204361 2019-11-19 10:43:45 -0800 HTTPHeaderMap's operator== is not fully correct 2019-11-22 16:15:19 -0800 1 1 1 Unclassified WebKit Page Loading WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 cdumez cdumez achristensen beidson commit-queue ggaren nham webkit-bug-importer youennf oldest_to_newest 1591591 0 cdumez 2019-11-19 10:43:45 -0800 HTTPHeaderMap's operator== is not fully correct. 1591592 1 cdumez 2019-11-19 10:44:34 -0800 Noticed by Ben. 1591597 2 383883 cdumez 2019-11-19 10:58:11 -0800 Created attachment 383883 Simpler Patch 1591627 3 nham 2019-11-19 11:59:39 -0800 I'm a bit nervous about switching to a quadratic time algorithm since the number of HTTP headers is unbounded. Maybe the fast path could be something like: - reject if # of headers is different - accept if vector comparison succeeds And the slow path could be: - build and sort temporary array of keys - accept/reject based on comparing sorted key/val pairs I removed the implementation of the function and the compiler told me this is used by: 1. ResourceRequestBase::equal 2. ResourceRequestBase::compare 3. operator== on NetworkLoadMetrics 4. NetworkCacheSpeculativeLoad::requestsHeadersMatch I don't have enough experience in the code base to know the code paths that use these methods, but (4) is on the critical path for speculative revalidation and loading. It's probably a good idea to run whatever patch we use on the perf bots because (4) can definitely impact PLT times. 1591635 4 nham 2019-11-19 12:04:06 -0800 My list should have been: 1. ResourceRequestBase::equal 2. ResourceResponseBase::compare 3. operator== on NetworkLoadMetrics 4. NetworkCacheSpeculativeLoad::requestsHeadersMatch 1591658 5 cdumez 2019-11-19 12:57:19 -0800 (In reply to Ben Nham from comment #3) > I'm a bit nervous about switching to a quadratic time algorithm since the > number of HTTP headers is unbounded. Maybe the fast path could be something > like: > > - reject if # of headers is different > - accept if vector comparison succeeds > > And the slow path could be: > > - build and sort temporary array of keys > - accept/reject based on comparing sorted key/val pairs > > I removed the implementation of the function and the compiler told me this > is used by: > > 1. ResourceRequestBase::equal > 2. ResourceRequestBase::compare > 3. operator== on NetworkLoadMetrics > 4. NetworkCacheSpeculativeLoad::requestsHeadersMatch > > I don't have enough experience in the code base to know the code paths that > use these methods, but (4) is on the critical path for speculative > revalidation and loading. > > It's probably a good idea to run whatever patch we use on the perf bots > because (4) can definitely impact PLT times. The number of headers is small which is why we switched from a hashmap to a vector in the first place. There was zero regression when we switched to a vector and started doing linear search for headers. I don’t think concerns are warranted here. 1592145 6 cdumez 2019-11-20 15:01:41 -0800 (In reply to Chris Dumez from comment #5) > (In reply to Ben Nham from comment #3) > > I'm a bit nervous about switching to a quadratic time algorithm since the > > number of HTTP headers is unbounded. Maybe the fast path could be something > > like: > > > > - reject if # of headers is different > > - accept if vector comparison succeeds > > > > And the slow path could be: > > > > - build and sort temporary array of keys > > - accept/reject based on comparing sorted key/val pairs > > > > I removed the implementation of the function and the compiler told me this > > is used by: > > > > 1. ResourceRequestBase::equal > > 2. ResourceRequestBase::compare > > 3. operator== on NetworkLoadMetrics > > 4. NetworkCacheSpeculativeLoad::requestsHeadersMatch > > > > I don't have enough experience in the code base to know the code paths that > > use these methods, but (4) is on the critical path for speculative > > revalidation and loading. > > > > It's probably a good idea to run whatever patch we use on the perf bots > > because (4) can definitely impact PLT times. > > The number of headers is small which is why we switched from a hashmap to a > vector in the first place. There was zero regression when we switched to a > vector and started doing linear search for headers. > > I don’t think concerns are warranted here. Early PLT5 A/B testing results show no regression on macOS or iOS. Ping review? 1592859 7 383883 achristensen 2019-11-22 10:05:26 -0800 Comment on attachment 383883 Simpler Patch Instead of introducing a quadratic algorithm, why don't we just sort both vectors before comparison? 1592870 8 cdumez 2019-11-22 10:23:53 -0800 (In reply to Alex Christensen from comment #7) > Comment on attachment 383883 [details] > Patch > > Instead of introducing a quadratic algorithm, why don't we just sort both > vectors before comparison? The number of headers is small, there is no perf impact on PLT from this change so it did not seem worth the extra complexity. 1592877 9 383883 achristensen 2019-11-22 10:33:43 -0800 Comment on attachment 383883 Simpler Patch A call to std::sort doesn't add much code complexity. Even though it didn't affect a data set that doesn't have a lot of header fields, JavaScript can add an arbitrarily large number of header fields. https://fetch.spec.whatwg.org/#terminology-headers 1592883 10 cdumez 2019-11-22 10:41:12 -0800 (In reply to Alex Christensen from comment #9) > Comment on attachment 383883 [details] > Patch > > A call to std::sort doesn't add much code complexity. Even though it didn't > affect a data set that doesn't have a lot of header fields, JavaScript can > add an arbitrarily large number of header fields. > https://fetch.spec.whatwg.org/#terminology-headers If you insist, but the perf will be worse in the common case. I will have to copy 4 vectors, sort them and then compare them with ==. 1592889 11 achristensen 2019-11-22 10:42:38 -0800 Can't you just sort them in-place? That will make 0 copies, and most of the time the headers will be completely sorted or mostly sorted. 1592891 12 cdumez 2019-11-22 10:44:26 -0800 (In reply to Chris Dumez from comment #10) > (In reply to Alex Christensen from comment #9) > > Comment on attachment 383883 [details] > > Patch > > > > A call to std::sort doesn't add much code complexity. Even though it didn't > > affect a data set that doesn't have a lot of header fields, JavaScript can > > add an arbitrarily large number of header fields. > > https://fetch.spec.whatwg.org/#terminology-headers > > If you insist, but the perf will be worse in the common case. I will have to > copy 4 vectors, sort them and then compare them with ==. Wouldn't it be weird for operator== to modify the 2 HTTPHeaderMaps it is comparing? Also, it could mean operator==() would take non-const to those HTTPHeaderMaps, which means some call sites will likely have to be updated to make copies 1592893 13 cdumez 2019-11-22 10:46:22 -0800 (In reply to Chris Dumez from comment #12) > (In reply to Chris Dumez from comment #10) > > (In reply to Alex Christensen from comment #9) > > > Comment on attachment 383883 [details] > > > Patch > > > > > > A call to std::sort doesn't add much code complexity. Even though it didn't > > > affect a data set that doesn't have a lot of header fields, JavaScript can > > > add an arbitrarily large number of header fields. > > > https://fetch.spec.whatwg.org/#terminology-headers > > > > If you insist, but the perf will be worse in the common case. I will have to > > copy 4 vectors, sort them and then compare them with ==. > > Wouldn't it be weird for operator== to modify the 2 HTTPHeaderMaps it is > comparing? Also, it could mean operator==() would take non-const to those > HTTPHeaderMaps, which means some call sites will likely have to be updated > to make copies Or maybe I can work around this by making m_uncommonHeaders / m_commonHeaders mutable.. 1592894 14 achristensen 2019-11-22 10:46:44 -0800 HTTPHeaderMap does not guarantee order right now. If it does, then its operator== is correct now. A little "mutable" or "const_cast" can make it so we never need to copy. 1592951 15 cdumez 2019-11-22 12:14:23 -0800 (In reply to Alex Christensen from comment #14) > HTTPHeaderMap does not guarantee order right now. If it does, then its > operator== is correct now. A little "mutable" or "const_cast" can make it > so we never need to copy. HTTPHeaderMap does have an iterator so this change is definitely not risk free, but let's try... 1592954 16 384183 cdumez 2019-11-22 12:36:54 -0800 Created attachment 384183 Patch 1592955 17 384183 achristensen 2019-11-22 12:40:25 -0800 Comment on attachment 384183 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=384183&action=review > Source/WebCore/platform/network/HTTPHeaderMap.h:202 > + std::sort(a.m_uncommonHeaders.begin(), a.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); > + std::sort(b.m_uncommonHeaders.begin(), b.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. 1592961 18 nham 2019-11-22 12:52:58 -0800 To me, const_cast-ing in operator== seems like it could lead to unexpected consequences if someone invokes operator== while iterating through the map (which is weird but could happen). After talking to Chris a bit more I am more convinced of his opinion that we should land his original patch to keep the complexity down. If this method becomes a problem in the future, then we could switch the whole implementation to use a hash map, or have some slow path that kicks in and builds a temporary hash map in the implementation of operator== for large amounts of headers. 1592967 19 384183 achristensen 2019-11-22 13:04:16 -0800 Comment on attachment 384183 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=384183&action=review All right. >> Source/WebCore/platform/network/HTTPHeaderMap.h:202 >> + std::sort(a.m_uncommonHeaders.begin(), a.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); >> + std::sort(b.m_uncommonHeaders.begin(), b.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); > > You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. 1592972 20 cdumez 2019-11-22 13:12:52 -0800 (In reply to Alex Christensen from comment #19) > Comment on attachment 384183 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=384183&action=review > > All right. > > >> Source/WebCore/platform/network/HTTPHeaderMap.h:202 > >> + std::sort(a.m_uncommonHeaders.begin(), a.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); > >> + std::sort(b.m_uncommonHeaders.begin(), b.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); > > > > You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. > > You should be able to just put WTF::codePointCompareLessThan instead of a > lambda that wraps it. The reason I need a lambda is to extra the 'key' data member from the CommonHeader / UncommonHeader struct. For the record, I don't really like where this patch ended up. I feel like modifying the internal representation in an operator==() is super scary and bound to bite us someday. All this for doubtful performance benefits. Also, if we had concerns about having a ton of headers, the fix would not be at operator==() level, but at get() level, because get() would be super slow too (which is why my previous implementation of operator==() relied on get()). 1593013 21 384183 ggaren 2019-11-22 14:31:16 -0800 Comment on attachment 384183 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=384183&action=review >>>> Source/WebCore/platform/network/HTTPHeaderMap.h:202 >>>> + std::sort(b.m_uncommonHeaders.begin(), b.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); >>> >>> You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. >> >> You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. > > The reason I need a lambda is to extra the 'key' data member from the CommonHeader / UncommonHeader struct. > > For the record, I don't really like where this patch ended up. I feel like modifying the internal representation in an operator==() is super scary and bound to bite us someday. All this for doubtful performance benefits. Also, if we had concerns about having a ton of headers, the fix would not be at operator==() level, but at get() level, because get() would be super slow too (which is why my previous implementation of operator==() relied on get()). I don't want to stand in the way of landing this, but I tend to agree that modifying the object in == is weird, and the potential performance issue isn't limited to ==. I guess you could copy out the values and sort the copies to avoid weirdness. But maybe just accepting that get() is linear is OK in this case. 🤷🏻‍♂️ 1593018 22 384183 cdumez 2019-11-22 14:37:12 -0800 Comment on attachment 384183 Patch This actually is not right anymore because header names are not case sensitive. 1593024 23 cdumez 2019-11-22 14:45:25 -0800 (In reply to Chris Dumez from comment #22) > Comment on attachment 384183 [details] > Patch > > This actually is not right anymore because header names are not case > sensitive. Will extend the test case to cover this. 1593026 24 cdumez 2019-11-22 14:49:11 -0800 (In reply to Geoffrey Garen from comment #21) > Comment on attachment 384183 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=384183&action=review > > >>>> Source/WebCore/platform/network/HTTPHeaderMap.h:202 > >>>> + std::sort(b.m_uncommonHeaders.begin(), b.m_uncommonHeaders.end(), [](auto& headerA, auto& headerB) { return WTF::codePointCompareLessThan(headerA.key, headerB.key); }); > >>> > >>> You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. > >> > >> You should be able to just put WTF::codePointCompareLessThan instead of a lambda that wraps it. > > > > The reason I need a lambda is to extra the 'key' data member from the CommonHeader / UncommonHeader struct. > > > > For the record, I don't really like where this patch ended up. I feel like modifying the internal representation in an operator==() is super scary and bound to bite us someday. All this for doubtful performance benefits. Also, if we had concerns about having a ton of headers, the fix would not be at operator==() level, but at get() level, because get() would be super slow too (which is why my previous implementation of operator==() relied on get()). > > I don't want to stand in the way of landing this, but I tend to agree that > modifying the object in == is weird, and the potential performance issue > isn't limited to ==. I guess you could copy out the values and sort the > copies to avoid weirdness. But maybe just accepting that get() is linear is > OK in this case. 🤷🏻‍♂️ If people feel strongly about avoiding the linear search, maybe we can have a code path that does the linear search only if the vectors are small (e.g. <= 16), and fallback to constructing a HashMap in operator==() otherwise, to avoid pathological cases. 1593035 25 384202 cdumez 2019-11-22 15:04:18 -0800 Created attachment 384202 Alternative Patch dealing with large maps 1593038 26 384203 cdumez 2019-11-22 15:06:25 -0800 Created attachment 384203 Alternative Patch dealing with large maps 1593041 27 384203 achristensen 2019-11-22 15:08:27 -0800 Comment on attachment 384203 Alternative Patch dealing with large maps View in context: https://bugs.webkit.org/attachment.cgi?id=384203&action=review > Source/WebCore/platform/network/HTTPHeaderMap.cpp:228 > + bool isVectorSmall = m_commonHeaders.size() <= 16; m_uncommonHeaders has the unbounded size. I like the other patch. 1593043 28 383883 achristensen 2019-11-22 15:09:45 -0800 Comment on attachment 383883 Simpler Patch View in context: https://bugs.webkit.org/attachment.cgi?id=383883&action=review > Source/WebCore/platform/network/HTTPHeaderMap.h:193 > + if (a.m_commonHeaders.size() != b.m_commonHeaders.size() || a.m_uncommonHeaders.size() != b.m_uncommonHeaders.size()) It might be worth adding another fast path for if the vectors are actually equal, to have a O(N) possibility that returns true. 1593059 29 384206 cdumez 2019-11-22 15:22:50 -0800 Created attachment 384206 Patch 1593085 30 384206 cdumez 2019-11-22 16:04:12 -0800 Comment on attachment 384206 Patch Clearing flags on attachment: 384206 Committed r252813: <https://trac.webkit.org/changeset/252813> 1593086 31 cdumez 2019-11-22 16:04:14 -0800 All reviewed patches have been landed. Closing bug. 1593089 32 webkit-bug-importer 2019-11-22 16:05:29 -0800 <rdar://problem/57444366> 383883 2019-11-19 10:58:11 -0800 2019-11-22 15:22:47 -0800 Simpler Patch bug-204361-20191119105810.patch text/plain 12725 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjUyNjM2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzBlZDViODE1YzM1ZDA1 NjFkZWNjYzJjOGNlMTIwYWE5ZDBkYTY3MC4uMTllOGVjOTUzOGI3NjQ5MjUxOWE5NmI4MDRhNDkz NTBlOTI1OWUzOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE5LTExLTE5ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSFRUUEhlYWRlck1hcCdzIG9w ZXJhdG9yPT0gaXMgbm90IGZ1bGx5IGNvcnJlY3QKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDM2MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIElmIGhlYWRlcnMgYXJlIGFkZGVkIGluIGEgZGlmZmVyZW50 IG9yZGVyLCBIVFRQSGVhZGVyTWFwJ3Mgb3BlcmF0b3I9PSgpIHdvdWxkIHdyb25nbHkKKyAgICAg ICAgcmV0dXJuIGZhbHNlIGJlY2F1c2UgaXQgaXMgdXNpbmcgYSBWZWN0b3IgaW50ZXJuYWxseSB0 byBzdG9yZSB0aGUgaGVhZGVycy4KKworICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvSFRUUEhl YWRlck1hcC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVFRQSGVhZGVyTWFwOjpnZXQgY29uc3Qp OgorICAgICAgICAoV2ViQ29yZTo6SFRUUEhlYWRlck1hcDo6Z2V0VW5jb21tb25IZWFkZXIgY29u c3QpOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5oOgorICAgICAg ICAoV2ViQ29yZTo6SFRUUEhlYWRlck1hcDo6b3BlcmF0b3I9PSk6CisKIDIwMTktMTEtMTkgIFNp aHVpIExpdSAgPHNpaHVpX2xpdUBhcHBsZS5jb20+CiAKICAgICAgICAgVXBkYXRlIGV4cGVjdGF0 aW9ucyBmb3IgYnVmZmVyZWRBbW91bnQtdW5jaGFuZ2VkLWJ5LXN5bmMteGhyLmFueS53b3JrZXIu aHRtbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVh ZGVyTWFwLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1h cC5jcHAKaW5kZXggMWU5NzlmODEyM2Q2YzM1NzMwNzgxNDc0YzlhZGI0M2Q4Yzg3MWJiOS4uMzlj YjU2MGU1NGJmOWVmZDJkYWQ2ZTFmYjYwZGQwZjYwOWRhZjZiZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFkZXJNYXAuY3BwCkBAIC01NSw2ICs1NSwx MSBAQCBTdHJpbmcgSFRUUEhlYWRlck1hcDo6Z2V0KGNvbnN0IFN0cmluZyYgbmFtZSkgY29uc3QK ICAgICBpZiAoZmluZEhUVFBIZWFkZXJOYW1lKG5hbWUsIGhlYWRlck5hbWUpKQogICAgICAgICBy ZXR1cm4gZ2V0KGhlYWRlck5hbWUpOwogCisgICAgcmV0dXJuIGdldFVuY29tbW9uSGVhZGVyKG5h bWUpOworfQorCitTdHJpbmcgSFRUUEhlYWRlck1hcDo6Z2V0VW5jb21tb25IZWFkZXIoY29uc3Qg U3RyaW5nJiBuYW1lKSBjb25zdAorewogICAgIGF1dG8gaW5kZXggPSBtX3VuY29tbW9uSGVhZGVy cy5maW5kTWF0Y2hpbmcoWyZdKGF1dG8mIGhlYWRlcikgewogICAgICAgICByZXR1cm4gZXF1YWxJ Z25vcmluZ0FTQ0lJQ2FzZShoZWFkZXIua2V5LCBuYW1lKTsKICAgICB9KTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmgKaW5kZXggMGJkMDQyOTk0 NjcwNGVjMDdjZjk1ZGRlZGMzNzZmOTFhMzdmMjM1My4uNjAwMDc0NTk5N2U1NTVkYzI4Y2FhYzE0 MGVlNWMyM2Y2MzdhOGI5NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9IVFRQSGVhZGVyTWFwLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9IVFRQSGVhZGVyTWFwLmgKQEAgLTE1OCw3ICsxNTgsNyBAQCBwdWJsaWM6CiAgICAgV0VCQ09S RV9FWFBPUlQgdm9pZCBhZGQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVl KTsKICAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGFwcGVuZChjb25zdCBTdHJpbmcmIG5hbWUsIGNv bnN0IFN0cmluZyYgdmFsdWUpOwogICAgIFdFQkNPUkVfRVhQT1JUIGJvb2wgY29udGFpbnMoY29u c3QgU3RyaW5nJikgY29uc3Q7Ci0gICAgYm9vbCByZW1vdmUoY29uc3QgU3RyaW5nJik7CisgICAg V0VCQ09SRV9FWFBPUlQgYm9vbCByZW1vdmUoY29uc3QgU3RyaW5nJik7CiAKICNpZiBVU0UoQ0Yp CiAgICAgdm9pZCBzZXQoQ0ZTdHJpbmdSZWYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSk7CkBA IC0xOTAsNyArMTkwLDE3IEBAIHB1YmxpYzoKIAogICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0o Y29uc3QgSFRUUEhlYWRlck1hcCYgYSwgY29uc3QgSFRUUEhlYWRlck1hcCYgYikKICAgICB7Ci0g ICAgICAgIHJldHVybiBhLm1fY29tbW9uSGVhZGVycyA9PSBiLm1fY29tbW9uSGVhZGVycyAmJiBh Lm1fdW5jb21tb25IZWFkZXJzID09IGIubV91bmNvbW1vbkhlYWRlcnM7CisgICAgICAgIGlmIChh Lm1fY29tbW9uSGVhZGVycy5zaXplKCkgIT0gYi5tX2NvbW1vbkhlYWRlcnMuc2l6ZSgpIHx8IGEu bV91bmNvbW1vbkhlYWRlcnMuc2l6ZSgpICE9IGIubV91bmNvbW1vbkhlYWRlcnMuc2l6ZSgpKQor ICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICBmb3IgKGF1dG8mIGNvbW1vbkhlYWRl ciA6IGEubV9jb21tb25IZWFkZXJzKSB7CisgICAgICAgICAgICBpZiAoYi5nZXQoY29tbW9uSGVh ZGVyLmtleSkgIT0gY29tbW9uSGVhZGVyLnZhbHVlKQorICAgICAgICAgICAgICAgIHJldHVybiBm YWxzZTsKKyAgICAgICAgfQorICAgICAgICBmb3IgKGF1dG8mIHVuY29tbW9uSGVhZGVyIDogYS5t X3VuY29tbW9uSGVhZGVycykgeworICAgICAgICAgICAgaWYgKGIuZ2V0VW5jb21tb25IZWFkZXIo dW5jb21tb25IZWFkZXIua2V5KSAhPSB1bmNvbW1vbkhlYWRlci52YWx1ZSkKKyAgICAgICAgICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIHRydWU7CiAgICAg fQogCiAgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3IhPShjb25zdCBIVFRQSGVhZGVyTWFwJiBhLCBj b25zdCBIVFRQSGVhZGVyTWFwJiBiKQpAQCAtMjAzLDYgKzIxMyw3IEBAIHB1YmxpYzoKIAogcHJp dmF0ZToKICAgICB2b2lkIHNldFVuY29tbW9uSGVhZGVyKGNvbnN0IFN0cmluZyYgbmFtZSwgY29u c3QgU3RyaW5nJiB2YWx1ZSk7CisgICAgV0VCQ09SRV9FWFBPUlQgU3RyaW5nIGdldFVuY29tbW9u SGVhZGVyKGNvbnN0IFN0cmluZyYgbmFtZSkgY29uc3Q7CiAKICAgICBDb21tb25IZWFkZXJzVmVj dG9yIG1fY29tbW9uSGVhZGVyczsKICAgICBVbmNvbW1vbkhlYWRlcnNWZWN0b3IgbV91bmNvbW1v bkhlYWRlcnM7CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cK aW5kZXggZTU0MzRhYWI0N2FiZWQ2ZTBiMmVlNTY1OGQ0ZWM4MjU2ZDU4N2I3Zi4uNjUzMzY1M2Jm YTdhZmJhODE2MGEzMzEyODNlNGJiN2JhZmFiM2QxYyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdl TG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDE5LTExLTE5ICBD aHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSFRUUEhlYWRlck1hcCdz IG9wZXJhdG9yPT0gaXMgbm90IGZ1bGx5IGNvcnJlY3QKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDM2MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBBUEkgdGVzdCBjb3ZlcmFnZS4KKworICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q OgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9IVFRQSGVhZGVyTWFwLmNw cDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKwogMjAxOS0xMS0xOSAg QnJpYW4gQnVyZyAgPGJidXJnQGFwcGxlLmNvbT4KIAogICAgICAgICBbQ29jb2FdIEFkZCBXS1VJ RGVsZWdhdGUgU1BJIHRvIGluZm9ybSBjbGllbnRzIHdoZW4gYSBfV0tJbnNwZWN0b3IgYXR0YWNo ZXMgdG8gYSBXS1dlYlZpZXcKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdl YktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNzMxOWQyZmM0OTcw ZWM0ZWViY2QwMTE0YTM0MDcwZjVhZGRkMWEwNC4uNTQ5NTgzYWQwNjdlODhhYTRjYmQxYzE3YTcz ZWFlMzlmNWU2ODM4MyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0 QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTI0Niw2ICsyNDYsNyBA QAogCQk0NkU2NkE5MDFGMEQ3NTU5MDAyNkQ4M0MgLyogV0tXZWJWaWV3RGlhZ25vc3RpY0xvZ2dp bmcubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NkU2 NkE4RjFGMEQ3NTU5MDAyNkQ4M0MgLyogV0tXZWJWaWV3RGlhZ25vc3RpY0xvZ2dpbmcubW0gKi87 IH07CiAJCTQ2RTgxNkY4MUU3OUUyOUMwMDM3NUFEQyAvKiBSZXN0b3JlU3RhdGVBZnRlclRlcm1p bmF0aW9uLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NDZFODE2RjcxRTc5RTI5MTAwMzc1QURDIC8qIFJlc3RvcmVTdGF0ZUFmdGVyVGVybWluYXRpb24u bW0gKi87IH07CiAJCTQ2RUJEODQ3MjM3MjMyMEYwMDIyM0E2RSAvKiBSZXN0b3JlU2Nyb2xsUG9z aXRpb24ubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0 NkVCRDg0NjIzNzIzMUU2MDAyMjNBNkUgLyogUmVzdG9yZVNjcm9sbFBvc2l0aW9uLm1tICovOyB9 OworCQk0NkZBMkZFRTIzODQ2Q0E1MDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NkZBMkZFRDIzODQ2QzlB MDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAgKi87IH07CiAJCTQ5MDlFRTNBMkQwOTQ4MEM4 ODk4MkQ1NiAvKiBNYXJrYWJsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBFQzc5RjE2OEJFNDU0RTU3OUU0MTdCMDUgLyogTWFya2FibGUuY3BwICov OyB9OwogCQk0QkZERkZBNzEzMTQ3NzZDMDA2MUYyNEIgLyogSGl0VGVzdFJlc3VsdE5vZGVIYW5k bGVfQnVuZGxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDRCRkRGRkE2MTMxNDc3NkMwMDYxRjI0QiAvKiBIaXRUZXN0UmVzdWx0Tm9kZUhhbmRsZV9C dW5kbGUuY3BwICovOyB9OwogCQk1MTA0Nzc3MjFEMjk4REREMDA5NzQ3RUIgLyogSURCRGVsZXRl UmVjb3Zlcnkuc3FsaXRlMyBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1MTA0Nzc2RjFEMjk4RDg1MDA5NzQ3RUIgLyogSURCRGVsZXRlUmVjb3Zl cnkuc3FsaXRlMyAqLzsgfTsKQEAgLTExNDIsNyArMTE0Myw2IEBACiAJCQlkc3RQYXRoID0gVGVz dFdlYktpdEFQSS5yZXNvdXJjZXM7CiAJCQlkc3RTdWJmb2xkZXJTcGVjID0gNzsKIAkJCWZpbGVz ID0gKAotCQkJCUNEODM5NERGMjMyQUY3QzAwMDE0OTQ5NSAvKiBtZWRpYS1sb2FkaW5nLmh0bWwg aW4gQ29weSBSZXNvdXJjZXMgKi8sCiAJCQkJNTVBODE3RkYyMTgxMDIxQTAwMDRBMzlBIC8qIDEw MHgxMDAtcmVkLnRnYSBpbiBDb3B5IFJlc291cmNlcyAqLywKIAkJCQkxQTlFNTJDOTEzRTY1RUY0 MDA2OTE3RjUgLyogMTgtY2hhcmFjdGVycy5odG1sIGluIENvcHkgUmVzb3VyY2VzICovLAogCQkJ CTU1QTgxODAwMjE4MTAyMjEwMDA0QTM5QSAvKiA0MDB4NDAwLWdyZWVuLnBuZyBpbiBDb3B5IFJl c291cmNlcyAqLywKQEAgLTEzNzUsNiArMTM3NSw3IEBACiAJCQkJOTMwQUQ0MDIxNTA2OThEMDAw Njc5NzBGIC8qIGxvdHMtb2YtdGV4dC5odG1sIGluIENvcHkgUmVzb3VyY2VzICovLAogCQkJCUFE NTdBQzIyMURBNzQ2NkUwMEZGMUJERSAvKiBtYW55LWlmcmFtZXMuaHRtbCBpbiBDb3B5IFJlc291 cmNlcyAqLywKIAkJCQk3NzcyRUNFMTIyRkUwNkM2MDAwOUE3OTkgLyogbWFueS1zYW1lLW9yaWdp bi1pZnJhbWVzLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCisJCQkJQ0Q4Mzk0REYyMzJBRjdD MDAwMTQ5NDk1IC8qIG1lZGlhLWxvYWRpbmcuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLywKIAkJ CQlDREEzMTU5QTFFRDU0OEYxMDA5RjYwRDMgLyogTWVkaWFQbGF5YmFja1NsZWVwQXNzZXJ0aW9u Lmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCiAJCQkJQ0RDOTQ0MkYxRUYyMDVENjAwNTlDM0M0 IC8qIG1lZGlhc3RyZWFtdHJhY2stZGV0YWNoZWQuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLywK IAkJCQlFMTIyMERDQTE1NUIyOEFBMDAxM0UyRkMgLyogTWVtb3J5Q2FjaGVEaXNhYmxlV2l0aGlu UmVzb3VyY2VMb2FkRGVsZWdhdGUuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLywKQEAgLTE3Nzks NiArMTc4MCw3IEBACiAJCTQ2RTY2QThGMUYwRDc1NTkwMDI2RDgzQyAvKiBXS1dlYlZpZXdEaWFn bm9zdGljTG9nZ2luZy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9 IFdLV2ViVmlld0RpYWdub3N0aWNMb2dnaW5nLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk0NkU4MTZGNzFFNzlFMjkxMDAzNzVBREMgLyogUmVzdG9yZVN0YXRlQWZ0ZXJUZXJtaW5h dGlvbi5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFJlc3RvcmVT dGF0ZUFmdGVyVGVybWluYXRpb24ubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ2 RUJEODQ2MjM3MjMxRTYwMDIyM0E2RSAvKiBSZXN0b3JlU2Nyb2xsUG9zaXRpb24ubW0gKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBSZXN0b3JlU2Nyb2xsUG9zaXRpb24u bW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ2RkEyRkVEMjM4NDZDOUEwMDBDQ0Iw QyAvKiBIVFRQSGVhZGVyTWFwLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IEhUVFBIZWFkZXJNYXAuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0QTQx MEY0QjE5QUY3QkQ2MDAyRUJBQjUgLyogVXNlck1lZGlhLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IFVzZXJNZWRpYS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCTRBNDEwRjREMTlBRjdCRUYwMDJFQkFCNSAvKiBnZXRVc2VyTWVkaWEuaHRtbCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IGdldFVzZXJNZWRpYS5odG1sOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk0QTQxMEY0RDE5QUY3QkVGMDAyRUJBQjYgLyogb25kZXZpY2VjaGFu Z2UuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IG9uZGV2aWNlY2hhbmdlLmh0bWw7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zMTA1LDYgKzMxMDcsNyBAQAogCQkJCThF NEE4NTM2MUUxRDFBQTEwMEY1M0IwRiAvKiBHcmlkUG9zaXRpb24uY3BwICovLAogCQkJCTgzQjg4 QTMzMUM4MDA1NkQwMEJCMjQxOCAvKiBIVE1MUGFyc2VySWRpb21zLmNwcCAqLywKIAkJCQk1Q0Ex REVDNzFGNzFGNDA3MDBFNzFCRDMgLyogSFRUUEhlYWRlckZpZWxkLmNwcCAqLywKKwkJCQk0NkZB MkZFRDIzODQ2QzlBMDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAgKi8sCiAJCQkJNkI5QUJF MTEyMDg2OTUyRjAwRDc1REU2IC8qIEhUVFBQYXJzZXJzLmNwcCAqLywKIAkJCQk3QTkwOUE3MzFE ODc3NDc1MDA3RTEwRjggLyogSW50UG9pbnQuY3BwICovLAogCQkJCTdBOTA5QTc0MUQ4Nzc0NzUw MDdFMTBGOCAvKiBJbnRSZWN0LmNwcCAqLywKQEAgLTM4NTIsNiArMzg1NSw3IEBACiAJCQkJOTMw QUQ0MDExNTA2OThCMzAwNjc5NzBGIC8qIGxvdHMtb2YtdGV4dC5odG1sICovLAogCQkJCUFENTdB QzFEMURBNzQ2MzgwMEZGMUJERSAvKiBtYW55LWlmcmFtZXMuaHRtbCAqLywKIAkJCQk3NzcyRUNF MDIyRkUwNUUxMDAwOUE3OTkgLyogbWFueS1zYW1lLW9yaWdpbi1pZnJhbWVzLmh0bWwgKi8sCisJ CQkJQ0Q4Mzk0REUyMzJBRjE1RTAwMTQ5NDk1IC8qIG1lZGlhLWxvYWRpbmcuaHRtbCAqLywKIAkJ CQlDREM5NDQyQjFFRjFGQkQyMDA1OUMzQzQgLyogbWVkaWFzdHJlYW10cmFjay1kZXRhY2hlZC5o dG1sICovLAogCQkJCTUxQ0QxQzcxMUIzOEQ0ODQwMDE0MkNBNSAvKiBtb2RhbC1hbGVydHMtaW4t bmV3LWFib3V0LWJsYW5rLXdpbmRvdy5odG1sICovLAogCQkJCTdBMTQ1OEZCMUFENUMwMzUwMEUw Njc3MiAvKiBtb3VzZS1idXR0b24tbGlzdGVuZXIuaHRtbCAqLywKQEAgLTM4ODMsNyArMzg4Nyw2 IEBACiAJCQkJMDdDRDMyRjcyMDY1QjcyQTAwNjRBNEJFIC8qIHZpZGVvLmh0bWwgKi8sCiAJCQkJ MUMyQjgxODQxQzg5MjRBMjAwQTU1MjlGIC8qIHdlYmZvbnQuaHRtbCAqLywKIAkJCQk0NjhGMkY5 MzIzNjhEQUE3MDBGNEI4NjQgLyogd2luZG93LW9wZW4tdGhlbi1kb2N1bWVudC1vcGVuLmh0bWwg Ki8sCi0JCQkJQ0Q4Mzk0REUyMzJBRjE1RTAwMTQ5NDk1IC8qIG1lZGlhLWxvYWRpbmcuaHRtbCAq LywKIAkJCSk7CiAJCQluYW1lID0gUmVzb3VyY2VzOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsKQEAgLTQ2NzAsNiArNDY3Myw3IEBACiAJCQkJN0NDRTdFQzIxQTQxMUE3RTAwNDQ3QzRDIC8q IEhUTUxGb3JtQ29sbGVjdGlvbk5hbWVkSXRlbS5tbSBpbiBTb3VyY2VzICovLAogCQkJCTdDODNF MDUwMUQwQTY0MTgwMEZFQkNGMyAvKiBIVE1MUGFyc2VySWRpb21zLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTVDQTFERUM4MUY3MUY3MDEwMEU3MUJEMyAvKiBIVFRQSGVhZGVyRmllbGQuY3BwIGlu IFNvdXJjZXMgKi8sCisJCQkJNDZGQTJGRUUyMzg0NkNBNTAwMENDQjBDIC8qIEhUVFBIZWFkZXJN YXAuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNkI5QUJFMTIyMDg2OTUyRjAwRDc1REU2IC8qIEhU VFBQYXJzZXJzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTVDN0MyNEZDMjM3Qzk3NTQwMDU5OUM5 MSAvKiBIVFRQU2VydmVyLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNTFBRjIzREYxRUYxQTM3MzAw NzJGMjgxIC8qIEljb25Mb2FkaW5nRGVsZWdhdGUubW0gaW4gU291cmNlcyAqLywKZGlmZiAtLWdp dCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9IVFRQSGVhZGVyTWFwLmNwcCBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9IVFRQSGVhZGVyTWFwLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi4yYTI3YTEyN2FkNTcxMjJjYzMzZDI4NTU1OGVmODgyMDQ4ZTU2MDE5Ci0tLSAvZGV2 L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0hUVFBIZWFkZXJN YXAuY3BwCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgQXBwbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUK KyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERB VEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJUZXN0LmgiCisj aW5jbHVkZSA8V2ViQ29yZS9IVFRQSGVhZGVyTWFwLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJD b3JlOworCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK1RFU1QoSFRUUEhlYWRlck1hcCwg Q29tcGFyaXNvbk9wZXJhdG9yKQoreworICAgIEhUVFBIZWFkZXJNYXAgbWFwMTsKKyAgICBIVFRQ SGVhZGVyTWFwIG1hcDI7CisKKyAgICBtYXAxLmFkZCgiQ2FjaGUtQ29udHJvbCJfc3RyLCAibWF4 LWFnZTowIl9zdHIpOworICAgIG1hcDEuYWRkKCJFVGFnIl9zdHIsICJmb28iX3N0cik7CisgICAg bWFwMS5hZGQoIk5vdC1Db21tb24xIl9zdHIsICJiYXIiX3N0cik7CisgICAgbWFwMS5hZGQoIk5v dC1Db21tb24yIl9zdHIsICJiYXIiX3N0cik7CisKKyAgICBtYXAyLmFkZCgiRVRhZyJfc3RyLCAi Zm9vIl9zdHIpOworICAgIG1hcDIuYWRkKCJDYWNoZS1Db250cm9sIl9zdHIsICJtYXgtYWdlOjAi X3N0cik7CisgICAgbWFwMi5hZGQoIk5vdC1Db21tb24yIl9zdHIsICJiYXIiX3N0cik7CisgICAg bWFwMi5hZGQoIk5vdC1Db21tb24xIl9zdHIsICJiYXIiX3N0cik7CisKKyAgICBFWFBFQ1RfVFJV RShtYXAxID09IG1hcDIpOworICAgIEVYUEVDVF9GQUxTRShtYXAxICE9IG1hcDIpOworCisgICAg bWFwMS5hZGQoIkxhc3QtTW9kaWZpZWQiX3N0ciwgIjEyMzQ1NSJfc3RyKTsKKyAgICBtYXAyLmFk ZCgiTGFzdC1Nb2RpZmllZCJfc3RyLCAiMTIzNDU2Il9zdHIpOworICAgIEVYUEVDVF9GQUxTRSht YXAxID09IG1hcDIpOworICAgIEVYUEVDVF9UUlVFKG1hcDEgIT0gbWFwMik7CisKKyAgICBtYXAx LnJlbW92ZSgiTGFzdC1Nb2RpZmllZCJfc3RyKTsKKyAgICBtYXAyLnJlbW92ZSgiTGFzdC1Nb2Rp ZmllZCJfc3RyKTsKKyAgICBFWFBFQ1RfVFJVRShtYXAxID09IG1hcDIpOworICAgIEVYUEVDVF9G QUxTRShtYXAxICE9IG1hcDIpOworCisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24zIl9zdHIsICJi YXIiX3N0cik7CisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24zIl9zdHIsICJiYXoiX3N0cik7Cisg ICAgRVhQRUNUX0ZBTFNFKG1hcDEgPT0gbWFwMik7CisgICAgRVhQRUNUX1RSVUUobWFwMSAhPSBt YXAyKTsKK30KKworfQo= 384183 2019-11-22 12:36:54 -0800 2019-11-22 14:37:32 -0800 Patch bug-204361-20191122123646.patch text/plain 12544 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjUyNzgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWM4ZWVmNGRmYTgyYWMx MTA4NjZjODNmNDk1Y2ExMGFmYTk1MWIyYy4uNGU3MGZkNzJiOTQ1YjIzNjdjNTRhN2RkNjU1NDI3 Y2UwMmQ3ZTE2ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE5LTExLTIyICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSFRUUEhlYWRlck1hcCdzIG9w ZXJhdG9yPT0gaXMgbm90IGZ1bGx5IGNvcnJlY3QKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDM2MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIElmIGhlYWRlcnMgYXJlIGFkZGVkIGluIGEgZGlmZmVyZW50 IG9yZGVyLCBIVFRQSGVhZGVyTWFwJ3Mgb3BlcmF0b3I9PSgpIHdvdWxkIHdyb25nbHkKKyAgICAg ICAgcmV0dXJuIGZhbHNlIGJlY2F1c2UgaXQgaXMgdXNpbmcgYSBWZWN0b3IgaW50ZXJuYWxseSB0 byBzdG9yZSB0aGUgaGVhZGVycy4KKworICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvSFRUUEhl YWRlck1hcC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVFRQSGVhZGVyTWFwOjpnZXQgY29uc3Qp OgorICAgICAgICAoV2ViQ29yZTo6SFRUUEhlYWRlck1hcDo6Z2V0VW5jb21tb25IZWFkZXIgY29u c3QpOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5oOgorICAgICAg ICAoV2ViQ29yZTo6SFRUUEhlYWRlck1hcDo6b3BlcmF0b3I9PSk6CisKIDIwMTktMTEtMjIgIFph bGFuIEJ1anRhcyAgPHphbGFuQGFwcGxlLmNvbT4KIAogICAgICAgICBbTEZDXVtJRkNdIExpbmU6 OmlubGluZUl0ZW1Db250ZW50SGVpZ2h0IHNob3VsZCBvbmx5IGNhbGwgRm9ybWF0dGluZ0NvbnRl eHQ6Omdlb21ldHJ5Rm9yQm94IHdoZW4gbmVlZGVkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFkZXJNYXAuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5oCmluZGV4IDBiZDA0Mjk5NDY3MDRlYzA3Y2Y5NWRk ZWRjMzc2ZjkxYTM3ZjIzNTMuLjNjYjgyNGYwZmQ4ZjBlZDlmMTUxNmNiZjhlODJlZGVjNTdmZTlk M2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRl ck1hcC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1h cC5oCkBAIC0xNTgsNyArMTU4LDcgQEAgcHVibGljOgogICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQg YWRkKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSk7CiAgICAgV0VCQ09S RV9FWFBPUlQgdm9pZCBhcHBlbmQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZh bHVlKTsKICAgICBXRUJDT1JFX0VYUE9SVCBib29sIGNvbnRhaW5zKGNvbnN0IFN0cmluZyYpIGNv bnN0OwotICAgIGJvb2wgcmVtb3ZlKGNvbnN0IFN0cmluZyYpOworICAgIFdFQkNPUkVfRVhQT1JU IGJvb2wgcmVtb3ZlKGNvbnN0IFN0cmluZyYpOwogCiAjaWYgVVNFKENGKQogICAgIHZvaWQgc2V0 KENGU3RyaW5nUmVmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmFsdWUpOwpAQCAtMTkwLDcgKzE5MCwy MCBAQCBwdWJsaWM6CiAKICAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IEhUVFBIZWFk ZXJNYXAmIGEsIGNvbnN0IEhUVFBIZWFkZXJNYXAmIGIpCiAgICAgewotICAgICAgICByZXR1cm4g YS5tX2NvbW1vbkhlYWRlcnMgPT0gYi5tX2NvbW1vbkhlYWRlcnMgJiYgYS5tX3VuY29tbW9uSGVh ZGVycyA9PSBiLm1fdW5jb21tb25IZWFkZXJzOworICAgICAgICBpZiAoYS5tX2NvbW1vbkhlYWRl cnMuc2l6ZSgpICE9IGIubV9jb21tb25IZWFkZXJzLnNpemUoKSB8fCBhLm1fdW5jb21tb25IZWFk ZXJzLnNpemUoKSAhPSBiLm1fdW5jb21tb25IZWFkZXJzLnNpemUoKSkKKyAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKKworICAgICAgICBzdGQ6OnNvcnQoYS5tX2NvbW1vbkhlYWRlcnMuYmVnaW4o KSwgYS5tX2NvbW1vbkhlYWRlcnMuZW5kKCksIFtdKGF1dG8mIGhlYWRlckEsIGF1dG8mIGhlYWRl ckIpIHsgcmV0dXJuIGhlYWRlckEua2V5IDwgaGVhZGVyQi5rZXk7IH0pOworICAgICAgICBzdGQ6 OnNvcnQoYi5tX2NvbW1vbkhlYWRlcnMuYmVnaW4oKSwgYi5tX2NvbW1vbkhlYWRlcnMuZW5kKCks IFtdKGF1dG8mIGhlYWRlckEsIGF1dG8mIGhlYWRlckIpIHsgcmV0dXJuIGhlYWRlckEua2V5IDwg aGVhZGVyQi5rZXk7IH0pOworICAgICAgICBpZiAoYS5tX2NvbW1vbkhlYWRlcnMgIT0gYi5tX2Nv bW1vbkhlYWRlcnMpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAgICAgc3RkOjpz b3J0KGEubV91bmNvbW1vbkhlYWRlcnMuYmVnaW4oKSwgYS5tX3VuY29tbW9uSGVhZGVycy5lbmQo KSwgW10oYXV0byYgaGVhZGVyQSwgYXV0byYgaGVhZGVyQikgeyByZXR1cm4gV1RGOjpjb2RlUG9p bnRDb21wYXJlTGVzc1RoYW4oaGVhZGVyQS5rZXksIGhlYWRlckIua2V5KTsgfSk7CisgICAgICAg IHN0ZDo6c29ydChiLm1fdW5jb21tb25IZWFkZXJzLmJlZ2luKCksIGIubV91bmNvbW1vbkhlYWRl cnMuZW5kKCksIFtdKGF1dG8mIGhlYWRlckEsIGF1dG8mIGhlYWRlckIpIHsgcmV0dXJuIFdURjo6 Y29kZVBvaW50Q29tcGFyZUxlc3NUaGFuKGhlYWRlckEua2V5LCBoZWFkZXJCLmtleSk7IH0pOwor ICAgICAgICBpZiAoYS5tX3VuY29tbW9uSGVhZGVycyAhPSBiLm1fdW5jb21tb25IZWFkZXJzKQor ICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0K IAogICAgIGZyaWVuZCBib29sIG9wZXJhdG9yIT0oY29uc3QgSFRUUEhlYWRlck1hcCYgYSwgY29u c3QgSFRUUEhlYWRlck1hcCYgYikKQEAgLTIwNCw4ICsyMTcsOCBAQCBwdWJsaWM6CiBwcml2YXRl OgogICAgIHZvaWQgc2V0VW5jb21tb25IZWFkZXIoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBT dHJpbmcmIHZhbHVlKTsKIAotICAgIENvbW1vbkhlYWRlcnNWZWN0b3IgbV9jb21tb25IZWFkZXJz OwotICAgIFVuY29tbW9uSGVhZGVyc1ZlY3RvciBtX3VuY29tbW9uSGVhZGVyczsKKyAgICBtdXRh YmxlIENvbW1vbkhlYWRlcnNWZWN0b3IgbV9jb21tb25IZWFkZXJzOworICAgIG11dGFibGUgVW5j b21tb25IZWFkZXJzVmVjdG9yIG1fdW5jb21tb25IZWFkZXJzOwogfTsKIAogdGVtcGxhdGUgPGNs YXNzIEVuY29kZXI+CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VM b2cKaW5kZXggYzk3OTM5ZDEzMzBjYmU4YjQ3ZmMxNzNkNmE3MzVjMTU2MTk4MDgyZi4uYjIwN2Ni NTAzOGM4NjA2YWNmMGE2NjkxZWQ2ZmMwYmJhMGIxNGU0MCAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hh bmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDE5LTExLTIy ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSFRUUEhlYWRlck1h cCdzIG9wZXJhdG9yPT0gaXMgbm90IGZ1bGx5IGNvcnJlY3QKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDM2MQorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBBUEkgdGVzdCBjb3ZlcmFnZS4KKworICAg ICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9IVFRQSGVhZGVyTWFw LmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKwogMjAxOS0xMS0y MiAgSm9uYXRoYW4gQmVkYXJkICA8amJlZGFyZEBhcHBsZS5jb20+CiAKICAgICAgICAgcnVuLWph dmFzY3JpcHRjb3JlLXRlc3RzOiBIaWRlIHRoZSBvdXRwdXQgb2YgYmluYXJpZXMgYmVoaW5kIC0t dmVyYm9zZQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRB UEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA3MzE5ZDJmYzQ5NzBlYzRlZWJjZDAx MTRhMzQwNzBmNWFkZGQxYTA0Li41NDk1ODNhZDA2N2U4OGFhNGNiZDFjMTdhNzNlYWUzOWY1ZTY4 MzgzIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRB UEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMjQ2LDYgKzI0Niw3IEBACiAJCTQ2RTY2 QTkwMUYwRDc1NTkwMDI2RDgzQyAvKiBXS1dlYlZpZXdEaWFnbm9zdGljTG9nZ2luZy5tbSBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ2RTY2QThGMUYwRDc1 NTkwMDI2RDgzQyAvKiBXS1dlYlZpZXdEaWFnbm9zdGljTG9nZ2luZy5tbSAqLzsgfTsKIAkJNDZF ODE2RjgxRTc5RTI5QzAwMzc1QURDIC8qIFJlc3RvcmVTdGF0ZUFmdGVyVGVybWluYXRpb24ubW0g aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NkU4MTZGNzFF NzlFMjkxMDAzNzVBREMgLyogUmVzdG9yZVN0YXRlQWZ0ZXJUZXJtaW5hdGlvbi5tbSAqLzsgfTsK IAkJNDZFQkQ4NDcyMzcyMzIwRjAwMjIzQTZFIC8qIFJlc3RvcmVTY3JvbGxQb3NpdGlvbi5tbSBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ2RUJEODQ2MjM3 MjMxRTYwMDIyM0E2RSAvKiBSZXN0b3JlU2Nyb2xsUG9zaXRpb24ubW0gKi87IH07CisJCTQ2RkEy RkVFMjM4NDZDQTUwMDBDQ0IwQyAvKiBIVFRQSGVhZGVyTWFwLmNwcCBpbiBTb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ2RkEyRkVEMjM4NDZDOUEwMDBDQ0IwQyAv KiBIVFRQSGVhZGVyTWFwLmNwcCAqLzsgfTsKIAkJNDkwOUVFM0EyRDA5NDgwQzg4OTgyRDU2IC8q IE1hcmthYmxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEVDNzlGMTY4QkU0NTRFNTc5RTQxN0IwNSAvKiBNYXJrYWJsZS5jcHAgKi87IH07CiAJCTRC RkRGRkE3MTMxNDc3NkMwMDYxRjI0QiAvKiBIaXRUZXN0UmVzdWx0Tm9kZUhhbmRsZV9CdW5kbGUu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEJGREZG QTYxMzE0Nzc2QzAwNjFGMjRCIC8qIEhpdFRlc3RSZXN1bHROb2RlSGFuZGxlX0J1bmRsZS5jcHAg Ki87IH07CiAJCTUxMDQ3NzcyMUQyOThEREQwMDk3NDdFQiAvKiBJREJEZWxldGVSZWNvdmVyeS5z cWxpdGUzIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDUxMDQ3NzZGMUQyOThEODUwMDk3NDdFQiAvKiBJREJEZWxldGVSZWNvdmVyeS5zcWxpdGUz ICovOyB9OwpAQCAtMTE0Miw3ICsxMTQzLDYgQEAKIAkJCWRzdFBhdGggPSBUZXN0V2ViS2l0QVBJ LnJlc291cmNlczsKIAkJCWRzdFN1YmZvbGRlclNwZWMgPSA3OwogCQkJZmlsZXMgPSAoCi0JCQkJ Q0Q4Mzk0REYyMzJBRjdDMDAwMTQ5NDk1IC8qIG1lZGlhLWxvYWRpbmcuaHRtbCBpbiBDb3B5IFJl c291cmNlcyAqLywKIAkJCQk1NUE4MTdGRjIxODEwMjFBMDAwNEEzOUEgLyogMTAweDEwMC1yZWQu dGdhIGluIENvcHkgUmVzb3VyY2VzICovLAogCQkJCTFBOUU1MkM5MTNFNjVFRjQwMDY5MTdGNSAv KiAxOC1jaGFyYWN0ZXJzLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCiAJCQkJNTVBODE4MDAy MTgxMDIyMTAwMDRBMzlBIC8qIDQwMHg0MDAtZ3JlZW4ucG5nIGluIENvcHkgUmVzb3VyY2VzICov LApAQCAtMTM3NSw2ICsxMzc1LDcgQEAKIAkJCQk5MzBBRDQwMjE1MDY5OEQwMDA2Nzk3MEYgLyog bG90cy1vZi10ZXh0Lmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCiAJCQkJQUQ1N0FDMjIxREE3 NDY2RTAwRkYxQkRFIC8qIG1hbnktaWZyYW1lcy5odG1sIGluIENvcHkgUmVzb3VyY2VzICovLAog CQkJCTc3NzJFQ0UxMjJGRTA2QzYwMDA5QTc5OSAvKiBtYW55LXNhbWUtb3JpZ2luLWlmcmFtZXMu aHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLywKKwkJCQlDRDgzOTRERjIzMkFGN0MwMDAxNDk0OTUg LyogbWVkaWEtbG9hZGluZy5odG1sIGluIENvcHkgUmVzb3VyY2VzICovLAogCQkJCUNEQTMxNTlB MUVENTQ4RjEwMDlGNjBEMyAvKiBNZWRpYVBsYXliYWNrU2xlZXBBc3NlcnRpb24uaHRtbCBpbiBD b3B5IFJlc291cmNlcyAqLywKIAkJCQlDREM5NDQyRjFFRjIwNUQ2MDA1OUMzQzQgLyogbWVkaWFz dHJlYW10cmFjay1kZXRhY2hlZC5odG1sIGluIENvcHkgUmVzb3VyY2VzICovLAogCQkJCUUxMjIw RENBMTU1QjI4QUEwMDEzRTJGQyAvKiBNZW1vcnlDYWNoZURpc2FibGVXaXRoaW5SZXNvdXJjZUxv YWREZWxlZ2F0ZS5odG1sIGluIENvcHkgUmVzb3VyY2VzICovLApAQCAtMTc3OSw2ICsxNzgwLDcg QEAKIAkJNDZFNjZBOEYxRjBENzU1OTAwMjZEODNDIC8qIFdLV2ViVmlld0RpYWdub3N0aWNMb2dn aW5nLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV0tXZWJWaWV3 RGlhZ25vc3RpY0xvZ2dpbmcubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ2RTgx NkY3MUU3OUUyOTEwMDM3NUFEQyAvKiBSZXN0b3JlU3RhdGVBZnRlclRlcm1pbmF0aW9uLm1tICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gUmVzdG9yZVN0YXRlQWZ0ZXJU ZXJtaW5hdGlvbi5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDZFQkQ4NDYyMzcy MzFFNjAwMjIzQTZFIC8qIFJlc3RvcmVTY3JvbGxQb3NpdGlvbi5tbSAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFJlc3RvcmVTY3JvbGxQb3NpdGlvbi5tbTsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDZGQTJGRUQyMzg0NkM5QTAwMENDQjBDIC8qIEhUVFBI ZWFkZXJNYXAuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSFRUUEhl YWRlck1hcC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRBNDEwRjRCMTlBRjdC RDYwMDJFQkFCNSAvKiBVc2VyTWVkaWEuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gVXNlck1lZGlhLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNEE0 MTBGNEQxOUFGN0JFRjAwMkVCQUI1IC8qIGdldFVzZXJNZWRpYS5odG1sICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4 dC5odG1sOyBwYXRoID0gZ2V0VXNlck1lZGlhLmh0bWw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCTRBNDEwRjREMTlBRjdCRUYwMDJFQkFCNiAvKiBvbmRldmljZWNoYW5nZS5odG1sICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gdGV4dC5odG1sOyBwYXRoID0gb25kZXZpY2VjaGFuZ2UuaHRtbDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTMxMDUsNiArMzEwNyw3IEBACiAJCQkJOEU0QTg1MzYxRTFE MUFBMTAwRjUzQjBGIC8qIEdyaWRQb3NpdGlvbi5jcHAgKi8sCiAJCQkJODNCODhBMzMxQzgwMDU2 RDAwQkIyNDE4IC8qIEhUTUxQYXJzZXJJZGlvbXMuY3BwICovLAogCQkJCTVDQTFERUM3MUY3MUY0 MDcwMEU3MUJEMyAvKiBIVFRQSGVhZGVyRmllbGQuY3BwICovLAorCQkJCTQ2RkEyRkVEMjM4NDZD OUEwMDBDQ0IwQyAvKiBIVFRQSGVhZGVyTWFwLmNwcCAqLywKIAkJCQk2QjlBQkUxMTIwODY5NTJG MDBENzVERTYgLyogSFRUUFBhcnNlcnMuY3BwICovLAogCQkJCTdBOTA5QTczMUQ4Nzc0NzUwMDdF MTBGOCAvKiBJbnRQb2ludC5jcHAgKi8sCiAJCQkJN0E5MDlBNzQxRDg3NzQ3NTAwN0UxMEY4IC8q IEludFJlY3QuY3BwICovLApAQCAtMzg1Miw2ICszODU1LDcgQEAKIAkJCQk5MzBBRDQwMTE1MDY5 OEIzMDA2Nzk3MEYgLyogbG90cy1vZi10ZXh0Lmh0bWwgKi8sCiAJCQkJQUQ1N0FDMUQxREE3NDYz ODAwRkYxQkRFIC8qIG1hbnktaWZyYW1lcy5odG1sICovLAogCQkJCTc3NzJFQ0UwMjJGRTA1RTEw MDA5QTc5OSAvKiBtYW55LXNhbWUtb3JpZ2luLWlmcmFtZXMuaHRtbCAqLywKKwkJCQlDRDgzOTRE RTIzMkFGMTVFMDAxNDk0OTUgLyogbWVkaWEtbG9hZGluZy5odG1sICovLAogCQkJCUNEQzk0NDJC MUVGMUZCRDIwMDU5QzNDNCAvKiBtZWRpYXN0cmVhbXRyYWNrLWRldGFjaGVkLmh0bWwgKi8sCiAJ CQkJNTFDRDFDNzExQjM4RDQ4NDAwMTQyQ0E1IC8qIG1vZGFsLWFsZXJ0cy1pbi1uZXctYWJvdXQt Ymxhbmstd2luZG93Lmh0bWwgKi8sCiAJCQkJN0ExNDU4RkIxQUQ1QzAzNTAwRTA2NzcyIC8qIG1v dXNlLWJ1dHRvbi1saXN0ZW5lci5odG1sICovLApAQCAtMzg4Myw3ICszODg3LDYgQEAKIAkJCQkw N0NEMzJGNzIwNjVCNzJBMDA2NEE0QkUgLyogdmlkZW8uaHRtbCAqLywKIAkJCQkxQzJCODE4NDFD ODkyNEEyMDBBNTUyOUYgLyogd2ViZm9udC5odG1sICovLAogCQkJCTQ2OEYyRjkzMjM2OERBQTcw MEY0Qjg2NCAvKiB3aW5kb3ctb3Blbi10aGVuLWRvY3VtZW50LW9wZW4uaHRtbCAqLywKLQkJCQlD RDgzOTRERTIzMkFGMTVFMDAxNDk0OTUgLyogbWVkaWEtbG9hZGluZy5odG1sICovLAogCQkJKTsK IAkJCW5hbWUgPSBSZXNvdXJjZXM7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpAQCAtNDY3 MCw2ICs0NjczLDcgQEAKIAkJCQk3Q0NFN0VDMjFBNDExQTdFMDA0NDdDNEMgLyogSFRNTEZvcm1D b2xsZWN0aW9uTmFtZWRJdGVtLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJN0M4M0UwNTAxRDBBNjQx ODAwRkVCQ0YzIC8qIEhUTUxQYXJzZXJJZGlvbXMuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNUNB MURFQzgxRjcxRjcwMTAwRTcxQkQzIC8qIEhUVFBIZWFkZXJGaWVsZC5jcHAgaW4gU291cmNlcyAq LywKKwkJCQk0NkZBMkZFRTIzODQ2Q0E1MDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAgaW4g U291cmNlcyAqLywKIAkJCQk2QjlBQkUxMjIwODY5NTJGMDBENzVERTYgLyogSFRUUFBhcnNlcnMu Y3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNUM3QzI0RkMyMzdDOTc1NDAwNTk5QzkxIC8qIEhUVFBT ZXJ2ZXIubW0gaW4gU291cmNlcyAqLywKIAkJCQk1MUFGMjNERjFFRjFBMzczMDA3MkYyODEgLyog SWNvbkxvYWRpbmdEZWxlZ2F0ZS5tbSBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0hUVFBIZWFkZXJNYXAuY3BwIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0hUVFBIZWFkZXJNYXAuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjJh MjdhMTI3YWQ1NzEyMmNjMzNkMjg1NTU4ZWY4ODIwNDhlNTYwMTkKLS0tIC9kZXYvbnVsbAorKysg Yi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvSFRUUEhlYWRlck1hcC5jcHAKQEAg LTAsMCArMSw2OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUg SU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBP RiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAq IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlRlc3QuaCIKKyNpbmNsdWRlIDxX ZWJDb3JlL0hUVFBIZWFkZXJNYXAuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25h bWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKKworVEVTVChIVFRQSGVhZGVyTWFwLCBDb21wYXJpc29u T3BlcmF0b3IpCit7CisgICAgSFRUUEhlYWRlck1hcCBtYXAxOworICAgIEhUVFBIZWFkZXJNYXAg bWFwMjsKKworICAgIG1hcDEuYWRkKCJDYWNoZS1Db250cm9sIl9zdHIsICJtYXgtYWdlOjAiX3N0 cik7CisgICAgbWFwMS5hZGQoIkVUYWciX3N0ciwgImZvbyJfc3RyKTsKKyAgICBtYXAxLmFkZCgi Tm90LUNvbW1vbjEiX3N0ciwgImJhciJfc3RyKTsKKyAgICBtYXAxLmFkZCgiTm90LUNvbW1vbjIi X3N0ciwgImJhciJfc3RyKTsKKworICAgIG1hcDIuYWRkKCJFVGFnIl9zdHIsICJmb28iX3N0cik7 CisgICAgbWFwMi5hZGQoIkNhY2hlLUNvbnRyb2wiX3N0ciwgIm1heC1hZ2U6MCJfc3RyKTsKKyAg ICBtYXAyLmFkZCgiTm90LUNvbW1vbjIiX3N0ciwgImJhciJfc3RyKTsKKyAgICBtYXAyLmFkZCgi Tm90LUNvbW1vbjEiX3N0ciwgImJhciJfc3RyKTsKKworICAgIEVYUEVDVF9UUlVFKG1hcDEgPT0g bWFwMik7CisgICAgRVhQRUNUX0ZBTFNFKG1hcDEgIT0gbWFwMik7CisKKyAgICBtYXAxLmFkZCgi TGFzdC1Nb2RpZmllZCJfc3RyLCAiMTIzNDU1Il9zdHIpOworICAgIG1hcDIuYWRkKCJMYXN0LU1v ZGlmaWVkIl9zdHIsICIxMjM0NTYiX3N0cik7CisgICAgRVhQRUNUX0ZBTFNFKG1hcDEgPT0gbWFw Mik7CisgICAgRVhQRUNUX1RSVUUobWFwMSAhPSBtYXAyKTsKKworICAgIG1hcDEucmVtb3ZlKCJM YXN0LU1vZGlmaWVkIl9zdHIpOworICAgIG1hcDIucmVtb3ZlKCJMYXN0LU1vZGlmaWVkIl9zdHIp OworICAgIEVYUEVDVF9UUlVFKG1hcDEgPT0gbWFwMik7CisgICAgRVhQRUNUX0ZBTFNFKG1hcDEg IT0gbWFwMik7CisKKyAgICBtYXAxLmFkZCgiTm90LUNvbW1vbjMiX3N0ciwgImJhciJfc3RyKTsK KyAgICBtYXAxLmFkZCgiTm90LUNvbW1vbjMiX3N0ciwgImJheiJfc3RyKTsKKyAgICBFWFBFQ1Rf RkFMU0UobWFwMSA9PSBtYXAyKTsKKyAgICBFWFBFQ1RfVFJVRShtYXAxICE9IG1hcDIpOworfQor Cit9Cg== 384202 2019-11-22 15:04:18 -0800 2019-11-22 15:06:25 -0800 Alternative Patch dealing with large maps bug-204361-20191122150411.patch text/plain 15352 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjUyNzgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWM4ZWVmNGRmYTgyYWMx MTA4NjZjODNmNDk1Y2ExMGFmYTk1MWIyYy4uOTQ1NWZkM2FlMDJhNDlhZjk2OGE4ZmVmNjQ1MDBi NGM1NDZhNDIzYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDE5LTExLTIyICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSFRUUEhlYWRlck1hcCdzIG9w ZXJhdG9yPT0gaXMgbm90IGZ1bGx5IGNvcnJlY3QKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDM2MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIGlmIGhlYWRlcnMgYXJlIGFkZGVkIGluIGEgZGlmZmVyZW50 IG9yZGVyLCBIVFRQSGVhZGVyTWFwJ3Mgb3BlcmF0b3I9PSgpIHdvdWxkIHdyb25nbHkKKyAgICAg ICAgcmV0dXJuIGZhbHNlIGJlY2F1c2UgaXQgaXMgdXNpbmcgYSBWZWN0b3IgaW50ZXJuYWxseSB0 byBzdG9yZSB0aGUgaGVhZGVycy4gQWxzbywgaXRzCisgICAgICAgIHdvdWxkIGluY29ycmVjdGx5 IHJldHVybiBmYWxzZSBpZiB0aGUgY2FzZSBvZiB0aGUgSFRUUCBoZWFkZXJzIHdvdWxkIG5vdCBt YXRjaC4KKworICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpIVFRQSGVhZGVyTWFwOjpnZXQgY29uc3QpOgorICAgICAgICAoV2Vi Q29yZTo6SFRUUEhlYWRlck1hcDo6dW5jb21tb25IZWFkZXIgY29uc3QpOgorICAgICAgICAoV2Vi Q29yZTo6Y29tcGFyZUhlYWRlcnMpOgorICAgICAgICAoV2ViQ29yZTo6SFRUUEhlYWRlck1hcDo6 ZXF1YWxzIGNvbnN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFkZXJNYXAu aDoKKyAgICAgICAgKFdlYkNvcmU6OkhUVFBIZWFkZXJNYXA6Om9wZXJhdG9yPT0pOgorCiAyMDE5 LTExLTIyICBaYWxhbiBCdWp0YXMgIDx6YWxhbkBhcHBsZS5jb20+CiAKICAgICAgICAgW0xGQ11b SUZDXSBMaW5lOjppbmxpbmVJdGVtQ29udGVudEhlaWdodCBzaG91bGQgb25seSBjYWxsIEZvcm1h dHRpbmdDb250ZXh0OjpnZW9tZXRyeUZvckJveCB3aGVuIG5lZWRlZApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5jcHAKaW5kZXggMWU5NzlmODEy M2Q2YzM1NzMwNzgxNDc0YzlhZGI0M2Q4Yzg3MWJiOS4uZjkwY2RmODljMGRlMWFhODg5MmNmOTM2 MWIwZjc0MzhiMzQzOWI1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9IVFRQSGVhZGVyTWFwLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL0hUVFBIZWFkZXJNYXAuY3BwCkBAIC01NCw3ICs1NCwxMSBAQCBTdHJpbmcgSFRUUEhlYWRl ck1hcDo6Z2V0KGNvbnN0IFN0cmluZyYgbmFtZSkgY29uc3QKICAgICBIVFRQSGVhZGVyTmFtZSBo ZWFkZXJOYW1lOwogICAgIGlmIChmaW5kSFRUUEhlYWRlck5hbWUobmFtZSwgaGVhZGVyTmFtZSkp CiAgICAgICAgIHJldHVybiBnZXQoaGVhZGVyTmFtZSk7CisgICAgcmV0dXJuIHVuY29tbW9uSGVh ZGVyKG5hbWUpOworfQogCitTdHJpbmcgSFRUUEhlYWRlck1hcDo6dW5jb21tb25IZWFkZXIoY29u c3QgU3RyaW5nJiBuYW1lKSBjb25zdAorewogICAgIGF1dG8gaW5kZXggPSBtX3VuY29tbW9uSGVh ZGVycy5maW5kTWF0Y2hpbmcoWyZdKGF1dG8mIGhlYWRlcikgewogICAgICAgICByZXR1cm4gZXF1 YWxJZ25vcmluZ0FTQ0lJQ2FzZShoZWFkZXIua2V5LCBuYW1lKTsKICAgICB9KTsKQEAgLTIwNiw0 ICsyMTAsNDQgQEAgdm9pZCBIVFRQSGVhZGVyTWFwOjphZGQoSFRUUEhlYWRlck5hbWUgbmFtZSwg Y29uc3QgU3RyaW5nJiB2YWx1ZSkKICAgICAgICAgbV9jb21tb25IZWFkZXJzLmFwcGVuZChDb21t b25IZWFkZXIgeyBuYW1lLCB2YWx1ZSB9KTsKIH0KIAordGVtcGxhdGU8dHlwZW5hbWUgViwgdHlw ZW5hbWUgRj4KK3N0YXRpYyBib29sIGNvbXBhcmVIZWFkZXJzKGNvbnN0IFYmIGhlYWRlcnMsIGNv bnN0IEYmIG90aGVySGVhZGVyVmFsdWUpCit7CisgICAgZm9yIChhdXRvJiBoZWFkZXIgOiBoZWFk ZXJzKSB7CisgICAgICAgIGlmIChvdGhlckhlYWRlclZhbHVlKGhlYWRlci5rZXkpICE9IGhlYWRl ci52YWx1ZSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgcmV0dXJuIHRy dWU7Cit9CisKK2Jvb2wgSFRUUEhlYWRlck1hcDo6ZXF1YWxzKGNvbnN0IEhUVFBIZWFkZXJNYXAm IG90aGVyKSBjb25zdAoreworICAgIGlmIChtX2NvbW1vbkhlYWRlcnMuc2l6ZSgpICE9IG90aGVy Lm1fY29tbW9uSGVhZGVycy5zaXplKCkgfHwgbV91bmNvbW1vbkhlYWRlcnMuc2l6ZSgpICE9IG90 aGVyLm1fdW5jb21tb25IZWFkZXJzLnNpemUoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgYm9vbCBpc1ZlY3RvclNtYWxsID0gbV9jb21tb25IZWFkZXJzLnNpemUoKSA8PSAxNjsKKyAg ICBpZiAoaXNWZWN0b3JTbWFsbCkgeworICAgICAgICAvLyBDb21tb24gY2FzZS4KKyAgICAgICAg aWYgKCFjb21wYXJlSGVhZGVycyhtX2NvbW1vbkhlYWRlcnMsIFsmXShhdXRvJiBrZXkpIHsgcmV0 dXJuIG90aGVyLmdldChrZXkpOyB9KSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAg ICAgaWYgKCFjb21wYXJlSGVhZGVycyhtX3VuY29tbW9uSGVhZGVycywgWyZdKGF1dG8mIGtleSkg eyByZXR1cm4gb3RoZXIudW5jb21tb25IZWFkZXIoa2V5KTsgfSkpCisgICAgICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKworICAgIEhhc2hNYXA8SFRU UEhlYWRlck5hbWUsIFN0cmluZywgV1RGOjpJbnRIYXNoPEhUVFBIZWFkZXJOYW1lPiwgV1RGOjpT dHJvbmdFbnVtSGFzaFRyYWl0czxIVFRQSGVhZGVyTmFtZT4+IG90aGVyQ29tbW9uSGVhZGVyczsK KyAgICBmb3IgKGF1dG8mIGNvbW1vbkhlYWRlciA6IG90aGVyLm1fY29tbW9uSGVhZGVycykKKyAg ICAgICAgb3RoZXJDb21tb25IZWFkZXJzLmFkZChjb21tb25IZWFkZXIua2V5LCBjb21tb25IZWFk ZXIudmFsdWUpOworICAgIGlmICghY29tcGFyZUhlYWRlcnMobV9jb21tb25IZWFkZXJzLCBbJl0o YXV0byYga2V5KSB7IHJldHVybiBvdGhlckNvbW1vbkhlYWRlcnMuZ2V0KGtleSk7IH0pKQorICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nLCBBU0NJSUNh c2VJbnNlbnNpdGl2ZUhhc2g+IG90aGVyVW5jb21tb25IZWFkZXJzOworICAgIGZvciAoYXV0byYg dW5jb21tb25IZWFkZXIgOiBvdGhlci5tX3VuY29tbW9uSGVhZGVycykKKyAgICAgICAgb3RoZXJV bmNvbW1vbkhlYWRlcnMuYWRkKHVuY29tbW9uSGVhZGVyLmtleSwgdW5jb21tb25IZWFkZXIudmFs dWUpOworICAgIGlmICghY29tcGFyZUhlYWRlcnMobV91bmNvbW1vbkhlYWRlcnMsIFsmXShhdXRv JiBrZXkpIHsgcmV0dXJuIG90aGVyVW5jb21tb25IZWFkZXJzLmdldChrZXkpOyB9KSkKKyAgICAg ICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0dXJuIHRydWU7Cit9CisKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRU UEhlYWRlck1hcC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVy TWFwLmgKaW5kZXggMGJkMDQyOTk0NjcwNGVjMDdjZjk1ZGRlZGMzNzZmOTFhMzdmMjM1My4uOTc0 NTA1ZTQ5OGNlMjA1NzUzYjdkOTMwZGM2YThjMzM3OTg2MThkYyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmgKQEAgLTE1OCw3ICsxNTgsNyBA QCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBhZGQoY29uc3QgU3RyaW5nJiBuYW1l LCBjb25zdCBTdHJpbmcmIHZhbHVlKTsKICAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGFwcGVuZChj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmFsdWUpOwogICAgIFdFQkNPUkVfRVhQ T1JUIGJvb2wgY29udGFpbnMoY29uc3QgU3RyaW5nJikgY29uc3Q7Ci0gICAgYm9vbCByZW1vdmUo Y29uc3QgU3RyaW5nJik7CisgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCByZW1vdmUoY29uc3QgU3Ry aW5nJik7CiAKICNpZiBVU0UoQ0YpCiAgICAgdm9pZCBzZXQoQ0ZTdHJpbmdSZWYgbmFtZSwgY29u c3QgU3RyaW5nJiB2YWx1ZSk7CkBAIC0xODgsOSArMTg4LDExIEBAIHB1YmxpYzoKICAgICBjb25z dF9pdGVyYXRvciBiZWdpbigpIGNvbnN0IHsgcmV0dXJuIGNvbnN0X2l0ZXJhdG9yKCp0aGlzLCBt X2NvbW1vbkhlYWRlcnMuYmVnaW4oKSwgbV91bmNvbW1vbkhlYWRlcnMuYmVnaW4oKSk7IH0KICAg ICBjb25zdF9pdGVyYXRvciBlbmQoKSBjb25zdCB7IHJldHVybiBjb25zdF9pdGVyYXRvcigqdGhp cywgbV9jb21tb25IZWFkZXJzLmVuZCgpLCBtX3VuY29tbW9uSGVhZGVycy5lbmQoKSk7IH0KIAor ICAgIFdFQkNPUkVfRVhQT1JUIGJvb2wgZXF1YWxzKGNvbnN0IEhUVFBIZWFkZXJNYXAmKSBjb25z dDsKKwogICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgSFRUUEhlYWRlck1hcCYgYSwg Y29uc3QgSFRUUEhlYWRlck1hcCYgYikKICAgICB7Ci0gICAgICAgIHJldHVybiBhLm1fY29tbW9u SGVhZGVycyA9PSBiLm1fY29tbW9uSGVhZGVycyAmJiBhLm1fdW5jb21tb25IZWFkZXJzID09IGIu bV91bmNvbW1vbkhlYWRlcnM7CisgICAgICAgIHJldHVybiBhLmVxdWFscyhiKTsKICAgICB9CiAK ICAgICBmcmllbmQgYm9vbCBvcGVyYXRvciE9KGNvbnN0IEhUVFBIZWFkZXJNYXAmIGEsIGNvbnN0 IEhUVFBIZWFkZXJNYXAmIGIpCkBAIC0yMDMsNiArMjA1LDcgQEAgcHVibGljOgogCiBwcml2YXRl OgogICAgIHZvaWQgc2V0VW5jb21tb25IZWFkZXIoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBT dHJpbmcmIHZhbHVlKTsKKyAgICBTdHJpbmcgdW5jb21tb25IZWFkZXIoY29uc3QgU3RyaW5nJiBu YW1lKSBjb25zdDsKIAogICAgIENvbW1vbkhlYWRlcnNWZWN0b3IgbV9jb21tb25IZWFkZXJzOwog ICAgIFVuY29tbW9uSGVhZGVyc1ZlY3RvciBtX3VuY29tbW9uSGVhZGVyczsKZGlmZiAtLWdpdCBh L1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBjOTc5MzlkMTMzMGNiZThi NDdmYzE3M2Q2YTczNWMxNTYxOTgwODJmLi5iNDRkNTIyMTQxNDhlMDVmZTE2ZjQwNWQzNWFlYjhk NzcxMjdlNmRkIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTktMTEtMjIgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFw cGxlLmNvbT4KKworICAgICAgICBIVFRQSGVhZGVyTWFwJ3Mgb3BlcmF0b3I9PSBpcyBub3QgZnVs bHkgY29ycmVjdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjA0MzYxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgQWRkIEFQSSB0ZXN0IGNvdmVyYWdlLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0 V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJDb3JlL0hUVFBIZWFkZXJNYXAuY3BwOiBBZGRlZC4KKyAgICAgICAgKFRl c3RXZWJLaXRBUEk6OnRlc3RDb21wYXJpc29uT3BlcmF0b3IpOgorICAgICAgICAoVGVzdFdlYktp dEFQSTo6VEVTVCk6CisKIDIwMTktMTEtMjIgIEpvbmF0aGFuIEJlZGFyZCAgPGpiZWRhcmRAYXBw bGUuY29tPgogCiAgICAgICAgIHJ1bi1qYXZhc2NyaXB0Y29yZS10ZXN0czogSGlkZSB0aGUgb3V0 cHV0IG9mIGJpbmFyaWVzIGJlaGluZCAtLXZlcmJvc2UKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5k ZXggNzMxOWQyZmM0OTcwZWM0ZWViY2QwMTE0YTM0MDcwZjVhZGRkMWEwNC4uNTQ5NTgzYWQwNjdl ODhhYTRjYmQxYzE3YTczZWFlMzlmNWU2ODM4MyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAg LTI0Niw2ICsyNDYsNyBAQAogCQk0NkU2NkE5MDFGMEQ3NTU5MDAyNkQ4M0MgLyogV0tXZWJWaWV3 RGlhZ25vc3RpY0xvZ2dpbmcubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA0NkU2NkE4RjFGMEQ3NTU5MDAyNkQ4M0MgLyogV0tXZWJWaWV3RGlhZ25vc3Rp Y0xvZ2dpbmcubW0gKi87IH07CiAJCTQ2RTgxNkY4MUU3OUUyOUMwMDM3NUFEQyAvKiBSZXN0b3Jl U3RhdGVBZnRlclRlcm1pbmF0aW9uLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNDZFODE2RjcxRTc5RTI5MTAwMzc1QURDIC8qIFJlc3RvcmVTdGF0ZUFm dGVyVGVybWluYXRpb24ubW0gKi87IH07CiAJCTQ2RUJEODQ3MjM3MjMyMEYwMDIyM0E2RSAvKiBS ZXN0b3JlU2Nyb2xsUG9zaXRpb24ubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA0NkVCRDg0NjIzNzIzMUU2MDAyMjNBNkUgLyogUmVzdG9yZVNjcm9sbFBv c2l0aW9uLm1tICovOyB9OworCQk0NkZBMkZFRTIzODQ2Q0E1MDAwQ0NCMEMgLyogSFRUUEhlYWRl ck1hcC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0 NkZBMkZFRDIzODQ2QzlBMDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAgKi87IH07CiAJCTQ5 MDlFRTNBMkQwOTQ4MEM4ODk4MkQ1NiAvKiBNYXJrYWJsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFQzc5RjE2OEJFNDU0RTU3OUU0MTdCMDUgLyog TWFya2FibGUuY3BwICovOyB9OwogCQk0QkZERkZBNzEzMTQ3NzZDMDA2MUYyNEIgLyogSGl0VGVz dFJlc3VsdE5vZGVIYW5kbGVfQnVuZGxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDRCRkRGRkE2MTMxNDc3NkMwMDYxRjI0QiAvKiBIaXRUZXN0UmVz dWx0Tm9kZUhhbmRsZV9CdW5kbGUuY3BwICovOyB9OwogCQk1MTA0Nzc3MjFEMjk4REREMDA5NzQ3 RUIgLyogSURCRGVsZXRlUmVjb3Zlcnkuc3FsaXRlMyBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTA0Nzc2RjFEMjk4RDg1MDA5NzQ3RUIgLyog SURCRGVsZXRlUmVjb3Zlcnkuc3FsaXRlMyAqLzsgfTsKQEAgLTExNDIsNyArMTE0Myw2IEBACiAJ CQlkc3RQYXRoID0gVGVzdFdlYktpdEFQSS5yZXNvdXJjZXM7CiAJCQlkc3RTdWJmb2xkZXJTcGVj ID0gNzsKIAkJCWZpbGVzID0gKAotCQkJCUNEODM5NERGMjMyQUY3QzAwMDE0OTQ5NSAvKiBtZWRp YS1sb2FkaW5nLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCiAJCQkJNTVBODE3RkYyMTgxMDIx QTAwMDRBMzlBIC8qIDEwMHgxMDAtcmVkLnRnYSBpbiBDb3B5IFJlc291cmNlcyAqLywKIAkJCQkx QTlFNTJDOTEzRTY1RUY0MDA2OTE3RjUgLyogMTgtY2hhcmFjdGVycy5odG1sIGluIENvcHkgUmVz b3VyY2VzICovLAogCQkJCTU1QTgxODAwMjE4MTAyMjEwMDA0QTM5QSAvKiA0MDB4NDAwLWdyZWVu LnBuZyBpbiBDb3B5IFJlc291cmNlcyAqLywKQEAgLTEzNzUsNiArMTM3NSw3IEBACiAJCQkJOTMw QUQ0MDIxNTA2OThEMDAwNjc5NzBGIC8qIGxvdHMtb2YtdGV4dC5odG1sIGluIENvcHkgUmVzb3Vy Y2VzICovLAogCQkJCUFENTdBQzIyMURBNzQ2NkUwMEZGMUJERSAvKiBtYW55LWlmcmFtZXMuaHRt bCBpbiBDb3B5IFJlc291cmNlcyAqLywKIAkJCQk3NzcyRUNFMTIyRkUwNkM2MDAwOUE3OTkgLyog bWFueS1zYW1lLW9yaWdpbi1pZnJhbWVzLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCisJCQkJ Q0Q4Mzk0REYyMzJBRjdDMDAwMTQ5NDk1IC8qIG1lZGlhLWxvYWRpbmcuaHRtbCBpbiBDb3B5IFJl c291cmNlcyAqLywKIAkJCQlDREEzMTU5QTFFRDU0OEYxMDA5RjYwRDMgLyogTWVkaWFQbGF5YmFj a1NsZWVwQXNzZXJ0aW9uLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCiAJCQkJQ0RDOTQ0MkYx RUYyMDVENjAwNTlDM0M0IC8qIG1lZGlhc3RyZWFtdHJhY2stZGV0YWNoZWQuaHRtbCBpbiBDb3B5 IFJlc291cmNlcyAqLywKIAkJCQlFMTIyMERDQTE1NUIyOEFBMDAxM0UyRkMgLyogTWVtb3J5Q2Fj aGVEaXNhYmxlV2l0aGluUmVzb3VyY2VMb2FkRGVsZWdhdGUuaHRtbCBpbiBDb3B5IFJlc291cmNl cyAqLywKQEAgLTE3NzksNiArMTc4MCw3IEBACiAJCTQ2RTY2QThGMUYwRDc1NTkwMDI2RDgzQyAv KiBXS1dlYlZpZXdEaWFnbm9zdGljTG9nZ2luZy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw Lm9iamNwcDsgcGF0aCA9IFdLV2ViVmlld0RpYWdub3N0aWNMb2dnaW5nLm1tOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk0NkU4MTZGNzFFNzlFMjkxMDAzNzVBREMgLyogUmVzdG9yZVN0 YXRlQWZ0ZXJUZXJtaW5hdGlvbi5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsg cGF0aCA9IFJlc3RvcmVTdGF0ZUFmdGVyVGVybWluYXRpb24ubW07IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTQ2RUJEODQ2MjM3MjMxRTYwMDIyM0E2RSAvKiBSZXN0b3JlU2Nyb2xsUG9z aXRpb24ubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBSZXN0b3Jl U2Nyb2xsUG9zaXRpb24ubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ2RkEyRkVE MjM4NDZDOUEwMDBDQ0IwQyAvKiBIVFRQSGVhZGVyTWFwLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IEhUVFBIZWFkZXJNYXAuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk0QTQxMEY0QjE5QUY3QkQ2MDAyRUJBQjUgLyogVXNlck1lZGlhLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFVzZXJNZWRpYS5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRBNDEwRjREMTlBRjdCRUYwMDJFQkFCNSAvKiBnZXRVc2Vy TWVkaWEuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IGdldFVzZXJNZWRpYS5odG1s OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0QTQxMEY0RDE5QUY3QkVGMDAyRUJBQjYg Lyogb25kZXZpY2VjaGFuZ2UuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IG9uZGV2 aWNlY2hhbmdlLmh0bWw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zMTA1LDYgKzMx MDcsNyBAQAogCQkJCThFNEE4NTM2MUUxRDFBQTEwMEY1M0IwRiAvKiBHcmlkUG9zaXRpb24uY3Bw ICovLAogCQkJCTgzQjg4QTMzMUM4MDA1NkQwMEJCMjQxOCAvKiBIVE1MUGFyc2VySWRpb21zLmNw cCAqLywKIAkJCQk1Q0ExREVDNzFGNzFGNDA3MDBFNzFCRDMgLyogSFRUUEhlYWRlckZpZWxkLmNw cCAqLywKKwkJCQk0NkZBMkZFRDIzODQ2QzlBMDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAg Ki8sCiAJCQkJNkI5QUJFMTEyMDg2OTUyRjAwRDc1REU2IC8qIEhUVFBQYXJzZXJzLmNwcCAqLywK IAkJCQk3QTkwOUE3MzFEODc3NDc1MDA3RTEwRjggLyogSW50UG9pbnQuY3BwICovLAogCQkJCTdB OTA5QTc0MUQ4Nzc0NzUwMDdFMTBGOCAvKiBJbnRSZWN0LmNwcCAqLywKQEAgLTM4NTIsNiArMzg1 NSw3IEBACiAJCQkJOTMwQUQ0MDExNTA2OThCMzAwNjc5NzBGIC8qIGxvdHMtb2YtdGV4dC5odG1s ICovLAogCQkJCUFENTdBQzFEMURBNzQ2MzgwMEZGMUJERSAvKiBtYW55LWlmcmFtZXMuaHRtbCAq LywKIAkJCQk3NzcyRUNFMDIyRkUwNUUxMDAwOUE3OTkgLyogbWFueS1zYW1lLW9yaWdpbi1pZnJh bWVzLmh0bWwgKi8sCisJCQkJQ0Q4Mzk0REUyMzJBRjE1RTAwMTQ5NDk1IC8qIG1lZGlhLWxvYWRp bmcuaHRtbCAqLywKIAkJCQlDREM5NDQyQjFFRjFGQkQyMDA1OUMzQzQgLyogbWVkaWFzdHJlYW10 cmFjay1kZXRhY2hlZC5odG1sICovLAogCQkJCTUxQ0QxQzcxMUIzOEQ0ODQwMDE0MkNBNSAvKiBt b2RhbC1hbGVydHMtaW4tbmV3LWFib3V0LWJsYW5rLXdpbmRvdy5odG1sICovLAogCQkJCTdBMTQ1 OEZCMUFENUMwMzUwMEUwNjc3MiAvKiBtb3VzZS1idXR0b24tbGlzdGVuZXIuaHRtbCAqLywKQEAg LTM4ODMsNyArMzg4Nyw2IEBACiAJCQkJMDdDRDMyRjcyMDY1QjcyQTAwNjRBNEJFIC8qIHZpZGVv Lmh0bWwgKi8sCiAJCQkJMUMyQjgxODQxQzg5MjRBMjAwQTU1MjlGIC8qIHdlYmZvbnQuaHRtbCAq LywKIAkJCQk0NjhGMkY5MzIzNjhEQUE3MDBGNEI4NjQgLyogd2luZG93LW9wZW4tdGhlbi1kb2N1 bWVudC1vcGVuLmh0bWwgKi8sCi0JCQkJQ0Q4Mzk0REUyMzJBRjE1RTAwMTQ5NDk1IC8qIG1lZGlh LWxvYWRpbmcuaHRtbCAqLywKIAkJCSk7CiAJCQluYW1lID0gUmVzb3VyY2VzOwogCQkJc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTQ2NzAsNiArNDY3Myw3IEBACiAJCQkJN0NDRTdFQzIxQTQx MUE3RTAwNDQ3QzRDIC8qIEhUTUxGb3JtQ29sbGVjdGlvbk5hbWVkSXRlbS5tbSBpbiBTb3VyY2Vz ICovLAogCQkJCTdDODNFMDUwMUQwQTY0MTgwMEZFQkNGMyAvKiBIVE1MUGFyc2VySWRpb21zLmNw cCBpbiBTb3VyY2VzICovLAogCQkJCTVDQTFERUM4MUY3MUY3MDEwMEU3MUJEMyAvKiBIVFRQSGVh ZGVyRmllbGQuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJNDZGQTJGRUUyMzg0NkNBNTAwMENDQjBD IC8qIEhUVFBIZWFkZXJNYXAuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNkI5QUJFMTIyMDg2OTUy RjAwRDc1REU2IC8qIEhUVFBQYXJzZXJzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTVDN0MyNEZD MjM3Qzk3NTQwMDU5OUM5MSAvKiBIVFRQU2VydmVyLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNTFB RjIzREYxRUYxQTM3MzAwNzJGMjgxIC8qIEljb25Mb2FkaW5nRGVsZWdhdGUubW0gaW4gU291cmNl cyAqLywKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9IVFRQ SGVhZGVyTWFwLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9IVFRQSGVh ZGVyTWFwLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zMWNjODI3ODU2ZjlmZjliNWUyZTM3MThjODc2NzM1NmQ1 OWRkNjAyCi0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJD b3JlL0hUVFBIZWFkZXJNYXAuY3BwCkBAIC0wLDAgKzEsOTYgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNs dWRlICJUZXN0LmgiCisjaW5jbHVkZSA8V2ViQ29yZS9IVFRQSGVhZGVyTWFwLmg+CisjaW5jbHVk ZSA8d3RmL3RleHQvU3RyaW5nQ29uY2F0ZW5hdGVOdW1iZXJzLmg+CisKK3VzaW5nIG5hbWVzcGFj ZSBXZWJDb3JlOworCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK3N0YXRpYyB2b2lkIHRl c3RDb21wYXJpc29uT3BlcmF0b3IoSFRUUEhlYWRlck1hcCBtYXAxLCBIVFRQSGVhZGVyTWFwIG1h cDIpCit7CisgICAgbWFwMS5hZGQoIkNhY2hlLUNvbnRyb2wiX3N0ciwgIm1heC1hZ2U6MCJfc3Ry KTsKKyAgICBtYXAxLmFkZCgiRVRhZyJfc3RyLCAiZm9vIl9zdHIpOworICAgIG1hcDEuYWRkKCJO b3QtQ29tbW9uMSJfc3RyLCAiYmFyIl9zdHIpOworICAgIG1hcDEuYWRkKCJOb3QtQ29tbW9uMiJf c3RyLCAiYmFyIl9zdHIpOworICAgIAorICAgIG1hcDIuYWRkKCJFVGFnIl9zdHIsICJmb28iX3N0 cik7CisgICAgbWFwMi5hZGQoIkNhY2hlLUNvbnRyb2wiX3N0ciwgIm1heC1hZ2U6MCJfc3RyKTsK KyAgICBtYXAyLmFkZCgiTm90LUNvbW1vbjIiX3N0ciwgImJhciJfc3RyKTsKKyAgICBtYXAyLmFk ZCgiTm90LUNvbW1vbjEiX3N0ciwgImJhciJfc3RyKTsKKyAgICAKKyAgICBFWFBFQ1RfVFJVRSht YXAxID09IG1hcDIpOworICAgIEVYUEVDVF9GQUxTRShtYXAxICE9IG1hcDIpOworICAgIAorICAg IG1hcDEuYWRkKCJMYXN0LU1vZGlmaWVkIl9zdHIsICIxMjM0NTUiX3N0cik7CisgICAgbWFwMi5h ZGQoIkxhc3QtTW9kaWZpZWQiX3N0ciwgIjEyMzQ1NiJfc3RyKTsKKyAgICBFWFBFQ1RfRkFMU0Uo bWFwMSA9PSBtYXAyKTsKKyAgICBFWFBFQ1RfVFJVRShtYXAxICE9IG1hcDIpOworICAgIAorICAg IG1hcDEucmVtb3ZlKCJMYXN0LU1vZGlmaWVkIl9zdHIpOworICAgIG1hcDIucmVtb3ZlKCJMYXN0 LU1vZGlmaWVkIl9zdHIpOworICAgIEVYUEVDVF9UUlVFKG1hcDEgPT0gbWFwMik7CisgICAgRVhQ RUNUX0ZBTFNFKG1hcDEgIT0gbWFwMik7CisgICAgCisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24z Il9zdHIsICJiYXIiX3N0cik7CisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24zIl9zdHIsICJiYXoi X3N0cik7CisgICAgRVhQRUNUX0ZBTFNFKG1hcDEgPT0gbWFwMik7CisgICAgRVhQRUNUX1RSVUUo bWFwMSAhPSBtYXAyKTsKKworICAgIG1hcDEucmVtb3ZlKCJOb3QtQ29tbW9uMyJfc3RyKTsKKyAg ICBtYXAyLnJlbW92ZSgiTm90LUNvbW1vbjMiX3N0cik7CisgICAgRVhQRUNUX1RSVUUobWFwMSA9 PSBtYXAyKTsKKyAgICBFWFBFQ1RfRkFMU0UobWFwMSAhPSBtYXAyKTsKKworICAgIG1hcDEuYWRk KCJOT1QtQ09NTU9ONCJfc3RyLCAiZm9vIik7CisgICAgbWFwMi5hZGQoIk5vdC1Db21tb240Il9z dHIsICJmb28iKTsKKyAgICBFWFBFQ1RfVFJVRShtYXAxID09IG1hcDIpOworICAgIEVYUEVDVF9G QUxTRShtYXAxICE9IG1hcDIpOworfQorCitURVNUKEhUVFBIZWFkZXJNYXAsIENvbXBhcmlzb25P cGVyYXRvclNtYWxsTWFwKQoreworICAgIEhUVFBIZWFkZXJNYXAgbWFwMTsKKyAgICBIVFRQSGVh ZGVyTWFwIG1hcDI7CisgICAgdGVzdENvbXBhcmlzb25PcGVyYXRvcihtYXAxLCBtYXAyKTsKK30K KworVEVTVChIVFRQSGVhZGVyTWFwLCBDb21wYXJpc29uT3BlcmF0b3JMYXJnZU1hcCkKK3sKKyAg ICBIVFRQSGVhZGVyTWFwIG1hcDE7CisgICAgSFRUUEhlYWRlck1hcCBtYXAyOworICAgIGZvciAo aW50IGkgPSAwOyBpIDwgMzA7ICsraSkgeworICAgICAgICBhdXRvIGtleSA9IG1ha2VTdHJpbmco InBhZGRpbmciLCBpKTsKKyAgICAgICAgbWFwMS5hZGQoa2V5LCAiZm9vIik7CisgICAgICAgIG1h cDIuYWRkKGtleSwgImZvbyIpOworICAgIH0KKyAgICB0ZXN0Q29tcGFyaXNvbk9wZXJhdG9yKG1h cDEsIG1hcDIpOworfQorCit9Cg== 384203 2019-11-22 15:06:25 -0800 2019-11-22 15:22:48 -0800 Alternative Patch dealing with large maps HTTPHeaderMap_operator.patch text/plain 13126 cdumez ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAyMTExZjY3M2VjNS4uODRmNzkzOWFkYzIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMiBAQAorMjAxOS0xMS0yMiAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUuY29tPgor CisgICAgICAgIEhUVFBIZWFkZXJNYXAncyBvcGVyYXRvcj09IGlzIG5vdCBmdWxseSBjb3JyZWN0 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDQzNjEK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBpZiBoZWFk ZXJzIGFyZSBhZGRlZCBpbiBhIGRpZmZlcmVudCBvcmRlciwgSFRUUEhlYWRlck1hcCdzIG9wZXJh dG9yPT0oKSB3b3VsZCB3cm9uZ2x5CisgICAgICAgIHJldHVybiBmYWxzZSBiZWNhdXNlIGl0IGlz IHVzaW5nIGEgVmVjdG9yIGludGVybmFsbHkgdG8gc3RvcmUgdGhlIGhlYWRlcnMuIEFsc28sIGl0 cworICAgICAgICB3b3VsZCBpbmNvcnJlY3RseSByZXR1cm4gZmFsc2UgaWYgdGhlIGNhc2Ugb2Yg dGhlIEhUVFAgaGVhZGVycyB3b3VsZCBub3QgbWF0Y2guCisKKyAgICAgICAgKiBwbGF0Zm9ybS9u ZXR3b3JrL0hUVFBIZWFkZXJNYXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRUUEhlYWRlck1h cDo6Z2V0IGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OkhUVFBIZWFkZXJNYXA6OnVuY29tbW9u SGVhZGVyIGNvbnN0KToKKyAgICAgICAgKFdlYkNvcmU6OmNvbXBhcmVIZWFkZXJzKToKKyAgICAg ICAgKFdlYkNvcmU6OkhUVFBIZWFkZXJNYXA6OmVxdWFscyBjb25zdCk6CisgICAgICAgICogcGxh dGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmg6CisgICAgICAgIChXZWJDb3JlOjpIVFRQSGVh ZGVyTWFwOjpvcGVyYXRvcj09KToKKwogMjAxOS0xMS0yMiAgTXlsZXMgQy4gTWF4ZmllbGQgIDxt bWF4ZmllbGRAYXBwbGUuY29tPgogCiAgICAgICAgIFtDb2NvYV0gUmVuYW1lIHNvbWUgaW50ZXJu YWwgbmFtZXMgZm9yIHN5c3RlbSBmb250cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvSFRUUEhlYWRlck1hcC5jcHAKaW5kZXggMWU5NzlmODEyM2QuLmY5MGNkZjg5YzBk IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFkZXJN YXAuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1h cC5jcHAKQEAgLTU0LDcgKzU0LDExIEBAIFN0cmluZyBIVFRQSGVhZGVyTWFwOjpnZXQoY29uc3Qg U3RyaW5nJiBuYW1lKSBjb25zdAogICAgIEhUVFBIZWFkZXJOYW1lIGhlYWRlck5hbWU7CiAgICAg aWYgKGZpbmRIVFRQSGVhZGVyTmFtZShuYW1lLCBoZWFkZXJOYW1lKSkKICAgICAgICAgcmV0dXJu IGdldChoZWFkZXJOYW1lKTsKKyAgICByZXR1cm4gdW5jb21tb25IZWFkZXIobmFtZSk7Cit9CiAK K1N0cmluZyBIVFRQSGVhZGVyTWFwOjp1bmNvbW1vbkhlYWRlcihjb25zdCBTdHJpbmcmIG5hbWUp IGNvbnN0Cit7CiAgICAgYXV0byBpbmRleCA9IG1fdW5jb21tb25IZWFkZXJzLmZpbmRNYXRjaGlu ZyhbJl0oYXV0byYgaGVhZGVyKSB7CiAgICAgICAgIHJldHVybiBlcXVhbElnbm9yaW5nQVNDSUlD YXNlKGhlYWRlci5rZXksIG5hbWUpOwogICAgIH0pOwpAQCAtMjA2LDQgKzIxMCw0NCBAQCB2b2lk IEhUVFBIZWFkZXJNYXA6OmFkZChIVFRQSGVhZGVyTmFtZSBuYW1lLCBjb25zdCBTdHJpbmcmIHZh bHVlKQogICAgICAgICBtX2NvbW1vbkhlYWRlcnMuYXBwZW5kKENvbW1vbkhlYWRlciB7IG5hbWUs IHZhbHVlIH0pOwogfQogCit0ZW1wbGF0ZTx0eXBlbmFtZSBWLCB0eXBlbmFtZSBGPgorc3RhdGlj IGJvb2wgY29tcGFyZUhlYWRlcnMoY29uc3QgViYgaGVhZGVycywgY29uc3QgRiYgb3RoZXJIZWFk ZXJWYWx1ZSkKK3sKKyAgICBmb3IgKGF1dG8mIGhlYWRlciA6IGhlYWRlcnMpIHsKKyAgICAgICAg aWYgKG90aGVySGVhZGVyVmFsdWUoaGVhZGVyLmtleSkgIT0gaGVhZGVyLnZhbHVlKQorICAgICAg ICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKyAgICByZXR1cm4gdHJ1ZTsKK30KKworYm9vbCBI VFRQSGVhZGVyTWFwOjplcXVhbHMoY29uc3QgSFRUUEhlYWRlck1hcCYgb3RoZXIpIGNvbnN0Cit7 CisgICAgaWYgKG1fY29tbW9uSGVhZGVycy5zaXplKCkgIT0gb3RoZXIubV9jb21tb25IZWFkZXJz LnNpemUoKSB8fCBtX3VuY29tbW9uSGVhZGVycy5zaXplKCkgIT0gb3RoZXIubV91bmNvbW1vbkhl YWRlcnMuc2l6ZSgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBib29sIGlzVmVjdG9y U21hbGwgPSBtX2NvbW1vbkhlYWRlcnMuc2l6ZSgpIDw9IDE2OworICAgIGlmIChpc1ZlY3RvclNt YWxsKSB7CisgICAgICAgIC8vIENvbW1vbiBjYXNlLgorICAgICAgICBpZiAoIWNvbXBhcmVIZWFk ZXJzKG1fY29tbW9uSGVhZGVycywgWyZdKGF1dG8mIGtleSkgeyByZXR1cm4gb3RoZXIuZ2V0KGtl eSk7IH0pKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICBpZiAoIWNvbXBhcmVI ZWFkZXJzKG1fdW5jb21tb25IZWFkZXJzLCBbJl0oYXV0byYga2V5KSB7IHJldHVybiBvdGhlci51 bmNvbW1vbkhlYWRlcihrZXkpOyB9KSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgfQorCisgICAgSGFzaE1hcDxIVFRQSGVhZGVyTmFtZSwgU3Ry aW5nLCBXVEY6OkludEhhc2g8SFRUUEhlYWRlck5hbWU+LCBXVEY6OlN0cm9uZ0VudW1IYXNoVHJh aXRzPEhUVFBIZWFkZXJOYW1lPj4gb3RoZXJDb21tb25IZWFkZXJzOworICAgIGZvciAoYXV0byYg Y29tbW9uSGVhZGVyIDogb3RoZXIubV9jb21tb25IZWFkZXJzKQorICAgICAgICBvdGhlckNvbW1v bkhlYWRlcnMuYWRkKGNvbW1vbkhlYWRlci5rZXksIGNvbW1vbkhlYWRlci52YWx1ZSk7CisgICAg aWYgKCFjb21wYXJlSGVhZGVycyhtX2NvbW1vbkhlYWRlcnMsIFsmXShhdXRvJiBrZXkpIHsgcmV0 dXJuIG90aGVyQ29tbW9uSGVhZGVycy5nZXQoa2V5KTsgfSkpCisgICAgICAgIHJldHVybiBmYWxz ZTsKKworICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmcsIEFTQ0lJQ2FzZUluc2Vuc2l0aXZlSGFz aD4gb3RoZXJVbmNvbW1vbkhlYWRlcnM7CisgICAgZm9yIChhdXRvJiB1bmNvbW1vbkhlYWRlciA6 IG90aGVyLm1fdW5jb21tb25IZWFkZXJzKQorICAgICAgICBvdGhlclVuY29tbW9uSGVhZGVycy5h ZGQodW5jb21tb25IZWFkZXIua2V5LCB1bmNvbW1vbkhlYWRlci52YWx1ZSk7CisgICAgaWYgKCFj b21wYXJlSGVhZGVycyhtX3VuY29tbW9uSGVhZGVycywgWyZdKGF1dG8mIGtleSkgeyByZXR1cm4g b3RoZXJVbmNvbW1vbkhlYWRlcnMuZ2V0KGtleSk7IH0pKQorICAgICAgICByZXR1cm4gZmFsc2U7 CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFkZXJNYXAuaAppbmRleCAwYmQw NDI5OTQ2Ny4uOTc0NTA1ZTQ5OGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvSFRUUEhlYWRlck1hcC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvSFRUUEhlYWRlck1hcC5oCkBAIC0xNTgsNyArMTU4LDcgQEAgcHVibGljOgogICAgIFdF QkNPUkVfRVhQT1JUIHZvaWQgYWRkKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2 YWx1ZSk7CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBhcHBlbmQoY29uc3QgU3RyaW5nJiBuYW1l LCBjb25zdCBTdHJpbmcmIHZhbHVlKTsKICAgICBXRUJDT1JFX0VYUE9SVCBib29sIGNvbnRhaW5z KGNvbnN0IFN0cmluZyYpIGNvbnN0OwotICAgIGJvb2wgcmVtb3ZlKGNvbnN0IFN0cmluZyYpOwor ICAgIFdFQkNPUkVfRVhQT1JUIGJvb2wgcmVtb3ZlKGNvbnN0IFN0cmluZyYpOwogCiAjaWYgVVNF KENGKQogICAgIHZvaWQgc2V0KENGU3RyaW5nUmVmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmFsdWUp OwpAQCAtMTg4LDkgKzE4OCwxMSBAQCBwdWJsaWM6CiAgICAgY29uc3RfaXRlcmF0b3IgYmVnaW4o KSBjb25zdCB7IHJldHVybiBjb25zdF9pdGVyYXRvcigqdGhpcywgbV9jb21tb25IZWFkZXJzLmJl Z2luKCksIG1fdW5jb21tb25IZWFkZXJzLmJlZ2luKCkpOyB9CiAgICAgY29uc3RfaXRlcmF0b3Ig ZW5kKCkgY29uc3QgeyByZXR1cm4gY29uc3RfaXRlcmF0b3IoKnRoaXMsIG1fY29tbW9uSGVhZGVy cy5lbmQoKSwgbV91bmNvbW1vbkhlYWRlcnMuZW5kKCkpOyB9CiAKKyAgICBXRUJDT1JFX0VYUE9S VCBib29sIGVxdWFscyhjb25zdCBIVFRQSGVhZGVyTWFwJikgY29uc3Q7CisKICAgICBmcmllbmQg Ym9vbCBvcGVyYXRvcj09KGNvbnN0IEhUVFBIZWFkZXJNYXAmIGEsIGNvbnN0IEhUVFBIZWFkZXJN YXAmIGIpCiAgICAgewotICAgICAgICByZXR1cm4gYS5tX2NvbW1vbkhlYWRlcnMgPT0gYi5tX2Nv bW1vbkhlYWRlcnMgJiYgYS5tX3VuY29tbW9uSGVhZGVycyA9PSBiLm1fdW5jb21tb25IZWFkZXJz OworICAgICAgICByZXR1cm4gYS5lcXVhbHMoYik7CiAgICAgfQogCiAgICAgZnJpZW5kIGJvb2wg b3BlcmF0b3IhPShjb25zdCBIVFRQSGVhZGVyTWFwJiBhLCBjb25zdCBIVFRQSGVhZGVyTWFwJiBi KQpAQCAtMjAzLDYgKzIwNSw3IEBAIHB1YmxpYzoKIAogcHJpdmF0ZToKICAgICB2b2lkIHNldFVu Y29tbW9uSGVhZGVyKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSk7Cisg ICAgU3RyaW5nIHVuY29tbW9uSGVhZGVyKGNvbnN0IFN0cmluZyYgbmFtZSkgY29uc3Q7CiAKICAg ICBDb21tb25IZWFkZXJzVmVjdG9yIG1fY29tbW9uSGVhZGVyczsKICAgICBVbmNvbW1vbkhlYWRl cnNWZWN0b3IgbV91bmNvbW1vbkhlYWRlcnM7CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMzI1ZGE2ZGVmMWUuLmNjNDI1ZDMzZjhlIDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcg QEAKKzIwMTktMTEtMjIgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAg ICBIVFRQSGVhZGVyTWFwJ3Mgb3BlcmF0b3I9PSBpcyBub3QgZnVsbHkgY29ycmVjdAorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA0MzYxCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQSSB0ZXN0IGNv dmVyYWdlLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3Jl L0hUVFBIZWFkZXJNYXAuY3BwOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OnRlc3RD b21wYXJpc29uT3BlcmF0b3IpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIw MTktMTEtMjIgIFNpaHVpIExpdSAgPHNpaHVpX2xpdUBhcHBsZS5jb20+CiAKICAgICAgICAgQ3Jv c3MtdGhyZWFkIHZlcnNpb24gU3RvcmFnZVF1b3RhTWFuYWdlcgpkaWZmIC0tZ2l0IGEvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agppbmRleCBiM2JhOWEyY2FkZS4uODI1MmY5OGRlMmYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q CkBAIC0yNDYsNiArMjQ2LDcgQEAKIAkJNDZFNjZBOTAxRjBENzU1OTAwMjZEODNDIC8qIFdLV2Vi Vmlld0RpYWdub3N0aWNMb2dnaW5nLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNDZFNjZBOEYxRjBENzU1OTAwMjZEODNDIC8qIFdLV2ViVmlld0RpYWdu b3N0aWNMb2dnaW5nLm1tICovOyB9OwogCQk0NkU4MTZGODFFNzlFMjlDMDAzNzVBREMgLyogUmVz dG9yZVN0YXRlQWZ0ZXJUZXJtaW5hdGlvbi5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDQ2RTgxNkY3MUU3OUUyOTEwMDM3NUFEQyAvKiBSZXN0b3JlU3Rh dGVBZnRlclRlcm1pbmF0aW9uLm1tICovOyB9OwogCQk0NkVCRDg0NzIzNzIzMjBGMDAyMjNBNkUg LyogUmVzdG9yZVNjcm9sbFBvc2l0aW9uLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gNDZFQkQ4NDYyMzcyMzFFNjAwMjIzQTZFIC8qIFJlc3RvcmVTY3Jv bGxQb3NpdGlvbi5tbSAqLzsgfTsKKwkJNDZGQTJGRUUyMzg0NkNBNTAwMENDQjBDIC8qIEhUVFBI ZWFkZXJNYXAuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gNDZGQTJGRUQyMzg0NkM5QTAwMENDQjBDIC8qIEhUVFBIZWFkZXJNYXAuY3BwICovOyB9Owog CQk0OTA5RUUzQTJEMDk0ODBDODg5ODJENTYgLyogTWFya2FibGUuY3BwIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRUM3OUYxNjhCRTQ1NEU1NzlFNDE3QjA1 IC8qIE1hcmthYmxlLmNwcCAqLzsgfTsKIAkJNEJGREZGQTcxMzE0Nzc2QzAwNjFGMjRCIC8qIEhp dFRlc3RSZXN1bHROb2RlSGFuZGxlX0J1bmRsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0QkZERkZBNjEzMTQ3NzZDMDA2MUYyNEIgLyogSGl0VGVz dFJlc3VsdE5vZGVIYW5kbGVfQnVuZGxlLmNwcCAqLzsgfTsKIAkJNTEwNDc3NzIxRDI5OERERDAw OTc0N0VCIC8qIElEQkRlbGV0ZVJlY292ZXJ5LnNxbGl0ZTMgaW4gQ29weSBSZXNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTEwNDc3NkYxRDI5OEQ4NTAwOTc0N0VC IC8qIElEQkRlbGV0ZVJlY292ZXJ5LnNxbGl0ZTMgKi87IH07CkBAIC0xNzc4LDYgKzE3NzksNyBA QAogCQk0NkU2NkE4RjFGMEQ3NTU5MDAyNkQ4M0MgLyogV0tXZWJWaWV3RGlhZ25vc3RpY0xvZ2dp bmcubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBXS1dlYlZpZXdE aWFnbm9zdGljTG9nZ2luZy5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDZFODE2 RjcxRTc5RTI5MTAwMzc1QURDIC8qIFJlc3RvcmVTdGF0ZUFmdGVyVGVybWluYXRpb24ubW0gKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBSZXN0b3JlU3RhdGVBZnRlclRl cm1pbmF0aW9uLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0NkVCRDg0NjIzNzIz MUU2MDAyMjNBNkUgLyogUmVzdG9yZVNjcm9sbFBvc2l0aW9uLm1tICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAub2JqY3BwOyBwYXRoID0gUmVzdG9yZVNjcm9sbFBvc2l0aW9uLm1tOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OworCQk0NkZBMkZFRDIzODQ2QzlBMDAwQ0NCMEMgLyogSFRUUEhl YWRlck1hcC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBIVFRQSGVh ZGVyTWFwLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNEE0MTBGNEIxOUFGN0JE NjAwMkVCQUI1IC8qIFVzZXJNZWRpYS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7 IHBhdGggPSBVc2VyTWVkaWEuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0QTQx MEY0RDE5QUY3QkVGMDAyRUJBQjUgLyogZ2V0VXNlck1lZGlhLmh0bWwgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0 Lmh0bWw7IHBhdGggPSBnZXRVc2VyTWVkaWEuaHRtbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJNEE0MTBGNEQxOUFGN0JFRjAwMkVCQUI2IC8qIG9uZGV2aWNlY2hhbmdlLmh0bWwgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSB0ZXh0Lmh0bWw7IHBhdGggPSBvbmRldmljZWNoYW5nZS5odG1sOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwpAQCAtMzEwMyw2ICszMTA1LDcgQEAKIAkJCQk4RTRBODUzNjFFMUQx QUExMDBGNTNCMEYgLyogR3JpZFBvc2l0aW9uLmNwcCAqLywKIAkJCQk4M0I4OEEzMzFDODAwNTZE MDBCQjI0MTggLyogSFRNTFBhcnNlcklkaW9tcy5jcHAgKi8sCiAJCQkJNUNBMURFQzcxRjcxRjQw NzAwRTcxQkQzIC8qIEhUVFBIZWFkZXJGaWVsZC5jcHAgKi8sCisJCQkJNDZGQTJGRUQyMzg0NkM5 QTAwMENDQjBDIC8qIEhUVFBIZWFkZXJNYXAuY3BwICovLAogCQkJCTZCOUFCRTExMjA4Njk1MkYw MEQ3NURFNiAvKiBIVFRQUGFyc2Vycy5jcHAgKi8sCiAJCQkJN0E5MDlBNzMxRDg3NzQ3NTAwN0Ux MEY4IC8qIEludFBvaW50LmNwcCAqLywKIAkJCQk3QTkwOUE3NDFEODc3NDc1MDA3RTEwRjggLyog SW50UmVjdC5jcHAgKi8sCkBAIC00NjY3LDYgKzQ2NzAsNyBAQAogCQkJCTdDQ0U3RUMyMUE0MTFB N0UwMDQ0N0M0QyAvKiBIVE1MRm9ybUNvbGxlY3Rpb25OYW1lZEl0ZW0ubW0gaW4gU291cmNlcyAq LywKIAkJCQk3QzgzRTA1MDFEMEE2NDE4MDBGRUJDRjMgLyogSFRNTFBhcnNlcklkaW9tcy5jcHAg aW4gU291cmNlcyAqLywKIAkJCQk1Q0ExREVDODFGNzFGNzAxMDBFNzFCRDMgLyogSFRUUEhlYWRl ckZpZWxkLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTQ2RkEyRkVFMjM4NDZDQTUwMDBDQ0IwQyAv KiBIVFRQSGVhZGVyTWFwLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTZCOUFCRTEyMjA4Njk1MkYw MEQ3NURFNiAvKiBIVFRQUGFyc2Vycy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk1QzdDMjRGQzIz N0M5NzU0MDA1OTlDOTEgLyogSFRUUFNlcnZlci5tbSBpbiBTb3VyY2VzICovLAogCQkJCTUxQUYy M0RGMUVGMUEzNzMwMDcyRjI4MSAvKiBJY29uTG9hZGluZ0RlbGVnYXRlLm1tIGluIFNvdXJjZXMg Ki8sCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvSFRUUEhl YWRlck1hcC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvSFRUUEhlYWRl ck1hcC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjMxY2M4Mjc4 NTZmCi0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3Jl L0hUVFBIZWFkZXJNYXAuY3BwCkBAIC0wLDAgKzEsOTYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQor ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRl ICJUZXN0LmgiCisjaW5jbHVkZSA8V2ViQ29yZS9IVFRQSGVhZGVyTWFwLmg+CisjaW5jbHVkZSA8 d3RmL3RleHQvU3RyaW5nQ29uY2F0ZW5hdGVOdW1iZXJzLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBX ZWJDb3JlOworCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK3N0YXRpYyB2b2lkIHRlc3RD b21wYXJpc29uT3BlcmF0b3IoSFRUUEhlYWRlck1hcCBtYXAxLCBIVFRQSGVhZGVyTWFwIG1hcDIp Cit7CisgICAgbWFwMS5hZGQoIkNhY2hlLUNvbnRyb2wiX3N0ciwgIm1heC1hZ2U6MCJfc3RyKTsK KyAgICBtYXAxLmFkZCgiRVRhZyJfc3RyLCAiZm9vIl9zdHIpOworICAgIG1hcDEuYWRkKCJOb3Qt Q29tbW9uMSJfc3RyLCAiYmFyIl9zdHIpOworICAgIG1hcDEuYWRkKCJOb3QtQ29tbW9uMiJfc3Ry LCAiYmFyIl9zdHIpOworICAgIAorICAgIG1hcDIuYWRkKCJFVGFnIl9zdHIsICJmb28iX3N0cik7 CisgICAgbWFwMi5hZGQoIkNhY2hlLUNvbnRyb2wiX3N0ciwgIm1heC1hZ2U6MCJfc3RyKTsKKyAg ICBtYXAyLmFkZCgiTm90LUNvbW1vbjIiX3N0ciwgImJhciJfc3RyKTsKKyAgICBtYXAyLmFkZCgi Tm90LUNvbW1vbjEiX3N0ciwgImJhciJfc3RyKTsKKyAgICAKKyAgICBFWFBFQ1RfVFJVRShtYXAx ID09IG1hcDIpOworICAgIEVYUEVDVF9GQUxTRShtYXAxICE9IG1hcDIpOworICAgIAorICAgIG1h cDEuYWRkKCJMYXN0LU1vZGlmaWVkIl9zdHIsICIxMjM0NTUiX3N0cik7CisgICAgbWFwMi5hZGQo Ikxhc3QtTW9kaWZpZWQiX3N0ciwgIjEyMzQ1NiJfc3RyKTsKKyAgICBFWFBFQ1RfRkFMU0UobWFw MSA9PSBtYXAyKTsKKyAgICBFWFBFQ1RfVFJVRShtYXAxICE9IG1hcDIpOworICAgIAorICAgIG1h cDEucmVtb3ZlKCJMYXN0LU1vZGlmaWVkIl9zdHIpOworICAgIG1hcDIucmVtb3ZlKCJMYXN0LU1v ZGlmaWVkIl9zdHIpOworICAgIEVYUEVDVF9UUlVFKG1hcDEgPT0gbWFwMik7CisgICAgRVhQRUNU X0ZBTFNFKG1hcDEgIT0gbWFwMik7CisgICAgCisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24zIl9z dHIsICJiYXIiX3N0cik7CisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24zIl9zdHIsICJiYXoiX3N0 cik7CisgICAgRVhQRUNUX0ZBTFNFKG1hcDEgPT0gbWFwMik7CisgICAgRVhQRUNUX1RSVUUobWFw MSAhPSBtYXAyKTsKKworICAgIG1hcDEucmVtb3ZlKCJOb3QtQ29tbW9uMyJfc3RyKTsKKyAgICBt YXAyLnJlbW92ZSgiTm90LUNvbW1vbjMiX3N0cik7CisgICAgRVhQRUNUX1RSVUUobWFwMSA9PSBt YXAyKTsKKyAgICBFWFBFQ1RfRkFMU0UobWFwMSAhPSBtYXAyKTsKKworICAgIG1hcDEuYWRkKCJO T1QtQ09NTU9ONCJfc3RyLCAiZm9vIik7CisgICAgbWFwMi5hZGQoIk5vdC1Db21tb240Il9zdHIs ICJmb28iKTsKKyAgICBFWFBFQ1RfVFJVRShtYXAxID09IG1hcDIpOworICAgIEVYUEVDVF9GQUxT RShtYXAxICE9IG1hcDIpOworfQorCitURVNUKEhUVFBIZWFkZXJNYXAsIENvbXBhcmlzb25PcGVy YXRvclNtYWxsTWFwKQoreworICAgIEhUVFBIZWFkZXJNYXAgbWFwMTsKKyAgICBIVFRQSGVhZGVy TWFwIG1hcDI7CisgICAgdGVzdENvbXBhcmlzb25PcGVyYXRvcihtYXAxLCBtYXAyKTsKK30KKwor VEVTVChIVFRQSGVhZGVyTWFwLCBDb21wYXJpc29uT3BlcmF0b3JMYXJnZU1hcCkKK3sKKyAgICBI VFRQSGVhZGVyTWFwIG1hcDE7CisgICAgSFRUUEhlYWRlck1hcCBtYXAyOworICAgIGZvciAoaW50 IGkgPSAwOyBpIDwgMzA7ICsraSkgeworICAgICAgICBhdXRvIGtleSA9IG1ha2VTdHJpbmcoInBh ZGRpbmciLCBpKTsKKyAgICAgICAgbWFwMS5hZGQoa2V5LCAiZm9vIik7CisgICAgICAgIG1hcDIu YWRkKGtleSwgImZvbyIpOworICAgIH0KKyAgICB0ZXN0Q29tcGFyaXNvbk9wZXJhdG9yKG1hcDEs IG1hcDIpOworfQorCit9Cg== 384206 2019-11-22 15:22:50 -0800 2019-11-22 16:04:12 -0800 Patch bug-204361-20191122152249.patch text/plain 11278 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjUyODA3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmRmZWE1ODI0MjJiYmQ4 NjQ1ZGI0MDNkZWE1OTQxOGE4MmQ5NGFjNy4uNjEwM2RhNGU1NTBmNjJjNTA0MzZkM2IzNGE2NDhm N2U4MGZkZTIzNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDE5LTExLTIyICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSFRUUEhlYWRlck1hcCdzIG9w ZXJhdG9yPT0gaXMgbm90IGZ1bGx5IGNvcnJlY3QKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDM2MQorCisgICAgICAgIFJldmlld2VkIGJ5IEFsZXgg Q2hyaXN0ZW5zZW4uCisKKyAgICAgICAgSWYgaGVhZGVycyBhcmUgYWRkZWQgaW4gYSBkaWZmZXJl bnQgb3JkZXIsIEhUVFBIZWFkZXJNYXAncyBvcGVyYXRvcj09KCkgd291bGQgd3JvbmdseQorICAg ICAgICByZXR1cm4gZmFsc2UgYmVjYXVzZSBpdCBpcyB1c2luZyBhIFZlY3RvciBpbnRlcm5hbGx5 IHRvIHN0b3JlIHRoZSBoZWFkZXJzLiBBbHNvLCBpdAorICAgICAgICB3b3VsZCBpbmNvcnJlY3Rs eSByZXR1cm4gZmFsc2UgaWYgdGhlIGNhc2Ugb2YgdGhlIGhlYWRlcnMgZGlkIG5vdCBtYXRjaC4K KworICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpIVFRQSGVhZGVyTWFwOjpnZXQgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6 SFRUUEhlYWRlck1hcDo6Z2V0VW5jb21tb25IZWFkZXIgY29uc3QpOgorICAgICAgICAqIHBsYXRm b3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5oOgorICAgICAgICAoV2ViQ29yZTo6SFRUUEhlYWRl ck1hcDo6b3BlcmF0b3I9PSk6CisKIDIwMTktMTEtMjIgIFphbGFuIEJ1anRhcyAgPHphbGFuQGFw cGxlLmNvbT4KIAogICAgICAgICBbTEZDXVtJRkNdIExpbmU6OlJ1bjo6ZXhwYW5kIHNob3VsZCB0 YWtlIGEgcmFuZ2Ugb2YgcnVucyB0byBtZXJnZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5jcHAKaW5kZXggMWU5NzlmODEyM2Q2YzM1NzMwNzgx NDc0YzlhZGI0M2Q4Yzg3MWJiOS4uMzljYjU2MGU1NGJmOWVmZDJkYWQ2ZTFmYjYwZGQwZjYwOWRh ZjZiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVh ZGVyTWFwLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFk ZXJNYXAuY3BwCkBAIC01NSw2ICs1NSwxMSBAQCBTdHJpbmcgSFRUUEhlYWRlck1hcDo6Z2V0KGNv bnN0IFN0cmluZyYgbmFtZSkgY29uc3QKICAgICBpZiAoZmluZEhUVFBIZWFkZXJOYW1lKG5hbWUs IGhlYWRlck5hbWUpKQogICAgICAgICByZXR1cm4gZ2V0KGhlYWRlck5hbWUpOwogCisgICAgcmV0 dXJuIGdldFVuY29tbW9uSGVhZGVyKG5hbWUpOworfQorCitTdHJpbmcgSFRUUEhlYWRlck1hcDo6 Z2V0VW5jb21tb25IZWFkZXIoY29uc3QgU3RyaW5nJiBuYW1lKSBjb25zdAorewogICAgIGF1dG8g aW5kZXggPSBtX3VuY29tbW9uSGVhZGVycy5maW5kTWF0Y2hpbmcoWyZdKGF1dG8mIGhlYWRlcikg ewogICAgICAgICByZXR1cm4gZXF1YWxJZ25vcmluZ0FTQ0lJQ2FzZShoZWFkZXIua2V5LCBuYW1l KTsKICAgICB9KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv SFRUUEhlYWRlck1hcC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVh ZGVyTWFwLmgKaW5kZXggMGJkMDQyOTk0NjcwNGVjMDdjZjk1ZGRlZGMzNzZmOTFhMzdmMjM1My4u NjAwMDc0NTk5N2U1NTVkYzI4Y2FhYzE0MGVlNWMyM2Y2MzdhOGI5NSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmgKQEAgLTE1OCw3ICsxNTgs NyBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBhZGQoY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlKTsKICAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGFwcGVu ZChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmFsdWUpOwogICAgIFdFQkNPUkVf RVhQT1JUIGJvb2wgY29udGFpbnMoY29uc3QgU3RyaW5nJikgY29uc3Q7Ci0gICAgYm9vbCByZW1v dmUoY29uc3QgU3RyaW5nJik7CisgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCByZW1vdmUoY29uc3Qg U3RyaW5nJik7CiAKICNpZiBVU0UoQ0YpCiAgICAgdm9pZCBzZXQoQ0ZTdHJpbmdSZWYgbmFtZSwg Y29uc3QgU3RyaW5nJiB2YWx1ZSk7CkBAIC0xOTAsNyArMTkwLDE3IEBAIHB1YmxpYzoKIAogICAg IGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgSFRUUEhlYWRlck1hcCYgYSwgY29uc3QgSFRU UEhlYWRlck1hcCYgYikKICAgICB7Ci0gICAgICAgIHJldHVybiBhLm1fY29tbW9uSGVhZGVycyA9 PSBiLm1fY29tbW9uSGVhZGVycyAmJiBhLm1fdW5jb21tb25IZWFkZXJzID09IGIubV91bmNvbW1v bkhlYWRlcnM7CisgICAgICAgIGlmIChhLm1fY29tbW9uSGVhZGVycy5zaXplKCkgIT0gYi5tX2Nv bW1vbkhlYWRlcnMuc2l6ZSgpIHx8IGEubV91bmNvbW1vbkhlYWRlcnMuc2l6ZSgpICE9IGIubV91 bmNvbW1vbkhlYWRlcnMuc2l6ZSgpKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAg ICBmb3IgKGF1dG8mIGNvbW1vbkhlYWRlciA6IGEubV9jb21tb25IZWFkZXJzKSB7CisgICAgICAg ICAgICBpZiAoYi5nZXQoY29tbW9uSGVhZGVyLmtleSkgIT0gY29tbW9uSGVhZGVyLnZhbHVlKQor ICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfQorICAgICAgICBmb3IgKGF1 dG8mIHVuY29tbW9uSGVhZGVyIDogYS5tX3VuY29tbW9uSGVhZGVycykgeworICAgICAgICAgICAg aWYgKGIuZ2V0VW5jb21tb25IZWFkZXIodW5jb21tb25IZWFkZXIua2V5KSAhPSB1bmNvbW1vbkhl YWRlci52YWx1ZSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0KKyAg ICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQogCiAgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3IhPShj b25zdCBIVFRQSGVhZGVyTWFwJiBhLCBjb25zdCBIVFRQSGVhZGVyTWFwJiBiKQpAQCAtMjAzLDYg KzIxMyw3IEBAIHB1YmxpYzoKIAogcHJpdmF0ZToKICAgICB2b2lkIHNldFVuY29tbW9uSGVhZGVy KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSk7CisgICAgV0VCQ09SRV9F WFBPUlQgU3RyaW5nIGdldFVuY29tbW9uSGVhZGVyKGNvbnN0IFN0cmluZyYgbmFtZSkgY29uc3Q7 CiAKICAgICBDb21tb25IZWFkZXJzVmVjdG9yIG1fY29tbW9uSGVhZGVyczsKICAgICBVbmNvbW1v bkhlYWRlcnNWZWN0b3IgbV91bmNvbW1vbkhlYWRlcnM7CmRpZmYgLS1naXQgYS9Ub29scy9DaGFu Z2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMzI1ZGE2ZGVmMWU0YjFmNzJlYTJmOWFmMzY1 Y2ExNTBlZWZmMzQzZC4uNDU0N2U2NTFkM2YwYmM1OWRkNjRkMTE2MDk4NmIxZjFhZDA3YTNlMCAx MDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE2IEBACisyMDE5LTExLTIyICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisK KyAgICAgICAgSFRUUEhlYWRlck1hcCdzIG9wZXJhdG9yPT0gaXMgbm90IGZ1bGx5IGNvcnJlY3QK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDM2MQor CisgICAgICAgIFJldmlld2VkIGJ5IEFsZXggQ2hyaXN0ZW5zZW4uCisKKyAgICAgICAgQWRkIEFQ SSB0ZXN0IGNvdmVyYWdlLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJ Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJDb3JlL0hUVFBIZWFkZXJNYXAuY3BwOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRB UEk6OlRFU1QpOgorCiAyMDE5LTExLTIyICBTaWh1aSBMaXUgIDxzaWh1aV9saXVAYXBwbGUuY29t PgogCiAgICAgICAgIENyb3NzLXRocmVhZCB2ZXJzaW9uIFN0b3JhZ2VRdW90YU1hbmFnZXIKZGlm ZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oKaW5kZXggYjNiYTlhMmNhZGVmYTFiNWE1OThhNmU0MjA2NDIxNjdm NjYxNGUwZS4uODI1MmY5OGRlMmY1NzllNDA2NTc0NDM4YzY3ODhjMWUzNWZlZDFkYSAxMDA2NDQK LS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2oKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oKQEAgLTI0Niw2ICsyNDYsNyBAQAogCQk0NkU2NkE5MDFGMEQ3NTU5 MDAyNkQ4M0MgLyogV0tXZWJWaWV3RGlhZ25vc3RpY0xvZ2dpbmcubW0gaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NkU2NkE4RjFGMEQ3NTU5MDAyNkQ4M0Mg LyogV0tXZWJWaWV3RGlhZ25vc3RpY0xvZ2dpbmcubW0gKi87IH07CiAJCTQ2RTgxNkY4MUU3OUUy OUMwMDM3NUFEQyAvKiBSZXN0b3JlU3RhdGVBZnRlclRlcm1pbmF0aW9uLm1tIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDZFODE2RjcxRTc5RTI5MTAwMzc1 QURDIC8qIFJlc3RvcmVTdGF0ZUFmdGVyVGVybWluYXRpb24ubW0gKi87IH07CiAJCTQ2RUJEODQ3 MjM3MjMyMEYwMDIyM0E2RSAvKiBSZXN0b3JlU2Nyb2xsUG9zaXRpb24ubW0gaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NkVCRDg0NjIzNzIzMUU2MDAyMjNB NkUgLyogUmVzdG9yZVNjcm9sbFBvc2l0aW9uLm1tICovOyB9OworCQk0NkZBMkZFRTIzODQ2Q0E1 MDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA0NkZBMkZFRDIzODQ2QzlBMDAwQ0NCMEMgLyogSFRUUEhlYWRl ck1hcC5jcHAgKi87IH07CiAJCTQ5MDlFRTNBMkQwOTQ4MEM4ODk4MkQ1NiAvKiBNYXJrYWJsZS5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFQzc5RjE2 OEJFNDU0RTU3OUU0MTdCMDUgLyogTWFya2FibGUuY3BwICovOyB9OwogCQk0QkZERkZBNzEzMTQ3 NzZDMDA2MUYyNEIgLyogSGl0VGVzdFJlc3VsdE5vZGVIYW5kbGVfQnVuZGxlLmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRCRkRGRkE2MTMxNDc3NkMw MDYxRjI0QiAvKiBIaXRUZXN0UmVzdWx0Tm9kZUhhbmRsZV9CdW5kbGUuY3BwICovOyB9OwogCQk1 MTA0Nzc3MjFEMjk4REREMDA5NzQ3RUIgLyogSURCRGVsZXRlUmVjb3Zlcnkuc3FsaXRlMyBpbiBD b3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTA0Nzc2 RjFEMjk4RDg1MDA5NzQ3RUIgLyogSURCRGVsZXRlUmVjb3Zlcnkuc3FsaXRlMyAqLzsgfTsKQEAg LTE3NzgsNiArMTc3OSw3IEBACiAJCTQ2RTY2QThGMUYwRDc1NTkwMDI2RDgzQyAvKiBXS1dlYlZp ZXdEaWFnbm9zdGljTG9nZ2luZy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsg cGF0aCA9IFdLV2ViVmlld0RpYWdub3N0aWNMb2dnaW5nLm1tOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk0NkU4MTZGNzFFNzlFMjkxMDAzNzVBREMgLyogUmVzdG9yZVN0YXRlQWZ0ZXJU ZXJtaW5hdGlvbi5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFJl c3RvcmVTdGF0ZUFmdGVyVGVybWluYXRpb24ubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTQ2RUJEODQ2MjM3MjMxRTYwMDIyM0E2RSAvKiBSZXN0b3JlU2Nyb2xsUG9zaXRpb24ubW0g Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBSZXN0b3JlU2Nyb2xsUG9z aXRpb24ubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQ2RkEyRkVEMjM4NDZDOUEw MDBDQ0IwQyAvKiBIVFRQSGVhZGVyTWFwLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IEhUVFBIZWFkZXJNYXAuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQk0QTQxMEY0QjE5QUY3QkQ2MDAyRUJBQjUgLyogVXNlck1lZGlhLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFVzZXJNZWRpYS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTRBNDEwRjREMTlBRjdCRUYwMDJFQkFCNSAvKiBnZXRVc2VyTWVkaWEuaHRt bCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IGdldFVzZXJNZWRpYS5odG1sOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk0QTQxMEY0RDE5QUY3QkVGMDAyRUJBQjYgLyogb25kZXZp Y2VjaGFuZ2UuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IG9uZGV2aWNlY2hhbmdl Lmh0bWw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zMTAzLDYgKzMxMDUsNyBAQAog CQkJCThFNEE4NTM2MUUxRDFBQTEwMEY1M0IwRiAvKiBHcmlkUG9zaXRpb24uY3BwICovLAogCQkJ CTgzQjg4QTMzMUM4MDA1NkQwMEJCMjQxOCAvKiBIVE1MUGFyc2VySWRpb21zLmNwcCAqLywKIAkJ CQk1Q0ExREVDNzFGNzFGNDA3MDBFNzFCRDMgLyogSFRUUEhlYWRlckZpZWxkLmNwcCAqLywKKwkJ CQk0NkZBMkZFRDIzODQ2QzlBMDAwQ0NCMEMgLyogSFRUUEhlYWRlck1hcC5jcHAgKi8sCiAJCQkJ NkI5QUJFMTEyMDg2OTUyRjAwRDc1REU2IC8qIEhUVFBQYXJzZXJzLmNwcCAqLywKIAkJCQk3QTkw OUE3MzFEODc3NDc1MDA3RTEwRjggLyogSW50UG9pbnQuY3BwICovLAogCQkJCTdBOTA5QTc0MUQ4 Nzc0NzUwMDdFMTBGOCAvKiBJbnRSZWN0LmNwcCAqLywKQEAgLTQ2NjcsNiArNDY3MCw3IEBACiAJ CQkJN0NDRTdFQzIxQTQxMUE3RTAwNDQ3QzRDIC8qIEhUTUxGb3JtQ29sbGVjdGlvbk5hbWVkSXRl bS5tbSBpbiBTb3VyY2VzICovLAogCQkJCTdDODNFMDUwMUQwQTY0MTgwMEZFQkNGMyAvKiBIVE1M UGFyc2VySWRpb21zLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTVDQTFERUM4MUY3MUY3MDEwMEU3 MUJEMyAvKiBIVFRQSGVhZGVyRmllbGQuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJNDZGQTJGRUUy Mzg0NkNBNTAwMENDQjBDIC8qIEhUVFBIZWFkZXJNYXAuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ NkI5QUJFMTIyMDg2OTUyRjAwRDc1REU2IC8qIEhUVFBQYXJzZXJzLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTVDN0MyNEZDMjM3Qzk3NTQwMDU5OUM5MSAvKiBIVFRQU2VydmVyLm1tIGluIFNvdXJj ZXMgKi8sCiAJCQkJNTFBRjIzREYxRUYxQTM3MzAwNzJGMjgxIC8qIEljb25Mb2FkaW5nRGVsZWdh dGUubW0gaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViQ29yZS9IVFRQSGVhZGVyTWFwLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViQ29yZS9IVFRQSGVhZGVyTWFwLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yZjZkODRkMWUwNDk3OWMwZTg0 ODUyM2FhNWMwZTc2NTA5NmI4OWJkCi0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJDb3JlL0hUVFBIZWFkZXJNYXAuY3BwCkBAIC0wLDAgKzEsNzkgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBg YEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisKKyNpbmNsdWRlICJUZXN0LmgiCisjaW5jbHVkZSA8V2ViQ29yZS9IVFRQSGVhZGVy TWFwLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCituYW1lc3BhY2UgVGVzdFdlYktp dEFQSSB7CisKK1RFU1QoSFRUUEhlYWRlck1hcCwgQ29tcGFyaXNvbk9wZXJhdG9yKQoreworICAg IEhUVFBIZWFkZXJNYXAgbWFwMTsKKyAgICBIVFRQSGVhZGVyTWFwIG1hcDI7CisKKyAgICBtYXAx LmFkZCgiQ2FjaGUtQ29udHJvbCJfc3RyLCAibWF4LWFnZTowIl9zdHIpOworICAgIG1hcDEuYWRk KCJFVGFnIl9zdHIsICJmb28iX3N0cik7CisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24xIl9zdHIs ICJiYXIiX3N0cik7CisgICAgbWFwMS5hZGQoIk5vdC1Db21tb24yIl9zdHIsICJiYXIiX3N0cik7 CisKKyAgICBtYXAyLmFkZCgiRVRhZyJfc3RyLCAiZm9vIl9zdHIpOworICAgIG1hcDIuYWRkKCJD YWNoZS1Db250cm9sIl9zdHIsICJtYXgtYWdlOjAiX3N0cik7CisgICAgbWFwMi5hZGQoIk5vdC1D b21tb24yIl9zdHIsICJiYXIiX3N0cik7CisgICAgbWFwMi5hZGQoIk5vdC1Db21tb24xIl9zdHIs ICJiYXIiX3N0cik7CisKKyAgICBFWFBFQ1RfVFJVRShtYXAxID09IG1hcDIpOworICAgIEVYUEVD VF9GQUxTRShtYXAxICE9IG1hcDIpOworCisgICAgbWFwMS5hZGQoIkxhc3QtTW9kaWZpZWQiX3N0 ciwgIjEyMzQ1NSJfc3RyKTsKKyAgICBtYXAyLmFkZCgiTGFzdC1Nb2RpZmllZCJfc3RyLCAiMTIz NDU2Il9zdHIpOworICAgIEVYUEVDVF9GQUxTRShtYXAxID09IG1hcDIpOworICAgIEVYUEVDVF9U UlVFKG1hcDEgIT0gbWFwMik7CisKKyAgICBtYXAxLnJlbW92ZSgiTGFzdC1Nb2RpZmllZCJfc3Ry KTsKKyAgICBtYXAyLnJlbW92ZSgiTGFzdC1Nb2RpZmllZCJfc3RyKTsKKyAgICBFWFBFQ1RfVFJV RShtYXAxID09IG1hcDIpOworICAgIEVYUEVDVF9GQUxTRShtYXAxICE9IG1hcDIpOworCisgICAg bWFwMS5hZGQoIk5vdC1Db21tb24zIl9zdHIsICJiYXIiX3N0cik7CisgICAgbWFwMS5hZGQoIk5v dC1Db21tb24zIl9zdHIsICJiYXoiX3N0cik7CisgICAgRVhQRUNUX0ZBTFNFKG1hcDEgPT0gbWFw Mik7CisgICAgRVhQRUNUX1RSVUUobWFwMSAhPSBtYXAyKTsKKworICAgIG1hcDEucmVtb3ZlKCJO b3QtQ29tbW9uMyJfc3RyKTsKKyAgICBtYXAyLnJlbW92ZSgiTm90LUNvbW1vbjMiX3N0cik7Cisg ICAgRVhQRUNUX1RSVUUobWFwMSA9PSBtYXAyKTsKKyAgICBFWFBFQ1RfRkFMU0UobWFwMSAhPSBt YXAyKTsKKworICAgIG1hcDEuYWRkKCJOT1QtQ09NTU9ONCJfc3RyLCAiZm9vIik7CisgICAgbWFw Mi5hZGQoIk5vdC1Db21tb240Il9zdHIsICJmb28iKTsKKyAgICBFWFBFQ1RfVFJVRShtYXAxID09 IG1hcDIpOworICAgIEVYUEVDVF9GQUxTRShtYXAxICE9IG1hcDIpOworfQorCit9Cg==