196855 2019-04-12 03:45:30 -0700 Fix Covscan uninitialized after ctor 2019-04-18 12:38:23 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified NEW P2 Normal --- 104114 1 erack webkit-unassigned ap bfulgham bugs-noreply darin ews-watchlist fpizlo krollin mcatanzaro oldest_to_newest 1526702 0 erack 2019-04-12 03:45:30 -0700 Fix Covscan uninitialized after ctor 1526703 1 367313 erack 2019-04-12 03:53:30 -0700 Created attachment 367313 Patch 1526704 2 ews-watchlist 2019-04-12 03:57:02 -0700 Attachment 367313 did not pass style-queue: ERROR: Source/WebCore/ChangeLog:8: You should remove the 'No new tests' and either add and list tests, or explain why no new tests were possible. [changelog/nonewtests] [5] Total errors found: 1 in 39 files If any of these errors are false positives, please file a bug against check-webkit-style. 1526705 3 367314 erack 2019-04-12 04:08:23 -0700 Created attachment 367314 Patch 1526732 4 367314 darin 2019-04-12 07:54:33 -0700 Comment on attachment 367314 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=367314&action=review I really appreciate the time an effort to run Coverity and fix everything it finds. This patch includes fixes for some real bugs, and some cases where Coverity effectively just prefers a different coding style. The Coverity coding style may be safer, but we don’t necessarily want to make that kind of a change without a discussion first. Generally we would not land a patch, especially from a non-contributor, without discussion. I started looking at the changes in the patch to check them for correctness and value but didn’t have a chance to review the whole thing, just started looking at a couple. > Source/WebCore/html/HTMLMediaElement.cpp:2105 > - if (actionIfInvalid == Complain) > + if (actionIfInvalid == Complain) { > FrameLoader::reportLocalLoadFailed(frame.get(), url.stringCenterEllipsizedToLength()); > ERROR_LOG(LOGIDENTIFIER, url , " was rejected by SecurityOrigin"); > + } > return false; Good fix, but a different Coverity error, not uninitialized data members. > Source/WebCore/html/HTMLMenuElement.h:43 > - bool m_isTouchBarMenu; > + bool m_isTouchBarMenu { false }; Definitely a real bug here. 1526751 5 erack 2019-04-12 09:10:33 -0700 (In reply to Darin Adler from comment #4) > This patch includes fixes for some real bugs, and some cases where Coverity > effectively just prefers a different coding style. The Coverity coding style > may be safer, but we don’t necessarily want to make that kind of a change > without a discussion first. There may be some false positives now because the actual patches stem from covscans of between 2.20.x to 2.22.7 backported to master. However, I think there is nothing coding style involved but rather most are indeed some "left uninitialized" errors. Or could you point out an example that you think is only coding style? > Generally we would not land a patch, especially from a non-contributor, > without discussion. Fine with me. > > Source/WebCore/html/HTMLMediaElement.cpp:2105 > > - if (actionIfInvalid == Complain) > > + if (actionIfInvalid == Complain) { > > FrameLoader::reportLocalLoadFailed(frame.get(), url.stringCenterEllipsizedToLength()); > > ERROR_LOG(LOGIDENTIFIER, url , " was rejected by SecurityOrigin"); > > + } > > return false; > > Good fix, but a different Coverity error, not uninitialized data members. Historically it has been in a general covscan fixes patch that later was renamed to uninit_ctor probably because by then it contained mostly such fixes.. Certainly the covscan error here indeed was something different. 1526758 6 darin 2019-04-12 09:14:02 -0700 (In reply to Eike Rathke from comment #5) > However, I think there is nothing coding style involved but rather most are > indeed some "left uninitialized" errors. Or could you point out an example > that you think is only coding style? I will once I review more. I am pretty sure I spotted some that are technically uninitialized, but semantically there is no need to initialize. A source code analyzer can’t see enough of the semantics to understand the the optimization, lack of initialization, is safe. 1526767 7 367314 mcatanzaro 2019-04-12 09:40:51 -0700 Comment on attachment 367314 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=367314&action=review Although I agree with Darin, I'm also generally of the opinion that we should change WebKit to please as many static analysis tools as we can. Even when the tool reports false positives, as long as it's not too many, then avoiding those will make it easier to see when there are real problems. This is my approach to GCC compiler warnings, and I believe it has worked well there. In one previous discussion, we were perhaps too strict about whether we should fix UNINIT_CTOR warnings, even proposing in one case that some should not be fixed so that we could diagnose with asan if code outside the constructor failed to initialize particular members. While that could work in theory, I don't think it was the right judgment call, and work on fixing Coverity issues stalled as a result, which was not good for WebKit. I like the rule that constructors should initialize all data members, and our code should be more robust and contain fewer bugs if we follow it. Anyway, looking through this patch, the changes mostly look good. I'm impressed that we have fewer issues here than I would have expected. We have several existing Coverity bugs: bug #104114, bug #186798, bug #190468. We should be aware of those as well, especially the metabug #104114. I would remove the HTMLMediaElement.cpp change from this patch, since it's clearly not a UNINIT_CTOR issue, and fix that in a new bug marked against bug #104114 instead. Also, since there are a relatively large number of whitespace fixes in AccessibilityTableColumn.h, those should be landed separately as well; if it was a smaller amount, I wouldn't consider it worth a separate patch, but that's enough to obscure the fix you've made there. BTW, welcome Eike. :) Darin, Eike is the new maintainer of Red Hat's WebKit and Chromium packages. > Source/JavaScriptCore/dfg/DFGOSRExit.h:135 > - ExtraInitializationLevel extraInitializationLevel; > + ExtraInitializationLevel extraInitializationLevel { }; You could choose to be explicit here: extraInitializationLevel { ExtraInitializationLevel::None }; But I think this is fine, too. > Source/JavaScriptCore/runtime/CodeCache.cpp:141 > - JSToken token; > + JSToken token = { }; I think you should fix this one in ParserTokens.h: struct JSToken { JSToken() = default; // ... }; to match the other tokens defined in that file. That would be much more robust. > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:154 > + ResultList result { }; But ResultList is: Vector<Value*, 1> so this one shouldn't need the brace initialization... correct? > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:53 > int m_writeIndex; Both constructors initialize this to 0, so might as well modernize them by initializing it here instead of in the constructors' initializer lists. > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:56 > bool m_firstTime; Ditto. > Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp:59 > + : m_hasForwardButtonStartPart(false) > + , m_hasForwardButtonEndPart(false) > + , m_hasBackButtonStartPart(false) > + , m_hasBackButtonEndPart(false) Hm, is it possible to initialize these in the class declaration instead? Or is that not possible, because these are bitfields? If so, this is fine. 1526769 8 mcatanzaro 2019-04-12 09:44:47 -0700 I see there's some overlap between this patch and bug #186798, for example, but only some. What's the status of that one? Is the other patch obsolete, or do they need to be combined to comprehensively fix these warnings? 1526770 9 367314 mcatanzaro 2019-04-12 09:45:12 -0700 Comment on attachment 367314 Patch (r+ -> r? because I see Darin wants to review this further.) 1526771 10 367314 mcatanzaro 2019-04-12 09:50:14 -0700 Comment on attachment 367314 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=367314&action=review > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:151 > + BlockType blockType { }; I originally left a comment complaining that there was no sane default value to use here, but then removed it, deciding the initial value should be good enough. But I notice Mark has left a similar complaint about an equivalent change in bug #186798. This probably requires further discussion with the JSC developers, perhaps in that bug, to decide how to fix this specific instance, as well as your two changes in WasmValidate.cpp. Looks like there is considerable overlap between the fixes in these bugs, at any rate. 1526812 11 ap 2019-04-12 10:41:56 -0700 > Although I agree with Darin, I'm also generally of the opinion that we should change WebKit to please as many static analysis tools as we can. Even when the tool reports false positives, as long as it's not too many, then avoiding those will make it easier to see when there are real problems. It may be obvious to everyone looking at this bug, but adding initialization where it is not needed regresses performance, almost by definition. Other changes needed to please code analysis tools can be introducing other problems, so I think that each one needs to be discussed on its merits. 1526853 12 367314 fpizlo 2019-04-12 11:33:20 -0700 Comment on attachment 367314 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=367314&action=review This patch is almost good. Please revert whitespace changes. Please consider applying some of the other feedback. >> Source/JavaScriptCore/dfg/DFGOSRExit.h:135 >> + ExtraInitializationLevel extraInitializationLevel { }; > > You could choose to be explicit here: extraInitializationLevel { ExtraInitializationLevel::None }; > > But I think this is fine, too. Yeah that would be better in this case. >> Source/JavaScriptCore/runtime/CodeCache.cpp:141 >> + JSToken token = { }; > > I think you should fix this one in ParserTokens.h: > > struct JSToken { > JSToken() = default; > // ... > }; > > to match the other tokens defined in that file. That would be much more robust. Agreed. >> Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:154 >> + ResultList result { }; > > But ResultList is: > > Vector<Value*, 1> > > so this one shouldn't need the brace initialization... correct? I think that's right. It's not necessary to have { } on result but it doesn't hurt either. > Source/WebCore/accessibility/AccessibilityTableColumn.h:60 > #include "IntRect.h" > > namespace WebCore { > - > + > class RenderTableSection; > > class AccessibilityTableColumn final : public AccessibilityMockObject { > public: > static Ref<AccessibilityTableColumn> create(); > virtual ~AccessibilityTableColumn(); > - > + > AccessibilityObject* headerObject(); > - > + > AccessibilityRole roleValue() const override { return AccessibilityRole::Column; } > - > + > void setColumnIndex(int columnIndex) { m_columnIndex = columnIndex; } > - int columnIndex() const { return m_columnIndex; } > - > + int columnIndex() const { return m_columnIndex; } > + > void addChildren() override; > void setParent(AccessibilityObject*) override; > - > + > LayoutRect elementRect() const override; > - > + > private: > AccessibilityTableColumn(); > - > + > AccessibilityObject* headerObjectForSection(RenderTableSection*, bool thTagRequired); > bool computeAccessibilityIsIgnored() const override; Please revert whitespace changes. 1526859 13 erack 2019-04-12 11:51:51 -0700 (In reply to Michael Catanzaro from comment #7) > We have several existing Coverity bugs: bug #104114, bug #186798, bug > #190468. We should be aware of those as well, especially the metabug > #104114. I can only see bug #186798 and get "You are not authorized to access" for the others. However, that one bug and patch was submitted by Tomas (I wasn't aware that old bug still existed) and my patch contains the same old fixes if they weren't applied, as I tried to apply everything we have to current master, plus a set of new ones resulting from differences between 2.20.x and 2.22.7 > I would remove the HTMLMediaElement.cpp change from this patch, > since it's clearly not a UNINIT_CTOR issue, and fix that in a new bug marked > against bug #104114 instead. Do you want me to split the patch? > Also, since there are a relatively large number > of whitespace fixes in AccessibilityTableColumn.h, those should be landed > separately as well; if it was a smaller amount, I wouldn't consider it worth > a separate patch, but that's enough to obscure the fix you've made there. That's probably due to an editor not saving trailing spaces (which is a good thing, IMHO). And also already in the old patch. But well, yes, that's easily squeezable to the one changed line. > BTW, welcome Eike. :) Darin, Eike is the new maintainer of Red Hat's WebKit > and Chromium packages. Thanks :-) > > Source/JavaScriptCore/dfg/DFGOSRExit.h:135 > > - ExtraInitializationLevel extraInitializationLevel; > > + ExtraInitializationLevel extraInitializationLevel { }; > > You could choose to be explicit here: extraInitializationLevel { > ExtraInitializationLevel::None }; > > But I think this is fine, too. > > > Source/JavaScriptCore/runtime/CodeCache.cpp:141 > > - JSToken token; > > + JSToken token = { }; > > I think you should fix this one in ParserTokens.h: > > struct JSToken { > JSToken() = default; > // ... > }; > > to match the other tokens defined in that file. That would be much more > robust. Agreed. That was also discussed in bug #186798. So, what I could do to prevent duplicated discussion and work is to split off all the old changes and submit a new patch that contains only newer fixes. Does that make sense? > > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:154 > > + ResultList result { }; > > But ResultList is: > > Vector<Value*, 1> > > so this one shouldn't need the brace initialization... correct? Looks like. That one is also carried over from bug #186798, maybe it was simply "one too much" (three had to be initialized, one not). > > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:53 > > int m_writeIndex; > > Both constructors initialize this to 0, so might as well modernize them by > initializing it here instead of in the constructors' initializer lists. > > > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:56 > > bool m_firstTime; > > Ditto. Ditto, both from the old patch. > > Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp:59 > > + : m_hasForwardButtonStartPart(false) > > + , m_hasForwardButtonEndPart(false) > > + , m_hasBackButtonStartPart(false) > > + , m_hasBackButtonEndPart(false) > > Hm, is it possible to initialize these in the class declaration instead? Or > is that not possible, because these are bitfields? If so, this is fine. Bitfield initializers are available only since C++20 (In reply to Alexey Proskuryakov from comment #11) > > Although I agree with Darin, I'm also generally of the opinion that we should change WebKit to please as many static analysis tools as we can. Even when the tool reports false positives, as long as it's not too many, then avoiding those will make it easier to see when there are real problems. > > It may be obvious to everyone looking at this bug, but adding initialization > where it is not needed regresses performance, almost by definition. Other > changes needed to please code analysis tools can be introducing other > problems, so I think that each one needs to be discussed on its merits. If so, then WebKit should be added to the actual Coverity Scan Analysis platform, where each "error" can be marked as false positive (which is remembered) and other means of telling Coverity already in the source code how to interpret things exist. For example, there are dozens of false positives about unreachable code or uninitialized where, well, an ASSERT_NOTREACHED() or so exists in a switch case. Coverity can be taught about such things. 1526864 14 fpizlo 2019-04-12 11:56:16 -0700 (In reply to Eike Rathke from comment #13) > (In reply to Michael Catanzaro from comment #7) > > We have several existing Coverity bugs: bug #104114, bug #186798, bug > > #190468. We should be aware of those as well, especially the metabug > > #104114. > I can only see bug #186798 and get "You are not authorized to access" for > the others. However, that one bug and patch was submitted by Tomas (I wasn't > aware that old bug still existed) and my patch contains the same old fixes > if they weren't applied, as I tried to apply everything we have to current > master, plus a set of new ones resulting from differences between 2.20.x and > 2.22.7 > > > I would remove the HTMLMediaElement.cpp change from this patch, > > since it's clearly not a UNINIT_CTOR issue, and fix that in a new bug marked > > against bug #104114 instead. > Do you want me to split the patch? > > > Also, since there are a relatively large number > > of whitespace fixes in AccessibilityTableColumn.h, those should be landed > > separately as well; if it was a smaller amount, I wouldn't consider it worth > > a separate patch, but that's enough to obscure the fix you've made there. > That's probably due to an editor not saving trailing spaces (which is a good > thing, IMHO). And also already in the old patch. But well, yes, that's > easily squeezable to the one changed line. > > > BTW, welcome Eike. :) Darin, Eike is the new maintainer of Red Hat's WebKit > > and Chromium packages. > Thanks :-) > > > > > Source/JavaScriptCore/dfg/DFGOSRExit.h:135 > > > - ExtraInitializationLevel extraInitializationLevel; > > > + ExtraInitializationLevel extraInitializationLevel { }; > > > > You could choose to be explicit here: extraInitializationLevel { > > ExtraInitializationLevel::None }; > > > > But I think this is fine, too. > > > > > Source/JavaScriptCore/runtime/CodeCache.cpp:141 > > > - JSToken token; > > > + JSToken token = { }; > > > > I think you should fix this one in ParserTokens.h: > > > > struct JSToken { > > JSToken() = default; > > // ... > > }; > > > > to match the other tokens defined in that file. That would be much more > > robust. > Agreed. That was also discussed in bug #186798. So, what I could do to > prevent duplicated discussion and work is to split off all the old changes > and submit a new patch that contains only newer fixes. Does that make sense? > > > > > Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp:154 > > > + ResultList result { }; > > > > But ResultList is: > > > > Vector<Value*, 1> > > > > so this one shouldn't need the brace initialization... correct? > Looks like. That one is also carried over from bug #186798, maybe it was > simply "one too much" (three had to be initialized, one not). > > > > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:53 > > > int m_writeIndex; > > > > Both constructors initialize this to 0, so might as well modernize them by > > initializing it here instead of in the constructors' initializer lists. > > > > > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:56 > > > bool m_firstTime; > > > > Ditto. > Ditto, both from the old patch. > > > > Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp:59 > > > + : m_hasForwardButtonStartPart(false) > > > + , m_hasForwardButtonEndPart(false) > > > + , m_hasBackButtonStartPart(false) > > > + , m_hasBackButtonEndPart(false) > > > > Hm, is it possible to initialize these in the class declaration instead? Or > > is that not possible, because these are bitfields? If so, this is fine. > Bitfield initializers are available only since C++20 > > > (In reply to Alexey Proskuryakov from comment #11) > > > Although I agree with Darin, I'm also generally of the opinion that we should change WebKit to please as many static analysis tools as we can. Even when the tool reports false positives, as long as it's not too many, then avoiding those will make it easier to see when there are real problems. > > > > It may be obvious to everyone looking at this bug, but adding initialization > > where it is not needed regresses performance, almost by definition. Other > > changes needed to please code analysis tools can be introducing other > > problems, so I think that each one needs to be discussed on its merits. > If so, then WebKit should be added to the actual Coverity Scan Analysis > platform, where each "error" can be marked as false positive (which is > remembered) and other means of telling Coverity already in the source code > how to interpret things exist. For example, there are dozens of false > positives about unreachable code or uninitialized where, well, an > ASSERT_NOTREACHED() or so exists in a switch case. Coverity can be taught > about such things. Compiler dude here. Adding initialization where it is unnecessary is most likely not going to add any overhead. It won't even add instructions in many cases. This is because once you get to the compiler's optimizer, it knows very well if an initialization is live at any use. If an initialization was added just to placate a sanitizer or static analysis tool, then it will be very obvious to the compiler that the initialization is dead. The compiler will then remove it. For example, say you have: int x = 0; x = 42; print(x); Then the "x = 0" part will disappear in the eventual code. This is true even for complex control flow patterns, including probably many cases where we add " = 0" to spoonfeed tools around a switch statement. Generally, I only like to spoonfeed tools if those tools are useful. I think that in the case of adding initializations of fields, it's not just useful to do it but it's also generally perf-neutral and it makes the code more clear. 1526870 15 erack 2019-04-12 12:19:22 -0700 (In reply to Eike Rathke from comment #13) > > > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:53 > > > int m_writeIndex; > > > > Both constructors initialize this to 0, so might as well modernize them by > > initializing it here instead of in the constructors' initializer lists. > > > > > Source/WebCore/Modules/webaudio/DelayDSPKernel.h:56 > > > bool m_firstTime; > > > > Ditto. > Ditto, both from the old patch. Or rather, it's old here, but not in bug #186798 (which carries only changes to Source/JavaScriptCore/), maybe in a patch at one of the other bugs I can't see? 1526873 16 ap 2019-04-12 12:25:28 -0700 > If so, then WebKit should be added to the actual Coverity Scan Analysis platform, where each "error" can be marked as false positive Are you talking about <https://scan.coverity.com/projects/webkit>, or some other Coverity platform thing? > Compiler dude here. Adding initialization where it is unnecessary is most likely not going to add any overhead. It won't even add instructions in many cases. Most of the code that Coverity complains about is not dead code of the kind you describe. Let's look at the changes to GradientImage for example, are you claiming that the compiler is going to eliminate the unnecessary initialization added in this patch? 1526877 17 erack 2019-04-12 12:46:27 -0700 (In reply to Alexey Proskuryakov from comment #16) > > If so, then WebKit should be added to the actual Coverity Scan Analysis platform, where each "error" can be marked as false positive > > Are you talking about <https://scan.coverity.com/projects/webkit>, or some > other Coverity platform thing? No, exactly that. But then again.. is it really scanned? Component Name Pattern Ignore Line of Code Defect density Source ./Source No 0 N/A My guess: ./Source should be ./Source/* instead (or even /Source/.* maybe?), or there's something else preventing the scan. 1526888 18 mcatanzaro 2019-04-12 13:12:31 -0700 (In reply to Eike Rathke from comment #13) > Do you want me to split the patch? Yes please. Such a small patch will be very easy to land, anyway. > Agreed. That was also discussed in bug #186798. So, what I could do to > prevent duplicated discussion and work is to split off all the old changes > and submit a new patch that contains only newer fixes. Does that make sense? Yeah that sounds like a good idea. You can take over and update Tom's patch there. 1526890 19 mcatanzaro 2019-04-12 13:18:29 -0700 (In reply to Alexey Proskuryakov from comment #16) > Most of the code that Coverity complains about is not dead code of the kind > you describe. Let's look at the changes to GradientImage for example, are > you claiming that the compiler is going to eliminate the unnecessary > initialization added in this patch? It's not unnecessary, though. It's fixing a real bug. The first time GradientImage::drawPattern is called, m_cachedGeneratorHash is read uninitialized. The only place m_cachedGeneratorHash is ever initialized is after that read, so currently there's no way it can ever be initialized unless an uninitialized memory read has already occurred. I don't like Coverity, but got to admit the scan results are quality.... 1526893 20 mcatanzaro 2019-04-12 13:23:27 -0700 (In reply to Eike Rathke from comment #13) > If so, then WebKit should be added to the actual Coverity Scan Analysis > platform, where each "error" can be marked as false positive (which is > remembered) and other means of telling Coverity already in the source code > how to interpret things exist. For example, there are dozens of false > positives about unreachable code or uninitialized where, well, an > ASSERT_NOTREACHED() or so exists in a switch case. Coverity can be taught > about such things. Maybe something like this would be enough to solve it: diff --git a/Source/WTF/wtf/Assertions.h b/Source/WTF/wtf/Assertions.h index ac1a0774595..f5477d6008c 100644 --- a/Source/WTF/wtf/Assertions.h +++ b/Source/WTF/wtf/Assertions.h @@ -64,7 +64,7 @@ extern "C" void _ReadWriteBarrier(void); #endif #endif -#ifdef NDEBUG +#if defined(NDEBUG) && !defined(__COVERITY__) /* Disable ASSERT* macros in release mode. */ #define ASSERTIONS_DISABLED_DEFAULT 1 #els 1526929 21 ap 2019-04-12 15:55:28 -0700 > No, exactly that. But then again.. is it really scanned? I do not know. The access is restricted, and IIRC I never had access. Worth discussing on the webkit-security list, not in this bug. > It's not unnecessary, though. It's fixing a real bug. The first time > GradientImage::drawPattern is called, m_cachedGeneratorHash is read > uninitialized. The code is actually correct. The first time this function is called, m_cachedImage is null, so the rest of the expression is not evaluated (it's called short-circuiting logical operators in C++). 1526939 22 mcatanzaro 2019-04-12 16:28:11 -0700 (In reply to Alexey Proskuryakov from comment #21) > The code is actually correct. The first time this function is called, > m_cachedImage is null, so the rest of the expression is not evaluated (it's > called short-circuiting logical operators in C++). Ah, you are right, of course. It is subtle and very fragile, though. I wouldn't want to leave a footgun like that in WebKit. Programming is just too hard if we can't count on the data members of a class to be initialized. 1527048 23 darin 2019-04-13 08:15:17 -0700 (In reply to Michael Catanzaro from comment #22) > (In reply to Alexey Proskuryakov from comment #21) > > The code is actually correct. The first time this function is called, > > m_cachedImage is null, so the rest of the expression is not evaluated (it's > > called short-circuiting logical operators in C++). > > Ah, you are right, of course. It is subtle and very fragile, though. I > wouldn't want to leave a footgun like that in WebKit. Programming is just > too hard if we can't count on the data members of a class to be initialized. I understand your point of view on this Michael, and this is the coding style discussion I was alluding to. 1527055 24 367314 darin 2019-04-13 09:23:05 -0700 Comment on attachment 367314 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=367314&action=review I’m OK with making these changes. Many are correctness problems, but many are not correctness problems. I know that some on the project are certain we should make almost all these changes because they are either helpful or harmless. I believe that is overstating the case because in the past additional initialization has had measurable performance costs. I hope that none of these changes are in that category, but it would be overconfident to say that we are certain there are none. We could also just say we want to take these changes so we can continue to use Coverity to find future problems and quieting the warnings is worth it. I audited most of these to the best of my ability and added comments to many that are not correctness problems; I can provide more detail if someone is interested in why, but I think it‘s obvious from reading over the code in most cases. Probably OK to make all of these changes, despite the many that are not needed. > Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp:1334 > + Node* m_currentNode { nullptr }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or safety decision rather than a correctness decision. > Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp:14203 > + StringImpl* string { nullptr }; > + LBasicBlock target { nullptr }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/JavaScriptCore/parser/Nodes.h:2042 > + FunctionMode m_functionMode { FunctionMode::FunctionExpression }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/JavaScriptCore/runtime/ConfigFile.cpp:236 > + FILE* m_file { nullptr }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/JavaScriptCore/runtime/ErrorInstance.h:101 > + unsigned m_line { 0 }; > + unsigned m_column { 0 }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/JavaScriptCore/runtime/JSBigInt.h:246 > + unsigned m_length { 0 }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. And I don’t understand which constructor Coverity is warning about here. I only see one constructor and it does initialize m_length. > Source/JavaScriptCore/runtime/PropertySlot.h:390 > + unsigned m_attributes { 0 }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. This is a peculiar case. The PropertySlot constructor does not initialize one of the most important members, m_data, but Coverity does not warn about it presumably because it’s complex. Initializing just this one more data member has negligible value. Typically PropertySlot objects are initialized by the various set functions, all of which set m_attributes at the same time that they set m_data. > Source/WebCore/Modules/webaudio/AudioProcessingEvent.h:61 > + double m_playbackTime { 0.0 }; Not sure that 0 is the correct default value here. Would be good to have a test covering this. > Source/WebCore/accessibility/AccessibilityTableColumn.h:63 > + unsigned m_columnIndex { 0 }; Not clear to me that a 0 is an acceptable default here. I suppose initialized is better than not, but 0 can be initialized but incorrect. > Source/WebCore/animation/DeclarativeAnimation.h:95 > + double m_previousIteration { 0.0 }; I think NAN is a better default here than 0. Not sure. > Source/WebCore/dom/RequestAnimationFrameCallback.h:46 > + int m_id { 0 }; > + bool m_firedOrCancelled { false }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/WebCore/platform/graphics/ANGLEWebKitBridge.h:95 > + ShBuiltInResources m_resources { }; Seems like a mistake to initialize this with aggregate initialization instead of by calling the InitBuiltInResources function. Not sure if this is needed. > Source/WebCore/platform/graphics/GradientImage.h:57 > + unsigned m_cachedGeneratorHash { 0 }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:224 > + bool m_hasAlphaChannel { false }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.h:83 > + GLint m_internalFormat { 0 }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. >> Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp:59 >> + , m_hasBackButtonEndPart(false) > > Hm, is it possible to initialize these in the class declaration instead? Or is that not possible, because these are bitfields? If so, this is fine. That’s right, has to be done this way because they are bitfields. > Source/WebCore/platform/text/TextCodecUTF16.h:45 > + unsigned char m_bufferedByte { 0 }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/WebCore/rendering/RenderFragmentedFlow.h:230 > + bool m_rangeInvalidated { false }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/WebCore/workers/WorkerScriptLoader.h:97 > + FetchOptions::Destination m_destination { FetchOptions::Destination::EmptyString }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. > Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.h:50 > + PluginProcessType processType { PluginProcessTypeNormal }; Not needed; as far as I can tell this is a coding style and "make the static checker happy" or future-proofing/safety measure rather than a correctness decision. 1527085 25 ap 2019-04-13 21:34:17 -0700 I think that some ways to help inform the coding style discussion are: 1. Confirm whether it is practical to silence incorrect findings on the website. 2. Think about whether there are less costly way to find such bugs. E.g. one thing that we haven’t done to my knowledge is to run regression tests with UBSan. Does that find most of the same uninitialized variable bugs? Does it find more? Static analysis is not the same thing in the abstract, but what about practice? I am skeptical of the line of thinking that it’s ok to slow down code as long as we can’t measure that with benchmarks. Benchmarks are not measuring everything, and their results are quite coarse. WebKit developers have always been micro-optimizing code they wrote, and I think that’s been doing us good overall. 1527126 26 mcatanzaro 2019-04-14 17:36:36 -0700 We're now talking about extreme micro-optimization at the cost of safety and robustness. The case we discussed up above, in comment #21, seems like case in point to me. Although you're right that the code is correct in its current form -- I was wrong about that -- it's easy to see a small and seemingly-correct change to this code would result in uninitialized memory read. Short-circuiting to avoid e.g. dereferencing NULL is common practice; short-circuiting to avoid uninitialized memory reads is not. The checks could easily be moved around in the future. Or a getter function could be added to the class. It's just too fragile. Humans are not good enough to avoid such mistakes; we can check to make sure local variables we declare in functions are initialized before first use, but it's just too hard if we can't assume that classes are fully-initialized. 1527130 27 ap 2019-04-14 19:01:35 -0700 It’s not just this case. Darin went through the whole patch and pointed out lots of those. Michael, are you saying that you’ve made up your mind, and your opinion cannot be changed regardless to what the answers to my two questions are? 1527164 28 mcatanzaro 2019-04-15 07:12:10 -0700 I would just initialize everything regardless, yes. 1527179 29 erack 2019-04-15 09:00:49 -0700 Oh, you sort not initializing under coding style, ah well.. wasn't aware of that. (In reply to Darin Adler from comment #24) > > Source/JavaScriptCore/runtime/JSBigInt.h:246 > > + unsigned m_length { 0 }; > > Not needed; as far as I can tell this is a coding style and "make the static > checker happy" or future-proofing/safety measure rather than a correctness > decision. > > And I don’t understand which constructor Coverity is warning about here. I > only see one constructor and it does initialize m_length. As I mentioned, part of the patch are old covscan fixes that more or less still applied, if current code initializes things now then that is not caught and the patch is moot. Our Covscan didn't run against master or versions more recent than 2.22 This (patch outdated) is in particluar true for most if not all Source/JavaScriptCore/ changes that were already submitted with bug #186798 or changes submitted with bug #190468 (both which I now have access to, thanks). As mentioned, I'll submit a new patch that omits those old changes and contains only newer fixes to not duplicate work, and I'll check the changes against these comments before submitting and weed out the "style only" ones. > > Source/WebCore/Modules/webaudio/AudioProcessingEvent.h:61 > > + double m_playbackTime { 0.0 }; > > Not sure that 0 is the correct default value here. Would be good to have a > test covering this. Current code on master has AudioProcessingEvent::AudioProcessingEvent() = default; so either initializing with 0.0 is correct (and could be omitted) or it needs an explicit different value anyway. > > Source/WebCore/animation/DeclarativeAnimation.h:95 > > + double m_previousIteration { 0.0 }; > > I think NAN is a better default here than 0. Not sure. It's used in DeclarativeAnimation::invalidateDOMEvents() line 284 else if (wasActive && isActive && m_previousIteration != iteration) where a NaN would compare to always false with operator!=(), which in this case would be ok. (if no one introduces comparisons with operator<() or operator>()) 1527180 30 darin 2019-04-15 09:25:23 -0700 (In reply to Eike Rathke from comment #29) > Oh, you sort not initializing under coding style, ah well.. wasn't aware of > that. That’s an incorrect characterization of my view. Here’s my view: Initializing something that is *used* is absolutely required, not a coding style decision. Many of the changes in this patch repair those kinds of problems and we must take those changes as soon as possible. Initializing something that is *not* used is a coding style decision. Some advocate this style, citing that it’s safer to initialize everything and is unlikely to have any major negative impact or cost. Others advocate a style where we initialize only in cases where the initialization is meaningful, citing possible performance benefits in cases where the compiler can’t see the fact that the value is never used, or preferring not to write code that has no effect by setting an initial value that is provably irrelevant since it is only written and never read. 1527187 31 erack 2019-04-15 09:34:49 -0700 So, taking only my newer changes and weeding out everything marked "not needed" above leaves just the NaN-or-not-NaN case --- webkitgtk-2.22.7/Source/WebCore/animation/DeclarativeAnimation.h.covscan_uninit_ctor 2019-02-28 11:08:20.000000000 +0100 +++ webkitgtk-2.22.7/Source/WebCore/animation/DeclarativeAnimation.h 2019-04-04 00:36:57.991556884 +0200 @@ -69,7 +69,7 @@ private: Ref<Animation> m_backingAnimation; bool m_wasPending { false }; AnimationEffectReadOnly::Phase m_previousPhase { AnimationEffectReadOnly::Phase::Idle }; - double m_previousIteration; + double m_previousIteration { 0.0 }; GenericEventQueue m_eventQueue; }; I guess this bug can be closed then. And sorry for fuzz. 1527216 32 darin 2019-04-15 10:23:42 -0700 To be clear, I am not intending to forbid check-in of the ones I marked "not needed". Instead my intention is to call them out as ones where we have to think/discuss at least a little more to make our "project style" decision. Also, my analysis may be wrong. 1527238 33 mcatanzaro 2019-04-15 10:44:41 -0700 Well I think we've discussed it. Alexey seems to be opposed (or at least unenthusiastic) and I won't give r+ unless he's OK with it. Let's land the DeclarativeAnimation fix, at least. 1527241 34 darin 2019-04-15 10:47:16 -0700 (In reply to Michael Catanzaro from comment #33) > Let's land the DeclarativeAnimation fix, at least. What about the HTMLMenuElement one, for example? I want that one! 1527324 35 mcatanzaro 2019-04-15 12:35:27 -0700 Eike, might be a good idea to go through these again and see if you missed anything else. 1527382 36 erack 2019-04-15 13:51:21 -0700 Sigh.. only bug #186798 had a patch attached, the others only covscan logs, so concluding only from my last changes didn't include the ones related. I'll prepare another patch that does not cross #186798 but includes everything else, modulo the trailing blank change. 1527420 37 erack 2019-04-15 14:34:11 -0700 (In reply to Darin Adler from comment #4) > > Source/WebCore/html/HTMLMediaElement.cpp:2105 > > - if (actionIfInvalid == Complain) > > + if (actionIfInvalid == Complain) { > > FrameLoader::reportLocalLoadFailed(frame.get(), url.stringCenterEllipsizedToLength()); > > ERROR_LOG(LOGIDENTIFIER, url , " was rejected by SecurityOrigin"); > > + } > > return false; > > Good fix, but a different Coverity error, not uninitialized data members. I submitted that with a separate bug #196933. 1527588 38 ap 2019-04-15 19:59:27 -0700 To be clear, I am quite interested in better undefined behavior diagnostics, as well as in other bugs that static analysis catches. I’m questioning whether the approach that has a negative user impact in terms of performance is the one to choose. The correct place for such discussions is the mailing list of course, as a discussion in a bug is only immediately visible to people CCed on it. 1527695 39 367314 erack 2019-04-16 03:34:34 -0700 Comment on attachment 367314 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=367314&action=review >> Source/WebCore/accessibility/AccessibilityTableColumn.h:63 >> + unsigned m_columnIndex { 0 }; > > Not clear to me that a 0 is an acceptable default here. I suppose initialized is better than not, but 0 can be initialized but incorrect. AccessibilityTableColumn::headerObjectForSection() does unsigned numCols = section->numColumns(); if (m_columnIndex >= numCols) return nullptr; I guess any other initial value than 0 (if nothing was set with setColumnIndex()) would be unexpected. Also for (int testCol = m_columnIndex; testCol >= 0; --testCol) { starting with a greater value then would seem quite odd to me. >> Source/WebCore/animation/DeclarativeAnimation.h:95 >> + double m_previousIteration { 0.0 }; > > I think NAN is a better default here than 0. Not sure. DeclarativeAnimation::invalidateDOMEvents() has else if (wasActive && isActive && m_previousIteration != iteration) { auto iterationBoundary = iteration; if (m_previousIteration > iteration) iterationBoundary++; With NaN m_previousIteration != iteration is always true, m_previousIteration > iteration is always false, no matter what the value of iteration is (even if negative). Just to point out, don't know what would be correct. 1527702 40 367526 erack 2019-04-16 03:44:04 -0700 Created attachment 367526 Patch 1527703 41 erack 2019-04-16 03:47:57 -0700 This patch omits all changes already present on bug #186798. 367313 2019-04-12 03:53:30 -0700 2019-04-12 04:08:18 -0700 Patch bug-196855-20190412125329.patch text/plain 27600 erack U3VidmVyc2lvbiBSZXZpc2lvbjogMjQ0MTg3CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAz NWIzOWU3MDI2ODlmMThhMzkyM2U0NTYyZGMxNTY4YTU3ZWZjNjRlLi5mMmIwZmFlN2E2MDdlZDcw NmY1NzY4N2Q3MDM3MWZkOWRlNmY4NDEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNSBAQAorMjAxOS0wNC0xMiAgRWlrZSBSYXRoa2UgIDxlcmFja0ByZWRoYXQuY29tPgor CisgICAgICAgIEZpeCBDb3ZzY2FuIHVuaW5pdGlhbGl6ZWQgYWZ0ZXIgY3RvcgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk2ODU1CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4IGEgYnVuY2ggb2YgQ292 ZXJpdHkgU2NhbiBVTklOSVRfQ1RPUiBlcnJvcnMsIHdoZXJlIGFmdGVyCisgICAgICAgIGNvbnN0 cnVjdGluZyBhbiBvYmplY3QgaW5zdGFuY2UgbWVtYmVyIHZhcmlhYmxlcyB3ZXJlIGxlZnQKKyAg ICAgICAgdW5pbml0aWFsaXplZC4KKworICAgICAgICAqIGIzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lz dGVyc0J5R3JhcGhDb2xvcmluZy5jcHA6CisgICAgICAgICogYnl0ZWNvZGUvUG9seW1vcnBoaWNB Y2Nlc3MuaDoKKyAgICAgICAgKiBkZmcvREZHT1NSRXhpdC5oOgorICAgICAgICAqIGRmZy9ERkdQ cmVkaWN0aW9uUHJvcGFnYXRpb25QaGFzZS5jcHA6CisgICAgICAgICogZnRsL0ZUTExvd2VyREZH VG9CMy5jcHA6CisgICAgICAgICogcGFyc2VyL05vZGVzLmg6CisgICAgICAgICogcnVudGltZS9D b2RlQ2FjaGUuY3BwOgorICAgICAgICAoSlNDOjpDb2RlQ2FjaGU6OmdldFVubGlua2VkR2xvYmFs RnVuY3Rpb25FeGVjdXRhYmxlKToKKyAgICAgICAgKiBydW50aW1lL0NvbmZpZ0ZpbGUuY3BwOgor ICAgICAgICAqIHJ1bnRpbWUvRXJyb3JJbnN0YW5jZS5oOgorICAgICAgICAqIHJ1bnRpbWUvSlNC aWdJbnQuaDoKKyAgICAgICAgKiBydW50aW1lL1Byb3BlcnR5U2xvdC5oOgorICAgICAgICAqIHdh c20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwOgorICAgICAgICAqIHdhc20vV2FzbUZvcm1hdC5oOgor ICAgICAgICAqIHdhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmg6CisgICAgICAgICogd2FzbS9XYXNt VGllclVwQ291bnQuaDoKKyAgICAgICAgKiB3YXNtL1dhc21WYWxpZGF0ZS5jcHA6CisgICAgICAg ICogd2FzbS9qcy9XYXNtVG9KUy5jcHA6CisgICAgICAgIChKU0M6Oldhc206Ondhc21Ub0pTKToK KyAgICAgICAgKiB5YXJyL1lhcnJKSVQuaDoKKwogMjAxOS0wNC0xMCAgU2FhbSBCYXJhdGkgIDxz YmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBBYnN0cmFjdFZhbHVlOjp2YWxpZGF0ZU9TUkVu dHJ5VmFsdWUgaXMgd3JvbmcgZm9yIEludDUyIGNvbnN0YW50cwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDgxODE3 ODYyYzQ0MjlhYzIyODRmOWFjYTVmNTlhMDYwYWY5Yzg1NmUuLjlmMDcyMjE3NzQzNGQxYzViNDU0 MzIzODc3Y2EyOGQ4NGZkODE3OTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAxOS0w NC0xMiAgRWlrZSBSYXRoa2UgIDxlcmFja0ByZWRoYXQuY29tPgorCisgICAgICAgIEZpeCBDb3Zz Y2FuIHVuaW5pdGlhbGl6ZWQgYWZ0ZXIgY3RvcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk2ODU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChPT1BTISkuCisKKyAgICAgICAgKiBN b2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2ZW50Lmg6CisgICAgICAgICogTW9kdWxl cy93ZWJhdWRpby9EZWxheURTUEtlcm5lbC5oOgorICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNj ZXNzaWJpbGl0eVRhYmxlQ29sdW1uLmg6CisgICAgICAgICogYW5pbWF0aW9uL0RlY2xhcmF0aXZl QW5pbWF0aW9uLmg6CisgICAgICAgICogZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNr Lmg6CisgICAgICAgICogaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkhUTUxNZWRpYUVsZW1lbnQ6OmlzU2FmZVRvTG9hZFVSTCk6CisgICAgICAgICogaHRtbC9I VE1MTWVudUVsZW1lbnQuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYktp dEJyaWRnZS5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0dyYWRpZW50SW1hZ2UuaDoK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRl R1N0cmVhbWVyQmFzZS5jcHA6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvdGV4bWFwL1Rl eHR1cmVNYXBwZXJQbGF0Zm9ybUxheWVyQnVmZmVyLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3Rr L1Njcm9sbGJhclRoZW1lR3RrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbGJhclRoZW1l R3RrOjpTY3JvbGxiYXJUaGVtZUd0ayk6CisgICAgICAgICogcGxhdGZvcm0vaW1hZ2UtZGVjb2Rl cnMvanBlZy9KUEVHSW1hZ2VEZWNvZGVyLmNwcDoKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L1Rl eHRDb2RlY1VURjE2Lmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckZyYWdtZW50ZWRGbG93 Lmg6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJTY3JpcHRMb2FkZXIuaDoKKwogMjAxOS0wNC0x MSAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAg W0dUS10gTGF5b3V0IHRlc3QgYWNjZXNzaWJpbGl0eS9hcmlhLWhpZGRlbi1mYWxzZS13b3Jrcy1p bi1zdWJ0cmVlcy5odG1sIGZhaWxzIGFmdGVyIHIxODQ4OTAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggYzY4OGJhMTlh ZGNkYjEzMWUyZmY5NzM0ZDllNGJjNzlhZWE5MzI5Mi4uNzE4ODUxYmQyZTBlNzI0OTAzYmIzMmJl NjAzZDg2OWZkN2IzNzI2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxOS0wNC0xMiAg RWlrZSBSYXRoa2UgIDxlcmFja0ByZWRoYXQuY29tPgorCisgICAgICAgIEZpeCBDb3ZzY2FuIHVu aW5pdGlhbGl6ZWQgYWZ0ZXIgY3RvcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTk2ODU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgKiBTaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJh bWV0ZXJzLmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9nbGliL0ljb25EYXRhYmFzZS5oOgor CiAyMDE5LTA0LTEwICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAKICAgICAgICAg UmVncmVzc2lvbihyMjQ0MTQ0KSBQcm9jZXNzU3dhcC5SZXVzZVN1c3BlbmRlZFByb2Nlc3NMb2Fk SFRNTFN0cmluZyBBUEkgdGVzdCBpcyBmbGFreQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL2IzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lzdGVyc0J5R3JhcGhDb2xvcmluZy5jcHAgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvYjMvYWlyL0FpckFsbG9jYXRlUmVnaXN0ZXJzQnlHcmFwaENv bG9yaW5nLmNwcAppbmRleCA4ZjQ5NzY1MGFjYmU3ZWIyYjdmMmM3ZTRkZGZjNzc3YzhlYzY4NDUz Li43ZDgwNDhkMWU4NGU1ZDhmZTIyNmVmMmY1YWQ1NGFiZjJmZWE4N2ZhIDEwMDY0NAotLS0gYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvYjMvYWlyL0FpckFsbG9jYXRlUmVnaXN0ZXJzQnlHcmFwaENv bG9yaW5nLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvYjMvYWlyL0FpckFsbG9jYXRl UmVnaXN0ZXJzQnlHcmFwaENvbG9yaW5nLmNwcApAQCAtODc2LDcgKzg3Niw3IEBAIHByb3RlY3Rl ZDoKICAgICAgICAgfQogCiAgICAgcHJpdmF0ZToKLSAgICAgICAgdW5zaWduZWQgbV9wb3NpdGlv bkluTW92ZUxpc3Q7CisgICAgICAgIHVuc2lnbmVkIG1fcG9zaXRpb25Jbk1vdmVMaXN0IHsgMCB9 OwogICAgICAgICBWZWN0b3I8dW5zaWduZWQsIDAsIFVuc2FmZVZlY3Rvck92ZXJmbG93PiBtX21v dmVMaXN0OwogICAgICAgICBWZWN0b3I8dW5zaWduZWQsIDAsIFVuc2FmZVZlY3Rvck92ZXJmbG93 PiBtX2xvd1ByaW9yaXR5TW92ZUxpc3Q7CiAgICAgfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ieXRlY29kZS9Qb2x5bW9ycGhpY0FjY2Vzcy5oIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL2J5dGVjb2RlL1BvbHltb3JwaGljQWNjZXNzLmgKaW5kZXggMzA1NTg1NTFjYmNhYjAx OWY0NThmNzM5ZDU2OWNlZWUxYzA0NjJhZS4uNWU3MmVhYThkYmU1ZjFkZWE1M2FhODFhNzQzZjU4 NzUyNmYyNWJlMyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2J5dGVjb2RlL1Bv bHltb3JwaGljQWNjZXNzLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2J5dGVjb2RlL1Bv bHltb3JwaGljQWNjZXNzLmgKQEAgLTEyMiw3ICsxMjIsNyBAQCBwdWJsaWM6CiAgICAgfQogICAg IAogcHJpdmF0ZToKLSAgICBLaW5kIG1fa2luZDsKKyAgICBLaW5kIG1fa2luZCB7IE1hZGVOb0No YW5nZXMgfTsKICAgICBNYWNyb0Fzc2VtYmxlckNvZGVQdHI8SklUU3R1YlJvdXRpbmVQdHJUYWc+ IG1fY29kZTsKICAgICBWZWN0b3I8c3RkOjpwYWlyPElubGluZVdhdGNocG9pbnRTZXQmLCBTdHJp bmdGaXJlRGV0YWlsPj4gbV93YXRjaHBvaW50c1RvRmlyZTsKIH07CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR09TUkV4aXQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9kZmcvREZHT1NSRXhpdC5oCmluZGV4IGY1NDIyZWEyOTI1ZTgwNGRlZThhZDg1YTUwMWJlZjZl YTVmMWJhOWYuLmU2YWY4YjVhMTkxNmU2NjNmY2RlMjU0ZGVhOGNkYzY3MjkwZDkxODEgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHT1NSRXhpdC5oCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHT1NSRXhpdC5oCkBAIC0xMzIsNyArMTMyLDcgQEAgc3Ry dWN0IE9TUkV4aXRTdGF0ZSA6IFJlZkNvdW50ZWQ8T1NSRXhpdFN0YXRlPiB7CiAgICAgdm9pZCog anVtcFRhcmdldDsKICAgICBBcnJheVByb2ZpbGUqIGFycmF5UHJvZmlsZTsKIAotICAgIEV4dHJh SW5pdGlhbGl6YXRpb25MZXZlbCBleHRyYUluaXRpYWxpemF0aW9uTGV2ZWw7CisgICAgRXh0cmFJ bml0aWFsaXphdGlvbkxldmVsIGV4dHJhSW5pdGlhbGl6YXRpb25MZXZlbCB7IH07CiAgICAgUHJv ZmlsZXI6Ok9TUkV4aXQqIHByb2ZpbGVyRXhpdCB7IG51bGxwdHIgfTsKIH07CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHUHJlZGljdGlvblByb3BhZ2F0aW9uUGhh c2UuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdQcmVkaWN0aW9uUHJvcGFnYXRp b25QaGFzZS5jcHAKaW5kZXggNjI5ZGJlNGQ5NTkzMWE5MTJkYTMxNzliYWMwMDBlNmY0NTljZmUz ZC4uYmYzOTRhZjJiYjY3YmEwZmU0NzczN2Y1NDI4YTkyYTNiYjNhNjQwNSAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdQcmVkaWN0aW9uUHJvcGFnYXRpb25QaGFzZS5j cHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdQcmVkaWN0aW9uUHJvcGFnYXRp b25QaGFzZS5jcHAKQEAgLTEzMzEsNyArMTMzMSw3IEBAIHByaXZhdGU6CiAgICAgfQogCiAgICAg VmVjdG9yPE5vZGUqPiBtX2RlcGVuZGVudE5vZGVzOwotICAgIE5vZGUqIG1fY3VycmVudE5vZGU7 CisgICAgTm9kZSogbV9jdXJyZW50Tm9kZSB7IG51bGxwdHIgfTsKICAgICBib29sIG1fY2hhbmdl ZCB7IGZhbHNlIH07CiAgICAgUHJlZGljdGlvblBhc3MgbV9wYXNzIHsgUHJpbWFyeVBhc3MgfTsg Ly8gV2UgdXNlIGRpZmZlcmVudCBsb2dpYyBmb3IgY29uc2lkZXJpbmcgcHJlZGljdGlvbnMgZGVw ZW5kaW5nIG9uIGhvdyBmYXIgYWxvbmcgd2UgYXJlIGluIHByb3BhZ2F0aW9uLgogfTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9mdGwvRlRMTG93ZXJERkdUb0IzLmNwcCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9mdGwvRlRMTG93ZXJERkdUb0IzLmNwcAppbmRleCA2MmE2ZDMz NGMzMTExYmRiMDQ5NjYwODAwYzIxYmM5MDViZGM5MGJiLi4zY2ExOWUxNzM4MjZmNzdiMTJhN2U5 MzI2MzY1OTYxYWY4N2I1NDIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRs L0ZUTExvd2VyREZHVG9CMy5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2Z0bC9GVExM b3dlckRGR1RvQjMuY3BwCkBAIC0xNDE5OSw4ICsxNDE5OSw4IEBAIHByaXZhdGU6CiAgICAgICAg ICAgICByZXR1cm4gc3RyaW5nTGVzc1RoYW4oKnN0cmluZywgKm90aGVyLnN0cmluZyk7CiAgICAg ICAgIH0KICAgICAgICAgCi0gICAgICAgIFN0cmluZ0ltcGwqIHN0cmluZzsKLSAgICAgICAgTEJh c2ljQmxvY2sgdGFyZ2V0OworICAgICAgICBTdHJpbmdJbXBsKiBzdHJpbmcgeyBudWxscHRyIH07 CisgICAgICAgIExCYXNpY0Jsb2NrIHRhcmdldCB7IG51bGxwdHIgfTsKICAgICB9OwogICAgIAog ICAgIHN0cnVjdCBDaGFyYWN0ZXJDYXNlIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9wYXJzZXIvTm9kZXMuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9wYXJzZXIvTm9kZXMu aAppbmRleCAxNWZmYzE0ZGYxZTcwNjJiNDY2MjM0YTc5ODIyOGUwNzJmMDA1NDEzLi5lNjNhOTE0 ZTcxODQ5NDFkMWZjNTE3OTE1Mjc4NWZmN2Q1NmJiMTI1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcGFyc2VyL05vZGVzLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3Bh cnNlci9Ob2Rlcy5oCkBAIC0yMDM5LDcgKzIwMzksNyBAQCBuYW1lc3BhY2UgSlNDIHsKICAgICAg ICAgdW5zaWduZWQgbV9jb25zdHJ1Y3RvcktpbmQgOiAyOwogICAgICAgICB1bnNpZ25lZCBtX2lz QXJyb3dGdW5jdGlvbkJvZHlFeHByZXNzaW9uIDogMTsKICAgICAgICAgU291cmNlUGFyc2VNb2Rl IG1fcGFyc2VNb2RlOwotICAgICAgICBGdW5jdGlvbk1vZGUgbV9mdW5jdGlvbk1vZGU7CisgICAg ICAgIEZ1bmN0aW9uTW9kZSBtX2Z1bmN0aW9uTW9kZSB7IEZ1bmN0aW9uTW9kZTo6RnVuY3Rpb25F eHByZXNzaW9uIH07CiAgICAgICAgIElkZW50aWZpZXIgbV9pZGVudDsKICAgICAgICAgSWRlbnRp ZmllciBtX2VjbWFOYW1lOwogICAgICAgICBJZGVudGlmaWVyIG1faW5mZXJyZWROYW1lOwpAQCAt MjA1Miw3ICsyMDUyLDcgQEAgbmFtZXNwYWNlIEpTQyB7CiAgICAgICAgIFNvdXJjZUNvZGUgbV9j bGFzc1NvdXJjZTsKICAgICAgICAgaW50IG1fc3RhcnRTdGFydE9mZnNldDsKICAgICAgICAgdW5z aWduZWQgbV9wYXJhbWV0ZXJDb3VudDsKLSAgICAgICAgaW50IG1fbGFzdExpbmU7CisgICAgICAg IGludCBtX2xhc3RMaW5lIHsgLTEgfTsKICAgICB9OwogCiAgICAgY2xhc3MgRnVuY3Rpb25Ob2Rl IGZpbmFsIDogcHVibGljIFNjb3BlTm9kZSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvQ29kZUNhY2hlLmNwcAppbmRleCA5MzEzNDhkNjIxMTlmMzRlMzEwN2FhMDczMWQ1YTJmYWU2 NjdmZTMxLi44OWYxN2YxNTE2MzY1ZjQ0ZmI4N2I2NDQzNDEyZDRjNDE5ZmNmMjQzIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvZGVDYWNoZS5jcHAKQEAgLTEzOCw3ICsxMzgs NyBAQCBVbmxpbmtlZEZ1bmN0aW9uRXhlY3V0YWJsZSogQ29kZUNhY2hlOjpnZXRVbmxpbmtlZEds b2JhbEZ1bmN0aW9uRXhlY3V0YWJsZShWTSYgdgogICAgIC8vIFRoaXMgZnVuY3Rpb24gYXNzdW1l cyBhbiBpbnB1dCBzdHJpbmcgdGhhdCB3b3VsZCByZXN1bHQgaW4gYSBzaW5nbGUgZnVuY3Rpb24g ZGVjbGFyYXRpb24uCiAgICAgU3RhdGVtZW50Tm9kZSogZnVuY0RlY2wgPSBwcm9ncmFtLT5zaW5n bGVTdGF0ZW1lbnQoKTsKICAgICBpZiAoVU5MSUtFTFkoIWZ1bmNEZWNsKSkgewotICAgICAgICBK U1Rva2VuIHRva2VuOworICAgICAgICBKU1Rva2VuIHRva2VuID0geyB9OwogICAgICAgICBlcnJv ciA9IFBhcnNlckVycm9yKFBhcnNlckVycm9yOjpTeW50YXhFcnJvciwgUGFyc2VyRXJyb3I6OlN5 bnRheEVycm9ySXJyZWNvdmVyYWJsZSwgdG9rZW4sICJQYXJzZXIgZXJyb3IiLCAtMSk7CiAgICAg ICAgIHJldHVybiBudWxscHRyOwogICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0NvbmZpZ0ZpbGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvQ29uZmlnRmlsZS5jcHAKaW5kZXggNjM2YzgwMWQwMDU1OGQ3YmIxZWMxYzllZjk1OTA2YTdm Zjk4OWI2YS4uM2M5ZWE1NDZlMmFkZTdkOGJiOGNmMzRhZDhkYThiYzU4ZjkzY2MxYSAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQ29uZmlnRmlsZS5jcHAKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQ29uZmlnRmlsZS5jcHAKQEAgLTIzMyw3ICsy MzMsNyBAQCBwcml2YXRlOgogCiAgICAgY29uc3QgY2hhciogbV9maWxlbmFtZTsKICAgICB1bnNp Z25lZCBtX2xpbmVOdW1iZXI7Ci0gICAgRklMRSogbV9maWxlOworICAgIEZJTEUqIG1fZmlsZSB7 IG51bGxwdHIgfTsKICAgICBjaGFyIG1fYnVmZmVyW0JVRlNJWl07CiAgICAgY2hhciogbV9zcmNQ dHI7CiAgICAgY2hhciogbV9idWZmZXJFbmQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9FcnJvckluc3RhbmNlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9FcnJvckluc3RhbmNlLmgKaW5kZXggZmJjNmYyNTNkOTM2ZGYzN2VmYTdhNmM0YmVlMTVm NWI5MTZiN2ViYi4uMTdjNzJjNjJlOGQ0ZDc4MDg1MWI5YTA5MDBkYjJjODA1MGRiMjA4MSAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRXJyb3JJbnN0YW5jZS5oCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Vycm9ySW5zdGFuY2UuaApAQCAtOTcs OCArOTcsOCBAQCBwcm90ZWN0ZWQ6CiAKICAgICBTb3VyY2VBcHBlbmRlciBtX3NvdXJjZUFwcGVu ZGVyIHsgbnVsbHB0ciB9OwogICAgIHN0ZDo6dW5pcXVlX3B0cjxWZWN0b3I8U3RhY2tGcmFtZT4+ IG1fc3RhY2tUcmFjZTsKLSAgICB1bnNpZ25lZCBtX2xpbmU7Ci0gICAgdW5zaWduZWQgbV9jb2x1 bW47CisgICAgdW5zaWduZWQgbV9saW5lIHsgMCB9OworICAgIHVuc2lnbmVkIG1fY29sdW1uIHsg MCB9OwogICAgIFN0cmluZyBtX3NvdXJjZVVSTDsKICAgICBTdHJpbmcgbV9zdGFja1N0cmluZzsK ICAgICBSdW50aW1lVHlwZSBtX3J1bnRpbWVUeXBlRm9yQ2F1c2UgeyBUeXBlTm90aGluZyB9Owpk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNCaWdJbnQuaCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQmlnSW50LmgKaW5kZXggNWNjOWUwOWQ0Y2Jl MjJhOWVmMmE2MTkwMjg3MzMwMjIwMzc2ZGVmMS4uMzc3OGE0NDVmYzMwN2JhYzgzYjc4ODc5ZmNj NDhkZDAyYzdmOWQyYyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv SlNCaWdJbnQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0JpZ0ludC5o CkBAIC0yNDMsNyArMjQzLDcgQEAgcHJpdmF0ZToKICAgICBEaWdpdCBkaWdpdCh1bnNpZ25lZCk7 CiAgICAgdm9pZCBzZXREaWdpdCh1bnNpZ25lZCwgRGlnaXQpOwogICAgICAgICAKLSAgICB1bnNp Z25lZCBtX2xlbmd0aDsKKyAgICB1bnNpZ25lZCBtX2xlbmd0aCB7IDAgfTsKICAgICBib29sIG1f c2lnbiB7IGZhbHNlIH07CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv cnVudGltZS9Qcm9wZXJ0eVNsb3QuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1By b3BlcnR5U2xvdC5oCmluZGV4IDJmMmY5MGMxNmNjZGU1N2NlMTgzNjNhOGZjMzI0NzdjMGQ2N2Nh ZjQuLjVlOGYzZGZkZGI5M2U5MmU1YzU0Y2Y5ODg3MDM0NDllMzM3MjU1NjkgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Byb3BlcnR5U2xvdC5oCisrKyBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Byb3BlcnR5U2xvdC5oCkBAIC0zODcsNyArMzg3LDcg QEAgcHJpdmF0ZToKICAgICAgICAgfSBjdXN0b21BY2Nlc3NvcjsKICAgICB9IG1fZGF0YTsKIAot ICAgIHVuc2lnbmVkIG1fYXR0cmlidXRlczsKKyAgICB1bnNpZ25lZCBtX2F0dHJpYnV0ZXMgeyAw IH07CiAgICAgUHJvcGVydHlPZmZzZXQgbV9vZmZzZXQ7CiAgICAgSlNWYWx1ZSBtX3RoaXNWYWx1 ZTsKICAgICBKU09iamVjdCogbV9zbG90QmFzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21CM0lSR2VuZXJhdG9yLmNwcAppbmRleCA3YTdiZGMzM2RjZTM3NmRiMTIzODQ3 YzYwOGE1Njk4NGE4ZGMyMDQ5Li5hNGNhNjQzN2E4NDRhMjNhZDU2ZjM0Mzg3YjhjMDY5NWRiNTZk YTUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVy YXRvci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUIzSVJHZW5lcmF0 b3IuY3BwCkBAIC0xNDgsMTAgKzE0OCwxMCBAQCBwdWJsaWM6CiAKICAgICBwcml2YXRlOgogICAg ICAgICBmcmllbmQgY2xhc3MgQjNJUkdlbmVyYXRvcjsKLSAgICAgICAgQmxvY2tUeXBlIGJsb2Nr VHlwZTsKLSAgICAgICAgQmFzaWNCbG9jayogY29udGludWF0aW9uOwotICAgICAgICBCYXNpY0Js b2NrKiBzcGVjaWFsOwotICAgICAgICBSZXN1bHRMaXN0IHJlc3VsdDsKKyAgICAgICAgQmxvY2tU eXBlIGJsb2NrVHlwZSB7IH07CisgICAgICAgIEJhc2ljQmxvY2sqIGNvbnRpbnVhdGlvbiB7IG51 bGxwdHIgfTsKKyAgICAgICAgQmFzaWNCbG9jayogc3BlY2lhbCB7IG51bGxwdHIgfTsKKyAgICAg ICAgUmVzdWx0TGlzdCByZXN1bHQgeyB9OwogICAgIH07CiAKICAgICB0eXBlZGVmIFZhbHVlKiBF eHByZXNzaW9uVHlwZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21Gb3JtYXQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Gb3JtYXQuaAppbmRl eCBmYzY5ZWU1YzU4YTRmYWMzMWFjOTdiNGUxNmFjNjA0ZjJhMTRhZThkLi5lYmVjMzA1NjJjNDU0 ODY1NDZkOTdhYTBjZTdmYWUwNGEyYWE4ZjM1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtRm9ybWF0LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbUZvcm1hdC5oCkBAIC0yMjcsNyArMjI3LDcgQEAgcHVibGljOgogICAgIE9wdGlvbmFsPHVp bnQzMl90PiBtYXhpbXVtKCkgY29uc3QgeyByZXR1cm4gbV9tYXhpbXVtOyB9CiAKIHByaXZhdGU6 Ci0gICAgdWludDMyX3QgbV9pbml0aWFsOworICAgIHVpbnQzMl90IG1faW5pdGlhbCB7IDAgfTsK ICAgICBPcHRpb25hbDx1aW50MzJfdD4gbV9tYXhpbXVtOwogICAgIGJvb2wgbV9pc0ltcG9ydCB7 IGZhbHNlIH07CiAgICAgYm9vbCBtX2lzVmFsaWQgeyBmYWxzZSB9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmggYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVuY3Rpb25QYXJzZXIuaAppbmRleCAyZTAyOGUzNjY2MjY1 M2VjZWMzOWUwMmVkYjhhMjBiZmQ0NGNkYTkxLi45NDk1ZjMyZWU5YTNjMDA4OWNkOWRiZWU4ZGUw ZTU1MmY4YmRkNmU3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNt RnVuY3Rpb25QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRnVu Y3Rpb25QYXJzZXIuaApAQCAtODksNyArODksNyBAQCBwcml2YXRlOgogICAgIGNvbnN0IFNpZ25h dHVyZSYgbV9zaWduYXR1cmU7CiAgICAgY29uc3QgTW9kdWxlSW5mb3JtYXRpb24mIG1faW5mbzsK IAotICAgIE9wVHlwZSBtX2N1cnJlbnRPcGNvZGU7CisgICAgT3BUeXBlIG1fY3VycmVudE9wY29k ZSB7IH07CiAgICAgc2l6ZV90IG1fY3VycmVudE9wY29kZVN0YXJ0aW5nT2Zmc2V0IHsgMCB9Owog CiAgICAgVmVjdG9yPEV4cHJlc3Npb25UeXBlLCA4PiBtX3RvS2lsbEFmdGVyRXhwcmVzc2lvbjsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21UaWVyVXBDb3VudC5o IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVRpZXJVcENvdW50LmgKaW5kZXggYTk4 OWIzNjdlNmRlZmU3MTA0MWFmZDc3ZmFkYjNhZjA0MDE4M2IwNS4uNzM2OGZmODYwMGJiMjZmYjM1 NWFhOWEwNWU1MWM0ZjBlNmFjMmI5YiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVRpZXJVcENvdW50LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVRpZXJVcENvdW50LmgKQEAgLTY1LDcgKzY1LDcgQEAgcHVibGljOgogCiBwcml2YXRlOgog ICAgIHVpbnQzMl90IG1fY291bnQ7Ci0gICAgQXRvbWljPGJvb2w+IG1fdGllclVwU3RhcnRlZDsK KyAgICBBdG9taWM8Ym9vbD4gbV90aWVyVXBTdGFydGVkIHsgZmFsc2UgfTsKIH07CiAgICAgCiB9 IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dh c21WYWxpZGF0ZS5jcHAKaW5kZXggYmNkNDc3YmMyMGVmN2M4YWE3M2JlYjFhODZhM2FhYjkxZDBi ZjA4YS4uOWUyZjdkYTcyMjI1MDE4ZjlhNzMzNWE0ZWVkNDVkMDgwNWZjZWNkMCAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcAorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCkBAIC03Miw4ICs3Miw4IEBA IHB1YmxpYzoKICAgICAgICAgVHlwZSBzaWduYXR1cmUoKSBjb25zdCB7IHJldHVybiBtX3NpZ25h dHVyZTsgfQogICAgICAgICBUeXBlIGJyYW5jaFRhcmdldFNpZ25hdHVyZSgpIGNvbnN0IHsgcmV0 dXJuIHR5cGUoKSA9PSBCbG9ja1R5cGU6Okxvb3AgPyBWb2lkIDogc2lnbmF0dXJlKCk7IH0KICAg ICBwcml2YXRlOgotICAgICAgICBCbG9ja1R5cGUgbV9ibG9ja1R5cGU7Ci0gICAgICAgIFR5cGUg bV9zaWduYXR1cmU7CisgICAgICAgIEJsb2NrVHlwZSBtX2Jsb2NrVHlwZSB7IH07CisgICAgICAg IFR5cGUgbV9zaWduYXR1cmUgeyB9OwogICAgIH07CiAgICAgdHlwZWRlZiBTdHJpbmcgRXJyb3JU eXBlOwogICAgIHR5cGVkZWYgVW5leHBlY3RlZDxFcnJvclR5cGU+IFVuZXhwZWN0ZWRSZXN1bHQ7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XYXNtVG9KUy5jcHAg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9qcy9XYXNtVG9KUy5jcHAKaW5kZXggNTcyYjAz MDdkMDMyYzQwYjU5MjM1M2U2YjZkNDIzYmQ2ZmNkYmIzYy4uMWRjMGI0MWVmZDMzYTg2ZWE1Yzlj ZWJlZDE1NGU2ODYwZWQ0NmI1NCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vanMvV2FzbVRvSlMuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL2pzL1dh c21Ub0pTLmNwcApAQCAtMjU5LDcgKzI1OSw3IEBAIEV4cGVjdGVkPE1hY3JvQXNzZW1ibGVyQ29k ZVJlZjxXYXNtRW50cnlQdHJUYWc+LCBCaW5kaW5nRmFpbHVyZT4gd2FzbVRvSlMoVk0qIHZtCiAg ICAgICAgICAgICAgICAgSlNWYWx1ZSByZXN1bHQgPSBjYWxsKGV4ZWMsIGNhbGxlZSwgY2FsbFR5 cGUsIGNhbGxEYXRhLCBqc1VuZGVmaW5lZCgpLCBhcmdzKTsKICAgICAgICAgICAgICAgICBSRVRV Uk5fSUZfRVhDRVBUSU9OKHRocm93U2NvcGUsIDApOwogCi0gICAgICAgICAgICAgICAgdWludDY0 X3QgcmVhbFJlc3VsdDsKKyAgICAgICAgICAgICAgICB1aW50NjRfdCByZWFsUmVzdWx0ID0gMDsK ICAgICAgICAgICAgICAgICBzd2l0Y2ggKHNpZ25hdHVyZS5yZXR1cm5UeXBlKCkpIHsKICAgICAg ICAgICAgICAgICBjYXNlIEZ1bmM6CiAgICAgICAgICAgICAgICAgY2FzZSBBbnlmdW5jOgpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3lhcnIvWWFyckpJVC5oIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3lhcnIvWWFyckpJVC5oCmluZGV4IDdhMzAwMzVkNWRjMGE0NzU1NjQ1NTM1 ZTU3YzRiOTVlNDA4MGRlY2EuLjhkNzRjMmQ5ZWMzZTFmYzZlYmE3OTgwMTU0ZTY0NmM5ZmNhNjUx NmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS95YXJyL1lhcnJKSVQuaAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUveWFyci9ZYXJySklULmgKQEAgLTIwMyw3ICsyMDMsNyBA QCBwcml2YXRlOgogICAgIE1hY3JvQXNzZW1ibGVyQ29kZVJlZjxZYXJyTWF0Y2hPbmx5OEJpdFB0 clRhZz4gbV9tYXRjaE9ubHk4OwogICAgIE1hY3JvQXNzZW1ibGVyQ29kZVJlZjxZYXJyTWF0Y2hP bmx5MTZCaXRQdHJUYWc+IG1fbWF0Y2hPbmx5MTY7CiAjaWYgRU5BQkxFKFlBUlJfSklUX0FMTF9Q QVJFTlNfRVhQUkVTU0lPTlMpCi0gICAgYm9vbCBtX3VzZXNQYXR0ZXJuQ29udGV4dEJ1ZmZlcjsK KyAgICBib29sIG1fdXNlc1BhdHRlcm5Db250ZXh0QnVmZmVyIHsgZmFsc2UgfTsKICNlbmRpZgog ICAgIE9wdGlvbmFsPEpJVEZhaWx1cmVSZWFzb24+IG1fZmFpbHVyZVJlYXNvbjsKIH07CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2 ZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2 ZW50LmgKaW5kZXggNjk5MTU3NjEyMjE5YzU3NGI4ZGQzODRiMDMyYTUxZGI3Y2Y4ZDUzZi4uYmFm ODAyODFhOTkyNWU2ODNkZGY4YzE1ODc0MWNkM2ZjMTczNTZmZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Byb2Nlc3NpbmdFdmVudC5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Qcm9jZXNzaW5nRXZlbnQuaApAQCAt NTgsNyArNTgsNyBAQCBwcml2YXRlOgogCiAgICAgUmVmUHRyPEF1ZGlvQnVmZmVyPiBtX2lucHV0 QnVmZmVyOwogICAgIFJlZlB0cjxBdWRpb0J1ZmZlcj4gbV9vdXRwdXRCdWZmZXI7Ci0gICAgZG91 YmxlIG1fcGxheWJhY2tUaW1lOworICAgIGRvdWJsZSBtX3BsYXliYWNrVGltZSB7IDAuMCB9Owog fTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJhdWRpby9EZWxheURTUEtlcm5lbC5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxl cy93ZWJhdWRpby9EZWxheURTUEtlcm5lbC5oCmluZGV4IGUyMGYxYTlhY2RiZGNjYzUxNGQ5NDM5 Mzk4Y2FlYjFmY2EwYjc4NTQuLjM4OWZkZTU3NzM1NDNkNjU5YzIyZGZiMjc3ZGY0NDZjYjFlNjFh OTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vRGVsYXlEU1BL ZXJuZWwuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0RlbGF5RFNQS2Vy bmVsLmgKQEAgLTQ5LDEyICs0OSwxMiBAQCBwdWJsaWM6CiAKIHByaXZhdGU6CiAgICAgQXVkaW9G bG9hdEFycmF5IG1fYnVmZmVyOwotICAgIGRvdWJsZSBtX21heERlbGF5VGltZTsKKyAgICBkb3Vi bGUgbV9tYXhEZWxheVRpbWUgeyAwLjAgfTsKICAgICBpbnQgbV93cml0ZUluZGV4OwotICAgIGRv dWJsZSBtX2N1cnJlbnREZWxheVRpbWU7Ci0gICAgZG91YmxlIG1fc21vb3RoaW5nUmF0ZTsKKyAg ICBkb3VibGUgbV9jdXJyZW50RGVsYXlUaW1lIHsgMC4wIH07CisgICAgZG91YmxlIG1fc21vb3Ro aW5nUmF0ZSB7IDAuMCB9OwogICAgIGJvb2wgbV9maXJzdFRpbWU7Ci0gICAgZG91YmxlIG1fZGVz aXJlZERlbGF5RnJhbWVzOworICAgIGRvdWJsZSBtX2Rlc2lyZWREZWxheUZyYW1lcyB7IDAuMCB9 OwogCiAgICAgQXVkaW9GbG9hdEFycmF5IG1fZGVsYXlUaW1lczsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4uaCBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVRhYmxlQ29sdW1uLmgKaW5k ZXggOWZjZGI1Y2YzNmUyNzk2M2FlODIwMGIyNDAwYzM3M2JiNWUzOThjNS4uYjNmYWM4YTUwOTEy ZGJjNDgxNWM0Y2U0MTAwY2YxOGViNzZiMzcwYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4uaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlUYWJsZUNvbHVtbi5oCkBAIC0zMywzNiAr MzMsMzYgQEAKICNpbmNsdWRlICJJbnRSZWN0LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKLSAg ICAKKwogY2xhc3MgUmVuZGVyVGFibGVTZWN0aW9uOwogCiBjbGFzcyBBY2Nlc3NpYmlsaXR5VGFi bGVDb2x1bW4gZmluYWwgOiBwdWJsaWMgQWNjZXNzaWJpbGl0eU1vY2tPYmplY3QgewogcHVibGlj OgogICAgIHN0YXRpYyBSZWY8QWNjZXNzaWJpbGl0eVRhYmxlQ29sdW1uPiBjcmVhdGUoKTsKICAg ICB2aXJ0dWFsIH5BY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4oKTsKLSAgICAKKwogICAgIEFjY2Vz c2liaWxpdHlPYmplY3QqIGhlYWRlck9iamVjdCgpOwotICAgICAgICAKKwogICAgIEFjY2Vzc2li aWxpdHlSb2xlIHJvbGVWYWx1ZSgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIEFjY2Vzc2liaWxp dHlSb2xlOjpDb2x1bW47IH0KLSAgICAKKwogICAgIHZvaWQgc2V0Q29sdW1uSW5kZXgoaW50IGNv bHVtbkluZGV4KSB7IG1fY29sdW1uSW5kZXggPSBjb2x1bW5JbmRleDsgfQotICAgIGludCBjb2x1 bW5JbmRleCgpIGNvbnN0IHsgcmV0dXJuIG1fY29sdW1uSW5kZXg7IH0gICAgCi0gICAgCisgICAg aW50IGNvbHVtbkluZGV4KCkgY29uc3QgeyByZXR1cm4gbV9jb2x1bW5JbmRleDsgfQorCiAgICAg dm9pZCBhZGRDaGlsZHJlbigpIG92ZXJyaWRlOwogICAgIHZvaWQgc2V0UGFyZW50KEFjY2Vzc2li aWxpdHlPYmplY3QqKSBvdmVycmlkZTsKLSAgICAKKwogICAgIExheW91dFJlY3QgZWxlbWVudFJl Y3QoKSBjb25zdCBvdmVycmlkZTsKLSAgICAKKwogcHJpdmF0ZToKICAgICBBY2Nlc3NpYmlsaXR5 VGFibGVDb2x1bW4oKTsKLSAgICAKKwogICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIGhlYWRlck9i amVjdEZvclNlY3Rpb24oUmVuZGVyVGFibGVTZWN0aW9uKiwgYm9vbCB0aFRhZ1JlcXVpcmVkKTsK ICAgICBib29sIGNvbXB1dGVBY2Nlc3NpYmlsaXR5SXNJZ25vcmVkKCkgY29uc3Qgb3ZlcnJpZGU7 CiAgICAgYm9vbCBpc1RhYmxlQ29sdW1uKCkgY29uc3Qgb3ZlcnJpZGUgeyByZXR1cm4gdHJ1ZTsg fQogCi0gICAgdW5zaWduZWQgbV9jb2x1bW5JbmRleDsKKyAgICB1bnNpZ25lZCBtX2NvbHVtbklu ZGV4IHsgMCB9OwogfTsKIAotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZSAKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKIAogU1BFQ0lBTElaRV9UWVBFX1RSQUlUU19BQ0NFU1NJQklMSVRZKEFjY2Vzc2li aWxpdHlUYWJsZUNvbHVtbiwgaXNUYWJsZUNvbHVtbigpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYW5pbWF0aW9uL0RlY2xhcmF0aXZlQW5pbWF0aW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9h bmltYXRpb24vRGVjbGFyYXRpdmVBbmltYXRpb24uaAppbmRleCBkOTU4MzhmYmQ4YTc0NjRlMGEw OWUyZmNlYmUwMTYxZTJlZGM5M2I2Li4yMzNhNmZmYmYwNmI0OGE1OWI3NjMwNmRiODQ1ZjhhOTc3 OWRiNDk1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vRGVjbGFyYXRpdmVB bmltYXRpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vRGVjbGFyYXRpdmVBbmlt YXRpb24uaApAQCAtOTIsNyArOTIsNyBAQCBwcml2YXRlOgogCiAgICAgRWxlbWVudCogbV9vd25p bmdFbGVtZW50OwogICAgIFJlZjxBbmltYXRpb24+IG1fYmFja2luZ0FuaW1hdGlvbjsKLSAgICBk b3VibGUgbV9wcmV2aW91c0l0ZXJhdGlvbjsKKyAgICBkb3VibGUgbV9wcmV2aW91c0l0ZXJhdGlv biB7IDAuMCB9OwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmggYi9Tb3VyY2Uv V2ViQ29yZS9kb20vUmVxdWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2suaAppbmRleCAwNjM5OGM0 MzU1YTEyZjllODA2NTlkNDBjOTYzODk5NTMyZWRiZDZmLi4yMjJiZDY5NGM4MzZjMjg3YTEwYzc3 MmU0YTI4NDUxNDk3M2E0NDE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vUmVxdWVz dEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2suaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vUmVxdWVz dEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2suaApAQCAtNDIsOCArNDIsOCBAQCBwdWJsaWM6CiAKICAg ICB2aXJ0dWFsIENhbGxiYWNrUmVzdWx0PHZvaWQ+IGhhbmRsZUV2ZW50KGRvdWJsZSBoaWdoUmVz VGltZU1zKSA9IDA7CiAKLSAgICBpbnQgbV9pZDsKLSAgICBib29sIG1fZmlyZWRPckNhbmNlbGxl ZDsKKyAgICBpbnQgbV9pZCB7IDAgfTsKKyAgICBib29sIG1fZmlyZWRPckNhbmNlbGxlZCB7IGZh bHNlIH07CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MTWVkaWFFbGVtZW50LmNwcAppbmRleCAyZThiZGFiM2I5YWI3YzdjNDFhYTM4NzRmMzA4YzMy MTg1YmYwMTBiLi44ZjE0MWMxYjJkMWNjYjFhNDI1ODViOTE0MzhhNTFjZGE5NGQ1YTk1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKQEAgLTIwOTgsOSArMjA5OCwx MCBAQCBib29sIEhUTUxNZWRpYUVsZW1lbnQ6OmlzU2FmZVRvTG9hZFVSTChjb25zdCBVUkwmIHVy bCwgSW52YWxpZFVSTEFjdGlvbiBhY3Rpb25JZgogCiAgICAgUmVmUHRyPEZyYW1lPiBmcmFtZSA9 IGRvY3VtZW50KCkuZnJhbWUoKTsKICAgICBpZiAoIWZyYW1lIHx8ICFkb2N1bWVudCgpLnNlY3Vy aXR5T3JpZ2luKCkuY2FuRGlzcGxheSh1cmwpKSB7Ci0gICAgICAgIGlmIChhY3Rpb25JZkludmFs aWQgPT0gQ29tcGxhaW4pCisgICAgICAgIGlmIChhY3Rpb25JZkludmFsaWQgPT0gQ29tcGxhaW4p IHsKICAgICAgICAgICAgIEZyYW1lTG9hZGVyOjpyZXBvcnRMb2NhbExvYWRGYWlsZWQoZnJhbWUu Z2V0KCksIHVybC5zdHJpbmdDZW50ZXJFbGxpcHNpemVkVG9MZW5ndGgoKSk7CiAgICAgICAgICAg ICBFUlJPUl9MT0coTE9HSURFTlRJRklFUiwgdXJsICwgIiB3YXMgcmVqZWN0ZWQgYnkgU2VjdXJp dHlPcmlnaW4iKTsKKyAgICAgICAgfQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZW51RWxlbWVudC5oIGIvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MTWVudUVsZW1lbnQuaAppbmRleCBlNjU5ZjcwODA1Mzc2YjFiYzVm MmIzMWE5NjRkZGFkMDlhM2E4YWE1Li44ZjViNzg1ZjBhNGUwMDU3YjZhOGJhNDMzMDZjY2EwNDE5 OThhZDE0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZW51RWxlbWVudC5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lbnVFbGVtZW50LmgKQEAgLTQwLDcgKzQw LDcgQEAgcHJpdmF0ZToKICAgICB2b2lkIHJlbW92ZWRGcm9tQW5jZXN0b3IoUmVtb3ZhbFR5cGUs IENvbnRhaW5lck5vZGUmKSBmaW5hbDsKICAgICB2b2lkIHBhcnNlQXR0cmlidXRlKGNvbnN0IFF1 YWxpZmllZE5hbWUmLCBjb25zdCBBdG9taWNTdHJpbmcmKSBmaW5hbDsKIAotICAgIGJvb2wgbV9p c1RvdWNoQmFyTWVudTsKKyAgICBib29sIG1faXNUb3VjaEJhck1lbnUgeyBmYWxzZSB9OwogfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvQU5HTEVXZWJLaXRCcmlkZ2UuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL0FOR0xFV2ViS2l0QnJpZGdlLmgKaW5kZXggMzgyMzU5MTk1MjY0ZDdhNTAw NTZmYTFkYzlmNDBiZWM3NWVjNzkxNS4uNmQ4ZWNlNDBlY2NiMDg3OGM4MjRhNDBlNWQzZTVjNmJj ODEyYzE1MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQU5H TEVXZWJLaXRCcmlkZ2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9B TkdMRVdlYktpdEJyaWRnZS5oCkBAIC05Miw3ICs5Miw3IEBAIHByaXZhdGU6CiAgICAgU2hTaGFk ZXJPdXRwdXQgbV9zaGFkZXJPdXRwdXQ7CiAgICAgU2hTaGFkZXJTcGVjIG1fc2hhZGVyU3BlYzsK IAotICAgIFNoQnVpbHRJblJlc291cmNlcyBtX3Jlc291cmNlczsKKyAgICBTaEJ1aWx0SW5SZXNv dXJjZXMgbV9yZXNvdXJjZXMgeyB9OwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhZGllbnRJbWFnZS5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhZGllbnRJbWFnZS5oCmluZGV4 IGQ3NGQ1NzhhMmM5MzQ2ZjYxNzE0ZmQwOGY3ZTA4OGM3OGFkODAxMGIuLjQwODM5M2ZiZWQwMWIx YWQ1OGQ4YjkzOTM1ZTIxOThlNWE2NTM4ODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0dyYWRpZW50SW1hZ2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9HcmFkaWVudEltYWdlLmgKQEAgLTU0LDcgKzU0LDcgQEAgcHJpdmF0ZToK ICAgICBSZWY8R3JhZGllbnQ+IG1fZ3JhZGllbnQ7CiAgICAgUmVmUHRyPEltYWdlPiBtX2NhY2hl ZEltYWdlOwogICAgIEZsb2F0U2l6ZSBtX2NhY2hlZEFkanVzdGVkU2l6ZTsKLSAgICB1bnNpZ25l ZCBtX2NhY2hlZEdlbmVyYXRvckhhc2g7CisgICAgdW5zaWduZWQgbV9jYWNoZWRHZW5lcmF0b3JI YXNoIHsgMCB9OwogICAgIEZsb2F0U2l6ZSBtX2NhY2hlZFNjYWxlRmFjdG9yOwogfTsKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlh UGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCmlu ZGV4IDVjYjVmNzUzNmFjM2NlZmUxZTE2Yzk4ZmU5NjcwMjExMzBhNmRmNzQuLmFkYTZhY2ZkODgy ZGMxZGVmNzliZDFkYzMxYjYxYjgzZDk0MmM5MDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJC YXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIv TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKQEAgLTIyMSw3ICsyMjEsNyBAQCBw cml2YXRlOgogICAgIEdzdEJ1ZmZlciogbV9idWZmZXI7CiAgICAgR3N0VmlkZW9GcmFtZSBtX3Zp ZGVvRnJhbWUgeyB9OwogICAgIEludFNpemUgbV9zaXplOwotICAgIGJvb2wgbV9oYXNBbHBoYUNo YW5uZWw7CisgICAgYm9vbCBtX2hhc0FscGhhQ2hhbm5lbCB7IGZhbHNlIH07CiAgICAgVGV4dHVy ZU1hcHBlckdMOjpGbGFncyBtX2ZsYWdzIHsgfTsKICAgICBHTHVpbnQgbV90ZXh0dXJlSUQgeyAw IH07CiAgICAgYm9vbCBtX2lzTWFwcGVkIHsgZmFsc2UgfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RleG1hcC9UZXh0dXJlTWFwcGVyUGxhdGZvcm1MYXll ckJ1ZmZlci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdGV4bWFwL1RleHR1 cmVNYXBwZXJQbGF0Zm9ybUxheWVyQnVmZmVyLmgKaW5kZXggZDEwMGUyNGFkMTMxNjQ5Nzk0Yjkw NjkyZTY2MTJhMzdhYjdjOWFlYi4uNDZiOGRkNzQxOWFmY2RmZjM5NDEzMmUwNmNiZTc2ZTFhMDFl ZWExNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdGV4bWFw L1RleHR1cmVNYXBwZXJQbGF0Zm9ybUxheWVyQnVmZmVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvdGV4bWFwL1RleHR1cmVNYXBwZXJQbGF0Zm9ybUxheWVyQnVmZmVy LmgKQEAgLTgwLDcgKzgwLDcgQEAgcHJpdmF0ZToKIAogICAgIEdMdWludCBtX3RleHR1cmVJRDsK ICAgICBJbnRTaXplIG1fc2l6ZTsKLSAgICBHTGludCBtX2ludGVybmFsRm9ybWF0OworICAgIEdM aW50IG1faW50ZXJuYWxGb3JtYXQgeyAwIH07CiAgICAgVGV4dHVyZU1hcHBlckdMOjpGbGFncyBt X2V4dHJhRmxhZ3M7CiAgICAgYm9vbCBtX2hhc01hbmFnZWRUZXh0dXJlOwogICAgIHN0ZDo6dW5p cXVlX3B0cjxVbm1hbmFnZWRCdWZmZXJEYXRhSG9sZGVyPiBtX3VubWFuYWdlZEJ1ZmZlckRhdGFI b2xkZXI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvU2Nyb2xsYmFy VGhlbWVHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Njcm9sbGJhclRoZW1l R3RrLmNwcAppbmRleCAyMDlhZjdiNTVkYmE0YjExNDA5NjRmZDVjZTE0NjEwOTVkMDNmMjBiLi45 MTExM2EwZDczNzI0ZjJkNmUwNzUzNGYxYWI5OTM3ZmEzYzI3YzhhIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvU2Nyb2xsYmFyVGhlbWVHdGsuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TY3JvbGxiYXJUaGVtZUd0ay5jcHAKQEAgLTUzLDYgKzUz LDEwIEBAIHN0YXRpYyB2b2lkIHRoZW1lQ2hhbmdlZENhbGxiYWNrKCkKIH0KIAogU2Nyb2xsYmFy VGhlbWVHdGs6OlNjcm9sbGJhclRoZW1lR3RrKCkKKyAgICA6IG1faGFzRm9yd2FyZEJ1dHRvblN0 YXJ0UGFydChmYWxzZSkKKyAgICAsIG1faGFzRm9yd2FyZEJ1dHRvbkVuZFBhcnQoZmFsc2UpCisg ICAgLCBtX2hhc0JhY2tCdXR0b25TdGFydFBhcnQoZmFsc2UpCisgICAgLCBtX2hhc0JhY2tCdXR0 b25FbmRQYXJ0KGZhbHNlKQogewogI2lmIEdUS19DSEVDS19WRVJTSU9OKDMsIDIwLCAwKQogICAg IG1fdXNlc092ZXJsYXlTY3JvbGxiYXJzID0gZ19zdHJjbXAwKGdfZ2V0ZW52KCJHVEtfT1ZFUkxB WV9TQ1JPTExJTkciKSwgIjAiKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2ltYWdlLWRlY29kZXJzL2pwZWcvSlBFR0ltYWdlRGVjb2Rlci5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9qcGVnL0pQRUdJbWFnZURlY29kZXIuY3BwCmluZGV4 IGI3MmM1NWEyY2I5MDlmYTM0NjFjZjc5NWYwNGRjZWFkNTEwNGU4ZWUuLmQyYzY3ZWZkOTQwNGQ1 ZmFiMGRiNDI0ODAzYTU5OTkxZTRlMGRkOWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2ltYWdlLWRlY29kZXJzL2pwZWcvSlBFR0ltYWdlRGVjb2Rlci5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvanBlZy9KUEVHSW1hZ2VEZWNvZGVy LmNwcApAQCAtNDU0LDEwICs0NTQsMTAgQEAgcHJpdmF0ZToKICAgICBKUEVHSW1hZ2VEZWNvZGVy KiBtX2RlY29kZXI7CiAgICAgdW5zaWduZWQgbV9idWZmZXJMZW5ndGg7CiAgICAgaW50IG1fYnl0 ZXNUb1NraXA7Ci0gICAgYm9vbCBtX2RlY29kaW5nU2l6ZU9ubHk7CisgICAgYm9vbCBtX2RlY29k aW5nU2l6ZU9ubHkgeyBmYWxzZSB9OwogCiAgICAganBlZ19kZWNvbXByZXNzX3N0cnVjdCBtX2lu Zm87Ci0gICAgZGVjb2Rlcl9lcnJvcl9tZ3IgbV9lcnI7CisgICAgZGVjb2Rlcl9lcnJvcl9tZ3Ig bV9lcnIgeyB9OwogICAgIGpzdGF0ZSBtX3N0YXRlOwogCiAgICAgSlNBTVBBUlJBWSBtX3NhbXBs ZXM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRDb2RlY1VU RjE2LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRDb2RlY1VURjE2LmgKaW5k ZXggYzExYmJmYjFjYThiOGYzYTkxYjFhN2VmODVlMjRiYjRlYzE4MzljNy4uYmNiMTRkNzRmNTBl MzI2ZWNlZGFjZjBiNzVlODNiYzE3ZTE0MzMyMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vdGV4dC9UZXh0Q29kZWNVVEYxNi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL3RleHQvVGV4dENvZGVjVVRGMTYuaApAQCAtNDIsNyArNDIsNyBAQCBwcml2YXRlOgogCiAg ICAgYm9vbCBtX2xpdHRsZUVuZGlhbjsKICAgICBib29sIG1faGF2ZUJ1ZmZlcmVkQnl0ZSB7IGZh bHNlIH07Ci0gICAgdW5zaWduZWQgY2hhciBtX2J1ZmZlcmVkQnl0ZTsKKyAgICB1bnNpZ25lZCBj aGFyIG1fYnVmZmVyZWRCeXRlIHsgMCB9OwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckZyYWdtZW50ZWRGbG93 LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRnJhZ21lbnRlZEZsb3cuaAppbmRl eCA0YzM5NzdlNWYwYmU2MzI3MDNjYjZkZmM1YzRkNTBhNmQzMzhkOGJkLi43NTkyNTE2MGVmN2Y4 ZjMwZDc4ODIwMGQ2ZDM1MmRiMWFhZTYwNDg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyRnJhZ21lbnRlZEZsb3cuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyRnJhZ21lbnRlZEZsb3cuaApAQCAtMjI3LDcgKzIyNyw3IEBAIHByb3RlY3Rl ZDoKICAgICBwcml2YXRlOgogICAgICAgICBXZWFrUHRyPFJlbmRlckZyYWdtZW50Q29udGFpbmVy PiBtX3N0YXJ0RnJhZ21lbnQ7CiAgICAgICAgIFdlYWtQdHI8UmVuZGVyRnJhZ21lbnRDb250YWlu ZXI+IG1fZW5kRnJhZ21lbnQ7Ci0gICAgICAgIGJvb2wgbV9yYW5nZUludmFsaWRhdGVkOworICAg ICAgICBib29sIG1fcmFuZ2VJbnZhbGlkYXRlZCB7IGZhbHNlIH07CiAgICAgfTsKIAogICAgIHR5 cGVkZWYgUE9ESW50ZXJ2YWw8TGF5b3V0VW5pdCwgV2Vha1B0cjxSZW5kZXJGcmFnbWVudENvbnRh aW5lcj4+IEZyYWdtZW50SW50ZXJ2YWw7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS93b3Jr ZXJzL1dvcmtlclNjcmlwdExvYWRlci5oIGIvU291cmNlL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJT Y3JpcHRMb2FkZXIuaAppbmRleCBiNTc0ODU2OGFmMWI5NGFlNDNjMTRiNDM5NzI0Y2I5ZmQ0NTUz OTNkLi4yYjA5MDA3ZDY2NWM1NmQ5MTBiMzgxYjVkOTBlZTY1ZWRlYjExZmZiIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzL1dvcmtlclNjcmlwdExvYWRlci5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyU2NyaXB0TG9hZGVyLmgKQEAgLTk0LDcgKzk0LDcgQEAg cHJpdmF0ZToKICAgICBVUkwgbV91cmw7CiAgICAgVVJMIG1fcmVzcG9uc2VVUkw7CiAgICAgU3Ry aW5nIG1fcmVzcG9uc2VNSU1FVHlwZTsKLSAgICBGZXRjaE9wdGlvbnM6OkRlc3RpbmF0aW9uIG1f ZGVzdGluYXRpb247CisgICAgRmV0Y2hPcHRpb25zOjpEZXN0aW5hdGlvbiBtX2Rlc3RpbmF0aW9u IHsgRmV0Y2hPcHRpb25zOjpEZXN0aW5hdGlvbjo6RW1wdHlTdHJpbmcgfTsKICAgICBDb250ZW50 U2VjdXJpdHlQb2xpY3lSZXNwb25zZUhlYWRlcnMgbV9jb250ZW50U2VjdXJpdHlQb2xpY3k7CiAg ICAgU3RyaW5nIG1fcmVmZXJyZXJQb2xpY3k7CiAgICAgdW5zaWduZWQgbG9uZyBtX2lkZW50aWZp ZXIgeyAwIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9QbHVnaW5zL1BsdWdp blByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1BsdWdp bnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCmluZGV4IGQzMjY4ODBhOTQ3N2Iz YWJlYjNhYjM5NjBhYWQwYmFjMTJhNTNhOGYuLmJlMDc1ZWMzM2E2N2YxNmE3ZmU4YTVmOTY5ZDFm OTAwMmVmNWM4ZTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1BsdWdpbnMvUGx1 Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVk L1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCkBAIC00Nyw3ICs0Nyw3 IEBAIHN0cnVjdCBQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzIHsKICAgICB2b2lkIGVu Y29kZShJUEM6OkVuY29kZXImKSBjb25zdDsKICAgICBzdGF0aWMgYm9vbCBkZWNvZGUoSVBDOjpE ZWNvZGVyJiwgUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyYpOwogCi0gICAgUGx1Z2lu UHJvY2Vzc1R5cGUgcHJvY2Vzc1R5cGU7CisgICAgUGx1Z2luUHJvY2Vzc1R5cGUgcHJvY2Vzc1R5 cGUgeyBQbHVnaW5Qcm9jZXNzVHlwZU5vcm1hbCB9OwogICAgIGJvb2wgc3VwcG9ydHNBc3luY2hy b25vdXNQbHVnaW5Jbml0aWFsaXphdGlvbjsKIAogICAgIFNlY29uZHMgbWluaW11bUxpZmV0aW1l OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvSWNvbkRhdGFi YXNlLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9JY29uRGF0YWJhc2UuaApp bmRleCBiYWJkOGE5ODI5ZmI4MGQxOTg1MmVjOTc0YWVlYTcwY2VlMGI5MTU4Li4yMGRhOTcyMzMx YzYwMzM2MzE5MjA1Y2U2MDU4NTc5MzBmZTU0ZTBlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9BUEkvZ2xpYi9JY29uRGF0YWJhc2UuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9BUEkvZ2xpYi9JY29uRGF0YWJhc2UuaApAQCAtMjI2LDcgKzIyNiw3IEBAIHByaXZh dGU6CiAKICAgICAgICAgRGVxdWU8RnVuY3Rpb248dm9pZCgpPj4gbV9ub3RpZmljYXRpb25RdWV1 ZTsKICAgICAgICAgTG9jayBtX25vdGlmaWNhdGlvblF1ZXVlTG9jazsKLSAgICAgICAgQXRvbWlj PGJvb2w+IG1faXNBY3RpdmU7CisgICAgICAgIEF0b21pYzxib29sPiBtX2lzQWN0aXZlIHsgZmFs c2UgfTsKICAgICAgICAgUnVuTG9vcDo6VGltZXI8TWFpblRocmVhZE5vdGlmaWVyPiBtX3RpbWVy OwogICAgIH07CiAK 367314 2019-04-12 04:08:23 -0700 2019-04-16 03:43:56 -0700 Patch bug-196855-20190412130822.patch text/plain 27895 erack U3VidmVyc2lvbiBSZXZpc2lvbjogMjQ0MTg3CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAz NWIzOWU3MDI2ODlmMThhMzkyM2U0NTYyZGMxNTY4YTU3ZWZjNjRlLi5mMmIwZmFlN2E2MDdlZDcw NmY1NzY4N2Q3MDM3MWZkOWRlNmY4NDEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNSBAQAorMjAxOS0wNC0xMiAgRWlrZSBSYXRoa2UgIDxlcmFja0ByZWRoYXQuY29tPgor CisgICAgICAgIEZpeCBDb3ZzY2FuIHVuaW5pdGlhbGl6ZWQgYWZ0ZXIgY3RvcgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk2ODU1CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4IGEgYnVuY2ggb2YgQ292 ZXJpdHkgU2NhbiBVTklOSVRfQ1RPUiBlcnJvcnMsIHdoZXJlIGFmdGVyCisgICAgICAgIGNvbnN0 cnVjdGluZyBhbiBvYmplY3QgaW5zdGFuY2UgbWVtYmVyIHZhcmlhYmxlcyB3ZXJlIGxlZnQKKyAg ICAgICAgdW5pbml0aWFsaXplZC4KKworICAgICAgICAqIGIzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lz dGVyc0J5R3JhcGhDb2xvcmluZy5jcHA6CisgICAgICAgICogYnl0ZWNvZGUvUG9seW1vcnBoaWNB Y2Nlc3MuaDoKKyAgICAgICAgKiBkZmcvREZHT1NSRXhpdC5oOgorICAgICAgICAqIGRmZy9ERkdQ cmVkaWN0aW9uUHJvcGFnYXRpb25QaGFzZS5jcHA6CisgICAgICAgICogZnRsL0ZUTExvd2VyREZH VG9CMy5jcHA6CisgICAgICAgICogcGFyc2VyL05vZGVzLmg6CisgICAgICAgICogcnVudGltZS9D b2RlQ2FjaGUuY3BwOgorICAgICAgICAoSlNDOjpDb2RlQ2FjaGU6OmdldFVubGlua2VkR2xvYmFs RnVuY3Rpb25FeGVjdXRhYmxlKToKKyAgICAgICAgKiBydW50aW1lL0NvbmZpZ0ZpbGUuY3BwOgor ICAgICAgICAqIHJ1bnRpbWUvRXJyb3JJbnN0YW5jZS5oOgorICAgICAgICAqIHJ1bnRpbWUvSlNC aWdJbnQuaDoKKyAgICAgICAgKiBydW50aW1lL1Byb3BlcnR5U2xvdC5oOgorICAgICAgICAqIHdh c20vV2FzbUIzSVJHZW5lcmF0b3IuY3BwOgorICAgICAgICAqIHdhc20vV2FzbUZvcm1hdC5oOgor ICAgICAgICAqIHdhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmg6CisgICAgICAgICogd2FzbS9XYXNt VGllclVwQ291bnQuaDoKKyAgICAgICAgKiB3YXNtL1dhc21WYWxpZGF0ZS5jcHA6CisgICAgICAg ICogd2FzbS9qcy9XYXNtVG9KUy5jcHA6CisgICAgICAgIChKU0M6Oldhc206Ondhc21Ub0pTKToK KyAgICAgICAgKiB5YXJyL1lhcnJKSVQuaDoKKwogMjAxOS0wNC0xMCAgU2FhbSBCYXJhdGkgIDxz YmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBBYnN0cmFjdFZhbHVlOjp2YWxpZGF0ZU9TUkVu dHJ5VmFsdWUgaXMgd3JvbmcgZm9yIEludDUyIGNvbnN0YW50cwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDgxODE3 ODYyYzQ0MjlhYzIyODRmOWFjYTVmNTlhMDYwYWY5Yzg1NmUuLmQ1OTc0ODAwNzNjNmQ4MjIxYWQ1 NjZjYjMyYWYxN2FkN2ViODJhNjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMyBAQAorMjAxOS0w NC0xMiAgRWlrZSBSYXRoa2UgIDxlcmFja0ByZWRoYXQuY29tPgorCisgICAgICAgIEZpeCBDb3Zz Y2FuIHVuaW5pdGlhbGl6ZWQgYWZ0ZXIgY3RvcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk2ODU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgRml4IGEgYnVuY2ggb2YgQ292ZXJpdHkgU2NhbiBVTklOSVRf Q1RPUiBlcnJvcnMsIHdoZXJlIGFmdGVyCisgICAgICAgIGNvbnN0cnVjdGluZyBhbiBvYmplY3Qg aW5zdGFuY2UgbWVtYmVyIHZhcmlhYmxlcyB3ZXJlIGxlZnQKKyAgICAgICAgdW5pbml0aWFsaXpl ZC4KKworICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9Qcm9jZXNzaW5nRXZlbnQuaDoK KyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0RlbGF5RFNQS2VybmVsLmg6CisgICAgICAgICog YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4uaDoKKyAgICAgICAgKiBhbmlt YXRpb24vRGVjbGFyYXRpdmVBbmltYXRpb24uaDoKKyAgICAgICAgKiBkb20vUmVxdWVzdEFuaW1h dGlvbkZyYW1lQ2FsbGJhY2suaDoKKyAgICAgICAgKiBodG1sL0hUTUxNZWRpYUVsZW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SFRNTE1lZGlhRWxlbWVudDo6aXNTYWZlVG9Mb2FkVVJMKToK KyAgICAgICAgKiBodG1sL0hUTUxNZW51RWxlbWVudC5oOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL0FOR0xFV2ViS2l0QnJpZGdlLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv R3JhZGllbnRJbWFnZS5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9N ZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcDoKKyAgICAgICAgKiBwbGF0Zm9ybS9n cmFwaGljcy90ZXhtYXAvVGV4dHVyZU1hcHBlclBsYXRmb3JtTGF5ZXJCdWZmZXIuaDoKKyAgICAg ICAgKiBwbGF0Zm9ybS9ndGsvU2Nyb2xsYmFyVGhlbWVHdGsuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6U2Nyb2xsYmFyVGhlbWVHdGs6OlNjcm9sbGJhclRoZW1lR3RrKToKKyAgICAgICAgKiBwbGF0 Zm9ybS9pbWFnZS1kZWNvZGVycy9qcGVnL0pQRUdJbWFnZURlY29kZXIuY3BwOgorICAgICAgICAq IHBsYXRmb3JtL3RleHQvVGV4dENvZGVjVVRGMTYuaDoKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyRnJhZ21lbnRlZEZsb3cuaDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclNjcmlwdExvYWRl ci5oOgorCiAyMDE5LTA0LTExICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlh LmNvbT4KIAogICAgICAgICBbR1RLXSBMYXlvdXQgdGVzdCBhY2Nlc3NpYmlsaXR5L2FyaWEtaGlk ZGVuLWZhbHNlLXdvcmtzLWluLXN1YnRyZWVzLmh0bWwgZmFpbHMgYWZ0ZXIgcjE4NDg5MApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxv ZwppbmRleCBjNjg4YmExOWFkY2RiMTMxZTJmZjk3MzRkOWU0YmM3OWFlYTkzMjkyLi4zNTEzZjkx OTg3ZDJmYjdmOTVhYWZmMDQ2MmRmZjI2ZjhmNjZjOWIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3 IEBACisyMDE5LTA0LTEyICBFaWtlIFJhdGhrZSAgPGVyYWNrQHJlZGhhdC5jb20+CisKKyAgICAg ICAgRml4IENvdnNjYW4gdW5pbml0aWFsaXplZCBhZnRlciBjdG9yCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xOTY4NTUKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBGaXggYSBidW5jaCBvZiBDb3Zlcml0eSBT Y2FuIFVOSU5JVF9DVE9SIGVycm9ycywgd2hlcmUgYWZ0ZXIKKyAgICAgICAgY29uc3RydWN0aW5n IGFuIG9iamVjdCBpbnN0YW5jZSBtZW1iZXIgdmFyaWFibGVzIHdlcmUgbGVmdAorICAgICAgICB1 bmluaXRpYWxpemVkLgorCisgICAgICAgICogU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVycy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ2xpYi9JY29uRGF0 YWJhc2UuaDoKKwogMjAxOS0wNC0xMCAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUuY29tPgog CiAgICAgICAgIFJlZ3Jlc3Npb24ocjI0NDE0NCkgUHJvY2Vzc1N3YXAuUmV1c2VTdXNwZW5kZWRQ cm9jZXNzTG9hZEhUTUxTdHJpbmcgQVBJIHRlc3QgaXMgZmxha3kKZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9iMy9haXIvQWlyQWxsb2NhdGVSZWdpc3RlcnNCeUdyYXBoQ29sb3Jp bmcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2IzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lzdGVy c0J5R3JhcGhDb2xvcmluZy5jcHAKaW5kZXggOGY0OTc2NTBhY2JlN2ViMmI3ZjJjN2U0ZGRmYzc3 N2M4ZWM2ODQ1My4uN2Q4MDQ4ZDFlODRlNWQ4ZmUyMjZlZjJmNWFkNTRhYmYyZmVhODdmYSAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2IzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lzdGVy c0J5R3JhcGhDb2xvcmluZy5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2IzL2Fpci9B aXJBbGxvY2F0ZVJlZ2lzdGVyc0J5R3JhcGhDb2xvcmluZy5jcHAKQEAgLTg3Niw3ICs4NzYsNyBA QCBwcm90ZWN0ZWQ6CiAgICAgICAgIH0KIAogICAgIHByaXZhdGU6Ci0gICAgICAgIHVuc2lnbmVk IG1fcG9zaXRpb25Jbk1vdmVMaXN0OworICAgICAgICB1bnNpZ25lZCBtX3Bvc2l0aW9uSW5Nb3Zl TGlzdCB7IDAgfTsKICAgICAgICAgVmVjdG9yPHVuc2lnbmVkLCAwLCBVbnNhZmVWZWN0b3JPdmVy Zmxvdz4gbV9tb3ZlTGlzdDsKICAgICAgICAgVmVjdG9yPHVuc2lnbmVkLCAwLCBVbnNhZmVWZWN0 b3JPdmVyZmxvdz4gbV9sb3dQcmlvcml0eU1vdmVMaXN0OwogICAgIH07CmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvYnl0ZWNvZGUvUG9seW1vcnBoaWNBY2Nlc3MuaCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ieXRlY29kZS9Qb2x5bW9ycGhpY0FjY2Vzcy5oCmluZGV4IDMwNTU4 NTUxY2JjYWIwMTlmNDU4ZjczOWQ1NjljZWVlMWMwNDYyYWUuLjVlNzJlYWE4ZGJlNWYxZGVhNTNh YTgxYTc0M2Y1ODc1MjZmMjViZTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9i eXRlY29kZS9Qb2x5bW9ycGhpY0FjY2Vzcy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9i eXRlY29kZS9Qb2x5bW9ycGhpY0FjY2Vzcy5oCkBAIC0xMjIsNyArMTIyLDcgQEAgcHVibGljOgog ICAgIH0KICAgICAKIHByaXZhdGU6Ci0gICAgS2luZCBtX2tpbmQ7CisgICAgS2luZCBtX2tpbmQg eyBNYWRlTm9DaGFuZ2VzIH07CiAgICAgTWFjcm9Bc3NlbWJsZXJDb2RlUHRyPEpJVFN0dWJSb3V0 aW5lUHRyVGFnPiBtX2NvZGU7CiAgICAgVmVjdG9yPHN0ZDo6cGFpcjxJbmxpbmVXYXRjaHBvaW50 U2V0JiwgU3RyaW5nRmlyZURldGFpbD4+IG1fd2F0Y2hwb2ludHNUb0ZpcmU7CiB9OwpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0LmggYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvZGZnL0RGR09TUkV4aXQuaAppbmRleCBmNTQyMmVhMjkyNWU4MDRkZWU4YWQ4 NWE1MDFiZWY2ZWE1ZjFiYTlmLi5lNmFmOGI1YTE5MTZlNjYzZmNkZTI1NGRlYThjZGM2NzI5MGQ5 MTgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR09TUkV4aXQuaAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR09TUkV4aXQuaApAQCAtMTMyLDcgKzEz Miw3IEBAIHN0cnVjdCBPU1JFeGl0U3RhdGUgOiBSZWZDb3VudGVkPE9TUkV4aXRTdGF0ZT4gewog ICAgIHZvaWQqIGp1bXBUYXJnZXQ7CiAgICAgQXJyYXlQcm9maWxlKiBhcnJheVByb2ZpbGU7CiAK LSAgICBFeHRyYUluaXRpYWxpemF0aW9uTGV2ZWwgZXh0cmFJbml0aWFsaXphdGlvbkxldmVsOwor ICAgIEV4dHJhSW5pdGlhbGl6YXRpb25MZXZlbCBleHRyYUluaXRpYWxpemF0aW9uTGV2ZWwgeyB9 OwogICAgIFByb2ZpbGVyOjpPU1JFeGl0KiBwcm9maWxlckV4aXQgeyBudWxscHRyIH07CiB9Owog CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR1ByZWRpY3Rpb25Qcm9w YWdhdGlvblBoYXNlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHUHJlZGljdGlv blByb3BhZ2F0aW9uUGhhc2UuY3BwCmluZGV4IDYyOWRiZTRkOTU5MzFhOTEyZGEzMTc5YmFjMDAw ZTZmNDU5Y2ZlM2QuLmJmMzk0YWYyYmI2N2JhMGZlNDc3MzdmNTQyOGE5MmEzYmIzYTY0MDUgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHUHJlZGljdGlvblByb3BhZ2F0 aW9uUGhhc2UuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHUHJlZGljdGlv blByb3BhZ2F0aW9uUGhhc2UuY3BwCkBAIC0xMzMxLDcgKzEzMzEsNyBAQCBwcml2YXRlOgogICAg IH0KIAogICAgIFZlY3RvcjxOb2RlKj4gbV9kZXBlbmRlbnROb2RlczsKLSAgICBOb2RlKiBtX2N1 cnJlbnROb2RlOworICAgIE5vZGUqIG1fY3VycmVudE5vZGUgeyBudWxscHRyIH07CiAgICAgYm9v bCBtX2NoYW5nZWQgeyBmYWxzZSB9OwogICAgIFByZWRpY3Rpb25QYXNzIG1fcGFzcyB7IFByaW1h cnlQYXNzIH07IC8vIFdlIHVzZSBkaWZmZXJlbnQgbG9naWMgZm9yIGNvbnNpZGVyaW5nIHByZWRp Y3Rpb25zIGRlcGVuZGluZyBvbiBob3cgZmFyIGFsb25nIHdlIGFyZSBpbiBwcm9wYWdhdGlvbi4K IH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRsL0ZUTExvd2VyREZHVG9C My5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRsL0ZUTExvd2VyREZHVG9CMy5jcHAKaW5k ZXggNjJhNmQzMzRjMzExMWJkYjA0OTY2MDgwMGMyMWJjOTA1YmRjOTBiYi4uM2NhMTllMTczODI2 Zjc3YjEyYTdlOTMyNjM2NTk2MWFmODdiNTQyMyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL2Z0bC9GVExMb3dlckRGR1RvQjMuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9mdGwvRlRMTG93ZXJERkdUb0IzLmNwcApAQCAtMTQxOTksOCArMTQxOTksOCBAQCBwcml2YXRl OgogICAgICAgICAgICAgcmV0dXJuIHN0cmluZ0xlc3NUaGFuKCpzdHJpbmcsICpvdGhlci5zdHJp bmcpOwogICAgICAgICB9CiAgICAgICAgIAotICAgICAgICBTdHJpbmdJbXBsKiBzdHJpbmc7Ci0g ICAgICAgIExCYXNpY0Jsb2NrIHRhcmdldDsKKyAgICAgICAgU3RyaW5nSW1wbCogc3RyaW5nIHsg bnVsbHB0ciB9OworICAgICAgICBMQmFzaWNCbG9jayB0YXJnZXQgeyBudWxscHRyIH07CiAgICAg fTsKICAgICAKICAgICBzdHJ1Y3QgQ2hhcmFjdGVyQ2FzZSB7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvcGFyc2VyL05vZGVzLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcGFy c2VyL05vZGVzLmgKaW5kZXggMTVmZmMxNGRmMWU3MDYyYjQ2NjIzNGE3OTgyMjhlMDcyZjAwNTQx My4uZTYzYTkxNGU3MTg0OTQxZDFmYzUxNzkxNTI3ODVmZjdkNTZiYjEyNSAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3BhcnNlci9Ob2Rlcy5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9wYXJzZXIvTm9kZXMuaApAQCAtMjAzOSw3ICsyMDM5LDcgQEAgbmFtZXNwYWNlIEpT QyB7CiAgICAgICAgIHVuc2lnbmVkIG1fY29uc3RydWN0b3JLaW5kIDogMjsKICAgICAgICAgdW5z aWduZWQgbV9pc0Fycm93RnVuY3Rpb25Cb2R5RXhwcmVzc2lvbiA6IDE7CiAgICAgICAgIFNvdXJj ZVBhcnNlTW9kZSBtX3BhcnNlTW9kZTsKLSAgICAgICAgRnVuY3Rpb25Nb2RlIG1fZnVuY3Rpb25N b2RlOworICAgICAgICBGdW5jdGlvbk1vZGUgbV9mdW5jdGlvbk1vZGUgeyBGdW5jdGlvbk1vZGU6 OkZ1bmN0aW9uRXhwcmVzc2lvbiB9OwogICAgICAgICBJZGVudGlmaWVyIG1faWRlbnQ7CiAgICAg ICAgIElkZW50aWZpZXIgbV9lY21hTmFtZTsKICAgICAgICAgSWRlbnRpZmllciBtX2luZmVycmVk TmFtZTsKQEAgLTIwNTIsNyArMjA1Miw3IEBAIG5hbWVzcGFjZSBKU0MgewogICAgICAgICBTb3Vy Y2VDb2RlIG1fY2xhc3NTb3VyY2U7CiAgICAgICAgIGludCBtX3N0YXJ0U3RhcnRPZmZzZXQ7CiAg ICAgICAgIHVuc2lnbmVkIG1fcGFyYW1ldGVyQ291bnQ7Ci0gICAgICAgIGludCBtX2xhc3RMaW5l OworICAgICAgICBpbnQgbV9sYXN0TGluZSB7IC0xIH07CiAgICAgfTsKIAogICAgIGNsYXNzIEZ1 bmN0aW9uTm9kZSBmaW5hbCA6IHB1YmxpYyBTY29wZU5vZGUgewpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQ29kZUNhY2hlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0NvZGVDYWNoZS5jcHAKaW5kZXggOTMxMzQ4ZDYyMTE5ZjM0ZTMxMDdhYTA3 MzFkNWEyZmFlNjY3ZmUzMS4uODlmMTdmMTUxNjM2NWY0NGZiODdiNjQ0MzQxMmQ0YzQxOWZjZjI0 MyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQ29kZUNhY2hlLmNw cAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwCkBAIC0x MzgsNyArMTM4LDcgQEAgVW5saW5rZWRGdW5jdGlvbkV4ZWN1dGFibGUqIENvZGVDYWNoZTo6Z2V0 VW5saW5rZWRHbG9iYWxGdW5jdGlvbkV4ZWN1dGFibGUoVk0mIHYKICAgICAvLyBUaGlzIGZ1bmN0 aW9uIGFzc3VtZXMgYW4gaW5wdXQgc3RyaW5nIHRoYXQgd291bGQgcmVzdWx0IGluIGEgc2luZ2xl IGZ1bmN0aW9uIGRlY2xhcmF0aW9uLgogICAgIFN0YXRlbWVudE5vZGUqIGZ1bmNEZWNsID0gcHJv Z3JhbS0+c2luZ2xlU3RhdGVtZW50KCk7CiAgICAgaWYgKFVOTElLRUxZKCFmdW5jRGVjbCkpIHsK LSAgICAgICAgSlNUb2tlbiB0b2tlbjsKKyAgICAgICAgSlNUb2tlbiB0b2tlbiA9IHsgfTsKICAg ICAgICAgZXJyb3IgPSBQYXJzZXJFcnJvcihQYXJzZXJFcnJvcjo6U3ludGF4RXJyb3IsIFBhcnNl ckVycm9yOjpTeW50YXhFcnJvcklycmVjb3ZlcmFibGUsIHRva2VuLCAiUGFyc2VyIGVycm9yIiwg LTEpOwogICAgICAgICByZXR1cm4gbnVsbHB0cjsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvcnVudGltZS9Db25maWdGaWxlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0NvbmZpZ0ZpbGUuY3BwCmluZGV4IDYzNmM4MDFkMDA1NThkN2JiMWVjMWM5 ZWY5NTkwNmE3ZmY5ODliNmEuLjNjOWVhNTQ2ZTJhZGU3ZDhiYjhjZjM0YWQ4ZGE4YmM1OGY5M2Nj MWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvbmZpZ0ZpbGUu Y3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvbmZpZ0ZpbGUuY3BwCkBA IC0yMzMsNyArMjMzLDcgQEAgcHJpdmF0ZToKIAogICAgIGNvbnN0IGNoYXIqIG1fZmlsZW5hbWU7 CiAgICAgdW5zaWduZWQgbV9saW5lTnVtYmVyOwotICAgIEZJTEUqIG1fZmlsZTsKKyAgICBGSUxF KiBtX2ZpbGUgeyBudWxscHRyIH07CiAgICAgY2hhciBtX2J1ZmZlcltCVUZTSVpdOwogICAgIGNo YXIqIG1fc3JjUHRyOwogICAgIGNoYXIqIG1fYnVmZmVyRW5kOwpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRXJyb3JJbnN0YW5jZS5oIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3J1bnRpbWUvRXJyb3JJbnN0YW5jZS5oCmluZGV4IGZiYzZmMjUzZDkzNmRmMzdlZmE3 YTZjNGJlZTE1ZjViOTE2YjdlYmIuLjE3YzcyYzYyZThkNGQ3ODA4NTFiOWEwOTAwZGIyYzgwNTBk YjIwODEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Vycm9ySW5z dGFuY2UuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9FcnJvckluc3RhbmNl LmgKQEAgLTk3LDggKzk3LDggQEAgcHJvdGVjdGVkOgogCiAgICAgU291cmNlQXBwZW5kZXIgbV9z b3VyY2VBcHBlbmRlciB7IG51bGxwdHIgfTsKICAgICBzdGQ6OnVuaXF1ZV9wdHI8VmVjdG9yPFN0 YWNrRnJhbWU+PiBtX3N0YWNrVHJhY2U7Ci0gICAgdW5zaWduZWQgbV9saW5lOwotICAgIHVuc2ln bmVkIG1fY29sdW1uOworICAgIHVuc2lnbmVkIG1fbGluZSB7IDAgfTsKKyAgICB1bnNpZ25lZCBt X2NvbHVtbiB7IDAgfTsKICAgICBTdHJpbmcgbV9zb3VyY2VVUkw7CiAgICAgU3RyaW5nIG1fc3Rh Y2tTdHJpbmc7CiAgICAgUnVudGltZVR5cGUgbV9ydW50aW1lVHlwZUZvckNhdXNlIHsgVHlwZU5v dGhpbmcgfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQmln SW50LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0JpZ0ludC5oCmluZGV4IDVj YzllMDlkNGNiZTIyYTllZjJhNjE5MDI4NzMzMDIyMDM3NmRlZjEuLjM3NzhhNDQ1ZmMzMDdiYWM4 M2I3ODg3OWZjYzQ4ZGQwMmM3ZjlkMmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0pTQmlnSW50LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv SlNCaWdJbnQuaApAQCAtMjQzLDcgKzI0Myw3IEBAIHByaXZhdGU6CiAgICAgRGlnaXQgZGlnaXQo dW5zaWduZWQpOwogICAgIHZvaWQgc2V0RGlnaXQodW5zaWduZWQsIERpZ2l0KTsKICAgICAgICAg Ci0gICAgdW5zaWduZWQgbV9sZW5ndGg7CisgICAgdW5zaWduZWQgbV9sZW5ndGggeyAwIH07CiAg ICAgYm9vbCBtX3NpZ24geyBmYWxzZSB9OwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvUHJvcGVydHlTbG90LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv cnVudGltZS9Qcm9wZXJ0eVNsb3QuaAppbmRleCAyZjJmOTBjMTZjY2RlNTdjZTE4MzYzYThmYzMy NDc3YzBkNjdjYWY0Li41ZThmM2RmZGRiOTNlOTJlNWM1NGNmOTg4NzAzNDQ5ZTMzNzI1NTY5IDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Qcm9wZXJ0eVNsb3QuaAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Qcm9wZXJ0eVNsb3QuaApAQCAtMzg3 LDcgKzM4Nyw3IEBAIHByaXZhdGU6CiAgICAgICAgIH0gY3VzdG9tQWNjZXNzb3I7CiAgICAgfSBt X2RhdGE7CiAKLSAgICB1bnNpZ25lZCBtX2F0dHJpYnV0ZXM7CisgICAgdW5zaWduZWQgbV9hdHRy aWJ1dGVzIHsgMCB9OwogICAgIFByb3BlcnR5T2Zmc2V0IG1fb2Zmc2V0OwogICAgIEpTVmFsdWUg bV90aGlzVmFsdWU7CiAgICAgSlNPYmplY3QqIG1fc2xvdEJhc2U7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvd2FzbS9XYXNtQjNJUkdlbmVyYXRvci5jcHAKaW5kZXggN2E3YmRjMzNkY2Uz NzZkYjEyMzg0N2M2MDhhNTY5ODRhOGRjMjA0OS4uYTRjYTY0MzdhODQ0YTIzYWQ1NmYzNDM4N2I4 YzA2OTVkYjU2ZGE1MCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2Fz bUIzSVJHZW5lcmF0b3IuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21C M0lSR2VuZXJhdG9yLmNwcApAQCAtMTQ4LDEwICsxNDgsMTAgQEAgcHVibGljOgogCiAgICAgcHJp dmF0ZToKICAgICAgICAgZnJpZW5kIGNsYXNzIEIzSVJHZW5lcmF0b3I7Ci0gICAgICAgIEJsb2Nr VHlwZSBibG9ja1R5cGU7Ci0gICAgICAgIEJhc2ljQmxvY2sqIGNvbnRpbnVhdGlvbjsKLSAgICAg ICAgQmFzaWNCbG9jayogc3BlY2lhbDsKLSAgICAgICAgUmVzdWx0TGlzdCByZXN1bHQ7CisgICAg ICAgIEJsb2NrVHlwZSBibG9ja1R5cGUgeyB9OworICAgICAgICBCYXNpY0Jsb2NrKiBjb250aW51 YXRpb24geyBudWxscHRyIH07CisgICAgICAgIEJhc2ljQmxvY2sqIHNwZWNpYWwgeyBudWxscHRy IH07CisgICAgICAgIFJlc3VsdExpc3QgcmVzdWx0IHsgfTsKICAgICB9OwogCiAgICAgdHlwZWRl ZiBWYWx1ZSogRXhwcmVzc2lvblR5cGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtRm9ybWF0LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtRm9y bWF0LmgKaW5kZXggZmM2OWVlNWM1OGE0ZmFjMzFhYzk3YjRlMTZhYzYwNGYyYTE0YWU4ZC4uZWJl YzMwNTYyYzQ1NDg2NTQ2ZDk3YWEwY2U3ZmFlMDRhMmFhOGYzNSAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZvcm1hdC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21Gb3JtYXQuaApAQCAtMjI3LDcgKzIyNyw3IEBAIHB1YmxpYzoKICAgICBP cHRpb25hbDx1aW50MzJfdD4gbWF4aW11bSgpIGNvbnN0IHsgcmV0dXJuIG1fbWF4aW11bTsgfQog CiBwcml2YXRlOgotICAgIHVpbnQzMl90IG1faW5pdGlhbDsKKyAgICB1aW50MzJfdCBtX2luaXRp YWwgeyAwIH07CiAgICAgT3B0aW9uYWw8dWludDMyX3Q+IG1fbWF4aW11bTsKICAgICBib29sIG1f aXNJbXBvcnQgeyBmYWxzZSB9OwogICAgIGJvb2wgbV9pc1ZhbGlkIHsgZmFsc2UgfTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21GdW5jdGlvblBhcnNlci5oIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmgKaW5kZXggMmUw MjhlMzY2NjI2NTNlY2VjMzllMDJlZGI4YTIwYmZkNDRjZGE5MS4uOTQ5NWYzMmVlOWEzYzAwODlj ZDlkYmVlOGRlMGU1NTJmOGJkZDZlNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbUZ1bmN0aW9uUGFyc2VyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dh c20vV2FzbUZ1bmN0aW9uUGFyc2VyLmgKQEAgLTg5LDcgKzg5LDcgQEAgcHJpdmF0ZToKICAgICBj b25zdCBTaWduYXR1cmUmIG1fc2lnbmF0dXJlOwogICAgIGNvbnN0IE1vZHVsZUluZm9ybWF0aW9u JiBtX2luZm87CiAKLSAgICBPcFR5cGUgbV9jdXJyZW50T3Bjb2RlOworICAgIE9wVHlwZSBtX2N1 cnJlbnRPcGNvZGUgeyB9OwogICAgIHNpemVfdCBtX2N1cnJlbnRPcGNvZGVTdGFydGluZ09mZnNl dCB7IDAgfTsKIAogICAgIFZlY3RvcjxFeHByZXNzaW9uVHlwZSwgOD4gbV90b0tpbGxBZnRlckV4 cHJlc3Npb247CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtVGll clVwQ291bnQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21UaWVyVXBDb3VudC5o CmluZGV4IGE5ODliMzY3ZTZkZWZlNzEwNDFhZmQ3N2ZhZGIzYWYwNDAxODNiMDUuLjczNjhmZjg2 MDBiYjI2ZmIzNTVhYTlhMDVlNTFjNGYwZTZhYzJiOWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21UaWVyVXBDb3VudC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21UaWVyVXBDb3VudC5oCkBAIC02NSw3ICs2NSw3IEBAIHB1YmxpYzoKIAog cHJpdmF0ZToKICAgICB1aW50MzJfdCBtX2NvdW50OwotICAgIEF0b21pYzxib29sPiBtX3RpZXJV cFN0YXJ0ZWQ7CisgICAgQXRvbWljPGJvb2w+IG1fdGllclVwU3RhcnRlZCB7IGZhbHNlIH07CiB9 OwogICAgIAogfSB9IC8vIG5hbWVzcGFjZSBKU0M6Oldhc20KZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvd2FzbS9XYXNtVmFsaWRhdGUuY3BwCmluZGV4IGJjZDQ3N2JjMjBlZjdjOGFhNzNiZWIxYTg2 YTNhYWI5MWQwYmYwOGEuLjllMmY3ZGE3MjIyNTAxOGY5YTczMzVhNGVlZDQ1ZDA4MDVmY2VjZDAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21WYWxpZGF0ZS5jcHAK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVZhbGlkYXRlLmNwcApAQCAtNzIs OCArNzIsOCBAQCBwdWJsaWM6CiAgICAgICAgIFR5cGUgc2lnbmF0dXJlKCkgY29uc3QgeyByZXR1 cm4gbV9zaWduYXR1cmU7IH0KICAgICAgICAgVHlwZSBicmFuY2hUYXJnZXRTaWduYXR1cmUoKSBj b25zdCB7IHJldHVybiB0eXBlKCkgPT0gQmxvY2tUeXBlOjpMb29wID8gVm9pZCA6IHNpZ25hdHVy ZSgpOyB9CiAgICAgcHJpdmF0ZToKLSAgICAgICAgQmxvY2tUeXBlIG1fYmxvY2tUeXBlOwotICAg ICAgICBUeXBlIG1fc2lnbmF0dXJlOworICAgICAgICBCbG9ja1R5cGUgbV9ibG9ja1R5cGUgeyB9 OworICAgICAgICBUeXBlIG1fc2lnbmF0dXJlIHsgfTsKICAgICB9OwogICAgIHR5cGVkZWYgU3Ry aW5nIEVycm9yVHlwZTsKICAgICB0eXBlZGVmIFVuZXhwZWN0ZWQ8RXJyb3JUeXBlPiBVbmV4cGVj dGVkUmVzdWx0OwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2Fz bVRvSlMuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vanMvV2FzbVRvSlMuY3BwCmlu ZGV4IDU3MmIwMzA3ZDAzMmM0MGI1OTIzNTNlNmI2ZDQyM2JkNmZjZGJiM2MuLjFkYzBiNDFlZmQz M2E4NmVhNWM5Y2ViZWQxNTRlNjg2MGVkNDZiNTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL2pzL1dhc21Ub0pTLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv d2FzbS9qcy9XYXNtVG9KUy5jcHAKQEAgLTI1OSw3ICsyNTksNyBAQCBFeHBlY3RlZDxNYWNyb0Fz c2VtYmxlckNvZGVSZWY8V2FzbUVudHJ5UHRyVGFnPiwgQmluZGluZ0ZhaWx1cmU+IHdhc21Ub0pT KFZNKiB2bQogICAgICAgICAgICAgICAgIEpTVmFsdWUgcmVzdWx0ID0gY2FsbChleGVjLCBjYWxs ZWUsIGNhbGxUeXBlLCBjYWxsRGF0YSwganNVbmRlZmluZWQoKSwgYXJncyk7CiAgICAgICAgICAg ICAgICAgUkVUVVJOX0lGX0VYQ0VQVElPTih0aHJvd1Njb3BlLCAwKTsKIAotICAgICAgICAgICAg ICAgIHVpbnQ2NF90IHJlYWxSZXN1bHQ7CisgICAgICAgICAgICAgICAgdWludDY0X3QgcmVhbFJl c3VsdCA9IDA7CiAgICAgICAgICAgICAgICAgc3dpdGNoIChzaWduYXR1cmUucmV0dXJuVHlwZSgp KSB7CiAgICAgICAgICAgICAgICAgY2FzZSBGdW5jOgogICAgICAgICAgICAgICAgIGNhc2UgQW55 ZnVuYzoKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS95YXJyL1lhcnJKSVQuaCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS95YXJyL1lhcnJKSVQuaAppbmRleCA3YTMwMDM1ZDVkYzBh NDc1NTY0NTUzNWU1N2M0Yjk1ZTQwODBkZWNhLi44ZDc0YzJkOWVjM2UxZmM2ZWJhNzk4MDE1NGU2 NDZjOWZjYTY1MTZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUveWFyci9ZYXJy SklULmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3lhcnIvWWFyckpJVC5oCkBAIC0yMDMs NyArMjAzLDcgQEAgcHJpdmF0ZToKICAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWY8WWFyck1hdGNo T25seThCaXRQdHJUYWc+IG1fbWF0Y2hPbmx5ODsKICAgICBNYWNyb0Fzc2VtYmxlckNvZGVSZWY8 WWFyck1hdGNoT25seTE2Qml0UHRyVGFnPiBtX21hdGNoT25seTE2OwogI2lmIEVOQUJMRShZQVJS X0pJVF9BTExfUEFSRU5TX0VYUFJFU1NJT05TKQotICAgIGJvb2wgbV91c2VzUGF0dGVybkNvbnRl eHRCdWZmZXI7CisgICAgYm9vbCBtX3VzZXNQYXR0ZXJuQ29udGV4dEJ1ZmZlciB7IGZhbHNlIH07 CiAjZW5kaWYKICAgICBPcHRpb25hbDxKSVRGYWlsdXJlUmVhc29uPiBtX2ZhaWx1cmVSZWFzb247 CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1By b2Nlc3NpbmdFdmVudC5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1By b2Nlc3NpbmdFdmVudC5oCmluZGV4IDY5OTE1NzYxMjIxOWM1NzRiOGRkMzg0YjAzMmE1MWRiN2Nm OGQ1M2YuLmJhZjgwMjgxYTk5MjVlNjgzZGRmOGMxNTg3NDFjZDNmYzE3MzU2ZmYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Qcm9jZXNzaW5nRXZlbnQu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2 ZW50LmgKQEAgLTU4LDcgKzU4LDcgQEAgcHJpdmF0ZToKIAogICAgIFJlZlB0cjxBdWRpb0J1ZmZl cj4gbV9pbnB1dEJ1ZmZlcjsKICAgICBSZWZQdHI8QXVkaW9CdWZmZXI+IG1fb3V0cHV0QnVmZmVy OwotICAgIGRvdWJsZSBtX3BsYXliYWNrVGltZTsKKyAgICBkb3VibGUgbV9wbGF5YmFja1RpbWUg eyAwLjAgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vRGVsYXlEU1BLZXJuZWwuaCBiL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vRGVsYXlEU1BLZXJuZWwuaAppbmRleCBlMjBmMWE5YWNkYmRj Y2M1MTRkOTQzOTM5OGNhZWIxZmNhMGI3ODU0Li4zODlmZGU1NzczNTQzZDY1OWMyMmRmYjI3N2Rm NDQ2Y2IxZTYxYTkxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlv L0RlbGF5RFNQS2VybmVsLmgKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9E ZWxheURTUEtlcm5lbC5oCkBAIC00OSwxMiArNDksMTIgQEAgcHVibGljOgogCiBwcml2YXRlOgog ICAgIEF1ZGlvRmxvYXRBcnJheSBtX2J1ZmZlcjsKLSAgICBkb3VibGUgbV9tYXhEZWxheVRpbWU7 CisgICAgZG91YmxlIG1fbWF4RGVsYXlUaW1lIHsgMC4wIH07CiAgICAgaW50IG1fd3JpdGVJbmRl eDsKLSAgICBkb3VibGUgbV9jdXJyZW50RGVsYXlUaW1lOwotICAgIGRvdWJsZSBtX3Ntb290aGlu Z1JhdGU7CisgICAgZG91YmxlIG1fY3VycmVudERlbGF5VGltZSB7IDAuMCB9OworICAgIGRvdWJs ZSBtX3Ntb290aGluZ1JhdGUgeyAwLjAgfTsKICAgICBib29sIG1fZmlyc3RUaW1lOwotICAgIGRv dWJsZSBtX2Rlc2lyZWREZWxheUZyYW1lczsKKyAgICBkb3VibGUgbV9kZXNpcmVkRGVsYXlGcmFt ZXMgeyAwLjAgfTsKIAogICAgIEF1ZGlvRmxvYXRBcnJheSBtX2RlbGF5VGltZXM7CiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVRhYmxlQ29s dW1uLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlUYWJsZUNv bHVtbi5oCmluZGV4IDlmY2RiNWNmMzZlMjc5NjNhZTgyMDBiMjQwMGMzNzNiYjVlMzk4YzUuLmIz ZmFjOGE1MDkxMmRiYzQ4MTVjNGNlNDEwMGNmMThlYjc2YjM3MGMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVRhYmxlQ29sdW1uLmgKKysrIGIv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4uaApA QCAtMzMsMzYgKzMzLDM2IEBACiAjaW5jbHVkZSAiSW50UmVjdC5oIgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7Ci0gICAgCisKIGNsYXNzIFJlbmRlclRhYmxlU2VjdGlvbjsKIAogY2xhc3MgQWNjZXNz aWJpbGl0eVRhYmxlQ29sdW1uIGZpbmFsIDogcHVibGljIEFjY2Vzc2liaWxpdHlNb2NrT2JqZWN0 IHsKIHB1YmxpYzoKICAgICBzdGF0aWMgUmVmPEFjY2Vzc2liaWxpdHlUYWJsZUNvbHVtbj4gY3Jl YXRlKCk7CiAgICAgdmlydHVhbCB+QWNjZXNzaWJpbGl0eVRhYmxlQ29sdW1uKCk7Ci0gICAgCisK ICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBoZWFkZXJPYmplY3QoKTsKLSAgICAgICAgCisKICAg ICBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBB Y2Nlc3NpYmlsaXR5Um9sZTo6Q29sdW1uOyB9Ci0gICAgCisKICAgICB2b2lkIHNldENvbHVtbklu ZGV4KGludCBjb2x1bW5JbmRleCkgeyBtX2NvbHVtbkluZGV4ID0gY29sdW1uSW5kZXg7IH0KLSAg ICBpbnQgY29sdW1uSW5kZXgoKSBjb25zdCB7IHJldHVybiBtX2NvbHVtbkluZGV4OyB9ICAgIAot ICAgIAorICAgIGludCBjb2x1bW5JbmRleCgpIGNvbnN0IHsgcmV0dXJuIG1fY29sdW1uSW5kZXg7 IH0KKwogICAgIHZvaWQgYWRkQ2hpbGRyZW4oKSBvdmVycmlkZTsKICAgICB2b2lkIHNldFBhcmVu dChBY2Nlc3NpYmlsaXR5T2JqZWN0Kikgb3ZlcnJpZGU7Ci0gICAgCisKICAgICBMYXlvdXRSZWN0 IGVsZW1lbnRSZWN0KCkgY29uc3Qgb3ZlcnJpZGU7Ci0gICAgCisKIHByaXZhdGU6CiAgICAgQWNj ZXNzaWJpbGl0eVRhYmxlQ29sdW1uKCk7Ci0gICAgCisKICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0 KiBoZWFkZXJPYmplY3RGb3JTZWN0aW9uKFJlbmRlclRhYmxlU2VjdGlvbiosIGJvb2wgdGhUYWdS ZXF1aXJlZCk7CiAgICAgYm9vbCBjb21wdXRlQWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpIGNvbnN0 IG92ZXJyaWRlOwogICAgIGJvb2wgaXNUYWJsZUNvbHVtbigpIGNvbnN0IG92ZXJyaWRlIHsgcmV0 dXJuIHRydWU7IH0KIAotICAgIHVuc2lnbmVkIG1fY29sdW1uSW5kZXg7CisgICAgdW5zaWduZWQg bV9jb2x1bW5JbmRleCB7IDAgfTsKIH07CiAKLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUgCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKIFNQRUNJQUxJWkVfVFlQRV9UUkFJVFNfQUNDRVNTSUJJTElU WShBY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4sIGlzVGFibGVDb2x1bW4oKSkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2FuaW1hdGlvbi9EZWNsYXJhdGl2ZUFuaW1hdGlvbi5oIGIvU291cmNl L1dlYkNvcmUvYW5pbWF0aW9uL0RlY2xhcmF0aXZlQW5pbWF0aW9uLmgKaW5kZXggZDk1ODM4ZmJk OGE3NDY0ZTBhMDllMmZjZWJlMDE2MWUyZWRjOTNiNi4uMjMzYTZmZmJmMDZiNDhhNTliNzYzMDZk Yjg0NWY4YTk3NzlkYjQ5NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL0Rl Y2xhcmF0aXZlQW5pbWF0aW9uLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL0RlY2xh cmF0aXZlQW5pbWF0aW9uLmgKQEAgLTkyLDcgKzkyLDcgQEAgcHJpdmF0ZToKIAogICAgIEVsZW1l bnQqIG1fb3duaW5nRWxlbWVudDsKICAgICBSZWY8QW5pbWF0aW9uPiBtX2JhY2tpbmdBbmltYXRp b247Ci0gICAgZG91YmxlIG1fcHJldmlvdXNJdGVyYXRpb247CisgICAgZG91YmxlIG1fcHJldmlv dXNJdGVyYXRpb24geyAwLjAgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5o IGIvU291cmNlL1dlYkNvcmUvZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmgKaW5k ZXggMDYzOThjNDM1NWExMmY5ZTgwNjU5ZDQwYzk2Mzg5OTUzMmVkYmQ2Zi4uMjIyYmQ2OTRjODM2 YzI4N2ExMGM3NzJlNGEyODQ1MTQ5NzNhNDQxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv ZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmgKKysrIGIvU291cmNlL1dlYkNvcmUv ZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmgKQEAgLTQyLDggKzQyLDggQEAgcHVi bGljOgogCiAgICAgdmlydHVhbCBDYWxsYmFja1Jlc3VsdDx2b2lkPiBoYW5kbGVFdmVudChkb3Vi bGUgaGlnaFJlc1RpbWVNcykgPSAwOwogCi0gICAgaW50IG1faWQ7Ci0gICAgYm9vbCBtX2ZpcmVk T3JDYW5jZWxsZWQ7CisgICAgaW50IG1faWQgeyAwIH07CisgICAgYm9vbCBtX2ZpcmVkT3JDYW5j ZWxsZWQgeyBmYWxzZSB9OwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKaW5kZXggMmU4YmRhYjNiOWFiN2M3YzQxYWEz ODc0ZjMwOGMzMjE4NWJmMDEwYi4uOGYxNDFjMWIyZDFjY2IxYTQyNTg1YjkxNDM4YTUxY2RhOTRk NWE5NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwCkBAIC0yMDk4 LDkgKzIwOTgsMTAgQEAgYm9vbCBIVE1MTWVkaWFFbGVtZW50Ojppc1NhZmVUb0xvYWRVUkwoY29u c3QgVVJMJiB1cmwsIEludmFsaWRVUkxBY3Rpb24gYWN0aW9uSWYKIAogICAgIFJlZlB0cjxGcmFt ZT4gZnJhbWUgPSBkb2N1bWVudCgpLmZyYW1lKCk7CiAgICAgaWYgKCFmcmFtZSB8fCAhZG9jdW1l bnQoKS5zZWN1cml0eU9yaWdpbigpLmNhbkRpc3BsYXkodXJsKSkgewotICAgICAgICBpZiAoYWN0 aW9uSWZJbnZhbGlkID09IENvbXBsYWluKQorICAgICAgICBpZiAoYWN0aW9uSWZJbnZhbGlkID09 IENvbXBsYWluKSB7CiAgICAgICAgICAgICBGcmFtZUxvYWRlcjo6cmVwb3J0TG9jYWxMb2FkRmFp bGVkKGZyYW1lLmdldCgpLCB1cmwuc3RyaW5nQ2VudGVyRWxsaXBzaXplZFRvTGVuZ3RoKCkpOwog ICAgICAgICAgICAgRVJST1JfTE9HKExPR0lERU5USUZJRVIsIHVybCAsICIgd2FzIHJlamVjdGVk IGJ5IFNlY3VyaXR5T3JpZ2luIik7CisgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGZhbHNlOwog ICAgIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVudUVsZW1lbnQu aCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lbnVFbGVtZW50LmgKaW5kZXggZTY1OWY3MDgw NTM3NmIxYmM1ZjJiMzFhOTY0ZGRhZDA5YTNhOGFhNS4uOGY1Yjc4NWYwYTRlMDA1N2I2YThiYTQz MzA2Y2NhMDQxOTk4YWQxNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVu dUVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZW51RWxlbWVudC5oCkBA IC00MCw3ICs0MCw3IEBAIHByaXZhdGU6CiAgICAgdm9pZCByZW1vdmVkRnJvbUFuY2VzdG9yKFJl bW92YWxUeXBlLCBDb250YWluZXJOb2RlJikgZmluYWw7CiAgICAgdm9pZCBwYXJzZUF0dHJpYnV0 ZShjb25zdCBRdWFsaWZpZWROYW1lJiwgY29uc3QgQXRvbWljU3RyaW5nJikgZmluYWw7CiAKLSAg ICBib29sIG1faXNUb3VjaEJhck1lbnU7CisgICAgYm9vbCBtX2lzVG91Y2hCYXJNZW51IHsgZmFs c2UgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FOR0xFV2ViS2l0QnJpZGdlLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYktpdEJyaWRnZS5oCmluZGV4IDM4MjM1OTE5 NTI2NGQ3YTUwMDU2ZmExZGM5ZjQwYmVjNzVlYzc5MTUuLjZkOGVjZTQwZWNjYjA4NzhjODI0YTQw ZTVkM2U1YzZiYzgxMmMxNTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL0FOR0xFV2ViS2l0QnJpZGdlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvQU5HTEVXZWJLaXRCcmlkZ2UuaApAQCAtOTIsNyArOTIsNyBAQCBwcml2YXRlOgog ICAgIFNoU2hhZGVyT3V0cHV0IG1fc2hhZGVyT3V0cHV0OwogICAgIFNoU2hhZGVyU3BlYyBtX3No YWRlclNwZWM7CiAKLSAgICBTaEJ1aWx0SW5SZXNvdXJjZXMgbV9yZXNvdXJjZXM7CisgICAgU2hC dWlsdEluUmVzb3VyY2VzIG1fcmVzb3VyY2VzIHsgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYWRp ZW50SW1hZ2UuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYWRpZW50SW1h Z2UuaAppbmRleCBkNzRkNTc4YTJjOTM0NmY2MTcxNGZkMDhmN2UwODhjNzhhZDgwMTBiLi40MDgz OTNmYmVkMDFiMWFkNThkOGI5MzkzNWUyMTk4ZTVhNjUzODg3IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFkaWVudEltYWdlLmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhZGllbnRJbWFnZS5oCkBAIC01NCw3ICs1NCw3IEBA IHByaXZhdGU6CiAgICAgUmVmPEdyYWRpZW50PiBtX2dyYWRpZW50OwogICAgIFJlZlB0cjxJbWFn ZT4gbV9jYWNoZWRJbWFnZTsKICAgICBGbG9hdFNpemUgbV9jYWNoZWRBZGp1c3RlZFNpemU7Ci0g ICAgdW5zaWduZWQgbV9jYWNoZWRHZW5lcmF0b3JIYXNoOworICAgIHVuc2lnbmVkIG1fY2FjaGVk R2VuZXJhdG9ySGFzaCB7IDAgfTsKICAgICBGbG9hdFNpemUgbV9jYWNoZWRTY2FsZUZhY3RvcjsK IH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJl YW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJC YXNlLmNwcAppbmRleCA1Y2I1Zjc1MzZhYzNjZWZlMWUxNmM5OGZlOTY3MDIxMTMwYTZkZjc0Li5h ZGE2YWNmZDg4MmRjMWRlZjc5YmQxZGMzMWI2MWI4M2Q5NDJjOTAxIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRl R1N0cmVhbWVyQmFzZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCkBAIC0yMjEsNyAr MjIxLDcgQEAgcHJpdmF0ZToKICAgICBHc3RCdWZmZXIqIG1fYnVmZmVyOwogICAgIEdzdFZpZGVv RnJhbWUgbV92aWRlb0ZyYW1lIHsgfTsKICAgICBJbnRTaXplIG1fc2l6ZTsKLSAgICBib29sIG1f aGFzQWxwaGFDaGFubmVsOworICAgIGJvb2wgbV9oYXNBbHBoYUNoYW5uZWwgeyBmYWxzZSB9Owog ICAgIFRleHR1cmVNYXBwZXJHTDo6RmxhZ3MgbV9mbGFncyB7IH07CiAgICAgR0x1aW50IG1fdGV4 dHVyZUlEIHsgMCB9OwogICAgIGJvb2wgbV9pc01hcHBlZCB7IGZhbHNlIH07CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90ZXhtYXAvVGV4dHVyZU1hcHBlclBs YXRmb3JtTGF5ZXJCdWZmZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3Rl eG1hcC9UZXh0dXJlTWFwcGVyUGxhdGZvcm1MYXllckJ1ZmZlci5oCmluZGV4IGQxMDBlMjRhZDEz MTY0OTc5NGI5MDY5MmU2NjEyYTM3YWI3YzlhZWIuLjQ2YjhkZDc0MTlhZmNkZmYzOTQxMzJlMDZj YmU3NmUxYTAxZWVhMTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL3RleG1hcC9UZXh0dXJlTWFwcGVyUGxhdGZvcm1MYXllckJ1ZmZlci5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RleG1hcC9UZXh0dXJlTWFwcGVyUGxhdGZvcm1M YXllckJ1ZmZlci5oCkBAIC04MCw3ICs4MCw3IEBAIHByaXZhdGU6CiAKICAgICBHTHVpbnQgbV90 ZXh0dXJlSUQ7CiAgICAgSW50U2l6ZSBtX3NpemU7Ci0gICAgR0xpbnQgbV9pbnRlcm5hbEZvcm1h dDsKKyAgICBHTGludCBtX2ludGVybmFsRm9ybWF0IHsgMCB9OwogICAgIFRleHR1cmVNYXBwZXJH TDo6RmxhZ3MgbV9leHRyYUZsYWdzOwogICAgIGJvb2wgbV9oYXNNYW5hZ2VkVGV4dHVyZTsKICAg ICBzdGQ6OnVuaXF1ZV9wdHI8VW5tYW5hZ2VkQnVmZmVyRGF0YUhvbGRlcj4gbV91bm1hbmFnZWRC dWZmZXJEYXRhSG9sZGVyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L1Njcm9sbGJhclRoZW1lR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TY3Jv bGxiYXJUaGVtZUd0ay5jcHAKaW5kZXggMjA5YWY3YjU1ZGJhNGIxMTQwOTY0ZmQ1Y2UxNDYxMDk1 ZDAzZjIwYi4uOTExMTNhMGQ3MzcyNGYyZDZlMDc1MzRmMWFiOTkzN2ZhM2MyN2M4YSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Njcm9sbGJhclRoZW1lR3RrLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvU2Nyb2xsYmFyVGhlbWVHdGsuY3BwCkBA IC01Myw2ICs1MywxMCBAQCBzdGF0aWMgdm9pZCB0aGVtZUNoYW5nZWRDYWxsYmFjaygpCiB9CiAK IFNjcm9sbGJhclRoZW1lR3RrOjpTY3JvbGxiYXJUaGVtZUd0aygpCisgICAgOiBtX2hhc0Zvcndh cmRCdXR0b25TdGFydFBhcnQoZmFsc2UpCisgICAgLCBtX2hhc0ZvcndhcmRCdXR0b25FbmRQYXJ0 KGZhbHNlKQorICAgICwgbV9oYXNCYWNrQnV0dG9uU3RhcnRQYXJ0KGZhbHNlKQorICAgICwgbV9o YXNCYWNrQnV0dG9uRW5kUGFydChmYWxzZSkKIHsKICNpZiBHVEtfQ0hFQ0tfVkVSU0lPTigzLCAy MCwgMCkKICAgICBtX3VzZXNPdmVybGF5U2Nyb2xsYmFycyA9IGdfc3RyY21wMChnX2dldGVudigi R1RLX09WRVJMQVlfU0NST0xMSU5HIiksICIwIik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9qcGVnL0pQRUdJbWFnZURlY29kZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvanBlZy9KUEVHSW1hZ2VEZWNvZGVy LmNwcAppbmRleCBiNzJjNTVhMmNiOTA5ZmEzNDYxY2Y3OTVmMDRkY2VhZDUxMDRlOGVlLi5kMmM2 N2VmZDk0MDRkNWZhYjBkYjQyNDgwM2E1OTk5MWU0ZTBkZDlhIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9qcGVnL0pQRUdJbWFnZURlY29kZXIuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL2pwZWcvSlBFR0lt YWdlRGVjb2Rlci5jcHAKQEAgLTQ1NCwxMCArNDU0LDEwIEBAIHByaXZhdGU6CiAgICAgSlBFR0lt YWdlRGVjb2RlciogbV9kZWNvZGVyOwogICAgIHVuc2lnbmVkIG1fYnVmZmVyTGVuZ3RoOwogICAg IGludCBtX2J5dGVzVG9Ta2lwOwotICAgIGJvb2wgbV9kZWNvZGluZ1NpemVPbmx5OworICAgIGJv b2wgbV9kZWNvZGluZ1NpemVPbmx5IHsgZmFsc2UgfTsKIAogICAgIGpwZWdfZGVjb21wcmVzc19z dHJ1Y3QgbV9pbmZvOwotICAgIGRlY29kZXJfZXJyb3JfbWdyIG1fZXJyOworICAgIGRlY29kZXJf ZXJyb3JfbWdyIG1fZXJyIHsgfTsKICAgICBqc3RhdGUgbV9zdGF0ZTsKIAogICAgIEpTQU1QQVJS QVkgbV9zYW1wbGVzOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9U ZXh0Q29kZWNVVEYxNi5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Q29kZWNV VEYxNi5oCmluZGV4IGMxMWJiZmIxY2E4YjhmM2E5MWIxYTdlZjg1ZTI0YmI0ZWMxODM5YzcuLmJj YjE0ZDc0ZjUwZTMyNmVjZWRhY2YwYjc1ZTgzYmMxN2UxNDMzMjIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dENvZGVjVVRGMTYuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS90ZXh0L1RleHRDb2RlY1VURjE2LmgKQEAgLTQyLDcgKzQyLDcgQEAgcHJp dmF0ZToKIAogICAgIGJvb2wgbV9saXR0bGVFbmRpYW47CiAgICAgYm9vbCBtX2hhdmVCdWZmZXJl ZEJ5dGUgeyBmYWxzZSB9OwotICAgIHVuc2lnbmVkIGNoYXIgbV9idWZmZXJlZEJ5dGU7CisgICAg dW5zaWduZWQgY2hhciBtX2J1ZmZlcmVkQnl0ZSB7IDAgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJGcmFn bWVudGVkRmxvdy5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckZyYWdtZW50ZWRG bG93LmgKaW5kZXggNGMzOTc3ZTVmMGJlNjMyNzAzY2I2ZGZjNWM0ZDUwYTZkMzM4ZDhiZC4uNzU5 MjUxNjBlZjdmOGYzMGQ3ODgyMDBkNmQzNTJkYjFhYWU2MDQ4NSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckZyYWdtZW50ZWRGbG93LmgKKysrIGIvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckZyYWdtZW50ZWRGbG93LmgKQEAgLTIyNyw3ICsyMjcsNyBA QCBwcm90ZWN0ZWQ6CiAgICAgcHJpdmF0ZToKICAgICAgICAgV2Vha1B0cjxSZW5kZXJGcmFnbWVu dENvbnRhaW5lcj4gbV9zdGFydEZyYWdtZW50OwogICAgICAgICBXZWFrUHRyPFJlbmRlckZyYWdt ZW50Q29udGFpbmVyPiBtX2VuZEZyYWdtZW50OwotICAgICAgICBib29sIG1fcmFuZ2VJbnZhbGlk YXRlZDsKKyAgICAgICAgYm9vbCBtX3JhbmdlSW52YWxpZGF0ZWQgeyBmYWxzZSB9OwogICAgIH07 CiAKICAgICB0eXBlZGVmIFBPREludGVydmFsPExheW91dFVuaXQsIFdlYWtQdHI8UmVuZGVyRnJh Z21lbnRDb250YWluZXI+PiBGcmFnbWVudEludGVydmFsOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvd29ya2Vycy9Xb3JrZXJTY3JpcHRMb2FkZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3dvcmtl cnMvV29ya2VyU2NyaXB0TG9hZGVyLmgKaW5kZXggYjU3NDg1NjhhZjFiOTRhZTQzYzE0YjQzOTcy NGNiOWZkNDU1MzkzZC4uMmIwOTAwN2Q2NjVjNTZkOTEwYjM4MWI1ZDkwZWU2NWVkZWIxMWZmYiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJTY3JpcHRMb2FkZXIuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzL1dvcmtlclNjcmlwdExvYWRlci5oCkBAIC05NCw3 ICs5NCw3IEBAIHByaXZhdGU6CiAgICAgVVJMIG1fdXJsOwogICAgIFVSTCBtX3Jlc3BvbnNlVVJM OwogICAgIFN0cmluZyBtX3Jlc3BvbnNlTUlNRVR5cGU7Ci0gICAgRmV0Y2hPcHRpb25zOjpEZXN0 aW5hdGlvbiBtX2Rlc3RpbmF0aW9uOworICAgIEZldGNoT3B0aW9uczo6RGVzdGluYXRpb24gbV9k ZXN0aW5hdGlvbiB7IEZldGNoT3B0aW9uczo6RGVzdGluYXRpb246OkVtcHR5U3RyaW5nIH07CiAg ICAgQ29udGVudFNlY3VyaXR5UG9saWN5UmVzcG9uc2VIZWFkZXJzIG1fY29udGVudFNlY3VyaXR5 UG9saWN5OwogICAgIFN0cmluZyBtX3JlZmVycmVyUG9saWN5OwogICAgIHVuc2lnbmVkIGxvbmcg bV9pZGVudGlmaWVyIHsgMCB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvUGx1 Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmggYi9Tb3VyY2UvV2ViS2l0L1No YXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAppbmRleCBkMzI2 ODgwYTk0NzdiM2FiZWIzYWIzOTYwYWFkMGJhYzEyYTUzYThmLi5iZTA3NWVjMzNhNjdmMTZhN2Zl OGE1Zjk2OWQxZjkwMDJlZjVjOGU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9Q bHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L1NoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaApAQCAt NDcsNyArNDcsNyBAQCBzdHJ1Y3QgUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyB7CiAg ICAgdm9pZCBlbmNvZGUoSVBDOjpFbmNvZGVyJikgY29uc3Q7CiAgICAgc3RhdGljIGJvb2wgZGVj b2RlKElQQzo6RGVjb2RlciYsIFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmKTsKIAot ICAgIFBsdWdpblByb2Nlc3NUeXBlIHByb2Nlc3NUeXBlOworICAgIFBsdWdpblByb2Nlc3NUeXBl IHByb2Nlc3NUeXBlIHsgUGx1Z2luUHJvY2Vzc1R5cGVOb3JtYWwgfTsKICAgICBib29sIHN1cHBv cnRzQXN5bmNocm9ub3VzUGx1Z2luSW5pdGlhbGl6YXRpb247CiAKICAgICBTZWNvbmRzIG1pbmlt dW1MaWZldGltZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGli L0ljb25EYXRhYmFzZS5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvSWNvbkRh dGFiYXNlLmgKaW5kZXggYmFiZDhhOTgyOWZiODBkMTk4NTJlYzk3NGFlZWE3MGNlZTBiOTE1OC4u MjBkYTk3MjMzMWM2MDMzNjMxOTIwNWNlNjA1ODU3OTMwZmU1NGUwZSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvSWNvbkRhdGFiYXNlLmgKKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIvSWNvbkRhdGFiYXNlLmgKQEAgLTIyNiw3ICsyMjYs NyBAQCBwcml2YXRlOgogCiAgICAgICAgIERlcXVlPEZ1bmN0aW9uPHZvaWQoKT4+IG1fbm90aWZp Y2F0aW9uUXVldWU7CiAgICAgICAgIExvY2sgbV9ub3RpZmljYXRpb25RdWV1ZUxvY2s7Ci0gICAg ICAgIEF0b21pYzxib29sPiBtX2lzQWN0aXZlOworICAgICAgICBBdG9taWM8Ym9vbD4gbV9pc0Fj dGl2ZSB7IGZhbHNlIH07CiAgICAgICAgIFJ1bkxvb3A6OlRpbWVyPE1haW5UaHJlYWROb3RpZmll cj4gbV90aW1lcjsKICAgICB9OwogCg== 367526 2019-04-16 03:44:04 -0700 2019-04-16 03:44:04 -0700 Patch bug-196855-20190416124402.patch text/plain 17288 erack U3VidmVyc2lvbiBSZXZpc2lvbjogMjQ0MjYwCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA4 NDFlNzIwYmQ3YWJiOTVkNWY4NzMwNjk2ZWQ1NzI1Y2IxM2RmMjRhLi4xNTlkZDY5Yjg5MjA5ZDRi NzIwYzM3MzY1M2EwMjc1YjYxZWY4YzRiIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMCBAQAorMjAxOS0wNC0xNiAgRWlrZSBSYXRoa2UgIDxlcmFja0ByZWRoYXQuY29tPgor CisgICAgICAgIEZpeCBDb3ZzY2FuIHVuaW5pdGlhbGl6ZWQgYWZ0ZXIgY3RvcgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTk2ODU1CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4IGEgYnVuY2ggb2YgQ292 ZXJpdHkgU2NhbiBVTklOSVRfQ1RPUiBlcnJvcnMsIHdoZXJlIGFmdGVyCisgICAgICAgIGNvbnN0 cnVjdGluZyBhbiBvYmplY3QgaW5zdGFuY2UgbWVtYmVyIHZhcmlhYmxlcyB3ZXJlIGxlZnQKKyAg ICAgICAgdW5pbml0aWFsaXplZC4KKworICAgICAgICAqIGRmZy9ERkdQcmVkaWN0aW9uUHJvcGFn YXRpb25QaGFzZS5jcHA6CisgICAgICAgICogZnRsL0ZUTExvd2VyREZHVG9CMy5jcHA6CisgICAg ICAgICogcGFyc2VyL05vZGVzLmg6CisgICAgICAgICogcGFyc2VyL1BhcnNlclRva2Vucy5oOgor ICAgICAgICAqIHJ1bnRpbWUvRXJyb3JJbnN0YW5jZS5oOgorCiAyMDE5LTA0LTE0ICBEb24gT2xt c3RlYWQgIDxkb24ub2xtc3RlYWRAc29ueS5jb20+CiAKICAgICAgICAgW0NNYWtlXSBKYXZhU2Ny aXB0Q29yZSBkZXJpdmVkIHNvdXJjZXMgc2hvdWxkIG9ubHkgYmUgcmVmZXJlbmNlZCBpbnNpZGUg SmF2YVNjcmlwdENvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2NDQ4N2ViYzI4OWQyZjJmYzMyMDdhZDY2YjUz ZGM5ZTU5MGQ5ZTAxLi41ZWZiNWEwNGY3OWZlMzY4MDI0MGQwMGRjMDE2MWRiZjkxNjk1NDIxIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTktMDQtMTYgIEVpa2UgUmF0aGtlICA8ZXJh Y2tAcmVkaGF0LmNvbT4KKworICAgICAgICBGaXggQ292c2NhbiB1bmluaXRpYWxpemVkIGFmdGVy IGN0b3IKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5 Njg1NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEZp eCBhIGJ1bmNoIG9mIENvdmVyaXR5IFNjYW4gVU5JTklUX0NUT1IgZXJyb3JzLCB3aGVyZSBhZnRl cgorICAgICAgICBjb25zdHJ1Y3RpbmcgYW4gb2JqZWN0IGluc3RhbmNlIG1lbWJlciB2YXJpYWJs ZXMgd2VyZSBsZWZ0CisgICAgICAgIHVuaW5pdGlhbGl6ZWQuCisKKyAgICAgICAgKiBNb2R1bGVz L3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2ZW50Lmg6CisgICAgICAgICogTW9kdWxlcy93ZWJh dWRpby9EZWxheURTUEtlcm5lbC5oOgorICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJp bGl0eVRhYmxlQ29sdW1uLmg6CisgICAgICAgICogYW5pbWF0aW9uL0RlY2xhcmF0aXZlQW5pbWF0 aW9uLmg6CisgICAgICAgICogZG9tL1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrLmg6Cisg ICAgICAgICogaHRtbC9IVE1MTWVudUVsZW1lbnQuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9BTkdMRVdlYktpdEJyaWRnZS5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0dy YWRpZW50SW1hZ2UuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVk aWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHA6CisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvdGV4bWFwL1RleHR1cmVNYXBwZXJQbGF0Zm9ybUxheWVyQnVmZmVyLmg6CisgICAgICAg ICogcGxhdGZvcm0vZ3RrL1Njcm9sbGJhclRoZW1lR3RrLmg6CisgICAgICAgICogcGxhdGZvcm0v aW1hZ2UtZGVjb2RlcnMvanBlZy9KUEVHSW1hZ2VEZWNvZGVyLmNwcDoKKyAgICAgICAgKiBwbGF0 Zm9ybS90ZXh0L1RleHRDb2RlY1VURjE2Lmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckZy YWdtZW50ZWRGbG93Lmg6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJTY3JpcHRMb2FkZXIuaDoK KwogMjAxOS0wNC0xNSAgQW50b2luZSBRdWludCAgPGdyYW91dHNAYXBwbGUuY29tPgogCiAgICAg ICAgIEVuc3VyZSBpT1MgbGF5b3V0IHRyYWl0cyBhcmUgdXNlZCBmb3IgbWVkaWEgY29udHJvbHMg aW4gbW9kZXJuIGNvbXBhdGliaWxpdHkgbW9kZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCA2M2Y5NjM4NTZjMmQ1ZmI3 ZGIyNzlkMWY1NTY3MjA3NWFlZDk0OGZmLi5jZDFiYTE0YjE4MmNhZTY2MmE5MDEwODRjNTgxNGE3 OGRmNGFkZjk0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZworKysgYi9Tb3Vy Y2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDE5LTA0LTE2ICBFaWtlIFJh dGhrZSAgPGVyYWNrQHJlZGhhdC5jb20+CisKKyAgICAgICAgRml4IENvdnNjYW4gdW5pbml0aWFs aXplZCBhZnRlciBjdG9yCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xOTY4NTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBGaXggYSBidW5jaCBvZiBDb3Zlcml0eSBTY2FuIFVOSU5JVF9DVE9SIGVycm9ycywg d2hlcmUgYWZ0ZXIKKyAgICAgICAgY29uc3RydWN0aW5nIGFuIG9iamVjdCBpbnN0YW5jZSBtZW1i ZXIgdmFyaWFibGVzIHdlcmUgbGVmdAorICAgICAgICB1bmluaXRpYWxpemVkLgorCisgICAgICAg ICogU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oOgorICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ2xpYi9JY29uRGF0YWJhc2UuaDoKKwogMjAxOS0wNC0xNSAg UGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5kQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS11b V1BFXSBBZGQgZW5hYmxlLW1lZGlhIHdlYnNldHRpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9kZmcvREZHUHJlZGljdGlvblByb3BhZ2F0aW9uUGhhc2UuY3BwIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL2RmZy9ERkdQcmVkaWN0aW9uUHJvcGFnYXRpb25QaGFzZS5jcHAKaW5k ZXggZTBmNGUwNWI5MmM4ODE1ZTM0NzY3ZTFhNmExYjQzODE4M2NhOWRhZS4uNGNkOTk0MTQwMDQw NzhlMzU1MTE1NzAyMmY3OTA3MWUwMzk2OTAzZCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL2RmZy9ERkdQcmVkaWN0aW9uUHJvcGFnYXRpb25QaGFzZS5jcHAKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL2RmZy9ERkdQcmVkaWN0aW9uUHJvcGFnYXRpb25QaGFzZS5jcHAKQEAg LTEzMzMsNyArMTMzMyw3IEBAIHByaXZhdGU6CiAgICAgfQogCiAgICAgVmVjdG9yPE5vZGUqPiBt X2RlcGVuZGVudE5vZGVzOwotICAgIE5vZGUqIG1fY3VycmVudE5vZGU7CisgICAgTm9kZSogbV9j dXJyZW50Tm9kZSB7IG51bGxwdHIgfTsKICAgICBib29sIG1fY2hhbmdlZCB7IGZhbHNlIH07CiAg ICAgUHJlZGljdGlvblBhc3MgbV9wYXNzIHsgUHJpbWFyeVBhc3MgfTsgLy8gV2UgdXNlIGRpZmZl cmVudCBsb2dpYyBmb3IgY29uc2lkZXJpbmcgcHJlZGljdGlvbnMgZGVwZW5kaW5nIG9uIGhvdyBm YXIgYWxvbmcgd2UgYXJlIGluIHByb3BhZ2F0aW9uLgogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9mdGwvRlRMTG93ZXJERkdUb0IzLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9mdGwvRlRMTG93ZXJERkdUb0IzLmNwcAppbmRleCA2MmE2ZDMzNGMzMTExYmRiMDQ5NjYw ODAwYzIxYmM5MDViZGM5MGJiLi4zY2ExOWUxNzM4MjZmNzdiMTJhN2U5MzI2MzY1OTYxYWY4N2I1 NDIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRsL0ZUTExvd2VyREZHVG9C My5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2Z0bC9GVExMb3dlckRGR1RvQjMuY3Bw CkBAIC0xNDE5OSw4ICsxNDE5OSw4IEBAIHByaXZhdGU6CiAgICAgICAgICAgICByZXR1cm4gc3Ry aW5nTGVzc1RoYW4oKnN0cmluZywgKm90aGVyLnN0cmluZyk7CiAgICAgICAgIH0KICAgICAgICAg Ci0gICAgICAgIFN0cmluZ0ltcGwqIHN0cmluZzsKLSAgICAgICAgTEJhc2ljQmxvY2sgdGFyZ2V0 OworICAgICAgICBTdHJpbmdJbXBsKiBzdHJpbmcgeyBudWxscHRyIH07CisgICAgICAgIExCYXNp Y0Jsb2NrIHRhcmdldCB7IG51bGxwdHIgfTsKICAgICB9OwogICAgIAogICAgIHN0cnVjdCBDaGFy YWN0ZXJDYXNlIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9wYXJzZXIvTm9k ZXMuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9wYXJzZXIvTm9kZXMuaAppbmRleCAxNWZmYzE0 ZGYxZTcwNjJiNDY2MjM0YTc5ODIyOGUwNzJmMDA1NDEzLi5lNjNhOTE0ZTcxODQ5NDFkMWZjNTE3 OTE1Mjc4NWZmN2Q1NmJiMTI1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcGFy c2VyL05vZGVzLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3BhcnNlci9Ob2Rlcy5oCkBA IC0yMDM5LDcgKzIwMzksNyBAQCBuYW1lc3BhY2UgSlNDIHsKICAgICAgICAgdW5zaWduZWQgbV9j b25zdHJ1Y3RvcktpbmQgOiAyOwogICAgICAgICB1bnNpZ25lZCBtX2lzQXJyb3dGdW5jdGlvbkJv ZHlFeHByZXNzaW9uIDogMTsKICAgICAgICAgU291cmNlUGFyc2VNb2RlIG1fcGFyc2VNb2RlOwot ICAgICAgICBGdW5jdGlvbk1vZGUgbV9mdW5jdGlvbk1vZGU7CisgICAgICAgIEZ1bmN0aW9uTW9k ZSBtX2Z1bmN0aW9uTW9kZSB7IEZ1bmN0aW9uTW9kZTo6RnVuY3Rpb25FeHByZXNzaW9uIH07CiAg ICAgICAgIElkZW50aWZpZXIgbV9pZGVudDsKICAgICAgICAgSWRlbnRpZmllciBtX2VjbWFOYW1l OwogICAgICAgICBJZGVudGlmaWVyIG1faW5mZXJyZWROYW1lOwpAQCAtMjA1Miw3ICsyMDUyLDcg QEAgbmFtZXNwYWNlIEpTQyB7CiAgICAgICAgIFNvdXJjZUNvZGUgbV9jbGFzc1NvdXJjZTsKICAg ICAgICAgaW50IG1fc3RhcnRTdGFydE9mZnNldDsKICAgICAgICAgdW5zaWduZWQgbV9wYXJhbWV0 ZXJDb3VudDsKLSAgICAgICAgaW50IG1fbGFzdExpbmU7CisgICAgICAgIGludCBtX2xhc3RMaW5l IHsgLTEgfTsKICAgICB9OwogCiAgICAgY2xhc3MgRnVuY3Rpb25Ob2RlIGZpbmFsIDogcHVibGlj IFNjb3BlTm9kZSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcGFyc2VyL1Bh cnNlclRva2Vucy5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3BhcnNlci9QYXJzZXJUb2tlbnMu aAppbmRleCBjZmVlMzM3OThjMjRkODc4M2JkOTljNDhlMWM4NzIwODg3M2I1YzljLi44YTk0OTU5 MTBlMTQyOTkxNTMzOWViODY5N2RmYjM5ZGFmYWVhNjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcGFyc2VyL1BhcnNlclRva2Vucy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9wYXJzZXIvUGFyc2VyVG9rZW5zLmgKQEAgLTI1Niw2ICsyNTYsOCBAQCBzdHJ1Y3QgSlNU b2tlbkxvY2F0aW9uIHsKIH07CiAKIHN0cnVjdCBKU1Rva2VuIHsKKyAgICBKU1Rva2VuKCkgPSBk ZWZhdWx0OworCiAgICAgSlNUb2tlblR5cGUgbV90eXBlIHsgRVJST1JUT0sgfTsKICAgICBKU1Rv a2VuRGF0YSBtX2RhdGEgeyB7IG51bGxwdHIsIG51bGxwdHIsIGZhbHNlIH0gfTsKICAgICBKU1Rv a2VuTG9jYXRpb24gbV9sb2NhdGlvbjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0Vycm9ySW5zdGFuY2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0Vycm9ySW5zdGFuY2UuaAppbmRleCBmYmM2ZjI1M2Q5MzZkZjM3ZWZhN2E2YzRiZWUxNWY1Yjkx NmI3ZWJiLi4xN2M3MmM2MmU4ZDRkNzgwODUxYjlhMDkwMGRiMmM4MDUwZGIyMDgxIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9FcnJvckluc3RhbmNlLmgKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRXJyb3JJbnN0YW5jZS5oCkBAIC05Nyw4ICs5 Nyw4IEBAIHByb3RlY3RlZDoKIAogICAgIFNvdXJjZUFwcGVuZGVyIG1fc291cmNlQXBwZW5kZXIg eyBudWxscHRyIH07CiAgICAgc3RkOjp1bmlxdWVfcHRyPFZlY3RvcjxTdGFja0ZyYW1lPj4gbV9z dGFja1RyYWNlOwotICAgIHVuc2lnbmVkIG1fbGluZTsKLSAgICB1bnNpZ25lZCBtX2NvbHVtbjsK KyAgICB1bnNpZ25lZCBtX2xpbmUgeyAwIH07CisgICAgdW5zaWduZWQgbV9jb2x1bW4geyAwIH07 CiAgICAgU3RyaW5nIG1fc291cmNlVVJMOwogICAgIFN0cmluZyBtX3N0YWNrU3RyaW5nOwogICAg IFJ1bnRpbWVUeXBlIG1fcnVudGltZVR5cGVGb3JDYXVzZSB7IFR5cGVOb3RoaW5nIH07CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2 ZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2 ZW50LmgKaW5kZXggNjk5MTU3NjEyMjE5YzU3NGI4ZGQzODRiMDMyYTUxZGI3Y2Y4ZDUzZi4uYmFm ODAyODFhOTkyNWU2ODNkZGY4YzE1ODc0MWNkM2ZjMTczNTZmZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb1Byb2Nlc3NpbmdFdmVudC5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Qcm9jZXNzaW5nRXZlbnQuaApAQCAt NTgsNyArNTgsNyBAQCBwcml2YXRlOgogCiAgICAgUmVmUHRyPEF1ZGlvQnVmZmVyPiBtX2lucHV0 QnVmZmVyOwogICAgIFJlZlB0cjxBdWRpb0J1ZmZlcj4gbV9vdXRwdXRCdWZmZXI7Ci0gICAgZG91 YmxlIG1fcGxheWJhY2tUaW1lOworICAgIGRvdWJsZSBtX3BsYXliYWNrVGltZSB7IDAuMCB9Owog fTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJhdWRpby9EZWxheURTUEtlcm5lbC5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxl cy93ZWJhdWRpby9EZWxheURTUEtlcm5lbC5oCmluZGV4IGUyMGYxYTlhY2RiZGNjYzUxNGQ5NDM5 Mzk4Y2FlYjFmY2EwYjc4NTQuLjM4OWZkZTU3NzM1NDNkNjU5YzIyZGZiMjc3ZGY0NDZjYjFlNjFh OTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vRGVsYXlEU1BL ZXJuZWwuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0RlbGF5RFNQS2Vy bmVsLmgKQEAgLTQ5LDEyICs0OSwxMiBAQCBwdWJsaWM6CiAKIHByaXZhdGU6CiAgICAgQXVkaW9G bG9hdEFycmF5IG1fYnVmZmVyOwotICAgIGRvdWJsZSBtX21heERlbGF5VGltZTsKKyAgICBkb3Vi bGUgbV9tYXhEZWxheVRpbWUgeyAwLjAgfTsKICAgICBpbnQgbV93cml0ZUluZGV4OwotICAgIGRv dWJsZSBtX2N1cnJlbnREZWxheVRpbWU7Ci0gICAgZG91YmxlIG1fc21vb3RoaW5nUmF0ZTsKKyAg ICBkb3VibGUgbV9jdXJyZW50RGVsYXlUaW1lIHsgMC4wIH07CisgICAgZG91YmxlIG1fc21vb3Ro aW5nUmF0ZSB7IDAuMCB9OwogICAgIGJvb2wgbV9maXJzdFRpbWU7Ci0gICAgZG91YmxlIG1fZGVz aXJlZERlbGF5RnJhbWVzOworICAgIGRvdWJsZSBtX2Rlc2lyZWREZWxheUZyYW1lcyB7IDAuMCB9 OwogCiAgICAgQXVkaW9GbG9hdEFycmF5IG1fZGVsYXlUaW1lczsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4uaCBiL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVRhYmxlQ29sdW1uLmgKaW5k ZXggOWZjZGI1Y2YzNmUyNzk2M2FlODIwMGIyNDAwYzM3M2JiNWUzOThjNS4uYTc1NWRjZmQ4MzZh MzIyNDRhYTcwM2MxZTkyMTZhOWFjMGRhMzEwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4uaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlUYWJsZUNvbHVtbi5oCkBAIC02MCw3ICs2 MCw3IEBAIHByaXZhdGU6CiAgICAgYm9vbCBjb21wdXRlQWNjZXNzaWJpbGl0eUlzSWdub3JlZCgp IGNvbnN0IG92ZXJyaWRlOwogICAgIGJvb2wgaXNUYWJsZUNvbHVtbigpIGNvbnN0IG92ZXJyaWRl IHsgcmV0dXJuIHRydWU7IH0KIAotICAgIHVuc2lnbmVkIG1fY29sdW1uSW5kZXg7CisgICAgdW5z aWduZWQgbV9jb2x1bW5JbmRleCB7IDAgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUg CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vRGVjbGFyYXRpdmVBbmltYXRp b24uaCBiL1NvdXJjZS9XZWJDb3JlL2FuaW1hdGlvbi9EZWNsYXJhdGl2ZUFuaW1hdGlvbi5oCmlu ZGV4IGQ5NTgzOGZiZDhhNzQ2NGUwYTA5ZTJmY2ViZTAxNjFlMmVkYzkzYjYuLjIzM2E2ZmZiZjA2 YjQ4YTU5Yjc2MzA2ZGI4NDVmOGE5Nzc5ZGI0OTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2FuaW1hdGlvbi9EZWNsYXJhdGl2ZUFuaW1hdGlvbi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Fu aW1hdGlvbi9EZWNsYXJhdGl2ZUFuaW1hdGlvbi5oCkBAIC05Miw3ICs5Miw3IEBAIHByaXZhdGU6 CiAKICAgICBFbGVtZW50KiBtX293bmluZ0VsZW1lbnQ7CiAgICAgUmVmPEFuaW1hdGlvbj4gbV9i YWNraW5nQW5pbWF0aW9uOwotICAgIGRvdWJsZSBtX3ByZXZpb3VzSXRlcmF0aW9uOworICAgIGRv dWJsZSBtX3ByZXZpb3VzSXRlcmF0aW9uIHsgMC4wIH07CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vUmVxdWVzdEFuaW1hdGlvbkZy YW1lQ2FsbGJhY2suaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVD YWxsYmFjay5oCmluZGV4IDA2Mzk4YzQzNTVhMTJmOWU4MDY1OWQ0MGM5NjM4OTk1MzJlZGJkNmYu LjIyMmJkNjk0YzgzNmMyODdhMTBjNzcyZTRhMjg0NTE0OTczYTQ0MTcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2RvbS9SZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFjay5oCkBAIC00Miw4 ICs0Miw4IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgQ2FsbGJhY2tSZXN1bHQ8dm9pZD4gaGFu ZGxlRXZlbnQoZG91YmxlIGhpZ2hSZXNUaW1lTXMpID0gMDsKIAotICAgIGludCBtX2lkOwotICAg IGJvb2wgbV9maXJlZE9yQ2FuY2VsbGVkOworICAgIGludCBtX2lkIHsgMCB9OworICAgIGJvb2wg bV9maXJlZE9yQ2FuY2VsbGVkIHsgZmFsc2UgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lbnVFbGVtZW50LmggYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZW51RWxlbWVudC5oCmluZGV4IGU2NTlmNzA4MDUzNzZi MWJjNWYyYjMxYTk2NGRkYWQwOWEzYThhYTUuLjhmNWI3ODVmMGE0ZTAwNTdiNmE4YmE0MzMwNmNj YTA0MTk5OGFkMTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lbnVFbGVt ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVudUVsZW1lbnQuaApAQCAtNDAs NyArNDAsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgcmVtb3ZlZEZyb21BbmNlc3RvcihSZW1vdmFs VHlwZSwgQ29udGFpbmVyTm9kZSYpIGZpbmFsOwogICAgIHZvaWQgcGFyc2VBdHRyaWJ1dGUoY29u c3QgUXVhbGlmaWVkTmFtZSYsIGNvbnN0IEF0b21pY1N0cmluZyYpIGZpbmFsOwogCi0gICAgYm9v bCBtX2lzVG91Y2hCYXJNZW51OworICAgIGJvb2wgbV9pc1RvdWNoQmFyTWVudSB7IGZhbHNlIH07 CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYktpdEJyaWRnZS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvQU5HTEVXZWJLaXRCcmlkZ2UuaAppbmRleCAzODIzNTkxOTUyNjRk N2E1MDA1NmZhMWRjOWY0MGJlYzc1ZWM3OTE1Li42ZDhlY2U0MGVjY2IwODc4YzgyNGE0MGU1ZDNl NWM2YmM4MTJjMTUyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9BTkdMRVdlYktpdEJyaWRnZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL0FOR0xFV2ViS2l0QnJpZGdlLmgKQEAgLTkyLDcgKzkyLDcgQEAgcHJpdmF0ZToKICAgICBT aFNoYWRlck91dHB1dCBtX3NoYWRlck91dHB1dDsKICAgICBTaFNoYWRlclNwZWMgbV9zaGFkZXJT cGVjOwogCi0gICAgU2hCdWlsdEluUmVzb3VyY2VzIG1fcmVzb3VyY2VzOworICAgIFNoQnVpbHRJ blJlc291cmNlcyBtX3Jlc291cmNlcyB7IH07CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFkaWVudElt YWdlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFkaWVudEltYWdlLmgK aW5kZXggZDc0ZDU3OGEyYzkzNDZmNjE3MTRmZDA4ZjdlMDg4Yzc4YWQ4MDEwYi4uNDA4MzkzZmJl ZDAxYjFhZDU4ZDhiOTM5MzVlMjE5OGU1YTY1Mzg4NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhZGllbnRJbWFnZS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL0dyYWRpZW50SW1hZ2UuaApAQCAtNTQsNyArNTQsNyBAQCBwcml2 YXRlOgogICAgIFJlZjxHcmFkaWVudD4gbV9ncmFkaWVudDsKICAgICBSZWZQdHI8SW1hZ2U+IG1f Y2FjaGVkSW1hZ2U7CiAgICAgRmxvYXRTaXplIG1fY2FjaGVkQWRqdXN0ZWRTaXplOwotICAgIHVu c2lnbmVkIG1fY2FjaGVkR2VuZXJhdG9ySGFzaDsKKyAgICB1bnNpZ25lZCBtX2NhY2hlZEdlbmVy YXRvckhhc2ggeyAwIH07CiAgICAgRmxvYXRTaXplIG1fY2FjaGVkU2NhbGVGYWN0b3I7CiB9Owog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIv TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5j cHAKaW5kZXggNWNiNWY3NTM2YWMzY2VmZTFlMTZjOThmZTk2NzAyMTEzMGE2ZGY3NC4uYWRhNmFj ZmQ4ODJkYzFkZWY3OWJkMWRjMzFiNjFiODNkOTQyYzkwMSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJl YW1lckJhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJl YW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcApAQCAtMjIxLDcgKzIyMSw3 IEBAIHByaXZhdGU6CiAgICAgR3N0QnVmZmVyKiBtX2J1ZmZlcjsKICAgICBHc3RWaWRlb0ZyYW1l IG1fdmlkZW9GcmFtZSB7IH07CiAgICAgSW50U2l6ZSBtX3NpemU7Ci0gICAgYm9vbCBtX2hhc0Fs cGhhQ2hhbm5lbDsKKyAgICBib29sIG1faGFzQWxwaGFDaGFubmVsIHsgZmFsc2UgfTsKICAgICBU ZXh0dXJlTWFwcGVyR0w6OkZsYWdzIG1fZmxhZ3MgeyB9OwogICAgIEdMdWludCBtX3RleHR1cmVJ RCB7IDAgfTsKICAgICBib29sIG1faXNNYXBwZWQgeyBmYWxzZSB9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdGV4bWFwL1RleHR1cmVNYXBwZXJQbGF0Zm9y bUxheWVyQnVmZmVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90ZXhtYXAv VGV4dHVyZU1hcHBlclBsYXRmb3JtTGF5ZXJCdWZmZXIuaAppbmRleCBkMTAwZTI0YWQxMzE2NDk3 OTRiOTA2OTJlNjYxMmEzN2FiN2M5YWViLi40NmI4ZGQ3NDE5YWZjZGZmMzk0MTMyZTA2Y2JlNzZl MWEwMWVlYTE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90 ZXhtYXAvVGV4dHVyZU1hcHBlclBsYXRmb3JtTGF5ZXJCdWZmZXIuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy90ZXhtYXAvVGV4dHVyZU1hcHBlclBsYXRmb3JtTGF5ZXJC dWZmZXIuaApAQCAtODAsNyArODAsNyBAQCBwcml2YXRlOgogCiAgICAgR0x1aW50IG1fdGV4dHVy ZUlEOwogICAgIEludFNpemUgbV9zaXplOwotICAgIEdMaW50IG1faW50ZXJuYWxGb3JtYXQ7Cisg ICAgR0xpbnQgbV9pbnRlcm5hbEZvcm1hdCB7IDAgfTsKICAgICBUZXh0dXJlTWFwcGVyR0w6OkZs YWdzIG1fZXh0cmFGbGFnczsKICAgICBib29sIG1faGFzTWFuYWdlZFRleHR1cmU7CiAgICAgc3Rk Ojp1bmlxdWVfcHRyPFVubWFuYWdlZEJ1ZmZlckRhdGFIb2xkZXI+IG1fdW5tYW5hZ2VkQnVmZmVy RGF0YUhvbGRlcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TY3Jv bGxiYXJUaGVtZUd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvU2Nyb2xsYmFy VGhlbWVHdGsuY3BwCmluZGV4IDIwOWFmN2I1NWRiYTRiMTE0MDk2NGZkNWNlMTQ2MTA5NWQwM2Yy MGIuLjkxMTEzYTBkNzM3MjRmMmQ2ZTA3NTM0ZjFhYjk5MzdmYTNjMjdjOGEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TY3JvbGxiYXJUaGVtZUd0ay5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Njcm9sbGJhclRoZW1lR3RrLmNwcApAQCAtNTMs NiArNTMsMTAgQEAgc3RhdGljIHZvaWQgdGhlbWVDaGFuZ2VkQ2FsbGJhY2soKQogfQogCiBTY3Jv bGxiYXJUaGVtZUd0azo6U2Nyb2xsYmFyVGhlbWVHdGsoKQorICAgIDogbV9oYXNGb3J3YXJkQnV0 dG9uU3RhcnRQYXJ0KGZhbHNlKQorICAgICwgbV9oYXNGb3J3YXJkQnV0dG9uRW5kUGFydChmYWxz ZSkKKyAgICAsIG1faGFzQmFja0J1dHRvblN0YXJ0UGFydChmYWxzZSkKKyAgICAsIG1faGFzQmFj a0J1dHRvbkVuZFBhcnQoZmFsc2UpCiB7CiAjaWYgR1RLX0NIRUNLX1ZFUlNJT04oMywgMjAsIDAp CiAgICAgbV91c2VzT3ZlcmxheVNjcm9sbGJhcnMgPSBnX3N0cmNtcDAoZ19nZXRlbnYoIkdUS19P VkVSTEFZX1NDUk9MTElORyIpLCAiMCIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vaW1hZ2UtZGVjb2RlcnMvanBlZy9KUEVHSW1hZ2VEZWNvZGVyLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL2pwZWcvSlBFR0ltYWdlRGVjb2Rlci5jcHAK aW5kZXggYjcyYzU1YTJjYjkwOWZhMzQ2MWNmNzk1ZjA0ZGNlYWQ1MTA0ZThlZS4uZDJjNjdlZmQ5 NDA0ZDVmYWIwZGI0MjQ4MDNhNTk5OTFlNGUwZGQ5YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvanBlZy9KUEVHSW1hZ2VEZWNvZGVyLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9qcGVnL0pQRUdJbWFnZURl Y29kZXIuY3BwCkBAIC00NTQsMTAgKzQ1NCwxMCBAQCBwcml2YXRlOgogICAgIEpQRUdJbWFnZURl Y29kZXIqIG1fZGVjb2RlcjsKICAgICB1bnNpZ25lZCBtX2J1ZmZlckxlbmd0aDsKICAgICBpbnQg bV9ieXRlc1RvU2tpcDsKLSAgICBib29sIG1fZGVjb2RpbmdTaXplT25seTsKKyAgICBib29sIG1f ZGVjb2RpbmdTaXplT25seSB7IGZhbHNlIH07CiAKICAgICBqcGVnX2RlY29tcHJlc3Nfc3RydWN0 IG1faW5mbzsKLSAgICBkZWNvZGVyX2Vycm9yX21nciBtX2VycjsKKyAgICBkZWNvZGVyX2Vycm9y X21nciBtX2VyciB7IH07CiAgICAganN0YXRlIG1fc3RhdGU7CiAKICAgICBKU0FNUEFSUkFZIG1f c2FtcGxlczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dENv ZGVjVVRGMTYuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dENvZGVjVVRGMTYu aAppbmRleCBjMTFiYmZiMWNhOGI4ZjNhOTFiMWE3ZWY4NWUyNGJiNGVjMTgzOWM3Li5iY2IxNGQ3 NGY1MGUzMjZlY2VkYWNmMGI3NWU4M2JjMTdlMTQzMzIyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS90ZXh0L1RleHRDb2RlY1VURjE2LmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vdGV4dC9UZXh0Q29kZWNVVEYxNi5oCkBAIC00Miw3ICs0Miw3IEBAIHByaXZhdGU6 CiAKICAgICBib29sIG1fbGl0dGxlRW5kaWFuOwogICAgIGJvb2wgbV9oYXZlQnVmZmVyZWRCeXRl IHsgZmFsc2UgfTsKLSAgICB1bnNpZ25lZCBjaGFyIG1fYnVmZmVyZWRCeXRlOworICAgIHVuc2ln bmVkIGNoYXIgbV9idWZmZXJlZEJ5dGUgeyAwIH07CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRnJhZ21lbnRl ZEZsb3cuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJGcmFnbWVudGVkRmxvdy5o CmluZGV4IDRjMzk3N2U1ZjBiZTYzMjcwM2NiNmRmYzVjNGQ1MGE2ZDMzOGQ4YmQuLjc1OTI1MTYw ZWY3ZjhmMzBkNzg4MjAwZDZkMzUyZGIxYWFlNjA0ODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJGcmFnbWVudGVkRmxvdy5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJGcmFnbWVudGVkRmxvdy5oCkBAIC0yMjcsNyArMjI3LDcgQEAgcHJv dGVjdGVkOgogICAgIHByaXZhdGU6CiAgICAgICAgIFdlYWtQdHI8UmVuZGVyRnJhZ21lbnRDb250 YWluZXI+IG1fc3RhcnRGcmFnbWVudDsKICAgICAgICAgV2Vha1B0cjxSZW5kZXJGcmFnbWVudENv bnRhaW5lcj4gbV9lbmRGcmFnbWVudDsKLSAgICAgICAgYm9vbCBtX3JhbmdlSW52YWxpZGF0ZWQ7 CisgICAgICAgIGJvb2wgbV9yYW5nZUludmFsaWRhdGVkIHsgZmFsc2UgfTsKICAgICB9OwogCiAg ICAgdHlwZWRlZiBQT0RJbnRlcnZhbDxMYXlvdXRVbml0LCBXZWFrUHRyPFJlbmRlckZyYWdtZW50 Q29udGFpbmVyPj4gRnJhZ21lbnRJbnRlcnZhbDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyU2NyaXB0TG9hZGVyLmggYi9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzL1dv cmtlclNjcmlwdExvYWRlci5oCmluZGV4IGI1NzQ4NTY4YWYxYjk0YWU0M2MxNGI0Mzk3MjRjYjlm ZDQ1NTM5M2QuLjJiMDkwMDdkNjY1YzU2ZDkxMGIzODFiNWQ5MGVlNjVlZGViMTFmZmIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyU2NyaXB0TG9hZGVyLmgKKysrIGIv U291cmNlL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJTY3JpcHRMb2FkZXIuaApAQCAtOTQsNyArOTQs NyBAQCBwcml2YXRlOgogICAgIFVSTCBtX3VybDsKICAgICBVUkwgbV9yZXNwb25zZVVSTDsKICAg ICBTdHJpbmcgbV9yZXNwb25zZU1JTUVUeXBlOwotICAgIEZldGNoT3B0aW9uczo6RGVzdGluYXRp b24gbV9kZXN0aW5hdGlvbjsKKyAgICBGZXRjaE9wdGlvbnM6OkRlc3RpbmF0aW9uIG1fZGVzdGlu YXRpb24geyBGZXRjaE9wdGlvbnM6OkRlc3RpbmF0aW9uOjpFbXB0eVN0cmluZyB9OwogICAgIENv bnRlbnRTZWN1cml0eVBvbGljeVJlc3BvbnNlSGVhZGVycyBtX2NvbnRlbnRTZWN1cml0eVBvbGlj eTsKICAgICBTdHJpbmcgbV9yZWZlcnJlclBvbGljeTsKICAgICB1bnNpZ25lZCBsb25nIG1faWRl bnRpZmllciB7IDAgfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1BsdWdpbnMv UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGIvU291cmNlL1dlYktpdC9TaGFyZWQv UGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKaW5kZXggZDMyNjg4MGE5 NDc3YjNhYmViM2FiMzk2MGFhZDBiYWMxMmE1M2E4Zi4uYmUwNzVlYzMzYTY3ZjE2YTdmZThhNWY5 NjlkMWY5MDAyZWY1YzhlNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvUGx1Z2lu cy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKKysrIGIvU291cmNlL1dlYktpdC9T aGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKQEAgLTQ3LDcg KzQ3LDcgQEAgc3RydWN0IFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMgewogICAgIHZv aWQgZW5jb2RlKElQQzo6RW5jb2RlciYpIGNvbnN0OwogICAgIHN0YXRpYyBib29sIGRlY29kZShJ UEM6OkRlY29kZXImLCBQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJik7CiAKLSAgICBQ bHVnaW5Qcm9jZXNzVHlwZSBwcm9jZXNzVHlwZTsKKyAgICBQbHVnaW5Qcm9jZXNzVHlwZSBwcm9j ZXNzVHlwZSB7IFBsdWdpblByb2Nlc3NUeXBlTm9ybWFsIH07CiAgICAgYm9vbCBzdXBwb3J0c0Fz eW5jaHJvbm91c1BsdWdpbkluaXRpYWxpemF0aW9uOwogCiAgICAgU2Vjb25kcyBtaW5pbXVtTGlm ZXRpbWU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ2xpYi9JY29u RGF0YWJhc2UuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL0ljb25EYXRhYmFz ZS5oCmluZGV4IGJhYmQ4YTk4MjlmYjgwZDE5ODUyZWM5NzRhZWVhNzBjZWUwYjkxNTguLjIwZGE5 NzIzMzFjNjAzMzYzMTkyMDVjZTYwNTg1NzkzMGZlNTRlMGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL0ljb25EYXRhYmFzZS5oCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9nbGliL0ljb25EYXRhYmFzZS5oCkBAIC0yMjYsNyArMjI2LDcgQEAg cHJpdmF0ZToKIAogICAgICAgICBEZXF1ZTxGdW5jdGlvbjx2b2lkKCk+PiBtX25vdGlmaWNhdGlv blF1ZXVlOwogICAgICAgICBMb2NrIG1fbm90aWZpY2F0aW9uUXVldWVMb2NrOwotICAgICAgICBB dG9taWM8Ym9vbD4gbV9pc0FjdGl2ZTsKKyAgICAgICAgQXRvbWljPGJvb2w+IG1faXNBY3RpdmUg eyBmYWxzZSB9OwogICAgICAgICBSdW5Mb29wOjpUaW1lcjxNYWluVGhyZWFkTm90aWZpZXI+IG1f dGltZXI7CiAgICAgfTsKIAo=