48317 2010-10-26 03:45:08 -0700 Refactor HTMLInputElement: Move a part of HTMLInputElement::defaultEventHandler() to InputTypes 2010-11-15 21:14:40 -0800 1 1 1 Unclassified WebKit Forms 528+ (Nightly build) All All RESOLVED FIXED P3 Minor --- 49302 49426 1 tkent tkent darin dglazkov oldest_to_newest 299370 0 tkent 2010-10-26 03:45:08 -0700 Refactor HTMLInputElement: Move a part of HTMLInputElement::defaultEventhandler() to InputTypes 299376 1 71860 tkent 2010-10-26 03:54:56 -0700 Created attachment 71860 Patch 304197 2 71860 darin 2010-11-03 12:23:32 -0700 Comment on attachment 71860 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=71860&action=review Great work on the refactoring. I’m going to say review- because I find the boolean results of these various functions a bit too confusing. We should choose a single meaning for the boolean result from the event function and stick to that. That probably means reversing the logic for DOMActivateEvent. I’m not sure that the “return immediately if form is 0” behavior from DOMActivate is even important. Maybe the handleDOMActivateEvent function doesn’t need a return value. These confusing bool return values are poison! > WebCore/ChangeLog:16 > + Move m_xPos and m_yPos from HTMLInputElement to ImageInputType. It's > + safe to move them because they have valid values just after click event > + and form submission by the click. Could you create a test case where we change the type in response to the click event before the form submission happens? > WebCore/html/BaseDateAndTimeInputType.cpp:116 > +bool BaseDateAndTimeInputType::handleKeydownEvent(KeyboardEvent* event) > +{ > + if (handleKeydownEventForSpinButton(event)) > + return true; > + return TextFieldInputType::handleKeydownEventForSpinButton(event); > +} This is a very surprising function. It’s not clear at all why this calls handleKeydownEventForSpinButton first, and then calls TextFieldInputType::handleKeydownEventForSpinButton! Maybe the second call was supposed to be a call to handleKeydownEvent? > WebCore/html/FileInputType.cpp:83 > + if (element()->renderer()) > + toRenderFileUploadControl(element()->renderer())->click(); > + return false; I would use && here instead of an if statement. > WebCore/html/HTMLInputElement.cpp:1238 > + if (evt->isKeyboardEvent() && evt->type() == eventNames().keydownEvent > + && m_inputType->handleKeydownEvent(static_cast<KeyboardEvent*>(evt))) > return; I hate how the formatting looks in cases like this. Maybe we could put this all on one long line? > WebCore/html/HTMLInputElement.cpp:1256 > + if (evt->type() == eventNames().DOMActivateEvent && !disabled() > + && m_inputType->handleDOMActivateEvent(evt)) > + return; Same thought here. I’m not sure why the !disabled() check is being done here in the base class. It’s an unclear separation of responsibilities. Nothing in the name handleDOMActivateEvent makes it clear that disabled is already checked. It seems a surprising difference from the handleKeydownEvent function. > WebCore/html/ImageInputType.cpp:33 > +ALWAYS_INLINE ImageInputType::ImageInputType(HTMLInputElement* element) Isn’t a plain old inline sufficient? Why was ALWAYS_INLINE needed? > WebCore/html/ImageInputType.cpp:72 > +bool ImageInputType::handleClickEvent(MouseEvent* mouseEvent) You’re moving enough code here that you may have to update copyright. > WebCore/html/ImageInputType.h:53 > + int m_xPosition; > + int m_yPosition; These names aren’t so great. How about: IntPoint m_clickLocation; Or something like that? > WebCore/html/InputType.cpp:276 > +bool InputType::handleKeydownEventForSpinButton(KeyboardEvent* event) Why is this spin-button-specific event handling in the InputType base class? There should at least be a comment explaining this. > WebCore/html/InputType.cpp:278 > + String key = static_cast<KeyboardEvent*>(event)->keyIdentifier(); It would be better if keyIdentifier returned a const String& and this local variable was also const String&. There’s no need to churn the reference count just to check string equality. > WebCore/html/InputType.cpp:285 > + int step = 0; > + if (key == "Up") > + step = 1; > + else if (key == "Down") > + step = -1; > + if (!step) > + return false; I think "else return false" would be clearer. > WebCore/html/InputType.h:105 > + virtual bool handleClickEvent(MouseEvent*); > + virtual bool handleDOMActivateEvent(Event*); > + virtual bool handleKeydownEvent(KeyboardEvent*); The meanings of these bool return values are unclear to me. What does true and false mean? I also think that we should provide a basic handleEvent function here, and put the dispatching to the individual handleEvent functions inside that, but maybe you can do that later. Eventually I’d hope these individual functions could become protected or even private. > WebCore/html/RangeInputType.cpp:131 > +bool RangeInputType::handleKeydownEvent(KeyboardEvent* event) You’re moving enough code here that you may have to update copyright. > WebCore/html/RangeInputType.cpp:141 > + // FIXME: Is 1/100 reasonable? This is a mysterious comment. Rewrite for clarity? > WebCore/html/ResetInputType.cpp:60 > +bool ResetInputType::handleDOMActivateEvent(Event*) > +{ > + if (!element()->form()) > + return true; > + element()->form()->reset(); > + return false; > +} This seems backwards. What does the boolean return value from this function means? It seems to be returning true when the function does nothing and false when the function does something. Maybe we need a different return type if the boolean result is unclear. > WebCore/html/TextFieldInputType.cpp:59 > + Document* document = element()->document(); > + if (!document->frame()) > + return false; > + if (!document->frame()->editor()->doTextFieldCommandFromEvent(element(), event)) The only way document is ever used is to call document->frame() so clearly the local variable should be the Frame* instead. > WebCore/html/TextFieldInputType.cpp:62 > + event->setDefaultHandled(); > + return true; Why do some of these functions call setDefaultedHandled, but not others. I think there is something wrong with the idiom here. I know you are only refactoring, but this refactoring seems to be exposing inconsistencies that may be bugs, so we should at least add FIXME. 308395 3 71860 tkent 2010-11-11 23:15:18 -0800 Comment on attachment 71860 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=71860&action=review >> WebCore/ChangeLog:16 >> + and form submission by the click. > > Could you create a test case where we change the type in response to the click event before the form submission happens? I added a test in Bug#49302, and found this patch was wrong :-) HTMLFormElement::prepareSubmit() dispatches 'submit' event and JavaScript code may change the input type. So we should not access data members of InputType after prepareSubmit(). I fixed it in the second patch. >> WebCore/html/BaseDateAndTimeInputType.cpp:116 >> +} > > This is a very surprising function. It’s not clear at all why this calls handleKeydownEventForSpinButton first, and then calls TextFieldInputType::handleKeydownEventForSpinButton! Maybe the second call was supposed to be a call to handleKeydownEvent? Oh, you're right. But this mistake didn't make behavior change. >> WebCore/html/FileInputType.cpp:83 >> + return false; > > I would use && here instead of an if statement. done. >> WebCore/html/HTMLInputElement.cpp:1238 >> return; > > I hate how the formatting looks in cases like this. Maybe we could put this all on one long line? done. >> WebCore/html/HTMLInputElement.cpp:1256 >> + return; > > Same thought here. > > I’m not sure why the !disabled() check is being done here in the base class. It’s an unclear separation of responsibilities. Nothing in the name handleDOMActivateEvent makes it clear that disabled is already checked. It seems a surprising difference from the handleKeydownEvent function. done. I moved the disabled() check to handleDOMActivateEvent() implementations though I wonder if the disabled() check is required. >> WebCore/html/ImageInputType.cpp:33 >> +ALWAYS_INLINE ImageInputType::ImageInputType(HTMLInputElement* element) > > Isn’t a plain old inline sufficient? Why was ALWAYS_INLINE needed? I'm not sure. Anyway, I reverted this change because m_xPosition and m_yPosition is merged to m_clickLocation and we don't need to initialize it explicitly. >> WebCore/html/ImageInputType.cpp:72 >> +bool ImageInputType::handleClickEvent(MouseEvent* mouseEvent) > > You’re moving enough code here that you may have to update copyright. I checked revision logs, and confirmed the current copyright statement is enough. This file already have non-Google copyright. > WebCore/html/ImageInputType.cpp:77 > + // FIXME: We could just call offsetX() and offsetY() on the event, > + // but that's currently broken, so for now do the computation here. This comment was added in r12153, and we have many improvements on offsetX() and offsetY() after r12153. I think we should use offsetX() and offsetY(). The second patch uses them. > WebCore/html/ImageInputType.cpp:105 > + if (!element()->form()->prepareSubmit(event)) { > + m_xPosition = 0; > + m_yPosition = 0; > + } > + element()->setActivatedSubmit(false); We shouldn't call element(). "this" might be deleted by 'submit' event. >> WebCore/html/ImageInputType.h:53 >> + int m_yPosition; > > These names aren’t so great. How about: > > IntPoint m_clickLocation; > > Or something like that? Done. >> WebCore/html/InputType.cpp:276 >> +bool InputType::handleKeydownEventForSpinButton(KeyboardEvent* event) > > Why is this spin-button-specific event handling in the InputType base class? There should at least be a comment explaining this. I moved it to TextFieldInputType. >> WebCore/html/InputType.cpp:278 >> + String key = static_cast<KeyboardEvent*>(event)->keyIdentifier(); > > It would be better if keyIdentifier returned a const String& and this local variable was also const String&. There’s no need to churn the reference count just to check string equality. I'll handle it in Bug#49426. >> WebCore/html/InputType.cpp:285 >> + return false; > > I think "else return false" would be clearer. Done. >> WebCore/html/InputType.h:105 >> + virtual bool handleKeydownEvent(KeyboardEvent*); > > The meanings of these bool return values are unclear to me. What does true and false mean? > > I also think that we should provide a basic handleEvent function here, and put the dispatching to the individual handleEvent functions inside that, but maybe you can do that later. Eventually I’d hope these individual functions could become protected or even private. I added a comment on the bools in the second patch. // The return value means "should return from the caller event handler immediately." Does it make sense? It is almost identical to Event::setDefaultHandled(). However the current HTMLInputElement::defaultEventHandler() does early-return without setDefaultHandled() in some cases. So we need the flag. Should we introduce new enum for this? Yes, the implementation of HTMLInputElement::defaultEventHandler() should be just "m_inputType->handleEvent(evt)" in the future. >> WebCore/html/RangeInputType.cpp:131 >> +bool RangeInputType::handleKeydownEvent(KeyboardEvent* event) > > You’re moving enough code here that you may have to update copyright. I checked revision logs, and confirmed the current copyright statement is enough. >> WebCore/html/RangeInputType.cpp:141 >> + // FIXME: Is 1/100 reasonable? > > This is a mysterious comment. Rewrite for clarity? Done. >> WebCore/html/ResetInputType.cpp:60 >> +} > > This seems backwards. What does the boolean return value from this function means? It seems to be returning true when the function does nothing and false when the function does something. Maybe we need a different return type if the boolean result is unclear. The behavior of this code is same as the original code. But I suspect the original code has a bug. This should be the following? element()->form()->reset(); event->setDefaultHandled(); return true; > WebCore/html/SubmitInputType.cpp:69 > + element()->form()->prepareSubmit(event); > + element()->setActivatedSubmit(false); We shouldn't call element(). "this" might be deleted by 'submit' event. >> WebCore/html/TextFieldInputType.cpp:59 >> + if (!document->frame()->editor()->doTextFieldCommandFromEvent(element(), event)) > > The only way document is ever used is to call document->frame() so clearly the local variable should be the Frame* instead. Done. 308399 4 73703 tkent 2010-11-11 23:28:10 -0800 Created attachment 73703 Patch 2 309186 5 73875 tkent 2010-11-14 21:35:14 -0800 Created attachment 73875 Patch 3 (rebased for keyIdentifier()) 309187 6 darin 2010-11-14 21:39:41 -0800 (In reply to comment #3) > > I’m not sure why the !disabled() check is being done here in the base class. It’s an unclear separation of responsibilities. Nothing in the name handleDOMActivateEvent makes it clear that disabled is already checked. It seems a surprising difference from the handleKeydownEvent function. > > done. > I moved the disabled() check to handleDOMActivateEvent() implementations though I wonder if the disabled() check is required. I believe it is required, but we can create a test to explore that if yo like. > > This seems backwards. What does the boolean return value from this function means? It seems to be returning true when the function does nothing and false when the function does something. Maybe we need a different return type if the boolean result is unclear. > > The behavior of this code is same as the original code. But I suspect the original code has a bug. This should be the following? > element()->form()->reset(); > event->setDefaultHandled(); > return true; I honestly don’t know. We have to figure out how to create a test that can detect the difference. 309191 7 73875 darin 2010-11-14 21:56:39 -0800 Comment on attachment 73875 Patch 3 (rebased for keyIdentifier()) View in context: https://bugs.webkit.org/attachment.cgi?id=73875&action=review r=me, but there are still some tricky bits that need a little more thought > WebCore/html/FileInputType.cpp:84 > +bool FileInputType::handleDOMActivateEvent(Event*) > +{ > + if (!element()->disabled() && element()->renderer()) > + toRenderFileUploadControl(element()->renderer())->click(); > + return false; > +} Is it correct to return false when the DOMActivate event is handled? We should construct a test for this. > WebCore/html/ImageInputType.cpp:71 > + RefPtr<HTMLInputElement> input(element()); I prefer the assignment style to constructor style for this sort of thing, and I also suggest we put this at the top of the function rather than after the checks of disabled and form. Or, to make it more clear exactly where the issue lies, we could put it just before the call to prepareSubmit. Also, another possible name for the local variable is "element", which might be clearer. RefPtr<HTMLInputElement> element = this->element(); Or we could come up with a name that makes it clear it’s about surviving even after arbitrary code runs. Since the only reason we need this is for the call to setActivatedSubmit(false), we might instead make an object that calls setActivatedSubmit(true) and then setActivatedSubmit(false) when it falls out of scope, and that object can use a RefPtr. The RAII idiom. > WebCore/html/ImageInputType.cpp:78 > + input->form()->prepareSubmit(event); // JavaScript code might run. It might be be clearer to say that “event handlers” can run rather than JavaScript. The same issue exists regardless of programming language. > WebCore/html/ImageInputType.cpp:80 > + return false; I think returning false here is truly strange as I mentioned earlier, and I suggest we create test cases to see what is going on. In fact, because we return false, I suspect the caller will use a possibly-bad "this" pointer if the event handler ran, so I think this is more than just a minor behavioral issue. It’s possible the caller has to be prepared for event handlers to be run even if false is returned. We should take a look at the various functions to see if that ever happens. > WebCore/html/InputType.h:104 > + // Event handlers > + // The return value means "should return from the caller event handler immediately." Strange formatting here. I know I asked for a comment, but I still don’t find this comment entirely clear. I think what the return value means is more like "if true, do no further default event handling in the default event handler and return true from that function". The reason I was unclear before is that some of the functions seem to do the opposite. > WebCore/html/RangeInputType.cpp:158 > + setValueAsNumber(newValue, ec); > + element()->dispatchFormControlChangeEvent(); Can we really get at element() after calling setValueAsNumber? Can’t event handlers run? > WebCore/html/RangeInputType.cpp:165 > + element()->stepUp(stepMagnification, ec); > + if (lastStringValue != element()->value()) > + element()->dispatchFormControlChangeEvent(); Can we really get at element() after calling stepUp? Can’t event handlers run? > WebCore/html/ResetInputType.cpp:61 > + return false; Same crazy "return false" here as in the other DOMActivate event handlers. This should really get explored and fixed. > WebCore/html/SubmitInputType.cpp:73 > + return false; Again, same issue. 309563 8 73875 tkent 2010-11-15 20:54:55 -0800 Comment on attachment 73875 Patch 3 (rebased for keyIdentifier()) View in context: https://bugs.webkit.org/attachment.cgi?id=73875&action=review Thank you for reviewing. I'll commit the patch with some small changes. >> WebCore/html/FileInputType.cpp:84 >> +} > > Is it correct to return false when the DOMActivate event is handled? We should construct a test for this. We should call setDefaultHandled() and return true. However, AFAIK, calling setDefaultHandled() won't make any behavior change with the current WebKit code. So, I'll add setDefaultHandled() here, but won't add tests. >> WebCore/html/ImageInputType.cpp:71 >> + RefPtr<HTMLInputElement> input(element()); > > I prefer the assignment style to constructor style for this sort of thing, and I also suggest we put this at the top of the function rather than after the checks of disabled and form. Or, to make it more clear exactly where the issue lies, we could put it just before the call to prepareSubmit. > > Also, another possible name for the local variable is "element", which might be clearer. > > RefPtr<HTMLInputElement> element = this->element(); > > Or we could come up with a name that makes it clear it’s about surviving even after arbitrary code runs. > > Since the only reason we need this is for the call to setActivatedSubmit(false), we might instead make an object that calls setActivatedSubmit(true) and then setActivatedSubmit(false) when it falls out of scope, and that object can use a RefPtr. The RAII idiom. I changed so that "element = this->element()" is at the top of the function. RAII is cool, but I feel it's overkill because we can use RefPtr. >> WebCore/html/ImageInputType.cpp:78 >> + input->form()->prepareSubmit(event); // JavaScript code might run. > > It might be be clearer to say that “event handlers” can run rather than JavaScript. The same issue exists regardless of programming language. Fixed. >> WebCore/html/ImageInputType.cpp:80 >> + return false; > > I think returning false here is truly strange as I mentioned earlier, and I suggest we create test cases to see what is going on. > > In fact, because we return false, I suspect the caller will use a possibly-bad "this" pointer if the event handler ran, so I think this is more than just a minor behavioral issue. It’s possible the caller has to be prepared for event handlers to be run even if false is returned. We should take a look at the various functions to see if that ever happens. Fixed same as FileInputType.cpp. >> WebCore/html/InputType.h:104 >> + // The return value means "should return from the caller event handler immediately." > > Strange formatting here. I know I asked for a comment, but I still don’t find this comment entirely clear. I think what the return value means is more like "if true, do no further default event handling in the default event handler and return true from that function". The reason I was unclear before is that some of the functions seem to do the opposite. Fixed the comment. >> WebCore/html/RangeInputType.cpp:158 >> + element()->dispatchFormControlChangeEvent(); > > Can we really get at element() after calling setValueAsNumber? Can’t event handlers run? setValueAsNumber() doesn't dispatch events. >> WebCore/html/RangeInputType.cpp:165 >> + element()->dispatchFormControlChangeEvent(); > > Can we really get at element() after calling stepUp? Can’t event handlers run? stepUp() doesn't dispatch events. >> WebCore/html/ResetInputType.cpp:61 >> + return false; > > Same crazy "return false" here as in the other DOMActivate event handlers. This should really get explored and fixed. Fixed same as FileInputType.cpp. >> WebCore/html/SubmitInputType.cpp:73 >> + return false; > > Again, same issue. Fixed same as FileInputType.cpp. 309570 9 tkent 2010-11-15 21:14:20 -0800 Landed: http://trac.webkit.org/changeset/72059 71860 2010-10-26 03:54:56 -0700 2010-11-11 23:28:05 -0800 Patch bug-48317-20101026195454.patch text/plain 29710 tkent ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MzQ4MzY0MTQyODNmM2QzZmY4ZTYyNDE1YjVmYWUzYjY0MjM4MWJhOS4uMDc4MmY5YmY5ZjRiMGU5 MzgxYmM0OThmOTkzNDQ1MTViYWJlNGY4MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2MyBAQAorMjAxMC0xMC0yNiAgS2Vu dCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgSFRNTElucHV0RWxlbWVudDogTW92ZSBh IHBhcnQgb2YgSFRNTElucHV0RWxlbWVudDo6CisgICAgICAgIGRlZmF1bHRFdmVudGhhbmRsZXIo KSB0byBJbnB1dFR5cGVzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NDgzMTcKKworICAgICAgICBNb3ZlIG91dCB0aGUgZm9sbG93aW5ncyB0byBJbnB1 dFR5cGVzOgorICAgICAgICAgLSBjbGljayBldmVudCBwcm9jZXNzaW5nLAorICAgICAgICAgLSB0 aGUgZmlyc3Qga2V5ZG93biBldmVudCBwcm9jZXNzaW5nLCBhbmQKKyAgICAgICAgIC0gRE9NQWN0 aXZhdGUgZXZlbnQgcHJvY2Vzc2luZy4KKworICAgICAgICBNb3ZlIG1feFBvcyBhbmQgbV95UG9z IGZyb20gSFRNTElucHV0RWxlbWVudCB0byBJbWFnZUlucHV0VHlwZS4gSXQncworICAgICAgICBz YWZlIHRvIG1vdmUgdGhlbSBiZWNhdXNlIHRoZXkgaGF2ZSB2YWxpZCB2YWx1ZXMganVzdCBhZnRl ciBjbGljayBldmVudAorICAgICAgICBhbmQgZm9ybSBzdWJtaXNzaW9uIGJ5IHRoZSBjbGljay4K KworICAgICAgICBObyBuZXcgdGVzdHMgYmVjYXVzZSB0aGlzIGlzIGp1c3QgYSByZWZhY3Rvcmlu Zy4KKworICAgICAgICAqIGh0bWwvQmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkJhc2VEYXRlQW5kVGltZUlucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50 KToKKyAgICAgICAgKiBodG1sL0Jhc2VEYXRlQW5kVGltZUlucHV0VHlwZS5oOgorICAgICAgICAq IGh0bWwvRmlsZUlucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGaWxlSW5wdXRUeXBl OjpoYW5kbGVET01BY3RpdmF0ZUV2ZW50KToKKyAgICAgICAgKiBodG1sL0ZpbGVJbnB1dFR5cGUu aDoKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6SFRNTElucHV0RWxlbWVudDo6SFRNTElucHV0RWxlbWVudCk6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKToKKyAgICAgICAgKiBodG1s L0hUTUxJbnB1dEVsZW1lbnQuaDoKKyAgICAgICAgKiBodG1sL0ltYWdlSW5wdXRUeXBlLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkltYWdlSW5wdXRUeXBlOjpJbWFnZUlucHV0VHlwZSk6CisgICAg ICAgIChXZWJDb3JlOjpJbWFnZUlucHV0VHlwZTo6YXBwZW5kRm9ybURhdGEpOgorICAgICAgICAo V2ViQ29yZTo6SW1hZ2VJbnB1dFR5cGU6OmhhbmRsZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2Vi Q29yZTo6SW1hZ2VJbnB1dFR5cGU6OmhhbmRsZURPTUFjdGl2YXRlRXZlbnQpOgorICAgICAgICAq IGh0bWwvSW1hZ2VJbnB1dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL0lucHV0VHlwZS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpJbnB1dFR5cGU6OmhhbmRsZUNsaWNrRXZlbnQpOgorICAgICAgICAo V2ViQ29yZTo6SW5wdXRUeXBlOjpoYW5kbGVET01BY3RpdmF0ZUV2ZW50KToKKyAgICAgICAgKFdl YkNvcmU6OklucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6 OklucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50Rm9yU3BpbkJ1dHRvbik6CisgICAgICAgICog aHRtbC9JbnB1dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL051bWJlcklucHV0VHlwZS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpOdW1iZXJJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVudCk6Cisg ICAgICAgICogaHRtbC9OdW1iZXJJbnB1dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL1JhZGlvSW5w dXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJhZGlvSW5wdXRUeXBlOjpoYW5kbGVDbGlj a0V2ZW50KToKKyAgICAgICAgKiBodG1sL1JhZGlvSW5wdXRUeXBlLmg6CisgICAgICAgICogaHRt bC9SYW5nZUlucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSYW5nZUlucHV0VHlwZTo6 aGFuZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKiBodG1sL1JhbmdlSW5wdXRUeXBlLmg6Cisg ICAgICAgICogaHRtbC9SZXNldElucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZXNl dElucHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudCk6CisgICAgICAgICogaHRtbC9SZXNl dElucHV0VHlwZS5oOgorICAgICAgICAqIGh0bWwvU3VibWl0SW5wdXRUeXBlLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlN1Ym1pdElucHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudCk6Cisg ICAgICAgICogaHRtbC9TdWJtaXRJbnB1dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL1RleHRGaWVs ZElucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUZXh0RmllbGRJbnB1dFR5cGU6Omhh bmRsZUtleWRvd25FdmVudCk6CisgICAgICAgICogaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaDoK KwogMjAxMC0xMC0yNiAgWGFuIExvcGV6ICA8eGxvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgTWFydGluIFJvYmluc29uLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0Jh c2VEYXRlQW5kVGltZUlucHV0VHlwZS5jcHAgYi9XZWJDb3JlL2h0bWwvQmFzZURhdGVBbmRUaW1l SW5wdXRUeXBlLmNwcAppbmRleCBlMTEyNmQ0ZDZkN2I5ZWNhZTU5NmNkZjk1NDlhMGQ2N2IxMzkz OTcyLi5lNjZkODkwYWFjYzg2MjA1ODc1YmRlNjMwNmQ5MzJjYWY4NThkMWU5IDEwMDY0NAotLS0g YS9XZWJDb3JlL2h0bWwvQmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlLmNwcAorKysgYi9XZWJDb3Jl L2h0bWwvQmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlLmNwcApAQCAtMTA4LDYgKzEwOCwxMyBAQCBk b3VibGUgQmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlOjpzdGVwQmFzZSgpIGNvbnN0CiAgICAgcmV0 dXJuIHBhcnNlVG9Eb3VibGUoZWxlbWVudCgpLT5mYXN0R2V0QXR0cmlidXRlKG1pbkF0dHIpLCBk ZWZhdWx0U3RlcEJhc2UoKSk7CiB9CiAKK2Jvb2wgQmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlOjpo YW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCogZXZlbnQpCit7CisgICAgaWYgKGhhbmRs ZUtleWRvd25FdmVudEZvclNwaW5CdXR0b24oZXZlbnQpKQorICAgICAgICByZXR1cm4gdHJ1ZTsK KyAgICByZXR1cm4gVGV4dEZpZWxkSW5wdXRUeXBlOjpoYW5kbGVLZXlkb3duRXZlbnRGb3JTcGlu QnV0dG9uKGV2ZW50KTsKK30KKwogZG91YmxlIEJhc2VEYXRlQW5kVGltZUlucHV0VHlwZTo6cGFy c2VUb0RvdWJsZShjb25zdCBTdHJpbmcmIHNyYywgZG91YmxlIGRlZmF1bHRWYWx1ZSkgY29uc3QK IHsKICAgICBEYXRlQ29tcG9uZW50cyBkYXRlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0Jh c2VEYXRlQW5kVGltZUlucHV0VHlwZS5oIGIvV2ViQ29yZS9odG1sL0Jhc2VEYXRlQW5kVGltZUlu cHV0VHlwZS5oCmluZGV4IDgzYzFlOTNmZTI0MTczMzkyNDgxN2E0NGZiMDU5MThmOTBjODk3MmMu LjExYzYwYWZjYTY1OGM2YjcyMmZjMDI3ZGRlNTg0Y2Q2NzU2MGQ0OWEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvaHRtbC9CYXNlRGF0ZUFuZFRpbWVJbnB1dFR5cGUuaAorKysgYi9XZWJDb3JlL2h0bWwv QmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlLmgKQEAgLTU3LDYgKzU3LDcgQEAgcHJpdmF0ZToKICAg ICB2aXJ0dWFsIGJvb2wgcmFuZ2VPdmVyZmxvdyhjb25zdCBTdHJpbmcmKSBjb25zdDsKICAgICB2 aXJ0dWFsIGJvb2wgc3RlcE1pc21hdGNoKGNvbnN0IFN0cmluZyYsIGRvdWJsZSkgY29uc3Q7CiAg ICAgdmlydHVhbCBkb3VibGUgc3RlcEJhc2UoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaGFu ZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqKTsKICAgICB2aXJ0dWFsIFN0cmluZyBzZXJp YWxpemUoZG91YmxlKSBjb25zdDsKIH07CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9GaWxl SW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmNwcAppbmRleCBkOThk M2I2YzhiY2VjNDk5YWRlZjBjOTJlYWM2MWU1ZjA4YThiNDkyLi4yOWI2NDQwNjk1NDIyMTZhNzA0 ZWNmYmMzMWVlOWMxMjkyMDRmMTVhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvRmlsZUlucHV0 VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0ZpbGVJbnB1dFR5cGUuY3BwCkBAIC03Niw2ICs3 NiwxMyBAQCBib29sIEZpbGVJbnB1dFR5cGU6OnZhbHVlTWlzc2luZyhjb25zdCBTdHJpbmcmIHZh bHVlKSBjb25zdAogICAgIHJldHVybiB2YWx1ZS5pc0VtcHR5KCk7CiB9CiAKK2Jvb2wgRmlsZUlu cHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudChFdmVudCopCit7CisgICAgaWYgKGVsZW1l bnQoKS0+cmVuZGVyZXIoKSkKKyAgICAgICAgdG9SZW5kZXJGaWxlVXBsb2FkQ29udHJvbChlbGVt ZW50KCktPnJlbmRlcmVyKCkpLT5jbGljaygpOworICAgIHJldHVybiBmYWxzZTsKK30KKwogUmVu ZGVyT2JqZWN0KiBGaWxlSW5wdXRUeXBlOjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSogYXJl bmEsIFJlbmRlclN0eWxlKikgY29uc3QKIHsKICAgICByZXR1cm4gbmV3IChhcmVuYSkgUmVuZGVy RmlsZVVwbG9hZENvbnRyb2woZWxlbWVudCgpKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9G aWxlSW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvRmlsZUlucHV0VHlwZS5oCmluZGV4IDI0NDMw ZmIyNDcxOGI1ZjdiNDQxNTRiOThlMzhjY2IwYjRmNGJkOTIuLjE0MmFmYWY2Y2Y3OTU4NTdmNWM1 MDI5YzFlOGZjYjE2MmRjMWM4MTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRU eXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL0ZpbGVJbnB1dFR5cGUuaApAQCAtNDQsNiArNDQsNyBA QCBwcml2YXRlOgogICAgIHZpcnR1YWwgY29uc3QgQXRvbWljU3RyaW5nJiBmb3JtQ29udHJvbFR5 cGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgYXBwZW5kRm9ybURhdGEoRm9ybURhdGFMaXN0 JiwgYm9vbCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHZhbHVlTWlzc2luZyhjb25zdCBTdHJp bmcmKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlRE9NQWN0aXZhdGVFdmVudChFdmVu dCopOwogICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVu YSosIFJlbmRlclN0eWxlKikgY29uc3Q7CiB9OwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwv SFRNTElucHV0RWxlbWVudC5jcHAgYi9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAK aW5kZXggMmZmOGVjNWE4NTcyZDJkMDQzM2Y3ZjNmYmQzMzVhZTIwOWRlNGIwZC4uOTRjYjNiZmY4 MDhiZTg0NjgyZmNiMzk0Zjk5ZmM1ZTU3NTRiMTA4ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1s L0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50 LmNwcApAQCAtODcsOCArODcsNiBAQCBzdGF0aWMgYm9vbCBpc051bWJlckNoYXJhY3RlcihVQ2hh ciBjaCkKIAogSFRNTElucHV0RWxlbWVudDo6SFRNTElucHV0RWxlbWVudChjb25zdCBRdWFsaWZp ZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCogZG9jdW1lbnQsIEhUTUxGb3JtRWxlbWVudCogZm9y bSkKICAgICA6IEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50KHRhZ05hbWUsIGRvY3VtZW50LCBm b3JtKQotICAgICwgbV94UG9zKDApCi0gICAgLCBtX3lQb3MoMCkKICAgICAsIG1fbWF4UmVzdWx0 cygtMSkKICAgICAsIG1fZGVwcmVjYXRlZFR5cGVOdW1iZXIoVEVYVCkKICAgICAsIG1fY2hlY2tl ZChmYWxzZSkKQEAgLTEyMzEsNTcgKzEyMjksMTQgQEAgdm9pZCBIVE1MSW5wdXRFbGVtZW50Ojpk ZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCiAgICAgaWYgKGlzVGV4dEZpZWxkKCkgJiYg ZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLnRleHRJbnB1dEV2ZW50ICYmIGV2dC0+aXNUZXh0 RXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxUZXh0RXZlbnQqPihldnQpLT5kYXRhKCkgPT0gIlxuIikK ICAgICAgICAgaW1wbGljaXRTdWJtaXNzaW9uID0gdHJ1ZTsKIAotICAgIGlmIChkZXByZWNhdGVk SW5wdXRUeXBlKCkgPT0gSU1BR0UgJiYgZXZ0LT5pc01vdXNlRXZlbnQoKSAmJiBldnQtPnR5cGUo KSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkgewotICAgICAgICAvLyByZWNvcmQgdGhlIG1v dXNlIHBvc2l0aW9uIGZvciB3aGVuIHdlIGdldCB0aGUgRE9NQWN0aXZhdGUgZXZlbnQKLSAgICAg ICAgTW91c2VFdmVudCogbWUgPSBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KTsKLSAgICAg ICAgLy8gRklYTUU6IFdlIGNvdWxkIGp1c3QgY2FsbCBvZmZzZXRYKCkgYW5kIG9mZnNldFkoKSBv biB0aGUgZXZlbnQsCi0gICAgICAgIC8vIGJ1dCB0aGF0J3MgY3VycmVudGx5IGJyb2tlbiwgc28g Zm9yIG5vdyBkbyB0aGUgY29tcHV0YXRpb24gaGVyZS4KLSAgICAgICAgaWYgKG1lLT5pc1NpbXVs YXRlZCgpIHx8ICFyZW5kZXJlcigpKSB7Ci0gICAgICAgICAgICBtX3hQb3MgPSAwOwotICAgICAg ICAgICAgbV95UG9zID0gMDsKLSAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgIC8vIEZJWE1F OiBUaGlzIGRvZXNuJ3Qgd29yayBjb3JyZWN0bHkgd2l0aCB0cmFuc2Zvcm1zLgotICAgICAgICAg ICAgLy8gRklYTUU6IHBhZ2VYL3BhZ2VZIG5lZWQgYWRqdXN0aW5nIGZvciBwYWdlWm9vbUZhY3Rv cigpLiBVc2UgYWN0dWFsUGFnZUxvY2F0aW9uKCk/Ci0gICAgICAgICAgICBJbnRQb2ludCBhYnNP ZmZzZXQgPSByb3VuZGVkSW50UG9pbnQocmVuZGVyZXIoKS0+bG9jYWxUb0Fic29sdXRlKCkpOwot ICAgICAgICAgICAgbV94UG9zID0gbWUtPnBhZ2VYKCkgLSBhYnNPZmZzZXQueCgpOwotICAgICAg ICAgICAgbV95UG9zID0gbWUtPnBhZ2VZKCkgLSBhYnNPZmZzZXQueSgpOwotICAgICAgICB9Ci0g ICAgfQotCi0gICAgaWYgKGhhc1NwaW5CdXR0b24oKSAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5h bWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2FyZEV2ZW50KCkpIHsKLSAgICAgICAg U3RyaW5nIGtleSA9IHN0YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldnQpLT5rZXlJZGVudGlm aWVyKCk7Ci0gICAgICAgIGludCBzdGVwID0gMDsKLSAgICAgICAgaWYgKGtleSA9PSAiVXAiKQot ICAgICAgICAgICAgc3RlcCA9IDE7Ci0gICAgICAgIGVsc2UgaWYgKGtleSA9PSAiRG93biIpCi0g ICAgICAgICAgICBzdGVwID0gLTE7Ci0gICAgICAgIGlmIChzdGVwKSB7Ci0gICAgICAgICAgICBz dGVwVXBGcm9tUmVuZGVyZXIoc3RlcCk7Ci0gICAgICAgICAgICBldnQtPnNldERlZmF1bHRIYW5k bGVkKCk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLSAgICB9Ci0gICAgaWYgKGRl cHJlY2F0ZWRJbnB1dFR5cGUoKSA9PSBSQU5HRSAmJiBldnQtPmlzS2V5Ym9hcmRFdmVudCgpKSB7 Ci0gICAgICAgIGhhbmRsZUtleUV2ZW50Rm9yUmFuZ2Uoc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVu dCo+KGV2dCkpOwotICAgICAgICBpZiAoZXZ0LT5kZWZhdWx0SGFuZGxlZCgpKQotICAgICAgICAg ICAgcmV0dXJuOwotICAgIH0KLSAKLSAgIGlmIChpc1RleHRGaWVsZCgpCi0gICAgICAgICAgICAm JiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50Ci0gICAgICAgICAgICAm JiBldnQtPmlzS2V5Ym9hcmRFdmVudCgpCi0gICAgICAgICAgICAmJiBmb2N1c2VkKCkKLSAgICAg ICAgICAgICYmIGRvY3VtZW50KCktPmZyYW1lKCkKLSAgICAgICAgICAgICYmIGRvY3VtZW50KCkt PmZyYW1lKCktPmVkaXRvcigpLT5kb1RleHRGaWVsZENvbW1hbmRGcm9tRXZlbnQodGhpcywgc3Rh dGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCkpKSB7Ci0gICAgICAgIGV2dC0+c2V0RGVmYXVs dEhhbmRsZWQoKTsKKyAgICBpZiAoZXZ0LT5pc01vdXNlRXZlbnQoKSAmJiBldnQtPnR5cGUoKSA9 PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudAorICAgICAgICAmJiBtX2lucHV0VHlwZS0+aGFuZGxl Q2xpY2tFdmVudChzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KSkpCiAgICAgICAgIHJldHVy bjsKLSAgICB9CiAKLSAgICBpZiAoZGVwcmVjYXRlZElucHV0VHlwZSgpID09IFJBRElPICYmIGV2 dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7Ci0gICAgICAgIGV2dC0+c2V0 RGVmYXVsdEhhbmRsZWQoKTsKKyAgICBpZiAoZXZ0LT5pc0tleWJvYXJkRXZlbnQoKSAmJiBldnQt PnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50CisgICAgICAgICYmIG1faW5wdXRU eXBlLT5oYW5kbGVLZXlkb3duRXZlbnQoc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCkp KQogICAgICAgICByZXR1cm47Ci0gICAgfQotICAgIAorCiAgICAgLy8gQ2FsbCB0aGUgYmFzZSBl dmVudCBoYW5kbGVyIGJlZm9yZSBhbnkgb2Ygb3VyIG93biBldmVudCBoYW5kbGluZyBmb3IgYWxt b3N0IGFsbCBldmVudHMgaW4gdGV4dCBmaWVsZHMuCiAgICAgLy8gTWFrZXMgZWRpdGluZyBrZXli b2FyZCBoYW5kbGluZyB0YWtlIHByZWNlZGVuY2Ugb3ZlciB0aGUga2V5ZG93biBhbmQga2V5cHJl c3MgaGFuZGxpbmcgaW4gdGhpcyBmdW5jdGlvbi4KICAgICBib29sIGNhbGxCYXNlQ2xhc3NFYXJs eSA9IGlzVGV4dEZpZWxkKCkgJiYgIWltcGxpY2l0U3VibWlzc2lvbgpAQCAtMTI5NiwyNyArMTI1 MSw5IEBAIHZvaWQgSFRNTElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCog ZXZ0KQogICAgIC8vIGFjdHVhbGx5IHN1Ym1pdHRpbmcgdGhlIGZvcm0uIEZvciByZXNldCBpbnB1 dHMsIHRoZSBmb3JtIGlzIHJlc2V0LiBUaGVzZSBldmVudHMgYXJlIHNlbnQgd2hlbiB0aGUgdXNl ciBjbGlja3MKICAgICAvLyBvbiB0aGUgZWxlbWVudCwgb3IgcHJlc3NlcyBlbnRlciB3aGlsZSBp dCBpcyB0aGUgYWN0aXZlIGVsZW1lbnQuIEphdmFTY3JpcHQgY29kZSB3aXNoaW5nIHRvIGFjdGl2 YXRlIHRoZSBlbGVtZW50CiAgICAgLy8gbXVzdCBkaXNwYXRjaCBhIERPTUFjdGl2YXRlIGV2ZW50 IC0gYSBjbGljayBldmVudCB3aWxsIG5vdCBkbyB0aGUgam9iLgotICAgIGlmIChldnQtPnR5cGUo KSA9PSBldmVudE5hbWVzKCkuRE9NQWN0aXZhdGVFdmVudCAmJiAhZGlzYWJsZWQoKSkgewotICAg ICAgICBpZiAoZGVwcmVjYXRlZElucHV0VHlwZSgpID09IElNQUdFIHx8IGRlcHJlY2F0ZWRJbnB1 dFR5cGUoKSA9PSBTVUJNSVQgfHwgZGVwcmVjYXRlZElucHV0VHlwZSgpID09IFJFU0VUKSB7Ci0g ICAgICAgICAgICBpZiAoIWZvcm0oKSkKLSAgICAgICAgICAgICAgICByZXR1cm47Ci0gICAgICAg ICAgICBpZiAoZGVwcmVjYXRlZElucHV0VHlwZSgpID09IFJFU0VUKQotICAgICAgICAgICAgICAg IGZvcm0oKS0+cmVzZXQoKTsKLSAgICAgICAgICAgIGVsc2UgewotICAgICAgICAgICAgICAgIG1f YWN0aXZlU3VibWl0ID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICAvLyBGSVhNRTogV291bGQgYmUg Y2xlYW5lciB0byBnZXQgbV94UG9zIGFuZCBtX3lQb3Mgb3V0IG9mIHRoZSB1bmRlcmx5aW5nIG1v dXNlCi0gICAgICAgICAgICAgICAgLy8gZXZlbnQgKGlmIGFueSkgaGVyZSBpbnN0ZWFkIG9mIHJl bHlpbmcgb24gdGhlIHZhcmlhYmxlcyBzZXQgYWJvdmUgd2hlbgotICAgICAgICAgICAgICAgIC8v IHByb2Nlc3NpbmcgdGhlIGNsaWNrIGV2ZW50LiBFdmVuIGJldHRlciwgYXBwZW5kRm9ybURhdGEg Y291bGQgcGFzcyB0aGUKLSAgICAgICAgICAgICAgICAvLyBldmVudCBpbiwgYW5kIHRoZW4gd2Ug Y291bGQgZ2V0IHJpZCBvZiBtX3hQb3MgYW5kIG1feVBvcyBhbHRvZ2V0aGVyIQotICAgICAgICAg ICAgICAgIGlmICghZm9ybSgpLT5wcmVwYXJlU3VibWl0KGV2dCkpIHsKLSAgICAgICAgICAgICAg ICAgICAgbV94UG9zID0gMDsKLSAgICAgICAgICAgICAgICAgICAgbV95UG9zID0gMDsKLSAgICAg ICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgbV9hY3RpdmVTdWJtaXQgPSBmYWxzZTsKLSAg ICAgICAgICAgIH0KLSAgICAgICAgfSBlbHNlIGlmIChkZXByZWNhdGVkSW5wdXRUeXBlKCkgPT0g RklMRSAmJiByZW5kZXJlcigpKQotICAgICAgICAgICAgdG9SZW5kZXJGaWxlVXBsb2FkQ29udHJv bChyZW5kZXJlcigpKS0+Y2xpY2soKTsKLSAgICB9CisgICAgaWYgKGV2dC0+dHlwZSgpID09IGV2 ZW50TmFtZXMoKS5ET01BY3RpdmF0ZUV2ZW50ICYmICFkaXNhYmxlZCgpCisgICAgICAgICYmIG1f aW5wdXRUeXBlLT5oYW5kbGVET01BY3RpdmF0ZUV2ZW50KGV2dCkpCisgICAgICAgIHJldHVybjsK IAogICAgIC8vIFVzZSBrZXkgcHJlc3MgZXZlbnQgaGVyZSBzaW5jZSBzZW5kaW5nIHNpbXVsYXRl ZCBtb3VzZSBldmVudHMKICAgICAvLyBvbiBrZXkgZG93biBibG9ja3MgdGhlIHByb3BlciBzZW5k aW5nIG9mIHRoZSBrZXkgcHJlc3MgZXZlbnQuCkBAIC0xNTc1LDQ3ICsxNTEyLDYgQEAgdm9pZCBI VE1MSW5wdXRFbGVtZW50OjpoYW5kbGVCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudChFdmVudCogZXZl bnQpCiAgICAgSW5wdXRFbGVtZW50OjpoYW5kbGVCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudChtX2Rh dGEsIHRoaXMsIHRoaXMsIGV2ZW50KTsKIH0KIAotdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpoYW5k bGVLZXlFdmVudEZvclJhbmdlKEtleWJvYXJkRXZlbnQqIGV2ZW50KQotewotICAgIGlmIChldmVu dC0+dHlwZSgpICE9IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQpCi0gICAgICAgIHJldHVybjsK LSAgICBTdHJpbmcga2V5ID0gZXZlbnQtPmtleUlkZW50aWZpZXIoKTsKLSAgICBpZiAoa2V5ICE9 ICJVcCIgJiYga2V5ICE9ICJSaWdodCIgJiYga2V5ICE9ICJEb3duIiAmJiBrZXkgIT0gIkxlZnQi KQotICAgICAgICByZXR1cm47Ci0KLSAgICBFeGNlcHRpb25Db2RlIGVjOwotICAgIGlmIChlcXVh bElnbm9yaW5nQ2FzZShnZXRBdHRyaWJ1dGUoc3RlcEF0dHIpLCAiYW55IikpIHsKLSAgICAgICAg ZG91YmxlIG1pbiA9IG1faW5wdXRUeXBlLT5taW5pbXVtKCk7Ci0gICAgICAgIGRvdWJsZSBtYXgg PSBtX2lucHV0VHlwZS0+bWF4aW11bSgpOwotICAgICAgICAvLyBGSVhNRTogSXMgMS8xMDAgcmVh c29uYWJsZT8KLSAgICAgICAgZG91YmxlIHN0ZXAgPSAobWF4IC0gbWluKSAvIDEwMDsKLSAgICAg ICAgZG91YmxlIGN1cnJlbnQgPSBtX2lucHV0VHlwZS0+cGFyc2VUb0RvdWJsZSh2YWx1ZSgpLCBu dW1lcmljX2xpbWl0czxkb3VibGU+OjpxdWlldF9OYU4oKSk7Ci0gICAgICAgIEFTU0VSVChpc2Zp bml0ZShjdXJyZW50KSk7Ci0gICAgICAgIGRvdWJsZSBuZXdWYWx1ZTsKLSAgICAgICAgaWYgKGtl eSA9PSAiVXAiIHx8IGtleSA9PSAiUmlnaHQiKSB7Ci0gICAgICAgICAgICBuZXdWYWx1ZSA9IGN1 cnJlbnQgKyBzdGVwOwotICAgICAgICAgICAgaWYgKG5ld1ZhbHVlID4gbWF4KQotICAgICAgICAg ICAgICAgIG5ld1ZhbHVlID0gbWF4OwotICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgbmV3 VmFsdWUgPSBjdXJyZW50IC0gc3RlcDsKLSAgICAgICAgICAgIGlmIChuZXdWYWx1ZSA8IG1pbikK LSAgICAgICAgICAgICAgICBuZXdWYWx1ZSA9IG1pbjsKLSAgICAgICAgfQotICAgICAgICBpZiAo bmV3VmFsdWUgIT0gY3VycmVudCkgewotICAgICAgICAgICAgc2V0VmFsdWVBc051bWJlcihuZXdW YWx1ZSwgZWMpOwotICAgICAgICAgICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7 Ci0gICAgICAgIH0KLSAgICB9IGVsc2UgewotICAgICAgICBpbnQgc3RlcE1hZ25pZmljYXRpb24g PSAoa2V5ID09ICJVcCIgfHwga2V5ID09ICJSaWdodCIpID8gMSA6IC0xOwotICAgICAgICBTdHJp bmcgbGFzdFN0cmluZ1ZhbHVlID0gdmFsdWUoKTsKLSAgICAgICAgc3RlcFVwKHN0ZXBNYWduaWZp Y2F0aW9uLCBlYyk7Ci0gICAgICAgIGlmIChsYXN0U3RyaW5nVmFsdWUgIT0gdmFsdWUoKSkKLSAg ICAgICAgICAgIGRpc3BhdGNoRm9ybUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAgIH0KLSAgICBl dmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKLSAgICByZXR1cm47Ci19Ci0KIFBhc3NSZWZQdHI8 SFRNTEZvcm1FbGVtZW50PiBIVE1MSW5wdXRFbGVtZW50OjpjcmVhdGVUZW1wb3JhcnlGb3JtRm9y SXNJbmRleCgpCiB7CiAgICAgUmVmUHRyPEhUTUxGb3JtRWxlbWVudD4gZm9ybSA9IEhUTUxGb3Jt RWxlbWVudDo6Y3JlYXRlKGRvY3VtZW50KCkpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hU TUxJbnB1dEVsZW1lbnQuaCBiL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXgg MWEwNDkwZTcwMWExYjFiNTI3Yjg3N2ZjZGQ3ZmVmNDU0NTczOGJkNy4uMDU4YTVjNjcwMTU1NWNj MWU0OTg2OTIxNGY4NDg1OTI5MjVlYWVjMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxJ bnB1dEVsZW1lbnQuaAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCkBAIC0y MDMsMTAgKzIwMyw2IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIGRvY3VtZW50KCktPmNoZWNr ZWRSYWRpb0J1dHRvbnMoKTsKICAgICB9CiAKLSAgICAvLyBGSVhNRTogV2Ugc2hvdWxkIG1vdmUg bV94UG9zIGFuZCBtX3lQb3MgdG8gSW1hZ2VJbnB1dFR5cGUgY2xhc3MuCi0gICAgaW50IHhQb3Np dGlvbigpIGNvbnN0IHsgcmV0dXJuIG1feFBvczsgfQotICAgIGludCB5UG9zaXRpb24oKSBjb25z dCB7IHJldHVybiBtX3lQb3M7IH0KLQogcHJvdGVjdGVkOgogICAgIEhUTUxJbnB1dEVsZW1lbnQo Y29uc3QgUXVhbGlmaWVkTmFtZSYsIERvY3VtZW50KiwgSFRNTEZvcm1FbGVtZW50KiA9IDApOwog CkBAIC0zMzYsNyArMzMyLDYgQEAgcHJpdmF0ZToKICAgICB2b2lkIHVwZGF0ZUNoZWNrZWRSYWRp b0J1dHRvbnMoKTsKICAgICAKICAgICB2b2lkIGhhbmRsZUJlZm9yZVRleHRJbnNlcnRlZEV2ZW50 KEV2ZW50Kik7Ci0gICAgdm9pZCBoYW5kbGVLZXlFdmVudEZvclJhbmdlKEtleWJvYXJkRXZlbnQq KTsKICAgICBQYXNzUmVmUHRyPEhUTUxGb3JtRWxlbWVudD4gY3JlYXRlVGVtcG9yYXJ5Rm9ybUZv cklzSW5kZXgoKTsKICAgICAvLyBIZWxwZXIgZm9yIHN0ZXBVcCgpL3N0ZXBEb3duKCkuICBBZGRz IHN0ZXAgdmFsdWUgKiBjb3VudCB0byB0aGUgY3VycmVudCB2YWx1ZS4KICAgICB2b2lkIGFwcGx5 U3RlcChkb3VibGUgY291bnQsIEV4Y2VwdGlvbkNvZGUmKTsKQEAgLTM1MCw4ICszNDUsNiBAQCBw cml2YXRlOgogI2VuZGlmCiAKICAgICBJbnB1dEVsZW1lbnREYXRhIG1fZGF0YTsKLSAgICBpbnQg bV94UG9zOwotICAgIGludCBtX3lQb3M7CiAgICAgc2hvcnQgbV9tYXhSZXN1bHRzOwogICAgIE93 blB0cjxIVE1MSW1hZ2VMb2FkZXI+IG1faW1hZ2VMb2FkZXI7CiAgICAgUmVmUHRyPEZpbGVMaXN0 PiBtX2ZpbGVMaXN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0ltYWdlSW5wdXRUeXBlLmNw cCBiL1dlYkNvcmUvaHRtbC9JbWFnZUlucHV0VHlwZS5jcHAKaW5kZXggZGUyNDE4ODhlYzc3ZjVi MTYzOTVlNGZjOGZmYmY4Yjg5NjU4MjJhOC4uOTA4Nzc1NzczOGYwYzlmNjg3OWNkODhlZTA2MTFi NTEwZmZlNzc0ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0ltYWdlSW5wdXRUeXBlLmNwcAor KysgYi9XZWJDb3JlL2h0bWwvSW1hZ2VJbnB1dFR5cGUuY3BwCkBAIC0yNCwxMSArMjQsMTkgQEAK IAogI2luY2x1ZGUgIkZvcm1EYXRhTGlzdC5oIgogI2luY2x1ZGUgIkhUTUxJbnB1dEVsZW1lbnQu aCIKKyNpbmNsdWRlICJNb3VzZUV2ZW50LmgiCiAjaW5jbHVkZSAiUmVuZGVySW1hZ2UuaCIKICNp bmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK0FMV0FZ U19JTkxJTkUgSW1hZ2VJbnB1dFR5cGU6OkltYWdlSW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQq IGVsZW1lbnQpCisgICAgOiBCYXNlQnV0dG9uSW5wdXRUeXBlKGVsZW1lbnQpCisgICAgLCBtX3hQ b3NpdGlvbigwKQorICAgICwgbV95UG9zaXRpb24oMCkKK3sKK30KKwogUGFzc093blB0cjxJbnB1 dFR5cGU+IEltYWdlSW5wdXRUeXBlOjpjcmVhdGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkK IHsKICAgICByZXR1cm4gYWRvcHRQdHIobmV3IEltYWdlSW5wdXRUeXBlKGVsZW1lbnQpKTsKQEAg LTQ5LDggKzU3LDggQEAgYm9vbCBJbWFnZUlucHV0VHlwZTo6YXBwZW5kRm9ybURhdGEoRm9ybURh dGFMaXN0JiBlbmNvZGluZywgYm9vbCkgY29uc3QKICAgICBpZiAoIWVsZW1lbnQoKS0+aXNBY3Rp dmF0ZWRTdWJtaXQoKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIGNvbnN0IEF0b21pY1N0 cmluZyYgbmFtZSA9IGVsZW1lbnQoKS0+bmFtZSgpOwotICAgIGVuY29kaW5nLmFwcGVuZERhdGEo bmFtZS5pc0VtcHR5KCkgPyAieCIgOiAobmFtZSArICIueCIpLCBlbGVtZW50KCktPnhQb3NpdGlv bigpKTsKLSAgICBlbmNvZGluZy5hcHBlbmREYXRhKG5hbWUuaXNFbXB0eSgpID8gInkiIDogKG5h bWUgKyAiLnkiKSwgZWxlbWVudCgpLT55UG9zaXRpb24oKSk7CisgICAgZW5jb2RpbmcuYXBwZW5k RGF0YShuYW1lLmlzRW1wdHkoKSA/ICJ4IiA6IChuYW1lICsgIi54IiksIG1feFBvc2l0aW9uKTsK KyAgICBlbmNvZGluZy5hcHBlbmREYXRhKG5hbWUuaXNFbXB0eSgpID8gInkiIDogKG5hbWUgKyAi LnkiKSwgbV95UG9zaXRpb24pOwogICAgIGlmICghbmFtZS5pc0VtcHR5KCkgJiYgIWVsZW1lbnQo KS0+dmFsdWUoKS5pc0VtcHR5KCkpCiAgICAgICAgIGVuY29kaW5nLmFwcGVuZERhdGEobmFtZSwg ZWxlbWVudCgpLT52YWx1ZSgpKTsKICAgICByZXR1cm4gdHJ1ZTsKQEAgLTYxLDYgKzY5LDQzIEBA IGJvb2wgSW1hZ2VJbnB1dFR5cGU6OnN1cHBvcnRzVmFsaWRhdGlvbigpIGNvbnN0CiAgICAgcmV0 dXJuIGZhbHNlOwogfQogCitib29sIEltYWdlSW5wdXRUeXBlOjpoYW5kbGVDbGlja0V2ZW50KE1v dXNlRXZlbnQqIG1vdXNlRXZlbnQpCit7CisgICAgLy8gUmVjb3JkIHRoZSBtb3VzZSBwb3NpdGlv biBmb3Igd2hlbiB3ZSBnZXQgdGhlIERPTUFjdGl2YXRlIGV2ZW50CisKKyAgICAvLyBGSVhNRTog V2UgY291bGQganVzdCBjYWxsIG9mZnNldFgoKSBhbmQgb2Zmc2V0WSgpIG9uIHRoZSBldmVudCwK KyAgICAvLyBidXQgdGhhdCdzIGN1cnJlbnRseSBicm9rZW4sIHNvIGZvciBub3cgZG8gdGhlIGNv bXB1dGF0aW9uIGhlcmUuCisgICAgaWYgKG1vdXNlRXZlbnQtPmlzU2ltdWxhdGVkKCkgfHwgIWVs ZW1lbnQoKS0+cmVuZGVyZXIoKSkgeworICAgICAgICBtX3hQb3NpdGlvbiA9IDA7CisgICAgICAg IG1feVBvc2l0aW9uID0gMDsKKyAgICB9IGVsc2UgeworICAgICAgICAvLyBGSVhNRTogVGhpcyBk b2Vzbid0IHdvcmsgY29ycmVjdGx5IHdpdGggdHJhbnNmb3Jtcy4KKyAgICAgICAgLy8gRklYTUU6 IHBhZ2VYL3BhZ2VZIG5lZWQgYWRqdXN0aW5nIGZvciBwYWdlWm9vbUZhY3RvcigpLiBVc2UgYWN0 dWFsUGFnZUxvY2F0aW9uKCk/CisgICAgICAgIEludFBvaW50IGFic09mZnNldCA9IHJvdW5kZWRJ bnRQb2ludChlbGVtZW50KCktPnJlbmRlcmVyKCktPmxvY2FsVG9BYnNvbHV0ZSgpKTsKKyAgICAg ICAgbV94UG9zaXRpb24gPSBtb3VzZUV2ZW50LT5wYWdlWCgpIC0gYWJzT2Zmc2V0LngoKTsKKyAg ICAgICAgbV95UG9zaXRpb24gPSBtb3VzZUV2ZW50LT5wYWdlWSgpIC0gYWJzT2Zmc2V0LnkoKTsK KyAgICB9CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIEltYWdlSW5wdXRUeXBlOjpoYW5k bGVET01BY3RpdmF0ZUV2ZW50KEV2ZW50KiBldmVudCkKK3sKKyAgICBpZiAoIWVsZW1lbnQoKS0+ Zm9ybSgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBlbGVtZW50KCktPnNldEFjdGl2YXRl ZFN1Ym1pdCh0cnVlKTsKKyAgICAvLyBGSVhNRTogV291bGQgYmUgY2xlYW5lciB0byBnZXQgbV94 UG9zaXRpb24gYW5kIG1feVBvc2l0aW9uIG91dCBvZiB0aGUKKyAgICAvLyB1bmRlcmx5aW5nIG1v dXNlIGV2ZW50IChpZiBhbnkpIGhlcmUgaW5zdGVhZCBvZiByZWx5aW5nIG9uIHRoZSB2YXJpYWJs ZXMKKyAgICAvLyBzZXQgYWJvdmUgd2hlbiBwcm9jZXNzaW5nIHRoZSBjbGljayBldmVudC4gRXZl biBiZXR0ZXIsIGFwcGVuZEZvcm1EYXRhCisgICAgLy8gY291bGQgcGFzcyB0aGUgZXZlbnQgaW4s IGFuZCB0aGVuIHdlIGNvdWxkIGdldCByaWQgb2YgbV94UG9zaXRpb24gYW5kCisgICAgLy8gbV95 UG9zaXRpb24gYWx0b2dldGhlciEKKyAgICBpZiAoIWVsZW1lbnQoKS0+Zm9ybSgpLT5wcmVwYXJl U3VibWl0KGV2ZW50KSkgeworICAgICAgICBtX3hQb3NpdGlvbiA9IDA7CisgICAgICAgIG1feVBv c2l0aW9uID0gMDsKKyAgICB9CisgICAgZWxlbWVudCgpLT5zZXRBY3RpdmF0ZWRTdWJtaXQoZmFs c2UpOworICAgIHJldHVybiBmYWxzZTsKK30KKwogUmVuZGVyT2JqZWN0KiBJbWFnZUlucHV0VHlw ZTo6Y3JlYXRlUmVuZGVyZXIoUmVuZGVyQXJlbmEqIGFyZW5hLCBSZW5kZXJTdHlsZSopIGNvbnN0 CiB7CiAgICAgUmVuZGVySW1hZ2UqIGltYWdlID0gbmV3IChhcmVuYSkgUmVuZGVySW1hZ2UoZWxl bWVudCgpKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9JbWFnZUlucHV0VHlwZS5oIGIvV2Vi Q29yZS9odG1sL0ltYWdlSW5wdXRUeXBlLmgKaW5kZXggY2Q3NmU3MmZkNjYxOGFjZjQ2MmE2YjBi MzgyNGZiMjNkZjA1ZTdhNC4uNDY5YWQ2ZWI4Y2ZjNTA0YjIxYjk3ZjQ5NjI1NjkwZjAzYTIxYTc0 ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0ltYWdlSW5wdXRUeXBlLmgKKysrIGIvV2ViQ29y ZS9odG1sL0ltYWdlSW5wdXRUeXBlLmgKQEAgLTQwLDEyICs0MCwxNyBAQCBwdWJsaWM6CiAgICAg c3RhdGljIFBhc3NPd25QdHI8SW5wdXRUeXBlPiBjcmVhdGUoSFRNTElucHV0RWxlbWVudCopOwog CiBwcml2YXRlOgotICAgIEltYWdlSW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQp IDogQmFzZUJ1dHRvbklucHV0VHlwZShlbGVtZW50KSB7IH0KKyAgICBJbWFnZUlucHV0VHlwZShI VE1MSW5wdXRFbGVtZW50Kik7CiAgICAgdmlydHVhbCBjb25zdCBBdG9taWNTdHJpbmcmIGZvcm1D b250cm9sVHlwZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBpc0Zvcm1EYXRhQXBwZW5kYWJs ZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBhcHBlbmRGb3JtRGF0YShGb3JtRGF0YUxpc3Qm LCBib29sKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgc3VwcG9ydHNWYWxpZGF0aW9uKCkgY29u c3Q7CiAgICAgdmlydHVhbCBSZW5kZXJPYmplY3QqIGNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5h KiwgUmVuZGVyU3R5bGUqKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlQ2xpY2tFdmVu dChNb3VzZUV2ZW50Kik7CisgICAgdmlydHVhbCBib29sIGhhbmRsZURPTUFjdGl2YXRlRXZlbnQo RXZlbnQqKTsKKworICAgIGludCBtX3hQb3NpdGlvbjsKKyAgICBpbnQgbV95UG9zaXRpb247CiB9 OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSW5w dXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCmluZGV4IGM4NzBjNjk0M2U2 YWJjZTA4NzJkMGY5ZDY4NzY0ZjVkZDE2YjU4YmEuLjg3OGM3NzYxMWIzYzdhNTYyMmQ1ODZkMzMx ZDYyZTgxYTkxYzQ0NmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCisr KyBiL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVk ZSAiSGlkZGVuSW5wdXRUeXBlLmgiCiAjaW5jbHVkZSAiSW1hZ2VJbnB1dFR5cGUuaCIKICNpbmNs dWRlICJJc0luZGV4SW5wdXRUeXBlLmgiCisjaW5jbHVkZSAiS2V5Ym9hcmRFdmVudC5oIgogI2lu Y2x1ZGUgIk1vbnRoSW5wdXRUeXBlLmgiCiAjaW5jbHVkZSAiTnVtYmVySW5wdXRUeXBlLmgiCiAj aW5jbHVkZSAiUGFzc3dvcmRJbnB1dFR5cGUuaCIKQEAgLTI1Nyw2ICsyNTgsMzYgQEAgYm9vbCBJ bnB1dFR5cGU6OnNjYWxlZFN0ZXBWYWxldVNob3VsZEJlSW50ZWdlcigpIGNvbnN0CiAgICAgcmV0 dXJuIGZhbHNlOwogfQogCitib29sIElucHV0VHlwZTo6aGFuZGxlQ2xpY2tFdmVudChNb3VzZUV2 ZW50KikKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgSW5wdXRUeXBlOjpoYW5kbGVE T01BY3RpdmF0ZUV2ZW50KEV2ZW50KikKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wg SW5wdXRUeXBlOjpoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCopCit7CisgICAgcmV0 dXJuIGZhbHNlOworfQorCitib29sIElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50Rm9yU3Bp bkJ1dHRvbihLZXlib2FyZEV2ZW50KiBldmVudCkKK3sKKyAgICBTdHJpbmcga2V5ID0gc3RhdGlj X2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2ZW50KS0+a2V5SWRlbnRpZmllcigpOworICAgIGludCBz dGVwID0gMDsKKyAgICBpZiAoa2V5ID09ICJVcCIpCisgICAgICAgIHN0ZXAgPSAxOworICAgIGVs c2UgaWYgKGtleSA9PSAiRG93biIpCisgICAgICAgIHN0ZXAgPSAtMTsKKyAgICBpZiAoIXN0ZXAp CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBlbGVtZW50KCktPnN0ZXBVcEZyb21SZW5kZXJl cihzdGVwKTsKKyAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICByZXR1cm4gdHJ1 ZTsKK30KKwogUmVuZGVyT2JqZWN0KiBJbnB1dFR5cGU6OmNyZWF0ZVJlbmRlcmVyKFJlbmRlckFy ZW5hKiwgUmVuZGVyU3R5bGUqIHN0eWxlKSBjb25zdAogewogICAgIHJldHVybiBSZW5kZXJPYmpl Y3Q6OmNyZWF0ZU9iamVjdChlbGVtZW50KCksIHN0eWxlKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv aHRtbC9JbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaAppbmRleCBmNjAxMDUx M2ZiYzZkMDc2ZDU1MTUzZGJiMTdlMWQ3OTg0NGY1MTVlLi45NTQ3ZTA5MjMxNjA1MjhlMzQ3YmI1 ZGY0MmVkM2NhY2U5MDdjYzQ2IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgK KysrIGIvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5oCkBAIC0zOCw4ICszOCwxMSBAQAogbmFtZXNw YWNlIFdlYkNvcmUgewogCiBjbGFzcyBEYXRlQ29tcG9uZW50czsKK2NsYXNzIEV2ZW50OwogY2xh c3MgRm9ybURhdGFMaXN0OwogY2xhc3MgSFRNTElucHV0RWxlbWVudDsKK2NsYXNzIEtleWJvYXJk RXZlbnQ7CitjbGFzcyBNb3VzZUV2ZW50OwogY2xhc3MgUmVuZGVyQXJlbmE7CiBjbGFzcyBSZW5k ZXJPYmplY3Q7CiBjbGFzcyBSZW5kZXJTdHlsZTsKQEAgLTk1LDYgKzk4LDEyIEBAIHB1YmxpYzoK ICAgICB2aXJ0dWFsIGJvb2wgcGFyc2VkU3RlcFZhbHVlU2hvdWxkQmVJbnRlZ2VyKCkgY29uc3Q7 CiAgICAgdmlydHVhbCBib29sIHNjYWxlZFN0ZXBWYWxldVNob3VsZEJlSW50ZWdlcigpIGNvbnN0 OwogCisgICAgLy8gRXZlbnQgaGFuZGxlcnMKKworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVDbGlj a0V2ZW50KE1vdXNlRXZlbnQqKTsKKyAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlRE9NQWN0aXZhdGVF dmVudChFdmVudCopOworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9h cmRFdmVudCopOworCiAgICAgLy8gTWlzY2VsbGFuZW91cyBmdW5jdGlvbnMKIAogICAgIHZpcnR1 YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxl KikgY29uc3Q7CkBAIC0xMjAsNiArMTI5LDggQEAgcHJvdGVjdGVkOgogICAgIC8vIFdlIGNhbid0 IG1ha2UgdGhpcyBhIHN0YXRpYyBjb25zdCBkYXRhIG1lbWJlciBiZWNhdXNlIFZDKysgZG9lc24n dCBsaWtlIGl0LgogICAgIHN0YXRpYyBkb3VibGUgZGVmYXVsdFN0ZXBCYXNlKCkgeyByZXR1cm4g MC4wOyB9CiAKKyAgICBib29sIGhhbmRsZUtleWRvd25FdmVudEZvclNwaW5CdXR0b24oS2V5Ym9h cmRFdmVudCopOworCiBwcml2YXRlOgogICAgIC8vIFJhdyBwb2ludGVyIGJlY2F1c2UgdGhlIEhU TUxJbnB1dEVsZW1lbnQgb2JqZWN0IG93bnMgdGhpcyBJbnB1dFR5cGUgb2JqZWN0LgogICAgIEhU TUxJbnB1dEVsZW1lbnQqIG1fZWxlbWVudDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9OdW1i ZXJJbnB1dFR5cGUuY3BwIGIvV2ViQ29yZS9odG1sL051bWJlcklucHV0VHlwZS5jcHAKaW5kZXgg YTRlMTE4YzAyZjMyYzA5ZDM3MWM1Y2Q4ZmY5MjUyNjI1YTNiZGQ3ZC4uNzQyZmRjMGNjMDVlNzU1 MDE2NzQ1OWE3YzY1NGYwMDc2ZjU1ZWM3NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL051bWJl cklucHV0VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL051bWJlcklucHV0VHlwZS5jcHAKQEAg LTE0MCw2ICsxNDAsMTMgQEAgZG91YmxlIE51bWJlcklucHV0VHlwZTo6c3RlcFNjYWxlRmFjdG9y KCkgY29uc3QKICAgICByZXR1cm4gbnVtYmVyU3RlcFNjYWxlRmFjdG9yOwogfQogCitib29sIE51 bWJlcklucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqIGV2ZW50KQor eworICAgIGlmIChoYW5kbGVLZXlkb3duRXZlbnRGb3JTcGluQnV0dG9uKGV2ZW50KSkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgcmV0dXJuIFRleHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5 ZG93bkV2ZW50Rm9yU3BpbkJ1dHRvbihldmVudCk7Cit9CisKIGRvdWJsZSBOdW1iZXJJbnB1dFR5 cGU6OnBhcnNlVG9Eb3VibGUoY29uc3QgU3RyaW5nJiBzcmMsIGRvdWJsZSBkZWZhdWx0VmFsdWUp IGNvbnN0CiB7CiAgICAgZG91YmxlIG51bWJlclZhbHVlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9o dG1sL051bWJlcklucHV0VHlwZS5oIGIvV2ViQ29yZS9odG1sL051bWJlcklucHV0VHlwZS5oCmlu ZGV4IDI2Mjk1NWU3ZDkxOTI0ZmQ1YjEzNGJjNWU2NWY5MDIyZmFjYjg2MGEuLjBlNTY4ODc3NTVk OTU5NTFkMTg4MjUzMmIxN2JlYjAyNmQxZjQzZDcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9O dW1iZXJJbnB1dFR5cGUuaAorKysgYi9XZWJDb3JlL2h0bWwvTnVtYmVySW5wdXRUeXBlLmgKQEAg LTU0LDYgKzU0LDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIGRvdWJsZSBzdGVwQmFzZSgpIGNv bnN0OwogICAgIHZpcnR1YWwgZG91YmxlIGRlZmF1bHRTdGVwKCkgY29uc3Q7CiAgICAgdmlydHVh bCBkb3VibGUgc3RlcFNjYWxlRmFjdG9yKCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGhhbmRs ZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50Kik7CiAgICAgdmlydHVhbCBkb3VibGUgcGFyc2VU b0RvdWJsZShjb25zdCBTdHJpbmcmLCBkb3VibGUpIGNvbnN0OwogICAgIHZpcnR1YWwgU3RyaW5n IHNlcmlhbGl6ZShkb3VibGUpIGNvbnN0OwogfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9S YWRpb0lucHV0VHlwZS5jcHAgYi9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuY3BwCmluZGV4 IDVkZjRiYmM0NGEwNDA1MjJiYzQ0OTM3ZGY2ZTAwNmU0ZTQ2NDJjODUuLmE2YzQ3MDdiZTViODlj NWYyZjA3MDBhZjk3NTQ0MDZjOTg1Njg5NjggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9SYWRp b0lucHV0VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmNwcApAQCAt MzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlJhZGlvSW5wdXRUeXBlLmgiCiAKICNpbmNsdWRlICJI VE1MSW5wdXRFbGVtZW50LmgiCisjaW5jbHVkZSAiTW91c2VFdmVudC5oIgogI2luY2x1ZGUgPHd0 Zi9QYXNzT3duUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTUxLDQgKzUyLDEwIEBA IGJvb2wgUmFkaW9JbnB1dFR5cGU6OnZhbHVlTWlzc2luZyhjb25zdCBTdHJpbmcmKSBjb25zdAog ICAgIHJldHVybiAhZWxlbWVudCgpLT5jaGVja2VkUmFkaW9CdXR0b25zKCkuY2hlY2tlZEJ1dHRv bkZvckdyb3VwKGVsZW1lbnQoKS0+bmFtZSgpKTsKIH0KIAorYm9vbCBSYWRpb0lucHV0VHlwZTo6 aGFuZGxlQ2xpY2tFdmVudChNb3VzZUV2ZW50KiBldmVudCkKK3sKKyAgICBldmVudC0+c2V0RGVm YXVsdEhhbmRsZWQoKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmggYi9XZWJDb3Jl L2h0bWwvUmFkaW9JbnB1dFR5cGUuaAppbmRleCA5ZTdhYjAwZGNlMmI4YTY1MjYyNzhmNDYxNjM0 ODU4OTE4MDIyOTRlLi4yNzk4MDEwYTA0NTc0NDRiZGRlNjNjY2ZiMTdlNDBiZmQwYmViNmYzIDEw MDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuaAorKysgYi9XZWJDb3JlL2h0 bWwvUmFkaW9JbnB1dFR5cGUuaApAQCAtNDMsNiArNDMsNyBAQCBwcml2YXRlOgogICAgIFJhZGlv SW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpIDogQmFzZUNoZWNrYWJsZUlucHV0 VHlwZShlbGVtZW50KSB7IH0KICAgICB2aXJ0dWFsIGNvbnN0IEF0b21pY1N0cmluZyYgZm9ybUNv bnRyb2xUeXBlKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHZhbHVlTWlzc2luZyhjb25zdCBT dHJpbmcmKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlQ2xpY2tFdmVudChNb3VzZUV2 ZW50Kik7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3Jl L2h0bWwvUmFuZ2VJbnB1dFR5cGUuY3BwIGIvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNw cAppbmRleCAxNzZkNzNiNTIwMjZhNzBkYzA1MjliY2E1NGJlOTA5ZThlZDY3ZWYxLi42NDA3MDE4 OThhMjdhODEyMGM4NDIwNGNmNDdhZjA5ZmZiNzE5YzVhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0 bWwvUmFuZ2VJbnB1dFR5cGUuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5j cHAKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCiAjaW5j bHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiSFRNTFBhcnNlcklkaW9tcy5oIgorI2luY2x1 ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJSZW5kZXJTbGlkZXIuaCIKICNpbmNsdWRl IDxsaW1pdHM+CiAjaW5jbHVkZSA8d3RmL01hdGhFeHRyYXMuaD4KQEAgLTEyNyw2ICsxMjgsNDUg QEAgZG91YmxlIFJhbmdlSW5wdXRUeXBlOjpzdGVwU2NhbGVGYWN0b3IoKSBjb25zdAogICAgIHJl dHVybiByYW5nZVN0ZXBTY2FsZUZhY3RvcjsKIH0KIAorYm9vbCBSYW5nZUlucHV0VHlwZTo6aGFu ZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqIGV2ZW50KQoreworICAgIFN0cmluZyBrZXkg PSBldmVudC0+a2V5SWRlbnRpZmllcigpOworICAgIGlmIChrZXkgIT0gIlVwIiAmJiBrZXkgIT0g IlJpZ2h0IiAmJiBrZXkgIT0gIkRvd24iICYmIGtleSAhPSAiTGVmdCIpCisgICAgICAgIHJldHVy biBmYWxzZTsKKworICAgIEV4Y2VwdGlvbkNvZGUgZWM7CisgICAgaWYgKGVxdWFsSWdub3JpbmdD YXNlKGVsZW1lbnQoKS0+ZmFzdEdldEF0dHJpYnV0ZShzdGVwQXR0ciksICJhbnkiKSkgeworICAg ICAgICBkb3VibGUgbWluID0gbWluaW11bSgpOworICAgICAgICBkb3VibGUgbWF4ID0gbWF4aW11 bSgpOworICAgICAgICAvLyBGSVhNRTogSXMgMS8xMDAgcmVhc29uYWJsZT8KKyAgICAgICAgZG91 YmxlIHN0ZXAgPSAobWF4IC0gbWluKSAvIDEwMDsKKyAgICAgICAgZG91YmxlIGN1cnJlbnQgPSBw YXJzZVRvRG91YmxlKGVsZW1lbnQoKS0+dmFsdWUoKSwgbnVtZXJpY19saW1pdHM8ZG91YmxlPjo6 cXVpZXRfTmFOKCkpOworICAgICAgICBBU1NFUlQoaXNmaW5pdGUoY3VycmVudCkpOworICAgICAg ICBkb3VibGUgbmV3VmFsdWU7CisgICAgICAgIGlmIChrZXkgPT0gIlVwIiB8fCBrZXkgPT0gIlJp Z2h0IikgeworICAgICAgICAgICAgbmV3VmFsdWUgPSBjdXJyZW50ICsgc3RlcDsKKyAgICAgICAg ICAgIGlmIChuZXdWYWx1ZSA+IG1heCkKKyAgICAgICAgICAgICAgICBuZXdWYWx1ZSA9IG1heDsK KyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIG5ld1ZhbHVlID0gY3VycmVudCAtIHN0ZXA7 CisgICAgICAgICAgICBpZiAobmV3VmFsdWUgPCBtaW4pCisgICAgICAgICAgICAgICAgbmV3VmFs dWUgPSBtaW47CisgICAgICAgIH0KKyAgICAgICAgaWYgKG5ld1ZhbHVlICE9IGN1cnJlbnQpIHsK KyAgICAgICAgICAgIHNldFZhbHVlQXNOdW1iZXIobmV3VmFsdWUsIGVjKTsKKyAgICAgICAgICAg IGVsZW1lbnQoKS0+ZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisgICAgICAgIH0K KyAgICB9IGVsc2UgeworICAgICAgICBpbnQgc3RlcE1hZ25pZmljYXRpb24gPSAoa2V5ID09ICJV cCIgfHwga2V5ID09ICJSaWdodCIpID8gMSA6IC0xOworICAgICAgICBTdHJpbmcgbGFzdFN0cmlu Z1ZhbHVlID0gZWxlbWVudCgpLT52YWx1ZSgpOworICAgICAgICBlbGVtZW50KCktPnN0ZXBVcChz dGVwTWFnbmlmaWNhdGlvbiwgZWMpOworICAgICAgICBpZiAobGFzdFN0cmluZ1ZhbHVlICE9IGVs ZW1lbnQoKS0+dmFsdWUoKSkKKyAgICAgICAgICAgIGVsZW1lbnQoKS0+ZGlzcGF0Y2hGb3JtQ29u dHJvbENoYW5nZUV2ZW50KCk7CisgICAgfQorICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgp OworICAgIHJldHVybiB0cnVlOworfQorCiBSZW5kZXJPYmplY3QqIFJhbmdlSW5wdXRUeXBlOjpj cmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSogYXJlbmEsIFJlbmRlclN0eWxlKikgY29uc3QKIHsK ICAgICByZXR1cm4gbmV3IChhcmVuYSkgUmVuZGVyU2xpZGVyKGVsZW1lbnQoKSk7CmRpZmYgLS1n aXQgYS9XZWJDb3JlL2h0bWwvUmFuZ2VJbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9SYW5nZUlu cHV0VHlwZS5oCmluZGV4IDY0NTQ4ZjY3MTE5ODRmNDRkZDg1OTFjOThjOWU0OTU3NGRlYzg0ZjEu LmMyYmJiMGZjMWQxMzJiMGY3OWI1ZDcxNGNkYjUxNWRkOWNlMzE1YTEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0 VHlwZS5oCkBAIC01Myw2ICs1Myw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBkb3VibGUgc3Rl cEJhc2UoKSBjb25zdDsKICAgICB2aXJ0dWFsIGRvdWJsZSBkZWZhdWx0U3RlcCgpIGNvbnN0Owog ICAgIHZpcnR1YWwgZG91YmxlIHN0ZXBTY2FsZUZhY3RvcigpIGNvbnN0OworICAgIHZpcnR1YWwg Ym9vbCBoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCopOwogICAgIHZpcnR1YWwgUmVu ZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKikgY29u c3Q7CiAgICAgdmlydHVhbCBkb3VibGUgcGFyc2VUb0RvdWJsZShjb25zdCBTdHJpbmcmLCBkb3Vi bGUpIGNvbnN0OwogICAgIHZpcnR1YWwgU3RyaW5nIHNlcmlhbGl6ZShkb3VibGUpIGNvbnN0Owpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL1Jlc2V0SW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRt bC9SZXNldElucHV0VHlwZS5jcHAKaW5kZXggMWRiNzU5MjU0YjE2M2NhZGVhYmRlMDJjYjZkYjBi ZDdkZTJkZDQ4OC4uZmY2ODE3ZGUyNTBlMWRlMmE2ZDgzYjg4ZGM4NjhlZmYwYzQ3ZWI5MyAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9odG1sL1Jlc2V0SW5wdXRUeXBlLmNwcAorKysgYi9XZWJDb3JlL2h0 bWwvUmVzZXRJbnB1dFR5cGUuY3BwCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiY29uZmln LmgiCiAjaW5jbHVkZSAiUmVzZXRJbnB1dFR5cGUuaCIKIAorI2luY2x1ZGUgIkhUTUxJbnB1dEVs ZW1lbnQuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CkBAIC01MCw0ICs1MSwxMiBAQCBib29sIFJlc2V0SW5wdXRUeXBlOjpzdXBwb3J0c1ZhbGlk YXRpb24oKSBjb25zdAogICAgIHJldHVybiBmYWxzZTsKIH0KIAorYm9vbCBSZXNldElucHV0VHlw ZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudChFdmVudCopCit7CisgICAgaWYgKCFlbGVtZW50KCkt PmZvcm0oKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgZWxlbWVudCgpLT5mb3JtKCktPnJl c2V0KCk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvUmVzZXRJbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9S ZXNldElucHV0VHlwZS5oCmluZGV4IGFkOTQwYjQ0YzZhMzI4MjUwNjRiZjMzYjhiZDBmOTMyMDZi YjRhZGQuLjE1M2FmYWMxOTJjZjcyZjM1MmUwM2EwODllY2VhZGNiODA5YTIwZmUgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvaHRtbC9SZXNldElucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9SZXNl dElucHV0VHlwZS5oCkBAIC00Myw2ICs0Myw3IEBAIHByaXZhdGU6CiAgICAgUmVzZXRJbnB1dFR5 cGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkgOiBCYXNlQnV0dG9uSW5wdXRUeXBlKGVsZW1l bnQpIHsgfQogICAgIHZpcnR1YWwgY29uc3QgQXRvbWljU3RyaW5nJiBmb3JtQ29udHJvbFR5cGUo KSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgc3VwcG9ydHNWYWxpZGF0aW9uKCkgY29uc3Q7Cisg ICAgdmlydHVhbCBib29sIGhhbmRsZURPTUFjdGl2YXRlRXZlbnQoRXZlbnQqKTsKIH07CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1 dFR5cGUuY3BwIGIvV2ViQ29yZS9odG1sL1N1Ym1pdElucHV0VHlwZS5jcHAKaW5kZXggOTljODA4 ZTE0YjUwYzY1NzliYTE1ODU0ZDM1NDMyOGJkNGI3MTVjMy4uY2M0Yjk2ZDYyZDFhMWZiODI4MmJm MWVlNzFiN2Q0MGE2Y2E2NGY4ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1N1Ym1pdElucHV0 VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL1N1Ym1pdElucHV0VHlwZS5jcHAKQEAgLTYwLDQg KzYwLDE0IEBAIGJvb2wgU3VibWl0SW5wdXRUeXBlOjpzdXBwb3J0c1ZhbGlkYXRpb24oKSBjb25z dAogICAgIHJldHVybiBmYWxzZTsKIH0KIAorYm9vbCBTdWJtaXRJbnB1dFR5cGU6OmhhbmRsZURP TUFjdGl2YXRlRXZlbnQoRXZlbnQqIGV2ZW50KQoreworICAgIGlmICghZWxlbWVudCgpLT5mb3Jt KCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIGVsZW1lbnQoKS0+c2V0QWN0aXZhdGVkU3Vi bWl0KHRydWUpOworICAgIGVsZW1lbnQoKS0+Zm9ybSgpLT5wcmVwYXJlU3VibWl0KGV2ZW50KTsK KyAgICBlbGVtZW50KCktPnNldEFjdGl2YXRlZFN1Ym1pdChmYWxzZSk7CisgICAgcmV0dXJuIGZh bHNlOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0 bWwvU3VibWl0SW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvU3VibWl0SW5wdXRUeXBlLmgKaW5k ZXggMmZlN2FjZTk2YzUzMDU3ODAyMmZiNGQyM2E0ZWMxOGY5MjdiMWZjYS4uZDAzMjE5Y2UxOWYz YTgzZGZkMDY1NDA1NmVkMDJmOGI2ZDkzNDI4NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1N1 Ym1pdElucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1dFR5cGUuaApAQCAt NDQsNiArNDQsNyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgY29uc3QgQXRvbWljU3RyaW5nJiBm b3JtQ29udHJvbFR5cGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgYXBwZW5kRm9ybURhdGEo Rm9ybURhdGFMaXN0JiwgYm9vbCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHN1cHBvcnRzVmFs aWRhdGlvbigpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVET01BY3RpdmF0ZUV2ZW50 KEV2ZW50Kik7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJD b3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJ bnB1dFR5cGUuY3BwCmluZGV4IDkyNmQwYWM2Nzk2Njc0NjRkZDY4MjU2ZjczYTIwNGNlZWMzYmFm YjQuLjFkMjE4ZjFlOTBhMDViZTc0ODYwMDdkNGZmYWRlNjMyZmJkNzI5MzMgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9U ZXh0RmllbGRJbnB1dFR5cGUuY3BwCkBAIC0zMSw3ICszMSw5IEBACiAjaW5jbHVkZSAiY29uZmln LmgiCiAjaW5jbHVkZSAiVGV4dEZpZWxkSW5wdXRUeXBlLmgiCiAKKyNpbmNsdWRlICJGcmFtZS5o IgogI2luY2x1ZGUgIkhUTUxJbnB1dEVsZW1lbnQuaCIKKyNpbmNsdWRlICJLZXlib2FyZEV2ZW50 LmgiCiAjaW5jbHVkZSAiUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVMaW5lLmgiCiAjaW5jbHVkZSA8 d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKQEAgLTQ3LDYgKzQ5LDE5IEBAIGJvb2wgVGV4dEZpZWxk SW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmcoY29uc3QgU3RyaW5nJiB2YWx1ZSkgY29uc3QKICAgICBy ZXR1cm4gdmFsdWUuaXNFbXB0eSgpOwogfQogCitib29sIFRleHRGaWVsZElucHV0VHlwZTo6aGFu ZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqIGV2ZW50KQoreworICAgIGlmICghZWxlbWVu dCgpLT5mb2N1c2VkKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBEb2N1bWVudCogZG9j dW1lbnQgPSBlbGVtZW50KCktPmRvY3VtZW50KCk7CisgICAgaWYgKCFkb2N1bWVudC0+ZnJhbWUo KSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGlmICghZG9jdW1lbnQtPmZyYW1lKCktPmVk aXRvcigpLT5kb1RleHRGaWVsZENvbW1hbmRGcm9tRXZlbnQoZWxlbWVudCgpLCBldmVudCkpCisg ICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAg ICByZXR1cm4gdHJ1ZTsKK30KKwogUmVuZGVyT2JqZWN0KiBUZXh0RmllbGRJbnB1dFR5cGU6OmNy ZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqKSBjb25zdAogewog ICAgIHJldHVybiBuZXcgKGFyZW5hKSBSZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUoZWxlbWVu dCgpLCBlbGVtZW50KCktPnBsYWNlaG9sZGVyU2hvdWxkQmVWaXNpYmxlKCkpOwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5oIGIvV2ViQ29yZS9odG1sL1RleHRG aWVsZElucHV0VHlwZS5oCmluZGV4IDc4YmVjMWQ1OGUxYTNmNWIyYjljYjFhMzE1MDkyNWVjN2Jm NGU5NTUuLjU3ODcyYjlmZTdmODBjYzNhYjQyZTgzMzZmMzc5M2UxYmU4NmY3ZTUgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaAorKysgYi9XZWJDb3JlL2h0bWwv VGV4dEZpZWxkSW5wdXRUeXBlLmgKQEAgLTQyLDYgKzQyLDcgQEAgcHJvdGVjdGVkOgogICAgIFRl eHRGaWVsZElucHV0VHlwZShIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KSA6IElucHV0VHlwZShl bGVtZW50KSB7IH0KICAgICB2aXJ0dWFsIGJvb2wgaXNUZXh0RmllbGQoKSBjb25zdDsKICAgICB2 aXJ0dWFsIGJvb2wgdmFsdWVNaXNzaW5nKGNvbnN0IFN0cmluZyYpIGNvbnN0OworICAgIHZpcnR1 YWwgYm9vbCBoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCopOwogICAgIHZpcnR1YWwg UmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKikg Y29uc3Q7CiB9OwogCg== 73703 2010-11-11 23:28:10 -0800 2010-11-14 21:35:08 -0800 Patch 2 bug-48317-20101112162808.patch text/plain 28340 tkent ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NDMxODEyNTcxZGMwN2NjM2NlM2VhMTQyZGI4ZjU1ZDhjNDIxZTI3My4uM2NjOTQ4YTk5NGNmNzhh ZDAyNWZkNDhkZGZlZjg0MmRmMzI4NGVlZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2MyBAQAorMjAxMC0xMC0yNiAgS2Vu dCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgSFRNTElucHV0RWxlbWVudDogTW92ZSBh IHBhcnQgb2YgSFRNTElucHV0RWxlbWVudDo6CisgICAgICAgIGRlZmF1bHRFdmVudEhhbmRsZXIo KSB0byBJbnB1dFR5cGVzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NDgzMTcKKworICAgICAgICBNb3ZlIG91dCB0aGUgZm9sbG93aW5ncyB0byBJbnB1 dFR5cGVzOgorICAgICAgICAgLSBjbGljayBldmVudCBwcm9jZXNzaW5nLAorICAgICAgICAgLSB0 aGUgZmlyc3Qga2V5ZG93biBldmVudCBwcm9jZXNzaW5nLCBhbmQKKyAgICAgICAgIC0gRE9NQWN0 aXZhdGUgZXZlbnQgcHJvY2Vzc2luZy4KKworICAgICAgICBNb3ZlIG1feFBvcyBhbmQgbV95UG9z IGZyb20gSFRNTElucHV0RWxlbWVudCB0byBJbWFnZUlucHV0VHlwZSBhcworICAgICAgICBtX2Ns aWNrTG9jYXRpb24uIEl0J3Mgb2sgdG8gbW92ZSB0aGVtIGJlY2F1c2UgdGhleSBzaG91bGQgYmUg dmFsaWQgb25seQorICAgICAgICB3aGVuIEhUTUxJbnB1dEVsZW1lbnQ6Om1fYWN0aXZlU3VibWl0 IGlzIHRydWUuIEZvciB0eXBlPWltYWdlLAorICAgICAgICBtX2FjdGl2ZVN1Ym1pdCBpcyB0cnVl IG9ubHkgaW4gRE9NQWN0aXZhdGUgZXZlbnQgaGFuZGxpbmcuIFNvIHdlIHJlc2V0CisgICAgICAg IG1fY2xpY2tMb2NhdGlvbiBpbiBoYW5kbGVET01BY3RpdmF0ZUV2ZW50KCkgd2l0aCBFdmVudDo6 dW5kZXJseWluZ0V2ZW50KCkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIGJlY2F1c2UgdGhpcyBp cyBqdXN0IGEgcmVmYWN0b3JpbmcuCisKKyAgICAgICAgKiBodG1sL0Jhc2VEYXRlQW5kVGltZUlu cHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpCYXNlRGF0ZUFuZFRpbWVJbnB1dFR5cGU6 OmhhbmRsZUtleWRvd25FdmVudCk6CisgICAgICAgICogaHRtbC9CYXNlRGF0ZUFuZFRpbWVJbnB1 dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL0ZpbGVJbnB1dFR5cGUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6RmlsZUlucHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudCk6CisgICAgICAgICog aHRtbC9GaWxlSW5wdXRUeXBlLmg6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OkhUTUxJbnB1dEVsZW1lbnQp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxl cik6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9J bWFnZUlucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbWFnZUlucHV0VHlwZTo6YXBw ZW5kRm9ybURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6SW1hZ2VJbnB1dFR5cGU6OmhhbmRsZURP TUFjdGl2YXRlRXZlbnQpOgorICAgICAgICAqIGh0bWwvSW1hZ2VJbnB1dFR5cGUuaDoKKyAgICAg ICAgKiBodG1sL0lucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnB1dFR5cGU6Omhh bmRsZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6SW5wdXRUeXBlOjpoYW5kbGVET01B Y3RpdmF0ZUV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OklucHV0VHlwZTo6aGFuZGxlS2V5ZG93 bkV2ZW50KToKKyAgICAgICAgKiBodG1sL0lucHV0VHlwZS5oOgorICAgICAgICAqIGh0bWwvTnVt YmVySW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok51bWJlcklucHV0VHlwZTo6aGFu ZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKiBodG1sL051bWJlcklucHV0VHlwZS5oOgorICAg ICAgICAqIGh0bWwvUmFkaW9JbnB1dFR5cGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9J bnB1dFR5cGU6OmhhbmRsZUNsaWNrRXZlbnQpOgorICAgICAgICAqIGh0bWwvUmFkaW9JbnB1dFR5 cGUuaDoKKyAgICAgICAgKiBodG1sL1JhbmdlSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJhbmdlSW5wdXRUeXBlOjpoYW5kbGVLZXlkb3duRXZlbnQpOgorICAgICAgICAqIGh0bWwv UmFuZ2VJbnB1dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL1Jlc2V0SW5wdXRUeXBlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlJlc2V0SW5wdXRUeXBlOjpoYW5kbGVET01BY3RpdmF0ZUV2ZW50KToK KyAgICAgICAgKiBodG1sL1Jlc2V0SW5wdXRUeXBlLmg6CisgICAgICAgICogaHRtbC9TdWJtaXRJ bnB1dFR5cGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3VibWl0SW5wdXRUeXBlOjpoYW5kbGVE T01BY3RpdmF0ZUV2ZW50KToKKyAgICAgICAgKiBodG1sL1N1Ym1pdElucHV0VHlwZS5oOgorICAg ICAgICAqIGh0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRl eHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6 OlRleHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50Rm9yU3BpbkJ1dHRvbik6Cisg ICAgICAgICogaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaDoKKwogMjAxMC0xMS0xMSAgQ2Fyb2wg U3phYm8gPGNhcm9sLnN6YWJvQG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBLZW50 IFRhbXVyYS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9CYXNlRGF0ZUFuZFRpbWVJbnB1dFR5 cGUuY3BwIGIvV2ViQ29yZS9odG1sL0Jhc2VEYXRlQW5kVGltZUlucHV0VHlwZS5jcHAKaW5kZXgg ZTExMjZkNGQ2ZDdiOWVjYWU1OTZjZGY5NTQ5YTBkNjdiMTM5Mzk3Mi4uZTc4MGVkNmJhMjRkMjBm YWZiZGI2MjllMjgzNjk4NWYxYTVhOTBjYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0Jhc2VE YXRlQW5kVGltZUlucHV0VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0Jhc2VEYXRlQW5kVGlt ZUlucHV0VHlwZS5jcHAKQEAgLTEwOCw2ICsxMDgsMTEgQEAgZG91YmxlIEJhc2VEYXRlQW5kVGlt ZUlucHV0VHlwZTo6c3RlcEJhc2UoKSBjb25zdAogICAgIHJldHVybiBwYXJzZVRvRG91YmxlKGVs ZW1lbnQoKS0+ZmFzdEdldEF0dHJpYnV0ZShtaW5BdHRyKSwgZGVmYXVsdFN0ZXBCYXNlKCkpOwog fQogCitib29sIEJhc2VEYXRlQW5kVGltZUlucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtl eWJvYXJkRXZlbnQqIGV2ZW50KQoreworICAgIHJldHVybiBoYW5kbGVLZXlkb3duRXZlbnRGb3JT cGluQnV0dG9uKGV2ZW50KSB8fCBUZXh0RmllbGRJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVu dChldmVudCk7Cit9CisKIGRvdWJsZSBCYXNlRGF0ZUFuZFRpbWVJbnB1dFR5cGU6OnBhcnNlVG9E b3VibGUoY29uc3QgU3RyaW5nJiBzcmMsIGRvdWJsZSBkZWZhdWx0VmFsdWUpIGNvbnN0CiB7CiAg ICAgRGF0ZUNvbXBvbmVudHMgZGF0ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9CYXNlRGF0 ZUFuZFRpbWVJbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9CYXNlRGF0ZUFuZFRpbWVJbnB1dFR5 cGUuaAppbmRleCA4M2MxZTkzZmUyNDE3MzM5MjQ4MTdhNDRmYjA1OTE4ZjkwYzg5NzJjLi4xMWM2 MGFmY2E2NThjNmI3MjJmYzAyN2RkZTU4NGNkNjc1NjBkNDlhIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2h0bWwvQmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL0Jhc2VE YXRlQW5kVGltZUlucHV0VHlwZS5oCkBAIC01Nyw2ICs1Nyw3IEBAIHByaXZhdGU6CiAgICAgdmly dHVhbCBib29sIHJhbmdlT3ZlcmZsb3coY29uc3QgU3RyaW5nJikgY29uc3Q7CiAgICAgdmlydHVh bCBib29sIHN0ZXBNaXNtYXRjaChjb25zdCBTdHJpbmcmLCBkb3VibGUpIGNvbnN0OwogICAgIHZp cnR1YWwgZG91YmxlIHN0ZXBCYXNlKCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGhhbmRsZUtl eWRvd25FdmVudChLZXlib2FyZEV2ZW50Kik7CiAgICAgdmlydHVhbCBTdHJpbmcgc2VyaWFsaXpl KGRvdWJsZSkgY29uc3Q7CiB9OwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvRmlsZUlucHV0 VHlwZS5jcHAgYi9XZWJDb3JlL2h0bWwvRmlsZUlucHV0VHlwZS5jcHAKaW5kZXggZDk4ZDNiNmM4 YmNlYzQ5OWFkZWYwYzkyZWFjNjFlNWYwOGE4YjQ5Mi4uZmExNmIxZDI0NzRlZDk2NjM3NmIzOTM1 MWY1YjUzODQ5ZjAyNDg3MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0ZpbGVJbnB1dFR5cGUu Y3BwCisrKyBiL1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmNwcApAQCAtNzYsNiArNzYsMTMg QEAgYm9vbCBGaWxlSW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmcoY29uc3QgU3RyaW5nJiB2YWx1ZSkg Y29uc3QKICAgICByZXR1cm4gdmFsdWUuaXNFbXB0eSgpOwogfQogCitib29sIEZpbGVJbnB1dFR5 cGU6OmhhbmRsZURPTUFjdGl2YXRlRXZlbnQoRXZlbnQqKQoreworICAgIGlmICghZWxlbWVudCgp LT5kaXNhYmxlZCgpICYmIGVsZW1lbnQoKS0+cmVuZGVyZXIoKSkKKyAgICAgICAgdG9SZW5kZXJG aWxlVXBsb2FkQ29udHJvbChlbGVtZW50KCktPnJlbmRlcmVyKCkpLT5jbGljaygpOworICAgIHJl dHVybiBmYWxzZTsKK30KKwogUmVuZGVyT2JqZWN0KiBGaWxlSW5wdXRUeXBlOjpjcmVhdGVSZW5k ZXJlcihSZW5kZXJBcmVuYSogYXJlbmEsIFJlbmRlclN0eWxlKikgY29uc3QKIHsKICAgICByZXR1 cm4gbmV3IChhcmVuYSkgUmVuZGVyRmlsZVVwbG9hZENvbnRyb2woZWxlbWVudCgpKTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvRmlsZUlu cHV0VHlwZS5oCmluZGV4IDI0NDMwZmIyNDcxOGI1ZjdiNDQxNTRiOThlMzhjY2IwYjRmNGJkOTIu LjE0MmFmYWY2Y2Y3OTU4NTdmNWM1MDI5YzFlOGZjYjE2MmRjMWM4MTEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL0ZpbGVJbnB1dFR5 cGUuaApAQCAtNDQsNiArNDQsNyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgY29uc3QgQXRvbWlj U3RyaW5nJiBmb3JtQ29udHJvbFR5cGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgYXBwZW5k Rm9ybURhdGEoRm9ybURhdGFMaXN0JiwgYm9vbCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHZh bHVlTWlzc2luZyhjb25zdCBTdHJpbmcmKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaGFuZGxl RE9NQWN0aXZhdGVFdmVudChFdmVudCopOwogICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVh dGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKikgY29uc3Q7CiB9OwogCmRpZmYg LS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9XZWJDb3JlL2h0bWwv SFRNTElucHV0RWxlbWVudC5jcHAKaW5kZXggNTQwNjUyNDc1NjMxMDc3MzlkMGY5MTk3MThmZTUx MDg5MzQ3ZjgxNy4uMTE1N2Q2ZWVkMTMyNGNlMGJhNGVkZTFlZjViMzUxYmJmNDMyZDY5MCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODgsOCArODgsNiBAQCBzdGF0aWMgYm9vbCBp c051bWJlckNoYXJhY3RlcihVQ2hhciBjaCkKIAogSFRNTElucHV0RWxlbWVudDo6SFRNTElucHV0 RWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCogZG9jdW1lbnQs IEhUTUxGb3JtRWxlbWVudCogZm9ybSkKICAgICA6IEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50 KHRhZ05hbWUsIGRvY3VtZW50LCBmb3JtKQotICAgICwgbV94UG9zKDApCi0gICAgLCBtX3lQb3Mo MCkKICAgICAsIG1fbWF4UmVzdWx0cygtMSkKICAgICAsIG1fZGVwcmVjYXRlZFR5cGVOdW1iZXIo VEVYVCkKICAgICAsIG1fY2hlY2tlZChmYWxzZSkKQEAgLTEyNTgsNTcgKzEyNTYsMTIgQEAgdm9p ZCBIVE1MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCiAgICAg aWYgKGlzVGV4dEZpZWxkKCkgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLnRleHRJbnB1 dEV2ZW50ICYmIGV2dC0+aXNUZXh0RXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxUZXh0RXZlbnQqPihl dnQpLT5kYXRhKCkgPT0gIlxuIikKICAgICAgICAgaW1wbGljaXRTdWJtaXNzaW9uID0gdHJ1ZTsK IAotICAgIGlmIChkZXByZWNhdGVkSW5wdXRUeXBlKCkgPT0gSU1BR0UgJiYgZXZ0LT5pc01vdXNl RXZlbnQoKSAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkgewotICAg ICAgICAvLyByZWNvcmQgdGhlIG1vdXNlIHBvc2l0aW9uIGZvciB3aGVuIHdlIGdldCB0aGUgRE9N QWN0aXZhdGUgZXZlbnQKLSAgICAgICAgTW91c2VFdmVudCogbWUgPSBzdGF0aWNfY2FzdDxNb3Vz ZUV2ZW50Kj4oZXZ0KTsKLSAgICAgICAgLy8gRklYTUU6IFdlIGNvdWxkIGp1c3QgY2FsbCBvZmZz ZXRYKCkgYW5kIG9mZnNldFkoKSBvbiB0aGUgZXZlbnQsCi0gICAgICAgIC8vIGJ1dCB0aGF0J3Mg Y3VycmVudGx5IGJyb2tlbiwgc28gZm9yIG5vdyBkbyB0aGUgY29tcHV0YXRpb24gaGVyZS4KLSAg ICAgICAgaWYgKG1lLT5pc1NpbXVsYXRlZCgpIHx8ICFyZW5kZXJlcigpKSB7Ci0gICAgICAgICAg ICBtX3hQb3MgPSAwOwotICAgICAgICAgICAgbV95UG9zID0gMDsKLSAgICAgICAgfSBlbHNlIHsK LSAgICAgICAgICAgIC8vIEZJWE1FOiBUaGlzIGRvZXNuJ3Qgd29yayBjb3JyZWN0bHkgd2l0aCB0 cmFuc2Zvcm1zLgotICAgICAgICAgICAgLy8gRklYTUU6IHBhZ2VYL3BhZ2VZIG5lZWQgYWRqdXN0 aW5nIGZvciBwYWdlWm9vbUZhY3RvcigpLiBVc2UgYWN0dWFsUGFnZUxvY2F0aW9uKCk/Ci0gICAg ICAgICAgICBJbnRQb2ludCBhYnNPZmZzZXQgPSByb3VuZGVkSW50UG9pbnQocmVuZGVyZXIoKS0+ bG9jYWxUb0Fic29sdXRlKCkpOwotICAgICAgICAgICAgbV94UG9zID0gbWUtPnBhZ2VYKCkgLSBh YnNPZmZzZXQueCgpOwotICAgICAgICAgICAgbV95UG9zID0gbWUtPnBhZ2VZKCkgLSBhYnNPZmZz ZXQueSgpOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgaWYgKGhhc1NwaW5CdXR0b24oKSAmJiBl dnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2Fy ZEV2ZW50KCkpIHsKLSAgICAgICAgU3RyaW5nIGtleSA9IHN0YXRpY19jYXN0PEtleWJvYXJkRXZl bnQqPihldnQpLT5rZXlJZGVudGlmaWVyKCk7Ci0gICAgICAgIGludCBzdGVwID0gMDsKLSAgICAg ICAgaWYgKGtleSA9PSAiVXAiKQotICAgICAgICAgICAgc3RlcCA9IDE7Ci0gICAgICAgIGVsc2Ug aWYgKGtleSA9PSAiRG93biIpCi0gICAgICAgICAgICBzdGVwID0gLTE7Ci0gICAgICAgIGlmIChz dGVwKSB7Ci0gICAgICAgICAgICBzdGVwVXBGcm9tUmVuZGVyZXIoc3RlcCk7Ci0gICAgICAgICAg ICBldnQtPnNldERlZmF1bHRIYW5kbGVkKCk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAg IH0KLSAgICB9Ci0gICAgaWYgKGRlcHJlY2F0ZWRJbnB1dFR5cGUoKSA9PSBSQU5HRSAmJiBldnQt PmlzS2V5Ym9hcmRFdmVudCgpKSB7Ci0gICAgICAgIGhhbmRsZUtleUV2ZW50Rm9yUmFuZ2Uoc3Rh dGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCkpOwotICAgICAgICBpZiAoZXZ0LT5kZWZhdWx0 SGFuZGxlZCgpKQotICAgICAgICAgICAgcmV0dXJuOwotICAgIH0KLSAKLSAgIGlmIChpc1RleHRG aWVsZCgpCi0gICAgICAgICAgICAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5ZG93 bkV2ZW50Ci0gICAgICAgICAgICAmJiBldnQtPmlzS2V5Ym9hcmRFdmVudCgpCi0gICAgICAgICAg ICAmJiBmb2N1c2VkKCkKLSAgICAgICAgICAgICYmIGRvY3VtZW50KCktPmZyYW1lKCkKLSAgICAg ICAgICAgICYmIGRvY3VtZW50KCktPmZyYW1lKCktPmVkaXRvcigpLT5kb1RleHRGaWVsZENvbW1h bmRGcm9tRXZlbnQodGhpcywgc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCkpKSB7Ci0g ICAgICAgIGV2dC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICBpZiAoZXZ0LT5pc01vdXNlRXZl bnQoKSAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBtX2lucHV0 VHlwZS0+aGFuZGxlQ2xpY2tFdmVudChzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KSkpCiAg ICAgICAgIHJldHVybjsKLSAgICB9CiAKLSAgICBpZiAoZGVwcmVjYXRlZElucHV0VHlwZSgpID09 IFJBRElPICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7Ci0gICAg ICAgIGV2dC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICBpZiAoZXZ0LT5pc0tleWJvYXJkRXZl bnQoKSAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIG1faW5w dXRUeXBlLT5oYW5kbGVLZXlkb3duRXZlbnQoc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2 dCkpKQogICAgICAgICByZXR1cm47Ci0gICAgfQotICAgIAorCiAgICAgLy8gQ2FsbCB0aGUgYmFz ZSBldmVudCBoYW5kbGVyIGJlZm9yZSBhbnkgb2Ygb3VyIG93biBldmVudCBoYW5kbGluZyBmb3Ig YWxtb3N0IGFsbCBldmVudHMgaW4gdGV4dCBmaWVsZHMuCiAgICAgLy8gTWFrZXMgZWRpdGluZyBr ZXlib2FyZCBoYW5kbGluZyB0YWtlIHByZWNlZGVuY2Ugb3ZlciB0aGUga2V5ZG93biBhbmQga2V5 cHJlc3MgaGFuZGxpbmcgaW4gdGhpcyBmdW5jdGlvbi4KICAgICBib29sIGNhbGxCYXNlQ2xhc3NF YXJseSA9IGlzVGV4dEZpZWxkKCkgJiYgIWltcGxpY2l0U3VibWlzc2lvbgpAQCAtMTMyMywyNyAr MTI3Niw4IEBAIHZvaWQgSFRNTElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVu dCogZXZ0KQogICAgIC8vIGFjdHVhbGx5IHN1Ym1pdHRpbmcgdGhlIGZvcm0uIEZvciByZXNldCBp bnB1dHMsIHRoZSBmb3JtIGlzIHJlc2V0LiBUaGVzZSBldmVudHMgYXJlIHNlbnQgd2hlbiB0aGUg dXNlciBjbGlja3MKICAgICAvLyBvbiB0aGUgZWxlbWVudCwgb3IgcHJlc3NlcyBlbnRlciB3aGls ZSBpdCBpcyB0aGUgYWN0aXZlIGVsZW1lbnQuIEphdmFTY3JpcHQgY29kZSB3aXNoaW5nIHRvIGFj dGl2YXRlIHRoZSBlbGVtZW50CiAgICAgLy8gbXVzdCBkaXNwYXRjaCBhIERPTUFjdGl2YXRlIGV2 ZW50IC0gYSBjbGljayBldmVudCB3aWxsIG5vdCBkbyB0aGUgam9iLgotICAgIGlmIChldnQtPnR5 cGUoKSA9PSBldmVudE5hbWVzKCkuRE9NQWN0aXZhdGVFdmVudCAmJiAhZGlzYWJsZWQoKSkgewot ICAgICAgICBpZiAoZGVwcmVjYXRlZElucHV0VHlwZSgpID09IElNQUdFIHx8IGRlcHJlY2F0ZWRJ bnB1dFR5cGUoKSA9PSBTVUJNSVQgfHwgZGVwcmVjYXRlZElucHV0VHlwZSgpID09IFJFU0VUKSB7 Ci0gICAgICAgICAgICBpZiAoIWZvcm0oKSkKLSAgICAgICAgICAgICAgICByZXR1cm47Ci0gICAg ICAgICAgICBpZiAoZGVwcmVjYXRlZElucHV0VHlwZSgpID09IFJFU0VUKQotICAgICAgICAgICAg ICAgIGZvcm0oKS0+cmVzZXQoKTsKLSAgICAgICAgICAgIGVsc2UgewotICAgICAgICAgICAgICAg IG1fYWN0aXZlU3VibWl0ID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICAvLyBGSVhNRTogV291bGQg YmUgY2xlYW5lciB0byBnZXQgbV94UG9zIGFuZCBtX3lQb3Mgb3V0IG9mIHRoZSB1bmRlcmx5aW5n IG1vdXNlCi0gICAgICAgICAgICAgICAgLy8gZXZlbnQgKGlmIGFueSkgaGVyZSBpbnN0ZWFkIG9m IHJlbHlpbmcgb24gdGhlIHZhcmlhYmxlcyBzZXQgYWJvdmUgd2hlbgotICAgICAgICAgICAgICAg IC8vIHByb2Nlc3NpbmcgdGhlIGNsaWNrIGV2ZW50LiBFdmVuIGJldHRlciwgYXBwZW5kRm9ybURh dGEgY291bGQgcGFzcyB0aGUKLSAgICAgICAgICAgICAgICAvLyBldmVudCBpbiwgYW5kIHRoZW4g d2UgY291bGQgZ2V0IHJpZCBvZiBtX3hQb3MgYW5kIG1feVBvcyBhbHRvZ2V0aGVyIQotICAgICAg ICAgICAgICAgIGlmICghZm9ybSgpLT5wcmVwYXJlU3VibWl0KGV2dCkpIHsKLSAgICAgICAgICAg ICAgICAgICAgbV94UG9zID0gMDsKLSAgICAgICAgICAgICAgICAgICAgbV95UG9zID0gMDsKLSAg ICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgbV9hY3RpdmVTdWJtaXQgPSBmYWxzZTsK LSAgICAgICAgICAgIH0KLSAgICAgICAgfSBlbHNlIGlmIChkZXByZWNhdGVkSW5wdXRUeXBlKCkg PT0gRklMRSAmJiByZW5kZXJlcigpKQotICAgICAgICAgICAgdG9SZW5kZXJGaWxlVXBsb2FkQ29u dHJvbChyZW5kZXJlcigpKS0+Y2xpY2soKTsKLSAgICB9CisgICAgaWYgKGV2dC0+dHlwZSgpID09 IGV2ZW50TmFtZXMoKS5ET01BY3RpdmF0ZUV2ZW50ICYmIG1faW5wdXRUeXBlLT5oYW5kbGVET01B Y3RpdmF0ZUV2ZW50KGV2dCkpCisgICAgICAgIHJldHVybjsKIAogICAgIC8vIFVzZSBrZXkgcHJl c3MgZXZlbnQgaGVyZSBzaW5jZSBzZW5kaW5nIHNpbXVsYXRlZCBtb3VzZSBldmVudHMKICAgICAv LyBvbiBrZXkgZG93biBibG9ja3MgdGhlIHByb3BlciBzZW5kaW5nIG9mIHRoZSBrZXkgcHJlc3Mg ZXZlbnQuCkBAIC0xNjAyLDQ3ICsxNTM2LDYgQEAgdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpoYW5k bGVCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudChFdmVudCogZXZlbnQpCiAgICAgSW5wdXRFbGVtZW50 OjpoYW5kbGVCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudChtX2RhdGEsIHRoaXMsIHRoaXMsIGV2ZW50 KTsKIH0KIAotdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpoYW5kbGVLZXlFdmVudEZvclJhbmdlKEtl eWJvYXJkRXZlbnQqIGV2ZW50KQotewotICAgIGlmIChldmVudC0+dHlwZSgpICE9IGV2ZW50TmFt ZXMoKS5rZXlkb3duRXZlbnQpCi0gICAgICAgIHJldHVybjsKLSAgICBTdHJpbmcga2V5ID0gZXZl bnQtPmtleUlkZW50aWZpZXIoKTsKLSAgICBpZiAoa2V5ICE9ICJVcCIgJiYga2V5ICE9ICJSaWdo dCIgJiYga2V5ICE9ICJEb3duIiAmJiBrZXkgIT0gIkxlZnQiKQotICAgICAgICByZXR1cm47Ci0K LSAgICBFeGNlcHRpb25Db2RlIGVjOwotICAgIGlmIChlcXVhbElnbm9yaW5nQ2FzZShnZXRBdHRy aWJ1dGUoc3RlcEF0dHIpLCAiYW55IikpIHsKLSAgICAgICAgZG91YmxlIG1pbiA9IG1faW5wdXRU eXBlLT5taW5pbXVtKCk7Ci0gICAgICAgIGRvdWJsZSBtYXggPSBtX2lucHV0VHlwZS0+bWF4aW11 bSgpOwotICAgICAgICAvLyBGSVhNRTogSXMgMS8xMDAgcmVhc29uYWJsZT8KLSAgICAgICAgZG91 YmxlIHN0ZXAgPSAobWF4IC0gbWluKSAvIDEwMDsKLSAgICAgICAgZG91YmxlIGN1cnJlbnQgPSBt X2lucHV0VHlwZS0+cGFyc2VUb0RvdWJsZSh2YWx1ZSgpLCBudW1lcmljX2xpbWl0czxkb3VibGU+ OjpxdWlldF9OYU4oKSk7Ci0gICAgICAgIEFTU0VSVChpc2Zpbml0ZShjdXJyZW50KSk7Ci0gICAg ICAgIGRvdWJsZSBuZXdWYWx1ZTsKLSAgICAgICAgaWYgKGtleSA9PSAiVXAiIHx8IGtleSA9PSAi UmlnaHQiKSB7Ci0gICAgICAgICAgICBuZXdWYWx1ZSA9IGN1cnJlbnQgKyBzdGVwOwotICAgICAg ICAgICAgaWYgKG5ld1ZhbHVlID4gbWF4KQotICAgICAgICAgICAgICAgIG5ld1ZhbHVlID0gbWF4 OwotICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgbmV3VmFsdWUgPSBjdXJyZW50IC0gc3Rl cDsKLSAgICAgICAgICAgIGlmIChuZXdWYWx1ZSA8IG1pbikKLSAgICAgICAgICAgICAgICBuZXdW YWx1ZSA9IG1pbjsKLSAgICAgICAgfQotICAgICAgICBpZiAobmV3VmFsdWUgIT0gY3VycmVudCkg ewotICAgICAgICAgICAgc2V0VmFsdWVBc051bWJlcihuZXdWYWx1ZSwgZWMpOwotICAgICAgICAg ICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7Ci0gICAgICAgIH0KLSAgICB9IGVs c2UgewotICAgICAgICBpbnQgc3RlcE1hZ25pZmljYXRpb24gPSAoa2V5ID09ICJVcCIgfHwga2V5 ID09ICJSaWdodCIpID8gMSA6IC0xOwotICAgICAgICBTdHJpbmcgbGFzdFN0cmluZ1ZhbHVlID0g dmFsdWUoKTsKLSAgICAgICAgc3RlcFVwKHN0ZXBNYWduaWZpY2F0aW9uLCBlYyk7Ci0gICAgICAg IGlmIChsYXN0U3RyaW5nVmFsdWUgIT0gdmFsdWUoKSkKLSAgICAgICAgICAgIGRpc3BhdGNoRm9y bUNvbnRyb2xDaGFuZ2VFdmVudCgpOwotICAgIH0KLSAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRs ZWQoKTsKLSAgICByZXR1cm47Ci19Ci0KIFBhc3NSZWZQdHI8SFRNTEZvcm1FbGVtZW50PiBIVE1M SW5wdXRFbGVtZW50OjpjcmVhdGVUZW1wb3JhcnlGb3JtRm9ySXNJbmRleCgpCiB7CiAgICAgUmVm UHRyPEhUTUxGb3JtRWxlbWVudD4gZm9ybSA9IEhUTUxGb3JtRWxlbWVudDo6Y3JlYXRlKGRvY3Vt ZW50KCkpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaCBiL1dl YkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXggMGFjZjIxZTc1ZThmNzFiZjc5NjQ2 NWM0ODFmZTExOWM0NWMxN2YwZi4uYjExYjc1Y2U2MjdlY2YxZWQxMTFhNWNhZjY1Nzc4NTgwMDNl NDc5NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAorKysgYi9X ZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCkBAIC0yMDQsMTAgKzIwNCw2IEBAIHB1Ymxp YzoKICAgICAgICAgcmV0dXJuIGRvY3VtZW50KCktPmNoZWNrZWRSYWRpb0J1dHRvbnMoKTsKICAg ICB9CiAKLSAgICAvLyBGSVhNRTogV2Ugc2hvdWxkIG1vdmUgbV94UG9zIGFuZCBtX3lQb3MgdG8g SW1hZ2VJbnB1dFR5cGUgY2xhc3MuCi0gICAgaW50IHhQb3NpdGlvbigpIGNvbnN0IHsgcmV0dXJu IG1feFBvczsgfQotICAgIGludCB5UG9zaXRpb24oKSBjb25zdCB7IHJldHVybiBtX3lQb3M7IH0K LQogcHJvdGVjdGVkOgogICAgIEhUTUxJbnB1dEVsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYs IERvY3VtZW50KiwgSFRNTEZvcm1FbGVtZW50KiA9IDApOwogCkBAIC0zMzcsNyArMzMzLDYgQEAg cHJpdmF0ZToKICAgICB2b2lkIHVwZGF0ZUNoZWNrZWRSYWRpb0J1dHRvbnMoKTsKICAgICAKICAg ICB2b2lkIGhhbmRsZUJlZm9yZVRleHRJbnNlcnRlZEV2ZW50KEV2ZW50Kik7Ci0gICAgdm9pZCBo YW5kbGVLZXlFdmVudEZvclJhbmdlKEtleWJvYXJkRXZlbnQqKTsKICAgICBQYXNzUmVmUHRyPEhU TUxGb3JtRWxlbWVudD4gY3JlYXRlVGVtcG9yYXJ5Rm9ybUZvcklzSW5kZXgoKTsKICAgICAvLyBI ZWxwZXIgZm9yIHN0ZXBVcCgpL3N0ZXBEb3duKCkuICBBZGRzIHN0ZXAgdmFsdWUgKiBjb3VudCB0 byB0aGUgY3VycmVudCB2YWx1ZS4KICAgICB2b2lkIGFwcGx5U3RlcChkb3VibGUgY291bnQsIEV4 Y2VwdGlvbkNvZGUmKTsKQEAgLTM1MSw4ICszNDYsNiBAQCBwcml2YXRlOgogI2VuZGlmCiAKICAg ICBJbnB1dEVsZW1lbnREYXRhIG1fZGF0YTsKLSAgICBpbnQgbV94UG9zOwotICAgIGludCBtX3lQ b3M7CiAgICAgc2hvcnQgbV9tYXhSZXN1bHRzOwogICAgIE93blB0cjxIVE1MSW1hZ2VMb2FkZXI+ IG1faW1hZ2VMb2FkZXI7CiAgICAgUmVmUHRyPEZpbGVMaXN0PiBtX2ZpbGVMaXN0OwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9odG1sL0ltYWdlSW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9JbWFn ZUlucHV0VHlwZS5jcHAKaW5kZXggZGUyNDE4ODhlYzc3ZjViMTYzOTVlNGZjOGZmYmY4Yjg5NjU4 MjJhOC4uNmY3YzIxOGQ3OWFiMjUwOWRjZDg2ZWFmYTIwZWE1ZmE5NDFiYjkyNyAxMDA2NDQKLS0t IGEvV2ViQ29yZS9odG1sL0ltYWdlSW5wdXRUeXBlLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSW1h Z2VJbnB1dFR5cGUuY3BwCkBAIC0yNCw2ICsyNCw3IEBACiAKICNpbmNsdWRlICJGb3JtRGF0YUxp c3QuaCIKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCisjaW5jbHVkZSAiTW91c2VFdmVu dC5oIgogI2luY2x1ZGUgIlJlbmRlckltYWdlLmgiCiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIu aD4KIApAQCAtNDksOCArNTAsOCBAQCBib29sIEltYWdlSW5wdXRUeXBlOjphcHBlbmRGb3JtRGF0 YShGb3JtRGF0YUxpc3QmIGVuY29kaW5nLCBib29sKSBjb25zdAogICAgIGlmICghZWxlbWVudCgp LT5pc0FjdGl2YXRlZFN1Ym1pdCgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgY29uc3Qg QXRvbWljU3RyaW5nJiBuYW1lID0gZWxlbWVudCgpLT5uYW1lKCk7Ci0gICAgZW5jb2RpbmcuYXBw ZW5kRGF0YShuYW1lLmlzRW1wdHkoKSA/ICJ4IiA6IChuYW1lICsgIi54IiksIGVsZW1lbnQoKS0+ eFBvc2l0aW9uKCkpOwotICAgIGVuY29kaW5nLmFwcGVuZERhdGEobmFtZS5pc0VtcHR5KCkgPyAi eSIgOiAobmFtZSArICIueSIpLCBlbGVtZW50KCktPnlQb3NpdGlvbigpKTsKKyAgICBlbmNvZGlu Zy5hcHBlbmREYXRhKG5hbWUuaXNFbXB0eSgpID8gIngiIDogKG5hbWUgKyAiLngiKSwgbV9jbGlj a0xvY2F0aW9uLngoKSk7CisgICAgZW5jb2RpbmcuYXBwZW5kRGF0YShuYW1lLmlzRW1wdHkoKSA/ ICJ5IiA6IChuYW1lICsgIi55IiksIG1fY2xpY2tMb2NhdGlvbi55KCkpOwogICAgIGlmICghbmFt ZS5pc0VtcHR5KCkgJiYgIWVsZW1lbnQoKS0+dmFsdWUoKS5pc0VtcHR5KCkpCiAgICAgICAgIGVu Y29kaW5nLmFwcGVuZERhdGEobmFtZSwgZWxlbWVudCgpLT52YWx1ZSgpKTsKICAgICByZXR1cm4g dHJ1ZTsKQEAgLTYxLDYgKzYyLDI0IEBAIGJvb2wgSW1hZ2VJbnB1dFR5cGU6OnN1cHBvcnRzVmFs aWRhdGlvbigpIGNvbnN0CiAgICAgcmV0dXJuIGZhbHNlOwogfQogCitib29sIEltYWdlSW5wdXRU eXBlOjpoYW5kbGVET01BY3RpdmF0ZUV2ZW50KEV2ZW50KiBldmVudCkKK3sKKyAgICBpZiAoZWxl bWVudCgpLT5kaXNhYmxlZCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKCFlbGVt ZW50KCktPmZvcm0oKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgUmVmUHRyPEhUTUxJbnB1 dEVsZW1lbnQ+IGlucHV0KGVsZW1lbnQoKSk7CisgICAgaW5wdXQtPnNldEFjdGl2YXRlZFN1Ym1p dCh0cnVlKTsKKyAgICBpZiAoZXZlbnQtPnVuZGVybHlpbmdFdmVudCgpICYmIGV2ZW50LT51bmRl cmx5aW5nRXZlbnQoKS0+aXNNb3VzZUV2ZW50KCkpIHsKKyAgICAgICAgTW91c2VFdmVudCogbW91 c2VFdmVudCA9IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudC0+dW5kZXJseWluZ0V2ZW50 KCkpOworICAgICAgICBtX2NsaWNrTG9jYXRpb24gPSBJbnRQb2ludChtb3VzZUV2ZW50LT5vZmZz ZXRYKCksIG1vdXNlRXZlbnQtPm9mZnNldFkoKSk7CisgICAgfSBlbHNlCisgICAgICAgIG1fY2xp Y2tMb2NhdGlvbiA9IEludFBvaW50KCk7CisgICAgaW5wdXQtPmZvcm0oKS0+cHJlcGFyZVN1Ym1p dChldmVudCk7IC8vIEphdmFTY3JpcHQgY29kZSBtaWdodCBydW4uCisgICAgaW5wdXQtPnNldEFj dGl2YXRlZFN1Ym1pdChmYWxzZSk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCiBSZW5kZXJPYmpl Y3QqIEltYWdlSW5wdXRUeXBlOjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSogYXJlbmEsIFJl bmRlclN0eWxlKikgY29uc3QKIHsKICAgICBSZW5kZXJJbWFnZSogaW1hZ2UgPSBuZXcgKGFyZW5h KSBSZW5kZXJJbWFnZShlbGVtZW50KCkpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0ltYWdl SW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvSW1hZ2VJbnB1dFR5cGUuaAppbmRleCBjZDc2ZTcy ZmQ2NjE4YWNmNDYyYTZiMGIzODI0ZmIyM2RmMDVlN2E0Li42MWFiZjlkMDBlNjlhMzBjOTlkZWJm MzAwYmEyYjFiMmEzMTQzNjEyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSW1hZ2VJbnB1dFR5 cGUuaAorKysgYi9XZWJDb3JlL2h0bWwvSW1hZ2VJbnB1dFR5cGUuaApAQCAtMzIsNiArMzIsNyBA QAogI2RlZmluZSBJbWFnZUlucHV0VHlwZV9oCiAKICNpbmNsdWRlICJCYXNlQnV0dG9uSW5wdXRU eXBlLmgiCisjaW5jbHVkZSAiSW50UG9pbnQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBA IC00Niw2ICs0NywxMCBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgYm9vbCBhcHBlbmRGb3JtRGF0 YShGb3JtRGF0YUxpc3QmLCBib29sKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgc3VwcG9ydHNW YWxpZGF0aW9uKCkgY29uc3Q7CiAgICAgdmlydHVhbCBSZW5kZXJPYmplY3QqIGNyZWF0ZVJlbmRl cmVyKFJlbmRlckFyZW5hKiwgUmVuZGVyU3R5bGUqKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wg aGFuZGxlRE9NQWN0aXZhdGVFdmVudChFdmVudCopOworCisgICAgLy8gVGhpcyBpcyB2YWxpZCBv bmx5IGR1cmluZyBIVE1MRm9ybUVsZW1lbnQ6OnByZXBhcmVTdWJtaXQoKS4KKyAgICBJbnRQb2lu dCBtX2NsaWNrTG9jYXRpb247CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUu Y3BwCmluZGV4IGMwY2MzNDI3OTBhYzkxZWU1MmU1MjdiMzVhOGIzYzE4ZGY5YmY4ZDQuLjE0ODk3 NGMwYTRlZWRjMDQ2YzMyYWE4ZTM0NjM5MWFiMTBiOTg1YmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv aHRtbC9JbnB1dFR5cGUuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCkBAIC0y NjksNiArMjY5LDIxIEBAIGRvdWJsZSBJbnB1dFR5cGU6OmFjY2VwdGFibGVFcnJvcihkb3VibGUp IGNvbnN0CiAgICAgcmV0dXJuIDA7CiB9CiAKK2Jvb2wgSW5wdXRUeXBlOjpoYW5kbGVDbGlja0V2 ZW50KE1vdXNlRXZlbnQqKQoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBJbnB1dFR5 cGU6OmhhbmRsZURPTUFjdGl2YXRlRXZlbnQoRXZlbnQqKQoreworICAgIHJldHVybiBmYWxzZTsK K30KKworYm9vbCBJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50KikK K3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIFJlbmRlck9iamVjdCogSW5wdXRUeXBlOjpjcmVh dGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKiBzdHlsZSkgY29uc3QKIHsKICAg ICByZXR1cm4gUmVuZGVyT2JqZWN0OjpjcmVhdGVPYmplY3QoZWxlbWVudCgpLCBzdHlsZSk7CmRp ZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvSW5wdXRU eXBlLmgKaW5kZXggNzhhYWI3YzgxYTRkYTY4M2IxNjZjNzkxZmNkNzk1YjE3MWI4Yzc0OS4uOTlk NTRkYTE5MjZlODljMmVhZjY3ODI4YTMzNDExOWFhMzczNGVjMCAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9odG1sL0lucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaApAQCAtMzgs OCArMzgsMTEgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0ZUNvbXBvbmVudHM7 CitjbGFzcyBFdmVudDsKIGNsYXNzIEZvcm1EYXRhTGlzdDsKIGNsYXNzIEhUTUxJbnB1dEVsZW1l bnQ7CitjbGFzcyBLZXlib2FyZEV2ZW50OworY2xhc3MgTW91c2VFdmVudDsKIGNsYXNzIFJlbmRl ckFyZW5hOwogY2xhc3MgUmVuZGVyT2JqZWN0OwogY2xhc3MgUmVuZGVyU3R5bGU7CkBAIC05Nyw2 ICsxMDAsMTMgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBzY2FsZWRTdGVwVmFsZXVTaG91 bGRCZUludGVnZXIoKSBjb25zdDsKICAgICB2aXJ0dWFsIGRvdWJsZSBhY2NlcHRhYmxlRXJyb3Io ZG91YmxlKSBjb25zdDsKIAorICAgIC8vIEV2ZW50IGhhbmRsZXJzCisgICAgLy8gICBUaGUgcmV0 dXJuIHZhbHVlIG1lYW5zICJzaG91bGQgcmV0dXJuIGZyb20gdGhlIGNhbGxlciBldmVudCBoYW5k bGVyIGltbWVkaWF0ZWx5LiIKKworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVDbGlja0V2ZW50KE1v dXNlRXZlbnQqKTsKKyAgICB2aXJ0dWFsIGJvb2wgaGFuZGxlRE9NQWN0aXZhdGVFdmVudChFdmVu dCopOworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCop OworCiAgICAgLy8gTWlzY2VsbGFuZW91cyBmdW5jdGlvbnMKIAogICAgIHZpcnR1YWwgUmVuZGVy T2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKikgY29uc3Q7 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvTnVtYmVySW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUv aHRtbC9OdW1iZXJJbnB1dFR5cGUuY3BwCmluZGV4IDdhNGQ1MDQ3M2I3YjRiY2E2NWE5YjBjMTkw N2FlN2QxNTMxN2Y1N2MuLmUyOTBlNTBlMzFkM2Q4MGEyYzI5MTI5OTJjNDJlODc3YjJkYjAxNGMg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9OdW1iZXJJbnB1dFR5cGUuY3BwCisrKyBiL1dlYkNv cmUvaHRtbC9OdW1iZXJJbnB1dFR5cGUuY3BwCkBAIC0xNTUsNiArMTU1LDExIEBAIGRvdWJsZSBO dW1iZXJJbnB1dFR5cGU6OnN0ZXBTY2FsZUZhY3RvcigpIGNvbnN0CiAgICAgcmV0dXJuIG51bWJl clN0ZXBTY2FsZUZhY3RvcjsKIH0KIAorYm9vbCBOdW1iZXJJbnB1dFR5cGU6OmhhbmRsZUtleWRv d25FdmVudChLZXlib2FyZEV2ZW50KiBldmVudCkKK3sKKyAgICByZXR1cm4gaGFuZGxlS2V5ZG93 bkV2ZW50Rm9yU3BpbkJ1dHRvbihldmVudCkgfHwgVGV4dEZpZWxkSW5wdXRUeXBlOjpoYW5kbGVL ZXlkb3duRXZlbnRGb3JTcGluQnV0dG9uKGV2ZW50KTsKK30KKwogZG91YmxlIE51bWJlcklucHV0 VHlwZTo6cGFyc2VUb0RvdWJsZShjb25zdCBTdHJpbmcmIHNyYywgZG91YmxlIGRlZmF1bHRWYWx1 ZSkgY29uc3QKIHsKICAgICBkb3VibGUgbnVtYmVyVmFsdWU7CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2h0bWwvTnVtYmVySW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvTnVtYmVySW5wdXRUeXBlLmgK aW5kZXggMWYwYjg4MTRjNzE5MzAzOGMyZmRkMjdkODg5MDY1OTg2M2U0YzBjMC4uZGM2ZTAyMDVh ZGU0OWM0ZjFhYjc0MzA3YWQ4NWM0ZTc4ZGE5ZWI0MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1s L051bWJlcklucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9OdW1iZXJJbnB1dFR5cGUuaApA QCAtNTUsNiArNTUsNyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgZG91YmxlIHN0ZXBCYXNlV2l0 aERlY2ltYWxQbGFjZXModW5zaWduZWQqKSBjb25zdDsKICAgICB2aXJ0dWFsIGRvdWJsZSBkZWZh dWx0U3RlcCgpIGNvbnN0OwogICAgIHZpcnR1YWwgZG91YmxlIHN0ZXBTY2FsZUZhY3RvcigpIGNv bnN0OworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCop OwogICAgIHZpcnR1YWwgZG91YmxlIHBhcnNlVG9Eb3VibGUoY29uc3QgU3RyaW5nJiwgZG91Ymxl KSBjb25zdDsKICAgICB2aXJ0dWFsIGRvdWJsZSBwYXJzZVRvRG91YmxlV2l0aERlY2ltYWxQbGFj ZXMoY29uc3QgU3RyaW5nJiwgZG91YmxlLCB1bnNpZ25lZCopIGNvbnN0OwogICAgIHZpcnR1YWwg U3RyaW5nIHNlcmlhbGl6ZShkb3VibGUpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1s L1JhZGlvSW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlwZS5jcHAKaW5k ZXggNWRmNGJiYzQ0YTA0MDUyMmJjNDQ5MzdkZjZlMDA2ZTRlNDY0MmM4NS4uYTZjNDcwN2JlNWI4 OWM1ZjJmMDcwMGFmOTc1NDQwNmM5ODU2ODk2OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1Jh ZGlvSW5wdXRUeXBlLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuY3BwCkBA IC0zMiw2ICszMiw3IEBACiAjaW5jbHVkZSAiUmFkaW9JbnB1dFR5cGUuaCIKIAogI2luY2x1ZGUg IkhUTUxJbnB1dEVsZW1lbnQuaCIKKyNpbmNsdWRlICJNb3VzZUV2ZW50LmgiCiAjaW5jbHVkZSA8 d3RmL1Bhc3NPd25QdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNTEsNCArNTIsMTAg QEAgYm9vbCBSYWRpb0lucHV0VHlwZTo6dmFsdWVNaXNzaW5nKGNvbnN0IFN0cmluZyYpIGNvbnN0 CiAgICAgcmV0dXJuICFlbGVtZW50KCktPmNoZWNrZWRSYWRpb0J1dHRvbnMoKS5jaGVja2VkQnV0 dG9uRm9yR3JvdXAoZWxlbWVudCgpLT5uYW1lKCkpOwogfQogCitib29sIFJhZGlvSW5wdXRUeXBl OjpoYW5kbGVDbGlja0V2ZW50KE1vdXNlRXZlbnQqIGV2ZW50KQoreworICAgIGV2ZW50LT5zZXRE ZWZhdWx0SGFuZGxlZCgpOworICAgIHJldHVybiB0cnVlOworfQorCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuaCBiL1dlYkNv cmUvaHRtbC9SYWRpb0lucHV0VHlwZS5oCmluZGV4IDllN2FiMDBkY2UyYjhhNjUyNjI3OGY0NjE2 MzQ4NTg5MTgwMjI5NGUuLjI3OTgwMTBhMDQ1NzQ0NGJkZGU2M2NjZmIxN2U0MGJmZDBiZWI2ZjMg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUv aHRtbC9SYWRpb0lucHV0VHlwZS5oCkBAIC00Myw2ICs0Myw3IEBAIHByaXZhdGU6CiAgICAgUmFk aW9JbnB1dFR5cGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkgOiBCYXNlQ2hlY2thYmxlSW5w dXRUeXBlKGVsZW1lbnQpIHsgfQogICAgIHZpcnR1YWwgY29uc3QgQXRvbWljU3RyaW5nJiBmb3Jt Q29udHJvbFR5cGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgdmFsdWVNaXNzaW5nKGNvbnN0 IFN0cmluZyYpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVDbGlja0V2ZW50KE1vdXNl RXZlbnQqKTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNv cmUvaHRtbC9SYW5nZUlucHV0VHlwZS5jcHAgYi9XZWJDb3JlL2h0bWwvUmFuZ2VJbnB1dFR5cGUu Y3BwCmluZGV4IDE3NmQ3M2I1MjAyNmE3MGRjMDUyOWJjYTU0YmU5MDllOGVkNjdlZjEuLjY2YWE2 ZWRmNGFlYzlmZDE3ZjZkN2FiOTg2NTMwZWE0MTJkMjg5YmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv aHRtbC9SYW5nZUlucHV0VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBl LmNwcApAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1ZGUgIkhUTUxJbnB1dEVsZW1lbnQuaCIKICNp bmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJIVE1MUGFyc2VySWRpb21zLmgiCisjaW5j bHVkZSAiS2V5Ym9hcmRFdmVudC5oIgogI2luY2x1ZGUgIlJlbmRlclNsaWRlci5oIgogI2luY2x1 ZGUgPGxpbWl0cz4KICNpbmNsdWRlIDx3dGYvTWF0aEV4dHJhcy5oPgpAQCAtMTI3LDYgKzEyOCw0 NiBAQCBkb3VibGUgUmFuZ2VJbnB1dFR5cGU6OnN0ZXBTY2FsZUZhY3RvcigpIGNvbnN0CiAgICAg cmV0dXJuIHJhbmdlU3RlcFNjYWxlRmFjdG9yOwogfQogCitib29sIFJhbmdlSW5wdXRUeXBlOjpo YW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCogZXZlbnQpCit7CisgICAgU3RyaW5nIGtl eSA9IGV2ZW50LT5rZXlJZGVudGlmaWVyKCk7CisgICAgaWYgKGtleSAhPSAiVXAiICYmIGtleSAh PSAiUmlnaHQiICYmIGtleSAhPSAiRG93biIgJiYga2V5ICE9ICJMZWZ0IikKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworCisgICAgRXhjZXB0aW9uQ29kZSBlYzsKKyAgICBpZiAoZXF1YWxJZ25vcmlu Z0Nhc2UoZWxlbWVudCgpLT5mYXN0R2V0QXR0cmlidXRlKHN0ZXBBdHRyKSwgImFueSIpKSB7Cisg ICAgICAgIGRvdWJsZSBtaW4gPSBtaW5pbXVtKCk7CisgICAgICAgIGRvdWJsZSBtYXggPSBtYXhp bXVtKCk7CisgICAgICAgIC8vIEZJWE1FOiBXZSBjYW4ndCB1c2Ugc3RlcFVwKCkgZm9yIHRoZSBz dGVwIHZhbHVlICJhbnkiLiBTbywgd2UgaW5jcmVhc2UKKyAgICAgICAgLy8gb3IgZGVjcmVhc2Ug dGhlIHZhbHVlIGJ5IDEvMTAwIG9mIHRoZSB2YWx1ZSByYW5nZS4gSXMgaXQgcmVhc29uYWJsZT8K KyAgICAgICAgZG91YmxlIHN0ZXAgPSAobWF4IC0gbWluKSAvIDEwMDsKKyAgICAgICAgZG91Ymxl IGN1cnJlbnQgPSBwYXJzZVRvRG91YmxlKGVsZW1lbnQoKS0+dmFsdWUoKSwgbnVtZXJpY19saW1p dHM8ZG91YmxlPjo6cXVpZXRfTmFOKCkpOworICAgICAgICBBU1NFUlQoaXNmaW5pdGUoY3VycmVu dCkpOworICAgICAgICBkb3VibGUgbmV3VmFsdWU7CisgICAgICAgIGlmIChrZXkgPT0gIlVwIiB8 fCBrZXkgPT0gIlJpZ2h0IikgeworICAgICAgICAgICAgbmV3VmFsdWUgPSBjdXJyZW50ICsgc3Rl cDsKKyAgICAgICAgICAgIGlmIChuZXdWYWx1ZSA+IG1heCkKKyAgICAgICAgICAgICAgICBuZXdW YWx1ZSA9IG1heDsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIG5ld1ZhbHVlID0gY3Vy cmVudCAtIHN0ZXA7CisgICAgICAgICAgICBpZiAobmV3VmFsdWUgPCBtaW4pCisgICAgICAgICAg ICAgICAgbmV3VmFsdWUgPSBtaW47CisgICAgICAgIH0KKyAgICAgICAgaWYgKG5ld1ZhbHVlICE9 IGN1cnJlbnQpIHsKKyAgICAgICAgICAgIHNldFZhbHVlQXNOdW1iZXIobmV3VmFsdWUsIGVjKTsK KyAgICAgICAgICAgIGVsZW1lbnQoKS0+ZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7 CisgICAgICAgIH0KKyAgICB9IGVsc2UgeworICAgICAgICBpbnQgc3RlcE1hZ25pZmljYXRpb24g PSAoa2V5ID09ICJVcCIgfHwga2V5ID09ICJSaWdodCIpID8gMSA6IC0xOworICAgICAgICBTdHJp bmcgbGFzdFN0cmluZ1ZhbHVlID0gZWxlbWVudCgpLT52YWx1ZSgpOworICAgICAgICBlbGVtZW50 KCktPnN0ZXBVcChzdGVwTWFnbmlmaWNhdGlvbiwgZWMpOworICAgICAgICBpZiAobGFzdFN0cmlu Z1ZhbHVlICE9IGVsZW1lbnQoKS0+dmFsdWUoKSkKKyAgICAgICAgICAgIGVsZW1lbnQoKS0+ZGlz cGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisgICAgfQorICAgIGV2ZW50LT5zZXREZWZh dWx0SGFuZGxlZCgpOworICAgIHJldHVybiB0cnVlOworfQorCiBSZW5kZXJPYmplY3QqIFJhbmdl SW5wdXRUeXBlOjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSogYXJlbmEsIFJlbmRlclN0eWxl KikgY29uc3QKIHsKICAgICByZXR1cm4gbmV3IChhcmVuYSkgUmVuZGVyU2xpZGVyKGVsZW1lbnQo KSk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvUmFuZ2VJbnB1dFR5cGUuaCBiL1dlYkNvcmUv aHRtbC9SYW5nZUlucHV0VHlwZS5oCmluZGV4IDY0NTQ4ZjY3MTE5ODRmNDRkZDg1OTFjOThjOWU0 OTU3NGRlYzg0ZjEuLmMyYmJiMGZjMWQxMzJiMGY3OWI1ZDcxNGNkYjUxNWRkOWNlMzE1YTEgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRt bC9SYW5nZUlucHV0VHlwZS5oCkBAIC01Myw2ICs1Myw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVh bCBkb3VibGUgc3RlcEJhc2UoKSBjb25zdDsKICAgICB2aXJ0dWFsIGRvdWJsZSBkZWZhdWx0U3Rl cCgpIGNvbnN0OwogICAgIHZpcnR1YWwgZG91YmxlIHN0ZXBTY2FsZUZhY3RvcigpIGNvbnN0Owor ICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCopOwogICAg IHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRl clN0eWxlKikgY29uc3Q7CiAgICAgdmlydHVhbCBkb3VibGUgcGFyc2VUb0RvdWJsZShjb25zdCBT dHJpbmcmLCBkb3VibGUpIGNvbnN0OwogICAgIHZpcnR1YWwgU3RyaW5nIHNlcmlhbGl6ZShkb3Vi bGUpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL1Jlc2V0SW5wdXRUeXBlLmNwcCBi L1dlYkNvcmUvaHRtbC9SZXNldElucHV0VHlwZS5jcHAKaW5kZXggMWRiNzU5MjU0YjE2M2NhZGVh YmRlMDJjYjZkYjBiZDdkZTJkZDQ4OC4uNzlmOGRiNDI1MDJiZmZhYzgxZjA2OGJlZWNjYjg1OGNi YTAxMjE2YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1Jlc2V0SW5wdXRUeXBlLmNwcAorKysg Yi9XZWJDb3JlL2h0bWwvUmVzZXRJbnB1dFR5cGUuY3BwCkBAIC0zMSw2ICszMSw3IEBACiAjaW5j bHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiUmVzZXRJbnB1dFR5cGUuaCIKIAorI2luY2x1ZGUg IkhUTUxJbnB1dEVsZW1lbnQuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CkBAIC01MCw0ICs1MSwxNCBAQCBib29sIFJlc2V0SW5wdXRUeXBlOjpz dXBwb3J0c1ZhbGlkYXRpb24oKSBjb25zdAogICAgIHJldHVybiBmYWxzZTsKIH0KIAorYm9vbCBS ZXNldElucHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudChFdmVudCopCit7CisgICAgaWYg KGVsZW1lbnQoKS0+ZGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGlmICgh ZWxlbWVudCgpLT5mb3JtKCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIGVsZW1lbnQoKS0+ Zm9ybSgpLT5yZXNldCgpOworICAgIHJldHVybiBmYWxzZTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL1Jlc2V0SW5wdXRUeXBlLmggYi9XZWJD b3JlL2h0bWwvUmVzZXRJbnB1dFR5cGUuaAppbmRleCBhZDk0MGI0NGM2YTMyODI1MDY0YmYzM2I4 YmQwZjkzMjA2YmI0YWRkLi4xNTNhZmFjMTkyY2Y3MmYzNTJlMDNhMDg5ZWNlYWRjYjgwOWEyMGZl IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvUmVzZXRJbnB1dFR5cGUuaAorKysgYi9XZWJDb3Jl L2h0bWwvUmVzZXRJbnB1dFR5cGUuaApAQCAtNDMsNiArNDMsNyBAQCBwcml2YXRlOgogICAgIFJl c2V0SW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpIDogQmFzZUJ1dHRvbklucHV0 VHlwZShlbGVtZW50KSB7IH0KICAgICB2aXJ0dWFsIGNvbnN0IEF0b21pY1N0cmluZyYgZm9ybUNv bnRyb2xUeXBlKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHN1cHBvcnRzVmFsaWRhdGlvbigp IGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVET01BY3RpdmF0ZUV2ZW50KEV2ZW50Kik7 CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwv U3VibWl0SW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1dFR5cGUuY3BwCmlu ZGV4IDk5YzgwOGUxNGI1MGM2NTc5YmExNTg1NGQzNTQzMjhiZDRiNzE1YzMuLjViMzc3OTNkY2Mz N2M0ZTdkNTc4NTQzYzdmNGU3YWE4MjU1MDE1MjIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9T dWJtaXRJbnB1dFR5cGUuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1dFR5cGUuY3Bw CkBAIC02MCw0ICs2MCwxNyBAQCBib29sIFN1Ym1pdElucHV0VHlwZTo6c3VwcG9ydHNWYWxpZGF0 aW9uKCkgY29uc3QKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2Jvb2wgU3VibWl0SW5wdXRUeXBl OjpoYW5kbGVET01BY3RpdmF0ZUV2ZW50KEV2ZW50KiBldmVudCkKK3sKKyAgICBpZiAoZWxlbWVu dCgpLT5kaXNhYmxlZCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKCFlbGVtZW50 KCktPmZvcm0oKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgUmVmUHRyPEhUTUxJbnB1dEVs ZW1lbnQ+IGlucHV0KGVsZW1lbnQoKSk7CisgICAgaW5wdXQtPnNldEFjdGl2YXRlZFN1Ym1pdCh0 cnVlKTsKKyAgICBpbnB1dC0+Zm9ybSgpLT5wcmVwYXJlU3VibWl0KGV2ZW50KTsgLy8gSmF2YVNj cmlwdCBjb2RlIG1pZ2h0IHJ1bi4KKyAgICBpbnB1dC0+c2V0QWN0aXZhdGVkU3VibWl0KGZhbHNl KTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9TdWJt aXRJbnB1dFR5cGUuaAppbmRleCAyZmU3YWNlOTZjNTMwNTc4MDIyZmI0ZDIzYTRlYzE4ZjkyN2Ix ZmNhLi5kMDMyMTljZTE5ZjNhODNkZmQwNjU0MDU2ZWQwMmY4YjZkOTM0Mjg2IDEwMDY0NAotLS0g YS9XZWJDb3JlL2h0bWwvU3VibWl0SW5wdXRUeXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL1N1Ym1p dElucHV0VHlwZS5oCkBAIC00NCw2ICs0NCw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBjb25z dCBBdG9taWNTdHJpbmcmIGZvcm1Db250cm9sVHlwZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9v bCBhcHBlbmRGb3JtRGF0YShGb3JtRGF0YUxpc3QmLCBib29sKSBjb25zdDsKICAgICB2aXJ0dWFs IGJvb2wgc3VwcG9ydHNWYWxpZGF0aW9uKCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGhhbmRs ZURPTUFjdGl2YXRlRXZlbnQoRXZlbnQqKTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwIGIvV2ViQ29y ZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAKaW5kZXggOTI2ZDBhYzY3OTY2NzQ2NGRkNjgy NTZmNzNhMjA0Y2VlYzNiYWZiNC4uZDkzZjk3MjFmNTNlODI4ZWQ4ZjkyZmMxNzhlMzRiNzRmM2M3 OWFjOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAKKysr IGIvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAKQEAgLTMxLDcgKzMxLDkgQEAK ICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJUZXh0RmllbGRJbnB1dFR5cGUuaCIKIAor I2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiSFRNTElucHV0RWxlbWVudC5oIgorI2luY2x1 ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJSZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxp bmUuaCIKICNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIApAQCAtNDcsNiArNDksMzIg QEAgYm9vbCBUZXh0RmllbGRJbnB1dFR5cGU6OnZhbHVlTWlzc2luZyhjb25zdCBTdHJpbmcmIHZh bHVlKSBjb25zdAogICAgIHJldHVybiB2YWx1ZS5pc0VtcHR5KCk7CiB9CiAKK2Jvb2wgVGV4dEZp ZWxkSW5wdXRUeXBlOjpoYW5kbGVLZXlkb3duRXZlbnQoS2V5Ym9hcmRFdmVudCogZXZlbnQpCit7 CisgICAgaWYgKCFlbGVtZW50KCktPmZvY3VzZWQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIEZyYW1lKiBmcmFtZSA9IGVsZW1lbnQoKS0+ZG9jdW1lbnQoKS0+ZnJhbWUoKTsKKyAgICBp ZiAoIWZyYW1lIHx8ICFmcmFtZS0+ZWRpdG9yKCktPmRvVGV4dEZpZWxkQ29tbWFuZEZyb21FdmVu dChlbGVtZW50KCksIGV2ZW50KSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGV2ZW50LT5z ZXREZWZhdWx0SGFuZGxlZCgpOworICAgIHJldHVybiB0cnVlOworfQorCitib29sIFRleHRGaWVs ZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50Rm9yU3BpbkJ1dHRvbihLZXlib2FyZEV2ZW50 KiBldmVudCkKK3sKKyAgICBjb25zdCBTdHJpbmcmIGtleSA9IGV2ZW50LT5rZXlJZGVudGlmaWVy KCk7CisgICAgaW50IHN0ZXAgPSAwOworICAgIGlmIChrZXkgPT0gIlVwIikKKyAgICAgICAgc3Rl cCA9IDE7CisgICAgZWxzZSBpZiAoa2V5ID09ICJEb3duIikKKyAgICAgICAgc3RlcCA9IC0xOwor ICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGVsZW1lbnQoKS0+c3RlcFVwRnJv bVJlbmRlcmVyKHN0ZXApOworICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOworICAgIHJl dHVybiB0cnVlOworfQorCiBSZW5kZXJPYmplY3QqIFRleHRGaWVsZElucHV0VHlwZTo6Y3JlYXRl UmVuZGVyZXIoUmVuZGVyQXJlbmEqIGFyZW5hLCBSZW5kZXJTdHlsZSopIGNvbnN0CiB7CiAgICAg cmV0dXJuIG5ldyAoYXJlbmEpIFJlbmRlclRleHRDb250cm9sU2luZ2xlTGluZShlbGVtZW50KCks IGVsZW1lbnQoKS0+cGxhY2Vob2xkZXJTaG91bGRCZVZpc2libGUoKSk7CmRpZmYgLS1naXQgYS9X ZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvVGV4dEZpZWxk SW5wdXRUeXBlLmgKaW5kZXggNzhiZWMxZDU4ZTFhM2Y1YjJiOWNiMWEzMTUwOTI1ZWM3YmY0ZTk1 NS4uNTA0MThhYWNkZjJiYjg4MjMwMjEyMmY1NWMxZmVkMTdkOGYzYjAyNSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9UZXh0 RmllbGRJbnB1dFR5cGUuaApAQCAtNDIsNiArNDIsOCBAQCBwcm90ZWN0ZWQ6CiAgICAgVGV4dEZp ZWxkSW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpIDogSW5wdXRUeXBlKGVsZW1l bnQpIHsgfQogICAgIHZpcnR1YWwgYm9vbCBpc1RleHRGaWVsZCgpIGNvbnN0OwogICAgIHZpcnR1 YWwgYm9vbCB2YWx1ZU1pc3NpbmcoY29uc3QgU3RyaW5nJikgY29uc3Q7CisgICAgdmlydHVhbCBi b29sIGhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50Kik7CisgICAgYm9vbCBoYW5kbGVL ZXlkb3duRXZlbnRGb3JTcGluQnV0dG9uKEtleWJvYXJkRXZlbnQqKTsKICAgICB2aXJ0dWFsIFJl bmRlck9iamVjdCogY3JlYXRlUmVuZGVyZXIoUmVuZGVyQXJlbmEqLCBSZW5kZXJTdHlsZSopIGNv bnN0OwogfTsKIAo= 73875 2010-11-14 21:35:14 -0800 2010-11-15 21:14:40 -0800 Patch 3 (rebased for keyIdentifier()) bug-48317-20101115143511.patch text/plain 28361 tkent ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWZmYThhMTQxOGJjZmMzYTQ0MDViNGRjNmI2YjQ4NjdjMzNjOTcxOS4uOTM5N2I2MTIxMTgyMDA2 ZWFhMDlkNjIwMTdkODZjZjg4MGRmNzExZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2MyBAQAorMjAxMC0xMC0yNiAgS2Vu dCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgUmVmYWN0b3IgSFRNTElucHV0RWxlbWVudDogTW92ZSBh IHBhcnQgb2YgSFRNTElucHV0RWxlbWVudDo6CisgICAgICAgIGRlZmF1bHRFdmVudEhhbmRsZXIo KSB0byBJbnB1dFR5cGVzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NDgzMTcKKworICAgICAgICBNb3ZlIG91dCB0aGUgZm9sbG93aW5ncyB0byBJbnB1 dFR5cGVzOgorICAgICAgICAgLSBjbGljayBldmVudCBwcm9jZXNzaW5nLAorICAgICAgICAgLSB0 aGUgZmlyc3Qga2V5ZG93biBldmVudCBwcm9jZXNzaW5nLCBhbmQKKyAgICAgICAgIC0gRE9NQWN0 aXZhdGUgZXZlbnQgcHJvY2Vzc2luZy4KKworICAgICAgICBNb3ZlIG1feFBvcyBhbmQgbV95UG9z IGZyb20gSFRNTElucHV0RWxlbWVudCB0byBJbWFnZUlucHV0VHlwZSBhcworICAgICAgICBtX2Ns aWNrTG9jYXRpb24uIEl0J3Mgb2sgdG8gbW92ZSB0aGVtIGJlY2F1c2UgdGhleSBzaG91bGQgYmUg dmFsaWQgb25seQorICAgICAgICB3aGVuIEhUTUxJbnB1dEVsZW1lbnQ6Om1fYWN0aXZlU3VibWl0 IGlzIHRydWUuIEZvciB0eXBlPWltYWdlLAorICAgICAgICBtX2FjdGl2ZVN1Ym1pdCBpcyB0cnVl IG9ubHkgaW4gRE9NQWN0aXZhdGUgZXZlbnQgaGFuZGxpbmcuIFNvIHdlIHJlc2V0CisgICAgICAg IG1fY2xpY2tMb2NhdGlvbiBpbiBoYW5kbGVET01BY3RpdmF0ZUV2ZW50KCkgd2l0aCBFdmVudDo6 dW5kZXJseWluZ0V2ZW50KCkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIGJlY2F1c2UgdGhpcyBp cyBqdXN0IGEgcmVmYWN0b3JpbmcuCisKKyAgICAgICAgKiBodG1sL0Jhc2VEYXRlQW5kVGltZUlu cHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpCYXNlRGF0ZUFuZFRpbWVJbnB1dFR5cGU6 OmhhbmRsZUtleWRvd25FdmVudCk6CisgICAgICAgICogaHRtbC9CYXNlRGF0ZUFuZFRpbWVJbnB1 dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL0ZpbGVJbnB1dFR5cGUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6RmlsZUlucHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudCk6CisgICAgICAgICog aHRtbC9GaWxlSW5wdXRUeXBlLmg6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OkhUTUxJbnB1dEVsZW1lbnQp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxl cik6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9J bWFnZUlucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbWFnZUlucHV0VHlwZTo6YXBw ZW5kRm9ybURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6SW1hZ2VJbnB1dFR5cGU6OmhhbmRsZURP TUFjdGl2YXRlRXZlbnQpOgorICAgICAgICAqIGh0bWwvSW1hZ2VJbnB1dFR5cGUuaDoKKyAgICAg ICAgKiBodG1sL0lucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnB1dFR5cGU6Omhh bmRsZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6SW5wdXRUeXBlOjpoYW5kbGVET01B Y3RpdmF0ZUV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OklucHV0VHlwZTo6aGFuZGxlS2V5ZG93 bkV2ZW50KToKKyAgICAgICAgKiBodG1sL0lucHV0VHlwZS5oOgorICAgICAgICAqIGh0bWwvTnVt YmVySW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok51bWJlcklucHV0VHlwZTo6aGFu ZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKiBodG1sL051bWJlcklucHV0VHlwZS5oOgorICAg ICAgICAqIGh0bWwvUmFkaW9JbnB1dFR5cGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmFkaW9J bnB1dFR5cGU6OmhhbmRsZUNsaWNrRXZlbnQpOgorICAgICAgICAqIGh0bWwvUmFkaW9JbnB1dFR5 cGUuaDoKKyAgICAgICAgKiBodG1sL1JhbmdlSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJhbmdlSW5wdXRUeXBlOjpoYW5kbGVLZXlkb3duRXZlbnQpOgorICAgICAgICAqIGh0bWwv UmFuZ2VJbnB1dFR5cGUuaDoKKyAgICAgICAgKiBodG1sL1Jlc2V0SW5wdXRUeXBlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlJlc2V0SW5wdXRUeXBlOjpoYW5kbGVET01BY3RpdmF0ZUV2ZW50KToK KyAgICAgICAgKiBodG1sL1Jlc2V0SW5wdXRUeXBlLmg6CisgICAgICAgICogaHRtbC9TdWJtaXRJ bnB1dFR5cGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3VibWl0SW5wdXRUeXBlOjpoYW5kbGVE T01BY3RpdmF0ZUV2ZW50KToKKyAgICAgICAgKiBodG1sL1N1Ym1pdElucHV0VHlwZS5oOgorICAg ICAgICAqIGh0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRl eHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6 OlRleHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50Rm9yU3BpbkJ1dHRvbik6Cisg ICAgICAgICogaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaDoKKwogMjAxMC0xMS0xNCAgS2VudCBU YW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQW5kcmVh cyBLbGluZy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9CYXNlRGF0ZUFuZFRpbWVJbnB1dFR5 cGUuY3BwIGIvV2ViQ29yZS9odG1sL0Jhc2VEYXRlQW5kVGltZUlucHV0VHlwZS5jcHAKaW5kZXgg ZTExMjZkNGQ2ZDdiOWVjYWU1OTZjZGY5NTQ5YTBkNjdiMTM5Mzk3Mi4uZTc4MGVkNmJhMjRkMjBm YWZiZGI2MjllMjgzNjk4NWYxYTVhOTBjYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0Jhc2VE YXRlQW5kVGltZUlucHV0VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0Jhc2VEYXRlQW5kVGlt ZUlucHV0VHlwZS5jcHAKQEAgLTEwOCw2ICsxMDgsMTEgQEAgZG91YmxlIEJhc2VEYXRlQW5kVGlt ZUlucHV0VHlwZTo6c3RlcEJhc2UoKSBjb25zdAogICAgIHJldHVybiBwYXJzZVRvRG91YmxlKGVs ZW1lbnQoKS0+ZmFzdEdldEF0dHJpYnV0ZShtaW5BdHRyKSwgZGVmYXVsdFN0ZXBCYXNlKCkpOwog fQogCitib29sIEJhc2VEYXRlQW5kVGltZUlucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtl eWJvYXJkRXZlbnQqIGV2ZW50KQoreworICAgIHJldHVybiBoYW5kbGVLZXlkb3duRXZlbnRGb3JT cGluQnV0dG9uKGV2ZW50KSB8fCBUZXh0RmllbGRJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVu dChldmVudCk7Cit9CisKIGRvdWJsZSBCYXNlRGF0ZUFuZFRpbWVJbnB1dFR5cGU6OnBhcnNlVG9E b3VibGUoY29uc3QgU3RyaW5nJiBzcmMsIGRvdWJsZSBkZWZhdWx0VmFsdWUpIGNvbnN0CiB7CiAg ICAgRGF0ZUNvbXBvbmVudHMgZGF0ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9CYXNlRGF0 ZUFuZFRpbWVJbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9CYXNlRGF0ZUFuZFRpbWVJbnB1dFR5 cGUuaAppbmRleCA4M2MxZTkzZmUyNDE3MzM5MjQ4MTdhNDRmYjA1OTE4ZjkwYzg5NzJjLi4xMWM2 MGFmY2E2NThjNmI3MjJmYzAyN2RkZTU4NGNkNjc1NjBkNDlhIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2h0bWwvQmFzZURhdGVBbmRUaW1lSW5wdXRUeXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL0Jhc2VE YXRlQW5kVGltZUlucHV0VHlwZS5oCkBAIC01Nyw2ICs1Nyw3IEBAIHByaXZhdGU6CiAgICAgdmly dHVhbCBib29sIHJhbmdlT3ZlcmZsb3coY29uc3QgU3RyaW5nJikgY29uc3Q7CiAgICAgdmlydHVh bCBib29sIHN0ZXBNaXNtYXRjaChjb25zdCBTdHJpbmcmLCBkb3VibGUpIGNvbnN0OwogICAgIHZp cnR1YWwgZG91YmxlIHN0ZXBCYXNlKCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGhhbmRsZUtl eWRvd25FdmVudChLZXlib2FyZEV2ZW50Kik7CiAgICAgdmlydHVhbCBTdHJpbmcgc2VyaWFsaXpl KGRvdWJsZSkgY29uc3Q7CiB9OwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvRmlsZUlucHV0 VHlwZS5jcHAgYi9XZWJDb3JlL2h0bWwvRmlsZUlucHV0VHlwZS5jcHAKaW5kZXggZDk4ZDNiNmM4 YmNlYzQ5OWFkZWYwYzkyZWFjNjFlNWYwOGE4YjQ5Mi4uZmExNmIxZDI0NzRlZDk2NjM3NmIzOTM1 MWY1YjUzODQ5ZjAyNDg3MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0ZpbGVJbnB1dFR5cGUu Y3BwCisrKyBiL1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmNwcApAQCAtNzYsNiArNzYsMTMg QEAgYm9vbCBGaWxlSW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmcoY29uc3QgU3RyaW5nJiB2YWx1ZSkg Y29uc3QKICAgICByZXR1cm4gdmFsdWUuaXNFbXB0eSgpOwogfQogCitib29sIEZpbGVJbnB1dFR5 cGU6OmhhbmRsZURPTUFjdGl2YXRlRXZlbnQoRXZlbnQqKQoreworICAgIGlmICghZWxlbWVudCgp LT5kaXNhYmxlZCgpICYmIGVsZW1lbnQoKS0+cmVuZGVyZXIoKSkKKyAgICAgICAgdG9SZW5kZXJG aWxlVXBsb2FkQ29udHJvbChlbGVtZW50KCktPnJlbmRlcmVyKCkpLT5jbGljaygpOworICAgIHJl dHVybiBmYWxzZTsKK30KKwogUmVuZGVyT2JqZWN0KiBGaWxlSW5wdXRUeXBlOjpjcmVhdGVSZW5k ZXJlcihSZW5kZXJBcmVuYSogYXJlbmEsIFJlbmRlclN0eWxlKikgY29uc3QKIHsKICAgICByZXR1 cm4gbmV3IChhcmVuYSkgUmVuZGVyRmlsZVVwbG9hZENvbnRyb2woZWxlbWVudCgpKTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvRmlsZUlu cHV0VHlwZS5oCmluZGV4IDI0NDMwZmIyNDcxOGI1ZjdiNDQxNTRiOThlMzhjY2IwYjRmNGJkOTIu LjE0MmFmYWY2Y2Y3OTU4NTdmNWM1MDI5YzFlOGZjYjE2MmRjMWM4MTEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvaHRtbC9GaWxlSW5wdXRUeXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL0ZpbGVJbnB1dFR5 cGUuaApAQCAtNDQsNiArNDQsNyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgY29uc3QgQXRvbWlj U3RyaW5nJiBmb3JtQ29udHJvbFR5cGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgYXBwZW5k Rm9ybURhdGEoRm9ybURhdGFMaXN0JiwgYm9vbCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHZh bHVlTWlzc2luZyhjb25zdCBTdHJpbmcmKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaGFuZGxl RE9NQWN0aXZhdGVFdmVudChFdmVudCopOwogICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVh dGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKikgY29uc3Q7CiB9OwogCmRpZmYg LS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9XZWJDb3JlL2h0bWwv SFRNTElucHV0RWxlbWVudC5jcHAKaW5kZXggYzY4M2Q0OTFkNWI4ZGU4NDRkZjdjZjEyNzM4ZDMw ZTUyNTk2ZmU1My4uMjBkMzJhZDlmYzFlMGM0NDg0NDk4MTU3MjNjYzBkM2U3MzZiYTUzOSAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtODgsOCArODgsNiBAQCBzdGF0aWMgYm9vbCBp c051bWJlckNoYXJhY3RlcihVQ2hhciBjaCkKIAogSFRNTElucHV0RWxlbWVudDo6SFRNTElucHV0 RWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCogZG9jdW1lbnQs IEhUTUxGb3JtRWxlbWVudCogZm9ybSkKICAgICA6IEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50 KHRhZ05hbWUsIGRvY3VtZW50LCBmb3JtKQotICAgICwgbV94UG9zKDApCi0gICAgLCBtX3lQb3Mo MCkKICAgICAsIG1fbWF4UmVzdWx0cygtMSkKICAgICAsIG1fZGVwcmVjYXRlZFR5cGVOdW1iZXIo VEVYVCkKICAgICAsIG1fY2hlY2tlZChmYWxzZSkKQEAgLTEyNTgsNTcgKzEyNTYsMTIgQEAgdm9p ZCBIVE1MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCiAgICAg aWYgKGlzVGV4dEZpZWxkKCkgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLnRleHRJbnB1 dEV2ZW50ICYmIGV2dC0+aXNUZXh0RXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxUZXh0RXZlbnQqPihl dnQpLT5kYXRhKCkgPT0gIlxuIikKICAgICAgICAgaW1wbGljaXRTdWJtaXNzaW9uID0gdHJ1ZTsK IAotICAgIGlmIChkZXByZWNhdGVkSW5wdXRUeXBlKCkgPT0gSU1BR0UgJiYgZXZ0LT5pc01vdXNl RXZlbnQoKSAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkgewotICAg ICAgICAvLyByZWNvcmQgdGhlIG1vdXNlIHBvc2l0aW9uIGZvciB3aGVuIHdlIGdldCB0aGUgRE9N QWN0aXZhdGUgZXZlbnQKLSAgICAgICAgTW91c2VFdmVudCogbWUgPSBzdGF0aWNfY2FzdDxNb3Vz ZUV2ZW50Kj4oZXZ0KTsKLSAgICAgICAgLy8gRklYTUU6IFdlIGNvdWxkIGp1c3QgY2FsbCBvZmZz ZXRYKCkgYW5kIG9mZnNldFkoKSBvbiB0aGUgZXZlbnQsCi0gICAgICAgIC8vIGJ1dCB0aGF0J3Mg Y3VycmVudGx5IGJyb2tlbiwgc28gZm9yIG5vdyBkbyB0aGUgY29tcHV0YXRpb24gaGVyZS4KLSAg ICAgICAgaWYgKG1lLT5pc1NpbXVsYXRlZCgpIHx8ICFyZW5kZXJlcigpKSB7Ci0gICAgICAgICAg ICBtX3hQb3MgPSAwOwotICAgICAgICAgICAgbV95UG9zID0gMDsKLSAgICAgICAgfSBlbHNlIHsK LSAgICAgICAgICAgIC8vIEZJWE1FOiBUaGlzIGRvZXNuJ3Qgd29yayBjb3JyZWN0bHkgd2l0aCB0 cmFuc2Zvcm1zLgotICAgICAgICAgICAgLy8gRklYTUU6IHBhZ2VYL3BhZ2VZIG5lZWQgYWRqdXN0 aW5nIGZvciBwYWdlWm9vbUZhY3RvcigpLiBVc2UgYWN0dWFsUGFnZUxvY2F0aW9uKCk/Ci0gICAg ICAgICAgICBJbnRQb2ludCBhYnNPZmZzZXQgPSByb3VuZGVkSW50UG9pbnQocmVuZGVyZXIoKS0+ bG9jYWxUb0Fic29sdXRlKCkpOwotICAgICAgICAgICAgbV94UG9zID0gbWUtPnBhZ2VYKCkgLSBh YnNPZmZzZXQueCgpOwotICAgICAgICAgICAgbV95UG9zID0gbWUtPnBhZ2VZKCkgLSBhYnNPZmZz ZXQueSgpOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgaWYgKGhhc1NwaW5CdXR0b24oKSAmJiBl dnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2Fy ZEV2ZW50KCkpIHsKLSAgICAgICAgY29uc3QgU3RyaW5nJiBrZXkgPSBzdGF0aWNfY2FzdDxLZXli b2FyZEV2ZW50Kj4oZXZ0KS0+a2V5SWRlbnRpZmllcigpOwotICAgICAgICBpbnQgc3RlcCA9IDA7 Ci0gICAgICAgIGlmIChrZXkgPT0gIlVwIikKLSAgICAgICAgICAgIHN0ZXAgPSAxOwotICAgICAg ICBlbHNlIGlmIChrZXkgPT0gIkRvd24iKQotICAgICAgICAgICAgc3RlcCA9IC0xOwotICAgICAg ICBpZiAoc3RlcCkgewotICAgICAgICAgICAgc3RlcFVwRnJvbVJlbmRlcmVyKHN0ZXApOwotICAg ICAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgICAgICAgICAgcmV0dXJuOwot ICAgICAgICB9Ci0gICAgfQotICAgIGlmIChkZXByZWNhdGVkSW5wdXRUeXBlKCkgPT0gUkFOR0Ug JiYgZXZ0LT5pc0tleWJvYXJkRXZlbnQoKSkgewotICAgICAgICBoYW5kbGVLZXlFdmVudEZvclJh bmdlKHN0YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldnQpKTsKLSAgICAgICAgaWYgKGV2dC0+ ZGVmYXVsdEhhbmRsZWQoKSkKLSAgICAgICAgICAgIHJldHVybjsKLSAgICB9Ci0gCi0gICBpZiAo aXNUZXh0RmllbGQoKQotICAgICAgICAgICAgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygp LmtleWRvd25FdmVudAotICAgICAgICAgICAgJiYgZXZ0LT5pc0tleWJvYXJkRXZlbnQoKQotICAg ICAgICAgICAgJiYgZm9jdXNlZCgpCi0gICAgICAgICAgICAmJiBkb2N1bWVudCgpLT5mcmFtZSgp Ci0gICAgICAgICAgICAmJiBkb2N1bWVudCgpLT5mcmFtZSgpLT5lZGl0b3IoKS0+ZG9UZXh0Rmll bGRDb21tYW5kRnJvbUV2ZW50KHRoaXMsIHN0YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldnQp KSkgewotICAgICAgICBldnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisgICAgaWYgKGV2dC0+aXNN b3VzZUV2ZW50KCkgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgJiYg bV9pbnB1dFR5cGUtPmhhbmRsZUNsaWNrRXZlbnQoc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2 dCkpKQogICAgICAgICByZXR1cm47Ci0gICAgfQogCi0gICAgaWYgKGRlcHJlY2F0ZWRJbnB1dFR5 cGUoKSA9PSBSQURJTyAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkg ewotICAgICAgICBldnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisgICAgaWYgKGV2dC0+aXNLZXli b2FyZEV2ZW50KCkgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRvd25FdmVudCAm JiBtX2lucHV0VHlwZS0+aGFuZGxlS2V5ZG93bkV2ZW50KHN0YXRpY19jYXN0PEtleWJvYXJkRXZl bnQqPihldnQpKSkKICAgICAgICAgcmV0dXJuOwotICAgIH0KLSAgICAKKwogICAgIC8vIENhbGwg dGhlIGJhc2UgZXZlbnQgaGFuZGxlciBiZWZvcmUgYW55IG9mIG91ciBvd24gZXZlbnQgaGFuZGxp bmcgZm9yIGFsbW9zdCBhbGwgZXZlbnRzIGluIHRleHQgZmllbGRzLgogICAgIC8vIE1ha2VzIGVk aXRpbmcga2V5Ym9hcmQgaGFuZGxpbmcgdGFrZSBwcmVjZWRlbmNlIG92ZXIgdGhlIGtleWRvd24g YW5kIGtleXByZXNzIGhhbmRsaW5nIGluIHRoaXMgZnVuY3Rpb24uCiAgICAgYm9vbCBjYWxsQmFz ZUNsYXNzRWFybHkgPSBpc1RleHRGaWVsZCgpICYmICFpbXBsaWNpdFN1Ym1pc3Npb24KQEAgLTEz MjMsMjcgKzEyNzYsOCBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRs ZXIoRXZlbnQqIGV2dCkKICAgICAvLyBhY3R1YWxseSBzdWJtaXR0aW5nIHRoZSBmb3JtLiBGb3Ig cmVzZXQgaW5wdXRzLCB0aGUgZm9ybSBpcyByZXNldC4gVGhlc2UgZXZlbnRzIGFyZSBzZW50IHdo ZW4gdGhlIHVzZXIgY2xpY2tzCiAgICAgLy8gb24gdGhlIGVsZW1lbnQsIG9yIHByZXNzZXMgZW50 ZXIgd2hpbGUgaXQgaXMgdGhlIGFjdGl2ZSBlbGVtZW50LiBKYXZhU2NyaXB0IGNvZGUgd2lzaGlu ZyB0byBhY3RpdmF0ZSB0aGUgZWxlbWVudAogICAgIC8vIG11c3QgZGlzcGF0Y2ggYSBET01BY3Rp dmF0ZSBldmVudCAtIGEgY2xpY2sgZXZlbnQgd2lsbCBub3QgZG8gdGhlIGpvYi4KLSAgICBpZiAo ZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLkRPTUFjdGl2YXRlRXZlbnQgJiYgIWRpc2FibGVk KCkpIHsKLSAgICAgICAgaWYgKGRlcHJlY2F0ZWRJbnB1dFR5cGUoKSA9PSBJTUFHRSB8fCBkZXBy ZWNhdGVkSW5wdXRUeXBlKCkgPT0gU1VCTUlUIHx8IGRlcHJlY2F0ZWRJbnB1dFR5cGUoKSA9PSBS RVNFVCkgewotICAgICAgICAgICAgaWYgKCFmb3JtKCkpCi0gICAgICAgICAgICAgICAgcmV0dXJu OwotICAgICAgICAgICAgaWYgKGRlcHJlY2F0ZWRJbnB1dFR5cGUoKSA9PSBSRVNFVCkKLSAgICAg ICAgICAgICAgICBmb3JtKCktPnJlc2V0KCk7Ci0gICAgICAgICAgICBlbHNlIHsKLSAgICAgICAg ICAgICAgICBtX2FjdGl2ZVN1Ym1pdCA9IHRydWU7Ci0gICAgICAgICAgICAgICAgLy8gRklYTUU6 IFdvdWxkIGJlIGNsZWFuZXIgdG8gZ2V0IG1feFBvcyBhbmQgbV95UG9zIG91dCBvZiB0aGUgdW5k ZXJseWluZyBtb3VzZQotICAgICAgICAgICAgICAgIC8vIGV2ZW50IChpZiBhbnkpIGhlcmUgaW5z dGVhZCBvZiByZWx5aW5nIG9uIHRoZSB2YXJpYWJsZXMgc2V0IGFib3ZlIHdoZW4KLSAgICAgICAg ICAgICAgICAvLyBwcm9jZXNzaW5nIHRoZSBjbGljayBldmVudC4gRXZlbiBiZXR0ZXIsIGFwcGVu ZEZvcm1EYXRhIGNvdWxkIHBhc3MgdGhlCi0gICAgICAgICAgICAgICAgLy8gZXZlbnQgaW4sIGFu ZCB0aGVuIHdlIGNvdWxkIGdldCByaWQgb2YgbV94UG9zIGFuZCBtX3lQb3MgYWx0b2dldGhlciEK LSAgICAgICAgICAgICAgICBpZiAoIWZvcm0oKS0+cHJlcGFyZVN1Ym1pdChldnQpKSB7Ci0gICAg ICAgICAgICAgICAgICAgIG1feFBvcyA9IDA7Ci0gICAgICAgICAgICAgICAgICAgIG1feVBvcyA9 IDA7Ci0gICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIG1fYWN0aXZlU3VibWl0ID0g ZmFsc2U7Ci0gICAgICAgICAgICB9Ci0gICAgICAgIH0gZWxzZSBpZiAoZGVwcmVjYXRlZElucHV0 VHlwZSgpID09IEZJTEUgJiYgcmVuZGVyZXIoKSkKLSAgICAgICAgICAgIHRvUmVuZGVyRmlsZVVw bG9hZENvbnRyb2wocmVuZGVyZXIoKSktPmNsaWNrKCk7Ci0gICAgfQorICAgIGlmIChldnQtPnR5 cGUoKSA9PSBldmVudE5hbWVzKCkuRE9NQWN0aXZhdGVFdmVudCAmJiBtX2lucHV0VHlwZS0+aGFu ZGxlRE9NQWN0aXZhdGVFdmVudChldnQpKQorICAgICAgICByZXR1cm47CiAKICAgICAvLyBVc2Ug a2V5IHByZXNzIGV2ZW50IGhlcmUgc2luY2Ugc2VuZGluZyBzaW11bGF0ZWQgbW91c2UgZXZlbnRz CiAgICAgLy8gb24ga2V5IGRvd24gYmxvY2tzIHRoZSBwcm9wZXIgc2VuZGluZyBvZiB0aGUga2V5 IHByZXNzIGV2ZW50LgpAQCAtMTYwMiw0NyArMTUzNiw2IEBAIHZvaWQgSFRNTElucHV0RWxlbWVu dDo6aGFuZGxlQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoRXZlbnQqIGV2ZW50KQogICAgIElucHV0 RWxlbWVudDo6aGFuZGxlQmVmb3JlVGV4dEluc2VydGVkRXZlbnQobV9kYXRhLCB0aGlzLCB0aGlz LCBldmVudCk7CiB9CiAKLXZvaWQgSFRNTElucHV0RWxlbWVudDo6aGFuZGxlS2V5RXZlbnRGb3JS YW5nZShLZXlib2FyZEV2ZW50KiBldmVudCkKLXsKLSAgICBpZiAoZXZlbnQtPnR5cGUoKSAhPSBl dmVudE5hbWVzKCkua2V5ZG93bkV2ZW50KQotICAgICAgICByZXR1cm47Ci0gICAgY29uc3QgU3Ry aW5nJiBrZXkgPSBldmVudC0+a2V5SWRlbnRpZmllcigpOwotICAgIGlmIChrZXkgIT0gIlVwIiAm JiBrZXkgIT0gIlJpZ2h0IiAmJiBrZXkgIT0gIkRvd24iICYmIGtleSAhPSAiTGVmdCIpCi0gICAg ICAgIHJldHVybjsKLQotICAgIEV4Y2VwdGlvbkNvZGUgZWM7Ci0gICAgaWYgKGVxdWFsSWdub3Jp bmdDYXNlKGdldEF0dHJpYnV0ZShzdGVwQXR0ciksICJhbnkiKSkgewotICAgICAgICBkb3VibGUg bWluID0gbV9pbnB1dFR5cGUtPm1pbmltdW0oKTsKLSAgICAgICAgZG91YmxlIG1heCA9IG1faW5w dXRUeXBlLT5tYXhpbXVtKCk7Ci0gICAgICAgIC8vIEZJWE1FOiBJcyAxLzEwMCByZWFzb25hYmxl PwotICAgICAgICBkb3VibGUgc3RlcCA9IChtYXggLSBtaW4pIC8gMTAwOwotICAgICAgICBkb3Vi bGUgY3VycmVudCA9IG1faW5wdXRUeXBlLT5wYXJzZVRvRG91YmxlKHZhbHVlKCksIG51bWVyaWNf bGltaXRzPGRvdWJsZT46OnF1aWV0X05hTigpKTsKLSAgICAgICAgQVNTRVJUKGlzZmluaXRlKGN1 cnJlbnQpKTsKLSAgICAgICAgZG91YmxlIG5ld1ZhbHVlOwotICAgICAgICBpZiAoa2V5ID09ICJV cCIgfHwga2V5ID09ICJSaWdodCIpIHsKLSAgICAgICAgICAgIG5ld1ZhbHVlID0gY3VycmVudCAr IHN0ZXA7Ci0gICAgICAgICAgICBpZiAobmV3VmFsdWUgPiBtYXgpCi0gICAgICAgICAgICAgICAg bmV3VmFsdWUgPSBtYXg7Ci0gICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICBuZXdWYWx1ZSA9 IGN1cnJlbnQgLSBzdGVwOwotICAgICAgICAgICAgaWYgKG5ld1ZhbHVlIDwgbWluKQotICAgICAg ICAgICAgICAgIG5ld1ZhbHVlID0gbWluOwotICAgICAgICB9Ci0gICAgICAgIGlmIChuZXdWYWx1 ZSAhPSBjdXJyZW50KSB7Ci0gICAgICAgICAgICBzZXRWYWx1ZUFzTnVtYmVyKG5ld1ZhbHVlLCBl Yyk7Ci0gICAgICAgICAgICBkaXNwYXRjaEZvcm1Db250cm9sQ2hhbmdlRXZlbnQoKTsKLSAgICAg ICAgfQotICAgIH0gZWxzZSB7Ci0gICAgICAgIGludCBzdGVwTWFnbmlmaWNhdGlvbiA9IChrZXkg PT0gIlVwIiB8fCBrZXkgPT0gIlJpZ2h0IikgPyAxIDogLTE7Ci0gICAgICAgIFN0cmluZyBsYXN0 U3RyaW5nVmFsdWUgPSB2YWx1ZSgpOwotICAgICAgICBzdGVwVXAoc3RlcE1hZ25pZmljYXRpb24s IGVjKTsKLSAgICAgICAgaWYgKGxhc3RTdHJpbmdWYWx1ZSAhPSB2YWx1ZSgpKQotICAgICAgICAg ICAgZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7Ci0gICAgfQotICAgIGV2ZW50LT5z ZXREZWZhdWx0SGFuZGxlZCgpOwotICAgIHJldHVybjsKLX0KLQogUGFzc1JlZlB0cjxIVE1MRm9y bUVsZW1lbnQ+IEhUTUxJbnB1dEVsZW1lbnQ6OmNyZWF0ZVRlbXBvcmFyeUZvcm1Gb3JJc0luZGV4 KCkKIHsKICAgICBSZWZQdHI8SFRNTEZvcm1FbGVtZW50PiBmb3JtID0gSFRNTEZvcm1FbGVtZW50 OjpjcmVhdGUoZG9jdW1lbnQoKSk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTElucHV0 RWxlbWVudC5oIGIvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAppbmRleCAwYWNmMjFl NzVlOGY3MWJmNzk2NDY1YzQ4MWZlMTE5YzQ1YzE3ZjBmLi5iMTFiNzVjZTYyN2VjZjFlZDExMWE1 Y2FmNjU3Nzg1ODAwM2U0Nzk0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxl bWVudC5oCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKQEAgLTIwNCwxMCAr MjA0LDYgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gZG9jdW1lbnQoKS0+Y2hlY2tlZFJhZGlv QnV0dG9ucygpOwogICAgIH0KIAotICAgIC8vIEZJWE1FOiBXZSBzaG91bGQgbW92ZSBtX3hQb3Mg YW5kIG1feVBvcyB0byBJbWFnZUlucHV0VHlwZSBjbGFzcy4KLSAgICBpbnQgeFBvc2l0aW9uKCkg Y29uc3QgeyByZXR1cm4gbV94UG9zOyB9Ci0gICAgaW50IHlQb3NpdGlvbigpIGNvbnN0IHsgcmV0 dXJuIG1feVBvczsgfQotCiBwcm90ZWN0ZWQ6CiAgICAgSFRNTElucHV0RWxlbWVudChjb25zdCBR dWFsaWZpZWROYW1lJiwgRG9jdW1lbnQqLCBIVE1MRm9ybUVsZW1lbnQqID0gMCk7CiAKQEAgLTMz Nyw3ICszMzMsNiBAQCBwcml2YXRlOgogICAgIHZvaWQgdXBkYXRlQ2hlY2tlZFJhZGlvQnV0dG9u cygpOwogICAgIAogICAgIHZvaWQgaGFuZGxlQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoRXZlbnQq KTsKLSAgICB2b2lkIGhhbmRsZUtleUV2ZW50Rm9yUmFuZ2UoS2V5Ym9hcmRFdmVudCopOwogICAg IFBhc3NSZWZQdHI8SFRNTEZvcm1FbGVtZW50PiBjcmVhdGVUZW1wb3JhcnlGb3JtRm9ySXNJbmRl eCgpOwogICAgIC8vIEhlbHBlciBmb3Igc3RlcFVwKCkvc3RlcERvd24oKS4gIEFkZHMgc3RlcCB2 YWx1ZSAqIGNvdW50IHRvIHRoZSBjdXJyZW50IHZhbHVlLgogICAgIHZvaWQgYXBwbHlTdGVwKGRv dWJsZSBjb3VudCwgRXhjZXB0aW9uQ29kZSYpOwpAQCAtMzUxLDggKzM0Niw2IEBAIHByaXZhdGU6 CiAjZW5kaWYKIAogICAgIElucHV0RWxlbWVudERhdGEgbV9kYXRhOwotICAgIGludCBtX3hQb3M7 Ci0gICAgaW50IG1feVBvczsKICAgICBzaG9ydCBtX21heFJlc3VsdHM7CiAgICAgT3duUHRyPEhU TUxJbWFnZUxvYWRlcj4gbV9pbWFnZUxvYWRlcjsKICAgICBSZWZQdHI8RmlsZUxpc3Q+IG1fZmls ZUxpc3Q7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSW1hZ2VJbnB1dFR5cGUuY3BwIGIvV2Vi Q29yZS9odG1sL0ltYWdlSW5wdXRUeXBlLmNwcAppbmRleCBkZTI0MTg4OGVjNzdmNWIxNjM5NWU0 ZmM4ZmZiZjhiODk2NTgyMmE4Li42ZjdjMjE4ZDc5YWIyNTA5ZGNkODZlYWZhMjBlYTVmYTk0MWJi OTI3IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSW1hZ2VJbnB1dFR5cGUuY3BwCisrKyBiL1dl YkNvcmUvaHRtbC9JbWFnZUlucHV0VHlwZS5jcHAKQEAgLTI0LDYgKzI0LDcgQEAKIAogI2luY2x1 ZGUgIkZvcm1EYXRhTGlzdC5oIgogI2luY2x1ZGUgIkhUTUxJbnB1dEVsZW1lbnQuaCIKKyNpbmNs dWRlICJNb3VzZUV2ZW50LmgiCiAjaW5jbHVkZSAiUmVuZGVySW1hZ2UuaCIKICNpbmNsdWRlIDx3 dGYvUGFzc093blB0ci5oPgogCkBAIC00OSw4ICs1MCw4IEBAIGJvb2wgSW1hZ2VJbnB1dFR5cGU6 OmFwcGVuZEZvcm1EYXRhKEZvcm1EYXRhTGlzdCYgZW5jb2RpbmcsIGJvb2wpIGNvbnN0CiAgICAg aWYgKCFlbGVtZW50KCktPmlzQWN0aXZhdGVkU3VibWl0KCkpCiAgICAgICAgIHJldHVybiBmYWxz ZTsKICAgICBjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUgPSBlbGVtZW50KCktPm5hbWUoKTsKLSAg ICBlbmNvZGluZy5hcHBlbmREYXRhKG5hbWUuaXNFbXB0eSgpID8gIngiIDogKG5hbWUgKyAiLngi KSwgZWxlbWVudCgpLT54UG9zaXRpb24oKSk7Ci0gICAgZW5jb2RpbmcuYXBwZW5kRGF0YShuYW1l LmlzRW1wdHkoKSA/ICJ5IiA6IChuYW1lICsgIi55IiksIGVsZW1lbnQoKS0+eVBvc2l0aW9uKCkp OworICAgIGVuY29kaW5nLmFwcGVuZERhdGEobmFtZS5pc0VtcHR5KCkgPyAieCIgOiAobmFtZSAr ICIueCIpLCBtX2NsaWNrTG9jYXRpb24ueCgpKTsKKyAgICBlbmNvZGluZy5hcHBlbmREYXRhKG5h bWUuaXNFbXB0eSgpID8gInkiIDogKG5hbWUgKyAiLnkiKSwgbV9jbGlja0xvY2F0aW9uLnkoKSk7 CiAgICAgaWYgKCFuYW1lLmlzRW1wdHkoKSAmJiAhZWxlbWVudCgpLT52YWx1ZSgpLmlzRW1wdHko KSkKICAgICAgICAgZW5jb2RpbmcuYXBwZW5kRGF0YShuYW1lLCBlbGVtZW50KCktPnZhbHVlKCkp OwogICAgIHJldHVybiB0cnVlOwpAQCAtNjEsNiArNjIsMjQgQEAgYm9vbCBJbWFnZUlucHV0VHlw ZTo6c3VwcG9ydHNWYWxpZGF0aW9uKCkgY29uc3QKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2Jv b2wgSW1hZ2VJbnB1dFR5cGU6OmhhbmRsZURPTUFjdGl2YXRlRXZlbnQoRXZlbnQqIGV2ZW50KQor eworICAgIGlmIChlbGVtZW50KCktPmRpc2FibGVkKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICBpZiAoIWVsZW1lbnQoKS0+Zm9ybSgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBS ZWZQdHI8SFRNTElucHV0RWxlbWVudD4gaW5wdXQoZWxlbWVudCgpKTsKKyAgICBpbnB1dC0+c2V0 QWN0aXZhdGVkU3VibWl0KHRydWUpOworICAgIGlmIChldmVudC0+dW5kZXJseWluZ0V2ZW50KCkg JiYgZXZlbnQtPnVuZGVybHlpbmdFdmVudCgpLT5pc01vdXNlRXZlbnQoKSkgeworICAgICAgICBN b3VzZUV2ZW50KiBtb3VzZUV2ZW50ID0gc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2ZW50LT51 bmRlcmx5aW5nRXZlbnQoKSk7CisgICAgICAgIG1fY2xpY2tMb2NhdGlvbiA9IEludFBvaW50KG1v dXNlRXZlbnQtPm9mZnNldFgoKSwgbW91c2VFdmVudC0+b2Zmc2V0WSgpKTsKKyAgICB9IGVsc2UK KyAgICAgICAgbV9jbGlja0xvY2F0aW9uID0gSW50UG9pbnQoKTsKKyAgICBpbnB1dC0+Zm9ybSgp LT5wcmVwYXJlU3VibWl0KGV2ZW50KTsgLy8gSmF2YVNjcmlwdCBjb2RlIG1pZ2h0IHJ1bi4KKyAg ICBpbnB1dC0+c2V0QWN0aXZhdGVkU3VibWl0KGZhbHNlKTsKKyAgICByZXR1cm4gZmFsc2U7Cit9 CisKIFJlbmRlck9iamVjdCogSW1hZ2VJbnB1dFR5cGU6OmNyZWF0ZVJlbmRlcmVyKFJlbmRlckFy ZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqKSBjb25zdAogewogICAgIFJlbmRlckltYWdlKiBpbWFn ZSA9IG5ldyAoYXJlbmEpIFJlbmRlckltYWdlKGVsZW1lbnQoKSk7CmRpZmYgLS1naXQgYS9XZWJD b3JlL2h0bWwvSW1hZ2VJbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9JbWFnZUlucHV0VHlwZS5o CmluZGV4IGNkNzZlNzJmZDY2MThhY2Y0NjJhNmIwYjM4MjRmYjIzZGYwNWU3YTQuLjYxYWJmOWQw MGU2OWEzMGM5OWRlYmYzMDBiYTJiMWIyYTMxNDM2MTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRt bC9JbWFnZUlucHV0VHlwZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9JbWFnZUlucHV0VHlwZS5oCkBA IC0zMiw2ICszMiw3IEBACiAjZGVmaW5lIEltYWdlSW5wdXRUeXBlX2gKIAogI2luY2x1ZGUgIkJh c2VCdXR0b25JbnB1dFR5cGUuaCIKKyNpbmNsdWRlICJJbnRQb2ludC5oIgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKQEAgLTQ2LDYgKzQ3LDEwIEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBib29s IGFwcGVuZEZvcm1EYXRhKEZvcm1EYXRhTGlzdCYsIGJvb2wpIGNvbnN0OwogICAgIHZpcnR1YWwg Ym9vbCBzdXBwb3J0c1ZhbGlkYXRpb24oKSBjb25zdDsKICAgICB2aXJ0dWFsIFJlbmRlck9iamVj dCogY3JlYXRlUmVuZGVyZXIoUmVuZGVyQXJlbmEqLCBSZW5kZXJTdHlsZSopIGNvbnN0OworICAg IHZpcnR1YWwgYm9vbCBoYW5kbGVET01BY3RpdmF0ZUV2ZW50KEV2ZW50Kik7CisKKyAgICAvLyBU aGlzIGlzIHZhbGlkIG9ubHkgZHVyaW5nIEhUTUxGb3JtRWxlbWVudDo6cHJlcGFyZVN1Ym1pdCgp LgorICAgIEludFBvaW50IG1fY2xpY2tMb2NhdGlvbjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwIGIvV2ViQ29yZS9o dG1sL0lucHV0VHlwZS5jcHAKaW5kZXggYzBjYzM0Mjc5MGFjOTFlZTUyZTUyN2IzNWE4YjNjMThk ZjliZjhkNC4uMTQ4OTc0YzBhNGVlZGMwNDZjMzJhYThlMzQ2MzkxYWIxMGI5ODViZSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0lucHV0 VHlwZS5jcHAKQEAgLTI2OSw2ICsyNjksMjEgQEAgZG91YmxlIElucHV0VHlwZTo6YWNjZXB0YWJs ZUVycm9yKGRvdWJsZSkgY29uc3QKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBJbnB1dFR5cGU6 OmhhbmRsZUNsaWNrRXZlbnQoTW91c2VFdmVudCopCit7CisgICAgcmV0dXJuIGZhbHNlOworfQor Citib29sIElucHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVudChFdmVudCopCit7CisgICAg cmV0dXJuIGZhbHNlOworfQorCitib29sIElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtl eWJvYXJkRXZlbnQqKQoreworICAgIHJldHVybiBmYWxzZTsKK30KKwogUmVuZGVyT2JqZWN0KiBJ bnB1dFR5cGU6OmNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiwgUmVuZGVyU3R5bGUqIHN0eWxl KSBjb25zdAogewogICAgIHJldHVybiBSZW5kZXJPYmplY3Q6OmNyZWF0ZU9iamVjdChlbGVtZW50 KCksIHN0eWxlKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaCBiL1dlYkNv cmUvaHRtbC9JbnB1dFR5cGUuaAppbmRleCA3OGFhYjdjODFhNGRhNjgzYjE2NmM3OTFmY2Q3OTVi MTcxYjhjNzQ5Li45OWQ1NGRhMTkyNmU4OWMyZWFmNjc4MjhhMzM0MTE5YWEzNzM0ZWMwIDEwMDY0 NAotLS0gYS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL0lucHV0 VHlwZS5oCkBAIC0zOCw4ICszOCwxMSBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBE YXRlQ29tcG9uZW50czsKK2NsYXNzIEV2ZW50OwogY2xhc3MgRm9ybURhdGFMaXN0OwogY2xhc3Mg SFRNTElucHV0RWxlbWVudDsKK2NsYXNzIEtleWJvYXJkRXZlbnQ7CitjbGFzcyBNb3VzZUV2ZW50 OwogY2xhc3MgUmVuZGVyQXJlbmE7CiBjbGFzcyBSZW5kZXJPYmplY3Q7CiBjbGFzcyBSZW5kZXJT dHlsZTsKQEAgLTk3LDYgKzEwMCwxMyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIHNjYWxl ZFN0ZXBWYWxldVNob3VsZEJlSW50ZWdlcigpIGNvbnN0OwogICAgIHZpcnR1YWwgZG91YmxlIGFj Y2VwdGFibGVFcnJvcihkb3VibGUpIGNvbnN0OwogCisgICAgLy8gRXZlbnQgaGFuZGxlcnMKKyAg ICAvLyAgIFRoZSByZXR1cm4gdmFsdWUgbWVhbnMgInNob3VsZCByZXR1cm4gZnJvbSB0aGUgY2Fs bGVyIGV2ZW50IGhhbmRsZXIgaW1tZWRpYXRlbHkuIgorCisgICAgdmlydHVhbCBib29sIGhhbmRs ZUNsaWNrRXZlbnQoTW91c2VFdmVudCopOworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVET01BY3Rp dmF0ZUV2ZW50KEV2ZW50Kik7CisgICAgdmlydHVhbCBib29sIGhhbmRsZUtleWRvd25FdmVudChL ZXlib2FyZEV2ZW50Kik7CisKICAgICAvLyBNaXNjZWxsYW5lb3VzIGZ1bmN0aW9ucwogCiAgICAg dmlydHVhbCBSZW5kZXJPYmplY3QqIGNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiwgUmVuZGVy U3R5bGUqKSBjb25zdDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9OdW1iZXJJbnB1dFR5cGUu Y3BwIGIvV2ViQ29yZS9odG1sL051bWJlcklucHV0VHlwZS5jcHAKaW5kZXggN2E0ZDUwNDczYjdi NGJjYTY1YTliMGMxOTA3YWU3ZDE1MzE3ZjU3Yy4uZTI5MGU1MGUzMWQzZDgwYTJjMjkxMjk5MmM0 MmU4NzdiMmRiMDE0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL051bWJlcklucHV0VHlwZS5j cHAKKysrIGIvV2ViQ29yZS9odG1sL051bWJlcklucHV0VHlwZS5jcHAKQEAgLTE1NSw2ICsxNTUs MTEgQEAgZG91YmxlIE51bWJlcklucHV0VHlwZTo6c3RlcFNjYWxlRmFjdG9yKCkgY29uc3QKICAg ICByZXR1cm4gbnVtYmVyU3RlcFNjYWxlRmFjdG9yOwogfQogCitib29sIE51bWJlcklucHV0VHlw ZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqIGV2ZW50KQoreworICAgIHJldHVy biBoYW5kbGVLZXlkb3duRXZlbnRGb3JTcGluQnV0dG9uKGV2ZW50KSB8fCBUZXh0RmllbGRJbnB1 dFR5cGU6OmhhbmRsZUtleWRvd25FdmVudEZvclNwaW5CdXR0b24oZXZlbnQpOworfQorCiBkb3Vi bGUgTnVtYmVySW5wdXRUeXBlOjpwYXJzZVRvRG91YmxlKGNvbnN0IFN0cmluZyYgc3JjLCBkb3Vi bGUgZGVmYXVsdFZhbHVlKSBjb25zdAogewogICAgIGRvdWJsZSBudW1iZXJWYWx1ZTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaHRtbC9OdW1iZXJJbnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9OdW1i ZXJJbnB1dFR5cGUuaAppbmRleCAxZjBiODgxNGM3MTkzMDM4YzJmZGQyN2Q4ODkwNjU5ODYzZTRj MGMwLi5kYzZlMDIwNWFkZTQ5YzRmMWFiNzQzMDdhZDg1YzRlNzhkYTllYjQwIDEwMDY0NAotLS0g YS9XZWJDb3JlL2h0bWwvTnVtYmVySW5wdXRUeXBlLmgKKysrIGIvV2ViQ29yZS9odG1sL051bWJl cklucHV0VHlwZS5oCkBAIC01NSw2ICs1NSw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBkb3Vi bGUgc3RlcEJhc2VXaXRoRGVjaW1hbFBsYWNlcyh1bnNpZ25lZCopIGNvbnN0OwogICAgIHZpcnR1 YWwgZG91YmxlIGRlZmF1bHRTdGVwKCkgY29uc3Q7CiAgICAgdmlydHVhbCBkb3VibGUgc3RlcFNj YWxlRmFjdG9yKCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGhhbmRsZUtleWRvd25FdmVudChL ZXlib2FyZEV2ZW50Kik7CiAgICAgdmlydHVhbCBkb3VibGUgcGFyc2VUb0RvdWJsZShjb25zdCBT dHJpbmcmLCBkb3VibGUpIGNvbnN0OwogICAgIHZpcnR1YWwgZG91YmxlIHBhcnNlVG9Eb3VibGVX aXRoRGVjaW1hbFBsYWNlcyhjb25zdCBTdHJpbmcmLCBkb3VibGUsIHVuc2lnbmVkKikgY29uc3Q7 CiAgICAgdmlydHVhbCBTdHJpbmcgc2VyaWFsaXplKGRvdWJsZSkgY29uc3Q7CmRpZmYgLS1naXQg YS9XZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuY3BwIGIvV2ViQ29yZS9odG1sL1JhZGlvSW5w dXRUeXBlLmNwcAppbmRleCA1ZGY0YmJjNDRhMDQwNTIyYmM0NDkzN2RmNmUwMDZlNGU0NjQyYzg1 Li5hNmM0NzA3YmU1Yjg5YzVmMmYwNzAwYWY5NzU0NDA2Yzk4NTY4OTY4IDEwMDY0NAotLS0gYS9X ZWJDb3JlL2h0bWwvUmFkaW9JbnB1dFR5cGUuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9SYWRpb0lu cHV0VHlwZS5jcHAKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlICJSYWRpb0lucHV0VHlwZS5o IgogCiAjaW5jbHVkZSAiSFRNTElucHV0RWxlbWVudC5oIgorI2luY2x1ZGUgIk1vdXNlRXZlbnQu aCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBA IC01MSw0ICs1MiwxMCBAQCBib29sIFJhZGlvSW5wdXRUeXBlOjp2YWx1ZU1pc3NpbmcoY29uc3Qg U3RyaW5nJikgY29uc3QKICAgICByZXR1cm4gIWVsZW1lbnQoKS0+Y2hlY2tlZFJhZGlvQnV0dG9u cygpLmNoZWNrZWRCdXR0b25Gb3JHcm91cChlbGVtZW50KCktPm5hbWUoKSk7CiB9CiAKK2Jvb2wg UmFkaW9JbnB1dFR5cGU6OmhhbmRsZUNsaWNrRXZlbnQoTW91c2VFdmVudCogZXZlbnQpCit7Cisg ICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9SYWRpb0lucHV0 VHlwZS5oIGIvV2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmgKaW5kZXggOWU3YWIwMGRjZTJi OGE2NTI2Mjc4ZjQ2MTYzNDg1ODkxODAyMjk0ZS4uMjc5ODAxMGEwNDU3NDQ0YmRkZTYzY2NmYjE3 ZTQwYmZkMGJlYjZmMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmgK KysrIGIvV2ViQ29yZS9odG1sL1JhZGlvSW5wdXRUeXBlLmgKQEAgLTQzLDYgKzQzLDcgQEAgcHJp dmF0ZToKICAgICBSYWRpb0lucHV0VHlwZShIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KSA6IEJh c2VDaGVja2FibGVJbnB1dFR5cGUoZWxlbWVudCkgeyB9CiAgICAgdmlydHVhbCBjb25zdCBBdG9t aWNTdHJpbmcmIGZvcm1Db250cm9sVHlwZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCB2YWx1 ZU1pc3NpbmcoY29uc3QgU3RyaW5nJikgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGhhbmRsZUNs aWNrRXZlbnQoTW91c2VFdmVudCopOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9S YW5nZUlucHV0VHlwZS5jcHAKaW5kZXggMTc2ZDczYjUyMDI2YTcwZGMwNTI5YmNhNTRiZTkwOWU4 ZWQ2N2VmMS4uYWQ0N2YxNGNiMTRhOWQ4ODkxMmZjZGE2MmM4Zjk3Zjg4YWQzYmMxYyAxMDA2NDQK LS0tIGEvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcAorKysgYi9XZWJDb3JlL2h0bWwv UmFuZ2VJbnB1dFR5cGUuY3BwCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiSFRNTElucHV0 RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkhUTUxQYXJzZXJJ ZGlvbXMuaCIKKyNpbmNsdWRlICJLZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiUmVuZGVyU2xp ZGVyLmgiCiAjaW5jbHVkZSA8bGltaXRzPgogI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CkBA IC0xMjcsNiArMTI4LDQ2IEBAIGRvdWJsZSBSYW5nZUlucHV0VHlwZTo6c3RlcFNjYWxlRmFjdG9y KCkgY29uc3QKICAgICByZXR1cm4gcmFuZ2VTdGVwU2NhbGVGYWN0b3I7CiB9CiAKK2Jvb2wgUmFu Z2VJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50KiBldmVudCkKK3sK KyAgICBjb25zdCBTdHJpbmcmIGtleSA9IGV2ZW50LT5rZXlJZGVudGlmaWVyKCk7CisgICAgaWYg KGtleSAhPSAiVXAiICYmIGtleSAhPSAiUmlnaHQiICYmIGtleSAhPSAiRG93biIgJiYga2V5ICE9 ICJMZWZ0IikKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgRXhjZXB0aW9uQ29kZSBlYzsK KyAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UoZWxlbWVudCgpLT5mYXN0R2V0QXR0cmlidXRlKHN0 ZXBBdHRyKSwgImFueSIpKSB7CisgICAgICAgIGRvdWJsZSBtaW4gPSBtaW5pbXVtKCk7CisgICAg ICAgIGRvdWJsZSBtYXggPSBtYXhpbXVtKCk7CisgICAgICAgIC8vIEZJWE1FOiBXZSBjYW4ndCB1 c2Ugc3RlcFVwKCkgZm9yIHRoZSBzdGVwIHZhbHVlICJhbnkiLiBTbywgd2UgaW5jcmVhc2UKKyAg ICAgICAgLy8gb3IgZGVjcmVhc2UgdGhlIHZhbHVlIGJ5IDEvMTAwIG9mIHRoZSB2YWx1ZSByYW5n ZS4gSXMgaXQgcmVhc29uYWJsZT8KKyAgICAgICAgZG91YmxlIHN0ZXAgPSAobWF4IC0gbWluKSAv IDEwMDsKKyAgICAgICAgZG91YmxlIGN1cnJlbnQgPSBwYXJzZVRvRG91YmxlKGVsZW1lbnQoKS0+ dmFsdWUoKSwgbnVtZXJpY19saW1pdHM8ZG91YmxlPjo6cXVpZXRfTmFOKCkpOworICAgICAgICBB U1NFUlQoaXNmaW5pdGUoY3VycmVudCkpOworICAgICAgICBkb3VibGUgbmV3VmFsdWU7CisgICAg ICAgIGlmIChrZXkgPT0gIlVwIiB8fCBrZXkgPT0gIlJpZ2h0IikgeworICAgICAgICAgICAgbmV3 VmFsdWUgPSBjdXJyZW50ICsgc3RlcDsKKyAgICAgICAgICAgIGlmIChuZXdWYWx1ZSA+IG1heCkK KyAgICAgICAgICAgICAgICBuZXdWYWx1ZSA9IG1heDsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAg ICAgICAgIG5ld1ZhbHVlID0gY3VycmVudCAtIHN0ZXA7CisgICAgICAgICAgICBpZiAobmV3VmFs dWUgPCBtaW4pCisgICAgICAgICAgICAgICAgbmV3VmFsdWUgPSBtaW47CisgICAgICAgIH0KKyAg ICAgICAgaWYgKG5ld1ZhbHVlICE9IGN1cnJlbnQpIHsKKyAgICAgICAgICAgIHNldFZhbHVlQXNO dW1iZXIobmV3VmFsdWUsIGVjKTsKKyAgICAgICAgICAgIGVsZW1lbnQoKS0+ZGlzcGF0Y2hGb3Jt Q29udHJvbENoYW5nZUV2ZW50KCk7CisgICAgICAgIH0KKyAgICB9IGVsc2UgeworICAgICAgICBp bnQgc3RlcE1hZ25pZmljYXRpb24gPSAoa2V5ID09ICJVcCIgfHwga2V5ID09ICJSaWdodCIpID8g MSA6IC0xOworICAgICAgICBTdHJpbmcgbGFzdFN0cmluZ1ZhbHVlID0gZWxlbWVudCgpLT52YWx1 ZSgpOworICAgICAgICBlbGVtZW50KCktPnN0ZXBVcChzdGVwTWFnbmlmaWNhdGlvbiwgZWMpOwor ICAgICAgICBpZiAobGFzdFN0cmluZ1ZhbHVlICE9IGVsZW1lbnQoKS0+dmFsdWUoKSkKKyAgICAg ICAgICAgIGVsZW1lbnQoKS0+ZGlzcGF0Y2hGb3JtQ29udHJvbENoYW5nZUV2ZW50KCk7CisgICAg fQorICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOworICAgIHJldHVybiB0cnVlOworfQor CiBSZW5kZXJPYmplY3QqIFJhbmdlSW5wdXRUeXBlOjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVu YSogYXJlbmEsIFJlbmRlclN0eWxlKikgY29uc3QKIHsKICAgICByZXR1cm4gbmV3IChhcmVuYSkg UmVuZGVyU2xpZGVyKGVsZW1lbnQoKSk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvUmFuZ2VJ bnB1dFR5cGUuaCBiL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oCmluZGV4IDY0NTQ4ZjY3 MTE5ODRmNDRkZDg1OTFjOThjOWU0OTU3NGRlYzg0ZjEuLmMyYmJiMGZjMWQxMzJiMGY3OWI1ZDcx NGNkYjUxNWRkOWNlMzE1YTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlw ZS5oCisrKyBiL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oCkBAIC01Myw2ICs1Myw3IEBA IHByaXZhdGU6CiAgICAgdmlydHVhbCBkb3VibGUgc3RlcEJhc2UoKSBjb25zdDsKICAgICB2aXJ0 dWFsIGRvdWJsZSBkZWZhdWx0U3RlcCgpIGNvbnN0OwogICAgIHZpcnR1YWwgZG91YmxlIHN0ZXBT Y2FsZUZhY3RvcigpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVLZXlkb3duRXZlbnQo S2V5Ym9hcmRFdmVudCopOwogICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJl cihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKikgY29uc3Q7CiAgICAgdmlydHVhbCBkb3VibGUg cGFyc2VUb0RvdWJsZShjb25zdCBTdHJpbmcmLCBkb3VibGUpIGNvbnN0OwogICAgIHZpcnR1YWwg U3RyaW5nIHNlcmlhbGl6ZShkb3VibGUpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1s L1Jlc2V0SW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9SZXNldElucHV0VHlwZS5jcHAKaW5k ZXggMWRiNzU5MjU0YjE2M2NhZGVhYmRlMDJjYjZkYjBiZDdkZTJkZDQ4OC4uNzlmOGRiNDI1MDJi ZmZhYzgxZjA2OGJlZWNjYjg1OGNiYTAxMjE2YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1Jl c2V0SW5wdXRUeXBlLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvUmVzZXRJbnB1dFR5cGUuY3BwCkBA IC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiUmVzZXRJbnB1 dFR5cGUuaCIKIAorI2luY2x1ZGUgIkhUTUxJbnB1dEVsZW1lbnQuaCIKICNpbmNsdWRlIDx3dGYv UGFzc093blB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC01MCw0ICs1MSwxNCBAQCBi b29sIFJlc2V0SW5wdXRUeXBlOjpzdXBwb3J0c1ZhbGlkYXRpb24oKSBjb25zdAogICAgIHJldHVy biBmYWxzZTsKIH0KIAorYm9vbCBSZXNldElucHV0VHlwZTo6aGFuZGxlRE9NQWN0aXZhdGVFdmVu dChFdmVudCopCit7CisgICAgaWYgKGVsZW1lbnQoKS0+ZGlzYWJsZWQoKSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgIGlmICghZWxlbWVudCgpLT5mb3JtKCkpCisgICAgICAgIHJldHVybiB0 cnVlOworICAgIGVsZW1lbnQoKS0+Zm9ybSgpLT5yZXNldCgpOworICAgIHJldHVybiBmYWxzZTsK K30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL1Jl c2V0SW5wdXRUeXBlLmggYi9XZWJDb3JlL2h0bWwvUmVzZXRJbnB1dFR5cGUuaAppbmRleCBhZDk0 MGI0NGM2YTMyODI1MDY0YmYzM2I4YmQwZjkzMjA2YmI0YWRkLi4xNTNhZmFjMTkyY2Y3MmYzNTJl MDNhMDg5ZWNlYWRjYjgwOWEyMGZlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvUmVzZXRJbnB1 dFR5cGUuaAorKysgYi9XZWJDb3JlL2h0bWwvUmVzZXRJbnB1dFR5cGUuaApAQCAtNDMsNiArNDMs NyBAQCBwcml2YXRlOgogICAgIFJlc2V0SW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1l bnQpIDogQmFzZUJ1dHRvbklucHV0VHlwZShlbGVtZW50KSB7IH0KICAgICB2aXJ0dWFsIGNvbnN0 IEF0b21pY1N0cmluZyYgZm9ybUNvbnRyb2xUeXBlKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29s IHN1cHBvcnRzVmFsaWRhdGlvbigpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBoYW5kbGVET01B Y3RpdmF0ZUV2ZW50KEV2ZW50Kik7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYg LS1naXQgYS9XZWJDb3JlL2h0bWwvU3VibWl0SW5wdXRUeXBlLmNwcCBiL1dlYkNvcmUvaHRtbC9T dWJtaXRJbnB1dFR5cGUuY3BwCmluZGV4IDk5YzgwOGUxNGI1MGM2NTc5YmExNTg1NGQzNTQzMjhi ZDRiNzE1YzMuLjViMzc3OTNkY2MzN2M0ZTdkNTc4NTQzYzdmNGU3YWE4MjU1MDE1MjIgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1dFR5cGUuY3BwCisrKyBiL1dlYkNvcmUvaHRt bC9TdWJtaXRJbnB1dFR5cGUuY3BwCkBAIC02MCw0ICs2MCwxNyBAQCBib29sIFN1Ym1pdElucHV0 VHlwZTo6c3VwcG9ydHNWYWxpZGF0aW9uKCkgY29uc3QKICAgICByZXR1cm4gZmFsc2U7CiB9CiAK K2Jvb2wgU3VibWl0SW5wdXRUeXBlOjpoYW5kbGVET01BY3RpdmF0ZUV2ZW50KEV2ZW50KiBldmVu dCkKK3sKKyAgICBpZiAoZWxlbWVudCgpLT5kaXNhYmxlZCgpKQorICAgICAgICByZXR1cm4gZmFs c2U7CisgICAgaWYgKCFlbGVtZW50KCktPmZvcm0oKSkKKyAgICAgICAgcmV0dXJuIHRydWU7Cisg ICAgUmVmUHRyPEhUTUxJbnB1dEVsZW1lbnQ+IGlucHV0KGVsZW1lbnQoKSk7CisgICAgaW5wdXQt PnNldEFjdGl2YXRlZFN1Ym1pdCh0cnVlKTsKKyAgICBpbnB1dC0+Zm9ybSgpLT5wcmVwYXJlU3Vi bWl0KGV2ZW50KTsgLy8gSmF2YVNjcmlwdCBjb2RlIG1pZ2h0IHJ1bi4KKyAgICBpbnB1dC0+c2V0 QWN0aXZhdGVkU3VibWl0KGZhbHNlKTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1dFR5cGUu aCBiL1dlYkNvcmUvaHRtbC9TdWJtaXRJbnB1dFR5cGUuaAppbmRleCAyZmU3YWNlOTZjNTMwNTc4 MDIyZmI0ZDIzYTRlYzE4ZjkyN2IxZmNhLi5kMDMyMTljZTE5ZjNhODNkZmQwNjU0MDU2ZWQwMmY4 YjZkOTM0Mjg2IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvU3VibWl0SW5wdXRUeXBlLmgKKysr IGIvV2ViQ29yZS9odG1sL1N1Ym1pdElucHV0VHlwZS5oCkBAIC00NCw2ICs0NCw3IEBAIHByaXZh dGU6CiAgICAgdmlydHVhbCBjb25zdCBBdG9taWNTdHJpbmcmIGZvcm1Db250cm9sVHlwZSgpIGNv bnN0OwogICAgIHZpcnR1YWwgYm9vbCBhcHBlbmRGb3JtRGF0YShGb3JtRGF0YUxpc3QmLCBib29s KSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgc3VwcG9ydHNWYWxpZGF0aW9uKCkgY29uc3Q7Cisg ICAgdmlydHVhbCBib29sIGhhbmRsZURPTUFjdGl2YXRlRXZlbnQoRXZlbnQqKTsKIH07CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJ bnB1dFR5cGUuY3BwIGIvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAKaW5kZXgg OTI2ZDBhYzY3OTY2NzQ2NGRkNjgyNTZmNzNhMjA0Y2VlYzNiYWZiNC4uZDkzZjk3MjFmNTNlODI4 ZWQ4ZjkyZmMxNzhlMzRiNzRmM2M3OWFjOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1RleHRG aWVsZElucHV0VHlwZS5jcHAKKysrIGIvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5j cHAKQEAgLTMxLDcgKzMxLDkgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJUZXh0 RmllbGRJbnB1dFR5cGUuaCIKIAorI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiSFRNTElu cHV0RWxlbWVudC5oIgorI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJSZW5k ZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUuaCIKICNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcu aD4KIApAQCAtNDcsNiArNDksMzIgQEAgYm9vbCBUZXh0RmllbGRJbnB1dFR5cGU6OnZhbHVlTWlz c2luZyhjb25zdCBTdHJpbmcmIHZhbHVlKSBjb25zdAogICAgIHJldHVybiB2YWx1ZS5pc0VtcHR5 KCk7CiB9CiAKK2Jvb2wgVGV4dEZpZWxkSW5wdXRUeXBlOjpoYW5kbGVLZXlkb3duRXZlbnQoS2V5 Ym9hcmRFdmVudCogZXZlbnQpCit7CisgICAgaWYgKCFlbGVtZW50KCktPmZvY3VzZWQoKSkKKyAg ICAgICAgcmV0dXJuIGZhbHNlOworICAgIEZyYW1lKiBmcmFtZSA9IGVsZW1lbnQoKS0+ZG9jdW1l bnQoKS0+ZnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lIHx8ICFmcmFtZS0+ZWRpdG9yKCktPmRvVGV4 dEZpZWxkQ29tbWFuZEZyb21FdmVudChlbGVtZW50KCksIGV2ZW50KSkKKyAgICAgICAgcmV0dXJu IGZhbHNlOworICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOworICAgIHJldHVybiB0cnVl OworfQorCitib29sIFRleHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50Rm9yU3Bp bkJ1dHRvbihLZXlib2FyZEV2ZW50KiBldmVudCkKK3sKKyAgICBjb25zdCBTdHJpbmcmIGtleSA9 IGV2ZW50LT5rZXlJZGVudGlmaWVyKCk7CisgICAgaW50IHN0ZXAgPSAwOworICAgIGlmIChrZXkg PT0gIlVwIikKKyAgICAgICAgc3RlcCA9IDE7CisgICAgZWxzZSBpZiAoa2V5ID09ICJEb3duIikK KyAgICAgICAgc3RlcCA9IC0xOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IGVsZW1lbnQoKS0+c3RlcFVwRnJvbVJlbmRlcmVyKHN0ZXApOworICAgIGV2ZW50LT5zZXREZWZh dWx0SGFuZGxlZCgpOworICAgIHJldHVybiB0cnVlOworfQorCiBSZW5kZXJPYmplY3QqIFRleHRG aWVsZElucHV0VHlwZTo6Y3JlYXRlUmVuZGVyZXIoUmVuZGVyQXJlbmEqIGFyZW5hLCBSZW5kZXJT dHlsZSopIGNvbnN0CiB7CiAgICAgcmV0dXJuIG5ldyAoYXJlbmEpIFJlbmRlclRleHRDb250cm9s U2luZ2xlTGluZShlbGVtZW50KCksIGVsZW1lbnQoKS0+cGxhY2Vob2xkZXJTaG91bGRCZVZpc2li bGUoKSk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmggYi9X ZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmgKaW5kZXggNzhiZWMxZDU4ZTFhM2Y1YjJi OWNiMWEzMTUwOTI1ZWM3YmY0ZTk1NS4uNTA0MThhYWNkZjJiYjg4MjMwMjEyMmY1NWMxZmVkMTdk OGYzYjAyNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5oCisr KyBiL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaApAQCAtNDIsNiArNDIsOCBAQCBw cm90ZWN0ZWQ6CiAgICAgVGV4dEZpZWxkSW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1l bnQpIDogSW5wdXRUeXBlKGVsZW1lbnQpIHsgfQogICAgIHZpcnR1YWwgYm9vbCBpc1RleHRGaWVs ZCgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCB2YWx1ZU1pc3NpbmcoY29uc3QgU3RyaW5nJikg Y29uc3Q7CisgICAgdmlydHVhbCBib29sIGhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50 Kik7CisgICAgYm9vbCBoYW5kbGVLZXlkb3duRXZlbnRGb3JTcGluQnV0dG9uKEtleWJvYXJkRXZl bnQqKTsKICAgICB2aXJ0dWFsIFJlbmRlck9iamVjdCogY3JlYXRlUmVuZGVyZXIoUmVuZGVyQXJl bmEqLCBSZW5kZXJTdHlsZSopIGNvbnN0OwogfTsKIAo=