211729 2020-05-11 10:05:45 -0700 Introduce WTF::Config and put Signal.cpp's init-once globals in it. 2020-06-09 15:54:06 -0700 1 1 1 Unclassified WebKit Web Template Framework WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=211773 https://bugs.webkit.org/show_bug.cgi?id=212999 InRadar P2 Normal --- 1 mark.lam mark.lam annulen benjamin cdumez cmarcelo darin dpino ews-watchlist gyuyoung.kim keith_miller msaboff ryuan.choi saam sergio tzagallo webkit-bug-importer ysuzuki oldest_to_newest 1651299 0 mark.lam 2020-05-11 10:05:45 -0700 <rdar://problem/62938878> 1651326 1 399028 mark.lam 2020-05-11 11:00:13 -0700 Created attachment 399028 proposed patch. Let's try this on the EWS. 1651330 2 399031 mark.lam 2020-05-11 11:08:35 -0700 Created attachment 399031 proposed patch. 1651377 3 399031 mark.lam 2020-05-11 12:21:36 -0700 Comment on attachment 399031 proposed patch. Ready for review. 1651392 4 399031 darin 2020-05-11 13:00:56 -0700 Comment on attachment 399031 proposed patch. View in context: https://bugs.webkit.org/attachment.cgi?id=399031&action=review > Source/WTF/ChangeLog:3 > + Introduce WTF::Config and put Signal.cpp's init-once globals in it. WebKit coding style says we use words, not abbreviations. Why "Config"? 1651396 5 399031 mark.lam 2020-05-11 13:08:48 -0700 Comment on attachment 399031 proposed patch. View in context: https://bugs.webkit.org/attachment.cgi?id=399031&action=review >> Source/WTF/ChangeLog:3 >> + Introduce WTF::Config and put Signal.cpp's init-once globals in it. > > WebKit coding style says we use words, not abbreviations. Why "Config"? Config is commonly used all over our code and is well recognized to mean configuration e.g. config.h is not named configuration.h. The reason I use Config is because it contains all the effectively "constant" global values that configures the behavior of our system. The are initialized and then expected to remain unchanged by our code (hence, effectively "constant"). The current instances of these Configs are g_gigacageConfig, g_wtfConfig, and g_jscConfig. I'm open to a better name if you have one that is concise and short. 1651403 6 399031 darin 2020-05-11 13:20:17 -0700 Comment on attachment 399031 proposed patch. View in context: https://bugs.webkit.org/attachment.cgi?id=399031&action=review >>> Source/WTF/ChangeLog:3 >>> + Introduce WTF::Config and put Signal.cpp's init-once globals in it. >> >> WebKit coding style says we use words, not abbreviations. Why "Config"? > > Config is commonly used all over our code and is well recognized to mean configuration e.g. config.h is not named configuration.h. The reason I use Config is because it contains all the effectively "constant" global values that configures the behavior of our system. The are initialized and then expected to remain unchanged by our code (hence, effectively "constant"). The current instances of these Configs are g_gigacageConfig, g_wtfConfig, and g_jscConfig. I'm open to a better name if you have one that is concise and short. Configuration is not long and it’s a normal word. The header "config.h" was not named by the WebKit project; we chose it for compatibility with autoconf. I don’t think the names g_gigacageConfig, g_wtfConfig, and g_jscConfig are consistent with WebKit coding style. 1651430 7 mark.lam 2020-05-11 13:58:06 -0700 (In reply to Darin Adler from comment #6) > Comment on attachment 399031 [details] > proposed patch. > > View in context: > https://bugs.webkit.org/attachment.cgi?id=399031&action=review > > >>> Source/WTF/ChangeLog:3 > >>> + Introduce WTF::Config and put Signal.cpp's init-once globals in it. > >> > >> WebKit coding style says we use words, not abbreviations. Why "Config"? > > > > Config is commonly used all over our code and is well recognized to mean configuration e.g. config.h is not named configuration.h. The reason I use Config is because it contains all the effectively "constant" global values that configures the behavior of our system. The are initialized and then expected to remain unchanged by our code (hence, effectively "constant"). The current instances of these Configs are g_gigacageConfig, g_wtfConfig, and g_jscConfig. I'm open to a better name if you have one that is concise and short. > > Configuration is not long and it’s a normal word. > > The header "config.h" was not named by the WebKit project; we chose it for > compatibility with autoconf. > > I don’t think the names g_gigacageConfig, g_wtfConfig, and g_jscConfig are > consistent with WebKit coding style. 1. I think of Config as a term of art. It's so commonly used and understood in software. We don't special out VirtualMachine instead of VM, DocumentObjectModel instead of DOM, etc. 2. I did not quote 3 examples to convince you of the precedence, merely to point out that it would be longer to type things like this: g_gigacageConfiguration.ensureGigacageHasBeenCalled g_gigacageConfiguration.shouldBeEnabledHasBeenCalled g_jscConfiguration.startOfFixedWritableMemoryPool It adds more typing and reading with 0 benefit in code comprehension. If anything, it slightly adds a bit of mental friction to read code because one would have to process more text. 3. Precedence. % cd Source % grep -rn Config * | grep -v Configuration | grep -v Configurable | grep -v ChangeLog | grep -v props | grep -vi make | grep -vi xcode | grep -v '.pyc' | grep -v ThirdParty | grep -v 'Scripts/' | wc 1024 5432 119346 Minus my uses (approximately): % grep -rn Config * | grep -v Configuration | grep -v Configurable | grep -v ChangeLog | grep -v props | grep -vi make | grep -vi xcode | grep -v '.pyc' | grep -v ThirdParty | grep -v 'Scripts/' | grep -v g_wtfConfig | grep -v g_gigacageConfig | grep -v g_jscConfig | grep -v WTF::Config | grep -v JSC::Config | grep -v Gigacage::Config | wc 891 4827 104559 But if you strongly object to my use of it, I'll change mine to Configuration. 1651432 8 mark.lam 2020-05-11 13:59:07 -0700 (In reply to Mark Lam from comment #7) > We don't special out VirtualMachine instead of VM, DocumentObjectModel > instead of DOM, etc. typo: /special/spell out/ 1651436 9 darin 2020-05-11 14:01:09 -0700 (In reply to Mark Lam from comment #7) > I think of Config as a term of art. Yes, and I also think most of the programming world heavily uses abbreviations. Our approach of using words is atypical. > But if you strongly object to my use of it, I'll change mine to > Configuration. I do. But since I am not the sole decider here please don’t change it based only on my opinion. 1651501 10 399031 keith_miller 2020-05-11 16:03:27 -0700 Comment on attachment 399031 proposed patch. View in context: https://bugs.webkit.org/attachment.cgi?id=399031&action=review r=me with comment. >>>>> Source/WTF/ChangeLog:3 >>>>> + Introduce WTF::Config and put Signal.cpp's init-once globals in it. >>>> >>>> WebKit coding style says we use words, not abbreviations. Why "Config"? >>> >>> Config is commonly used all over our code and is well recognized to mean configuration e.g. config.h is not named configuration.h. The reason I use Config is because it contains all the effectively "constant" global values that configures the behavior of our system. The are initialized and then expected to remain unchanged by our code (hence, effectively "constant"). The current instances of these Configs are g_gigacageConfig, g_wtfConfig, and g_jscConfig. I'm open to a better name if you have one that is concise and short. >> >> Configuration is not long and it’s a normal word. >> >> The header "config.h" was not named by the WebKit project; we chose it for compatibility with autoconf. >> >> I don’t think the names g_gigacageConfig, g_wtfConfig, and g_jscConfig are consistent with WebKit coding style. > > 1. I think of Config as a term of art. It's so commonly used and understood in software. > We don't special out VirtualMachine instead of VM, DocumentObjectModel instead of DOM, etc. > > 2. I did not quote 3 examples to convince you of the precedence, merely to point out that it would be longer to type things like this: > > g_gigacageConfiguration.ensureGigacageHasBeenCalled > g_gigacageConfiguration.shouldBeEnabledHasBeenCalled > g_jscConfiguration.startOfFixedWritableMemoryPool > > It adds more typing and reading with 0 benefit in code comprehension. If anything, it slightly adds a bit of mental friction to read code because one would have to process more text. > > 3. Precedence. > > % cd Source > % grep -rn Config * | grep -v Configuration | grep -v Configurable | grep -v ChangeLog | grep -v props | grep -vi make | grep -vi xcode | grep -v '.pyc' | grep -v ThirdParty | grep -v 'Scripts/' | wc > 1024 5432 119346 > > Minus my uses (approximately): > % grep -rn Config * | grep -v Configuration | grep -v Configurable | grep -v ChangeLog | grep -v props | grep -vi make | grep -vi xcode | grep -v '.pyc' | grep -v ThirdParty | grep -v 'Scripts/' | grep -v g_wtfConfig | grep -v g_gigacageConfig | grep -v g_jscConfig | grep -v WTF::Config | grep -v JSC::Config | grep -v Gigacage::Config | wc > 891 4827 104559 > > But if you strongly object to my use of it, I'll change mine to Configuration. For what it's worth, Config is pretty widely used but it Configuration is more common. I don't really care either way though. $ ag -i "configuration" Source --ignore Source/ThirdParty --ignore "*ChangeLog*" --stats-only 7861 matches 604 files contained matches The [^xc] is to skip xcconfig files. If you count them then I guess config is more common. $ ag -i "[^xc]config[^u|^\.]" Source --ignore Source/ThirdParty --ignore "*ChangeLog*" --stats-only 1900 matches 363 files contained matches > Source/WTF/wtf/threads/Signals.cpp:326 > - dataLogLn("We somehow got called for an unknown signal ", sig, ", halp."); > + dataLogLn("We somehow got called for an unknown signal ", sig, ", help."); This spelling was intentional :P > Source/WTF/wtf/threads/Signals.h:93 > + SignalHandlerMemory* alloc(Signal); This is bizarre. I think this should be: add(Signal, SignalHandler&&); 1651515 11 399031 saam 2020-05-11 16:27:59 -0700 Comment on attachment 399031 proposed patch. View in context: https://bugs.webkit.org/attachment.cgi?id=399031&action=review r=me too with some comments > Source/JavaScriptCore/ChangeLog:9 > + 1. Initialize VMTraps' signals early not that we'll be freezing signals at the end not => now > Source/JavaScriptCore/runtime/InitializeThreading.cpp:108 > + WTF::storeLoadFence(); why? > Source/WTF/ChangeLog:10 > + we'll be initializing them on boot up, but should not have any reason to boot up => first VM initialization should not => do not (alternatively, just say for immutable constants) > Source/WTF/ChangeLog:15 > + operations that should only be called at boot time will not be called once the same as above, don't say "boot time" > Source/WTF/ChangeLog:19 > + statics) no moved are ones that cannot be moved because they require a no => not > Source/WTF/ChangeLog:20 > + non-trivial default constructor (once_flag), or are needs to be modifiable are needs => need > Source/WTF/ChangeLog:40 > + SignalHandlers::alloc() uses a mutex. In practice, this mutex will never be > + contended on because all signal handlers are now installed at boot time before but can you guarantee we're not holding the mutex when we're catching a signal? Otherwise, dead lock > Source/WTF/ChangeLog:44 > + deployments, this does not matter because signal handler installations will in deployments => in production builds? > Source/WTF/wtf/WTFConfig.cpp:43 > +void Config::disableFreezingForTesting() I'd get rid of this capability. > Source/WTF/wtf/WTFConfig.cpp:64 > + enum { > + AllowPermissionChangesAfterThis = false, > + DisallowPermissionChangesAfterThis = true > + }; seems like this could just be done with a local variable since you never use AllowPermissionChangesAfterThis > Source/WTF/wtf/WTFConfig.h:39 > +struct Config { To jump in on the naming debate from a different angle: I'd just pick something more specific than "Config"/"Configuration". This isn't really a Config, it's only one very specific thing. So maybe we can name it more specifically. > Source/WTF/wtf/WTFConfig.h:47 > + static void configureForTesting() why even have this? It's not called AFAICT > Source/WTF/wtf/WTFConfig.h:66 > + }; nit: static assert this union field size is ConfigSizeToProtect? > Source/WTF/wtf/WTFConfig.h:75 > + storeLoadFence(); why? compilerFence? > Source/WTF/wtf/WTFConfig.h:76 > + RELEASE_ASSERT(!g_wtfConfig.isPermanentlyFrozen); also assert in constructor? > Source/WTF/wtf/threads/Signals.cpp:67 > +SignalHandlerMemory* SignalHandlers::alloc(Signal signal) > +{ > + static Lock lock; > + auto locker = holdLock(lock); > + > + size_t signalIndex = static_cast<size_t>(signal); > + RELEASE_ASSERT(numberOfHandlers[signalIndex] < maxNumberOfHandlers); > + size_t nextFree = numberOfHandlers[signalIndex]++; > + return &handlers[signalIndex][nextFree]; > +} I think the safest thing to do here is just to pass in the handler too, and then: call constructor w/ the new memory storeStoreFence bump numberOfHandlers count The main reasoning here is just to make sure the code below in forEachHandler doesn't blow up if it's called at an unexpected time in startup code. Also, should we assertNotFrozen scope here? > Source/WTF/wtf/threads/Signals.cpp:70 > +inline void SignalHandlers::forEachHandler(Signal signal, const Func& func) const I wonder if we should just early return if we haven't frozen the config? That proves we got here before we expected to > Source/WTF/wtf/threads/Signals.cpp:73 > + size_t handlerIndex = numberOfHandlers[signalIndex]; to be super duper correct, with my proposed threading policy, you need a loadLoadFence or a dependency after this. You don't want the compiler/CPU loading handler before this. > Source/WTF/wtf/threads/Signals.cpp:76 > + const SignalHandler& handler = *reinterpret_cast<SignalHandler*>(memory); nit: bitwise_cast nit: this line and above line can easily be joined into the same line of code > Source/WTF/wtf/threads/Signals.cpp:213 > void handleSignalsWithMach() assert not frozen scope? > Source/WTF/wtf/threads/Signals.cpp:326 > + dataLogLn("We somehow got called for an unknown signal ", sig, ", help."); I think Keith wrote the previous way on purpose ;-) > Source/WTF/wtf/threads/Signals.cpp:379 > + // Ensure that we've initialized this before freeze the Config. before freeze => before we freeze You should say why. Currently, code is saying the same thing as a comment > Source/WTF/wtf/threads/Signals.h:113 > +static_assert(SignalHandlers::numberOfSignals < std::numeric_limits<uint8_t>::max()); this should go in the struct AFAICT 1651535 12 mark.lam 2020-05-11 17:27:30 -0700 Thanks for the reviews. (In reply to Keith Miller from comment #10) > For what it's worth, Config is pretty widely used but it Configuration is > more common. I don't really care either way though. I'm just going to stick with Config for now. We can rename these (and others) to Configuration in a separate refactoring patch if desired. I still think Config is a better choice here. > > Source/WTF/wtf/threads/Signals.cpp:326 > > - dataLogLn("We somehow got called for an unknown signal ", sig, ", halp."); > This spelling was intentional :P I'm going to un-cute it. > > Source/WTF/wtf/threads/Signals.h:93 > > + SignalHandlerMemory* alloc(Signal); > > This is bizarre. I think this should be: add(Signal, SignalHandler&&); Saam talked to me about the same thing. Fixed. (In reply to Saam Barati from comment #11) > > Source/JavaScriptCore/ChangeLog:9 > > + 1. Initialize VMTraps' signals early not that we'll be freezing signals at the end > > not => now Fixed. > > Source/JavaScriptCore/runtime/InitializeThreading.cpp:108 > > + WTF::storeLoadFence(); > > why? Fixed by replacing with a compilerFence(). > > Source/WTF/ChangeLog:10 > > + we'll be initializing them on boot up, but should not have any reason to > > boot up => first VM initialization Fixed. > should not => do not > (alternatively, just say for immutable constants) Fixed. > > Source/WTF/ChangeLog:15 > > + operations that should only be called at boot time will not be called once the > > same as above, don't say "boot time" Fixed. I replaced it with initialization time. > > Source/WTF/ChangeLog:19 > > + statics) no moved are ones that cannot be moved because they require a > > no => not Fixed. > > Source/WTF/ChangeLog:20 > > + non-trivial default constructor (once_flag), or are needs to be modifiable > > are needs => need Fixed. > > Source/WTF/ChangeLog:40 > > + SignalHandlers::alloc() uses a mutex. In practice, this mutex will never be > > + contended on because all signal handlers are now installed at boot time before > > but can you guarantee we're not holding the mutex when we're catching a > signal? Otherwise, dead lock The signal catcher does not acquire the lock, and does not call alloc(). It only relies on the numberOfHandles value for that type of Signal. Per our offline discussion, I'll change the SignalHandlers::alloc() function into an add() function, and just WTFMove the handler into it. I'll also defer incrementing numberOfHandlers[signalIndex] until after the handler has been full initialized. This will allow the signal catcher side (via forEachHandler()) to be able to continue to iterate the added handlers without acquiring a lock. > > Source/WTF/ChangeLog:44 > > + deployments, this does not matter because signal handler installations will > > in deployments => in production builds? This is not quite correct. The issue isn't about what's built in. It's about what configuration is deployed in production. I'll replace "deployment" with "production configurations". > > Source/WTF/wtf/WTFConfig.cpp:43 > > +void Config::disableFreezingForTesting() > > I'd get rid of this capability. Since currently, freezing is tied to JSC's Config freezing, which, in turn, would be circumvented if g_jscConfig.disabledFreezingForTesting is set. So, this WTF specific flag is redundant. I'll remove it until we see a need to have one of its own. > > Source/WTF/wtf/WTFConfig.cpp:64 > > + enum { > > + AllowPermissionChangesAfterThis = false, > > + DisallowPermissionChangesAfterThis = true > > + }; > > seems like this could just be done with a local variable since you never use > AllowPermissionChangesAfterThis I'm going to keep this because I think it documents the values better. Note that "Allow" is false, and "Disallow" is true. Using a boolean local can get confusing. > > Source/WTF/wtf/WTFConfig.h:39 > > +struct Config { > > To jump in on the naming debate from a different angle: I'd just pick > something more specific than "Config"/"Configuration". This isn't really a > Config, it's only one very specific thing. So maybe we can name it more > specifically. Signals.cpp will not be the only client of this mechanism (more to come). So, I think Config / Configuration (or something that describes "collection of stuff that configures how the system behaves") is appropriate. Alternatively, if there's a concise name to mean "place to hold stuff we want to freeze", I think that may be appropriate too. For now, I'll keep it as is. We can play the renaming game later. > > Source/WTF/wtf/WTFConfig.h:47 > > + static void configureForTesting() > > why even have this? It's not called AFAICT Fixed: removed for same reason as disableFreezingForTesting() above. > > Source/WTF/wtf/WTFConfig.h:66 > > + }; > > nit: static assert this union field size is ConfigSizeToProtect? It's not the union size that matters. It's the size of the Config struct itself. And I already static_assert its size just below this. > > Source/WTF/wtf/WTFConfig.h:75 > > + storeLoadFence(); > > why? > > compilerFence? Yes, this should be a compilerFence. Fixed. > > Source/WTF/wtf/WTFConfig.h:76 > > + RELEASE_ASSERT(!g_wtfConfig.isPermanentlyFrozen); > > also assert in constructor? Strictly speaking, asserting in the destructor is all that is needed, and the required case. The only value in asserting in the constructor is that crash logs will be more informative. Otherwise, we may crash while trying to execute any of the other code in the client function before we get to the destructor. Since, this assertion scope is not used in any hot critical paths, I'll add assertion in the constructor as well. > > Source/WTF/wtf/threads/Signals.cpp:67 > > +SignalHandlerMemory* SignalHandlers::alloc(Signal signal) > > +{ > > + static Lock lock; > > + auto locker = holdLock(lock); > > + > > + size_t signalIndex = static_cast<size_t>(signal); > > + RELEASE_ASSERT(numberOfHandlers[signalIndex] < maxNumberOfHandlers); > > + size_t nextFree = numberOfHandlers[signalIndex]++; > > + return &handlers[signalIndex][nextFree]; > > +} > > I think the safest thing to do here is just to pass in the handler too, and > then: > call constructor w/ the new memory > storeStoreFence > bump numberOfHandlers count Fixed. > The main reasoning here is just to make sure the code below in > forEachHandler doesn't blow up if it's called at an unexpected time in > startup code. > > Also, should we assertNotFrozen scope here? My reason for not including in the first place is because, if already frozen, the WTFMove to the handler, and the bumping of the numberOfHandlers count will already trigger a crash. I'll add it because this is not a hot critical path and a crash on that assert would point more clearly to what the bug is. > > Source/WTF/wtf/threads/Signals.cpp:70 > > +inline void SignalHandlers::forEachHandler(Signal signal, const Func& func) const > > I wonder if we should just early return if we haven't frozen the config? > That proves we got here before we expected to I can do that if I hadn't gotten rid of the disabledFreezingForTesting flag. On debug/test configurations, it should be fine to proceed without the Config being frozen. The check would be: if (!g_wtfConfig.isPermanentlyFrozen && g_wtfConfig.disabledFreezingForTesting) return; I think it's fine to leave this as is. If the client-side handler has been installed, it should be able to do its work. Otherwise, the client-side handler should be doing its own check for a "not yet ready" condition. > > Source/WTF/wtf/threads/Signals.cpp:73 > > + size_t handlerIndex = numberOfHandlers[signalIndex]; > > to be super duper correct, with my proposed threading policy, you need a > loadLoadFence or a dependency after this. You don't want the compiler/CPU > loading handler before this. Thanks. I added a loadLoadFence(). > > Source/WTF/wtf/threads/Signals.cpp:76 > > + const SignalHandler& handler = *reinterpret_cast<SignalHandler*>(memory); > > nit: bitwise_cast It's a pointer to pointer conversion. I think it's overkill, but sure, I'll use bitwise_cast. > nit: this line and above line can easily be joined into the same line of code > > > Source/WTF/wtf/threads/Signals.cpp:213 > > void handleSignalsWithMach() > > assert not frozen scope? > > > Source/WTF/wtf/threads/Signals.cpp:326 > > + dataLogLn("We somehow got called for an unknown signal ", sig, ", help."); > > I think Keith wrote the previous way on purpose ;-) I'm still going to un-cute it. > > Source/WTF/wtf/threads/Signals.cpp:379 > > + // Ensure that we've initialized this before freeze the Config. > > before freeze => before we freeze > > You should say why. Currently, code is saying the same thing as a comment I replaced this with a comment explaining why adapted from the ChangeLog. > > Source/WTF/wtf/threads/Signals.h:113 > > +static_assert(SignalHandlers::numberOfSignals < std::numeric_limits<uint8_t>::max()); > > this should go in the struct AFAICT Fixed. 1651541 13 399074 mark.lam 2020-05-11 17:34:27 -0700 Created attachment 399074 patch for landing. 1651575 14 mark.lam 2020-05-11 19:11:14 -0700 Landed in r261538: <http://trac.webkit.org/r261538>. 1651647 15 dpino 2020-05-11 23:57:45 -0700 GTK API tests are failing after this patch https://bugs.webkit.org/show_bug.cgi?id=211773 399028 2020-05-11 11:00:13 -0700 2020-05-11 11:08:35 -0700 proposed patch. bug-211729.patch text/plain 33577 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjYxNDgxKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMzIEBA CisyMDIwLTA1LTExICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBJ bnRyb2R1Y2UgV1RGOjpDb25maWcgYW5kIHB1dCBTaWduYWwuY3BwJ3MgaW5pdC1vbmNlIGdsb2Jh bHMgaW4gaXQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMTE3MjkKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzYyOTM4ODc4PgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIDEuIEluaXRpYWxpemUgVk1UcmFw cycgc2lnbmFscyBlYXJseSBub3QgdGhhdCB3ZSdsbCBiZSBmcmVlemluZyBzaWduYWxzIGF0IHRo ZSBlbmQKKyAgICAgICAgICAgb2YgdGhlIGZpcnN0IFZNIGluaXRpYWxpemF0aW9uLgorCisgICAg ICAgIDIuIE1vdmUgdGhlICFpbml0aWFsaXplVGhyZWFkaW5nSGFzQmVlbkNhbGxlZCBSRUxFQVNF X0FTU0VSVCBpbiBpbml0aWFsaXplVGhyZWFkaW5nKCkKKyAgICAgICAgICAgdG8gdGhlIGJvdHRv bSBvZiB0aGUgZnVuY3Rpb24uICBUaGlzIHdheSwgd2UnbGwgYWxzbyBjYXRjaCBidWdzIHdoaWNo IG1heSBjYXVzZQorICAgICAgICAgICB1cyB0byBqdW1wIGludG8gdGhlIG1pZGRsZSBvZiB0aGUg ZnVuY3Rpb24uCisKKyAgICAgICAgICAgQWRkZWQgYSBsb2FkU3RvcmVGZW5jZSB0aGVyZSB0byBl bnN1cmUgdGhhdCB0aGUgUkVMRUFTRV9BU1NFUlQgaXMgb25seSBleGVjdXRlZAorICAgICAgICAg ICBhZnRlciBhbGwgaW5pdGlhbGl6YXRpb24gaXMgZG9uZS4gIFRoaXMgZ3VhcmFudGVlcyB0aGF0 IGl0IHdpbGwgb25seSBiZSBleGVjdXRlZAorICAgICAgICAgICBhdCB0aGUgZW5kLgorCisgICAg ICAgIDMuIENhbGwgV1RGOjpDb25maWc6OnBlcm1hbmVudGx5RnJlZXplKCkgZnJvbSBKU0M6OkNv bmZpZzo6cGVybWFuZW50bHlGcmVlemUoKQorICAgICAgICAgICBmb3Igb2J2aW91cyByZWFzb25z OiBmcmVlemluZyBvbmUgc2hvdWxkIGZyZWV6ZSB0aGUgb3RoZXIuCisKKyAgICAgICAgKiBydW50 aW1lL0luaXRpYWxpemVUaHJlYWRpbmcuY3BwOgorICAgICAgICAoSlNDOjppbml0aWFsaXplVGhy ZWFkaW5nKToKKyAgICAgICAgKiBydW50aW1lL0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6 OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUpOgorICAgICAgICAqIHJ1bnRpbWUvVk1UcmFwcy5j cHA6CisgICAgICAgIChKU0M6OlZNVHJhcHM6OmluaXRpYWxpemVTaWduYWxzKToKKyAgICAgICAg KiBydW50aW1lL1ZNVHJhcHMuaDoKKwogMjAyMC0wNS0xMCAgUm9zcyBLaXJzbGluZyAgPHJvc3Mu a2lyc2xpbmdAc29ueS5jb20+CiAKICAgICAgICAgW2NsYW5nLXRpZHldIFJ1biBtb2Rlcm5pemUt dXNlLW51bGxwdHIgb3ZlciBKU0MKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0luaXRpYWxpemVUaHJlYWRpbmcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0luaXRpYWxpemVUaHJlYWRpbmcuY3BwCShyZXZpc2lvbiAyNjE0NjkpCisr KyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Jbml0aWFsaXplVGhyZWFkaW5nLmNwcAko d29ya2luZyBjb3B5KQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDgt MjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIw MDgtMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKQEAgLTQ0LDYgKzQ0LDcgQEAKICNpbmNsdWRlICJTaWdpbGxDcmFzaEFu YWx5emVyLmgiCiAjaW5jbHVkZSAiU3RydWN0dXJlSURUYWJsZS5oIgogI2luY2x1ZGUgIlN1cGVy U2FtcGxlci5oIgorI2luY2x1ZGUgIlZNVHJhcHMuaCIKICNpbmNsdWRlICJXYXNtQ2FsbGVlUmVn aXN0cnkuaCIKICNpbmNsdWRlICJXYXNtQ2FwYWJpbGl0aWVzLmgiCiAjaW5jbHVkZSAiV2FzbVRo dW5rcy5oIgpAQCAtNjQsOSArNjUsNiBAQCB2b2lkIGluaXRpYWxpemVUaHJlYWRpbmcoKQogICAg IHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBpbml0aWFsaXplVGhyZWFkaW5nT25jZUZsYWc7CiAKICAg ICBzdGQ6OmNhbGxfb25jZShpbml0aWFsaXplVGhyZWFkaW5nT25jZUZsYWcsIFtdewotICAgICAg ICBSRUxFQVNFX0FTU0VSVCghZ19qc2NDb25maWcuaW5pdGlhbGl6ZVRocmVhZGluZ0hhc0JlZW5D YWxsZWQpOwotICAgICAgICBnX2pzY0NvbmZpZy5pbml0aWFsaXplVGhyZWFkaW5nSGFzQmVlbkNh bGxlZCA9IHRydWU7Ci0KICAgICAgICAgV1RGOjppbml0aWFsaXplVGhyZWFkaW5nKCk7CiAgICAg ICAgIE9wdGlvbnM6OmluaXRpYWxpemUoKTsKIApAQCAtMTA1LDYgKzEwMywxMSBAQCB2b2lkIGlu aXRpYWxpemVUaHJlYWRpbmcoKQogICAgICAgICAvLyBKU0xvY2s6OmxvY2soKSBjYW4gY2FsbCBy ZWdpc3RlclRocmVhZEZvck1hY2hFeGNlcHRpb25IYW5kbGluZygpIHdoaWNoIGNyYXNoZXMgaWYg dGhpcyBoYXMgbm90IGJlZW4gY2FsbGVkIGZpcnN0LgogICAgICAgICBXVEY6OnN0YXJ0TWFjaEV4 Y2VwdGlvbkhhbmRsZXJUaHJlYWQoKTsKICNlbmRpZgorICAgICAgICBWTVRyYXBzOjppbml0aWFs aXplU2lnbmFscygpOworCisgICAgICAgIFdURjo6c3RvcmVMb2FkRmVuY2UoKTsKKyAgICAgICAg UkVMRUFTRV9BU1NFUlQoIWdfanNjQ29uZmlnLmluaXRpYWxpemVUaHJlYWRpbmdIYXNCZWVuQ2Fs bGVkKTsKKyAgICAgICAgZ19qc2NDb25maWcuaW5pdGlhbGl6ZVRocmVhZGluZ0hhc0JlZW5DYWxs ZWQgPSB0cnVlOwogICAgIH0pOwogfQogCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9KU0NDb25maWcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9y dW50aW1lL0pTQ0NvbmZpZy5jcHAJKHJldmlzaW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI5LDYgKzI5 LDcgQEAKICNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9SZXNvdXJjZVVzYWdl Lmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorI2luY2x1ZGUgPHd0Zi9XVEZDb25m aWcuaD4KIAogI2lmIE9TKERBUldJTikKICNpbmNsdWRlIDxtYWNoL21hY2guaD4KQEAgLTU0LDYg KzU1LDggQEAgdm9pZCBDb25maWc6OmVuYWJsZVJlc3RyaWN0ZWRPcHRpb25zKCkKICAgICAKIHZv aWQgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpCiB7CisgICAgV1RGOjpDb25maWc6OnBlcm1h bmVudGx5RnJlZXplKCk7CisKICAgICBzdGF0aWMgTG9jayBjb25maWdMb2NrOwogICAgIGF1dG8g bG9ja2VyID0gaG9sZExvY2soY29uZmlnTG9jayk7CiAKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL1ZNVHJhcHMuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL1ZNVHJhcHMuY3BwCShyZXZpc2lvbiAyNjE0NjkpCisrKyBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9WTVRyYXBzLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMSw1ICsx LDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTE5OCw2 ICsxOTgsOSBAQCBwdWJsaWM6CiAgICAgU2lnbmFsU2VuZGVyKGNvbnN0IEFic3RyYWN0TG9ja2Vy JiBsb2NrZXIsIFZNJiB2bSkKICAgICAgICAgOiBCYXNlKGxvY2tlciwgdm0udHJhcHMoKS5tX2xv Y2ssIHZtLnRyYXBzKCkubV9jb25kaXRpb24uY29weVJlZigpKQogICAgICAgICAsIG1fdm0odm0p CisgICAgeyB9CisKKyAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplU2lnbmFscygpCiAgICAgewog ICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZTsKICAgICAgICAgc3RkOjpjYWxsX29u Y2Uob25jZSwgW10gewpAQCAtMjk0LDYgKzI5NywxNCBAQCBwcml2YXRlOgogCiAjZW5kaWYgLy8g RU5BQkxFKFNJR05BTF9CQVNFRF9WTV9UUkFQUykKIAordm9pZCBWTVRyYXBzOjppbml0aWFsaXpl U2lnbmFscygpCit7CisjaWYgRU5BQkxFKFNJR05BTF9CQVNFRF9WTV9UUkFQUykKKyAgICBpZiAo IU9wdGlvbnM6OnVzZVBvbGxpbmdUcmFwcygpKQorICAgICAgICBTaWduYWxTZW5kZXI6OmluaXRp YWxpemVTaWduYWxzKCk7CisjZW5kaWYKK30KKwogdm9pZCBWTVRyYXBzOjp3aWxsRGVzdHJveVZN KCkKIHsKICAgICBtX2lzU2h1dHRpbmdEb3duID0gdHJ1ZTsKSW5kZXg6IFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9WTVRyYXBzLmgJKHJldmlzaW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuaAkod29ya2luZyBjb3B5KQpAQCAtMSw1ICsxLDUg QEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTk4LDYgKzk4 LDggQEAgcHVibGljOgogICAgIH5WTVRyYXBzKCk7CiAgICAgVk1UcmFwcygpOwogCisgICAgc3Rh dGljIHZvaWQgaW5pdGlhbGl6ZVNpZ25hbHMoKTsKKwogICAgIHZvaWQgd2lsbERlc3Ryb3lWTSgp OwogCiAgICAgYm9vbCBuZWVkVHJhcEhhbmRsaW5nKCkgeyByZXR1cm4gbV9uZWVkVHJhcEhhbmRs aW5nOyB9CkluZGV4OiBTb3VyY2UvV1RGL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V1RGL0NoYW5nZUxvZwkocmV2aXNpb24gMjYxNDY5KQorKysgU291cmNlL1dURi9DaGFuZ2VMb2cJ KHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSw3NCBAQAorMjAyMC0wNS0xMSAgTWFyayBMYW0gIDxt YXJrLmxhbUBhcHBsZS5jb20+CisKKyAgICAgICAgSW50cm9kdWNlIFdURjo6Q29uZmlnIGFuZCBw dXQgU2lnbmFsLmNwcCdzIGluaXQtb25jZSBnbG9iYWxzIGluIGl0LgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjExNzI5CisgICAgICAgIDxyZGFyOi8v cHJvYmxlbS82MjkzODg3OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAxLiBBZGRlZCBXVEY6OkNvbmZpZyBmb3Igc3RvcmluZyBnbG9iYWxzIHRoYXQg ZWZmZWN0aXZlbHkgc2VydmUgYXMgY29uc3RhbnRzIGkuZQorICAgICAgICAgICB3ZSdsbCBiZSBp bml0aWFsaXppbmcgdGhlbSBvbiBib290IHVwLCBidXQgc2hvdWxkIG5vdCBoYXZlIGFueSByZWFz b24gdG8KKyAgICAgICAgICAgbW9kaWZ5IHRoZW0gbGF0ZXIuICBUaGUgV1RGOjpDb25maWcgd2ls bCBiZSBmcm96ZW4gKGFsb25nIHdpdGggSlNDOjpDb25maWcpCisgICAgICAgICAgIGF0IHRoZSBl bmQgb2YgaW5zdGFudGlhdGluZyB0aGUgZmlyc3QgVk0gaW5zdGFuY2UuCisKKyAgICAgICAgMi4g QWRkZWQgYSBDb25maWc6OkFzc2VydE5vdEZyb3plblNjb3BlIFJBSUkgb2JqZWN0IHRvIGVuc3Vy ZSB0aGF0IGluaXRpYWxpemF0aW9uCisgICAgICAgICAgIG9wZXJhdGlvbnMgdGhhdCBzaG91bGQg b25seSBiZSBjYWxsZWQgYXQgYm9vdCB0aW1lIHdpbGwgbm90IGJlIGNhbGxlZCBvbmNlIHRoZQor ICAgICAgICAgICBDb25maWcgaGFzIGJlZW4gZnJvemVuLgorCisgICAgICAgIDMuIE1vdmVkIG1v c3Qgb2YgU2lnbmFsLmNwcCdzIGdsb2JhbHMgaW50byBXVEY6OkNvbmZpZy4gIFRoZSBvbmx5IGds b2JhbHMgKG9yCisgICAgICAgICAgIHN0YXRpY3MpIG5vIG1vdmVkIGFyZSBvbmVzIHRoYXQgY2Fu bm90IGJlIG1vdmVkIGJlY2F1c2UgdGhleSByZXF1aXJlIGEKKyAgICAgICAgICAgbm9uLXRyaXZp YWwgZGVmYXVsdCBjb25zdHJ1Y3RvciAob25jZV9mbGFnKSwgb3IgYXJlIG5lZWRzIHRvIGJlIG1v ZGlmaWFibGUKKyAgICAgICAgICAgYXQgcnVudGltZSAoZS5nLiBMb2NrKS4KKworICAgICAgICAg ICBJbnN0ZWFkIG9mIGZyZWV6aW5nIHRoZSBvbmNlX2ZsYWcsIHdlIHNhbml0eSBjaGVjayB0aGUg Y2FsbF9vbmNlIGJsb2NrIHdpdGgKKyAgICAgICAgICAgdGhlIENvbmZpZzo6QXNzZXJ0Tm90RnJv emVuU2NvcGUuCisKKyAgICAgICAgNC4gU2lnbmFsSGFuZGxlciByZWNvcmRzIGFyZSBub3cgYWxs b2NhdGVkIGZyb20gYXJyYXlzIG9mIFNpZ25hbEhhbmRsZXJNZW1vcnkgaW4KKyAgICAgICAgICAg dGhlIFdURjo6Q29uZmlnLiAgVGhlIG51bWJlciBvZiBzaWduYWwgaGFuZGxlcnMgd2Ugd2lsbCBl dmVyIGluc3RhbGwgaXMgYWx3YXlzCisgICAgICAgICAgIGZpbml0ZS4gIEhlbmNlLCB0aGVyZSdz IG5vIHJlYXNvbiB0byB1c2UgYSBkeW5hbWljIGRhdGEgc3RydWN0dXJlIGxpa2UgdGhlCisgICAg ICAgICAgIExvY2tsZXNzQmFnIHRvIGhvbGQgaXQuCisKKyAgICAgICAgICAgV2UgaW50cm9kdWNl IGEgU2lnbmFsSGFuZGxlcnMgc3RydWN0IHRvIG1hbmFnZSB0aGVzZSBhcnJheXMgKGFuZCBhbGwg dGhlIG90aGVyCisgICAgICAgICAgIFNpZ25hbC5jcHAgZ2xvYmFscyB0aGF0IHdlIHdhbnQgdG8g bW92ZSB0byB0aGUgV1RGOjpDb25maWcpLiAgQW1vbmdzdCBvdGhlcgorICAgICAgICAgICB0aGlu Z3MsIFNpZ25hbEhhbmRsZXJzIHByb3ZpZGVzIHRoZSBhYnN0cmFjdGlvbnMgZm9yOgorCisgICAg ICAgICAgIGEuIGFsbG9jYXRpbmcgbWVtb3J5IGZvciB0aGUgU2lnbmFsSGFuZGxlciBpbnN0YW5j ZXMuICBTZWUgU2lnbmFsSGFuZGxlcnM6OmFsbG9jKCkuCisgICAgICAgICAgIGIuIGl0ZXJhdGlu ZyBTaWduYWxIYW5kbGVyIGluc3RhbmNlcy4gU2VlIFNpZ25hbEhhbmRsZXJzOjpmb3JFYWNoSGFu ZGxlcigpLgorCisgICAgICAgICAgIFRvIG1haW50YWluIHRoZSBzeW5jaHJvbml6YXRpb24gcHJv cGVydGllcyBvZiB0aGUgTG9ja2xlc3NCYWcsCisgICAgICAgICAgIFNpZ25hbEhhbmRsZXJzOjph bGxvYygpIHVzZXMgYSBtdXRleC4gIEluIHByYWN0aWNlLCB0aGlzIG11dGV4IHdpbGwgbmV2ZXIg YmUKKyAgICAgICAgICAgY29udGVuZGVkIG9uIGJlY2F1c2UgYWxsIHNpZ25hbCBoYW5kbGVycyBh cmUgbm93IGluc3RhbGxlZCBhdCBib290IHRpbWUgYmVmb3JlCisgICAgICAgICAgIGFueSBjb25j dXJyZW5jeSBjb21lcyBpbnRvIHBsYXkuCisKKyAgICAgICAgNS4gV2Ugbm93IGluaXRpYWxpemUg YWN0aXZlVGhyZWFkcygpIGVhZ2VybHkgdmlhIGluaXRpYWxpemVUaHJlYWRpbmcuICBJbgorICAg ICAgICAgICBkZXBsb3ltZW50cywgdGhpcyBkb2VzIG5vdCBtYXR0ZXIgYmVjYXVzZSBzaWduYWwg aGFuZGxlciBpbnN0YWxsYXRpb25zIHdpbGwKKyAgICAgICAgICAgYWx3YXlzIHRyaWdnZXIgaXRz IGluaXRpYWxpemF0aW9uLiAgSG93ZXZlciwgaW4gZGVidWdnaW5nIHVzZSBjYXNlcywgd2UgbWF5 CisgICAgICAgICAgIGVuZCB1cCBkaXNhYmxpbmcgdGhlIHVzZSBvZiBhbGwgc2lnbmFsIGhhbmRs ZXJzLiAgQXMgYSByZXN1bHQsIHdlIG5lZWQgdG8KKyAgICAgICAgICAgZG8gdGhpcyBlYWdlciBp bml0aWFsaXphdGlvbiB0byBlbnN1cmUgdGhhdCBpdCBpcyBkb25lIGJlZm9yZSB3ZSBmcmVlemUg dGhlCisgICAgICAgICAgIFdURjo6Q29uZmlnLgorCisgICAgICAgICogV1RGLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2o6CisgICAgICAgICogd3RmL0NNYWtlTGlzdHMudHh0OgorICAgICAgICAq IHd0Zi9UaHJlYWRpbmcuY3BwOgorICAgICAgICAoV1RGOjppbml0aWFsaXplVGhyZWFkaW5nKToK KyAgICAgICAgKiB3dGYvV1RGQ29uZmlnLmNwcDogQWRkZWQuCisgICAgICAgIChXVEY6OkNvbmZp Zzo6ZGlzYWJsZUZyZWV6aW5nRm9yVGVzdGluZyk6CisgICAgICAgIChXVEY6OkNvbmZpZzo6cGVy bWFuZW50bHlGcmVlemUpOgorICAgICAgICAqIHd0Zi9XVEZDb25maWcuaDogQWRkZWQuCisgICAg ICAgIChXVEY6OkNvbmZpZzo6Y29uZmlndXJlRm9yVGVzdGluZyk6CisgICAgICAgIChXVEY6OkNv bmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGU6On5Bc3NlcnROb3RGcm96ZW5TY29wZSk6CisgICAg ICAgICogd3RmL3RocmVhZHMvU2lnbmFscy5jcHA6CisgICAgICAgIChXVEY6OlNpZ25hbEhhbmRs ZXJzOjphbGxvYyk6CisgICAgICAgIChXVEY6OlNpZ25hbEhhbmRsZXJzOjpmb3JFYWNoSGFuZGxl ciBjb25zdCk6CisgICAgICAgIChXVEY6OnN0YXJ0TWFjaEV4Y2VwdGlvbkhhbmRsZXJUaHJlYWQp OgorICAgICAgICAoV1RGOjpoYW5kbGVTaWduYWxzV2l0aE1hY2gpOgorICAgICAgICAoV1RGOjpz ZXRFeGNlcHRpb25Qb3J0cyk6CisgICAgICAgIChXVEY6OmFjdGl2ZVRocmVhZHMpOgorICAgICAg ICAoV1RGOjppbnN0YWxsU2lnbmFsSGFuZGxlcik6CisgICAgICAgIChXVEY6OmpzY1NpZ25hbEhh bmRsZXIpOgorICAgICAgICAoV1RGOjpTaWduYWxIYW5kbGVyczo6aW5pdGlhbGl6ZSk6CisgICAg ICAgICogd3RmL3RocmVhZHMvU2lnbmFscy5oOgorCiAyMDIwLTA1LTEwICBEYXJpbiBBZGxlciAg PGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQgY29weSBjb25zdHJ1Y3RvciBhbmQgYXNz aWdubWVudCBvcGVyYXRvciB0byBSZWY8PgpJbmRleDogU291cmNlL1dURi9XVEYueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL1dURi54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAyNjE0NjkpCisrKyBTb3VyY2UvV1RGL1dURi54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC0xODIsNiArMTgyLDcgQEAK IAkJRTRBMEFEMzkxQTk2MjQ1NTAwNTM2REY2IC8qIFdvcmtRdWV1ZS5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNEEwQUQzNzFBOTYyNDU1MDA1MzZE RjYgLyogV29ya1F1ZXVlLmNwcCAqLzsgfTsKIAkJRTRBMEFEM0QxQTk2MjUzQzAwNTM2REY2IC8q IFdvcmtRdWV1ZUNvY29hLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEU0QTBBRDNDMUE5NjI1M0MwMDUzNkRGNiAvKiBXb3JrUXVldWVDb2NvYS5jcHAg Ki87IH07CiAJCUVCNjFFREM3MjQwOUNDQzEwMDFFRkUzNiAvKiBTeXN0ZW1UcmFjaW5nQ29jb2Eu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRUI2MUVE QzYyNDA5Q0NDMDAwMUVGRTM2IC8qIFN5c3RlbVRyYWNpbmdDb2NvYS5jcHAgKi87IH07CisJCUZF MDMyQUQyMjQ2M0U0M0IwMDEyRDdDNyAvKiBXVEZDb25maWcuY3BwIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkUwMzJBRDAyNDYzRTQzQjAwMTJEN0M3IC8q IFdURkNvbmZpZy5jcHAgKi87IH07CiAJCUZFMDVGQUZGMUZFNTAwNzUwMDA5MzIzMCAvKiBXVEZB c3NlcnRpb25zLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEZFMDVGQUZFMUZFNTAwNzUwMDA5MzIzMCAvKiBXVEZBc3NlcnRpb25zLmNwcCAqLzsgfTsK IAkJRkUxRTJDM0IyMjQwQzA2NjAwRjZCNzI5IC8qIFB0clRhZy5jcHAgaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRTFFMkMzOTIyNDBDMDU0MDBGNkI3Mjkg LyogUHRyVGFnLmNwcCAqLzsgfTsKIAkJRkUxRTJDNDIyMjQxODdDNjAwRjZCNzI5IC8qIFBsYXRm b3JtUmVnaXN0ZXJzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEZFMUUyQzQxMjI0MTg3QzYwMEY2QjcyOSAvKiBQbGF0Zm9ybVJlZ2lzdGVycy5jcHAg Ki87IH07CkBAIC03MzgsNiArNzM5LDggQEAKIAkJRUJGRjY3RkMyNDBEN0Q2NjAwNzhGRjFCIC8q IE9TVmFyaWFudFNQSS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBPU1Zhcmlh bnRTUEkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRUY3RDZDRDU5RDg2NDJBOEEw REE4NkFEIC8qIFN0YWNrVHJhY2UuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g U3RhY2tUcmFjZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNzJCQkRCMTA3RkE0 MjQ4ODYxNzhCOUUgLyogU3ltYm9sSW1wbC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBTeW1ib2xJbXBsLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ RkUwMzJBRDAyNDYzRTQzQjAwMTJEN0M3IC8qIFdURkNvbmZpZy5jcHAgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBXVEZDb25maWcuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQlGRTAzMkFEMTI0NjNFNDNCMDAxMkQ3QzcgLyogV1RGQ29uZmlnLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdURkNvbmZpZy5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlGRTA1RkFFNjFGREIyMTQzMDAwOTMyMzAgLyogRHVtYlB0clRyYWl0cy5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBEdW1iUHRyVHJhaXRzLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFMDVGQUZFMUZFNTAwNzUwMDA5MzIzMCAvKiBXVEZB c3NlcnRpb25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdURkFz c2VydGlvbnMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRTFENkQ4NzIzNzQw MUNEMDA3QTVDMjYgLyogU3RhY2tDaGVjay5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBTdGFja0NoZWNrLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xMzA0LDYg KzEzMDcsOCBAQAogCQkJCUU0QTBBRDM3MUE5NjI0NTUwMDUzNkRGNiAvKiBXb3JrUXVldWUuY3Bw ICovLAogCQkJCUU0QTBBRDM4MUE5NjI0NTUwMDUzNkRGNiAvKiBXb3JrUXVldWUuaCAqLywKIAkJ CQlGRTA1RkFGRTFGRTUwMDc1MDAwOTMyMzAgLyogV1RGQXNzZXJ0aW9ucy5jcHAgKi8sCisJCQkJ RkUwMzJBRDAyNDYzRTQzQjAwMTJEN0M3IC8qIFdURkNvbmZpZy5jcHAgKi8sCisJCQkJRkUwMzJB RDEyNDYzRTQzQjAwMTJEN0M3IC8qIFdURkNvbmZpZy5oICovLAogCQkJCUEzNkUxNkY3MjE2RkY4 MjgwMDhERDg3RSAvKiBXVEZTZW1hcGhvcmUuaCAqLywKIAkJCSk7CiAJCQlwYXRoID0gd3RmOwpA QCAtMTc2MSw2ICsxNzY2LDcgQEAKIAkJCQlBOEE0NzQ2OTE1MUE4MjVCMDA0MTIzRkYgLyogVVRG OENvbnZlcnNpb24uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0FGRUM2QjExRUIyMkI1OTAwREFE RTM2IC8qIFVVSUQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTMxNDlBMzkyMjhCQjQzNTAwQkZB NkM3IC8qIFZlY3Rvci5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlGRTAzMkFEMjI0NjNFNDNCMDAx MkQ3QzcgLyogV1RGQ29uZmlnLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTBGNjZCMjkyMURDOTdC QUIwMDRBMUQzRiAvKiBXYWxsVGltZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxRkE0N0M4QTE1 MjUwMkRBMDA1NjhEMUIgLyogV2ViQ29yZVRocmVhZC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkw RkU0NDc5QzFCN0FBQTAzMDA5NDk4RUIgLyogV29yZExvY2suY3BwIGluIFNvdXJjZXMgKi8sCklu ZGV4OiBTb3VyY2UvV1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAkocmV2aXNpb24gMjYxNDY5KQorKysgU291cmNlL1dURi93 dGYvQ01ha2VMaXN0cy50eHQJKHdvcmtpbmcgY29weSkKQEAgLTI4NCw2ICsyODQsNyBAQCBzZXQo V1RGX1BVQkxJQ19IRUFERVJTCiAgICAgVmVjdG9yLmgKICAgICBWZWN0b3JIYXNoLmgKICAgICBW ZWN0b3JUcmFpdHMuaAorICAgIFdURkNvbmZpZy5oCiAgICAgV1RGU2VtYXBob3JlLmgKICAgICBX YWxsVGltZS5oCiAgICAgV2Vha0hhc2hTZXQuaApAQCAtNDQ1LDYgKzQ0Niw3IEBAIHNldChXVEZf U09VUkNFUwogICAgIFVuaXF1ZUFycmF5LmNwcAogICAgIFZlY3Rvci5jcHAKICAgICBXVEZBc3Nl cnRpb25zLmNwcAorICAgIFdURkNvbmZpZy5jcHAKICAgICBXYWxsVGltZS5jcHAKICAgICBXb3Jk TG9jay5jcHAKICAgICBXb3JrUXVldWUuY3BwCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9UaHJlYWRp bmcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAJKHJldmlz aW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTM2LDggKzM2LDEwIEBACiAjaW5jbHVkZSA8d3RmL1RocmVhZEdyb3VwLmg+CiAjaW5j bHVkZSA8d3RmL1RocmVhZE1lc3NhZ2UuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nUHJpbWl0 aXZlcy5oPgorI2luY2x1ZGUgPHd0Zi9XVEZDb25maWcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9B dG9tU3RyaW5nVGFibGUuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdWaWV3Lmg+CisjaW5j bHVkZSA8d3RmL3RocmVhZHMvU2lnbmFscy5oPgogCiAjaWYgSEFWRShRT1NfQ0xBU1NFUykKICNp bmNsdWRlIDxibWFsbG9jL2JtYWxsb2MuaD4KQEAgLTM2MCwxMiArMzYyLDE0IEBAIHZvaWQgaW5p dGlhbGl6ZVRocmVhZGluZygpCiB7CiAgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9uY2VLZXk7 CiAgICAgc3RkOjpjYWxsX29uY2Uob25jZUtleSwgW10geworICAgICAgICBDb25maWc6OkFzc2Vy dE5vdEZyb3plblNjb3BlIGFzc2VydFNjb3BlOwogICAgICAgICBpbml0aWFsaXplUmFuZG9tTnVt YmVyR2VuZXJhdG9yKCk7CiAjaWYgIUhBVkUoRkFTVF9UTFMpICYmICFPUyhXSU5ET1dTKQogICAg ICAgICBUaHJlYWQ6OmluaXRpYWxpemVUTFNLZXkoKTsKICNlbmRpZgogICAgICAgICBpbml0aWFs aXplRGF0ZXMoKTsKICAgICAgICAgVGhyZWFkOjppbml0aWFsaXplUGxhdGZvcm1UaHJlYWRpbmco KTsKKyAgICAgICAgU2lnbmFsSGFuZGxlcnM6OmluaXRpYWxpemUoKTsKICAgICB9KTsKIH0KIApJ bmRleDogU291cmNlL1dURi93dGYvV1RGQ29uZmlnLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V1RGL3d0Zi9XVEZDb25maWcuY3BwCShub25leGlzdGVudCkKKysrIFNvdXJjZS9XVEYvd3RmL1dU RkNvbmZpZy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSw3OCBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBB TkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisg KiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNp bmNsdWRlIDx3dGYvV1RGQ29uZmlnLmg+CisKKyNpbmNsdWRlIDx3dGYvTG9jay5oPgorI2luY2x1 ZGUgPHd0Zi9SZXNvdXJjZVVzYWdlLmg+CisjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgor CisjaWYgT1MoREFSV0lOKQorI2luY2x1ZGUgPG1hY2gvbWFjaC5oPgorI2VsaWYgT1MoTElOVVgp CisjaW5jbHVkZSA8c3lzL21tYW4uaD4KKyNlbmRpZgorCituYW1lc3BhY2UgV1RGIHsKKworYWxp Z25hcyhDb25maWdTaXplVG9Qcm90ZWN0KSBXVEZfRVhQT1JUX1BSSVZBVEUgQ29uZmlnIGdfd3Rm Q29uZmlnOworCit2b2lkIENvbmZpZzo6ZGlzYWJsZUZyZWV6aW5nRm9yVGVzdGluZygpCit7Cisg ICAgUkVMRUFTRV9BU1NFUlQoIWdfd3RmQ29uZmlnLmlzUGVybWFuZW50bHlGcm96ZW4pOworICAg IGdfd3RmQ29uZmlnLmRpc2FibGVkRnJlZXppbmdGb3JUZXN0aW5nID0gdHJ1ZTsKK30KKwordm9p ZCBDb25maWc6OnBlcm1hbmVudGx5RnJlZXplKCkKK3sKKyAgICBzdGF0aWMgTG9jayBjb25maWdM b2NrOworICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2soY29uZmlnTG9jayk7CisKKyAgICBSRUxF QVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0aXBsZU9mKHBhZ2VTaXplKCksIENvbmZpZ1NpemVUb1By b3RlY3QpID09IENvbmZpZ1NpemVUb1Byb3RlY3QpOworCisgICAgaWYgKCFnX3d0ZkNvbmZpZy5p c1Blcm1hbmVudGx5RnJvemVuKQorICAgICAgICBnX3d0ZkNvbmZpZy5pc1Blcm1hbmVudGx5RnJv emVuID0gdHJ1ZTsKKworICAgIGludCByZXN1bHQgPSAwOworI2lmIE9TKERBUldJTikKKyAgICBl bnVtIHsKKyAgICAgICAgQWxsb3dQZXJtaXNzaW9uQ2hhbmdlc0FmdGVyVGhpcyA9IGZhbHNlLAor ICAgICAgICBEaXNhbGxvd1Blcm1pc3Npb25DaGFuZ2VzQWZ0ZXJUaGlzID0gdHJ1ZQorICAgIH07 CisKKyAgICAvLyBUaGVyZSdzIG5vIGdvaW5nIGJhY2sgbm93IQorICAgIHJlc3VsdCA9IHZtX3By b3RlY3QobWFjaF90YXNrX3NlbGYoKSwgcmVpbnRlcnByZXRfY2FzdDx2bV9hZGRyZXNzX3Q+KCZn X3d0ZkNvbmZpZyksIENvbmZpZ1NpemVUb1Byb3RlY3QsIERpc2FsbG93UGVybWlzc2lvbkNoYW5n ZXNBZnRlclRoaXMsIFZNX1BST1RfUkVBRCk7CisjZWxpZiBPUyhMSU5VWCkKKyAgICByZXN1bHQg PSBtcHJvdGVjdCgmZ193dGZDb25maWcsIENvbmZpZ1NpemVUb1Byb3RlY3QsIFBST1RfUkVBRCk7 CisjZWxpZiBPUyhXSU5ET1dTKQorICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgZXF1aXZhbGVudCwg bWF5YmUgd2l0aCBWaXJ0dWFsUHJvdGVjdC4KKyAgICAvLyBBbHNvIG5lZWQgdG8gZml4IFdlYktp dFRlc3RSdW5uZXIuCisjZW5kaWYKKyAgICBSRUxFQVNFX0FTU0VSVCghcmVzdWx0KTsKKyAgICBS RUxFQVNFX0FTU0VSVChnX3d0ZkNvbmZpZy5pc1Blcm1hbmVudGx5RnJvemVuKTsKK30KKworfSAv LyBuYW1lc3BhY2UgV1RGCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9XVEZDb25maWcuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9XVEZDb25maWcuaAkobm9uZXhpc3RlbnQpCisrKyBTb3Vy Y2UvV1RGL3d0Zi9XVEZDb25maWcuaAkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDc5IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4g YGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICog T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNl CisKKyNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9BdG9taWNzLmg+ CisjaW5jbHVkZSA8d3RmL0V4cG9ydE1hY3Jvcy5oPgorI2luY2x1ZGUgPHd0Zi9QYWdlQmxvY2su aD4KKyNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CisjaW5jbHVkZSA8d3RmL3RocmVhZHMv U2lnbmFscy5oPgorCituYW1lc3BhY2UgV1RGIHsKKworY29uc3RleHByIHNpemVfdCBDb25maWdT aXplVG9Qcm90ZWN0ID0gQ2VpbGluZ09uUGFnZVNpemU7CisKK3N0cnVjdCBDb25maWcgeworICAg IFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMgdm9pZCBkaXNhYmxlRnJlZXppbmdGb3JUZXN0aW5n KCk7CisgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0YXRpYyB2b2lkIHBlcm1hbmVudGx5RnJlZXpl KCk7CisKKyAgICBzdHJ1Y3QgQXNzZXJ0Tm90RnJvemVuU2NvcGUgeworICAgICAgICB+QXNzZXJ0 Tm90RnJvemVuU2NvcGUoKTsKKyAgICB9OworCisgICAgc3RhdGljIHZvaWQgY29uZmlndXJlRm9y VGVzdGluZygpCisgICAgeworICAgICAgICBkaXNhYmxlRnJlZXppbmdGb3JUZXN0aW5nKCk7Cisg ICAgfQorCisgICAgdW5pb24geworICAgICAgICBzdHJ1Y3QgeworICAgICAgICAgICAgLy8gQWxs IHRoZSBmaWVsZHMgaW4gdGhpcyBzdHJ1Y3Qgc2hvdWxkIGJlIGNob3NlbiBzdWNoIHRoYXQgdGhl aXIKKyAgICAgICAgICAgIC8vIGluaXRpYWwgdmFsdWUgaXMgMCAvIG51bGwgLyBmYWxzeSBiZWNh dXNlIENvbmZpZyBpcyBpbnN0YW50aWF0ZWQKKyAgICAgICAgICAgIC8vIGFzIGEgZ2xvYmFsIHNp bmdsZXRvbi4KKworICAgICAgICAgICAgYm9vbCBpc1Blcm1hbmVudGx5RnJvemVuOworICAgICAg ICAgICAgYm9vbCBkaXNhYmxlZEZyZWV6aW5nRm9yVGVzdGluZzsKKworI2lmIFVTRShQVEhSRUFE UykgJiYgSEFWRShNQUNISU5FX0NPTlRFWFQpCisgICAgICAgICAgICBTaWduYWxIYW5kbGVycyBz aWduYWxIYW5kbGVyczsKKyNlbmRpZgorICAgICAgICB9OworICAgICAgICBjaGFyIGVuc3VyZVNp emVbQ29uZmlnU2l6ZVRvUHJvdGVjdF07CisgICAgfTsKK307CisKK2V4dGVybiAiQyIgYWxpZ25h cyhDb25maWdTaXplVG9Qcm90ZWN0KSBXVEZfRVhQT1JUX1BSSVZBVEUgQ29uZmlnIGdfd3RmQ29u ZmlnOworCitzdGF0aWNfYXNzZXJ0KHNpemVvZihDb25maWcpID09IENvbmZpZ1NpemVUb1Byb3Rl Y3QpOworCitBTFdBWVNfSU5MSU5FIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGU6On5Bc3Nl cnROb3RGcm96ZW5TY29wZSgpCit7CisgICAgc3RvcmVMb2FkRmVuY2UoKTsKKyAgICBSRUxFQVNF X0FTU0VSVCghZ193dGZDb25maWcuaXNQZXJtYW5lbnRseUZyb3plbik7Cit9OworCit9IC8vIG5h bWVzcGFjZSBXVEYKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL3RocmVhZHMvU2lnbmFscy5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dURi93dGYvdGhyZWFkcy9TaWduYWxzLmNwcAkocmV2aXNpb24g MjYxNDY5KQorKysgU291cmNlL1dURi93dGYvdGhyZWFkcy9TaWduYWxzLmNwcAkod29ya2luZyBj b3B5KQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTcgQXBwbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE3LTIwMjAgQXBwbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CkBAIC01MSwxNCArNTEsMzIgQEAgZXh0ZXJuICJDIiB7CiAjaW5jbHVkZSA8d3RmL1RocmVhZEdy b3VwLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZE1lc3NhZ2UuaD4KICNpbmNsdWRlIDx3dGYvVGhy ZWFkaW5nLmg+Ci0KKyNpbmNsdWRlIDx3dGYvV1RGQ29uZmlnLmg+CiAKIG5hbWVzcGFjZSBXVEYg ewogCi0gICAgCi1zdGF0aWMgTGF6eU5ldmVyRGVzdHJveWVkPExvY2tsZXNzQmFnPFNpZ25hbEhh bmRsZXI+PiBoYW5kbGVyc1tzdGF0aWNfY2FzdDxzaXplX3Q+KFNpZ25hbDo6TnVtYmVyT2ZTaWdu YWxzKV0gPSB7IH07Ci1zdGF0aWMgc3RkOjpvbmNlX2ZsYWcgaW5pdGlhbGl6ZU9uY2VGbGFnc1tz dGF0aWNfY2FzdDxzaXplX3Q+KFNpZ25hbDo6TnVtYmVyT2ZTaWduYWxzKV07Ci1zdGF0aWMgc3Ry dWN0IHNpZ2FjdGlvbiBvbGRBY3Rpb25zW3N0YXRpY19jYXN0PHNpemVfdD4oU2lnbmFsOjpOdW1i ZXJPZlNpZ25hbHMpXTsKK1NpZ25hbEhhbmRsZXJNZW1vcnkqIFNpZ25hbEhhbmRsZXJzOjphbGxv YyhTaWduYWwgc2lnbmFsKQoreworICAgIHN0YXRpYyBMb2NrIGxvY2s7CisgICAgYXV0byBsb2Nr ZXIgPSBob2xkTG9jayhsb2NrKTsKKworICAgIHNpemVfdCBzaWduYWxJbmRleCA9IHN0YXRpY19j YXN0PHNpemVfdD4oc2lnbmFsKTsKKyAgICBSRUxFQVNFX0FTU0VSVChudW1iZXJPZkhhbmRsZXJz W3NpZ25hbEluZGV4XSA8IG1heE51bWJlck9mSGFuZGxlcnMpOworICAgIHNpemVfdCBuZXh0RnJl ZSA9IG51bWJlck9mSGFuZGxlcnNbc2lnbmFsSW5kZXhdKys7CisgICAgcmV0dXJuICZoYW5kbGVy c1tzaWduYWxJbmRleF1bbmV4dEZyZWVdOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBGdW5jPgor aW5saW5lIHZvaWQgU2lnbmFsSGFuZGxlcnM6OmZvckVhY2hIYW5kbGVyKFNpZ25hbCBzaWduYWws IGNvbnN0IEZ1bmMmIGZ1bmMpIGNvbnN0Cit7CisgICAgc2l6ZV90IHNpZ25hbEluZGV4ID0gc3Rh dGljX2Nhc3Q8c2l6ZV90PihzaWduYWwpOworICAgIHNpemVfdCBoYW5kbGVySW5kZXggPSBudW1i ZXJPZkhhbmRsZXJzW3NpZ25hbEluZGV4XTsKKyAgICB3aGlsZSAoaGFuZGxlckluZGV4LS0pIHsK KyAgICAgICAgYXV0byogbWVtb3J5ID0gY29uc3RfY2FzdDxTaWduYWxIYW5kbGVyTWVtb3J5Kj4o JmhhbmRsZXJzW3NpZ25hbEluZGV4XVtoYW5kbGVySW5kZXhdKTsKKyAgICAgICAgY29uc3QgU2ln bmFsSGFuZGxlciYgaGFuZGxlciA9ICpyZWludGVycHJldF9jYXN0PFNpZ25hbEhhbmRsZXIqPiht ZW1vcnkpOworICAgICAgICBmdW5jKGhhbmRsZXIpOworICAgIH0KK30KIAogI2lmIEhBVkUoTUFD SF9FWENFUFRJT05TKQogLy8gWW91IGNhbiByZWFkIG1vcmUgYWJvdXQgbWFjaCBleGNlcHRpb25z IGhlcmU6CkBAIC02NiwyNyArODQsMjggQEAgc3RhdGljIHN0cnVjdCBzaWdhY3Rpb24gb2xkQWN0 aW9uc1tzdGF0aQogLy8gYW5kIHRoZSBNYWNoIGludGVyZmFjZSBHZW5lcmF0b3IgKE1pRykgaGVy ZToKIC8vIGh0dHA6Ly93d3cuY3MuY211LmVkdS9hZnMvY3MvcHJvamVjdC9tYWNoL3B1YmxpYy9k b2MvdW5wdWJsaXNoZWQvbWlnLnBzCiAKLXN0YXRpYyBtYWNoX3BvcnRfdCBleGNlcHRpb25Qb3J0 Owogc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgbWF4TWVzc2FnZVNpemUgPSAxICogS0I7CiAKIHZv aWQgc3RhcnRNYWNoRXhjZXB0aW9uSGFuZGxlclRocmVhZCgpCiB7CiAgICAgc3RhdGljIHN0ZDo6 b25jZV9mbGFnIG9uY2U7CiAgICAgc3RkOjpjYWxsX29uY2Uob25jZSwgW10gewotICAgICAgICBr ZXJuX3JldHVybl90IGtyID0gbWFjaF9wb3J0X2FsbG9jYXRlKG1hY2hfdGFza19zZWxmKCksIE1B Q0hfUE9SVF9SSUdIVF9SRUNFSVZFLCAmZXhjZXB0aW9uUG9ydCk7CisgICAgICAgIENvbmZpZzo6 QXNzZXJ0Tm90RnJvemVuU2NvcGUgYXNzZXJ0U2NvcGU7CisgICAgICAgIFNpZ25hbEhhbmRsZXJz JiBoYW5kbGVycyA9IGdfd3RmQ29uZmlnLnNpZ25hbEhhbmRsZXJzOworICAgICAgICBrZXJuX3Jl dHVybl90IGtyID0gbWFjaF9wb3J0X2FsbG9jYXRlKG1hY2hfdGFza19zZWxmKCksIE1BQ0hfUE9S VF9SSUdIVF9SRUNFSVZFLCAmaGFuZGxlcnMuZXhjZXB0aW9uUG9ydCk7CiAgICAgICAgIFJFTEVB U0VfQVNTRVJUKGtyID09IEtFUk5fU1VDQ0VTUyk7Ci0gICAgICAgIGtyID0gbWFjaF9wb3J0X2lu c2VydF9yaWdodChtYWNoX3Rhc2tfc2VsZigpLCBleGNlcHRpb25Qb3J0LCBleGNlcHRpb25Qb3J0 LCBNQUNIX01TR19UWVBFX01BS0VfU0VORCk7CisgICAgICAgIGtyID0gbWFjaF9wb3J0X2luc2Vy dF9yaWdodChtYWNoX3Rhc2tfc2VsZigpLCBoYW5kbGVycy5leGNlcHRpb25Qb3J0LCBoYW5kbGVy cy5leGNlcHRpb25Qb3J0LCBNQUNIX01TR19UWVBFX01BS0VfU0VORCk7CiAgICAgICAgIFJFTEVB U0VfQVNTRVJUKGtyID09IEtFUk5fU1VDQ0VTUyk7CiAKICAgICAgICAgZGlzcGF0Y2hfc291cmNl X3Qgc291cmNlID0gZGlzcGF0Y2hfc291cmNlX2NyZWF0ZSgKLSAgICAgICAgICAgIERJU1BBVENI X1NPVVJDRV9UWVBFX01BQ0hfUkVDViwgZXhjZXB0aW9uUG9ydCwgMCwgRElTUEFUQ0hfVEFSR0VU X1FVRVVFX0RFRkFVTFQpOworICAgICAgICAgICAgRElTUEFUQ0hfU09VUkNFX1RZUEVfTUFDSF9S RUNWLCBoYW5kbGVycy5leGNlcHRpb25Qb3J0LCAwLCBESVNQQVRDSF9UQVJHRVRfUVVFVUVfREVG QVVMVCk7CiAgICAgICAgIFJFTEVBU0VfQVNTRVJUKHNvdXJjZSk7CiAKICAgICAgICAgZGlzcGF0 Y2hfc291cmNlX3NldF9ldmVudF9oYW5kbGVyKHNvdXJjZSwgXnsKICAgICAgICAgICAgIFVOVVNF RF9QQVJBTShzb3VyY2UpOyAvLyBDYXB0dXJlIGEgcG9pbnRlciB0byBzb3VyY2UgaW4gdXNlciBz cGFjZSB0byBzaWxlbmNlIHRoZSBsZWFrcyB0b29sLgogCiAgICAgICAgICAgICBrZXJuX3JldHVy bl90IGtyID0gbWFjaF9tc2dfc2VydmVyX29uY2UoCi0gICAgICAgICAgICAgICAgbWFjaF9leGNf c2VydmVyLCBtYXhNZXNzYWdlU2l6ZSwgZXhjZXB0aW9uUG9ydCwgTUFDSF9NU0dfVElNRU9VVF9O T05FKTsKKyAgICAgICAgICAgICAgICBtYWNoX2V4Y19zZXJ2ZXIsIG1heE1lc3NhZ2VTaXplLCBo YW5kbGVycy5leGNlcHRpb25Qb3J0LCBNQUNIX01TR19USU1FT1VUX05PTkUpOwogICAgICAgICAg ICAgUkVMRUFTRV9BU1NFUlQoa3IgPT0gS0VSTl9TVUNDRVNTKTsKICAgICAgICAgfSk7CiAKQEAg LTE0NSw3ICsxNjQsOCBAQCBrZXJuX3JldHVybl90IGNhdGNoX21hY2hfZXhjZXB0aW9uX3JhaXNl CiAgICAgdGhyZWFkX3N0YXRlX3Qgb3V0U3RhdGUsCiAgICAgbWFjaF9tc2dfdHlwZV9udW1iZXJf dCogb3V0U3RhdGVDb3VudCkKIHsKLSAgICBSRUxFQVNFX0FTU0VSVChwb3J0ID09IGV4Y2VwdGlv blBvcnQpOworICAgIFNpZ25hbEhhbmRsZXJzJiBoYW5kbGVycyA9IGdfd3RmQ29uZmlnLnNpZ25h bEhhbmRsZXJzOworICAgIFJFTEVBU0VfQVNTRVJUKHBvcnQgPT0gaGFuZGxlcnMuZXhjZXB0aW9u UG9ydCk7CiAgICAgLy8gSWYgd2Ugd2FudGVkIHRvIGRpc3Rpbmd1aXNoIGJldHdlZW4gU0lHQlVT IGFuZCBTSUdTRUdWIGZvciBFWENfQkFEX0FDQ0VTUyBvbiBEYXJ3aW4gd2UgY291bGQgZG86CiAg ICAgLy8gaWYgKGV4Y2VwdGlvbkRhdGFbMF0gPT0gS0VSTl9JTlZBTElEX0FERFJFU1MpCiAgICAg Ly8gICAgc2lnbmFsID0gU0lHU0VHVjsKQEAgLTE3OCw3ICsxOTgsNyBAQCBrZXJuX3JldHVybl90 IGNhdGNoX21hY2hfZXhjZXB0aW9uX3JhaXNlCiAgICAgfQogCiAgICAgYm9vbCBkaWRIYW5kbGUg PSBmYWxzZTsKLSAgICBoYW5kbGVyc1tzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCldLT5pdGVy YXRlKFsmXSAoY29uc3QgU2lnbmFsSGFuZGxlciYgaGFuZGxlcikgeworICAgIGhhbmRsZXJzLmZv ckVhY2hIYW5kbGVyKHNpZ25hbCwgWyZdIChjb25zdCBTaWduYWxIYW5kbGVyJiBoYW5kbGVyKSB7 CiAgICAgICAgIFNpZ25hbEFjdGlvbiBoYW5kbGVyUmVzdWx0ID0gaGFuZGxlcihzaWduYWwsIGlu Zm8sIHJlZ2lzdGVycyk7CiAgICAgICAgIGRpZEhhbmRsZSB8PSBoYW5kbGVyUmVzdWx0ID09IFNp Z25hbEFjdGlvbjo6SGFuZGxlZDsKICAgICB9KTsKQEAgLTE4OCwyMSArMjA4LDE4IEBAIGtlcm5f cmV0dXJuX3QgY2F0Y2hfbWFjaF9leGNlcHRpb25fcmFpc2UKICAgICByZXR1cm4gS0VSTl9GQUlM VVJFOwogfQogCi19OworfTsgLy8gZXh0ZXJuICJDIgogCi1zdGF0aWMgYm9vbCB1c2VNYWNoIHsg ZmFsc2UgfTsKIHZvaWQgaGFuZGxlU2lnbmFsc1dpdGhNYWNoKCkKIHsKLSAgICB1c2VNYWNoID0g dHJ1ZTsKKyAgICBnX3d0ZkNvbmZpZy5zaWduYWxIYW5kbGVycy51c2VNYWNoID0gdHJ1ZTsKIH0K IAotCi1leGNlcHRpb25fbWFza190IGFjdGl2ZUV4Y2VwdGlvbnMgeyAwIH07Ci0KIGlubGluZSB2 b2lkIHNldEV4Y2VwdGlvblBvcnRzKGNvbnN0IEFic3RyYWN0TG9ja2VyJiB0aHJlYWRHcm91cExv Y2tlciwgVGhyZWFkJiB0aHJlYWQpCiB7CiAgICAgVU5VU0VEX1BBUkFNKHRocmVhZEdyb3VwTG9j a2VyKTsKLSAgICBrZXJuX3JldHVybl90IHJlc3VsdCA9IHRocmVhZF9zZXRfZXhjZXB0aW9uX3Bv cnRzKHRocmVhZC5tYWNoVGhyZWFkKCksIGFjdGl2ZUV4Y2VwdGlvbnMsIGV4Y2VwdGlvblBvcnQs IEVYQ0VQVElPTl9TVEFURSB8IE1BQ0hfRVhDRVBUSU9OX0NPREVTLCBNQUNISU5FX1RIUkVBRF9T VEFURSk7CisgICAgU2lnbmFsSGFuZGxlcnMmIGhhbmRsZXJzID0gZ193dGZDb25maWcuc2lnbmFs SGFuZGxlcnM7CisgICAga2Vybl9yZXR1cm5fdCByZXN1bHQgPSB0aHJlYWRfc2V0X2V4Y2VwdGlv bl9wb3J0cyh0aHJlYWQubWFjaFRocmVhZCgpLCBoYW5kbGVycy5hY3RpdmVFeGNlcHRpb25zLCBo YW5kbGVycy5leGNlcHRpb25Qb3J0LCBFWENFUFRJT05fU1RBVEUgfCBNQUNIX0VYQ0VQVElPTl9D T0RFUywgTUFDSElORV9USFJFQURfU1RBVEUpOwogICAgIGlmIChyZXN1bHQgIT0gS0VSTl9TVUND RVNTKSB7CiAgICAgICAgIGRhdGFMb2dMbigidGhyZWFkIHNldCBwb3J0IGZhaWxlZCBkdWUgdG8g IiwgbWFjaF9lcnJvcl9zdHJpbmcocmVzdWx0KSk7CiAgICAgICAgIENSQVNIKCk7CkBAIC0yMTQs NiArMjMxLDcgQEAgc3RhdGljIFRocmVhZEdyb3VwJiBhY3RpdmVUaHJlYWRzKCkKICAgICBzdGF0 aWMgc3RkOjpvbmNlX2ZsYWcgaW5pdGlhbGl6ZUtleTsKICAgICBzdGF0aWMgVGhyZWFkR3JvdXAq IGFjdGl2ZVRocmVhZHNQdHIgPSBudWxscHRyOwogICAgIHN0ZDo6Y2FsbF9vbmNlKGluaXRpYWxp emVLZXksIFsmXSB7CisgICAgICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUgYXNzZXJ0 U2NvcGU7CiAgICAgICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxzdGQ6OnNoYXJlZF9wdHI8VGhy ZWFkR3JvdXA+PiBhY3RpdmVUaHJlYWRzIHsgVGhyZWFkR3JvdXA6OmNyZWF0ZSgpIH07CiAgICAg ICAgIGFjdGl2ZVRocmVhZHNQdHIgPSBhY3RpdmVUaHJlYWRzLmdldCgpLmdldCgpOwogICAgIH0p OwpAQCAtMjQyLDE3ICsyNjAsMjIgQEAgc3RhdGljIHZvaWQganNjU2lnbmFsSGFuZGxlcihpbnQs IHNpZ2luZgogCiB2b2lkIGluc3RhbGxTaWduYWxIYW5kbGVyKFNpZ25hbCBzaWduYWwsIFNpZ25h bEhhbmRsZXImJiBoYW5kbGVyKQogeworICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUg YXNzZXJ0U2NvcGU7CisgICAgU2lnbmFsSGFuZGxlcnMmIGhhbmRsZXJzID0gZ193dGZDb25maWcu c2lnbmFsSGFuZGxlcnM7CiAgICAgQVNTRVJUKHNpZ25hbCA8IFNpZ25hbDo6VW5rbm93bik7CiAj aWYgSEFWRShNQUNIX0VYQ0VQVElPTlMpCi0gICAgQVNTRVJUKCF1c2VNYWNoIHx8IHNpZ25hbCAh PSBTaWduYWw6OlVzcik7CisgICAgQVNTRVJUKCFoYW5kbGVycy51c2VNYWNoIHx8IHNpZ25hbCAh PSBTaWduYWw6OlVzcik7CiAKLSAgICBpZiAodXNlTWFjaCkKKyAgICBpZiAoaGFuZGxlcnMudXNl TWFjaCkKICAgICAgICAgc3RhcnRNYWNoRXhjZXB0aW9uSGFuZGxlclRocmVhZCgpOwogI2VuZGlm CiAKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgaW5pdGlhbGl6ZU9uY2VGbGFnc1tzdGF0aWNf Y2FzdDxzaXplX3Q+KFNpZ25hbDo6TnVtYmVyT2ZTaWduYWxzKV07CiAgICAgc3RkOjpjYWxsX29u Y2UoaW5pdGlhbGl6ZU9uY2VGbGFnc1tzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCldLCBbJl0g ewotICAgICAgICBoYW5kbGVyc1tzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCldLmNvbnN0cnVj dCgpOwotCisgICAgICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUgYXNzZXJ0U2NvcGU7 CisjaWYgSEFWRShNQUNIX0VYQ0VQVElPTlMpCisgICAgICAgIGJvb2wgdXNlTWFjaCA9IGhhbmRs ZXJzLnVzZU1hY2g7CisjZW5kaWYKICAgICAgICAgaWYgKCF1c2VNYWNoKSB7CiAgICAgICAgICAg ICBzdHJ1Y3Qgc2lnYWN0aW9uIGFjdGlvbjsKICAgICAgICAgICAgIGFjdGlvbi5zYV9zaWdhY3Rp b24gPSBqc2NTaWduYWxIYW5kbGVyOwpAQCAtMjYzLDIwICsyODYsMjAgQEAgdm9pZCBpbnN0YWxs U2lnbmFsSGFuZGxlcihTaWduYWwgc2lnbmFsLAogICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQo IXJlc3VsdCk7CiAgICAgICAgICAgICBhY3Rpb24uc2FfZmxhZ3MgPSBTQV9TSUdJTkZPOwogICAg ICAgICAgICAgYXV0byBzeXN0ZW1TaWduYWxzID0gdG9TeXN0ZW1TaWduYWwoc2lnbmFsKTsKLSAg ICAgICAgICAgIHJlc3VsdCA9IHNpZ2FjdGlvbihzdGQ6OmdldDwwPihzeXN0ZW1TaWduYWxzKSwg JmFjdGlvbiwgJm9sZEFjdGlvbnNbb2Zmc2V0Rm9yU3lzdGVtU2lnbmFsKHN0ZDo6Z2V0PDA+KHN5 c3RlbVNpZ25hbHMpKV0pOworICAgICAgICAgICAgcmVzdWx0ID0gc2lnYWN0aW9uKHN0ZDo6Z2V0 PDA+KHN5c3RlbVNpZ25hbHMpLCAmYWN0aW9uLCAmaGFuZGxlcnMub2xkQWN0aW9uc1tvZmZzZXRG b3JTeXN0ZW1TaWduYWwoc3RkOjpnZXQ8MD4oc3lzdGVtU2lnbmFscykpXSk7CiAgICAgICAgICAg ICBpZiAoc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscykpCi0gICAgICAgICAgICAgICAgcmVzdWx0 IHw9IHNpZ2FjdGlvbigqc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscyksICZhY3Rpb24sICZvbGRB Y3Rpb25zW29mZnNldEZvclN5c3RlbVNpZ25hbCgqc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscykp XSk7CisgICAgICAgICAgICAgICAgcmVzdWx0IHw9IHNpZ2FjdGlvbigqc3RkOjpnZXQ8MT4oc3lz dGVtU2lnbmFscyksICZhY3Rpb24sICZoYW5kbGVycy5vbGRBY3Rpb25zW29mZnNldEZvclN5c3Rl bVNpZ25hbCgqc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscykpXSk7CiAgICAgICAgICAgICBSRUxF QVNFX0FTU0VSVCghcmVzdWx0KTsKICAgICAgICAgfQotCiAgICAgfSk7CiAKLSAgICBoYW5kbGVy c1tzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCldLT5hZGQoV1RGTW92ZShoYW5kbGVyKSk7Cisg ICAgU2lnbmFsSGFuZGxlck1lbW9yeSogbWVtb3J5ID0gaGFuZGxlcnMuYWxsb2Moc2lnbmFsKTsK KyAgICBuZXcgKG1lbW9yeSkgU2lnbmFsSGFuZGxlcihXVEZNb3ZlKGhhbmRsZXIpKTsKIAogI2lm IEhBVkUoTUFDSF9FWENFUFRJT05TKQogICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2soYWN0aXZl VGhyZWFkcygpLmdldExvY2soKSk7Ci0gICAgaWYgKHVzZU1hY2gpIHsKLSAgICAgICAgYWN0aXZl RXhjZXB0aW9ucyB8PSB0b01hY2hNYXNrKHNpZ25hbCk7CisgICAgaWYgKGhhbmRsZXJzLnVzZU1h Y2gpIHsKKyAgICAgICAgaGFuZGxlcnMuYWN0aXZlRXhjZXB0aW9ucyB8PSB0b01hY2hNYXNrKHNp Z25hbCk7CiAKICAgICAgICAgZm9yIChhdXRvJiB0aHJlYWQgOiBhY3RpdmVUaHJlYWRzKCkudGhy ZWFkcyhsb2NrZXIpKQogICAgICAgICAgICAgc2V0RXhjZXB0aW9uUG9ydHMobG9ja2VyLCB0aHJl YWQuZ2V0KCkpOwpAQCAtMjg3LDYgKzMxMCw3IEBAIHZvaWQgaW5zdGFsbFNpZ25hbEhhbmRsZXIo U2lnbmFsIHNpZ25hbCwKIHZvaWQganNjU2lnbmFsSGFuZGxlcihpbnQgc2lnLCBzaWdpbmZvX3Qq IGluZm8sIHZvaWQqIHVjb250ZXh0KQogewogICAgIFNpZ25hbCBzaWduYWwgPSBmcm9tU3lzdGVt U2lnbmFsKHNpZyk7CisgICAgU2lnbmFsSGFuZGxlcnMmIGhhbmRsZXJzID0gZ193dGZDb25maWcu c2lnbmFsSGFuZGxlcnM7CiAKICAgICBhdXRvIHJlc3RvcmVEZWZhdWx0ID0gWyZdIHsKICAgICAg ICAgc3RydWN0IHNpZ2FjdGlvbiBkZWZhdWx0QWN0aW9uOwpAQCAtMjk5LDcgKzMyMyw3IEBAIHZv aWQganNjU2lnbmFsSGFuZGxlcihpbnQgc2lnLCBzaWdpbmZvX3QKIAogICAgIC8vIFRoaXMgc2hv dWxkbid0IGhhcHBlbiBidXQgd2UgbWlnaHQgYXMgd2VsbCBiZSBjYXJlZnVsLgogICAgIGlmIChz aWduYWwgPT0gU2lnbmFsOjpVbmtub3duKSB7Ci0gICAgICAgIGRhdGFMb2dMbigiV2Ugc29tZWhv dyBnb3QgY2FsbGVkIGZvciBhbiB1bmtub3duIHNpZ25hbCAiLCBzaWcsICIsIGhhbHAuIik7Cisg ICAgICAgIGRhdGFMb2dMbigiV2Ugc29tZWhvdyBnb3QgY2FsbGVkIGZvciBhbiB1bmtub3duIHNp Z25hbCAiLCBzaWcsICIsIGhlbHAuIik7CiAgICAgICAgIHJlc3RvcmVEZWZhdWx0KCk7CiAgICAg ICAgIHJldHVybjsKICAgICB9CkBAIC0zMTIsNyArMzM2LDcgQEAgdm9pZCBqc2NTaWduYWxIYW5k bGVyKGludCBzaWcsIHNpZ2luZm9fdAogCiAgICAgYm9vbCBkaWRIYW5kbGUgPSBmYWxzZTsKICAg ICBib29sIHJlc3RvcmVEZWZhdWx0SGFuZGxlciA9IGZhbHNlOwotICAgIGhhbmRsZXJzW3N0YXRp Y19jYXN0PHNpemVfdD4oc2lnbmFsKV0tPml0ZXJhdGUoWyZdIChjb25zdCBTaWduYWxIYW5kbGVy JiBoYW5kbGVyKSB7CisgICAgaGFuZGxlcnMuZm9yRWFjaEhhbmRsZXIoc2lnbmFsLCBbJl0gKGNv bnN0IFNpZ25hbEhhbmRsZXImIGhhbmRsZXIpIHsKICAgICAgICAgc3dpdGNoIChoYW5kbGVyKHNp Z25hbCwgc2lnSW5mbywgcmVnaXN0ZXJzKSkgewogICAgICAgICBjYXNlIFNpZ25hbEFjdGlvbjo6 SGFuZGxlZDoKICAgICAgICAgICAgIGRpZEhhbmRsZSA9IHRydWU7CkBAIC0zMzEsNyArMzU1LDcg QEAgdm9pZCBqc2NTaWduYWxIYW5kbGVyKGludCBzaWcsIHNpZ2luZm9fdAogICAgIH0KIAogICAg IHVuc2lnbmVkIG9sZEFjdGlvbkluZGV4ID0gc3RhdGljX2Nhc3Q8c2l6ZV90PihzaWduYWwpICsg KHNpZyA9PSBTSUdCVVMpOwotICAgIHN0cnVjdCBzaWdhY3Rpb24mIG9sZEFjdGlvbiA9IG9sZEFj dGlvbnNbc3RhdGljX2Nhc3Q8c2l6ZV90PihvbGRBY3Rpb25JbmRleCldOworICAgIHN0cnVjdCBz aWdhY3Rpb24mIG9sZEFjdGlvbiA9IGhhbmRsZXJzLm9sZEFjdGlvbnNbc3RhdGljX2Nhc3Q8c2l6 ZV90PihvbGRBY3Rpb25JbmRleCldOwogICAgIGlmIChzaWduYWwgPT0gU2lnbmFsOjpVc3IpIHsK ICAgICAgICAgaWYgKG9sZEFjdGlvbi5zYV9zaWdhY3Rpb24pCiAgICAgICAgICAgICBvbGRBY3Rp b24uc2Ffc2lnYWN0aW9uKHNpZywgaW5mbywgdWNvbnRleHQpOwpAQCAtMzQ5LDYgKzM3MywxNCBA QCB2b2lkIGpzY1NpZ25hbEhhbmRsZXIoaW50IHNpZywgc2lnaW5mb190CiAgICAgfQogfQogCit2 b2lkIFNpZ25hbEhhbmRsZXJzOjppbml0aWFsaXplKCkKK3sKKyNpZiBIQVZFKE1BQ0hfRVhDRVBU SU9OUykKKyAgICAvLyBFbnN1cmUgdGhhdCB3ZSd2ZSBpbml0aWFsaXplZCB0aGlzIGJlZm9yZSBm cmVlemUgdGhlIENvbmZpZy4KKyAgICBhY3RpdmVUaHJlYWRzKCk7CisjZW5kaWYKK30KKwogfSAv LyBuYW1lc3BhY2UgV1RGCiAKICNlbmRpZiAvLyBVU0UoUFRIUkVBRFMpICYmIEhBVkUoTUFDSElO RV9DT05URVhUKQpJbmRleDogU291cmNlL1dURi93dGYvdGhyZWFkcy9TaWduYWxzLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dURi93dGYvdGhyZWFkcy9TaWduYWxzLmgJKHJldmlzaW9uIDI2MTQ2 OSkKKysrIFNvdXJjZS9XVEYvd3RmL3RocmVhZHMvU2lnbmFscy5oCSh3b3JraW5nIGNvcHkpCkBA IC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNyBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTMw LDkgKzMwLDE0IEBACiAjaW5jbHVkZSA8c2lnbmFsLmg+CiAjaW5jbHVkZSA8dHVwbGU+CiAjaW5j bHVkZSA8d3RmL0Z1bmN0aW9uLmg+CisjaW5jbHVkZSA8d3RmL0xvY2suaD4KICNpbmNsdWRlIDx3 dGYvT3B0aW9uYWwuaD4KICNpbmNsdWRlIDx3dGYvUGxhdGZvcm1SZWdpc3RlcnMuaD4KIAorI2lm IEhBVkUoTUFDSF9FWENFUFRJT05TKQorI2luY2x1ZGUgPG1hY2gvZXhjZXB0aW9uX3R5cGVzLmg+ CisjZW5kaWYKKwogbmFtZXNwYWNlIFdURiB7CiAKIC8vIE5vdGUgdGhhdCBTSUdVU1IxIGlzIHVz ZWQgaW4gUHRocmVhZC1iYXNlZCBwb3J0cyBleGNlcHQgZm9yIERhcndpbiB0byBzdXNwZW5kIGFu ZCByZXN1bWUgdGhyZWFkcy4KQEAgLTgyLDExICs4NywzNyBAQCBzdHJ1Y3QgU2lnSW5mbyB7CiB9 OwogCiB1c2luZyBTaWduYWxIYW5kbGVyID0gRnVuY3Rpb248U2lnbmFsQWN0aW9uKFNpZ25hbCwg U2lnSW5mbyYsIFBsYXRmb3JtUmVnaXN0ZXJzJik+OwordXNpbmcgU2lnbmFsSGFuZGxlck1lbW9y eSA9IHN0ZDo6YWxpZ25lZF9zdG9yYWdlPHNpemVvZihTaWduYWxIYW5kbGVyKSwgc3RkOjphbGln bm1lbnRfb2Y8U2lnbmFsSGFuZGxlcj46OnZhbHVlPjo6dHlwZTsKKworc3RydWN0IFNpZ25hbEhh bmRsZXJzIHsKKyAgICBTaWduYWxIYW5kbGVyTWVtb3J5KiBhbGxvYyhTaWduYWwpOworCisgICAg c3RhdGljIHZvaWQgaW5pdGlhbGl6ZSgpOworCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgRnVuYz4K KyAgICB2b2lkIGZvckVhY2hIYW5kbGVyKFNpZ25hbCwgY29uc3QgRnVuYyYpIGNvbnN0OworCisg ICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgbnVtYmVyT2ZTaWduYWxzID0gc3RhdGljX2Nhc3Q8 c2l6ZV90PihTaWduYWw6Ok51bWJlck9mU2lnbmFscyk7CisgICAgc3RhdGljIGNvbnN0ZXhwciBz aXplX3QgbWF4TnVtYmVyT2ZIYW5kbGVycyA9IDI7CisKKyNpZiBIQVZFKE1BQ0hfRVhDRVBUSU9O UykKKyAgICBtYWNoX3BvcnRfdCBleGNlcHRpb25Qb3J0OworICAgIGV4Y2VwdGlvbl9tYXNrX3Qg YWN0aXZlRXhjZXB0aW9uczsKKyAgICBib29sIHVzZU1hY2g7CisjZW5kaWYKKyAgICB1aW50OF90 IG51bWJlck9mSGFuZGxlcnNbbnVtYmVyT2ZTaWduYWxzXTsKKyAgICBTaWduYWxIYW5kbGVyTWVt b3J5IGhhbmRsZXJzW251bWJlck9mU2lnbmFsc11bbWF4TnVtYmVyT2ZIYW5kbGVyc107CisgICAg c3RydWN0IHNpZ2FjdGlvbiBvbGRBY3Rpb25zW251bWJlck9mU2lnbmFsc107Cit9OworCitzdGF0 aWNfYXNzZXJ0KFNpZ25hbEhhbmRsZXJzOjpudW1iZXJPZlNpZ25hbHMgPCBzdGQ6Om51bWVyaWNf bGltaXRzPHVpbnQ4X3Q+OjptYXgoKSk7CiAKLS8vIENhbGwgdGhpcyBtZXRob2Qgd2hlbmV2ZXIg eW91IHdhbnQgdG8gaW5zdGFsbCBhIHNpZ25hbCBoYW5kbGVyLiBJdCdzIG9rIHRvIGNhbGwgdGhp cyBmdW5jdGlvbiBsYXppbHkuCisvLyBDYWxsIHRoaXMgbWV0aG9kIHdoZW5ldmVyIHlvdSB3YW50 IHRvIGluc3RhbGwgYSBzaWduYWwgaGFuZGxlci4gVGhpcyBmdW5jdGlvbiBuZWVkcyB0byBiZSBj YWxsZWQKKy8vIGJlZm9yZSBnX3d0ZkNvbmZpZyBpcyBmcm96ZW4uIEFmdGVyIHRoZSBnX3d0ZkNv bmZpZyBpcyBmcm96ZW4sIG5vIGFkZGl0aW9uYWwgc2lnbmFsIGhhbmRsZXJzIG1heQorLy8gYmUg aW5zdGFsbGVkLiBBbnkgYXR0ZW1wdCB0byBkbyBzbyB3aWxsIHRyaWdnZXIgYSBjcmFzaC4KIC8v IE5vdGU6IFlvdXIgc2lnbmFsIGhhbmRsZXIgd2lsbCBiZSBjYWxsZWQgZXZlcnkgdGltZSB0aGUg aGFuZGxlciBmb3IgdGhlIGRlc2lyZWQgc2lnbmFsIGlzIGNhbGxlZC4KIC8vIFRodXMgaXQgaXMg eW91ciByZXNwb25zaWJpbGl0eSB0byBkaXNjZXJuIGlmIHRoZSBzaWduYWwgZmlyZWQgd2FzIHlv dXJzLgotLy8gVGhpcyBmdW5jdGlvbiBpcyBjdXJyZW50bHkgYSBvbmUgd2F5IHN0cmVldCBpLmUu IG9uY2UgaW5zdGFsbGVkLCBhIHNpZ25hbCBoYW5kbGVyIGNhbm5vdCBiZSB1bmluc3RhbGxlZC4K Ky8vIFRoaXMgZnVuY3Rpb24gaXMgYSBvbmUgd2F5IHN0cmVldCBpLmUuIG9uY2UgaW5zdGFsbGVk LCBhIHNpZ25hbCBoYW5kbGVyIGNhbm5vdCBiZSB1bmluc3RhbGxlZC4KIFdURl9FWFBPUlRfUFJJ VkFURSB2b2lkIGluc3RhbGxTaWduYWxIYW5kbGVyKFNpZ25hbCwgU2lnbmFsSGFuZGxlciYmKTsK IAogCg== 399031 2020-05-11 11:08:35 -0700 2020-05-11 17:34:27 -0700 proposed patch. bug-211729.patch text/plain 33629 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjYxNDgxKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMzIEBA CisyMDIwLTA1LTExICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBJ bnRyb2R1Y2UgV1RGOjpDb25maWcgYW5kIHB1dCBTaWduYWwuY3BwJ3MgaW5pdC1vbmNlIGdsb2Jh bHMgaW4gaXQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMTE3MjkKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzYyOTM4ODc4PgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIDEuIEluaXRpYWxpemUgVk1UcmFw cycgc2lnbmFscyBlYXJseSBub3QgdGhhdCB3ZSdsbCBiZSBmcmVlemluZyBzaWduYWxzIGF0IHRo ZSBlbmQKKyAgICAgICAgICAgb2YgdGhlIGZpcnN0IFZNIGluaXRpYWxpemF0aW9uLgorCisgICAg ICAgIDIuIE1vdmUgdGhlICFpbml0aWFsaXplVGhyZWFkaW5nSGFzQmVlbkNhbGxlZCBSRUxFQVNF X0FTU0VSVCBpbiBpbml0aWFsaXplVGhyZWFkaW5nKCkKKyAgICAgICAgICAgdG8gdGhlIGJvdHRv bSBvZiB0aGUgZnVuY3Rpb24uICBUaGlzIHdheSwgd2UnbGwgYWxzbyBjYXRjaCBidWdzIHdoaWNo IG1heSBjYXVzZQorICAgICAgICAgICB1cyB0byBqdW1wIGludG8gdGhlIG1pZGRsZSBvZiB0aGUg ZnVuY3Rpb24uCisKKyAgICAgICAgICAgQWRkZWQgYSBsb2FkU3RvcmVGZW5jZSB0aGVyZSB0byBl bnN1cmUgdGhhdCB0aGUgUkVMRUFTRV9BU1NFUlQgaXMgb25seSBleGVjdXRlZAorICAgICAgICAg ICBhZnRlciBhbGwgaW5pdGlhbGl6YXRpb24gaXMgZG9uZS4gIFRoaXMgZ3VhcmFudGVlcyB0aGF0 IGl0IHdpbGwgb25seSBiZSBleGVjdXRlZAorICAgICAgICAgICBhdCB0aGUgZW5kLgorCisgICAg ICAgIDMuIENhbGwgV1RGOjpDb25maWc6OnBlcm1hbmVudGx5RnJlZXplKCkgZnJvbSBKU0M6OkNv bmZpZzo6cGVybWFuZW50bHlGcmVlemUoKQorICAgICAgICAgICBmb3Igb2J2aW91cyByZWFzb25z OiBmcmVlemluZyBvbmUgc2hvdWxkIGZyZWV6ZSB0aGUgb3RoZXIuCisKKyAgICAgICAgKiBydW50 aW1lL0luaXRpYWxpemVUaHJlYWRpbmcuY3BwOgorICAgICAgICAoSlNDOjppbml0aWFsaXplVGhy ZWFkaW5nKToKKyAgICAgICAgKiBydW50aW1lL0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6 OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUpOgorICAgICAgICAqIHJ1bnRpbWUvVk1UcmFwcy5j cHA6CisgICAgICAgIChKU0M6OlZNVHJhcHM6OmluaXRpYWxpemVTaWduYWxzKToKKyAgICAgICAg KiBydW50aW1lL1ZNVHJhcHMuaDoKKwogMjAyMC0wNS0xMCAgUm9zcyBLaXJzbGluZyAgPHJvc3Mu a2lyc2xpbmdAc29ueS5jb20+CiAKICAgICAgICAgW2NsYW5nLXRpZHldIFJ1biBtb2Rlcm5pemUt dXNlLW51bGxwdHIgb3ZlciBKU0MKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0luaXRpYWxpemVUaHJlYWRpbmcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0luaXRpYWxpemVUaHJlYWRpbmcuY3BwCShyZXZpc2lvbiAyNjE0NjkpCisr KyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Jbml0aWFsaXplVGhyZWFkaW5nLmNwcAko d29ya2luZyBjb3B5KQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDgt MjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIw MDgtMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKQEAgLTQ0LDYgKzQ0LDcgQEAKICNpbmNsdWRlICJTaWdpbGxDcmFzaEFu YWx5emVyLmgiCiAjaW5jbHVkZSAiU3RydWN0dXJlSURUYWJsZS5oIgogI2luY2x1ZGUgIlN1cGVy U2FtcGxlci5oIgorI2luY2x1ZGUgIlZNVHJhcHMuaCIKICNpbmNsdWRlICJXYXNtQ2FsbGVlUmVn aXN0cnkuaCIKICNpbmNsdWRlICJXYXNtQ2FwYWJpbGl0aWVzLmgiCiAjaW5jbHVkZSAiV2FzbVRo dW5rcy5oIgpAQCAtNjQsOSArNjUsNiBAQCB2b2lkIGluaXRpYWxpemVUaHJlYWRpbmcoKQogICAg IHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBpbml0aWFsaXplVGhyZWFkaW5nT25jZUZsYWc7CiAKICAg ICBzdGQ6OmNhbGxfb25jZShpbml0aWFsaXplVGhyZWFkaW5nT25jZUZsYWcsIFtdewotICAgICAg ICBSRUxFQVNFX0FTU0VSVCghZ19qc2NDb25maWcuaW5pdGlhbGl6ZVRocmVhZGluZ0hhc0JlZW5D YWxsZWQpOwotICAgICAgICBnX2pzY0NvbmZpZy5pbml0aWFsaXplVGhyZWFkaW5nSGFzQmVlbkNh bGxlZCA9IHRydWU7Ci0KICAgICAgICAgV1RGOjppbml0aWFsaXplVGhyZWFkaW5nKCk7CiAgICAg ICAgIE9wdGlvbnM6OmluaXRpYWxpemUoKTsKIApAQCAtMTA1LDYgKzEwMywxMSBAQCB2b2lkIGlu aXRpYWxpemVUaHJlYWRpbmcoKQogICAgICAgICAvLyBKU0xvY2s6OmxvY2soKSBjYW4gY2FsbCBy ZWdpc3RlclRocmVhZEZvck1hY2hFeGNlcHRpb25IYW5kbGluZygpIHdoaWNoIGNyYXNoZXMgaWYg dGhpcyBoYXMgbm90IGJlZW4gY2FsbGVkIGZpcnN0LgogICAgICAgICBXVEY6OnN0YXJ0TWFjaEV4 Y2VwdGlvbkhhbmRsZXJUaHJlYWQoKTsKICNlbmRpZgorICAgICAgICBWTVRyYXBzOjppbml0aWFs aXplU2lnbmFscygpOworCisgICAgICAgIFdURjo6c3RvcmVMb2FkRmVuY2UoKTsKKyAgICAgICAg UkVMRUFTRV9BU1NFUlQoIWdfanNjQ29uZmlnLmluaXRpYWxpemVUaHJlYWRpbmdIYXNCZWVuQ2Fs bGVkKTsKKyAgICAgICAgZ19qc2NDb25maWcuaW5pdGlhbGl6ZVRocmVhZGluZ0hhc0JlZW5DYWxs ZWQgPSB0cnVlOwogICAgIH0pOwogfQogCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9KU0NDb25maWcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9y dW50aW1lL0pTQ0NvbmZpZy5jcHAJKHJldmlzaW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI5LDYgKzI5 LDcgQEAKICNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9SZXNvdXJjZVVzYWdl Lmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorI2luY2x1ZGUgPHd0Zi9XVEZDb25m aWcuaD4KIAogI2lmIE9TKERBUldJTikKICNpbmNsdWRlIDxtYWNoL21hY2guaD4KQEAgLTU0LDYg KzU1LDggQEAgdm9pZCBDb25maWc6OmVuYWJsZVJlc3RyaWN0ZWRPcHRpb25zKCkKICAgICAKIHZv aWQgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpCiB7CisgICAgV1RGOjpDb25maWc6OnBlcm1h bmVudGx5RnJlZXplKCk7CisKICAgICBzdGF0aWMgTG9jayBjb25maWdMb2NrOwogICAgIGF1dG8g bG9ja2VyID0gaG9sZExvY2soY29uZmlnTG9jayk7CiAKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL1ZNVHJhcHMuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL1ZNVHJhcHMuY3BwCShyZXZpc2lvbiAyNjE0NjkpCisrKyBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9WTVRyYXBzLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMSw1ICsx LDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTE5OCw2 ICsxOTgsOSBAQCBwdWJsaWM6CiAgICAgU2lnbmFsU2VuZGVyKGNvbnN0IEFic3RyYWN0TG9ja2Vy JiBsb2NrZXIsIFZNJiB2bSkKICAgICAgICAgOiBCYXNlKGxvY2tlciwgdm0udHJhcHMoKS5tX2xv Y2ssIHZtLnRyYXBzKCkubV9jb25kaXRpb24uY29weVJlZigpKQogICAgICAgICAsIG1fdm0odm0p CisgICAgeyB9CisKKyAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplU2lnbmFscygpCiAgICAgewog ICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZTsKICAgICAgICAgc3RkOjpjYWxsX29u Y2Uob25jZSwgW10gewpAQCAtMjk0LDYgKzI5NywxNCBAQCBwcml2YXRlOgogCiAjZW5kaWYgLy8g RU5BQkxFKFNJR05BTF9CQVNFRF9WTV9UUkFQUykKIAordm9pZCBWTVRyYXBzOjppbml0aWFsaXpl U2lnbmFscygpCit7CisjaWYgRU5BQkxFKFNJR05BTF9CQVNFRF9WTV9UUkFQUykKKyAgICBpZiAo IU9wdGlvbnM6OnVzZVBvbGxpbmdUcmFwcygpKQorICAgICAgICBTaWduYWxTZW5kZXI6OmluaXRp YWxpemVTaWduYWxzKCk7CisjZW5kaWYKK30KKwogdm9pZCBWTVRyYXBzOjp3aWxsRGVzdHJveVZN KCkKIHsKICAgICBtX2lzU2h1dHRpbmdEb3duID0gdHJ1ZTsKSW5kZXg6IFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9WTVRyYXBzLmgJKHJldmlzaW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuaAkod29ya2luZyBjb3B5KQpAQCAtMSw1ICsxLDUg QEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTk4LDYgKzk4 LDggQEAgcHVibGljOgogICAgIH5WTVRyYXBzKCk7CiAgICAgVk1UcmFwcygpOwogCisgICAgc3Rh dGljIHZvaWQgaW5pdGlhbGl6ZVNpZ25hbHMoKTsKKwogICAgIHZvaWQgd2lsbERlc3Ryb3lWTSgp OwogCiAgICAgYm9vbCBuZWVkVHJhcEhhbmRsaW5nKCkgeyByZXR1cm4gbV9uZWVkVHJhcEhhbmRs aW5nOyB9CkluZGV4OiBTb3VyY2UvV1RGL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V1RGL0NoYW5nZUxvZwkocmV2aXNpb24gMjYxNDY5KQorKysgU291cmNlL1dURi9DaGFuZ2VMb2cJ KHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSw3NCBAQAorMjAyMC0wNS0xMSAgTWFyayBMYW0gIDxt YXJrLmxhbUBhcHBsZS5jb20+CisKKyAgICAgICAgSW50cm9kdWNlIFdURjo6Q29uZmlnIGFuZCBw dXQgU2lnbmFsLmNwcCdzIGluaXQtb25jZSBnbG9iYWxzIGluIGl0LgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjExNzI5CisgICAgICAgIDxyZGFyOi8v cHJvYmxlbS82MjkzODg3OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAxLiBBZGRlZCBXVEY6OkNvbmZpZyBmb3Igc3RvcmluZyBnbG9iYWxzIHRoYXQg ZWZmZWN0aXZlbHkgc2VydmUgYXMgY29uc3RhbnRzIGkuZQorICAgICAgICAgICB3ZSdsbCBiZSBp bml0aWFsaXppbmcgdGhlbSBvbiBib290IHVwLCBidXQgc2hvdWxkIG5vdCBoYXZlIGFueSByZWFz b24gdG8KKyAgICAgICAgICAgbW9kaWZ5IHRoZW0gbGF0ZXIuICBUaGUgV1RGOjpDb25maWcgd2ls bCBiZSBmcm96ZW4gKGFsb25nIHdpdGggSlNDOjpDb25maWcpCisgICAgICAgICAgIGF0IHRoZSBl bmQgb2YgaW5zdGFudGlhdGluZyB0aGUgZmlyc3QgVk0gaW5zdGFuY2UuCisKKyAgICAgICAgMi4g QWRkZWQgYSBDb25maWc6OkFzc2VydE5vdEZyb3plblNjb3BlIFJBSUkgb2JqZWN0IHRvIGVuc3Vy ZSB0aGF0IGluaXRpYWxpemF0aW9uCisgICAgICAgICAgIG9wZXJhdGlvbnMgdGhhdCBzaG91bGQg b25seSBiZSBjYWxsZWQgYXQgYm9vdCB0aW1lIHdpbGwgbm90IGJlIGNhbGxlZCBvbmNlIHRoZQor ICAgICAgICAgICBDb25maWcgaGFzIGJlZW4gZnJvemVuLgorCisgICAgICAgIDMuIE1vdmVkIG1v c3Qgb2YgU2lnbmFsLmNwcCdzIGdsb2JhbHMgaW50byBXVEY6OkNvbmZpZy4gIFRoZSBvbmx5IGds b2JhbHMgKG9yCisgICAgICAgICAgIHN0YXRpY3MpIG5vIG1vdmVkIGFyZSBvbmVzIHRoYXQgY2Fu bm90IGJlIG1vdmVkIGJlY2F1c2UgdGhleSByZXF1aXJlIGEKKyAgICAgICAgICAgbm9uLXRyaXZp YWwgZGVmYXVsdCBjb25zdHJ1Y3RvciAob25jZV9mbGFnKSwgb3IgYXJlIG5lZWRzIHRvIGJlIG1v ZGlmaWFibGUKKyAgICAgICAgICAgYXQgcnVudGltZSAoZS5nLiBMb2NrKS4KKworICAgICAgICAg ICBJbnN0ZWFkIG9mIGZyZWV6aW5nIHRoZSBvbmNlX2ZsYWcsIHdlIHNhbml0eSBjaGVjayB0aGUg Y2FsbF9vbmNlIGJsb2NrIHdpdGgKKyAgICAgICAgICAgdGhlIENvbmZpZzo6QXNzZXJ0Tm90RnJv emVuU2NvcGUuCisKKyAgICAgICAgNC4gU2lnbmFsSGFuZGxlciByZWNvcmRzIGFyZSBub3cgYWxs b2NhdGVkIGZyb20gYXJyYXlzIG9mIFNpZ25hbEhhbmRsZXJNZW1vcnkgaW4KKyAgICAgICAgICAg dGhlIFdURjo6Q29uZmlnLiAgVGhlIG51bWJlciBvZiBzaWduYWwgaGFuZGxlcnMgd2Ugd2lsbCBl dmVyIGluc3RhbGwgaXMgYWx3YXlzCisgICAgICAgICAgIGZpbml0ZS4gIEhlbmNlLCB0aGVyZSdz IG5vIHJlYXNvbiB0byB1c2UgYSBkeW5hbWljIGRhdGEgc3RydWN0dXJlIGxpa2UgdGhlCisgICAg ICAgICAgIExvY2tsZXNzQmFnIHRvIGhvbGQgaXQuCisKKyAgICAgICAgICAgV2UgaW50cm9kdWNl IGEgU2lnbmFsSGFuZGxlcnMgc3RydWN0IHRvIG1hbmFnZSB0aGVzZSBhcnJheXMgKGFuZCBhbGwg dGhlIG90aGVyCisgICAgICAgICAgIFNpZ25hbC5jcHAgZ2xvYmFscyB0aGF0IHdlIHdhbnQgdG8g bW92ZSB0byB0aGUgV1RGOjpDb25maWcpLiAgQW1vbmdzdCBvdGhlcgorICAgICAgICAgICB0aGlu Z3MsIFNpZ25hbEhhbmRsZXJzIHByb3ZpZGVzIHRoZSBhYnN0cmFjdGlvbnMgZm9yOgorCisgICAg ICAgICAgIGEuIGFsbG9jYXRpbmcgbWVtb3J5IGZvciB0aGUgU2lnbmFsSGFuZGxlciBpbnN0YW5j ZXMuICBTZWUgU2lnbmFsSGFuZGxlcnM6OmFsbG9jKCkuCisgICAgICAgICAgIGIuIGl0ZXJhdGlu ZyBTaWduYWxIYW5kbGVyIGluc3RhbmNlcy4gU2VlIFNpZ25hbEhhbmRsZXJzOjpmb3JFYWNoSGFu ZGxlcigpLgorCisgICAgICAgICAgIFRvIG1haW50YWluIHRoZSBzeW5jaHJvbml6YXRpb24gcHJv cGVydGllcyBvZiB0aGUgTG9ja2xlc3NCYWcsCisgICAgICAgICAgIFNpZ25hbEhhbmRsZXJzOjph bGxvYygpIHVzZXMgYSBtdXRleC4gIEluIHByYWN0aWNlLCB0aGlzIG11dGV4IHdpbGwgbmV2ZXIg YmUKKyAgICAgICAgICAgY29udGVuZGVkIG9uIGJlY2F1c2UgYWxsIHNpZ25hbCBoYW5kbGVycyBh cmUgbm93IGluc3RhbGxlZCBhdCBib290IHRpbWUgYmVmb3JlCisgICAgICAgICAgIGFueSBjb25j dXJyZW5jeSBjb21lcyBpbnRvIHBsYXkuCisKKyAgICAgICAgNS4gV2Ugbm93IGluaXRpYWxpemUg YWN0aXZlVGhyZWFkcygpIGVhZ2VybHkgdmlhIGluaXRpYWxpemVUaHJlYWRpbmcuICBJbgorICAg ICAgICAgICBkZXBsb3ltZW50cywgdGhpcyBkb2VzIG5vdCBtYXR0ZXIgYmVjYXVzZSBzaWduYWwg aGFuZGxlciBpbnN0YWxsYXRpb25zIHdpbGwKKyAgICAgICAgICAgYWx3YXlzIHRyaWdnZXIgaXRz IGluaXRpYWxpemF0aW9uLiAgSG93ZXZlciwgaW4gZGVidWdnaW5nIHVzZSBjYXNlcywgd2UgbWF5 CisgICAgICAgICAgIGVuZCB1cCBkaXNhYmxpbmcgdGhlIHVzZSBvZiBhbGwgc2lnbmFsIGhhbmRs ZXJzLiAgQXMgYSByZXN1bHQsIHdlIG5lZWQgdG8KKyAgICAgICAgICAgZG8gdGhpcyBlYWdlciBp bml0aWFsaXphdGlvbiB0byBlbnN1cmUgdGhhdCBpdCBpcyBkb25lIGJlZm9yZSB3ZSBmcmVlemUg dGhlCisgICAgICAgICAgIFdURjo6Q29uZmlnLgorCisgICAgICAgICogV1RGLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2o6CisgICAgICAgICogd3RmL0NNYWtlTGlzdHMudHh0OgorICAgICAgICAq IHd0Zi9UaHJlYWRpbmcuY3BwOgorICAgICAgICAoV1RGOjppbml0aWFsaXplVGhyZWFkaW5nKToK KyAgICAgICAgKiB3dGYvV1RGQ29uZmlnLmNwcDogQWRkZWQuCisgICAgICAgIChXVEY6OkNvbmZp Zzo6ZGlzYWJsZUZyZWV6aW5nRm9yVGVzdGluZyk6CisgICAgICAgIChXVEY6OkNvbmZpZzo6cGVy bWFuZW50bHlGcmVlemUpOgorICAgICAgICAqIHd0Zi9XVEZDb25maWcuaDogQWRkZWQuCisgICAg ICAgIChXVEY6OkNvbmZpZzo6Y29uZmlndXJlRm9yVGVzdGluZyk6CisgICAgICAgIChXVEY6OkNv bmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGU6On5Bc3NlcnROb3RGcm96ZW5TY29wZSk6CisgICAg ICAgICogd3RmL3RocmVhZHMvU2lnbmFscy5jcHA6CisgICAgICAgIChXVEY6OlNpZ25hbEhhbmRs ZXJzOjphbGxvYyk6CisgICAgICAgIChXVEY6OlNpZ25hbEhhbmRsZXJzOjpmb3JFYWNoSGFuZGxl ciBjb25zdCk6CisgICAgICAgIChXVEY6OnN0YXJ0TWFjaEV4Y2VwdGlvbkhhbmRsZXJUaHJlYWQp OgorICAgICAgICAoV1RGOjpoYW5kbGVTaWduYWxzV2l0aE1hY2gpOgorICAgICAgICAoV1RGOjpz ZXRFeGNlcHRpb25Qb3J0cyk6CisgICAgICAgIChXVEY6OmFjdGl2ZVRocmVhZHMpOgorICAgICAg ICAoV1RGOjppbnN0YWxsU2lnbmFsSGFuZGxlcik6CisgICAgICAgIChXVEY6OmpzY1NpZ25hbEhh bmRsZXIpOgorICAgICAgICAoV1RGOjpTaWduYWxIYW5kbGVyczo6aW5pdGlhbGl6ZSk6CisgICAg ICAgICogd3RmL3RocmVhZHMvU2lnbmFscy5oOgorCiAyMDIwLTA1LTEwICBEYXJpbiBBZGxlciAg PGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQgY29weSBjb25zdHJ1Y3RvciBhbmQgYXNz aWdubWVudCBvcGVyYXRvciB0byBSZWY8PgpJbmRleDogU291cmNlL1dURi9XVEYueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL1dURi54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAyNjE0NjkpCisrKyBTb3VyY2UvV1RGL1dURi54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC0xODIsNiArMTgyLDcgQEAK IAkJRTRBMEFEMzkxQTk2MjQ1NTAwNTM2REY2IC8qIFdvcmtRdWV1ZS5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNEEwQUQzNzFBOTYyNDU1MDA1MzZE RjYgLyogV29ya1F1ZXVlLmNwcCAqLzsgfTsKIAkJRTRBMEFEM0QxQTk2MjUzQzAwNTM2REY2IC8q IFdvcmtRdWV1ZUNvY29hLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEU0QTBBRDNDMUE5NjI1M0MwMDUzNkRGNiAvKiBXb3JrUXVldWVDb2NvYS5jcHAg Ki87IH07CiAJCUVCNjFFREM3MjQwOUNDQzEwMDFFRkUzNiAvKiBTeXN0ZW1UcmFjaW5nQ29jb2Eu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRUI2MUVE QzYyNDA5Q0NDMDAwMUVGRTM2IC8qIFN5c3RlbVRyYWNpbmdDb2NvYS5jcHAgKi87IH07CisJCUZF MDMyQUQyMjQ2M0U0M0IwMDEyRDdDNyAvKiBXVEZDb25maWcuY3BwIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkUwMzJBRDAyNDYzRTQzQjAwMTJEN0M3IC8q IFdURkNvbmZpZy5jcHAgKi87IH07CiAJCUZFMDVGQUZGMUZFNTAwNzUwMDA5MzIzMCAvKiBXVEZB c3NlcnRpb25zLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEZFMDVGQUZFMUZFNTAwNzUwMDA5MzIzMCAvKiBXVEZBc3NlcnRpb25zLmNwcCAqLzsgfTsK IAkJRkUxRTJDM0IyMjQwQzA2NjAwRjZCNzI5IC8qIFB0clRhZy5jcHAgaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRTFFMkMzOTIyNDBDMDU0MDBGNkI3Mjkg LyogUHRyVGFnLmNwcCAqLzsgfTsKIAkJRkUxRTJDNDIyMjQxODdDNjAwRjZCNzI5IC8qIFBsYXRm b3JtUmVnaXN0ZXJzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEZFMUUyQzQxMjI0MTg3QzYwMEY2QjcyOSAvKiBQbGF0Zm9ybVJlZ2lzdGVycy5jcHAg Ki87IH07CkBAIC03MzgsNiArNzM5LDggQEAKIAkJRUJGRjY3RkMyNDBEN0Q2NjAwNzhGRjFCIC8q IE9TVmFyaWFudFNQSS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBPU1Zhcmlh bnRTUEkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRUY3RDZDRDU5RDg2NDJBOEEw REE4NkFEIC8qIFN0YWNrVHJhY2UuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g U3RhY2tUcmFjZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNzJCQkRCMTA3RkE0 MjQ4ODYxNzhCOUUgLyogU3ltYm9sSW1wbC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBTeW1ib2xJbXBsLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ RkUwMzJBRDAyNDYzRTQzQjAwMTJEN0M3IC8qIFdURkNvbmZpZy5jcHAgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBXVEZDb25maWcuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQlGRTAzMkFEMTI0NjNFNDNCMDAxMkQ3QzcgLyogV1RGQ29uZmlnLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdURkNvbmZpZy5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlGRTA1RkFFNjFGREIyMTQzMDAwOTMyMzAgLyogRHVtYlB0clRyYWl0cy5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBEdW1iUHRyVHJhaXRzLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFMDVGQUZFMUZFNTAwNzUwMDA5MzIzMCAvKiBXVEZB c3NlcnRpb25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdURkFz c2VydGlvbnMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRTFENkQ4NzIzNzQw MUNEMDA3QTVDMjYgLyogU3RhY2tDaGVjay5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBTdGFja0NoZWNrLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xMzA0LDYg KzEzMDcsOCBAQAogCQkJCUU0QTBBRDM3MUE5NjI0NTUwMDUzNkRGNiAvKiBXb3JrUXVldWUuY3Bw ICovLAogCQkJCUU0QTBBRDM4MUE5NjI0NTUwMDUzNkRGNiAvKiBXb3JrUXVldWUuaCAqLywKIAkJ CQlGRTA1RkFGRTFGRTUwMDc1MDAwOTMyMzAgLyogV1RGQXNzZXJ0aW9ucy5jcHAgKi8sCisJCQkJ RkUwMzJBRDAyNDYzRTQzQjAwMTJEN0M3IC8qIFdURkNvbmZpZy5jcHAgKi8sCisJCQkJRkUwMzJB RDEyNDYzRTQzQjAwMTJEN0M3IC8qIFdURkNvbmZpZy5oICovLAogCQkJCUEzNkUxNkY3MjE2RkY4 MjgwMDhERDg3RSAvKiBXVEZTZW1hcGhvcmUuaCAqLywKIAkJCSk7CiAJCQlwYXRoID0gd3RmOwpA QCAtMTc2MSw2ICsxNzY2LDcgQEAKIAkJCQlBOEE0NzQ2OTE1MUE4MjVCMDA0MTIzRkYgLyogVVRG OENvbnZlcnNpb24uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0FGRUM2QjExRUIyMkI1OTAwREFE RTM2IC8qIFVVSUQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTMxNDlBMzkyMjhCQjQzNTAwQkZB NkM3IC8qIFZlY3Rvci5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlGRTAzMkFEMjI0NjNFNDNCMDAx MkQ3QzcgLyogV1RGQ29uZmlnLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTBGNjZCMjkyMURDOTdC QUIwMDRBMUQzRiAvKiBXYWxsVGltZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkxRkE0N0M4QTE1 MjUwMkRBMDA1NjhEMUIgLyogV2ViQ29yZVRocmVhZC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkw RkU0NDc5QzFCN0FBQTAzMDA5NDk4RUIgLyogV29yZExvY2suY3BwIGluIFNvdXJjZXMgKi8sCklu ZGV4OiBTb3VyY2UvV1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAkocmV2aXNpb24gMjYxNDY5KQorKysgU291cmNlL1dURi93 dGYvQ01ha2VMaXN0cy50eHQJKHdvcmtpbmcgY29weSkKQEAgLTI4NCw2ICsyODQsNyBAQCBzZXQo V1RGX1BVQkxJQ19IRUFERVJTCiAgICAgVmVjdG9yLmgKICAgICBWZWN0b3JIYXNoLmgKICAgICBW ZWN0b3JUcmFpdHMuaAorICAgIFdURkNvbmZpZy5oCiAgICAgV1RGU2VtYXBob3JlLmgKICAgICBX YWxsVGltZS5oCiAgICAgV2Vha0hhc2hTZXQuaApAQCAtNDQ1LDYgKzQ0Niw3IEBAIHNldChXVEZf U09VUkNFUwogICAgIFVuaXF1ZUFycmF5LmNwcAogICAgIFZlY3Rvci5jcHAKICAgICBXVEZBc3Nl cnRpb25zLmNwcAorICAgIFdURkNvbmZpZy5jcHAKICAgICBXYWxsVGltZS5jcHAKICAgICBXb3Jk TG9jay5jcHAKICAgICBXb3JrUXVldWUuY3BwCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9UaHJlYWRp bmcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAJKHJldmlz aW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTM2LDggKzM2LDEwIEBACiAjaW5jbHVkZSA8d3RmL1RocmVhZEdyb3VwLmg+CiAjaW5j bHVkZSA8d3RmL1RocmVhZE1lc3NhZ2UuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nUHJpbWl0 aXZlcy5oPgorI2luY2x1ZGUgPHd0Zi9XVEZDb25maWcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9B dG9tU3RyaW5nVGFibGUuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdWaWV3Lmg+CisjaW5j bHVkZSA8d3RmL3RocmVhZHMvU2lnbmFscy5oPgogCiAjaWYgSEFWRShRT1NfQ0xBU1NFUykKICNp bmNsdWRlIDxibWFsbG9jL2JtYWxsb2MuaD4KQEAgLTM2MCwxMiArMzYyLDE2IEBAIHZvaWQgaW5p dGlhbGl6ZVRocmVhZGluZygpCiB7CiAgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9uY2VLZXk7 CiAgICAgc3RkOjpjYWxsX29uY2Uob25jZUtleSwgW10geworICAgICAgICBDb25maWc6OkFzc2Vy dE5vdEZyb3plblNjb3BlIGFzc2VydFNjb3BlOwogICAgICAgICBpbml0aWFsaXplUmFuZG9tTnVt YmVyR2VuZXJhdG9yKCk7CiAjaWYgIUhBVkUoRkFTVF9UTFMpICYmICFPUyhXSU5ET1dTKQogICAg ICAgICBUaHJlYWQ6OmluaXRpYWxpemVUTFNLZXkoKTsKICNlbmRpZgogICAgICAgICBpbml0aWFs aXplRGF0ZXMoKTsKICAgICAgICAgVGhyZWFkOjppbml0aWFsaXplUGxhdGZvcm1UaHJlYWRpbmco KTsKKyNpZiBVU0UoUFRIUkVBRFMpICYmIEhBVkUoTUFDSElORV9DT05URVhUKQorICAgICAgICBT aWduYWxIYW5kbGVyczo6aW5pdGlhbGl6ZSgpOworI2VuZGlmCiAgICAgfSk7CiB9CiAKSW5kZXg6 IFNvdXJjZS9XVEYvd3RmL1dURkNvbmZpZy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93 dGYvV1RGQ29uZmlnLmNwcAkobm9uZXhpc3RlbnQpCisrKyBTb3VyY2UvV1RGL3d0Zi9XVEZDb25m aWcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsNzggQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVk ZSA8d3RmL1dURkNvbmZpZy5oPgorCisjaW5jbHVkZSA8d3RmL0xvY2suaD4KKyNpbmNsdWRlIDx3 dGYvUmVzb3VyY2VVc2FnZS5oPgorI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KKworI2lm IE9TKERBUldJTikKKyNpbmNsdWRlIDxtYWNoL21hY2guaD4KKyNlbGlmIE9TKExJTlVYKQorI2lu Y2x1ZGUgPHN5cy9tbWFuLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIFdURiB7CisKK2FsaWduYXMo Q29uZmlnU2l6ZVRvUHJvdGVjdCkgV1RGX0VYUE9SVF9QUklWQVRFIENvbmZpZyBnX3d0ZkNvbmZp ZzsKKwordm9pZCBDb25maWc6OmRpc2FibGVGcmVlemluZ0ZvclRlc3RpbmcoKQoreworICAgIFJF TEVBU0VfQVNTRVJUKCFnX3d0ZkNvbmZpZy5pc1Blcm1hbmVudGx5RnJvemVuKTsKKyAgICBnX3d0 ZkNvbmZpZy5kaXNhYmxlZEZyZWV6aW5nRm9yVGVzdGluZyA9IHRydWU7Cit9CisKK3ZvaWQgQ29u ZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpCit7CisgICAgc3RhdGljIExvY2sgY29uZmlnTG9jazsK KyAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKGNvbmZpZ0xvY2spOworCisgICAgUkVMRUFTRV9B U1NFUlQocm91bmRVcFRvTXVsdGlwbGVPZihwYWdlU2l6ZSgpLCBDb25maWdTaXplVG9Qcm90ZWN0 KSA9PSBDb25maWdTaXplVG9Qcm90ZWN0KTsKKworICAgIGlmICghZ193dGZDb25maWcuaXNQZXJt YW5lbnRseUZyb3plbikKKyAgICAgICAgZ193dGZDb25maWcuaXNQZXJtYW5lbnRseUZyb3plbiA9 IHRydWU7CisKKyAgICBpbnQgcmVzdWx0ID0gMDsKKyNpZiBPUyhEQVJXSU4pCisgICAgZW51bSB7 CisgICAgICAgIEFsbG93UGVybWlzc2lvbkNoYW5nZXNBZnRlclRoaXMgPSBmYWxzZSwKKyAgICAg ICAgRGlzYWxsb3dQZXJtaXNzaW9uQ2hhbmdlc0FmdGVyVGhpcyA9IHRydWUKKyAgICB9OworCisg ICAgLy8gVGhlcmUncyBubyBnb2luZyBiYWNrIG5vdyEKKyAgICByZXN1bHQgPSB2bV9wcm90ZWN0 KG1hY2hfdGFza19zZWxmKCksIHJlaW50ZXJwcmV0X2Nhc3Q8dm1fYWRkcmVzc190PigmZ193dGZD b25maWcpLCBDb25maWdTaXplVG9Qcm90ZWN0LCBEaXNhbGxvd1Blcm1pc3Npb25DaGFuZ2VzQWZ0 ZXJUaGlzLCBWTV9QUk9UX1JFQUQpOworI2VsaWYgT1MoTElOVVgpCisgICAgcmVzdWx0ID0gbXBy b3RlY3QoJmdfd3RmQ29uZmlnLCBDb25maWdTaXplVG9Qcm90ZWN0LCBQUk9UX1JFQUQpOworI2Vs aWYgT1MoV0lORE9XUykKKyAgICAvLyBGSVhNRTogSW1wbGVtZW50IGVxdWl2YWxlbnQsIG1heWJl IHdpdGggVmlydHVhbFByb3RlY3QuCisgICAgLy8gQWxzbyBuZWVkIHRvIGZpeCBXZWJLaXRUZXN0 UnVubmVyLgorI2VuZGlmCisgICAgUkVMRUFTRV9BU1NFUlQoIXJlc3VsdCk7CisgICAgUkVMRUFT RV9BU1NFUlQoZ193dGZDb25maWcuaXNQZXJtYW5lbnRseUZyb3plbik7Cit9CisKK30gLy8gbmFt ZXNwYWNlIFdURgpJbmRleDogU291cmNlL1dURi93dGYvV1RGQ29uZmlnLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dURi93dGYvV1RGQ29uZmlnLmgJKG5vbmV4aXN0ZW50KQorKysgU291cmNlL1dU Ri93dGYvV1RGQ29uZmlnLmgJKHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSw3OSBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMg SVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisj aW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvQXRvbWljcy5oPgorI2lu Y2x1ZGUgPHd0Zi9FeHBvcnRNYWNyb3MuaD4KKyNpbmNsdWRlIDx3dGYvUGFnZUJsb2NrLmg+Cisj aW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorI2luY2x1ZGUgPHd0Zi90aHJlYWRzL1NpZ25h bHMuaD4KKworbmFtZXNwYWNlIFdURiB7CisKK2NvbnN0ZXhwciBzaXplX3QgQ29uZmlnU2l6ZVRv UHJvdGVjdCA9IENlaWxpbmdPblBhZ2VTaXplOworCitzdHJ1Y3QgQ29uZmlnIHsKKyAgICBXVEZf RVhQT1JUX1BSSVZBVEUgc3RhdGljIHZvaWQgZGlzYWJsZUZyZWV6aW5nRm9yVGVzdGluZygpOwor ICAgIFdURl9FWFBPUlRfUFJJVkFURSBzdGF0aWMgdm9pZCBwZXJtYW5lbnRseUZyZWV6ZSgpOwor CisgICAgc3RydWN0IEFzc2VydE5vdEZyb3plblNjb3BlIHsKKyAgICAgICAgfkFzc2VydE5vdEZy b3plblNjb3BlKCk7CisgICAgfTsKKworICAgIHN0YXRpYyB2b2lkIGNvbmZpZ3VyZUZvclRlc3Rp bmcoKQorICAgIHsKKyAgICAgICAgZGlzYWJsZUZyZWV6aW5nRm9yVGVzdGluZygpOworICAgIH0K KworICAgIHVuaW9uIHsKKyAgICAgICAgc3RydWN0IHsKKyAgICAgICAgICAgIC8vIEFsbCB0aGUg ZmllbGRzIGluIHRoaXMgc3RydWN0IHNob3VsZCBiZSBjaG9zZW4gc3VjaCB0aGF0IHRoZWlyCisg ICAgICAgICAgICAvLyBpbml0aWFsIHZhbHVlIGlzIDAgLyBudWxsIC8gZmFsc3kgYmVjYXVzZSBD b25maWcgaXMgaW5zdGFudGlhdGVkCisgICAgICAgICAgICAvLyBhcyBhIGdsb2JhbCBzaW5nbGV0 b24uCisKKyAgICAgICAgICAgIGJvb2wgaXNQZXJtYW5lbnRseUZyb3plbjsKKyAgICAgICAgICAg IGJvb2wgZGlzYWJsZWRGcmVlemluZ0ZvclRlc3Rpbmc7CisKKyNpZiBVU0UoUFRIUkVBRFMpICYm IEhBVkUoTUFDSElORV9DT05URVhUKQorICAgICAgICAgICAgU2lnbmFsSGFuZGxlcnMgc2lnbmFs SGFuZGxlcnM7CisjZW5kaWYKKyAgICAgICAgfTsKKyAgICAgICAgY2hhciBlbnN1cmVTaXplW0Nv bmZpZ1NpemVUb1Byb3RlY3RdOworICAgIH07Cit9OworCitleHRlcm4gIkMiIGFsaWduYXMoQ29u ZmlnU2l6ZVRvUHJvdGVjdCkgV1RGX0VYUE9SVF9QUklWQVRFIENvbmZpZyBnX3d0ZkNvbmZpZzsK Kworc3RhdGljX2Fzc2VydChzaXplb2YoQ29uZmlnKSA9PSBDb25maWdTaXplVG9Qcm90ZWN0KTsK KworQUxXQVlTX0lOTElORSBDb25maWc6OkFzc2VydE5vdEZyb3plblNjb3BlOjp+QXNzZXJ0Tm90 RnJvemVuU2NvcGUoKQoreworICAgIHN0b3JlTG9hZEZlbmNlKCk7CisgICAgUkVMRUFTRV9BU1NF UlQoIWdfd3RmQ29uZmlnLmlzUGVybWFuZW50bHlGcm96ZW4pOworfTsKKworfSAvLyBuYW1lc3Bh Y2UgV1RGCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi90aHJlYWRzL1NpZ25hbHMuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XVEYvd3RmL3RocmVhZHMvU2lnbmFscy5jcHAJKHJldmlzaW9uIDI2MTQ2 OSkKKysrIFNvdXJjZS9XVEYvd3RmL3RocmVhZHMvU2lnbmFscy5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDE3IEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNy0yMDIwIEFwcGxlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAt NTEsMTQgKzUxLDMyIEBAIGV4dGVybiAiQyIgewogI2luY2x1ZGUgPHd0Zi9UaHJlYWRHcm91cC5o PgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRNZXNzYWdlLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZGlu Zy5oPgotCisjaW5jbHVkZSA8d3RmL1dURkNvbmZpZy5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIAot ICAgIAotc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxMb2NrbGVzc0JhZzxTaWduYWxIYW5kbGVy Pj4gaGFuZGxlcnNbc3RhdGljX2Nhc3Q8c2l6ZV90PihTaWduYWw6Ok51bWJlck9mU2lnbmFscyld ID0geyB9Owotc3RhdGljIHN0ZDo6b25jZV9mbGFnIGluaXRpYWxpemVPbmNlRmxhZ3Nbc3RhdGlj X2Nhc3Q8c2l6ZV90PihTaWduYWw6Ok51bWJlck9mU2lnbmFscyldOwotc3RhdGljIHN0cnVjdCBz aWdhY3Rpb24gb2xkQWN0aW9uc1tzdGF0aWNfY2FzdDxzaXplX3Q+KFNpZ25hbDo6TnVtYmVyT2ZT aWduYWxzKV07CitTaWduYWxIYW5kbGVyTWVtb3J5KiBTaWduYWxIYW5kbGVyczo6YWxsb2MoU2ln bmFsIHNpZ25hbCkKK3sKKyAgICBzdGF0aWMgTG9jayBsb2NrOworICAgIGF1dG8gbG9ja2VyID0g aG9sZExvY2sobG9jayk7CisKKyAgICBzaXplX3Qgc2lnbmFsSW5kZXggPSBzdGF0aWNfY2FzdDxz aXplX3Q+KHNpZ25hbCk7CisgICAgUkVMRUFTRV9BU1NFUlQobnVtYmVyT2ZIYW5kbGVyc1tzaWdu YWxJbmRleF0gPCBtYXhOdW1iZXJPZkhhbmRsZXJzKTsKKyAgICBzaXplX3QgbmV4dEZyZWUgPSBu dW1iZXJPZkhhbmRsZXJzW3NpZ25hbEluZGV4XSsrOworICAgIHJldHVybiAmaGFuZGxlcnNbc2ln bmFsSW5kZXhdW25leHRGcmVlXTsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgRnVuYz4KK2lubGlu ZSB2b2lkIFNpZ25hbEhhbmRsZXJzOjpmb3JFYWNoSGFuZGxlcihTaWduYWwgc2lnbmFsLCBjb25z dCBGdW5jJiBmdW5jKSBjb25zdAoreworICAgIHNpemVfdCBzaWduYWxJbmRleCA9IHN0YXRpY19j YXN0PHNpemVfdD4oc2lnbmFsKTsKKyAgICBzaXplX3QgaGFuZGxlckluZGV4ID0gbnVtYmVyT2ZI YW5kbGVyc1tzaWduYWxJbmRleF07CisgICAgd2hpbGUgKGhhbmRsZXJJbmRleC0tKSB7CisgICAg ICAgIGF1dG8qIG1lbW9yeSA9IGNvbnN0X2Nhc3Q8U2lnbmFsSGFuZGxlck1lbW9yeSo+KCZoYW5k bGVyc1tzaWduYWxJbmRleF1baGFuZGxlckluZGV4XSk7CisgICAgICAgIGNvbnN0IFNpZ25hbEhh bmRsZXImIGhhbmRsZXIgPSAqcmVpbnRlcnByZXRfY2FzdDxTaWduYWxIYW5kbGVyKj4obWVtb3J5 KTsKKyAgICAgICAgZnVuYyhoYW5kbGVyKTsKKyAgICB9Cit9CiAKICNpZiBIQVZFKE1BQ0hfRVhD RVBUSU9OUykKIC8vIFlvdSBjYW4gcmVhZCBtb3JlIGFib3V0IG1hY2ggZXhjZXB0aW9ucyBoZXJl OgpAQCAtNjYsMjcgKzg0LDI4IEBAIHN0YXRpYyBzdHJ1Y3Qgc2lnYWN0aW9uIG9sZEFjdGlvbnNb c3RhdGkKIC8vIGFuZCB0aGUgTWFjaCBpbnRlcmZhY2UgR2VuZXJhdG9yIChNaUcpIGhlcmU6CiAv LyBodHRwOi8vd3d3LmNzLmNtdS5lZHUvYWZzL2NzL3Byb2plY3QvbWFjaC9wdWJsaWMvZG9jL3Vu cHVibGlzaGVkL21pZy5wcwogCi1zdGF0aWMgbWFjaF9wb3J0X3QgZXhjZXB0aW9uUG9ydDsKIHN0 YXRpYyBjb25zdGV4cHIgc2l6ZV90IG1heE1lc3NhZ2VTaXplID0gMSAqIEtCOwogCiB2b2lkIHN0 YXJ0TWFjaEV4Y2VwdGlvbkhhbmRsZXJUaHJlYWQoKQogewogICAgIHN0YXRpYyBzdGQ6Om9uY2Vf ZmxhZyBvbmNlOwogICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2UsIFtdIHsKLSAgICAgICAga2Vybl9y ZXR1cm5fdCBrciA9IG1hY2hfcG9ydF9hbGxvY2F0ZShtYWNoX3Rhc2tfc2VsZigpLCBNQUNIX1BP UlRfUklHSFRfUkVDRUlWRSwgJmV4Y2VwdGlvblBvcnQpOworICAgICAgICBDb25maWc6OkFzc2Vy dE5vdEZyb3plblNjb3BlIGFzc2VydFNjb3BlOworICAgICAgICBTaWduYWxIYW5kbGVycyYgaGFu ZGxlcnMgPSBnX3d0ZkNvbmZpZy5zaWduYWxIYW5kbGVyczsKKyAgICAgICAga2Vybl9yZXR1cm5f dCBrciA9IG1hY2hfcG9ydF9hbGxvY2F0ZShtYWNoX3Rhc2tfc2VsZigpLCBNQUNIX1BPUlRfUklH SFRfUkVDRUlWRSwgJmhhbmRsZXJzLmV4Y2VwdGlvblBvcnQpOwogICAgICAgICBSRUxFQVNFX0FT U0VSVChrciA9PSBLRVJOX1NVQ0NFU1MpOwotICAgICAgICBrciA9IG1hY2hfcG9ydF9pbnNlcnRf cmlnaHQobWFjaF90YXNrX3NlbGYoKSwgZXhjZXB0aW9uUG9ydCwgZXhjZXB0aW9uUG9ydCwgTUFD SF9NU0dfVFlQRV9NQUtFX1NFTkQpOworICAgICAgICBrciA9IG1hY2hfcG9ydF9pbnNlcnRfcmln aHQobWFjaF90YXNrX3NlbGYoKSwgaGFuZGxlcnMuZXhjZXB0aW9uUG9ydCwgaGFuZGxlcnMuZXhj ZXB0aW9uUG9ydCwgTUFDSF9NU0dfVFlQRV9NQUtFX1NFTkQpOwogICAgICAgICBSRUxFQVNFX0FT U0VSVChrciA9PSBLRVJOX1NVQ0NFU1MpOwogCiAgICAgICAgIGRpc3BhdGNoX3NvdXJjZV90IHNv dXJjZSA9IGRpc3BhdGNoX3NvdXJjZV9jcmVhdGUoCi0gICAgICAgICAgICBESVNQQVRDSF9TT1VS Q0VfVFlQRV9NQUNIX1JFQ1YsIGV4Y2VwdGlvblBvcnQsIDAsIERJU1BBVENIX1RBUkdFVF9RVUVV RV9ERUZBVUxUKTsKKyAgICAgICAgICAgIERJU1BBVENIX1NPVVJDRV9UWVBFX01BQ0hfUkVDViwg aGFuZGxlcnMuZXhjZXB0aW9uUG9ydCwgMCwgRElTUEFUQ0hfVEFSR0VUX1FVRVVFX0RFRkFVTFQp OwogICAgICAgICBSRUxFQVNFX0FTU0VSVChzb3VyY2UpOwogCiAgICAgICAgIGRpc3BhdGNoX3Nv dXJjZV9zZXRfZXZlbnRfaGFuZGxlcihzb3VyY2UsIF57CiAgICAgICAgICAgICBVTlVTRURfUEFS QU0oc291cmNlKTsgLy8gQ2FwdHVyZSBhIHBvaW50ZXIgdG8gc291cmNlIGluIHVzZXIgc3BhY2Ug dG8gc2lsZW5jZSB0aGUgbGVha3MgdG9vbC4KIAogICAgICAgICAgICAga2Vybl9yZXR1cm5fdCBr ciA9IG1hY2hfbXNnX3NlcnZlcl9vbmNlKAotICAgICAgICAgICAgICAgIG1hY2hfZXhjX3NlcnZl ciwgbWF4TWVzc2FnZVNpemUsIGV4Y2VwdGlvblBvcnQsIE1BQ0hfTVNHX1RJTUVPVVRfTk9ORSk7 CisgICAgICAgICAgICAgICAgbWFjaF9leGNfc2VydmVyLCBtYXhNZXNzYWdlU2l6ZSwgaGFuZGxl cnMuZXhjZXB0aW9uUG9ydCwgTUFDSF9NU0dfVElNRU9VVF9OT05FKTsKICAgICAgICAgICAgIFJF TEVBU0VfQVNTRVJUKGtyID09IEtFUk5fU1VDQ0VTUyk7CiAgICAgICAgIH0pOwogCkBAIC0xNDUs NyArMTY0LDggQEAga2Vybl9yZXR1cm5fdCBjYXRjaF9tYWNoX2V4Y2VwdGlvbl9yYWlzZQogICAg IHRocmVhZF9zdGF0ZV90IG91dFN0YXRlLAogICAgIG1hY2hfbXNnX3R5cGVfbnVtYmVyX3QqIG91 dFN0YXRlQ291bnQpCiB7Ci0gICAgUkVMRUFTRV9BU1NFUlQocG9ydCA9PSBleGNlcHRpb25Qb3J0 KTsKKyAgICBTaWduYWxIYW5kbGVycyYgaGFuZGxlcnMgPSBnX3d0ZkNvbmZpZy5zaWduYWxIYW5k bGVyczsKKyAgICBSRUxFQVNFX0FTU0VSVChwb3J0ID09IGhhbmRsZXJzLmV4Y2VwdGlvblBvcnQp OwogICAgIC8vIElmIHdlIHdhbnRlZCB0byBkaXN0aW5ndWlzaCBiZXR3ZWVuIFNJR0JVUyBhbmQg U0lHU0VHViBmb3IgRVhDX0JBRF9BQ0NFU1Mgb24gRGFyd2luIHdlIGNvdWxkIGRvOgogICAgIC8v IGlmIChleGNlcHRpb25EYXRhWzBdID09IEtFUk5fSU5WQUxJRF9BRERSRVNTKQogICAgIC8vICAg IHNpZ25hbCA9IFNJR1NFR1Y7CkBAIC0xNzgsNyArMTk4LDcgQEAga2Vybl9yZXR1cm5fdCBjYXRj aF9tYWNoX2V4Y2VwdGlvbl9yYWlzZQogICAgIH0KIAogICAgIGJvb2wgZGlkSGFuZGxlID0gZmFs c2U7Ci0gICAgaGFuZGxlcnNbc3RhdGljX2Nhc3Q8c2l6ZV90PihzaWduYWwpXS0+aXRlcmF0ZShb Jl0gKGNvbnN0IFNpZ25hbEhhbmRsZXImIGhhbmRsZXIpIHsKKyAgICBoYW5kbGVycy5mb3JFYWNo SGFuZGxlcihzaWduYWwsIFsmXSAoY29uc3QgU2lnbmFsSGFuZGxlciYgaGFuZGxlcikgewogICAg ICAgICBTaWduYWxBY3Rpb24gaGFuZGxlclJlc3VsdCA9IGhhbmRsZXIoc2lnbmFsLCBpbmZvLCBy ZWdpc3RlcnMpOwogICAgICAgICBkaWRIYW5kbGUgfD0gaGFuZGxlclJlc3VsdCA9PSBTaWduYWxB Y3Rpb246OkhhbmRsZWQ7CiAgICAgfSk7CkBAIC0xODgsMjEgKzIwOCwxOCBAQCBrZXJuX3JldHVy bl90IGNhdGNoX21hY2hfZXhjZXB0aW9uX3JhaXNlCiAgICAgcmV0dXJuIEtFUk5fRkFJTFVSRTsK IH0KIAotfTsKK307IC8vIGV4dGVybiAiQyIKIAotc3RhdGljIGJvb2wgdXNlTWFjaCB7IGZhbHNl IH07CiB2b2lkIGhhbmRsZVNpZ25hbHNXaXRoTWFjaCgpCiB7Ci0gICAgdXNlTWFjaCA9IHRydWU7 CisgICAgZ193dGZDb25maWcuc2lnbmFsSGFuZGxlcnMudXNlTWFjaCA9IHRydWU7CiB9CiAKLQot ZXhjZXB0aW9uX21hc2tfdCBhY3RpdmVFeGNlcHRpb25zIHsgMCB9OwotCiBpbmxpbmUgdm9pZCBz ZXRFeGNlcHRpb25Qb3J0cyhjb25zdCBBYnN0cmFjdExvY2tlciYgdGhyZWFkR3JvdXBMb2NrZXIs IFRocmVhZCYgdGhyZWFkKQogewogICAgIFVOVVNFRF9QQVJBTSh0aHJlYWRHcm91cExvY2tlcik7 Ci0gICAga2Vybl9yZXR1cm5fdCByZXN1bHQgPSB0aHJlYWRfc2V0X2V4Y2VwdGlvbl9wb3J0cyh0 aHJlYWQubWFjaFRocmVhZCgpLCBhY3RpdmVFeGNlcHRpb25zLCBleGNlcHRpb25Qb3J0LCBFWENF UFRJT05fU1RBVEUgfCBNQUNIX0VYQ0VQVElPTl9DT0RFUywgTUFDSElORV9USFJFQURfU1RBVEUp OworICAgIFNpZ25hbEhhbmRsZXJzJiBoYW5kbGVycyA9IGdfd3RmQ29uZmlnLnNpZ25hbEhhbmRs ZXJzOworICAgIGtlcm5fcmV0dXJuX3QgcmVzdWx0ID0gdGhyZWFkX3NldF9leGNlcHRpb25fcG9y dHModGhyZWFkLm1hY2hUaHJlYWQoKSwgaGFuZGxlcnMuYWN0aXZlRXhjZXB0aW9ucywgaGFuZGxl cnMuZXhjZXB0aW9uUG9ydCwgRVhDRVBUSU9OX1NUQVRFIHwgTUFDSF9FWENFUFRJT05fQ09ERVMs IE1BQ0hJTkVfVEhSRUFEX1NUQVRFKTsKICAgICBpZiAocmVzdWx0ICE9IEtFUk5fU1VDQ0VTUykg ewogICAgICAgICBkYXRhTG9nTG4oInRocmVhZCBzZXQgcG9ydCBmYWlsZWQgZHVlIHRvICIsIG1h Y2hfZXJyb3Jfc3RyaW5nKHJlc3VsdCkpOwogICAgICAgICBDUkFTSCgpOwpAQCAtMjE0LDYgKzIz MSw3IEBAIHN0YXRpYyBUaHJlYWRHcm91cCYgYWN0aXZlVGhyZWFkcygpCiAgICAgc3RhdGljIHN0 ZDo6b25jZV9mbGFnIGluaXRpYWxpemVLZXk7CiAgICAgc3RhdGljIFRocmVhZEdyb3VwKiBhY3Rp dmVUaHJlYWRzUHRyID0gbnVsbHB0cjsKICAgICBzdGQ6OmNhbGxfb25jZShpbml0aWFsaXplS2V5 LCBbJl0geworICAgICAgICBDb25maWc6OkFzc2VydE5vdEZyb3plblNjb3BlIGFzc2VydFNjb3Bl OwogICAgICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8c3RkOjpzaGFyZWRfcHRyPFRocmVhZEdy b3VwPj4gYWN0aXZlVGhyZWFkcyB7IFRocmVhZEdyb3VwOjpjcmVhdGUoKSB9OwogICAgICAgICBh Y3RpdmVUaHJlYWRzUHRyID0gYWN0aXZlVGhyZWFkcy5nZXQoKS5nZXQoKTsKICAgICB9KTsKQEAg LTI0MiwxNyArMjYwLDIyIEBAIHN0YXRpYyB2b2lkIGpzY1NpZ25hbEhhbmRsZXIoaW50LCBzaWdp bmYKIAogdm9pZCBpbnN0YWxsU2lnbmFsSGFuZGxlcihTaWduYWwgc2lnbmFsLCBTaWduYWxIYW5k bGVyJiYgaGFuZGxlcikKIHsKKyAgICBDb25maWc6OkFzc2VydE5vdEZyb3plblNjb3BlIGFzc2Vy dFNjb3BlOworICAgIFNpZ25hbEhhbmRsZXJzJiBoYW5kbGVycyA9IGdfd3RmQ29uZmlnLnNpZ25h bEhhbmRsZXJzOwogICAgIEFTU0VSVChzaWduYWwgPCBTaWduYWw6OlVua25vd24pOwogI2lmIEhB VkUoTUFDSF9FWENFUFRJT05TKQotICAgIEFTU0VSVCghdXNlTWFjaCB8fCBzaWduYWwgIT0gU2ln bmFsOjpVc3IpOworICAgIEFTU0VSVCghaGFuZGxlcnMudXNlTWFjaCB8fCBzaWduYWwgIT0gU2ln bmFsOjpVc3IpOwogCi0gICAgaWYgKHVzZU1hY2gpCisgICAgaWYgKGhhbmRsZXJzLnVzZU1hY2gp CiAgICAgICAgIHN0YXJ0TWFjaEV4Y2VwdGlvbkhhbmRsZXJUaHJlYWQoKTsKICNlbmRpZgogCisg ICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIGluaXRpYWxpemVPbmNlRmxhZ3Nbc3RhdGljX2Nhc3Q8 c2l6ZV90PihTaWduYWw6Ok51bWJlck9mU2lnbmFscyldOwogICAgIHN0ZDo6Y2FsbF9vbmNlKGlu aXRpYWxpemVPbmNlRmxhZ3Nbc3RhdGljX2Nhc3Q8c2l6ZV90PihzaWduYWwpXSwgWyZdIHsKLSAg ICAgICAgaGFuZGxlcnNbc3RhdGljX2Nhc3Q8c2l6ZV90PihzaWduYWwpXS5jb25zdHJ1Y3QoKTsK LQorICAgICAgICBDb25maWc6OkFzc2VydE5vdEZyb3plblNjb3BlIGFzc2VydFNjb3BlOworI2lm IEhBVkUoTUFDSF9FWENFUFRJT05TKQorICAgICAgICBib29sIHVzZU1hY2ggPSBoYW5kbGVycy51 c2VNYWNoOworI2VuZGlmCiAgICAgICAgIGlmICghdXNlTWFjaCkgewogICAgICAgICAgICAgc3Ry dWN0IHNpZ2FjdGlvbiBhY3Rpb247CiAgICAgICAgICAgICBhY3Rpb24uc2Ffc2lnYWN0aW9uID0g anNjU2lnbmFsSGFuZGxlcjsKQEAgLTI2MywyMCArMjg2LDIwIEBAIHZvaWQgaW5zdGFsbFNpZ25h bEhhbmRsZXIoU2lnbmFsIHNpZ25hbCwKICAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKCFyZXN1 bHQpOwogICAgICAgICAgICAgYWN0aW9uLnNhX2ZsYWdzID0gU0FfU0lHSU5GTzsKICAgICAgICAg ICAgIGF1dG8gc3lzdGVtU2lnbmFscyA9IHRvU3lzdGVtU2lnbmFsKHNpZ25hbCk7Ci0gICAgICAg ICAgICByZXN1bHQgPSBzaWdhY3Rpb24oc3RkOjpnZXQ8MD4oc3lzdGVtU2lnbmFscyksICZhY3Rp b24sICZvbGRBY3Rpb25zW29mZnNldEZvclN5c3RlbVNpZ25hbChzdGQ6OmdldDwwPihzeXN0ZW1T aWduYWxzKSldKTsKKyAgICAgICAgICAgIHJlc3VsdCA9IHNpZ2FjdGlvbihzdGQ6OmdldDwwPihz eXN0ZW1TaWduYWxzKSwgJmFjdGlvbiwgJmhhbmRsZXJzLm9sZEFjdGlvbnNbb2Zmc2V0Rm9yU3lz dGVtU2lnbmFsKHN0ZDo6Z2V0PDA+KHN5c3RlbVNpZ25hbHMpKV0pOwogICAgICAgICAgICAgaWYg KHN0ZDo6Z2V0PDE+KHN5c3RlbVNpZ25hbHMpKQotICAgICAgICAgICAgICAgIHJlc3VsdCB8PSBz aWdhY3Rpb24oKnN0ZDo6Z2V0PDE+KHN5c3RlbVNpZ25hbHMpLCAmYWN0aW9uLCAmb2xkQWN0aW9u c1tvZmZzZXRGb3JTeXN0ZW1TaWduYWwoKnN0ZDo6Z2V0PDE+KHN5c3RlbVNpZ25hbHMpKV0pOwor ICAgICAgICAgICAgICAgIHJlc3VsdCB8PSBzaWdhY3Rpb24oKnN0ZDo6Z2V0PDE+KHN5c3RlbVNp Z25hbHMpLCAmYWN0aW9uLCAmaGFuZGxlcnMub2xkQWN0aW9uc1tvZmZzZXRGb3JTeXN0ZW1TaWdu YWwoKnN0ZDo6Z2V0PDE+KHN5c3RlbVNpZ25hbHMpKV0pOwogICAgICAgICAgICAgUkVMRUFTRV9B U1NFUlQoIXJlc3VsdCk7CiAgICAgICAgIH0KLQogICAgIH0pOwogCi0gICAgaGFuZGxlcnNbc3Rh dGljX2Nhc3Q8c2l6ZV90PihzaWduYWwpXS0+YWRkKFdURk1vdmUoaGFuZGxlcikpOworICAgIFNp Z25hbEhhbmRsZXJNZW1vcnkqIG1lbW9yeSA9IGhhbmRsZXJzLmFsbG9jKHNpZ25hbCk7CisgICAg bmV3IChtZW1vcnkpIFNpZ25hbEhhbmRsZXIoV1RGTW92ZShoYW5kbGVyKSk7CiAKICNpZiBIQVZF KE1BQ0hfRVhDRVBUSU9OUykKICAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKGFjdGl2ZVRocmVh ZHMoKS5nZXRMb2NrKCkpOwotICAgIGlmICh1c2VNYWNoKSB7Ci0gICAgICAgIGFjdGl2ZUV4Y2Vw dGlvbnMgfD0gdG9NYWNoTWFzayhzaWduYWwpOworICAgIGlmIChoYW5kbGVycy51c2VNYWNoKSB7 CisgICAgICAgIGhhbmRsZXJzLmFjdGl2ZUV4Y2VwdGlvbnMgfD0gdG9NYWNoTWFzayhzaWduYWwp OwogCiAgICAgICAgIGZvciAoYXV0byYgdGhyZWFkIDogYWN0aXZlVGhyZWFkcygpLnRocmVhZHMo bG9ja2VyKSkKICAgICAgICAgICAgIHNldEV4Y2VwdGlvblBvcnRzKGxvY2tlciwgdGhyZWFkLmdl dCgpKTsKQEAgLTI4Nyw2ICszMTAsNyBAQCB2b2lkIGluc3RhbGxTaWduYWxIYW5kbGVyKFNpZ25h bCBzaWduYWwsCiB2b2lkIGpzY1NpZ25hbEhhbmRsZXIoaW50IHNpZywgc2lnaW5mb190KiBpbmZv LCB2b2lkKiB1Y29udGV4dCkKIHsKICAgICBTaWduYWwgc2lnbmFsID0gZnJvbVN5c3RlbVNpZ25h bChzaWcpOworICAgIFNpZ25hbEhhbmRsZXJzJiBoYW5kbGVycyA9IGdfd3RmQ29uZmlnLnNpZ25h bEhhbmRsZXJzOwogCiAgICAgYXV0byByZXN0b3JlRGVmYXVsdCA9IFsmXSB7CiAgICAgICAgIHN0 cnVjdCBzaWdhY3Rpb24gZGVmYXVsdEFjdGlvbjsKQEAgLTI5OSw3ICszMjMsNyBAQCB2b2lkIGpz Y1NpZ25hbEhhbmRsZXIoaW50IHNpZywgc2lnaW5mb190CiAKICAgICAvLyBUaGlzIHNob3VsZG4n dCBoYXBwZW4gYnV0IHdlIG1pZ2h0IGFzIHdlbGwgYmUgY2FyZWZ1bC4KICAgICBpZiAoc2lnbmFs ID09IFNpZ25hbDo6VW5rbm93bikgewotICAgICAgICBkYXRhTG9nTG4oIldlIHNvbWVob3cgZ290 IGNhbGxlZCBmb3IgYW4gdW5rbm93biBzaWduYWwgIiwgc2lnLCAiLCBoYWxwLiIpOworICAgICAg ICBkYXRhTG9nTG4oIldlIHNvbWVob3cgZ290IGNhbGxlZCBmb3IgYW4gdW5rbm93biBzaWduYWwg Iiwgc2lnLCAiLCBoZWxwLiIpOwogICAgICAgICByZXN0b3JlRGVmYXVsdCgpOwogICAgICAgICBy ZXR1cm47CiAgICAgfQpAQCAtMzEyLDcgKzMzNiw3IEBAIHZvaWQganNjU2lnbmFsSGFuZGxlcihp bnQgc2lnLCBzaWdpbmZvX3QKIAogICAgIGJvb2wgZGlkSGFuZGxlID0gZmFsc2U7CiAgICAgYm9v bCByZXN0b3JlRGVmYXVsdEhhbmRsZXIgPSBmYWxzZTsKLSAgICBoYW5kbGVyc1tzdGF0aWNfY2Fz dDxzaXplX3Q+KHNpZ25hbCldLT5pdGVyYXRlKFsmXSAoY29uc3QgU2lnbmFsSGFuZGxlciYgaGFu ZGxlcikgeworICAgIGhhbmRsZXJzLmZvckVhY2hIYW5kbGVyKHNpZ25hbCwgWyZdIChjb25zdCBT aWduYWxIYW5kbGVyJiBoYW5kbGVyKSB7CiAgICAgICAgIHN3aXRjaCAoaGFuZGxlcihzaWduYWws IHNpZ0luZm8sIHJlZ2lzdGVycykpIHsKICAgICAgICAgY2FzZSBTaWduYWxBY3Rpb246OkhhbmRs ZWQ6CiAgICAgICAgICAgICBkaWRIYW5kbGUgPSB0cnVlOwpAQCAtMzMxLDcgKzM1NSw3IEBAIHZv aWQganNjU2lnbmFsSGFuZGxlcihpbnQgc2lnLCBzaWdpbmZvX3QKICAgICB9CiAKICAgICB1bnNp Z25lZCBvbGRBY3Rpb25JbmRleCA9IHN0YXRpY19jYXN0PHNpemVfdD4oc2lnbmFsKSArIChzaWcg PT0gU0lHQlVTKTsKLSAgICBzdHJ1Y3Qgc2lnYWN0aW9uJiBvbGRBY3Rpb24gPSBvbGRBY3Rpb25z W3N0YXRpY19jYXN0PHNpemVfdD4ob2xkQWN0aW9uSW5kZXgpXTsKKyAgICBzdHJ1Y3Qgc2lnYWN0 aW9uJiBvbGRBY3Rpb24gPSBoYW5kbGVycy5vbGRBY3Rpb25zW3N0YXRpY19jYXN0PHNpemVfdD4o b2xkQWN0aW9uSW5kZXgpXTsKICAgICBpZiAoc2lnbmFsID09IFNpZ25hbDo6VXNyKSB7CiAgICAg ICAgIGlmIChvbGRBY3Rpb24uc2Ffc2lnYWN0aW9uKQogICAgICAgICAgICAgb2xkQWN0aW9uLnNh X3NpZ2FjdGlvbihzaWcsIGluZm8sIHVjb250ZXh0KTsKQEAgLTM0OSw2ICszNzMsMTQgQEAgdm9p ZCBqc2NTaWduYWxIYW5kbGVyKGludCBzaWcsIHNpZ2luZm9fdAogICAgIH0KIH0KIAordm9pZCBT aWduYWxIYW5kbGVyczo6aW5pdGlhbGl6ZSgpCit7CisjaWYgSEFWRShNQUNIX0VYQ0VQVElPTlMp CisgICAgLy8gRW5zdXJlIHRoYXQgd2UndmUgaW5pdGlhbGl6ZWQgdGhpcyBiZWZvcmUgZnJlZXpl IHRoZSBDb25maWcuCisgICAgYWN0aXZlVGhyZWFkcygpOworI2VuZGlmCit9CisKIH0gLy8gbmFt ZXNwYWNlIFdURgogCiAjZW5kaWYgLy8gVVNFKFBUSFJFQURTKSAmJiBIQVZFKE1BQ0hJTkVfQ09O VEVYVCkKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL3RocmVhZHMvU2lnbmFscy5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XVEYvd3RmL3RocmVhZHMvU2lnbmFscy5oCShyZXZpc2lvbiAyNjE0NjkpCisr KyBTb3VyY2UvV1RGL3d0Zi90aHJlYWRzL1NpZ25hbHMuaAkod29ya2luZyBjb3B5KQpAQCAtMSw1 ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE3LTIwMjAgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0zMCw5ICsz MCwxNCBAQAogI2luY2x1ZGUgPHNpZ25hbC5oPgogI2luY2x1ZGUgPHR1cGxlPgogI2luY2x1ZGUg PHd0Zi9GdW5jdGlvbi5oPgorI2luY2x1ZGUgPHd0Zi9Mb2NrLmg+CiAjaW5jbHVkZSA8d3RmL09w dGlvbmFsLmg+CiAjaW5jbHVkZSA8d3RmL1BsYXRmb3JtUmVnaXN0ZXJzLmg+CiAKKyNpZiBIQVZF KE1BQ0hfRVhDRVBUSU9OUykKKyNpbmNsdWRlIDxtYWNoL2V4Y2VwdGlvbl90eXBlcy5oPgorI2Vu ZGlmCisKIG5hbWVzcGFjZSBXVEYgewogCiAvLyBOb3RlIHRoYXQgU0lHVVNSMSBpcyB1c2VkIGlu IFB0aHJlYWQtYmFzZWQgcG9ydHMgZXhjZXB0IGZvciBEYXJ3aW4gdG8gc3VzcGVuZCBhbmQgcmVz dW1lIHRocmVhZHMuCkBAIC04MiwxMSArODcsMzcgQEAgc3RydWN0IFNpZ0luZm8gewogfTsKIAog dXNpbmcgU2lnbmFsSGFuZGxlciA9IEZ1bmN0aW9uPFNpZ25hbEFjdGlvbihTaWduYWwsIFNpZ0lu Zm8mLCBQbGF0Zm9ybVJlZ2lzdGVycyYpPjsKK3VzaW5nIFNpZ25hbEhhbmRsZXJNZW1vcnkgPSBz dGQ6OmFsaWduZWRfc3RvcmFnZTxzaXplb2YoU2lnbmFsSGFuZGxlciksIHN0ZDo6YWxpZ25tZW50 X29mPFNpZ25hbEhhbmRsZXI+Ojp2YWx1ZT46OnR5cGU7CisKK3N0cnVjdCBTaWduYWxIYW5kbGVy cyB7CisgICAgU2lnbmFsSGFuZGxlck1lbW9yeSogYWxsb2MoU2lnbmFsKTsKKworICAgIHN0YXRp YyB2b2lkIGluaXRpYWxpemUoKTsKKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIEZ1bmM+CisgICAg dm9pZCBmb3JFYWNoSGFuZGxlcihTaWduYWwsIGNvbnN0IEZ1bmMmKSBjb25zdDsKKworICAgIHN0 YXRpYyBjb25zdGV4cHIgc2l6ZV90IG51bWJlck9mU2lnbmFscyA9IHN0YXRpY19jYXN0PHNpemVf dD4oU2lnbmFsOjpOdW1iZXJPZlNpZ25hbHMpOworICAgIHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90 IG1heE51bWJlck9mSGFuZGxlcnMgPSAyOworCisjaWYgSEFWRShNQUNIX0VYQ0VQVElPTlMpCisg ICAgbWFjaF9wb3J0X3QgZXhjZXB0aW9uUG9ydDsKKyAgICBleGNlcHRpb25fbWFza190IGFjdGl2 ZUV4Y2VwdGlvbnM7CisgICAgYm9vbCB1c2VNYWNoOworI2VuZGlmCisgICAgdWludDhfdCBudW1i ZXJPZkhhbmRsZXJzW251bWJlck9mU2lnbmFsc107CisgICAgU2lnbmFsSGFuZGxlck1lbW9yeSBo YW5kbGVyc1tudW1iZXJPZlNpZ25hbHNdW21heE51bWJlck9mSGFuZGxlcnNdOworICAgIHN0cnVj dCBzaWdhY3Rpb24gb2xkQWN0aW9uc1tudW1iZXJPZlNpZ25hbHNdOworfTsKKworc3RhdGljX2Fz c2VydChTaWduYWxIYW5kbGVyczo6bnVtYmVyT2ZTaWduYWxzIDwgc3RkOjpudW1lcmljX2xpbWl0 czx1aW50OF90Pjo6bWF4KCkpOwogCi0vLyBDYWxsIHRoaXMgbWV0aG9kIHdoZW5ldmVyIHlvdSB3 YW50IHRvIGluc3RhbGwgYSBzaWduYWwgaGFuZGxlci4gSXQncyBvayB0byBjYWxsIHRoaXMgZnVu Y3Rpb24gbGF6aWx5LgorLy8gQ2FsbCB0aGlzIG1ldGhvZCB3aGVuZXZlciB5b3Ugd2FudCB0byBp bnN0YWxsIGEgc2lnbmFsIGhhbmRsZXIuIFRoaXMgZnVuY3Rpb24gbmVlZHMgdG8gYmUgY2FsbGVk CisvLyBiZWZvcmUgZ193dGZDb25maWcgaXMgZnJvemVuLiBBZnRlciB0aGUgZ193dGZDb25maWcg aXMgZnJvemVuLCBubyBhZGRpdGlvbmFsIHNpZ25hbCBoYW5kbGVycyBtYXkKKy8vIGJlIGluc3Rh bGxlZC4gQW55IGF0dGVtcHQgdG8gZG8gc28gd2lsbCB0cmlnZ2VyIGEgY3Jhc2guCiAvLyBOb3Rl OiBZb3VyIHNpZ25hbCBoYW5kbGVyIHdpbGwgYmUgY2FsbGVkIGV2ZXJ5IHRpbWUgdGhlIGhhbmRs ZXIgZm9yIHRoZSBkZXNpcmVkIHNpZ25hbCBpcyBjYWxsZWQuCiAvLyBUaHVzIGl0IGlzIHlvdXIg cmVzcG9uc2liaWxpdHkgdG8gZGlzY2VybiBpZiB0aGUgc2lnbmFsIGZpcmVkIHdhcyB5b3Vycy4K LS8vIFRoaXMgZnVuY3Rpb24gaXMgY3VycmVudGx5IGEgb25lIHdheSBzdHJlZXQgaS5lLiBvbmNl IGluc3RhbGxlZCwgYSBzaWduYWwgaGFuZGxlciBjYW5ub3QgYmUgdW5pbnN0YWxsZWQuCisvLyBU aGlzIGZ1bmN0aW9uIGlzIGEgb25lIHdheSBzdHJlZXQgaS5lLiBvbmNlIGluc3RhbGxlZCwgYSBz aWduYWwgaGFuZGxlciBjYW5ub3QgYmUgdW5pbnN0YWxsZWQuCiBXVEZfRVhQT1JUX1BSSVZBVEUg dm9pZCBpbnN0YWxsU2lnbmFsSGFuZGxlcihTaWduYWwsIFNpZ25hbEhhbmRsZXImJik7CiAKIAo= 399074 2020-05-11 17:34:27 -0700 2020-05-11 17:34:27 -0700 patch for landing. bug-211729.patch text/plain 34231 mark.lam SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjYxNDgxKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMzIEBA CisyMDIwLTA1LTExICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxlLmNvbT4KKworICAgICAgICBJ bnRyb2R1Y2UgV1RGOjpDb25maWcgYW5kIHB1dCBTaWduYWwuY3BwJ3MgaW5pdC1vbmNlIGdsb2Jh bHMgaW4gaXQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMTE3MjkKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzYyOTM4ODc4PgorCisgICAgICAgIFJl dmlld2VkIGJ5IEtlaXRoIE1pbGxlciBhbmQgU2FhbSBCYXJhdGkuCisKKyAgICAgICAgMS4gSW5p dGlhbGl6ZSBWTVRyYXBzJyBzaWduYWxzIGVhcmx5IG5vdyB0aGF0IHdlJ2xsIGJlIGZyZWV6aW5n IHNpZ25hbHMgYXQgdGhlIGVuZAorICAgICAgICAgICBvZiB0aGUgZmlyc3QgVk0gaW5pdGlhbGl6 YXRpb24uCisKKyAgICAgICAgMi4gTW92ZSB0aGUgIWluaXRpYWxpemVUaHJlYWRpbmdIYXNCZWVu Q2FsbGVkIFJFTEVBU0VfQVNTRVJUIGluIGluaXRpYWxpemVUaHJlYWRpbmcoKQorICAgICAgICAg ICB0byB0aGUgYm90dG9tIG9mIHRoZSBmdW5jdGlvbi4gIFRoaXMgd2F5LCB3ZSdsbCBhbHNvIGNh dGNoIGJ1Z3Mgd2hpY2ggbWF5IGNhdXNlCisgICAgICAgICAgIHVzIHRvIGp1bXAgaW50byB0aGUg bWlkZGxlIG9mIHRoZSBmdW5jdGlvbi4KKworICAgICAgICAgICBBZGRlZCBhIGNvbXBpbGVyRmVu Y2UgdGhlcmUgdG8gZW5zdXJlIHRoYXQgdGhlIFJFTEVBU0VfQVNTRVJUIGlzIG9ubHkgZXhlY3V0 ZWQKKyAgICAgICAgICAgYWZ0ZXIgYWxsIGluaXRpYWxpemF0aW9uIGlzIGRvbmUuICBUaGlzIGd1 YXJhbnRlZXMgdGhhdCBpdCB3aWxsIG9ubHkgYmUgZXhlY3V0ZWQKKyAgICAgICAgICAgYXQgdGhl IGVuZC4KKworICAgICAgICAzLiBDYWxsIFdURjo6Q29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgp IGZyb20gSlNDOjpDb25maWc6OnBlcm1hbmVudGx5RnJlZXplKCkKKyAgICAgICAgICAgZm9yIG9i dmlvdXMgcmVhc29uczogZnJlZXppbmcgb25lIHNob3VsZCBmcmVlemUgdGhlIG90aGVyLgorCisg ICAgICAgICogcnVudGltZS9Jbml0aWFsaXplVGhyZWFkaW5nLmNwcDoKKyAgICAgICAgKEpTQzo6 aW5pdGlhbGl6ZVRocmVhZGluZyk6CisgICAgICAgICogcnVudGltZS9KU0NDb25maWcuY3BwOgor ICAgICAgICAoSlNDOjpDb25maWc6OnBlcm1hbmVudGx5RnJlZXplKToKKyAgICAgICAgKiBydW50 aW1lL1ZNVHJhcHMuY3BwOgorICAgICAgICAoSlNDOjpWTVRyYXBzOjppbml0aWFsaXplU2lnbmFs cyk6CisgICAgICAgICogcnVudGltZS9WTVRyYXBzLmg6CisKIDIwMjAtMDUtMTAgIFJvc3MgS2ly c2xpbmcgIDxyb3NzLmtpcnNsaW5nQHNvbnkuY29tPgogCiAgICAgICAgIFtjbGFuZy10aWR5XSBS dW4gbW9kZXJuaXplLXVzZS1udWxscHRyIG92ZXIgSlNDCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9Jbml0aWFsaXplVGhyZWFkaW5nLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Jbml0aWFsaXplVGhyZWFkaW5nLmNwcAkocmV2aXNp b24gMjYxNDY5KQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSW5pdGlhbGl6ZVRo cmVhZGluZy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJp Z2h0IChDKSAyMDA4LTIwMTkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29w eXJpZ2h0IChDKSAyMDA4LTIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoK ICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC00NCw2ICs0NCw3IEBACiAjaW5jbHVkZSAi U2lnaWxsQ3Jhc2hBbmFseXplci5oIgogI2luY2x1ZGUgIlN0cnVjdHVyZUlEVGFibGUuaCIKICNp bmNsdWRlICJTdXBlclNhbXBsZXIuaCIKKyNpbmNsdWRlICJWTVRyYXBzLmgiCiAjaW5jbHVkZSAi V2FzbUNhbGxlZVJlZ2lzdHJ5LmgiCiAjaW5jbHVkZSAiV2FzbUNhcGFiaWxpdGllcy5oIgogI2lu Y2x1ZGUgIldhc21UaHVua3MuaCIKQEAgLTY0LDkgKzY1LDYgQEAgdm9pZCBpbml0aWFsaXplVGhy ZWFkaW5nKCkKICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgaW5pdGlhbGl6ZVRocmVhZGluZ09u Y2VGbGFnOwogCiAgICAgc3RkOjpjYWxsX29uY2UoaW5pdGlhbGl6ZVRocmVhZGluZ09uY2VGbGFn LCBbXXsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoIWdfanNjQ29uZmlnLmluaXRpYWxpemVUaHJl YWRpbmdIYXNCZWVuQ2FsbGVkKTsKLSAgICAgICAgZ19qc2NDb25maWcuaW5pdGlhbGl6ZVRocmVh ZGluZ0hhc0JlZW5DYWxsZWQgPSB0cnVlOwotCiAgICAgICAgIFdURjo6aW5pdGlhbGl6ZVRocmVh ZGluZygpOwogICAgICAgICBPcHRpb25zOjppbml0aWFsaXplKCk7CiAKQEAgLTEwNSw2ICsxMDMs MTEgQEAgdm9pZCBpbml0aWFsaXplVGhyZWFkaW5nKCkKICAgICAgICAgLy8gSlNMb2NrOjpsb2Nr KCkgY2FuIGNhbGwgcmVnaXN0ZXJUaHJlYWRGb3JNYWNoRXhjZXB0aW9uSGFuZGxpbmcoKSB3aGlj aCBjcmFzaGVzIGlmIHRoaXMgaGFzIG5vdCBiZWVuIGNhbGxlZCBmaXJzdC4KICAgICAgICAgV1RG OjpzdGFydE1hY2hFeGNlcHRpb25IYW5kbGVyVGhyZWFkKCk7CiAjZW5kaWYKKyAgICAgICAgVk1U cmFwczo6aW5pdGlhbGl6ZVNpZ25hbHMoKTsKKworICAgICAgICBXVEY6OmNvbXBpbGVyRmVuY2Uo KTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoIWdfanNjQ29uZmlnLmluaXRpYWxpemVUaHJlYWRp bmdIYXNCZWVuQ2FsbGVkKTsKKyAgICAgICAgZ19qc2NDb25maWcuaW5pdGlhbGl6ZVRocmVhZGlu Z0hhc0JlZW5DYWxsZWQgPSB0cnVlOwogICAgIH0pOwogfQogCkluZGV4OiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAJKHJldmlzaW9uIDI2MTQ2OSkKKysrIFNv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9S ZXNvdXJjZVVzYWdlLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorI2luY2x1ZGUg PHd0Zi9XVEZDb25maWcuaD4KIAogI2lmIE9TKERBUldJTikKICNpbmNsdWRlIDxtYWNoL21hY2gu aD4KQEAgLTU0LDYgKzU1LDggQEAgdm9pZCBDb25maWc6OmVuYWJsZVJlc3RyaWN0ZWRPcHRpb25z KCkKICAgICAKIHZvaWQgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpCiB7CisgICAgV1RGOjpD b25maWc6OnBlcm1hbmVudGx5RnJlZXplKCk7CisKICAgICBzdGF0aWMgTG9jayBjb25maWdMb2Nr OwogICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2soY29uZmlnTG9jayk7CiAKSW5kZXg6IFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuY3BwCShyZXZpc2lvbiAyNjE0NjkpCisr KyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTVRyYXBzLmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOSBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKQEAgLTE5OCw2ICsxOTgsOSBAQCBwdWJsaWM6CiAgICAgU2lnbmFsU2VuZGVyKGNvbnN0IEFi c3RyYWN0TG9ja2VyJiBsb2NrZXIsIFZNJiB2bSkKICAgICAgICAgOiBCYXNlKGxvY2tlciwgdm0u dHJhcHMoKS5tX2xvY2ssIHZtLnRyYXBzKCkubV9jb25kaXRpb24uY29weVJlZigpKQogICAgICAg ICAsIG1fdm0odm0pCisgICAgeyB9CisKKyAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplU2lnbmFs cygpCiAgICAgewogICAgICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZTsKICAgICAgICAg c3RkOjpjYWxsX29uY2Uob25jZSwgW10gewpAQCAtMjk0LDYgKzI5NywxNCBAQCBwcml2YXRlOgog CiAjZW5kaWYgLy8gRU5BQkxFKFNJR05BTF9CQVNFRF9WTV9UUkFQUykKIAordm9pZCBWTVRyYXBz Ojppbml0aWFsaXplU2lnbmFscygpCit7CisjaWYgRU5BQkxFKFNJR05BTF9CQVNFRF9WTV9UUkFQ UykKKyAgICBpZiAoIU9wdGlvbnM6OnVzZVBvbGxpbmdUcmFwcygpKQorICAgICAgICBTaWduYWxT ZW5kZXI6OmluaXRpYWxpemVTaWduYWxzKCk7CisjZW5kaWYKK30KKwogdm9pZCBWTVRyYXBzOjp3 aWxsRGVzdHJveVZNKCkKIHsKICAgICBtX2lzU2h1dHRpbmdEb3duID0gdHJ1ZTsKSW5kZXg6IFNv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTVRyYXBzLmgJKHJldmlzaW9uIDI2MTQ2OSkKKysr IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNVHJhcHMuaAkod29ya2luZyBjb3B5KQpA QCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOSBBcHBsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK QEAgLTk4LDYgKzk4LDggQEAgcHVibGljOgogICAgIH5WTVRyYXBzKCk7CiAgICAgVk1UcmFwcygp OwogCisgICAgc3RhdGljIHZvaWQgaW5pdGlhbGl6ZVNpZ25hbHMoKTsKKwogICAgIHZvaWQgd2ls bERlc3Ryb3lWTSgpOwogCiAgICAgYm9vbCBuZWVkVHJhcEhhbmRsaW5nKCkgeyByZXR1cm4gbV9u ZWVkVHJhcEhhbmRsaW5nOyB9CkluZGV4OiBTb3VyY2UvV1RGL0NoYW5nZUxvZwo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvV1RGL0NoYW5nZUxvZwkocmV2aXNpb24gMjYxNDY5KQorKysgU291cmNlL1dU Ri9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSw3NCBAQAorMjAyMC0wNS0xMSAg TWFyayBMYW0gIDxtYXJrLmxhbUBhcHBsZS5jb20+CisKKyAgICAgICAgSW50cm9kdWNlIFdURjo6 Q29uZmlnIGFuZCBwdXQgU2lnbmFsLmNwcCdzIGluaXQtb25jZSBnbG9iYWxzIGluIGl0LgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjExNzI5CisgICAg ICAgIDxyZGFyOi8vcHJvYmxlbS82MjkzODg3OD4KKworICAgICAgICBSZXZpZXdlZCBieSBLZWl0 aCBNaWxsZXIgYW5kIFNhYW0gQmFyYXRpLgorCisgICAgICAgIDEuIEFkZGVkIFdURjo6Q29uZmln IGZvciBzdG9yaW5nIGdsb2JhbHMgdGhhdCBlZmZlY3RpdmVseSBzZXJ2ZSBhcyBjb25zdGFudHMg aS5lCisgICAgICAgICAgIHdlJ2xsIGJlIGluaXRpYWxpemluZyB0aGVtIGJlZm9yZSBvciBkdXJp bmcgdGhlIGZpcnN0IFZNIGluc3RhbnRpYXRpb24sIGJ1dAorICAgICAgICAgICBzaG91bGQgbm90 IGhhdmUgYW55IHJlYXNvbiB0byBtb2RpZnkgdGhlbSBsYXRlci4gIFRoZSBXVEY6OkNvbmZpZyB3 aWxsIGJlIGZyb3plbgorICAgICAgICAgICAoYWxvbmcgd2l0aCBKU0M6OkNvbmZpZykgYXQgdGhl IGVuZCBvZiBpbnN0YW50aWF0aW5nIHRoZSBmaXJzdCBWTSBpbnN0YW5jZS4KKworICAgICAgICAy LiBBZGRlZCBhIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUgUkFJSSBvYmplY3QgdG8gZW5z dXJlIHRoYXQgaW5pdGlhbGl6YXRpb24KKyAgICAgICAgICAgb3BlcmF0aW9ucyB0aGF0IHNob3Vs ZCBvbmx5IGJlIGNhbGxlZCBhdCBpbml0aWFsaXphdGlvbiB0aW1lLCB3aWxsIG5vdCBiZQorICAg ICAgICAgICBjYWxsZWQgb25jZSB0aGUgQ29uZmlnIGhhcyBiZWVuIGZyb3plbi4KKworICAgICAg ICAzLiBNb3ZlZCBtb3N0IG9mIFNpZ25hbC5jcHAncyBnbG9iYWxzIGludG8gV1RGOjpDb25maWcu ICBUaGUgb25seSBnbG9iYWxzIChvcgorICAgICAgICAgICBzdGF0aWNzKSBub3QgbW92ZWQgYXJl IG9uZXMgdGhhdCBjYW5ub3QgYmUgbW92ZWQgYmVjYXVzZSB0aGV5IHJlcXVpcmUgYQorICAgICAg ICAgICBub24tdHJpdmlhbCBkZWZhdWx0IGNvbnN0cnVjdG9yIChvbmNlX2ZsYWcpLCBvciBuZWVk IHRvIGJlIG1vZGlmaWFibGUKKyAgICAgICAgICAgYXQgcnVudGltZSAoZS5nLiBMb2NrKS4KKwor ICAgICAgICAgICBJbnN0ZWFkIG9mIGZyZWV6aW5nIHRoZSBvbmNlX2ZsYWcsIHdlIHNhbml0eSBj aGVjayB0aGUgY2FsbF9vbmNlIGJsb2NrIHdpdGgKKyAgICAgICAgICAgdGhlIENvbmZpZzo6QXNz ZXJ0Tm90RnJvemVuU2NvcGUuCisKKyAgICAgICAgNC4gU2lnbmFsSGFuZGxlciByZWNvcmRzIGFy ZSBub3cgYWxsb2NhdGVkIGZyb20gYXJyYXlzIG9mIFNpZ25hbEhhbmRsZXJNZW1vcnkgaW4KKyAg ICAgICAgICAgdGhlIFdURjo6Q29uZmlnLiAgVGhlIG51bWJlciBvZiBzaWduYWwgaGFuZGxlcnMg d2Ugd2lsbCBldmVyIGluc3RhbGwgaXMgYWx3YXlzCisgICAgICAgICAgIGZpbml0ZS4gIEhlbmNl LCB0aGVyZSdzIG5vIHJlYXNvbiB0byB1c2UgYSBkeW5hbWljIGRhdGEgc3RydWN0dXJlIGxpa2Ug dGhlCisgICAgICAgICAgIExvY2tsZXNzQmFnIHRvIGhvbGQgaXQuCisKKyAgICAgICAgICAgV2Ug aW50cm9kdWNlIGEgU2lnbmFsSGFuZGxlcnMgc3RydWN0IHRvIG1hbmFnZSB0aGVzZSBhcnJheXMg KGFuZCBhbGwgdGhlIG90aGVyCisgICAgICAgICAgIFNpZ25hbC5jcHAgZ2xvYmFscyB0aGF0IHdl IHdhbnQgdG8gbW92ZSB0byB0aGUgV1RGOjpDb25maWcpLiAgQW1vbmdzdCBvdGhlcgorICAgICAg ICAgICB0aGluZ3MsIFNpZ25hbEhhbmRsZXJzIHByb3ZpZGVzIHRoZSBhYnN0cmFjdGlvbnMgZm9y OgorCisgICAgICAgICAgIGEuIGFsbG9jYXRpbmcgbWVtb3J5IGZvciB0aGUgU2lnbmFsSGFuZGxl ciBpbnN0YW5jZXMuICBTZWUgU2lnbmFsSGFuZGxlcnM6OmFsbG9jKCkuCisgICAgICAgICAgIGIu IGl0ZXJhdGluZyBTaWduYWxIYW5kbGVyIGluc3RhbmNlcy4gU2VlIFNpZ25hbEhhbmRsZXJzOjpm b3JFYWNoSGFuZGxlcigpLgorCisgICAgICAgICAgIFRvIG1haW50YWluIHRoZSBzeW5jaHJvbml6 YXRpb24gcHJvcGVydGllcyBvZiB0aGUgTG9ja2xlc3NCYWcsCisgICAgICAgICAgIFNpZ25hbEhh bmRsZXJzOjphbGxvYygpIHVzZXMgYSBtdXRleC4gIEluIHByYWN0aWNlLCB0aGlzIG11dGV4IHdp bGwgbmV2ZXIgYmUKKyAgICAgICAgICAgY29udGVuZGVkIG9uIGJlY2F1c2UgYWxsIHNpZ25hbCBo YW5kbGVycyBhcmUgbm93IGluc3RhbGxlZCBhdCBpbml0aWFsaXphdGlvbgorICAgICAgICAgICB0 aW1lIGJlZm9yZSBhbnkgY29uY3VycmVuY3kgY29tZXMgaW50byBwbGF5LgorCisgICAgICAgIDUu IFdlIG5vdyBpbml0aWFsaXplIGFjdGl2ZVRocmVhZHMoKSBlYWdlcmx5IHZpYSBpbml0aWFsaXpl VGhyZWFkaW5nLiAgSW4KKyAgICAgICAgICAgcHJvZHVjdGlvbiBjb25maWd1cmF0aW9ucywgdGhp cyBkb2VzIG5vdCBtYXR0ZXIgYmVjYXVzZSBzaWduYWwgaGFuZGxlcgorICAgICAgICAgICBpbnN0 YWxsYXRpb25zIHdpbGwgYWx3YXlzIHRyaWdnZXIgaXRzIGluaXRpYWxpemF0aW9uLiAgSG93ZXZl ciwgaW4gZGVidWdnaW5nCisgICAgICAgICAgIGNvbmZpZ3VyYXRpb25zLCB3ZSBtYXkgZW5kIHVw IGRpc2FibGluZyB0aGUgdXNlIG9mIGFsbCBzaWduYWwgaGFuZGxlcnMuICBBcyBhCisgICAgICAg ICAgIHJlc3VsdCwgd2UgbmVlZCB0byBkbyB0aGlzIGVhZ2VyIGluaXRpYWxpemF0aW9uIHRvIGVu c3VyZSB0aGF0IGl0IGlzIGRvbmUKKyAgICAgICAgICAgYmVmb3JlIHdlIGZyZWV6ZSB0aGUgV1RG OjpDb25maWcuCisKKyAgICAgICAgKiBXVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAg ICAgICAgKiB3dGYvQ01ha2VMaXN0cy50eHQ6CisgICAgICAgICogd3RmL1RocmVhZGluZy5jcHA6 CisgICAgICAgIChXVEY6OmluaXRpYWxpemVUaHJlYWRpbmcpOgorICAgICAgICAqIHd0Zi9XVEZD b25maWcuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29uZmlnOjpkaXNhYmxlRnJlZXppbmdG b3JUZXN0aW5nKToKKyAgICAgICAgKFdURjo6Q29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSk6Cisg ICAgICAgICogd3RmL1dURkNvbmZpZy5oOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29uZmlnOjpj b25maWd1cmVGb3JUZXN0aW5nKToKKyAgICAgICAgKFdURjo6Q29uZmlnOjpBc3NlcnROb3RGcm96 ZW5TY29wZTo6fkFzc2VydE5vdEZyb3plblNjb3BlKToKKyAgICAgICAgKiB3dGYvdGhyZWFkcy9T aWduYWxzLmNwcDoKKyAgICAgICAgKFdURjo6U2lnbmFsSGFuZGxlcnM6OmFsbG9jKToKKyAgICAg ICAgKFdURjo6U2lnbmFsSGFuZGxlcnM6OmZvckVhY2hIYW5kbGVyIGNvbnN0KToKKyAgICAgICAg KFdURjo6c3RhcnRNYWNoRXhjZXB0aW9uSGFuZGxlclRocmVhZCk6CisgICAgICAgIChXVEY6Omhh bmRsZVNpZ25hbHNXaXRoTWFjaCk6CisgICAgICAgIChXVEY6OnNldEV4Y2VwdGlvblBvcnRzKToK KyAgICAgICAgKFdURjo6YWN0aXZlVGhyZWFkcyk6CisgICAgICAgIChXVEY6Omluc3RhbGxTaWdu YWxIYW5kbGVyKToKKyAgICAgICAgKFdURjo6anNjU2lnbmFsSGFuZGxlcik6CisgICAgICAgIChX VEY6OlNpZ25hbEhhbmRsZXJzOjppbml0aWFsaXplKToKKyAgICAgICAgKiB3dGYvdGhyZWFkcy9T aWduYWxzLmg6CisKIDIwMjAtMDUtMTAgIERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29tPgog CiAgICAgICAgIEFkZCBjb3B5IGNvbnN0cnVjdG9yIGFuZCBhc3NpZ25tZW50IG9wZXJhdG9yIHRv IFJlZjw+CkluZGV4OiBTb3VyY2UvV1RGL1dURi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJl dmlzaW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oJKHdvcmtpbmcgY29weSkKQEAgLTE4Miw2ICsxODIsNyBAQAogCQlFNEEwQUQzOTFBOTYyNDU1 MDA1MzZERjYgLyogV29ya1F1ZXVlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEU0QTBBRDM3MUE5NjI0NTUwMDUzNkRGNiAvKiBXb3JrUXVldWUuY3Bw ICovOyB9OwogCQlFNEEwQUQzRDFBOTYyNTNDMDA1MzZERjYgLyogV29ya1F1ZXVlQ29jb2EuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRTRBMEFEM0Mx QTk2MjUzQzAwNTM2REY2IC8qIFdvcmtRdWV1ZUNvY29hLmNwcCAqLzsgfTsKIAkJRUI2MUVEQzcy NDA5Q0NDMTAwMUVGRTM2IC8qIFN5c3RlbVRyYWNpbmdDb2NvYS5jcHAgaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFQjYxRURDNjI0MDlDQ0MwMDAxRUZFMzYg LyogU3lzdGVtVHJhY2luZ0NvY29hLmNwcCAqLzsgfTsKKwkJRkUwMzJBRDIyNDYzRTQzQjAwMTJE N0M3IC8qIFdURkNvbmZpZy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBGRTAzMkFEMDI0NjNFNDNCMDAxMkQ3QzcgLyogV1RGQ29uZmlnLmNwcCAqLzsg fTsKIAkJRkUwNUZBRkYxRkU1MDA3NTAwMDkzMjMwIC8qIFdURkFzc2VydGlvbnMuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkUwNUZBRkUxRkU1MDA3 NTAwMDkzMjMwIC8qIFdURkFzc2VydGlvbnMuY3BwICovOyB9OwogCQlGRTFFMkMzQjIyNDBDMDY2 MDBGNkI3MjkgLyogUHRyVGFnLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEZFMUUyQzM5MjI0MEMwNTQwMEY2QjcyOSAvKiBQdHJUYWcuY3BwICovOyB9 OwogCQlGRTFFMkM0MjIyNDE4N0M2MDBGNkI3MjkgLyogUGxhdGZvcm1SZWdpc3RlcnMuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkUxRTJDNDEyMjQx ODdDNjAwRjZCNzI5IC8qIFBsYXRmb3JtUmVnaXN0ZXJzLmNwcCAqLzsgfTsKQEAgLTczOCw2ICs3 MzksOCBAQAogCQlFQkZGNjdGQzI0MEQ3RDY2MDA3OEZGMUIgLyogT1NWYXJpYW50U1BJLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9TVmFyaWFudFNQSS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQlFRjdENkNENTlEODY0MkE4QTBEQTg2QUQgLyogU3RhY2tUcmFj ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTdGFja1RyYWNlLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUY3MkJCREIxMDdGQTQyNDg4NjE3OEI5RSAvKiBTeW1i b2xJbXBsLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFN5bWJvbElt cGwuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlGRTAzMkFEMDI0NjNFNDNCMDAx MkQ3QzcgLyogV1RGQ29uZmlnLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IFdURkNvbmZpZy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUZFMDMyQUQx MjQ2M0U0M0IwMDEyRDdDNyAvKiBXVEZDb25maWcuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gV1RGQ29uZmlnLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFMDVG QUU2MUZEQjIxNDMwMDA5MzIzMCAvKiBEdW1iUHRyVHJhaXRzLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IER1bWJQdHJUcmFpdHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJRkUwNUZBRkUxRkU1MDA3NTAwMDkzMjMwIC8qIFdURkFzc2VydGlvbnMuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV1RGQXNzZXJ0aW9ucy5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFMUQ2RDg3MjM3NDAxQ0QwMDdBNUMyNiAvKiBTdGFj a0NoZWNrLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFN0YWNrQ2hlY2suaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTEzMDQsNiArMTMwNyw4IEBACiAJCQkJRTRB MEFEMzcxQTk2MjQ1NTAwNTM2REY2IC8qIFdvcmtRdWV1ZS5jcHAgKi8sCiAJCQkJRTRBMEFEMzgx QTk2MjQ1NTAwNTM2REY2IC8qIFdvcmtRdWV1ZS5oICovLAogCQkJCUZFMDVGQUZFMUZFNTAwNzUw MDA5MzIzMCAvKiBXVEZBc3NlcnRpb25zLmNwcCAqLywKKwkJCQlGRTAzMkFEMDI0NjNFNDNCMDAx MkQ3QzcgLyogV1RGQ29uZmlnLmNwcCAqLywKKwkJCQlGRTAzMkFEMTI0NjNFNDNCMDAxMkQ3Qzcg LyogV1RGQ29uZmlnLmggKi8sCiAJCQkJQTM2RTE2RjcyMTZGRjgyODAwOEREODdFIC8qIFdURlNl bWFwaG9yZS5oICovLAogCQkJKTsKIAkJCXBhdGggPSB3dGY7CkBAIC0xNzYxLDYgKzE3NjYsNyBA QAogCQkJCUE4QTQ3NDY5MTUxQTgyNUIwMDQxMjNGRiAvKiBVVEY4Q29udmVyc2lvbi5jcHAgaW4g U291cmNlcyAqLywKIAkJCQk3QUZFQzZCMTFFQjIyQjU5MDBEQURFMzYgLyogVVVJRC5jcHAgaW4g U291cmNlcyAqLywKIAkJCQlFMzE0OUEzOTIyOEJCNDM1MDBCRkE2QzcgLyogVmVjdG9yLmNwcCBp biBTb3VyY2VzICovLAorCQkJCUZFMDMyQUQyMjQ2M0U0M0IwMDEyRDdDNyAvKiBXVEZDb25maWcu Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMEY2NkIyOTIxREM5N0JBQjAwNEExRDNGIC8qIFdhbGxU aW1lLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTFGQTQ3QzhBMTUyNTAyREEwMDU2OEQxQiAvKiBX ZWJDb3JlVGhyZWFkLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTBGRTQ0NzlDMUI3QUFBMDMwMDk0 OThFQiAvKiBXb3JkTG9jay5jcHAgaW4gU291cmNlcyAqLywKSW5kZXg6IFNvdXJjZS9XVEYvd3Rm L0NNYWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL0NNYWtlTGlzdHMu dHh0CShyZXZpc2lvbiAyNjE0NjkpCisrKyBTb3VyY2UvV1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAko d29ya2luZyBjb3B5KQpAQCAtMjg0LDYgKzI4NCw3IEBAIHNldChXVEZfUFVCTElDX0hFQURFUlMK ICAgICBWZWN0b3IuaAogICAgIFZlY3Rvckhhc2guaAogICAgIFZlY3RvclRyYWl0cy5oCisgICAg V1RGQ29uZmlnLmgKICAgICBXVEZTZW1hcGhvcmUuaAogICAgIFdhbGxUaW1lLmgKICAgICBXZWFr SGFzaFNldC5oCkBAIC00NDUsNiArNDQ2LDcgQEAgc2V0KFdURl9TT1VSQ0VTCiAgICAgVW5pcXVl QXJyYXkuY3BwCiAgICAgVmVjdG9yLmNwcAogICAgIFdURkFzc2VydGlvbnMuY3BwCisgICAgV1RG Q29uZmlnLmNwcAogICAgIFdhbGxUaW1lLmNwcAogICAgIFdvcmRMb2NrLmNwcAogICAgIFdvcmtR dWV1ZS5jcHAKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmNwcAkocmV2aXNpb24gMjYxNDY5KQorKysgU291 cmNlL1dURi93dGYvVGhyZWFkaW5nLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzYsOCArMzYsMTAg QEAKICNpbmNsdWRlIDx3dGYvVGhyZWFkR3JvdXAuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkTWVz c2FnZS5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmdQcmltaXRpdmVzLmg+CisjaW5jbHVkZSA8 d3RmL1dURkNvbmZpZy5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L0F0b21TdHJpbmdUYWJsZS5oPgog I2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ1ZpZXcuaD4KKyNpbmNsdWRlIDx3dGYvdGhyZWFkcy9T aWduYWxzLmg+CiAKICNpZiBIQVZFKFFPU19DTEFTU0VTKQogI2luY2x1ZGUgPGJtYWxsb2MvYm1h bGxvYy5oPgpAQCAtMzYwLDEyICszNjIsMTYgQEAgdm9pZCBpbml0aWFsaXplVGhyZWFkaW5nKCkK IHsKICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZUtleTsKICAgICBzdGQ6OmNhbGxfb25j ZShvbmNlS2V5LCBbXSB7CisgICAgICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUgYXNz ZXJ0U2NvcGU7CiAgICAgICAgIGluaXRpYWxpemVSYW5kb21OdW1iZXJHZW5lcmF0b3IoKTsKICNp ZiAhSEFWRShGQVNUX1RMUykgJiYgIU9TKFdJTkRPV1MpCiAgICAgICAgIFRocmVhZDo6aW5pdGlh bGl6ZVRMU0tleSgpOwogI2VuZGlmCiAgICAgICAgIGluaXRpYWxpemVEYXRlcygpOwogICAgICAg ICBUaHJlYWQ6OmluaXRpYWxpemVQbGF0Zm9ybVRocmVhZGluZygpOworI2lmIFVTRShQVEhSRUFE UykgJiYgSEFWRShNQUNISU5FX0NPTlRFWFQpCisgICAgICAgIFNpZ25hbEhhbmRsZXJzOjppbml0 aWFsaXplKCk7CisjZW5kaWYKICAgICB9KTsKIH0KIApJbmRleDogU291cmNlL1dURi93dGYvV1RG Q29uZmlnLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9XVEZDb25maWcuY3BwCShu b25leGlzdGVudCkKKysrIFNvdXJjZS9XVEYvd3RmL1dURkNvbmZpZy5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTAsMCArMSw3MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICog SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlIDx3dGYvV1RGQ29uZmlnLmg+ CisKKyNpbmNsdWRlIDx3dGYvTG9jay5oPgorI2luY2x1ZGUgPHd0Zi9SZXNvdXJjZVVzYWdlLmg+ CisjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorCisjaWYgT1MoREFSV0lOKQorI2luY2x1 ZGUgPG1hY2gvbWFjaC5oPgorI2VsaWYgT1MoTElOVVgpCisjaW5jbHVkZSA8c3lzL21tYW4uaD4K KyNlbmRpZgorCituYW1lc3BhY2UgV1RGIHsKKworYWxpZ25hcyhDb25maWdTaXplVG9Qcm90ZWN0 KSBXVEZfRVhQT1JUX1BSSVZBVEUgQ29uZmlnIGdfd3RmQ29uZmlnOworCit2b2lkIENvbmZpZzo6 cGVybWFuZW50bHlGcmVlemUoKQoreworICAgIHN0YXRpYyBMb2NrIGNvbmZpZ0xvY2s7CisgICAg YXV0byBsb2NrZXIgPSBob2xkTG9jayhjb25maWdMb2NrKTsKKworICAgIFJFTEVBU0VfQVNTRVJU KHJvdW5kVXBUb011bHRpcGxlT2YocGFnZVNpemUoKSwgQ29uZmlnU2l6ZVRvUHJvdGVjdCkgPT0g Q29uZmlnU2l6ZVRvUHJvdGVjdCk7CisKKyAgICBpZiAoIWdfd3RmQ29uZmlnLmlzUGVybWFuZW50 bHlGcm96ZW4pCisgICAgICAgIGdfd3RmQ29uZmlnLmlzUGVybWFuZW50bHlGcm96ZW4gPSB0cnVl OworCisgICAgaW50IHJlc3VsdCA9IDA7CisjaWYgT1MoREFSV0lOKQorICAgIGVudW0geworICAg ICAgICBBbGxvd1Blcm1pc3Npb25DaGFuZ2VzQWZ0ZXJUaGlzID0gZmFsc2UsCisgICAgICAgIERp c2FsbG93UGVybWlzc2lvbkNoYW5nZXNBZnRlclRoaXMgPSB0cnVlCisgICAgfTsKKworICAgIC8v IFRoZXJlJ3Mgbm8gZ29pbmcgYmFjayBub3chCisgICAgcmVzdWx0ID0gdm1fcHJvdGVjdChtYWNo X3Rhc2tfc2VsZigpLCByZWludGVycHJldF9jYXN0PHZtX2FkZHJlc3NfdD4oJmdfd3RmQ29uZmln KSwgQ29uZmlnU2l6ZVRvUHJvdGVjdCwgRGlzYWxsb3dQZXJtaXNzaW9uQ2hhbmdlc0FmdGVyVGhp cywgVk1fUFJPVF9SRUFEKTsKKyNlbGlmIE9TKExJTlVYKQorICAgIHJlc3VsdCA9IG1wcm90ZWN0 KCZnX3d0ZkNvbmZpZywgQ29uZmlnU2l6ZVRvUHJvdGVjdCwgUFJPVF9SRUFEKTsKKyNlbGlmIE9T KFdJTkRPV1MpCisgICAgLy8gRklYTUU6IEltcGxlbWVudCBlcXVpdmFsZW50LCBtYXliZSB3aXRo IFZpcnR1YWxQcm90ZWN0LgorICAgIC8vIEFsc28gbmVlZCB0byBmaXggV2ViS2l0VGVzdFJ1bm5l ci4KKyNlbmRpZgorICAgIFJFTEVBU0VfQVNTRVJUKCFyZXN1bHQpOworICAgIFJFTEVBU0VfQVNT RVJUKGdfd3RmQ29uZmlnLmlzUGVybWFuZW50bHlGcm96ZW4pOworfQorCit9IC8vIG5hbWVzcGFj ZSBXVEYKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL1dURkNvbmZpZy5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XVEYvd3RmL1dURkNvbmZpZy5oCShub25leGlzdGVudCkKKysrIFNvdXJjZS9XVEYvd3Rm L1dURkNvbmZpZy5oCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsNzkgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycg QU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAor ICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2luY2x1 ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3RmL0F0b21pY3MuaD4KKyNpbmNsdWRl IDx3dGYvRXhwb3J0TWFjcm9zLmg+CisjaW5jbHVkZSA8d3RmL1BhZ2VCbG9jay5oPgorI2luY2x1 ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KKyNpbmNsdWRlIDx3dGYvdGhyZWFkcy9TaWduYWxzLmg+ CisKK25hbWVzcGFjZSBXVEYgeworCitjb25zdGV4cHIgc2l6ZV90IENvbmZpZ1NpemVUb1Byb3Rl Y3QgPSBDZWlsaW5nT25QYWdlU2l6ZTsKKworc3RydWN0IENvbmZpZyB7CisgICAgV1RGX0VYUE9S VF9QUklWQVRFIHN0YXRpYyB2b2lkIHBlcm1hbmVudGx5RnJlZXplKCk7CisKKyAgICBzdHJ1Y3Qg QXNzZXJ0Tm90RnJvemVuU2NvcGUgeworICAgICAgICBBc3NlcnROb3RGcm96ZW5TY29wZSgpOwor ICAgICAgICB+QXNzZXJ0Tm90RnJvemVuU2NvcGUoKTsKKyAgICB9OworCisgICAgdW5pb24gewor ICAgICAgICBzdHJ1Y3QgeworICAgICAgICAgICAgLy8gQWxsIHRoZSBmaWVsZHMgaW4gdGhpcyBz dHJ1Y3Qgc2hvdWxkIGJlIGNob3NlbiBzdWNoIHRoYXQgdGhlaXIKKyAgICAgICAgICAgIC8vIGlu aXRpYWwgdmFsdWUgaXMgMCAvIG51bGwgLyBmYWxzeSBiZWNhdXNlIENvbmZpZyBpcyBpbnN0YW50 aWF0ZWQKKyAgICAgICAgICAgIC8vIGFzIGEgZ2xvYmFsIHNpbmdsZXRvbi4KKworICAgICAgICAg ICAgYm9vbCBpc1Blcm1hbmVudGx5RnJvemVuOworCisjaWYgVVNFKFBUSFJFQURTKSAmJiBIQVZF KE1BQ0hJTkVfQ09OVEVYVCkKKyAgICAgICAgICAgIFNpZ25hbEhhbmRsZXJzIHNpZ25hbEhhbmRs ZXJzOworI2VuZGlmCisgICAgICAgIH07CisgICAgICAgIGNoYXIgZW5zdXJlU2l6ZVtDb25maWdT aXplVG9Qcm90ZWN0XTsKKyAgICB9OworfTsKKworZXh0ZXJuICJDIiBhbGlnbmFzKENvbmZpZ1Np emVUb1Byb3RlY3QpIFdURl9FWFBPUlRfUFJJVkFURSBDb25maWcgZ193dGZDb25maWc7CisKK3N0 YXRpY19hc3NlcnQoc2l6ZW9mKENvbmZpZykgPT0gQ29uZmlnU2l6ZVRvUHJvdGVjdCk7CisKK0FM V0FZU19JTkxJTkUgQ29uZmlnOjpBc3NlcnROb3RGcm96ZW5TY29wZTo6QXNzZXJ0Tm90RnJvemVu U2NvcGUoKQoreworICAgIFJFTEVBU0VfQVNTRVJUKCFnX3d0ZkNvbmZpZy5pc1Blcm1hbmVudGx5 RnJvemVuKTsKKyAgICBjb21waWxlckZlbmNlKCk7Cit9OworCitBTFdBWVNfSU5MSU5FIENvbmZp Zzo6QXNzZXJ0Tm90RnJvemVuU2NvcGU6On5Bc3NlcnROb3RGcm96ZW5TY29wZSgpCit7CisgICAg Y29tcGlsZXJGZW5jZSgpOworICAgIFJFTEVBU0VfQVNTRVJUKCFnX3d0ZkNvbmZpZy5pc1Blcm1h bmVudGx5RnJvemVuKTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdURgpJbmRleDogU291cmNlL1dU Ri93dGYvdGhyZWFkcy9TaWduYWxzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi90 aHJlYWRzL1NpZ25hbHMuY3BwCShyZXZpc2lvbiAyNjE0NjkpCisrKyBTb3VyY2UvV1RGL3d0Zi90 aHJlYWRzL1NpZ25hbHMuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAq IENvcHlyaWdodCAoQykgMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBD b3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAg KgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTUxLDE0ICs1MSw0MSBAQCBleHRlcm4g IkMiIHsKICNpbmNsdWRlIDx3dGYvVGhyZWFkR3JvdXAuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFk TWVzc2FnZS5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KLQorI2luY2x1ZGUgPHd0Zi9X VEZDb25maWcuaD4KIAogbmFtZXNwYWNlIFdURiB7CiAKLSAgICAKLXN0YXRpYyBMYXp5TmV2ZXJE ZXN0cm95ZWQ8TG9ja2xlc3NCYWc8U2lnbmFsSGFuZGxlcj4+IGhhbmRsZXJzW3N0YXRpY19jYXN0 PHNpemVfdD4oU2lnbmFsOjpOdW1iZXJPZlNpZ25hbHMpXSA9IHsgfTsKLXN0YXRpYyBzdGQ6Om9u Y2VfZmxhZyBpbml0aWFsaXplT25jZUZsYWdzW3N0YXRpY19jYXN0PHNpemVfdD4oU2lnbmFsOjpO dW1iZXJPZlNpZ25hbHMpXTsKLXN0YXRpYyBzdHJ1Y3Qgc2lnYWN0aW9uIG9sZEFjdGlvbnNbc3Rh dGljX2Nhc3Q8c2l6ZV90PihTaWduYWw6Ok51bWJlck9mU2lnbmFscyldOwordm9pZCBTaWduYWxI YW5kbGVyczo6YWRkKFNpZ25hbCBzaWduYWwsIFNpZ25hbEhhbmRsZXImJiBoYW5kbGVyKQorewor ICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUgYXNzZXJ0U2NvcGU7CisgICAgc3RhdGlj IExvY2sgbG9jazsKKyAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKGxvY2spOworCisgICAgc2l6 ZV90IHNpZ25hbEluZGV4ID0gc3RhdGljX2Nhc3Q8c2l6ZV90PihzaWduYWwpOworICAgIHNpemVf dCBuZXh0RnJlZSA9IG51bWJlck9mSGFuZGxlcnNbc2lnbmFsSW5kZXhdOworICAgIFJFTEVBU0Vf QVNTRVJUKG5leHRGcmVlIDwgbWF4TnVtYmVyT2ZIYW5kbGVycyk7CisgICAgU2lnbmFsSGFuZGxl ck1lbW9yeSogbWVtb3J5ID0gJmhhbmRsZXJzW3NpZ25hbEluZGV4XVtuZXh0RnJlZV07CisgICAg bmV3IChtZW1vcnkpIFNpZ25hbEhhbmRsZXIoV1RGTW92ZShoYW5kbGVyKSk7CisKKyAgICAvLyBX ZSBkZWxpYmVyYXRlbHkgZG8gbm90IHdhbnQgdG8gaW5jcmVtZW50IHRoZSBjb3VudCB1bnRpbCBh ZnRlciB3ZSd2ZQorICAgIC8vIGZ1bGx5IGluaXRpYWxpemVkIHRoZSBtZW1vcnkuIFRoaXMgd2F5 LCBmb3JFYWNoSGFuZGxlcigpIHdvbid0IHNlZSBhCisgICAgLy8gcGFydGlhbGx5IGluaXRpYWxp emVkIGhhbmRsZXIuCisgICAgc3RvcmVTdG9yZUZlbmNlKCk7CisgICAgbnVtYmVyT2ZIYW5kbGVy c1tzaWduYWxJbmRleF0rKzsKKyAgICBsb2FkTG9hZEZlbmNlKCk7Cit9CisKK3RlbXBsYXRlPHR5 cGVuYW1lIEZ1bmM+CitpbmxpbmUgdm9pZCBTaWduYWxIYW5kbGVyczo6Zm9yRWFjaEhhbmRsZXIo U2lnbmFsIHNpZ25hbCwgY29uc3QgRnVuYyYgZnVuYykgY29uc3QKK3sKKyAgICBzaXplX3Qgc2ln bmFsSW5kZXggPSBzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCk7CisgICAgc2l6ZV90IGhhbmRs ZXJJbmRleCA9IG51bWJlck9mSGFuZGxlcnNbc2lnbmFsSW5kZXhdOworICAgIHdoaWxlIChoYW5k bGVySW5kZXgtLSkgeworICAgICAgICBhdXRvKiBtZW1vcnkgPSBjb25zdF9jYXN0PFNpZ25hbEhh bmRsZXJNZW1vcnkqPigmaGFuZGxlcnNbc2lnbmFsSW5kZXhdW2hhbmRsZXJJbmRleF0pOworICAg ICAgICBjb25zdCBTaWduYWxIYW5kbGVyJiBoYW5kbGVyID0gKmJpdHdpc2VfY2FzdDxTaWduYWxI YW5kbGVyKj4obWVtb3J5KTsKKyAgICAgICAgZnVuYyhoYW5kbGVyKTsKKyAgICB9Cit9CiAKICNp ZiBIQVZFKE1BQ0hfRVhDRVBUSU9OUykKIC8vIFlvdSBjYW4gcmVhZCBtb3JlIGFib3V0IG1hY2gg ZXhjZXB0aW9ucyBoZXJlOgpAQCAtNjYsMjcgKzkzLDI4IEBAIHN0YXRpYyBzdHJ1Y3Qgc2lnYWN0 aW9uIG9sZEFjdGlvbnNbc3RhdGkKIC8vIGFuZCB0aGUgTWFjaCBpbnRlcmZhY2UgR2VuZXJhdG9y IChNaUcpIGhlcmU6CiAvLyBodHRwOi8vd3d3LmNzLmNtdS5lZHUvYWZzL2NzL3Byb2plY3QvbWFj aC9wdWJsaWMvZG9jL3VucHVibGlzaGVkL21pZy5wcwogCi1zdGF0aWMgbWFjaF9wb3J0X3QgZXhj ZXB0aW9uUG9ydDsKIHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IG1heE1lc3NhZ2VTaXplID0gMSAq IEtCOwogCiB2b2lkIHN0YXJ0TWFjaEV4Y2VwdGlvbkhhbmRsZXJUaHJlYWQoKQogewogICAgIHN0 YXRpYyBzdGQ6Om9uY2VfZmxhZyBvbmNlOwogICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2UsIFtdIHsK LSAgICAgICAga2Vybl9yZXR1cm5fdCBrciA9IG1hY2hfcG9ydF9hbGxvY2F0ZShtYWNoX3Rhc2tf c2VsZigpLCBNQUNIX1BPUlRfUklHSFRfUkVDRUlWRSwgJmV4Y2VwdGlvblBvcnQpOworICAgICAg ICBDb25maWc6OkFzc2VydE5vdEZyb3plblNjb3BlIGFzc2VydFNjb3BlOworICAgICAgICBTaWdu YWxIYW5kbGVycyYgaGFuZGxlcnMgPSBnX3d0ZkNvbmZpZy5zaWduYWxIYW5kbGVyczsKKyAgICAg ICAga2Vybl9yZXR1cm5fdCBrciA9IG1hY2hfcG9ydF9hbGxvY2F0ZShtYWNoX3Rhc2tfc2VsZigp LCBNQUNIX1BPUlRfUklHSFRfUkVDRUlWRSwgJmhhbmRsZXJzLmV4Y2VwdGlvblBvcnQpOwogICAg ICAgICBSRUxFQVNFX0FTU0VSVChrciA9PSBLRVJOX1NVQ0NFU1MpOwotICAgICAgICBrciA9IG1h Y2hfcG9ydF9pbnNlcnRfcmlnaHQobWFjaF90YXNrX3NlbGYoKSwgZXhjZXB0aW9uUG9ydCwgZXhj ZXB0aW9uUG9ydCwgTUFDSF9NU0dfVFlQRV9NQUtFX1NFTkQpOworICAgICAgICBrciA9IG1hY2hf cG9ydF9pbnNlcnRfcmlnaHQobWFjaF90YXNrX3NlbGYoKSwgaGFuZGxlcnMuZXhjZXB0aW9uUG9y dCwgaGFuZGxlcnMuZXhjZXB0aW9uUG9ydCwgTUFDSF9NU0dfVFlQRV9NQUtFX1NFTkQpOwogICAg ICAgICBSRUxFQVNFX0FTU0VSVChrciA9PSBLRVJOX1NVQ0NFU1MpOwogCiAgICAgICAgIGRpc3Bh dGNoX3NvdXJjZV90IHNvdXJjZSA9IGRpc3BhdGNoX3NvdXJjZV9jcmVhdGUoCi0gICAgICAgICAg ICBESVNQQVRDSF9TT1VSQ0VfVFlQRV9NQUNIX1JFQ1YsIGV4Y2VwdGlvblBvcnQsIDAsIERJU1BB VENIX1RBUkdFVF9RVUVVRV9ERUZBVUxUKTsKKyAgICAgICAgICAgIERJU1BBVENIX1NPVVJDRV9U WVBFX01BQ0hfUkVDViwgaGFuZGxlcnMuZXhjZXB0aW9uUG9ydCwgMCwgRElTUEFUQ0hfVEFSR0VU X1FVRVVFX0RFRkFVTFQpOwogICAgICAgICBSRUxFQVNFX0FTU0VSVChzb3VyY2UpOwogCiAgICAg ICAgIGRpc3BhdGNoX3NvdXJjZV9zZXRfZXZlbnRfaGFuZGxlcihzb3VyY2UsIF57CiAgICAgICAg ICAgICBVTlVTRURfUEFSQU0oc291cmNlKTsgLy8gQ2FwdHVyZSBhIHBvaW50ZXIgdG8gc291cmNl IGluIHVzZXIgc3BhY2UgdG8gc2lsZW5jZSB0aGUgbGVha3MgdG9vbC4KIAogICAgICAgICAgICAg a2Vybl9yZXR1cm5fdCBrciA9IG1hY2hfbXNnX3NlcnZlcl9vbmNlKAotICAgICAgICAgICAgICAg IG1hY2hfZXhjX3NlcnZlciwgbWF4TWVzc2FnZVNpemUsIGV4Y2VwdGlvblBvcnQsIE1BQ0hfTVNH X1RJTUVPVVRfTk9ORSk7CisgICAgICAgICAgICAgICAgbWFjaF9leGNfc2VydmVyLCBtYXhNZXNz YWdlU2l6ZSwgaGFuZGxlcnMuZXhjZXB0aW9uUG9ydCwgTUFDSF9NU0dfVElNRU9VVF9OT05FKTsK ICAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKGtyID09IEtFUk5fU1VDQ0VTUyk7CiAgICAgICAg IH0pOwogCkBAIC0xNDUsNyArMTczLDggQEAga2Vybl9yZXR1cm5fdCBjYXRjaF9tYWNoX2V4Y2Vw dGlvbl9yYWlzZQogICAgIHRocmVhZF9zdGF0ZV90IG91dFN0YXRlLAogICAgIG1hY2hfbXNnX3R5 cGVfbnVtYmVyX3QqIG91dFN0YXRlQ291bnQpCiB7Ci0gICAgUkVMRUFTRV9BU1NFUlQocG9ydCA9 PSBleGNlcHRpb25Qb3J0KTsKKyAgICBTaWduYWxIYW5kbGVycyYgaGFuZGxlcnMgPSBnX3d0ZkNv bmZpZy5zaWduYWxIYW5kbGVyczsKKyAgICBSRUxFQVNFX0FTU0VSVChwb3J0ID09IGhhbmRsZXJz LmV4Y2VwdGlvblBvcnQpOwogICAgIC8vIElmIHdlIHdhbnRlZCB0byBkaXN0aW5ndWlzaCBiZXR3 ZWVuIFNJR0JVUyBhbmQgU0lHU0VHViBmb3IgRVhDX0JBRF9BQ0NFU1Mgb24gRGFyd2luIHdlIGNv dWxkIGRvOgogICAgIC8vIGlmIChleGNlcHRpb25EYXRhWzBdID09IEtFUk5fSU5WQUxJRF9BRERS RVNTKQogICAgIC8vICAgIHNpZ25hbCA9IFNJR1NFR1Y7CkBAIC0xNzgsNyArMjA3LDcgQEAga2Vy bl9yZXR1cm5fdCBjYXRjaF9tYWNoX2V4Y2VwdGlvbl9yYWlzZQogICAgIH0KIAogICAgIGJvb2wg ZGlkSGFuZGxlID0gZmFsc2U7Ci0gICAgaGFuZGxlcnNbc3RhdGljX2Nhc3Q8c2l6ZV90PihzaWdu YWwpXS0+aXRlcmF0ZShbJl0gKGNvbnN0IFNpZ25hbEhhbmRsZXImIGhhbmRsZXIpIHsKKyAgICBo YW5kbGVycy5mb3JFYWNoSGFuZGxlcihzaWduYWwsIFsmXSAoY29uc3QgU2lnbmFsSGFuZGxlciYg aGFuZGxlcikgewogICAgICAgICBTaWduYWxBY3Rpb24gaGFuZGxlclJlc3VsdCA9IGhhbmRsZXIo c2lnbmFsLCBpbmZvLCByZWdpc3RlcnMpOwogICAgICAgICBkaWRIYW5kbGUgfD0gaGFuZGxlclJl c3VsdCA9PSBTaWduYWxBY3Rpb246OkhhbmRsZWQ7CiAgICAgfSk7CkBAIC0xODgsMjEgKzIxNywx OSBAQCBrZXJuX3JldHVybl90IGNhdGNoX21hY2hfZXhjZXB0aW9uX3JhaXNlCiAgICAgcmV0dXJu IEtFUk5fRkFJTFVSRTsKIH0KIAotfTsKK307IC8vIGV4dGVybiAiQyIKIAotc3RhdGljIGJvb2wg dXNlTWFjaCB7IGZhbHNlIH07CiB2b2lkIGhhbmRsZVNpZ25hbHNXaXRoTWFjaCgpCiB7Ci0gICAg dXNlTWFjaCA9IHRydWU7CisgICAgQ29uZmlnOjpBc3NlcnROb3RGcm96ZW5TY29wZSBhc3NlcnRT Y29wZTsKKyAgICBnX3d0ZkNvbmZpZy5zaWduYWxIYW5kbGVycy51c2VNYWNoID0gdHJ1ZTsKIH0K IAotCi1leGNlcHRpb25fbWFza190IGFjdGl2ZUV4Y2VwdGlvbnMgeyAwIH07Ci0KIGlubGluZSB2 b2lkIHNldEV4Y2VwdGlvblBvcnRzKGNvbnN0IEFic3RyYWN0TG9ja2VyJiB0aHJlYWRHcm91cExv Y2tlciwgVGhyZWFkJiB0aHJlYWQpCiB7CiAgICAgVU5VU0VEX1BBUkFNKHRocmVhZEdyb3VwTG9j a2VyKTsKLSAgICBrZXJuX3JldHVybl90IHJlc3VsdCA9IHRocmVhZF9zZXRfZXhjZXB0aW9uX3Bv cnRzKHRocmVhZC5tYWNoVGhyZWFkKCksIGFjdGl2ZUV4Y2VwdGlvbnMsIGV4Y2VwdGlvblBvcnQs IEVYQ0VQVElPTl9TVEFURSB8IE1BQ0hfRVhDRVBUSU9OX0NPREVTLCBNQUNISU5FX1RIUkVBRF9T VEFURSk7CisgICAgU2lnbmFsSGFuZGxlcnMmIGhhbmRsZXJzID0gZ193dGZDb25maWcuc2lnbmFs SGFuZGxlcnM7CisgICAga2Vybl9yZXR1cm5fdCByZXN1bHQgPSB0aHJlYWRfc2V0X2V4Y2VwdGlv bl9wb3J0cyh0aHJlYWQubWFjaFRocmVhZCgpLCBoYW5kbGVycy5hY3RpdmVFeGNlcHRpb25zLCBo YW5kbGVycy5leGNlcHRpb25Qb3J0LCBFWENFUFRJT05fU1RBVEUgfCBNQUNIX0VYQ0VQVElPTl9D T0RFUywgTUFDSElORV9USFJFQURfU1RBVEUpOwogICAgIGlmIChyZXN1bHQgIT0gS0VSTl9TVUND RVNTKSB7CiAgICAgICAgIGRhdGFMb2dMbigidGhyZWFkIHNldCBwb3J0IGZhaWxlZCBkdWUgdG8g IiwgbWFjaF9lcnJvcl9zdHJpbmcocmVzdWx0KSk7CiAgICAgICAgIENSQVNIKCk7CkBAIC0yMTQs NiArMjQxLDcgQEAgc3RhdGljIFRocmVhZEdyb3VwJiBhY3RpdmVUaHJlYWRzKCkKICAgICBzdGF0 aWMgc3RkOjpvbmNlX2ZsYWcgaW5pdGlhbGl6ZUtleTsKICAgICBzdGF0aWMgVGhyZWFkR3JvdXAq IGFjdGl2ZVRocmVhZHNQdHIgPSBudWxscHRyOwogICAgIHN0ZDo6Y2FsbF9vbmNlKGluaXRpYWxp emVLZXksIFsmXSB7CisgICAgICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUgYXNzZXJ0 U2NvcGU7CiAgICAgICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxzdGQ6OnNoYXJlZF9wdHI8VGhy ZWFkR3JvdXA+PiBhY3RpdmVUaHJlYWRzIHsgVGhyZWFkR3JvdXA6OmNyZWF0ZSgpIH07CiAgICAg ICAgIGFjdGl2ZVRocmVhZHNQdHIgPSBhY3RpdmVUaHJlYWRzLmdldCgpLmdldCgpOwogICAgIH0p OwpAQCAtMjQyLDE3ICsyNzAsMjIgQEAgc3RhdGljIHZvaWQganNjU2lnbmFsSGFuZGxlcihpbnQs IHNpZ2luZgogCiB2b2lkIGluc3RhbGxTaWduYWxIYW5kbGVyKFNpZ25hbCBzaWduYWwsIFNpZ25h bEhhbmRsZXImJiBoYW5kbGVyKQogeworICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUg YXNzZXJ0U2NvcGU7CisgICAgU2lnbmFsSGFuZGxlcnMmIGhhbmRsZXJzID0gZ193dGZDb25maWcu c2lnbmFsSGFuZGxlcnM7CiAgICAgQVNTRVJUKHNpZ25hbCA8IFNpZ25hbDo6VW5rbm93bik7CiAj aWYgSEFWRShNQUNIX0VYQ0VQVElPTlMpCi0gICAgQVNTRVJUKCF1c2VNYWNoIHx8IHNpZ25hbCAh PSBTaWduYWw6OlVzcik7CisgICAgQVNTRVJUKCFoYW5kbGVycy51c2VNYWNoIHx8IHNpZ25hbCAh PSBTaWduYWw6OlVzcik7CiAKLSAgICBpZiAodXNlTWFjaCkKKyAgICBpZiAoaGFuZGxlcnMudXNl TWFjaCkKICAgICAgICAgc3RhcnRNYWNoRXhjZXB0aW9uSGFuZGxlclRocmVhZCgpOwogI2VuZGlm CiAKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgaW5pdGlhbGl6ZU9uY2VGbGFnc1tzdGF0aWNf Y2FzdDxzaXplX3Q+KFNpZ25hbDo6TnVtYmVyT2ZTaWduYWxzKV07CiAgICAgc3RkOjpjYWxsX29u Y2UoaW5pdGlhbGl6ZU9uY2VGbGFnc1tzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCldLCBbJl0g ewotICAgICAgICBoYW5kbGVyc1tzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCldLmNvbnN0cnVj dCgpOwotCisgICAgICAgIENvbmZpZzo6QXNzZXJ0Tm90RnJvemVuU2NvcGUgYXNzZXJ0U2NvcGU7 CisjaWYgSEFWRShNQUNIX0VYQ0VQVElPTlMpCisgICAgICAgIGJvb2wgdXNlTWFjaCA9IGhhbmRs ZXJzLnVzZU1hY2g7CisjZW5kaWYKICAgICAgICAgaWYgKCF1c2VNYWNoKSB7CiAgICAgICAgICAg ICBzdHJ1Y3Qgc2lnYWN0aW9uIGFjdGlvbjsKICAgICAgICAgICAgIGFjdGlvbi5zYV9zaWdhY3Rp b24gPSBqc2NTaWduYWxIYW5kbGVyOwpAQCAtMjYzLDIwICsyOTYsMTkgQEAgdm9pZCBpbnN0YWxs U2lnbmFsSGFuZGxlcihTaWduYWwgc2lnbmFsLAogICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQo IXJlc3VsdCk7CiAgICAgICAgICAgICBhY3Rpb24uc2FfZmxhZ3MgPSBTQV9TSUdJTkZPOwogICAg ICAgICAgICAgYXV0byBzeXN0ZW1TaWduYWxzID0gdG9TeXN0ZW1TaWduYWwoc2lnbmFsKTsKLSAg ICAgICAgICAgIHJlc3VsdCA9IHNpZ2FjdGlvbihzdGQ6OmdldDwwPihzeXN0ZW1TaWduYWxzKSwg JmFjdGlvbiwgJm9sZEFjdGlvbnNbb2Zmc2V0Rm9yU3lzdGVtU2lnbmFsKHN0ZDo6Z2V0PDA+KHN5 c3RlbVNpZ25hbHMpKV0pOworICAgICAgICAgICAgcmVzdWx0ID0gc2lnYWN0aW9uKHN0ZDo6Z2V0 PDA+KHN5c3RlbVNpZ25hbHMpLCAmYWN0aW9uLCAmaGFuZGxlcnMub2xkQWN0aW9uc1tvZmZzZXRG b3JTeXN0ZW1TaWduYWwoc3RkOjpnZXQ8MD4oc3lzdGVtU2lnbmFscykpXSk7CiAgICAgICAgICAg ICBpZiAoc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscykpCi0gICAgICAgICAgICAgICAgcmVzdWx0 IHw9IHNpZ2FjdGlvbigqc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscyksICZhY3Rpb24sICZvbGRB Y3Rpb25zW29mZnNldEZvclN5c3RlbVNpZ25hbCgqc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscykp XSk7CisgICAgICAgICAgICAgICAgcmVzdWx0IHw9IHNpZ2FjdGlvbigqc3RkOjpnZXQ8MT4oc3lz dGVtU2lnbmFscyksICZhY3Rpb24sICZoYW5kbGVycy5vbGRBY3Rpb25zW29mZnNldEZvclN5c3Rl bVNpZ25hbCgqc3RkOjpnZXQ8MT4oc3lzdGVtU2lnbmFscykpXSk7CiAgICAgICAgICAgICBSRUxF QVNFX0FTU0VSVCghcmVzdWx0KTsKICAgICAgICAgfQotCiAgICAgfSk7CiAKLSAgICBoYW5kbGVy c1tzdGF0aWNfY2FzdDxzaXplX3Q+KHNpZ25hbCldLT5hZGQoV1RGTW92ZShoYW5kbGVyKSk7Cisg ICAgaGFuZGxlcnMuYWRkKHNpZ25hbCwgV1RGTW92ZShoYW5kbGVyKSk7CiAKICNpZiBIQVZFKE1B Q0hfRVhDRVBUSU9OUykKICAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKGFjdGl2ZVRocmVhZHMo KS5nZXRMb2NrKCkpOwotICAgIGlmICh1c2VNYWNoKSB7Ci0gICAgICAgIGFjdGl2ZUV4Y2VwdGlv bnMgfD0gdG9NYWNoTWFzayhzaWduYWwpOworICAgIGlmIChoYW5kbGVycy51c2VNYWNoKSB7Cisg ICAgICAgIGhhbmRsZXJzLmFjdGl2ZUV4Y2VwdGlvbnMgfD0gdG9NYWNoTWFzayhzaWduYWwpOwog CiAgICAgICAgIGZvciAoYXV0byYgdGhyZWFkIDogYWN0aXZlVGhyZWFkcygpLnRocmVhZHMobG9j a2VyKSkKICAgICAgICAgICAgIHNldEV4Y2VwdGlvblBvcnRzKGxvY2tlciwgdGhyZWFkLmdldCgp KTsKQEAgLTI4Nyw2ICszMTksNyBAQCB2b2lkIGluc3RhbGxTaWduYWxIYW5kbGVyKFNpZ25hbCBz aWduYWwsCiB2b2lkIGpzY1NpZ25hbEhhbmRsZXIoaW50IHNpZywgc2lnaW5mb190KiBpbmZvLCB2 b2lkKiB1Y29udGV4dCkKIHsKICAgICBTaWduYWwgc2lnbmFsID0gZnJvbVN5c3RlbVNpZ25hbChz aWcpOworICAgIFNpZ25hbEhhbmRsZXJzJiBoYW5kbGVycyA9IGdfd3RmQ29uZmlnLnNpZ25hbEhh bmRsZXJzOwogCiAgICAgYXV0byByZXN0b3JlRGVmYXVsdCA9IFsmXSB7CiAgICAgICAgIHN0cnVj dCBzaWdhY3Rpb24gZGVmYXVsdEFjdGlvbjsKQEAgLTI5OSw3ICszMzIsNyBAQCB2b2lkIGpzY1Np Z25hbEhhbmRsZXIoaW50IHNpZywgc2lnaW5mb190CiAKICAgICAvLyBUaGlzIHNob3VsZG4ndCBo YXBwZW4gYnV0IHdlIG1pZ2h0IGFzIHdlbGwgYmUgY2FyZWZ1bC4KICAgICBpZiAoc2lnbmFsID09 IFNpZ25hbDo6VW5rbm93bikgewotICAgICAgICBkYXRhTG9nTG4oIldlIHNvbWVob3cgZ290IGNh bGxlZCBmb3IgYW4gdW5rbm93biBzaWduYWwgIiwgc2lnLCAiLCBoYWxwLiIpOworICAgICAgICBk YXRhTG9nTG4oIldlIHNvbWVob3cgZ290IGNhbGxlZCBmb3IgYW4gdW5rbm93biBzaWduYWwgIiwg c2lnLCAiLCBoZWxwLiIpOwogICAgICAgICByZXN0b3JlRGVmYXVsdCgpOwogICAgICAgICByZXR1 cm47CiAgICAgfQpAQCAtMzEyLDcgKzM0NSw3IEBAIHZvaWQganNjU2lnbmFsSGFuZGxlcihpbnQg c2lnLCBzaWdpbmZvX3QKIAogICAgIGJvb2wgZGlkSGFuZGxlID0gZmFsc2U7CiAgICAgYm9vbCBy ZXN0b3JlRGVmYXVsdEhhbmRsZXIgPSBmYWxzZTsKLSAgICBoYW5kbGVyc1tzdGF0aWNfY2FzdDxz aXplX3Q+KHNpZ25hbCldLT5pdGVyYXRlKFsmXSAoY29uc3QgU2lnbmFsSGFuZGxlciYgaGFuZGxl cikgeworICAgIGhhbmRsZXJzLmZvckVhY2hIYW5kbGVyKHNpZ25hbCwgWyZdIChjb25zdCBTaWdu YWxIYW5kbGVyJiBoYW5kbGVyKSB7CiAgICAgICAgIHN3aXRjaCAoaGFuZGxlcihzaWduYWwsIHNp Z0luZm8sIHJlZ2lzdGVycykpIHsKICAgICAgICAgY2FzZSBTaWduYWxBY3Rpb246OkhhbmRsZWQ6 CiAgICAgICAgICAgICBkaWRIYW5kbGUgPSB0cnVlOwpAQCAtMzMxLDcgKzM2NCw3IEBAIHZvaWQg anNjU2lnbmFsSGFuZGxlcihpbnQgc2lnLCBzaWdpbmZvX3QKICAgICB9CiAKICAgICB1bnNpZ25l ZCBvbGRBY3Rpb25JbmRleCA9IHN0YXRpY19jYXN0PHNpemVfdD4oc2lnbmFsKSArIChzaWcgPT0g U0lHQlVTKTsKLSAgICBzdHJ1Y3Qgc2lnYWN0aW9uJiBvbGRBY3Rpb24gPSBvbGRBY3Rpb25zW3N0 YXRpY19jYXN0PHNpemVfdD4ob2xkQWN0aW9uSW5kZXgpXTsKKyAgICBzdHJ1Y3Qgc2lnYWN0aW9u JiBvbGRBY3Rpb24gPSBoYW5kbGVycy5vbGRBY3Rpb25zW3N0YXRpY19jYXN0PHNpemVfdD4ob2xk QWN0aW9uSW5kZXgpXTsKICAgICBpZiAoc2lnbmFsID09IFNpZ25hbDo6VXNyKSB7CiAgICAgICAg IGlmIChvbGRBY3Rpb24uc2Ffc2lnYWN0aW9uKQogICAgICAgICAgICAgb2xkQWN0aW9uLnNhX3Np Z2FjdGlvbihzaWcsIGluZm8sIHVjb250ZXh0KTsKQEAgLTM0OSw2ICszODIsMTggQEAgdm9pZCBq c2NTaWduYWxIYW5kbGVyKGludCBzaWcsIHNpZ2luZm9fdAogICAgIH0KIH0KIAordm9pZCBTaWdu YWxIYW5kbGVyczo6aW5pdGlhbGl6ZSgpCit7CisjaWYgSEFWRShNQUNIX0VYQ0VQVElPTlMpCisg ICAgLy8gSW4gcHJvZHVjdGlvbiBjb25maWd1cmF0aW9ucywgdGhpcyBkb2VzIG5vdCBtYXR0ZXIg YmVjYXVzZSBzaWduYWwgaGFuZGxlcgorICAgIC8vIGluc3RhbGxhdGlvbnMgd2lsbCBhbHdheXMg dHJpZ2dlciB0aGlzIGluaXRpYWxpemF0aW9uLiBIb3dldmVyLCBpbiBkZWJ1Z2dpbmcKKyAgICAv LyBjb25maWd1cmF0aW9ucywgd2UgbWF5IGVuZCB1cCBkaXNhYmxpbmcgdGhlIHVzZSBvZiBhbGwg c2lnbmFsIGhhbmRsZXJzIGJ1dAorICAgIC8vIHdlIHN0aWxsIG5lZWQgdGhpcyB0byBiZSBpbml0 aWFsaXplZC4gSGVuY2UsIHdlIG5lZWQgdG8gaW5pdGlhbGl6ZSBpdAorICAgIC8vIGVhZ2VybHkg dG8gZW5zdXJlIHRoYXQgaXQgaXMgZG9uZSBiZWZvcmUgd2UgZnJlZXplIHRoZSBXVEY6OkNvbmZp Zy4KKyAgICBhY3RpdmVUaHJlYWRzKCk7CisjZW5kaWYKK30KKwogfSAvLyBuYW1lc3BhY2UgV1RG CiAKICNlbmRpZiAvLyBVU0UoUFRIUkVBRFMpICYmIEhBVkUoTUFDSElORV9DT05URVhUKQpJbmRl eDogU291cmNlL1dURi93dGYvdGhyZWFkcy9TaWduYWxzLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dURi93dGYvdGhyZWFkcy9TaWduYWxzLmgJKHJldmlzaW9uIDI2MTQ2OSkKKysrIFNvdXJjZS9X VEYvd3RmL3RocmVhZHMvU2lnbmFscy5oCSh3b3JraW5nIGNvcHkpCkBAIC0xLDUgKzEsNSBAQAog LyoKLSAqIENvcHlyaWdodCAoQykgMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTMwLDkgKzMwLDE0IEBACiAj aW5jbHVkZSA8c2lnbmFsLmg+CiAjaW5jbHVkZSA8dHVwbGU+CiAjaW5jbHVkZSA8d3RmL0Z1bmN0 aW9uLmg+CisjaW5jbHVkZSA8d3RmL0xvY2suaD4KICNpbmNsdWRlIDx3dGYvT3B0aW9uYWwuaD4K ICNpbmNsdWRlIDx3dGYvUGxhdGZvcm1SZWdpc3RlcnMuaD4KIAorI2lmIEhBVkUoTUFDSF9FWENF UFRJT05TKQorI2luY2x1ZGUgPG1hY2gvZXhjZXB0aW9uX3R5cGVzLmg+CisjZW5kaWYKKwogbmFt ZXNwYWNlIFdURiB7CiAKIC8vIE5vdGUgdGhhdCBTSUdVU1IxIGlzIHVzZWQgaW4gUHRocmVhZC1i YXNlZCBwb3J0cyBleGNlcHQgZm9yIERhcndpbiB0byBzdXNwZW5kIGFuZCByZXN1bWUgdGhyZWFk cy4KQEAgLTgyLDExICs4NywzNiBAQCBzdHJ1Y3QgU2lnSW5mbyB7CiB9OwogCiB1c2luZyBTaWdu YWxIYW5kbGVyID0gRnVuY3Rpb248U2lnbmFsQWN0aW9uKFNpZ25hbCwgU2lnSW5mbyYsIFBsYXRm b3JtUmVnaXN0ZXJzJik+OwordXNpbmcgU2lnbmFsSGFuZGxlck1lbW9yeSA9IHN0ZDo6YWxpZ25l ZF9zdG9yYWdlPHNpemVvZihTaWduYWxIYW5kbGVyKSwgc3RkOjphbGlnbm1lbnRfb2Y8U2lnbmFs SGFuZGxlcj46OnZhbHVlPjo6dHlwZTsKKworc3RydWN0IFNpZ25hbEhhbmRsZXJzIHsKKyAgICBz dGF0aWMgdm9pZCBpbml0aWFsaXplKCk7CisKKyAgICB2b2lkIGFkZChTaWduYWwsIFNpZ25hbEhh bmRsZXImJik7CisgICAgdGVtcGxhdGU8dHlwZW5hbWUgRnVuYz4KKyAgICB2b2lkIGZvckVhY2hI YW5kbGVyKFNpZ25hbCwgY29uc3QgRnVuYyYpIGNvbnN0OworCisgICAgc3RhdGljIGNvbnN0ZXhw ciBzaXplX3QgbnVtYmVyT2ZTaWduYWxzID0gc3RhdGljX2Nhc3Q8c2l6ZV90PihTaWduYWw6Ok51 bWJlck9mU2lnbmFscyk7CisgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgbWF4TnVtYmVyT2ZI YW5kbGVycyA9IDI7CisKKyAgICBzdGF0aWNfYXNzZXJ0KG51bWJlck9mU2lnbmFscyA8IHN0ZDo6 bnVtZXJpY19saW1pdHM8dWludDhfdD46Om1heCgpKTsKKworI2lmIEhBVkUoTUFDSF9FWENFUFRJ T05TKQorICAgIG1hY2hfcG9ydF90IGV4Y2VwdGlvblBvcnQ7CisgICAgZXhjZXB0aW9uX21hc2tf dCBhY3RpdmVFeGNlcHRpb25zOworICAgIGJvb2wgdXNlTWFjaDsKKyNlbmRpZgorICAgIHVpbnQ4 X3QgbnVtYmVyT2ZIYW5kbGVyc1tudW1iZXJPZlNpZ25hbHNdOworICAgIFNpZ25hbEhhbmRsZXJN ZW1vcnkgaGFuZGxlcnNbbnVtYmVyT2ZTaWduYWxzXVttYXhOdW1iZXJPZkhhbmRsZXJzXTsKKyAg ICBzdHJ1Y3Qgc2lnYWN0aW9uIG9sZEFjdGlvbnNbbnVtYmVyT2ZTaWduYWxzXTsKK307CiAKLS8v IENhbGwgdGhpcyBtZXRob2Qgd2hlbmV2ZXIgeW91IHdhbnQgdG8gaW5zdGFsbCBhIHNpZ25hbCBo YW5kbGVyLiBJdCdzIG9rIHRvIGNhbGwgdGhpcyBmdW5jdGlvbiBsYXppbHkuCisvLyBDYWxsIHRo aXMgbWV0aG9kIHdoZW5ldmVyIHlvdSB3YW50IHRvIGluc3RhbGwgYSBzaWduYWwgaGFuZGxlci4g VGhpcyBmdW5jdGlvbiBuZWVkcyB0byBiZSBjYWxsZWQKKy8vIGJlZm9yZSBnX3d0ZkNvbmZpZyBp cyBmcm96ZW4uIEFmdGVyIHRoZSBnX3d0ZkNvbmZpZyBpcyBmcm96ZW4sIG5vIGFkZGl0aW9uYWwg c2lnbmFsIGhhbmRsZXJzIG1heQorLy8gYmUgaW5zdGFsbGVkLiBBbnkgYXR0ZW1wdCB0byBkbyBz byB3aWxsIHRyaWdnZXIgYSBjcmFzaC4KIC8vIE5vdGU6IFlvdXIgc2lnbmFsIGhhbmRsZXIgd2ls bCBiZSBjYWxsZWQgZXZlcnkgdGltZSB0aGUgaGFuZGxlciBmb3IgdGhlIGRlc2lyZWQgc2lnbmFs IGlzIGNhbGxlZC4KIC8vIFRodXMgaXQgaXMgeW91ciByZXNwb25zaWJpbGl0eSB0byBkaXNjZXJu IGlmIHRoZSBzaWduYWwgZmlyZWQgd2FzIHlvdXJzLgotLy8gVGhpcyBmdW5jdGlvbiBpcyBjdXJy ZW50bHkgYSBvbmUgd2F5IHN0cmVldCBpLmUuIG9uY2UgaW5zdGFsbGVkLCBhIHNpZ25hbCBoYW5k bGVyIGNhbm5vdCBiZSB1bmluc3RhbGxlZC4KKy8vIFRoaXMgZnVuY3Rpb24gaXMgYSBvbmUgd2F5 IHN0cmVldCBpLmUuIG9uY2UgaW5zdGFsbGVkLCBhIHNpZ25hbCBoYW5kbGVyIGNhbm5vdCBiZSB1 bmluc3RhbGxlZC4KIFdURl9FWFBPUlRfUFJJVkFURSB2b2lkIGluc3RhbGxTaWduYWxIYW5kbGVy KFNpZ25hbCwgU2lnbmFsSGFuZGxlciYmKTsKIAogCg==