92640 2012-07-30 05:41:42 -0700 Slider should snap to datalist tick marks 2012-08-03 00:40:22 -0700 1 1 1 Unclassified WebKit Forms 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED WebExposed P2 Normal --- 93074 1 keishi keishi gustavo jbadics mifenton philn tkent webkit.review.bot xan.lopez yosin oldest_to_newest 681917 0 keishi 2012-07-30 05:41:42 -0700 Slider maybe should snap to datalist tick marks. 681925 1 keishi 2012-07-30 05:46:23 -0700 Here is a Mac build with snapping turned on so we can discuss whether we do this. https://docs.google.com/open?id=0BwRi59l_ri74ZUtkTHZuLUhKUTA 682916 2 155490 keishi 2012-07-31 04:35:35 -0700 Created attachment 155490 Patch 683010 3 155490 tkent 2012-07-31 07:17:29 -0700 Comment on attachment 155490 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=155490&action=review > Source/WebCore/html/shadow/SliderThumbElement.cpp:277 > +#if ENABLE(DATALIST_ELEMENT) We should have a new function for this code. > Source/WebCore/html/shadow/SliderThumbElement.cpp:283 > + for (unsigned i = 0; Node* node = options->item(i); i++) { Please follow an idiom; for (unsigned i = 0; i < options->length(); ++i) { Your current code disturbs code readers. BTW, this code is called whenever mousemove is dispatched during the thumb dragging, and this code is O(N). We should improve the complexity. > Source/WebCore/html/shadow/SliderThumbElement.cpp:285 > + ASSERT(node->hasTagName(optionTag)); > + HTMLOptionElement* optionElement = static_cast<HTMLOptionElement*>(node); We have toHTMLOptionElement(). > Source/WebCore/html/shadow/SliderThumbElement.cpp:306 > +&& closest.isFinite() && !closest.isNaN()) wrong indentation 683731 4 155490 yosin 2012-07-31 18:33:34 -0700 Comment on attachment 155490 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=155490&action=review > Source/WebCore/html/shadow/SliderThumbElement.cpp:287 > + if (!input->isValidValue(optionValue)) Do we need to use HTMLInputElement functions? Because of we have stepRange for input element. We can do as follows: const Decimal rawTickValue = parseToDecimalForNumberType(optionValue); if (!rawTickValue.isFinite()) continue; const Decimal tickValue = std::max(std::min(rawTickValue, stepRange.maximum()), stepRange.minimum()); > Source/WebCore/html/shadow/SliderThumbElement.cpp:291 > + if (difference > 0 && tickValue < closestRight) You can use Decimal::isPositive() and isNegative() functions instead of comparing to zero. > Source/WebCore/html/shadow/SliderThumbElement.cpp:292 > + closestRight = tickValue; We can write this if (difference.isPositive()) closestRight = std::min(closestRight, tickValue) else if (difference.isNegative()) closestLeft = std::max(closestLeft, tickValue) else closestLeft = closestRight = tickValue; > Source/WebCore/html/shadow/SliderThumbElement.cpp:301 > + double closestFraction = stepRange.proportionFromValue(closest).toDouble(); * Can we do decimal arithmetic instead of double arithmetic? * It is better to check closest.isFinite() and skip L301-L307 if !closest.isFinite(). We can see closest is ininity when !options.length(). >> Source/WebCore/html/shadow/SliderThumbElement.cpp:306 >> +&& closest.isFinite() && !closest.isNaN()) > > wrong indentation closes.isFinite() implies !closes.isNaN(). So, we don't need to have "&& !closes.isNan()". 683741 5 155490 yosin 2012-07-31 18:50:33 -0700 Comment on attachment 155490 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=155490&action=review >> Source/WebCore/html/shadow/SliderThumbElement.cpp:287 >> + if (!input->isValidValue(optionValue)) > > Do we need to use HTMLInputElement functions? Because of we have stepRange for input element. We can do as follows: > const Decimal rawTickValue = parseToDecimalForNumberType(optionValue); > if (!rawTickValue.isFinite()) > continue; > const Decimal tickValue = std::max(std::min(rawTickValue, stepRange.maximum()), stepRange.minimum()); Oops, tickValue should be sanitized, so we can do const Decimal originalTickValue = parseToDecimalForNumberType(optionValue, stepRange.defaultValue()); const Decimal tickValue = stepRange.clampValue(originalTickValue); 683770 6 155490 tkent 2012-07-31 19:30:48 -0700 Comment on attachment 155490 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=155490&action=review >>> Source/WebCore/html/shadow/SliderThumbElement.cpp:287 >>> + if (!input->isValidValue(optionValue)) >> >> Do we need to use HTMLInputElement functions? Because of we have stepRange for input element. We can do as follows: >> const Decimal rawTickValue = parseToDecimalForNumberType(optionValue); >> if (!rawTickValue.isFinite()) >> continue; >> const Decimal tickValue = std::max(std::min(rawTickValue, stepRange.maximum()), stepRange.minimum()); > > Oops, tickValue should be sanitized, so we can do > const Decimal originalTickValue = parseToDecimalForNumberType(optionValue, stepRange.defaultValue()); > const Decimal tickValue = stepRange.clampValue(originalTickValue); We should skip the step-mismatched values, and shouldn't alter the option value here. Skip the value with isValidValue() is ok. 684099 7 yosin 2012-08-01 05:22:31 -0700 (In reply to comment #6) > (From update of attachment 155490 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=155490&action=review > > >>> Source/WebCore/html/shadow/SliderThumbElement.cpp:287 > >>> + if (!input->isValidValue(optionValue)) > >> > >> Do we need to use HTMLInputElement functions? Because of we have stepRange for input element. We can do as follows: > >> const Decimal rawTickValue = parseToDecimalForNumberType(optionValue); > >> if (!rawTickValue.isFinite()) > >> continue; > >> const Decimal tickValue = std::max(std::min(rawTickValue, stepRange.maximum()), stepRange.minimum()); > > > > Oops, tickValue should be sanitized, so we can do > > const Decimal originalTickValue = parseToDecimalForNumberType(optionValue, stepRange.defaultValue()); > > const Decimal tickValue = stepRange.clampValue(originalTickValue); > > We should skip the step-mismatched values, and shouldn't alter the option value here. Skip the value with isValidValue() is ok. HTMLInputElement::isValidValue() creates StepRange class many times. How about adding bool StepRange::isValidValue(const Decimal&)? It can be bool StepRange::isValidalue(const Decimal& value) { if (!value.isFinite()) return false; if (value < m_minimum || value > m_maximum) return false; return value.remainder(m_step).isZero(); } 684884 8 155950 keishi 2012-08-01 19:09:30 -0700 Created attachment 155950 Patch 684892 9 keishi 2012-08-01 19:17:22 -0700 > HTMLInputElement::isValidValue() creates StepRange class many times. I tried to avoid this by moving the code into RangeInputType and doing the equivalent to isValidValue with one StepRange. 684894 10 155950 buildbot 2012-08-01 19:24:02 -0700 Comment on attachment 155950 Patch Attachment 155950 did not pass win-ews (win): Output: http://queues.webkit.org/results/13411697 684895 11 155950 buildbot 2012-08-01 19:24:08 -0700 Comment on attachment 155950 Patch Attachment 155950 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/13411695 684930 12 155950 tkent 2012-08-01 20:30:36 -0700 Comment on attachment 155950 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=155950&action=review > Source/WebCore/html/HTMLInputElement.cpp:320 > +Decimal HTMLInputElement::findClosestTickMarkValue(Decimal value) > +{ > + return m_inputType->findClosestTickMarkValue(value); > +} > + Please move it into the existing #if ENABLE(DATALIST_ELEMENT) block. > Source/WebCore/html/HTMLInputElement.h:77 > +#if ENABLE(DATALIST_ELEMENT) > + Decimal findClosestTickMarkValue(Decimal); > +#endif Please move the declaration into the existing #if ENABLE(DATALIST_ELEMENT) block. > Source/WebCore/html/RangeInputType.cpp:58 > +#if ENABLE(TOUCH_EVENTS) Maybe DATALIST_ELEMENT ? > Source/WebCore/html/RangeInputType.cpp:352 > + Vector<Decimal> tickValues; This is not used. > Source/WebCore/html/RangeInputType.cpp:366 > + String optionValue = optionElement->value(); > + if (typeMismatchFor(optionValue)) > + continue; > + Decimal rawOptionValue = parseToNumber(optionValue, Decimal::nan()); > + if (!rawOptionValue.isFinite() > + || stepRange.stepMismatch(rawOptionValue) > + || rawOptionValue < stepRange.minimum() > + || rawOptionValue > stepRange.maximum()) We should use HTMLInputElement::isValidValue() because - This is a duplication of HTMLInputElement::isValidValue(). It's hard to maintain both to be synchronized forever. - Now we have a cache of datalist values. The cost of StepRange creation is not important. If you'd like to improve the performance, you should improve isValidValue(). > Source/WebCore/html/RangeInputType.cpp:385 > + middle = (left + right) / 2; possible integer overflow. > Source/WebCore/html/RangeInputType.h:80 > #endif > + > + bool m_tickMarkValuesDirty; > + Vector<Decimal> m_tickMarkValues; They should be in #if ENABLE(DATALIST_ELEMENT) > Source/WebCore/html/shadow/SliderThumbElement.cpp:241 > > + > + this change is unnecessary. 685096 13 156004 keishi 2012-08-02 01:34:20 -0700 Created attachment 156004 Patch 685099 14 156004 yosin 2012-08-02 01:42:09 -0700 Comment on attachment 156004 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=156004&action=review > Source/WebCore/html/HTMLInputElement.cpp:317 > +Decimal HTMLInputElement::findClosestTickMarkValue(Decimal value) nit: Is it better to use const Decimal& as other functions which take Decimal? > Source/WebCore/html/RangeInputType.cpp:340 > +static bool decimalCompare(Decimal a, Decimal b) Please use "const Decimal&" to avoid copying Decimal objects. > Source/WebCore/html/RangeInputType.cpp:363 > + m_tickMarkValues.append(stepRange.clampValue(parseToNumber(optionValue, stepRange.defaultValue()))); We don't need to call StepRange::clampValue, because isValidValue is true. > Source/WebCore/html/RangeInputType.cpp:395 > + Decimal closestLeft = middle ? m_tickMarkValues[middle - 1] : Decimal::infinity(Decimal::Negative); nit: const Decimal > Source/WebCore/html/RangeInputType.cpp:396 > + Decimal closestRight = middle != m_tickMarkValues.size() ? m_tickMarkValues[middle] : Decimal::infinity(Decimal::Positive); nit: const Decimal > Source/WebCore/html/shadow/SliderThumbElement.cpp:278 > + Decimal closest = input->findClosestTickMarkValue(value); nit: const Decimal > Source/WebCore/html/shadow/SliderThumbElement.cpp:280 > + double closestFraction = stepRange.proportionFromValue(closest).toDouble(); Is it better to do in decimal arithmetic? Could you tell me why do we use double arithmetic? For speed? 685105 15 156004 tkent 2012-08-02 01:50:20 -0700 Comment on attachment 156004 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=156004&action=review > Source/WebCore/html/InputType.cpp:914 > + return Decimal::nan(); ASSERT_NOT_REACHED(). > Source/WebCore/html/RangeInputType.cpp:380 > + middle = (static_cast<long>(left) + static_cast<long>(right)) / 2; Still have possibility of integer overflow because sizeof(size_t) is usually same as sizeof(long). middle = left + (right - left) / 2; > LayoutTests/fast/forms/datalist/range-snap-to-datalist.html:66 > +<script> > + var input = document.getElementById("input"); > + var thumbWidth = 15; > + var halfThumbWidth = (thumbWidth - 1) / 2; > + function clickSlider(offsetLeft) { > + var centerY = input.offsetTop + input.offsetHeight / 2; > + eventSender.mouseMoveTo(input.offsetLeft + offsetLeft, centerY); > + eventSender.mouseDown(); > + eventSender.mouseUp(); > + } > + function resetSliderPosition() { > + clickSlider(0); > + shouldBe('input.value', '"0"'); > + } > + function expectedValueForPosition(pos) { > + clickSlider(pos); > + var value = Math.round((pos - halfThumbWidth - 0.5) / (input.offsetWidth - thumbWidth) * (input.max - input.min) + input.min); > + value = Math.max(Math.min(value, input.max), input.min); > + return value; > + } > + resetSliderPosition(); > + clickSlider(45); > + shouldBeTrue('parseInt(input.value, 10) < 500'); > + resetSliderPosition(); > + clickSlider(46); > + shouldBeTrue('parseInt(input.value, 10) < 500'); > + resetSliderPosition(); > + clickSlider(47); > + shouldBeTrue('parseInt(input.value, 10) < 500'); > + resetSliderPosition(); > + clickSlider(48); > + shouldBe('input.value', "'500'"); > + resetSliderPosition(); > + clickSlider(49); > + shouldBe('input.value', "'500'"); > + resetSliderPosition(); > + clickSlider(50); > + shouldBe('input.value', "'500'"); > + resetSliderPosition(); > + clickSlider(51); > + shouldBe('input.value', "'500'"); > + resetSliderPosition(); > + clickSlider(52); > + shouldBe('input.value', "'500'"); > + resetSliderPosition(); > + clickSlider(53); > + shouldBeTrue('parseInt(input.value, 10) > 500'); > + resetSliderPosition(); > + clickSlider(54); > + shouldBeTrue('parseInt(input.value, 10) > 500'); > + resetSliderPosition(); > + clickSlider(55); > + shouldBeTrue('parseInt(input.value, 10) > 500'); > +</script> nit: Indenting everything is not helpful. 685111 16 156004 tkent 2012-08-02 01:55:40 -0700 Comment on attachment 156004 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=156004&action=review > LayoutTests/fast/forms/datalist/range-snap-to-datalist.html:32 > + function expectedValueForPosition(pos) { > + clickSlider(pos); > + var value = Math.round((pos - halfThumbWidth - 0.5) / (input.offsetWidth - thumbWidth) * (input.max - input.min) + input.min); > + value = Math.max(Math.min(value, input.max), input.min); > + return value; > + } This function is not used. 685114 17 156010 keishi 2012-08-02 02:03:22 -0700 Created attachment 156010 Patch 685115 18 keishi 2012-08-02 02:05:40 -0700 > > Source/WebCore/html/shadow/SliderThumbElement.cpp:280 > > + double closestFraction = stepRange.proportionFromValue(closest).toDouble(); > > Is it better to do in decimal arithmetic? > Could you tell me why do we use double arithmetic? For speed? Should I use decimal arithmetic? My thinking was that Decimal precision is unnecessary and it would be slightly faster to use double. 685127 19 yosin 2012-08-02 02:15:57 -0700 (In reply to comment #15) > (From update of attachment 156004 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=156004&action=review > > > Source/WebCore/html/InputType.cpp:914 > > + return Decimal::nan(); > > ASSERT_NOT_REACHED(). > > > Source/WebCore/html/RangeInputType.cpp:380 > > + middle = (static_cast<long>(left) + static_cast<long>(right)) / 2; > > Still have possibility of integer overflow because sizeof(size_t) is usually same as sizeof(long). > > middle = left + (right - left) / 2; > It is impossible to have elements in Vector due by available memory. 685137 20 tkent 2012-08-02 02:21:40 -0700 (In reply to comment #19) > > Still have possibility of integer overflow because sizeof(size_t) is usually same as sizeof(long). > > > > middle = left + (right - left) / 2; > > > > It is impossible to have elements in Vector due by available memory. Right. However we should always write correct code because the code might be copied, and the copy might have integer overflow. 685138 21 156010 tkent 2012-08-02 02:23:47 -0700 Comment on attachment 156010 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=156010&action=review > Source/WebCore/html/RangeInputType.cpp:356 > + StepRange stepRange(createStepRange(RejectAny)); This StepRange looks unnecessary because parseToNumber call below never fails. 685141 22 yosin 2012-08-02 02:26:55 -0700 (In reply to comment #20) > (In reply to comment #19) > > > Still have possibility of integer overflow because sizeof(size_t) is usually same as sizeof(long). > > > > > > middle = left + (right - left) / 2; > > > > > > > It is impossible to have elements in Vector due by available memory. > > Right. However we should always write correct code because the code might be copied, and the copy might have integer overflow. Can we use binarySearch in WTF/wtf/StdLibExtras.h? http://trac.webkit.org/browser/trunk/Source/WTF/wtf/StdLibExtras.h 685144 23 keishi 2012-08-02 02:35:26 -0700 (In reply to comment #22) > (In reply to comment #20) > > (In reply to comment #19) > > > > Still have possibility of integer overflow because sizeof(size_t) is usually same as sizeof(long). > > > > > > > > middle = left + (right - left) / 2; > > > > > > > > > > It is impossible to have elements in Vector due by available memory. > > > > Right. However we should always write correct code because the code might be copied, and the copy might have integer overflow. > > Can we use binarySearch in WTF/wtf/StdLibExtras.h? > http://trac.webkit.org/browser/trunk/Source/WTF/wtf/StdLibExtras.h I guess its possible by creating a new class that represents the space between tick marks. And doing a binary search against that. 685147 24 yosin 2012-08-02 02:42:05 -0700 (In reply to comment #18) > > > Source/WebCore/html/shadow/SliderThumbElement.cpp:280 > > > + double closestFraction = stepRange.proportionFromValue(closest).toDouble(); > > > > Is it better to do in decimal arithmetic? > > Could you tell me why do we use double arithmetic? For speed? > > Should I use decimal arithmetic? My thinking was that Decimal precision is unnecessary and it would be slightly faster to use double. Agree, we don't need to use decimal arithmetic. However, it seems it is better to use LayoutUnit instead of double. Because postion and trackSize are LayoutUnit and closestPostion also can be LayoutUnit. 685161 25 tkent 2012-08-02 03:07:11 -0700 (In reply to comment #24) > (In reply to comment #18) > > > > Source/WebCore/html/shadow/SliderThumbElement.cpp:280 > > > > + double closestFraction = stepRange.proportionFromValue(closest).toDouble(); > > > > > > Is it better to do in decimal arithmetic? > > > Could you tell me why do we use double arithmetic? For speed? > > > > Should I use decimal arithmetic? My thinking was that Decimal precision is unnecessary and it would be slightly faster to use double. > > Agree, we don't need to use decimal arithmetic. > However, it seems it is better to use LayoutUnit instead of double. Because postion and trackSize are LayoutUnit and closestPostion also can be LayoutUnit. We shouldn't use LayoutUnit here. LayoutUnit is an alias of int if !ENABLE(SUBPIXEL_LAYOUT). 685169 26 tkent 2012-08-02 03:16:56 -0700 (In reply to comment #25) > > However, it seems it is better to use LayoutUnit instead of double. Because postion and trackSize are LayoutUnit and closestPostion also can be LayoutUnit. > > We shouldn't use LayoutUnit here. LayoutUnit is an alias of int if !ENABLE(SUBPIXEL_LAYOUT). We discussed offline. We had better make 'closestPosition' and 'snapThreashold' LayoutUnit because they are pixel lengths. 685183 27 156028 keishi 2012-08-02 03:36:49 -0700 Created attachment 156028 Patch 685186 28 156028 tkent 2012-08-02 03:45:38 -0700 Comment on attachment 156028 Patch ok 686123 29 156028 webkit.review.bot 2012-08-02 19:06:06 -0700 Comment on attachment 156028 Patch Clearing flags on attachment: 156028 Committed r124549: <http://trac.webkit.org/changeset/124549> 686124 30 webkit.review.bot 2012-08-02 19:06:12 -0700 All reviewed patches have been landed. Closing bug. 686312 31 jbadics 2012-08-03 00:40:22 -0700 Unfortunately the newly added test (fast/forms/datalist/range-snap-to-datalist.html) fails on Qt and EFL bots since r124549. I created a bug entry for the issue: https://bugs.webkit.org/show_bug.cgi?id=93074 Would you give it a look please? 155490 2012-07-31 04:35:35 -0700 2012-08-01 19:09:26 -0700 Patch bug-92640-20120731203518.patch text/plain 8557 keishi U3VidmVyc2lvbiBSZXZpc2lvbjogMTI0MTc2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTQ2ODM4M2Q3NjUzNTYz MjQzODk2YmFkNjZlZmExODgzMWE0MWQ5OC4uZmZmYTA5MmM5ZTY2ZjUzYTE5ZTg1MTU2ZmJhOTE1 NTUxMTY0MjEwYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA3LTMxICBLZWlz aGkgSGF0dG9yaSAgPGtlaXNoaUB3ZWJraXQub3JnPgorCisgICAgICAgIFNsaWRlciBzaG91bGQg c25hcCB0byBkYXRhbGlzdCB0aWNrIG1hcmtzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD05MjY0MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIElucHV0IHR5cGU9cmFuZ2Ugc2xpZGVyIHNuYXBzIHRvIGRhdGFs aXN0IHRpY2sgbWFya3MuCisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5n ZS1zbmFwLXRvLWRhdGFsaXN0Lmh0bWwKKworICAgICAgICAqIGh0bWwvc2hhZG93L1NsaWRlclRo dW1iRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlNs aWRlclRodW1iRWxlbWVudDo6c2V0UG9zaXRpb25Gcm9tUG9pbnQpOiBGaW5kIHRoZSBjbG9zZXN0 IHRpY2sgbWFyayBhbmQgaWYgaXQgaXMgY2xvc2UsIHNuYXAgdG8gdGhhdCB0aWNrIG1hcmsgdmFs dWUuCisKIDIwMTItMDctMzAgIEtlaXNoaSBIYXR0b3JpICA8a2Vpc2hpQHdlYmtpdC5vcmc+CiAK ICAgICAgICAgSW1wbGVtZW50IGRhdGFsaXN0IFVJIGZvciBpbnB1dCB0eXBlIGNvbG9yIGZvciBD aHJvbWl1bQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvU2xpZGVyVGh1 bWJFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1NsaWRlclRodW1iRWxl bWVudC5jcHAKaW5kZXggYjAyMGIzODI5OWU3NzVlNmQ4MWJmNjE1ZTcxOTZlZGU3MGJlYTgwMS4u OTc2OTY3OWRlOTcxYTBkY2MwYTE2NDk4NDg1ZDc5N2ViMjY0NmI3NyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvU2xpZGVyVGh1bWJFbGVtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQuY3BwCkBAIC00NywxMCAr NDcsMTcgQEAKICNpbmNsdWRlICJTdGVwUmFuZ2UuaCIKICNpbmNsdWRlIDx3dGYvTWF0aEV4dHJh cy5oPgogCisjaWYgRU5BQkxFKERBVEFMSVNUX0VMRU1FTlQpCisjaW5jbHVkZSAiSFRNTERhdGFM aXN0RWxlbWVudC5oIgorI2luY2x1ZGUgIkhUTUxPcHRpb25FbGVtZW50LmgiCisjZW5kaWYKKwog dXNpbmcgbmFtZXNwYWNlIHN0ZDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1l c3BhY2UgSFRNTE5hbWVzOworCiBpbmxpbmUgc3RhdGljIERlY2ltYWwgc2xpZGVyUG9zaXRpb24o SFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKIHsKICAgICBjb25zdCBTdGVwUmFuZ2Ugc3RlcFJh bmdlKGVsZW1lbnQtPmNyZWF0ZVN0ZXBSYW5nZShSZWplY3RBbnkpKTsKQEAgLTI2NSw3ICsyNzIs NDEgQEAgdm9pZCBTbGlkZXJUaHVtYkVsZW1lbnQ6OnNldFBvc2l0aW9uRnJvbVBvaW50KGNvbnN0 IExheW91dFBvaW50JiBwb2ludCkKICAgICBjb25zdCBEZWNpbWFsIHJhdGlvID0gRGVjaW1hbDo6 ZnJvbURvdWJsZShzdGF0aWNfY2FzdDxkb3VibGU+KHBvc2l0aW9uKSAvIHRyYWNrU2l6ZSk7CiAg ICAgY29uc3QgRGVjaW1hbCBmcmFjdGlvbiA9IGlzVmVydGljYWwgfHwgIXJlbmRlckJveCgpLT5z dHlsZSgpLT5pc0xlZnRUb1JpZ2h0RGlyZWN0aW9uKCkgPyBEZWNpbWFsKDEpIC0gcmF0aW8gOiBy YXRpbzsKICAgICBTdGVwUmFuZ2Ugc3RlcFJhbmdlKGlucHV0LT5jcmVhdGVTdGVwUmFuZ2UoUmVq ZWN0QW55KSk7Ci0gICAgY29uc3QgRGVjaW1hbCB2YWx1ZSA9IHN0ZXBSYW5nZS5jbGFtcFZhbHVl KHN0ZXBSYW5nZS52YWx1ZUZyb21Qcm9wb3J0aW9uKGZyYWN0aW9uKSk7CisgICAgRGVjaW1hbCB2 YWx1ZSA9IHN0ZXBSYW5nZS5jbGFtcFZhbHVlKHN0ZXBSYW5nZS52YWx1ZUZyb21Qcm9wb3J0aW9u KGZyYWN0aW9uKSk7CisKKyNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKKyAgICBIVE1MRGF0 YUxpc3RFbGVtZW50KiBkYXRhTGlzdCA9IGlucHV0LT5kYXRhTGlzdCgpOworICAgIGlmIChkYXRh TGlzdCkgeworICAgICAgICBEZWNpbWFsIGNsb3Nlc3RMZWZ0ID0gRGVjaW1hbDo6aW5maW5pdHko RGVjaW1hbDo6TmVnYXRpdmUpOworICAgICAgICBEZWNpbWFsIGNsb3Nlc3RSaWdodCA9IERlY2lt YWw6OmluZmluaXR5KERlY2ltYWw6OlBvc2l0aXZlKTsKKyAgICAgICAgUmVmUHRyPEhUTUxDb2xs ZWN0aW9uPiBvcHRpb25zID0gZGF0YUxpc3QtPm9wdGlvbnMoKTsKKyAgICAgICAgZm9yICh1bnNp Z25lZCBpID0gMDsgTm9kZSogbm9kZSA9IG9wdGlvbnMtPml0ZW0oaSk7IGkrKykgeworICAgICAg ICAgICAgQVNTRVJUKG5vZGUtPmhhc1RhZ05hbWUob3B0aW9uVGFnKSk7CisgICAgICAgICAgICBI VE1MT3B0aW9uRWxlbWVudCogb3B0aW9uRWxlbWVudCA9IHN0YXRpY19jYXN0PEhUTUxPcHRpb25F bGVtZW50Kj4obm9kZSk7CisgICAgICAgICAgICBTdHJpbmcgb3B0aW9uVmFsdWUgPSBvcHRpb25F bGVtZW50LT52YWx1ZSgpOworICAgICAgICAgICAgaWYgKCFpbnB1dC0+aXNWYWxpZFZhbHVlKG9w dGlvblZhbHVlKSkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIERlY2lt YWwgdGlja1ZhbHVlID0gcGFyc2VUb0RlY2ltYWxGb3JOdW1iZXJUeXBlKGlucHV0LT5zYW5pdGl6 ZVZhbHVlKG9wdGlvblZhbHVlKSk7CisgICAgICAgICAgICBEZWNpbWFsIGRpZmZlcmVuY2UgPSB0 aWNrVmFsdWUgLSB2YWx1ZTsKKyAgICAgICAgICAgIGlmIChkaWZmZXJlbmNlID4gMCAmJiB0aWNr VmFsdWUgPCBjbG9zZXN0UmlnaHQpCisgICAgICAgICAgICAgICAgY2xvc2VzdFJpZ2h0ID0gdGlj a1ZhbHVlOworICAgICAgICAgICAgZWxzZSBpZiAoZGlmZmVyZW5jZSA8IDAgJiYgdGlja1ZhbHVl ID4gY2xvc2VzdExlZnQpCisgICAgICAgICAgICAgICAgY2xvc2VzdExlZnQgPSB0aWNrVmFsdWU7 CisgICAgICAgIH0KKyAgICAgICAgRGVjaW1hbCBjbG9zZXN0OworICAgICAgICBpZiAoY2xvc2Vz dFJpZ2h0IC0gdmFsdWUgPCB2YWx1ZSAtIGNsb3Nlc3RMZWZ0KQorICAgICAgICAgICAgY2xvc2Vz dCA9IGNsb3Nlc3RSaWdodDsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgY2xvc2VzdCA9IGNs b3Nlc3RMZWZ0OworICAgICAgICBkb3VibGUgY2xvc2VzdEZyYWN0aW9uID0gc3RlcFJhbmdlLnBy b3BvcnRpb25Gcm9tVmFsdWUoY2xvc2VzdCkudG9Eb3VibGUoKTsKKyAgICAgICAgZG91YmxlIGNs b3Nlc3RSYXRpbyA9IGlzVmVydGljYWwgfHwgIXJlbmRlckJveCgpLT5zdHlsZSgpLT5pc0xlZnRU b1JpZ2h0RGlyZWN0aW9uKCkgPyAxLjAgLSBjbG9zZXN0RnJhY3Rpb24gOiBjbG9zZXN0RnJhY3Rp b247CisgICAgICAgIGRvdWJsZSBjbG9zZXN0UG9zaXRpb24gPSB0cmFja1NpemUgKiBjbG9zZXN0 UmF0aW87CisgICAgICAgIGNvbnN0IGludCBzbmFwVGhyZXNob2xkID0gMzsKKyAgICAgICAgaWYg KGFicyhjbG9zZXN0UG9zaXRpb24gLSBzdGF0aWNfY2FzdDxkb3VibGU+KHBvc2l0aW9uKSkgPCBz bmFwVGhyZXNob2xkCismJiBjbG9zZXN0LmlzRmluaXRlKCkgJiYgIWNsb3Nlc3QuaXNOYU4oKSkK KyAgICAgICAgICAgIHZhbHVlID0gc3RlcFJhbmdlLmNsYW1wVmFsdWUoY2xvc2VzdCk7CisgICAg fQorI2VuZGlmCiAKICAgICAvLyBGSVhNRTogVGhpcyBpcyBubyBsb25nZXIgYmVpbmcgc2V0IGZy b20gcmVuZGVyZXIuIENvbnNpZGVyIHVwZGF0aW5nIHRoZSBtZXRob2QgbmFtZS4KICAgICBpbnB1 dC0+c2V0VmFsdWVGcm9tUmVuZGVyZXIoc2VyaWFsaXplRm9yTnVtYmVyVHlwZSh2YWx1ZSkpOwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CmluZGV4IDYwMWU1NGI0YTc1YmNlMWM1OWNkMTU4MjYwN2RkY2MzMjNmMmUzMTMuLjJmNzFiZTI5 NjgxMzU2N2VkOTYwOTA1OTJhZWFlMjQ5OWJiZTY0NzcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAor MjAxMi0wNy0zMSAgS2Vpc2hpIEhhdHRvcmkgIDxrZWlzaGlAd2Via2l0Lm9yZz4KKworICAgICAg ICBTbGlkZXIgc2hvdWxkIHNuYXAgdG8gZGF0YWxpc3QgdGljayBtYXJrcworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTI2NDAKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvZm9ybXMvZGF0YWxpc3Qv cmFuZ2Utc25hcC10by1kYXRhbGlzdC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZh c3QvZm9ybXMvZGF0YWxpc3QvcmFuZ2Utc25hcC10by1kYXRhbGlzdC5odG1sOiBBZGRlZC4KKwog MjAxMi0wNy0zMCAgS2Vpc2hpIEhhdHRvcmkgIDxrZWlzaGlAd2Via2l0Lm9yZz4KIAogICAgICAg ICBJbXBsZW1lbnQgZGF0YWxpc3QgVUkgZm9yIGlucHV0IHR5cGUgY29sb3IgZm9yIENocm9taXVt CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAt dG8tZGF0YWxpc3QtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlz dC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMzVhOGUy YzJkMTY0MjIzMmMwZGY5NTFhM2IzNTZlZjlhOWMyNjA5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0LWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDI4IEBACitUZXN0cyBpZiBjbGlja2luZyBjbG9zZSB0byBhIHRp Y2sgbWFyayBzbmFwcyB0byBpdC4KKworUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgcGFy c2VJbnQoaW5wdXQudmFsdWUsIDEwKSA8IDUwMCBpcyB0cnVlCitQQVNTIGlucHV0LnZhbHVlIGlz ICIwIgorUEFTUyBwYXJzZUludChpbnB1dC52YWx1ZSwgMTApIDwgNTAwIGlzIHRydWUKK1BBU1Mg aW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIHBhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPCA1MDAg aXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgaW5wdXQudmFsdWUgaXMgJzUw MCcKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIGlucHV0LnZhbHVlIGlzICc1MDAnCitQ QVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBpbnB1dC52YWx1ZSBpcyAnNTAwJworUEFTUyBp bnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgaW5wdXQudmFsdWUgaXMgJzUwMCcKK1BBU1MgaW5wdXQu dmFsdWUgaXMgIjAiCitQQVNTIGlucHV0LnZhbHVlIGlzICc1MDAnCitQQVNTIGlucHV0LnZhbHVl IGlzICIwIgorUEFTUyBwYXJzZUludChpbnB1dC52YWx1ZSwgMTApID4gNTAwIGlzIHRydWUKK1BB U1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIHBhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPiA1 MDAgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgcGFyc2VJbnQoaW5wdXQu dmFsdWUsIDEwKSA+IDUwMCBpcyB0cnVlCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVl CisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9k YXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zv cm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iYWJm ZWMxOWFhZTNlMmE3MzMwN2RkY2Y4YmYzNGY2MDJlMjUzNDc4Ci0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0Lmh0 bWwKQEAgLTAsMCArMSw3MCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPHNj cmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8 L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+VGVzdHMgaWYgY2xpY2tpbmcgY2xv c2UgdG8gYSB0aWNrIG1hcmsgc25hcHMgdG8gaXQuPC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9k aXY+Cis8aW5wdXQgaWQ9ImlucHV0IiB0eXBlPXJhbmdlIG1pbj0wIG1heD0xMDAwIHN0ZXA9MSBs aXN0PXRhcmdldCBzdHlsZT0id2lkdGg6IDEwMHB4Ij4KKzxkYXRhbGlzdCBpZD0idGFyZ2V0Ij4K KyAgICA8b3B0aW9uPjUwMDwvb3B0aW9uPgorPC9kYXRhbGlzdD4KKzxzY3JpcHQ+CisgICAgdmFy IGlucHV0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImlucHV0Iik7CisgICAgdmFyIHRodW1i V2lkdGggPSAxNTsKKyAgICB2YXIgaGFsZlRodW1iV2lkdGggPSAodGh1bWJXaWR0aCAtIDEpIC8g MjsKKyAgICBmdW5jdGlvbiBjbGlja1NsaWRlcihvZmZzZXRMZWZ0KSB7CisgICAgICAgIHZhciBj ZW50ZXJZID0gaW5wdXQub2Zmc2V0VG9wICsgaW5wdXQub2Zmc2V0SGVpZ2h0IC8gMjsKKyAgICAg ICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oaW5wdXQub2Zmc2V0TGVmdCArIG9mZnNldExlZnQs IGNlbnRlclkpOworICAgICAgICBldmVudFNlbmRlci5tb3VzZURvd24oKTsKKyAgICAgICAgZXZl bnRTZW5kZXIubW91c2VVcCgpOworICAgIH0KKyAgICBmdW5jdGlvbiByZXNldFNsaWRlclBvc2l0 aW9uKCkgeworICAgICAgICBjbGlja1NsaWRlcigwKTsKKyAgICAgICAgc2hvdWxkQmUoJ2lucHV0 LnZhbHVlJywgJyIwIicpOworICAgIH0KKyAgICBmdW5jdGlvbiBleHBlY3RlZFZhbHVlRm9yUG9z aXRpb24ocG9zKSB7CisgICAgICAgIGNsaWNrU2xpZGVyKHBvcyk7CisgICAgICAgIHZhciB2YWx1 ZSA9IE1hdGgucm91bmQoKHBvcyAtIGhhbGZUaHVtYldpZHRoIC0gMC41KSAvIChpbnB1dC5vZmZz ZXRXaWR0aCAtIHRodW1iV2lkdGgpICogKGlucHV0Lm1heCAtIGlucHV0Lm1pbikgKyBpbnB1dC5t aW4pOworICAgICAgICB2YWx1ZSA9IE1hdGgubWF4KE1hdGgubWluKHZhbHVlLCBpbnB1dC5tYXgp LCBpbnB1dC5taW4pOworICAgICAgICByZXR1cm4gdmFsdWU7CisgICAgfQorICAgIHJlc2V0U2xp ZGVyUG9zaXRpb24oKTsKKyAgICBjbGlja1NsaWRlcig0NSk7CisgICAgc2hvdWxkQmVUcnVlKCdw YXJzZUludChpbnB1dC52YWx1ZSwgMTApIDwgNTAwJyk7CisgICAgcmVzZXRTbGlkZXJQb3NpdGlv bigpOworICAgIGNsaWNrU2xpZGVyKDQ2KTsKKyAgICBzaG91bGRCZVRydWUoJ3BhcnNlSW50KGlu cHV0LnZhbHVlLCAxMCkgPCA1MDAnKTsKKyAgICByZXNldFNsaWRlclBvc2l0aW9uKCk7CisgICAg Y2xpY2tTbGlkZXIoNDcpOworICAgIHNob3VsZEJlVHJ1ZSgncGFyc2VJbnQoaW5wdXQudmFsdWUs IDEwKSA8IDUwMCcpOworICAgIHJlc2V0U2xpZGVyUG9zaXRpb24oKTsKKyAgICBjbGlja1NsaWRl cig0OCk7CisgICAgc2hvdWxkQmUoJ2lucHV0LnZhbHVlJywgIic1MDAnIik7CisgICAgcmVzZXRT bGlkZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVyKDQ5KTsKKyAgICBzaG91bGRCZSgnaW5w dXQudmFsdWUnLCAiJzUwMCciKTsKKyAgICByZXNldFNsaWRlclBvc2l0aW9uKCk7CisgICAgY2xp Y2tTbGlkZXIoNTApOworICAgIHNob3VsZEJlKCdpbnB1dC52YWx1ZScsICInNTAwJyIpOworICAg IHJlc2V0U2xpZGVyUG9zaXRpb24oKTsKKyAgICBjbGlja1NsaWRlcig1MSk7CisgICAgc2hvdWxk QmUoJ2lucHV0LnZhbHVlJywgIic1MDAnIik7CisgICAgcmVzZXRTbGlkZXJQb3NpdGlvbigpOwor ICAgIGNsaWNrU2xpZGVyKDUyKTsKKyAgICBzaG91bGRCZSgnaW5wdXQudmFsdWUnLCAiJzUwMCci KTsKKyAgICByZXNldFNsaWRlclBvc2l0aW9uKCk7CisgICAgY2xpY2tTbGlkZXIoNTMpOworICAg IHNob3VsZEJlVHJ1ZSgncGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+IDUwMCcpOworICAgIHJl c2V0U2xpZGVyUG9zaXRpb24oKTsKKyAgICBjbGlja1NsaWRlcig1NCk7CisgICAgc2hvdWxkQmVU cnVlKCdwYXJzZUludChpbnB1dC52YWx1ZSwgMTApID4gNTAwJyk7CisgICAgcmVzZXRTbGlkZXJQ b3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVyKDU1KTsKKyAgICBzaG91bGRCZVRydWUoJ3BhcnNl SW50KGlucHV0LnZhbHVlLCAxMCkgPiA1MDAnKTsKKzwvc2NyaXB0PgorCis8c2NyaXB0IHNyYz0i Li4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8 L2h0bWw+Cg== 155950 2012-08-01 19:09:30 -0700 2012-08-02 01:34:15 -0700 Patch bug-92640-20120802110912.patch text/plain 15503 keishi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA3ZjJlODU3ZDhlNDQwNjNhNjkxZGY3MTk5M2Y2NzdkMjM4MWM3ODc0Li4w NDFiNTY4Y2EyODNkMDAyNTEwYzE5NTMxNzkxYmMzZGI1YzI4MDk2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzcgQEAKKzIwMTItMDgtMDEgIEtlaXNoaSBIYXR0b3JpICA8a2Vpc2hpQHdlYmtpdC5v cmc+CisKKyAgICAgICAgU2xpZGVyIHNob3VsZCBzbmFwIHRvIGRhdGFsaXN0IHRpY2sgbWFya3MK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkyNjQwCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkaXRpb25h bCBpbmZvcm1hdGlvbiBvZiB0aGUgY2hhbmdlIHN1Y2ggYXMgYXBwcm9hY2gsIHJhdGlvbmFsZS4g UGxlYXNlIGFkZCBwZXItZnVuY3Rpb24gZGVzY3JpcHRpb25zIGJlbG93IChPT1BTISkuCisKKyAg ICAgICAgVGVzdDogZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0Lmh0 bWwKKworICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpIVE1MSW5wdXRFbGVtZW50OjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUpOiBKdXN0IGNh bGxzIElucHV0VHlwZTo6ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlLgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgIChIVE1MSW5w dXRFbGVtZW50KToKKyAgICAgICAgKiBodG1sL0lucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OklucHV0VHlwZTo6ZmluZENsb3Nlc3RUaWNrTWFya1Zh bHVlKTogT3ZlcnJpZGRlbiBieSBSYW5nZUlucHV0VHlwZS4KKyAgICAgICAgKiBodG1sL0lucHV0 VHlwZS5oOgorICAgICAgICAoSW5wdXRUeXBlKToKKyAgICAgICAgKiBodG1sL1JhbmdlSW5wdXRU eXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJhbmdlSW5wdXRUeXBlOjpSYW5nZUlucHV0VHlw ZSk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJhbmdlSW5wdXRUeXBl OjpsaXN0QXR0cmlidXRlVGFyZ2V0Q2hhbmdlZCk6IE1hcmsgbV90aWNrTWFya1ZhbHVlcyBhcyBk aXJ0eS4KKyAgICAgICAgKFdlYkNvcmU6OmRlY2ltYWxDb21wYXJlKToKKyAgICAgICAgKFdlYkNv cmU6OlJhbmdlSW5wdXRUeXBlOjp1cGRhdGVUaWNrTWFya1ZhbHVlcyk6IFNldHMgbV90aWNrTWFy a1ZhbHVlcyB0byBhIGxpc3Qgb2Ygc29ydGVkIHZhbGlkIGRhdGFsaXN0IHZhbHVlcy4KKyAgICAg ICAgKFdlYkNvcmU6OlJhbmdlSW5wdXRUeXBlOjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUpOiBG aW5kcyBjbG9zZXN0IHRpY2sgbWFyayB2YWx1ZSB0byBhIGdpdmVuIHZhbHVlLgorICAgICAgICAq IGh0bWwvUmFuZ2VJbnB1dFR5cGUuaDoKKyAgICAgICAgKFJhbmdlSW5wdXRUeXBlKToKKyAgICAg ICAgKiBodG1sL3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgIChXZWJDb3JlOjpTbGlkZXJUaHVtYkVsZW1lbnQ6OnNldFBvc2l0aW9uRnJv bVBvaW50KTogU25hcHMgdG8gdGhlIGNsb3Nlc3QgdGljayBtYXJrIHZhbHVlIGlmIGl0IGlzIHdp dGhpbiBhIGNlcnRhaW4gZGlzdGFuY2UuCisKIDIwMTItMDgtMDEgIEt3YW5nIFl1bCBTZW8gIDxz a3l1bEBjb21wYW55MTAwLm5ldD4KIAogICAgICAgICBNYWtlIEhUTUxDb25zdHJ1Y3Rpb25TaXRl OjpjcmVhdGVIVE1MRWxlbWVudChBdG9taWNIVE1MVG9rZW4qKSBwcml2YXRlLgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKaW5kZXggMjE2ZDE3MjlmNDBkNTAyZTlhZjc3 NmZkZDBlOWNlNzdiMjUzOWJmNS4uMWZmNzI4OTQ0YzEyMDc0OGU2Njk4Y2U3N2U3ODgwNzBmMTEz YTFiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC0zMTMs NiArMzEzLDExIEBAIFN0ZXBSYW5nZSBIVE1MSW5wdXRFbGVtZW50OjpjcmVhdGVTdGVwUmFuZ2Uo QW55U3RlcEhhbmRsaW5nIGFueVN0ZXBIYW5kbGluZykgY29uCiAgICAgcmV0dXJuIG1faW5wdXRU eXBlLT5jcmVhdGVTdGVwUmFuZ2UoYW55U3RlcEhhbmRsaW5nKTsKIH0KIAorRGVjaW1hbCBIVE1M SW5wdXRFbGVtZW50OjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUoRGVjaW1hbCB2YWx1ZSkKK3sK KyAgICByZXR1cm4gbV9pbnB1dFR5cGUtPmZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZSh2YWx1ZSk7 Cit9CisKIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c3RlcFVwKGludCBuLCBFeGNlcHRpb25Db2Rl JiBlYykKIHsKICAgICBtX2lucHV0VHlwZS0+c3RlcFVwKG4sIGVjKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXggYmE1NDYwNDM1YTFkYzI1OTFmYmVlYmM1ZDg4Y2Jl ZGE5ZTlhYjY4ZC4uODJjOTkyYzFhOThkMzI4MDJjMWQ4M2I4Njg0NjdmMDdiZmRiZDQwZiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKQEAgLTcyLDYgKzcyLDEwIEBAIHB1 YmxpYzoKICAgICBib29sIGdldEFsbG93ZWRWYWx1ZVN0ZXAoRGVjaW1hbCopIGNvbnN0OwogICAg IFN0ZXBSYW5nZSBjcmVhdGVTdGVwUmFuZ2UoQW55U3RlcEhhbmRsaW5nKSBjb25zdDsKIAorI2lm IEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQorICAgIERlY2ltYWwgZmluZENsb3Nlc3RUaWNrTWFy a1ZhbHVlKERlY2ltYWwpOworI2VuZGlmCisKICAgICAvLyBJbXBsZW1lbnRhdGlvbnMgb2YgSFRN TElucHV0RWxlbWVudDo6c3RlcFVwKCkgYW5kIHN0ZXBEb3duKCkuCiAgICAgdm9pZCBzdGVwVXAo aW50LCBFeGNlcHRpb25Db2RlJik7CiAgICAgdm9pZCBzdGVwRG93bihpbnQsIEV4Y2VwdGlvbkNv ZGUmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNwcAppbmRleCAwOWE4OTViNTAyODljNWFhMWUy MjlmN2Y0ZDU4MzI1NzZlMTk4NGQyLi45YzJiNGUyNGM0OGVhZWI4ZDk3MGE1ZmJiZTM0OWE0ODY4 ZThlOGU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCkBAIC05MDgsNiArOTA4LDExIEBA IFN0cmluZyBJbnB1dFR5cGU6OmRlZmF1bHRUb29sVGlwKCkgY29uc3QKIHZvaWQgSW5wdXRUeXBl OjpsaXN0QXR0cmlidXRlVGFyZ2V0Q2hhbmdlZCgpCiB7CiB9CisKK0RlY2ltYWwgSW5wdXRUeXBl OjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUoRGVjaW1hbCkKK3sKKyAgICByZXR1cm4gRGVjaW1h bDo6bmFuKCk7Cit9CiAjZW5kaWYKIAogYm9vbCBJbnB1dFR5cGU6OnN1cHBvcnRzSW5kZXRlcm1p bmF0ZUFwcGVhcmFuY2UoKSBjb25zdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9J bnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKaW5kZXggMDI0NWJh ODg4MGIzZjA3MWM2MTU5YmJiZGE4YWYzNWIyZWIwMGRjNi4uYTEyYzc0MGU0M2VhYTVhMDVkYTA5 MDFkMzU5MDMzMDhjZDdhN2JkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1 dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5oCkBAIC0yODEsNiAr MjgxLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgU3RyaW5nIGRlZmF1bHRUb29sVGlwKCkgY29u c3Q7CiAjaWYgRU5BQkxFKERBVEFMSVNUX0VMRU1FTlQpCiAgICAgdmlydHVhbCB2b2lkIGxpc3RB dHRyaWJ1dGVUYXJnZXRDaGFuZ2VkKCk7CisgICAgdmlydHVhbCBEZWNpbWFsIGZpbmRDbG9zZXN0 VGlja01hcmtWYWx1ZShEZWNpbWFsKTsKICNlbmRpZgogCiAgICAgLy8gUGFyc2VzIHRoZSBzcGVj aWZpZWQgc3RyaW5nIGZvciB0aGUgdHlwZSwgYW5kIHJldHVybgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1Jh bmdlSW5wdXRUeXBlLmNwcAppbmRleCA5MDFhOWFjYzFiMzdkNWYwNTYwNGY5MDM1MDE3ZTk5NGJj NWJiNDViLi42NmFlOTdlZWUyZjA0YzA3MDU2MmNhNjI5MjE3MThkMWJmZTEwNGI3IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcApAQCAtNTUsNiArNTUsMTIgQEAKICNpbmNs dWRlICJUb3VjaExpc3QuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKKyNp bmNsdWRlICJIVE1MRGF0YUxpc3RFbGVtZW50LmgiCisjaW5jbHVkZSAiSFRNTE9wdGlvbkVsZW1l bnQuaCIKKyNpbmNsdWRlIDx3dGYvTm9uQ29weWluZ1NvcnQuaD4KKyNlbmRpZgorCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKIHVzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CkBAIC03Niw2ICs4Miwx MiBAQCBQYXNzT3duUHRyPElucHV0VHlwZT4gUmFuZ2VJbnB1dFR5cGU6OmNyZWF0ZShIVE1MSW5w dXRFbGVtZW50KiBlbGVtZW50KQogICAgIHJldHVybiBhZG9wdFB0cihuZXcgUmFuZ2VJbnB1dFR5 cGUoZWxlbWVudCkpOwogfQogCitSYW5nZUlucHV0VHlwZTo6UmFuZ2VJbnB1dFR5cGUoSFRNTElu cHV0RWxlbWVudCogZWxlbWVudCkKKyAgICA6IElucHV0VHlwZShlbGVtZW50KQorICAgICwgbV90 aWNrTWFya1ZhbHVlc0RpcnR5KHRydWUpCit7Cit9CisKIGJvb2wgUmFuZ2VJbnB1dFR5cGU6Omlz UmFuZ2VDb250cm9sKCkgY29uc3QKIHsKICAgICByZXR1cm4gdHJ1ZTsKQEAgLTMxOCw5ICszMzAs NzkgQEAgSFRNTEVsZW1lbnQqIFJhbmdlSW5wdXRUeXBlOjpzbGlkZXJUaHVtYkVsZW1lbnQoKSBj b25zdAogCiAjaWYgRU5BQkxFKERBVEFMSVNUX0VMRU1FTlQpCiB2b2lkIFJhbmdlSW5wdXRUeXBl OjpsaXN0QXR0cmlidXRlVGFyZ2V0Q2hhbmdlZCgpCi17Cit7ICAgIAorICAgIG1fdGlja01hcmtW YWx1ZXNEaXJ0eSA9IHRydWU7CiAgICAgZWxlbWVudCgpLT5zZXROZWVkc1N0eWxlUmVjYWxjKCk7 CiB9CisKK3N0YXRpYyBib29sIGRlY2ltYWxDb21wYXJlKERlY2ltYWwgYSwgRGVjaW1hbCBiKQor eworICAgIHJldHVybiBhIDwgYjsKK30KKwordm9pZCBSYW5nZUlucHV0VHlwZTo6dXBkYXRlVGlj a01hcmtWYWx1ZXMoKQoreworICAgIGlmICghbV90aWNrTWFya1ZhbHVlc0RpcnR5KQorICAgICAg ICByZXR1cm47CisgICAgbV90aWNrTWFya1ZhbHVlcy5jbGVhcigpOworICAgIG1fdGlja01hcmtW YWx1ZXNEaXJ0eSA9IGZhbHNlOworICAgIEhUTUxEYXRhTGlzdEVsZW1lbnQqIGRhdGFMaXN0ID0g ZWxlbWVudCgpLT5kYXRhTGlzdCgpOworICAgIGlmICghZGF0YUxpc3QpCisgICAgICAgIHJldHVy bjsKKyAgICBWZWN0b3I8RGVjaW1hbD4gdGlja1ZhbHVlczsKKyAgICBSZWZQdHI8SFRNTENvbGxl Y3Rpb24+IG9wdGlvbnMgPSBkYXRhTGlzdC0+b3B0aW9ucygpOworICAgIG1fdGlja01hcmtWYWx1 ZXMucmVzZXJ2ZUNhcGFjaXR5KG9wdGlvbnMtPmxlbmd0aCgpKTsKKyAgICBTdGVwUmFuZ2Ugc3Rl cFJhbmdlKGNyZWF0ZVN0ZXBSYW5nZShSZWplY3RBbnkpKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkg PSAwOyBpIDwgb3B0aW9ucy0+bGVuZ3RoKCk7ICsraSkgeworICAgICAgICBOb2RlKiBub2RlID0g b3B0aW9ucy0+aXRlbShpKTsKKyAgICAgICAgSFRNTE9wdGlvbkVsZW1lbnQqIG9wdGlvbkVsZW1l bnQgPSB0b0hUTUxPcHRpb25FbGVtZW50KG5vZGUpOworICAgICAgICBTdHJpbmcgb3B0aW9uVmFs dWUgPSBvcHRpb25FbGVtZW50LT52YWx1ZSgpOworICAgICAgICBpZiAodHlwZU1pc21hdGNoRm9y KG9wdGlvblZhbHVlKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICBEZWNpbWFsIHJh d09wdGlvblZhbHVlID0gcGFyc2VUb051bWJlcihvcHRpb25WYWx1ZSwgRGVjaW1hbDo6bmFuKCkp OworICAgICAgICBpZiAoIXJhd09wdGlvblZhbHVlLmlzRmluaXRlKCkKKyAgICAgICAgICAgIHx8 IHN0ZXBSYW5nZS5zdGVwTWlzbWF0Y2gocmF3T3B0aW9uVmFsdWUpCisgICAgICAgICAgICB8fCBy YXdPcHRpb25WYWx1ZSA8IHN0ZXBSYW5nZS5taW5pbXVtKCkKKyAgICAgICAgICAgIHx8IHJhd09w dGlvblZhbHVlID4gc3RlcFJhbmdlLm1heGltdW0oKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOwor ICAgICAgICBtX3RpY2tNYXJrVmFsdWVzLmFwcGVuZChzdGVwUmFuZ2UuY2xhbXBWYWx1ZShyYXdP cHRpb25WYWx1ZSkpOworICAgIH0KKyAgICBtX3RpY2tNYXJrVmFsdWVzLnNocmlua1RvRml0KCk7 CisgICAgbm9uQ29weWluZ1NvcnQobV90aWNrTWFya1ZhbHVlcy5iZWdpbigpLCBtX3RpY2tNYXJr VmFsdWVzLmVuZCgpLCBkZWNpbWFsQ29tcGFyZSk7Cit9CisKK0RlY2ltYWwgUmFuZ2VJbnB1dFR5 cGU6OmZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZShEZWNpbWFsIHZhbHVlKQoreworICAgIHVwZGF0 ZVRpY2tNYXJrVmFsdWVzKCk7CisgICAgaWYgKCFtX3RpY2tNYXJrVmFsdWVzLnNpemUoKSkKKyAg ICAgICAgcmV0dXJuIERlY2ltYWw6Om5hbigpOworCisgICAgc2l6ZV90IGxlZnQgPSAwOworICAg IHNpemVfdCByaWdodCA9IG1fdGlja01hcmtWYWx1ZXMuc2l6ZSgpOworICAgIHNpemVfdCBtaWRk bGU7CisgICAgd2hpbGUgKHRydWUpIHsKKyAgICAgICAgQVNTRVJUKGxlZnQgPD0gcmlnaHQpOwor ICAgICAgICBtaWRkbGUgPSAobGVmdCArIHJpZ2h0KSAvIDI7CisgICAgICAgIGlmICghbWlkZGxl KQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGlmIChtaWRkbGUgPT0gbV90aWNrTWFya1Zh bHVlcy5zaXplKCkgLSAxICYmIG1fdGlja01hcmtWYWx1ZXNbbWlkZGxlXSA8IHZhbHVlKSB7Cisg ICAgICAgICAgICBtaWRkbGUrKzsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAg ICAgIGlmIChtX3RpY2tNYXJrVmFsdWVzW21pZGRsZSAtIDFdIDw9IHZhbHVlICYmIG1fdGlja01h cmtWYWx1ZXNbbWlkZGxlXSA+PSB2YWx1ZSkKKyAgICAgICAgICAgIGJyZWFrOworCisgICAgICAg IGlmIChtX3RpY2tNYXJrVmFsdWVzW21pZGRsZV0gPCB2YWx1ZSkKKyAgICAgICAgICAgIGxlZnQg PSBtaWRkbGU7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJpZ2h0ID0gbWlkZGxlOworICAg IH0KKyAgICBEZWNpbWFsIGNsb3Nlc3RMZWZ0ID0gbWlkZGxlID8gbV90aWNrTWFya1ZhbHVlc1tt aWRkbGUgLSAxXSA6IERlY2ltYWw6OmluZmluaXR5KERlY2ltYWw6Ok5lZ2F0aXZlKTsKKyAgICBE ZWNpbWFsIGNsb3Nlc3RSaWdodCA9IG1pZGRsZSAhPSBtX3RpY2tNYXJrVmFsdWVzLnNpemUoKSA/ IG1fdGlja01hcmtWYWx1ZXNbbWlkZGxlXSA6IERlY2ltYWw6OmluZmluaXR5KERlY2ltYWw6OlBv c2l0aXZlKTsKKyAgICBpZiAoY2xvc2VzdFJpZ2h0IC0gdmFsdWUgPCB2YWx1ZSAtIGNsb3Nlc3RM ZWZ0KQorICAgICAgICByZXR1cm4gY2xvc2VzdFJpZ2h0OworICAgIHJldHVybiBjbG9zZXN0TGVm dDsKK30KICNlbmRpZgogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1Jh bmdlSW5wdXRUeXBlLmgKaW5kZXggNjlkMmVjN2M2Y2MxOWQxMDM2MTU0MjAzM2JjZmQ2NzE0ODQ4 NjI4Ny4uNDJiYjk1ZjNkYjc5ZGY4NTBiMGRiZjdjZmUxMTk3MDUzMzAzNzk5NSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvUmFuZ2VJbnB1dFR5cGUuaApAQCAtNDIsNyArNDIsNyBAQCBwdWJsaWM6CiAgICAg c3RhdGljIFBhc3NPd25QdHI8SW5wdXRUeXBlPiBjcmVhdGUoSFRNTElucHV0RWxlbWVudCopOwog CiBwcml2YXRlOgotICAgIFJhbmdlSW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQp IDogSW5wdXRUeXBlKGVsZW1lbnQpIHsgfQorICAgIFJhbmdlSW5wdXRUeXBlKEhUTUxJbnB1dEVs ZW1lbnQqKTsKICAgICB2aXJ0dWFsIGJvb2wgaXNSYW5nZUNvbnRyb2woKSBjb25zdCBPVkVSUklE RTsKICAgICB2aXJ0dWFsIGNvbnN0IEF0b21pY1N0cmluZyYgZm9ybUNvbnRyb2xUeXBlKCkgY29u c3QgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBkb3VibGUgdmFsdWVBc0RvdWJsZSgpIGNvbnN0IE9W RVJSSURFOwpAQCAtNzIsNyArNzIsMTIgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIEhUTUxFbGVt ZW50KiBzbGlkZXJUaHVtYkVsZW1lbnQoKSBjb25zdCBPVkVSUklERTsKICNpZiBFTkFCTEUoREFU QUxJU1RfRUxFTUVOVCkKICAgICB2aXJ0dWFsIHZvaWQgbGlzdEF0dHJpYnV0ZVRhcmdldENoYW5n ZWQoKSBPVkVSUklERTsKKyAgICB2b2lkIHVwZGF0ZVRpY2tNYXJrVmFsdWVzKCk7CisgICAgdmly dHVhbCBEZWNpbWFsIGZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZShEZWNpbWFsKSBPVkVSUklERTsK ICNlbmRpZgorCisgICAgYm9vbCBtX3RpY2tNYXJrVmFsdWVzRGlydHk7CisgICAgVmVjdG9yPERl Y2ltYWw+IG1fdGlja01hcmtWYWx1ZXM7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQu Y3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvU2xpZGVyVGh1bWJFbGVtZW50LmNwcApp bmRleCAzNjIyMWRkZDdlNTQ3ZWUxNThiMTYyNTA1ZGM4ZWNjMDRjYzBlMTk5Li40MzA2N2M3ZTIy MWEzYjQ5NThkYzljNDNkY2Y4NDhhMDkzZGIyNGQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9odG1sL3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2h0bWwvc2hhZG93L1NsaWRlclRodW1iRWxlbWVudC5jcHAKQEAgLTUxLDYgKzUxLDggQEAgdXNp bmcgbmFtZXNwYWNlIHN0ZDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1lc3Bh Y2UgSFRNTE5hbWVzOworCiBpbmxpbmUgc3RhdGljIERlY2ltYWwgc2xpZGVyUG9zaXRpb24oSFRN TElucHV0RWxlbWVudCogZWxlbWVudCkKIHsKICAgICBjb25zdCBTdGVwUmFuZ2Ugc3RlcFJhbmdl KGVsZW1lbnQtPmNyZWF0ZVN0ZXBSYW5nZShSZWplY3RBbnkpKTsKQEAgLTIzNSw2ICsyMzcsOCBA QCB2b2lkIFNsaWRlclRodW1iRWxlbWVudDo6ZHJhZ0Zyb20oY29uc3QgTGF5b3V0UG9pbnQmIHBv aW50KQogICAgIHN0YXJ0RHJhZ2dpbmcoKTsKIH0KIAorCisKIHZvaWQgU2xpZGVyVGh1bWJFbGVt ZW50OjpzZXRQb3NpdGlvbkZyb21Qb2ludChjb25zdCBMYXlvdXRQb2ludCYgcG9pbnQpCiB7CiAg ICAgSFRNTElucHV0RWxlbWVudCogaW5wdXQgPSBob3N0SW5wdXQoKTsKQEAgLTI3MCw3ICsyNzQs MTkgQEAgdm9pZCBTbGlkZXJUaHVtYkVsZW1lbnQ6OnNldFBvc2l0aW9uRnJvbVBvaW50KGNvbnN0 IExheW91dFBvaW50JiBwb2ludCkKICAgICBjb25zdCBEZWNpbWFsIHJhdGlvID0gRGVjaW1hbDo6 ZnJvbURvdWJsZShzdGF0aWNfY2FzdDxkb3VibGU+KHBvc2l0aW9uKSAvIHRyYWNrU2l6ZSk7CiAg ICAgY29uc3QgRGVjaW1hbCBmcmFjdGlvbiA9IGlzVmVydGljYWwgfHwgIXJlbmRlckJveCgpLT5z dHlsZSgpLT5pc0xlZnRUb1JpZ2h0RGlyZWN0aW9uKCkgPyBEZWNpbWFsKDEpIC0gcmF0aW8gOiBy YXRpbzsKICAgICBTdGVwUmFuZ2Ugc3RlcFJhbmdlKGlucHV0LT5jcmVhdGVTdGVwUmFuZ2UoUmVq ZWN0QW55KSk7Ci0gICAgY29uc3QgRGVjaW1hbCB2YWx1ZSA9IHN0ZXBSYW5nZS5jbGFtcFZhbHVl KHN0ZXBSYW5nZS52YWx1ZUZyb21Qcm9wb3J0aW9uKGZyYWN0aW9uKSk7CisgICAgRGVjaW1hbCB2 YWx1ZSA9IHN0ZXBSYW5nZS5jbGFtcFZhbHVlKHN0ZXBSYW5nZS52YWx1ZUZyb21Qcm9wb3J0aW9u KGZyYWN0aW9uKSk7CisKKyNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKKyAgICBEZWNpbWFs IGNsb3Nlc3QgPSBpbnB1dC0+ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKHZhbHVlKTsKKyAgICBp ZiAoY2xvc2VzdC5pc0Zpbml0ZSgpKSB7CisgICAgICAgIGRvdWJsZSBjbG9zZXN0RnJhY3Rpb24g PSBzdGVwUmFuZ2UucHJvcG9ydGlvbkZyb21WYWx1ZShjbG9zZXN0KS50b0RvdWJsZSgpOworICAg ICAgICBkb3VibGUgY2xvc2VzdFJhdGlvID0gaXNWZXJ0aWNhbCB8fCAhcmVuZGVyQm94KCktPnN0 eWxlKCktPmlzTGVmdFRvUmlnaHREaXJlY3Rpb24oKSA/IDEuMCAtIGNsb3Nlc3RGcmFjdGlvbiA6 IGNsb3Nlc3RGcmFjdGlvbjsKKyAgICAgICAgZG91YmxlIGNsb3Nlc3RQb3NpdGlvbiA9IHRyYWNr U2l6ZSAqIGNsb3Nlc3RSYXRpbzsKKyAgICAgICAgY29uc3QgaW50IHNuYXBUaHJlc2hvbGQgPSAz OworICAgICAgICBpZiAoYWJzKGNsb3Nlc3RQb3NpdGlvbiAtIHN0YXRpY19jYXN0PGRvdWJsZT4o cG9zaXRpb24pKSA8IHNuYXBUaHJlc2hvbGQpCisgICAgICAgICAgICB2YWx1ZSA9IGNsb3Nlc3Q7 CisgICAgfQorI2VuZGlmCiAKICAgICAvLyBGSVhNRTogVGhpcyBpcyBubyBsb25nZXIgYmVpbmcg c2V0IGZyb20gcmVuZGVyZXIuIENvbnNpZGVyIHVwZGF0aW5nIHRoZSBtZXRob2QgbmFtZS4KICAg ICBpbnB1dC0+c2V0VmFsdWVGcm9tUmVuZGVyZXIoc2VyaWFsaXplRm9yTnVtYmVyVHlwZSh2YWx1 ZSkpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCmluZGV4IGU4YTk2YzMyZDExNWIwZWNhN2RhOGE0NTc4ZDY0OGU3YzY3MDc5MjguLjhl MmM2YWY0ZGJmNzYyMTVjYzU3YmNlYTY1NjdkMTIwOWRiNzRlMWIgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx MyBAQAorMjAxMi0wOC0wMSAgS2Vpc2hpIEhhdHRvcmkgIDxrZWlzaGlAd2Via2l0Lm9yZz4KKwor ICAgICAgICBTbGlkZXIgc2hvdWxkIHNuYXAgdG8gZGF0YWxpc3QgdGljayBtYXJrcworICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTI2NDAKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvZm9ybXMvZGF0 YWxpc3QvcmFuZ2Utc25hcC10by1kYXRhbGlzdC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvZm9ybXMvZGF0YWxpc3QvcmFuZ2Utc25hcC10by1kYXRhbGlzdC5odG1sOiBBZGRl ZC4KKwogMjAxMi0wOC0wMSAgUGV0ZXIgS2FzdGluZyAgPHBrYXN0aW5nQGdvb2dsZS5jb20+CiAK ICAgICAgICAgW0Nocm9taXVtXSBNYXJrIGEgY291cGxlIG9mIGZsYWt5IHRlc3RzLgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFs aXN0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvZGF0YWxpc3QvcmFuZ2Ut c25hcC10by1kYXRhbGlzdC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYzM1YThlMmMyZDE2NDIy MzJjMGRmOTUxYTNiMzU2ZWY5YTljMjYwOQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvZGF0YWxpc3QvcmFuZ2Utc25hcC10by1kYXRhbGlzdC1leHBlY3RlZC50eHQK QEAgLTAsMCArMSwyOCBAQAorVGVzdHMgaWYgY2xpY2tpbmcgY2xvc2UgdG8gYSB0aWNrIG1hcmsg c25hcHMgdG8gaXQuCisKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIHBhcnNlSW50KGlu cHV0LnZhbHVlLCAxMCkgPCA1MDAgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BB U1MgcGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA8IDUwMCBpcyB0cnVlCitQQVNTIGlucHV0LnZh bHVlIGlzICIwIgorUEFTUyBwYXJzZUludChpbnB1dC52YWx1ZSwgMTApIDwgNTAwIGlzIHRydWUK K1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIGlucHV0LnZhbHVlIGlzICc1MDAnCitQQVNT IGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBpbnB1dC52YWx1ZSBpcyAnNTAwJworUEFTUyBpbnB1 dC52YWx1ZSBpcyAiMCIKK1BBU1MgaW5wdXQudmFsdWUgaXMgJzUwMCcKK1BBU1MgaW5wdXQudmFs dWUgaXMgIjAiCitQQVNTIGlucHV0LnZhbHVlIGlzICc1MDAnCitQQVNTIGlucHV0LnZhbHVlIGlz ICIwIgorUEFTUyBpbnB1dC52YWx1ZSBpcyAnNTAwJworUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIK K1BBU1MgcGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+IDUwMCBpcyB0cnVlCitQQVNTIGlucHV0 LnZhbHVlIGlzICIwIgorUEFTUyBwYXJzZUludChpbnB1dC52YWx1ZSwgMTApID4gNTAwIGlzIHRy dWUKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIHBhcnNlSW50KGlucHV0LnZhbHVlLCAx MCkgPiA1MDAgaXMgdHJ1ZQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNU IENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvZGF0YWxpc3Qv cmFuZ2Utc25hcC10by1kYXRhbGlzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRh bGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmFiZmVjMTlhYWUz ZTJhNzMzMDdkZGNmOGJmMzRmNjAyZTI1MzQ3OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvZm9ybXMvZGF0YWxpc3QvcmFuZ2Utc25hcC10by1kYXRhbGlzdC5odG1sCkBAIC0w LDAgKzEsNzAgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQgc3Jj PSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgor PGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPlRlc3RzIGlmIGNsaWNraW5nIGNsb3NlIHRvIGEg dGljayBtYXJrIHNuYXBzIHRvIGl0LjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPGlu cHV0IGlkPSJpbnB1dCIgdHlwZT1yYW5nZSBtaW49MCBtYXg9MTAwMCBzdGVwPTEgbGlzdD10YXJn ZXQgc3R5bGU9IndpZHRoOiAxMDBweCI+Cis8ZGF0YWxpc3QgaWQ9InRhcmdldCI+CisgICAgPG9w dGlvbj41MDA8L29wdGlvbj4KKzwvZGF0YWxpc3Q+Cis8c2NyaXB0PgorICAgIHZhciBpbnB1dCA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJpbnB1dCIpOworICAgIHZhciB0aHVtYldpZHRoID0g MTU7CisgICAgdmFyIGhhbGZUaHVtYldpZHRoID0gKHRodW1iV2lkdGggLSAxKSAvIDI7CisgICAg ZnVuY3Rpb24gY2xpY2tTbGlkZXIob2Zmc2V0TGVmdCkgeworICAgICAgICB2YXIgY2VudGVyWSA9 IGlucHV0Lm9mZnNldFRvcCArIGlucHV0Lm9mZnNldEhlaWdodCAvIDI7CisgICAgICAgIGV2ZW50 U2VuZGVyLm1vdXNlTW92ZVRvKGlucHV0Lm9mZnNldExlZnQgKyBvZmZzZXRMZWZ0LCBjZW50ZXJZ KTsKKyAgICAgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgICAgIGV2ZW50U2VuZGVy Lm1vdXNlVXAoKTsKKyAgICB9CisgICAgZnVuY3Rpb24gcmVzZXRTbGlkZXJQb3NpdGlvbigpIHsK KyAgICAgICAgY2xpY2tTbGlkZXIoMCk7CisgICAgICAgIHNob3VsZEJlKCdpbnB1dC52YWx1ZScs ICciMCInKTsKKyAgICB9CisgICAgZnVuY3Rpb24gZXhwZWN0ZWRWYWx1ZUZvclBvc2l0aW9uKHBv cykgeworICAgICAgICBjbGlja1NsaWRlcihwb3MpOworICAgICAgICB2YXIgdmFsdWUgPSBNYXRo LnJvdW5kKChwb3MgLSBoYWxmVGh1bWJXaWR0aCAtIDAuNSkgLyAoaW5wdXQub2Zmc2V0V2lkdGgg LSB0aHVtYldpZHRoKSAqIChpbnB1dC5tYXggLSBpbnB1dC5taW4pICsgaW5wdXQubWluKTsKKyAg ICAgICAgdmFsdWUgPSBNYXRoLm1heChNYXRoLm1pbih2YWx1ZSwgaW5wdXQubWF4KSwgaW5wdXQu bWluKTsKKyAgICAgICAgcmV0dXJuIHZhbHVlOworICAgIH0KKyAgICByZXNldFNsaWRlclBvc2l0 aW9uKCk7CisgICAgY2xpY2tTbGlkZXIoNDUpOworICAgIHNob3VsZEJlVHJ1ZSgncGFyc2VJbnQo aW5wdXQudmFsdWUsIDEwKSA8IDUwMCcpOworICAgIHJlc2V0U2xpZGVyUG9zaXRpb24oKTsKKyAg ICBjbGlja1NsaWRlcig0Nik7CisgICAgc2hvdWxkQmVUcnVlKCdwYXJzZUludChpbnB1dC52YWx1 ZSwgMTApIDwgNTAwJyk7CisgICAgcmVzZXRTbGlkZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xp ZGVyKDQ3KTsKKyAgICBzaG91bGRCZVRydWUoJ3BhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPCA1 MDAnKTsKKyAgICByZXNldFNsaWRlclBvc2l0aW9uKCk7CisgICAgY2xpY2tTbGlkZXIoNDgpOwor ICAgIHNob3VsZEJlKCdpbnB1dC52YWx1ZScsICInNTAwJyIpOworICAgIHJlc2V0U2xpZGVyUG9z aXRpb24oKTsKKyAgICBjbGlja1NsaWRlcig0OSk7CisgICAgc2hvdWxkQmUoJ2lucHV0LnZhbHVl JywgIic1MDAnIik7CisgICAgcmVzZXRTbGlkZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVy KDUwKTsKKyAgICBzaG91bGRCZSgnaW5wdXQudmFsdWUnLCAiJzUwMCciKTsKKyAgICByZXNldFNs aWRlclBvc2l0aW9uKCk7CisgICAgY2xpY2tTbGlkZXIoNTEpOworICAgIHNob3VsZEJlKCdpbnB1 dC52YWx1ZScsICInNTAwJyIpOworICAgIHJlc2V0U2xpZGVyUG9zaXRpb24oKTsKKyAgICBjbGlj a1NsaWRlcig1Mik7CisgICAgc2hvdWxkQmUoJ2lucHV0LnZhbHVlJywgIic1MDAnIik7CisgICAg cmVzZXRTbGlkZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVyKDUzKTsKKyAgICBzaG91bGRC ZVRydWUoJ3BhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPiA1MDAnKTsKKyAgICByZXNldFNsaWRl clBvc2l0aW9uKCk7CisgICAgY2xpY2tTbGlkZXIoNTQpOworICAgIHNob3VsZEJlVHJ1ZSgncGFy c2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+IDUwMCcpOworICAgIHJlc2V0U2xpZGVyUG9zaXRpb24o KTsKKyAgICBjbGlja1NsaWRlcig1NSk7CisgICAgc2hvdWxkQmVUcnVlKCdwYXJzZUludChpbnB1 dC52YWx1ZSwgMTApID4gNTAwJyk7Cis8L3NjcmlwdD4KKworPHNjcmlwdCBzcmM9Ii4uLy4uL2pz L3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 156004 2012-08-02 01:34:20 -0700 2012-08-02 02:03:17 -0700 Patch bug-92640-20120802173401.patch text/plain 15070 keishi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA2NGU2YTUyZDBiMmE2NWYyYTUzY2Y4MDBmMmUzZWM3Y2ViMDM2NDVmLi5j MmNhNThmN2IxNTc4NjY4MjNjZmQ4M2I2ZmE0ZTNiZDM5YjM2MmE4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzcgQEAKKzIwMTItMDgtMDEgIEtlaXNoaSBIYXR0b3JpICA8a2Vpc2hpQHdlYmtpdC5v cmc+CisKKyAgICAgICAgU2xpZGVyIHNob3VsZCBzbmFwIHRvIGRhdGFsaXN0IHRpY2sgbWFya3MK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkyNjQwCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkaXRpb25h bCBpbmZvcm1hdGlvbiBvZiB0aGUgY2hhbmdlIHN1Y2ggYXMgYXBwcm9hY2gsIHJhdGlvbmFsZS4g UGxlYXNlIGFkZCBwZXItZnVuY3Rpb24gZGVzY3JpcHRpb25zIGJlbG93IChPT1BTISkuCisKKyAg ICAgICAgVGVzdDogZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0Lmh0 bWwKKworICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpIVE1MSW5wdXRFbGVtZW50OjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUpOiBKdXN0IGNh bGxzIElucHV0VHlwZTo6ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlLgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgIChIVE1MSW5w dXRFbGVtZW50KToKKyAgICAgICAgKiBodG1sL0lucHV0VHlwZS5jcHA6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OklucHV0VHlwZTo6ZmluZENsb3Nlc3RUaWNrTWFya1Zh bHVlKTogT3ZlcnJpZGRlbiBieSBSYW5nZUlucHV0VHlwZS4KKyAgICAgICAgKiBodG1sL0lucHV0 VHlwZS5oOgorICAgICAgICAoSW5wdXRUeXBlKToKKyAgICAgICAgKiBodG1sL1JhbmdlSW5wdXRU eXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJhbmdlSW5wdXRUeXBlOjpSYW5nZUlucHV0VHlw ZSk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJhbmdlSW5wdXRUeXBl OjpsaXN0QXR0cmlidXRlVGFyZ2V0Q2hhbmdlZCk6IE1hcmsgbV90aWNrTWFya1ZhbHVlcyBhcyBk aXJ0eS4KKyAgICAgICAgKFdlYkNvcmU6OmRlY2ltYWxDb21wYXJlKToKKyAgICAgICAgKFdlYkNv cmU6OlJhbmdlSW5wdXRUeXBlOjp1cGRhdGVUaWNrTWFya1ZhbHVlcyk6IFNldHMgbV90aWNrTWFy a1ZhbHVlcyB0byBhIGxpc3Qgb2Ygc29ydGVkIHZhbGlkIGRhdGFsaXN0IHZhbHVlcy4KKyAgICAg ICAgKFdlYkNvcmU6OlJhbmdlSW5wdXRUeXBlOjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUpOiBG aW5kcyBjbG9zZXN0IHRpY2sgbWFyayB2YWx1ZSB0byBhIGdpdmVuIHZhbHVlLgorICAgICAgICAq IGh0bWwvUmFuZ2VJbnB1dFR5cGUuaDoKKyAgICAgICAgKFJhbmdlSW5wdXRUeXBlKToKKyAgICAg ICAgKiBodG1sL3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgIChXZWJDb3JlOjpTbGlkZXJUaHVtYkVsZW1lbnQ6OnNldFBvc2l0aW9uRnJv bVBvaW50KTogU25hcHMgdG8gdGhlIGNsb3Nlc3QgdGljayBtYXJrIHZhbHVlIGlmIGl0IGlzIHdp dGhpbiBhIGNlcnRhaW4gZGlzdGFuY2UuCisKIDIwMTItMDgtMDEgIE1pa2hhaWwgUG96ZG55YWtv diAgPG1pa2hhaWwucG96ZG55YWtvdkBpbnRlbC5jb20+CiAKICAgICAgICAgW0VGTF0gQ3Jhc2gg YXQgV2ViQ29yZTo6dG9SZW5kZXJTbGlkZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVs ZW1lbnQuY3BwCmluZGV4IDIxNmQxNzI5ZjQwZDUwMmU5YWY3NzZmZGQwZTljZTc3YjI1MzliZjUu LjQzZGNkZDI1OWM2ODU0NGMyZWM2OWYzODY4OWJiZTlhOGMzYTQ4YTIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtMzEzLDYgKzMxMywxMyBAQCBTdGVwUmFu Z2UgSFRNTElucHV0RWxlbWVudDo6Y3JlYXRlU3RlcFJhbmdlKEFueVN0ZXBIYW5kbGluZyBhbnlT dGVwSGFuZGxpbmcpIGNvbgogICAgIHJldHVybiBtX2lucHV0VHlwZS0+Y3JlYXRlU3RlcFJhbmdl KGFueVN0ZXBIYW5kbGluZyk7CiB9CiAKKyNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKK0Rl Y2ltYWwgSFRNTElucHV0RWxlbWVudDo6ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKERlY2ltYWwg dmFsdWUpCit7CisgICAgcmV0dXJuIG1faW5wdXRUeXBlLT5maW5kQ2xvc2VzdFRpY2tNYXJrVmFs dWUodmFsdWUpOworfQorI2VuZGlmCisKIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c3RlcFVwKGlu dCBuLCBFeGNlcHRpb25Db2RlJiBlYykKIHsKICAgICBtX2lucHV0VHlwZS0+c3RlcFVwKG4sIGVj KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXggYmE1NDYwNDM1YTFk YzI1OTFmYmVlYmM1ZDg4Y2JlZGE5ZTlhYjY4ZC4uODJjOTkyYzFhOThkMzI4MDJjMWQ4M2I4Njg0 NjdmMDdiZmRiZDQwZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRF bGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKQEAg LTcyLDYgKzcyLDEwIEBAIHB1YmxpYzoKICAgICBib29sIGdldEFsbG93ZWRWYWx1ZVN0ZXAoRGVj aW1hbCopIGNvbnN0OwogICAgIFN0ZXBSYW5nZSBjcmVhdGVTdGVwUmFuZ2UoQW55U3RlcEhhbmRs aW5nKSBjb25zdDsKIAorI2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQorICAgIERlY2ltYWwg ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKERlY2ltYWwpOworI2VuZGlmCisKICAgICAvLyBJbXBs ZW1lbnRhdGlvbnMgb2YgSFRNTElucHV0RWxlbWVudDo6c3RlcFVwKCkgYW5kIHN0ZXBEb3duKCku CiAgICAgdm9pZCBzdGVwVXAoaW50LCBFeGNlcHRpb25Db2RlJik7CiAgICAgdm9pZCBzdGVwRG93 bihpbnQsIEV4Y2VwdGlvbkNvZGUmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SW5wdXRUeXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNwcAppbmRleCAw OWE4OTViNTAyODljNWFhMWUyMjlmN2Y0ZDU4MzI1NzZlMTk4NGQyLi45YzJiNGUyNGM0OGVhZWI4 ZDk3MGE1ZmJiZTM0OWE0ODY4ZThlOGU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1s L0lucHV0VHlwZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCkBA IC05MDgsNiArOTA4LDExIEBAIFN0cmluZyBJbnB1dFR5cGU6OmRlZmF1bHRUb29sVGlwKCkgY29u c3QKIHZvaWQgSW5wdXRUeXBlOjpsaXN0QXR0cmlidXRlVGFyZ2V0Q2hhbmdlZCgpCiB7CiB9CisK K0RlY2ltYWwgSW5wdXRUeXBlOjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUoRGVjaW1hbCkKK3sK KyAgICByZXR1cm4gRGVjaW1hbDo6bmFuKCk7Cit9CiAjZW5kaWYKIAogYm9vbCBJbnB1dFR5cGU6 OnN1cHBvcnRzSW5kZXRlcm1pbmF0ZUFwcGVhcmFuY2UoKSBjb25zdApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRU eXBlLmgKaW5kZXggMDI0NWJhODg4MGIzZjA3MWM2MTU5YmJiZGE4YWYzNWIyZWIwMGRjNi4uYTEy Yzc0MGU0M2VhYTVhMDVkYTA5MDFkMzU5MDMzMDhjZDdhN2JkYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0 VHlwZS5oCkBAIC0yODEsNiArMjgxLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgU3RyaW5nIGRl ZmF1bHRUb29sVGlwKCkgY29uc3Q7CiAjaWYgRU5BQkxFKERBVEFMSVNUX0VMRU1FTlQpCiAgICAg dmlydHVhbCB2b2lkIGxpc3RBdHRyaWJ1dGVUYXJnZXRDaGFuZ2VkKCk7CisgICAgdmlydHVhbCBE ZWNpbWFsIGZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZShEZWNpbWFsKTsKICNlbmRpZgogCiAgICAg Ly8gUGFyc2VzIHRoZSBzcGVjaWZpZWQgc3RyaW5nIGZvciB0aGUgdHlwZSwgYW5kIHJldHVybgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcAppbmRleCA5MDFhOWFjYzFiMzdkNWYw NTYwNGY5MDM1MDE3ZTk5NGJjNWJiNDViLi5hMWM1YzU5MzYwNjZmNzQzMjk1ZWMxMDMwNjRhMDMw ZDA2ZjFkNzk3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBl LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcApAQCAtNTUs NiArNTUsMTIgQEAKICNpbmNsdWRlICJUb3VjaExpc3QuaCIKICNlbmRpZgogCisjaWYgRU5BQkxF KERBVEFMSVNUX0VMRU1FTlQpCisjaW5jbHVkZSAiSFRNTERhdGFMaXN0RWxlbWVudC5oIgorI2lu Y2x1ZGUgIkhUTUxPcHRpb25FbGVtZW50LmgiCisjaW5jbHVkZSA8d3RmL05vbkNvcHlpbmdTb3J0 Lmg+CisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiB1c2luZyBuYW1lc3BhY2UgSFRN TE5hbWVzOwpAQCAtNzYsNiArODIsMTQgQEAgUGFzc093blB0cjxJbnB1dFR5cGU+IFJhbmdlSW5w dXRUeXBlOjpjcmVhdGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKICAgICByZXR1cm4gYWRv cHRQdHIobmV3IFJhbmdlSW5wdXRUeXBlKGVsZW1lbnQpKTsKIH0KIAorUmFuZ2VJbnB1dFR5cGU6 OlJhbmdlSW5wdXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpCisgICAgOiBJbnB1dFR5 cGUoZWxlbWVudCkKKyNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKKyAgICAsIG1fdGlja01h cmtWYWx1ZXNEaXJ0eSh0cnVlKQorI2VuZGlmCit7Cit9CisKIGJvb2wgUmFuZ2VJbnB1dFR5cGU6 OmlzUmFuZ2VDb250cm9sKCkgY29uc3QKIHsKICAgICByZXR1cm4gdHJ1ZTsKQEAgLTMxOSw4ICsz MzMsNzEgQEAgSFRNTEVsZW1lbnQqIFJhbmdlSW5wdXRUeXBlOjpzbGlkZXJUaHVtYkVsZW1lbnQo KSBjb25zdAogI2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQogdm9pZCBSYW5nZUlucHV0VHlw ZTo6bGlzdEF0dHJpYnV0ZVRhcmdldENoYW5nZWQoKQogeworICAgIG1fdGlja01hcmtWYWx1ZXNE aXJ0eSA9IHRydWU7CiAgICAgZWxlbWVudCgpLT5zZXROZWVkc1N0eWxlUmVjYWxjKCk7CiB9CisK K3N0YXRpYyBib29sIGRlY2ltYWxDb21wYXJlKERlY2ltYWwgYSwgRGVjaW1hbCBiKQoreworICAg IHJldHVybiBhIDwgYjsKK30KKwordm9pZCBSYW5nZUlucHV0VHlwZTo6dXBkYXRlVGlja01hcmtW YWx1ZXMoKQoreworICAgIGlmICghbV90aWNrTWFya1ZhbHVlc0RpcnR5KQorICAgICAgICByZXR1 cm47CisgICAgbV90aWNrTWFya1ZhbHVlcy5jbGVhcigpOworICAgIG1fdGlja01hcmtWYWx1ZXNE aXJ0eSA9IGZhbHNlOworICAgIEhUTUxEYXRhTGlzdEVsZW1lbnQqIGRhdGFMaXN0ID0gZWxlbWVu dCgpLT5kYXRhTGlzdCgpOworICAgIGlmICghZGF0YUxpc3QpCisgICAgICAgIHJldHVybjsKKyAg ICBSZWZQdHI8SFRNTENvbGxlY3Rpb24+IG9wdGlvbnMgPSBkYXRhTGlzdC0+b3B0aW9ucygpOwor ICAgIG1fdGlja01hcmtWYWx1ZXMucmVzZXJ2ZUNhcGFjaXR5KG9wdGlvbnMtPmxlbmd0aCgpKTsK KyAgICBTdGVwUmFuZ2Ugc3RlcFJhbmdlKGNyZWF0ZVN0ZXBSYW5nZShSZWplY3RBbnkpKTsKKyAg ICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgb3B0aW9ucy0+bGVuZ3RoKCk7ICsraSkgeworICAg ICAgICBOb2RlKiBub2RlID0gb3B0aW9ucy0+aXRlbShpKTsKKyAgICAgICAgSFRNTE9wdGlvbkVs ZW1lbnQqIG9wdGlvbkVsZW1lbnQgPSB0b0hUTUxPcHRpb25FbGVtZW50KG5vZGUpOworICAgICAg ICBTdHJpbmcgb3B0aW9uVmFsdWUgPSBvcHRpb25FbGVtZW50LT52YWx1ZSgpOworICAgICAgICBp ZiAoIWVsZW1lbnQoKS0+aXNWYWxpZFZhbHVlKG9wdGlvblZhbHVlKSkKKyAgICAgICAgICAgIGNv bnRpbnVlOworICAgICAgICBtX3RpY2tNYXJrVmFsdWVzLmFwcGVuZChzdGVwUmFuZ2UuY2xhbXBW YWx1ZShwYXJzZVRvTnVtYmVyKG9wdGlvblZhbHVlLCBzdGVwUmFuZ2UuZGVmYXVsdFZhbHVlKCkp KSk7CisgICAgfQorICAgIG1fdGlja01hcmtWYWx1ZXMuc2hyaW5rVG9GaXQoKTsKKyAgICBub25D b3B5aW5nU29ydChtX3RpY2tNYXJrVmFsdWVzLmJlZ2luKCksIG1fdGlja01hcmtWYWx1ZXMuZW5k KCksIGRlY2ltYWxDb21wYXJlKTsKK30KKworRGVjaW1hbCBSYW5nZUlucHV0VHlwZTo6ZmluZENs b3Nlc3RUaWNrTWFya1ZhbHVlKERlY2ltYWwgdmFsdWUpCit7CisgICAgdXBkYXRlVGlja01hcmtW YWx1ZXMoKTsKKyAgICBpZiAoIW1fdGlja01hcmtWYWx1ZXMuc2l6ZSgpKQorICAgICAgICByZXR1 cm4gRGVjaW1hbDo6bmFuKCk7CisKKyAgICBzaXplX3QgbGVmdCA9IDA7CisgICAgc2l6ZV90IHJp Z2h0ID0gbV90aWNrTWFya1ZhbHVlcy5zaXplKCk7CisgICAgc2l6ZV90IG1pZGRsZTsKKyAgICB3 aGlsZSAodHJ1ZSkgeworICAgICAgICBBU1NFUlQobGVmdCA8PSByaWdodCk7CisgICAgICAgIG1p ZGRsZSA9IChzdGF0aWNfY2FzdDxsb25nPihsZWZ0KSArIHN0YXRpY19jYXN0PGxvbmc+KHJpZ2h0 KSkgLyAyOworICAgICAgICBpZiAoIW1pZGRsZSkKKyAgICAgICAgICAgIGJyZWFrOworICAgICAg ICBpZiAobWlkZGxlID09IG1fdGlja01hcmtWYWx1ZXMuc2l6ZSgpIC0gMSAmJiBtX3RpY2tNYXJr VmFsdWVzW21pZGRsZV0gPCB2YWx1ZSkgeworICAgICAgICAgICAgbWlkZGxlKys7CisgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgfQorICAgICAgICBpZiAobV90aWNrTWFya1ZhbHVlc1ttaWRk bGUgLSAxXSA8PSB2YWx1ZSAmJiBtX3RpY2tNYXJrVmFsdWVzW21pZGRsZV0gPj0gdmFsdWUpCisg ICAgICAgICAgICBicmVhazsKKworICAgICAgICBpZiAobV90aWNrTWFya1ZhbHVlc1ttaWRkbGVd IDwgdmFsdWUpCisgICAgICAgICAgICBsZWZ0ID0gbWlkZGxlOworICAgICAgICBlbHNlCisgICAg ICAgICAgICByaWdodCA9IG1pZGRsZTsKKyAgICB9CisgICAgRGVjaW1hbCBjbG9zZXN0TGVmdCA9 IG1pZGRsZSA/IG1fdGlja01hcmtWYWx1ZXNbbWlkZGxlIC0gMV0gOiBEZWNpbWFsOjppbmZpbml0 eShEZWNpbWFsOjpOZWdhdGl2ZSk7CisgICAgRGVjaW1hbCBjbG9zZXN0UmlnaHQgPSBtaWRkbGUg IT0gbV90aWNrTWFya1ZhbHVlcy5zaXplKCkgPyBtX3RpY2tNYXJrVmFsdWVzW21pZGRsZV0gOiBE ZWNpbWFsOjppbmZpbml0eShEZWNpbWFsOjpQb3NpdGl2ZSk7CisgICAgaWYgKGNsb3Nlc3RSaWdo dCAtIHZhbHVlIDwgdmFsdWUgLSBjbG9zZXN0TGVmdCkKKyAgICAgICAgcmV0dXJuIGNsb3Nlc3RS aWdodDsKKyAgICByZXR1cm4gY2xvc2VzdExlZnQ7Cit9CiAjZW5kaWYKIAogfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlw ZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oCmluZGV4IDY5ZDJlYzdj NmNjMTlkMTAzNjE1NDIwMzNiY2ZkNjcxNDg0ODYyODcuLjlmNWY4Yzg5NDBmZmFkNDkwMDJiMjg2 OGVhM2ZmNmE1NGI3YzViNTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFuZ2VJ bnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmgKQEAg LTQyLDcgKzQyLDcgQEAgcHVibGljOgogICAgIHN0YXRpYyBQYXNzT3duUHRyPElucHV0VHlwZT4g Y3JlYXRlKEhUTUxJbnB1dEVsZW1lbnQqKTsKIAogcHJpdmF0ZToKLSAgICBSYW5nZUlucHV0VHlw ZShIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KSA6IElucHV0VHlwZShlbGVtZW50KSB7IH0KKyAg ICBSYW5nZUlucHV0VHlwZShIVE1MSW5wdXRFbGVtZW50Kik7CiAgICAgdmlydHVhbCBib29sIGlz UmFuZ2VDb250cm9sKCkgY29uc3QgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBjb25zdCBBdG9taWNT dHJpbmcmIGZvcm1Db250cm9sVHlwZSgpIGNvbnN0IE9WRVJSSURFOwogICAgIHZpcnR1YWwgZG91 YmxlIHZhbHVlQXNEb3VibGUoKSBjb25zdCBPVkVSUklERTsKQEAgLTcyLDYgKzcyLDExIEBAIHBy aXZhdGU6CiAgICAgdmlydHVhbCBIVE1MRWxlbWVudCogc2xpZGVyVGh1bWJFbGVtZW50KCkgY29u c3QgT1ZFUlJJREU7CiAjaWYgRU5BQkxFKERBVEFMSVNUX0VMRU1FTlQpCiAgICAgdmlydHVhbCB2 b2lkIGxpc3RBdHRyaWJ1dGVUYXJnZXRDaGFuZ2VkKCkgT1ZFUlJJREU7CisgICAgdm9pZCB1cGRh dGVUaWNrTWFya1ZhbHVlcygpOworICAgIHZpcnR1YWwgRGVjaW1hbCBmaW5kQ2xvc2VzdFRpY2tN YXJrVmFsdWUoRGVjaW1hbCkgT1ZFUlJJREU7CisKKyAgICBib29sIG1fdGlja01hcmtWYWx1ZXNE aXJ0eTsKKyAgICBWZWN0b3I8RGVjaW1hbD4gbV90aWNrTWFya1ZhbHVlczsKICNlbmRpZgogfTsK IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvU2xpZGVyVGh1bWJFbGVt ZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1NsaWRlclRodW1iRWxlbWVudC5j cHAKaW5kZXggMzYyMjFkZGQ3ZTU0N2VlMTU4YjE2MjUwNWRjOGVjYzA0Y2MwZTE5OS4uMjUzOGFm NzE4ODg3ZjZlMzhkOWY1ODg0NzlkZGRlNWVlYTI0ZDQ4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvaHRtbC9zaGFkb3cvU2xpZGVyVGh1bWJFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQuY3BwCkBAIC01MSw2ICs1MSw4IEBA IHVzaW5nIG5hbWVzcGFjZSBzdGQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAordXNpbmcgbmFt ZXNwYWNlIEhUTUxOYW1lczsKKwogaW5saW5lIHN0YXRpYyBEZWNpbWFsIHNsaWRlclBvc2l0aW9u KEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpCiB7CiAgICAgY29uc3QgU3RlcFJhbmdlIHN0ZXBS YW5nZShlbGVtZW50LT5jcmVhdGVTdGVwUmFuZ2UoUmVqZWN0QW55KSk7CkBAIC0yNzAsNyArMjcy LDE5IEBAIHZvaWQgU2xpZGVyVGh1bWJFbGVtZW50OjpzZXRQb3NpdGlvbkZyb21Qb2ludChjb25z dCBMYXlvdXRQb2ludCYgcG9pbnQpCiAgICAgY29uc3QgRGVjaW1hbCByYXRpbyA9IERlY2ltYWw6 OmZyb21Eb3VibGUoc3RhdGljX2Nhc3Q8ZG91YmxlPihwb3NpdGlvbikgLyB0cmFja1NpemUpOwog ICAgIGNvbnN0IERlY2ltYWwgZnJhY3Rpb24gPSBpc1ZlcnRpY2FsIHx8ICFyZW5kZXJCb3goKS0+ c3R5bGUoKS0+aXNMZWZ0VG9SaWdodERpcmVjdGlvbigpID8gRGVjaW1hbCgxKSAtIHJhdGlvIDog cmF0aW87CiAgICAgU3RlcFJhbmdlIHN0ZXBSYW5nZShpbnB1dC0+Y3JlYXRlU3RlcFJhbmdlKFJl amVjdEFueSkpOwotICAgIGNvbnN0IERlY2ltYWwgdmFsdWUgPSBzdGVwUmFuZ2UuY2xhbXBWYWx1 ZShzdGVwUmFuZ2UudmFsdWVGcm9tUHJvcG9ydGlvbihmcmFjdGlvbikpOworICAgIERlY2ltYWwg dmFsdWUgPSBzdGVwUmFuZ2UuY2xhbXBWYWx1ZShzdGVwUmFuZ2UudmFsdWVGcm9tUHJvcG9ydGlv bihmcmFjdGlvbikpOworCisjaWYgRU5BQkxFKERBVEFMSVNUX0VMRU1FTlQpCisgICAgRGVjaW1h bCBjbG9zZXN0ID0gaW5wdXQtPmZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZSh2YWx1ZSk7CisgICAg aWYgKGNsb3Nlc3QuaXNGaW5pdGUoKSkgeworICAgICAgICBkb3VibGUgY2xvc2VzdEZyYWN0aW9u ID0gc3RlcFJhbmdlLnByb3BvcnRpb25Gcm9tVmFsdWUoY2xvc2VzdCkudG9Eb3VibGUoKTsKKyAg ICAgICAgZG91YmxlIGNsb3Nlc3RSYXRpbyA9IGlzVmVydGljYWwgfHwgIXJlbmRlckJveCgpLT5z dHlsZSgpLT5pc0xlZnRUb1JpZ2h0RGlyZWN0aW9uKCkgPyAxLjAgLSBjbG9zZXN0RnJhY3Rpb24g OiBjbG9zZXN0RnJhY3Rpb247CisgICAgICAgIGRvdWJsZSBjbG9zZXN0UG9zaXRpb24gPSB0cmFj a1NpemUgKiBjbG9zZXN0UmF0aW87CisgICAgICAgIGNvbnN0IGludCBzbmFwVGhyZXNob2xkID0g MzsKKyAgICAgICAgaWYgKGFicyhjbG9zZXN0UG9zaXRpb24gLSBzdGF0aWNfY2FzdDxkb3VibGU+ KHBvc2l0aW9uKSkgPCBzbmFwVGhyZXNob2xkKQorICAgICAgICAgICAgdmFsdWUgPSBjbG9zZXN0 OworICAgIH0KKyNlbmRpZgogCiAgICAgLy8gRklYTUU6IFRoaXMgaXMgbm8gbG9uZ2VyIGJlaW5n IHNldCBmcm9tIHJlbmRlcmVyLiBDb25zaWRlciB1cGRhdGluZyB0aGUgbWV0aG9kIG5hbWUuCiAg ICAgaW5wdXQtPnNldFZhbHVlRnJvbVJlbmRlcmVyKHNlcmlhbGl6ZUZvck51bWJlclR5cGUodmFs dWUpKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0No YW5nZUxvZwppbmRleCA0MzA1ZmZkYzMwY2IxYzdmNzY4NzBlNDA0Yzc5Y2NlZDM0YjQwZDcxLi5l YjczNWMxYjdmMzNhM2UyMmE5YTc5Yjk5NWM0MDU4YWQ5ZjEzNTJjIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTMgQEAKKzIwMTItMDgtMDEgIEtlaXNoaSBIYXR0b3JpICA8a2Vpc2hpQHdlYmtpdC5vcmc+CisK KyAgICAgICAgU2xpZGVyIHNob3VsZCBzbmFwIHRvIGRhdGFsaXN0IHRpY2sgbWFya3MKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkyNjQwCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBmYXN0L2Zvcm1zL2Rh dGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QuaHRtbDogQWRk ZWQuCisKIDIwMTItMDgtMDEgIFJheW1vbmQgVG95ICA8cnRveUBnb29nbGUuY29tPgogCiAgICAg ICAgIEVuYWJsZSBjb2RlYyB0ZXN0cyBpbiBUZXN0RXhwZWN0YXRpb25zIGFuZCB1cGRhdGUgZXhw ZWN0ZWQgbXAzIGZpbGVzCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2RhdGFs aXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0LWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5jMzVhOGUyYzJkMTY0MjIzMmMwZGY5NTFhM2IzNTZlZjlhOWMyNjA5Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRv LWRhdGFsaXN0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDI4IEBACitUZXN0cyBpZiBjbGlja2lu ZyBjbG9zZSB0byBhIHRpY2sgbWFyayBzbmFwcyB0byBpdC4KKworUEFTUyBpbnB1dC52YWx1ZSBp cyAiMCIKK1BBU1MgcGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA8IDUwMCBpcyB0cnVlCitQQVNT IGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBwYXJzZUludChpbnB1dC52YWx1ZSwgMTApIDwgNTAw IGlzIHRydWUKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIHBhcnNlSW50KGlucHV0LnZh bHVlLCAxMCkgPCA1MDAgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgaW5w dXQudmFsdWUgaXMgJzUwMCcKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIGlucHV0LnZh bHVlIGlzICc1MDAnCitQQVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBpbnB1dC52YWx1ZSBp cyAnNTAwJworUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgaW5wdXQudmFsdWUgaXMgJzUw MCcKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIGlucHV0LnZhbHVlIGlzICc1MDAnCitQ QVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBwYXJzZUludChpbnB1dC52YWx1ZSwgMTApID4g NTAwIGlzIHRydWUKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIHBhcnNlSW50KGlucHV0 LnZhbHVlLCAxMCkgPiA1MDAgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1Mg cGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+IDUwMCBpcyB0cnVlCitQQVNTIHN1Y2Nlc3NmdWxs eVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0Lmh0bWwgYi9MYXlv dXRUZXN0cy9mYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5iYWJmZWMxOWFhZTNlMmE3MzMwN2RkY2Y4YmYzNGY2MDJlMjUzNDc4Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFw LXRvLWRhdGFsaXN0Lmh0bWwKQEAgLTAsMCArMSw3MCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRt bD4KKzxoZWFkPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5q cyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+VGVzdHMg aWYgY2xpY2tpbmcgY2xvc2UgdG8gYSB0aWNrIG1hcmsgc25hcHMgdG8gaXQuPC9wPgorPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+Cis8aW5wdXQgaWQ9ImlucHV0IiB0eXBlPXJhbmdlIG1pbj0wIG1h eD0xMDAwIHN0ZXA9MSBsaXN0PXRhcmdldCBzdHlsZT0id2lkdGg6IDEwMHB4Ij4KKzxkYXRhbGlz dCBpZD0idGFyZ2V0Ij4KKyAgICA8b3B0aW9uPjUwMDwvb3B0aW9uPgorPC9kYXRhbGlzdD4KKzxz Y3JpcHQ+CisgICAgdmFyIGlucHV0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImlucHV0Iik7 CisgICAgdmFyIHRodW1iV2lkdGggPSAxNTsKKyAgICB2YXIgaGFsZlRodW1iV2lkdGggPSAodGh1 bWJXaWR0aCAtIDEpIC8gMjsKKyAgICBmdW5jdGlvbiBjbGlja1NsaWRlcihvZmZzZXRMZWZ0KSB7 CisgICAgICAgIHZhciBjZW50ZXJZID0gaW5wdXQub2Zmc2V0VG9wICsgaW5wdXQub2Zmc2V0SGVp Z2h0IC8gMjsKKyAgICAgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oaW5wdXQub2Zmc2V0TGVm dCArIG9mZnNldExlZnQsIGNlbnRlclkpOworICAgICAgICBldmVudFNlbmRlci5tb3VzZURvd24o KTsKKyAgICAgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworICAgIH0KKyAgICBmdW5jdGlvbiBy ZXNldFNsaWRlclBvc2l0aW9uKCkgeworICAgICAgICBjbGlja1NsaWRlcigwKTsKKyAgICAgICAg c2hvdWxkQmUoJ2lucHV0LnZhbHVlJywgJyIwIicpOworICAgIH0KKyAgICBmdW5jdGlvbiBleHBl Y3RlZFZhbHVlRm9yUG9zaXRpb24ocG9zKSB7CisgICAgICAgIGNsaWNrU2xpZGVyKHBvcyk7Cisg ICAgICAgIHZhciB2YWx1ZSA9IE1hdGgucm91bmQoKHBvcyAtIGhhbGZUaHVtYldpZHRoIC0gMC41 KSAvIChpbnB1dC5vZmZzZXRXaWR0aCAtIHRodW1iV2lkdGgpICogKGlucHV0Lm1heCAtIGlucHV0 Lm1pbikgKyBpbnB1dC5taW4pOworICAgICAgICB2YWx1ZSA9IE1hdGgubWF4KE1hdGgubWluKHZh bHVlLCBpbnB1dC5tYXgpLCBpbnB1dC5taW4pOworICAgICAgICByZXR1cm4gdmFsdWU7CisgICAg fQorICAgIHJlc2V0U2xpZGVyUG9zaXRpb24oKTsKKyAgICBjbGlja1NsaWRlcig0NSk7CisgICAg c2hvdWxkQmVUcnVlKCdwYXJzZUludChpbnB1dC52YWx1ZSwgMTApIDwgNTAwJyk7CisgICAgcmVz ZXRTbGlkZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVyKDQ2KTsKKyAgICBzaG91bGRCZVRy dWUoJ3BhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPCA1MDAnKTsKKyAgICByZXNldFNsaWRlclBv c2l0aW9uKCk7CisgICAgY2xpY2tTbGlkZXIoNDcpOworICAgIHNob3VsZEJlVHJ1ZSgncGFyc2VJ bnQoaW5wdXQudmFsdWUsIDEwKSA8IDUwMCcpOworICAgIHJlc2V0U2xpZGVyUG9zaXRpb24oKTsK KyAgICBjbGlja1NsaWRlcig0OCk7CisgICAgc2hvdWxkQmUoJ2lucHV0LnZhbHVlJywgIic1MDAn Iik7CisgICAgcmVzZXRTbGlkZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVyKDQ5KTsKKyAg ICBzaG91bGRCZSgnaW5wdXQudmFsdWUnLCAiJzUwMCciKTsKKyAgICByZXNldFNsaWRlclBvc2l0 aW9uKCk7CisgICAgY2xpY2tTbGlkZXIoNTApOworICAgIHNob3VsZEJlKCdpbnB1dC52YWx1ZScs ICInNTAwJyIpOworICAgIHJlc2V0U2xpZGVyUG9zaXRpb24oKTsKKyAgICBjbGlja1NsaWRlcig1 MSk7CisgICAgc2hvdWxkQmUoJ2lucHV0LnZhbHVlJywgIic1MDAnIik7CisgICAgcmVzZXRTbGlk ZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVyKDUyKTsKKyAgICBzaG91bGRCZSgnaW5wdXQu dmFsdWUnLCAiJzUwMCciKTsKKyAgICByZXNldFNsaWRlclBvc2l0aW9uKCk7CisgICAgY2xpY2tT bGlkZXIoNTMpOworICAgIHNob3VsZEJlVHJ1ZSgncGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+ IDUwMCcpOworICAgIHJlc2V0U2xpZGVyUG9zaXRpb24oKTsKKyAgICBjbGlja1NsaWRlcig1NCk7 CisgICAgc2hvdWxkQmVUcnVlKCdwYXJzZUludChpbnB1dC52YWx1ZSwgMTApID4gNTAwJyk7Cisg ICAgcmVzZXRTbGlkZXJQb3NpdGlvbigpOworICAgIGNsaWNrU2xpZGVyKDU1KTsKKyAgICBzaG91 bGRCZVRydWUoJ3BhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPiA1MDAnKTsKKzwvc2NyaXB0Pgor Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3Jp cHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 156010 2012-08-02 02:03:22 -0700 2012-08-02 03:36:43 -0700 Patch bug-92640-20120802180302.patch text/plain 14493 keishi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA2NGU2YTUyZDBiMmE2NWYyYTUzY2Y4MDBmMmUzZWM3Y2ViMDM2NDVmLi5h OWRlNGNkMjJiZTBkM2NiOTU0MjY4ZDczYmZmM2I1MTY1NWQ4ZTEyIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzcgQEAKKzIwMTItMDgtMDEgIEtlaXNoaSBIYXR0b3JpICA8a2Vpc2hpQHdlYmtpdC5v cmc+CisKKyAgICAgICAgU2xpZGVyIHNob3VsZCBzbmFwIHRvIGRhdGFsaXN0IHRpY2sgbWFya3MK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkyNjQwCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSW5wdXQgdHlw ZT1yYW5nZSBzbGlkZXIgc25hcHMgdG8gZGF0YWxpc3QgdGljayBtYXJrcy4KKworICAgICAgICBU ZXN0OiBmYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QuaHRtbAorCisg ICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxJbnB1dEVsZW1lbnQ6OmZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZSk6IEp1c3QgY2FsbHMgSW5w dXRUeXBlOjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUuCisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuaDoKKyAgICAgICAgKEhUTUxJbnB1dEVsZW1l bnQpOgorICAgICAgICAqIGh0bWwvSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6SW5wdXRUeXBlOjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUpOiBP dmVycmlkZGVuIGJ5IFJhbmdlSW5wdXRUeXBlLgorICAgICAgICAqIGh0bWwvSW5wdXRUeXBlLmg6 CisgICAgICAgIChJbnB1dFR5cGUpOgorICAgICAgICAqIGh0bWwvUmFuZ2VJbnB1dFR5cGUuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmFuZ2VJbnB1dFR5cGU6OlJhbmdlSW5wdXRUeXBlKToKKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6UmFuZ2VJbnB1dFR5cGU6Omxpc3RB dHRyaWJ1dGVUYXJnZXRDaGFuZ2VkKTogTWFyayBtX3RpY2tNYXJrVmFsdWVzIGFzIGRpcnR5Lgor ICAgICAgICAoV2ViQ29yZTo6ZGVjaW1hbENvbXBhcmUpOgorICAgICAgICAoV2ViQ29yZTo6UmFu Z2VJbnB1dFR5cGU6OnVwZGF0ZVRpY2tNYXJrVmFsdWVzKTogU2V0cyBtX3RpY2tNYXJrVmFsdWVz IHRvIGEgbGlzdCBvZiBzb3J0ZWQgdmFsaWQgZGF0YWxpc3QgdmFsdWVzLgorICAgICAgICAoV2Vi Q29yZTo6UmFuZ2VJbnB1dFR5cGU6OmZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZSk6IEZpbmRzIGNs b3Nlc3QgdGljayBtYXJrIHZhbHVlIHRvIGEgZ2l2ZW4gdmFsdWUuCisgICAgICAgICogaHRtbC9S YW5nZUlucHV0VHlwZS5oOgorICAgICAgICAoUmFuZ2VJbnB1dFR5cGUpOgorICAgICAgICAqIGh0 bWwvc2hhZG93L1NsaWRlclRodW1iRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKFdlYkNvcmU6OlNsaWRlclRodW1iRWxlbWVudDo6c2V0UG9zaXRpb25Gcm9tUG9pbnQp OiBTbmFwcyB0byB0aGUgY2xvc2VzdCB0aWNrIG1hcmsgdmFsdWUgaWYgaXQgaXMgd2l0aGluIGEg Y2VydGFpbiBkaXN0YW5jZS4KKwogMjAxMi0wOC0wMSAgTWlraGFpbCBQb3pkbnlha292ICA8bWlr aGFpbC5wb3pkbnlha292QGludGVsLmNvbT4KIAogICAgICAgICBbRUZMXSBDcmFzaCBhdCBXZWJD b3JlOjp0b1JlbmRlclNsaWRlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M SW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5j cHAKaW5kZXggMjE2ZDE3MjlmNDBkNTAyZTlhZjc3NmZkZDBlOWNlNzdiMjUzOWJmNS4uMmJiMWZl ZGFhZWM5NmQ1MGJlNDFlZDljYTAxYzllYWRhN2U1NGM0YyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC0zMTMsNiArMzEzLDEzIEBAIFN0ZXBSYW5nZSBIVE1M SW5wdXRFbGVtZW50OjpjcmVhdGVTdGVwUmFuZ2UoQW55U3RlcEhhbmRsaW5nIGFueVN0ZXBIYW5k bGluZykgY29uCiAgICAgcmV0dXJuIG1faW5wdXRUeXBlLT5jcmVhdGVTdGVwUmFuZ2UoYW55U3Rl cEhhbmRsaW5nKTsKIH0KIAorI2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQorRGVjaW1hbCBI VE1MSW5wdXRFbGVtZW50OjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUoY29uc3QgRGVjaW1hbCYg dmFsdWUpCit7CisgICAgcmV0dXJuIG1faW5wdXRUeXBlLT5maW5kQ2xvc2VzdFRpY2tNYXJrVmFs dWUodmFsdWUpOworfQorI2VuZGlmCisKIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c3RlcFVwKGlu dCBuLCBFeGNlcHRpb25Db2RlJiBlYykKIHsKICAgICBtX2lucHV0VHlwZS0+c3RlcFVwKG4sIGVj KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXggYmE1NDYwNDM1YTFk YzI1OTFmYmVlYmM1ZDg4Y2JlZGE5ZTlhYjY4ZC4uZGMzMjE1OWYyNTM5MGMyZDJjYTdiNmUyOGQz MmJiNTc0OGU3ZGIyMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRF bGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKQEAg LTcyLDYgKzcyLDEwIEBAIHB1YmxpYzoKICAgICBib29sIGdldEFsbG93ZWRWYWx1ZVN0ZXAoRGVj aW1hbCopIGNvbnN0OwogICAgIFN0ZXBSYW5nZSBjcmVhdGVTdGVwUmFuZ2UoQW55U3RlcEhhbmRs aW5nKSBjb25zdDsKIAorI2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQorICAgIERlY2ltYWwg ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKGNvbnN0IERlY2ltYWwmKTsKKyNlbmRpZgorCiAgICAg Ly8gSW1wbGVtZW50YXRpb25zIG9mIEhUTUxJbnB1dEVsZW1lbnQ6OnN0ZXBVcCgpIGFuZCBzdGVw RG93bigpLgogICAgIHZvaWQgc3RlcFVwKGludCwgRXhjZXB0aW9uQ29kZSYpOwogICAgIHZvaWQg c3RlcERvd24oaW50LCBFeGNlcHRpb25Db2RlJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9odG1sL0lucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAK aW5kZXggMDlhODk1YjUwMjg5YzVhYTFlMjI5ZjdmNGQ1ODMyNTc2ZTE5ODRkMi4uNjc0NTcyZTIx ZDFhZDE0N2I1MTY5ZjYwOGVhNTMzYWFiNzJhODYxMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvaHRtbC9JbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBl LmNwcApAQCAtOTA4LDYgKzkwOCwxMiBAQCBTdHJpbmcgSW5wdXRUeXBlOjpkZWZhdWx0VG9vbFRp cCgpIGNvbnN0CiB2b2lkIElucHV0VHlwZTo6bGlzdEF0dHJpYnV0ZVRhcmdldENoYW5nZWQoKQog ewogfQorCitEZWNpbWFsIElucHV0VHlwZTo6ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKGNvbnN0 IERlY2ltYWwmKQoreworICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiBEZWNp bWFsOjpuYW4oKTsKK30KICNlbmRpZgogCiBib29sIElucHV0VHlwZTo6c3VwcG9ydHNJbmRldGVy bWluYXRlQXBwZWFyYW5jZSgpIGNvbnN0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1s L0lucHV0VHlwZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaAppbmRleCAwMjQ1 YmE4ODgwYjNmMDcxYzYxNTliYmJkYThhZjM1YjJlYjAwZGM2Li5hNzNkZGJhMjcxNjE3YWIwOGU2 MDkxOTZjNDE0NTI0M2VmYWE0NzI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lu cHV0VHlwZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKQEAgLTI4MSw2 ICsyODEsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTdHJpbmcgZGVmYXVsdFRvb2xUaXAoKSBj b25zdDsKICNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKICAgICB2aXJ0dWFsIHZvaWQgbGlz dEF0dHJpYnV0ZVRhcmdldENoYW5nZWQoKTsKKyAgICB2aXJ0dWFsIERlY2ltYWwgZmluZENsb3Nl c3RUaWNrTWFya1ZhbHVlKGNvbnN0IERlY2ltYWwmKTsKICNlbmRpZgogCiAgICAgLy8gUGFyc2Vz IHRoZSBzcGVjaWZpZWQgc3RyaW5nIGZvciB0aGUgdHlwZSwgYW5kIHJldHVybgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcAppbmRleCA5MDFhOWFjYzFiMzdkNWYwNTYwNGY5MDM1 MDE3ZTk5NGJjNWJiNDViLi4wMzIwNGYzYmNkMzk2Mzc0MWJkYTAxYWFjZjc1ZjM4ZmZhODkzNjdm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcApAQCAtNTUsNiArNTUsMTIg QEAKICNpbmNsdWRlICJUb3VjaExpc3QuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKERBVEFMSVNU X0VMRU1FTlQpCisjaW5jbHVkZSAiSFRNTERhdGFMaXN0RWxlbWVudC5oIgorI2luY2x1ZGUgIkhU TUxPcHRpb25FbGVtZW50LmgiCisjaW5jbHVkZSA8d3RmL05vbkNvcHlpbmdTb3J0Lmg+CisjZW5k aWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiB1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOwpA QCAtNzYsNiArODIsMTQgQEAgUGFzc093blB0cjxJbnB1dFR5cGU+IFJhbmdlSW5wdXRUeXBlOjpj cmVhdGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKICAgICByZXR1cm4gYWRvcHRQdHIobmV3 IFJhbmdlSW5wdXRUeXBlKGVsZW1lbnQpKTsKIH0KIAorUmFuZ2VJbnB1dFR5cGU6OlJhbmdlSW5w dXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpCisgICAgOiBJbnB1dFR5cGUoZWxlbWVu dCkKKyNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKKyAgICAsIG1fdGlja01hcmtWYWx1ZXNE aXJ0eSh0cnVlKQorI2VuZGlmCit7Cit9CisKIGJvb2wgUmFuZ2VJbnB1dFR5cGU6OmlzUmFuZ2VD b250cm9sKCkgY29uc3QKIHsKICAgICByZXR1cm4gdHJ1ZTsKQEAgLTMxOSw4ICszMzMsNzEgQEAg SFRNTEVsZW1lbnQqIFJhbmdlSW5wdXRUeXBlOjpzbGlkZXJUaHVtYkVsZW1lbnQoKSBjb25zdAog I2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQogdm9pZCBSYW5nZUlucHV0VHlwZTo6bGlzdEF0 dHJpYnV0ZVRhcmdldENoYW5nZWQoKQogeworICAgIG1fdGlja01hcmtWYWx1ZXNEaXJ0eSA9IHRy dWU7CiAgICAgZWxlbWVudCgpLT5zZXROZWVkc1N0eWxlUmVjYWxjKCk7CiB9CisKK3N0YXRpYyBi b29sIGRlY2ltYWxDb21wYXJlKGNvbnN0IERlY2ltYWwmIGEsIGNvbnN0IERlY2ltYWwmIGIpCit7 CisgICAgcmV0dXJuIGEgPCBiOworfQorCit2b2lkIFJhbmdlSW5wdXRUeXBlOjp1cGRhdGVUaWNr TWFya1ZhbHVlcygpCit7CisgICAgaWYgKCFtX3RpY2tNYXJrVmFsdWVzRGlydHkpCisgICAgICAg IHJldHVybjsKKyAgICBtX3RpY2tNYXJrVmFsdWVzLmNsZWFyKCk7CisgICAgbV90aWNrTWFya1Zh bHVlc0RpcnR5ID0gZmFsc2U7CisgICAgSFRNTERhdGFMaXN0RWxlbWVudCogZGF0YUxpc3QgPSBl bGVtZW50KCktPmRhdGFMaXN0KCk7CisgICAgaWYgKCFkYXRhTGlzdCkKKyAgICAgICAgcmV0dXJu OworICAgIFJlZlB0cjxIVE1MQ29sbGVjdGlvbj4gb3B0aW9ucyA9IGRhdGFMaXN0LT5vcHRpb25z KCk7CisgICAgbV90aWNrTWFya1ZhbHVlcy5yZXNlcnZlQ2FwYWNpdHkob3B0aW9ucy0+bGVuZ3Ro KCkpOworICAgIFN0ZXBSYW5nZSBzdGVwUmFuZ2UoY3JlYXRlU3RlcFJhbmdlKFJlamVjdEFueSkp OworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBvcHRpb25zLT5sZW5ndGgoKTsgKytpKSB7 CisgICAgICAgIE5vZGUqIG5vZGUgPSBvcHRpb25zLT5pdGVtKGkpOworICAgICAgICBIVE1MT3B0 aW9uRWxlbWVudCogb3B0aW9uRWxlbWVudCA9IHRvSFRNTE9wdGlvbkVsZW1lbnQobm9kZSk7Cisg ICAgICAgIFN0cmluZyBvcHRpb25WYWx1ZSA9IG9wdGlvbkVsZW1lbnQtPnZhbHVlKCk7CisgICAg ICAgIGlmICghZWxlbWVudCgpLT5pc1ZhbGlkVmFsdWUob3B0aW9uVmFsdWUpKQorICAgICAgICAg ICAgY29udGludWU7CisgICAgICAgIG1fdGlja01hcmtWYWx1ZXMuYXBwZW5kKHBhcnNlVG9OdW1i ZXIob3B0aW9uVmFsdWUsIHN0ZXBSYW5nZS5kZWZhdWx0VmFsdWUoKSkpOworICAgIH0KKyAgICBt X3RpY2tNYXJrVmFsdWVzLnNocmlua1RvRml0KCk7CisgICAgbm9uQ29weWluZ1NvcnQobV90aWNr TWFya1ZhbHVlcy5iZWdpbigpLCBtX3RpY2tNYXJrVmFsdWVzLmVuZCgpLCBkZWNpbWFsQ29tcGFy ZSk7Cit9CisKK0RlY2ltYWwgUmFuZ2VJbnB1dFR5cGU6OmZpbmRDbG9zZXN0VGlja01hcmtWYWx1 ZShjb25zdCBEZWNpbWFsJiB2YWx1ZSkKK3sKKyAgICB1cGRhdGVUaWNrTWFya1ZhbHVlcygpOwor ICAgIGlmICghbV90aWNrTWFya1ZhbHVlcy5zaXplKCkpCisgICAgICAgIHJldHVybiBEZWNpbWFs OjpuYW4oKTsKKworICAgIHNpemVfdCBsZWZ0ID0gMDsKKyAgICBzaXplX3QgcmlnaHQgPSBtX3Rp Y2tNYXJrVmFsdWVzLnNpemUoKTsKKyAgICBzaXplX3QgbWlkZGxlOworICAgIHdoaWxlICh0cnVl KSB7CisgICAgICAgIEFTU0VSVChsZWZ0IDw9IHJpZ2h0KTsKKyAgICAgICAgbWlkZGxlID0gbGVm dCArIChyaWdodCAtIGxlZnQpIC8gMjsKKyAgICAgICAgaWYgKCFtaWRkbGUpCisgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgaWYgKG1pZGRsZSA9PSBtX3RpY2tNYXJrVmFsdWVzLnNpemUoKSAt IDEgJiYgbV90aWNrTWFya1ZhbHVlc1ttaWRkbGVdIDwgdmFsdWUpIHsKKyAgICAgICAgICAgIG1p ZGRsZSsrOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICAgICAgaWYgKG1fdGlj a01hcmtWYWx1ZXNbbWlkZGxlIC0gMV0gPD0gdmFsdWUgJiYgbV90aWNrTWFya1ZhbHVlc1ttaWRk bGVdID49IHZhbHVlKQorICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgaWYgKG1fdGlja01h cmtWYWx1ZXNbbWlkZGxlXSA8IHZhbHVlKQorICAgICAgICAgICAgbGVmdCA9IG1pZGRsZTsKKyAg ICAgICAgZWxzZQorICAgICAgICAgICAgcmlnaHQgPSBtaWRkbGU7CisgICAgfQorICAgIGNvbnN0 IERlY2ltYWwgY2xvc2VzdExlZnQgPSBtaWRkbGUgPyBtX3RpY2tNYXJrVmFsdWVzW21pZGRsZSAt IDFdIDogRGVjaW1hbDo6aW5maW5pdHkoRGVjaW1hbDo6TmVnYXRpdmUpOworICAgIGNvbnN0IERl Y2ltYWwgY2xvc2VzdFJpZ2h0ID0gbWlkZGxlICE9IG1fdGlja01hcmtWYWx1ZXMuc2l6ZSgpID8g bV90aWNrTWFya1ZhbHVlc1ttaWRkbGVdIDogRGVjaW1hbDo6aW5maW5pdHkoRGVjaW1hbDo6UG9z aXRpdmUpOworICAgIGlmIChjbG9zZXN0UmlnaHQgLSB2YWx1ZSA8IHZhbHVlIC0gY2xvc2VzdExl ZnQpCisgICAgICAgIHJldHVybiBjbG9zZXN0UmlnaHQ7CisgICAgcmV0dXJuIGNsb3Nlc3RMZWZ0 OworfQogI2VuZGlmCiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvUmFuZ2VJbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvUmFu Z2VJbnB1dFR5cGUuaAppbmRleCA2OWQyZWM3YzZjYzE5ZDEwMzYxNTQyMDMzYmNmZDY3MTQ4NDg2 Mjg3Li44MzY3YjZmZWYxZWUwNDUwMDc4ZjE3YTA5ODIzODRlMTcwYzUwMzQxIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmgKKysrIGIvU291cmNlL1dlYkNv cmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oCkBAIC00Miw3ICs0Miw3IEBAIHB1YmxpYzoKICAgICBz dGF0aWMgUGFzc093blB0cjxJbnB1dFR5cGU+IGNyZWF0ZShIVE1MSW5wdXRFbGVtZW50Kik7CiAK IHByaXZhdGU6Ci0gICAgUmFuZ2VJbnB1dFR5cGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkg OiBJbnB1dFR5cGUoZWxlbWVudCkgeyB9CisgICAgUmFuZ2VJbnB1dFR5cGUoSFRNTElucHV0RWxl bWVudCopOwogICAgIHZpcnR1YWwgYm9vbCBpc1JhbmdlQ29udHJvbCgpIGNvbnN0IE9WRVJSSURF OwogICAgIHZpcnR1YWwgY29uc3QgQXRvbWljU3RyaW5nJiBmb3JtQ29udHJvbFR5cGUoKSBjb25z dCBPVkVSUklERTsKICAgICB2aXJ0dWFsIGRvdWJsZSB2YWx1ZUFzRG91YmxlKCkgY29uc3QgT1ZF UlJJREU7CkBAIC03Miw2ICs3MiwxMSBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgSFRNTEVsZW1l bnQqIHNsaWRlclRodW1iRWxlbWVudCgpIGNvbnN0IE9WRVJSSURFOwogI2lmIEVOQUJMRShEQVRB TElTVF9FTEVNRU5UKQogICAgIHZpcnR1YWwgdm9pZCBsaXN0QXR0cmlidXRlVGFyZ2V0Q2hhbmdl ZCgpIE9WRVJSSURFOworICAgIHZvaWQgdXBkYXRlVGlja01hcmtWYWx1ZXMoKTsKKyAgICB2aXJ0 dWFsIERlY2ltYWwgZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKGNvbnN0IERlY2ltYWwmKSBPVkVS UklERTsKKworICAgIGJvb2wgbV90aWNrTWFya1ZhbHVlc0RpcnR5OworICAgIFZlY3RvcjxEZWNp bWFsPiBtX3RpY2tNYXJrVmFsdWVzOwogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNv cmUvaHRtbC9zaGFkb3cvU2xpZGVyVGh1bWJFbGVtZW50LmNwcAppbmRleCAzNjIyMWRkZDdlNTQ3 ZWUxNThiMTYyNTA1ZGM4ZWNjMDRjYzBlMTk5Li4yNTM4YWY3MTg4ODdmNmUzOGQ5ZjU4ODQ3OWRk ZGU1ZWVhMjRkNDg2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9TbGlk ZXJUaHVtYkVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1NsaWRl clRodW1iRWxlbWVudC5jcHAKQEAgLTUxLDYgKzUxLDggQEAgdXNpbmcgbmFtZXNwYWNlIHN0ZDsK IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOworCiBp bmxpbmUgc3RhdGljIERlY2ltYWwgc2xpZGVyUG9zaXRpb24oSFRNTElucHV0RWxlbWVudCogZWxl bWVudCkKIHsKICAgICBjb25zdCBTdGVwUmFuZ2Ugc3RlcFJhbmdlKGVsZW1lbnQtPmNyZWF0ZVN0 ZXBSYW5nZShSZWplY3RBbnkpKTsKQEAgLTI3MCw3ICsyNzIsMTkgQEAgdm9pZCBTbGlkZXJUaHVt YkVsZW1lbnQ6OnNldFBvc2l0aW9uRnJvbVBvaW50KGNvbnN0IExheW91dFBvaW50JiBwb2ludCkK ICAgICBjb25zdCBEZWNpbWFsIHJhdGlvID0gRGVjaW1hbDo6ZnJvbURvdWJsZShzdGF0aWNfY2Fz dDxkb3VibGU+KHBvc2l0aW9uKSAvIHRyYWNrU2l6ZSk7CiAgICAgY29uc3QgRGVjaW1hbCBmcmFj dGlvbiA9IGlzVmVydGljYWwgfHwgIXJlbmRlckJveCgpLT5zdHlsZSgpLT5pc0xlZnRUb1JpZ2h0 RGlyZWN0aW9uKCkgPyBEZWNpbWFsKDEpIC0gcmF0aW8gOiByYXRpbzsKICAgICBTdGVwUmFuZ2Ug c3RlcFJhbmdlKGlucHV0LT5jcmVhdGVTdGVwUmFuZ2UoUmVqZWN0QW55KSk7Ci0gICAgY29uc3Qg RGVjaW1hbCB2YWx1ZSA9IHN0ZXBSYW5nZS5jbGFtcFZhbHVlKHN0ZXBSYW5nZS52YWx1ZUZyb21Q cm9wb3J0aW9uKGZyYWN0aW9uKSk7CisgICAgRGVjaW1hbCB2YWx1ZSA9IHN0ZXBSYW5nZS5jbGFt cFZhbHVlKHN0ZXBSYW5nZS52YWx1ZUZyb21Qcm9wb3J0aW9uKGZyYWN0aW9uKSk7CisKKyNpZiBF TkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKKyAgICBEZWNpbWFsIGNsb3Nlc3QgPSBpbnB1dC0+Zmlu ZENsb3Nlc3RUaWNrTWFya1ZhbHVlKHZhbHVlKTsKKyAgICBpZiAoY2xvc2VzdC5pc0Zpbml0ZSgp KSB7CisgICAgICAgIGRvdWJsZSBjbG9zZXN0RnJhY3Rpb24gPSBzdGVwUmFuZ2UucHJvcG9ydGlv bkZyb21WYWx1ZShjbG9zZXN0KS50b0RvdWJsZSgpOworICAgICAgICBkb3VibGUgY2xvc2VzdFJh dGlvID0gaXNWZXJ0aWNhbCB8fCAhcmVuZGVyQm94KCktPnN0eWxlKCktPmlzTGVmdFRvUmlnaHRE aXJlY3Rpb24oKSA/IDEuMCAtIGNsb3Nlc3RGcmFjdGlvbiA6IGNsb3Nlc3RGcmFjdGlvbjsKKyAg ICAgICAgZG91YmxlIGNsb3Nlc3RQb3NpdGlvbiA9IHRyYWNrU2l6ZSAqIGNsb3Nlc3RSYXRpbzsK KyAgICAgICAgY29uc3QgaW50IHNuYXBUaHJlc2hvbGQgPSAzOworICAgICAgICBpZiAoYWJzKGNs b3Nlc3RQb3NpdGlvbiAtIHN0YXRpY19jYXN0PGRvdWJsZT4ocG9zaXRpb24pKSA8IHNuYXBUaHJl c2hvbGQpCisgICAgICAgICAgICB2YWx1ZSA9IGNsb3Nlc3Q7CisgICAgfQorI2VuZGlmCiAKICAg ICAvLyBGSVhNRTogVGhpcyBpcyBubyBsb25nZXIgYmVpbmcgc2V0IGZyb20gcmVuZGVyZXIuIENv bnNpZGVyIHVwZGF0aW5nIHRoZSBtZXRob2QgbmFtZS4KICAgICBpbnB1dC0+c2V0VmFsdWVGcm9t UmVuZGVyZXIoc2VyaWFsaXplRm9yTnVtYmVyVHlwZSh2YWx1ZSkpOwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDQzMDVmZmRj MzBjYjFjN2Y3Njg3MGU0MDRjNzljY2VkMzRiNDBkNzEuLmViNzM1YzFiN2YzM2EzZTIyYTlhNzli OTk1YzQwNThhZDlmMTM1MmMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysg Yi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxMi0wOC0wMSAgS2Vp c2hpIEhhdHRvcmkgIDxrZWlzaGlAd2Via2l0Lm9yZz4KKworICAgICAgICBTbGlkZXIgc2hvdWxk IHNuYXAgdG8gZGF0YWxpc3QgdGljayBtYXJrcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTI2NDAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvZm9ybXMvZGF0YWxpc3QvcmFuZ2Utc25hcC10by1k YXRhbGlzdC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZm9ybXMvZGF0YWxp c3QvcmFuZ2Utc25hcC10by1kYXRhbGlzdC5odG1sOiBBZGRlZC4KKwogMjAxMi0wOC0wMSAgUmF5 bW9uZCBUb3kgIDxydG95QGdvb2dsZS5jb20+CiAKICAgICAgICAgRW5hYmxlIGNvZGVjIHRlc3Rz IGluIFRlc3RFeHBlY3RhdGlvbnMgYW5kIHVwZGF0ZSBleHBlY3RlZCBtcDMgZmlsZXMKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvZGF0YWxpc3QvcmFuZ2Utc25hcC10by1kYXRh bGlzdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2RhdGFsaXN0L3Jhbmdl LXNuYXAtdG8tZGF0YWxpc3QtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmMzNWE4ZTJjMmQxNjQy MjMyYzBkZjk1MWEzYjM1NmVmOWE5YzI2MDkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsMjggQEAKK1Rlc3RzIGlmIGNsaWNraW5nIGNsb3NlIHRvIGEgdGljayBtYXJr IHNuYXBzIHRvIGl0LgorCitQQVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBwYXJzZUludChp bnB1dC52YWx1ZSwgMTApIDwgNTAwIGlzIHRydWUKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQ QVNTIHBhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPCA1MDAgaXMgdHJ1ZQorUEFTUyBpbnB1dC52 YWx1ZSBpcyAiMCIKK1BBU1MgcGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA8IDUwMCBpcyB0cnVl CitQQVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBpbnB1dC52YWx1ZSBpcyAnNTAwJworUEFT UyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgaW5wdXQudmFsdWUgaXMgJzUwMCcKK1BBU1MgaW5w dXQudmFsdWUgaXMgIjAiCitQQVNTIGlucHV0LnZhbHVlIGlzICc1MDAnCitQQVNTIGlucHV0LnZh bHVlIGlzICIwIgorUEFTUyBpbnB1dC52YWx1ZSBpcyAnNTAwJworUEFTUyBpbnB1dC52YWx1ZSBp cyAiMCIKK1BBU1MgaW5wdXQudmFsdWUgaXMgJzUwMCcKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAi CitQQVNTIHBhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPiA1MDAgaXMgdHJ1ZQorUEFTUyBpbnB1 dC52YWx1ZSBpcyAiMCIKK1BBU1MgcGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+IDUwMCBpcyB0 cnVlCitQQVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBwYXJzZUludChpbnB1dC52YWx1ZSwg MTApID4gNTAwIGlzIHRydWUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVT VCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2RhdGFsaXN0 L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvZGF0 YWxpc3QvcmFuZ2Utc25hcC10by1kYXRhbGlzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjAyZmYwZjFlZjlm NWI0ZjI0YzAwMjgwNWI3ZmZjNzRjZDNiM2M2NGUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QuaHRtbApAQCAt MCwwICsxLDYyIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4K Kzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj5UZXN0cyBpZiBjbGlja2luZyBjbG9zZSB0byBh IHRpY2sgbWFyayBzbmFwcyB0byBpdC48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxp bnB1dCBpZD0iaW5wdXQiIHR5cGU9cmFuZ2UgbWluPTAgbWF4PTEwMDAgc3RlcD0xIGxpc3Q9dGFy Z2V0IHN0eWxlPSJ3aWR0aDogMTAwcHgiPgorPGRhdGFsaXN0IGlkPSJ0YXJnZXQiPgorICAgIDxv cHRpb24+NTAwPC9vcHRpb24+Cis8L2RhdGFsaXN0PgorPHNjcmlwdD4KK3ZhciBpbnB1dCA9IGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJpbnB1dCIpOworZnVuY3Rpb24gY2xpY2tTbGlkZXIob2Zm c2V0TGVmdCkgeworICAgIHZhciBjZW50ZXJZID0gaW5wdXQub2Zmc2V0VG9wICsgaW5wdXQub2Zm c2V0SGVpZ2h0IC8gMjsKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyhpbnB1dC5vZmZzZXRM ZWZ0ICsgb2Zmc2V0TGVmdCwgY2VudGVyWSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7 CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworfQorZnVuY3Rpb24gcmVzZXRTbGlkZXJQb3Np dGlvbigpIHsKKyAgICBjbGlja1NsaWRlcigwKTsKKyAgICBzaG91bGRCZSgnaW5wdXQudmFsdWUn LCAnIjAiJyk7Cit9CityZXNldFNsaWRlclBvc2l0aW9uKCk7CitjbGlja1NsaWRlcig0NSk7Citz aG91bGRCZVRydWUoJ3BhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPCA1MDAnKTsKK3Jlc2V0U2xp ZGVyUG9zaXRpb24oKTsKK2NsaWNrU2xpZGVyKDQ2KTsKK3Nob3VsZEJlVHJ1ZSgncGFyc2VJbnQo aW5wdXQudmFsdWUsIDEwKSA8IDUwMCcpOworcmVzZXRTbGlkZXJQb3NpdGlvbigpOworY2xpY2tT bGlkZXIoNDcpOworc2hvdWxkQmVUcnVlKCdwYXJzZUludChpbnB1dC52YWx1ZSwgMTApIDwgNTAw Jyk7CityZXNldFNsaWRlclBvc2l0aW9uKCk7CitjbGlja1NsaWRlcig0OCk7CitzaG91bGRCZSgn aW5wdXQudmFsdWUnLCAiJzUwMCciKTsKK3Jlc2V0U2xpZGVyUG9zaXRpb24oKTsKK2NsaWNrU2xp ZGVyKDQ5KTsKK3Nob3VsZEJlKCdpbnB1dC52YWx1ZScsICInNTAwJyIpOworcmVzZXRTbGlkZXJQ b3NpdGlvbigpOworY2xpY2tTbGlkZXIoNTApOworc2hvdWxkQmUoJ2lucHV0LnZhbHVlJywgIic1 MDAnIik7CityZXNldFNsaWRlclBvc2l0aW9uKCk7CitjbGlja1NsaWRlcig1MSk7CitzaG91bGRC ZSgnaW5wdXQudmFsdWUnLCAiJzUwMCciKTsKK3Jlc2V0U2xpZGVyUG9zaXRpb24oKTsKK2NsaWNr U2xpZGVyKDUyKTsKK3Nob3VsZEJlKCdpbnB1dC52YWx1ZScsICInNTAwJyIpOworcmVzZXRTbGlk ZXJQb3NpdGlvbigpOworY2xpY2tTbGlkZXIoNTMpOworc2hvdWxkQmVUcnVlKCdwYXJzZUludChp bnB1dC52YWx1ZSwgMTApID4gNTAwJyk7CityZXNldFNsaWRlclBvc2l0aW9uKCk7CitjbGlja1Ns aWRlcig1NCk7CitzaG91bGRCZVRydWUoJ3BhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPiA1MDAn KTsKK3Jlc2V0U2xpZGVyUG9zaXRpb24oKTsKK2NsaWNrU2xpZGVyKDU1KTsKK3Nob3VsZEJlVHJ1 ZSgncGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+IDUwMCcpOworPC9zY3JpcHQ+CisKKzxzY3Jp cHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4K 156028 2012-08-02 03:36:49 -0700 2012-08-02 19:06:06 -0700 Patch bug-92640-20120802193629.patch text/plain 14422 keishi ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA2NGU2YTUyZDBiMmE2NWYyYTUzY2Y4MDBmMmUzZWM3Y2ViMDM2NDVmLi5h OWRlNGNkMjJiZTBkM2NiOTU0MjY4ZDczYmZmM2I1MTY1NWQ4ZTEyIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzcgQEAKKzIwMTItMDgtMDEgIEtlaXNoaSBIYXR0b3JpICA8a2Vpc2hpQHdlYmtpdC5v cmc+CisKKyAgICAgICAgU2xpZGVyIHNob3VsZCBzbmFwIHRvIGRhdGFsaXN0IHRpY2sgbWFya3MK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkyNjQwCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSW5wdXQgdHlw ZT1yYW5nZSBzbGlkZXIgc25hcHMgdG8gZGF0YWxpc3QgdGljayBtYXJrcy4KKworICAgICAgICBU ZXN0OiBmYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QuaHRtbAorCisg ICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxJbnB1dEVsZW1lbnQ6OmZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZSk6IEp1c3QgY2FsbHMgSW5w dXRUeXBlOjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUuCisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuaDoKKyAgICAgICAgKEhUTUxJbnB1dEVsZW1l bnQpOgorICAgICAgICAqIGh0bWwvSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6SW5wdXRUeXBlOjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUpOiBP dmVycmlkZGVuIGJ5IFJhbmdlSW5wdXRUeXBlLgorICAgICAgICAqIGh0bWwvSW5wdXRUeXBlLmg6 CisgICAgICAgIChJbnB1dFR5cGUpOgorICAgICAgICAqIGh0bWwvUmFuZ2VJbnB1dFR5cGUuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmFuZ2VJbnB1dFR5cGU6OlJhbmdlSW5wdXRUeXBlKToKKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6UmFuZ2VJbnB1dFR5cGU6Omxpc3RB dHRyaWJ1dGVUYXJnZXRDaGFuZ2VkKTogTWFyayBtX3RpY2tNYXJrVmFsdWVzIGFzIGRpcnR5Lgor ICAgICAgICAoV2ViQ29yZTo6ZGVjaW1hbENvbXBhcmUpOgorICAgICAgICAoV2ViQ29yZTo6UmFu Z2VJbnB1dFR5cGU6OnVwZGF0ZVRpY2tNYXJrVmFsdWVzKTogU2V0cyBtX3RpY2tNYXJrVmFsdWVz IHRvIGEgbGlzdCBvZiBzb3J0ZWQgdmFsaWQgZGF0YWxpc3QgdmFsdWVzLgorICAgICAgICAoV2Vi Q29yZTo6UmFuZ2VJbnB1dFR5cGU6OmZpbmRDbG9zZXN0VGlja01hcmtWYWx1ZSk6IEZpbmRzIGNs b3Nlc3QgdGljayBtYXJrIHZhbHVlIHRvIGEgZ2l2ZW4gdmFsdWUuCisgICAgICAgICogaHRtbC9S YW5nZUlucHV0VHlwZS5oOgorICAgICAgICAoUmFuZ2VJbnB1dFR5cGUpOgorICAgICAgICAqIGh0 bWwvc2hhZG93L1NsaWRlclRodW1iRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKFdlYkNvcmU6OlNsaWRlclRodW1iRWxlbWVudDo6c2V0UG9zaXRpb25Gcm9tUG9pbnQp OiBTbmFwcyB0byB0aGUgY2xvc2VzdCB0aWNrIG1hcmsgdmFsdWUgaWYgaXQgaXMgd2l0aGluIGEg Y2VydGFpbiBkaXN0YW5jZS4KKwogMjAxMi0wOC0wMSAgTWlraGFpbCBQb3pkbnlha292ICA8bWlr aGFpbC5wb3pkbnlha292QGludGVsLmNvbT4KIAogICAgICAgICBbRUZMXSBDcmFzaCBhdCBXZWJD b3JlOjp0b1JlbmRlclNsaWRlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M SW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5j cHAKaW5kZXggMjE2ZDE3MjlmNDBkNTAyZTlhZjc3NmZkZDBlOWNlNzdiMjUzOWJmNS4uMmJiMWZl ZGFhZWM5NmQ1MGJlNDFlZDljYTAxYzllYWRhN2U1NGM0YyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC0zMTMsNiArMzEzLDEzIEBAIFN0ZXBSYW5nZSBIVE1M SW5wdXRFbGVtZW50OjpjcmVhdGVTdGVwUmFuZ2UoQW55U3RlcEhhbmRsaW5nIGFueVN0ZXBIYW5k bGluZykgY29uCiAgICAgcmV0dXJuIG1faW5wdXRUeXBlLT5jcmVhdGVTdGVwUmFuZ2UoYW55U3Rl cEhhbmRsaW5nKTsKIH0KIAorI2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQorRGVjaW1hbCBI VE1MSW5wdXRFbGVtZW50OjpmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUoY29uc3QgRGVjaW1hbCYg dmFsdWUpCit7CisgICAgcmV0dXJuIG1faW5wdXRUeXBlLT5maW5kQ2xvc2VzdFRpY2tNYXJrVmFs dWUodmFsdWUpOworfQorI2VuZGlmCisKIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c3RlcFVwKGlu dCBuLCBFeGNlcHRpb25Db2RlJiBlYykKIHsKICAgICBtX2lucHV0VHlwZS0+c3RlcFVwKG4sIGVj KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXggYmE1NDYwNDM1YTFk YzI1OTFmYmVlYmM1ZDg4Y2JlZGE5ZTlhYjY4ZC4uZGMzMjE1OWYyNTM5MGMyZDJjYTdiNmUyOGQz MmJiNTc0OGU3ZGIyMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRF bGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKQEAg LTcyLDYgKzcyLDEwIEBAIHB1YmxpYzoKICAgICBib29sIGdldEFsbG93ZWRWYWx1ZVN0ZXAoRGVj aW1hbCopIGNvbnN0OwogICAgIFN0ZXBSYW5nZSBjcmVhdGVTdGVwUmFuZ2UoQW55U3RlcEhhbmRs aW5nKSBjb25zdDsKIAorI2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQorICAgIERlY2ltYWwg ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKGNvbnN0IERlY2ltYWwmKTsKKyNlbmRpZgorCiAgICAg Ly8gSW1wbGVtZW50YXRpb25zIG9mIEhUTUxJbnB1dEVsZW1lbnQ6OnN0ZXBVcCgpIGFuZCBzdGVw RG93bigpLgogICAgIHZvaWQgc3RlcFVwKGludCwgRXhjZXB0aW9uQ29kZSYpOwogICAgIHZvaWQg c3RlcERvd24oaW50LCBFeGNlcHRpb25Db2RlJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9odG1sL0lucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAK aW5kZXggMDlhODk1YjUwMjg5YzVhYTFlMjI5ZjdmNGQ1ODMyNTc2ZTE5ODRkMi4uNjc0NTcyZTIx ZDFhZDE0N2I1MTY5ZjYwOGVhNTMzYWFiNzJhODYxMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvaHRtbC9JbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBl LmNwcApAQCAtOTA4LDYgKzkwOCwxMiBAQCBTdHJpbmcgSW5wdXRUeXBlOjpkZWZhdWx0VG9vbFRp cCgpIGNvbnN0CiB2b2lkIElucHV0VHlwZTo6bGlzdEF0dHJpYnV0ZVRhcmdldENoYW5nZWQoKQog ewogfQorCitEZWNpbWFsIElucHV0VHlwZTo6ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKGNvbnN0 IERlY2ltYWwmKQoreworICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiBEZWNp bWFsOjpuYW4oKTsKK30KICNlbmRpZgogCiBib29sIElucHV0VHlwZTo6c3VwcG9ydHNJbmRldGVy bWluYXRlQXBwZWFyYW5jZSgpIGNvbnN0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1s L0lucHV0VHlwZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaAppbmRleCAwMjQ1 YmE4ODgwYjNmMDcxYzYxNTliYmJkYThhZjM1YjJlYjAwZGM2Li5hNzNkZGJhMjcxNjE3YWIwOGU2 MDkxOTZjNDE0NTI0M2VmYWE0NzI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lu cHV0VHlwZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKQEAgLTI4MSw2 ICsyODEsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTdHJpbmcgZGVmYXVsdFRvb2xUaXAoKSBj b25zdDsKICNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKICAgICB2aXJ0dWFsIHZvaWQgbGlz dEF0dHJpYnV0ZVRhcmdldENoYW5nZWQoKTsKKyAgICB2aXJ0dWFsIERlY2ltYWwgZmluZENsb3Nl c3RUaWNrTWFya1ZhbHVlKGNvbnN0IERlY2ltYWwmKTsKICNlbmRpZgogCiAgICAgLy8gUGFyc2Vz IHRoZSBzcGVjaWZpZWQgc3RyaW5nIGZvciB0aGUgdHlwZSwgYW5kIHJldHVybgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcAppbmRleCA5MDFhOWFjYzFiMzdkNWYwNTYwNGY5MDM1 MDE3ZTk5NGJjNWJiNDViLi5hZTY5NmU2ZGYzZTRlZDYyODdjNWVlNDIxYTQwNmE5ZTU5Y2U2YjY4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL1JhbmdlSW5wdXRUeXBlLmNwcApAQCAtNTUsNiArNTUsMTIg QEAKICNpbmNsdWRlICJUb3VjaExpc3QuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKERBVEFMSVNU X0VMRU1FTlQpCisjaW5jbHVkZSAiSFRNTERhdGFMaXN0RWxlbWVudC5oIgorI2luY2x1ZGUgIkhU TUxPcHRpb25FbGVtZW50LmgiCisjaW5jbHVkZSA8d3RmL05vbkNvcHlpbmdTb3J0Lmg+CisjZW5k aWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiB1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOwpA QCAtNzYsNiArODIsMTQgQEAgUGFzc093blB0cjxJbnB1dFR5cGU+IFJhbmdlSW5wdXRUeXBlOjpj cmVhdGUoSFRNTElucHV0RWxlbWVudCogZWxlbWVudCkKICAgICByZXR1cm4gYWRvcHRQdHIobmV3 IFJhbmdlSW5wdXRUeXBlKGVsZW1lbnQpKTsKIH0KIAorUmFuZ2VJbnB1dFR5cGU6OlJhbmdlSW5w dXRUeXBlKEhUTUxJbnB1dEVsZW1lbnQqIGVsZW1lbnQpCisgICAgOiBJbnB1dFR5cGUoZWxlbWVu dCkKKyNpZiBFTkFCTEUoREFUQUxJU1RfRUxFTUVOVCkKKyAgICAsIG1fdGlja01hcmtWYWx1ZXNE aXJ0eSh0cnVlKQorI2VuZGlmCit7Cit9CisKIGJvb2wgUmFuZ2VJbnB1dFR5cGU6OmlzUmFuZ2VD b250cm9sKCkgY29uc3QKIHsKICAgICByZXR1cm4gdHJ1ZTsKQEAgLTMxOSw4ICszMzMsNzAgQEAg SFRNTEVsZW1lbnQqIFJhbmdlSW5wdXRUeXBlOjpzbGlkZXJUaHVtYkVsZW1lbnQoKSBjb25zdAog I2lmIEVOQUJMRShEQVRBTElTVF9FTEVNRU5UKQogdm9pZCBSYW5nZUlucHV0VHlwZTo6bGlzdEF0 dHJpYnV0ZVRhcmdldENoYW5nZWQoKQogeworICAgIG1fdGlja01hcmtWYWx1ZXNEaXJ0eSA9IHRy dWU7CiAgICAgZWxlbWVudCgpLT5zZXROZWVkc1N0eWxlUmVjYWxjKCk7CiB9CisKK3N0YXRpYyBi b29sIGRlY2ltYWxDb21wYXJlKGNvbnN0IERlY2ltYWwmIGEsIGNvbnN0IERlY2ltYWwmIGIpCit7 CisgICAgcmV0dXJuIGEgPCBiOworfQorCit2b2lkIFJhbmdlSW5wdXRUeXBlOjp1cGRhdGVUaWNr TWFya1ZhbHVlcygpCit7CisgICAgaWYgKCFtX3RpY2tNYXJrVmFsdWVzRGlydHkpCisgICAgICAg IHJldHVybjsKKyAgICBtX3RpY2tNYXJrVmFsdWVzLmNsZWFyKCk7CisgICAgbV90aWNrTWFya1Zh bHVlc0RpcnR5ID0gZmFsc2U7CisgICAgSFRNTERhdGFMaXN0RWxlbWVudCogZGF0YUxpc3QgPSBl bGVtZW50KCktPmRhdGFMaXN0KCk7CisgICAgaWYgKCFkYXRhTGlzdCkKKyAgICAgICAgcmV0dXJu OworICAgIFJlZlB0cjxIVE1MQ29sbGVjdGlvbj4gb3B0aW9ucyA9IGRhdGFMaXN0LT5vcHRpb25z KCk7CisgICAgbV90aWNrTWFya1ZhbHVlcy5yZXNlcnZlQ2FwYWNpdHkob3B0aW9ucy0+bGVuZ3Ro KCkpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBvcHRpb25zLT5sZW5ndGgoKTsgKytp KSB7CisgICAgICAgIE5vZGUqIG5vZGUgPSBvcHRpb25zLT5pdGVtKGkpOworICAgICAgICBIVE1M T3B0aW9uRWxlbWVudCogb3B0aW9uRWxlbWVudCA9IHRvSFRNTE9wdGlvbkVsZW1lbnQobm9kZSk7 CisgICAgICAgIFN0cmluZyBvcHRpb25WYWx1ZSA9IG9wdGlvbkVsZW1lbnQtPnZhbHVlKCk7Cisg ICAgICAgIGlmICghZWxlbWVudCgpLT5pc1ZhbGlkVmFsdWUob3B0aW9uVmFsdWUpKQorICAgICAg ICAgICAgY29udGludWU7CisgICAgICAgIG1fdGlja01hcmtWYWx1ZXMuYXBwZW5kKHBhcnNlVG9O dW1iZXIob3B0aW9uVmFsdWUsIERlY2ltYWw6Om5hbigpKSk7CisgICAgfQorICAgIG1fdGlja01h cmtWYWx1ZXMuc2hyaW5rVG9GaXQoKTsKKyAgICBub25Db3B5aW5nU29ydChtX3RpY2tNYXJrVmFs dWVzLmJlZ2luKCksIG1fdGlja01hcmtWYWx1ZXMuZW5kKCksIGRlY2ltYWxDb21wYXJlKTsKK30K KworRGVjaW1hbCBSYW5nZUlucHV0VHlwZTo6ZmluZENsb3Nlc3RUaWNrTWFya1ZhbHVlKGNvbnN0 IERlY2ltYWwmIHZhbHVlKQoreworICAgIHVwZGF0ZVRpY2tNYXJrVmFsdWVzKCk7CisgICAgaWYg KCFtX3RpY2tNYXJrVmFsdWVzLnNpemUoKSkKKyAgICAgICAgcmV0dXJuIERlY2ltYWw6Om5hbigp OworCisgICAgc2l6ZV90IGxlZnQgPSAwOworICAgIHNpemVfdCByaWdodCA9IG1fdGlja01hcmtW YWx1ZXMuc2l6ZSgpOworICAgIHNpemVfdCBtaWRkbGU7CisgICAgd2hpbGUgKHRydWUpIHsKKyAg ICAgICAgQVNTRVJUKGxlZnQgPD0gcmlnaHQpOworICAgICAgICBtaWRkbGUgPSBsZWZ0ICsgKHJp Z2h0IC0gbGVmdCkgLyAyOworICAgICAgICBpZiAoIW1pZGRsZSkKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICBpZiAobWlkZGxlID09IG1fdGlja01hcmtWYWx1ZXMuc2l6ZSgpIC0gMSAmJiBt X3RpY2tNYXJrVmFsdWVzW21pZGRsZV0gPCB2YWx1ZSkgeworICAgICAgICAgICAgbWlkZGxlKys7 CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorICAgICAgICBpZiAobV90aWNrTWFya1Zh bHVlc1ttaWRkbGUgLSAxXSA8PSB2YWx1ZSAmJiBtX3RpY2tNYXJrVmFsdWVzW21pZGRsZV0gPj0g dmFsdWUpCisgICAgICAgICAgICBicmVhazsKKworICAgICAgICBpZiAobV90aWNrTWFya1ZhbHVl c1ttaWRkbGVdIDwgdmFsdWUpCisgICAgICAgICAgICBsZWZ0ID0gbWlkZGxlOworICAgICAgICBl bHNlCisgICAgICAgICAgICByaWdodCA9IG1pZGRsZTsKKyAgICB9CisgICAgY29uc3QgRGVjaW1h bCBjbG9zZXN0TGVmdCA9IG1pZGRsZSA/IG1fdGlja01hcmtWYWx1ZXNbbWlkZGxlIC0gMV0gOiBE ZWNpbWFsOjppbmZpbml0eShEZWNpbWFsOjpOZWdhdGl2ZSk7CisgICAgY29uc3QgRGVjaW1hbCBj bG9zZXN0UmlnaHQgPSBtaWRkbGUgIT0gbV90aWNrTWFya1ZhbHVlcy5zaXplKCkgPyBtX3RpY2tN YXJrVmFsdWVzW21pZGRsZV0gOiBEZWNpbWFsOjppbmZpbml0eShEZWNpbWFsOjpQb3NpdGl2ZSk7 CisgICAgaWYgKGNsb3Nlc3RSaWdodCAtIHZhbHVlIDwgdmFsdWUgLSBjbG9zZXN0TGVmdCkKKyAg ICAgICAgcmV0dXJuIGNsb3Nlc3RSaWdodDsKKyAgICByZXR1cm4gY2xvc2VzdExlZnQ7Cit9CiAj ZW5kaWYKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9SYW5nZUlucHV0VHlwZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9SYW5nZUlucHV0 VHlwZS5oCmluZGV4IDY5ZDJlYzdjNmNjMTlkMTAzNjE1NDIwMzNiY2ZkNjcxNDg0ODYyODcuLjgz NjdiNmZlZjFlZTA0NTAwNzhmMTdhMDk4MjM4NGUxNzBjNTAzNDEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvUmFuZ2VJbnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L1JhbmdlSW5wdXRUeXBlLmgKQEAgLTQyLDcgKzQyLDcgQEAgcHVibGljOgogICAgIHN0YXRpYyBQ YXNzT3duUHRyPElucHV0VHlwZT4gY3JlYXRlKEhUTUxJbnB1dEVsZW1lbnQqKTsKIAogcHJpdmF0 ZToKLSAgICBSYW5nZUlucHV0VHlwZShIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KSA6IElucHV0 VHlwZShlbGVtZW50KSB7IH0KKyAgICBSYW5nZUlucHV0VHlwZShIVE1MSW5wdXRFbGVtZW50Kik7 CiAgICAgdmlydHVhbCBib29sIGlzUmFuZ2VDb250cm9sKCkgY29uc3QgT1ZFUlJJREU7CiAgICAg dmlydHVhbCBjb25zdCBBdG9taWNTdHJpbmcmIGZvcm1Db250cm9sVHlwZSgpIGNvbnN0IE9WRVJS SURFOwogICAgIHZpcnR1YWwgZG91YmxlIHZhbHVlQXNEb3VibGUoKSBjb25zdCBPVkVSUklERTsK QEAgLTcyLDYgKzcyLDExIEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBIVE1MRWxlbWVudCogc2xp ZGVyVGh1bWJFbGVtZW50KCkgY29uc3QgT1ZFUlJJREU7CiAjaWYgRU5BQkxFKERBVEFMSVNUX0VM RU1FTlQpCiAgICAgdmlydHVhbCB2b2lkIGxpc3RBdHRyaWJ1dGVUYXJnZXRDaGFuZ2VkKCkgT1ZF UlJJREU7CisgICAgdm9pZCB1cGRhdGVUaWNrTWFya1ZhbHVlcygpOworICAgIHZpcnR1YWwgRGVj aW1hbCBmaW5kQ2xvc2VzdFRpY2tNYXJrVmFsdWUoY29uc3QgRGVjaW1hbCYpIE9WRVJSSURFOwor CisgICAgYm9vbCBtX3RpY2tNYXJrVmFsdWVzRGlydHk7CisgICAgVmVjdG9yPERlY2ltYWw+IG1f dGlja01hcmtWYWx1ZXM7CiAjZW5kaWYKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvc2hhZG93L1NsaWRlclRodW1iRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L3NoYWRvdy9TbGlkZXJUaHVtYkVsZW1lbnQuY3BwCmluZGV4IDM2MjIxZGRkN2U1NDdlZTE1OGIx NjI1MDVkYzhlY2MwNGNjMGUxOTkuLjFjNzUwN2YwMjg4Mjg1MGJmMWM1NzYwYTZiNzBmYmIzNWQz MzUxN2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1NsaWRlclRodW1i RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvU2xpZGVyVGh1bWJF bGVtZW50LmNwcApAQCAtNTEsNiArNTEsOCBAQCB1c2luZyBuYW1lc3BhY2Ugc3RkOwogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKK3VzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CisKIGlubGluZSBz dGF0aWMgRGVjaW1hbCBzbGlkZXJQb3NpdGlvbihIVE1MSW5wdXRFbGVtZW50KiBlbGVtZW50KQog ewogICAgIGNvbnN0IFN0ZXBSYW5nZSBzdGVwUmFuZ2UoZWxlbWVudC0+Y3JlYXRlU3RlcFJhbmdl KFJlamVjdEFueSkpOwpAQCAtMjcwLDcgKzI3MiwxOSBAQCB2b2lkIFNsaWRlclRodW1iRWxlbWVu dDo6c2V0UG9zaXRpb25Gcm9tUG9pbnQoY29uc3QgTGF5b3V0UG9pbnQmIHBvaW50KQogICAgIGNv bnN0IERlY2ltYWwgcmF0aW8gPSBEZWNpbWFsOjpmcm9tRG91YmxlKHN0YXRpY19jYXN0PGRvdWJs ZT4ocG9zaXRpb24pIC8gdHJhY2tTaXplKTsKICAgICBjb25zdCBEZWNpbWFsIGZyYWN0aW9uID0g aXNWZXJ0aWNhbCB8fCAhcmVuZGVyQm94KCktPnN0eWxlKCktPmlzTGVmdFRvUmlnaHREaXJlY3Rp b24oKSA/IERlY2ltYWwoMSkgLSByYXRpbyA6IHJhdGlvOwogICAgIFN0ZXBSYW5nZSBzdGVwUmFu Z2UoaW5wdXQtPmNyZWF0ZVN0ZXBSYW5nZShSZWplY3RBbnkpKTsKLSAgICBjb25zdCBEZWNpbWFs IHZhbHVlID0gc3RlcFJhbmdlLmNsYW1wVmFsdWUoc3RlcFJhbmdlLnZhbHVlRnJvbVByb3BvcnRp b24oZnJhY3Rpb24pKTsKKyAgICBEZWNpbWFsIHZhbHVlID0gc3RlcFJhbmdlLmNsYW1wVmFsdWUo c3RlcFJhbmdlLnZhbHVlRnJvbVByb3BvcnRpb24oZnJhY3Rpb24pKTsKKworI2lmIEVOQUJMRShE QVRBTElTVF9FTEVNRU5UKQorICAgIERlY2ltYWwgY2xvc2VzdCA9IGlucHV0LT5maW5kQ2xvc2Vz dFRpY2tNYXJrVmFsdWUodmFsdWUpOworICAgIGlmIChjbG9zZXN0LmlzRmluaXRlKCkpIHsKKyAg ICAgICAgZG91YmxlIGNsb3Nlc3RGcmFjdGlvbiA9IHN0ZXBSYW5nZS5wcm9wb3J0aW9uRnJvbVZh bHVlKGNsb3Nlc3QpLnRvRG91YmxlKCk7CisgICAgICAgIGRvdWJsZSBjbG9zZXN0UmF0aW8gPSBp c1ZlcnRpY2FsIHx8ICFyZW5kZXJCb3goKS0+c3R5bGUoKS0+aXNMZWZ0VG9SaWdodERpcmVjdGlv bigpID8gMS4wIC0gY2xvc2VzdEZyYWN0aW9uIDogY2xvc2VzdEZyYWN0aW9uOworICAgICAgICBM YXlvdXRVbml0IGNsb3Nlc3RQb3NpdGlvbiA9IHRyYWNrU2l6ZSAqIGNsb3Nlc3RSYXRpbzsKKyAg ICAgICAgY29uc3QgTGF5b3V0VW5pdCBzbmFwVGhyZXNob2xkID0gMzsKKyAgICAgICAgaWYgKChj bG9zZXN0UG9zaXRpb24gLSBwb3NpdGlvbikuYWJzKCkgPCBzbmFwVGhyZXNob2xkKQorICAgICAg ICAgICAgdmFsdWUgPSBjbG9zZXN0OworICAgIH0KKyNlbmRpZgogCiAgICAgLy8gRklYTUU6IFRo aXMgaXMgbm8gbG9uZ2VyIGJlaW5nIHNldCBmcm9tIHJlbmRlcmVyLiBDb25zaWRlciB1cGRhdGlu ZyB0aGUgbWV0aG9kIG5hbWUuCiAgICAgaW5wdXQtPnNldFZhbHVlRnJvbVJlbmRlcmVyKHNlcmlh bGl6ZUZvck51bWJlclR5cGUodmFsdWUpKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA0MzA1ZmZkYzMwY2IxYzdmNzY4NzBl NDA0Yzc5Y2NlZDM0YjQwZDcxLi5lYjczNWMxYjdmMzNhM2UyMmE5YTc5Yjk5NWM0MDU4YWQ5ZjEz NTJjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTItMDgtMDEgIEtlaXNoaSBIYXR0b3JpICA8 a2Vpc2hpQHdlYmtpdC5vcmc+CisKKyAgICAgICAgU2xpZGVyIHNob3VsZCBzbmFwIHRvIGRhdGFs aXN0IHRpY2sgbWFya3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTkyNjQwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgKiBmYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAt dG8tZGF0YWxpc3QuaHRtbDogQWRkZWQuCisKIDIwMTItMDgtMDEgIFJheW1vbmQgVG95ICA8cnRv eUBnb29nbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSBjb2RlYyB0ZXN0cyBpbiBUZXN0RXhwZWN0 YXRpb25zIGFuZCB1cGRhdGUgZXhwZWN0ZWQgbXAzIGZpbGVzCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNuYXAtdG8tZGF0YWxpc3QtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFs aXN0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMzVhOGUyYzJkMTY0MjIzMmMwZGY5NTFhM2Iz NTZlZjlhOWMyNjA5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9k YXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDI4 IEBACitUZXN0cyBpZiBjbGlja2luZyBjbG9zZSB0byBhIHRpY2sgbWFyayBzbmFwcyB0byBpdC4K KworUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BBU1MgcGFyc2VJbnQoaW5wdXQudmFsdWUsIDEw KSA8IDUwMCBpcyB0cnVlCitQQVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBwYXJzZUludChp bnB1dC52YWx1ZSwgMTApIDwgNTAwIGlzIHRydWUKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQ QVNTIHBhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPCA1MDAgaXMgdHJ1ZQorUEFTUyBpbnB1dC52 YWx1ZSBpcyAiMCIKK1BBU1MgaW5wdXQudmFsdWUgaXMgJzUwMCcKK1BBU1MgaW5wdXQudmFsdWUg aXMgIjAiCitQQVNTIGlucHV0LnZhbHVlIGlzICc1MDAnCitQQVNTIGlucHV0LnZhbHVlIGlzICIw IgorUEFTUyBpbnB1dC52YWx1ZSBpcyAnNTAwJworUEFTUyBpbnB1dC52YWx1ZSBpcyAiMCIKK1BB U1MgaW5wdXQudmFsdWUgaXMgJzUwMCcKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAiCitQQVNTIGlu cHV0LnZhbHVlIGlzICc1MDAnCitQQVNTIGlucHV0LnZhbHVlIGlzICIwIgorUEFTUyBwYXJzZUlu dChpbnB1dC52YWx1ZSwgMTApID4gNTAwIGlzIHRydWUKK1BBU1MgaW5wdXQudmFsdWUgaXMgIjAi CitQQVNTIHBhcnNlSW50KGlucHV0LnZhbHVlLCAxMCkgPiA1MDAgaXMgdHJ1ZQorUEFTUyBpbnB1 dC52YWx1ZSBpcyAiMCIKK1BBU1MgcGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA+IDUwMCBpcyB0 cnVlCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRv LWRhdGFsaXN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2RhdGFsaXN0L3JhbmdlLXNu YXAtdG8tZGF0YWxpc3QuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wMmZmMGYxZWY5ZjViNGYyNGMwMDI4MDVi N2ZmYzc0Y2QzYjNjNjRlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jt cy9kYXRhbGlzdC9yYW5nZS1zbmFwLXRvLWRhdGFsaXN0Lmh0bWwKQEAgLTAsMCArMSw2MiBAQAor PCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jl c291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlk PSJkZXNjcmlwdGlvbiI+VGVzdHMgaWYgY2xpY2tpbmcgY2xvc2UgdG8gYSB0aWNrIG1hcmsgc25h cHMgdG8gaXQuPC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8aW5wdXQgaWQ9ImlucHV0 IiB0eXBlPXJhbmdlIG1pbj0wIG1heD0xMDAwIHN0ZXA9MSBsaXN0PXRhcmdldCBzdHlsZT0id2lk dGg6IDEwMHB4Ij4KKzxkYXRhbGlzdCBpZD0idGFyZ2V0Ij4KKyAgICA8b3B0aW9uPjUwMDwvb3B0 aW9uPgorPC9kYXRhbGlzdD4KKzxzY3JpcHQ+Cit2YXIgaW5wdXQgPSBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiaW5wdXQiKTsKK2Z1bmN0aW9uIGNsaWNrU2xpZGVyKG9mZnNldExlZnQpIHsKKyAg ICB2YXIgY2VudGVyWSA9IGlucHV0Lm9mZnNldFRvcCArIGlucHV0Lm9mZnNldEhlaWdodCAvIDI7 CisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8oaW5wdXQub2Zmc2V0TGVmdCArIG9mZnNldExl ZnQsIGNlbnRlclkpOworICAgIGV2ZW50U2VuZGVyLm1vdXNlRG93bigpOworICAgIGV2ZW50U2Vu ZGVyLm1vdXNlVXAoKTsKK30KK2Z1bmN0aW9uIHJlc2V0U2xpZGVyUG9zaXRpb24oKSB7CisgICAg Y2xpY2tTbGlkZXIoMCk7CisgICAgc2hvdWxkQmUoJ2lucHV0LnZhbHVlJywgJyIwIicpOworfQor cmVzZXRTbGlkZXJQb3NpdGlvbigpOworY2xpY2tTbGlkZXIoNDUpOworc2hvdWxkQmVUcnVlKCdw YXJzZUludChpbnB1dC52YWx1ZSwgMTApIDwgNTAwJyk7CityZXNldFNsaWRlclBvc2l0aW9uKCk7 CitjbGlja1NsaWRlcig0Nik7CitzaG91bGRCZVRydWUoJ3BhcnNlSW50KGlucHV0LnZhbHVlLCAx MCkgPCA1MDAnKTsKK3Jlc2V0U2xpZGVyUG9zaXRpb24oKTsKK2NsaWNrU2xpZGVyKDQ3KTsKK3No b3VsZEJlVHJ1ZSgncGFyc2VJbnQoaW5wdXQudmFsdWUsIDEwKSA8IDUwMCcpOworcmVzZXRTbGlk ZXJQb3NpdGlvbigpOworY2xpY2tTbGlkZXIoNDgpOworc2hvdWxkQmUoJ2lucHV0LnZhbHVlJywg Iic1MDAnIik7CityZXNldFNsaWRlclBvc2l0aW9uKCk7CitjbGlja1NsaWRlcig0OSk7CitzaG91 bGRCZSgnaW5wdXQudmFsdWUnLCAiJzUwMCciKTsKK3Jlc2V0U2xpZGVyUG9zaXRpb24oKTsKK2Ns aWNrU2xpZGVyKDUwKTsKK3Nob3VsZEJlKCdpbnB1dC52YWx1ZScsICInNTAwJyIpOworcmVzZXRT bGlkZXJQb3NpdGlvbigpOworY2xpY2tTbGlkZXIoNTEpOworc2hvdWxkQmUoJ2lucHV0LnZhbHVl JywgIic1MDAnIik7CityZXNldFNsaWRlclBvc2l0aW9uKCk7CitjbGlja1NsaWRlcig1Mik7Citz aG91bGRCZSgnaW5wdXQudmFsdWUnLCAiJzUwMCciKTsKK3Jlc2V0U2xpZGVyUG9zaXRpb24oKTsK K2NsaWNrU2xpZGVyKDUzKTsKK3Nob3VsZEJlVHJ1ZSgncGFyc2VJbnQoaW5wdXQudmFsdWUsIDEw KSA+IDUwMCcpOworcmVzZXRTbGlkZXJQb3NpdGlvbigpOworY2xpY2tTbGlkZXIoNTQpOworc2hv dWxkQmVUcnVlKCdwYXJzZUludChpbnB1dC52YWx1ZSwgMTApID4gNTAwJyk7CityZXNldFNsaWRl clBvc2l0aW9uKCk7CitjbGlja1NsaWRlcig1NSk7CitzaG91bGRCZVRydWUoJ3BhcnNlSW50KGlu cHV0LnZhbHVlLCAxMCkgPiA1MDAnKTsKKzwvc2NyaXB0PgorCis8c2NyaXB0IHNyYz0iLi4vLi4v anMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+ Cg==