37060 2010-04-03 04:23:06 -0700 List item markers are not always updated after changes in the DOM 2010-04-21 09:06:38 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 36724 1 jwieczorek jwieczorek abarth darin dbates eric gustavo luiz tonikitoo webkit.review.bot xan.lopez oldest_to_newest 208273 0 52494 jwieczorek 2010-04-03 04:23:06 -0700 Created attachment 52494 test case See the attached test case. It works properly in Firefox. Basically, it does not work if the item being added/removed is an indirect child of the list. 208274 1 52495 jwieczorek 2010-04-03 04:36:27 -0700 Created attachment 52495 patch This patch addresses the problem. I've added a function to LayoutTestController that returns the marker number for a list item, according to Darin's idea in https://bugs.webkit.org/show_bug.cgi?id=36724 and an JS function that output a readable representation of a list, so that the tests don't need to dump the whole render tree. 208323 2 webkit.review.bot 2010-04-03 21:41:06 -0700 Attachment 52495 did not build on win: Build output: http://webkit-commit-queue.appspot.com/results/1583216 208358 3 52512 jwieczorek 2010-04-04 06:42:23 -0700 Created attachment 52512 patch Added stubs for the new LayoutTestController function in Mac and Win ports and skipped the new tests on these platforms. This will most likely fix the Windows build failure. 208393 4 52512 darin 2010-04-04 21:46:15 -0700 Comment on attachment 52512 patch > static Node* enclosingList(const RenderObject* renderer) > { > - Node* node = renderer->node(); > - if (node) > - return enclosingList(node); > - > - renderer = renderer->parent(); > while (renderer && !renderer->node()) > renderer = renderer->parent(); > > - node = renderer->node(); > + if (!renderer) > + return 0; > + > + Node* node = renderer->node(); > if (isList(node)) > return node; This change means the code now walks up the render tree before walking up the DOM tree. How did you determine that there was no case where that changed the function result? > +void updateListMarkerNumbers(RenderObject* listItem) > +{ > + ASSERT(listItem->isListItem()); Since this function is designed to only be called on a RenderListItem, its argument type should be RenderListItem*, not RenderObject*. The callers should call toRenderListItem, which will do the type cast and assertion. In fact, you should make it a member function, since it's in the RenderListItem.cpp file and is a basic part of what a RenderListItem does. I suggest also changing the argument type of the enclosingList function to RenderListItem*. > + RenderObject* child = listItem->nextInPreOrder(list); Is this the right thing to do when list is 0? It means you'll walk the entire document looking for other list items. Is that really what we want to do for items outside the document. > + while (child) { This should probably be written as a for loop instead of a while loop, although the line will end up being long. But it would make the loop logic easier to understand. > + // We've found a nested, independent list - nothing to do here. Instead of a hyphen separating these phrases, I'd suggest a colon. > // renumber ordered lists > if (oldChild->isListItem()) > - updateListMarkerNumbers(oldChild->nextSibling()); > + updateListMarkerNumbers(oldChild); > + // renumber ordered lists > + if (newChild->isListItem()) > + updateListMarkerNumbers(newChild); > + // renumber ordered lists > + if (child->isListItem()) > + updateListMarkerNumbers(child); If we really need this same comment every time we call the updateListMarkerNumbers function, then I think we need to rename the function instead. Please omit the comment. > +gchar* webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSObjectRef nodeObject) > +{ > + JSC::JSObject* object = toJS(nodeObject); > + if (!object || !object->inherits(&JSHTMLElement::s_info)) > + return 0; > + > + HTMLElement* element = static_cast<JSHTMLElement*>(object)->impl(); > + if (!element || !element->renderer()) > + return 0; > + > + RenderObject* renderer = element->renderer(); > + if (!renderer->isListItem()) > + return 0; > + > + String markerText = toRenderListItem(renderer)->markerText(); > + return g_strdup(markerText.utf8().data()); > +} There's no reason to limit this to HTML elements. Non-HTML elements can be styled and end up as list items. You should check for JSElement rather than JSHTMLElement. This function as written isn't safe. You can't grab an element's renderer without first calling Document::updateLayout. You should move the part of this function that goes from an element to marker text out of Qt-specific and GTK-specific code into RenderTreeAsText.cpp, alongside the similar counterValueForElement function and using similar implementation techniques. > +static JSValueRef markerTextForListItemCallback(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) > +{ > + if (argumentCount < 1) > + return JSValueMakeUndefined(context); > + > + LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject)); > + JSObjectRef nodeObject = JSValueToObject(context, arguments[0], exception); > + ASSERT(!*exception); > + > + return JSValueMakeString(context, controller->markerTextForListItem(nodeObject).get()); > +} I find the division of responsibilities here a little strange. This function handles converting the JSValue to a JSObject, but not checking the type of JSObject. I think it would be cleaner to pass the JSValue in to the controller since it already has to deal with JavaScript type checking to check that this is a node object. review- because I think at least some of these things should be fixed before landing 208442 5 52526 jwieczorek 2010-04-05 05:28:54 -0700 Created attachment 52526 patch (In reply to comment #4) > (From update of attachment 52512 [details]) > > static Node* enclosingList(const RenderObject* renderer) > > { > > - Node* node = renderer->node(); > > - if (node) > > - return enclosingList(node); > > - > > - renderer = renderer->parent(); > > while (renderer && !renderer->node()) > > renderer = renderer->parent(); > > > > - node = renderer->node(); > > + if (!renderer) > > + return 0; > > + > > + Node* node = renderer->node(); > > if (isList(node)) > > return node; > > This change means the code now walks up the render tree before walking up the > DOM tree. How did you determine that there was no case where that changed the > function result? Actually it was doing this before too, I just wanted to formulate it simpler. But you're right, there is one possible behavior change: for a list that also acts as a list item, it would return the list itself. Anyway, I'll just revert this hunk as it's not even necessary for this patch. > > +void updateListMarkerNumbers(RenderObject* listItem) > > +{ > > + ASSERT(listItem->isListItem()); > > Since this function is designed to only be called on a RenderListItem, its > argument type should be RenderListItem*, not RenderObject*. The callers should > call toRenderListItem, which will do the type cast and assertion. > > In fact, you should make it a member function, since it's in the > RenderListItem.cpp file and is a basic part of what a RenderListItem does. > > I suggest also changing the argument type of the enclosingList function to > RenderListItem*. Done. > > + RenderObject* child = listItem->nextInPreOrder(list); > > Is this the right thing to do when list is 0? It means you'll walk the entire > document looking for other list items. Is that really what we want to do for > items outside the document. Well, I made a mistake to let enclosingList be 0 in the first place. For some reason I came to that conclusion when I saw fast/lists/anonymous-items.html crashing with my patch but it turned out to be a different issue which I fixed even before the first version of the patch. > > + while (child) { > > This should probably be written as a for loop instead of a while loop, although > the line will end up being long. But it would make the loop logic easier to > understand. I changed it to be a for loop but personally I don't find it easier to read as we're ending up with something like: if (child->node() && isList(child->node())) { // We've found a nested, independent list: nothing to do here. child = child->nextInPreOrderAfterChildren(list)->previousInPreOrder(); continue; } > > + // We've found a nested, independent list - nothing to do here. > > Instead of a hyphen separating these phrases, I'd suggest a colon. Fixed. > > // renumber ordered lists > > if (oldChild->isListItem()) > > - updateListMarkerNumbers(oldChild->nextSibling()); > > + updateListMarkerNumbers(oldChild); > > > + // renumber ordered lists > > + if (newChild->isListItem()) > > + updateListMarkerNumbers(newChild); > > > + // renumber ordered lists > > + if (child->isListItem()) > > + updateListMarkerNumbers(child); > > If we really need this same comment every time we call the > updateListMarkerNumbers function, then I think we need to rename the function > instead. Please omit the comment. Yeah, that original comment wasn't really valuable. > > +gchar* webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSObjectRef nodeObject) > > +{ > > + JSC::JSObject* object = toJS(nodeObject); > > + if (!object || !object->inherits(&JSHTMLElement::s_info)) > > + return 0; > > + > > + HTMLElement* element = static_cast<JSHTMLElement*>(object)->impl(); > > + if (!element || !element->renderer()) > > + return 0; > > + > > + RenderObject* renderer = element->renderer(); > > + if (!renderer->isListItem()) > > + return 0; > > + > > + String markerText = toRenderListItem(renderer)->markerText(); > > + return g_strdup(markerText.utf8().data()); > > +} > > There's no reason to limit this to HTML elements. Non-HTML elements can be > styled and end up as list items. You should check for JSElement rather than > JSHTMLElement. Fixed. > This function as written isn't safe. You can't grab an element's renderer > without first calling Document::updateLayout. Indeed, that's why I needed to explicitly trigger a layout in the tests. Doing this in the function makes more sense. > You should move the part of this function that goes from an element to marker > text out of Qt-specific and GTK-specific code into RenderTreeAsText.cpp, > alongside the similar counterValueForElement function and using similar > implementation techniques. Done. > > +static JSValueRef markerTextForListItemCallback(JSContextRef context, JSObjectRef, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) > > +{ > > + if (argumentCount < 1) > > + return JSValueMakeUndefined(context); > > + > > + LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject)); > > + JSObjectRef nodeObject = JSValueToObject(context, arguments[0], exception); > > + ASSERT(!*exception); > > + > > + return JSValueMakeString(context, controller->markerTextForListItem(nodeObject).get()); > > +} > > I find the division of responsibilities here a little strange. This function > handles converting the JSValue to a JSObject, but not checking the type of > JSObject. I think it would be cleaner to pass the JSValue in to the controller > since it already has to deal with JavaScript type checking to check that this > is a node object. Done. > review- because I think at least some of these things should be fixed before > landing Thanks, can you take another look? 208445 6 webkit.review.bot 2010-04-05 05:35:42 -0700 Attachment 52526 did not build on gtk: Build output: http://webkit-commit-queue.appspot.com/results/1652163 208477 7 darin 2010-04-05 07:57:03 -0700 (In reply to comment #5) > Created an attachment (id=52526) [details] > patch > > (In reply to comment #4) > > (From update of attachment 52512 [details] [details]) > > > static Node* enclosingList(const RenderObject* renderer) > > > { > > > - Node* node = renderer->node(); > > > - if (node) > > > - return enclosingList(node); > > > - > > > - renderer = renderer->parent(); > > > while (renderer && !renderer->node()) > > > renderer = renderer->parent(); > > > > > > - node = renderer->node(); > > > + if (!renderer) > > > + return 0; > > > + > > > + Node* node = renderer->node(); > > > if (isList(node)) > > > return node; > > > > This change means the code now walks up the render tree before walking up the > > DOM tree. How did you determine that there was no case where that changed the > > function result? > > Actually it was doing this before too Huh? The old code says if there is a node, then call enclosingList, walking up the DOM tree, and don't go up the render tree at all. The new code does not do that. We can debate that later if needed when we try to land this change, I guess. > Anyway, I'll just revert > this hunk as it's not even necessary for this patch. All we need to land this is a test case demonstrating what the code change fixes. > I changed it to be a for loop but personally I don't find it easier to read as > we're ending up with something like: > > if (child->node() && isList(child->node())) { > // We've found a nested, independent list: nothing to do here. > child = child->nextInPreOrderAfterChildren(list)->previousInPreOrder(); > continue; > } Yes, that's not good. You should not let it be like that! Lets go back to the way you have it. 208479 8 webkit.review.bot 2010-04-05 08:00:05 -0700 Attachment 52526 did not build on win: Build output: http://webkit-commit-queue.appspot.com/results/1581254 208483 9 52526 darin 2010-04-05 08:31:56 -0700 Comment on attachment 52526 patch My biggest worry here is that this algorithm seems to iterate the entire document every time you add a list item. And if you add multiple list items, it seems to iterate the document once per list item. That can't be good for performance. Sorry I didn't mention that last time. Is there some way to quantify this? I don't think other browsers have this sort of O(n^2) behavior when adding list items, but I could be wrong. Some good performance tests would be to make a extremely large list and test performance of adding items, an extremely document without lists and test performance of adding list items, a small list of extremely large lists and test the performance of adding an item at the top level. It would be good to know if this patch has significantly changed performance or not for those cases. It may be that the only cases that are slower with this patch are unlikely or unimportant cases, but we should find that out with some testing. > + RenderListItem* item = toRenderListItem(renderer); > + Node* otherList = enclosingList(item); > // This item is part of our current list, so it's what we're looking for. > if (list == otherList) > - return toRenderListItem(renderer); > + return item; This variable named item shadows the function argument. Might be OK. It's also OK to repeat the toRenderListItem call twice, because it's just an inlined typecast. > +void RenderListItem::updateListMarkerNumbers() > +{ > + Node* listNode = enclosingList(this); > + RenderObject* list = listNode ? listNode->renderer() : 0; > + > + for (RenderObject* child = this->nextInPreOrder(list); child; child = child->nextInPreOrder(list)) { > + if (child->node() && isList(child->node())) { > + // We've found a nested, independent list: nothing to do here. > + child = child->nextInPreOrderAfterChildren(list)->previousInPreOrder(); > + continue; > + } > + > + if (child->isListItem()) > + toRenderListItem(child)->updateValue(); > + } > +} I asked in the previous patch whether it was OK, when the local variable list is 0, to iterate the entire document looking for other list items. Because that is what nextInPreOrder will do when passed a 0. I did not see an answer to my question, and the question remains. It seems potentially bad for performance. Is this tested in a test case? > + if (!element->renderer()) > + return String(); > + > + RenderObject* renderer = element->renderer(); > + if (!renderer->isListItem()) > + return String(); It would be a little more elegant to use the local variable, renderer, for the null check as well as the list item check. > + WEBKIT_API gchar* > + webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSValueRef nodeObject); Normally it would be the responsibility of the layout test controller file in DumpRenderTree, which binds test controller JavaScript calls to WebKit calls, to convert from a JSValueRef all the way to the platform's API representation for an Element. Last time I advised you to make sure you didn't do JSValueRef to JSObjectRef in one place, and then JSObjectRef to Element* in another. But I think that using actual JSValueRef in the API on GTK is not great. I don't think functions at the WebKit API level should be responsible for converting a JavaScript value into an element pointer. I see now that for ports that don't have a public DOM API, it's difficult to figure out what type to use to pass around a pointer to a element. That's the reason that we ended up using an ID instead of an element pointer in counterValueForElementById. While you found a way to make this work for GTK and Qt, I'm concerned that it will be tricky to get this working on the other platforms. This seems almost ready to go in, but review- because of my performance question and the "is this the right thing to do when the list is 0" question 208486 10 jwieczorek 2010-04-05 08:42:02 -0700 (In reply to comment #7) > Huh? The old code says if there is a node, then call enclosingList, walking up > the DOM tree, and don't go up the render tree at all. The new code does not do > that. We can debate that later if needed when we try to land this change, I > guess. I'm not sure I am following. This loop: while (renderer && !renderer->node()) renderer = renderer->parent(); will execute 0 times when the renderer has a node attached to it, which will bring us to: Node* node = renderer->node(); if (isList(node)) return node; return enclosingList(node); so basically it's the same code, just formulated in a different way. > > Anyway, I'll just revert > > this hunk as it's not even necessary for this patch. > > All we need to land this is a test case demonstrating what the code change > fixes. The thing is it was not supposed to fix anything. It was just an unnecessary cleanup. I should have been more clear about it before. > > I changed it to be a for loop but personally I don't find it easier to read as > > we're ending up with something like: > > > > if (child->node() && isList(child->node())) { > > // We've found a nested, independent list: nothing to do here. > > child = child->nextInPreOrderAfterChildren(list)->previousInPreOrder(); > > continue; > > } > > Yes, that's not good. You should not let it be like that! Lets go back to the > way you have it. 208490 11 darin 2010-04-05 08:43:07 -0700 (In reply to comment #10) > so basically it's the same code, just formulated in a different way. I see. > The thing is it was not supposed to fix anything. It was just an unnecessary > cleanup. I should have been more clear about it before. Oh, OK. We can still land it later. 208511 12 jwieczorek 2010-04-05 09:22:03 -0700 (In reply to comment #9) > (From update of attachment 52526 [details]) > My biggest worry here is that this algorithm seems to iterate the entire > document every time you add a list item. And if you add multiple list items, it > seems to iterate the document once per list item. That can't be good for > performance. Sorry I didn't mention that last time. Is there some way to > quantify this? I don't think other browsers have this sort of O(n^2) behavior > when adding list items, but I could be wrong. We're not making the complexity worse as such (it was already pretty much n^2) but yes, we're possibly making the code slower for some cases. To fix the bugs we're fixing here we need to be traversing more than before. We can benefit from the assumption, that whenever a list item is marked as needing an update to the marker, then all the subsequent ones will be too (this was not true before but with this patch is). I can't think of any situation where that would not be the case: 1) changing the start value for a list revaluates the whole list 2) changing the value of an item revaluates all the subsequent ones 3) adding/removing items revaluates all the subsequent ones If this is true, then I could improve this, either as part of this patch, or a separate one. > Some good performance tests would be to make a extremely large list and test > performance of adding items, an extremely document without lists and test > performance of adding list items, a small list of extremely large lists and > test the performance of adding an item at the top level. > > It would be good to know if this patch has significantly changed performance or > not for those cases. It may be that the only cases that are slower with this > patch are unlikely or unimportant cases, but we should find that out with some > testing. > > > + RenderListItem* item = toRenderListItem(renderer); > > + Node* otherList = enclosingList(item); > > // This item is part of our current list, so it's what we're looking for. > > if (list == otherList) > > - return toRenderListItem(renderer); > > + return item; > > This variable named item shadows the function argument. Might be OK. It's also > OK to repeat the toRenderListItem call twice, because it's just an inlined > typecast. > > > +void RenderListItem::updateListMarkerNumbers() > > +{ > > + Node* listNode = enclosingList(this); > > + RenderObject* list = listNode ? listNode->renderer() : 0; > > + > > + for (RenderObject* child = this->nextInPreOrder(list); child; child = child->nextInPreOrder(list)) { > > + if (child->node() && isList(child->node())) { > > + // We've found a nested, independent list: nothing to do here. > > + child = child->nextInPreOrderAfterChildren(list)->previousInPreOrder(); > > + continue; > > + } > > + > > + if (child->isListItem()) > > + toRenderListItem(child)->updateValue(); > > + } > > +} > > I asked in the previous patch whether it was OK, when the local variable list > is 0, to iterate the entire document looking for other list items. Because that > is what nextInPreOrder will do when passed a 0. I did not see an answer to my > question, and the question remains. It seems potentially bad for performance. > Is this tested in a test case? I responded: > Well, I made a mistake to let enclosingList be 0 in the first place. For some > reason I came to that conclusion when I saw fast/lists/anonymous-items.html > crashing with my patch but it turned out to be a different issue which I fixed > even before the first version of the patch. Again, should have been more precise: enclosingList would never be 0 now. > > + if (!element->renderer()) > > + return String(); > > + > > + RenderObject* renderer = element->renderer(); > > + if (!renderer->isListItem()) > > + return String(); > > It would be a little more elegant to use the local variable, renderer, for the > null check as well as the list item check. > > > + WEBKIT_API gchar* > > + webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSValueRef nodeObject); > > Normally it would be the responsibility of the layout test controller file in > DumpRenderTree, which binds test controller JavaScript calls to WebKit calls, > to convert from a JSValueRef all the way to the platform's API representation > for an Element. > > Last time I advised you to make sure you didn't do JSValueRef to JSObjectRef in > one place, and then JSObjectRef to Element* in another. But I think that using > actual JSValueRef in the API on GTK is not great. I don't think functions at > the WebKit API level should be responsible for converting a JavaScript value > into an element pointer. I see now that for ports that don't have a public DOM > API, it's difficult to figure out what type to use to pass around a pointer to > a element. That's the reason that we ended up using an ID instead of an element > pointer in counterValueForElementById. Right, but using IDs instead of node objects would make the tests more complicated. We could, however, automate the assignment within the dumpList() JS function. > While you found a way to make this work > for GTK and Qt, I'm concerned that it will be tricky to get this working on the > other platforms. What exactly would be tricky with implementing this on other platforms? By grepping the sources, it looks like the JSC C API is being used in the API layer both of the Mac and Win ports. > This seems almost ready to go in, but review- because of my performance > question and the "is this the right thing to do when the list is 0" question I'll post one more patch to fix the GTK+ and Windows builds and address some of your comments. Thanks. 208524 13 darin 2010-04-05 10:00:53 -0700 (In reply to comment #12) > (In reply to comment #9) > > (From update of attachment 52526 [details] [details]) > > My biggest worry here is that this algorithm seems to iterate the entire > > document every time you add a list item. And if you add multiple list items, it > > seems to iterate the document once per list item. That can't be good for > > performance. Sorry I didn't mention that last time. Is there some way to > > quantify this? I don't think other browsers have this sort of O(n^2) behavior > > when adding list items, but I could be wrong. > > We're not making the complexity worse as such (it was already pretty much n^2) > but yes, we're possibly making the code slower for some cases. To fix the bugs > we're fixing here we need to be traversing more than before. I'd like to see some actual test data. It should be easy to make something so huge that you can easily see these effects with a "stopwatch test". One thing that's different from our list marker code and our other similar code is that it's not coalesced. The values of markers are updated immediately, even if they are about to be invalidated a moment later by another DOM modification. Whereas other sorts of updates use an invalidation scheme and then get updated later, for example when layout occurs. > We can benefit from the assumption, that whenever a list item is marked as > needing an update to the marker, then all the subsequent ones will be too (this > was not true before but with this patch is). I can't think of any situation > where that would not be the case: > 1) changing the start value for a list revaluates the whole list > 2) changing the value of an item revaluates all the subsequent ones > 3) adding/removing items revaluates all the subsequent ones > > If this is true, then I could improve this, either as part of this patch, or a > separate one. There's another patch adding support for the "reversed" attribute for <ol>, which will probably change these assumptions and thus change this code. An improvement that helps improve the case where you're constantly adding a new last item for an existing list is probably worthwhile. If we can prove this patch doesn't make any case significantly worse, then we can definitely leave optimization for a later patch. But we do need to double check that we haven't added any new bad performance behavior. I don't want any nasty surprises later from people testing live websites. > > > +void RenderListItem::updateListMarkerNumbers() > > > +{ > > > + Node* listNode = enclosingList(this); > > > + RenderObject* list = listNode ? listNode->renderer() : 0; > > > + > > > + for (RenderObject* child = this->nextInPreOrder(list); child; child = child->nextInPreOrder(list)) { > > > + if (child->node() && isList(child->node())) { > > > + // We've found a nested, independent list: nothing to do here. > > > + child = child->nextInPreOrderAfterChildren(list)->previousInPreOrder(); > > > + continue; > > > + } > > > + > > > + if (child->isListItem()) > > > + toRenderListItem(child)->updateValue(); > > > + } > > > +} > > > > I asked in the previous patch whether it was OK, when the local variable list > > is 0, to iterate the entire document looking for other list items. Because that > > is what nextInPreOrder will do when passed a 0. I did not see an answer to my > > question, and the question remains. It seems potentially bad for performance. > > Is this tested in a test case? > > I responded: > > Well, I made a mistake to let enclosingList be 0 in the first place. For some > > reason I came to that conclusion when I saw fast/lists/anonymous-items.html > > crashing with my patch but it turned out to be a different issue which I fixed > > even before the first version of the patch. > > Again, should have been more precise: enclosingList would never be 0 now. What about enclosingList->renderer()? If it's really true that neither should ever be 0 then I think we should add assertions to that effect. And I also suggest an early return after the assertions. It's OK to have code to handle the 0 case without crashing, but I would suggest an early return rather than "iterate the entire document" behavior for that case. > using IDs instead of node objects would make the tests more complicated. It would. > We could, however, automate the assignment within the dumpList() JS function. Yes. > > While you found a way to make this work > > for GTK and Qt, I'm concerned that it will be tricky to get this working on the > > other platforms. > > What exactly would be tricky with implementing this on other platforms? By > grepping the sources, it looks like the JSC C API is being used in the API > layer both of the Mac and Win ports. There are no other existing layout test controller functions that do this; things like include files and type casting will be covering new territory. But I'm encouraged by your optimism. If this really is easy, I'd be tempted to change the counter test function to work this way instead of depending on IDs. 208540 14 jwieczorek 2010-04-05 10:24:58 -0700 (In reply to comment #13) > > We're not making the complexity worse as such (it was already pretty much n^2) > > but yes, we're possibly making the code slower for some cases. To fix the bugs > > we're fixing here we need to be traversing more than before. > > I'd like to see some actual test data. It should be easy to make something so > huge that you can easily see these effects with a "stopwatch test". OK, I'll give it a go. > One thing that's different from our list marker code and our other similar code > is that it's not coalesced. The values of markers are updated immediately, even > if they are about to be invalidated a moment later by another DOM modification. > Whereas other sorts of updates use an invalidation scheme and then get updated > later, for example when layout occurs. Are you sure this is the case? What the patch does (and so does the old code) is calling updateValue() on the RenderListItems, which is: void RenderListItem::updateValue() { if (!m_hasExplicitValue) { m_isValueUpToDate = false; if (m_marker) m_marker->setNeedsLayoutAndPrefWidthsRecalc(); } } And then, on the next layout, RenderListMarker pulls the value, which is lazily calculated in updateValueNow(). But still, what we're doing too many times is marking items as outdated. > > We can benefit from the assumption, that whenever a list item is marked as > > needing an update to the marker, then all the subsequent ones will be too (this > > was not true before but with this patch is). I can't think of any situation > > where that would not be the case: > > 1) changing the start value for a list revaluates the whole list > > 2) changing the value of an item revaluates all the subsequent ones > > 3) adding/removing items revaluates all the subsequent ones > > > > If this is true, then I could improve this, either as part of this patch, or a > > separate one. > > There's another patch adding support for the "reversed" attribute for <ol>, > which will probably change these assumptions and thus change this code. Yes. For a reversed list, however, an opposite assumption would be true (adding/removing an item requires all the previous ones to be updated or the whole list for other changes, as above). > An improvement that helps improve the case where you're constantly adding a new > last item for an existing list is probably worthwhile. If we're adding a new last item for an existing list, we need to find out if it's the last one. But anyway, we only go through the nodes after the new item within the list subtree. So this case should already be fast. > If we can prove this > patch doesn't make any case significantly worse, then we can definitely leave > optimization for a later patch. But we do need to double check that we haven't > added any new bad performance behavior. I don't want any nasty surprises later > from people testing live websites. I understand that. I hope we can simply add the optimization I mentioned as it's quite straightforward. This would make the code even faster than it was before (assuming I got it right). 208554 15 darin 2010-04-05 10:38:34 -0700 (In reply to comment #14) > But still, what we're doing too many times is marking items as outdated. Got it. Your plan sounds good. 208615 16 52553 jwieczorek 2010-04-05 12:03:13 -0700 Created attachment 52553 patch A revised patch addressing your comments and the build failures. 208619 17 webkit.review.bot 2010-04-05 12:05:36 -0700 Attachment 52553 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WARNING: File exempt from style guide. Skipping: "WebKit/qt/Api/qwebframe_p.h" WARNING: File exempt from style guide. Skipping: "WebKit/qt/Api/qwebframe.cpp" WebKitTools/DumpRenderTree/win/LayoutTestControllerWin.cpp:42: Alphabetical sorting problem. [build/include_order] [4] WARNING: File exempt from style guide. Skipping: "WebKit/qt/Api/qwebelement.h" Total errors found: 1 in 38 files If any of these errors are false positives, please file a bug against check-webkit-style. 208631 18 52553 darin 2010-04-05 12:13:45 -0700 Comment on attachment 52553 patch > +JSRetainPtr<JSStringRef> LayoutTestController::markerTextForListItem(JSValueRef nodeObject) const > +{ > + gchar* markerTextGChar = webkit_web_frame_marker_text_for_list_item(mainFrame, nodeObject); > + if (!markerTextGChar) > + return 0; > + > + JSRetainPtr<JSStringRef> markerText(Adopt, JSStringCreateWithUTF8CString(markerTextGChar)); > + return markerText; > +} There's a storage leak here. You need to g_free markerTextGChar. > #include <JavaScriptCore/JSRetainPtr.h> > #include <JavaScriptCore/JSStringRefBSTR.h> > #include <JavaScriptCore/JavaScriptCore.h> > +#include <JavaScriptCore/JSValueRef.h> > #include <WebCore/COMPtr.h> > #include <WebKit/WebKit.h> > #include <WebKit/WebKitCOMAPI.h> Alphabetical order, case sensitive, like the sort tool. That means JSValueRef.h should be moved up one line. But I really don't get why you need to add an include here at all. JavaScriptCore.h includes JavaScript.h which in turn includes JSValueRef.h. 208639 19 jwieczorek 2010-04-05 12:21:08 -0700 Thanks! (In reply to comment #18) > (From update of attachment 52553 [details]) > > +JSRetainPtr<JSStringRef> LayoutTestController::markerTextForListItem(JSValueRef nodeObject) const > > +{ > > + gchar* markerTextGChar = webkit_web_frame_marker_text_for_list_item(mainFrame, nodeObject); > > + if (!markerTextGChar) > > + return 0; > > + > > + JSRetainPtr<JSStringRef> markerText(Adopt, JSStringCreateWithUTF8CString(markerTextGChar)); > > + return markerText; > > +} > > There's a storage leak here. You need to g_free markerTextGChar. Will fix. > > #include <JavaScriptCore/JSRetainPtr.h> > > #include <JavaScriptCore/JSStringRefBSTR.h> > > #include <JavaScriptCore/JavaScriptCore.h> > > +#include <JavaScriptCore/JSValueRef.h> > > #include <WebCore/COMPtr.h> > > #include <WebKit/WebKit.h> > > #include <WebKit/WebKitCOMAPI.h> > > Alphabetical order, case sensitive, like the sort tool. That means JSValueRef.h > should be moved up one line. Will fix. > But I really don't get why you need to add an include here at all. > JavaScriptCore.h includes JavaScript.h which in turn includes JSValueRef.h. Yeah, I must say it was a blind guess at the build failure. The win EWS does not seem to provide build logs. :( 208652 20 52559 jwieczorek 2010-04-05 12:55:03 -0700 Created attachment 52559 patch Let me post the patch once again to let the EWS test it on all platforms. Darin, please don't r+ it yet as the EWS does not process reviewed patches. 208657 21 webkit.review.bot 2010-04-05 13:06:03 -0700 Attachment 52559 did not build on gtk: Build output: http://webkit-commit-queue.appspot.com/results/1608243 208659 22 52561 jwieczorek 2010-04-05 13:11:28 -0700 Created attachment 52561 patch (In reply to comment #21) > Attachment 52559 [details] did not build on gtk: > Build output: http://webkit-commit-queue.appspot.com/results/1608243 Oh, that would explain the Windows failure as well. I wonder how it compiled on Mac. 208665 23 webkit.review.bot 2010-04-05 13:21:37 -0700 Attachment 52561 did not build on gtk: Build output: http://webkit-commit-queue.appspot.com/results/1600261 208679 24 darin 2010-04-05 13:52:00 -0700 > gchar* webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSObjectRef nodeObject); You changed the actual function to take a JSValueRef, but this extra definition still has the old signature. I don't know why this definition has to be here, but this is why the GTK build is failing. 208683 25 webkit.review.bot 2010-04-05 14:07:27 -0700 Attachment 52559 did not build on win: Build output: http://webkit-commit-queue.appspot.com/results/1605310 208696 26 52569 jwieczorek 2010-04-05 14:18:29 -0700 Created attachment 52569 patch (In reply to comment #24) > > gchar* webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSObjectRef nodeObject); > > You changed the actual function to take a JSValueRef, but this extra definition > still has the old signature. I don't know why this definition has to be here, > but this is why the GTK build is failing. Yeah, it's not in the public headers. Thanks! I just finished a local build to make sure it builds fine on GTK+. I looked at a diff between the patch that built on win and the last one, and I suspect this is what breaks it: + RenderListItem* item = toRenderListItem(renderer); + Node* otherList = enclosingList(item); // This item is part of our current list, so it's what we're looking for. if (list == otherList) - return toRenderListItem(renderer); + return item; This one should fix it. Thanks for your patience. :) And yay for the EWS! 208698 27 darin 2010-04-05 14:20:28 -0700 (In reply to comment #26) > I looked at a diff between the patch that built on win and the last one, and I > suspect this is what breaks it: > > + RenderListItem* item = toRenderListItem(renderer); > + Node* otherList = enclosingList(item); > // This item is part of our current list, so it's what we're looking > for. > if (list == otherList) > - return toRenderListItem(renderer); > + return item; Ah. The shadowing I mentioned in my review. 208943 28 jwieczorek 2010-04-06 01:22:18 -0700 OK, looks like it builds on all platforms. Darin, if you don't have further comments, could you r+ this patch so I can land it? 209064 29 52569 darin 2010-04-06 08:47:36 -0700 Comment on attachment 52569 patch The downside of waiting for all the EWS compiles is that I forgot the review I did earlier, and had to reread the patch. > + var child = element.firstChild; > + while (child) { > + if (child.nodeType == Node.ELEMENT_NODE) { > + var marker = layoutTestController.markerTextForListItem(child); > + if (marker) > + ret += indent(depth) + ' ' + marker + ' ' + child.innerText.trim() + '<br />'; > + ret += dumpListHelper(child, depth + 1); > + } > + > + child = child.nextSibling; > + } This could be a for loop. Loop could use firstElementChild and nextElementSibling and so avoid the nodeType check. No need for that "/" in "<br />". This is not XHTML; the slash is just ignored. > + return ret; I much prefer words for variable names over fragments of words. > + // Don't show the actual list as it is useless in the text-only mode. > + document.getElementById("list").style.display = "none"; Instead of styling it, you can just remove it from the DOM tree after grabbing a dump of it. r=me 209268 30 jwieczorek 2010-04-06 14:59:10 -0700 Thanks Darin but I'm afraid the patch will need at least one more iteration. :( I was just going to land it but decided to give it a go with a debug build and it turns out we're actually hitting the assertion we decided to add (it's great that you suggested it, otherwise it would remain unspotted): void RenderListItem::updateListMarkerNumbers() { Node* listNode = enclosingList(this); ASSERT(listNode && listNode->renderer()); This happens because of the difference in when ContainerNode detaches a node from the DOM tree: - when removing all children (ContainerNode::removeChildren), it does that _before_ detaching it from the rendering tree - whereas when removing a single child (ContainerNode::removeChild), it does that _afterwards_. We're being hit by the former - in enclosingList() we can't walk up the DOM tree, because there is nowhere we can go. That looks strange to me, but it looks like it's not only me because even the comments next to the code says: // Remove the node from the tree before calling detach or removedFromDocument (4427024, 4129744). // removeChild() does this after calling detach(). There is no explanation for // this discrepancy between removeChild() and its optimized version removeChildren(). (I wonder what these numbers are). Do you think it should be OK to change the enclosingList() function to walk up the rendering tree only? If so, I'm going to upload one more patch tomorrow with a test case for this situation. 209275 31 darin 2010-04-06 15:05:53 -0700 (In reply to comment #30) > Thanks Darin but I'm afraid the patch will need at least one more iteration. :( Sad, but I think our direction is good. > This happens because of the difference in when ContainerNode detaches a node > from the DOM tree: > - when removing all children (ContainerNode::removeChildren), it does that > _before_ detaching it from the rendering tree > - whereas when removing a single child (ContainerNode::removeChild), it does > that _afterwards_. > > We're being hit by the former - in enclosingList() we can't walk up the DOM > tree, because there is nowhere we can go. Irritating that these two are different. > That looks strange to me, but it looks like it's not only me because even the > comments next to the code says: > // Remove the node from the tree before calling detach or removedFromDocument > (4427024, 4129744). > // removeChild() does this after calling detach(). There is no explanation for > // this discrepancy between removeChild() and its optimized version > removeChildren(). Alexey and I wrote this comment recently. Or maybe it was Mitz and me, but we wrote it together. > (I wonder what these numbers are). Those numbers are Apple Radar bug numbers. Bug 4427024 was reported in 2006 and was about this crash: http://www.formassembly.com/form-builder.php? Safari consistently crashes when using this AJAX demo. Follow the instructions.. click on the link "unnamed form" on the left) type in a name for the form as instructed, hit" return" after that - Safari crashes. Bug 4129744 was <http://trac.webkit.org/changeset/14045>. There is a test case included. > Do you think it should be OK to change the enclosingList() function to walk up > the rendering tree only? Maybe, but we'll have to quite a bit more testing to make that change. In fact, I suggest you make that change separately before changing how list item markers are updated. 209469 32 52553 eric 2010-04-06 23:43:37 -0700 Comment on attachment 52553 patch Cleared Darin Adler's review+ from obsolete attachment 52553 so that this bug does not appear in http://webkit.org/pending-commit. 209653 33 jwieczorek 2010-04-07 08:47:03 -0700 (In reply to comment #31) > Alexey and I wrote this comment recently. Or maybe it was Mitz and me, but we > wrote it together. > > > (I wonder what these numbers are). > > Those numbers are Apple Radar bug numbers. > > Bug 4427024 was reported in 2006 and was about this crash: > > http://www.formassembly.com/form-builder.php? > Safari consistently crashes when using this AJAX demo. > Follow the instructions.. click on the link "unnamed form" on the left) > type in a name for the form as instructed, hit" return" after that - Safari > crashes. > > Bug 4129744 was <http://trac.webkit.org/changeset/14045>. There is a test case > included. Thanks for this data. > > Do you think it should be OK to change the enclosingList() function to walk up > > the rendering tree only? > > Maybe, but we'll have to quite a bit more testing to make that change. In fact, > I suggest you make that change separately before changing how list item markers > are updated. That sounds good but I wonder if I need a test case for this? If so, it might be hard to come up with one as this does not really affect the current code. If not, I can definitely do that as a separate change. 209664 34 darin 2010-04-07 09:13:47 -0700 (In reply to comment #33) > > > Do you think it should be OK to change the enclosingList() function to walk up > > > the rendering tree only? > > > > Maybe, but we'll have to quite a bit more testing to make that change. In fact, > > I suggest you make that change separately before changing how list item markers > > are updated. > > That sounds good but I wonder if I need a test case for this? If so, it might > be hard to come up with one as this does not really affect the current code. If > not, I can definitely do that as a separate change. You should definitely do the change separately whether or not it changes behavior. If it's just a refactoring that helps with your later change, that's good too. You say it "does really affect the current code". I find that surprising since the DOM tree and render tree don't always have identical hierarchies, but maybe I'm wrong about that. You can make the change and just add a test case that helps demonstrate the change didn't break anything, or even no test case at all if you find specific tests that you think cover it well enough. 210459 35 52910 jwieczorek 2010-04-08 16:04:05 -0700 Created attachment 52910 2nd changeset > You say it "does really affect the current code". I find that surprising since > the DOM tree and render tree don't always have identical hierarchies, but maybe > I'm wrong about that. You're right here. This could be a dangerous change to make. I'm not sure if it would work correctly with e.g. the list object living in a different layer than an item. That's only a guess as I haven't tested that. I think we can make a safer and a simpler change that will address the issue. Posting the proposed change here in a separate patch as you suggested. I should have filed another bug for it probably but I'm not sure if it's not better to incorporate it to the first one if it's an one-liner (with no tests and a comment that is not true until the main patch gets in). I'm planning on doing the proper testing tomorrow to see if it's the right to do. 210460 36 darin 2010-04-08 16:05:43 -0700 (In reply to comment #35) > > You say it "does really affect the current code". I find that surprising since > > the DOM tree and render tree don't always have identical hierarchies, but maybe > > I'm wrong about that. > > You're right here. This could be a dangerous change to make. I'm not sure if it > would work correctly with e.g. the list object living in a different layer than > an item. That's only a guess as I haven't tested that. I think we can make a > safer and a simpler change that will address the issue. My take on this is that I think it will be safe, and in fact is an improvement in making things logical, but we should think about the likely edge cases and make tests. 210961 37 52999 jwieczorek 2010-04-09 15:20:53 -0700 Created attachment 52999 Use render tree to find the enclosing list (In reply to comment #36) > My take on this is that I think it will be safe, and in fact is an improvement > in making things logical, but we should think about the likely edge cases and > make tests. OK, sounds good to me. I am posting the patch now but I'm going to see if we can include some tests with this change. The existing test coverage seems to be pretty good but there might be some edge cases that I could have missed and that the existing tests also don't cover. However, it seems that we will need to get the DRT support from the 1st patch first landed if we want to include any plain text tests. We could also make this single change without adding new tests and let them come with the other patch. I'm fine with either of the options. 212853 38 jwieczorek 2010-04-15 07:59:25 -0700 Darin, could you take a look at this? 214315 39 52999 darin 2010-04-19 16:13:31 -0700 Comment on attachment 52999 Use render tree to find the enclosing list This change seems OK. I think we should consider using the renderer itself to represent the list rather than the renderer's node. Thus the return value would have a type of RenderObject* rather than Node*. I also think that the argument should be RenderListItem* rather than const RenderListeItem*. I don't know why we made it const! 214673 40 jwieczorek 2010-04-20 08:12:38 -0700 (In reply to comment #39) > I think we should consider using the renderer itself to represent the list > rather than the renderer's node. Thus the return value would have a type of > RenderObject* rather than Node*. If you don't mind, I'll be happy to do this in a follow-up patch. > I also think that the argument should be RenderListItem* rather than const > RenderListeItem*. I don't know why we made it const! I know that it is not a common practice in WebKit but in this case we're calling it in const contexts, so yes, it's necessary. 214711 41 darin 2010-04-20 09:59:33 -0700 (In reply to comment #40) > (In reply to comment #39) > > I think we should consider using the renderer itself to represent the list > > rather than the renderer's node. Thus the return value would have a type of > > RenderObject* rather than Node*. > > If you don't mind, I'll be happy to do this in a follow-up patch. Yes. I meant to leave that decision in your hands, otherwise I would have used review- and asked for it more forcefully. > > I also think that the argument should be RenderListItem* rather than const > > RenderListeItem*. I don't know why we made it const! > > I know that it is not a common practice in WebKit but in this case we're > calling it in const contexts, so yes, it's necessary. I think that those const contexts are probably unwise -- const member functions where the const provides little or no benefit -- but changing that has little to do with your patch and this was a sort of "side comment" rather than some action I wanted you to take. 214764 42 52999 jwieczorek 2010-04-20 10:48:28 -0700 Comment on attachment 52999 Use render tree to find the enclosing list Committed in http://trac.webkit.org/changeset/57893. 215018 43 53896 jwieczorek 2010-04-20 15:35:05 -0700 Created attachment 53896 patch Getting back to the first patch. It does no longer apply against ToT (partially due to a recent Qt DRT refactoring), let me post a slightly rebased version (moved the Qt private API from QWebFramePrivate to the new DumpRenderTreeSupportQt). (In reply to comment #29) > (From update of attachment 52569 [details]) > The downside of waiting for all the EWS compiles is that I forgot the review I > did earlier, and had to reread the patch. > > > + var child = element.firstChild; > > + while (child) { > > + if (child.nodeType == Node.ELEMENT_NODE) { > > + var marker = layoutTestController.markerTextForListItem(child); > > + if (marker) > > + ret += indent(depth) + ' ' + marker + ' ' + child.innerText.trim() + '<br />'; > > + ret += dumpListHelper(child, depth + 1); > > + } > > + > > + child = child.nextSibling; > > + } > > This could be a for loop. Loop could use firstElementChild and > nextElementSibling and so avoid the nodeType check. > > No need for that "/" in "<br />". This is not XHTML; the slash is just ignored. > > > + return ret; > > I much prefer words for variable names over fragments of words. > > > + // Don't show the actual list as it is useless in the text-only mode. > > + document.getElementById("list").style.display = "none"; > > Instead of styling it, you can just remove it from the DOM tree after grabbing > a dump of it. Fixed all of them. I'm afraid the LayoutTestController patch will need to be changed to pass the JS context to the private functions in each port, just like the new computedStyleIncludingVisitedInfo API does. I had no idea that there was an assertion about the context not being 0 in the JSC C API, even though it is not actually used. I'm not a big fan of this but that's what computedStyleIncludingVisitedInfo does. Following this idea seems like the best choice. Darin, these are the only changes I've made compared to the old version, hopefully it doesn't involve much effort from you. Thanks in advance. 215078 44 53896 darin 2010-04-20 17:26:18 -0700 Comment on attachment 53896 patch > + RenderObject* child = this->nextInPreOrder(list); No need for "this->" here. > + if (newChild->isListItem()) > + toRenderListItem(newChild)->updateListMarkerNumbers(); After looking at this over and over again, I realized that we should probably just put a virtual updateListMarkerNumbers function into RenderObject. Because the code is just making a virtual function call to get the answer for whether something is a list item, which is just a slower less elegant way of calling virtual function in the first place. > + String markerText = markerTextForListItem(element); > + return g_strdup(markerText.utf8().data()); Seems to me we don't really need the local variable here. > friend class QWebFrame; > + friend class DumpRenderTreeSupportQt; > friend class QWebElementCollection; > friend class QWebHitTestResult; > friend class QWebHitTestResultPrivate; Normally we keep these in alphabetical order. > + Element* element = listItem.m_element; > + return WebCore::markerTextForListItem(element); Seems to me we don't really need the local variable here. 215339 45 jwieczorek 2010-04-21 08:42:47 -0700 Thanks, will fix all of these except for: > After looking at this over and over again, I realized that we should probably > just put a virtual updateListMarkerNumbers function into RenderObject. Because > the code is just making a virtual function call to get the answer for whether > something is a list item, which is just a slower less elegant way of calling > virtual function in the first place. Because I don't think having a virtual function in RenderObject would make that code more elegant. It doesn't seem to belong there and in fact, it would be somewhat confusing as updateListMarkerNumbers() would always do nothing for renderers other than RenderListItem and that wouldn't be that obvious from just reading the code that calls the function as it is now. 215341 46 jwieczorek 2010-04-21 08:45:25 -0700 Committed in http://trac.webkit.org/changeset/57986. 215346 47 webkit.review.bot 2010-04-21 09:04:19 -0700 http://trac.webkit.org/changeset/57986 might have broken SnowLeopard Intel Release (Tests) 215347 48 jwieczorek 2010-04-21 09:06:38 -0700 (In reply to comment #47) > http://trac.webkit.org/changeset/57986 might have broken SnowLeopard Intel > Release (Tests) Fixed in http://trac.webkit.org/changeset/57989. For some reason the Skipped list changes disappeared in between the review iterations. 52494 2010-04-03 04:23:06 -0700 2010-04-03 04:23:06 -0700 test case test2.html text/html 513 jwieczorek PGh0bWw+CiAgICA8aGVhZD4KICAgICAgICA8c2NyaXB0PgogICAgICAgICAgICBmdW5jdGlvbiB0 ZXN0KCkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgiZm9vIik7CiAgICAgICAgICAgICAgICB2YXIgbGkgPSBkb2N1bWVudC5jcmVh dGVFbGVtZW50KCJsaSIpOwogICAgICAgICAgICAgICAgbGkuaW5uZXJIVE1MID0gInRlc3QiOwog ICAgICAgICAgICAgICAgcC5hcHBlbmRDaGlsZChsaSk7CiAgICAgICAgICAgIH0KICAgICAgICA8 L3NjcmlwdD4KICAgIDwvaGVhZD4KICAgIDxib2R5IG9ubG9hZD0ic2V0VGltZW91dCh0ZXN0LCAz MDAwKSI+CiAgICAgICAgPG9sPgogICAgICAgICAgICA8bGk+Zm9vPC9saT4KICAgICAgICAgICAg PGxpPmJhcjwvbGk+CiAgICAgICAgICAgIDxwIGlkPSJmb28iPgoKICAgICAgICAgICAgPC9wPgog ICAgICAgICAgICA8bGk+YmF6PC9saT4KICAgICAgICA8L29sPgogICAgPC9ib2R5Pgo8L2h0bWw+ 52495 2010-04-03 04:36:27 -0700 2010-04-04 06:42:23 -0700 patch ol-update-markers-after-dom-changes.patch text/plain 36281 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4ZmNiOTBkLi4xNzdhNmQzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjcgQEAKKzIwMTAtMDQt MDMgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKwogMjAxMC0wNC0wMyAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5j b20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gRmlzaGVyLgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9kdW1wLWxpc3QuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3Rz L2R1bXAtbGlzdC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hYjRhM2I4 Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9kdW1wLWxpc3QuanMK QEAgLTAsMCArMSwzMSBAQAorZnVuY3Rpb24gaW5kZW50KGRlcHRoKQoreworICAgIHZhciByZXQg PSBuZXcgU3RyaW5nKCk7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBkZXB0aDsgKytpKQorICAg ICAgICByZXQgKz0gIi0+ICI7CisgICAgcmV0dXJuIHJldCArICIgIjsKK30KKworZnVuY3Rpb24g ZHVtcExpc3RIZWxwZXIoZWxlbWVudCwgZGVwdGgpCit7CisgICAgdmFyIHJldCA9IG5ldyBTdHJp bmcoKTsKKworICAgIHZhciBjaGlsZCA9IGVsZW1lbnQuZmlyc3RDaGlsZDsKKyAgICB3aGlsZSAo Y2hpbGQpIHsKKyAgICAgICAgaWYgKGNoaWxkLm5vZGVUeXBlID09IE5vZGUuRUxFTUVOVF9OT0RF KSB7CisgICAgICAgICAgICB2YXIgbWFya2VyID0gbGF5b3V0VGVzdENvbnRyb2xsZXIubWFya2Vy VGV4dEZvckxpc3RJdGVtKGNoaWxkKTsKKyAgICAgICAgICAgIGlmIChtYXJrZXIpCisgICAgICAg ICAgICAgICAgcmV0ICs9IGluZGVudChkZXB0aCkgKyAnICcgKyBtYXJrZXIgKyAnICcgKyBjaGls ZC5pbm5lclRleHQudHJpbSgpICsgJzxiciAvPic7CisgICAgICAgICAgICByZXQgKz0gZHVtcExp c3RIZWxwZXIoY2hpbGQsIGRlcHRoICsgMSk7CisgICAgICAgIH0KKworICAgICAgICBjaGlsZCA9 IGNoaWxkLm5leHRTaWJsaW5nOworICAgIH0KKworICAgIHJldHVybiByZXQ7Cit9CisKK2Z1bmN0 aW9uIGR1bXBMaXN0KGxpc3QpCit7CisgICAgcmV0dXJuIGR1bXBMaXN0SGVscGVyKGxpc3QsIDAp OworfQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMt ZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLmYzOTY0OTYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQK QEAgLTAsMCArMSwxNCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1 cGRhdGVkIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyBhcyBpbmRpcmVjdCBjaGlsZHJlbiBvZiB0aGUg bGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKy0+IDMgVGhyZWUKKzQgRm91cgorNSBGaXZl Cis2IFNpeAorLT4gNyBTZXZlbgorLT4gOCBFaWdodAorLT4gOSBOaW5lCisxMCBUZW4KKzExIEVs ZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVt cy1keW5hbWljLWluc2VydC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZHluYW1pYy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi5hMjk4MDJiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9v bC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQuaHRtbApAQCAtMCwwICsxLDUzIEBACis8aHRt bD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAg ICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAg eworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAg ICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsK KyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNldFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKwor ICAgICAgICAgICAgICAgIHZhciBwID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm5lc3RlZCIp OworCisgICAgICAgICAgICAgICAgdmFyIGxpMSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxp Iik7CisgICAgICAgICAgICAgICAgbGkxLmlubmVyVGV4dCA9ICJFaWdodCI7CisKKyAgICAgICAg ICAgICAgICB2YXIgbGkyID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgibGkiKTsKKyAgICAgICAg ICAgICAgICBsaTIuaW5uZXJUZXh0ID0gIlNldmVuIjsKKworICAgICAgICAgICAgICAgIHZhciBp dGVtMyA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImRpdiIpOworICAgICAgICAgICAgICAgIGl0 ZW0zLmlubmVyVGV4dCA9ICJOaW5lIjsKKyAgICAgICAgICAgICAgICBpdGVtMy5zdHlsZS5kaXNw bGF5ID0gImxpc3QtaXRlbSI7CisKKyAgICAgICAgICAgICAgICBwLmFwcGVuZENoaWxkKGxpMSk7 CisgICAgICAgICAgICAgICAgcC5pbnNlcnRCZWZvcmUobGkyLCBsaTEpOworICAgICAgICAgICAg ICAgIHAuYXBwZW5kQ2hpbGQoaXRlbTMpOworCisgICAgICAgICAgICAgICAgbGlzdC5vZmZzZXRU b3A7IC8vIEZvcmNlIGEgcmVsYXlvdXQuCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAgICAg ICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxlc3Mg aW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgpIj4K KyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRhdGVk IHdoZW4gYWRkaW5nIG5ldyBpdGVtcyBhcyBpbmRpcmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBl bGVtZW50LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAgICAgICAgICAgIDxsaT5PbmU8 L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAgICA8ZGl2PjxsaT5UaHJl ZTwvbGk+PC9kaXY+CisgICAgICAgICAgICA8bGk+Rm91cjwvbGk+CisgICAgICAgICAgICA8bGk+ Rml2ZTwvbGk+CisgICAgICAgICAgICA8bGk+U2l4PC9saT4KKyAgICAgICAgICAgIDxwIGlkPSJu ZXN0ZWQiPjwvcD4KKyAgICAgICAgICAgIDxsaT5UZW48L2xpPgorICAgICAgICAgICAgPGxpPkVs ZXZlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBpZD0iY29uc29sZSI+PC9k aXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMt cmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0 ZW1zLWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5iZTQ1MzA5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9s aXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0CkBAIC0wLDAg KzEsMTAgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBhcmUgdXBkYXRlZCB3 aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIHRoYXQgYXJlIG5vdCBkaXJlY3QgY2hpbGRyZW4g b2YgdGhlIGxpc3QgZWxlbWVudC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUg Rml2ZQorNiBTaXgKKzcgU2V2ZW4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3ZlLmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uYWEzYjY5OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3ZlLmh0bWwKQEAgLTAs MCArMSw1MiBAQAorPGh0bWw+CisgICAgPGhlYWQ+CisgICAgICAgIDxzY3JpcHQgc3JjPSJkdW1w LWxpc3QuanMiIC8+CisgICAgICAgIDxzY3JpcHQ+CisgICAgICAgICAgICBmdW5jdGlvbiB0ZXN0 KCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQorICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CisKKyAgICAgICAgICAgICAgICB2YXIgbGlzdCA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJsaXN0Iik7CisgICAgICAgICAgICAgICAgbGlzdC5vZmZzZXRUb3A7IC8vIEZvcmNl IGEgcmVsYXlvdXQuCisKKyAgICAgICAgICAgICAgICB2YXIgYiA9IGRvY3VtZW50LmdldEVsZW1l bnRzQnlUYWdOYW1lKCJiIilbMF07CisgICAgICAgICAgICAgICAgbGlzdC5yZW1vdmVDaGlsZChi KTsKKworICAgICAgICAgICAgICAgIHZhciBkaXYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi bmVzdGVkIik7CisgICAgICAgICAgICAgICAgdmFyIGl0ZW1zID0gZGl2LmNoaWxkcmVuLmxlbmd0 aDsKKyAgICAgICAgICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IGl0ZW1zOyArK2kpCisgICAg ICAgICAgICAgICAgICAgIGRpdi5yZW1vdmVDaGlsZChkaXYuZmlyc3RFbGVtZW50Q2hpbGQpOwor CisgICAgICAgICAgICAgICAgbGlzdC5yZW1vdmVDaGlsZChkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiaXRlbSIpKTsKKworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBh IHJlbGF5b3V0LgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25z b2xlIikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBE b24ndCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9u bHkgbW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIp LnN0eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0 PgorICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRo aXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBhcmUgdXBkYXRlZCB3aGVuIHJlbW92aW5n IGV4aXN0aW5nIGl0ZW1zIHRoYXQgYXJlIG5vdCBkaXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxpc3Qg ZWxlbWVudC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+CisgICAgICAgICAgICA8bGk+T25l PC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgPGI+PGxpPkZvbzwv bGk+PC9iPgorICAgICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgIDxsaT5Gb3Vy PC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlPC9saT4KKyAgICAgICAgICAgIDxkaXYgaWQ9Im5l c3RlZCI+CisgICAgICAgICAgICAgICAgPGxpPkZvbzwvbGk+CisgICAgICAgICAgICAgICAgPGxp PkJhcjwvbGk+CisgICAgICAgICAgICAgICAgPGxpPkJhejwvbGk+CisgICAgICAgICAgICA8L2Rp dj4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgPGRpdiBpZD0iaXRlbSIg c3R5bGU9ImRpc3BsYXk6IGxpc3QtaXRlbSI+Rm9vPC9kaXY+CisgICAgICAgICAgICA8bGk+U2V2 ZW48L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2 PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1leHBlY3RlZC50 eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDM0YjM2NgotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVy bHkgbWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRlbXMgYXJlIGluZGlyZWN0IGNoaWxkcmVuIG9m IHRoZSBsaXN0IGVsZW1lbnQuCisKKzEgT25lCisyIFR3bworMyBUaHJlZQorNCBGb3VyCistPiA1 IEZpdmUKKy0+IDYgU2l4CisxMCBUZW4KKzExIEVsZXZlbgorLT4gMTIgVHdlbHZlCistPiAxMyBU aGlydGVlbgorMTQgRm91cnRlZW4KKzE1IEZpZnRlZW4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWl0ZW1zLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MC4uODEzOWY5ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wt bmVzdGVkLWl0ZW1zLmh0bWwKQEAgLTAsMCArMSw0MyBAQAorPGh0bWw+CisgICAgPGhlYWQ+Cisg ICAgICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+CisgICAgICAgIDxzY3JpcHQ+Cisg ICAgICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAg ICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgICAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAgICAgICAgICAgICB2YXIg bGlzdCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iik7CisgICAgICAgICAgICAgICAg bGlzdC5vZmZzZXRUb3A7IC8vIEZvcmNlIGEgcmVsYXlvdXQuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0 KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0 IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9h ZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHBy b3Blcmx5IG1hcmtlZCB3aGVuIHNvbWUgb2YgdGhlIGl0ZW1zIGFyZSBpbmRpcmVjdCBjaGlsZHJl biBvZiB0aGUgbGlzdCBlbGVtZW50LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAgICAg ICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAg ICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXIKKyAgICAgICAgICAgICAgICA8 Yj4KKyAgICAgICAgICAgICAgICAgICAgPGxpPkZpdmU8L2xpPgorICAgICAgICAgICAgICAgICAg ICA8bGk+U2l4PC9saT4KKyAgICAgICAgICAgICAgICA8L2I+CisgICAgICAgICAgICA8L2xpPgor ICAgICAgICAgICAgPGxpIHZhbHVlPSIxMCI+VGVuPC9saT4KKyAgICAgICAgICAgIDxsaT5FbGV2 ZW48L2xpPgorICAgICAgICAgICAgPGRpdj4KKyAgICAgICAgICAgICAgICA8bGk+VHdlbHZlPC9s aT4KKyAgICAgICAgICAgICAgICA8bGk+VGhpcnRlZW48L2xpPgorICAgICAgICAgICAgPC9kaXY+ CisgICAgICAgICAgICA8bGk+Rm91cnRlZW48L2xpPgorICAgICAgICAgICAgPGxpPkZpZnRlZW48 L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2Pgor ICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0 LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHlu YW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjM2ZjA5OGUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29s LW5lc3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEzIEBA CitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIGFk ZGluZyBuZXcgaXRlbXMgdG8gYSBuZXN0ZWQgbGlzdC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVl Cis0IEZvdXIKKzUgRml2ZSBPbmUgVHdlbnR5IGZpdmUgVHdlbnR5IHNpeAorLT4gLT4gMSBPbmUK Ky0+IC0+IDI1IFR3ZW50eSBmaXZlCistPiAtPiAyNiBUd2VudHkgc2l4Cis2IFNpeAorNyBTZXZl bgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5 bmFtaWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0 LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u MzE5ZTA4YQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVz dGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbApAQCAtMCwwICsxLDQ5IEBACis8aHRtbD4KKyAg ICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAg PHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAg ICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAg ICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAg ICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAg ICAgICAgICAgICBsaXN0Lm9mZnNldFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKworICAgICAg ICAgICAgICAgIHZhciBuZXN0ZWRMaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm5lc3Rl ZC1saXN0Iik7CisKKyAgICAgICAgICAgICAgICB2YXIgbGkyID0gZG9jdW1lbnQuY3JlYXRlRWxl bWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTIuaW5uZXJUZXh0ID0gIlR3ZW50eSBmaXZl IjsKKyAgICAgICAgICAgICAgICBsaTIudmFsdWUgPSAiMjUiOworICAgICAgICAgICAgICAgIHZh ciBsaTEgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxp MS5pbm5lclRleHQgPSAiT25lIjsKKyAgICAgICAgICAgICAgICB2YXIgbGkzID0gZG9jdW1lbnQu Y3JlYXRlRWxlbWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTMuaW5uZXJUZXh0ID0gIlR3 ZW50eSBzaXgiOworCisgICAgICAgICAgICAgICAgbmVzdGVkTGlzdC5hcHBlbmRDaGlsZChsaTIp OworICAgICAgICAgICAgICAgIG5lc3RlZExpc3QuaW5zZXJ0QmVmb3JlKGxpMSwgbGkyKTsKKyAg ICAgICAgICAgICAgICBuZXN0ZWRMaXN0LmFwcGVuZENoaWxkKGxpMyk7CisKKyAgICAgICAgICAg ICAgICBsaXN0Lm9mZnNldFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKyAgICAgICAgICAgICAg ICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0 KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3Qg YXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOwor ICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkg b25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1h cmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIGFkZGluZyBuZXcgaXRlbXMgdG8gYSBuZXN0ZWQgbGlz dC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+CisgICAgICAgICAgICA8bGk+T25lPC9saT4K KyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAg ICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlIDxvbCBpZD0ibmVz dGVkLWxpc3QiPjwvb2w+PC9saT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAg ICAgPGxpPlNldmVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlkPSJjb25z b2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2Yg ZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1k eW5hbWljLXJlbW92ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi42NjkxMWIzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS1leHBlY3RlZC50eHQKQEAg LTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGRvIG5vdCBj aGFuZ2Ugd2hlbiByZW1vdmluZyBleGlzdGluZyBpdGVtcyBmcm9tIGEgbmVzdGVkIGxpc3QuCisK KzEgT25lCisyIFR3bworMyBUaHJlZQorNCBGb3VyCis1IEZpdmUKKzEgT25lCisyIFR3bworCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFt aWMtcmVtb3ZlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzgyNGZh YQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxp c3QtZHluYW1pYy1yZW1vdmUuaHRtbApAQCAtMCwwICsxLDQ2IEBACis8aHRtbD4KKyAgICA8aGVh ZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlw dD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAg ICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAg IHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAg ICAgICBsaXN0Lm9mZnNldFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKworICAgICAgICAgICAg ICAgIHZhciBuZXN0ZWRMaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm5lc3RlZC1saXN0 Iik7CisgICAgICAgICAgICAgICAgdmFyIGl0ZW1zID0gbmVzdGVkTGlzdC5jaGlsZHJlbi5sZW5n dGg7CisgICAgICAgICAgICAgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBpdGVtczsgKytpKQorICAg ICAgICAgICAgICAgICAgICBuZXN0ZWRMaXN0LnJlbW92ZUNoaWxkKG5lc3RlZExpc3QuZmlyc3RF bGVtZW50Q2hpbGQpOworCisgICAgICAgICAgICAgICAgbGlzdC5vZmZzZXRUb3A7IC8vIEZvcmNl IGEgcmVsYXlvdXQuCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNv bnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAgICAgICAgICAgICAgIC8v IERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQt b25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0 Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgPC9zY3Jp cHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgpIj4KKyAgICAgICAgPHA+ VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGRvIG5vdCBjaGFuZ2Ugd2hlbiByZW1v dmluZyBleGlzdGluZyBpdGVtcyBmcm9tIGEgbmVzdGVkIGxpc3QuPC9wPgorICAgICAgICA8b2wg aWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdv PC9saT4KKyAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+Rm91cjwv bGk+CisgICAgICAgICAgICA8bGk+Rml2ZQorICAgICAgICAgICAgICAgIDxvbCBpZD0ibmVzdGVk LWxpc3QiPgorICAgICAgICAgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgICAg ICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+Cisg ICAgICAgICAgICAgICAgPC9vbD4KKyAgICAgICAgICAgIDwvbGk+CisgICAgICAgICAgICA8bGkg dmFsdWU9IjEiPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgPC9v bD4KKworICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0 bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi5kZmY1M2ViCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxNSBAQAorVGhp cyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHByb3Blcmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0 IGNvbnRhaW5zIG5lc3RlZCBsaXN0cy4KKworMTAgVGVuCisxMSBFbGV2ZW4KKzEyIFR3ZWx2ZQor MTMgVGhpcnRlZW4gT25lIFR3bworLT4gLT4g4pemIE9uZQorLT4gLT4g4pemIFR3bworMTQgRm91 cnRlZW4KKzE1IEZpZnRlZW4KKy0+IDEgT25lCistPiAyIFR3bworMTYgU2l4dGVlbgorMTcgU2V2 ZW50ZWVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxp c3QuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44YzQ1ZDZmCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sCkBAIC0wLDAgKzEs NDMgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xl IikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBEb24n dCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9ubHkg bW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpLnN0 eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0Pgor ICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMg dGVzdHMgdGhhdCBsaXN0IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJrZWQgd2hlbiB0aGUgbGlzdCBj b250YWlucyBuZXN0ZWQgbGlzdHMuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiIHN0YXJ0PSIx MCI+CisgICAgICAgICAgICA8bGk+VGVuPC9saT4KKyAgICAgICAgICAgIDxsaT5FbGV2ZW48L2xp PgorICAgICAgICAgICAgPGxpPlR3ZWx2ZTwvbGk+CisgICAgICAgICAgICA8bGk+VGhpcnRlZW4K KyAgICAgICAgICAgICAgICA8dWw+CisgICAgICAgICAgICAgICAgICAgIDxsaT5PbmU8L2xpPgor ICAgICAgICAgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgICAgICA8L3VsPgor ICAgICAgICAgICAgPC9saT4KKyAgICAgICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+CisgICAgICAg ICAgICA8bGk+RmlmdGVlbjwvbGk+CisgICAgICAgICAgICA8b2w+CisgICAgICAgICAgICAgICAg PGxpPk9uZTwvbGk+CisgICAgICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAgICA8 L29sPgorICAgICAgICAgICAgPGxpPlNpeHRlZW48L2xpPgorICAgICAgICAgICAgPGxpPlNldmVu dGVlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBpZD0iY29uc29sZSI+PC9k aXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWJm MjA2MC4uMjMxMjA1OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29y ZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAxMC0wNC0wMyAgSmFrdWIgV2llY3pvcmVr ICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0 ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzcwNjAKKworICAgICAgICBJbiBwYXJ0aWN1bGFyLCB0aGV5 IHdvdWxkIG5vdCBiZSB1cGRhdGVkIHdoZW4gYWRkaW5nL3JlbW92aW5nIGFuIGl0ZW0KKyAgICAg ICAgdGhhdCBpcyBub3QgYSBkaXJlY3QgY2hpbGQgb2YgdGhlIGxpc3QgZWxlbWVudC4KKworICAg ICAgICBUZXN0czogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQuaHRt bAorICAgICAgICAgICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1v dmUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbAor ICAgICAgICAgICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5o dG1sCisgICAgICAgICAgICAgICBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVt b3ZlLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRtbAor CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmVuY2xvc2luZ0xpc3QpOiBTaW1wbGlmeSBhbmQgZml4IGl0IHRvIHdvcmsgcHJvcGVybHkg d2l0aCBhbm9ueW1vdXMgcmVuZGVyIG9iamVjdHMuCisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVM aXN0TWFya2VyTnVtYmVycyk6IENoYW5nZSBpdCB0byB0cmF2ZXJzZSB0aGUgd2hvbGUgc3VidHJl ZSBvZiBhIGxpc3QsIG5vdCBvbmx5IHNpYmxpbmdzIG9mIGFuIGl0ZW0uCisgICAgICAgICogcmVu ZGVyaW5nL1JlbmRlckxpc3RJdGVtLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVj dC5jcHA6IE1vdmUgdGhlIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzIGZ1bmN0aW9uIHRvIFJlbmRl ckxpc3RJdGVtLmNwcC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6YWRkQ2hpbGQp OiBNb3ZlIHRoZSBjb2RlIHVwZGF0aW5nIGxpc3QgbWFya2VycyB0byBSZW5kZXJPYmplY3RDaGls ZExpc3QgZm9yIGNvbnNpc3RlbmN5LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RD aGlsZExpc3QuY3BwOiBNb3ZlIHRoZSB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlvbiB0 byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3RDaGls ZExpc3Q6OnJlbW92ZUNoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5nIHJlbW92 ZWQsIG5vdCB0aGUgbmV4dCBzaWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Q2hpbGRMaXN0OjphcHBlbmRDaGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyBh ZGRlZCwgbm90IHRoZSBuZXh0IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmpl Y3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5n IGFkZGVkLCBub3QgdGhlIG5leHQgc2libGluZy4KKwogMjAxMC0wNC0wMyAgS2VubmV0aCBSdXNz ZWxsICA8a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gRmlzaGVy LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwIGIvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCmluZGV4IDU0YTdkZDIuLjdjODU0MDgg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmNwcAorKysgYi9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKQEAgLTk0LDE1ICs5NCwxMyBAQCBz dGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChOb2RlKiBub2RlKQogCiBzdGF0aWMgTm9kZSogZW5j bG9zaW5nTGlzdChjb25zdCBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogewotICAgIE5vZGUqIG5v ZGUgPSByZW5kZXJlci0+bm9kZSgpOwotICAgIGlmIChub2RlKQotICAgICAgICByZXR1cm4gZW5j bG9zaW5nTGlzdChub2RlKTsKLQotICAgIHJlbmRlcmVyID0gcmVuZGVyZXItPnBhcmVudCgpOwog ICAgIHdoaWxlIChyZW5kZXJlciAmJiAhcmVuZGVyZXItPm5vZGUoKSkKICAgICAgICAgcmVuZGVy ZXIgPSByZW5kZXJlci0+cGFyZW50KCk7CiAKLSAgICBub2RlID0gcmVuZGVyZXItPm5vZGUoKTsK KyAgICBpZiAoIXJlbmRlcmVyKQorICAgICAgICByZXR1cm4gMDsKKworICAgIE5vZGUqIG5vZGUg PSByZW5kZXJlci0+bm9kZSgpOwogICAgIGlmIChpc0xpc3Qobm9kZSkpCiAgICAgICAgIHJldHVy biBub2RlOwogCkBAIC0zNjQsNCArMzYyLDI2IEBAIHZvaWQgUmVuZGVyTGlzdEl0ZW06OmNsZWFy RXhwbGljaXRWYWx1ZSgpCiAgICAgZXhwbGljaXRWYWx1ZUNoYW5nZWQoKTsKIH0KIAordm9pZCB1 cGRhdGVMaXN0TWFya2VyTnVtYmVycyhSZW5kZXJPYmplY3QqIGxpc3RJdGVtKQoreworICAgIEFT U0VSVChsaXN0SXRlbS0+aXNMaXN0SXRlbSgpKTsKKworICAgIE5vZGUqIGxpc3ROb2RlID0gZW5j bG9zaW5nTGlzdChsaXN0SXRlbSk7CisgICAgUmVuZGVyT2JqZWN0KiBsaXN0ID0gbGlzdE5vZGUg PyBsaXN0Tm9kZS0+cmVuZGVyZXIoKSA6IDA7CisKKyAgICBSZW5kZXJPYmplY3QqIGNoaWxkID0g bGlzdEl0ZW0tPm5leHRJblByZU9yZGVyKGxpc3QpOworICAgIHdoaWxlIChjaGlsZCkgeworICAg ICAgICBpZiAoY2hpbGQtPm5vZGUoKSAmJiBpc0xpc3QoY2hpbGQtPm5vZGUoKSkpIHsKKyAgICAg ICAgICAgIC8vIFdlJ3ZlIGZvdW5kIGEgbmVzdGVkLCBpbmRlcGVuZGVudCBsaXN0IC0gbm90aGlu ZyB0byBkbyBoZXJlLgorICAgICAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEluUHJlT3JkZXJB ZnRlckNoaWxkcmVuKGxpc3QpOworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKwor ICAgICAgICBpZiAoY2hpbGQtPmlzTGlzdEl0ZW0oKSkKKyAgICAgICAgICAgIHRvUmVuZGVyTGlz dEl0ZW0oY2hpbGQpLT51cGRhdGVWYWx1ZSgpOworCisgICAgICAgIGNoaWxkID0gY2hpbGQtPm5l eHRJblByZU9yZGVyKGxpc3QpOworICAgIH0KK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uaCBiL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmgKaW5kZXggYzRjNDFkYy4uY2JhYTY3OCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uaAorKysgYi9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oCkBAIC04Niw2ICs4Niw4IEBAIGlubGluZSBSZW5kZXJM aXN0SXRlbSogdG9SZW5kZXJMaXN0SXRlbShSZW5kZXJPYmplY3QqIG9iamVjdCkKIC8vIFRoaXMg d2lsbCBjYXRjaCBhbnlvbmUgZG9pbmcgYW4gdW5uZWNlc3NhcnkgY2FzdC4KIHZvaWQgdG9SZW5k ZXJMaXN0SXRlbShjb25zdCBSZW5kZXJMaXN0SXRlbSopOwogCit2b2lkIHVwZGF0ZUxpc3RNYXJr ZXJOdW1iZXJzKFJlbmRlck9iamVjdCogbGlzdEl0ZW0pOworCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCiAKICNlbmRpZiAvLyBSZW5kZXJMaXN0SXRlbV9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJPYmplY3QuY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0 LmNwcAppbmRleCA3MDAwYjcwLi4xZjVmNDQwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5j cHAKQEAgLTI1NywxNCArMjU3LDYgQEAgYm9vbCBSZW5kZXJPYmplY3Q6OmlzSFRNTE1hcnF1ZWUo KSBjb25zdAogICAgIHJldHVybiBub2RlKCkgJiYgbm9kZSgpLT5yZW5kZXJlcigpID09IHRoaXMg JiYgbm9kZSgpLT5oYXNUYWdOYW1lKG1hcnF1ZWVUYWcpOwogfQogCi1zdGF0aWMgdm9pZCB1cGRh dGVMaXN0TWFya2VyTnVtYmVycyhSZW5kZXJPYmplY3QqIGNoaWxkKQotewotICAgIGZvciAoUmVu ZGVyT2JqZWN0KiBzaWJsaW5nID0gY2hpbGQ7IHNpYmxpbmc7IHNpYmxpbmcgPSBzaWJsaW5nLT5u ZXh0U2libGluZygpKSB7Ci0gICAgICAgIGlmIChzaWJsaW5nLT5pc0xpc3RJdGVtKCkpCi0gICAg ICAgICAgICB0b1JlbmRlckxpc3RJdGVtKHNpYmxpbmcpLT51cGRhdGVWYWx1ZSgpOwotICAgIH0K LX0KLQogdm9pZCBSZW5kZXJPYmplY3Q6OmFkZENoaWxkKFJlbmRlck9iamVjdCogbmV3Q2hpbGQs IFJlbmRlck9iamVjdCogYmVmb3JlQ2hpbGQpCiB7CiAgICAgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0 KiBjaGlsZHJlbiA9IHZpcnR1YWxDaGlsZHJlbigpOwpAQCAtMjc0LDkgKzI2Niw3IEBAIHZvaWQg UmVuZGVyT2JqZWN0OjphZGRDaGlsZChSZW5kZXJPYmplY3QqIG5ld0NoaWxkLCBSZW5kZXJPYmpl Y3QqIGJlZm9yZUNoaWxkKQogCiAgICAgYm9vbCBuZWVkc1RhYmxlID0gZmFsc2U7CiAKLSAgICBp ZiAobmV3Q2hpbGQtPmlzTGlzdEl0ZW0oKSkKLSAgICAgICAgdXBkYXRlTGlzdE1hcmtlck51bWJl cnMoYmVmb3JlQ2hpbGQgPyBiZWZvcmVDaGlsZCA6IGNoaWxkcmVuLT5sYXN0Q2hpbGQoKSk7Ci0g ICAgZWxzZSBpZiAobmV3Q2hpbGQtPmlzVGFibGVDb2woKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+ ZGlzcGxheSgpID09IFRBQkxFX0NPTFVNTl9HUk9VUCkKKyAgICBpZiAobmV3Q2hpbGQtPmlzVGFi bGVDb2woKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+ZGlzcGxheSgpID09IFRBQkxFX0NPTFVNTl9H Uk9VUCkKICAgICAgICAgbmVlZHNUYWJsZSA9ICFpc1RhYmxlKCk7CiAgICAgZWxzZSBpZiAobmV3 Q2hpbGQtPmlzUmVuZGVyQmxvY2soKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+ZGlzcGxheSgpID09 IFRBQkxFX0NBUFRJT04pCiAgICAgICAgIG5lZWRzVGFibGUgPSAhaXNUYWJsZSgpOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcCBiL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdENoaWxkTGlzdC5jcHAKaW5kZXggOGVlODExMi4uNTcx MGQyOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0 LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwCkBA IC0zOSwxNCArMzksNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLXN0YXRpYyB2b2lkIHVw ZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVjdCogY2hpbGQpCi17Ci0gICAgZm9yIChS ZW5kZXJPYmplY3QqIHNpYmxpbmcgPSBjaGlsZDsgc2libGluZzsgc2libGluZyA9IHNpYmxpbmct Pm5leHRTaWJsaW5nKCkpIHsKLSAgICAgICAgaWYgKHNpYmxpbmctPmlzTGlzdEl0ZW0oKSkKLSAg ICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0oc2libGluZyktPnVwZGF0ZVZhbHVlKCk7Ci0gICAg fQotfQotCiB2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6ZGVzdHJveUxlZnRvdmVyQ2hpbGRy ZW4oKQogewogICAgIHdoaWxlIChmaXJzdENoaWxkKCkpIHsKQEAgLTk0LDggKzg2LDggQEAgUmVu ZGVyT2JqZWN0KiBSZW5kZXJPYmplY3RDaGlsZExpc3Q6OnJlbW92ZUNoaWxkTm9kZShSZW5kZXJP YmplY3QqIG93bmVyLCBSZW5kZXIKICAgICAgICAgCiAgICAgICAgIC8vIHJlbnVtYmVyIG9yZGVy ZWQgbGlzdHMKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc0xpc3RJdGVtKCkpCi0gICAgICAgICAg ICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhvbGRDaGlsZC0+bmV4dFNpYmxpbmcoKSk7Ci0gICAg ICAgIAorICAgICAgICAgICAgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMob2xkQ2hpbGQpOworCiAg ICAgICAgIGlmIChvbGRDaGlsZC0+aXNQb3NpdGlvbmVkKCkgJiYgb3duZXItPmNoaWxkcmVuSW5s aW5lKCkpCiAgICAgICAgICAgICBvd25lci0+ZGlydHlMaW5lc0Zyb21DaGFuZ2VkQ2hpbGQob2xk Q2hpbGQpOwogICAgIH0KQEAgLTE2MSw3ICsxNTMsMTEgQEAgdm9pZCBSZW5kZXJPYmplY3RDaGls ZExpc3Q6OmFwcGVuZENoaWxkTm9kZShSZW5kZXJPYmplY3QqIG93bmVyLCBSZW5kZXJPYmplY3Qq IG4KICAgICAgICAgICAgIGlmIChsYXllcikKICAgICAgICAgICAgICAgICBsYXllci0+c2V0SGFz VmlzaWJsZUNvbnRlbnQodHJ1ZSk7CiAgICAgICAgIH0KLSAgICAgICAgCisKKyAgICAgICAgLy8g cmVudW1iZXIgb3JkZXJlZCBsaXN0cworICAgICAgICBpZiAobmV3Q2hpbGQtPmlzTGlzdEl0ZW0o KSkKKyAgICAgICAgICAgIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKG5ld0NoaWxkKTsKKwogICAg ICAgICBpZiAoIW5ld0NoaWxkLT5pc0Zsb2F0aW5nT3JQb3NpdGlvbmVkKCkgJiYgb3duZXItPmNo aWxkcmVuSW5saW5lKCkpCiAgICAgICAgICAgICBvd25lci0+ZGlydHlMaW5lc0Zyb21DaGFuZ2Vk Q2hpbGQobmV3Q2hpbGQpOwogICAgIH0KQEAgLTIxOCw3ICsyMTQsMTAgQEAgdm9pZCBSZW5kZXJP YmplY3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZShSZW5kZXJPYmplY3QqIG93bmVyLCBSZW5k ZXJPYmplY3QqIGMKICAgICAgICAgICAgICAgICBsYXllci0+c2V0SGFzVmlzaWJsZUNvbnRlbnQo dHJ1ZSk7CiAgICAgICAgIH0KIAotICAgICAgICAKKyAgICAgICAgLy8gcmVudW1iZXIgb3JkZXJl ZCBsaXN0cworICAgICAgICBpZiAoY2hpbGQtPmlzTGlzdEl0ZW0oKSkKKyAgICAgICAgICAgIHVw ZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKGNoaWxkKTsKKwogICAgICAgICBpZiAoIWNoaWxkLT5pc0Zs b2F0aW5nKCkgJiYgb3duZXItPmNoaWxkcmVuSW5saW5lKCkpCiAgICAgICAgICAgICBvd25lci0+ ZGlydHlMaW5lc0Zyb21DaGFuZ2VkQ2hpbGQoY2hpbGQpOwogICAgIH0KZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggMTVlZmY3Yy4u ZDM3OWE5YiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0 ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMC0wNC0wMyAgSmFrdWIgV2llY3pvcmVr ICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0 ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzcwNjAKKworICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2 YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAgICAgICAgKHdl YmtpdF93ZWJfZnJhbWVfbWFya2VyX3RleHRfZm9yX2xpc3RfaXRlbSk6IEFkZCBhIHByaXZhdGUg QVBJIHRvIGdldCB0aGUgbWFya2VyIHRleHQgZm9yIGEgbGlzdCBpdGVtLgorCiAyMDEwLTA0LTAx ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVr PgogCiAgICAgICAgIFJldmlld2VkIGJ5IEhvbGdlciBGcmV5dGhlci4KZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHByaXZhdGUuaAppbmRleCBkMDAwMGIxLi5mYWFiN2JmIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5oCkBAIC0zMTUsNiArMzE1LDkgQEAgZXh0ZXJuICJDIiB7CiAgICAgV0VCS0lUX0FQSSBi b29sCiAgICAgd2Via2l0X3dlYl9mcmFtZV9wYXVzZV9zdmdfYW5pbWF0aW9uKFdlYktpdFdlYkZy YW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIqIGFuaW1hdGlvbklkLCBkb3VibGUgdGltZSwgY29uc3Qg Z2NoYXIqIGVsZW1lbnRJZCk7CiAKKyAgICBXRUJLSVRfQVBJIGdjaGFyKgorICAgIHdlYmtpdF93 ZWJfZnJhbWVfbWFya2VyX3RleHRfZm9yX2xpc3RfaXRlbShXZWJLaXRXZWJGcmFtZSogZnJhbWUs IEpTT2JqZWN0UmVmIG5vZGVPYmplY3QpOworCiAgICAgV0VCS0lUX0FQSSB1bnNpZ25lZCBpbnQK ICAgICB3ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRX ZWJGcmFtZSogZnJhbWUpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJmcmFtZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXgg OTUzOGQyNy4uNWE4M2FmZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vi ZnJhbWUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAt NDcsOCArNDcsMTAgQEAKICNpbmNsdWRlICJHdGtWZXJzaW9uaW5nLmgiCiAjaW5jbHVkZSAiSFRN TEZyYW1lT3duZXJFbGVtZW50LmgiCiAjaW5jbHVkZSAiSlNET01XaW5kb3cuaCIKKyNpbmNsdWRl ICJKU0hUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAiSlNMb2NrLmgiCiAjaW5jbHVkZSAiUHJpbnRD b250ZXh0LmgiCisjaW5jbHVkZSAiUmVuZGVyTGlzdEl0ZW0uaCIKICNpbmNsdWRlICJSZW5kZXJW aWV3LmgiCiAjaW5jbHVkZSAiUmVuZGVyVHJlZUFzVGV4dC5oIgogI2luY2x1ZGUgIkpTRE9NQmlu ZGluZy5oIgpAQCAtMTA0Myw2ICsxMDQ1LDI0IEBAIGJvb2wgd2Via2l0X3dlYl9mcmFtZV9wYXVz ZV9zdmdfYW5pbWF0aW9uKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIqIGFuCiAj ZW5kaWYKIH0KIAorZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfbWFya2VyX3RleHRfZm9yX2xpc3Rf aXRlbShXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEpTT2JqZWN0UmVmIG5vZGVPYmplY3QpCit7Cisg ICAgSlNDOjpKU09iamVjdCogb2JqZWN0ID0gdG9KUyhub2RlT2JqZWN0KTsKKyAgICBpZiAoIW9i amVjdCB8fCAhb2JqZWN0LT5pbmhlcml0cygmSlNIVE1MRWxlbWVudDo6c19pbmZvKSkKKyAgICAg ICAgcmV0dXJuIDA7CisKKyAgICBIVE1MRWxlbWVudCogZWxlbWVudCA9IHN0YXRpY19jYXN0PEpT SFRNTEVsZW1lbnQqPihvYmplY3QpLT5pbXBsKCk7CisgICAgaWYgKCFlbGVtZW50IHx8ICFlbGVt ZW50LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIFJlbmRlck9iamVjdCog cmVuZGVyZXIgPSBlbGVtZW50LT5yZW5kZXJlcigpOworICAgIGlmICghcmVuZGVyZXItPmlzTGlz dEl0ZW0oKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBTdHJpbmcgbWFya2VyVGV4dCA9IHRv UmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpLT5tYXJrZXJUZXh0KCk7CisgICAgcmV0dXJuIGdfc3Ry ZHVwKG1hcmtlclRleHQudXRmOCgpLmRhdGEoKSk7Cit9CisKIHVuc2lnbmVkIGludCB3ZWJraXRf d2ViX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFtZSogZnJh bWUpCiB7CiAgICAgRnJhbWUqIGNvcmVGcmFtZSA9IGNvcmUoZnJhbWUpOwpkaWZmIC0tZ2l0IGEv V2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVudC5oIGIvV2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVudC5o CmluZGV4IGE4N2QzODguLmYxYmRmNGUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmVs ZW1lbnQuaAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50LmgKQEAgLTE1NSw2ICsxNTUs NyBAQCBwcml2YXRlOgogICAgIHN0YXRpYyBRV2ViRWxlbWVudCBlbmNsb3NpbmdFbGVtZW50KFdl YkNvcmU6Ok5vZGUqKTsKIAogICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJhbWU7CisgICAgZnJpZW5k IGNsYXNzIFFXZWJGcmFtZVByaXZhdGU7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJFbGVtZW50Q29s bGVjdGlvbjsKICAgICBmcmllbmQgY2xhc3MgUVdlYkhpdFRlc3RSZXN1bHQ7CiAgICAgZnJpZW5k IGNsYXNzIFFXZWJIaXRUZXN0UmVzdWx0UHJpdmF0ZTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9B cGkvcXdlYmZyYW1lLmNwcCBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAppbmRleCAzYmJj ZmUyLi4zYjk2MTA4IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKKysr IGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCkBAIC00OCw2ICs0OCw3IEBACiAjaW5jbHVk ZSAiUGxhdGZvcm1XaGVlbEV2ZW50LmgiCiAjaW5jbHVkZSAiUHJpbnRDb250ZXh0LmgiCiAjaW5j bHVkZSAiUHV0UHJvcGVydHlTbG90LmgiCisjaW5jbHVkZSAiUmVuZGVyTGlzdEl0ZW0uaCIKICNp bmNsdWRlICJSZW5kZXJUcmVlQXNUZXh0LmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2lu Y2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgpAQCAtMjc1LDYgKzI3NiwyNCBAQCB2b2lkIFFXRUJL SVRfRVhQT1JUIHF0X2RydF9ldmFsdWF0ZVNjcmlwdEluSXNvbGF0ZWRXb3JsZChRV2ViRnJhbWUq IHFGcmFtZSwgaW50CiAgICAgICAgIEpTQzo6SlNWYWx1ZSByZXN1bHQgPSBmcmFtZS0+c2NyaXB0 KCktPmV4ZWN1dGVTY3JpcHRJbldvcmxkKG1haW5UaHJlYWROb3JtYWxXb3JsZCgpLCBzY3JpcHQs IHRydWUpLmpzVmFsdWUoKTsKIH0KIAorUVN0cmluZyBRV2ViRnJhbWVQcml2YXRlOjptYXJrZXJU ZXh0Rm9yTGlzdEl0ZW0oY29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKQoreworICAgIEVsZW1l bnQqIGVsZW1lbnQgPSBsaXN0SXRlbS5tX2VsZW1lbnQ7CisgICAgaWYgKCFlbGVtZW50IHx8ICFl bGVtZW50LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm4gUVN0cmluZygpOworCisgICAgUmVu ZGVyT2JqZWN0KiByZW5kZXJlciA9IGVsZW1lbnQtPnJlbmRlcmVyKCk7CisgICAgaWYgKCFyZW5k ZXJlci0+aXNMaXN0SXRlbSgpKQorICAgICAgICByZXR1cm4gUVN0cmluZygpOworCisgICAgcmV0 dXJuIHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpLT5tYXJrZXJUZXh0KCk7Cit9CisKK1FTdHJp bmcgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X21hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2Vi RWxlbWVudCYgbGlzdEl0ZW0pCit7CisgICAgcmV0dXJuIFFXZWJGcmFtZVByaXZhdGU6Om1hcmtl clRleHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9CisKIHN0YXRpYyBib29sIHdlYmZyYW1lX3Nj cm9sbE92ZXJmbG93KFdlYkNvcmU6OkZyYW1lKiBmcmFtZSwgaW50IGR4LCBpbnQgZHksIGNvbnN0 IFFQb2ludCYgcG9zKQogewogICAgIGlmICghZnJhbWUgfHwgIWZyYW1lLT5kb2N1bWVudCgpIHx8 ICFmcmFtZS0+ZXZlbnRIYW5kbGVyKCkpCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJm cmFtZV9wLmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmgKaW5kZXggZmNjMzdlNy4uMjU1 NmQzMCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWVfcC5oCisrKyBiL1dlYktp dC9xdC9BcGkvcXdlYmZyYW1lX3AuaApAQCAtODgsNiArODgsOCBAQCBwdWJsaWM6CiAgICAgdm9p ZCByZW5kZXJGcm9tVGlsZWRCYWNraW5nU3RvcmUoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0Kiwg Y29uc3QgUVJlZ2lvbiYgY2xpcCk7CiAjZW5kaWYKIAorICAgIHN0YXRpYyBRU3RyaW5nIG1hcmtl clRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pOworCiAgICAgUVdl YkZyYW1lICpxOwogICAgIFF0OjpTY3JvbGxCYXJQb2xpY3kgaG9yaXpvbnRhbFNjcm9sbEJhclBv bGljeTsKICAgICBRdDo6U2Nyb2xsQmFyUG9saWN5IHZlcnRpY2FsU2Nyb2xsQmFyUG9saWN5Owpk aWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5k ZXggN2YzYmQxNi4uYzkwZGI3NyAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxvZworKysg Yi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDQtMDMgIEpha3Vi IFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBhcmUgbm90IGFs d2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAgKiBBcGkvcXdl YmVsZW1lbnQuaDoKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmNwcDoKKyAgICAgICAgKFFXZWJG cmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0SXRlbSk6CisgICAgICAgIChxdF9kcnRfbWFy a2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgcHJpdmF0ZSBBUEkgdG8gZ2V0IHRoZSBtYXJrZXIg dGV4dCBmb3IgYSBsaXN0IGl0ZW0uCisgICAgICAgICogQXBpL3F3ZWJmcmFtZV9wLmg6CisKIDIw MTAtMDQtMDIgIExhc3psbyBHb21ib3MgIDxsYXN6bG8uMS5nb21ib3NAbm9raWEuY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuLgpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IGU1 ODg4MTIuLjgzNzMwNTkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9X ZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wNC0wMyAgSmFrdWIg V2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3 YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzcwNjAKKworICAgICAgICAqIER1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKG1hcmtlclRleHRGb3JM aXN0SXRlbUNhbGxiYWNrKTogQSBmdW5jdGlvbiB0aGF0IHJldHVybnMgdGhlIG1hcmtlciB0ZXh0 IGZvciBhIGdpdmVuIGxpc3QgaXRlbS4KKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpz dGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmg6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9s bGVyR3RrLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9y TGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhlIEdUSyBwb3J0LgorICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwOgorICAgICAgICAoTGF5b3V0 VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91dFRl c3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhl IFF0IHBvcnQuCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xs ZXJRdC5oOgorCiAyMDEwLTA0LTAzICBDaHJpcyBKZXJkb25layAgPGNqZXJkb25la0B3ZWJraXQu b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNoaW5pY2hpcm8gSGFtYWppLgpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCmluZGV4 IDI1NTRmYTQuLmE5YjNlMWMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAgLTEzMzEsNiArMTMzMSwxOCBAQCBzdGF0aWMg SlNWYWx1ZVJlZiBhcGlUZXN0R29Ub0N1cnJlbnRCYWNrRm9yd2FyZEl0ZW1DYWxsYmFjayhKU0Nv bnRleHRSZWYgY29udGV4dAogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0 KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgbWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2so SlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0 LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNW YWx1ZVJlZiogZXhjZXB0aW9uKQoreworICAgIGlmIChhcmd1bWVudENvdW50IDwgMSkKKyAgICAg ICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworCisgICAgTGF5b3V0VGVz dENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSBzdGF0aWNfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxl cio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgSlNPYmplY3RSZWYgbm9k ZU9iamVjdCA9IEpTVmFsdWVUb09iamVjdChjb250ZXh0LCBhcmd1bWVudHNbMF0sIGV4Y2VwdGlv bik7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKworICAgIHJldHVybiBKU1ZhbHVlTWFrZVN0 cmluZyhjb250ZXh0LCBjb250cm9sbGVyLT5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0obm9kZU9iamVj dCkuZ2V0KCkpOworfQorCiAvLyBTdGF0aWMgVmFsdWVzCiAKIHN0YXRpYyBKU1ZhbHVlUmVmIGdl dEdsb2JhbEZsYWdDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgdGhp c09iamVjdCwgSlNTdHJpbmdSZWYgcHJvcGVydHlOYW1lLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24p CkBAIC0xNDQ0LDYgKzE0NTYsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJv bGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAia2VlcFdlYkhpc3RvcnkiLCBrZWVw V2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJv cGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgImxheWVyVHJlZUFzVGV4dCIs IGxheWVyVHJlZUFzVGV4dENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm51bWJlck9mUGFn ZXMiLCBudW1iZXJPZlBhZ2VzQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAibWFya2VyVGV4 dEZvckxpc3RJdGVtIiwgbWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAg ICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRy aWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAg ICB7ICJudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMiLCBudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnND YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBvdmVycmlk ZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1By b3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggM2M3MGY5OC4uNjE5NWE3YSAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu aAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5o CkBAIC0yNDgsNiArMjQ4LDggQEAgcHVibGljOgogICAgIAogICAgIEpTUmV0YWluUHRyPEpTU3Ry aW5nUmVmPiBsYXllclRyZWVBc1RleHQoKSBjb25zdDsKIAorICAgIEpTUmV0YWluUHRyPEpTU3Ry aW5nUmVmPiBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNPYmplY3RSZWYgbm9kZU9iamVjdCkgY29u c3Q7CisKICAgICBzdGF0aWMgY29uc3QgdW5zaWduZWQgbWF4Vmlld1dpZHRoOwogICAgIHN0YXRp YyBjb25zdCB1bnNpZ25lZCBtYXhWaWV3SGVpZ2h0OwogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAppbmRl eCA3YzFiNmU3Li41ZTdjNzI3IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKQEAgLTU4LDYgKzU4LDcg QEAgZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfY291bnRlcl92YWx1ZV9mb3JfZWxlbWVudF9ieV9p ZChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIGMKIGludCB3ZWJraXRfd2ViX2ZyYW1lX3BhZ2VfbnVt YmVyX2Zvcl9lbGVtZW50X2J5X2lkKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIq IGlkLCBmbG9hdCBwYWdlV2lkdGgsIGZsb2F0IHBhZ2VIZWlnaHQpOwogaW50IHdlYmtpdF93ZWJf ZnJhbWVfbnVtYmVyX29mX3BhZ2VzKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgZmxvYXQgcGFnZVdp ZHRoLCBmbG9hdCBwYWdlSGVpZ2h0KTsKIHZvaWQgd2Via2l0X3dlYl9pbnNwZWN0b3JfZXhlY3V0 ZV9zY3JpcHQoV2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0b3IsIGxvbmcgY2FsbElkLCBjb25z dCBnY2hhciogc2NyaXB0KTsKK2djaGFyKiB3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zv cl9saXN0X2l0ZW0oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBKU09iamVjdFJlZiBub2RlT2JqZWN0 KTsKIH0KIAogc3RhdGljIGdjaGFyKiBjb3B5V2ViU2V0dGluZ0tleShnY2hhciogcHJlZmVyZW5j ZUtleSkKQEAgLTY0MywzICs2NDQsMTMgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6YXBp VGVzdEdvVG9DdXJyZW50QmFja0ZvcndhcmRJdGVtKCkKIHsKIAogfQorCitKU1JldGFpblB0cjxK U1N0cmluZ1JlZj4gTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbShK U09iamVjdFJlZiBub2RlT2JqZWN0KSBjb25zdAoreworICAgIGdjaGFyKiBtYXJrZXJUZXh0R0No YXIgPSB3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0obWFpbkZyYW1l LCBub2RlT2JqZWN0KTsKKyAgICBpZiAoIW1hcmtlclRleHRHQ2hhcikKKyAgICAgICAgcmV0dXJu IDA7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gbWFya2VyVGV4dChBZG9wdCwgSlNT dHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcobWFya2VyVGV4dEdDaGFyKSk7CisgICAgcmV0dXJu IG1hcmtlclRleHQ7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9x dC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCmluZGV4IGI2NDgwYzIuLjI0MzliOGYgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9s bGVyUXQuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RD b250cm9sbGVyUXQuY3BwCkBAIC01OSwxMSArNTksMTMgQEAgZXh0ZXJuIHZvaWQgcXRfZHJ0X3dl Ymluc3BlY3Rvcl9leGVjdXRlU2NyaXB0KFFXZWJQYWdlKiBwYWdlLCBsb25nIGNhbGxJZCwgY29u c3QKIGV4dGVybiB2b2lkIHF0X2RydF93ZWJpbnNwZWN0b3Jfc2hvdyhRV2ViUGFnZSAqcGFnZSk7 CiBleHRlcm4gdm9pZCBxdF9kcnRfd2ViaW5zcGVjdG9yX2Nsb3NlKFFXZWJQYWdlICpwYWdlKTsK IGV4dGVybiB2b2lkIHF0X2RydF9lbmFibGVDYXJldEJyb3dzaW5nKFFXZWJQYWdlKiBwYWdlLCBi b29sIHZhbHVlKTsKK2V4dGVybiBRU3RyaW5nIHF0X2RydF9tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0o Y29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKTsKIAogTGF5b3V0VGVzdENvbnRyb2xsZXI6Okxh eW91dFRlc3RDb250cm9sbGVyKFdlYkNvcmU6OkR1bXBSZW5kZXJUcmVlKiBkcnQpCiAgICAgOiBR T2JqZWN0KCkKICAgICAsIG1fZHJ0KGRydCkKIHsKKyAgICBxUmVnaXN0ZXJNZXRhVHlwZTxRV2Vi RWxlbWVudD4oIlFXZWJFbGVtZW50Iik7CiAgICAgcmVzZXQoKTsKIH0KIApAQCAtNTQxLDUgKzU0 MywxMCBAQCBib29sIExheW91dFRlc3RDb250cm9sbGVyOjpjYWxsU2hvdWxkQ2xvc2VPbldlYlZp ZXcoKQogICAgIHJldHVybiBmYWxzZTsKIH0KIAorUVN0cmluZyBMYXlvdXRUZXN0Q29udHJvbGxl cjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sK KyAgICByZXR1cm4gcXRfZHJ0X21hcmtlclRleHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9CisK IGNvbnN0IHVuc2lnbmVkIExheW91dFRlc3RDb250cm9sbGVyOjptYXhWaWV3V2lkdGggPSA4MDA7 CiBjb25zdCB1bnNpZ25lZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWF4Vmlld0hlaWdodCA9IDYw MDsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RD b250cm9sbGVyUXQuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RD b250cm9sbGVyUXQuaAppbmRleCAzNmI1ZjcwLi44NWU1ZmU1IDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmgKKysrIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5oCkBAIC00 MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8UVZhcmlhbnQ+CiAKICNpbmNsdWRlIDxxd2ViZGF0YWJh c2UuaD4KKyNpbmNsdWRlIDxxd2ViZWxlbWVudC5oPgogI2luY2x1ZGUgPHF3ZWJmcmFtZS5oPgog I2luY2x1ZGUgPHF3ZWJoaXN0b3J5Lmg+CiAjaW5jbHVkZSA8cXdlYnBhZ2UuaD4KQEAgLTE2NSw2 ICsxNjYsOCBAQCBwdWJsaWMgc2xvdHM6CiAgICAgaW50IG51bWJlck9mUGFnZXMoZmxvYXQgd2lk dGggPSBtYXhWaWV3V2lkdGgsIGZsb2F0IGhlaWdodCA9IG1heFZpZXdIZWlnaHQpOwogICAgIGJv b2wgY2FsbFNob3VsZENsb3NlT25XZWJWaWV3KCk7CiAKKyAgICBRU3RyaW5nIG1hcmtlclRleHRG b3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pOworCiBwcml2YXRlIHNsb3Rz OgogICAgIHZvaWQgcHJvY2Vzc1dvcmsoKTsKIAo= 52512 2010-04-04 06:42:23 -0700 2010-04-05 05:28:54 -0700 patch list-markers-dom-changes.patch text/plain 40194 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAzNWU2ODMzLi5iOTBhMDU1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDQt MDQgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKwogMjAxMC0wNC0wMyAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3 ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvZHVtcC1s aXN0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFiNGEzYjgKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcwpAQCAtMCww ICsxLDMxIEBACitmdW5jdGlvbiBpbmRlbnQoZGVwdGgpCit7CisgICAgdmFyIHJldCA9IG5ldyBT dHJpbmcoKTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGRlcHRoOyArK2kpCisgICAgICAgIHJl dCArPSAiLT4gIjsKKyAgICByZXR1cm4gcmV0ICsgIiAiOworfQorCitmdW5jdGlvbiBkdW1wTGlz dEhlbHBlcihlbGVtZW50LCBkZXB0aCkKK3sKKyAgICB2YXIgcmV0ID0gbmV3IFN0cmluZygpOwor CisgICAgdmFyIGNoaWxkID0gZWxlbWVudC5maXJzdENoaWxkOworICAgIHdoaWxlIChjaGlsZCkg eworICAgICAgICBpZiAoY2hpbGQubm9kZVR5cGUgPT0gTm9kZS5FTEVNRU5UX05PREUpIHsKKyAg ICAgICAgICAgIHZhciBtYXJrZXIgPSBsYXlvdXRUZXN0Q29udHJvbGxlci5tYXJrZXJUZXh0Rm9y TGlzdEl0ZW0oY2hpbGQpOworICAgICAgICAgICAgaWYgKG1hcmtlcikKKyAgICAgICAgICAgICAg ICByZXQgKz0gaW5kZW50KGRlcHRoKSArICcgJyArIG1hcmtlciArICcgJyArIGNoaWxkLmlubmVy VGV4dC50cmltKCkgKyAnPGJyIC8+JzsKKyAgICAgICAgICAgIHJldCArPSBkdW1wTGlzdEhlbHBl cihjaGlsZCwgZGVwdGggKyAxKTsKKyAgICAgICAgfQorCisgICAgICAgIGNoaWxkID0gY2hpbGQu bmV4dFNpYmxpbmc7CisgICAgfQorCisgICAgcmV0dXJuIHJldDsKK30KKworZnVuY3Rpb24gZHVt cExpc3QobGlzdCkKK3sKKyAgICByZXR1cm4gZHVtcExpc3RIZWxwZXIobGlzdCwgMCk7Cit9CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWlj LWluc2VydC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1p dGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uZjM5NjQ5NgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dApAQCAtMCww ICsxLDE0IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtlcnMgYXJlIHVwZGF0ZWQg d2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVs ZW1lbnQuCisKKzEgT25lCisyIFR3bworLT4gMyBUaHJlZQorNCBGb3VyCis1IEZpdmUKKzYgU2l4 CistPiA3IFNldmVuCistPiA4IEVpZ2h0CistPiA5IE5pbmUKKzEwIFRlbgorMTEgRWxldmVuCisK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFt aWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1k eW5hbWljLWluc2VydC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmEy OTgwMmIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3Rl ZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAgKzEsNTMgQEAKKzxodG1sPgorICAg IDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0LmpzIiAvPgorICAgICAgICA8 c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAg ICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCisgICAgICAgICAg ICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpOworICAgICAg ICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJlbGF5b3V0LgorCisgICAgICAg ICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibmVzdGVkIik7CisKKyAg ICAgICAgICAgICAgICB2YXIgbGkxID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgibGkiKTsKKyAg ICAgICAgICAgICAgICBsaTEuaW5uZXJUZXh0ID0gIkVpZ2h0IjsKKworICAgICAgICAgICAgICAg IHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAg IGxpMi5pbm5lclRleHQgPSAiU2V2ZW4iOworCisgICAgICAgICAgICAgICAgdmFyIGl0ZW0zID0g ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgICAgICAgICAgICAgaXRlbTMuaW5u ZXJUZXh0ID0gIk5pbmUiOworICAgICAgICAgICAgICAgIGl0ZW0zLnN0eWxlLmRpc3BsYXkgPSAi bGlzdC1pdGVtIjsKKworICAgICAgICAgICAgICAgIHAuYXBwZW5kQ2hpbGQobGkxKTsKKyAgICAg ICAgICAgICAgICBwLmluc2VydEJlZm9yZShsaTIsIGxpMSk7CisgICAgICAgICAgICAgICAgcC5h cHBlbmRDaGlsZChpdGVtMyk7CisKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNldFRvcDsgLy8g Rm9yY2UgYSByZWxheW91dC4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAg ICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUg dGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo Imxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAgICAgICAgICAgfQorICAgICAgICA8 L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAg ICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtlcnMgYXJlIHVwZGF0ZWQgd2hlbiBh ZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQu PC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+Cisg ICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDxkaXY+PGxpPlRocmVlPC9saT48 L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlPC9s aT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgPHAgaWQ9Im5lc3RlZCI+ PC9wPgorICAgICAgICAgICAgPGxpPlRlbjwvbGk+CisgICAgICAgICAgICA8bGk+RWxldmVuPC9s aT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAg ICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHlu YW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmJlNDUzMDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMCBA QAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRhdGVkIHdoZW4gcmVt b3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGlsZHJlbiBvZiB0aGUg bGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgorNSBGaXZlCis2 IFNpeAorNyBTZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9v bC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi5hYTNiNjk4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApAQCAtMCwwICsxLDUy IEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5q cyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAg ICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo Imxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNldFRvcDsgLy8gRm9yY2UgYSByZWxh eW91dC4KKworICAgICAgICAgICAgICAgIHZhciBiID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRh Z05hbWUoImIiKVswXTsKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGIpOworCisg ICAgICAgICAgICAgICAgdmFyIGRpdiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJuZXN0ZWQi KTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBkaXYuY2hpbGRyZW4ubGVuZ3RoOworICAg ICAgICAgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgaXRlbXM7ICsraSkKKyAgICAgICAgICAg ICAgICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5maXJzdEVsZW1lbnRDaGlsZCk7CisKKyAgICAg ICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJpdGVt IikpOworCisgICAgICAgICAgICAgICAgbGlzdC5vZmZzZXRUb3A7IC8vIEZvcmNlIGEgcmVsYXlv dXQuCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5p bm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNo b3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2Rl LgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUu ZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAg PC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0 cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRhdGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3Rp bmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50 LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAgICAgICAgICAgIDxsaT5PbmU8L2xpPgor ICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAgICA8Yj48bGk+Rm9vPC9saT48L2I+ CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgor ICAgICAgICAgICAgPGxpPkZpdmU8L2xpPgorICAgICAgICAgICAgPGRpdiBpZD0ibmVzdGVkIj4K KyAgICAgICAgICAgICAgICA8bGk+Rm9vPC9saT4KKyAgICAgICAgICAgICAgICA8bGk+QmFyPC9s aT4KKyAgICAgICAgICAgICAgICA8bGk+QmF6PC9saT4KKyAgICAgICAgICAgIDwvZGl2PgorICAg ICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8ZGl2IGlkPSJpdGVtIiBzdHlsZT0i ZGlzcGxheTogbGlzdC1pdGVtIj5Gb288L2Rpdj4KKyAgICAgICAgICAgIDxsaT5TZXZlbjwvbGk+ CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisgICAg PC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWV4cGVjdGVkLnR4dCBiL0xh eW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWV4cGVjdGVkLnR4dApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMzRiMzY2Ci0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0CkBAIC0w LDAgKzEsMTUgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJr ZWQgd2hlbiBzb21lIG9mIHRoZSBpdGVtcyBhcmUgaW5kaXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxp c3QgZWxlbWVudC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKy0+IDUgRml2ZQor LT4gNiBTaXgKKzEwIFRlbgorMTEgRWxldmVuCistPiAxMiBUd2VsdmUKKy0+IDEzIFRoaXJ0ZWVu CisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44MTM5 ZjllCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMuaHRtbApAQCAtMCwwICsxLDQzIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAg PHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAg ICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9m ZnNldFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisg ICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNl bGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAgICAgICAgICAg fQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0 KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkg bWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRlbXMgYXJlIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRo ZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAg PGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDxsaT5U aHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+Rm91cgorICAgICAgICAgICAgICAgIDxiPgorICAg ICAgICAgICAgICAgICAgICA8bGk+Rml2ZTwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5T aXg8L2xpPgorICAgICAgICAgICAgICAgIDwvYj4KKyAgICAgICAgICAgIDwvbGk+CisgICAgICAg ICAgICA8bGkgdmFsdWU9IjEwIj5UZW48L2xpPgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+ CisgICAgICAgICAgICA8ZGl2PgorICAgICAgICAgICAgICAgIDxsaT5Ud2VsdmU8L2xpPgorICAg ICAgICAgICAgICAgIDxsaT5UaGlydGVlbjwvbGk+CisgICAgICAgICAgICA8L2Rpdj4KKyAgICAg ICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+CisgICAgICAgICAgICA8bGk+RmlmdGVlbjwvbGk+Cisg ICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9i b2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWlu c2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZm MDk4ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTMgQEAKK1RoaXMg dGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5l dyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LgorCisxIE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91 cgorNSBGaXZlIE9uZSBUd2VudHkgZml2ZSBUd2VudHkgc2l4CistPiAtPiAxIE9uZQorLT4gLT4g MjUgVHdlbnR5IGZpdmUKKy0+IC0+IDI2IFR3ZW50eSBzaXgKKzYgU2l4Cis3IFNldmVuCisKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1p bnNlcnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1p Yy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMTllMDhh Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlz dC1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAgKzEsNDkgQEAKKzxodG1sPgorICAgIDxoZWFk PgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0 PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisgICAgICAgICAgICB7CisgICAgICAgICAg ICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCisgICAgICAgICAgICAgICAg dmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpOworICAgICAgICAgICAg ICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJlbGF5b3V0LgorCisgICAgICAgICAgICAg ICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3Qi KTsKKworICAgICAgICAgICAgICAgIHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJs aSIpOworICAgICAgICAgICAgICAgIGxpMi5pbm5lclRleHQgPSAiVHdlbnR5IGZpdmUiOworICAg ICAgICAgICAgICAgIGxpMi52YWx1ZSA9ICIyNSI7CisgICAgICAgICAgICAgICAgdmFyIGxpMSA9 IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxpIik7CisgICAgICAgICAgICAgICAgbGkxLmlubmVy VGV4dCA9ICJPbmUiOworICAgICAgICAgICAgICAgIHZhciBsaTMgPSBkb2N1bWVudC5jcmVhdGVF bGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMy5pbm5lclRleHQgPSAiVHdlbnR5IHNp eCI7CisKKyAgICAgICAgICAgICAgICBuZXN0ZWRMaXN0LmFwcGVuZENoaWxkKGxpMik7CisgICAg ICAgICAgICAgICAgbmVzdGVkTGlzdC5pbnNlcnRCZWZvcmUobGkxLCBsaTIpOworICAgICAgICAg ICAgICAgIG5lc3RlZExpc3QuYXBwZW5kQ2hpbGQobGkzKTsKKworICAgICAgICAgICAgICAgIGxp c3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJlbGF5b3V0LgorICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xlIikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7 CisKKyAgICAgICAgICAgICAgICAvLyBEb24ndCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBp cyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9ubHkgbW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgibGlzdCIpLnN0eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAg ICAgICB9CisgICAgICAgIDwvc2NyaXB0PgorICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9 InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBk byBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LjwvcD4K KyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAgICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAg ICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAg ICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAgICAgPGxpPkZpdmUgPG9sIGlkPSJuZXN0ZWQtbGlz dCI+PC9vbD48L2xpPgorICAgICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8bGk+ U2V2ZW48L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwv ZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxp c3QtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjY2OTExYjMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xp c3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsx LDEwIEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3 aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0ZWQgbGlzdC4KKworMSBPbmUK KzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUgRml2ZQorMSBPbmUKKzIgVHdvCisKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1v dmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jODI0ZmFhCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5h bWljLXJlbW92ZS5odG1sCkBAIC0wLDAgKzEsNDYgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAg ICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAg ICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAg aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxp c3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxp c3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFy IG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKyAg ICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBuZXN0ZWRMaXN0LmNoaWxkcmVuLmxlbmd0aDsKKyAg ICAgICAgICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IGl0ZW1zOyArK2kpCisgICAgICAgICAg ICAgICAgICAgIG5lc3RlZExpc3QucmVtb3ZlQ2hpbGQobmVzdGVkTGlzdC5maXJzdEVsZW1lbnRD aGlsZCk7CisKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNldFRvcDsgLy8gRm9yY2UgYSByZWxh eW91dC4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIp LmlubmVySFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qg c2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1v ZGUuCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHls ZS5kaXNwbGF5ID0gIm5vbmUiOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAg ICA8L2hlYWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRl c3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4 aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0ZWQgbGlzdC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlz dCI+CisgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgor ICAgICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAg ICAgICAgICAgIDxsaT5GaXZlCisgICAgICAgICAgICAgICAgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+ CisgICAgICAgICAgICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgICAgICAgICA8 bGk+VHdvPC9saT4KKyAgICAgICAgICAgICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAg ICAgICAgICA8L29sPgorICAgICAgICAgICAgPC9saT4KKyAgICAgICAgICAgIDxsaSB2YWx1ZT0i MSI+T25lPC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICA8L29sPgorCisg ICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBO byBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xp c3RzL29sLW5lc3RlZC1saXN0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLmRmZjUzZWIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3Rz L29sLW5lc3RlZC1saXN0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3Rz IHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gdGhlIGxpc3QgY29udGFp bnMgbmVzdGVkIGxpc3RzLgorCisxMCBUZW4KKzExIEVsZXZlbgorMTIgVHdlbHZlCisxMyBUaGly dGVlbiBPbmUgVHdvCistPiAtPiDil6YgT25lCistPiAtPiDil6YgVHdvCisxNCBGb3VydGVlbgor MTUgRmlmdGVlbgorLT4gMSBPbmUKKy0+IDIgVHdvCisxNiBTaXh0ZWVuCisxNyBTZXZlbnRlZW4K KwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1s IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhjNDVkNmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwKQEAgLTAsMCArMSw0MyBAQAor PGh0bWw+CisgICAgPGhlYWQ+CisgICAgICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+ CisgICAgICAgIDxzY3JpcHQ+CisgICAgICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAg ICAgIHsKKyAgICAgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQor ICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisK KyAgICAgICAgICAgICAgICB2YXIgbGlzdCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0 Iik7CisgICAgICAgICAgICAgICAgbGlzdC5vZmZzZXRUb3A7IC8vIEZvcmNlIGEgcmVsYXlvdXQu CisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5l ckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cg dGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgor ICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlz cGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9o ZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0 aGF0IGxpc3QgaXRlbXMgYXJlIHByb3Blcmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0IGNvbnRhaW5z IG5lc3RlZCBsaXN0cy48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCIgc3RhcnQ9IjEwIj4KKyAg ICAgICAgICAgIDxsaT5UZW48L2xpPgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAg ICAgICAgICA8bGk+VHdlbHZlPC9saT4KKyAgICAgICAgICAgIDxsaT5UaGlydGVlbgorICAgICAg ICAgICAgICAgIDx1bD4KKyAgICAgICAgICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAg ICAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgICAgIDwvdWw+CisgICAgICAg ICAgICA8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXJ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxs aT5GaWZ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxvbD4KKyAgICAgICAgICAgICAgICA8bGk+T25l PC9saT4KKyAgICAgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDwvb2w+Cisg ICAgICAgICAgICA8bGk+U2l4dGVlbjwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW50ZWVuPC9s aT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAg ICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9tYWMvU2tpcHBlZAppbmRleCBhNjFhZDIxLi45MDc4OGExIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv U2tpcHBlZApAQCAtMTU2LDMgKzE1NiwxMCBAQCBmYXN0L3JlcGxhY2VkL2JvcmRlci1yYWRpdXMt Y2xpcC5odG1sCiAjIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjY0 NgogZmFzdC93b3JrZXJzL3dvcmtlci10ZXJtaW5hdGUuaHRtbAogCisjIE1pc3NpbmcgYW4gaW1w bGVtZW50YXRpb24gb2YgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRl bSgpCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCitmYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sCitmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtaW5z ZXJ0Lmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbAor ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS93aW4vU2tpcHBlZCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCmlu ZGV4IGU3YzRjZWYuLmY2OWE3OGEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dp bi9Ta2lwcGVkCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCkBAIC04MjIs MyArODIyLDExIEBAIGZhc3QvbWVkaWEvbWVkaWEtZmVhdHVyZS13Z3Qtdmlldy1tb2RlLmh0bWwK IAogIyBOZWVkIGV4cGVjdGF0aW9ucy4gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0zNjQ2MQogZmFzdC9yZXBhaW50L292ZXJmbG93LXNjcm9sbC1ib2R5LWFwcGVh ci5odG1sCisKKyMgTWlzc2luZyBhbiBpbXBsZW1lbnRhdGlvbiBvZiBMYXlvdXRUZXN0Q29udHJv bGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKCkKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1z LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMt cmVtb3ZlLmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLmh0bWwKK2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQt bGlzdC1keW5hbWljLXJlbW92ZS5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWZmNjBkYi4uOTUwMDkyZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAxMC0wNC0wNCAgSmFrdWIgV2llY3pv cmVrICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVw ZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzcwNjAKKworICAgICAgICBJbiBwYXJ0aWN1bGFyLCB0 aGV5IHdvdWxkIG5vdCBiZSB1cGRhdGVkIHdoZW4gYWRkaW5nL3JlbW92aW5nIGFuIGl0ZW0KKyAg ICAgICAgdGhhdCBpcyBub3QgYSBkaXJlY3QgY2hpbGQgb2YgdGhlIGxpc3QgZWxlbWVudC4KKwor ICAgICAgICBUZXN0czogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQu aHRtbAorICAgICAgICAgICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1y ZW1vdmUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRt bAorICAgICAgICAgICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2Vy dC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRt bAorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OmVuY2xvc2luZ0xpc3QpOiBTaW1wbGlmeSBhbmQgZml4IGl0IHRvIHdvcmsgcHJvcGVy bHkgd2l0aCBhbm9ueW1vdXMgcmVuZGVyIG9iamVjdHMuCisgICAgICAgIChXZWJDb3JlOjp1cGRh dGVMaXN0TWFya2VyTnVtYmVycyk6IENoYW5nZSBpdCB0byB0cmF2ZXJzZSB0aGUgd2hvbGUgc3Vi dHJlZSBvZiBhIGxpc3QsIG5vdCBvbmx5IHNpYmxpbmdzIG9mIGFuIGl0ZW0uCisgICAgICAgICog cmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9i amVjdC5jcHA6IE1vdmUgdGhlIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzIGZ1bmN0aW9uIHRvIFJl bmRlckxpc3RJdGVtLmNwcC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6YWRkQ2hp bGQpOiBNb3ZlIHRoZSBjb2RlIHVwZGF0aW5nIGxpc3QgbWFya2VycyB0byBSZW5kZXJPYmplY3RD aGlsZExpc3QgZm9yIGNvbnNpc3RlbmN5LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmpl Y3RDaGlsZExpc3QuY3BwOiBNb3ZlIHRoZSB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlv biB0byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3RD aGlsZExpc3Q6OnJlbW92ZUNoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5nIHJl bW92ZWQsIG5vdCB0aGUgbmV4dCBzaWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2Jq ZWN0Q2hpbGRMaXN0OjphcHBlbmRDaGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWlu ZyBhZGRlZCwgbm90IHRoZSBuZXh0IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJP YmplY3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJl aW5nIGFkZGVkLCBub3QgdGhlIG5leHQgc2libGluZy4KKwogMjAxMC0wNC0wMyAgeWFlbCBhaGFy b24gIDx5YWVsLmFoYXJvbkBub2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4g QWRsZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAg Yi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKaW5kZXggNTRhN2RkMi4uN2M4 NTQwOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCisr KyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmNwcApAQCAtOTQsMTUgKzk0LDEz IEBAIHN0YXRpYyBOb2RlKiBlbmNsb3NpbmdMaXN0KE5vZGUqIG5vZGUpCiAKIHN0YXRpYyBOb2Rl KiBlbmNsb3NpbmdMaXN0KGNvbnN0IFJlbmRlck9iamVjdCogcmVuZGVyZXIpCiB7Ci0gICAgTm9k ZSogbm9kZSA9IHJlbmRlcmVyLT5ub2RlKCk7Ci0gICAgaWYgKG5vZGUpCi0gICAgICAgIHJldHVy biBlbmNsb3NpbmdMaXN0KG5vZGUpOwotCi0gICAgcmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50 KCk7CiAgICAgd2hpbGUgKHJlbmRlcmVyICYmICFyZW5kZXJlci0+bm9kZSgpKQogICAgICAgICBy ZW5kZXJlciA9IHJlbmRlcmVyLT5wYXJlbnQoKTsKIAotICAgIG5vZGUgPSByZW5kZXJlci0+bm9k ZSgpOworICAgIGlmICghcmVuZGVyZXIpCisgICAgICAgIHJldHVybiAwOworCisgICAgTm9kZSog bm9kZSA9IHJlbmRlcmVyLT5ub2RlKCk7CiAgICAgaWYgKGlzTGlzdChub2RlKSkKICAgICAgICAg cmV0dXJuIG5vZGU7CiAKQEAgLTM2NCw0ICszNjIsMjYgQEAgdm9pZCBSZW5kZXJMaXN0SXRlbTo6 Y2xlYXJFeHBsaWNpdFZhbHVlKCkKICAgICBleHBsaWNpdFZhbHVlQ2hhbmdlZCgpOwogfQogCit2 b2lkIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVjdCogbGlzdEl0ZW0pCit7Cisg ICAgQVNTRVJUKGxpc3RJdGVtLT5pc0xpc3RJdGVtKCkpOworCisgICAgTm9kZSogbGlzdE5vZGUg PSBlbmNsb3NpbmdMaXN0KGxpc3RJdGVtKTsKKyAgICBSZW5kZXJPYmplY3QqIGxpc3QgPSBsaXN0 Tm9kZSA/IGxpc3ROb2RlLT5yZW5kZXJlcigpIDogMDsKKworICAgIFJlbmRlck9iamVjdCogY2hp bGQgPSBsaXN0SXRlbS0+bmV4dEluUHJlT3JkZXIobGlzdCk7CisgICAgd2hpbGUgKGNoaWxkKSB7 CisgICAgICAgIGlmIChjaGlsZC0+bm9kZSgpICYmIGlzTGlzdChjaGlsZC0+bm9kZSgpKSkgewor ICAgICAgICAgICAgLy8gV2UndmUgZm91bmQgYSBuZXN0ZWQsIGluZGVwZW5kZW50IGxpc3QgLSBu b3RoaW5nIHRvIGRvIGhlcmUuCisgICAgICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0SW5QcmVP cmRlckFmdGVyQ2hpbGRyZW4obGlzdCk7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAg fQorCisgICAgICAgIGlmIChjaGlsZC0+aXNMaXN0SXRlbSgpKQorICAgICAgICAgICAgdG9SZW5k ZXJMaXN0SXRlbShjaGlsZCktPnVwZGF0ZVZhbHVlKCk7CisKKyAgICAgICAgY2hpbGQgPSBjaGls ZC0+bmV4dEluUHJlT3JkZXIobGlzdCk7CisgICAgfQorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oIGIvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uaAppbmRleCBjNGM0MWRjLi5jYmFhNjc4IDEw MDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oCisrKyBiL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmgKQEAgLTg2LDYgKzg2LDggQEAgaW5saW5lIFJl bmRlckxpc3RJdGVtKiB0b1JlbmRlckxpc3RJdGVtKFJlbmRlck9iamVjdCogb2JqZWN0KQogLy8g VGhpcyB3aWxsIGNhdGNoIGFueW9uZSBkb2luZyBhbiB1bm5lY2Vzc2FyeSBjYXN0Lgogdm9pZCB0 b1JlbmRlckxpc3RJdGVtKGNvbnN0IFJlbmRlckxpc3RJdGVtKik7CiAKK3ZvaWQgdXBkYXRlTGlz dE1hcmtlck51bWJlcnMoUmVuZGVyT2JqZWN0KiBsaXN0SXRlbSk7CisKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKIAogI2VuZGlmIC8vIFJlbmRlckxpc3RJdGVtX2gKZGlmZiAtLWdpdCBhL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJP YmplY3QuY3BwCmluZGV4IDcwMDBiNzAuLjFmNWY0NDAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmNwcApAQCAtMjU3LDE0ICsyNTcsNiBAQCBib29sIFJlbmRlck9iamVjdDo6aXNIVE1MTWFy cXVlZSgpIGNvbnN0CiAgICAgcmV0dXJuIG5vZGUoKSAmJiBub2RlKCktPnJlbmRlcmVyKCkgPT0g dGhpcyAmJiBub2RlKCktPmhhc1RhZ05hbWUobWFycXVlZVRhZyk7CiB9CiAKLXN0YXRpYyB2b2lk IHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVjdCogY2hpbGQpCi17Ci0gICAgZm9y IChSZW5kZXJPYmplY3QqIHNpYmxpbmcgPSBjaGlsZDsgc2libGluZzsgc2libGluZyA9IHNpYmxp bmctPm5leHRTaWJsaW5nKCkpIHsKLSAgICAgICAgaWYgKHNpYmxpbmctPmlzTGlzdEl0ZW0oKSkK LSAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0oc2libGluZyktPnVwZGF0ZVZhbHVlKCk7Ci0g ICAgfQotfQotCiB2b2lkIFJlbmRlck9iamVjdDo6YWRkQ2hpbGQoUmVuZGVyT2JqZWN0KiBuZXdD aGlsZCwgUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCkKIHsKICAgICBSZW5kZXJPYmplY3RDaGls ZExpc3QqIGNoaWxkcmVuID0gdmlydHVhbENoaWxkcmVuKCk7CkBAIC0yNzQsOSArMjY2LDcgQEAg dm9pZCBSZW5kZXJPYmplY3Q6OmFkZENoaWxkKFJlbmRlck9iamVjdCogbmV3Q2hpbGQsIFJlbmRl ck9iamVjdCogYmVmb3JlQ2hpbGQpCiAKICAgICBib29sIG5lZWRzVGFibGUgPSBmYWxzZTsKIAot ICAgIGlmIChuZXdDaGlsZC0+aXNMaXN0SXRlbSgpKQotICAgICAgICB1cGRhdGVMaXN0TWFya2Vy TnVtYmVycyhiZWZvcmVDaGlsZCA/IGJlZm9yZUNoaWxkIDogY2hpbGRyZW4tPmxhc3RDaGlsZCgp KTsKLSAgICBlbHNlIGlmIChuZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0NoaWxkLT5zdHls ZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ09MVU1OX0dST1VQKQorICAgIGlmIChuZXdDaGlsZC0+ aXNUYWJsZUNvbCgpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ09M VU1OX0dST1VQKQogICAgICAgICBuZWVkc1RhYmxlID0gIWlzVGFibGUoKTsKICAgICBlbHNlIGlm IChuZXdDaGlsZC0+aXNSZW5kZXJCbG9jaygpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5 KCkgPT0gVEFCTEVfQ0FQVElPTikKICAgICAgICAgbmVlZHNUYWJsZSA9ICFpc1RhYmxlKCk7CmRp ZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwIGIv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAppbmRleCA4ZWU4MTEy Li41NzEwZDI4IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGls ZExpc3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdENoaWxkTGlzdC5j cHAKQEAgLTM5LDE0ICszOSw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotc3RhdGljIHZv aWQgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoUmVuZGVyT2JqZWN0KiBjaGlsZCkKLXsKLSAgICBm b3IgKFJlbmRlck9iamVjdCogc2libGluZyA9IGNoaWxkOyBzaWJsaW5nOyBzaWJsaW5nID0gc2li bGluZy0+bmV4dFNpYmxpbmcoKSkgewotICAgICAgICBpZiAoc2libGluZy0+aXNMaXN0SXRlbSgp KQotICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShzaWJsaW5nKS0+dXBkYXRlVmFsdWUoKTsK LSAgICB9Ci19Ci0KIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpkZXN0cm95TGVmdG92ZXJD aGlsZHJlbigpCiB7CiAgICAgd2hpbGUgKGZpcnN0Q2hpbGQoKSkgewpAQCAtOTQsOCArODYsOCBA QCBSZW5kZXJPYmplY3QqIFJlbmRlck9iamVjdENoaWxkTGlzdDo6cmVtb3ZlQ2hpbGROb2RlKFJl bmRlck9iamVjdCogb3duZXIsIFJlbmRlcgogICAgICAgICAKICAgICAgICAgLy8gcmVudW1iZXIg b3JkZXJlZCBsaXN0cwogICAgICAgICBpZiAob2xkQ2hpbGQtPmlzTGlzdEl0ZW0oKSkKLSAgICAg ICAgICAgIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKG9sZENoaWxkLT5uZXh0U2libGluZygpKTsK LSAgICAgICAgCisgICAgICAgICAgICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhvbGRDaGlsZCk7 CisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc1Bvc2l0aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRy ZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGls ZChvbGRDaGlsZCk7CiAgICAgfQpAQCAtMTYxLDcgKzE1MywxMSBAQCB2b2lkIFJlbmRlck9iamVj dENoaWxkTGlzdDo6YXBwZW5kQ2hpbGROb2RlKFJlbmRlck9iamVjdCogb3duZXIsIFJlbmRlck9i amVjdCogbgogICAgICAgICAgICAgaWYgKGxheWVyKQogICAgICAgICAgICAgICAgIGxheWVyLT5z ZXRIYXNWaXNpYmxlQ29udGVudCh0cnVlKTsKICAgICAgICAgfQotICAgICAgICAKKworICAgICAg ICAvLyByZW51bWJlciBvcmRlcmVkIGxpc3RzCisgICAgICAgIGlmIChuZXdDaGlsZC0+aXNMaXN0 SXRlbSgpKQorICAgICAgICAgICAgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMobmV3Q2hpbGQpOwor CiAgICAgICAgIGlmICghbmV3Q2hpbGQtPmlzRmxvYXRpbmdPclBvc2l0aW9uZWQoKSAmJiBvd25l ci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxpbmVzRnJvbUNo YW5nZWRDaGlsZChuZXdDaGlsZCk7CiAgICAgfQpAQCAtMjE4LDcgKzIxNCwxMCBAQCB2b2lkIFJl bmRlck9iamVjdENoaWxkTGlzdDo6aW5zZXJ0Q2hpbGROb2RlKFJlbmRlck9iamVjdCogb3duZXIs IFJlbmRlck9iamVjdCogYwogICAgICAgICAgICAgICAgIGxheWVyLT5zZXRIYXNWaXNpYmxlQ29u dGVudCh0cnVlKTsKICAgICAgICAgfQogCi0gICAgICAgIAorICAgICAgICAvLyByZW51bWJlciBv cmRlcmVkIGxpc3RzCisgICAgICAgIGlmIChjaGlsZC0+aXNMaXN0SXRlbSgpKQorICAgICAgICAg ICAgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoY2hpbGQpOworCiAgICAgICAgIGlmICghY2hpbGQt PmlzRmxvYXRpbmcoKSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93 bmVyLT5kaXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGlsZChjaGlsZCk7CiAgICAgfQpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCAxNWVm ZjdjLi5lNDY2YmM4IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJL aXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEwLTA0LTA0ICBKYWt1YiBXaWVj em9yZWsgIDxqd2llY3pvcmVrQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgTGlzdCBpdGVtIG1hcmtlcnMgYXJlIG5vdCBhbHdheXMg dXBkYXRlZCBhZnRlciBjaGFuZ2VzIGluIHRoZSBET00uCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzA2MAorCisgICAgICAgICogd2Via2l0L3dlYmtp dHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwOgorICAgICAg ICAod2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKTogQWRkIGEgcHJp dmF0ZSBBUEkgdG8gZ2V0IHRoZSBtYXJrZXIgdGV4dCBmb3IgYSBsaXN0IGl0ZW0uCisKIDIwMTAt MDQtMDEgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEu Y28udWs+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2VyIEZyZXl0aGVyLgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5oCmluZGV4IGQwMDAwYjEuLmZhYWI3YmYgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRwcml2YXRlLmgKQEAgLTMxNSw2ICszMTUsOSBAQCBleHRlcm4gIkMiIHsKICAgICBXRUJLSVRf QVBJIGJvb2wKICAgICB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3N2Z19hbmltYXRpb24oV2ViS2l0 V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogYW5pbWF0aW9uSWQsIGRvdWJsZSB0aW1lLCBj b25zdCBnY2hhciogZWxlbWVudElkKTsKIAorICAgIFdFQktJVF9BUEkgZ2NoYXIqCisgICAgd2Vi a2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKFdlYktpdFdlYkZyYW1lKiBm cmFtZSwgSlNPYmplY3RSZWYgbm9kZU9iamVjdCk7CisKICAgICBXRUJLSVRfQVBJIHVuc2lnbmVk IGludAogICAgIHdlYmtpdF93ZWJfZnJhbWVfbnVtYmVyX29mX2FjdGl2ZV9hbmltYXRpb25zKFdl YktpdFdlYkZyYW1lKiBmcmFtZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYmZyYW1lLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApp bmRleCA5NTM4ZDI3Li41YTgzYWZlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXR3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3Bw CkBAIC00Nyw4ICs0NywxMCBAQAogI2luY2x1ZGUgIkd0a1ZlcnNpb25pbmcuaCIKICNpbmNsdWRl ICJIVE1MRnJhbWVPd25lckVsZW1lbnQuaCIKICNpbmNsdWRlICJKU0RPTVdpbmRvdy5oIgorI2lu Y2x1ZGUgIkpTSFRNTEVsZW1lbnQuaCIKICNpbmNsdWRlICJKU0xvY2suaCIKICNpbmNsdWRlICJQ cmludENvbnRleHQuaCIKKyNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgogI2luY2x1ZGUgIlJl bmRlclZpZXcuaCIKICNpbmNsdWRlICJSZW5kZXJUcmVlQXNUZXh0LmgiCiAjaW5jbHVkZSAiSlNE T01CaW5kaW5nLmgiCkBAIC0xMDQzLDYgKzEwNDUsMjQgQEAgYm9vbCB3ZWJraXRfd2ViX2ZyYW1l X3BhdXNlX3N2Z19hbmltYXRpb24oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciog YW4KICNlbmRpZgogfQogCitnY2hhciogd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3Jf bGlzdF9pdGVtKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgSlNPYmplY3RSZWYgbm9kZU9iamVjdCkK K3sKKyAgICBKU0M6OkpTT2JqZWN0KiBvYmplY3QgPSB0b0pTKG5vZGVPYmplY3QpOworICAgIGlm ICghb2JqZWN0IHx8ICFvYmplY3QtPmluaGVyaXRzKCZKU0hUTUxFbGVtZW50OjpzX2luZm8pKQor ICAgICAgICByZXR1cm4gMDsKKworICAgIEhUTUxFbGVtZW50KiBlbGVtZW50ID0gc3RhdGljX2Nh c3Q8SlNIVE1MRWxlbWVudCo+KG9iamVjdCktPmltcGwoKTsKKyAgICBpZiAoIWVsZW1lbnQgfHwg IWVsZW1lbnQtPnJlbmRlcmVyKCkpCisgICAgICAgIHJldHVybiAwOworCisgICAgUmVuZGVyT2Jq ZWN0KiByZW5kZXJlciA9IGVsZW1lbnQtPnJlbmRlcmVyKCk7CisgICAgaWYgKCFyZW5kZXJlci0+ aXNMaXN0SXRlbSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIFN0cmluZyBtYXJrZXJUZXh0 ID0gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlciktPm1hcmtlclRleHQoKTsKKyAgICByZXR1cm4g Z19zdHJkdXAobWFya2VyVGV4dC51dGY4KCkuZGF0YSgpKTsKK30KKwogdW5zaWduZWQgaW50IHdl YmtpdF93ZWJfZnJhbWVfbnVtYmVyX29mX2FjdGl2ZV9hbmltYXRpb25zKFdlYktpdFdlYkZyYW1l KiBmcmFtZSkKIHsKICAgICBGcmFtZSogY29yZUZyYW1lID0gY29yZShmcmFtZSk7CmRpZmYgLS1n aXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50LmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVt ZW50LmgKaW5kZXggYTg3ZDM4OC4uZjFiZGY0ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9x d2ViZWxlbWVudC5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmVsZW1lbnQuaApAQCAtMTU1LDYg KzE1NSw3IEBAIHByaXZhdGU6CiAgICAgc3RhdGljIFFXZWJFbGVtZW50IGVuY2xvc2luZ0VsZW1l bnQoV2ViQ29yZTo6Tm9kZSopOwogCiAgICAgZnJpZW5kIGNsYXNzIFFXZWJGcmFtZTsKKyAgICBm cmllbmQgY2xhc3MgUVdlYkZyYW1lUHJpdmF0ZTsKICAgICBmcmllbmQgY2xhc3MgUVdlYkVsZW1l bnRDb2xsZWN0aW9uOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViSGl0VGVzdFJlc3VsdDsKICAgICBm cmllbmQgY2xhc3MgUVdlYkhpdFRlc3RSZXN1bHRQcml2YXRlOwpkaWZmIC0tZ2l0IGEvV2ViS2l0 L3F0L0FwaS9xd2ViZnJhbWUuY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCmluZGV4 IDNiYmNmZTIuLjNiOTYxMDggMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNw cAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKQEAgLTQ4LDYgKzQ4LDcgQEAKICNp bmNsdWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQuaCIKICNpbmNsdWRlICJQcmludENvbnRleHQuaCIK ICNpbmNsdWRlICJQdXRQcm9wZXJ0eVNsb3QuaCIKKyNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5o IgogI2luY2x1ZGUgIlJlbmRlclRyZWVBc1RleHQuaCIKICNpbmNsdWRlICJSZW5kZXJWaWV3Lmgi CiAjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCkBAIC0yNzUsNiArMjc2LDI0IEBAIHZvaWQg UVdFQktJVF9FWFBPUlQgcXRfZHJ0X2V2YWx1YXRlU2NyaXB0SW5Jc29sYXRlZFdvcmxkKFFXZWJG cmFtZSogcUZyYW1lLCBpbnQKICAgICAgICAgSlNDOjpKU1ZhbHVlIHJlc3VsdCA9IGZyYW1lLT5z Y3JpcHQoKS0+ZXhlY3V0ZVNjcmlwdEluV29ybGQobWFpblRocmVhZE5vcm1hbFdvcmxkKCksIHNj cmlwdCwgdHJ1ZSkuanNWYWx1ZSgpOwogfQogCitRU3RyaW5nIFFXZWJGcmFtZVByaXZhdGU6Om1h cmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pCit7CisgICAg RWxlbWVudCogZWxlbWVudCA9IGxpc3RJdGVtLm1fZWxlbWVudDsKKyAgICBpZiAoIWVsZW1lbnQg fHwgIWVsZW1lbnQtPnJlbmRlcmVyKCkpCisgICAgICAgIHJldHVybiBRU3RyaW5nKCk7CisKKyAg ICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gZWxlbWVudC0+cmVuZGVyZXIoKTsKKyAgICBpZiAo IXJlbmRlcmVyLT5pc0xpc3RJdGVtKCkpCisgICAgICAgIHJldHVybiBRU3RyaW5nKCk7CisKKyAg ICByZXR1cm4gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlciktPm1hcmtlclRleHQoKTsKK30KKwor UVN0cmluZyBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfbWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0 IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICByZXR1cm4gUVdlYkZyYW1lUHJpdmF0ZTo6 bWFya2VyVGV4dEZvckxpc3RJdGVtKGxpc3RJdGVtKTsKK30KKwogc3RhdGljIGJvb2wgd2ViZnJh bWVfc2Nyb2xsT3ZlcmZsb3coV2ViQ29yZTo6RnJhbWUqIGZyYW1lLCBpbnQgZHgsIGludCBkeSwg Y29uc3QgUVBvaW50JiBwb3MpCiB7CiAgICAgaWYgKCFmcmFtZSB8fCAhZnJhbWUtPmRvY3VtZW50 KCkgfHwgIWZyYW1lLT5ldmVudEhhbmRsZXIoKSkKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkv cXdlYmZyYW1lX3AuaCBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaAppbmRleCBmY2MzN2U3 Li4yNTU2ZDMwIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmgKKysrIGIv V2ViS2l0L3F0L0FwaS9xd2ViZnJhbWVfcC5oCkBAIC04OCw2ICs4OCw4IEBAIHB1YmxpYzoKICAg ICB2b2lkIHJlbmRlckZyb21UaWxlZEJhY2tpbmdTdG9yZShXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQqLCBjb25zdCBRUmVnaW9uJiBjbGlwKTsKICNlbmRpZgogCisgICAgc3RhdGljIFFTdHJpbmcg bWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSk7CisKICAg ICBRV2ViRnJhbWUgKnE7CiAgICAgUXQ6OlNjcm9sbEJhclBvbGljeSBob3Jpem9udGFsU2Nyb2xs QmFyUG9saWN5OwogICAgIFF0OjpTY3JvbGxCYXJQb2xpY3kgdmVydGljYWxTY3JvbGxCYXJQb2xp Y3k7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxv ZwppbmRleCA3ZjNiZDE2Li4wNTdkOGZiIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9n CisrKyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNC0wNCAg SmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExpc3QgaXRlbSBtYXJrZXJzIGFyZSBu b3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0aGUgRE9NLgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzcwNjAKKworICAgICAgICAqIEFw aS9xd2ViZWxlbWVudC5oOgorICAgICAgICAqIEFwaS9xd2ViZnJhbWUuY3BwOgorICAgICAgICAo UVdlYkZyYW1lUHJpdmF0ZTo6bWFya2VyVGV4dEZvckxpc3RJdGVtKToKKyAgICAgICAgKHF0X2Ry dF9tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBBZGQgYSBwcml2YXRlIEFQSSB0byBnZXQgdGhlIG1h cmtlciB0ZXh0IGZvciBhIGxpc3QgaXRlbS4KKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lX3AuaDoK KwogMjAxMC0wNC0wMiAgTGFzemxvIEdvbWJvcyAgPGxhc3psby4xLmdvbWJvc0Bub2tpYS5jb20+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4uCmRpZmYg LS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5k ZXggMWZmZTdhMC4uM2ZlYjA4MCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisr KyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDEwLTA0LTA0ICBK YWt1YiBXaWVjem9yZWsgIDxqd2llY3pvcmVrQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGlzdCBpdGVtIG1hcmtlcnMgYXJlIG5v dCBhbHdheXMgdXBkYXRlZCBhZnRlciBjaGFuZ2VzIGluIHRoZSBET00uCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzA2MAorCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAgICAobWFya2VyVGV4 dEZvckxpc3RJdGVtQ2FsbGJhY2spOiBBIGZ1bmN0aW9uIHRoYXQgcmV0dXJucyB0aGUgbWFya2Vy IHRleHQgZm9yIGEgZ2l2ZW4gbGlzdCBpdGVtLgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnN0YXRpY0Z1bmN0aW9ucyk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVz dENvbnRyb2xsZXIuaDoKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENv bnRyb2xsZXJHdGsuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRl eHRGb3JMaXN0SXRlbSk6IEltcGxlbWVudCBpdCBpbiB0aGUgR1RLIHBvcnQuCisgICAgICAgICog RHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tOgorICAgICAgICAo TGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSk6IEFkZCBhIHN0dWIu CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6 CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsZXIpOgor ICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSk6IElt cGxlbWVudCBpdCBpbiB0aGUgUXQgcG9ydC4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9xdC9M YXlvdXRUZXN0Q29udHJvbGxlclF0Lmg6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvd2luL0xh eW91dFRlc3RDb250cm9sbGVyV2luLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy OjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBBZGQgYSBzdHViLgorCiAyMDEwLTA0LTA0ICBEdW1p dHJ1IERhbmlsaXVjICA8ZHVtaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwg YWRkaW5nIG15IElSQyBuaWNrbmFtZSB0byBjb21taXR0ZXJzLnB5CmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggMjU1NGZh NC4uYTliM2UxYyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcApAQCAtMTMzMSw2ICsxMzMxLDE4IEBAIHN0YXRpYyBKU1ZhbHVl UmVmIGFwaVRlc3RHb1RvQ3VycmVudEJhY2tGb3J3YXJkSXRlbUNhbGxiYWNrKEpTQ29udGV4dFJl ZiBjb250ZXh0CiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQog CitzdGF0aWMgSlNWYWx1ZVJlZiBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW1DYWxsYmFjayhKU0NvbnRl eHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYsIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVf dCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVm KiBleGNlcHRpb24pCit7CisgICAgaWYgKGFyZ3VtZW50Q291bnQgPCAxKQorICAgICAgICByZXR1 cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBMYXlvdXRUZXN0Q29udHJv bGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNP YmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBKU09iamVjdFJlZiBub2RlT2JqZWN0 ID0gSlNWYWx1ZVRvT2JqZWN0KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKTsKKyAg ICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlU3RyaW5nKGNv bnRleHQsIGNvbnRyb2xsZXItPm1hcmtlclRleHRGb3JMaXN0SXRlbShub2RlT2JqZWN0KS5nZXQo KSk7Cit9CisKIC8vIFN0YXRpYyBWYWx1ZXMKIAogc3RhdGljIEpTVmFsdWVSZWYgZ2V0R2xvYmFs RmxhZ0NhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiB0aGlzT2JqZWN0 LCBKU1N0cmluZ1JlZiBwcm9wZXJ0eU5hbWUsIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKQEAgLTE0 NDQsNiArMTQ1Niw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91dFRlc3RDb250cm9sbGVyOjpz dGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJrZWVwV2ViSGlzdG9yeSIsIGtlZXBXZWJIaXN0 b3J5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibGF5ZXJUcmVlQXNUZXh0IiwgbGF5ZXJU cmVlQXNUZXh0Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibnVtYmVyT2ZQYWdlcyIsIG51 bWJlck9mUGFnZXNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1By b3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJtYXJrZXJUZXh0Rm9yTGlz dEl0ZW0iLCBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW1DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7 ICJub3RpZnlEb25lIiwgbm90aWZ5RG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJl YWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm51 bWJlck9mQWN0aXZlQW5pbWF0aW9ucyIsIG51bWJlck9mQWN0aXZlQW5pbWF0aW9uc0NhbGxiYWNr LCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250 RGVsZXRlIH0sCiAgICAgICAgIHsgIm92ZXJyaWRlUHJlZmVyZW5jZSIsIG92ZXJyaWRlUHJlZmVy ZW5jZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlB dHRyaWJ1dGVEb250RGVsZXRlIH0sCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv TGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCAzYzcwZjk4Li42MTk1YTdhIDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisrKyBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTI0 OCw2ICsyNDgsOCBAQCBwdWJsaWM6CiAgICAgCiAgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+ IGxheWVyVHJlZUFzVGV4dCgpIGNvbnN0OwogCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+ IG1hcmtlclRleHRGb3JMaXN0SXRlbShKU09iamVjdFJlZiBub2RlT2JqZWN0KSBjb25zdDsKKwog ICAgIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhWaWV3V2lkdGg7CiAgICAgc3RhdGljIGNvbnN0 IHVuc2lnbmVkIG1heFZpZXdIZWlnaHQ7CiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAgYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCmluZGV4IDdjMWI2 ZTcuLjVlN2M3MjcgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9M YXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcApAQCAtNTgsNiArNTgsNyBAQCBnY2hh ciogd2Via2l0X3dlYl9mcmFtZV9jb3VudGVyX3ZhbHVlX2Zvcl9lbGVtZW50X2J5X2lkKFdlYktp dFdlYkZyYW1lKiBmcmFtZSwgYwogaW50IHdlYmtpdF93ZWJfZnJhbWVfcGFnZV9udW1iZXJfZm9y X2VsZW1lbnRfYnlfaWQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogaWQsIGZs b2F0IHBhZ2VXaWR0aCwgZmxvYXQgcGFnZUhlaWdodCk7CiBpbnQgd2Via2l0X3dlYl9mcmFtZV9u dW1iZXJfb2ZfcGFnZXMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBmbG9hdCBwYWdlV2lkdGgsIGZs b2F0IHBhZ2VIZWlnaHQpOwogdm9pZCB3ZWJraXRfd2ViX2luc3BlY3Rvcl9leGVjdXRlX3Njcmlw dChXZWJLaXRXZWJJbnNwZWN0b3IqIGluc3BlY3RvciwgbG9uZyBjYWxsSWQsIGNvbnN0IGdjaGFy KiBzY3JpcHQpOworZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfbWFya2VyX3RleHRfZm9yX2xpc3Rf aXRlbShXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEpTT2JqZWN0UmVmIG5vZGVPYmplY3QpOwogfQog CiBzdGF0aWMgZ2NoYXIqIGNvcHlXZWJTZXR0aW5nS2V5KGdjaGFyKiBwcmVmZXJlbmNlS2V5KQpA QCAtNjQzLDMgKzY0NCwxMyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjphcGlUZXN0R29U b0N1cnJlbnRCYWNrRm9yd2FyZEl0ZW0oKQogewogCiB9CisKK0pTUmV0YWluUHRyPEpTU3RyaW5n UmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKEpTT2JqZWN0 UmVmIG5vZGVPYmplY3QpIGNvbnN0Cit7CisgICAgZ2NoYXIqIG1hcmtlclRleHRHQ2hhciA9IHdl YmtpdF93ZWJfZnJhbWVfbWFya2VyX3RleHRfZm9yX2xpc3RfaXRlbShtYWluRnJhbWUsIG5vZGVP YmplY3QpOworICAgIGlmICghbWFya2VyVGV4dEdDaGFyKQorICAgICAgICByZXR1cm4gMDsKKwor ICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBtYXJrZXJUZXh0KEFkb3B0LCBKU1N0cmluZ0Ny ZWF0ZVdpdGhVVEY4Q1N0cmluZyhtYXJrZXJUZXh0R0NoYXIpKTsKKyAgICByZXR1cm4gbWFya2Vy VGV4dDsKK30KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlv dXRUZXN0Q29udHJvbGxlck1hYy5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9M YXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQppbmRleCBmMzMyNjMwLi42NDRmY2VmIDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJN YWMubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250 cm9sbGVyTWFjLm1tCkBAIC0zNSw2ICszNSw3IEBACiAjaW1wb3J0ICJXb3JrUXVldWUuaCIKICNp bXBvcnQgIldvcmtRdWV1ZUl0ZW0uaCIKICNpbXBvcnQgPEZvdW5kYXRpb24vRm91bmRhdGlvbi5o PgorI2ltcG9ydCA8SmF2YVNjcmlwdENvcmUvSlNPYmplY3RSZWYuaD4KICNpbXBvcnQgPEphdmFT Y3JpcHRDb3JlL0pTUmV0YWluUHRyLmg+CiAjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9KU1N0cmlu Z1JlZi5oPgogI2ltcG9ydCA8SmF2YVNjcmlwdENvcmUvSlNTdHJpbmdSZWZDRi5oPgpAQCAtMTg3 LDYgKzE4OCwxMiBAQCBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gTGF5b3V0VGVzdENvbnRyb2xs ZXI6OmxheWVyVHJlZUFzVGV4dCgpIGNvbnN0CiAgICAgcmV0dXJuIHN0cmluZzsKIH0KIAorSlNS ZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9y TGlzdEl0ZW0oSlNPYmplY3RSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICAvLyBGSVhNRTog SW1wbGVtZW50IG1lLgorICAgIHJldHVybiBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4oKTsKK30K KwogaW50IExheW91dFRlc3RDb250cm9sbGVyOjpwYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoSlNT dHJpbmdSZWYgaWQsIGZsb2F0IHBhZ2VXaWR0aEluUGl4ZWxzLCBmbG9hdCBwYWdlSGVpZ2h0SW5Q aXhlbHMpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBpZENGKEFkb3B0Q0YsIEpTU3Ry aW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGlkKSk7CmRpZmYgLS1naXQgYS9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcCBi L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3Bw CmluZGV4IGI2NDgwYzIuLjI0MzliOGYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCkBAIC01OSwxMSArNTks MTMgQEAgZXh0ZXJuIHZvaWQgcXRfZHJ0X3dlYmluc3BlY3Rvcl9leGVjdXRlU2NyaXB0KFFXZWJQ YWdlKiBwYWdlLCBsb25nIGNhbGxJZCwgY29uc3QKIGV4dGVybiB2b2lkIHF0X2RydF93ZWJpbnNw ZWN0b3Jfc2hvdyhRV2ViUGFnZSAqcGFnZSk7CiBleHRlcm4gdm9pZCBxdF9kcnRfd2ViaW5zcGVj dG9yX2Nsb3NlKFFXZWJQYWdlICpwYWdlKTsKIGV4dGVybiB2b2lkIHF0X2RydF9lbmFibGVDYXJl dEJyb3dzaW5nKFFXZWJQYWdlKiBwYWdlLCBib29sIHZhbHVlKTsKK2V4dGVybiBRU3RyaW5nIHF0 X2RydF9tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKTsK IAogTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKFdlYkNvcmU6OkR1 bXBSZW5kZXJUcmVlKiBkcnQpCiAgICAgOiBRT2JqZWN0KCkKICAgICAsIG1fZHJ0KGRydCkKIHsK KyAgICBxUmVnaXN0ZXJNZXRhVHlwZTxRV2ViRWxlbWVudD4oIlFXZWJFbGVtZW50Iik7CiAgICAg cmVzZXQoKTsKIH0KIApAQCAtNTQxLDUgKzU0MywxMCBAQCBib29sIExheW91dFRlc3RDb250cm9s bGVyOjpjYWxsU2hvdWxkQ2xvc2VPbldlYlZpZXcoKQogICAgIHJldHVybiBmYWxzZTsKIH0KIAor UVN0cmluZyBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0 IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICByZXR1cm4gcXRfZHJ0X21hcmtlclRleHRG b3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9CisKIGNvbnN0IHVuc2lnbmVkIExheW91dFRlc3RDb250 cm9sbGVyOjptYXhWaWV3V2lkdGggPSA4MDA7CiBjb25zdCB1bnNpZ25lZCBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6bWF4Vmlld0hlaWdodCA9IDYwMDsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaCBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaAppbmRleCAzNmI1ZjcwLi44 NWU1ZmU1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRU ZXN0Q29udHJvbGxlclF0LmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5 b3V0VGVzdENvbnRyb2xsZXJRdC5oCkBAIC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8UVZhcmlh bnQ+CiAKICNpbmNsdWRlIDxxd2ViZGF0YWJhc2UuaD4KKyNpbmNsdWRlIDxxd2ViZWxlbWVudC5o PgogI2luY2x1ZGUgPHF3ZWJmcmFtZS5oPgogI2luY2x1ZGUgPHF3ZWJoaXN0b3J5Lmg+CiAjaW5j bHVkZSA8cXdlYnBhZ2UuaD4KQEAgLTE2NSw2ICsxNjYsOCBAQCBwdWJsaWMgc2xvdHM6CiAgICAg aW50IG51bWJlck9mUGFnZXMoZmxvYXQgd2lkdGggPSBtYXhWaWV3V2lkdGgsIGZsb2F0IGhlaWdo dCA9IG1heFZpZXdIZWlnaHQpOwogICAgIGJvb2wgY2FsbFNob3VsZENsb3NlT25XZWJWaWV3KCk7 CiAKKyAgICBRU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYg bGlzdEl0ZW0pOworCiBwcml2YXRlIHNsb3RzOgogICAgIHZvaWQgcHJvY2Vzc1dvcmsoKTsKIApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250 cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0 Q29udHJvbGxlcldpbi5jcHAKaW5kZXggYWQ3NTdlNC4uZTEyMTEzOSAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJX aW4uY3BwCkBAIC0zNiw2ICszNiw3IEBACiAjaW5jbHVkZSAiV29ya1F1ZXVlSXRlbS5oIgogI2lu Y2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9uLmg+CiAjaW5jbHVkZSA8SmF2YVNj cmlwdENvcmUvQXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTT2JqZWN0 UmVmLmg+CiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KICNpbmNsdWRl IDxKYXZhU2NyaXB0Q29yZS9KU1N0cmluZ1JlZkJTVFIuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS5oPgpAQCAtMTg4LDYgKzE4OSwxMiBAQCBKU1JldGFpblB0cjxK U1N0cmluZ1JlZj4gTGF5b3V0VGVzdENvbnRyb2xsZXI6OmxheWVyVHJlZUFzVGV4dCgpIGNvbnN0 CiAgICAgcmV0dXJuIHRleHRWYWx1ZUpTOwogfQogCitKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4g TGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbShKU09iamVjdFJlZiBu b2RlT2JqZWN0KSBjb25zdAoreworICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgbWUuCisgICAgcmV0 dXJuIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPigpOworfQorCiB2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjp3YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQogewogICAgIC8vIEZJWE1FOiBJbXBsZW1l bnQgdGhpcy4K 52526 2010-04-05 05:28:54 -0700 2010-04-05 12:03:13 -0700 patch 37060.patch text/plain 41001 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlYjMyYTk4Li4wYTk0ZTkyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDQt MDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKwogMjAxMC0wNC0wMyAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJr aXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgZXhwZWN0ZWQgcmVzdWx0cyBmaXguCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvbGlzdHMvZHVtcC1saXN0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmFiNGEzYjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1 bXAtbGlzdC5qcwpAQCAtMCwwICsxLDMxIEBACitmdW5jdGlvbiBpbmRlbnQoZGVwdGgpCit7Cisg ICAgdmFyIHJldCA9IG5ldyBTdHJpbmcoKTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGRlcHRo OyArK2kpCisgICAgICAgIHJldCArPSAiLT4gIjsKKyAgICByZXR1cm4gcmV0ICsgIiAiOworfQor CitmdW5jdGlvbiBkdW1wTGlzdEhlbHBlcihlbGVtZW50LCBkZXB0aCkKK3sKKyAgICB2YXIgcmV0 ID0gbmV3IFN0cmluZygpOworCisgICAgdmFyIGNoaWxkID0gZWxlbWVudC5maXJzdENoaWxkOwor ICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoY2hpbGQubm9kZVR5cGUgPT0gTm9kZS5F TEVNRU5UX05PREUpIHsKKyAgICAgICAgICAgIHZhciBtYXJrZXIgPSBsYXlvdXRUZXN0Q29udHJv bGxlci5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY2hpbGQpOworICAgICAgICAgICAgaWYgKG1hcmtl cikKKyAgICAgICAgICAgICAgICByZXQgKz0gaW5kZW50KGRlcHRoKSArICcgJyArIG1hcmtlciAr ICcgJyArIGNoaWxkLmlubmVyVGV4dC50cmltKCkgKyAnPGJyIC8+JzsKKyAgICAgICAgICAgIHJl dCArPSBkdW1wTGlzdEhlbHBlcihjaGlsZCwgZGVwdGggKyAxKTsKKyAgICAgICAgfQorCisgICAg ICAgIGNoaWxkID0gY2hpbGQubmV4dFNpYmxpbmc7CisgICAgfQorCisgICAgcmV0dXJuIHJldDsK K30KKworZnVuY3Rpb24gZHVtcExpc3QobGlzdCkKK3sKKyAgICByZXR1cm4gZHVtcExpc3RIZWxw ZXIobGlzdCwgMCk7Cit9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjM5NjQ5NgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0LWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDE0IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1h cmtlcnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxk cmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuCisKKzEgT25lCisyIFR3bworLT4gMyBUaHJlZQorNCBG b3VyCis1IEZpdmUKKzYgU2l4CistPiA3IFNldmVuCistPiA4IEVpZ2h0CistPiA5IE5pbmUKKzEw IFRlbgorMTEgRWxldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wt bmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjZiM2Q5ODcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAgKzEs NTIgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibmVzdGVkIik7CisKKyAgICAgICAgICAgICAgICB2YXIgbGkxID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTEuaW5uZXJUZXh0ID0gIkVpZ2h0IjsK KworICAgICAgICAgICAgICAgIHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIp OworICAgICAgICAgICAgICAgIGxpMi5pbm5lclRleHQgPSAiU2V2ZW4iOworCisgICAgICAgICAg ICAgICAgdmFyIGl0ZW0zID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgICAg ICAgICAgICAgaXRlbTMuaW5uZXJUZXh0ID0gIk5pbmUiOworICAgICAgICAgICAgICAgIGl0ZW0z LnN0eWxlLmRpc3BsYXkgPSAibGlzdC1pdGVtIjsKKworICAgICAgICAgICAgICAgIHAuYXBwZW5k Q2hpbGQobGkxKTsKKyAgICAgICAgICAgICAgICBwLmluc2VydEJlZm9yZShsaTIsIGxpMSk7Cisg ICAgICAgICAgICAgICAgcC5hcHBlbmRDaGlsZChpdGVtMyk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVu IG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAg ICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg IDxkaXY+PGxpPlRocmVlPC9saT48L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAg ICAgICAgICAgIDxsaT5GaXZlPC9saT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAg ICAgICAgPHAgaWQ9Im5lc3RlZCI+PC9wPgorICAgICAgICAgICAgPGxpPlRlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RWxldmVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlk PSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJlNDUzMDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJz IGFyZSB1cGRhdGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRp cmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKzMgVGhy ZWUKKzQgRm91cgorNSBGaXZlCis2IFNpeAorNyBTZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYThkYjVjCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1v dmUuaHRtbApAQCAtMCwwICsxLDUxIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNj cmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAg IGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNl dFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKworICAgICAgICAgICAgICAgIHZhciBiID0gZG9j dW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoImIiKVswXTsKKyAgICAgICAgICAgICAgICBsaXN0 LnJlbW92ZUNoaWxkKGIpOworCisgICAgICAgICAgICAgICAgdmFyIGRpdiA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJuZXN0ZWQiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBkaXYu Y2hpbGRyZW4ubGVuZ3RoOworICAgICAgICAgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgaXRl bXM7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5maXJzdEVs ZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJpdGVtIikpOworCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAg ICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxl c3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0K KyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgp Ij4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRh dGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGls ZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8Yj48bGk+Rm9vPC9saT48L2I+CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xpPgorICAg ICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAgICAgPGxpPkZpdmU8L2xpPgorICAgICAg ICAgICAgPGRpdiBpZD0ibmVzdGVkIj4KKyAgICAgICAgICAgICAgICA8bGk+Rm9vPC9saT4KKyAg ICAgICAgICAgICAgICA8bGk+QmFyPC9saT4KKyAgICAgICAgICAgICAgICA8bGk+QmF6PC9saT4K KyAgICAgICAgICAgIDwvZGl2PgorICAgICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAgICAgICAg ICA8ZGl2IGlkPSJpdGVtIiBzdHlsZT0iZGlzcGxheTogbGlzdC1pdGVtIj5Gb288L2Rpdj4KKyAg ICAgICAgICAgIDxsaT5TZXZlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWl0ZW1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0 ZW1zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMzRi MzY2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0 IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJrZWQgd2hlbiBzb21lIG9mIHRoZSBpdGVtcyBhcmUgaW5k aXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxpc3QgZWxlbWVudC4KKworMSBPbmUKKzIgVHdvCiszIFRo cmVlCis0IEZvdXIKKy0+IDUgRml2ZQorLT4gNiBTaXgKKzEwIFRlbgorMTEgRWxldmVuCistPiAx MiBUd2VsdmUKKy0+IDEzIFRoaXJ0ZWVuCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi40NDY2MjAyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApAQCAtMCwwICsxLDQyIEBACis8aHRt bD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAg ICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAg eworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAg ICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsK KyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVy SFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0 aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisg ICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNw bGF5ID0gIm5vbmUiOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hl YWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRo YXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRlbXMg YXJlIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8 b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+ VHdvPC9saT4KKyAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+Rm91 cgorICAgICAgICAgICAgICAgIDxiPgorICAgICAgICAgICAgICAgICAgICA8bGk+Rml2ZTwvbGk+ CisgICAgICAgICAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgICAgIDwvYj4K KyAgICAgICAgICAgIDwvbGk+CisgICAgICAgICAgICA8bGkgdmFsdWU9IjEwIj5UZW48L2xpPgor ICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8ZGl2PgorICAgICAgICAg ICAgICAgIDxsaT5Ud2VsdmU8L2xpPgorICAgICAgICAgICAgICAgIDxsaT5UaGlydGVlbjwvbGk+ CisgICAgICAgICAgICA8L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RmlmdGVlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZmMDk4ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTMgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBk byBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LgorCisx IE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgorNSBGaXZlIE9uZSBUd2VudHkgZml2ZSBUd2Vu dHkgc2l4CistPiAtPiAxIE9uZQorLT4gLT4gMjUgVHdlbnR5IGZpdmUKKy0+IC0+IDI2IFR3ZW50 eSBzaXgKKzYgU2l4Cis3IFNldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4wNDhiZGNlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAg KzEsNDggQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1s aXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgp CisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBh IHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKworICAgICAgICAgICAgICAgIHZhciBsaTIg PSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMi5pbm5l clRleHQgPSAiVHdlbnR5IGZpdmUiOworICAgICAgICAgICAgICAgIGxpMi52YWx1ZSA9ICIyNSI7 CisgICAgICAgICAgICAgICAgdmFyIGxpMSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxpIik7 CisgICAgICAgICAgICAgICAgbGkxLmlubmVyVGV4dCA9ICJPbmUiOworICAgICAgICAgICAgICAg IHZhciBsaTMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAg IGxpMy5pbm5lclRleHQgPSAiVHdlbnR5IHNpeCI7CisKKyAgICAgICAgICAgICAgICBuZXN0ZWRM aXN0LmFwcGVuZENoaWxkKGxpMik7CisgICAgICAgICAgICAgICAgbmVzdGVkTGlzdC5pbnNlcnRC ZWZvcmUobGkxLCBsaTIpOworICAgICAgICAgICAgICAgIG5lc3RlZExpc3QuYXBwZW5kQ2hpbGQo bGkzKTsKKworICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xl IikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBEb24n dCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9ubHkg bW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpLnN0 eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0Pgor ICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMg dGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5l dyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAg ICAgPGxpPkZpdmUgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+PC9vbD48L2xpPgorICAgICAgICAgICAg PGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW48L2xpPgorICAgICAgICA8L29sPgor CisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4K XCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY2OTExYjMKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIHRoYXQgbGlz dCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1z IGZyb20gYSBuZXN0ZWQgbGlzdC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUg Rml2ZQorMSBPbmUKKzIgVHdvCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi42OTE0ZmI4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5odG1sCkBAIC0wLDAgKzEs NDUgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBu ZXN0ZWRMaXN0LmNoaWxkcmVuLmxlbmd0aDsKKyAgICAgICAgICAgICAgICBmb3IgKHZhciBpID0g MDsgaSA8IGl0ZW1zOyArK2kpCisgICAgICAgICAgICAgICAgICAgIG5lc3RlZExpc3QucmVtb3Zl Q2hpbGQobmVzdGVkTGlzdC5maXJzdEVsZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0 ZWQgbGlzdC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+CisgICAgICAgICAgICA8bGk+T25l PC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgPGxpPlRocmVlPC9s aT4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlCisgICAg ICAgICAgICAgICAgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+CisgICAgICAgICAgICAgICAgICAgIDxs aT5PbmU8L2xpPgorICAgICAgICAgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg ICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgICAgICA8L29sPgorICAgICAgICAg ICAgPC9saT4KKyAgICAgICAgICAgIDxsaSB2YWx1ZT0iMSI+T25lPC9saT4KKyAgICAgICAgICAg IDxsaT5Ud288L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxl CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRmZjUzZWIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJv cGVybHkgbWFya2VkIHdoZW4gdGhlIGxpc3QgY29udGFpbnMgbmVzdGVkIGxpc3RzLgorCisxMCBU ZW4KKzExIEVsZXZlbgorMTIgVHdlbHZlCisxMyBUaGlydGVlbiBPbmUgVHdvCistPiAtPiDil6Yg T25lCistPiAtPiDil6YgVHdvCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorLT4gMSBPbmUKKy0+ IDIgVHdvCisxNiBTaXh0ZWVuCisxNyBTZXZlbnRlZW4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjljOWVjZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0Lmh0bWwKQEAgLTAsMCArMSw0MiBAQAorPGh0bWw+CisgICAgPGhlYWQ+CisgICAg ICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+CisgICAgICAgIDxzY3JpcHQ+CisgICAg ICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAgICAgICAgICAgICB2YXIgbGlz dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iik7CisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0 KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0 IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9h ZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHBy b3Blcmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0IGNvbnRhaW5zIG5lc3RlZCBsaXN0cy48L3A+Cisg ICAgICAgIDxvbCBpZD0ibGlzdCIgc3RhcnQ9IjEwIj4KKyAgICAgICAgICAgIDxsaT5UZW48L2xp PgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8bGk+VHdlbHZlPC9s aT4KKyAgICAgICAgICAgIDxsaT5UaGlydGVlbgorICAgICAgICAgICAgICAgIDx1bD4KKyAgICAg ICAgICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5Ud288 L2xpPgorICAgICAgICAgICAgICAgIDwvdWw+CisgICAgICAgICAgICA8L2xpPgorICAgICAgICAg ICAgPGxpPkZvdXJ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxsaT5GaWZ0ZWVuPC9saT4KKyAgICAg ICAgICAgIDxvbD4KKyAgICAgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgICAg ICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDwvb2w+CisgICAgICAgICAgICA8bGk+U2l4dGVl bjwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW50ZWVuPC9saT4KKyAgICAgICAgPC9vbD4KKwor ICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+Clwg Tm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAppbmRleCBh NjFhZDIxLi45MDc4OGExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tp cHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZApAQCAtMTU2LDMgKzE1 NiwxMCBAQCBmYXN0L3JlcGxhY2VkL2JvcmRlci1yYWRpdXMtY2xpcC5odG1sCiAjIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjY0NgogZmFzdC93b3JrZXJzL3dvcmtl ci10ZXJtaW5hdGUuaHRtbAogCisjIE1pc3NpbmcgYW4gaW1wbGVtZW50YXRpb24gb2YgTGF5b3V0 VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSgpCitmYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVt cy1keW5hbWljLXJlbW92ZS5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sCitm YXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKK2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQt bGlzdC5odG1sCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZCBi L0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCmluZGV4IGU3YzRjZWYuLmY2OWE3OGEg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCkBAIC04MjIsMyArODIyLDExIEBAIGZhc3QvbWVk aWEvbWVkaWEtZmVhdHVyZS13Z3Qtdmlldy1tb2RlLmh0bWwKIAogIyBOZWVkIGV4cGVjdGF0aW9u cy4gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjQ2MQogZmFz dC9yZXBhaW50L292ZXJmbG93LXNjcm9sbC1ib2R5LWFwcGVhci5odG1sCisKKyMgTWlzc2luZyBh biBpbXBsZW1lbnRhdGlvbiBvZiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxp c3RJdGVtKCkKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwK K2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3ZlLmh0bWwKK2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWl0ZW1zLmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1p Yy1pbnNlcnQuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5o dG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwKZGlmZiAtLWdpdCBhL1dlYkNvcmUv Q2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzYwMzg2MC4uY2MzODZjYiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNCBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJr aXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBp biB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzcwNjAKKworICAgICAgICBJbiBwYXJ0aWN1bGFyLCB0aGV5IHdvdWxkIG5vdCBiZSB1cGRh dGVkIHdoZW4gYWRkaW5nL3JlbW92aW5nIGFuIGl0ZW0KKyAgICAgICAgdGhhdCBpcyBub3QgYSBk aXJlY3QgY2hpbGQgb2YgdGhlIGxpc3QgZWxlbWVudC4KKworICAgICAgICBUZXN0czogZmFzdC9s aXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQuaHRtbAorICAgICAgICAgICAgICAg ZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbAorICAgICAgICAg ICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbAorICAgICAgICAgICAgICAgZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCisgICAgICAgICAgICAg ICBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRtbAorCisgICAgICAgICogcmVuZGVy aW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVuY2xvc2luZ0xpc3Qp OiBDaGFuZ2UgdGhlIHNpZ25hdHVyZSB0byB0YWtlIGEgUmVuZGVyTGlzdEl0ZW0qLgorICAgICAg ICAoV2ViQ29yZTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMpOiBDaGFuZ2UgaXQgdG8gdHJhdmVy c2UgdGhlIHdob2xlIHN1YnRyZWUgb2YgYSBsaXN0LCBub3Qgb25seSBzaWJsaW5ncyBvZiBhbiBp dGVtLgorICAgICAgICAoV2ViQ29yZTo6cHJldmlvdXNMaXN0SXRlbSk6CisgICAgICAgICogcmVu ZGVyaW5nL1JlbmRlckxpc3RJdGVtLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVj dC5jcHA6IE1vdmUgdGhlIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzIGZ1bmN0aW9uIHRvIFJlbmRl ckxpc3RJdGVtLmNwcC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6YWRkQ2hpbGQp OiBNb3ZlIHRoZSBjb2RlIHVwZGF0aW5nIGxpc3QgbWFya2VycyB0byBSZW5kZXJPYmplY3RDaGls ZExpc3QgZm9yIGNvbnNpc3RlbmN5LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RD aGlsZExpc3QuY3BwOiBNb3ZlIHRoZSB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlvbiB0 byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3RDaGls ZExpc3Q6OnJlbW92ZUNoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5nIHJlbW92 ZWQsIG5vdCB0aGUgbmV4dCBzaWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Q2hpbGRMaXN0OjphcHBlbmRDaGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyBh ZGRlZCwgbm90IHRoZSBuZXh0IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmpl Y3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5n IGFkZGVkLCBub3QgdGhlIG5leHQgc2libGluZy4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVy VHJlZUFzVGV4dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0p OgorCiAyMDEwLTA0LTA0ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgog CiAgICAgICAgIE5vdCByZXZpZXdlZC4gUm9sbGluZyBvdXQgY2hyb21pdW0gY2hhbmdlcyByNTcw MjggYW5kIHI1NzAzMgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0 ZW0uY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCmluZGV4IDU0YTdk ZDIuLmM5OTQxOTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVt LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKQEAgLTkyLDEz ICs5MiwxMyBAQCBzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChOb2RlKiBub2RlKQogICAgIHJl dHVybiBwYXJlbnQ7CiB9CiAKLXN0YXRpYyBOb2RlKiBlbmNsb3NpbmdMaXN0KGNvbnN0IFJlbmRl ck9iamVjdCogcmVuZGVyZXIpCitzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChjb25zdCBSZW5k ZXJMaXN0SXRlbSogbGlzdEl0ZW0pCiB7Ci0gICAgTm9kZSogbm9kZSA9IHJlbmRlcmVyLT5ub2Rl KCk7CisgICAgTm9kZSogbm9kZSA9IGxpc3RJdGVtLT5ub2RlKCk7CiAgICAgaWYgKG5vZGUpCiAg ICAgICAgIHJldHVybiBlbmNsb3NpbmdMaXN0KG5vZGUpOwogCi0gICAgcmVuZGVyZXIgPSByZW5k ZXJlci0+cGFyZW50KCk7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGxpc3RJ dGVtOwogICAgIHdoaWxlIChyZW5kZXJlciAmJiAhcmVuZGVyZXItPm5vZGUoKSkKICAgICAgICAg cmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50KCk7CiAKQEAgLTExNCwxMCArMTE0LDEyIEBAIHN0 YXRpYyBSZW5kZXJMaXN0SXRlbSogcHJldmlvdXNMaXN0SXRlbShOb2RlKiBsaXN0LCBjb25zdCBS ZW5kZXJMaXN0SXRlbSogaXRlbSkKICAgICBmb3IgKFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBp dGVtLT5wcmV2aW91c0luUHJlT3JkZXIoKTsgcmVuZGVyZXIgIT0gbGlzdC0+cmVuZGVyZXIoKTsg cmVuZGVyZXIgPSByZW5kZXJlci0+cHJldmlvdXNJblByZU9yZGVyKCkpIHsKICAgICAgICAgaWYg KCFyZW5kZXJlci0+aXNMaXN0SXRlbSgpKQogICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QocmVuZGVyZXIpOworCisgICAgICAgIFJl bmRlckxpc3RJdGVtKiBpdGVtID0gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlcik7CisgICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QoaXRlbSk7CiAgICAgICAgIC8vIFRoaXMg aXRlbSBpcyBwYXJ0IG9mIG91ciBjdXJyZW50IGxpc3QsIHNvIGl0J3Mgd2hhdCB3ZSdyZSBsb29r aW5nIGZvci4KICAgICAgICAgaWYgKGxpc3QgPT0gb3RoZXJMaXN0KQotICAgICAgICAgICAgcmV0 dXJuIHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpOworICAgICAgICAgICAgcmV0dXJuIGl0ZW07 CiAgICAgICAgIC8vIFdlIGZvdW5kIG91cnNlbGYgaW5zaWRlIGFub3RoZXIgbGlzdDsgbGV0cyBz a2lwIHRoZSByZXN0IG9mIGl0LgogICAgICAgICAvLyBVc2UgbmV4dEluUHJlT3JkZXIoKSBoZXJl IGJlY2F1c2UgdGhlIG90aGVyIGxpc3QgaXRzZWxmIG1heSBhY3R1YWxseQogICAgICAgICAvLyBi ZSBhIGxpc3QgaXRlbSBpdHNlbGYuIFdlIG5lZWQgdG8gZXhhbWluZSBpdCwgc28gd2UgZG8gdGhp cyB0byBjb3VudGVyYWN0CkBAIC0zNjQsNCArMzY2LDIxIEBAIHZvaWQgUmVuZGVyTGlzdEl0ZW06 OmNsZWFyRXhwbGljaXRWYWx1ZSgpCiAgICAgZXhwbGljaXRWYWx1ZUNoYW5nZWQoKTsKIH0KIAor dm9pZCBSZW5kZXJMaXN0SXRlbTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMoKQoreworICAgIE5v ZGUqIGxpc3ROb2RlID0gZW5jbG9zaW5nTGlzdCh0aGlzKTsKKyAgICBSZW5kZXJPYmplY3QqIGxp c3QgPSBsaXN0Tm9kZSA/IGxpc3ROb2RlLT5yZW5kZXJlcigpIDogMDsKKworICAgIGZvciAoUmVu ZGVyT2JqZWN0KiBjaGlsZCA9IHRoaXMtPm5leHRJblByZU9yZGVyKGxpc3QpOyBjaGlsZDsgY2hp bGQgPSBjaGlsZC0+bmV4dEluUHJlT3JkZXIobGlzdCkpIHsKKyAgICAgICAgaWYgKGNoaWxkLT5u b2RlKCkgJiYgaXNMaXN0KGNoaWxkLT5ub2RlKCkpKSB7CisgICAgICAgICAgICAvLyBXZSd2ZSBm b3VuZCBhIG5lc3RlZCwgaW5kZXBlbmRlbnQgbGlzdDogbm90aGluZyB0byBkbyBoZXJlLgorICAg ICAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEluUHJlT3JkZXJBZnRlckNoaWxkcmVuKGxpc3Qp LT5wcmV2aW91c0luUHJlT3JkZXIoKTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9 CisKKyAgICAgICAgaWYgKGNoaWxkLT5pc0xpc3RJdGVtKCkpCisgICAgICAgICAgICB0b1JlbmRl ckxpc3RJdGVtKGNoaWxkKS0+dXBkYXRlVmFsdWUoKTsKKyAgICB9Cit9CisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVt LmggYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oCmluZGV4IGM0YzQxZGMuLjJh ZDlhNDEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmgKKysr IGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uaApAQCAtNDYsNiArNDYsOCBAQCBw dWJsaWM6CiAKICAgICBjb25zdCBTdHJpbmcmIG1hcmtlclRleHQoKSBjb25zdDsKIAorICAgIHZv aWQgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoKTsKKwogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNv bnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdCB7IHJldHVybiAiUmVuZGVyTGlzdEl0ZW0iOyB9 CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCmluZGV4IDcwMDBiNzAuLjFmNWY0NDAgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApAQCAtMjU3LDE0ICsyNTcsNiBAQCBib29sIFJl bmRlck9iamVjdDo6aXNIVE1MTWFycXVlZSgpIGNvbnN0CiAgICAgcmV0dXJuIG5vZGUoKSAmJiBu b2RlKCktPnJlbmRlcmVyKCkgPT0gdGhpcyAmJiBub2RlKCktPmhhc1RhZ05hbWUobWFycXVlZVRh Zyk7CiB9CiAKLXN0YXRpYyB2b2lkIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVj dCogY2hpbGQpCi17Ci0gICAgZm9yIChSZW5kZXJPYmplY3QqIHNpYmxpbmcgPSBjaGlsZDsgc2li bGluZzsgc2libGluZyA9IHNpYmxpbmctPm5leHRTaWJsaW5nKCkpIHsKLSAgICAgICAgaWYgKHNp YmxpbmctPmlzTGlzdEl0ZW0oKSkKLSAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0oc2libGlu ZyktPnVwZGF0ZVZhbHVlKCk7Ci0gICAgfQotfQotCiB2b2lkIFJlbmRlck9iamVjdDo6YWRkQ2hp bGQoUmVuZGVyT2JqZWN0KiBuZXdDaGlsZCwgUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCkKIHsK ICAgICBSZW5kZXJPYmplY3RDaGlsZExpc3QqIGNoaWxkcmVuID0gdmlydHVhbENoaWxkcmVuKCk7 CkBAIC0yNzQsOSArMjY2LDcgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OmFkZENoaWxkKFJlbmRlck9i amVjdCogbmV3Q2hpbGQsIFJlbmRlck9iamVjdCogYmVmb3JlQ2hpbGQpCiAKICAgICBib29sIG5l ZWRzVGFibGUgPSBmYWxzZTsKIAotICAgIGlmIChuZXdDaGlsZC0+aXNMaXN0SXRlbSgpKQotICAg ICAgICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhiZWZvcmVDaGlsZCA/IGJlZm9yZUNoaWxkIDog Y2hpbGRyZW4tPmxhc3RDaGlsZCgpKTsKLSAgICBlbHNlIGlmIChuZXdDaGlsZC0+aXNUYWJsZUNv bCgpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ09MVU1OX0dST1VQ KQorICAgIGlmIChuZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5k aXNwbGF5KCkgPT0gVEFCTEVfQ09MVU1OX0dST1VQKQogICAgICAgICBuZWVkc1RhYmxlID0gIWlz VGFibGUoKTsKICAgICBlbHNlIGlmIChuZXdDaGlsZC0+aXNSZW5kZXJCbG9jaygpICYmIG5ld0No aWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ0FQVElPTikKICAgICAgICAgbmVlZHNU YWJsZSA9ICFpc1RhYmxlKCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJP YmplY3RDaGlsZExpc3QuY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRM aXN0LmNwcAppbmRleCA4ZWU4MTEyLi42ZDc2ZjM0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlck9iamVjdENoaWxkTGlzdC5jcHAKQEAgLTM5LDE0ICszOSw2IEBACiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAotc3RhdGljIHZvaWQgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoUmVuZGVyT2Jq ZWN0KiBjaGlsZCkKLXsKLSAgICBmb3IgKFJlbmRlck9iamVjdCogc2libGluZyA9IGNoaWxkOyBz aWJsaW5nOyBzaWJsaW5nID0gc2libGluZy0+bmV4dFNpYmxpbmcoKSkgewotICAgICAgICBpZiAo c2libGluZy0+aXNMaXN0SXRlbSgpKQotICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShzaWJs aW5nKS0+dXBkYXRlVmFsdWUoKTsKLSAgICB9Ci19Ci0KIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRM aXN0OjpkZXN0cm95TGVmdG92ZXJDaGlsZHJlbigpCiB7CiAgICAgd2hpbGUgKGZpcnN0Q2hpbGQo KSkgewpAQCAtOTEsMTEgKzgzLDEwIEBAIFJlbmRlck9iamVjdCogUmVuZGVyT2JqZWN0Q2hpbGRM aXN0OjpyZW1vdmVDaGlsZE5vZGUoUmVuZGVyT2JqZWN0KiBvd25lciwgUmVuZGVyCiAgICAgICAg ICAgICAgICAgbGF5ZXIgPSBvd25lci0+ZW5jbG9zaW5nTGF5ZXIoKTsKICAgICAgICAgICAgIG9s ZENoaWxkLT5yZW1vdmVMYXllcnMobGF5ZXIpOwogICAgICAgICB9Ci0gICAgICAgIAotICAgICAg ICAvLyByZW51bWJlciBvcmRlcmVkIGxpc3RzCisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc0xp c3RJdGVtKCkpCi0gICAgICAgICAgICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhvbGRDaGlsZC0+ bmV4dFNpYmxpbmcoKSk7Ci0gICAgICAgIAorICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShv bGRDaGlsZCktPnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKG9sZENo aWxkLT5pc1Bvc2l0aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAg ICAgIG93bmVyLT5kaXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGlsZChvbGRDaGlsZCk7CiAgICAgfQpA QCAtMTYxLDcgKzE1MiwxMCBAQCB2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6YXBwZW5kQ2hp bGROb2RlKFJlbmRlck9iamVjdCogb3duZXIsIFJlbmRlck9iamVjdCogbgogICAgICAgICAgICAg aWYgKGxheWVyKQogICAgICAgICAgICAgICAgIGxheWVyLT5zZXRIYXNWaXNpYmxlQ29udGVudCh0 cnVlKTsKICAgICAgICAgfQotICAgICAgICAKKworICAgICAgICBpZiAobmV3Q2hpbGQtPmlzTGlz dEl0ZW0oKSkKKyAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0obmV3Q2hpbGQpLT51cGRhdGVM aXN0TWFya2VyTnVtYmVycygpOworCiAgICAgICAgIGlmICghbmV3Q2hpbGQtPmlzRmxvYXRpbmdP clBvc2l0aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93 bmVyLT5kaXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGlsZChuZXdDaGlsZCk7CiAgICAgfQpAQCAtMjE4 LDcgKzIxMiw5IEBAIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjppbnNlcnRDaGlsZE5vZGUo UmVuZGVyT2JqZWN0KiBvd25lciwgUmVuZGVyT2JqZWN0KiBjCiAgICAgICAgICAgICAgICAgbGF5 ZXItPnNldEhhc1Zpc2libGVDb250ZW50KHRydWUpOwogICAgICAgICB9CiAKLSAgICAgICAgCisg ICAgICAgIGlmIChjaGlsZC0+aXNMaXN0SXRlbSgpKQorICAgICAgICAgICAgdG9SZW5kZXJMaXN0 SXRlbShjaGlsZCktPnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKCFj aGlsZC0+aXNGbG9hdGluZygpICYmIG93bmVyLT5jaGlsZHJlbklubGluZSgpKQogICAgICAgICAg ICAgb3duZXItPmRpcnR5TGluZXNGcm9tQ2hhbmdlZENoaWxkKGNoaWxkKTsKICAgICB9CmRpZmYg LS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmNwcCBiL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCmluZGV4IDg0ZjUyYzYuLjllZmMwM2UgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCisrKyBiL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCkBAIC0zNyw2ICszNyw3IEBACiAj aW5jbHVkZSAiUmVuZGVyQlIuaCIKICNpbmNsdWRlICJSZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5o IgogI2luY2x1ZGUgIlJlbmRlcklubGluZS5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgi CiAjaW5jbHVkZSAiUmVuZGVyTGlzdE1hcmtlci5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIK ICNpbmNsdWRlICJSZW5kZXJUYWJsZUNlbGwuaCIKQEAgLTY2MCw0ICs2NjEsMjAgQEAgU3RyaW5n IGNvdW50ZXJWYWx1ZUZvckVsZW1lbnQoRWxlbWVudCogZWxlbWVudCkKICAgICByZXR1cm4gc3Ry ZWFtLnJlbGVhc2UoKTsKIH0KIAorU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShFbGVtZW50 KiBlbGVtZW50KQoreworICAgIC8vIE1ha2Ugc3VyZSB0aGUgZWxlbWVudCBpcyBub3QgZnJlZWQg ZHVyaW5nIHRoZSBsYXlvdXQuCisgICAgUmVmUHRyPEVsZW1lbnQ+IGVsZW1lbnRSZWYoZWxlbWVu dCk7CisgICAgZWxlbWVudC0+ZG9jdW1lbnQoKS0+dXBkYXRlTGF5b3V0KCk7CisKKyAgICBpZiAo IWVsZW1lbnQtPnJlbmRlcmVyKCkpCisgICAgICAgIHJldHVybiBTdHJpbmcoKTsKKworICAgIFJl bmRlck9iamVjdCogcmVuZGVyZXIgPSBlbGVtZW50LT5yZW5kZXJlcigpOworICAgIGlmICghcmVu ZGVyZXItPmlzTGlzdEl0ZW0oKSkKKyAgICAgICAgcmV0dXJuIFN0cmluZygpOworCisgICAgcmV0 dXJuIHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpLT5tYXJrZXJUZXh0KCk7Cit9CisKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRy ZWVBc1RleHQuaCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuaAppbmRleCAx ZmNmZWMxLi40ZGEwYmFiIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVl QXNUZXh0LmgKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJlZUFzVGV4dC5oCkBAIC01 MSw2ICs1MSw4IEBAIFN0cmluZyBxdW90ZUFuZEVzY2FwZU5vblByaW50YWJsZXMoY29uc3QgU3Ry aW5nJik7CiAKIFN0cmluZyBjb3VudGVyVmFsdWVGb3JFbGVtZW50KEVsZW1lbnQqKTsKIAorU3Ry aW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShFbGVtZW50Kik7CisKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKIAogI2VuZGlmIC8vIFJlbmRlclRyZWVBc1RleHRfaApkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCAxNWVmZjdjLi40MDAx MTFkIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0No YW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEwLTA0LTA1ICBKYWt1YiBXaWVjem9yZWsgIDxq d2llY3pvcmVrQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgTGlzdCBpdGVtIG1hcmtlcnMgYXJlIG5vdCBhbHdheXMgdXBkYXRlZCBh ZnRlciBjaGFuZ2VzIGluIHRoZSBET00uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0zNzA2MAorCisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUu aDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwOgorICAgICAgICAod2Via2l0 X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKTogQWRkIGEgcHJpdmF0ZSBBUEkg dG8gZ2V0IHRoZSBtYXJrZXIgdGV4dCBmb3IgYSBsaXN0IGl0ZW0uCisKIDIwMTAtMDQtMDEgIEd1 c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2VyIEZyZXl0aGVyLgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5oCmluZGV4IGQwMDAwYjEuLjdkY2JkNjcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmgKQEAgLTMxNSw2ICszMTUsOSBAQCBleHRlcm4gIkMiIHsKICAgICBXRUJLSVRfQVBJIGJvb2wK ICAgICB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3N2Z19hbmltYXRpb24oV2ViS2l0V2ViRnJhbWUq IGZyYW1lLCBjb25zdCBnY2hhciogYW5pbWF0aW9uSWQsIGRvdWJsZSB0aW1lLCBjb25zdCBnY2hh ciogZWxlbWVudElkKTsKIAorICAgIFdFQktJVF9BUEkgZ2NoYXIqCisgICAgd2Via2l0X3dlYl9m cmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgSlNW YWx1ZVJlZiBub2RlT2JqZWN0KTsKKwogICAgIFdFQktJVF9BUEkgdW5zaWduZWQgaW50CiAgICAg d2Via2l0X3dlYl9mcmFtZV9udW1iZXJfb2ZfYWN0aXZlX2FuaW1hdGlvbnMoV2ViS2l0V2ViRnJh bWUqIGZyYW1lKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJh bWUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCmluZGV4IDk1Mzhk MjcuLmQ3YmIyNmMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1l LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKQEAgLTQ3LDgg KzQ3LDEwIEBACiAjaW5jbHVkZSAiR3RrVmVyc2lvbmluZy5oIgogI2luY2x1ZGUgIkhUTUxGcmFt ZU93bmVyRWxlbWVudC5oIgogI2luY2x1ZGUgIkpTRE9NV2luZG93LmgiCisjaW5jbHVkZSAiSlNI VE1MRWxlbWVudC5oIgogI2luY2x1ZGUgIkpTTG9jay5oIgogI2luY2x1ZGUgIlByaW50Q29udGV4 dC5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5o IgogI2luY2x1ZGUgIlJlbmRlclRyZWVBc1RleHQuaCIKICNpbmNsdWRlICJKU0RPTUJpbmRpbmcu aCIKQEAgLTEwNDMsNiArMTA0NSwxNiBAQCBib29sIHdlYmtpdF93ZWJfZnJhbWVfcGF1c2Vfc3Zn X2FuaW1hdGlvbihXZWJLaXRXZWJGcmFtZSogZnJhbWUsIGNvbnN0IGdjaGFyKiBhbgogI2VuZGlm CiB9CiAKK2djaGFyKiB3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0o V2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBKU1ZhbHVlUmVmIG5vZGVPYmplY3QpCit7CisgICAgRWxl bWVudCogZWxlbWVudCA9IHRvRWxlbWVudChub2RlT2JqZWN0KTsKKyAgICBpZiAoIWVsZW1lbnQp CisgICAgICAgIHJldHVybiAwOworCisgICAgU3RyaW5nIG1hcmtlclRleHQgPSBtYXJrZXJUZXh0 Rm9yTGlzdEl0ZW0oZWxlbWVudCk7CisgICAgcmV0dXJuIGdfc3RyZHVwKG1hcmtlclRleHQudXRm OCgpLmRhdGEoKSk7Cit9CisKIHVuc2lnbmVkIGludCB3ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9v Zl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFtZSogZnJhbWUpCiB7CiAgICAgRnJhbWUq IGNvcmVGcmFtZSA9IGNvcmUoZnJhbWUpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vi ZWxlbWVudC5oIGIvV2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVudC5oCmluZGV4IGE4N2QzODguLmYx YmRmNGUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmVsZW1lbnQuaAorKysgYi9XZWJL aXQvcXQvQXBpL3F3ZWJlbGVtZW50LmgKQEAgLTE1NSw2ICsxNTUsNyBAQCBwcml2YXRlOgogICAg IHN0YXRpYyBRV2ViRWxlbWVudCBlbmNsb3NpbmdFbGVtZW50KFdlYkNvcmU6Ok5vZGUqKTsKIAog ICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJhbWU7CisgICAgZnJpZW5kIGNsYXNzIFFXZWJGcmFtZVBy aXZhdGU7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJFbGVtZW50Q29sbGVjdGlvbjsKICAgICBmcmll bmQgY2xhc3MgUVdlYkhpdFRlc3RSZXN1bHQ7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJIaXRUZXN0 UmVzdWx0UHJpdmF0ZTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBi L1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAppbmRleCAzYmJjZmUyLi4zMGFmNDdiIDEwMDY0 NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9x d2ViZnJhbWUuY3BwCkBAIC00OCw2ICs0OCw3IEBACiAjaW5jbHVkZSAiUGxhdGZvcm1XaGVlbEV2 ZW50LmgiCiAjaW5jbHVkZSAiUHJpbnRDb250ZXh0LmgiCiAjaW5jbHVkZSAiUHV0UHJvcGVydHlT bG90LmgiCisjaW5jbHVkZSAiUmVuZGVyTGlzdEl0ZW0uaCIKICNpbmNsdWRlICJSZW5kZXJUcmVl QXNUZXh0LmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUgIlJlc291cmNlUmVx dWVzdC5oIgpAQCAtMjc1LDYgKzI3NiwxNyBAQCB2b2lkIFFXRUJLSVRfRVhQT1JUIHF0X2RydF9l dmFsdWF0ZVNjcmlwdEluSXNvbGF0ZWRXb3JsZChRV2ViRnJhbWUqIHFGcmFtZSwgaW50CiAgICAg ICAgIEpTQzo6SlNWYWx1ZSByZXN1bHQgPSBmcmFtZS0+c2NyaXB0KCktPmV4ZWN1dGVTY3JpcHRJ bldvcmxkKG1haW5UaHJlYWROb3JtYWxXb3JsZCgpLCBzY3JpcHQsIHRydWUpLmpzVmFsdWUoKTsK IH0KIAorUVN0cmluZyBRV2ViRnJhbWVQcml2YXRlOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY29u c3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKQoreworICAgIEVsZW1lbnQqIGVsZW1lbnQgPSBsaXN0 SXRlbS5tX2VsZW1lbnQ7CisgICAgcmV0dXJuIFdlYkNvcmU6Om1hcmtlclRleHRGb3JMaXN0SXRl bShlbGVtZW50KTsKK30KKworUVN0cmluZyBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfbWFya2VyVGV4 dEZvckxpc3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICByZXR1cm4g UVdlYkZyYW1lUHJpdmF0ZTo6bWFya2VyVGV4dEZvckxpc3RJdGVtKGxpc3RJdGVtKTsKK30KKwog c3RhdGljIGJvb2wgd2ViZnJhbWVfc2Nyb2xsT3ZlcmZsb3coV2ViQ29yZTo6RnJhbWUqIGZyYW1l LCBpbnQgZHgsIGludCBkeSwgY29uc3QgUVBvaW50JiBwb3MpCiB7CiAgICAgaWYgKCFmcmFtZSB8 fCAhZnJhbWUtPmRvY3VtZW50KCkgfHwgIWZyYW1lLT5ldmVudEhhbmRsZXIoKSkKZGlmZiAtLWdp dCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaCBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1l X3AuaAppbmRleCBmY2MzN2U3Li4yNTU2ZDMwIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3 ZWJmcmFtZV9wLmgKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWVfcC5oCkBAIC04OCw2ICs4 OCw4IEBAIHB1YmxpYzoKICAgICB2b2lkIHJlbmRlckZyb21UaWxlZEJhY2tpbmdTdG9yZShXZWJD b3JlOjpHcmFwaGljc0NvbnRleHQqLCBjb25zdCBRUmVnaW9uJiBjbGlwKTsKICNlbmRpZgogCisg ICAgc3RhdGljIFFTdHJpbmcgbWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50 JiBsaXN0SXRlbSk7CisKICAgICBRV2ViRnJhbWUgKnE7CiAgICAgUXQ6OlNjcm9sbEJhclBvbGlj eSBob3Jpem9udGFsU2Nyb2xsQmFyUG9saWN5OwogICAgIFF0OjpTY3JvbGxCYXJQb2xpY3kgdmVy dGljYWxTY3JvbGxCYXJQb2xpY3k7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIv V2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCA3ZjNiZDE2Li5kNWYyMDdlIDEwMDY0NAotLS0gYS9X ZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx NiBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJraXQub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExpc3Qg aXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0aGUg RE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzcw NjAKKworICAgICAgICAqIEFwaS9xd2ViZWxlbWVudC5oOgorICAgICAgICAqIEFwaS9xd2ViZnJh bWUuY3BwOgorICAgICAgICAoUVdlYkZyYW1lUHJpdmF0ZTo6bWFya2VyVGV4dEZvckxpc3RJdGVt KToKKyAgICAgICAgKHF0X2RydF9tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBBZGQgYSBwcml2YXRl IEFQSSB0byBnZXQgdGhlIG1hcmtlciB0ZXh0IGZvciBhIGxpc3QgaXRlbS4KKyAgICAgICAgKiBB cGkvcXdlYmZyYW1lX3AuaDoKKwogMjAxMC0wNC0wMiAgTGFzemxvIEdvbWJvcyAgPGxhc3psby4x LmdvbWJvc0Bub2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSb2hkZSBD aHJpc3RpYW5zZW4uCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9XZWJLaXRU b29scy9DaGFuZ2VMb2cKaW5kZXggMzhlZjRhYS4uYmJiOTE2OSAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1 IEBACisyMDEwLTA0LTA1ICBKYWt1YiBXaWVjem9yZWsgIDxqd2llY3pvcmVrQHdlYmtpdC5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGlzdCBp dGVtIG1hcmtlcnMgYXJlIG5vdCBhbHdheXMgdXBkYXRlZCBhZnRlciBjaGFuZ2VzIGluIHRoZSBE T00uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzA2 MAorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgor ICAgICAgICAobWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2spOiBBIGZ1bmN0aW9uIHRoYXQg cmV0dXJucyB0aGUgbWFya2VyIHRleHQgZm9yIGEgZ2l2ZW4gbGlzdCBpdGVtLgorICAgICAgICAo TGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucyk6CisgICAgICAgICogRHVtcFJl bmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaDoKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENv bnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSk6IEltcGxlbWVudCBpdCBpbiB0aGUgR1RL IHBvcnQuCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVy TWFjLm1tOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0 SXRlbSk6IEFkZCBhIHN0dWIuCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVz dENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0 VGVzdENvbnRyb2xsZXIpOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRl eHRGb3JMaXN0SXRlbSk6IEltcGxlbWVudCBpdCBpbiB0aGUgUXQgcG9ydC4KKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0Lmg6CisgICAgICAgICogRHVt cFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDoKKyAgICAgICAgKExh eW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBBZGQgYSBzdHViLgor CiAyMDEwLTA0LTA1ICBDaHJpcyBKZXJkb25layAgPGNqZXJkb25la0B3ZWJraXQub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IFNoaW5pY2hpcm8gSGFtYWppLgpkaWZmIC0tZ2l0IGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCmluZGV4IDI1NTRmYTQu LjQ3Njg2YzQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5jcHAKQEAgLTEzMzEsNiArMTMzMSwxMyBAQCBzdGF0aWMgSlNWYWx1ZVJl ZiBhcGlUZXN0R29Ub0N1cnJlbnRCYWNrRm9yd2FyZEl0ZW1DYWxsYmFjayhKU0NvbnRleHRSZWYg Y29udGV4dAogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAor c3RhdGljIEpTVmFsdWVSZWYgbWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3Qg YXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiog ZXhjZXB0aW9uKQoreworICAgIGlmIChhcmd1bWVudENvdW50IDwgMSkKKyAgICAgICAgcmV0dXJu IEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworICAgIHJldHVybiBKU1ZhbHVlTWFrZVN0 cmluZyhjb250ZXh0LCBjb250cm9sbGVyLT5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oYXJndW1lbnRz WzBdKS5nZXQoKSk7Cit9CisKIC8vIFN0YXRpYyBWYWx1ZXMKIAogc3RhdGljIEpTVmFsdWVSZWYg Z2V0R2xvYmFsRmxhZ0NhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiB0 aGlzT2JqZWN0LCBKU1N0cmluZ1JlZiBwcm9wZXJ0eU5hbWUsIEpTVmFsdWVSZWYqIGV4Y2VwdGlv bikKQEAgLTE0NDQsNiArMTQ1MSw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91dFRlc3RDb250 cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJrZWVwV2ViSGlzdG9yeSIsIGtl ZXBXZWJIaXN0b3J5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQ cm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibGF5ZXJUcmVlQXNUZXh0 IiwgbGF5ZXJUcmVlQXNUZXh0Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibnVtYmVyT2ZQ YWdlcyIsIG51bWJlck9mUGFnZXNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25s eSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJtYXJrZXJU ZXh0Rm9yTGlzdEl0ZW0iLCBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW1DYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJub3RpZnlEb25lIiwgbm90aWZ5RG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAg ICAgIHsgIm51bWJlck9mQWN0aXZlQW5pbWF0aW9ucyIsIG51bWJlck9mQWN0aXZlQW5pbWF0aW9u c0NhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRy aWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm92ZXJyaWRlUHJlZmVyZW5jZSIsIG92ZXJy aWRlUHJlZmVyZW5jZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pT UHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCAzYzcwZjk4Li40NjQ5ZGU5IDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxl ci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVy LmgKQEAgLTI0OCw2ICsyNDgsOCBAQCBwdWJsaWM6CiAgICAgCiAgICAgSlNSZXRhaW5QdHI8SlNT dHJpbmdSZWY+IGxheWVyVHJlZUFzVGV4dCgpIGNvbnN0OwogCisgICAgSlNSZXRhaW5QdHI8SlNT dHJpbmdSZWY+IG1hcmtlclRleHRGb3JMaXN0SXRlbShKU1ZhbHVlUmVmIG5vZGVPYmplY3QpIGNv bnN0OworCiAgICAgc3RhdGljIGNvbnN0IHVuc2lnbmVkIG1heFZpZXdXaWR0aDsKICAgICBzdGF0 aWMgY29uc3QgdW5zaWduZWQgbWF4Vmlld0hlaWdodDsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcCBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKaW5k ZXggN2MxYjZlNy4uZjI0Mjk0OSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCkBAIC01OCw2ICs1OCw3 IEBAIGdjaGFyKiB3ZWJraXRfd2ViX2ZyYW1lX2NvdW50ZXJfdmFsdWVfZm9yX2VsZW1lbnRfYnlf aWQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjCiBpbnQgd2Via2l0X3dlYl9mcmFtZV9wYWdlX251 bWJlcl9mb3JfZWxlbWVudF9ieV9pZChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIGNvbnN0IGdjaGFy KiBpZCwgZmxvYXQgcGFnZVdpZHRoLCBmbG9hdCBwYWdlSGVpZ2h0KTsKIGludCB3ZWJraXRfd2Vi X2ZyYW1lX251bWJlcl9vZl9wYWdlcyhXZWJLaXRXZWJGcmFtZSogZnJhbWUsIGZsb2F0IHBhZ2VX aWR0aCwgZmxvYXQgcGFnZUhlaWdodCk7CiB2b2lkIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2V4ZWN1 dGVfc2NyaXB0KFdlYktpdFdlYkluc3BlY3RvciogaW5zcGVjdG9yLCBsb25nIGNhbGxJZCwgY29u c3QgZ2NoYXIqIHNjcmlwdCk7CitnY2hhciogd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9m b3JfbGlzdF9pdGVtKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgSlNPYmplY3RSZWYgbm9kZU9iamVj dCk7CiB9CiAKIHN0YXRpYyBnY2hhciogY29weVdlYlNldHRpbmdLZXkoZ2NoYXIqIHByZWZlcmVu Y2VLZXkpCkBAIC02NDMsMyArNjQ0LDEzIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmFw aVRlc3RHb1RvQ3VycmVudEJhY2tGb3J3YXJkSXRlbSgpCiB7CiAKIH0KKworSlNSZXRhaW5QdHI8 SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0o SlNWYWx1ZVJlZiBub2RlT2JqZWN0KSBjb25zdAoreworICAgIGdjaGFyKiBtYXJrZXJUZXh0R0No YXIgPSB3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0obWFpbkZyYW1l LCBub2RlT2JqZWN0KTsKKyAgICBpZiAoIW1hcmtlclRleHRHQ2hhcikKKyAgICAgICAgcmV0dXJu IDA7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gbWFya2VyVGV4dChBZG9wdCwgSlNT dHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcobWFya2VyVGV4dEdDaGFyKSk7CisgICAgcmV0dXJu IG1hcmtlclRleHQ7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KaW5kZXggZjMzMjYzMC4uMmEwYjRiMSAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250 cm9sbGVyTWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRU ZXN0Q29udHJvbGxlck1hYy5tbQpAQCAtMTg3LDYgKzE4NywxMiBAQCBKU1JldGFpblB0cjxKU1N0 cmluZ1JlZj4gTGF5b3V0VGVzdENvbnRyb2xsZXI6OmxheWVyVHJlZUFzVGV4dCgpIGNvbnN0CiAg ICAgcmV0dXJuIHN0cmluZzsKIH0KIAorSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRl c3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNWYWx1ZVJlZiBub2RlT2JqZWN0 KSBjb25zdAoreworICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgbWUuCisgICAgcmV0dXJuIEpTUmV0 YWluUHRyPEpTU3RyaW5nUmVmPigpOworfQorCiBpbnQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnBh Z2VOdW1iZXJGb3JFbGVtZW50QnlJZChKU1N0cmluZ1JlZiBpZCwgZmxvYXQgcGFnZVdpZHRoSW5Q aXhlbHMsIGZsb2F0IHBhZ2VIZWlnaHRJblBpeGVscykKIHsKICAgICBSZXRhaW5QdHI8Q0ZTdHJp bmdSZWY+IGlkQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVm YXVsdCwgaWQpKTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xh eW91dFRlc3RDb250cm9sbGVyUXQuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQv TGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHAKaW5kZXggYjY0ODBjMi4uMjQzOWI4ZiAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJR dC5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRy b2xsZXJRdC5jcHAKQEAgLTU5LDExICs1OSwxMyBAQCBleHRlcm4gdm9pZCBxdF9kcnRfd2ViaW5z cGVjdG9yX2V4ZWN1dGVTY3JpcHQoUVdlYlBhZ2UqIHBhZ2UsIGxvbmcgY2FsbElkLCBjb25zdAog ZXh0ZXJuIHZvaWQgcXRfZHJ0X3dlYmluc3BlY3Rvcl9zaG93KFFXZWJQYWdlICpwYWdlKTsKIGV4 dGVybiB2b2lkIHF0X2RydF93ZWJpbnNwZWN0b3JfY2xvc2UoUVdlYlBhZ2UgKnBhZ2UpOwogZXh0 ZXJuIHZvaWQgcXRfZHJ0X2VuYWJsZUNhcmV0QnJvd3NpbmcoUVdlYlBhZ2UqIHBhZ2UsIGJvb2wg dmFsdWUpOworZXh0ZXJuIFFTdHJpbmcgcXRfZHJ0X21hcmtlclRleHRGb3JMaXN0SXRlbShjb25z dCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pOwogCiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0 VGVzdENvbnRyb2xsZXIoV2ViQ29yZTo6RHVtcFJlbmRlclRyZWUqIGRydCkKICAgICA6IFFPYmpl Y3QoKQogICAgICwgbV9kcnQoZHJ0KQogeworICAgIHFSZWdpc3Rlck1ldGFUeXBlPFFXZWJFbGVt ZW50PigiUVdlYkVsZW1lbnQiKTsKICAgICByZXNldCgpOwogfQogCkBAIC01NDEsNSArNTQzLDEw IEBAIGJvb2wgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmNhbGxTaG91bGRDbG9zZU9uV2ViVmlldygp CiAgICAgcmV0dXJuIGZhbHNlOwogfQogCitRU3RyaW5nIExheW91dFRlc3RDb250cm9sbGVyOjpt YXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKQoreworICAg IHJldHVybiBxdF9kcnRfbWFya2VyVGV4dEZvckxpc3RJdGVtKGxpc3RJdGVtKTsKK30KKwogY29u c3QgdW5zaWduZWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1heFZpZXdXaWR0aCA9IDgwMDsKIGNv bnN0IHVuc2lnbmVkIExheW91dFRlc3RDb250cm9sbGVyOjptYXhWaWV3SGVpZ2h0ID0gNjAwOwpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRy b2xsZXJRdC5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRy b2xsZXJRdC5oCmluZGV4IDM2YjVmNzAuLjg1ZTVmZTUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaAorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmgKQEAgLTQwLDYg KzQwLDcgQEAKICNpbmNsdWRlIDxRVmFyaWFudD4KIAogI2luY2x1ZGUgPHF3ZWJkYXRhYmFzZS5o PgorI2luY2x1ZGUgPHF3ZWJlbGVtZW50Lmg+CiAjaW5jbHVkZSA8cXdlYmZyYW1lLmg+CiAjaW5j bHVkZSA8cXdlYmhpc3RvcnkuaD4KICNpbmNsdWRlIDxxd2VicGFnZS5oPgpAQCAtMTY1LDYgKzE2 Niw4IEBAIHB1YmxpYyBzbG90czoKICAgICBpbnQgbnVtYmVyT2ZQYWdlcyhmbG9hdCB3aWR0aCA9 IG1heFZpZXdXaWR0aCwgZmxvYXQgaGVpZ2h0ID0gbWF4Vmlld0hlaWdodCk7CiAgICAgYm9vbCBj YWxsU2hvdWxkQ2xvc2VPbldlYlZpZXcoKTsKIAorICAgIFFTdHJpbmcgbWFya2VyVGV4dEZvckxp c3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSk7CisKIHByaXZhdGUgc2xvdHM6CiAg ICAgdm9pZCBwcm9jZXNzV29yaygpOwogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAppbmRleCBhZDc1N2U0 Li41ZWY4Y2NjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5 b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKQEAgLTE4OCw2ICsxODgsMTIgQEAgSlNS ZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVyOjpsYXllclRyZWVBc1Rl eHQoKSBjb25zdAogICAgIHJldHVybiB0ZXh0VmFsdWVKUzsKIH0KIAorSlNSZXRhaW5QdHI8SlNT dHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNW YWx1ZVJlZiBub2RlT2JqZWN0KSBjb25zdAoreworICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgbWUu CisgICAgcmV0dXJuIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPigpOworfQorCiB2b2lkIExheW91 dFRlc3RDb250cm9sbGVyOjp3YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQogewogICAgIC8vIEZJWE1F OiBJbXBsZW1lbnQgdGhpcy4K 52553 2010-04-05 12:03:13 -0700 2010-04-06 23:43:37 -0700 patch list-markers-dom-changes-v3.patch text/plain 41740 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlYjMyYTk4Li4wYTk0ZTkyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDQt MDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKwogMjAxMC0wNC0wMyAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJr aXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgZXhwZWN0ZWQgcmVzdWx0cyBmaXguCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvbGlzdHMvZHVtcC1saXN0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmFiNGEzYjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1 bXAtbGlzdC5qcwpAQCAtMCwwICsxLDMxIEBACitmdW5jdGlvbiBpbmRlbnQoZGVwdGgpCit7Cisg ICAgdmFyIHJldCA9IG5ldyBTdHJpbmcoKTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGRlcHRo OyArK2kpCisgICAgICAgIHJldCArPSAiLT4gIjsKKyAgICByZXR1cm4gcmV0ICsgIiAiOworfQor CitmdW5jdGlvbiBkdW1wTGlzdEhlbHBlcihlbGVtZW50LCBkZXB0aCkKK3sKKyAgICB2YXIgcmV0 ID0gbmV3IFN0cmluZygpOworCisgICAgdmFyIGNoaWxkID0gZWxlbWVudC5maXJzdENoaWxkOwor ICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoY2hpbGQubm9kZVR5cGUgPT0gTm9kZS5F TEVNRU5UX05PREUpIHsKKyAgICAgICAgICAgIHZhciBtYXJrZXIgPSBsYXlvdXRUZXN0Q29udHJv bGxlci5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY2hpbGQpOworICAgICAgICAgICAgaWYgKG1hcmtl cikKKyAgICAgICAgICAgICAgICByZXQgKz0gaW5kZW50KGRlcHRoKSArICcgJyArIG1hcmtlciAr ICcgJyArIGNoaWxkLmlubmVyVGV4dC50cmltKCkgKyAnPGJyIC8+JzsKKyAgICAgICAgICAgIHJl dCArPSBkdW1wTGlzdEhlbHBlcihjaGlsZCwgZGVwdGggKyAxKTsKKyAgICAgICAgfQorCisgICAg ICAgIGNoaWxkID0gY2hpbGQubmV4dFNpYmxpbmc7CisgICAgfQorCisgICAgcmV0dXJuIHJldDsK K30KKworZnVuY3Rpb24gZHVtcExpc3QobGlzdCkKK3sKKyAgICByZXR1cm4gZHVtcExpc3RIZWxw ZXIobGlzdCwgMCk7Cit9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjM5NjQ5NgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0LWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDE0IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1h cmtlcnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxk cmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuCisKKzEgT25lCisyIFR3bworLT4gMyBUaHJlZQorNCBG b3VyCis1IEZpdmUKKzYgU2l4CistPiA3IFNldmVuCistPiA4IEVpZ2h0CistPiA5IE5pbmUKKzEw IFRlbgorMTEgRWxldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wt bmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjZiM2Q5ODcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAgKzEs NTIgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibmVzdGVkIik7CisKKyAgICAgICAgICAgICAgICB2YXIgbGkxID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTEuaW5uZXJUZXh0ID0gIkVpZ2h0IjsK KworICAgICAgICAgICAgICAgIHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIp OworICAgICAgICAgICAgICAgIGxpMi5pbm5lclRleHQgPSAiU2V2ZW4iOworCisgICAgICAgICAg ICAgICAgdmFyIGl0ZW0zID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgICAg ICAgICAgICAgaXRlbTMuaW5uZXJUZXh0ID0gIk5pbmUiOworICAgICAgICAgICAgICAgIGl0ZW0z LnN0eWxlLmRpc3BsYXkgPSAibGlzdC1pdGVtIjsKKworICAgICAgICAgICAgICAgIHAuYXBwZW5k Q2hpbGQobGkxKTsKKyAgICAgICAgICAgICAgICBwLmluc2VydEJlZm9yZShsaTIsIGxpMSk7Cisg ICAgICAgICAgICAgICAgcC5hcHBlbmRDaGlsZChpdGVtMyk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVu IG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAg ICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg IDxkaXY+PGxpPlRocmVlPC9saT48L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAg ICAgICAgICAgIDxsaT5GaXZlPC9saT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAg ICAgICAgPHAgaWQ9Im5lc3RlZCI+PC9wPgorICAgICAgICAgICAgPGxpPlRlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RWxldmVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlk PSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJlNDUzMDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJz IGFyZSB1cGRhdGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRp cmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKzMgVGhy ZWUKKzQgRm91cgorNSBGaXZlCis2IFNpeAorNyBTZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYThkYjVjCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1v dmUuaHRtbApAQCAtMCwwICsxLDUxIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNj cmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAg IGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNl dFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKworICAgICAgICAgICAgICAgIHZhciBiID0gZG9j dW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoImIiKVswXTsKKyAgICAgICAgICAgICAgICBsaXN0 LnJlbW92ZUNoaWxkKGIpOworCisgICAgICAgICAgICAgICAgdmFyIGRpdiA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJuZXN0ZWQiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBkaXYu Y2hpbGRyZW4ubGVuZ3RoOworICAgICAgICAgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgaXRl bXM7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5maXJzdEVs ZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJpdGVtIikpOworCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAg ICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxl c3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0K KyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgp Ij4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRh dGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGls ZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8Yj48bGk+Rm9vPC9saT48L2I+CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xpPgorICAg ICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAgICAgPGxpPkZpdmU8L2xpPgorICAgICAg ICAgICAgPGRpdiBpZD0ibmVzdGVkIj4KKyAgICAgICAgICAgICAgICA8bGk+Rm9vPC9saT4KKyAg ICAgICAgICAgICAgICA8bGk+QmFyPC9saT4KKyAgICAgICAgICAgICAgICA8bGk+QmF6PC9saT4K KyAgICAgICAgICAgIDwvZGl2PgorICAgICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAgICAgICAg ICA8ZGl2IGlkPSJpdGVtIiBzdHlsZT0iZGlzcGxheTogbGlzdC1pdGVtIj5Gb288L2Rpdj4KKyAg ICAgICAgICAgIDxsaT5TZXZlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWl0ZW1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0 ZW1zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMzRi MzY2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0 IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJrZWQgd2hlbiBzb21lIG9mIHRoZSBpdGVtcyBhcmUgaW5k aXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxpc3QgZWxlbWVudC4KKworMSBPbmUKKzIgVHdvCiszIFRo cmVlCis0IEZvdXIKKy0+IDUgRml2ZQorLT4gNiBTaXgKKzEwIFRlbgorMTEgRWxldmVuCistPiAx MiBUd2VsdmUKKy0+IDEzIFRoaXJ0ZWVuCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi40NDY2MjAyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApAQCAtMCwwICsxLDQyIEBACis8aHRt bD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAg ICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAg eworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAg ICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsK KyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVy SFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0 aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisg ICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNw bGF5ID0gIm5vbmUiOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hl YWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRo YXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRlbXMg YXJlIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8 b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+ VHdvPC9saT4KKyAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+Rm91 cgorICAgICAgICAgICAgICAgIDxiPgorICAgICAgICAgICAgICAgICAgICA8bGk+Rml2ZTwvbGk+ CisgICAgICAgICAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgICAgIDwvYj4K KyAgICAgICAgICAgIDwvbGk+CisgICAgICAgICAgICA8bGkgdmFsdWU9IjEwIj5UZW48L2xpPgor ICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8ZGl2PgorICAgICAgICAg ICAgICAgIDxsaT5Ud2VsdmU8L2xpPgorICAgICAgICAgICAgICAgIDxsaT5UaGlydGVlbjwvbGk+ CisgICAgICAgICAgICA8L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RmlmdGVlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZmMDk4ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTMgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBk byBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LgorCisx IE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgorNSBGaXZlIE9uZSBUd2VudHkgZml2ZSBUd2Vu dHkgc2l4CistPiAtPiAxIE9uZQorLT4gLT4gMjUgVHdlbnR5IGZpdmUKKy0+IC0+IDI2IFR3ZW50 eSBzaXgKKzYgU2l4Cis3IFNldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4wNDhiZGNlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAg KzEsNDggQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1s aXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgp CisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBh IHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKworICAgICAgICAgICAgICAgIHZhciBsaTIg PSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMi5pbm5l clRleHQgPSAiVHdlbnR5IGZpdmUiOworICAgICAgICAgICAgICAgIGxpMi52YWx1ZSA9ICIyNSI7 CisgICAgICAgICAgICAgICAgdmFyIGxpMSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxpIik7 CisgICAgICAgICAgICAgICAgbGkxLmlubmVyVGV4dCA9ICJPbmUiOworICAgICAgICAgICAgICAg IHZhciBsaTMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAg IGxpMy5pbm5lclRleHQgPSAiVHdlbnR5IHNpeCI7CisKKyAgICAgICAgICAgICAgICBuZXN0ZWRM aXN0LmFwcGVuZENoaWxkKGxpMik7CisgICAgICAgICAgICAgICAgbmVzdGVkTGlzdC5pbnNlcnRC ZWZvcmUobGkxLCBsaTIpOworICAgICAgICAgICAgICAgIG5lc3RlZExpc3QuYXBwZW5kQ2hpbGQo bGkzKTsKKworICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xl IikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBEb24n dCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9ubHkg bW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpLnN0 eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0Pgor ICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMg dGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5l dyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAg ICAgPGxpPkZpdmUgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+PC9vbD48L2xpPgorICAgICAgICAgICAg PGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW48L2xpPgorICAgICAgICA8L29sPgor CisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4K XCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY2OTExYjMKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIHRoYXQgbGlz dCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1z IGZyb20gYSBuZXN0ZWQgbGlzdC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUg Rml2ZQorMSBPbmUKKzIgVHdvCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi42OTE0ZmI4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5odG1sCkBAIC0wLDAgKzEs NDUgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBu ZXN0ZWRMaXN0LmNoaWxkcmVuLmxlbmd0aDsKKyAgICAgICAgICAgICAgICBmb3IgKHZhciBpID0g MDsgaSA8IGl0ZW1zOyArK2kpCisgICAgICAgICAgICAgICAgICAgIG5lc3RlZExpc3QucmVtb3Zl Q2hpbGQobmVzdGVkTGlzdC5maXJzdEVsZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0 ZWQgbGlzdC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+CisgICAgICAgICAgICA8bGk+T25l PC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgPGxpPlRocmVlPC9s aT4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlCisgICAg ICAgICAgICAgICAgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+CisgICAgICAgICAgICAgICAgICAgIDxs aT5PbmU8L2xpPgorICAgICAgICAgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg ICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgICAgICA8L29sPgorICAgICAgICAg ICAgPC9saT4KKyAgICAgICAgICAgIDxsaSB2YWx1ZT0iMSI+T25lPC9saT4KKyAgICAgICAgICAg IDxsaT5Ud288L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxl CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRmZjUzZWIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJv cGVybHkgbWFya2VkIHdoZW4gdGhlIGxpc3QgY29udGFpbnMgbmVzdGVkIGxpc3RzLgorCisxMCBU ZW4KKzExIEVsZXZlbgorMTIgVHdlbHZlCisxMyBUaGlydGVlbiBPbmUgVHdvCistPiAtPiDil6Yg T25lCistPiAtPiDil6YgVHdvCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorLT4gMSBPbmUKKy0+ IDIgVHdvCisxNiBTaXh0ZWVuCisxNyBTZXZlbnRlZW4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjljOWVjZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0Lmh0bWwKQEAgLTAsMCArMSw0MiBAQAorPGh0bWw+CisgICAgPGhlYWQ+CisgICAg ICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+CisgICAgICAgIDxzY3JpcHQ+CisgICAg ICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAgICAgICAgICAgICB2YXIgbGlz dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iik7CisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0 KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0 IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9h ZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHBy b3Blcmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0IGNvbnRhaW5zIG5lc3RlZCBsaXN0cy48L3A+Cisg ICAgICAgIDxvbCBpZD0ibGlzdCIgc3RhcnQ9IjEwIj4KKyAgICAgICAgICAgIDxsaT5UZW48L2xp PgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8bGk+VHdlbHZlPC9s aT4KKyAgICAgICAgICAgIDxsaT5UaGlydGVlbgorICAgICAgICAgICAgICAgIDx1bD4KKyAgICAg ICAgICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5Ud288 L2xpPgorICAgICAgICAgICAgICAgIDwvdWw+CisgICAgICAgICAgICA8L2xpPgorICAgICAgICAg ICAgPGxpPkZvdXJ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxsaT5GaWZ0ZWVuPC9saT4KKyAgICAg ICAgICAgIDxvbD4KKyAgICAgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgICAg ICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDwvb2w+CisgICAgICAgICAgICA8bGk+U2l4dGVl bjwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW50ZWVuPC9saT4KKyAgICAgICAgPC9vbD4KKwor ICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+Clwg Tm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAppbmRleCBh NjFhZDIxLi45MDc4OGExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tp cHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZApAQCAtMTU2LDMgKzE1 NiwxMCBAQCBmYXN0L3JlcGxhY2VkL2JvcmRlci1yYWRpdXMtY2xpcC5odG1sCiAjIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjY0NgogZmFzdC93b3JrZXJzL3dvcmtl ci10ZXJtaW5hdGUuaHRtbAogCisjIE1pc3NpbmcgYW4gaW1wbGVtZW50YXRpb24gb2YgTGF5b3V0 VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSgpCitmYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVt cy1keW5hbWljLXJlbW92ZS5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sCitm YXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKK2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQt bGlzdC5odG1sCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZCBi L0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCmluZGV4IGU3YzRjZWYuLmY2OWE3OGEg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCkBAIC04MjIsMyArODIyLDExIEBAIGZhc3QvbWVk aWEvbWVkaWEtZmVhdHVyZS13Z3Qtdmlldy1tb2RlLmh0bWwKIAogIyBOZWVkIGV4cGVjdGF0aW9u cy4gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjQ2MQogZmFz dC9yZXBhaW50L292ZXJmbG93LXNjcm9sbC1ib2R5LWFwcGVhci5odG1sCisKKyMgTWlzc2luZyBh biBpbXBsZW1lbnRhdGlvbiBvZiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxp c3RJdGVtKCkKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwK K2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3ZlLmh0bWwKK2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWl0ZW1zLmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1p Yy1pbnNlcnQuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5o dG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwKZGlmZiAtLWdpdCBhL1dlYkNvcmUv Q2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzYwMzg2MC4uY2MzODZjYiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNCBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJr aXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBp biB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzcwNjAKKworICAgICAgICBJbiBwYXJ0aWN1bGFyLCB0aGV5IHdvdWxkIG5vdCBiZSB1cGRh dGVkIHdoZW4gYWRkaW5nL3JlbW92aW5nIGFuIGl0ZW0KKyAgICAgICAgdGhhdCBpcyBub3QgYSBk aXJlY3QgY2hpbGQgb2YgdGhlIGxpc3QgZWxlbWVudC4KKworICAgICAgICBUZXN0czogZmFzdC9s aXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQuaHRtbAorICAgICAgICAgICAgICAg ZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbAorICAgICAgICAg ICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbAorICAgICAgICAgICAgICAgZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCisgICAgICAgICAgICAg ICBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRtbAorCisgICAgICAgICogcmVuZGVy aW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVuY2xvc2luZ0xpc3Qp OiBDaGFuZ2UgdGhlIHNpZ25hdHVyZSB0byB0YWtlIGEgUmVuZGVyTGlzdEl0ZW0qLgorICAgICAg ICAoV2ViQ29yZTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMpOiBDaGFuZ2UgaXQgdG8gdHJhdmVy c2UgdGhlIHdob2xlIHN1YnRyZWUgb2YgYSBsaXN0LCBub3Qgb25seSBzaWJsaW5ncyBvZiBhbiBp dGVtLgorICAgICAgICAoV2ViQ29yZTo6cHJldmlvdXNMaXN0SXRlbSk6CisgICAgICAgICogcmVu ZGVyaW5nL1JlbmRlckxpc3RJdGVtLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVj dC5jcHA6IE1vdmUgdGhlIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzIGZ1bmN0aW9uIHRvIFJlbmRl ckxpc3RJdGVtLmNwcC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6YWRkQ2hpbGQp OiBNb3ZlIHRoZSBjb2RlIHVwZGF0aW5nIGxpc3QgbWFya2VycyB0byBSZW5kZXJPYmplY3RDaGls ZExpc3QgZm9yIGNvbnNpc3RlbmN5LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RD aGlsZExpc3QuY3BwOiBNb3ZlIHRoZSB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlvbiB0 byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3RDaGls ZExpc3Q6OnJlbW92ZUNoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5nIHJlbW92 ZWQsIG5vdCB0aGUgbmV4dCBzaWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Q2hpbGRMaXN0OjphcHBlbmRDaGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyBh ZGRlZCwgbm90IHRoZSBuZXh0IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmpl Y3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5n IGFkZGVkLCBub3QgdGhlIG5leHQgc2libGluZy4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVy VHJlZUFzVGV4dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0p OgorCiAyMDEwLTA0LTA0ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgog CiAgICAgICAgIE5vdCByZXZpZXdlZC4gUm9sbGluZyBvdXQgY2hyb21pdW0gY2hhbmdlcyByNTcw MjggYW5kIHI1NzAzMgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0 ZW0uY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCmluZGV4IDU0YTdk ZDIuLmYxMGM2ZTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVt LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKQEAgLTkyLDEz ICs5MiwxMyBAQCBzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChOb2RlKiBub2RlKQogICAgIHJl dHVybiBwYXJlbnQ7CiB9CiAKLXN0YXRpYyBOb2RlKiBlbmNsb3NpbmdMaXN0KGNvbnN0IFJlbmRl ck9iamVjdCogcmVuZGVyZXIpCitzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChjb25zdCBSZW5k ZXJMaXN0SXRlbSogbGlzdEl0ZW0pCiB7Ci0gICAgTm9kZSogbm9kZSA9IHJlbmRlcmVyLT5ub2Rl KCk7CisgICAgTm9kZSogbm9kZSA9IGxpc3RJdGVtLT5ub2RlKCk7CiAgICAgaWYgKG5vZGUpCiAg ICAgICAgIHJldHVybiBlbmNsb3NpbmdMaXN0KG5vZGUpOwogCi0gICAgcmVuZGVyZXIgPSByZW5k ZXJlci0+cGFyZW50KCk7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGxpc3RJ dGVtOwogICAgIHdoaWxlIChyZW5kZXJlciAmJiAhcmVuZGVyZXItPm5vZGUoKSkKICAgICAgICAg cmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50KCk7CiAKQEAgLTExNCwxMCArMTE0LDEyIEBAIHN0 YXRpYyBSZW5kZXJMaXN0SXRlbSogcHJldmlvdXNMaXN0SXRlbShOb2RlKiBsaXN0LCBjb25zdCBS ZW5kZXJMaXN0SXRlbSogaXRlbSkKICAgICBmb3IgKFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBp dGVtLT5wcmV2aW91c0luUHJlT3JkZXIoKTsgcmVuZGVyZXIgIT0gbGlzdC0+cmVuZGVyZXIoKTsg cmVuZGVyZXIgPSByZW5kZXJlci0+cHJldmlvdXNJblByZU9yZGVyKCkpIHsKICAgICAgICAgaWYg KCFyZW5kZXJlci0+aXNMaXN0SXRlbSgpKQogICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QocmVuZGVyZXIpOworCisgICAgICAgIFJl bmRlckxpc3RJdGVtKiBpdGVtID0gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlcik7CisgICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QoaXRlbSk7CiAgICAgICAgIC8vIFRoaXMg aXRlbSBpcyBwYXJ0IG9mIG91ciBjdXJyZW50IGxpc3QsIHNvIGl0J3Mgd2hhdCB3ZSdyZSBsb29r aW5nIGZvci4KICAgICAgICAgaWYgKGxpc3QgPT0gb3RoZXJMaXN0KQotICAgICAgICAgICAgcmV0 dXJuIHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpOworICAgICAgICAgICAgcmV0dXJuIGl0ZW07 CiAgICAgICAgIC8vIFdlIGZvdW5kIG91cnNlbGYgaW5zaWRlIGFub3RoZXIgbGlzdDsgbGV0cyBz a2lwIHRoZSByZXN0IG9mIGl0LgogICAgICAgICAvLyBVc2UgbmV4dEluUHJlT3JkZXIoKSBoZXJl IGJlY2F1c2UgdGhlIG90aGVyIGxpc3QgaXRzZWxmIG1heSBhY3R1YWxseQogICAgICAgICAvLyBi ZSBhIGxpc3QgaXRlbSBpdHNlbGYuIFdlIG5lZWQgdG8gZXhhbWluZSBpdCwgc28gd2UgZG8gdGhp cyB0byBjb3VudGVyYWN0CkBAIC0zNjQsNCArMzY2LDM4IEBAIHZvaWQgUmVuZGVyTGlzdEl0ZW06 OmNsZWFyRXhwbGljaXRWYWx1ZSgpCiAgICAgZXhwbGljaXRWYWx1ZUNoYW5nZWQoKTsKIH0KIAor dm9pZCBSZW5kZXJMaXN0SXRlbTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMoKQoreworICAgIE5v ZGUqIGxpc3ROb2RlID0gZW5jbG9zaW5nTGlzdCh0aGlzKTsKKyAgICBBU1NFUlQobGlzdE5vZGUg JiYgbGlzdE5vZGUtPnJlbmRlcmVyKCkpOworICAgIGlmICghbGlzdE5vZGUgfHwgIWxpc3ROb2Rl LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm47CisKKyAgICBSZW5kZXJPYmplY3QqIGxpc3Qg PSBsaXN0Tm9kZS0+cmVuZGVyZXIoKTsKKyAgICBSZW5kZXJPYmplY3QqIGNoaWxkID0gdGhpcy0+ bmV4dEluUHJlT3JkZXIobGlzdCk7CisgICAgd2hpbGUgKGNoaWxkKSB7CisgICAgICAgIGlmIChj aGlsZC0+bm9kZSgpICYmIGlzTGlzdChjaGlsZC0+bm9kZSgpKSkgeworICAgICAgICAgICAgLy8g V2UndmUgZm91bmQgYSBuZXN0ZWQsIGluZGVwZW5kZW50IGxpc3Q6IG5vdGhpbmcgdG8gZG8gaGVy ZS4KKyAgICAgICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHRJblByZU9yZGVyQWZ0ZXJDaGlsZHJl bihsaXN0KTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgaWYg KGNoaWxkLT5pc0xpc3RJdGVtKCkpIHsKKyAgICAgICAgICAgIFJlbmRlckxpc3RJdGVtKiBpdGVt ID0gdG9SZW5kZXJMaXN0SXRlbShjaGlsZCk7CisKKyAgICAgICAgICAgIGlmICghaXRlbS0+bV9p c1ZhbHVlVXBUb0RhdGUpIHsKKyAgICAgICAgICAgICAgICAvLyBJZiBhbiBpdGVtIGhhcyBiZWVu IG1hcmtlZCBmb3IgdXBkYXRlIGJlZm9yZSwgd2UgY2FuIHNhZmVseQorICAgICAgICAgICAgICAg IC8vIGFzc3VtZSB0aGF0IGFsbCB0aGUgZm9sbG93aW5nIG9uZXMgaGF2ZSB0b28uCisgICAgICAg ICAgICAgICAgLy8gVGhpcyBnaXZlcyB1cyB0aGUgb3Bwb3J0dW5pdHkgdG8gc3RvcCBoZXJlIGFu ZCBhdm9pZAorICAgICAgICAgICAgICAgIC8vIG1hcmtpbmcgdGhlIHNhbWUgbm9kZXMgYWdhaW4u CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGl0 ZW0tPnVwZGF0ZVZhbHVlKCk7CisgICAgICAgIH0KKworICAgICAgICBjaGlsZCA9IGNoaWxkLT5u ZXh0SW5QcmVPcmRlcihsaXN0KTsKKyAgICB9Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmggYi9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oCmluZGV4IGM0YzQxZGMuLjJhZDlhNDEgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmgKKysrIGIvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uaApAQCAtNDYsNiArNDYsOCBAQCBwdWJsaWM6CiAKICAg ICBjb25zdCBTdHJpbmcmIG1hcmtlclRleHQoKSBjb25zdDsKIAorICAgIHZvaWQgdXBkYXRlTGlz dE1hcmtlck51bWJlcnMoKTsKKwogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJl bmRlck5hbWUoKSBjb25zdCB7IHJldHVybiAiUmVuZGVyTGlzdEl0ZW0iOyB9CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCmluZGV4IDcwMDBiNzAuLjFmNWY0NDAgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyT2JqZWN0LmNwcApAQCAtMjU3LDE0ICsyNTcsNiBAQCBib29sIFJlbmRlck9iamVjdDo6 aXNIVE1MTWFycXVlZSgpIGNvbnN0CiAgICAgcmV0dXJuIG5vZGUoKSAmJiBub2RlKCktPnJlbmRl cmVyKCkgPT0gdGhpcyAmJiBub2RlKCktPmhhc1RhZ05hbWUobWFycXVlZVRhZyk7CiB9CiAKLXN0 YXRpYyB2b2lkIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVjdCogY2hpbGQpCi17 Ci0gICAgZm9yIChSZW5kZXJPYmplY3QqIHNpYmxpbmcgPSBjaGlsZDsgc2libGluZzsgc2libGlu ZyA9IHNpYmxpbmctPm5leHRTaWJsaW5nKCkpIHsKLSAgICAgICAgaWYgKHNpYmxpbmctPmlzTGlz dEl0ZW0oKSkKLSAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0oc2libGluZyktPnVwZGF0ZVZh bHVlKCk7Ci0gICAgfQotfQotCiB2b2lkIFJlbmRlck9iamVjdDo6YWRkQ2hpbGQoUmVuZGVyT2Jq ZWN0KiBuZXdDaGlsZCwgUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCkKIHsKICAgICBSZW5kZXJP YmplY3RDaGlsZExpc3QqIGNoaWxkcmVuID0gdmlydHVhbENoaWxkcmVuKCk7CkBAIC0yNzQsOSAr MjY2LDcgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OmFkZENoaWxkKFJlbmRlck9iamVjdCogbmV3Q2hp bGQsIFJlbmRlck9iamVjdCogYmVmb3JlQ2hpbGQpCiAKICAgICBib29sIG5lZWRzVGFibGUgPSBm YWxzZTsKIAotICAgIGlmIChuZXdDaGlsZC0+aXNMaXN0SXRlbSgpKQotICAgICAgICB1cGRhdGVM aXN0TWFya2VyTnVtYmVycyhiZWZvcmVDaGlsZCA/IGJlZm9yZUNoaWxkIDogY2hpbGRyZW4tPmxh c3RDaGlsZCgpKTsKLSAgICBlbHNlIGlmIChuZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0No aWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ09MVU1OX0dST1VQKQorICAgIGlmIChu ZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0g VEFCTEVfQ09MVU1OX0dST1VQKQogICAgICAgICBuZWVkc1RhYmxlID0gIWlzVGFibGUoKTsKICAg ICBlbHNlIGlmIChuZXdDaGlsZC0+aXNSZW5kZXJCbG9jaygpICYmIG5ld0NoaWxkLT5zdHlsZSgp LT5kaXNwbGF5KCkgPT0gVEFCTEVfQ0FQVElPTikKICAgICAgICAgbmVlZHNUYWJsZSA9ICFpc1Rh YmxlKCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExp c3QuY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAppbmRl eCA4ZWU4MTEyLi42ZDc2ZjM0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJP YmplY3RDaGlsZExpc3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdENo aWxkTGlzdC5jcHAKQEAgLTM5LDE0ICszOSw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAot c3RhdGljIHZvaWQgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoUmVuZGVyT2JqZWN0KiBjaGlsZCkK LXsKLSAgICBmb3IgKFJlbmRlck9iamVjdCogc2libGluZyA9IGNoaWxkOyBzaWJsaW5nOyBzaWJs aW5nID0gc2libGluZy0+bmV4dFNpYmxpbmcoKSkgewotICAgICAgICBpZiAoc2libGluZy0+aXNM aXN0SXRlbSgpKQotICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShzaWJsaW5nKS0+dXBkYXRl VmFsdWUoKTsKLSAgICB9Ci19Ci0KIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpkZXN0cm95 TGVmdG92ZXJDaGlsZHJlbigpCiB7CiAgICAgd2hpbGUgKGZpcnN0Q2hpbGQoKSkgewpAQCAtOTEs MTEgKzgzLDEwIEBAIFJlbmRlck9iamVjdCogUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpyZW1vdmVD aGlsZE5vZGUoUmVuZGVyT2JqZWN0KiBvd25lciwgUmVuZGVyCiAgICAgICAgICAgICAgICAgbGF5 ZXIgPSBvd25lci0+ZW5jbG9zaW5nTGF5ZXIoKTsKICAgICAgICAgICAgIG9sZENoaWxkLT5yZW1v dmVMYXllcnMobGF5ZXIpOwogICAgICAgICB9Ci0gICAgICAgIAotICAgICAgICAvLyByZW51bWJl ciBvcmRlcmVkIGxpc3RzCisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc0xpc3RJdGVtKCkpCi0g ICAgICAgICAgICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhvbGRDaGlsZC0+bmV4dFNpYmxpbmco KSk7Ci0gICAgICAgIAorICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShvbGRDaGlsZCktPnVw ZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc1Bvc2l0 aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5k aXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGlsZChvbGRDaGlsZCk7CiAgICAgfQpAQCAtMTYxLDcgKzE1 MiwxMCBAQCB2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6YXBwZW5kQ2hpbGROb2RlKFJlbmRl ck9iamVjdCogb3duZXIsIFJlbmRlck9iamVjdCogbgogICAgICAgICAgICAgaWYgKGxheWVyKQog ICAgICAgICAgICAgICAgIGxheWVyLT5zZXRIYXNWaXNpYmxlQ29udGVudCh0cnVlKTsKICAgICAg ICAgfQotICAgICAgICAKKworICAgICAgICBpZiAobmV3Q2hpbGQtPmlzTGlzdEl0ZW0oKSkKKyAg ICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0obmV3Q2hpbGQpLT51cGRhdGVMaXN0TWFya2VyTnVt YmVycygpOworCiAgICAgICAgIGlmICghbmV3Q2hpbGQtPmlzRmxvYXRpbmdPclBvc2l0aW9uZWQo KSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxp bmVzRnJvbUNoYW5nZWRDaGlsZChuZXdDaGlsZCk7CiAgICAgfQpAQCAtMjE4LDcgKzIxMiw5IEBA IHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjppbnNlcnRDaGlsZE5vZGUoUmVuZGVyT2JqZWN0 KiBvd25lciwgUmVuZGVyT2JqZWN0KiBjCiAgICAgICAgICAgICAgICAgbGF5ZXItPnNldEhhc1Zp c2libGVDb250ZW50KHRydWUpOwogICAgICAgICB9CiAKLSAgICAgICAgCisgICAgICAgIGlmIChj aGlsZC0+aXNMaXN0SXRlbSgpKQorICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShjaGlsZCkt PnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKCFjaGlsZC0+aXNGbG9h dGluZygpICYmIG93bmVyLT5jaGlsZHJlbklubGluZSgpKQogICAgICAgICAgICAgb3duZXItPmRp cnR5TGluZXNGcm9tQ2hhbmdlZENoaWxkKGNoaWxkKTsKICAgICB9CmRpZmYgLS1naXQgYS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlclRyZWVBc1RleHQuY3BwCmluZGV4IDg0ZjUyYzYuLjc1YzM1YmEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiUmVu ZGVyQlIuaCIKICNpbmNsdWRlICJSZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5oIgogI2luY2x1ZGUg IlJlbmRlcklubGluZS5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAi UmVuZGVyTGlzdE1hcmtlci5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJS ZW5kZXJUYWJsZUNlbGwuaCIKQEAgLTY2MCw0ICs2NjEsMTcgQEAgU3RyaW5nIGNvdW50ZXJWYWx1 ZUZvckVsZW1lbnQoRWxlbWVudCogZWxlbWVudCkKICAgICByZXR1cm4gc3RyZWFtLnJlbGVhc2Uo KTsKIH0KIAorU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShFbGVtZW50KiBlbGVtZW50KQor eworICAgIC8vIE1ha2Ugc3VyZSB0aGUgZWxlbWVudCBpcyBub3QgZnJlZWQgZHVyaW5nIHRoZSBs YXlvdXQuCisgICAgUmVmUHRyPEVsZW1lbnQ+IGVsZW1lbnRSZWYoZWxlbWVudCk7CisgICAgZWxl bWVudC0+ZG9jdW1lbnQoKS0+dXBkYXRlTGF5b3V0KCk7CisKKyAgICBSZW5kZXJPYmplY3QqIHJl bmRlcmVyID0gZWxlbWVudC0+cmVuZGVyZXIoKTsKKyAgICBpZiAoIXJlbmRlcmVyIHx8ICFyZW5k ZXJlci0+aXNMaXN0SXRlbSgpKQorICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisKKyAgICByZXR1 cm4gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlciktPm1hcmtlclRleHQoKTsKK30KKwogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJl ZUFzVGV4dC5oIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJlZUFzVGV4dC5oCmluZGV4IDFm Y2ZlYzEuLjRkYTBiYWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVB c1RleHQuaAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmgKQEAgLTUx LDYgKzUxLDggQEAgU3RyaW5nIHF1b3RlQW5kRXNjYXBlTm9uUHJpbnRhYmxlcyhjb25zdCBTdHJp bmcmKTsKIAogU3RyaW5nIGNvdW50ZXJWYWx1ZUZvckVsZW1lbnQoRWxlbWVudCopOwogCitTdHJp bmcgbWFya2VyVGV4dEZvckxpc3RJdGVtKEVsZW1lbnQqKTsKKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQogCiAjZW5kaWYgLy8gUmVuZGVyVHJlZUFzVGV4dF9oCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDE1ZWZmN2MuLjQwMDEx MWQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTAtMDQtMDUgIEpha3ViIFdpZWN6b3JlayAgPGp3 aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBhcmUgbm90IGFsd2F5cyB1cGRhdGVkIGFm dGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5o OgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHA6CisgICAgICAgICh3ZWJraXRf d2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0pOiBBZGQgYSBwcml2YXRlIEFQSSB0 byBnZXQgdGhlIG1hcmtlciB0ZXh0IGZvciBhIGxpc3QgaXRlbS4KKwogMjAxMC0wNC0wMSAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KIAog ICAgICAgICBSZXZpZXdlZCBieSBIb2xnZXIgRnJleXRoZXIuCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgKaW5kZXggZDAwMDBiMS4uN2RjYmQ2NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu aApAQCAtMzE1LDYgKzMxNSw5IEBAIGV4dGVybiAiQyIgewogICAgIFdFQktJVF9BUEkgYm9vbAog ICAgIHdlYmtpdF93ZWJfZnJhbWVfcGF1c2Vfc3ZnX2FuaW1hdGlvbihXZWJLaXRXZWJGcmFtZSog ZnJhbWUsIGNvbnN0IGdjaGFyKiBhbmltYXRpb25JZCwgZG91YmxlIHRpbWUsIGNvbnN0IGdjaGFy KiBlbGVtZW50SWQpOwogCisgICAgV0VCS0lUX0FQSSBnY2hhcioKKyAgICB3ZWJraXRfd2ViX2Zy YW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBKU1Zh bHVlUmVmIG5vZGVPYmplY3QpOworCiAgICAgV0VCS0lUX0FQSSB1bnNpZ25lZCBpbnQKICAgICB3 ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFt ZSogZnJhbWUpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggOTUzOGQy Ny4uYjgzOTNjZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUu Y3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNDcsOCAr NDcsMTAgQEAKICNpbmNsdWRlICJHdGtWZXJzaW9uaW5nLmgiCiAjaW5jbHVkZSAiSFRNTEZyYW1l T3duZXJFbGVtZW50LmgiCiAjaW5jbHVkZSAiSlNET01XaW5kb3cuaCIKKyNpbmNsdWRlICJKU0Vs ZW1lbnQuaCIKICNpbmNsdWRlICJKU0xvY2suaCIKICNpbmNsdWRlICJQcmludENvbnRleHQuaCIK KyNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNp bmNsdWRlICJSZW5kZXJUcmVlQXNUZXh0LmgiCiAjaW5jbHVkZSAiSlNET01CaW5kaW5nLmgiCkBA IC0xMDQzLDYgKzEwNDUsMTYgQEAgYm9vbCB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3N2Z19hbmlt YXRpb24oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogYW4KICNlbmRpZgogfQog CitnY2hhciogd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKFdlYktp dFdlYkZyYW1lKiBmcmFtZSwgSlNWYWx1ZVJlZiBub2RlT2JqZWN0KQoreworICAgIEVsZW1lbnQq IGVsZW1lbnQgPSB0b0VsZW1lbnQodG9KUygwLCBub2RlT2JqZWN0KSk7CisgICAgaWYgKCFlbGVt ZW50KQorICAgICAgICByZXR1cm4gMDsKKworICAgIFN0cmluZyBtYXJrZXJUZXh0ID0gbWFya2Vy VGV4dEZvckxpc3RJdGVtKGVsZW1lbnQpOworICAgIHJldHVybiBnX3N0cmR1cChtYXJrZXJUZXh0 LnV0ZjgoKS5kYXRhKCkpOworfQorCiB1bnNpZ25lZCBpbnQgd2Via2l0X3dlYl9mcmFtZV9udW1i ZXJfb2ZfYWN0aXZlX2FuaW1hdGlvbnMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKQogewogICAgIEZy YW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkv cXdlYmVsZW1lbnQuaCBiL1dlYktpdC9xdC9BcGkvcXdlYmVsZW1lbnQuaAppbmRleCBhODdkMzg4 Li5mMWJkZjRlIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50LmgKKysrIGIv V2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVudC5oCkBAIC0xNTUsNiArMTU1LDcgQEAgcHJpdmF0ZToK ICAgICBzdGF0aWMgUVdlYkVsZW1lbnQgZW5jbG9zaW5nRWxlbWVudChXZWJDb3JlOjpOb2RlKik7 CiAKICAgICBmcmllbmQgY2xhc3MgUVdlYkZyYW1lOworICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJh bWVQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViRWxlbWVudENvbGxlY3Rpb247CiAgICAg ZnJpZW5kIGNsYXNzIFFXZWJIaXRUZXN0UmVzdWx0OwogICAgIGZyaWVuZCBjbGFzcyBRV2ViSGl0 VGVzdFJlc3VsdFByaXZhdGU7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5j cHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggM2JiY2ZlMi4uMzBhZjQ3YiAx MDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9xdC9B cGkvcXdlYmZyYW1lLmNwcApAQCAtNDgsNiArNDgsNyBAQAogI2luY2x1ZGUgIlBsYXRmb3JtV2hl ZWxFdmVudC5oIgogI2luY2x1ZGUgIlByaW50Q29udGV4dC5oIgogI2luY2x1ZGUgIlB1dFByb3Bl cnR5U2xvdC5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVy VHJlZUFzVGV4dC5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJSZXNvdXJj ZVJlcXVlc3QuaCIKQEAgLTI3NSw2ICsyNzYsMTcgQEAgdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9k cnRfZXZhbHVhdGVTY3JpcHRJbklzb2xhdGVkV29ybGQoUVdlYkZyYW1lKiBxRnJhbWUsIGludAog ICAgICAgICBKU0M6OkpTVmFsdWUgcmVzdWx0ID0gZnJhbWUtPnNjcmlwdCgpLT5leGVjdXRlU2Ny aXB0SW5Xb3JsZChtYWluVGhyZWFkTm9ybWFsV29ybGQoKSwgc2NyaXB0LCB0cnVlKS5qc1ZhbHVl KCk7CiB9CiAKK1FTdHJpbmcgUVdlYkZyYW1lUHJpdmF0ZTo6bWFya2VyVGV4dEZvckxpc3RJdGVt KGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICBFbGVtZW50KiBlbGVtZW50ID0g bGlzdEl0ZW0ubV9lbGVtZW50OworICAgIHJldHVybiBXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlz dEl0ZW0oZWxlbWVudCk7Cit9CisKK1FTdHJpbmcgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X21hcmtl clRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pCit7CisgICAgcmV0 dXJuIFFXZWJGcmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9 CisKIHN0YXRpYyBib29sIHdlYmZyYW1lX3Njcm9sbE92ZXJmbG93KFdlYkNvcmU6OkZyYW1lKiBm cmFtZSwgaW50IGR4LCBpbnQgZHksIGNvbnN0IFFQb2ludCYgcG9zKQogewogICAgIGlmICghZnJh bWUgfHwgIWZyYW1lLT5kb2N1bWVudCgpIHx8ICFmcmFtZS0+ZXZlbnRIYW5kbGVyKCkpCmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJm cmFtZV9wLmgKaW5kZXggZmNjMzdlNy4uMjU1NmQzMCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0Fw aS9xd2ViZnJhbWVfcC5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaApAQCAtODgs NiArODgsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCByZW5kZXJGcm9tVGlsZWRCYWNraW5nU3RvcmUo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0KiwgY29uc3QgUVJlZ2lvbiYgY2xpcCk7CiAjZW5kaWYK IAorICAgIHN0YXRpYyBRU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxl bWVudCYgbGlzdEl0ZW0pOworCiAgICAgUVdlYkZyYW1lICpxOwogICAgIFF0OjpTY3JvbGxCYXJQ b2xpY3kgaG9yaXpvbnRhbFNjcm9sbEJhclBvbGljeTsKICAgICBRdDo6U2Nyb2xsQmFyUG9saWN5 IHZlcnRpY2FsU2Nyb2xsQmFyUG9saWN5OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxv ZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggN2YzYmQxNi4uZDVmMjA3ZSAxMDA2NDQKLS0t IGEvV2ViS2l0L3F0L0NoYW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTYgQEAKKzIwMTAtMDQtMDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0 Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBM aXN0IGl0ZW0gbWFya2VycyBhcmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4g dGhlIERPTS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM3MDYwCisKKyAgICAgICAgKiBBcGkvcXdlYmVsZW1lbnQuaDoKKyAgICAgICAgKiBBcGkvcXdl YmZyYW1lLmNwcDoKKyAgICAgICAgKFFXZWJGcmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0 SXRlbSk6CisgICAgICAgIChxdF9kcnRfbWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgcHJp dmF0ZSBBUEkgdG8gZ2V0IHRoZSBtYXJrZXIgdGV4dCBmb3IgYSBsaXN0IGl0ZW0uCisgICAgICAg ICogQXBpL3F3ZWJmcmFtZV9wLmg6CisKIDIwMTAtMDQtMDIgIExhc3psbyBHb21ib3MgIDxsYXN6 bG8uMS5nb21ib3NAbm9raWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9o ZGUgQ2hyaXN0aWFuc2VuLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2Vi S2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDM4ZWY0YWEuLmJiYjkxNjkgMTAwNjQ0Ci0tLSBhL1dl YktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyNSBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJraXQu b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExp c3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0 aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzcwNjAKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNw cDoKKyAgICAgICAgKG1hcmtlclRleHRGb3JMaXN0SXRlbUNhbGxiYWNrKTogQSBmdW5jdGlvbiB0 aGF0IHJldHVybnMgdGhlIG1hcmtlciB0ZXh0IGZvciBhIGdpdmVuIGxpc3QgaXRlbS4KKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAqIER1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAgICogRHVtcFJlbmRl clRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoKKyAgICAgICAgKExheW91dFRl c3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhl IEdUSyBwb3J0LgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJv bGxlck1hYy5tbToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9y TGlzdEl0ZW0pOiBBZGQgYSBzdHViLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L0xheW91 dFRlc3RDb250cm9sbGVyUXQuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Okxh eW91dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJr ZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhlIFF0IHBvcnQuCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5oOgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHA6CisgICAgICAg IChMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgc3R1 Yi4KKwogMjAxMC0wNC0wNSAgQ2hyaXMgSmVyZG9uZWsgIDxjamVyZG9uZWtAd2Via2l0Lm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBTaGluaWNoaXJvIEhhbWFqaS4KZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCAyNTU0 ZmE0Li40NzY4NmM0IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBAIC0xMzMxLDYgKzEzMzEsMTMgQEAgc3RhdGljIEpTVmFs dWVSZWYgYXBpVGVzdEdvVG9DdXJyZW50QmFja0ZvcndhcmRJdGVtQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQKICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9 CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG1hcmtlclRleHRGb3JMaXN0SXRlbUNhbGxiYWNrKEpTQ29u dGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6 ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVS ZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBpZiAoYXJndW1lbnRDb3VudCA8IDEpCisgICAgICAgIHJl dHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKKyAgICByZXR1cm4gSlNWYWx1ZU1h a2VTdHJpbmcoY29udGV4dCwgY29udHJvbGxlci0+bWFya2VyVGV4dEZvckxpc3RJdGVtKGFyZ3Vt ZW50c1swXSkuZ2V0KCkpOworfQorCiAvLyBTdGF0aWMgVmFsdWVzCiAKIHN0YXRpYyBKU1ZhbHVl UmVmIGdldEdsb2JhbEZsYWdDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RS ZWYgdGhpc09iamVjdCwgSlNTdHJpbmdSZWYgcHJvcGVydHlOYW1lLCBKU1ZhbHVlUmVmKiBleGNl cHRpb24pCkBAIC0xNDQ0LDYgKzE0NTEsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0 Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAia2VlcFdlYkhpc3Rvcnki LCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgImxheWVyVHJlZUFz VGV4dCIsIGxheWVyVHJlZUFzVGV4dENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRP bmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm51bWJl ck9mUGFnZXMiLCBudW1iZXJPZlBhZ2VzQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVh ZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAibWFy a2VyVGV4dEZvckxpc3RJdGVtIiwgbWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2ssIGtKU1By b3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUg fSwKICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMiLCBudW1iZXJPZkFjdGl2ZUFuaW1h dGlvbnNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBv dmVycmlkZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggM2M3MGY5OC4uNDY0OWRl OSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5oCkBAIC0yNDgsNiArMjQ4LDggQEAgcHVibGljOgogICAgIAogICAgIEpTUmV0YWluUHRy PEpTU3RyaW5nUmVmPiBsYXllclRyZWVBc1RleHQoKSBjb25zdDsKIAorICAgIEpTUmV0YWluUHRy PEpTU3RyaW5nUmVmPiBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNWYWx1ZVJlZiBub2RlT2JqZWN0 KSBjb25zdDsKKwogICAgIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhWaWV3V2lkdGg7CiAgICAg c3RhdGljIGNvbnN0IHVuc2lnbmVkIG1heFZpZXdIZWlnaHQ7CiAKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3Bw CmluZGV4IDdjMWI2ZTcuLmYyNDI5NDkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKKysrIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcApAQCAtNTgsNiAr NTgsNyBAQCBnY2hhciogd2Via2l0X3dlYl9mcmFtZV9jb3VudGVyX3ZhbHVlX2Zvcl9lbGVtZW50 X2J5X2lkKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgYwogaW50IHdlYmtpdF93ZWJfZnJhbWVfcGFn ZV9udW1iZXJfZm9yX2VsZW1lbnRfYnlfaWQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBn Y2hhciogaWQsIGZsb2F0IHBhZ2VXaWR0aCwgZmxvYXQgcGFnZUhlaWdodCk7CiBpbnQgd2Via2l0 X3dlYl9mcmFtZV9udW1iZXJfb2ZfcGFnZXMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBmbG9hdCBw YWdlV2lkdGgsIGZsb2F0IHBhZ2VIZWlnaHQpOwogdm9pZCB3ZWJraXRfd2ViX2luc3BlY3Rvcl9l eGVjdXRlX3NjcmlwdChXZWJLaXRXZWJJbnNwZWN0b3IqIGluc3BlY3RvciwgbG9uZyBjYWxsSWQs IGNvbnN0IGdjaGFyKiBzY3JpcHQpOworZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfbWFya2VyX3Rl eHRfZm9yX2xpc3RfaXRlbShXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEpTT2JqZWN0UmVmIG5vZGVP YmplY3QpOwogfQogCiBzdGF0aWMgZ2NoYXIqIGNvcHlXZWJTZXR0aW5nS2V5KGdjaGFyKiBwcmVm ZXJlbmNlS2V5KQpAQCAtNjQzLDMgKzY0NCwxMyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVy OjphcGlUZXN0R29Ub0N1cnJlbnRCYWNrRm9yd2FyZEl0ZW0oKQogewogCiB9CisKK0pTUmV0YWlu UHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJ dGVtKEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICBnY2hhciogbWFya2VyVGV4 dEdDaGFyID0gd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKG1haW5G cmFtZSwgbm9kZU9iamVjdCk7CisgICAgaWYgKCFtYXJrZXJUZXh0R0NoYXIpCisgICAgICAgIHJl dHVybiAwOworCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IG1hcmtlclRleHQoQWRvcHQs IEpTU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKG1hcmtlclRleHRHQ2hhcikpOworICAgIHJl dHVybiBtYXJrZXJUZXh0OworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IGYzMzI2MzAuLjJhMGI0 YjEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0 Q29udHJvbGxlck1hYy5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5 b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTE4Nyw2ICsxODcsMTIgQEAgSlNSZXRhaW5QdHI8 SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVyOjpsYXllclRyZWVBc1RleHQoKSBjb25z dAogICAgIHJldHVybiBzdHJpbmc7CiB9CiAKK0pTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlv dXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKEpTVmFsdWVSZWYgbm9kZU9i amVjdCkgY29uc3QKK3sKKyAgICAvLyBGSVhNRTogSW1wbGVtZW50IG1lLgorICAgIHJldHVybiBK U1JldGFpblB0cjxKU1N0cmluZ1JlZj4oKTsKK30KKwogaW50IExheW91dFRlc3RDb250cm9sbGVy OjpwYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoSlNTdHJpbmdSZWYgaWQsIGZsb2F0IHBhZ2VXaWR0 aEluUGl4ZWxzLCBmbG9hdCBwYWdlSGVpZ2h0SW5QaXhlbHMpCiB7CiAgICAgUmV0YWluUHRyPENG U3RyaW5nUmVmPiBpZENGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRv ckRlZmF1bHQsIGlkKSk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9x dC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCmluZGV4IGI2NDgwYzIuLjI0MzliOGYgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9s bGVyUXQuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RD b250cm9sbGVyUXQuY3BwCkBAIC01OSwxMSArNTksMTMgQEAgZXh0ZXJuIHZvaWQgcXRfZHJ0X3dl Ymluc3BlY3Rvcl9leGVjdXRlU2NyaXB0KFFXZWJQYWdlKiBwYWdlLCBsb25nIGNhbGxJZCwgY29u c3QKIGV4dGVybiB2b2lkIHF0X2RydF93ZWJpbnNwZWN0b3Jfc2hvdyhRV2ViUGFnZSAqcGFnZSk7 CiBleHRlcm4gdm9pZCBxdF9kcnRfd2ViaW5zcGVjdG9yX2Nsb3NlKFFXZWJQYWdlICpwYWdlKTsK IGV4dGVybiB2b2lkIHF0X2RydF9lbmFibGVDYXJldEJyb3dzaW5nKFFXZWJQYWdlKiBwYWdlLCBi b29sIHZhbHVlKTsKK2V4dGVybiBRU3RyaW5nIHF0X2RydF9tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0o Y29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKTsKIAogTGF5b3V0VGVzdENvbnRyb2xsZXI6Okxh eW91dFRlc3RDb250cm9sbGVyKFdlYkNvcmU6OkR1bXBSZW5kZXJUcmVlKiBkcnQpCiAgICAgOiBR T2JqZWN0KCkKICAgICAsIG1fZHJ0KGRydCkKIHsKKyAgICBxUmVnaXN0ZXJNZXRhVHlwZTxRV2Vi RWxlbWVudD4oIlFXZWJFbGVtZW50Iik7CiAgICAgcmVzZXQoKTsKIH0KIApAQCAtNTQxLDUgKzU0 MywxMCBAQCBib29sIExheW91dFRlc3RDb250cm9sbGVyOjpjYWxsU2hvdWxkQ2xvc2VPbldlYlZp ZXcoKQogICAgIHJldHVybiBmYWxzZTsKIH0KIAorUVN0cmluZyBMYXlvdXRUZXN0Q29udHJvbGxl cjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sK KyAgICByZXR1cm4gcXRfZHJ0X21hcmtlclRleHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9CisK IGNvbnN0IHVuc2lnbmVkIExheW91dFRlc3RDb250cm9sbGVyOjptYXhWaWV3V2lkdGggPSA4MDA7 CiBjb25zdCB1bnNpZ25lZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWF4Vmlld0hlaWdodCA9IDYw MDsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RD b250cm9sbGVyUXQuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RD b250cm9sbGVyUXQuaAppbmRleCAzNmI1ZjcwLi44NWU1ZmU1IDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmgKKysrIGIvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5oCkBAIC00 MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8UVZhcmlhbnQ+CiAKICNpbmNsdWRlIDxxd2ViZGF0YWJh c2UuaD4KKyNpbmNsdWRlIDxxd2ViZWxlbWVudC5oPgogI2luY2x1ZGUgPHF3ZWJmcmFtZS5oPgog I2luY2x1ZGUgPHF3ZWJoaXN0b3J5Lmg+CiAjaW5jbHVkZSA8cXdlYnBhZ2UuaD4KQEAgLTE2NSw2 ICsxNjYsOCBAQCBwdWJsaWMgc2xvdHM6CiAgICAgaW50IG51bWJlck9mUGFnZXMoZmxvYXQgd2lk dGggPSBtYXhWaWV3V2lkdGgsIGZsb2F0IGhlaWdodCA9IG1heFZpZXdIZWlnaHQpOwogICAgIGJv b2wgY2FsbFNob3VsZENsb3NlT25XZWJWaWV3KCk7CiAKKyAgICBRU3RyaW5nIG1hcmtlclRleHRG b3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pOworCiBwcml2YXRlIHNsb3Rz OgogICAgIHZvaWQgcHJvY2Vzc1dvcmsoKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKaW5kZXggYWQ3 NTdlNC4uYzU2ZmFmMCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2lu L0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCkBAIC0zOSw2ICszOSw3IEBACiAj aW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KICNpbmNsdWRlIDxKYXZhU2Ny aXB0Q29yZS9KU1N0cmluZ1JlZkJTVFIuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KYXZh U2NyaXB0Q29yZS5oPgorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTVmFsdWVSZWYuaD4KICNp bmNsdWRlIDxXZWJDb3JlL0NPTVB0ci5oPgogI2luY2x1ZGUgPFdlYktpdC9XZWJLaXQuaD4KICNp bmNsdWRlIDxXZWJLaXQvV2ViS2l0Q09NQVBJLmg+CkBAIC0xODgsNiArMTg5LDEyIEBAIEpTUmV0 YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bGF5ZXJUcmVlQXNUZXh0 KCkgY29uc3QKICAgICByZXR1cm4gdGV4dFZhbHVlSlM7CiB9CiAKK0pTUmV0YWluUHRyPEpTU3Ry aW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKEpTVmFs dWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICAvLyBGSVhNRTogSW1wbGVtZW50IG1lLgor ICAgIHJldHVybiBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4oKTsKK30KKwogdm9pZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6d2FpdEZvclBvbGljeURlbGVnYXRlKCkKIHsKICAgICAvLyBGSVhNRTog SW1wbGVtZW50IHRoaXMuCg== 52559 2010-04-05 12:55:03 -0700 2010-04-05 13:11:28 -0700 patch list-markers-dom-changes-v4.patch text/plain 41491 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlYjMyYTk4Li4wYTk0ZTkyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDQt MDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKwogMjAxMC0wNC0wMyAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJr aXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgZXhwZWN0ZWQgcmVzdWx0cyBmaXguCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvbGlzdHMvZHVtcC1saXN0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmFiNGEzYjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1 bXAtbGlzdC5qcwpAQCAtMCwwICsxLDMxIEBACitmdW5jdGlvbiBpbmRlbnQoZGVwdGgpCit7Cisg ICAgdmFyIHJldCA9IG5ldyBTdHJpbmcoKTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGRlcHRo OyArK2kpCisgICAgICAgIHJldCArPSAiLT4gIjsKKyAgICByZXR1cm4gcmV0ICsgIiAiOworfQor CitmdW5jdGlvbiBkdW1wTGlzdEhlbHBlcihlbGVtZW50LCBkZXB0aCkKK3sKKyAgICB2YXIgcmV0 ID0gbmV3IFN0cmluZygpOworCisgICAgdmFyIGNoaWxkID0gZWxlbWVudC5maXJzdENoaWxkOwor ICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoY2hpbGQubm9kZVR5cGUgPT0gTm9kZS5F TEVNRU5UX05PREUpIHsKKyAgICAgICAgICAgIHZhciBtYXJrZXIgPSBsYXlvdXRUZXN0Q29udHJv bGxlci5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY2hpbGQpOworICAgICAgICAgICAgaWYgKG1hcmtl cikKKyAgICAgICAgICAgICAgICByZXQgKz0gaW5kZW50KGRlcHRoKSArICcgJyArIG1hcmtlciAr ICcgJyArIGNoaWxkLmlubmVyVGV4dC50cmltKCkgKyAnPGJyIC8+JzsKKyAgICAgICAgICAgIHJl dCArPSBkdW1wTGlzdEhlbHBlcihjaGlsZCwgZGVwdGggKyAxKTsKKyAgICAgICAgfQorCisgICAg ICAgIGNoaWxkID0gY2hpbGQubmV4dFNpYmxpbmc7CisgICAgfQorCisgICAgcmV0dXJuIHJldDsK K30KKworZnVuY3Rpb24gZHVtcExpc3QobGlzdCkKK3sKKyAgICByZXR1cm4gZHVtcExpc3RIZWxw ZXIobGlzdCwgMCk7Cit9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjM5NjQ5NgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0LWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDE0IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1h cmtlcnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxk cmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuCisKKzEgT25lCisyIFR3bworLT4gMyBUaHJlZQorNCBG b3VyCis1IEZpdmUKKzYgU2l4CistPiA3IFNldmVuCistPiA4IEVpZ2h0CistPiA5IE5pbmUKKzEw IFRlbgorMTEgRWxldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wt bmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjZiM2Q5ODcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAgKzEs NTIgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibmVzdGVkIik7CisKKyAgICAgICAgICAgICAgICB2YXIgbGkxID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTEuaW5uZXJUZXh0ID0gIkVpZ2h0IjsK KworICAgICAgICAgICAgICAgIHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIp OworICAgICAgICAgICAgICAgIGxpMi5pbm5lclRleHQgPSAiU2V2ZW4iOworCisgICAgICAgICAg ICAgICAgdmFyIGl0ZW0zID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgICAg ICAgICAgICAgaXRlbTMuaW5uZXJUZXh0ID0gIk5pbmUiOworICAgICAgICAgICAgICAgIGl0ZW0z LnN0eWxlLmRpc3BsYXkgPSAibGlzdC1pdGVtIjsKKworICAgICAgICAgICAgICAgIHAuYXBwZW5k Q2hpbGQobGkxKTsKKyAgICAgICAgICAgICAgICBwLmluc2VydEJlZm9yZShsaTIsIGxpMSk7Cisg ICAgICAgICAgICAgICAgcC5hcHBlbmRDaGlsZChpdGVtMyk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVu IG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAg ICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg IDxkaXY+PGxpPlRocmVlPC9saT48L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAg ICAgICAgICAgIDxsaT5GaXZlPC9saT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAg ICAgICAgPHAgaWQ9Im5lc3RlZCI+PC9wPgorICAgICAgICAgICAgPGxpPlRlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RWxldmVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlk PSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJlNDUzMDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJz IGFyZSB1cGRhdGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRp cmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKzMgVGhy ZWUKKzQgRm91cgorNSBGaXZlCis2IFNpeAorNyBTZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYThkYjVjCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1v dmUuaHRtbApAQCAtMCwwICsxLDUxIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNj cmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAg IGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNl dFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKworICAgICAgICAgICAgICAgIHZhciBiID0gZG9j dW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoImIiKVswXTsKKyAgICAgICAgICAgICAgICBsaXN0 LnJlbW92ZUNoaWxkKGIpOworCisgICAgICAgICAgICAgICAgdmFyIGRpdiA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJuZXN0ZWQiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBkaXYu Y2hpbGRyZW4ubGVuZ3RoOworICAgICAgICAgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgaXRl bXM7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5maXJzdEVs ZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJpdGVtIikpOworCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAg ICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxl c3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0K KyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgp Ij4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRh dGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGls ZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8Yj48bGk+Rm9vPC9saT48L2I+CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xpPgorICAg ICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAgICAgPGxpPkZpdmU8L2xpPgorICAgICAg ICAgICAgPGRpdiBpZD0ibmVzdGVkIj4KKyAgICAgICAgICAgICAgICA8bGk+Rm9vPC9saT4KKyAg ICAgICAgICAgICAgICA8bGk+QmFyPC9saT4KKyAgICAgICAgICAgICAgICA8bGk+QmF6PC9saT4K KyAgICAgICAgICAgIDwvZGl2PgorICAgICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAgICAgICAg ICA8ZGl2IGlkPSJpdGVtIiBzdHlsZT0iZGlzcGxheTogbGlzdC1pdGVtIj5Gb288L2Rpdj4KKyAg ICAgICAgICAgIDxsaT5TZXZlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWl0ZW1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0 ZW1zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMzRi MzY2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0 IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJrZWQgd2hlbiBzb21lIG9mIHRoZSBpdGVtcyBhcmUgaW5k aXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxpc3QgZWxlbWVudC4KKworMSBPbmUKKzIgVHdvCiszIFRo cmVlCis0IEZvdXIKKy0+IDUgRml2ZQorLT4gNiBTaXgKKzEwIFRlbgorMTEgRWxldmVuCistPiAx MiBUd2VsdmUKKy0+IDEzIFRoaXJ0ZWVuCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi40NDY2MjAyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApAQCAtMCwwICsxLDQyIEBACis8aHRt bD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAg ICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAg eworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAg ICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsK KyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVy SFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0 aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisg ICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNw bGF5ID0gIm5vbmUiOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hl YWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRo YXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRlbXMg YXJlIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8 b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+ VHdvPC9saT4KKyAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+Rm91 cgorICAgICAgICAgICAgICAgIDxiPgorICAgICAgICAgICAgICAgICAgICA8bGk+Rml2ZTwvbGk+ CisgICAgICAgICAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgICAgIDwvYj4K KyAgICAgICAgICAgIDwvbGk+CisgICAgICAgICAgICA8bGkgdmFsdWU9IjEwIj5UZW48L2xpPgor ICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8ZGl2PgorICAgICAgICAg ICAgICAgIDxsaT5Ud2VsdmU8L2xpPgorICAgICAgICAgICAgICAgIDxsaT5UaGlydGVlbjwvbGk+ CisgICAgICAgICAgICA8L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RmlmdGVlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZmMDk4ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTMgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBk byBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LgorCisx IE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgorNSBGaXZlIE9uZSBUd2VudHkgZml2ZSBUd2Vu dHkgc2l4CistPiAtPiAxIE9uZQorLT4gLT4gMjUgVHdlbnR5IGZpdmUKKy0+IC0+IDI2IFR3ZW50 eSBzaXgKKzYgU2l4Cis3IFNldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4wNDhiZGNlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAg KzEsNDggQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1s aXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgp CisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBh IHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKworICAgICAgICAgICAgICAgIHZhciBsaTIg PSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMi5pbm5l clRleHQgPSAiVHdlbnR5IGZpdmUiOworICAgICAgICAgICAgICAgIGxpMi52YWx1ZSA9ICIyNSI7 CisgICAgICAgICAgICAgICAgdmFyIGxpMSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxpIik7 CisgICAgICAgICAgICAgICAgbGkxLmlubmVyVGV4dCA9ICJPbmUiOworICAgICAgICAgICAgICAg IHZhciBsaTMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAg IGxpMy5pbm5lclRleHQgPSAiVHdlbnR5IHNpeCI7CisKKyAgICAgICAgICAgICAgICBuZXN0ZWRM aXN0LmFwcGVuZENoaWxkKGxpMik7CisgICAgICAgICAgICAgICAgbmVzdGVkTGlzdC5pbnNlcnRC ZWZvcmUobGkxLCBsaTIpOworICAgICAgICAgICAgICAgIG5lc3RlZExpc3QuYXBwZW5kQ2hpbGQo bGkzKTsKKworICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xl IikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBEb24n dCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9ubHkg bW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpLnN0 eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0Pgor ICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMg dGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5l dyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAg ICAgPGxpPkZpdmUgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+PC9vbD48L2xpPgorICAgICAgICAgICAg PGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW48L2xpPgorICAgICAgICA8L29sPgor CisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4K XCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY2OTExYjMKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIHRoYXQgbGlz dCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1z IGZyb20gYSBuZXN0ZWQgbGlzdC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUg Rml2ZQorMSBPbmUKKzIgVHdvCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi42OTE0ZmI4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5odG1sCkBAIC0wLDAgKzEs NDUgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBu ZXN0ZWRMaXN0LmNoaWxkcmVuLmxlbmd0aDsKKyAgICAgICAgICAgICAgICBmb3IgKHZhciBpID0g MDsgaSA8IGl0ZW1zOyArK2kpCisgICAgICAgICAgICAgICAgICAgIG5lc3RlZExpc3QucmVtb3Zl Q2hpbGQobmVzdGVkTGlzdC5maXJzdEVsZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0 ZWQgbGlzdC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+CisgICAgICAgICAgICA8bGk+T25l PC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgPGxpPlRocmVlPC9s aT4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlCisgICAg ICAgICAgICAgICAgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+CisgICAgICAgICAgICAgICAgICAgIDxs aT5PbmU8L2xpPgorICAgICAgICAgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg ICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgICAgICA8L29sPgorICAgICAgICAg ICAgPC9saT4KKyAgICAgICAgICAgIDxsaSB2YWx1ZT0iMSI+T25lPC9saT4KKyAgICAgICAgICAg IDxsaT5Ud288L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxl CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRmZjUzZWIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJv cGVybHkgbWFya2VkIHdoZW4gdGhlIGxpc3QgY29udGFpbnMgbmVzdGVkIGxpc3RzLgorCisxMCBU ZW4KKzExIEVsZXZlbgorMTIgVHdlbHZlCisxMyBUaGlydGVlbiBPbmUgVHdvCistPiAtPiDil6Yg T25lCistPiAtPiDil6YgVHdvCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorLT4gMSBPbmUKKy0+ IDIgVHdvCisxNiBTaXh0ZWVuCisxNyBTZXZlbnRlZW4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjljOWVjZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0Lmh0bWwKQEAgLTAsMCArMSw0MiBAQAorPGh0bWw+CisgICAgPGhlYWQ+CisgICAg ICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+CisgICAgICAgIDxzY3JpcHQ+CisgICAg ICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAgICAgICAgICAgICB2YXIgbGlz dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iik7CisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0 KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0 IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9h ZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHBy b3Blcmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0IGNvbnRhaW5zIG5lc3RlZCBsaXN0cy48L3A+Cisg ICAgICAgIDxvbCBpZD0ibGlzdCIgc3RhcnQ9IjEwIj4KKyAgICAgICAgICAgIDxsaT5UZW48L2xp PgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8bGk+VHdlbHZlPC9s aT4KKyAgICAgICAgICAgIDxsaT5UaGlydGVlbgorICAgICAgICAgICAgICAgIDx1bD4KKyAgICAg ICAgICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5Ud288 L2xpPgorICAgICAgICAgICAgICAgIDwvdWw+CisgICAgICAgICAgICA8L2xpPgorICAgICAgICAg ICAgPGxpPkZvdXJ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxsaT5GaWZ0ZWVuPC9saT4KKyAgICAg ICAgICAgIDxvbD4KKyAgICAgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgICAg ICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDwvb2w+CisgICAgICAgICAgICA8bGk+U2l4dGVl bjwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW50ZWVuPC9saT4KKyAgICAgICAgPC9vbD4KKwor ICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+Clwg Tm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAppbmRleCBh NjFhZDIxLi45MDc4OGExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tp cHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZApAQCAtMTU2LDMgKzE1 NiwxMCBAQCBmYXN0L3JlcGxhY2VkL2JvcmRlci1yYWRpdXMtY2xpcC5odG1sCiAjIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjY0NgogZmFzdC93b3JrZXJzL3dvcmtl ci10ZXJtaW5hdGUuaHRtbAogCisjIE1pc3NpbmcgYW4gaW1wbGVtZW50YXRpb24gb2YgTGF5b3V0 VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSgpCitmYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVt cy1keW5hbWljLXJlbW92ZS5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sCitm YXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKK2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQt bGlzdC5odG1sCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZCBi L0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCmluZGV4IGU3YzRjZWYuLmY2OWE3OGEg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCkBAIC04MjIsMyArODIyLDExIEBAIGZhc3QvbWVk aWEvbWVkaWEtZmVhdHVyZS13Z3Qtdmlldy1tb2RlLmh0bWwKIAogIyBOZWVkIGV4cGVjdGF0aW9u cy4gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjQ2MQogZmFz dC9yZXBhaW50L292ZXJmbG93LXNjcm9sbC1ib2R5LWFwcGVhci5odG1sCisKKyMgTWlzc2luZyBh biBpbXBsZW1lbnRhdGlvbiBvZiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxp c3RJdGVtKCkKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwK K2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3ZlLmh0bWwKK2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWl0ZW1zLmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1p Yy1pbnNlcnQuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5o dG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwKZGlmZiAtLWdpdCBhL1dlYkNvcmUv Q2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzYwMzg2MC4uY2MzODZjYiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNCBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJr aXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBp biB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzcwNjAKKworICAgICAgICBJbiBwYXJ0aWN1bGFyLCB0aGV5IHdvdWxkIG5vdCBiZSB1cGRh dGVkIHdoZW4gYWRkaW5nL3JlbW92aW5nIGFuIGl0ZW0KKyAgICAgICAgdGhhdCBpcyBub3QgYSBk aXJlY3QgY2hpbGQgb2YgdGhlIGxpc3QgZWxlbWVudC4KKworICAgICAgICBUZXN0czogZmFzdC9s aXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQuaHRtbAorICAgICAgICAgICAgICAg ZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbAorICAgICAgICAg ICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbAorICAgICAgICAgICAgICAgZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCisgICAgICAgICAgICAg ICBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRtbAorCisgICAgICAgICogcmVuZGVy aW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVuY2xvc2luZ0xpc3Qp OiBDaGFuZ2UgdGhlIHNpZ25hdHVyZSB0byB0YWtlIGEgUmVuZGVyTGlzdEl0ZW0qLgorICAgICAg ICAoV2ViQ29yZTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMpOiBDaGFuZ2UgaXQgdG8gdHJhdmVy c2UgdGhlIHdob2xlIHN1YnRyZWUgb2YgYSBsaXN0LCBub3Qgb25seSBzaWJsaW5ncyBvZiBhbiBp dGVtLgorICAgICAgICAoV2ViQ29yZTo6cHJldmlvdXNMaXN0SXRlbSk6CisgICAgICAgICogcmVu ZGVyaW5nL1JlbmRlckxpc3RJdGVtLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVj dC5jcHA6IE1vdmUgdGhlIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzIGZ1bmN0aW9uIHRvIFJlbmRl ckxpc3RJdGVtLmNwcC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6YWRkQ2hpbGQp OiBNb3ZlIHRoZSBjb2RlIHVwZGF0aW5nIGxpc3QgbWFya2VycyB0byBSZW5kZXJPYmplY3RDaGls ZExpc3QgZm9yIGNvbnNpc3RlbmN5LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RD aGlsZExpc3QuY3BwOiBNb3ZlIHRoZSB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlvbiB0 byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3RDaGls ZExpc3Q6OnJlbW92ZUNoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5nIHJlbW92 ZWQsIG5vdCB0aGUgbmV4dCBzaWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Q2hpbGRMaXN0OjphcHBlbmRDaGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyBh ZGRlZCwgbm90IHRoZSBuZXh0IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmpl Y3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5n IGFkZGVkLCBub3QgdGhlIG5leHQgc2libGluZy4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVy VHJlZUFzVGV4dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0p OgorCiAyMDEwLTA0LTA0ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgog CiAgICAgICAgIE5vdCByZXZpZXdlZC4gUm9sbGluZyBvdXQgY2hyb21pdW0gY2hhbmdlcyByNTcw MjggYW5kIHI1NzAzMgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0 ZW0uY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCmluZGV4IDU0YTdk ZDIuLmYxMGM2ZTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVt LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKQEAgLTkyLDEz ICs5MiwxMyBAQCBzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChOb2RlKiBub2RlKQogICAgIHJl dHVybiBwYXJlbnQ7CiB9CiAKLXN0YXRpYyBOb2RlKiBlbmNsb3NpbmdMaXN0KGNvbnN0IFJlbmRl ck9iamVjdCogcmVuZGVyZXIpCitzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChjb25zdCBSZW5k ZXJMaXN0SXRlbSogbGlzdEl0ZW0pCiB7Ci0gICAgTm9kZSogbm9kZSA9IHJlbmRlcmVyLT5ub2Rl KCk7CisgICAgTm9kZSogbm9kZSA9IGxpc3RJdGVtLT5ub2RlKCk7CiAgICAgaWYgKG5vZGUpCiAg ICAgICAgIHJldHVybiBlbmNsb3NpbmdMaXN0KG5vZGUpOwogCi0gICAgcmVuZGVyZXIgPSByZW5k ZXJlci0+cGFyZW50KCk7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGxpc3RJ dGVtOwogICAgIHdoaWxlIChyZW5kZXJlciAmJiAhcmVuZGVyZXItPm5vZGUoKSkKICAgICAgICAg cmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50KCk7CiAKQEAgLTExNCwxMCArMTE0LDEyIEBAIHN0 YXRpYyBSZW5kZXJMaXN0SXRlbSogcHJldmlvdXNMaXN0SXRlbShOb2RlKiBsaXN0LCBjb25zdCBS ZW5kZXJMaXN0SXRlbSogaXRlbSkKICAgICBmb3IgKFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBp dGVtLT5wcmV2aW91c0luUHJlT3JkZXIoKTsgcmVuZGVyZXIgIT0gbGlzdC0+cmVuZGVyZXIoKTsg cmVuZGVyZXIgPSByZW5kZXJlci0+cHJldmlvdXNJblByZU9yZGVyKCkpIHsKICAgICAgICAgaWYg KCFyZW5kZXJlci0+aXNMaXN0SXRlbSgpKQogICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QocmVuZGVyZXIpOworCisgICAgICAgIFJl bmRlckxpc3RJdGVtKiBpdGVtID0gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlcik7CisgICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QoaXRlbSk7CiAgICAgICAgIC8vIFRoaXMg aXRlbSBpcyBwYXJ0IG9mIG91ciBjdXJyZW50IGxpc3QsIHNvIGl0J3Mgd2hhdCB3ZSdyZSBsb29r aW5nIGZvci4KICAgICAgICAgaWYgKGxpc3QgPT0gb3RoZXJMaXN0KQotICAgICAgICAgICAgcmV0 dXJuIHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpOworICAgICAgICAgICAgcmV0dXJuIGl0ZW07 CiAgICAgICAgIC8vIFdlIGZvdW5kIG91cnNlbGYgaW5zaWRlIGFub3RoZXIgbGlzdDsgbGV0cyBz a2lwIHRoZSByZXN0IG9mIGl0LgogICAgICAgICAvLyBVc2UgbmV4dEluUHJlT3JkZXIoKSBoZXJl IGJlY2F1c2UgdGhlIG90aGVyIGxpc3QgaXRzZWxmIG1heSBhY3R1YWxseQogICAgICAgICAvLyBi ZSBhIGxpc3QgaXRlbSBpdHNlbGYuIFdlIG5lZWQgdG8gZXhhbWluZSBpdCwgc28gd2UgZG8gdGhp cyB0byBjb3VudGVyYWN0CkBAIC0zNjQsNCArMzY2LDM4IEBAIHZvaWQgUmVuZGVyTGlzdEl0ZW06 OmNsZWFyRXhwbGljaXRWYWx1ZSgpCiAgICAgZXhwbGljaXRWYWx1ZUNoYW5nZWQoKTsKIH0KIAor dm9pZCBSZW5kZXJMaXN0SXRlbTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMoKQoreworICAgIE5v ZGUqIGxpc3ROb2RlID0gZW5jbG9zaW5nTGlzdCh0aGlzKTsKKyAgICBBU1NFUlQobGlzdE5vZGUg JiYgbGlzdE5vZGUtPnJlbmRlcmVyKCkpOworICAgIGlmICghbGlzdE5vZGUgfHwgIWxpc3ROb2Rl LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm47CisKKyAgICBSZW5kZXJPYmplY3QqIGxpc3Qg PSBsaXN0Tm9kZS0+cmVuZGVyZXIoKTsKKyAgICBSZW5kZXJPYmplY3QqIGNoaWxkID0gdGhpcy0+ bmV4dEluUHJlT3JkZXIobGlzdCk7CisgICAgd2hpbGUgKGNoaWxkKSB7CisgICAgICAgIGlmIChj aGlsZC0+bm9kZSgpICYmIGlzTGlzdChjaGlsZC0+bm9kZSgpKSkgeworICAgICAgICAgICAgLy8g V2UndmUgZm91bmQgYSBuZXN0ZWQsIGluZGVwZW5kZW50IGxpc3Q6IG5vdGhpbmcgdG8gZG8gaGVy ZS4KKyAgICAgICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHRJblByZU9yZGVyQWZ0ZXJDaGlsZHJl bihsaXN0KTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgaWYg KGNoaWxkLT5pc0xpc3RJdGVtKCkpIHsKKyAgICAgICAgICAgIFJlbmRlckxpc3RJdGVtKiBpdGVt ID0gdG9SZW5kZXJMaXN0SXRlbShjaGlsZCk7CisKKyAgICAgICAgICAgIGlmICghaXRlbS0+bV9p c1ZhbHVlVXBUb0RhdGUpIHsKKyAgICAgICAgICAgICAgICAvLyBJZiBhbiBpdGVtIGhhcyBiZWVu IG1hcmtlZCBmb3IgdXBkYXRlIGJlZm9yZSwgd2UgY2FuIHNhZmVseQorICAgICAgICAgICAgICAg IC8vIGFzc3VtZSB0aGF0IGFsbCB0aGUgZm9sbG93aW5nIG9uZXMgaGF2ZSB0b28uCisgICAgICAg ICAgICAgICAgLy8gVGhpcyBnaXZlcyB1cyB0aGUgb3Bwb3J0dW5pdHkgdG8gc3RvcCBoZXJlIGFu ZCBhdm9pZAorICAgICAgICAgICAgICAgIC8vIG1hcmtpbmcgdGhlIHNhbWUgbm9kZXMgYWdhaW4u CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGl0 ZW0tPnVwZGF0ZVZhbHVlKCk7CisgICAgICAgIH0KKworICAgICAgICBjaGlsZCA9IGNoaWxkLT5u ZXh0SW5QcmVPcmRlcihsaXN0KTsKKyAgICB9Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmggYi9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oCmluZGV4IGM0YzQxZGMuLjJhZDlhNDEgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmgKKysrIGIvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uaApAQCAtNDYsNiArNDYsOCBAQCBwdWJsaWM6CiAKICAg ICBjb25zdCBTdHJpbmcmIG1hcmtlclRleHQoKSBjb25zdDsKIAorICAgIHZvaWQgdXBkYXRlTGlz dE1hcmtlck51bWJlcnMoKTsKKwogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJl bmRlck5hbWUoKSBjb25zdCB7IHJldHVybiAiUmVuZGVyTGlzdEl0ZW0iOyB9CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCmluZGV4IDcwMDBiNzAuLjFmNWY0NDAgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyT2JqZWN0LmNwcApAQCAtMjU3LDE0ICsyNTcsNiBAQCBib29sIFJlbmRlck9iamVjdDo6 aXNIVE1MTWFycXVlZSgpIGNvbnN0CiAgICAgcmV0dXJuIG5vZGUoKSAmJiBub2RlKCktPnJlbmRl cmVyKCkgPT0gdGhpcyAmJiBub2RlKCktPmhhc1RhZ05hbWUobWFycXVlZVRhZyk7CiB9CiAKLXN0 YXRpYyB2b2lkIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVjdCogY2hpbGQpCi17 Ci0gICAgZm9yIChSZW5kZXJPYmplY3QqIHNpYmxpbmcgPSBjaGlsZDsgc2libGluZzsgc2libGlu ZyA9IHNpYmxpbmctPm5leHRTaWJsaW5nKCkpIHsKLSAgICAgICAgaWYgKHNpYmxpbmctPmlzTGlz dEl0ZW0oKSkKLSAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0oc2libGluZyktPnVwZGF0ZVZh bHVlKCk7Ci0gICAgfQotfQotCiB2b2lkIFJlbmRlck9iamVjdDo6YWRkQ2hpbGQoUmVuZGVyT2Jq ZWN0KiBuZXdDaGlsZCwgUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCkKIHsKICAgICBSZW5kZXJP YmplY3RDaGlsZExpc3QqIGNoaWxkcmVuID0gdmlydHVhbENoaWxkcmVuKCk7CkBAIC0yNzQsOSAr MjY2LDcgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OmFkZENoaWxkKFJlbmRlck9iamVjdCogbmV3Q2hp bGQsIFJlbmRlck9iamVjdCogYmVmb3JlQ2hpbGQpCiAKICAgICBib29sIG5lZWRzVGFibGUgPSBm YWxzZTsKIAotICAgIGlmIChuZXdDaGlsZC0+aXNMaXN0SXRlbSgpKQotICAgICAgICB1cGRhdGVM aXN0TWFya2VyTnVtYmVycyhiZWZvcmVDaGlsZCA/IGJlZm9yZUNoaWxkIDogY2hpbGRyZW4tPmxh c3RDaGlsZCgpKTsKLSAgICBlbHNlIGlmIChuZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0No aWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ09MVU1OX0dST1VQKQorICAgIGlmIChu ZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0g VEFCTEVfQ09MVU1OX0dST1VQKQogICAgICAgICBuZWVkc1RhYmxlID0gIWlzVGFibGUoKTsKICAg ICBlbHNlIGlmIChuZXdDaGlsZC0+aXNSZW5kZXJCbG9jaygpICYmIG5ld0NoaWxkLT5zdHlsZSgp LT5kaXNwbGF5KCkgPT0gVEFCTEVfQ0FQVElPTikKICAgICAgICAgbmVlZHNUYWJsZSA9ICFpc1Rh YmxlKCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExp c3QuY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAppbmRl eCA4ZWU4MTEyLi42ZDc2ZjM0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJP YmplY3RDaGlsZExpc3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdENo aWxkTGlzdC5jcHAKQEAgLTM5LDE0ICszOSw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAot c3RhdGljIHZvaWQgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoUmVuZGVyT2JqZWN0KiBjaGlsZCkK LXsKLSAgICBmb3IgKFJlbmRlck9iamVjdCogc2libGluZyA9IGNoaWxkOyBzaWJsaW5nOyBzaWJs aW5nID0gc2libGluZy0+bmV4dFNpYmxpbmcoKSkgewotICAgICAgICBpZiAoc2libGluZy0+aXNM aXN0SXRlbSgpKQotICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShzaWJsaW5nKS0+dXBkYXRl VmFsdWUoKTsKLSAgICB9Ci19Ci0KIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpkZXN0cm95 TGVmdG92ZXJDaGlsZHJlbigpCiB7CiAgICAgd2hpbGUgKGZpcnN0Q2hpbGQoKSkgewpAQCAtOTEs MTEgKzgzLDEwIEBAIFJlbmRlck9iamVjdCogUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpyZW1vdmVD aGlsZE5vZGUoUmVuZGVyT2JqZWN0KiBvd25lciwgUmVuZGVyCiAgICAgICAgICAgICAgICAgbGF5 ZXIgPSBvd25lci0+ZW5jbG9zaW5nTGF5ZXIoKTsKICAgICAgICAgICAgIG9sZENoaWxkLT5yZW1v dmVMYXllcnMobGF5ZXIpOwogICAgICAgICB9Ci0gICAgICAgIAotICAgICAgICAvLyByZW51bWJl ciBvcmRlcmVkIGxpc3RzCisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc0xpc3RJdGVtKCkpCi0g ICAgICAgICAgICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhvbGRDaGlsZC0+bmV4dFNpYmxpbmco KSk7Ci0gICAgICAgIAorICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShvbGRDaGlsZCktPnVw ZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc1Bvc2l0 aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5k aXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGlsZChvbGRDaGlsZCk7CiAgICAgfQpAQCAtMTYxLDcgKzE1 MiwxMCBAQCB2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6YXBwZW5kQ2hpbGROb2RlKFJlbmRl ck9iamVjdCogb3duZXIsIFJlbmRlck9iamVjdCogbgogICAgICAgICAgICAgaWYgKGxheWVyKQog ICAgICAgICAgICAgICAgIGxheWVyLT5zZXRIYXNWaXNpYmxlQ29udGVudCh0cnVlKTsKICAgICAg ICAgfQotICAgICAgICAKKworICAgICAgICBpZiAobmV3Q2hpbGQtPmlzTGlzdEl0ZW0oKSkKKyAg ICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0obmV3Q2hpbGQpLT51cGRhdGVMaXN0TWFya2VyTnVt YmVycygpOworCiAgICAgICAgIGlmICghbmV3Q2hpbGQtPmlzRmxvYXRpbmdPclBvc2l0aW9uZWQo KSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxp bmVzRnJvbUNoYW5nZWRDaGlsZChuZXdDaGlsZCk7CiAgICAgfQpAQCAtMjE4LDcgKzIxMiw5IEBA IHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjppbnNlcnRDaGlsZE5vZGUoUmVuZGVyT2JqZWN0 KiBvd25lciwgUmVuZGVyT2JqZWN0KiBjCiAgICAgICAgICAgICAgICAgbGF5ZXItPnNldEhhc1Zp c2libGVDb250ZW50KHRydWUpOwogICAgICAgICB9CiAKLSAgICAgICAgCisgICAgICAgIGlmIChj aGlsZC0+aXNMaXN0SXRlbSgpKQorICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShjaGlsZCkt PnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKCFjaGlsZC0+aXNGbG9h dGluZygpICYmIG93bmVyLT5jaGlsZHJlbklubGluZSgpKQogICAgICAgICAgICAgb3duZXItPmRp cnR5TGluZXNGcm9tQ2hhbmdlZENoaWxkKGNoaWxkKTsKICAgICB9CmRpZmYgLS1naXQgYS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlclRyZWVBc1RleHQuY3BwCmluZGV4IDg0ZjUyYzYuLjc1YzM1YmEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiUmVu ZGVyQlIuaCIKICNpbmNsdWRlICJSZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5oIgogI2luY2x1ZGUg IlJlbmRlcklubGluZS5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAi UmVuZGVyTGlzdE1hcmtlci5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJS ZW5kZXJUYWJsZUNlbGwuaCIKQEAgLTY2MCw0ICs2NjEsMTcgQEAgU3RyaW5nIGNvdW50ZXJWYWx1 ZUZvckVsZW1lbnQoRWxlbWVudCogZWxlbWVudCkKICAgICByZXR1cm4gc3RyZWFtLnJlbGVhc2Uo KTsKIH0KIAorU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShFbGVtZW50KiBlbGVtZW50KQor eworICAgIC8vIE1ha2Ugc3VyZSB0aGUgZWxlbWVudCBpcyBub3QgZnJlZWQgZHVyaW5nIHRoZSBs YXlvdXQuCisgICAgUmVmUHRyPEVsZW1lbnQ+IGVsZW1lbnRSZWYoZWxlbWVudCk7CisgICAgZWxl bWVudC0+ZG9jdW1lbnQoKS0+dXBkYXRlTGF5b3V0KCk7CisKKyAgICBSZW5kZXJPYmplY3QqIHJl bmRlcmVyID0gZWxlbWVudC0+cmVuZGVyZXIoKTsKKyAgICBpZiAoIXJlbmRlcmVyIHx8ICFyZW5k ZXJlci0+aXNMaXN0SXRlbSgpKQorICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisKKyAgICByZXR1 cm4gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlciktPm1hcmtlclRleHQoKTsKK30KKwogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJl ZUFzVGV4dC5oIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJlZUFzVGV4dC5oCmluZGV4IDFm Y2ZlYzEuLjRkYTBiYWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVB c1RleHQuaAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmgKQEAgLTUx LDYgKzUxLDggQEAgU3RyaW5nIHF1b3RlQW5kRXNjYXBlTm9uUHJpbnRhYmxlcyhjb25zdCBTdHJp bmcmKTsKIAogU3RyaW5nIGNvdW50ZXJWYWx1ZUZvckVsZW1lbnQoRWxlbWVudCopOwogCitTdHJp bmcgbWFya2VyVGV4dEZvckxpc3RJdGVtKEVsZW1lbnQqKTsKKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQogCiAjZW5kaWYgLy8gUmVuZGVyVHJlZUFzVGV4dF9oCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDE1ZWZmN2MuLjQwMDEx MWQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTAtMDQtMDUgIEpha3ViIFdpZWN6b3JlayAgPGp3 aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBhcmUgbm90IGFsd2F5cyB1cGRhdGVkIGFm dGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5o OgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHA6CisgICAgICAgICh3ZWJraXRf d2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0pOiBBZGQgYSBwcml2YXRlIEFQSSB0 byBnZXQgdGhlIG1hcmtlciB0ZXh0IGZvciBhIGxpc3QgaXRlbS4KKwogMjAxMC0wNC0wMSAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KIAog ICAgICAgICBSZXZpZXdlZCBieSBIb2xnZXIgRnJleXRoZXIuCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgKaW5kZXggZDAwMDBiMS4uN2RjYmQ2NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu aApAQCAtMzE1LDYgKzMxNSw5IEBAIGV4dGVybiAiQyIgewogICAgIFdFQktJVF9BUEkgYm9vbAog ICAgIHdlYmtpdF93ZWJfZnJhbWVfcGF1c2Vfc3ZnX2FuaW1hdGlvbihXZWJLaXRXZWJGcmFtZSog ZnJhbWUsIGNvbnN0IGdjaGFyKiBhbmltYXRpb25JZCwgZG91YmxlIHRpbWUsIGNvbnN0IGdjaGFy KiBlbGVtZW50SWQpOwogCisgICAgV0VCS0lUX0FQSSBnY2hhcioKKyAgICB3ZWJraXRfd2ViX2Zy YW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBKU1Zh bHVlUmVmIG5vZGVPYmplY3QpOworCiAgICAgV0VCS0lUX0FQSSB1bnNpZ25lZCBpbnQKICAgICB3 ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFt ZSogZnJhbWUpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggOTUzOGQy Ny4uYjgzOTNjZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUu Y3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNDcsOCAr NDcsMTAgQEAKICNpbmNsdWRlICJHdGtWZXJzaW9uaW5nLmgiCiAjaW5jbHVkZSAiSFRNTEZyYW1l T3duZXJFbGVtZW50LmgiCiAjaW5jbHVkZSAiSlNET01XaW5kb3cuaCIKKyNpbmNsdWRlICJKU0Vs ZW1lbnQuaCIKICNpbmNsdWRlICJKU0xvY2suaCIKICNpbmNsdWRlICJQcmludENvbnRleHQuaCIK KyNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNp bmNsdWRlICJSZW5kZXJUcmVlQXNUZXh0LmgiCiAjaW5jbHVkZSAiSlNET01CaW5kaW5nLmgiCkBA IC0xMDQzLDYgKzEwNDUsMTYgQEAgYm9vbCB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3N2Z19hbmlt YXRpb24oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogYW4KICNlbmRpZgogfQog CitnY2hhciogd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKFdlYktp dFdlYkZyYW1lKiBmcmFtZSwgSlNWYWx1ZVJlZiBub2RlT2JqZWN0KQoreworICAgIEVsZW1lbnQq IGVsZW1lbnQgPSB0b0VsZW1lbnQodG9KUygwLCBub2RlT2JqZWN0KSk7CisgICAgaWYgKCFlbGVt ZW50KQorICAgICAgICByZXR1cm4gMDsKKworICAgIFN0cmluZyBtYXJrZXJUZXh0ID0gbWFya2Vy VGV4dEZvckxpc3RJdGVtKGVsZW1lbnQpOworICAgIHJldHVybiBnX3N0cmR1cChtYXJrZXJUZXh0 LnV0ZjgoKS5kYXRhKCkpOworfQorCiB1bnNpZ25lZCBpbnQgd2Via2l0X3dlYl9mcmFtZV9udW1i ZXJfb2ZfYWN0aXZlX2FuaW1hdGlvbnMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKQogewogICAgIEZy YW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkv cXdlYmVsZW1lbnQuaCBiL1dlYktpdC9xdC9BcGkvcXdlYmVsZW1lbnQuaAppbmRleCBhODdkMzg4 Li5mMWJkZjRlIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50LmgKKysrIGIv V2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVudC5oCkBAIC0xNTUsNiArMTU1LDcgQEAgcHJpdmF0ZToK ICAgICBzdGF0aWMgUVdlYkVsZW1lbnQgZW5jbG9zaW5nRWxlbWVudChXZWJDb3JlOjpOb2RlKik7 CiAKICAgICBmcmllbmQgY2xhc3MgUVdlYkZyYW1lOworICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJh bWVQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViRWxlbWVudENvbGxlY3Rpb247CiAgICAg ZnJpZW5kIGNsYXNzIFFXZWJIaXRUZXN0UmVzdWx0OwogICAgIGZyaWVuZCBjbGFzcyBRV2ViSGl0 VGVzdFJlc3VsdFByaXZhdGU7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5j cHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggM2JiY2ZlMi4uMzBhZjQ3YiAx MDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9xdC9B cGkvcXdlYmZyYW1lLmNwcApAQCAtNDgsNiArNDgsNyBAQAogI2luY2x1ZGUgIlBsYXRmb3JtV2hl ZWxFdmVudC5oIgogI2luY2x1ZGUgIlByaW50Q29udGV4dC5oIgogI2luY2x1ZGUgIlB1dFByb3Bl cnR5U2xvdC5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVy VHJlZUFzVGV4dC5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJSZXNvdXJj ZVJlcXVlc3QuaCIKQEAgLTI3NSw2ICsyNzYsMTcgQEAgdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9k cnRfZXZhbHVhdGVTY3JpcHRJbklzb2xhdGVkV29ybGQoUVdlYkZyYW1lKiBxRnJhbWUsIGludAog ICAgICAgICBKU0M6OkpTVmFsdWUgcmVzdWx0ID0gZnJhbWUtPnNjcmlwdCgpLT5leGVjdXRlU2Ny aXB0SW5Xb3JsZChtYWluVGhyZWFkTm9ybWFsV29ybGQoKSwgc2NyaXB0LCB0cnVlKS5qc1ZhbHVl KCk7CiB9CiAKK1FTdHJpbmcgUVdlYkZyYW1lUHJpdmF0ZTo6bWFya2VyVGV4dEZvckxpc3RJdGVt KGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICBFbGVtZW50KiBlbGVtZW50ID0g bGlzdEl0ZW0ubV9lbGVtZW50OworICAgIHJldHVybiBXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlz dEl0ZW0oZWxlbWVudCk7Cit9CisKK1FTdHJpbmcgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X21hcmtl clRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pCit7CisgICAgcmV0 dXJuIFFXZWJGcmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9 CisKIHN0YXRpYyBib29sIHdlYmZyYW1lX3Njcm9sbE92ZXJmbG93KFdlYkNvcmU6OkZyYW1lKiBm cmFtZSwgaW50IGR4LCBpbnQgZHksIGNvbnN0IFFQb2ludCYgcG9zKQogewogICAgIGlmICghZnJh bWUgfHwgIWZyYW1lLT5kb2N1bWVudCgpIHx8ICFmcmFtZS0+ZXZlbnRIYW5kbGVyKCkpCmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJm cmFtZV9wLmgKaW5kZXggZmNjMzdlNy4uMjU1NmQzMCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0Fw aS9xd2ViZnJhbWVfcC5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaApAQCAtODgs NiArODgsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCByZW5kZXJGcm9tVGlsZWRCYWNraW5nU3RvcmUo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0KiwgY29uc3QgUVJlZ2lvbiYgY2xpcCk7CiAjZW5kaWYK IAorICAgIHN0YXRpYyBRU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxl bWVudCYgbGlzdEl0ZW0pOworCiAgICAgUVdlYkZyYW1lICpxOwogICAgIFF0OjpTY3JvbGxCYXJQ b2xpY3kgaG9yaXpvbnRhbFNjcm9sbEJhclBvbGljeTsKICAgICBRdDo6U2Nyb2xsQmFyUG9saWN5 IHZlcnRpY2FsU2Nyb2xsQmFyUG9saWN5OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxv ZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggN2YzYmQxNi4uZDVmMjA3ZSAxMDA2NDQKLS0t IGEvV2ViS2l0L3F0L0NoYW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTYgQEAKKzIwMTAtMDQtMDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0 Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBM aXN0IGl0ZW0gbWFya2VycyBhcmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4g dGhlIERPTS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM3MDYwCisKKyAgICAgICAgKiBBcGkvcXdlYmVsZW1lbnQuaDoKKyAgICAgICAgKiBBcGkvcXdl YmZyYW1lLmNwcDoKKyAgICAgICAgKFFXZWJGcmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0 SXRlbSk6CisgICAgICAgIChxdF9kcnRfbWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgcHJp dmF0ZSBBUEkgdG8gZ2V0IHRoZSBtYXJrZXIgdGV4dCBmb3IgYSBsaXN0IGl0ZW0uCisgICAgICAg ICogQXBpL3F3ZWJmcmFtZV9wLmg6CisKIDIwMTAtMDQtMDIgIExhc3psbyBHb21ib3MgIDxsYXN6 bG8uMS5nb21ib3NAbm9raWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9o ZGUgQ2hyaXN0aWFuc2VuLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2Vi S2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDM4ZWY0YWEuLmJiYjkxNjkgMTAwNjQ0Ci0tLSBhL1dl YktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyNSBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJraXQu b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExp c3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0 aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzcwNjAKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNw cDoKKyAgICAgICAgKG1hcmtlclRleHRGb3JMaXN0SXRlbUNhbGxiYWNrKTogQSBmdW5jdGlvbiB0 aGF0IHJldHVybnMgdGhlIG1hcmtlciB0ZXh0IGZvciBhIGdpdmVuIGxpc3QgaXRlbS4KKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAqIER1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAgICogRHVtcFJlbmRl clRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoKKyAgICAgICAgKExheW91dFRl c3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhl IEdUSyBwb3J0LgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJv bGxlck1hYy5tbToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9y TGlzdEl0ZW0pOiBBZGQgYSBzdHViLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L0xheW91 dFRlc3RDb250cm9sbGVyUXQuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Okxh eW91dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJr ZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhlIFF0IHBvcnQuCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5oOgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHA6CisgICAgICAg IChMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgc3R1 Yi4KKwogMjAxMC0wNC0wNSAgQ2hyaXMgSmVyZG9uZWsgIDxjamVyZG9uZWtAd2Via2l0Lm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBTaGluaWNoaXJvIEhhbWFqaS4KZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCAyNTU0 ZmE0Li40NzY4NmM0IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBAIC0xMzMxLDYgKzEzMzEsMTMgQEAgc3RhdGljIEpTVmFs dWVSZWYgYXBpVGVzdEdvVG9DdXJyZW50QmFja0ZvcndhcmRJdGVtQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQKICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9 CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG1hcmtlclRleHRGb3JMaXN0SXRlbUNhbGxiYWNrKEpTQ29u dGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6 ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVS ZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBpZiAoYXJndW1lbnRDb3VudCA8IDEpCisgICAgICAgIHJl dHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKKyAgICByZXR1cm4gSlNWYWx1ZU1h a2VTdHJpbmcoY29udGV4dCwgY29udHJvbGxlci0+bWFya2VyVGV4dEZvckxpc3RJdGVtKGFyZ3Vt ZW50c1swXSkuZ2V0KCkpOworfQorCiAvLyBTdGF0aWMgVmFsdWVzCiAKIHN0YXRpYyBKU1ZhbHVl UmVmIGdldEdsb2JhbEZsYWdDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RS ZWYgdGhpc09iamVjdCwgSlNTdHJpbmdSZWYgcHJvcGVydHlOYW1lLCBKU1ZhbHVlUmVmKiBleGNl cHRpb24pCkBAIC0xNDQ0LDYgKzE0NTEsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0 Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAia2VlcFdlYkhpc3Rvcnki LCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgImxheWVyVHJlZUFz VGV4dCIsIGxheWVyVHJlZUFzVGV4dENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRP bmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm51bWJl ck9mUGFnZXMiLCBudW1iZXJPZlBhZ2VzQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVh ZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAibWFy a2VyVGV4dEZvckxpc3RJdGVtIiwgbWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2ssIGtKU1By b3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUg fSwKICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMiLCBudW1iZXJPZkFjdGl2ZUFuaW1h dGlvbnNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBv dmVycmlkZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggM2M3MGY5OC4uNDY0OWRl OSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5oCkBAIC0yNDgsNiArMjQ4LDggQEAgcHVibGljOgogICAgIAogICAgIEpTUmV0YWluUHRy PEpTU3RyaW5nUmVmPiBsYXllclRyZWVBc1RleHQoKSBjb25zdDsKIAorICAgIEpTUmV0YWluUHRy PEpTU3RyaW5nUmVmPiBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNWYWx1ZVJlZiBub2RlT2JqZWN0 KSBjb25zdDsKKwogICAgIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhWaWV3V2lkdGg7CiAgICAg c3RhdGljIGNvbnN0IHVuc2lnbmVkIG1heFZpZXdIZWlnaHQ7CiAKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3Bw CmluZGV4IDdjMWI2ZTcuLjI0OTQ1YzUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKKysrIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcApAQCAtNTgsNiAr NTgsNyBAQCBnY2hhciogd2Via2l0X3dlYl9mcmFtZV9jb3VudGVyX3ZhbHVlX2Zvcl9lbGVtZW50 X2J5X2lkKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgYwogaW50IHdlYmtpdF93ZWJfZnJhbWVfcGFn ZV9udW1iZXJfZm9yX2VsZW1lbnRfYnlfaWQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBn Y2hhciogaWQsIGZsb2F0IHBhZ2VXaWR0aCwgZmxvYXQgcGFnZUhlaWdodCk7CiBpbnQgd2Via2l0 X3dlYl9mcmFtZV9udW1iZXJfb2ZfcGFnZXMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBmbG9hdCBw YWdlV2lkdGgsIGZsb2F0IHBhZ2VIZWlnaHQpOwogdm9pZCB3ZWJraXRfd2ViX2luc3BlY3Rvcl9l eGVjdXRlX3NjcmlwdChXZWJLaXRXZWJJbnNwZWN0b3IqIGluc3BlY3RvciwgbG9uZyBjYWxsSWQs IGNvbnN0IGdjaGFyKiBzY3JpcHQpOworZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfbWFya2VyX3Rl eHRfZm9yX2xpc3RfaXRlbShXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEpTT2JqZWN0UmVmIG5vZGVP YmplY3QpOwogfQogCiBzdGF0aWMgZ2NoYXIqIGNvcHlXZWJTZXR0aW5nS2V5KGdjaGFyKiBwcmVm ZXJlbmNlS2V5KQpAQCAtNjQzLDMgKzY0NCwxNCBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVy OjphcGlUZXN0R29Ub0N1cnJlbnRCYWNrRm9yd2FyZEl0ZW0oKQogewogCiB9CisKK0pTUmV0YWlu UHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJ dGVtKEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICBnY2hhciogbWFya2VyVGV4 dEdDaGFyID0gd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKG1haW5G cmFtZSwgbm9kZU9iamVjdCk7CisgICAgaWYgKCFtYXJrZXJUZXh0R0NoYXIpCisgICAgICAgIHJl dHVybiAwOworCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IG1hcmtlclRleHQoQWRvcHQs IEpTU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKG1hcmtlclRleHRHQ2hhcikpOworICAgIGdf ZnJlZShtYXJrZXJUZXh0R0NoYXIpOworICAgIHJldHVybiBtYXJrZXJUZXh0OworfQpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVy TWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9s bGVyTWFjLm1tCmluZGV4IGYzMzI2MzAuLjJhMGI0YjEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQorKysgYi9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAg LTE4Nyw2ICsxODcsMTIgQEAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250 cm9sbGVyOjpsYXllclRyZWVBc1RleHQoKSBjb25zdAogICAgIHJldHVybiBzdHJpbmc7CiB9CiAK K0pTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4 dEZvckxpc3RJdGVtKEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICAvLyBGSVhN RTogSW1wbGVtZW50IG1lLgorICAgIHJldHVybiBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4oKTsK K30KKwogaW50IExheW91dFRlc3RDb250cm9sbGVyOjpwYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQo SlNTdHJpbmdSZWYgaWQsIGZsb2F0IHBhZ2VXaWR0aEluUGl4ZWxzLCBmbG9hdCBwYWdlSGVpZ2h0 SW5QaXhlbHMpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBpZENGKEFkb3B0Q0YsIEpT U3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGlkKSk7CmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNw cCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQu Y3BwCmluZGV4IGI2NDgwYzIuLjI0MzliOGYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCisrKyBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCkBAIC01OSwxMSAr NTksMTMgQEAgZXh0ZXJuIHZvaWQgcXRfZHJ0X3dlYmluc3BlY3Rvcl9leGVjdXRlU2NyaXB0KFFX ZWJQYWdlKiBwYWdlLCBsb25nIGNhbGxJZCwgY29uc3QKIGV4dGVybiB2b2lkIHF0X2RydF93ZWJp bnNwZWN0b3Jfc2hvdyhRV2ViUGFnZSAqcGFnZSk7CiBleHRlcm4gdm9pZCBxdF9kcnRfd2ViaW5z cGVjdG9yX2Nsb3NlKFFXZWJQYWdlICpwYWdlKTsKIGV4dGVybiB2b2lkIHF0X2RydF9lbmFibGVD YXJldEJyb3dzaW5nKFFXZWJQYWdlKiBwYWdlLCBib29sIHZhbHVlKTsKK2V4dGVybiBRU3RyaW5n IHF0X2RydF9tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVt KTsKIAogTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKFdlYkNvcmU6 OkR1bXBSZW5kZXJUcmVlKiBkcnQpCiAgICAgOiBRT2JqZWN0KCkKICAgICAsIG1fZHJ0KGRydCkK IHsKKyAgICBxUmVnaXN0ZXJNZXRhVHlwZTxRV2ViRWxlbWVudD4oIlFXZWJFbGVtZW50Iik7CiAg ICAgcmVzZXQoKTsKIH0KIApAQCAtNTQxLDUgKzU0MywxMCBAQCBib29sIExheW91dFRlc3RDb250 cm9sbGVyOjpjYWxsU2hvdWxkQ2xvc2VPbldlYlZpZXcoKQogICAgIHJldHVybiBmYWxzZTsKIH0K IAorUVN0cmluZyBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKGNv bnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICByZXR1cm4gcXRfZHJ0X21hcmtlclRl eHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9CisKIGNvbnN0IHVuc2lnbmVkIExheW91dFRlc3RD b250cm9sbGVyOjptYXhWaWV3V2lkdGggPSA4MDA7CiBjb25zdCB1bnNpZ25lZCBMYXlvdXRUZXN0 Q29udHJvbGxlcjo6bWF4Vmlld0hlaWdodCA9IDYwMDsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaCBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaAppbmRleCAzNmI1Zjcw Li44NWU1ZmU1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlv dXRUZXN0Q29udHJvbGxlclF0LmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQv TGF5b3V0VGVzdENvbnRyb2xsZXJRdC5oCkBAIC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8UVZh cmlhbnQ+CiAKICNpbmNsdWRlIDxxd2ViZGF0YWJhc2UuaD4KKyNpbmNsdWRlIDxxd2ViZWxlbWVu dC5oPgogI2luY2x1ZGUgPHF3ZWJmcmFtZS5oPgogI2luY2x1ZGUgPHF3ZWJoaXN0b3J5Lmg+CiAj aW5jbHVkZSA8cXdlYnBhZ2UuaD4KQEAgLTE2NSw2ICsxNjYsOCBAQCBwdWJsaWMgc2xvdHM6CiAg ICAgaW50IG51bWJlck9mUGFnZXMoZmxvYXQgd2lkdGggPSBtYXhWaWV3V2lkdGgsIGZsb2F0IGhl aWdodCA9IG1heFZpZXdIZWlnaHQpOwogICAgIGJvb2wgY2FsbFNob3VsZENsb3NlT25XZWJWaWV3 KCk7CiAKKyAgICBRU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVu dCYgbGlzdEl0ZW0pOworCiBwcml2YXRlIHNsb3RzOgogICAgIHZvaWQgcHJvY2Vzc1dvcmsoKTsK IApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RD b250cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRU ZXN0Q29udHJvbGxlcldpbi5jcHAKaW5kZXggYWQ3NTdlNC4uNWVmOGNjYyAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNw cAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xs ZXJXaW4uY3BwCkBAIC0xODgsNiArMTg4LDEyIEBAIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBM YXlvdXRUZXN0Q29udHJvbGxlcjo6bGF5ZXJUcmVlQXNUZXh0KCkgY29uc3QKICAgICByZXR1cm4g dGV4dFZhbHVlSlM7CiB9CiAKK0pTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29u c3QKK3sKKyAgICAvLyBGSVhNRTogSW1wbGVtZW50IG1lLgorICAgIHJldHVybiBKU1JldGFpblB0 cjxKU1N0cmluZ1JlZj4oKTsKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2FpdEZv clBvbGljeURlbGVnYXRlKCkKIHsKICAgICAvLyBGSVhNRTogSW1wbGVtZW50IHRoaXMuCg== 52561 2010-04-05 13:11:28 -0700 2010-04-05 14:18:29 -0700 patch list-markers-dom-changes-v5.patch text/plain 41599 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlYjMyYTk4Li4wYTk0ZTkyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDQt MDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKwogMjAxMC0wNC0wMyAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJr aXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgZXhwZWN0ZWQgcmVzdWx0cyBmaXguCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvbGlzdHMvZHVtcC1saXN0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmFiNGEzYjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1 bXAtbGlzdC5qcwpAQCAtMCwwICsxLDMxIEBACitmdW5jdGlvbiBpbmRlbnQoZGVwdGgpCit7Cisg ICAgdmFyIHJldCA9IG5ldyBTdHJpbmcoKTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGRlcHRo OyArK2kpCisgICAgICAgIHJldCArPSAiLT4gIjsKKyAgICByZXR1cm4gcmV0ICsgIiAiOworfQor CitmdW5jdGlvbiBkdW1wTGlzdEhlbHBlcihlbGVtZW50LCBkZXB0aCkKK3sKKyAgICB2YXIgcmV0 ID0gbmV3IFN0cmluZygpOworCisgICAgdmFyIGNoaWxkID0gZWxlbWVudC5maXJzdENoaWxkOwor ICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoY2hpbGQubm9kZVR5cGUgPT0gTm9kZS5F TEVNRU5UX05PREUpIHsKKyAgICAgICAgICAgIHZhciBtYXJrZXIgPSBsYXlvdXRUZXN0Q29udHJv bGxlci5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY2hpbGQpOworICAgICAgICAgICAgaWYgKG1hcmtl cikKKyAgICAgICAgICAgICAgICByZXQgKz0gaW5kZW50KGRlcHRoKSArICcgJyArIG1hcmtlciAr ICcgJyArIGNoaWxkLmlubmVyVGV4dC50cmltKCkgKyAnPGJyIC8+JzsKKyAgICAgICAgICAgIHJl dCArPSBkdW1wTGlzdEhlbHBlcihjaGlsZCwgZGVwdGggKyAxKTsKKyAgICAgICAgfQorCisgICAg ICAgIGNoaWxkID0gY2hpbGQubmV4dFNpYmxpbmc7CisgICAgfQorCisgICAgcmV0dXJuIHJldDsK K30KKworZnVuY3Rpb24gZHVtcExpc3QobGlzdCkKK3sKKyAgICByZXR1cm4gZHVtcExpc3RIZWxw ZXIobGlzdCwgMCk7Cit9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjM5NjQ5NgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0LWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDE0IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1h cmtlcnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxk cmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuCisKKzEgT25lCisyIFR3bworLT4gMyBUaHJlZQorNCBG b3VyCis1IEZpdmUKKzYgU2l4CistPiA3IFNldmVuCistPiA4IEVpZ2h0CistPiA5IE5pbmUKKzEw IFRlbgorMTEgRWxldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wt bmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjZiM2Q5ODcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAgKzEs NTIgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibmVzdGVkIik7CisKKyAgICAgICAgICAgICAgICB2YXIgbGkxID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTEuaW5uZXJUZXh0ID0gIkVpZ2h0IjsK KworICAgICAgICAgICAgICAgIHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIp OworICAgICAgICAgICAgICAgIGxpMi5pbm5lclRleHQgPSAiU2V2ZW4iOworCisgICAgICAgICAg ICAgICAgdmFyIGl0ZW0zID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgICAg ICAgICAgICAgaXRlbTMuaW5uZXJUZXh0ID0gIk5pbmUiOworICAgICAgICAgICAgICAgIGl0ZW0z LnN0eWxlLmRpc3BsYXkgPSAibGlzdC1pdGVtIjsKKworICAgICAgICAgICAgICAgIHAuYXBwZW5k Q2hpbGQobGkxKTsKKyAgICAgICAgICAgICAgICBwLmluc2VydEJlZm9yZShsaTIsIGxpMSk7Cisg ICAgICAgICAgICAgICAgcC5hcHBlbmRDaGlsZChpdGVtMyk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVu IG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAg ICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg IDxkaXY+PGxpPlRocmVlPC9saT48L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAg ICAgICAgICAgIDxsaT5GaXZlPC9saT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAg ICAgICAgPHAgaWQ9Im5lc3RlZCI+PC9wPgorICAgICAgICAgICAgPGxpPlRlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RWxldmVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlk PSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJlNDUzMDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJz IGFyZSB1cGRhdGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRp cmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKzMgVGhy ZWUKKzQgRm91cgorNSBGaXZlCis2IFNpeAorNyBTZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYThkYjVjCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1v dmUuaHRtbApAQCAtMCwwICsxLDUxIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNj cmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAg IGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNl dFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKworICAgICAgICAgICAgICAgIHZhciBiID0gZG9j dW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoImIiKVswXTsKKyAgICAgICAgICAgICAgICBsaXN0 LnJlbW92ZUNoaWxkKGIpOworCisgICAgICAgICAgICAgICAgdmFyIGRpdiA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJuZXN0ZWQiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBkaXYu Y2hpbGRyZW4ubGVuZ3RoOworICAgICAgICAgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgaXRl bXM7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5maXJzdEVs ZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJpdGVtIikpOworCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAg ICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxl c3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0K KyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgp Ij4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRh dGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGls ZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8Yj48bGk+Rm9vPC9saT48L2I+CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xpPgorICAg ICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAgICAgPGxpPkZpdmU8L2xpPgorICAgICAg ICAgICAgPGRpdiBpZD0ibmVzdGVkIj4KKyAgICAgICAgICAgICAgICA8bGk+Rm9vPC9saT4KKyAg ICAgICAgICAgICAgICA8bGk+QmFyPC9saT4KKyAgICAgICAgICAgICAgICA8bGk+QmF6PC9saT4K KyAgICAgICAgICAgIDwvZGl2PgorICAgICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAgICAgICAg ICA8ZGl2IGlkPSJpdGVtIiBzdHlsZT0iZGlzcGxheTogbGlzdC1pdGVtIj5Gb288L2Rpdj4KKyAg ICAgICAgICAgIDxsaT5TZXZlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWl0ZW1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0 ZW1zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMzRi MzY2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0 IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJrZWQgd2hlbiBzb21lIG9mIHRoZSBpdGVtcyBhcmUgaW5k aXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxpc3QgZWxlbWVudC4KKworMSBPbmUKKzIgVHdvCiszIFRo cmVlCis0IEZvdXIKKy0+IDUgRml2ZQorLT4gNiBTaXgKKzEwIFRlbgorMTEgRWxldmVuCistPiAx MiBUd2VsdmUKKy0+IDEzIFRoaXJ0ZWVuCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi40NDY2MjAyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApAQCAtMCwwICsxLDQyIEBACis8aHRt bD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAg ICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAg eworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAg ICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsK KyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVy SFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0 aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisg ICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNw bGF5ID0gIm5vbmUiOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hl YWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRo YXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRlbXMg YXJlIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8 b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+ VHdvPC9saT4KKyAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+Rm91 cgorICAgICAgICAgICAgICAgIDxiPgorICAgICAgICAgICAgICAgICAgICA8bGk+Rml2ZTwvbGk+ CisgICAgICAgICAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgICAgIDwvYj4K KyAgICAgICAgICAgIDwvbGk+CisgICAgICAgICAgICA8bGkgdmFsdWU9IjEwIj5UZW48L2xpPgor ICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8ZGl2PgorICAgICAgICAg ICAgICAgIDxsaT5Ud2VsdmU8L2xpPgorICAgICAgICAgICAgICAgIDxsaT5UaGlydGVlbjwvbGk+ CisgICAgICAgICAgICA8L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RmlmdGVlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZmMDk4ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTMgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBk byBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LgorCisx IE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgorNSBGaXZlIE9uZSBUd2VudHkgZml2ZSBUd2Vu dHkgc2l4CistPiAtPiAxIE9uZQorLT4gLT4gMjUgVHdlbnR5IGZpdmUKKy0+IC0+IDI2IFR3ZW50 eSBzaXgKKzYgU2l4Cis3IFNldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4wNDhiZGNlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAg KzEsNDggQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1s aXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgp CisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBh IHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKworICAgICAgICAgICAgICAgIHZhciBsaTIg PSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMi5pbm5l clRleHQgPSAiVHdlbnR5IGZpdmUiOworICAgICAgICAgICAgICAgIGxpMi52YWx1ZSA9ICIyNSI7 CisgICAgICAgICAgICAgICAgdmFyIGxpMSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxpIik7 CisgICAgICAgICAgICAgICAgbGkxLmlubmVyVGV4dCA9ICJPbmUiOworICAgICAgICAgICAgICAg IHZhciBsaTMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAg IGxpMy5pbm5lclRleHQgPSAiVHdlbnR5IHNpeCI7CisKKyAgICAgICAgICAgICAgICBuZXN0ZWRM aXN0LmFwcGVuZENoaWxkKGxpMik7CisgICAgICAgICAgICAgICAgbmVzdGVkTGlzdC5pbnNlcnRC ZWZvcmUobGkxLCBsaTIpOworICAgICAgICAgICAgICAgIG5lc3RlZExpc3QuYXBwZW5kQ2hpbGQo bGkzKTsKKworICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xl IikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBEb24n dCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9ubHkg bW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpLnN0 eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0Pgor ICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMg dGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5l dyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAg ICAgPGxpPkZpdmUgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+PC9vbD48L2xpPgorICAgICAgICAgICAg PGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW48L2xpPgorICAgICAgICA8L29sPgor CisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4K XCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY2OTExYjMKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIHRoYXQgbGlz dCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1z IGZyb20gYSBuZXN0ZWQgbGlzdC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUg Rml2ZQorMSBPbmUKKzIgVHdvCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi42OTE0ZmI4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5odG1sCkBAIC0wLDAgKzEs NDUgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBu ZXN0ZWRMaXN0LmNoaWxkcmVuLmxlbmd0aDsKKyAgICAgICAgICAgICAgICBmb3IgKHZhciBpID0g MDsgaSA8IGl0ZW1zOyArK2kpCisgICAgICAgICAgICAgICAgICAgIG5lc3RlZExpc3QucmVtb3Zl Q2hpbGQobmVzdGVkTGlzdC5maXJzdEVsZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0 ZWQgbGlzdC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+CisgICAgICAgICAgICA8bGk+T25l PC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgPGxpPlRocmVlPC9s aT4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlCisgICAg ICAgICAgICAgICAgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+CisgICAgICAgICAgICAgICAgICAgIDxs aT5PbmU8L2xpPgorICAgICAgICAgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg ICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgICAgICA8L29sPgorICAgICAgICAg ICAgPC9saT4KKyAgICAgICAgICAgIDxsaSB2YWx1ZT0iMSI+T25lPC9saT4KKyAgICAgICAgICAg IDxsaT5Ud288L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxl CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRmZjUzZWIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJv cGVybHkgbWFya2VkIHdoZW4gdGhlIGxpc3QgY29udGFpbnMgbmVzdGVkIGxpc3RzLgorCisxMCBU ZW4KKzExIEVsZXZlbgorMTIgVHdlbHZlCisxMyBUaGlydGVlbiBPbmUgVHdvCistPiAtPiDil6Yg T25lCistPiAtPiDil6YgVHdvCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorLT4gMSBPbmUKKy0+ IDIgVHdvCisxNiBTaXh0ZWVuCisxNyBTZXZlbnRlZW4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjljOWVjZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0Lmh0bWwKQEAgLTAsMCArMSw0MiBAQAorPGh0bWw+CisgICAgPGhlYWQ+CisgICAg ICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+CisgICAgICAgIDxzY3JpcHQ+CisgICAg ICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAgICAgICAgICAgICB2YXIgbGlz dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iik7CisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0 KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0 IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9h ZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHBy b3Blcmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0IGNvbnRhaW5zIG5lc3RlZCBsaXN0cy48L3A+Cisg ICAgICAgIDxvbCBpZD0ibGlzdCIgc3RhcnQ9IjEwIj4KKyAgICAgICAgICAgIDxsaT5UZW48L2xp PgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8bGk+VHdlbHZlPC9s aT4KKyAgICAgICAgICAgIDxsaT5UaGlydGVlbgorICAgICAgICAgICAgICAgIDx1bD4KKyAgICAg ICAgICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5Ud288 L2xpPgorICAgICAgICAgICAgICAgIDwvdWw+CisgICAgICAgICAgICA8L2xpPgorICAgICAgICAg ICAgPGxpPkZvdXJ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxsaT5GaWZ0ZWVuPC9saT4KKyAgICAg ICAgICAgIDxvbD4KKyAgICAgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgICAg ICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDwvb2w+CisgICAgICAgICAgICA8bGk+U2l4dGVl bjwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW50ZWVuPC9saT4KKyAgICAgICAgPC9vbD4KKwor ICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+Clwg Tm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAppbmRleCBh NjFhZDIxLi45MDc4OGExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tp cHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZApAQCAtMTU2LDMgKzE1 NiwxMCBAQCBmYXN0L3JlcGxhY2VkL2JvcmRlci1yYWRpdXMtY2xpcC5odG1sCiAjIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjY0NgogZmFzdC93b3JrZXJzL3dvcmtl ci10ZXJtaW5hdGUuaHRtbAogCisjIE1pc3NpbmcgYW4gaW1wbGVtZW50YXRpb24gb2YgTGF5b3V0 VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSgpCitmYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVt cy1keW5hbWljLXJlbW92ZS5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sCitm YXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKK2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQt bGlzdC5odG1sCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZCBi L0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCmluZGV4IGU3YzRjZWYuLmY2OWE3OGEg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCkBAIC04MjIsMyArODIyLDExIEBAIGZhc3QvbWVk aWEvbWVkaWEtZmVhdHVyZS13Z3Qtdmlldy1tb2RlLmh0bWwKIAogIyBOZWVkIGV4cGVjdGF0aW9u cy4gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjQ2MQogZmFz dC9yZXBhaW50L292ZXJmbG93LXNjcm9sbC1ib2R5LWFwcGVhci5odG1sCisKKyMgTWlzc2luZyBh biBpbXBsZW1lbnRhdGlvbiBvZiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxp c3RJdGVtKCkKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwK K2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3ZlLmh0bWwKK2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWl0ZW1zLmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1p Yy1pbnNlcnQuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5o dG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwKZGlmZiAtLWdpdCBhL1dlYkNvcmUv Q2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzYwMzg2MC4uY2MzODZjYiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNCBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJr aXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBp biB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzcwNjAKKworICAgICAgICBJbiBwYXJ0aWN1bGFyLCB0aGV5IHdvdWxkIG5vdCBiZSB1cGRh dGVkIHdoZW4gYWRkaW5nL3JlbW92aW5nIGFuIGl0ZW0KKyAgICAgICAgdGhhdCBpcyBub3QgYSBk aXJlY3QgY2hpbGQgb2YgdGhlIGxpc3QgZWxlbWVudC4KKworICAgICAgICBUZXN0czogZmFzdC9s aXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQuaHRtbAorICAgICAgICAgICAgICAg ZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbAorICAgICAgICAg ICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbAorICAgICAgICAgICAgICAgZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCisgICAgICAgICAgICAg ICBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRtbAorCisgICAgICAgICogcmVuZGVy aW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVuY2xvc2luZ0xpc3Qp OiBDaGFuZ2UgdGhlIHNpZ25hdHVyZSB0byB0YWtlIGEgUmVuZGVyTGlzdEl0ZW0qLgorICAgICAg ICAoV2ViQ29yZTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMpOiBDaGFuZ2UgaXQgdG8gdHJhdmVy c2UgdGhlIHdob2xlIHN1YnRyZWUgb2YgYSBsaXN0LCBub3Qgb25seSBzaWJsaW5ncyBvZiBhbiBp dGVtLgorICAgICAgICAoV2ViQ29yZTo6cHJldmlvdXNMaXN0SXRlbSk6CisgICAgICAgICogcmVu ZGVyaW5nL1JlbmRlckxpc3RJdGVtLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVj dC5jcHA6IE1vdmUgdGhlIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzIGZ1bmN0aW9uIHRvIFJlbmRl ckxpc3RJdGVtLmNwcC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6YWRkQ2hpbGQp OiBNb3ZlIHRoZSBjb2RlIHVwZGF0aW5nIGxpc3QgbWFya2VycyB0byBSZW5kZXJPYmplY3RDaGls ZExpc3QgZm9yIGNvbnNpc3RlbmN5LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RD aGlsZExpc3QuY3BwOiBNb3ZlIHRoZSB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlvbiB0 byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3RDaGls ZExpc3Q6OnJlbW92ZUNoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5nIHJlbW92 ZWQsIG5vdCB0aGUgbmV4dCBzaWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Q2hpbGRMaXN0OjphcHBlbmRDaGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyBh ZGRlZCwgbm90IHRoZSBuZXh0IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmpl Y3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5n IGFkZGVkLCBub3QgdGhlIG5leHQgc2libGluZy4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVy VHJlZUFzVGV4dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0p OgorCiAyMDEwLTA0LTA0ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgog CiAgICAgICAgIE5vdCByZXZpZXdlZC4gUm9sbGluZyBvdXQgY2hyb21pdW0gY2hhbmdlcyByNTcw MjggYW5kIHI1NzAzMgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0 ZW0uY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCmluZGV4IDU0YTdk ZDIuLmYxMGM2ZTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVt LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKQEAgLTkyLDEz ICs5MiwxMyBAQCBzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChOb2RlKiBub2RlKQogICAgIHJl dHVybiBwYXJlbnQ7CiB9CiAKLXN0YXRpYyBOb2RlKiBlbmNsb3NpbmdMaXN0KGNvbnN0IFJlbmRl ck9iamVjdCogcmVuZGVyZXIpCitzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChjb25zdCBSZW5k ZXJMaXN0SXRlbSogbGlzdEl0ZW0pCiB7Ci0gICAgTm9kZSogbm9kZSA9IHJlbmRlcmVyLT5ub2Rl KCk7CisgICAgTm9kZSogbm9kZSA9IGxpc3RJdGVtLT5ub2RlKCk7CiAgICAgaWYgKG5vZGUpCiAg ICAgICAgIHJldHVybiBlbmNsb3NpbmdMaXN0KG5vZGUpOwogCi0gICAgcmVuZGVyZXIgPSByZW5k ZXJlci0+cGFyZW50KCk7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGxpc3RJ dGVtOwogICAgIHdoaWxlIChyZW5kZXJlciAmJiAhcmVuZGVyZXItPm5vZGUoKSkKICAgICAgICAg cmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50KCk7CiAKQEAgLTExNCwxMCArMTE0LDEyIEBAIHN0 YXRpYyBSZW5kZXJMaXN0SXRlbSogcHJldmlvdXNMaXN0SXRlbShOb2RlKiBsaXN0LCBjb25zdCBS ZW5kZXJMaXN0SXRlbSogaXRlbSkKICAgICBmb3IgKFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBp dGVtLT5wcmV2aW91c0luUHJlT3JkZXIoKTsgcmVuZGVyZXIgIT0gbGlzdC0+cmVuZGVyZXIoKTsg cmVuZGVyZXIgPSByZW5kZXJlci0+cHJldmlvdXNJblByZU9yZGVyKCkpIHsKICAgICAgICAgaWYg KCFyZW5kZXJlci0+aXNMaXN0SXRlbSgpKQogICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QocmVuZGVyZXIpOworCisgICAgICAgIFJl bmRlckxpc3RJdGVtKiBpdGVtID0gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlcik7CisgICAgICAg IE5vZGUqIG90aGVyTGlzdCA9IGVuY2xvc2luZ0xpc3QoaXRlbSk7CiAgICAgICAgIC8vIFRoaXMg aXRlbSBpcyBwYXJ0IG9mIG91ciBjdXJyZW50IGxpc3QsIHNvIGl0J3Mgd2hhdCB3ZSdyZSBsb29r aW5nIGZvci4KICAgICAgICAgaWYgKGxpc3QgPT0gb3RoZXJMaXN0KQotICAgICAgICAgICAgcmV0 dXJuIHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpOworICAgICAgICAgICAgcmV0dXJuIGl0ZW07 CiAgICAgICAgIC8vIFdlIGZvdW5kIG91cnNlbGYgaW5zaWRlIGFub3RoZXIgbGlzdDsgbGV0cyBz a2lwIHRoZSByZXN0IG9mIGl0LgogICAgICAgICAvLyBVc2UgbmV4dEluUHJlT3JkZXIoKSBoZXJl IGJlY2F1c2UgdGhlIG90aGVyIGxpc3QgaXRzZWxmIG1heSBhY3R1YWxseQogICAgICAgICAvLyBi ZSBhIGxpc3QgaXRlbSBpdHNlbGYuIFdlIG5lZWQgdG8gZXhhbWluZSBpdCwgc28gd2UgZG8gdGhp cyB0byBjb3VudGVyYWN0CkBAIC0zNjQsNCArMzY2LDM4IEBAIHZvaWQgUmVuZGVyTGlzdEl0ZW06 OmNsZWFyRXhwbGljaXRWYWx1ZSgpCiAgICAgZXhwbGljaXRWYWx1ZUNoYW5nZWQoKTsKIH0KIAor dm9pZCBSZW5kZXJMaXN0SXRlbTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMoKQoreworICAgIE5v ZGUqIGxpc3ROb2RlID0gZW5jbG9zaW5nTGlzdCh0aGlzKTsKKyAgICBBU1NFUlQobGlzdE5vZGUg JiYgbGlzdE5vZGUtPnJlbmRlcmVyKCkpOworICAgIGlmICghbGlzdE5vZGUgfHwgIWxpc3ROb2Rl LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm47CisKKyAgICBSZW5kZXJPYmplY3QqIGxpc3Qg PSBsaXN0Tm9kZS0+cmVuZGVyZXIoKTsKKyAgICBSZW5kZXJPYmplY3QqIGNoaWxkID0gdGhpcy0+ bmV4dEluUHJlT3JkZXIobGlzdCk7CisgICAgd2hpbGUgKGNoaWxkKSB7CisgICAgICAgIGlmIChj aGlsZC0+bm9kZSgpICYmIGlzTGlzdChjaGlsZC0+bm9kZSgpKSkgeworICAgICAgICAgICAgLy8g V2UndmUgZm91bmQgYSBuZXN0ZWQsIGluZGVwZW5kZW50IGxpc3Q6IG5vdGhpbmcgdG8gZG8gaGVy ZS4KKyAgICAgICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHRJblByZU9yZGVyQWZ0ZXJDaGlsZHJl bihsaXN0KTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgaWYg KGNoaWxkLT5pc0xpc3RJdGVtKCkpIHsKKyAgICAgICAgICAgIFJlbmRlckxpc3RJdGVtKiBpdGVt ID0gdG9SZW5kZXJMaXN0SXRlbShjaGlsZCk7CisKKyAgICAgICAgICAgIGlmICghaXRlbS0+bV9p c1ZhbHVlVXBUb0RhdGUpIHsKKyAgICAgICAgICAgICAgICAvLyBJZiBhbiBpdGVtIGhhcyBiZWVu IG1hcmtlZCBmb3IgdXBkYXRlIGJlZm9yZSwgd2UgY2FuIHNhZmVseQorICAgICAgICAgICAgICAg IC8vIGFzc3VtZSB0aGF0IGFsbCB0aGUgZm9sbG93aW5nIG9uZXMgaGF2ZSB0b28uCisgICAgICAg ICAgICAgICAgLy8gVGhpcyBnaXZlcyB1cyB0aGUgb3Bwb3J0dW5pdHkgdG8gc3RvcCBoZXJlIGFu ZCBhdm9pZAorICAgICAgICAgICAgICAgIC8vIG1hcmtpbmcgdGhlIHNhbWUgbm9kZXMgYWdhaW4u CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGl0 ZW0tPnVwZGF0ZVZhbHVlKCk7CisgICAgICAgIH0KKworICAgICAgICBjaGlsZCA9IGNoaWxkLT5u ZXh0SW5QcmVPcmRlcihsaXN0KTsKKyAgICB9Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmggYi9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oCmluZGV4IGM0YzQxZGMuLjJhZDlhNDEgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmgKKysrIGIvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uaApAQCAtNDYsNiArNDYsOCBAQCBwdWJsaWM6CiAKICAg ICBjb25zdCBTdHJpbmcmIG1hcmtlclRleHQoKSBjb25zdDsKIAorICAgIHZvaWQgdXBkYXRlTGlz dE1hcmtlck51bWJlcnMoKTsKKwogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJl bmRlck5hbWUoKSBjb25zdCB7IHJldHVybiAiUmVuZGVyTGlzdEl0ZW0iOyB9CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCmluZGV4IDcwMDBiNzAuLjFmNWY0NDAgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyT2JqZWN0LmNwcApAQCAtMjU3LDE0ICsyNTcsNiBAQCBib29sIFJlbmRlck9iamVjdDo6 aXNIVE1MTWFycXVlZSgpIGNvbnN0CiAgICAgcmV0dXJuIG5vZGUoKSAmJiBub2RlKCktPnJlbmRl cmVyKCkgPT0gdGhpcyAmJiBub2RlKCktPmhhc1RhZ05hbWUobWFycXVlZVRhZyk7CiB9CiAKLXN0 YXRpYyB2b2lkIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVjdCogY2hpbGQpCi17 Ci0gICAgZm9yIChSZW5kZXJPYmplY3QqIHNpYmxpbmcgPSBjaGlsZDsgc2libGluZzsgc2libGlu ZyA9IHNpYmxpbmctPm5leHRTaWJsaW5nKCkpIHsKLSAgICAgICAgaWYgKHNpYmxpbmctPmlzTGlz dEl0ZW0oKSkKLSAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0oc2libGluZyktPnVwZGF0ZVZh bHVlKCk7Ci0gICAgfQotfQotCiB2b2lkIFJlbmRlck9iamVjdDo6YWRkQ2hpbGQoUmVuZGVyT2Jq ZWN0KiBuZXdDaGlsZCwgUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCkKIHsKICAgICBSZW5kZXJP YmplY3RDaGlsZExpc3QqIGNoaWxkcmVuID0gdmlydHVhbENoaWxkcmVuKCk7CkBAIC0yNzQsOSAr MjY2LDcgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OmFkZENoaWxkKFJlbmRlck9iamVjdCogbmV3Q2hp bGQsIFJlbmRlck9iamVjdCogYmVmb3JlQ2hpbGQpCiAKICAgICBib29sIG5lZWRzVGFibGUgPSBm YWxzZTsKIAotICAgIGlmIChuZXdDaGlsZC0+aXNMaXN0SXRlbSgpKQotICAgICAgICB1cGRhdGVM aXN0TWFya2VyTnVtYmVycyhiZWZvcmVDaGlsZCA/IGJlZm9yZUNoaWxkIDogY2hpbGRyZW4tPmxh c3RDaGlsZCgpKTsKLSAgICBlbHNlIGlmIChuZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0No aWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ09MVU1OX0dST1VQKQorICAgIGlmIChu ZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0g VEFCTEVfQ09MVU1OX0dST1VQKQogICAgICAgICBuZWVkc1RhYmxlID0gIWlzVGFibGUoKTsKICAg ICBlbHNlIGlmIChuZXdDaGlsZC0+aXNSZW5kZXJCbG9jaygpICYmIG5ld0NoaWxkLT5zdHlsZSgp LT5kaXNwbGF5KCkgPT0gVEFCTEVfQ0FQVElPTikKICAgICAgICAgbmVlZHNUYWJsZSA9ICFpc1Rh YmxlKCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExp c3QuY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAppbmRl eCA4ZWU4MTEyLi42ZDc2ZjM0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJP YmplY3RDaGlsZExpc3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdENo aWxkTGlzdC5jcHAKQEAgLTM5LDE0ICszOSw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAot c3RhdGljIHZvaWQgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoUmVuZGVyT2JqZWN0KiBjaGlsZCkK LXsKLSAgICBmb3IgKFJlbmRlck9iamVjdCogc2libGluZyA9IGNoaWxkOyBzaWJsaW5nOyBzaWJs aW5nID0gc2libGluZy0+bmV4dFNpYmxpbmcoKSkgewotICAgICAgICBpZiAoc2libGluZy0+aXNM aXN0SXRlbSgpKQotICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShzaWJsaW5nKS0+dXBkYXRl VmFsdWUoKTsKLSAgICB9Ci19Ci0KIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpkZXN0cm95 TGVmdG92ZXJDaGlsZHJlbigpCiB7CiAgICAgd2hpbGUgKGZpcnN0Q2hpbGQoKSkgewpAQCAtOTEs MTEgKzgzLDEwIEBAIFJlbmRlck9iamVjdCogUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpyZW1vdmVD aGlsZE5vZGUoUmVuZGVyT2JqZWN0KiBvd25lciwgUmVuZGVyCiAgICAgICAgICAgICAgICAgbGF5 ZXIgPSBvd25lci0+ZW5jbG9zaW5nTGF5ZXIoKTsKICAgICAgICAgICAgIG9sZENoaWxkLT5yZW1v dmVMYXllcnMobGF5ZXIpOwogICAgICAgICB9Ci0gICAgICAgIAotICAgICAgICAvLyByZW51bWJl ciBvcmRlcmVkIGxpc3RzCisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc0xpc3RJdGVtKCkpCi0g ICAgICAgICAgICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhvbGRDaGlsZC0+bmV4dFNpYmxpbmco KSk7Ci0gICAgICAgIAorICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShvbGRDaGlsZCktPnVw ZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc1Bvc2l0 aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5k aXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGlsZChvbGRDaGlsZCk7CiAgICAgfQpAQCAtMTYxLDcgKzE1 MiwxMCBAQCB2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6YXBwZW5kQ2hpbGROb2RlKFJlbmRl ck9iamVjdCogb3duZXIsIFJlbmRlck9iamVjdCogbgogICAgICAgICAgICAgaWYgKGxheWVyKQog ICAgICAgICAgICAgICAgIGxheWVyLT5zZXRIYXNWaXNpYmxlQ29udGVudCh0cnVlKTsKICAgICAg ICAgfQotICAgICAgICAKKworICAgICAgICBpZiAobmV3Q2hpbGQtPmlzTGlzdEl0ZW0oKSkKKyAg ICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0obmV3Q2hpbGQpLT51cGRhdGVMaXN0TWFya2VyTnVt YmVycygpOworCiAgICAgICAgIGlmICghbmV3Q2hpbGQtPmlzRmxvYXRpbmdPclBvc2l0aW9uZWQo KSAmJiBvd25lci0+Y2hpbGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxp bmVzRnJvbUNoYW5nZWRDaGlsZChuZXdDaGlsZCk7CiAgICAgfQpAQCAtMjE4LDcgKzIxMiw5IEBA IHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjppbnNlcnRDaGlsZE5vZGUoUmVuZGVyT2JqZWN0 KiBvd25lciwgUmVuZGVyT2JqZWN0KiBjCiAgICAgICAgICAgICAgICAgbGF5ZXItPnNldEhhc1Zp c2libGVDb250ZW50KHRydWUpOwogICAgICAgICB9CiAKLSAgICAgICAgCisgICAgICAgIGlmIChj aGlsZC0+aXNMaXN0SXRlbSgpKQorICAgICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShjaGlsZCkt PnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisKICAgICAgICAgaWYgKCFjaGlsZC0+aXNGbG9h dGluZygpICYmIG93bmVyLT5jaGlsZHJlbklubGluZSgpKQogICAgICAgICAgICAgb3duZXItPmRp cnR5TGluZXNGcm9tQ2hhbmdlZENoaWxkKGNoaWxkKTsKICAgICB9CmRpZmYgLS1naXQgYS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlclRyZWVBc1RleHQuY3BwCmluZGV4IDg0ZjUyYzYuLjc1YzM1YmEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiUmVu ZGVyQlIuaCIKICNpbmNsdWRlICJSZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5oIgogI2luY2x1ZGUg IlJlbmRlcklubGluZS5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAi UmVuZGVyTGlzdE1hcmtlci5oIgogI2luY2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJS ZW5kZXJUYWJsZUNlbGwuaCIKQEAgLTY2MCw0ICs2NjEsMTcgQEAgU3RyaW5nIGNvdW50ZXJWYWx1 ZUZvckVsZW1lbnQoRWxlbWVudCogZWxlbWVudCkKICAgICByZXR1cm4gc3RyZWFtLnJlbGVhc2Uo KTsKIH0KIAorU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShFbGVtZW50KiBlbGVtZW50KQor eworICAgIC8vIE1ha2Ugc3VyZSB0aGUgZWxlbWVudCBpcyBub3QgZnJlZWQgZHVyaW5nIHRoZSBs YXlvdXQuCisgICAgUmVmUHRyPEVsZW1lbnQ+IGVsZW1lbnRSZWYoZWxlbWVudCk7CisgICAgZWxl bWVudC0+ZG9jdW1lbnQoKS0+dXBkYXRlTGF5b3V0KCk7CisKKyAgICBSZW5kZXJPYmplY3QqIHJl bmRlcmVyID0gZWxlbWVudC0+cmVuZGVyZXIoKTsKKyAgICBpZiAoIXJlbmRlcmVyIHx8ICFyZW5k ZXJlci0+aXNMaXN0SXRlbSgpKQorICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisKKyAgICByZXR1 cm4gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlciktPm1hcmtlclRleHQoKTsKK30KKwogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJl ZUFzVGV4dC5oIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJlZUFzVGV4dC5oCmluZGV4IDFm Y2ZlYzEuLjRkYTBiYWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVB c1RleHQuaAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmgKQEAgLTUx LDYgKzUxLDggQEAgU3RyaW5nIHF1b3RlQW5kRXNjYXBlTm9uUHJpbnRhYmxlcyhjb25zdCBTdHJp bmcmKTsKIAogU3RyaW5nIGNvdW50ZXJWYWx1ZUZvckVsZW1lbnQoRWxlbWVudCopOwogCitTdHJp bmcgbWFya2VyVGV4dEZvckxpc3RJdGVtKEVsZW1lbnQqKTsKKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQogCiAjZW5kaWYgLy8gUmVuZGVyVHJlZUFzVGV4dF9oCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDE1ZWZmN2MuLjQwMDEx MWQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTAtMDQtMDUgIEpha3ViIFdpZWN6b3JlayAgPGp3 aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBhcmUgbm90IGFsd2F5cyB1cGRhdGVkIGFm dGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5o OgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHA6CisgICAgICAgICh3ZWJraXRf d2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0pOiBBZGQgYSBwcml2YXRlIEFQSSB0 byBnZXQgdGhlIG1hcmtlciB0ZXh0IGZvciBhIGxpc3QgaXRlbS4KKwogMjAxMC0wNC0wMSAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KIAog ICAgICAgICBSZXZpZXdlZCBieSBIb2xnZXIgRnJleXRoZXIuCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgKaW5kZXggZDAwMDBiMS4uN2RjYmQ2NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu aApAQCAtMzE1LDYgKzMxNSw5IEBAIGV4dGVybiAiQyIgewogICAgIFdFQktJVF9BUEkgYm9vbAog ICAgIHdlYmtpdF93ZWJfZnJhbWVfcGF1c2Vfc3ZnX2FuaW1hdGlvbihXZWJLaXRXZWJGcmFtZSog ZnJhbWUsIGNvbnN0IGdjaGFyKiBhbmltYXRpb25JZCwgZG91YmxlIHRpbWUsIGNvbnN0IGdjaGFy KiBlbGVtZW50SWQpOwogCisgICAgV0VCS0lUX0FQSSBnY2hhcioKKyAgICB3ZWJraXRfd2ViX2Zy YW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBKU1Zh bHVlUmVmIG5vZGVPYmplY3QpOworCiAgICAgV0VCS0lUX0FQSSB1bnNpZ25lZCBpbnQKICAgICB3 ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFt ZSogZnJhbWUpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggOTUzOGQy Ny4uYjgzOTNjZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUu Y3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNDcsOCAr NDcsMTAgQEAKICNpbmNsdWRlICJHdGtWZXJzaW9uaW5nLmgiCiAjaW5jbHVkZSAiSFRNTEZyYW1l T3duZXJFbGVtZW50LmgiCiAjaW5jbHVkZSAiSlNET01XaW5kb3cuaCIKKyNpbmNsdWRlICJKU0Vs ZW1lbnQuaCIKICNpbmNsdWRlICJKU0xvY2suaCIKICNpbmNsdWRlICJQcmludENvbnRleHQuaCIK KyNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNp bmNsdWRlICJSZW5kZXJUcmVlQXNUZXh0LmgiCiAjaW5jbHVkZSAiSlNET01CaW5kaW5nLmgiCkBA IC0xMDQzLDYgKzEwNDUsMTYgQEAgYm9vbCB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3N2Z19hbmlt YXRpb24oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogYW4KICNlbmRpZgogfQog CitnY2hhciogd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKFdlYktp dFdlYkZyYW1lKiBmcmFtZSwgSlNWYWx1ZVJlZiBub2RlT2JqZWN0KQoreworICAgIEVsZW1lbnQq IGVsZW1lbnQgPSB0b0VsZW1lbnQodG9KUygwLCBub2RlT2JqZWN0KSk7CisgICAgaWYgKCFlbGVt ZW50KQorICAgICAgICByZXR1cm4gMDsKKworICAgIFN0cmluZyBtYXJrZXJUZXh0ID0gbWFya2Vy VGV4dEZvckxpc3RJdGVtKGVsZW1lbnQpOworICAgIHJldHVybiBnX3N0cmR1cChtYXJrZXJUZXh0 LnV0ZjgoKS5kYXRhKCkpOworfQorCiB1bnNpZ25lZCBpbnQgd2Via2l0X3dlYl9mcmFtZV9udW1i ZXJfb2ZfYWN0aXZlX2FuaW1hdGlvbnMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKQogewogICAgIEZy YW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkv cXdlYmVsZW1lbnQuaCBiL1dlYktpdC9xdC9BcGkvcXdlYmVsZW1lbnQuaAppbmRleCBhODdkMzg4 Li5mMWJkZjRlIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50LmgKKysrIGIv V2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVudC5oCkBAIC0xNTUsNiArMTU1LDcgQEAgcHJpdmF0ZToK ICAgICBzdGF0aWMgUVdlYkVsZW1lbnQgZW5jbG9zaW5nRWxlbWVudChXZWJDb3JlOjpOb2RlKik7 CiAKICAgICBmcmllbmQgY2xhc3MgUVdlYkZyYW1lOworICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJh bWVQcml2YXRlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViRWxlbWVudENvbGxlY3Rpb247CiAgICAg ZnJpZW5kIGNsYXNzIFFXZWJIaXRUZXN0UmVzdWx0OwogICAgIGZyaWVuZCBjbGFzcyBRV2ViSGl0 VGVzdFJlc3VsdFByaXZhdGU7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5j cHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggM2JiY2ZlMi4uMzBhZjQ3YiAx MDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9xdC9B cGkvcXdlYmZyYW1lLmNwcApAQCAtNDgsNiArNDgsNyBAQAogI2luY2x1ZGUgIlBsYXRmb3JtV2hl ZWxFdmVudC5oIgogI2luY2x1ZGUgIlByaW50Q29udGV4dC5oIgogI2luY2x1ZGUgIlB1dFByb3Bl cnR5U2xvdC5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVy VHJlZUFzVGV4dC5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJSZXNvdXJj ZVJlcXVlc3QuaCIKQEAgLTI3NSw2ICsyNzYsMTcgQEAgdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9k cnRfZXZhbHVhdGVTY3JpcHRJbklzb2xhdGVkV29ybGQoUVdlYkZyYW1lKiBxRnJhbWUsIGludAog ICAgICAgICBKU0M6OkpTVmFsdWUgcmVzdWx0ID0gZnJhbWUtPnNjcmlwdCgpLT5leGVjdXRlU2Ny aXB0SW5Xb3JsZChtYWluVGhyZWFkTm9ybWFsV29ybGQoKSwgc2NyaXB0LCB0cnVlKS5qc1ZhbHVl KCk7CiB9CiAKK1FTdHJpbmcgUVdlYkZyYW1lUHJpdmF0ZTo6bWFya2VyVGV4dEZvckxpc3RJdGVt KGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICBFbGVtZW50KiBlbGVtZW50ID0g bGlzdEl0ZW0ubV9lbGVtZW50OworICAgIHJldHVybiBXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlz dEl0ZW0oZWxlbWVudCk7Cit9CisKK1FTdHJpbmcgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X21hcmtl clRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pCit7CisgICAgcmV0 dXJuIFFXZWJGcmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9 CisKIHN0YXRpYyBib29sIHdlYmZyYW1lX3Njcm9sbE92ZXJmbG93KFdlYkNvcmU6OkZyYW1lKiBm cmFtZSwgaW50IGR4LCBpbnQgZHksIGNvbnN0IFFQb2ludCYgcG9zKQogewogICAgIGlmICghZnJh bWUgfHwgIWZyYW1lLT5kb2N1bWVudCgpIHx8ICFmcmFtZS0+ZXZlbnRIYW5kbGVyKCkpCmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJm cmFtZV9wLmgKaW5kZXggZmNjMzdlNy4uMjU1NmQzMCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0Fw aS9xd2ViZnJhbWVfcC5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaApAQCAtODgs NiArODgsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCByZW5kZXJGcm9tVGlsZWRCYWNraW5nU3RvcmUo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0KiwgY29uc3QgUVJlZ2lvbiYgY2xpcCk7CiAjZW5kaWYK IAorICAgIHN0YXRpYyBRU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxl bWVudCYgbGlzdEl0ZW0pOworCiAgICAgUVdlYkZyYW1lICpxOwogICAgIFF0OjpTY3JvbGxCYXJQ b2xpY3kgaG9yaXpvbnRhbFNjcm9sbEJhclBvbGljeTsKICAgICBRdDo6U2Nyb2xsQmFyUG9saWN5 IHZlcnRpY2FsU2Nyb2xsQmFyUG9saWN5OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxv ZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggN2YzYmQxNi4uZDVmMjA3ZSAxMDA2NDQKLS0t IGEvV2ViS2l0L3F0L0NoYW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTYgQEAKKzIwMTAtMDQtMDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0 Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBM aXN0IGl0ZW0gbWFya2VycyBhcmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4g dGhlIERPTS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM3MDYwCisKKyAgICAgICAgKiBBcGkvcXdlYmVsZW1lbnQuaDoKKyAgICAgICAgKiBBcGkvcXdl YmZyYW1lLmNwcDoKKyAgICAgICAgKFFXZWJGcmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0 SXRlbSk6CisgICAgICAgIChxdF9kcnRfbWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgcHJp dmF0ZSBBUEkgdG8gZ2V0IHRoZSBtYXJrZXIgdGV4dCBmb3IgYSBsaXN0IGl0ZW0uCisgICAgICAg ICogQXBpL3F3ZWJmcmFtZV9wLmg6CisKIDIwMTAtMDQtMDIgIExhc3psbyBHb21ib3MgIDxsYXN6 bG8uMS5nb21ib3NAbm9raWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9o ZGUgQ2hyaXN0aWFuc2VuLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2Vi S2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDM4ZWY0YWEuLmJiYjkxNjkgMTAwNjQ0Ci0tLSBhL1dl YktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyNSBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJraXQu b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExp c3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0 aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzcwNjAKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNw cDoKKyAgICAgICAgKG1hcmtlclRleHRGb3JMaXN0SXRlbUNhbGxiYWNrKTogQSBmdW5jdGlvbiB0 aGF0IHJldHVybnMgdGhlIG1hcmtlciB0ZXh0IGZvciBhIGdpdmVuIGxpc3QgaXRlbS4KKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAqIER1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAgICogRHVtcFJlbmRl clRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoKKyAgICAgICAgKExheW91dFRl c3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhl IEdUSyBwb3J0LgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJv bGxlck1hYy5tbToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9y TGlzdEl0ZW0pOiBBZGQgYSBzdHViLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L0xheW91 dFRlc3RDb250cm9sbGVyUXQuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Okxh eW91dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJr ZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhlIFF0IHBvcnQuCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5oOgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHA6CisgICAgICAg IChMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgc3R1 Yi4KKwogMjAxMC0wNC0wNSAgQ2hyaXMgSmVyZG9uZWsgIDxjamVyZG9uZWtAd2Via2l0Lm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBTaGluaWNoaXJvIEhhbWFqaS4KZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCAyNTU0 ZmE0Li42NmI1MDUzIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBAIC0xMzMxLDYgKzEzMzEsMTQgQEAgc3RhdGljIEpTVmFs dWVSZWYgYXBpVGVzdEdvVG9DdXJyZW50QmFja0ZvcndhcmRJdGVtQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQKICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9 CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG1hcmtlclRleHRGb3JMaXN0SXRlbUNhbGxiYWNrKEpTQ29u dGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6 ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVS ZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9 IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRo aXNPYmplY3QpKTsKKyAgICBpZiAoYXJndW1lbnRDb3VudCA8IDEpCisgICAgICAgIHJldHVybiBK U1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VTdHJp bmcoY29udGV4dCwgY29udHJvbGxlci0+bWFya2VyVGV4dEZvckxpc3RJdGVtKGFyZ3VtZW50c1sw XSkuZ2V0KCkpOworfQorCiAvLyBTdGF0aWMgVmFsdWVzCiAKIHN0YXRpYyBKU1ZhbHVlUmVmIGdl dEdsb2JhbEZsYWdDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgdGhp c09iamVjdCwgSlNTdHJpbmdSZWYgcHJvcGVydHlOYW1lLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24p CkBAIC0xNDQ0LDYgKzE0NTIsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJv bGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAia2VlcFdlYkhpc3RvcnkiLCBrZWVw V2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJv cGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgImxheWVyVHJlZUFzVGV4dCIs IGxheWVyVHJlZUFzVGV4dENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm51bWJlck9mUGFn ZXMiLCBudW1iZXJPZlBhZ2VzQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAibWFya2VyVGV4 dEZvckxpc3RJdGVtIiwgbWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAg ICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRy aWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAg ICB7ICJudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMiLCBudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnND YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBvdmVycmlk ZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1By b3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggM2M3MGY5OC4uNDY0OWRlOSAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu aAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5o CkBAIC0yNDgsNiArMjQ4LDggQEAgcHVibGljOgogICAgIAogICAgIEpTUmV0YWluUHRyPEpTU3Ry aW5nUmVmPiBsYXllclRyZWVBc1RleHQoKSBjb25zdDsKIAorICAgIEpTUmV0YWluUHRyPEpTU3Ry aW5nUmVmPiBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNWYWx1ZVJlZiBub2RlT2JqZWN0KSBjb25z dDsKKwogICAgIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhWaWV3V2lkdGg7CiAgICAgc3RhdGlj IGNvbnN0IHVuc2lnbmVkIG1heFZpZXdIZWlnaHQ7CiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCmluZGV4 IDdjMWI2ZTcuLjI0OTQ1YzUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcApAQCAtNTgsNiArNTgsNyBA QCBnY2hhciogd2Via2l0X3dlYl9mcmFtZV9jb3VudGVyX3ZhbHVlX2Zvcl9lbGVtZW50X2J5X2lk KFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgYwogaW50IHdlYmtpdF93ZWJfZnJhbWVfcGFnZV9udW1i ZXJfZm9yX2VsZW1lbnRfYnlfaWQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciog aWQsIGZsb2F0IHBhZ2VXaWR0aCwgZmxvYXQgcGFnZUhlaWdodCk7CiBpbnQgd2Via2l0X3dlYl9m cmFtZV9udW1iZXJfb2ZfcGFnZXMoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBmbG9hdCBwYWdlV2lk dGgsIGZsb2F0IHBhZ2VIZWlnaHQpOwogdm9pZCB3ZWJraXRfd2ViX2luc3BlY3Rvcl9leGVjdXRl X3NjcmlwdChXZWJLaXRXZWJJbnNwZWN0b3IqIGluc3BlY3RvciwgbG9uZyBjYWxsSWQsIGNvbnN0 IGdjaGFyKiBzY3JpcHQpOworZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfbWFya2VyX3RleHRfZm9y X2xpc3RfaXRlbShXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEpTT2JqZWN0UmVmIG5vZGVPYmplY3Qp OwogfQogCiBzdGF0aWMgZ2NoYXIqIGNvcHlXZWJTZXR0aW5nS2V5KGdjaGFyKiBwcmVmZXJlbmNl S2V5KQpAQCAtNjQzLDMgKzY0NCwxNCBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjphcGlU ZXN0R29Ub0N1cnJlbnRCYWNrRm9yd2FyZEl0ZW0oKQogewogCiB9CisKK0pTUmV0YWluUHRyPEpT U3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKEpT VmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICBnY2hhciogbWFya2VyVGV4dEdDaGFy ID0gd2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKG1haW5GcmFtZSwg bm9kZU9iamVjdCk7CisgICAgaWYgKCFtYXJrZXJUZXh0R0NoYXIpCisgICAgICAgIHJldHVybiAw OworCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IG1hcmtlclRleHQoQWRvcHQsIEpTU3Ry aW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKG1hcmtlclRleHRHQ2hhcikpOworICAgIGdfZnJlZSht YXJrZXJUZXh0R0NoYXIpOworICAgIHJldHVybiBtYXJrZXJUZXh0OworfQpkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1t IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFj Lm1tCmluZGV4IGYzMzI2MzAuLjJhMGI0YjEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQorKysgYi9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTE4Nyw2 ICsxODcsMTIgQEAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVy OjpsYXllclRyZWVBc1RleHQoKSBjb25zdAogICAgIHJldHVybiBzdHJpbmc7CiB9CiAKK0pTUmV0 YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxp c3RJdGVtKEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICAvLyBGSVhNRTogSW1w bGVtZW50IG1lLgorICAgIHJldHVybiBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4oKTsKK30KKwog aW50IExheW91dFRlc3RDb250cm9sbGVyOjpwYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoSlNTdHJp bmdSZWYgaWQsIGZsb2F0IHBhZ2VXaWR0aEluUGl4ZWxzLCBmbG9hdCBwYWdlSGVpZ2h0SW5QaXhl bHMpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBpZENGKEFkb3B0Q0YsIEpTU3RyaW5n Q29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGlkKSk7CmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcCBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCmlu ZGV4IGI2NDgwYzIuLjI0MzliOGYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCkBAIC01OSwxMSArNTksMTMg QEAgZXh0ZXJuIHZvaWQgcXRfZHJ0X3dlYmluc3BlY3Rvcl9leGVjdXRlU2NyaXB0KFFXZWJQYWdl KiBwYWdlLCBsb25nIGNhbGxJZCwgY29uc3QKIGV4dGVybiB2b2lkIHF0X2RydF93ZWJpbnNwZWN0 b3Jfc2hvdyhRV2ViUGFnZSAqcGFnZSk7CiBleHRlcm4gdm9pZCBxdF9kcnRfd2ViaW5zcGVjdG9y X2Nsb3NlKFFXZWJQYWdlICpwYWdlKTsKIGV4dGVybiB2b2lkIHF0X2RydF9lbmFibGVDYXJldEJy b3dzaW5nKFFXZWJQYWdlKiBwYWdlLCBib29sIHZhbHVlKTsKK2V4dGVybiBRU3RyaW5nIHF0X2Ry dF9tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKTsKIAog TGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKFdlYkNvcmU6OkR1bXBS ZW5kZXJUcmVlKiBkcnQpCiAgICAgOiBRT2JqZWN0KCkKICAgICAsIG1fZHJ0KGRydCkKIHsKKyAg ICBxUmVnaXN0ZXJNZXRhVHlwZTxRV2ViRWxlbWVudD4oIlFXZWJFbGVtZW50Iik7CiAgICAgcmVz ZXQoKTsKIH0KIApAQCAtNTQxLDUgKzU0MywxMCBAQCBib29sIExheW91dFRlc3RDb250cm9sbGVy OjpjYWxsU2hvdWxkQ2xvc2VPbldlYlZpZXcoKQogICAgIHJldHVybiBmYWxzZTsKIH0KIAorUVN0 cmluZyBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0IFFX ZWJFbGVtZW50JiBsaXN0SXRlbSkKK3sKKyAgICByZXR1cm4gcXRfZHJ0X21hcmtlclRleHRGb3JM aXN0SXRlbShsaXN0SXRlbSk7Cit9CisKIGNvbnN0IHVuc2lnbmVkIExheW91dFRlc3RDb250cm9s bGVyOjptYXhWaWV3V2lkdGggPSA4MDA7CiBjb25zdCB1bnNpZ25lZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6bWF4Vmlld0hlaWdodCA9IDYwMDsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaCBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaAppbmRleCAzNmI1ZjcwLi44NWU1 ZmU1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0 Q29udHJvbGxlclF0LmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0 VGVzdENvbnRyb2xsZXJRdC5oCkBAIC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8UVZhcmlhbnQ+ CiAKICNpbmNsdWRlIDxxd2ViZGF0YWJhc2UuaD4KKyNpbmNsdWRlIDxxd2ViZWxlbWVudC5oPgog I2luY2x1ZGUgPHF3ZWJmcmFtZS5oPgogI2luY2x1ZGUgPHF3ZWJoaXN0b3J5Lmg+CiAjaW5jbHVk ZSA8cXdlYnBhZ2UuaD4KQEAgLTE2NSw2ICsxNjYsOCBAQCBwdWJsaWMgc2xvdHM6CiAgICAgaW50 IG51bWJlck9mUGFnZXMoZmxvYXQgd2lkdGggPSBtYXhWaWV3V2lkdGgsIGZsb2F0IGhlaWdodCA9 IG1heFZpZXdIZWlnaHQpOwogICAgIGJvb2wgY2FsbFNob3VsZENsb3NlT25XZWJWaWV3KCk7CiAK KyAgICBRU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlz dEl0ZW0pOworCiBwcml2YXRlIHNsb3RzOgogICAgIHZvaWQgcHJvY2Vzc1dvcmsoKTsKIApkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9s bGVyV2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29u dHJvbGxlcldpbi5jcHAKaW5kZXggYWQ3NTdlNC4uNWVmOGNjYyAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAorKysg Yi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4u Y3BwCkBAIC0xODgsNiArMTg4LDEyIEBAIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6bGF5ZXJUcmVlQXNUZXh0KCkgY29uc3QKICAgICByZXR1cm4gdGV4dFZh bHVlSlM7CiB9CiAKK0pTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxl cjo6bWFya2VyVGV4dEZvckxpc3RJdGVtKEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sK KyAgICAvLyBGSVhNRTogSW1wbGVtZW50IG1lLgorICAgIHJldHVybiBKU1JldGFpblB0cjxKU1N0 cmluZ1JlZj4oKTsKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6d2FpdEZvclBvbGlj eURlbGVnYXRlKCkKIHsKICAgICAvLyBGSVhNRTogSW1wbGVtZW50IHRoaXMuCg== 52569 2010-04-05 14:18:29 -0700 2010-04-20 15:35:05 -0700 patch list-markers-dom-changes-v6.patch text/plain 41289 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlYjMyYTk4Li4wYTk0ZTkyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDQt MDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKwogMjAxMC0wNC0wMyAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJr aXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgZXhwZWN0ZWQgcmVzdWx0cyBmaXguCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvbGlzdHMvZHVtcC1saXN0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmFiNGEzYjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1 bXAtbGlzdC5qcwpAQCAtMCwwICsxLDMxIEBACitmdW5jdGlvbiBpbmRlbnQoZGVwdGgpCit7Cisg ICAgdmFyIHJldCA9IG5ldyBTdHJpbmcoKTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGRlcHRo OyArK2kpCisgICAgICAgIHJldCArPSAiLT4gIjsKKyAgICByZXR1cm4gcmV0ICsgIiAiOworfQor CitmdW5jdGlvbiBkdW1wTGlzdEhlbHBlcihlbGVtZW50LCBkZXB0aCkKK3sKKyAgICB2YXIgcmV0 ID0gbmV3IFN0cmluZygpOworCisgICAgdmFyIGNoaWxkID0gZWxlbWVudC5maXJzdENoaWxkOwor ICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoY2hpbGQubm9kZVR5cGUgPT0gTm9kZS5F TEVNRU5UX05PREUpIHsKKyAgICAgICAgICAgIHZhciBtYXJrZXIgPSBsYXlvdXRUZXN0Q29udHJv bGxlci5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY2hpbGQpOworICAgICAgICAgICAgaWYgKG1hcmtl cikKKyAgICAgICAgICAgICAgICByZXQgKz0gaW5kZW50KGRlcHRoKSArICcgJyArIG1hcmtlciAr ICcgJyArIGNoaWxkLmlubmVyVGV4dC50cmltKCkgKyAnPGJyIC8+JzsKKyAgICAgICAgICAgIHJl dCArPSBkdW1wTGlzdEhlbHBlcihjaGlsZCwgZGVwdGggKyAxKTsKKyAgICAgICAgfQorCisgICAg ICAgIGNoaWxkID0gY2hpbGQubmV4dFNpYmxpbmc7CisgICAgfQorCisgICAgcmV0dXJuIHJldDsK K30KKworZnVuY3Rpb24gZHVtcExpc3QobGlzdCkKK3sKKyAgICByZXR1cm4gZHVtcExpc3RIZWxw ZXIobGlzdCwgMCk7Cit9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjM5NjQ5NgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0LWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDE0IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1h cmtlcnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxk cmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuCisKKzEgT25lCisyIFR3bworLT4gMyBUaHJlZQorNCBG b3VyCis1IEZpdmUKKzYgU2l4CistPiA3IFNldmVuCistPiA4IEVpZ2h0CistPiA5IE5pbmUKKzEw IFRlbgorMTEgRWxldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wt bmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjZiM2Q5ODcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAgKzEs NTIgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibmVzdGVkIik7CisKKyAgICAgICAgICAgICAgICB2YXIgbGkxID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTEuaW5uZXJUZXh0ID0gIkVpZ2h0IjsK KworICAgICAgICAgICAgICAgIHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIp OworICAgICAgICAgICAgICAgIGxpMi5pbm5lclRleHQgPSAiU2V2ZW4iOworCisgICAgICAgICAg ICAgICAgdmFyIGl0ZW0zID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgICAg ICAgICAgICAgaXRlbTMuaW5uZXJUZXh0ID0gIk5pbmUiOworICAgICAgICAgICAgICAgIGl0ZW0z LnN0eWxlLmRpc3BsYXkgPSAibGlzdC1pdGVtIjsKKworICAgICAgICAgICAgICAgIHAuYXBwZW5k Q2hpbGQobGkxKTsKKyAgICAgICAgICAgICAgICBwLmluc2VydEJlZm9yZShsaTIsIGxpMSk7Cisg ICAgICAgICAgICAgICAgcC5hcHBlbmRDaGlsZChpdGVtMyk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVu IG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAg ICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg IDxkaXY+PGxpPlRocmVlPC9saT48L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAg ICAgICAgICAgIDxsaT5GaXZlPC9saT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAg ICAgICAgPHAgaWQ9Im5lc3RlZCI+PC9wPgorICAgICAgICAgICAgPGxpPlRlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RWxldmVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlk PSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJlNDUzMDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJz IGFyZSB1cGRhdGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRp cmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKzMgVGhy ZWUKKzQgRm91cgorNSBGaXZlCis2IFNpeAorNyBTZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYThkYjVjCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1v dmUuaHRtbApAQCAtMCwwICsxLDUxIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNj cmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAg IGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNl dFRvcDsgLy8gRm9yY2UgYSByZWxheW91dC4KKworICAgICAgICAgICAgICAgIHZhciBiID0gZG9j dW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoImIiKVswXTsKKyAgICAgICAgICAgICAgICBsaXN0 LnJlbW92ZUNoaWxkKGIpOworCisgICAgICAgICAgICAgICAgdmFyIGRpdiA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJuZXN0ZWQiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBkaXYu Y2hpbGRyZW4ubGVuZ3RoOworICAgICAgICAgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgaXRl bXM7ICsraSkKKyAgICAgICAgICAgICAgICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5maXJzdEVs ZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJpdGVtIikpOworCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAg ICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxl c3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAgICAgICAgIH0K KyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0idGVzdCgp Ij4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRh dGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGls ZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8Yj48bGk+Rm9vPC9saT48L2I+CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xpPgorICAg ICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAgICAgPGxpPkZpdmU8L2xpPgorICAgICAg ICAgICAgPGRpdiBpZD0ibmVzdGVkIj4KKyAgICAgICAgICAgICAgICA8bGk+Rm9vPC9saT4KKyAg ICAgICAgICAgICAgICA8bGk+QmFyPC9saT4KKyAgICAgICAgICAgICAgICA8bGk+QmF6PC9saT4K KyAgICAgICAgICAgIDwvZGl2PgorICAgICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAgICAgICAg ICA8ZGl2IGlkPSJpdGVtIiBzdHlsZT0iZGlzcGxheTogbGlzdC1pdGVtIj5Gb288L2Rpdj4KKyAg ICAgICAgICAgIDxsaT5TZXZlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWl0ZW1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0 ZW1zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMzRi MzY2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0 IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJrZWQgd2hlbiBzb21lIG9mIHRoZSBpdGVtcyBhcmUgaW5k aXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxpc3QgZWxlbWVudC4KKworMSBPbmUKKzIgVHdvCiszIFRo cmVlCis0IEZvdXIKKy0+IDUgRml2ZQorLT4gNiBTaXgKKzEwIFRlbgorMTEgRWxldmVuCistPiAx MiBUd2VsdmUKKy0+IDEzIFRoaXJ0ZWVuCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi40NDY2MjAyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbApAQCAtMCwwICsxLDQyIEBACis8aHRt bD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAg ICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRlc3QoKQorICAgICAgICAgICAg eworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAg ICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKTsK KyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVy SFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0 aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisg ICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNw bGF5ID0gIm5vbmUiOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hl YWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRo YXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRlbXMg YXJlIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAgICA8 b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8bGk+ VHdvPC9saT4KKyAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+Rm91 cgorICAgICAgICAgICAgICAgIDxiPgorICAgICAgICAgICAgICAgICAgICA8bGk+Rml2ZTwvbGk+ CisgICAgICAgICAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgICAgIDwvYj4K KyAgICAgICAgICAgIDwvbGk+CisgICAgICAgICAgICA8bGkgdmFsdWU9IjEwIj5UZW48L2xpPgor ICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8ZGl2PgorICAgICAgICAg ICAgICAgIDxsaT5Ud2VsdmU8L2xpPgorICAgICAgICAgICAgICAgIDxsaT5UaGlydGVlbjwvbGk+ CisgICAgICAgICAgICA8L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+CisgICAg ICAgICAgICA8bGk+RmlmdGVlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVk LWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZmMDk4ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTMgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBk byBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LgorCisx IE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgorNSBGaXZlIE9uZSBUd2VudHkgZml2ZSBUd2Vu dHkgc2l4CistPiAtPiAxIE9uZQorLT4gLT4gMjUgVHdlbnR5IGZpdmUKKy0+IC0+IDI2IFR3ZW50 eSBzaXgKKzYgU2l4Cis3IFNldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4wNDhiZGNlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCkBAIC0wLDAg KzEsNDggQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1s aXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgp CisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBh IHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKworICAgICAgICAgICAgICAgIHZhciBsaTIg PSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMi5pbm5l clRleHQgPSAiVHdlbnR5IGZpdmUiOworICAgICAgICAgICAgICAgIGxpMi52YWx1ZSA9ICIyNSI7 CisgICAgICAgICAgICAgICAgdmFyIGxpMSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxpIik7 CisgICAgICAgICAgICAgICAgbGkxLmlubmVyVGV4dCA9ICJPbmUiOworICAgICAgICAgICAgICAg IHZhciBsaTMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAg IGxpMy5pbm5lclRleHQgPSAiVHdlbnR5IHNpeCI7CisKKyAgICAgICAgICAgICAgICBuZXN0ZWRM aXN0LmFwcGVuZENoaWxkKGxpMik7CisgICAgICAgICAgICAgICAgbmVzdGVkTGlzdC5pbnNlcnRC ZWZvcmUobGkxLCBsaTIpOworICAgICAgICAgICAgICAgIG5lc3RlZExpc3QuYXBwZW5kQ2hpbGQo bGkzKTsKKworICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xl IikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBEb24n dCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9ubHkg bW9kZS4KKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpLnN0 eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0Pgor ICAgIDwvaGVhZD4KKyAgICA8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMg dGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2VycyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5l dyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAg ICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAg ICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAg ICAgPGxpPkZpdmUgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+PC9vbD48L2xpPgorICAgICAgICAgICAg PGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW48L2xpPgorICAgICAgICA8L29sPgor CisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4K XCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY2OTExYjMKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMt cmVtb3ZlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIHRoYXQgbGlz dCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1z IGZyb20gYSBuZXN0ZWQgbGlzdC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUg Rml2ZQorMSBPbmUKKzIgVHdvCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi42OTE0ZmI4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5odG1sCkBAIC0wLDAgKzEs NDUgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0 LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJl bGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBu ZXN0ZWRMaXN0LmNoaWxkcmVuLmxlbmd0aDsKKyAgICAgICAgICAgICAgICBmb3IgKHZhciBpID0g MDsgaSA8IGl0ZW1zOyArK2kpCisgICAgICAgICAgICAgICAgICAgIG5lc3RlZExpc3QucmVtb3Zl Q2hpbGQobmVzdGVkTGlzdC5maXJzdEVsZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxp c3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMg aXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxpc3QiKS5zdHlsZS5kaXNwbGF5ID0gIm5vbmUiOworICAg ICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25s b2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtl cnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0 ZWQgbGlzdC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+CisgICAgICAgICAgICA8bGk+T25l PC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICAgICAgPGxpPlRocmVlPC9s aT4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxsaT5GaXZlCisgICAg ICAgICAgICAgICAgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+CisgICAgICAgICAgICAgICAgICAgIDxs aT5PbmU8L2xpPgorICAgICAgICAgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAg ICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgICAgICA8L29sPgorICAgICAgICAg ICAgPC9saT4KKyAgICAgICAgICAgIDxsaSB2YWx1ZT0iMSI+T25lPC9saT4KKyAgICAgICAgICAg IDxsaT5Ud288L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxl CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRmZjUzZWIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJv cGVybHkgbWFya2VkIHdoZW4gdGhlIGxpc3QgY29udGFpbnMgbmVzdGVkIGxpc3RzLgorCisxMCBU ZW4KKzExIEVsZXZlbgorMTIgVHdlbHZlCisxMyBUaGlydGVlbiBPbmUgVHdvCistPiAtPiDil6Yg T25lCistPiAtPiDil6YgVHdvCisxNCBGb3VydGVlbgorMTUgRmlmdGVlbgorLT4gMSBPbmUKKy0+ IDIgVHdvCisxNiBTaXh0ZWVuCisxNyBTZXZlbnRlZW4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0 cy9vbC1uZXN0ZWQtbGlzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjljOWVjZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0Lmh0bWwKQEAgLTAsMCArMSw0MiBAQAorPGh0bWw+CisgICAgPGhlYWQ+CisgICAg ICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+CisgICAgICAgIDxzY3JpcHQ+CisgICAg ICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAgICAgICAgICAgICB2YXIgbGlz dCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iik7CisgICAgICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0 KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0 IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iikuc3R5bGUuZGlzcGxheSA9ICJub25lIjsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9h ZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHBy b3Blcmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0IGNvbnRhaW5zIG5lc3RlZCBsaXN0cy48L3A+Cisg ICAgICAgIDxvbCBpZD0ibGlzdCIgc3RhcnQ9IjEwIj4KKyAgICAgICAgICAgIDxsaT5UZW48L2xp PgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8bGk+VHdlbHZlPC9s aT4KKyAgICAgICAgICAgIDxsaT5UaGlydGVlbgorICAgICAgICAgICAgICAgIDx1bD4KKyAgICAg ICAgICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5Ud288 L2xpPgorICAgICAgICAgICAgICAgIDwvdWw+CisgICAgICAgICAgICA8L2xpPgorICAgICAgICAg ICAgPGxpPkZvdXJ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxsaT5GaWZ0ZWVuPC9saT4KKyAgICAg ICAgICAgIDxvbD4KKyAgICAgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgICAg ICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDwvb2w+CisgICAgICAgICAgICA8bGk+U2l4dGVl bjwvbGk+CisgICAgICAgICAgICA8bGk+U2V2ZW50ZWVuPC9saT4KKyAgICAgICAgPC9vbD4KKwor ICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+Clwg Tm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAppbmRleCBh NjFhZDIxLi45MDc4OGExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tp cHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZApAQCAtMTU2LDMgKzE1 NiwxMCBAQCBmYXN0L3JlcGxhY2VkL2JvcmRlci1yYWRpdXMtY2xpcC5odG1sCiAjIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjY0NgogZmFzdC93b3JrZXJzL3dvcmtl ci10ZXJtaW5hdGUuaHRtbAogCisjIE1pc3NpbmcgYW4gaW1wbGVtZW50YXRpb24gb2YgTGF5b3V0 VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSgpCitmYXN0L2xpc3RzL29sLW5l c3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVt cy1keW5hbWljLXJlbW92ZS5odG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy5odG1sCitm YXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKK2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQt bGlzdC5odG1sCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZCBi L0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCmluZGV4IGU3YzRjZWYuLmY2OWE3OGEg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCkBAIC04MjIsMyArODIyLDExIEBAIGZhc3QvbWVk aWEvbWVkaWEtZmVhdHVyZS13Z3Qtdmlldy1tb2RlLmh0bWwKIAogIyBOZWVkIGV4cGVjdGF0aW9u cy4gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjQ2MQogZmFz dC9yZXBhaW50L292ZXJmbG93LXNjcm9sbC1ib2R5LWFwcGVhci5odG1sCisKKyMgTWlzc2luZyBh biBpbXBsZW1lbnRhdGlvbiBvZiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxp c3RJdGVtKCkKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwK K2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3ZlLmh0bWwKK2Zhc3QvbGlz dHMvb2wtbmVzdGVkLWl0ZW1zLmh0bWwKK2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1p Yy1pbnNlcnQuaHRtbAorZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5o dG1sCitmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwKZGlmZiAtLWdpdCBhL1dlYkNvcmUv Q2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzYwMzg2MC4uY2MzODZjYiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNCBAQAorMjAxMC0wNC0wNSAgSmFrdWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJr aXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3QgYWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBp biB0aGUgRE9NLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzcwNjAKKworICAgICAgICBJbiBwYXJ0aWN1bGFyLCB0aGV5IHdvdWxkIG5vdCBiZSB1cGRh dGVkIHdoZW4gYWRkaW5nL3JlbW92aW5nIGFuIGl0ZW0KKyAgICAgICAgdGhhdCBpcyBub3QgYSBk aXJlY3QgY2hpbGQgb2YgdGhlIGxpc3QgZWxlbWVudC4KKworICAgICAgICBUZXN0czogZmFzdC9s aXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1pbnNlcnQuaHRtbAorICAgICAgICAgICAgICAg ZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbAorICAgICAgICAg ICAgICAgZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRtbAorICAgICAgICAgICAgICAgZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCisgICAgICAgICAgICAg ICBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QuaHRtbAorCisgICAgICAgICogcmVuZGVy aW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVuY2xvc2luZ0xpc3Qp OiBDaGFuZ2UgdGhlIHNpZ25hdHVyZSB0byB0YWtlIGEgUmVuZGVyTGlzdEl0ZW0qLgorICAgICAg ICAoV2ViQ29yZTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMpOiBDaGFuZ2UgaXQgdG8gdHJhdmVy c2UgdGhlIHdob2xlIHN1YnRyZWUgb2YgYSBsaXN0LCBub3Qgb25seSBzaWJsaW5ncyBvZiBhbiBp dGVtLgorICAgICAgICAoV2ViQ29yZTo6cHJldmlvdXNMaXN0SXRlbSk6CisgICAgICAgICogcmVu ZGVyaW5nL1JlbmRlckxpc3RJdGVtLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVj dC5jcHA6IE1vdmUgdGhlIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzIGZ1bmN0aW9uIHRvIFJlbmRl ckxpc3RJdGVtLmNwcC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6YWRkQ2hpbGQp OiBNb3ZlIHRoZSBjb2RlIHVwZGF0aW5nIGxpc3QgbWFya2VycyB0byBSZW5kZXJPYmplY3RDaGls ZExpc3QgZm9yIGNvbnNpc3RlbmN5LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RD aGlsZExpc3QuY3BwOiBNb3ZlIHRoZSB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlvbiB0 byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3RDaGls ZExpc3Q6OnJlbW92ZUNoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5nIHJlbW92 ZWQsIG5vdCB0aGUgbmV4dCBzaWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Q2hpbGRMaXN0OjphcHBlbmRDaGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyBh ZGRlZCwgbm90IHRoZSBuZXh0IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmpl Y3RDaGlsZExpc3Q6Omluc2VydENoaWxkTm9kZSk6IFBhc3MgdGhlIGFjdHVhbCBub2RlIGJlaW5n IGFkZGVkLCBub3QgdGhlIG5leHQgc2libGluZy4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVy VHJlZUFzVGV4dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0p OgorCiAyMDEwLTA0LTA0ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AY2hyb21pdW0ub3JnPgog CiAgICAgICAgIE5vdCByZXZpZXdlZC4gUm9sbGluZyBvdXQgY2hyb21pdW0gY2hhbmdlcyByNTcw MjggYW5kIHI1NzAzMgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0 ZW0uY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCmluZGV4IDU0YTdk ZDIuLjE4MzJmODUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVt LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKQEAgLTkyLDEz ICs5MiwxMyBAQCBzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChOb2RlKiBub2RlKQogICAgIHJl dHVybiBwYXJlbnQ7CiB9CiAKLXN0YXRpYyBOb2RlKiBlbmNsb3NpbmdMaXN0KGNvbnN0IFJlbmRl ck9iamVjdCogcmVuZGVyZXIpCitzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChjb25zdCBSZW5k ZXJMaXN0SXRlbSogbGlzdEl0ZW0pCiB7Ci0gICAgTm9kZSogbm9kZSA9IHJlbmRlcmVyLT5ub2Rl KCk7CisgICAgTm9kZSogbm9kZSA9IGxpc3RJdGVtLT5ub2RlKCk7CiAgICAgaWYgKG5vZGUpCiAg ICAgICAgIHJldHVybiBlbmNsb3NpbmdMaXN0KG5vZGUpOwogCi0gICAgcmVuZGVyZXIgPSByZW5k ZXJlci0+cGFyZW50KCk7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGxpc3RJ dGVtOwogICAgIHdoaWxlIChyZW5kZXJlciAmJiAhcmVuZGVyZXItPm5vZGUoKSkKICAgICAgICAg cmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50KCk7CiAKQEAgLTExNCw3ICsxMTQsOCBAQCBzdGF0 aWMgUmVuZGVyTGlzdEl0ZW0qIHByZXZpb3VzTGlzdEl0ZW0oTm9kZSogbGlzdCwgY29uc3QgUmVu ZGVyTGlzdEl0ZW0qIGl0ZW0pCiAgICAgZm9yIChSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gaXRl bS0+cHJldmlvdXNJblByZU9yZGVyKCk7IHJlbmRlcmVyICE9IGxpc3QtPnJlbmRlcmVyKCk7IHJl bmRlcmVyID0gcmVuZGVyZXItPnByZXZpb3VzSW5QcmVPcmRlcigpKSB7CiAgICAgICAgIGlmICgh cmVuZGVyZXItPmlzTGlzdEl0ZW0oKSkKICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICBO b2RlKiBvdGhlckxpc3QgPSBlbmNsb3NpbmdMaXN0KHJlbmRlcmVyKTsKKworICAgICAgICBOb2Rl KiBvdGhlckxpc3QgPSBlbmNsb3NpbmdMaXN0KHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpKTsK ICAgICAgICAgLy8gVGhpcyBpdGVtIGlzIHBhcnQgb2Ygb3VyIGN1cnJlbnQgbGlzdCwgc28gaXQn cyB3aGF0IHdlJ3JlIGxvb2tpbmcgZm9yLgogICAgICAgICBpZiAobGlzdCA9PSBvdGhlckxpc3Qp CiAgICAgICAgICAgICByZXR1cm4gdG9SZW5kZXJMaXN0SXRlbShyZW5kZXJlcik7CkBAIC0zNjQs NCArMzY1LDM4IEBAIHZvaWQgUmVuZGVyTGlzdEl0ZW06OmNsZWFyRXhwbGljaXRWYWx1ZSgpCiAg ICAgZXhwbGljaXRWYWx1ZUNoYW5nZWQoKTsKIH0KIAordm9pZCBSZW5kZXJMaXN0SXRlbTo6dXBk YXRlTGlzdE1hcmtlck51bWJlcnMoKQoreworICAgIE5vZGUqIGxpc3ROb2RlID0gZW5jbG9zaW5n TGlzdCh0aGlzKTsKKyAgICBBU1NFUlQobGlzdE5vZGUgJiYgbGlzdE5vZGUtPnJlbmRlcmVyKCkp OworICAgIGlmICghbGlzdE5vZGUgfHwgIWxpc3ROb2RlLT5yZW5kZXJlcigpKQorICAgICAgICBy ZXR1cm47CisKKyAgICBSZW5kZXJPYmplY3QqIGxpc3QgPSBsaXN0Tm9kZS0+cmVuZGVyZXIoKTsK KyAgICBSZW5kZXJPYmplY3QqIGNoaWxkID0gdGhpcy0+bmV4dEluUHJlT3JkZXIobGlzdCk7Cisg ICAgd2hpbGUgKGNoaWxkKSB7CisgICAgICAgIGlmIChjaGlsZC0+bm9kZSgpICYmIGlzTGlzdChj aGlsZC0+bm9kZSgpKSkgeworICAgICAgICAgICAgLy8gV2UndmUgZm91bmQgYSBuZXN0ZWQsIGlu ZGVwZW5kZW50IGxpc3Q6IG5vdGhpbmcgdG8gZG8gaGVyZS4KKyAgICAgICAgICAgIGNoaWxkID0g Y2hpbGQtPm5leHRJblByZU9yZGVyQWZ0ZXJDaGlsZHJlbihsaXN0KTsKKyAgICAgICAgICAgIGNv bnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgaWYgKGNoaWxkLT5pc0xpc3RJdGVtKCkpIHsK KyAgICAgICAgICAgIFJlbmRlckxpc3RJdGVtKiBpdGVtID0gdG9SZW5kZXJMaXN0SXRlbShjaGls ZCk7CisKKyAgICAgICAgICAgIGlmICghaXRlbS0+bV9pc1ZhbHVlVXBUb0RhdGUpIHsKKyAgICAg ICAgICAgICAgICAvLyBJZiBhbiBpdGVtIGhhcyBiZWVuIG1hcmtlZCBmb3IgdXBkYXRlIGJlZm9y ZSwgd2UgY2FuIHNhZmVseQorICAgICAgICAgICAgICAgIC8vIGFzc3VtZSB0aGF0IGFsbCB0aGUg Zm9sbG93aW5nIG9uZXMgaGF2ZSB0b28uCisgICAgICAgICAgICAgICAgLy8gVGhpcyBnaXZlcyB1 cyB0aGUgb3Bwb3J0dW5pdHkgdG8gc3RvcCBoZXJlIGFuZCBhdm9pZAorICAgICAgICAgICAgICAg IC8vIG1hcmtpbmcgdGhlIHNhbWUgbm9kZXMgYWdhaW4uCisgICAgICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGl0ZW0tPnVwZGF0ZVZhbHVlKCk7CisgICAg ICAgIH0KKworICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0SW5QcmVPcmRlcihsaXN0KTsKKyAg ICB9Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckxpc3RJdGVtLmggYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRl bS5oCmluZGV4IGM0YzQxZGMuLjJhZDlhNDEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckxpc3RJdGVtLmgKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0u aApAQCAtNDYsNiArNDYsOCBAQCBwdWJsaWM6CiAKICAgICBjb25zdCBTdHJpbmcmIG1hcmtlclRl eHQoKSBjb25zdDsKIAorICAgIHZvaWQgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoKTsKKwogcHJp dmF0ZToKICAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdCB7IHJldHVy biAiUmVuZGVyTGlzdEl0ZW0iOyB9CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlck9iamVjdC5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCmluZGV4 IDcwMDBiNzAuLjFmNWY0NDAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9i amVjdC5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApAQCAtMjU3 LDE0ICsyNTcsNiBAQCBib29sIFJlbmRlck9iamVjdDo6aXNIVE1MTWFycXVlZSgpIGNvbnN0CiAg ICAgcmV0dXJuIG5vZGUoKSAmJiBub2RlKCktPnJlbmRlcmVyKCkgPT0gdGhpcyAmJiBub2RlKCkt Pmhhc1RhZ05hbWUobWFycXVlZVRhZyk7CiB9CiAKLXN0YXRpYyB2b2lkIHVwZGF0ZUxpc3RNYXJr ZXJOdW1iZXJzKFJlbmRlck9iamVjdCogY2hpbGQpCi17Ci0gICAgZm9yIChSZW5kZXJPYmplY3Qq IHNpYmxpbmcgPSBjaGlsZDsgc2libGluZzsgc2libGluZyA9IHNpYmxpbmctPm5leHRTaWJsaW5n KCkpIHsKLSAgICAgICAgaWYgKHNpYmxpbmctPmlzTGlzdEl0ZW0oKSkKLSAgICAgICAgICAgIHRv UmVuZGVyTGlzdEl0ZW0oc2libGluZyktPnVwZGF0ZVZhbHVlKCk7Ci0gICAgfQotfQotCiB2b2lk IFJlbmRlck9iamVjdDo6YWRkQ2hpbGQoUmVuZGVyT2JqZWN0KiBuZXdDaGlsZCwgUmVuZGVyT2Jq ZWN0KiBiZWZvcmVDaGlsZCkKIHsKICAgICBSZW5kZXJPYmplY3RDaGlsZExpc3QqIGNoaWxkcmVu ID0gdmlydHVhbENoaWxkcmVuKCk7CkBAIC0yNzQsOSArMjY2LDcgQEAgdm9pZCBSZW5kZXJPYmpl Y3Q6OmFkZENoaWxkKFJlbmRlck9iamVjdCogbmV3Q2hpbGQsIFJlbmRlck9iamVjdCogYmVmb3Jl Q2hpbGQpCiAKICAgICBib29sIG5lZWRzVGFibGUgPSBmYWxzZTsKIAotICAgIGlmIChuZXdDaGls ZC0+aXNMaXN0SXRlbSgpKQotICAgICAgICB1cGRhdGVMaXN0TWFya2VyTnVtYmVycyhiZWZvcmVD aGlsZCA/IGJlZm9yZUNoaWxkIDogY2hpbGRyZW4tPmxhc3RDaGlsZCgpKTsKLSAgICBlbHNlIGlm IChuZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkg PT0gVEFCTEVfQ09MVU1OX0dST1VQKQorICAgIGlmIChuZXdDaGlsZC0+aXNUYWJsZUNvbCgpICYm IG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ09MVU1OX0dST1VQKQogICAg ICAgICBuZWVkc1RhYmxlID0gIWlzVGFibGUoKTsKICAgICBlbHNlIGlmIChuZXdDaGlsZC0+aXNS ZW5kZXJCbG9jaygpICYmIG5ld0NoaWxkLT5zdHlsZSgpLT5kaXNwbGF5KCkgPT0gVEFCTEVfQ0FQ VElPTikKICAgICAgICAgbmVlZHNUYWJsZSA9ICFpc1RhYmxlKCk7CmRpZmYgLS1naXQgYS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwIGIvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAppbmRleCA4ZWU4MTEyLi42ZDc2ZjM0IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwCisrKyBi L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdENoaWxkTGlzdC5jcHAKQEAgLTM5LDE0ICsz OSw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotc3RhdGljIHZvaWQgdXBkYXRlTGlzdE1h cmtlck51bWJlcnMoUmVuZGVyT2JqZWN0KiBjaGlsZCkKLXsKLSAgICBmb3IgKFJlbmRlck9iamVj dCogc2libGluZyA9IGNoaWxkOyBzaWJsaW5nOyBzaWJsaW5nID0gc2libGluZy0+bmV4dFNpYmxp bmcoKSkgewotICAgICAgICBpZiAoc2libGluZy0+aXNMaXN0SXRlbSgpKQotICAgICAgICAgICAg dG9SZW5kZXJMaXN0SXRlbShzaWJsaW5nKS0+dXBkYXRlVmFsdWUoKTsKLSAgICB9Ci19Ci0KIHZv aWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpkZXN0cm95TGVmdG92ZXJDaGlsZHJlbigpCiB7CiAg ICAgd2hpbGUgKGZpcnN0Q2hpbGQoKSkgewpAQCAtOTEsMTEgKzgzLDEwIEBAIFJlbmRlck9iamVj dCogUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpyZW1vdmVDaGlsZE5vZGUoUmVuZGVyT2JqZWN0KiBv d25lciwgUmVuZGVyCiAgICAgICAgICAgICAgICAgbGF5ZXIgPSBvd25lci0+ZW5jbG9zaW5nTGF5 ZXIoKTsKICAgICAgICAgICAgIG9sZENoaWxkLT5yZW1vdmVMYXllcnMobGF5ZXIpOwogICAgICAg ICB9Ci0gICAgICAgIAotICAgICAgICAvLyByZW51bWJlciBvcmRlcmVkIGxpc3RzCisKICAgICAg ICAgaWYgKG9sZENoaWxkLT5pc0xpc3RJdGVtKCkpCi0gICAgICAgICAgICB1cGRhdGVMaXN0TWFy a2VyTnVtYmVycyhvbGRDaGlsZC0+bmV4dFNpYmxpbmcoKSk7Ci0gICAgICAgIAorICAgICAgICAg ICAgdG9SZW5kZXJMaXN0SXRlbShvbGRDaGlsZCktPnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7 CisKICAgICAgICAgaWYgKG9sZENoaWxkLT5pc1Bvc2l0aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRy ZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGls ZChvbGRDaGlsZCk7CiAgICAgfQpAQCAtMTYxLDcgKzE1MiwxMCBAQCB2b2lkIFJlbmRlck9iamVj dENoaWxkTGlzdDo6YXBwZW5kQ2hpbGROb2RlKFJlbmRlck9iamVjdCogb3duZXIsIFJlbmRlck9i amVjdCogbgogICAgICAgICAgICAgaWYgKGxheWVyKQogICAgICAgICAgICAgICAgIGxheWVyLT5z ZXRIYXNWaXNpYmxlQ29udGVudCh0cnVlKTsKICAgICAgICAgfQotICAgICAgICAKKworICAgICAg ICBpZiAobmV3Q2hpbGQtPmlzTGlzdEl0ZW0oKSkKKyAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0 ZW0obmV3Q2hpbGQpLT51cGRhdGVMaXN0TWFya2VyTnVtYmVycygpOworCiAgICAgICAgIGlmICgh bmV3Q2hpbGQtPmlzRmxvYXRpbmdPclBvc2l0aW9uZWQoKSAmJiBvd25lci0+Y2hpbGRyZW5Jbmxp bmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxpbmVzRnJvbUNoYW5nZWRDaGlsZChuZXdD aGlsZCk7CiAgICAgfQpAQCAtMjE4LDcgKzIxMiw5IEBAIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRM aXN0OjppbnNlcnRDaGlsZE5vZGUoUmVuZGVyT2JqZWN0KiBvd25lciwgUmVuZGVyT2JqZWN0KiBj CiAgICAgICAgICAgICAgICAgbGF5ZXItPnNldEhhc1Zpc2libGVDb250ZW50KHRydWUpOwogICAg ICAgICB9CiAKLSAgICAgICAgCisgICAgICAgIGlmIChjaGlsZC0+aXNMaXN0SXRlbSgpKQorICAg ICAgICAgICAgdG9SZW5kZXJMaXN0SXRlbShjaGlsZCktPnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJz KCk7CisKICAgICAgICAgaWYgKCFjaGlsZC0+aXNGbG9hdGluZygpICYmIG93bmVyLT5jaGlsZHJl bklubGluZSgpKQogICAgICAgICAgICAgb3duZXItPmRpcnR5TGluZXNGcm9tQ2hhbmdlZENoaWxk KGNoaWxkKTsKICAgICB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVl QXNUZXh0LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwCmluZGV4 IDg0ZjUyYzYuLjc1YzM1YmEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRy ZWVBc1RleHQuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3Bw CkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQlIuaCIKICNpbmNsdWRlICJSZW5k ZXJGaWxlVXBsb2FkQ29udHJvbC5oIgogI2luY2x1ZGUgIlJlbmRlcklubGluZS5oIgorI2luY2x1 ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVyTGlzdE1hcmtlci5oIgogI2lu Y2x1ZGUgIlJlbmRlclBhcnQuaCIKICNpbmNsdWRlICJSZW5kZXJUYWJsZUNlbGwuaCIKQEAgLTY2 MCw0ICs2NjEsMTcgQEAgU3RyaW5nIGNvdW50ZXJWYWx1ZUZvckVsZW1lbnQoRWxlbWVudCogZWxl bWVudCkKICAgICByZXR1cm4gc3RyZWFtLnJlbGVhc2UoKTsKIH0KIAorU3RyaW5nIG1hcmtlclRl eHRGb3JMaXN0SXRlbShFbGVtZW50KiBlbGVtZW50KQoreworICAgIC8vIE1ha2Ugc3VyZSB0aGUg ZWxlbWVudCBpcyBub3QgZnJlZWQgZHVyaW5nIHRoZSBsYXlvdXQuCisgICAgUmVmUHRyPEVsZW1l bnQ+IGVsZW1lbnRSZWYoZWxlbWVudCk7CisgICAgZWxlbWVudC0+ZG9jdW1lbnQoKS0+dXBkYXRl TGF5b3V0KCk7CisKKyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gZWxlbWVudC0+cmVuZGVy ZXIoKTsKKyAgICBpZiAoIXJlbmRlcmVyIHx8ICFyZW5kZXJlci0+aXNMaXN0SXRlbSgpKQorICAg ICAgICByZXR1cm4gU3RyaW5nKCk7CisKKyAgICByZXR1cm4gdG9SZW5kZXJMaXN0SXRlbShyZW5k ZXJlciktPm1hcmtlclRleHQoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVHJlZUFzVGV4dC5oIGIvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyVHJlZUFzVGV4dC5oCmluZGV4IDFmY2ZlYzEuLjRkYTBiYWIgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuaAorKysgYi9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmgKQEAgLTUxLDYgKzUxLDggQEAgU3RyaW5nIHF1b3Rl QW5kRXNjYXBlTm9uUHJpbnRhYmxlcyhjb25zdCBTdHJpbmcmKTsKIAogU3RyaW5nIGNvdW50ZXJW YWx1ZUZvckVsZW1lbnQoRWxlbWVudCopOwogCitTdHJpbmcgbWFya2VyVGV4dEZvckxpc3RJdGVt KEVsZW1lbnQqKTsKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gUmVuZGVy VHJlZUFzVGV4dF9oCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktpdC9n dGsvQ2hhbmdlTG9nCmluZGV4IDE1ZWZmN2MuLjQwMDExMWQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9n dGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTAtMDQtMDUgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0g bWFya2VycyBhcmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisK KyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgorICAgICAgICAqIHdlYmtpdC93ZWJr aXR3ZWJmcmFtZS5jcHA6CisgICAgICAgICh3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zv cl9saXN0X2l0ZW0pOiBBZGQgYSBwcml2YXRlIEFQSSB0byBnZXQgdGhlIG1hcmtlciB0ZXh0IGZv ciBhIGxpc3QgaXRlbS4KKwogMjAxMC0wNC0wMSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3Vz dGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KIAogICAgICAgICBSZXZpZXdlZCBieSBIb2xn ZXIgRnJleXRoZXIuCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXggZDAwMDBiMS4uN2Rj YmQ2NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtMzE1LDYgKzMxNSw5IEBAIGV4 dGVybiAiQyIgewogICAgIFdFQktJVF9BUEkgYm9vbAogICAgIHdlYmtpdF93ZWJfZnJhbWVfcGF1 c2Vfc3ZnX2FuaW1hdGlvbihXZWJLaXRXZWJGcmFtZSogZnJhbWUsIGNvbnN0IGdjaGFyKiBhbmlt YXRpb25JZCwgZG91YmxlIHRpbWUsIGNvbnN0IGdjaGFyKiBlbGVtZW50SWQpOwogCisgICAgV0VC S0lUX0FQSSBnY2hhcioKKyAgICB3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0 X2l0ZW0oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBKU1ZhbHVlUmVmIG5vZGVPYmplY3QpOworCiAg ICAgV0VCS0lUX0FQSSB1bnNpZ25lZCBpbnQKICAgICB3ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9v Zl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwogCmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggOTUzOGQyNy4uYjgzOTNjZiAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNDcsOCArNDcsMTAgQEAKICNpbmNsdWRlICJHdGtW ZXJzaW9uaW5nLmgiCiAjaW5jbHVkZSAiSFRNTEZyYW1lT3duZXJFbGVtZW50LmgiCiAjaW5jbHVk ZSAiSlNET01XaW5kb3cuaCIKKyNpbmNsdWRlICJKU0VsZW1lbnQuaCIKICNpbmNsdWRlICJKU0xv Y2suaCIKICNpbmNsdWRlICJQcmludENvbnRleHQuaCIKKyNpbmNsdWRlICJSZW5kZXJMaXN0SXRl bS5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJSZW5kZXJUcmVlQXNUZXh0 LmgiCiAjaW5jbHVkZSAiSlNET01CaW5kaW5nLmgiCkBAIC0xMDQzLDYgKzEwNDUsMTYgQEAgYm9v bCB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3N2Z19hbmltYXRpb24oV2ViS2l0V2ViRnJhbWUqIGZy YW1lLCBjb25zdCBnY2hhciogYW4KICNlbmRpZgogfQogCitnY2hhciogd2Via2l0X3dlYl9mcmFt ZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgSlNWYWx1 ZVJlZiBub2RlT2JqZWN0KQoreworICAgIEVsZW1lbnQqIGVsZW1lbnQgPSB0b0VsZW1lbnQodG9K UygwLCBub2RlT2JqZWN0KSk7CisgICAgaWYgKCFlbGVtZW50KQorICAgICAgICByZXR1cm4gMDsK KworICAgIFN0cmluZyBtYXJrZXJUZXh0ID0gbWFya2VyVGV4dEZvckxpc3RJdGVtKGVsZW1lbnQp OworICAgIHJldHVybiBnX3N0cmR1cChtYXJrZXJUZXh0LnV0ZjgoKS5kYXRhKCkpOworfQorCiB1 bnNpZ25lZCBpbnQgd2Via2l0X3dlYl9mcmFtZV9udW1iZXJfb2ZfYWN0aXZlX2FuaW1hdGlvbnMo V2ViS2l0V2ViRnJhbWUqIGZyYW1lKQogewogICAgIEZyYW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZy YW1lKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmVsZW1lbnQuaCBiL1dlYktpdC9x dC9BcGkvcXdlYmVsZW1lbnQuaAppbmRleCBhODdkMzg4Li5mMWJkZjRlIDEwMDY0NAotLS0gYS9X ZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50LmgKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVu dC5oCkBAIC0xNTUsNiArMTU1LDcgQEAgcHJpdmF0ZToKICAgICBzdGF0aWMgUVdlYkVsZW1lbnQg ZW5jbG9zaW5nRWxlbWVudChXZWJDb3JlOjpOb2RlKik7CiAKICAgICBmcmllbmQgY2xhc3MgUVdl YkZyYW1lOworICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJhbWVQcml2YXRlOwogICAgIGZyaWVuZCBj bGFzcyBRV2ViRWxlbWVudENvbGxlY3Rpb247CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJIaXRUZXN0 UmVzdWx0OwogICAgIGZyaWVuZCBjbGFzcyBRV2ViSGl0VGVzdFJlc3VsdFByaXZhdGU7CmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJm cmFtZS5jcHAKaW5kZXggM2JiY2ZlMi4uMzBhZjQ3YiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0Fw aS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNDgs NiArNDgsNyBAQAogI2luY2x1ZGUgIlBsYXRmb3JtV2hlZWxFdmVudC5oIgogI2luY2x1ZGUgIlBy aW50Q29udGV4dC5oIgogI2luY2x1ZGUgIlB1dFByb3BlcnR5U2xvdC5oIgorI2luY2x1ZGUgIlJl bmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVyVHJlZUFzVGV4dC5oIgogI2luY2x1ZGUg IlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKQEAgLTI3NSw2ICsy NzYsMTcgQEAgdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfZXZhbHVhdGVTY3JpcHRJbklzb2xh dGVkV29ybGQoUVdlYkZyYW1lKiBxRnJhbWUsIGludAogICAgICAgICBKU0M6OkpTVmFsdWUgcmVz dWx0ID0gZnJhbWUtPnNjcmlwdCgpLT5leGVjdXRlU2NyaXB0SW5Xb3JsZChtYWluVGhyZWFkTm9y bWFsV29ybGQoKSwgc2NyaXB0LCB0cnVlKS5qc1ZhbHVlKCk7CiB9CiAKK1FTdHJpbmcgUVdlYkZy YW1lUHJpdmF0ZTo6bWFya2VyVGV4dEZvckxpc3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0 SXRlbSkKK3sKKyAgICBFbGVtZW50KiBlbGVtZW50ID0gbGlzdEl0ZW0ubV9lbGVtZW50OworICAg IHJldHVybiBXZWJDb3JlOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oZWxlbWVudCk7Cit9CisKK1FT dHJpbmcgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X21hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBR V2ViRWxlbWVudCYgbGlzdEl0ZW0pCit7CisgICAgcmV0dXJuIFFXZWJGcmFtZVByaXZhdGU6Om1h cmtlclRleHRGb3JMaXN0SXRlbShsaXN0SXRlbSk7Cit9CisKIHN0YXRpYyBib29sIHdlYmZyYW1l X3Njcm9sbE92ZXJmbG93KFdlYkNvcmU6OkZyYW1lKiBmcmFtZSwgaW50IGR4LCBpbnQgZHksIGNv bnN0IFFQb2ludCYgcG9zKQogewogICAgIGlmICghZnJhbWUgfHwgIWZyYW1lLT5kb2N1bWVudCgp IHx8ICFmcmFtZS0+ZXZlbnRIYW5kbGVyKCkpCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3 ZWJmcmFtZV9wLmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmgKaW5kZXggZmNjMzdlNy4u MjU1NmQzMCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWVfcC5oCisrKyBiL1dl YktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaApAQCAtODgsNiArODgsOCBAQCBwdWJsaWM6CiAgICAg dm9pZCByZW5kZXJGcm9tVGlsZWRCYWNraW5nU3RvcmUoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0 KiwgY29uc3QgUVJlZ2lvbiYgY2xpcCk7CiAjZW5kaWYKIAorICAgIHN0YXRpYyBRU3RyaW5nIG1h cmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pOworCiAgICAg UVdlYkZyYW1lICpxOwogICAgIFF0OjpTY3JvbGxCYXJQb2xpY3kgaG9yaXpvbnRhbFNjcm9sbEJh clBvbGljeTsKICAgICBRdDo6U2Nyb2xsQmFyUG9saWN5IHZlcnRpY2FsU2Nyb2xsQmFyUG9saWN5 OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cK aW5kZXggN2YzYmQxNi4uZDVmMjA3ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxvZwor KysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDQtMDUgIEph a3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBhcmUgbm90 IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAgKiBBcGkv cXdlYmVsZW1lbnQuaDoKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmNwcDoKKyAgICAgICAgKFFX ZWJGcmFtZVByaXZhdGU6Om1hcmtlclRleHRGb3JMaXN0SXRlbSk6CisgICAgICAgIChxdF9kcnRf bWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgcHJpdmF0ZSBBUEkgdG8gZ2V0IHRoZSBtYXJr ZXIgdGV4dCBmb3IgYSBsaXN0IGl0ZW0uCisgICAgICAgICogQXBpL3F3ZWJmcmFtZV9wLmg6CisK IDIwMTAtMDQtMDIgIExhc3psbyBHb21ib3MgIDxsYXN6bG8uMS5nb21ib3NAbm9raWEuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuLgpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4 IDM4ZWY0YWEuLmJiYjkxNjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZworKysg Yi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAxMC0wNC0wNSAgSmFr dWIgV2llY3pvcmVrICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExpc3QgaXRlbSBtYXJrZXJzIGFyZSBub3Qg YWx3YXlzIHVwZGF0ZWQgYWZ0ZXIgY2hhbmdlcyBpbiB0aGUgRE9NLgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzcwNjAKKworICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKG1hcmtlclRleHRG b3JMaXN0SXRlbUNhbGxiYWNrKTogQSBmdW5jdGlvbiB0aGF0IHJldHVybnMgdGhlIG1hcmtlciB0 ZXh0IGZvciBhIGdpdmVuIGxpc3QgaXRlbS4KKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy OjpzdGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RD b250cm9sbGVyLmg6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250 cm9sbGVyR3RrLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0 Rm9yTGlzdEl0ZW0pOiBJbXBsZW1lbnQgaXQgaW4gdGhlIEdUSyBwb3J0LgorICAgICAgICAqIER1 bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbToKKyAgICAgICAgKExh eW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBBZGQgYSBzdHViLgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwOgor ICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKToKKyAg ICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBJbXBs ZW1lbnQgaXQgaW4gdGhlIFF0IHBvcnQuCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvcXQvTGF5 b3V0VGVzdENvbnRyb2xsZXJRdC5oOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlv dXRUZXN0Q29udHJvbGxlcldpbi5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 bWFya2VyVGV4dEZvckxpc3RJdGVtKTogQWRkIGEgc3R1Yi4KKwogMjAxMC0wNC0wNSAgQ2hyaXMg SmVyZG9uZWsgIDxjamVyZG9uZWtAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBT aGluaWNoaXJvIEhhbWFqaS4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCAyNTU0ZmE0Li42NmI1MDUzIDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKKysr IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBA IC0xMzMxLDYgKzEzMzEsMTQgQEAgc3RhdGljIEpTVmFsdWVSZWYgYXBpVGVzdEdvVG9DdXJyZW50 QmFja0ZvcndhcmRJdGVtQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQKICAgICByZXR1cm4g SlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG1h cmtlclRleHRGb3JMaXN0SXRlbUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVj dFJlZiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0 IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBM YXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RD b250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBpZiAoYXJn dW1lbnRDb3VudCA8IDEpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250 ZXh0KTsKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VTdHJpbmcoY29udGV4dCwgY29udHJvbGxlci0+ bWFya2VyVGV4dEZvckxpc3RJdGVtKGFyZ3VtZW50c1swXSkuZ2V0KCkpOworfQorCiAvLyBTdGF0 aWMgVmFsdWVzCiAKIHN0YXRpYyBKU1ZhbHVlUmVmIGdldEdsb2JhbEZsYWdDYWxsYmFjayhKU0Nv bnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgSlNTdHJpbmdSZWYgcHJv cGVydHlOYW1lLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCkBAIC0xNDQ0LDYgKzE0NTIsNyBAQCBK U1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkK ICAgICAgICAgeyAia2VlcFdlYkhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQ cm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRl IH0sCiAgICAgICAgIHsgImxheWVyVHJlZUFzVGV4dCIsIGxheWVyVHJlZUFzVGV4dENhbGxiYWNr LCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250 RGVsZXRlIH0sCiAgICAgICAgIHsgIm51bWJlck9mUGFnZXMiLCBudW1iZXJPZlBhZ2VzQ2FsbGJh Y2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURv bnREZWxldGUgfSwKKyAgICAgICAgeyAibWFya2VyVGV4dEZvckxpc3RJdGVtIiwgbWFya2VyVGV4 dEZvckxpc3RJdGVtQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQ cm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5v dGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3Bl cnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJudW1iZXJPZkFjdGl2ZUFuaW1h dGlvbnMiLCBudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRy aWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAg ICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFjaywga0pT UHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0 ZSB9LApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9s bGVyLmgKaW5kZXggM2M3MGY5OC4uNDY0OWRlOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCkBAIC0yNDgsNiArMjQ4LDggQEAgcHVi bGljOgogICAgIAogICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBsYXllclRyZWVBc1RleHQo KSBjb25zdDsKIAorICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBtYXJrZXJUZXh0Rm9yTGlz dEl0ZW0oSlNWYWx1ZVJlZiBub2RlT2JqZWN0KSBjb25zdDsKKwogICAgIHN0YXRpYyBjb25zdCB1 bnNpZ25lZCBtYXhWaWV3V2lkdGg7CiAgICAgc3RhdGljIGNvbnN0IHVuc2lnbmVkIG1heFZpZXdI ZWlnaHQ7CiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlv dXRUZXN0Q29udHJvbGxlckd0ay5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsv TGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCmluZGV4IDdjMWI2ZTcuLjE3ZmZjN2MgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxl ckd0ay5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RD b250cm9sbGVyR3RrLmNwcApAQCAtNTgsNiArNTgsNyBAQCBnY2hhciogd2Via2l0X3dlYl9mcmFt ZV9jb3VudGVyX3ZhbHVlX2Zvcl9lbGVtZW50X2J5X2lkKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwg YwogaW50IHdlYmtpdF93ZWJfZnJhbWVfcGFnZV9udW1iZXJfZm9yX2VsZW1lbnRfYnlfaWQoV2Vi S2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogaWQsIGZsb2F0IHBhZ2VXaWR0aCwgZmxv YXQgcGFnZUhlaWdodCk7CiBpbnQgd2Via2l0X3dlYl9mcmFtZV9udW1iZXJfb2ZfcGFnZXMoV2Vi S2l0V2ViRnJhbWUqIGZyYW1lLCBmbG9hdCBwYWdlV2lkdGgsIGZsb2F0IHBhZ2VIZWlnaHQpOwog dm9pZCB3ZWJraXRfd2ViX2luc3BlY3Rvcl9leGVjdXRlX3NjcmlwdChXZWJLaXRXZWJJbnNwZWN0 b3IqIGluc3BlY3RvciwgbG9uZyBjYWxsSWQsIGNvbnN0IGdjaGFyKiBzY3JpcHQpOworZ2NoYXIq IHdlYmtpdF93ZWJfZnJhbWVfbWFya2VyX3RleHRfZm9yX2xpc3RfaXRlbShXZWJLaXRXZWJGcmFt ZSogZnJhbWUsIEpTVmFsdWVSZWYgbm9kZU9iamVjdCk7CiB9CiAKIHN0YXRpYyBnY2hhciogY29w eVdlYlNldHRpbmdLZXkoZ2NoYXIqIHByZWZlcmVuY2VLZXkpCkBAIC02NDMsMyArNjQ0LDE0IEBA IHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmFwaVRlc3RHb1RvQ3VycmVudEJhY2tGb3J3YXJk SXRlbSgpCiB7CiAKIH0KKworSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250 cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNWYWx1ZVJlZiBub2RlT2JqZWN0KSBjb25z dAoreworICAgIGdjaGFyKiBtYXJrZXJUZXh0R0NoYXIgPSB3ZWJraXRfd2ViX2ZyYW1lX21hcmtl cl90ZXh0X2Zvcl9saXN0X2l0ZW0obWFpbkZyYW1lLCBub2RlT2JqZWN0KTsKKyAgICBpZiAoIW1h cmtlclRleHRHQ2hhcikKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBKU1JldGFpblB0cjxKU1N0 cmluZ1JlZj4gbWFya2VyVGV4dChBZG9wdCwgSlNTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmco bWFya2VyVGV4dEdDaGFyKSk7CisgICAgZ19mcmVlKG1hcmtlclRleHRHQ2hhcik7CisgICAgcmV0 dXJuIG1hcmtlclRleHQ7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KaW5kZXggZjMzMjYzMC4uMmEwYjRi MSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RD b250cm9sbGVyTWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlv dXRUZXN0Q29udHJvbGxlck1hYy5tbQpAQCAtMTg3LDYgKzE4NywxMiBAQCBKU1JldGFpblB0cjxK U1N0cmluZ1JlZj4gTGF5b3V0VGVzdENvbnRyb2xsZXI6OmxheWVyVHJlZUFzVGV4dCgpIGNvbnN0 CiAgICAgcmV0dXJuIHN0cmluZzsKIH0KIAorSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91 dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNWYWx1ZVJlZiBub2RlT2Jq ZWN0KSBjb25zdAoreworICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgbWUuCisgICAgcmV0dXJuIEpT UmV0YWluUHRyPEpTU3RyaW5nUmVmPigpOworfQorCiBpbnQgTGF5b3V0VGVzdENvbnRyb2xsZXI6 OnBhZ2VOdW1iZXJGb3JFbGVtZW50QnlJZChKU1N0cmluZ1JlZiBpZCwgZmxvYXQgcGFnZVdpZHRo SW5QaXhlbHMsIGZsb2F0IHBhZ2VIZWlnaHRJblBpeGVscykKIHsKICAgICBSZXRhaW5QdHI8Q0ZT dHJpbmdSZWY+IGlkQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9y RGVmYXVsdCwgaWQpKTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0 L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv cXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHAKaW5kZXggYjY0ODBjMi4uMjQzOWI4ZiAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xs ZXJRdC5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENv bnRyb2xsZXJRdC5jcHAKQEAgLTU5LDExICs1OSwxMyBAQCBleHRlcm4gdm9pZCBxdF9kcnRfd2Vi aW5zcGVjdG9yX2V4ZWN1dGVTY3JpcHQoUVdlYlBhZ2UqIHBhZ2UsIGxvbmcgY2FsbElkLCBjb25z dAogZXh0ZXJuIHZvaWQgcXRfZHJ0X3dlYmluc3BlY3Rvcl9zaG93KFFXZWJQYWdlICpwYWdlKTsK IGV4dGVybiB2b2lkIHF0X2RydF93ZWJpbnNwZWN0b3JfY2xvc2UoUVdlYlBhZ2UgKnBhZ2UpOwog ZXh0ZXJuIHZvaWQgcXRfZHJ0X2VuYWJsZUNhcmV0QnJvd3NpbmcoUVdlYlBhZ2UqIHBhZ2UsIGJv b2wgdmFsdWUpOworZXh0ZXJuIFFTdHJpbmcgcXRfZHJ0X21hcmtlclRleHRGb3JMaXN0SXRlbShj b25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pOwogCiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5 b3V0VGVzdENvbnRyb2xsZXIoV2ViQ29yZTo6RHVtcFJlbmRlclRyZWUqIGRydCkKICAgICA6IFFP YmplY3QoKQogICAgICwgbV9kcnQoZHJ0KQogeworICAgIHFSZWdpc3Rlck1ldGFUeXBlPFFXZWJF bGVtZW50PigiUVdlYkVsZW1lbnQiKTsKICAgICByZXNldCgpOwogfQogCkBAIC01NDEsNSArNTQz LDEwIEBAIGJvb2wgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmNhbGxTaG91bGRDbG9zZU9uV2ViVmll dygpCiAgICAgcmV0dXJuIGZhbHNlOwogfQogCitRU3RyaW5nIExheW91dFRlc3RDb250cm9sbGVy OjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKQorewor ICAgIHJldHVybiBxdF9kcnRfbWFya2VyVGV4dEZvckxpc3RJdGVtKGxpc3RJdGVtKTsKK30KKwog Y29uc3QgdW5zaWduZWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1heFZpZXdXaWR0aCA9IDgwMDsK IGNvbnN0IHVuc2lnbmVkIExheW91dFRlc3RDb250cm9sbGVyOjptYXhWaWV3SGVpZ2h0ID0gNjAw OwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENv bnRyb2xsZXJRdC5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENv bnRyb2xsZXJRdC5oCmluZGV4IDM2YjVmNzAuLjg1ZTVmZTUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuaAorKysgYi9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmgKQEAgLTQw LDYgKzQwLDcgQEAKICNpbmNsdWRlIDxRVmFyaWFudD4KIAogI2luY2x1ZGUgPHF3ZWJkYXRhYmFz ZS5oPgorI2luY2x1ZGUgPHF3ZWJlbGVtZW50Lmg+CiAjaW5jbHVkZSA8cXdlYmZyYW1lLmg+CiAj aW5jbHVkZSA8cXdlYmhpc3RvcnkuaD4KICNpbmNsdWRlIDxxd2VicGFnZS5oPgpAQCAtMTY1LDYg KzE2Niw4IEBAIHB1YmxpYyBzbG90czoKICAgICBpbnQgbnVtYmVyT2ZQYWdlcyhmbG9hdCB3aWR0 aCA9IG1heFZpZXdXaWR0aCwgZmxvYXQgaGVpZ2h0ID0gbWF4Vmlld0hlaWdodCk7CiAgICAgYm9v bCBjYWxsU2hvdWxkQ2xvc2VPbldlYlZpZXcoKTsKIAorICAgIFFTdHJpbmcgbWFya2VyVGV4dEZv ckxpc3RJdGVtKGNvbnN0IFFXZWJFbGVtZW50JiBsaXN0SXRlbSk7CisKIHByaXZhdGUgc2xvdHM6 CiAgICAgdm9pZCBwcm9jZXNzV29yaygpOwogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAppbmRleCBhZDc1 N2U0Li41ZWY4Y2NjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4v TGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKQEAgLTE4OCw2ICsxODgsMTIgQEAg SlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVyOjpsYXllclRyZWVB c1RleHQoKSBjb25zdAogICAgIHJldHVybiB0ZXh0VmFsdWVKUzsKIH0KIAorSlNSZXRhaW5QdHI8 SlNTdHJpbmdSZWY+IExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0o SlNWYWx1ZVJlZiBub2RlT2JqZWN0KSBjb25zdAoreworICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQg bWUuCisgICAgcmV0dXJuIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPigpOworfQorCiB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjp3YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQogewogICAgIC8vIEZJ WE1FOiBJbXBsZW1lbnQgdGhpcy4K 52910 2010-04-08 16:04:05 -0700 2010-04-09 15:20:53 -0700 2nd changeset enclosingList-detached-from-dom.patch text/plain 1494 jwieczorek ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NGFjYTQ5Yi4uOTY5YjRhNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNC0wOCAgSmFrdWIgV2llY3pv cmVrICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJlbmRlckxpc3RJdGVtOiBtYWtlIGVuY2xvc2luZ0xpc3Qo KSBzYWZlIHRvIHVzZSBhZnRlciBkZXRhY2htZW50IGZyb20gdGhlIERPTSB0cmVlLgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzcwNjAKKworICAgICAg ICBDb3ZlcmVkIGJ5IGV4aXN0aW5nIHRlc3RzLgorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRl ckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVuY2xvc2luZ0xpc3QpOiBGYWxsIGJh Y2sgdG8gd2Fsa2luZyB1cCB0aGUgcmVuZGVyIHRyZWUgd2hlbiB1bmFibGUgdG8gb2J0YWluCisg ICAgICAgIHRoZSBlbmNsb3NpbmcgbGlzdCBmcm9tIHRoZSBpdGVtJ3Mgbm9kZS4KKwogMjAxMC0w NC0wOCAgQmVuamFtaW4gT3R0ZSAgPG90dGVAZ25vbWUub3JnPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IEd1c3Rhdm8gTm9yb25oYS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckxpc3RJdGVtLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmNwcAppbmRl eCA1NGE3ZGQyLi5hYjdhZTYwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJM aXN0SXRlbS5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCkBA IC05NSw4ICs5NSwxMyBAQCBzdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChOb2RlKiBub2RlKQog c3RhdGljIE5vZGUqIGVuY2xvc2luZ0xpc3QoY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlcikK IHsKICAgICBOb2RlKiBub2RlID0gcmVuZGVyZXItPm5vZGUoKTsKLSAgICBpZiAobm9kZSkKLSAg ICAgICAgcmV0dXJuIGVuY2xvc2luZ0xpc3Qobm9kZSk7CisgICAgaWYgKG5vZGUpIHsKKyAgICAg ICAgLy8gVGhlIGl0ZW0gbWlnaHQgYmUgZGV0YWNoZWQgZnJvbSB0aGUgRE9NIHRyZWUgYXQgdGhp cyBwb2ludCwgaW4gdGhpcyBjYXNlCisgICAgICAgIC8vIHdlIHNob3VsZCB0cnkgZm9sbG93aW5n IHRoZSByZW5kZXIgdHJlZSwgd2hpY2ggY2FuIGdpdmUgdXMgdGhlIHJpZ2h0IGxpc3QuCisgICAg ICAgIE5vZGUqIGxpc3ROb2RlID0gZW5jbG9zaW5nTGlzdChub2RlKTsKKyAgICAgICAgaWYgKGxp c3ROb2RlKQorICAgICAgICAgICAgcmV0dXJuIGxpc3ROb2RlOworICAgIH0KIAogICAgIHJlbmRl cmVyID0gcmVuZGVyZXItPnBhcmVudCgpOwogICAgIHdoaWxlIChyZW5kZXJlciAmJiAhcmVuZGVy ZXItPm5vZGUoKSkK 52999 2010-04-09 15:20:53 -0700 2010-04-20 10:48:28 -0700 Use render tree to find the enclosing list enclosing-list-render-tree.patch text/plain 3568 jwieczorek ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTg0ZWIxNC4uMDY0ZjNiZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAxMC0wNC0wOSAgSmFrdWIgV2llY3pv cmVrICA8andpZWN6b3Jla0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJlbmRlckxpc3RJdGVtOiBjaGFuZ2UgZW5jbG9zaW5nTGlz dCgpIHRvIG9ubHkgdHJhdmVyc2UgdGhlIHJlbmRlciB0cmVlLgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzczMTkKKworICAgICAgICBUaGlzIG1ha2Vz IHRoZSBmdW5jdGlvbiBzYWZlIHRvIHVzZSBmb3IgaXRlbXMgd2l0aCBub2RlcyB0aGF0IGFyZSBk ZXRhY2hlZCBmcm9tCisgICAgICAgIHRoZSBET00gdHJlZSBhbmQgc2ltcGxpZmllcyB0aGUgY29k ZSBxdWl0ZSBhIGJpdC4KKworICAgICAgICBDb3ZlcmVkIGJ5IGV4aXN0aW5nIHRlc3RzLgorCisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OmVuY2xvc2luZ0xpc3QpOgorICAgICAgICAoV2ViQ29yZTo6cHJldmlvdXNMaXN0SXRlbSk6Cisg ICAgICAgIChXZWJDb3JlOjpSZW5kZXJMaXN0SXRlbTo6ZXhwbGljaXRWYWx1ZUNoYW5nZWQpOgor CiAyMDEwLTA0LTA5ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxlLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBZGFtIFJvYmVuLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyTGlzdEl0ZW0uY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlzdEl0ZW0uY3BwCmlu ZGV4IDU0YTdkZDIuLjVlMmUxNjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckxpc3RJdGVtLmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAK QEAgLTgwLDMzICs4MCwyNCBAQCBzdGF0aWMgYm9vbCBpc0xpc3QoTm9kZSogbm9kZSkKICAgICBy ZXR1cm4gKG5vZGUtPmhhc1RhZ05hbWUodWxUYWcpIHx8IG5vZGUtPmhhc1RhZ05hbWUob2xUYWcp KTsKIH0KIAotc3RhdGljIE5vZGUqIGVuY2xvc2luZ0xpc3QoTm9kZSogbm9kZSkKK3N0YXRpYyBO b2RlKiBlbmNsb3NpbmdMaXN0KGNvbnN0IFJlbmRlckxpc3RJdGVtKiBsaXN0SXRlbSkKIHsKLSAg ICBOb2RlKiBwYXJlbnQgPSBub2RlLT5wYXJlbnROb2RlKCk7Ci0gICAgZm9yIChOb2RlKiBuID0g cGFyZW50OyBuOyBuID0gbi0+cGFyZW50Tm9kZSgpKQotICAgICAgICBpZiAoaXNMaXN0KG4pKQot ICAgICAgICAgICAgcmV0dXJuIG47Ci0gICAgLy8gSWYgdGhlcmUncyBubyBhY3R1YWwgPHVsPiBv ciA8b2w+IGxpc3QgZWxlbWVudCwgdGhlbiBvdXIgcGFyZW50IGFjdHMgYXMKLSAgICAvLyBvdXIg bGlzdCBmb3IgcHVycG9zZXMgb2YgZGV0ZXJtaW5pbmcgd2hhdCBvdGhlciBsaXN0IGl0ZW1zIHNo b3VsZCBiZQotICAgIC8vIG51bWJlcmVkIGFzIHBhcnQgb2YgdGhlIHNhbWUgbGlzdC4KLSAgICBy ZXR1cm4gcGFyZW50OwotfQotCi1zdGF0aWMgTm9kZSogZW5jbG9zaW5nTGlzdChjb25zdCBSZW5k ZXJPYmplY3QqIHJlbmRlcmVyKQotewotICAgIE5vZGUqIG5vZGUgPSByZW5kZXJlci0+bm9kZSgp OwotICAgIGlmIChub2RlKQotICAgICAgICByZXR1cm4gZW5jbG9zaW5nTGlzdChub2RlKTsKLQot ICAgIHJlbmRlcmVyID0gcmVuZGVyZXItPnBhcmVudCgpOwotICAgIHdoaWxlIChyZW5kZXJlciAm JiAhcmVuZGVyZXItPm5vZGUoKSkKLSAgICAgICAgcmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50 KCk7Ci0KLSAgICBub2RlID0gcmVuZGVyZXItPm5vZGUoKTsKLSAgICBpZiAoaXNMaXN0KG5vZGUp KQotICAgICAgICByZXR1cm4gbm9kZTsKKyAgICBOb2RlKiBmaXJzdE5vZGUgPSAwOworCisgICAg Zm9yIChjb25zdCBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gbGlzdEl0ZW0tPnBhcmVudCgpOyBy ZW5kZXJlcjsgcmVuZGVyZXIgPSByZW5kZXJlci0+cGFyZW50KCkpIHsKKyAgICAgICAgTm9kZSog bm9kZSA9IHJlbmRlcmVyLT5ub2RlKCk7CisgICAgICAgIGlmIChub2RlKSB7CisgICAgICAgICAg ICBpZiAoaXNMaXN0KG5vZGUpKQorICAgICAgICAgICAgICAgIHJldHVybiBub2RlOworICAgICAg ICAgICAgaWYgKCFmaXJzdE5vZGUpCisgICAgICAgICAgICAgICAgZmlyc3ROb2RlID0gbm9kZTsK KyAgICAgICAgfQorICAgIH0KIAotICAgIHJldHVybiBlbmNsb3NpbmdMaXN0KG5vZGUpOworICAg IC8vIElmIHRoZXJlJ3Mgbm8gYWN0dWFsIDx1bD4gb3IgPG9sPiBsaXN0IGVsZW1lbnQsIHRoZW4g dGhlIGZpcnN0IGZvdW5kCisgICAgLy8gbm9kZSBhY3RzIGFzIG91ciBsaXN0IGZvciBwdXJwb3Nl cyBvZiBkZXRlcm1pbmluZyB3aGF0IG90aGVyIGxpc3QgaXRlbXMKKyAgICAvLyBzaG91bGQgYmUg bnVtYmVyZWQgYXMgcGFydCBvZiB0aGUgc2FtZSBsaXN0LgorICAgIHJldHVybiBmaXJzdE5vZGU7 CiB9CiAKIHN0YXRpYyBSZW5kZXJMaXN0SXRlbSogcHJldmlvdXNMaXN0SXRlbShOb2RlKiBsaXN0 LCBjb25zdCBSZW5kZXJMaXN0SXRlbSogaXRlbSkKQEAgLTExNCw3ICsxMDUsNyBAQCBzdGF0aWMg UmVuZGVyTGlzdEl0ZW0qIHByZXZpb3VzTGlzdEl0ZW0oTm9kZSogbGlzdCwgY29uc3QgUmVuZGVy TGlzdEl0ZW0qIGl0ZW0pCiAgICAgZm9yIChSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gaXRlbS0+ cHJldmlvdXNJblByZU9yZGVyKCk7IHJlbmRlcmVyICE9IGxpc3QtPnJlbmRlcmVyKCk7IHJlbmRl cmVyID0gcmVuZGVyZXItPnByZXZpb3VzSW5QcmVPcmRlcigpKSB7CiAgICAgICAgIGlmICghcmVu ZGVyZXItPmlzTGlzdEl0ZW0oKSkKICAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICBOb2Rl KiBvdGhlckxpc3QgPSBlbmNsb3NpbmdMaXN0KHJlbmRlcmVyKTsKKyAgICAgICAgTm9kZSogb3Ro ZXJMaXN0ID0gZW5jbG9zaW5nTGlzdCh0b1JlbmRlckxpc3RJdGVtKHJlbmRlcmVyKSk7CiAgICAg ICAgIC8vIFRoaXMgaXRlbSBpcyBwYXJ0IG9mIG91ciBjdXJyZW50IGxpc3QsIHNvIGl0J3Mgd2hh dCB3ZSdyZSBsb29raW5nIGZvci4KICAgICAgICAgaWYgKGxpc3QgPT0gb3RoZXJMaXN0KQogICAg ICAgICAgICAgcmV0dXJuIHRvUmVuZGVyTGlzdEl0ZW0ocmVuZGVyZXIpOwpAQCAtMzI2LDcgKzMx Nyw3IEBAIHZvaWQgUmVuZGVyTGlzdEl0ZW06OmV4cGxpY2l0VmFsdWVDaGFuZ2VkKCkKIHsKICAg ICBpZiAobV9tYXJrZXIpCiAgICAgICAgIG1fbWFya2VyLT5zZXROZWVkc0xheW91dEFuZFByZWZX aWR0aHNSZWNhbGMoKTsKLSAgICBOb2RlKiBsaXN0Tm9kZSA9IGVuY2xvc2luZ0xpc3Qobm9kZSgp KTsKKyAgICBOb2RlKiBsaXN0Tm9kZSA9IGVuY2xvc2luZ0xpc3QodGhpcyk7CiAgICAgUmVuZGVy T2JqZWN0KiBsaXN0UmVuZGVyZXIgPSAwOwogICAgIGlmIChsaXN0Tm9kZSkKICAgICAgICAgbGlz dFJlbmRlcmVyID0gbGlzdE5vZGUtPnJlbmRlcmVyKCk7Cg== 53896 2010-04-20 15:35:05 -0700 2010-04-20 17:26:18 -0700 patch 37060.patch text/plain 38291 jwieczorek ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkNTVjYjQ4Li5kYjExN2QyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDQt MjAgIEpha3ViIFdpZWN6b3JlayAgPGp3aWVjem9yZWtAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMaXN0IGl0ZW0gbWFya2VycyBh cmUgbm90IGFsd2F5cyB1cGRhdGVkIGFmdGVyIGNoYW5nZXMgaW4gdGhlIERPTS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3MDYwCisKKyAgICAgICAg KiBmYXN0L2xpc3RzL2R1bXAtbGlzdC5qczoKKyAgICAgICAgKGluZGVudCk6CisgICAgICAgIChk dW1wTGlzdEhlbHBlcik6IEEgcmVjdXJzaXZlIGZ1bmN0aW9uIHRvIGR1bXAgbmVzdGVkIGxpc3Rz LgorICAgICAgICAoZHVtcExpc3QpOiBBIGZ1bmN0aW9uIHRoYXQgZHVtcHMgYSByZWFkYWJsZSBw bGFpbiB0ZXh0IHJlcHJlc2VudGF0aW9uIG9mIGEgbGlzdC4KKyAgICAgICAgKiBmYXN0L2xpc3Rz L29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtcmVtb3Zl LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMtZHluYW1pYy1yZW1vdmUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1u ZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1saXN0LWR5bmFtaWMtaW5zZXJ0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFz dC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLXJl bW92ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDogU2tpcCB0aGUgdGVz dHMgdW50aWwgdGhpcyBwb3J0IGltcGxlbWVudHMgdGhlIG5ldyBMYXlvdXRUZXN0Q29udHJvbGxl ciBmdW5jdGlvbi4KKwogMjAxMC0wNC0yMCAgSmFtZXMgUm9iaW5zb24gIDxqYW1lc3JAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQuICBVcGRhdGUgY2hyb21pdW0gdGVzdCBleHBl Y3RhdGlvbnMgdG8gcmVmbGVjdCBjaGFuZ2VzCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL2R1bXAtbGlzdC5qcyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvZHVtcC1saXN0Lmpz Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdkNTA5NzIKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL2R1bXAtbGlzdC5qcwpAQCAtMCwwICsxLDI2 IEBACitmdW5jdGlvbiBpbmRlbnQoZGVwdGgpCit7CisgICAgdmFyIHJldCA9IG5ldyBTdHJpbmco KTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IGRlcHRoOyArK2kpCisgICAgICAgIHJldCArPSAi LT4gIjsKKyAgICByZXR1cm4gcmV0ICsgIiAiOworfQorCitmdW5jdGlvbiBkdW1wTGlzdEhlbHBl cihlbGVtZW50LCBkZXB0aCkKK3sKKyAgICB2YXIgbGlzdCA9IG5ldyBTdHJpbmcoKTsKKworICAg IGZvciAodmFyIGNoaWxkID0gZWxlbWVudC5maXJzdEVsZW1lbnRDaGlsZDsgY2hpbGQ7IGNoaWxk ID0gY2hpbGQubmV4dEVsZW1lbnRTaWJsaW5nKSB7CisgICAgICAgIHZhciBtYXJrZXIgPSBsYXlv dXRUZXN0Q29udHJvbGxlci5tYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oY2hpbGQpOworICAgICAgICBp ZiAobWFya2VyKQorICAgICAgICAgICAgbGlzdCArPSBpbmRlbnQoZGVwdGgpICsgJyAnICsgbWFy a2VyICsgJyAnICsgY2hpbGQuaW5uZXJUZXh0LnRyaW0oKSArICc8YnI+JzsKKyAgICAgICAgbGlz dCArPSBkdW1wTGlzdEhlbHBlcihjaGlsZCwgZGVwdGggKyAxKTsKKyAgICB9CisKKyAgICByZXR1 cm4gbGlzdDsKK30KKworZnVuY3Rpb24gZHVtcExpc3QobGlzdCkKK3sKKyAgICByZXR1cm4gZHVt cExpc3RIZWxwZXIobGlzdCwgMCk7Cit9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xp c3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQgYi9MYXlvdXRU ZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjM5NjQ5NgotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMt aW5zZXJ0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE0IEBACitUaGlzIHRlc3RzIHRoYXQgbGlz dCBpdGVtIG1hcmtlcnMgYXJlIHVwZGF0ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGly ZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuCisKKzEgT25lCisyIFR3bworLT4gMyBU aHJlZQorNCBGb3VyCis1IEZpdmUKKzYgU2l4CistPiA3IFNldmVuCistPiA4IEVpZ2h0CistPiA5 IE5pbmUKKzEwIFRlbgorMTEgRWxldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWR5bmFtaWMtaW5zZXJ0Lmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjJmNDY5MjEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCkBA IC0wLDAgKzEsNTIgQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0i ZHVtcC1saXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24g dGVzdCgpCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBG b3JjZSBhIHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgibmVzdGVkIik7CisKKyAgICAgICAgICAgICAgICB2YXIgbGkxID0gZG9jdW1l bnQuY3JlYXRlRWxlbWVudCgibGkiKTsKKyAgICAgICAgICAgICAgICBsaTEuaW5uZXJUZXh0ID0g IkVpZ2h0IjsKKworICAgICAgICAgICAgICAgIHZhciBsaTIgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMi5pbm5lclRleHQgPSAiU2V2ZW4iOworCisg ICAgICAgICAgICAgICAgdmFyIGl0ZW0zID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7 CisgICAgICAgICAgICAgICAgaXRlbTMuaW5uZXJUZXh0ID0gIk5pbmUiOworICAgICAgICAgICAg ICAgIGl0ZW0zLnN0eWxlLmRpc3BsYXkgPSAibGlzdC1pdGVtIjsKKworICAgICAgICAgICAgICAg IHAuYXBwZW5kQ2hpbGQobGkxKTsKKyAgICAgICAgICAgICAgICBwLmluc2VydEJlZm9yZShsaTIs IGxpMSk7CisgICAgICAgICAgICAgICAgcC5hcHBlbmRDaGlsZChpdGVtMyk7CisKKyAgICAgICAg ICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1 bXBMaXN0KGxpc3QpOworCisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFs IGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAg ICAgICAgbGlzdC5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKGxpc3QpOworICAgICAgICAgICAgfQor ICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hlYWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCki PgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtlcnMgYXJlIHVwZGF0 ZWQgd2hlbiBhZGRpbmcgbmV3IGl0ZW1zIGFzIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0 IGVsZW1lbnQuPC9wPgorICAgICAgICA8b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9u ZTwvbGk+CisgICAgICAgICAgICA8bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDxkaXY+PGxpPlRo cmVlPC9saT48L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAgICAgIDxs aT5GaXZlPC9saT4KKyAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgPHAgaWQ9 Im5lc3RlZCI+PC9wPgorICAgICAgICAgICAgPGxpPlRlbjwvbGk+CisgICAgICAgICAgICA8bGk+ RWxldmVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAgICAgICA8ZGl2IGlkPSJjb25zb2xlIj48 L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1p Yy1yZW1vdmUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQt aXRlbXMtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLmJlNDUzMDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2xpc3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS1leHBlY3RlZC50eHQKQEAgLTAs MCArMSwxMCBAQAorVGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRhdGVk IHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMgdGhhdCBhcmUgbm90IGRpcmVjdCBjaGlsZHJl biBvZiB0aGUgbGlzdCBlbGVtZW50LgorCisxIE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgor NSBGaXZlCis2IFNpeAorNyBTZXZlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xp c3RzL29sLW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi43N2FlY2ExCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZHluYW1pYy1yZW1vdmUuaHRtbApAQCAt MCwwICsxLDUxIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBzcmM9ImR1 bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0aW9uIHRl c3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVz dENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1 bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBsaXN0Lm9mZnNldFRvcDsgLy8gRm9y Y2UgYSByZWxheW91dC4KKworICAgICAgICAgICAgICAgIHZhciBiID0gZG9jdW1lbnQuZ2V0RWxl bWVudHNCeVRhZ05hbWUoImIiKVswXTsKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxk KGIpOworCisgICAgICAgICAgICAgICAgdmFyIGRpdiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJuZXN0ZWQiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBkaXYuY2hpbGRyZW4ubGVu Z3RoOworICAgICAgICAgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgaXRlbXM7ICsraSkKKyAg ICAgICAgICAgICAgICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5maXJzdEVsZW1lbnRDaGlsZCk7 CisKKyAgICAgICAgICAgICAgICBsaXN0LnJlbW92ZUNoaWxkKGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJpdGVtIikpOworCisgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo ImNvbnNvbGUiKS5pbm5lckhUTUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAgICAgICAgICAgICAg IC8vIERvbid0IHNob3cgdGhlIGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxlc3MgaW4gdGhlIHRl eHQtb25seSBtb2RlLgorICAgICAgICAgICAgICAgIGxpc3QucGFyZW50Tm9kZS5yZW1vdmVDaGls ZChsaXN0KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgor ICAgIDxib2R5IG9ubG9hZD0idGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxp c3QgaXRlbSBtYXJrZXJzIGFyZSB1cGRhdGVkIHdoZW4gcmVtb3ZpbmcgZXhpc3RpbmcgaXRlbXMg dGhhdCBhcmUgbm90IGRpcmVjdCBjaGlsZHJlbiBvZiB0aGUgbGlzdCBlbGVtZW50LjwvcD4KKyAg ICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAgICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAg ICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAgICA8Yj48bGk+Rm9vPC9saT48L2I+CisgICAgICAg ICAgICA8bGk+VGhyZWU8L2xpPgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAg ICAgPGxpPkZpdmU8L2xpPgorICAgICAgICAgICAgPGRpdiBpZD0ibmVzdGVkIj4KKyAgICAgICAg ICAgICAgICA8bGk+Rm9vPC9saT4KKyAgICAgICAgICAgICAgICA8bGk+QmFyPC9saT4KKyAgICAg ICAgICAgICAgICA8bGk+QmF6PC9saT4KKyAgICAgICAgICAgIDwvZGl2PgorICAgICAgICAgICAg PGxpPlNpeDwvbGk+CisgICAgICAgICAgICA8ZGl2IGlkPSJpdGVtIiBzdHlsZT0iZGlzcGxheTog bGlzdC1pdGVtIj5Gb288L2Rpdj4KKyAgICAgICAgICAgIDxsaT5TZXZlbjwvbGk+CisgICAgICAg IDwvb2w+CisKKyAgICAgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5Pgor PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWl0ZW1zLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi5kMzRiMzY2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTUg QEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW1zIGFyZSBwcm9wZXJseSBtYXJrZWQgd2hlbiBz b21lIG9mIHRoZSBpdGVtcyBhcmUgaW5kaXJlY3QgY2hpbGRyZW4gb2YgdGhlIGxpc3QgZWxlbWVu dC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKy0+IDUgRml2ZQorLT4gNiBTaXgK KzEwIFRlbgorMTEgRWxldmVuCistPiAxMiBUd2VsdmUKKy0+IDEzIFRoaXJ0ZWVuCisxNCBGb3Vy dGVlbgorMTUgRmlmdGVlbgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRl bXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lY2NiZTE1Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtaXRlbXMuaHRt bApAQCAtMCwwICsxLDQyIEBACis8aHRtbD4KKyAgICA8aGVhZD4KKyAgICAgICAgPHNjcmlwdCBz cmM9ImR1bXAtbGlzdC5qcyIgLz4KKyAgICAgICAgPHNjcmlwdD4KKyAgICAgICAgICAgIGZ1bmN0 aW9uIHRlc3QoKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGlmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9s bGVyLmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgICAgIHZhciBsaXN0ID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImxpc3QiKTsKKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAg ICAgICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBp biB0aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgbGlzdC5wYXJlbnROb2RlLnJl bW92ZUNoaWxkKGxpc3QpOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8 L2hlYWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3Rz IHRoYXQgbGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gc29tZSBvZiB0aGUgaXRl bXMgYXJlIGluZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSBsaXN0IGVsZW1lbnQuPC9wPgorICAgICAg ICA8b2wgaWQ9Imxpc3QiPgorICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICA8 bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDxsaT5UaHJlZTwvbGk+CisgICAgICAgICAgICA8bGk+ Rm91cgorICAgICAgICAgICAgICAgIDxiPgorICAgICAgICAgICAgICAgICAgICA8bGk+Rml2ZTwv bGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5TaXg8L2xpPgorICAgICAgICAgICAgICAgIDwv Yj4KKyAgICAgICAgICAgIDwvbGk+CisgICAgICAgICAgICA8bGkgdmFsdWU9IjEwIj5UZW48L2xp PgorICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8ZGl2PgorICAgICAg ICAgICAgICAgIDxsaT5Ud2VsdmU8L2xpPgorICAgICAgICAgICAgICAgIDxsaT5UaGlydGVlbjwv bGk+CisgICAgICAgICAgICA8L2Rpdj4KKyAgICAgICAgICAgIDxsaT5Gb3VydGVlbjwvbGk+Cisg ICAgICAgICAgICA8bGk+RmlmdGVlbjwvbGk+CisgICAgICAgIDwvb2w+CisKKyAgICAgICAgPGRp diBpZD0iY29uc29sZSI+PC9kaXY+CisgICAgPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUg YXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVz dGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9s aXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC1leHBlY3RlZC50eHQKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZmMDk4ZQotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQtZXhwZWN0 ZWQudHh0CkBAIC0wLDAgKzEsMTMgQEAKK1RoaXMgdGVzdHMgdGhhdCBsaXN0IGl0ZW0gbWFya2Vy cyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3RlZCBsaXN0Lgor CisxIE9uZQorMiBUd28KKzMgVGhyZWUKKzQgRm91cgorNSBGaXZlIE9uZSBUd2VudHkgZml2ZSBU d2VudHkgc2l4CistPiAtPiAxIE9uZQorLT4gLT4gMjUgVHdlbnR5IGZpdmUKKy0+IC0+IDI2IFR3 ZW50eSBzaXgKKzYgU2l4Cis3IFNldmVuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv bGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHluYW1pYy1pbnNlcnQuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi5kZjYzNGY1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC1keW5hbWljLWluc2VydC5odG1sCkBAIC0w LDAgKzEsNDggQEAKKzxodG1sPgorICAgIDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVt cC1saXN0LmpzIiAvPgorICAgICAgICA8c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVz dCgpCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVt cEFzVGV4dCgpOworCisgICAgICAgICAgICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgibGlzdCIpOworICAgICAgICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3Jj ZSBhIHJlbGF5b3V0LgorCisgICAgICAgICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgibmVzdGVkLWxpc3QiKTsKKworICAgICAgICAgICAgICAgIHZhciBs aTIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAgICAgIGxpMi5p bm5lclRleHQgPSAiVHdlbnR5IGZpdmUiOworICAgICAgICAgICAgICAgIGxpMi52YWx1ZSA9ICIy NSI7CisgICAgICAgICAgICAgICAgdmFyIGxpMSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImxp Iik7CisgICAgICAgICAgICAgICAgbGkxLmlubmVyVGV4dCA9ICJPbmUiOworICAgICAgICAgICAg ICAgIHZhciBsaTMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJsaSIpOworICAgICAgICAgICAg ICAgIGxpMy5pbm5lclRleHQgPSAiVHdlbnR5IHNpeCI7CisKKyAgICAgICAgICAgICAgICBuZXN0 ZWRMaXN0LmFwcGVuZENoaWxkKGxpMik7CisgICAgICAgICAgICAgICAgbmVzdGVkTGlzdC5pbnNl cnRCZWZvcmUobGkxLCBsaTIpOworICAgICAgICAgICAgICAgIG5lc3RlZExpc3QuYXBwZW5kQ2hp bGQobGkzKTsKKworICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25z b2xlIikuaW5uZXJIVE1MID0gZHVtcExpc3QobGlzdCk7CisKKyAgICAgICAgICAgICAgICAvLyBE b24ndCBzaG93IHRoZSBhY3R1YWwgbGlzdCBhcyBpdCBpcyB1c2VsZXNzIGluIHRoZSB0ZXh0LW9u bHkgbW9kZS4KKyAgICAgICAgICAgICAgICBsaXN0LnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQobGlz dCk7CisgICAgICAgICAgICB9CisgICAgICAgIDwvc2NyaXB0PgorICAgIDwvaGVhZD4KKyAgICA8 Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgICAgIDxwPlRoaXMgdGVzdHMgdGhhdCBsaXN0IGl0 ZW0gbWFya2VycyBkbyBub3QgY2hhbmdlIHdoZW4gYWRkaW5nIG5ldyBpdGVtcyB0byBhIG5lc3Rl ZCBsaXN0LjwvcD4KKyAgICAgICAgPG9sIGlkPSJsaXN0Ij4KKyAgICAgICAgICAgIDxsaT5PbmU8 L2xpPgorICAgICAgICAgICAgPGxpPlR3bzwvbGk+CisgICAgICAgICAgICA8bGk+VGhyZWU8L2xp PgorICAgICAgICAgICAgPGxpPkZvdXI8L2xpPgorICAgICAgICAgICAgPGxpPkZpdmUgPG9sIGlk PSJuZXN0ZWQtbGlzdCI+PC9vbD48L2xpPgorICAgICAgICAgICAgPGxpPlNpeDwvbGk+CisgICAg ICAgICAgICA8bGk+U2V2ZW48L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAgIDxkaXYgaWQ9 ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVu ZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1s aXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY2OTExYjMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0LWR5bmFtaWMtcmVtb3ZlLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIHRoYXQgbGlzdCBpdGVtIG1hcmtlcnMgZG8g bm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5nIGl0ZW1zIGZyb20gYSBuZXN0ZWQgbGlz dC4KKworMSBPbmUKKzIgVHdvCiszIFRocmVlCis0IEZvdXIKKzUgRml2ZQorMSBPbmUKKzIgVHdv CisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3QtZHlu YW1pYy1yZW1vdmUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVzdGVkLWxpc3Qt ZHluYW1pYy1yZW1vdmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43 M2E2NDI1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0 ZWQtbGlzdC1keW5hbWljLXJlbW92ZS5odG1sCkBAIC0wLDAgKzEsNDUgQEAKKzxodG1sPgorICAg IDxoZWFkPgorICAgICAgICA8c2NyaXB0IHNyYz0iZHVtcC1saXN0LmpzIiAvPgorICAgICAgICA8 c2NyaXB0PgorICAgICAgICAgICAgZnVuY3Rpb24gdGVzdCgpCisgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAg ICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCisgICAgICAgICAg ICAgICAgdmFyIGxpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibGlzdCIpOworICAgICAg ICAgICAgICAgIGxpc3Qub2Zmc2V0VG9wOyAvLyBGb3JjZSBhIHJlbGF5b3V0LgorCisgICAgICAg ICAgICAgICAgdmFyIG5lc3RlZExpc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibmVzdGVk LWxpc3QiKTsKKyAgICAgICAgICAgICAgICB2YXIgaXRlbXMgPSBuZXN0ZWRMaXN0LmNoaWxkcmVu Lmxlbmd0aDsKKyAgICAgICAgICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IGl0ZW1zOyArK2kp CisgICAgICAgICAgICAgICAgICAgIG5lc3RlZExpc3QucmVtb3ZlQ2hpbGQobmVzdGVkTGlzdC5m aXJzdEVsZW1lbnRDaGlsZCk7CisKKyAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgiY29uc29sZSIpLmlubmVySFRNTCA9IGR1bXBMaXN0KGxpc3QpOworCisgICAgICAgICAg ICAgICAgLy8gRG9uJ3Qgc2hvdyB0aGUgYWN0dWFsIGxpc3QgYXMgaXQgaXMgdXNlbGVzcyBpbiB0 aGUgdGV4dC1vbmx5IG1vZGUuCisgICAgICAgICAgICAgICAgbGlzdC5wYXJlbnROb2RlLnJlbW92 ZUNoaWxkKGxpc3QpOworICAgICAgICAgICAgfQorICAgICAgICA8L3NjcmlwdD4KKyAgICA8L2hl YWQ+CisgICAgPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgICAgICA8cD5UaGlzIHRlc3RzIHRo YXQgbGlzdCBpdGVtIG1hcmtlcnMgZG8gbm90IGNoYW5nZSB3aGVuIHJlbW92aW5nIGV4aXN0aW5n IGl0ZW1zIGZyb20gYSBuZXN0ZWQgbGlzdC48L3A+CisgICAgICAgIDxvbCBpZD0ibGlzdCI+Cisg ICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAg ICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgIDxsaT5Gb3VyPC9saT4KKyAgICAgICAg ICAgIDxsaT5GaXZlCisgICAgICAgICAgICAgICAgPG9sIGlkPSJuZXN0ZWQtbGlzdCI+CisgICAg ICAgICAgICAgICAgICAgIDxsaT5PbmU8L2xpPgorICAgICAgICAgICAgICAgICAgICA8bGk+VHdv PC9saT4KKyAgICAgICAgICAgICAgICAgICAgPGxpPlRocmVlPC9saT4KKyAgICAgICAgICAgICAg ICA8L29sPgorICAgICAgICAgICAgPC9saT4KKyAgICAgICAgICAgIDxsaSB2YWx1ZT0iMSI+T25l PC9saT4KKyAgICAgICAgICAgIDxsaT5Ud288L2xpPgorICAgICAgICA8L29sPgorCisgICAgICAg IDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorICAgIDwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXds aW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29s LW5lc3RlZC1saXN0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbGlzdHMvb2wtbmVz dGVkLWxpc3QtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LmRmZjUzZWIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE1IEBACitUaGlzIHRlc3RzIHRoYXQg bGlzdCBpdGVtcyBhcmUgcHJvcGVybHkgbWFya2VkIHdoZW4gdGhlIGxpc3QgY29udGFpbnMgbmVz dGVkIGxpc3RzLgorCisxMCBUZW4KKzExIEVsZXZlbgorMTIgVHdlbHZlCisxMyBUaGlydGVlbiBP bmUgVHdvCistPiAtPiDil6YgT25lCistPiAtPiDil6YgVHdvCisxNCBGb3VydGVlbgorMTUgRmlm dGVlbgorLT4gMSBPbmUKKy0+IDIgVHdvCisxNiBTaXh0ZWVuCisxNyBTZXZlbnRlZW4KKwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC9saXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLmNiOGFhNTEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2xpc3RzL29sLW5lc3RlZC1saXN0Lmh0bWwKQEAgLTAsMCArMSw0MiBAQAorPGh0bWw+ CisgICAgPGhlYWQ+CisgICAgICAgIDxzY3JpcHQgc3JjPSJkdW1wLWxpc3QuanMiIC8+CisgICAg ICAgIDxzY3JpcHQ+CisgICAgICAgICAgICBmdW5jdGlvbiB0ZXN0KCkKKyAgICAgICAgICAgIHsK KyAgICAgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAg ICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAgICAg ICAgICAgICAgICB2YXIgbGlzdCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsaXN0Iik7Cisg ICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lckhU TUwgPSBkdW1wTGlzdChsaXN0KTsKKworICAgICAgICAgICAgICAgIC8vIERvbid0IHNob3cgdGhl IGFjdHVhbCBsaXN0IGFzIGl0IGlzIHVzZWxlc3MgaW4gdGhlIHRleHQtb25seSBtb2RlLgorICAg ICAgICAgICAgICAgIGxpc3QucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChsaXN0KTsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+CisgICAgPC9oZWFkPgorICAgIDxib2R5IG9ubG9hZD0i dGVzdCgpIj4KKyAgICAgICAgPHA+VGhpcyB0ZXN0cyB0aGF0IGxpc3QgaXRlbXMgYXJlIHByb3Bl cmx5IG1hcmtlZCB3aGVuIHRoZSBsaXN0IGNvbnRhaW5zIG5lc3RlZCBsaXN0cy48L3A+CisgICAg ICAgIDxvbCBpZD0ibGlzdCIgc3RhcnQ9IjEwIj4KKyAgICAgICAgICAgIDxsaT5UZW48L2xpPgor ICAgICAgICAgICAgPGxpPkVsZXZlbjwvbGk+CisgICAgICAgICAgICA8bGk+VHdlbHZlPC9saT4K KyAgICAgICAgICAgIDxsaT5UaGlydGVlbgorICAgICAgICAgICAgICAgIDx1bD4KKyAgICAgICAg ICAgICAgICAgICAgPGxpPk9uZTwvbGk+CisgICAgICAgICAgICAgICAgICAgIDxsaT5Ud288L2xp PgorICAgICAgICAgICAgICAgIDwvdWw+CisgICAgICAgICAgICA8L2xpPgorICAgICAgICAgICAg PGxpPkZvdXJ0ZWVuPC9saT4KKyAgICAgICAgICAgIDxsaT5GaWZ0ZWVuPC9saT4KKyAgICAgICAg ICAgIDxvbD4KKyAgICAgICAgICAgICAgICA8bGk+T25lPC9saT4KKyAgICAgICAgICAgICAgICA8 bGk+VHdvPC9saT4KKyAgICAgICAgICAgIDwvb2w+CisgICAgICAgICAgICA8bGk+U2l4dGVlbjwv bGk+CisgICAgICAgICAgICA8bGk+U2V2ZW50ZWVuPC9saT4KKyAgICAgICAgPC9vbD4KKworICAg ICAgICA8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKyAgICA8L2JvZHk+Cis8L2h0bWw+ClwgTm8g bmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCAyMWI2ZjEyLi5hMmYyNTllIDEwMDY0NAotLS0gYS9XZWJD b3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMyIEBACisy MDEwLTA0LTIwICBKYWt1YiBXaWVjem9yZWsgIDxqd2llY3pvcmVrQHdlYmtpdC5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGlzdCBpdGVtIG1h cmtlcnMgYXJlIG5vdCBhbHdheXMgdXBkYXRlZCBhZnRlciBjaGFuZ2VzIGluIHRoZSBET00uCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzA2MAorCisg ICAgICAgIEluIHBhcnRpY3VsYXIsIHRoZXkgd291bGQgbm90IGJlIHVwZGF0ZWQgd2hlbiBhZGRp bmcvcmVtb3ZpbmcgYW4gaXRlbQorICAgICAgICB0aGF0IGlzIG5vdCBhIGRpcmVjdCBjaGlsZCBv ZiB0aGUgbGlzdCBlbGVtZW50LgorCisgICAgICAgIFRlc3RzOiBmYXN0L2xpc3RzL29sLW5lc3Rl ZC1pdGVtcy1keW5hbWljLWluc2VydC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2xpc3RzL29s LW5lc3RlZC1pdGVtcy1keW5hbWljLXJlbW92ZS5odG1sCisgICAgICAgICAgICAgICBmYXN0L2xp c3RzL29sLW5lc3RlZC1pdGVtcy5odG1sCisgICAgICAgICAgICAgICBmYXN0L2xpc3RzL29sLW5l c3RlZC1saXN0LWR5bmFtaWMtaW5zZXJ0Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvbGlzdHMv b2wtbmVzdGVkLWxpc3QtZHluYW1pYy1yZW1vdmUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9s aXN0cy9vbC1uZXN0ZWQtbGlzdC5odG1sCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyTGlz dEl0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6dXBkYXRlTGlzdE1hcmtlck51bWJlcnMpOiBD aGFuZ2UgaXQgdG8gdHJhdmVyc2UgdGhlIHdob2xlIHN1YnRyZWUgb2YgYSBsaXN0LCBub3Qgb25s eSBzaWJsaW5ncyBvZiBhbiBpdGVtLgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJMaXN0SXRl bS5oOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwOiBNb3ZlIHRoZSB1cGRh dGVMaXN0TWFya2VyTnVtYmVycyBmdW5jdGlvbiB0byBSZW5kZXJMaXN0SXRlbS5jcHAuCisgICAg ICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmFkZENoaWxkKTogTW92ZSB0aGUgY29kZSB1cGRh dGluZyBsaXN0IG1hcmtlcnMgdG8gUmVuZGVyT2JqZWN0Q2hpbGRMaXN0IGZvciBjb25zaXN0ZW5j eS4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcDogTW92ZSB0 aGUgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMgZnVuY3Rpb24gdG8gUmVuZGVyTGlzdEl0ZW0uY3Bw LgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjpyZW1vdmVDaGlsZE5v ZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyByZW1vdmVkLCBub3QgdGhlIG5leHQgc2li bGluZy4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdENoaWxkTGlzdDo6YXBwZW5kQ2hp bGROb2RlKTogUGFzcyB0aGUgYWN0dWFsIG5vZGUgYmVpbmcgYWRkZWQsIG5vdCB0aGUgbmV4dCBz aWJsaW5nLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjppbnNlcnRD aGlsZE5vZGUpOiBQYXNzIHRoZSBhY3R1YWwgbm9kZSBiZWluZyBhZGRlZCwgbm90IHRoZSBuZXh0 IHNpYmxpbmcuCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6bWFya2VyVGV4dEZvckxpc3RJdGVtKToKKwogMjAxMC0wNC0yMCAgR2F2 aW4gQmFycmFjbG91Z2ggIDxiYXJyYWNsb3VnaEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgR2VvZmYgR2FyZW4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJM aXN0SXRlbS5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5jcHAKaW5kZXgg NWUyZTE2Ny4uNmZiODA2NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlz dEl0ZW0uY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJdGVtLmNwcApAQCAt MzU1LDQgKzM1NSwzOCBAQCB2b2lkIFJlbmRlckxpc3RJdGVtOjpjbGVhckV4cGxpY2l0VmFsdWUo KQogICAgIGV4cGxpY2l0VmFsdWVDaGFuZ2VkKCk7CiB9CiAKK3ZvaWQgUmVuZGVyTGlzdEl0ZW06 OnVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCkKK3sKKyAgICBOb2RlKiBsaXN0Tm9kZSA9IGVuY2xv c2luZ0xpc3QodGhpcyk7CisgICAgQVNTRVJUKGxpc3ROb2RlICYmIGxpc3ROb2RlLT5yZW5kZXJl cigpKTsKKyAgICBpZiAoIWxpc3ROb2RlIHx8ICFsaXN0Tm9kZS0+cmVuZGVyZXIoKSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgUmVuZGVyT2JqZWN0KiBsaXN0ID0gbGlzdE5vZGUtPnJlbmRlcmVy KCk7CisgICAgUmVuZGVyT2JqZWN0KiBjaGlsZCA9IHRoaXMtPm5leHRJblByZU9yZGVyKGxpc3Qp OworICAgIHdoaWxlIChjaGlsZCkgeworICAgICAgICBpZiAoY2hpbGQtPm5vZGUoKSAmJiBpc0xp c3QoY2hpbGQtPm5vZGUoKSkpIHsKKyAgICAgICAgICAgIC8vIFdlJ3ZlIGZvdW5kIGEgbmVzdGVk LCBpbmRlcGVuZGVudCBsaXN0OiBub3RoaW5nIHRvIGRvIGhlcmUuCisgICAgICAgICAgICBjaGls ZCA9IGNoaWxkLT5uZXh0SW5QcmVPcmRlckFmdGVyQ2hpbGRyZW4obGlzdCk7CisgICAgICAgICAg ICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGlmIChjaGlsZC0+aXNMaXN0SXRlbSgp KSB7CisgICAgICAgICAgICBSZW5kZXJMaXN0SXRlbSogaXRlbSA9IHRvUmVuZGVyTGlzdEl0ZW0o Y2hpbGQpOworCisgICAgICAgICAgICBpZiAoIWl0ZW0tPm1faXNWYWx1ZVVwVG9EYXRlKSB7Cisg ICAgICAgICAgICAgICAgLy8gSWYgYW4gaXRlbSBoYXMgYmVlbiBtYXJrZWQgZm9yIHVwZGF0ZSBi ZWZvcmUsIHdlIGNhbiBzYWZlbHkKKyAgICAgICAgICAgICAgICAvLyBhc3N1bWUgdGhhdCBhbGwg dGhlIGZvbGxvd2luZyBvbmVzIGhhdmUgdG9vLgorICAgICAgICAgICAgICAgIC8vIFRoaXMgZ2l2 ZXMgdXMgdGhlIG9wcG9ydHVuaXR5IHRvIHN0b3AgaGVyZSBhbmQgYXZvaWQKKyAgICAgICAgICAg ICAgICAvLyBtYXJraW5nIHRoZSBzYW1lIG5vZGVzIGFnYWluLgorICAgICAgICAgICAgICAgIGJy ZWFrOworICAgICAgICAgICAgfQorCisgICAgICAgICAgICBpdGVtLT51cGRhdGVWYWx1ZSgpOwor ICAgICAgICB9CisKKyAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dEluUHJlT3JkZXIobGlzdCk7 CisgICAgfQorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJMaXN0SXRlbS5oIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyTGlz dEl0ZW0uaAppbmRleCBjNGM0MWRjLi4yYWQ5YTQxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJMaXN0SXRlbS5oCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckxpc3RJ dGVtLmgKQEAgLTQ2LDYgKzQ2LDggQEAgcHVibGljOgogCiAgICAgY29uc3QgU3RyaW5nJiBtYXJr ZXJUZXh0KCkgY29uc3Q7CiAKKyAgICB2b2lkIHVwZGF0ZUxpc3RNYXJrZXJOdW1iZXJzKCk7CisK IHByaXZhdGU6CiAgICAgdmlydHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3QgeyBy ZXR1cm4gIlJlbmRlckxpc3RJdGVtIjsgfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApp bmRleCA4YTYyZDEzLi5jYjY0NDE5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJPYmplY3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKQEAg LTI1NywxNCArMjU3LDYgQEAgYm9vbCBSZW5kZXJPYmplY3Q6OmlzSFRNTE1hcnF1ZWUoKSBjb25z dAogICAgIHJldHVybiBub2RlKCkgJiYgbm9kZSgpLT5yZW5kZXJlcigpID09IHRoaXMgJiYgbm9k ZSgpLT5oYXNUYWdOYW1lKG1hcnF1ZWVUYWcpOwogfQogCi1zdGF0aWMgdm9pZCB1cGRhdGVMaXN0 TWFya2VyTnVtYmVycyhSZW5kZXJPYmplY3QqIGNoaWxkKQotewotICAgIGZvciAoUmVuZGVyT2Jq ZWN0KiBzaWJsaW5nID0gY2hpbGQ7IHNpYmxpbmc7IHNpYmxpbmcgPSBzaWJsaW5nLT5uZXh0U2li bGluZygpKSB7Ci0gICAgICAgIGlmIChzaWJsaW5nLT5pc0xpc3RJdGVtKCkpCi0gICAgICAgICAg ICB0b1JlbmRlckxpc3RJdGVtKHNpYmxpbmcpLT51cGRhdGVWYWx1ZSgpOwotICAgIH0KLX0KLQog dm9pZCBSZW5kZXJPYmplY3Q6OmFkZENoaWxkKFJlbmRlck9iamVjdCogbmV3Q2hpbGQsIFJlbmRl ck9iamVjdCogYmVmb3JlQ2hpbGQpCiB7CiAgICAgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0KiBjaGls ZHJlbiA9IHZpcnR1YWxDaGlsZHJlbigpOwpAQCAtMjc0LDkgKzI2Niw3IEBAIHZvaWQgUmVuZGVy T2JqZWN0OjphZGRDaGlsZChSZW5kZXJPYmplY3QqIG5ld0NoaWxkLCBSZW5kZXJPYmplY3QqIGJl Zm9yZUNoaWxkKQogCiAgICAgYm9vbCBuZWVkc1RhYmxlID0gZmFsc2U7CiAKLSAgICBpZiAobmV3 Q2hpbGQtPmlzTGlzdEl0ZW0oKSkKLSAgICAgICAgdXBkYXRlTGlzdE1hcmtlck51bWJlcnMoYmVm b3JlQ2hpbGQgPyBiZWZvcmVDaGlsZCA6IGNoaWxkcmVuLT5sYXN0Q2hpbGQoKSk7Ci0gICAgZWxz ZSBpZiAobmV3Q2hpbGQtPmlzVGFibGVDb2woKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+ZGlzcGxh eSgpID09IFRBQkxFX0NPTFVNTl9HUk9VUCkKKyAgICBpZiAobmV3Q2hpbGQtPmlzVGFibGVDb2wo KSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+ZGlzcGxheSgpID09IFRBQkxFX0NPTFVNTl9HUk9VUCkK ICAgICAgICAgbmVlZHNUYWJsZSA9ICFpc1RhYmxlKCk7CiAgICAgZWxzZSBpZiAobmV3Q2hpbGQt PmlzUmVuZGVyQmxvY2soKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+ZGlzcGxheSgpID09IFRBQkxF X0NBUFRJT04pCiAgICAgICAgIG5lZWRzVGFibGUgPSAhaXNUYWJsZSgpOwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcCBiL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlck9iamVjdENoaWxkTGlzdC5jcHAKaW5kZXggOGVlODExMi4uNmQ3NmYzNCAx MDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAor KysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwCkBAIC0zOSwx NCArMzksNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLXN0YXRpYyB2b2lkIHVwZGF0ZUxp c3RNYXJrZXJOdW1iZXJzKFJlbmRlck9iamVjdCogY2hpbGQpCi17Ci0gICAgZm9yIChSZW5kZXJP YmplY3QqIHNpYmxpbmcgPSBjaGlsZDsgc2libGluZzsgc2libGluZyA9IHNpYmxpbmctPm5leHRT aWJsaW5nKCkpIHsKLSAgICAgICAgaWYgKHNpYmxpbmctPmlzTGlzdEl0ZW0oKSkKLSAgICAgICAg ICAgIHRvUmVuZGVyTGlzdEl0ZW0oc2libGluZyktPnVwZGF0ZVZhbHVlKCk7Ci0gICAgfQotfQot CiB2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6ZGVzdHJveUxlZnRvdmVyQ2hpbGRyZW4oKQog ewogICAgIHdoaWxlIChmaXJzdENoaWxkKCkpIHsKQEAgLTkxLDExICs4MywxMCBAQCBSZW5kZXJP YmplY3QqIFJlbmRlck9iamVjdENoaWxkTGlzdDo6cmVtb3ZlQ2hpbGROb2RlKFJlbmRlck9iamVj dCogb3duZXIsIFJlbmRlcgogICAgICAgICAgICAgICAgIGxheWVyID0gb3duZXItPmVuY2xvc2lu Z0xheWVyKCk7CiAgICAgICAgICAgICBvbGRDaGlsZC0+cmVtb3ZlTGF5ZXJzKGxheWVyKTsKICAg ICAgICAgfQotICAgICAgICAKLSAgICAgICAgLy8gcmVudW1iZXIgb3JkZXJlZCBsaXN0cworCiAg ICAgICAgIGlmIChvbGRDaGlsZC0+aXNMaXN0SXRlbSgpKQotICAgICAgICAgICAgdXBkYXRlTGlz dE1hcmtlck51bWJlcnMob2xkQ2hpbGQtPm5leHRTaWJsaW5nKCkpOwotICAgICAgICAKKyAgICAg ICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0ob2xkQ2hpbGQpLT51cGRhdGVMaXN0TWFya2VyTnVtYmVy cygpOworCiAgICAgICAgIGlmIChvbGRDaGlsZC0+aXNQb3NpdGlvbmVkKCkgJiYgb3duZXItPmNo aWxkcmVuSW5saW5lKCkpCiAgICAgICAgICAgICBvd25lci0+ZGlydHlMaW5lc0Zyb21DaGFuZ2Vk Q2hpbGQob2xkQ2hpbGQpOwogICAgIH0KQEAgLTE2MSw3ICsxNTIsMTAgQEAgdm9pZCBSZW5kZXJP YmplY3RDaGlsZExpc3Q6OmFwcGVuZENoaWxkTm9kZShSZW5kZXJPYmplY3QqIG93bmVyLCBSZW5k ZXJPYmplY3QqIG4KICAgICAgICAgICAgIGlmIChsYXllcikKICAgICAgICAgICAgICAgICBsYXll ci0+c2V0SGFzVmlzaWJsZUNvbnRlbnQodHJ1ZSk7CiAgICAgICAgIH0KLSAgICAgICAgCisKKyAg ICAgICAgaWYgKG5ld0NoaWxkLT5pc0xpc3RJdGVtKCkpCisgICAgICAgICAgICB0b1JlbmRlckxp c3RJdGVtKG5ld0NoaWxkKS0+dXBkYXRlTGlzdE1hcmtlck51bWJlcnMoKTsKKwogICAgICAgICBp ZiAoIW5ld0NoaWxkLT5pc0Zsb2F0aW5nT3JQb3NpdGlvbmVkKCkgJiYgb3duZXItPmNoaWxkcmVu SW5saW5lKCkpCiAgICAgICAgICAgICBvd25lci0+ZGlydHlMaW5lc0Zyb21DaGFuZ2VkQ2hpbGQo bmV3Q2hpbGQpOwogICAgIH0KQEAgLTIxOCw3ICsyMTIsOSBAQCB2b2lkIFJlbmRlck9iamVjdENo aWxkTGlzdDo6aW5zZXJ0Q2hpbGROb2RlKFJlbmRlck9iamVjdCogb3duZXIsIFJlbmRlck9iamVj dCogYwogICAgICAgICAgICAgICAgIGxheWVyLT5zZXRIYXNWaXNpYmxlQ29udGVudCh0cnVlKTsK ICAgICAgICAgfQogCi0gICAgICAgIAorICAgICAgICBpZiAoY2hpbGQtPmlzTGlzdEl0ZW0oKSkK KyAgICAgICAgICAgIHRvUmVuZGVyTGlzdEl0ZW0oY2hpbGQpLT51cGRhdGVMaXN0TWFya2VyTnVt YmVycygpOworCiAgICAgICAgIGlmICghY2hpbGQtPmlzRmxvYXRpbmcoKSAmJiBvd25lci0+Y2hp bGRyZW5JbmxpbmUoKSkKICAgICAgICAgICAgIG93bmVyLT5kaXJ0eUxpbmVzRnJvbUNoYW5nZWRD aGlsZChjaGlsZCk7CiAgICAgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy VHJlZUFzVGV4dC5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmNwcApp bmRleCA4NGY1MmM2Li43NWMzNWJhIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJUcmVlQXNUZXh0LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0 LmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlJlbmRlckJSLmgiCiAjaW5jbHVkZSAi UmVuZGVyRmlsZVVwbG9hZENvbnRyb2wuaCIKICNpbmNsdWRlICJSZW5kZXJJbmxpbmUuaCIKKyNp bmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgogI2luY2x1ZGUgIlJlbmRlckxpc3RNYXJrZXIuaCIK ICNpbmNsdWRlICJSZW5kZXJQYXJ0LmgiCiAjaW5jbHVkZSAiUmVuZGVyVGFibGVDZWxsLmgiCkBA IC02NjAsNCArNjYxLDE3IEBAIFN0cmluZyBjb3VudGVyVmFsdWVGb3JFbGVtZW50KEVsZW1lbnQq IGVsZW1lbnQpCiAgICAgcmV0dXJuIHN0cmVhbS5yZWxlYXNlKCk7CiB9CiAKK1N0cmluZyBtYXJr ZXJUZXh0Rm9yTGlzdEl0ZW0oRWxlbWVudCogZWxlbWVudCkKK3sKKyAgICAvLyBNYWtlIHN1cmUg dGhlIGVsZW1lbnQgaXMgbm90IGZyZWVkIGR1cmluZyB0aGUgbGF5b3V0LgorICAgIFJlZlB0cjxF bGVtZW50PiBlbGVtZW50UmVmKGVsZW1lbnQpOworICAgIGVsZW1lbnQtPmRvY3VtZW50KCktPnVw ZGF0ZUxheW91dCgpOworCisgICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGVsZW1lbnQtPnJl bmRlcmVyKCk7CisgICAgaWYgKCFyZW5kZXJlciB8fCAhcmVuZGVyZXItPmlzTGlzdEl0ZW0oKSkK KyAgICAgICAgcmV0dXJuIFN0cmluZygpOworCisgICAgcmV0dXJuIHRvUmVuZGVyTGlzdEl0ZW0o cmVuZGVyZXIpLT5tYXJrZXJUZXh0KCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuaCBiL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlclRyZWVBc1RleHQuaAppbmRleCAxZmNmZWMxLi40ZGEwYmFiIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUcmVlQXNUZXh0LmgKKysrIGIvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyVHJlZUFzVGV4dC5oCkBAIC01MSw2ICs1MSw4IEBAIFN0cmluZyBx dW90ZUFuZEVzY2FwZU5vblByaW50YWJsZXMoY29uc3QgU3RyaW5nJik7CiAKIFN0cmluZyBjb3Vu dGVyVmFsdWVGb3JFbGVtZW50KEVsZW1lbnQqKTsKIAorU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0 SXRlbShFbGVtZW50Kik7CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIFJl bmRlclRyZWVBc1RleHRfaApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJL aXQvZ3RrL0NoYW5nZUxvZwppbmRleCAxYjMzNTQzLi45M2M5MGYxIDEwMDY0NAotLS0gYS9XZWJL aXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0 IEBACisyMDEwLTA0LTIwICBKYWt1YiBXaWVjem9yZWsgIDxqd2llY3pvcmVrQHdlYmtpdC5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGlzdCBp dGVtIG1hcmtlcnMgYXJlIG5vdCBhbHdheXMgdXBkYXRlZCBhZnRlciBjaGFuZ2VzIGluIHRoZSBE T00uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzA2 MAorCisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQv d2Via2l0d2ViZnJhbWUuY3BwOgorICAgICAgICAod2Via2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4 dF9mb3JfbGlzdF9pdGVtKTogQWRkIGEgcHJpdmF0ZSBBUEkgdG8gZ2V0IHRoZSBtYXJrZXIgdGV4 dCBmb3IgYSBsaXN0IGl0ZW0uCisKIDIwMTAtMDQtMjAgIEtlbnQgVGFtdXJhICA8dGtlbnRAY2hy b21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5oCmluZGV4IGQwMDAwYjEuLjI2NDJkNTAgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRwcml2YXRlLmgKQEAgLTMxNSw2ICszMTUsOSBAQCBleHRlcm4gIkMiIHsKICAgICBXRUJLSVRf QVBJIGJvb2wKICAgICB3ZWJraXRfd2ViX2ZyYW1lX3BhdXNlX3N2Z19hbmltYXRpb24oV2ViS2l0 V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogYW5pbWF0aW9uSWQsIGRvdWJsZSB0aW1lLCBj b25zdCBnY2hhciogZWxlbWVudElkKTsKIAorICAgIFdFQktJVF9BUEkgZ2NoYXIqCisgICAgd2Vi a2l0X3dlYl9mcmFtZV9tYXJrZXJfdGV4dF9mb3JfbGlzdF9pdGVtKFdlYktpdFdlYkZyYW1lKiBm cmFtZSwgSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgbm9kZU9iamVjdCk7CisKICAg ICBXRUJLSVRfQVBJIHVuc2lnbmVkIGludAogICAgIHdlYmtpdF93ZWJfZnJhbWVfbnVtYmVyX29m X2FjdGl2ZV9hbmltYXRpb25zKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiAKZGlmZiAtLWdpdCBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHdlYmZyYW1lLmNwcAppbmRleCA5NTM4ZDI3Li4zN2EyNmJlIDEwMDY0NAotLS0gYS9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0d2ViZnJhbWUuY3BwCkBAIC00Nyw4ICs0NywxMCBAQAogI2luY2x1ZGUgIkd0a1Zl cnNpb25pbmcuaCIKICNpbmNsdWRlICJIVE1MRnJhbWVPd25lckVsZW1lbnQuaCIKICNpbmNsdWRl ICJKU0RPTVdpbmRvdy5oIgorI2luY2x1ZGUgIkpTRWxlbWVudC5oIgogI2luY2x1ZGUgIkpTTG9j ay5oIgogI2luY2x1ZGUgIlByaW50Q29udGV4dC5oIgorI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVt LmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUgIlJlbmRlclRyZWVBc1RleHQu aCIKICNpbmNsdWRlICJKU0RPTUJpbmRpbmcuaCIKQEAgLTEwNDMsNiArMTA0NSwxNyBAQCBib29s IHdlYmtpdF93ZWJfZnJhbWVfcGF1c2Vfc3ZnX2FuaW1hdGlvbihXZWJLaXRXZWJGcmFtZSogZnJh bWUsIGNvbnN0IGdjaGFyKiBhbgogI2VuZGlmCiB9CiAKK2djaGFyKiB3ZWJraXRfd2ViX2ZyYW1l X21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBKU0NvbnRl eHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBub2RlT2JqZWN0KQoreworICAgIEpTQzo6RXhlY1N0 YXRlKiBleGVjID0gdG9KUyhjb250ZXh0KTsKKyAgICBFbGVtZW50KiBlbGVtZW50ID0gdG9FbGVt ZW50KHRvSlMoZXhlYywgbm9kZU9iamVjdCkpOworICAgIGlmICghZWxlbWVudCkKKyAgICAgICAg cmV0dXJuIDA7CisKKyAgICBTdHJpbmcgbWFya2VyVGV4dCA9IG1hcmtlclRleHRGb3JMaXN0SXRl bShlbGVtZW50KTsKKyAgICByZXR1cm4gZ19zdHJkdXAobWFya2VyVGV4dC51dGY4KCkuZGF0YSgp KTsKK30KKwogdW5zaWduZWQgaW50IHdlYmtpdF93ZWJfZnJhbWVfbnVtYmVyX29mX2FjdGl2ZV9h bmltYXRpb25zKFdlYktpdFdlYkZyYW1lKiBmcmFtZSkKIHsKICAgICBGcmFtZSogY29yZUZyYW1l ID0gY29yZShmcmFtZSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50Lmgg Yi9XZWJLaXQvcXQvQXBpL3F3ZWJlbGVtZW50LmgKaW5kZXggYTg3ZDM4OC4uNjcyODZmZCAxMDA2 NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZWxlbWVudC5oCisrKyBiL1dlYktpdC9xdC9BcGkv cXdlYmVsZW1lbnQuaApAQCAtMTU1LDYgKzE1NSw3IEBAIHByaXZhdGU6CiAgICAgc3RhdGljIFFX ZWJFbGVtZW50IGVuY2xvc2luZ0VsZW1lbnQoV2ViQ29yZTo6Tm9kZSopOwogCiAgICAgZnJpZW5k IGNsYXNzIFFXZWJGcmFtZTsKKyAgICBmcmllbmQgY2xhc3MgRHVtcFJlbmRlclRyZWVTdXBwb3J0 UXQ7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJFbGVtZW50Q29sbGVjdGlvbjsKICAgICBmcmllbmQg Y2xhc3MgUVdlYkhpdFRlc3RSZXN1bHQ7CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJIaXRUZXN0UmVz dWx0UHJpdmF0ZTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQv Q2hhbmdlTG9nCmluZGV4IDFkMjAwOTQuLjg5Y2I0YWEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9D aGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEw LTA0LTIwICBKYWt1YiBXaWVjem9yZWsgIDxqd2llY3pvcmVrQHdlYmtpdC5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTGlzdCBpdGVtIG1hcmtl cnMgYXJlIG5vdCBhbHdheXMgdXBkYXRlZCBhZnRlciBjaGFuZ2VzIGluIHRoZSBET00uCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzA2MAorCisgICAg ICAgICogQXBpL3F3ZWJlbGVtZW50Lmg6IE1ha2UgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQgYSBm cmllbmQgY2xhc3MuCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBw b3J0UXQuY3BwOgorICAgICAgICAoRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6Om1hcmtlclRleHRG b3JMaXN0SXRlbSk6IEFkZCBhIHByaXZhdGUgQVBJIHRvIGdldCB0aGUgbWFya2VyIHRleHQgZm9y IGEgbGlzdCBpdGVtLgorCiAyMDEwLTA0LTIwICBLZW50IFRhbXVyYSAgPHRrZW50QGNocm9taXVt Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL1dl YktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAgYi9XZWJL aXQvcXQvV2ViQ29yZVN1cHBvcnQvRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQuY3BwCmluZGV4IDhj MjExN2UuLjcwMzEwNzEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9EdW1w UmVuZGVyVHJlZVN1cHBvcnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1 bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlBh Z2VHcm91cC5oIgogI2luY2x1ZGUgIlBsdWdpbkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiUHJpbnRD b250ZXh0LmgiCisjaW5jbHVkZSAiUmVuZGVyTGlzdEl0ZW0uaCIKICNpbmNsdWRlICJSZW5kZXJU cmVlQXNUZXh0LmgiCiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKICNpbmNsdWRlICJTZXR0 aW5ncy5oIgpAQCAtMzY0LDMgKzM2NSw5IEBAIGJvb2wgRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6 OmlzQ29tbWFuZEVuYWJsZWQoUVdlYlBhZ2UqIHBhZ2UsIGNvbnN0IFFTdHJpbmcmIG5hCiB7CiAg ICAgcmV0dXJuIHBhZ2UtPmhhbmRsZSgpLT5wYWdlLT5mb2N1c0NvbnRyb2xsZXIoKS0+Zm9jdXNl ZE9yTWFpbkZyYW1lKCktPmVkaXRvcigpLT5jb21tYW5kKG5hbWUpLmlzRW5hYmxlZCgpOwogfQor CitRU3RyaW5nIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0o Y29uc3QgUVdlYkVsZW1lbnQmIGxpc3RJdGVtKQoreworICAgIEVsZW1lbnQqIGVsZW1lbnQgPSBs aXN0SXRlbS5tX2VsZW1lbnQ7CisgICAgcmV0dXJuIFdlYkNvcmU6Om1hcmtlclRleHRGb3JMaXN0 SXRlbShlbGVtZW50KTsKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9E dW1wUmVuZGVyVHJlZVN1cHBvcnRRdC5oIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBS ZW5kZXJUcmVlU3VwcG9ydFF0LmgKaW5kZXggMGMzY2Y5YS4uYjkyYjg2YSAxMDA2NDQKLS0tIGEv V2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmgKKysrIGIv V2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0R1bXBSZW5kZXJUcmVlU3VwcG9ydFF0LmgKQEAgLTI1 LDYgKzI1LDggQEAKIAogI2luY2x1ZGUgInF3ZWJraXRnbG9iYWwuaCIKIAorI2luY2x1ZGUgInF3 ZWJlbGVtZW50LmgiCisKIGNsYXNzIFFXZWJQYWdlOwogY2xhc3MgUVdlYkZyYW1lOwogCkBAIC03 OCw2ICs4MCw4IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgdm9pZCByZXNldE9yaWdpbkFjY2Vzc1do aXRlTGlzdHMoKTsKIAogICAgIHN0YXRpYyBpbnQgd29ya2VyVGhyZWFkQ291bnQoKTsKKworICAg IHN0YXRpYyBRU3RyaW5nIG1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYg bGlzdEl0ZW0pOwogfTsKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5kZXggOTUzNjgxMi4uYjdmMTUwMyAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI1IEBACisyMDEwLTA0LTIwICBKYWt1YiBXaWVjem9yZWsgIDxqd2llY3pvcmVr QHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgTGlzdCBpdGVtIG1hcmtlcnMgYXJlIG5vdCBhbHdheXMgdXBkYXRlZCBhZnRlciBjaGFu Z2VzIGluIHRoZSBET00uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0zNzA2MAorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuY3BwOgorICAgICAgICAobWFya2VyVGV4dEZvckxpc3RJdGVtQ2FsbGJhY2spOiBBIGZ1 bmN0aW9uIHRoYXQgcmV0dXJucyB0aGUgbWFya2VyIHRleHQgZm9yIGEgZ2l2ZW4gbGlzdCBpdGVt LgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucyk6CisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaDoKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwOgorICAgICAgICAo TGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSk6IEltcGxlbWVudCBp dCBpbiB0aGUgR1RLIHBvcnQuCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRl c3RDb250cm9sbGVyTWFjLm1tOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtl clRleHRGb3JMaXN0SXRlbSk6IEFkZCBhIHN0dWIuCisgICAgICAgICogRHVtcFJlbmRlclRyZWUv cXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJv bGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsZXIpOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbSk6IEltcGxlbWVudCBpdCBpbiB0aGUgUXQgcG9ydC4K KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0Lmg6Cisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDoK KyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0pOiBB ZGQgYSBzdHViLgorCiAyMDEwLTA0LTIwICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCmluZGV4IGQ5MDRkN2MuLmJm MmRkYWIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RD b250cm9sbGVyLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0 Q29udHJvbGxlci5jcHAKQEAgLTEzODgsNiArMTM4OCwxNCBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBz ZXRXZWJWaWV3RWRpdGFibGVDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RS ZWYgZgogfQogCiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG1hcmtlclRleHRGb3JMaXN0SXRlbUNhbGxi YWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiwgSlNPYmplY3RSZWYgdGhpc09i amVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10s IEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29u dHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQ cml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBpZiAoYXJndW1lbnRDb3VudCA8IDEpCisgICAgICAg IHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKKyAgICByZXR1cm4gSlNWYWx1 ZU1ha2VTdHJpbmcoY29udGV4dCwgY29udHJvbGxlci0+bWFya2VyVGV4dEZvckxpc3RJdGVtKGNv bnRleHQsIGFyZ3VtZW50c1swXSkuZ2V0KCkpOworfQorCiAvLyBTdGF0aWMgVmFsdWVzCiAKIHN0 YXRpYyBKU1ZhbHVlUmVmIGdldEdsb2JhbEZsYWdDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4 dCwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgSlNTdHJpbmdSZWYgcHJvcGVydHlOYW1lLCBKU1Zh bHVlUmVmKiBleGNlcHRpb24pCkBAIC0xNTAyLDYgKzE1MTAsNyBAQCBKU1N0YXRpY0Z1bmN0aW9u KiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAia2Vl cFdlYkhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsg ImxheWVyVHJlZUFzVGV4dCIsIGxheWVyVHJlZUFzVGV4dENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAg ICAgIHsgIm51bWJlck9mUGFnZXMiLCBudW1iZXJPZlBhZ2VzQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAg ICAgICAgeyAibWFya2VyVGV4dEZvckxpc3RJdGVtIiwgbWFya2VyVGV4dEZvckxpc3RJdGVtQ2Fs bGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LAogICAgICAgICB7ICJudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMiLCBudW1iZXJP ZkFjdGl2ZUFuaW1hdGlvbnNDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJvdmVycmlkZVBy ZWZlcmVuY2UiLCBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggNjFj MzQ2My4uNTdhYTk1MiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5oCkBAIC0yNTMsNiArMjUzLDggQEAgcHVibGljOgogICAgIAogICAg IEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBsYXllclRyZWVBc1RleHQoKSBjb25zdDsKIAorICAg IEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBtYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNDb250ZXh0 UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3Q7CisKICAgICBzdGF0aWMg Y29uc3QgdW5zaWduZWQgbWF4Vmlld1dpZHRoOwogICAgIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBt YXhWaWV3SGVpZ2h0OwogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9n dGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAppbmRleCAzZmE5YmE3Li4yZmYzNDhm IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENv bnRyb2xsZXJHdGsuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlv dXRUZXN0Q29udHJvbGxlckd0ay5jcHAKQEAgLTU4LDYgKzU4LDcgQEAgZ2NoYXIqIHdlYmtpdF93 ZWJfZnJhbWVfY291bnRlcl92YWx1ZV9mb3JfZWxlbWVudF9ieV9pZChXZWJLaXRXZWJGcmFtZSog ZnJhbWUsIGMKIGludCB3ZWJraXRfd2ViX2ZyYW1lX3BhZ2VfbnVtYmVyX2Zvcl9lbGVtZW50X2J5 X2lkKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIqIGlkLCBmbG9hdCBwYWdlV2lk dGgsIGZsb2F0IHBhZ2VIZWlnaHQpOwogaW50IHdlYmtpdF93ZWJfZnJhbWVfbnVtYmVyX29mX3Bh Z2VzKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgZmxvYXQgcGFnZVdpZHRoLCBmbG9hdCBwYWdlSGVp Z2h0KTsKIHZvaWQgd2Via2l0X3dlYl9pbnNwZWN0b3JfZXhlY3V0ZV9zY3JpcHQoV2ViS2l0V2Vi SW5zcGVjdG9yKiBpbnNwZWN0b3IsIGxvbmcgY2FsbElkLCBjb25zdCBnY2hhciogc2NyaXB0KTsK K2djaGFyKiB3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9saXN0X2l0ZW0oV2ViS2l0 V2ViRnJhbWUqIGZyYW1lLCBKU0NvbnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBub2RlT2Jq ZWN0KTsKIH0KIAogc3RhdGljIGdjaGFyKiBjb3B5V2ViU2V0dGluZ0tleShnY2hhciogcHJlZmVy ZW5jZUtleSkKQEAgLTY2MywzICs2NjQsMTQgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 YXBpVGVzdEdvVG9DdXJyZW50QmFja0ZvcndhcmRJdGVtKCkKIHZvaWQgTGF5b3V0VGVzdENvbnRy b2xsZXI6OnNldFdlYlZpZXdFZGl0YWJsZShib29sKQogewogfQorCitKU1JldGFpblB0cjxKU1N0 cmluZ1JlZj4gTGF5b3V0VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbShKU0Nv bnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBub2RlT2JqZWN0KSBjb25zdAoreworICAgIGdj aGFyKiBtYXJrZXJUZXh0R0NoYXIgPSB3ZWJraXRfd2ViX2ZyYW1lX21hcmtlcl90ZXh0X2Zvcl9s aXN0X2l0ZW0obWFpbkZyYW1lLCBjb250ZXh0LCBub2RlT2JqZWN0KTsKKyAgICBpZiAoIW1hcmtl clRleHRHQ2hhcikKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmlu Z1JlZj4gbWFya2VyVGV4dChBZG9wdCwgSlNTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcobWFy a2VyVGV4dEdDaGFyKSk7CisgICAgZ19mcmVlKG1hcmtlclRleHRHQ2hhcik7CisgICAgcmV0dXJu IG1hcmtlclRleHQ7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KaW5kZXggMThlNjFhZC4uMDQ5MDZmZCAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250 cm9sbGVyTWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRU ZXN0Q29udHJvbGxlck1hYy5tbQpAQCAtMTkyLDYgKzE5MiwxMiBAQCBKU1JldGFpblB0cjxKU1N0 cmluZ1JlZj4gTGF5b3V0VGVzdENvbnRyb2xsZXI6OmxheWVyVHJlZUFzVGV4dCgpIGNvbnN0CiAg ICAgcmV0dXJuIHN0cmluZzsKIH0KIAorSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IExheW91dFRl c3RDb250cm9sbGVyOjptYXJrZXJUZXh0Rm9yTGlzdEl0ZW0oSlNDb250ZXh0UmVmIGNvbnRleHQs IEpTVmFsdWVSZWYgbm9kZU9iamVjdCkgY29uc3QKK3sKKyAgICAvLyBGSVhNRTogSW1wbGVtZW50 IG1lLgorICAgIHJldHVybiBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4oKTsKK30KKwogaW50IExh eW91dFRlc3RDb250cm9sbGVyOjpwYWdlTnVtYmVyRm9yRWxlbWVudEJ5SWQoSlNTdHJpbmdSZWYg aWQsIGZsb2F0IHBhZ2VXaWR0aEluUGl4ZWxzLCBmbG9hdCBwYWdlSGVpZ2h0SW5QaXhlbHMpCiB7 CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBpZENGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNG U3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGlkKSk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcCBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCmluZGV4IGEw NjVmZmQuLjVmN2NmNGMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0 L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwCkBAIC01MSw2ICs1MSw3IEBAIExheW91 dFRlc3RDb250cm9sbGVyOjpMYXlvdXRUZXN0Q29udHJvbGxlcihXZWJDb3JlOjpEdW1wUmVuZGVy VHJlZSogZHJ0KQogICAgIDogUU9iamVjdCgpCiAgICAgLCBtX2RydChkcnQpCiB7CisgICAgcVJl Z2lzdGVyTWV0YVR5cGU8UVdlYkVsZW1lbnQ+KCJRV2ViRWxlbWVudCIpOwogICAgIHJlc2V0KCk7 CiAgICAgcXRfZHVtcF9ub3RpZmljYXRpb24odHJ1ZSk7CiB9CkBAIC02MDksNSArNjEwLDEwIEBA IGJvb2wgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmlzQ29tbWFuZEVuYWJsZWQoY29uc3QgUVN0cmlu ZyYgbmFtZSkgY29uc3QKICAgICByZXR1cm4gRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OmlzQ29t bWFuZEVuYWJsZWQobV9kcnQtPndlYlBhZ2UoKSwgbmFtZSk7CiB9CiAKK1FTdHJpbmcgTGF5b3V0 VGVzdENvbnRyb2xsZXI6Om1hcmtlclRleHRGb3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYg bGlzdEl0ZW0pCit7CisgICAgcmV0dXJuIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0OjptYXJrZXJU ZXh0Rm9yTGlzdEl0ZW0obGlzdEl0ZW0pOworfQorCiBjb25zdCB1bnNpZ25lZCBMYXlvdXRUZXN0 Q29udHJvbGxlcjo6bWF4Vmlld1dpZHRoID0gODAwOwogY29uc3QgdW5zaWduZWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6Om1heFZpZXdIZWlnaHQgPSA2MDA7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmggYi9XZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmgKaW5kZXggYmM0ZWI0 Mi4uNWRhMWQ3YSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5 b3V0VGVzdENvbnRyb2xsZXJRdC5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0 L0xheW91dFRlc3RDb250cm9sbGVyUXQuaApAQCAtNDAsNiArNDAsNyBAQAogI2luY2x1ZGUgPFFW YXJpYW50PgogCiAjaW5jbHVkZSA8cXdlYmRhdGFiYXNlLmg+CisjaW5jbHVkZSA8cXdlYmVsZW1l bnQuaD4KICNpbmNsdWRlIDxxd2ViZnJhbWUuaD4KICNpbmNsdWRlIDxxd2ViaGlzdG9yeS5oPgog I2luY2x1ZGUgPHF3ZWJwYWdlLmg+CkBAIC0xODIsNiArMTgzLDggQEAgcHVibGljIHNsb3RzOgog ICAgICovCiAgICAgdm9pZCBzZXRTY3JvbGxiYXJQb2xpY3koY29uc3QgUVN0cmluZyYgb3JpZW50 YXRpb24sIGNvbnN0IFFTdHJpbmcmIHBvbGljeSk7CiAKKyAgICBRU3RyaW5nIG1hcmtlclRleHRG b3JMaXN0SXRlbShjb25zdCBRV2ViRWxlbWVudCYgbGlzdEl0ZW0pOworCiBwcml2YXRlIHNsb3Rz OgogICAgIHZvaWQgcHJvY2Vzc1dvcmsoKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKaW5kZXggMDc4 ZGE4MC4uMjM2ZjJkZCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2lu L0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCkBAIC0xOTQsNiArMTk0LDEyIEBA IEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bGF5ZXJUcmVl QXNUZXh0KCkgY29uc3QKICAgICByZXR1cm4gdGV4dFZhbHVlSlM7CiB9CiAKK0pTUmV0YWluUHRy PEpTU3RyaW5nUmVmPiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6bWFya2VyVGV4dEZvckxpc3RJdGVt KEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU1ZhbHVlUmVmIG5vZGVPYmplY3QpIGNvbnN0Cit7Cisg ICAgLy8gRklYTUU6IEltcGxlbWVudCBtZS4KKyAgICByZXR1cm4gSlNSZXRhaW5QdHI8SlNTdHJp bmdSZWY+KCk7Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OndhaXRGb3JQb2xpY3lE ZWxlZ2F0ZSgpCiB7CiAgICAgLy8gRklYTUU6IEltcGxlbWVudCB0aGlzLgo=