74909 2011-12-19 21:23:16 -0800 Introduce RadioButtonGroup class to keep track of the group members and required state 2012-01-24 02:02:47 -0800 1 1 1 Unclassified WebKit Forms 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 45719 74914 76365 1 tkent tkent darin dglazkov huiqing.zeng webkit.review.bot oldest_to_newest 524421 0 tkent 2011-12-19 21:23:16 -0800 If a document has a radio button group containing many radio buttons, the document rendering is very slow. HTMLInputElement::updateCheckedRadioButtons() is called in attach() of a radio button, and the function iterates over all of radio buttons in the same group. So, it's O(N^2). See http://crbug.com/81553 and Bug 62840. 524450 1 119989 tkent 2011-12-19 22:32:54 -0800 Created attachment 119989 Patch 524491 2 119996 tkent 2011-12-20 01:59:22 -0800 Created attachment 119996 Patch 2 Avoid virtual function calls 524633 3 119996 dglazkov 2011-12-20 08:40:04 -0800 Comment on attachment 119996 Patch 2 Can we have a perf test for this? Seems like it should be fairly easy. 524687 4 119996 darin 2011-12-20 10:57:09 -0800 Comment on attachment 119996 Patch 2 View in context: https://bugs.webkit.org/attachment.cgi?id=119996&action=review It should be straightforward to put a test in LayoutTests/perf that shows that this was O(n^2) and is no longer O(n^2). > Source/WebCore/ChangeLog:12 > + We can skip this iteration in a case that validity status is not changed. This is not a sufficient explanation. > Source/WebCore/html/HTMLInputElement.cpp:188 > + CheckedRadioButtons& radioButtons = checkedRadioButtons(); > + bool radioGroupHadChecked = radioButtons.checkedButtonForGroup(name()); > if (attached() && checked()) > - checkedRadioButtons().addButton(this); > + radioButtons.addButton(this); > + bool radioGroupHasChecked = radioButtons.checkedButtonForGroup(name()); > + if (radioGroupHadChecked == radioGroupHasChecked) > + return; To understand the concept of this patch, one needs to look at RadioInputType::valueMissing. That’s where the rule about validity that is affected by radio button checking comes from. The division of code between HTMLInputElement and RadioInputType hides that, and it took me a long time to figure it out. There wasn’t even a comment that pointed specifically to “missing value” as the validity criterion that can change here. That’s a problem. This patch doesn’t optimize all the cases it seems to attempt. By the time this function is called by HTMLInputElement::setChecked, the button has already been removed from checkedRadioButtons(). So it seems to me that setChecked(true) on a radio button that is already checked won’t get the optimization because radioGroupHadChecked will be false even though it should have been true. This case ought to be covered by a performance test. Even for cases where the validity is in fact changing, I’d like to see us get rid of this massive performance cost for the very common case that the page is not using validity features at all. We shouldn’t walk the entire list of controls searching for other buttons in the group if nothing in the entire document is even looking at validity. We should probably consider a design where we keep a complete set of all the radio buttons in a group for each group. We avoided that before and kept track of only the checked radio button, which was an elegant thing to do without validity. But now that we have added a feature where the checkedness of a radio button can affect all the other buttons, even unchecked ones, it’s no longer a good trick, at least for pages where validity is being used. It seems we should reconsider the data structure. We cannot get acceptable performance by walking the whole document the way we do in this function. The algorithm is proportional to the size of the entire document for radio buttons outside forms, not just the number of radio buttons, and that is unacceptable. Even aside from the comments above I also think there are many things we should do to make the code readable and better. Not sure what order to do these in and what importance there is: - Change the updateCheckedRadioButtons function’s name. The function does not “update” checked radio buttons. What it does is record the fact that this button is checked if it is, and uncheck the old checked button. It does only half the job, and HTMLInputElement::setChecked does the other half. Perhaps the reason it only does half the job is so it can be called by RadioInputType::attach and doesn’t waste time removing the button if it’s not already there, but if so that’s not a great reason. Maybe we need to refactor the function as well. - Review HTMLInputElement::updateType and the code in HTMLInputElement::parseMappedAttribute for the name attribute, and figure out why it’s OK that these functions call CheckedRadioButtons::addButton directly without doing anything to update validity of other buttons in the group. My guess is that we could construct test cases showing there are bugs in those cases. - Review HTMLInputElement::willMoveToNewOwnerDocument and HTMLInputElement::~HTMLInputElement and figure out why it’s OK that these functions call CheckedRadioButtons::removeButton without doing anything to update validity of other buttons in the group. Again, I suspect at least one of these is a bug. It’s also strange that ~HTMLInputElement removes the radio button from the document’s CheckedRadioButtons only, no the one from the form. - Other functions that also manipulate the CheckedRadioButtons directly and probably handle the validation impact of this wrong include: HTMLFormControlElement::parseMappedAttribute for the form attribute, HTMLFormControlElement::insertedIntoTree, and HTMLFormElement::registerFormElement. - In the code that does update validity, currently part of the updateCheckedRadioButtons function, we need to add a comment to make it clear how checking a radio button relates to validity. Specifically, if a group gets into the state where there is no checked button this affects the valueMissing state of all the radio buttons in that group. - Since the validity updating in updateCheckedRadioButtons is specific to RadioInputType, that function should move into RadioInputType and out of HTMLInputElement. As should all manipulation of the checkedRadioButtons(). - Since CheckedRadioButtons already takes care of checking checked(), we should remove the redundant call to that function from HTMLInputElement::updateCheckedRadioButtons, unless it’s a helpful performance optimization. We should also investigate why HTMLInputElement::updateCheckedRadioButtons has to check attached(). Presumably CheckedRadioButtons::addButton should add that check too. Callers that are calling addButton without checking attached are probably doing it wrong. Maybe all the code in HTMLInputElement::updateCheckedRadioButtons should move into CheckedRadioButtons? - If we still have them, the loops in updateCheckedRadioButtons should use isRadioButton instead of checking type() == type() to see if something is a radio button. - For the the loops in updateCheckedRadioButtons we use an efficient way to check name equality. Calling name() ends up calling the virtual formControlName() function, all just to get at a field of HTMLInputElement. I don’t think we should go through a virtual function each time. I think we probably could compare m_name directly as long as we figure out what to do about null vs. empty values. In general it’s not good to have functions in HTMLInputElement going through a virtual function just to get at the m_name field with a bit of null value handling. We should override the name function in HTMLInputElement so that you can get the name instantly without a function call if you already have an HTMLInputElement*. We should put the special handling for null into HTMLInputElement::parseMappedAttribute rather than in HTMLInputElement::formControlName. - Document::m_formElementsWithState should change to hold HTMLFormControlElement* instead of Element*, and all the functions should likewise change. I think the looser type is a remnant of WML support. - The function HTMLInputElement::setDefaultName is strange and only used by HTMLIsIndexElement, so I suggest making it protected and giving it a different name. 525033 5 tkent 2011-12-20 18:23:29 -0800 Thank you for the loooong comment. I'll try to make a perf test. I won't make a single large patch to address all of your comments. I'll focus on some points in the next patch. (In reply to comment #4) > To understand the concept of this patch, one needs to look at RadioInputType::valueMissing. That’s where the rule about validity that is affected by radio button checking comes from. The division of code between HTMLInputElement and RadioInputType hides that, and it took me a long time to figure it out. There wasn’t even a comment that pointed specifically to “missing value” as the validity criterion that can change here. That’s a problem. Ok, I should have used InputType::valueMissing(), or HTMLFromControlEement::isValidFormControlElement() for readability. > This patch doesn’t optimize all the cases it seems to attempt. By the time this function is called by HTMLInputElement::setChecked, the button has already been removed from checkedRadioButtons(). So it seems to me that setChecked(true) on a radio button that is already checked won’t get the optimization because radioGroupHadChecked will be false even though it should have been true. This case ought to be covered by a performance test. You're right. The patch improves only a specific case. > Even for cases where the validity is in fact changing, I’d like to see us get rid of this massive performance cost for the very common case that the page is not using validity features at all. We shouldn’t walk the entire list of controls searching for other buttons in the group if nothing in the entire document is even looking at validity. If we can check existence of 'required' attribute in a radio group in O(1), we can skip the iteration in a case of no 'required'. > We should probably consider a design where we keep a complete set of all the radio buttons in a group for each group. We avoided that before and kept track of only the checked radio button, which was an elegant thing to do without validity. But now that we have added a feature where the checkedness of a radio button can affect all the other buttons, even unchecked ones, it’s no longer a good trick, at least for pages where validity is being used. It seems we should reconsider the data structure. We cannot get acceptable performance by walking the whole document the way we do in this function. The algorithm is proportional to the size of the entire document for radio buttons outside forms, not just the number of radio buttons, and that is unacceptable. I'd like to avoid keeping a complete set of radio buttons if possible. I'll try to make alternative solution. > Even aside from the comments above I also think there are many things we should do to make the code readable and better. Not sure what order to do these in and what importance there is: > - Change the updateCheckedRadioButtons function’s name. The function does not “update” checked radio buttons. What it does is record the fact that this button is checked if it is, and uncheck the old checked button. It does only half the job, and HTMLInputElement::setChecked does the other half. Perhaps the reason it only does half the job is so it can be called by RadioInputType::attach and doesn’t waste time removing the button if it’s not already there, but if so that’s not a great reason. Maybe we need to refactor the function as well. > > - Review HTMLInputElement::updateType and the code in HTMLInputElement::parseMappedAttribute for the name attribute, and figure out why it’s OK that these functions call CheckedRadioButtons::addButton directly without doing anything to update validity of other buttons in the group. My guess is that we could construct test cases showing there are bugs in those cases. It's not ok. I found this problem yesterday and filed Bug 74914. > - Review HTMLInputElement::willMoveToNewOwnerDocument and HTMLInputElement::~HTMLInputElement and figure out why it’s OK that these functions call CheckedRadioButtons::removeButton without doing anything to update validity of other buttons in the group. Again, I suspect at least one of these is a bug. It’s also strange that ~HTMLInputElement removes the radio button from the document’s CheckedRadioButtons only, no the one from the form. I think it's not ok too. Whenever updating a CheckedRadioButtons, we should update the validity state of radio butons in the same group. > - Other functions that also manipulate the CheckedRadioButtons directly and probably handle the validation impact of this wrong include: HTMLFormControlElement::parseMappedAttribute for the form attribute, HTMLFormControlElement::insertedIntoTree, and HTMLFormElement::registerFormElement. ditto. > - In the code that does update validity, currently part of the updateCheckedRadioButtons function, we need to add a comment to make it clear how checking a radio button relates to validity. Specifically, if a group gets into the state where there is no checked button this affects the valueMissing state of all the radio buttons in that group. > > - Since the validity updating in updateCheckedRadioButtons is specific to RadioInputType, that function should move into RadioInputType and out of HTMLInputElement. As should all manipulation of the checkedRadioButtons(). Indeed! > - Since CheckedRadioButtons already takes care of checking checked(), we should remove the redundant call to that function from HTMLInputElement::updateCheckedRadioButtons, unless it’s a helpful performance optimization. We should also investigate why HTMLInputElement::updateCheckedRadioButtons has to check attached(). Presumably CheckedRadioButtons::addButton should add that check too. Callers that are calling addButton without checking attached are probably doing it wrong. Maybe all the code in HTMLInputElement::updateCheckedRadioButtons should move into CheckedRadioButtons? > - If we still have them, the loops in updateCheckedRadioButtons should use isRadioButton instead of checking type() == type() to see if something is a radio button. > - For the the loops in updateCheckedRadioButtons we use an efficient way to check name equality. Calling name() ends up calling the virtual formControlName() function, all just to get at a field of HTMLInputElement. I don’t think we should go through a virtual function each time. I think we probably could compare m_name directly as long as we figure out what to do about null vs. empty values. In general it’s not good to have functions in HTMLInputElement going through a virtual function just to get at the m_name field with a bit of null value handling. We should override the name function in HTMLInputElement so that you can get the name instantly without a function call if you already have an HTMLInputElement*. We should put the special handling for null into HTMLInputElement::parseMappedAttribute rather than in HTMLInputElement::formControlName. > > - Document::m_formElementsWithState should change to hold HTMLFormControlElement* instead of Element*, and all the functions should likewise change. I think the looser type is a remnant of WML support. > > - The function HTMLInputElement::setDefaultName is strange and only used by HTMLIsIndexElement, so I suggest making it protected and giving it a different name. 525981 6 tkent 2011-12-21 21:33:44 -0800 I'm trying to change the CheckedRadioButtons::m_nameToCheckedRadioButtomMap so that it maps names to the following struct. struct { HTMLInputElmeent* checkedControl; size_t memberCount; size_t requiredCount; }; We need to keep the number of radio buttons with "required" attribute to check if the group needs validation. 525984 7 darin 2011-12-21 21:35:36 -0800 (In reply to comment #6) > I'm trying to change the CheckedRadioButtons::m_nameToCheckedRadioButtomMap so that it maps names to the following struct. > > struct { > HTMLInputElement* checkedControl; > size_t memberCount; > size_t requiredCount; > }; > > We need to keep the number of radio buttons with "required" attribute to check if the group needs validation. I think I would name this struct or class RadioButtonGroup. Then the map would be a map from a name to the radio button group of that name. 533727 8 121991 tkent 2012-01-11 00:55:49 -0800 Created attachment 121991 WIP 533729 9 tkent 2012-01-11 01:00:33 -0800 (In reply to comment #8) > Created an attachment (id=121991) [details] > WIP This is not ready for review. But comments are welcome. 534029 10 121991 darin 2012-01-11 10:47:13 -0800 Comment on attachment 121991 WIP View in context: https://bugs.webkit.org/attachment.cgi?id=121991&action=review > Source/WebCore/dom/CheckedRadioButtons.cpp:126 > + if (!m_members.size()) > + return; This check is not needed. An empty set can’t contain a member. > Source/WebCore/dom/CheckedRadioButtons.cpp:127 > + m_members.remove(element); It’s not efficient to do a contains and then a remove; it does two table lookups when we could do only one. Instead, we should do a find, and then use iterator to remove the set element. > Source/WebCore/dom/CheckedRadioButtons.cpp:129 > + if (!m_members.size()) > + return; This can leave m_requiredCount set to non-zero and m_checkedButton set to non-zero, so it’s wrong to return early here. > Source/WebCore/dom/CheckedRadioButtons.cpp:141 > + return; No need for this. > Source/WebCore/dom/CheckedRadioButtons.cpp:163 > +// Provide empty constructor and destructor in order to avoid that a compiler > +// generates them and requires RadioButtonGroup class during compiling Document.cpp. Mentioning Document.cpp seems a little too specific here. Otherwise, a useful comment. I would say “explicitly define” rather than “provide”. Also grammar mistake “avoid that a compiler generates them”. Could instead say in order to “prevent the compiler from generating them as inlines”. > Source/WebCore/dom/CheckedRadioButtons.cpp:182 > + NameToGroupMap::iterator i = m_nameToGroupMap->find(element->name().impl()); > + if (i == m_nameToGroupMap->end()) > + i = m_nameToGroupMap->set(element->name().impl(), RadioButtonGroup::create()).first; The right idiom here is to use add, not find/set. Check for null for the value and then call create. > Source/WebCore/dom/CheckedRadioButtons.cpp:196 > + NameToGroupMap::iterator i = m_nameToGroupMap->find(element->name().impl()); > + ASSERT(i != m_nameToGroupMap->end()); > + i->second->updateCheckedState(element); I suggest using get instead of find here. > Source/WebCore/dom/CheckedRadioButtons.cpp:209 > + NameToGroupMap::iterator i = m_nameToGroupMap->find(element->name().impl()); > + ASSERT(i != m_nameToGroupMap->end()); > + i->second->requiredAttributeChanged(element); Also here. Use get instead of find. > Source/WebCore/dom/CheckedRadioButtons.cpp:219 > + NameToGroupMap::iterator i = m_nameToGroupMap->find(name.impl()); > + return i == m_nameToGroupMap->end() ? 0 : i->second->checkedButton(); I suggest get instead of find. > Source/WebCore/html/HTMLFormControlElement.h:118 > + virtual void requiredAttributeChanged(); use OVERRIDE please 536376 11 122595 tkent 2012-01-15 22:52:29 -0800 Created attachment 122595 Patch 3 538377 12 tkent 2012-01-18 18:04:19 -0800 Darin, would you take a look at the patch please? 540223 13 122595 darin 2012-01-21 20:50:09 -0800 Comment on attachment 122595 Patch 3 View in context: https://bugs.webkit.org/attachment.cgi?id=122595&action=review Seems OK, with room for improvement. > Source/WebCore/dom/CheckedRadioButtons.cpp:34 > + HTMLInputElement* checkedButton() { return m_checkedButton; } Could be const. > Source/WebCore/dom/CheckedRadioButtons.cpp:65 > + if (m_members.contains(element)) > + return; > + > + m_members.add(element); Calling contains followed by add does two hash table lookups. But add is written so it already does nothing if the set already contains the new member and it returns a boolean that indicates that happened. The same thing can be done like this: if (!m_members.add(element).second) return; I know that’s not terribly readable but it’s faster than contains/add. At some point we’ll rename “second” to “newEntryAdded” or something like that. > Source/WebCore/dom/CheckedRadioButtons.cpp:66 > + bool updateValidityStatusInGroup = false; This is a verb phrase, and would be better if it was not. Maybe mustUpdateValidityForAllMembers, or something like that. > Source/WebCore/dom/CheckedRadioButtons.cpp:69 > + if (++m_requiredCount == 1) > + updateValidityStatusInGroup = true; Why? The fact that a group changing from not-required to required creates the need to update the validity status of all radio buttons in a group is not self-evident; it needs a comment. Unless the code can somehow be structured so that it is self-evident. For example, I would think that if the group has a checked button already, making the group required does not require updating the validity status. I am possibly wrong, but if so, reading this code wouldn’t clear things up for me. > Source/WebCore/dom/CheckedRadioButtons.cpp:75 > + ASSERT(oldCheckedButton != element); > + if (oldCheckedButton != element) { There seems no chance this assertion will be false, so I think we should omit the if statement. The function already checks if the set contains the new element, and I believe m_checkedButton won’t ever be set to something not in the set. > Source/WebCore/dom/CheckedRadioButtons.cpp:80 > + else if (isRequired()) > + updateValidityStatusInGroup = true; What this code does is not self-evident; it needs a comment. I gather that what’s happening is that a group that has no checked button is now acquiring a checked button, and that means the other buttons in the group are now valid. But that required careful study to determine and was not obvious from the code structure. Perhaps the code can somehow be structured so that it is self-evident but otherwise we should add a suitable comment. > Source/WebCore/dom/CheckedRadioButtons.cpp:86 > + else if (isRequired()) > + element->setNeedsValidityCheck(); Again, not clear why this is needed so needs a comment or different code structure. > Source/WebCore/dom/CheckedRadioButtons.cpp:89 > +void RadioButtonGroup::updateCheckedState(HTMLInputElement* element) Why not name this button instead of element? Generally speaking if the function can only be called with a radio button I think it’s good that we name the function that way. > Source/WebCore/dom/CheckedRadioButtons.cpp:98 > + if (element->checked()) { > + HTMLInputElement* oldCheckedButton = m_checkedButton; > + m_checkedButton = element; > + if (oldCheckedButton) > + oldCheckedButton->setChecked(false); > + else if (isRequired()) > + updateButtonsValidity(); We need to find a way to share this logic with the “add already checked button” code above in RadioButtonGroup::add. It’s identical, except for the coalescing of the updateButtonsValidity call. Should we also be asserting that element != m_checkedButton? > Source/WebCore/dom/CheckedRadioButtons.cpp:105 > + if (m_checkedButton == element) { > + m_checkedButton = 0; > + if (isRequired()) > + updateButtonsValidity(); > + } > + } I’d like to see this share code with the remove function. > Source/WebCore/dom/CheckedRadioButtons.cpp:113 > + if (element->required()) { > + if (++m_requiredCount == 1) > + updateButtonsValidity(); I’d like to see this share code with the add function. > Source/WebCore/dom/CheckedRadioButtons.cpp:118 > + ASSERT(m_requiredCount); > + if (!--m_requiredCount) > + updateButtonsValidity(); > + } I’d like to see this share code with the remove function. > Source/WebCore/dom/CheckedRadioButtons.cpp:133 > + if (element->checked()) { > + m_checkedButton = 0; Why check checked() rather than checking == m_checkedButton? > Source/WebCore/dom/CheckedRadioButtons.cpp:152 > +void RadioButtonGroup::updateButtonsValidity() > +{ > + typedef HashSet<HTMLInputElement*>::const_iterator Iterator; > + Iterator end = m_members.end(); > + for (Iterator it = m_members.begin(); it != end; ++it) { > + HTMLInputElement* control = *it; > + ASSERT(control->isRadioButton()); > + control->setNeedsValidityCheck(); > + } > +} I don’t like the difference in terminology here. This does not update the validity of the radio buttons. It sets a flag saying they need a validity check. That’s why the HTMLInputElement function is not named updateValidity. > Source/WebCore/dom/CheckedRadioButtons.cpp:162 > +// Explicity define empty constructor and destructor in order to prevent the > +// compiler from generating them as inlines and requiring RadioButtonGroup. This comment should include the phrase “so we don’t need to define RadioButtonGroup in the header”. I don’t think that “requiring RadioButtonGroup” is clear enough. > Source/WebCore/dom/CheckedRadioButtons.cpp:182 > + NameToGroupMap::iterator it = m_nameToGroupMap->add(element->name().impl(), PassOwnPtr<RadioButtonGroup>()).first; > + if (!it->second) > + it->second = RadioButtonGroup::create(); > + it->second->add(element); I normally write these like this: RefPtr<RadioButtonGroup>& group = m_nameToGroupMap->add(element->name().impl(), PassOwnPtr<RadioButtonGroup>()).first->second; if (!group) group = RadioButtonGroup::create(); group->add(element); Your way has at least one advantage over mine; the iterator gets checked after the call to RadioButtonGroup::create, so if something crazy happens we will find out in debug builds. But I like mine better for readability. > Source/WebCore/dom/CheckedRadioButtons.cpp:188 > + if (!shouldMakeRadioGroup(element)) > + return; Is it more efficient to check shouldMakeRadioGroup, or to let the rest of the code run and end up doing nothing since the element is not in the set in the group? I would normally lean toward the latter. > Source/WebCore/dom/CheckedRadioButtons.cpp:201 > + if (!shouldMakeRadioGroup(element)) > return; Same comment as above. > Source/WebCore/dom/CheckedRadioButtons.cpp:224 > + if (!shouldMakeRadioGroup(element)) > + return false; Is all the logic in the shouldMakeRadioGroup function needed here? I worry that this is more overhead than we need. > Source/WebCore/dom/CheckedRadioButtons.cpp:235 > + if (!shouldMakeRadioGroup(element)) > return; Does this improve performance? I’d suggest leaving it out unless we think it does. > Source/WebCore/dom/CheckedRadioButtons.cpp:248 > + it->second->remove(element); > + if (it->second->isEmpty()) { > + m_nameToGroupMap->remove(it); > + if (m_nameToGroupMap->isEmpty()) > + m_nameToGroupMap.clear(); > + } Deallocating these makes performance bad if we go from 0 to 1 and back and forth. Not deallocating them makes memory use bad if we have transient groups and leave behind empty data structures. I am not sure which is the right tradeoff. > Source/WebCore/dom/CheckedRadioButtons.h:33 > +// FIXME: Rename the class. This would be a better FIXME if it stated explicitly what we think is wrong with the current name. > Source/WebCore/html/CheckboxInputType.cpp:54 > - return !element()->checked(); > + return element()->isRequiredFormControl() && !element()->checked(); It’s wasteful that isRequiredFormControl is a virtual function dispatch here. It’s nothing new, though. > Source/WebCore/html/FileInputType.cpp:132 > - return value.isEmpty(); > + return element()->isRequiredFormControl() && value.isEmpty(); Ditto. > Source/WebCore/html/HTMLFormControlElement.cpp:136 > + // Updates for :required :optional classes. > + setNeedsStyleRecalc(); This comment, which you moved but did not change, is confusing grammar-wise. The phrase “updates for” could be a noun phrase. I would write: // Style recalculation is needed because style selectors may include :required and :optional pseudo-classes. > Source/WebCore/html/HTMLInputElement.h:75 > + virtual bool isRequiredFormControl() const OVERRIDE; It’s unfortunate that this public function is virtual. Any caller that has an HTMLInputElement* could instead call a non-virtual version. > Source/WebCore/html/RadioInputType.cpp:51 > - return !element()->checkedRadioButtons().checkedButtonForGroup(element()->name()); > + return element()->checkedRadioButtons().isInRequiredGroup(element()) && !element()->checkedRadioButtons().checkedButtonForGroup(element()->name()); Can a single radio button, not in a group, still be required? Or is that nonsense? If it is, do we have test cases for that? 541083 14 123691 tkent 2012-01-23 19:54:38 -0800 Created attachment 123691 Patch for landing 541084 15 122595 tkent 2012-01-23 19:56:17 -0800 Comment on attachment 122595 Patch 3 View in context: https://bugs.webkit.org/attachment.cgi?id=122595&action=review >> Source/WebCore/dom/CheckedRadioButtons.cpp:34 >> + HTMLInputElement* checkedButton() { return m_checkedButton; } > > Could be const. Done. >> Source/WebCore/dom/CheckedRadioButtons.cpp:65 >> + m_members.add(element); > > Calling contains followed by add does two hash table lookups. But add is written so it already does nothing if the set already contains the new member and it returns a boolean that indicates that happened. > > The same thing can be done like this: > > if (!m_members.add(element).second) > return; > > I know that’s not terribly readable but it’s faster than contains/add. At some point we’ll rename “second” to “newEntryAdded” or something like that. Done. >> Source/WebCore/dom/CheckedRadioButtons.cpp:69 >> + updateValidityStatusInGroup = true; > > Why? The fact that a group changing from not-required to required creates the need to update the validity status of all radio buttons in a group is not self-evident; it needs a comment. Unless the code can somehow be structured so that it is self-evident. > > For example, I would think that if the group has a checked button already, making the group required does not require updating the validity status. I am possibly wrong, but if so, reading this code wouldn’t clear things up for me. You're right. We need to update validity only if the group becomes required and has no checked button. I update the RadioButtonGroup code like bool wasValid = isValid(); ..... if (wasValid != isValid()) updateButtonValdity(); I think this change improved the code readability significantly. >> Source/WebCore/dom/CheckedRadioButtons.cpp:75 >> + if (oldCheckedButton != element) { > > There seems no chance this assertion will be false, so I think we should omit the if statement. The function already checks if the set contains the new element, and I believe m_checkedButton won’t ever be set to something not in the set. done. >> Source/WebCore/dom/CheckedRadioButtons.cpp:89 >> +void RadioButtonGroup::updateCheckedState(HTMLInputElement* element) > > Why not name this button instead of element? Generally speaking if the function can only be called with a radio button I think it’s good that we name the function that way. Done. >> Source/WebCore/dom/CheckedRadioButtons.cpp:98 >> + updateButtonsValidity(); > > We need to find a way to share this logic with the “add already checked button” code above in RadioButtonGroup::add. It’s identical, except for the coalescing of the updateButtonsValidity call. > > Should we also be asserting that element != m_checkedButton? I added RadioButtonGroup::setCheckedButton() to share the code. >> Source/WebCore/dom/CheckedRadioButtons.cpp:133 >> + m_checkedButton = 0; > > Why check checked() rather than checking == m_checkedButton? I changed this to if (m_checkedButton == button). >> Source/WebCore/dom/CheckedRadioButtons.cpp:152 >> +} > > I don’t like the difference in terminology here. This does not update the validity of the radio buttons. It sets a flag saying they need a validity check. That’s why the HTMLInputElement function is not named updateValidity. I renamed it to setNeedsValidityCheckForAllButtons(). >> Source/WebCore/dom/CheckedRadioButtons.cpp:162 >> +// compiler from generating them as inlines and requiring RadioButtonGroup. > > This comment should include the phrase “so we don’t need to define RadioButtonGroup in the header”. I don’t think that “requiring RadioButtonGroup” is clear enough. Done. >> Source/WebCore/dom/CheckedRadioButtons.cpp:182 >> + it->second->add(element); > > I normally write these like this: > > RefPtr<RadioButtonGroup>& group = m_nameToGroupMap->add(element->name().impl(), PassOwnPtr<RadioButtonGroup>()).first->second; > if (!group) > group = RadioButtonGroup::create(); > group->add(element); > > Your way has at least one advantage over mine; the iterator gets checked after the call to RadioButtonGroup::create, so if something crazy happens we will find out in debug builds. But I like mine better for readability. Done. >> Source/WebCore/dom/CheckedRadioButtons.cpp:188 >> + return; > > Is it more efficient to check shouldMakeRadioGroup, or to let the rest of the code run and end up doing nothing since the element is not in the set in the group? I would normally lean toward the latter. I thought the cost of HashMap<AtomicStringImpl*,...>::get() was higher than the cost of shouldMakeRadioGroup() because the key type is string and string hash is not a light operation. I found HashMap<AtomicStringImpl*,...> didn't use StringHash, but PtrHash. Also, a radio button group owner (<form> or document) typically has a little number of groups. I understand the hash lookup cost is not expensive here. However, checking shouldMakeRadioGroup() is required. For example, updateCheckedState() is called for a checkbox and a radio button not in a document tree, which might have a valid name(). We don't need to check name().isEmpty() here, but I think using a single function is good for simplicity and some assertions are helpful for avoiding inconsistent state of m_nameToGroupMap by future changes. >> Source/WebCore/dom/CheckedRadioButtons.cpp:224 >> + return false; > > Is all the logic in the shouldMakeRadioGroup function needed here? I worry that this is more overhead than we need. Changed to if (!element->inDocument()). isInRequiredGroup() is called only by RadioInputType. We don't need to check isRadioButton(). >> Source/WebCore/dom/CheckedRadioButtons.cpp:248 >> + } > > Deallocating these makes performance bad if we go from 0 to 1 and back and forth. Not deallocating them makes memory use bad if we have transient groups and leave behind empty data structures. I am not sure which is the right tradeoff. I adde a FIXME comment. We can't do it for now because m_nameToGroupMap doesn't own AtomicStringImpl objects. >> Source/WebCore/dom/CheckedRadioButtons.h:33 >> +// FIXME: Rename the class. > > This would be a better FIXME if it stated explicitly what we think is wrong with the current name. Done. >> Source/WebCore/html/CheckboxInputType.cpp:54 >> + return element()->isRequiredFormControl() && !element()->checked(); > > It’s wasteful that isRequiredFormControl is a virtual function dispatch here. It’s nothing new, though. Done. We already have non-virtual required(). There are no reasons to use isRequiredFormControl(). >> Source/WebCore/html/HTMLFormControlElement.cpp:136 >> + setNeedsStyleRecalc(); > > This comment, which you moved but did not change, is confusing grammar-wise. The phrase “updates for” could be a noun phrase. I would write: > > // Style recalculation is needed because style selectors may include :required and :optional pseudo-classes. Done. >> Source/WebCore/html/HTMLInputElement.h:75 >> + virtual bool isRequiredFormControl() const OVERRIDE; > > It’s unfortunate that this public function is virtual. Any caller that has an HTMLInputElement* could instead call a non-virtual version. Reverted this part. >> Source/WebCore/html/RadioInputType.cpp:51 >> + return element()->checkedRadioButtons().isInRequiredGroup(element()) && !element()->checkedRadioButtons().checkedButtonForGroup(element()->name()); > > Can a single radio button, not in a group, still be required? Or is that nonsense? If it is, do we have test cases for that? According to the HTML specification, such radio button can't be valueMissing(). I added a test case to fast/forms/ValidityState-valueMissing-radio.html. 541185 16 123691 webkit.review.bot 2012-01-24 01:57:33 -0800 Comment on attachment 123691 Patch for landing Rejecting attachment 123691 from commit-queue. New failing tests: media/audio-garbage-collect.html Full output: http://queues.webkit.org/results/11212753 541188 17 tkent 2012-01-24 02:02:47 -0800 Committed r105710: <http://trac.webkit.org/changeset/105710> 119989 2011-12-19 22:32:54 -0800 2011-12-20 01:59:15 -0800 Patch bug-74909-20111220153252.patch text/plain 1981 tkent U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzMzAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOGIzYWI3YTc1YWI4YzE5 ZGJjMWVkOWZkZjM4MTA0YTVkYmI4M2U1Yy4uYTQ2ZTMwMzI0NmY0NTI5ZDE1NDAwZjFmMzhiM2Y0 OTRlNmFmYTNiNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDExLTEyLTE5ICBLZW50 IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KKworICAgICAgICBQZXJmb3JtYW5jZSBpbXBy b3ZlbWVudCBvZiBIVE1MSW5wdXRFbGVtZW50Ojp1cGRhdGVDaGVja2VkUmFkaW9CdXR0b25zKCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc0OTA5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgdXBkYXRlQ2hl Y2tlZFJhZGlvQnV0dG9ucygpIGlzIGNhbGxlZCBpbiBhdHRhY2goKSBmb3IgYSByYWRpbyBidXR0 b24sCisgICAgICAgIGFuZCBpdCBpdGVyYXRlcyBvdmVyIGFsbCBvZiByYWRpbyBidXR0b25zIGlu IHRoZSBzYW1lIHJhZGlvIGdyb3VwLiBJdAorICAgICAgICBtYWRlIGRvY3VtZW50IHJlbmRlcmlu ZyBzbG93ZXIgaWYgdGhlIGRvY3VtZW50IGhhcyBhIHJhZGlvIGdyb3VwIHdpdGgKKyAgICAgICAg bWFueSByYWRpbyBidXR0b25zLgorICAgICAgICBXZSBjYW4gc2tpcCB0aGlzIGl0ZXJhdGlvbiBp biBhIGNhc2UgdGhhdCB2YWxpZGl0eSBzdGF0dXMgaXMgbm90IGNoYW5nZWQuCisKKyAgICAgICAg KiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0 RWxlbWVudDo6dXBkYXRlQ2hlY2tlZFJhZGlvQnV0dG9ucyk6CisgICAgICAgIEl0ZXJhdGVzIG9u bHkgaWYgdGhlIHZhbGlkaXR5IHN0YXRlIG9mIHRoZSByYWRpbyBncm91cCBpcyBjaGFuZ2VkLgor CiAyMDExLTEyLTE5ICBBbWkgRmlzY2htYW4gIDxmaXNjaG1hbkBjaHJvbWl1bS5vcmc+CiAKICAg ICAgICAgVGVhY2ggVmlkZW9MYXllckNocm9taXVtIGhvdyB0byByZW5kZXIgbmF0aXZlIHRleHR1 cmUgKHRvIHN1cHBvcnQgSFcgdmlkZW8gZGVjb2RlKS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJ bnB1dEVsZW1lbnQuY3BwCmluZGV4IDdlMDNlYzZmMWFjZGM1ODQ1OTY5MGFkOWQzNWY0NjA5MWE2 YzdhZGMuLjdmNTI1YzEyMTI2YmQ1ODI3YTQ1ODUzYmFiZjY0MzhlNmExMTdmM2EgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtMTc5LDggKzE3OSwxMiBAQCBi b29sIEhUTUxJbnB1dEVsZW1lbnQ6OnNob3VsZEF1dG9jb21wbGV0ZSgpIGNvbnN0CiAKIHZvaWQg SFRNTElucHV0RWxlbWVudDo6dXBkYXRlQ2hlY2tlZFJhZGlvQnV0dG9ucygpCiB7CisgICAgYm9v bCByYWRpb0dyb3VwV2FzVmFsaWQgPSBtX2lucHV0VHlwZS0+dmFsdWVNaXNzaW5nKFN0cmluZygp KTsKICAgICBpZiAoYXR0YWNoZWQoKSAmJiBjaGVja2VkKCkpCiAgICAgICAgIGNoZWNrZWRSYWRp b0J1dHRvbnMoKS5hZGRCdXR0b24odGhpcyk7CisgICAgYm9vbCByYWRpb0dyb3VwSXNWYWxpZCA9 IG1faW5wdXRUeXBlLT52YWx1ZU1pc3NpbmcoU3RyaW5nKCkpOworICAgIGlmIChyYWRpb0dyb3Vw V2FzVmFsaWQgPT0gcmFkaW9Hcm91cElzVmFsaWQpCisgICAgICAgIHJldHVybjsKIAogICAgIGlm IChmb3JtKCkpIHsKICAgICAgICAgY29uc3QgVmVjdG9yPEZvcm1Bc3NvY2lhdGVkRWxlbWVudCo+ JiBjb250cm9scyA9IGZvcm0oKS0+YXNzb2NpYXRlZEVsZW1lbnRzKCk7Cg== 119996 2011-12-20 01:59:22 -0800 2012-01-11 00:55:45 -0800 Patch 2 bug-74909-20111220185920.patch text/plain 2107 tkent U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzMzAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOGIzYWI3YTc1YWI4YzE5 ZGJjMWVkOWZkZjM4MTA0YTVkYmI4M2U1Yy4uNmE1MGIzOGQxMTUxNzBlYzIxMzEyMDExMzYzYzYx NzIzNzk1MDUwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDExLTEyLTE5ICBLZW50 IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KKworICAgICAgICBQZXJmb3JtYW5jZSBpbXBy b3ZlbWVudCBvZiBIVE1MSW5wdXRFbGVtZW50Ojp1cGRhdGVDaGVja2VkUmFkaW9CdXR0b25zKCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc0OTA5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgdXBkYXRlQ2hl Y2tlZFJhZGlvQnV0dG9ucygpIGlzIGNhbGxlZCBpbiBhdHRhY2goKSBmb3IgYSByYWRpbyBidXR0 b24sCisgICAgICAgIGFuZCBpdCBpdGVyYXRlcyBvdmVyIGFsbCBvZiByYWRpbyBidXR0b25zIGlu IHRoZSBzYW1lIHJhZGlvIGdyb3VwLiBJdAorICAgICAgICBtYWRlIGRvY3VtZW50IHJlbmRlcmlu ZyBzbG93ZXIgaWYgdGhlIGRvY3VtZW50IGhhcyBhIHJhZGlvIGdyb3VwIHdpdGgKKyAgICAgICAg bWFueSByYWRpbyBidXR0b25zLgorICAgICAgICBXZSBjYW4gc2tpcCB0aGlzIGl0ZXJhdGlvbiBp biBhIGNhc2UgdGhhdCB2YWxpZGl0eSBzdGF0dXMgaXMgbm90IGNoYW5nZWQuCisKKyAgICAgICAg KiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0 RWxlbWVudDo6dXBkYXRlQ2hlY2tlZFJhZGlvQnV0dG9ucyk6CisgICAgICAgIEl0ZXJhdGVzIG9u bHkgaWYgdGhlIGNoZWNrZWQgc3RhdGUgb2YgdGhlIHJhZGlvIGdyb3VwIGlzIGNoYW5nZWQuCisK IDIwMTEtMTItMTkgIEFtaSBGaXNjaG1hbiAgPGZpc2NobWFuQGNocm9taXVtLm9yZz4KIAogICAg ICAgICBUZWFjaCBWaWRlb0xheWVyQ2hyb21pdW0gaG93IHRvIHJlbmRlciBuYXRpdmUgdGV4dHVy ZSAodG8gc3VwcG9ydCBIVyB2aWRlbyBkZWNvZGUpLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElu cHV0RWxlbWVudC5jcHAKaW5kZXggN2UwM2VjNmYxYWNkYzU4NDU5NjkwYWQ5ZDM1ZjQ2MDkxYTZj N2FkYy4uZDFhNGE4YzdmMTFhNTgyNDU1ZmNlMjYxYTc3OTA4NDdjMDZkZDM1OSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC0xNzksOCArMTc5LDEzIEBAIGJv b2wgSFRNTElucHV0RWxlbWVudDo6c2hvdWxkQXV0b2NvbXBsZXRlKCkgY29uc3QKIAogdm9pZCBI VE1MSW5wdXRFbGVtZW50Ojp1cGRhdGVDaGVja2VkUmFkaW9CdXR0b25zKCkKIHsKKyAgICBDaGVj a2VkUmFkaW9CdXR0b25zJiByYWRpb0J1dHRvbnMgPSBjaGVja2VkUmFkaW9CdXR0b25zKCk7Cisg ICAgYm9vbCByYWRpb0dyb3VwSGFkQ2hlY2tlZCA9IHJhZGlvQnV0dG9ucy5jaGVja2VkQnV0dG9u Rm9yR3JvdXAobmFtZSgpKTsKICAgICBpZiAoYXR0YWNoZWQoKSAmJiBjaGVja2VkKCkpCi0gICAg ICAgIGNoZWNrZWRSYWRpb0J1dHRvbnMoKS5hZGRCdXR0b24odGhpcyk7CisgICAgICAgIHJhZGlv QnV0dG9ucy5hZGRCdXR0b24odGhpcyk7CisgICAgYm9vbCByYWRpb0dyb3VwSGFzQ2hlY2tlZCA9 IHJhZGlvQnV0dG9ucy5jaGVja2VkQnV0dG9uRm9yR3JvdXAobmFtZSgpKTsKKyAgICBpZiAocmFk aW9Hcm91cEhhZENoZWNrZWQgPT0gcmFkaW9Hcm91cEhhc0NoZWNrZWQpCisgICAgICAgIHJldHVy bjsKIAogICAgIGlmIChmb3JtKCkpIHsKICAgICAgICAgY29uc3QgVmVjdG9yPEZvcm1Bc3NvY2lh dGVkRWxlbWVudCo+JiBjb250cm9scyA9IGZvcm0oKS0+YXNzb2NpYXRlZEVsZW1lbnRzKCk7Cg== 121991 2012-01-11 00:55:49 -0800 2012-01-15 22:52:22 -0800 WIP bug-74909-20120111175547.patch text/plain 17702 tkent U3VidmVyc2lvbiBSZXZpc2lvbjogMTA0NjY4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODkwZDEzZmQ5ZTVkMmRi MWE3ZjFiYzVhZGJjMTdkY2RmYWY3NDQ0Yy4uNzk2MDgzMmI1MDhkYjM1NmM5YzA5YTBiMzI0NWEw NjI0ZDNkZTRiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQxIEBACisyMDEyLTAxLTExICBLZW50 IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KKworICAgICAgICBQZXJmb3JtYW5jZSBpbXBy b3ZlbWVudCBvZiBIVE1MSW5wdXRFbGVtZW50Ojp1cGRhdGVDaGVja2VkUmFkaW9CdXR0b25zKCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc0OTA5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRl c3RzLiAoT09QUyEpCisKKyAgICAgICAgKiBkb20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpSYWRpb0J1dHRvbkdyb3VwOjppc0VtcHR5KToKKyAgICAgICAgKFdl YkNvcmU6OlJhZGlvQnV0dG9uR3JvdXA6OmNoZWNrZWRCdXR0b24pOgorICAgICAgICAoV2ViQ29y ZTo6UmFkaW9CdXR0b25Hcm91cDo6UmFkaW9CdXR0b25Hcm91cCk6CisgICAgICAgIChXZWJDb3Jl OjpSYWRpb0J1dHRvbkdyb3VwOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9CdXR0 b25Hcm91cDo6YWRkKToKKyAgICAgICAgKFdlYkNvcmU6OlJhZGlvQnV0dG9uR3JvdXA6OnVwZGF0 ZUNoZWNrZWRTdGF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpSYWRpb0J1dHRvbkdyb3VwOjpyZXF1 aXJlZEF0dHJpYnV0ZUNoYW5nZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9CdXR0b25Hcm91 cDo6cmVtb3ZlKToKKyAgICAgICAgKFdlYkNvcmU6OlJhZGlvQnV0dG9uR3JvdXA6OnVwZGF0ZUJ1 dHRvbnNWYWxpZGl0eSk6CisgICAgICAgIChXZWJDb3JlOjpDaGVja2VkUmFkaW9CdXR0b25zOjpD aGVja2VkUmFkaW9CdXR0b25zKToKKyAgICAgICAgKFdlYkNvcmU6OkNoZWNrZWRSYWRpb0J1dHRv bnM6On5DaGVja2VkUmFkaW9CdXR0b25zKToKKyAgICAgICAgKFdlYkNvcmU6OkNoZWNrZWRSYWRp b0J1dHRvbnM6OmFkZEJ1dHRvbik6CisgICAgICAgIChXZWJDb3JlOjpDaGVja2VkUmFkaW9CdXR0 b25zOjp1cGRhdGVDaGVja2VkU3RhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q2hlY2tlZFJhZGlv QnV0dG9uczo6cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKToKKyAgICAgICAgKFdlYkNvcmU6OkNo ZWNrZWRSYWRpb0J1dHRvbnM6OmNoZWNrZWRCdXR0b25Gb3JHcm91cCk6CisgICAgICAgIChXZWJD b3JlOjpDaGVja2VkUmFkaW9CdXR0b25zOjpyZW1vdmVCdXR0b24pOgorICAgICAgICAqIGRvbS9D aGVja2VkUmFkaW9CdXR0b25zLmg6CisgICAgICAgICogaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVt ZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OnBhcnNl TWFwcGVkQXR0cmlidXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxGb3JtQ29udHJvbEVsZW1l bnQ6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCk6CisgICAgICAgICogaHRtbC9IVE1MRm9ybUNv bnRyb2xFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldENoZWNrZWQpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKToKKyAg ICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuaDoKKyAgICAgICAgKiBodG1sL1JhZGlvSW5w dXRUeXBlLmNwcDoKKyAgICAgICAgKiBodG1sL1JhZGlvSW5wdXRUeXBlLmg6CisKIDIwMTItMDEt MDQgIEtlbnQgVGFtdXJhICA8dGtlbnRAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIEEgcmFkaW8g YnV0dG9uIG5vdCBpbiBhIGRvY3VtZW50IHNob3VsZCBub3Qgam9pbiBhIHJhZGlvIGJ1dHRvbiBn cm91cApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMu Y3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMuY3BwCmluZGV4IDlh Yjg5MTIwZjlkNzBjMGI1M2I4Njc4NDA5MWU0MzJiOTY1NWU0YTYuLmU0YjFjZWY5MWE2ZDM4MzVm NjA4N2U5MTdhYTVkNDU2MzgyYjY5OWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9D aGVja2VkUmFkaW9CdXR0b25zLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vQ2hlY2tlZFJh ZGlvQnV0dG9ucy5jcHAKQEAgLTIxLDY2ICsyMSwyMjIgQEAKICNpbmNsdWRlICJjb25maWcuaCIK ICNpbmNsdWRlICJDaGVja2VkUmFkaW9CdXR0b25zLmgiCiAKKyNpbmNsdWRlICJIVE1MRm9ybUVs ZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCisjaW5jbHVkZSA8d3RmL0hh c2hTZXQuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBSYWRpb0J1dHRvbkdyb3Vw IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxSYWRpb0J1dHRvbkdyb3VwPiBjcmVh dGUoKTsKKyAgICBib29sIGlzRW1wdHkoKSBjb25zdCB7IHJldHVybiBtX21lbWJlcnMuaXNFbXB0 eSgpOyB9CisgICAgSFRNTElucHV0RWxlbWVudCogY2hlY2tlZEJ1dHRvbigpIHsgcmV0dXJuIG1f Y2hlY2tlZEJ1dHRvbjsgfQorICAgIHZvaWQgYWRkKEhUTUxJbnB1dEVsZW1lbnQqKTsKKyAgICB2 b2lkIHVwZGF0ZUNoZWNrZWRTdGF0ZShIVE1MSW5wdXRFbGVtZW50Kik7CisgICAgdm9pZCByZXF1 aXJlZEF0dHJpYnV0ZUNoYW5nZWQoSFRNTElucHV0RWxlbWVudCopOworICAgIHZvaWQgcmVtb3Zl KEhUTUxJbnB1dEVsZW1lbnQqKTsKKworcHJpdmF0ZToKKyAgICBSYWRpb0J1dHRvbkdyb3VwKCk7 CisgICAgdm9pZCB1cGRhdGVCdXR0b25zVmFsaWRpdHkoKTsKKworICAgIEhhc2hTZXQ8SFRNTElu cHV0RWxlbWVudCo+IG1fbWVtYmVyczsKKyAgICBIVE1MSW5wdXRFbGVtZW50KiBtX2NoZWNrZWRC dXR0b247CisgICAgc2l6ZV90IG1fcmVxdWlyZWRDb3VudDsKK307CisKK1JhZGlvQnV0dG9uR3Jv dXA6OlJhZGlvQnV0dG9uR3JvdXAoKQorICAgIDogbV9jaGVja2VkQnV0dG9uKDApCisgICAgLCBt X3JlcXVpcmVkQ291bnQoMCkKK3sKK30KKworUGFzc093blB0cjxSYWRpb0J1dHRvbkdyb3VwPiBS YWRpb0J1dHRvbkdyb3VwOjpjcmVhdGUoKQoreworICAgIHJldHVybiBhZG9wdFB0cihuZXcgUmFk aW9CdXR0b25Hcm91cCk7Cit9CisKK3ZvaWQgUmFkaW9CdXR0b25Hcm91cDo6YWRkKEhUTUxJbnB1 dEVsZW1lbnQqIGVsZW1lbnQpCit7CisgICAgaWYgKG1fbWVtYmVycy5jb250YWlucyhlbGVtZW50 KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgbV9tZW1iZXJzLmFkZChlbGVtZW50KTsKKyAgICBi b29sIHVwZGF0ZVZhbGlkaXR5U3RhdHVzID0gZmFsc2U7CisgICAgaWYgKGVsZW1lbnQtPnJlcXVp cmVkKCkpIHsKKyAgICAgICAgaWYgKCsrbV9yZXF1aXJlZENvdW50ID09IDEpCisgICAgICAgICAg ICB1cGRhdGVWYWxpZGl0eVN0YXR1cyA9IHRydWU7CisgICAgfQorCisgICAgaWYgKGVsZW1lbnQt PmNoZWNrZWQoKSkgeworICAgICAgICBIVE1MSW5wdXRFbGVtZW50KiBvbGRDaGVja2VkQnV0dG9u ID0gbV9jaGVja2VkQnV0dG9uOworICAgICAgICBBU1NFUlQob2xkQ2hlY2tlZEJ1dHRvbiAhPSBl bGVtZW50KTsKKyAgICAgICAgaWYgKG9sZENoZWNrZWRCdXR0b24gIT0gZWxlbWVudCkgeworICAg ICAgICAgICAgbV9jaGVja2VkQnV0dG9uID0gZWxlbWVudDsKKyAgICAgICAgICAgIGlmIChvbGRD aGVja2VkQnV0dG9uKQorICAgICAgICAgICAgICAgIG9sZENoZWNrZWRCdXR0b24tPnNldENoZWNr ZWQoZmFsc2UpOworICAgICAgICAgICAgZWxzZSBpZiAobV9yZXF1aXJlZENvdW50KQorICAgICAg ICAgICAgICAgIHVwZGF0ZVZhbGlkaXR5U3RhdHVzID0gdHJ1ZTsKKyAgICAgICAgfQorICAgIH0K KyAgICBpZiAodXBkYXRlVmFsaWRpdHlTdGF0dXMpCisgICAgICAgIHVwZGF0ZUJ1dHRvbnNWYWxp ZGl0eSgpOworfQorCit2b2lkIFJhZGlvQnV0dG9uR3JvdXA6OnVwZGF0ZUNoZWNrZWRTdGF0ZShI VE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KQoreworICAgIEFTU0VSVChtX21lbWJlcnMuY29udGFp bnMoZWxlbWVudCkpOworICAgIGlmIChlbGVtZW50LT5jaGVja2VkKCkpIHsKKyAgICAgICAgSFRN TElucHV0RWxlbWVudCogb2xkQ2hlY2tlZEJ1dHRvbiA9IG1fY2hlY2tlZEJ1dHRvbjsKKyAgICAg ICAgbV9jaGVja2VkQnV0dG9uID0gZWxlbWVudDsKKyAgICAgICAgaWYgKG9sZENoZWNrZWRCdXR0 b24pCisgICAgICAgICAgICBvbGRDaGVja2VkQnV0dG9uLT5zZXRDaGVja2VkKGZhbHNlKTsKKyAg ICAgICAgZWxzZSBpZiAobV9yZXF1aXJlZENvdW50KQorICAgICAgICAgICAgdXBkYXRlQnV0dG9u c1ZhbGlkaXR5KCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgaWYgKG1fY2hlY2tlZEJ1dHRvbiA9 PSBlbGVtZW50KSB7CisgICAgICAgICAgICBtX2NoZWNrZWRCdXR0b24gPSAwOworICAgICAgICAg ICAgaWYgKG1fcmVxdWlyZWRDb3VudCkKKyAgICAgICAgICAgICAgICB1cGRhdGVCdXR0b25zVmFs aWRpdHkoKTsKKyAgICAgICAgfQorICAgIH0KK30KKwordm9pZCBSYWRpb0J1dHRvbkdyb3VwOjpy ZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKK3sKKyAg ICBBU1NFUlQobV9tZW1iZXJzLmNvbnRhaW5zKGVsZW1lbnQpKTsKKyAgICBpZiAoZWxlbWVudC0+ cmVxdWlyZWQoKSkgeworICAgICAgICBpZiAoKyttX3JlcXVpcmVkQ291bnQgPT0gMSkKKyAgICAg ICAgICAgIHVwZGF0ZUJ1dHRvbnNWYWxpZGl0eSgpOworICAgIH0gZWxzZSB7CisgICAgICAgIEFT U0VSVChtX3JlcXVpcmVkQ291bnQpOworICAgICAgICBpZiAoIS0tbV9yZXF1aXJlZENvdW50KQor ICAgICAgICAgICAgdXBkYXRlQnV0dG9uc1ZhbGlkaXR5KCk7CisgICAgfQorfQorCit2b2lkIFJh ZGlvQnV0dG9uR3JvdXA6OnJlbW92ZShIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KQoreworICAg IGlmICghbV9tZW1iZXJzLmNvbnRhaW5zKGVsZW1lbnQpKQorICAgICAgICByZXR1cm47CisKKyAg ICBBU1NFUlQobV9tZW1iZXJzLnNpemUoKSk7CisgICAgaWYgKCFtX21lbWJlcnMuc2l6ZSgpKQor ICAgICAgICByZXR1cm47CisgICAgbV9tZW1iZXJzLnJlbW92ZShlbGVtZW50KTsKKyAgICBpZiAo IW1fbWVtYmVycy5zaXplKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChlbGVtZW50LT5y ZXF1aXJlZCgpKSB7CisgICAgICAgIEFTU0VSVChtX3JlcXVpcmVkQ291bnQpOworICAgICAgICBp ZiAoIS0tbV9yZXF1aXJlZENvdW50KQorICAgICAgICAgICAgdXBkYXRlQnV0dG9uc1ZhbGlkaXR5 KCk7CisgICAgfQorICAgIGlmIChlbGVtZW50LT5jaGVja2VkKCkpIHsKKyAgICAgICAgbV9jaGVj a2VkQnV0dG9uID0gMDsKKyAgICAgICAgaWYgKG1fcmVxdWlyZWRDb3VudCkKKyAgICAgICAgICAg IHVwZGF0ZUJ1dHRvbnNWYWxpZGl0eSgpOworICAgIH0KKyAgICByZXR1cm47Cit9CisKK3ZvaWQg UmFkaW9CdXR0b25Hcm91cDo6dXBkYXRlQnV0dG9uc1ZhbGlkaXR5KCkKK3sKKyAgICB0eXBlZGVm IEhhc2hTZXQ8SFRNTElucHV0RWxlbWVudCo+Ojpjb25zdF9pdGVyYXRvciBJdGVyYXRvcjsKKyAg ICBJdGVyYXRvciBlbmQgPSBtX21lbWJlcnMuZW5kKCk7CisgICAgZm9yIChJdGVyYXRvciBpdCA9 IG1fbWVtYmVycy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgSFRNTElucHV0 RWxlbWVudCogY29udHJvbCA9ICppdDsKKyAgICAgICAgQVNTRVJUKGNvbnRyb2wtPmlzUmFkaW9C dXR0b24oKSk7CisgICAgICAgIGNvbnRyb2wtPnNldE5lZWRzVmFsaWRpdHlDaGVjaygpOworICAg IH0KK30KKworLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQorCiBzdGF0aWMgaW5saW5lIGJvb2wgc2hvdWxkTWFrZVJhZGlv R3JvdXAoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKIHsKICAgICByZXR1cm4gZWxlbWVudC0+ aXNSYWRpb0J1dHRvbigpICYmICFlbGVtZW50LT5uYW1lKCkuaXNFbXB0eSgpICYmIGVsZW1lbnQt PmluRG9jdW1lbnQoKTsKIH0KIAorLy8gUHJvdmlkZSBlbXB0eSBjb25zdHJ1Y3RvciBhbmQgZGVz dHJ1Y3RvciBpbiBvcmRlciB0byBhdm9pZCB0aGF0IGEgY29tcGlsZXIKKy8vIGdlbmVyYXRlcyB0 aGVtIGFuZCByZXF1aXJlcyBSYWRpb0J1dHRvbkdyb3VwIGNsYXNzIGR1cmluZyBjb21waWxpbmcg RG9jdW1lbnQuY3BwLgorQ2hlY2tlZFJhZGlvQnV0dG9uczo6Q2hlY2tlZFJhZGlvQnV0dG9ucygp Cit7Cit9CisKK0NoZWNrZWRSYWRpb0J1dHRvbnM6On5DaGVja2VkUmFkaW9CdXR0b25zKCkKK3sK K30KKwogdm9pZCBDaGVja2VkUmFkaW9CdXR0b25zOjphZGRCdXR0b24oSFRNTElucHV0RWxlbWVu dCogZWxlbWVudCkKIHsKICAgICBpZiAoIXNob3VsZE1ha2VSYWRpb0dyb3VwKGVsZW1lbnQpKQog ICAgICAgICByZXR1cm47CiAKLSAgICAvLyBXZSBvbmx5IHRyYWNrIGNoZWNrZWQgYnV0dG9ucy4K LSAgICBpZiAoIWVsZW1lbnQtPmNoZWNrZWQoKSkKKyAgICBpZiAoIW1fbmFtZVRvR3JvdXBNYXAp CisgICAgICAgIG1fbmFtZVRvR3JvdXBNYXAgPSBhZG9wdFB0cihuZXcgTmFtZVRvR3JvdXBNYXAp OworCisgICAgTmFtZVRvR3JvdXBNYXA6Oml0ZXJhdG9yIGkgPSBtX25hbWVUb0dyb3VwTWFwLT5m aW5kKGVsZW1lbnQtPm5hbWUoKS5pbXBsKCkpOworICAgIGlmIChpID09IG1fbmFtZVRvR3JvdXBN YXAtPmVuZCgpKQorICAgICAgICBpID0gbV9uYW1lVG9Hcm91cE1hcC0+c2V0KGVsZW1lbnQtPm5h bWUoKS5pbXBsKCksIFJhZGlvQnV0dG9uR3JvdXA6OmNyZWF0ZSgpKS5maXJzdDsKKyAgICBpLT5z ZWNvbmQtPmFkZChlbGVtZW50KTsKK30KKwordm9pZCBDaGVja2VkUmFkaW9CdXR0b25zOjp1cGRh dGVDaGVja2VkU3RhdGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKK3sKKyAgICBpZiAoIXNo b3VsZE1ha2VSYWRpb0dyb3VwKGVsZW1lbnQpKQorICAgICAgICByZXR1cm47CisgICAgQVNTRVJU KG1fbmFtZVRvR3JvdXBNYXApOworICAgIGlmICghbV9uYW1lVG9Hcm91cE1hcCkKICAgICAgICAg cmV0dXJuOwogCi0gICAgaWYgKCFtX25hbWVUb0NoZWNrZWRSYWRpb0J1dHRvbk1hcCkKLSAgICAg ICAgbV9uYW1lVG9DaGVja2VkUmFkaW9CdXR0b25NYXAgPSBhZG9wdFB0cihuZXcgTmFtZVRvSW5w dXRNYXApOworICAgIE5hbWVUb0dyb3VwTWFwOjppdGVyYXRvciBpID0gbV9uYW1lVG9Hcm91cE1h cC0+ZmluZChlbGVtZW50LT5uYW1lKCkuaW1wbCgpKTsKKyAgICBBU1NFUlQoaSAhPSBtX25hbWVU b0dyb3VwTWFwLT5lbmQoKSk7CisgICAgaS0+c2Vjb25kLT51cGRhdGVDaGVja2VkU3RhdGUoZWxl bWVudCk7Cit9CiAKLSAgICBwYWlyPE5hbWVUb0lucHV0TWFwOjppdGVyYXRvciwgYm9vbD4gcmVz dWx0ID0gbV9uYW1lVG9DaGVja2VkUmFkaW9CdXR0b25NYXAtPmFkZChlbGVtZW50LT5uYW1lKCku aW1wbCgpLCBlbGVtZW50KTsKLSAgICBpZiAocmVzdWx0LnNlY29uZCkKK3ZvaWQgQ2hlY2tlZFJh ZGlvQnV0dG9uczo6cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKEhUTUxJbnB1dEVsZW1lbnQqIGVs ZW1lbnQpCit7CisgICAgaWYgKCFzaG91bGRNYWtlUmFkaW9Hcm91cChlbGVtZW50KSkKICAgICAg ICAgcmV0dXJuOwotICAgIAotICAgIEhUTUxJbnB1dEVsZW1lbnQqIG9sZENoZWNrZWRCdXR0b24g PSByZXN1bHQuZmlyc3QtPnNlY29uZDsKLSAgICBpZiAob2xkQ2hlY2tlZEJ1dHRvbiA9PSBlbGVt ZW50KQorICAgIEFTU0VSVChtX25hbWVUb0dyb3VwTWFwKTsKKyAgICBpZiAoIW1fbmFtZVRvR3Jv dXBNYXApCiAgICAgICAgIHJldHVybjsKIAotICAgIHJlc3VsdC5maXJzdC0+c2Vjb25kID0gZWxl bWVudDsKLSAgICBvbGRDaGVja2VkQnV0dG9uLT5zZXRDaGVja2VkKGZhbHNlKTsKKyAgICBOYW1l VG9Hcm91cE1hcDo6aXRlcmF0b3IgaSA9IG1fbmFtZVRvR3JvdXBNYXAtPmZpbmQoZWxlbWVudC0+ bmFtZSgpLmltcGwoKSk7CisgICAgQVNTRVJUKGkgIT0gbV9uYW1lVG9Hcm91cE1hcC0+ZW5kKCkp OworICAgIGktPnNlY29uZC0+cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKGVsZW1lbnQpOwogfQog CiBIVE1MSW5wdXRFbGVtZW50KiBDaGVja2VkUmFkaW9CdXR0b25zOjpjaGVja2VkQnV0dG9uRm9y R3JvdXAoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lKSBjb25zdAogewotICAgIGlmICghbV9uYW1l VG9DaGVja2VkUmFkaW9CdXR0b25NYXApCisgICAgaWYgKCFtX25hbWVUb0dyb3VwTWFwKQogICAg ICAgICByZXR1cm4gMDsKIAotICAgIG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwLT5jaGVj a0NvbnNpc3RlbmN5KCk7Ci0gICAgCi0gICAgcmV0dXJuIG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0 dG9uTWFwLT5nZXQobmFtZS5pbXBsKCkpOworICAgIG1fbmFtZVRvR3JvdXBNYXAtPmNoZWNrQ29u c2lzdGVuY3koKTsKKyAgICBOYW1lVG9Hcm91cE1hcDo6aXRlcmF0b3IgaSA9IG1fbmFtZVRvR3Jv dXBNYXAtPmZpbmQobmFtZS5pbXBsKCkpOworICAgIHJldHVybiBpID09IG1fbmFtZVRvR3JvdXBN YXAtPmVuZCgpID8gMCA6IGktPnNlY29uZC0+Y2hlY2tlZEJ1dHRvbigpOwogfQogCiB2b2lkIENo ZWNrZWRSYWRpb0J1dHRvbnM6OnJlbW92ZUJ1dHRvbihIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50 KQogewotICAgIGlmIChlbGVtZW50LT5uYW1lKCkuaXNFbXB0eSgpIHx8ICFtX25hbWVUb0NoZWNr ZWRSYWRpb0J1dHRvbk1hcCkKKyAgICBpZiAoIXNob3VsZE1ha2VSYWRpb0dyb3VwKGVsZW1lbnQp KQogICAgICAgICByZXR1cm47Ci0gICAgCi0gICAgbV9uYW1lVG9DaGVja2VkUmFkaW9CdXR0b25N YXAtPmNoZWNrQ29uc2lzdGVuY3koKTsKLQotICAgIE5hbWVUb0lucHV0TWFwOjppdGVyYXRvciBp dCA9IG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwLT5maW5kKGVsZW1lbnQtPm5hbWUoKS5p bXBsKCkpOwotICAgIGlmIChpdCA9PSBtX25hbWVUb0NoZWNrZWRSYWRpb0J1dHRvbk1hcC0+ZW5k KCkgfHwgaXQtPnNlY29uZCAhPSBlbGVtZW50KQorICAgIGlmICghbV9uYW1lVG9Hcm91cE1hcCkK ICAgICAgICAgcmV0dXJuOwogICAgIAotICAgIEFTU0VSVChlbGVtZW50LT5zaG91bGRBcHBlYXJD aGVja2VkKCkpOwotICAgIEFTU0VSVChlbGVtZW50LT5pc1JhZGlvQnV0dG9uKCkpOworICAgIG1f bmFtZVRvR3JvdXBNYXAtPmNoZWNrQ29uc2lzdGVuY3koKTsKIAotICAgIG1fbmFtZVRvQ2hlY2tl ZFJhZGlvQnV0dG9uTWFwLT5yZW1vdmUoaXQpOwotICAgIGlmIChtX25hbWVUb0NoZWNrZWRSYWRp b0J1dHRvbk1hcC0+aXNFbXB0eSgpKQotICAgICAgICBtX25hbWVUb0NoZWNrZWRSYWRpb0J1dHRv bk1hcC5jbGVhcigpOworICAgIE5hbWVUb0dyb3VwTWFwOjppdGVyYXRvciBpdCA9IG1fbmFtZVRv R3JvdXBNYXAtPmZpbmQoZWxlbWVudC0+bmFtZSgpLmltcGwoKSk7CisgICAgaWYgKGl0ID09IG1f bmFtZVRvR3JvdXBNYXAtPmVuZCgpKQorICAgICAgICByZXR1cm47CisgICAgaXQtPnNlY29uZC0+ cmVtb3ZlKGVsZW1lbnQpOworICAgIGlmIChpdC0+c2Vjb25kLT5pc0VtcHR5KCkpIHsKKyAgICAg ICAgbV9uYW1lVG9Hcm91cE1hcC0+cmVtb3ZlKGl0KTsKKyAgICAgICAgaWYgKG1fbmFtZVRvR3Jv dXBNYXAtPmlzRW1wdHkoKSkKKyAgICAgICAgICAgIG1fbmFtZVRvR3JvdXBNYXAuY2xlYXIoKTsK KyAgICB9CiB9CiAKIH0gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9k b20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5oIGIvU291cmNlL1dlYkNvcmUvZG9tL0NoZWNrZWRSYWRp b0J1dHRvbnMuaAppbmRleCA5MjViNTA2NzgyYTQxYzI3ZDE1NDdlZjAxOTlhZDk1ZjViZGEzMjI3 Li5lM2YxZGUyYWFlMzBjZDBlZmNlNjJiMTcxZWE2ZjhhOWY0ZDU4Zjc5IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9kb20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL2RvbS9DaGVja2VkUmFkaW9CdXR0b25zLmgKQEAgLTI4LDE2ICsyOCwyMiBAQAogbmFtZXNw YWNlIFdlYkNvcmUgewogCiBjbGFzcyBIVE1MSW5wdXRFbGVtZW50OworY2xhc3MgUmFkaW9CdXR0 b25Hcm91cDsKIAorLy8gRklYTUU6IFJlbmFtZSB0aGUgY2xhc3MuCiBjbGFzcyBDaGVja2VkUmFk aW9CdXR0b25zIHsKIHB1YmxpYzoKKyAgICBDaGVja2VkUmFkaW9CdXR0b25zKCk7CisgICAgfkNo ZWNrZWRSYWRpb0J1dHRvbnMoKTsKICAgICB2b2lkIGFkZEJ1dHRvbihIVE1MSW5wdXRFbGVtZW50 Kik7CisgICAgdm9pZCB1cGRhdGVDaGVja2VkU3RhdGUoSFRNTElucHV0RWxlbWVudCopOworICAg IHZvaWQgcmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKEhUTUxJbnB1dEVsZW1lbnQqKTsKICAgICB2 b2lkIHJlbW92ZUJ1dHRvbihIVE1MSW5wdXRFbGVtZW50Kik7CiAgICAgSFRNTElucHV0RWxlbWVu dCogY2hlY2tlZEJ1dHRvbkZvckdyb3VwKGNvbnN0IEF0b21pY1N0cmluZyYgZ3JvdXBOYW1lKSBj b25zdDsKIAogcHJpdmF0ZToKLSAgICB0eXBlZGVmIEhhc2hNYXA8QXRvbWljU3RyaW5nSW1wbCos IEhUTUxJbnB1dEVsZW1lbnQqPiBOYW1lVG9JbnB1dE1hcDsKLSAgICBPd25QdHI8TmFtZVRvSW5w dXRNYXA+IG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwOworICAgIHR5cGVkZWYgSGFzaE1h cDxBdG9taWNTdHJpbmdJbXBsKiwgT3duUHRyPFJhZGlvQnV0dG9uR3JvdXA+ID4gTmFtZVRvR3Jv dXBNYXA7CisgICAgT3duUHRyPE5hbWVUb0dyb3VwTWFwPiBtX25hbWVUb0dyb3VwTWFwOwogfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZv cm1Db250cm9sRWxlbWVudC5jcHAKaW5kZXggYjEzYjI1Njc2MzE5N2Q3Mjc2OTg2MDM1YWI3MGRm NDQyMmExZDAzYS4uNzE4NDliY2Q3NzBmM2Y3MzcyZDA2MTcyY2VmOTYwYmIzNGQwMDViMiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCkBAIC0x MjIsMTUgKzEyMiwyMCBAQCB2b2lkIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OnBhcnNlTWFwcGVk QXR0cmlidXRlKEF0dHJpYnV0ZSogYXR0cikKICAgICB9IGVsc2UgaWYgKGF0dHItPm5hbWUoKSA9 PSByZXF1aXJlZEF0dHIpIHsKICAgICAgICAgYm9vbCBvbGRSZXF1aXJlZCA9IG1fcmVxdWlyZWQ7 CiAgICAgICAgIG1fcmVxdWlyZWQgPSAhYXR0ci0+aXNOdWxsKCk7Ci0gICAgICAgIGlmIChvbGRS ZXF1aXJlZCAhPSBtX3JlcXVpcmVkKSB7Ci0gICAgICAgICAgICBzZXROZWVkc1ZhbGlkaXR5Q2hl Y2soKTsKLSAgICAgICAgICAgIHNldE5lZWRzU3R5bGVSZWNhbGMoKTsgLy8gVXBkYXRlcyBmb3Ig OnJlcXVpcmVkIDpvcHRpb25hbCBjbGFzc2VzLgotICAgICAgICB9CisgICAgICAgIGlmIChvbGRS ZXF1aXJlZCAhPSBtX3JlcXVpcmVkKQorICAgICAgICAgICAgcmVxdWlyZWRBdHRyaWJ1dGVDaGFu Z2VkKCk7CiAgICAgfSBlbHNlCiAgICAgICAgIEhUTUxFbGVtZW50OjpwYXJzZU1hcHBlZEF0dHJp YnV0ZShhdHRyKTsKICAgICBzZXROZWVkc1dpbGxWYWxpZGF0ZUNoZWNrKCk7CiB9CiAKK3ZvaWQg SFRNTEZvcm1Db250cm9sRWxlbWVudDo6cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKCkKK3sKKyAg ICBzZXROZWVkc1ZhbGlkaXR5Q2hlY2soKTsKKyAgICAvLyBVcGRhdGVzIGZvciA6cmVxdWlyZWQg Om9wdGlvbmFsIGNsYXNzZXMuCisgICAgc2V0TmVlZHNTdHlsZVJlY2FsYygpOworfQorCiBzdGF0 aWMgYm9vbCBzaG91bGRBdXRvZm9jdXMoSFRNTEZvcm1Db250cm9sRWxlbWVudCogZWxlbWVudCkK IHsKICAgICBpZiAoIWVsZW1lbnQtPmF1dG9mb2N1cygpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuaAppbmRleCBmNTAwYjZkZjliMjY1ZWQ1OGMxNTczMjkz ZjlmMDVlZjY2NmQwN2JjLi5lZGM0MDZmNTFhMzJhZDE4Yjk5NjI3N2Q4ZThmMTljNDA4MTljNWUw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuaApAQCAt MTE1LDYgKzExNSw3IEBAIHByb3RlY3RlZDoKICAgICBIVE1MRm9ybUNvbnRyb2xFbGVtZW50KGNv bnN0IFF1YWxpZmllZE5hbWUmIHRhZ05hbWUsIERvY3VtZW50KiwgSFRNTEZvcm1FbGVtZW50Kik7 CiAKICAgICB2aXJ0dWFsIHZvaWQgcGFyc2VNYXBwZWRBdHRyaWJ1dGUoQXR0cmlidXRlKik7Cisg ICAgdmlydHVhbCB2b2lkIHJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpOwogICAgIHZpcnR1YWwg dm9pZCBhdHRhY2goKTsKICAgICB2aXJ0dWFsIHZvaWQgaW5zZXJ0ZWRJbnRvVHJlZShib29sIGRl ZXApOwogICAgIHZpcnR1YWwgdm9pZCByZW1vdmVkRnJvbVRyZWUoYm9vbCBkZWVwKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCmluZGV4IDNiYjlhZjA5Mzc1NGU2MmYy MzgxYWEzNGVkNTM4OWMxMTIyYWMyMDUuLjBmNmRkY2YzZWNlNDQ2MDliNGRkNjk3MzY0OTM5ODlj ZjMzNGU1YzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAt MTc1LDM4ICsxNzUsNiBAQCBib29sIEhUTUxJbnB1dEVsZW1lbnQ6OnNob3VsZEF1dG9jb21wbGV0 ZSgpIGNvbnN0CiAgICAgcmV0dXJuIEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50OjpzaG91bGRB dXRvY29tcGxldGUoKTsKIH0KIAotdm9pZCBIVE1MSW5wdXRFbGVtZW50Ojp1cGRhdGVDaGVja2Vk UmFkaW9CdXR0b25zKCkKLXsKLSAgICBjaGVja2VkUmFkaW9CdXR0b25zKCkuYWRkQnV0dG9uKHRo aXMpOwotCi0gICAgaWYgKGZvcm0oKSkgewotICAgICAgICBjb25zdCBWZWN0b3I8Rm9ybUFzc29j aWF0ZWRFbGVtZW50Kj4mIGNvbnRyb2xzID0gZm9ybSgpLT5hc3NvY2lhdGVkRWxlbWVudHMoKTsK LSAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGNvbnRyb2xzLnNpemUoKTsgKytpKSB7 Ci0gICAgICAgICAgICBpZiAoIWNvbnRyb2xzW2ldLT5pc0Zvcm1Db250cm9sRWxlbWVudCgpKQot ICAgICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICAgICAgSFRNTEZvcm1Db250cm9sRWxl bWVudCogY29udHJvbCA9IHN0YXRpY19jYXN0PEhUTUxGb3JtQ29udHJvbEVsZW1lbnQqPihjb250 cm9sc1tpXSk7Ci0gICAgICAgICAgICBpZiAoY29udHJvbC0+bmFtZSgpICE9IG5hbWUoKSkKLSAg ICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIGlmIChjb250cm9sLT50eXBlKCkg IT0gdHlwZSgpKQotICAgICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICAgICAgY29udHJv bC0+c2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7Ci0gICAgICAgIH0KLSAgICB9IGVsc2UgewotICAg ICAgICB0eXBlZGVmIERvY3VtZW50OjpGb3JtRWxlbWVudExpc3RIYXNoU2V0Ojpjb25zdF9pdGVy YXRvciBJdGVyYXRvcjsKLSAgICAgICAgSXRlcmF0b3IgZW5kID0gZG9jdW1lbnQoKS0+Zm9ybUVs ZW1lbnRzKCktPmVuZCgpOwotICAgICAgICBmb3IgKEl0ZXJhdG9yIGl0ID0gZG9jdW1lbnQoKS0+ Zm9ybUVsZW1lbnRzKCktPmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkgewotICAgICAgICAgICAg SFRNTEZvcm1Db250cm9sRWxlbWVudFdpdGhTdGF0ZSogY29udHJvbCA9ICppdDsKLSAgICAgICAg ICAgIGlmIChjb250cm9sLT5mb3JtQ29udHJvbE5hbWUoKSAhPSBuYW1lKCkpCi0gICAgICAgICAg ICAgICAgY29udGludWU7Ci0gICAgICAgICAgICBpZiAoY29udHJvbC0+Zm9ybUNvbnRyb2xUeXBl KCkgIT0gdHlwZSgpKQotICAgICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICAgICAgaWYg KGNvbnRyb2wtPmZvcm0oKSkKLSAgICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAg IGNvbnRyb2wtPnNldE5lZWRzVmFsaWRpdHlDaGVjaygpOwotICAgICAgICB9Ci0gICAgfQotfQot CiBib29sIEhUTUxJbnB1dEVsZW1lbnQ6OmlzVmFsaWRWYWx1ZShjb25zdCBTdHJpbmcmIHZhbHVl KSBjb25zdAogewogICAgIGlmICghbV9pbnB1dFR5cGUtPmNhblNldFN0cmluZ1ZhbHVlKCkpIHsK QEAgLTk2MCwxMyArOTI4LDExIEBAIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c2V0Q2hlY2tlZChi b29sIG5vd0NoZWNrZWQsIGJvb2wgc2VuZENoYW5nZUV2ZW50KQogICAgIGlmIChjaGVja2VkKCkg PT0gbm93Q2hlY2tlZCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgY2hlY2tlZFJhZGlvQnV0dG9u cygpLnJlbW92ZUJ1dHRvbih0aGlzKTsKLQogICAgIG1fcmVmbGVjdHNDaGVja2VkQXR0cmlidXRl ID0gZmFsc2U7CiAgICAgbV9pc0NoZWNrZWQgPSBub3dDaGVja2VkOwogICAgIHNldE5lZWRzU3R5 bGVSZWNhbGMoKTsKICAgICBpZiAoaXNSYWRpb0J1dHRvbigpKQotICAgICAgICB1cGRhdGVDaGVj a2VkUmFkaW9CdXR0b25zKCk7CisgICAgICAgIGNoZWNrZWRSYWRpb0J1dHRvbnMoKS51cGRhdGVD aGVja2VkU3RhdGUodGhpcyk7CiAgICAgaWYgKHJlbmRlcmVyKCkgJiYgcmVuZGVyZXIoKS0+c3R5 bGUoKS0+aGFzQXBwZWFyYW5jZSgpKQogICAgICAgICByZW5kZXJlcigpLT50aGVtZSgpLT5zdGF0 ZUNoYW5nZWQocmVuZGVyZXIoKSwgQ2hlY2tlZFN0YXRlKTsKICAgICBzZXROZWVkc1ZhbGlkaXR5 Q2hlY2soKTsKQEAgLTE1NTQsNiArMTUyMCwxMyBAQCBib29sIEhUTUxJbnB1dEVsZW1lbnQ6OnJl Y2FsY1dpbGxWYWxpZGF0ZSgpIGNvbnN0CiAgICAgcmV0dXJuIG1faW5wdXRUeXBlLT5zdXBwb3J0 c1ZhbGlkYXRpb24oKSAmJiBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6cmVjYWxjV2lsbFZh bGlkYXRlKCk7CiB9CiAKK3ZvaWQgSFRNTElucHV0RWxlbWVudDo6cmVxdWlyZWRBdHRyaWJ1dGVD aGFuZ2VkKCkKK3sKKyAgICBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6cmVxdWlyZWRBdHRy aWJ1dGVDaGFuZ2VkKCk7CisgICAgLy8gRklYTUU6IE1vdmUgdG8gUmFkaW9JbnB1dFR5cGUuCisg ICAgY2hlY2tlZFJhZGlvQnV0dG9ucygpLnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCh0aGlzKTsK K30KKwogI2lmIEVOQUJMRShJTlBVVF9DT0xPUikKIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c2Vs ZWN0Q29sb3JJbkNvbG9yQ2hvb3Nlcihjb25zdCBDb2xvciYgY29sb3IpCiB7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3Jl L2h0bWwvSFRNTElucHV0RWxlbWVudC5oCmluZGV4IGQyMTI0NGQzOWQ3NTJhMzYzYjJjN2E1ZTY5 MmE1ZTkxMjEyZGVlNDguLjdmNzJkZjcyY2RlNjBhNzIzOTQ0ZDRhM2IwNjkzNzZhYTdlNmE3Njgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCkBAIC0zMjIsNiArMzIyLDcg QEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIGJvb2wgaXNPcHRpb25hbEZvcm1Db250cm9sKCkgY29u c3QgeyByZXR1cm4gIWlzUmVxdWlyZWRGb3JtQ29udHJvbCgpOyB9CiAgICAgdmlydHVhbCBib29s IGlzUmVxdWlyZWRGb3JtQ29udHJvbCgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCByZWNhbGNX aWxsVmFsaWRhdGUoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgcmVxdWlyZWRBdHRyaWJ1dGVD aGFuZ2VkKCkgT1ZFUlJJREU7CiAKICAgICB2b2lkIHVwZGF0ZVR5cGUoKTsKICAgICAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuY3BwIGIvU291cmNlL1dl YkNvcmUvaHRtbC9SYWRpb0lucHV0VHlwZS5jcHAKaW5kZXggN2U2OTUxN2EzNTMyOTQ3YWY5MWQ0 YjU0MDYyYThiMTc4YmY4MDdhZi4uNzJmMDVkNDZjMjVhODgxMWJkNmY1NTE1MWFhNDA1YzE0YjNk N2Q4ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlwZS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlwZS5jcHAKQEAgLTEzMywxMiAr MTMzLDYgQEAgYm9vbCBSYWRpb0lucHV0VHlwZTo6aXNLZXlib2FyZEZvY3VzYWJsZSgpIGNvbnN0 CiAgICAgcmV0dXJuIGVsZW1lbnQoKS0+Y2hlY2tlZCgpIHx8ICFlbGVtZW50KCktPmNoZWNrZWRS YWRpb0J1dHRvbnMoKS5jaGVja2VkQnV0dG9uRm9yR3JvdXAoZWxlbWVudCgpLT5uYW1lKCkpOwog fQogCi12b2lkIFJhZGlvSW5wdXRUeXBlOjphdHRhY2goKQotewotICAgIElucHV0VHlwZTo6YXR0 YWNoKCk7Ci0gICAgZWxlbWVudCgpLT51cGRhdGVDaGVja2VkUmFkaW9CdXR0b25zKCk7Ci19Ci0K IGJvb2wgUmFkaW9JbnB1dFR5cGU6OnNob3VsZFNlbmRDaGFuZ2VFdmVudEFmdGVyQ2hlY2tlZENo YW5nZWQoKQogewogICAgIC8vIERvbid0IHNlbmQgYSBjaGFuZ2UgZXZlbnQgZm9yIGEgcmFkaW8g YnV0dG9uIHRoYXQncyBnZXR0aW5nIHVuY2hlY2tlZC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1 dFR5cGUuaAppbmRleCA1MjVlZDY5MWNmNGIwZDIwOTk4NmY2OWYxZDgxM2NiZjJlOGVjMzBlLi45 Y2VmZTUxNmJkNmU1OGU2NzNiOWNkODc4OWIwZWVhMjFjY2E0ZGIwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRt bC9SYWRpb0lucHV0VHlwZS5oCkBAIC00OCw3ICs0OCw2IEBAIHByaXZhdGU6CiAgICAgdmlydHVh bCB2b2lkIGhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50KikgT1ZFUlJJREU7CiAgICAg dmlydHVhbCB2b2lkIGhhbmRsZUtleXVwRXZlbnQoS2V5Ym9hcmRFdmVudCopIE9WRVJSSURFOwog ICAgIHZpcnR1YWwgYm9vbCBpc0tleWJvYXJkRm9jdXNhYmxlKCkgY29uc3QgT1ZFUlJJREU7Ci0g ICAgdmlydHVhbCB2b2lkIGF0dGFjaCgpIE9WRVJSSURFOwogICAgIHZpcnR1YWwgYm9vbCBzaG91 bGRTZW5kQ2hhbmdlRXZlbnRBZnRlckNoZWNrZWRDaGFuZ2VkKCkgT1ZFUlJJREU7CiAgICAgdmly dHVhbCBQYXNzT3duUHRyPENsaWNrSGFuZGxpbmdTdGF0ZT4gd2lsbERpc3BhdGNoQ2xpY2soKSBP VkVSUklERTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkRGlzcGF0Y2hDbGljayhFdmVudCosIGNvbnN0 IENsaWNrSGFuZGxpbmdTdGF0ZSYpIE9WRVJSSURFOwo= 122595 2012-01-15 22:52:29 -0800 2012-01-23 19:57:03 -0800 Patch 3 bug-74909-20120116155227.patch text/plain 36267 tkent U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1MDM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZmQxOTkyMTNlZTUxYzE0 OGFlMjUzZDJkNGUzMzY5Mjk5MDYwZTM2NS4uNzgxNzBlZTAwMGM4NzBiZjA3MzYyN2U2M2IzZWQw NmUxOWE4NzcwOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDkwIEBACisyMDEyLTAxLTE1ICBLZW50 IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KKworICAgICAgICBJbnRyb2R1Y2UgUmFkaW9C dXR0b25Hcm91cCBjbGFzcyB0byBrZWVwIHRyYWNrIG9mIHRoZSBncm91cCBtZW1iZXJzIGFuZCBy ZXF1aXJlZCBzdGF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NzQ5MDkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBSYWRpb0J1dHRvbkdyb3VwIGNvbnRhaW5zIGEgc2V0IG9mIG1lbWJlciByYWRpbyBidXR0 b25zIGluIHRoZSBncm91cCwKKyAgICAgICAgYW5kICJyZXF1aXJlZCIgc3RhdHVzIG9mIHRoZSBn cm91cC4gVGhpcyBoZWxwcyBpbXBsZW1lbnRpbmcgY29ycmVjdAorICAgICAgICByYWRpbyBidXR0 b24gdmFsaWRpdHksIGFuZCBpbXByb3ZpbmcgcGVyZm9ybWFuY2Ugb2YgdXBkYXRpbmcgdmFsaWRp dHkKKyAgICAgICAgc3RhdHVzIG9mIHJhZGlvIGJ1dHRvbnMuCisKKyAgICAgICAgVGhpcyBjaGFu Z2UgZml4ZXMgdGhlIGZvbGxvd2luZyBidWdzOgorICAgICAgICAtIEEgcmFkaW8gYnV0dG9uIHNo b3VsZCBiZSAicmVxdWlyZWQiIGlmIG9uZSBvZiBhIG1lbWJlciBvZiB0aGUgc2FtZQorICAgICAg ICAgIGdyb3VwIGhhcyB0aGUgInJlcXVpcmVkIiBhdHRyaWJ1dGUuCisgICAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc2MzY1CisgICAgICAgIC0gOmludmFs aWQgc3R5bGUgaXMgbm90IGFwcGxpZWQgd2hlbiBhIGNoZWNrZWQgcmFkaW8gYnV0dG9uIGlzIHJl bW92ZWQKKyAgICAgICAgICBmcm9tIGl0cyByYWRpbyBncm91cAorICAgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NDkxNAorICAgICAgICAtIExvYWRpbmcg YSBwYWdlIHdpdGggTiByYWRpbyBidXR0b25zIGluIGEgZ3JvdXAgdGFrZXMgTyhOXjIpIHRpbWUu CisKKyAgICAgICAgVGVzdHM6IGZhc3QvZm9ybXMvcmFkaW8vcmFkaW8tbGl2ZS12YWxpZGF0aW9u LXN0eWxlLmh0bWwKKyAgICAgICAgICAgICAgIHBlcmYvYWRkaW5nLXJhZGlvLWJ1dHRvbnMuaHRt bAorCisgICAgICAgICogZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmFkaW9CdXR0b25Hcm91cDo6aXNFbXB0eSk6CisgICAgICAgIChXZWJDb3JlOjpSYWRp b0J1dHRvbkdyb3VwOjppc1JlcXVpcmVkKToKKyAgICAgICAgKFdlYkNvcmU6OlJhZGlvQnV0dG9u R3JvdXA6OmNoZWNrZWRCdXR0b24pOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9CdXR0b25Hcm91 cDo6UmFkaW9CdXR0b25Hcm91cCk6CisgICAgICAgIChXZWJDb3JlOjpSYWRpb0J1dHRvbkdyb3Vw OjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9CdXR0b25Hcm91cDo6YWRkKToKKyAg ICAgICAgKFdlYkNvcmU6OlJhZGlvQnV0dG9uR3JvdXA6OnVwZGF0ZUNoZWNrZWRTdGF0ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpSYWRpb0J1dHRvbkdyb3VwOjpyZXF1aXJlZEF0dHJpYnV0ZUNoYW5n ZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9CdXR0b25Hcm91cDo6cmVtb3ZlKToKKyAgICAg ICAgKFdlYkNvcmU6OlJhZGlvQnV0dG9uR3JvdXA6OnVwZGF0ZUJ1dHRvbnNWYWxpZGl0eSk6Cisg ICAgICAgIEFkZCBSYWRpb0J1dHRvbkdyb3VwIGNsYXNzLiBJdCBrZWVwcyB0cmFjayBvZiBwb2lu dGVycyB0byBtZW1iZXIgcmFkaW8KKyAgICAgICAgYnV0dG9ucyBhbmQgcmVxdWlyZWQgc3RhdHVz IG9mIHRoZSBncm91cCBpbiBhZGRpdGlvbiB0byB0aGUgY2hlY2tlZAorICAgICAgICByYWRpbyBi dXR0b24gcG9pbnRlci4KKworICAgICAgICAoV2ViQ29yZTo6Q2hlY2tlZFJhZGlvQnV0dG9uczo6 Q2hlY2tlZFJhZGlvQnV0dG9ucyk6CisgICAgICAgIChXZWJDb3JlOjpDaGVja2VkUmFkaW9CdXR0 b25zOjp+Q2hlY2tlZFJhZGlvQnV0dG9ucyk6CisgICAgICAgIERlZmluZSBlbXB0eSBjb25zdHJ1 Y3RvciBhbmQgZGVzdHJ1Y3RvciBpbiBvcmRlciB0byBhdm9pZCBleHBvc2luZworICAgICAgICBS YWRpb0J1dHRvbkdyb3VwIGNsYXNzLgorCisgICAgICAgIChXZWJDb3JlOjpDaGVja2VkUmFkaW9C dXR0b25zOjphZGRCdXR0b24pOgorICAgICAgICAoV2ViQ29yZTo6Q2hlY2tlZFJhZGlvQnV0dG9u czo6dXBkYXRlQ2hlY2tlZFN0YXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkNoZWNrZWRSYWRpb0J1 dHRvbnM6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCk6CisgICAgICAgIChXZWJDb3JlOjpDaGVj a2VkUmFkaW9CdXR0b25zOjpjaGVja2VkQnV0dG9uRm9yR3JvdXApOgorICAgICAgICAoV2ViQ29y ZTo6Q2hlY2tlZFJhZGlvQnV0dG9uczo6aXNJblJlcXVpcmVkR3JvdXApOgorICAgICAgICAoV2Vi Q29yZTo6Q2hlY2tlZFJhZGlvQnV0dG9uczo6cmVtb3ZlQnV0dG9uKToKKyAgICAgICAgQ2hhbmdl IHRoZSBIYXNoTWFwIG1lbWJlciBvZiB0aGlzIGNsYXNzIHNvdCB0aGF0IGl0IG1hcHMgYSBncm91 cCBuYW1lIHRvCisgICAgICAgIGEgUmFkaW9CdXR0b25Hcm91cCBvYmplY3QuIFRoZXNlIGZ1bmN0 aW9ucyBqdXN0IGdldCBhIFJhZGlvQnV0dG9uR3JvdXAKKyAgICAgICAgb2JqZWN0IGFuZCBjYWxs IGEgY29ycmVzcG9uZGluZyBtZW1iZXIgZnVuY3Rpb24gb2YgUmFkaW9CdXR0b25Hcm91cC4KKwor ICAgICAgICAqIGRvbS9DaGVja2VkUmFkaW9CdXR0b25zLmg6IFVwZGF0ZSBkZWNsYXJhdGlvbnMu CisKKyAgICAgICAgKiBodG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6cGFyc2VNYXBwZWRBdHRyaWJ1dGUpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6cmVxdWlyZWRBdHRyaWJ1 dGVDaGFuZ2VkKToKKyAgICAgICAgTW92ZSBhIHBhcnQgb2YgcGFyc2VNYXBwZWRBdHRyaWJ1dGUo KSBpbnRvIHJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpLgorICAgICAgICAqIGh0bWwvSFRNTEZv cm1Db250cm9sRWxlbWVudC5oOiBBZGQgcmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKCkuCisgICAg ICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJ bnB1dEVsZW1lbnQ6OnZhbHVlTWlzc2luZyk6CisgICAgICAgIE1vdmUgcmVxdWlyZWQgY2hlY2sg Y29kZSB0byBJbnB1dFR5cGU6OnZhbHVlTWlzc2luZyBpbXBsZW1lbnRhdGlvbnMuCisgICAgICAg IFJhZGlvSW5wdXRUeXBlIG5lZWRzIHNwZWNpYWwgaGFuZGxpbmcgZm9yIGNoZWNraW5nIHJlcXVp cmVkIHN0YXRlLgorICAgICAgICByZWFkT25seSgpIGFuZCBkaXNhYmxlZCgpIGFyZSB1bm5lY2Vz c2FyeSBiZWNhdXNlIHdpbGxWYWxpZGF0ZSgpIGNoZWNrcyB0aGVtLgorICAgICAgICAoV2ViQ29y ZTo6SFRNTElucHV0RWxlbWVudDo6c2V0Q2hlY2tlZCk6CisgICAgICAgIENhbGwgbmV3IGZ1bmN0 aW9uIENoZWNrZWRSYWRpb0J1dHRvbnM6OnVwZGF0ZUNoZWNrZWRTdGF0ZSgpIGluc3RlYWQgb2YK KyAgICAgICAgcmVtb3ZlQnV0dG9uKCkgYW5kIHVwZGF0ZUNoZWNrZWRSYWRpb0J1dHRvbnMoKS4K KyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnJlcXVpcmVkQXR0cmlidXRlQ2hh bmdlZCk6CisgICAgICAgIE92ZXJyaWRlIHRoaXMgdG8gY2FsbCBDaGVja2VkUmFkaW9CdXR0b25z OjpyZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoKS4KKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVs ZW1lbnQuaDoKKyAgICAgICAgIC0gTWFrZSBpc1JlcXVpcmVkRm9ybUNvbnRyb2woKSBwdWJsaWMg c28gdGhhdCBJbnB1dFR5cGUgY2FuIGNhbGwgaXQuCisgICAgICAgICAtIEFkZCByZXF1aXJlZEF0 dHJpYnV0ZUNoYW5nZWQoKS4KKyAgICAgICAgKiBodG1sL1JhZGlvSW5wdXRUeXBlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlJhZGlvSW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmcpOgorICAgICAgICBD aGVjayByZXF1aXJlZCBzdGF0ZSBieSBDaGVja2VkUmFkaW9CdXR0b25zOjppc0luUmVxdWlyZWRH cm91cCgpLgorICAgICAgICAqIGh0bWwvUmFkaW9JbnB1dFR5cGUuaDogUmVtb3ZlIGF0dGFjaCgp LgorCisgICAgICAgICogaHRtbC9DaGVja2JveElucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpDaGVja2JveElucHV0VHlwZTo6dmFsdWVNaXNzaW5nKToKKyAgICAgICAgICBNb3ZlIHJl cXVpcmVkIGNoZWNrIGZyb20gSFRNTElucHV0RWxlbWVudDo6dmFsdWVNaXNzaW5nKCkuCisgICAg ICAgICogaHRtbC9GaWxlSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZpbGVJbnB1 dFR5cGU6OnZhbHVlTWlzc2luZyk6IGRpdHRvLgorICAgICAgICAqIGh0bWwvVGV4dEZpZWxkSW5w dXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRleHRGaWVsZElucHV0VHlwZTo6dmFsdWVN aXNzaW5nKTogZGl0dG8uCisKIDIwMTItMDEtMTUgIEx1a2UgTWFjcGhlcnNvbiAgIDxtYWNwaGVy c29uQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZW1vdmUgZXh0ZXJuYWwgcmVmZXJlbmNlcyB0 byBDU1NQcmltaXRpdmVWYWx1ZTo6VW5pdFR5cGVzIGVudW0uCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9kb20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20v Q2hlY2tlZFJhZGlvQnV0dG9ucy5jcHAKaW5kZXggOWFiODkxMjBmOWQ3MGMwYjUzYjg2Nzg0MDkx ZTQzMmI5NjU1ZTRhNi4uNjg0NTBkNThmZDk2MGRjZTFhYzAxMjhhYTkxM2E2YTJjZjhkNmE4NyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9DaGVja2VkUmFkaW9CdXR0b25zLmNwcApAQCAtMjIsNjUg KzIyLDIzMCBAQAogI2luY2x1ZGUgIkNoZWNrZWRSYWRpb0J1dHRvbnMuaCIKIAogI2luY2x1ZGUg IkhUTUxJbnB1dEVsZW1lbnQuaCIKKyNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKK2NsYXNzIFJhZGlvQnV0dG9uR3JvdXAgeworcHVibGljOgorICAgIHN0 YXRpYyBQYXNzT3duUHRyPFJhZGlvQnV0dG9uR3JvdXA+IGNyZWF0ZSgpOworICAgIGJvb2wgaXNF bXB0eSgpIGNvbnN0IHsgcmV0dXJuIG1fbWVtYmVycy5pc0VtcHR5KCk7IH0KKyAgICBib29sIGlz UmVxdWlyZWQoKSBjb25zdCB7IHJldHVybiBtX3JlcXVpcmVkQ291bnQ7IH0KKyAgICBIVE1MSW5w dXRFbGVtZW50KiBjaGVja2VkQnV0dG9uKCkgeyByZXR1cm4gbV9jaGVja2VkQnV0dG9uOyB9Cisg ICAgdm9pZCBhZGQoSFRNTElucHV0RWxlbWVudCopOworICAgIHZvaWQgdXBkYXRlQ2hlY2tlZFN0 YXRlKEhUTUxJbnB1dEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVpcmVkQXR0cmlidXRlQ2hhbmdl ZChIVE1MSW5wdXRFbGVtZW50Kik7CisgICAgdm9pZCByZW1vdmUoSFRNTElucHV0RWxlbWVudCop OworCitwcml2YXRlOgorICAgIFJhZGlvQnV0dG9uR3JvdXAoKTsKKyAgICB2b2lkIHVwZGF0ZUJ1 dHRvbnNWYWxpZGl0eSgpOworCisgICAgSGFzaFNldDxIVE1MSW5wdXRFbGVtZW50Kj4gbV9tZW1i ZXJzOworICAgIEhUTUxJbnB1dEVsZW1lbnQqIG1fY2hlY2tlZEJ1dHRvbjsKKyAgICBzaXplX3Qg bV9yZXF1aXJlZENvdW50OworfTsKKworUmFkaW9CdXR0b25Hcm91cDo6UmFkaW9CdXR0b25Hcm91 cCgpCisgICAgOiBtX2NoZWNrZWRCdXR0b24oMCkKKyAgICAsIG1fcmVxdWlyZWRDb3VudCgwKQor eworfQorCitQYXNzT3duUHRyPFJhZGlvQnV0dG9uR3JvdXA+IFJhZGlvQnV0dG9uR3JvdXA6OmNy ZWF0ZSgpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBSYWRpb0J1dHRvbkdyb3VwKTsKK30K Kwordm9pZCBSYWRpb0J1dHRvbkdyb3VwOjphZGQoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkK K3sKKyAgICBpZiAobV9tZW1iZXJzLmNvbnRhaW5zKGVsZW1lbnQpKQorICAgICAgICByZXR1cm47 CisKKyAgICBtX21lbWJlcnMuYWRkKGVsZW1lbnQpOworICAgIGJvb2wgdXBkYXRlVmFsaWRpdHlT dGF0dXNJbkdyb3VwID0gZmFsc2U7CisgICAgaWYgKGVsZW1lbnQtPnJlcXVpcmVkKCkpIHsKKyAg ICAgICAgaWYgKCsrbV9yZXF1aXJlZENvdW50ID09IDEpCisgICAgICAgICAgICB1cGRhdGVWYWxp ZGl0eVN0YXR1c0luR3JvdXAgPSB0cnVlOworICAgIH0KKworICAgIGlmIChlbGVtZW50LT5jaGVj a2VkKCkpIHsKKyAgICAgICAgSFRNTElucHV0RWxlbWVudCogb2xkQ2hlY2tlZEJ1dHRvbiA9IG1f Y2hlY2tlZEJ1dHRvbjsKKyAgICAgICAgQVNTRVJUKG9sZENoZWNrZWRCdXR0b24gIT0gZWxlbWVu dCk7CisgICAgICAgIGlmIChvbGRDaGVja2VkQnV0dG9uICE9IGVsZW1lbnQpIHsKKyAgICAgICAg ICAgIG1fY2hlY2tlZEJ1dHRvbiA9IGVsZW1lbnQ7CisgICAgICAgICAgICBpZiAob2xkQ2hlY2tl ZEJ1dHRvbikKKyAgICAgICAgICAgICAgICBvbGRDaGVja2VkQnV0dG9uLT5zZXRDaGVja2VkKGZh bHNlKTsKKyAgICAgICAgICAgIGVsc2UgaWYgKGlzUmVxdWlyZWQoKSkKKyAgICAgICAgICAgICAg ICB1cGRhdGVWYWxpZGl0eVN0YXR1c0luR3JvdXAgPSB0cnVlOworICAgICAgICB9CisgICAgfQor ICAgIGlmICh1cGRhdGVWYWxpZGl0eVN0YXR1c0luR3JvdXApCisgICAgICAgIHVwZGF0ZUJ1dHRv bnNWYWxpZGl0eSgpOworICAgIGVsc2UgaWYgKGlzUmVxdWlyZWQoKSkKKyAgICAgICAgZWxlbWVu dC0+c2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7Cit9CisKK3ZvaWQgUmFkaW9CdXR0b25Hcm91cDo6 dXBkYXRlQ2hlY2tlZFN0YXRlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpCit7CisgICAgQVNT RVJUKG1fbWVtYmVycy5jb250YWlucyhlbGVtZW50KSk7CisgICAgaWYgKGVsZW1lbnQtPmNoZWNr ZWQoKSkgeworICAgICAgICBIVE1MSW5wdXRFbGVtZW50KiBvbGRDaGVja2VkQnV0dG9uID0gbV9j aGVja2VkQnV0dG9uOworICAgICAgICBtX2NoZWNrZWRCdXR0b24gPSBlbGVtZW50OworICAgICAg ICBpZiAob2xkQ2hlY2tlZEJ1dHRvbikKKyAgICAgICAgICAgIG9sZENoZWNrZWRCdXR0b24tPnNl dENoZWNrZWQoZmFsc2UpOworICAgICAgICBlbHNlIGlmIChpc1JlcXVpcmVkKCkpCisgICAgICAg ICAgICB1cGRhdGVCdXR0b25zVmFsaWRpdHkoKTsKKyAgICB9IGVsc2UgeworICAgICAgICBpZiAo bV9jaGVja2VkQnV0dG9uID09IGVsZW1lbnQpIHsKKyAgICAgICAgICAgIG1fY2hlY2tlZEJ1dHRv biA9IDA7CisgICAgICAgICAgICBpZiAoaXNSZXF1aXJlZCgpKQorICAgICAgICAgICAgICAgIHVw ZGF0ZUJ1dHRvbnNWYWxpZGl0eSgpOworICAgICAgICB9CisgICAgfQorfQorCit2b2lkIFJhZGlv QnV0dG9uR3JvdXA6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZChIVE1MSW5wdXRFbGVtZW50KiBl bGVtZW50KQoreworICAgIEFTU0VSVChtX21lbWJlcnMuY29udGFpbnMoZWxlbWVudCkpOworICAg IGlmIChlbGVtZW50LT5yZXF1aXJlZCgpKSB7CisgICAgICAgIGlmICgrK21fcmVxdWlyZWRDb3Vu dCA9PSAxKQorICAgICAgICAgICAgdXBkYXRlQnV0dG9uc1ZhbGlkaXR5KCk7CisgICAgfSBlbHNl IHsKKyAgICAgICAgQVNTRVJUKG1fcmVxdWlyZWRDb3VudCk7CisgICAgICAgIGlmICghLS1tX3Jl cXVpcmVkQ291bnQpCisgICAgICAgICAgICB1cGRhdGVCdXR0b25zVmFsaWRpdHkoKTsKKyAgICB9 Cit9CisKK3ZvaWQgUmFkaW9CdXR0b25Hcm91cDo6cmVtb3ZlKEhUTUxJbnB1dEVsZW1lbnQqIGVs ZW1lbnQpCit7CisgICAgSGFzaFNldDxIVE1MSW5wdXRFbGVtZW50Kj46Oml0ZXJhdG9yIGl0ID0g bV9tZW1iZXJzLmZpbmQoZWxlbWVudCk7CisgICAgaWYgKGl0ID09IG1fbWVtYmVycy5lbmQoKSkK KyAgICAgICAgcmV0dXJuOworICAgIG1fbWVtYmVycy5yZW1vdmUoaXQpOworICAgIGlmIChlbGVt ZW50LT5yZXF1aXJlZCgpKSB7CisgICAgICAgIEFTU0VSVChtX3JlcXVpcmVkQ291bnQpOworICAg ICAgICBpZiAoIS0tbV9yZXF1aXJlZENvdW50KQorICAgICAgICAgICAgdXBkYXRlQnV0dG9uc1Zh bGlkaXR5KCk7CisgICAgfQorICAgIGlmIChlbGVtZW50LT5jaGVja2VkKCkpIHsKKyAgICAgICAg bV9jaGVja2VkQnV0dG9uID0gMDsKKyAgICAgICAgaWYgKGlzUmVxdWlyZWQoKSkKKyAgICAgICAg ICAgIHVwZGF0ZUJ1dHRvbnNWYWxpZGl0eSgpOworICAgIH0KKyAgICBpZiAobV9tZW1iZXJzLmlz RW1wdHkoKSkgeworICAgICAgICBBU1NFUlQoIW1fcmVxdWlyZWRDb3VudCk7CisgICAgICAgIEFT U0VSVCghbV9jaGVja2VkQnV0dG9uKTsKKyAgICB9Cit9CisKK3ZvaWQgUmFkaW9CdXR0b25Hcm91 cDo6dXBkYXRlQnV0dG9uc1ZhbGlkaXR5KCkKK3sKKyAgICB0eXBlZGVmIEhhc2hTZXQ8SFRNTElu cHV0RWxlbWVudCo+Ojpjb25zdF9pdGVyYXRvciBJdGVyYXRvcjsKKyAgICBJdGVyYXRvciBlbmQg PSBtX21lbWJlcnMuZW5kKCk7CisgICAgZm9yIChJdGVyYXRvciBpdCA9IG1fbWVtYmVycy5iZWdp bigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgSFRNTElucHV0RWxlbWVudCogY29udHJv bCA9ICppdDsKKyAgICAgICAgQVNTRVJUKGNvbnRyb2wtPmlzUmFkaW9CdXR0b24oKSk7CisgICAg ICAgIGNvbnRyb2wtPnNldE5lZWRzVmFsaWRpdHlDaGVjaygpOworICAgIH0KK30KKworLy8gLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQorCiBzdGF0aWMgaW5saW5lIGJvb2wgc2hvdWxkTWFrZVJhZGlvR3JvdXAoSFRNTElucHV0 RWxlbWVudCogZWxlbWVudCkKIHsKICAgICByZXR1cm4gZWxlbWVudC0+aXNSYWRpb0J1dHRvbigp ICYmICFlbGVtZW50LT5uYW1lKCkuaXNFbXB0eSgpICYmIGVsZW1lbnQtPmluRG9jdW1lbnQoKTsK IH0KIAorLy8gRXhwbGljaXR5IGRlZmluZSBlbXB0eSBjb25zdHJ1Y3RvciBhbmQgZGVzdHJ1Y3Rv ciBpbiBvcmRlciB0byBwcmV2ZW50IHRoZQorLy8gY29tcGlsZXIgZnJvbSBnZW5lcmF0aW5nIHRo ZW0gYXMgaW5saW5lcyBhbmQgcmVxdWlyaW5nIFJhZGlvQnV0dG9uR3JvdXAuCitDaGVja2VkUmFk aW9CdXR0b25zOjpDaGVja2VkUmFkaW9CdXR0b25zKCkKK3sKK30KKworQ2hlY2tlZFJhZGlvQnV0 dG9uczo6fkNoZWNrZWRSYWRpb0J1dHRvbnMoKQoreworfQorCiB2b2lkIENoZWNrZWRSYWRpb0J1 dHRvbnM6OmFkZEJ1dHRvbihIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KQogewogICAgIGlmICgh c2hvdWxkTWFrZVJhZGlvR3JvdXAoZWxlbWVudCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIC8v IFdlIG9ubHkgdHJhY2sgY2hlY2tlZCBidXR0b25zLgotICAgIGlmICghZWxlbWVudC0+Y2hlY2tl ZCgpKQorICAgIGlmICghbV9uYW1lVG9Hcm91cE1hcCkKKyAgICAgICAgbV9uYW1lVG9Hcm91cE1h cCA9IGFkb3B0UHRyKG5ldyBOYW1lVG9Hcm91cE1hcCk7CisKKyAgICBOYW1lVG9Hcm91cE1hcDo6 aXRlcmF0b3IgaXQgPSBtX25hbWVUb0dyb3VwTWFwLT5hZGQoZWxlbWVudC0+bmFtZSgpLmltcGwo KSwgUGFzc093blB0cjxSYWRpb0J1dHRvbkdyb3VwPigpKS5maXJzdDsKKyAgICBpZiAoIWl0LT5z ZWNvbmQpCisgICAgICAgIGl0LT5zZWNvbmQgPSBSYWRpb0J1dHRvbkdyb3VwOjpjcmVhdGUoKTsK KyAgICBpdC0+c2Vjb25kLT5hZGQoZWxlbWVudCk7Cit9CisKK3ZvaWQgQ2hlY2tlZFJhZGlvQnV0 dG9uczo6dXBkYXRlQ2hlY2tlZFN0YXRlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpCit7Cisg ICAgaWYgKCFzaG91bGRNYWtlUmFkaW9Hcm91cChlbGVtZW50KSkKKyAgICAgICAgcmV0dXJuOwor ICAgIEFTU0VSVChtX25hbWVUb0dyb3VwTWFwKTsKKyAgICBpZiAoIW1fbmFtZVRvR3JvdXBNYXAp CiAgICAgICAgIHJldHVybjsKIAotICAgIGlmICghbV9uYW1lVG9DaGVja2VkUmFkaW9CdXR0b25N YXApCi0gICAgICAgIG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwID0gYWRvcHRQdHIobmV3 IE5hbWVUb0lucHV0TWFwKTsKKyAgICBSYWRpb0J1dHRvbkdyb3VwKiBncm91cCA9IG1fbmFtZVRv R3JvdXBNYXAtPmdldChlbGVtZW50LT5uYW1lKCkuaW1wbCgpKTsKKyAgICBBU1NFUlQoZ3JvdXAp OworICAgIGdyb3VwLT51cGRhdGVDaGVja2VkU3RhdGUoZWxlbWVudCk7Cit9CiAKLSAgICBwYWly PE5hbWVUb0lucHV0TWFwOjppdGVyYXRvciwgYm9vbD4gcmVzdWx0ID0gbV9uYW1lVG9DaGVja2Vk UmFkaW9CdXR0b25NYXAtPmFkZChlbGVtZW50LT5uYW1lKCkuaW1wbCgpLCBlbGVtZW50KTsKLSAg ICBpZiAocmVzdWx0LnNlY29uZCkKK3ZvaWQgQ2hlY2tlZFJhZGlvQnV0dG9uczo6cmVxdWlyZWRB dHRyaWJ1dGVDaGFuZ2VkKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpCit7CisgICAgaWYgKCFz aG91bGRNYWtlUmFkaW9Hcm91cChlbGVtZW50KSkKICAgICAgICAgcmV0dXJuOwotICAgIAotICAg IEhUTUxJbnB1dEVsZW1lbnQqIG9sZENoZWNrZWRCdXR0b24gPSByZXN1bHQuZmlyc3QtPnNlY29u ZDsKLSAgICBpZiAob2xkQ2hlY2tlZEJ1dHRvbiA9PSBlbGVtZW50KQorICAgIEFTU0VSVChtX25h bWVUb0dyb3VwTWFwKTsKKyAgICBpZiAoIW1fbmFtZVRvR3JvdXBNYXApCiAgICAgICAgIHJldHVy bjsKIAotICAgIHJlc3VsdC5maXJzdC0+c2Vjb25kID0gZWxlbWVudDsKLSAgICBvbGRDaGVja2Vk QnV0dG9uLT5zZXRDaGVja2VkKGZhbHNlKTsKKyAgICBSYWRpb0J1dHRvbkdyb3VwKiBncm91cCA9 IG1fbmFtZVRvR3JvdXBNYXAtPmdldChlbGVtZW50LT5uYW1lKCkuaW1wbCgpKTsKKyAgICBBU1NF UlQoZ3JvdXApOworICAgIGdyb3VwLT5yZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoZWxlbWVudCk7 CiB9CiAKIEhUTUxJbnB1dEVsZW1lbnQqIENoZWNrZWRSYWRpb0J1dHRvbnM6OmNoZWNrZWRCdXR0 b25Gb3JHcm91cChjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUpIGNvbnN0CiB7Ci0gICAgaWYgKCFt X25hbWVUb0NoZWNrZWRSYWRpb0J1dHRvbk1hcCkKKyAgICBpZiAoIW1fbmFtZVRvR3JvdXBNYXAp CiAgICAgICAgIHJldHVybiAwOwogCi0gICAgbV9uYW1lVG9DaGVja2VkUmFkaW9CdXR0b25NYXAt PmNoZWNrQ29uc2lzdGVuY3koKTsKLSAgICAKLSAgICByZXR1cm4gbV9uYW1lVG9DaGVja2VkUmFk aW9CdXR0b25NYXAtPmdldChuYW1lLmltcGwoKSk7CisgICAgbV9uYW1lVG9Hcm91cE1hcC0+Y2hl Y2tDb25zaXN0ZW5jeSgpOworICAgIFJhZGlvQnV0dG9uR3JvdXAqIGdyb3VwID0gbV9uYW1lVG9H cm91cE1hcC0+Z2V0KG5hbWUuaW1wbCgpKTsKKyAgICByZXR1cm4gZ3JvdXAgPyBncm91cC0+Y2hl Y2tlZEJ1dHRvbigpIDogMDsKK30KKworYm9vbCBDaGVja2VkUmFkaW9CdXR0b25zOjppc0luUmVx dWlyZWRHcm91cChIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KSBjb25zdAoreworICAgIGlmICgh c2hvdWxkTWFrZVJhZGlvR3JvdXAoZWxlbWVudCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAg ICBpZiAoIW1fbmFtZVRvR3JvdXBNYXApCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIFJh ZGlvQnV0dG9uR3JvdXAqIGdyb3VwID0gbV9uYW1lVG9Hcm91cE1hcC0+Z2V0KGVsZW1lbnQtPm5h bWUoKS5pbXBsKCkpOworICAgIHJldHVybiBncm91cCAmJiBncm91cC0+aXNSZXF1aXJlZCgpOwog fQogCiB2b2lkIENoZWNrZWRSYWRpb0J1dHRvbnM6OnJlbW92ZUJ1dHRvbihIVE1MSW5wdXRFbGVt ZW50KiBlbGVtZW50KQogewotICAgIGlmIChlbGVtZW50LT5uYW1lKCkuaXNFbXB0eSgpIHx8ICFt X25hbWVUb0NoZWNrZWRSYWRpb0J1dHRvbk1hcCkKKyAgICBpZiAoIXNob3VsZE1ha2VSYWRpb0dy b3VwKGVsZW1lbnQpKQogICAgICAgICByZXR1cm47Ci0gICAgCi0gICAgbV9uYW1lVG9DaGVja2Vk UmFkaW9CdXR0b25NYXAtPmNoZWNrQ29uc2lzdGVuY3koKTsKLQotICAgIE5hbWVUb0lucHV0TWFw OjppdGVyYXRvciBpdCA9IG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwLT5maW5kKGVsZW1l bnQtPm5hbWUoKS5pbXBsKCkpOwotICAgIGlmIChpdCA9PSBtX25hbWVUb0NoZWNrZWRSYWRpb0J1 dHRvbk1hcC0+ZW5kKCkgfHwgaXQtPnNlY29uZCAhPSBlbGVtZW50KQorICAgIGlmICghbV9uYW1l VG9Hcm91cE1hcCkKICAgICAgICAgcmV0dXJuOwogICAgIAotICAgIEFTU0VSVChlbGVtZW50LT5z aG91bGRBcHBlYXJDaGVja2VkKCkpOwotICAgIEFTU0VSVChlbGVtZW50LT5pc1JhZGlvQnV0dG9u KCkpOwotCi0gICAgbV9uYW1lVG9DaGVja2VkUmFkaW9CdXR0b25NYXAtPnJlbW92ZShpdCk7Ci0g ICAgaWYgKG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwLT5pc0VtcHR5KCkpCi0gICAgICAg IG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwLmNsZWFyKCk7CisgICAgbV9uYW1lVG9Hcm91 cE1hcC0+Y2hlY2tDb25zaXN0ZW5jeSgpOworICAgIE5hbWVUb0dyb3VwTWFwOjppdGVyYXRvciBp dCA9IG1fbmFtZVRvR3JvdXBNYXAtPmZpbmQoZWxlbWVudC0+bmFtZSgpLmltcGwoKSk7CisgICAg aWYgKGl0ID09IG1fbmFtZVRvR3JvdXBNYXAtPmVuZCgpKQorICAgICAgICByZXR1cm47CisgICAg aXQtPnNlY29uZC0+cmVtb3ZlKGVsZW1lbnQpOworICAgIGlmIChpdC0+c2Vjb25kLT5pc0VtcHR5 KCkpIHsKKyAgICAgICAgbV9uYW1lVG9Hcm91cE1hcC0+cmVtb3ZlKGl0KTsKKyAgICAgICAgaWYg KG1fbmFtZVRvR3JvdXBNYXAtPmlzRW1wdHkoKSkKKyAgICAgICAgICAgIG1fbmFtZVRvR3JvdXBN YXAuY2xlYXIoKTsKKyAgICB9CiB9CiAKIH0gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5oIGIvU291cmNlL1dlYkNvcmUvZG9t L0NoZWNrZWRSYWRpb0J1dHRvbnMuaAppbmRleCA5MjViNTA2NzgyYTQxYzI3ZDE1NDdlZjAxOTlh ZDk1ZjViZGEzMjI3Li5lOGIzZmY3NzE2NWE5MmI0M2VhZDBmZmI3NTAzN2Q5Mjk2ZDZkMTdkIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL2RvbS9DaGVja2VkUmFkaW9CdXR0b25zLmgKQEAgLTI4LDE2ICsyOCwy MyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBIVE1MSW5wdXRFbGVtZW50OworY2xh c3MgUmFkaW9CdXR0b25Hcm91cDsKIAorLy8gRklYTUU6IFJlbmFtZSB0aGUgY2xhc3MuCiBjbGFz cyBDaGVja2VkUmFkaW9CdXR0b25zIHsKIHB1YmxpYzoKKyAgICBDaGVja2VkUmFkaW9CdXR0b25z KCk7CisgICAgfkNoZWNrZWRSYWRpb0J1dHRvbnMoKTsKICAgICB2b2lkIGFkZEJ1dHRvbihIVE1M SW5wdXRFbGVtZW50Kik7CisgICAgdm9pZCB1cGRhdGVDaGVja2VkU3RhdGUoSFRNTElucHV0RWxl bWVudCopOworICAgIHZvaWQgcmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKEhUTUxJbnB1dEVsZW1l bnQqKTsKICAgICB2b2lkIHJlbW92ZUJ1dHRvbihIVE1MSW5wdXRFbGVtZW50Kik7CiAgICAgSFRN TElucHV0RWxlbWVudCogY2hlY2tlZEJ1dHRvbkZvckdyb3VwKGNvbnN0IEF0b21pY1N0cmluZyYg Z3JvdXBOYW1lKSBjb25zdDsKKyAgICBib29sIGlzSW5SZXF1aXJlZEdyb3VwKEhUTUxJbnB1dEVs ZW1lbnQqKSBjb25zdDsKIAogcHJpdmF0ZToKLSAgICB0eXBlZGVmIEhhc2hNYXA8QXRvbWljU3Ry aW5nSW1wbCosIEhUTUxJbnB1dEVsZW1lbnQqPiBOYW1lVG9JbnB1dE1hcDsKLSAgICBPd25QdHI8 TmFtZVRvSW5wdXRNYXA+IG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwOworICAgIHR5cGVk ZWYgSGFzaE1hcDxBdG9taWNTdHJpbmdJbXBsKiwgT3duUHRyPFJhZGlvQnV0dG9uR3JvdXA+ID4g TmFtZVRvR3JvdXBNYXA7CisgICAgT3duUHRyPE5hbWVUb0dyb3VwTWFwPiBtX25hbWVUb0dyb3Vw TWFwOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaHRtbC9DaGVja2JveElucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0No ZWNrYm94SW5wdXRUeXBlLmNwcAppbmRleCBkZGExNzJhZWM3ODNmZDFlOGMwZDc1OGY5Y2U1Yjdi ZmQwOWY0ZmZiLi5kNzg5YzMyZDkyNDllZjExODk1MGIyYzYzODA3YTdjODAwNmQ0OWFmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0NoZWNrYm94SW5wdXRUeXBlLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9odG1sL0NoZWNrYm94SW5wdXRUeXBlLmNwcApAQCAtNTEsNyArNTEsNyBA QCBjb25zdCBBdG9taWNTdHJpbmcmIENoZWNrYm94SW5wdXRUeXBlOjpmb3JtQ29udHJvbFR5cGUo KSBjb25zdAogCiBib29sIENoZWNrYm94SW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmcoY29uc3QgU3Ry aW5nJikgY29uc3QKIHsKLSAgICByZXR1cm4gIWVsZW1lbnQoKS0+Y2hlY2tlZCgpOworICAgIHJl dHVybiBlbGVtZW50KCktPmlzUmVxdWlyZWRGb3JtQ29udHJvbCgpICYmICFlbGVtZW50KCktPmNo ZWNrZWQoKTsKIH0KIAogU3RyaW5nIENoZWNrYm94SW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmdUZXh0 KCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvRmlsZUlucHV0VHlwZS5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0ZpbGVJbnB1dFR5cGUuY3BwCmluZGV4IDY1NWU4MWVh ZGJjNzMxMTljNTAwYjZkNTU5NzA5MmIwODU0ZjJlMDcuLjkzOWM5Y2ViN2MxODYxMTI2YTNhNmIy ZGExMjc4ZjEzNDE0NmVkYTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvRmlsZUlu cHV0VHlwZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmNwcApA QCAtMTI5LDcgKzEyOSw3IEBAIGJvb2wgRmlsZUlucHV0VHlwZTo6YXBwZW5kRm9ybURhdGEoRm9y bURhdGFMaXN0JiBlbmNvZGluZywgYm9vbCBtdWx0aXBhcnQpIGNvbnN0CiAKIGJvb2wgRmlsZUlu cHV0VHlwZTo6dmFsdWVNaXNzaW5nKGNvbnN0IFN0cmluZyYgdmFsdWUpIGNvbnN0CiB7Ci0gICAg cmV0dXJuIHZhbHVlLmlzRW1wdHkoKTsKKyAgICByZXR1cm4gZWxlbWVudCgpLT5pc1JlcXVpcmVk Rm9ybUNvbnRyb2woKSAmJiB2YWx1ZS5pc0VtcHR5KCk7CiB9CiAKIFN0cmluZyBGaWxlSW5wdXRU eXBlOjp2YWx1ZU1pc3NpbmdUZXh0KCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCmluZGV4IDZlMmVkNmNmYzg2MDE1MWNmM2I0YzFhM2Yw MWFiZWE1ZTMyYjM0MWIuLmE2MTE5MjJhYTc5MmU2M2VmNjVmZmZmYzg4OTJiMGMwNmIyODFhZjcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcApA QCAtMTIyLDE1ICsxMjIsMjAgQEAgdm9pZCBIVE1MRm9ybUNvbnRyb2xFbGVtZW50OjpwYXJzZU1h cHBlZEF0dHJpYnV0ZShBdHRyaWJ1dGUqIGF0dHIpCiAgICAgfSBlbHNlIGlmIChhdHRyLT5uYW1l KCkgPT0gcmVxdWlyZWRBdHRyKSB7CiAgICAgICAgIGJvb2wgb2xkUmVxdWlyZWQgPSBtX3JlcXVp cmVkOwogICAgICAgICBtX3JlcXVpcmVkID0gIWF0dHItPmlzTnVsbCgpOwotICAgICAgICBpZiAo b2xkUmVxdWlyZWQgIT0gbV9yZXF1aXJlZCkgewotICAgICAgICAgICAgc2V0TmVlZHNWYWxpZGl0 eUNoZWNrKCk7Ci0gICAgICAgICAgICBzZXROZWVkc1N0eWxlUmVjYWxjKCk7IC8vIFVwZGF0ZXMg Zm9yIDpyZXF1aXJlZCA6b3B0aW9uYWwgY2xhc3Nlcy4KLSAgICAgICAgfQorICAgICAgICBpZiAo b2xkUmVxdWlyZWQgIT0gbV9yZXF1aXJlZCkKKyAgICAgICAgICAgIHJlcXVpcmVkQXR0cmlidXRl Q2hhbmdlZCgpOwogICAgIH0gZWxzZQogICAgICAgICBIVE1MRWxlbWVudDo6cGFyc2VNYXBwZWRB dHRyaWJ1dGUoYXR0cik7CiAgICAgc2V0TmVlZHNXaWxsVmFsaWRhdGVDaGVjaygpOwogfQogCit2 b2lkIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpCit7 CisgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7CisgICAgLy8gVXBkYXRlcyBmb3IgOnJlcXVp cmVkIDpvcHRpb25hbCBjbGFzc2VzLgorICAgIHNldE5lZWRzU3R5bGVSZWNhbGMoKTsKK30KKwog c3RhdGljIGJvb2wgc2hvdWxkQXV0b2ZvY3VzKEhUTUxGb3JtQ29udHJvbEVsZW1lbnQqIGVsZW1l bnQpCiB7CiAgICAgaWYgKCFlbGVtZW50LT5hdXRvZm9jdXMoKSkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKaW5kZXggZjUwMGI2ZGY5YjI2NWVkNThjMTU3 MzI5M2Y5ZjA1ZWY2NjZkMDdiYy4uZWRjNDA2ZjUxYTMyYWQxOGI5OTYyNzdkOGU4ZjE5YzQwODE5 YzVlMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVt ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgK QEAgLTExNSw2ICsxMTUsNyBAQCBwcm90ZWN0ZWQ6CiAgICAgSFRNTEZvcm1Db250cm9sRWxlbWVu dChjb25zdCBRdWFsaWZpZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCosIEhUTUxGb3JtRWxlbWVu dCopOwogCiAgICAgdmlydHVhbCB2b2lkIHBhcnNlTWFwcGVkQXR0cmlidXRlKEF0dHJpYnV0ZSop OworICAgIHZpcnR1YWwgdm9pZCByZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoKTsKICAgICB2aXJ0 dWFsIHZvaWQgYXR0YWNoKCk7CiAgICAgdmlydHVhbCB2b2lkIGluc2VydGVkSW50b1RyZWUoYm9v bCBkZWVwKTsKICAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlZEZyb21UcmVlKGJvb2wgZGVlcCk7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAppbmRleCA3NTAxYmM0MzY5MDgz ZTk4N2EzZWI4ZWViMGIzNTM4M2NmZTk5YjY3Li5lY2RlMGI3Njg4ZDk4YTRmN2QxNTRmNmZkMTk5 MTViMTVkMGUwMTUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVs ZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAK QEAgLTE3OCwzOCArMTc4LDYgQEAgYm9vbCBIVE1MSW5wdXRFbGVtZW50OjpzaG91bGRBdXRvY29t cGxldGUoKSBjb25zdAogICAgIHJldHVybiBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6c2hv dWxkQXV0b2NvbXBsZXRlKCk7CiB9CiAKLXZvaWQgSFRNTElucHV0RWxlbWVudDo6dXBkYXRlQ2hl Y2tlZFJhZGlvQnV0dG9ucygpCi17Ci0gICAgY2hlY2tlZFJhZGlvQnV0dG9ucygpLmFkZEJ1dHRv bih0aGlzKTsKLQotICAgIGlmIChmb3JtKCkpIHsKLSAgICAgICAgY29uc3QgVmVjdG9yPEZvcm1B c3NvY2lhdGVkRWxlbWVudCo+JiBjb250cm9scyA9IGZvcm0oKS0+YXNzb2NpYXRlZEVsZW1lbnRz KCk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBjb250cm9scy5zaXplKCk7ICsr aSkgewotICAgICAgICAgICAgaWYgKCFjb250cm9sc1tpXS0+aXNGb3JtQ29udHJvbEVsZW1lbnQo KSkKLSAgICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIEhUTUxGb3JtQ29udHJv bEVsZW1lbnQqIGNvbnRyb2wgPSBzdGF0aWNfY2FzdDxIVE1MRm9ybUNvbnRyb2xFbGVtZW50Kj4o Y29udHJvbHNbaV0pOwotICAgICAgICAgICAgaWYgKGNvbnRyb2wtPm5hbWUoKSAhPSBuYW1lKCkp Ci0gICAgICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAgICAgICBpZiAoY29udHJvbC0+dHlw ZSgpICE9IHR5cGUoKSkKLSAgICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIGNv bnRyb2wtPnNldE5lZWRzVmFsaWRpdHlDaGVjaygpOwotICAgICAgICB9Ci0gICAgfSBlbHNlIHsK LSAgICAgICAgdHlwZWRlZiBEb2N1bWVudDo6Rm9ybUVsZW1lbnRMaXN0SGFzaFNldDo6Y29uc3Rf aXRlcmF0b3IgSXRlcmF0b3I7Ci0gICAgICAgIEl0ZXJhdG9yIGVuZCA9IGRvY3VtZW50KCktPmZv cm1FbGVtZW50cygpLT5lbmQoKTsKLSAgICAgICAgZm9yIChJdGVyYXRvciBpdCA9IGRvY3VtZW50 KCktPmZvcm1FbGVtZW50cygpLT5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKLSAgICAgICAg ICAgIEhUTUxGb3JtQ29udHJvbEVsZW1lbnRXaXRoU3RhdGUqIGNvbnRyb2wgPSAqaXQ7Ci0gICAg ICAgICAgICBpZiAoY29udHJvbC0+Zm9ybUNvbnRyb2xOYW1lKCkgIT0gbmFtZSgpKQotICAgICAg ICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICAgICAgaWYgKGNvbnRyb2wtPmZvcm1Db250cm9s VHlwZSgpICE9IHR5cGUoKSkKLSAgICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAg IGlmIChjb250cm9sLT5mb3JtKCkpCi0gICAgICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAg ICAgICBjb250cm9sLT5zZXROZWVkc1ZhbGlkaXR5Q2hlY2soKTsKLSAgICAgICAgfQotICAgIH0K LX0KLQogYm9vbCBIVE1MSW5wdXRFbGVtZW50Ojppc1ZhbGlkVmFsdWUoY29uc3QgU3RyaW5nJiB2 YWx1ZSkgY29uc3QKIHsKICAgICBpZiAoIW1faW5wdXRUeXBlLT5jYW5TZXRTdHJpbmdWYWx1ZSgp KSB7CkBAIC0yMzIsOCArMjAwLDYgQEAgYm9vbCBIVE1MSW5wdXRFbGVtZW50Ojp0eXBlTWlzbWF0 Y2goKSBjb25zdAogCiBib29sIEhUTUxJbnB1dEVsZW1lbnQ6OnZhbHVlTWlzc2luZyhjb25zdCBT dHJpbmcmIHZhbHVlKSBjb25zdAogewotICAgIGlmICghaXNSZXF1aXJlZEZvcm1Db250cm9sKCkg fHwgcmVhZE9ubHkoKSB8fCBkaXNhYmxlZCgpKQotICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAg cmV0dXJuIG1faW5wdXRUeXBlLT52YWx1ZU1pc3NpbmcodmFsdWUpOwogfQogCkBAIC05NjMsMTMg KzkyOSwxMSBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnNldENoZWNrZWQoYm9vbCBub3dDaGVj a2VkLCBib29sIHNlbmRDaGFuZ2VFdmVudCkKICAgICBpZiAoY2hlY2tlZCgpID09IG5vd0NoZWNr ZWQpCiAgICAgICAgIHJldHVybjsKIAotICAgIGNoZWNrZWRSYWRpb0J1dHRvbnMoKS5yZW1vdmVC dXR0b24odGhpcyk7Ci0KICAgICBtX3JlZmxlY3RzQ2hlY2tlZEF0dHJpYnV0ZSA9IGZhbHNlOwog ICAgIG1faXNDaGVja2VkID0gbm93Q2hlY2tlZDsKICAgICBzZXROZWVkc1N0eWxlUmVjYWxjKCk7 CiAgICAgaWYgKGlzUmFkaW9CdXR0b24oKSkKLSAgICAgICAgdXBkYXRlQ2hlY2tlZFJhZGlvQnV0 dG9ucygpOworICAgICAgICBjaGVja2VkUmFkaW9CdXR0b25zKCkudXBkYXRlQ2hlY2tlZFN0YXRl KHRoaXMpOwogICAgIGlmIChyZW5kZXJlcigpICYmIHJlbmRlcmVyKCktPnN0eWxlKCktPmhhc0Fw cGVhcmFuY2UoKSkKICAgICAgICAgcmVuZGVyZXIoKS0+dGhlbWUoKS0+c3RhdGVDaGFuZ2VkKHJl bmRlcmVyKCksIENoZWNrZWRTdGF0ZSk7CiAgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7CkBA IC0xNTU5LDYgKzE1MjMsMTIgQEAgYm9vbCBIVE1MSW5wdXRFbGVtZW50OjpyZWNhbGNXaWxsVmFs aWRhdGUoKSBjb25zdAogICAgIHJldHVybiBtX2lucHV0VHlwZS0+c3VwcG9ydHNWYWxpZGF0aW9u KCkgJiYgSFRNTFRleHRGb3JtQ29udHJvbEVsZW1lbnQ6OnJlY2FsY1dpbGxWYWxpZGF0ZSgpOwog fQogCit2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpCit7 CisgICAgSFRNTFRleHRGb3JtQ29udHJvbEVsZW1lbnQ6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdl ZCgpOworICAgIGNoZWNrZWRSYWRpb0J1dHRvbnMoKS5yZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQo dGhpcyk7Cit9CisKICNpZiBFTkFCTEUoSU5QVVRfQ09MT1IpCiB2b2lkIEhUTUxJbnB1dEVsZW1l bnQ6OnNlbGVjdENvbG9ySW5Db2xvckNob29zZXIoY29uc3QgQ29sb3ImIGNvbG9yKQogewpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmggYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAppbmRleCBmYzZmMDY4MjhmOTg3YmM4ZTBk NzU5YzUyOWM5MGJiM2VjNzE5NTViLi4wOTNlN2Y1ZGRkYTNjODEwNGE0Yjc4NzdiMjlmMWI0YmYx N2E2N2U2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaApAQCAtNzIsNiAr NzIsOCBAQCBwdWJsaWM6CiAgICAgU3RyaW5nIHR5cGVNaXNtYXRjaFRleHQoKSBjb25zdDsKICAg ICBTdHJpbmcgdmFsdWVNaXNzaW5nVGV4dCgpIGNvbnN0OwogCisgICAgdmlydHVhbCBib29sIGlz UmVxdWlyZWRGb3JtQ29udHJvbCgpIGNvbnN0IE9WRVJSSURFOworCiAgICAgLy8gSW1wbGVtZW50 YXRpb25zIG9mIEhUTUxJbnB1dEVsZW1lbnQ6OnN0ZXBVcCgpIGFuZCBzdGVwRG93bigpLgogICAg IHZvaWQgc3RlcFVwKGludCwgRXhjZXB0aW9uQ29kZSYpOwogICAgIHZvaWQgc3RlcERvd24oaW50 LCBFeGNlcHRpb25Db2RlJik7CkBAIC0zMTksOCArMzIxLDggQEAgcHJpdmF0ZToKICAgICB2aXJ0 dWFsIHZvaWQgaGFuZGxlQmx1ckV2ZW50KCk7CiAKICAgICB2aXJ0dWFsIGJvb2wgaXNPcHRpb25h bEZvcm1Db250cm9sKCkgY29uc3QgeyByZXR1cm4gIWlzUmVxdWlyZWRGb3JtQ29udHJvbCgpOyB9 Ci0gICAgdmlydHVhbCBib29sIGlzUmVxdWlyZWRGb3JtQ29udHJvbCgpIGNvbnN0OwogICAgIHZp cnR1YWwgYm9vbCByZWNhbGNXaWxsVmFsaWRhdGUoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQg cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKCkgT1ZFUlJJREU7CiAKICAgICB2b2lkIHVwZGF0ZVR5 cGUoKTsKICAgICAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5 cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlwZS5jcHAKaW5kZXggN2U2 OTUxN2EzNTMyOTQ3YWY5MWQ0YjU0MDYyYThiMTc4YmY4MDdhZi4uYmFlYzllODYxYjgxYTIxZjY1 MTc0MmJmM2ViNGJiMTcxNmEzOWU2MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9S YWRpb0lucHV0VHlwZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlw ZS5jcHAKQEAgLTQ4LDcgKzQ4LDcgQEAgY29uc3QgQXRvbWljU3RyaW5nJiBSYWRpb0lucHV0VHlw ZTo6Zm9ybUNvbnRyb2xUeXBlKCkgY29uc3QKIAogYm9vbCBSYWRpb0lucHV0VHlwZTo6dmFsdWVN aXNzaW5nKGNvbnN0IFN0cmluZyYpIGNvbnN0CiB7Ci0gICAgcmV0dXJuICFlbGVtZW50KCktPmNo ZWNrZWRSYWRpb0J1dHRvbnMoKS5jaGVja2VkQnV0dG9uRm9yR3JvdXAoZWxlbWVudCgpLT5uYW1l KCkpOworICAgIHJldHVybiBlbGVtZW50KCktPmNoZWNrZWRSYWRpb0J1dHRvbnMoKS5pc0luUmVx dWlyZWRHcm91cChlbGVtZW50KCkpICYmICFlbGVtZW50KCktPmNoZWNrZWRSYWRpb0J1dHRvbnMo KS5jaGVja2VkQnV0dG9uRm9yR3JvdXAoZWxlbWVudCgpLT5uYW1lKCkpOwogfQogCiBTdHJpbmcg UmFkaW9JbnB1dFR5cGU6OnZhbHVlTWlzc2luZ1RleHQoKSBjb25zdApAQCAtMTMzLDEyICsxMzMs NiBAQCBib29sIFJhZGlvSW5wdXRUeXBlOjppc0tleWJvYXJkRm9jdXNhYmxlKCkgY29uc3QKICAg ICByZXR1cm4gZWxlbWVudCgpLT5jaGVja2VkKCkgfHwgIWVsZW1lbnQoKS0+Y2hlY2tlZFJhZGlv QnV0dG9ucygpLmNoZWNrZWRCdXR0b25Gb3JHcm91cChlbGVtZW50KCktPm5hbWUoKSk7CiB9CiAK LXZvaWQgUmFkaW9JbnB1dFR5cGU6OmF0dGFjaCgpCi17Ci0gICAgSW5wdXRUeXBlOjphdHRhY2go KTsKLSAgICBlbGVtZW50KCktPnVwZGF0ZUNoZWNrZWRSYWRpb0J1dHRvbnMoKTsKLX0KLQogYm9v bCBSYWRpb0lucHV0VHlwZTo6c2hvdWxkU2VuZENoYW5nZUV2ZW50QWZ0ZXJDaGVja2VkQ2hhbmdl ZCgpCiB7CiAgICAgLy8gRG9uJ3Qgc2VuZCBhIGNoYW5nZSBldmVudCBmb3IgYSByYWRpbyBidXR0 b24gdGhhdCdzIGdldHRpbmcgdW5jaGVja2VkLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9SYWRpb0lucHV0VHlwZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlw ZS5oCmluZGV4IDUyNWVkNjkxY2Y0YjBkMjA5OTg2ZjY5ZjFkODEzY2JmMmU4ZWMzMGUuLjljZWZl NTE2YmQ2ZTU4ZTY3M2I5Y2Q4Nzg5YjBlZWEyMWNjYTRkYjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1Jh ZGlvSW5wdXRUeXBlLmgKQEAgLTQ4LDcgKzQ4LDYgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHZv aWQgaGFuZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqKSBPVkVSUklERTsKICAgICB2aXJ0 dWFsIHZvaWQgaGFuZGxlS2V5dXBFdmVudChLZXlib2FyZEV2ZW50KikgT1ZFUlJJREU7CiAgICAg dmlydHVhbCBib29sIGlzS2V5Ym9hcmRGb2N1c2FibGUoKSBjb25zdCBPVkVSUklERTsKLSAgICB2 aXJ0dWFsIHZvaWQgYXR0YWNoKCkgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBib29sIHNob3VsZFNl bmRDaGFuZ2VFdmVudEFmdGVyQ2hlY2tlZENoYW5nZWQoKSBPVkVSUklERTsKICAgICB2aXJ0dWFs IFBhc3NPd25QdHI8Q2xpY2tIYW5kbGluZ1N0YXRlPiB3aWxsRGlzcGF0Y2hDbGljaygpIE9WRVJS SURFOwogICAgIHZpcnR1YWwgdm9pZCBkaWREaXNwYXRjaENsaWNrKEV2ZW50KiwgY29uc3QgQ2xp Y2tIYW5kbGluZ1N0YXRlJikgT1ZFUlJJREU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9o dG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVs ZElucHV0VHlwZS5jcHAKaW5kZXggYzljOTA4MzM1NzI2MzNlOGMxZmQ5NDdhNzU3OGYzMTRiMjM3 MjhlNi4uMzhkNGYxNjA2NzMxOGI0NTMxY2UyZGJmZjc3MzI3OGU5ZDJjMWVjOCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmNwcApAQCAtNjksNyArNjksNyBAQCBi b29sIFRleHRGaWVsZElucHV0VHlwZTo6aXNUZXh0RmllbGQoKSBjb25zdAogCiBib29sIFRleHRG aWVsZElucHV0VHlwZTo6dmFsdWVNaXNzaW5nKGNvbnN0IFN0cmluZyYgdmFsdWUpIGNvbnN0CiB7 Ci0gICAgcmV0dXJuIHZhbHVlLmlzRW1wdHkoKTsKKyAgICByZXR1cm4gZWxlbWVudCgpLT5pc1Jl cXVpcmVkRm9ybUNvbnRyb2woKSAmJiB2YWx1ZS5pc0VtcHR5KCk7CiB9CiAKIGJvb2wgVGV4dEZp ZWxkSW5wdXRUeXBlOjpjYW5TZXRTdWdnZXN0ZWRWYWx1ZSgpCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggM2RlM2VmOTBkMTE4 ZjU1ODNlN2I1ZGJhODk5NTQ1NzA2M2YxNWQ5Zi4uNDI3YzA4ZTNiNTcwY2Y1OTQwZmU5ZDY2MTlh ZDg3MzgwMTA1NjdhNyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xh eW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEyLTAxLTE1ICBLZW50IFRh bXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KKworICAgICAgICBJbnRyb2R1Y2UgUmFkaW9CdXR0 b25Hcm91cCBjbGFzcyB0byBrZWVwIHRyYWNrIG9mIHRoZSBncm91cCBtZW1iZXJzIGFuZCByZXF1 aXJlZCBzdGF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzQ5MDkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICAqIGZhc3QvZm9ybXMvcmFkaW8vcmFkaW8tbGl2ZS12YWxpZGF0aW9uLXN0eWxlLWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9mb3Jtcy9yYWRpby9yYWRpby1saXZlLXZhbGlk YXRpb24tc3R5bGUuaHRtbDogQWRkZWQuCisKKyAgICAgICAgKiBmYXN0L2Zvcm1zL3NjcmlwdC10 ZXN0cy9WYWxpZGl0eVN0YXRlLXZhbHVlTWlzc2luZy1yYWRpby5qczoKKyAgICAgICAgVXBkYXRl IHRoZSBleHBlY3RhdGlvbiBmb3IgdGhlIGJlaGF2aW9yIGNoYW5nZSBvZgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzYzNjUKKyAgICAgICAgKiBmYXN0 L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdmFsdWVNaXNzaW5nLXJhZGlvLWV4cGVjdGVkLnR4dDogZGl0 dG8uCisKKyAgICAgICAgKiBwZXJmL2FkZGluZy1yYWRpby1idXR0b25zLWV4cGVjdGVkLnR4dDog QWRkZWQuCisgICAgICAgICogcGVyZi9hZGRpbmctcmFkaW8tYnV0dG9ucy5odG1sOiBBZGRlZC4K KwogMjAxMS0wOC0zMCAgUm9iZXJ0IEhvZ2FuICA8cm9iZXJ0QHdlYmtpdC5vcmc+CiAKICAgICAg ICAgPGVtYmVkPiB3aWR0aCBhbmQgaGVpZ2h0IHByb3BlcnRpZXMgcHJvcGFnYXRlIHRvIHBhcmVu dCBvYmplY3Qgbm9kZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0 eVN0YXRlLXZhbHVlTWlzc2luZy1yYWRpby1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdmFsdWVNaXNzaW5nLXJhZGlvLWV4cGVjdGVkLnR4dAppbmRl eCBmMDlkZGViN2U2YjYzMTg0MThhNjhjZGQyMWMyYjRkM2UwNDU3NWJiLi4wNjQ1YmQxZmY2Njc1 MWE0NDY4NDU4NmE0MmNjMjc5Y2M5OGQ1OTlhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0 L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdmFsdWVNaXNzaW5nLXJhZGlvLWV4cGVjdGVkLnR4dAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdmFsdWVNaXNzaW5nLXJhZGlv LWV4cGVjdGVkLnR4dApAQCAtNiw4ICs2LDggQEAgT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEg c2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUKIFdp dGhvdXQgZm9ybSBlbGVtZW50CiBObyBjaGVja2VkIGJ1dHRvbjoKIFBBU1MgaW5wdXRzWzBdLnZh bGlkaXR5LnZhbHVlTWlzc2luZyBpcyB0cnVlCi1QQVNTIGlucHV0c1sxXS52YWxpZGl0eS52YWx1 ZU1pc3NpbmcgaXMgZmFsc2UKLVBBU1MgaW5wdXRzWzJdLnZhbGlkaXR5LnZhbHVlTWlzc2luZyBp cyBmYWxzZQorUEFTUyBpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVNaXNzaW5nIGlzIHRydWUKK1BB U1MgaW5wdXRzWzJdLnZhbGlkaXR5LnZhbHVlTWlzc2luZyBpcyB0cnVlCiBUaGUgc2Vjb25kIGJ1 dHRvbiBoYXMgYmVlbiBjaGVja2VkOgogUEFTUyBpbnB1dHNbMF0udmFsaWRpdHkudmFsdWVNaXNz aW5nIGlzIGZhbHNlCiBQQVNTIGlucHV0c1sxXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgZmFs c2UKQEAgLTIzLDggKzIzLDggQEAgUEFTUyBpbnB1dHNbMl0udmFsaWRpdHkudmFsdWVNaXNzaW5n IGlzIGZhbHNlCiBXaXRoIGZvcm0gZWxlbWVudAogTm8gY2hlY2tlZCBidXR0b246CiBQQVNTIGlu cHV0c1swXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgdHJ1ZQotUEFTUyBpbnB1dHNbMV0udmFs aWRpdHkudmFsdWVNaXNzaW5nIGlzIGZhbHNlCi1QQVNTIGlucHV0c1syXS52YWxpZGl0eS52YWx1 ZU1pc3NpbmcgaXMgZmFsc2UKK1BBU1MgaW5wdXRzWzFdLnZhbGlkaXR5LnZhbHVlTWlzc2luZyBp cyB0cnVlCitQQVNTIGlucHV0c1syXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgdHJ1ZQogVGhl IGZpcnN0IGJ1dHRvbiBoYXMgYmVlbiBjaGVja2VkOgogUEFTUyBpbnB1dHNbMF0udmFsaWRpdHku dmFsdWVNaXNzaW5nIGlzIGZhbHNlCiBQQVNTIGlucHV0c1sxXS52YWxpZGl0eS52YWx1ZU1pc3Np bmcgaXMgZmFsc2UKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvcmFkaW8vcmFk aW8tbGl2ZS12YWxpZGF0aW9uLXN0eWxlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3Qv Zm9ybXMvcmFkaW8vcmFkaW8tbGl2ZS12YWxpZGF0aW9uLXN0eWxlLWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi41MjAyMjViYWI0N2IwZGExZTI2Mzk1MTk2OTY3YzEyOTM1MWVhODk2Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9yYWRpby9yYWRpby1saXZlLXZhbGlk YXRpb24tc3R5bGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNDUgQEAKK0NoZWNrIGlmIDp2YWxp ZC86aW52YWxpZCBDU1MgcHNldWRvIHNlbGVjdG9ycyBhcmUgbGl2ZWx5IGFwcGxpZWQKKworT24g c3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93 ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK1JlbW92aW5nIGEgY2hlY2tlZCByYWRpbyBidXR0 b24gZnJvbSBhIHJlcXVpcmVkIHJhZGlvIGJ1dHRvbiBncm91cCBieSBhIERPTSB0cmVlIG11dGF0 aW9uOgorUEFTUyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikpIGlzIHZhbGlkQ29sb3IKK1BBU1Mg cGFyZW50LnJlbW92ZUNoaWxkKCQoInJhZGlvMiIpKTsgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIp KSBpcyBpbnZhbGlkQ29sb3IKKworUmVtb3ZpbmcgYSBjaGVja2VkIHJhZGlvIGJ1dHRvbiBmcm9t IGEgcmVxdWlyZWQgcmFkaW8gYnV0dG9uIGdyb3VwIGJ5IG5hbWUgYXR0cmlidXRlIGNoYW5nZToK K1BBU1MgJCgicmFkaW8yIikubmFtZSA9ICJncm91cDIiOyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8x IikpIGlzIGludmFsaWRDb2xvcgorCitSZW1vdmluZyBhIGNoZWNrZWQgcmFkaW8gYnV0dG9uIGZy b20gYSByZXF1aXJlZCByYWRpbyBidXR0b24gZ3JvdXAgYnkgdHlwZSBjaGFuZ2U6CitQQVNTICQo InJhZGlvMiIpLnR5cGUgPSAidGV4dCI7IGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSkgaXMgaW52 YWxpZENvbG9yCisKK01ha2UgYSByYWRpbyBidXR0b24gZ3JvdXAgcmVxdWlyZWQgYnkgcmVxdWly ZWQgYXR0cmlidXRlIGNoYW5nZToKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKSBpcyB2 YWxpZENvbG9yCitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzIiKSkgaXMgdmFsaWRDb2xvcgor UEFTUyAkKCJyYWRpbzEiKS5yZXF1aXJlZCA9IHRydWU7IGJhY2tncm91bmRPZigkKCJyYWRpbzEi KSkgaXMgaW52YWxpZENvbG9yCitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzIiKSkgaXMgaW52 YWxpZENvbG9yCisKK01ha2UgYSByYWRpbyBidXR0b24gZ3JvdXAgbm90IHJlcXVpcmVkIGJ5IHJl cXVpcmVkIGF0dHJpYnV0ZSBjaGFuZ2U6CitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSkg aXMgaW52YWxpZENvbG9yCitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzIiKSkgaXMgaW52YWxp ZENvbG9yCitQQVNTICQoInJhZGlvMSIpLnJlcXVpcmVkID0gZmFsc2U7IGJhY2tncm91bmRPZigk KCJyYWRpbzEiKSkgaXMgdmFsaWRDb2xvcgorUEFTUyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8yIikp IGlzIHZhbGlkQ29sb3IKKworUmVtb3Zpbmcgb25lIG9mIG11bHRpcGxlIHJlcXVpcmVkIGF0dHJp YnV0ZXM6CitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSkgaXMgaW52YWxpZENvbG9yCitQ QVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzIiKSkgaXMgaW52YWxpZENvbG9yCitQQVNTICQoInJh ZGlvMSIpLnJlcXVpcmVkID0gZmFsc2U7IGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSkgaXMgaW52 YWxpZENvbG9yCitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzIiKSkgaXMgaW52YWxpZENvbG9y CisKK0FkZGluZyBhIHJhZGlvIGJ1dHRvbiB3aXRoIHRoZSByZXF1aXJlZCBhdHRyaWJ1dGUgdG8g YSByYWRpbyBidXR0b24gZ3JvdXA6CitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSkgaXMg dmFsaWRDb2xvcgorUEFTUyBwYXJlbnQuYXBwZW5kQ2hpbGQocmVxdWlyZWRSYWRpb0J1dHRvbik7 IGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSkgaXMgaW52YWxpZENvbG9yCitQQVNTIGJhY2tncm91 bmRPZihyZXF1aXJlZFJhZGlvQnV0dG9uKSBpcyBpbnZhbGlkQ29sb3IKKworUmVtb3ZpbmcgYSBy YWRpbyBidXR0b24gd2l0aCB0aGUgcmVxdWlyZWQgYXR0cmlidXRlIGZyb20gYSByYWRpbyBidXR0 b24gZ3JvdXA6CitQQVNTIHBhcmVudC5yZW1vdmVDaGlsZChyZXF1aXJlZFJhZGlvQnV0dG9uKTsg YmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKSBpcyB2YWxpZENvbG9yCisKK1BBU1Mgc3VjY2Vzc2Z1 bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2Zvcm1zL3JhZGlvL3JhZGlvLWxpdmUtdmFsaWRhdGlvbi1zdHlsZS5odG1sIGIv TGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9yYWRpby9yYWRpby1saXZlLXZhbGlkYXRpb24tc3R5bGUu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi43MzI0NDQ3MGM0OWE0ODZhMmJhNjdhZTVlMWRkMzdhMzQyODcxZTcw Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9yYWRpby9yYWRpby1s aXZlLXZhbGlkYXRpb24tc3R5bGUuaHRtbApAQCAtMCwwICsxLDk0IEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKzxzdHlsZT4KKzppbnZhbGlkIHsgYmFja2dyb3VuZDogcmdi KDI1NSwgMCwgMCk7IH0KKzp2YWxpZCB7IGJhY2tncm91bmQ6IHJnYigwLCAwLCAyNTUpOyB9Cis8 L3N0eWxlPgorPC9oZWFkPgorPGJvZHk+Cis8c2NyaXB0PgorZGVzY3JpcHRpb24oJ0NoZWNrIGlm IDp2YWxpZC86aW52YWxpZCBDU1MgcHNldWRvIHNlbGVjdG9ycyBhcmUgbGl2ZWx5IGFwcGxpZWQn KTsKKworZnVuY3Rpb24gJChpZCkgeworICAgIHJldHVybiBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZChpZCk7Cit9CisKK2Z1bmN0aW9uIGJhY2tncm91bmRPZihlbGVtZW50KSB7CisgICAgcmV0dXJu IGRvY3VtZW50LmRlZmF1bHRWaWV3LmdldENvbXB1dGVkU3R5bGUoZWxlbWVudCwgbnVsbCkuZ2V0 UHJvcGVydHlWYWx1ZSgnYmFja2dyb3VuZC1jb2xvcicpOworfQorCit2YXIgaW52YWxpZENvbG9y ID0gJ3JnYigyNTUsIDAsIDApJzsKK3ZhciB2YWxpZENvbG9yID0gJ3JnYigwLCAwLCAyNTUpJzsK KwordmFyIHBhcmVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworZG9jdW1lbnQu Ym9keS5hcHBlbmRDaGlsZChwYXJlbnQpOworCitkZWJ1ZygnUmVtb3ZpbmcgYSBjaGVja2VkIHJh ZGlvIGJ1dHRvbiBmcm9tIGEgcmVxdWlyZWQgcmFkaW8gYnV0dG9uIGdyb3VwIGJ5IGEgRE9NIHRy ZWUgbXV0YXRpb246Jyk7CitwYXJlbnQuaW5uZXJIVE1MID0gJzxpbnB1dCB0eXBlPXJhZGlvIG5h bWU9Z3JvdXAxIHJlcXVpcmVkIGlkPXJhZGlvMT4nICsKKyAgICAnPGlucHV0IHR5cGU9cmFkaW8g bmFtZT1ncm91cDEgY2hlY2tlZCBpZD1yYWRpbzI+JzsKK3Nob3VsZEJlKCdiYWNrZ3JvdW5kT2Yo JCgicmFkaW8xIikpJywgJ3ZhbGlkQ29sb3InKTsKK3Nob3VsZEJlKCdwYXJlbnQucmVtb3ZlQ2hp bGQoJCgicmFkaW8yIikpOyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikpJywgJ2ludmFsaWRDb2xv cicpOworZGVidWcoJycpOworCitkZWJ1ZygnUmVtb3ZpbmcgYSBjaGVja2VkIHJhZGlvIGJ1dHRv biBmcm9tIGEgcmVxdWlyZWQgcmFkaW8gYnV0dG9uIGdyb3VwIGJ5IG5hbWUgYXR0cmlidXRlIGNo YW5nZTonKTsKK3BhcmVudC5pbm5lckhUTUwgPSAnPGlucHV0IHR5cGU9cmFkaW8gbmFtZT1ncm91 cDEgcmVxdWlyZWQgaWQ9cmFkaW8xPicgKworICAgICc8aW5wdXQgdHlwZT1yYWRpbyBuYW1lPWdy b3VwMSBjaGVja2VkIGlkPXJhZGlvMj4nOworc2hvdWxkQmUoJyQoInJhZGlvMiIpLm5hbWUgPSAi Z3JvdXAyIjsgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKScsICdpbnZhbGlkQ29sb3InKTsKK2Rl YnVnKCcnKTsKKworZGVidWcoJ1JlbW92aW5nIGEgY2hlY2tlZCByYWRpbyBidXR0b24gZnJvbSBh IHJlcXVpcmVkIHJhZGlvIGJ1dHRvbiBncm91cCBieSB0eXBlIGNoYW5nZTonKTsKK3BhcmVudC5p bm5lckhUTUwgPSAnPGlucHV0IHR5cGU9cmFkaW8gbmFtZT1ncm91cDEgcmVxdWlyZWQgaWQ9cmFk aW8xPicgKworICAgICc8aW5wdXQgdHlwZT1yYWRpbyBuYW1lPWdyb3VwMSBjaGVja2VkIGlkPXJh ZGlvMj4nOworc2hvdWxkQmUoJyQoInJhZGlvMiIpLnR5cGUgPSAidGV4dCI7IGJhY2tncm91bmRP ZigkKCJyYWRpbzEiKSknLCAnaW52YWxpZENvbG9yJyk7CitkZWJ1ZygnJyk7CisKK2RlYnVnKCdN YWtlIGEgcmFkaW8gYnV0dG9uIGdyb3VwIHJlcXVpcmVkIGJ5IHJlcXVpcmVkIGF0dHJpYnV0ZSBj aGFuZ2U6Jyk7CitwYXJlbnQuaW5uZXJIVE1MID0gJzxpbnB1dCB0eXBlPXJhZGlvIG5hbWU9Z3Jv dXAxIGlkPXJhZGlvMT4nICsKKyAgICAnPGlucHV0IHR5cGU9cmFkaW8gbmFtZT1ncm91cDEgaWQ9 cmFkaW8yPic7CitzaG91bGRCZSgnYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKScsICd2YWxpZENv bG9yJyk7CitzaG91bGRCZSgnYmFja2dyb3VuZE9mKCQoInJhZGlvMiIpKScsICd2YWxpZENvbG9y Jyk7CitzaG91bGRCZSgnJCgicmFkaW8xIikucmVxdWlyZWQgPSB0cnVlOyBiYWNrZ3JvdW5kT2Yo JCgicmFkaW8xIikpJywgJ2ludmFsaWRDb2xvcicpOworc2hvdWxkQmUoJ2JhY2tncm91bmRPZigk KCJyYWRpbzIiKSknLCAnaW52YWxpZENvbG9yJyk7CitkZWJ1ZygnJyk7CisKK2RlYnVnKCdNYWtl IGEgcmFkaW8gYnV0dG9uIGdyb3VwIG5vdCByZXF1aXJlZCBieSByZXF1aXJlZCBhdHRyaWJ1dGUg Y2hhbmdlOicpOworcGFyZW50LmlubmVySFRNTCA9ICc8aW5wdXQgdHlwZT1yYWRpbyByZXF1aXJl ZCBuYW1lPWdyb3VwMSBpZD1yYWRpbzE+JyArCisgICAgJzxpbnB1dCB0eXBlPXJhZGlvIG5hbWU9 Z3JvdXAxIGlkPXJhZGlvMj4nOworc2hvdWxkQmUoJ2JhY2tncm91bmRPZigkKCJyYWRpbzEiKSkn LCAnaW52YWxpZENvbG9yJyk7CitzaG91bGRCZSgnYmFja2dyb3VuZE9mKCQoInJhZGlvMiIpKScs ICdpbnZhbGlkQ29sb3InKTsKK3Nob3VsZEJlKCckKCJyYWRpbzEiKS5yZXF1aXJlZCA9IGZhbHNl OyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikpJywgJ3ZhbGlkQ29sb3InKTsKK3Nob3VsZEJlKCdi YWNrZ3JvdW5kT2YoJCgicmFkaW8yIikpJywgJ3ZhbGlkQ29sb3InKTsKK2RlYnVnKCcnKTsKKwor CitkZWJ1ZygnUmVtb3Zpbmcgb25lIG9mIG11bHRpcGxlIHJlcXVpcmVkIGF0dHJpYnV0ZXM6Jyk7 CitwYXJlbnQuaW5uZXJIVE1MID0gJzxpbnB1dCB0eXBlPXJhZGlvIHJlcXVpcmVkIG5hbWU9Z3Jv dXAxIGlkPXJhZGlvMT4nICsKKyAgICAnPGlucHV0IHR5cGU9cmFkaW8gcmVxdWlyZWQgbmFtZT1n cm91cDEgaWQ9cmFkaW8yPic7CitzaG91bGRCZSgnYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKScs ICdpbnZhbGlkQ29sb3InKTsKK3Nob3VsZEJlKCdiYWNrZ3JvdW5kT2YoJCgicmFkaW8yIikpJywg J2ludmFsaWRDb2xvcicpOworc2hvdWxkQmUoJyQoInJhZGlvMSIpLnJlcXVpcmVkID0gZmFsc2U7 IGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSknLCAnaW52YWxpZENvbG9yJyk7CitzaG91bGRCZSgn YmFja2dyb3VuZE9mKCQoInJhZGlvMiIpKScsICdpbnZhbGlkQ29sb3InKTsKK2RlYnVnKCcnKTsK KworZGVidWcoJ0FkZGluZyBhIHJhZGlvIGJ1dHRvbiB3aXRoIHRoZSByZXF1aXJlZCBhdHRyaWJ1 dGUgdG8gYSByYWRpbyBidXR0b24gZ3JvdXA6Jyk7CitwYXJlbnQuaW5uZXJIVE1MID0gJzxpbnB1 dCB0eXBlPXJhZGlvIG5hbWU9Z3JvdXAxIGlkPXJhZGlvMT4nOworc2hvdWxkQmUoJ2JhY2tncm91 bmRPZigkKCJyYWRpbzEiKSknLCAndmFsaWRDb2xvcicpOwordmFyIHJlcXVpcmVkUmFkaW9CdXR0 b24gPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdpbnB1dCcpOworcmVxdWlyZWRSYWRpb0J1dHRv bi50eXBlID0gJ3JhZGlvJzsKK3JlcXVpcmVkUmFkaW9CdXR0b24ubmFtZSA9ICdncm91cDEnOwor cmVxdWlyZWRSYWRpb0J1dHRvbi5yZXF1aXJlZCA9IHRydWU7CitzaG91bGRCZSgncGFyZW50LmFw cGVuZENoaWxkKHJlcXVpcmVkUmFkaW9CdXR0b24pOyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikp JywgJ2ludmFsaWRDb2xvcicpOworc2hvdWxkQmUoJ2JhY2tncm91bmRPZihyZXF1aXJlZFJhZGlv QnV0dG9uKScsICdpbnZhbGlkQ29sb3InKTsKK2RlYnVnKCcnKTsKKworZGVidWcoJ1JlbW92aW5n IGEgcmFkaW8gYnV0dG9uIHdpdGggdGhlIHJlcXVpcmVkIGF0dHJpYnV0ZSBmcm9tIGEgcmFkaW8g YnV0dG9uIGdyb3VwOicpOworc2hvdWxkQmUoJ3BhcmVudC5yZW1vdmVDaGlsZChyZXF1aXJlZFJh ZGlvQnV0dG9uKTsgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKScsICd2YWxpZENvbG9yJyk7Citk ZWJ1ZygnJyk7CisKK3BhcmVudC5pbm5lckhUTUwgPSAnJzsKKzwvc2NyaXB0PgorPHNjcmlwdCBz cmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5 PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9zY3JpcHQtdGVz dHMvVmFsaWRpdHlTdGF0ZS12YWx1ZU1pc3NpbmctcmFkaW8uanMgYi9MYXlvdXRUZXN0cy9mYXN0 L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXZhbHVlTWlzc2luZy1yYWRpby5qcwpp bmRleCA5NGM0OTBjYmE1ZmE5YTk4ODIyMjM0NGNiZTRjZThlZjBhYzFiNWE4Li41OTY2ZjMwOGE0 NjQxNDU0ZmRmZWM2OGZkOGZhY2FhZTgzNzJlMWUzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXZhbHVlTWlzc2luZy1yYWRpby5q cworKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRl LXZhbHVlTWlzc2luZy1yYWRpby5qcwpAQCAtMTAsMTEgKzEwLDggQEAgcGFyZW50LmlubmVySFRN TCA9ICc8aW5wdXQgbmFtZT12aWN0aW0gdHlwZT1yYWRpbyByZXF1aXJlZD4nCiB2YXIgaW5wdXRz ID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCeU5hbWUoJ3ZpY3RpbScpOwogZGVidWcoJ05vIGNoZWNr ZWQgYnV0dG9uOicpOwogc2hvdWxkQmVUcnVlKCdpbnB1dHNbMF0udmFsaWRpdHkudmFsdWVNaXNz aW5nJyk7Ci0vLyBUaGUgZm9sbG93aW5nIHJlc3VsdCBzaG91bGQgYmUgZmFsc2UgYmVjYXVzZSB0 aGUgZWxlbWVudCBkb2VzIG5vdCBoYXZlCi0vLyAicmVxdWlyZWQiLiAgSXQgY29uZm9ybXMgdG8g SFRNTDUsIGFuZCB0aGlzIGJlaGF2aW9yIGhhcyBubyBwcmFjdGljYWwKLS8vIHByb2JsZW1zLgot c2hvdWxkQmVGYWxzZSgnaW5wdXRzWzFdLnZhbGlkaXR5LnZhbHVlTWlzc2luZycpOwotc2hvdWxk QmVGYWxzZSgnaW5wdXRzWzJdLnZhbGlkaXR5LnZhbHVlTWlzc2luZycpOworc2hvdWxkQmVUcnVl KCdpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7CitzaG91bGRCZVRydWUoJ2lucHV0 c1syXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsKIGRlYnVnKCdUaGUgc2Vjb25kIGJ1dHRvbiBo YXMgYmVlbiBjaGVja2VkOicpOwogaW5wdXRzWzFdLmNoZWNrZWQgPSB0cnVlOwogc2hvdWxkQmVG YWxzZSgnaW5wdXRzWzBdLnZhbGlkaXR5LnZhbHVlTWlzc2luZycpOwpAQCAtNDAsOSArMzcsOCBA QCBwYXJlbnQuaW5uZXJIVE1MID0gJzxmb3JtPicKIGlucHV0cyA9IGRvY3VtZW50LmdldEVsZW1l bnRzQnlOYW1lKCd2aWN0aW0nKTsKIGRlYnVnKCdObyBjaGVja2VkIGJ1dHRvbjonKTsKIHNob3Vs ZEJlVHJ1ZSgnaW5wdXRzWzBdLnZhbGlkaXR5LnZhbHVlTWlzc2luZycpOwotLy8gVGhlIGZvbGxv d2luZyByZXN1bHQgc2hvdWxkIGJlIGZhbHNlLgotc2hvdWxkQmVGYWxzZSgnaW5wdXRzWzFdLnZh bGlkaXR5LnZhbHVlTWlzc2luZycpOwotc2hvdWxkQmVGYWxzZSgnaW5wdXRzWzJdLnZhbGlkaXR5 LnZhbHVlTWlzc2luZycpOworc2hvdWxkQmVUcnVlKCdpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVN aXNzaW5nJyk7CitzaG91bGRCZVRydWUoJ2lucHV0c1syXS52YWxpZGl0eS52YWx1ZU1pc3Npbmcn KTsKIGRlYnVnKCdUaGUgZmlyc3QgYnV0dG9uIGhhcyBiZWVuIGNoZWNrZWQ6Jyk7CiBpbnB1dHNb MF0uY2hlY2tlZCA9IHRydWU7CiBzaG91bGRCZUZhbHNlKCdpbnB1dHNbMF0udmFsaWRpdHkudmFs dWVNaXNzaW5nJyk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wZXJmL2FkZGluZy1yYWRpby1i dXR0b25zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BlcmYvYWRkaW5nLXJhZGlvLWJ1dHRv bnMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmEyOTEzMmRmOGM4MGQyZDcyOGMxMTgzZDc4M2I5 ODI0MjgxNGRhNDEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wZXJmL2FkZGluZy1y YWRpby1idXR0b25zLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK1Rlc3RzIHRoYXQgYWRk aW5nIGEgcmFkaW8gYnV0dG9uIHRvIGEgcmFkaW8gYnV0dG9uIGdyb3VwIGlzIGNvbnN0YW50IGlu IHRoZSBudW1iZXIgb2YgcmFkaW8gYnV0dG9ucy4KK1BBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGVyZi9hZGRpbmctcmFkaW8tYnV0dG9ucy5odG1sIGIvTGF5b3V0VGVzdHMvcGVyZi9h ZGRpbmctcmFkaW8tYnV0dG9ucy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFhYmFlZjQ5MTA5OTAxY2UyN2M3 MjhhZGJjMGM1ODljMzllYzUxN2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wZXJm L2FkZGluZy1yYWRpby1idXR0b25zLmh0bWwKQEAgLTAsMCArMSwzNyBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxib2R5PgorPHNjcmlwdCBzcmM9Ii4uL3Jlc291cmNlcy9tYWduaXR1ZGUt cGVyZi5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0PgordmFyIHBhcmVudEZvcm0gPSBudWxsOworCitm dW5jdGlvbiBzZXR1cChtYWduaXR1ZGUpIHsKKyAgICBpZiAocGFyZW50Rm9ybSkKKyAgICAgICAg ZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChwYXJlbnRGb3JtKTsKKyAgICBwYXJlbnRGb3JtID0g ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZm9ybScpOworICAgIGRvY3VtZW50LmJvZHkuYXBwZW5k Q2hpbGQocGFyZW50Rm9ybSk7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBtYWduaXR1ZGU7ICsr aSkgeworICAgICAgICB2YXIgcmFkaW8gPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdpbnB1dCcp OworICAgICAgICByYWRpby50eXBlID0gJ3JhZGlvJzsKKyAgICAgICAgcmFkaW8ubmFtZSA9ICdn cm91cDEnOworICAgICAgICByYWRpby5jaGVja2VkID0gdHJ1ZTsKKyAgICAgICAgcGFyZW50Rm9y bS5hcHBlbmRDaGlsZChyYWRpbyk7CisgICAgfQorICAgIHBhcmVudEZvcm0ub2Zmc2V0TGVmdDsK K30KKworZnVuY3Rpb24gdGVzdChtYWduaXR1ZGUpIHsKKyAgICB2YXIgcmFkaW8gPSBkb2N1bWVu dC5jcmVhdGVFbGVtZW50KCdpbnB1dCcpOworICAgIHJhZGlvLnR5cGUgPSAncmFkaW8nOworICAg IHJhZGlvLm5hbWUgPSAnZ3JvdXAxJzsKKyAgICByYWRpby5jaGVja2VkID0gdHJ1ZTsKKyAgICBw YXJlbnRGb3JtLmFwcGVuZENoaWxkKHJhZGlvKTsKKyAgICByYWRpby5vZmZzZXRMZWZ0OworICAg IHBhcmVudEZvcm0ucmVtb3ZlQ2hpbGQocmFkaW8pOworfQorCitNYWduaXR1ZGUuZGVzY3JpcHRp b24oIlRlc3RzIHRoYXQgYWRkaW5nIGEgcmFkaW8gYnV0dG9uIHRvIGEgcmFkaW8gYnV0dG9uIGdy b3VwIGlzIGNvbnN0YW50IGluIHRoZSBudW1iZXIgb2YgcmFkaW8gYnV0dG9ucy4iKTsKK01hZ25p dHVkZS5ydW4oc2V0dXAsIHRlc3QsIE1hZ25pdHVkZS5DT05TVEFOVCk7Cis8L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4K 123691 2012-01-23 19:54:38 -0800 2012-01-24 01:57:33 -0800 Patch for landing bug-74909-20120124125436.patch text/plain 38763 tkent U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1NTkyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZGZiNDI0ZDk3NmNhYzcw YTU2NTQ0NzIxYTEwZWE4ODMxOTM2OWU0Yy4uZWY1NGE3Mzk0NjM5Y2ZiOTFiYTRmNTY5NTM0YWVj N2QyZWRhYjI0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDkwIEBACisyMDEyLTAxLTIzICBLZW50 IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KKworICAgICAgICBJbnRyb2R1Y2UgUmFkaW9C dXR0b25Hcm91cCBjbGFzcyB0byBrZWVwIHRyYWNrIG9mIHRoZSBncm91cCBtZW1iZXJzIGFuZCBy ZXF1aXJlZCBzdGF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NzQ5MDkKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KKworICAgICAg ICBSYWRpb0J1dHRvbkdyb3VwIGNvbnRhaW5zIGEgc2V0IG9mIG1lbWJlciByYWRpbyBidXR0b25z IGluIHRoZSBncm91cCwKKyAgICAgICAgYW5kICJyZXF1aXJlZCIgc3RhdHVzIG9mIHRoZSBncm91 cC4gVGhpcyBoZWxwcyBpbXBsZW1lbnRpbmcgY29ycmVjdAorICAgICAgICByYWRpbyBidXR0b24g dmFsaWRpdHksIGFuZCBpbXByb3ZpbmcgcGVyZm9ybWFuY2Ugb2YgdXBkYXRpbmcgdmFsaWRpdHkK KyAgICAgICAgc3RhdHVzIG9mIHJhZGlvIGJ1dHRvbnMuCisKKyAgICAgICAgVGhpcyBjaGFuZ2Ug Zml4ZXMgdGhlIGZvbGxvd2luZyBidWdzOgorICAgICAgICAtIEEgcmFkaW8gYnV0dG9uIHNob3Vs ZCBiZSAicmVxdWlyZWQiIGlmIG9uZSBvZiBhIG1lbWJlciBvZiB0aGUgc2FtZQorICAgICAgICAg IGdyb3VwIGhhcyB0aGUgInJlcXVpcmVkIiBhdHRyaWJ1dGUuCisgICAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc2MzY1CisgICAgICAgIC0gOmludmFsaWQg c3R5bGUgaXMgbm90IGFwcGxpZWQgd2hlbiBhIGNoZWNrZWQgcmFkaW8gYnV0dG9uIGlzIHJlbW92 ZWQKKyAgICAgICAgICBmcm9tIGl0cyByYWRpbyBncm91cAorICAgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NDkxNAorICAgICAgICAtIExvYWRpbmcgYSBw YWdlIHdpdGggTiByYWRpbyBidXR0b25zIGluIGEgZ3JvdXAgdGFrZXMgTyhOXjIpIHRpbWUuCisK KyAgICAgICAgVGVzdHM6IGZhc3QvZm9ybXMvcmFkaW8vcmFkaW8tbGl2ZS12YWxpZGF0aW9uLXN0 eWxlLmh0bWwKKyAgICAgICAgICAgICAgIHBlcmYvYWRkaW5nLXJhZGlvLWJ1dHRvbnMuaHRtbAor CisgICAgICAgICogZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UmFkaW9CdXR0b25Hcm91cDo6aXNFbXB0eSk6CisgICAgICAgIChXZWJDb3JlOjpSYWRpb0J1 dHRvbkdyb3VwOjppc1JlcXVpcmVkKToKKyAgICAgICAgKFdlYkNvcmU6OlJhZGlvQnV0dG9uR3Jv dXA6OmNoZWNrZWRCdXR0b24pOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9CdXR0b25Hcm91cDo6 UmFkaW9CdXR0b25Hcm91cCk6CisgICAgICAgIChXZWJDb3JlOjpSYWRpb0J1dHRvbkdyb3VwOjpj cmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9CdXR0b25Hcm91cDo6aXNWYWxpZCk6Cisg ICAgICAgIChXZWJDb3JlOjpSYWRpb0J1dHRvbkdyb3VwOjpzZXRDaGVja2VkQnV0dG9uKToKKyAg ICAgICAgKFdlYkNvcmU6OlJhZGlvQnV0dG9uR3JvdXA6OmFkZCk6CisgICAgICAgIChXZWJDb3Jl OjpSYWRpb0J1dHRvbkdyb3VwOjp1cGRhdGVDaGVja2VkU3RhdGUpOgorICAgICAgICAoV2ViQ29y ZTo6UmFkaW9CdXR0b25Hcm91cDo6cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKToKKyAgICAgICAg KFdlYkNvcmU6OlJhZGlvQnV0dG9uR3JvdXA6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpS YWRpb0J1dHRvbkdyb3VwOjpzZXROZWVkc1ZhbGlkaXR5Q2hlY2tGb3JBbGxCdXR0b25zKToKKyAg ICAgICAgQWRkIFJhZGlvQnV0dG9uR3JvdXAgY2xhc3MuIEl0IGtlZXBzIHRyYWNrIG9mIHBvaW50 ZXJzIHRvIG1lbWJlciByYWRpbworICAgICAgICBidXR0b25zIGFuZCByZXF1aXJlZCBzdGF0dXMg b2YgdGhlIGdyb3VwIGluIGFkZGl0aW9uIHRvIHRoZSBjaGVja2VkCisgICAgICAgIHJhZGlvIGJ1 dHRvbiBwb2ludGVyLgorCisgICAgICAgIChXZWJDb3JlOjpDaGVja2VkUmFkaW9CdXR0b25zOjpD aGVja2VkUmFkaW9CdXR0b25zKToKKyAgICAgICAgKFdlYkNvcmU6OkNoZWNrZWRSYWRpb0J1dHRv bnM6On5DaGVja2VkUmFkaW9CdXR0b25zKToKKyAgICAgICAgRGVmaW5lIGVtcHR5IGNvbnN0cnVj dG9yIGFuZCBkZXN0cnVjdG9yIGluIG9yZGVyIHRvIGF2b2lkIGV4cG9zaW5nCisgICAgICAgIFJh ZGlvQnV0dG9uR3JvdXAgY2xhc3MuCisKKyAgICAgICAgKFdlYkNvcmU6OkNoZWNrZWRSYWRpb0J1 dHRvbnM6OmFkZEJ1dHRvbik6CisgICAgICAgIChXZWJDb3JlOjpDaGVja2VkUmFkaW9CdXR0b25z Ojp1cGRhdGVDaGVja2VkU3RhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q2hlY2tlZFJhZGlvQnV0 dG9uczo6cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKToKKyAgICAgICAgKFdlYkNvcmU6OkNoZWNr ZWRSYWRpb0J1dHRvbnM6OmNoZWNrZWRCdXR0b25Gb3JHcm91cCk6CisgICAgICAgIChXZWJDb3Jl OjpDaGVja2VkUmFkaW9CdXR0b25zOjppc0luUmVxdWlyZWRHcm91cCk6CisgICAgICAgIChXZWJD b3JlOjpDaGVja2VkUmFkaW9CdXR0b25zOjpyZW1vdmVCdXR0b24pOgorICAgICAgICBDaGFuZ2Ug dGhlIEhhc2hNYXAgbWVtYmVyIG9mIHRoaXMgY2xhc3Mgc28gdGhhdCBpdCBtYXBzIGEgZ3JvdXAg bmFtZSB0bworICAgICAgICBhIFJhZGlvQnV0dG9uR3JvdXAgb2JqZWN0LiBUaGVzZSBmdW5jdGlv bnMganVzdCBnZXQgYSBSYWRpb0J1dHRvbkdyb3VwCisgICAgICAgIG9iamVjdCBhbmQgY2FsbCBh IGNvcnJlc3BvbmRpbmcgbWVtYmVyIGZ1bmN0aW9uIG9mIFJhZGlvQnV0dG9uR3JvdXAuCisKKyAg ICAgICAgKiBkb20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5oOiBVcGRhdGUgZGVjbGFyYXRpb25zLgor CisgICAgICAgICogaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OnBhcnNlTWFwcGVkQXR0cmlidXRlKToKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OnJlcXVpcmVkQXR0cmlidXRl Q2hhbmdlZCk6CisgICAgICAgIE1vdmUgYSBwYXJ0IG9mIHBhcnNlTWFwcGVkQXR0cmlidXRlKCkg aW50byByZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoKS4KKyAgICAgICAgKiBodG1sL0hUTUxGb3Jt Q29udHJvbEVsZW1lbnQuaDogQWRkIHJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpLgorICAgICAg ICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW5w dXRFbGVtZW50Ojp2YWx1ZU1pc3NpbmcpOgorICAgICAgICBNb3ZlIHJlcXVpcmVkIGNoZWNrIGNv ZGUgdG8gSW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmcgaW1wbGVtZW50YXRpb25zLgorICAgICAgICBS YWRpb0lucHV0VHlwZSBuZWVkcyBzcGVjaWFsIGhhbmRsaW5nIGZvciBjaGVja2luZyByZXF1aXJl ZCBzdGF0ZS4KKyAgICAgICAgcmVhZE9ubHkoKSBhbmQgZGlzYWJsZWQoKSBhcmUgdW5uZWNlc3Nh cnkgYmVjYXVzZSB3aWxsVmFsaWRhdGUoKSBjaGVja3MgdGhlbS4KKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxJbnB1dEVsZW1lbnQ6OnNldENoZWNrZWQpOgorICAgICAgICBDYWxsIG5ldyBmdW5jdGlv biBDaGVja2VkUmFkaW9CdXR0b25zOjp1cGRhdGVDaGVja2VkU3RhdGUoKSBpbnN0ZWFkIG9mCisg ICAgICAgIHJlbW92ZUJ1dHRvbigpIGFuZCB1cGRhdGVDaGVja2VkUmFkaW9CdXR0b25zKCkuCisg ICAgICAgIChXZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpyZXF1aXJlZEF0dHJpYnV0ZUNoYW5n ZWQpOgorICAgICAgICBPdmVycmlkZSB0aGlzIHRvIGNhbGwgQ2hlY2tlZFJhZGlvQnV0dG9uczo6 cmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKCkuCisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVt ZW50Lmg6IEFkZCByZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoKS4KKyAgICAgICAgKiBodG1sL1Jh ZGlvSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJhZGlvSW5wdXRUeXBlOjp2YWx1 ZU1pc3NpbmcpOgorICAgICAgICBDaGVjayByZXF1aXJlZCBzdGF0ZSBieSBDaGVja2VkUmFkaW9C dXR0b25zOjppc0luUmVxdWlyZWRHcm91cCgpLgorICAgICAgICAqIGh0bWwvUmFkaW9JbnB1dFR5 cGUuaDogUmVtb3ZlIGF0dGFjaCgpLgorCisgICAgICAgICogaHRtbC9DaGVja2JveElucHV0VHlw ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDaGVja2JveElucHV0VHlwZTo6dmFsdWVNaXNzaW5n KToKKyAgICAgICAgICBNb3ZlIHJlcXVpcmVkIGNoZWNrIGZyb20gSFRNTElucHV0RWxlbWVudDo6 dmFsdWVNaXNzaW5nKCkuCisgICAgICAgICogaHRtbC9GaWxlSW5wdXRUeXBlLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkZpbGVJbnB1dFR5cGU6OnZhbHVlTWlzc2luZyk6IGRpdHRvLgorICAgICAg ICAqIGh0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRleHRG aWVsZElucHV0VHlwZTo6dmFsdWVNaXNzaW5nKTogZGl0dG8uCisKIDIwMTItMDEtMjIgIE1hcmlv IFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIEFU SyB0ZXh0LWNhcmV0LW1vdmVkIGFuZCB0ZXh0LXNlbGVjdGlvbi1jaGFuZ2VkIGV2ZW50cyBub3Qg YmVpbmcgZW1pdHRlZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0NoZWNrZWRSYWRp b0J1dHRvbnMuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMuY3Bw CmluZGV4IDlhYjg5MTIwZjlkNzBjMGI1M2I4Njc4NDA5MWU0MzJiOTY1NWU0YTYuLjliNWM1MDMz NGU3NGY1OTFjZDBjYmVmNjU0MjAwZjZhNDQ1YTAwYTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2RvbS9DaGVja2VkUmFkaW9CdXR0b25zLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20v Q2hlY2tlZFJhZGlvQnV0dG9ucy5jcHAKQEAgLTIyLDY1ICsyMiwyNDQgQEAKICNpbmNsdWRlICJD aGVja2VkUmFkaW9CdXR0b25zLmgiCiAKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCisj aW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBS YWRpb0J1dHRvbkdyb3VwIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxSYWRpb0J1 dHRvbkdyb3VwPiBjcmVhdGUoKTsKKyAgICBib29sIGlzRW1wdHkoKSBjb25zdCB7IHJldHVybiBt X21lbWJlcnMuaXNFbXB0eSgpOyB9CisgICAgYm9vbCBpc1JlcXVpcmVkKCkgY29uc3QgeyByZXR1 cm4gbV9yZXF1aXJlZENvdW50OyB9CisgICAgSFRNTElucHV0RWxlbWVudCogY2hlY2tlZEJ1dHRv bigpIGNvbnN0IHsgcmV0dXJuIG1fY2hlY2tlZEJ1dHRvbjsgfQorICAgIHZvaWQgYWRkKEhUTUxJ bnB1dEVsZW1lbnQqKTsKKyAgICB2b2lkIHVwZGF0ZUNoZWNrZWRTdGF0ZShIVE1MSW5wdXRFbGVt ZW50Kik7CisgICAgdm9pZCByZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoSFRNTElucHV0RWxlbWVu dCopOworICAgIHZvaWQgcmVtb3ZlKEhUTUxJbnB1dEVsZW1lbnQqKTsKKworcHJpdmF0ZToKKyAg ICBSYWRpb0J1dHRvbkdyb3VwKCk7CisgICAgdm9pZCBzZXROZWVkc1ZhbGlkaXR5Q2hlY2tGb3JB bGxCdXR0b25zKCk7CisgICAgYm9vbCBpc1ZhbGlkKCkgY29uc3Q7CisgICAgdm9pZCBzZXRDaGVj a2VkQnV0dG9uKEhUTUxJbnB1dEVsZW1lbnQqKTsKKworICAgIEhhc2hTZXQ8SFRNTElucHV0RWxl bWVudCo+IG1fbWVtYmVyczsKKyAgICBIVE1MSW5wdXRFbGVtZW50KiBtX2NoZWNrZWRCdXR0b247 CisgICAgc2l6ZV90IG1fcmVxdWlyZWRDb3VudDsKK307CisKK1JhZGlvQnV0dG9uR3JvdXA6OlJh ZGlvQnV0dG9uR3JvdXAoKQorICAgIDogbV9jaGVja2VkQnV0dG9uKDApCisgICAgLCBtX3JlcXVp cmVkQ291bnQoMCkKK3sKK30KKworUGFzc093blB0cjxSYWRpb0J1dHRvbkdyb3VwPiBSYWRpb0J1 dHRvbkdyb3VwOjpjcmVhdGUoKQoreworICAgIHJldHVybiBhZG9wdFB0cihuZXcgUmFkaW9CdXR0 b25Hcm91cCk7Cit9CisKK2lubGluZSBib29sIFJhZGlvQnV0dG9uR3JvdXA6OmlzVmFsaWQoKSBj b25zdAoreworICAgIHJldHVybiAhaXNSZXF1aXJlZCgpIHx8IG1fY2hlY2tlZEJ1dHRvbjsKK30K Kwordm9pZCBSYWRpb0J1dHRvbkdyb3VwOjpzZXRDaGVja2VkQnV0dG9uKEhUTUxJbnB1dEVsZW1l bnQqIGJ1dHRvbikKK3sKKyAgICBIVE1MSW5wdXRFbGVtZW50KiBvbGRDaGVja2VkQnV0dG9uID0g bV9jaGVja2VkQnV0dG9uOworICAgIGlmIChvbGRDaGVja2VkQnV0dG9uID09IGJ1dHRvbikKKyAg ICAgICAgcmV0dXJuOworICAgIG1fY2hlY2tlZEJ1dHRvbiA9IGJ1dHRvbjsKKyAgICBpZiAob2xk Q2hlY2tlZEJ1dHRvbikKKyAgICAgICAgb2xkQ2hlY2tlZEJ1dHRvbi0+c2V0Q2hlY2tlZChmYWxz ZSk7Cit9CisKK3ZvaWQgUmFkaW9CdXR0b25Hcm91cDo6YWRkKEhUTUxJbnB1dEVsZW1lbnQqIGJ1 dHRvbikKK3sKKyAgICBBU1NFUlQoYnV0dG9uLT5pc1JhZGlvQnV0dG9uKCkpOworICAgIGlmICgh bV9tZW1iZXJzLmFkZChidXR0b24pLnNlY29uZCkKKyAgICAgICAgcmV0dXJuOworICAgIGJvb2wg Z3JvdXBXYXNWYWxpZCA9IGlzVmFsaWQoKTsKKyAgICBpZiAoYnV0dG9uLT5yZXF1aXJlZCgpKQor ICAgICAgICArK21fcmVxdWlyZWRDb3VudDsKKyAgICBpZiAoYnV0dG9uLT5jaGVja2VkKCkpCisg ICAgICAgIHNldENoZWNrZWRCdXR0b24oYnV0dG9uKTsKKworICAgIGJvb2wgZ3JvdXBJc1ZhbGlk ID0gaXNWYWxpZCgpOworICAgIGlmIChncm91cFdhc1ZhbGlkICE9IGdyb3VwSXNWYWxpZCkKKyAg ICAgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrRm9yQWxsQnV0dG9ucygpOworICAgIGVsc2UgaWYg KCFncm91cElzVmFsaWQpIHsKKyAgICAgICAgLy8gQSByYWRpbyBidXR0b24gbm90IGluIGEgZ3Jv dXAgaXMgYWx3YXlzIHZhbGlkLiBXZSBuZWVkIHRvIG1ha2UgaXQKKyAgICAgICAgLy8gaW52YWxp ZCBvbmx5IGlmIHRoZSBncm91cCBpcyBpbnZhbGlkLgorICAgICAgICBidXR0b24tPnNldE5lZWRz VmFsaWRpdHlDaGVjaygpOworICAgIH0KK30KKwordm9pZCBSYWRpb0J1dHRvbkdyb3VwOjp1cGRh dGVDaGVja2VkU3RhdGUoSFRNTElucHV0RWxlbWVudCogYnV0dG9uKQoreworICAgIEFTU0VSVChi dXR0b24tPmlzUmFkaW9CdXR0b24oKSk7CisgICAgQVNTRVJUKG1fbWVtYmVycy5jb250YWlucyhi dXR0b24pKTsKKyAgICBib29sIHdhc1ZhbGlkID0gaXNWYWxpZCgpOworICAgIGlmIChidXR0b24t PmNoZWNrZWQoKSkKKyAgICAgICAgc2V0Q2hlY2tlZEJ1dHRvbihidXR0b24pOworICAgIGVsc2Ug eworICAgICAgICBpZiAobV9jaGVja2VkQnV0dG9uID09IGJ1dHRvbikKKyAgICAgICAgICAgIG1f Y2hlY2tlZEJ1dHRvbiA9IDA7CisgICAgfQorICAgIGlmICh3YXNWYWxpZCAhPSBpc1ZhbGlkKCkp CisgICAgICAgIHNldE5lZWRzVmFsaWRpdHlDaGVja0ZvckFsbEJ1dHRvbnMoKTsKK30KKwordm9p ZCBSYWRpb0J1dHRvbkdyb3VwOjpyZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoSFRNTElucHV0RWxl bWVudCogYnV0dG9uKQoreworICAgIEFTU0VSVChidXR0b24tPmlzUmFkaW9CdXR0b24oKSk7Cisg ICAgQVNTRVJUKG1fbWVtYmVycy5jb250YWlucyhidXR0b24pKTsKKyAgICBib29sIHdhc1ZhbGlk ID0gaXNWYWxpZCgpOworICAgIGlmIChidXR0b24tPnJlcXVpcmVkKCkpCisgICAgICAgICsrbV9y ZXF1aXJlZENvdW50OworICAgIGVsc2UgeworICAgICAgICBBU1NFUlQobV9yZXF1aXJlZENvdW50 KTsKKyAgICAgICAgLS1tX3JlcXVpcmVkQ291bnQ7CisgICAgfQorICAgIGlmICh3YXNWYWxpZCAh PSBpc1ZhbGlkKCkpCisgICAgICAgIHNldE5lZWRzVmFsaWRpdHlDaGVja0ZvckFsbEJ1dHRvbnMo KTsKK30KKwordm9pZCBSYWRpb0J1dHRvbkdyb3VwOjpyZW1vdmUoSFRNTElucHV0RWxlbWVudCog YnV0dG9uKQoreworICAgIEFTU0VSVChidXR0b24tPmlzUmFkaW9CdXR0b24oKSk7CisgICAgSGFz aFNldDxIVE1MSW5wdXRFbGVtZW50Kj46Oml0ZXJhdG9yIGl0ID0gbV9tZW1iZXJzLmZpbmQoYnV0 dG9uKTsKKyAgICBpZiAoaXQgPT0gbV9tZW1iZXJzLmVuZCgpKQorICAgICAgICByZXR1cm47Cisg ICAgYm9vbCB3YXNWYWxpZCA9IGlzVmFsaWQoKTsKKyAgICBtX21lbWJlcnMucmVtb3ZlKGl0KTsK KyAgICBpZiAoYnV0dG9uLT5yZXF1aXJlZCgpKSB7CisgICAgICAgIEFTU0VSVChtX3JlcXVpcmVk Q291bnQpOworICAgICAgICAtLW1fcmVxdWlyZWRDb3VudDsKKyAgICB9CisgICAgaWYgKG1fY2hl Y2tlZEJ1dHRvbiA9PSBidXR0b24pCisgICAgICAgIG1fY2hlY2tlZEJ1dHRvbiA9IDA7CisKKyAg ICBpZiAobV9tZW1iZXJzLmlzRW1wdHkoKSkgeworICAgICAgICBBU1NFUlQoIW1fcmVxdWlyZWRD b3VudCk7CisgICAgICAgIEFTU0VSVCghbV9jaGVja2VkQnV0dG9uKTsKKyAgICB9IGVsc2UgaWYg KHdhc1ZhbGlkICE9IGlzVmFsaWQoKSkKKyAgICAgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrRm9y QWxsQnV0dG9ucygpOworICAgIGlmICghd2FzVmFsaWQpIHsKKyAgICAgICAgLy8gQSByYWRpbyBi dXR0b24gbm90IGluIGEgZ3JvdXAgaXMgYWx3YXlzIHZhbGlkLiBXZSBuZWVkIHRvIG1ha2UgaXQK KyAgICAgICAgLy8gdmFsaWQgb25seSBpZiB0aGUgZ3JvdXAgd2FzIGludmFsaWQuCisgICAgICAg IGJ1dHRvbi0+c2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7CisgICAgfQorfQorCit2b2lkIFJhZGlv QnV0dG9uR3JvdXA6OnNldE5lZWRzVmFsaWRpdHlDaGVja0ZvckFsbEJ1dHRvbnMoKQoreworICAg IHR5cGVkZWYgSGFzaFNldDxIVE1MSW5wdXRFbGVtZW50Kj46OmNvbnN0X2l0ZXJhdG9yIEl0ZXJh dG9yOworICAgIEl0ZXJhdG9yIGVuZCA9IG1fbWVtYmVycy5lbmQoKTsKKyAgICBmb3IgKEl0ZXJh dG9yIGl0ID0gbV9tZW1iZXJzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkgeworICAgICAgICBI VE1MSW5wdXRFbGVtZW50KiBidXR0b24gPSAqaXQ7CisgICAgICAgIEFTU0VSVChidXR0b24tPmlz UmFkaW9CdXR0b24oKSk7CisgICAgICAgIGJ1dHRvbi0+c2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7 CisgICAgfQorfQorCisvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKIHN0YXRpYyBpbmxpbmUgYm9vbCBzaG91bGRNYWtl UmFkaW9Hcm91cChIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KQogewogICAgIHJldHVybiBlbGVt ZW50LT5pc1JhZGlvQnV0dG9uKCkgJiYgIWVsZW1lbnQtPm5hbWUoKS5pc0VtcHR5KCkgJiYgZWxl bWVudC0+aW5Eb2N1bWVudCgpOwogfQogCisvLyBFeHBsaWNpdHkgZGVmaW5lIGVtcHR5IGNvbnN0 cnVjdG9yIGFuZCBkZXN0cnVjdG9yIGluIG9yZGVyIHRvIHByZXZlbnQgdGhlCisvLyBjb21waWxl ciBmcm9tIGdlbmVyYXRpbmcgdGhlbSBhcyBpbmxpbmVzLiBTbyB3ZSBkb24ndCBuZWVkIHRvIHRv IGRlZmluZQorLy8gUmFkaW9CdXR0b25Hcm91cCBpbiB0aGUgaGVhZGVyLgorQ2hlY2tlZFJhZGlv QnV0dG9uczo6Q2hlY2tlZFJhZGlvQnV0dG9ucygpCit7Cit9CisKK0NoZWNrZWRSYWRpb0J1dHRv bnM6On5DaGVja2VkUmFkaW9CdXR0b25zKCkKK3sKK30KKwogdm9pZCBDaGVja2VkUmFkaW9CdXR0 b25zOjphZGRCdXR0b24oSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKIHsKICAgICBpZiAoIXNo b3VsZE1ha2VSYWRpb0dyb3VwKGVsZW1lbnQpKQogICAgICAgICByZXR1cm47CiAKLSAgICAvLyBX ZSBvbmx5IHRyYWNrIGNoZWNrZWQgYnV0dG9ucy4KLSAgICBpZiAoIWVsZW1lbnQtPmNoZWNrZWQo KSkKLSAgICAgICAgcmV0dXJuOworICAgIGlmICghbV9uYW1lVG9Hcm91cE1hcCkKKyAgICAgICAg bV9uYW1lVG9Hcm91cE1hcCA9IGFkb3B0UHRyKG5ldyBOYW1lVG9Hcm91cE1hcCk7CiAKLSAgICBp ZiAoIW1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwKQotICAgICAgICBtX25hbWVUb0NoZWNr ZWRSYWRpb0J1dHRvbk1hcCA9IGFkb3B0UHRyKG5ldyBOYW1lVG9JbnB1dE1hcCk7CisgICAgT3du UHRyPFJhZGlvQnV0dG9uR3JvdXA+JiBncm91cCA9IG1fbmFtZVRvR3JvdXBNYXAtPmFkZChlbGVt ZW50LT5uYW1lKCkuaW1wbCgpLCBQYXNzT3duUHRyPFJhZGlvQnV0dG9uR3JvdXA+KCkpLmZpcnN0 LT5zZWNvbmQ7CisgICAgaWYgKCFncm91cCkKKyAgICAgICAgZ3JvdXAgPSBSYWRpb0J1dHRvbkdy b3VwOjpjcmVhdGUoKTsKKyAgICBncm91cC0+YWRkKGVsZW1lbnQpOworfQogCi0gICAgcGFpcjxO YW1lVG9JbnB1dE1hcDo6aXRlcmF0b3IsIGJvb2w+IHJlc3VsdCA9IG1fbmFtZVRvQ2hlY2tlZFJh ZGlvQnV0dG9uTWFwLT5hZGQoZWxlbWVudC0+bmFtZSgpLmltcGwoKSwgZWxlbWVudCk7Ci0gICAg aWYgKHJlc3VsdC5zZWNvbmQpCit2b2lkIENoZWNrZWRSYWRpb0J1dHRvbnM6OnVwZGF0ZUNoZWNr ZWRTdGF0ZShIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KQoreworICAgIGlmICghc2hvdWxkTWFr ZVJhZGlvR3JvdXAoZWxlbWVudCkpCiAgICAgICAgIHJldHVybjsKLSAgICAKLSAgICBIVE1MSW5w dXRFbGVtZW50KiBvbGRDaGVja2VkQnV0dG9uID0gcmVzdWx0LmZpcnN0LT5zZWNvbmQ7Ci0gICAg aWYgKG9sZENoZWNrZWRCdXR0b24gPT0gZWxlbWVudCkKKyAgICBBU1NFUlQobV9uYW1lVG9Hcm91 cE1hcCk7CisgICAgaWYgKCFtX25hbWVUb0dyb3VwTWFwKQogICAgICAgICByZXR1cm47CisgICAg UmFkaW9CdXR0b25Hcm91cCogZ3JvdXAgPSBtX25hbWVUb0dyb3VwTWFwLT5nZXQoZWxlbWVudC0+ bmFtZSgpLmltcGwoKSk7CisgICAgQVNTRVJUKGdyb3VwKTsKKyAgICBncm91cC0+dXBkYXRlQ2hl Y2tlZFN0YXRlKGVsZW1lbnQpOworfQogCi0gICAgcmVzdWx0LmZpcnN0LT5zZWNvbmQgPSBlbGVt ZW50OwotICAgIG9sZENoZWNrZWRCdXR0b24tPnNldENoZWNrZWQoZmFsc2UpOwordm9pZCBDaGVj a2VkUmFkaW9CdXR0b25zOjpyZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoSFRNTElucHV0RWxlbWVu dCogZWxlbWVudCkKK3sKKyAgICBpZiAoIXNob3VsZE1ha2VSYWRpb0dyb3VwKGVsZW1lbnQpKQor ICAgICAgICByZXR1cm47CisgICAgQVNTRVJUKG1fbmFtZVRvR3JvdXBNYXApOworICAgIGlmICgh bV9uYW1lVG9Hcm91cE1hcCkKKyAgICAgICAgcmV0dXJuOworICAgIFJhZGlvQnV0dG9uR3JvdXAq IGdyb3VwID0gbV9uYW1lVG9Hcm91cE1hcC0+Z2V0KGVsZW1lbnQtPm5hbWUoKS5pbXBsKCkpOwor ICAgIEFTU0VSVChncm91cCk7CisgICAgZ3JvdXAtPnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZChl bGVtZW50KTsKIH0KIAogSFRNTElucHV0RWxlbWVudCogQ2hlY2tlZFJhZGlvQnV0dG9uczo6Y2hl Y2tlZEJ1dHRvbkZvckdyb3VwKGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSkgY29uc3QKIHsKLSAg ICBpZiAoIW1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwKQorICAgIGlmICghbV9uYW1lVG9H cm91cE1hcCkKICAgICAgICAgcmV0dXJuIDA7CisgICAgbV9uYW1lVG9Hcm91cE1hcC0+Y2hlY2tD b25zaXN0ZW5jeSgpOworICAgIFJhZGlvQnV0dG9uR3JvdXAqIGdyb3VwID0gbV9uYW1lVG9Hcm91 cE1hcC0+Z2V0KG5hbWUuaW1wbCgpKTsKKyAgICByZXR1cm4gZ3JvdXAgPyBncm91cC0+Y2hlY2tl ZEJ1dHRvbigpIDogMDsKK30KIAotICAgIG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwLT5j aGVja0NvbnNpc3RlbmN5KCk7Ci0gICAgCi0gICAgcmV0dXJuIG1fbmFtZVRvQ2hlY2tlZFJhZGlv QnV0dG9uTWFwLT5nZXQobmFtZS5pbXBsKCkpOworYm9vbCBDaGVja2VkUmFkaW9CdXR0b25zOjpp c0luUmVxdWlyZWRHcm91cChIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KSBjb25zdAoreworICAg IEFTU0VSVChlbGVtZW50LT5pc1JhZGlvQnV0dG9uKCkpOworICAgIGlmICghZWxlbWVudC0+aW5E b2N1bWVudCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKCFtX25hbWVUb0dyb3Vw TWFwKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBSYWRpb0J1dHRvbkdyb3VwKiBncm91 cCA9IG1fbmFtZVRvR3JvdXBNYXAtPmdldChlbGVtZW50LT5uYW1lKCkuaW1wbCgpKTsKKyAgICBy ZXR1cm4gZ3JvdXAgJiYgZ3JvdXAtPmlzUmVxdWlyZWQoKTsKIH0KIAogdm9pZCBDaGVja2VkUmFk aW9CdXR0b25zOjpyZW1vdmVCdXR0b24oSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKIHsKLSAg ICBpZiAoZWxlbWVudC0+bmFtZSgpLmlzRW1wdHkoKSB8fCAhbV9uYW1lVG9DaGVja2VkUmFkaW9C dXR0b25NYXApCisgICAgaWYgKCFzaG91bGRNYWtlUmFkaW9Hcm91cChlbGVtZW50KSkKICAgICAg ICAgcmV0dXJuOwotICAgIAotICAgIG1fbmFtZVRvQ2hlY2tlZFJhZGlvQnV0dG9uTWFwLT5jaGVj a0NvbnNpc3RlbmN5KCk7Ci0KLSAgICBOYW1lVG9JbnB1dE1hcDo6aXRlcmF0b3IgaXQgPSBtX25h bWVUb0NoZWNrZWRSYWRpb0J1dHRvbk1hcC0+ZmluZChlbGVtZW50LT5uYW1lKCkuaW1wbCgpKTsK LSAgICBpZiAoaXQgPT0gbV9uYW1lVG9DaGVja2VkUmFkaW9CdXR0b25NYXAtPmVuZCgpIHx8IGl0 LT5zZWNvbmQgIT0gZWxlbWVudCkKKyAgICBpZiAoIW1fbmFtZVRvR3JvdXBNYXApCiAgICAgICAg IHJldHVybjsKLSAgICAKLSAgICBBU1NFUlQoZWxlbWVudC0+c2hvdWxkQXBwZWFyQ2hlY2tlZCgp KTsKLSAgICBBU1NFUlQoZWxlbWVudC0+aXNSYWRpb0J1dHRvbigpKTsKIAotICAgIG1fbmFtZVRv Q2hlY2tlZFJhZGlvQnV0dG9uTWFwLT5yZW1vdmUoaXQpOwotICAgIGlmIChtX25hbWVUb0NoZWNr ZWRSYWRpb0J1dHRvbk1hcC0+aXNFbXB0eSgpKQotICAgICAgICBtX25hbWVUb0NoZWNrZWRSYWRp b0J1dHRvbk1hcC5jbGVhcigpOworICAgIG1fbmFtZVRvR3JvdXBNYXAtPmNoZWNrQ29uc2lzdGVu Y3koKTsKKyAgICBOYW1lVG9Hcm91cE1hcDo6aXRlcmF0b3IgaXQgPSBtX25hbWVUb0dyb3VwTWFw LT5maW5kKGVsZW1lbnQtPm5hbWUoKS5pbXBsKCkpOworICAgIGlmIChpdCA9PSBtX25hbWVUb0dy b3VwTWFwLT5lbmQoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGl0LT5zZWNvbmQtPnJlbW92ZShl bGVtZW50KTsKKyAgICBpZiAoaXQtPnNlY29uZC0+aXNFbXB0eSgpKSB7CisgICAgICAgIC8vIEZJ WE1FOiBXZSBtYXkgc2tpcCBkZWFsbG9jYXRpbmcgdGhlIGVtcHR5IFJhZGlvQnV0dG9uR3JvdXAg Zm9yCisgICAgICAgIC8vIHBlcmZvcm1hbmNlIGltcHJvdmVtZW50LiBJZiB3ZSBkbyBzbywgd2Ug bmVlZCB0byBjaGFuZ2UgdGhlIGtleSB0eXBlCisgICAgICAgIC8vIG9mIG1fbmFtZVRvR3JvdXBN YXAgZnJvbSBBdG9taWNTdHJpbmdJbXBsKiB0byBSZWZQdHI8QXRvbWljU3RyaW5nSW1wbD4uCisg ICAgICAgIG1fbmFtZVRvR3JvdXBNYXAtPnJlbW92ZShpdCk7CisgICAgICAgIGlmIChtX25hbWVU b0dyb3VwTWFwLT5pc0VtcHR5KCkpCisgICAgICAgICAgICBtX25hbWVUb0dyb3VwTWFwLmNsZWFy KCk7CisgICAgfQogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9DaGVja2Vk UmFkaW9CdXR0b25zLmgKaW5kZXggOTI1YjUwNjc4MmE0MWMyN2QxNTQ3ZWYwMTk5YWQ5NWY1YmRh MzIyNy4uZjA1MGZhYTQ4YzE2MjQ0Yzk3NDVlMzAxOTA3MmFmNjE3MWY0OTQ3MiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvZG9tL0NoZWNrZWRSYWRpb0J1dHRvbnMuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9kb20vQ2hlY2tlZFJhZGlvQnV0dG9ucy5oCkBAIC0yOCwxNiArMjgsMjQgQEAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgSFRNTElucHV0RWxlbWVudDsKK2NsYXNzIFJhZGlv QnV0dG9uR3JvdXA7CiAKKy8vIEZJWE1FOiBSZW5hbWUgdGhlIGNsYXNzLiBUaGUgY2xhc3Mgd2Fz IGEgc2ltcGxlIG1hcCBmcm9tIGEgbmFtZSB0byBhIGNoZWNrZWQKKy8vIHJhZGlvIGJ1dHRvbi4g SXQgbWFuYWdlcyBSYWRpb0J1dHRvbkdyb3VwIG9iamVjdHMgbm93LgogY2xhc3MgQ2hlY2tlZFJh ZGlvQnV0dG9ucyB7CiBwdWJsaWM6CisgICAgQ2hlY2tlZFJhZGlvQnV0dG9ucygpOworICAgIH5D aGVja2VkUmFkaW9CdXR0b25zKCk7CiAgICAgdm9pZCBhZGRCdXR0b24oSFRNTElucHV0RWxlbWVu dCopOworICAgIHZvaWQgdXBkYXRlQ2hlY2tlZFN0YXRlKEhUTUxJbnB1dEVsZW1lbnQqKTsKKyAg ICB2b2lkIHJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZChIVE1MSW5wdXRFbGVtZW50Kik7CiAgICAg dm9pZCByZW1vdmVCdXR0b24oSFRNTElucHV0RWxlbWVudCopOwogICAgIEhUTUxJbnB1dEVsZW1l bnQqIGNoZWNrZWRCdXR0b25Gb3JHcm91cChjb25zdCBBdG9taWNTdHJpbmcmIGdyb3VwTmFtZSkg Y29uc3Q7CisgICAgYm9vbCBpc0luUmVxdWlyZWRHcm91cChIVE1MSW5wdXRFbGVtZW50KikgY29u c3Q7CiAKIHByaXZhdGU6Ci0gICAgdHlwZWRlZiBIYXNoTWFwPEF0b21pY1N0cmluZ0ltcGwqLCBI VE1MSW5wdXRFbGVtZW50Kj4gTmFtZVRvSW5wdXRNYXA7Ci0gICAgT3duUHRyPE5hbWVUb0lucHV0 TWFwPiBtX25hbWVUb0NoZWNrZWRSYWRpb0J1dHRvbk1hcDsKKyAgICB0eXBlZGVmIEhhc2hNYXA8 QXRvbWljU3RyaW5nSW1wbCosIE93blB0cjxSYWRpb0J1dHRvbkdyb3VwPiA+IE5hbWVUb0dyb3Vw TWFwOworICAgIE93blB0cjxOYW1lVG9Hcm91cE1hcD4gbV9uYW1lVG9Hcm91cE1hcDsKIH07CiAK IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv Q2hlY2tib3hJbnB1dFR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9DaGVja2JveElucHV0 VHlwZS5jcHAKaW5kZXggZGRhMTcyYWVjNzgzZmQxZThjMGQ3NThmOWNlNWI3YmZkMDlmNGZmYi4u ZWQ4MzUxN2I5MTQ2ZWIxODgzOWNjNTIzYTQ1ZmJmNjE5MzI0Zjg3YyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaHRtbC9DaGVja2JveElucHV0VHlwZS5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvaHRtbC9DaGVja2JveElucHV0VHlwZS5jcHAKQEAgLTUxLDcgKzUxLDcgQEAgY29uc3QgQXRv bWljU3RyaW5nJiBDaGVja2JveElucHV0VHlwZTo6Zm9ybUNvbnRyb2xUeXBlKCkgY29uc3QKIAog Ym9vbCBDaGVja2JveElucHV0VHlwZTo6dmFsdWVNaXNzaW5nKGNvbnN0IFN0cmluZyYpIGNvbnN0 CiB7Ci0gICAgcmV0dXJuICFlbGVtZW50KCktPmNoZWNrZWQoKTsKKyAgICByZXR1cm4gZWxlbWVu dCgpLT5yZXF1aXJlZCgpICYmICFlbGVtZW50KCktPmNoZWNrZWQoKTsKIH0KIAogU3RyaW5nIENo ZWNrYm94SW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmdUZXh0KCkgY29uc3QKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvRmlsZUlucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0ZpbGVJbnB1dFR5cGUuY3BwCmluZGV4IDY1NWU4MWVhZGJjNzMxMTljNTAwYjZkNTU5NzA5MmIw ODU0ZjJlMDcuLjc2ZWZhNDE3ODY2OThiZDRmNjk1Nzk3Yzk1ZjNhNzMyZDIzMDI2NmIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvRmlsZUlucHV0VHlwZS5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmNwcApAQCAtMTI5LDcgKzEyOSw3IEBAIGJvb2wg RmlsZUlucHV0VHlwZTo6YXBwZW5kRm9ybURhdGEoRm9ybURhdGFMaXN0JiBlbmNvZGluZywgYm9v bCBtdWx0aXBhcnQpIGNvbnN0CiAKIGJvb2wgRmlsZUlucHV0VHlwZTo6dmFsdWVNaXNzaW5nKGNv bnN0IFN0cmluZyYgdmFsdWUpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIHZhbHVlLmlzRW1wdHkoKTsK KyAgICByZXR1cm4gZWxlbWVudCgpLT5yZXF1aXJlZCgpICYmIHZhbHVlLmlzRW1wdHkoKTsKIH0K IAogU3RyaW5nIEZpbGVJbnB1dFR5cGU6OnZhbHVlTWlzc2luZ1RleHQoKSBjb25zdApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcCBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAKaW5kZXggNmUyZWQ2 Y2ZjODYwMTUxY2YzYjRjMWEzZjAxYWJlYTVlMzJiMzQxYi4uMmIwNmYzZDA0MDliMjVlNjRlMTU3 YjA3Mzk5NWMxMDAzNjBkZGY0ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M Rm9ybUNvbnRyb2xFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3Jt Q29udHJvbEVsZW1lbnQuY3BwCkBAIC0xMjIsMTUgKzEyMiwyMSBAQCB2b2lkIEhUTUxGb3JtQ29u dHJvbEVsZW1lbnQ6OnBhcnNlTWFwcGVkQXR0cmlidXRlKEF0dHJpYnV0ZSogYXR0cikKICAgICB9 IGVsc2UgaWYgKGF0dHItPm5hbWUoKSA9PSByZXF1aXJlZEF0dHIpIHsKICAgICAgICAgYm9vbCBv bGRSZXF1aXJlZCA9IG1fcmVxdWlyZWQ7CiAgICAgICAgIG1fcmVxdWlyZWQgPSAhYXR0ci0+aXNO dWxsKCk7Ci0gICAgICAgIGlmIChvbGRSZXF1aXJlZCAhPSBtX3JlcXVpcmVkKSB7Ci0gICAgICAg ICAgICBzZXROZWVkc1ZhbGlkaXR5Q2hlY2soKTsKLSAgICAgICAgICAgIHNldE5lZWRzU3R5bGVS ZWNhbGMoKTsgLy8gVXBkYXRlcyBmb3IgOnJlcXVpcmVkIDpvcHRpb25hbCBjbGFzc2VzLgotICAg ICAgICB9CisgICAgICAgIGlmIChvbGRSZXF1aXJlZCAhPSBtX3JlcXVpcmVkKQorICAgICAgICAg ICAgcmVxdWlyZWRBdHRyaWJ1dGVDaGFuZ2VkKCk7CiAgICAgfSBlbHNlCiAgICAgICAgIEhUTUxF bGVtZW50OjpwYXJzZU1hcHBlZEF0dHJpYnV0ZShhdHRyKTsKICAgICBzZXROZWVkc1dpbGxWYWxp ZGF0ZUNoZWNrKCk7CiB9CiAKK3ZvaWQgSFRNTEZvcm1Db250cm9sRWxlbWVudDo6cmVxdWlyZWRB dHRyaWJ1dGVDaGFuZ2VkKCkKK3sKKyAgICBzZXROZWVkc1ZhbGlkaXR5Q2hlY2soKTsKKyAgICAv LyBTdHlsZSByZWNhbGN1bGF0aW9uIGlzIG5lZWRlZCBiZWNhdXNlIHN0eWxlIHNlbGVjdG9ycyBt YXkgaW5jbHVkZQorICAgIC8vIDpyZXF1aXJlZCBhbmQgOm9wdGlvbmFsIHBzZXVkby1jbGFzc2Vz LgorICAgIHNldE5lZWRzU3R5bGVSZWNhbGMoKTsKK30KKwogc3RhdGljIGJvb2wgc2hvdWxkQXV0 b2ZvY3VzKEhUTUxGb3JtQ29udHJvbEVsZW1lbnQqIGVsZW1lbnQpCiB7CiAgICAgaWYgKCFlbGVt ZW50LT5hdXRvZm9jdXMoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZv cm1Db250cm9sRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xF bGVtZW50LmgKaW5kZXggZjUwMGI2ZGY5YjI2NWVkNThjMTU3MzI5M2Y5ZjA1ZWY2NjZkMDdiYy4u ZWRjNDA2ZjUxYTMyYWQxOGI5OTYyNzdkOGU4ZjE5YzQwODE5YzVlMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKKysrIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKQEAgLTExNSw2ICsxMTUsNyBAQCBw cm90ZWN0ZWQ6CiAgICAgSFRNTEZvcm1Db250cm9sRWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1l JiB0YWdOYW1lLCBEb2N1bWVudCosIEhUTUxGb3JtRWxlbWVudCopOwogCiAgICAgdmlydHVhbCB2 b2lkIHBhcnNlTWFwcGVkQXR0cmlidXRlKEF0dHJpYnV0ZSopOworICAgIHZpcnR1YWwgdm9pZCBy ZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQoKTsKICAgICB2aXJ0dWFsIHZvaWQgYXR0YWNoKCk7CiAg ICAgdmlydHVhbCB2b2lkIGluc2VydGVkSW50b1RyZWUoYm9vbCBkZWVwKTsKICAgICB2aXJ0dWFs IHZvaWQgcmVtb3ZlZEZyb21UcmVlKGJvb2wgZGVlcCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M SW5wdXRFbGVtZW50LmNwcAppbmRleCA3NTAxYmM0MzY5MDgzZTk4N2EzZWI4ZWViMGIzNTM4M2Nm ZTk5YjY3Li5lY2RlMGI3Njg4ZDk4YTRmN2QxNTRmNmZkMTk5MTViMTVkMGUwMTUwIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKQEAgLTE3OCwzOCArMTc4LDYgQEAg Ym9vbCBIVE1MSW5wdXRFbGVtZW50OjpzaG91bGRBdXRvY29tcGxldGUoKSBjb25zdAogICAgIHJl dHVybiBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6c2hvdWxkQXV0b2NvbXBsZXRlKCk7CiB9 CiAKLXZvaWQgSFRNTElucHV0RWxlbWVudDo6dXBkYXRlQ2hlY2tlZFJhZGlvQnV0dG9ucygpCi17 Ci0gICAgY2hlY2tlZFJhZGlvQnV0dG9ucygpLmFkZEJ1dHRvbih0aGlzKTsKLQotICAgIGlmIChm b3JtKCkpIHsKLSAgICAgICAgY29uc3QgVmVjdG9yPEZvcm1Bc3NvY2lhdGVkRWxlbWVudCo+JiBj b250cm9scyA9IGZvcm0oKS0+YXNzb2NpYXRlZEVsZW1lbnRzKCk7Ci0gICAgICAgIGZvciAodW5z aWduZWQgaSA9IDA7IGkgPCBjb250cm9scy5zaXplKCk7ICsraSkgewotICAgICAgICAgICAgaWYg KCFjb250cm9sc1tpXS0+aXNGb3JtQ29udHJvbEVsZW1lbnQoKSkKLSAgICAgICAgICAgICAgICBj b250aW51ZTsKLSAgICAgICAgICAgIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQqIGNvbnRyb2wgPSBz dGF0aWNfY2FzdDxIVE1MRm9ybUNvbnRyb2xFbGVtZW50Kj4oY29udHJvbHNbaV0pOwotICAgICAg ICAgICAgaWYgKGNvbnRyb2wtPm5hbWUoKSAhPSBuYW1lKCkpCi0gICAgICAgICAgICAgICAgY29u dGludWU7Ci0gICAgICAgICAgICBpZiAoY29udHJvbC0+dHlwZSgpICE9IHR5cGUoKSkKLSAgICAg ICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIGNvbnRyb2wtPnNldE5lZWRzVmFsaWRp dHlDaGVjaygpOwotICAgICAgICB9Ci0gICAgfSBlbHNlIHsKLSAgICAgICAgdHlwZWRlZiBEb2N1 bWVudDo6Rm9ybUVsZW1lbnRMaXN0SGFzaFNldDo6Y29uc3RfaXRlcmF0b3IgSXRlcmF0b3I7Ci0g ICAgICAgIEl0ZXJhdG9yIGVuZCA9IGRvY3VtZW50KCktPmZvcm1FbGVtZW50cygpLT5lbmQoKTsK LSAgICAgICAgZm9yIChJdGVyYXRvciBpdCA9IGRvY3VtZW50KCktPmZvcm1FbGVtZW50cygpLT5i ZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKLSAgICAgICAgICAgIEhUTUxGb3JtQ29udHJvbEVs ZW1lbnRXaXRoU3RhdGUqIGNvbnRyb2wgPSAqaXQ7Ci0gICAgICAgICAgICBpZiAoY29udHJvbC0+ Zm9ybUNvbnRyb2xOYW1lKCkgIT0gbmFtZSgpKQotICAgICAgICAgICAgICAgIGNvbnRpbnVlOwot ICAgICAgICAgICAgaWYgKGNvbnRyb2wtPmZvcm1Db250cm9sVHlwZSgpICE9IHR5cGUoKSkKLSAg ICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgIGlmIChjb250cm9sLT5mb3JtKCkp Ci0gICAgICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAgICAgICBjb250cm9sLT5zZXROZWVk c1ZhbGlkaXR5Q2hlY2soKTsKLSAgICAgICAgfQotICAgIH0KLX0KLQogYm9vbCBIVE1MSW5wdXRF bGVtZW50Ojppc1ZhbGlkVmFsdWUoY29uc3QgU3RyaW5nJiB2YWx1ZSkgY29uc3QKIHsKICAgICBp ZiAoIW1faW5wdXRUeXBlLT5jYW5TZXRTdHJpbmdWYWx1ZSgpKSB7CkBAIC0yMzIsOCArMjAwLDYg QEAgYm9vbCBIVE1MSW5wdXRFbGVtZW50Ojp0eXBlTWlzbWF0Y2goKSBjb25zdAogCiBib29sIEhU TUxJbnB1dEVsZW1lbnQ6OnZhbHVlTWlzc2luZyhjb25zdCBTdHJpbmcmIHZhbHVlKSBjb25zdAog ewotICAgIGlmICghaXNSZXF1aXJlZEZvcm1Db250cm9sKCkgfHwgcmVhZE9ubHkoKSB8fCBkaXNh YmxlZCgpKQotICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgcmV0dXJuIG1faW5wdXRUeXBlLT52 YWx1ZU1pc3NpbmcodmFsdWUpOwogfQogCkBAIC05NjMsMTMgKzkyOSwxMSBAQCB2b2lkIEhUTUxJ bnB1dEVsZW1lbnQ6OnNldENoZWNrZWQoYm9vbCBub3dDaGVja2VkLCBib29sIHNlbmRDaGFuZ2VF dmVudCkKICAgICBpZiAoY2hlY2tlZCgpID09IG5vd0NoZWNrZWQpCiAgICAgICAgIHJldHVybjsK IAotICAgIGNoZWNrZWRSYWRpb0J1dHRvbnMoKS5yZW1vdmVCdXR0b24odGhpcyk7Ci0KICAgICBt X3JlZmxlY3RzQ2hlY2tlZEF0dHJpYnV0ZSA9IGZhbHNlOwogICAgIG1faXNDaGVja2VkID0gbm93 Q2hlY2tlZDsKICAgICBzZXROZWVkc1N0eWxlUmVjYWxjKCk7CiAgICAgaWYgKGlzUmFkaW9CdXR0 b24oKSkKLSAgICAgICAgdXBkYXRlQ2hlY2tlZFJhZGlvQnV0dG9ucygpOworICAgICAgICBjaGVj a2VkUmFkaW9CdXR0b25zKCkudXBkYXRlQ2hlY2tlZFN0YXRlKHRoaXMpOwogICAgIGlmIChyZW5k ZXJlcigpICYmIHJlbmRlcmVyKCktPnN0eWxlKCktPmhhc0FwcGVhcmFuY2UoKSkKICAgICAgICAg cmVuZGVyZXIoKS0+dGhlbWUoKS0+c3RhdGVDaGFuZ2VkKHJlbmRlcmVyKCksIENoZWNrZWRTdGF0 ZSk7CiAgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7CkBAIC0xNTU5LDYgKzE1MjMsMTIgQEAg Ym9vbCBIVE1MSW5wdXRFbGVtZW50OjpyZWNhbGNXaWxsVmFsaWRhdGUoKSBjb25zdAogICAgIHJl dHVybiBtX2lucHV0VHlwZS0+c3VwcG9ydHNWYWxpZGF0aW9uKCkgJiYgSFRNTFRleHRGb3JtQ29u dHJvbEVsZW1lbnQ6OnJlY2FsY1dpbGxWYWxpZGF0ZSgpOwogfQogCit2b2lkIEhUTUxJbnB1dEVs ZW1lbnQ6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpCit7CisgICAgSFRNTFRleHRGb3JtQ29u dHJvbEVsZW1lbnQ6OnJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpOworICAgIGNoZWNrZWRSYWRp b0J1dHRvbnMoKS5yZXF1aXJlZEF0dHJpYnV0ZUNoYW5nZWQodGhpcyk7Cit9CisKICNpZiBFTkFC TEUoSU5QVVRfQ09MT1IpCiB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnNlbGVjdENvbG9ySW5Db2xv ckNob29zZXIoY29uc3QgQ29sb3ImIGNvbG9yKQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1 dEVsZW1lbnQuaAppbmRleCBmYzZmMDY4MjhmOTg3YmM4ZTBkNzU5YzUyOWM5MGJiM2VjNzE5NTVi Li40N2FjNGQzMjYyMjYwODJhYjgwNTJhM2Y2NzQ3MDhjMTM5ZjNmYjhmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaApAQCAtMzIxLDYgKzMyMSw3IEBAIHByaXZhdGU6CiAg ICAgdmlydHVhbCBib29sIGlzT3B0aW9uYWxGb3JtQ29udHJvbCgpIGNvbnN0IHsgcmV0dXJuICFp c1JlcXVpcmVkRm9ybUNvbnRyb2woKTsgfQogICAgIHZpcnR1YWwgYm9vbCBpc1JlcXVpcmVkRm9y bUNvbnRyb2woKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgcmVjYWxjV2lsbFZhbGlkYXRlKCkg Y29uc3Q7CisgICAgdmlydHVhbCB2b2lkIHJlcXVpcmVkQXR0cmlidXRlQ2hhbmdlZCgpIE9WRVJS SURFOwogCiAgICAgdm9pZCB1cGRhdGVUeXBlKCk7CiAgICAgCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFk aW9JbnB1dFR5cGUuY3BwCmluZGV4IDdlNjk1MTdhMzUzMjk0N2FmOTFkNGI1NDA2MmE4YjE3OGJm ODA3YWYuLmJhZWM5ZTg2MWI4MWEyMWY2NTE3NDJiZjNlYjRiYjE3MTZhMzllNjIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuY3BwCkBAIC00OCw3ICs0OCw3IEBAIGNvbnN0IEF0 b21pY1N0cmluZyYgUmFkaW9JbnB1dFR5cGU6OmZvcm1Db250cm9sVHlwZSgpIGNvbnN0CiAKIGJv b2wgUmFkaW9JbnB1dFR5cGU6OnZhbHVlTWlzc2luZyhjb25zdCBTdHJpbmcmKSBjb25zdAogewot ICAgIHJldHVybiAhZWxlbWVudCgpLT5jaGVja2VkUmFkaW9CdXR0b25zKCkuY2hlY2tlZEJ1dHRv bkZvckdyb3VwKGVsZW1lbnQoKS0+bmFtZSgpKTsKKyAgICByZXR1cm4gZWxlbWVudCgpLT5jaGVj a2VkUmFkaW9CdXR0b25zKCkuaXNJblJlcXVpcmVkR3JvdXAoZWxlbWVudCgpKSAmJiAhZWxlbWVu dCgpLT5jaGVja2VkUmFkaW9CdXR0b25zKCkuY2hlY2tlZEJ1dHRvbkZvckdyb3VwKGVsZW1lbnQo KS0+bmFtZSgpKTsKIH0KIAogU3RyaW5nIFJhZGlvSW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmdUZXh0 KCkgY29uc3QKQEAgLTEzMywxMiArMTMzLDYgQEAgYm9vbCBSYWRpb0lucHV0VHlwZTo6aXNLZXli b2FyZEZvY3VzYWJsZSgpIGNvbnN0CiAgICAgcmV0dXJuIGVsZW1lbnQoKS0+Y2hlY2tlZCgpIHx8 ICFlbGVtZW50KCktPmNoZWNrZWRSYWRpb0J1dHRvbnMoKS5jaGVja2VkQnV0dG9uRm9yR3JvdXAo ZWxlbWVudCgpLT5uYW1lKCkpOwogfQogCi12b2lkIFJhZGlvSW5wdXRUeXBlOjphdHRhY2goKQot ewotICAgIElucHV0VHlwZTo6YXR0YWNoKCk7Ci0gICAgZWxlbWVudCgpLT51cGRhdGVDaGVja2Vk UmFkaW9CdXR0b25zKCk7Ci19Ci0KIGJvb2wgUmFkaW9JbnB1dFR5cGU6OnNob3VsZFNlbmRDaGFu Z2VFdmVudEFmdGVyQ2hlY2tlZENoYW5nZWQoKQogewogICAgIC8vIERvbid0IHNlbmQgYSBjaGFu Z2UgZXZlbnQgZm9yIGEgcmFkaW8gYnV0dG9uIHRoYXQncyBnZXR0aW5nIHVuY2hlY2tlZC4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuaCBiL1NvdXJjZS9X ZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuaAppbmRleCA1MjVlZDY5MWNmNGIwZDIwOTk4NmY2 OWYxZDgxM2NiZjJlOGVjMzBlLi45Y2VmZTUxNmJkNmU1OGU2NzNiOWNkODc4OWIwZWVhMjFjY2E0 ZGIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmgKKysr IGIvU291cmNlL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlwZS5oCkBAIC00OCw3ICs0OCw2IEBA IHByaXZhdGU6CiAgICAgdmlydHVhbCB2b2lkIGhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2 ZW50KikgT1ZFUlJJREU7CiAgICAgdmlydHVhbCB2b2lkIGhhbmRsZUtleXVwRXZlbnQoS2V5Ym9h cmRFdmVudCopIE9WRVJSSURFOwogICAgIHZpcnR1YWwgYm9vbCBpc0tleWJvYXJkRm9jdXNhYmxl KCkgY29uc3QgT1ZFUlJJREU7Ci0gICAgdmlydHVhbCB2b2lkIGF0dGFjaCgpIE9WRVJSSURFOwog ICAgIHZpcnR1YWwgYm9vbCBzaG91bGRTZW5kQ2hhbmdlRXZlbnRBZnRlckNoZWNrZWRDaGFuZ2Vk KCkgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBQYXNzT3duUHRyPENsaWNrSGFuZGxpbmdTdGF0ZT4g d2lsbERpc3BhdGNoQ2xpY2soKSBPVkVSUklERTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkRGlzcGF0 Y2hDbGljayhFdmVudCosIGNvbnN0IENsaWNrSGFuZGxpbmdTdGF0ZSYpIE9WRVJSSURFOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwCmluZGV4IGM5YzkwODMzNTcy NjMzZThjMWZkOTQ3YTc1NzhmMzE0YjIzNzI4ZTYuLjM3ZTBiOWY1Yjg1NDk0NTQzNzc4YzE5MjMw YWZlM2VlZTY2MWNkMjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxk SW5wdXRUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlw ZS5jcHAKQEAgLTY5LDcgKzY5LDcgQEAgYm9vbCBUZXh0RmllbGRJbnB1dFR5cGU6OmlzVGV4dEZp ZWxkKCkgY29uc3QKIAogYm9vbCBUZXh0RmllbGRJbnB1dFR5cGU6OnZhbHVlTWlzc2luZyhjb25z dCBTdHJpbmcmIHZhbHVlKSBjb25zdAogewotICAgIHJldHVybiB2YWx1ZS5pc0VtcHR5KCk7Cisg ICAgcmV0dXJuIGVsZW1lbnQoKS0+cmVxdWlyZWQoKSAmJiB2YWx1ZS5pc0VtcHR5KCk7CiB9CiAK IGJvb2wgVGV4dEZpZWxkSW5wdXRUeXBlOjpjYW5TZXRTdWdnZXN0ZWRWYWx1ZSgpCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXgg NGU0YjM1NTRjM2Q4M2VjZWVmN2ExMDAwNWFlYzUyYWZhYzNiZjA3YS4uYjhmNjJhOTE0MjVhNDdj OTQzNzkxODI0NWZjOGVmYTA0Y2NmNzJhZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTAx LTIzICBLZW50IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KKworICAgICAgICBJbnRyb2R1 Y2UgUmFkaW9CdXR0b25Hcm91cCBjbGFzcyB0byBrZWVwIHRyYWNrIG9mIHRoZSBncm91cCBtZW1i ZXJzIGFuZCByZXF1aXJlZCBzdGF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NzQ5MDkKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4K KworICAgICAgICAqIGZhc3QvZm9ybXMvcmFkaW8vcmFkaW8tbGl2ZS12YWxpZGF0aW9uLXN0eWxl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9mb3Jtcy9yYWRpby9yYWRpby1s aXZlLXZhbGlkYXRpb24tc3R5bGUuaHRtbDogQWRkZWQuCisKKyAgICAgICAgKiBmYXN0L2Zvcm1z L3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXZhbHVlTWlzc2luZy1yYWRpby5qczoKKyAgICAg ICAgLSBVcGRhdGUgdGhlIGV4cGVjdGF0aW9uIGZvciB0aGUgYmVoYXZpb3IgY2hhbmdlIG9mCisg ICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc2MzY1Cisg ICAgICAgIC0gQWRkIHRlc3QgY2FzZXMgZm9yIHJhZGlvIGJ1dHRvbnMgbm90IGluIGEgcmFkaW8g YnV0dG9uIGdyb3VwLgorICAgICAgICAqIGZhc3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS12YWx1ZU1p c3NpbmctcmFkaW8tZXhwZWN0ZWQudHh0OiBkaXR0by4KKworICAgICAgICAqIHBlcmYvYWRkaW5n LXJhZGlvLWJ1dHRvbnMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwZXJmL2FkZGlu Zy1yYWRpby1idXR0b25zLmh0bWw6IEFkZGVkLgorCiAyMDEyLTAxLTIyICBOaWtvbGFzIFppbW1l cm1hbm4gIDxuemltbWVybWFubkByaW0uY29tPgogCiAgICAgICAgIE5vdCByZXZpZXdlZC4gRml4 IHR5cG8sIHdoaWNoIG1ha2VzIHRoZSBzdHlsZSBib3Qgd2FybiBvbiBldmVyeSBwYXRjaC4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS12YWx1ZU1pc3Np bmctcmFkaW8tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0 YXRlLXZhbHVlTWlzc2luZy1yYWRpby1leHBlY3RlZC50eHQKaW5kZXggZjA5ZGRlYjdlNmI2MzE4 NDE4YTY4Y2RkMjFjMmI0ZDNlMDQ1NzViYi4uNGQ5MDEzMzc3NjFlMTAyOGM1ZTFiZjJmNzFkODY4 NTNhZDU2OWNjOCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0 YXRlLXZhbHVlTWlzc2luZy1yYWRpby1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy9WYWxpZGl0eVN0YXRlLXZhbHVlTWlzc2luZy1yYWRpby1leHBlY3RlZC50eHQKQEAg LTYsOCArNiw4IEBAIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIg bWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFCiBXaXRob3V0IGZvcm0gZWxlbWVu dAogTm8gY2hlY2tlZCBidXR0b246CiBQQVNTIGlucHV0c1swXS52YWxpZGl0eS52YWx1ZU1pc3Np bmcgaXMgdHJ1ZQotUEFTUyBpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVNaXNzaW5nIGlzIGZhbHNl Ci1QQVNTIGlucHV0c1syXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgZmFsc2UKK1BBU1MgaW5w dXRzWzFdLnZhbGlkaXR5LnZhbHVlTWlzc2luZyBpcyB0cnVlCitQQVNTIGlucHV0c1syXS52YWxp ZGl0eS52YWx1ZU1pc3NpbmcgaXMgdHJ1ZQogVGhlIHNlY29uZCBidXR0b24gaGFzIGJlZW4gY2hl Y2tlZDoKIFBBU1MgaW5wdXRzWzBdLnZhbGlkaXR5LnZhbHVlTWlzc2luZyBpcyBmYWxzZQogUEFT UyBpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVNaXNzaW5nIGlzIGZhbHNlCkBAIC0yMCwxMSArMjAs MTIgQEAgVGhlIHRoaXJkIGJ1dHRvbiBoYXMgYmVlbiBjaGVja2VkOgogUEFTUyBpbnB1dHNbMF0u dmFsaWRpdHkudmFsdWVNaXNzaW5nIGlzIGZhbHNlCiBQQVNTIGlucHV0c1sxXS52YWxpZGl0eS52 YWx1ZU1pc3NpbmcgaXMgZmFsc2UKIFBBU1MgaW5wdXRzWzJdLnZhbGlkaXR5LnZhbHVlTWlzc2lu ZyBpcyBmYWxzZQorCiBXaXRoIGZvcm0gZWxlbWVudAogTm8gY2hlY2tlZCBidXR0b246CiBQQVNT IGlucHV0c1swXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgdHJ1ZQotUEFTUyBpbnB1dHNbMV0u dmFsaWRpdHkudmFsdWVNaXNzaW5nIGlzIGZhbHNlCi1QQVNTIGlucHV0c1syXS52YWxpZGl0eS52 YWx1ZU1pc3NpbmcgaXMgZmFsc2UKK1BBU1MgaW5wdXRzWzFdLnZhbGlkaXR5LnZhbHVlTWlzc2lu ZyBpcyB0cnVlCitQQVNTIGlucHV0c1syXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgdHJ1ZQog VGhlIGZpcnN0IGJ1dHRvbiBoYXMgYmVlbiBjaGVja2VkOgogUEFTUyBpbnB1dHNbMF0udmFsaWRp dHkudmFsdWVNaXNzaW5nIGlzIGZhbHNlCiBQQVNTIGlucHV0c1sxXS52YWxpZGl0eS52YWx1ZU1p c3NpbmcgaXMgZmFsc2UKQEAgLTM3LDYgKzM4LDEzIEBAIFRoZSB0aGlyZCBidXR0b24gaGFzIGJl ZW4gY2hlY2tlZDoKIFBBU1MgaW5wdXRzWzBdLnZhbGlkaXR5LnZhbHVlTWlzc2luZyBpcyBmYWxz ZQogUEFTUyBpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVNaXNzaW5nIGlzIGZhbHNlCiBQQVNTIGlu cHV0c1syXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgZmFsc2UKKworTm90IGluIGEgcmFkaW8g YnV0dG9uIGdyb3VwCitQQVNTIHJlcXVpcmVkQnV0dG9uLnZhbGlkaXR5LnZhbHVlTWlzc2luZyBp cyBmYWxzZQorUEFTUyByZXF1aXJlZEJ1dHRvbi52YWxpZGl0eS52YWx1ZU1pc3NpbmcgaXMgdHJ1 ZQorUEFTUyBidXR0b24udmFsaWRpdHkudmFsdWVNaXNzaW5nIGlzIHRydWUKK1BBU1MgYnV0dG9u LnZhbGlkaXR5LnZhbHVlTWlzc2luZyBpcyBmYWxzZQorUEFTUyByZXF1aXJlZEJ1dHRvbi52YWxp ZGl0eS52YWx1ZU1pc3NpbmcgaXMgZmFsc2UKIFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRy dWUKIAogVEVTVCBDT01QTEVURQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9y YWRpby9yYWRpby1saXZlLXZhbGlkYXRpb24tc3R5bGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9mb3Jtcy9yYWRpby9yYWRpby1saXZlLXZhbGlkYXRpb24tc3R5bGUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjUyMDIyNWJhYjQ3YjBkYTFlMjYzOTUxOTY5NjdjMTI5MzUxZWE4OTYK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3JhZGlvL3JhZGlvLWxp dmUtdmFsaWRhdGlvbi1zdHlsZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw0NSBAQAorQ2hlY2sg aWYgOnZhbGlkLzppbnZhbGlkIENTUyBwc2V1ZG8gc2VsZWN0b3JzIGFyZSBsaXZlbHkgYXBwbGll ZAorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2Vz LCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUmVtb3ZpbmcgYSBjaGVja2VkIHJh ZGlvIGJ1dHRvbiBmcm9tIGEgcmVxdWlyZWQgcmFkaW8gYnV0dG9uIGdyb3VwIGJ5IGEgRE9NIHRy ZWUgbXV0YXRpb246CitQQVNTIGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSkgaXMgdmFsaWRDb2xv cgorUEFTUyBwYXJlbnQucmVtb3ZlQ2hpbGQoJCgicmFkaW8yIikpOyBiYWNrZ3JvdW5kT2YoJCgi cmFkaW8xIikpIGlzIGludmFsaWRDb2xvcgorCitSZW1vdmluZyBhIGNoZWNrZWQgcmFkaW8gYnV0 dG9uIGZyb20gYSByZXF1aXJlZCByYWRpbyBidXR0b24gZ3JvdXAgYnkgbmFtZSBhdHRyaWJ1dGUg Y2hhbmdlOgorUEFTUyAkKCJyYWRpbzIiKS5uYW1lID0gImdyb3VwMiI7IGJhY2tncm91bmRPZigk KCJyYWRpbzEiKSkgaXMgaW52YWxpZENvbG9yCisKK1JlbW92aW5nIGEgY2hlY2tlZCByYWRpbyBi dXR0b24gZnJvbSBhIHJlcXVpcmVkIHJhZGlvIGJ1dHRvbiBncm91cCBieSB0eXBlIGNoYW5nZToK K1BBU1MgJCgicmFkaW8yIikudHlwZSA9ICJ0ZXh0IjsgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIp KSBpcyBpbnZhbGlkQ29sb3IKKworTWFrZSBhIHJhZGlvIGJ1dHRvbiBncm91cCByZXF1aXJlZCBi eSByZXF1aXJlZCBhdHRyaWJ1dGUgY2hhbmdlOgorUEFTUyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8x IikpIGlzIHZhbGlkQ29sb3IKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlvMiIpKSBpcyB2YWxp ZENvbG9yCitQQVNTICQoInJhZGlvMSIpLnJlcXVpcmVkID0gdHJ1ZTsgYmFja2dyb3VuZE9mKCQo InJhZGlvMSIpKSBpcyBpbnZhbGlkQ29sb3IKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlvMiIp KSBpcyBpbnZhbGlkQ29sb3IKKworTWFrZSBhIHJhZGlvIGJ1dHRvbiBncm91cCBub3QgcmVxdWly ZWQgYnkgcmVxdWlyZWQgYXR0cmlidXRlIGNoYW5nZToKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJh ZGlvMSIpKSBpcyBpbnZhbGlkQ29sb3IKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlvMiIpKSBp cyBpbnZhbGlkQ29sb3IKK1BBU1MgJCgicmFkaW8xIikucmVxdWlyZWQgPSBmYWxzZTsgYmFja2dy b3VuZE9mKCQoInJhZGlvMSIpKSBpcyB2YWxpZENvbG9yCitQQVNTIGJhY2tncm91bmRPZigkKCJy YWRpbzIiKSkgaXMgdmFsaWRDb2xvcgorCitSZW1vdmluZyBvbmUgb2YgbXVsdGlwbGUgcmVxdWly ZWQgYXR0cmlidXRlczoKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKSBpcyBpbnZhbGlk Q29sb3IKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlvMiIpKSBpcyBpbnZhbGlkQ29sb3IKK1BB U1MgJCgicmFkaW8xIikucmVxdWlyZWQgPSBmYWxzZTsgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIp KSBpcyBpbnZhbGlkQ29sb3IKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlvMiIpKSBpcyBpbnZh bGlkQ29sb3IKKworQWRkaW5nIGEgcmFkaW8gYnV0dG9uIHdpdGggdGhlIHJlcXVpcmVkIGF0dHJp YnV0ZSB0byBhIHJhZGlvIGJ1dHRvbiBncm91cDoKK1BBU1MgYmFja2dyb3VuZE9mKCQoInJhZGlv MSIpKSBpcyB2YWxpZENvbG9yCitQQVNTIHBhcmVudC5hcHBlbmRDaGlsZChyZXF1aXJlZFJhZGlv QnV0dG9uKTsgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKSBpcyBpbnZhbGlkQ29sb3IKK1BBU1Mg YmFja2dyb3VuZE9mKHJlcXVpcmVkUmFkaW9CdXR0b24pIGlzIGludmFsaWRDb2xvcgorCitSZW1v dmluZyBhIHJhZGlvIGJ1dHRvbiB3aXRoIHRoZSByZXF1aXJlZCBhdHRyaWJ1dGUgZnJvbSBhIHJh ZGlvIGJ1dHRvbiBncm91cDoKK1BBU1MgcGFyZW50LnJlbW92ZUNoaWxkKHJlcXVpcmVkUmFkaW9C dXR0b24pOyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikpIGlzIHZhbGlkQ29sb3IKKworUEFTUyBz dWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvcmFkaW8vcmFkaW8tbGl2ZS12YWxpZGF0aW9uLXN0eWxl Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3JhZGlvL3JhZGlvLWxpdmUtdmFsaWRhdGlv bi1zdHlsZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjczMjQ0NDcwYzQ5YTQ4NmEyYmE2N2FlNWUxZGQzN2Ez NDI4NzFlNzAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3JhZGlv L3JhZGlvLWxpdmUtdmFsaWRhdGlvbi1zdHlsZS5odG1sCkBAIC0wLDAgKzEsOTQgQEAKKzwhRE9D VFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHN0eWxlPgorOmludmFsaWQgeyBiYWNrZ3Jv dW5kOiByZ2IoMjU1LCAwLCAwKTsgfQorOnZhbGlkIHsgYmFja2dyb3VuZDogcmdiKDAsIDAsIDI1 NSk7IH0KKzwvc3R5bGU+Cis8L2hlYWQ+Cis8Ym9keT4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbign Q2hlY2sgaWYgOnZhbGlkLzppbnZhbGlkIENTUyBwc2V1ZG8gc2VsZWN0b3JzIGFyZSBsaXZlbHkg YXBwbGllZCcpOworCitmdW5jdGlvbiAkKGlkKSB7CisgICAgcmV0dXJuIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKGlkKTsKK30KKworZnVuY3Rpb24gYmFja2dyb3VuZE9mKGVsZW1lbnQpIHsKKyAg ICByZXR1cm4gZG9jdW1lbnQuZGVmYXVsdFZpZXcuZ2V0Q29tcHV0ZWRTdHlsZShlbGVtZW50LCBu dWxsKS5nZXRQcm9wZXJ0eVZhbHVlKCdiYWNrZ3JvdW5kLWNvbG9yJyk7Cit9CisKK3ZhciBpbnZh bGlkQ29sb3IgPSAncmdiKDI1NSwgMCwgMCknOwordmFyIHZhbGlkQ29sb3IgPSAncmdiKDAsIDAs IDI1NSknOworCit2YXIgcGFyZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7Citk b2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHBhcmVudCk7CisKK2RlYnVnKCdSZW1vdmluZyBhIGNo ZWNrZWQgcmFkaW8gYnV0dG9uIGZyb20gYSByZXF1aXJlZCByYWRpbyBidXR0b24gZ3JvdXAgYnkg YSBET00gdHJlZSBtdXRhdGlvbjonKTsKK3BhcmVudC5pbm5lckhUTUwgPSAnPGlucHV0IHR5cGU9 cmFkaW8gbmFtZT1ncm91cDEgcmVxdWlyZWQgaWQ9cmFkaW8xPicgKworICAgICc8aW5wdXQgdHlw ZT1yYWRpbyBuYW1lPWdyb3VwMSBjaGVja2VkIGlkPXJhZGlvMj4nOworc2hvdWxkQmUoJ2JhY2tn cm91bmRPZigkKCJyYWRpbzEiKSknLCAndmFsaWRDb2xvcicpOworc2hvdWxkQmUoJ3BhcmVudC5y ZW1vdmVDaGlsZCgkKCJyYWRpbzIiKSk7IGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSknLCAnaW52 YWxpZENvbG9yJyk7CitkZWJ1ZygnJyk7CisKK2RlYnVnKCdSZW1vdmluZyBhIGNoZWNrZWQgcmFk aW8gYnV0dG9uIGZyb20gYSByZXF1aXJlZCByYWRpbyBidXR0b24gZ3JvdXAgYnkgbmFtZSBhdHRy aWJ1dGUgY2hhbmdlOicpOworcGFyZW50LmlubmVySFRNTCA9ICc8aW5wdXQgdHlwZT1yYWRpbyBu YW1lPWdyb3VwMSByZXF1aXJlZCBpZD1yYWRpbzE+JyArCisgICAgJzxpbnB1dCB0eXBlPXJhZGlv IG5hbWU9Z3JvdXAxIGNoZWNrZWQgaWQ9cmFkaW8yPic7CitzaG91bGRCZSgnJCgicmFkaW8yIiku bmFtZSA9ICJncm91cDIiOyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikpJywgJ2ludmFsaWRDb2xv cicpOworZGVidWcoJycpOworCitkZWJ1ZygnUmVtb3ZpbmcgYSBjaGVja2VkIHJhZGlvIGJ1dHRv biBmcm9tIGEgcmVxdWlyZWQgcmFkaW8gYnV0dG9uIGdyb3VwIGJ5IHR5cGUgY2hhbmdlOicpOwor cGFyZW50LmlubmVySFRNTCA9ICc8aW5wdXQgdHlwZT1yYWRpbyBuYW1lPWdyb3VwMSByZXF1aXJl ZCBpZD1yYWRpbzE+JyArCisgICAgJzxpbnB1dCB0eXBlPXJhZGlvIG5hbWU9Z3JvdXAxIGNoZWNr ZWQgaWQ9cmFkaW8yPic7CitzaG91bGRCZSgnJCgicmFkaW8yIikudHlwZSA9ICJ0ZXh0IjsgYmFj a2dyb3VuZE9mKCQoInJhZGlvMSIpKScsICdpbnZhbGlkQ29sb3InKTsKK2RlYnVnKCcnKTsKKwor ZGVidWcoJ01ha2UgYSByYWRpbyBidXR0b24gZ3JvdXAgcmVxdWlyZWQgYnkgcmVxdWlyZWQgYXR0 cmlidXRlIGNoYW5nZTonKTsKK3BhcmVudC5pbm5lckhUTUwgPSAnPGlucHV0IHR5cGU9cmFkaW8g bmFtZT1ncm91cDEgaWQ9cmFkaW8xPicgKworICAgICc8aW5wdXQgdHlwZT1yYWRpbyBuYW1lPWdy b3VwMSBpZD1yYWRpbzI+JzsKK3Nob3VsZEJlKCdiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikpJywg J3ZhbGlkQ29sb3InKTsKK3Nob3VsZEJlKCdiYWNrZ3JvdW5kT2YoJCgicmFkaW8yIikpJywgJ3Zh bGlkQ29sb3InKTsKK3Nob3VsZEJlKCckKCJyYWRpbzEiKS5yZXF1aXJlZCA9IHRydWU7IGJhY2tn cm91bmRPZigkKCJyYWRpbzEiKSknLCAnaW52YWxpZENvbG9yJyk7CitzaG91bGRCZSgnYmFja2dy b3VuZE9mKCQoInJhZGlvMiIpKScsICdpbnZhbGlkQ29sb3InKTsKK2RlYnVnKCcnKTsKKworZGVi dWcoJ01ha2UgYSByYWRpbyBidXR0b24gZ3JvdXAgbm90IHJlcXVpcmVkIGJ5IHJlcXVpcmVkIGF0 dHJpYnV0ZSBjaGFuZ2U6Jyk7CitwYXJlbnQuaW5uZXJIVE1MID0gJzxpbnB1dCB0eXBlPXJhZGlv IHJlcXVpcmVkIG5hbWU9Z3JvdXAxIGlkPXJhZGlvMT4nICsKKyAgICAnPGlucHV0IHR5cGU9cmFk aW8gbmFtZT1ncm91cDEgaWQ9cmFkaW8yPic7CitzaG91bGRCZSgnYmFja2dyb3VuZE9mKCQoInJh ZGlvMSIpKScsICdpbnZhbGlkQ29sb3InKTsKK3Nob3VsZEJlKCdiYWNrZ3JvdW5kT2YoJCgicmFk aW8yIikpJywgJ2ludmFsaWRDb2xvcicpOworc2hvdWxkQmUoJyQoInJhZGlvMSIpLnJlcXVpcmVk ID0gZmFsc2U7IGJhY2tncm91bmRPZigkKCJyYWRpbzEiKSknLCAndmFsaWRDb2xvcicpOworc2hv dWxkQmUoJ2JhY2tncm91bmRPZigkKCJyYWRpbzIiKSknLCAndmFsaWRDb2xvcicpOworZGVidWco JycpOworCisKK2RlYnVnKCdSZW1vdmluZyBvbmUgb2YgbXVsdGlwbGUgcmVxdWlyZWQgYXR0cmli dXRlczonKTsKK3BhcmVudC5pbm5lckhUTUwgPSAnPGlucHV0IHR5cGU9cmFkaW8gcmVxdWlyZWQg bmFtZT1ncm91cDEgaWQ9cmFkaW8xPicgKworICAgICc8aW5wdXQgdHlwZT1yYWRpbyByZXF1aXJl ZCBuYW1lPWdyb3VwMSBpZD1yYWRpbzI+JzsKK3Nob3VsZEJlKCdiYWNrZ3JvdW5kT2YoJCgicmFk aW8xIikpJywgJ2ludmFsaWRDb2xvcicpOworc2hvdWxkQmUoJ2JhY2tncm91bmRPZigkKCJyYWRp bzIiKSknLCAnaW52YWxpZENvbG9yJyk7CitzaG91bGRCZSgnJCgicmFkaW8xIikucmVxdWlyZWQg PSBmYWxzZTsgYmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKScsICdpbnZhbGlkQ29sb3InKTsKK3No b3VsZEJlKCdiYWNrZ3JvdW5kT2YoJCgicmFkaW8yIikpJywgJ2ludmFsaWRDb2xvcicpOworZGVi dWcoJycpOworCitkZWJ1ZygnQWRkaW5nIGEgcmFkaW8gYnV0dG9uIHdpdGggdGhlIHJlcXVpcmVk IGF0dHJpYnV0ZSB0byBhIHJhZGlvIGJ1dHRvbiBncm91cDonKTsKK3BhcmVudC5pbm5lckhUTUwg PSAnPGlucHV0IHR5cGU9cmFkaW8gbmFtZT1ncm91cDEgaWQ9cmFkaW8xPic7CitzaG91bGRCZSgn YmFja2dyb3VuZE9mKCQoInJhZGlvMSIpKScsICd2YWxpZENvbG9yJyk7Cit2YXIgcmVxdWlyZWRS YWRpb0J1dHRvbiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2lucHV0Jyk7CityZXF1aXJlZFJh ZGlvQnV0dG9uLnR5cGUgPSAncmFkaW8nOworcmVxdWlyZWRSYWRpb0J1dHRvbi5uYW1lID0gJ2dy b3VwMSc7CityZXF1aXJlZFJhZGlvQnV0dG9uLnJlcXVpcmVkID0gdHJ1ZTsKK3Nob3VsZEJlKCdw YXJlbnQuYXBwZW5kQ2hpbGQocmVxdWlyZWRSYWRpb0J1dHRvbik7IGJhY2tncm91bmRPZigkKCJy YWRpbzEiKSknLCAnaW52YWxpZENvbG9yJyk7CitzaG91bGRCZSgnYmFja2dyb3VuZE9mKHJlcXVp cmVkUmFkaW9CdXR0b24pJywgJ2ludmFsaWRDb2xvcicpOworZGVidWcoJycpOworCitkZWJ1Zygn UmVtb3ZpbmcgYSByYWRpbyBidXR0b24gd2l0aCB0aGUgcmVxdWlyZWQgYXR0cmlidXRlIGZyb20g YSByYWRpbyBidXR0b24gZ3JvdXA6Jyk7CitzaG91bGRCZSgncGFyZW50LnJlbW92ZUNoaWxkKHJl cXVpcmVkUmFkaW9CdXR0b24pOyBiYWNrZ3JvdW5kT2YoJCgicmFkaW8xIikpJywgJ3ZhbGlkQ29s b3InKTsKK2RlYnVnKCcnKTsKKworcGFyZW50LmlubmVySFRNTCA9ICcnOworPC9zY3JpcHQ+Cis8 c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+ Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3Nj cmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXZhbHVlTWlzc2luZy1yYWRpby5qcyBiL0xheW91dFRl c3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdmFsdWVNaXNzaW5nLXJh ZGlvLmpzCmluZGV4IDk0YzQ5MGNiYTVmYTlhOTg4MjIyMzQ0Y2JlNGNlOGVmMGFjMWI1YTguLjRi MGJiNGE2OThlYjcwZDY1YWNmODkzZGFhY2Y0M2M1Y2RmNDIwZTEgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdmFsdWVNaXNzaW5n LXJhZGlvLmpzCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlk aXR5U3RhdGUtdmFsdWVNaXNzaW5nLXJhZGlvLmpzCkBAIC0xMCwxMSArMTAsOCBAQCBwYXJlbnQu aW5uZXJIVE1MID0gJzxpbnB1dCBuYW1lPXZpY3RpbSB0eXBlPXJhZGlvIHJlcXVpcmVkPicKIHZh ciBpbnB1dHMgPSBkb2N1bWVudC5nZXRFbGVtZW50c0J5TmFtZSgndmljdGltJyk7CiBkZWJ1Zygn Tm8gY2hlY2tlZCBidXR0b246Jyk7CiBzaG91bGRCZVRydWUoJ2lucHV0c1swXS52YWxpZGl0eS52 YWx1ZU1pc3NpbmcnKTsKLS8vIFRoZSBmb2xsb3dpbmcgcmVzdWx0IHNob3VsZCBiZSBmYWxzZSBi ZWNhdXNlIHRoZSBlbGVtZW50IGRvZXMgbm90IGhhdmUKLS8vICJyZXF1aXJlZCIuICBJdCBjb25m b3JtcyB0byBIVE1MNSwgYW5kIHRoaXMgYmVoYXZpb3IgaGFzIG5vIHByYWN0aWNhbAotLy8gcHJv YmxlbXMuCi1zaG91bGRCZUZhbHNlKCdpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7 Ci1zaG91bGRCZUZhbHNlKCdpbnB1dHNbMl0udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7CitzaG91 bGRCZVRydWUoJ2lucHV0c1sxXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsKK3Nob3VsZEJlVHJ1 ZSgnaW5wdXRzWzJdLnZhbGlkaXR5LnZhbHVlTWlzc2luZycpOwogZGVidWcoJ1RoZSBzZWNvbmQg YnV0dG9uIGhhcyBiZWVuIGNoZWNrZWQ6Jyk7CiBpbnB1dHNbMV0uY2hlY2tlZCA9IHRydWU7CiBz aG91bGRCZUZhbHNlKCdpbnB1dHNbMF0udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7CkBAIC0zMSw2 ICsyOCw3IEBAIHNob3VsZEJlRmFsc2UoJ2lucHV0c1swXS52YWxpZGl0eS52YWx1ZU1pc3Npbmcn KTsKIHNob3VsZEJlRmFsc2UoJ2lucHV0c1sxXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsKIHNo b3VsZEJlRmFsc2UoJ2lucHV0c1syXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsKIAorZGVidWco JycpOwogZGVidWcoJ1dpdGggZm9ybSBlbGVtZW50Jyk7CiBwYXJlbnQuaW5uZXJIVE1MID0gJzxm b3JtPicKICAgICArICc8aW5wdXQgbmFtZT12aWN0aW0gdHlwZT1yYWRpbyByZXF1aXJlZD4nCkBA IC00MCw5ICszOCw4IEBAIHBhcmVudC5pbm5lckhUTUwgPSAnPGZvcm0+JwogaW5wdXRzID0gZG9j dW1lbnQuZ2V0RWxlbWVudHNCeU5hbWUoJ3ZpY3RpbScpOwogZGVidWcoJ05vIGNoZWNrZWQgYnV0 dG9uOicpOwogc2hvdWxkQmVUcnVlKCdpbnB1dHNbMF0udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7 Ci0vLyBUaGUgZm9sbG93aW5nIHJlc3VsdCBzaG91bGQgYmUgZmFsc2UuCi1zaG91bGRCZUZhbHNl KCdpbnB1dHNbMV0udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7Ci1zaG91bGRCZUZhbHNlKCdpbnB1 dHNbMl0udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7CitzaG91bGRCZVRydWUoJ2lucHV0c1sxXS52 YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsKK3Nob3VsZEJlVHJ1ZSgnaW5wdXRzWzJdLnZhbGlkaXR5 LnZhbHVlTWlzc2luZycpOwogZGVidWcoJ1RoZSBmaXJzdCBidXR0b24gaGFzIGJlZW4gY2hlY2tl ZDonKTsKIGlucHV0c1swXS5jaGVja2VkID0gdHJ1ZTsKIHNob3VsZEJlRmFsc2UoJ2lucHV0c1sw XS52YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsKQEAgLTU4LDMgKzU1LDIyIEBAIGlucHV0c1syXS5j aGVja2VkID0gdHJ1ZTsKIHNob3VsZEJlRmFsc2UoJ2lucHV0c1swXS52YWxpZGl0eS52YWx1ZU1p c3NpbmcnKTsKIHNob3VsZEJlRmFsc2UoJ2lucHV0c1sxXS52YWxpZGl0eS52YWx1ZU1pc3Npbmcn KTsKIHNob3VsZEJlRmFsc2UoJ2lucHV0c1syXS52YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsKKwor ZGVidWcoJycpOworZGVidWcoJ05vdCBpbiBhIHJhZGlvIGJ1dHRvbiBncm91cCcpOwordmFyIHJl cXVpcmVkQnV0dG9uID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnaW5wdXQnKTsKK3JlcXVpcmVk QnV0dG9uLnR5cGUgPSAncmFkaW8nOworcmVxdWlyZWRCdXR0b24ubmFtZSA9ICd2aWN0aW0nOwor cmVxdWlyZWRCdXR0b24ucmVxdWlyZWQgPSB0cnVlOworc2hvdWxkQmVGYWxzZSgncmVxdWlyZWRC dXR0b24udmFsaWRpdHkudmFsdWVNaXNzaW5nJyk7CisKK3BhcmVudC5pbm5lckhUTUwgPSAnPGlu cHV0IG5hbWU9dmljdGltIHR5cGU9cmFkaW8gcmVxdWlyZWQ+PGlucHV0IG5hbWU9dmljdGltIHR5 cGU9cmFkaW8+JzsKK3JlcXVpcmVkQnV0dG9uID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCeU5hbWUo J3ZpY3RpbScpWzBdOwordmFyIGJ1dHRvbiA9IGRvY3VtZW50LmdldEVsZW1lbnRzQnlOYW1lKCd2 aWN0aW0nKVsxXTsKK3Nob3VsZEJlVHJ1ZSgncmVxdWlyZWRCdXR0b24udmFsaWRpdHkudmFsdWVN aXNzaW5nJyk7CitzaG91bGRCZVRydWUoJ2J1dHRvbi52YWxpZGl0eS52YWx1ZU1pc3NpbmcnKTsK K3BhcmVudC5yZW1vdmVDaGlsZChidXR0b24pOworc2hvdWxkQmVGYWxzZSgnYnV0dG9uLnZhbGlk aXR5LnZhbHVlTWlzc2luZycpOworcGFyZW50LnJlbW92ZUNoaWxkKHJlcXVpcmVkQnV0dG9uKTsK K3Nob3VsZEJlRmFsc2UoJ3JlcXVpcmVkQnV0dG9uLnZhbGlkaXR5LnZhbHVlTWlzc2luZycpOwor CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wZXJmL2FkZGluZy1yYWRpby1idXR0b25zLWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL3BlcmYvYWRkaW5nLXJhZGlvLWJ1dHRvbnMtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmEyOTEzMmRmOGM4MGQyZDcyOGMxMTgzZDc4M2I5ODI0MjgxNGRhNDEK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wZXJmL2FkZGluZy1yYWRpby1idXR0b25z LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK1Rlc3RzIHRoYXQgYWRkaW5nIGEgcmFkaW8g YnV0dG9uIHRvIGEgcmFkaW8gYnV0dG9uIGdyb3VwIGlzIGNvbnN0YW50IGluIHRoZSBudW1iZXIg b2YgcmFkaW8gYnV0dG9ucy4KK1BBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGVyZi9h ZGRpbmctcmFkaW8tYnV0dG9ucy5odG1sIGIvTGF5b3V0VGVzdHMvcGVyZi9hZGRpbmctcmFkaW8t YnV0dG9ucy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFhYmFlZjQ5MTA5OTAxY2UyN2M3MjhhZGJjMGM1ODlj MzllYzUxN2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wZXJmL2FkZGluZy1yYWRp by1idXR0b25zLmh0bWwKQEAgLTAsMCArMSwzNyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4K Kzxib2R5PgorPHNjcmlwdCBzcmM9Ii4uL3Jlc291cmNlcy9tYWduaXR1ZGUtcGVyZi5qcyI+PC9z Y3JpcHQ+Cis8c2NyaXB0PgordmFyIHBhcmVudEZvcm0gPSBudWxsOworCitmdW5jdGlvbiBzZXR1 cChtYWduaXR1ZGUpIHsKKyAgICBpZiAocGFyZW50Rm9ybSkKKyAgICAgICAgZG9jdW1lbnQuYm9k eS5yZW1vdmVDaGlsZChwYXJlbnRGb3JtKTsKKyAgICBwYXJlbnRGb3JtID0gZG9jdW1lbnQuY3Jl YXRlRWxlbWVudCgnZm9ybScpOworICAgIGRvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQocGFyZW50 Rm9ybSk7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBtYWduaXR1ZGU7ICsraSkgeworICAgICAg ICB2YXIgcmFkaW8gPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdpbnB1dCcpOworICAgICAgICBy YWRpby50eXBlID0gJ3JhZGlvJzsKKyAgICAgICAgcmFkaW8ubmFtZSA9ICdncm91cDEnOworICAg ICAgICByYWRpby5jaGVja2VkID0gdHJ1ZTsKKyAgICAgICAgcGFyZW50Rm9ybS5hcHBlbmRDaGls ZChyYWRpbyk7CisgICAgfQorICAgIHBhcmVudEZvcm0ub2Zmc2V0TGVmdDsKK30KKworZnVuY3Rp b24gdGVzdChtYWduaXR1ZGUpIHsKKyAgICB2YXIgcmFkaW8gPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCdpbnB1dCcpOworICAgIHJhZGlvLnR5cGUgPSAncmFkaW8nOworICAgIHJhZGlvLm5hbWUg PSAnZ3JvdXAxJzsKKyAgICByYWRpby5jaGVja2VkID0gdHJ1ZTsKKyAgICBwYXJlbnRGb3JtLmFw cGVuZENoaWxkKHJhZGlvKTsKKyAgICByYWRpby5vZmZzZXRMZWZ0OworICAgIHBhcmVudEZvcm0u cmVtb3ZlQ2hpbGQocmFkaW8pOworfQorCitNYWduaXR1ZGUuZGVzY3JpcHRpb24oIlRlc3RzIHRo YXQgYWRkaW5nIGEgcmFkaW8gYnV0dG9uIHRvIGEgcmFkaW8gYnV0dG9uIGdyb3VwIGlzIGNvbnN0 YW50IGluIHRoZSBudW1iZXIgb2YgcmFkaW8gYnV0dG9ucy4iKTsKK01hZ25pdHVkZS5ydW4oc2V0 dXAsIHRlc3QsIE1hZ25pdHVkZS5DT05TVEFOVCk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRt bD4K