215879 2020-08-26 22:35:55 -0700 Add a variant of map which filters items to Vector.h 2021-04-12 21:45:50 -0700 1 1 1 Unclassified WebKit Web Template Framework WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=215673 https://bugs.webkit.org/show_bug.cgi?id=216119 InRadar P2 Normal --- 224470 1 rniwa rniwa benjamin cdumez cmarcelo darin ews-watchlist geofflang koivisto saam sam simon.fraser webkit-bug-importer youennf ysuzuki zalan oldest_to_newest 1683284 0 rniwa 2020-08-26 22:35:55 -0700 Add filteredMap which calls mapFunction on each item on an iterable object and filters the result by the boolean operator. 1683288 1 407376 rniwa 2020-08-26 22:49:36 -0700 Created attachment 407376 Adds filteredMap 1683307 2 407376 youennf 2020-08-27 00:58:46 -0700 Comment on attachment 407376 Adds filteredMap View in context: https://bugs.webkit.org/attachment.cgi?id=407376&action=review > Source/WTF/wtf/Vector.h:1694 > + static ItemType extractValue(Optional<T>& returnValue) { return *returnValue; } It seems we might be using ItemType copy constructor. Ideally, we would take an Optional<>&& as input and use ItemType move constructor. Can we add a test with a filter function returning an Optional<Ref-Like-For-Test<...>> and verify there is no unnecessary count churning? 1683401 3 407376 sam 2020-08-27 09:24:39 -0700 Comment on attachment 407376 Adds filteredMap View in context: https://bugs.webkit.org/attachment.cgi?id=407376&action=review > Source/WTF/ChangeLog:11 > + This patch adds WTF::filteredMap, which calls a function on each item in an iterable object like WTF::map > + but also filters the returned value. The mapped function may return Optional<T> or RefPtr<T>. The value > + is kept in the result if the returned value is not WTF::nullopt in the case of Optional<T> and not null > + in the case of RefPtr<T>. The result will be either Vector<T> for Optional<T> or else Vector<Ref<T>>. I get that Optional<Ref<T>> is a bad thing to store in a class (since it will be 2 * sizeof(T*) rather than sizeof(T*)), but I think for something like this, where we are only using it as a return type, Optional<Ref<T>> might be nicer, and would require less special casing. Is there a particular use where having this special case for RefPtr is useful? (as a side note, I think we should start thinking about what specializing Optional<Ref<T>> to be sizeof(T*) would mean. The most obvious thing it would mean is that we couldn't move to std::optional<>, but that seems contentious already). 1683432 4 darin 2020-08-27 10:58:09 -0700 I agree with Sam’s comments and have some of the same thoughts and questions that he does. I think we should look at optimizing Optional<Ref<T>> if we are willing to let the std::optional possibility go for good, and making Optional<Ref<T>> and RefPtr<T> much more interoperable. There’s already quite a bit, since the "*" operator works on both and if (x) works on both. But it would be nice to be able to use nullptr to mean WTF::nullopt in this case, and to support both move and copy assignment and conversion in both directions with syntax that’s as convenient as possible. There’s no need to be at all explicit about such conversions; they’re not lossy at all. 1683433 5 darin 2020-08-27 11:02:51 -0700 Swift calls this operation compactMap. I like that name a bit better than filteredMap. Could also consider reconciling terminology a bit between my makeNSArray, makeVector, map, and this new function. I don’t like how different those names are. Maybe we should rename makeNSArray and makeVector to compactMapToNSArray and compactMapToVector. When programming in Swift I really enjoy map, filter, reduce, flatMap, and compactMap, and I think we might eventually find we want all 5 of them. 1683512 6 rniwa 2020-08-27 16:07:17 -0700 (In reply to youenn fablet from comment #2) > Comment on attachment 407376 [details] > Adds filteredMap > > View in context: > https://bugs.webkit.org/attachment.cgi?id=407376&action=review > > > Source/WTF/wtf/Vector.h:1694 > > + static ItemType extractValue(Optional<T>& returnValue) { return *returnValue; } > > It seems we might be using ItemType copy constructor. > Ideally, we would take an Optional<>&& as input and use ItemType move > constructor. No. https://en.cppreference.com/w/cpp/language/copy_elision (In reply to Sam Weinig from comment #3) > Comment on attachment 407376 [details] > Adds filteredMap > > View in context: > https://bugs.webkit.org/attachment.cgi?id=407376&action=review > > > Source/WTF/ChangeLog:11 > > + This patch adds WTF::filteredMap, which calls a function on each item in an iterable object like WTF::map > > + but also filters the returned value. The mapped function may return Optional<T> or RefPtr<T>. The value > > + is kept in the result if the returned value is not WTF::nullopt in the case of Optional<T> and not null > > + in the case of RefPtr<T>. The result will be either Vector<T> for Optional<T> or else Vector<Ref<T>>. > > I get that Optional<Ref<T>> is a bad thing to store in a class (since it > will be 2 * sizeof(T*) rather than sizeof(T*)), but I think for something > like this, where we are only using it as a return type, Optional<Ref<T>> > might be nicer, and would require less special casing. > > Is there a particular use where having this special case for RefPtr is > useful? The main use case is calling an existing function which returns RefPtr. It's annoying to write code like this: filteredMap(~, Optional<Ref<X>> [] (auto& x) { auto result = foo(x); if (!result) return WTF::nullopt; return result.releaseNonNull(); }); (In reply to Darin Adler from comment #5) > Swift calls this operation compactMap. I like that name a bit better than > filteredMap. Okay, we can call this compactMap. 1683584 7 407450 rniwa 2020-08-27 22:07:06 -0700 Created attachment 407450 Updated per review comments 1683585 8 rniwa 2020-08-27 22:08:00 -0700 (In reply to Darin Adler from comment #5) > > When programming in Swift I really enjoy map, filter, reduce, flatMap, and > compactMap, and I think we might eventually find we want all 5 of them. I think filter is up next for sure. 1683693 9 sam 2020-08-28 10:43:32 -0700 (In reply to Ryosuke Niwa from comment #6) > (In reply to youenn fablet from comment #2) > > > Source/WTF/ChangeLog:11 > > > + This patch adds WTF::filteredMap, which calls a function on each item in an iterable object like WTF::map > > > + but also filters the returned value. The mapped function may return Optional<T> or RefPtr<T>. The value > > > + is kept in the result if the returned value is not WTF::nullopt in the case of Optional<T> and not null > > > + in the case of RefPtr<T>. The result will be either Vector<T> for Optional<T> or else Vector<Ref<T>>. > > > > I get that Optional<Ref<T>> is a bad thing to store in a class (since it > > will be 2 * sizeof(T*) rather than sizeof(T*)), but I think for something > > like this, where we are only using it as a return type, Optional<Ref<T>> > > might be nicer, and would require less special casing. > > > > Is there a particular use where having this special case for RefPtr is > > useful? > > The main use case is calling an existing function which returns RefPtr. It's > annoying to write code like this: > > filteredMap(~, Optional<Ref<X>> [] (auto& x) { > auto result = foo(x); > if (!result) > return WTF::nullopt; > return result.releaseNonNull(); > }); > Is there a specific instance of this you have in mind for use with this new function? That would probably help me visualize things a bit better. 1683742 10 407450 darin 2020-08-28 12:45:56 -0700 Comment on attachment 407450 Updated per review comments View in context: https://bugs.webkit.org/attachment.cgi?id=407450&action=review > Source/WTF/wtf/Vector.h:1741 > +template<typename MapFunction, typename SourceType> > +Vector<typename CompactMapper<MapFunction, SourceType>::DestinationItemType> compactMap(SourceType&& source, MapFunction&& mapFunction) With "map" still a member function but this a free function, we are a bit inconsistent. > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:885 > + auto mapped = WTF::compactMap(vector, evenMultipliedByFive); Not sure the WTF prefix is needed here. 1683745 11 407450 darin 2020-08-28 12:49:44 -0700 Comment on attachment 407450 Updated per review comments View in context: https://bugs.webkit.org/attachment.cgi?id=407450&action=review > Source/WTF/wtf/Vector.h:1716 > + result.append(CompactMapTraits<ResultItemType>::extractValue(itemResult)); Don’t we want WTFMove here? Should we add test coverage tho check for that? > Source/WTF/wtf/Vector.h:1718 > + return result; I think typically we’d want a call to shrinkToFit here if we don’t use reserveInitialCapacity. > Source/WTF/wtf/Vector.h:1734 > + result.append(CompactMapTraits<ResultItemType>::extractValue(itemResult)); Don’t we want WTFMove here? Should we add test coverage tho check for that? > Source/WTF/wtf/Vector.h:1736 > + return result; I think typically we’d want a call to shrinkToFit here if we don’t use reserveInitialCapacity. 1683794 12 rniwa 2020-08-28 15:39:40 -0700 (In reply to Sam Weinig from comment #9) > > Is there a specific instance of this you have in mind for use with this new > function? That would probably help me visualize things a bit better. Sure. In HTMLSlotElement::assignedNodes, we have a code like this: Vector<Ref<Node>> nodes; nodes.reserveInitialCapacity(assignedNodes->size()); for (auto& nodePtr : *assignedNodes) { auto* node = nodePtr.get(); if (UNLIKELY(!node)) continue; nodes.uncheckedAppend(*node); } This could be written as: assignedNodes.compactMap([](auto& node) -> RefPtr<Node> { return node.get(); }); I guess we can add a helper on WeakPtr to return Optional<Ref<>> as well but given many of these classes and functions return RefPtr right now, it's going to be annoying. There is also the case of functions returning a raw pointer as well. Unless we create a helper to convert T* to Optional<T&> and Optional<Ref<T>>, it would be annoying to explicitly create either. 1683795 13 407450 rniwa 2020-08-28 15:43:13 -0700 Comment on attachment 407450 Updated per review comments View in context: https://bugs.webkit.org/attachment.cgi?id=407450&action=review >> Source/WTF/wtf/Vector.h:1716 >> + result.append(CompactMapTraits<ResultItemType>::extractValue(itemResult)); > > Don’t we want WTFMove here? Should we add test coverage tho check for that? No, this is the version which doesn't move the original Vector. I guess I didn't add a test coverage for this one so I'll add it. (the r-reference version is now tested by CompactMapLambdaReturnOptionalCountedObject). >> Source/WTF/wtf/Vector.h:1718 >> + return result; > > I think typically we’d want a call to shrinkToFit here if we don’t use reserveInitialCapacity. Sure, I can add that call there. >> Source/WTF/wtf/Vector.h:1734 >> + result.append(CompactMapTraits<ResultItemType>::extractValue(itemResult)); > > Don’t we want WTFMove here? Should we add test coverage tho check for that? No, Youenn mentioned that too earlier but copy elision takes care of that, and I did add test a test per Youenn's comment: CompactMapLambdaReturnOptionalCountedObject I guess I forgot to update the change log so I'll update that. >> Source/WTF/wtf/Vector.h:1736 >> + return result; > > I think typically we’d want a call to shrinkToFit here if we don’t use reserveInitialCapacity. Sure, will do. >> Source/WTF/wtf/Vector.h:1741 >> +Vector<typename CompactMapper<MapFunction, SourceType>::DestinationItemType> compactMap(SourceType&& source, MapFunction&& mapFunction) > > With "map" still a member function but this a free function, we are a bit inconsistent. Hm... I guess we can call it CompactMapper<~>::compactMap. 1684329 14 407450 rniwa 2020-08-31 18:05:38 -0700 Comment on attachment 407450 Updated per review comments View in context: https://bugs.webkit.org/attachment.cgi?id=407450&action=review >>> Source/WTF/wtf/Vector.h:1734 >>> + result.append(CompactMapTraits<ResultItemType>::extractValue(itemResult)); >> >> Don’t we want WTFMove here? Should we add test coverage tho check for that? > > No, Youenn mentioned that too earlier but copy elision takes care of that, > and I did add test a test per Youenn's comment: CompactMapLambdaReturnOptionalCountedObject > > I guess I forgot to update the change log so I'll update that. Oh, now I see what's wrong here. You were talking about the argument to extractValue, not the return value. My test had a bug to not catch this. Fixed that. 1684351 15 407649 rniwa 2020-08-31 19:06:36 -0700 Created attachment 407649 Updated patch 1684352 16 rniwa 2020-08-31 19:07:09 -0700 Putting this up for a review once again since I've added quite a few new unit tests and there has been some semantic changes in the code as well. 1684738 17 rniwa 2020-09-02 00:20:06 -0700 Ping reviewers. 1684890 18 407649 ysuzuki 2020-09-02 11:28:14 -0700 Comment on attachment 407649 Updated patch r=me 1684895 19 407649 youennf 2020-09-02 11:32:50 -0700 Comment on attachment 407649 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=407649&action=review > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:926 > + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedForOdd); auto > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:946 > + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedForEven); auto > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:968 > + Vector<RefPtr<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedWhenDivisibleByThree); auto > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:995 > + CountedObject(int value) explicit > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:1063 > + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, [](int value) -> RefPtr<RefCountedObject> { auto > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:1102 > + Vector<RefPtr<RefCountedObject>> mapped = WTF::compactMap(vector, [&](int value) -> Optional<RefPtr<RefCountedObject>> { s/Vector<RefPtr<RefCountedObject>>/auto > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:1110 > + EXPECT_EQ(0U, RefCountedObject::s_totalRefCount); I guess you might want to set s_totalRefCount to zero at the beginning of this test 1684903 20 rniwa 2020-09-02 11:47:07 -0700 (In reply to youenn fablet from comment #19) > Comment on attachment 407649 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=407649&action=review > > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:926 > > + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedForOdd); > > auto I actually wanted to explicitly write out the type so that if we regress compactMap to start returning a wrong type, we'd catch it. > > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:946 > > + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedForEven); > > auto I guess we can use auto here since I've already tested above. > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:968 > > + Vector<RefPtr<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedWhenDivisibleByThree); > > auto Here, because it's RefPtr, I'd like to test it. > > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:995 > > + CountedObject(int value) > > explicit Fixed. > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:1063 > > + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, [](int value) -> RefPtr<RefCountedObject> { > > auto Ditto about testing the type. > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:1102 > > + Vector<RefPtr<RefCountedObject>> mapped = WTF::compactMap(vector, [&](int value) -> Optional<RefPtr<RefCountedObject>> { > > s/Vector<RefPtr<RefCountedObject>>/auto Ditto. > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:1110 > > + EXPECT_EQ(0U, RefCountedObject::s_totalRefCount); > > I guess you might want to set s_totalRefCount to zero at the beginning of > this test Good point. Fixed. 1684910 21 407783 rniwa 2020-09-02 12:04:29 -0700 Created attachment 407783 Patch for landing 1684981 22 ews-feeder 2020-09-02 14:16:31 -0700 Committed r266488: <https://trac.webkit.org/changeset/266488> All reviewed patches have been landed. Closing bug and clearing flags on attachment 407783. 1684984 23 webkit-bug-importer 2020-09-02 14:17:30 -0700 <rdar://problem/68232471> 1684992 24 407649 darin 2020-09-02 14:20:53 -0700 Comment on attachment 407649 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=407649&action=review >>> Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:926 >>> + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedForOdd); >> >> auto > > I actually wanted to explicitly write out the type so that if we regress compactMap to start returning a wrong type, we'd catch it. Technically that’s not right. Assigning to a specific type will test that we can convert to that type, not that we return the right type. The way to check what type we return is with a static_assert of what the return type is. >>> Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:968 >>> + Vector<RefPtr<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedWhenDivisibleByThree); >> >> auto > > Here, because it's RefPtr, I'd like to test it. Same comment as above. 1685105 25 rniwa 2020-09-02 18:45:01 -0700 (In reply to Darin Adler from comment #24) > Comment on attachment 407649 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=407649&action=review > > >>> Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:926 > >>> + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedForOdd); > >> > >> auto > > > > I actually wanted to explicitly write out the type so that if we regress compactMap to start returning a wrong type, we'd catch it. > > Technically that’s not right. Assigning to a specific type will test that we > can convert to that type, not that we return the right type. The way to > check what type we return is with a static_assert of what the return type is. That's a good point. 1685187 26 rniwa 2020-09-02 22:37:53 -0700 (In reply to Ryosuke Niwa from comment #25) > (In reply to Darin Adler from comment #24) > > Comment on attachment 407649 [details] > > Updated patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=407649&action=review > > > > >>> Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:926 > > >>> + Vector<Ref<RefCountedObject>> mapped = WTF::compactMap(vector, createRefCountedForOdd); > > >> > > >> auto > > > > > > I actually wanted to explicitly write out the type so that if we regress compactMap to start returning a wrong type, we'd catch it. > > > > Technically that’s not right. Assigning to a specific type will test that we > > can convert to that type, not that we return the right type. The way to > > check what type we return is with a static_assert of what the return type is. > > That's a good point. Addressing this in https://bugs.webkit.org/show_bug.cgi?id=216119 407376 2020-08-26 22:49:36 -0700 2020-08-27 22:07:04 -0700 Adds filteredMap bug-215879-20200826224936.patch text/plain 11011 rniwa U3VidmVyc2lvbiBSZXZpc2lvbjogMjY2MjEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDE2YTJiNWFkN2I2MjgxYTdlNmI5NDJj NDcxNjFlMGM4Nzc3ZWNiN2EuLjY2M2I1OTQ4NjJjMGE4Y2RjYWNiYmFiMzdjMmMzMDE4MmRkYjk1 OWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjAtMDgtMjYgIFJ5b3N1a2UgTml3YSAgPHJuaXdh QHdlYmtpdC5vcmc+CisKKyAgICAgICAgQWRkIGEgdmFyaWFudCBvZiBtYXAgd2hpY2ggZmlsdGVy cyBpdGVtcyB0byBWZWN0b3IuaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjE1ODc5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIFdURjo6ZmlsdGVyZWRNYXAsIHdoaWNoIGNhbGxz IGEgZnVuY3Rpb24gb24gZWFjaCBpdGVtIGluIGFuIGl0ZXJhYmxlIG9iamVjdCBsaWtlIFdURjo6 bWFwCisgICAgICAgIGJ1dCBhbHNvIGZpbHRlcnMgdGhlIHJldHVybmVkIHZhbHVlLiBUaGUgbWFw cGVkIGZ1bmN0aW9uIG1heSByZXR1cm4gT3B0aW9uYWw8VD4gb3IgUmVmUHRyPFQ+LiBUaGUgdmFs dWUKKyAgICAgICAgaXMga2VwdCBpbiB0aGUgcmVzdWx0IGlmIHRoZSByZXR1cm5lZCB2YWx1ZSBp cyBub3QgV1RGOjpudWxsb3B0IGluIHRoZSBjYXNlIG9mIE9wdGlvbmFsPFQ+IGFuZCBub3QgbnVs bAorICAgICAgICBpbiB0aGUgY2FzZSBvZiBSZWZQdHI8VD4uIFRoZSByZXN1bHQgd2lsbCBiZSBl aXRoZXIgVmVjdG9yPFQ+IGZvciBPcHRpb25hbDxUPiBvciBlbHNlIFZlY3RvcjxSZWY8VD4+Lgor CisgICAgICAgICogd3RmL1ZlY3Rvci5oOgorICAgICAgICAoV1RGOjpGaWx0ZXJlZE1hcFRyYWl0 czopOiBBZGRlZC4gVHJhaXRzIHRvIGhhdmUgYSBkaWZmZXJlbnQgYmVoYXZpb3IKKyAgICAgICAg KFdURjo6RmlsdGVyZWRNYXBUcmFpdHM8T3B0aW9uYWw8VD4+OjpoYXNWYWx1ZSk6IEFkZGVkLgor ICAgICAgICAoV1RGOjpGaWx0ZXJlZE1hcFRyYWl0czxPcHRpb25hbDxUPj46OmV4dHJhY3RWYWx1 ZSk6IEFkZGVkLgorICAgICAgICAoV1RGOjpGaWx0ZXJlZE1hcFRyYWl0czxSZWZQdHI8VD4+Ojpo YXNWYWx1ZSk6IEFkZGVkLgorICAgICAgICAoV1RGOjpGaWx0ZXJlZE1hcFRyYWl0czxSZWZQdHI8 VD4+OjpleHRyYWN0VmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKFdURjo6RmlsdGVyZWRNYXApOiBB ZGRlZC4gVGhlIGhlbHBlciB0byB1c2UgV1RGTW92ZSBvbiB0aGUgYXJndW1lbnQgdG8gdGhlIG1h cHBlZCBmdW5jdGlvbiBpZiBwb3NzaWJsZS4KKyAgICAgICAgKFdURjo6ZmlsdGVyZWRNYXApOiBB ZGRlZC4KKwogMjAyMC0wOC0yNSAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KIAog ICAgICAgICBIYXNoTWFwPFJlZjxUPj46OnRha2Ugc2hvdWxkIHJldHVybiBSZWZQdHI8VD4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oIGIvU291cmNlL1dURi93dGYvVmVjdG9y LmgKaW5kZXggZjk4Zjg0ZTYzOGNlMjI4MDM3ZWYyMDRlODZlYTc4MmI5YTE1MzhjOS4uYzljNTYw ZjFiNDIxNzU0OGIxOWYwYmI3NGE3MTJjNGQwMjUwZmNmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dU Ri93dGYvVmVjdG9yLmgKKysrIGIvU291cmNlL1dURi93dGYvVmVjdG9yLmgKQEAgLTE2ODAsNiAr MTY4MCw2OSBAQCBWZWN0b3I8dHlwZW5hbWUgTWFwcGVyPE1hcEZ1bmN0aW9uLCBTb3VyY2VUeXBl Pjo6RGVzdGluYXRpb25JdGVtVHlwZT4gbWFwKFNvdXJjZQogICAgIHJldHVybiBNYXBwZXI8TWFw RnVuY3Rpb24sIFNvdXJjZVR5cGU+OjptYXAoc3RkOjpmb3J3YXJkPFNvdXJjZVR5cGU+KHNvdXJj ZSksIHN0ZDo6Zm9yd2FyZDxNYXBGdW5jdGlvbj4obWFwRnVuY3Rpb24pKTsKIH0KIAordGVtcGxh dGU8dHlwZW5hbWUgTWFwRnVuY3Rpb25SZXR1cm5UeXBlPgorc3RydWN0IEZpbHRlcmVkTWFwVHJh aXRzIHsKKyAgICBzdGF0aWMgYm9vbCBoYXNWYWx1ZShjb25zdCBNYXBGdW5jdGlvblJldHVyblR5 cGUmKTsKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBJdGVtVHlwZT4KKyAgICBzdGF0aWMgSXRlbVR5 cGUgZXh0cmFjdFZhbHVlKE1hcEZ1bmN0aW9uUmV0dXJuVHlwZSYpOworfTsKKwordGVtcGxhdGU8 dHlwZW5hbWUgVD4KK3N0cnVjdCBGaWx0ZXJlZE1hcFRyYWl0czxPcHRpb25hbDxUPj4geworICAg IHVzaW5nIEl0ZW1UeXBlID0gVDsKKyAgICBzdGF0aWMgYm9vbCBoYXNWYWx1ZShjb25zdCBPcHRp b25hbDxUPiYgcmV0dXJuVmFsdWUpIHsgcmV0dXJuICEhcmV0dXJuVmFsdWU7IH0KKyAgICBzdGF0 aWMgSXRlbVR5cGUgZXh0cmFjdFZhbHVlKE9wdGlvbmFsPFQ+JiByZXR1cm5WYWx1ZSkgeyByZXR1 cm4gKnJldHVyblZhbHVlOyB9Cit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorc3RydWN0IEZp bHRlcmVkTWFwVHJhaXRzPFJlZlB0cjxUPj4geworICAgIHVzaW5nIEl0ZW1UeXBlID0gUmVmPFQ+ OworICAgIHN0YXRpYyBib29sIGhhc1ZhbHVlKGNvbnN0IFJlZlB0cjxUPiYgcmV0dXJuVmFsdWUp IHsgcmV0dXJuICEhcmV0dXJuVmFsdWU7IH0KKyAgICBzdGF0aWMgSXRlbVR5cGUgZXh0cmFjdFZh bHVlKFJlZlB0cjxUPiYgcmV0dXJuVmFsdWUpIHsgcmV0dXJuIHJldHVyblZhbHVlLnJlbGVhc2VO b25OdWxsKCk7IH0KK307CisKK3RlbXBsYXRlPHR5cGVuYW1lIE1hcEZ1bmN0aW9uLCB0eXBlbmFt ZSBTb3VyY2VUeXBlLCB0eXBlbmFtZSBFbmFibGUgPSB2b2lkPgorc3RydWN0IEZpbHRlcmVkTWFw cGVyIHsKKyAgICB1c2luZyBTb3VyY2VJdGVtVHlwZSA9IHR5cGVuYW1lIENvbGxlY3Rpb25JbnNw ZWN0b3I8U291cmNlVHlwZT46OlNvdXJjZUl0ZW1UeXBlOworICAgIHVzaW5nIFJlc3VsdEl0ZW1U eXBlID0gdHlwZW5hbWUgc3RkOjpyZXN1bHRfb2Y8TWFwRnVuY3Rpb24oU291cmNlSXRlbVR5cGUm KT46OnR5cGU7CisgICAgdXNpbmcgRGVzdGluYXRpb25JdGVtVHlwZSA9IHR5cGVuYW1lIEZpbHRl cmVkTWFwVHJhaXRzPFJlc3VsdEl0ZW1UeXBlPjo6SXRlbVR5cGU7CisKKyAgICBzdGF0aWMgVmVj dG9yPERlc3RpbmF0aW9uSXRlbVR5cGU+IG1hcChTb3VyY2VUeXBlIHNvdXJjZSwgY29uc3QgTWFw RnVuY3Rpb24mIG1hcEZ1bmN0aW9uKQorICAgIHsKKyAgICAgICAgVmVjdG9yPERlc3RpbmF0aW9u SXRlbVR5cGU+IHJlc3VsdDsKKyAgICAgICAgZm9yIChhdXRvJiBpdGVtIDogc291cmNlKSB7Cisg ICAgICAgICAgICBhdXRvIGl0ZW1SZXN1bHQgPSBtYXBGdW5jdGlvbihpdGVtKTsKKyAgICAgICAg ICAgIGlmIChGaWx0ZXJlZE1hcFRyYWl0czxSZXN1bHRJdGVtVHlwZT46Omhhc1ZhbHVlKGl0ZW1S ZXN1bHQpKQorICAgICAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoRmlsdGVyZWRNYXBUcmFpdHM8 UmVzdWx0SXRlbVR5cGU+OjpleHRyYWN0VmFsdWUoaXRlbVJlc3VsdCkpOworICAgICAgICB9Cisg ICAgICAgIHJldHVybiByZXN1bHQ7CisgICAgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgTWFw RnVuY3Rpb24sIHR5cGVuYW1lIFNvdXJjZVR5cGU+CitzdHJ1Y3QgRmlsdGVyZWRNYXBwZXI8TWFw RnVuY3Rpb24sIFNvdXJjZVR5cGUsIHR5cGVuYW1lIHN0ZDo6ZW5hYmxlX2lmPHN0ZDo6aXNfcnZh bHVlX3JlZmVyZW5jZTxTb3VyY2VUeXBlJiY+Ojp2YWx1ZT46OnR5cGU+IHsKKyAgICB1c2luZyBT b3VyY2VJdGVtVHlwZSA9IHR5cGVuYW1lIENvbGxlY3Rpb25JbnNwZWN0b3I8U291cmNlVHlwZT46 OlNvdXJjZUl0ZW1UeXBlOworICAgIHVzaW5nIFJlc3VsdEl0ZW1UeXBlID0gdHlwZW5hbWUgc3Rk OjpyZXN1bHRfb2Y8TWFwRnVuY3Rpb24oU291cmNlSXRlbVR5cGUmKT46OnR5cGU7CisgICAgdXNp bmcgRGVzdGluYXRpb25JdGVtVHlwZSA9IHR5cGVuYW1lIEZpbHRlcmVkTWFwVHJhaXRzPFJlc3Vs dEl0ZW1UeXBlPjo6SXRlbVR5cGU7CisKKyAgICBzdGF0aWMgVmVjdG9yPERlc3RpbmF0aW9uSXRl bVR5cGU+IG1hcChTb3VyY2VUeXBlIHNvdXJjZSwgY29uc3QgTWFwRnVuY3Rpb24mIG1hcEZ1bmN0 aW9uKQorICAgIHsKKyAgICAgICAgVmVjdG9yPERlc3RpbmF0aW9uSXRlbVR5cGU+IHJlc3VsdDsK KyAgICAgICAgZm9yIChhdXRvJiBpdGVtIDogc291cmNlKSB7CisgICAgICAgICAgICBhdXRvIGl0 ZW1SZXN1bHQgPSBtYXBGdW5jdGlvbihXVEZNb3ZlKGl0ZW0pKTsKKyAgICAgICAgICAgIGlmIChG aWx0ZXJlZE1hcFRyYWl0czxSZXN1bHRJdGVtVHlwZT46Omhhc1ZhbHVlKGl0ZW1SZXN1bHQpKQor ICAgICAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQoRmlsdGVyZWRNYXBUcmFpdHM8UmVzdWx0SXRl bVR5cGU+OjpleHRyYWN0VmFsdWUoaXRlbVJlc3VsdCkpOworICAgICAgICB9CisgICAgICAgIHJl dHVybiByZXN1bHQ7CisgICAgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgTWFwRnVuY3Rpb24s IHR5cGVuYW1lIFNvdXJjZVR5cGU+CitWZWN0b3I8dHlwZW5hbWUgRmlsdGVyZWRNYXBwZXI8TWFw RnVuY3Rpb24sIFNvdXJjZVR5cGU+OjpEZXN0aW5hdGlvbkl0ZW1UeXBlPiBmaWx0ZXJlZE1hcChT b3VyY2VUeXBlJiYgc291cmNlLCBNYXBGdW5jdGlvbiYmIG1hcEZ1bmN0aW9uKQoreworICAgIHJl dHVybiBGaWx0ZXJlZE1hcHBlcjxNYXBGdW5jdGlvbiwgU291cmNlVHlwZT46Om1hcChzdGQ6OmZv cndhcmQ8U291cmNlVHlwZT4oc291cmNlKSwgc3RkOjpmb3J3YXJkPE1hcEZ1bmN0aW9uPihtYXBG dW5jdGlvbikpOworfQorCiB0ZW1wbGF0ZTx0eXBlbmFtZSBEZXN0aW5hdGlvblZlY3RvciwgdHlw ZW5hbWUgQ29sbGVjdGlvbj4KIGlubGluZSBhdXRvIGNvcHlUb1ZlY3RvclNwZWNpYWxpemF0aW9u KGNvbnN0IENvbGxlY3Rpb24mIGNvbGxlY3Rpb24pIC0+IERlc3RpbmF0aW9uVmVjdG9yCiB7CkBA IC0xNzE1LDQgKzE3NzgsNSBAQCB1c2luZyBXVEY6OlZlY3RvcjsKIHVzaW5nIFdURjo6Y29weVRv VmVjdG9yOwogdXNpbmcgV1RGOjpjb3B5VG9WZWN0b3JPZjsKIHVzaW5nIFdURjo6Y29weVRvVmVj dG9yU3BlY2lhbGl6YXRpb247Cit1c2luZyBXVEY6OmZpbHRlcmVkTWFwOwogdXNpbmcgV1RGOjpy ZW1vdmVSZXBlYXRlZEVsZW1lbnRzOwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9v bHMvQ2hhbmdlTG9nCmluZGV4IDM3NmIyNTU1NGVmMjEwMTM1NDkyODUxMGZhMjkyYTUxZmM2YzU1 MTcuLjczZTRlMmQ2MDY0ODMyNzdiMzdjNjE3NzU1ZjUyMzBlYTY2MzBiMzAgMTAwNjQ0Ci0tLSBh L1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAor MjAyMC0wOC0yNiAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KKworICAgICAgICBB ZGQgYSB2YXJpYW50IG9mIG1hcCB3aGljaCBmaWx0ZXJzIGl0ZW1zIHRvIFZlY3Rvci5oCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTU4NzkKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB1bml0IHRl c3RzLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcDoKKyAg ICAgICAgKFRlc3RXZWJLaXRBUEk6OmV2ZW5NdWx0aXBsaWVkQnlGaXZlKToKKyAgICAgICAgKFdU Rl9WZWN0b3IuRmlsdGVyZWRNYXBTdGF0aWNGdW5jdGlvblJldHVybk9wdGlvbmFsKToKKyAgICAg ICAgKFRlc3RXZWJLaXRBUEk6OlJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZSk6CisgICAgICAgIChU ZXN0V2ViS2l0QVBJOjpSZWZDb3VudGVkT2JqZWN0OjpSZWZDb3VudGVkT2JqZWN0KToKKyAgICAg ICAgKFRlc3RXZWJLaXRBUEk6OmNyZWF0ZVJlZkNvdW50ZWRGb3JPZGQpOgorICAgICAgICAoV1RG X1ZlY3Rvci5GaWx0ZXJlZE1hcFN0YXRpY0Z1bmN0aW9uUmV0dXJuUmVmUHRyKToKKyAgICAgICAg KFRlc3RXZWJLaXRBUEk6OmNyZWF0ZVJlZkNvdW50ZWRGb3JFdmVuKToKKyAgICAgICAgKFdURl9W ZWN0b3IuRmlsdGVyZWRNYXBTdGF0aWNGdW5jdGlvblJldHVybk9wdGlvbmFsUmVmKToKKyAgICAg ICAgKFRlc3RXZWJLaXRBUEk6OmNyZWF0ZVJlZkNvdW50ZWRXaGVuRGl2aXNpYmxlQnlUaHJlZSk6 CisgICAgICAgIChXVEZfVmVjdG9yLkZpbHRlcmVkTWFwU3RhdGljRnVuY3Rpb25SZXR1cm5PcHRp b25hbFJlZlB0cik6CisgICAgICAgIChXVEZfVmVjdG9yLkZpbHRlcmVkTWFwTGFtYmRhUmV0dXJu T3B0aW9uYWwpOgorICAgICAgICAoV1RGX1ZlY3Rvci5GaWx0ZXJlZE1hcExhbWJkYVJldHVyblJl ZlB0cik6CisgICAgICAgIChXVEZfVmVjdG9yLkZpbHRlcmVkTWFwTGFtYmRhUmV0dXJuT3B0aW9u YWxSZWZQdHIpOgorCiAyMDIwLTA4LTI2ICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNs b3BlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdW1dQRV0gQWRkIGJvdHMgZm9yIGdlbmVy YXRpbmcgbmlnaHRseSBidW5kbGUgcGFja2FnZXMKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dU Ri9WZWN0b3IuY3BwCmluZGV4IDEwMzg0MzYyYjE4NGIyNTE4MjQ5NzE0NDU4YjdjNmVhOTgwY2Q1 YmMuLjU3NTczMGEzNWJhNDgxMjZmMmYzNmEwMjhhOGEyZGM3OTAzNjdjMWIgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAKKysrIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcApAQCAtODcxLDYgKzg3MSwxNDUgQEAgVEVT VChXVEZfVmVjdG9yLCBNYXBGcm9tSGFzaE1hcCkKIAogfQogCitXVEY6Ok9wdGlvbmFsPGludD4g ZXZlbk11bHRpcGxpZWRCeUZpdmUoaW50IGlucHV0KQoreworICAgIGlmIChpbnB1dCAlIDIpCisg ICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisgICAgcmV0dXJuIGlucHV0ICogNTsKK30KKwor VEVTVChXVEZfVmVjdG9yLCBGaWx0ZXJlZE1hcFN0YXRpY0Z1bmN0aW9uUmV0dXJuT3B0aW9uYWwp Cit7CisgICAgVmVjdG9yPGludD4gdmVjdG9yIHsgMSwgMiwgMywgNCB9OworCisgICAgYXV0byBt YXBwZWQgPSBXVEY6OmZpbHRlcmVkTWFwKHZlY3RvciwgZXZlbk11bHRpcGxpZWRCeUZpdmUpOwor CisgICAgRVhQRUNUX0VRKDJVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMTAsIG1h cHBlZFswXSk7CisgICAgRVhQRUNUX0VRKDIwLCBtYXBwZWRbMV0pOworfQorCitzdHJ1Y3QgUmVm Q291bnRlZE9iamVjdCA6IHB1YmxpYyBSZWZDb3VudGVkPFJlZkNvdW50ZWRPYmplY3Q+IHsKK3B1 YmxpYzoKKyAgICBzdGF0aWMgUmVmPFJlZkNvdW50ZWRPYmplY3Q+IGNyZWF0ZShpbnQgdmFsdWUp IHsgcmV0dXJuIGFkb3B0UmVmKCpuZXcgUmVmQ291bnRlZE9iamVjdCh2YWx1ZSkpOyB9CisKKyAg ICBpbnQgdmFsdWUgeyAwIH07CisKK3ByaXZhdGU6CisgICAgUmVmQ291bnRlZE9iamVjdChpbnQg dmFsdWUpCisgICAgICAgIDogdmFsdWUodmFsdWUpCisgICAgeyB9Cit9OworCitSZWZQdHI8UmVm Q291bnRlZE9iamVjdD4gY3JlYXRlUmVmQ291bnRlZEZvck9kZChpbnQgaW5wdXQpCit7CisgICAg aWYgKGlucHV0ICUgMikKKyAgICAgICAgcmV0dXJuIFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZShp bnB1dCk7CisgICAgcmV0dXJuIG51bGxwdHI7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgRmlsdGVy ZWRNYXBTdGF0aWNGdW5jdGlvblJldHVyblJlZlB0cikKK3sKKyAgICBWZWN0b3I8aW50PiB2ZWN0 b3IgeyAxLCAyLCAzLCA0IH07CisKKyAgICBWZWN0b3I8UmVmPFJlZkNvdW50ZWRPYmplY3Q+PiBt YXBwZWQgPSBXVEY6OmZpbHRlcmVkTWFwKHZlY3RvciwgY3JlYXRlUmVmQ291bnRlZEZvck9kZCk7 CisKKyAgICBFWFBFQ1RfRVEoMlUsIG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9FUSgxLCBt YXBwZWRbMF0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEoMywgbWFwcGVkWzFdLT52YWx1ZSk7Cit9 CisKK09wdGlvbmFsPFJlZjxSZWZDb3VudGVkT2JqZWN0Pj4gY3JlYXRlUmVmQ291bnRlZEZvckV2 ZW4oaW50IGlucHV0KQoreworICAgIGlmIChpbnB1dCAlIDIpCisgICAgICAgIHJldHVybiBXVEY6 Om51bGxvcHQ7CisgICAgcmV0dXJuIFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZShpbnB1dCk7Cit9 CisKK1RFU1QoV1RGX1ZlY3RvciwgRmlsdGVyZWRNYXBTdGF0aWNGdW5jdGlvblJldHVybk9wdGlv bmFsUmVmKQoreworICAgIFZlY3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQgfTsKKworICAg IFZlY3RvcjxSZWY8UmVmQ291bnRlZE9iamVjdD4+IG1hcHBlZCA9IFdURjo6ZmlsdGVyZWRNYXAo dmVjdG9yLCBjcmVhdGVSZWZDb3VudGVkRm9yRXZlbik7CisKKyAgICBFWFBFQ1RfRVEoMlUsIG1h cHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9FUSgyLCBtYXBwZWRbMF0tPnZhbHVlKTsKKyAgICBF WFBFQ1RfRVEoNCwgbWFwcGVkWzFdLT52YWx1ZSk7Cit9CisKK09wdGlvbmFsPFJlZlB0cjxSZWZD b3VudGVkT2JqZWN0Pj4gY3JlYXRlUmVmQ291bnRlZFdoZW5EaXZpc2libGVCeVRocmVlKGludCBp bnB1dCkKK3sKKyAgICBpZiAoaW5wdXQgJSAzKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0 OworICAgIGlmIChpbnB1dCAlIDIpCisgICAgICAgIHJldHVybiBSZWZQdHI8UmVmQ291bnRlZE9i amVjdD4oKTsKKyAgICByZXR1cm4gUmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+KFJlZkNvdW50ZWRP YmplY3Q6OmNyZWF0ZShpbnB1dCkpOworfQorCitURVNUKFdURl9WZWN0b3IsIEZpbHRlcmVkTWFw U3RhdGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbFJlZlB0cikKK3sKKyAgICBWZWN0b3I8aW50PiB2 ZWN0b3IgeyAxLCAyLCAzLCA0LCA1LCA2LCA3LCA4LCA5LCAxMCB9OworCisgICAgVmVjdG9yPFJl ZlB0cjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RGOjpmaWx0ZXJlZE1hcCh2ZWN0b3Is IGNyZWF0ZVJlZkNvdW50ZWRXaGVuRGl2aXNpYmxlQnlUaHJlZSk7CisKKyAgICBFWFBFQ1RfRVEo M1UsIG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9FUShudWxscHRyLCBtYXBwZWRbMF0pOwor ICAgIEVYUEVDVF9FUSg2LCBtYXBwZWRbMV0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEobnVsbHB0 ciwgbWFwcGVkWzJdKTsKK30KKworVEVTVChXVEZfVmVjdG9yLCBGaWx0ZXJlZE1hcExhbWJkYVJl dHVybk9wdGlvbmFsKQoreworICAgIFZlY3RvcjxTdHJpbmc+IHZlY3RvciB7ICJhIiwgImIiLCAi aGVsbG8iLCAiY2lhbyIsICJ3b3JsZCIsICJ3ZWJraXQiIH07CisKKyAgICBhdXRvIG1hcHBlZCA9 IFdURjo6ZmlsdGVyZWRNYXAodmVjdG9yLCBbJl0gKGNvbnN0IFN0cmluZyYgdmFsdWUpIC0+IE9w dGlvbmFsPFN0cmluZz4geworICAgICAgICBpZiAodmFsdWUubGVuZ3RoKCkgPCA1KQorICAgICAg ICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICAgICAgcmV0dXJuIHZhbHVlLmNvbnZlcnRU b0FTQ0lJVXBwZXJjYXNlKCk7CisgICAgfSk7CisKKyAgICBFWFBFQ1RfRVEoM1UsIG1hcHBlZC5z aXplKCkpOworICAgIEVYUEVDVF9TVFJFUSgiSEVMTE8iLCBtYXBwZWRbMF0uYXNjaWkoKS5kYXRh KCkpOworICAgIEVYUEVDVF9TVFJFUSgiV09STEQiLCBtYXBwZWRbMV0uYXNjaWkoKS5kYXRhKCkp OworICAgIEVYUEVDVF9TVFJFUSgiV0VCS0lUIiwgbWFwcGVkWzJdLmFzY2lpKCkuZGF0YSgpKTsK K30KKworVEVTVChXVEZfVmVjdG9yLCBGaWx0ZXJlZE1hcExhbWJkYVJldHVyblJlZlB0cikKK3sK KyAgICBWZWN0b3I8aW50PiB2ZWN0b3IgeyAxLCAyLCAzLCA0LCA1LCA2LCA3LCA4LCA5LCAxMCB9 OworCisgICAgVmVjdG9yPFJlZjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RGOjpmaWx0 ZXJlZE1hcCh2ZWN0b3IsIFsmXSAoaW50IHZhbHVlKSAtPiBSZWZQdHI8UmVmQ291bnRlZE9iamVj dD4geworICAgICAgICBpZiAodmFsdWUgJSAzKQorICAgICAgICAgICAgcmV0dXJuIG51bGxwdHI7 CisgICAgICAgIHJldHVybiBSZWZDb3VudGVkT2JqZWN0OjpjcmVhdGUodmFsdWUpOworICAgIH0p OworCisgICAgRVhQRUNUX0VRKDNVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMywg bWFwcGVkWzBdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKDYsIG1hcHBlZFsxXS0+dmFsdWUpOwor ICAgIEVYUEVDVF9FUSg5LCBtYXBwZWRbMl0tPnZhbHVlKTsKK30KKworVEVTVChXVEZfVmVjdG9y LCBGaWx0ZXJlZE1hcExhbWJkYVJldHVybk9wdGlvbmFsUmVmUHRyKQoreworICAgIFZlY3Rvcjxp bnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQsIDUsIDYsIDcsIDgsIDksIDEwIH07CisKKyAgICBWZWN0 b3I8UmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+PiBtYXBwZWQgPSBXVEY6OmZpbHRlcmVkTWFwKHZl Y3RvciwgWyZdIChpbnQgdmFsdWUpIC0+IE9wdGlvbmFsPFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0 Pj4geworICAgICAgICBpZiAoISh2YWx1ZSAlIDIpKQorICAgICAgICAgICAgcmV0dXJuIFdURjo6 bnVsbG9wdDsKKyAgICAgICAgaWYgKCEodmFsdWUgJSAzKSkKKyAgICAgICAgICAgIHJldHVybiBS ZWZQdHI8UmVmQ291bnRlZE9iamVjdD4oKTsKKyAgICAgICAgcmV0dXJuIFJlZlB0cjxSZWZDb3Vu dGVkT2JqZWN0PihSZWZDb3VudGVkT2JqZWN0OjpjcmVhdGUodmFsdWUpKTsKKyAgICB9KTsKKwor ICAgIEVYUEVDVF9FUSg1VSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNUX0VRKDEsIG1hcHBl ZFswXS0+dmFsdWUpOworICAgIEVYUEVDVF9FUShudWxscHRyLCBtYXBwZWRbMV0pOworICAgIEVY UEVDVF9FUSg1LCBtYXBwZWRbMl0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEoNywgbWFwcGVkWzNd LT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKG51bGxwdHIsIG1hcHBlZFs0XSk7Cit9CisKIFRFU1Qo V1RGX1ZlY3RvciwgQ29weVRvVmVjdG9yKQogewogICAgIEhhc2hTZXQ8aW50PiBpbnRTZXQgeyAx LCAyLCAzIH07Cg== 407450 2020-08-27 22:07:06 -0700 2020-08-31 19:06:34 -0700 Updated per review comments bug-215879-20200827220706.patch text/plain 11871 rniwa U3VidmVyc2lvbiBSZXZpc2lvbjogMjY2MjEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDE2YTJiNWFkN2I2MjgxYTdlNmI5NDJj NDcxNjFlMGM4Nzc3ZWNiN2EuLmIyYWNjMzQ4ZTBhNWUyYTlmMmU0ZWY5MmE5YWI3NTI3MmM1NGMw OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjAtMDgtMjYgIFJ5b3N1a2UgTml3YSAgPHJuaXdh QHdlYmtpdC5vcmc+CisKKyAgICAgICAgQWRkIGEgdmFyaWFudCBvZiBtYXAgd2hpY2ggZmlsdGVy cyBpdGVtcyB0byBWZWN0b3IuaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjE1ODc5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIFdURjo6Y29tcGFjdE1hcCwgd2hpY2ggY2FsbHMg YSBmdW5jdGlvbiBvbiBlYWNoIGl0ZW0gaW4gYW4gaXRlcmFibGUgb2JqZWN0IGxpa2UgV1RGOjpt YXAKKyAgICAgICAgYnV0IGFsc28gZmlsdGVycyB0aGUgcmV0dXJuZWQgdmFsdWUuIFRoZSBtYXBw ZWQgZnVuY3Rpb24gbWF5IHJldHVybiBPcHRpb25hbDxUPiBvciBSZWZQdHI8VD4uIFRoZSB2YWx1 ZQorICAgICAgICBpcyBrZXB0IGluIHRoZSByZXN1bHQgaWYgdGhlIHJldHVybmVkIHZhbHVlIGlz IG5vdCBXVEY6Om51bGxvcHQgaW4gdGhlIGNhc2Ugb2YgT3B0aW9uYWw8VD4gYW5kIG5vdCBudWxs CisgICAgICAgIGluIHRoZSBjYXNlIG9mIFJlZlB0cjxUPi4gVGhlIHJlc3VsdCB3aWxsIGJlIGVp dGhlciBWZWN0b3I8VD4gZm9yIE9wdGlvbmFsPFQ+IG9yIGVsc2UgVmVjdG9yPFJlZjxUPj4uCisK KyAgICAgICAgKiB3dGYvVmVjdG9yLmg6CisgICAgICAgIChXVEY6OkNvbXBhY3RNYXBUcmFpdHM6 KTogQWRkZWQuIFRyYWl0cyB0byBoYXZlIGEgZGlmZmVyZW50IGJlaGF2aW9yCisgICAgICAgIChX VEY6OkNvbXBhY3RNYXBUcmFpdHM8T3B0aW9uYWw8VD4+OjpoYXNWYWx1ZSk6IEFkZGVkLgorICAg ICAgICAoV1RGOjpDb21wYWN0TWFwVHJhaXRzPE9wdGlvbmFsPFQ+Pjo6ZXh0cmFjdFZhbHVlKTog QWRkZWQuCisgICAgICAgIChXVEY6OkNvbXBhY3RNYXBUcmFpdHM8UmVmUHRyPFQ+Pjo6aGFzVmFs dWUpOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29tcGFjdE1hcFRyYWl0czxSZWZQdHI8VD4+Ojpl eHRyYWN0VmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29tcGFjdE1hcCk6IEFkZGVkLiBU aGUgaGVscGVyIHRvIHVzZSBXVEZNb3ZlIG9uIHRoZSBhcmd1bWVudCB0byB0aGUgbWFwcGVkIGZ1 bmN0aW9uIGlmIHBvc3NpYmxlLgorICAgICAgICAoV1RGOjpjb21wYWN0TWFwKTogQWRkZWQuCisK IDIwMjAtMDgtMjUgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAg SGFzaE1hcDxSZWY8VD4+Ojp0YWtlIHNob3VsZCByZXR1cm4gUmVmUHRyPFQ+CmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaCBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCmluZGV4 IGY5OGY4NGU2MzhjZTIyODAzN2VmMjA0ZTg2ZWE3ODJiOWExNTM4YzkuLmI4ZmRhNGJjMjBhZDI1 MGE1YWRhZDI0ZWRmOTE5N2RiZGJmYjI0YjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1Zl Y3Rvci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCkBAIC0xNjgwLDYgKzE2ODAsNjkg QEAgVmVjdG9yPHR5cGVuYW1lIE1hcHBlcjxNYXBGdW5jdGlvbiwgU291cmNlVHlwZT46OkRlc3Rp bmF0aW9uSXRlbVR5cGU+IG1hcChTb3VyY2UKICAgICByZXR1cm4gTWFwcGVyPE1hcEZ1bmN0aW9u LCBTb3VyY2VUeXBlPjo6bWFwKHN0ZDo6Zm9yd2FyZDxTb3VyY2VUeXBlPihzb3VyY2UpLCBzdGQ6 OmZvcndhcmQ8TWFwRnVuY3Rpb24+KG1hcEZ1bmN0aW9uKSk7CiB9CiAKK3RlbXBsYXRlPHR5cGVu YW1lIE1hcEZ1bmN0aW9uUmV0dXJuVHlwZT4KK3N0cnVjdCBDb21wYWN0TWFwVHJhaXRzIHsKKyAg ICBzdGF0aWMgYm9vbCBoYXNWYWx1ZShjb25zdCBNYXBGdW5jdGlvblJldHVyblR5cGUmKTsKKyAg ICB0ZW1wbGF0ZTx0eXBlbmFtZSBJdGVtVHlwZT4KKyAgICBzdGF0aWMgSXRlbVR5cGUgZXh0cmFj dFZhbHVlKE1hcEZ1bmN0aW9uUmV0dXJuVHlwZSYpOworfTsKKwordGVtcGxhdGU8dHlwZW5hbWUg VD4KK3N0cnVjdCBDb21wYWN0TWFwVHJhaXRzPE9wdGlvbmFsPFQ+PiB7CisgICAgdXNpbmcgSXRl bVR5cGUgPSBUOworICAgIHN0YXRpYyBib29sIGhhc1ZhbHVlKGNvbnN0IE9wdGlvbmFsPFQ+JiBy ZXR1cm5WYWx1ZSkgeyByZXR1cm4gISFyZXR1cm5WYWx1ZTsgfQorICAgIHN0YXRpYyBJdGVtVHlw ZSBleHRyYWN0VmFsdWUoT3B0aW9uYWw8VD4mIHJldHVyblZhbHVlKSB7IHJldHVybiAqcmV0dXJu VmFsdWU7IH0KK307CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitzdHJ1Y3QgQ29tcGFjdE1hcFRy YWl0czxSZWZQdHI8VD4+IHsKKyAgICB1c2luZyBJdGVtVHlwZSA9IFJlZjxUPjsKKyAgICBzdGF0 aWMgYm9vbCBoYXNWYWx1ZShjb25zdCBSZWZQdHI8VD4mIHJldHVyblZhbHVlKSB7IHJldHVybiAh IXJldHVyblZhbHVlOyB9CisgICAgc3RhdGljIEl0ZW1UeXBlIGV4dHJhY3RWYWx1ZShSZWZQdHI8 VD4mIHJldHVyblZhbHVlKSB7IHJldHVybiByZXR1cm5WYWx1ZS5yZWxlYXNlTm9uTnVsbCgpOyB9 Cit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBNYXBGdW5jdGlvbiwgdHlwZW5hbWUgU291cmNlVHlw ZSwgdHlwZW5hbWUgRW5hYmxlID0gdm9pZD4KK3N0cnVjdCBDb21wYWN0TWFwcGVyIHsKKyAgICB1 c2luZyBTb3VyY2VJdGVtVHlwZSA9IHR5cGVuYW1lIENvbGxlY3Rpb25JbnNwZWN0b3I8U291cmNl VHlwZT46OlNvdXJjZUl0ZW1UeXBlOworICAgIHVzaW5nIFJlc3VsdEl0ZW1UeXBlID0gdHlwZW5h bWUgc3RkOjpyZXN1bHRfb2Y8TWFwRnVuY3Rpb24oU291cmNlSXRlbVR5cGUmKT46OnR5cGU7Cisg ICAgdXNpbmcgRGVzdGluYXRpb25JdGVtVHlwZSA9IHR5cGVuYW1lIENvbXBhY3RNYXBUcmFpdHM8 UmVzdWx0SXRlbVR5cGU+OjpJdGVtVHlwZTsKKworICAgIHN0YXRpYyBWZWN0b3I8RGVzdGluYXRp b25JdGVtVHlwZT4gbWFwKFNvdXJjZVR5cGUgc291cmNlLCBjb25zdCBNYXBGdW5jdGlvbiYgbWFw RnVuY3Rpb24pCisgICAgeworICAgICAgICBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gcmVz dWx0OworICAgICAgICBmb3IgKGF1dG8mIGl0ZW0gOiBzb3VyY2UpIHsKKyAgICAgICAgICAgIGF1 dG8gaXRlbVJlc3VsdCA9IG1hcEZ1bmN0aW9uKGl0ZW0pOworICAgICAgICAgICAgaWYgKENvbXBh Y3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+OjpoYXNWYWx1ZShpdGVtUmVzdWx0KSkKKyAgICAg ICAgICAgICAgICByZXN1bHQuYXBwZW5kKENvbXBhY3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+ OjpleHRyYWN0VmFsdWUoaXRlbVJlc3VsdCkpOworICAgICAgICB9CisgICAgICAgIHJldHVybiBy ZXN1bHQ7CisgICAgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgTWFwRnVuY3Rpb24sIHR5cGVu YW1lIFNvdXJjZVR5cGU+CitzdHJ1Y3QgQ29tcGFjdE1hcHBlcjxNYXBGdW5jdGlvbiwgU291cmNl VHlwZSwgdHlwZW5hbWUgc3RkOjplbmFibGVfaWY8c3RkOjppc19ydmFsdWVfcmVmZXJlbmNlPFNv dXJjZVR5cGUmJj46OnZhbHVlPjo6dHlwZT4geworICAgIHVzaW5nIFNvdXJjZUl0ZW1UeXBlID0g dHlwZW5hbWUgQ29sbGVjdGlvbkluc3BlY3RvcjxTb3VyY2VUeXBlPjo6U291cmNlSXRlbVR5cGU7 CisgICAgdXNpbmcgUmVzdWx0SXRlbVR5cGUgPSB0eXBlbmFtZSBzdGQ6OnJlc3VsdF9vZjxNYXBG dW5jdGlvbihTb3VyY2VJdGVtVHlwZSYmKT46OnR5cGU7CisgICAgdXNpbmcgRGVzdGluYXRpb25J dGVtVHlwZSA9IHR5cGVuYW1lIENvbXBhY3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+OjpJdGVt VHlwZTsKKworICAgIHN0YXRpYyBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gbWFwKFNvdXJj ZVR5cGUgc291cmNlLCBjb25zdCBNYXBGdW5jdGlvbiYgbWFwRnVuY3Rpb24pCisgICAgeworICAg ICAgICBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gcmVzdWx0OworICAgICAgICBmb3IgKGF1 dG8mIGl0ZW0gOiBzb3VyY2UpIHsKKyAgICAgICAgICAgIGF1dG8gaXRlbVJlc3VsdCA9IG1hcEZ1 bmN0aW9uKFdURk1vdmUoaXRlbSkpOworICAgICAgICAgICAgaWYgKENvbXBhY3RNYXBUcmFpdHM8 UmVzdWx0SXRlbVR5cGU+OjpoYXNWYWx1ZShpdGVtUmVzdWx0KSkKKyAgICAgICAgICAgICAgICBy ZXN1bHQuYXBwZW5kKENvbXBhY3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+OjpleHRyYWN0VmFs dWUoaXRlbVJlc3VsdCkpOworICAgICAgICB9CisgICAgICAgIHJldHVybiByZXN1bHQ7CisgICAg fQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgTWFwRnVuY3Rpb24sIHR5cGVuYW1lIFNvdXJjZVR5 cGU+CitWZWN0b3I8dHlwZW5hbWUgQ29tcGFjdE1hcHBlcjxNYXBGdW5jdGlvbiwgU291cmNlVHlw ZT46OkRlc3RpbmF0aW9uSXRlbVR5cGU+IGNvbXBhY3RNYXAoU291cmNlVHlwZSYmIHNvdXJjZSwg TWFwRnVuY3Rpb24mJiBtYXBGdW5jdGlvbikKK3sKKyAgICByZXR1cm4gQ29tcGFjdE1hcHBlcjxN YXBGdW5jdGlvbiwgU291cmNlVHlwZT46Om1hcChzdGQ6OmZvcndhcmQ8U291cmNlVHlwZT4oc291 cmNlKSwgc3RkOjpmb3J3YXJkPE1hcEZ1bmN0aW9uPihtYXBGdW5jdGlvbikpOworfQorCiB0ZW1w bGF0ZTx0eXBlbmFtZSBEZXN0aW5hdGlvblZlY3RvciwgdHlwZW5hbWUgQ29sbGVjdGlvbj4KIGlu bGluZSBhdXRvIGNvcHlUb1ZlY3RvclNwZWNpYWxpemF0aW9uKGNvbnN0IENvbGxlY3Rpb24mIGNv bGxlY3Rpb24pIC0+IERlc3RpbmF0aW9uVmVjdG9yCiB7CkBAIC0xNzE1LDQgKzE3NzgsNSBAQCB1 c2luZyBXVEY6OlZlY3RvcjsKIHVzaW5nIFdURjo6Y29weVRvVmVjdG9yOwogdXNpbmcgV1RGOjpj b3B5VG9WZWN0b3JPZjsKIHVzaW5nIFdURjo6Y29weVRvVmVjdG9yU3BlY2lhbGl6YXRpb247Cit1 c2luZyBXVEY6OmNvbXBhY3RNYXA7CiB1c2luZyBXVEY6OnJlbW92ZVJlcGVhdGVkRWxlbWVudHM7 CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMzc2 YjI1NTU0ZWYyMTAxMzU0OTI4NTEwZmEyOTJhNTFmYzZjNTUxNy4uOWFmYmM5YzU5YTk4MTNkNTM5 ZWNmZDFhOTcyM2Y5YjJmZTQyY2ViNyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBi L1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIwLTA4LTI2ICBSeW9zdWtlIE5p d2EgIDxybml3YUB3ZWJraXQub3JnPgorCisgICAgICAgIEFkZCBhIHZhcmlhbnQgb2YgbWFwIHdo aWNoIGZpbHRlcnMgaXRlbXMgdG8gVmVjdG9yLmgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNTg3OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHVuaXQgdGVzdHMuCisKKyAgICAgICAgKiBUZXN0 V2ViS2l0QVBJL1Rlc3RzL1dURi9WZWN0b3IuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6 ZXZlbk11bHRpcGxpZWRCeUZpdmUpOgorICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFwU3Rh dGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpSZWZD b3VudGVkT2JqZWN0OjpjcmVhdGUpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6UmVmQ291bnRl ZE9iamVjdDo6UmVmQ291bnRlZE9iamVjdCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpjcmVh dGVSZWZDb3VudGVkRm9yT2RkKToKKyAgICAgICAgKFdURl9WZWN0b3IuQ29tcGFjdE1hcFN0YXRp Y0Z1bmN0aW9uUmV0dXJuUmVmUHRyKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OmNyZWF0ZVJl ZkNvdW50ZWRGb3JFdmVuKToKKyAgICAgICAgKFdURl9WZWN0b3IuQ29tcGFjdE1hcFN0YXRpY0Z1 bmN0aW9uUmV0dXJuT3B0aW9uYWxSZWYpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6Y3JlYXRl UmVmQ291bnRlZFdoZW5EaXZpc2libGVCeVRocmVlKToKKyAgICAgICAgKFdURl9WZWN0b3IuQ29t cGFjdE1hcFN0YXRpY0Z1bmN0aW9uUmV0dXJuT3B0aW9uYWxSZWZQdHIpOgorICAgICAgICAoV1RG X1ZlY3Rvci5Db21wYWN0TWFwTGFtYmRhUmV0dXJuT3B0aW9uYWwpOgorICAgICAgICAoV1RGX1Zl Y3Rvci5Db21wYWN0TWFwTGFtYmRhUmV0dXJuUmVmUHRyKToKKyAgICAgICAgKFdURl9WZWN0b3Iu Q29tcGFjdE1hcExhbWJkYVJldHVybk9wdGlvbmFsUmVmUHRyKToKKwogMjAyMC0wOC0yNiAgQ2Fy bG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBb R1RLXVtXUEVdIEFkZCBib3RzIGZvciBnZW5lcmF0aW5nIG5pZ2h0bHkgYnVuZGxlIHBhY2thZ2Vz CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9WZWN0b3IuY3BwIGIv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcAppbmRleCAxMDM4NDM2MmIx ODRiMjUxODI0OTcxNDQ1OGI3YzZlYTk4MGNkNWJjLi5iZTk2ZDlmYmZhMjg4ZWZhODgxY2JiZDYw ODQyMDk4ZGRlNmVhODAwIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dU Ri9WZWN0b3IuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5j cHAKQEAgLTg3MSw2ICs4NzEsMTgyIEBAIFRFU1QoV1RGX1ZlY3RvciwgTWFwRnJvbUhhc2hNYXAp CiAKIH0KIAorV1RGOjpPcHRpb25hbDxpbnQ+IGV2ZW5NdWx0aXBsaWVkQnlGaXZlKGludCBpbnB1 dCkKK3sKKyAgICBpZiAoaW5wdXQgJSAyKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0Owor ICAgIHJldHVybiBpbnB1dCAqIDU7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgQ29tcGFjdE1hcFN0 YXRpY0Z1bmN0aW9uUmV0dXJuT3B0aW9uYWwpCit7CisgICAgVmVjdG9yPGludD4gdmVjdG9yIHsg MSwgMiwgMywgNCB9OworCisgICAgYXV0byBtYXBwZWQgPSBXVEY6OmNvbXBhY3RNYXAodmVjdG9y LCBldmVuTXVsdGlwbGllZEJ5Rml2ZSk7CisKKyAgICBFWFBFQ1RfRVEoMlUsIG1hcHBlZC5zaXpl KCkpOworICAgIEVYUEVDVF9FUSgxMCwgbWFwcGVkWzBdKTsKKyAgICBFWFBFQ1RfRVEoMjAsIG1h cHBlZFsxXSk7Cit9CisKK3N0cnVjdCBSZWZDb3VudGVkT2JqZWN0IDogcHVibGljIFJlZkNvdW50 ZWQ8UmVmQ291bnRlZE9iamVjdD4geworcHVibGljOgorICAgIHN0YXRpYyBSZWY8UmVmQ291bnRl ZE9iamVjdD4gY3JlYXRlKGludCB2YWx1ZSkgeyByZXR1cm4gYWRvcHRSZWYoKm5ldyBSZWZDb3Vu dGVkT2JqZWN0KHZhbHVlKSk7IH0KKworICAgIGludCB2YWx1ZSB7IDAgfTsKKworcHJpdmF0ZToK KyAgICBSZWZDb3VudGVkT2JqZWN0KGludCB2YWx1ZSkKKyAgICAgICAgOiB2YWx1ZSh2YWx1ZSkK KyAgICB7IH0KK307CisKK1JlZlB0cjxSZWZDb3VudGVkT2JqZWN0PiBjcmVhdGVSZWZDb3VudGVk Rm9yT2RkKGludCBpbnB1dCkKK3sKKyAgICBpZiAoaW5wdXQgJSAyKQorICAgICAgICByZXR1cm4g UmVmQ291bnRlZE9iamVjdDo6Y3JlYXRlKGlucHV0KTsKKyAgICByZXR1cm4gbnVsbHB0cjsKK30K KworVEVTVChXVEZfVmVjdG9yLCBDb21wYWN0TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5SZWZQdHIp Cit7CisgICAgVmVjdG9yPGludD4gdmVjdG9yIHsgMSwgMiwgMywgNCB9OworCisgICAgVmVjdG9y PFJlZjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RGOjpjb21wYWN0TWFwKHZlY3Rvciwg Y3JlYXRlUmVmQ291bnRlZEZvck9kZCk7CisKKyAgICBFWFBFQ1RfRVEoMlUsIG1hcHBlZC5zaXpl KCkpOworICAgIEVYUEVDVF9FUSgxLCBtYXBwZWRbMF0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEo MywgbWFwcGVkWzFdLT52YWx1ZSk7Cit9CisKK09wdGlvbmFsPFJlZjxSZWZDb3VudGVkT2JqZWN0 Pj4gY3JlYXRlUmVmQ291bnRlZEZvckV2ZW4oaW50IGlucHV0KQoreworICAgIGlmIChpbnB1dCAl IDIpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisgICAgcmV0dXJuIFJlZkNvdW50ZWRP YmplY3Q6OmNyZWF0ZShpbnB1dCk7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgQ29tcGFjdE1hcFN0 YXRpY0Z1bmN0aW9uUmV0dXJuT3B0aW9uYWxSZWYpCit7CisgICAgVmVjdG9yPGludD4gdmVjdG9y IHsgMSwgMiwgMywgNCB9OworCisgICAgVmVjdG9yPFJlZjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFw cGVkID0gV1RGOjpjb21wYWN0TWFwKHZlY3RvciwgY3JlYXRlUmVmQ291bnRlZEZvckV2ZW4pOwor CisgICAgRVhQRUNUX0VRKDJVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMiwgbWFw cGVkWzBdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKDQsIG1hcHBlZFsxXS0+dmFsdWUpOworfQor CitPcHRpb25hbDxSZWZQdHI8UmVmQ291bnRlZE9iamVjdD4+IGNyZWF0ZVJlZkNvdW50ZWRXaGVu RGl2aXNpYmxlQnlUaHJlZShpbnQgaW5wdXQpCit7CisgICAgaWYgKGlucHV0ICUgMykKKyAgICAg ICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICBpZiAoaW5wdXQgJSAyKQorICAgICAgICByZXR1 cm4gUmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+KCk7CisgICAgcmV0dXJuIFJlZlB0cjxSZWZDb3Vu dGVkT2JqZWN0PihSZWZDb3VudGVkT2JqZWN0OjpjcmVhdGUoaW5wdXQpKTsKK30KKworVEVTVChX VEZfVmVjdG9yLCBDb21wYWN0TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbFJlZlB0cikK K3sKKyAgICBWZWN0b3I8aW50PiB2ZWN0b3IgeyAxLCAyLCAzLCA0LCA1LCA2LCA3LCA4LCA5LCAx MCB9OworCisgICAgVmVjdG9yPFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RG Ojpjb21wYWN0TWFwKHZlY3RvciwgY3JlYXRlUmVmQ291bnRlZFdoZW5EaXZpc2libGVCeVRocmVl KTsKKworICAgIEVYUEVDVF9FUSgzVSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNUX0VRKG51 bGxwdHIsIG1hcHBlZFswXSk7CisgICAgRVhQRUNUX0VRKDYsIG1hcHBlZFsxXS0+dmFsdWUpOwor ICAgIEVYUEVDVF9FUShudWxscHRyLCBtYXBwZWRbMl0pOworfQorCitURVNUKFdURl9WZWN0b3Is IENvbXBhY3RNYXBMYW1iZGFSZXR1cm5PcHRpb25hbCkKK3sKKyAgICBWZWN0b3I8U3RyaW5nPiB2 ZWN0b3IgeyAiYSIsICJiIiwgImhlbGxvIiwgImNpYW8iLCAid29ybGQiLCAid2Via2l0IiB9Owor CisgICAgYXV0byBtYXBwZWQgPSBXVEY6OmNvbXBhY3RNYXAodmVjdG9yLCBbJl0gKGNvbnN0IFN0 cmluZyYgdmFsdWUpIC0+IE9wdGlvbmFsPFN0cmluZz4geworICAgICAgICBpZiAodmFsdWUubGVu Z3RoKCkgPCA1KQorICAgICAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICAgICAgcmV0 dXJuIHZhbHVlLmNvbnZlcnRUb0FTQ0lJVXBwZXJjYXNlKCk7CisgICAgfSk7CisKKyAgICBFWFBF Q1RfRVEoM1UsIG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9TVFJFUSgiSEVMTE8iLCBtYXBw ZWRbMF0uYXNjaWkoKS5kYXRhKCkpOworICAgIEVYUEVDVF9TVFJFUSgiV09STEQiLCBtYXBwZWRb MV0uYXNjaWkoKS5kYXRhKCkpOworICAgIEVYUEVDVF9TVFJFUSgiV0VCS0lUIiwgbWFwcGVkWzJd LmFzY2lpKCkuZGF0YSgpKTsKK30KKworY2xhc3MgQ291bnRlZE9iamVjdCB7CitwdWJsaWM6Cisg ICAgQ291bnRlZE9iamVjdChpbnQgdmFsdWUpCisgICAgICAgIDogbV92YWx1ZSh2YWx1ZSkKKyAg ICB7ICsrc19jb3VudDsgfQorCisgICAgaW50IHZhbHVlKCkgeyByZXR1cm4gbV92YWx1ZTsgfQor CisgICAgc3RhdGljIHVuc2lnbmVkIGNvdW50KCkgeyByZXR1cm4gc19jb3VudDsgfQorCitwcml2 YXRlOgorICAgIGludCBtX3ZhbHVlOworCisgICAgc3RhdGljIHVuc2lnbmVkIHNfY291bnQ7Cit9 OworCit1bnNpZ25lZCBDb3VudGVkT2JqZWN0OjpzX2NvdW50ID0gMDsKKworVEVTVChXVEZfVmVj dG9yLCBDb21wYWN0TWFwTGFtYmRhUmV0dXJuT3B0aW9uYWxDb3VudGVkT2JqZWN0KQoreworICAg IFZlY3RvcjxDb3VudGVkT2JqZWN0PiB2ZWN0b3IgeyBDb3VudGVkT2JqZWN0KDEpLCBDb3VudGVk T2JqZWN0KDIpLCBDb3VudGVkT2JqZWN0KDMpLCBDb3VudGVkT2JqZWN0KDQpIH07CisKKyAgICBF WFBFQ1RfRVEoNFUsIENvdW50ZWRPYmplY3Q6OmNvdW50KCkpOworCisgICAgYXV0byBtYXBwZWQg PSBXVEY6OmNvbXBhY3RNYXAoV1RGTW92ZSh2ZWN0b3IpLCBbXSAoQ291bnRlZE9iamVjdCYmIG9i amVjdCkgLT4gT3B0aW9uYWw8Q291bnRlZE9iamVjdD4geworICAgICAgICBpZiAob2JqZWN0LnZh bHVlKCkgJSAyKQorICAgICAgICAgICAgcmV0dXJuIG9iamVjdDsKKyAgICAgICAgcmV0dXJuIFdU Rjo6bnVsbG9wdDsKKyAgICB9KTsKKworICAgIEVYUEVDVF9FUSg0VSwgQ291bnRlZE9iamVjdDo6 Y291bnQoKSk7CisKKyAgICBFWFBFQ1RfRVEoMlUsIG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVD VF9FUSgxLCBtYXBwZWRbMF0udmFsdWUoKSk7CisgICAgRVhQRUNUX0VRKDMsIG1hcHBlZFsxXS52 YWx1ZSgpKTsKK30KKworVEVTVChXVEZfVmVjdG9yLCBDb21wYWN0TWFwTGFtYmRhUmV0dXJuUmVm UHRyKQoreworICAgIFZlY3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQsIDUsIDYsIDcsIDgs IDksIDEwIH07CisKKyAgICBWZWN0b3I8UmVmPFJlZkNvdW50ZWRPYmplY3Q+PiBtYXBwZWQgPSBX VEY6OmNvbXBhY3RNYXAodmVjdG9yLCBbJl0gKGludCB2YWx1ZSkgLT4gUmVmUHRyPFJlZkNvdW50 ZWRPYmplY3Q+IHsKKyAgICAgICAgaWYgKHZhbHVlICUgMykKKyAgICAgICAgICAgIHJldHVybiBu dWxscHRyOworICAgICAgICByZXR1cm4gUmVmQ291bnRlZE9iamVjdDo6Y3JlYXRlKHZhbHVlKTsK KyAgICB9KTsKKworICAgIEVYUEVDVF9FUSgzVSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNU X0VRKDMsIG1hcHBlZFswXS0+dmFsdWUpOworICAgIEVYUEVDVF9FUSg2LCBtYXBwZWRbMV0tPnZh bHVlKTsKKyAgICBFWFBFQ1RfRVEoOSwgbWFwcGVkWzJdLT52YWx1ZSk7Cit9CisKK1RFU1QoV1RG X1ZlY3RvciwgQ29tcGFjdE1hcExhbWJkYVJldHVybk9wdGlvbmFsUmVmUHRyKQoreworICAgIFZl Y3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQsIDUsIDYsIDcsIDgsIDksIDEwIH07CisKKyAg ICBWZWN0b3I8UmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+PiBtYXBwZWQgPSBXVEY6OmNvbXBhY3RN YXAodmVjdG9yLCBbJl0gKGludCB2YWx1ZSkgLT4gT3B0aW9uYWw8UmVmUHRyPFJlZkNvdW50ZWRP YmplY3Q+PiB7CisgICAgICAgIGlmICghKHZhbHVlICUgMikpCisgICAgICAgICAgICByZXR1cm4g V1RGOjpudWxsb3B0OworICAgICAgICBpZiAoISh2YWx1ZSAlIDMpKQorICAgICAgICAgICAgcmV0 dXJuIFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0PigpOworICAgICAgICByZXR1cm4gUmVmUHRyPFJl ZkNvdW50ZWRPYmplY3Q+KFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZSh2YWx1ZSkpOworICAgIH0p OworCisgICAgRVhQRUNUX0VRKDVVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMSwg bWFwcGVkWzBdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKG51bGxwdHIsIG1hcHBlZFsxXSk7Cisg ICAgRVhQRUNUX0VRKDUsIG1hcHBlZFsyXS0+dmFsdWUpOworICAgIEVYUEVDVF9FUSg3LCBtYXBw ZWRbM10tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEobnVsbHB0ciwgbWFwcGVkWzRdKTsKK30KKwog VEVTVChXVEZfVmVjdG9yLCBDb3B5VG9WZWN0b3IpCiB7CiAgICAgSGFzaFNldDxpbnQ+IGludFNl dCB7IDEsIDIsIDMgfTsK 407649 2020-08-31 19:06:36 -0700 2020-09-02 12:04:27 -0700 Updated patch bug-215879-20200831190637.patch text/plain 14725 rniwa U3VidmVyc2lvbiBSZXZpc2lvbjogMjY2MjEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDE2YTJiNWFkN2I2MjgxYTdlNmI5NDJj NDcxNjFlMGM4Nzc3ZWNiN2EuLmIyYWNjMzQ4ZTBhNWUyYTlmMmU0ZWY5MmE5YWI3NTI3MmM1NGMw OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjAtMDgtMjYgIFJ5b3N1a2UgTml3YSAgPHJuaXdh QHdlYmtpdC5vcmc+CisKKyAgICAgICAgQWRkIGEgdmFyaWFudCBvZiBtYXAgd2hpY2ggZmlsdGVy cyBpdGVtcyB0byBWZWN0b3IuaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjE1ODc5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIFdURjo6Y29tcGFjdE1hcCwgd2hpY2ggY2FsbHMg YSBmdW5jdGlvbiBvbiBlYWNoIGl0ZW0gaW4gYW4gaXRlcmFibGUgb2JqZWN0IGxpa2UgV1RGOjpt YXAKKyAgICAgICAgYnV0IGFsc28gZmlsdGVycyB0aGUgcmV0dXJuZWQgdmFsdWUuIFRoZSBtYXBw ZWQgZnVuY3Rpb24gbWF5IHJldHVybiBPcHRpb25hbDxUPiBvciBSZWZQdHI8VD4uIFRoZSB2YWx1 ZQorICAgICAgICBpcyBrZXB0IGluIHRoZSByZXN1bHQgaWYgdGhlIHJldHVybmVkIHZhbHVlIGlz IG5vdCBXVEY6Om51bGxvcHQgaW4gdGhlIGNhc2Ugb2YgT3B0aW9uYWw8VD4gYW5kIG5vdCBudWxs CisgICAgICAgIGluIHRoZSBjYXNlIG9mIFJlZlB0cjxUPi4gVGhlIHJlc3VsdCB3aWxsIGJlIGVp dGhlciBWZWN0b3I8VD4gZm9yIE9wdGlvbmFsPFQ+IG9yIGVsc2UgVmVjdG9yPFJlZjxUPj4uCisK KyAgICAgICAgKiB3dGYvVmVjdG9yLmg6CisgICAgICAgIChXVEY6OkNvbXBhY3RNYXBUcmFpdHM6 KTogQWRkZWQuIFRyYWl0cyB0byBoYXZlIGEgZGlmZmVyZW50IGJlaGF2aW9yCisgICAgICAgIChX VEY6OkNvbXBhY3RNYXBUcmFpdHM8T3B0aW9uYWw8VD4+OjpoYXNWYWx1ZSk6IEFkZGVkLgorICAg ICAgICAoV1RGOjpDb21wYWN0TWFwVHJhaXRzPE9wdGlvbmFsPFQ+Pjo6ZXh0cmFjdFZhbHVlKTog QWRkZWQuCisgICAgICAgIChXVEY6OkNvbXBhY3RNYXBUcmFpdHM8UmVmUHRyPFQ+Pjo6aGFzVmFs dWUpOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29tcGFjdE1hcFRyYWl0czxSZWZQdHI8VD4+Ojpl eHRyYWN0VmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29tcGFjdE1hcCk6IEFkZGVkLiBU aGUgaGVscGVyIHRvIHVzZSBXVEZNb3ZlIG9uIHRoZSBhcmd1bWVudCB0byB0aGUgbWFwcGVkIGZ1 bmN0aW9uIGlmIHBvc3NpYmxlLgorICAgICAgICAoV1RGOjpjb21wYWN0TWFwKTogQWRkZWQuCisK IDIwMjAtMDgtMjUgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAg SGFzaE1hcDxSZWY8VD4+Ojp0YWtlIHNob3VsZCByZXR1cm4gUmVmUHRyPFQ+CmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaCBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCmluZGV4 IGY5OGY4NGU2MzhjZTIyODAzN2VmMjA0ZTg2ZWE3ODJiOWExNTM4YzkuLmM2YWRjYzk4ZGY0MDNl M2Q1NTYyY2RhMTM2M2YzOTMzOWM2YzJkNGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1Zl Y3Rvci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCkBAIC0xNjgwLDYgKzE2ODAsNzEg QEAgVmVjdG9yPHR5cGVuYW1lIE1hcHBlcjxNYXBGdW5jdGlvbiwgU291cmNlVHlwZT46OkRlc3Rp bmF0aW9uSXRlbVR5cGU+IG1hcChTb3VyY2UKICAgICByZXR1cm4gTWFwcGVyPE1hcEZ1bmN0aW9u LCBTb3VyY2VUeXBlPjo6bWFwKHN0ZDo6Zm9yd2FyZDxTb3VyY2VUeXBlPihzb3VyY2UpLCBzdGQ6 OmZvcndhcmQ8TWFwRnVuY3Rpb24+KG1hcEZ1bmN0aW9uKSk7CiB9CiAKK3RlbXBsYXRlPHR5cGVu YW1lIE1hcEZ1bmN0aW9uUmV0dXJuVHlwZT4KK3N0cnVjdCBDb21wYWN0TWFwVHJhaXRzIHsKKyAg ICBzdGF0aWMgYm9vbCBoYXNWYWx1ZShjb25zdCBNYXBGdW5jdGlvblJldHVyblR5cGUmKTsKKyAg ICB0ZW1wbGF0ZTx0eXBlbmFtZSBJdGVtVHlwZT4KKyAgICBzdGF0aWMgSXRlbVR5cGUgZXh0cmFj dFZhbHVlKE1hcEZ1bmN0aW9uUmV0dXJuVHlwZSYmKTsKK307CisKK3RlbXBsYXRlPHR5cGVuYW1l IFQ+CitzdHJ1Y3QgQ29tcGFjdE1hcFRyYWl0czxPcHRpb25hbDxUPj4geworICAgIHVzaW5nIEl0 ZW1UeXBlID0gVDsKKyAgICBzdGF0aWMgYm9vbCBoYXNWYWx1ZShjb25zdCBPcHRpb25hbDxUPiYg cmV0dXJuVmFsdWUpIHsgcmV0dXJuICEhcmV0dXJuVmFsdWU7IH0KKyAgICBzdGF0aWMgSXRlbVR5 cGUgZXh0cmFjdFZhbHVlKE9wdGlvbmFsPFQ+JiYgcmV0dXJuVmFsdWUpIHsgcmV0dXJuIFdURk1v dmUoKnJldHVyblZhbHVlKTsgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK3N0cnVjdCBD b21wYWN0TWFwVHJhaXRzPFJlZlB0cjxUPj4geworICAgIHVzaW5nIEl0ZW1UeXBlID0gUmVmPFQ+ OworICAgIHN0YXRpYyBib29sIGhhc1ZhbHVlKGNvbnN0IFJlZlB0cjxUPiYgcmV0dXJuVmFsdWUp IHsgcmV0dXJuICEhcmV0dXJuVmFsdWU7IH0KKyAgICBzdGF0aWMgSXRlbVR5cGUgZXh0cmFjdFZh bHVlKFJlZlB0cjxUPiYmIHJldHVyblZhbHVlKSB7IHJldHVybiByZXR1cm5WYWx1ZS5yZWxlYXNl Tm9uTnVsbCgpOyB9Cit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBNYXBGdW5jdGlvbiwgdHlwZW5h bWUgU291cmNlVHlwZSwgdHlwZW5hbWUgRW5hYmxlID0gdm9pZD4KK3N0cnVjdCBDb21wYWN0TWFw cGVyIHsKKyAgICB1c2luZyBTb3VyY2VJdGVtVHlwZSA9IHR5cGVuYW1lIENvbGxlY3Rpb25JbnNw ZWN0b3I8U291cmNlVHlwZT46OlNvdXJjZUl0ZW1UeXBlOworICAgIHVzaW5nIFJlc3VsdEl0ZW1U eXBlID0gdHlwZW5hbWUgc3RkOjpyZXN1bHRfb2Y8TWFwRnVuY3Rpb24oU291cmNlSXRlbVR5cGUm KT46OnR5cGU7CisgICAgdXNpbmcgRGVzdGluYXRpb25JdGVtVHlwZSA9IHR5cGVuYW1lIENvbXBh Y3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+OjpJdGVtVHlwZTsKKworICAgIHN0YXRpYyBWZWN0 b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gY29tcGFjdE1hcChTb3VyY2VUeXBlIHNvdXJjZSwgY29u c3QgTWFwRnVuY3Rpb24mIG1hcEZ1bmN0aW9uKQorICAgIHsKKyAgICAgICAgVmVjdG9yPERlc3Rp bmF0aW9uSXRlbVR5cGU+IHJlc3VsdDsKKyAgICAgICAgZm9yIChhdXRvJiBpdGVtIDogc291cmNl KSB7CisgICAgICAgICAgICBhdXRvIGl0ZW1SZXN1bHQgPSBtYXBGdW5jdGlvbihpdGVtKTsKKyAg ICAgICAgICAgIGlmIChDb21wYWN0TWFwVHJhaXRzPFJlc3VsdEl0ZW1UeXBlPjo6aGFzVmFsdWUo aXRlbVJlc3VsdCkpCisgICAgICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChDb21wYWN0TWFwVHJh aXRzPFJlc3VsdEl0ZW1UeXBlPjo6ZXh0cmFjdFZhbHVlKFdURk1vdmUoaXRlbVJlc3VsdCkpKTsK KyAgICAgICAgfQorICAgICAgICByZXN1bHQuc2hyaW5rVG9GaXQoKTsKKyAgICAgICAgcmV0dXJu IHJlc3VsdDsKKyAgICB9Cit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBNYXBGdW5jdGlvbiwgdHlw ZW5hbWUgU291cmNlVHlwZT4KK3N0cnVjdCBDb21wYWN0TWFwcGVyPE1hcEZ1bmN0aW9uLCBTb3Vy Y2VUeXBlLCB0eXBlbmFtZSBzdGQ6OmVuYWJsZV9pZjxzdGQ6OmlzX3J2YWx1ZV9yZWZlcmVuY2U8 U291cmNlVHlwZSYmPjo6dmFsdWU+Ojp0eXBlPiB7CisgICAgdXNpbmcgU291cmNlSXRlbVR5cGUg PSB0eXBlbmFtZSBDb2xsZWN0aW9uSW5zcGVjdG9yPFNvdXJjZVR5cGU+OjpTb3VyY2VJdGVtVHlw ZTsKKyAgICB1c2luZyBSZXN1bHRJdGVtVHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVzdWx0X29mPE1h cEZ1bmN0aW9uKFNvdXJjZUl0ZW1UeXBlJiYpPjo6dHlwZTsKKyAgICB1c2luZyBEZXN0aW5hdGlv bkl0ZW1UeXBlID0gdHlwZW5hbWUgQ29tcGFjdE1hcFRyYWl0czxSZXN1bHRJdGVtVHlwZT46Okl0 ZW1UeXBlOworCisgICAgc3RhdGljIFZlY3RvcjxEZXN0aW5hdGlvbkl0ZW1UeXBlPiBjb21wYWN0 TWFwKFNvdXJjZVR5cGUgc291cmNlLCBjb25zdCBNYXBGdW5jdGlvbiYgbWFwRnVuY3Rpb24pCisg ICAgeworICAgICAgICBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gcmVzdWx0OworICAgICAg ICBmb3IgKGF1dG8mIGl0ZW0gOiBzb3VyY2UpIHsKKyAgICAgICAgICAgIGF1dG8gaXRlbVJlc3Vs dCA9IG1hcEZ1bmN0aW9uKFdURk1vdmUoaXRlbSkpOworICAgICAgICAgICAgaWYgKENvbXBhY3RN YXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+OjpoYXNWYWx1ZShpdGVtUmVzdWx0KSkKKyAgICAgICAg ICAgICAgICByZXN1bHQuYXBwZW5kKENvbXBhY3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+Ojpl eHRyYWN0VmFsdWUoV1RGTW92ZShpdGVtUmVzdWx0KSkpOworICAgICAgICB9CisgICAgICAgIHJl c3VsdC5zaHJpbmtUb0ZpdCgpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KK307CisK K3RlbXBsYXRlPHR5cGVuYW1lIE1hcEZ1bmN0aW9uLCB0eXBlbmFtZSBTb3VyY2VUeXBlPgorVmVj dG9yPHR5cGVuYW1lIENvbXBhY3RNYXBwZXI8TWFwRnVuY3Rpb24sIFNvdXJjZVR5cGU+OjpEZXN0 aW5hdGlvbkl0ZW1UeXBlPiBjb21wYWN0TWFwKFNvdXJjZVR5cGUmJiBzb3VyY2UsIE1hcEZ1bmN0 aW9uJiYgbWFwRnVuY3Rpb24pCit7CisgICAgcmV0dXJuIENvbXBhY3RNYXBwZXI8TWFwRnVuY3Rp b24sIFNvdXJjZVR5cGU+Ojpjb21wYWN0TWFwKHN0ZDo6Zm9yd2FyZDxTb3VyY2VUeXBlPihzb3Vy Y2UpLCBzdGQ6OmZvcndhcmQ8TWFwRnVuY3Rpb24+KG1hcEZ1bmN0aW9uKSk7Cit9CisKIHRlbXBs YXRlPHR5cGVuYW1lIERlc3RpbmF0aW9uVmVjdG9yLCB0eXBlbmFtZSBDb2xsZWN0aW9uPgogaW5s aW5lIGF1dG8gY29weVRvVmVjdG9yU3BlY2lhbGl6YXRpb24oY29uc3QgQ29sbGVjdGlvbiYgY29s bGVjdGlvbikgLT4gRGVzdGluYXRpb25WZWN0b3IKIHsKQEAgLTE3MTUsNCArMTc4MCw1IEBAIHVz aW5nIFdURjo6VmVjdG9yOwogdXNpbmcgV1RGOjpjb3B5VG9WZWN0b3I7CiB1c2luZyBXVEY6OmNv cHlUb1ZlY3Rvck9mOwogdXNpbmcgV1RGOjpjb3B5VG9WZWN0b3JTcGVjaWFsaXphdGlvbjsKK3Vz aW5nIFdURjo6Y29tcGFjdE1hcDsKIHVzaW5nIFdURjo6cmVtb3ZlUmVwZWF0ZWRFbGVtZW50czsK ZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCAzNzZi MjU1NTRlZjIxMDEzNTQ5Mjg1MTBmYTI5MmE1MWZjNmM1NTE3Li4zZmMzN2M0ZWM1YjY5NTQwZWQ3 YTljNmI5NDQwOWUwMDQ4ODNkYzU5IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIv VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAKKzIwMjAtMDgtMjYgIFJ5b3N1a2UgTml3 YSAgPHJuaXdhQHdlYmtpdC5vcmc+CisKKyAgICAgICAgQWRkIGEgdmFyaWFudCBvZiBtYXAgd2hp Y2ggZmlsdGVycyBpdGVtcyB0byBWZWN0b3IuaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE1ODc5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgdW5pdCB0ZXN0cy4KKworICAgICAgICAqIFRlc3RX ZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHA6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpl dmVuTXVsdGlwbGllZEJ5Rml2ZSk6CisgICAgICAgIChXVEZfVmVjdG9yLkNvbXBhY3RNYXBTdGF0 aWNGdW5jdGlvblJldHVybk9wdGlvbmFsKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlJlZkNv dW50ZWRPYmplY3QpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6UmVmQ291bnRlZE9iamVjdDo6 Y3JlYXRlKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlJlZkNvdW50ZWRPYmplY3Q6OnJlZik6 CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpSZWZDb3VudGVkT2JqZWN0OjpSZWZDb3VudGVkT2Jq ZWN0KToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OmNyZWF0ZVJlZkNvdW50ZWRGb3JPZGQpOgor ICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5SZWZQdHIp OgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6Y3JlYXRlUmVmQ291bnRlZEZvckV2ZW4pOgorICAg ICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbFJl Zik6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpjcmVhdGVSZWZDb3VudGVkV2hlbkRpdmlzaWJs ZUJ5VGhyZWUpOgorICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFwU3RhdGljRnVuY3Rpb25S ZXR1cm5PcHRpb25hbFJlZlB0cik6CisgICAgICAgIChXVEZfVmVjdG9yLkNvbXBhY3RNYXBMYW1i ZGFSZXR1cm5PcHRpb25hbCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpDb3VudGVkT2JqZWN0 KToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OkNvdW50ZWRPYmplY3Q6OkNvdW50ZWRPYmplY3Qp OgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6Q291bnRlZE9iamVjdDo6dmFsdWUpOgorICAgICAg ICAoVGVzdFdlYktpdEFQSTo6Q291bnRlZE9iamVjdDo6Y291bnQpOgorICAgICAgICAoV1RGX1Zl Y3Rvci5Db21wYWN0TWFwTGFtYmRhQ29weVZlY3RvclJldHVybk9wdGlvbmFsQ291bnRlZE9iamVj dCk6CisgICAgICAgIChXVEZfVmVjdG9yLkNvbXBhY3RNYXBMYW1iZGFNb3ZlVmVjdG9yUmV0dXJu T3B0aW9uYWxDb3VudGVkT2JqZWN0KToKKyAgICAgICAgKFdURl9WZWN0b3IuQ29tcGFjdE1hcExh bWJkYVJldHVyblJlZlB0cik6CisgICAgICAgIChXVEZfVmVjdG9yLkNvbXBhY3RNYXBMYW1iZGFS ZXR1cm5SZWZQdHJGcm9tTW92ZWRSZWYpOgorICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFw TGFtYmRhUmV0dXJuT3B0aW9uYWxSZWZQdHIpOgorCiAyMDIwLTA4LTI2ICBDYXJsb3MgQWxiZXJ0 byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdW1dQRV0g QWRkIGJvdHMgZm9yIGdlbmVyYXRpbmcgbmlnaHRseSBidW5kbGUgcGFja2FnZXMKZGlmZiAtLWdp dCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAgYi9Ub29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dURi9WZWN0b3IuY3BwCmluZGV4IDEwMzg0MzYyYjE4NGIyNTE4MjQ5 NzE0NDU4YjdjNmVhOTgwY2Q1YmMuLjk3NzFjNDU3OWQ1ZWI5ODYyMDY5YTU2N2EwYzRlMjg1YjQy NmFhMmQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5j cHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcApAQCAtODcx LDYgKzg3MSwyNTEgQEAgVEVTVChXVEZfVmVjdG9yLCBNYXBGcm9tSGFzaE1hcCkKIAogfQogCitX VEY6Ok9wdGlvbmFsPGludD4gZXZlbk11bHRpcGxpZWRCeUZpdmUoaW50IGlucHV0KQoreworICAg IGlmIChpbnB1dCAlIDIpCisgICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisgICAgcmV0dXJu IGlucHV0ICogNTsKK30KKworVEVTVChXVEZfVmVjdG9yLCBDb21wYWN0TWFwU3RhdGljRnVuY3Rp b25SZXR1cm5PcHRpb25hbCkKK3sKKyAgICBWZWN0b3I8aW50PiB2ZWN0b3IgeyAxLCAyLCAzLCA0 IH07CisKKyAgICBhdXRvIG1hcHBlZCA9IFdURjo6Y29tcGFjdE1hcCh2ZWN0b3IsIGV2ZW5NdWx0 aXBsaWVkQnlGaXZlKTsKKworICAgIEVYUEVDVF9FUSgyVSwgbWFwcGVkLnNpemUoKSk7CisgICAg RVhQRUNUX0VRKDEwLCBtYXBwZWRbMF0pOworICAgIEVYUEVDVF9FUSgyMCwgbWFwcGVkWzFdKTsK K30KKworc3RydWN0IFJlZkNvdW50ZWRPYmplY3QgOiBwdWJsaWMgUmVmQ291bnRlZDxSZWZDb3Vu dGVkT2JqZWN0PiB7CitwdWJsaWM6CisgICAgc3RhdGljIFJlZjxSZWZDb3VudGVkT2JqZWN0PiBj cmVhdGUoaW50IHZhbHVlKSB7IHJldHVybiBhZG9wdFJlZigqbmV3IFJlZkNvdW50ZWRPYmplY3Qo dmFsdWUpKTsgfQorCisgICAgdm9pZCByZWYoKSBjb25zdAorICAgIHsKKyAgICAgICAgUmVmQ291 bnRlZDxSZWZDb3VudGVkT2JqZWN0Pjo6cmVmKCk7CisgICAgICAgICsrc190b3RhbFJlZkNvdW50 OworICAgIH0KKworICAgIGludCB2YWx1ZSB7IDAgfTsKKworICAgIHN0YXRpYyB1bnNpZ25lZCBz X3RvdGFsUmVmQ291bnQ7CisKK3ByaXZhdGU6CisgICAgUmVmQ291bnRlZE9iamVjdChpbnQgdmFs dWUpCisgICAgICAgIDogdmFsdWUodmFsdWUpCisgICAgeyB9Cit9OworCit1bnNpZ25lZCBSZWZD b3VudGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291bnQgPSAwOworCitSZWZQdHI8UmVmQ291bnRlZE9i amVjdD4gY3JlYXRlUmVmQ291bnRlZEZvck9kZChpbnQgaW5wdXQpCit7CisgICAgaWYgKGlucHV0 ICUgMikKKyAgICAgICAgcmV0dXJuIFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZShpbnB1dCk7Cisg ICAgcmV0dXJuIG51bGxwdHI7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgQ29tcGFjdE1hcFN0YXRp Y0Z1bmN0aW9uUmV0dXJuUmVmUHRyKQoreworICAgIFZlY3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIs IDMsIDQgfTsKKworICAgIFJlZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxSZWZDb3VudCA9IDA7Cisg ICAgVmVjdG9yPFJlZjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RGOjpjb21wYWN0TWFw KHZlY3RvciwgY3JlYXRlUmVmQ291bnRlZEZvck9kZCk7CisKKyAgICBFWFBFQ1RfRVEoMFUsIFJl ZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxSZWZDb3VudCk7CisgICAgRVhQRUNUX0VRKDJVLCBtYXBw ZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMSwgbWFwcGVkWzBdLT52YWx1ZSk7CisgICAgRVhQ RUNUX0VRKDMsIG1hcHBlZFsxXS0+dmFsdWUpOworfQorCitPcHRpb25hbDxSZWY8UmVmQ291bnRl ZE9iamVjdD4+IGNyZWF0ZVJlZkNvdW50ZWRGb3JFdmVuKGludCBpbnB1dCkKK3sKKyAgICBpZiAo aW5wdXQgJSAyKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworICAgIHJldHVybiBSZWZD b3VudGVkT2JqZWN0OjpjcmVhdGUoaW5wdXQpOworfQorCitURVNUKFdURl9WZWN0b3IsIENvbXBh Y3RNYXBTdGF0aWNGdW5jdGlvblJldHVybk9wdGlvbmFsUmVmKQoreworICAgIFZlY3RvcjxpbnQ+ IHZlY3RvciB7IDEsIDIsIDMsIDQgfTsKKworICAgIFJlZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxS ZWZDb3VudCA9IDA7CisgICAgVmVjdG9yPFJlZjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0g V1RGOjpjb21wYWN0TWFwKHZlY3RvciwgY3JlYXRlUmVmQ291bnRlZEZvckV2ZW4pOworCisgICAg RVhQRUNUX0VRKDBVLCBSZWZDb3VudGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291bnQpOworICAgIEVY UEVDVF9FUSgyVSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNUX0VRKDIsIG1hcHBlZFswXS0+ dmFsdWUpOworICAgIEVYUEVDVF9FUSg0LCBtYXBwZWRbMV0tPnZhbHVlKTsKK30KKworT3B0aW9u YWw8UmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+PiBjcmVhdGVSZWZDb3VudGVkV2hlbkRpdmlzaWJs ZUJ5VGhyZWUoaW50IGlucHV0KQoreworICAgIGlmIChpbnB1dCAlIDMpCisgICAgICAgIHJldHVy biBXVEY6Om51bGxvcHQ7CisgICAgaWYgKGlucHV0ICUgMikKKyAgICAgICAgcmV0dXJuIFJlZlB0 cjxSZWZDb3VudGVkT2JqZWN0PigpOworICAgIHJldHVybiBSZWZQdHI8UmVmQ291bnRlZE9iamVj dD4oUmVmQ291bnRlZE9iamVjdDo6Y3JlYXRlKGlucHV0KSk7Cit9CisKK1RFU1QoV1RGX1ZlY3Rv ciwgQ29tcGFjdE1hcFN0YXRpY0Z1bmN0aW9uUmV0dXJuT3B0aW9uYWxSZWZQdHIpCit7CisgICAg VmVjdG9yPGludD4gdmVjdG9yIHsgMSwgMiwgMywgNCwgNSwgNiwgNywgOCwgOSwgMTAgfTsKKwor ICAgIFJlZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxSZWZDb3VudCA9IDA7CisgICAgVmVjdG9yPFJl ZlB0cjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RGOjpjb21wYWN0TWFwKHZlY3Rvciwg Y3JlYXRlUmVmQ291bnRlZFdoZW5EaXZpc2libGVCeVRocmVlKTsKKworICAgIEVYUEVDVF9FUSgw VSwgUmVmQ291bnRlZE9iamVjdDo6c190b3RhbFJlZkNvdW50KTsKKyAgICBFWFBFQ1RfRVEoM1Us IG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9FUShudWxscHRyLCBtYXBwZWRbMF0pOworICAg IEVYUEVDVF9FUSg2LCBtYXBwZWRbMV0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEobnVsbHB0ciwg bWFwcGVkWzJdKTsKK30KKworVEVTVChXVEZfVmVjdG9yLCBDb21wYWN0TWFwTGFtYmRhUmV0dXJu T3B0aW9uYWwpCit7CisgICAgVmVjdG9yPFN0cmluZz4gdmVjdG9yIHsgImEiLCAiYiIsICJoZWxs byIsICJjaWFvIiwgIndvcmxkIiwgIndlYmtpdCIgfTsKKworICAgIGF1dG8gbWFwcGVkID0gV1RG Ojpjb21wYWN0TWFwKHZlY3RvciwgW10oY29uc3QgU3RyaW5nJiB2YWx1ZSkgLT4gT3B0aW9uYWw8 U3RyaW5nPiB7CisgICAgICAgIGlmICh2YWx1ZS5sZW5ndGgoKSA8IDUpCisgICAgICAgICAgICBy ZXR1cm4gV1RGOjpudWxsb3B0OworICAgICAgICByZXR1cm4gdmFsdWUuY29udmVydFRvQVNDSUlV cHBlcmNhc2UoKTsKKyAgICB9KTsKKworICAgIEVYUEVDVF9FUSgzVSwgbWFwcGVkLnNpemUoKSk7 CisgICAgRVhQRUNUX1NUUkVRKCJIRUxMTyIsIG1hcHBlZFswXS5hc2NpaSgpLmRhdGEoKSk7Cisg ICAgRVhQRUNUX1NUUkVRKCJXT1JMRCIsIG1hcHBlZFsxXS5hc2NpaSgpLmRhdGEoKSk7CisgICAg RVhQRUNUX1NUUkVRKCJXRUJLSVQiLCBtYXBwZWRbMl0uYXNjaWkoKS5kYXRhKCkpOworfQorCitj bGFzcyBDb3VudGVkT2JqZWN0IHsKK3B1YmxpYzoKKyAgICBDb3VudGVkT2JqZWN0KGludCB2YWx1 ZSkKKyAgICAgICAgOiBtX3ZhbHVlKHZhbHVlKQorICAgIHsgKytzX2NvdW50OyB9CisKKyAgICBD b3VudGVkT2JqZWN0KGNvbnN0IENvdW50ZWRPYmplY3QmIG90aGVyKQorICAgICAgICA6IG1fdmFs dWUob3RoZXIubV92YWx1ZSkKKyAgICB7ICsrc19jb3VudDsgfQorCisgICAgQ291bnRlZE9iamVj dChDb3VudGVkT2JqZWN0JiYgb3RoZXIpCisgICAgICAgIDogbV92YWx1ZShvdGhlci5tX3ZhbHVl KQorICAgIHsgfQorCisgICAgaW50IHZhbHVlKCkgY29uc3QgeyByZXR1cm4gbV92YWx1ZTsgfQor CisgICAgc3RhdGljIHVuc2lnbmVkJiBjb3VudCgpIHsgcmV0dXJuIHNfY291bnQ7IH0KKworcHJp dmF0ZToKKyAgICBpbnQgbV92YWx1ZTsKKworICAgIHN0YXRpYyB1bnNpZ25lZCBzX2NvdW50Owor fTsKKwordW5zaWduZWQgQ291bnRlZE9iamVjdDo6c19jb3VudCA9IDA7CisKK1RFU1QoV1RGX1Zl Y3RvciwgQ29tcGFjdE1hcExhbWJkYUNvcHlWZWN0b3JSZXR1cm5PcHRpb25hbENvdW50ZWRPYmpl Y3QpCit7CisgICAgVmVjdG9yPENvdW50ZWRPYmplY3Q+IHZlY3RvciB7IENvdW50ZWRPYmplY3Qo MSksIENvdW50ZWRPYmplY3QoMiksIENvdW50ZWRPYmplY3QoMyksIENvdW50ZWRPYmplY3QoNCkg fTsKKworICAgIENvdW50ZWRPYmplY3Q6OmNvdW50KCkgPSAwOworCisgICAgYXV0byBtYXBwZWQg PSBXVEY6OmNvbXBhY3RNYXAodmVjdG9yLCBbXShjb25zdCBDb3VudGVkT2JqZWN0JiBvYmplY3Qp IC0+IE9wdGlvbmFsPENvdW50ZWRPYmplY3Q+IHsKKyAgICAgICAgaWYgKG9iamVjdC52YWx1ZSgp ICUgMikKKyAgICAgICAgICAgIHJldHVybiBvYmplY3Q7CisgICAgICAgIHJldHVybiBXVEY6Om51 bGxvcHQ7CisgICAgfSk7CisKKyAgICBFWFBFQ1RfRVEoMlUsIENvdW50ZWRPYmplY3Q6OmNvdW50 KCkpOworCisgICAgRVhQRUNUX0VRKDJVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEo MSwgbWFwcGVkWzBdLnZhbHVlKCkpOworICAgIEVYUEVDVF9FUSgzLCBtYXBwZWRbMV0udmFsdWUo KSk7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgQ29tcGFjdE1hcExhbWJkYU1vdmVWZWN0b3JSZXR1 cm5PcHRpb25hbENvdW50ZWRPYmplY3QpCit7CisgICAgVmVjdG9yPENvdW50ZWRPYmplY3Q+IHZl Y3RvciB7IENvdW50ZWRPYmplY3QoMSksIENvdW50ZWRPYmplY3QoMiksIENvdW50ZWRPYmplY3Qo MyksIENvdW50ZWRPYmplY3QoNCkgfTsKKworICAgIENvdW50ZWRPYmplY3Q6OmNvdW50KCkgPSAw OworCisgICAgUmVmQ291bnRlZE9iamVjdDo6c190b3RhbFJlZkNvdW50ID0gMDsKKyAgICBhdXRv IG1hcHBlZCA9IFdURjo6Y29tcGFjdE1hcChXVEZNb3ZlKHZlY3RvciksIFtdKENvdW50ZWRPYmpl Y3QmJiBvYmplY3QpIC0+IE9wdGlvbmFsPENvdW50ZWRPYmplY3Q+IHsKKyAgICAgICAgaWYgKG9i amVjdC52YWx1ZSgpICUgMikKKyAgICAgICAgICAgIHJldHVybiBXVEZNb3ZlKG9iamVjdCk7Cisg ICAgICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisgICAgfSk7CisKKyAgICBFWFBFQ1RfRVEoMFUs IENvdW50ZWRPYmplY3Q6OmNvdW50KCkpOworCisgICAgRVhQRUNUX0VRKDJVLCBtYXBwZWQuc2l6 ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMSwgbWFwcGVkWzBdLnZhbHVlKCkpOworICAgIEVYUEVDVF9F USgzLCBtYXBwZWRbMV0udmFsdWUoKSk7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgQ29tcGFjdE1h cExhbWJkYVJldHVyblJlZlB0cikKK3sKKyAgICBWZWN0b3I8aW50PiB2ZWN0b3IgeyAxLCAyLCAz LCA0LCA1LCA2LCA3LCA4LCA5LCAxMCB9OworCisgICAgUmVmQ291bnRlZE9iamVjdDo6c190b3Rh bFJlZkNvdW50ID0gMDsKKyAgICBWZWN0b3I8UmVmPFJlZkNvdW50ZWRPYmplY3Q+PiBtYXBwZWQg PSBXVEY6OmNvbXBhY3RNYXAodmVjdG9yLCBbXShpbnQgdmFsdWUpIC0+IFJlZlB0cjxSZWZDb3Vu dGVkT2JqZWN0PiB7CisgICAgICAgIGlmICh2YWx1ZSAlIDMpCisgICAgICAgICAgICByZXR1cm4g bnVsbHB0cjsKKyAgICAgICAgcmV0dXJuIFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZSh2YWx1ZSk7 CisgICAgfSk7CisKKyAgICBFWFBFQ1RfRVEoMFUsIFJlZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxS ZWZDb3VudCk7CisgICAgRVhQRUNUX0VRKDNVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1Rf RVEoMywgbWFwcGVkWzBdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKDYsIG1hcHBlZFsxXS0+dmFs dWUpOworICAgIEVYUEVDVF9FUSg5LCBtYXBwZWRbMl0tPnZhbHVlKTsKK30KKworVEVTVChXVEZf VmVjdG9yLCBDb21wYWN0TWFwTGFtYmRhUmV0dXJuUmVmUHRyRnJvbU1vdmVkUmVmKQoreworICAg IFZlY3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQsIDUsIDYsIDcsIDgsIDksIDEwIH07CisK KyAgICBhdXRvIGNvdW50ZWRPYmplY3RzID0gV1RGOjptYXAodmVjdG9yLCBbXShpbnQgdmFsdWUp IC0+IFJlZjxSZWZDb3VudGVkT2JqZWN0PiB7CisgICAgICAgIHJldHVybiBSZWZDb3VudGVkT2Jq ZWN0OjpjcmVhdGUodmFsdWUpOworICAgIH0pOworCisgICAgUmVmQ291bnRlZE9iamVjdDo6c190 b3RhbFJlZkNvdW50ID0gMDsKKyAgICBhdXRvIG1hcHBlZCA9IFdURjo6Y29tcGFjdE1hcChXVEZN b3ZlKGNvdW50ZWRPYmplY3RzKSwgW10oUmVmPFJlZkNvdW50ZWRPYmplY3Q+JiYgb2JqZWN0KSAt PiBSZWZQdHI8UmVmQ291bnRlZE9iamVjdD4geworICAgICAgICBpZiAob2JqZWN0LT52YWx1ZSAl IDMpCisgICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICAgICAgcmV0dXJuIFdURk1vdmUo b2JqZWN0KTsKKyAgICB9KTsKKworICAgIEVYUEVDVF9FUSgwVSwgUmVmQ291bnRlZE9iamVjdDo6 c190b3RhbFJlZkNvdW50KTsKKyAgICBFWFBFQ1RfRVEoM1UsIG1hcHBlZC5zaXplKCkpOworICAg IEVYUEVDVF9FUSgzLCBtYXBwZWRbMF0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEoNiwgbWFwcGVk WzFdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKDksIG1hcHBlZFsyXS0+dmFsdWUpOworfQorCitU RVNUKFdURl9WZWN0b3IsIENvbXBhY3RNYXBMYW1iZGFSZXR1cm5PcHRpb25hbFJlZlB0cikKK3sK KyAgICBWZWN0b3I8aW50PiB2ZWN0b3IgeyAxLCAyLCAzLCA0LCA1LCA2LCA3LCA4LCA5LCAxMCB9 OworCisgICAgVmVjdG9yPFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RGOjpj b21wYWN0TWFwKHZlY3RvciwgWyZdKGludCB2YWx1ZSkgLT4gT3B0aW9uYWw8UmVmUHRyPFJlZkNv dW50ZWRPYmplY3Q+PiB7CisgICAgICAgIGlmICghKHZhbHVlICUgMikpCisgICAgICAgICAgICBy ZXR1cm4gV1RGOjpudWxsb3B0OworICAgICAgICBpZiAoISh2YWx1ZSAlIDMpKQorICAgICAgICAg ICAgcmV0dXJuIFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0PigpOworICAgICAgICByZXR1cm4gUmVm UHRyPFJlZkNvdW50ZWRPYmplY3Q+KFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZSh2YWx1ZSkpOwor ICAgIH0pOworCisgICAgRVhQRUNUX0VRKDBVLCBSZWZDb3VudGVkT2JqZWN0OjpzX3RvdGFsUmVm Q291bnQpOworICAgIEVYUEVDVF9FUSg1VSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNUX0VR KDEsIG1hcHBlZFswXS0+dmFsdWUpOworICAgIEVYUEVDVF9FUShudWxscHRyLCBtYXBwZWRbMV0p OworICAgIEVYUEVDVF9FUSg1LCBtYXBwZWRbMl0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEoNywg bWFwcGVkWzNdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKG51bGxwdHIsIG1hcHBlZFs0XSk7Cit9 CisKIFRFU1QoV1RGX1ZlY3RvciwgQ29weVRvVmVjdG9yKQogewogICAgIEhhc2hTZXQ8aW50PiBp bnRTZXQgeyAxLCAyLCAzIH07Cg== 407783 2020-09-02 12:04:29 -0700 2020-09-02 14:16:32 -0700 Patch for landing bug-215879-20200902120435.patch text/plain 14785 rniwa U3VidmVyc2lvbiBSZXZpc2lvbjogMjY2MjEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDE2YTJiNWFkN2I2MjgxYTdlNmI5NDJj NDcxNjFlMGM4Nzc3ZWNiN2EuLjQwZmQ1ZDQ0Y2YwNjlkZjIxNTJkNjFkMTM0MzUxNjhkNzE3YmVl OGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjAtMDgtMjYgIFJ5b3N1a2UgTml3YSAgPHJuaXdh QHdlYmtpdC5vcmc+CisKKyAgICAgICAgQWRkIGEgdmFyaWFudCBvZiBtYXAgd2hpY2ggZmlsdGVy cyBpdGVtcyB0byBWZWN0b3IuaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjE1ODc5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIgYW5k IFl1c3VrZSBTdXp1a2kuCisKKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIFdURjo6Y29tcGFjdE1h cCwgd2hpY2ggY2FsbHMgYSBmdW5jdGlvbiBvbiBlYWNoIGl0ZW0gaW4gYW4gaXRlcmFibGUgb2Jq ZWN0IGxpa2UgV1RGOjptYXAKKyAgICAgICAgYnV0IGFsc28gZmlsdGVycyB0aGUgcmV0dXJuZWQg dmFsdWUuIFRoZSBtYXBwZWQgZnVuY3Rpb24gbWF5IHJldHVybiBPcHRpb25hbDxUPiBvciBSZWZQ dHI8VD4uIFRoZSB2YWx1ZQorICAgICAgICBpcyBrZXB0IGluIHRoZSByZXN1bHQgaWYgdGhlIHJl dHVybmVkIHZhbHVlIGlzIG5vdCBXVEY6Om51bGxvcHQgaW4gdGhlIGNhc2Ugb2YgT3B0aW9uYWw8 VD4gYW5kIG5vdCBudWxsCisgICAgICAgIGluIHRoZSBjYXNlIG9mIFJlZlB0cjxUPi4gVGhlIHJl c3VsdCB3aWxsIGJlIGVpdGhlciBWZWN0b3I8VD4gZm9yIE9wdGlvbmFsPFQ+IG9yIGVsc2UgVmVj dG9yPFJlZjxUPj4uCisKKyAgICAgICAgKiB3dGYvVmVjdG9yLmg6CisgICAgICAgIChXVEY6OkNv bXBhY3RNYXBUcmFpdHM6KTogQWRkZWQuIFRyYWl0cyB0byBoYXZlIGEgZGlmZmVyZW50IGJlaGF2 aW9yCisgICAgICAgIChXVEY6OkNvbXBhY3RNYXBUcmFpdHM8T3B0aW9uYWw8VD4+OjpoYXNWYWx1 ZSk6IEFkZGVkLgorICAgICAgICAoV1RGOjpDb21wYWN0TWFwVHJhaXRzPE9wdGlvbmFsPFQ+Pjo6 ZXh0cmFjdFZhbHVlKTogQWRkZWQuCisgICAgICAgIChXVEY6OkNvbXBhY3RNYXBUcmFpdHM8UmVm UHRyPFQ+Pjo6aGFzVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29tcGFjdE1hcFRyYWl0 czxSZWZQdHI8VD4+OjpleHRyYWN0VmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKFdURjo6Q29tcGFj dE1hcCk6IEFkZGVkLiBUaGUgaGVscGVyIHRvIHVzZSBXVEZNb3ZlIG9uIHRoZSBhcmd1bWVudCB0 byB0aGUgbWFwcGVkIGZ1bmN0aW9uIGlmIHBvc3NpYmxlLgorICAgICAgICAoV1RGOjpjb21wYWN0 TWFwKTogQWRkZWQuCisKIDIwMjAtMDgtMjUgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CiAKICAgICAgICAgSGFzaE1hcDxSZWY8VD4+Ojp0YWtlIHNob3VsZCByZXR1cm4gUmVmUHRy PFQ+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaCBiL1NvdXJjZS9XVEYvd3Rm L1ZlY3Rvci5oCmluZGV4IGY5OGY4NGU2MzhjZTIyODAzN2VmMjA0ZTg2ZWE3ODJiOWExNTM4Yzku LmM2YWRjYzk4ZGY0MDNlM2Q1NTYyY2RhMTM2M2YzOTMzOWM2YzJkNGEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XVEYvd3RmL1ZlY3Rvci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCkBAIC0x NjgwLDYgKzE2ODAsNzEgQEAgVmVjdG9yPHR5cGVuYW1lIE1hcHBlcjxNYXBGdW5jdGlvbiwgU291 cmNlVHlwZT46OkRlc3RpbmF0aW9uSXRlbVR5cGU+IG1hcChTb3VyY2UKICAgICByZXR1cm4gTWFw cGVyPE1hcEZ1bmN0aW9uLCBTb3VyY2VUeXBlPjo6bWFwKHN0ZDo6Zm9yd2FyZDxTb3VyY2VUeXBl Pihzb3VyY2UpLCBzdGQ6OmZvcndhcmQ8TWFwRnVuY3Rpb24+KG1hcEZ1bmN0aW9uKSk7CiB9CiAK K3RlbXBsYXRlPHR5cGVuYW1lIE1hcEZ1bmN0aW9uUmV0dXJuVHlwZT4KK3N0cnVjdCBDb21wYWN0 TWFwVHJhaXRzIHsKKyAgICBzdGF0aWMgYm9vbCBoYXNWYWx1ZShjb25zdCBNYXBGdW5jdGlvblJl dHVyblR5cGUmKTsKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBJdGVtVHlwZT4KKyAgICBzdGF0aWMg SXRlbVR5cGUgZXh0cmFjdFZhbHVlKE1hcEZ1bmN0aW9uUmV0dXJuVHlwZSYmKTsKK307CisKK3Rl bXBsYXRlPHR5cGVuYW1lIFQ+CitzdHJ1Y3QgQ29tcGFjdE1hcFRyYWl0czxPcHRpb25hbDxUPj4g eworICAgIHVzaW5nIEl0ZW1UeXBlID0gVDsKKyAgICBzdGF0aWMgYm9vbCBoYXNWYWx1ZShjb25z dCBPcHRpb25hbDxUPiYgcmV0dXJuVmFsdWUpIHsgcmV0dXJuICEhcmV0dXJuVmFsdWU7IH0KKyAg ICBzdGF0aWMgSXRlbVR5cGUgZXh0cmFjdFZhbHVlKE9wdGlvbmFsPFQ+JiYgcmV0dXJuVmFsdWUp IHsgcmV0dXJuIFdURk1vdmUoKnJldHVyblZhbHVlKTsgfQorfTsKKwordGVtcGxhdGU8dHlwZW5h bWUgVD4KK3N0cnVjdCBDb21wYWN0TWFwVHJhaXRzPFJlZlB0cjxUPj4geworICAgIHVzaW5nIEl0 ZW1UeXBlID0gUmVmPFQ+OworICAgIHN0YXRpYyBib29sIGhhc1ZhbHVlKGNvbnN0IFJlZlB0cjxU PiYgcmV0dXJuVmFsdWUpIHsgcmV0dXJuICEhcmV0dXJuVmFsdWU7IH0KKyAgICBzdGF0aWMgSXRl bVR5cGUgZXh0cmFjdFZhbHVlKFJlZlB0cjxUPiYmIHJldHVyblZhbHVlKSB7IHJldHVybiByZXR1 cm5WYWx1ZS5yZWxlYXNlTm9uTnVsbCgpOyB9Cit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBNYXBG dW5jdGlvbiwgdHlwZW5hbWUgU291cmNlVHlwZSwgdHlwZW5hbWUgRW5hYmxlID0gdm9pZD4KK3N0 cnVjdCBDb21wYWN0TWFwcGVyIHsKKyAgICB1c2luZyBTb3VyY2VJdGVtVHlwZSA9IHR5cGVuYW1l IENvbGxlY3Rpb25JbnNwZWN0b3I8U291cmNlVHlwZT46OlNvdXJjZUl0ZW1UeXBlOworICAgIHVz aW5nIFJlc3VsdEl0ZW1UeXBlID0gdHlwZW5hbWUgc3RkOjpyZXN1bHRfb2Y8TWFwRnVuY3Rpb24o U291cmNlSXRlbVR5cGUmKT46OnR5cGU7CisgICAgdXNpbmcgRGVzdGluYXRpb25JdGVtVHlwZSA9 IHR5cGVuYW1lIENvbXBhY3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+OjpJdGVtVHlwZTsKKwor ICAgIHN0YXRpYyBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gY29tcGFjdE1hcChTb3VyY2VU eXBlIHNvdXJjZSwgY29uc3QgTWFwRnVuY3Rpb24mIG1hcEZ1bmN0aW9uKQorICAgIHsKKyAgICAg ICAgVmVjdG9yPERlc3RpbmF0aW9uSXRlbVR5cGU+IHJlc3VsdDsKKyAgICAgICAgZm9yIChhdXRv JiBpdGVtIDogc291cmNlKSB7CisgICAgICAgICAgICBhdXRvIGl0ZW1SZXN1bHQgPSBtYXBGdW5j dGlvbihpdGVtKTsKKyAgICAgICAgICAgIGlmIChDb21wYWN0TWFwVHJhaXRzPFJlc3VsdEl0ZW1U eXBlPjo6aGFzVmFsdWUoaXRlbVJlc3VsdCkpCisgICAgICAgICAgICAgICAgcmVzdWx0LmFwcGVu ZChDb21wYWN0TWFwVHJhaXRzPFJlc3VsdEl0ZW1UeXBlPjo6ZXh0cmFjdFZhbHVlKFdURk1vdmUo aXRlbVJlc3VsdCkpKTsKKyAgICAgICAgfQorICAgICAgICByZXN1bHQuc2hyaW5rVG9GaXQoKTsK KyAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICB9Cit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBN YXBGdW5jdGlvbiwgdHlwZW5hbWUgU291cmNlVHlwZT4KK3N0cnVjdCBDb21wYWN0TWFwcGVyPE1h cEZ1bmN0aW9uLCBTb3VyY2VUeXBlLCB0eXBlbmFtZSBzdGQ6OmVuYWJsZV9pZjxzdGQ6OmlzX3J2 YWx1ZV9yZWZlcmVuY2U8U291cmNlVHlwZSYmPjo6dmFsdWU+Ojp0eXBlPiB7CisgICAgdXNpbmcg U291cmNlSXRlbVR5cGUgPSB0eXBlbmFtZSBDb2xsZWN0aW9uSW5zcGVjdG9yPFNvdXJjZVR5cGU+ OjpTb3VyY2VJdGVtVHlwZTsKKyAgICB1c2luZyBSZXN1bHRJdGVtVHlwZSA9IHR5cGVuYW1lIHN0 ZDo6cmVzdWx0X29mPE1hcEZ1bmN0aW9uKFNvdXJjZUl0ZW1UeXBlJiYpPjo6dHlwZTsKKyAgICB1 c2luZyBEZXN0aW5hdGlvbkl0ZW1UeXBlID0gdHlwZW5hbWUgQ29tcGFjdE1hcFRyYWl0czxSZXN1 bHRJdGVtVHlwZT46Okl0ZW1UeXBlOworCisgICAgc3RhdGljIFZlY3RvcjxEZXN0aW5hdGlvbkl0 ZW1UeXBlPiBjb21wYWN0TWFwKFNvdXJjZVR5cGUgc291cmNlLCBjb25zdCBNYXBGdW5jdGlvbiYg bWFwRnVuY3Rpb24pCisgICAgeworICAgICAgICBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4g cmVzdWx0OworICAgICAgICBmb3IgKGF1dG8mIGl0ZW0gOiBzb3VyY2UpIHsKKyAgICAgICAgICAg IGF1dG8gaXRlbVJlc3VsdCA9IG1hcEZ1bmN0aW9uKFdURk1vdmUoaXRlbSkpOworICAgICAgICAg ICAgaWYgKENvbXBhY3RNYXBUcmFpdHM8UmVzdWx0SXRlbVR5cGU+OjpoYXNWYWx1ZShpdGVtUmVz dWx0KSkKKyAgICAgICAgICAgICAgICByZXN1bHQuYXBwZW5kKENvbXBhY3RNYXBUcmFpdHM8UmVz dWx0SXRlbVR5cGU+OjpleHRyYWN0VmFsdWUoV1RGTW92ZShpdGVtUmVzdWx0KSkpOworICAgICAg ICB9CisgICAgICAgIHJlc3VsdC5zaHJpbmtUb0ZpdCgpOworICAgICAgICByZXR1cm4gcmVzdWx0 OworICAgIH0KK307CisKK3RlbXBsYXRlPHR5cGVuYW1lIE1hcEZ1bmN0aW9uLCB0eXBlbmFtZSBT b3VyY2VUeXBlPgorVmVjdG9yPHR5cGVuYW1lIENvbXBhY3RNYXBwZXI8TWFwRnVuY3Rpb24sIFNv dXJjZVR5cGU+OjpEZXN0aW5hdGlvbkl0ZW1UeXBlPiBjb21wYWN0TWFwKFNvdXJjZVR5cGUmJiBz b3VyY2UsIE1hcEZ1bmN0aW9uJiYgbWFwRnVuY3Rpb24pCit7CisgICAgcmV0dXJuIENvbXBhY3RN YXBwZXI8TWFwRnVuY3Rpb24sIFNvdXJjZVR5cGU+Ojpjb21wYWN0TWFwKHN0ZDo6Zm9yd2FyZDxT b3VyY2VUeXBlPihzb3VyY2UpLCBzdGQ6OmZvcndhcmQ8TWFwRnVuY3Rpb24+KG1hcEZ1bmN0aW9u KSk7Cit9CisKIHRlbXBsYXRlPHR5cGVuYW1lIERlc3RpbmF0aW9uVmVjdG9yLCB0eXBlbmFtZSBD b2xsZWN0aW9uPgogaW5saW5lIGF1dG8gY29weVRvVmVjdG9yU3BlY2lhbGl6YXRpb24oY29uc3Qg Q29sbGVjdGlvbiYgY29sbGVjdGlvbikgLT4gRGVzdGluYXRpb25WZWN0b3IKIHsKQEAgLTE3MTUs NCArMTc4MCw1IEBAIHVzaW5nIFdURjo6VmVjdG9yOwogdXNpbmcgV1RGOjpjb3B5VG9WZWN0b3I7 CiB1c2luZyBXVEY6OmNvcHlUb1ZlY3Rvck9mOwogdXNpbmcgV1RGOjpjb3B5VG9WZWN0b3JTcGVj aWFsaXphdGlvbjsKK3VzaW5nIFdURjo6Y29tcGFjdE1hcDsKIHVzaW5nIFdURjo6cmVtb3ZlUmVw ZWF0ZWRFbGVtZW50czsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5n ZUxvZwppbmRleCAzNzZiMjU1NTRlZjIxMDEzNTQ5Mjg1MTBmYTI5MmE1MWZjNmM1NTE3Li5kODAx YzZmZDc4ZjQ3MGZmYjM3ZWE3YTA0NjJhYTMxNmFlMDk0OWE0IDEwMDY0NAotLS0gYS9Ub29scy9D aGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAKKzIwMjAtMDgt MjYgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CisKKyAgICAgICAgQWRkIGEgdmFy aWFudCBvZiBtYXAgd2hpY2ggZmlsdGVycyBpdGVtcyB0byBWZWN0b3IuaAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE1ODc5CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgRGFyaW4gQWRsZXIgYW5kIFl1c3VrZSBTdXp1a2kuCisKKyAgICAgICAgQWRkZWQg dW5pdCB0ZXN0cy4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5j cHA6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpldmVuTXVsdGlwbGllZEJ5Rml2ZSk6CisgICAg ICAgIChXVEZfVmVjdG9yLkNvbXBhY3RNYXBTdGF0aWNGdW5jdGlvblJldHVybk9wdGlvbmFsKToK KyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlJlZkNvdW50ZWRPYmplY3QpOgorICAgICAgICAoVGVz dFdlYktpdEFQSTo6UmVmQ291bnRlZE9iamVjdDo6Y3JlYXRlKToKKyAgICAgICAgKFRlc3RXZWJL aXRBUEk6OlJlZkNvdW50ZWRPYmplY3Q6OnJlZik6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpS ZWZDb3VudGVkT2JqZWN0OjpSZWZDb3VudGVkT2JqZWN0KToKKyAgICAgICAgKFRlc3RXZWJLaXRB UEk6OmNyZWF0ZVJlZkNvdW50ZWRGb3JPZGQpOgorICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0 TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5SZWZQdHIpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6 Y3JlYXRlUmVmQ291bnRlZEZvckV2ZW4pOgorICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFw U3RhdGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbFJlZik6CisgICAgICAgIChUZXN0V2ViS2l0QVBJ OjpjcmVhdGVSZWZDb3VudGVkV2hlbkRpdmlzaWJsZUJ5VGhyZWUpOgorICAgICAgICAoV1RGX1Zl Y3Rvci5Db21wYWN0TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbFJlZlB0cik6CisgICAg ICAgIChXVEZfVmVjdG9yLkNvbXBhY3RNYXBMYW1iZGFSZXR1cm5PcHRpb25hbCk6CisgICAgICAg IChUZXN0V2ViS2l0QVBJOjpDb3VudGVkT2JqZWN0KToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OkNvdW50ZWRPYmplY3Q6OkNvdW50ZWRPYmplY3QpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6 Q291bnRlZE9iamVjdDo6dmFsdWUpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6Q291bnRlZE9i amVjdDo6Y291bnQpOgorICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFwTGFtYmRhQ29weVZl Y3RvclJldHVybk9wdGlvbmFsQ291bnRlZE9iamVjdCk6CisgICAgICAgIChXVEZfVmVjdG9yLkNv bXBhY3RNYXBMYW1iZGFNb3ZlVmVjdG9yUmV0dXJuT3B0aW9uYWxDb3VudGVkT2JqZWN0KToKKyAg ICAgICAgKFdURl9WZWN0b3IuQ29tcGFjdE1hcExhbWJkYVJldHVyblJlZlB0cik6CisgICAgICAg IChXVEZfVmVjdG9yLkNvbXBhY3RNYXBMYW1iZGFSZXR1cm5SZWZQdHJGcm9tTW92ZWRSZWYpOgor ICAgICAgICAoV1RGX1ZlY3Rvci5Db21wYWN0TWFwTGFtYmRhUmV0dXJuT3B0aW9uYWxSZWZQdHIp OgorCiAyMDIwLTA4LTI2ICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2Fs aWEuY29tPgogCiAgICAgICAgIFtHVEtdW1dQRV0gQWRkIGJvdHMgZm9yIGdlbmVyYXRpbmcgbmln aHRseSBidW5kbGUgcGFja2FnZXMKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV1RGL1ZlY3Rvci5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9WZWN0b3Iu Y3BwCmluZGV4IDEwMzg0MzYyYjE4NGIyNTE4MjQ5NzE0NDU4YjdjNmVhOTgwY2Q1YmMuLmRkMWNk OTU2OWJkZGYwY2ViMTc2OGZmZDBmMTE0OWVjZDY0ZGE3OTEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XVEYvVmVjdG9yLmNwcApAQCAtODcxLDYgKzg3MSwyNTMgQEAgVEVTVChXVEZfVmVj dG9yLCBNYXBGcm9tSGFzaE1hcCkKIAogfQogCitXVEY6Ok9wdGlvbmFsPGludD4gZXZlbk11bHRp cGxpZWRCeUZpdmUoaW50IGlucHV0KQoreworICAgIGlmIChpbnB1dCAlIDIpCisgICAgICAgIHJl dHVybiBXVEY6Om51bGxvcHQ7CisgICAgcmV0dXJuIGlucHV0ICogNTsKK30KKworVEVTVChXVEZf VmVjdG9yLCBDb21wYWN0TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbCkKK3sKKyAgICBW ZWN0b3I8aW50PiB2ZWN0b3IgeyAxLCAyLCAzLCA0IH07CisKKyAgICBhdXRvIG1hcHBlZCA9IFdU Rjo6Y29tcGFjdE1hcCh2ZWN0b3IsIGV2ZW5NdWx0aXBsaWVkQnlGaXZlKTsKKworICAgIEVYUEVD VF9FUSgyVSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNUX0VRKDEwLCBtYXBwZWRbMF0pOwor ICAgIEVYUEVDVF9FUSgyMCwgbWFwcGVkWzFdKTsKK30KKworc3RydWN0IFJlZkNvdW50ZWRPYmpl Y3QgOiBwdWJsaWMgUmVmQ291bnRlZDxSZWZDb3VudGVkT2JqZWN0PiB7CitwdWJsaWM6CisgICAg c3RhdGljIFJlZjxSZWZDb3VudGVkT2JqZWN0PiBjcmVhdGUoaW50IHZhbHVlKSB7IHJldHVybiBh ZG9wdFJlZigqbmV3IFJlZkNvdW50ZWRPYmplY3QodmFsdWUpKTsgfQorCisgICAgdm9pZCByZWYo KSBjb25zdAorICAgIHsKKyAgICAgICAgUmVmQ291bnRlZDxSZWZDb3VudGVkT2JqZWN0Pjo6cmVm KCk7CisgICAgICAgICsrc190b3RhbFJlZkNvdW50OworICAgIH0KKworICAgIGludCB2YWx1ZSB7 IDAgfTsKKworICAgIHN0YXRpYyB1bnNpZ25lZCBzX3RvdGFsUmVmQ291bnQ7CisKK3ByaXZhdGU6 CisgICAgUmVmQ291bnRlZE9iamVjdChpbnQgdmFsdWUpCisgICAgICAgIDogdmFsdWUodmFsdWUp CisgICAgeyB9Cit9OworCit1bnNpZ25lZCBSZWZDb3VudGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291 bnQgPSAwOworCitSZWZQdHI8UmVmQ291bnRlZE9iamVjdD4gY3JlYXRlUmVmQ291bnRlZEZvck9k ZChpbnQgaW5wdXQpCit7CisgICAgaWYgKGlucHV0ICUgMikKKyAgICAgICAgcmV0dXJuIFJlZkNv dW50ZWRPYmplY3Q6OmNyZWF0ZShpbnB1dCk7CisgICAgcmV0dXJuIG51bGxwdHI7Cit9CisKK1RF U1QoV1RGX1ZlY3RvciwgQ29tcGFjdE1hcFN0YXRpY0Z1bmN0aW9uUmV0dXJuUmVmUHRyKQorewor ICAgIFZlY3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQgfTsKKworICAgIFJlZkNvdW50ZWRP YmplY3Q6OnNfdG90YWxSZWZDb3VudCA9IDA7CisgICAgVmVjdG9yPFJlZjxSZWZDb3VudGVkT2Jq ZWN0Pj4gbWFwcGVkID0gV1RGOjpjb21wYWN0TWFwKHZlY3RvciwgY3JlYXRlUmVmQ291bnRlZEZv ck9kZCk7CisKKyAgICBFWFBFQ1RfRVEoMFUsIFJlZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxSZWZD b3VudCk7CisgICAgRVhQRUNUX0VRKDJVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEo MSwgbWFwcGVkWzBdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKDMsIG1hcHBlZFsxXS0+dmFsdWUp OworfQorCitPcHRpb25hbDxSZWY8UmVmQ291bnRlZE9iamVjdD4+IGNyZWF0ZVJlZkNvdW50ZWRG b3JFdmVuKGludCBpbnB1dCkKK3sKKyAgICBpZiAoaW5wdXQgJSAyKQorICAgICAgICByZXR1cm4g V1RGOjpudWxsb3B0OworICAgIHJldHVybiBSZWZDb3VudGVkT2JqZWN0OjpjcmVhdGUoaW5wdXQp OworfQorCitURVNUKFdURl9WZWN0b3IsIENvbXBhY3RNYXBTdGF0aWNGdW5jdGlvblJldHVybk9w dGlvbmFsUmVmKQoreworICAgIFZlY3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQgfTsKKwor ICAgIFJlZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxSZWZDb3VudCA9IDA7CisgICAgYXV0byBtYXBw ZWQgPSBXVEY6OmNvbXBhY3RNYXAodmVjdG9yLCBjcmVhdGVSZWZDb3VudGVkRm9yRXZlbik7CisK KyAgICBFWFBFQ1RfRVEoMFUsIFJlZkNvdW50ZWRPYmplY3Q6OnNfdG90YWxSZWZDb3VudCk7Cisg ICAgRVhQRUNUX0VRKDJVLCBtYXBwZWQuc2l6ZSgpKTsKKyAgICBFWFBFQ1RfRVEoMiwgbWFwcGVk WzBdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKDQsIG1hcHBlZFsxXS0+dmFsdWUpOworfQorCitP cHRpb25hbDxSZWZQdHI8UmVmQ291bnRlZE9iamVjdD4+IGNyZWF0ZVJlZkNvdW50ZWRXaGVuRGl2 aXNpYmxlQnlUaHJlZShpbnQgaW5wdXQpCit7CisgICAgaWYgKGlucHV0ICUgMykKKyAgICAgICAg cmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICBpZiAoaW5wdXQgJSAyKQorICAgICAgICByZXR1cm4g UmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+KCk7CisgICAgcmV0dXJuIFJlZlB0cjxSZWZDb3VudGVk T2JqZWN0PihSZWZDb3VudGVkT2JqZWN0OjpjcmVhdGUoaW5wdXQpKTsKK30KKworVEVTVChXVEZf VmVjdG9yLCBDb21wYWN0TWFwU3RhdGljRnVuY3Rpb25SZXR1cm5PcHRpb25hbFJlZlB0cikKK3sK KyAgICBWZWN0b3I8aW50PiB2ZWN0b3IgeyAxLCAyLCAzLCA0LCA1LCA2LCA3LCA4LCA5LCAxMCB9 OworCisgICAgUmVmQ291bnRlZE9iamVjdDo6c190b3RhbFJlZkNvdW50ID0gMDsKKyAgICBWZWN0 b3I8UmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+PiBtYXBwZWQgPSBXVEY6OmNvbXBhY3RNYXAodmVj dG9yLCBjcmVhdGVSZWZDb3VudGVkV2hlbkRpdmlzaWJsZUJ5VGhyZWUpOworCisgICAgRVhQRUNU X0VRKDBVLCBSZWZDb3VudGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291bnQpOworICAgIEVYUEVDVF9F USgzVSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNUX0VRKG51bGxwdHIsIG1hcHBlZFswXSk7 CisgICAgRVhQRUNUX0VRKDYsIG1hcHBlZFsxXS0+dmFsdWUpOworICAgIEVYUEVDVF9FUShudWxs cHRyLCBtYXBwZWRbMl0pOworfQorCitURVNUKFdURl9WZWN0b3IsIENvbXBhY3RNYXBMYW1iZGFS ZXR1cm5PcHRpb25hbCkKK3sKKyAgICBWZWN0b3I8U3RyaW5nPiB2ZWN0b3IgeyAiYSIsICJiIiwg ImhlbGxvIiwgImNpYW8iLCAid29ybGQiLCAid2Via2l0IiB9OworCisgICAgYXV0byBtYXBwZWQg PSBXVEY6OmNvbXBhY3RNYXAodmVjdG9yLCBbXShjb25zdCBTdHJpbmcmIHZhbHVlKSAtPiBPcHRp b25hbDxTdHJpbmc+IHsKKyAgICAgICAgaWYgKHZhbHVlLmxlbmd0aCgpIDwgNSkKKyAgICAgICAg ICAgIHJldHVybiBXVEY6Om51bGxvcHQ7CisgICAgICAgIHJldHVybiB2YWx1ZS5jb252ZXJ0VG9B U0NJSVVwcGVyY2FzZSgpOworICAgIH0pOworCisgICAgRVhQRUNUX0VRKDNVLCBtYXBwZWQuc2l6 ZSgpKTsKKyAgICBFWFBFQ1RfU1RSRVEoIkhFTExPIiwgbWFwcGVkWzBdLmFzY2lpKCkuZGF0YSgp KTsKKyAgICBFWFBFQ1RfU1RSRVEoIldPUkxEIiwgbWFwcGVkWzFdLmFzY2lpKCkuZGF0YSgpKTsK KyAgICBFWFBFQ1RfU1RSRVEoIldFQktJVCIsIG1hcHBlZFsyXS5hc2NpaSgpLmRhdGEoKSk7Cit9 CisKK2NsYXNzIENvdW50ZWRPYmplY3QgeworcHVibGljOgorICAgIGV4cGxpY2l0IENvdW50ZWRP YmplY3QoaW50IHZhbHVlKQorICAgICAgICA6IG1fdmFsdWUodmFsdWUpCisgICAgeyArK3NfY291 bnQ7IH0KKworICAgIENvdW50ZWRPYmplY3QoY29uc3QgQ291bnRlZE9iamVjdCYgb3RoZXIpCisg ICAgICAgIDogbV92YWx1ZShvdGhlci5tX3ZhbHVlKQorICAgIHsgKytzX2NvdW50OyB9CisKKyAg ICBDb3VudGVkT2JqZWN0KENvdW50ZWRPYmplY3QmJiBvdGhlcikKKyAgICAgICAgOiBtX3ZhbHVl KG90aGVyLm1fdmFsdWUpCisgICAgeyB9CisKKyAgICBpbnQgdmFsdWUoKSBjb25zdCB7IHJldHVy biBtX3ZhbHVlOyB9CisKKyAgICBzdGF0aWMgdW5zaWduZWQmIGNvdW50KCkgeyByZXR1cm4gc19j b3VudDsgfQorCitwcml2YXRlOgorICAgIGludCBtX3ZhbHVlOworCisgICAgc3RhdGljIHVuc2ln bmVkIHNfY291bnQ7Cit9OworCit1bnNpZ25lZCBDb3VudGVkT2JqZWN0OjpzX2NvdW50ID0gMDsK KworVEVTVChXVEZfVmVjdG9yLCBDb21wYWN0TWFwTGFtYmRhQ29weVZlY3RvclJldHVybk9wdGlv bmFsQ291bnRlZE9iamVjdCkKK3sKKyAgICBWZWN0b3I8Q291bnRlZE9iamVjdD4gdmVjdG9yIHsg Q291bnRlZE9iamVjdCgxKSwgQ291bnRlZE9iamVjdCgyKSwgQ291bnRlZE9iamVjdCgzKSwgQ291 bnRlZE9iamVjdCg0KSB9OworCisgICAgQ291bnRlZE9iamVjdDo6Y291bnQoKSA9IDA7CisKKyAg ICBhdXRvIG1hcHBlZCA9IFdURjo6Y29tcGFjdE1hcCh2ZWN0b3IsIFtdKGNvbnN0IENvdW50ZWRP YmplY3QmIG9iamVjdCkgLT4gT3B0aW9uYWw8Q291bnRlZE9iamVjdD4geworICAgICAgICBpZiAo b2JqZWN0LnZhbHVlKCkgJSAyKQorICAgICAgICAgICAgcmV0dXJuIG9iamVjdDsKKyAgICAgICAg cmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICB9KTsKKworICAgIEVYUEVDVF9FUSgyVSwgQ291bnRl ZE9iamVjdDo6Y291bnQoKSk7CisKKyAgICBFWFBFQ1RfRVEoMlUsIG1hcHBlZC5zaXplKCkpOwor ICAgIEVYUEVDVF9FUSgxLCBtYXBwZWRbMF0udmFsdWUoKSk7CisgICAgRVhQRUNUX0VRKDMsIG1h cHBlZFsxXS52YWx1ZSgpKTsKK30KKworVEVTVChXVEZfVmVjdG9yLCBDb21wYWN0TWFwTGFtYmRh TW92ZVZlY3RvclJldHVybk9wdGlvbmFsQ291bnRlZE9iamVjdCkKK3sKKyAgICBWZWN0b3I8Q291 bnRlZE9iamVjdD4gdmVjdG9yIHsgQ291bnRlZE9iamVjdCgxKSwgQ291bnRlZE9iamVjdCgyKSwg Q291bnRlZE9iamVjdCgzKSwgQ291bnRlZE9iamVjdCg0KSB9OworCisgICAgQ291bnRlZE9iamVj dDo6Y291bnQoKSA9IDA7CisKKyAgICBSZWZDb3VudGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291bnQg PSAwOworICAgIGF1dG8gbWFwcGVkID0gV1RGOjpjb21wYWN0TWFwKFdURk1vdmUodmVjdG9yKSwg W10oQ291bnRlZE9iamVjdCYmIG9iamVjdCkgLT4gT3B0aW9uYWw8Q291bnRlZE9iamVjdD4gewor ICAgICAgICBpZiAob2JqZWN0LnZhbHVlKCkgJSAyKQorICAgICAgICAgICAgcmV0dXJuIFdURk1v dmUob2JqZWN0KTsKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICB9KTsKKworICAg IEVYUEVDVF9FUSgwVSwgQ291bnRlZE9iamVjdDo6Y291bnQoKSk7CisKKyAgICBFWFBFQ1RfRVEo MlUsIG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9FUSgxLCBtYXBwZWRbMF0udmFsdWUoKSk7 CisgICAgRVhQRUNUX0VRKDMsIG1hcHBlZFsxXS52YWx1ZSgpKTsKK30KKworVEVTVChXVEZfVmVj dG9yLCBDb21wYWN0TWFwTGFtYmRhUmV0dXJuUmVmUHRyKQoreworICAgIFZlY3RvcjxpbnQ+IHZl Y3RvciB7IDEsIDIsIDMsIDQsIDUsIDYsIDcsIDgsIDksIDEwIH07CisKKyAgICBSZWZDb3VudGVk T2JqZWN0OjpzX3RvdGFsUmVmQ291bnQgPSAwOworICAgIFZlY3RvcjxSZWY8UmVmQ291bnRlZE9i amVjdD4+IG1hcHBlZCA9IFdURjo6Y29tcGFjdE1hcCh2ZWN0b3IsIFtdKGludCB2YWx1ZSkgLT4g UmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+IHsKKyAgICAgICAgaWYgKHZhbHVlICUgMykKKyAgICAg ICAgICAgIHJldHVybiBudWxscHRyOworICAgICAgICByZXR1cm4gUmVmQ291bnRlZE9iamVjdDo6 Y3JlYXRlKHZhbHVlKTsKKyAgICB9KTsKKworICAgIEVYUEVDVF9FUSgwVSwgUmVmQ291bnRlZE9i amVjdDo6c190b3RhbFJlZkNvdW50KTsKKyAgICBFWFBFQ1RfRVEoM1UsIG1hcHBlZC5zaXplKCkp OworICAgIEVYUEVDVF9FUSgzLCBtYXBwZWRbMF0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEoNiwg bWFwcGVkWzFdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKDksIG1hcHBlZFsyXS0+dmFsdWUpOwor fQorCitURVNUKFdURl9WZWN0b3IsIENvbXBhY3RNYXBMYW1iZGFSZXR1cm5SZWZQdHJGcm9tTW92 ZWRSZWYpCit7CisgICAgVmVjdG9yPGludD4gdmVjdG9yIHsgMSwgMiwgMywgNCwgNSwgNiwgNywg OCwgOSwgMTAgfTsKKworICAgIGF1dG8gY291bnRlZE9iamVjdHMgPSBXVEY6Om1hcCh2ZWN0b3Is IFtdKGludCB2YWx1ZSkgLT4gUmVmPFJlZkNvdW50ZWRPYmplY3Q+IHsKKyAgICAgICAgcmV0dXJu IFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZSh2YWx1ZSk7CisgICAgfSk7CisKKyAgICBSZWZDb3Vu dGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291bnQgPSAwOworICAgIGF1dG8gbWFwcGVkID0gV1RGOjpj b21wYWN0TWFwKFdURk1vdmUoY291bnRlZE9iamVjdHMpLCBbXShSZWY8UmVmQ291bnRlZE9iamVj dD4mJiBvYmplY3QpIC0+IFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0PiB7CisgICAgICAgIGlmIChv YmplY3QtPnZhbHVlICUgMykKKyAgICAgICAgICAgIHJldHVybiBudWxscHRyOworICAgICAgICBy ZXR1cm4gV1RGTW92ZShvYmplY3QpOworICAgIH0pOworCisgICAgRVhQRUNUX0VRKDBVLCBSZWZD b3VudGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291bnQpOworICAgIEVYUEVDVF9FUSgzVSwgbWFwcGVk LnNpemUoKSk7CisgICAgRVhQRUNUX0VRKDMsIG1hcHBlZFswXS0+dmFsdWUpOworICAgIEVYUEVD VF9FUSg2LCBtYXBwZWRbMV0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEoOSwgbWFwcGVkWzJdLT52 YWx1ZSk7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgQ29tcGFjdE1hcExhbWJkYVJldHVybk9wdGlv bmFsUmVmUHRyKQoreworICAgIFZlY3RvcjxpbnQ+IHZlY3RvciB7IDEsIDIsIDMsIDQsIDUsIDYs IDcsIDgsIDksIDEwIH07CisKKyAgICBSZWZDb3VudGVkT2JqZWN0OjpzX3RvdGFsUmVmQ291bnQg PSAwOworCisgICAgVmVjdG9yPFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0Pj4gbWFwcGVkID0gV1RG Ojpjb21wYWN0TWFwKHZlY3RvciwgWyZdKGludCB2YWx1ZSkgLT4gT3B0aW9uYWw8UmVmUHRyPFJl ZkNvdW50ZWRPYmplY3Q+PiB7CisgICAgICAgIGlmICghKHZhbHVlICUgMikpCisgICAgICAgICAg ICByZXR1cm4gV1RGOjpudWxsb3B0OworICAgICAgICBpZiAoISh2YWx1ZSAlIDMpKQorICAgICAg ICAgICAgcmV0dXJuIFJlZlB0cjxSZWZDb3VudGVkT2JqZWN0PigpOworICAgICAgICByZXR1cm4g UmVmUHRyPFJlZkNvdW50ZWRPYmplY3Q+KFJlZkNvdW50ZWRPYmplY3Q6OmNyZWF0ZSh2YWx1ZSkp OworICAgIH0pOworCisgICAgRVhQRUNUX0VRKDBVLCBSZWZDb3VudGVkT2JqZWN0OjpzX3RvdGFs UmVmQ291bnQpOworICAgIEVYUEVDVF9FUSg1VSwgbWFwcGVkLnNpemUoKSk7CisgICAgRVhQRUNU X0VRKDEsIG1hcHBlZFswXS0+dmFsdWUpOworICAgIEVYUEVDVF9FUShudWxscHRyLCBtYXBwZWRb MV0pOworICAgIEVYUEVDVF9FUSg1LCBtYXBwZWRbMl0tPnZhbHVlKTsKKyAgICBFWFBFQ1RfRVEo NywgbWFwcGVkWzNdLT52YWx1ZSk7CisgICAgRVhQRUNUX0VRKG51bGxwdHIsIG1hcHBlZFs0XSk7 Cit9CisKIFRFU1QoV1RGX1ZlY3RvciwgQ29weVRvVmVjdG9yKQogewogICAgIEhhc2hTZXQ8aW50 PiBpbnRTZXQgeyAxLCAyLCAzIH07Cg==