144310 2015-04-27 20:11:47 -0700 NodeList has issues with Symbol and empty string 2015-04-29 18:14:25 -0700 1 1 1 Unclassified WebKit JavaScriptCore 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 joepeck joepeck benjamin darin ggaren joepeck rniwa webkit-bug-importer ysuzuki oldest_to_newest 1089356 0 joepeck 2015-04-27 20:11:47 -0700 * SUMMARY NodeList has issues with Symbol. * STEPS TO REPRODUCE 1. Inspect <http://www.webkit.org> 2. js> document.querySelectorAll("nothing")[Symbol()] => expected undefined, actually got <p> * NOTES - This affects Array.from(NodeList), because apparently NodeList[Symbol.iterator] is returning a Node, instead of undefined. 1089357 1 webkit-bug-importer 2015-04-27 20:13:07 -0700 <rdar://problem/20721814> 1089411 2 rniwa 2015-04-27 22:43:29 -0700 I suspect what's happening is that propertyNameToAtomicString in JSDOMBinding.h is converting Symbol() to some valid string: inline AtomicString propertyNameToAtomicString(JSC::PropertyName propertyName) { return AtomicString(propertyName.publicName()); } 1089412 3 rniwa 2015-04-27 22:44:09 -0700 See https://github.com/WebKit/webkit/blob/master/Source/WebCore/bindings/js/JSNodeListCustom.cpp#L54 1089672 4 joepeck 2015-04-28 12:26:03 -0700 Yes, the issue here is: 54 bool JSNodeList::getOwnPropertySlotDelegate(ExecState* exec, PropertyName propertyName, PropertySlot& slot) 55 { -> 56 if (Node* item = impl().namedItem(propertyNameToAtomicString(propertyName))) { 57 slot.setValue(this, ReadOnly | DontDelete | DontEnum, toJS(exec, globalObject(), item)); 58 return true; 59 } The propertyNameToAtomicString converts the Symbol PropertyName to AtomicString(nullptr), which later matches a "namedItem" comparing to an element's non-existent idAttribute (line 72): 68 Node* StaticElementList::namedItem(const AtomicString& elementId) const 69 { 70 for (unsigned i = 0, length = m_elements.size(); i < length; ++i) { 71 Element& element = const_cast<Element&>(m_elements[i].get()); 72 if (element.getIdAttribute() == elementId) 73 return &element; 74 } 75 return nullptr; 76 } 1089674 5 rniwa 2015-04-28 12:29:07 -0700 We should look at other places where propertyNameToAtomicString is called. I bet we're doing something wrong. 1089676 6 ysuzuki 2015-04-28 12:32:13 -0700 Seeing this, it seems that using `propertyName.uid()` solves this problem. `propertyName.uid()` returns symbolized StringImpl* if it's symbol. 1089677 7 rniwa 2015-04-28 12:33:24 -0700 (In reply to comment #6) > Seeing this, it seems that using `propertyName.uid()` solves this problem. > `propertyName.uid()` returns symbolized StringImpl* if it's symbol. Is that always different from any other string? 1089681 8 joepeck 2015-04-28 12:39:23 -0700 (In reply to comment #7) > (In reply to comment #6) > > Seeing this, it seems that using `propertyName.uid()` solves this problem. > > `propertyName.uid()` returns symbolized StringImpl* if it's symbol. > > Is that always different from any other string? Yeah, I started with that approach and it should work, but we may want to do even less work and bail in the "named" item cases where a Symbol would never be a name. I'll audit all propertyNameToString / propertyNameToAtomicString cases. 1089689 9 ysuzuki 2015-04-28 12:42:18 -0700 (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #6) > > > Seeing this, it seems that using `propertyName.uid()` solves this problem. > > > `propertyName.uid()` returns symbolized StringImpl* if it's symbol. > > > > Is that always different from any other string? > > Yeah, I started with that approach and it should work, but we may want to do > even less work and bail in the "named" item cases where a Symbol would never > be a name. > > I'll audit all propertyNameToString / propertyNameToAtomicString cases. Yay! You can check the identity of the given symbolized StringImpl* by comparing it in pointer values. But now, we need to take care to use this AtomicStringImpl* because it holds a different hash value from the other normal StringImpl* which content is the same to this. For example, a given Symbolized StringImpl* "Object" doesn't have a same hash value with the non symbolized StringImpl* "Object" I think it easily causes a serious error. I've opened the issue to change the situation. https://bugs.webkit.org/show_bug.cgi?id=144347 1089752 10 joepeck 2015-04-28 15:00:18 -0700 Same issue exists for this test: <body> <div id=""></div> <script> alert(document.getElementsByTagName("div")[""]); // undefined. alert(document.querySelectorAll("div")[""]); // <div>. (expected undefined) </script> NOTE: Firefox and Chrome have undefined for both. I think I'll address both at the same time considering how related they are. 1089807 11 251904 joepeck 2015-04-28 17:53:29 -0700 Created attachment 251904 [PATCH] Proposed Fix Turns out we had a number of custom cases in the bindings generation. I searched around and tried to handle all of them. Here we match Chrome's behavior for Symbol properties on special named objects, like sessionStorage/localStorage. // Treat as defining a private property on the storage. localStorage[symbol] = value; // Treat as setItem(name, value) localStorage[name] = value; // Treat as defining a private property on the map. element.dataset[symbol] = value; // Treat as adding a new "data-<name>" attribute. element.dataset[name] = value; Likewise handle deleteProperty appropriately in such cases. 1089912 12 251904 darin 2015-04-29 00:15:10 -0700 Comment on attachment 251904 [PATCH] Proposed Fix View in context: https://bugs.webkit.org/attachment.cgi?id=251904&action=review Is all this extra isSymbol checking OK from a performance point of view? All this additional empty string checking needs some test coverage. > Source/WebCore/Modules/mediastream/RTCStatsResponse.cpp:45 > + if (name.isEmpty()) > + return nullptr; I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > Source/WebCore/Modules/mediastream/RTCStatsResponse.cpp:48 > if (m_idmap.find(name) != m_idmap.end()) > return m_result[m_idmap.get(name)]; > return nullptr; This is comically incorrect code. We should never do a find followed by a get! It should be: auto iterator = m_idmap.find(name); if (iterator == m_idmap.end()) return nullptr; return m_result[*iterator]; > Source/WebCore/Modules/mediastream/RTCStatsResponse.cpp:53 > + return !name.isEmpty() && m_idmap.contains(name); I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return false. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > Source/WebCore/dom/ChildNodeList.cpp:87 > + if (name.isEmpty()) > + return nullptr; I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > Source/WebCore/dom/DOMNamedFlowCollection.cpp:59 > + if (name.isEmpty()) > + return nullptr; I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > Source/WebCore/dom/LiveNodeList.cpp:57 > + if (elementId.isEmpty()) > + return nullptr; I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > Source/WebCore/dom/StaticNodeList.cpp:49 > + if (elementId.isEmpty()) > + return nullptr; I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > Source/WebCore/dom/StaticNodeList.cpp:73 > + if (elementId.isEmpty()) > + return nullptr; I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > Source/WebCore/html/HTMLFormControlsCollection.cpp:132 > + if (name.isEmpty()) > + return nullptr; I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. 1090106 13 joepeck 2015-04-29 12:14:07 -0700 (In reply to comment #12) > Comment on attachment 251904 [details] > [PATCH] Proposed Fix > > View in context: > https://bugs.webkit.org/attachment.cgi?id=251904&action=review > > Is all this extra isSymbol checking OK from a performance point of view? > > All this additional empty string checking needs some test coverage. Yeah, I'll just remove the empty string checks. I added them but didn't go back and test them for each of the possible collection types. Each collection will need to be investigated/tested individually. 1090208 14 251904 joepeck 2015-04-29 16:08:38 -0700 Comment on attachment 251904 [PATCH] Proposed Fix View in context: https://bugs.webkit.org/attachment.cgi?id=251904&action=review >> Source/WebCore/dom/StaticNodeList.cpp:49 >> + return nullptr; > > I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. These empty checks in StaticNodeList and StaticElementList were important. Covered by this test: <body> <div id=""></div> <script> alert(document.getElementsByTagName("div")[""]); // undefined. alert(document.querySelectorAll("div")[""]); // <div>. (expected undefined) </script> The named lookup compares this potentially empty string with a potentially empty id attribute: if (is<Element>(node) && downcast<Element>(node).getIdAttribute() == elementId) I'm not entirely sure how LiveNodeList gets away with it. Its check is slightly different and includes a FIXME. // FIXME: This should probably be using getIdAttribute instead of idForStyleResolution. if (element.hasID() && element.idForStyleResolution() == elementId) Maybe an empty string was avoided getting into idForStyleResolution. Do you think there would be a better change then the isEmpty check here? 1090211 15 joepeck 2015-04-29 16:19:13 -0700 > Do you think there would be a better change then the isEmpty check here? HTMLCollection had the isEmpty check which was the pattern I was following with these collections. 1090217 16 joepeck 2015-04-29 16:29:16 -0700 <http://trac.webkit.org/changeset/183589> 1090271 17 251904 joepeck 2015-04-29 18:14:25 -0700 Comment on attachment 251904 [PATCH] Proposed Fix View in context: https://bugs.webkit.org/attachment.cgi?id=251904&action=review >>> Source/WebCore/dom/StaticNodeList.cpp:49 >>> + return nullptr; >> >> I don’t understand why this is needed. I believe that if this function was passed the empty string it would already return nullptr. If this is an optimization I’d like to understand why it’s needed. If this is here so that we can handle the null string, which the default hash function can’t handle, then maybe we should do the more efficient isNull check instead of the more expansive isEmpty one. > > These empty checks in StaticNodeList and StaticElementList were important. Covered by this test: > > <body> > <div id=""></div> > <script> > alert(document.getElementsByTagName("div")[""]); // undefined. > alert(document.querySelectorAll("div")[""]); // <div>. (expected undefined) > </script> > > The named lookup compares this potentially empty string with a potentially empty id attribute: > > if (is<Element>(node) && downcast<Element>(node).getIdAttribute() == elementId) > > I'm not entirely sure how LiveNodeList gets away with it. Its check is slightly different and includes a FIXME. > > // FIXME: This should probably be using getIdAttribute instead of idForStyleResolution. > if (element.hasID() && element.idForStyleResolution() == elementId) > > Maybe an empty string was avoided getting into idForStyleResolution. > > Do you think there would be a better change then the isEmpty check here? Darin walked over and talked with me on this. For the LiveNodeList case, the same issue exhibits for a node in a live node list that is not in the document. Test: <script> var container = document.createElement("div"); var div = document.createElement("div"); div.id = ""; container.appendChild(div); var list = container.getElementsByTagName("div"); list[""]; // expected undefined, was <div> </script> I'll address this in a new bug. 251904 2015-04-28 17:53:29 -0700 2015-04-29 00:15:10 -0700 [PATCH] Proposed Fix symbol-properties.patch text/plain 29816 joepeck ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkOGQ1M2QzLi43OWIyNjBjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTUtMDQt MjggIEpvc2VwaCBQZWNvcmFybyAgPHBlY29yYXJvQGFwcGxlLmNvbT4KKworICAgICAgICBOb2Rl TGlzdCBoYXMgaXNzdWVzIHdpdGggU3ltYm9sIGFuZCBlbXB0eSBzdHJpbmcKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NDMxMAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZmFzdC9kb20vU3R5bGVTaGVl dC9zdHlsZXNoZWV0LXN5bWJvbC1uYW1lcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZG9tL1N0eWxlU2hlZXQvc3R5bGVzaGVldC1zeW1ib2wtbmFtZXMuaHRtbDogQWRkZWQu CisgICAgICAgICogZmFzdC9kb20vZGF0YXNldC1uYW1lLWdldHRlci1zeW1ib2xzLWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vZGF0YXNldC1uYW1lLWdldHRlci1zeW1i b2xzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL25hbWVkLWl0ZW1zLXdpdGgtZW1w dHktbmFtZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL25hbWVkLWl0 ZW1zLXdpdGgtZW1wdHktbmFtZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9uYW1l ZC1pdGVtcy13aXRoLXN5bWJvbC1uYW1lLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICog ZmFzdC9kb20vbmFtZWQtaXRlbXMtd2l0aC1zeW1ib2wtbmFtZS5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBzdG9yYWdlL2RvbXN0b3JhZ2UvbG9jYWxzdG9yYWdlL25hbWVkLWl0ZW1zLWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS9kb21zdG9yYWdlL2xvY2Fsc3RvcmFnZS9u YW1lZC1pdGVtcy5odG1sOiBBZGRlZC4KKwogMjAxNS0wNC0yOCAgQnJlbnQgRnVsZ2hhbSAgPGJm dWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBUZW1wb3JhcmlseSBkaXNhYmxlIFdl YkdMIHN1cHBvcnQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL1N0eWxlU2hlZXQv c3R5bGVzaGVldC1zeW1ib2wtbmFtZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vU3R5bGVTaGVldC9zdHlsZXNoZWV0LXN5bWJvbC1uYW1lcy1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTYxNjUyNAotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvZG9tL1N0eWxlU2hlZXQvc3R5bGVzaGVldC1zeW1ib2wtbmFtZXMt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTYgQEAKK1RoaXMgdGVzdHMgZG9jdW1lbnQuc3R5ZWxT aGVldHMgd2l0aCBTeW1ib2wgcHJvcGVydHkgbmFtZXMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxs IHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBM RVRFIi4KKworCitQQVNTIGRvY3VtZW50LnN0eWxlU2hlZXRzLmxlbmd0aCBpcyAzCitQQVNTIGRv Y3VtZW50LnN0eWxlU2hlZXRzWycnXSBpcyB1bmRlZmluZWQKK1BBU1MgZG9jdW1lbnQuc3R5bGVT aGVldHNbJ3Rlc3QnXSBpcyBzdHlsZUVsZW1lbnQyLnNoZWV0CitQQVNTIGRvY3VtZW50LnN0eWxl U2hlZXRzW1N5bWJvbCgpXSBpcyB1bmRlZmluZWQKK1BBU1MgZGVsZXRlIGRvY3VtZW50LnN0eWxl U2hlZXRzWyd0ZXN0J10gZGlkIG5vdCB0aHJvdyBleGNlcHRpb24uCitQQVNTIGRlbGV0ZSBkb2N1 bWVudC5zdHlsZVNoZWV0c1tTeW1ib2woKV0gZGlkIG5vdCB0aHJvdyBleGNlcHRpb24uCitQQVNT IGRvY3VtZW50LnN0eWxlU2hlZXRzLmxlbmd0aCBpcyAzCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNl ZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9kb20vU3R5bGVTaGVldC9zdHlsZXNoZWV0LXN5bWJvbC1uYW1lcy5odG1sIGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vU3R5bGVTaGVldC9zdHlsZXNoZWV0LXN5bWJvbC1uYW1lcy5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUyYmE3NjgKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9TdHlsZVNoZWV0L3N0eWxlc2hlZXQtc3ltYm9sLW5hbWVz Lmh0bWwKQEAgLTAsMCArMSwyOSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9E VEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi9yZXNv dXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8c2NyaXB0 PgorZGVzY3JpcHRpb24oIlRoaXMgdGVzdHMgZG9jdW1lbnQuc3R5ZWxTaGVldHMgd2l0aCBTeW1i b2wgcHJvcGVydHkgbmFtZXMuIik7CisKK3N0eWxlRWxlbWVudDEgPSBkb2N1bWVudC5jcmVhdGVF bGVtZW50KCJzdHlsZSIpOworc3R5bGVFbGVtZW50MS5zZXRBdHRyaWJ1dGUoImlkIiwgIiIpOwor ZG9jdW1lbnQuaGVhZC5hcHBlbmRDaGlsZChzdHlsZUVsZW1lbnQxKTsKKworc3R5bGVFbGVtZW50 MiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInN0eWxlIik7CitzdHlsZUVsZW1lbnQyLnNldEF0 dHJpYnV0ZSgiaWQiLCAidGVzdCIpOworZG9jdW1lbnQuaGVhZC5hcHBlbmRDaGlsZChzdHlsZUVs ZW1lbnQyKTsKKworc2hvdWxkQmUoImRvY3VtZW50LnN0eWxlU2hlZXRzLmxlbmd0aCIsICIzIik7 CitzaG91bGRCZSgiZG9jdW1lbnQuc3R5bGVTaGVldHNbJyddIiwgInVuZGVmaW5lZCIpOworc2hv dWxkQmUoImRvY3VtZW50LnN0eWxlU2hlZXRzWyd0ZXN0J10iLCAic3R5bGVFbGVtZW50Mi5zaGVl dCIpOworc2hvdWxkQmUoImRvY3VtZW50LnN0eWxlU2hlZXRzW1N5bWJvbCgpXSIsICJ1bmRlZmlu ZWQiKTsKK3Nob3VsZE5vdFRocm93KCJkZWxldGUgZG9jdW1lbnQuc3R5bGVTaGVldHNbJ3Rlc3Qn XSIpOworc2hvdWxkTm90VGhyb3coImRlbGV0ZSBkb2N1bWVudC5zdHlsZVNoZWV0c1tTeW1ib2wo KV0iKTsKK3Nob3VsZEJlKCJkb2N1bWVudC5zdHlsZVNoZWV0cy5sZW5ndGgiLCAiMyIpOworCis8 L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi9yZXNvdXJjZXMvanMtdGVzdC1wb3N0Lmpz Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZG9tL2RhdGFzZXQtbmFtZS1nZXR0ZXItc3ltYm9scy1leHBlY3RlZC50eHQgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9kYXRhc2V0LW5hbWUtZ2V0dGVyLXN5bWJvbHMtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIxMTJlM2UKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9kYXRhc2V0LW5hbWUtZ2V0dGVyLXN5bWJvbHMtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsMjIgQEAKK1Rlc3QgdGhlIG5hbWUgZ2V0dGVycyBvbiBET01T dHJpbmdNYXAgKGRhdGFzZXQpLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMg b2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFT UyBkb2N1bWVudC5ib2R5LmRhdGFzZXQud2Via2l0Um9ja3MgPT09ICd5ZXMnIGlzIHRydWUKK1BB U1MgT2JqZWN0LmtleXMoZG9jdW1lbnQuYm9keS5kYXRhc2V0KS5sZW5ndGggPT09IDEgaXMgdHJ1 ZQorUEFTUyBkb2N1bWVudC5ib2R5LmRhdGFzZXRbJyddID0gJ3Rlc3QnIGRpZCBub3QgdGhyb3cg ZXhjZXB0aW9uLgorUEFTUyBkb2N1bWVudC5ib2R5LmRhdGFzZXRbJyddID09PSAndGVzdCcgaXMg dHJ1ZQorUEFTUyBkb2N1bWVudC5ib2R5LmRhdGFzZXRbU3ltYm9sKCldID09PSB1bmRlZmluZWQg aXMgdHJ1ZQorUEFTUyBPYmplY3Qua2V5cyhkb2N1bWVudC5ib2R5LmRhdGFzZXQpLmxlbmd0aCA9 PT0gMiBpcyB0cnVlCitQQVNTIGRvY3VtZW50LmJvZHkuZGF0YXNldFtrbm93blN5bWJvbF0gPT09 IHVuZGVmaW5lZCBpcyB0cnVlCitQQVNTIE9iamVjdC5rZXlzKGRvY3VtZW50LmJvZHkuZGF0YXNl dCkubGVuZ3RoID09PSAyIGlzIHRydWUKK1BBU1MgZG9jdW1lbnQuYm9keS5kYXRhc2V0W2tub3du U3ltYm9sXSA9ICdzeW1ib2wgcHJvcGVydHknIGRpZCBub3QgdGhyb3cgZXhjZXB0aW9uLgorUEFT UyBkb2N1bWVudC5ib2R5LmRhdGFzZXRba25vd25TeW1ib2xdID09PSAnc3ltYm9sIHByb3BlcnR5 JyBpcyB0cnVlCitQQVNTIGRlbGV0ZSBkb2N1bWVudC5ib2R5LmRhdGFzZXRba25vd25TeW1ib2xd IGlzIHRydWUKK1BBU1MgZG9jdW1lbnQuYm9keS5kYXRhc2V0W2tub3duU3ltYm9sXSA9PT0gdW5k ZWZpbmVkIGlzIHRydWUKK1BBU1MgT2JqZWN0LmtleXMoZG9jdW1lbnQuYm9keS5kYXRhc2V0KS5s ZW5ndGggPT09IDIgaXMgdHJ1ZQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitU RVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RhdGFzZXQt bmFtZS1nZXR0ZXItc3ltYm9scy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vZGF0YXNldC1u YW1lLWdldHRlci1zeW1ib2xzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MC4uMGQyMjBhMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL2RhdGFz ZXQtbmFtZS1nZXR0ZXItc3ltYm9scy5odG1sCkBAIC0wLDAgKzEsMzAgQEAKKzwhRE9DVFlQRSBI VE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8c2Ny aXB0IHNyYz0iLi4vLi4vcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVh ZD4KKzxib2R5IGRhdGEtd2Via2l0LXJvY2tzPXllcz4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbign VGVzdCB0aGUgbmFtZSBnZXR0ZXJzIG9uIERPTVN0cmluZ01hcCAoZGF0YXNldCkuJyk7CisKK2tu b3duU3ltYm9sID0gU3ltYm9sKCk7CisKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1lbnQuYm9keS5kYXRh c2V0LndlYmtpdFJvY2tzID09PSAneWVzJyIpOworc2hvdWxkQmVUcnVlKCJPYmplY3Qua2V5cyhk b2N1bWVudC5ib2R5LmRhdGFzZXQpLmxlbmd0aCA9PT0gMSIpOworCitzaG91bGROb3RUaHJvdygi ZG9jdW1lbnQuYm9keS5kYXRhc2V0WycnXSA9ICd0ZXN0JyIpOworc2hvdWxkQmVUcnVlKCJkb2N1 bWVudC5ib2R5LmRhdGFzZXRbJyddID09PSAndGVzdCciKTsKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1l bnQuYm9keS5kYXRhc2V0W1N5bWJvbCgpXSA9PT0gdW5kZWZpbmVkIik7CitzaG91bGRCZVRydWUo Ik9iamVjdC5rZXlzKGRvY3VtZW50LmJvZHkuZGF0YXNldCkubGVuZ3RoID09PSAyIik7CisKK3No b3VsZEJlVHJ1ZSgiZG9jdW1lbnQuYm9keS5kYXRhc2V0W2tub3duU3ltYm9sXSA9PT0gdW5kZWZp bmVkIik7CitzaG91bGRCZVRydWUoIk9iamVjdC5rZXlzKGRvY3VtZW50LmJvZHkuZGF0YXNldCku bGVuZ3RoID09PSAyIik7CitzaG91bGROb3RUaHJvdygiZG9jdW1lbnQuYm9keS5kYXRhc2V0W2tu b3duU3ltYm9sXSA9ICdzeW1ib2wgcHJvcGVydHknIik7CitzaG91bGRCZVRydWUoImRvY3VtZW50 LmJvZHkuZGF0YXNldFtrbm93blN5bWJvbF0gPT09ICdzeW1ib2wgcHJvcGVydHknIik7CitzaG91 bGRCZVRydWUoImRlbGV0ZSBkb2N1bWVudC5ib2R5LmRhdGFzZXRba25vd25TeW1ib2xdIik7Citz aG91bGRCZVRydWUoImRvY3VtZW50LmJvZHkuZGF0YXNldFtrbm93blN5bWJvbF0gPT09IHVuZGVm aW5lZCIpOworc2hvdWxkQmVUcnVlKCJPYmplY3Qua2V5cyhkb2N1bWVudC5ib2R5LmRhdGFzZXQp Lmxlbmd0aCA9PT0gMiIpOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2Vz L2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9uYW1lZC1pdGVtcy13aXRoLWVtcHR5LW5hbWUtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vbmFtZWQtaXRlbXMtd2l0aC1lbXB0eS1uYW1l LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mNzAyYmUz Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vbmFtZWQtaXRlbXMtd2l0 aC1lbXB0eS1uYW1lLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIGVt cHR5IHN0cmluZ3MgZG8gbm90IHJldHVybiBhIHZhbHVlIGluIGNvbGxlY3Rpb25zIG9yIG5hbWVk IGl0ZW1zIGNhc2VzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB U1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFTUyBkb2N1 bWVudC5xdWVyeVNlbGVjdG9yQWxsKCdkaXYnKVsnJ10gPT09IHVuZGVmaW5lZCBpcyB0cnVlCitQ QVNTIGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCdkaXYnKVsnJ10gPT09IHVuZGVmaW5l ZCBpcyB0cnVlCitQQVNTIGRvY3VtZW50LmJvZHkuY2hpbGRyZW5bJyddID09PSB1bmRlZmluZWQg aXMgdHJ1ZQorUEFTUyBkb2N1bWVudC5hbGxbJyddID09PSB1bmRlZmluZWQgaXMgdHJ1ZQorCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9uYW1lZC1pdGVtcy13aXRoLWVtcHR5LW5h bWUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL25hbWVkLWl0ZW1zLXdpdGgtZW1wdHktbmFt ZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUxNzQ5MGYKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9uYW1lZC1pdGVtcy13aXRoLWVtcHR5 LW5hbWUuaHRtbApAQCAtMCwwICsxLDIwIEBACis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCBzcmM9 Ii4uLy4uL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9k eT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8 ZGl2IGlkPSIiPjwvZGl2PgorICAgIAorPHNjcmlwdD4KK2Rlc2NyaXB0aW9uKCdUaGlzIHRlc3Rz IGVtcHR5IHN0cmluZ3MgZG8gbm90IHJldHVybiBhIHZhbHVlIGluIGNvbGxlY3Rpb25zIG9yIG5h bWVkIGl0ZW1zIGNhc2VzLicpOworCitzaG91bGRCZVRydWUoImRvY3VtZW50LnF1ZXJ5U2VsZWN0 b3JBbGwoJ2RpdicpWycnXSA9PT0gdW5kZWZpbmVkIik7CitzaG91bGRCZVRydWUoImRvY3VtZW50 LmdldEVsZW1lbnRzQnlUYWdOYW1lKCdkaXYnKVsnJ10gPT09IHVuZGVmaW5lZCIpOworc2hvdWxk QmVUcnVlKCJkb2N1bWVudC5ib2R5LmNoaWxkcmVuWycnXSA9PT0gdW5kZWZpbmVkIik7CitzaG91 bGRCZVRydWUoImRvY3VtZW50LmFsbFsnJ10gPT09IHVuZGVmaW5lZCIpOworPC9zY3JpcHQ+Cis8 c2NyaXB0IHNyYz0iLi4vLi4vLi4vcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+ Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9uYW1l ZC1pdGVtcy13aXRoLXN5bWJvbC1uYW1lLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL25hbWVkLWl0ZW1zLXdpdGgtc3ltYm9sLW5hbWUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE3Mjk1YjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2RvbS9uYW1lZC1pdGVtcy13aXRoLXN5bWJvbC1uYW1lLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDQyIEBACitUaGlzIHRlc3RzIFN5bWJvbCBwcm9wZXJ0eSBuYW1lcyB3aXRo IGEgbnVtYmVyIG9mIG5hbWVkIGl0ZW1zIGNvbGxlY3Rpb25zLgorCitPbiBzdWNjZXNzLCB5b3Ug d2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBD T01QTEVURSIuCisKKworW29iamVjdCBOb2RlTGlzdF0KK1BBU1MgcXVlcnlTZWxlY3RvckFsbExp c3QubGVuZ3RoID09PSA0IGlzIHRydWUKK1BBU1MgcXVlcnlTZWxlY3RvckFsbExpc3RbU3ltYm9s KCldID09PSB1bmRlZmluZWQgaXMgdHJ1ZQorUEFTUyBxdWVyeVNlbGVjdG9yQWxsTGlzdFtTeW1i b2woJ2RpdicpXSA9PT0gdW5kZWZpbmVkIGlzIHRydWUKK1BBU1MgcXVlcnlTZWxlY3RvckFsbExp c3RbJ1N5bWJvbChkaXYpJ10gaW5zdGFuY2VvZiBIVE1MRGl2RWxlbWVudCBpcyB0cnVlCisKK1tv YmplY3QgTm9kZUxpc3RdCitQQVNTIGdldEVsZW1lbnRzQnlUYWdOYW1lTGlzdC5sZW5ndGggPT09 IDQgaXMgdHJ1ZQorUEFTUyBnZXRFbGVtZW50c0J5VGFnTmFtZUxpc3RbU3ltYm9sKCldID09PSB1 bmRlZmluZWQgaXMgdHJ1ZQorUEFTUyBnZXRFbGVtZW50c0J5VGFnTmFtZUxpc3RbU3ltYm9sKCdk aXYnKV0gPT09IHVuZGVmaW5lZCBpcyB0cnVlCitQQVNTIGdldEVsZW1lbnRzQnlUYWdOYW1lTGlz dFsnU3ltYm9sKGRpdiknXSBpbnN0YW5jZW9mIEhUTUxEaXZFbGVtZW50IGlzIHRydWUKKworW29i amVjdCBXaW5kb3ddCitQQVNTIHdpbmRvd1tTeW1ib2woKV0gPT09IHVuZGVmaW5lZCBpcyB0cnVl CitQQVNTIHdpbmRvd1tTeW1ib2woJ2RpdicpXSA9PT0gdW5kZWZpbmVkIGlzIHRydWUKK1BBU1Mg d2luZG93WydTeW1ib2woZGl2KSddIGluc3RhbmNlb2YgSFRNTERpdkVsZW1lbnQgaXMgdHJ1ZQor Citbb2JqZWN0IEhUTUxDb2xsZWN0aW9uXQorUEFTUyBkb2N1bWVudC5pbWFnZXMubGVuZ3RoID09 PSAzIGlzIHRydWUKK1BBU1MgZG9jdW1lbnQuaW1hZ2VzW1N5bWJvbCgpXSA9PT0gdW5kZWZpbmVk IGlzIHRydWUKK1BBU1MgZG9jdW1lbnQuaW1hZ2VzW1N5bWJvbCgnaW1nJyldID09PSB1bmRlZmlu ZWQgaXMgdHJ1ZQorUEFTUyBkb2N1bWVudC5pbWFnZXNbJ1N5bWJvbChpbWcpJ10gaW5zdGFuY2Vv ZiBIVE1MSW1hZ2VFbGVtZW50IGlzIHRydWUKKworW29iamVjdCBIVE1MQWxsQ29sbGVjdGlvbl0K K1BBU1MgZG9jdW1lbnQuYWxsLmxlbmd0aCA+IDEwIGlzIHRydWUKK1BBU1MgZG9jdW1lbnQuYWxs W1N5bWJvbCgpXSA9PT0gdW5kZWZpbmVkIGlzIHRydWUKK1BBU1MgZG9jdW1lbnQuYWxsW1N5bWJv bCgnZGl2JyldID09PSB1bmRlZmluZWQgaXMgdHJ1ZQorUEFTUyBkb2N1bWVudC5hbGxbJ1N5bWJv bChkaXYpJ10gaW5zdGFuY2VvZiBIVE1MRGl2RWxlbWVudCBpcyB0cnVlCisKK1tvYmplY3QgSFRN TENvbGxlY3Rpb25dCitQQVNTIGRvY3VtZW50LmZvcm1zW1N5bWJvbCgpXSA9PT0gdW5kZWZpbmVk IGlzIHRydWUKKworW29iamVjdCBIVE1MRm9ybUVsZW1lbnRdCitQQVNTIGRvY3VtZW50LmZvcm1z WzBdW1N5bWJvbCgpXSA9PT0gdW5kZWZpbmVkIGlzIHRydWUKK1BBU1MgZG9jdW1lbnQuZm9ybXNb MF1bU3ltYm9sKCdpbnB1dCcpXSA9PT0gdW5kZWZpbmVkIGlzIHRydWUKK1BBU1MgZG9jdW1lbnQu Zm9ybXNbMF1bJ1N5bWJvbChpbnB1dCknXSBpbnN0YW5jZW9mIEhUTUxJbnB1dEVsZW1lbnQgaXMg dHJ1ZQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9uYW1lZC1pdGVtcy13aXRo LXN5bWJvbC1uYW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9uYW1lZC1pdGVtcy13aXRo LXN5bWJvbC1uYW1lLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzIx MDEwMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL25hbWVkLWl0ZW1z LXdpdGgtc3ltYm9sLW5hbWUuaHRtbApAQCAtMCwwICsxLDU5IEBACis8aHRtbD4KKzxoZWFkPgor PHNjcmlwdCBzcmM9Ii4uLy4uL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8 L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29s ZSI+PC9kaXY+CisKKzxkaXYgc3R5bGU9ImRpc3BsYXk6bm9uZSI+CisgICAgPGRpdj50ZXh0MTwv ZGl2PjxkaXYgaWQ9J1N5bWJvbChkaXYpJz50ZXh0MjwvZGl2PgorICAgIDxpbWc+PGltZyBpZD0i aW1nIj48aW1nIGlkPSJTeW1ib2woaW1nKSI+CisgICAgPGZvcm0+PGlucHV0PjxpbnB1dCBuYW1l PSJpbnB1dCI+PGlucHV0IG5hbWU9IlN5bWJvbChpbnB1dCkiPjwvZm9ybT4KKzwvZGl2PgorICAg IAorPHNjcmlwdD4KK2Rlc2NyaXB0aW9uKCdUaGlzIHRlc3RzIFN5bWJvbCBwcm9wZXJ0eSBuYW1l cyB3aXRoIGEgbnVtYmVyIG9mIG5hbWVkIGl0ZW1zIGNvbGxlY3Rpb25zLicpOworCit2YXIgcXVl cnlTZWxlY3RvckFsbExpc3QgPSBkb2N1bWVudC5xdWVyeVNlbGVjdG9yQWxsKCdkaXYnKTsKK2Rl YnVnKFN0cmluZyhxdWVyeVNlbGVjdG9yQWxsTGlzdCkpOworc2hvdWxkQmVUcnVlKCJxdWVyeVNl bGVjdG9yQWxsTGlzdC5sZW5ndGggPT09IDQiKTsKK3Nob3VsZEJlVHJ1ZSgicXVlcnlTZWxlY3Rv ckFsbExpc3RbU3ltYm9sKCldID09PSB1bmRlZmluZWQiKTsKK3Nob3VsZEJlVHJ1ZSgicXVlcnlT ZWxlY3RvckFsbExpc3RbU3ltYm9sKCdkaXYnKV0gPT09IHVuZGVmaW5lZCIpOworc2hvdWxkQmVU cnVlKCJxdWVyeVNlbGVjdG9yQWxsTGlzdFsnU3ltYm9sKGRpdiknXSBpbnN0YW5jZW9mIEhUTUxE aXZFbGVtZW50Iik7CisKK3ZhciBnZXRFbGVtZW50c0J5VGFnTmFtZUxpc3QgPSBkb2N1bWVudC5n ZXRFbGVtZW50c0J5VGFnTmFtZSgnZGl2Jyk7CitkZWJ1ZygiXG4iICsgU3RyaW5nKGdldEVsZW1l bnRzQnlUYWdOYW1lTGlzdCkpOworc2hvdWxkQmVUcnVlKCJnZXRFbGVtZW50c0J5VGFnTmFtZUxp c3QubGVuZ3RoID09PSA0Iik7CitzaG91bGRCZVRydWUoImdldEVsZW1lbnRzQnlUYWdOYW1lTGlz dFtTeW1ib2woKV0gPT09IHVuZGVmaW5lZCIpOworc2hvdWxkQmVUcnVlKCJnZXRFbGVtZW50c0J5 VGFnTmFtZUxpc3RbU3ltYm9sKCdkaXYnKV0gPT09IHVuZGVmaW5lZCIpOworc2hvdWxkQmVUcnVl KCJnZXRFbGVtZW50c0J5VGFnTmFtZUxpc3RbJ1N5bWJvbChkaXYpJ10gaW5zdGFuY2VvZiBIVE1M RGl2RWxlbWVudCIpOworCitkZWJ1ZygiXG4iICsgU3RyaW5nKHdpbmRvdykpOworc2hvdWxkQmVU cnVlKCJ3aW5kb3dbU3ltYm9sKCldID09PSB1bmRlZmluZWQiKTsKK3Nob3VsZEJlVHJ1ZSgid2lu ZG93W1N5bWJvbCgnZGl2JyldID09PSB1bmRlZmluZWQiKTsKK3Nob3VsZEJlVHJ1ZSgid2luZG93 WydTeW1ib2woZGl2KSddIGluc3RhbmNlb2YgSFRNTERpdkVsZW1lbnQiKTsKKworZGVidWcoIlxu IiArIFN0cmluZyhkb2N1bWVudC5pbWFnZXMpKTsKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1lbnQuaW1h Z2VzLmxlbmd0aCA9PT0gMyIpOworc2hvdWxkQmVUcnVlKCJkb2N1bWVudC5pbWFnZXNbU3ltYm9s KCldID09PSB1bmRlZmluZWQiKTsKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1lbnQuaW1hZ2VzW1N5bWJv bCgnaW1nJyldID09PSB1bmRlZmluZWQiKTsKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1lbnQuaW1hZ2Vz WydTeW1ib2woaW1nKSddIGluc3RhbmNlb2YgSFRNTEltYWdlRWxlbWVudCIpOworCitkZWJ1Zygi XG4iICsgU3RyaW5nKGRvY3VtZW50LmFsbCkpOworc2hvdWxkQmVUcnVlKCJkb2N1bWVudC5hbGwu bGVuZ3RoID4gMTAiKTsKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1lbnQuYWxsW1N5bWJvbCgpXSA9PT0g dW5kZWZpbmVkIik7CitzaG91bGRCZVRydWUoImRvY3VtZW50LmFsbFtTeW1ib2woJ2RpdicpXSA9 PT0gdW5kZWZpbmVkIik7CitzaG91bGRCZVRydWUoImRvY3VtZW50LmFsbFsnU3ltYm9sKGRpdikn XSBpbnN0YW5jZW9mIEhUTUxEaXZFbGVtZW50Iik7CisKK2RlYnVnKCJcbiIgKyBTdHJpbmcoZG9j dW1lbnQuZm9ybXMpKTsKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1lbnQuZm9ybXNbU3ltYm9sKCldID09 PSB1bmRlZmluZWQiKTsKKworZGVidWcoIlxuIiArIFN0cmluZyhkb2N1bWVudC5mb3Jtc1swXSkp Oworc2hvdWxkQmVUcnVlKCJkb2N1bWVudC5mb3Jtc1swXVtTeW1ib2woKV0gPT09IHVuZGVmaW5l ZCIpOworc2hvdWxkQmVUcnVlKCJkb2N1bWVudC5mb3Jtc1swXVtTeW1ib2woJ2lucHV0JyldID09 PSB1bmRlZmluZWQiKTsKK3Nob3VsZEJlVHJ1ZSgiZG9jdW1lbnQuZm9ybXNbMF1bJ1N5bWJvbChp bnB1dCknXSBpbnN0YW5jZW9mIEhUTUxJbnB1dEVsZW1lbnQiKTsKKzwvc2NyaXB0PgorPHNjcmlw dCBzcmM9Ii4uLy4uLy4uL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9kb21zdG9yYWdl L2xvY2Fsc3RvcmFnZS9uYW1lZC1pdGVtcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9zdG9y YWdlL2RvbXN0b3JhZ2UvbG9jYWxzdG9yYWdlL25hbWVkLWl0ZW1zLWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMDcxZjQ0Ci0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9kb21zdG9yYWdlL2xvY2Fsc3RvcmFnZS9uYW1lZC1pdGVt cy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwyOCBAQAorVGVzdHMgc3RvcmFnZSB3aXRoIG5hbWVk IGl0ZW0gYWNjZXNzIGFuZCBTeW1ib2wgcHJvcGVydGllcy4KKworT24gc3VjY2VzcywgeW91IHdp bGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09N UExFVEUiLgorCisKK1BBU1MgbG9jYWxTdG9yYWdlLmxlbmd0aCA9PT0gMCBpcyB0cnVlCitQQVNT IGxvY2FsU3RvcmFnZVtTeW1ib2woKV0gPT09IHVuZGVmaW5lZCBpcyB0cnVlCitQQVNTIGxvY2Fs U3RvcmFnZS5sZW5ndGggPT09IDAgaXMgdHJ1ZQorUEFTUyBsb2NhbFN0b3JhZ2Vba25vd25TeW1i b2xdID09PSAyIGlzIHRydWUKK1BBU1MgZGVsZXRlIGxvY2FsU3RvcmFnZVtrbm93blN5bWJvbF0g ZGlkIG5vdCB0aHJvdyBleGNlcHRpb24uCitQQVNTIGxvY2FsU3RvcmFnZS5sZW5ndGggPT09IDAg aXMgdHJ1ZQorUEFTUyBsb2NhbFN0b3JhZ2Vba25vd25TeW1ib2xdID09PSB1bmRlZmluZWQgaXMg dHJ1ZQorUEFTUyBsb2NhbFN0b3JhZ2UubGVuZ3RoID09PSAxIGlzIHRydWUKK1BBU1MgbG9jYWxT dG9yYWdlWydTeW1ib2woKSddID09PSAnMycgaXMgdHJ1ZQorUEFTUyBsb2NhbFN0b3JhZ2Uua2V5 KDApID09PSAnU3ltYm9sKCknIGlzIHRydWUKK1BBU1MgbG9jYWxTdG9yYWdlWycnXSA9PT0gdW5k ZWZpbmVkIGlzIHRydWUKK1BBU1MgbG9jYWxTdG9yYWdlWycnXSA9PT0gJzQnIGlzIHRydWUKK1BB U1MgbG9jYWxTdG9yYWdlLmxlbmd0aCA9PT0gMiBpcyB0cnVlCitQQVNTIGRlbGV0ZSBsb2NhbFN0 b3JhZ2VbJ1N5bWJvbCgpJ10gZGlkIG5vdCB0aHJvdyBleGNlcHRpb24uCitQQVNTIGxvY2FsU3Rv cmFnZS5sZW5ndGggPT09IDEgaXMgdHJ1ZQorUEFTUyBsb2NhbFN0b3JhZ2VbJ1N5bWJvbCgpJ10g PT09IHVuZGVmaW5lZCBpcyB0cnVlCitQQVNTIGRlbGV0ZSBsb2NhbFN0b3JhZ2VbJyddIGRpZCBu b3QgdGhyb3cgZXhjZXB0aW9uLgorUEFTUyBsb2NhbFN0b3JhZ2UubGVuZ3RoID09PSAwIGlzIHRy dWUKK1BBU1MgbG9jYWxTdG9yYWdlWycnXSA9PT0gdW5kZWZpbmVkIGlzIHRydWUKK1BBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2RvbXN0b3JhZ2UvbG9jYWxzdG9yYWdlL25hbWVkLWl0ZW1zLmh0 bWwgYi9MYXlvdXRUZXN0cy9zdG9yYWdlL2RvbXN0b3JhZ2UvbG9jYWxzdG9yYWdlL25hbWVkLWl0 ZW1zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzBjN2YyOAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvZG9tc3RvcmFnZS9sb2NhbHN0b3Jh Z2UvbmFtZWQtaXRlbXMuaHRtbApAQCAtMCwwICsxLDQzIEBACis8aHRtbD4KKzxoZWFkPgorPHNj cmlwdCBzcmM9Ii4uLy4uLy4uL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8 L2hlYWQ+Cis8Ym9keT4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbigiVGVzdHMgc3RvcmFnZSB3aXRo IG5hbWVkIGl0ZW0gYWNjZXNzIGFuZCBTeW1ib2wgcHJvcGVydGllcy4iKTsKKwora25vd25TeW1i b2wgPSBTeW1ib2woKTsKK2xvY2FsU3RvcmFnZS5jbGVhcigpOworCitsb2NhbFN0b3JhZ2VbU3lt Ym9sKCldID0gMTsKK3Nob3VsZEJlVHJ1ZSgibG9jYWxTdG9yYWdlLmxlbmd0aCA9PT0gMCIpOwor c2hvdWxkQmVUcnVlKCJsb2NhbFN0b3JhZ2VbU3ltYm9sKCldID09PSB1bmRlZmluZWQiKTsKKwor bG9jYWxTdG9yYWdlW2tub3duU3ltYm9sXSA9IDI7CitzaG91bGRCZVRydWUoImxvY2FsU3RvcmFn ZS5sZW5ndGggPT09IDAiKTsKK3Nob3VsZEJlVHJ1ZSgibG9jYWxTdG9yYWdlW2tub3duU3ltYm9s XSA9PT0gMiIpOyAvLyBudW1iZXIKK3Nob3VsZE5vdFRocm93KCJkZWxldGUgbG9jYWxTdG9yYWdl W2tub3duU3ltYm9sXSIpOworc2hvdWxkQmVUcnVlKCJsb2NhbFN0b3JhZ2UubGVuZ3RoID09PSAw Iik7CitzaG91bGRCZVRydWUoImxvY2FsU3RvcmFnZVtrbm93blN5bWJvbF0gPT09IHVuZGVmaW5l ZCIpOworCitsb2NhbFN0b3JhZ2VbIlN5bWJvbCgpIl0gPSAzOworc2hvdWxkQmVUcnVlKCJsb2Nh bFN0b3JhZ2UubGVuZ3RoID09PSAxIik7CitzaG91bGRCZVRydWUoImxvY2FsU3RvcmFnZVsnU3lt Ym9sKCknXSA9PT0gJzMnIik7IC8vIHN0cmluZworc2hvdWxkQmVUcnVlKCJsb2NhbFN0b3JhZ2Uu a2V5KDApID09PSAnU3ltYm9sKCknIik7CisKK3Nob3VsZEJlVHJ1ZSgibG9jYWxTdG9yYWdlWycn XSA9PT0gdW5kZWZpbmVkIik7Citsb2NhbFN0b3JhZ2VbJyddID0gNDsKK3Nob3VsZEJlVHJ1ZSgi bG9jYWxTdG9yYWdlWycnXSA9PT0gJzQnIik7IC8vIHN0cmluZworc2hvdWxkQmVUcnVlKCJsb2Nh bFN0b3JhZ2UubGVuZ3RoID09PSAyIik7CisKK3Nob3VsZE5vdFRocm93KCJkZWxldGUgbG9jYWxT dG9yYWdlWydTeW1ib2woKSddIik7CitzaG91bGRCZVRydWUoImxvY2FsU3RvcmFnZS5sZW5ndGgg PT09IDEiKTsKK3Nob3VsZEJlVHJ1ZSgibG9jYWxTdG9yYWdlWydTeW1ib2woKSddID09PSB1bmRl ZmluZWQiKTsgLy8gc3RyaW5nCisKK3Nob3VsZE5vdFRocm93KCJkZWxldGUgbG9jYWxTdG9yYWdl WycnXSIpOworc2hvdWxkQmVUcnVlKCJsb2NhbFN0b3JhZ2UubGVuZ3RoID09PSAwIik7CitzaG91 bGRCZVRydWUoImxvY2FsU3RvcmFnZVsnJ10gPT09IHVuZGVmaW5lZCIpOyAvLyBzdHJpbmcKKzwv c2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMi Pjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKaW5kZXgg MWFjNDgwMS4uZTRiYWRmNiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTYg QEAKIDIwMTUtMDQtMjggIEpvc2VwaCBQZWNvcmFybyAgPHBlY29yYXJvQGFwcGxlLmNvbT4KIAor ICAgICAgICBOb2RlTGlzdCBoYXMgaXNzdWVzIHdpdGggU3ltYm9sIGFuZCBlbXB0eSBzdHJpbmcK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NDMxMAor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcnVudGlt ZS9Qcm9wZXJ0eU5hbWUuaDoKKyAgICAgICAgKEpTQzo6UHJvcGVydHlOYW1lOjppc1N5bWJvbCk6 CisgICAgICAgIEhlbHBlciB0byBjaGVjayBpZiB0aGUgUHJvcGVydHlOYW1lIGlzIGEgc3RyaW5n IG9yIHN5bWJvbCBwcm9wZXJ0eS4KKworMjAxNS0wNC0yOCAgSm9zZXBoIFBlY29yYXJvICA8cGVj b3Jhcm9AYXBwbGUuY29tPgorCiAgICAgICAgIEZpeCBjb21tb24gdHlwbyAidGFyZ2V0dGluZyIg PT4gInRhcmdldGluZyIKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTE0NDM0OQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9Qcm9wZXJ0eU5hbWUuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Byb3BlcnR5 TmFtZS5oCmluZGV4IDc0MjQyMjkuLjRmMmNhODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL1Byb3BlcnR5TmFtZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL1Byb3BlcnR5TmFtZS5oCkBAIC01Miw2ICs1MiwxMSBAQCBwdWJsaWM6CiAgICAg ICAgIEFTU0VSVChtX2ltcGwtPmlzU3ltYm9sKCkpOwogICAgIH0KIAorICAgIGJvb2wgaXNTeW1i b2woKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG1faW1wbCAmJiBtX2ltcGwtPmlzU3ltYm9sKCk7 CisgICAgfQorCiAgICAgQXRvbWljU3RyaW5nSW1wbCogdWlkKCkgY29uc3QKICAgICB7CiAgICAg ICAgIHJldHVybiBtX2ltcGw7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjIzZjVkNi4uZjE0ZjFhNiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDYzIEBACisyMDE1LTA0LTI4ICBKb3NlcGggUGVjb3Jhcm8gIDxwZWNv cmFyb0BhcHBsZS5jb20+CisKKyAgICAgICAgTm9kZUxpc3QgaGFzIGlzc3VlcyB3aXRoIFN5bWJv bCBhbmQgZW1wdHkgc3RyaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNDQzMTAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBUZXN0czogZmFzdC9kb20vU3R5bGVTaGVldC9zdHlsZXNoZWV0LXN5bWJvbC1u YW1lcy5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9kYXRhc2V0LW5hbWUtZ2V0dGVyLXN5 bWJvbHMuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vbmFtZWQtaXRlbXMtd2l0aC1lbXB0 eS1uYW1lLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL25hbWVkLWl0ZW1zLXdpdGgtc3lt Ym9sLW5hbWUuaHRtbAorICAgICAgICAgICAgICAgc3RvcmFnZS9kb21zdG9yYWdlL2xvY2Fsc3Rv cmFnZS9uYW1lZC1pdGVtcy5odG1sCisKKyAgICAgICAgVGVzdCBkaWZmZXJlbnQgYmluZGluZ3Mg b2JqZWN0cyB3aXRoIGN1c3RvbSBuYW1lZCBzZXR0ZXIKKyAgICAgICAgYW5kIGdldHRlciBoYW5k bGVycy4gRW5zdXJlIHRoYXQgdGhleSBoYW5kbGUgU3ltYm9sIHByb3BlcnRpZXMKKyAgICAgICAg Z3JhY2VmdWxseS4gT2Z0ZW4gdGltZXMgYXZvaWRpbmcgdGhlIHN0cmluZyBwYXRoLgorCisgICAg ICAgICogZG9tL0xpdmVOb2RlTGlzdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMaXZlTm9kZUxp c3Q6Om5hbWVkSXRlbSk6CisgICAgICAgICogZG9tL1N0YXRpY05vZGVMaXN0LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlN0YXRpY05vZGVMaXN0OjpuYW1lZEl0ZW0pOgorICAgICAgICAoV2ViQ29y ZTo6U3RhdGljRWxlbWVudExpc3Q6Om5hbWVkSXRlbSk6CisgICAgICAgIEJldHRlciBoYW5kbGUg dGhlIGVtcHR5IHN0cmluZy4gSXQgc2hvdWxkIG5vdCBtYXRjaCBhbiBpdGVtLgorCisgICAgICAg ICogYmluZGluZ3MvanMvSlNET01CaW5kaW5nLmg6CisgICAgICAgIChXZWJDb3JlOjpwcm9wZXJ0 eU5hbWVUb1N0cmluZyk6CisgICAgICAgIEluIGNhc2VzIHdoZXJlIHdlIHdvdWxkIHVzZSB0aGlz LCB3ZSBzaG91bGQgaGF2ZSBoYW5kbGVkCisgICAgICAgIFN5bWJvbCBwcm9wZXJ0aWVzLgorCisg ICAgICAgIChXZWJDb3JlOjpwcm9wZXJ0eU5hbWVUb0F0b21pY1N0cmluZyk6CisgICAgICAgIEZv ciBTeW1ib2xzLCB1c2UgdGhlIHVuaXF1ZSBzdHJpbmcuIFRoaXMgc2hvdWxkIHJlc3VsdAorICAg ICAgICBpbiBubyBtYXRjaGVzIGZvciBhIFN5bWJvbCBwcm9wZXJ0eS4KKworICAgICAgICAqIGJp bmRpbmdzL2pzL0pTRE9NU3RyaW5nTWFwQ3VzdG9tLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkpT RE9NU3RyaW5nTWFwOjpnZXRPd25Qcm9wZXJ0eVNsb3REZWxlZ2F0ZSk6CisgICAgICAgIChXZWJD b3JlOjpKU0RPTVN0cmluZ01hcDo6ZGVsZXRlUHJvcGVydHkpOgorICAgICAgICAoV2ViQ29yZTo6 SlNET01TdHJpbmdNYXA6OnB1dERlbGVnYXRlKToKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9KU1N0 b3JhZ2VDdXN0b20uY3BwOgorICAgICAgICAoV2ViQ29yZTo6SlNTdG9yYWdlOjpjYW5HZXRJdGVt c0Zvck5hbWUpOgorICAgICAgICAoV2ViQ29yZTo6SlNTdG9yYWdlOjpuYW1lR2V0dGVyKToKKyAg ICAgICAgKFdlYkNvcmU6OkpTU3RvcmFnZTo6ZGVsZXRlUHJvcGVydHkpOgorICAgICAgICAoV2Vi Q29yZTo6SlNTdG9yYWdlOjpwdXREZWxlZ2F0ZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSlNT dHlsZVNoZWV0TGlzdEN1c3RvbS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpKU1N0eWxlU2hlZXRM aXN0OjpjYW5HZXRJdGVtc0Zvck5hbWUpOgorICAgICAgICBUcmVhdCBTeW1ib2wgcHJvcGVydGll cyBhcyBwcml2YXRlIHByb3BlcnRpZXMuIFRoZXkganVzdAorICAgICAgICBnbyBkaXJlY3RseSB0 aHJvdWdoIHRvIHRoZSBPYmplY3QsIGFuZCBhdm9pZCB0aGUgc3RyaW5nCisgICAgICAgIGdldHRl ci9zZXR0ZXIgcHJvcGVydHkgcGF0aC4KKworICAgICAgICAqIGRvbS9DaGlsZE5vZGVMaXN0LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkNoaWxkTm9kZUxpc3Q6Om5hbWVkSXRlbSk6CisgICAgICAg ICogZG9tL0RPTU5hbWVkRmxvd0NvbGxlY3Rpb24uY3BwOgorICAgICAgICAoV2ViQ29yZTo6RE9N TmFtZWRGbG93Q29sbGVjdGlvbjo6bmFtZWRJdGVtKToKKyAgICAgICAgKiBodG1sL0hUTUxGb3Jt Q29udHJvbHNDb2xsZWN0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxGb3JtQ29udHJv bHNDb2xsZWN0aW9uOjpuYW1lZEl0ZW0pOgorICAgICAgICAqIE1vZHVsZXMvbWVkaWFzdHJlYW0v UlRDU3RhdHNSZXNwb25zZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSVENTdGF0c1Jlc3BvbnNl OjpuYW1lZEl0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6UlRDU3RhdHNSZXNwb25zZTo6Y2FuR2V0 SXRlbXNGb3JOYW1lKToKKyAgICAgICAgSWdub3JlIGVtcHR5IHN0cmluZ3MgaW4gb3RoZXIgbmFt ZWQgaXRlbSBnZXR0ZXJzLCBhcyB0aGF0CisgICAgICAgIHNob3VsZG4ndCBwcm9kdWNlIGEgcmVz dWx0LgorCiAyMDE1LTA0LTI4ICBZb3Vlbm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fu b24uZnI+CiAKICAgICAgICAgU2hhcmVkQnVmZmVyOjpjb3B5IGlzIG5vdCBjb21wdXRpbmcgdGhl IGJ1ZmZlciBzaXplIGNvcnJlY3RseSB3aGVuIGhhdmluZyBtX2RhdGFBcnJheQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9SVENTdGF0c1Jlc3BvbnNlLmNw cCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vUlRDU3RhdHNSZXNwb25zZS5j cHAKaW5kZXggYzNiNDFmZS4uMmM2MjZlMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy9tZWRpYXN0cmVhbS9SVENTdGF0c1Jlc3BvbnNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL21lZGlhc3RyZWFtL1JUQ1N0YXRzUmVzcG9uc2UuY3BwCkBAIC00MSw2ICs0MSw4 IEBAIFJUQ1N0YXRzUmVzcG9uc2U6OlJUQ1N0YXRzUmVzcG9uc2UoKQogCiBQYXNzUmVmUHRyPFJU Q1N0YXRzUmVwb3J0PiBSVENTdGF0c1Jlc3BvbnNlOjpuYW1lZEl0ZW0oY29uc3QgQXRvbWljU3Ry aW5nJiBuYW1lKQogeworICAgIGlmIChuYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIG51 bGxwdHI7CiAgICAgaWYgKG1faWRtYXAuZmluZChuYW1lKSAhPSBtX2lkbWFwLmVuZCgpKQogICAg ICAgICByZXR1cm4gbV9yZXN1bHRbbV9pZG1hcC5nZXQobmFtZSldOwogICAgIHJldHVybiBudWxs cHRyOwpAQCAtNDgsNyArNTAsNyBAQCBQYXNzUmVmUHRyPFJUQ1N0YXRzUmVwb3J0PiBSVENTdGF0 c1Jlc3BvbnNlOjpuYW1lZEl0ZW0oY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lKQogCiBib29sIFJU Q1N0YXRzUmVzcG9uc2U6OmNhbkdldEl0ZW1zRm9yTmFtZShjb25zdCBBdG9taWNTdHJpbmcmIG5h bWUpCiB7Ci0gICAgcmV0dXJuIG1faWRtYXAuY29udGFpbnMobmFtZSk7CisgICAgcmV0dXJuICFu YW1lLmlzRW1wdHkoKSAmJiBtX2lkbWFwLmNvbnRhaW5zKG5hbWUpOwogfQogCiBzaXplX3QgUlRD U3RhdHNSZXNwb25zZTo6YWRkUmVwb3J0KFN0cmluZyBpZCwgU3RyaW5nIHR5cGUsIGRvdWJsZSB0 aW1lc3RhbXApCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RPTUJp bmRpbmcuaCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NQmluZGluZy5oCmluZGV4 IDFlMGM4ZmQuLmM3ZjcxYmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pz L0pTRE9NQmluZGluZy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NQmlu ZGluZy5oCkBAIC01NjcsMTIgKzU2NywxMyBAQCBKU0M6OkVuY29kZWRKU1ZhbHVlIG9iamVjdFRv U3RyaW5nRnVuY3Rpb25HZXR0ZXIoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTT2JqZWN0KgogCiBp bmxpbmUgU3RyaW5nIHByb3BlcnR5TmFtZVRvU3RyaW5nKEpTQzo6UHJvcGVydHlOYW1lIHByb3Bl cnR5TmFtZSkKIHsKLSAgICByZXR1cm4gcHJvcGVydHlOYW1lLnB1YmxpY05hbWUoKTsKKyAgICBB U1NFUlQoIXByb3BlcnR5TmFtZS5pc1N5bWJvbCgpKTsKKyAgICByZXR1cm4gcHJvcGVydHlOYW1l LnVpZCgpID8gcHJvcGVydHlOYW1lLnVpZCgpIDogcHJvcGVydHlOYW1lLnB1YmxpY05hbWUoKTsK IH0KIAogaW5saW5lIEF0b21pY1N0cmluZyBwcm9wZXJ0eU5hbWVUb0F0b21pY1N0cmluZyhKU0M6 OlByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUpCiB7Ci0gICAgcmV0dXJuIEF0b21pY1N0cmluZyhw cm9wZXJ0eU5hbWUucHVibGljTmFtZSgpKTsKKyAgICByZXR1cm4gQXRvbWljU3RyaW5nKHByb3Bl cnR5TmFtZS51aWQoKSA/IHByb3BlcnR5TmFtZS51aWQoKSA6IHByb3BlcnR5TmFtZS5wdWJsaWNO YW1lKCkpOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBET01DbGFzcz4gaW5saW5lIGNvbnN0IEpT Qzo6SGFzaFRhYmxlVmFsdWUqIGdldFN0YXRpY1ZhbHVlU2xvdEVudHJ5V2l0aG91dENhY2hpbmco SlNDOjpFeGVjU3RhdGUqIGV4ZWMsIEpTQzo6UHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NU3RyaW5nTWFwQ3VzdG9t LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NU3RyaW5nTWFwQ3VzdG9tLmNw cAppbmRleCA1MjU5OGNlLi44OGRjNTZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy9qcy9KU0RPTVN0cmluZ01hcEN1c3RvbS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvanMvSlNET01TdHJpbmdNYXBDdXN0b20uY3BwCkBAIC0zNyw2ICszNyw4IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogYm9vbCBKU0RPTVN0cmluZ01hcDo6Z2V0T3duUHJvcGVydHlTbG90 RGVsZWdhdGUoRXhlY1N0YXRlKiBleGVjLCBQcm9wZXJ0eU5hbWUgcHJvcGVydHlOYW1lLCBQcm9w ZXJ0eVNsb3QmIHNsb3QpCiB7CisgICAgaWYgKHByb3BlcnR5TmFtZS5pc1N5bWJvbCgpKQorICAg ICAgICByZXR1cm4gZmFsc2U7CiAgICAgYm9vbCBuYW1lSXNWYWxpZDsKICAgICBjb25zdCBBdG9t aWNTdHJpbmcmIGl0ZW0gPSBpbXBsKCkuaXRlbShwcm9wZXJ0eU5hbWVUb1N0cmluZyhwcm9wZXJ0 eU5hbWUpLCBuYW1lSXNWYWxpZCk7CiAgICAgaWYgKG5hbWVJc1ZhbGlkKSB7CkBAIC01OCw5ICs2 MCwxMSBAQCB2b2lkIEpTRE9NU3RyaW5nTWFwOjpnZXRPd25Qcm9wZXJ0eU5hbWVzKEpTT2JqZWN0 KiBvYmplY3QsIEV4ZWNTdGF0ZSogZXhlYywgUHJvcAogICAgIEJhc2U6OmdldE93blByb3BlcnR5 TmFtZXModGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lcywgbW9kZSk7CiB9CiAKLWJvb2wg SlNET01TdHJpbmdNYXA6OmRlbGV0ZVByb3BlcnR5KEpTQ2VsbCogY2VsbCwgRXhlY1N0YXRlKiwg UHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSkKK2Jvb2wgSlNET01TdHJpbmdNYXA6OmRlbGV0ZVBy b3BlcnR5KEpTQ2VsbCogY2VsbCwgRXhlY1N0YXRlKiBleGVjLCBQcm9wZXJ0eU5hbWUgcHJvcGVy dHlOYW1lKQogewogICAgIEpTRE9NU3RyaW5nTWFwKiB0aGlzT2JqZWN0ID0ganNDYXN0PEpTRE9N U3RyaW5nTWFwKj4oY2VsbCk7CisgICAgaWYgKHByb3BlcnR5TmFtZS5pc1N5bWJvbCgpKQorICAg ICAgICByZXR1cm4gQmFzZTo6ZGVsZXRlUHJvcGVydHkodGhpc09iamVjdCwgZXhlYywgcHJvcGVy dHlOYW1lKTsKICAgICByZXR1cm4gdGhpc09iamVjdC0+bV9pbXBsLT5kZWxldGVJdGVtKHByb3Bl cnR5TmFtZVRvU3RyaW5nKHByb3BlcnR5TmFtZSkpOwogfQogCkBAIC03MSw5ICs3NSwxMyBAQCBi b29sIEpTRE9NU3RyaW5nTWFwOjpkZWxldGVQcm9wZXJ0eUJ5SW5kZXgoSlNDZWxsKiBjZWxsLCBF eGVjU3RhdGUqIGV4ZWMsIHVuc2lnbgogCiBib29sIEpTRE9NU3RyaW5nTWFwOjpwdXREZWxlZ2F0 ZShFeGVjU3RhdGUqIGV4ZWMsIFByb3BlcnR5TmFtZSBwcm9wZXJ0eU5hbWUsIEpTVmFsdWUgdmFs dWUsIFB1dFByb3BlcnR5U2xvdCYpCiB7CisgICAgaWYgKHByb3BlcnR5TmFtZS5pc1N5bWJvbCgp KQorICAgICAgICByZXR1cm4gZmFsc2U7CisKICAgICBTdHJpbmcgc3RyaW5nVmFsdWUgPSB2YWx1 ZS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhlYyk7CiAgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlv bigpKQogICAgICAgICByZXR1cm4gZmFsc2U7CisKICAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsK ICAgICBpbXBsKCkuc2V0SXRlbShwcm9wZXJ0eU5hbWVUb1N0cmluZyhwcm9wZXJ0eU5hbWUpLCBz dHJpbmdWYWx1ZSwgZWMpOwogICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU1N0b3JhZ2VDdXN0b20uY3BwIGIvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNTdG9yYWdlQ3VzdG9tLmNwcAppbmRleCBkNjQ2MDNl Li5lNjUxMzQwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU1N0b3Jh Z2VDdXN0b20uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTU3RvcmFnZUN1 c3RvbS5jcHAKQEAgLTM3LDYgKzM3LDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBib29sIEpT U3RvcmFnZTo6Y2FuR2V0SXRlbXNGb3JOYW1lKEV4ZWNTdGF0ZSogZXhlYywgU3RvcmFnZSogaW1w bCwgUHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSkKIHsKKyAgICBpZiAocHJvcGVydHlOYW1lLmlz U3ltYm9sKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWMg PSAwOwogICAgIGJvb2wgcmVzdWx0ID0gaW1wbC0+Y29udGFpbnMocHJvcGVydHlOYW1lVG9TdHJp bmcocHJvcGVydHlOYW1lKSwgZWMpOwogICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7CkBA IC01MSw2ICs1NCw5IEBAIEVuY29kZWRKU1ZhbHVlIEpTU3RvcmFnZTo6bmFtZUdldHRlcihFeGVj U3RhdGUqIGV4ZWMsIEpTT2JqZWN0KiBzbG90QmFzZSwgRW5jb2RlCiAgICAgaWYgKHByb3RvdHlw ZS5pc09iamVjdCgpICYmIGFzT2JqZWN0KHByb3RvdHlwZSktPmdldFByb3BlcnR5U2xvdChleGVj LCBwcm9wZXJ0eU5hbWUsIHNsb3QpKQogICAgICAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHNs b3QuZ2V0VmFsdWUoZXhlYywgcHJvcGVydHlOYW1lKSk7CiAKKyAgICBpZiAocHJvcGVydHlOYW1l LmlzU3ltYm9sKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwogICAgIEV4Y2VwdGlvbkNvZGUg ZWMgPSAwOwogICAgIEpTVmFsdWUgcmVzdWx0ID0ganNTdHJpbmdPck51bGwoZXhlYywgdGhpc09i amVjdC0+aW1wbCgpLmdldEl0ZW0ocHJvcGVydHlOYW1lVG9TdHJpbmcocHJvcGVydHlOYW1lKSwg ZWMpKTsKICAgICBzZXRET01FeGNlcHRpb24oZXhlYywgZWMpOwpAQCAtNjUsMTEgKzcxLDE0IEBA IGJvb2wgSlNTdG9yYWdlOjpkZWxldGVQcm9wZXJ0eShKU0NlbGwqIGNlbGwsIEV4ZWNTdGF0ZSog ZXhlYywgUHJvcGVydHlOYW1lIHByb3BlCiAgICAgLy8gdGhlIG5hdGl2ZSBwcm9wZXJ0eSBzbG90 cyBtYW51YWxseS4KICAgICBQcm9wZXJ0eVNsb3Qgc2xvdCh0aGlzT2JqZWN0KTsKICAgICBpZiAo Z2V0U3RhdGljVmFsdWVTbG90PEpTU3RvcmFnZSwgQmFzZT4oZXhlYywgKnNfaW5mby5zdGF0aWNQ cm9wSGFzaFRhYmxlLCB0aGlzT2JqZWN0LCBwcm9wZXJ0eU5hbWUsIHNsb3QpKQotICAgICAgICBy ZXR1cm4gZmFsc2U7Ci0gICAgICAgIAorICAgICAgICByZXR1cm4gQmFzZTo6ZGVsZXRlUHJvcGVy dHkodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lKTsKKwogICAgIEpTVmFsdWUgcHJvdG90 eXBlID0gdGhpc09iamVjdC0+cHJvdG90eXBlKCk7CiAgICAgaWYgKHByb3RvdHlwZS5pc09iamVj dCgpICYmIGFzT2JqZWN0KHByb3RvdHlwZSktPmdldFByb3BlcnR5U2xvdChleGVjLCBwcm9wZXJ0 eU5hbWUsIHNsb3QpKQotICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIHJldHVybiBCYXNl OjpkZWxldGVQcm9wZXJ0eSh0aGlzT2JqZWN0LCBleGVjLCBwcm9wZXJ0eU5hbWUpOworCisgICAg aWYgKHByb3BlcnR5TmFtZS5pc1N5bWJvbCgpKQorICAgICAgICByZXR1cm4gQmFzZTo6ZGVsZXRl UHJvcGVydHkodGhpc09iamVjdCwgZXhlYywgcHJvcGVydHlOYW1lKTsKIAogICAgIEV4Y2VwdGlv bkNvZGUgZWMgPSAwOwogICAgIHRoaXNPYmplY3QtPm1faW1wbC0+cmVtb3ZlSXRlbShwcm9wZXJ0 eU5hbWVUb1N0cmluZyhwcm9wZXJ0eU5hbWUpLCBlYyk7CkBAIC0xMTMsMTAgKzEyMiwxMyBAQCBi b29sIEpTU3RvcmFnZTo6cHV0RGVsZWdhdGUoRXhlY1N0YXRlKiBleGVjLCBQcm9wZXJ0eU5hbWUg cHJvcGVydHlOYW1lLCBKU1ZhbHVlCiAgICAgaWYgKHByb3RvdHlwZS5pc09iamVjdCgpICYmIGFz T2JqZWN0KHByb3RvdHlwZSktPmdldFByb3BlcnR5U2xvdChleGVjLCBwcm9wZXJ0eU5hbWUsIHNs b3QpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKKyAgICBpZiAocHJvcGVydHlOYW1lLmlzU3lt Ym9sKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwogICAgIFN0cmluZyBzdHJpbmdWYWx1ZSA9 IHZhbHVlLnRvU3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKTsKICAgICBpZiAoZXhlYy0+aGFkRXhj ZXB0aW9uKCkpCiAgICAgICAgIHJldHVybiB0cnVlOwotICAgIAorCiAgICAgRXhjZXB0aW9uQ29k ZSBlYyA9IDA7CiAgICAgaW1wbCgpLnNldEl0ZW0ocHJvcGVydHlOYW1lVG9TdHJpbmcocHJvcGVy dHlOYW1lKSwgc3RyaW5nVmFsdWUsIGVjKTsKICAgICBzZXRET01FeGNlcHRpb24oZXhlYywgZWMp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNTdHlsZVNoZWV0TGlz dEN1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU1N0eWxlU2hlZXRMaXN0 Q3VzdG9tLmNwcAppbmRleCBjNWVkYTMzLi44ZDliOTRhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU1N0eWxlU2hlZXRMaXN0Q3VzdG9tLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU1N0eWxlU2hlZXRMaXN0Q3VzdG9tLmNwcApAQCAtMzcsNiAr MzcsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wgSlNTdHlsZVNoZWV0TGlzdDo6Y2Fu R2V0SXRlbXNGb3JOYW1lKEV4ZWNTdGF0ZSosIFN0eWxlU2hlZXRMaXN0KiBzdHlsZVNoZWV0TGlz dCwgUHJvcGVydHlOYW1lIHByb3BlcnR5TmFtZSkKIHsKKyAgICBpZiAocHJvcGVydHlOYW1lLmlz U3ltYm9sKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICByZXR1cm4gc3R5bGVTaGVldExp c3QtPmdldE5hbWVkSXRlbShwcm9wZXJ0eU5hbWVUb1N0cmluZyhwcm9wZXJ0eU5hbWUpKTsKIH0K IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0NoaWxkTm9kZUxpc3QuY3BwIGIvU291 cmNlL1dlYkNvcmUvZG9tL0NoaWxkTm9kZUxpc3QuY3BwCmluZGV4IGRlZjllYjIuLmMwZjZkNWUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9DaGlsZE5vZGVMaXN0LmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9kb20vQ2hpbGROb2RlTGlzdC5jcHAKQEAgLTgzLDYgKzgzLDggQEAgdm9p ZCBDaGlsZE5vZGVMaXN0Ojpjb2xsZWN0aW9uVHJhdmVyc2VCYWNrd2FyZChOb2RlKiYgY3VycmVu dCwgdW5zaWduZWQgY291bnQpIGMKIAogTm9kZSogQ2hpbGROb2RlTGlzdDo6bmFtZWRJdGVtKGNv bnN0IEF0b21pY1N0cmluZyYgbmFtZSkgY29uc3QKIHsKKyAgICBpZiAobmFtZS5pc0VtcHR5KCkp CisgICAgICAgIHJldHVybiBudWxscHRyOwogICAgIC8vIEZJWE1FOiBBY2NvcmRpbmcgdG8gdGhl IHNwZWMgY2hpbGQgbm9kZSBsaXN0IHNob3VsZCBub3QgaGF2ZSBuYW1lZEl0ZW0oKS4KICAgICBp ZiAobV9wYXJlbnQuZ2V0KCkuaW5Eb2N1bWVudCgpKSB7CiAgICAgICAgIEVsZW1lbnQqIGVsZW1l bnQgPSBtX3BhcmVudC5nZXQoKS50cmVlU2NvcGUoKS5nZXRFbGVtZW50QnlJZChuYW1lKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9ET01OYW1lZEZsb3dDb2xsZWN0aW9uLmNwcCBi L1NvdXJjZS9XZWJDb3JlL2RvbS9ET01OYW1lZEZsb3dDb2xsZWN0aW9uLmNwcAppbmRleCA1ZWQ4 Y2Q1Li5lYzYzNWMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRE9NTmFtZWRGbG93 Q29sbGVjdGlvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RPTU5hbWVkRmxvd0NvbGxl Y3Rpb24uY3BwCkBAIC01NSw2ICs1NSw4IEBAIFBhc3NSZWZQdHI8V2ViS2l0TmFtZWRGbG93PiBE T01OYW1lZEZsb3dDb2xsZWN0aW9uOjppdGVtKHVuc2lnbmVkIGxvbmcgaW5kZXgpIGNvCiAKIFBh c3NSZWZQdHI8V2ViS2l0TmFtZWRGbG93PiBET01OYW1lZEZsb3dDb2xsZWN0aW9uOjpuYW1lZEl0 ZW0oY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lKSBjb25zdAogeworICAgIGlmIChuYW1lLmlzRW1w dHkoKSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CiAgICAgRE9NTmFtZWRGbG93U2V0Ojpjb25z dF9pdGVyYXRvciBpdCA9IG1fbmFtZWRGbG93cy5maW5kPFN0cmluZywgRE9NTmFtZWRGbG93SGFz aFRyYW5zbGF0b3I+KG5hbWUpOwogICAgIGlmIChpdCAhPSBtX25hbWVkRmxvd3MuZW5kKCkpCiAg ICAgICAgIHJldHVybiAqaXQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vTGl2ZU5v ZGVMaXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9MaXZlTm9kZUxpc3QuY3BwCmluZGV4IDRi YmFmZGYuLjM4MTI0NGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9MaXZlTm9kZUxp c3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9MaXZlTm9kZUxpc3QuY3BwCkBAIC01Myw2 ICs1Myw5IEBAIENvbnRhaW5lck5vZGUmIExpdmVOb2RlTGlzdDo6cm9vdE5vZGUoKSBjb25zdAog CiBOb2RlKiBMaXZlTm9kZUxpc3Q6Om5hbWVkSXRlbShjb25zdCBBdG9taWNTdHJpbmcmIGVsZW1l bnRJZCkgY29uc3QKIHsKKyAgICBpZiAoZWxlbWVudElkLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0 dXJuIG51bGxwdHI7CisKICAgICAvLyBGSVhNRTogV2h5IGRvZXNuJ3QgdGhpcyBsb29rIGludG8g dGhlIG5hbWUgYXR0cmlidXRlIGxpa2UgSFRNTENvbGxlY3Rpb246Om5hbWVkSXRlbSBkb2VzPwog ICAgIE5vZGUmIHJvb3ROb2RlID0gdGhpcy0+cm9vdE5vZGUoKTsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZG9tL1N0YXRpY05vZGVMaXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9T dGF0aWNOb2RlTGlzdC5jcHAKaW5kZXggZGQ3MGVlOS4uNWYwMjMzYiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvZG9tL1N0YXRpY05vZGVMaXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9k b20vU3RhdGljTm9kZUxpc3QuY3BwCkBAIC00NSw2ICs0NSw4IEBAIE5vZGUqIFN0YXRpY05vZGVM aXN0OjppdGVtKHVuc2lnbmVkIGluZGV4KSBjb25zdAogCiBOb2RlKiBTdGF0aWNOb2RlTGlzdDo6 bmFtZWRJdGVtKGNvbnN0IEF0b21pY1N0cmluZyYgZWxlbWVudElkKSBjb25zdAogeworICAgIGlm IChlbGVtZW50SWQuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKICAgICBmb3Ig KHVuc2lnbmVkIGkgPSAwLCBsZW5ndGggPSBtX25vZGVzLnNpemUoKTsgaSA8IGxlbmd0aDsgKytp KSB7CiAgICAgICAgIE5vZGUmIG5vZGUgPSBjb25zdF9jYXN0PE5vZGUmPihtX25vZGVzW2ldLmdl dCgpKTsKICAgICAgICAgaWYgKGlzPEVsZW1lbnQ+KG5vZGUpICYmIGRvd25jYXN0PEVsZW1lbnQ+ KG5vZGUpLmdldElkQXR0cmlidXRlKCkgPT0gZWxlbWVudElkKQpAQCAtNjcsNiArNjksOCBAQCBO b2RlKiBTdGF0aWNFbGVtZW50TGlzdDo6aXRlbSh1bnNpZ25lZCBpbmRleCkgY29uc3QKIAogTm9k ZSogU3RhdGljRWxlbWVudExpc3Q6Om5hbWVkSXRlbShjb25zdCBBdG9taWNTdHJpbmcmIGVsZW1l bnRJZCkgY29uc3QKIHsKKyAgICBpZiAoZWxlbWVudElkLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0 dXJuIG51bGxwdHI7CiAgICAgZm9yICh1bnNpZ25lZCBpID0gMCwgbGVuZ3RoID0gbV9lbGVtZW50 cy5zaXplKCk7IGkgPCBsZW5ndGg7ICsraSkgewogICAgICAgICBFbGVtZW50JiBlbGVtZW50ID0g Y29uc3RfY2FzdDxFbGVtZW50Jj4obV9lbGVtZW50c1tpXS5nZXQoKSk7CiAgICAgICAgIGlmIChl bGVtZW50LmdldElkQXR0cmlidXRlKCkgPT0gZWxlbWVudElkKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xzQ29sbGVjdGlvbi5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxGb3JtQ29udHJvbHNDb2xsZWN0aW9uLmNwcAppbmRleCAwZGVlY2MyLi4y ZWZiNDA1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbHND b2xsZWN0aW9uLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbHND b2xsZWN0aW9uLmNwcApAQCAtMTI4LDYgKzEyOCw4IEBAIEhUTUxFbGVtZW50KiBIVE1MRm9ybUNv bnRyb2xzQ29sbGVjdGlvbjo6bmFtZWRJdGVtKGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSkgY29u CiAgICAgLy8gYXR0cmlidXRlLiBJZiBhIG1hdGNoIGlzIG5vdCBmb3VuZCwgdGhlIG1ldGhvZCB0 aGVuIHNlYXJjaGVzIGZvciBhbgogICAgIC8vIG9iamVjdCB3aXRoIGEgbWF0Y2hpbmcgbmFtZSBh dHRyaWJ1dGUsIGJ1dCBvbmx5IG9uIHRob3NlIGVsZW1lbnRzCiAgICAgLy8gdGhhdCBhcmUgYWxs b3dlZCBhIG5hbWUgYXR0cmlidXRlLgorICAgIGlmIChuYW1lLmlzRW1wdHkoKSkKKyAgICAgICAg cmV0dXJuIG51bGxwdHI7CiAgICAgYXV0byogaW1hZ2VFbGVtZW50cyA9IGlzPEhUTUxGaWVsZFNl dEVsZW1lbnQ+KG93bmVyTm9kZSgpKSA/IG51bGxwdHIgOiAmZm9ybUltYWdlRWxlbWVudHMoKTsK ICAgICBpZiAoSFRNTEVsZW1lbnQqIGl0ZW0gPSBmaXJzdE5hbWVkSXRlbShmb3JtQ29udHJvbEVs ZW1lbnRzKCksIGltYWdlRWxlbWVudHMsIGlkQXR0ciwgbmFtZSkpCiAgICAgICAgIHJldHVybiBp dGVtOwo=