53160 2011-01-25 21:34:18 -0800 HTMLInputElement::setValue() should schedule change event when the element is focused 2011-03-07 02:52:22 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 1 isherman isherman abarth adele buildbot commit-queue darin eric gustavo.noronha gustavo isherman rniwa tkent webkit-ews webkit.review.bot xan.lopez oldest_to_newest 340141 0 isherman 2011-01-25 21:34:18 -0800 Fire onchange() event for text field after value is programmatically changed and focus is lost 340142 1 80167 isherman 2011-01-25 21:36:42 -0800 Created attachment 80167 Patch 340144 2 80168 isherman 2011-01-25 21:47:10 -0800 Created attachment 80168 Patch 340148 3 80168 rniwa 2011-01-25 22:06:24 -0800 Comment on attachment 80168 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=80168&action=review > Source/WebCore/ChangeLog:6 > + Fire onchange() event for focused text field after its value is programmatically changed and focus is lost > + https://bugs.webkit.org/show_bug.cgi?id=53160 Please update the bug title here. > Source/WebCore/html/HTMLInputElement.cpp:897 > + else if (isTextField()) > + toRenderTextControl(renderer())->setChangedSinceLastChangeEvent(true); I don't think it's correct to do this just for text fields. We probably want to fire change event for other types of input elements as well. 340155 4 isherman 2011-01-25 22:08:54 -0800 This code really needs a test to go along with it, but I'm not sure how to go about adding one. The difficulty is that there aren't any regular clients who call into setValue(..., true) (nor into setValueForUser()). In fact, afaict, essentially the only clients are Safari and Chromium's autofill implementations -- and I'm only guessing that Safari still uses this, based on the comment in http://trac.webkit.org/browser/trunk/WebCore/dom/InputElement.h?rev=51602 . Suggestions on how to add a test are very welcome! 340156 5 80171 isherman 2011-01-25 22:11:19 -0800 Created attachment 80171 Patch 340158 6 80168 rniwa 2011-01-25 22:19:04 -0800 Comment on attachment 80168 Patch It's very unfortunate that there's no way to test this code per http://trac.webkit.org/changeset/51602. 340159 7 80173 isherman 2011-01-25 22:22:10 -0800 Created attachment 80173 Patch 340160 8 isherman 2011-01-25 22:22:28 -0800 (In reply to comment #3) > Please update the bug title here. Done. > > Source/WebCore/html/HTMLInputElement.cpp:897 > > + else if (isTextField()) > > + toRenderTextControl(renderer())->setChangedSinceLastChangeEvent(true); > > I don't think it's correct to do this just for text fields. We probably want to fire change event for other types of input elements as well. You're right -- I just wasn't sure what exactly to do for other element types. Judging from the other code, I think it might make sense to fire the event immediately for non-text fields -- updated the patch to do that in this case. 340250 9 80173 dglazkov 2011-01-26 06:59:18 -0800 Comment on attachment 80173 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=80173&action=review > Source/WebCore/ChangeLog:9 > + No new tests. (OOPS!) Please explain why no test is possible here. > Source/WebCore/html/HTMLInputElement.cpp:897 > + toRenderTextControl(renderer())->setChangedSinceLastChangeEvent(true); Would it be possible for renderer() to be not RenderTextControl here? 340333 10 80173 rniwa 2011-01-26 10:23:08 -0800 Comment on attachment 80173 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=80173&action=review >> Source/WebCore/html/HTMLInputElement.cpp:897 >> + toRenderTextControl(renderer())->setChangedSinceLastChangeEvent(true); > > Would it be possible for renderer() to be not RenderTextControl here? Hopefully not but we do should make sure the renderer is there (i.e. not NULL). http://trac.webkit.org/browser/trunk/Source/WebCore/html/HTMLInputElement.cpp#L1037 http://trac.webkit.org/browser/trunk/Source/WebCore/html/HTMLInputElement.cpp#L1033 356689 11 83610 isherman 2011-02-23 23:02:17 -0800 Created attachment 83610 Patch 356690 12 webkit.review.bot 2011-02-23 23:04:17 -0800 Attachment 83610 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/WebView/WebViewPrivate.h:680: Extra space before ( in function call [whitespace/parens] [4] Tools/DumpRenderTree/LayoutTestController.h:114: The parameter name "value" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 2 in 13 files If any of these errors are false positives, please file a bug against check-webkit-style. 356696 13 83610 isherman 2011-02-23 23:10:40 -0800 Comment on attachment 83610 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=83610&action=review Apologies for the long silence here -- got stuck writing the test code, and cycled away from this for a while. The latest patch includes a stab at writing a test. I would appreciate feedback and suggestions on how to improve that -- I've never tried to mess with DRT before, so I'm sure I did a bunch of stuff wrong. Aaalso, the check-webkit-style script has a couple of complaints, but I think they are both erroneous. Is the style checker correct? If not, is there something I should do to silence it? > LayoutTests/fast/forms/onchange-setvalueforuser.html:1 > +<html> Should this test live in fast/forms or fast/events? Both seem to have precedent. > LayoutTests/fast/forms/onchange-setvalueforuser.html:20 > + tf.blur(); Do we want to also test that the event is not fired until the blur occurs? If so, any suggestions on a nice, straightforward way to do that? > LayoutTests/fast/forms/onchange-setvalueforuser.html:22 > + </script> I've seen other tests have js in a separate file rather than inline -- is that preferred? > Source/WebKit/mac/WebView/WebView.mm:6271 > + JSStringRef jsStringValue = JSValueToStringCopy(context, value, NULL); > + String stringValue(jsStringValue->characters(), jsStringValue->length()); Do either of these leak memory? I don't have a good understanding of the memory ownership model here. 356701 14 buildbot 2011-02-23 23:24:37 -0800 Attachment 83610 did not build on win: Build output: http://queues.webkit.org/results/7985388 357640 15 gustavo.noronha 2011-02-24 18:41:19 -0800 Attachment 83610 did not build on gtk: Build output: http://queues.webkit.org/results/7987630 358854 16 83610 tkent 2011-02-27 19:57:25 -0800 Comment on attachment 83610 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=83610&action=review >> LayoutTests/fast/forms/onchange-setvalueforuser.html:1 >> +<html> > > Should this test live in fast/forms or fast/events? Both seem to have precedent. Either is ok. I prefer fast/forms because it's a test of a form-specific feature. > LayoutTests/fast/forms/onchange-setvalueforuser.html:7 > + function log(msg) { > + var res = document.getElementById('res'); > + res.innerHTML = res.innerHTML + msg + "<br>"; > + } We had better use debug() or testPassed() defined in LayoutTests/fast/js/resources/js-test-pre.js. >> LayoutTests/fast/forms/onchange-setvalueforuser.html:20 >> + tf.blur(); > > Do we want to also test that the event is not fired until the blur occurs? If so, any suggestions on a nice, straightforward way to do that? Introducing a global counter for the number of fired 'change' events? >> LayoutTests/fast/forms/onchange-setvalueforuser.html:22 >> + </script> > > I've seen other tests have js in a separate file rather than inline -- is that preferred? Some developers don't like separating js file. IMO, either is ok. > Source/WebCore/html/HTMLInputElement.cpp:899 > + if (sendChangeEvent) { > + // For text fields, don't dispatch the change event when focused. > + // It will be dispatched when the control loses focus. > + RenderObject* r = renderer(); > + if (r && r->isTextField() && document()->focusedNode() == this) > + toRenderTextControl(r)->setChangedSinceLastChangeEvent(true); > + else > dispatchFormControlChangeEvent(); Wrong indentation. >> Source/WebKit/mac/WebView/WebView.mm:6271 >> + String stringValue(jsStringValue->characters(), jsStringValue->length()); > > Do either of these leak memory? I don't have a good understanding of the memory ownership model here. I'm not sure too. 359399 17 84131 isherman 2011-02-28 15:10:50 -0800 Created attachment 84131 Patch 359402 18 84131 isherman 2011-02-28 15:12:42 -0800 Comment on attachment 84131 Patch Updated patch to address Kent's comments and add stub implementations so that non-Mac platforms compile. 359403 19 webkit.review.bot 2011-02-28 15:13:49 -0800 Attachment 84131 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/WebView/WebViewPrivate.h:680: Extra space before ( in function call [whitespace/parens] [4] Tools/DumpRenderTree/LayoutTestController.h:114: The parameter name "value" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 2 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 359415 20 84131 darin 2011-02-28 15:20:16 -0800 Comment on attachment 84131 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=84131&action=review > Source/WebCore/html/HTMLInputElement.cpp:895 > + RenderObject* r = renderer(); I know you were doing this the same as the code in HTMLInputDefaultEventHandler, but please don’t use a single letter for a local variable. One way to avoid that is to write it like this: RenderObject* renderer = this->renderer(); > Source/WebCore/html/HTMLInputElement.cpp:897 > + if (r && r->isTextField() && document()->focusedNode() == this) > + toRenderTextControl(r)->setChangedSinceLastChangeEvent(true); It is kind of weak that when we have a focused node that for some reason has no renderer or a renderer of the wrong type we behave differently. Generally speaking it is not safe to access a renderer from a function like this that is callable directly from the DOM without first updating style and renderers with a call like updateLayout. It’s possible that the renderer is hanging around from before and the style has recently changed, so we could get the wrong behavior. To test that out you’d want a test case where the input starts out as a text field, then is focused, then changed to another type and then its value is changed. We might find that we get no change event even though we should get one because this code will see the old renderer. Again, I know you are matching existing code, but it's best to make the check match the typecast. Since the check is isTextField, then the cast should be toRenderTextControlSingleLine. If the cast was to RenderTextControl, then the appropriate check would be isTextControl. I think it would be better to find a way to share the setChangedSinceLastChangeEvent code, since the call sites are all doing the same check. But I guess this one call site is different in that the logic is entirely different when the renderer is not created or is not a text field. 359439 21 84138 isherman 2011-02-28 15:48:14 -0800 Created attachment 84138 Patch 359442 22 84138 isherman 2011-02-28 15:50:16 -0800 Comment on attachment 84138 Patch Renamed "r" to "renderer", checking for isTextControl() rather than isTextField() because I think we want the same logic for text areas as well. 359445 23 darin 2011-02-28 15:50:57 -0800 (In reply to comment #22) > checking for isTextControl() rather than isTextField() because I think we want the same logic for text areas as well. Sensible, but text areas use HTMLTextAreaElement, not HTMLInputElement. 359447 24 webkit.review.bot 2011-02-28 15:51:20 -0800 Attachment 84138 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/WebView/WebViewPrivate.h:680: Extra space before ( in function call [whitespace/parens] [4] Tools/DumpRenderTree/LayoutTestController.h:114: The parameter name "value" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 2 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 359454 25 84131 isherman 2011-02-28 15:59:04 -0800 Comment on attachment 84131 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=84131&action=review >> Source/WebCore/html/HTMLInputElement.cpp:897 >> + toRenderTextControl(r)->setChangedSinceLastChangeEvent(true); > > It is kind of weak that when we have a focused node that for some reason has no renderer or a renderer of the wrong type we behave differently. Generally speaking it is not safe to access a renderer from a function like this that is callable directly from the DOM without first updating style and renderers with a call like updateLayout. It’s possible that the renderer is hanging around from before and the style has recently changed, so we could get the wrong behavior. To test that out you’d want a test case where the input starts out as a text field, then is focused, then changed to another type and then its value is changed. We might find that we get no change event even though we should get one because this code will see the old renderer. > > Again, I know you are matching existing code, but it's best to make the check match the typecast. Since the check is isTextField, then the cast should be toRenderTextControlSingleLine. If the cast was to RenderTextControl, then the appropriate check would be isTextControl. > > I think it would be better to find a way to share the setChangedSinceLastChangeEvent code, since the call sites are all doing the same check. But I guess this one call site is different in that the logic is entirely different when the renderer is not created or is not a text field. Please pardon my ignorance, as I don't know this code very well: I tried writing the test you suggested, and the change event was fired as expected. That obviously doesn't cover all possible cases, though. Is it safe/appropriate to add code along the lines of if (isTextControl()) updateLayout() before the rest of the code here? I think it makes sense to delay the onchange event for text areas as well as single-line fields, so I changed the check to be isTextControl(). I'm not sure that's right, though, since the other callers all check isTextField(). Perhaps someone who knows the history of this could chime in? 359456 26 isherman 2011-02-28 16:00:17 -0800 (In reply to comment #23) > (In reply to comment #22) > > checking for isTextControl() rather than isTextField() because I think we want the same logic for text areas as well. > > Sensible, but text areas use HTMLTextAreaElement, not HTMLInputElement. Ah, makes sense -- I'll change the cast instead, then. 359458 27 84142 isherman 2011-02-28 16:01:57 -0800 Created attachment 84142 Patch 359460 28 webkit.review.bot 2011-02-28 16:03:55 -0800 Attachment 84142 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/WebView/WebViewPrivate.h:680: Extra space before ( in function call [whitespace/parens] [4] Tools/DumpRenderTree/LayoutTestController.h:114: The parameter name "value" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 2 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 359464 29 darin 2011-02-28 16:11:32 -0800 (In reply to comment #25) > I tried writing the test you suggested, and the change event was fired as expected. That obviously doesn't cover all possible cases, though. Is it safe/appropriate to add code along the lines of > > if (isTextControl()) > updateLayout() > > before the rest of the code here? I am surprised the test didn’t fail. Maybe there was nothing to force the renderer to be updated before you changed the type so there was no leftover text field renderer. One way to force the renderer to be created is to call a function like offsetLeft from the JavaScript, since it calls updateLayoutIgnorePendingStylesheets. I think you should keep trying. You can’t call isTextControl before calling a function updateLayoutIgnorePendingStylesheets, because the type of renderer could change based on the update. Sorry, I don’t have an immediate complete answer for you. The general principle is that when making DOM calls the renderers may not yet reflect recent DOM or style changes, and so such calls shouldn’t make decisions based on the state of the renderer. This code is doing that. I think that the decision about how to handle the change event should be based on the result of isTextType() rather than on the type of the renderer at the time of the value change. And we can construct some test cases where the change happens when the type is <input type="text"> but the element has no renderer at the time because of "display: none" and then later gets a renderer to make sure we get the right behavior for change events there. 359625 30 webkit-ews 2011-02-28 20:07:16 -0800 Attachment 84142 did not build on qt: Build output: http://queues.webkit.org/results/8073533 359659 31 isherman 2011-02-28 22:19:20 -0800 (In reply to comment #29) > (In reply to comment #25) > > I tried writing the test you suggested, and the change event was fired as expected. That obviously doesn't cover all possible cases, though. Is it safe/appropriate to add code along the lines of > > > > if (isTextControl()) > > updateLayout() > > > > before the rest of the code here? > > I am surprised the test didn’t fail. Maybe there was nothing to force the renderer to be updated before you changed the type so there was no leftover text field renderer. One way to force the renderer to be created is to call a function like offsetLeft from the JavaScript, since it calls updateLayoutIgnorePendingStylesheets. I think you should keep trying. I tried this as well, and everything still worked properly. I suspect this is because setValue() calls setSuggestedValue(), which in turn calls renderer()->updateFromElement(); > You can’t call isTextControl before calling a function updateLayoutIgnorePendingStylesheets, because the type of renderer could change based on the update. > > Sorry, I don’t have an immediate complete answer for you. The general principle is that when making DOM calls the renderers may not yet reflect recent DOM or style changes, and so such calls shouldn’t make decisions based on the state of the renderer. This code is doing that. Would it be appropriate to track whether the value has changed since the last change event on the DOM side, rather than on the renderer side? If not, I don't see how we can avoid making decisions based on the state of the renderer :( > I think that the decision about how to handle the change event should be based on the result of isTextType() rather than on the type of the renderer at the time of the value change. And we can construct some test cases where the change happens when the type is <input type="text"> but the element has no renderer at the time because of "display: none" and then later gets a renderer to make sure we get the right behavior for change events there. What is the right behavior? Fire a change event without delay? Fire a change event as soon as the element is displayed? 359991 32 darin 2011-03-01 10:16:40 -0800 (In reply to comment #31) > Would it be appropriate to track whether the value has changed since the last change event on the DOM side, rather than on the renderer side? Yes. > What is the right behavior? Fire a change event without delay? Fire a change event as soon as the element is displayed? I don’t know. I suggest testing behavior of other browsers since compatibility may be the main issue. Generally speaking, I am thinking that the principle is that the DOM code should not be able to detect whether there is a renderer or not. 360730 33 84402 isherman 2011-03-02 04:58:37 -0800 Created attachment 84402 Patch 360732 34 webkit.review.bot 2011-03-02 05:00:36 -0800 Attachment 84402 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/WebView/WebViewPrivate.h:680: Extra space before ( in function call [whitespace/parens] [4] Total errors found: 1 in 28 files If any of these errors are false positives, please file a bug against check-webkit-style. 360919 35 84402 darin 2011-03-02 10:54:46 -0800 Comment on attachment 84402 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=84402&action=review Great approach. This looks good. If it wasn’t for WML I would be absolutely sure we should put this bit into HTMLFormControlElement and not add any new virtual functions to Element. I am really unhappy we have to make such a mess just to handle WML. I still think we should put this into HTMLFormControlElement. If we have to have virtual functions that’s OK, but I would prefer not to spread this across so many classes. > Source/WebCore/dom/Document.cpp:3172 > + if (oldFocusedNode->isElementNode()) { Since we have to do a type check here anyway, I suggest we instead call isFormControlElement and then cast to HTMLFormControlElement instead of just casting to Element. We then should put the flag bit into HTMLFormControlElement instead of having two separate flag bits and virtual functions to access them. Even though only text input and textareas would use the flags, I think we can spare the bit in HTMLFormControlElement. > Source/WebCore/dom/Document.cpp:3173 > + Element* element = static_cast<Element *>(oldFocusedNode.get()); Instead of Element * this should say Element*. But actually HTMLFormControlElement* if you take my advice above. > Source/WebCore/dom/Element.h:328 > + virtual void setChangedSinceLastChangeEvent(bool) { } > virtual void dispatchFormControlChangeEvent() { } I think the function names should consistently use the phrase “form control change event” if we are adding them to Element.h. But we should not add new functions to Element.h (see my comment above). > Source/WebCore/html/HTMLFormControlElement.cpp:656 > +void HTMLTextFormControlElement::dispatchFormControlChangeEvent() > +{ > + HTMLFormControlElement::dispatchFormControlChangeEvent(); > + setChangedSinceLastChangeEvent(false); > +} Since we’ll put the bit directly into HTMLFormControlElement, this code can go there too. > Source/WebCore/html/HTMLInputElement.cpp:899 > + // For text fields, don't dispatch the change event when focused. > + // It will be dispatched when the control loses focus. > + if (isTextField() && document()->focusedNode() == this) > + setChangedSinceLastChangeEvent(true); > + else > + dispatchFormControlChangeEvent(); What about the other sites that call dispatchFormControlChangeEvent? Aren’t there any others that have the same issue, and should defer the change event in the case of a text input or textarea? A change specific to setValue may not cover enough cases. We should also investigate whether we can call focused() here instead of document()->focusedNode() == this. Do we need to clear this flag when the type of the input element changes? > Source/WebCore/html/HTMLInputElement.cpp:-1044 > // Fire onChange for text fields. > - RenderObject* r = renderer(); > - if (r && r->isTextField() && toRenderTextControl(r)->wasChangedSinceLastChangeEvent()) { > + if (isTextField() && wasChangedSinceLastChangeEvent()) > dispatchFormControlChangeEvent(); > - // Refetch the renderer since arbitrary JS code run during onchange can do anything, including destroying it. > - r = renderer(); > - if (r && r->isTextField()) > - toRenderTextControl(r)->setChangedSinceLastChangeEvent(false); > - } We don’t need the isTextField check here. It was needed before because we needed to type check the renderer before casting and calling functions on it. But here we would be OK unconditionally dispatching the change event if the wasChangedSinceLastChangeEvent flag was set. It won’t be set for other types of input elements that don’t need to send a change event. Please remove the isTextField check and also consider removing or rewording the existing comment. For one thing, the event is a "change event", not "onChange". And a comment that just states what the code does is not valuable. It needs to explain *why* the code does something. > Source/WebCore/html/HTMLInputElement.cpp:1413 > if (renderer() && renderer()->isTextField()) > - toRenderTextControl(renderer())->setChangedSinceLastChangeEvent(true); > + setChangedSinceLastChangeEvent(true); The if statement here should be removed. It was a type check for the renderer. Instead we can unconditionally call setChangedSinceLastChangeEvent(true). > Source/WebCore/html/HTMLInputElement.h:144 > + virtual bool wasChangedSinceLastChangeEvent() const { return m_wasChangedSinceLastChangeEvent; } > + virtual void setChangedSinceLastChangeEvent(bool changed) { m_wasChangedSinceLastChangeEvent = changed; } Virtual functions like these should not have function definitions in the header; there is no chance of inlining them. I know that others in this file do, but one effect of this is to make our compile and link times slower with the many duplicate copies of such functions. Another effect is to make it so we have to recompile more if we ever decide to change the function bodies. The functions don’t actually get inlined when called as virtual functions, and these are never called in a non-virtual fashion. Please move the function definitions into the .cpp file, except you probably will remove them entirely if you take my other suggestion above. > Source/WebCore/html/HTMLTextAreaElement.h:55 > + virtual bool wasChangedSinceLastChangeEvent() const { return m_wasChangedSinceLastChangeEvent; } > + virtual void setChangedSinceLastChangeEvent(bool changed) { m_wasChangedSinceLastChangeEvent = changed; } Same comment as above. Please put these in the .cpp file. > Source/WebCore/html/shadow/TextControlInnerElements.cpp:214 > + input->setValue("", true); Good change, but this points out why we prefer enums instead of booleans. That “true” is completely mysterious! Is there a test that covers this? To put it another way: What test fails if you pass false here instead of true? > Source/WebCore/rendering/RenderTextControlMultiLine.cpp:49 > + textArea->setChangedSinceLastChangeEvent(true); Which test fails if you don’t add this? 361412 36 84402 isherman 2011-03-03 00:30:28 -0800 Comment on attachment 84402 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=84402&action=review I should also note that I haven't actually verified that the WML changes are correct -- I'm not even sure how to compile the WML code :/ >> Source/WebCore/dom/Document.cpp:3172 > > Since we have to do a type check here anyway, I suggest we instead call isFormControlElement and then cast to HTMLFormControlElement instead of just casting to Element. We then should put the flag bit into HTMLFormControlElement instead of having two separate flag bits and virtual functions to access them. Even though only text input and textareas would use the flags, I think we can spare the bit in HTMLFormControlElement. Probably HTMLTextFormControlElement is even better. I originally didn't add the bit there because it looked like none of the abstract superclasses of HTMLInputElement had any data members -- I'd assumed that was an intentional aspect of the design, perhaps for the sake of better bit-packing the data structure in memory. >> Source/WebCore/html/HTMLFormControlElement.cpp:656 >> +} > > Since we’ll put the bit directly into HTMLFormControlElement, this code can go there too. HTMLTextFormControlElement seems more appropriate to me -- is there something I'm overlooking? >> Source/WebCore/html/HTMLInputElement.cpp:899 > > What about the other sites that call dispatchFormControlChangeEvent? Aren’t there any others that have the same issue, and should defer the change event in the case of a text input or textarea? A change specific to setValue may not cover enough cases. > > We should also investigate whether we can call focused() here instead of document()->focusedNode() == this. > > Do we need to clear this flag when the type of the input element changes? Scanning the results of "git gs dispatchFormControlChangeEvent", there don't seem to be other relevant call sites not already covered in this patch -- I might've missed something though. It seems ok to use focused() here -- switched to that. You're probably right that we should clear the flag when the type changes: that's the behavior that we had previously, and that's what Gecko does. Added that tweak. >> Source/WebCore/html/HTMLInputElement.cpp:1413 >> + setChangedSinceLastChangeEvent(true); > > The if statement here should be removed. It was a type check for the renderer. Instead we can unconditionally call setChangedSinceLastChangeEvent(true). We should probably only ever call setChangedSinceLastChangeEvent for text fields -- updated the code to decide based on the field's type. >> Source/WebCore/html/shadow/TextControlInnerElements.cpp:214 >> + input->setValue("", true); > > Good change, but this points out why we prefer enums instead of booleans. That “true” is completely mysterious! > > Is there a test that covers this? To put it another way: What test fails if you pass false here instead of true? search-cancel-button-events.html at your service. Actually, that test caught a bug in the previous implementation: if we delay the change event, we should send an input event -- fixed :) >> Source/WebCore/rendering/RenderTextControlMultiLine.cpp:49 >> + textArea->setChangedSinceLastChangeEvent(true); > > Which test fails if you don’t add this? That would be fast/forms/formchange-event.html =) 361413 37 84531 isherman 2011-03-03 00:30:41 -0800 Created attachment 84531 Patch 361415 38 webkit.review.bot 2011-03-03 00:33:59 -0800 Attachment 84531 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/WebView/WebViewPrivate.h:680: Extra space before ( in function call [whitespace/parens] [4] Total errors found: 1 in 26 files If any of these errors are false positives, please file a bug against check-webkit-style. 361831 39 84531 darin 2011-03-03 12:28:05 -0800 Comment on attachment 84531 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=84531&action=review > Source/WebCore/dom/Document.cpp:3182 > + if (element->isTextFormControl()) { > + bool wasChanged = false; > + if (element->isHTMLElement()) > + wasChanged = static_cast<HTMLTextFormControlElement*>(element)->wasChangedSinceLastChangeEvent(); > +#if ENABLE(WML) > + else if (element->isWMLElement()) > + wasChanged = static_cast<WMLInputElement*>(element)->wasChangedSinceLastChangeEvent(); > +#endif I think I steered you in the wrong direction moving this code out of Element like this. It kills me that WML is the reason we have to do it with virtual functions, but all these if statements and typecasts are terrible. If we do stick with this design, then getting the “was changed” flag should be encapsulated in a separate function. The code would read much more clearly if it was. Honestly, this code and the code below in RenderTextControlSingleLine::subtreeHasChanged seems like an argument for putting the virtual functions back into Element. All these specific cases are ugly and hide the real logic in a forest of trivia. > Source/WebCore/html/HTMLFormControlElement.h:209 > + virtual bool wasChangedSinceLastChangeEvent() const; > + virtual void setChangedSinceLastChangeEvent(bool); Why are these functions virtual? They should not be! > Source/WebCore/html/HTMLFormControlElement.h:237 > + bool m_wasChangedSinceLastChangeEvent : 1; Adding the bit toHTMLTextFormControlElement is not great. By adding a single bit here we end up spending an entire machine word. I know the flag is only needed for the text controls, but I think it’s OK to have the bit in the base class. I suggest adding this to HTMLFormControlElement instead because that has other bits that this could combine with in a single word. > Source/WebCore/html/HTMLInputElement.cpp:901 > + // For text fields, don't dispatch the change event when focused. > + // It will be dispatched when the control loses focus. > + if (isTextField() && focused()) { > + setChangedSinceLastChangeEvent(true); > + dispatchFormControlInputEvent(); > + } else > + dispatchFormControlChangeEvent(); This comment does not make it clear why it’s right to send an input event. I think we could have a much better comment here, while still keeping it short. > Source/WebCore/html/HTMLInputElement.cpp:1046 > + // Dispatch a change event for text fields that have been edited prior > + // to form submission. Normally this event is dispatched when the field > + // loses focus, but form submission is another special case where we > + // consider editing to have finished. Can you say the same thing in a shorter comment? I would say something more like: // Form submission finishes editing as loss of focus does. If there was a change, send the event now. > Source/WebCore/html/HTMLInputElement.cpp:1418 > + if (isTextField()) > + setChangedSinceLastChangeEvent(true); Might be clearer to put this inside the else below. It’s a little confusing since the range control branch sends a change event and this involves change events too. > Source/WebCore/rendering/RenderTextControlSingleLine.cpp:205 > + bool wasChanged = false; > + if (element->isHTMLElement()) { > + HTMLTextFormControlElement* textFormControlElement = static_cast<HTMLTextFormControlElement*>(element); > + wasChanged = textFormControlElement->wasChangedSinceLastChangeEvent(); > + textFormControlElement->setChangedSinceLastChangeEvent(true); > + } > +#if ENABLE(WML) > + else if (element->isWMLElement()) { > + WMLInputElement* wmlInput = static_cast<WMLInputElement*>(element); > + wasChanged = wmlInput->wasChangedSinceLastChangeEvent(); > + wmlInput->setChangedSinceLastChangeEvent(true); > + } > +#endif If we do stick with this design, then we should find some way to encapsulate this in a separate function. The code would read much more clearly if we could concentrate on what we are getting and setting and not so much on the mechanics of how. > Source/WebCore/wml/WMLInputElement.h:70 > + virtual bool wasChangedSinceLastChangeEvent() const { return m_wasChangedSinceLastChangeEvent; } > + virtual void setChangedSinceLastChangeEvent(bool changed) { m_wasChangedSinceLastChangeEvent = changed; } Why are these functions virtual? > Source/WebKit/mac/WebView/WebView.mm:6266 > + JSElement* jsElement = static_cast<JSElement*>(asObject(jsElementValue)); > + Element* webcoreElement = jsElement->impl(); > + InputElement* inputElement = toInputElement(webcoreElement); There are too many local variables here. Makes the code confusing for no good reason. It should just be like this: JSValue elementValue = toJS(exec, element); if (!elementValue.inherits(&JSElement::s_info)) return; InputElement* inputElement = toInputElement(static_cast<JSElement*>(asObject(elementValue))->impl()); > Source/WebKit/mac/WebView/WebView.mm:6271 > + if (!JSValueIsString(context, value)) > + return; This check is incorrect. Any JSValue can be converted to a string. There is no need to reject the argument since it isn’t already a string. > Source/WebKit/mac/WebView/WebView.mm:6273 > + JSStringRef jsStringValue = JSValueToStringCopy(context, value, NULL); > + String stringValue(jsStringValue->characters(), jsStringValue->length()); The jsStringValue here leaks. You should be using a JSRetainPtr or explicitly releasing it. I don’t know why this code is compiling for you. For a JSStringRef, you can’t just call ->characters(). > Source/WebKit/mac/WebView/WebView.mm:6275 > + inputElement->setValueForUser(stringValue); The local variable is not needed. It doesn’t make things read better. It should be like this: JSRetainPtr<JSStringRef> string(Adopt, JSValueToStringCopy(context, value, 0); inputElement->setValueForUser(String(JSStringGetCharacterPtr(string.get()), JSStringGetLength(string.get()))); > Source/WebKit/mac/WebView/WebViewPrivate.h:681 > +- (void)_setValueForUser:(JSContextRef)context forElement:(JSValueRef)element withValue:(JSValueRef)value; This is not the right way to hook this up; too much of the code is in WebKit here. You model for this should be _markerTextForListItem. The argument for the element can just be a DOMElement * and the argument for the value can just be a NSString *. Conversion from a JSValueRef to a DOMElement * and an NSString * can be handled in the layout test controller. 361832 40 darin 2011-03-03 12:28:26 -0800 Thanks for your persistence on this. We’re getting there! 362383 41 84531 isherman 2011-03-04 02:36:59 -0800 Comment on attachment 84531 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=84531&action=review Thanks for your patience in reviewing this =) >> Source/WebCore/dom/Document.cpp:3182 >> +#endif > > I think I steered you in the wrong direction moving this code out of Element like this. It kills me that WML is the reason we have to do it with virtual functions, but all these if statements and typecasts are terrible. > > If we do stick with this design, then getting the “was changed” flag should be encapsulated in a separate function. The code would read much more clearly if it was. > > Honestly, this code and the code below in RenderTextControlSingleLine::subtreeHasChanged seems like an argument for putting the virtual functions back into Element. All these specific cases are ugly and hide the real logic in a forest of trivia. Yeah, WML really doesn't play nicely with the inheritance hierarchy. I switched back to hanging these functions off Element -- it adds a bit of bloat to the API, but I like the alternative even less :( >> Source/WebCore/html/HTMLFormControlElement.h:209 >> + virtual void setChangedSinceLastChangeEvent(bool); > > Why are these functions virtual? They should not be! Oops... they shouldn't have been, though now they again should be. >> Source/WebCore/html/HTMLFormControlElement.h:237 >> + bool m_wasChangedSinceLastChangeEvent : 1; > > Adding the bit toHTMLTextFormControlElement is not great. By adding a single bit here we end up spending an entire machine word. I know the flag is only needed for the text controls, but I think it’s OK to have the bit in the base class. I suggest adding this to HTMLFormControlElement instead because that has other bits that this could combine with in a single word. Ah, somehow I missed the fact that HTMLFormControlElement had data members... oops. Moved the code into there. >> Source/WebKit/mac/WebView/WebView.mm:6273 >> + String stringValue(jsStringValue->characters(), jsStringValue->length()); > > The jsStringValue here leaks. You should be using a JSRetainPtr or explicitly releasing it. > > I don’t know why this code is compiling for you. For a JSStringRef, you can’t just call ->characters(). Uh, you can if you #include "OpaqueJSString.h" :P Mostly I don't know this code at all, so I was just trying whatever I could to get the right logic to compile, and hoping that reviewers would tell me the proper way to do it. So, thanks! =) >> Source/WebKit/mac/WebView/WebViewPrivate.h:681 >> +- (void)_setValueForUser:(JSContextRef)context forElement:(JSValueRef)element withValue:(JSValueRef)value; > > This is not the right way to hook this up; too much of the code is in WebKit here. You model for this should be _markerTextForListItem. The argument for the element can just be a DOMElement * and the argument for the value can just be a NSString *. > > Conversion from a JSValueRef to a DOMElement * and an NSString * can be handled in the layout test controller. Could you point me at where DOMElement, etc. are defined? I found what looks like it might be an auto-generated header "DOMHTMLInputElement.h", but it doesn't have an accessor to the setValueForUser() function that I'm trying to expose. Is it appropriate to expose this function there? If so, approximately how do I set about doing so? 362385 42 84715 isherman 2011-03-04 02:57:08 -0800 Created attachment 84715 Patch 362387 43 webkit.review.bot 2011-03-04 02:59:31 -0800 Attachment 84715 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/WebView/WebViewPrivate.h:680: Extra space before ( in function call [whitespace/parens] [4] Total errors found: 1 in 28 files If any of these errors are false positives, please file a bug against check-webkit-style. 362638 44 darin 2011-03-04 11:17:16 -0800 (In reply to comment #41) > >> Source/WebKit/mac/WebView/WebViewPrivate.h:681 > >> +- (void)_setValueForUser:(JSContextRef)context forElement:(JSValueRef)element withValue:(JSValueRef)value; > > > > This is not the right way to hook this up; too much of the code is in WebKit here. You model for this should be _markerTextForListItem. The argument for the element can just be a DOMElement * and the argument for the value can just be a NSString *. > > > > Conversion from a JSValueRef to a DOMElement * and an NSString * can be handled in the layout test controller. > > Could you point me at where DOMElement, etc. are defined? I found what looks like it might be an auto-generated header "DOMHTMLInputElement.h", but it doesn't have an accessor to the setValueForUser() function that I'm trying to expose. Is it appropriate to expose this function there? If so, approximately how do I set about doing so? Those classes are defined in automatically generated headers. To expose a setValueForUser function, you will want to use what’s called a “category” in Objective-C. The example here is the _markerTextForListItem method in WebDOMOperationsPrivate.h and WebDOMOperations.mm. You could either define this on DOMElement and have it just not do anything for non-input elements, or you could add a category on DOMHTMLInputElement named WebDOMElementOperationsPrivate, analogous to the one that exists for DOMElement. You’ll call core(self) on the element to get a pointer to the WebCore DOM class. 362789 45 84824 isherman 2011-03-04 16:26:40 -0800 Created attachment 84824 Patch 362790 46 84824 isherman 2011-03-04 16:28:05 -0800 Comment on attachment 84824 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=84824&action=review > Source/WebKit/mac/DOM/WebDOMOperations.mm:202 > + static_cast<HTMLInputElement*>(core(self))->setValueForUser(value); This typecast seems redundant, but I'm not sure if there's a better way to achieve this. > Tools/DumpRenderTree/mac/LayoutTestControllerMac.mm:485 > + if (!element || ![element isKindOfClass:[DOMHTMLInputElement class]]) Is this type check the right way to go? 362791 47 webkit.review.bot 2011-03-04 16:29:15 -0800 Attachment 84824 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebKit/mac/DOM/WebDOMOperationsPrivate.h:41: Extra space before ( in function call [whitespace/parens] [4] Total errors found: 1 in 28 files If any of these errors are false positives, please file a bug against check-webkit-style. 362898 48 commit-queue 2011-03-05 00:07:30 -0800 The commit-queue encountered the following flaky tests while processing attachment 84824: inspector/audits/audits-panel-functional.html bug 55776 (authors: apavlov@chromium.org, pfeldman@chromium.org, and rniwa@webkit.org) The commit-queue is continuing to process your patch. 362900 49 84824 commit-queue 2011-03-05 00:09:56 -0800 Comment on attachment 84824 Patch Clearing flags on attachment: 84824 Committed r80412: <http://trac.webkit.org/changeset/80412> 362901 50 commit-queue 2011-03-05 00:10:04 -0800 All reviewed patches have been landed. Closing bug. 363276 51 webkit.review.bot 2011-03-07 02:52:22 -0800 http://trac.webkit.org/changeset/80412 might have broken Windows 7 Release (Tests) and GTK Linux 32-bit Debug The following tests are not passing: fast/forms/onchange-setvalueforuser.html 80167 2011-01-25 21:36:42 -0800 2011-01-25 21:47:08 -0800 Patch bug-53160-20110125213640.patch text/plain 1505 isherman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxODZhMWM0MTA4NTljZGE5ZTUwNWIxMDI0NzIzZDIyODhkMzljOTcyLi4x N2RmMTA2ZWVhZWJlMjg4M2M2YTlkYzk1NzA4ODY4N2UxYTY5NjBmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTYgQEAKKzIwMTEtMDEtMjUgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBG aXJlIG9uY2hhbmdlKCkgZXZlbnQgZm9yIGZvY3VzZWQgdGV4dCBmaWVsZCBhZnRlciBpdHMgdmFs dWUgaXMgcHJvZ3JhbW1hdGljYWxseSBjaGFuZ2VkIGFuZCBmb2N1cyBpcyBsb3N0CisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAg IE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKToKKyAg ICAgICAgICAgIEZvciBhIGZvY3VzZWQgdGV4dCBmaWVsZCwgdGVsbCB0aGUgcmVuZGVyZXIgdGhh dCB0aGUgdmFsdWUgaGFzIGNoYW5nZWQgc2luY2UgdGhlIGxhc3QgY2hhbmcgZXZlbnQuCisKIDIw MTEtMDEtMjUgIFNhbSBXZWluaWcgIDxzYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBEYXZpZCBIeWF0dC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElu cHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3Bw CmluZGV4IDdiMTI3NjcwZmZkM2RmZDY0ZjVjMDdjYzM3NThjZjM3OTAyMjkxNjcuLjhkZmYzMGRh ZGVhMGVhZTUxOGVhOTZiNDJkYTZjNTYxMjRlYmQ2YTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODkyLDYgKzg5Miw4IEBAIHZvaWQgSFRNTElucHV0RWxl bWVudDo6c2V0VmFsdWUoY29uc3QgU3RyaW5nJiB2YWx1ZSwgYm9vbCBzZW5kQ2hhbmdlRXZlbnQp CiAgICAgLy8gd2hlbiB0aGUgY29udHJvbCBsb3NlcyBmb2N1cy4KICAgICBpZiAoc2VuZENoYW5n ZUV2ZW50ICYmIGRvY3VtZW50KCktPmZvY3VzZWROb2RlKCkgIT0gdGhpcykKICAgICAgICAgZGlz cGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisgICAgZWxzZSBpZiAoaXNUZXh0RmllbGQo KSkKKyAgICAgICAgdG9SZW5kZXJUZXh0Q29udHJvbChyZW5kZXJlcigpKS0+c2V0Q2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50KHRydWUpOwogCiAgICAgSW5wdXRFbGVtZW50Ojpub3RpZnlGb3Jt U3RhdGVDaGFuZ2VkKHRoaXMpOwogfQo= 80168 2011-01-25 21:47:10 -0800 2011-01-25 22:19:04 -0800 Patch bug-53160-20110125214709.patch text/plain 1885 isherman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxODZhMWM0MTA4NTljZGE5ZTUwNWIxMDI0NzIzZDIyODhkMzljOTcyLi4x N2RmMTA2ZWVhZWJlMjg4M2M2YTlkYzk1NzA4ODY4N2UxYTY5NjBmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTYgQEAKKzIwMTEtMDEtMjUgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBG aXJlIG9uY2hhbmdlKCkgZXZlbnQgZm9yIGZvY3VzZWQgdGV4dCBmaWVsZCBhZnRlciBpdHMgdmFs dWUgaXMgcHJvZ3JhbW1hdGljYWxseSBjaGFuZ2VkIGFuZCBmb2N1cyBpcyBsb3N0CisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAg IE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKToKKyAg ICAgICAgICAgIEZvciBhIGZvY3VzZWQgdGV4dCBmaWVsZCwgdGVsbCB0aGUgcmVuZGVyZXIgdGhh dCB0aGUgdmFsdWUgaGFzIGNoYW5nZWQgc2luY2UgdGhlIGxhc3QgY2hhbmcgZXZlbnQuCisKIDIw MTEtMDEtMjUgIFNhbSBXZWluaWcgIDxzYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBEYXZpZCBIeWF0dC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElu cHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3Bw CmluZGV4IDdiMTI3NjcwZmZkM2RmZDY0ZjVjMDdjYzM3NThjZjM3OTAyMjkxNjcuLmY1YzJmNmQw MWYwZGIxNWRlODFiNGIxMjU2N2I0ZjdlMGZkZjEwY2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODg4LDEwICs4ODgsMTQgQEAgdm9pZCBIVE1MSW5wdXRF bGVtZW50OjpzZXRWYWx1ZShjb25zdCBTdHJpbmcmIHZhbHVlLCBib29sIHNlbmRDaGFuZ2VFdmVu dCkKICAgICAgICAgbV9kYXRhLnNldFN1Z2dlc3RlZFZhbHVlKFN0cmluZygpKTsKICAgICB9CiAK LSAgICAvLyBEb24ndCBkaXNwYXRjaCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4gZm9jdXNlZCwgaXQg d2lsbCBiZSBkaXNwYXRjaGVkCi0gICAgLy8gd2hlbiB0aGUgY29udHJvbCBsb3NlcyBmb2N1cy4K LSAgICBpZiAoc2VuZENoYW5nZUV2ZW50ICYmIGRvY3VtZW50KCktPmZvY3VzZWROb2RlKCkgIT0g dGhpcykKLSAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisgICAgaWYg KHNlbmRDaGFuZ2VFdmVudCkgeworICAgICAgLy8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5nZSBl dmVudCB3aGVuIGZvY3VzZWQsIGl0IHdpbGwgYmUgZGlzcGF0Y2hlZAorICAgICAgLy8gd2hlbiB0 aGUgY29udHJvbCBsb3NlcyBmb2N1cy4KKyAgICAgIGlmIChkb2N1bWVudCgpLT5mb2N1c2VkTm9k ZSgpICE9IHRoaXMpCisgICAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7 CisgICAgICBlbHNlIGlmIChpc1RleHRGaWVsZCgpKQorICAgICAgICAgIHRvUmVuZGVyVGV4dENv bnRyb2wocmVuZGVyZXIoKSktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCh0cnVlKTsK KyAgICB9CiAKICAgICBJbnB1dEVsZW1lbnQ6Om5vdGlmeUZvcm1TdGF0ZUNoYW5nZWQodGhpcyk7 CiB9Cg== 80171 2011-01-25 22:11:19 -0800 2011-01-25 22:22:07 -0800 Patch bug-53160-20110125221118.patch text/plain 1946 isherman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxODZhMWM0MTA4NTljZGE5ZTUwNWIxMDI0NzIzZDIyODhkMzljOTcyLi4w YzE4YTAwNTQwN2JjODExM2ZjZmU2MTZlOGM1ZDkzMDQyNGU4ZjE5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTcgQEAKKzIwMTEtMDEtMjUgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBI VE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQg d2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6 Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAg ICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVt ZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKToK KyAgICAgICAgICAgIEZvciBhIGZvY3VzZWQgdGV4dCBmaWVsZCwgdGVsbCB0aGUgcmVuZGVyZXIg dGhhdCB0aGUgdmFsdWUgaGFzIGNoYW5nZWQgc2luY2UgdGhlIGxhc3QgY2hhbmdlIGV2ZW50Lgor CiAyMDExLTAxLTI1ICBTYW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgRGF2aWQgSHlhdHQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50 LmNwcAppbmRleCA3YjEyNzY3MGZmZDNkZmQ2NGY1YzA3Y2MzNzU4Y2YzNzkwMjI5MTY3Li5mNWMy ZjZkMDFmMGRiMTVkZTgxYjRiMTI1NjdiNGY3ZTBmZGYxMGNiIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTElucHV0RWxlbWVudC5jcHAKQEAgLTg4OCwxMCArODg4LDE0IEBAIHZvaWQgSFRNTElu cHV0RWxlbWVudDo6c2V0VmFsdWUoY29uc3QgU3RyaW5nJiB2YWx1ZSwgYm9vbCBzZW5kQ2hhbmdl RXZlbnQpCiAgICAgICAgIG1fZGF0YS5zZXRTdWdnZXN0ZWRWYWx1ZShTdHJpbmcoKSk7CiAgICAg fQogCi0gICAgLy8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5nZSBldmVudCB3aGVuIGZvY3VzZWQs IGl0IHdpbGwgYmUgZGlzcGF0Y2hlZAotICAgIC8vIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9j dXMuCi0gICAgaWYgKHNlbmRDaGFuZ2VFdmVudCAmJiBkb2N1bWVudCgpLT5mb2N1c2VkTm9kZSgp ICE9IHRoaXMpCi0gICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAg IGlmIChzZW5kQ2hhbmdlRXZlbnQpIHsKKyAgICAgIC8vIERvbid0IGRpc3BhdGNoIHRoZSBjaGFu Z2UgZXZlbnQgd2hlbiBmb2N1c2VkLCBpdCB3aWxsIGJlIGRpc3BhdGNoZWQKKyAgICAgIC8vIHdo ZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCisgICAgICBpZiAoZG9jdW1lbnQoKS0+Zm9jdXNl ZE5vZGUoKSAhPSB0aGlzKQorICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVu dCgpOworICAgICAgZWxzZSBpZiAoaXNUZXh0RmllbGQoKSkKKyAgICAgICAgICB0b1JlbmRlclRl eHRDb250cm9sKHJlbmRlcmVyKCkpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQodHJ1 ZSk7CisgICAgfQogCiAgICAgSW5wdXRFbGVtZW50Ojpub3RpZnlGb3JtU3RhdGVDaGFuZ2VkKHRo aXMpOwogfQo= 80173 2011-01-25 22:22:10 -0800 2011-02-23 23:02:14 -0800 Patch bug-53160-20110125222209.patch text/plain 1962 isherman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxODZhMWM0MTA4NTljZGE5ZTUwNWIxMDI0NzIzZDIyODhkMzljOTcyLi4w YzE4YTAwNTQwN2JjODExM2ZjZmU2MTZlOGM1ZDkzMDQyNGU4ZjE5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTcgQEAKKzIwMTEtMDEtMjUgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBI VE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQg d2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6 Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAg ICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVt ZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKToK KyAgICAgICAgICAgIEZvciBhIGZvY3VzZWQgdGV4dCBmaWVsZCwgdGVsbCB0aGUgcmVuZGVyZXIg dGhhdCB0aGUgdmFsdWUgaGFzIGNoYW5nZWQgc2luY2UgdGhlIGxhc3QgY2hhbmdlIGV2ZW50Lgor CiAyMDExLTAxLTI1ICBTYW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgRGF2aWQgSHlhdHQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50 LmNwcAppbmRleCA3YjEyNzY3MGZmZDNkZmQ2NGY1YzA3Y2MzNzU4Y2YzNzkwMjI5MTY3Li5iNTZl N2E2MDEyYWVmMGUwMDE4ZDk3NmEzODdlMzMwMDRhZWE3NmNjIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTElucHV0RWxlbWVudC5jcHAKQEAgLTg4OCwxMCArODg4LDE0IEBAIHZvaWQgSFRNTElu cHV0RWxlbWVudDo6c2V0VmFsdWUoY29uc3QgU3RyaW5nJiB2YWx1ZSwgYm9vbCBzZW5kQ2hhbmdl RXZlbnQpCiAgICAgICAgIG1fZGF0YS5zZXRTdWdnZXN0ZWRWYWx1ZShTdHJpbmcoKSk7CiAgICAg fQogCi0gICAgLy8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5nZSBldmVudCB3aGVuIGZvY3VzZWQs IGl0IHdpbGwgYmUgZGlzcGF0Y2hlZAotICAgIC8vIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9j dXMuCi0gICAgaWYgKHNlbmRDaGFuZ2VFdmVudCAmJiBkb2N1bWVudCgpLT5mb2N1c2VkTm9kZSgp ICE9IHRoaXMpCi0gICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAg IGlmIChzZW5kQ2hhbmdlRXZlbnQpIHsKKyAgICAgIC8vIEZvciB0ZXh0IGZpZWxkcywgZG9uJ3Qg ZGlzcGF0Y2ggdGhlIGNoYW5nZSBldmVudCB3aGVuIGZvY3VzZWQuCisgICAgICAvLyBJdCB3aWxs IGJlIGRpc3BhdGNoZWQgd2hlbiB0aGUgY29udHJvbCBsb3NlcyBmb2N1cy4KKyAgICAgIGlmICgh aXNUZXh0RmllbGQoKSB8fCBkb2N1bWVudCgpLT5mb2N1c2VkTm9kZSgpICE9IHRoaXMpCisgICAg ICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisgICAgICBlbHNlCisgICAg ICAgICAgdG9SZW5kZXJUZXh0Q29udHJvbChyZW5kZXJlcigpKS0+c2V0Q2hhbmdlZFNpbmNlTGFz dENoYW5nZUV2ZW50KHRydWUpOworICAgIH0KIAogICAgIElucHV0RWxlbWVudDo6bm90aWZ5Rm9y bVN0YXRlQ2hhbmdlZCh0aGlzKTsKIH0K 83610 2011-02-23 23:02:17 -0800 2011-02-28 15:10:46 -0800 Patch bug-53160-20110223230215.patch text/plain 14443 isherman ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlNTU5NzRlNmI4NzAwMmI5N2YwYWRjMmMxMDkwNzY2NWI3NjViYmY4Li5mYmIzMjc3 NzM4NTE4NmIzYzIwYTZhNDNmNmQzNWNhMzQ0M2NiZTZiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVt ZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxl bWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2ds ZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgICogZmFzdC9m b3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sOiBBZGRlZC4KKwog MjAxMS0wMi0yMiAgQW5kcmV3IFdpbHNvbiAgPGF0d2lsc29uQGNocm9taXVtLm9yZz4KIAogICAg ICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByNzkzMzkuCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZDA1OTQ5OThiYzkwMzg5MDQxMTQ4YmRhMjE2ODE0YWYxYzE1NDBlZgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFs dWVmb3J1c2VyLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDUgQEAKK1RoaXMgdGVzdHMgdGhhdCBv bmNoYW5nZSBjb3JyZWN0bHkgZmlyZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1ZUZvclVzZXIoKS4g SXQgY2FuIG9ubHkgYmUgcnVuIHVzaW5nIER1bXBSZW5kZXJUcmVlLgorCit0ZXh0IG9uY2hhbmdl Cit0ZXh0IG9uYmx1cgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hh bmdlLXNldHZhbHVlZm9ydXNlci5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5n ZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xZDY4NTZjNzM0ZjllZjZkZDc1NWZl MDYxMGUzZDhhZTU4MjExNWRiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9m b3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApAQCAtMCwwICsxLDMxIEBACis8aHRt bD4KKzxoZWFkPgorICAgIDxzY3JpcHQ+CisgICAgZnVuY3Rpb24gbG9nKG1zZykgeworICAgICAg ICB2YXIgcmVzID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3JlcycpOworICAgICAgICByZXMu aW5uZXJIVE1MID0gcmVzLmlubmVySFRNTCArIG1zZyArICI8YnI+IjsKKyAgICB9CisKKyAgICBm dW5jdGlvbiB0ZXN0KCkgeworICAgICAgICB2YXIgdGYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgndGYnKTsKKworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIH0K KworICAgICAgICB0Zi5mb2N1cygpOworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5zZXRWYWx1ZUZvclVz ZXIodGYsICJIZWxsbyEiKTsKKyAgICAgICAgfQorICAgICAgICB0Zi5ibHVyKCk7CisgICAgfQor ICAgIDwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgIFRoaXMg dGVzdHMgdGhhdCBvbmNoYW5nZSBjb3JyZWN0bHkgZmlyZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1 ZUZvclVzZXIoKS4gIEl0IGNhbiBvbmx5IGJlIHJ1biB1c2luZyBEdW1wUmVuZGVyVHJlZS48YnI+ CisgICAgPGZvcm0gbmFtZT0iZm0iPgorICAgICAgICA8aW5wdXQgdHlwZT0idGV4dCIgaWQ9InRm IiBvbmNoYW5nZT0ibG9nKCd0ZXh0IG9uY2hhbmdlJykiIG9uYmx1cj0ibG9nKCd0ZXh0IG9uYmx1 cicpIiAvPgorICAgIDwvZm9ybT4KKyAgICA8ZGl2IGlkPSJyZXMiPjwvZGl2PgorPC9ib2R5Pgor PC9odG1sPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCmluZGV4IGRjYTJlZjU0NzZlNmRiN2I3M2QxNzI3YTg2OWMzZTJjNjgy ZjdhMmUuLjgxZjJmZGUwMDQzYTYyMWY5NjhmN2M1MDQzZGE1NmRjMDI5OTAyNWYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxOCBAQAorMjAxMS0wMi0yMyAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5A Y2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5n ZSBldmVudCB3aGVuIHRoZSBlbGVtZW50IGlzIGZvY3VzZWQKKyAgICAgICAgSW4gc2VydmljZSBv ZiBodHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9taXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3 MTYKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTYw CisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRt bAorCisgICAgICAgICogV2ViQ29yZS5leHAuaW46CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRF bGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVl KToKKyAgICAgICAgICAgIEZvciBhIGZvY3VzZWQgdGV4dCBmaWVsZCwgdGVsbCB0aGUgcmVuZGVy ZXIgdGhhdCB0aGUgdmFsdWUgaGFzIGNoYW5nZWQgc2luY2UgdGhlIGxhc3QgY2hhbmdlIGV2ZW50 LgorCiAyMDExLTAyLTIyICBCZXRoIERha2luICA8YmRha2luQGFwcGxlLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS5leHAuaW4gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCBjNmE5Yzgw NzRmNDMyYmM3MmM2MTZiMGVlYjE1YmY2NzczMmNiZGU5Li44NzhjMjFmZGEzMTA5ZTM2NjU4MTAy MGQ4MTE5NjAxZjA4ZjEwNGMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4 cC5pbgorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgpAQCAtMzYyLDYgKzM2Miw3 IEBAIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4zMnJlbW92ZU9yaWdpbkFjY2Vzc1doaXRl bGlzdEVudHJ5RVJLUzBfUktOM1dURjZTdHJpCiBfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2lu NDBzZXREb21haW5SZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJMU2NoZW1lRWJSS04zV1RGNlN0cmlu Z0UKIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTjNXVEY2U3RyaW5nRVM0 X2kKIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFaQorX19a TjdXZWJDb3JlMTR0b0lucHV0RWxlbWVudEVQTlNfN0VsZW1lbnRFCiBfX1pON1dlYkNvcmUxNUFy Y2hpdmVSZXNvdXJjZTZjcmVhdGVFTjNXVEYxMFBhc3NSZWZQdHJJTlNfMTJTaGFyZWRCdWZmZXJF RUVSS05TXzRLVVJMRVJLTlMxXzZTdHJpbmdFU0FfU0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VF CiBfX1pON1dlYkNvcmUxNURPTVdyYXBwZXJXb3JsZDEzY2xlYXJXcmFwcGVyc0V2CiBfX1pON1dl YkNvcmUxNURPTVdyYXBwZXJXb3JsZEQxRXYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVs ZW1lbnQuY3BwCmluZGV4IDZjNWZjMDVlN2U4YmRhNTlmZjc4Mjk4OWMwMDc0ZTZiMmJlMzlkMzEu LmRkNTE5NDBmYzIzOTVhZDQzNDcwMzMzODJlYmE0NzRhMDU3NzViMjcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODg5LDEwICs4ODksMTUgQEAgdm9pZCBI VE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZShjb25zdCBTdHJpbmcmIHZhbHVlLCBib29sIHNlbmRD aGFuZ2VFdmVudCkKICAgICB9CiAgICAgbV9pbnB1dFR5cGUtPnZhbHVlQ2hhbmdlZCgpOwogCi0g ICAgLy8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5nZSBldmVudCB3aGVuIGZvY3VzZWQsIGl0IHdp bGwgYmUgZGlzcGF0Y2hlZAotICAgIC8vIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCi0g ICAgaWYgKHNlbmRDaGFuZ2VFdmVudCAmJiBkb2N1bWVudCgpLT5mb2N1c2VkTm9kZSgpICE9IHRo aXMpCisgICAgaWYgKHNlbmRDaGFuZ2VFdmVudCkgeworICAgICAgLy8gRm9yIHRleHQgZmllbGRz LCBkb24ndCBkaXNwYXRjaCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4gZm9jdXNlZC4KKyAgICAgIC8v IEl0IHdpbGwgYmUgZGlzcGF0Y2hlZCB3aGVuIHRoZSBjb250cm9sIGxvc2VzIGZvY3VzLgorICAg ICAgUmVuZGVyT2JqZWN0KiByID0gcmVuZGVyZXIoKTsKKyAgICAgIGlmIChyICYmIHItPmlzVGV4 dEZpZWxkKCkgJiYgZG9jdW1lbnQoKS0+Zm9jdXNlZE5vZGUoKSA9PSB0aGlzKQorICAgICAgICAg IHRvUmVuZGVyVGV4dENvbnRyb2wociktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCh0 cnVlKTsKKyAgICAgIGVsc2UKICAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50 KCk7CisgICAgfQogCiAgICAgSW5wdXRFbGVtZW50Ojpub3RpZnlGb3JtU3RhdGVDaGFuZ2VkKHRo aXMpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nIGIvU291cmNl L1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IGQ5NDc3MGU3Mjc5OTg2MzI0MzYwZGVkZTYwZDYy OTI1YzFjODlhODQuLjIyYTE1ZWYzNDEzZDYzMjY5ZTBkOWY0MTM2ZTA5YmQyMjNlMTU2NjggMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0 L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMS0wMi0yMyAgSWx5YSBTaGVybWFu ICA8aXNoZXJtYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNj aGVkdWxlIGNoYW5nZSBldmVudCB3aGVuIHRoZSBlbGVtZW50IGlzIGZvY3VzZWQKKyAgICAgICAg SW4gc2VydmljZSBvZiBodHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9taXVtL2lzc3Vlcy9k ZXRhaWw/aWQ9NDI3MTYKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTUzMTYwCisKKyAgICAgICAgKiBXZWJWaWV3L1dlYlZpZXcubW06CisgICAgICAgICgt W1dlYlZpZXcgX3NldFZhbHVlRm9yVXNlcjpmb3JFbGVtZW50OndpdGhWYWx1ZTpdKTogRXhwb3Nl IEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlRm9yVXNlcigpIHRvIHRlc3RzCisgICAgICAgICog V2ViVmlldy9XZWJWaWV3SW50ZXJuYWwuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlZpZXdQcml2 YXRlLmg6CisKIDIwMTEtMDItMjIgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IEFuZGVycyBDYXJsc3Nvbi4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViVmlldy5tbQppbmRleCBkMWFlNzM0MDU2NGYxMGVlMTAyOGQ4ZGQwZmE2OWQyOTlmNzVi M2IyLi5kZWU2MDc3MmFhMTUwMTc5YzBiNzhjMDUyMDBiMmM0OTI0Njk0MTBjIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KKysrIGIvU291cmNlL1dlYktp dC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCkBAIC0xMDgsNiArMTA4LDcgQEAKICNpbXBvcnQgPEZv dW5kYXRpb24vTlNVUkxDb25uZWN0aW9uLmg+CiAjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9BUElD YXN0Lmg+CiAjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9KU1ZhbHVlUmVmLmg+CisjaW1wb3J0IDxK YXZhU2NyaXB0Q29yZS9PcGFxdWVKU1N0cmluZy5oPgogI2ltcG9ydCA8V2ViQ29yZS9BYnN0cmFj dERhdGFiYXNlLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0FwcGxpY2F0aW9uQ2FjaGVTdG9yYWdlLmg+ CiAjaW1wb3J0IDxXZWJDb3JlL0JhY2tGb3J3YXJkTGlzdEltcGwuaD4KQEAgLTEzMiw2ICsxMzMs NyBAQAogI2ltcG9ydCA8V2ViQ29yZS9IVE1MTmFtZXMuaD4KICNpbXBvcnQgPFdlYkNvcmUvSGlz dG9yeUl0ZW0uaD4KICNpbXBvcnQgPFdlYkNvcmUvSWNvbkRhdGFiYXNlLmg+CisjaW1wb3J0IDxX ZWJDb3JlL0lucHV0RWxlbWVudC5oPgogI2ltcG9ydCA8V2ViQ29yZS9KU0NTU1N0eWxlRGVjbGFy YXRpb24uaD4KICNpbXBvcnQgPFdlYkNvcmUvSlNEb2N1bWVudC5oPgogI2ltcG9ydCA8V2ViQ29y ZS9KU0VsZW1lbnQuaD4KQEAgLTYyNDUsNiArNjI0NywzNSBAQCBzdGF0aWMgdm9pZCBnbGliQ29u dGV4dEl0ZXJhdGlvbkNhbGxiYWNrKENGUnVuTG9vcE9ic2VydmVyUmVmLCBDRlJ1bkxvb3BBY3Rp dml0eQogCiBAZW5kCiAKK0BpbXBsZW1lbnRhdGlvbiBXZWJWaWV3IChXZWJWaWV3UHJpdmF0ZVNl dFZhbHVlRm9yVXNlcikKKworLSAodm9pZClfc2V0VmFsdWVGb3JVc2VyOihKU0NvbnRleHRSZWYp Y29udGV4dCBmb3JFbGVtZW50OihKU1ZhbHVlUmVmKWVsZW1lbnQgd2l0aFZhbHVlOihKU1ZhbHVl UmVmKXZhbHVlCit7CisgICAgaWYgKCFlbGVtZW50IHx8ICF2YWx1ZSkKKyAgICAgICAgcmV0dXJu OworCisgICAgSlNMb2NrIGxvY2soU2lsZW5jZUFzc2VydGlvbnNPbmx5KTsKKyAgICBFeGVjU3Rh dGUqIGV4ZWMgPSB0b0pTKGNvbnRleHQpOworICAgIEpTVmFsdWUganNFbGVtZW50VmFsdWUgPSB0 b0pTKGV4ZWMsIGVsZW1lbnQpOworICAgIGlmICghanNFbGVtZW50VmFsdWUuaW5oZXJpdHMoJkpT RWxlbWVudDo6c19pbmZvKSkKKyAgICAgICAgcmV0dXJuOworICAgIEpTRWxlbWVudCoganNFbGVt ZW50ID0gc3RhdGljX2Nhc3Q8SlNFbGVtZW50Kj4oYXNPYmplY3QoanNFbGVtZW50VmFsdWUpKTsK KyAgICBFbGVtZW50KiB3ZWJjb3JlRWxlbWVudCA9IGpzRWxlbWVudC0+aW1wbCgpOworICAgIElu cHV0RWxlbWVudCogaW5wdXRFbGVtZW50ID0gdG9JbnB1dEVsZW1lbnQod2ViY29yZUVsZW1lbnQp OworICAgIGlmICghaW5wdXRFbGVtZW50KQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIUpT VmFsdWVJc1N0cmluZyhjb250ZXh0LCB2YWx1ZSkpCisgICAgICAgIHJldHVybjsKKyAgICBKU1N0 cmluZ1JlZiBqc1N0cmluZ1ZhbHVlID0gSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCB2YWx1 ZSwgTlVMTCk7CisgICAgU3RyaW5nIHN0cmluZ1ZhbHVlKGpzU3RyaW5nVmFsdWUtPmNoYXJhY3Rl cnMoKSwganNTdHJpbmdWYWx1ZS0+bGVuZ3RoKCkpOworCisgICAgaW5wdXRFbGVtZW50LT5zZXRW YWx1ZUZvclVzZXIoc3RyaW5nVmFsdWUpOworICAgIHJldHVybjsKK30KKworQGVuZAorCiBAaW1w bGVtZW50YXRpb24gV2ViVmlldyAoV2ViVmlld1ByaXZhdGVOb2Rlc0Zyb21SZWN0KQogCiAtIChK U1ZhbHVlUmVmKV9ub2Rlc0Zyb21SZWN0OihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JEb2N1bWVu dDooSlNWYWx1ZVJlZil2YWx1ZSB4OihpbnQpeCAgeTooaW50KXkgdG9wOih1bnNpZ25lZCl0b3Ag cmlnaHQ6KHVuc2lnbmVkKXJpZ2h0IGJvdHRvbToodW5zaWduZWQpYm90dG9tIGxlZnQ6KHVuc2ln bmVkKWxlZnQgaWdub3JlQ2xpcHBpbmc6KEJPT0wpaWdub3JlQ2xpcHBpbmcKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmggYi9Tb3VyY2UvV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oCmluZGV4IDU1NWM0ZDExMGVkMGJmYzlj ZmI2NWRjOTYyZjBiMjgxMTA5NzI3ODcuLmEyMzEwMjQ1YWQ5YjBkNDI3Y2NkZjUzOTJjZGY2NDUw Mjk4MmI0YzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0lu dGVybmFsLmgKKysrIGIvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3SW50ZXJuYWwu aApAQCAtMTk0LDYgKzE5NCw0IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIC0gKHZvaWQpX2Z1bGxT Y3JlZW5SZW5kZXJlckNoYW5nZWQ6KFdlYkNvcmU6OlJlbmRlckJveCopcmVuZGVyZXI7CiAjZW5k aWYKIAotLSAoSlNWYWx1ZVJlZilfY29tcHV0ZWRTdHlsZUluY2x1ZGluZ1Zpc2l0ZWRJbmZvOihK U0NvbnRleHRSZWYpY29udGV4dCBmb3JFbGVtZW50OihKU1ZhbHVlUmVmKXZhbHVlOwotCiBAZW5k CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgg Yi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgKaW5kZXggYTRlYTgw OWIwMDFkYmM2YTY3MjM0ZjE3MmYwMjBiYzM0Y2Y3ZTg0Yy4uOGM0YWY4NDljYTY3YTFlYTFmZTZk YWUwYjI2YmQwNzg0YjdlYzVhMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvV2ViVmll dy9XZWJWaWV3UHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmll d1ByaXZhdGUuaApAQCAtNjc3LDYgKzY3NywxMCBAQCBDb3VsZCBiZSB3b3J0aCBhZGRpbmcgdG8g dGhlIEFQSS4KIC0gKEpTVmFsdWVSZWYpX2NvbXB1dGVkU3R5bGVJbmNsdWRpbmdWaXNpdGVkSW5m bzooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZil2YWx1ZTsKIEBl bmQKIAorQGludGVyZmFjZSBXZWJWaWV3IChXZWJWaWV3UHJpdmF0ZVNldFZhbHVlRm9yVXNlcikK Ky0gKHZvaWQpX3NldFZhbHVlRm9yVXNlcjooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRWxlbWVu dDooSlNWYWx1ZVJlZillbGVtZW50IHdpdGhWYWx1ZTooSlNWYWx1ZVJlZil2YWx1ZTsKK0BlbmQK KwogQGludGVyZmFjZSBXZWJWaWV3IChXZWJWaWV3UHJpdmF0ZU5vZGVzRnJvbVJlY3QpCiAtIChK U1ZhbHVlUmVmKV9ub2Rlc0Zyb21SZWN0OihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JEb2N1bWVu dDooSlNWYWx1ZVJlZil2YWx1ZSB4OihpbnQpeCAgeTooaW50KXkgdG9wOih1bnNpZ25lZCl0b3Ag cmlnaHQ6KHVuc2lnbmVkKXJpZ2h0IGJvdHRvbToodW5zaWduZWQpYm90dG9tIGxlZnQ6KHVuc2ln bmVkKWxlZnQgaWdub3JlQ2xpcHBpbmc6KEJPT0wpaWdub3JlQ2xpcHBpbmc7CiBAZW5kCmRpZmYg LS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggN2IyYzJjYzMx ZGZjZDQzN2FhMzI3YTBlZTZlNWVkODVlOGU0MWJjMy4uZDZjMTRlNzY5NGVlNTMwMWE1MGU4MjUz NGYwYWI1Mzk2YWYwY2ZjNiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDExLTAyLTIzICBJbHlhIFNoZXJtYW4gIDxp c2hlcm1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgSFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWUoKSBzaG91bGQgc2NoZWR1 bGUgY2hhbmdlIGV2ZW50IHdoZW4gdGhlIGVsZW1lbnQgaXMgZm9jdXNlZAorICAgICAgICBJbiBz ZXJ2aWNlIG9mIGh0dHBzOi8vY29kZS5nb29nbGUuY29tL3AvY2hyb21pdW0vaXNzdWVzL2RldGFp bD9pZD00MjcxNgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NTMxNjAKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVy LmNwcDoKKyAgICAgICAgKHNldFZhbHVlRm9yVXNlckNhbGxiYWNrKToKKyAgICAgICAgKExheW91 dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAqIER1bXBSZW5kZXJU cmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFj L0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnNldFZhbHVlRm9yVXNlcik6IEV4cG9zZSBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZUZv clVzZXIoKSB0byB0ZXN0cworCiAyMDExLTAyLTE4ICBNaWhhaSBQYXJwYXJpdGEgIDxtaWhhaXBA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE9qYW4gVmFmYWkuCmRpZmYgLS1n aXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9Ub29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggMTZjZmU3ODVi MDc5NDY1NzFhZDYwNDJjOTdjZWY4ODJlOGUxNGMwOC4uZGY5NzgyMWZmMGM5YzcyZDM5MGEwMzFk ODU5MGQ3YzZiMWVkZWRhYyAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RD b250cm9sbGVyLmNwcApAQCAtMTQyNCw2ICsxNDI0LDE4IEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHNl dFVzZXJTdHlsZVNoZWV0TG9jYXRpb25DYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNP YmplCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0 aWMgSlNWYWx1ZVJlZiBzZXRWYWx1ZUZvclVzZXJDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4 dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBh cmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBl eGNlcHRpb24pCit7CisgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgorICAgIGlmIChhcmd1 bWVudENvdW50ICE9IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250 ZXh0KTsKKworICAgIExheW91dFRlc3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gc3RhdGljX2Nh c3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09iamVjdCkp OworICAgIGNvbnRyb2xsZXItPnNldFZhbHVlRm9yVXNlcihjb250ZXh0LCBhcmd1bWVudHNbMF0s IGFyZ3VtZW50c1sxXSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4 dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIHNldFZpZXdNb2RlTWVkaWFGZWF0dXJlQ2FsbGJh Y2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJl ZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1 bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgaW1wbGVt ZW50YXRpb24KQEAgLTIxMDksNiArMjEyMSw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91dFRl c3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJzZXRVc2VEYXNoYm9h cmRDb21wYXRpYmlsaXR5TW9kZSIsIHNldFVzZURhc2hib2FyZENvbXBhdGliaWxpdHlNb2RlQ2Fs bGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0VXNlclN0eWxlU2hlZXRFbmFibGVkIiwgc2V0 VXNlclN0eWxlU2hlZXRFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0VXNl clN0eWxlU2hlZXRMb2NhdGlvbiIsIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb25DYWxsYmFjaywg a0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERl bGV0ZSB9LAorICAgICAgICB7ICJzZXRWYWx1ZUZvclVzZXIiLCBzZXRWYWx1ZUZvclVzZXJDYWxs YmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNldFZp ZXdNb2RlTWVkaWFGZWF0dXJlIiwgc2V0Vmlld01vZGVNZWRpYUZlYXR1cmVDYWxsYmFjaywga0pT UHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0 ZSB9LAogICAgICAgICB7ICJzZXRXZWJWaWV3RWRpdGFibGUiLCBzZXRXZWJWaWV3RWRpdGFibGVD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRXaWxsU2VuZFJlcXVlc3RDbGVhckhlYWRl ciIsIHNldFdpbGxTZW5kUmVxdWVzdENsZWFySGVhZGVyQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKZGlmZiAt LWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmggYi9Ub29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCmluZGV4IDNkNjVlY2ZlYzli Yjk3NWQyMmE4MjVlZGE3M2Y0YTRkY2JjOTJlZTQuLjczNThlODFmNjFkOGJkZTRlZWY5Yzk2YzEx MzEzNDc0NjZiYjM1YzQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmgKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaApAQCAtMTExLDYgKzExMSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldFVzZURhc2hi b2FyZENvbXBhdGliaWxpdHlNb2RlKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBzZXRVc2VyU3R5bGVT aGVldEVuYWJsZWQoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRp b24oSlNTdHJpbmdSZWYgcGF0aCk7CisgICAgdm9pZCBzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0 UmVmLCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVSZWYgdmFsdWUpOwogICAgIHZvaWQgc2V0 Vmlld01vZGVNZWRpYUZlYXR1cmUoSlNTdHJpbmdSZWYgbW9kZSk7CiAgICAgdm9pZCBzZXRYU1NB dWRpdG9yRW5hYmxlZChib29sIGZsYWcpOwogICAgIHZvaWQgc2V0RnJhbWVGbGF0dGVuaW5nRW5h YmxlZChib29sIGVuYWJsZSk7CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMv TGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0gYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5 b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KaW5kZXggNDQ1NDRjZDM2MDZmZjAyODM2Yzc2ZmU5MWE1 MDM5OTM4ZDY3NmI1NC4uMTBlMGRlZmRmZTE3MDIzZGU4ZWFkZWRhYmJjMmYwMjUzZDFlMmE1ZiAx MDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVy TWFjLm1tCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxl ck1hYy5tbQpAQCAtNDc5LDYgKzQ3OSwxMSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpz ZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpCiAgICAgW1tXZWJQcmVm ZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uOnVy bF07CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcihKU0Nv bnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBlbGVtZW50LCBKU1ZhbHVlUmVmIHZhbHVlKQor eworICAgIFtbbWFpbkZyYW1lIHdlYlZpZXddIF9zZXRWYWx1ZUZvclVzZXI6Y29udGV4dCBmb3JF bGVtZW50OmVsZW1lbnQgd2l0aFZhbHVlOnZhbHVlXTsKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUoSlNTdHJpbmdSZWYgbW9kZSkKIHsKICAg ICAvLyBGSVhNRTogaW1wbGVtZW50Cg== 84131 2011-02-28 15:10:50 -0800 2011-02-28 15:59:04 -0800 Patch bug-53160-20110228151049.patch text/plain 18389 isherman U3VidmVyc2lvbiBSZXZpc2lvbjogNzk4ODIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAxNGRkZGJmYmY0NmVmZjFlZGFkODMw ZGFjOWMxMjk3MmQ1NDY1ZGVkLi4zOGU3NjliMWY5YjJiYzU1Mjg1NTgzYmViZjkwZTQzMDdlZmJj NmZkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlz aGVybWFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVs ZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNl cnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWls P2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01MzE2MAorCisgICAgICAgICogZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZh bHVlZm9ydXNlci5odG1sOiBBZGRlZC4KKwogMjAxMS0wMi0yOCAgTWloYWkgUGFycGFyaXRhICA8 bWloYWlwQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIENocm9taXVtIGV4cGVj dGF0aW9ucyBjaGFuZ2UuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hh bmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1z L29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmM2M2Ex ZGQzODZlMTBjOGZhNTVjZjc0ODZjMGIwMTAwMDljMGVmMAotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDQgQEAKK1RoaXMgdGVzdHMgdGhhdCBvbmNoYW5nZSBjb3JyZWN0bHkgZmly ZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1ZUZvclVzZXIoKS4gSXQgY2FuIG9ubHkgYmUgcnVuIHVz aW5nIER1bXBSZW5kZXJUcmVlLgorCitQQVNTIAorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40ZGJiOGY3 OWUwNzY2NjM0MmExYWU2YTM3OWIyNzc4NmY0NTU0NTNjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApAQCAtMCww ICsxLDQ0IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQ+CisgICAgZnVuY3Rpb24g dGVzdCgpIHsKKyAgICAgICAgdmFyIHRmID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3RmJyk7 CisKKyAgICAgICAgdmFyIGRpZEZpcmVPbkNoYW5nZSA9IGZhbHNlOworICAgICAgICB0Zi5vbmNo YW5nZSA9IGZ1bmN0aW9uKCkgeworICAgICAgICAgIGRpZEZpcmVPbkNoYW5nZSA9IHRydWU7Cisg ICAgICAgIH0KKworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIH0K KworICAgICAgICB0Zi5mb2N1cygpOworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5zZXRWYWx1ZUZvclVz ZXIodGYsICdIZWxsbyEnKTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFNob3VsZCBub3QgZmly ZSB0aGUgZXZlbnQgdW50aWwgZm9jdXMgaXMgbG9zdC4KKyAgICAgICAgaWYgKGRpZEZpcmVPbkNo YW5nZSkgeworICAgICAgICAgICAgdGVzdEZhaWxlZCgnb25jaGFuZ2UgZmlyZWQgdG9vIGVhcmx5 Jyk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICB0Zi5ibHVyKCk7 CisgICAgICAgIGlmIChkaWRGaXJlT25DaGFuZ2UpIHsKKyAgICAgICAgICAgIHRlc3RQYXNzZWQo JycpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgdGVzdEZhaWxlZCgnb25jaGFuZ2Ug bmV2ZXIgZmlyZWQnKQorICAgICAgICB9CisgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFkPgor PGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgIFRoaXMgdGVzdHMgdGhhdCBvbmNoYW5nZSBjb3Jy ZWN0bHkgZmlyZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1ZUZvclVzZXIoKS4gIEl0IGNhbiBvbmx5 IGJlIHJ1biB1c2luZyBEdW1wUmVuZGVyVHJlZS48YnI+CisgICAgPGZvcm0gbmFtZT0iZm0iPgor ICAgICAgICA8aW5wdXQgdHlwZT0idGV4dCIgaWQ9InRmIiAvPgorICAgIDwvZm9ybT4KKyAgICA8 ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBj M2U5ZmEwZWNjZTA3OWNmMDY0Zjg0ODZkM2MyYTJkNDYzYjRkZDYzLi4xYzk0YWVjMjcwZjYzZDU3 M2FmYmEyZGY5YjkyMzAwNGNkODI1ZmQxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIw MTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVtZW50 OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxlbWVu dCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5j b20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgIFRlc3Q6IGZhc3Qv Zm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUu ZXhwLmluOgorICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSk6CisgICAgICAgICAgICBGb3IgYSBm b2N1c2VkIHRleHQgZmllbGQsIHRlbGwgdGhlIHJlbmRlcmVyIHRoYXQgdGhlIHZhbHVlIGhhcyBj aGFuZ2VkIHNpbmNlIHRoZSBsYXN0IGNoYW5nZSBldmVudC4KKwogMjAxMS0wMi0yOCAgU2hlcmlm ZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjc5ODc3LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS5leHAuaW4gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCBlZmNiN2JmMzgw MDY1YzIyNTkwNmNlZjk4MjQwOTFjMmI3MDUxZWIyLi43NTcyN2E0MzExOTIyNDhhMjk2OTRlOTA1 NDk4OGJmZTcyZTcyY2U4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5p bgorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgpAQCAtMzYzLDYgKzM2Myw3IEBA IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4zMnJlbW92ZU9yaWdpbkFjY2Vzc1doaXRlbGlz dEVudHJ5RVJLUzBfUktOM1dURjZTdHJpCiBfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luNDBz ZXREb21haW5SZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJMU2NoZW1lRWJSS04zV1RGNlN0cmluZ0UK IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTjNXVEY2U3RyaW5nRVM0X2kK IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFaQorX19aTjdX ZWJDb3JlMTR0b0lucHV0RWxlbWVudEVQTlNfN0VsZW1lbnRFCiBfX1pON1dlYkNvcmUxNUFyY2hp dmVSZXNvdXJjZTZjcmVhdGVFTjNXVEYxMFBhc3NSZWZQdHJJTlNfMTJTaGFyZWRCdWZmZXJFRUVS S05TXzRLVVJMRVJLTlMxXzZTdHJpbmdFU0FfU0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VFCiBf X1pON1dlYkNvcmUxNURPTVdyYXBwZXJXb3JsZDEzY2xlYXJXcmFwcGVyc0V2CiBfX1pON1dlYkNv cmUxNURPTVdyYXBwZXJXb3JsZEQxRXYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1l bnQuY3BwCmluZGV4IGEyMjFkM2U1YTlmZjIxNjIzNDA1OTVhZmZkMTM0NmIyMDlmNmJlMmYuLmY4 OGU2N2Y5NzU4MzJjYmE5MjJiNThjMWNkNzYxNDkxZjA4YzMwNTEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODg5LDEwICs4ODksMTUgQEAgdm9pZCBIVE1M SW5wdXRFbGVtZW50OjpzZXRWYWx1ZShjb25zdCBTdHJpbmcmIHZhbHVlLCBib29sIHNlbmRDaGFu Z2VFdmVudCkKICAgICB9CiAgICAgbV9pbnB1dFR5cGUtPnZhbHVlQ2hhbmdlZCgpOwogCi0gICAg Ly8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5nZSBldmVudCB3aGVuIGZvY3VzZWQsIGl0IHdpbGwg YmUgZGlzcGF0Y2hlZAotICAgIC8vIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCi0gICAg aWYgKHNlbmRDaGFuZ2VFdmVudCAmJiBkb2N1bWVudCgpLT5mb2N1c2VkTm9kZSgpICE9IHRoaXMp Ci0gICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAgIGlmIChzZW5k Q2hhbmdlRXZlbnQpIHsKKyAgICAgICAgLy8gRm9yIHRleHQgZmllbGRzLCBkb24ndCBkaXNwYXRj aCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4gZm9jdXNlZC4KKyAgICAgICAgLy8gSXQgd2lsbCBiZSBk aXNwYXRjaGVkIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCisgICAgICAgIFJlbmRlck9i amVjdCogciA9IHJlbmRlcmVyKCk7CisgICAgICAgIGlmIChyICYmIHItPmlzVGV4dEZpZWxkKCkg JiYgZG9jdW1lbnQoKS0+Zm9jdXNlZE5vZGUoKSA9PSB0aGlzKQorICAgICAgICAgICAgdG9SZW5k ZXJUZXh0Q29udHJvbChyKS0+c2V0Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KHRydWUpOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBkaXNwYXRjaEZvcm1Db250cm9sQ2hhbmdlRXZlbnQo KTsKKyAgICB9CiAKICAgICBJbnB1dEVsZW1lbnQ6Om5vdGlmeUZvcm1TdGF0ZUNoYW5nZWQodGhp cyk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cgYi9Tb3VyY2Uv V2ViS2l0L21hYy9DaGFuZ2VMb2cKaW5kZXggMTYzZjY2OTk1YjQ2ZmIxM2RjNTA0ZjhjYjhhOTE5 NTlkNWY0MjgxMC4uN2U2MWYxMGNlZGJmMjU3ZmJhOWQ4MjBiYWM5NGZkNmY5YmM5MjAxNSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQv bWFjL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTAyLTIzICBJbHlhIFNoZXJtYW4g IDxpc2hlcm1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgSFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWUoKSBzaG91bGQgc2No ZWR1bGUgY2hhbmdlIGV2ZW50IHdoZW4gdGhlIGVsZW1lbnQgaXMgZm9jdXNlZAorICAgICAgICBJ biBzZXJ2aWNlIG9mIGh0dHBzOi8vY29kZS5nb29nbGUuY29tL3AvY2hyb21pdW0vaXNzdWVzL2Rl dGFpbD9pZD00MjcxNgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NTMxNjAKKworICAgICAgICAqIFdlYlZpZXcvV2ViVmlldy5tbToKKyAgICAgICAgKC1b V2ViVmlldyBfc2V0VmFsdWVGb3JVc2VyOmZvckVsZW1lbnQ6d2l0aFZhbHVlOl0pOiBFeHBvc2Ug SFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWVGb3JVc2VyKCkgdG8gdGVzdHMKKyAgICAgICAgKiBX ZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oOgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlld1ByaXZh dGUuaDoKKwogMjAxMS0wMi0yNiAgVnNldm9sb2QgVmxhc292ICA8dnNldmlrQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBSZXZpZXdlZCBieSBQYXZlbCBGZWxkbWFuLgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tIGIvU291cmNlL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJWaWV3Lm1tCmluZGV4IDI3YjY0NzYwZmVjMGUzNmQxNmY5ODgzYjI2ZDc4YzE5ZmY2 N2U4NTcuLmYyZDM5ZGJhNjU2MTlmYmViY2NhYjNmYjIwOWFhODliYmE5MzE2MDAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbQorKysgYi9Tb3VyY2UvV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KQEAgLTEwNyw2ICsxMDcsNyBAQAogI2ltcG9ydCA8 Rm91bmRhdGlvbi9OU1VSTENvbm5lY3Rpb24uaD4KICNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0FQ SUNhc3QuaD4KICNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0pTVmFsdWVSZWYuaD4KKyNpbXBvcnQg PEphdmFTY3JpcHRDb3JlL09wYXF1ZUpTU3RyaW5nLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0Fic3Ry YWN0RGF0YWJhc2UuaD4KICNpbXBvcnQgPFdlYkNvcmUvQXBwbGljYXRpb25DYWNoZVN0b3JhZ2Uu aD4KICNpbXBvcnQgPFdlYkNvcmUvQmFja0ZvcndhcmRMaXN0SW1wbC5oPgpAQCAtMTMxLDYgKzEz Miw3IEBACiAjaW1wb3J0IDxXZWJDb3JlL0hUTUxOYW1lcy5oPgogI2ltcG9ydCA8V2ViQ29yZS9I aXN0b3J5SXRlbS5oPgogI2ltcG9ydCA8V2ViQ29yZS9JY29uRGF0YWJhc2UuaD4KKyNpbXBvcnQg PFdlYkNvcmUvSW5wdXRFbGVtZW50Lmg+CiAjaW1wb3J0IDxXZWJDb3JlL0pTQ1NTU3R5bGVEZWNs YXJhdGlvbi5oPgogI2ltcG9ydCA8V2ViQ29yZS9KU0RvY3VtZW50Lmg+CiAjaW1wb3J0IDxXZWJD b3JlL0pTRWxlbWVudC5oPgpAQCAtNjI0NCw2ICs2MjQ2LDM1IEBAIHN0YXRpYyB2b2lkIGdsaWJD b250ZXh0SXRlcmF0aW9uQ2FsbGJhY2soQ0ZSdW5Mb29wT2JzZXJ2ZXJSZWYsIENGUnVuTG9vcEFj dGl2aXR5CiAKIEBlbmQKIAorQGltcGxlbWVudGF0aW9uIFdlYlZpZXcgKFdlYlZpZXdQcml2YXRl U2V0VmFsdWVGb3JVc2VyKQorCistICh2b2lkKV9zZXRWYWx1ZUZvclVzZXI6KEpTQ29udGV4dFJl Ziljb250ZXh0IGZvckVsZW1lbnQ6KEpTVmFsdWVSZWYpZWxlbWVudCB3aXRoVmFsdWU6KEpTVmFs dWVSZWYpdmFsdWUKK3sKKyAgICBpZiAoIWVsZW1lbnQgfHwgIXZhbHVlKQorICAgICAgICByZXR1 cm47CisKKyAgICBKU0xvY2sgbG9jayhTaWxlbmNlQXNzZXJ0aW9uc09ubHkpOworICAgIEV4ZWNT dGF0ZSogZXhlYyA9IHRvSlMoY29udGV4dCk7CisgICAgSlNWYWx1ZSBqc0VsZW1lbnRWYWx1ZSA9 IHRvSlMoZXhlYywgZWxlbWVudCk7CisgICAgaWYgKCFqc0VsZW1lbnRWYWx1ZS5pbmhlcml0cygm SlNFbGVtZW50OjpzX2luZm8pKQorICAgICAgICByZXR1cm47CisgICAgSlNFbGVtZW50KiBqc0Vs ZW1lbnQgPSBzdGF0aWNfY2FzdDxKU0VsZW1lbnQqPihhc09iamVjdChqc0VsZW1lbnRWYWx1ZSkp OworICAgIEVsZW1lbnQqIHdlYmNvcmVFbGVtZW50ID0ganNFbGVtZW50LT5pbXBsKCk7CisgICAg SW5wdXRFbGVtZW50KiBpbnB1dEVsZW1lbnQgPSB0b0lucHV0RWxlbWVudCh3ZWJjb3JlRWxlbWVu dCk7CisgICAgaWYgKCFpbnB1dEVsZW1lbnQpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICgh SlNWYWx1ZUlzU3RyaW5nKGNvbnRleHQsIHZhbHVlKSkKKyAgICAgICAgcmV0dXJuOworICAgIEpT U3RyaW5nUmVmIGpzU3RyaW5nVmFsdWUgPSBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIHZh bHVlLCBOVUxMKTsKKyAgICBTdHJpbmcgc3RyaW5nVmFsdWUoanNTdHJpbmdWYWx1ZS0+Y2hhcmFj dGVycygpLCBqc1N0cmluZ1ZhbHVlLT5sZW5ndGgoKSk7CisKKyAgICBpbnB1dEVsZW1lbnQtPnNl dFZhbHVlRm9yVXNlcihzdHJpbmdWYWx1ZSk7CisgICAgcmV0dXJuOworfQorCitAZW5kCisKIEBp bXBsZW1lbnRhdGlvbiBXZWJWaWV3IChXZWJWaWV3UHJpdmF0ZU5vZGVzRnJvbVJlY3QpCiAKIC0g KEpTVmFsdWVSZWYpX25vZGVzRnJvbVJlY3Q6KEpTQ29udGV4dFJlZiljb250ZXh0IGZvckRvY3Vt ZW50OihKU1ZhbHVlUmVmKXZhbHVlIHg6KGludCl4ICB5OihpbnQpeSB0b3A6KHVuc2lnbmVkKXRv cCByaWdodDoodW5zaWduZWQpcmlnaHQgYm90dG9tOih1bnNpZ25lZClib3R0b20gbGVmdDoodW5z aWduZWQpbGVmdCBpZ25vcmVDbGlwcGluZzooQk9PTClpZ25vcmVDbGlwcGluZwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3SW50ZXJuYWwuaCBiL1NvdXJjZS9X ZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmgKaW5kZXggNTU1YzRkMTEwZWQwYmZj OWNmYjY1ZGM5NjJmMGIyODExMDk3Mjc4Ny4uYTIzMTAyNDVhZDliMGQ0MjdjY2RmNTM5MmNkZjY0 NTAyOTgyYjRjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3 SW50ZXJuYWwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5h bC5oCkBAIC0xOTQsNiArMTk0LDQgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogLSAodm9pZClfZnVs bFNjcmVlblJlbmRlcmVyQ2hhbmdlZDooV2ViQ29yZTo6UmVuZGVyQm94KilyZW5kZXJlcjsKICNl bmRpZgogCi0tIChKU1ZhbHVlUmVmKV9jb21wdXRlZFN0eWxlSW5jbHVkaW5nVmlzaXRlZEluZm86 KEpTQ29udGV4dFJlZiljb250ZXh0IGZvckVsZW1lbnQ6KEpTVmFsdWVSZWYpdmFsdWU7Ci0KIEBl bmQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUu aCBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaAppbmRleCBhNGVh ODA5YjAwMWRiYzZhNjcyMzRmMTcyZjAyMGJjMzRjZjdlODRjLi44YzRhZjg0OWNhNjdhMWVhMWZl NmRhZTBiMjZiZDA3ODRiN2VjNWEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJW aWV3L1dlYlZpZXdQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJW aWV3UHJpdmF0ZS5oCkBAIC02NzcsNiArNjc3LDEwIEBAIENvdWxkIGJlIHdvcnRoIGFkZGluZyB0 byB0aGUgQVBJLgogLSAoSlNWYWx1ZVJlZilfY29tcHV0ZWRTdHlsZUluY2x1ZGluZ1Zpc2l0ZWRJ bmZvOihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JFbGVtZW50OihKU1ZhbHVlUmVmKXZhbHVlOwog QGVuZAogCitAaW50ZXJmYWNlIFdlYlZpZXcgKFdlYlZpZXdQcml2YXRlU2V0VmFsdWVGb3JVc2Vy KQorLSAodm9pZClfc2V0VmFsdWVGb3JVc2VyOihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JFbGVt ZW50OihKU1ZhbHVlUmVmKWVsZW1lbnQgd2l0aFZhbHVlOihKU1ZhbHVlUmVmKXZhbHVlOworQGVu ZAorCiBAaW50ZXJmYWNlIFdlYlZpZXcgKFdlYlZpZXdQcml2YXRlTm9kZXNGcm9tUmVjdCkKIC0g KEpTVmFsdWVSZWYpX25vZGVzRnJvbVJlY3Q6KEpTQ29udGV4dFJlZiljb250ZXh0IGZvckRvY3Vt ZW50OihKU1ZhbHVlUmVmKXZhbHVlIHg6KGludCl4ICB5OihpbnQpeSB0b3A6KHVuc2lnbmVkKXRv cCByaWdodDoodW5zaWduZWQpcmlnaHQgYm90dG9tOih1bnNpZ25lZClib3R0b20gbGVmdDoodW5z aWduZWQpbGVmdCBpZ25vcmVDbGlwcGluZzooQk9PTClpZ25vcmVDbGlwcGluZzsKIEBlbmQKZGlm ZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCAyYzJhNTM0 ZTQyMmNiNzA5Y2NmNzA5ZGU5YWQzMzE2ZWNhMjc1ZTk3Li5lNDBjZmZkNDdlMTEyMGNjZDM0OWRk YTIyZDE3MTNkMTE4YTFhMDlkIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMTEtMDItMjMgIElseWEgU2hlcm1hbiAg PGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hl ZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIElu IHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0 YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD01MzE2MAorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwOgorICAgICAgICAoc2V0VmFsdWVGb3JVc2VyQ2FsbGJhY2spOgorICAgICAgICAoTGF5 b3V0VGVzdENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucyk6CisgICAgICAgICogRHVtcFJlbmRl clRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaDoKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9n dGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRy b2xsZXI6OnNldFZhbHVlRm9yVXNlcik6IFN0dWJiZWQgb3V0OyBuZWVkIHJlYWwgaW1wbGVtZW50 YXRpb24uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVy TWFjLm1tOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcik6 IEV4cG9zZSBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZUZvclVzZXIoKSB0byB0ZXN0cworICAg ICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwOgorICAg ICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcik6IFN0dWJiZWQgb3V0 OyBuZWVkIHJlYWwgaW1wbGVtZW50YXRpb24uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvd2lu L0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9s bGVyOjpzZXRWYWx1ZUZvclVzZXIpOiBTdHViYmVkIG91dDsgbmVlZCByZWFsIGltcGxlbWVudGF0 aW9uLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRlc3RDb250cm9sbGVyV3gu Y3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcik6IFN0 dWJiZWQgb3V0OyBuZWVkIHJlYWwgaW1wbGVtZW50YXRpb24uCisKIDIwMTEtMDItMjggIEFkYW0g Um9iZW4gIDxhcm9iZW5AYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBhIHRlc3QgZm9yIHRoZSBw YWludCByZWN0IHBhc3NlZCB2aWEgV01fUEFJTlQgdG8gd2luZG93bGVzcyBwbHVnaW5zCmRpZmYg LS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9U b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggNDE2Yjlm Y2IxMDg1ZmUxY2Q0ODNmZGQ5MmM2NmQ0YjVkYmE4Njg2ZC4uOGQ4ZWJjMzYzNmM5ZmJlNWEyNWIx NjZmNGJlMzNkMDViZjM2M2ExYiAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmNwcApAQCAtMTQzMiw2ICsxNDMyLDE4IEBAIHN0YXRpYyBKU1ZhbHVlUmVm IHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb25DYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwg SlNPYmplCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitz dGF0aWMgSlNWYWx1ZVJlZiBzZXRWYWx1ZUZvclVzZXJDYWxsYmFjayhKU0NvbnRleHRSZWYgY29u dGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVf dCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVm KiBleGNlcHRpb24pCit7CisgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgorICAgIGlmIChh cmd1bWVudENvdW50ICE9IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChj b250ZXh0KTsKKworICAgIExheW91dFRlc3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gc3RhdGlj X2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09iamVj dCkpOworICAgIGNvbnRyb2xsZXItPnNldFZhbHVlRm9yVXNlcihjb250ZXh0LCBhcmd1bWVudHNb MF0sIGFyZ3VtZW50c1sxXSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29u dGV4dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIHNldFZpZXdNb2RlTWVkaWFGZWF0dXJlQ2Fs bGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVj dFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBh cmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgaW1w bGVtZW50YXRpb24KQEAgLTIxMjksNiArMjE0MSw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91 dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJzZXRVc2VEYXNo Ym9hcmRDb21wYXRpYmlsaXR5TW9kZSIsIHNldFVzZURhc2hib2FyZENvbXBhdGliaWxpdHlNb2Rl Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0VXNlclN0eWxlU2hlZXRFbmFibGVkIiwg c2V0VXNlclN0eWxlU2hlZXRFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVh ZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0 VXNlclN0eWxlU2hlZXRMb2NhdGlvbiIsIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb25DYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LAorICAgICAgICB7ICJzZXRWYWx1ZUZvclVzZXIiLCBzZXRWYWx1ZUZvclVzZXJD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNl dFZpZXdNb2RlTWVkaWFGZWF0dXJlIiwgc2V0Vmlld01vZGVNZWRpYUZlYXR1cmVDYWxsYmFjaywg a0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERl bGV0ZSB9LAogICAgICAgICB7ICJzZXRXZWJWaWV3RWRpdGFibGUiLCBzZXRXZWJWaWV3RWRpdGFi bGVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0 cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRXaWxsU2VuZFJlcXVlc3RDbGVhckhl YWRlciIsIHNldFdpbGxTZW5kUmVxdWVzdENsZWFySGVhZGVyQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKZGlm ZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmggYi9U b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCmluZGV4IDhhMjA1MDA1 OTFlMWE0OWM3YmZhMWIzNGJmNzcyOGJmNTE2MTBiOTUuLjk1MGFjMDgzZWRlZWIwOGUzNmEyMjNj OWZkYzFiYmVkNjQ1YzhlYWEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmgKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuaApAQCAtMTExLDYgKzExMSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldFVzZURh c2hib2FyZENvbXBhdGliaWxpdHlNb2RlKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBzZXRVc2VyU3R5 bGVTaGVldEVuYWJsZWQoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9j YXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7CisgICAgdm9pZCBzZXRWYWx1ZUZvclVzZXIoSlNDb250 ZXh0UmVmLCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVSZWYgdmFsdWUpOwogICAgIHZvaWQg c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUoSlNTdHJpbmdSZWYgbW9kZSk7CiAgICAgdm9pZCBzZXRY U1NBdWRpdG9yRW5hYmxlZChib29sIGZsYWcpOwogICAgIHZvaWQgc2V0RnJhbWVGbGF0dGVuaW5n RW5hYmxlZChib29sIGVuYWJsZSk7CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9n dGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvZ3Rr L0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAppbmRleCAwYmJhYjg2N2VmYjAwNTM0M2VkYWU5 OTk4OTYyYzRiNDk4ZGZmZjZhLi5lOWI4NGZhNWUyODdlZWU3ODAwZWUzNTNiNTE2Mzk0Njk3ZmNi NTgzIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRy b2xsZXJHdGsuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29u dHJvbGxlckd0ay5jcHAKQEAgLTMzMyw2ICszMzMsMTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKQogICAgICAg ICBzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQodHJ1ZSk7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENv bnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcihKU0NvbnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJl ZiBlbGVtZW50LCBKU1ZhbHVlUmVmIHZhbHVlKQoreworICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQK K30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUo SlNTdHJpbmdSZWYgbW9kZSkKIHsKICAgICBXZWJLaXRXZWJWaWV3KiB2aWV3ID0gd2Via2l0X3dl Yl9mcmFtZV9nZXRfd2ViX3ZpZXcobWFpbkZyYW1lKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbSBiL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQppbmRleCBiYzlkYmI3YzgyODlj MmMzMzFmZWE4ZDFmMWY1YTYwZTA2MWFkMTNjLi5hMTI1NzliZjc3MmNiODMzMDgwNTdmYzAwZDQx ODI5ZWRiZWI4Y2ZmIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0 VGVzdENvbnRyb2xsZXJNYWMubW0KKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91 dFRlc3RDb250cm9sbGVyTWFjLm1tCkBAIC00NzksNiArNDc5LDExIEBAIHZvaWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6OnNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCkK ICAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVyZW5jZXNdIHNldFVzZXJTdHlsZVNo ZWV0TG9jYXRpb246dXJsXTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFs dWVGb3JVc2VyKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFs dWVSZWYgdmFsdWUpCit7CisgICAgW1ttYWluRnJhbWUgd2ViVmlld10gX3NldFZhbHVlRm9yVXNl cjpjb250ZXh0IGZvckVsZW1lbnQ6ZWxlbWVudCB3aXRoVmFsdWU6dmFsdWVdOworfQorCiB2b2lk IExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1Jl ZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1 bXBSZW5kZXJUcmVlL3F0L0xheW91dFRlc3RDb250cm9sbGVyUXQuY3BwIGIvVG9vbHMvRHVtcFJl bmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHAKaW5kZXggYmI5YWFlODFhZTg1 NWQyMjgzM2VkY2JlZGFiZDM3OTc1ZDY5OWZlOC4uMzY4NWFiNDAwOTdmMWYxN2M0MjhjYmU3YjBh NjRiODQ0MDU4ZDY5ZiAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0 VGVzdENvbnRyb2xsZXJRdC5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5b3V0 VGVzdENvbnRyb2xsZXJRdC5jcHAKQEAgLTE0OCw2ICsxNDgsMTEgQEAgUVN0cmluZyBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6Y291bnRlclZhbHVlRm9yRWxlbWVudEJ5SWQoY29uc3QgUVN0cmluZyYg aWQpCiAgICAgcmV0dXJuIER1bXBSZW5kZXJUcmVlU3VwcG9ydFF0Ojpjb3VudGVyVmFsdWVGb3JF bGVtZW50QnlJZChtX2RydC0+d2ViUGFnZSgpLT5tYWluRnJhbWUoKSwgaWQpOwogfQogCit2b2lk IExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRl eHQsIEpTVmFsdWVSZWYgZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSkKK3sKKyAgICAvLyBGSVhN RTogaW1wbGVtZW50Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZpZXdNb2Rl TWVkaWFGZWF0dXJlKGNvbnN0IFFTdHJpbmcmIG1vZGUpCiB7CiAgICAgbV9kcnQtPndlYlBhZ2Uo KS0+c2V0UHJvcGVydHkoIl9xX3ZpZXdNb2RlIiwgbW9kZSk7CmRpZmYgLS1naXQgYS9Ub29scy9E dW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwIGIvVG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAppbmRleCA4MDg2MmVi MjFiNmI3YjFmNWM5NmY1YTk5NzNkMDgwYjQzMGNmM2JlLi42ZGE2MmQ3YjFlZjlmODhiMjBiZTli NTlmYjQwNDQ2Yzc1OTk5ZjdlIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS93aW4v TGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dp bi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKQEAgLTc1NSw2ICs3NTUsMTEgQEAgdm9pZCBM YXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1Jl ZiBqc1VSTCkKICAgICBTeXNGcmVlU3RyaW5nKHJlc3VsdFBhdGhCU1RSKTsKIH0KIAordm9pZCBM YXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKEpTQ29udGV4dFJlZiBjb250ZXh0 LCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6 IGltcGxlbWVudAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1l ZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQK ZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRlc3RDb250cm9sbGVy V3guY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5j cHAKaW5kZXggMTBlMTEwNzExNmJkNGM2MzAxZTY0MWNlZGM3YTNmMTNhNmY0YzZmYS4uNzA2NmZk YzA1ZDRjNzJhMDNmMzVlZjNiYjhiMWRmNjFhODgyMTE5YSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVt cFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAKKysrIGIvVG9vbHMvRHVt cFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAKQEAgLTEzNSw2ICsxMzUs MTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlv bihKU1N0cmluZ1JlZiBwYXRoKQogewogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpz ZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVudCwg SlNWYWx1ZVJlZiB2YWx1ZSkKK3sKKyAgICAvLyBGSVhNRTogaW1wbGVtZW50Cit9CisKIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpTU3RyaW5nUmVm IG1vZGUpCiB7CiAgICAgLy8gRklYTUU6IGltcGxlbWVudAo= 84138 2011-02-28 15:48:14 -0800 2011-02-28 16:01:53 -0800 Patch bug-53160-20110228154813.patch text/plain 18427 isherman U3VidmVyc2lvbiBSZXZpc2lvbjogNzk4ODIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAxNGRkZGJmYmY0NmVmZjFlZGFkODMw ZGFjOWMxMjk3MmQ1NDY1ZGVkLi4zOGU3NjliMWY5YjJiYzU1Mjg1NTgzYmViZjkwZTQzMDdlZmJj NmZkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlz aGVybWFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVs ZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNl cnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWls P2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01MzE2MAorCisgICAgICAgICogZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZh bHVlZm9ydXNlci5odG1sOiBBZGRlZC4KKwogMjAxMS0wMi0yOCAgTWloYWkgUGFycGFyaXRhICA8 bWloYWlwQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIENocm9taXVtIGV4cGVj dGF0aW9ucyBjaGFuZ2UuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hh bmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1z L29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmM2M2Ex ZGQzODZlMTBjOGZhNTVjZjc0ODZjMGIwMTAwMDljMGVmMAotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDQgQEAKK1RoaXMgdGVzdHMgdGhhdCBvbmNoYW5nZSBjb3JyZWN0bHkgZmly ZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1ZUZvclVzZXIoKS4gSXQgY2FuIG9ubHkgYmUgcnVuIHVz aW5nIER1bXBSZW5kZXJUcmVlLgorCitQQVNTIAorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40ZGJiOGY3 OWUwNzY2NjM0MmExYWU2YTM3OWIyNzc4NmY0NTU0NTNjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApAQCAtMCww ICsxLDQ0IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQ+CisgICAgZnVuY3Rpb24g dGVzdCgpIHsKKyAgICAgICAgdmFyIHRmID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3RmJyk7 CisKKyAgICAgICAgdmFyIGRpZEZpcmVPbkNoYW5nZSA9IGZhbHNlOworICAgICAgICB0Zi5vbmNo YW5nZSA9IGZ1bmN0aW9uKCkgeworICAgICAgICAgIGRpZEZpcmVPbkNoYW5nZSA9IHRydWU7Cisg ICAgICAgIH0KKworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIH0K KworICAgICAgICB0Zi5mb2N1cygpOworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5zZXRWYWx1ZUZvclVz ZXIodGYsICdIZWxsbyEnKTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFNob3VsZCBub3QgZmly ZSB0aGUgZXZlbnQgdW50aWwgZm9jdXMgaXMgbG9zdC4KKyAgICAgICAgaWYgKGRpZEZpcmVPbkNo YW5nZSkgeworICAgICAgICAgICAgdGVzdEZhaWxlZCgnb25jaGFuZ2UgZmlyZWQgdG9vIGVhcmx5 Jyk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICB0Zi5ibHVyKCk7 CisgICAgICAgIGlmIChkaWRGaXJlT25DaGFuZ2UpIHsKKyAgICAgICAgICAgIHRlc3RQYXNzZWQo JycpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgdGVzdEZhaWxlZCgnb25jaGFuZ2Ug bmV2ZXIgZmlyZWQnKQorICAgICAgICB9CisgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFkPgor PGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgIFRoaXMgdGVzdHMgdGhhdCBvbmNoYW5nZSBjb3Jy ZWN0bHkgZmlyZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1ZUZvclVzZXIoKS4gIEl0IGNhbiBvbmx5 IGJlIHJ1biB1c2luZyBEdW1wUmVuZGVyVHJlZS48YnI+CisgICAgPGZvcm0gbmFtZT0iZm0iPgor ICAgICAgICA8aW5wdXQgdHlwZT0idGV4dCIgaWQ9InRmIiAvPgorICAgIDwvZm9ybT4KKyAgICA8 ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBj M2U5ZmEwZWNjZTA3OWNmMDY0Zjg0ODZkM2MyYTJkNDYzYjRkZDYzLi4xYzk0YWVjMjcwZjYzZDU3 M2FmYmEyZGY5YjkyMzAwNGNkODI1ZmQxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIw MTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVtZW50 OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxlbWVu dCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5j b20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgIFRlc3Q6IGZhc3Qv Zm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUu ZXhwLmluOgorICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSk6CisgICAgICAgICAgICBGb3IgYSBm b2N1c2VkIHRleHQgZmllbGQsIHRlbGwgdGhlIHJlbmRlcmVyIHRoYXQgdGhlIHZhbHVlIGhhcyBj aGFuZ2VkIHNpbmNlIHRoZSBsYXN0IGNoYW5nZSBldmVudC4KKwogMjAxMS0wMi0yOCAgU2hlcmlm ZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjc5ODc3LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS5leHAuaW4gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCBlZmNiN2JmMzgw MDY1YzIyNTkwNmNlZjk4MjQwOTFjMmI3MDUxZWIyLi43NTcyN2E0MzExOTIyNDhhMjk2OTRlOTA1 NDk4OGJmZTcyZTcyY2U4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5p bgorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgpAQCAtMzYzLDYgKzM2Myw3IEBA IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4zMnJlbW92ZU9yaWdpbkFjY2Vzc1doaXRlbGlz dEVudHJ5RVJLUzBfUktOM1dURjZTdHJpCiBfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luNDBz ZXREb21haW5SZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJMU2NoZW1lRWJSS04zV1RGNlN0cmluZ0UK IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTjNXVEY2U3RyaW5nRVM0X2kK IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFaQorX19aTjdX ZWJDb3JlMTR0b0lucHV0RWxlbWVudEVQTlNfN0VsZW1lbnRFCiBfX1pON1dlYkNvcmUxNUFyY2hp dmVSZXNvdXJjZTZjcmVhdGVFTjNXVEYxMFBhc3NSZWZQdHJJTlNfMTJTaGFyZWRCdWZmZXJFRUVS S05TXzRLVVJMRVJLTlMxXzZTdHJpbmdFU0FfU0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VFCiBf X1pON1dlYkNvcmUxNURPTVdyYXBwZXJXb3JsZDEzY2xlYXJXcmFwcGVyc0V2CiBfX1pON1dlYkNv cmUxNURPTVdyYXBwZXJXb3JsZEQxRXYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1l bnQuY3BwCmluZGV4IGEyMjFkM2U1YTlmZjIxNjIzNDA1OTVhZmZkMTM0NmIyMDlmNmJlMmYuLjAw MzEyYmUwMmJiZTMxNWZkNzU1NzMyY2JiZDllOWQ4ZmZiYTMzYjAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODg5LDEwICs4ODksMTUgQEAgdm9pZCBIVE1M SW5wdXRFbGVtZW50OjpzZXRWYWx1ZShjb25zdCBTdHJpbmcmIHZhbHVlLCBib29sIHNlbmRDaGFu Z2VFdmVudCkKICAgICB9CiAgICAgbV9pbnB1dFR5cGUtPnZhbHVlQ2hhbmdlZCgpOwogCi0gICAg Ly8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5nZSBldmVudCB3aGVuIGZvY3VzZWQsIGl0IHdpbGwg YmUgZGlzcGF0Y2hlZAotICAgIC8vIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCi0gICAg aWYgKHNlbmRDaGFuZ2VFdmVudCAmJiBkb2N1bWVudCgpLT5mb2N1c2VkTm9kZSgpICE9IHRoaXMp Ci0gICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAgIGlmIChzZW5k Q2hhbmdlRXZlbnQpIHsKKyAgICAgICAgLy8gRm9yIHRleHQgY29udHJvbHMsIGRvbid0IGRpc3Bh dGNoIHRoZSBjaGFuZ2UgZXZlbnQgd2hlbiBmb2N1c2VkLgorICAgICAgICAvLyBJdCB3aWxsIGJl IGRpc3BhdGNoZWQgd2hlbiB0aGUgY29udHJvbCBsb3NlcyBmb2N1cy4KKyAgICAgICAgUmVuZGVy T2JqZWN0KiByZW5kZXJlciA9IHRoaXMtPnJlbmRlcmVyKCk7CisgICAgICAgIGlmIChyZW5kZXJl ciAmJiByZW5kZXJlci0+aXNUZXh0Q29udHJvbCgpICYmIGRvY3VtZW50KCktPmZvY3VzZWROb2Rl KCkgPT0gdGhpcykKKyAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wocmVuZGVyZXIpLT5z ZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQodHJ1ZSk7CisgICAgICAgIGVsc2UKKyAgICAg ICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAgIH0KIAogICAgIElu cHV0RWxlbWVudDo6bm90aWZ5Rm9ybVN0YXRlQ2hhbmdlZCh0aGlzKTsKIH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxv ZwppbmRleCAxNjNmNjY5OTViNDZmYjEzZGM1MDRmOGNiOGE5MTk1OWQ1ZjQyODEwLi43ZTYxZjEw Y2VkYmYyNTdmYmE5ZDgyMGJhYzk0ZmQ2ZjliYzkyMDE1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L21hYy9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTYgQEAKKzIwMTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBI VE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQg d2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6 Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAg ICAgICogV2ViVmlldy9XZWJWaWV3Lm1tOgorICAgICAgICAoLVtXZWJWaWV3IF9zZXRWYWx1ZUZv clVzZXI6Zm9yRWxlbWVudDp3aXRoVmFsdWU6XSk6IEV4cG9zZSBIVE1MSW5wdXRFbGVtZW50Ojpz ZXRWYWx1ZUZvclVzZXIoKSB0byB0ZXN0cworICAgICAgICAqIFdlYlZpZXcvV2ViVmlld0ludGVy bmFsLmg6CisgICAgICAgICogV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oOgorCiAyMDExLTAyLTI2 ICBWc2V2b2xvZCBWbGFzb3YgIDx2c2V2aWtAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmll d2VkIGJ5IFBhdmVsIEZlbGRtYW4uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJW aWV3L1dlYlZpZXcubW0gYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KaW5k ZXggMjdiNjQ3NjBmZWMwZTM2ZDE2Zjk4ODNiMjZkNzhjMTlmZjY3ZTg1Ny4uZjJkMzlkYmE2NTYx OWZiZWJjY2FiM2ZiMjA5YWE4OWJiYTkzMTYwMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9t YWMvV2ViVmlldy9XZWJWaWV3Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2Vi Vmlldy5tbQpAQCAtMTA3LDYgKzEwNyw3IEBACiAjaW1wb3J0IDxGb3VuZGF0aW9uL05TVVJMQ29u bmVjdGlvbi5oPgogI2ltcG9ydCA8SmF2YVNjcmlwdENvcmUvQVBJQ2FzdC5oPgogI2ltcG9ydCA8 SmF2YVNjcmlwdENvcmUvSlNWYWx1ZVJlZi5oPgorI2ltcG9ydCA8SmF2YVNjcmlwdENvcmUvT3Bh cXVlSlNTdHJpbmcuaD4KICNpbXBvcnQgPFdlYkNvcmUvQWJzdHJhY3REYXRhYmFzZS5oPgogI2lt cG9ydCA8V2ViQ29yZS9BcHBsaWNhdGlvbkNhY2hlU3RvcmFnZS5oPgogI2ltcG9ydCA8V2ViQ29y ZS9CYWNrRm9yd2FyZExpc3RJbXBsLmg+CkBAIC0xMzEsNiArMTMyLDcgQEAKICNpbXBvcnQgPFdl YkNvcmUvSFRNTE5hbWVzLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0hpc3RvcnlJdGVtLmg+CiAjaW1w b3J0IDxXZWJDb3JlL0ljb25EYXRhYmFzZS5oPgorI2ltcG9ydCA8V2ViQ29yZS9JbnB1dEVsZW1l bnQuaD4KICNpbXBvcnQgPFdlYkNvcmUvSlNDU1NTdHlsZURlY2xhcmF0aW9uLmg+CiAjaW1wb3J0 IDxXZWJDb3JlL0pTRG9jdW1lbnQuaD4KICNpbXBvcnQgPFdlYkNvcmUvSlNFbGVtZW50Lmg+CkBA IC02MjQ0LDYgKzYyNDYsMzUgQEAgc3RhdGljIHZvaWQgZ2xpYkNvbnRleHRJdGVyYXRpb25DYWxs YmFjayhDRlJ1bkxvb3BPYnNlcnZlclJlZiwgQ0ZSdW5Mb29wQWN0aXZpdHkKIAogQGVuZAogCitA aW1wbGVtZW50YXRpb24gV2ViVmlldyAoV2ViVmlld1ByaXZhdGVTZXRWYWx1ZUZvclVzZXIpCisK Ky0gKHZvaWQpX3NldFZhbHVlRm9yVXNlcjooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRWxlbWVu dDooSlNWYWx1ZVJlZillbGVtZW50IHdpdGhWYWx1ZTooSlNWYWx1ZVJlZil2YWx1ZQoreworICAg IGlmICghZWxlbWVudCB8fCAhdmFsdWUpCisgICAgICAgIHJldHVybjsKKworICAgIEpTTG9jayBs b2NrKFNpbGVuY2VBc3NlcnRpb25zT25seSk7CisgICAgRXhlY1N0YXRlKiBleGVjID0gdG9KUyhj b250ZXh0KTsKKyAgICBKU1ZhbHVlIGpzRWxlbWVudFZhbHVlID0gdG9KUyhleGVjLCBlbGVtZW50 KTsKKyAgICBpZiAoIWpzRWxlbWVudFZhbHVlLmluaGVyaXRzKCZKU0VsZW1lbnQ6OnNfaW5mbykp CisgICAgICAgIHJldHVybjsKKyAgICBKU0VsZW1lbnQqIGpzRWxlbWVudCA9IHN0YXRpY19jYXN0 PEpTRWxlbWVudCo+KGFzT2JqZWN0KGpzRWxlbWVudFZhbHVlKSk7CisgICAgRWxlbWVudCogd2Vi Y29yZUVsZW1lbnQgPSBqc0VsZW1lbnQtPmltcGwoKTsKKyAgICBJbnB1dEVsZW1lbnQqIGlucHV0 RWxlbWVudCA9IHRvSW5wdXRFbGVtZW50KHdlYmNvcmVFbGVtZW50KTsKKyAgICBpZiAoIWlucHV0 RWxlbWVudCkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFKU1ZhbHVlSXNTdHJpbmcoY29u dGV4dCwgdmFsdWUpKQorICAgICAgICByZXR1cm47CisgICAgSlNTdHJpbmdSZWYganNTdHJpbmdW YWx1ZSA9IEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgdmFsdWUsIE5VTEwpOworICAgIFN0 cmluZyBzdHJpbmdWYWx1ZShqc1N0cmluZ1ZhbHVlLT5jaGFyYWN0ZXJzKCksIGpzU3RyaW5nVmFs dWUtPmxlbmd0aCgpKTsKKworICAgIGlucHV0RWxlbWVudC0+c2V0VmFsdWVGb3JVc2VyKHN0cmlu Z1ZhbHVlKTsKKyAgICByZXR1cm47Cit9CisKK0BlbmQKKwogQGltcGxlbWVudGF0aW9uIFdlYlZp ZXcgKFdlYlZpZXdQcml2YXRlTm9kZXNGcm9tUmVjdCkKIAogLSAoSlNWYWx1ZVJlZilfbm9kZXNG cm9tUmVjdDooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRG9jdW1lbnQ6KEpTVmFsdWVSZWYpdmFs dWUgeDooaW50KXggIHk6KGludCl5IHRvcDoodW5zaWduZWQpdG9wIHJpZ2h0Oih1bnNpZ25lZCly aWdodCBib3R0b206KHVuc2lnbmVkKWJvdHRvbSBsZWZ0Oih1bnNpZ25lZClsZWZ0IGlnbm9yZUNs aXBwaW5nOihCT09MKWlnbm9yZUNsaXBwaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oIGIvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9X ZWJWaWV3SW50ZXJuYWwuaAppbmRleCA1NTVjNGQxMTBlZDBiZmM5Y2ZiNjVkYzk2MmYwYjI4MTEw OTcyNzg3Li5hMjMxMDI0NWFkOWIwZDQyN2NjZGY1MzkyY2RmNjQ1MDI5ODJiNGMzIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmgKQEAgLTE5NCw2ICsxOTQs NCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAtICh2b2lkKV9mdWxsU2NyZWVuUmVuZGVyZXJDaGFu Z2VkOihXZWJDb3JlOjpSZW5kZXJCb3gqKXJlbmRlcmVyOwogI2VuZGlmCiAKLS0gKEpTVmFsdWVS ZWYpX2NvbXB1dGVkU3R5bGVJbmNsdWRpbmdWaXNpdGVkSW5mbzooSlNDb250ZXh0UmVmKWNvbnRl eHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZil2YWx1ZTsKLQogQGVuZApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9t YWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCmluZGV4IGE0ZWE4MDliMDAxZGJjNmE2NzIzNGYx NzJmMDIwYmMzNGNmN2U4NGMuLjhjNGFmODQ5Y2E2N2ExZWExZmU2ZGFlMGIyNmJkMDc4NGI3ZWM1 YTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUu aAorKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgKQEAgLTY3 Nyw2ICs2NzcsMTAgQEAgQ291bGQgYmUgd29ydGggYWRkaW5nIHRvIHRoZSBBUEkuCiAtIChKU1Zh bHVlUmVmKV9jb21wdXRlZFN0eWxlSW5jbHVkaW5nVmlzaXRlZEluZm86KEpTQ29udGV4dFJlZilj b250ZXh0IGZvckVsZW1lbnQ6KEpTVmFsdWVSZWYpdmFsdWU7CiBAZW5kCiAKK0BpbnRlcmZhY2Ug V2ViVmlldyAoV2ViVmlld1ByaXZhdGVTZXRWYWx1ZUZvclVzZXIpCistICh2b2lkKV9zZXRWYWx1 ZUZvclVzZXI6KEpTQ29udGV4dFJlZiljb250ZXh0IGZvckVsZW1lbnQ6KEpTVmFsdWVSZWYpZWxl bWVudCB3aXRoVmFsdWU6KEpTVmFsdWVSZWYpdmFsdWU7CitAZW5kCisKIEBpbnRlcmZhY2UgV2Vi VmlldyAoV2ViVmlld1ByaXZhdGVOb2Rlc0Zyb21SZWN0KQogLSAoSlNWYWx1ZVJlZilfbm9kZXNG cm9tUmVjdDooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRG9jdW1lbnQ6KEpTVmFsdWVSZWYpdmFs dWUgeDooaW50KXggIHk6KGludCl5IHRvcDoodW5zaWduZWQpdG9wIHJpZ2h0Oih1bnNpZ25lZCly aWdodCBib3R0b206KHVuc2lnbmVkKWJvdHRvbSBsZWZ0Oih1bnNpZ25lZClsZWZ0IGlnbm9yZUNs aXBwaW5nOihCT09MKWlnbm9yZUNsaXBwaW5nOwogQGVuZApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hh bmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDJjMmE1MzRlNDIyY2I3MDljY2Y3MDlkZTlh ZDMzMTZlY2EyNzVlOTcuLmU0MGNmZmQ0N2UxMTIwY2NkMzQ5ZGRhMjJkMTcxM2QxMThhMWEwOWQg MTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNiBAQAorMjAxMS0wMi0yMyAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhU TUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBldmVudCB3 aGVuIHRoZSBlbGVtZW50IGlzIGZvY3VzZWQKKyAgICAgICAgSW4gc2VydmljZSBvZiBodHRwczov L2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9taXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisKKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6CisgICAgICAgIChz ZXRWYWx1ZUZvclVzZXJDYWxsYmFjayk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 c3RhdGljRnVuY3Rpb25zKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJv bGxlckd0ay5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JV c2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06CisgICAgICAgIChM YXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogRXhwb3NlIEhUTUxJbnB1dEVs ZW1lbnQ6OnNldFZhbHVlRm9yVXNlcigpIHRvIHRlc3RzCisgICAgICAgICogRHVtcFJlbmRlclRy ZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1l bnRhdGlvbi4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xs ZXJXaW4uY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNl cik6IFN0dWJiZWQgb3V0OyBuZWVkIHJlYWwgaW1wbGVtZW50YXRpb24uCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHA6CisgICAgICAgIChMYXlv dXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVh bCBpbXBsZW1lbnRhdGlvbi4KKwogMjAxMS0wMi0yOCAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBs ZS5jb20+CiAKICAgICAgICAgQWRkIGEgdGVzdCBmb3IgdGhlIHBhaW50IHJlY3QgcGFzc2VkIHZp YSBXTV9QQUlOVCB0byB3aW5kb3dsZXNzIHBsdWdpbnMKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBS ZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCA0MTZiOWZjYjEwODVmZTFjZDQ4M2ZkZDky YzY2ZDRiNWRiYTg2ODZkLi44ZDhlYmMzNjM2YzlmYmU1YTI1YjE2NmY0YmUzM2QwNWJmMzYzYTFi IDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5j cHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBA IC0xNDMyLDYgKzE0MzIsMTggQEAgc3RhdGljIEpTVmFsdWVSZWYgc2V0VXNlclN0eWxlU2hlZXRM b2NhdGlvbkNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamUKICAgICByZXR1cm4g SlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIHNl dFZhbHVlRm9yVXNlckNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBm dW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNv bnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAg ICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCisgICAgaWYgKGFyZ3VtZW50Q291bnQgIT0gMikK KyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworCisgICAgTGF5 b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSBzdGF0aWNfY2FzdDxMYXlvdXRUZXN0Q29u dHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29udHJvbGxl ci0+c2V0VmFsdWVGb3JVc2VyKGNvbnRleHQsIGFyZ3VtZW50c1swXSwgYXJndW1lbnRzWzFdKTsK KworICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKK30KKwogc3RhdGlj IEpTVmFsdWVSZWYgc2V0Vmlld01vZGVNZWRpYUZlYXR1cmVDYWxsYmFjayhKU0NvbnRleHRSZWYg Y29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNp emVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVl UmVmKiBleGNlcHRpb24pCiB7CiAgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgpAQCAtMjEy OSw2ICsyMTQxLDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0 YXRpY0Z1bmN0aW9ucygpCiAgICAgICAgIHsgInNldFVzZURhc2hib2FyZENvbXBhdGliaWxpdHlN b2RlIiwgc2V0VXNlRGFzaGJvYXJkQ29tcGF0aWJpbGl0eU1vZGVDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQiLCBzZXRVc2VyU3R5bGVTaGVldEVu YWJsZWRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRVc2VyU3R5bGVTaGVldExvY2F0 aW9uIiwgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCisgICAgICAg IHsgInNldFZhbHVlRm9yVXNlciIsIHNldFZhbHVlRm9yVXNlckNhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0Vmlld01vZGVNZWRpYUZlYXR1 cmUiLCBzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsg InNldFdlYlZpZXdFZGl0YWJsZSIsIHNldFdlYlZpZXdFZGl0YWJsZUNhbGxiYWNrLCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0s CiAgICAgICAgIHsgInNldFdpbGxTZW5kUmVxdWVzdENsZWFySGVhZGVyIiwgc2V0V2lsbFNlbmRS ZXF1ZXN0Q2xlYXJIZWFkZXJDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0IGEvVG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggOGEyMDUwMDU5MWUxYTQ5YzdiZmExYjM0YmY3 NzI4YmY1MTYxMGI5NS4uOTUwYWMwODNlZGVlYjA4ZTM2YTIyM2M5ZmRjMWJiZWQ2NDVjOGVhYSAx MDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAor KysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCkBAIC0xMTEs NiArMTExLDcgQEAgcHVibGljOgogICAgIHZvaWQgc2V0VXNlRGFzaGJvYXJkQ29tcGF0aWJpbGl0 eU1vZGUoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZChib29s IGZsYWcpOwogICAgIHZvaWQgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBw YXRoKTsKKyAgICB2b2lkIHNldFZhbHVlRm9yVXNlcihKU0NvbnRleHRSZWYsIEpTVmFsdWVSZWYg ZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSk7CiAgICAgdm9pZCBzZXRWaWV3TW9kZU1lZGlhRmVh dHVyZShKU1N0cmluZ1JlZiBtb2RlKTsKICAgICB2b2lkIHNldFhTU0F1ZGl0b3JFbmFibGVkKGJv b2wgZmxhZyk7CiAgICAgdm9pZCBzZXRGcmFtZUZsYXR0ZW5pbmdFbmFibGVkKGJvb2wgZW5hYmxl KTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJv bGxlckd0ay5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xs ZXJHdGsuY3BwCmluZGV4IDBiYmFiODY3ZWZiMDA1MzQzZWRhZTk5OTg5NjJjNGI0OThkZmZmNmEu LmU5Yjg0ZmE1ZTI4N2VlZTc4MDBlZTM1M2I1MTYzOTQ2OTdmY2I1ODMgMTAwNjQ0Ci0tLSBhL1Rv b2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKKysrIGIv VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcApAQCAt MzMzLDYgKzMzMywxMSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVT aGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpCiAgICAgICAgIHNldFVzZXJTdHlsZVNoZWV0 RW5hYmxlZCh0cnVlKTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVG b3JVc2VyKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVS ZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6IGltcGxlbWVudAorfQorCiB2b2lkIExheW91dFRl c3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQog ewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSB3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmll dyhtYWluRnJhbWUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91 dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRl c3RDb250cm9sbGVyTWFjLm1tCmluZGV4IGJjOWRiYjdjODI4OWMyYzMzMWZlYThkMWYxZjVhNjBl MDYxYWQxM2MuLmExMjU3OWJmNzcyY2I4MzMwODA1N2ZjMDBkNDE4MjllZGJlYjhjZmYgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5t bQorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMu bW0KQEAgLTQ3OSw2ICs0NzksMTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNl clN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKQogICAgIFtbV2ViUHJlZmVyZW5j ZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwog fQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0 UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSkKK3sKKyAg ICBbW21haW5GcmFtZSB3ZWJWaWV3XSBfc2V0VmFsdWVGb3JVc2VyOmNvbnRleHQgZm9yRWxlbWVu dDplbGVtZW50IHdpdGhWYWx1ZTp2YWx1ZV07Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpTU3RyaW5nUmVmIG1vZGUpCiB7CiAgICAgLy8g RklYTUU6IGltcGxlbWVudApkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvTGF5 b3V0VGVzdENvbnRyb2xsZXJRdC5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRU ZXN0Q29udHJvbGxlclF0LmNwcAppbmRleCBiYjlhYWU4MWFlODU1ZDIyODMzZWRjYmVkYWJkMzc5 NzVkNjk5ZmU4Li4zNjg1YWI0MDA5N2YxZjE3YzQyOGNiZTdiMGE2NGI4NDQwNThkNjlmIDEwMDY0 NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNw cAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNw cApAQCAtMTQ4LDYgKzE0OCwxMSBAQCBRU3RyaW5nIExheW91dFRlc3RDb250cm9sbGVyOjpjb3Vu dGVyVmFsdWVGb3JFbGVtZW50QnlJZChjb25zdCBRU3RyaW5nJiBpZCkKICAgICByZXR1cm4gRHVt cFJlbmRlclRyZWVTdXBwb3J0UXQ6OmNvdW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKG1fZHJ0LT53 ZWJQYWdlKCktPm1haW5GcmFtZSgpLCBpZCk7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnNldFZhbHVlRm9yVXNlcihKU0NvbnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBlbGVt ZW50LCBKU1ZhbHVlUmVmIHZhbHVlKQoreworICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKK30KKwog dm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUoY29uc3Qg UVN0cmluZyYgbW9kZSkKIHsKICAgICBtX2RydC0+d2ViUGFnZSgpLT5zZXRQcm9wZXJ0eSgiX3Ff dmlld01vZGUiLCBtb2RlKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9M YXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5 b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCmluZGV4IDgwODYyZWIyMWI2YjdiMWY1Yzk2ZjVhOTk3 M2QwODBiNDMwY2YzYmUuLjZkYTYyZDdiMWVmOWY4OGIyMGJlOWI1OWZiNDA0NDZjNzU5OTlmN2Ug MTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxl cldpbi5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9s bGVyV2luLmNwcApAQCAtNzU1LDYgKzc1NSwxMSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVy OjpzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIGpzVVJMKQogICAgIFN5c0Zy ZWVTdHJpbmcocmVzdWx0UGF0aEJTVFIpOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVy OjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVu dCwgSlNWYWx1ZVJlZiB2YWx1ZSkKK3sKKyAgICAvLyBGSVhNRTogaW1wbGVtZW50Cit9CisKIHZv aWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpTU3RyaW5n UmVmIG1vZGUpCiB7CiAgICAgLy8gRklYTUU6IGltcGxlbWVudApkaWZmIC0tZ2l0IGEvVG9vbHMv RHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAgYi9Ub29scy9EdW1w UmVuZGVyVHJlZS93eC9MYXlvdXRUZXN0Q29udHJvbGxlcld4LmNwcAppbmRleCAxMGUxMTA3MTE2 YmQ0YzYzMDFlNjQxY2VkYzdhM2YxM2E2ZjRjNmZhLi43MDY2ZmRjMDVkNGM3MmEwM2YzNWVmM2Ji OGIxZGY2MWE4ODIxMTlhIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS93eC9MYXlv dXRUZXN0Q29udHJvbGxlcld4LmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS93eC9MYXlv dXRUZXN0Q29udHJvbGxlcld4LmNwcApAQCAtMTM1LDYgKzEzNSwxMSBAQCB2b2lkIExheW91dFRl c3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgp CiB7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcihKU0Nv bnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBlbGVtZW50LCBKU1ZhbHVlUmVmIHZhbHVlKQor eworICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxl cjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUoSlNTdHJpbmdSZWYgbW9kZSkKIHsKICAgICAvLyBG SVhNRTogaW1wbGVtZW50Cg== 84142 2011-02-28 16:01:57 -0800 2011-03-02 04:58:33 -0800 Patch bug-53160-20110228160156.patch text/plain 18433 isherman U3VidmVyc2lvbiBSZXZpc2lvbjogNzk4ODIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAxNGRkZGJmYmY0NmVmZjFlZGFkODMw ZGFjOWMxMjk3MmQ1NDY1ZGVkLi4zOGU3NjliMWY5YjJiYzU1Mjg1NTgzYmViZjkwZTQzMDdlZmJj NmZkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlz aGVybWFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVs ZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNl cnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWls P2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01MzE2MAorCisgICAgICAgICogZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZh bHVlZm9ydXNlci5odG1sOiBBZGRlZC4KKwogMjAxMS0wMi0yOCAgTWloYWkgUGFycGFyaXRhICA8 bWloYWlwQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIENocm9taXVtIGV4cGVj dGF0aW9ucyBjaGFuZ2UuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hh bmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1z L29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmM2M2Ex ZGQzODZlMTBjOGZhNTVjZjc0ODZjMGIwMTAwMDljMGVmMAotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDQgQEAKK1RoaXMgdGVzdHMgdGhhdCBvbmNoYW5nZSBjb3JyZWN0bHkgZmly ZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1ZUZvclVzZXIoKS4gSXQgY2FuIG9ubHkgYmUgcnVuIHVz aW5nIER1bXBSZW5kZXJUcmVlLgorCitQQVNTIAorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40ZGJiOGY3 OWUwNzY2NjM0MmExYWU2YTM3OWIyNzc4NmY0NTU0NTNjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbApAQCAtMCww ICsxLDQ0IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQ+CisgICAgZnVuY3Rpb24g dGVzdCgpIHsKKyAgICAgICAgdmFyIHRmID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3RmJyk7 CisKKyAgICAgICAgdmFyIGRpZEZpcmVPbkNoYW5nZSA9IGZhbHNlOworICAgICAgICB0Zi5vbmNo YW5nZSA9IGZ1bmN0aW9uKCkgeworICAgICAgICAgIGRpZEZpcmVPbkNoYW5nZSA9IHRydWU7Cisg ICAgICAgIH0KKworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIH0K KworICAgICAgICB0Zi5mb2N1cygpOworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5zZXRWYWx1ZUZvclVz ZXIodGYsICdIZWxsbyEnKTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFNob3VsZCBub3QgZmly ZSB0aGUgZXZlbnQgdW50aWwgZm9jdXMgaXMgbG9zdC4KKyAgICAgICAgaWYgKGRpZEZpcmVPbkNo YW5nZSkgeworICAgICAgICAgICAgdGVzdEZhaWxlZCgnb25jaGFuZ2UgZmlyZWQgdG9vIGVhcmx5 Jyk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICB0Zi5ibHVyKCk7 CisgICAgICAgIGlmIChkaWRGaXJlT25DaGFuZ2UpIHsKKyAgICAgICAgICAgIHRlc3RQYXNzZWQo JycpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgdGVzdEZhaWxlZCgnb25jaGFuZ2Ug bmV2ZXIgZmlyZWQnKQorICAgICAgICB9CisgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFkPgor PGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgIFRoaXMgdGVzdHMgdGhhdCBvbmNoYW5nZSBjb3Jy ZWN0bHkgZmlyZXMgYWZ0ZXIgY2FsbGluZyBzZXRWYWx1ZUZvclVzZXIoKS4gIEl0IGNhbiBvbmx5 IGJlIHJ1biB1c2luZyBEdW1wUmVuZGVyVHJlZS48YnI+CisgICAgPGZvcm0gbmFtZT0iZm0iPgor ICAgICAgICA8aW5wdXQgdHlwZT0idGV4dCIgaWQ9InRmIiAvPgorICAgIDwvZm9ybT4KKyAgICA8 ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBj M2U5ZmEwZWNjZTA3OWNmMDY0Zjg0ODZkM2MyYTJkNDYzYjRkZDYzLi4xYzk0YWVjMjcwZjYzZDU3 M2FmYmEyZGY5YjkyMzAwNGNkODI1ZmQxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIw MTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVtZW50 OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxlbWVu dCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5j b20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgIFRlc3Q6IGZhc3Qv Zm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUu ZXhwLmluOgorICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSk6CisgICAgICAgICAgICBGb3IgYSBm b2N1c2VkIHRleHQgZmllbGQsIHRlbGwgdGhlIHJlbmRlcmVyIHRoYXQgdGhlIHZhbHVlIGhhcyBj aGFuZ2VkIHNpbmNlIHRoZSBsYXN0IGNoYW5nZSBldmVudC4KKwogMjAxMS0wMi0yOCAgU2hlcmlm ZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjc5ODc3LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS5leHAuaW4gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCBlZmNiN2JmMzgw MDY1YzIyNTkwNmNlZjk4MjQwOTFjMmI3MDUxZWIyLi43NTcyN2E0MzExOTIyNDhhMjk2OTRlOTA1 NDk4OGJmZTcyZTcyY2U4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5p bgorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgpAQCAtMzYzLDYgKzM2Myw3IEBA IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4zMnJlbW92ZU9yaWdpbkFjY2Vzc1doaXRlbGlz dEVudHJ5RVJLUzBfUktOM1dURjZTdHJpCiBfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luNDBz ZXREb21haW5SZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJMU2NoZW1lRWJSS04zV1RGNlN0cmluZ0UK IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTjNXVEY2U3RyaW5nRVM0X2kK IF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFaQorX19aTjdX ZWJDb3JlMTR0b0lucHV0RWxlbWVudEVQTlNfN0VsZW1lbnRFCiBfX1pON1dlYkNvcmUxNUFyY2hp dmVSZXNvdXJjZTZjcmVhdGVFTjNXVEYxMFBhc3NSZWZQdHJJTlNfMTJTaGFyZWRCdWZmZXJFRUVS S05TXzRLVVJMRVJLTlMxXzZTdHJpbmdFU0FfU0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VFCiBf X1pON1dlYkNvcmUxNURPTVdyYXBwZXJXb3JsZDEzY2xlYXJXcmFwcGVyc0V2CiBfX1pON1dlYkNv cmUxNURPTVdyYXBwZXJXb3JsZEQxRXYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1l bnQuY3BwCmluZGV4IGEyMjFkM2U1YTlmZjIxNjIzNDA1OTVhZmZkMTM0NmIyMDlmNmJlMmYuLjk4 MTMzZDJkN2U5ZjIyNTRkZDhhOTJhMjU0MTY4NzhhMjZlMzJlYWIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODg5LDEwICs4ODksMTUgQEAgdm9pZCBIVE1M SW5wdXRFbGVtZW50OjpzZXRWYWx1ZShjb25zdCBTdHJpbmcmIHZhbHVlLCBib29sIHNlbmRDaGFu Z2VFdmVudCkKICAgICB9CiAgICAgbV9pbnB1dFR5cGUtPnZhbHVlQ2hhbmdlZCgpOwogCi0gICAg Ly8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5nZSBldmVudCB3aGVuIGZvY3VzZWQsIGl0IHdpbGwg YmUgZGlzcGF0Y2hlZAotICAgIC8vIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCi0gICAg aWYgKHNlbmRDaGFuZ2VFdmVudCAmJiBkb2N1bWVudCgpLT5mb2N1c2VkTm9kZSgpICE9IHRoaXMp Ci0gICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAgIGlmIChzZW5k Q2hhbmdlRXZlbnQpIHsKKyAgICAgICAgLy8gRm9yIHRleHQgZmllbGRzLCBkb24ndCBkaXNwYXRj aCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4gZm9jdXNlZC4KKyAgICAgICAgLy8gSXQgd2lsbCBiZSBk aXNwYXRjaGVkIHdoZW4gdGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCisgICAgICAgIFJlbmRlck9i amVjdCogcmVuZGVyZXIgPSB0aGlzLT5yZW5kZXJlcigpOworICAgICAgICBpZiAocmVuZGVyZXIg JiYgcmVuZGVyZXItPmlzVGV4dEZpZWxkKCkgJiYgZG9jdW1lbnQoKS0+Zm9jdXNlZE5vZGUoKSA9 PSB0aGlzKQorICAgICAgICAgICAgdG9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUocmVuZGVy ZXIpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQodHJ1ZSk7CisgICAgICAgIGVsc2UK KyAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAgIH0KIAog ICAgIElucHV0RWxlbWVudDo6bm90aWZ5Rm9ybVN0YXRlQ2hhbmdlZCh0aGlzKTsKIH0KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvbWFjL0No YW5nZUxvZwppbmRleCAxNjNmNjY5OTViNDZmYjEzZGM1MDRmOGNiOGE5MTk1OWQ1ZjQyODEwLi43 ZTYxZjEwY2VkYmYyNTdmYmE5ZDgyMGJhYzk0ZmQ2ZjliYzkyMDE1IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDItMjMgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNo cm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2Ug ZXZlbnQgd2hlbiB0aGUgZWxlbWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2Yg aHR0cHM6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAor CisgICAgICAgICogV2ViVmlldy9XZWJWaWV3Lm1tOgorICAgICAgICAoLVtXZWJWaWV3IF9zZXRW YWx1ZUZvclVzZXI6Zm9yRWxlbWVudDp3aXRoVmFsdWU6XSk6IEV4cG9zZSBIVE1MSW5wdXRFbGVt ZW50OjpzZXRWYWx1ZUZvclVzZXIoKSB0byB0ZXN0cworICAgICAgICAqIFdlYlZpZXcvV2ViVmll d0ludGVybmFsLmg6CisgICAgICAgICogV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oOgorCiAyMDEx LTAyLTI2ICBWc2V2b2xvZCBWbGFzb3YgIDx2c2V2aWtAY2hyb21pdW0ub3JnPgogCiAgICAgICAg IFJldmlld2VkIGJ5IFBhdmVsIEZlbGRtYW4uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlZpZXcubW0gYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcu bW0KaW5kZXggMjdiNjQ3NjBmZWMwZTM2ZDE2Zjk4ODNiMjZkNzhjMTlmZjY3ZTg1Ny4uZjJkMzlk YmE2NTYxOWZiZWJjY2FiM2ZiMjA5YWE4OWJiYTkzMTYwMCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViVmlldy5tbQpAQCAtMTA3LDYgKzEwNyw3IEBACiAjaW1wb3J0IDxGb3VuZGF0aW9uL05T VVJMQ29ubmVjdGlvbi5oPgogI2ltcG9ydCA8SmF2YVNjcmlwdENvcmUvQVBJQ2FzdC5oPgogI2lt cG9ydCA8SmF2YVNjcmlwdENvcmUvSlNWYWx1ZVJlZi5oPgorI2ltcG9ydCA8SmF2YVNjcmlwdENv cmUvT3BhcXVlSlNTdHJpbmcuaD4KICNpbXBvcnQgPFdlYkNvcmUvQWJzdHJhY3REYXRhYmFzZS5o PgogI2ltcG9ydCA8V2ViQ29yZS9BcHBsaWNhdGlvbkNhY2hlU3RvcmFnZS5oPgogI2ltcG9ydCA8 V2ViQ29yZS9CYWNrRm9yd2FyZExpc3RJbXBsLmg+CkBAIC0xMzEsNiArMTMyLDcgQEAKICNpbXBv cnQgPFdlYkNvcmUvSFRNTE5hbWVzLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0hpc3RvcnlJdGVtLmg+ CiAjaW1wb3J0IDxXZWJDb3JlL0ljb25EYXRhYmFzZS5oPgorI2ltcG9ydCA8V2ViQ29yZS9JbnB1 dEVsZW1lbnQuaD4KICNpbXBvcnQgPFdlYkNvcmUvSlNDU1NTdHlsZURlY2xhcmF0aW9uLmg+CiAj aW1wb3J0IDxXZWJDb3JlL0pTRG9jdW1lbnQuaD4KICNpbXBvcnQgPFdlYkNvcmUvSlNFbGVtZW50 Lmg+CkBAIC02MjQ0LDYgKzYyNDYsMzUgQEAgc3RhdGljIHZvaWQgZ2xpYkNvbnRleHRJdGVyYXRp b25DYWxsYmFjayhDRlJ1bkxvb3BPYnNlcnZlclJlZiwgQ0ZSdW5Mb29wQWN0aXZpdHkKIAogQGVu ZAogCitAaW1wbGVtZW50YXRpb24gV2ViVmlldyAoV2ViVmlld1ByaXZhdGVTZXRWYWx1ZUZvclVz ZXIpCisKKy0gKHZvaWQpX3NldFZhbHVlRm9yVXNlcjooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9y RWxlbWVudDooSlNWYWx1ZVJlZillbGVtZW50IHdpdGhWYWx1ZTooSlNWYWx1ZVJlZil2YWx1ZQor eworICAgIGlmICghZWxlbWVudCB8fCAhdmFsdWUpCisgICAgICAgIHJldHVybjsKKworICAgIEpT TG9jayBsb2NrKFNpbGVuY2VBc3NlcnRpb25zT25seSk7CisgICAgRXhlY1N0YXRlKiBleGVjID0g dG9KUyhjb250ZXh0KTsKKyAgICBKU1ZhbHVlIGpzRWxlbWVudFZhbHVlID0gdG9KUyhleGVjLCBl bGVtZW50KTsKKyAgICBpZiAoIWpzRWxlbWVudFZhbHVlLmluaGVyaXRzKCZKU0VsZW1lbnQ6OnNf aW5mbykpCisgICAgICAgIHJldHVybjsKKyAgICBKU0VsZW1lbnQqIGpzRWxlbWVudCA9IHN0YXRp Y19jYXN0PEpTRWxlbWVudCo+KGFzT2JqZWN0KGpzRWxlbWVudFZhbHVlKSk7CisgICAgRWxlbWVu dCogd2ViY29yZUVsZW1lbnQgPSBqc0VsZW1lbnQtPmltcGwoKTsKKyAgICBJbnB1dEVsZW1lbnQq IGlucHV0RWxlbWVudCA9IHRvSW5wdXRFbGVtZW50KHdlYmNvcmVFbGVtZW50KTsKKyAgICBpZiAo IWlucHV0RWxlbWVudCkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFKU1ZhbHVlSXNTdHJp bmcoY29udGV4dCwgdmFsdWUpKQorICAgICAgICByZXR1cm47CisgICAgSlNTdHJpbmdSZWYganNT dHJpbmdWYWx1ZSA9IEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgdmFsdWUsIE5VTEwpOwor ICAgIFN0cmluZyBzdHJpbmdWYWx1ZShqc1N0cmluZ1ZhbHVlLT5jaGFyYWN0ZXJzKCksIGpzU3Ry aW5nVmFsdWUtPmxlbmd0aCgpKTsKKworICAgIGlucHV0RWxlbWVudC0+c2V0VmFsdWVGb3JVc2Vy KHN0cmluZ1ZhbHVlKTsKKyAgICByZXR1cm47Cit9CisKK0BlbmQKKwogQGltcGxlbWVudGF0aW9u IFdlYlZpZXcgKFdlYlZpZXdQcml2YXRlTm9kZXNGcm9tUmVjdCkKIAogLSAoSlNWYWx1ZVJlZilf bm9kZXNGcm9tUmVjdDooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRG9jdW1lbnQ6KEpTVmFsdWVS ZWYpdmFsdWUgeDooaW50KXggIHk6KGludCl5IHRvcDoodW5zaWduZWQpdG9wIHJpZ2h0Oih1bnNp Z25lZClyaWdodCBib3R0b206KHVuc2lnbmVkKWJvdHRvbSBsZWZ0Oih1bnNpZ25lZClsZWZ0IGln bm9yZUNsaXBwaW5nOihCT09MKWlnbm9yZUNsaXBwaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oIGIvU291cmNlL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJWaWV3SW50ZXJuYWwuaAppbmRleCA1NTVjNGQxMTBlZDBiZmM5Y2ZiNjVkYzk2MmYw YjI4MTEwOTcyNzg3Li5hMjMxMDI0NWFkOWIwZDQyN2NjZGY1MzkyY2RmNjQ1MDI5ODJiNGMzIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oCisr KyBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmgKQEAgLTE5NCw2 ICsxOTQsNCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAtICh2b2lkKV9mdWxsU2NyZWVuUmVuZGVy ZXJDaGFuZ2VkOihXZWJDb3JlOjpSZW5kZXJCb3gqKXJlbmRlcmVyOwogI2VuZGlmCiAKLS0gKEpT VmFsdWVSZWYpX2NvbXB1dGVkU3R5bGVJbmNsdWRpbmdWaXNpdGVkSW5mbzooSlNDb250ZXh0UmVm KWNvbnRleHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZil2YWx1ZTsKLQogQGVuZApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oIGIvU291cmNlL1dl YktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCmluZGV4IGE0ZWE4MDliMDAxZGJjNmE2 NzIzNGYxNzJmMDIwYmMzNGNmN2U4NGMuLjhjNGFmODQ5Y2E2N2ExZWExZmU2ZGFlMGIyNmJkMDc4 NGI3ZWM1YTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1By aXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgK QEAgLTY3Nyw2ICs2NzcsMTAgQEAgQ291bGQgYmUgd29ydGggYWRkaW5nIHRvIHRoZSBBUEkuCiAt IChKU1ZhbHVlUmVmKV9jb21wdXRlZFN0eWxlSW5jbHVkaW5nVmlzaXRlZEluZm86KEpTQ29udGV4 dFJlZiljb250ZXh0IGZvckVsZW1lbnQ6KEpTVmFsdWVSZWYpdmFsdWU7CiBAZW5kCiAKK0BpbnRl cmZhY2UgV2ViVmlldyAoV2ViVmlld1ByaXZhdGVTZXRWYWx1ZUZvclVzZXIpCistICh2b2lkKV9z ZXRWYWx1ZUZvclVzZXI6KEpTQ29udGV4dFJlZiljb250ZXh0IGZvckVsZW1lbnQ6KEpTVmFsdWVS ZWYpZWxlbWVudCB3aXRoVmFsdWU6KEpTVmFsdWVSZWYpdmFsdWU7CitAZW5kCisKIEBpbnRlcmZh Y2UgV2ViVmlldyAoV2ViVmlld1ByaXZhdGVOb2Rlc0Zyb21SZWN0KQogLSAoSlNWYWx1ZVJlZilf bm9kZXNGcm9tUmVjdDooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRG9jdW1lbnQ6KEpTVmFsdWVS ZWYpdmFsdWUgeDooaW50KXggIHk6KGludCl5IHRvcDoodW5zaWduZWQpdG9wIHJpZ2h0Oih1bnNp Z25lZClyaWdodCBib3R0b206KHVuc2lnbmVkKWJvdHRvbSBsZWZ0Oih1bnNpZ25lZClsZWZ0IGln bm9yZUNsaXBwaW5nOihCT09MKWlnbm9yZUNsaXBwaW5nOwogQGVuZApkaWZmIC0tZ2l0IGEvVG9v bHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDJjMmE1MzRlNDIyY2I3MDljY2Y3 MDlkZTlhZDMzMTZlY2EyNzVlOTcuLmU0MGNmZmQ0N2UxMTIwY2NkMzQ5ZGRhMjJkMTcxM2QxMThh MWEwOWQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwyNiBAQAorMjAxMS0wMi0yMyAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBl dmVudCB3aGVuIHRoZSBlbGVtZW50IGlzIGZvY3VzZWQKKyAgICAgICAgSW4gc2VydmljZSBvZiBo dHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9taXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisK KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6CisgICAg ICAgIChzZXRWYWx1ZUZvclVzZXJDYWxsYmFjayk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJv bGxlcjo6c3RhdGljRnVuY3Rpb25zKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5oOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0 Q29udHJvbGxlckd0ay5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFs dWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1lbnRhdGlvbi4KKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06CisgICAg ICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogRXhwb3NlIEhUTUxJ bnB1dEVsZW1lbnQ6OnNldFZhbHVlRm9yVXNlcigpIHRvIHRlc3RzCisgICAgICAgICogRHVtcFJl bmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlvdXRU ZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBp bXBsZW1lbnRhdGlvbi4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENv bnRyb2xsZXJXaW4uY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVl Rm9yVXNlcik6IFN0dWJiZWQgb3V0OyBuZWVkIHJlYWwgaW1wbGVtZW50YXRpb24uCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHA6CisgICAgICAg IChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5l ZWQgcmVhbCBpbXBsZW1lbnRhdGlvbi4KKwogMjAxMS0wMi0yOCAgQWRhbSBSb2JlbiAgPGFyb2Jl bkBhcHBsZS5jb20+CiAKICAgICAgICAgQWRkIGEgdGVzdCBmb3IgdGhlIHBhaW50IHJlY3QgcGFz c2VkIHZpYSBXTV9QQUlOVCB0byB3aW5kb3dsZXNzIHBsdWdpbnMKZGlmZiAtLWdpdCBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCA0MTZiOWZjYjEwODVmZTFjZDQ4 M2ZkZDkyYzY2ZDRiNWRiYTg2ODZkLi44ZDhlYmMzNjM2YzlmYmU1YTI1YjE2NmY0YmUzM2QwNWJm MzYzYTFiIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu Y3BwCkBAIC0xNDMyLDYgKzE0MzIsMTggQEAgc3RhdGljIEpTVmFsdWVSZWYgc2V0VXNlclN0eWxl U2hlZXRMb2NhdGlvbkNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamUKICAgICBy ZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVl UmVmIHNldFZhbHVlRm9yVXNlckNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVj dFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291 bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikK K3sKKyAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCisgICAgaWYgKGFyZ3VtZW50Q291bnQg IT0gMikKKyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworCisg ICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSBzdGF0aWNfY2FzdDxMYXlvdXRU ZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29u dHJvbGxlci0+c2V0VmFsdWVGb3JVc2VyKGNvbnRleHQsIGFyZ3VtZW50c1swXSwgYXJndW1lbnRz WzFdKTsKKworICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKK30KKwog c3RhdGljIEpTVmFsdWVSZWYgc2V0Vmlld01vZGVNZWRpYUZlYXR1cmVDYWxsYmFjayhKU0NvbnRl eHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmpl Y3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBK U1ZhbHVlUmVmKiBleGNlcHRpb24pCiB7CiAgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgpA QCAtMjEyOSw2ICsyMTQxLDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnN0YXRpY0Z1bmN0aW9ucygpCiAgICAgICAgIHsgInNldFVzZURhc2hib2FyZENvbXBhdGli aWxpdHlNb2RlIiwgc2V0VXNlRGFzaGJvYXJkQ29tcGF0aWJpbGl0eU1vZGVDYWxsYmFjaywga0pT UHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0 ZSB9LAogICAgICAgICB7ICJzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQiLCBzZXRVc2VyU3R5bGVT aGVldEVuYWJsZWRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1By b3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRVc2VyU3R5bGVTaGVl dExvY2F0aW9uIiwgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCisg ICAgICAgIHsgInNldFZhbHVlRm9yVXNlciIsIHNldFZhbHVlRm9yVXNlckNhbGxiYWNrLCBrSlNQ cm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0Vmlld01vZGVNZWRp YUZlYXR1cmUiLCBzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAg ICAgIHsgInNldFdlYlZpZXdFZGl0YWJsZSIsIHNldFdlYlZpZXdFZGl0YWJsZUNhbGxiYWNrLCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVs ZXRlIH0sCiAgICAgICAgIHsgInNldFdpbGxTZW5kUmVxdWVzdENsZWFySGVhZGVyIiwgc2V0V2ls bFNlbmRSZXF1ZXN0Q2xlYXJIZWFkZXJDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApkaWZmIC0tZ2l0IGEvVG9v bHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggOGEyMDUwMDU5MWUxYTQ5YzdiZmEx YjM0YmY3NzI4YmY1MTYxMGI5NS4uOTUwYWMwODNlZGVlYjA4ZTM2YTIyM2M5ZmRjMWJiZWQ2NDVj OGVhYSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuaAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCkBA IC0xMTEsNiArMTExLDcgQEAgcHVibGljOgogICAgIHZvaWQgc2V0VXNlRGFzaGJvYXJkQ29tcGF0 aWJpbGl0eU1vZGUoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxl ZChib29sIGZsYWcpOwogICAgIHZvaWQgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmlu Z1JlZiBwYXRoKTsKKyAgICB2b2lkIHNldFZhbHVlRm9yVXNlcihKU0NvbnRleHRSZWYsIEpTVmFs dWVSZWYgZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSk7CiAgICAgdm9pZCBzZXRWaWV3TW9kZU1l ZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKTsKICAgICB2b2lkIHNldFhTU0F1ZGl0b3JFbmFi bGVkKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBzZXRGcmFtZUZsYXR0ZW5pbmdFbmFibGVkKGJvb2wg ZW5hYmxlKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0 Q29udHJvbGxlckd0ay5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENv bnRyb2xsZXJHdGsuY3BwCmluZGV4IDBiYmFiODY3ZWZiMDA1MzQzZWRhZTk5OTg5NjJjNGI0OThk ZmZmNmEuLmU5Yjg0ZmE1ZTI4N2VlZTc4MDBlZTM1M2I1MTYzOTQ2OTdmY2I1ODMgMTAwNjQ0Ci0t LSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAK KysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNw cApAQCAtMzMzLDYgKzMzMywxMSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2Vy U3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpCiAgICAgICAgIHNldFVzZXJTdHls ZVNoZWV0RW5hYmxlZCh0cnVlKTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0 VmFsdWVGb3JVc2VyKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpT VmFsdWVSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6IGltcGxlbWVudAorfQorCiB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBt b2RlKQogewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSB3ZWJraXRfd2ViX2ZyYW1lX2dldF93 ZWJfdmlldyhtYWluRnJhbWUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFj L0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xh eW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IGJjOWRiYjdjODI4OWMyYzMzMWZlYThkMWYx ZjVhNjBlMDYxYWQxM2MuLmExMjU3OWJmNzcyY2I4MzMwODA1N2ZjMDBkNDE4MjllZGJlYjhjZmYg MTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxl ck1hYy5tbQorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xs ZXJNYWMubW0KQEAgLTQ3OSw2ICs0NzksMTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKQogICAgIFtbV2ViUHJl ZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjp1 cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlND b250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSkK K3sKKyAgICBbW21haW5GcmFtZSB3ZWJWaWV3XSBfc2V0VmFsdWVGb3JVc2VyOmNvbnRleHQgZm9y RWxlbWVudDplbGVtZW50IHdpdGhWYWx1ZTp2YWx1ZV07Cit9CisKIHZvaWQgTGF5b3V0VGVzdENv bnRyb2xsZXI6OnNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpTU3RyaW5nUmVmIG1vZGUpCiB7CiAg ICAgLy8gRklYTUU6IGltcGxlbWVudApkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUv cXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9M YXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcAppbmRleCBiYjlhYWU4MWFlODU1ZDIyODMzZWRjYmVk YWJkMzc5NzVkNjk5ZmU4Li4zNjg1YWI0MDA5N2YxZjE3YzQyOGNiZTdiMGE2NGI4NDQwNThkNjlm IDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxl clF0LmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxl clF0LmNwcApAQCAtMTQ4LDYgKzE0OCwxMSBAQCBRU3RyaW5nIExheW91dFRlc3RDb250cm9sbGVy Ojpjb3VudGVyVmFsdWVGb3JFbGVtZW50QnlJZChjb25zdCBRU3RyaW5nJiBpZCkKICAgICByZXR1 cm4gRHVtcFJlbmRlclRyZWVTdXBwb3J0UXQ6OmNvdW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKG1f ZHJ0LT53ZWJQYWdlKCktPm1haW5GcmFtZSgpLCBpZCk7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENv bnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcihKU0NvbnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJl ZiBlbGVtZW50LCBKU1ZhbHVlUmVmIHZhbHVlKQoreworICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQK K30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUo Y29uc3QgUVN0cmluZyYgbW9kZSkKIHsKICAgICBtX2RydC0+d2ViUGFnZSgpLT5zZXRQcm9wZXJ0 eSgiX3Ffdmlld01vZGUiLCBtb2RlKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVl L3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS93 aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCmluZGV4IDgwODYyZWIyMWI2YjdiMWY1Yzk2 ZjVhOTk3M2QwODBiNDMwY2YzYmUuLjZkYTYyZDdiMWVmOWY4OGIyMGJlOWI1OWZiNDA0NDZjNzU5 OTlmN2UgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29u dHJvbGxlcldpbi5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RD b250cm9sbGVyV2luLmNwcApAQCAtNzU1LDYgKzc1NSwxMSBAQCB2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjpzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIGpzVVJMKQogICAg IFN5c0ZyZWVTdHJpbmcocmVzdWx0UGF0aEJTVFIpOwogfQogCit2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYg ZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSkKK3sKKyAgICAvLyBGSVhNRTogaW1wbGVtZW50Cit9 CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpT U3RyaW5nUmVmIG1vZGUpCiB7CiAgICAgLy8gRklYTUU6IGltcGxlbWVudApkaWZmIC0tZ2l0IGEv VG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAgYi9Ub29s cy9EdW1wUmVuZGVyVHJlZS93eC9MYXlvdXRUZXN0Q29udHJvbGxlcld4LmNwcAppbmRleCAxMGUx MTA3MTE2YmQ0YzYzMDFlNjQxY2VkYzdhM2YxM2E2ZjRjNmZhLi43MDY2ZmRjMDVkNGM3MmEwM2Yz NWVmM2JiOGIxZGY2MWE4ODIxMTlhIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS93 eC9MYXlvdXRUZXN0Q29udHJvbGxlcld4LmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS93 eC9MYXlvdXRUZXN0Q29udHJvbGxlcld4LmNwcApAQCAtMTM1LDYgKzEzNSwxMSBAQCB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVm IHBhdGgpCiB7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNl cihKU0NvbnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBlbGVtZW50LCBKU1ZhbHVlUmVmIHZh bHVlKQoreworICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUoSlNTdHJpbmdSZWYgbW9kZSkKIHsKICAg ICAvLyBGSVhNRTogaW1wbGVtZW50Cg== 84402 2011-03-02 04:58:37 -0800 2011-03-03 00:30:38 -0800 Patch bug-53160-20110302045836.patch text/plain 33756 isherman ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAwZDE3YzE3NDQ1YjU0OTI2NzJlYTU2NmRiMzg2Y2M5YjY1YThhMTlhLi44NDFjNWI5 MGE0NjdmMzE1OGQ3MTQyNDYzMTRmMDc1ZDcxNzU3MjJlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTEtMDMtMDIgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVt ZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxl bWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2ds ZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgICogZmFzdC9m b3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sOiBBZGRlZC4KKwog MjAxMS0wMy0wMSAgUGF2ZWwgRmVsZG1hbiAgPHBmZWxkbWFuQGNocm9taXVtLm9yZz4KIAogICAg ICAgICBSZXZpZXdlZCBieSBZdXJ5IFNlbWlraGF0c2t5LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0 Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmJjNjNhMWRkMzg2ZTEwYzhmYTU1Y2Y3NDg2YzBiMDEwMDA5YzBlZjAKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVl Zm9ydXNlci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw0IEBACitUaGlzIHRlc3RzIHRoYXQgb25j aGFuZ2UgY29ycmVjdGx5IGZpcmVzIGFmdGVyIGNhbGxpbmcgc2V0VmFsdWVGb3JVc2VyKCkuIEl0 IGNhbiBvbmx5IGJlIHJ1biB1c2luZyBEdW1wUmVuZGVyVHJlZS4KKworUEFTUyAKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRt bCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uNGRiYjhmNzllMDc2NjYzNDJhMWFlNmEzNzliMjc3ODZmNDU1NDUzYwotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVm b3J1c2VyLmh0bWwKQEAgLTAsMCArMSw0NCBAQAorPGh0bWw+Cis8aGVhZD4KKyAgICA8c2NyaXB0 IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKyAgICA8c2Ny aXB0PgorICAgIGZ1bmN0aW9uIHRlc3QoKSB7CisgICAgICAgIHZhciB0ZiA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCd0ZicpOworCisgICAgICAgIHZhciBkaWRGaXJlT25DaGFuZ2UgPSBmYWxz ZTsKKyAgICAgICAgdGYub25jaGFuZ2UgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgICBkaWRGaXJl T25DaGFuZ2UgPSB0cnVlOworICAgICAgICB9CisKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworICAgICAgICB9CisKKyAgICAgICAgdGYuZm9jdXMoKTsKKyAgICAgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIuc2V0VmFsdWVGb3JVc2VyKHRmLCAnSGVsbG8hJyk7CisgICAgICAgIH0KKworICAgICAg ICAvLyBTaG91bGQgbm90IGZpcmUgdGhlIGV2ZW50IHVudGlsIGZvY3VzIGlzIGxvc3QuCisgICAg ICAgIGlmIChkaWRGaXJlT25DaGFuZ2UpIHsKKyAgICAgICAgICAgIHRlc3RGYWlsZWQoJ29uY2hh bmdlIGZpcmVkIHRvbyBlYXJseScpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisK KyAgICAgICAgdGYuYmx1cigpOworICAgICAgICBpZiAoZGlkRmlyZU9uQ2hhbmdlKSB7CisgICAg ICAgICAgICB0ZXN0UGFzc2VkKCcnKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIHRl c3RGYWlsZWQoJ29uY2hhbmdlIG5ldmVyIGZpcmVkJykKKyAgICAgICAgfQorICAgIH0KKyAgICA8 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0idGVzdCgpIj4KKyAgICBUaGlzIHRlc3Rz IHRoYXQgb25jaGFuZ2UgY29ycmVjdGx5IGZpcmVzIGFmdGVyIGNhbGxpbmcgc2V0VmFsdWVGb3JV c2VyKCkuICBJdCBjYW4gb25seSBiZSBydW4gdXNpbmcgRHVtcFJlbmRlclRyZWUuPGJyPgorICAg IDxmb3JtIG5hbWU9ImZtIj4KKyAgICAgICAgPGlucHV0IHR5cGU9InRleHQiIGlkPSJ0ZiIgLz4K KyAgICA8L2Zvcm0+CisgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8L2JvZHk+Cis8L2h0 bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKaW5kZXggMjk1NmE2NTFhMjU5NDQ0OWU5OTRhZDJmYzhiMWQ4NDM4NTNjNzcw NS4uNjE3ZWNhMzg2NDYyZjY4MzZmZGMxMWY3MmVkOTI4Y2NmM2VjYjU5YSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDU0IEBACisyMDExLTAzLTAyICBJbHlhIFNoZXJtYW4gIDxpc2hlcm1hbkBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgSFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWUoKSBzaG91bGQgc2NoZWR1bGUgY2hhbmdlIGV2 ZW50IHdoZW4gdGhlIGVsZW1lbnQgaXMgZm9jdXNlZC4KKyAgICAgICAgUmVmYWN0b3JlZCB0cmFj a2luZyBvZiAiY2hhbmdlZCBzaW5jZSBsYXN0IGNoYW5nZSBldmVudCIgc3RhdGUgZnJvbSByZW5k ZXJlciB0byBET00uCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5j b20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgIFRlc3Q6IGZhc3Qv Zm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUu ZXhwLmluOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpE b2N1bWVudDo6c2V0Rm9jdXNlZE5vZGUpOgorICAgICAgICAqIGRvbS9FbGVtZW50Lmg6CisgICAg ICAgIChXZWJDb3JlOjpFbGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQpOiBB ZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6OnNldENoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudCk6IEFkZGVkLgorICAgICAgICAqIGh0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0 Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KTogQWRkZWQ7IHJlc2V0cyAiY2hhbmdlZCBzaW5jZSBs YXN0IGNoYW5nZSBldmVudCIgc3RhdGUuCisgICAgICAgICogaHRtbC9IVE1MRm9ybUNvbnRyb2xF bGVtZW50Lmg6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OkhUTUxJbnB1dEVsZW1lbnQpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWUpOgorICAgICAgICAgICAgRm9yIGEg Zm9jdXNlZCB0ZXh0IGZpZWxkLCB0ZWxsIHRoZSByZW5kZXJlciB0aGF0IHRoZSB2YWx1ZSBoYXMg Y2hhbmdlZCBzaW5jZSB0aGUgbGFzdCBjaGFuZ2UgZXZlbnQuCisgICAgICAgIChXZWJDb3JlOjpI VE1MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKToKKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxJbnB1dEVsZW1lbnQ6OnN0ZXBVcEZyb21SZW5kZXJlcik6CisgICAgICAgICogaHRtbC9I VE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50Ojp3 YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxJbnB1dEVsZW1lbnQ6OnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCk6IEFkZGVk LgorICAgICAgICAqIGh0bWwvSFRNTFRleHRBcmVhRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpIVE1MVGV4dEFyZWFFbGVtZW50OjpIVE1MVGV4dEFyZWFFbGVtZW50KToKKyAgICAgICAg KiBodG1sL0hUTUxUZXh0QXJlYUVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxUZXh0 QXJlYUVsZW1lbnQ6Ondhc0NoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCk6IEFkZGVkLgorICAg ICAgICAoV2ViQ29yZTo6SFRNTFRleHRBcmVhRWxlbWVudDo6c2V0Q2hhbmdlZFNpbmNlTGFzdENo YW5nZUV2ZW50KTogQWRkZWQuCisgICAgICAgICogaHRtbC9zaGFkb3cvVGV4dENvbnRyb2xJbm5l ckVsZW1lbnRzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNlYXJjaEZpZWxkQ2FuY2VsQnV0dG9u RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcik6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRl clRleHRDb250cm9sLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclRleHRDb250cm9sOjpS ZW5kZXJUZXh0Q29udHJvbCk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJUZXh0Q29udHJvbDo6 c3VidHJlZUhhc0NoYW5nZWQpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJv bC5oOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbE11bHRpTGluZS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJUZXh0Q29udHJvbE11bHRpTGluZTo6c3VidHJlZUhh c0NoYW5nZWQpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxp bmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyVGV4dENvbnRyb2xTaW5nbGVMaW5lOjpz dWJ0cmVlSGFzQ2hhbmdlZCk6CisgICAgICAgICogd21sL1dNTElucHV0RWxlbWVudC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OldNTElucHV0RWxlbWVudCk6CisgICAg ICAgIChXZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgorICAg ICAgICAqIHdtbC9XTUxJbnB1dEVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0 RWxlbWVudDo6d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KTogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVu dCk6IEFkZGVkLgorCiAyMDExLTAzLTAxICBJbHlhIFRpa2hvbm92c2t5ICA8bG9pc2xvQGNocm9t aXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBQYXZlbCBGZWxkbWFuLgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl LmV4cC5pbgppbmRleCA5OWI1ZTg0NDkyZDg1ZGU1MzcyNjQ2NmQyZjY4MmI0YTRjMGM4MmViLi4w YjBhNDEzYzMzMzY1NTFmZjlhMGZmM2U0NzRlNGE5MmYxYjY4N2FmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4 cC5pbgpAQCAtMzYzLDYgKzM2Myw3IEBAIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW4zMnJl bW92ZU9yaWdpbkFjY2Vzc1doaXRlbGlzdEVudHJ5RVJLUzBfUktOM1dURjZTdHJpCiBfX1pON1dl YkNvcmUxNFNlY3VyaXR5T3JpZ2luNDBzZXREb21haW5SZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJM U2NoZW1lRWJSS04zV1RGNlN0cmluZ0UKIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3Jl YXRlRVJLTjNXVEY2U3RyaW5nRVM0X2kKIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW42Y3Jl YXRlRVJLTlNfNEtVUkxFaQorX19aTjdXZWJDb3JlMTR0b0lucHV0RWxlbWVudEVQTlNfN0VsZW1l bnRFCiBfX1pON1dlYkNvcmUxNUFyY2hpdmVSZXNvdXJjZTZjcmVhdGVFTjNXVEYxMFBhc3NSZWZQ dHJJTlNfMTJTaGFyZWRCdWZmZXJFRUVSS05TXzRLVVJMRVJLTlMxXzZTdHJpbmdFU0FfU0FfUktO U18xNlJlc291cmNlUmVzcG9uc2VFCiBfX1pON1dlYkNvcmUxNURPTVdyYXBwZXJXb3JsZDEzY2xl YXJXcmFwcGVyc0V2CiBfX1pON1dlYkNvcmUxNURPTVdyYXBwZXJXb3JsZEQxRXYKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20v RG9jdW1lbnQuY3BwCmluZGV4IDU3NzdiMTUxMzAxMmUyYmQzNjNkMTU2NTA3ZTU3NzkxMWIzZWM4 NDIuLmI0NWRlNjQxNjJhYzUyY2NhZGEwZmM4MWM5NGYxZDdhY2U3MjFhNTEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcApAQCAtMzE2OSwxMiArMzE2OSwxMCBAQCBib29sIERvY3VtZW50OjpzZXRG b2N1c2VkTm9kZShQYXNzUmVmUHRyPE5vZGU+IG5ld0ZvY3VzZWROb2RlKQogICAgICAgICBvbGRG b2N1c2VkTm9kZS0+c2V0Rm9jdXMoZmFsc2UpOwogCiAgICAgICAgIC8vIERpc3BhdGNoIGEgY2hh bmdlIGV2ZW50IGZvciB0ZXh0IGZpZWxkcyBvciB0ZXh0YXJlYXMgdGhhdCBoYXZlIGJlZW4gZWRp dGVkCi0gICAgICAgIFJlbmRlck9iamVjdCogciA9IG9sZEZvY3VzZWROb2RlLT5yZW5kZXJlcigp OwotICAgICAgICBpZiAociAmJiByLT5pc1RleHRDb250cm9sKCkgJiYgdG9SZW5kZXJUZXh0Q29u dHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkpIHsKLSAgICAgICAgICAg IHN0YXRpY19jYXN0PEVsZW1lbnQqPihvbGRGb2N1c2VkTm9kZS5nZXQoKSktPmRpc3BhdGNoRm9y bUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAgICAgICAgICAgciA9IG9sZEZvY3VzZWROb2RlLT5y ZW5kZXJlcigpOwotICAgICAgICAgICAgaWYgKHIgJiYgci0+aXNUZXh0Q29udHJvbCgpKQotICAg ICAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wociktPnNldENoYW5nZWRTaW5jZUxhc3RD aGFuZ2VFdmVudChmYWxzZSk7CisgICAgICAgIGlmIChvbGRGb2N1c2VkTm9kZS0+aXNFbGVtZW50 Tm9kZSgpKSB7CisgICAgICAgICAgICBFbGVtZW50KiBlbGVtZW50ID0gc3RhdGljX2Nhc3Q8RWxl bWVudCAqPihvbGRGb2N1c2VkTm9kZS5nZXQoKSk7CisgICAgICAgICAgICBpZiAoZWxlbWVudC0+ d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkpCisgICAgICAgICAgICAgICAgZWxlbWVu dC0+ZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CiAgICAgICAgIH0KIAogICAgICAg ICAvLyBEaXNwYXRjaCB0aGUgYmx1ciBldmVudCBhbmQgbGV0IHRoZSBub2RlIGRvIGFueSBvdGhl ciBibHVyIHJlbGF0ZWQgYWN0aXZpdGllcyAoaW1wb3J0YW50IGZvciB0ZXh0IGZpZWxkcykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9k b20vRWxlbWVudC5oCmluZGV4IGE4NWY4Y2RkODc3YWU1NzVmOTQ2ZDA2OTc3NzMwNWMxYTcwMWZl M2MuLmUzMjJlMDQ4Y2E4MGYyNTVhZWM3ZTEwNWJmYThlODYwMDEyMGNlY2MgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0Vs ZW1lbnQuaApAQCAtMzIzLDYgKzMyMyw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIGJvb2wgc2F2 ZUZvcm1Db250cm9sU3RhdGUoU3RyaW5nJikgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2 aXJ0dWFsIHZvaWQgcmVzdG9yZUZvcm1Db250cm9sU3RhdGUoY29uc3QgU3RyaW5nJikgeyB9CiAK KyAgICB2aXJ0dWFsIGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkgY29uc3Qg eyByZXR1cm4gZmFsc2U7IH0KKyAgICB2aXJ0dWFsIHZvaWQgc2V0Q2hhbmdlZFNpbmNlTGFzdENo YW5nZUV2ZW50KGJvb2wpIHsgfQogICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaEZvcm1Db250cm9s Q2hhbmdlRXZlbnQoKSB7IH0KIAogI2lmIEVOQUJMRShTVkcpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcAppbmRleCAyZjNkYjA4ZjU1NzZlOWViNDFl YTg2ZTA5MzcwYjVlYWY5MDcxNDc4Li5kZmQ1YWM1NmQyYjcxOWNkMmM5MTEzZWFlYzE2OTI5OTIy YWRhZjYyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVs ZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVu dC5jcHAKQEAgLTY0OSw2ICs2NDksMTIgQEAgUGFzc1JlZlB0cjxSYW5nZT4gSFRNTFRleHRGb3Jt Q29udHJvbEVsZW1lbnQ6OnNlbGVjdGlvbigpIGNvbnN0CiAgICAgcmV0dXJuIHRvUmVuZGVyVGV4 dENvbnRyb2wocmVuZGVyZXIoKSktPnNlbGVjdGlvbihjYWNoZWRTZWxlY3Rpb25TdGFydCgpLCBj YWNoZWRTZWxlY3Rpb25FbmQoKSk7CiB9CiAKK3ZvaWQgSFRNTFRleHRGb3JtQ29udHJvbEVsZW1l bnQ6OmRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpCit7CisgICAgSFRNTEZvcm1Db250 cm9sRWxlbWVudDo6ZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisgICAgc2V0Q2hh bmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KGZhbHNlKTsKK30KKwogdm9pZCBIVE1MVGV4dEZvcm1D b250cm9sRWxlbWVudDo6cGFyc2VNYXBwZWRBdHRyaWJ1dGUoQXR0cmlidXRlKiBhdHRyKQogewog ICAgIGlmIChhdHRyLT5uYW1lKCkgPT0gcGxhY2Vob2xkZXJBdHRyKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuaAppbmRleCAzNjhkY2ZhZDdmNGQ2ODUwMzg2 NGU4YWFjZGVmZmE0ZDg1ZGM5YjFlLi4zZmMzNmY1Mzc4NjQxMzEyMGEyNTRiYWEyNTAyNWFmYmIy ODBiZmIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQu aApAQCAtMjA1LDYgKzIwNSw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIGludCBtYXhMZW5ndGgo KSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBTdHJpbmcgdmFsdWUoKSBjb25zdCA9IDA7CiAKKyAg ICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisKIHByb3Rl Y3RlZDoKICAgICBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1l JiwgRG9jdW1lbnQqLCBIVE1MRm9ybUVsZW1lbnQqKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TElucHV0RWxlbWVudC5jcHAKaW5kZXggYTIyMWQzZTVhOWZmMjE2MjM0MDU5NWFmZmQxMzQ2YjIw OWY2YmUyZi4uZWNlMjk4NmYyYTBiZTZlZjIzMzU5NDQwMDgzY2MxODgxOTkxYjg5MSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC03NCw2ICs3NCw3IEBAIEhU TUxJbnB1dEVsZW1lbnQ6OkhUTUxJbnB1dEVsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYgdGFn TmFtZSwgRG9jdW1lbnQqIGRvY3VtCiAgICAgLCBtX2lzQXV0b2ZpbGxlZChmYWxzZSkKICAgICAs IG1fc3RhdGVSZXN0b3JlZChmYWxzZSkKICAgICAsIG1fcGFyc2luZ0luUHJvZ3Jlc3MoY3JlYXRl ZEJ5UGFyc2VyKQorICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2Up CiAgICAgLCBtX2lucHV0VHlwZShJbnB1dFR5cGU6OmNyZWF0ZVRleHQodGhpcykpCiB7CiAgICAg QVNTRVJUKGhhc1RhZ05hbWUoaW5wdXRUYWcpIHx8IGhhc1RhZ05hbWUoaXNpbmRleFRhZykpOwpA QCAtODg5LDEwICs4OTAsMTQgQEAgdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZShjb25z dCBTdHJpbmcmIHZhbHVlLCBib29sIHNlbmRDaGFuZ2VFdmVudCkKICAgICB9CiAgICAgbV9pbnB1 dFR5cGUtPnZhbHVlQ2hhbmdlZCgpOwogCi0gICAgLy8gRG9uJ3QgZGlzcGF0Y2ggdGhlIGNoYW5n ZSBldmVudCB3aGVuIGZvY3VzZWQsIGl0IHdpbGwgYmUgZGlzcGF0Y2hlZAotICAgIC8vIHdoZW4g dGhlIGNvbnRyb2wgbG9zZXMgZm9jdXMuCi0gICAgaWYgKHNlbmRDaGFuZ2VFdmVudCAmJiBkb2N1 bWVudCgpLT5mb2N1c2VkTm9kZSgpICE9IHRoaXMpCi0gICAgICAgIGRpc3BhdGNoRm9ybUNvbnRy b2xDaGFuZ2VFdmVudCgpOworICAgIGlmIChzZW5kQ2hhbmdlRXZlbnQpIHsKKyAgICAgICAgLy8g Rm9yIHRleHQgZmllbGRzLCBkb24ndCBkaXNwYXRjaCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4gZm9j dXNlZC4KKyAgICAgICAgLy8gSXQgd2lsbCBiZSBkaXNwYXRjaGVkIHdoZW4gdGhlIGNvbnRyb2wg bG9zZXMgZm9jdXMuCisgICAgICAgIGlmIChpc1RleHRGaWVsZCgpICYmIGRvY3VtZW50KCktPmZv Y3VzZWROb2RlKCkgPT0gdGhpcykKKyAgICAgICAgICAgIHNldENoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudCh0cnVlKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgZGlzcGF0Y2hGb3JtQ29u dHJvbENoYW5nZUV2ZW50KCk7CisgICAgfQogCiAgICAgSW5wdXRFbGVtZW50Ojpub3RpZnlGb3Jt U3RhdGVDaGFuZ2VkKHRoaXMpOwogfQpAQCAtMTAzNCwxNCArMTAzOSw4IEBAIHZvaWQgSFRNTElu cHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZ0KQogICAgICAgICAgICAg b25TZWFyY2goKTsKICAgICAgICAgfQogICAgICAgICAvLyBGaXJlIG9uQ2hhbmdlIGZvciB0ZXh0 IGZpZWxkcy4KLSAgICAgICAgUmVuZGVyT2JqZWN0KiByID0gcmVuZGVyZXIoKTsKLSAgICAgICAg aWYgKHIgJiYgci0+aXNUZXh0RmllbGQoKSAmJiB0b1JlbmRlclRleHRDb250cm9sKHIpLT53YXND aGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoKSkgeworICAgICAgICBpZiAoaXNUZXh0RmllbGQo KSAmJiB3YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoKSkKICAgICAgICAgICAgIGRpc3Bh dGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAgICAgICAgICAgLy8gUmVmZXRjaCB0aGUg cmVuZGVyZXIgc2luY2UgYXJiaXRyYXJ5IEpTIGNvZGUgcnVuIGR1cmluZyBvbmNoYW5nZSBjYW4g ZG8gYW55dGhpbmcsIGluY2x1ZGluZyBkZXN0cm95aW5nIGl0LgotICAgICAgICAgICAgciA9IHJl bmRlcmVyKCk7Ci0gICAgICAgICAgICBpZiAociAmJiByLT5pc1RleHRGaWVsZCgpKQotICAgICAg ICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wociktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudChmYWxzZSk7Ci0gICAgICAgIH0KIAogICAgICAgICBSZWZQdHI8SFRNTEZvcm1FbGVt ZW50PiBmb3JtRm9yU3VibWlzc2lvbiA9IG1faW5wdXRUeXBlLT5mb3JtRm9yU3VibWlzc2lvbigp OwogICAgICAgICAvLyBGb3JtIG1heSBuZXZlciBoYXZlIGJlZW4gcHJlc2VudCwgb3IgbWF5IGhh dmUgYmVlbiBkZXN0cm95ZWQgYnkgY29kZSByZXNwb25kaW5nIHRvIHRoZSBjaGFuZ2UgZXZlbnQu CkBAIC0xNDExLDcgKzE0MTAsNyBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnN0ZXBVcEZyb21S ZW5kZXJlcihpbnQgbikKIAogICAgIGlmIChjdXJyZW50U3RyaW5nVmFsdWUgIT0gdmFsdWUoKSkg ewogICAgICAgICBpZiAocmVuZGVyZXIoKSAmJiByZW5kZXJlcigpLT5pc1RleHRGaWVsZCgpKQot ICAgICAgICAgICAgdG9SZW5kZXJUZXh0Q29udHJvbChyZW5kZXJlcigpKS0+c2V0Q2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50KHRydWUpOworICAgICAgICAgICAgc2V0Q2hhbmdlZFNpbmNlTGFz dENoYW5nZUV2ZW50KHRydWUpOwogICAgICAgICBpZiAobV9pbnB1dFR5cGUtPmlzUmFuZ2VDb250 cm9sKCkpCiAgICAgICAgICAgICBkaXNwYXRjaEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoKTsKICAg ICAgICAgZWxzZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVt ZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAppbmRleCA3NTc5 OTJhZGE2NzU0MjYwZjYwMTQzMzEwNzMxYmRkOGZjMDhjMGE1Li5lMzkyZjg3MzQ2ZWVmMjIzMjU2 ZWRhZTFhZGVmZmQ3Zjk0ZTc1YmRiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1l bnQuaApAQCAtMTQwLDYgKzE0MCw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmFs dWVGcm9tUmVuZGVyZXIoY29uc3QgU3RyaW5nJik7CiAgICAgdm9pZCBzZXRGaWxlTGlzdEZyb21S ZW5kZXJlcihjb25zdCBWZWN0b3I8U3RyaW5nPiYpOwogCisgICAgdmlydHVhbCBib29sIHdhc0No YW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fd2FzQ2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50OyB9CisgICAgdmlydHVhbCB2b2lkIHNldENoYW5nZWRTaW5jZUxh c3RDaGFuZ2VFdmVudChib29sIGNoYW5nZWQpIHsgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdl RXZlbnQgPSBjaGFuZ2VkOyB9CisKICAgICBib29sIGNhbkhhdmVTZWxlY3Rpb24oKSBjb25zdDsK ICAgICB2aXJ0dWFsIHZvaWQgc2VsZWN0KCkgeyBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6 c2VsZWN0KCk7IH0KIApAQCAtMzE2LDYgKzMxOSw3IEBAIHByaXZhdGU6CiAjZW5kaWYKICAgICBi b29sIG1fc3RhdGVSZXN0b3JlZCA6IDE7CiAgICAgYm9vbCBtX3BhcnNpbmdJblByb2dyZXNzIDog MTsKKyAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50IDogMTsKICAgICBP d25QdHI8SW5wdXRUeXBlPiBtX2lucHV0VHlwZTsKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvSFRNTFRleHRBcmVhRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxUZXh0QXJlYUVsZW1lbnQuY3BwCmluZGV4IDQzMzYxMzEwMGVhNmUzZTlhOWZjNDFmZDRm MjM2MTIyMTQyOWUxNjMuLjQ2YTM0MzU5YjVhZDlmNzc4NDNmZWUzNjU1ZTRjOWY0MzlhZWI3ZmEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFRleHRBcmVhRWxlbWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEFyZWFFbGVtZW50LmNwcApAQCAtNzIs NiArNzIsNyBAQCBIVE1MVGV4dEFyZWFFbGVtZW50OjpIVE1MVGV4dEFyZWFFbGVtZW50KGNvbnN0 IFF1YWxpZmllZE5hbWUmIHRhZ05hbWUsIERvY3VtZW50KgogICAgICwgbV9jYWNoZWRTZWxlY3Rp b25TdGFydCgtMSkKICAgICAsIG1fY2FjaGVkU2VsZWN0aW9uRW5kKC0xKQogICAgICwgbV9pc0Rp cnR5KGZhbHNlKQorICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2Up CiB7CiAgICAgQVNTRVJUKGhhc1RhZ05hbWUodGV4dGFyZWFUYWcpKTsKICAgICBzZXRGb3JtQ29u dHJvbFZhbHVlTWF0Y2hlc1JlbmRlcmVyKHRydWUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MVGV4dEFyZWFFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxU ZXh0QXJlYUVsZW1lbnQuaAppbmRleCAyMWI1ODgwNGM1MjdmNGFjNzY2MDc1OTBjMzZiN2IxODNl M2YyY2Q1Li44NTZiN2U5MTRiY2RhNjY4YjZlZmI3M2NkZjY0YWI4ZTViYjIxN2FkIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxUZXh0QXJlYUVsZW1lbnQuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxUZXh0QXJlYUVsZW1lbnQuaApAQCAtNTEsNiArNTEsOSBAQCBw dWJsaWM6CiAgICAgYm9vbCB0b29Mb25nKGNvbnN0IFN0cmluZyYsIE5lZWRzVG9DaGVja0RpcnR5 RmxhZykgY29uc3Q7CiAgICAgYm9vbCBpc1ZhbGlkVmFsdWUoY29uc3QgU3RyaW5nJikgY29uc3Q7 CiAgICAgCisgICAgdmlydHVhbCBib29sIHdhc0NoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCgp IGNvbnN0IHsgcmV0dXJuIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OyB9CisgICAg dmlydHVhbCB2b2lkIHNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudChib29sIGNoYW5nZWQp IHsgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQgPSBjaGFuZ2VkOyB9CisKICAgICB2 b2lkIHJlbmRlcmVyV2lsbEJlRGVzdHJveWVkKCk7CiAgICAgCiAgICAgdm9pZCBzZXRDb2xzKGlu dCk7CkBAIC0xMDksNiArMTEyLDcgQEAgcHJpdmF0ZToKICAgICBpbnQgbV9jYWNoZWRTZWxlY3Rp b25TdGFydDsKICAgICBpbnQgbV9jYWNoZWRTZWxlY3Rpb25FbmQ7CiAgICAgbXV0YWJsZSBib29s IG1faXNEaXJ0eTsKKyAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50Owog fTsKIAogfSAvL25hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFk b3cvVGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hh ZG93L1RleHRDb250cm9sSW5uZXJFbGVtZW50cy5jcHAKaW5kZXggMDdmNTM5ZGE1NDY4NmRmNWYy MWMzMzAwZWZjMTVhYzFlYTgyM2FiNi4uNjExNzEwNGQ1YWUzZDU2MWUzZGUxM2VkYTlmN2ZkYTU5 ZjhkNGFhOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dENvbnRy b2xJbm5lckVsZW1lbnRzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0 Q29udHJvbElubmVyRWxlbWVudHMuY3BwCkBAIC0yMTEsMTEgKzIxMSw3IEBAIHZvaWQgU2VhcmNo RmllbGRDYW5jZWxCdXR0b25FbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVu dCkKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIGlmIChob3ZlcmVkKCkpIHsKICAgICAgICAg ICAgICAgICBTdHJpbmcgb2xkVmFsdWUgPSBpbnB1dC0+dmFsdWUoKTsKLSAgICAgICAgICAgICAg ICBpbnB1dC0+c2V0VmFsdWUoIiIpOwotICAgICAgICAgICAgICAgIGlmICghb2xkVmFsdWUuaXNF bXB0eSgpKSB7Ci0gICAgICAgICAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2woaW5wdXQt PnJlbmRlcmVyKCkpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQodHJ1ZSk7Ci0gICAg ICAgICAgICAgICAgICAgIGlucHV0LT5kaXNwYXRjaEZvcm1Db250cm9sSW5wdXRFdmVudCgpOwot ICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBpbnB1dC0+c2V0VmFsdWUoIiIsIHRy dWUpOwogICAgICAgICAgICAgICAgIGlucHV0LT5vblNlYXJjaCgpOwogICAgICAgICAgICAgICAg IGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOwogICAgICAgICAgICAgfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbC5jcHAKaW5kZXggMzdkZWVjMTBhZGZl YWY5OGQ5NTE5ZWQxMWI5NWI5ZWE5MWI4MTQzMS4uMDI2M2IwYjllMzk0ODRiM2IwNzhjMzA2NjFl MGUyNjc4NzhiMWMwYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl clRleHRDb250cm9sLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4 dENvbnRyb2wuY3BwCkBAIC03NCw3ICs3NCw2IEBAIHN0YXRpYyBDb2xvciBkaXNhYmxlZFRleHRD b2xvcihjb25zdCBDb2xvciYgdGV4dENvbG9yLCBjb25zdCBDb2xvciYgYmFja2dyb3VuZENvCiBS ZW5kZXJUZXh0Q29udHJvbDo6UmVuZGVyVGV4dENvbnRyb2woTm9kZSogbm9kZSwgYm9vbCBwbGFj ZWhvbGRlclZpc2libGUpCiAgICAgOiBSZW5kZXJCbG9jayhub2RlKQogICAgICwgbV9wbGFjZWhv bGRlclZpc2libGUocGxhY2Vob2xkZXJWaXNpYmxlKQotICAgICwgbV93YXNDaGFuZ2VkU2luY2VM YXN0Q2hhbmdlRXZlbnQoZmFsc2UpCiAgICAgLCBtX2xhc3RDaGFuZ2VXYXNVc2VyRWRpdChmYWxz ZSkKIHsKIH0KQEAgLTM1MSw3ICszNTAsNiBAQCBpbnQgUmVuZGVyVGV4dENvbnRyb2w6OmluZGV4 Rm9yVmlzaWJsZVBvc2l0aW9uKGNvbnN0IFZpc2libGVQb3NpdGlvbiYgcG9zKSBjb25zdAogCiB2 b2lkIFJlbmRlclRleHRDb250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdlZCgpCiB7Ci0gICAgbV93YXND aGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQgPSB0cnVlOwogICAgIG1fbGFzdENoYW5nZVdhc1Vz ZXJFZGl0ID0gdHJ1ZTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlclRleHRDb250cm9sLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4 dENvbnRyb2wuaAppbmRleCBjZDg4MTJlNjg2OTdmZjU5MzczMjI3OThiZGU2MzY5YjM1MWMxMGMw Li4wYzMwZWQ2NGE4NTFiMDk2OTg1Y2RhOWI5NzVjMWZlOGNhZTY4NzAyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuaApAQCAtMzYsOSArMzYsNiBAQCBw dWJsaWM6CiAKICAgICBIVE1MRWxlbWVudCogaW5uZXJUZXh0RWxlbWVudCgpIGNvbnN0OwogCi0g ICAgYm9vbCB3YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoKSBjb25zdCB7IHJldHVybiBt X3dhc0NoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudDsgfQotICAgIHZvaWQgc2V0Q2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50KGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KSB7 IG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50ID0gd2FzQ2hhbmdlZFNpbmNlTGFzdENo YW5nZUV2ZW50OyB9Ci0KICAgICBib29sIGxhc3RDaGFuZ2VXYXNVc2VyRWRpdCgpIGNvbnN0IHsg cmV0dXJuIG1fbGFzdENoYW5nZVdhc1VzZXJFZGl0OyB9CiAgICAgdm9pZCBzZXRMYXN0Q2hhbmdl V2FzVXNlckVkaXQoYm9vbCBsYXN0Q2hhbmdlV2FzVXNlckVkaXQpOwogCkBAIC0xMTUsNyArMTEy LDYgQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgcGFpbnRQbGFjZWhvbGRlcihQYWludEluZm8mLCBp bnQgdHgsIGludCB0eSk7CiAKLSAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2 ZW50OwogICAgIGJvb2wgbV9sYXN0Q2hhbmdlV2FzVXNlckVkaXQ7CiAgICAgUmVmUHRyPFRleHRD b250cm9sSW5uZXJUZXh0RWxlbWVudD4gbV9pbm5lclRleHQ7CiB9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sTXVsdGlMaW5lLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbE11bHRpTGluZS5jcHAKaW5k ZXggMGQ1MTJmMzYyMTAwN2ZjNTc1NmFlMTYxNWE5ZDE2YWFhZDdlM2Q2Zi4uNTZiZGY1ZGE0M2Rj NGNlYTdiNWMxZjBlMjBlOGYwMTdjMGIzNmJmNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sTXVsdGlMaW5lLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xNdWx0aUxpbmUuY3BwCkBAIC00Niw2ICs0 Niw3IEBAIHZvaWQgUmVuZGVyVGV4dENvbnRyb2xNdWx0aUxpbmU6OnN1YnRyZWVIYXNDaGFuZ2Vk KCkKIHsKICAgICBSZW5kZXJUZXh0Q29udHJvbDo6c3VidHJlZUhhc0NoYW5nZWQoKTsKICAgICBI VE1MVGV4dEFyZWFFbGVtZW50KiB0ZXh0QXJlYSA9IHN0YXRpY19jYXN0PEhUTUxUZXh0QXJlYUVs ZW1lbnQqPihub2RlKCkpOworICAgIHRleHRBcmVhLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdl RXZlbnQodHJ1ZSk7CiAgICAgdGV4dEFyZWEtPnNldEZvcm1Db250cm9sVmFsdWVNYXRjaGVzUmVu ZGVyZXIoZmFsc2UpOwogICAgIHRleHRBcmVhLT5zZXROZWVkc1ZhbGlkaXR5Q2hlY2soKTsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sU2lu Z2xlTGluZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xT aW5nbGVMaW5lLmNwcAppbmRleCA2ZGVkMGVhMGNkZjI1MWU5N2U3MTVjNmI3NjNmZDdiNmZmYmQy YzFjLi5kODc3N2RlNWNkMmEzYmJhNDMxY2E4MWJhZmE0ODViOTVmNGZkY2Q1IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVMaW5lLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVM aW5lLmNwcApAQCAtMTgxLDkgKzE4MSwxMyBAQCB2b2lkIFJlbmRlclRleHRDb250cm9sU2luZ2xl TGluZTo6aGlkZVBvcHVwKCkKIAogdm9pZCBSZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmU6OnN1 YnRyZWVIYXNDaGFuZ2VkKCkKIHsKLSAgICBib29sIHdhc0NoYW5nZWQgPSB3YXNDaGFuZ2VkU2lu Y2VMYXN0Q2hhbmdlRXZlbnQoKTsKICAgICBSZW5kZXJUZXh0Q29udHJvbDo6c3VidHJlZUhhc0No YW5nZWQoKTsKIAorICAgIEFTU0VSVChub2RlKCktPmlzRWxlbWVudE5vZGUoKSk7CisgICAgRWxl bWVudCogZWxlbWVudCA9IHN0YXRpY19jYXN0PEVsZW1lbnQqPihub2RlKCkpOworICAgIGJvb2wg d2FzQ2hhbmdlZCA9IGVsZW1lbnQtPndhc0NoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCgpOwor ICAgIGVsZW1lbnQtPnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCh0cnVlKTsKKwogICAg IElucHV0RWxlbWVudCogaW5wdXQgPSBpbnB1dEVsZW1lbnQoKTsKICAgICAvLyBXZSBkb24ndCBu ZWVkIHRvIGNhbGwgc2FuaXRpemVVc2VySW5wdXRWYWx1ZSgpIGZ1bmN0aW9uIGhlcmUgYmVjYXVz ZQogICAgIC8vIElucHV0RWxlbWVudDo6aGFuZGxlQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoKSBo YXMgYWxyZWFkeSBjYWxsZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3dtbC9XTUxJbnB1 dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKaW5k ZXggNjg3YTM4NzI1NWIxMDEwYjVlOTE3NTliYTYwZjVmZTMyYTNlNzI2OS4uMjIzOTJmNDk1ODJm NTI3OGJkYzBhNjgzNmVhNTZiNjNmNDU4MTA3NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv d21sL1dNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0 RWxlbWVudC5jcHAKQEAgLTQxLDYgKzQxLDcgQEAgV01MSW5wdXRFbGVtZW50OjpXTUxJbnB1dEVs ZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYgdGFnTmFtZSwgRG9jdW1lbnQqIGRvYykKICAgICA6 IFdNTEZvcm1Db250cm9sRWxlbWVudCh0YWdOYW1lLCBkb2MpCiAgICAgLCBtX2lzUGFzc3dvcmRG aWVsZChmYWxzZSkKICAgICAsIG1faXNFbXB0eU9rKGZhbHNlKQorICAgICwgbV93YXNDaGFuZ2Vk U2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpCiAgICAgLCBtX251bU9mQ2hhcnNBbGxvd2VkQnlN YXNrKDApCiB7CiB9CkBAIC0yOTYsMTQgKzI5Nyw5IEBAIHZvaWQgV01MSW5wdXRFbGVtZW50Ojpk ZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCiAKICAgICBpZiAoY2xpY2tEZWZhdWx0Rm9y bUJ1dHRvbikgewogICAgICAgICAvLyBGaXJlIG9uQ2hhbmdlIGZvciB0ZXh0IGZpZWxkcy4KLSAg ICAgICAgUmVuZGVyT2JqZWN0KiByID0gcmVuZGVyZXIoKTsKLSAgICAgICAgaWYgKHIgJiYgdG9S ZW5kZXJUZXh0Q29udHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkpIHsK KyAgICAgICAgaWYgKHdhc0NoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCgpKSB7CisgICAgICAg ICAgICBzZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpOwogICAgICAgICAgICAg ZGlzcGF0Y2hFdmVudChFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5jaGFuZ2VFdmVudCwgdHJ1 ZSwgZmFsc2UpKTsKLSAgICAgICAgICAgIAotICAgICAgICAgICAgLy8gUmVmZXRjaCB0aGUgcmVu ZGVyZXIgc2luY2UgYXJiaXRyYXJ5IEpTIGNvZGUgcnVuIGR1cmluZyBvbmNoYW5nZSBjYW4gZG8g YW55dGhpbmcsIGluY2x1ZGluZyBkZXN0cm95aW5nIGl0LgotICAgICAgICAgICAgciA9IHJlbmRl cmVyKCk7Ci0gICAgICAgICAgICBpZiAocikKLSAgICAgICAgICAgICAgICB0b1JlbmRlclRleHRD b250cm9sKHIpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpOwogICAgICAg ICB9CiAKICAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvd21sL1dN TElucHV0RWxlbWVudC5oCmluZGV4IDZjNjY0MTBiY2Y3NmE5ZWZmYjE4ZWU1MzlkYjBhNjE3OTg5 YTI1M2UuLmQzNjM4ODU1YzgzZDQzZTNmMWIzN2Y2NjU1NTBlNGY2MjNjMjZjOWUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS93bWwvV01MSW5wdXRFbGVtZW50LmgKQEAgLTY2LDYgKzY2LDkgQEAgcHVibGljOgogICAg IHZpcnR1YWwgU3RyaW5nIHZpc2libGVWYWx1ZSgpIGNvbnN0IHsgcmV0dXJuIHZhbHVlKCk7IH0K ICAgICB2aXJ0dWFsIHZvaWQgc2V0VmFsdWVGcm9tUmVuZGVyZXIoY29uc3QgU3RyaW5nJik7CiAK KyAgICB2aXJ0dWFsIGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkgY29uc3Qg eyByZXR1cm4gbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQ7IH0KKyAgICB2aXJ0dWFs IHZvaWQgc2V0Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KGJvb2wgY2hhbmdlZCkgeyBtX3dh c0NoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCA9IGNoYW5nZWQ7IH0KKwogICAgIHZpcnR1YWwg Ym9vbCBzYXZlRm9ybUNvbnRyb2xTdGF0ZShTdHJpbmcmIHZhbHVlKSBjb25zdDsKICAgICB2aXJ0 dWFsIHZvaWQgcmVzdG9yZUZvcm1Db250cm9sU3RhdGUoY29uc3QgU3RyaW5nJik7CiAKQEAgLTEw OSw2ICsxMTIsNyBAQCBwcml2YXRlOgogICAgIElucHV0RWxlbWVudERhdGEgbV9kYXRhOwogICAg IGJvb2wgbV9pc1Bhc3N3b3JkRmllbGQ7CiAgICAgYm9vbCBtX2lzRW1wdHlPazsKKyAgICBib29s IG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OwogICAgIFN0cmluZyBtX2Zvcm1hdE1h c2s7CiAgICAgdW5zaWduZWQgbV9udW1PZkNoYXJzQWxsb3dlZEJ5TWFzazsKIH07CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFu Z2VMb2cKaW5kZXggYmZmMDExYmU2MDU3NjIzYjEzMmNkYTYzMTUxYzU3N2ZjMWNkMDMxNy4uNTAy M2E3MzkwODkwODVlNjMyYTQzMTc5M2IwMzRiZGU3NzA1ZGM3MiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9tYWMvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZwpA QCAtMSwzICsxLDE2IEBACisyMDExLTAzLTAyICBJbHlhIFNoZXJtYW4gIDxpc2hlcm1hbkBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgSFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWUoKSBzaG91bGQgc2NoZWR1bGUgY2hhbmdlIGV2 ZW50IHdoZW4gdGhlIGVsZW1lbnQgaXMgZm9jdXNlZAorICAgICAgICBJbiBzZXJ2aWNlIG9mIGh0 dHBzOi8vY29kZS5nb29nbGUuY29tL3AvY2hyb21pdW0vaXNzdWVzL2RldGFpbD9pZD00MjcxNgor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMxNjAKKwor ICAgICAgICAqIFdlYlZpZXcvV2ViVmlldy5tbToKKyAgICAgICAgKC1bV2ViVmlldyBfc2V0VmFs dWVGb3JVc2VyOmZvckVsZW1lbnQ6d2l0aFZhbHVlOl0pOiBFeHBvc2UgSFRNTElucHV0RWxlbWVu dDo6c2V0VmFsdWVGb3JVc2VyKCkgdG8gdGVzdHMKKyAgICAgICAgKiBXZWJWaWV3L1dlYlZpZXdJ bnRlcm5hbC5oOgorICAgICAgICAqIFdlYlZpZXcvV2ViVmlld1ByaXZhdGUuaDoKKwogMjAxMS0w Mi0yNSBTdGV2ZSBCbG9jayA8c3RldmVibG9ja0Bnb29nbGUuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IEplcmVteSBPcmxvdy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViVmlldy5tbSBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbQppbmRl eCA4ZmIwNmQ2NjQ0ZTc5Y2RlZTBlNWJmYzFhZWNjYTkyMzM2NDcwNTcwLi5jMGY5NDdhMDE1ZDU3 YmNlYjJkYTE1Njk0NjI2OTY2NWE1MmZkMjhlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlZpZXcubW0KKysrIGIvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJW aWV3Lm1tCkBAIC0xMDcsNiArMTA3LDcgQEAKICNpbXBvcnQgPEZvdW5kYXRpb24vTlNVUkxDb25u ZWN0aW9uLmg+CiAjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9BUElDYXN0Lmg+CiAjaW1wb3J0IDxK YXZhU2NyaXB0Q29yZS9KU1ZhbHVlUmVmLmg+CisjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9PcGFx dWVKU1N0cmluZy5oPgogI2ltcG9ydCA8V2ViQ29yZS9BYnN0cmFjdERhdGFiYXNlLmg+CiAjaW1w b3J0IDxXZWJDb3JlL0FwcGxpY2F0aW9uQ2FjaGVTdG9yYWdlLmg+CiAjaW1wb3J0IDxXZWJDb3Jl L0JhY2tGb3J3YXJkTGlzdEltcGwuaD4KQEAgLTEzMSw2ICsxMzIsNyBAQAogI2ltcG9ydCA8V2Vi Q29yZS9IVE1MTmFtZXMuaD4KICNpbXBvcnQgPFdlYkNvcmUvSGlzdG9yeUl0ZW0uaD4KICNpbXBv cnQgPFdlYkNvcmUvSWNvbkRhdGFiYXNlLmg+CisjaW1wb3J0IDxXZWJDb3JlL0lucHV0RWxlbWVu dC5oPgogI2ltcG9ydCA8V2ViQ29yZS9KU0NTU1N0eWxlRGVjbGFyYXRpb24uaD4KICNpbXBvcnQg PFdlYkNvcmUvSlNEb2N1bWVudC5oPgogI2ltcG9ydCA8V2ViQ29yZS9KU0VsZW1lbnQuaD4KQEAg LTYyNDcsNiArNjI0OSwzNSBAQCBzdGF0aWMgdm9pZCBnbGliQ29udGV4dEl0ZXJhdGlvbkNhbGxi YWNrKENGUnVuTG9vcE9ic2VydmVyUmVmLCBDRlJ1bkxvb3BBY3Rpdml0eQogCiBAZW5kCiAKK0Bp bXBsZW1lbnRhdGlvbiBXZWJWaWV3IChXZWJWaWV3UHJpdmF0ZVNldFZhbHVlRm9yVXNlcikKKwor LSAodm9pZClfc2V0VmFsdWVGb3JVc2VyOihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JFbGVtZW50 OihKU1ZhbHVlUmVmKWVsZW1lbnQgd2l0aFZhbHVlOihKU1ZhbHVlUmVmKXZhbHVlCit7CisgICAg aWYgKCFlbGVtZW50IHx8ICF2YWx1ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgSlNMb2NrIGxv Y2soU2lsZW5jZUFzc2VydGlvbnNPbmx5KTsKKyAgICBFeGVjU3RhdGUqIGV4ZWMgPSB0b0pTKGNv bnRleHQpOworICAgIEpTVmFsdWUganNFbGVtZW50VmFsdWUgPSB0b0pTKGV4ZWMsIGVsZW1lbnQp OworICAgIGlmICghanNFbGVtZW50VmFsdWUuaW5oZXJpdHMoJkpTRWxlbWVudDo6c19pbmZvKSkK KyAgICAgICAgcmV0dXJuOworICAgIEpTRWxlbWVudCoganNFbGVtZW50ID0gc3RhdGljX2Nhc3Q8 SlNFbGVtZW50Kj4oYXNPYmplY3QoanNFbGVtZW50VmFsdWUpKTsKKyAgICBFbGVtZW50KiB3ZWJj b3JlRWxlbWVudCA9IGpzRWxlbWVudC0+aW1wbCgpOworICAgIElucHV0RWxlbWVudCogaW5wdXRF bGVtZW50ID0gdG9JbnB1dEVsZW1lbnQod2ViY29yZUVsZW1lbnQpOworICAgIGlmICghaW5wdXRF bGVtZW50KQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIUpTVmFsdWVJc1N0cmluZyhjb250 ZXh0LCB2YWx1ZSkpCisgICAgICAgIHJldHVybjsKKyAgICBKU1N0cmluZ1JlZiBqc1N0cmluZ1Zh bHVlID0gSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCB2YWx1ZSwgTlVMTCk7CisgICAgU3Ry aW5nIHN0cmluZ1ZhbHVlKGpzU3RyaW5nVmFsdWUtPmNoYXJhY3RlcnMoKSwganNTdHJpbmdWYWx1 ZS0+bGVuZ3RoKCkpOworCisgICAgaW5wdXRFbGVtZW50LT5zZXRWYWx1ZUZvclVzZXIoc3RyaW5n VmFsdWUpOworICAgIHJldHVybjsKK30KKworQGVuZAorCiBAaW1wbGVtZW50YXRpb24gV2ViVmll dyAoV2ViVmlld1ByaXZhdGVOb2Rlc0Zyb21SZWN0KQogCiAtIChKU1ZhbHVlUmVmKV9ub2Rlc0Zy b21SZWN0OihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JEb2N1bWVudDooSlNWYWx1ZVJlZil2YWx1 ZSB4OihpbnQpeCAgeTooaW50KXkgdG9wOih1bnNpZ25lZCl0b3AgcmlnaHQ6KHVuc2lnbmVkKXJp Z2h0IGJvdHRvbToodW5zaWduZWQpYm90dG9tIGxlZnQ6KHVuc2lnbmVkKWxlZnQgaWdub3JlQ2xp cHBpbmc6KEJPT0wpaWdub3JlQ2xpcHBpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFj L1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmggYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dl YlZpZXdJbnRlcm5hbC5oCmluZGV4IDU1NWM0ZDExMGVkMGJmYzljZmI2NWRjOTYyZjBiMjgxMTA5 NzI3ODcuLmEyMzEwMjQ1YWQ5YjBkNDI3Y2NkZjUzOTJjZGY2NDUwMjk4MmI0YzMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmgKKysrIGIvU291 cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3SW50ZXJuYWwuaApAQCAtMTk0LDYgKzE5NCw0 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIC0gKHZvaWQpX2Z1bGxTY3JlZW5SZW5kZXJlckNoYW5n ZWQ6KFdlYkNvcmU6OlJlbmRlckJveCopcmVuZGVyZXI7CiAjZW5kaWYKIAotLSAoSlNWYWx1ZVJl ZilfY29tcHV0ZWRTdHlsZUluY2x1ZGluZ1Zpc2l0ZWRJbmZvOihKU0NvbnRleHRSZWYpY29udGV4 dCBmb3JFbGVtZW50OihKU1ZhbHVlUmVmKXZhbHVlOwotCiBAZW5kCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgKaW5kZXggYTRlYTgwOWIwMDFkYmM2YTY3MjM0ZjE3 MmYwMjBiYzM0Y2Y3ZTg0Yy4uOGM0YWY4NDljYTY3YTFlYTFmZTZkYWUwYjI2YmQwNzg0YjdlYzVh MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5o CisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaApAQCAtNjc3 LDYgKzY3NywxMCBAQCBDb3VsZCBiZSB3b3J0aCBhZGRpbmcgdG8gdGhlIEFQSS4KIC0gKEpTVmFs dWVSZWYpX2NvbXB1dGVkU3R5bGVJbmNsdWRpbmdWaXNpdGVkSW5mbzooSlNDb250ZXh0UmVmKWNv bnRleHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZil2YWx1ZTsKIEBlbmQKIAorQGludGVyZmFjZSBX ZWJWaWV3IChXZWJWaWV3UHJpdmF0ZVNldFZhbHVlRm9yVXNlcikKKy0gKHZvaWQpX3NldFZhbHVl Rm9yVXNlcjooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZillbGVt ZW50IHdpdGhWYWx1ZTooSlNWYWx1ZVJlZil2YWx1ZTsKK0BlbmQKKwogQGludGVyZmFjZSBXZWJW aWV3IChXZWJWaWV3UHJpdmF0ZU5vZGVzRnJvbVJlY3QpCiAtIChKU1ZhbHVlUmVmKV9ub2Rlc0Zy b21SZWN0OihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JEb2N1bWVudDooSlNWYWx1ZVJlZil2YWx1 ZSB4OihpbnQpeCAgeTooaW50KXkgdG9wOih1bnNpZ25lZCl0b3AgcmlnaHQ6KHVuc2lnbmVkKXJp Z2h0IGJvdHRvbToodW5zaWduZWQpYm90dG9tIGxlZnQ6KHVuc2lnbmVkKWxlZnQgaWdub3JlQ2xp cHBpbmc6KEJPT0wpaWdub3JlQ2xpcHBpbmc7CiBAZW5kCmRpZmYgLS1naXQgYS9Ub29scy9DaGFu Z2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYTJmMTM5NDI5NjQ4Nzg1N2RkNTA0ZDM2MzE3 Mjc4MWY3MDQ4NGJkNC4uNmViNmJhMjFlOTc4ZDFjNjg5MmJhYjI0NTM4ZWNkZDk3MDE2ZTJiOSAx MDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDI2IEBACisyMDExLTAzLTAyICBJbHlhIFNoZXJtYW4gIDxpc2hlcm1hbkBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSFRN TElucHV0RWxlbWVudDo6c2V0VmFsdWUoKSBzaG91bGQgc2NoZWR1bGUgY2hhbmdlIGV2ZW50IHdo ZW4gdGhlIGVsZW1lbnQgaXMgZm9jdXNlZAorICAgICAgICBJbiBzZXJ2aWNlIG9mIGh0dHBzOi8v Y29kZS5nb29nbGUuY29tL3AvY2hyb21pdW0vaXNzdWVzL2RldGFpbD9pZD00MjcxNgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMxNjAKKworICAgICAg ICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKHNl dFZhbHVlRm9yVXNlckNhbGxiYWNrKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpz dGF0aWNGdW5jdGlvbnMpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmg6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9s bGVyR3RrLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVz ZXIpOiBTdHViYmVkIG91dDsgbmVlZCByZWFsIGltcGxlbWVudGF0aW9uLgorICAgICAgICAqIER1 bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbToKKyAgICAgICAgKExh eW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIpOiBFeHBvc2UgSFRNTElucHV0RWxl bWVudDo6c2V0VmFsdWVGb3JVc2VyKCkgdG8gdGVzdHMKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250 cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIpOiBTdHViYmVkIG91dDsgbmVlZCByZWFsIGltcGxlbWVu dGF0aW9uLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxl cldpbi5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2Vy KTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS93eC9MYXlvdXRUZXN0Q29udHJvbGxlcld4LmNwcDoKKyAgICAgICAgKExheW91 dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIpOiBTdHViYmVkIG91dDsgbmVlZCByZWFs IGltcGxlbWVudGF0aW9uLgorCiAyMDExLTAzLTAxICBBZGFtIFJvYmVuICA8YXJvYmVuQGFwcGxl LmNvbT4KIAogICAgICAgICBUZXN0IHRoYXQgdGhlIFdlYktpdDIgcmVzcG9uc2l2ZW5lc3MgdGlt ZXIgZG9lc24ndCBmaXJlIHRvbyBlYXJseQpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuY3BwCmluZGV4IDQxNmI5ZmNiMTA4NWZlMWNkNDgzZmRkOTJjNjZkNGI1 ZGJhODY4NmQuLjhkOGViYzM2MzZjOWZiZTVhMjViMTY2ZjRiZTMzZDA1YmYzNjNhMWIgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysg Yi9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAgLTE0MzIs NiArMTQzMiwxOCBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9u Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZQogICAgIHJldHVybiBKU1ZhbHVl TWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgc2V0VmFsdWVG b3JVc2VyQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9u LCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNW YWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQoreworICAgIC8vIEhh cyBtYWMgaW1wbGVtZW50YXRpb24KKyAgICBpZiAoYXJndW1lbnRDb3VudCAhPSAyKQorICAgICAg ICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBMYXlvdXRUZXN0 Q29udHJvbGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVy Kj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5zZXRW YWx1ZUZvclVzZXIoY29udGV4dCwgYXJndW1lbnRzWzBdLCBhcmd1bWVudHNbMV0pOworCisgICAg cmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1 ZVJlZiBzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0 LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFy Z3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4 Y2VwdGlvbikKIHsKICAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCkBAIC0yMTI5LDYgKzIx NDEsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVu Y3Rpb25zKCkKICAgICAgICAgeyAic2V0VXNlRGFzaGJvYXJkQ29tcGF0aWJpbGl0eU1vZGUiLCBz ZXRVc2VEYXNoYm9hcmRDb21wYXRpYmlsaXR5TW9kZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAg IHsgInNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZCIsIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZENh bGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1 dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24iLCBz ZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVh ZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAic2V0 VmFsdWVGb3JVc2VyIiwgc2V0VmFsdWVGb3JVc2VyQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZSIsIHNl dFZpZXdNb2RlTWVkaWFGZWF0dXJlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0V2Vi Vmlld0VkaXRhYmxlIiwgc2V0V2ViVmlld0VkaXRhYmxlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAg ICAgeyAic2V0V2lsbFNlbmRSZXF1ZXN0Q2xlYXJIZWFkZXIiLCBzZXRXaWxsU2VuZFJlcXVlc3RD bGVhckhlYWRlckNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJv cGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVy VHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuaAppbmRleCA4YTIwNTAwNTkxZTFhNDljN2JmYTFiMzRiZjc3MjhiZjUx NjEwYjk1Li5mYTljZmYyOGQ0MjIyNTMyY2Y2YjBkNTZiZDE2YTg3Mzk5ZGRiYTZjIDEwMDY0NAot LS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisrKyBiL1Rv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTExMSw2ICsxMTEs NyBAQCBwdWJsaWM6CiAgICAgdm9pZCBzZXRVc2VEYXNoYm9hcmRDb21wYXRpYmlsaXR5TW9kZShi b29sIGZsYWcpOwogICAgIHZvaWQgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKGJvb2wgZmxhZyk7 CiAgICAgdm9pZCBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOwor ICAgIHZvaWQgc2V0VmFsdWVGb3JVc2VyKEpTQ29udGV4dFJlZiwgSlNWYWx1ZVJlZiBlbGVtZW50 LCBKU1ZhbHVlUmVmIHVzZXJWYWx1ZSk7CiAgICAgdm9pZCBzZXRWaWV3TW9kZU1lZGlhRmVhdHVy ZShKU1N0cmluZ1JlZiBtb2RlKTsKICAgICB2b2lkIHNldFhTU0F1ZGl0b3JFbmFibGVkKGJvb2wg ZmxhZyk7CiAgICAgdm9pZCBzZXRGcmFtZUZsYXR0ZW5pbmdFbmFibGVkKGJvb2wgZW5hYmxlKTsK ZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxl ckd0ay5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJH dGsuY3BwCmluZGV4IDBiYmFiODY3ZWZiMDA1MzQzZWRhZTk5OTg5NjJjNGI0OThkZmZmNmEuLmU5 Yjg0ZmE1ZTI4N2VlZTc4MDBlZTM1M2I1MTYzOTQ2OTdmY2I1ODMgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKKysrIGIvVG9v bHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcApAQCAtMzMz LDYgKzMzMywxMSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVTaGVl dExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpCiAgICAgICAgIHNldFVzZXJTdHlsZVNoZWV0RW5h YmxlZCh0cnVlKTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JV c2VyKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVSZWYg dmFsdWUpCit7CisgICAgLy8gRklYTUU6IGltcGxlbWVudAorfQorCiB2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewog ICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSB3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyht YWluRnJhbWUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRl c3RDb250cm9sbGVyTWFjLm1tIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RD b250cm9sbGVyTWFjLm1tCmluZGV4IGJjOWRiYjdjODI4OWMyYzMzMWZlYThkMWYxZjVhNjBlMDYx YWQxM2MuLmExMjU3OWJmNzcyY2I4MzMwODA1N2ZjMDBkNDE4MjllZGJlYjhjZmYgMTAwNjQ0Ci0t LSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQor KysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0K QEAgLTQ3OSw2ICs0NzksMTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0 eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKQogICAgIFtbV2ViUHJlZmVyZW5jZXMg c3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwogfQog Cit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVm IGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSkKK3sKKyAgICBb W21haW5GcmFtZSB3ZWJWaWV3XSBfc2V0VmFsdWVGb3JVc2VyOmNvbnRleHQgZm9yRWxlbWVudDpl bGVtZW50IHdpdGhWYWx1ZTp2YWx1ZV07Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6 OnNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpTU3RyaW5nUmVmIG1vZGUpCiB7CiAgICAgLy8gRklY TUU6IGltcGxlbWVudApkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91 dFRlc3RDb250cm9sbGVyV2luLmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRU ZXN0Q29udHJvbGxlcldpbi5jcHAKaW5kZXggODA4NjJlYjIxYjZiN2IxZjVjOTZmNWE5OTczZDA4 MGI0MzBjZjNiZS4uNmRhNjJkN2IxZWY5Zjg4YjIwYmU5YjU5ZmI0MDQ0NmM3NTk5OWY3ZSAxMDA2 NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2lu LmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJX aW4uY3BwCkBAIC03NTUsNiArNzU1LDExIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNl dFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYganNVUkwpCiAgICAgU3lzRnJlZVN0 cmluZyhyZXN1bHRQYXRoQlNUUik7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNl dFZhbHVlRm9yVXNlcihKU0NvbnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBlbGVtZW50LCBK U1ZhbHVlUmVmIHZhbHVlKQoreworICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKK30KKwogdm9pZCBM YXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUoSlNTdHJpbmdSZWYg bW9kZSkKIHsKICAgICAvLyBGSVhNRTogaW1wbGVtZW50CmRpZmYgLS1naXQgYS9Ub29scy9EdW1w UmVuZGVyVHJlZS93eC9MYXlvdXRUZXN0Q29udHJvbGxlcld4LmNwcCBiL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL3d4L0xheW91dFRlc3RDb250cm9sbGVyV3guY3BwCmluZGV4IDEwZTExMDcxMTZiZDRj NjMwMWU2NDFjZWRjN2EzZjEzYTZmNGM2ZmEuLjcwNjZmZGMwNWQ0YzcyYTAzZjM1ZWYzYmI4YjFk ZjYxYTg4MjExOWEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRl c3RDb250cm9sbGVyV3guY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRl c3RDb250cm9sbGVyV3guY3BwCkBAIC0xMzUsNiArMTM1LDExIEBAIHZvaWQgTGF5b3V0VGVzdENv bnRyb2xsZXI6OnNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCkKIHsK IH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKEpTQ29udGV4 dFJlZiBjb250ZXh0LCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVSZWYgdmFsdWUpCit7Cisg ICAgLy8gRklYTUU6IGltcGxlbWVudAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpz ZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIC8vIEZJWE1F OiBpbXBsZW1lbnQK 84531 2011-03-03 00:30:41 -0800 2011-03-04 02:57:04 -0800 Patch bug-53160-20110303003040.patch text/plain 35277 isherman ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAwZDE3YzE3NDQ1YjU0OTI2NzJlYTU2NmRiMzg2Y2M5YjY1YThhMTlhLi5kNWZhMmJh ODIwNGUwZjEyYTFkY2Q1MWY2ZTQ1ZWFjMzgwMzhkNGE0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDMtMDIgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVt ZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxl bWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2ds ZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgICogZmFzdC9m b3Jtcy9vbmNoYW5nZS1jaGFuZ2UtdHlwZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5cGUuaHRtbDogQWRkZWQuCisgICAgICAgICog ZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sOiBBZGRl ZC4KKwogMjAxMS0wMy0wMSAgUGF2ZWwgRmVsZG1hbiAgPHBmZWxkbWFuQGNocm9taXVtLm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBZdXJ5IFNlbWlraGF0c2t5LgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1jaGFuZ2UtdHlwZS1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLWNoYW5nZS10eXBlLWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi45ODZmODdmMTk5ZDA0Mjc0ZDEzNjIyMDY2YzkzYTQwNTZjYzE4NDA3Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1jaGFuZ2UtdHlw ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitUaGlzIHRlc3RzIHRoYXQgb25jaGFuZ2Ug aXMgbm90IGZpcmVkIGFmdGVyIGEgZm9ybSBmaWVsZCdzIHR5cGUgY2hhbmdlcy4KKworU2hvdWxk IGZpcmUgY2hhbmdlIGV2ZW50IHdoZW4gdHlwZSBkb2VzIG5vdCBjaGFuZ2UuCitQQVNTIHRydWUg aXMgdHJ1ZQorU2hvdWxkICpub3QqIGZpcmUgY2hhbmdlIGV2ZW50IHdoZW4gdHlwZSBkb2VzIG5v dCBjaGFuZ2UuCitQQVNTIGZhbHNlIGlzIGZhbHNlCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5cGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv Zm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5cGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xZDVkYmZkN2NlNmUy Zjk4NWZlYjNiYmUwYTRhN2EyYjRiMGY1YTg5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1jaGFuZ2UtdHlwZS5odG1sCkBAIC0wLDAgKzEsNDggQEAK KzxodG1sPgorPGhlYWQ+CisgICAgPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXByZS5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdD4KKyAgICBmdW5jdGlvbiBzZW5kVGV4dChl bGVtZW50LCB0ZXh0KSB7CisgICAgICAgIHZhciBldmVudCA9IGRvY3VtZW50LmNyZWF0ZUV2ZW50 KCdUZXh0RXZlbnQnKTsKKyAgICAgICAgZXZlbnQuaW5pdFRleHRFdmVudCgndGV4dElucHV0Jywg dHJ1ZSwgdHJ1ZSwgZG9jdW1lbnQuZGVmYXVsdFZpZXcsIHRleHQpOworICAgICAgICBlbGVtZW50 LmRpc3BhdGNoRXZlbnQoZXZlbnQpOworICAgIH0KKworICAgIGZ1bmN0aW9uIHRlc3QoKSB7Cisg ICAgICAgIHZhciB0ZiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZicpOworCisgICAgICAg IHZhciBkaWRGaXJlT25DaGFuZ2UgPSBmYWxzZTsKKyAgICAgICAgdGYub25jaGFuZ2UgPSBmdW5j dGlvbigpIHsKKyAgICAgICAgICBkaWRGaXJlT25DaGFuZ2UgPSB0cnVlOworICAgICAgICB9CisK KyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICB9CisKKyAgICAgICAg dGYuZm9jdXMoKTsKKyAgICAgICAgc2VuZFRleHQodGYsICdpbnB1dCB2YWx1ZScpOworICAgICAg ICB0Zi5ibHVyKCk7CisKKyAgICAgICAgZGVidWcoJ1Nob3VsZCBmaXJlIGNoYW5nZSBldmVudCB3 aGVuIHR5cGUgZG9lcyBub3QgY2hhbmdlLicpOworICAgICAgICBzaG91bGRCZVRydWUoZGlkRmly ZU9uQ2hhbmdlLnRvU3RyaW5nKCkpOworCisgICAgICAgIGRpZEZpcmVPbkNoYW5nZSA9IGZhbHNl OworICAgICAgICB0Zi5mb2N1cygpOworICAgICAgICBzZW5kVGV4dCh0ZiwgJ25ldyBpbnB1dCB2 YWx1ZScpOworICAgICAgICB0Zi5zZXRBdHRyaWJ1dGUoJ3R5cGUnLCAncGFzc3dvcmQnKTsKKyAg ICAgICAgdGYuYmx1cigpOworCisgICAgICAgIGRlYnVnKCdTaG91bGQgKm5vdCogZmlyZSBjaGFu Z2UgZXZlbnQgd2hlbiB0eXBlIGRvZXMgbm90IGNoYW5nZS4nKTsKKyAgICAgICAgc2hvdWxkQmVG YWxzZShkaWRGaXJlT25DaGFuZ2UudG9TdHJpbmcoKSk7CisgICAgfQorICAgIDwvc2NyaXB0Pgor PC9oZWFkPgorPGJvZHkgb25sb2FkPSJ0ZXN0KCkiPgorICAgIFRoaXMgdGVzdHMgdGhhdCBvbmNo YW5nZSBpcyBub3QgZmlyZWQgYWZ0ZXIgYSBmb3JtIGZpZWxkJ3MgdHlwZSBjaGFuZ2VzLjxicj4K KyAgICA8Zm9ybSBuYW1lPSJmbSI+CisgICAgICAgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0idGYi IC8+CisgICAgPC9mb3JtPgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPC9ib2R5Pgor PC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2 YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5n ZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJjNjNhMWRkMzg2ZTEw YzhmYTU1Y2Y3NDg2YzBiMDEwMDA5YzBlZjAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci1leHBlY3RlZC50eHQKQEAgLTAs MCArMSw0IEBACitUaGlzIHRlc3RzIHRoYXQgb25jaGFuZ2UgY29ycmVjdGx5IGZpcmVzIGFmdGVy IGNhbGxpbmcgc2V0VmFsdWVGb3JVc2VyKCkuIEl0IGNhbiBvbmx5IGJlIHJ1biB1c2luZyBEdW1w UmVuZGVyVHJlZS4KKworUEFTUyAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jt cy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMv b25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGRiYjhmNzllMDc2NjYz NDJhMWFlNmEzNzliMjc3ODZmNDU1NDUzYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwKQEAgLTAsMCArMSw0NCBA QAorPGh0bWw+Cis8aGVhZD4KKyAgICA8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKyAgICA8c2NyaXB0PgorICAgIGZ1bmN0aW9uIHRlc3QoKSB7 CisgICAgICAgIHZhciB0ZiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZicpOworCisgICAg ICAgIHZhciBkaWRGaXJlT25DaGFuZ2UgPSBmYWxzZTsKKyAgICAgICAgdGYub25jaGFuZ2UgPSBm dW5jdGlvbigpIHsKKyAgICAgICAgICBkaWRGaXJlT25DaGFuZ2UgPSB0cnVlOworICAgICAgICB9 CisKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICB9CisKKyAgICAg ICAgdGYuZm9jdXMoKTsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg eworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuc2V0VmFsdWVGb3JVc2VyKHRmLCAn SGVsbG8hJyk7CisgICAgICAgIH0KKworICAgICAgICAvLyBTaG91bGQgbm90IGZpcmUgdGhlIGV2 ZW50IHVudGlsIGZvY3VzIGlzIGxvc3QuCisgICAgICAgIGlmIChkaWRGaXJlT25DaGFuZ2UpIHsK KyAgICAgICAgICAgIHRlc3RGYWlsZWQoJ29uY2hhbmdlIGZpcmVkIHRvbyBlYXJseScpOworICAg ICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisKKyAgICAgICAgdGYuYmx1cigpOworICAgICAg ICBpZiAoZGlkRmlyZU9uQ2hhbmdlKSB7CisgICAgICAgICAgICB0ZXN0UGFzc2VkKCcnKTsKKyAg ICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIHRlc3RGYWlsZWQoJ29uY2hhbmdlIG5ldmVyIGZp cmVkJykKKyAgICAgICAgfQorICAgIH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9u bG9hZD0idGVzdCgpIj4KKyAgICBUaGlzIHRlc3RzIHRoYXQgb25jaGFuZ2UgY29ycmVjdGx5IGZp cmVzIGFmdGVyIGNhbGxpbmcgc2V0VmFsdWVGb3JVc2VyKCkuICBJdCBjYW4gb25seSBiZSBydW4g dXNpbmcgRHVtcFJlbmRlclRyZWUuPGJyPgorICAgIDxmb3JtIG5hbWU9ImZtIj4KKyAgICAgICAg PGlucHV0IHR5cGU9InRleHQiIGlkPSJ0ZiIgLz4KKyAgICA8L2Zvcm0+CisgICAgPGRpdiBpZD0i Y29uc29sZSI+PC9kaXY+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjk1NmE2NTFh MjU5NDQ0OWU5OTRhZDJmYzhiMWQ4NDM4NTNjNzcwNS4uOWYyZGYzYzQ5MDJiMjdlMWNlNTdhYzJh YjZkNzJhNWQyOThkNGM0ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3IEBACisyMDExLTAzLTAy ICBJbHlhIFNoZXJtYW4gIDxpc2hlcm1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSFRNTElucHV0RWxlbWVudDo6c2V0VmFs dWUoKSBzaG91bGQgc2NoZWR1bGUgY2hhbmdlIGV2ZW50IHdoZW4gdGhlIGVsZW1lbnQgaXMgZm9j dXNlZC4KKyAgICAgICAgUmVmYWN0b3JlZCB0cmFja2luZyBvZiAiY2hhbmdlZCBzaW5jZSBsYXN0 IGNoYW5nZSBldmVudCIgc3RhdGUgZnJvbSByZW5kZXJlciB0byBET00uSW4gc2VydmljZSBvZiBo dHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9taXVtL2lzc3VlcworICAgICAgICBJbiBzZXJ2 aWNlIG9mIGh0dHBzOi8vY29kZS5nb29nbGUuY29tL3AvY2hyb21pdW0vaXNzdWVzL2RldGFpbD9p ZD00MjcxNgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NTMxNjAKKworICAgICAgICBUZXN0OiBmYXN0L2Zvcm1zL29uY2hhbmdlLWNoYW5nZS10eXBlLmh0 bWwKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIuaHRt bAorCisgICAgICAgICogV2ViQ29yZS5leHAuaW46CisgICAgICAgICogZG9tL0RvY3VtZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpzZXRGb2N1c2VkTm9kZSk6CisgICAgICAg ICogaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50OjpIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudCk6Cisg ICAgICAgIChXZWJDb3JlOjpIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6d2FzQ2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50KTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpIVE1MVGV4dEZv cm1Db250cm9sRWxlbWVudDo6c2V0Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KTogQWRkZWQu CisgICAgICAgIChXZWJDb3JlOjpIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0Y2hG b3JtQ29udHJvbENoYW5nZUV2ZW50KTogT3ZlcnJpZGRlbiB0byBjbGVhciB0aGUgImNoYW5nZWQg c2luY2UgbGFzdCBjaGFuZ2UgZXZlbnQiIGZsYWcuCisgICAgICAgICogaHRtbC9IVE1MRm9ybUNv bnRyb2xFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnVwZGF0ZVR5cGUpOiBBbHNvIGNsZWFy IHRoZSAiY2hhbmdlZCBzaW5jZSBsYXN0IGNoYW5nZSBldmVudCIgZmxhZy4KKyAgICAgICAgKFdl YkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKToKKyAgICAgICAgICAgIEZvciBhIGZv Y3VzZWQgdGV4dCBmaWVsZCwgZGlzcGF0Y2ggYW4gaW5wdXQgZXZlbnQsIGJ1dCBkZWxheSB0aGUg Y2hhbmdlIGV2ZW50IHVudGlsIHRoZSBmaWVsZCBsb3NlcyBmb2N1cy4KKyAgICAgICAgKFdlYkNv cmU6OkhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgorICAgICAgICAoV2Vi Q29yZTo6SFRNTElucHV0RWxlbWVudDo6c3RlcFVwRnJvbVJlbmRlcmVyKToKKyAgICAgICAgKiBo dG1sL3NoYWRvdy9UZXh0Q29udHJvbElubmVyRWxlbWVudHMuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6U2VhcmNoRmllbGRDYW5jZWxCdXR0b25FbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKToK KyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmVuZGVyVGV4dENvbnRyb2w6OlJlbmRlclRleHRDb250cm9sKToKKyAgICAgICAgKFdl YkNvcmU6OlJlbmRlclRleHRDb250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdlZCk6CisgICAgICAgICog cmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRl clRleHRDb250cm9sTXVsdGlMaW5lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclRleHRD b250cm9sTXVsdGlMaW5lOjpzdWJ0cmVlSGFzQ2hhbmdlZCk6CisgICAgICAgICogcmVuZGVyaW5n L1JlbmRlclRleHRDb250cm9sU2luZ2xlTGluZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5k ZXJUZXh0Q29udHJvbFNpbmdsZUxpbmU6OnN1YnRyZWVIYXNDaGFuZ2VkKToKKyAgICAgICAgKiB3 bWwvV01MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVu dDo6V01MSW5wdXRFbGVtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6 ZGVmYXVsdEV2ZW50SGFuZGxlcik6CisgICAgICAgICogd21sL1dNTElucHV0RWxlbWVudC5oOgor ICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Q2hh bmdlRXZlbnQpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6c2V0 Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KTogQWRkZWQuCisKIDIwMTEtMDMtMDEgIElseWEg VGlraG9ub3Zza3kgIDxsb2lzbG9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IFBhdmVsIEZlbGRtYW4uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5p biBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZXhwLmluCmluZGV4IDk5YjVlODQ0OTJkODVkZTUz NzI2NDY2ZDJmNjgyYjRhNGMwYzgyZWIuLjBiMGE0MTNjMzMzNjU1MWZmOWEwZmYzZTQ3NGU0YTky ZjFiNjg3YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZXhwLmluCisrKyBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZXhwLmluCkBAIC0zNjMsNiArMzYzLDcgQEAgX19aTjdX ZWJDb3JlMTRTZWN1cml0eU9yaWdpbjMycmVtb3ZlT3JpZ2luQWNjZXNzV2hpdGVsaXN0RW50cnlF UktTMF9SS04zV1RGNlN0cmkKIF9fWk43V2ViQ29yZTE0U2VjdXJpdHlPcmlnaW40MHNldERvbWFp blJlbGF4YXRpb25Gb3JiaWRkZW5Gb3JVUkxTY2hlbWVFYlJLTjNXVEY2U3RyaW5nRQogX19aTjdX ZWJDb3JlMTRTZWN1cml0eU9yaWdpbjZjcmVhdGVFUktOM1dURjZTdHJpbmdFUzRfaQogX19aTjdX ZWJDb3JlMTRTZWN1cml0eU9yaWdpbjZjcmVhdGVFUktOU180S1VSTEVpCitfX1pON1dlYkNvcmUx NHRvSW5wdXRFbGVtZW50RVBOU183RWxlbWVudEUKIF9fWk43V2ViQ29yZTE1QXJjaGl2ZVJlc291 cmNlNmNyZWF0ZUVOM1dURjEwUGFzc1JlZlB0cklOU18xMlNoYXJlZEJ1ZmZlckVFRVJLTlNfNEtV UkxFUktOUzFfNlN0cmluZ0VTQV9TQV9SS05TXzE2UmVzb3VyY2VSZXNwb25zZUUKIF9fWk43V2Vi Q29yZTE1RE9NV3JhcHBlcldvcmxkMTNjbGVhcldyYXBwZXJzRXYKIF9fWk43V2ViQ29yZTE1RE9N V3JhcHBlcldvcmxkRDFFdgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggNTc3N2IxNTEzMDEy ZTJiZDM2M2QxNTY1MDdlNTc3OTExYjNlYzg0Mi4uZTcyYjE1ZmU0YzUyOGI2ZWYzZjc1YzJmZjI4 MjY0NmM0YWE1ZjE3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCkBAIC0xOTEsNiArMTkxLDcg QEAKICNpbmNsdWRlICJXTUxEb2N1bWVudC5oIgogI2luY2x1ZGUgIldNTEVsZW1lbnQuaCIKICNp bmNsdWRlICJXTUxFbGVtZW50RmFjdG9yeS5oIgorI2luY2x1ZGUgIldNTElucHV0RWxlbWVudC5o IgogI2luY2x1ZGUgIldNTE5hbWVzLmgiCiAjZW5kaWYKIApAQCAtMzE2OSwxMiArMzE3MCwyMCBA QCBib29sIERvY3VtZW50OjpzZXRGb2N1c2VkTm9kZShQYXNzUmVmUHRyPE5vZGU+IG5ld0ZvY3Vz ZWROb2RlKQogICAgICAgICBvbGRGb2N1c2VkTm9kZS0+c2V0Rm9jdXMoZmFsc2UpOwogCiAgICAg ICAgIC8vIERpc3BhdGNoIGEgY2hhbmdlIGV2ZW50IGZvciB0ZXh0IGZpZWxkcyBvciB0ZXh0YXJl YXMgdGhhdCBoYXZlIGJlZW4gZWRpdGVkCi0gICAgICAgIFJlbmRlck9iamVjdCogciA9IG9sZEZv Y3VzZWROb2RlLT5yZW5kZXJlcigpOwotICAgICAgICBpZiAociAmJiByLT5pc1RleHRDb250cm9s KCkgJiYgdG9SZW5kZXJUZXh0Q29udHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2 ZW50KCkpIHsKLSAgICAgICAgICAgIHN0YXRpY19jYXN0PEVsZW1lbnQqPihvbGRGb2N1c2VkTm9k ZS5nZXQoKSktPmRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAgICAgICAgICAg ciA9IG9sZEZvY3VzZWROb2RlLT5yZW5kZXJlcigpOwotICAgICAgICAgICAgaWYgKHIgJiYgci0+ aXNUZXh0Q29udHJvbCgpKQotICAgICAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wocikt PnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudChmYWxzZSk7CisgICAgICAgIGlmIChvbGRG b2N1c2VkTm9kZS0+aXNFbGVtZW50Tm9kZSgpKSB7CisgICAgICAgICAgICBFbGVtZW50KiBlbGVt ZW50ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG9sZEZvY3VzZWROb2RlLmdldCgpKTsKKyAgICAg ICAgICAgIGlmIChlbGVtZW50LT5pc1RleHRGb3JtQ29udHJvbCgpKSB7CisgICAgICAgICAgICAg ICAgYm9vbCB3YXNDaGFuZ2VkID0gZmFsc2U7CisgICAgICAgICAgICAgICAgaWYgKGVsZW1lbnQt PmlzSFRNTEVsZW1lbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgd2FzQ2hhbmdlZCA9IHN0YXRp Y19jYXN0PEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50Kj4oZWxlbWVudCktPndhc0NoYW5nZWRT aW5jZUxhc3RDaGFuZ2VFdmVudCgpOworI2lmIEVOQUJMRShXTUwpCisgICAgICAgICAgICAgICAg ZWxzZSBpZiAoZWxlbWVudC0+aXNXTUxFbGVtZW50KCkpCisgICAgICAgICAgICAgICAgICAgIHdh c0NoYW5nZWQgPSBzdGF0aWNfY2FzdDxXTUxJbnB1dEVsZW1lbnQqPihlbGVtZW50KS0+d2FzQ2hh bmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCk7CisjZW5kaWYKKworICAgICAgICAgICAgICAgIGlm ICh3YXNDaGFuZ2VkKQorICAgICAgICAgICAgICAgICAgICBlbGVtZW50LT5kaXNwYXRjaEZvcm1D b250cm9sQ2hhbmdlRXZlbnQoKTsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogCiAgICAgICAg IC8vIERpc3BhdGNoIHRoZSBibHVyIGV2ZW50IGFuZCBsZXQgdGhlIG5vZGUgZG8gYW55IG90aGVy IGJsdXIgcmVsYXRlZCBhY3Rpdml0aWVzIChpbXBvcnRhbnQgZm9yIHRleHQgZmllbGRzKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcCBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAKaW5kZXggMmYz ZGIwOGY1NTc2ZTllYjQxZWE4NmUwOTM3MGI1ZWFmOTA3MTQ3OC4uMTFmNmJjNDk0OGQ3OTJjYTdl Mzc0NjU0MTkxOGViZTFjYzI3NDk0ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxG b3JtQ29udHJvbEVsZW1lbnQuY3BwCkBAIC01MjcsNiArNTI3LDcgQEAgdm9pZCBIVE1MRm9ybUNv bnRyb2xFbGVtZW50V2l0aFN0YXRlOjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCkK IAogSFRNTFRleHRGb3JtQ29udHJvbEVsZW1lbnQ6OkhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50 KGNvbnN0IFF1YWxpZmllZE5hbWUmIHRhZ05hbWUsIERvY3VtZW50KiBkb2MsIEhUTUxGb3JtRWxl bWVudCogZm9ybSkKICAgICA6IEhUTUxGb3JtQ29udHJvbEVsZW1lbnRXaXRoU3RhdGUodGFnTmFt ZSwgZG9jLCBmb3JtKQorICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFs c2UpCiB7CiB9CiAKQEAgLTY0OCw2ICs2NDksMjIgQEAgUGFzc1JlZlB0cjxSYW5nZT4gSFRNTFRl eHRGb3JtQ29udHJvbEVsZW1lbnQ6OnNlbGVjdGlvbigpIGNvbnN0CiAgICAgICAgIHJldHVybiAw OwogICAgIHJldHVybiB0b1JlbmRlclRleHRDb250cm9sKHJlbmRlcmVyKCkpLT5zZWxlY3Rpb24o Y2FjaGVkU2VsZWN0aW9uU3RhcnQoKSwgY2FjaGVkU2VsZWN0aW9uRW5kKCkpOwogfQorICAgIAor Ym9vbCBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5n ZUV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdl RXZlbnQ7Cit9CisKK3ZvaWQgSFRNTFRleHRGb3JtQ29udHJvbEVsZW1lbnQ6OnNldENoYW5nZWRT aW5jZUxhc3RDaGFuZ2VFdmVudChib29sIGNoYW5nZWQpCit7CisgICAgbV93YXNDaGFuZ2VkU2lu Y2VMYXN0Q2hhbmdlRXZlbnQgPSBjaGFuZ2VkOworfQorCit2b2lkIEhUTUxUZXh0Rm9ybUNvbnRy b2xFbGVtZW50OjpkaXNwYXRjaEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoKQoreworICAgIEhUTUxG b3JtQ29udHJvbEVsZW1lbnQ6OmRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAg IHNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudChmYWxzZSk7Cit9CiAKIHZvaWQgSFRNTFRl eHRGb3JtQ29udHJvbEVsZW1lbnQ6OnBhcnNlTWFwcGVkQXR0cmlidXRlKEF0dHJpYnV0ZSogYXR0 cikKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxl bWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKaW5k ZXggMzY4ZGNmYWQ3ZjRkNjg1MDM4NjRlOGFhY2RlZmZhNGQ4NWRjOWIxZS4uYzgzOWU1M2MzNjUw MWZlYTc3OTFlMmQxYjU3ZGQyYmUwNzMxNzkxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKQEAgLTIwNSw2ICsyMDUsMTAgQEAgcHVibGljOgogICAg IHZpcnR1YWwgaW50IG1heExlbmd0aCgpIGNvbnN0ID0gMDsKICAgICB2aXJ0dWFsIFN0cmluZyB2 YWx1ZSgpIGNvbnN0ID0gMDsKIAorICAgIHZpcnR1YWwgYm9vbCB3YXNDaGFuZ2VkU2luY2VMYXN0 Q2hhbmdlRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0Q2hhbmdlZFNpbmNlTGFz dENoYW5nZUV2ZW50KGJvb2wpOworICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaEZvcm1Db250cm9s Q2hhbmdlRXZlbnQoKTsKKwogcHJvdGVjdGVkOgogICAgIEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVt ZW50KGNvbnN0IFF1YWxpZmllZE5hbWUmLCBEb2N1bWVudCosIEhUTUxGb3JtRWxlbWVudCopOwog CkBAIC0yMjksNiArMjMzLDggQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlQmx1 ckV2ZW50KCkgeyB9CiAKICAgICBSZW5kZXJUZXh0Q29udHJvbCogdGV4dFJlbmRlcmVyQWZ0ZXJV cGRhdGVMYXlvdXQoKTsKKyAgICAKKyAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5n ZUV2ZW50IDogMTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M SW5wdXRFbGVtZW50LmNwcAppbmRleCBhMjIxZDNlNWE5ZmYyMTYyMzQwNTk1YWZmZDEzNDZiMjA5 ZjZiZTJmLi44Njk3ODI1NmI3ZTQyNGZjOWUxNmNjZmM3MzlkNWVkOWRmZmUxZjMyIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKQEAgLTQ4OSw2ICs0ODksOCBAQCB2 b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnVwZGF0ZVR5cGUoKQogICAgICAgICAgICAgdXBkYXRlRm9j dXNBcHBlYXJhbmNlKHRydWUpOwogICAgIH0KIAorICAgIHNldENoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudChmYWxzZSk7CisKICAgICBjaGVja2VkUmFkaW9CdXR0b25zKCkuYWRkQnV0dG9uKHRo aXMpOwogCiAgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7CkBAIC04ODksMTAgKzg5MSwxNSBA QCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKGNvbnN0IFN0cmluZyYgdmFsdWUsIGJv b2wgc2VuZENoYW5nZUV2ZW50KQogICAgIH0KICAgICBtX2lucHV0VHlwZS0+dmFsdWVDaGFuZ2Vk KCk7CiAKLSAgICAvLyBEb24ndCBkaXNwYXRjaCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4gZm9jdXNl ZCwgaXQgd2lsbCBiZSBkaXNwYXRjaGVkCi0gICAgLy8gd2hlbiB0aGUgY29udHJvbCBsb3NlcyBm b2N1cy4KLSAgICBpZiAoc2VuZENoYW5nZUV2ZW50ICYmIGRvY3VtZW50KCktPmZvY3VzZWROb2Rl KCkgIT0gdGhpcykKLSAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7Cisg ICAgaWYgKHNlbmRDaGFuZ2VFdmVudCkgeworICAgICAgICAvLyBGb3IgdGV4dCBmaWVsZHMsIGRv bid0IGRpc3BhdGNoIHRoZSBjaGFuZ2UgZXZlbnQgd2hlbiBmb2N1c2VkLgorICAgICAgICAvLyBJ dCB3aWxsIGJlIGRpc3BhdGNoZWQgd2hlbiB0aGUgY29udHJvbCBsb3NlcyBmb2N1cy4KKyAgICAg ICAgaWYgKGlzVGV4dEZpZWxkKCkgJiYgZm9jdXNlZCgpKSB7CisgICAgICAgICAgICBzZXRDaGFu Z2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQodHJ1ZSk7CisgICAgICAgICAgICBkaXNwYXRjaEZvcm1D b250cm9sSW5wdXRFdmVudCgpOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGRpc3BhdGNo Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOworICAgIH0KIAogICAgIElucHV0RWxlbWVudDo6bm90 aWZ5Rm9ybVN0YXRlQ2hhbmdlZCh0aGlzKTsKIH0KQEAgLTEwMzMsMTUgKzEwNDAsMTIgQEAgdm9p ZCBIVE1MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCiAgICAg ICAgICAgICBhZGRTZWFyY2hSZXN1bHQoKTsKICAgICAgICAgICAgIG9uU2VhcmNoKCk7CiAgICAg ICAgIH0KLSAgICAgICAgLy8gRmlyZSBvbkNoYW5nZSBmb3IgdGV4dCBmaWVsZHMuCi0gICAgICAg IFJlbmRlck9iamVjdCogciA9IHJlbmRlcmVyKCk7Ci0gICAgICAgIGlmIChyICYmIHItPmlzVGV4 dEZpZWxkKCkgJiYgdG9SZW5kZXJUZXh0Q29udHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENo YW5nZUV2ZW50KCkpIHsKKyAgICAgICAgLy8gRGlzcGF0Y2ggYSBjaGFuZ2UgZXZlbnQgZm9yIHRl eHQgZmllbGRzIHRoYXQgaGF2ZSBiZWVuIGVkaXRlZCBwcmlvcgorICAgICAgICAvLyB0byBmb3Jt IHN1Ym1pc3Npb24uIE5vcm1hbGx5IHRoaXMgZXZlbnQgaXMgZGlzcGF0Y2hlZCB3aGVuIHRoZSBm aWVsZAorICAgICAgICAvLyBsb3NlcyBmb2N1cywgYnV0IGZvcm0gc3VibWlzc2lvbiBpcyBhbm90 aGVyIHNwZWNpYWwgY2FzZSB3aGVyZSB3ZQorICAgICAgICAvLyBjb25zaWRlciBlZGl0aW5nIHRv IGhhdmUgZmluaXNoZWQuCisgICAgICAgIGlmICh3YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZl bnQoKSkKICAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAg ICAgICAgICAgLy8gUmVmZXRjaCB0aGUgcmVuZGVyZXIgc2luY2UgYXJiaXRyYXJ5IEpTIGNvZGUg cnVuIGR1cmluZyBvbmNoYW5nZSBjYW4gZG8gYW55dGhpbmcsIGluY2x1ZGluZyBkZXN0cm95aW5n IGl0LgotICAgICAgICAgICAgciA9IHJlbmRlcmVyKCk7Ci0gICAgICAgICAgICBpZiAociAmJiBy LT5pc1RleHRGaWVsZCgpKQotICAgICAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wocikt PnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudChmYWxzZSk7Ci0gICAgICAgIH0KIAogICAg ICAgICBSZWZQdHI8SFRNTEZvcm1FbGVtZW50PiBmb3JtRm9yU3VibWlzc2lvbiA9IG1faW5wdXRU eXBlLT5mb3JtRm9yU3VibWlzc2lvbigpOwogICAgICAgICAvLyBGb3JtIG1heSBuZXZlciBoYXZl IGJlZW4gcHJlc2VudCwgb3IgbWF5IGhhdmUgYmVlbiBkZXN0cm95ZWQgYnkgY29kZSByZXNwb25k aW5nIHRvIHRoZSBjaGFuZ2UgZXZlbnQuCkBAIC0xNDEwLDggKzE0MTQsOSBAQCB2b2lkIEhUTUxJ bnB1dEVsZW1lbnQ6OnN0ZXBVcEZyb21SZW5kZXJlcihpbnQgbikKICAgICB9CiAKICAgICBpZiAo Y3VycmVudFN0cmluZ1ZhbHVlICE9IHZhbHVlKCkpIHsKLSAgICAgICAgaWYgKHJlbmRlcmVyKCkg JiYgcmVuZGVyZXIoKS0+aXNUZXh0RmllbGQoKSkKLSAgICAgICAgICAgIHRvUmVuZGVyVGV4dENv bnRyb2wocmVuZGVyZXIoKSktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCh0cnVlKTsK KyAgICAgICAgaWYgKGlzVGV4dEZpZWxkKCkpCisgICAgICAgICAgICBzZXRDaGFuZ2VkU2luY2VM YXN0Q2hhbmdlRXZlbnQodHJ1ZSk7CisKICAgICAgICAgaWYgKG1faW5wdXRUeXBlLT5pc1Jhbmdl Q29udHJvbCgpKQogICAgICAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7 CiAgICAgICAgIGVsc2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1Rl eHRDb250cm9sSW5uZXJFbGVtZW50cy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9U ZXh0Q29udHJvbElubmVyRWxlbWVudHMuY3BwCmluZGV4IDA3ZjUzOWRhNTQ2ODZkZjVmMjFjMzMw MGVmYzE1YWMxZWE4MjNhYjYuLjk2OGM1ZTQ4NWFlNDc5ZmQxNjUyYmEzNDM5M2FlMzY3ODI4ZjMx NzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRDb250cm9sSW5u ZXJFbGVtZW50cy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dENvbnRy b2xJbm5lckVsZW1lbnRzLmNwcApAQCAtMjExLDExICsyMTEsNyBAQCB2b2lkIFNlYXJjaEZpZWxk Q2FuY2VsQnV0dG9uRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiAg ICAgICAgICAgICB9CiAgICAgICAgICAgICBpZiAoaG92ZXJlZCgpKSB7CiAgICAgICAgICAgICAg ICAgU3RyaW5nIG9sZFZhbHVlID0gaW5wdXQtPnZhbHVlKCk7Ci0gICAgICAgICAgICAgICAgaW5w dXQtPnNldFZhbHVlKCIiKTsKLSAgICAgICAgICAgICAgICBpZiAoIW9sZFZhbHVlLmlzRW1wdHko KSkgewotICAgICAgICAgICAgICAgICAgICB0b1JlbmRlclRleHRDb250cm9sKGlucHV0LT5yZW5k ZXJlcigpKS0+c2V0Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KHRydWUpOwotICAgICAgICAg ICAgICAgICAgICBpbnB1dC0+ZGlzcGF0Y2hGb3JtQ29udHJvbElucHV0RXZlbnQoKTsKLSAgICAg ICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgaW5wdXQtPnNldFZhbHVlRm9yVXNlcigiIik7 CiAgICAgICAgICAgICAgICAgaW5wdXQtPm9uU2VhcmNoKCk7CiAgICAgICAgICAgICAgICAgZXZl bnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CiAgICAgICAgICAgICB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuY3BwIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNwcAppbmRleCAzN2RlZWMxMGFkZmVhZjk4 ZDk1MTllZDExYjk1YjllYTkxYjgxNDMxLi4wMjYzYjBiOWUzOTQ4NGIzYjA3OGMzMDY2MWUwZTI2 Nzg3OGIxYzBiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4 dENvbnRyb2wuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29u dHJvbC5jcHAKQEAgLTc0LDcgKzc0LDYgQEAgc3RhdGljIENvbG9yIGRpc2FibGVkVGV4dENvbG9y KGNvbnN0IENvbG9yJiB0ZXh0Q29sb3IsIGNvbnN0IENvbG9yJiBiYWNrZ3JvdW5kQ28KIFJlbmRl clRleHRDb250cm9sOjpSZW5kZXJUZXh0Q29udHJvbChOb2RlKiBub2RlLCBib29sIHBsYWNlaG9s ZGVyVmlzaWJsZSkKICAgICA6IFJlbmRlckJsb2NrKG5vZGUpCiAgICAgLCBtX3BsYWNlaG9sZGVy VmlzaWJsZShwbGFjZWhvbGRlclZpc2libGUpCi0gICAgLCBtX3dhc0NoYW5nZWRTaW5jZUxhc3RD aGFuZ2VFdmVudChmYWxzZSkKICAgICAsIG1fbGFzdENoYW5nZVdhc1VzZXJFZGl0KGZhbHNlKQog ewogfQpAQCAtMzUxLDcgKzM1MCw2IEBAIGludCBSZW5kZXJUZXh0Q29udHJvbDo6aW5kZXhGb3JW aXNpYmxlUG9zaXRpb24oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiBwb3MpIGNvbnN0CiAKIHZvaWQg UmVuZGVyVGV4dENvbnRyb2w6OnN1YnRyZWVIYXNDaGFuZ2VkKCkKIHsKLSAgICBtX3dhc0NoYW5n ZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCA9IHRydWU7CiAgICAgbV9sYXN0Q2hhbmdlV2FzVXNlckVk aXQgPSB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyVGV4dENvbnRyb2wuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29u dHJvbC5oCmluZGV4IGNkODgxMmU2ODY5N2ZmNTkzNzMyMjc5OGJkZTYzNjliMzUxYzEwYzAuLjBj MzBlZDY0YTg1MWIwOTY5ODVjZGE5Yjk3NWMxZmU4Y2FlNjg3MDIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbC5oCkBAIC0zNiw5ICszNiw2IEBAIHB1Ymxp YzoKIAogICAgIEhUTUxFbGVtZW50KiBpbm5lclRleHRFbGVtZW50KCkgY29uc3Q7CiAKLSAgICBi b29sIHdhc0NoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fd2Fz Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OyB9Ci0gICAgdm9pZCBzZXRDaGFuZ2VkU2luY2VM YXN0Q2hhbmdlRXZlbnQoYm9vbCB3YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQpIHsgbV93 YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQgPSB3YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdl RXZlbnQ7IH0KLQogICAgIGJvb2wgbGFzdENoYW5nZVdhc1VzZXJFZGl0KCkgY29uc3QgeyByZXR1 cm4gbV9sYXN0Q2hhbmdlV2FzVXNlckVkaXQ7IH0KICAgICB2b2lkIHNldExhc3RDaGFuZ2VXYXNV c2VyRWRpdChib29sIGxhc3RDaGFuZ2VXYXNVc2VyRWRpdCk7CiAKQEAgLTExNSw3ICsxMTIsNiBA QCBwcml2YXRlOgogCiAgICAgdm9pZCBwYWludFBsYWNlaG9sZGVyKFBhaW50SW5mbyYsIGludCB0 eCwgaW50IHR5KTsKIAotICAgIGJvb2wgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQ7 CiAgICAgYm9vbCBtX2xhc3RDaGFuZ2VXYXNVc2VyRWRpdDsKICAgICBSZWZQdHI8VGV4dENvbnRy b2xJbm5lclRleHRFbGVtZW50PiBtX2lubmVyVGV4dDsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xNdWx0aUxpbmUuY3BwIGIvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sTXVsdGlMaW5lLmNwcAppbmRleCAw ZDUxMmYzNjIxMDA3ZmM1NzU2YWUxNjE1YTlkMTZhYWFkN2UzZDZmLi41NmJkZjVkYTQzZGM0Y2Vh N2I1YzFmMGUyMGU4ZjAxN2MwYjM2YmY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xNdWx0aUxpbmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbE11bHRpTGluZS5jcHAKQEAgLTQ2LDYgKzQ2LDcg QEAgdm9pZCBSZW5kZXJUZXh0Q29udHJvbE11bHRpTGluZTo6c3VidHJlZUhhc0NoYW5nZWQoKQog ewogICAgIFJlbmRlclRleHRDb250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdlZCgpOwogICAgIEhUTUxU ZXh0QXJlYUVsZW1lbnQqIHRleHRBcmVhID0gc3RhdGljX2Nhc3Q8SFRNTFRleHRBcmVhRWxlbWVu dCo+KG5vZGUoKSk7CisgICAgdGV4dEFyZWEtPnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVu dCh0cnVlKTsKICAgICB0ZXh0QXJlYS0+c2V0Rm9ybUNvbnRyb2xWYWx1ZU1hdGNoZXNSZW5kZXJl cihmYWxzZSk7CiAgICAgdGV4dEFyZWEtPnNldE5lZWRzVmFsaWRpdHlDaGVjaygpOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVM aW5lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmds ZUxpbmUuY3BwCmluZGV4IDZkZWQwZWEwY2RmMjUxZTk3ZTcxNWM2Yjc2M2ZkN2I2ZmZiZDJjMWMu LjkwOTBlMDg3OWMwNzIzYjM5N2E1MDFjZTYzNmJiODRhZTQ5NDU5OTkgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUu Y3BwCkBAIC00NSw2ICs0NSwxMCBAQAogI2luY2x1ZGUgIlNpbXBsZUZvbnREYXRhLmgiCiAjaW5j bHVkZSAiVGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmgiCiAKKyNpZiBFTkFCTEUoV01MKQorI2lu Y2x1ZGUgIldNTElucHV0RWxlbWVudC5oIgorI2VuZGlmCisKIHVzaW5nIG5hbWVzcGFjZSBzdGQ7 CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTE4MSw5ICsxODUsMjUgQEAgdm9pZCBSZW5kZXJU ZXh0Q29udHJvbFNpbmdsZUxpbmU6OmhpZGVQb3B1cCgpCiAKIHZvaWQgUmVuZGVyVGV4dENvbnRy b2xTaW5nbGVMaW5lOjpzdWJ0cmVlSGFzQ2hhbmdlZCgpCiB7Ci0gICAgYm9vbCB3YXNDaGFuZ2Vk ID0gd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCk7CiAgICAgUmVuZGVyVGV4dENvbnRy b2w6OnN1YnRyZWVIYXNDaGFuZ2VkKCk7CiAKKyAgICBBU1NFUlQobm9kZSgpLT5pc0VsZW1lbnRO b2RlKCkpOworICAgIEVsZW1lbnQqIGVsZW1lbnQgPSBzdGF0aWNfY2FzdDxFbGVtZW50Kj4obm9k ZSgpKTsKKyAgICBBU1NFUlQoZWxlbWVudC0+aXNUZXh0Rm9ybUNvbnRyb2woKSk7CisgICAgYm9v bCB3YXNDaGFuZ2VkID0gZmFsc2U7CisgICAgaWYgKGVsZW1lbnQtPmlzSFRNTEVsZW1lbnQoKSkg eworICAgICAgICBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudCogdGV4dEZvcm1Db250cm9sRWxl bWVudCA9IHN0YXRpY19jYXN0PEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50Kj4oZWxlbWVudCk7 CisgICAgICAgIHdhc0NoYW5nZWQgPSB0ZXh0Rm9ybUNvbnRyb2xFbGVtZW50LT53YXNDaGFuZ2Vk U2luY2VMYXN0Q2hhbmdlRXZlbnQoKTsKKyAgICAgICAgdGV4dEZvcm1Db250cm9sRWxlbWVudC0+ c2V0Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KHRydWUpOworICAgIH0KKyNpZiBFTkFCTEUo V01MKQorICAgIGVsc2UgaWYgKGVsZW1lbnQtPmlzV01MRWxlbWVudCgpKSB7CisgICAgICAgIFdN TElucHV0RWxlbWVudCogd21sSW5wdXQgPSBzdGF0aWNfY2FzdDxXTUxJbnB1dEVsZW1lbnQqPihl bGVtZW50KTsKKyAgICAgICAgd2FzQ2hhbmdlZCA9IHdtbElucHV0LT53YXNDaGFuZ2VkU2luY2VM YXN0Q2hhbmdlRXZlbnQoKTsKKyAgICAgICAgd21sSW5wdXQtPnNldENoYW5nZWRTaW5jZUxhc3RD aGFuZ2VFdmVudCh0cnVlKTsKKyAgICB9CisjZW5kaWYKKwogICAgIElucHV0RWxlbWVudCogaW5w dXQgPSBpbnB1dEVsZW1lbnQoKTsKICAgICAvLyBXZSBkb24ndCBuZWVkIHRvIGNhbGwgc2FuaXRp emVVc2VySW5wdXRWYWx1ZSgpIGZ1bmN0aW9uIGhlcmUgYmVjYXVzZQogICAgIC8vIElucHV0RWxl bWVudDo6aGFuZGxlQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoKSBoYXMgYWxyZWFkeSBjYWxsZWQK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291 cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKaW5kZXggNjg3YTM4NzI1NWIxMDEw YjVlOTE3NTliYTYwZjVmZTMyYTNlNzI2OS4uMjIzOTJmNDk1ODJmNTI3OGJkYzBhNjgzNmVhNTZi NjNmNDU4MTA3NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKQEAgLTQx LDYgKzQxLDcgQEAgV01MSW5wdXRFbGVtZW50OjpXTUxJbnB1dEVsZW1lbnQoY29uc3QgUXVhbGlm aWVkTmFtZSYgdGFnTmFtZSwgRG9jdW1lbnQqIGRvYykKICAgICA6IFdNTEZvcm1Db250cm9sRWxl bWVudCh0YWdOYW1lLCBkb2MpCiAgICAgLCBtX2lzUGFzc3dvcmRGaWVsZChmYWxzZSkKICAgICAs IG1faXNFbXB0eU9rKGZhbHNlKQorICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZl bnQoZmFsc2UpCiAgICAgLCBtX251bU9mQ2hhcnNBbGxvd2VkQnlNYXNrKDApCiB7CiB9CkBAIC0y OTYsMTQgKzI5Nyw5IEBAIHZvaWQgV01MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVy KEV2ZW50KiBldnQpCiAKICAgICBpZiAoY2xpY2tEZWZhdWx0Rm9ybUJ1dHRvbikgewogICAgICAg ICAvLyBGaXJlIG9uQ2hhbmdlIGZvciB0ZXh0IGZpZWxkcy4KLSAgICAgICAgUmVuZGVyT2JqZWN0 KiByID0gcmVuZGVyZXIoKTsKLSAgICAgICAgaWYgKHIgJiYgdG9SZW5kZXJUZXh0Q29udHJvbChy KS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkpIHsKKyAgICAgICAgaWYgKHdhc0No YW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCgpKSB7CisgICAgICAgICAgICBzZXRDaGFuZ2VkU2lu Y2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpOwogICAgICAgICAgICAgZGlzcGF0Y2hFdmVudChFdmVu dDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5jaGFuZ2VFdmVudCwgdHJ1ZSwgZmFsc2UpKTsKLSAgICAg ICAgICAgIAotICAgICAgICAgICAgLy8gUmVmZXRjaCB0aGUgcmVuZGVyZXIgc2luY2UgYXJiaXRy YXJ5IEpTIGNvZGUgcnVuIGR1cmluZyBvbmNoYW5nZSBjYW4gZG8gYW55dGhpbmcsIGluY2x1ZGlu ZyBkZXN0cm95aW5nIGl0LgotICAgICAgICAgICAgciA9IHJlbmRlcmVyKCk7Ci0gICAgICAgICAg ICBpZiAocikKLSAgICAgICAgICAgICAgICB0b1JlbmRlclRleHRDb250cm9sKHIpLT5zZXRDaGFu Z2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpOwogICAgICAgICB9CiAKICAgICAgICAgZXZ0 LT5zZXREZWZhdWx0SGFuZGxlZCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvd21sL1dN TElucHV0RWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5oCmlu ZGV4IDZjNjY0MTBiY2Y3NmE5ZWZmYjE4ZWU1MzlkYjBhNjE3OTg5YTI1M2UuLmQzNjM4ODU1Yzgz ZDQzZTNmMWIzN2Y2NjU1NTBlNGY2MjNjMjZjOWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3dtbC9XTUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS93bWwvV01MSW5wdXRF bGVtZW50LmgKQEAgLTY2LDYgKzY2LDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwgU3RyaW5nIHZp c2libGVWYWx1ZSgpIGNvbnN0IHsgcmV0dXJuIHZhbHVlKCk7IH0KICAgICB2aXJ0dWFsIHZvaWQg c2V0VmFsdWVGcm9tUmVuZGVyZXIoY29uc3QgU3RyaW5nJik7CiAKKyAgICB2aXJ0dWFsIGJvb2wg d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkgY29uc3QgeyByZXR1cm4gbV93YXNDaGFu Z2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQ7IH0KKyAgICB2aXJ0dWFsIHZvaWQgc2V0Q2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50KGJvb2wgY2hhbmdlZCkgeyBtX3dhc0NoYW5nZWRTaW5jZUxhc3RD aGFuZ2VFdmVudCA9IGNoYW5nZWQ7IH0KKwogICAgIHZpcnR1YWwgYm9vbCBzYXZlRm9ybUNvbnRy b2xTdGF0ZShTdHJpbmcmIHZhbHVlKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgcmVzdG9yZUZv cm1Db250cm9sU3RhdGUoY29uc3QgU3RyaW5nJik7CiAKQEAgLTEwOSw2ICsxMTIsNyBAQCBwcml2 YXRlOgogICAgIElucHV0RWxlbWVudERhdGEgbV9kYXRhOwogICAgIGJvb2wgbV9pc1Bhc3N3b3Jk RmllbGQ7CiAgICAgYm9vbCBtX2lzRW1wdHlPazsKKyAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNl TGFzdENoYW5nZUV2ZW50OwogICAgIFN0cmluZyBtX2Zvcm1hdE1hc2s7CiAgICAgdW5zaWduZWQg bV9udW1PZkNoYXJzQWxsb3dlZEJ5TWFzazsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L21hYy9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKaW5kZXggYmZmMDEx YmU2MDU3NjIzYjEzMmNkYTYzMTUxYzU3N2ZjMWNkMDMxNy4uNTAyM2E3MzkwODkwODVlNjMyYTQz MTc5M2IwMzRiZGU3NzA1ZGM3MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisy MDExLTAzLTAyICBJbHlhIFNoZXJtYW4gIDxpc2hlcm1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSFRNTElucHV0RWxlbWVu dDo6c2V0VmFsdWUoKSBzaG91bGQgc2NoZWR1bGUgY2hhbmdlIGV2ZW50IHdoZW4gdGhlIGVsZW1l bnQgaXMgZm9jdXNlZAorICAgICAgICBJbiBzZXJ2aWNlIG9mIGh0dHBzOi8vY29kZS5nb29nbGUu Y29tL3AvY2hyb21pdW0vaXNzdWVzL2RldGFpbD9pZD00MjcxNgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMxNjAKKworICAgICAgICAqIFdlYlZpZXcv V2ViVmlldy5tbToKKyAgICAgICAgKC1bV2ViVmlldyBfc2V0VmFsdWVGb3JVc2VyOmZvckVsZW1l bnQ6d2l0aFZhbHVlOl0pOiBFeHBvc2UgSFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWVGb3JVc2Vy KCkgdG8gdGVzdHMKKyAgICAgICAgKiBXZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oOgorICAgICAg ICAqIFdlYlZpZXcvV2ViVmlld1ByaXZhdGUuaDoKKwogMjAxMS0wMi0yNSBTdGV2ZSBCbG9jayA8 c3RldmVibG9ja0Bnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEplcmVteSBPcmxv dy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbSBiL1Nv dXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5tbQppbmRleCA4ZmIwNmQ2NjQ0ZTc5Y2Rl ZTBlNWJmYzFhZWNjYTkyMzM2NDcwNTcwLi5jMGY5NDdhMDE1ZDU3YmNlYjJkYTE1Njk0NjI2OTY2 NWE1MmZkMjhlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcu bW0KKysrIGIvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCkBAIC0xMDcsNiAr MTA3LDcgQEAKICNpbXBvcnQgPEZvdW5kYXRpb24vTlNVUkxDb25uZWN0aW9uLmg+CiAjaW1wb3J0 IDxKYXZhU2NyaXB0Q29yZS9BUElDYXN0Lmg+CiAjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9KU1Zh bHVlUmVmLmg+CisjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9PcGFxdWVKU1N0cmluZy5oPgogI2lt cG9ydCA8V2ViQ29yZS9BYnN0cmFjdERhdGFiYXNlLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0FwcGxp Y2F0aW9uQ2FjaGVTdG9yYWdlLmg+CiAjaW1wb3J0IDxXZWJDb3JlL0JhY2tGb3J3YXJkTGlzdElt cGwuaD4KQEAgLTEzMSw2ICsxMzIsNyBAQAogI2ltcG9ydCA8V2ViQ29yZS9IVE1MTmFtZXMuaD4K ICNpbXBvcnQgPFdlYkNvcmUvSGlzdG9yeUl0ZW0uaD4KICNpbXBvcnQgPFdlYkNvcmUvSWNvbkRh dGFiYXNlLmg+CisjaW1wb3J0IDxXZWJDb3JlL0lucHV0RWxlbWVudC5oPgogI2ltcG9ydCA8V2Vi Q29yZS9KU0NTU1N0eWxlRGVjbGFyYXRpb24uaD4KICNpbXBvcnQgPFdlYkNvcmUvSlNEb2N1bWVu dC5oPgogI2ltcG9ydCA8V2ViQ29yZS9KU0VsZW1lbnQuaD4KQEAgLTYyNDcsNiArNjI0OSwzNSBA QCBzdGF0aWMgdm9pZCBnbGliQ29udGV4dEl0ZXJhdGlvbkNhbGxiYWNrKENGUnVuTG9vcE9ic2Vy dmVyUmVmLCBDRlJ1bkxvb3BBY3Rpdml0eQogCiBAZW5kCiAKK0BpbXBsZW1lbnRhdGlvbiBXZWJW aWV3IChXZWJWaWV3UHJpdmF0ZVNldFZhbHVlRm9yVXNlcikKKworLSAodm9pZClfc2V0VmFsdWVG b3JVc2VyOihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JFbGVtZW50OihKU1ZhbHVlUmVmKWVsZW1l bnQgd2l0aFZhbHVlOihKU1ZhbHVlUmVmKXZhbHVlCit7CisgICAgaWYgKCFlbGVtZW50IHx8ICF2 YWx1ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgSlNMb2NrIGxvY2soU2lsZW5jZUFzc2VydGlv bnNPbmx5KTsKKyAgICBFeGVjU3RhdGUqIGV4ZWMgPSB0b0pTKGNvbnRleHQpOworICAgIEpTVmFs dWUganNFbGVtZW50VmFsdWUgPSB0b0pTKGV4ZWMsIGVsZW1lbnQpOworICAgIGlmICghanNFbGVt ZW50VmFsdWUuaW5oZXJpdHMoJkpTRWxlbWVudDo6c19pbmZvKSkKKyAgICAgICAgcmV0dXJuOwor ICAgIEpTRWxlbWVudCoganNFbGVtZW50ID0gc3RhdGljX2Nhc3Q8SlNFbGVtZW50Kj4oYXNPYmpl Y3QoanNFbGVtZW50VmFsdWUpKTsKKyAgICBFbGVtZW50KiB3ZWJjb3JlRWxlbWVudCA9IGpzRWxl bWVudC0+aW1wbCgpOworICAgIElucHV0RWxlbWVudCogaW5wdXRFbGVtZW50ID0gdG9JbnB1dEVs ZW1lbnQod2ViY29yZUVsZW1lbnQpOworICAgIGlmICghaW5wdXRFbGVtZW50KQorICAgICAgICBy ZXR1cm47CisKKyAgICBpZiAoIUpTVmFsdWVJc1N0cmluZyhjb250ZXh0LCB2YWx1ZSkpCisgICAg ICAgIHJldHVybjsKKyAgICBKU1N0cmluZ1JlZiBqc1N0cmluZ1ZhbHVlID0gSlNWYWx1ZVRvU3Ry aW5nQ29weShjb250ZXh0LCB2YWx1ZSwgTlVMTCk7CisgICAgU3RyaW5nIHN0cmluZ1ZhbHVlKGpz U3RyaW5nVmFsdWUtPmNoYXJhY3RlcnMoKSwganNTdHJpbmdWYWx1ZS0+bGVuZ3RoKCkpOworCisg ICAgaW5wdXRFbGVtZW50LT5zZXRWYWx1ZUZvclVzZXIoc3RyaW5nVmFsdWUpOworICAgIHJldHVy bjsKK30KKworQGVuZAorCiBAaW1wbGVtZW50YXRpb24gV2ViVmlldyAoV2ViVmlld1ByaXZhdGVO b2Rlc0Zyb21SZWN0KQogCiAtIChKU1ZhbHVlUmVmKV9ub2Rlc0Zyb21SZWN0OihKU0NvbnRleHRS ZWYpY29udGV4dCBmb3JEb2N1bWVudDooSlNWYWx1ZVJlZil2YWx1ZSB4OihpbnQpeCAgeTooaW50 KXkgdG9wOih1bnNpZ25lZCl0b3AgcmlnaHQ6KHVuc2lnbmVkKXJpZ2h0IGJvdHRvbToodW5zaWdu ZWQpYm90dG9tIGxlZnQ6KHVuc2lnbmVkKWxlZnQgaWdub3JlQ2xpcHBpbmc6KEJPT0wpaWdub3Jl Q2xpcHBpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0lu dGVybmFsLmggYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oCmlu ZGV4IDU1NWM0ZDExMGVkMGJmYzljZmI2NWRjOTYyZjBiMjgxMTA5NzI3ODcuLmEyMzEwMjQ1YWQ5 YjBkNDI3Y2NkZjUzOTJjZGY2NDUwMjk4MmI0YzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv bWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmgKKysrIGIvU291cmNlL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJWaWV3SW50ZXJuYWwuaApAQCAtMTk0LDYgKzE5NCw0IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKIC0gKHZvaWQpX2Z1bGxTY3JlZW5SZW5kZXJlckNoYW5nZWQ6KFdlYkNvcmU6OlJlbmRl ckJveCopcmVuZGVyZXI7CiAjZW5kaWYKIAotLSAoSlNWYWx1ZVJlZilfY29tcHV0ZWRTdHlsZUlu Y2x1ZGluZ1Zpc2l0ZWRJbmZvOihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JFbGVtZW50OihKU1Zh bHVlUmVmKXZhbHVlOwotCiBAZW5kCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJW aWV3L1dlYlZpZXdQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQ cml2YXRlLmgKaW5kZXggYTRlYTgwOWIwMDFkYmM2YTY3MjM0ZjE3MmYwMjBiYzM0Y2Y3ZTg0Yy4u OGM0YWY4NDljYTY3YTFlYTFmZTZkYWUwYjI2YmQwNzg0YjdlYzVhMiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJL aXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaApAQCAtNjc3LDYgKzY3NywxMCBAQCBDb3Vs ZCBiZSB3b3J0aCBhZGRpbmcgdG8gdGhlIEFQSS4KIC0gKEpTVmFsdWVSZWYpX2NvbXB1dGVkU3R5 bGVJbmNsdWRpbmdWaXNpdGVkSW5mbzooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRWxlbWVudDoo SlNWYWx1ZVJlZil2YWx1ZTsKIEBlbmQKIAorQGludGVyZmFjZSBXZWJWaWV3IChXZWJWaWV3UHJp dmF0ZVNldFZhbHVlRm9yVXNlcikKKy0gKHZvaWQpX3NldFZhbHVlRm9yVXNlcjooSlNDb250ZXh0 UmVmKWNvbnRleHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZillbGVtZW50IHdpdGhWYWx1ZTooSlNW YWx1ZVJlZil2YWx1ZTsKK0BlbmQKKwogQGludGVyZmFjZSBXZWJWaWV3IChXZWJWaWV3UHJpdmF0 ZU5vZGVzRnJvbVJlY3QpCiAtIChKU1ZhbHVlUmVmKV9ub2Rlc0Zyb21SZWN0OihKU0NvbnRleHRS ZWYpY29udGV4dCBmb3JEb2N1bWVudDooSlNWYWx1ZVJlZil2YWx1ZSB4OihpbnQpeCAgeTooaW50 KXkgdG9wOih1bnNpZ25lZCl0b3AgcmlnaHQ6KHVuc2lnbmVkKXJpZ2h0IGJvdHRvbToodW5zaWdu ZWQpYm90dG9tIGxlZnQ6KHVuc2lnbmVkKWxlZnQgaWdub3JlQ2xpcHBpbmc6KEJPT0wpaWdub3Jl Q2xpcHBpbmc7CiBAZW5kCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFu Z2VMb2cKaW5kZXggYTJmMTM5NDI5NjQ4Nzg1N2RkNTA0ZDM2MzE3Mjc4MWY3MDQ4NGJkNC4uNmVi NmJhMjFlOTc4ZDFjNjg5MmJhYjI0NTM4ZWNkZDk3MDE2ZTJiOSAxMDA2NDQKLS0tIGEvVG9vbHMv Q2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDExLTAz LTAyICBJbHlhIFNoZXJtYW4gIDxpc2hlcm1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSFRNTElucHV0RWxlbWVudDo6c2V0 VmFsdWUoKSBzaG91bGQgc2NoZWR1bGUgY2hhbmdlIGV2ZW50IHdoZW4gdGhlIGVsZW1lbnQgaXMg Zm9jdXNlZAorICAgICAgICBJbiBzZXJ2aWNlIG9mIGh0dHBzOi8vY29kZS5nb29nbGUuY29tL3Av Y2hyb21pdW0vaXNzdWVzL2RldGFpbD9pZD00MjcxNgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTMxNjAKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKHNldFZhbHVlRm9yVXNlckNhbGxi YWNrKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMpOgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoKKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIpOiBTdHViYmVkIG91dDsg bmVlZCByZWFsIGltcGxlbWVudGF0aW9uLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9M YXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy OjpzZXRWYWx1ZUZvclVzZXIpOiBFeHBvc2UgSFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWVGb3JV c2VyKCkgdG8gdGVzdHMKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29u dHJvbGxlclF0LmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZv clVzZXIpOiBTdHViYmVkIG91dDsgbmVlZCByZWFsIGltcGxlbWVudGF0aW9uLgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHA6CisgICAgICAg IChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5l ZWQgcmVhbCBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93eC9MYXlv dXRUZXN0Q29udHJvbGxlcld4LmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpz ZXRWYWx1ZUZvclVzZXIpOiBTdHViYmVkIG91dDsgbmVlZCByZWFsIGltcGxlbWVudGF0aW9uLgor CiAyMDExLTAzLTAxICBBZGFtIFJvYmVuICA8YXJvYmVuQGFwcGxlLmNvbT4KIAogICAgICAgICBU ZXN0IHRoYXQgdGhlIFdlYktpdDIgcmVzcG9uc2l2ZW5lc3MgdGltZXIgZG9lc24ndCBmaXJlIHRv byBlYXJseQpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CmluZGV4IDQxNmI5ZmNiMTA4NWZlMWNkNDgzZmRkOTJjNjZkNGI1ZGJhODY4NmQuLjhkOGViYzM2 MzZjOWZiZTVhMjViMTY2ZjRiZTMzZDA1YmYzNjNhMWIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBS ZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVy VHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAgLTE0MzIsNiArMTQzMiwxOCBAQCBzdGF0 aWMgSlNWYWx1ZVJlZiBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uQ2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQsIEpTT2JqZQogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250 ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgc2V0VmFsdWVGb3JVc2VyQ2FsbGJhY2soSlND b250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlz T2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNb XSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQoreworICAgIC8vIEhhcyBtYWMgaW1wbGVtZW50YXRp b24KKyAgICBpZiAoYXJndW1lbnRDb3VudCAhPSAyKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1h a2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJv bGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2 YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5zZXRWYWx1ZUZvclVzZXIoY29udGV4 dCwgYXJndW1lbnRzWzBdLCBhcmd1bWVudHNbMV0pOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtl VW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJlZiBzZXRWaWV3TW9kZU1l ZGlhRmVhdHVyZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5j dGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0 IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKIHsKICAgICAv LyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCkBAIC0yMTI5LDYgKzIxNDEsNyBAQCBKU1N0YXRpY0Z1 bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAg eyAic2V0VXNlRGFzaGJvYXJkQ29tcGF0aWJpbGl0eU1vZGUiLCBzZXRVc2VEYXNoYm9hcmRDb21w YXRpYmlsaXR5TW9kZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pT UHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNldFVzZXJTdHlsZVNo ZWV0RW5hYmxlZCIsIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZENhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAg ICAgICAgIHsgInNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24iLCBzZXRVc2VyU3R5bGVTaGVldExv Y2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAic2V0VmFsdWVGb3JVc2VyIiwgc2V0 VmFsdWVGb3JVc2VyQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZSIsIHNldFZpZXdNb2RlTWVkaWFGZWF0 dXJlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0V2ViVmlld0VkaXRhYmxlIiwgc2V0 V2ViVmlld0VkaXRhYmxlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0V2lsbFNlbmRS ZXF1ZXN0Q2xlYXJIZWFkZXIiLCBzZXRXaWxsU2VuZFJlcXVlc3RDbGVhckhlYWRlckNhbGxiYWNr LCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250 RGVsZXRlIH0sCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaApp bmRleCA4YTIwNTAwNTkxZTFhNDljN2JmYTFiMzRiZjc3MjhiZjUxNjEwYjk1Li5mYTljZmYyOGQ0 MjIyNTMyY2Y2YjBkNTZiZDE2YTg3Mzk5ZGRiYTZjIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTExMSw2ICsxMTEsNyBAQCBwdWJsaWM6CiAgICAg dm9pZCBzZXRVc2VEYXNoYm9hcmRDb21wYXRpYmlsaXR5TW9kZShib29sIGZsYWcpOwogICAgIHZv aWQgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBzZXRVc2Vy U3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOworICAgIHZvaWQgc2V0VmFsdWVG b3JVc2VyKEpTQ29udGV4dFJlZiwgSlNWYWx1ZVJlZiBlbGVtZW50LCBKU1ZhbHVlUmVmIHVzZXJW YWx1ZSk7CiAgICAgdm9pZCBzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2Rl KTsKICAgICB2b2lkIHNldFhTU0F1ZGl0b3JFbmFibGVkKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBz ZXRGcmFtZUZsYXR0ZW5pbmdFbmFibGVkKGJvb2wgZW5hYmxlKTsKZGlmZiAtLWdpdCBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAgYi9Ub29scy9E dW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwCmluZGV4IDBiYmFi ODY3ZWZiMDA1MzQzZWRhZTk5OTg5NjJjNGI0OThkZmZmNmEuLmU5Yjg0ZmE1ZTI4N2VlZTc4MDBl ZTM1M2I1MTYzOTQ2OTdmY2I1ODMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0 ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUv Z3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcApAQCAtMzMzLDYgKzMzMywxMSBAQCB2b2lk IExheW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5n UmVmIHBhdGgpCiAgICAgICAgIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZCh0cnVlKTsKIH0KIAor dm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKEpTQ29udGV4dFJlZiBj b250ZXh0LCBKU1ZhbHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVSZWYgdmFsdWUpCit7CisgICAgLy8g RklYTUU6IGltcGxlbWVudAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3 TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIFdlYktpdFdlYlZpZXcq IHZpZXcgPSB3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhtYWluRnJhbWUpOwpkaWZmIC0t Z2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1t IGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmlu ZGV4IGJjOWRiYjdjODI4OWMyYzMzMWZlYThkMWYxZjVhNjBlMDYxYWQxM2MuLmExMjU3OWJmNzcy Y2I4MzMwODA1N2ZjMDBkNDE4MjllZGJlYjhjZmYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQorKysgYi9Ub29scy9EdW1wUmVu ZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTQ3OSw2ICs0NzksMTEg QEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihK U1N0cmluZ1JlZiBwYXRoKQogICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNl c10gc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVS ZWYgZWxlbWVudCwgSlNWYWx1ZVJlZiB2YWx1ZSkKK3sKKyAgICBbW21haW5GcmFtZSB3ZWJWaWV3 XSBfc2V0VmFsdWVGb3JVc2VyOmNvbnRleHQgZm9yRWxlbWVudDplbGVtZW50IHdpdGhWYWx1ZTp2 YWx1ZV07Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZpZXdNb2RlTWVkaWFG ZWF0dXJlKEpTU3RyaW5nUmVmIG1vZGUpCiB7CiAgICAgLy8gRklYTUU6IGltcGxlbWVudApkaWZm IC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2lu LmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5j cHAKaW5kZXggODA4NjJlYjIxYjZiN2IxZjVjOTZmNWE5OTczZDA4MGI0MzBjZjNiZS4uNmRhNjJk N2IxZWY5Zjg4YjIwYmU5YjU5ZmI0MDQ0NmM3NTk5OWY3ZSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAorKysgYi9Ub29scy9E dW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCkBAIC03NTUsNiAr NzU1LDExIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFVzZXJTdHlsZVNoZWV0TG9j YXRpb24oSlNTdHJpbmdSZWYganNVUkwpCiAgICAgU3lzRnJlZVN0cmluZyhyZXN1bHRQYXRoQlNU Uik7CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcihKU0Nv bnRleHRSZWYgY29udGV4dCwgSlNWYWx1ZVJlZiBlbGVtZW50LCBKU1ZhbHVlUmVmIHZhbHVlKQor eworICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxl cjo6c2V0Vmlld01vZGVNZWRpYUZlYXR1cmUoSlNTdHJpbmdSZWYgbW9kZSkKIHsKICAgICAvLyBG SVhNRTogaW1wbGVtZW50CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS93eC9MYXlv dXRUZXN0Q29udHJvbGxlcld4LmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRl c3RDb250cm9sbGVyV3guY3BwCmluZGV4IDEwZTExMDcxMTZiZDRjNjMwMWU2NDFjZWRjN2EzZjEz YTZmNGM2ZmEuLjcwNjZmZGMwNWQ0YzcyYTAzZjM1ZWYzYmI4YjFkZjYxYTg4MjExOWEgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRlc3RDb250cm9sbGVyV3guY3Bw CisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRlc3RDb250cm9sbGVyV3guY3Bw CkBAIC0xMzUsNiArMTM1LDExIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFVzZXJT dHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCkKIHsKIH0KIAordm9pZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU1Zh bHVlUmVmIGVsZW1lbnQsIEpTVmFsdWVSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6IGltcGxl bWVudAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVh dHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQK 84715 2011-03-04 02:57:08 -0800 2011-03-04 16:26:36 -0800 Patch bug-53160-20110304025707.patch text/plain 35784 isherman ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4ZTRiYzBjYTFlMDc1MGUyMjAyZWUzMjllZGRjNDgyY2U5YzM5YjRhLi4yNGQ2YjQy YjFjMjA4MDYxOTA2NDQxYjI3MmM1ZmQ1YjljNTU4MTUyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDMtMDIgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVt ZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxl bWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2ds ZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgICogZmFzdC9m b3Jtcy9vbmNoYW5nZS1jaGFuZ2UtdHlwZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5cGUuaHRtbDogQWRkZWQuCisgICAgICAgICog ZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sOiBBZGRl ZC4KKwogMjAxMS0wMy0wMiAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4K IAogICAgICAgICBVbnJldmlld2VkIENocm9taXVtIFNub3cgTGVvcGFyZCBiYXNlbGluZSB1cGRh dGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5 cGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1jaGFuZ2Ut dHlwZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTg2Zjg3ZjE5OWQwNDI3NGQxMzYyMjA2NmM5 M2E0MDU2Y2MxODQwNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMv b25jaGFuZ2UtY2hhbmdlLXR5cGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGhpcyB0 ZXN0cyB0aGF0IG9uY2hhbmdlIGlzIG5vdCBmaXJlZCBhZnRlciBhIGZvcm0gZmllbGQncyB0eXBl IGNoYW5nZXMuCisKK1Nob3VsZCBmaXJlIGNoYW5nZSBldmVudCB3aGVuIHR5cGUgZG9lcyBub3Qg Y2hhbmdlLgorUEFTUyB0cnVlIGlzIHRydWUKK1Nob3VsZCAqbm90KiBmaXJlIGNoYW5nZSBldmVu dCB3aGVuIHR5cGUgZG9lcyBub3QgY2hhbmdlLgorUEFTUyBmYWxzZSBpcyBmYWxzZQorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLWNoYW5nZS10eXBlLmh0bWwg Yi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLWNoYW5nZS10eXBlLmh0bWwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uMWQ1ZGJmZDdjZTZlMmY5ODVmZWIzYmJlMGE0YTdhMmI0YjBmNWE4OQotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5cGUuaHRt bApAQCAtMCwwICsxLDQ4IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQgc3JjPSIuLi9q cy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQ+CisgICAg ZnVuY3Rpb24gc2VuZFRleHQoZWxlbWVudCwgdGV4dCkgeworICAgICAgICB2YXIgZXZlbnQgPSBk b2N1bWVudC5jcmVhdGVFdmVudCgnVGV4dEV2ZW50Jyk7CisgICAgICAgIGV2ZW50LmluaXRUZXh0 RXZlbnQoJ3RleHRJbnB1dCcsIHRydWUsIHRydWUsIGRvY3VtZW50LmRlZmF1bHRWaWV3LCB0ZXh0 KTsKKyAgICAgICAgZWxlbWVudC5kaXNwYXRjaEV2ZW50KGV2ZW50KTsKKyAgICB9CisKKyAgICBm dW5jdGlvbiB0ZXN0KCkgeworICAgICAgICB2YXIgdGYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgndGYnKTsKKworICAgICAgICB2YXIgZGlkRmlyZU9uQ2hhbmdlID0gZmFsc2U7CisgICAgICAg IHRmLm9uY2hhbmdlID0gZnVuY3Rpb24oKSB7CisgICAgICAgICAgZGlkRmlyZU9uQ2hhbmdlID0g dHJ1ZTsKKyAgICAgICAgfQorCisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAg ICAgICAgfQorCisgICAgICAgIHRmLmZvY3VzKCk7CisgICAgICAgIHNlbmRUZXh0KHRmLCAnaW5w dXQgdmFsdWUnKTsKKyAgICAgICAgdGYuYmx1cigpOworCisgICAgICAgIGRlYnVnKCdTaG91bGQg ZmlyZSBjaGFuZ2UgZXZlbnQgd2hlbiB0eXBlIGRvZXMgbm90IGNoYW5nZS4nKTsKKyAgICAgICAg c2hvdWxkQmVUcnVlKGRpZEZpcmVPbkNoYW5nZS50b1N0cmluZygpKTsKKworICAgICAgICBkaWRG aXJlT25DaGFuZ2UgPSBmYWxzZTsKKyAgICAgICAgdGYuZm9jdXMoKTsKKyAgICAgICAgc2VuZFRl eHQodGYsICduZXcgaW5wdXQgdmFsdWUnKTsKKyAgICAgICAgdGYuc2V0QXR0cmlidXRlKCd0eXBl JywgJ3Bhc3N3b3JkJyk7CisgICAgICAgIHRmLmJsdXIoKTsKKworICAgICAgICBkZWJ1ZygnU2hv dWxkICpub3QqIGZpcmUgY2hhbmdlIGV2ZW50IHdoZW4gdHlwZSBkb2VzIG5vdCBjaGFuZ2UuJyk7 CisgICAgICAgIHNob3VsZEJlRmFsc2UoZGlkRmlyZU9uQ2hhbmdlLnRvU3RyaW5nKCkpOworICAg IH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0idGVzdCgpIj4KKyAgICBU aGlzIHRlc3RzIHRoYXQgb25jaGFuZ2UgaXMgbm90IGZpcmVkIGFmdGVyIGEgZm9ybSBmaWVsZCdz IHR5cGUgY2hhbmdlcy48YnI+CisgICAgPGZvcm0gbmFtZT0iZm0iPgorICAgICAgICA8aW5wdXQg dHlwZT0idGV4dCIgaWQ9InRmIiAvPgorICAgIDwvZm9ybT4KKyAgICA8ZGl2IGlkPSJjb25zb2xl Ij48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv Zm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLWV4cGVjdGVkLnR4dApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5iYzYzYTFkZDM4NmUxMGM4ZmE1NWNmNzQ4NmMwYjAxMDAwOWMwZWYwCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAorVGhpcyB0ZXN0cyB0aGF0IG9uY2hhbmdlIGNv cnJlY3RseSBmaXJlcyBhZnRlciBjYWxsaW5nIHNldFZhbHVlRm9yVXNlcigpLiBJdCBjYW4gb25s eSBiZSBydW4gdXNpbmcgRHVtcFJlbmRlclRyZWUuCisKK1BBU1MgCisKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwgYi9MYXlv dXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjRkYmI4Zjc5ZTA3NjY2MzQyYTFhZTZhMzc5YjI3Nzg2ZjQ1NTQ1M2MKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5o dG1sCkBAIC0wLDAgKzEsNDQgQEAKKzxodG1sPgorPGhlYWQ+CisgICAgPHNjcmlwdCBzcmM9Ii4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdD4KKyAg ICBmdW5jdGlvbiB0ZXN0KCkgeworICAgICAgICB2YXIgdGYgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgndGYnKTsKKworICAgICAgICB2YXIgZGlkRmlyZU9uQ2hhbmdlID0gZmFsc2U7CisgICAg ICAgIHRmLm9uY2hhbmdlID0gZnVuY3Rpb24oKSB7CisgICAgICAgICAgZGlkRmlyZU9uQ2hhbmdl ID0gdHJ1ZTsKKyAgICAgICAgfQorCisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK KyAgICAgICAgfQorCisgICAgICAgIHRmLmZvY3VzKCk7CisgICAgICAgIGlmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLnNl dFZhbHVlRm9yVXNlcih0ZiwgJ0hlbGxvIScpOworICAgICAgICB9CisKKyAgICAgICAgLy8gU2hv dWxkIG5vdCBmaXJlIHRoZSBldmVudCB1bnRpbCBmb2N1cyBpcyBsb3N0LgorICAgICAgICBpZiAo ZGlkRmlyZU9uQ2hhbmdlKSB7CisgICAgICAgICAgICB0ZXN0RmFpbGVkKCdvbmNoYW5nZSBmaXJl ZCB0b28gZWFybHknKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAg IHRmLmJsdXIoKTsKKyAgICAgICAgaWYgKGRpZEZpcmVPbkNoYW5nZSkgeworICAgICAgICAgICAg dGVzdFBhc3NlZCgnJyk7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICB0ZXN0RmFpbGVk KCdvbmNoYW5nZSBuZXZlciBmaXJlZCcpCisgICAgICAgIH0KKyAgICB9CisgICAgPC9zY3JpcHQ+ Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgVGhpcyB0ZXN0cyB0aGF0IG9u Y2hhbmdlIGNvcnJlY3RseSBmaXJlcyBhZnRlciBjYWxsaW5nIHNldFZhbHVlRm9yVXNlcigpLiAg SXQgY2FuIG9ubHkgYmUgcnVuIHVzaW5nIER1bXBSZW5kZXJUcmVlLjxicj4KKyAgICA8Zm9ybSBu YW1lPSJmbSI+CisgICAgICAgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0idGYiIC8+CisgICAgPC9m b3JtPgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCmluZGV4IDA1ZTgzNTY5MTdkODgxZDQ1YTU3MmM1ZDMxYmRlZDI0NzA2MWJhNWIuLmU3MDJl M2QwOWNkNzY5MDk4OTIzMGFlZjYxMmU4NWViYTAxYTNjN2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSw1MSBAQAorMjAxMS0wMy0wMiAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhUTUxJ bnB1dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBldmVudCB3aGVu IHRoZSBlbGVtZW50IGlzIGZvY3VzZWQuCisgICAgICAgIFJlZmFjdG9yZWQgdHJhY2tpbmcgb2Yg ImNoYW5nZWQgc2luY2UgbGFzdCBjaGFuZ2UgZXZlbnQiIHN0YXRlIGZyb20gcmVuZGVyZXIgdG8g RE9NLkluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1 ZXMKKyAgICAgICAgSW4gc2VydmljZSBvZiBodHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9t aXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy9vbmNo YW5nZS1jaGFuZ2UtdHlwZS5odG1sCisgICAgICAgIFRlc3Q6IGZhc3QvZm9ybXMvb25jaGFuZ2Ut c2V0dmFsdWVmb3J1c2VyLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUuZXhwLmluOgorICAgICAg ICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6c2V0Rm9j dXNlZE5vZGUpOgorICAgICAgICAqIGRvbS9FbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpF bGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6RWxlbWVudDo6c2V0Q2hhbmdlZFNpbmNlTGFzdEZvcm1Db250 cm9sQ2hhbmdlRXZlbnQpOiBBZGRlZC4KKyAgICAgICAgKiBodG1sL0hUTUxGb3JtQ29udHJvbEVs ZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6SFRN TEZvcm1Db250cm9sRWxlbWVudCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRm9ybUNvbnRyb2xF bGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6c2V0Q2hhbmdlZFNp bmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OmRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6 IEFsc28gY2xlYXIgdGhlICJjaGFuZ2VkIHNpbmNlIGxhc3QgY2hhbmdlIGV2ZW50IiBmbGFnLgor ICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0Y2hGb3JtQ29u dHJvbElucHV0RXZlbnQpOiBBbHNvIHNldCB0aGUgImNoYW5nZWQgc2luY2UgbGFzdCBjaGFuZ2Ug ZXZlbnQiIGZsYWcuCisgICAgICAgICogaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50Lmg6Cisg ICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxJbnB1dEVsZW1lbnQ6OnVwZGF0ZVR5cGUpOiBBbHNvIGNsZWFyIHRoZSAiY2hhbmdlZCBzaW5j ZSBsYXN0IGNoYW5nZSBldmVudCIgZmxhZy4KKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVs ZW1lbnQ6OnNldFZhbHVlKToKKyAgICAgICAgICAgIEZvciBhIGZvY3VzZWQgdGV4dCBmaWVsZCwg ZGlzcGF0Y2ggYW4gaW5wdXQgZXZlbnQsIGJ1dCBkZWxheSB0aGUgY2hhbmdlIGV2ZW50IHVudGls IHRoZSBmaWVsZCBsb3NlcyBmb2N1cy4KKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1l bnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxl bWVudDo6c3RlcFVwRnJvbVJlbmRlcmVyKToKKyAgICAgICAgKiBodG1sL3NoYWRvdy9UZXh0Q29u dHJvbElubmVyRWxlbWVudHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2VhcmNoRmllbGRDYW5j ZWxCdXR0b25FbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKToKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVyVGV4dENvbnRyb2wuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyVGV4dENv bnRyb2w6OlJlbmRlclRleHRDb250cm9sKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclRleHRD b250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdlZCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRl eHRDb250cm9sLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sTXVsdGlM aW5lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclRleHRDb250cm9sTXVsdGlMaW5lOjpz dWJ0cmVlSGFzQ2hhbmdlZCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9s U2luZ2xlTGluZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJUZXh0Q29udHJvbFNpbmds ZUxpbmU6OnN1YnRyZWVIYXNDaGFuZ2VkKToKKyAgICAgICAgKiB3bWwvV01MSW5wdXRFbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6V01MSW5wdXRFbGVtZW50 KToKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxl cik6CisgICAgICAgICogd21sL1dNTElucHV0RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6 V01MSW5wdXRFbGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVu dCk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVtZW50OjpzZXRDaGFuZ2Vk U2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6IEFkZGVkLgorCiAyMDExLTAzLTAyICBN T1JJVEEgSGFqaW1lICA8bW9ycml0YUBnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEtlbnQgVGFtdXJhLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4g Yi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCA0MGYxNmNlOThjZWQyMjRmYTY4 NGE3NTA4NjQwYmU0ZTg1YjVkODAwLi4yODViMTA2M2NkZTRlODhiMDA5NjQ3MDZlZjBkMDYyNTJl MTY4MGE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgorKysgYi9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgpAQCAtMzYzLDYgKzM2Myw3IEBAIF9fWk43V2Vi Q29yZTE0U2VjdXJpdHlPcmlnaW4zMnJlbW92ZU9yaWdpbkFjY2Vzc1doaXRlbGlzdEVudHJ5RVJL UzBfUktOM1dURjZTdHJpCiBfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luNDBzZXREb21haW5S ZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJMU2NoZW1lRWJSS04zV1RGNlN0cmluZ0UKIF9fWk43V2Vi Q29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTjNXVEY2U3RyaW5nRVM0X2kKIF9fWk43V2Vi Q29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFaQorX19aTjdXZWJDb3JlMTR0 b0lucHV0RWxlbWVudEVQTlNfN0VsZW1lbnRFCiBfX1pON1dlYkNvcmUxNUFyY2hpdmVSZXNvdXJj ZTZjcmVhdGVFTjNXVEYxMFBhc3NSZWZQdHJJTlNfMTJTaGFyZWRCdWZmZXJFRUVSS05TXzRLVVJM RVJLTlMxXzZTdHJpbmdFU0FfU0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VFCiBfX1pON1dlYkNv cmUxNURPTVdyYXBwZXJXb3JsZDEzY2xlYXJXcmFwcGVyc0V2CiBfX1pON1dlYkNvcmUxNURPTVdy YXBwZXJXb3JsZEQxRXYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IGY0NWQ2Y2ZjOWIwMGYy Y2YwMDQ3YzBlZjM4YWNkODgzY2VkNDcyZDAuLjg1NWE3OTIxYmVmOTJlMWJkYWI4ZDhmNGFjNDI2 NTIxZmJmZDcwYzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcApAQCAtMzE4MywxMiArMzE4Mywx MCBAQCBib29sIERvY3VtZW50OjpzZXRGb2N1c2VkTm9kZShQYXNzUmVmUHRyPE5vZGU+IG5ld0Zv Y3VzZWROb2RlKQogICAgICAgICBvbGRGb2N1c2VkTm9kZS0+c2V0Rm9jdXMoZmFsc2UpOwogCiAg ICAgICAgIC8vIERpc3BhdGNoIGEgY2hhbmdlIGV2ZW50IGZvciB0ZXh0IGZpZWxkcyBvciB0ZXh0 YXJlYXMgdGhhdCBoYXZlIGJlZW4gZWRpdGVkCi0gICAgICAgIFJlbmRlck9iamVjdCogciA9IG9s ZEZvY3VzZWROb2RlLT5yZW5kZXJlcigpOwotICAgICAgICBpZiAociAmJiByLT5pc1RleHRDb250 cm9sKCkgJiYgdG9SZW5kZXJUZXh0Q29udHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5n ZUV2ZW50KCkpIHsKLSAgICAgICAgICAgIHN0YXRpY19jYXN0PEVsZW1lbnQqPihvbGRGb2N1c2Vk Tm9kZS5nZXQoKSktPmRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAgICAgICAg ICAgciA9IG9sZEZvY3VzZWROb2RlLT5yZW5kZXJlcigpOwotICAgICAgICAgICAgaWYgKHIgJiYg ci0+aXNUZXh0Q29udHJvbCgpKQotICAgICAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wo ciktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudChmYWxzZSk7CisgICAgICAgIGlmIChv bGRGb2N1c2VkTm9kZS0+aXNFbGVtZW50Tm9kZSgpKSB7CisgICAgICAgICAgICBFbGVtZW50KiBl bGVtZW50ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG9sZEZvY3VzZWROb2RlLmdldCgpKTsKKyAg ICAgICAgICAgIGlmIChlbGVtZW50LT53YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFu Z2VFdmVudCgpKQorICAgICAgICAgICAgICAgIGVsZW1lbnQtPmRpc3BhdGNoRm9ybUNvbnRyb2xD aGFuZ2VFdmVudCgpOwogICAgICAgICB9CiAKICAgICAgICAgLy8gRGlzcGF0Y2ggdGhlIGJsdXIg ZXZlbnQgYW5kIGxldCB0aGUgbm9kZSBkbyBhbnkgb3RoZXIgYmx1ciByZWxhdGVkIGFjdGl2aXRp ZXMgKGltcG9ydGFudCBmb3IgdGV4dCBmaWVsZHMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9kb20vRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAKaW5kZXgg YWFiMDhlODdhYmY5ODY4ZmJhMDJmZDgyZmViNmQzYWIzZGY3NDZkZS4uYjljYjNhZGRkNjZjMTVl MTNiZDQ4MjkyMTFlZmZlNjYzZjJkZjg4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9t L0VsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmNwcApAQCAtODg4 LDYgKzg4OCwxNCBAQCBSZW5kZXJPYmplY3QqIEVsZW1lbnQ6OmNyZWF0ZVJlbmRlcmVyKFJlbmRl ckFyZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqIHN0eWxlKQogICAgIHJldHVybiBSZW5kZXJPYmpl Y3Q6OmNyZWF0ZU9iamVjdCh0aGlzLCBzdHlsZSk7CiB9CiAKK2Jvb2wgRWxlbWVudDo6d2FzQ2hh bmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoKSBjb25zdAoreworICAgIHJldHVy biBmYWxzZTsKK30KKwordm9pZCBFbGVtZW50OjpzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRy b2xDaGFuZ2VFdmVudChib29sKQoreworfQogCiB2b2lkIEVsZW1lbnQ6Omluc2VydGVkSW50b0Rv Y3VtZW50KCkKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmggYi9T b3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5oCmluZGV4IDc1MWU3ZTkzNjIyYzQ5MDY3MjMxMzU5 ZDQyZDNlN2E5ZmNmNzk2NmEuLmY3OTYzNTM2YmY5ZjA1YjBmZDQzMjJjZTFiMjg5YzRhMWFkZjRh NDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmgKKysrIGIvU291cmNl L1dlYkNvcmUvZG9tL0VsZW1lbnQuaApAQCAtMzI2LDYgKzMyNiw4IEBAIHB1YmxpYzoKICAgICB2 aXJ0dWFsIGJvb2wgc2F2ZUZvcm1Db250cm9sU3RhdGUoU3RyaW5nJikgY29uc3QgeyByZXR1cm4g ZmFsc2U7IH0KICAgICB2aXJ0dWFsIHZvaWQgcmVzdG9yZUZvcm1Db250cm9sU3RhdGUoY29uc3Qg U3RyaW5nJikgeyB9CiAKKyAgICB2aXJ0dWFsIGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdEZvcm1D b250cm9sQ2hhbmdlRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0Q2hhbmdlZFNp bmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lkIGRp c3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpIHsgfQogCiAjaWYgRU5BQkxFKFNWRykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCmluZGV4IDU4 ZWM1NTQwYjY3MjIxYzM3Y2MyNDYyODg5YmVmMzg4NjFiYmFiMTMuLmRiMzRlYzFkODM5MjkzYjI4 ZDRkOWQ4OTY3OTY0ZTdhNjQ5ODRhMjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M Rm9ybUNvbnRyb2xFbGVtZW50LmNwcApAQCAtNjUsNiArNjUsNyBAQCBIVE1MRm9ybUNvbnRyb2xF bGVtZW50OjpIVE1MRm9ybUNvbnRyb2xFbGVtZW50KGNvbnN0IFF1YWxpZmllZE5hbWUmIHRhZ05h bWUsIERvYwogICAgICwgbV93aWxsVmFsaWRhdGVJbml0aWFsaXplZChmYWxzZSkKICAgICAsIG1f d2lsbFZhbGlkYXRlKHRydWUpCiAgICAgLCBtX2lzVmFsaWQodHJ1ZSkKKyAgICAsIG1fd2FzQ2hh bmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoZmFsc2UpCiB7CiAgICAgaWYgKCF0 aGlzLT5mb3JtKCkpCiAgICAgICAgIHNldEZvcm0oZmluZEZvcm1BbmNlc3RvcigpKTsKQEAgLTE4 OCwxMyArMTg5LDI1IEBAIHZvaWQgSFRNTEZvcm1Db250cm9sRWxlbWVudDo6c2V0TmFtZShjb25z dCBBdG9taWNTdHJpbmcmIHZhbHVlKQogICAgIHNldEF0dHJpYnV0ZShuYW1lQXR0ciwgdmFsdWUp OwogfQogCitib29sIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6Ondhc0NoYW5nZWRTaW5jZUxhc3RG b3JtQ29udHJvbENoYW5nZUV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV93YXNDaGFuZ2Vk U2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudDsKK30KKwordm9pZCBIVE1MRm9ybUNvbnRy b2xFbGVtZW50OjpzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudChib29s IGNoYW5nZWQpCit7CisgICAgbV93YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VF dmVudCA9IGNoYW5nZWQ7Cit9CisKIHZvaWQgSFRNTEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0 Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCkKIHsKICAgICBIVE1MRWxlbWVudDo6ZGlzcGF0Y2hD aGFuZ2VFdmVudHMoKTsKKyAgICBzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VF dmVudChmYWxzZSk7CiB9CiAKIHZvaWQgSFRNTEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0Y2hG b3JtQ29udHJvbElucHV0RXZlbnQoKQogeworICAgIHNldENoYW5nZWRTaW5jZUxhc3RGb3JtQ29u dHJvbENoYW5nZUV2ZW50KHRydWUpOwogICAgIEhUTUxFbGVtZW50OjpkaXNwYXRjaElucHV0RXZl bnRzKCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250 cm9sRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50 LmgKaW5kZXggMzY4ZGNmYWQ3ZjRkNjg1MDM4NjRlOGFhY2RlZmZhNGQ4NWRjOWIxZS4uODA0Y2Y5 MDE0ODllYzI1YmZlMjc4ZDQwNWE4N2U2MGUyMWViMGNmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKQEAgLTUyLDYgKzUyLDkgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgYm9vbCBmb3JtQ29udHJvbFZhbHVlTWF0Y2hlc1JlbmRlcmVyKCkgY29uc3Qg eyByZXR1cm4gbV92YWx1ZU1hdGNoZXNSZW5kZXJlcjsgfQogICAgIHZpcnR1YWwgdm9pZCBzZXRG b3JtQ29udHJvbFZhbHVlTWF0Y2hlc1JlbmRlcmVyKGJvb2wgYikgeyBtX3ZhbHVlTWF0Y2hlc1Jl bmRlcmVyID0gYjsgfQogCisgICAgdmlydHVhbCBib29sIHdhc0NoYW5nZWRTaW5jZUxhc3RGb3Jt Q29udHJvbENoYW5nZUV2ZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCB2b2lkIHNldENoYW5nZWRT aW5jZUxhc3RGb3JtQ29udHJvbENoYW5nZUV2ZW50KGJvb2wpOworCiAgICAgdmlydHVhbCB2b2lk IGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwogICAgIHZpcnR1YWwgdm9pZCBkaXNw YXRjaEZvcm1Db250cm9sSW5wdXRFdmVudCgpOwogCkBAIC0xNjEsNiArMTY0LDggQEAgcHJpdmF0 ZToKICAgICAvLyBDYWNoZSBvZiB2YWxpZGl0eSgpLT52YWxpZCgpLgogICAgIC8vIEJ1dCAiY2Fu ZGlkYXRlIGZvciBjb25zdHJhaW50IHZhbGlkYXRpb24iIGRvZXNuJ3QgYWZmZWN0IG1faXNWYWxp ZC4KICAgICBib29sIG1faXNWYWxpZCA6IDE7CisKKyAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNl TGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQgOiAxOwogfTsKIAogLy8gRklYTUU6IEdpdmUgdGhp cyBjbGFzcyBpdHMgb3duIGhlYWRlciBmaWxlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0 RWxlbWVudC5jcHAKaW5kZXggZTEwOTU3OGYzMmIyMzMxODFlMGJiODY0Mzk5NzI2ODBkZjNkMDcz Yy4uZWYyNWQxYzA3NzJhMDRjZGI0NGU1YTk1NjU1ZGNmYzcxZjU2OGI1ZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC00ODksNiArNDg5LDggQEAgdm9pZCBI VE1MSW5wdXRFbGVtZW50Ojp1cGRhdGVUeXBlKCkKICAgICAgICAgICAgIHVwZGF0ZUZvY3VzQXBw ZWFyYW5jZSh0cnVlKTsKICAgICB9CiAKKyAgICBzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRy b2xDaGFuZ2VFdmVudChmYWxzZSk7CisKICAgICBjaGVja2VkUmFkaW9CdXR0b25zKCkuYWRkQnV0 dG9uKHRoaXMpOwogCiAgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7CkBAIC04ODksMTAgKzg5 MSwxNCBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKGNvbnN0IFN0cmluZyYgdmFs dWUsIGJvb2wgc2VuZENoYW5nZUV2ZW50KQogICAgIH0KICAgICBtX2lucHV0VHlwZS0+dmFsdWVD aGFuZ2VkKCk7CiAKLSAgICAvLyBEb24ndCBkaXNwYXRjaCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4g Zm9jdXNlZCwgaXQgd2lsbCBiZSBkaXNwYXRjaGVkCi0gICAgLy8gd2hlbiB0aGUgY29udHJvbCBs b3NlcyBmb2N1cy4KLSAgICBpZiAoc2VuZENoYW5nZUV2ZW50ICYmIGRvY3VtZW50KCktPmZvY3Vz ZWROb2RlKCkgIT0gdGhpcykKLSAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50 KCk7CisgICAgaWYgKHNlbmRDaGFuZ2VFdmVudCkgeworICAgICAgICAvLyBJZiB0aGUgdXNlciBp cyBzdGlsbCBlZGl0aW5nIHRoaXMgZmllbGQsIGRpc3BhdGNoIGFuIGlucHV0IGV2ZW50IHJhdGhl ciB0aGFuIGEgY2hhbmdlIGV2ZW50LgorICAgICAgICAvLyBUaGUgY2hhbmdlIGV2ZW50IHdpbGwg YmUgZGlzcGF0Y2hlZCB3aGVuIGVkaXRpbmcgZmluaXNoZXMuCisgICAgICAgIGlmIChpc1RleHRG aWVsZCgpICYmIGZvY3VzZWQoKSkKKyAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xJbnB1 dEV2ZW50KCk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xD aGFuZ2VFdmVudCgpOworICAgIH0KIAogICAgIElucHV0RWxlbWVudDo6bm90aWZ5Rm9ybVN0YXRl Q2hhbmdlZCh0aGlzKTsKIH0KQEAgLTEwMzMsMTUgKzEwMzksMTAgQEAgdm9pZCBIVE1MSW5wdXRF bGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCiAgICAgICAgICAgICBhZGRT ZWFyY2hSZXN1bHQoKTsKICAgICAgICAgICAgIG9uU2VhcmNoKCk7CiAgICAgICAgIH0KLSAgICAg ICAgLy8gRmlyZSBvbkNoYW5nZSBmb3IgdGV4dCBmaWVsZHMuCi0gICAgICAgIFJlbmRlck9iamVj dCogciA9IHJlbmRlcmVyKCk7Ci0gICAgICAgIGlmIChyICYmIHItPmlzVGV4dEZpZWxkKCkgJiYg dG9SZW5kZXJUZXh0Q29udHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkp IHsKKyAgICAgICAgLy8gRm9ybSBzdWJtaXNzaW9uIGZpbmlzaGVzIGVkaXRpbmcsIGp1c3QgYXMg bG9zcyBvZiBmb2N1cyBkb2VzLgorICAgICAgICAvLyBJZiB0aGVyZSB3YXMgYSBjaGFuZ2UsIHNl bmQgdGhlIGV2ZW50IG5vdy4KKyAgICAgICAgaWYgKHdhc0NoYW5nZWRTaW5jZUxhc3RGb3JtQ29u dHJvbENoYW5nZUV2ZW50KCkpCiAgICAgICAgICAgICBkaXNwYXRjaEZvcm1Db250cm9sQ2hhbmdl RXZlbnQoKTsKLSAgICAgICAgICAgIC8vIFJlZmV0Y2ggdGhlIHJlbmRlcmVyIHNpbmNlIGFyYml0 cmFyeSBKUyBjb2RlIHJ1biBkdXJpbmcgb25jaGFuZ2UgY2FuIGRvIGFueXRoaW5nLCBpbmNsdWRp bmcgZGVzdHJveWluZyBpdC4KLSAgICAgICAgICAgIHIgPSByZW5kZXJlcigpOwotICAgICAgICAg ICAgaWYgKHIgJiYgci0+aXNUZXh0RmllbGQoKSkKLSAgICAgICAgICAgICAgICB0b1JlbmRlclRl eHRDb250cm9sKHIpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpOwotICAg ICAgICB9CiAKICAgICAgICAgUmVmUHRyPEhUTUxGb3JtRWxlbWVudD4gZm9ybUZvclN1Ym1pc3Np b24gPSBtX2lucHV0VHlwZS0+Zm9ybUZvclN1Ym1pc3Npb24oKTsKICAgICAgICAgLy8gRm9ybSBt YXkgbmV2ZXIgaGF2ZSBiZWVuIHByZXNlbnQsIG9yIG1heSBoYXZlIGJlZW4gZGVzdHJveWVkIGJ5 IGNvZGUgcmVzcG9uZGluZyB0byB0aGUgY2hhbmdlIGV2ZW50LgpAQCAtMTQxNSw4ICsxNDE2LDYg QEAgdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpzdGVwVXBGcm9tUmVuZGVyZXIoaW50IG4pCiAgICAg fQogCiAgICAgaWYgKGN1cnJlbnRTdHJpbmdWYWx1ZSAhPSB2YWx1ZSgpKSB7Ci0gICAgICAgIGlm IChyZW5kZXJlcigpICYmIHJlbmRlcmVyKCktPmlzVGV4dEZpZWxkKCkpCi0gICAgICAgICAgICB0 b1JlbmRlclRleHRDb250cm9sKHJlbmRlcmVyKCkpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdl RXZlbnQodHJ1ZSk7CiAgICAgICAgIGlmIChtX2lucHV0VHlwZS0+aXNSYW5nZUNvbnRyb2woKSkK ICAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwogICAgICAgICBl bHNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0Q29udHJvbElu bmVyRWxlbWVudHMuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dENvbnRyb2xJ bm5lckVsZW1lbnRzLmNwcAppbmRleCAwN2Y1MzlkYTU0Njg2ZGY1ZjIxYzMzMDBlZmMxNWFjMWVh ODIzYWI2Li45NjhjNWU0ODVhZTQ3OWZkMTY1MmJhMzQzOTNhZTM2NzgyOGYzMTc3IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0Q29udHJvbElubmVyRWxlbWVudHMu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRDb250cm9sSW5uZXJFbGVt ZW50cy5jcHAKQEAgLTIxMSwxMSArMjExLDcgQEAgdm9pZCBTZWFyY2hGaWVsZENhbmNlbEJ1dHRv bkVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogICAgICAgICAgICAg fQogICAgICAgICAgICAgaWYgKGhvdmVyZWQoKSkgewogICAgICAgICAgICAgICAgIFN0cmluZyBv bGRWYWx1ZSA9IGlucHV0LT52YWx1ZSgpOwotICAgICAgICAgICAgICAgIGlucHV0LT5zZXRWYWx1 ZSgiIik7Ci0gICAgICAgICAgICAgICAgaWYgKCFvbGRWYWx1ZS5pc0VtcHR5KCkpIHsKLSAgICAg ICAgICAgICAgICAgICAgdG9SZW5kZXJUZXh0Q29udHJvbChpbnB1dC0+cmVuZGVyZXIoKSktPnNl dENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCh0cnVlKTsKLSAgICAgICAgICAgICAgICAgICAg aW5wdXQtPmRpc3BhdGNoRm9ybUNvbnRyb2xJbnB1dEV2ZW50KCk7Ci0gICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgIGlucHV0LT5zZXRWYWx1ZUZvclVzZXIoIiIpOwogICAgICAgICAg ICAgICAgIGlucHV0LT5vblNlYXJjaCgpOwogICAgICAgICAgICAgICAgIGV2ZW50LT5zZXREZWZh dWx0SGFuZGxlZCgpOwogICAgICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJUZXh0Q29udHJvbC5jcHAKaW5kZXggMTZjMDI0N2RhZjFiMzAxZGQxYWY2YzJjODUw MzEzYjQ2MjFiM2QxNC4uODE0OWY2Y2M2NjQ2MTdkOGExYTA4ZDQ4YWM1MTllNTcyOWMxMzRmYiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuY3BwCkBA IC03NCw3ICs3NCw2IEBAIHN0YXRpYyBDb2xvciBkaXNhYmxlZFRleHRDb2xvcihjb25zdCBDb2xv ciYgdGV4dENvbG9yLCBjb25zdCBDb2xvciYgYmFja2dyb3VuZENvCiBSZW5kZXJUZXh0Q29udHJv bDo6UmVuZGVyVGV4dENvbnRyb2woTm9kZSogbm9kZSwgYm9vbCBwbGFjZWhvbGRlclZpc2libGUp CiAgICAgOiBSZW5kZXJCbG9jayhub2RlKQogICAgICwgbV9wbGFjZWhvbGRlclZpc2libGUocGxh Y2Vob2xkZXJWaXNpYmxlKQotICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQo ZmFsc2UpCiAgICAgLCBtX2xhc3RDaGFuZ2VXYXNVc2VyRWRpdChmYWxzZSkKIHsKIH0KQEAgLTM1 MSw3ICszNTAsNiBAQCBpbnQgUmVuZGVyVGV4dENvbnRyb2w6OmluZGV4Rm9yVmlzaWJsZVBvc2l0 aW9uKGNvbnN0IFZpc2libGVQb3NpdGlvbiYgcG9zKSBjb25zdAogCiB2b2lkIFJlbmRlclRleHRD b250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdlZCgpCiB7Ci0gICAgbV93YXNDaGFuZ2VkU2luY2VMYXN0 Q2hhbmdlRXZlbnQgPSB0cnVlOwogICAgIG1fbGFzdENoYW5nZVdhc1VzZXJFZGl0ID0gdHJ1ZTsK IH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250 cm9sLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuaAppbmRl eCBjZDg4MTJlNjg2OTdmZjU5MzczMjI3OThiZGU2MzY5YjM1MWMxMGMwLi4wYzMwZWQ2NGE4NTFi MDk2OTg1Y2RhOWI5NzVjMWZlOGNhZTY4NzAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyVGV4dENvbnRyb2wuaApAQCAtMzYsOSArMzYsNiBAQCBwdWJsaWM6CiAKICAgICBI VE1MRWxlbWVudCogaW5uZXJUZXh0RWxlbWVudCgpIGNvbnN0OwogCi0gICAgYm9vbCB3YXNDaGFu Z2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoKSBjb25zdCB7IHJldHVybiBtX3dhc0NoYW5nZWRTaW5j ZUxhc3RDaGFuZ2VFdmVudDsgfQotICAgIHZvaWQgc2V0Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2 ZW50KGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KSB7IG1fd2FzQ2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50ID0gd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OyB9Ci0K ICAgICBib29sIGxhc3RDaGFuZ2VXYXNVc2VyRWRpdCgpIGNvbnN0IHsgcmV0dXJuIG1fbGFzdENo YW5nZVdhc1VzZXJFZGl0OyB9CiAgICAgdm9pZCBzZXRMYXN0Q2hhbmdlV2FzVXNlckVkaXQoYm9v bCBsYXN0Q2hhbmdlV2FzVXNlckVkaXQpOwogCkBAIC0xMTUsNyArMTEyLDYgQEAgcHJpdmF0ZToK IAogICAgIHZvaWQgcGFpbnRQbGFjZWhvbGRlcihQYWludEluZm8mLCBpbnQgdHgsIGludCB0eSk7 CiAKLSAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OwogICAgIGJvb2wg bV9sYXN0Q2hhbmdlV2FzVXNlckVkaXQ7CiAgICAgUmVmUHRyPFRleHRDb250cm9sSW5uZXJUZXh0 RWxlbWVudD4gbV9pbm5lclRleHQ7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlclRleHRDb250cm9sTXVsdGlMaW5lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbE11bHRpTGluZS5jcHAKaW5kZXggMGQ1MTJmMzYyMTAw N2ZjNTc1NmFlMTYxNWE5ZDE2YWFhZDdlM2Q2Zi4uNTU0YjY2N2QyYzY2MGFkM2UzOWUzODlkZTBk ZDNkZGU0ZDM2ZTcxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl clRleHRDb250cm9sTXVsdGlMaW5lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyVGV4dENvbnRyb2xNdWx0aUxpbmUuY3BwCkBAIC00Niw2ICs0Niw3IEBAIHZvaWQgUmVu ZGVyVGV4dENvbnRyb2xNdWx0aUxpbmU6OnN1YnRyZWVIYXNDaGFuZ2VkKCkKIHsKICAgICBSZW5k ZXJUZXh0Q29udHJvbDo6c3VidHJlZUhhc0NoYW5nZWQoKTsKICAgICBIVE1MVGV4dEFyZWFFbGVt ZW50KiB0ZXh0QXJlYSA9IHN0YXRpY19jYXN0PEhUTUxUZXh0QXJlYUVsZW1lbnQqPihub2RlKCkp OworICAgIHRleHRBcmVhLT5zZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVu dCh0cnVlKTsKICAgICB0ZXh0QXJlYS0+c2V0Rm9ybUNvbnRyb2xWYWx1ZU1hdGNoZXNSZW5kZXJl cihmYWxzZSk7CiAgICAgdGV4dEFyZWEtPnNldE5lZWRzVmFsaWRpdHlDaGVjaygpOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVM aW5lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmds ZUxpbmUuY3BwCmluZGV4IDI4NTNlNzhlNTBiNTViNTE4ZWQ4ZDU0MDBmZjlmZWQ5YTUzNmJiYjQu LmIzMTU3MDA2NGZmODJjYjAxMmM2N2Y2MjdlNjk4ZDRjYjg0M2Q4NzQgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUu Y3BwCkBAIC0xODEsOSArMTgxLDEzIEBAIHZvaWQgUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVMaW5l OjpoaWRlUG9wdXAoKQogCiB2b2lkIFJlbmRlclRleHRDb250cm9sU2luZ2xlTGluZTo6c3VidHJl ZUhhc0NoYW5nZWQoKQogewotICAgIGJvb2wgd2FzQ2hhbmdlZCA9IHdhc0NoYW5nZWRTaW5jZUxh c3RDaGFuZ2VFdmVudCgpOwogICAgIFJlbmRlclRleHRDb250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdl ZCgpOwogCisgICAgQVNTRVJUKG5vZGUoKS0+aXNFbGVtZW50Tm9kZSgpKTsKKyAgICBFbGVtZW50 KiBlbGVtZW50ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG5vZGUoKSk7CisgICAgYm9vbCB3YXND aGFuZ2VkID0gZWxlbWVudC0+d2FzQ2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZl bnQoKTsKKyAgICBlbGVtZW50LT5zZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VF dmVudCh0cnVlKTsKKwogICAgIElucHV0RWxlbWVudCogaW5wdXQgPSBpbnB1dEVsZW1lbnQoKTsK ICAgICAvLyBXZSBkb24ndCBuZWVkIHRvIGNhbGwgc2FuaXRpemVVc2VySW5wdXRWYWx1ZSgpIGZ1 bmN0aW9uIGhlcmUgYmVjYXVzZQogICAgIC8vIElucHV0RWxlbWVudDo6aGFuZGxlQmVmb3JlVGV4 dEluc2VydGVkRXZlbnQoKSBoYXMgYWxyZWFkeSBjYWxsZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvd21sL1dNTElu cHV0RWxlbWVudC5jcHAKaW5kZXggNjg3YTM4NzI1NWIxMDEwYjVlOTE3NTliYTYwZjVmZTMyYTNl NzI2OS4uODBlNGU3MGQxMDMxMjAyNDU1MTJkM2FkZmFlMTFkMTA2ZmIzNjQ1MyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKQEAgLTQxLDYgKzQxLDcgQEAgV01MSW5wdXRF bGVtZW50OjpXTUxJbnB1dEVsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYgdGFnTmFtZSwgRG9j dW1lbnQqIGRvYykKICAgICA6IFdNTEZvcm1Db250cm9sRWxlbWVudCh0YWdOYW1lLCBkb2MpCiAg ICAgLCBtX2lzUGFzc3dvcmRGaWVsZChmYWxzZSkKICAgICAsIG1faXNFbXB0eU9rKGZhbHNlKQor ICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpCiAgICAgLCBtX251 bU9mQ2hhcnNBbGxvd2VkQnlNYXNrKDApCiB7CiB9CkBAIC0xNzMsNiArMTc0LDE2IEBAIHZvaWQg V01MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZUZyb21SZW5kZXJlcihjb25zdCBTdHJpbmcmIHZhbHVl KQogICAgIElucHV0RWxlbWVudDo6c2V0VmFsdWVGcm9tUmVuZGVyZXIobV9kYXRhLCB0aGlzLCB0 aGlzLCB2YWx1ZSk7CiB9CiAKK2Jvb2wgV01MSW5wdXRFbGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VM YXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fd2FzQ2hh bmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OworfQorCit2b2lkIFdNTElucHV0RWxlbWVudDo6c2V0 Q2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoYm9vbCBjaGFuZ2VkKQorewor ICAgIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50ID0gY2hhbmdlZDsKK30KKwogYm9v bCBXTUxJbnB1dEVsZW1lbnQ6OnNhdmVGb3JtQ29udHJvbFN0YXRlKFN0cmluZyYgcmVzdWx0KSBj b25zdAogewogICAgIGlmIChtX2lzUGFzc3dvcmRGaWVsZCkKQEAgLTI5NiwxNCArMzA3LDkgQEAg dm9pZCBXTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2dCkKIAog ICAgIGlmIChjbGlja0RlZmF1bHRGb3JtQnV0dG9uKSB7CiAgICAgICAgIC8vIEZpcmUgb25DaGFu Z2UgZm9yIHRleHQgZmllbGRzLgotICAgICAgICBSZW5kZXJPYmplY3QqIHIgPSByZW5kZXJlcigp OwotICAgICAgICBpZiAociAmJiB0b1JlbmRlclRleHRDb250cm9sKHIpLT53YXNDaGFuZ2VkU2lu Y2VMYXN0Q2hhbmdlRXZlbnQoKSkgeworICAgICAgICBpZiAod2FzQ2hhbmdlZFNpbmNlTGFzdENo YW5nZUV2ZW50KCkpIHsKKyAgICAgICAgICAgIHNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVu dChmYWxzZSk7CiAgICAgICAgICAgICBkaXNwYXRjaEV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnRO YW1lcygpLmNoYW5nZUV2ZW50LCB0cnVlLCBmYWxzZSkpOwotICAgICAgICAgICAgCi0gICAgICAg ICAgICAvLyBSZWZldGNoIHRoZSByZW5kZXJlciBzaW5jZSBhcmJpdHJhcnkgSlMgY29kZSBydW4g ZHVyaW5nIG9uY2hhbmdlIGNhbiBkbyBhbnl0aGluZywgaW5jbHVkaW5nIGRlc3Ryb3lpbmcgaXQu Ci0gICAgICAgICAgICByID0gcmVuZGVyZXIoKTsKLSAgICAgICAgICAgIGlmIChyKQotICAgICAg ICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wociktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudChmYWxzZSk7CiAgICAgICAgIH0KIAogICAgICAgICBldnQtPnNldERlZmF1bHRIYW5k bGVkKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS93bWwvV01MSW5wdXRFbGVtZW50Lmgg Yi9Tb3VyY2UvV2ViQ29yZS93bWwvV01MSW5wdXRFbGVtZW50LmgKaW5kZXggMTE2MmFjMTkzYzcz N2UxNTQ2ZGI4NjM5ZTI2ZDdjYjVlN2RhZjRkNS4uNTU4MTQ3YTE1ZjA1OThjNDY4OTNiMDRkOTVj NjBmNWJlZDhjM2I0YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxl bWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuaApAQCAtNjcs NiArNjcsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTdHJpbmcgY29udmVydEZyb21WaXNpYmxl VmFsdWUoY29uc3QgU3RyaW5nJiB2YWx1ZSkgY29uc3QgeyByZXR1cm4gdmFsdWU7IH0KICAgICB2 aXJ0dWFsIHZvaWQgc2V0VmFsdWVGcm9tUmVuZGVyZXIoY29uc3QgU3RyaW5nJik7CiAKKyAgICB2 aXJ0dWFsIGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoKSBj b25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0Q2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hh bmdlRXZlbnQoYm9vbCk7CisKICAgICB2aXJ0dWFsIGJvb2wgc2F2ZUZvcm1Db250cm9sU3RhdGUo U3RyaW5nJiB2YWx1ZSkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIHJlc3RvcmVGb3JtQ29udHJv bFN0YXRlKGNvbnN0IFN0cmluZyYpOwogCkBAIC0xMTAsNiArMTEzLDcgQEAgcHJpdmF0ZToKICAg ICBJbnB1dEVsZW1lbnREYXRhIG1fZGF0YTsKICAgICBib29sIG1faXNQYXNzd29yZEZpZWxkOwog ICAgIGJvb2wgbV9pc0VtcHR5T2s7CisgICAgYm9vbCBtX3dhc0NoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudDsKICAgICBTdHJpbmcgbV9mb3JtYXRNYXNrOwogICAgIHVuc2lnbmVkIG1fbnVtT2ZD aGFyc0FsbG93ZWRCeU1hc2s7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9tYWMvQ2hh bmdlTG9nIGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IDI3NzBhYjg2M2Q4Mzg3 YWVhMGMyOWRiMDBkNTIzMjg4OTM3NDFjYjMuLjc5NDdkN2I5N2EyN2E1ZGVkODE4ZTY5YzNlMTk2 OTU4MTRmMThhMDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMS0wMy0w MiAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZh bHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBldmVudCB3aGVuIHRoZSBlbGVtZW50IGlzIGZv Y3VzZWQKKyAgICAgICAgSW4gc2VydmljZSBvZiBodHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2No cm9taXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisKKyAgICAgICAgKiBXZWJWaWV3L1dlYlZpZXcu bW06CisgICAgICAgICgtW1dlYlZpZXcgX3NldFZhbHVlRm9yVXNlcjpmb3JFbGVtZW50OndpdGhW YWx1ZTpdKTogRXhwb3NlIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlRm9yVXNlcigpIHRvIHRl c3RzCisgICAgICAgICogV2ViVmlldy9XZWJWaWV3SW50ZXJuYWwuaDoKKyAgICAgICAgKiBXZWJW aWV3L1dlYlZpZXdQcml2YXRlLmg6CisKIDIwMTEtMDMtMDIgIEplc3NpZSBCZXJsaW4gIDxqYmVy bGluQGFwcGxlLmNvbT4KIAogICAgICAgICBSdWJiZXItc3RhbXBlZCBieSBEYW4gQmVybnN0ZWlu LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tIGIvU291 cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3Lm1tCmluZGV4IDhmYjA2ZDY2NDRlNzljZGVl MGU1YmZjMWFlY2NhOTIzMzY0NzA1NzAuLjliNmNmMjc5YmY2ZjUzMWY3NmJlMzg3NGMxY2MxY2E2 ZDZiOTc2NDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlldy5t bQorKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXcubW0KQEAgLTEwNyw2ICsx MDcsNyBAQAogI2ltcG9ydCA8Rm91bmRhdGlvbi9OU1VSTENvbm5lY3Rpb24uaD4KICNpbXBvcnQg PEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KICNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0pTVmFs dWVSZWYuaD4KKyNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0pTU3RyaW5nUmVmLmg+CiAjaW1wb3J0 IDxXZWJDb3JlL0Fic3RyYWN0RGF0YWJhc2UuaD4KICNpbXBvcnQgPFdlYkNvcmUvQXBwbGljYXRp b25DYWNoZVN0b3JhZ2UuaD4KICNpbXBvcnQgPFdlYkNvcmUvQmFja0ZvcndhcmRMaXN0SW1wbC5o PgpAQCAtMTMxLDYgKzEzMiw3IEBACiAjaW1wb3J0IDxXZWJDb3JlL0hUTUxOYW1lcy5oPgogI2lt cG9ydCA8V2ViQ29yZS9IaXN0b3J5SXRlbS5oPgogI2ltcG9ydCA8V2ViQ29yZS9JY29uRGF0YWJh c2UuaD4KKyNpbXBvcnQgPFdlYkNvcmUvSW5wdXRFbGVtZW50Lmg+CiAjaW1wb3J0IDxXZWJDb3Jl L0pTQ1NTU3R5bGVEZWNsYXJhdGlvbi5oPgogI2ltcG9ydCA8V2ViQ29yZS9KU0RvY3VtZW50Lmg+ CiAjaW1wb3J0IDxXZWJDb3JlL0pTRWxlbWVudC5oPgpAQCAtNjI0Nyw2ICs2MjQ5LDI5IEBAIHN0 YXRpYyB2b2lkIGdsaWJDb250ZXh0SXRlcmF0aW9uQ2FsbGJhY2soQ0ZSdW5Mb29wT2JzZXJ2ZXJS ZWYsIENGUnVuTG9vcEFjdGl2aXR5CiAKIEBlbmQKIAorQGltcGxlbWVudGF0aW9uIFdlYlZpZXcg KFdlYlZpZXdQcml2YXRlU2V0VmFsdWVGb3JVc2VyKQorCistICh2b2lkKV9zZXRWYWx1ZUZvclVz ZXI6KEpTQ29udGV4dFJlZiljb250ZXh0IGZvckVsZW1lbnQ6KEpTVmFsdWVSZWYpZWxlbWVudCB3 aXRoVmFsdWU6KEpTU3RyaW5nUmVmKXZhbHVlCit7CisgICAgaWYgKCFlbGVtZW50IHx8ICF2YWx1 ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgSlNMb2NrIGxvY2soU2lsZW5jZUFzc2VydGlvbnNP bmx5KTsKKworICAgIEV4ZWNTdGF0ZSogZXhlYyA9IHRvSlMoY29udGV4dCk7CisgICAgSlNWYWx1 ZSBlbGVtZW50VmFsdWUgPSB0b0pTKGV4ZWMsIGVsZW1lbnQpOworICAgIGlmICghZWxlbWVudFZh bHVlLmluaGVyaXRzKCZKU0VsZW1lbnQ6OnNfaW5mbykpCisgICAgICAgIHJldHVybjsKKworICAg IElucHV0RWxlbWVudCogaW5wdXRFbGVtZW50ID0gdG9JbnB1dEVsZW1lbnQoc3RhdGljX2Nhc3Q8 SlNFbGVtZW50Kj4oYXNPYmplY3QoZWxlbWVudFZhbHVlKSktPmltcGwoKSk7CisgICAgaWYgKCFp bnB1dEVsZW1lbnQpCisgICAgICAgIHJldHVybjsKKworICAgIGlucHV0RWxlbWVudC0+c2V0VmFs dWVGb3JVc2VyKFN0cmluZyhKU1N0cmluZ0dldENoYXJhY3RlcnNQdHIodmFsdWUpLCBKU1N0cmlu Z0dldExlbmd0aCh2YWx1ZSkpKTsKK30KKworQGVuZAorCiBAaW1wbGVtZW50YXRpb24gV2ViVmll dyAoV2ViVmlld1ByaXZhdGVOb2Rlc0Zyb21SZWN0KQogCiAtIChKU1ZhbHVlUmVmKV9ub2Rlc0Zy b21SZWN0OihKU0NvbnRleHRSZWYpY29udGV4dCBmb3JEb2N1bWVudDooSlNWYWx1ZVJlZil2YWx1 ZSB4OihpbnQpeCAgeTooaW50KXkgdG9wOih1bnNpZ25lZCl0b3AgcmlnaHQ6KHVuc2lnbmVkKXJp Z2h0IGJvdHRvbToodW5zaWduZWQpYm90dG9tIGxlZnQ6KHVuc2lnbmVkKWxlZnQgaWdub3JlQ2xp cHBpbmc6KEJPT0wpaWdub3JlQ2xpcHBpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFj L1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmggYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dl YlZpZXdJbnRlcm5hbC5oCmluZGV4IDU1NWM0ZDExMGVkMGJmYzljZmI2NWRjOTYyZjBiMjgxMTA5 NzI3ODcuLmEyMzEwMjQ1YWQ5YjBkNDI3Y2NkZjUzOTJjZGY2NDUwMjk4MmI0YzMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmgKKysrIGIvU291 cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3SW50ZXJuYWwuaApAQCAtMTk0LDYgKzE5NCw0 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIC0gKHZvaWQpX2Z1bGxTY3JlZW5SZW5kZXJlckNoYW5n ZWQ6KFdlYkNvcmU6OlJlbmRlckJveCopcmVuZGVyZXI7CiAjZW5kaWYKIAotLSAoSlNWYWx1ZVJl ZilfY29tcHV0ZWRTdHlsZUluY2x1ZGluZ1Zpc2l0ZWRJbmZvOihKU0NvbnRleHRSZWYpY29udGV4 dCBmb3JFbGVtZW50OihKU1ZhbHVlUmVmKXZhbHVlOwotCiBAZW5kCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlZpZXdQcml2YXRlLmgKaW5kZXggYTRlYTgwOWIwMDFkYmM2YTY3MjM0ZjE3 MmYwMjBiYzM0Y2Y3ZTg0Yy4uNDBmMmJlZDA3NDRjZDc0OTg0MzAxNjYwYmY0ZjdiZjI0ODVkMDgw YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3UHJpdmF0ZS5o CisrKyBiL1NvdXJjZS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViVmlld1ByaXZhdGUuaApAQCAtNjc3 LDYgKzY3NywxMCBAQCBDb3VsZCBiZSB3b3J0aCBhZGRpbmcgdG8gdGhlIEFQSS4KIC0gKEpTVmFs dWVSZWYpX2NvbXB1dGVkU3R5bGVJbmNsdWRpbmdWaXNpdGVkSW5mbzooSlNDb250ZXh0UmVmKWNv bnRleHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZil2YWx1ZTsKIEBlbmQKIAorQGludGVyZmFjZSBX ZWJWaWV3IChXZWJWaWV3UHJpdmF0ZVNldFZhbHVlRm9yVXNlcikKKy0gKHZvaWQpX3NldFZhbHVl Rm9yVXNlcjooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRWxlbWVudDooSlNWYWx1ZVJlZillbGVt ZW50IHdpdGhWYWx1ZTooSlNTdHJpbmdSZWYpdmFsdWU7CitAZW5kCisKIEBpbnRlcmZhY2UgV2Vi VmlldyAoV2ViVmlld1ByaXZhdGVOb2Rlc0Zyb21SZWN0KQogLSAoSlNWYWx1ZVJlZilfbm9kZXNG cm9tUmVjdDooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRG9jdW1lbnQ6KEpTVmFsdWVSZWYpdmFs dWUgeDooaW50KXggIHk6KGludCl5IHRvcDoodW5zaWduZWQpdG9wIHJpZ2h0Oih1bnNpZ25lZCly aWdodCBib3R0b206KHVuc2lnbmVkKWJvdHRvbSBsZWZ0Oih1bnNpZ25lZClsZWZ0IGlnbm9yZUNs aXBwaW5nOihCT09MKWlnbm9yZUNsaXBwaW5nOwogQGVuZApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hh bmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDk3ZDk4OTBhNDQyYjgwYzgwOTM4YmJiYTQz NjJmOTQwZGNiYTc0MzIuLjYzZTJjMmFjM2EzNGQ5ZTA2YzVkY2ZkYzI3MDk3Y2U2MTk4ODM1OTkg MTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNiBAQAorMjAxMS0wMy0wMiAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhU TUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBldmVudCB3 aGVuIHRoZSBlbGVtZW50IGlzIGZvY3VzZWQKKyAgICAgICAgSW4gc2VydmljZSBvZiBodHRwczov L2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9taXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisKKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6CisgICAgICAgIChz ZXRWYWx1ZUZvclVzZXJDYWxsYmFjayk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 c3RhdGljRnVuY3Rpb25zKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJv bGxlckd0ay5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JV c2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06CisgICAgICAgIChM YXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogRXhwb3NlIEhUTUxJbnB1dEVs ZW1lbnQ6OnNldFZhbHVlRm9yVXNlcigpIHRvIHRlc3RzCisgICAgICAgICogRHVtcFJlbmRlclRy ZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1l bnRhdGlvbi4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xs ZXJXaW4uY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNl cik6IFN0dWJiZWQgb3V0OyBuZWVkIHJlYWwgaW1wbGVtZW50YXRpb24uCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHA6CisgICAgICAgIChMYXlv dXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVh bCBpbXBsZW1lbnRhdGlvbi4KKwogMjAxMS0wMy0wMSAgT2phbiBWYWZhaSAgPG9qYW5AY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFRvbnkgQ2hhbmcuCmRpZmYgLS1naXQgYS9U b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9Ub29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggNDE2YjlmY2IxMDg1ZmUx Y2Q0ODNmZGQ5MmM2NmQ0YjVkYmE4Njg2ZC4uOWYxODc3YzM3MWMwNmI0M2U1YjM1NDMyYjY2NmM4 MTRiZThmYjhiYyAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9s bGVyLmNwcApAQCAtMTQzMiw2ICsxNDMyLDIxIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHNldFVzZXJT dHlsZVNoZWV0TG9jYXRpb25DYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplCiAg ICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNW YWx1ZVJlZiBzZXRWYWx1ZUZvclVzZXJDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNP YmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVu dENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRp b24pCit7CisgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgorICAgIGlmIChhcmd1bWVudENv dW50ICE9IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsK KworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiB2YWx1ZShBZG9wdCwgSlNWYWx1ZVRvU3Ry aW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2VwdGlvbikpOworICAgIEFTU0VSVCgh KmV4Y2VwdGlvbik7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHN0 YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNP YmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5zZXRWYWx1ZUZvclVzZXIoY29udGV4dCwgYXJndW1l bnRzWzBdLCB2YWx1ZS5nZXQoKSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQo Y29udGV4dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIHNldFZpZXdNb2RlTWVkaWFGZWF0dXJl Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09i amVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJl ZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMg aW1wbGVtZW50YXRpb24KQEAgLTIxMjksNiArMjE0NCw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExh eW91dFRlc3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJzZXRVc2VE YXNoYm9hcmRDb21wYXRpYmlsaXR5TW9kZSIsIHNldFVzZURhc2hib2FyZENvbXBhdGliaWxpdHlN b2RlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0VXNlclN0eWxlU2hlZXRFbmFibGVk Iiwgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAi c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbiIsIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb25DYWxs YmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRl RG9udERlbGV0ZSB9LAorICAgICAgICB7ICJzZXRWYWx1ZUZvclVzZXIiLCBzZXRWYWx1ZUZvclVz ZXJDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsg InNldFZpZXdNb2RlTWVkaWFGZWF0dXJlIiwgc2V0Vmlld01vZGVNZWRpYUZlYXR1cmVDYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRXZWJWaWV3RWRpdGFibGUiLCBzZXRXZWJWaWV3RWRp dGFibGVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRXaWxsU2VuZFJlcXVlc3RDbGVh ckhlYWRlciIsIHNldFdpbGxTZW5kUmVxdWVzdENsZWFySGVhZGVyQ2FsbGJhY2ssIGtKU1Byb3Bl cnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwK ZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgg Yi9Ub29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCmluZGV4IDhhMjA1 MDA1OTFlMWE0OWM3YmZhMWIzNGJmNzcyOGJmNTE2MTBiOTUuLjRiMWMwNGUzZjY2OWE5OGMyODA0 NDVlMzViOTFiMTA4OWVjNmQ3NjAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmgKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVz dENvbnRyb2xsZXIuaApAQCAtMTExLDYgKzExMSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldFVz ZURhc2hib2FyZENvbXBhdGliaWxpdHlNb2RlKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBzZXRVc2Vy U3R5bGVTaGVldEVuYWJsZWQoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0 TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7CisgICAgdm9pZCBzZXRWYWx1ZUZvclVzZXIoSlND b250ZXh0UmVmLCBKU1ZhbHVlUmVmIG5vZGVPYmplY3QsIEpTU3RyaW5nUmVmIHZhbHVlKTsKICAg ICB2b2lkIHNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpTU3RyaW5nUmVmIG1vZGUpOwogICAgIHZv aWQgc2V0WFNTQXVkaXRvckVuYWJsZWQoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldEZyYW1lRmxh dHRlbmluZ0VuYWJsZWQoYm9vbCBlbmFibGUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRl clRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKaW5kZXggMGJiYWI4NjdlZmIwMDUz NDNlZGFlOTk5ODk2MmM0YjQ5OGRmZmY2YS4uMWEzOWRhODU5OWE1NmY3N2RjMzhkZWMzNjk2MDNi ZTgyYzY4YTJhZSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRl c3RDb250cm9sbGVyR3RrLmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0 VGVzdENvbnRyb2xsZXJHdGsuY3BwCkBAIC0zMzMsNiArMzMzLDExIEBAIHZvaWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6OnNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCkK ICAgICAgICAgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKHRydWUpOwogfQogCit2b2lkIExheW91 dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpT VmFsdWVSZWYgZWxlbWVudCwgSlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6IGlt cGxlbWVudAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlh RmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSB3 ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhtYWluRnJhbWUpOwpkaWZmIC0tZ2l0IGEvVG9v bHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvVG9vbHMv RHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IGJjOWRi YjdjODI4OWMyYzMzMWZlYThkMWYxZjVhNjBlMDYxYWQxM2MuLmVhNGFlYzY5OTMyMmE3YWVjNmEx M2U5YjVlMTRhODZkYzQzOTVhMjQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21h Yy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9t YWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTQ3OSw2ICs0NzksMTEgQEAgdm9pZCBM YXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1Jl ZiBwYXRoKQogICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNl clN0eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVy OjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVu dCwgSlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAgW1ttYWluRnJhbWUgd2ViVmlld10gX3NldFZh bHVlRm9yVXNlcjpjb250ZXh0IGZvckVsZW1lbnQ6ZWxlbWVudCB3aXRoVmFsdWU6dmFsdWVdOwor fQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShK U1N0cmluZ1JlZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKZGlmZiAtLWdpdCBh L1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAgYi9U b29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCmluZGV4 IDgwODYyZWIyMWI2YjdiMWY1Yzk2ZjVhOTk3M2QwODBiNDMwY2YzYmUuLjEyYTNhNTViOGFiNjI2 ZDgyMDBjYzE0MzU4ZGYyODlmMDI2NjE4MjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRl clRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcApAQCAtNzU1LDYgKzc1NSwxMSBA QCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpT U3RyaW5nUmVmIGpzVVJMKQogICAgIFN5c0ZyZWVTdHJpbmcocmVzdWx0UGF0aEJTVFIpOwogfQog Cit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVm IGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVudCwgSlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAg Ly8gRklYTUU6IGltcGxlbWVudAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRW aWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBp bXBsZW1lbnQKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRlc3RD b250cm9sbGVyV3guY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRy b2xsZXJXeC5jcHAKaW5kZXggMTBlMTEwNzExNmJkNGM2MzAxZTY0MWNlZGM3YTNmMTNhNmY0YzZm YS4uYTk1YWE1MDVhZDdjZGQzZGEwNWZjNzg5NmVkOGJmZDcwOGY4OTU4MCAxMDA2NDQKLS0tIGEv VG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAKKysrIGIv VG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAKQEAgLTEz NSw2ICsxMzUsMTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlU2hl ZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKQogewogfQogCit2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYg ZWxlbWVudCwgSlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6IGltcGxlbWVudAor fQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShK U1N0cmluZ1JlZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQK 84824 2011-03-04 16:26:40 -0800 2011-03-05 00:09:56 -0800 Patch bug-53160-20110304162639.patch text/plain 34806 isherman ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4ZTRiYzBjYTFlMDc1MGUyMjAyZWUzMjllZGRjNDgyY2U5YzM5YjRhLi4yNGQ2YjQy YjFjMjA4MDYxOTA2NDQxYjI3MmM1ZmQ1YjljNTU4MTUyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTEtMDMtMDIgIElseWEgU2hlcm1hbiAgPGlzaGVybWFuQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIVE1MSW5wdXRFbGVt ZW50OjpzZXRWYWx1ZSgpIHNob3VsZCBzY2hlZHVsZSBjaGFuZ2UgZXZlbnQgd2hlbiB0aGUgZWxl bWVudCBpcyBmb2N1c2VkCisgICAgICAgIEluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2ds ZS5jb20vcC9jaHJvbWl1bS9pc3N1ZXMvZGV0YWlsP2lkPTQyNzE2CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MzE2MAorCisgICAgICAgICogZmFzdC9m b3Jtcy9vbmNoYW5nZS1jaGFuZ2UtdHlwZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5cGUuaHRtbDogQWRkZWQuCisgICAgICAgICog ZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXItZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sOiBBZGRl ZC4KKwogMjAxMS0wMy0wMiAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4K IAogICAgICAgICBVbnJldmlld2VkIENocm9taXVtIFNub3cgTGVvcGFyZCBiYXNlbGluZSB1cGRh dGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5 cGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1jaGFuZ2Ut dHlwZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTg2Zjg3ZjE5OWQwNDI3NGQxMzYyMjA2NmM5 M2E0MDU2Y2MxODQwNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMv b25jaGFuZ2UtY2hhbmdlLXR5cGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGhpcyB0 ZXN0cyB0aGF0IG9uY2hhbmdlIGlzIG5vdCBmaXJlZCBhZnRlciBhIGZvcm0gZmllbGQncyB0eXBl IGNoYW5nZXMuCisKK1Nob3VsZCBmaXJlIGNoYW5nZSBldmVudCB3aGVuIHR5cGUgZG9lcyBub3Qg Y2hhbmdlLgorUEFTUyB0cnVlIGlzIHRydWUKK1Nob3VsZCAqbm90KiBmaXJlIGNoYW5nZSBldmVu dCB3aGVuIHR5cGUgZG9lcyBub3QgY2hhbmdlLgorUEFTUyBmYWxzZSBpcyBmYWxzZQorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLWNoYW5nZS10eXBlLmh0bWwg Yi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLWNoYW5nZS10eXBlLmh0bWwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uMWQ1ZGJmZDdjZTZlMmY5ODVmZWIzYmJlMGE0YTdhMmI0YjBmNWE4OQotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2UtY2hhbmdlLXR5cGUuaHRt bApAQCAtMCwwICsxLDQ4IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQgc3JjPSIuLi9q cy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQ+CisgICAg ZnVuY3Rpb24gc2VuZFRleHQoZWxlbWVudCwgdGV4dCkgeworICAgICAgICB2YXIgZXZlbnQgPSBk b2N1bWVudC5jcmVhdGVFdmVudCgnVGV4dEV2ZW50Jyk7CisgICAgICAgIGV2ZW50LmluaXRUZXh0 RXZlbnQoJ3RleHRJbnB1dCcsIHRydWUsIHRydWUsIGRvY3VtZW50LmRlZmF1bHRWaWV3LCB0ZXh0 KTsKKyAgICAgICAgZWxlbWVudC5kaXNwYXRjaEV2ZW50KGV2ZW50KTsKKyAgICB9CisKKyAgICBm dW5jdGlvbiB0ZXN0KCkgeworICAgICAgICB2YXIgdGYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgndGYnKTsKKworICAgICAgICB2YXIgZGlkRmlyZU9uQ2hhbmdlID0gZmFsc2U7CisgICAgICAg IHRmLm9uY2hhbmdlID0gZnVuY3Rpb24oKSB7CisgICAgICAgICAgZGlkRmlyZU9uQ2hhbmdlID0g dHJ1ZTsKKyAgICAgICAgfQorCisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAg ICAgICAgfQorCisgICAgICAgIHRmLmZvY3VzKCk7CisgICAgICAgIHNlbmRUZXh0KHRmLCAnaW5w dXQgdmFsdWUnKTsKKyAgICAgICAgdGYuYmx1cigpOworCisgICAgICAgIGRlYnVnKCdTaG91bGQg ZmlyZSBjaGFuZ2UgZXZlbnQgd2hlbiB0eXBlIGRvZXMgbm90IGNoYW5nZS4nKTsKKyAgICAgICAg c2hvdWxkQmVUcnVlKGRpZEZpcmVPbkNoYW5nZS50b1N0cmluZygpKTsKKworICAgICAgICBkaWRG aXJlT25DaGFuZ2UgPSBmYWxzZTsKKyAgICAgICAgdGYuZm9jdXMoKTsKKyAgICAgICAgc2VuZFRl eHQodGYsICduZXcgaW5wdXQgdmFsdWUnKTsKKyAgICAgICAgdGYuc2V0QXR0cmlidXRlKCd0eXBl JywgJ3Bhc3N3b3JkJyk7CisgICAgICAgIHRmLmJsdXIoKTsKKworICAgICAgICBkZWJ1ZygnU2hv dWxkICpub3QqIGZpcmUgY2hhbmdlIGV2ZW50IHdoZW4gdHlwZSBkb2VzIG5vdCBjaGFuZ2UuJyk7 CisgICAgICAgIHNob3VsZEJlRmFsc2UoZGlkRmlyZU9uQ2hhbmdlLnRvU3RyaW5nKCkpOworICAg IH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0idGVzdCgpIj4KKyAgICBU aGlzIHRlc3RzIHRoYXQgb25jaGFuZ2UgaXMgbm90IGZpcmVkIGFmdGVyIGEgZm9ybSBmaWVsZCdz IHR5cGUgY2hhbmdlcy48YnI+CisgICAgPGZvcm0gbmFtZT0iZm0iPgorICAgICAgICA8aW5wdXQg dHlwZT0idGV4dCIgaWQ9InRmIiAvPgorICAgIDwvZm9ybT4KKyAgICA8ZGl2IGlkPSJjb25zb2xl Ij48L2Rpdj4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv Zm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLWV4cGVjdGVkLnR4dApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5iYzYzYTFkZDM4NmUxMGM4ZmE1NWNmNzQ4NmMwYjAxMDAwOWMwZWYwCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9vbmNoYW5nZS1zZXR2YWx1ZWZvcnVzZXIt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAorVGhpcyB0ZXN0cyB0aGF0IG9uY2hhbmdlIGNv cnJlY3RseSBmaXJlcyBhZnRlciBjYWxsaW5nIHNldFZhbHVlRm9yVXNlcigpLiBJdCBjYW4gb25s eSBiZSBydW4gdXNpbmcgRHVtcFJlbmRlclRyZWUuCisKK1BBU1MgCisKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvb25jaGFuZ2Utc2V0dmFsdWVmb3J1c2VyLmh0bWwgYi9MYXlv dXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjRkYmI4Zjc5ZTA3NjY2MzQyYTFhZTZhMzc5YjI3Nzg2ZjQ1NTQ1M2MKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL29uY2hhbmdlLXNldHZhbHVlZm9ydXNlci5o dG1sCkBAIC0wLDAgKzEsNDQgQEAKKzxodG1sPgorPGhlYWQ+CisgICAgPHNjcmlwdCBzcmM9Ii4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdD4KKyAg ICBmdW5jdGlvbiB0ZXN0KCkgeworICAgICAgICB2YXIgdGYgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgndGYnKTsKKworICAgICAgICB2YXIgZGlkRmlyZU9uQ2hhbmdlID0gZmFsc2U7CisgICAg ICAgIHRmLm9uY2hhbmdlID0gZnVuY3Rpb24oKSB7CisgICAgICAgICAgZGlkRmlyZU9uQ2hhbmdl ID0gdHJ1ZTsKKyAgICAgICAgfQorCisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK KyAgICAgICAgfQorCisgICAgICAgIHRmLmZvY3VzKCk7CisgICAgICAgIGlmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLnNl dFZhbHVlRm9yVXNlcih0ZiwgJ0hlbGxvIScpOworICAgICAgICB9CisKKyAgICAgICAgLy8gU2hv dWxkIG5vdCBmaXJlIHRoZSBldmVudCB1bnRpbCBmb2N1cyBpcyBsb3N0LgorICAgICAgICBpZiAo ZGlkRmlyZU9uQ2hhbmdlKSB7CisgICAgICAgICAgICB0ZXN0RmFpbGVkKCdvbmNoYW5nZSBmaXJl ZCB0b28gZWFybHknKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAg IHRmLmJsdXIoKTsKKyAgICAgICAgaWYgKGRpZEZpcmVPbkNoYW5nZSkgeworICAgICAgICAgICAg dGVzdFBhc3NlZCgnJyk7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICB0ZXN0RmFpbGVk KCdvbmNoYW5nZSBuZXZlciBmaXJlZCcpCisgICAgICAgIH0KKyAgICB9CisgICAgPC9zY3JpcHQ+ Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CisgICAgVGhpcyB0ZXN0cyB0aGF0IG9u Y2hhbmdlIGNvcnJlY3RseSBmaXJlcyBhZnRlciBjYWxsaW5nIHNldFZhbHVlRm9yVXNlcigpLiAg SXQgY2FuIG9ubHkgYmUgcnVuIHVzaW5nIER1bXBSZW5kZXJUcmVlLjxicj4KKyAgICA8Zm9ybSBu YW1lPSJmbSI+CisgICAgICAgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0idGYiIC8+CisgICAgPC9m b3JtPgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCmluZGV4IDA1ZTgzNTY5MTdkODgxZDQ1YTU3MmM1ZDMxYmRlZDI0NzA2MWJhNWIuLmU3MDJl M2QwOWNkNzY5MDk4OTIzMGFlZjYxMmU4NWViYTAxYTNjN2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSw1MSBAQAorMjAxMS0wMy0wMiAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhUTUxJ bnB1dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBldmVudCB3aGVu IHRoZSBlbGVtZW50IGlzIGZvY3VzZWQuCisgICAgICAgIFJlZmFjdG9yZWQgdHJhY2tpbmcgb2Yg ImNoYW5nZWQgc2luY2UgbGFzdCBjaGFuZ2UgZXZlbnQiIHN0YXRlIGZyb20gcmVuZGVyZXIgdG8g RE9NLkluIHNlcnZpY2Ugb2YgaHR0cHM6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS9pc3N1 ZXMKKyAgICAgICAgSW4gc2VydmljZSBvZiBodHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9t aXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy9vbmNo YW5nZS1jaGFuZ2UtdHlwZS5odG1sCisgICAgICAgIFRlc3Q6IGZhc3QvZm9ybXMvb25jaGFuZ2Ut c2V0dmFsdWVmb3J1c2VyLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUuZXhwLmluOgorICAgICAg ICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6c2V0Rm9j dXNlZE5vZGUpOgorICAgICAgICAqIGRvbS9FbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpF bGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6RWxlbWVudDo6c2V0Q2hhbmdlZFNpbmNlTGFzdEZvcm1Db250 cm9sQ2hhbmdlRXZlbnQpOiBBZGRlZC4KKyAgICAgICAgKiBodG1sL0hUTUxGb3JtQ29udHJvbEVs ZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6SFRN TEZvcm1Db250cm9sRWxlbWVudCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRm9ybUNvbnRyb2xF bGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6c2V0Q2hhbmdlZFNp bmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OmRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6 IEFsc28gY2xlYXIgdGhlICJjaGFuZ2VkIHNpbmNlIGxhc3QgY2hhbmdlIGV2ZW50IiBmbGFnLgor ICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0Y2hGb3JtQ29u dHJvbElucHV0RXZlbnQpOiBBbHNvIHNldCB0aGUgImNoYW5nZWQgc2luY2UgbGFzdCBjaGFuZ2Ug ZXZlbnQiIGZsYWcuCisgICAgICAgICogaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50Lmg6Cisg ICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxJbnB1dEVsZW1lbnQ6OnVwZGF0ZVR5cGUpOiBBbHNvIGNsZWFyIHRoZSAiY2hhbmdlZCBzaW5j ZSBsYXN0IGNoYW5nZSBldmVudCIgZmxhZy4KKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVs ZW1lbnQ6OnNldFZhbHVlKToKKyAgICAgICAgICAgIEZvciBhIGZvY3VzZWQgdGV4dCBmaWVsZCwg ZGlzcGF0Y2ggYW4gaW5wdXQgZXZlbnQsIGJ1dCBkZWxheSB0aGUgY2hhbmdlIGV2ZW50IHVudGls IHRoZSBmaWVsZCBsb3NlcyBmb2N1cy4KKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1l bnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxl bWVudDo6c3RlcFVwRnJvbVJlbmRlcmVyKToKKyAgICAgICAgKiBodG1sL3NoYWRvdy9UZXh0Q29u dHJvbElubmVyRWxlbWVudHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2VhcmNoRmllbGRDYW5j ZWxCdXR0b25FbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKToKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVyVGV4dENvbnRyb2wuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyVGV4dENv bnRyb2w6OlJlbmRlclRleHRDb250cm9sKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclRleHRD b250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdlZCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRl eHRDb250cm9sLmg6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sTXVsdGlM aW5lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclRleHRDb250cm9sTXVsdGlMaW5lOjpz dWJ0cmVlSGFzQ2hhbmdlZCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9s U2luZ2xlTGluZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJUZXh0Q29udHJvbFNpbmds ZUxpbmU6OnN1YnRyZWVIYXNDaGFuZ2VkKToKKyAgICAgICAgKiB3bWwvV01MSW5wdXRFbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6V01MSW5wdXRFbGVtZW50 KToKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxl cik6CisgICAgICAgICogd21sL1dNTElucHV0RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6 V01MSW5wdXRFbGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVu dCk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVtZW50OjpzZXRDaGFuZ2Vk U2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCk6IEFkZGVkLgorCiAyMDExLTAzLTAyICBN T1JJVEEgSGFqaW1lICA8bW9ycml0YUBnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEtlbnQgVGFtdXJhLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4g Yi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCA0MGYxNmNlOThjZWQyMjRmYTY4 NGE3NTA4NjQwYmU0ZTg1YjVkODAwLi4yODViMTA2M2NkZTRlODhiMDA5NjQ3MDZlZjBkMDYyNTJl MTY4MGE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgorKysgYi9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgpAQCAtMzYzLDYgKzM2Myw3IEBAIF9fWk43V2Vi Q29yZTE0U2VjdXJpdHlPcmlnaW4zMnJlbW92ZU9yaWdpbkFjY2Vzc1doaXRlbGlzdEVudHJ5RVJL UzBfUktOM1dURjZTdHJpCiBfX1pON1dlYkNvcmUxNFNlY3VyaXR5T3JpZ2luNDBzZXREb21haW5S ZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJMU2NoZW1lRWJSS04zV1RGNlN0cmluZ0UKIF9fWk43V2Vi Q29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTjNXVEY2U3RyaW5nRVM0X2kKIF9fWk43V2Vi Q29yZTE0U2VjdXJpdHlPcmlnaW42Y3JlYXRlRVJLTlNfNEtVUkxFaQorX19aTjdXZWJDb3JlMTR0 b0lucHV0RWxlbWVudEVQTlNfN0VsZW1lbnRFCiBfX1pON1dlYkNvcmUxNUFyY2hpdmVSZXNvdXJj ZTZjcmVhdGVFTjNXVEYxMFBhc3NSZWZQdHJJTlNfMTJTaGFyZWRCdWZmZXJFRUVSS05TXzRLVVJM RVJLTlMxXzZTdHJpbmdFU0FfU0FfUktOU18xNlJlc291cmNlUmVzcG9uc2VFCiBfX1pON1dlYkNv cmUxNURPTVdyYXBwZXJXb3JsZDEzY2xlYXJXcmFwcGVyc0V2CiBfX1pON1dlYkNvcmUxNURPTVdy YXBwZXJXb3JsZEQxRXYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IGY0NWQ2Y2ZjOWIwMGYy Y2YwMDQ3YzBlZjM4YWNkODgzY2VkNDcyZDAuLjg1NWE3OTIxYmVmOTJlMWJkYWI4ZDhmNGFjNDI2 NTIxZmJmZDcwYzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcApAQCAtMzE4MywxMiArMzE4Mywx MCBAQCBib29sIERvY3VtZW50OjpzZXRGb2N1c2VkTm9kZShQYXNzUmVmUHRyPE5vZGU+IG5ld0Zv Y3VzZWROb2RlKQogICAgICAgICBvbGRGb2N1c2VkTm9kZS0+c2V0Rm9jdXMoZmFsc2UpOwogCiAg ICAgICAgIC8vIERpc3BhdGNoIGEgY2hhbmdlIGV2ZW50IGZvciB0ZXh0IGZpZWxkcyBvciB0ZXh0 YXJlYXMgdGhhdCBoYXZlIGJlZW4gZWRpdGVkCi0gICAgICAgIFJlbmRlck9iamVjdCogciA9IG9s ZEZvY3VzZWROb2RlLT5yZW5kZXJlcigpOwotICAgICAgICBpZiAociAmJiByLT5pc1RleHRDb250 cm9sKCkgJiYgdG9SZW5kZXJUZXh0Q29udHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5n ZUV2ZW50KCkpIHsKLSAgICAgICAgICAgIHN0YXRpY19jYXN0PEVsZW1lbnQqPihvbGRGb2N1c2Vk Tm9kZS5nZXQoKSktPmRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAgICAgICAg ICAgciA9IG9sZEZvY3VzZWROb2RlLT5yZW5kZXJlcigpOwotICAgICAgICAgICAgaWYgKHIgJiYg ci0+aXNUZXh0Q29udHJvbCgpKQotICAgICAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wo ciktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudChmYWxzZSk7CisgICAgICAgIGlmIChv bGRGb2N1c2VkTm9kZS0+aXNFbGVtZW50Tm9kZSgpKSB7CisgICAgICAgICAgICBFbGVtZW50KiBl bGVtZW50ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG9sZEZvY3VzZWROb2RlLmdldCgpKTsKKyAg ICAgICAgICAgIGlmIChlbGVtZW50LT53YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFu Z2VFdmVudCgpKQorICAgICAgICAgICAgICAgIGVsZW1lbnQtPmRpc3BhdGNoRm9ybUNvbnRyb2xD aGFuZ2VFdmVudCgpOwogICAgICAgICB9CiAKICAgICAgICAgLy8gRGlzcGF0Y2ggdGhlIGJsdXIg ZXZlbnQgYW5kIGxldCB0aGUgbm9kZSBkbyBhbnkgb3RoZXIgYmx1ciByZWxhdGVkIGFjdGl2aXRp ZXMgKGltcG9ydGFudCBmb3IgdGV4dCBmaWVsZHMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9kb20vRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAKaW5kZXgg YWFiMDhlODdhYmY5ODY4ZmJhMDJmZDgyZmViNmQzYWIzZGY3NDZkZS4uYjljYjNhZGRkNjZjMTVl MTNiZDQ4MjkyMTFlZmZlNjYzZjJkZjg4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZG9t L0VsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmNwcApAQCAtODg4 LDYgKzg4OCwxNCBAQCBSZW5kZXJPYmplY3QqIEVsZW1lbnQ6OmNyZWF0ZVJlbmRlcmVyKFJlbmRl ckFyZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqIHN0eWxlKQogICAgIHJldHVybiBSZW5kZXJPYmpl Y3Q6OmNyZWF0ZU9iamVjdCh0aGlzLCBzdHlsZSk7CiB9CiAKK2Jvb2wgRWxlbWVudDo6d2FzQ2hh bmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoKSBjb25zdAoreworICAgIHJldHVy biBmYWxzZTsKK30KKwordm9pZCBFbGVtZW50OjpzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRy b2xDaGFuZ2VFdmVudChib29sKQoreworfQogCiB2b2lkIEVsZW1lbnQ6Omluc2VydGVkSW50b0Rv Y3VtZW50KCkKIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmggYi9T b3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5oCmluZGV4IDc1MWU3ZTkzNjIyYzQ5MDY3MjMxMzU5 ZDQyZDNlN2E5ZmNmNzk2NmEuLmY3OTYzNTM2YmY5ZjA1YjBmZDQzMjJjZTFiMjg5YzRhMWFkZjRh NDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmgKKysrIGIvU291cmNl L1dlYkNvcmUvZG9tL0VsZW1lbnQuaApAQCAtMzI2LDYgKzMyNiw4IEBAIHB1YmxpYzoKICAgICB2 aXJ0dWFsIGJvb2wgc2F2ZUZvcm1Db250cm9sU3RhdGUoU3RyaW5nJikgY29uc3QgeyByZXR1cm4g ZmFsc2U7IH0KICAgICB2aXJ0dWFsIHZvaWQgcmVzdG9yZUZvcm1Db250cm9sU3RhdGUoY29uc3Qg U3RyaW5nJikgeyB9CiAKKyAgICB2aXJ0dWFsIGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdEZvcm1D b250cm9sQ2hhbmdlRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0Q2hhbmdlZFNp bmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lkIGRp c3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpIHsgfQogCiAjaWYgRU5BQkxFKFNWRykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCmluZGV4IDU4 ZWM1NTQwYjY3MjIxYzM3Y2MyNDYyODg5YmVmMzg4NjFiYmFiMTMuLmRiMzRlYzFkODM5MjkzYjI4 ZDRkOWQ4OTY3OTY0ZTdhNjQ5ODRhMjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M Rm9ybUNvbnRyb2xFbGVtZW50LmNwcApAQCAtNjUsNiArNjUsNyBAQCBIVE1MRm9ybUNvbnRyb2xF bGVtZW50OjpIVE1MRm9ybUNvbnRyb2xFbGVtZW50KGNvbnN0IFF1YWxpZmllZE5hbWUmIHRhZ05h bWUsIERvYwogICAgICwgbV93aWxsVmFsaWRhdGVJbml0aWFsaXplZChmYWxzZSkKICAgICAsIG1f d2lsbFZhbGlkYXRlKHRydWUpCiAgICAgLCBtX2lzVmFsaWQodHJ1ZSkKKyAgICAsIG1fd2FzQ2hh bmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoZmFsc2UpCiB7CiAgICAgaWYgKCF0 aGlzLT5mb3JtKCkpCiAgICAgICAgIHNldEZvcm0oZmluZEZvcm1BbmNlc3RvcigpKTsKQEAgLTE4 OCwxMyArMTg5LDI1IEBAIHZvaWQgSFRNTEZvcm1Db250cm9sRWxlbWVudDo6c2V0TmFtZShjb25z dCBBdG9taWNTdHJpbmcmIHZhbHVlKQogICAgIHNldEF0dHJpYnV0ZShuYW1lQXR0ciwgdmFsdWUp OwogfQogCitib29sIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6Ondhc0NoYW5nZWRTaW5jZUxhc3RG b3JtQ29udHJvbENoYW5nZUV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV93YXNDaGFuZ2Vk U2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudDsKK30KKwordm9pZCBIVE1MRm9ybUNvbnRy b2xFbGVtZW50OjpzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudChib29s IGNoYW5nZWQpCit7CisgICAgbV93YXNDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VF dmVudCA9IGNoYW5nZWQ7Cit9CisKIHZvaWQgSFRNTEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0 Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCkKIHsKICAgICBIVE1MRWxlbWVudDo6ZGlzcGF0Y2hD aGFuZ2VFdmVudHMoKTsKKyAgICBzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VF dmVudChmYWxzZSk7CiB9CiAKIHZvaWQgSFRNTEZvcm1Db250cm9sRWxlbWVudDo6ZGlzcGF0Y2hG b3JtQ29udHJvbElucHV0RXZlbnQoKQogeworICAgIHNldENoYW5nZWRTaW5jZUxhc3RGb3JtQ29u dHJvbENoYW5nZUV2ZW50KHRydWUpOwogICAgIEhUTUxFbGVtZW50OjpkaXNwYXRjaElucHV0RXZl bnRzKCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250 cm9sRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50 LmgKaW5kZXggMzY4ZGNmYWQ3ZjRkNjg1MDM4NjRlOGFhY2RlZmZhNGQ4NWRjOWIxZS4uODA0Y2Y5 MDE0ODllYzI1YmZlMjc4ZDQwNWE4N2U2MGUyMWViMGNmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKQEAgLTUyLDYgKzUyLDkgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgYm9vbCBmb3JtQ29udHJvbFZhbHVlTWF0Y2hlc1JlbmRlcmVyKCkgY29uc3Qg eyByZXR1cm4gbV92YWx1ZU1hdGNoZXNSZW5kZXJlcjsgfQogICAgIHZpcnR1YWwgdm9pZCBzZXRG b3JtQ29udHJvbFZhbHVlTWF0Y2hlc1JlbmRlcmVyKGJvb2wgYikgeyBtX3ZhbHVlTWF0Y2hlc1Jl bmRlcmVyID0gYjsgfQogCisgICAgdmlydHVhbCBib29sIHdhc0NoYW5nZWRTaW5jZUxhc3RGb3Jt Q29udHJvbENoYW5nZUV2ZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCB2b2lkIHNldENoYW5nZWRT aW5jZUxhc3RGb3JtQ29udHJvbENoYW5nZUV2ZW50KGJvb2wpOworCiAgICAgdmlydHVhbCB2b2lk IGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwogICAgIHZpcnR1YWwgdm9pZCBkaXNw YXRjaEZvcm1Db250cm9sSW5wdXRFdmVudCgpOwogCkBAIC0xNjEsNiArMTY0LDggQEAgcHJpdmF0 ZToKICAgICAvLyBDYWNoZSBvZiB2YWxpZGl0eSgpLT52YWxpZCgpLgogICAgIC8vIEJ1dCAiY2Fu ZGlkYXRlIGZvciBjb25zdHJhaW50IHZhbGlkYXRpb24iIGRvZXNuJ3QgYWZmZWN0IG1faXNWYWxp ZC4KICAgICBib29sIG1faXNWYWxpZCA6IDE7CisKKyAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNl TGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQgOiAxOwogfTsKIAogLy8gRklYTUU6IEdpdmUgdGhp cyBjbGFzcyBpdHMgb3duIGhlYWRlciBmaWxlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0 RWxlbWVudC5jcHAKaW5kZXggZTEwOTU3OGYzMmIyMzMxODFlMGJiODY0Mzk5NzI2ODBkZjNkMDcz Yy4uZWYyNWQxYzA3NzJhMDRjZGI0NGU1YTk1NjU1ZGNmYzcxZjU2OGI1ZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC00ODksNiArNDg5LDggQEAgdm9pZCBI VE1MSW5wdXRFbGVtZW50Ojp1cGRhdGVUeXBlKCkKICAgICAgICAgICAgIHVwZGF0ZUZvY3VzQXBw ZWFyYW5jZSh0cnVlKTsKICAgICB9CiAKKyAgICBzZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRy b2xDaGFuZ2VFdmVudChmYWxzZSk7CisKICAgICBjaGVja2VkUmFkaW9CdXR0b25zKCkuYWRkQnV0 dG9uKHRoaXMpOwogCiAgICAgc2V0TmVlZHNWYWxpZGl0eUNoZWNrKCk7CkBAIC04ODksMTAgKzg5 MSwxNCBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlKGNvbnN0IFN0cmluZyYgdmFs dWUsIGJvb2wgc2VuZENoYW5nZUV2ZW50KQogICAgIH0KICAgICBtX2lucHV0VHlwZS0+dmFsdWVD aGFuZ2VkKCk7CiAKLSAgICAvLyBEb24ndCBkaXNwYXRjaCB0aGUgY2hhbmdlIGV2ZW50IHdoZW4g Zm9jdXNlZCwgaXQgd2lsbCBiZSBkaXNwYXRjaGVkCi0gICAgLy8gd2hlbiB0aGUgY29udHJvbCBs b3NlcyBmb2N1cy4KLSAgICBpZiAoc2VuZENoYW5nZUV2ZW50ICYmIGRvY3VtZW50KCktPmZvY3Vz ZWROb2RlKCkgIT0gdGhpcykKLSAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50 KCk7CisgICAgaWYgKHNlbmRDaGFuZ2VFdmVudCkgeworICAgICAgICAvLyBJZiB0aGUgdXNlciBp cyBzdGlsbCBlZGl0aW5nIHRoaXMgZmllbGQsIGRpc3BhdGNoIGFuIGlucHV0IGV2ZW50IHJhdGhl ciB0aGFuIGEgY2hhbmdlIGV2ZW50LgorICAgICAgICAvLyBUaGUgY2hhbmdlIGV2ZW50IHdpbGwg YmUgZGlzcGF0Y2hlZCB3aGVuIGVkaXRpbmcgZmluaXNoZXMuCisgICAgICAgIGlmIChpc1RleHRG aWVsZCgpICYmIGZvY3VzZWQoKSkKKyAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xJbnB1 dEV2ZW50KCk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xD aGFuZ2VFdmVudCgpOworICAgIH0KIAogICAgIElucHV0RWxlbWVudDo6bm90aWZ5Rm9ybVN0YXRl Q2hhbmdlZCh0aGlzKTsKIH0KQEAgLTEwMzMsMTUgKzEwMzksMTAgQEAgdm9pZCBIVE1MSW5wdXRF bGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCiAgICAgICAgICAgICBhZGRT ZWFyY2hSZXN1bHQoKTsKICAgICAgICAgICAgIG9uU2VhcmNoKCk7CiAgICAgICAgIH0KLSAgICAg ICAgLy8gRmlyZSBvbkNoYW5nZSBmb3IgdGV4dCBmaWVsZHMuCi0gICAgICAgIFJlbmRlck9iamVj dCogciA9IHJlbmRlcmVyKCk7Ci0gICAgICAgIGlmIChyICYmIHItPmlzVGV4dEZpZWxkKCkgJiYg dG9SZW5kZXJUZXh0Q29udHJvbChyKS0+d2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KCkp IHsKKyAgICAgICAgLy8gRm9ybSBzdWJtaXNzaW9uIGZpbmlzaGVzIGVkaXRpbmcsIGp1c3QgYXMg bG9zcyBvZiBmb2N1cyBkb2VzLgorICAgICAgICAvLyBJZiB0aGVyZSB3YXMgYSBjaGFuZ2UsIHNl bmQgdGhlIGV2ZW50IG5vdy4KKyAgICAgICAgaWYgKHdhc0NoYW5nZWRTaW5jZUxhc3RGb3JtQ29u dHJvbENoYW5nZUV2ZW50KCkpCiAgICAgICAgICAgICBkaXNwYXRjaEZvcm1Db250cm9sQ2hhbmdl RXZlbnQoKTsKLSAgICAgICAgICAgIC8vIFJlZmV0Y2ggdGhlIHJlbmRlcmVyIHNpbmNlIGFyYml0 cmFyeSBKUyBjb2RlIHJ1biBkdXJpbmcgb25jaGFuZ2UgY2FuIGRvIGFueXRoaW5nLCBpbmNsdWRp bmcgZGVzdHJveWluZyBpdC4KLSAgICAgICAgICAgIHIgPSByZW5kZXJlcigpOwotICAgICAgICAg ICAgaWYgKHIgJiYgci0+aXNUZXh0RmllbGQoKSkKLSAgICAgICAgICAgICAgICB0b1JlbmRlclRl eHRDb250cm9sKHIpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpOwotICAg ICAgICB9CiAKICAgICAgICAgUmVmUHRyPEhUTUxGb3JtRWxlbWVudD4gZm9ybUZvclN1Ym1pc3Np b24gPSBtX2lucHV0VHlwZS0+Zm9ybUZvclN1Ym1pc3Npb24oKTsKICAgICAgICAgLy8gRm9ybSBt YXkgbmV2ZXIgaGF2ZSBiZWVuIHByZXNlbnQsIG9yIG1heSBoYXZlIGJlZW4gZGVzdHJveWVkIGJ5 IGNvZGUgcmVzcG9uZGluZyB0byB0aGUgY2hhbmdlIGV2ZW50LgpAQCAtMTQxNSw4ICsxNDE2LDYg QEAgdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpzdGVwVXBGcm9tUmVuZGVyZXIoaW50IG4pCiAgICAg fQogCiAgICAgaWYgKGN1cnJlbnRTdHJpbmdWYWx1ZSAhPSB2YWx1ZSgpKSB7Ci0gICAgICAgIGlm IChyZW5kZXJlcigpICYmIHJlbmRlcmVyKCktPmlzVGV4dEZpZWxkKCkpCi0gICAgICAgICAgICB0 b1JlbmRlclRleHRDb250cm9sKHJlbmRlcmVyKCkpLT5zZXRDaGFuZ2VkU2luY2VMYXN0Q2hhbmdl RXZlbnQodHJ1ZSk7CiAgICAgICAgIGlmIChtX2lucHV0VHlwZS0+aXNSYW5nZUNvbnRyb2woKSkK ICAgICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwogICAgICAgICBl bHNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0Q29udHJvbElu bmVyRWxlbWVudHMuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dENvbnRyb2xJ bm5lckVsZW1lbnRzLmNwcAppbmRleCAwN2Y1MzlkYTU0Njg2ZGY1ZjIxYzMzMDBlZmMxNWFjMWVh ODIzYWI2Li45NjhjNWU0ODVhZTQ3OWZkMTY1MmJhMzQzOTNhZTM2NzgyOGYzMTc3IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0Q29udHJvbElubmVyRWxlbWVudHMu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRDb250cm9sSW5uZXJFbGVt ZW50cy5jcHAKQEAgLTIxMSwxMSArMjExLDcgQEAgdm9pZCBTZWFyY2hGaWVsZENhbmNlbEJ1dHRv bkVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogICAgICAgICAgICAg fQogICAgICAgICAgICAgaWYgKGhvdmVyZWQoKSkgewogICAgICAgICAgICAgICAgIFN0cmluZyBv bGRWYWx1ZSA9IGlucHV0LT52YWx1ZSgpOwotICAgICAgICAgICAgICAgIGlucHV0LT5zZXRWYWx1 ZSgiIik7Ci0gICAgICAgICAgICAgICAgaWYgKCFvbGRWYWx1ZS5pc0VtcHR5KCkpIHsKLSAgICAg ICAgICAgICAgICAgICAgdG9SZW5kZXJUZXh0Q29udHJvbChpbnB1dC0+cmVuZGVyZXIoKSktPnNl dENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVudCh0cnVlKTsKLSAgICAgICAgICAgICAgICAgICAg aW5wdXQtPmRpc3BhdGNoRm9ybUNvbnRyb2xJbnB1dEV2ZW50KCk7Ci0gICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgIGlucHV0LT5zZXRWYWx1ZUZvclVzZXIoIiIpOwogICAgICAgICAg ICAgICAgIGlucHV0LT5vblNlYXJjaCgpOwogICAgICAgICAgICAgICAgIGV2ZW50LT5zZXREZWZh dWx0SGFuZGxlZCgpOwogICAgICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJUZXh0Q29udHJvbC5jcHAKaW5kZXggMTZjMDI0N2RhZjFiMzAxZGQxYWY2YzJjODUw MzEzYjQ2MjFiM2QxNC4uODE0OWY2Y2M2NjQ2MTdkOGExYTA4ZDQ4YWM1MTllNTcyOWMxMzRmYiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuY3BwCkBA IC03NCw3ICs3NCw2IEBAIHN0YXRpYyBDb2xvciBkaXNhYmxlZFRleHRDb2xvcihjb25zdCBDb2xv ciYgdGV4dENvbG9yLCBjb25zdCBDb2xvciYgYmFja2dyb3VuZENvCiBSZW5kZXJUZXh0Q29udHJv bDo6UmVuZGVyVGV4dENvbnRyb2woTm9kZSogbm9kZSwgYm9vbCBwbGFjZWhvbGRlclZpc2libGUp CiAgICAgOiBSZW5kZXJCbG9jayhub2RlKQogICAgICwgbV9wbGFjZWhvbGRlclZpc2libGUocGxh Y2Vob2xkZXJWaXNpYmxlKQotICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQo ZmFsc2UpCiAgICAgLCBtX2xhc3RDaGFuZ2VXYXNVc2VyRWRpdChmYWxzZSkKIHsKIH0KQEAgLTM1 MSw3ICszNTAsNiBAQCBpbnQgUmVuZGVyVGV4dENvbnRyb2w6OmluZGV4Rm9yVmlzaWJsZVBvc2l0 aW9uKGNvbnN0IFZpc2libGVQb3NpdGlvbiYgcG9zKSBjb25zdAogCiB2b2lkIFJlbmRlclRleHRD b250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdlZCgpCiB7Ci0gICAgbV93YXNDaGFuZ2VkU2luY2VMYXN0 Q2hhbmdlRXZlbnQgPSB0cnVlOwogICAgIG1fbGFzdENoYW5nZVdhc1VzZXJFZGl0ID0gdHJ1ZTsK IH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250 cm9sLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuaAppbmRl eCBjZDg4MTJlNjg2OTdmZjU5MzczMjI3OThiZGU2MzY5YjM1MWMxMGMwLi4wYzMwZWQ2NGE4NTFi MDk2OTg1Y2RhOWI5NzVjMWZlOGNhZTY4NzAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyVGV4dENvbnRyb2wuaApAQCAtMzYsOSArMzYsNiBAQCBwdWJsaWM6CiAKICAgICBI VE1MRWxlbWVudCogaW5uZXJUZXh0RWxlbWVudCgpIGNvbnN0OwogCi0gICAgYm9vbCB3YXNDaGFu Z2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoKSBjb25zdCB7IHJldHVybiBtX3dhc0NoYW5nZWRTaW5j ZUxhc3RDaGFuZ2VFdmVudDsgfQotICAgIHZvaWQgc2V0Q2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2 ZW50KGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50KSB7IG1fd2FzQ2hhbmdlZFNp bmNlTGFzdENoYW5nZUV2ZW50ID0gd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OyB9Ci0K ICAgICBib29sIGxhc3RDaGFuZ2VXYXNVc2VyRWRpdCgpIGNvbnN0IHsgcmV0dXJuIG1fbGFzdENo YW5nZVdhc1VzZXJFZGl0OyB9CiAgICAgdm9pZCBzZXRMYXN0Q2hhbmdlV2FzVXNlckVkaXQoYm9v bCBsYXN0Q2hhbmdlV2FzVXNlckVkaXQpOwogCkBAIC0xMTUsNyArMTEyLDYgQEAgcHJpdmF0ZToK IAogICAgIHZvaWQgcGFpbnRQbGFjZWhvbGRlcihQYWludEluZm8mLCBpbnQgdHgsIGludCB0eSk7 CiAKLSAgICBib29sIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OwogICAgIGJvb2wg bV9sYXN0Q2hhbmdlV2FzVXNlckVkaXQ7CiAgICAgUmVmUHRyPFRleHRDb250cm9sSW5uZXJUZXh0 RWxlbWVudD4gbV9pbm5lclRleHQ7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlclRleHRDb250cm9sTXVsdGlMaW5lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbE11bHRpTGluZS5jcHAKaW5kZXggMGQ1MTJmMzYyMTAw N2ZjNTc1NmFlMTYxNWE5ZDE2YWFhZDdlM2Q2Zi4uNTU0YjY2N2QyYzY2MGFkM2UzOWUzODlkZTBk ZDNkZGU0ZDM2ZTcxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl clRleHRDb250cm9sTXVsdGlMaW5lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyVGV4dENvbnRyb2xNdWx0aUxpbmUuY3BwCkBAIC00Niw2ICs0Niw3IEBAIHZvaWQgUmVu ZGVyVGV4dENvbnRyb2xNdWx0aUxpbmU6OnN1YnRyZWVIYXNDaGFuZ2VkKCkKIHsKICAgICBSZW5k ZXJUZXh0Q29udHJvbDo6c3VidHJlZUhhc0NoYW5nZWQoKTsKICAgICBIVE1MVGV4dEFyZWFFbGVt ZW50KiB0ZXh0QXJlYSA9IHN0YXRpY19jYXN0PEhUTUxUZXh0QXJlYUVsZW1lbnQqPihub2RlKCkp OworICAgIHRleHRBcmVhLT5zZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVu dCh0cnVlKTsKICAgICB0ZXh0QXJlYS0+c2V0Rm9ybUNvbnRyb2xWYWx1ZU1hdGNoZXNSZW5kZXJl cihmYWxzZSk7CiAgICAgdGV4dEFyZWEtPnNldE5lZWRzVmFsaWRpdHlDaGVjaygpOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVM aW5lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmds ZUxpbmUuY3BwCmluZGV4IDI4NTNlNzhlNTBiNTViNTE4ZWQ4ZDU0MDBmZjlmZWQ5YTUzNmJiYjQu LmIzMTU3MDA2NGZmODJjYjAxMmM2N2Y2MjdlNjk4ZDRjYjg0M2Q4NzQgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUu Y3BwCkBAIC0xODEsOSArMTgxLDEzIEBAIHZvaWQgUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVMaW5l OjpoaWRlUG9wdXAoKQogCiB2b2lkIFJlbmRlclRleHRDb250cm9sU2luZ2xlTGluZTo6c3VidHJl ZUhhc0NoYW5nZWQoKQogewotICAgIGJvb2wgd2FzQ2hhbmdlZCA9IHdhc0NoYW5nZWRTaW5jZUxh c3RDaGFuZ2VFdmVudCgpOwogICAgIFJlbmRlclRleHRDb250cm9sOjpzdWJ0cmVlSGFzQ2hhbmdl ZCgpOwogCisgICAgQVNTRVJUKG5vZGUoKS0+aXNFbGVtZW50Tm9kZSgpKTsKKyAgICBFbGVtZW50 KiBlbGVtZW50ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG5vZGUoKSk7CisgICAgYm9vbCB3YXND aGFuZ2VkID0gZWxlbWVudC0+d2FzQ2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZl bnQoKTsKKyAgICBlbGVtZW50LT5zZXRDaGFuZ2VkU2luY2VMYXN0Rm9ybUNvbnRyb2xDaGFuZ2VF dmVudCh0cnVlKTsKKwogICAgIElucHV0RWxlbWVudCogaW5wdXQgPSBpbnB1dEVsZW1lbnQoKTsK ICAgICAvLyBXZSBkb24ndCBuZWVkIHRvIGNhbGwgc2FuaXRpemVVc2VySW5wdXRWYWx1ZSgpIGZ1 bmN0aW9uIGhlcmUgYmVjYXVzZQogICAgIC8vIElucHV0RWxlbWVudDo6aGFuZGxlQmVmb3JlVGV4 dEluc2VydGVkRXZlbnQoKSBoYXMgYWxyZWFkeSBjYWxsZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvd21sL1dNTElu cHV0RWxlbWVudC5jcHAKaW5kZXggNjg3YTM4NzI1NWIxMDEwYjVlOTE3NTliYTYwZjVmZTMyYTNl NzI2OS4uODBlNGU3MGQxMDMxMjAyNDU1MTJkM2FkZmFlMTFkMTA2ZmIzNjQ1MyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKQEAgLTQxLDYgKzQxLDcgQEAgV01MSW5wdXRF bGVtZW50OjpXTUxJbnB1dEVsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYgdGFnTmFtZSwgRG9j dW1lbnQqIGRvYykKICAgICA6IFdNTEZvcm1Db250cm9sRWxlbWVudCh0YWdOYW1lLCBkb2MpCiAg ICAgLCBtX2lzUGFzc3dvcmRGaWVsZChmYWxzZSkKICAgICAsIG1faXNFbXB0eU9rKGZhbHNlKQor ICAgICwgbV93YXNDaGFuZ2VkU2luY2VMYXN0Q2hhbmdlRXZlbnQoZmFsc2UpCiAgICAgLCBtX251 bU9mQ2hhcnNBbGxvd2VkQnlNYXNrKDApCiB7CiB9CkBAIC0xNzMsNiArMTc0LDE2IEBAIHZvaWQg V01MSW5wdXRFbGVtZW50OjpzZXRWYWx1ZUZyb21SZW5kZXJlcihjb25zdCBTdHJpbmcmIHZhbHVl KQogICAgIElucHV0RWxlbWVudDo6c2V0VmFsdWVGcm9tUmVuZGVyZXIobV9kYXRhLCB0aGlzLCB0 aGlzLCB2YWx1ZSk7CiB9CiAKK2Jvb2wgV01MSW5wdXRFbGVtZW50Ojp3YXNDaGFuZ2VkU2luY2VM YXN0Rm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fd2FzQ2hh bmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50OworfQorCit2b2lkIFdNTElucHV0RWxlbWVudDo6c2V0 Q2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoYm9vbCBjaGFuZ2VkKQorewor ICAgIG1fd2FzQ2hhbmdlZFNpbmNlTGFzdENoYW5nZUV2ZW50ID0gY2hhbmdlZDsKK30KKwogYm9v bCBXTUxJbnB1dEVsZW1lbnQ6OnNhdmVGb3JtQ29udHJvbFN0YXRlKFN0cmluZyYgcmVzdWx0KSBj b25zdAogewogICAgIGlmIChtX2lzUGFzc3dvcmRGaWVsZCkKQEAgLTI5NiwxNCArMzA3LDkgQEAg dm9pZCBXTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2dCkKIAog ICAgIGlmIChjbGlja0RlZmF1bHRGb3JtQnV0dG9uKSB7CiAgICAgICAgIC8vIEZpcmUgb25DaGFu Z2UgZm9yIHRleHQgZmllbGRzLgotICAgICAgICBSZW5kZXJPYmplY3QqIHIgPSByZW5kZXJlcigp OwotICAgICAgICBpZiAociAmJiB0b1JlbmRlclRleHRDb250cm9sKHIpLT53YXNDaGFuZ2VkU2lu Y2VMYXN0Q2hhbmdlRXZlbnQoKSkgeworICAgICAgICBpZiAod2FzQ2hhbmdlZFNpbmNlTGFzdENo YW5nZUV2ZW50KCkpIHsKKyAgICAgICAgICAgIHNldENoYW5nZWRTaW5jZUxhc3RDaGFuZ2VFdmVu dChmYWxzZSk7CiAgICAgICAgICAgICBkaXNwYXRjaEV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnRO YW1lcygpLmNoYW5nZUV2ZW50LCB0cnVlLCBmYWxzZSkpOwotICAgICAgICAgICAgCi0gICAgICAg ICAgICAvLyBSZWZldGNoIHRoZSByZW5kZXJlciBzaW5jZSBhcmJpdHJhcnkgSlMgY29kZSBydW4g ZHVyaW5nIG9uY2hhbmdlIGNhbiBkbyBhbnl0aGluZywgaW5jbHVkaW5nIGRlc3Ryb3lpbmcgaXQu Ci0gICAgICAgICAgICByID0gcmVuZGVyZXIoKTsKLSAgICAgICAgICAgIGlmIChyKQotICAgICAg ICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wociktPnNldENoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudChmYWxzZSk7CiAgICAgICAgIH0KIAogICAgICAgICBldnQtPnNldERlZmF1bHRIYW5k bGVkKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS93bWwvV01MSW5wdXRFbGVtZW50Lmgg Yi9Tb3VyY2UvV2ViQ29yZS93bWwvV01MSW5wdXRFbGVtZW50LmgKaW5kZXggMTE2MmFjMTkzYzcz N2UxNTQ2ZGI4NjM5ZTI2ZDdjYjVlN2RhZjRkNS4uNTU4MTQ3YTE1ZjA1OThjNDY4OTNiMDRkOTVj NjBmNWJlZDhjM2I0YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvd21sL1dNTElucHV0RWxl bWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuaApAQCAtNjcs NiArNjcsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTdHJpbmcgY29udmVydEZyb21WaXNpYmxl VmFsdWUoY29uc3QgU3RyaW5nJiB2YWx1ZSkgY29uc3QgeyByZXR1cm4gdmFsdWU7IH0KICAgICB2 aXJ0dWFsIHZvaWQgc2V0VmFsdWVGcm9tUmVuZGVyZXIoY29uc3QgU3RyaW5nJik7CiAKKyAgICB2 aXJ0dWFsIGJvb2wgd2FzQ2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoKSBj b25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0Q2hhbmdlZFNpbmNlTGFzdEZvcm1Db250cm9sQ2hh bmdlRXZlbnQoYm9vbCk7CisKICAgICB2aXJ0dWFsIGJvb2wgc2F2ZUZvcm1Db250cm9sU3RhdGUo U3RyaW5nJiB2YWx1ZSkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIHJlc3RvcmVGb3JtQ29udHJv bFN0YXRlKGNvbnN0IFN0cmluZyYpOwogCkBAIC0xMTAsNiArMTEzLDcgQEAgcHJpdmF0ZToKICAg ICBJbnB1dEVsZW1lbnREYXRhIG1fZGF0YTsKICAgICBib29sIG1faXNQYXNzd29yZEZpZWxkOwog ICAgIGJvb2wgbV9pc0VtcHR5T2s7CisgICAgYm9vbCBtX3dhc0NoYW5nZWRTaW5jZUxhc3RDaGFu Z2VFdmVudDsKICAgICBTdHJpbmcgbV9mb3JtYXRNYXNrOwogICAgIHVuc2lnbmVkIG1fbnVtT2ZD aGFyc0FsbG93ZWRCeU1hc2s7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9tYWMvQ2hh bmdlTG9nIGIvU291cmNlL1dlYktpdC9tYWMvQ2hhbmdlTG9nCmluZGV4IDI3NzBhYjg2M2Q4Mzg3 YWVhMGMyOWRiMDBkNTIzMjg4OTM3NDFjYjMuLjAxNzA4MjYyZTI2NjE1NjczZWI2YTlmYmZlMmNh ZjJhYTYxZGUxZGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMS0wMy0w MiAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZh bHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBldmVudCB3aGVuIHRoZSBlbGVtZW50IGlzIGZv Y3VzZWQKKyAgICAgICAgSW4gc2VydmljZSBvZiBodHRwczovL2NvZGUuZ29vZ2xlLmNvbS9wL2No cm9taXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisKKyAgICAgICAgKiBET00vV2ViRE9NT3BlcmF0 aW9ucy5tbToKKyAgICAgICAgKC1bRE9NSFRNTElucHV0RWxlbWVudCBfc2V0VmFsdWVGb3JVc2Vy Ol0pOiBFeHBvc2UgSFRNTElucHV0RWxlbWVudDo6c2V0VmFsdWVGb3JVc2VyKCkgdG8gdGVzdHMK KyAgICAgICAgKiBET00vV2ViRE9NT3BlcmF0aW9uc1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJW aWV3L1dlYlZpZXdJbnRlcm5hbC5oOgorCiAyMDExLTAzLTAyICBKZXNzaWUgQmVybGluICA8amJl cmxpbkBhcHBsZS5jb20+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgRGFuIEJlcm5zdGVp bi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL0RPTS9XZWJET01PcGVyYXRpb25zLm1t IGIvU291cmNlL1dlYktpdC9tYWMvRE9NL1dlYkRPTU9wZXJhdGlvbnMubW0KaW5kZXggNWUwOTMw ODNlYzI2MDRhMjgzNTAyOGEwMTExMmU1NDU0ZmJhMzRlZC4uZjA0M2UyZjZjYWQyZTEwZjAwZjRh NjY1OTE3MzZkNzQ3ZTMzYzVkZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvRE9NL1dl YkRPTU9wZXJhdGlvbnMubW0KKysrIGIvU291cmNlL1dlYktpdC9tYWMvRE9NL1dlYkRPTU9wZXJh dGlvbnMubW0KQEAgLTM5LDYgKzM5LDcgQEAKICNpbXBvcnQgIldlYktpdE5TU3RyaW5nRXh0cmFz LmgiCiAjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9BUElDYXN0Lmg+CiAjaW1wb3J0IDxXZWJDb3Jl L0RvY3VtZW50Lmg+CisjaW1wb3J0IDxXZWJDb3JlL0hUTUxJbnB1dEVsZW1lbnQuaD4KICNpbXBv cnQgPFdlYkNvcmUvSFRNTFBhcnNlcklkaW9tcy5oPgogI2ltcG9ydCA8V2ViQ29yZS9KU0VsZW1l bnQuaD4KICNpbXBvcnQgPFdlYkNvcmUvTGVnYWN5V2ViQXJjaGl2ZS5oPgpAQCAtMTk0LDYgKzE5 NSwxNSBAQCB1c2luZyBuYW1lc3BhY2UgSlNDOwogCiBAZW5kCiAKK0BpbXBsZW1lbnRhdGlvbiBE T01IVE1MSW5wdXRFbGVtZW50IChXZWJET01IVE1MSW5wdXRFbGVtZW50T3BlcmF0aW9uc1ByaXZh dGUpCisKKy0gKHZvaWQpX3NldFZhbHVlRm9yVXNlcjooTlNTdHJpbmcgKil2YWx1ZQoreworICAg IHN0YXRpY19jYXN0PEhUTUxJbnB1dEVsZW1lbnQqPihjb3JlKHNlbGYpKS0+c2V0VmFsdWVGb3JV c2VyKHZhbHVlKTsKK30KKworQGVuZAorCiBAaW1wbGVtZW50YXRpb24gRE9NSFRNTE9iamVjdEVs ZW1lbnQgKFdlYkRPTUhUTUxPYmplY3RFbGVtZW50T3BlcmF0aW9ucykKIAogLSAoV2ViRnJhbWUg Kiljb250ZW50RnJhbWUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL0RPTS9XZWJET01P cGVyYXRpb25zUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9tYWMvRE9NL1dlYkRPTU9wZXJhdGlv bnNQcml2YXRlLmgKaW5kZXggMWMyMmU4MjYyMjI2NTZjMzFhNWNjM2E3ZGVlNzU1NjBmNjY0Mzlj Yy4uZGMxYWFmODMxYzZmNGJlYjlkNDI5YWRkMzY1N2VjYjZmZjM2ZjcyZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9tYWMvRE9NL1dlYkRPTU9wZXJhdGlvbnNQcml2YXRlLmgKKysrIGIvU291 cmNlL1dlYktpdC9tYWMvRE9NL1dlYkRPTU9wZXJhdGlvbnNQcml2YXRlLmgKQEAgLTM4LDYgKzM4 LDEwIEBACiAtIChOU0FycmF5ICopX2ZvY3VzYWJsZU5vZGVzOwogQGVuZAogCitAaW50ZXJmYWNl IERPTUhUTUxJbnB1dEVsZW1lbnQgKFdlYkRPTUhUTUxJbnB1dEVsZW1lbnRPcGVyYXRpb25zUHJp dmF0ZSkKKy0gKHZvaWQpX3NldFZhbHVlRm9yVXNlcjooTlNTdHJpbmcgKil2YWx1ZTsKK0BlbmQK KwogQGludGVyZmFjZSBET01Ob2RlIChXZWJET01Ob2RlT3BlcmF0aW9uc1BlbmRpbmdQdWJsaWMp CiAtIChOU1N0cmluZyAqKW1hcmt1cFN0cmluZzsKIC0gKE5TUmVjdClfcmVuZGVyUmVjdDooYm9v bCAqKWlzUmVwbGFjZWQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L21hYy9XZWJWaWV3L1dl YlZpZXdJbnRlcm5hbC5oIGIvU291cmNlL1dlYktpdC9tYWMvV2ViVmlldy9XZWJWaWV3SW50ZXJu YWwuaAppbmRleCA1NTVjNGQxMTBlZDBiZmM5Y2ZiNjVkYzk2MmYwYjI4MTEwOTcyNzg3Li5hMjMx MDI0NWFkOWIwZDQyN2NjZGY1MzkyY2RmNjQ1MDI5ODJiNGMzIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L21hYy9XZWJWaWV3L1dlYlZpZXdJbnRlcm5hbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQv bWFjL1dlYlZpZXcvV2ViVmlld0ludGVybmFsLmgKQEAgLTE5NCw2ICsxOTQsNCBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAtICh2b2lkKV9mdWxsU2NyZWVuUmVuZGVyZXJDaGFuZ2VkOihXZWJDb3Jl OjpSZW5kZXJCb3gqKXJlbmRlcmVyOwogI2VuZGlmCiAKLS0gKEpTVmFsdWVSZWYpX2NvbXB1dGVk U3R5bGVJbmNsdWRpbmdWaXNpdGVkSW5mbzooSlNDb250ZXh0UmVmKWNvbnRleHQgZm9yRWxlbWVu dDooSlNWYWx1ZVJlZil2YWx1ZTsKLQogQGVuZApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9n IGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDk3ZDk4OTBhNDQyYjgwYzgwOTM4YmJiYTQzNjJmOTQw ZGNiYTc0MzIuLjYzZTJjMmFjM2EzNGQ5ZTA2YzVkY2ZkYzI3MDk3Y2U2MTk4ODM1OTkgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy NiBAQAorMjAxMS0wMy0wMiAgSWx5YSBTaGVybWFuICA8aXNoZXJtYW5AY2hyb21pdW0ub3JnPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhUTUxJbnB1 dEVsZW1lbnQ6OnNldFZhbHVlKCkgc2hvdWxkIHNjaGVkdWxlIGNoYW5nZSBldmVudCB3aGVuIHRo ZSBlbGVtZW50IGlzIGZvY3VzZWQKKyAgICAgICAgSW4gc2VydmljZSBvZiBodHRwczovL2NvZGUu Z29vZ2xlLmNvbS9wL2Nocm9taXVtL2lzc3Vlcy9kZXRhaWw/aWQ9NDI3MTYKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUzMTYwCisKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6CisgICAgICAgIChzZXRWYWx1 ZUZvclVzZXJDYWxsYmFjayk6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGlj RnVuY3Rpb25zKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxl ci5oOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0 ay5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTog U3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgKiBEdW1wUmVu ZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06CisgICAgICAgIChMYXlvdXRU ZXN0Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogRXhwb3NlIEhUTUxJbnB1dEVsZW1lbnQ6 OnNldFZhbHVlRm9yVXNlcigpIHRvIHRlc3RzCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvcXQv TGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxl cjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBsZW1lbnRhdGlv bi4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4u Y3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFZhbHVlRm9yVXNlcik6IFN0 dWJiZWQgb3V0OyBuZWVkIHJlYWwgaW1wbGVtZW50YXRpb24uCisgICAgICAgICogRHVtcFJlbmRl clRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0 Q29udHJvbGxlcjo6c2V0VmFsdWVGb3JVc2VyKTogU3R1YmJlZCBvdXQ7IG5lZWQgcmVhbCBpbXBs ZW1lbnRhdGlvbi4KKwogMjAxMS0wMy0wMSAgT2phbiBWYWZhaSAgPG9qYW5AY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFJldmlld2VkIGJ5IFRvbnkgQ2hhbmcuCmRpZmYgLS1naXQgYS9Ub29scy9E dW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9Ub29scy9EdW1wUmVuZGVy VHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggNDE2YjlmY2IxMDg1ZmUxY2Q0ODNm ZGQ5MmM2NmQ0YjVkYmE4Njg2ZC4uOWYxODc3YzM3MWMwNmI0M2U1YjM1NDMyYjY2NmM4MTRiZThm YjhiYyAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNw cApAQCAtMTQzMiw2ICsxNDMyLDIxIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIHNldFVzZXJTdHlsZVNo ZWV0TG9jYXRpb25DYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplCiAgICAgcmV0 dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJl ZiBzZXRWYWx1ZUZvclVzZXJDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RS ZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50 LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7 CisgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgorICAgIGlmIChhcmd1bWVudENvdW50ICE9 IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKKworICAg IEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiB2YWx1ZShBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29w eShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2VwdGlvbikpOworICAgIEFTU0VSVCghKmV4Y2Vw dGlvbik7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHN0YXRpY19j YXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3Qp KTsKKyAgICBjb250cm9sbGVyLT5zZXRWYWx1ZUZvclVzZXIoY29udGV4dCwgYXJndW1lbnRzWzBd LCB2YWx1ZS5nZXQoKSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4 dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIHNldFZpZXdNb2RlTWVkaWFGZWF0dXJlQ2FsbGJh Y2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJl ZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1 bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgaW1wbGVt ZW50YXRpb24KQEAgLTIxMjksNiArMjE0NCw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91dFRl c3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJzZXRVc2VEYXNoYm9h cmRDb21wYXRpYmlsaXR5TW9kZSIsIHNldFVzZURhc2hib2FyZENvbXBhdGliaWxpdHlNb2RlQ2Fs bGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0VXNlclN0eWxlU2hlZXRFbmFibGVkIiwgc2V0 VXNlclN0eWxlU2hlZXRFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAic2V0VXNl clN0eWxlU2hlZXRMb2NhdGlvbiIsIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb25DYWxsYmFjaywg a0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERl bGV0ZSB9LAorICAgICAgICB7ICJzZXRWYWx1ZUZvclVzZXIiLCBzZXRWYWx1ZUZvclVzZXJDYWxs YmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInNldFZp ZXdNb2RlTWVkaWFGZWF0dXJlIiwgc2V0Vmlld01vZGVNZWRpYUZlYXR1cmVDYWxsYmFjaywga0pT UHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0 ZSB9LAogICAgICAgICB7ICJzZXRXZWJWaWV3RWRpdGFibGUiLCBzZXRXZWJWaWV3RWRpdGFibGVD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJzZXRXaWxsU2VuZFJlcXVlc3RDbGVhckhlYWRl ciIsIHNldFdpbGxTZW5kUmVxdWVzdENsZWFySGVhZGVyQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKZGlmZiAt LWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmggYi9Ub29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCmluZGV4IDhhMjA1MDA1OTFl MWE0OWM3YmZhMWIzNGJmNzcyOGJmNTE2MTBiOTUuLjRiMWMwNGUzZjY2OWE5OGMyODA0NDVlMzVi OTFiMTA4OWVjNmQ3NjAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmgKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaApAQCAtMTExLDYgKzExMSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldFVzZURhc2hi b2FyZENvbXBhdGliaWxpdHlNb2RlKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBzZXRVc2VyU3R5bGVT aGVldEVuYWJsZWQoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRp b24oSlNTdHJpbmdSZWYgcGF0aCk7CisgICAgdm9pZCBzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0 UmVmLCBKU1ZhbHVlUmVmIG5vZGVPYmplY3QsIEpTU3RyaW5nUmVmIHZhbHVlKTsKICAgICB2b2lk IHNldFZpZXdNb2RlTWVkaWFGZWF0dXJlKEpTU3RyaW5nUmVmIG1vZGUpOwogICAgIHZvaWQgc2V0 WFNTQXVkaXRvckVuYWJsZWQoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldEZyYW1lRmxhdHRlbmlu Z0VuYWJsZWQoYm9vbCBlbmFibGUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUv Z3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0 ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKaW5kZXggMGJiYWI4NjdlZmIwMDUzNDNlZGFl OTk5ODk2MmM0YjQ5OGRmZmY2YS4uMWEzOWRhODU5OWE1NmY3N2RjMzhkZWMzNjk2MDNiZTgyYzY4 YTJhZSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250 cm9sbGVyR3RrLmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENv bnRyb2xsZXJHdGsuY3BwCkBAIC0zMzMsNiArMzMzLDExIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRy b2xsZXI6OnNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCkKICAgICAg ICAgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKHRydWUpOwogfQogCit2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVS ZWYgZWxlbWVudCwgSlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6IGltcGxlbWVu dAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVy ZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSB3ZWJraXRf d2ViX2ZyYW1lX2dldF93ZWJfdmlldyhtYWluRnJhbWUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVt cFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvVG9vbHMvRHVtcFJl bmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IGJjOWRiYjdjODI4 OWMyYzMzMWZlYThkMWYxZjVhNjBlMDYxYWQxM2MuLjcyZWM3NTk4NTMwZGUwMTQzYWE2MTBkMWQy ODI0MmU1M2YwNjc3NWMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlv dXRUZXN0Q29udHJvbGxlck1hYy5tbQorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5 b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTQ3OSw2ICs0NzksMTYgQEAgdm9pZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRo KQogICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNlclN0eWxl U2hlZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRW YWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgbm9kZU9iamVjdCwg SlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAgRE9NRWxlbWVudCAqZWxlbWVudCA9IFtET01FbGVt ZW50IF9ET01FbGVtZW50RnJvbUpTQ29udGV4dDpjb250ZXh0IHZhbHVlOm5vZGVPYmplY3RdOwor ICAgIGlmICghZWxlbWVudCB8fCAhW2VsZW1lbnQgaXNLaW5kT2ZDbGFzczpbRE9NSFRNTElucHV0 RWxlbWVudCBjbGFzc11dKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgUmV0YWluUHRyPENG U3RyaW5nUmVmPiB2YWx1ZUNGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9j YXRvckRlZmF1bHQsIHZhbHVlKSk7CisgICAgWyhET01IVE1MSW5wdXRFbGVtZW50ICopZWxlbWVu dCBfc2V0VmFsdWVGb3JVc2VyOihOU1N0cmluZyAqKXZhbHVlQ0YuZ2V0KCldOworfQorCiB2b2lk IExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1Jl ZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1 bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAgYi9Ub29scy9EdW1w UmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCmluZGV4IDgwODYyZWIy MWI2YjdiMWY1Yzk2ZjVhOTk3M2QwODBiNDMwY2YzYmUuLjEyYTNhNTViOGFiNjI2ZDgyMDBjYzE0 MzU4ZGYyODlmMDI2NjE4MjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9M YXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2lu L0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcApAQCAtNzU1LDYgKzc1NSwxMSBAQCB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVm IGpzVVJMKQogICAgIFN5c0ZyZWVTdHJpbmcocmVzdWx0UGF0aEJTVFIpOwogfQogCit2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpzZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQs IEpTVmFsdWVSZWYgZWxlbWVudCwgSlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6 IGltcGxlbWVudAorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1l ZGlhRmVhdHVyZShKU1N0cmluZ1JlZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQK ZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRlc3RDb250cm9sbGVy V3guY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5j cHAKaW5kZXggMTBlMTEwNzExNmJkNGM2MzAxZTY0MWNlZGM3YTNmMTNhNmY0YzZmYS4uYTk1YWE1 MDVhZDdjZGQzZGEwNWZjNzg5NmVkOGJmZDcwOGY4OTU4MCAxMDA2NDQKLS0tIGEvVG9vbHMvRHVt cFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAKKysrIGIvVG9vbHMvRHVt cFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAKQEAgLTEzNSw2ICsxMzUs MTEgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlv bihKU1N0cmluZ1JlZiBwYXRoKQogewogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpz ZXRWYWx1ZUZvclVzZXIoSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTVmFsdWVSZWYgZWxlbWVudCwg SlNTdHJpbmdSZWYgdmFsdWUpCit7CisgICAgLy8gRklYTUU6IGltcGxlbWVudAorfQorCiB2b2lk IExheW91dFRlc3RDb250cm9sbGVyOjpzZXRWaWV3TW9kZU1lZGlhRmVhdHVyZShKU1N0cmluZ1Jl ZiBtb2RlKQogewogICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQK