228122 2021-07-20 13:28:43 -0700 Add functionalities for parsing URL query string 2021-09-22 08:16:48 -0700 1 1 1 Unclassified WebKit WebKit Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=230628 InRadar P2 Normal --- 1 risul_islam webkit-unassigned achristensen annevk benjamin bfulgham cdumez cmarcelo darin ews-watchlist katherine_cheney webkit-bug-importer wilander oldest_to_newest 1778256 0 risul_islam 2021-07-20 13:28:43 -0700 It would be useful to have more ways to get information about URL query parameters. 1779471 1 434214 risul_islam 2021-07-26 10:40:20 -0700 Created attachment 434214 Patch 1779485 2 434214 wilander 2021-07-26 11:14:49 -0700 Comment on attachment 434214 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434214&action=review Good work. I'll start with comments on the meat of your patch. > Source/WTF/wtf/URL.cpp:1171 > + // Assumption 1: Parameters are seperated by '&' although ';' is also possible and ';' is not handled here. You don't seem to have further assumptions so the number is superfluous. I'd go with "Assumes that parameters are …" if we're keeping this comment. I would prefer a reference to a spec though. https://datatracker.ietf.org/doc/html/rfc3986/#section-3.4 is a good starting point. You'd have to find some reference to the use of semicolons. > Source/WTF/wtf/URL.cpp:1172 > + Vector<QueryParameter> queryParametersKeyValues; This can be declared after the early return. > Source/WTF/wtf/URL.cpp:1178 > + return queryParametersKeyValues; I think this can return an { } instead and you can push the declaration of queryParametersKeyValues even further down. > Source/WTF/wtf/URL.cpp:1185 > + tempKeyValues.setValue(""); This may able too use emptyString. > Source/WTF/wtf/URL.cpp:1199 > +std::optional<Vector<URL::QueryParameter>> URL::differenceInQueryParameters(URL matchingURL) const I would call this function differingQueryParameters() since that sounds more like the getter it is. > Source/WTF/wtf/URL.cpp:1207 > + if (!thisQueryParameters || !matchingQueryParameters) I would write these as two early returns to not have to do all the work upfront. Like this: if (!thisQueryParameters = queryParameters()) return std::nullopt; if (!matchingQueryParameters = matchingURL.queryParameters()) return std::nullopt; > Source/WTF/wtf/URL.cpp:1212 > + return diffResult; You can probably return { } here and push the declaration of diffResult further down. > Source/WTF/wtf/URL.cpp:1215 > + return matchingQueryParameters; Ditto. > Source/WTF/wtf/URL.cpp:1218 > + return thisQueryParameters; Ditto. > Source/WTF/wtf/URL.cpp:1220 > + HashMap<URL::QueryParameter, int> frequencyOfParameters; The purpose of this code is unclear. I wonder if we can find a more verbose variable name? > Source/WTF/wtf/URL.cpp:1227 > + Here's where you should declare diffResult. > Source/WTF/wtf/URL.cpp:1249 > +std::optional<bool> URL::isEqualQuery(URL matchingURL) const I'd go with isQueryEqual(). > Source/WTF/wtf/URL.cpp:1254 > + std::optional<Vector<QueryParameter>> difference = differenceInQueryParameters(matchingURL); Use auto. > Source/WTF/wtf/URL.cpp:1255 > + if (!difference.value().size()) I think this may fail if you get a nullopt. Regardless, you can just do: return !difference || !difference->size(); > Source/WTF/wtf/URL.cpp:1267 > + unsigned thisPathLength = m_string[m_pathEnd-1] == '/' ? m_pathEnd-1 : m_pathEnd; Use auto. > Source/WTF/wtf/URL.cpp:1268 > + unsigned matchingPathLength = matchingURL.m_string[matchingURL.m_pathEnd-1] == '/' ? matchingURL.m_pathEnd-1 : matchingURL.m_pathEnd; Ditto. > Source/WTF/wtf/URL.cpp:1269 > + String thisURLWithoutQuery = m_string.substring(0, thisPathLength); Ditto. > Source/WTF/wtf/URL.cpp:1270 > + String matchingURLWithoutQuery = matchingURL.m_string.substring(0, matchingPathLength); Ditto. > Source/WTF/wtf/URL.cpp:1272 > + return thisURLWithoutQuery == matchingURLWithoutQuery; Can we do this without creating two new String objects? 1779504 3 434214 katherine_cheney 2021-07-26 12:06:04 -0700 Comment on attachment 434214 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434214&action=review > Source/WTF/wtf/URL.cpp:1169 > +std::optional<Vector<URL::QueryParameter>> URL::queryParameters() const I wonder if this could return an empty vector for an invalid URL instead of being optional. >> Source/WTF/wtf/URL.cpp:1171 >> + // Assumption 1: Parameters are seperated by '&' although ';' is also possible and ';' is not handled here. > > You don't seem to have further assumptions so the number is superfluous. I'd go with "Assumes that parameters are …" if we're keeping this comment. > > I would prefer a reference to a spec though. https://datatracker.ietf.org/doc/html/rfc3986/#section-3.4 is a good starting point. You'd have to find some reference to the use of semicolons. I agree with John about removing the number. I don't really think a comment is necessary, it is quite clear in the code that parameters are being split by &. > Source/WTF/wtf/URL.cpp:1176 > + String queryPart = m_queryEnd == m_pathEnd ? "" : m_string.substring(m_pathEnd + 1, m_queryEnd - (m_pathEnd + 1)); Can you call query() here to avoid code duplication? > Source/WTF/wtf/URL.cpp:1180 > + for (String keyValuePair : queryPart.splitAllowingEmptyEntries('&')) { You can change String to be auto, it is shorter. >> Source/WTF/wtf/URL.cpp:1199 >> +std::optional<Vector<URL::QueryParameter>> URL::differenceInQueryParameters(URL matchingURL) const > > I would call this function differingQueryParameters() since that sounds more like the getter it is. matchingURL sounds like the URLs are the same. I would also change it to be something else, like otherURL. > Source/WTF/wtf/URL.cpp:1205 > + std::optional<Vector<QueryParameter>> matchingQueryParameters = matchingURL.queryParameters(); Ditto, I would change this to be otherQueryParameters. You can also use auto for both of these. > Source/WTF/wtf/URL.cpp:1210 > + Vector<QueryParameter> diffResult; I would avoid abbreviations as much as possible (that is a part of our style guidelines), so I would recommend changing this vector name. > Source/WTF/wtf/URL.cpp:1211 > + if (!thisQueryParameters.value().size() && !matchingQueryParameters.value().size()) Vector has an isEmpty() function that you can use here. > Source/WTF/wtf/URL.cpp:1214 > + if (!thisQueryParameters.value().size()) Ditto, using isEmpty() here would be easier to read. > Source/WTF/wtf/URL.cpp:1217 > + if (!matchingQueryParameters.value().size()) Ditto. > Source/WTF/wtf/URL.cpp:1221 > + for (QueryParameter keyValue : thisQueryParameters.value()) { auto& instead of QueryParameter. Also, the name "keyValue" gets confusing when you later are trying to set values in the map. I would stick to key or queryParameter instead. > Source/WTF/wtf/URL.cpp:1222 > + if (!frequencyOfParameters.contains(keyValue)) I *think* you can replace this if-else statement with the HashMap's ensure() function if you want, which creates a new entry if it doesn't exist, something like: auto& frequency = frequencyOfParameters.ensure(keyValue, []() { return 0; }).iterator->value; ++frequency; > Source/WTF/wtf/URL.cpp:1228 > + for (QueryParameter keyValue : matchingQueryParameters.value()) { Ditto about auto& and the keyValue naming. > Source/WTF/wtf/URL.cpp:1239 > + for (QueryParameter keyvalue : frequencyOfParameters.keys()) { auto&, and keyValue should have a name change or at least be camel case. > Source/WTF/wtf/URL.cpp:1240 > + if (frequencyOfParameters.get(keyvalue) > 0) { No need for > 0, you can just check if (frequencyOfParameters.get(keyvalue) > Source/WTF/wtf/URL.cpp:1246 > + return diffResult; This does not address query parameter ordering. should we consider ?key1=value1&key2=value2 the same as ?key2=value2&key1=value1 ? > Source/WTF/wtf/URL.cpp:1252 > + return std::nullopt; I don't think this should return an optional. I think if either or both URLs are invalid return false. >> Source/WTF/wtf/URL.cpp:1255 >> + if (!difference.value().size()) > > I think this may fail if you get a nullopt. Regardless, you can just do: > return !difference || !difference->size(); You can use isEmpty() here. > Source/WTF/wtf/URL.cpp:1265 > + return std::nullopt; I don't think this should return an optional. I think if either or both URLs are invalid return false. 1779510 4 434214 achristensen 2021-07-26 12:18:30 -0700 Comment on attachment 434214 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434214&action=review >> Source/WTF/wtf/URL.cpp:1269 >> + String thisURLWithoutQuery = m_string.substring(0, thisPathLength); > > Ditto. You don't need to allocate and copy the substrings just to check if they are equal. Use StringView. > Source/WTF/wtf/URL.h:229 > + WTF_EXPORT_PRIVATE std::optional<Vector<QueryParameter>> queryParameters() const; This should probably just use URLParser::parseURLEncodedForm instead of adding this. That also returns a URLEncodedForm, which basically makes your QueryParameter class unnecessary. 1779824 5 webkit-bug-importer 2021-07-27 13:29:18 -0700 <rdar://problem/81179093> 1780242 6 434214 risul_islam 2021-07-28 16:08:14 -0700 Comment on attachment 434214 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434214&action=review >> Source/WTF/wtf/URL.cpp:1169 >> +std::optional<Vector<URL::QueryParameter>> URL::queryParameters() const > > I wonder if this could return an empty vector for an invalid URL instead of being optional. That would be good. Done. >>> Source/WTF/wtf/URL.cpp:1171 >>> + // Assumption 1: Parameters are seperated by '&' although ';' is also possible and ';' is not handled here. >> >> You don't seem to have further assumptions so the number is superfluous. I'd go with "Assumes that parameters are …" if we're keeping this comment. >> >> I would prefer a reference to a spec though. https://datatracker.ietf.org/doc/html/rfc3986/#section-3.4 is a good starting point. You'd have to find some reference to the use of semicolons. > > I agree with John about removing the number. I don't really think a comment is necessary, it is quite clear in the code that parameters are being split by &. on it. >> Source/WTF/wtf/URL.cpp:1172 >> + Vector<QueryParameter> queryParametersKeyValues; > > This can be declared after the early return. Agreed. Done. >> Source/WTF/wtf/URL.cpp:1176 >> + String queryPart = m_queryEnd == m_pathEnd ? "" : m_string.substring(m_pathEnd + 1, m_queryEnd - (m_pathEnd + 1)); > > Can you call query() here to avoid code duplication? yes. on it. Done. >> Source/WTF/wtf/URL.cpp:1178 >> + return queryParametersKeyValues; > > I think this can return an { } instead and you can push the declaration of queryParametersKeyValues even further down. yes. Done. >> Source/WTF/wtf/URL.cpp:1180 >> + for (String keyValuePair : queryPart.splitAllowingEmptyEntries('&')) { > > You can change String to be auto, it is shorter. Done using "auto" whenever applicable. >> Source/WTF/wtf/URL.cpp:1185 >> + tempKeyValues.setValue(""); > > This may able too use emptyString. Used another function (URLParser::parseURLEncodedForm) suggested by Alex. >>> Source/WTF/wtf/URL.cpp:1199 >>> +std::optional<Vector<URL::QueryParameter>> URL::differenceInQueryParameters(URL matchingURL) const >> >> I would call this function differingQueryParameters() since that sounds more like the getter it is. > > matchingURL sounds like the URLs are the same. I would also change it to be something else, like otherURL. Done using other and differingQueryParameters. >> Source/WTF/wtf/URL.cpp:1205 >> + std::optional<Vector<QueryParameter>> matchingQueryParameters = matchingURL.queryParameters(); > > Ditto, I would change this to be otherQueryParameters. You can also use auto for both of these. yes. >> Source/WTF/wtf/URL.cpp:1207 >> + if (!thisQueryParameters || !matchingQueryParameters) > > I would write these as two early returns to not have to do all the work upfront. Like this: > if (!thisQueryParameters = queryParameters()) > return std::nullopt; > if (!matchingQueryParameters = matchingURL.queryParameters()) > return std::nullopt; sure. btw, I really like this code style. >> Source/WTF/wtf/URL.cpp:1210 >> + Vector<QueryParameter> diffResult; > > I would avoid abbreviations as much as possible (that is a part of our style guidelines), so I would recommend changing this vector name. it would be good. Done. >> Source/WTF/wtf/URL.cpp:1211 >> + if (!thisQueryParameters.value().size() && !matchingQueryParameters.value().size()) > > Vector has an isEmpty() function that you can use here. Done using isEmpty() whenever possible. >> Source/WTF/wtf/URL.cpp:1220 >> + HashMap<URL::QueryParameter, int> frequencyOfParameters; > > The purpose of this code is unclear. I wonder if we can find a more verbose variable name? Used frequencyOfDistinctParameter >> Source/WTF/wtf/URL.cpp:1228 >> + for (QueryParameter keyValue : matchingQueryParameters.value()) { > > Ditto about auto& and the keyValue naming. Used singleQueryParameter instead of keyValue. >> Source/WTF/wtf/URL.cpp:1240 >> + if (frequencyOfParameters.get(keyvalue) > 0) { > > No need for > 0, you can just check if (frequencyOfParameters.get(keyvalue) Here, frequencyOfParameters.get(keyvalue) can also be negative. Rearranging the code so that it stays non-negative. >> Source/WTF/wtf/URL.cpp:1246 >> + return diffResult; > > This does not address query parameter ordering. should we consider ?key1=value1&key2=value2 the same as ?key2=value2&key1=value1 ? Addressed this issue. Now ensures ordering. >> Source/WTF/wtf/URL.cpp:1252 >> + return std::nullopt; > > I don't think this should return an optional. I think if either or both URLs are invalid return false. Done. >>> Source/WTF/wtf/URL.cpp:1269 >>> + String thisURLWithoutQuery = m_string.substring(0, thisPathLength); >> >> Ditto. > > You don't need to allocate and copy the substrings just to check if they are equal. Use StringView. on it. >> Source/WTF/wtf/URL.cpp:1272 >> + return thisURLWithoutQuery == matchingURLWithoutQuery; > > Can we do this without creating two new String objects? Done. >> Source/WTF/wtf/URL.h:229 >> + WTF_EXPORT_PRIVATE std::optional<Vector<QueryParameter>> queryParameters() const; > > This should probably just use URLParser::parseURLEncodedForm instead of adding this. That also returns a URLEncodedForm, which basically makes your QueryParameter class unnecessary. I am onto it. Done. Used the URLParser::parseURLEncodedForm. Works just the same and fine. 1780423 7 434531 risul_islam 2021-07-29 10:23:52 -0700 Created attachment 434531 Patch 1780434 8 434531 achristensen 2021-07-29 10:39:44 -0700 Comment on attachment 434531 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434531&action=review > Source/WTF/wtf/URL.cpp:1177 > + if (queryPart.isEmpty()) > + return { }; Is this needed? > Source/WTF/wtf/URL.cpp:1231 > +bool URL::isEqualIgnoringQuery(URL otherURL) const Do we want to compare the fragments after the query? > Source/WTF/wtf/URL.cpp:1237 > + auto thisPathLength = m_string[m_pathEnd-1] == '/' ? m_pathEnd-1 : m_pathEnd; > + auto otherPathLength = otherURL.m_string[otherURL.m_pathEnd-1] == '/' ? otherURL.m_pathEnd-1 : otherURL.m_pathEnd; WebKit code style needs a space before and after the minus > Source/WTF/wtf/URL.cpp:1239 > + return m_string.substring(0, thisPathLength) == otherURL.m_string.substring(0, otherPathLength); Use StringViews. There's no need to allocate and copy just to compare. > Source/WTF/wtf/URL.cpp:1242 > +bool URL::isQueryEqual(URL otherURL) const This should probably be a const URL& to avoid an unnecessary copy every time this is called. Also, this should probably be renamed to containsSameQueryParameters or something like that to reflect the fact that query parameter order doesn't matter here. You should also add a test showing that http://example.com/?a=b&c=d and http://example.com/?c=d&a=b are equal here. > Source/WTF/wtf/URL.cpp:1245 > + return { }; This should probably be true or false instead of { }, which is less clear for booleans. > Source/WTF/wtf/URL.cpp:1255 > +void URL::removeQueryParameters(HashSet<String> keysToRemove) ditto. const reference. > Source/WTF/wtf/URL.cpp:1267 > + queryWithoutRemovalKey = queryWithoutRemovalKey + singleQueryParameter.key + "=" + singleQueryParameter.value + "&"; This should use makeString instead of operator+ to avoid all the intermediaries. > Source/WTF/wtf/URL.cpp:1272 > + queryWithoutRemovalKey = queryWithoutRemovalKey.substring(0, queryWithoutRemovalKey.length() - 1); You need to check if queryWithoutRemovalKey.length() is zero. 1780505 9 434531 risul_islam 2021-07-29 12:14:13 -0700 Comment on attachment 434531 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434531&action=review >> Source/WTF/wtf/URL.cpp:1177 >> + return { }; > > Is this needed? We can achieve the same functionality using query() and URLParser::parseURLEncodedForm() function. So, we can discard it. >> Source/WTF/wtf/URL.cpp:1231 >> +bool URL::isEqualIgnoringQuery(URL otherURL) const > > Do we want to compare the fragments after the query? For now, we are only interested in anything before query. I guess we can rename the function name to 'isEqualIgnoringQueryAndFragment'? >> Source/WTF/wtf/URL.cpp:1237 >> + auto otherPathLength = otherURL.m_string[otherURL.m_pathEnd-1] == '/' ? otherURL.m_pathEnd-1 : otherURL.m_pathEnd; > > WebKit code style needs a space before and after the minus On it. >> Source/WTF/wtf/URL.cpp:1239 >> + return m_string.substring(0, thisPathLength) == otherURL.m_string.substring(0, otherPathLength); > > Use StringViews. There's no need to allocate and copy just to compare. On it. >> Source/WTF/wtf/URL.cpp:1242 >> +bool URL::isQueryEqual(URL otherURL) const > > This should probably be a const URL& to avoid an unnecessary copy every time this is called. > Also, this should probably be renamed to containsSameQueryParameters or something like that to reflect the fact that query parameter order doesn't matter here. You should also add a test showing that http://example.com/?a=b&c=d and http://example.com/?c=d&a=b are equal here. Awesome idea, adding a test case. >> Source/WTF/wtf/URL.cpp:1245 >> + return { }; > > This should probably be true or false instead of { }, which is less clear for booleans. Right. >> Source/WTF/wtf/URL.cpp:1267 >> + queryWithoutRemovalKey = queryWithoutRemovalKey + singleQueryParameter.key + "=" + singleQueryParameter.value + "&"; > > This should use makeString instead of operator+ to avoid all the intermediaries. Great. That would make code clear. >> Source/WTF/wtf/URL.cpp:1272 >> + queryWithoutRemovalKey = queryWithoutRemovalKey.substring(0, queryWithoutRemovalKey.length() - 1); > > You need to check if queryWithoutRemovalKey.length() is zero. On it. 1780836 10 434642 risul_islam 2021-07-30 10:06:47 -0700 Created attachment 434642 Patch 1780893 11 434642 achristensen 2021-07-30 11:31:48 -0700 Comment on attachment 434642 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434642&action=review Needs a bit more refinement. Also, your tests are missing queries with keys but no values, like http://example.com/?a=b&c&d=e > Source/WTF/wtf/KeyValuePair.h:62 > + We don't want to add empty whitespace here. > Source/WTF/wtf/URL.cpp:1172 > + Extra space. > Source/WTF/wtf/URL.cpp:1179 > + if (thisQueryParameters.isEmpty() && otherQueryParameters.isEmpty()) > + return { }; This is completely unnecessary, doesn't change any behavior, but does increase complexity of the code. Please remove. > Source/WTF/wtf/URL.cpp:1182 > + if (thisQueryParameters.isEmpty()) > + return otherQueryParameters; Probably also true with these, although these might be slight performance optimizations. > Source/WTF/wtf/URL.cpp:1188 > + HashMap<KeyValuePair<String, String>, int> frequencyOfDistinctParameter; Does the value of this map need to be signed? Could int be changed to unsigned or size_t? > Source/WTF/wtf/URL.cpp:1193 > + if (!frequencyOfDistinctParameter.contains(keyValue)) > + frequencyOfDistinctParameter.add(keyValue, 1); > + else > + frequencyOfDistinctParameter.set(keyValue, frequencyOfDistinctParameter.get(keyValue) + 1); This does up to 3 hash lookups when only one is necessary. Use HashMap::add(keyValue, 1) and look at the return value. If addResult.isNewEntry is true, then you're done. Otherwise, use addResult.iterator to increment the value. > Source/WTF/wtf/URL.cpp:1203 > + frequencyOfDistinctParameter.set(singleQueryParameter, frequencyOfDistinctParameter.get(singleQueryParameter) - 1); Ditto with the duplicate hash lookups. > Source/WTF/wtf/URL.cpp:1209 > + for (int i = 0; i < frequencyOfDistinctParameter.get(singleQueryParameter); i++) This does a get every loop iteration, when it should always return the same value, and I'm pretty sure the compiler optimizer doesn't realize it. Store the value outside the for loop. > Source/WTF/wtf/URL.cpp:1212 > + frequencyOfDistinctParameter.set(singleQueryParameter, 0); This is also a duplicate hash lookup. Use HashMap::take. > Source/WTF/wtf/URL.cpp:1224 > + auto thisPathLength = m_string[m_pathEnd - 1] == '/' ? m_pathEnd - 1 : m_pathEnd; I don't think this does what you think it does. You have a test with "http://www.webkit.org?" but when parsed and canonicalized it becomes "http://www.webkit.org/?". Add a test with a zero length path, like custom-scheme://host?a=b and http://example.com/?a=b > Source/WTF/wtf/URL.cpp:1225 > + auto otherPathLength = otherURL.m_string[otherURL.m_pathEnd - 1] == '/' ? otherURL.m_pathEnd - 1 : otherURL.m_pathEnd; Extra space. > Source/WTF/wtf/URL.cpp:1230 > +bool URL::containsSameQueryParameters(const URL& otherURL) const Do we want http://example.com/ and http://example.com/? to be considered to have the same query parameters? Add that test. > Source/WTF/wtf/URL.cpp:1239 > + if (queryDifference.isEmpty()) > + return true; > + > + return false; return queryDifference.isEmpty(); > Source/WTF/wtf/URL.cpp:1249 > + if (queryParametersList.isEmpty()) > + return; This is almost certainly unnecessary. > Source/WTF/wtf/URL.cpp:1254 > + queryWithoutRemovalKeys = makeString(queryWithoutRemovalKeys, singleQueryParameter.key, '=', singleQueryParameter.value, '&'); This. should actually be a StringBuilder instead. It's more efficient than this, which is currently an O(n^2) algorithm because of all the recopying of the current String. > Source/WTF/wtf/URL.cpp:1255 > + Extra space. > Source/WTF/wtf/URL.cpp:1259 > + queryWithoutRemovalKeys = queryWithoutRemovalKeys.substring(0, queryWithoutRemovalKeys.length() - 1); This is also a wasteful String allocation and copy. This could either be done with a StringView substring, which is just an integer subtraction, or by checking if queryWithoutRemovalKeys is empty in the loop and adding '&' before the new values if not. 1780901 12 434642 risul_islam 2021-07-30 12:14:44 -0700 Comment on attachment 434642 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434642&action=review >> Source/WTF/wtf/URL.cpp:1259 >> + queryWithoutRemovalKeys = queryWithoutRemovalKeys.substring(0, queryWithoutRemovalKeys.length() - 1); > > This is also a wasteful String allocation and copy. This could either be done with a StringView substring, which is just an integer subtraction, or by checking if queryWithoutRemovalKeys is empty in the loop and adding '&' before the new values if not. On all the above things. 1780942 13 434642 risul_islam 2021-07-30 14:05:50 -0700 Comment on attachment 434642 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434642&action=review >> Source/WTF/wtf/URL.cpp:1224 >> + auto thisPathLength = m_string[m_pathEnd - 1] == '/' ? m_pathEnd - 1 : m_pathEnd; > > I don't think this does what you think it does. You have a test with "http://www.webkit.org?" but when parsed and canonicalized it becomes "http://www.webkit.org/?". Add a test with a zero length path, like custom-scheme://host?a=b and http://example.com/?a=b Sorry for the confusion. I am changing thisPathLength to thisLengthOfURLIgnoringQueryAndFragments. >> Source/WTF/wtf/URL.cpp:1230 >> +bool URL::containsSameQueryParameters(const URL& otherURL) const > > Do we want http://example.com/ and http://example.com/? to be considered to have the same query parameters? Add that test. Yes, we want to consider them equal. Adding test. >> Source/WTF/wtf/URL.cpp:1254 >> + queryWithoutRemovalKeys = makeString(queryWithoutRemovalKeys, singleQueryParameter.key, '=', singleQueryParameter.value, '&'); > > This. should actually be a StringBuilder instead. It's more efficient than this, which is currently an O(n^2) algorithm because of all the recopying of the current String. Need a little bit more clarification. 1780976 14 434669 risul_islam 2021-07-30 16:05:10 -0700 Created attachment 434669 Patch 1780983 15 434669 darin 2021-07-30 16:13:51 -0700 Comment on attachment 434669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434669&action=review > Source/WTF/ChangeLog:8 > + Added more functionalities for parsing URL query parameters. I don’t fully understand why adding more functions that are not yet used is important for WebKIt, but I trust there is some reason. > Source/WTF/wtf/KeyValuePair.h:67 > + template <typename K, typename V> > + bool operator==(const KeyValuePair<K, V>& other) const > + { > + return key == other.key && value == other.value; > + } This doesn’t need to be a member. Making it a free function that takes two arguments is a little better in terms of supporting conversions on the left side of the "==" so I think we might prefer that. > Source/WTF/wtf/URL.cpp:1176 > + auto thisQueryParameters = URLParser::parseURLEncodedForm(query()); > + auto otherQueryParameters = URLParser::parseURLEncodedForm(otherURL.query()); It seems to me would could implement this operation significantly more efficiently by sorting both vectors and walking through them, rather than using a hash table. > Source/WTF/wtf/URL.cpp:1185 > + HashMap<KeyValuePair<String, String>, unsigned> frequencyOfDistinctParameters; We have a data structure for this called HashCountedSet. Using that would simplify the code below. > Source/WTF/wtf/URL.cpp:1205 > + auto frequencyOfsingleQueryParameter = frequencyOfDistinctParameters.take(singleQueryParameter); Lowercase "s" here. > Source/WTF/wtf/URL.cpp:1222 > + auto thisLengthOfURLIgnoringQueryAndFragments = m_string[m_pathEnd - 1] == '/' ? m_pathEnd - 1 : m_pathEnd; > + auto otherLengthOfURLIgnoringQueryAndFragments = otherURL.m_string[otherURL.m_pathEnd - 1] == '/' ? otherURL.m_pathEnd - 1 : otherURL.m_pathEnd; > + return StringView(m_string).substring(0, thisLengthOfURLIgnoringQueryAndFragments) == StringView(otherURL.m_string).substring(0, otherLengthOfURLIgnoringQueryAndFragments); Seems like we should use a helper function rather than repeating this logic twice. Could be private or local to this file. > Source/WTF/wtf/URL.cpp:1231 > + auto queryDifference = differingQueryParameters(otherURL); > + return queryDifference.isEmpty(); No need for a local variable here. This seems like an inefficient algorithm; if we were using this somewhere performance critical we’d want to do this in a way that doesn’t allocate so much memory. > Source/WTF/wtf/URL.cpp:1242 > + if (keysToRemove.find(singleQueryParameter.key) == keysToRemove.end()) { The best idiom here is to call contains, rather than find == end. > Source/WTF/wtf/URL.cpp:1244 > + queryWithoutRemovalKeys = makeString(queryWithoutRemovalKeys, '&', singleQueryParameter.key, '=', singleQueryParameter.value); This is not an efficient way to build up a string. Concatenating each time means lots of memory allocation. We have a class named StringBuilder that implements this kind of idiom efficiently. > Source/WTF/wtf/URL.cpp:1250 > + setQuery(StringView(queryWithoutRemovalKeys)); There should not be a need to call StringView() here explicitly. > Source/WTF/wtf/URL.h:207 > + WTF_EXPORT_PRIVATE Vector<KeyValuePair<String, String>> differingQueryParameters(const URL&) const; > + WTF_EXPORT_PRIVATE bool isEqualIgnoringQueryAndFragments(const URL&) const; > + WTF_EXPORT_PRIVATE bool containsSameQueryParameters(const URL&) const; > + WTF_EXPORT_PRIVATE void removeQueryParameters(const HashSet<String>&); How did you decide that these should be members of the URL class rather than functions that take a URL? In particular, the ones that take two URLs seem like they should be functions that take two URLs. 1781009 16 434669 risul_islam 2021-07-30 17:03:44 -0700 Comment on attachment 434669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434669&action=review >> Source/WTF/ChangeLog:8 >> + Added more functionalities for parsing URL query parameters. > > I don’t fully understand why adding more functions that are not yet used is important for WebKIt, but I trust there is some reason. Thank you Darin for your valuable comments and insights. We are trying to come up with a feature that restricts tracking parameters from the URL while loading or sharing by copying. Thats why we are adding the functionalities in this patch. >> Source/WTF/wtf/URL.cpp:1176 >> + auto otherQueryParameters = URLParser::parseURLEncodedForm(otherURL.query()); > > It seems to me would could implement this operation significantly more efficiently by sorting both vectors and walking through them, rather than using a hash table. Wouldn't sorting be costly in terms of time? We preferred to sacrifice some memory. Although the length of the URL and the number of the parameter is not that huge, still we can discuss about any kind of optimization. >> Source/WTF/wtf/URL.cpp:1185 >> + HashMap<KeyValuePair<String, String>, unsigned> frequencyOfDistinctParameters; > > We have a data structure for this called HashCountedSet. Using that would simplify the code below. Great idea, on to it. >> Source/WTF/wtf/URL.cpp:1205 >> + auto frequencyOfsingleQueryParameter = frequencyOfDistinctParameters.take(singleQueryParameter); > > Lowercase "s" here. Sorry for the mistake. Fixing it. >> Source/WTF/wtf/URL.cpp:1222 >> + return StringView(m_string).substring(0, thisLengthOfURLIgnoringQueryAndFragments) == StringView(otherURL.m_string).substring(0, otherLengthOfURLIgnoringQueryAndFragments); > > Seems like we should use a helper function rather than repeating this logic twice. Could be private or local to this file. We can write a static function in this file. >> Source/WTF/wtf/URL.cpp:1231 >> + return queryDifference.isEmpty(); > > No need for a local variable here. > > This seems like an inefficient algorithm; if we were using this somewhere performance critical we’d want to do this in a way that doesn’t allocate so much memory. I agree. we can directly use: return differingQueryParameters(otherURL).isEmpty(); Even discard the function. >> Source/WTF/wtf/URL.cpp:1242 >> + if (keysToRemove.find(singleQueryParameter.key) == keysToRemove.end()) { > > The best idiom here is to call contains, rather than find == end. On to it. >> Source/WTF/wtf/URL.cpp:1244 >> + queryWithoutRemovalKeys = makeString(queryWithoutRemovalKeys, '&', singleQueryParameter.key, '=', singleQueryParameter.value); > > This is not an efficient way to build up a string. Concatenating each time means lots of memory allocation. We have a class named StringBuilder that implements this kind of idiom efficiently. Using StringBuilder now. >> Source/WTF/wtf/URL.cpp:1250 >> + setQuery(StringView(queryWithoutRemovalKeys)); > > There should not be a need to call StringView() here explicitly. setQuery(StringView) takes StringView as argument. Will it type cast to StringView automatically if we provide String? >> Source/WTF/wtf/URL.h:207 >> + WTF_EXPORT_PRIVATE void removeQueryParameters(const HashSet<String>&); > > How did you decide that these should be members of the URL class rather than functions that take a URL? In particular, the ones that take two URLs seem like they should be functions that take two URLs. I am sorry I am a little bit unclear here. It would be very helpful if I could be a bit clear. 1781012 17 434669 darin 2021-07-30 17:06:04 -0700 Comment on attachment 434669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434669&action=review >>> Source/WTF/wtf/URL.cpp:1176 >>> + auto otherQueryParameters = URLParser::parseURLEncodedForm(otherURL.query()); >> >> It seems to me would could implement this operation significantly more efficiently by sorting both vectors and walking through them, rather than using a hash table. > > Wouldn't sorting be costly in terms of time? We preferred to sacrifice some memory. Although the length of the URL and the number of the parameter is not that huge, still we can discuss about any kind of optimization. No, I don’t think so. >>> Source/WTF/wtf/URL.cpp:1250 >>> + setQuery(StringView(queryWithoutRemovalKeys)); >> >> There should not be a need to call StringView() here explicitly. > > setQuery(StringView) takes StringView as argument. Will it type cast to StringView automatically if we provide String? Yes. >>> Source/WTF/wtf/URL.h:207 >>> + WTF_EXPORT_PRIVATE void removeQueryParameters(const HashSet<String>&); >> >> How did you decide that these should be members of the URL class rather than functions that take a URL? In particular, the ones that take two URLs seem like they should be functions that take two URLs. > > I am sorry I am a little bit unclear here. It would be very helpful if I could be a bit clear. Example:   bool areEqualIgnoringQueryAndFragments(const URL&, const URL&); 1781013 18 434669 wilander 2021-07-30 17:06:56 -0700 Comment on attachment 434669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434669&action=review Good suggestions from Darin. >> Source/WTF/ChangeLog:8 >> + Added more functionalities for parsing URL query parameters. > > I don’t fully understand why adding more functions that are not yet used is important for WebKIt, but I trust there is some reason. I'd say "Added parsing of URL query strings." > Tools/TestWebKitAPI/Tests/WTF/URL.cpp:522 > + EXPECT_EQ(url9.string(), url12.string()); You need to have a section of negative tests, for instance named URLMalformedQueryStrings. There your test things like: · http://www.webkit.org/?? · http://www.webkit.org/?/?test=test · http://www.webkit.org/?=test · http://www.webkit.org/?== · http://www.webkit.org/?=? · http://www.webkit.org/=? · http://www.webkit.org?? · http://www.webkit.org?/?test=test · http://www.webkit.org?=test · http://www.webkit.org?== · http://www.webkit.org?=? · http://www.webkit.org=? 1781016 19 434669 darin 2021-07-30 17:10:42 -0700 Comment on attachment 434669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434669&action=review >>>> Source/WTF/wtf/URL.cpp:1176 >>>> + auto otherQueryParameters = URLParser::parseURLEncodedForm(otherURL.query()); >>> >>> It seems to me would could implement this operation significantly more efficiently by sorting both vectors and walking through them, rather than using a hash table. >> >> Wouldn't sorting be costly in terms of time? We preferred to sacrifice some memory. Although the length of the URL and the number of the parameter is not that huge, still we can discuss about any kind of optimization. > > No, I don’t think so. We would be sorting a vector of pairs of pointers. It should not be more costly than hash tables. Both should be O(n log n). Including the speed of the memory allocation, I expect the sorting algorithm would be both faster and use less memory. 1781022 20 434669 risul_islam 2021-07-30 17:43:15 -0700 Comment on attachment 434669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434669&action=review >>>> Source/WTF/ChangeLog:8 >>>> + Added more functionalities for parsing URL query parameters. >>> >>> I don’t fully understand why adding more functions that are not yet used is important for WebKIt, but I trust there is some reason. >> >> Thank you Darin for your valuable comments and insights. We are trying to come up with a feature that restricts tracking parameters from the URL while loading or sharing by copying. Thats why we are adding the functionalities in this patch. > > I'd say "Added parsing of URL query strings." Great. On it. >> Tools/TestWebKitAPI/Tests/WTF/URL.cpp:522 >> + EXPECT_EQ(url9.string(), url12.string()); > > You need to have a section of negative tests, for instance named URLMalformedQueryStrings. There your test things like: > · http://www.webkit.org/?? > · http://www.webkit.org/?/?test=test > · http://www.webkit.org/?=test > · http://www.webkit.org/?== > · http://www.webkit.org/?=? > · http://www.webkit.org/=? > · http://www.webkit.org?? > · http://www.webkit.org?/?test=test > · http://www.webkit.org?=test > · http://www.webkit.org?== > · http://www.webkit.org?=? > · http://www.webkit.org=? We assumed that the first '?' is the start of the query string. Then the query parameters are separated by '&' and finally parameter key and value is separated by '=' . Since there is no standard we got this assumption from https://www.freeformatter.com/url-parser-query-string-splitter.html There are some test cases added for the above kinds of URLs. Do we want more tests? 1781023 21 434669 risul_islam 2021-07-30 17:46:12 -0700 Comment on attachment 434669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434669&action=review >>>>> Source/WTF/wtf/URL.cpp:1176 >>>>> + auto otherQueryParameters = URLParser::parseURLEncodedForm(otherURL.query()); >>>> >>>> It seems to me would could implement this operation significantly more efficiently by sorting both vectors and walking through them, rather than using a hash table. >>> >>> Wouldn't sorting be costly in terms of time? We preferred to sacrifice some memory. Although the length of the URL and the number of the parameter is not that huge, still we can discuss about any kind of optimization. >> >> No, I don’t think so. > > We would be sorting a vector of pairs of pointers. It should not be more costly than hash tables. Both should be O(n log n). Including the speed of the memory allocation, I expect the sorting algorithm would be both faster and use less memory. Clear now. Thanks Darin. >>>> Source/WTF/wtf/URL.h:207 >>>> + WTF_EXPORT_PRIVATE void removeQueryParameters(const HashSet<String>&); >>> >>> How did you decide that these should be members of the URL class rather than functions that take a URL? In particular, the ones that take two URLs seem like they should be functions that take two URLs. >> >> I am sorry I am a little bit unclear here. It would be very helpful if I could be a bit clear. > > Example: > >   bool areEqualIgnoringQueryAndFragments(const URL&, const URL&); Got it. Thank you for the clarification. 1781035 22 wilander 2021-07-30 18:58:39 -0700 (In reply to Risul Islam from comment #20) > Comment on attachment 434669 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=434669&action=review > > >>>> Source/WTF/ChangeLog:8 > >>>> + Added more functionalities for parsing URL query parameters. > >>> > >>> I don’t fully understand why adding more functions that are not yet used is important for WebKIt, but I trust there is some reason. > >> > >> Thank you Darin for your valuable comments and insights. We are trying to come up with a feature that restricts tracking parameters from the URL while loading or sharing by copying. Thats why we are adding the functionalities in this patch. > > > > I'd say "Added parsing of URL query strings." > > Great. On it. > > >> Tools/TestWebKitAPI/Tests/WTF/URL.cpp:522 > >> + EXPECT_EQ(url9.string(), url12.string()); > > > > You need to have a section of negative tests, for instance named URLMalformedQueryStrings. There your test things like: > > · http://www.webkit.org/?? > > · http://www.webkit.org/?/?test=test > > · http://www.webkit.org/?=test > > · http://www.webkit.org/?== > > · http://www.webkit.org/?=? > > · http://www.webkit.org/=? > > · http://www.webkit.org?? > > · http://www.webkit.org?/?test=test > > · http://www.webkit.org?=test > > · http://www.webkit.org?== > > · http://www.webkit.org?=? > > · http://www.webkit.org=? > > We assumed that the first '?' is the start of the query string. Then the > query parameters are separated by '&' and finally parameter key and value is > separated by '=' . Since there is no standard we got this assumption from > https://www.freeformatter.com/url-parser-query-string-splitter.html > > There are some test cases added for the above kinds of URLs. Do we want more > tests? Yes. Your tests are not just there to confirm intended functionality but also to defend against future mistakes. You want to explore a bunch of corner cases and make sure your code handles them gracefully. Then two years later, someone may change your code and make a simple mistake. That’s when your fleshed out test suite will pay off. 1781190 23 434736 risul_islam 2021-08-01 21:44:49 -0700 Created attachment 434736 Patch 1781315 24 434736 darin 2021-08-02 11:06:04 -0700 Comment on attachment 434736 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434736&action=review I appreciate the work to do a sorting-based algorithm instead of a hash table. > Source/WTF/wtf/HashFunctions.h:182 > + template<typename T, typename U> struct KeyValuePairHash { > + static unsigned hash(const KeyValuePair<T, U>& p) > + { > + return pairIntHash(DefaultHash<T>::hash(p.key), DefaultHash<U>::hash(p.value)); > + } > + static bool equal(const KeyValuePair<T, U>& a, const KeyValuePair<T, U>& b) > + { > + return DefaultHash<T>::equal(a.key, b.key) && DefaultHash<U>::equal(a.value, b.value); > + } > + static constexpr bool safeToCompareToEmptyOrDeleted = DefaultHash<T>::safeToCompareToEmptyOrDeleted && DefaultHash<U>::safeToCompareToEmptyOrDeleted; > + }; We aren’t using a KeyValuePair as a hash table key. Can we either not do this at all at this time, or do it in a separate patch? > Source/WTF/wtf/HashFunctions.h:282 > + template<typename T, typename U> struct DefaultHash<KeyValuePair<T, U>> : KeyValuePairHash<T, U> { }; We aren’t using a KeyValuePair as a hash table key. Can we either not do this at all at this time, or do it in a separate patch? > Source/WTF/wtf/HashTraits.h:431 > +using WTF::KeyValuePairHashTraits; We aren’t using a KeyValuePair as a hash table key. Can we either not do this at all at this time, or do it in a separate patch? > Source/WTF/wtf/KeyValuePair.h:67 > + template <typename K, typename V> > + bool operator==(const KeyValuePair<K, V>& other) const > + { > + return key == other.key && value == other.value; > + } I’d like to see this be done as a free function, after the class definition: template<typename KeyType, typename ValueType> constexpr bool operator=(const KeyValuePair<KeyType, ValueType>& a, const KeyValuePair<KeyType, ValueType>& b) { return a.key == b.key && a.value == b.value; } But also, this change is no longer needed in this patch. We aren’t using a KeyValuePair as a hash table key. Can we either not do this at all at this time, or do it in a separate patch? > Source/WTF/wtf/URL.cpp:1189 > + StringBuilder firstKeyValuePairAppended; > + StringBuilder secondKeyValuePairAppended; > + firstKeyValuePairAppended.append(firstKeyValuePair.key, firstKeyValuePair.value); > + secondKeyValuePairAppended.append(secondKeyValuePair.key, secondKeyValuePair.value); > + return firstKeyValuePairAppended.toString().utf8() < secondKeyValuePairAppended.toString().utf8(); 1) There is no reason to repeat this lambda twice! We can put it in a local variable and use it twice. Also, we repeat the comparison below, and should reuse for that too. 2) Concatenating strings using StringBuilder, then converting to UTF-8 is a super-expensive way to compare and makes this unnecessarily inefficient. Seems unlikely the sorting order matters at all: Code should be more like this: auto compare = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { if (int result = codePointCompare(a.key, b.key)) return result; return codePointCompare(a.value, b.value); }; auto comparesLessThan = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { return compare(a, b) < 0; }; std::sort(firstQueryParameters.begin(), firstQueryParameters.end(), comparesLessThan); std::sort(secondQueryParameters.begin(), secondQueryParameters.end(), comparesLessThan); > Source/WTF/wtf/URL.cpp:1219 > + if (tempParameterFromFirst.toString().utf8() < tempParameterFromSecond.toString().utf8()) { > + differingQueryParameters.append(firstQueryParameters[indexInFirstQueryParameter]); > + indexInFirstQueryParameter++; > + } else if (tempParameterFromSecond.toString().utf8() < tempParameterFromFirst.toString().utf8()) { > + differingQueryParameters.append(secondQueryParameters[indexInSecondQueryParameter]); > + indexInSecondQueryParameter++; > + } else { > + indexInFirstQueryParameter++; > + indexInSecondQueryParameter++; > + } Same issue here, should not be building temporary strings and converting to UTF-8 just compare. Also, since it’s important to use the same comparison function so we do it consistently, this makes the refactoring above more valuable. int comparison = compare(firstQueryParameters[indexInFirstQueryParameter], secondQueryParameters[indexInSecondQueryParameter]); if (comparison < 0) { ... } else if (comparison > 0) { ... } else { ... } > Source/WTF/wtf/URL.cpp:1240 > + return url.string()[url.pathEnd() - 1] == '/' ? url.pathEnd() - 1 : url.pathEnd(); I don’t understand why this "/" removal is needed. Which test case falls if we remove this logic? > Source/WTF/wtf/URL.cpp:1251 > +bool isEqualIgnoringQueryAndFragments(const URL& firstURL, const URL& secondURL) > +{ > + if (!firstURL.isValid() || !secondURL.isValid()) > + return false; > + > + auto lengthOfFirstURLIgnoringQueryAndFragments = lengthOfURLIgnoringQueryAndFragments(firstURL); > + auto secondLengthOfSecondURLIgnoringQueryAndFragments = lengthOfURLIgnoringQueryAndFragments(secondURL); > + return StringView(firstURL.string()).substring(0, lengthOfFirstURLIgnoringQueryAndFragments) == StringView(secondURL.string()).substring(0, secondLengthOfSecondURLIgnoringQueryAndFragments); > +} Seems a little peculiar that two invalid URLs always compare as unequal even if they are identical. Is that really the behavior we want? From a factoring point of view, one more function and shorter argument names can make this code much clearer and easier to read: static StringView substringIgnoringQueryAndFragments(const URL& url) { return StringView { url.string() }.left(lengthOfURLIgnoringQueryAndFragments(url)); } bool isEqualIgnoringQueryAndFragments(const URL& a, const URL& b) { return a.isValid() && b.isValid() && substringIgnoringQueryAndFragments(a) == substringIgnoringQueryAndFragments(b); } 1781323 25 434736 darin 2021-08-02 11:15:44 -0700 Comment on attachment 434736 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434736&action=review >> Source/WTF/wtf/URL.cpp:1189 >> + return firstKeyValuePairAppended.toString().utf8() < secondKeyValuePairAppended.toString().utf8(); > > 1) There is no reason to repeat this lambda twice! We can put it in a local variable and use it twice. Also, we repeat the comparison below, and should reuse for that too. > > 2) Concatenating strings using StringBuilder, then converting to UTF-8 is a super-expensive way to compare and makes this unnecessarily inefficient. Seems unlikely the sorting order matters at all: > > Code should be more like this: > > auto compare = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { > if (int result = codePointCompare(a.key, b.key)) > return result; > return codePointCompare(a.value, b.value); > }; > auto comparesLessThan = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { > return compare(a, b) < 0; > }; > > std::sort(firstQueryParameters.begin(), firstQueryParameters.end(), comparesLessThan); > std::sort(secondQueryParameters.begin(), secondQueryParameters.end(), comparesLessThan); By the way, the capture here is wrong. This would be better: auto compare = [] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { if (int result = codePointCompare(a.key, b.key)) return result; return codePointCompare(a.value, b.value); }; auto comparesLessThan = [] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { return compare(a, b) < 0; }; 1781497 26 434736 risul_islam 2021-08-02 18:23:04 -0700 Comment on attachment 434736 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434736&action=review >> Source/WTF/wtf/KeyValuePair.h:67 >> + } > > I’d like to see this be done as a free function, after the class definition: > > template<typename KeyType, typename ValueType> constexpr bool operator=(const KeyValuePair<KeyType, ValueType>& a, const KeyValuePair<KeyType, ValueType>& b) > { > return a.key == b.key && a.value == b.value; > } > > But also, this change is no longer needed in this patch. We aren’t using a KeyValuePair as a hash table key. Can we either not do this at all at this time, or do it in a separate patch? Thank you Darin for your valuable comments. All of your suggestions are great learning for me. I have removed the hash related codes. But removing this == operator overloading causes error in our test functions, specifically in EXPECT_EQ(differingQueryParameters(url1, url2), resultVector); Any workaround suggestion? >>> Source/WTF/wtf/URL.cpp:1189 >>> + return firstKeyValuePairAppended.toString().utf8() < secondKeyValuePairAppended.toString().utf8(); >> >> 1) There is no reason to repeat this lambda twice! We can put it in a local variable and use it twice. Also, we repeat the comparison below, and should reuse for that too. >> >> 2) Concatenating strings using StringBuilder, then converting to UTF-8 is a super-expensive way to compare and makes this unnecessarily inefficient. Seems unlikely the sorting order matters at all: >> >> Code should be more like this: >> >> auto compare = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { >> if (int result = codePointCompare(a.key, b.key)) >> return result; >> return codePointCompare(a.value, b.value); >> }; >> auto comparesLessThan = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { >> return compare(a, b) < 0; >> }; >> >> std::sort(firstQueryParameters.begin(), firstQueryParameters.end(), comparesLessThan); >> std::sort(secondQueryParameters.begin(), secondQueryParameters.end(), comparesLessThan); > > By the way, the capture here is wrong. This would be better: > > auto compare = [] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) > { > if (int result = codePointCompare(a.key, b.key)) > return result; > return codePointCompare(a.value, b.value); > }; > auto comparesLessThan = [] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) > { > return compare(a, b) < 0; > }; Wow, elegant code. >> Source/WTF/wtf/URL.cpp:1219 >> + } > > Same issue here, should not be building temporary strings and converting to UTF-8 just compare. Also, since it’s important to use the same comparison function so we do it consistently, this makes the refactoring above more valuable. > > int comparison = compare(firstQueryParameters[indexInFirstQueryParameter], secondQueryParameters[indexInSecondQueryParameter]); > if (comparison < 0) { > ... > } else if (comparison > 0) { > ... > } else { > ... > } Great idea. Code reuse at its best. >> Source/WTF/wtf/URL.cpp:1240 >> + return url.string()[url.pathEnd() - 1] == '/' ? url.pathEnd() - 1 : url.pathEnd(); > > I don’t understand why this "/" removal is needed. Which test case falls if we remove this logic? Thank you and Alex for this suggestion. Canonicalization removes the requirement of this log. Discarding it. >> Source/WTF/wtf/URL.cpp:1251 >> +} > > Seems a little peculiar that two invalid URLs always compare as unequal even if they are identical. Is that really the behavior we want? > > From a factoring point of view, one more function and shorter argument names can make this code much clearer and easier to read: > > static StringView substringIgnoringQueryAndFragments(const URL& url) > { > return StringView { url.string() }.left(lengthOfURLIgnoringQueryAndFragments(url)); > } > > bool isEqualIgnoringQueryAndFragments(const URL& a, const URL& b) > { > return a.isValid() && b.isValid() && substringIgnoringQueryAndFragments(a) == substringIgnoringQueryAndFragments(b); > } Done. 1781499 27 434736 risul_islam 2021-08-02 18:29:45 -0700 Comment on attachment 434736 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434736&action=review >>>> Source/WTF/wtf/URL.cpp:1189 >>>> + return firstKeyValuePairAppended.toString().utf8() < secondKeyValuePairAppended.toString().utf8(); >>> >>> 1) There is no reason to repeat this lambda twice! We can put it in a local variable and use it twice. Also, we repeat the comparison below, and should reuse for that too. >>> >>> 2) Concatenating strings using StringBuilder, then converting to UTF-8 is a super-expensive way to compare and makes this unnecessarily inefficient. Seems unlikely the sorting order matters at all: >>> >>> Code should be more like this: >>> >>> auto compare = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { >>> if (int result = codePointCompare(a.key, b.key)) >>> return result; >>> return codePointCompare(a.value, b.value); >>> }; >>> auto comparesLessThan = [&] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { >>> return compare(a, b) < 0; >>> }; >>> >>> std::sort(firstQueryParameters.begin(), firstQueryParameters.end(), comparesLessThan); >>> std::sort(secondQueryParameters.begin(), secondQueryParameters.end(), comparesLessThan); >> >> By the way, the capture here is wrong. This would be better: >> >> auto compare = [] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) >> { >> if (int result = codePointCompare(a.key, b.key)) >> return result; >> return codePointCompare(a.value, b.value); >> }; >> auto comparesLessThan = [] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) >> { >> return compare(a, b) < 0; >> }; > > Wow, elegant code. One issue found here. Had to write comparesLessThan like this: auto comparesLessThan = [&compare] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { return compare(a, b) < 0; }; Otherwise, it does not recognize 'compare'. 1781656 28 434736 risul_islam 2021-08-03 11:11:02 -0700 Comment on attachment 434736 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434736&action=review >>> Source/WTF/wtf/KeyValuePair.h:67 >>> + } >> >> I’d like to see this be done as a free function, after the class definition: >> >> template<typename KeyType, typename ValueType> constexpr bool operator=(const KeyValuePair<KeyType, ValueType>& a, const KeyValuePair<KeyType, ValueType>& b) >> { >> return a.key == b.key && a.value == b.value; >> } >> >> But also, this change is no longer needed in this patch. We aren’t using a KeyValuePair as a hash table key. Can we either not do this at all at this time, or do it in a separate patch? > > Thank you Darin for your valuable comments. All of your suggestions are great learning for me. > I have removed the hash related codes. But removing this == operator overloading causes error in our test functions, specifically in EXPECT_EQ(differingQueryParameters(url1, url2), resultVector); > Any workaround suggestion? Making the == operator a free function was a great idea. We do need this function for the purpose of testability of differingQueryParameters(url, url) function. I am submitting the new patch with it. If we find any workaround, we may discard the == operator overloaded function quickly. >>> Source/WTF/wtf/URL.cpp:1240 >>> + return url.string()[url.pathEnd() - 1] == '/' ? url.pathEnd() - 1 : url.pathEnd(); >> >> I don’t understand why this "/" removal is needed. Which test case falls if we remove this logic? > > Thank you and Alex for this suggestion. Canonicalization removes the requirement of this log. Discarding it. Thank you and Alex for this suggestion. Canonicalization removes the requirement of this *logic. Discarded it. 1781691 29 434848 risul_islam 2021-08-03 12:05:46 -0700 Created attachment 434848 Patch 1781717 30 434848 darin 2021-08-03 13:08:29 -0700 Comment on attachment 434848 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434848&action=review This seems good, but there is still room for improvement. > Source/WTF/ChangeLog:3 > + Add functionalities for parsing URL query string I think we can call these "functions"; don’t need to say "functionalities". > Source/WTF/wtf/URL.cpp:1173 > + if (!firstURL.isValid() || !secondURL.isValid()) > + return { }; Not 100% sure this is the best behavior if only one of the URLs is invalid. Depends on how we intend to use these functions. Tests should cover this behavior. > Source/WTF/wtf/URL.cpp:1190 > + auto comparesLessThan = [&compare] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { I suspect just [compare] would be fine, don’t necessarily need [&compare]. > Source/WTF/wtf/URL.cpp:1236 > +static StringView substringIgnoringQueryAndFragments(const URL& url) > +{ > + return StringView(url.string()).left(url.pathEnd()); > +} > + > +bool isEqualIgnoringQueryAndFragments(const URL& a, const URL& b) > +{ > + return a.isValid() && b.isValid() && substringIgnoringQueryAndFragments(a) == substringIgnoringQueryAndFragments(b); > +} This comment of mine may have been lost in the shuffle, I did not see a response: Why do we want to always return false if one of the two URLs is invalid? That means that an invalid URL would compare as not equal to itself. Is that the best behavior for this function? Maybe if one of the URLs is invalid we should simply compare the two strings, not ignoring anything? If so, we could implement that behavior by altering substringIgnoringQueryAndFragments to return the entire string when the URL is invalid. It’s hard to judge something like this when we are just adding a function without adding any uses of it. And I don’t see test cases that cover this behavior; we need to test such edge cases. > Source/WTF/wtf/URL.cpp:1243 > + auto queryParametersList = URLParser::parseURLEncodedForm(url.query()); This local variable is not needed. Could put this expression inside the for loop. for (auto& parameter : URLParser::parseURLEncodedForm(url.query())) { ... } > Source/WTF/wtf/URL.cpp:1245 > + for (auto& singleQueryParameter : queryParametersList) { Given the context, I think this could be called parameter instead of having a 3-word name. > Source/WTF/wtf/URL.cpp:1250 > + if (!queryWithoutRemovalKeys.isEmpty()) > + queryWithoutRemovalKeys.append('&', singleQueryParameter.key, '=', singleQueryParameter.value); > + else > + queryWithoutRemovalKeys.append(singleQueryParameter.key, '=', singleQueryParameter.value); Another way to write this: queryWithoutRemovalKeys.append(queryWithoutRemovalKeys.isEmpty() ? "" : "&", singleQueryParameter.key, '=', singleQueryParameter.value); Or: auto separator = queryWithoutRemovalKeys.isEmpty() ? "" : "&"; queryWithoutRemovalKeys.append(separator singleQueryParameter.key, '=', singleQueryParameter.value); Not sure that either of my ways are better, but they are less repetitive. > Source/WTF/wtf/URL.cpp:1254 > + url.setQuery(queryWithoutRemovalKeys); I am surprised this compiles. I would have thought we’d have to call one of the toString functions on the StringBuilder. > Tools/TestWebKitAPI/Tests/WTF/URL.cpp:362 > +TEST_F(WTF_URL, URLDifferingQueryParameters) I don’t think we have enough test cases. For example, all the keys are sorted in our tests; we aren’t testing the cases where the order isn’t right. So if our sort algorithm was broken we’d never know. 1781718 31 434848 darin 2021-08-03 13:11:49 -0700 Comment on attachment 434848 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434848&action=review >> Source/WTF/wtf/URL.cpp:1254 >> + url.setQuery(queryWithoutRemovalKeys); > > I am surprised this compiles. I would have thought we’d have to call one of the toString functions on the StringBuilder. I guess setQuery takes a StringView and StringBuilder can produce one of those without a function call, so: great, looks good. 1781719 32 434848 achristensen 2021-08-03 13:17:24 -0700 Comment on attachment 434848 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434848&action=review >> Source/WTF/wtf/URL.cpp:1173 >> + return { }; > > Not 100% sure this is the best behavior if only one of the URLs is invalid. Depends on how we intend to use these functions. > > Tests should cover this behavior. I think invalid URLs' queries are empty StringViews, so this is just a performance optimization which is probably unnecessary. >> Source/WTF/wtf/URL.cpp:1190 >> + auto comparesLessThan = [&compare] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { > > I suspect just [compare] would be fine, don’t necessarily need [&compare]. or [&] 1781732 33 434848 risul_islam 2021-08-03 13:48:51 -0700 Comment on attachment 434848 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434848&action=review >> Source/WTF/ChangeLog:3 >> + Add functionalities for parsing URL query string > > I think we can call these "functions"; don’t need to say "functionalities". On it. >> Source/WTF/wtf/URL.cpp:1173 >> + return { }; > > Not 100% sure this is the best behavior if only one of the URLs is invalid. Depends on how we intend to use these functions. > > Tests should cover this behavior. Earlier we returned optional null if any of the url is null. Following recommendation, we changed that to returning empty vector. URL url1 = createURL("www.webkit.org/?"); URL url2 = createURL("http://www.webkit.org/?key1=val1"); Vector<KeyValuePair<String, String>> testVector { }; EXPECT_EQ(differingQueryParameters(url1, url2), testVector); This test is covering that behavior. We can add more. >> Source/WTF/wtf/URL.cpp:1190 >> + auto comparesLessThan = [&compare] (const KeyValuePair<String, String>& a, const KeyValuePair<String, String>& b) { > > I suspect just [compare] would be fine, don’t necessarily need [&compare]. on it. >> Source/WTF/wtf/URL.cpp:1236 >> +} > > This comment of mine may have been lost in the shuffle, I did not see a response: > > Why do we want to always return false if one of the two URLs is invalid? > > That means that an invalid URL would compare as not equal to itself. Is that the best behavior for this function? Maybe if one of the URLs is invalid we should simply compare the two strings, not ignoring anything? If so, we could implement that behavior by altering substringIgnoringQueryAndFragments to return the entire string when the URL is invalid. > > It’s hard to judge something like this when we are just adding a function without adding any uses of it. > > And I don’t see test cases that cover this behavior; we need to test such edge cases. good idea, on it. Sorry, the comment got skipped in shuffling. >> Source/WTF/wtf/URL.cpp:1243 >> + auto queryParametersList = URLParser::parseURLEncodedForm(url.query()); > > This local variable is not needed. Could put this expression inside the for loop. > > for (auto& parameter : URLParser::parseURLEncodedForm(url.query())) { > ... > } on it. >> Source/WTF/wtf/URL.cpp:1245 >> + for (auto& singleQueryParameter : queryParametersList) { > > Given the context, I think this could be called parameter instead of having a 3-word name. sure. on it. >> Source/WTF/wtf/URL.cpp:1250 >> + queryWithoutRemovalKeys.append(singleQueryParameter.key, '=', singleQueryParameter.value); > > Another way to write this: > > queryWithoutRemovalKeys.append(queryWithoutRemovalKeys.isEmpty() ? "" : "&", singleQueryParameter.key, '=', singleQueryParameter.value); > > Or: > > auto separator = queryWithoutRemovalKeys.isEmpty() ? "" : "&"; > queryWithoutRemovalKeys.append(separator singleQueryParameter.key, '=', singleQueryParameter.value); > > Not sure that either of my ways are better, but they are less repetitive. on it. >> Source/WTF/wtf/URL.cpp:1254 >> + url.setQuery(queryWithoutRemovalKeys); > > I am surprised this compiles. I would have thought we’d have to call one of the toString functions on the StringBuilder. Surprisingly, it complies (checked). >> Tools/TestWebKitAPI/Tests/WTF/URL.cpp:362 >> +TEST_F(WTF_URL, URLDifferingQueryParameters) > > I don’t think we have enough test cases. For example, all the keys are sorted in our tests; we aren’t testing the cases where the order isn’t right. So if our sort algorithm was broken we’d never know. great idea, on it. 1781734 34 434848 risul_islam 2021-08-03 14:03:48 -0700 Comment on attachment 434848 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434848&action=review >>>> Source/WTF/wtf/URL.cpp:1173 >>>> + return { }; >>> >>> Not 100% sure this is the best behavior if only one of the URLs is invalid. Depends on how we intend to use these functions. >>> >>> Tests should cover this behavior. >> >> I think invalid URLs' queries are empty StringViews, so this is just a performance optimization which is probably unnecessary. > > Earlier we returned optional null if any of the url is null. Following recommendation, we changed that to returning empty vector. > URL url1 = createURL("www.webkit.org/?"); > URL url2 = createURL("http://www.webkit.org/?key1=val1"); > Vector<KeyValuePair<String, String>> testVector { }; > EXPECT_EQ(differingQueryParameters(url1, url2), testVector); > > This test is covering that behavior. We can add more. Alex: if both urls are invalid, then the code will automatically return empty vector. Thats fine. But if one is invalid and other is not, then discarding the initial isValid() condition will cause returning the parameters of valid url. But we agreed to return empty vector if one of the url is invalid. Do you suggest that we should return the valid url's parameter if another is invalid? 1781739 35 434848 risul_islam 2021-08-03 14:27:13 -0700 Comment on attachment 434848 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434848&action=review >>>>> Source/WTF/wtf/URL.cpp:1173 >>>>> + return { }; >>>> >>>> Not 100% sure this is the best behavior if only one of the URLs is invalid. Depends on how we intend to use these functions. >>>> >>>> Tests should cover this behavior. >>> >>> I think invalid URLs' queries are empty StringViews, so this is just a performance optimization which is probably unnecessary. >> >> Earlier we returned optional null if any of the url is null. Following recommendation, we changed that to returning empty vector. >> URL url1 = createURL("www.webkit.org/?"); >> URL url2 = createURL("http://www.webkit.org/?key1=val1"); >> Vector<KeyValuePair<String, String>> testVector { }; >> EXPECT_EQ(differingQueryParameters(url1, url2), testVector); >> >> This test is covering that behavior. We can add more. > > Alex: if both urls are invalid, then the code will automatically return empty vector. Thats fine. But if one is invalid and other is not, then discarding the initial isValid() condition will cause returning the parameters of valid url. But we agreed to return empty vector if one of the url is invalid. Do you suggest that we should return the valid url's parameter if another is invalid? I think we can discard the validity check in this function and get the query parameter difference results ignoring the validity. This will give us the freedom to use the returned results as per our need when called. When calling this function, we can check the urls validity and take our decision based on our use case. 1781747 36 434862 risul_islam 2021-08-03 14:53:10 -0700 Created attachment 434862 Patch 1781760 37 434864 risul_islam 2021-08-03 15:23:21 -0700 Created attachment 434864 Patch 1781801 38 ews-feeder 2021-08-03 18:37:31 -0700 Committed r280626 (240239@main): <https://commits.webkit.org/240239@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 434864. 1781812 39 434864 achristensen 2021-08-03 20:13:19 -0700 Comment on attachment 434864 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=434864&action=review Some post-commit feedback: > Source/WTF/wtf/URL.cpp:1225 > +static StringView substringIgnoringQueryAndFragments(const URL& url) Could you move this to be a lambda inside isEqualIgnoringQueryAndFragments? It's only used in that scope. > Source/WTF/wtf/URL.h:248 > +WTF_EXPORT_PRIVATE bool isEqualIgnoringQueryAndFragments(const URL&, const URL&); I think this should either be renamed to areEqualIgnoringQueriesAndFragments or it should be made a member of the URL class. bool equalsIgnoringQueryAndFragment(const URL&) const; > Source/WTF/wtf/URL.h:249 > +WTF_EXPORT_PRIVATE void removeQueryParameters(URL&, const HashSet<String>&); Could you add another important test case to verify that we don't regress behavior in the future? Make a URL from "https://example.com/?%C3%A4=value" See how removing "%C3%A4" changes the URL. See how removing "ä" changes the URL. I think rather than passing a non-const URL as a parameter, this should be a member of the URL class. void removeQueryParametersWithKeys(const HashSet<String>& keys); 1786583 40 wilander 2021-08-23 15:19:15 -0700 (In reply to Alex Christensen from comment #39) > Comment on attachment 434864 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=434864&action=review > > Some post-commit feedback: > > > Source/WTF/wtf/URL.cpp:1225 > > +static StringView substringIgnoringQueryAndFragments(const URL& url) > > Could you move this to be a lambda inside isEqualIgnoringQueryAndFragments? > It's only used in that scope. > > > Source/WTF/wtf/URL.h:248 > > +WTF_EXPORT_PRIVATE bool isEqualIgnoringQueryAndFragments(const URL&, const URL&); > > I think this should either be renamed to areEqualIgnoringQueriesAndFragments > or it should be made a member of the URL class. > bool equalsIgnoringQueryAndFragment(const URL&) const; > > > Source/WTF/wtf/URL.h:249 > > +WTF_EXPORT_PRIVATE void removeQueryParameters(URL&, const HashSet<String>&); > > Could you add another important test case to verify that we don't regress > behavior in the future? > Make a URL from "https://example.com/?%C3%A4=value" > See how removing "%C3%A4" changes the URL. > See how removing "ä" changes the URL. > > I think rather than passing a non-const URL as a parameter, this should be a > member of the URL class. > void removeQueryParametersWithKeys(const HashSet<String>& keys); Could you file follow-up Bugzillas, please? I can do it too if you're short on time. I just don't want us to lose these valuable enhancements. 1786584 41 wilander 2021-08-23 15:19:56 -0700 (In reply to John Wilander from comment #40) > Could you file follow-up Bugzillas, please? I can do it too if you're short > on time. I just don't want us to lose these valuable enhancements. You can assign them to me. 1795987 42 annevk 2021-09-22 01:29:51 -0700 FWIW: removeQueryParameters looks buggy as instead of using a serializer for the resulting query you append the raw keys and values to a string. Meaning that %3D would become = and %26 becomes &, etc. unless I'm missing something. You probably want to use the internal equivalent of URLSearchParams instead. 1796078 43 wilander 2021-09-22 08:16:42 -0700 (In reply to Anne van Kesteren from comment #42) > FWIW: removeQueryParameters looks buggy as instead of using a serializer for > the resulting query you append the raw keys and values to a string. Meaning > that %3D would become = and %26 becomes &, etc. unless I'm missing > something. You probably want to use the internal equivalent of > URLSearchParams instead. Thank you, Anne! This needs a separate bug so I filed it here: https://bugs.webkit.org/show_bug.cgi?id=230628 434214 2021-07-26 10:40:20 -0700 2021-07-29 10:23:49 -0700 Patch bug-228122-20210726104019.patch text/plain 17732 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLjU1NTcxNGE3M2Y2MmIxOTZkODE2MDQzOGFjZmVhNWI1YmI2YzJj MDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMjEtMDctMjYgIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEV4cGFuZCBVUkwgY2xhc3MgcXVlcnkgcGFyYW1l dGVyIGZ1bmN0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAg ICAgIAorICAgICAgICBBZGRlZCBtb3JlIGZ1bmN0aW9uYWxpdGllcyBmb3IgcGFyc2luZyBVUkwg cXVlcnkgcGFyYW1ldGVycy4KKworICAgICAgICAqIHd0Zi9VUkwuY3BwOgorICAgICAgICAoV1RG OjpVUkw6OnF1ZXJ5UGFyYW1ldGVycyBjb25zdCk6CisgICAgICAgIChXVEY6OlVSTDo6ZGlmZmVy ZW5jZUluUXVlcnlQYXJhbWV0ZXJzIGNvbnN0KToKKyAgICAgICAgKFdURjo6VVJMOjppc0VxdWFs UXVlcnkgY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OmlzRXF1YWxJZ25vcmluZ1F1ZXJ5IGNv bnN0KToKKyAgICAgICAgKiB3dGYvVVJMLmg6CisgICAgICAgIChXVEY6OlVSTDo6UXVlcnlQYXJh bWV0ZXI6OlF1ZXJ5UGFyYW1ldGVyKToKKyAgICAgICAgKFdURjo6VVJMOjpRdWVyeVBhcmFtZXRl cjo6b3BlcmF0b3I9PSBjb25zdCk6CisgICAgICAgIChXVEY6OlVSTDo6UXVlcnlQYXJhbWV0ZXI6 Omhhc2ggY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OlF1ZXJ5UGFyYW1ldGVyOjppc0hhc2hU YWJsZURlbGV0ZWRWYWx1ZSBjb25zdCk6CisgICAgICAgIChXVEY6OlVSTDo6UXVlcnlQYXJhbWV0 ZXI6OmtleSBjb25zdCk6CisgICAgICAgIChXVEY6OlVSTDo6UXVlcnlQYXJhbWV0ZXI6OnZhbHVl IGNvbnN0KToKKyAgICAgICAgKFdURjo6VVJMOjpRdWVyeVBhcmFtZXRlcjo6c2V0S2V5KToKKyAg ICAgICAgKFdURjo6VVJMOjpRdWVyeVBhcmFtZXRlcjo6c2V0VmFsdWUpOgorICAgICAgICAoV1RG OjpVUkw6OlF1ZXJ5UGFyYW1ldGVySGFzaDo6aGFzaCk6CisgICAgICAgIChXVEY6OlVSTDo6UXVl cnlQYXJhbWV0ZXJIYXNoOjplcXVhbCk6CisKIDIwMjEtMDctMTYgIEFsZXhhbmRlciBNaWtoYXls ZW5rbyAgPGFsZXhtQGdub21lLm9yZz4KIAogICAgICAgICBbR1RLXVtXUEVdIFN1cHBvcnQgY29s b3Itc2NoZW1lcyBDU1MgcHJvcGVydHkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5j cHAgYi9Tb3VyY2UvV1RGL3d0Zi9VUkwuY3BwCmluZGV4IGQ5YzA4MmNlYzY5YTVkODQ4ZDAzZDE2 ZTA4OTRhOGNiNzJhNWE1ZGIuLjZiM2FjMTQ1ZmIzYzRmMTllZGMxMDIxZjQ4NTBkODlmYzJhZDc3 MWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAKKysrIGIvU291cmNlL1dURi93 dGYvVVJMLmNwcApAQCAtMTE2Niw0ICsxMTY2LDExMCBAQCBib29sIFVSTDo6aG9zdElzSVBBZGRy ZXNzKFN0cmluZ1ZpZXcgaG9zdCkKIAogI2VuZGlmCiAKK3N0ZDo6b3B0aW9uYWw8VmVjdG9yPFVS TDo6UXVlcnlQYXJhbWV0ZXI+PiBVUkw6OnF1ZXJ5UGFyYW1ldGVycygpIGNvbnN0Cit7CisgICAg Ly8gQXNzdW1wdGlvbiAxOiBQYXJhbWV0ZXJzIGFyZSBzZXBlcmF0ZWQgYnkgJyYnIGFsdGhvdWdo ICc7JyBpcyBhbHNvIHBvc3NpYmxlIGFuZCAnOycgaXMgbm90IGhhbmRsZWQgaGVyZS4KKyAgICBW ZWN0b3I8UXVlcnlQYXJhbWV0ZXI+IHF1ZXJ5UGFyYW1ldGVyc0tleVZhbHVlczsKKyAgICBpZiAo IW1faXNWYWxpZCkKKyAgICAgICAgcmV0dXJuIHN0ZDo6bnVsbG9wdDsKKworICAgIFN0cmluZyBx dWVyeVBhcnQgPSBtX3F1ZXJ5RW5kID09IG1fcGF0aEVuZCA/ICIiIDogbV9zdHJpbmcuc3Vic3Ry aW5nKG1fcGF0aEVuZCArIDEsIG1fcXVlcnlFbmQgLSAobV9wYXRoRW5kICsgMSkpOworICAgIGlm ICghcXVlcnlQYXJ0Lmxlbmd0aCgpKQorICAgICAgICByZXR1cm4gcXVlcnlQYXJhbWV0ZXJzS2V5 VmFsdWVzOworCisgICAgZm9yIChTdHJpbmcga2V5VmFsdWVQYWlyIDogcXVlcnlQYXJ0LnNwbGl0 QWxsb3dpbmdFbXB0eUVudHJpZXMoJyYnKSkgeworICAgICAgICBpZiAoa2V5VmFsdWVQYWlyLmxl bmd0aCgpKSB7CisgICAgICAgICAgICBRdWVyeVBhcmFtZXRlciB0ZW1wS2V5VmFsdWVzOworICAg ICAgICAgICAgaWYgKCFrZXlWYWx1ZVBhaXIuY29udGFpbnMoJz0nKSkgeworICAgICAgICAgICAg ICAgIHRlbXBLZXlWYWx1ZXMuc2V0S2V5KGtleVZhbHVlUGFpcik7CisgICAgICAgICAgICAgICAg dGVtcEtleVZhbHVlcy5zZXRWYWx1ZSgiIik7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgICAgIHVuc2lnbmVkIGluZGV4T2ZFcXVhbCA9IGtleVZhbHVlUGFpci5maW5kKCc9Jyk7 CisgICAgICAgICAgICAgICAgdGVtcEtleVZhbHVlcy5zZXRLZXkoa2V5VmFsdWVQYWlyLnN1YnN0 cmluZygwLCBpbmRleE9mRXF1YWwpKTsKKyAgICAgICAgICAgICAgICB0ZW1wS2V5VmFsdWVzLnNl dFZhbHVlKGtleVZhbHVlUGFpci5zdWJzdHJpbmcoaW5kZXhPZkVxdWFsKzEpKTsKKyAgICAgICAg ICAgIH0KKworICAgICAgICAgICAgcXVlcnlQYXJhbWV0ZXJzS2V5VmFsdWVzLmFwcGVuZCh0ZW1w S2V5VmFsdWVzKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICByZXR1cm4gcXVlcnlQYXJh bWV0ZXJzS2V5VmFsdWVzOworfQorCitzdGQ6Om9wdGlvbmFsPFZlY3RvcjxVUkw6OlF1ZXJ5UGFy YW1ldGVyPj4gVVJMOjpkaWZmZXJlbmNlSW5RdWVyeVBhcmFtZXRlcnMoVVJMIG1hdGNoaW5nVVJM KSBjb25zdAoreworICAgIGlmICghbV9pc1ZhbGlkIHx8ICFtYXRjaGluZ1VSTC5tX2lzVmFsaWQp CisgICAgICAgIHJldHVybiBzdGQ6Om51bGxvcHQ7CisgICAgCisgICAgc3RkOjpvcHRpb25hbDxW ZWN0b3I8UXVlcnlQYXJhbWV0ZXI+PiB0aGlzUXVlcnlQYXJhbWV0ZXJzID0gcXVlcnlQYXJhbWV0 ZXJzKCk7CisgICAgc3RkOjpvcHRpb25hbDxWZWN0b3I8UXVlcnlQYXJhbWV0ZXI+PiBtYXRjaGlu Z1F1ZXJ5UGFyYW1ldGVycyA9IG1hdGNoaW5nVVJMLnF1ZXJ5UGFyYW1ldGVycygpOworICAgIAor ICAgIGlmICghdGhpc1F1ZXJ5UGFyYW1ldGVycyB8fCAhbWF0Y2hpbmdRdWVyeVBhcmFtZXRlcnMp CisgICAgICAgIHJldHVybiBzdGQ6Om51bGxvcHQ7CisgICAgCisgICAgVmVjdG9yPFF1ZXJ5UGFy YW1ldGVyPiBkaWZmUmVzdWx0OworICAgIGlmICghdGhpc1F1ZXJ5UGFyYW1ldGVycy52YWx1ZSgp LnNpemUoKSAmJiAhbWF0Y2hpbmdRdWVyeVBhcmFtZXRlcnMudmFsdWUoKS5zaXplKCkpCisgICAg ICAgIHJldHVybiBkaWZmUmVzdWx0OworICAgIAorICAgIGlmICghdGhpc1F1ZXJ5UGFyYW1ldGVy cy52YWx1ZSgpLnNpemUoKSkKKyAgICAgICAgcmV0dXJuIG1hdGNoaW5nUXVlcnlQYXJhbWV0ZXJz OworICAgIAorICAgIGlmICghbWF0Y2hpbmdRdWVyeVBhcmFtZXRlcnMudmFsdWUoKS5zaXplKCkp CisgICAgICAgIHJldHVybiB0aGlzUXVlcnlQYXJhbWV0ZXJzOworICAgIAorICAgIEhhc2hNYXA8 VVJMOjpRdWVyeVBhcmFtZXRlciwgaW50PiBmcmVxdWVuY3lPZlBhcmFtZXRlcnM7CisgICAgZm9y IChRdWVyeVBhcmFtZXRlciBrZXlWYWx1ZSA6IHRoaXNRdWVyeVBhcmFtZXRlcnMudmFsdWUoKSkg eworICAgICAgICBpZiAoIWZyZXF1ZW5jeU9mUGFyYW1ldGVycy5jb250YWlucyhrZXlWYWx1ZSkp CisgICAgICAgICAgICBmcmVxdWVuY3lPZlBhcmFtZXRlcnMuYWRkKGtleVZhbHVlLCAxKTsKKyAg ICAgICAgZWxzZQorICAgICAgICAgICAgZnJlcXVlbmN5T2ZQYXJhbWV0ZXJzLnNldChrZXlWYWx1 ZSwgZnJlcXVlbmN5T2ZQYXJhbWV0ZXJzLmdldChrZXlWYWx1ZSkgKyAxKTsKKyAgICB9CisgICAg CisgICAgZm9yIChRdWVyeVBhcmFtZXRlciBrZXlWYWx1ZSA6IG1hdGNoaW5nUXVlcnlQYXJhbWV0 ZXJzLnZhbHVlKCkpIHsKKyAgICAgICAgaWYgKGZyZXF1ZW5jeU9mUGFyYW1ldGVycy5maW5kKGtl eVZhbHVlKSA9PSBmcmVxdWVuY3lPZlBhcmFtZXRlcnMuZW5kKCkpCisgICAgICAgICAgICBkaWZm UmVzdWx0LmFwcGVuZChrZXlWYWx1ZSk7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgaWYg KCFmcmVxdWVuY3lPZlBhcmFtZXRlcnMuZ2V0KGtleVZhbHVlKSkKKyAgICAgICAgICAgICAgICBk aWZmUmVzdWx0LmFwcGVuZChrZXlWYWx1ZSk7CisgICAgICAgICAgICAKKyAgICAgICAgICAgIGZy ZXF1ZW5jeU9mUGFyYW1ldGVycy5zZXQoa2V5VmFsdWUsIGZyZXF1ZW5jeU9mUGFyYW1ldGVycy5n ZXQoa2V5VmFsdWUpIC0gMSk7CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAgZm9yIChRdWVy eVBhcmFtZXRlciBrZXl2YWx1ZSA6IGZyZXF1ZW5jeU9mUGFyYW1ldGVycy5rZXlzKCkpIHsKKyAg ICAgICAgaWYgKGZyZXF1ZW5jeU9mUGFyYW1ldGVycy5nZXQoa2V5dmFsdWUpID4gMCkgeworICAg ICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBmcmVxdWVuY3lPZlBhcmFtZXRlcnMuZ2V0KGtl eXZhbHVlKTsgaSsrKQorICAgICAgICAgICAgICAgIGRpZmZSZXN1bHQuYXBwZW5kKGtleXZhbHVl KTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICByZXR1cm4gZGlmZlJlc3VsdDsKK30KKwor c3RkOjpvcHRpb25hbDxib29sPiBVUkw6OmlzRXF1YWxRdWVyeShVUkwgbWF0Y2hpbmdVUkwpIGNv bnN0Cit7CisgICAgaWYgKCFtX2lzVmFsaWQgfHwgIW1hdGNoaW5nVVJMLm1faXNWYWxpZCkKKyAg ICAgICAgcmV0dXJuIHN0ZDo6bnVsbG9wdDsKKyAgICAKKyAgICBzdGQ6Om9wdGlvbmFsPFZlY3Rv cjxRdWVyeVBhcmFtZXRlcj4+IGRpZmZlcmVuY2UgPSBkaWZmZXJlbmNlSW5RdWVyeVBhcmFtZXRl cnMobWF0Y2hpbmdVUkwpOworICAgIGlmICghZGlmZmVyZW5jZS52YWx1ZSgpLnNpemUoKSkKKyAg ICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAKK30K Kworc3RkOjpvcHRpb25hbDxib29sPiBVUkw6OmlzRXF1YWxJZ25vcmluZ1F1ZXJ5KFVSTCBtYXRj aGluZ1VSTCkgY29uc3QKK3sKKyAgICBpZiAoIW1faXNWYWxpZCB8fCAhbWF0Y2hpbmdVUkwubV9p c1ZhbGlkKQorICAgICAgICByZXR1cm4gc3RkOjpudWxsb3B0OworICAgIAorICAgIHVuc2lnbmVk IHRoaXNQYXRoTGVuZ3RoID0gbV9zdHJpbmdbbV9wYXRoRW5kLTFdID09ICcvJyA/IG1fcGF0aEVu ZC0xIDogbV9wYXRoRW5kOworICAgIHVuc2lnbmVkIG1hdGNoaW5nUGF0aExlbmd0aCA9IG1hdGNo aW5nVVJMLm1fc3RyaW5nW21hdGNoaW5nVVJMLm1fcGF0aEVuZC0xXSA9PSAnLycgPyAgbWF0Y2hp bmdVUkwubV9wYXRoRW5kLTEgOiBtYXRjaGluZ1VSTC5tX3BhdGhFbmQ7CisgICAgU3RyaW5nIHRo aXNVUkxXaXRob3V0UXVlcnkgPSBtX3N0cmluZy5zdWJzdHJpbmcoMCwgdGhpc1BhdGhMZW5ndGgp OworICAgIFN0cmluZyBtYXRjaGluZ1VSTFdpdGhvdXRRdWVyeSA9IG1hdGNoaW5nVVJMLm1fc3Ry aW5nLnN1YnN0cmluZygwLCBtYXRjaGluZ1BhdGhMZW5ndGgpOworICAgIAorICAgIHJldHVybiB0 aGlzVVJMV2l0aG91dFF1ZXJ5ID09IG1hdGNoaW5nVVJMV2l0aG91dFF1ZXJ5OworfQorCiB9IC8v IG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5oIGIvU291cmNl L1dURi93dGYvVVJMLmgKaW5kZXggZjQ0NTQyMWUxZmUyM2NhYmI2MTU3ZjcwZDljNDQ2YTI4NmM1 ZjA1Ni4uOWZmZjM3NzA5OGUxNjc0NGU3NThkOTI0ZTA0NzlkMmRhMDBhYmUxZiAxMDA2NDQKLS0t IGEvU291cmNlL1dURi93dGYvVVJMLmgKKysrIGIvU291cmNlL1dURi93dGYvVVJMLmgKQEAgLTU2 LDYgKzU2LDMxIEBAIHByb3RlY3RlZDoKIGNsYXNzIFVSTCB7CiAgICAgV1RGX01BS0VfRkFTVF9B TExPQ0FURUQ7CiBwdWJsaWM6CisgICAgY2xhc3MgUXVlcnlQYXJhbWV0ZXIgeworICAgIHByaXZh dGU6CisgICAgICAgIFN0cmluZyBtX2tleTsKKyAgICAgICAgU3RyaW5nIG1fdmFsdWU7CisgICAg cHVibGljOgorICAgICAgICBRdWVyeVBhcmFtZXRlcigpID0gZGVmYXVsdDsKKyAgICAgICAgUXVl cnlQYXJhbWV0ZXIoY29uc3QgU3RyaW5nJiBrZXkgLCBjb25zdCBTdHJpbmcmIHZhbCkgeyBtX2tl eSA9IGtleTsgbV92YWx1ZSA9IHZhbDsgfQorICAgICAgICBRdWVyeVBhcmFtZXRlcihXVEY6Okhh c2hUYWJsZURlbGV0ZWRWYWx1ZVR5cGUpCisgICAgICAgIDogbV9rZXkoV1RGOjpIYXNoVGFibGVE ZWxldGVkVmFsdWUpLCBtX3ZhbHVlKFdURjo6SGFzaFRhYmxlRGVsZXRlZFZhbHVlKSB7IH0KKyAg ICAgICAgCisgICAgICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBRdWVyeVBhcmFtZXRlciAmb3Ro ZXIpIGNvbnN0IHsgcmV0dXJuIG1fa2V5ID09IG90aGVyLm1fa2V5ICYmIG1fdmFsdWUgPT0gb3Ro ZXIubV92YWx1ZTsgfQorICAgICAgICB1bnNpZ25lZCBoYXNoKCkgY29uc3QgeyByZXR1cm4gbV9r ZXkuaGFzaCgpICsgbV92YWx1ZS5oYXNoKCk7IH0KKyAgICAgICAgYm9vbCBpc0hhc2hUYWJsZURl bGV0ZWRWYWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fa2V5LmlzSGFzaFRhYmxlRGVsZXRlZFZhbHVl KCk7IH0KKyAgICAgICAgCisgICAgICAgIGNvbnN0IFN0cmluZyYga2V5KCkgY29uc3QgeyByZXR1 cm4gbV9rZXk7IH0KKyAgICAgICAgY29uc3QgU3RyaW5nJiB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJu IG1fdmFsdWU7IH0KKyAgICAgICAgdm9pZCBzZXRLZXkoU3RyaW5nIGtleSkgeyBtX2tleSA9IGtl eTsgfQorICAgICAgICB2b2lkIHNldFZhbHVlKFN0cmluZyB2YWx1ZSkgeyBtX3ZhbHVlID0gdmFs dWU7IH0KKyAgICB9OworICAgIHN0cnVjdCBRdWVyeVBhcmFtZXRlckhhc2ggeworICAgICAgICBz dGF0aWMgdW5zaWduZWQgaGFzaChjb25zdCBRdWVyeVBhcmFtZXRlciYgcXBhcmFtZXRlcikgeyBy ZXR1cm4gcXBhcmFtZXRlci5oYXNoKCk7IH0KKyAgICAgICAgc3RhdGljIGJvb2wgZXF1YWwoY29u c3QgUXVlcnlQYXJhbWV0ZXImIGEsIGNvbnN0IFF1ZXJ5UGFyYW1ldGVyJiBiKSB7IHJldHVybiBh ID09IGI7IH0KKyAgICAgICAgc3RhdGljIGNvbnN0ZXhwciBib29sIHNhZmVUb0NvbXBhcmVUb0Vt cHR5T3JEZWxldGVkID0gZmFsc2U7CisgICAgfTsKKyAgICAKICAgICAvLyBHZW5lcmF0ZXMgYSBV Ukwgd2hpY2ggY29udGFpbnMgYSBudWxsIHN0cmluZy4KICAgICBVUkwoKSB7IGludmFsaWRhdGUo KTsgfQogCkBAIC0yMDAsNiArMjI1LDExIEBAIHB1YmxpYzoKICAgICB0ZW1wbGF0ZTx0eXBlbmFt ZSBEZWNvZGVyPiBzdGF0aWMgc3RkOjpvcHRpb25hbDxVUkw+IGRlY29kZShEZWNvZGVyJik7CiAK ICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBoYXNTcGVjaWFsU2NoZW1lKCkgY29uc3Q7Cisg ICAgCisgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0ZDo6b3B0aW9uYWw8VmVjdG9yPFF1ZXJ5UGFy YW1ldGVyPj4gcXVlcnlQYXJhbWV0ZXJzKCkgY29uc3Q7CisgICAgV1RGX0VYUE9SVF9QUklWQVRF IHN0ZDo6b3B0aW9uYWw8VmVjdG9yPFF1ZXJ5UGFyYW1ldGVyPj4gZGlmZmVyZW5jZUluUXVlcnlQ YXJhbWV0ZXJzKFVSTCkgY29uc3Q7CisgICAgV1RGX0VYUE9SVF9QUklWQVRFIHN0ZDo6b3B0aW9u YWw8Ym9vbD4gaXNFcXVhbElnbm9yaW5nUXVlcnkoVVJMKSBjb25zdDsKKyAgICBXVEZfRVhQT1JU X1BSSVZBVEUgc3RkOjpvcHRpb25hbDxib29sPiBpc0VxdWFsUXVlcnkoVVJMKSBjb25zdDsKIAog cHJpdmF0ZToKICAgICBmcmllbmQgY2xhc3MgVVJMUGFyc2VyOwpAQCAtMjMzLDYgKzI2MywxMSBA QCBwcml2YXRlOgogICAgIHVuc2lnbmVkIG1fcXVlcnlFbmQ7CiB9OwogCit0ZW1wbGF0ZTx0eXBl bmFtZSBUPiBzdHJ1Y3QgRGVmYXVsdEhhc2g7Cit0ZW1wbGF0ZTw+IHN0cnVjdCBEZWZhdWx0SGFz aDxVUkw6OlF1ZXJ5UGFyYW1ldGVyPiA6IFVSTDo6UXVlcnlQYXJhbWV0ZXJIYXNoIHsgfTsKK3Rl bXBsYXRlPHR5cGVuYW1lIFQ+IHN0cnVjdCBIYXNoVHJhaXRzOwordGVtcGxhdGU8PiBzdHJ1Y3Qg SGFzaFRyYWl0czxVUkw6OlF1ZXJ5UGFyYW1ldGVyPiA6IHB1YmxpYyBTaW1wbGVDbGFzc0hhc2hU cmFpdHM8VVJMOjpRdWVyeVBhcmFtZXRlcj4geyB9OworCiBzdGF0aWNfYXNzZXJ0KHNpemVvZihV UkwpID09IHNpemVvZihTdHJpbmcpICsgOCAqIHNpemVvZih1bnNpZ25lZCksICJVUkwgc2hvdWxk IHN0YXkgc21hbGwiKTsKIAogYm9vbCBvcGVyYXRvcj09KGNvbnN0IFVSTCYsIGNvbnN0IFVSTCYp OwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGE2 NmEyNGZlNDc5ZjFlOTQyN2Y3OWQyNzdiZDE0ZWU4OTBlN2ZiM2MuLjI2ZmMwYTY0MThjYmY1N2Vj M2NmY2YwZjBkZTlhZDVhOWEyNDYxODMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysg Yi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMS0wNy0yNiAgUmlzdWwgSXNs YW0gIDxyaXN1bF9pc2xhbUBhcHBsZS5jb20+CisKKyAgICAgICAgRXhwYW5kIFVSTCBjbGFzcyBx dWVyeSBwYXJhbWV0ZXIgZnVuY3Rpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMjgxMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKyAgICAgICAgCisgICAgICAgIEFkZGVkIHRoZSB0ZXN0IGZ1bmN0aW9ucyByZXF1aXJl ZCBmb3IgVVJMIHF1ZXJ5IHBhcmFtZXRlciBwYXJ0IHBhcnNpbmcuCisKKyAgICAgICAgKiBUZXN0 V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVT VF9GKToKKwogMjAyMS0wNy0xOSAgUnlhbiBIYWRkYWQgIDxyeWFuaGFkZGFkQGFwcGxlLmNvbT4K IAogICAgICAgICBbYnVpbGQud2Via2l0Lm9yZ10gbGxkYi13ZWJraXQtdGVzdCBpcyBmYWlsaW5n IG9uIENhdGFsaW5hIHF1ZXVlcwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XVEYvVVJMLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHAKaW5k ZXggZWU4Y2UxOTI1NTkxMzEyMjYzNDM2YmIyZTFhYmJhMWQ3ZmQ3ODM4Ni4uZWViNDcyZGVmMDU3 Zjk2ODc2OTQ0NWVhYWRjYmYwYWU0YzBlNmZmYiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XVEYvVVJMLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dU Ri9VUkwuY3BwCkBAIC0zNTcsNCArMzU3LDE3NyBAQCBURVNUX0YoV1RGX1VSTCwgUHJpbnRTdHJl YW0pCiAgICAgRVhQRUNUX0VRKG91dC50b1N0cmluZygpLCB1cmxTdHJpbmcpOwogfQogCitURVNU X0YoV1RGX1VSTCwgVVJMUXVlcnlQYXJhbWV0ZXJzKQoreworICAgIFVSTCB1cmwgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgRVhQRUNUX0VRKHVybC5xdWVyeVBh cmFtZXRlcnMoKS52YWx1ZSgpLCBWZWN0b3I8VVJMOjpRdWVyeVBhcmFtZXRlcj4geyB9KTsKKyAg ICAKKyAgICBVUkwgdXJsMSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLyIpOwor ICAgIEVYUEVDVF9FUSh1cmwxLnF1ZXJ5UGFyYW1ldGVycygpLnZhbHVlKCksIFZlY3RvcjxVUkw6 OlF1ZXJ5UGFyYW1ldGVyPiB7IH0pOworICAgIAorICAgIFVSTCB1cmwyID0gY3JlYXRlVVJMKCJo dHRwOi8vd3d3LndlYmtpdC5vcmciKTsKKyAgICBFWFBFQ1RfRVEodXJsMi5xdWVyeVBhcmFtZXRl cnMoKS52YWx1ZSgpLCBWZWN0b3I8VVJMOjpRdWVyeVBhcmFtZXRlcj4geyB9KTsKKyAgICAKKyAg ICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnPyIpOworICAgIEVY UEVDVF9FUSh1cmwzLnF1ZXJ5UGFyYW1ldGVycygpLnZhbHVlKCksIFZlY3RvcjxVUkw6OlF1ZXJ5 UGFyYW1ldGVyPiB7IH0pOworICAgIAorICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvPyYiKTsKKyAgICBFWFBFQ1RfRVEodXJsOS5xdWVyeVBhcmFtZXRlcnMo KS52YWx1ZSgpLCBWZWN0b3I8VVJMOjpRdWVyeVBhcmFtZXRlcj4geyB9KTsKKyAgICAKKyAgICBV UkwgdXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsK KyAgICBVUkw6OlF1ZXJ5UGFyYW1ldGVyIHRlc3Q1ID0geyJrZXkxIiwgInZhbDEifTsKKyAgICBF WFBFQ1RfRVEodXJsNS5xdWVyeVBhcmFtZXRlcnMoKS52YWx1ZSgpLCBWZWN0b3I8VVJMOjpRdWVy eVBhcmFtZXRlcj4geyB0ZXN0NSB9KTsKKyAgICAKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPSIpOworICAgIFVSTDo6UXVlcnlQYXJhbWV0ZXIg dGVzdDYgPSB7ImtleTEiLCAiIn07CisgICAgRVhQRUNUX0VRKHVybDYucXVlcnlQYXJhbWV0ZXJz KCkudmFsdWUoKSwgVmVjdG9yPFVSTDo6UXVlcnlQYXJhbWV0ZXI+IHsgdGVzdDYgfSk7CisgICAg CisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MSIp OworICAgIFVSTDo6UXVlcnlQYXJhbWV0ZXIgdGVzdDcgPSB7ImtleTEiLCAiIn07CisgICAgRVhQ RUNUX0VRKHVybDcucXVlcnlQYXJhbWV0ZXJzKCkudmFsdWUoKSwgVmVjdG9yPFVSTDo6UXVlcnlQ YXJhbWV0ZXI+IHsgdGVzdDcgfSk7CisgICAgCisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0 dHA6Ly93d3cud2Via2l0Lm9yZy8/PSIpOworICAgIFVSTDo6UXVlcnlQYXJhbWV0ZXIgdGVzdDgg PSB7IiIsICIifTsKKyAgICBFWFBFQ1RfRVEodXJsOC5xdWVyeVBhcmFtZXRlcnMoKS52YWx1ZSgp LCBWZWN0b3I8VVJMOjpRdWVyeVBhcmFtZXRlcj4geyB0ZXN0OCB9KTsKKyAgICAKKyAgICBVUkwg dXJsMTAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Jj0iKTsKKyAgICBVUkw6 OlF1ZXJ5UGFyYW1ldGVyIHRlc3QxMCA9IHsiIiwgIiJ9OworICAgIEVYUEVDVF9FUSh1cmwxMC5x dWVyeVBhcmFtZXRlcnMoKS52YWx1ZSgpLCBWZWN0b3I8VVJMOjpRdWVyeVBhcmFtZXRlcj4geyB0 ZXN0MTAgfSk7CisgICAgCisgICAgVVJMIHVybDExID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvP2tleTE9dmFsMSYma2V5Mj12YWwyIik7CisgICAgVmVjdG9yPFVSTDo6UXVlcnlQ YXJhbWV0ZXI+IHRlc3RWZWN0b3IxMSB7eyJrZXkxIiwgInZhbDEifSwgeyJrZXkyIiwgInZhbDIi fX07CisgICAgRVhQRUNUX0VRKHVybDExLnF1ZXJ5UGFyYW1ldGVycygpLnZhbHVlKCksIHRlc3RW ZWN0b3IxMSk7CisgICAgCisgICAgVVJMIHVybDEyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvP2tleTE/PXZhbDEmJmtleTI9dmFsMj8iKTsKKyAgICBWZWN0b3I8VVJMOjpRdWVy eVBhcmFtZXRlcj4gdGVzdFZlY3RvcjEyIHt7ImtleTE/IiwgInZhbDEifSwgeyJrZXkyIiwgInZh bDI/In19OworICAgIEVYUEVDVF9FUSh1cmwxMi5xdWVyeVBhcmFtZXRlcnMoKS52YWx1ZSgpLCB0 ZXN0VmVjdG9yMTIpOworICAgIAorICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz89PyIpOworICAgIFZlY3RvcjxVUkw6OlF1ZXJ5UGFyYW1ldGVyPiB0ZXN0 VmVjdG9yMTMge3siIiwgIj8ifX07CisgICAgRVhQRUNUX0VRKHVybDEzLnF1ZXJ5UGFyYW1ldGVy cygpLnZhbHVlKCksIHRlc3RWZWN0b3IxMyk7CisgICAgCisgICAgVVJMIHVybDE1ID0gY3JlYXRl VVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMT0mIik7CisgICAgVVJMOjpRdWVy eVBhcmFtZXRlciB0ZXN0MTUgPSB7ImtleTEiLCAidmFsMT0ifTsKKyAgICBFWFBFQ1RfRVEodXJs MTUucXVlcnlQYXJhbWV0ZXJzKCkudmFsdWUoKSwgVmVjdG9yPFVSTDo6UXVlcnlQYXJhbWV0ZXI+ IHsgdGVzdDE1IH0pOworICAgIAorICAgIFVSTCB1cmw0ID0gY3JlYXRlVVJMKCIiKTsKKyAgICBF WFBFQ1RfRVEodXJsNC5xdWVyeVBhcmFtZXRlcnMoKSwgc3RkOjpudWxsb3B0KTsKKyAgICAKKyAg ICBVUkwgdXJsMTQgPSBjcmVhdGVVUkwoIi8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0VRKHVy bDE0LnF1ZXJ5UGFyYW1ldGVycygpLCBzdGQ6Om51bGxvcHQpOworICAgIAorICAgIFVSTCB1cmwx NiA9IGNyZWF0ZVVSTCgiL3BhdGgvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9FUSh1cmwxNi5x dWVyeVBhcmFtZXRlcnMoKSwgc3RkOjpudWxsb3B0KTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBj cmVhdGVVUkwoIi9wYXRoLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfRVEodXJsMTcucXVlcnlQ YXJhbWV0ZXJzKCksIHN0ZDo6bnVsbG9wdCk7CisgICAgCisgICAgVVJMIHVybDE4ID0gY3JlYXRl VVJMKCJ3d3cuZXhhbXBsZS5jb20vcGF0aC8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0VRKHVy bDE4LnF1ZXJ5UGFyYW1ldGVycygpLCBzdGQ6Om51bGxvcHQpOworICAgIAorICAgIFVSTCB1cmwx OSA9IGNyZWF0ZVVSTCgiZXhhbXBsZS5jb20vcGF0aC8/a2V5MT12YWwxIik7CisgICAgRVhQRUNU X0VRKHVybDE5LnF1ZXJ5UGFyYW1ldGVycygpLCBzdGQ6Om51bGxvcHQpOworfQorCitURVNUX0Yo V1RGX1VSTCwgVVJMRGlmZmVyZW5jZUluUXVlcnlQYXJhbWV0ZXJzKQoreworICAgIFVSTCB1cmwx ID0gY3JlYXRlVVJMKCJ3d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDIgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0VRKHVy bDEuZGlmZmVyZW5jZUluUXVlcnlQYXJhbWV0ZXJzKHVybDIpLCBzdGQ6Om51bGxvcHQpOworICAg IAorICAgIFVSTCB1cmwgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12 YWwxIik7CisgICAgRVhQRUNUX0VRKHVybC5kaWZmZXJlbmNlSW5RdWVyeVBhcmFtZXRlcnModXJs KS52YWx1ZSgpLCBWZWN0b3I8VVJMOjpRdWVyeVBhcmFtZXRlcj4geyB9KTsKKyAgICAKKyAgICBV UkwgdXJsOSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsK KyAgICBVUkwgdXJsMTAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12 YWwxIik7CisgICAgRVhQRUNUX0VRKHVybDkuZGlmZmVyZW5jZUluUXVlcnlQYXJhbWV0ZXJzKHVy bDEwKS52YWx1ZSgpICwgVmVjdG9yPFVSTDo6UXVlcnlQYXJhbWV0ZXI+IHsgfSk7CisgICAgCisg ICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAg VVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgRVhQ RUNUX0VRKHVybDcuZGlmZmVyZW5jZUluUXVlcnlQYXJhbWV0ZXJzKHVybDgpLnZhbHVlKCksIFZl Y3RvcjxVUkw6OlF1ZXJ5UGFyYW1ldGVyPiB7IH0pOworICAgIAorICAgIFVSTCB1cmwzID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPyIpOworICAgIFVSTCB1cmw0ID0gY3JlYXRl VVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFZlY3RvcjxVUkw6 OlF1ZXJ5UGFyYW1ldGVyPiB0ZXN0VmVjdG9yMzQge3sia2V5MSIsICJ2YWwxIn19OworICAgIEVY UEVDVF9FUSh1cmwzLmRpZmZlcmVuY2VJblF1ZXJ5UGFyYW1ldGVycyh1cmw0KS52YWx1ZSgpLCB0 ZXN0VmVjdG9yMzQpOworICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmw2ID0gY3JlYXRlVVJMKCJodHRw Oi8vd3d3LndlYmtpdC5vcmcvPyIpOworICAgIFZlY3RvcjxVUkw6OlF1ZXJ5UGFyYW1ldGVyPiB0 ZXN0VmVjdG9yNTYge3sia2V5MSIsICJ2YWwxIn19OworICAgIEVYUEVDVF9FUSh1cmw1LmRpZmZl cmVuY2VJblF1ZXJ5UGFyYW1ldGVycyh1cmw2KS52YWx1ZSgpLCB0ZXN0VmVjdG9yNTYpOworICAg IAorICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkx PXZhbDEma2V5Mj12YWwyIik7CisgICAgVVJMIHVybDE0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8VVJMOjpRdWVy eVBhcmFtZXRlcj4gdGVzdFZlY3RvcjEzMTQge3sia2V5MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2 YWwyIn19OworICAgIEVYUEVDVF9FUSh1cmwxMy5kaWZmZXJlbmNlSW5RdWVyeVBhcmFtZXRlcnMo dXJsMTQpLnZhbHVlKCksIHRlc3RWZWN0b3IxMzE0KTsKKyAgICAKKyAgICBVUkwgdXJsMTUgPSBj cmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgVVJMIHVy bDE2ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTI9dmFsMiIpOworICAg IFZlY3RvcjxVUkw6OlF1ZXJ5UGFyYW1ldGVyPiB0ZXN0VmVjdG9yMTUxNiB7eyJrZXkyIiwgInZh bDIifSwgeyJrZXkxIiwgInZhbDEifX07CisgICAgRVhQRUNUX0VRKHVybDE1LmRpZmZlcmVuY2VJ blF1ZXJ5UGFyYW1ldGVycyh1cmwxNikudmFsdWUoKSwgdGVzdFZlY3RvcjE1MTYpOworICAgIAor ICAgIFVSTCB1cmwxMSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZh bDEma2V5Mj12YWwyIik7CisgICAgVVJMIHVybDEyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvP2tleTE9dmFsMSZrZXkzPXZhbDMiKTsKKyAgICBWZWN0b3I8VVJMOjpRdWVyeVBh cmFtZXRlcj4gdGVzdFZlY3RvcjExMTIge3sia2V5MyIsICJ2YWwzIn0sIHsia2V5MiIsICJ2YWwy In19OworICAgIEVYUEVDVF9FUSh1cmwxMS5kaWZmZXJlbmNlSW5RdWVyeVBhcmFtZXRlcnModXJs MTIpLnZhbHVlKCksIHRlc3RWZWN0b3IxMTEyKTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTI9dmFsMiIpOworICAg IFVSTCB1cmwxOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9 dmFsMyIpOworICAgIFZlY3RvcjxVUkw6OlF1ZXJ5UGFyYW1ldGVyPiB0ZXN0VmVjdG9yMTcxOCB7 eyJrZXkxIiwgIiJ9LCB7ImtleTMiLCAidmFsMyJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIi LCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEodXJsMTcuZGlmZmVyZW5jZUluUXVlcnlQYXJhbWV0 ZXJzKHVybDE4KS52YWx1ZSgpLCB0ZXN0VmVjdG9yMTcxOCk7CisgICAgCisgICAgVVJMIHVybDE5 ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkxPXZhbDEm a2V5Mj12YWwyIik7CisgICAgVVJMIHVybDIwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtp dC5vcmcvP2tleTEma2V5Mz12YWwzIik7CisgICAgVmVjdG9yPFVSTDo6UXVlcnlQYXJhbWV0ZXI+ IHRlc3RWZWN0b3IxOTIwIHt7ImtleTEiLCAiIn0sIHsia2V5MyIsICJ2YWwzIn0sIHsia2V5MSIs ICJ2YWwxIn0sIHsia2V5MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2YWwyIn19OworICAgIEVYUEVD VF9FUSh1cmwxOS5kaWZmZXJlbmNlSW5RdWVyeVBhcmFtZXRlcnModXJsMjApLnZhbHVlKCksIHRl c3RWZWN0b3IxOTIwKTsKK30KKworVEVTVF9GKFdURl9VUkwsIFVSTElzRXF1YWxJZ25vcmluZ1F1 ZXJ5KQoreworICAgIFVSTCB1cmwxID0gY3JlYXRlVVJMKCJ3d3cud2Via2l0Lm9yZy8/Iik7Cisg ICAgVVJMIHVybDIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwx Iik7CisgICAgRVhQRUNUX0VRKHVybDEuaXNFcXVhbElnbm9yaW5nUXVlcnkodXJsMiksIHN0ZDo6 bnVsbG9wdCk7CisgICAgCisgICAgVVJMIHVybCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRSh1cmwuaXNFcXVhbElnbm9yaW5n UXVlcnkodXJsKS52YWx1ZSgpKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRSh1cmwzLmlzRXF1 YWxJZ25vcmluZ1F1ZXJ5KHVybDQpLnZhbHVlKCkpOworICAgIAorICAgIFVSTCB1cmw3ID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmc/Iik7CisgICAgVVJMIHVybDggPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX1RSVUUo dXJsNy5pc0VxdWFsSWdub3JpbmdRdWVyeSh1cmw4KS52YWx1ZSgpKTsKKyAgICAKKyAgICBVUkwg dXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy5leGFtcGxlLm9yZy9wYXRoPyIpOworICAgIFVS TCB1cmw2ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOwor ICAgIEVYUEVDVF9GQUxTRSh1cmw1LmlzRXF1YWxJZ25vcmluZ1F1ZXJ5KHVybDYpLnZhbHVlKCkp OworfQorCitURVNUX0YoV1RGX1VSTCwgVVJMSXNFcXVhbFF1ZXJ5KQoreworICAgIFVSTCB1cmwx ID0gY3JlYXRlVVJMKCJ3d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDIgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0VRKHVy bDEuaXNFcXVhbFF1ZXJ5KHVybDIpLCBzdGQ6Om51bGxvcHQpOworICAgIAorICAgIFVSTCB1cmwg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQ RUNUX1RSVUUodXJsLmlzRXF1YWxRdWVyeSh1cmwpLnZhbHVlKCkpOworICAgIAorICAgIFVSTCB1 cmw3ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LmV4YW1wbGUub3JnP2tleTE9dmFsMSIpOworICAg IFVSTCB1cmw4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIp OworICAgIEVYUEVDVF9UUlVFKHVybDcuaXNFcXVhbFF1ZXJ5KHVybDgpLnZhbHVlKCkpOworICAg IAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvcGF0aD8i KTsKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsK KyAgICBFWFBFQ1RfVFJVRSh1cmw1LmlzRXF1YWxRdWVyeSh1cmw2KS52YWx1ZSgpKTsKKyAgICAK KyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAg ICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEi KTsKKyAgICBFWFBFQ1RfRkFMU0UodXJsMy5pc0VxdWFsUXVlcnkodXJsNCkudmFsdWUoKSk7Cisg ICAgCisgICAgVVJMIHVybDkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy9wYXRo P2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwxMCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz9rZXkxPXZhbDEma2V5Mj12YWwyIik7CisgICAgRVhQRUNUX0ZBTFNFKHVybDkuaXNF cXVhbFF1ZXJ5KHVybDEwKS52YWx1ZSgpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktp dEFQSQo= 434531 2021-07-29 10:23:52 -0700 2021-07-30 10:06:44 -0700 Patch bug-228122-20210729102351.patch text/plain 20437 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLmZiZjQxMWJjNGQyMDU3MDQwY2UyYjNjZDFjM2NjNDBlNDIzNmU2 ZTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMjEtMDctMjggIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEV4cGFuZCBVUkwgY2xhc3MgcXVlcnkgcGFyYW1l dGVyIGZ1bmN0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAg ICAgIAorICAgICAgICBBZGRlZCBtb3JlIGZ1bmN0aW9uYWxpdGllcyBmb3IgcGFyc2luZyBVUkwg cXVlcnkgcGFyYW1ldGVycy4KKyAgICAgICAgCisgICAgICAgICogd3RmL0hhc2hGdW5jdGlvbnMu aDoKKyAgICAgICAgKFdURjo6S2V5VmFsdWVQYWlySGFzaDo6aGFzaCk6CisgICAgICAgIChXVEY6 OktleVZhbHVlUGFpckhhc2g6OmVxdWFsKToKKyAgICAgICAgKiB3dGYvSGFzaFRyYWl0cy5oOgor ICAgICAgICAqIHd0Zi9LZXlWYWx1ZVBhaXIuaDoKKyAgICAgICAgKFdURjo6S2V5VmFsdWVQYWly OjpvcGVyYXRvcj09IGNvbnN0KToKKyAgICAgICAgKiB3dGYvVVJMLmNwcDoKKyAgICAgICAgKFdU Rjo6VVJMOjpxdWVyeVBhcmFtZXRlcnMgY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OmRpZmZl cmluZ1F1ZXJ5UGFyYW1ldGVycyBjb25zdCk6CisgICAgICAgIChXVEY6OlVSTDo6aXNFcXVhbEln bm9yaW5nUXVlcnkgY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OmlzUXVlcnlFcXVhbCBjb25z dCk6CisgICAgICAgIChXVEY6OlVSTDo6cmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKToKKyAgICAgICAg KiB3dGYvVVJMLmg6CisKIDIwMjEtMDctMTYgIEFsZXhhbmRlciBNaWtoYXlsZW5rbyAgPGFsZXht QGdub21lLm9yZz4KIAogICAgICAgICBbR1RLXVtXUEVdIFN1cHBvcnQgY29sb3Itc2NoZW1lcyBD U1MgcHJvcGVydHkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0hhc2hGdW5jdGlvbnMuaCBi L1NvdXJjZS9XVEYvd3RmL0hhc2hGdW5jdGlvbnMuaAppbmRleCBmZmQ1MjJjZTI5MDhkN2ZlZTcy YWJiMDQ2MTRhYWY0NDEwNWI2YjY3Li44YTBjN2ExNjYwOTU0NzFiNzA0MjZkZmY0ZTY0NTkwMzI2 ZTliMDg0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoRnVuY3Rpb25zLmgKKysrIGIv U291cmNlL1dURi93dGYvSGFzaEZ1bmN0aW9ucy5oCkBAIC0xNjksNiArMTY5LDE4IEBAIG5hbWVz cGFjZSBXVEYgewogICAgICAgICBzdGF0aWMgY29uc3RleHByIGJvb2wgc2FmZVRvQ29tcGFyZVRv RW1wdHlPckRlbGV0ZWQgPSBEZWZhdWx0SGFzaDxUPjo6c2FmZVRvQ29tcGFyZVRvRW1wdHlPckRl bGV0ZWQgJiYgRGVmYXVsdEhhc2g8VT46OnNhZmVUb0NvbXBhcmVUb0VtcHR5T3JEZWxldGVkOwog ICAgIH07CiAKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBzdHJ1Y3QgS2V5 VmFsdWVQYWlySGFzaCB7CisgICAgICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IEtleVZh bHVlUGFpcjxULCBVPiYgcCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIHBhaXJJbnRI YXNoKERlZmF1bHRIYXNoPFQ+OjpoYXNoKHAua2V5KSwgRGVmYXVsdEhhc2g8VT46Omhhc2gocC52 YWx1ZSkpOworICAgICAgICB9CisgICAgICAgIHN0YXRpYyBib29sIGVxdWFsKGNvbnN0IEtleVZh bHVlUGFpcjxULCBVPiYgYSwgY29uc3QgS2V5VmFsdWVQYWlyPFQsIFU+JiBiKQorICAgICAgICB7 CisgICAgICAgICAgICByZXR1cm4gRGVmYXVsdEhhc2g8VD46OmVxdWFsKGEua2V5LCBiLmtleSkg JiYgRGVmYXVsdEhhc2g8VT46OmVxdWFsKGEudmFsdWUsIGIudmFsdWUpOworICAgICAgICB9Cisg ICAgICAgIHN0YXRpYyBjb25zdGV4cHIgYm9vbCBzYWZlVG9Db21wYXJlVG9FbXB0eU9yRGVsZXRl ZCA9IERlZmF1bHRIYXNoPFQ+OjpzYWZlVG9Db21wYXJlVG9FbXB0eU9yRGVsZXRlZCAmJiBEZWZh dWx0SGFzaDxVPjo6c2FmZVRvQ29tcGFyZVRvRW1wdHlPckRlbGV0ZWQ7CisgICAgfTsKKwogICAg IHRlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IHN0cnVjdCBJbnRQYWlySGFzaCB7CiAg ICAgICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IHN0ZDo6cGFpcjxULCBVPiYgcCkgeyBy ZXR1cm4gcGFpckludEhhc2gocC5maXJzdCwgcC5zZWNvbmQpOyB9CiAgICAgICAgIHN0YXRpYyBi b29sIGVxdWFsKGNvbnN0IHN0ZDo6cGFpcjxULCBVPiYgYSwgY29uc3Qgc3RkOjpwYWlyPFQsIFU+ JiBiKSB7IHJldHVybiBQYWlySGFzaDxULCBUPjo6ZXF1YWwoYSwgYik7IH0KQEAgLTI2Nyw2ICsy NzksNyBAQCBuYW1lc3BhY2UgV1RGIHsKIAogICAgIC8vIG1ha2UgUGFpckhhc2ggdGhlIGRlZmF1 bHQgaGFzaCBmdW5jdGlvbiBmb3IgcGFpcnMgb2YgYXJiaXRyYXJ5IHZhbHVlcy4KIAorICAgIHRl bXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IHN0cnVjdCBEZWZhdWx0SGFzaDxLZXlWYWx1 ZVBhaXI8VCwgVT4+IDogS2V5VmFsdWVQYWlySGFzaDxULCBVPiB7IH07CiAgICAgdGVtcGxhdGU8 dHlwZW5hbWUgVCwgdHlwZW5hbWUgVT4gc3RydWN0IERlZmF1bHRIYXNoPHN0ZDo6cGFpcjxULCBV Pj4gOiBQYWlySGFzaDxULCBVPiB7IH07CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUuLi4gVHlwZXM+ IHN0cnVjdCBEZWZhdWx0SGFzaDxzdGQ6OnR1cGxlPFR5cGVzLi4uPj4gOiBUdXBsZUhhc2g8VHlw ZXMuLi4+IHsgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvSGFzaFRyYWl0cy5oIGIv U291cmNlL1dURi93dGYvSGFzaFRyYWl0cy5oCmluZGV4IDc1MjQ4MWIzZmZjMTMxNWM1NjhhMjNj ZWQ3ZWQ2N2U1ZjE0YmJkOGYuLjIxMTJhNDk2MmZmODE5MjMyZDhjZGRkMTBlZWMwNGE3MDk1ODM0 ZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0hhc2hUcmFpdHMuaAorKysgYi9Tb3VyY2Uv V1RGL3d0Zi9IYXNoVHJhaXRzLmgKQEAgLTQyOCw2ICs0MjgsNyBAQCBzdHJ1Y3QgQ3VzdG9tSGFz aFRyYWl0cyA6IHB1YmxpYyBHZW5lcmljSGFzaFRyYWl0czxUPiB7CiAKIHVzaW5nIFdURjo6SGFz aFRyYWl0czsKIHVzaW5nIFdURjo6S2V5VmFsdWVQYWlyOwordXNpbmcgV1RGOjpLZXlWYWx1ZVBh aXJIYXNoVHJhaXRzOwogdXNpbmcgV1RGOjpQYWlySGFzaFRyYWl0czsKIHVzaW5nIFdURjo6TnVs bGFibGVIYXNoVHJhaXRzOwogdXNpbmcgV1RGOjpTaW1wbGVDbGFzc0hhc2hUcmFpdHM7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9LZXlWYWx1ZVBhaXIuaCBiL1NvdXJjZS9XVEYvd3RmL0tl eVZhbHVlUGFpci5oCmluZGV4IGIxYzJiYzM2ODM1ZGU2ZDBiZDQxMTc5MzViOTVkMmEwMmNhYjA4 ZTIuLjNhM2Q5NjZhMzQxN2YzYWE0OTAxNjdkOWNiNDY3MDRkZDJmMTIxNzYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0tleVZh bHVlUGFpci5oCkBAIC01OSw3ICs1OSwxMyBAQCBzdHJ1Y3QgS2V5VmFsdWVQYWlyIHsKICAgICAg ICAgLCB2YWx1ZShzdGQ6OmZvcndhcmQ8Vj4ob3RoZXIudmFsdWUpKQogICAgIHsKICAgICB9Ci0K KyAgICAKKyAgICB0ZW1wbGF0ZSA8dHlwZW5hbWUgSywgdHlwZW5hbWUgVj4KKyAgICBib29sIG9w ZXJhdG9yPT0oY29uc3QgS2V5VmFsdWVQYWlyPEssIFY+JiBvdGhlcikgY29uc3QKKyAgICB7Cisg ICAgICAgIHJldHVybiBrZXkgPT0gb3RoZXIua2V5ICYmIHZhbHVlID09IG90aGVyLnZhbHVlOwor ICAgIH0KKyAgICAKICAgICBLZXlUeXBlIGtleTsKICAgICBWYWx1ZVR5cGUgdmFsdWUgeyB9Owog fTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9V UkwuY3BwCmluZGV4IGQ5YzA4MmNlYzY5YTVkODQ4ZDAzZDE2ZTA4OTRhOGNiNzJhNWE1ZGIuLjlk ZTYwMTQyYmM3ZDllOTFiNjM5MTk3YWM2OTc2YTRlN2FiNDVlODggMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvd3RmL1VSTC5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVVJMLmNwcApAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVkZSA8dW5pY29kZS91aWRuYS5oPgog I2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNs dWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgogI2luY2x1 ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgpAQCAtMTE2Niw0ICsxMTY3LDExMSBAQCBib29sIFVSTDo6 aG9zdElzSVBBZGRyZXNzKFN0cmluZ1ZpZXcgaG9zdCkKIAogI2VuZGlmCiAKK1ZlY3RvcjxLZXlW YWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiBVUkw6OnF1ZXJ5UGFyYW1ldGVycygpIGNvbnN0Cit7 CisgICAgaWYgKCFtX2lzVmFsaWQpCisgICAgICAgIHJldHVybiB7IH07CisKKyAgICBTdHJpbmdW aWV3IHF1ZXJ5UGFydCA9IHF1ZXJ5KCk7CisgICAgaWYgKHF1ZXJ5UGFydC5pc0VtcHR5KCkpCisg ICAgICAgIHJldHVybiB7IH07CisgICAgCisgICAgcmV0dXJuIFVSTFBhcnNlcjo6cGFyc2VVUkxF bmNvZGVkRm9ybShxdWVyeVBhcnQpOworfQorCitWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywg U3RyaW5nPj4gVVJMOjpkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMoVVJMIG90aGVyVVJMKSBjb25z dAoreworICAgIAorICAgIGlmICghbV9pc1ZhbGlkIHx8ICFvdGhlclVSTC5tX2lzVmFsaWQpCisg ICAgICAgIHJldHVybiB7IH07CisgICAgCisgICAgYXV0byB0aGlzUXVlcnlQYXJhbWV0ZXJzID0g cXVlcnlQYXJhbWV0ZXJzKCk7CisgICAgYXV0byBvdGhlclF1ZXJ5UGFyYW1ldGVycyA9IG90aGVy VVJMLnF1ZXJ5UGFyYW1ldGVycygpOworICAgIGlmICh0aGlzUXVlcnlQYXJhbWV0ZXJzLmlzRW1w dHkoKSAmJiBvdGhlclF1ZXJ5UGFyYW1ldGVycy5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiB7 IH07CisgICAgCisgICAgaWYgKHRoaXNRdWVyeVBhcmFtZXRlcnMuaXNFbXB0eSgpKQorICAgICAg ICByZXR1cm4gb3RoZXJRdWVyeVBhcmFtZXRlcnM7CisKKyAgICBpZiAob3RoZXJRdWVyeVBhcmFt ZXRlcnMuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gdGhpc1F1ZXJ5UGFyYW1ldGVyczsKKwor ICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiBkaWZmZXJpbmdRdWVyeVBh cmFtZXRlcnM7CisgICAgSGFzaE1hcDxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+LCBpbnQ+ IGZyZXF1ZW5jeU9mRGlzdGluY3RQYXJhbWV0ZXI7CisgICAgZm9yIChhdXRvJiBrZXlWYWx1ZSA6 IHRoaXNRdWVyeVBhcmFtZXRlcnMpIHsKKyAgICAgICAgaWYgKCFmcmVxdWVuY3lPZkRpc3RpbmN0 UGFyYW1ldGVyLmNvbnRhaW5zKGtleVZhbHVlKSkKKyAgICAgICAgICAgIGZyZXF1ZW5jeU9mRGlz dGluY3RQYXJhbWV0ZXIuYWRkKGtleVZhbHVlLCAxKTsKKyAgICAgICAgZWxzZQorICAgICAgICAg ICAgZnJlcXVlbmN5T2ZEaXN0aW5jdFBhcmFtZXRlci5zZXQoa2V5VmFsdWUsIGZyZXF1ZW5jeU9m RGlzdGluY3RQYXJhbWV0ZXIuZ2V0KGtleVZhbHVlKSArIDEpOworICAgIH0KKyAgICAKKyAgICBm b3IgKGF1dG8mIHNpbmdsZVF1ZXJ5UGFyYW1ldGVyIDogb3RoZXJRdWVyeVBhcmFtZXRlcnMpIHsK KyAgICAgICAgaWYgKCFmcmVxdWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVyLmNvbnRhaW5zKHNpbmds ZVF1ZXJ5UGFyYW1ldGVyKSkKKyAgICAgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycy5h cHBlbmQoc2luZ2xlUXVlcnlQYXJhbWV0ZXIpOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAg IGlmICghZnJlcXVlbmN5T2ZEaXN0aW5jdFBhcmFtZXRlci5nZXQoc2luZ2xlUXVlcnlQYXJhbWV0 ZXIpKQorICAgICAgICAgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycy5hcHBlbmQoc2lu Z2xlUXVlcnlQYXJhbWV0ZXIpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGZy ZXF1ZW5jeU9mRGlzdGluY3RQYXJhbWV0ZXIuc2V0KHNpbmdsZVF1ZXJ5UGFyYW1ldGVyLCBmcmVx dWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVyLmdldChzaW5nbGVRdWVyeVBhcmFtZXRlcikgLSAxKTsK KyAgICAgICAgfQorICAgIH0KKworICAgIGZvciAoYXV0byYgc2luZ2xlUXVlcnlQYXJhbWV0ZXIg OiB0aGlzUXVlcnlQYXJhbWV0ZXJzKSB7CisgICAgICAgIGlmIChmcmVxdWVuY3lPZkRpc3RpbmN0 UGFyYW1ldGVyLmdldChzaW5nbGVRdWVyeVBhcmFtZXRlcikpIHsKKyAgICAgICAgICAgIGZvciAo aW50IGkgPSAwOyBpIDwgZnJlcXVlbmN5T2ZEaXN0aW5jdFBhcmFtZXRlci5nZXQoc2luZ2xlUXVl cnlQYXJhbWV0ZXIpOyBpKyspCisgICAgICAgICAgICAgICAgZGlmZmVyaW5nUXVlcnlQYXJhbWV0 ZXJzLmFwcGVuZChzaW5nbGVRdWVyeVBhcmFtZXRlcik7CisgICAgICAgICAgICAKKyAgICAgICAg ICAgIGZyZXF1ZW5jeU9mRGlzdGluY3RQYXJhbWV0ZXIuc2V0KHNpbmdsZVF1ZXJ5UGFyYW1ldGVy LCAwKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICByZXR1cm4gZGlmZmVyaW5nUXVlcnlQ YXJhbWV0ZXJzOworfQorCitib29sIFVSTDo6aXNFcXVhbElnbm9yaW5nUXVlcnkoVVJMIG90aGVy VVJMKSBjb25zdAoreworICAgIGlmICghbV9pc1ZhbGlkIHx8ICFvdGhlclVSTC5tX2lzVmFsaWQp CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAKKyAgICBhdXRvIHRoaXNQYXRoTGVuZ3RoID0g bV9zdHJpbmdbbV9wYXRoRW5kLTFdID09ICcvJyA/IG1fcGF0aEVuZC0xIDogbV9wYXRoRW5kOwor ICAgIGF1dG8gb3RoZXJQYXRoTGVuZ3RoID0gb3RoZXJVUkwubV9zdHJpbmdbb3RoZXJVUkwubV9w YXRoRW5kLTFdID09ICcvJyA/ICBvdGhlclVSTC5tX3BhdGhFbmQtMSA6IG90aGVyVVJMLm1fcGF0 aEVuZDsKKyAgICAKKyAgICByZXR1cm4gbV9zdHJpbmcuc3Vic3RyaW5nKDAsIHRoaXNQYXRoTGVu Z3RoKSA9PSBvdGhlclVSTC5tX3N0cmluZy5zdWJzdHJpbmcoMCwgb3RoZXJQYXRoTGVuZ3RoKTsK K30KKworYm9vbCBVUkw6OmlzUXVlcnlFcXVhbChVUkwgb3RoZXJVUkwpIGNvbnN0Cit7CisgICAg aWYgKCFtX2lzVmFsaWQgfHwgIW90aGVyVVJMLm1faXNWYWxpZCkKKyAgICAgICAgcmV0dXJuIHsg fTsKKyAgICAKKyAgICBhdXRvIHF1ZXJ5RGlmZmVyZW5jZSA9IGRpZmZlcmluZ1F1ZXJ5UGFyYW1l dGVycyhvdGhlclVSTCk7CisgICAgaWYgKHF1ZXJ5RGlmZmVyZW5jZS5pc0VtcHR5KCkpCisgICAg ICAgIHJldHVybiB0cnVlOworICAgIAorICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgCit9CisK K3ZvaWQgVVJMOjpyZW1vdmVRdWVyeVBhcmFtZXRlcnMoSGFzaFNldDxTdHJpbmc+IGtleXNUb1Jl bW92ZSkKK3sKKyAgICBpZiAoa2V5c1RvUmVtb3ZlLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJu OworICAgIAorICAgIGF1dG8gcXVlcnlQYXJhbWV0ZXJzTGlzdCA9IHF1ZXJ5UGFyYW1ldGVycygp OworICAgIGlmIChxdWVyeVBhcmFtZXRlcnNMaXN0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJu OworICAgIAorICAgIFN0cmluZyBxdWVyeVdpdGhvdXRSZW1vdmFsS2V5OworICAgIGZvciAoYXV0 byYgc2luZ2xlUXVlcnlQYXJhbWV0ZXIgOiBxdWVyeVBhcmFtZXRlcnNMaXN0KSB7CisgICAgICAg IGlmIChrZXlzVG9SZW1vdmUuZmluZChzaW5nbGVRdWVyeVBhcmFtZXRlci5rZXkpID09IGtleXNU b1JlbW92ZS5lbmQoKSkKKyAgICAgICAgICAgIHF1ZXJ5V2l0aG91dFJlbW92YWxLZXkgPSBxdWVy eVdpdGhvdXRSZW1vdmFsS2V5ICsgc2luZ2xlUXVlcnlQYXJhbWV0ZXIua2V5ICsgIj0iICsgc2lu Z2xlUXVlcnlQYXJhbWV0ZXIudmFsdWUgKyAiJiI7CisgICAgICAgIAorICAgIH0KKyAgICAKKyAg ICBpZiAoIXF1ZXJ5V2l0aG91dFJlbW92YWxLZXkuaXNFbXB0eSgpKQorICAgICAgICBxdWVyeVdp dGhvdXRSZW1vdmFsS2V5ID0gcXVlcnlXaXRob3V0UmVtb3ZhbEtleS5zdWJzdHJpbmcoMCwgcXVl cnlXaXRob3V0UmVtb3ZhbEtleS5sZW5ndGgoKSAtIDEpOworICAgIAorICAgIHNldFF1ZXJ5KFN0 cmluZ1ZpZXcocXVlcnlXaXRob3V0UmVtb3ZhbEtleSkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBX VEYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5oIGIvU291cmNlL1dURi93dGYvVVJM LmgKaW5kZXggZjQ0NTQyMWUxZmUyM2NhYmI2MTU3ZjcwZDljNDQ2YTI4NmM1ZjA1Ni4uZTY0YTk0 ZmI1MGJjNjIxYzA2NjVhMWExNjA5N2ZjZWNjMTM2NjEzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dU Ri93dGYvVVJMLmgKKysrIGIvU291cmNlL1dURi93dGYvVVJMLmgKQEAgLTIwMCw2ICsyMDAsMTIg QEAgcHVibGljOgogICAgIHRlbXBsYXRlPHR5cGVuYW1lIERlY29kZXI+IHN0YXRpYyBzdGQ6Om9w dGlvbmFsPFVSTD4gZGVjb2RlKERlY29kZXImKTsKIAogICAgIFdURl9FWFBPUlRfUFJJVkFURSBi b29sIGhhc1NwZWNpYWxTY2hlbWUoKSBjb25zdDsKKyAgICAKKyAgICBXVEZfRVhQT1JUX1BSSVZB VEUgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHF1ZXJ5UGFyYW1ldGVycygp IGNvbnN0OworICAgIFdURl9FWFBPUlRfUFJJVkFURSBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmlu ZywgU3RyaW5nPj4gZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKFVSTCkgY29uc3Q7CisgICAgV1RG X0VYUE9SVF9QUklWQVRFIGJvb2wgaXNFcXVhbElnbm9yaW5nUXVlcnkoVVJMKSBjb25zdDsKKyAg ICBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBpc1F1ZXJ5RXF1YWwoVVJMKSBjb25zdDsKKyAgICBX VEZfRVhQT1JUX1BSSVZBVEUgdm9pZCByZW1vdmVRdWVyeVBhcmFtZXRlcnMoSGFzaFNldDxTdHJp bmc+KTsKIAogcHJpdmF0ZToKICAgICBmcmllbmQgY2xhc3MgVVJMUGFyc2VyOwpkaWZmIC0tZ2l0 IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGE2NmEyNGZlNDc5ZjFl OTQyN2Y3OWQyNzdiZDE0ZWU4OTBlN2ZiM2MuLjVlMDFjMTMyYjM1MTVhYmViMDIwNDhjNmU4MDVj MzhjZWEzZDZmZGIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMS0wNy0yOCAgUmlzdWwgSXNsYW0gIDxyaXN1bF9p c2xhbUBhcHBsZS5jb20+CisKKyAgICAgICAgRXhwYW5kIFVSTCBjbGFzcyBxdWVyeSBwYXJhbWV0 ZXIgZnVuY3Rpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMjgxMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKyAgICAg ICAgCisgICAgICAgIEFkZGVkIHRoZSB0ZXN0IGZ1bmN0aW9ucyByZXF1aXJlZCBmb3IgVVJMIHF1 ZXJ5IHBhcmFtZXRlciBwYXJ0IHBhcnNpbmcuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rl c3RzL1dURi9VUkwuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVF9GKToKKwogMjAy MS0wNy0xOSAgUnlhbiBIYWRkYWQgIDxyeWFuaGFkZGFkQGFwcGxlLmNvbT4KIAogICAgICAgICBb YnVpbGQud2Via2l0Lm9yZ10gbGxkYi13ZWJraXQtdGVzdCBpcyBmYWlsaW5nIG9uIENhdGFsaW5h IHF1ZXVlcwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVVJMLmNw cCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHAKaW5kZXggZWU4Y2UxOTI1 NTkxMzEyMjYzNDM2YmIyZTFhYmJhMWQ3ZmQ3ODM4Ni4uYjBmYWVlNWZjZTEzZGYyYjEzMTQ1NTk3 ZDE0NTgzNzgxM2ViZGQ2NCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X VEYvVVJMLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwCkBA IC0yNSwxMCArMjUsMTIgQEAKIAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIldURlN0 cmluZ1V0aWxpdGllcy5oIgorI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3Rm L01haW5UaHJlYWQuaD4KICNpbmNsdWRlIDx3dGYvU3RyaW5nUHJpbnRTdHJlYW0uaD4KICNpbmNs dWRlIDx3dGYvVVJMLmg+CiAjaW5jbHVkZSA8d3RmL1VSTFBhcnNlci5oPgorI2luY2x1ZGUgPHd0 Zi90ZXh0L1N0cmluZ0hhc2guaD4KIAogbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgewogCkBAIC0z NTcsNCArMzU5LDIyOCBAQCBURVNUX0YoV1RGX1VSTCwgUHJpbnRTdHJlYW0pCiAgICAgRVhQRUNU X0VRKG91dC50b1N0cmluZygpLCB1cmxTdHJpbmcpOwogfQogCitURVNUX0YoV1RGX1VSTCwgVVJM UXVlcnlQYXJhbWV0ZXJzKQoreworICAgIFVSTCB1cmwgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZy8/Iik7CisgICAgVmVjdG9yPFdURjo6S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPj4gdGVzdFZlY3RvcjIgeyB9OworICAgIEVYUEVDVF9FUSh1cmwucXVlcnlQYXJhbWV0ZXJz KCksIHRlc3RWZWN0b3IyKTsKKyAgICAKKyAgICBVUkwgdXJsMSA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLyIpOworICAgIEVYUEVDVF9FUSh1cmwxLnF1ZXJ5UGFyYW1ldGVycygp LCB0ZXN0VmVjdG9yMik7CisgICAgCisgICAgVVJMIHVybDIgPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZyIpOworICAgIEVYUEVDVF9FUSh1cmwyLnF1ZXJ5UGFyYW1ldGVycygpLCB0 ZXN0VmVjdG9yMik7CisgICAgCisgICAgVVJMIHVybDMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZz8iKTsKKyAgICBFWFBFQ1RfRVEodXJsMy5xdWVyeVBhcmFtZXRlcnMoKSwgdGVz dFZlY3RvcjIpOworICAgIAorICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvPyYiKTsKKyAgICBFWFBFQ1RfRVEodXJsOS5xdWVyeVBhcmFtZXRlcnMoKSwgdGVz dFZlY3RvcjIpOworICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBT dHJpbmc+PiB0ZXN0VmVjdG9yNSB7IHsia2V5MSIsICJ2YWwxIn0gfTsKKyAgICBFWFBFQ1RfRVEo dXJsNS5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZlY3RvcjUpOworICAgIAorICAgIFVSTCB1cmw2 ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9Iik7CisgICAgVmVjdG9y PEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3I2IHsgeyJrZXkxIiwgIiJ9 IH07CisgICAgRVhQRUNUX0VRKHVybDYucXVlcnlQYXJhbWV0ZXJzKCksIHRlc3RWZWN0b3I2KTsK KyAgICAKKyAgICBVUkwgdXJsNyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9r ZXkxIik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0 b3I3IHsgeyJrZXkxIiwgIiJ9IH07CisgICAgRVhQRUNUX0VRKHVybDcucXVlcnlQYXJhbWV0ZXJz KCksIHRlc3RWZWN0b3I3KTsKKyAgICAKKyAgICBVUkwgdXJsOCA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz89Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0 cmluZz4+IHRlc3RWZWN0b3I4IHsgeyIiLCAiIn0gfTsKKyAgICBFWFBFQ1RfRVEodXJsOC5xdWVy eVBhcmFtZXRlcnMoKSwgdGVzdFZlY3RvcjgpOworICAgIAorICAgIFVSTCB1cmwxMCA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8mPSIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBh aXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTAgeyB7IiIsICIifSB9OworICAgIEVYUEVD VF9FUSh1cmwxMC5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZlY3RvcjEwKTsKKyAgICAKKyAgICBV UkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJiZr ZXkyPXZhbDIiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVz dFZlY3RvcjExIHt7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBF Q1RfRVEodXJsMTEucXVlcnlQYXJhbWV0ZXJzKCksIHRlc3RWZWN0b3IxMSk7CisgICAgCisgICAg VVJMIHVybDEyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE/PXZhbDEm JmtleTI9dmFsMj8iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4g dGVzdFZlY3RvcjEyIHt7ImtleTE/IiwgInZhbDEifSwgeyJrZXkyIiwgInZhbDI/In19OworICAg IEVYUEVDVF9FUSh1cmwxMi5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZlY3RvcjEyKTsKKyAgICAK KyAgICBVUkwgdXJsMTMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/PT8iKTsK KyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjEzIHt7 IiIsICI/In19OworICAgIEVYUEVDVF9FUSh1cmwxMy5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZl Y3RvcjEzKTsKKyAgICAKKyAgICBVUkwgdXJsMTUgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Vi a2l0Lm9yZy8/a2V5MT12YWwxPSYiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywg U3RyaW5nPj4gdGVzdFZlY3RvcjE1IHsgeyJrZXkxIiwgInZhbDE9In0gfTsKKyAgICBFWFBFQ1Rf RVEodXJsMTUucXVlcnlQYXJhbWV0ZXJzKCksIHRlc3RWZWN0b3IxNSk7CisgICAgCisgICAgVVJM IHVybDQgPSBjcmVhdGVVUkwoIiIpOworICAgIEVYUEVDVF9FUSh1cmw0LnF1ZXJ5UGFyYW1ldGVy cygpLCB0ZXN0VmVjdG9yMik7CisgICAgCisgICAgVVJMIHVybDE0ID0gY3JlYXRlVVJMKCIvP2tl eTE9dmFsMSIpOworICAgIEVYUEVDVF9FUSh1cmwxNC5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZl Y3RvcjIpOworICAgIAorICAgIFVSTCB1cmwxNiA9IGNyZWF0ZVVSTCgiL3BhdGgvP2tleTE9dmFs MSIpOworICAgIEVYUEVDVF9FUSh1cmwxNi5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZlY3RvcjIp OworICAgIAorICAgIFVSTCB1cmwxNyA9IGNyZWF0ZVVSTCgiL3BhdGgvP2tleTE9dmFsMSIpOwor ICAgIEVYUEVDVF9FUSh1cmwxNy5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZlY3RvcjIpOworICAg IAorICAgIFVSTCB1cmwxOCA9IGNyZWF0ZVVSTCgid3d3LmV4YW1wbGUuY29tL3BhdGgvP2tleTE9 dmFsMSIpOworICAgIEVYUEVDVF9FUSh1cmwxOC5xdWVyeVBhcmFtZXRlcnMoKSwgdGVzdFZlY3Rv cjIpOworICAgIAorICAgIFVSTCB1cmwxOSA9IGNyZWF0ZVVSTCgiZXhhbXBsZS5jb20vcGF0aC8/ a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0VRKHVybDE5LnF1ZXJ5UGFyYW1ldGVycygpLCB0ZXN0 VmVjdG9yMik7Cit9CisKK1RFU1RfRihXVEZfVVJMLCBVUkxEaWZmZXJpbmdRdWVyeVBhcmFtZXRl cnMpCit7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8iKTsKKyAg ICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEi KTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvciB7 IH07CisgICAgRVhQRUNUX0VRKHVybDEuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIpLCB0 ZXN0VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9FUSh1cmwuZGlmZmVyaW5nUXVlcnlQ YXJhbWV0ZXJzKHVybCksIHRlc3RWZWN0b3IpOworICAgIAorICAgIFVSTCB1cmw5ID0gY3JlYXRl VVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwxMCA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBF Q1RfRVEodXJsOS5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTApICwgdGVzdFZlY3Rvcik7 CisgICAgCisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ Iik7CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7 CisgICAgRVhQRUNUX0VRKHVybDcuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDgpLCB0ZXN0 VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQu b3JnLz9rZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5n Pj4gdGVzdFZlY3RvcjM0IHt7ImtleTEiLCAidmFsMSJ9fTsKKyAgICBFWFBFQ1RfRVEodXJsMy5k aWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsNCksIHRlc3RWZWN0b3IzNCk7CisgICAgCisgICAg VVJMIHVybDUgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7 CisgICAgVVJMIHVybDYgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7Cisg ICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3I1NiB7eyJr ZXkxIiwgInZhbDEifX07CisgICAgRVhQRUNUX0VRKHVybDUuZGlmZmVyaW5nUXVlcnlQYXJhbWV0 ZXJzKHVybDYpLCB0ZXN0VmVjdG9yNTYpOworICAgIAorICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5Mj12YWwyIik7CisgICAgVVJM IHVybDE0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkx PXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZl Y3RvcjEzMTQge3sia2V5MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2YWwyIn19OworICAgIEVYUEVD VF9FUSh1cmwxMy5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTQpLCB0ZXN0VmVjdG9yMTMx NCk7CisgICAgCisgICAgVVJMIHVybDE1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmcvP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwxNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkyPXZhbDIiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywg U3RyaW5nPj4gdGVzdFZlY3RvcjE1MTYge3sia2V5MiIsICJ2YWwyIn0sIHsia2V5MSIsICJ2YWwx In19OworICAgIEVYUEVDVF9FUSh1cmwxNS5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTYp LCB0ZXN0VmVjdG9yMTUxNik7CisgICAgCisgICAgVVJMIHVybDExID0gY3JlYXRlVVJMKCJodHRw Oi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkyPXZhbDIiKTsKKyAgICBVUkwgdXJsMTIg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTM9dmFsMyIp OworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTEx MiB7eyJrZXkzIiwgInZhbDMifSwgeyJrZXkyIiwgInZhbDIifX07CisgICAgRVhQRUNUX0VRKHVy bDExLmRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwxMiksIHRlc3RWZWN0b3IxMTEyKTsKKyAg ICAKKyAgICBVUkwgdXJsMTcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5 MT12YWwxJmtleTI9dmFsMiIpOworICAgIFVSTCB1cmwxOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz9rZXkxJmtleTM9dmFsMyIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8 U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTcxOCB7eyJrZXkxIiwgIiJ9LCB7ImtleTMiLCAi dmFsMyJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1Rf RVEodXJsMTcuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDE4KSwgdGVzdFZlY3RvcjE3MTgp OworICAgIAorICAgIFVSTCB1cmwxOSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3Jn Lz9rZXkxPXZhbDEma2V5MT12YWwxJmtleTI9dmFsMiIpOworICAgIFVSTCB1cmwyMCA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9dmFsMyIpOworICAgIFZlY3Rv cjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTkyMCB7eyJrZXkxIiwg IiJ9LCB7ImtleTMiLCAidmFsMyJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTEiLCAidmFsMSJ9 LCB7ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEodXJsMTkuZGlmZmVyaW5nUXVlcnlQ YXJhbWV0ZXJzKHVybDIwKSwgdGVzdFZlY3RvcjE5MjApOworfQorCitURVNUX0YoV1RGX1VSTCwg VVJMSXNFcXVhbElnbm9yaW5nUXVlcnkpCit7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3 dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfRkFMU0UodXJsMS5pc0VxdWFsSWdu b3JpbmdRdWVyeSh1cmwyKSk7CisKKyAgICBVUkwgdXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKHVybC5pc0VxdWFsSWdu b3JpbmdRdWVyeSh1cmwpKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRSh1cmwzLmlzRXF1YWxJ Z25vcmluZ1F1ZXJ5KHVybDQpKTsKKyAgICAKKyAgICBVUkwgdXJsNyA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnPyIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKHVybDcuaXNFcXVh bElnbm9yaW5nUXVlcnkodXJsOCkpOworICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJo dHRwOi8vd3d3LmV4YW1wbGUub3JnL3BhdGg/Iik7CisgICAgVVJMIHVybDYgPSBjcmVhdGVVUkwo Imh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0ZBTFNFKHVy bDUuaXNFcXVhbElnbm9yaW5nUXVlcnkodXJsNikpOworfQorCitURVNUX0YoV1RGX1VSTCwgVVJM SXNRdWVyeUVxdWFsKQoreworICAgIFVSTCB1cmwxID0gY3JlYXRlVVJMKCJ3d3cud2Via2l0Lm9y Zy8/Iik7CisgICAgVVJMIHVybDIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0ZBTFNFKHVybDEuaXNRdWVyeUVxdWFsKHVybDIpKTsK KyAgICAKKyAgICBVUkwgdXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tl eTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKHVybC5pc1F1ZXJ5RXF1YWwodXJsKSk7CisgICAg CisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cuZXhhbXBsZS5vcmc/a2V5MT12 YWwxIik7CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5MT12YWwxIik7CisgICAgRVhQRUNUX1RSVUUodXJsNy5pc1F1ZXJ5RXF1YWwodXJsOCkpOwor ICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvcGF0 aD8iKTsKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8i KTsKKyAgICBFWFBFQ1RfVFJVRSh1cmw1LmlzUXVlcnlFcXVhbCh1cmw2KSk7CisgICAgCisgICAg VVJMIHVybDMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJM IHVybDQgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7Cisg ICAgRVhQRUNUX0ZBTFNFKHVybDMuaXNRdWVyeUVxdWFsKHVybDQpKTsKKyAgICAKKyAgICBVUkwg dXJsOSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnL3BhdGg/a2V5MT12YWwxIik7 CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9 dmFsMSZrZXkyPXZhbDIiKTsKKyAgICBFWFBFQ1RfRkFMU0UodXJsOS5pc1F1ZXJ5RXF1YWwodXJs MTApKTsKK30KKworVEVTVF9GKFdURl9VUkwsIFVSTFJlbW92ZVF1ZXJ5UGFyYW1ldGVycykKK3sK KyAgICBVUkwgdXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwi KTsKKyAgICBVUkwgdXJsMSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9 dmFsJmtleTE9dmFsMSIpOworICAgIFVSTCB1cmwyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvPyIpOworICAgIFVSTCB1cmwzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtp dC5vcmcvP2tleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsJmtleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwg dXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkma2V5PSNmcmFnbWVu dCIpOworICAgIFVSTCB1cmw2ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvI2Zy YWdtZW50Iik7CisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9y Zy8/a2V5PXZhbCNmcmFnbWVudCIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvPyIpOworICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvI2ZyYWdtZW50Iik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRw Oi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsMTEgPSBj cmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEjZnJhZ21l bnQiKTsKKyAgICBVUkwgdXJsMTIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5PXZhbCZrZXkxPXZhbDEjZnJhZ21lbnQiKTsKKyAgICAKKyAgICBIYXNoU2V0PFN0cmluZz4g a2V5UmVtb3ZhbFNldDEgeyJrZXkifTsKKyAgICBIYXNoU2V0PFN0cmluZz4ga2V5UmVtb3ZhbFNl dDIgeyJrZXkxIn07CisgICAgSGFzaFNldDxTdHJpbmc+IGtleVJlbW92YWxTZXQzIHsia2V5MiJ9 OworICAgIEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0NCB7ImtleSIsICJrZXkxIn07CisK KyAgICB1cmwxLnJlbW92ZVF1ZXJ5UGFyYW1ldGVycyhrZXlSZW1vdmFsU2V0Mik7CisgICAgRVhQ RUNUX0VRKHVybC5zdHJpbmcoKSwgdXJsMS5zdHJpbmcoKSk7CisgICAgCisgICAgdXJsMi5yZW1v dmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVtb3ZhbFNldDEpOworICAgIEVYUEVDVF9FUSh1cmw4LnN0 cmluZygpLCB1cmwyLnN0cmluZygpKTsKKyAgICAKKyAgICB1cmwzLnJlbW92ZVF1ZXJ5UGFyYW1l dGVycyhrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDYuc3RyaW5nKCksIHVybDMu c3RyaW5nKCkpOworICAgIAorICAgIHVybDQucmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKGtleVJlbW92 YWxTZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJsNi5zdHJpbmcoKSwgdXJsNC5zdHJpbmcoKSk7Cisg ICAgCisgICAgdXJsNS5yZW1vdmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVtb3ZhbFNldDEpOworICAg IEVYUEVDVF9FUSh1cmw2LnN0cmluZygpLCB1cmw1LnN0cmluZygpKTsKKyAgICAKKyAgICB1cmw2 LnJlbW92ZVF1ZXJ5UGFyYW1ldGVycyhrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVy bDkuc3RyaW5nKCksIHVybDYuc3RyaW5nKCkpOworICAgIAorICAgIHVybDcucmVtb3ZlUXVlcnlQ YXJhbWV0ZXJzKGtleVJlbW92YWxTZXQyKTsKKyAgICBFWFBFQ1RfRVEodXJsMTAuc3RyaW5nKCks IHVybDcuc3RyaW5nKCkpOworICAgIAorICAgIHVybDExLnJlbW92ZVF1ZXJ5UGFyYW1ldGVycyhr ZXlSZW1vdmFsU2V0Myk7CisgICAgRVhQRUNUX0VRKHVybDEyLnN0cmluZygpLCB1cmwxMS5zdHJp bmcoKSk7CisgICAgCisgICAgdXJsMTIucmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKGtleVJlbW92YWxT ZXQ0KTsKKyAgICBFWFBFQ1RfRVEodXJsOS5zdHJpbmcoKSwgdXJsMTIuc3RyaW5nKCkpOworfQor CiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCg== 434642 2021-07-30 10:06:47 -0700 2021-07-30 16:05:06 -0700 Patch bug-228122-20210730100646.patch text/plain 17546 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLjZhN2IzNWRkZGUzYjRjZDkxZTMyMTJhY2M2M2VhMDllMjBhZWFl ZDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMjEtMDctMzAgIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEV4cGFuZCBVUkwgY2xhc3MgcXVlcnkgcGFyYW1l dGVyIGZ1bmN0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAg ICAgIAorICAgICAgICBBZGRlZCBtb3JlIGZ1bmN0aW9uYWxpdGllcyBmb3IgcGFyc2luZyBVUkwg cXVlcnkgcGFyYW1ldGVycy4KKyAgICAgICAgCisgICAgICAgICogd3RmL0hhc2hGdW5jdGlvbnMu aDoKKyAgICAgICAgKFdURjo6S2V5VmFsdWVQYWlySGFzaDo6aGFzaCk6CisgICAgICAgIChXVEY6 OktleVZhbHVlUGFpckhhc2g6OmVxdWFsKToKKyAgICAgICAgKiB3dGYvSGFzaFRyYWl0cy5oOgor ICAgICAgICAqIHd0Zi9LZXlWYWx1ZVBhaXIuaDoKKyAgICAgICAgKFdURjo6S2V5VmFsdWVQYWly OjpvcGVyYXRvcj09IGNvbnN0KToKKyAgICAgICAgKiB3dGYvVVJMLmNwcDoKKyAgICAgICAgKFdU Rjo6VVJMOjpxdWVyeVBhcmFtZXRlcnMgY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OmRpZmZl cmluZ1F1ZXJ5UGFyYW1ldGVycyBjb25zdCk6CisgICAgICAgIChXVEY6OlVSTDo6aXNFcXVhbEln bm9yaW5nUXVlcnkgY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OmlzUXVlcnlFcXVhbCBjb25z dCk6CisgICAgICAgIChXVEY6OlVSTDo6cmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKToKKyAgICAgICAg KiB3dGYvVVJMLmg6CisKIDIwMjEtMDctMTYgIEFsZXhhbmRlciBNaWtoYXlsZW5rbyAgPGFsZXht QGdub21lLm9yZz4KIAogICAgICAgICBbR1RLXVtXUEVdIFN1cHBvcnQgY29sb3Itc2NoZW1lcyBD U1MgcHJvcGVydHkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0hhc2hGdW5jdGlvbnMuaCBi L1NvdXJjZS9XVEYvd3RmL0hhc2hGdW5jdGlvbnMuaAppbmRleCBmZmQ1MjJjZTI5MDhkN2ZlZTcy YWJiMDQ2MTRhYWY0NDEwNWI2YjY3Li44YTBjN2ExNjYwOTU0NzFiNzA0MjZkZmY0ZTY0NTkwMzI2 ZTliMDg0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoRnVuY3Rpb25zLmgKKysrIGIv U291cmNlL1dURi93dGYvSGFzaEZ1bmN0aW9ucy5oCkBAIC0xNjksNiArMTY5LDE4IEBAIG5hbWVz cGFjZSBXVEYgewogICAgICAgICBzdGF0aWMgY29uc3RleHByIGJvb2wgc2FmZVRvQ29tcGFyZVRv RW1wdHlPckRlbGV0ZWQgPSBEZWZhdWx0SGFzaDxUPjo6c2FmZVRvQ29tcGFyZVRvRW1wdHlPckRl bGV0ZWQgJiYgRGVmYXVsdEhhc2g8VT46OnNhZmVUb0NvbXBhcmVUb0VtcHR5T3JEZWxldGVkOwog ICAgIH07CiAKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBzdHJ1Y3QgS2V5 VmFsdWVQYWlySGFzaCB7CisgICAgICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IEtleVZh bHVlUGFpcjxULCBVPiYgcCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIHBhaXJJbnRI YXNoKERlZmF1bHRIYXNoPFQ+OjpoYXNoKHAua2V5KSwgRGVmYXVsdEhhc2g8VT46Omhhc2gocC52 YWx1ZSkpOworICAgICAgICB9CisgICAgICAgIHN0YXRpYyBib29sIGVxdWFsKGNvbnN0IEtleVZh bHVlUGFpcjxULCBVPiYgYSwgY29uc3QgS2V5VmFsdWVQYWlyPFQsIFU+JiBiKQorICAgICAgICB7 CisgICAgICAgICAgICByZXR1cm4gRGVmYXVsdEhhc2g8VD46OmVxdWFsKGEua2V5LCBiLmtleSkg JiYgRGVmYXVsdEhhc2g8VT46OmVxdWFsKGEudmFsdWUsIGIudmFsdWUpOworICAgICAgICB9Cisg ICAgICAgIHN0YXRpYyBjb25zdGV4cHIgYm9vbCBzYWZlVG9Db21wYXJlVG9FbXB0eU9yRGVsZXRl ZCA9IERlZmF1bHRIYXNoPFQ+OjpzYWZlVG9Db21wYXJlVG9FbXB0eU9yRGVsZXRlZCAmJiBEZWZh dWx0SGFzaDxVPjo6c2FmZVRvQ29tcGFyZVRvRW1wdHlPckRlbGV0ZWQ7CisgICAgfTsKKwogICAg IHRlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IHN0cnVjdCBJbnRQYWlySGFzaCB7CiAg ICAgICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IHN0ZDo6cGFpcjxULCBVPiYgcCkgeyBy ZXR1cm4gcGFpckludEhhc2gocC5maXJzdCwgcC5zZWNvbmQpOyB9CiAgICAgICAgIHN0YXRpYyBi b29sIGVxdWFsKGNvbnN0IHN0ZDo6cGFpcjxULCBVPiYgYSwgY29uc3Qgc3RkOjpwYWlyPFQsIFU+ JiBiKSB7IHJldHVybiBQYWlySGFzaDxULCBUPjo6ZXF1YWwoYSwgYik7IH0KQEAgLTI2Nyw2ICsy NzksNyBAQCBuYW1lc3BhY2UgV1RGIHsKIAogICAgIC8vIG1ha2UgUGFpckhhc2ggdGhlIGRlZmF1 bHQgaGFzaCBmdW5jdGlvbiBmb3IgcGFpcnMgb2YgYXJiaXRyYXJ5IHZhbHVlcy4KIAorICAgIHRl bXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IHN0cnVjdCBEZWZhdWx0SGFzaDxLZXlWYWx1 ZVBhaXI8VCwgVT4+IDogS2V5VmFsdWVQYWlySGFzaDxULCBVPiB7IH07CiAgICAgdGVtcGxhdGU8 dHlwZW5hbWUgVCwgdHlwZW5hbWUgVT4gc3RydWN0IERlZmF1bHRIYXNoPHN0ZDo6cGFpcjxULCBV Pj4gOiBQYWlySGFzaDxULCBVPiB7IH07CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUuLi4gVHlwZXM+ IHN0cnVjdCBEZWZhdWx0SGFzaDxzdGQ6OnR1cGxlPFR5cGVzLi4uPj4gOiBUdXBsZUhhc2g8VHlw ZXMuLi4+IHsgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvSGFzaFRyYWl0cy5oIGIv U291cmNlL1dURi93dGYvSGFzaFRyYWl0cy5oCmluZGV4IDc1MjQ4MWIzZmZjMTMxNWM1NjhhMjNj ZWQ3ZWQ2N2U1ZjE0YmJkOGYuLjIxMTJhNDk2MmZmODE5MjMyZDhjZGRkMTBlZWMwNGE3MDk1ODM0 ZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0hhc2hUcmFpdHMuaAorKysgYi9Tb3VyY2Uv V1RGL3d0Zi9IYXNoVHJhaXRzLmgKQEAgLTQyOCw2ICs0MjgsNyBAQCBzdHJ1Y3QgQ3VzdG9tSGFz aFRyYWl0cyA6IHB1YmxpYyBHZW5lcmljSGFzaFRyYWl0czxUPiB7CiAKIHVzaW5nIFdURjo6SGFz aFRyYWl0czsKIHVzaW5nIFdURjo6S2V5VmFsdWVQYWlyOwordXNpbmcgV1RGOjpLZXlWYWx1ZVBh aXJIYXNoVHJhaXRzOwogdXNpbmcgV1RGOjpQYWlySGFzaFRyYWl0czsKIHVzaW5nIFdURjo6TnVs bGFibGVIYXNoVHJhaXRzOwogdXNpbmcgV1RGOjpTaW1wbGVDbGFzc0hhc2hUcmFpdHM7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9LZXlWYWx1ZVBhaXIuaCBiL1NvdXJjZS9XVEYvd3RmL0tl eVZhbHVlUGFpci5oCmluZGV4IGIxYzJiYzM2ODM1ZGU2ZDBiZDQxMTc5MzViOTVkMmEwMmNhYjA4 ZTIuLjNhM2Q5NjZhMzQxN2YzYWE0OTAxNjdkOWNiNDY3MDRkZDJmMTIxNzYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0tleVZh bHVlUGFpci5oCkBAIC01OSw3ICs1OSwxMyBAQCBzdHJ1Y3QgS2V5VmFsdWVQYWlyIHsKICAgICAg ICAgLCB2YWx1ZShzdGQ6OmZvcndhcmQ8Vj4ob3RoZXIudmFsdWUpKQogICAgIHsKICAgICB9Ci0K KyAgICAKKyAgICB0ZW1wbGF0ZSA8dHlwZW5hbWUgSywgdHlwZW5hbWUgVj4KKyAgICBib29sIG9w ZXJhdG9yPT0oY29uc3QgS2V5VmFsdWVQYWlyPEssIFY+JiBvdGhlcikgY29uc3QKKyAgICB7Cisg ICAgICAgIHJldHVybiBrZXkgPT0gb3RoZXIua2V5ICYmIHZhbHVlID09IG90aGVyLnZhbHVlOwor ICAgIH0KKyAgICAKICAgICBLZXlUeXBlIGtleTsKICAgICBWYWx1ZVR5cGUgdmFsdWUgeyB9Owog fTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9V UkwuY3BwCmluZGV4IGQ5YzA4MmNlYzY5YTVkODQ4ZDAzZDE2ZTA4OTRhOGNiNzJhNWE1ZGIuLmVi MGY1ZmIxMjE1MWU5NDIwMWM2MmI5NDE3MTI1YmExMzA2ZDYzNjkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvd3RmL1VSTC5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVVJMLmNwcApAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVkZSA8dW5pY29kZS91aWRuYS5oPgog I2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNs dWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgogI2luY2x1 ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgpAQCAtMTE2Niw0ICsxMTY3LDk4IEBAIGJvb2wgVVJMOjpo b3N0SXNJUEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQogCiAjZW5kaWYKIAorVmVjdG9yPEtleVZh bHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IFVSTDo6ZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKGNv bnN0IFVSTCYgb3RoZXJVUkwpIGNvbnN0Cit7CisgICAgCisgICAgaWYgKCFtX2lzVmFsaWQgfHwg IW90aGVyVVJMLm1faXNWYWxpZCkKKyAgICAgICAgcmV0dXJuIHsgfTsKKyAgICAKKyAgICBhdXRv IHRoaXNRdWVyeVBhcmFtZXRlcnMgPSBVUkxQYXJzZXI6OnBhcnNlVVJMRW5jb2RlZEZvcm0ocXVl cnkoKSk7CisgICAgYXV0byBvdGhlclF1ZXJ5UGFyYW1ldGVycyA9IFVSTFBhcnNlcjo6cGFyc2VV UkxFbmNvZGVkRm9ybShvdGhlclVSTC5xdWVyeSgpKTsKKyAgICBpZiAodGhpc1F1ZXJ5UGFyYW1l dGVycy5pc0VtcHR5KCkgJiYgb3RoZXJRdWVyeVBhcmFtZXRlcnMuaXNFbXB0eSgpKQorICAgICAg ICByZXR1cm4geyB9OworICAgIAorICAgIGlmICh0aGlzUXVlcnlQYXJhbWV0ZXJzLmlzRW1wdHko KSkKKyAgICAgICAgcmV0dXJuIG90aGVyUXVlcnlQYXJhbWV0ZXJzOworCisgICAgaWYgKG90aGVy UXVlcnlQYXJhbWV0ZXJzLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIHRoaXNRdWVyeVBhcmFt ZXRlcnM7CisKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gZGlmZmVy aW5nUXVlcnlQYXJhbWV0ZXJzOworICAgIEhhc2hNYXA8S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPiwgaW50PiBmcmVxdWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVyOworICAgIGZvciAoYXV0byYg a2V5VmFsdWUgOiB0aGlzUXVlcnlQYXJhbWV0ZXJzKSB7CisgICAgICAgIGlmICghZnJlcXVlbmN5 T2ZEaXN0aW5jdFBhcmFtZXRlci5jb250YWlucyhrZXlWYWx1ZSkpCisgICAgICAgICAgICBmcmVx dWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVyLmFkZChrZXlWYWx1ZSwgMSk7CisgICAgICAgIGVsc2UK KyAgICAgICAgICAgIGZyZXF1ZW5jeU9mRGlzdGluY3RQYXJhbWV0ZXIuc2V0KGtleVZhbHVlLCBm cmVxdWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVyLmdldChrZXlWYWx1ZSkgKyAxKTsKKyAgICB9Cisg ICAgCisgICAgZm9yIChhdXRvJiBzaW5nbGVRdWVyeVBhcmFtZXRlciA6IG90aGVyUXVlcnlQYXJh bWV0ZXJzKSB7CisgICAgICAgIGlmICghZnJlcXVlbmN5T2ZEaXN0aW5jdFBhcmFtZXRlci5jb250 YWlucyhzaW5nbGVRdWVyeVBhcmFtZXRlcikpCisgICAgICAgICAgICBkaWZmZXJpbmdRdWVyeVBh cmFtZXRlcnMuYXBwZW5kKHNpbmdsZVF1ZXJ5UGFyYW1ldGVyKTsKKyAgICAgICAgZWxzZSB7Cisg ICAgICAgICAgICBpZiAoIWZyZXF1ZW5jeU9mRGlzdGluY3RQYXJhbWV0ZXIuZ2V0KHNpbmdsZVF1 ZXJ5UGFyYW1ldGVyKSkKKyAgICAgICAgICAgICAgICBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMu YXBwZW5kKHNpbmdsZVF1ZXJ5UGFyYW1ldGVyKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAg ICAgICAgICBmcmVxdWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVyLnNldChzaW5nbGVRdWVyeVBhcmFt ZXRlciwgZnJlcXVlbmN5T2ZEaXN0aW5jdFBhcmFtZXRlci5nZXQoc2luZ2xlUXVlcnlQYXJhbWV0 ZXIpIC0gMSk7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBmb3IgKGF1dG8mIHNpbmdsZVF1ZXJ5 UGFyYW1ldGVyIDogdGhpc1F1ZXJ5UGFyYW1ldGVycykgeworICAgICAgICBpZiAoZnJlcXVlbmN5 T2ZEaXN0aW5jdFBhcmFtZXRlci5nZXQoc2luZ2xlUXVlcnlQYXJhbWV0ZXIpKSB7CisgICAgICAg ICAgICBmb3IgKGludCBpID0gMDsgaSA8IGZyZXF1ZW5jeU9mRGlzdGluY3RQYXJhbWV0ZXIuZ2V0 KHNpbmdsZVF1ZXJ5UGFyYW1ldGVyKTsgaSsrKQorICAgICAgICAgICAgICAgIGRpZmZlcmluZ1F1 ZXJ5UGFyYW1ldGVycy5hcHBlbmQoc2luZ2xlUXVlcnlQYXJhbWV0ZXIpOworICAgICAgICAgICAg CisgICAgICAgICAgICBmcmVxdWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVyLnNldChzaW5nbGVRdWVy eVBhcmFtZXRlciwgMCk7CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAgcmV0dXJuIGRpZmZl cmluZ1F1ZXJ5UGFyYW1ldGVyczsKK30KKworYm9vbCBVUkw6OmlzRXF1YWxJZ25vcmluZ1F1ZXJ5 QW5kRnJhZ21lbnRzKGNvbnN0IFVSTCYgb3RoZXJVUkwpIGNvbnN0Cit7CisgICAgaWYgKCFtX2lz VmFsaWQgfHwgIW90aGVyVVJMLm1faXNWYWxpZCkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IAorICAgIGF1dG8gdGhpc1BhdGhMZW5ndGggPSBtX3N0cmluZ1ttX3BhdGhFbmQgLSAxXSA9PSAn LycgPyBtX3BhdGhFbmQgLSAxIDogbV9wYXRoRW5kOworICAgIGF1dG8gb3RoZXJQYXRoTGVuZ3Ro ID0gb3RoZXJVUkwubV9zdHJpbmdbb3RoZXJVUkwubV9wYXRoRW5kIC0gMV0gPT0gJy8nID8gIG90 aGVyVVJMLm1fcGF0aEVuZCAtIDEgOiBvdGhlclVSTC5tX3BhdGhFbmQ7CisgICAgCisgICAgcmV0 dXJuIFN0cmluZ1ZpZXcobV9zdHJpbmcpLnN1YnN0cmluZygwLCB0aGlzUGF0aExlbmd0aCkgPT0g U3RyaW5nVmlldyhvdGhlclVSTC5tX3N0cmluZykuc3Vic3RyaW5nKDAsIG90aGVyUGF0aExlbmd0 aCk7Cit9CisKK2Jvb2wgVVJMOjpjb250YWluc1NhbWVRdWVyeVBhcmFtZXRlcnMoY29uc3QgVVJM JiBvdGhlclVSTCkgY29uc3QKK3sKKyAgICBpZiAoIW1faXNWYWxpZCB8fCAhb3RoZXJVUkwubV9p c1ZhbGlkKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgCisgICAgYXV0byBxdWVyeURpZmZl cmVuY2UgPSBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMob3RoZXJVUkwpOworICAgIGlmIChxdWVy eURpZmZlcmVuY2UuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAKKyAgICBy ZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgVVJMOjpyZW1vdmVRdWVyeVBhcmFtZXRlcnMoY29uc3Qg SGFzaFNldDxTdHJpbmc+JiBrZXlzVG9SZW1vdmUpCit7CisgICAgaWYgKGtleXNUb1JlbW92ZS5p c0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBhdXRvIHF1ZXJ5UGFyYW1ldGVy c0xpc3QgPSBVUkxQYXJzZXI6OnBhcnNlVVJMRW5jb2RlZEZvcm0ocXVlcnkoKSk7CisgICAgaWYg KHF1ZXJ5UGFyYW1ldGVyc0xpc3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisgICAgCisg ICAgU3RyaW5nIHF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzOworICAgIGZvciAoYXV0byYgc2luZ2xl UXVlcnlQYXJhbWV0ZXIgOiBxdWVyeVBhcmFtZXRlcnNMaXN0KSB7CisgICAgICAgIGlmIChrZXlz VG9SZW1vdmUuZmluZChzaW5nbGVRdWVyeVBhcmFtZXRlci5rZXkpID09IGtleXNUb1JlbW92ZS5l bmQoKSkKKyAgICAgICAgICAgIHF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzID0gbWFrZVN0cmluZyhx dWVyeVdpdGhvdXRSZW1vdmFsS2V5cywgc2luZ2xlUXVlcnlQYXJhbWV0ZXIua2V5LCAnPScsIHNp bmdsZVF1ZXJ5UGFyYW1ldGVyLnZhbHVlLCAnJicpOworICAgICAgICAKKyAgICB9CisgICAgCisg ICAgaWYgKCFxdWVyeVdpdGhvdXRSZW1vdmFsS2V5cy5pc0VtcHR5KCkpCisgICAgICAgIHF1ZXJ5 V2l0aG91dFJlbW92YWxLZXlzID0gcXVlcnlXaXRob3V0UmVtb3ZhbEtleXMuc3Vic3RyaW5nKDAs IHF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzLmxlbmd0aCgpIC0gMSk7CisgICAgCisgICAgc2V0UXVl cnkoU3RyaW5nVmlldyhxdWVyeVdpdGhvdXRSZW1vdmFsS2V5cykpOworfQorCiB9IC8vIG5hbWVz cGFjZSBXVEYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5oIGIvU291cmNlL1dURi93 dGYvVVJMLmgKaW5kZXggZjQ0NTQyMWUxZmUyM2NhYmI2MTU3ZjcwZDljNDQ2YTI4NmM1ZjA1Ni4u ZGIyNmVkNTEyZWRmZjVjYWNhM2U2YmYwYTZlNjRhNDQ1NjgwN2Y3NyAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi93dGYvVVJMLmgKKysrIGIvU291cmNlL1dURi93dGYvVVJMLmgKQEAgLTIwMCw2ICsy MDAsMTEgQEAgcHVibGljOgogICAgIHRlbXBsYXRlPHR5cGVuYW1lIERlY29kZXI+IHN0YXRpYyBz dGQ6Om9wdGlvbmFsPFVSTD4gZGVjb2RlKERlY29kZXImKTsKIAogICAgIFdURl9FWFBPUlRfUFJJ VkFURSBib29sIGhhc1NwZWNpYWxTY2hlbWUoKSBjb25zdDsKKyAgICAKKyAgICBXVEZfRVhQT1JU X1BSSVZBVEUgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IGRpZmZlcmluZ1F1 ZXJ5UGFyYW1ldGVycyhjb25zdCBVUkwmKSBjb25zdDsKKyAgICBXVEZfRVhQT1JUX1BSSVZBVEUg Ym9vbCBpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyhjb25zdCBVUkwmKSBjb25zdDsK KyAgICBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBjb250YWluc1NhbWVRdWVyeVBhcmFtZXRlcnMo Y29uc3QgVVJMJikgY29uc3Q7CisgICAgV1RGX0VYUE9SVF9QUklWQVRFIHZvaWQgcmVtb3ZlUXVl cnlQYXJhbWV0ZXJzKGNvbnN0IEhhc2hTZXQ8U3RyaW5nPiYpOwogCiBwcml2YXRlOgogICAgIGZy aWVuZCBjbGFzcyBVUkxQYXJzZXI7CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29s cy9DaGFuZ2VMb2cKaW5kZXggYTY2YTI0ZmU0NzlmMWU5NDI3Zjc5ZDI3N2JkMTRlZTg5MGU3ZmIz Yy4uZDNlMzQzMzE2ODg3NGE2MDRjZjEwNGMxOWNjZjVhODFiOWMzZWI3YiAxMDA2NDQKLS0tIGEv VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisy MDIxLTA3LTMwICBSaXN1bCBJc2xhbSAgPHJpc3VsX2lzbGFtQGFwcGxlLmNvbT4KKworICAgICAg ICBFeHBhbmQgVVJMIGNsYXNzIHF1ZXJ5IHBhcmFtZXRlciBmdW5jdGlvbnMKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyODEyMgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAgICAKKyAgICAgICAgQWRkZWQgdGhlIHRl c3QgZnVuY3Rpb25zIHJlcXVpcmVkIGZvciBVUkwgcXVlcnkgcGFyYW1ldGVyIHBhcnQgcGFyc2lu Zy4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHA6CisgICAgICAg IChUZXN0V2ViS2l0QVBJOjpURVNUX0YpOgorCiAyMDIxLTA3LTE5ICBSeWFuIEhhZGRhZCAgPHJ5 YW5oYWRkYWRAYXBwbGUuY29tPgogCiAgICAgICAgIFtidWlsZC53ZWJraXQub3JnXSBsbGRiLXdl YmtpdC10ZXN0IGlzIGZhaWxpbmcgb24gQ2F0YWxpbmEgcXVldWVzCmRpZmYgLS1naXQgYS9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XVEYvVVJMLmNwcAppbmRleCBlZThjZTE5MjU1OTEzMTIyNjM0MzZiYjJlMWFiYmExZDdm ZDc4Mzg2Li5iYTNiMDQyYWQ5ZTk5NWU4ZGE0YTFkYmFiOTRiYjZjMjBlMjA2N2QzIDEwMDY0NAot LS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwCisrKyBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHAKQEAgLTI1LDEwICsyNSwxMiBAQAogCiAjaW5j bHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV1RGU3RyaW5nVXRpbGl0aWVzLmgiCisjaW5jbHVk ZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgogI2luY2x1ZGUg PHd0Zi9TdHJpbmdQcmludFN0cmVhbS5oPgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4KICNpbmNsdWRl IDx3dGYvVVJMUGFyc2VyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCiBu YW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CiAKQEAgLTM1Nyw0ICszNTksMTU5IEBAIFRFU1RfRihX VEZfVVJMLCBQcmludFN0cmVhbSkKICAgICBFWFBFQ1RfRVEob3V0LnRvU3RyaW5nKCksIHVybFN0 cmluZyk7CiB9CiAKK1RFU1RfRihXVEZfVVJMLCBVUkxEaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMp Cit7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8iKTsKKyAgICBV UkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsK KyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvciB7IH07 CisgICAgRVhQRUNUX0VRKHVybDEuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIpLCB0ZXN0 VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtp dC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9FUSh1cmwuZGlmZmVyaW5nUXVlcnlQYXJh bWV0ZXJzKHVybCksIHRlc3RWZWN0b3IpOworICAgIAorICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJM KCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwxMCA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1Rf RVEodXJsOS5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTApICwgdGVzdFZlY3Rvcik7Cisg ICAgCisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7 CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7Cisg ICAgRVhQRUNUX0VRKHVybDcuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDgpLCB0ZXN0VmVj dG9yKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQu b3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3Jn Lz9rZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4g dGVzdFZlY3RvcjM0IHt7ImtleTEiLCAidmFsMSJ9fTsKKyAgICBFWFBFQ1RfRVEodXJsMy5kaWZm ZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsNCksIHRlc3RWZWN0b3IzNCk7CisgICAgCisgICAgVVJM IHVybDUgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7Cisg ICAgVVJMIHVybDYgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAg VmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3I1NiB7eyJrZXkx IiwgInZhbDEifX07CisgICAgRVhQRUNUX0VRKHVybDUuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJz KHVybDYpLCB0ZXN0VmVjdG9yNTYpOworICAgIAorICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5Mj12YWwyIik7CisgICAgVVJMIHVy bDE0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkxPXZh bDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3Rv cjEzMTQge3sia2V5MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2YWwyIn19OworICAgIEVYUEVDVF9F USh1cmwxMy5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTQpLCB0ZXN0VmVjdG9yMTMxNCk7 CisgICAgCisgICAgVVJMIHVybDE1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcv P2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwxNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz9rZXkyPXZhbDIiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPj4gdGVzdFZlY3RvcjE1MTYge3sia2V5MiIsICJ2YWwyIn0sIHsia2V5MSIsICJ2YWwxIn19 OworICAgIEVYUEVDVF9FUSh1cmwxNS5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTYpLCB0 ZXN0VmVjdG9yMTUxNik7CisgICAgCisgICAgVVJMIHVybDExID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkyPXZhbDIiKTsKKyAgICBVUkwgdXJsMTIgPSBj cmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTM9dmFsMyIpOwor ICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTExMiB7 eyJrZXkzIiwgInZhbDMifSwgeyJrZXkyIiwgInZhbDIifX07CisgICAgRVhQRUNUX0VRKHVybDEx LmRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwxMiksIHRlc3RWZWN0b3IxMTEyKTsKKyAgICAK KyAgICBVUkwgdXJsMTcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12 YWwxJmtleTI9dmFsMiIpOworICAgIFVSTCB1cmwxOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkxJmtleTM9dmFsMyIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3Ry aW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTcxOCB7eyJrZXkxIiwgIiJ9LCB7ImtleTMiLCAidmFs MyJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEo dXJsMTcuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDE4KSwgdGVzdFZlY3RvcjE3MTgpOwor ICAgIAorICAgIFVSTCB1cmwxOSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9r ZXkxPXZhbDEma2V5MT12YWwxJmtleTI9dmFsMiIpOworICAgIFVSTCB1cmwyMCA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9dmFsMyIpOworICAgIFZlY3RvcjxL ZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTkyMCB7eyJrZXkxIiwgIiJ9 LCB7ImtleTMiLCAidmFsMyJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7 ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEodXJsMTkuZGlmZmVyaW5nUXVlcnlQYXJh bWV0ZXJzKHVybDIwKSwgdGVzdFZlY3RvcjE5MjApOworfQorCitURVNUX0YoV1RGX1VSTCwgVVJM SXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMpCit7CisgICAgVVJMIHVybDEgPSBjcmVh dGVVUkwoInd3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfRkFMU0UodXJsMS5p c0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwyKSk7CisKKyAgICBVUkwgdXJsID0g Y3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVD VF9UUlVFKHVybC5pc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwpKTsKKyAgICAK KyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAg ICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEi KTsKKyAgICBFWFBFQ1RfVFJVRSh1cmwzLmlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRz KHVybDQpKTsKKyAgICAKKyAgICBVUkwgdXJsNyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnPyIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKHVybDcuaXNFcXVhbElnbm9yaW5nUXVl cnlBbmRGcmFnbWVudHModXJsOCkpOworICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJo dHRwOi8vd3d3LmV4YW1wbGUub3JnL3BhdGg/Iik7CisgICAgVVJMIHVybDYgPSBjcmVhdGVVUkwo Imh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0ZBTFNFKHVy bDUuaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsNikpOworfQorCitURVNUX0Yo V1RGX1VSTCwgVVJMQ29udGFpbnNTYW1lUXVlcnlQYXJhbWV0ZXJzKQoreworICAgIFVSTCB1cmwx ID0gY3JlYXRlVVJMKCJ3d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDIgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0ZBTFNF KHVybDEuY29udGFpbnNTYW1lUXVlcnlQYXJhbWV0ZXJzKHVybDIpKTsKKyAgICAKKyAgICBVUkwg dXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAg IEVYUEVDVF9UUlVFKHVybC5jb250YWluc1NhbWVRdWVyeVBhcmFtZXRlcnModXJsKSk7CisgICAg CisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cuZXhhbXBsZS5vcmc/a2V5MT12 YWwxIik7CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5MT12YWwxIik7CisgICAgRVhQRUNUX1RSVUUodXJsNy5jb250YWluc1NhbWVRdWVyeVBhcmFt ZXRlcnModXJsOCkpOworICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvcGF0aD8iKTsKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz8iKTsKKyAgICBFWFBFQ1RfVFJVRSh1cmw1LmNvbnRhaW5zU2FtZVF1ZXJ5 UGFyYW1ldGVycyh1cmw2KSk7CisgICAgCisgICAgVVJMIHVybDMgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDQgPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0ZBTFNFKHVybDMuY29udGFp bnNTYW1lUXVlcnlQYXJhbWV0ZXJzKHVybDQpKTsKKyAgICAKKyAgICBVUkwgdXJsOSA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnL3BhdGg/a2V5MT12YWwxIik7CisgICAgVVJMIHVy bDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkyPXZh bDIiKTsKKyAgICBFWFBFQ1RfRkFMU0UodXJsOS5jb250YWluc1NhbWVRdWVyeVBhcmFtZXRlcnMo dXJsMTApKTsKKyAgICAKKyAgICBVUkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0dHA6Ly9leGFtcGxl LmNvbS8/YT1iJmM9ZCIpOworICAgIFVSTCB1cmwxMiA9IGNyZWF0ZVVSTCgiaHR0cDovL2V4YW1w bGUuY29tLz9jPWQmYT1iIik7CisgICAgRVhQRUNUX1RSVUUodXJsMTEuY29udGFpbnNTYW1lUXVl cnlQYXJhbWV0ZXJzKHVybDEyKSk7Cit9CisKK1RFU1RfRihXVEZfVVJMLCBVUkxSZW1vdmVRdWVy eVBhcmFtZXRlcnMpCit7CisgICAgVVJMIHVybCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz9rZXk9dmFsIik7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsI2ZyYWdtZW50Iik7CisgICAgVVJMIHVybDQg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXk9dmFsI2ZyYWdt ZW50Iik7CisgICAgVVJMIHVybDUgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5JmtleT0jZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLyNmcmFnbWVudCIpOworICAgIFVSTCB1cmw3ID0gY3JlYXRlVVJMKCJodHRw Oi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsOCA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsOSA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLyNmcmFnbWVudCIpOworICAgIFVSTCB1cmwxMCA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsI2ZyYWdtZW50Iik7Cisg ICAgVVJMIHVybDExID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwm a2V5MT12YWwxI2ZyYWdtZW50Iik7CisgICAgVVJMIHVybDEyID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvP2tleT12YWwma2V5MT12YWwxI2ZyYWdtZW50Iik7CisgICAgCisgICAg SGFzaFNldDxTdHJpbmc+IGtleVJlbW92YWxTZXQxIHsia2V5In07CisgICAgSGFzaFNldDxTdHJp bmc+IGtleVJlbW92YWxTZXQyIHsia2V5MSJ9OworICAgIEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1v dmFsU2V0MyB7ImtleTIifTsKKyAgICBIYXNoU2V0PFN0cmluZz4ga2V5UmVtb3ZhbFNldDQgeyJr ZXkiLCAia2V5MSJ9OworCisgICAgdXJsMS5yZW1vdmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVtb3Zh bFNldDIpOworICAgIEVYUEVDVF9FUSh1cmwuc3RyaW5nKCksIHVybDEuc3RyaW5nKCkpOworICAg IAorICAgIHVybDIucmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKGtleVJlbW92YWxTZXQxKTsKKyAgICBF WFBFQ1RfRVEodXJsOC5zdHJpbmcoKSwgdXJsMi5zdHJpbmcoKSk7CisgICAgCisgICAgdXJsMy5y ZW1vdmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVtb3ZhbFNldDEpOworICAgIEVYUEVDVF9FUSh1cmw2 LnN0cmluZygpLCB1cmwzLnN0cmluZygpKTsKKyAgICAKKyAgICB1cmw0LnJlbW92ZVF1ZXJ5UGFy YW1ldGVycyhrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDYuc3RyaW5nKCksIHVy bDQuc3RyaW5nKCkpOworICAgIAorICAgIHVybDUucmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKGtleVJl bW92YWxTZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJsNi5zdHJpbmcoKSwgdXJsNS5zdHJpbmcoKSk7 CisgICAgCisgICAgdXJsNi5yZW1vdmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVtb3ZhbFNldDEpOwor ICAgIEVYUEVDVF9FUSh1cmw5LnN0cmluZygpLCB1cmw2LnN0cmluZygpKTsKKyAgICAKKyAgICB1 cmw3LnJlbW92ZVF1ZXJ5UGFyYW1ldGVycyhrZXlSZW1vdmFsU2V0Mik7CisgICAgRVhQRUNUX0VR KHVybDEwLnN0cmluZygpLCB1cmw3LnN0cmluZygpKTsKKyAgICAKKyAgICB1cmwxMS5yZW1vdmVR dWVyeVBhcmFtZXRlcnMoa2V5UmVtb3ZhbFNldDMpOworICAgIEVYUEVDVF9FUSh1cmwxMi5zdHJp bmcoKSwgdXJsMTEuc3RyaW5nKCkpOworICAgIAorICAgIHVybDEyLnJlbW92ZVF1ZXJ5UGFyYW1l dGVycyhrZXlSZW1vdmFsU2V0NCk7CisgICAgRVhQRUNUX0VRKHVybDkuc3RyaW5nKCksIHVybDEy LnN0cmluZygpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQo= 434669 2021-07-30 16:05:10 -0700 2021-08-01 21:44:45 -0700 Patch bug-228122-20210730160509.patch text/plain 17685 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLjZhN2IzNWRkZGUzYjRjZDkxZTMyMTJhY2M2M2VhMDllMjBhZWFl ZDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMjEtMDctMzAgIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEV4cGFuZCBVUkwgY2xhc3MgcXVlcnkgcGFyYW1l dGVyIGZ1bmN0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAg ICAgIAorICAgICAgICBBZGRlZCBtb3JlIGZ1bmN0aW9uYWxpdGllcyBmb3IgcGFyc2luZyBVUkwg cXVlcnkgcGFyYW1ldGVycy4KKyAgICAgICAgCisgICAgICAgICogd3RmL0hhc2hGdW5jdGlvbnMu aDoKKyAgICAgICAgKFdURjo6S2V5VmFsdWVQYWlySGFzaDo6aGFzaCk6CisgICAgICAgIChXVEY6 OktleVZhbHVlUGFpckhhc2g6OmVxdWFsKToKKyAgICAgICAgKiB3dGYvSGFzaFRyYWl0cy5oOgor ICAgICAgICAqIHd0Zi9LZXlWYWx1ZVBhaXIuaDoKKyAgICAgICAgKFdURjo6S2V5VmFsdWVQYWly OjpvcGVyYXRvcj09IGNvbnN0KToKKyAgICAgICAgKiB3dGYvVVJMLmNwcDoKKyAgICAgICAgKFdU Rjo6VVJMOjpxdWVyeVBhcmFtZXRlcnMgY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OmRpZmZl cmluZ1F1ZXJ5UGFyYW1ldGVycyBjb25zdCk6CisgICAgICAgIChXVEY6OlVSTDo6aXNFcXVhbEln bm9yaW5nUXVlcnkgY29uc3QpOgorICAgICAgICAoV1RGOjpVUkw6OmlzUXVlcnlFcXVhbCBjb25z dCk6CisgICAgICAgIChXVEY6OlVSTDo6cmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKToKKyAgICAgICAg KiB3dGYvVVJMLmg6CisKIDIwMjEtMDctMTYgIEFsZXhhbmRlciBNaWtoYXlsZW5rbyAgPGFsZXht QGdub21lLm9yZz4KIAogICAgICAgICBbR1RLXVtXUEVdIFN1cHBvcnQgY29sb3Itc2NoZW1lcyBD U1MgcHJvcGVydHkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0hhc2hGdW5jdGlvbnMuaCBi L1NvdXJjZS9XVEYvd3RmL0hhc2hGdW5jdGlvbnMuaAppbmRleCBmZmQ1MjJjZTI5MDhkN2ZlZTcy YWJiMDQ2MTRhYWY0NDEwNWI2YjY3Li44YTBjN2ExNjYwOTU0NzFiNzA0MjZkZmY0ZTY0NTkwMzI2 ZTliMDg0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoRnVuY3Rpb25zLmgKKysrIGIv U291cmNlL1dURi93dGYvSGFzaEZ1bmN0aW9ucy5oCkBAIC0xNjksNiArMTY5LDE4IEBAIG5hbWVz cGFjZSBXVEYgewogICAgICAgICBzdGF0aWMgY29uc3RleHByIGJvb2wgc2FmZVRvQ29tcGFyZVRv RW1wdHlPckRlbGV0ZWQgPSBEZWZhdWx0SGFzaDxUPjo6c2FmZVRvQ29tcGFyZVRvRW1wdHlPckRl bGV0ZWQgJiYgRGVmYXVsdEhhc2g8VT46OnNhZmVUb0NvbXBhcmVUb0VtcHR5T3JEZWxldGVkOwog ICAgIH07CiAKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBzdHJ1Y3QgS2V5 VmFsdWVQYWlySGFzaCB7CisgICAgICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IEtleVZh bHVlUGFpcjxULCBVPiYgcCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIHBhaXJJbnRI YXNoKERlZmF1bHRIYXNoPFQ+OjpoYXNoKHAua2V5KSwgRGVmYXVsdEhhc2g8VT46Omhhc2gocC52 YWx1ZSkpOworICAgICAgICB9CisgICAgICAgIHN0YXRpYyBib29sIGVxdWFsKGNvbnN0IEtleVZh bHVlUGFpcjxULCBVPiYgYSwgY29uc3QgS2V5VmFsdWVQYWlyPFQsIFU+JiBiKQorICAgICAgICB7 CisgICAgICAgICAgICByZXR1cm4gRGVmYXVsdEhhc2g8VD46OmVxdWFsKGEua2V5LCBiLmtleSkg JiYgRGVmYXVsdEhhc2g8VT46OmVxdWFsKGEudmFsdWUsIGIudmFsdWUpOworICAgICAgICB9Cisg ICAgICAgIHN0YXRpYyBjb25zdGV4cHIgYm9vbCBzYWZlVG9Db21wYXJlVG9FbXB0eU9yRGVsZXRl ZCA9IERlZmF1bHRIYXNoPFQ+OjpzYWZlVG9Db21wYXJlVG9FbXB0eU9yRGVsZXRlZCAmJiBEZWZh dWx0SGFzaDxVPjo6c2FmZVRvQ29tcGFyZVRvRW1wdHlPckRlbGV0ZWQ7CisgICAgfTsKKwogICAg IHRlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IHN0cnVjdCBJbnRQYWlySGFzaCB7CiAg ICAgICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IHN0ZDo6cGFpcjxULCBVPiYgcCkgeyBy ZXR1cm4gcGFpckludEhhc2gocC5maXJzdCwgcC5zZWNvbmQpOyB9CiAgICAgICAgIHN0YXRpYyBi b29sIGVxdWFsKGNvbnN0IHN0ZDo6cGFpcjxULCBVPiYgYSwgY29uc3Qgc3RkOjpwYWlyPFQsIFU+ JiBiKSB7IHJldHVybiBQYWlySGFzaDxULCBUPjo6ZXF1YWwoYSwgYik7IH0KQEAgLTI2Nyw2ICsy NzksNyBAQCBuYW1lc3BhY2UgV1RGIHsKIAogICAgIC8vIG1ha2UgUGFpckhhc2ggdGhlIGRlZmF1 bHQgaGFzaCBmdW5jdGlvbiBmb3IgcGFpcnMgb2YgYXJiaXRyYXJ5IHZhbHVlcy4KIAorICAgIHRl bXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IHN0cnVjdCBEZWZhdWx0SGFzaDxLZXlWYWx1 ZVBhaXI8VCwgVT4+IDogS2V5VmFsdWVQYWlySGFzaDxULCBVPiB7IH07CiAgICAgdGVtcGxhdGU8 dHlwZW5hbWUgVCwgdHlwZW5hbWUgVT4gc3RydWN0IERlZmF1bHRIYXNoPHN0ZDo6cGFpcjxULCBV Pj4gOiBQYWlySGFzaDxULCBVPiB7IH07CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUuLi4gVHlwZXM+ IHN0cnVjdCBEZWZhdWx0SGFzaDxzdGQ6OnR1cGxlPFR5cGVzLi4uPj4gOiBUdXBsZUhhc2g8VHlw ZXMuLi4+IHsgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvSGFzaFRyYWl0cy5oIGIv U291cmNlL1dURi93dGYvSGFzaFRyYWl0cy5oCmluZGV4IDc1MjQ4MWIzZmZjMTMxNWM1NjhhMjNj ZWQ3ZWQ2N2U1ZjE0YmJkOGYuLjIxMTJhNDk2MmZmODE5MjMyZDhjZGRkMTBlZWMwNGE3MDk1ODM0 ZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0hhc2hUcmFpdHMuaAorKysgYi9Tb3VyY2Uv V1RGL3d0Zi9IYXNoVHJhaXRzLmgKQEAgLTQyOCw2ICs0MjgsNyBAQCBzdHJ1Y3QgQ3VzdG9tSGFz aFRyYWl0cyA6IHB1YmxpYyBHZW5lcmljSGFzaFRyYWl0czxUPiB7CiAKIHVzaW5nIFdURjo6SGFz aFRyYWl0czsKIHVzaW5nIFdURjo6S2V5VmFsdWVQYWlyOwordXNpbmcgV1RGOjpLZXlWYWx1ZVBh aXJIYXNoVHJhaXRzOwogdXNpbmcgV1RGOjpQYWlySGFzaFRyYWl0czsKIHVzaW5nIFdURjo6TnVs bGFibGVIYXNoVHJhaXRzOwogdXNpbmcgV1RGOjpTaW1wbGVDbGFzc0hhc2hUcmFpdHM7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9LZXlWYWx1ZVBhaXIuaCBiL1NvdXJjZS9XVEYvd3RmL0tl eVZhbHVlUGFpci5oCmluZGV4IGIxYzJiYzM2ODM1ZGU2ZDBiZDQxMTc5MzViOTVkMmEwMmNhYjA4 ZTIuLmZjM2QwNDc4MGFjYzgwY2I5OWJhNmQwYWU4M2U4NDhiNDFhOTVmMTIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0tleVZh bHVlUGFpci5oCkBAIC02MCw2ICs2MCwxMiBAQCBzdHJ1Y3QgS2V5VmFsdWVQYWlyIHsKICAgICB7 CiAgICAgfQogCisgICAgdGVtcGxhdGUgPHR5cGVuYW1lIEssIHR5cGVuYW1lIFY+CisgICAgYm9v bCBvcGVyYXRvcj09KGNvbnN0IEtleVZhbHVlUGFpcjxLLCBWPiYgb3RoZXIpIGNvbnN0CisgICAg eworICAgICAgICByZXR1cm4ga2V5ID09IG90aGVyLmtleSAmJiB2YWx1ZSA9PSBvdGhlci52YWx1 ZTsKKyAgICB9CisKICAgICBLZXlUeXBlIGtleTsKICAgICBWYWx1ZVR5cGUgdmFsdWUgeyB9Owog fTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9V UkwuY3BwCmluZGV4IGQ5YzA4MmNlYzY5YTVkODQ4ZDAzZDE2ZTA4OTRhOGNiNzJhNWE1ZGIuLmNl ZjhjNTIwMzI4NGY0ZDJlMjlkNzAyMzgyODgxMDEzNDI2NjcyYWIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvd3RmL1VSTC5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVVJMLmNwcApAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVkZSA8dW5pY29kZS91aWRuYS5oPgog I2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNs dWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgogI2luY2x1 ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgpAQCAtMTE2Niw0ICsxMTY3LDg3IEBAIGJvb2wgVVJMOjpo b3N0SXNJUEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQogCiAjZW5kaWYKIAorVmVjdG9yPEtleVZh bHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IFVSTDo6ZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKGNv bnN0IFVSTCYgb3RoZXJVUkwpIGNvbnN0Cit7CisgICAgaWYgKCFtX2lzVmFsaWQgfHwgIW90aGVy VVJMLm1faXNWYWxpZCkKKyAgICAgICAgcmV0dXJuIHsgfTsKKyAgICAKKyAgICBhdXRvIHRoaXNR dWVyeVBhcmFtZXRlcnMgPSBVUkxQYXJzZXI6OnBhcnNlVVJMRW5jb2RlZEZvcm0ocXVlcnkoKSk7 CisgICAgYXV0byBvdGhlclF1ZXJ5UGFyYW1ldGVycyA9IFVSTFBhcnNlcjo6cGFyc2VVUkxFbmNv ZGVkRm9ybShvdGhlclVSTC5xdWVyeSgpKTsKKyAgICAKKyAgICBpZiAodGhpc1F1ZXJ5UGFyYW1l dGVycy5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiBvdGhlclF1ZXJ5UGFyYW1ldGVyczsKKwor ICAgIGlmIChvdGhlclF1ZXJ5UGFyYW1ldGVycy5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiB0 aGlzUXVlcnlQYXJhbWV0ZXJzOworCisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0 cmluZz4+IGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVyczsKKyAgICBIYXNoTWFwPEtleVZhbHVlUGFp cjxTdHJpbmcsIFN0cmluZz4sIHVuc2lnbmVkPiBmcmVxdWVuY3lPZkRpc3RpbmN0UGFyYW1ldGVy czsKKyAgICBmb3IgKGF1dG8mIHNpbmdsZVF1ZXJ5UGFyYW1ldGVyIDogdGhpc1F1ZXJ5UGFyYW1l dGVycykgeworICAgICAgICBhdXRvIGFkZFJlc3VsdCA9IGZyZXF1ZW5jeU9mRGlzdGluY3RQYXJh bWV0ZXJzLmFkZChzaW5nbGVRdWVyeVBhcmFtZXRlciwgMSk7CisgICAgICAgIGlmICghYWRkUmVz dWx0LmlzTmV3RW50cnkpCisgICAgICAgICAgICBhZGRSZXN1bHQuaXRlcmF0b3ItPnZhbHVlKys7 CisgICAgfQorCisgICAgZm9yIChhdXRvJiBzaW5nbGVRdWVyeVBhcmFtZXRlciA6IG90aGVyUXVl cnlQYXJhbWV0ZXJzKSB7CisgICAgICAgIGF1dG8gc2luZ2xlUXVlcnlQYXJhbWV0ZXJJdGVyYXRv ciA9IGZyZXF1ZW5jeU9mRGlzdGluY3RQYXJhbWV0ZXJzLmZpbmQoc2luZ2xlUXVlcnlQYXJhbWV0 ZXIpOworICAgICAgICBpZiAoc2luZ2xlUXVlcnlQYXJhbWV0ZXJJdGVyYXRvciA9PSBmcmVxdWVu Y3lPZkRpc3RpbmN0UGFyYW1ldGVycy5lbmQoKSkKKyAgICAgICAgICAgIGRpZmZlcmluZ1F1ZXJ5 UGFyYW1ldGVycy5hcHBlbmQoc2luZ2xlUXVlcnlQYXJhbWV0ZXIpOworICAgICAgICBlbHNlIHsK KyAgICAgICAgICAgIGlmICghc2luZ2xlUXVlcnlQYXJhbWV0ZXJJdGVyYXRvci0+dmFsdWUpCisg ICAgICAgICAgICAgICAgZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzLmFwcGVuZChzaW5nbGVRdWVy eVBhcmFtZXRlcik7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgc2luZ2xlUXVl cnlQYXJhbWV0ZXJJdGVyYXRvci0+dmFsdWUtLTsKKyAgICAgICAgfQorICAgIH0KKworICAgIGZv ciAoYXV0byYgc2luZ2xlUXVlcnlQYXJhbWV0ZXIgOiB0aGlzUXVlcnlQYXJhbWV0ZXJzKSB7Cisg ICAgICAgIGF1dG8gZnJlcXVlbmN5T2ZzaW5nbGVRdWVyeVBhcmFtZXRlciA9IGZyZXF1ZW5jeU9m RGlzdGluY3RQYXJhbWV0ZXJzLnRha2Uoc2luZ2xlUXVlcnlQYXJhbWV0ZXIpOworICAgICAgICBp ZiAoZnJlcXVlbmN5T2ZzaW5nbGVRdWVyeVBhcmFtZXRlcikgeworICAgICAgICAgICAgZm9yICh1 bnNpZ25lZCBpID0gMDsgaSA8IGZyZXF1ZW5jeU9mc2luZ2xlUXVlcnlQYXJhbWV0ZXI7IGkrKykK KyAgICAgICAgICAgICAgICBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMuYXBwZW5kKHNpbmdsZVF1 ZXJ5UGFyYW1ldGVyKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICByZXR1cm4gZGlmZmVy aW5nUXVlcnlQYXJhbWV0ZXJzOworfQorCitib29sIFVSTDo6aXNFcXVhbElnbm9yaW5nUXVlcnlB bmRGcmFnbWVudHMoY29uc3QgVVJMJiBvdGhlclVSTCkgY29uc3QKK3sKKyAgICBpZiAoIW1faXNW YWxpZCB8fCAhb3RoZXJVUkwubV9pc1ZhbGlkKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAg CisgICAgYXV0byB0aGlzTGVuZ3RoT2ZVUkxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzID0gbV9z dHJpbmdbbV9wYXRoRW5kIC0gMV0gPT0gJy8nID8gbV9wYXRoRW5kIC0gMSA6IG1fcGF0aEVuZDsK KyAgICBhdXRvIG90aGVyTGVuZ3RoT2ZVUkxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzID0gb3Ro ZXJVUkwubV9zdHJpbmdbb3RoZXJVUkwubV9wYXRoRW5kIC0gMV0gPT0gJy8nID8gIG90aGVyVVJM Lm1fcGF0aEVuZCAtIDEgOiBvdGhlclVSTC5tX3BhdGhFbmQ7CisgICAgcmV0dXJuIFN0cmluZ1Zp ZXcobV9zdHJpbmcpLnN1YnN0cmluZygwLCB0aGlzTGVuZ3RoT2ZVUkxJZ25vcmluZ1F1ZXJ5QW5k RnJhZ21lbnRzKSA9PSBTdHJpbmdWaWV3KG90aGVyVVJMLm1fc3RyaW5nKS5zdWJzdHJpbmcoMCwg b3RoZXJMZW5ndGhPZlVSTElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMpOworfQorCitib29sIFVS TDo6Y29udGFpbnNTYW1lUXVlcnlQYXJhbWV0ZXJzKGNvbnN0IFVSTCYgb3RoZXJVUkwpIGNvbnN0 Cit7CisgICAgaWYgKCFtX2lzVmFsaWQgfHwgIW90aGVyVVJMLm1faXNWYWxpZCkKKyAgICAgICAg cmV0dXJuIGZhbHNlOworICAgIAorICAgIGF1dG8gcXVlcnlEaWZmZXJlbmNlID0gZGlmZmVyaW5n UXVlcnlQYXJhbWV0ZXJzKG90aGVyVVJMKTsKKyAgICByZXR1cm4gcXVlcnlEaWZmZXJlbmNlLmlz RW1wdHkoKTsKK30KKwordm9pZCBVUkw6OnJlbW92ZVF1ZXJ5UGFyYW1ldGVycyhjb25zdCBIYXNo U2V0PFN0cmluZz4mIGtleXNUb1JlbW92ZSkKK3sKKyAgICBpZiAoa2V5c1RvUmVtb3ZlLmlzRW1w dHkoKSkKKyAgICAgICAgcmV0dXJuOworICAgIAorICAgIGF1dG8gcXVlcnlQYXJhbWV0ZXJzTGlz dCA9IFVSTFBhcnNlcjo6cGFyc2VVUkxFbmNvZGVkRm9ybShxdWVyeSgpKTsKKyAgICBTdHJpbmcg cXVlcnlXaXRob3V0UmVtb3ZhbEtleXM7CisgICAgZm9yIChhdXRvJiBzaW5nbGVRdWVyeVBhcmFt ZXRlciA6IHF1ZXJ5UGFyYW1ldGVyc0xpc3QpIHsKKyAgICAgICAgaWYgKGtleXNUb1JlbW92ZS5m aW5kKHNpbmdsZVF1ZXJ5UGFyYW1ldGVyLmtleSkgPT0ga2V5c1RvUmVtb3ZlLmVuZCgpKSB7Cisg ICAgICAgICAgICBpZiAoIXF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzLmlzRW1wdHkoKSkKKyAgICAg ICAgICAgICAgICBxdWVyeVdpdGhvdXRSZW1vdmFsS2V5cyA9IG1ha2VTdHJpbmcocXVlcnlXaXRo b3V0UmVtb3ZhbEtleXMsICcmJywgIHNpbmdsZVF1ZXJ5UGFyYW1ldGVyLmtleSwgJz0nLCBzaW5n bGVRdWVyeVBhcmFtZXRlci52YWx1ZSk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAg ICAgcXVlcnlXaXRob3V0UmVtb3ZhbEtleXMgPSBtYWtlU3RyaW5nKHNpbmdsZVF1ZXJ5UGFyYW1l dGVyLmtleSwgJz0nLCBzaW5nbGVRdWVyeVBhcmFtZXRlci52YWx1ZSk7CisgICAgICAgIH0KKyAg ICB9CisgICAgCisgICAgc2V0UXVlcnkoU3RyaW5nVmlldyhxdWVyeVdpdGhvdXRSZW1vdmFsS2V5 cykpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3Rm L1VSTC5oIGIvU291cmNlL1dURi93dGYvVVJMLmgKaW5kZXggZjQ0NTQyMWUxZmUyM2NhYmI2MTU3 ZjcwZDljNDQ2YTI4NmM1ZjA1Ni4uZGIyNmVkNTEyZWRmZjVjYWNhM2U2YmYwYTZlNjRhNDQ1Njgw N2Y3NyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVVJMLmgKKysrIGIvU291cmNlL1dURi93 dGYvVVJMLmgKQEAgLTIwMCw2ICsyMDAsMTEgQEAgcHVibGljOgogICAgIHRlbXBsYXRlPHR5cGVu YW1lIERlY29kZXI+IHN0YXRpYyBzdGQ6Om9wdGlvbmFsPFVSTD4gZGVjb2RlKERlY29kZXImKTsK IAogICAgIFdURl9FWFBPUlRfUFJJVkFURSBib29sIGhhc1NwZWNpYWxTY2hlbWUoKSBjb25zdDsK KyAgICAKKyAgICBXVEZfRVhQT1JUX1BSSVZBVEUgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcs IFN0cmluZz4+IGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyhjb25zdCBVUkwmKSBjb25zdDsKKyAg ICBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50 cyhjb25zdCBVUkwmKSBjb25zdDsKKyAgICBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBjb250YWlu c1NhbWVRdWVyeVBhcmFtZXRlcnMoY29uc3QgVVJMJikgY29uc3Q7CisgICAgV1RGX0VYUE9SVF9Q UklWQVRFIHZvaWQgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKGNvbnN0IEhhc2hTZXQ8U3RyaW5nPiYp OwogCiBwcml2YXRlOgogICAgIGZyaWVuZCBjbGFzcyBVUkxQYXJzZXI7CmRpZmYgLS1naXQgYS9U b29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYTY2YTI0ZmU0NzlmMWU5NDI3 Zjc5ZDI3N2JkMTRlZTg5MGU3ZmIzYy4uZDNlMzQzMzE2ODg3NGE2MDRjZjEwNGMxOWNjZjVhODFi OWMzZWI3YiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDE1IEBACisyMDIxLTA3LTMwICBSaXN1bCBJc2xhbSAgPHJpc3VsX2lzbGFt QGFwcGxlLmNvbT4KKworICAgICAgICBFeHBhbmQgVVJMIGNsYXNzIHF1ZXJ5IHBhcmFtZXRlciBm dW5jdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTIyODEyMgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAgICAK KyAgICAgICAgQWRkZWQgdGhlIHRlc3QgZnVuY3Rpb25zIHJlcXVpcmVkIGZvciBVUkwgcXVlcnkg cGFyYW1ldGVyIHBhcnQgcGFyc2luZy4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMv V1RGL1VSTC5jcHA6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUX0YpOgorCiAyMDIxLTA3 LTE5ICBSeWFuIEhhZGRhZCAgPHJ5YW5oYWRkYWRAYXBwbGUuY29tPgogCiAgICAgICAgIFtidWls ZC53ZWJraXQub3JnXSBsbGRiLXdlYmtpdC10ZXN0IGlzIGZhaWxpbmcgb24gQ2F0YWxpbmEgcXVl dWVzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwIGIv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVVJMLmNwcAppbmRleCBlZThjZTE5MjU1OTEz MTIyNjM0MzZiYjJlMWFiYmExZDdmZDc4Mzg2Li5mZjk5NjU1ODQyNzUxY2U0MTljNzBlNTZhYTdh NDU3ZWE3NjU4M2ZlIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9V UkwuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHAKQEAgLTI1 LDEwICsyNSwxMiBAQAogCiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV1RGU3RyaW5n VXRpbGl0aWVzLmgiCisjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTWFp blRocmVhZC5oPgogI2luY2x1ZGUgPHd0Zi9TdHJpbmdQcmludFN0cmVhbS5oPgogI2luY2x1ZGUg PHd0Zi9VUkwuaD4KICNpbmNsdWRlIDx3dGYvVVJMUGFyc2VyLmg+CisjaW5jbHVkZSA8d3RmL3Rl eHQvU3RyaW5nSGFzaC5oPgogCiBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CiAKQEAgLTM1Nyw0 ICszNTksMTY3IEBAIFRFU1RfRihXVEZfVVJMLCBQcmludFN0cmVhbSkKICAgICBFWFBFQ1RfRVEo b3V0LnRvU3RyaW5nKCksIHVybFN0cmluZyk7CiB9CiAKK1RFU1RfRihXVEZfVVJMLCBVUkxEaWZm ZXJpbmdRdWVyeVBhcmFtZXRlcnMpCit7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53 ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPj4gdGVzdFZlY3RvciB7IH07CisgICAgRVhQRUNUX0VRKHVybDEuZGlmZmVyaW5nUXVlcnlQ YXJhbWV0ZXJzKHVybDIpLCB0ZXN0VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsID0gY3JlYXRl VVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9FUSh1 cmwuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybCksIHRlc3RWZWN0b3IpOworICAgIAorICAg IFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIp OworICAgIFVSTCB1cmwxMCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkx PXZhbDEiKTsKKyAgICBFWFBFQ1RfRVEodXJsOS5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJs MTApICwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZy8/Iik7CisgICAgRVhQRUNUX0VRKHVybDcuZGlmZmVyaW5nUXVlcnlQYXJh bWV0ZXJzKHVybDgpLCB0ZXN0VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQ YWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjM0IHt7ImtleTEiLCAidmFsMSJ9fTsKKyAg ICBFWFBFQ1RfRVEodXJsMy5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsNCksIHRlc3RWZWN0 b3IzNCk7CisgICAgCisgICAgVVJMIHVybDUgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZy8/a2V5MT12YWwxIik7CisgICAgVVJMIHVybDYgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZy8/Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+ IHRlc3RWZWN0b3I1NiB7eyJrZXkxIiwgInZhbDEifX07CisgICAgRVhQRUNUX0VRKHVybDUuZGlm ZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDYpLCB0ZXN0VmVjdG9yNTYpOworICAgIAorICAgIFVS TCB1cmwxMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5 Mj12YWwyIik7CisgICAgVVJMIHVybDE0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmcvP2tleTE9dmFsMSZrZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmlu ZywgU3RyaW5nPj4gdGVzdFZlY3RvcjEzMTQge3sia2V5MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2 YWwyIn19OworICAgIEVYUEVDVF9FUSh1cmwxMy5kaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJs MTQpLCB0ZXN0VmVjdG9yMTMxNCk7CisgICAgCisgICAgVVJMIHVybDE1ID0gY3JlYXRlVVJMKCJo dHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwxNiA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkyPXZhbDIiKTsKKyAgICBWZWN0b3I8S2V5 VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjE1MTYge3sia2V5MiIsICJ2YWwy In0sIHsia2V5MSIsICJ2YWwxIn19OworICAgIEVYUEVDVF9FUSh1cmwxNS5kaWZmZXJpbmdRdWVy eVBhcmFtZXRlcnModXJsMTYpLCB0ZXN0VmVjdG9yMTUxNik7CisgICAgCisgICAgVVJMIHVybDEx ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkyPXZhbDIi KTsKKyAgICBVUkwgdXJsMTIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5 MT12YWwxJmtleTM9dmFsMyIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJp bmc+PiB0ZXN0VmVjdG9yMTExMiB7eyJrZXkzIiwgInZhbDMifSwgeyJrZXkyIiwgInZhbDIifX07 CisgICAgRVhQRUNUX0VRKHVybDExLmRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwxMiksIHRl c3RWZWN0b3IxMTEyKTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTI9dmFsMiIpOworICAgIFVSTCB1cmwxOCA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9dmFsMyIpOworICAgIFZl Y3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTcxOCB7eyJrZXkx IiwgIiJ9LCB7ImtleTMiLCAidmFsMyJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFs MiJ9fTsKKyAgICBFWFBFQ1RfRVEodXJsMTcuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDE4 KSwgdGVzdFZlY3RvcjE3MTgpOworICAgIAorICAgIFVSTCB1cmwxOSA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5MT12YWwxJmtleTI9dmFsMiIpOworICAg IFVSTCB1cmwyMCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9 dmFsMyIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVj dG9yMTkyMCB7eyJrZXkxIiwgIiJ9LCB7ImtleTMiLCAidmFsMyJ9LCB7ImtleTEiLCAidmFsMSJ9 LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEodXJs MTkuZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIwKSwgdGVzdFZlY3RvcjE5MjApOworfQor CitURVNUX0YoV1RGX1VSTCwgVVJMSXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMpCit7 CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwg dXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAg ICBFWFBFQ1RfRkFMU0UodXJsMS5pc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwy KSk7CisKKyAgICBVUkwgdXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tl eTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKHVybC5pc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZy YWdtZW50cyh1cmwpKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRSh1cmwzLmlzRXF1YWxJZ25v cmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKHVybDQpKTsKKyAgICAKKyAgICBVUkwgdXJsNyA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnPyIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRlVVJM KCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKHVy bDcuaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsOCkpOworICAgIAorICAgIFVS TCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LmV4YW1wbGUub3JnL3BhdGg/Iik7CisgICAg VVJMIHVybDYgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7 CisgICAgRVhQRUNUX0ZBTFNFKHVybDUuaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMo dXJsNikpOworICAgIAorICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vZXhhbXBsZS5j b20/YT1iIik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vZXhhbXBsZS5jb20v P2E9YiIpOworICAgIEVYUEVDVF9UUlVFKHVybDkuaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFn bWVudHModXJsMTApKTsKK30KKworVEVTVF9GKFdURl9VUkwsIFVSTENvbnRhaW5zU2FtZVF1ZXJ5 UGFyYW1ldGVycykKK3sKKyAgICBVUkwgdXJsMSA9IGNyZWF0ZVVSTCgid3d3LndlYmtpdC5vcmcv PyIpOworICAgIFVSTCB1cmwyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tl eTE9dmFsMSIpOworICAgIEVYUEVDVF9GQUxTRSh1cmwxLmNvbnRhaW5zU2FtZVF1ZXJ5UGFyYW1l dGVycyh1cmwyKSk7CisgICAgCisgICAgVVJMIHVybCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRSh1cmwuY29udGFpbnNTYW1l UXVlcnlQYXJhbWV0ZXJzKHVybCkpOworICAgIAorICAgIFVSTCB1cmw3ID0gY3JlYXRlVVJMKCJo dHRwOi8vd3d3LmV4YW1wbGUub3JnP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRl VVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVF KHVybDcuY29udGFpbnNTYW1lUXVlcnlQYXJhbWV0ZXJzKHVybDgpKTsKKyAgICAKKyAgICBVUkwg dXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnL3BhdGg/Iik7CisgICAgVVJM IHVybDYgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgRVhQRUNU X1RSVUUodXJsNS5jb250YWluc1NhbWVRdWVyeVBhcmFtZXRlcnModXJsNikpOworICAgIAorICAg IFVSTCB1cmwzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPyIpOworICAgIFVS TCB1cmw0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOwor ICAgIEVYUEVDVF9GQUxTRSh1cmwzLmNvbnRhaW5zU2FtZVF1ZXJ5UGFyYW1ldGVycyh1cmw0KSk7 CisgICAgCisgICAgVVJMIHVybDkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy9w YXRoP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwxMCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5Mj12YWwyIik7CisgICAgRVhQRUNUX0ZBTFNFKHVybDku Y29udGFpbnNTYW1lUXVlcnlQYXJhbWV0ZXJzKHVybDEwKSk7CisgICAgCisgICAgVVJMIHVybDEx ID0gY3JlYXRlVVJMKCJodHRwOi8vZXhhbXBsZS5jb20vP2E9YiZjPWQiKTsKKyAgICBVUkwgdXJs MTIgPSBjcmVhdGVVUkwoImh0dHA6Ly9leGFtcGxlLmNvbS8/Yz1kJmE9YiIpOworICAgIEVYUEVD VF9UUlVFKHVybDExLmNvbnRhaW5zU2FtZVF1ZXJ5UGFyYW1ldGVycyh1cmwxMikpOworICAgIAor ICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgiaHR0cDovL2V4YW1wbGUuY29tLz8iKTsKKyAgICBV UkwgdXJsMTQgPSBjcmVhdGVVUkwoImh0dHA6Ly9leGFtcGxlLmNvbS8iKTsKKyAgICBFWFBFQ1Rf VFJVRSh1cmwxMy5jb250YWluc1NhbWVRdWVyeVBhcmFtZXRlcnModXJsMTQpKTsKK30KKworVEVT VF9GKFdURl9VUkwsIFVSTFJlbW92ZVF1ZXJ5UGFyYW1ldGVycykKK3sKKyAgICBVUkwgdXJsID0g Y3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwiKTsKKyAgICBVUkwgdXJs MSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsJmtleTE9dmFsMSIp OworICAgIFVSTCB1cmwyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPyIpOwor ICAgIFVSTCB1cmwzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwj ZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQu b3JnLz9rZXk9dmFsJmtleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsNSA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkma2V5PSNmcmFnbWVudCIpOworICAgIFVSTCB1 cmw2ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvI2ZyYWdtZW50Iik7CisgICAg VVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCNmcmFn bWVudCIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcv Iik7CisgICAgVVJMIHVybDkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8jZnJh Z21lbnQiKTsKKyAgICBVUkwgdXJsMTAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9y Zy8/a2V5PXZhbCNmcmFnbWVudCIpOworICAgIFVSTCB1cmwxMSA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz9rZXk9dmFsJmtleTE9dmFsMSNmcmFnbWVudCIpOworICAgIFVSTCB1 cmwxMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsJmtleTE9dmFs MSNmcmFnbWVudCIpOworICAgIAorICAgIEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0MSB7 ImtleSJ9OworICAgIEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0MiB7ImtleTEifTsKKyAg ICBIYXNoU2V0PFN0cmluZz4ga2V5UmVtb3ZhbFNldDMgeyJrZXkyIn07CisgICAgSGFzaFNldDxT dHJpbmc+IGtleVJlbW92YWxTZXQ0IHsia2V5IiwgImtleTEifTsKKworICAgIHVybDEucmVtb3Zl UXVlcnlQYXJhbWV0ZXJzKGtleVJlbW92YWxTZXQyKTsKKyAgICBFWFBFQ1RfRVEodXJsLnN0cmlu ZygpLCB1cmwxLnN0cmluZygpKTsKKyAgICAKKyAgICB1cmwyLnJlbW92ZVF1ZXJ5UGFyYW1ldGVy cyhrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDguc3RyaW5nKCksIHVybDIuc3Ry aW5nKCkpOworICAgIAorICAgIHVybDMucmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKGtleVJlbW92YWxT ZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJsNi5zdHJpbmcoKSwgdXJsMy5zdHJpbmcoKSk7CisgICAg CisgICAgdXJsNC5yZW1vdmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVtb3ZhbFNldDEpOworICAgIEVY UEVDVF9FUSh1cmw2LnN0cmluZygpLCB1cmw0LnN0cmluZygpKTsKKyAgICAKKyAgICB1cmw1LnJl bW92ZVF1ZXJ5UGFyYW1ldGVycyhrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDYu c3RyaW5nKCksIHVybDUuc3RyaW5nKCkpOworICAgIAorICAgIHVybDYucmVtb3ZlUXVlcnlQYXJh bWV0ZXJzKGtleVJlbW92YWxTZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJsOS5zdHJpbmcoKSwgdXJs Ni5zdHJpbmcoKSk7CisgICAgCisgICAgdXJsNy5yZW1vdmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVt b3ZhbFNldDIpOworICAgIEVYUEVDVF9FUSh1cmwxMC5zdHJpbmcoKSwgdXJsNy5zdHJpbmcoKSk7 CisgICAgCisgICAgdXJsMTEucmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKGtleVJlbW92YWxTZXQzKTsK KyAgICBFWFBFQ1RfRVEodXJsMTIuc3RyaW5nKCksIHVybDExLnN0cmluZygpKTsKKyAgICAKKyAg ICB1cmwxMi5yZW1vdmVRdWVyeVBhcmFtZXRlcnMoa2V5UmVtb3ZhbFNldDQpOworICAgIEVYUEVD VF9FUSh1cmw5LnN0cmluZygpLCB1cmwxMi5zdHJpbmcoKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNl IFRlc3RXZWJLaXRBUEkK 434736 2021-08-01 21:44:49 -0700 2021-08-03 12:05:42 -0700 Patch bug-228122-20210801214448.patch text/plain 20549 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLmI1YzI0NmM2NTU1MTY5ZTIxMjkxMjk1M2NmNTJmMjY5ZjNiNjdl MTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMjEtMDgtMDEgIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBmdW5jdGlvbmFsaXRpZXMgZm9yIHBhcnNp bmcgVVJMIHF1ZXJ5IHN0cmluZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisgICAgICAgIAorICAgICAgICBBZGRlZCBwYXJzaW5nIG9mIFVSTCBxdWVyeSBzdHJpbmdzLgor ICAgICAgICAKKyAgICAgICAgKiB3dGYvSGFzaEZ1bmN0aW9ucy5oOgorICAgICAgICAoV1RGOjpL ZXlWYWx1ZVBhaXJIYXNoOjpoYXNoKToKKyAgICAgICAgKFdURjo6S2V5VmFsdWVQYWlySGFzaDo6 ZXF1YWwpOgorICAgICAgICAqIHd0Zi9IYXNoVHJhaXRzLmg6CisgICAgICAgICogd3RmL0tleVZh bHVlUGFpci5oOgorICAgICAgICAoV1RGOjpLZXlWYWx1ZVBhaXI6Om9wZXJhdG9yPT0gY29uc3Qp OgorICAgICAgICAqIHd0Zi9VUkwuY3BwOgorICAgICAgICAoV1RGOjpVUkw6OmRpZmZlcmluZ1F1 ZXJ5UGFyYW1ldGVycyk6CisgICAgICAgIChXVEY6Omxlbmd0aE9mVVJMSWdub3JpbmdRdWVyeUFu ZEZyYWdtZW50cyk6CisgICAgICAgIChXVEY6OlVSTDo6aXNFcXVhbElnbm9yaW5nUXVlcnlBbmRG cmFnbWVudHMpOgorICAgICAgICAoV1RGOjpVUkw6OnJlbW92ZVF1ZXJ5UGFyYW1ldGVycyk6Cisg ICAgICAgICogd3RmL1VSTC5oOgorCiAyMDIxLTA3LTE2ICBBbGV4YW5kZXIgTWlraGF5bGVua28g IDxhbGV4bUBnbm9tZS5vcmc+CiAKICAgICAgICAgW0dUS11bV1BFXSBTdXBwb3J0IGNvbG9yLXNj aGVtZXMgQ1NTIHByb3BlcnR5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoRnVuY3Rp b25zLmggYi9Tb3VyY2UvV1RGL3d0Zi9IYXNoRnVuY3Rpb25zLmgKaW5kZXggZmZkNTIyY2UyOTA4 ZDdmZWU3MmFiYjA0NjE0YWFmNDQxMDViNmI2Ny4uOGEwYzdhMTY2MDk1NDcxYjcwNDI2ZGZmNGU2 NDU5MDMyNmU5YjA4NCAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvSGFzaEZ1bmN0aW9ucy5o CisrKyBiL1NvdXJjZS9XVEYvd3RmL0hhc2hGdW5jdGlvbnMuaApAQCAtMTY5LDYgKzE2OSwxOCBA QCBuYW1lc3BhY2UgV1RGIHsKICAgICAgICAgc3RhdGljIGNvbnN0ZXhwciBib29sIHNhZmVUb0Nv bXBhcmVUb0VtcHR5T3JEZWxldGVkID0gRGVmYXVsdEhhc2g8VD46OnNhZmVUb0NvbXBhcmVUb0Vt cHR5T3JEZWxldGVkICYmIERlZmF1bHRIYXNoPFU+OjpzYWZlVG9Db21wYXJlVG9FbXB0eU9yRGVs ZXRlZDsKICAgICB9OwogCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVT4gc3Ry dWN0IEtleVZhbHVlUGFpckhhc2ggeworICAgICAgICBzdGF0aWMgdW5zaWduZWQgaGFzaChjb25z dCBLZXlWYWx1ZVBhaXI8VCwgVT4mIHApCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBw YWlySW50SGFzaChEZWZhdWx0SGFzaDxUPjo6aGFzaChwLmtleSksIERlZmF1bHRIYXNoPFU+Ojpo YXNoKHAudmFsdWUpKTsKKyAgICAgICAgfQorICAgICAgICBzdGF0aWMgYm9vbCBlcXVhbChjb25z dCBLZXlWYWx1ZVBhaXI8VCwgVT4mIGEsIGNvbnN0IEtleVZhbHVlUGFpcjxULCBVPiYgYikKKyAg ICAgICAgeworICAgICAgICAgICAgcmV0dXJuIERlZmF1bHRIYXNoPFQ+OjplcXVhbChhLmtleSwg Yi5rZXkpICYmIERlZmF1bHRIYXNoPFU+OjplcXVhbChhLnZhbHVlLCBiLnZhbHVlKTsKKyAgICAg ICAgfQorICAgICAgICBzdGF0aWMgY29uc3RleHByIGJvb2wgc2FmZVRvQ29tcGFyZVRvRW1wdHlP ckRlbGV0ZWQgPSBEZWZhdWx0SGFzaDxUPjo6c2FmZVRvQ29tcGFyZVRvRW1wdHlPckRlbGV0ZWQg JiYgRGVmYXVsdEhhc2g8VT46OnNhZmVUb0NvbXBhcmVUb0VtcHR5T3JEZWxldGVkOworICAgIH07 CisKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBzdHJ1Y3QgSW50UGFpckhh c2ggewogICAgICAgICBzdGF0aWMgdW5zaWduZWQgaGFzaChjb25zdCBzdGQ6OnBhaXI8VCwgVT4m IHApIHsgcmV0dXJuIHBhaXJJbnRIYXNoKHAuZmlyc3QsIHAuc2Vjb25kKTsgfQogICAgICAgICBz dGF0aWMgYm9vbCBlcXVhbChjb25zdCBzdGQ6OnBhaXI8VCwgVT4mIGEsIGNvbnN0IHN0ZDo6cGFp cjxULCBVPiYgYikgeyByZXR1cm4gUGFpckhhc2g8VCwgVD46OmVxdWFsKGEsIGIpOyB9CkBAIC0y NjcsNiArMjc5LDcgQEAgbmFtZXNwYWNlIFdURiB7CiAKICAgICAvLyBtYWtlIFBhaXJIYXNoIHRo ZSBkZWZhdWx0IGhhc2ggZnVuY3Rpb24gZm9yIHBhaXJzIG9mIGFyYml0cmFyeSB2YWx1ZXMuCiAK KyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBULCB0eXBlbmFtZSBVPiBzdHJ1Y3QgRGVmYXVsdEhhc2g8 S2V5VmFsdWVQYWlyPFQsIFU+PiA6IEtleVZhbHVlUGFpckhhc2g8VCwgVT4geyB9OwogICAgIHRl bXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IHN0cnVjdCBEZWZhdWx0SGFzaDxzdGQ6OnBh aXI8VCwgVT4+IDogUGFpckhhc2g8VCwgVT4geyB9OwogICAgIHRlbXBsYXRlPHR5cGVuYW1lLi4u IFR5cGVzPiBzdHJ1Y3QgRGVmYXVsdEhhc2g8c3RkOjp0dXBsZTxUeXBlcy4uLj4+IDogVHVwbGVI YXNoPFR5cGVzLi4uPiB7IH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0hhc2hUcmFp dHMuaCBiL1NvdXJjZS9XVEYvd3RmL0hhc2hUcmFpdHMuaAppbmRleCA3NTI0ODFiM2ZmYzEzMTVj NTY4YTIzY2VkN2VkNjdlNWYxNGJiZDhmLi4yMTEyYTQ5NjJmZjgxOTIzMmQ4Y2RkZDEwZWVjMDRh NzA5NTgzNGY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoVHJhaXRzLmgKKysrIGIv U291cmNlL1dURi93dGYvSGFzaFRyYWl0cy5oCkBAIC00MjgsNiArNDI4LDcgQEAgc3RydWN0IEN1 c3RvbUhhc2hUcmFpdHMgOiBwdWJsaWMgR2VuZXJpY0hhc2hUcmFpdHM8VD4gewogCiB1c2luZyBX VEY6Okhhc2hUcmFpdHM7CiB1c2luZyBXVEY6OktleVZhbHVlUGFpcjsKK3VzaW5nIFdURjo6S2V5 VmFsdWVQYWlySGFzaFRyYWl0czsKIHVzaW5nIFdURjo6UGFpckhhc2hUcmFpdHM7CiB1c2luZyBX VEY6Ok51bGxhYmxlSGFzaFRyYWl0czsKIHVzaW5nIFdURjo6U2ltcGxlQ2xhc3NIYXNoVHJhaXRz OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvS2V5VmFsdWVQYWlyLmggYi9Tb3VyY2UvV1RG L3d0Zi9LZXlWYWx1ZVBhaXIuaAppbmRleCBiMWMyYmMzNjgzNWRlNmQwYmQ0MTE3OTM1Yjk1ZDJh MDJjYWIwOGUyLi5mYzNkMDQ3ODBhY2M4MGNiOTliYTZkMGFlODNlODQ4YjQxYTk1ZjEyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9LZXlWYWx1ZVBhaXIuaAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9LZXlWYWx1ZVBhaXIuaApAQCAtNjAsNiArNjAsMTIgQEAgc3RydWN0IEtleVZhbHVlUGFpciB7 CiAgICAgewogICAgIH0KIAorICAgIHRlbXBsYXRlIDx0eXBlbmFtZSBLLCB0eXBlbmFtZSBWPgor ICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBLZXlWYWx1ZVBhaXI8SywgVj4mIG90aGVyKSBjb25z dAorICAgIHsKKyAgICAgICAgcmV0dXJuIGtleSA9PSBvdGhlci5rZXkgJiYgdmFsdWUgPT0gb3Ro ZXIudmFsdWU7CisgICAgfQorCiAgICAgS2V5VHlwZSBrZXk7CiAgICAgVmFsdWVUeXBlIHZhbHVl IHsgfTsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9VUkwuY3BwIGIvU291cmNlL1dU Ri93dGYvVVJMLmNwcAppbmRleCBkOWMwODJjZWM2OWE1ZDg0OGQwM2QxNmUwODk0YThjYjcyYTVh NWRiLi5mN2VlMDU3ZDA4MmIyYzU3ODUyNDQ4MTVkNzI2MmVhMjZiYTgzZDNkIDEwMDY0NAotLS0g YS9Tb3VyY2UvV1RGL3d0Zi9VUkwuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAKQEAg LTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlIDxzdGRpby5oPgogI2luY2x1ZGUgPHVuaWNvZGUvdWlk bmEuaD4KICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+ CiAjaW5jbHVkZSA8d3RmL0xvY2suaD4KICNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4K ICNpbmNsdWRlIDx3dGYvUHJpbnRTdHJlYW0uaD4KQEAgLTExNjYsNCArMTE2NywxMDYgQEAgYm9v bCBVUkw6Omhvc3RJc0lQQWRkcmVzcyhTdHJpbmdWaWV3IGhvc3QpCiAKICNlbmRpZgogCitWZWN0 b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJz KGNvbnN0IFVSTCYgZmlyc3RVUkwsIGNvbnN0IFVSTCYgc2Vjb25kVVJMKQoreworICAgIGlmICgh Zmlyc3RVUkwuaXNWYWxpZCgpIHx8ICFzZWNvbmRVUkwuaXNWYWxpZCgpKQorICAgICAgICByZXR1 cm4geyB9OworICAgIAorICAgIGF1dG8gZmlyc3RRdWVyeVBhcmFtZXRlcnMgPSBVUkxQYXJzZXI6 OnBhcnNlVVJMRW5jb2RlZEZvcm0oZmlyc3RVUkwucXVlcnkoKSk7CisgICAgYXV0byBzZWNvbmRR dWVyeVBhcmFtZXRlcnMgPSBVUkxQYXJzZXI6OnBhcnNlVVJMRW5jb2RlZEZvcm0oc2Vjb25kVVJM LnF1ZXJ5KCkpOworICAgIAorICAgIGlmIChmaXJzdFF1ZXJ5UGFyYW1ldGVycy5pc0VtcHR5KCkp CisgICAgICAgIHJldHVybiBzZWNvbmRRdWVyeVBhcmFtZXRlcnM7CisKKyAgICBpZiAoc2Vjb25k UXVlcnlQYXJhbWV0ZXJzLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIGZpcnN0UXVlcnlQYXJh bWV0ZXJzOworCisgICAgc3RkOjpzb3J0KGZpcnN0UXVlcnlQYXJhbWV0ZXJzLmJlZ2luKCksIGZp cnN0UXVlcnlQYXJhbWV0ZXJzLmVuZCgpLCBbJl0gKEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmlu Zz4mIGZpcnN0S2V5VmFsdWVQYWlyLCBLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+JiBzZWNv bmRLZXlWYWx1ZVBhaXIpIHsKKyAgICAgICAgU3RyaW5nQnVpbGRlciBmaXJzdEtleVZhbHVlUGFp ckFwcGVuZGVkOworICAgICAgICBTdHJpbmdCdWlsZGVyIHNlY29uZEtleVZhbHVlUGFpckFwcGVu ZGVkOworICAgICAgICBmaXJzdEtleVZhbHVlUGFpckFwcGVuZGVkLmFwcGVuZChmaXJzdEtleVZh bHVlUGFpci5rZXksIGZpcnN0S2V5VmFsdWVQYWlyLnZhbHVlKTsKKyAgICAgICAgc2Vjb25kS2V5 VmFsdWVQYWlyQXBwZW5kZWQuYXBwZW5kKHNlY29uZEtleVZhbHVlUGFpci5rZXksIHNlY29uZEtl eVZhbHVlUGFpci52YWx1ZSk7CisgICAgICAgIHJldHVybiBmaXJzdEtleVZhbHVlUGFpckFwcGVu ZGVkLnRvU3RyaW5nKCkudXRmOCgpIDwgc2Vjb25kS2V5VmFsdWVQYWlyQXBwZW5kZWQudG9TdHJp bmcoKS51dGY4KCk7CisgICAgfSk7CisgICAgCisgICAgc3RkOjpzb3J0KHNlY29uZFF1ZXJ5UGFy YW1ldGVycy5iZWdpbigpLCBzZWNvbmRRdWVyeVBhcmFtZXRlcnMuZW5kKCksIFsmXSAoS2V5VmFs dWVQYWlyPFN0cmluZywgU3RyaW5nPiYgZmlyc3RLZXlWYWx1ZVBhaXIsIEtleVZhbHVlUGFpcjxT dHJpbmcsIFN0cmluZz4mIHNlY29uZEtleVZhbHVlUGFpcikgeworICAgICAgICBTdHJpbmdCdWls ZGVyIGZpcnN0S2V5VmFsdWVQYWlyQXBwZW5kZWQ7CisgICAgICAgIFN0cmluZ0J1aWxkZXIgc2Vj b25kS2V5VmFsdWVQYWlyQXBwZW5kZWQ7CisgICAgICAgIGZpcnN0S2V5VmFsdWVQYWlyQXBwZW5k ZWQuYXBwZW5kKGZpcnN0S2V5VmFsdWVQYWlyLmtleSwgZmlyc3RLZXlWYWx1ZVBhaXIudmFsdWUp OworICAgICAgICBzZWNvbmRLZXlWYWx1ZVBhaXJBcHBlbmRlZC5hcHBlbmQoc2Vjb25kS2V5VmFs dWVQYWlyLmtleSwgc2Vjb25kS2V5VmFsdWVQYWlyLnZhbHVlKTsKKyAgICAgICAgcmV0dXJuIGZp cnN0S2V5VmFsdWVQYWlyQXBwZW5kZWQudG9TdHJpbmcoKS51dGY4KCkgPCBzZWNvbmRLZXlWYWx1 ZVBhaXJBcHBlbmRlZC50b1N0cmluZygpLnV0ZjgoKTsKKyAgICB9KTsKKyAgICAKKyAgICBzaXpl X3QgdG90YWxGaXJzdFF1ZXJ5UGFyYW1ldGVycyA9IGZpcnN0UXVlcnlQYXJhbWV0ZXJzLnNpemUo KTsKKyAgICBzaXplX3QgdG90YWxTZWNvbmRRdWVyeVBhcmFtZXRlcnMgPSBzZWNvbmRRdWVyeVBh cmFtZXRlcnMuc2l6ZSgpOworICAgIHNpemVfdCBpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlciA9 IDA7CisgICAgc2l6ZV90IGluZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlciA9IDA7CisgICAgU3Ry aW5nQnVpbGRlciB0ZW1wUGFyYW1ldGVyRnJvbUZpcnN0OworICAgIFN0cmluZ0J1aWxkZXIgdGVt cFBhcmFtZXRlckZyb21TZWNvbmQ7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0 cmluZz4+IGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVyczsKKyAgICB3aGlsZSAoaW5kZXhJbkZpcnN0 UXVlcnlQYXJhbWV0ZXIgPCB0b3RhbEZpcnN0UXVlcnlQYXJhbWV0ZXJzICYmIGluZGV4SW5TZWNv bmRRdWVyeVBhcmFtZXRlciA8IHRvdGFsU2Vjb25kUXVlcnlQYXJhbWV0ZXJzKSB7CisgICAgICAg IHRlbXBQYXJhbWV0ZXJGcm9tRmlyc3QuYXBwZW5kKGZpcnN0UXVlcnlQYXJhbWV0ZXJzW2luZGV4 SW5GaXJzdFF1ZXJ5UGFyYW1ldGVyXS5rZXksICc9JywgZmlyc3RRdWVyeVBhcmFtZXRlcnNbaW5k ZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJdLnZhbHVlKTsKKyAgICAgICAgdGVtcFBhcmFtZXRlckZy b21TZWNvbmQuYXBwZW5kKHNlY29uZFF1ZXJ5UGFyYW1ldGVyc1tpbmRleEluU2Vjb25kUXVlcnlQ YXJhbWV0ZXJdLmtleSwgJz0nLCBzZWNvbmRRdWVyeVBhcmFtZXRlcnNbaW5kZXhJblNlY29uZFF1 ZXJ5UGFyYW1ldGVyXS52YWx1ZSk7CisgICAgICAgIGlmICh0ZW1wUGFyYW1ldGVyRnJvbUZpcnN0 LnRvU3RyaW5nKCkudXRmOCgpIDwgdGVtcFBhcmFtZXRlckZyb21TZWNvbmQudG9TdHJpbmcoKS51 dGY4KCkpIHsKKyAgICAgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycy5hcHBlbmQoZmly c3RRdWVyeVBhcmFtZXRlcnNbaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJdKTsKKyAgICAgICAg ICAgIGluZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVyKys7CisgICAgICAgIH0gZWxzZSBpZiAodGVt cFBhcmFtZXRlckZyb21TZWNvbmQudG9TdHJpbmcoKS51dGY4KCkgPCB0ZW1wUGFyYW1ldGVyRnJv bUZpcnN0LnRvU3RyaW5nKCkudXRmOCgpKSB7CisgICAgICAgICAgICBkaWZmZXJpbmdRdWVyeVBh cmFtZXRlcnMuYXBwZW5kKHNlY29uZFF1ZXJ5UGFyYW1ldGVyc1tpbmRleEluU2Vjb25kUXVlcnlQ YXJhbWV0ZXJdKTsKKyAgICAgICAgICAgIGluZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcisrOwor ICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXIr KzsKKyAgICAgICAgICAgIGluZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcisrOworICAgICAgICB9 CisgICAgICAgIAorICAgICAgICB0ZW1wUGFyYW1ldGVyRnJvbUZpcnN0LmNsZWFyKCk7CisgICAg ICAgIHRlbXBQYXJhbWV0ZXJGcm9tU2Vjb25kLmNsZWFyKCk7CisgICAgfQorICAgIAorICAgIHdo aWxlIChpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlciA8IHRvdGFsRmlyc3RRdWVyeVBhcmFtZXRl cnMpIHsKKyAgICAgICAgZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzLmFwcGVuZChmaXJzdFF1ZXJ5 UGFyYW1ldGVyc1tpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcl0pOworICAgICAgICBpbmRleElu Rmlyc3RRdWVyeVBhcmFtZXRlcisrOworICAgIH0KKyAgICAKKyAgICB3aGlsZSAoaW5kZXhJblNl Y29uZFF1ZXJ5UGFyYW1ldGVyIDwgdG90YWxTZWNvbmRRdWVyeVBhcmFtZXRlcnMpIHsKKyAgICAg ICAgZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzLmFwcGVuZChzZWNvbmRRdWVyeVBhcmFtZXRlcnNb aW5kZXhJblNlY29uZFF1ZXJ5UGFyYW1ldGVyXSk7CisgICAgICAgIGluZGV4SW5TZWNvbmRRdWVy eVBhcmFtZXRlcisrOworICAgIH0KKyAgICAKKyAgICByZXR1cm4gZGlmZmVyaW5nUXVlcnlQYXJh bWV0ZXJzOworfQorCitzdGF0aWMgdW5zaWduZWQgbGVuZ3RoT2ZVUkxJZ25vcmluZ1F1ZXJ5QW5k RnJhZ21lbnRzKGNvbnN0IFVSTCYgdXJsKQoreworICAgIHJldHVybiB1cmwuc3RyaW5nKClbdXJs LnBhdGhFbmQoKSAtIDFdID09ICcvJyA/IHVybC5wYXRoRW5kKCkgLSAxIDogdXJsLnBhdGhFbmQo KTsKK30KKworYm9vbCBpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyhjb25zdCBVUkwm IGZpcnN0VVJMLCBjb25zdCBVUkwmIHNlY29uZFVSTCkKK3sKKyAgICBpZiAoIWZpcnN0VVJMLmlz VmFsaWQoKSB8fCAhc2Vjb25kVVJMLmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIAorICAgIGF1dG8gbGVuZ3RoT2ZGaXJzdFVSTElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMg PSBsZW5ndGhPZlVSTElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMoZmlyc3RVUkwpOworICAgIGF1 dG8gc2Vjb25kTGVuZ3RoT2ZTZWNvbmRVUkxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzID0gbGVu Z3RoT2ZVUkxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKHNlY29uZFVSTCk7CisgICAgcmV0dXJu IFN0cmluZ1ZpZXcoZmlyc3RVUkwuc3RyaW5nKCkpLnN1YnN0cmluZygwLCBsZW5ndGhPZkZpcnN0 VVJMSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cykgPT0gU3RyaW5nVmlldyhzZWNvbmRVUkwuc3Ry aW5nKCkpLnN1YnN0cmluZygwLCBzZWNvbmRMZW5ndGhPZlNlY29uZFVSTElnbm9yaW5nUXVlcnlB bmRGcmFnbWVudHMpOworfQorCit2b2lkIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyhVUkwmIHVybCwg Y29uc3QgSGFzaFNldDxTdHJpbmc+JiBrZXlzVG9SZW1vdmUpCit7CisgICAgaWYgKGtleXNUb1Jl bW92ZS5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBhdXRvIHF1ZXJ5UGFy YW1ldGVyc0xpc3QgPSBVUkxQYXJzZXI6OnBhcnNlVVJMRW5jb2RlZEZvcm0odXJsLnF1ZXJ5KCkp OworICAgIFN0cmluZ0J1aWxkZXIgcXVlcnlXaXRob3V0UmVtb3ZhbEtleXM7CisgICAgZm9yIChh dXRvJiBzaW5nbGVRdWVyeVBhcmFtZXRlciA6IHF1ZXJ5UGFyYW1ldGVyc0xpc3QpIHsKKyAgICAg ICAgaWYgKCFrZXlzVG9SZW1vdmUuY29udGFpbnMoc2luZ2xlUXVlcnlQYXJhbWV0ZXIua2V5KSkg eworICAgICAgICAgICAgaWYgKCFxdWVyeVdpdGhvdXRSZW1vdmFsS2V5cy5pc0VtcHR5KCkpCisg ICAgICAgICAgICAgICAgcXVlcnlXaXRob3V0UmVtb3ZhbEtleXMuYXBwZW5kKCcmJywgc2luZ2xl UXVlcnlQYXJhbWV0ZXIua2V5LCAnPScsIHNpbmdsZVF1ZXJ5UGFyYW1ldGVyLnZhbHVlKTsKKyAg ICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBxdWVyeVdpdGhvdXRSZW1vdmFsS2V5cy5h cHBlbmQoc2luZ2xlUXVlcnlQYXJhbWV0ZXIua2V5LCAnPScsIHNpbmdsZVF1ZXJ5UGFyYW1ldGVy LnZhbHVlKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICB1cmwuc2V0UXVlcnkocXVlcnlX aXRob3V0UmVtb3ZhbEtleXMpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBh L1NvdXJjZS9XVEYvd3RmL1VSTC5oIGIvU291cmNlL1dURi93dGYvVVJMLmgKaW5kZXggZjQ0NTQy MWUxZmUyM2NhYmI2MTU3ZjcwZDljNDQ2YTI4NmM1ZjA1Ni4uZWRhNDExN2I0OWI0M2UxM2IwOTE0 OTE5ZTM0Mjc2NzFjNTc4OTRlYyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVVJMLmgKKysr IGIvU291cmNlL1dURi93dGYvVVJMLmgKQEAgLTI0NCw2ICsyNDQsOSBAQCBib29sIG9wZXJhdG9y IT0oY29uc3QgU3RyaW5nJiwgY29uc3QgVVJMJik7CiAKIFdURl9FWFBPUlRfUFJJVkFURSBib29s IGVxdWFsSWdub3JpbmdGcmFnbWVudElkZW50aWZpZXIoY29uc3QgVVJMJiwgY29uc3QgVVJMJik7 CiBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBwcm90b2NvbEhvc3RBbmRQb3J0QXJlRXF1YWwoY29u c3QgVVJMJiwgY29uc3QgVVJMJik7CitXVEZfRVhQT1JUX1BSSVZBVEUgVmVjdG9yPEtleVZhbHVl UGFpcjxTdHJpbmcsIFN0cmluZz4+IGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyhjb25zdCBVUkwm LCBjb25zdCBVUkwmKTsKK1dURl9FWFBPUlRfUFJJVkFURSBib29sIGlzRXF1YWxJZ25vcmluZ1F1 ZXJ5QW5kRnJhZ21lbnRzKGNvbnN0IFVSTCYsIGNvbnN0IFVSTCYpOworV1RGX0VYUE9SVF9QUklW QVRFIHZvaWQgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKFVSTCYsIGNvbnN0IEhhc2hTZXQ8U3RyaW5n PiYpOwogCiBXVEZfRVhQT1JUX1BSSVZBVEUgY29uc3QgVVJMJiBhYm91dEJsYW5rVVJMKCk7CiBX VEZfRVhQT1JUX1BSSVZBVEUgY29uc3QgVVJMJiBhYm91dFNyY0RvY1VSTCgpOwpkaWZmIC0tZ2l0 IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGE2NmEyNGZlNDc5ZjFl OTQyN2Y3OWQyNzdiZDE0ZWU4OTBlN2ZiM2MuLmMwZmRkMzI2MDRjMmEyYTU5MDZjNWJkMmU2MDMx ZGE4MjY4NzllOGEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMS0wOC0wMSAgUmlzdWwgSXNsYW0gIDxyaXN1bF9p c2xhbUBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIGZ1bmN0aW9uYWxpdGllcyBmb3IgcGFyc2lu ZyBVUkwgcXVlcnkgc3RyaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0yMjgxMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KyAgICAgICAgCisgICAgICAgIEFkZGVkIHRoZSB0ZXN0IGZ1bmN0aW9ucyByZXF1aXJlZCBmb3Ig cGFyc2luZyBVUkwgcXVlcnkgc3RyaW5nLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0 cy9XVEYvVVJMLmNwcDoKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1RfRik6CisKIDIwMjEt MDctMTkgIFJ5YW4gSGFkZGFkICA8cnlhbmhhZGRhZEBhcHBsZS5jb20+CiAKICAgICAgICAgW2J1 aWxkLndlYmtpdC5vcmddIGxsZGItd2Via2l0LXRlc3QgaXMgZmFpbGluZyBvbiBDYXRhbGluYSBx dWV1ZXMKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHAg Yi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwCmluZGV4IGVlOGNlMTkyNTU5 MTMxMjI2MzQzNmJiMmUxYWJiYTFkN2ZkNzgzODYuLjRjNGFlZDQ0ZTI4MDE4ZWQ1YmQzMjRjNmZi OWU4M2E5ZWU0YmRiYzggMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RG L1VSTC5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVVJMLmNwcApAQCAt MjUsMTAgKzI1LDEyIEBACiAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXVEZTdHJp bmdVdGlsaXRpZXMuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9N YWluVGhyZWFkLmg+CiAjaW5jbHVkZSA8d3RmL1N0cmluZ1ByaW50U3RyZWFtLmg+CiAjaW5jbHVk ZSA8d3RmL1VSTC5oPgogI2luY2x1ZGUgPHd0Zi9VUkxQYXJzZXIuaD4KKyNpbmNsdWRlIDx3dGYv dGV4dC9TdHJpbmdIYXNoLmg+CiAKIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKIApAQCAtMzU3 LDQgKzM1OSwxODMgQEAgVEVTVF9GKFdURl9VUkwsIFByaW50U3RyZWFtKQogICAgIEVYUEVDVF9F UShvdXQudG9TdHJpbmcoKSwgdXJsU3RyaW5nKTsKIH0KIAorVEVTVF9GKFdURl9VUkwsIFVSTERp ZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycykKK3sKKyAgICBVUkwgdXJsMSA9IGNyZWF0ZVVSTCgid3d3 LndlYmtpdC5vcmcvPyIpOworICAgIFVSTCB1cmwyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBT dHJpbmc+PiB0ZXN0VmVjdG9yIHsgfTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJh bWV0ZXJzKHVybDEsIHVybDIpLCB0ZXN0VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9F UShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsLCB1cmwpLCB0ZXN0VmVjdG9yKTsKKyAgICAK KyAgICBVUkwgdXJsOSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZh bDEiKTsKKyAgICBVUkwgdXJsMTAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmw5 LCB1cmwxMCkgLCB0ZXN0VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsNyA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsOCA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJh bWV0ZXJzKHVybDcsIHVybDgpLCB0ZXN0VmVjdG9yKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5 VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjM0IHt7ImtleTEiLCAidmFsMSJ9 fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDMsIHVybDQpLCB0 ZXN0VmVjdG9yMzQpOworICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmw2ID0gY3JlYXRlVVJMKCJodHRw Oi8vd3d3LndlYmtpdC5vcmcvPyIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBT dHJpbmc+PiB0ZXN0VmVjdG9yNTYge3sia2V5MSIsICJ2YWwxIn19OworICAgIEVYUEVDVF9FUShk aWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsNSwgdXJsNiksIHRlc3RWZWN0b3I1Nik7CisgICAg CisgICAgVVJMIHVybDEzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9 dmFsMSZrZXkyPXZhbDIiKTsKKyAgICBVUkwgdXJsMTQgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTE9dmFsMSIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBh aXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTMxNCB7eyJrZXkxIiwgInZhbDEifSwgeyJr ZXkyIiwgInZhbDIifX07CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1 cmwxMywgdXJsMTQpLCB0ZXN0VmVjdG9yMTMxNCk7CisgICAgCisgICAgVVJMIHVybDE1ID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIFVSTCB1cmwx NiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkyPXZhbDIiKTsKKyAgICBW ZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjE1MTYge3sia2V5 MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2YWwyIn19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdR dWVyeVBhcmFtZXRlcnModXJsMTUsIHVybDE2KSwgdGVzdFZlY3RvcjE1MTYpOworICAgIAorICAg IFVSTCB1cmwxMSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEm a2V5Mj12YWwyIik7CisgICAgVVJMIHVybDEyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtp dC5vcmcvP2tleTE9dmFsMSZrZXkzPXZhbDMiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0 cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjExMTIge3sia2V5MiIsICJ2YWwyIn0sIHsia2V5MyIs ICJ2YWwzIn19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTEs IHVybDEyKSwgdGVzdFZlY3RvcjExMTIpOworICAgIAorICAgIFVSTCB1cmwxNyA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5Mj12YWwyIik7CisgICAgVVJM IHVybDE4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTEma2V5Mz12YWwz Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3Ix NzE4IHt7ImtleTEiLCAiIn0sIHsia2V5MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2YWwyIn0sIHsi a2V5MyIsICJ2YWwzIn19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMo dXJsMTcsIHVybDE4KSwgdGVzdFZlY3RvcjE3MTgpOworICAgIAorICAgIFVSTCB1cmwxOSA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5MT12YWwxJmtleTI9 dmFsMiIpOworICAgIFVSTCB1cmwyMCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3Jn Lz9rZXkxJmtleTM9dmFsMyIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJp bmc+PiB0ZXN0VmVjdG9yMTkyMCB7eyJrZXkxIiwgIiJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7Imtl eTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9LCB7ImtleTMiLCAidmFsMyJ9fTsKKyAgICBF WFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDE5LCB1cmwyMCksIHRlc3RWZWN0 b3IxOTIwKTsKKyAgICAKKyAgICBVUkwgdXJsMjEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Vi a2l0Lm9yZy8/PyIpOworICAgIFVSTCB1cmwyMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz8vP3Rlc3Q9dGVzdCIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBT dHJpbmc+PiB0ZXN0VmVjdG9yMjEyMiB7eyIvP3Rlc3QiLCAidGVzdCJ9LCB7Ij8iLCAiIn19Owor ICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMjEsIHVybDIyKSwgdGVz dFZlY3RvcjIxMjIpOworICAgIAorICAgIFVSTCB1cmwyMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz89dGVzdCIpOworICAgIFVSTCB1cmwyNCA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz89PSIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBT dHJpbmc+PiB0ZXN0VmVjdG9yMjMyNCB7eyIiLCAiPSJ9LCB7IiIsICJ0ZXN0In19OworICAgIEVY UEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMjMsIHVybDI0KSwgdGVzdFZlY3Rv cjIzMjQpOworICAgIAorICAgIFVSTCB1cmwyNyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnPz8iKTsKKyAgICBVUkwgdXJsMjggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZz8vP3Rlc3Q9dGVzdCIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJp bmc+PiB0ZXN0VmVjdG9yMjcyOCB7eyIvP3Rlc3QiLCAidGVzdCJ9LCB7Ij8iLCAiIn19OworICAg IEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMjcsIHVybDI4KSwgdGVzdFZl Y3RvcjI3MjgpOworICAgIAorICAgIFVSTCB1cmwyOSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnPz10ZXN0Iik7CisgICAgVVJMIHVybDMwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmc/PT0iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5n Pj4gdGVzdFZlY3RvcjI5MzAge3siIiwgIj0ifSwgeyIiLCAidGVzdCJ9fTsKKyAgICBFWFBFQ1Rf RVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDI5LCB1cmwzMCksIHRlc3RWZWN0b3IyOTMw KTsKKyAgICAKKyAgICBVUkwgdXJsMzEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9y Zz89PyIpOworICAgIFVSTCB1cmwzMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3Jn PT8iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3Rv cjMxMzIge3siIiwgIj8ifX07CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVy cyh1cmwzMSwgdXJsMzIpLCB0ZXN0VmVjdG9yMzEzMik7CisgICAgCisgICAgVVJMIHVybDI1ID0g Y3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz0/Iik7CisgICAgVVJMIHVybDI2ID0g Y3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPT8iKTsKKyAgICBWZWN0b3I8S2V5VmFs dWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjI1MjYge3siIiwgIj8ifX07CisgICAg RVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwyNSwgdXJsMjYpLCB0ZXN0VmVj dG9yMjUyNik7Cit9CisKK1RFU1RfRihXVEZfVVJMLCBVUkxJc0VxdWFsSWdub3JpbmdRdWVyeUFu ZEZyYWdtZW50cykKK3sKKyAgICBVUkwgdXJsMSA9IGNyZWF0ZVVSTCgid3d3LndlYmtpdC5vcmcv PyIpOworICAgIFVSTCB1cmwyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tl eTE9dmFsMSIpOworICAgIEVYUEVDVF9GQUxTRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdt ZW50cyh1cmwxLCB1cmwyKSk7CisKKyAgICBVUkwgdXJsID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmlu Z1F1ZXJ5QW5kRnJhZ21lbnRzKHVybCwgdXJsKSk7CisgICAgCisgICAgVVJMIHVybDMgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDQgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX1RSVUUo aXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMywgdXJsNCkpOworICAgIAorICAg IFVSTCB1cmw3ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmc/Iik7CisgICAgVVJM IHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7Cisg ICAgRVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsNywgdXJs OCkpOworICAgIAorICAgIFVSTCB1cmw1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LmV4YW1wbGUu b3JnL3BhdGg/Iik7CisgICAgVVJMIHVybDYgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZy8/a2V5MT12YWwxIik7CisgICAgRVhQRUNUX0ZBTFNFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5 QW5kRnJhZ21lbnRzKHVybDUsIHVybDYpKTsKKyAgICAKKyAgICBVUkwgdXJsOSA9IGNyZWF0ZVVS TCgiaHR0cDovL2V4YW1wbGUuY29tP2E9YiIpOworICAgIFVSTCB1cmwxMCA9IGNyZWF0ZVVSTCgi aHR0cDovL2V4YW1wbGUuY29tLz9hPWIiKTsKKyAgICBFWFBFQ1RfVFJVRShpc0VxdWFsSWdub3Jp bmdRdWVyeUFuZEZyYWdtZW50cyh1cmw5LCB1cmwxMCkpOworICAgIAorICAgIFVSTCB1cmwyMSA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8/Iik7CisgICAgVVJMIHVybDIyID0g Y3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPy8/Iik7CisgICAgRVhQRUNUX1RSVUUo aXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMjEsIHVybDIyKSk7CisgICAgCisg ICAgVVJMIHVybDIzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz0mIik7Cisg ICAgVVJMIHVybDI0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz09JiIpOwor ICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKHVybDIzLCB1 cmwyNCkpOworICAgIAorICAgIFVSTCB1cmwyNyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnPyY/Iik7CisgICAgVVJMIHVybDI4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtp dC5vcmc/PyYiKTsKKyAgICBFWFBFQ1RfVFJVRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdt ZW50cyh1cmwyNywgdXJsMjgpKTsKKyAgICAKKyAgICBVUkwgdXJsMzEgPSBjcmVhdGVVUkwoImh0 dHA6Ly93d3cud2Via2l0Lm9yZz89PyIpOworICAgIFVSTCB1cmwzMiA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnPT8iKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5n UXVlcnlBbmRGcmFnbWVudHModXJsMzEsIHVybDMyKSk7CisgICAgCisgICAgVVJMIHVybDI1ID0g Y3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz0/Iik7CisgICAgVVJMIHVybDI2ID0g Y3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPT8iKTsKKyAgICBFWFBFQ1RfRkFMU0Uo aXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMjUsIHVybDI2KSk7Cit9CisKK1RF U1RfRihXVEZfVVJMLCBVUkxSZW1vdmVRdWVyeVBhcmFtZXRlcnMpCit7CisgICAgVVJMIHVybCA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsIik7CisgICAgVVJMIHVy bDEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEi KTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsK KyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFs I2ZyYWdtZW50Iik7CisgICAgVVJMIHVybDQgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZy8/a2V5PXZhbCZrZXk9dmFsI2ZyYWdtZW50Iik7CisgICAgVVJMIHVybDUgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5JmtleT0jZnJhZ21lbnQiKTsKKyAgICBVUkwg dXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLyNmcmFnbWVudCIpOworICAg IFVSTCB1cmw3ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwjZnJh Z21lbnQiKTsKKyAgICBVUkwgdXJsOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3Jn LyIpOworICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvI2Zy YWdtZW50Iik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmcvP2tleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEjZnJhZ21lbnQiKTsKKyAgICBVUkwg dXJsMTIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZh bDEjZnJhZ21lbnQiKTsKKyAgICAKKyAgICBIYXNoU2V0PFN0cmluZz4ga2V5UmVtb3ZhbFNldDEg eyJrZXkifTsKKyAgICBIYXNoU2V0PFN0cmluZz4ga2V5UmVtb3ZhbFNldDIgeyJrZXkxIn07Cisg ICAgSGFzaFNldDxTdHJpbmc+IGtleVJlbW92YWxTZXQzIHsia2V5MiJ9OworICAgIEhhc2hTZXQ8 U3RyaW5nPiBrZXlSZW1vdmFsU2V0NCB7ImtleSIsICJrZXkxIn07CisgICAgCisgICAgcmVtb3Zl UXVlcnlQYXJhbWV0ZXJzKHVybDEsIGtleVJlbW92YWxTZXQyKTsKKyAgICBFWFBFQ1RfRVEodXJs MS5zdHJpbmcoKSwgdXJsLnN0cmluZygpKTsKKyAgICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRl cnModXJsMiwga2V5UmVtb3ZhbFNldDEpOworICAgIEVYUEVDVF9FUSh1cmwyLnN0cmluZygpLCB1 cmw4LnN0cmluZygpKTsKKyAgICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRlcnModXJsMywga2V5 UmVtb3ZhbFNldDEpOworICAgIEVYUEVDVF9FUSh1cmwzLnN0cmluZygpLCB1cmw2LnN0cmluZygp KTsKKyAgICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRlcnModXJsNCwga2V5UmVtb3ZhbFNldDEp OworICAgIEVYUEVDVF9FUSh1cmw0LnN0cmluZygpLCB1cmw2LnN0cmluZygpKTsKKyAgICAKKyAg ICByZW1vdmVRdWVyeVBhcmFtZXRlcnModXJsNSwga2V5UmVtb3ZhbFNldDEpOworICAgIEVYUEVD VF9FUSh1cmw1LnN0cmluZygpLCB1cmw2LnN0cmluZygpKTsKKyAgICAKKyAgICByZW1vdmVRdWVy eVBhcmFtZXRlcnModXJsNiwga2V5UmVtb3ZhbFNldDEpOworICAgIEVYUEVDVF9FUSh1cmw2LnN0 cmluZygpLCB1cmw5LnN0cmluZygpKTsKKyAgICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRlcnMo dXJsNywga2V5UmVtb3ZhbFNldDIpOworICAgIEVYUEVDVF9FUSh1cmw3LnN0cmluZygpLCB1cmwx MC5zdHJpbmcoKSk7CisgICAgCisgICAgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKHVybDExLCBrZXlS ZW1vdmFsU2V0Myk7CisgICAgRVhQRUNUX0VRKHVybDExLnN0cmluZygpLCB1cmwxMi5zdHJpbmco KSk7CisgICAgCisgICAgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKHVybDEyLCBrZXlSZW1vdmFsU2V0 NCk7CisgICAgRVhQRUNUX0VRKHVybDEyLnN0cmluZygpLCB1cmw5LnN0cmluZygpKTsKK30KKwog fSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQo= 434848 2021-08-03 12:05:46 -0700 2021-08-03 14:53:06 -0700 Patch bug-228122-20210803120545.patch text/plain 17225 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLjA0OTVkZDg2ZTUxZmE5ZmQzNTMzYzQzNWQ3YTUzMjBmYzI1M2Fk ZDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjEtMDgtMDMgIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBmdW5jdGlvbmFsaXRpZXMgZm9yIHBhcnNp bmcgVVJMIHF1ZXJ5IHN0cmluZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisgICAgICAgIAorICAgICAgICBBZGRlZCBwYXJzaW5nIG9mIFVSTCBxdWVyeSBzdHJpbmdzLgor ICAgICAgICAKKyAgICAgICAgKiB3dGYvS2V5VmFsdWVQYWlyLmg6CisgICAgICAgIChXVEY6Om9w ZXJhdG9yPT0gY29uc3QpOgorICAgICAgICAqIHd0Zi9VUkwuY3BwOgorICAgICAgICAoV1RGOjpV Ukw6OmRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyk6CisgICAgICAgIChXVEY6Omxlbmd0aE9mVVJM SWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyk6CisgICAgICAgIChXVEY6OlVSTDo6aXNFcXVhbEln bm9yaW5nUXVlcnlBbmRGcmFnbWVudHMpOgorICAgICAgICAoV1RGOjpVUkw6OnJlbW92ZVF1ZXJ5 UGFyYW1ldGVycyk6CisgICAgICAgICogd3RmL1VSTC5oOgorCiAyMDIxLTA3LTE2ICBBbGV4YW5k ZXIgTWlraGF5bGVua28gIDxhbGV4bUBnbm9tZS5vcmc+CiAKICAgICAgICAgW0dUS11bV1BFXSBT dXBwb3J0IGNvbG9yLXNjaGVtZXMgQ1NTIHByb3BlcnR5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9LZXlWYWx1ZVBhaXIuaCBiL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCmluZGV4 IGIxYzJiYzM2ODM1ZGU2ZDBiZDQxMTc5MzViOTVkMmEwMmNhYjA4ZTIuLmZmZWI1N2YzOWYwZDA1 YmVlNGU2ZTZlODM5YWU1NjRhYTM0MmJkYWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0tl eVZhbHVlUGFpci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCkBAIC03MCw2 ICs3MCwxMSBAQCBpbmxpbmUgS2V5VmFsdWVQYWlyPHR5cGVuYW1lIHN0ZDo6ZGVjYXk8Sz46OnR5 cGUsIHR5cGVuYW1lIHN0ZDo6ZGVjYXk8Vj46OnR5cGU+CiAgICAgcmV0dXJuIEtleVZhbHVlUGFp cjx0eXBlbmFtZSBzdGQ6OmRlY2F5PEs+Ojp0eXBlLCB0eXBlbmFtZSBzdGQ6OmRlY2F5PFY+Ojp0 eXBlPiB7IHN0ZDo6Zm9yd2FyZDxLPihrZXkpLCBzdGQ6OmZvcndhcmQ8Vj4odmFsdWUpIH07CiB9 CiAKK3RlbXBsYXRlPHR5cGVuYW1lIEtleVR5cGUsIHR5cGVuYW1lIFZhbHVlVHlwZT4gY29uc3Rl eHByIGJvb2wgb3BlcmF0b3I9PShjb25zdCBLZXlWYWx1ZVBhaXI8S2V5VHlwZSwgVmFsdWVUeXBl PiYgYSwgY29uc3QgS2V5VmFsdWVQYWlyPEtleVR5cGUsIFZhbHVlVHlwZT4mIGIpCit7CisgICAg cmV0dXJuIGEua2V5ID09IGIua2V5ICYmIGEudmFsdWUgPT0gYi52YWx1ZTsKK30KKwogfQogCiB1 c2luZyBXVEY6OktleVZhbHVlUGFpcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5j cHAgYi9Tb3VyY2UvV1RGL3d0Zi9VUkwuY3BwCmluZGV4IGQ5YzA4MmNlYzY5YTVkODQ4ZDAzZDE2 ZTA4OTRhOGNiNzJhNWE1ZGIuLjM3Y2ZiZjM4ZjUzMjIzMDc5NTY3YjFhMGMwMDBlN2YzMjYxYTA4 Y2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAKKysrIGIvU291cmNlL1dURi93 dGYvVVJMLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVk ZSA8dW5pY29kZS91aWRuYS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8 d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9OZXZl ckRlc3Ryb3llZC5oPgogI2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgpAQCAtMTE2Niw0ICsx MTY3LDkxIEBAIGJvb2wgVVJMOjpob3N0SXNJUEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQogCiAj ZW5kaWYKIAorVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IGRpZmZlcmluZ1F1 ZXJ5UGFyYW1ldGVycyhjb25zdCBVUkwmIGZpcnN0VVJMLCBjb25zdCBVUkwmIHNlY29uZFVSTCkK K3sKKyAgICBpZiAoIWZpcnN0VVJMLmlzVmFsaWQoKSB8fCAhc2Vjb25kVVJMLmlzVmFsaWQoKSkK KyAgICAgICAgcmV0dXJuIHsgfTsKKyAgICAKKyAgICBhdXRvIGZpcnN0UXVlcnlQYXJhbWV0ZXJz ID0gVVJMUGFyc2VyOjpwYXJzZVVSTEVuY29kZWRGb3JtKGZpcnN0VVJMLnF1ZXJ5KCkpOworICAg IGF1dG8gc2Vjb25kUXVlcnlQYXJhbWV0ZXJzID0gVVJMUGFyc2VyOjpwYXJzZVVSTEVuY29kZWRG b3JtKHNlY29uZFVSTC5xdWVyeSgpKTsKKyAgICAKKyAgICBpZiAoZmlyc3RRdWVyeVBhcmFtZXRl cnMuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gc2Vjb25kUXVlcnlQYXJhbWV0ZXJzOworCisg ICAgaWYgKHNlY29uZFF1ZXJ5UGFyYW1ldGVycy5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiBm aXJzdFF1ZXJ5UGFyYW1ldGVyczsKKyAgICAKKyAgICBhdXRvIGNvbXBhcmUgPSBbXSAoY29uc3Qg S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYSwgY29uc3QgS2V5VmFsdWVQYWlyPFN0cmlu ZywgU3RyaW5nPiYgYikgeworICAgICAgICBpZiAoaW50IHJlc3VsdCA9IGNvZGVQb2ludENvbXBh cmUoYS5rZXksIGIua2V5KSkKKyAgICAgICAgICAgIHJldHVybiByZXN1bHQ7CisgICAgICAgIHJl dHVybiBjb2RlUG9pbnRDb21wYXJlKGEudmFsdWUsIGIudmFsdWUpOworICAgICAgICAKKyAgICB9 OworICAgIGF1dG8gY29tcGFyZXNMZXNzVGhhbiA9IFsmY29tcGFyZV0gKGNvbnN0IEtleVZhbHVl UGFpcjxTdHJpbmcsIFN0cmluZz4mIGEsIGNvbnN0IEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmlu Zz4mIGIpIHsKKyAgICAgICAgcmV0dXJuIGNvbXBhcmUoYSwgYikgPCAwOworICAgIH07CisgICAg CisgICAgc3RkOjpzb3J0KGZpcnN0UXVlcnlQYXJhbWV0ZXJzLmJlZ2luKCksIGZpcnN0UXVlcnlQ YXJhbWV0ZXJzLmVuZCgpLCBjb21wYXJlc0xlc3NUaGFuKTsKKyAgICBzdGQ6OnNvcnQoc2Vjb25k UXVlcnlQYXJhbWV0ZXJzLmJlZ2luKCksIHNlY29uZFF1ZXJ5UGFyYW1ldGVycy5lbmQoKSwgY29t cGFyZXNMZXNzVGhhbik7CisgICAgc2l6ZV90IHRvdGFsRmlyc3RRdWVyeVBhcmFtZXRlcnMgPSBm aXJzdFF1ZXJ5UGFyYW1ldGVycy5zaXplKCk7CisgICAgc2l6ZV90IHRvdGFsU2Vjb25kUXVlcnlQ YXJhbWV0ZXJzID0gc2Vjb25kUXVlcnlQYXJhbWV0ZXJzLnNpemUoKTsKKyAgICBzaXplX3QgaW5k ZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJzID0gMDsKKyAgICBzaXplX3QgaW5kZXhJblNlY29uZFF1 ZXJ5UGFyYW1ldGVycyA9IDA7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmlu Zz4+IGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVyczsKKyAgICB3aGlsZSAoaW5kZXhJbkZpcnN0UXVl cnlQYXJhbWV0ZXJzIDwgdG90YWxGaXJzdFF1ZXJ5UGFyYW1ldGVycyAmJiBpbmRleEluU2Vjb25k UXVlcnlQYXJhbWV0ZXJzIDwgdG90YWxTZWNvbmRRdWVyeVBhcmFtZXRlcnMpIHsKKyAgICAgICAg aW50IGNvbXBhcmlzb24gPSBjb21wYXJlKGZpcnN0UXVlcnlQYXJhbWV0ZXJzW2luZGV4SW5GaXJz dFF1ZXJ5UGFyYW1ldGVyc10sIHNlY29uZFF1ZXJ5UGFyYW1ldGVyc1tpbmRleEluU2Vjb25kUXVl cnlQYXJhbWV0ZXJzXSk7CisgICAgICAgIGlmIChjb21wYXJpc29uIDwgMCkgeworICAgICAgICAg ICAgZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzLmFwcGVuZChmaXJzdFF1ZXJ5UGFyYW1ldGVyc1tp bmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnNdKTsKKyAgICAgICAgICAgIGluZGV4SW5GaXJzdFF1 ZXJ5UGFyYW1ldGVycysrOworICAgICAgICB9IGVsc2UgaWYgKGNvbXBhcmlzb24gPiAwKSB7Cisg ICAgICAgICAgICBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMuYXBwZW5kKHNlY29uZFF1ZXJ5UGFy YW1ldGVyc1tpbmRleEluU2Vjb25kUXVlcnlQYXJhbWV0ZXJzXSk7CisgICAgICAgICAgICBpbmRl eEluU2Vjb25kUXVlcnlQYXJhbWV0ZXJzKys7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAg ICBpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnMrKzsKKyAgICAgICAgICAgIGluZGV4SW5TZWNv bmRRdWVyeVBhcmFtZXRlcnMrKzsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICB3aGlsZSAo aW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJzIDwgdG90YWxGaXJzdFF1ZXJ5UGFyYW1ldGVycykg eworICAgICAgICBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMuYXBwZW5kKGZpcnN0UXVlcnlQYXJh bWV0ZXJzW2luZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVyc10pOworICAgICAgICBpbmRleEluRmly c3RRdWVyeVBhcmFtZXRlcnMrKzsKKyAgICB9CisgICAgCisgICAgd2hpbGUgKGluZGV4SW5TZWNv bmRRdWVyeVBhcmFtZXRlcnMgPCB0b3RhbFNlY29uZFF1ZXJ5UGFyYW1ldGVycykgeworICAgICAg ICBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMuYXBwZW5kKHNlY29uZFF1ZXJ5UGFyYW1ldGVyc1tp bmRleEluU2Vjb25kUXVlcnlQYXJhbWV0ZXJzXSk7CisgICAgICAgIGluZGV4SW5TZWNvbmRRdWVy eVBhcmFtZXRlcnMrKzsKKyAgICB9CisgICAgCisgICAgcmV0dXJuIGRpZmZlcmluZ1F1ZXJ5UGFy YW1ldGVyczsKK30KKworc3RhdGljIFN0cmluZ1ZpZXcgc3Vic3RyaW5nSWdub3JpbmdRdWVyeUFu ZEZyYWdtZW50cyhjb25zdCBVUkwmIHVybCkKK3sKKyAgICByZXR1cm4gU3RyaW5nVmlldyh1cmwu c3RyaW5nKCkpLmxlZnQodXJsLnBhdGhFbmQoKSk7Cit9CisKK2Jvb2wgaXNFcXVhbElnbm9yaW5n UXVlcnlBbmRGcmFnbWVudHMoY29uc3QgVVJMJiBhLCBjb25zdCBVUkwmIGIpCit7CisgICAgcmV0 dXJuIGEuaXNWYWxpZCgpICYmIGIuaXNWYWxpZCgpICYmIHN1YnN0cmluZ0lnbm9yaW5nUXVlcnlB bmRGcmFnbWVudHMoYSkgPT0gc3Vic3RyaW5nSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyhiKTsK K30KKwordm9pZCByZW1vdmVRdWVyeVBhcmFtZXRlcnMoVVJMJiB1cmwsIGNvbnN0IEhhc2hTZXQ8 U3RyaW5nPiYga2V5c1RvUmVtb3ZlKQoreworICAgIGlmIChrZXlzVG9SZW1vdmUuaXNFbXB0eSgp KQorICAgICAgICByZXR1cm47CisgICAgCisgICAgYXV0byBxdWVyeVBhcmFtZXRlcnNMaXN0ID0g VVJMUGFyc2VyOjpwYXJzZVVSTEVuY29kZWRGb3JtKHVybC5xdWVyeSgpKTsKKyAgICBTdHJpbmdC dWlsZGVyIHF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzOworICAgIGZvciAoYXV0byYgc2luZ2xlUXVl cnlQYXJhbWV0ZXIgOiBxdWVyeVBhcmFtZXRlcnNMaXN0KSB7CisgICAgICAgIGlmICgha2V5c1Rv UmVtb3ZlLmNvbnRhaW5zKHNpbmdsZVF1ZXJ5UGFyYW1ldGVyLmtleSkpIHsKKyAgICAgICAgICAg IGlmICghcXVlcnlXaXRob3V0UmVtb3ZhbEtleXMuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAg IHF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzLmFwcGVuZCgnJicsIHNpbmdsZVF1ZXJ5UGFyYW1ldGVy LmtleSwgJz0nLCBzaW5nbGVRdWVyeVBhcmFtZXRlci52YWx1ZSk7CisgICAgICAgICAgICBlbHNl CisgICAgICAgICAgICAgICAgcXVlcnlXaXRob3V0UmVtb3ZhbEtleXMuYXBwZW5kKHNpbmdsZVF1 ZXJ5UGFyYW1ldGVyLmtleSwgJz0nLCBzaW5nbGVRdWVyeVBhcmFtZXRlci52YWx1ZSk7CisgICAg ICAgIH0KKyAgICB9CisgICAgCisgICAgdXJsLnNldFF1ZXJ5KHF1ZXJ5V2l0aG91dFJlbW92YWxL ZXlzKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0 Zi9VUkwuaCBiL1NvdXJjZS9XVEYvd3RmL1VSTC5oCmluZGV4IGY0NDU0MjFlMWZlMjNjYWJiNjE1 N2Y3MGQ5YzQ0NmEyODZjNWYwNTYuLmVkYTQxMTdiNDliNDNlMTNiMDkxNDkxOWUzNDI3NjcxYzU3 ODk0ZWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1VSTC5oCisrKyBiL1NvdXJjZS9XVEYv d3RmL1VSTC5oCkBAIC0yNDQsNiArMjQ0LDkgQEAgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFN0cmlu ZyYsIGNvbnN0IFVSTCYpOwogCiBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBlcXVhbElnbm9yaW5n RnJhZ21lbnRJZGVudGlmaWVyKGNvbnN0IFVSTCYsIGNvbnN0IFVSTCYpOwogV1RGX0VYUE9SVF9Q UklWQVRFIGJvb2wgcHJvdG9jb2xIb3N0QW5kUG9ydEFyZUVxdWFsKGNvbnN0IFVSTCYsIGNvbnN0 IFVSTCYpOworV1RGX0VYUE9SVF9QUklWQVRFIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBT dHJpbmc+PiBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMoY29uc3QgVVJMJiwgY29uc3QgVVJMJik7 CitXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50 cyhjb25zdCBVUkwmLCBjb25zdCBVUkwmKTsKK1dURl9FWFBPUlRfUFJJVkFURSB2b2lkIHJlbW92 ZVF1ZXJ5UGFyYW1ldGVycyhVUkwmLCBjb25zdCBIYXNoU2V0PFN0cmluZz4mKTsKIAogV1RGX0VY UE9SVF9QUklWQVRFIGNvbnN0IFVSTCYgYWJvdXRCbGFua1VSTCgpOwogV1RGX0VYUE9SVF9QUklW QVRFIGNvbnN0IFVSTCYgYWJvdXRTcmNEb2NVUkwoKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5n ZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBhNjZhMjRmZTQ3OWYxZTk0MjdmNzlkMjc3YmQx NGVlODkwZTdmYjNjLi4xZWM4NDJhMWNiNzA5OWIxNGY4NWVlNjRjNDhkNzRkZTI4YmE2NjVkIDEw MDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTUgQEAKKzIwMjEtMDgtMDMgIFJpc3VsIElzbGFtICA8cmlzdWxfaXNsYW1AYXBwbGUuY29t PgorCisgICAgICAgIEFkZCBmdW5jdGlvbmFsaXRpZXMgZm9yIHBhcnNpbmcgVVJMIHF1ZXJ5IHN0 cmluZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4 MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAgIAorICAg ICAgICBBZGRlZCB0aGUgdGVzdCBmdW5jdGlvbnMgcmVxdWlyZWQgZm9yIHBhcnNpbmcgVVJMIHF1 ZXJ5IHN0cmluZy4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHA6 CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUX0YpOgorCiAyMDIxLTA3LTE5ICBSeWFuIEhh ZGRhZCAgPHJ5YW5oYWRkYWRAYXBwbGUuY29tPgogCiAgICAgICAgIFtidWlsZC53ZWJraXQub3Jn XSBsbGRiLXdlYmtpdC10ZXN0IGlzIGZhaWxpbmcgb24gQ2F0YWxpbmEgcXVldWVzCmRpZmYgLS1n aXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwIGIvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XVEYvVVJMLmNwcAppbmRleCBlZThjZTE5MjU1OTEzMTIyNjM0MzZiYjJl MWFiYmExZDdmZDc4Mzg2Li42ZTliZTFhZjgzNzIyMmEwZWM4ZTI0ZWYzODQ5NTU0OTRiNmI3Yjc5 IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwCisrKyBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHAKQEAgLTI1LDEwICsyNSwxMiBA QAogCiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV1RGU3RyaW5nVXRpbGl0aWVzLmgi CisjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgog I2luY2x1ZGUgPHd0Zi9TdHJpbmdQcmludFN0cmVhbS5oPgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4K ICNpbmNsdWRlIDx3dGYvVVJMUGFyc2VyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFz aC5oPgogCiBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CiAKQEAgLTM1Nyw0ICszNTksMTkxIEBA IFRFU1RfRihXVEZfVVJMLCBQcmludFN0cmVhbSkKICAgICBFWFBFQ1RfRVEob3V0LnRvU3RyaW5n KCksIHVybFN0cmluZyk7CiB9CiAKK1RFU1RfRihXVEZfVVJMLCBVUkxEaWZmZXJpbmdRdWVyeVBh cmFtZXRlcnMpCit7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8i KTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkx PXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZl Y3RvciB7IH07CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwxLCB1 cmwyKSwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybCA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVl cnlQYXJhbWV0ZXJzKHVybCwgdXJsKSwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDkg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgVVJM IHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOwor ICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsOSwgdXJsMTApICwgdGVz dFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Vi a2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZy8/Iik7CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmw3LCB1 cmw4KSwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDMgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDQgPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJp bmcsIFN0cmluZz4+IHRlc3RWZWN0b3IzNCB7eyJrZXkxIiwgInZhbDEifX07CisgICAgRVhQRUNU X0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwzLCB1cmw0KSwgdGVzdFZlY3RvcjM0KTsK KyAgICAKKyAgICBVUkwgdXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9r ZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQu b3JnLz8iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZl Y3RvcjU2IHt7ImtleTEiLCAidmFsMSJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQ YXJhbWV0ZXJzKHVybDUsIHVybDYpLCB0ZXN0VmVjdG9yNTYpOworICAgIAorICAgIFVSTCB1cmwx MyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEma2V5Mj12YWwy Iik7CisgICAgVVJMIHVybDE0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tl eTE9dmFsMSZrZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPj4gdGVzdFZlY3RvcjEzMTQge3sia2V5MSIsICJ2YWwxIn0sIHsia2V5MiIsICJ2YWwyIn19 OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMTMsIHVybDE0KSwg dGVzdFZlY3RvcjEzMTQpOworICAgIAorICAgIFVSTCB1cmwxNSA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsMTYgPSBjcmVhdGVVUkwo Imh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5Mj12YWwyIik7CisgICAgVmVjdG9yPEtleVZhbHVl UGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IxNTE2IHt7ImtleTEiLCAidmFsMSJ9LCB7 ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJz KHVybDE1LCB1cmwxNiksIHRlc3RWZWN0b3IxNTE2KTsKKyAgICAKKyAgICBVUkwgdXJsMTEgPSBj cmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTI9dmFsMiIpOwor ICAgIFVSTCB1cmwxMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZh bDEma2V5Mz12YWwzIik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+ IHRlc3RWZWN0b3IxMTEyIHt7ImtleTIiLCAidmFsMiJ9LCB7ImtleTMiLCAidmFsMyJ9fTsKKyAg ICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDExLCB1cmwxMiksIHRlc3RW ZWN0b3IxMTEyKTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTI9dmFsMiIpOworICAgIFVSTCB1cmwxOCA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9dmFsMyIpOworICAgIFZlY3Rv cjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTcxOCB7eyJrZXkxIiwg IiJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9LCB7ImtleTMiLCAidmFsMyJ9 fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDE3LCB1cmwxOCks IHRlc3RWZWN0b3IxNzE4KTsKKyAgICAKKyAgICBVUkwgdXJsMTkgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTE9dmFsMSZrZXkyPXZhbDIiKTsKKyAgICBV UkwgdXJsMjAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MSZrZXkzPXZh bDMiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3Rv cjE5MjAge3sia2V5MSIsICIifSwgeyJrZXkxIiwgInZhbDEifSwgeyJrZXkxIiwgInZhbDEifSwg eyJrZXkyIiwgInZhbDIifSwgeyJrZXkzIiwgInZhbDMifX07CisgICAgRVhQRUNUX0VRKGRpZmZl cmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwxOSwgdXJsMjApLCB0ZXN0VmVjdG9yMTkyMCk7CisgICAg CisgICAgVVJMIHVybDIxID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz8iKTsK KyAgICBVUkwgdXJsMjIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Lz90ZXN0 PXRlc3QiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZl Y3RvcjIxMjIge3siLz90ZXN0IiwgInRlc3QifSwgeyI/IiwgIiJ9fTsKKyAgICBFWFBFQ1RfRVEo ZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIxLCB1cmwyMiksIHRlc3RWZWN0b3IyMTIyKTsK KyAgICAKKyAgICBVUkwgdXJsMjMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ PXRlc3QiKTsKKyAgICBVUkwgdXJsMjQgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9y Zy8/PT0iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZl Y3RvcjIzMjQge3siIiwgIj0ifSwgeyIiLCAidGVzdCJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVy aW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIzLCB1cmwyNCksIHRlc3RWZWN0b3IyMzI0KTsKKyAgICAK KyAgICBVUkwgdXJsMjcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZz8/Iik7Cisg ICAgVVJMIHVybDI4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmc/Lz90ZXN0PXRl c3QiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3Rv cjI3Mjgge3siLz90ZXN0IiwgInRlc3QifSwgeyI/IiwgIiJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlm ZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDI3LCB1cmwyOCksIHRlc3RWZWN0b3IyNzI4KTsKKyAg ICAKKyAgICBVUkwgdXJsMjkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZz89dGVz dCIpOworICAgIFVSTCB1cmwzMCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnPz09 Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3Iy OTMwIHt7IiIsICI9In0sIHsiIiwgInRlc3QifX07CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1 ZXJ5UGFyYW1ldGVycyh1cmwyOSwgdXJsMzApLCB0ZXN0VmVjdG9yMjkzMCk7CisgICAgCisgICAg VVJMIHVybDMxID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmc/PT8iKTsKKyAgICBV UkwgdXJsMzIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZz0/Iik7CisgICAgVmVj dG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IzMTMyIHt7IiIsICI/ In19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMzEsIHVybDMy KSwgdGVzdFZlY3RvcjMxMzIpOworICAgIAorICAgIFVSTCB1cmwyNSA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz89PyIpOworICAgIFVSTCB1cmwyNiA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz0/Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcs IFN0cmluZz4+IHRlc3RWZWN0b3IyNTI2IHt7IiIsICI/In19OworICAgIEVYUEVDVF9FUShkaWZm ZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMjUsIHVybDI2KSwgdGVzdFZlY3RvcjI1MjYpOworfQor CitURVNUX0YoV1RGX1VSTCwgVVJMSXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMpCit7 CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwg dXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAg ICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMSwgdXJs MikpOworCisgICAgVVJMIHVybCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9r ZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdt ZW50cyh1cmwsIHVybCkpOworICAgIAorICAgIFVSTCB1cmwzID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvPyIpOworICAgIFVSTCB1cmw0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmlu Z1F1ZXJ5QW5kRnJhZ21lbnRzKHVybDMsIHVybDQpKTsKKyAgICAKKyAgICBVUkwgdXJsNyA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnPyIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRl VVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9UUlVF KGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKHVybDcsIHVybDgpKTsKKyAgICAKKyAg ICBVUkwgdXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy5leGFtcGxlLm9yZy9wYXRoPyIpOwor ICAgIFVSTCB1cmw2ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleTE9dmFs MSIpOworICAgIEVYUEVDVF9GQUxTRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1 cmw1LCB1cmw2KSk7CisgICAgCisgICAgVVJMIHVybDkgPSBjcmVhdGVVUkwoImh0dHA6Ly9leGFt cGxlLmNvbT9hPWIiKTsKKyAgICBVUkwgdXJsMTAgPSBjcmVhdGVVUkwoImh0dHA6Ly9leGFtcGxl LmNvbS8/YT1iIik7CisgICAgRVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFn bWVudHModXJsOSwgdXJsMTApKTsKKyAgICAKKyAgICBVUkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0 dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDEyID0gY3JlYXRlVVJMKCJodHRw Oi8vd3d3LndlYmtpdC5vcmc/Iik7CisgICAgRVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVl cnlBbmRGcmFnbWVudHModXJsMTEsIHVybDEyKSk7CisgICAgCisgICAgVVJMIHVybDIxID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz8iKTsKKyAgICBVUkwgdXJsMjIgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Lz8iKTsKKyAgICBFWFBFQ1RfVFJVRShpc0Vx dWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwyMSwgdXJsMjIpKTsKKyAgICAKKyAgICBV UkwgdXJsMjMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/PSYiKTsKKyAgICBV UkwgdXJsMjQgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/PT0mIik7CisgICAg RVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMjMsIHVybDI0 KSk7CisgICAgCisgICAgVVJMIHVybDI3ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmc/Jj8iKTsKKyAgICBVUkwgdXJsMjggPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9y Zz8/JiIpOworICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRz KHVybDI3LCB1cmwyOCkpOworICAgIAorICAgIFVSTCB1cmwzMSA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnPz0/Iik7CisgICAgVVJMIHVybDMyID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmc9PyIpOworICAgIEVYUEVDVF9GQUxTRShpc0VxdWFsSWdub3JpbmdRdWVy eUFuZEZyYWdtZW50cyh1cmwzMSwgdXJsMzIpKTsKKyAgICAKKyAgICBVUkwgdXJsMjUgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/PT8iKTsKKyAgICBVUkwgdXJsMjYgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy89PyIpOworICAgIEVYUEVDVF9GQUxTRShpc0Vx dWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwyNSwgdXJsMjYpKTsKK30KKworVEVTVF9G KFdURl9VUkwsIFVSTFJlbW92ZVF1ZXJ5UGFyYW1ldGVycykKK3sKKyAgICBVUkwgdXJsID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwiKTsKKyAgICBVUkwgdXJsMSA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsJmtleTE9dmFsMSIpOwor ICAgIFVSTCB1cmwyID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPyIpOworICAg IFVSTCB1cmwzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwjZnJh Z21lbnQiKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3Jn Lz9rZXk9dmFsJmtleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsNSA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkma2V5PSNmcmFnbWVudCIpOworICAgIFVSTCB1cmw2 ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvI2ZyYWdtZW50Iik7CisgICAgVVJM IHVybDcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCNmcmFnbWVu dCIpOworICAgIFVSTCB1cmw4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvIik7 CisgICAgVVJMIHVybDkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8jZnJhZ21l bnQiKTsKKyAgICBVUkwgdXJsMTAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5PXZhbCNmcmFnbWVudCIpOworICAgIFVSTCB1cmwxMSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz9rZXk9dmFsJmtleTE9dmFsMSNmcmFnbWVudCIpOworICAgIFVSTCB1cmwx MiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsJmtleTE9dmFsMSNm cmFnbWVudCIpOworICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQu b3JnIik7CisgICAgCisgICAgSGFzaFNldDxTdHJpbmc+IGtleVJlbW92YWxTZXQxIHsia2V5In07 CisgICAgSGFzaFNldDxTdHJpbmc+IGtleVJlbW92YWxTZXQyIHsia2V5MSJ9OworICAgIEhhc2hT ZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0MyB7ImtleTIifTsKKyAgICBIYXNoU2V0PFN0cmluZz4g a2V5UmVtb3ZhbFNldDQgeyJrZXkiLCAia2V5MSJ9OworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFy YW1ldGVycyh1cmwxLCBrZXlSZW1vdmFsU2V0Mik7CisgICAgRVhQRUNUX0VRKHVybDEuc3RyaW5n KCksIHVybC5zdHJpbmcoKSk7CisgICAgCisgICAgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKHVybDIs IGtleVJlbW92YWxTZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJsMi5zdHJpbmcoKSwgdXJsOC5zdHJp bmcoKSk7CisgICAgCisgICAgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKHVybDMsIGtleVJlbW92YWxT ZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJsMy5zdHJpbmcoKSwgdXJsNi5zdHJpbmcoKSk7CisgICAg CisgICAgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKHVybDQsIGtleVJlbW92YWxTZXQxKTsKKyAgICBF WFBFQ1RfRVEodXJsNC5zdHJpbmcoKSwgdXJsNi5zdHJpbmcoKSk7CisgICAgCisgICAgcmVtb3Zl UXVlcnlQYXJhbWV0ZXJzKHVybDUsIGtleVJlbW92YWxTZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJs NS5zdHJpbmcoKSwgdXJsNi5zdHJpbmcoKSk7CisgICAgCisgICAgcmVtb3ZlUXVlcnlQYXJhbWV0 ZXJzKHVybDYsIGtleVJlbW92YWxTZXQxKTsKKyAgICBFWFBFQ1RfRVEodXJsNi5zdHJpbmcoKSwg dXJsOS5zdHJpbmcoKSk7CisgICAgCisgICAgcmVtb3ZlUXVlcnlQYXJhbWV0ZXJzKHVybDcsIGtl eVJlbW92YWxTZXQyKTsKKyAgICBFWFBFQ1RfRVEodXJsNy5zdHJpbmcoKSwgdXJsMTAuc3RyaW5n KCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmwxMSwga2V5UmVtb3ZhbFNl dDMpOworICAgIEVYUEVDVF9FUSh1cmwxMS5zdHJpbmcoKSwgdXJsMTIuc3RyaW5nKCkpOworICAg IAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmwxMiwga2V5UmVtb3ZhbFNldDQpOworICAg IEVYUEVDVF9FUSh1cmwxMi5zdHJpbmcoKSwgdXJsOS5zdHJpbmcoKSk7CisgICAgCisgICAgcmVt b3ZlUXVlcnlQYXJhbWV0ZXJzKHVybDEzLCBrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VR KHVybDEzLnN0cmluZygpLCB1cmw4LnN0cmluZygpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgVGVz dFdlYktpdEFQSQo= 434862 2021-08-03 14:53:10 -0700 2021-08-03 15:23:17 -0700 Patch bug-228122-20210803145309.patch text/plain 17853 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLjZkNWY3YTIwNzIxZDcyODQ4Y2VmNThhMjZmMmEzZTczMWUyNzY3 MTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjEtMDgtMDMgIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBmdW5jdGlvbnMgZm9yIHBhcnNpbmcgVVJM IHF1ZXJ5IHN0cmluZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAg ICAgIAorICAgICAgICBBZGRlZCBwYXJzaW5nIG9mIFVSTCBxdWVyeSBzdHJpbmdzLgorICAgICAg ICAKKyAgICAgICAgKiB3dGYvS2V5VmFsdWVQYWlyLmg6CisgICAgICAgIChXVEY6Om9wZXJhdG9y PT0gY29uc3QpOgorICAgICAgICAqIHd0Zi9VUkwuY3BwOgorICAgICAgICAoV1RGOjpVUkw6OmRp ZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyk6CisgICAgICAgIChXVEY6Omxlbmd0aE9mVVJMSWdub3Jp bmdRdWVyeUFuZEZyYWdtZW50cyk6CisgICAgICAgIChXVEY6OlVSTDo6aXNFcXVhbElnbm9yaW5n UXVlcnlBbmRGcmFnbWVudHMpOgorICAgICAgICAoV1RGOjpVUkw6OnJlbW92ZVF1ZXJ5UGFyYW1l dGVycyk6CisgICAgICAgICogd3RmL1VSTC5oOgorCiAyMDIxLTA3LTE2ICBBbGV4YW5kZXIgTWlr aGF5bGVua28gIDxhbGV4bUBnbm9tZS5vcmc+CiAKICAgICAgICAgW0dUS11bV1BFXSBTdXBwb3J0 IGNvbG9yLXNjaGVtZXMgQ1NTIHByb3BlcnR5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9L ZXlWYWx1ZVBhaXIuaCBiL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCmluZGV4IGIxYzJi YzM2ODM1ZGU2ZDBiZDQxMTc5MzViOTVkMmEwMmNhYjA4ZTIuLmZmZWI1N2YzOWYwZDA1YmVlNGU2 ZTZlODM5YWU1NjRhYTM0MmJkYWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVl UGFpci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCkBAIC03MCw2ICs3MCwx MSBAQCBpbmxpbmUgS2V5VmFsdWVQYWlyPHR5cGVuYW1lIHN0ZDo6ZGVjYXk8Sz46OnR5cGUsIHR5 cGVuYW1lIHN0ZDo6ZGVjYXk8Vj46OnR5cGU+CiAgICAgcmV0dXJuIEtleVZhbHVlUGFpcjx0eXBl bmFtZSBzdGQ6OmRlY2F5PEs+Ojp0eXBlLCB0eXBlbmFtZSBzdGQ6OmRlY2F5PFY+Ojp0eXBlPiB7 IHN0ZDo6Zm9yd2FyZDxLPihrZXkpLCBzdGQ6OmZvcndhcmQ8Vj4odmFsdWUpIH07CiB9CiAKK3Rl bXBsYXRlPHR5cGVuYW1lIEtleVR5cGUsIHR5cGVuYW1lIFZhbHVlVHlwZT4gY29uc3RleHByIGJv b2wgb3BlcmF0b3I9PShjb25zdCBLZXlWYWx1ZVBhaXI8S2V5VHlwZSwgVmFsdWVUeXBlPiYgYSwg Y29uc3QgS2V5VmFsdWVQYWlyPEtleVR5cGUsIFZhbHVlVHlwZT4mIGIpCit7CisgICAgcmV0dXJu IGEua2V5ID09IGIua2V5ICYmIGEudmFsdWUgPT0gYi52YWx1ZTsKK30KKwogfQogCiB1c2luZyBX VEY6OktleVZhbHVlUGFpcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAgYi9T b3VyY2UvV1RGL3d0Zi9VUkwuY3BwCmluZGV4IGQ5YzA4MmNlYzY5YTVkODQ4ZDAzZDE2ZTA4OTRh OGNiNzJhNWE1ZGIuLmI0MWY3MTA3OTI3M2ZiM2YyMDZiNzRjMzdkZDE1ZWU4OGMyOWEwZDcgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVVJM LmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVkZSA8dW5p Y29kZS91aWRuYS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL0hh c2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ry b3llZC5oPgogI2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgpAQCAtMTE2Niw0ICsxMTY3LDg2 IEBAIGJvb2wgVVJMOjpob3N0SXNJUEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQogCiAjZW5kaWYK IAorVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IGRpZmZlcmluZ1F1ZXJ5UGFy YW1ldGVycyhjb25zdCBVUkwmIGZpcnN0VVJMLCBjb25zdCBVUkwmIHNlY29uZFVSTCkKK3sKKyAg ICBhdXRvIGZpcnN0UXVlcnlQYXJhbWV0ZXJzID0gVVJMUGFyc2VyOjpwYXJzZVVSTEVuY29kZWRG b3JtKGZpcnN0VVJMLnF1ZXJ5KCkpOworICAgIGF1dG8gc2Vjb25kUXVlcnlQYXJhbWV0ZXJzID0g VVJMUGFyc2VyOjpwYXJzZVVSTEVuY29kZWRGb3JtKHNlY29uZFVSTC5xdWVyeSgpKTsKKyAgICAK KyAgICBpZiAoZmlyc3RRdWVyeVBhcmFtZXRlcnMuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4g c2Vjb25kUXVlcnlQYXJhbWV0ZXJzOworCisgICAgaWYgKHNlY29uZFF1ZXJ5UGFyYW1ldGVycy5p c0VtcHR5KCkpCisgICAgICAgIHJldHVybiBmaXJzdFF1ZXJ5UGFyYW1ldGVyczsKKyAgICAKKyAg ICBhdXRvIGNvbXBhcmUgPSBbXSAoY29uc3QgS2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYg YSwgY29uc3QgS2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYikgeworICAgICAgICBpZiAo aW50IHJlc3VsdCA9IGNvZGVQb2ludENvbXBhcmUoYS5rZXksIGIua2V5KSkKKyAgICAgICAgICAg IHJldHVybiByZXN1bHQ7CisgICAgICAgIHJldHVybiBjb2RlUG9pbnRDb21wYXJlKGEudmFsdWUs IGIudmFsdWUpOworICAgICAgICAKKyAgICB9OworICAgIGF1dG8gY29tcGFyZXNMZXNzVGhhbiA9 IFtjb21wYXJlXSAoY29uc3QgS2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYSwgY29uc3Qg S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYikgeworICAgICAgICByZXR1cm4gY29tcGFy ZShhLCBiKSA8IDA7CisgICAgfTsKKyAgICAKKyAgICBzdGQ6OnNvcnQoZmlyc3RRdWVyeVBhcmFt ZXRlcnMuYmVnaW4oKSwgZmlyc3RRdWVyeVBhcmFtZXRlcnMuZW5kKCksIGNvbXBhcmVzTGVzc1Ro YW4pOworICAgIHN0ZDo6c29ydChzZWNvbmRRdWVyeVBhcmFtZXRlcnMuYmVnaW4oKSwgc2Vjb25k UXVlcnlQYXJhbWV0ZXJzLmVuZCgpLCBjb21wYXJlc0xlc3NUaGFuKTsKKyAgICBzaXplX3QgdG90 YWxGaXJzdFF1ZXJ5UGFyYW1ldGVycyA9IGZpcnN0UXVlcnlQYXJhbWV0ZXJzLnNpemUoKTsKKyAg ICBzaXplX3QgdG90YWxTZWNvbmRRdWVyeVBhcmFtZXRlcnMgPSBzZWNvbmRRdWVyeVBhcmFtZXRl cnMuc2l6ZSgpOworICAgIHNpemVfdCBpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnMgPSAwOwor ICAgIHNpemVfdCBpbmRleEluU2Vjb25kUXVlcnlQYXJhbWV0ZXJzID0gMDsKKyAgICBWZWN0b3I8 S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzOwor ICAgIHdoaWxlIChpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnMgPCB0b3RhbEZpcnN0UXVlcnlQ YXJhbWV0ZXJzICYmIGluZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnMgPCB0b3RhbFNlY29uZFF1 ZXJ5UGFyYW1ldGVycykgeworICAgICAgICBpbnQgY29tcGFyaXNvbiA9IGNvbXBhcmUoZmlyc3RR dWVyeVBhcmFtZXRlcnNbaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJzXSwgc2Vjb25kUXVlcnlQ YXJhbWV0ZXJzW2luZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnNdKTsKKyAgICAgICAgaWYgKGNv bXBhcmlzb24gPCAwKSB7CisgICAgICAgICAgICBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMuYXBw ZW5kKGZpcnN0UXVlcnlQYXJhbWV0ZXJzW2luZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVyc10pOwor ICAgICAgICAgICAgaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJzKys7CisgICAgICAgIH0gZWxz ZSBpZiAoY29tcGFyaXNvbiA+IDApIHsKKyAgICAgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1l dGVycy5hcHBlbmQoc2Vjb25kUXVlcnlQYXJhbWV0ZXJzW2luZGV4SW5TZWNvbmRRdWVyeVBhcmFt ZXRlcnNdKTsKKyAgICAgICAgICAgIGluZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnMrKzsKKyAg ICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGluZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVycysr OworICAgICAgICAgICAgaW5kZXhJblNlY29uZFF1ZXJ5UGFyYW1ldGVycysrOworICAgICAgICB9 CisgICAgfQorICAgIAorICAgIHdoaWxlIChpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnMgPCB0 b3RhbEZpcnN0UXVlcnlQYXJhbWV0ZXJzKSB7CisgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1l dGVycy5hcHBlbmQoZmlyc3RRdWVyeVBhcmFtZXRlcnNbaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0 ZXJzXSk7CisgICAgICAgIGluZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVycysrOworICAgIH0KKyAg ICAKKyAgICB3aGlsZSAoaW5kZXhJblNlY29uZFF1ZXJ5UGFyYW1ldGVycyA8IHRvdGFsU2Vjb25k UXVlcnlQYXJhbWV0ZXJzKSB7CisgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycy5hcHBl bmQoc2Vjb25kUXVlcnlQYXJhbWV0ZXJzW2luZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnNdKTsK KyAgICAgICAgaW5kZXhJblNlY29uZFF1ZXJ5UGFyYW1ldGVycysrOworICAgIH0KKyAgICAKKyAg ICByZXR1cm4gZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzOworfQorCitzdGF0aWMgU3RyaW5nVmll dyBzdWJzdHJpbmdJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKGNvbnN0IFVSTCYgdXJsKQorewor ICAgIGlmICghdXJsLmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIFN0cmluZ1ZpZXcodXJsLnN0 cmluZygpKTsKKyAgICAKKyAgICByZXR1cm4gU3RyaW5nVmlldyh1cmwuc3RyaW5nKCkpLmxlZnQo dXJsLnBhdGhFbmQoKSk7Cit9CisKK2Jvb2wgaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVu dHMoY29uc3QgVVJMJiBhLCBjb25zdCBVUkwmIGIpCit7CisgICAgcmV0dXJuIHN1YnN0cmluZ0ln bm9yaW5nUXVlcnlBbmRGcmFnbWVudHMoYSkgPT0gc3Vic3RyaW5nSWdub3JpbmdRdWVyeUFuZEZy YWdtZW50cyhiKTsKK30KKwordm9pZCByZW1vdmVRdWVyeVBhcmFtZXRlcnMoVVJMJiB1cmwsIGNv bnN0IEhhc2hTZXQ8U3RyaW5nPiYga2V5c1RvUmVtb3ZlKQoreworICAgIGlmIChrZXlzVG9SZW1v dmUuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgU3RyaW5nQnVpbGRlciBx dWVyeVdpdGhvdXRSZW1vdmFsS2V5czsKKyAgICBmb3IgKGF1dG8mIHBhcmFtZXRlciA6IFVSTFBh cnNlcjo6cGFyc2VVUkxFbmNvZGVkRm9ybSh1cmwucXVlcnkoKSkpIHsKKyAgICAgICAgaWYgKCFr ZXlzVG9SZW1vdmUuY29udGFpbnMocGFyYW1ldGVyLmtleSkpCisgICAgICAgICAgICBxdWVyeVdp dGhvdXRSZW1vdmFsS2V5cy5hcHBlbmQocXVlcnlXaXRob3V0UmVtb3ZhbEtleXMuaXNFbXB0eSgp ID8gIiIgOiAiJiIsIHBhcmFtZXRlci5rZXksICc9JywgcGFyYW1ldGVyLnZhbHVlKTsKKyAgICB9 CisgICAgCisgICAgdXJsLnNldFF1ZXJ5KHF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzKTsKK30KKwog fSAvLyBuYW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9VUkwuaCBiL1Nv dXJjZS9XVEYvd3RmL1VSTC5oCmluZGV4IGY0NDU0MjFlMWZlMjNjYWJiNjE1N2Y3MGQ5YzQ0NmEy ODZjNWYwNTYuLmVkYTQxMTdiNDliNDNlMTNiMDkxNDkxOWUzNDI3NjcxYzU3ODk0ZWMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1VSTC5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1VSTC5oCkBA IC0yNDQsNiArMjQ0LDkgQEAgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFN0cmluZyYsIGNvbnN0IFVS TCYpOwogCiBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVu dGlmaWVyKGNvbnN0IFVSTCYsIGNvbnN0IFVSTCYpOwogV1RGX0VYUE9SVF9QUklWQVRFIGJvb2wg cHJvdG9jb2xIb3N0QW5kUG9ydEFyZUVxdWFsKGNvbnN0IFVSTCYsIGNvbnN0IFVSTCYpOworV1RG X0VYUE9SVF9QUklWQVRFIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiBkaWZm ZXJpbmdRdWVyeVBhcmFtZXRlcnMoY29uc3QgVVJMJiwgY29uc3QgVVJMJik7CitXVEZfRVhQT1JU X1BSSVZBVEUgYm9vbCBpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyhjb25zdCBVUkwm LCBjb25zdCBVUkwmKTsKK1dURl9FWFBPUlRfUFJJVkFURSB2b2lkIHJlbW92ZVF1ZXJ5UGFyYW1l dGVycyhVUkwmLCBjb25zdCBIYXNoU2V0PFN0cmluZz4mKTsKIAogV1RGX0VYUE9SVF9QUklWQVRF IGNvbnN0IFVSTCYgYWJvdXRCbGFua1VSTCgpOwogV1RGX0VYUE9SVF9QUklWQVRFIGNvbnN0IFVS TCYgYWJvdXRTcmNEb2NVUkwoKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xz L0NoYW5nZUxvZwppbmRleCBhNjZhMjRmZTQ3OWYxZTk0MjdmNzlkMjc3YmQxNGVlODkwZTdmYjNj Li5iNTI1NjYxYzdmMmY4ZWMyOWM1YjNlOTI3MTMzNjViNjFlY2ZmZDNmIDEwMDY0NAotLS0gYS9U b29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIw MjEtMDgtMDMgIFJpc3VsIElzbGFtICA8cmlzdWxfaXNsYW1AYXBwbGUuY29tPgorCisgICAgICAg IEFkZCBmdW5jdGlvbnMgZm9yIHBhcnNpbmcgVVJMIHF1ZXJ5IHN0cmluZworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAgIAorICAgICAgICBBZGRlZCB0aGUgdGVz dCBmdW5jdGlvbnMgcmVxdWlyZWQgZm9yIHBhcnNpbmcgVVJMIHF1ZXJ5IHN0cmluZy4KKworICAg ICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHA6CisgICAgICAgIChUZXN0V2Vi S2l0QVBJOjpURVNUX0YpOgorCiAyMDIxLTA3LTE5ICBSeWFuIEhhZGRhZCAgPHJ5YW5oYWRkYWRA YXBwbGUuY29tPgogCiAgICAgICAgIFtidWlsZC53ZWJraXQub3JnXSBsbGRiLXdlYmtpdC10ZXN0 IGlzIGZhaWxpbmcgb24gQ2F0YWxpbmEgcXVldWVzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYv VVJMLmNwcAppbmRleCBlZThjZTE5MjU1OTEzMTIyNjM0MzZiYjJlMWFiYmExZDdmZDc4Mzg2Li44 NDU4Y2JhMmVkNzA3MmE0NDM1ZjkyOGYzMjZlNDZiOTBiOGIyMDQ1IDEwMDY0NAotLS0gYS9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV1RGL1VSTC5jcHAKQEAgLTI1LDEwICsyNSwxMiBAQAogCiAjaW5jbHVkZSAiY29u ZmlnLmgiCiAjaW5jbHVkZSAiV1RGU3RyaW5nVXRpbGl0aWVzLmgiCisjaW5jbHVkZSA8d3RmL0hh c2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgogI2luY2x1ZGUgPHd0Zi9TdHJp bmdQcmludFN0cmVhbS5oPgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4KICNpbmNsdWRlIDx3dGYvVVJM UGFyc2VyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCiBuYW1lc3BhY2Ug VGVzdFdlYktpdEFQSSB7CiAKQEAgLTM1Nyw0ICszNTksMjEyIEBAIFRFU1RfRihXVEZfVVJMLCBQ cmludFN0cmVhbSkKICAgICBFWFBFQ1RfRVEob3V0LnRvU3RyaW5nKCksIHVybFN0cmluZyk7CiB9 CiAKK1RFU1RfRihXVEZfVVJMLCBVUkxEaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMpCit7CisgICAg VVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsMiA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBWZWN0 b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjEyIHt7ImtleTEiLCAi dmFsMSJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDEsIHVy bDIpLCB0ZXN0VmVjdG9yMTIpOworICAgIAorICAgIFVSTCB1cmwzMyA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsMzQgPSBjcmVhdGVV UkwoIndlYmtpdC5vcmcvPyIpOworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRl cnModXJsMzMsIHVybDM0KSwgdGVzdFZlY3RvcjEyKTsKKyAgICAKKyAgICBVUkwgdXJsMzUgPSBj cmVhdGVVUkwoIi5vcmcvcGF0aC8/a2V5MT12YWwxIik7CisgICAgVVJMIHVybDM2ID0gY3JlYXRl VVJMKCIvcGF0aC8/a2V5MT12YWwxIik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcs IFN0cmluZz4+IHRlc3RWZWN0b3IgeyB9OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBh cmFtZXRlcnModXJsMzUsIHVybDM2KSwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybCA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBF Q1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybCwgdXJsKSwgdGVzdFZlY3Rvcik7Cisg ICAgCisgICAgVVJMIHVybDkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5 MT12YWwxIik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmcvP2tleTE9dmFsMSIpOworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMo dXJsOSwgdXJsMTApICwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDcgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwo Imh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5 UGFyYW1ldGVycyh1cmw3LCB1cmw4KSwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDMg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDQgPSBj cmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgVmVjdG9y PEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IzNCB7eyJrZXkxIiwgInZh bDEifX07CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwzLCB1cmw0 KSwgdGVzdFZlY3RvcjM0KTsKKyAgICAKKyAgICBVUkwgdXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmlu ZywgU3RyaW5nPj4gdGVzdFZlY3RvcjU2IHt7ImtleTEiLCAidmFsMSJ9fTsKKyAgICBFWFBFQ1Rf RVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDUsIHVybDYpLCB0ZXN0VmVjdG9yNTYpOwor ICAgIAorICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9r ZXkxPXZhbDEma2V5Mj12YWwyIik7CisgICAgVVJMIHVybDE0ID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvP2tleTE9dmFsMSZrZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFs dWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjEzMTQge3sia2V5MSIsICJ2YWwxIn0s IHsia2V5MiIsICJ2YWwyIn19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRl cnModXJsMTMsIHVybDE0KSwgdGVzdFZlY3RvcjEzMTQpOworICAgIAorICAgIFVSTCB1cmwxNSA9 IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBVUkwg dXJsMTYgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5Mj12YWwyIik7Cisg ICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IxNTE2IHt7 ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVy aW5nUXVlcnlQYXJhbWV0ZXJzKHVybDE1LCB1cmwxNiksIHRlc3RWZWN0b3IxNTE2KTsKKyAgICAK KyAgICBVUkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5Mj12 YWwyJmtleTE9dmFsMSIpOworICAgIFVSTCB1cmwxMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkzPXZhbDMma2V5MT12YWwxIik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFp cjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IxMTEyIHt7ImtleTIiLCAidmFsMiJ9LCB7Imtl eTMiLCAidmFsMyJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVy bDExLCB1cmwxMiksIHRlc3RWZWN0b3IxMTEyKTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTI9dmFsMiIpOworICAg IFVSTCB1cmwxOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9 dmFsMyIpOworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVj dG9yMTcxOCB7eyJrZXkxIiwgIiJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9 LCB7ImtleTMiLCAidmFsMyJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0 ZXJzKHVybDE3LCB1cmwxOCksIHRlc3RWZWN0b3IxNzE4KTsKKyAgICAKKyAgICBVUkwgdXJsMTkg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5Mj12YWwyJmtleTE9dmFsMSZr ZXkyPXZhbDIiKTsKKyAgICBVUkwgdXJsMjAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZy8/a2V5Mz12YWwzJmtleTEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywg U3RyaW5nPj4gdGVzdFZlY3RvcjE5MjAge3sia2V5MSIsICIifSwgeyJrZXkxIiwgInZhbDEifSwg eyJrZXkyIiwgInZhbDIifSwgeyJrZXkyIiwgInZhbDIifSwgeyJrZXkzIiwgInZhbDMifX07Cisg ICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwxOSwgdXJsMjApLCB0ZXN0 VmVjdG9yMTkyMCk7CisgICAgCisgICAgVVJMIHVybDIxID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3 LndlYmtpdC5vcmcvPz8iKTsKKyAgICBVUkwgdXJsMjIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZy8/Lz90ZXN0PXRlc3QiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmlu ZywgU3RyaW5nPj4gdGVzdFZlY3RvcjIxMjIge3siLz90ZXN0IiwgInRlc3QifSwgeyI/IiwgIiJ9 fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIxLCB1cmwyMiks IHRlc3RWZWN0b3IyMTIyKTsKKyAgICAKKyAgICBVUkwgdXJsMjMgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/PXRlc3QiKTsKKyAgICBVUkwgdXJsMjQgPSBjcmVhdGVVUkwoImh0 dHA6Ly93d3cud2Via2l0Lm9yZy8/PT0iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmlu ZywgU3RyaW5nPj4gdGVzdFZlY3RvcjIzMjQge3siIiwgIj0ifSwgeyIiLCAidGVzdCJ9fTsKKyAg ICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIzLCB1cmwyNCksIHRlc3RW ZWN0b3IyMzI0KTsKKyAgICAKKyAgICBVUkwgdXJsMjcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZz8/Iik7CisgICAgVVJMIHVybDI4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmc/Lz90ZXN0PXRlc3QiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywg U3RyaW5nPj4gdGVzdFZlY3RvcjI3Mjgge3siLz90ZXN0IiwgInRlc3QifSwgeyI/IiwgIiJ9fTsK KyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDI3LCB1cmwyOCksIHRl c3RWZWN0b3IyNzI4KTsKKyAgICAKKyAgICBVUkwgdXJsMjkgPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZz89dGVzdCIpOworICAgIFVSTCB1cmwzMCA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnPz09Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0 cmluZz4+IHRlc3RWZWN0b3IyOTMwIHt7IiIsICI9In0sIHsiIiwgInRlc3QifX07CisgICAgRVhQ RUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwyOSwgdXJsMzApLCB0ZXN0VmVjdG9y MjkzMCk7CisgICAgCisgICAgVVJMIHVybDMxID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtp dC5vcmc/PT8iKTsKKyAgICBVUkwgdXJsMzIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZz0/Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RW ZWN0b3IzMTMyIHt7IiIsICI/In19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFt ZXRlcnModXJsMzEsIHVybDMyKSwgdGVzdFZlY3RvcjMxMzIpOworICAgIAorICAgIFVSTCB1cmwy NSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz89PyIpOworICAgIFVSTCB1cmwy NiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz0/Iik7CisgICAgVmVjdG9yPEtl eVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IyNTI2IHt7IiIsICI/In19Owor ICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMjUsIHVybDI2KSwgdGVz dFZlY3RvcjI1MjYpOworfQorCitURVNUX0YoV1RGX1VSTCwgVVJMSXNFcXVhbElnbm9yaW5nUXVl cnlBbmRGcmFnbWVudHMpCit7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQu b3JnLz8iKTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3Jn Lz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRG cmFnbWVudHModXJsMSwgdXJsMikpOworICAgIAorICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgi d2Via2l0Lm9yZy8/PT8iKTsKKyAgICBVUkwgdXJsMTQgPSBjcmVhdGVVUkwoIndlYmtpdC5vcmcv Pz0/Iik7CisgICAgRVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMo dXJsMTMsIHVybDE0KSk7CisgICAgCisgICAgVVJMIHVybDE1ID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvIik7CisgICAgVVJMIHVybDE2ID0gY3JlYXRlVVJMKCJ3ZWJraXQub3Jn LyIpOworICAgIEVYUEVDVF9GQUxTRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1 cmwxNSwgdXJsMTYpKTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBjcmVhdGVVUkwoIndlYmtpdC5v cmcvPz0/Iik7CisgICAgVVJMIHVybDE4ID0gY3JlYXRlVVJMKCJraXQub3JnLz89PyIpOworICAg IEVYUEVDVF9GQUxTRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwxNywgdXJs MTgpKTsKKworICAgIFVSTCB1cmwgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5MT12YWwxIik7CisgICAgRVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFn bWVudHModXJsLCB1cmwpKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRShpc0VxdWFsSWdub3Jp bmdRdWVyeUFuZEZyYWdtZW50cyh1cmwzLCB1cmw0KSk7CisgICAgCisgICAgVVJMIHVybDcgPSBj cmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZz8iKTsKKyAgICBVUkwgdXJsOCA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJV RShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmw3LCB1cmw4KSk7CisgICAgCisg ICAgVVJMIHVybDUgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cuZXhhbXBsZS5vcmcvcGF0aD8iKTsK KyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZh bDEiKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMo dXJsNSwgdXJsNikpOworICAgIAorICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vZXhh bXBsZS5jb20/YT1iIik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vZXhhbXBs ZS5jb20vP2E9YiIpOworICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJh Z21lbnRzKHVybDksIHVybDEwKSk7CisgICAgCisgICAgVVJMIHVybDExID0gY3JlYXRlVVJMKCJo dHRwOi8vd3d3LndlYmtpdC5vcmcvPyIpOworICAgIFVSTCB1cmwxMiA9IGNyZWF0ZVVSTCgiaHR0 cDovL3d3dy53ZWJraXQub3JnPyIpOworICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1 ZXJ5QW5kRnJhZ21lbnRzKHVybDExLCB1cmwxMikpOworICAgIAorICAgIFVSTCB1cmwyMSA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8/Iik7CisgICAgVVJMIHVybDIyID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPy8/Iik7CisgICAgRVhQRUNUX1RSVUUoaXNF cXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMjEsIHVybDIyKSk7CisgICAgCisgICAg VVJMIHVybDIzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz0mIik7CisgICAg VVJMIHVybDI0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz09JiIpOworICAg IEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKHVybDIzLCB1cmwy NCkpOworICAgIAorICAgIFVSTCB1cmwyNyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQu b3JnPyY/Iik7CisgICAgVVJMIHVybDI4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmc/PyYiKTsKKyAgICBFWFBFQ1RfVFJVRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50 cyh1cmwyNywgdXJsMjgpKTsKKyAgICAKKyAgICBVUkwgdXJsMzEgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZz89PyIpOworICAgIFVSTCB1cmwzMiA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnPT8iKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5nUXVl cnlBbmRGcmFnbWVudHModXJsMzEsIHVybDMyKSk7CisgICAgCisgICAgVVJMIHVybDI1ID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz0/Iik7CisgICAgVVJMIHVybDI2ID0gY3Jl YXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPT8iKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNF cXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMjUsIHVybDI2KSk7Cit9CisKK1RFU1Rf RihXVEZfVVJMLCBVUkxSZW1vdmVRdWVyeVBhcmFtZXRlcnMpCit7CisgICAgVVJMIHVybCA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsIik7CisgICAgVVJMIHVybDEg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEiKTsK KyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAg ICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsI2Zy YWdtZW50Iik7CisgICAgVVJMIHVybDQgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9y Zy8/a2V5PXZhbCZrZXk9dmFsI2ZyYWdtZW50Iik7CisgICAgVVJMIHVybDUgPSBjcmVhdGVVUkwo Imh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5JmtleT0jZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJs NiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLyNmcmFnbWVudCIpOworICAgIFVS TCB1cmw3ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwjZnJhZ21l bnQiKTsKKyAgICBVUkwgdXJsOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLyIp OworICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvI2ZyYWdt ZW50Iik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcv P2tleT12YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJs MTIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEj ZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsMTMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZyIpOworICAgIAorICAgIEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0MSB7ImtleSJ9 OworICAgIEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0MiB7ImtleTEifTsKKyAgICBIYXNo U2V0PFN0cmluZz4ga2V5UmVtb3ZhbFNldDMgeyJrZXkyIn07CisgICAgSGFzaFNldDxTdHJpbmc+ IGtleVJlbW92YWxTZXQ0IHsia2V5IiwgImtleTEifTsKKyAgICAKKyAgICByZW1vdmVRdWVyeVBh cmFtZXRlcnModXJsMSwga2V5UmVtb3ZhbFNldDIpOworICAgIEVYUEVDVF9FUSh1cmwxLnN0cmlu ZygpLCB1cmwuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmwy LCBrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDIuc3RyaW5nKCksIHVybDguc3Ry aW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmwzLCBrZXlSZW1vdmFs U2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDMuc3RyaW5nKCksIHVybDYuc3RyaW5nKCkpOworICAg IAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmw0LCBrZXlSZW1vdmFsU2V0MSk7CisgICAg RVhQRUNUX0VRKHVybDQuc3RyaW5nKCksIHVybDYuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92 ZVF1ZXJ5UGFyYW1ldGVycyh1cmw1LCBrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVy bDUuc3RyaW5nKCksIHVybDYuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1l dGVycyh1cmw2LCBrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDYuc3RyaW5nKCks IHVybDkuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmw3LCBr ZXlSZW1vdmFsU2V0Mik7CisgICAgRVhQRUNUX0VRKHVybDcuc3RyaW5nKCksIHVybDEwLnN0cmlu ZygpKTsKKyAgICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRlcnModXJsMTEsIGtleVJlbW92YWxT ZXQzKTsKKyAgICBFWFBFQ1RfRVEodXJsMTEuc3RyaW5nKCksIHVybDEyLnN0cmluZygpKTsKKyAg ICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRlcnModXJsMTIsIGtleVJlbW92YWxTZXQ0KTsKKyAg ICBFWFBFQ1RfRVEodXJsMTIuc3RyaW5nKCksIHVybDkuc3RyaW5nKCkpOworICAgIAorICAgIHJl bW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmwxMywga2V5UmVtb3ZhbFNldDEpOworICAgIEVYUEVDVF9F USh1cmwxMy5zdHJpbmcoKSwgdXJsOC5zdHJpbmcoKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFRl c3RXZWJLaXRBUEkK 434864 2021-08-03 15:23:21 -0700 2021-08-03 19:17:48 -0700 Patch bug-228122-20210803152320.patch text/plain 17847 risul_islam U3VidmVyc2lvbiBSZXZpc2lvbjogMjgwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDFlOGIyNjIzNTI2ZDI1YzNkNjI3ZTlh MzE0MWM3NDdlNGI0MmQyOTQuLmUzZjJjNDY4MDVhMDhmNDhlYTYzZjc4ZTM2MmQyY2VlNTNkMTkz YjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjEtMDgtMDMgIFJpc3VsIElzbGFtICA8cmlzdWxf aXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBmdW5jdGlvbnMgZm9yIHBhcnNpbmcgVVJM IHF1ZXJ5IHN0cmluZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisgICAgICAg IAorICAgICAgICBBZGRlZCBwYXJzaW5nIG9mIFVSTCBxdWVyeSBzdHJpbmdzLgorICAgICAgICAK KyAgICAgICAgKiB3dGYvS2V5VmFsdWVQYWlyLmg6CisgICAgICAgIChXVEY6Om9wZXJhdG9yPT0g Y29uc3QpOgorICAgICAgICAqIHd0Zi9VUkwuY3BwOgorICAgICAgICAoV1RGOjpVUkw6OmRpZmZl cmluZ1F1ZXJ5UGFyYW1ldGVycyk6CisgICAgICAgIChXVEY6Omxlbmd0aE9mVVJMSWdub3JpbmdR dWVyeUFuZEZyYWdtZW50cyk6CisgICAgICAgIChXVEY6OlVSTDo6aXNFcXVhbElnbm9yaW5nUXVl cnlBbmRGcmFnbWVudHMpOgorICAgICAgICAoV1RGOjpVUkw6OnJlbW92ZVF1ZXJ5UGFyYW1ldGVy cyk6CisgICAgICAgICogd3RmL1VSTC5oOgorCiAyMDIxLTA3LTE2ICBBbGV4YW5kZXIgTWlraGF5 bGVua28gIDxhbGV4bUBnbm9tZS5vcmc+CiAKICAgICAgICAgW0dUS11bV1BFXSBTdXBwb3J0IGNv bG9yLXNjaGVtZXMgQ1NTIHByb3BlcnR5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9LZXlW YWx1ZVBhaXIuaCBiL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCmluZGV4IGIxYzJiYzM2 ODM1ZGU2ZDBiZDQxMTc5MzViOTVkMmEwMmNhYjA4ZTIuLmZmZWI1N2YzOWYwZDA1YmVlNGU2ZTZl ODM5YWU1NjRhYTM0MmJkYWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFp ci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0tleVZhbHVlUGFpci5oCkBAIC03MCw2ICs3MCwxMSBA QCBpbmxpbmUgS2V5VmFsdWVQYWlyPHR5cGVuYW1lIHN0ZDo6ZGVjYXk8Sz46OnR5cGUsIHR5cGVu YW1lIHN0ZDo6ZGVjYXk8Vj46OnR5cGU+CiAgICAgcmV0dXJuIEtleVZhbHVlUGFpcjx0eXBlbmFt ZSBzdGQ6OmRlY2F5PEs+Ojp0eXBlLCB0eXBlbmFtZSBzdGQ6OmRlY2F5PFY+Ojp0eXBlPiB7IHN0 ZDo6Zm9yd2FyZDxLPihrZXkpLCBzdGQ6OmZvcndhcmQ8Vj4odmFsdWUpIH07CiB9CiAKK3RlbXBs YXRlPHR5cGVuYW1lIEtleVR5cGUsIHR5cGVuYW1lIFZhbHVlVHlwZT4gY29uc3RleHByIGJvb2wg b3BlcmF0b3I9PShjb25zdCBLZXlWYWx1ZVBhaXI8S2V5VHlwZSwgVmFsdWVUeXBlPiYgYSwgY29u c3QgS2V5VmFsdWVQYWlyPEtleVR5cGUsIFZhbHVlVHlwZT4mIGIpCit7CisgICAgcmV0dXJuIGEu a2V5ID09IGIua2V5ICYmIGEudmFsdWUgPT0gYi52YWx1ZTsKK30KKwogfQogCiB1c2luZyBXVEY6 OktleVZhbHVlUGFpcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAgYi9Tb3Vy Y2UvV1RGL3d0Zi9VUkwuY3BwCmluZGV4IGQ5YzA4MmNlYzY5YTVkODQ4ZDAzZDE2ZTA4OTRhOGNi NzJhNWE1ZGIuLmI0MWY3MTA3OTI3M2ZiM2YyMDZiNzRjMzdkZDE1ZWU4OGMyOWEwZDcgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1VSTC5jcHAKKysrIGIvU291cmNlL1dURi93dGYvVVJMLmNw cApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVkZSA8dW5pY29k ZS91aWRuYS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hT ZXQuaD4KICNpbmNsdWRlIDx3dGYvTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3ll ZC5oPgogI2luY2x1ZGUgPHd0Zi9QcmludFN0cmVhbS5oPgpAQCAtMTE2Niw0ICsxMTY3LDg2IEBA IGJvb2wgVVJMOjpob3N0SXNJUEFkZHJlc3MoU3RyaW5nVmlldyBob3N0KQogCiAjZW5kaWYKIAor VmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IGRpZmZlcmluZ1F1ZXJ5UGFyYW1l dGVycyhjb25zdCBVUkwmIGZpcnN0VVJMLCBjb25zdCBVUkwmIHNlY29uZFVSTCkKK3sKKyAgICBh dXRvIGZpcnN0UXVlcnlQYXJhbWV0ZXJzID0gVVJMUGFyc2VyOjpwYXJzZVVSTEVuY29kZWRGb3Jt KGZpcnN0VVJMLnF1ZXJ5KCkpOworICAgIGF1dG8gc2Vjb25kUXVlcnlQYXJhbWV0ZXJzID0gVVJM UGFyc2VyOjpwYXJzZVVSTEVuY29kZWRGb3JtKHNlY29uZFVSTC5xdWVyeSgpKTsKKyAgICAKKyAg ICBpZiAoZmlyc3RRdWVyeVBhcmFtZXRlcnMuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gc2Vj b25kUXVlcnlQYXJhbWV0ZXJzOworCisgICAgaWYgKHNlY29uZFF1ZXJ5UGFyYW1ldGVycy5pc0Vt cHR5KCkpCisgICAgICAgIHJldHVybiBmaXJzdFF1ZXJ5UGFyYW1ldGVyczsKKyAgICAKKyAgICBh dXRvIGNvbXBhcmUgPSBbXSAoY29uc3QgS2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYSwg Y29uc3QgS2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYikgeworICAgICAgICBpZiAoaW50 IHJlc3VsdCA9IGNvZGVQb2ludENvbXBhcmUoYS5rZXksIGIua2V5KSkKKyAgICAgICAgICAgIHJl dHVybiByZXN1bHQ7CisgICAgICAgIHJldHVybiBjb2RlUG9pbnRDb21wYXJlKGEudmFsdWUsIGIu dmFsdWUpOworICAgICAgICAKKyAgICB9OworICAgIGF1dG8gY29tcGFyZXNMZXNzVGhhbiA9IFtj b21wYXJlXSAoY29uc3QgS2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYSwgY29uc3QgS2V5 VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPiYgYikgeworICAgICAgICByZXR1cm4gY29tcGFyZShh LCBiKSA8IDA7CisgICAgfTsKKyAgICAKKyAgICBzdGQ6OnNvcnQoZmlyc3RRdWVyeVBhcmFtZXRl cnMuYmVnaW4oKSwgZmlyc3RRdWVyeVBhcmFtZXRlcnMuZW5kKCksIGNvbXBhcmVzTGVzc1RoYW4p OworICAgIHN0ZDo6c29ydChzZWNvbmRRdWVyeVBhcmFtZXRlcnMuYmVnaW4oKSwgc2Vjb25kUXVl cnlQYXJhbWV0ZXJzLmVuZCgpLCBjb21wYXJlc0xlc3NUaGFuKTsKKyAgICBzaXplX3QgdG90YWxG aXJzdFF1ZXJ5UGFyYW1ldGVycyA9IGZpcnN0UXVlcnlQYXJhbWV0ZXJzLnNpemUoKTsKKyAgICBz aXplX3QgdG90YWxTZWNvbmRRdWVyeVBhcmFtZXRlcnMgPSBzZWNvbmRRdWVyeVBhcmFtZXRlcnMu c2l6ZSgpOworICAgIHNpemVfdCBpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnMgPSAwOworICAg IHNpemVfdCBpbmRleEluU2Vjb25kUXVlcnlQYXJhbWV0ZXJzID0gMDsKKyAgICBWZWN0b3I8S2V5 VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzOworICAg IHdoaWxlIChpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnMgPCB0b3RhbEZpcnN0UXVlcnlQYXJh bWV0ZXJzICYmIGluZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnMgPCB0b3RhbFNlY29uZFF1ZXJ5 UGFyYW1ldGVycykgeworICAgICAgICBpbnQgY29tcGFyaXNvbiA9IGNvbXBhcmUoZmlyc3RRdWVy eVBhcmFtZXRlcnNbaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJzXSwgc2Vjb25kUXVlcnlQYXJh bWV0ZXJzW2luZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnNdKTsKKyAgICAgICAgaWYgKGNvbXBh cmlzb24gPCAwKSB7CisgICAgICAgICAgICBkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMuYXBwZW5k KGZpcnN0UXVlcnlQYXJhbWV0ZXJzW2luZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVyc10pOworICAg ICAgICAgICAgaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJzKys7CisgICAgICAgIH0gZWxzZSBp ZiAoY29tcGFyaXNvbiA+IDApIHsKKyAgICAgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVy cy5hcHBlbmQoc2Vjb25kUXVlcnlQYXJhbWV0ZXJzW2luZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRl cnNdKTsKKyAgICAgICAgICAgIGluZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnMrKzsKKyAgICAg ICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGluZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVycysrOwor ICAgICAgICAgICAgaW5kZXhJblNlY29uZFF1ZXJ5UGFyYW1ldGVycysrOworICAgICAgICB9Cisg ICAgfQorICAgIAorICAgIHdoaWxlIChpbmRleEluRmlyc3RRdWVyeVBhcmFtZXRlcnMgPCB0b3Rh bEZpcnN0UXVlcnlQYXJhbWV0ZXJzKSB7CisgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVy cy5hcHBlbmQoZmlyc3RRdWVyeVBhcmFtZXRlcnNbaW5kZXhJbkZpcnN0UXVlcnlQYXJhbWV0ZXJz XSk7CisgICAgICAgIGluZGV4SW5GaXJzdFF1ZXJ5UGFyYW1ldGVycysrOworICAgIH0KKyAgICAK KyAgICB3aGlsZSAoaW5kZXhJblNlY29uZFF1ZXJ5UGFyYW1ldGVycyA8IHRvdGFsU2Vjb25kUXVl cnlQYXJhbWV0ZXJzKSB7CisgICAgICAgIGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycy5hcHBlbmQo c2Vjb25kUXVlcnlQYXJhbWV0ZXJzW2luZGV4SW5TZWNvbmRRdWVyeVBhcmFtZXRlcnNdKTsKKyAg ICAgICAgaW5kZXhJblNlY29uZFF1ZXJ5UGFyYW1ldGVycysrOworICAgIH0KKyAgICAKKyAgICBy ZXR1cm4gZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzOworfQorCitzdGF0aWMgU3RyaW5nVmlldyBz dWJzdHJpbmdJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKGNvbnN0IFVSTCYgdXJsKQoreworICAg IGlmICghdXJsLmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIFN0cmluZ1ZpZXcodXJsLnN0cmlu ZygpKTsKKyAgICAKKyAgICByZXR1cm4gU3RyaW5nVmlldyh1cmwuc3RyaW5nKCkpLmxlZnQodXJs LnBhdGhFbmQoKSk7Cit9CisKK2Jvb2wgaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMo Y29uc3QgVVJMJiBhLCBjb25zdCBVUkwmIGIpCit7CisgICAgcmV0dXJuIHN1YnN0cmluZ0lnbm9y aW5nUXVlcnlBbmRGcmFnbWVudHMoYSkgPT0gc3Vic3RyaW5nSWdub3JpbmdRdWVyeUFuZEZyYWdt ZW50cyhiKTsKK30KKwordm9pZCByZW1vdmVRdWVyeVBhcmFtZXRlcnMoVVJMJiB1cmwsIGNvbnN0 IEhhc2hTZXQ8U3RyaW5nPiYga2V5c1RvUmVtb3ZlKQoreworICAgIGlmIChrZXlzVG9SZW1vdmUu aXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgU3RyaW5nQnVpbGRlciBxdWVy eVdpdGhvdXRSZW1vdmFsS2V5czsKKyAgICBmb3IgKGF1dG8mIHBhcmFtZXRlciA6IFVSTFBhcnNl cjo6cGFyc2VVUkxFbmNvZGVkRm9ybSh1cmwucXVlcnkoKSkpIHsKKyAgICAgICAgaWYgKCFrZXlz VG9SZW1vdmUuY29udGFpbnMocGFyYW1ldGVyLmtleSkpCisgICAgICAgICAgICBxdWVyeVdpdGhv dXRSZW1vdmFsS2V5cy5hcHBlbmQocXVlcnlXaXRob3V0UmVtb3ZhbEtleXMuaXNFbXB0eSgpID8g IiIgOiAiJiIsIHBhcmFtZXRlci5rZXksICc9JywgcGFyYW1ldGVyLnZhbHVlKTsKKyAgICB9Cisg ICAgCisgICAgdXJsLnNldFF1ZXJ5KHF1ZXJ5V2l0aG91dFJlbW92YWxLZXlzKTsKK30KKwogfSAv LyBuYW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9VUkwuaCBiL1NvdXJj ZS9XVEYvd3RmL1VSTC5oCmluZGV4IGY0NDU0MjFlMWZlMjNjYWJiNjE1N2Y3MGQ5YzQ0NmEyODZj NWYwNTYuLmVkYTQxMTdiNDliNDNlMTNiMDkxNDkxOWUzNDI3NjcxYzU3ODk0ZWMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XVEYvd3RmL1VSTC5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1VSTC5oCkBAIC0y NDQsNiArMjQ0LDkgQEAgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFN0cmluZyYsIGNvbnN0IFVSTCYp OwogCiBXVEZfRVhQT1JUX1BSSVZBVEUgYm9vbCBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVudGlm aWVyKGNvbnN0IFVSTCYsIGNvbnN0IFVSTCYpOwogV1RGX0VYUE9SVF9QUklWQVRFIGJvb2wgcHJv dG9jb2xIb3N0QW5kUG9ydEFyZUVxdWFsKGNvbnN0IFVSTCYsIGNvbnN0IFVSTCYpOworV1RGX0VY UE9SVF9QUklWQVRFIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiBkaWZmZXJp bmdRdWVyeVBhcmFtZXRlcnMoY29uc3QgVVJMJiwgY29uc3QgVVJMJik7CitXVEZfRVhQT1JUX1BS SVZBVEUgYm9vbCBpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyhjb25zdCBVUkwmLCBj b25zdCBVUkwmKTsKK1dURl9FWFBPUlRfUFJJVkFURSB2b2lkIHJlbW92ZVF1ZXJ5UGFyYW1ldGVy cyhVUkwmLCBjb25zdCBIYXNoU2V0PFN0cmluZz4mKTsKIAogV1RGX0VYUE9SVF9QUklWQVRFIGNv bnN0IFVSTCYgYWJvdXRCbGFua1VSTCgpOwogV1RGX0VYUE9SVF9QUklWQVRFIGNvbnN0IFVSTCYg YWJvdXRTcmNEb2NVUkwoKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0No YW5nZUxvZwppbmRleCBhNjZhMjRmZTQ3OWYxZTk0MjdmNzlkMjc3YmQxNGVlODkwZTdmYjNjLi4z YTI0M2RjMzM0NTUyNGM1ODNhZTQyNjY2NTI2NDE0MzFmZDk1MmNjIDEwMDY0NAotLS0gYS9Ub29s cy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMjEt MDgtMDMgIFJpc3VsIElzbGFtICA8cmlzdWxfaXNsYW1AYXBwbGUuY29tPgorCisgICAgICAgIEFk ZCBmdW5jdGlvbnMgZm9yIHBhcnNpbmcgVVJMIHF1ZXJ5IHN0cmluZworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4MTIyCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgRGFyaW4gQWRsZXIuCisgICAgICAgIAorICAgICAgICBBZGRlZCB0aGUgdGVzdCBmdW5j dGlvbnMgcmVxdWlyZWQgZm9yIHBhcnNpbmcgVVJMIHF1ZXJ5IHN0cmluZy4KKworICAgICAgICAq IFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1VSTC5jcHA6CisgICAgICAgIChUZXN0V2ViS2l0QVBJ OjpURVNUX0YpOgorCiAyMDIxLTA3LTE5ICBSeWFuIEhhZGRhZCAgPHJ5YW5oYWRkYWRAYXBwbGUu Y29tPgogCiAgICAgICAgIFtidWlsZC53ZWJraXQub3JnXSBsbGRiLXdlYmtpdC10ZXN0IGlzIGZh aWxpbmcgb24gQ2F0YWxpbmEgcXVldWVzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dURi9VUkwuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVVJMLmNw cAppbmRleCBlZThjZTE5MjU1OTEzMTIyNjM0MzZiYjJlMWFiYmExZDdmZDc4Mzg2Li44NDU4Y2Jh MmVkNzA3MmE0NDM1ZjkyOGYzMjZlNDZiOTBiOGIyMDQ1IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dURi9VUkwuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV1RGL1VSTC5jcHAKQEAgLTI1LDEwICsyNSwxMiBAQAogCiAjaW5jbHVkZSAiY29uZmlnLmgi CiAjaW5jbHVkZSAiV1RGU3RyaW5nVXRpbGl0aWVzLmgiCisjaW5jbHVkZSA8d3RmL0hhc2hTZXQu aD4KICNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgogI2luY2x1ZGUgPHd0Zi9TdHJpbmdQcmlu dFN0cmVhbS5oPgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4KICNpbmNsdWRlIDx3dGYvVVJMUGFyc2Vy Lmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCiBuYW1lc3BhY2UgVGVzdFdl YktpdEFQSSB7CiAKQEAgLTM1Nyw0ICszNTksMjEyIEBAIFRFU1RfRihXVEZfVVJMLCBQcmludFN0 cmVhbSkKICAgICBFWFBFQ1RfRVEob3V0LnRvU3RyaW5nKCksIHVybFN0cmluZyk7CiB9CiAKK1RF U1RfRihXVEZfVVJMLCBVUkxEaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMpCit7CisgICAgVVJMIHVy bDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5 VmFsdWVQYWlyPFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjEyIHt7ImtleTEiLCAidmFsMSJ9 fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDEsIHVybDIpLCB0 ZXN0VmVjdG9yMTIpOworICAgIAorICAgIFVSTCB1cmwzMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsMzQgPSBjcmVhdGVVUkwoIndl YmtpdC5vcmcvPyIpOworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJs MzMsIHVybDM0KSwgdGVzdFZlY3RvcjEyKTsKKyAgICAKKyAgICBVUkwgdXJsMzUgPSBjcmVhdGVV UkwoIi5vcmcvcGF0aC8/a2V5MT12YWwxIik7CisgICAgVVJMIHVybDM2ID0gY3JlYXRlVVJMKCIv cGF0aC8/a2V5MT12YWwxIik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmlu Zz4+IHRlc3RWZWN0b3IgeyB9OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRl cnModXJsMzUsIHVybDM2KSwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybCA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfRVEo ZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybCwgdXJsKSwgdGVzdFZlY3Rvcik7CisgICAgCisg ICAgVVJMIHVybDkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwx Iik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tl eTE9dmFsMSIpOworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsOSwg dXJsMTApICwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDcgPSBjcmVhdGVVUkwoImh0 dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDggPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1l dGVycyh1cmw3LCB1cmw4KSwgdGVzdFZlY3Rvcik7CisgICAgCisgICAgVVJMIHVybDMgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/Iik7CisgICAgVVJMIHVybDQgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxIik7CisgICAgVmVjdG9yPEtleVZh bHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IzNCB7eyJrZXkxIiwgInZhbDEifX07 CisgICAgRVhQRUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwzLCB1cmw0KSwgdGVz dFZlY3RvcjM0KTsKKyAgICAKKyAgICBVUkwgdXJsNSA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDov L3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPj4gdGVzdFZlY3RvcjU2IHt7ImtleTEiLCAidmFsMSJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlm ZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDUsIHVybDYpLCB0ZXN0VmVjdG9yNTYpOworICAgIAor ICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZh bDEma2V5Mj12YWwyIik7CisgICAgVVJMIHVybDE0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvP2tleTE9dmFsMSZrZXkxPXZhbDEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWly PFN0cmluZywgU3RyaW5nPj4gdGVzdFZlY3RvcjEzMTQge3sia2V5MSIsICJ2YWwxIn0sIHsia2V5 MiIsICJ2YWwyIn19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJs MTMsIHVybDE0KSwgdGVzdFZlY3RvcjEzMTQpOworICAgIAorICAgIFVSTCB1cmwxNSA9IGNyZWF0 ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBVUkwgdXJsMTYg PSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5Mj12YWwyIik7CisgICAgVmVj dG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IxNTE2IHt7ImtleTEi LCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVl cnlQYXJhbWV0ZXJzKHVybDE1LCB1cmwxNiksIHRlc3RWZWN0b3IxNTE2KTsKKyAgICAKKyAgICBV UkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5Mj12YWwyJmtl eTE9dmFsMSIpOworICAgIFVSTCB1cmwxMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQu b3JnLz9rZXkzPXZhbDMma2V5MT12YWwxIik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJp bmcsIFN0cmluZz4+IHRlc3RWZWN0b3IxMTEyIHt7ImtleTIiLCAidmFsMiJ9LCB7ImtleTMiLCAi dmFsMyJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDExLCB1 cmwxMiksIHRlc3RWZWN0b3IxMTEyKTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBjcmVhdGVVUkwo Imh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12YWwxJmtleTI9dmFsMiIpOworICAgIFVSTCB1 cmwxOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxJmtleTM9dmFsMyIp OworICAgIFZlY3RvcjxLZXlWYWx1ZVBhaXI8U3RyaW5nLCBTdHJpbmc+PiB0ZXN0VmVjdG9yMTcx OCB7eyJrZXkxIiwgIiJ9LCB7ImtleTEiLCAidmFsMSJ9LCB7ImtleTIiLCAidmFsMiJ9LCB7Imtl eTMiLCAidmFsMyJ9fTsKKyAgICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVy bDE3LCB1cmwxOCksIHRlc3RWZWN0b3IxNzE4KTsKKyAgICAKKyAgICBVUkwgdXJsMTkgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5Mj12YWwyJmtleTE9dmFsMSZrZXkyPXZh bDIiKTsKKyAgICBVUkwgdXJsMjAgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/ a2V5Mz12YWwzJmtleTEiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5n Pj4gdGVzdFZlY3RvcjE5MjAge3sia2V5MSIsICIifSwgeyJrZXkxIiwgInZhbDEifSwgeyJrZXky IiwgInZhbDIifSwgeyJrZXkyIiwgInZhbDIifSwgeyJrZXkzIiwgInZhbDMifX07CisgICAgRVhQ RUNUX0VRKGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwxOSwgdXJsMjApLCB0ZXN0VmVjdG9y MTkyMCk7CisgICAgCisgICAgVVJMIHVybDIxID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtp dC5vcmcvPz8iKTsKKyAgICBVUkwgdXJsMjIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZy8/Lz90ZXN0PXRlc3QiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPj4gdGVzdFZlY3RvcjIxMjIge3siLz90ZXN0IiwgInRlc3QifSwgeyI/IiwgIiJ9fTsKKyAg ICBFWFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIxLCB1cmwyMiksIHRlc3RW ZWN0b3IyMTIyKTsKKyAgICAKKyAgICBVUkwgdXJsMjMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZy8/PXRlc3QiKTsKKyAgICBVUkwgdXJsMjQgPSBjcmVhdGVVUkwoImh0dHA6Ly93 d3cud2Via2l0Lm9yZy8/PT0iKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3Ry aW5nPj4gdGVzdFZlY3RvcjIzMjQge3siIiwgIj0ifSwgeyIiLCAidGVzdCJ9fTsKKyAgICBFWFBF Q1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDIzLCB1cmwyNCksIHRlc3RWZWN0b3Iy MzI0KTsKKyAgICAKKyAgICBVUkwgdXJsMjcgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0 Lm9yZz8/Iik7CisgICAgVVJMIHVybDI4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5v cmc/Lz90ZXN0PXRlc3QiKTsKKyAgICBWZWN0b3I8S2V5VmFsdWVQYWlyPFN0cmluZywgU3RyaW5n Pj4gdGVzdFZlY3RvcjI3Mjgge3siLz90ZXN0IiwgInRlc3QifSwgeyI/IiwgIiJ9fTsKKyAgICBF WFBFQ1RfRVEoZGlmZmVyaW5nUXVlcnlQYXJhbWV0ZXJzKHVybDI3LCB1cmwyOCksIHRlc3RWZWN0 b3IyNzI4KTsKKyAgICAKKyAgICBVUkwgdXJsMjkgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Vi a2l0Lm9yZz89dGVzdCIpOworICAgIFVSTCB1cmwzMCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnPz09Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+ IHRlc3RWZWN0b3IyOTMwIHt7IiIsICI9In0sIHsiIiwgInRlc3QifX07CisgICAgRVhQRUNUX0VR KGRpZmZlcmluZ1F1ZXJ5UGFyYW1ldGVycyh1cmwyOSwgdXJsMzApLCB0ZXN0VmVjdG9yMjkzMCk7 CisgICAgCisgICAgVVJMIHVybDMxID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmc/ PT8iKTsKKyAgICBVUkwgdXJsMzIgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZz0/ Iik7CisgICAgVmVjdG9yPEtleVZhbHVlUGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3Iz MTMyIHt7IiIsICI/In19OworICAgIEVYUEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnMo dXJsMzEsIHVybDMyKSwgdGVzdFZlY3RvcjMxMzIpOworICAgIAorICAgIFVSTCB1cmwyNSA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz89PyIpOworICAgIFVSTCB1cmwyNiA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz0/Iik7CisgICAgVmVjdG9yPEtleVZhbHVl UGFpcjxTdHJpbmcsIFN0cmluZz4+IHRlc3RWZWN0b3IyNTI2IHt7IiIsICI/In19OworICAgIEVY UEVDVF9FUShkaWZmZXJpbmdRdWVyeVBhcmFtZXRlcnModXJsMjUsIHVybDI2KSwgdGVzdFZlY3Rv cjI1MjYpOworfQorCitURVNUX0YoV1RGX1VSTCwgVVJMSXNFcXVhbElnbm9yaW5nUXVlcnlBbmRG cmFnbWVudHMpCit7CisgICAgVVJMIHVybDEgPSBjcmVhdGVVUkwoInd3dy53ZWJraXQub3JnLz8i KTsKKyAgICBVUkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkx PXZhbDEiKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVu dHModXJsMSwgdXJsMikpOworICAgIAorICAgIFVSTCB1cmwxMyA9IGNyZWF0ZVVSTCgid2Via2l0 Lm9yZy8/PT8iKTsKKyAgICBVUkwgdXJsMTQgPSBjcmVhdGVVUkwoIndlYmtpdC5vcmcvPz0/Iik7 CisgICAgRVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMTMs IHVybDE0KSk7CisgICAgCisgICAgVVJMIHVybDE1ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3Lndl YmtpdC5vcmcvIik7CisgICAgVVJMIHVybDE2ID0gY3JlYXRlVVJMKCJ3ZWJraXQub3JnLyIpOwor ICAgIEVYUEVDVF9GQUxTRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwxNSwg dXJsMTYpKTsKKyAgICAKKyAgICBVUkwgdXJsMTcgPSBjcmVhdGVVUkwoIndlYmtpdC5vcmcvPz0/ Iik7CisgICAgVVJMIHVybDE4ID0gY3JlYXRlVVJMKCJraXQub3JnLz89PyIpOworICAgIEVYUEVD VF9GQUxTRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwxNywgdXJsMTgpKTsK KworICAgIFVSTCB1cmwgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5MT12 YWwxIik7CisgICAgRVhQRUNUX1RSVUUoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHMo dXJsLCB1cmwpKTsKKyAgICAKKyAgICBVUkwgdXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnLz8iKTsKKyAgICBVUkwgdXJsNCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJr aXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRShpc0VxdWFsSWdub3JpbmdRdWVy eUFuZEZyYWdtZW50cyh1cmwzLCB1cmw0KSk7CisgICAgCisgICAgVVJMIHVybDcgPSBjcmVhdGVV UkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZz8iKTsKKyAgICBVUkwgdXJsOCA9IGNyZWF0ZVVSTCgi aHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsKKyAgICBFWFBFQ1RfVFJVRShpc0Vx dWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmw3LCB1cmw4KSk7CisgICAgCisgICAgVVJM IHVybDUgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cuZXhhbXBsZS5vcmcvcGF0aD8iKTsKKyAgICBV UkwgdXJsNiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXkxPXZhbDEiKTsK KyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsNSwg dXJsNikpOworICAgIAorICAgIFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vZXhhbXBsZS5j b20/YT1iIik7CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vZXhhbXBsZS5jb20v P2E9YiIpOworICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRz KHVybDksIHVybDEwKSk7CisgICAgCisgICAgVVJMIHVybDExID0gY3JlYXRlVVJMKCJodHRwOi8v d3d3LndlYmtpdC5vcmcvPyIpOworICAgIFVSTCB1cmwxMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3 dy53ZWJraXQub3JnPyIpOworICAgIEVYUEVDVF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5k RnJhZ21lbnRzKHVybDExLCB1cmwxMikpOworICAgIAorICAgIFVSTCB1cmwyMSA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8/Iik7CisgICAgVVJMIHVybDIyID0gY3JlYXRlVVJM KCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPy8/Iik7CisgICAgRVhQRUNUX1RSVUUoaXNFcXVhbEln bm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMjEsIHVybDIyKSk7CisgICAgCisgICAgVVJMIHVy bDIzID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz0mIik7CisgICAgVVJMIHVy bDI0ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz09JiIpOworICAgIEVYUEVD VF9UUlVFKGlzRXF1YWxJZ25vcmluZ1F1ZXJ5QW5kRnJhZ21lbnRzKHVybDIzLCB1cmwyNCkpOwor ICAgIAorICAgIFVSTCB1cmwyNyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnPyY/ Iik7CisgICAgVVJMIHVybDI4ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmc/PyYi KTsKKyAgICBFWFBFQ1RfVFJVRShpc0VxdWFsSWdub3JpbmdRdWVyeUFuZEZyYWdtZW50cyh1cmwy NywgdXJsMjgpKTsKKyAgICAKKyAgICBVUkwgdXJsMzEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cu d2Via2l0Lm9yZz89PyIpOworICAgIFVSTCB1cmwzMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53 ZWJraXQub3JnPT8iKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbElnbm9yaW5nUXVlcnlBbmRG cmFnbWVudHModXJsMzEsIHVybDMyKSk7CisgICAgCisgICAgVVJMIHVybDI1ID0gY3JlYXRlVVJM KCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPz0/Iik7CisgICAgVVJMIHVybDI2ID0gY3JlYXRlVVJM KCJodHRwOi8vd3d3LndlYmtpdC5vcmcvPT8iKTsKKyAgICBFWFBFQ1RfRkFMU0UoaXNFcXVhbEln bm9yaW5nUXVlcnlBbmRGcmFnbWVudHModXJsMjUsIHVybDI2KSk7Cit9CisKK1RFU1RfRihXVEZf VVJMLCBVUkxSZW1vdmVRdWVyeVBhcmFtZXRlcnMpCit7CisgICAgVVJMIHVybCA9IGNyZWF0ZVVS TCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsIik7CisgICAgVVJMIHVybDEgPSBjcmVh dGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEiKTsKKyAgICBV UkwgdXJsMiA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz8iKTsKKyAgICBVUkwg dXJsMyA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLz9rZXk9dmFsI2ZyYWdtZW50 Iik7CisgICAgVVJMIHVybDQgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5 PXZhbCZrZXk9dmFsI2ZyYWdtZW50Iik7CisgICAgVVJMIHVybDUgPSBjcmVhdGVVUkwoImh0dHA6 Ly93d3cud2Via2l0Lm9yZy8/a2V5JmtleT0jZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsNiA9IGNy ZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLyNmcmFnbWVudCIpOworICAgIFVSTCB1cmw3 ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12YWwjZnJhZ21lbnQiKTsK KyAgICBVUkwgdXJsOCA9IGNyZWF0ZVVSTCgiaHR0cDovL3d3dy53ZWJraXQub3JnLyIpOworICAg IFVSTCB1cmw5ID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvI2ZyYWdtZW50Iik7 CisgICAgVVJMIHVybDEwID0gY3JlYXRlVVJMKCJodHRwOi8vd3d3LndlYmtpdC5vcmcvP2tleT12 YWwjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsMTEgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Vi a2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEjZnJhZ21lbnQiKTsKKyAgICBVUkwgdXJsMTIgPSBj cmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZy8/a2V5PXZhbCZrZXkxPXZhbDEjZnJhZ21l bnQiKTsKKyAgICBVUkwgdXJsMTMgPSBjcmVhdGVVUkwoImh0dHA6Ly93d3cud2Via2l0Lm9yZyIp OworICAgIAorICAgIEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0MSB7ImtleSJ9OworICAg IEhhc2hTZXQ8U3RyaW5nPiBrZXlSZW1vdmFsU2V0MiB7ImtleTEifTsKKyAgICBIYXNoU2V0PFN0 cmluZz4ga2V5UmVtb3ZhbFNldDMgeyJrZXkyIn07CisgICAgSGFzaFNldDxTdHJpbmc+IGtleVJl bW92YWxTZXQ0IHsia2V5IiwgImtleTEifTsKKyAgICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRl cnModXJsMSwga2V5UmVtb3ZhbFNldDIpOworICAgIEVYUEVDVF9FUSh1cmwxLnN0cmluZygpLCB1 cmwuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmwyLCBrZXlS ZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDIuc3RyaW5nKCksIHVybDguc3RyaW5nKCkp OworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmwzLCBrZXlSZW1vdmFsU2V0MSk7 CisgICAgRVhQRUNUX0VRKHVybDMuc3RyaW5nKCksIHVybDYuc3RyaW5nKCkpOworICAgIAorICAg IHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmw0LCBrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNU X0VRKHVybDQuc3RyaW5nKCksIHVybDYuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5 UGFyYW1ldGVycyh1cmw1LCBrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDUuc3Ry aW5nKCksIHVybDYuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1 cmw2LCBrZXlSZW1vdmFsU2V0MSk7CisgICAgRVhQRUNUX0VRKHVybDYuc3RyaW5nKCksIHVybDku c3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1ZXJ5UGFyYW1ldGVycyh1cmw3LCBrZXlSZW1v dmFsU2V0Mik7CisgICAgRVhQRUNUX0VRKHVybDcuc3RyaW5nKCksIHVybDEwLnN0cmluZygpKTsK KyAgICAKKyAgICByZW1vdmVRdWVyeVBhcmFtZXRlcnModXJsMTEsIGtleVJlbW92YWxTZXQzKTsK KyAgICBFWFBFQ1RfRVEodXJsMTEuc3RyaW5nKCksIHVybDEyLnN0cmluZygpKTsKKyAgICAKKyAg ICByZW1vdmVRdWVyeVBhcmFtZXRlcnModXJsMTIsIGtleVJlbW92YWxTZXQ0KTsKKyAgICBFWFBF Q1RfRVEodXJsMTIuc3RyaW5nKCksIHVybDkuc3RyaW5nKCkpOworICAgIAorICAgIHJlbW92ZVF1 ZXJ5UGFyYW1ldGVycyh1cmwxMywga2V5UmVtb3ZhbFNldDEpOworICAgIEVYUEVDVF9FUSh1cmwx My5zdHJpbmcoKSwgdXJsOC5zdHJpbmcoKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFRlc3RXZWJL aXRBUEkK