152814 2016-01-06 16:35:59 -0800 SVG 2 requires a mechanism for restricting enum values exposed through the DOM 2016-01-19 14:02:14 -0800 1 1 1 Unclassified WebKit SVG WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 138456 141376 1 nikos.andronikos nikos.andronikos commit-queue darin dbates dino krit sabouhallawa zimmermann oldest_to_newest 1153269 0 nikos.andronikos 2016-01-06 16:35:59 -0800 SVG 1.1 used a pattern where enumerated values were exposed as integers through a property, with a constant defined in the interface to map meaningful names to those integer values. In SVG 2, this pattern is not used. Therefore, for new enumeration values added in SVG 2, the enumeration property must return UNKNOWN. In addition, when setting the enumeration property, values outside the range of the acceptable range in SVG 1.1 must not be accepted. 1153318 1 268434 nikos.andronikos 2016-01-06 18:53:48 -0800 Created attachment 268434 Patch 1153518 2 268434 sabouhallawa 2016-01-07 12:39:17 -0800 Comment on attachment 268434 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=268434&action=review > Source/WebCore/svg/SVGComponentTransferFunctionElement.h:34 > + static unsigned highestExposedEnumValue() { return FECOMPONENTTRANSFER_TYPE_GAMMA; } For easy reading, I would suggest the default case to be: static unsigned highestExposedEnumValue() { return highestEnumValue(); } > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:34 > + static unsigned outOfRangeEnumValue = 0; Can't we move this variable outside the function: private: static const unsigned outOfRangeEnumValue = 0; > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:58 > + if (!property || property > SVGPropertyTraits<EnumType>::highestExposedEnumValue() || property > SVGPropertyTraits<EnumType>::highestEnumValue()) { I do not this this is correct. I think we want to allow setting the enum value as long as it less than highestEnumValue(). But we want to not expose the new values through the DOM. So I think the original if-statment is correct. 1153651 3 268502 nikos.andronikos 2016-01-07 15:43:57 -0800 Created attachment 268502 Patch 1153658 4 nikos.andronikos 2016-01-07 15:49:21 -0800 (In reply to comment #2) > Comment on attachment 268434 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=268434&action=review > > > Source/WebCore/svg/SVGComponentTransferFunctionElement.h:34 > > + static unsigned highestExposedEnumValue() { return FECOMPONENTTRANSFER_TYPE_GAMMA; } > > For easy reading, I would suggest the default case to be: > > static unsigned highestExposedEnumValue() { return highestEnumValue(); } > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:34 > > + static unsigned outOfRangeEnumValue = 0; > > Can't we move this variable outside the function: > > private: > static const unsigned outOfRangeEnumValue = 0; Done and done. Not const though as method returns non-const. > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:58 > > + if (!property || property > SVGPropertyTraits<EnumType>::highestExposedEnumValue() || property > SVGPropertyTraits<EnumType>::highestEnumValue()) { > > I do not this this is correct. I think we want to allow setting the enum > value as long as it less than highestEnumValue(). But we want to not expose > the new values through the DOM. So I think the original if-statment is > correct. It's correct per the SVG 2 spec. See http://www.w3.org/TR/SVG2/types.html#InterfaceSVGAnimatedEnumeration Specifically, On setting baseVal, the following steps are run: ... 2. If value is 0 or is not the numeric type value for any value of the reflected attribute, then set the reflected attribute to the empty string. Where the numeric type value is any value that is defined in the table of constants for that type. E.g. See the line below the table of constants for SVGMarkerElement at http://www.w3.org/TR/SVG2/painting.html#InterfaceSVGMarkerElement 1153667 5 268434 sabouhallawa 2016-01-07 16:07:33 -0800 Comment on attachment 268434 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=268434&action=review >>> Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:58 >>> + if (!property || property > SVGPropertyTraits<EnumType>::highestExposedEnumValue() || property > SVGPropertyTraits<EnumType>::highestEnumValue()) { >> >> I do not this this is correct. I think we want to allow setting the enum value as long as it less than highestEnumValue(). But we want to not expose the new values through the DOM. So I think the original if-statment is correct. > > It's correct per the SVG 2 spec. > See http://www.w3.org/TR/SVG2/types.html#InterfaceSVGAnimatedEnumeration > > Specifically, > On setting baseVal, the following steps are run: > ... > 2. If value is 0 or is not the numeric type value for any value of the reflected attribute, then set the reflected attribute to the empty string. > > Where the numeric type value is any value that is defined in the table of constants for that type. > E.g. See the line below the table of constants for SVGMarkerElement at http://www.w3.org/TR/SVG2/painting.html#InterfaceSVGMarkerElement 1. Please make sure that you include the link to the specs in the ChangeLog 2. I saw Dirk Schulze in https://bugs.webkit.org/show_bug.cgi?id=138456 wants the new enum implemented but not exposed from the SVGDOM. My understanding was highestExposedEnumValue() is only for temporary period where the enum is implemented but not approved/tested yet; so it is okay to set the property to the new enum but it can't be retrieved from DOM. Now I think I am confused about the purpose of whole change. 3. In anyway, this new if-statment is misleading. Since it is always true that highestExposedEnumValue() < highestEnumValue(), is not it true that these conditions are equivalent: property > SVGPropertyTraits<EnumType>::highestExposedEnumValue() || property > SVGPropertyTraits<EnumType>::highestEnumValue() property > SVGPropertyTraits<EnumType>::highestExposedEnumValue() 1153677 6 268504 nikos.andronikos 2016-01-07 16:39:53 -0800 Created attachment 268504 Patch 1153678 7 nikos.andronikos 2016-01-07 16:40:42 -0800 (In reply to comment #5) > 1. Please make sure that you include the link to the specs in the ChangeLog No problem, done. > 2. I saw Dirk Schulze in https://bugs.webkit.org/show_bug.cgi?id=138456 > wants the new enum implemented but not exposed from the SVGDOM. My > understanding was highestExposedEnumValue() is only for temporary period > where the enum is implemented but not approved/tested yet; so it is okay to > set the property to the new enum but it can't be retrieved from DOM. Now I > think I am confused about the purpose of whole change. The purpose of this change is to add a mechanism for not exposing all internal enum values through the DOM. You can see in https://bugs.webkit.org/show_bug.cgi?id=138456 that we have a new enum value SVGMarkerOrientAutoStartReverse on the enum SVGMarkerOrientType. This is required internally to support this SVG 2 feature. But, in SVG 2, these enums don't map to an enum in the IDL definition, and the numeric equivalent value for this enum should not be exposed through the property. The reason for this is that the SVG working group wants to move away from the enum/constant pattern used in SVG 1.1 and move towards more standard JS patterns such as a method that returns a string. Not exposing new values is a means to avoid authors depending on a feature that we would ultimately like to drop in the future. If that's not clear, feel free to ping me on irc. > 3. In anyway, this new if-statment is misleading. Since it is always true > that highestExposedEnumValue() < highestEnumValue(), is not it true that > these conditions are equivalent: > > property > SVGPropertyTraits<EnumType>::highestExposedEnumValue() || > property > SVGPropertyTraits<EnumType>::highestEnumValue() > property > SVGPropertyTraits<EnumType>::highestExposedEnumValue() Ahh yes, I see what you are saying. The old test was wrong, but the new test can be simplified because it will always short circuit at the second condition. I did realise this, that's why the tests are in that order, but previously I was returning MAX_INT for highestExposedEnumValue so the additional test was required. I forgot to change the condition when I changed the return value for highestExposedEnumValue. Thanks for reviewing! 1155135 8 268504 sabouhallawa 2016-01-13 11:04:27 -0800 Comment on attachment 268504 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=268504&action=review > Source/WebCore/svg/SVGComponentTransferFunctionElement.h:34 > + static unsigned highestExposedEnumValue() { return highestEnumValue(); } I still do not like repeating this new function for every enum. How about this change: 1. In SVGPropertyTraits.h you define template<typename EnumType> struct SVGEnumLimits { static unsigned outOfRangeEnumValue() { return 0; } static unsigned highestEnumValue() { return 0; } static unsigned highestExposedEnumValue() { return highestEnumValue(); } }; 2. In SVGComponentTransferFunctionElement.h, you add template<> inline unsigned SVGEnumLimits<ComponentTransferType>::outOfRangeEnumValue() { return FECOMPONENTTRANSFER_TYPE_UNKNOWN; } template<> inline unsigned SVGEnumLimits<ComponentTransferType>::highestEnumValue() { return FECOMPONENTTRANSFER_TYPE_GAMMA; } 3. In SVGComponentTransferFunctionElement.h, you delete static unsigned highestEnumValue() { return FECOMPONENTTRANSFER_TYPE_GAMMA; } 4. In any place which uses SVGPropertyTraits<EnumType>::highestEnumValue() you replace it with SVGEnumLimits<EnumType>::highestEnumValue(). > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:34 > + if (m_property > SVGPropertyTraits<EnumType>::highestExposedEnumValue()) You can use SVGEnumLimits<EnumType>::highestExposedEnumValue() instead. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:53 > + Please remove this line. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:85 > +unsigned SVGAnimatedEnumerationPropertyTearOff<EnumType>::m_outOfRangeEnumValue = 0; You can use SVGEnumLimits<EnumType>::outOfRangeEnumValue() instead of 0. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:86 > + Please remove this empty line. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:90 > + Please remove these two empty lines. 1155136 9 sabouhallawa 2016-01-13 11:05:08 -0800 The change looks fine to me. Unofficial r=me. 1155409 10 nikos.andronikos 2016-01-14 03:00:46 -0800 Thanks Said. Those are good suggestions so I'll prepare another patch tomorrow. 1155671 11 269029 nikos.andronikos 2016-01-14 20:36:39 -0800 Created attachment 269029 Patch 1155787 12 269029 darin 2016-01-15 08:59:15 -0800 Comment on attachment 269029 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=269029&action=review I am not sure this is the right approach, and I also see some smaller problems. review- for now but perhaps I’d review+ if I understood the strategy better. > Source/WebCore/ChangeLog:23 > + Setters: > + On setting baseVal, the following steps are run: > + 1. ... > + 2. If value is 0 or is not the numeric type value for any value of the reflected attribute, then set the reflected attribute to the empty string. The specification talks about extra work in setters, but we instead are putting extra work in the animation process and getters. Is that right? > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:30 > class SVGAnimatedEnumerationPropertyTearOff : public SVGAnimatedStaticPropertyTearOff<unsigned> { I think this class template should be marked final. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:37 > + if (m_property > SVGEnumLimits<EnumType>::highestExposedEnumValue()) > + return outOfRangeEnumValue(); > + > + return m_property; This function could call SVGAnimatedStaticPropertyTearOff::baseVal to get the reference to the property rather than accessing m_property directly. Then we could leave m_property private. Not all that helpful, though, I guess since this returns a non-const reference to it anyway. But I think it helps make clearer the relationship of this override to the underlying function. It does not seem safe for this function to return a non-const reference to the constant out-of-range enum value. If the caller modifies it, then the value will be incorrect for future callers! Can we figure out if tear-offs can return const references instead of non-const? > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:48 > + if (!m_animatedProperty) > + return baseVal(); > + > + if (*m_animatedProperty > SVGEnumLimits<EnumType>::highestExposedEnumValue()) > + return outOfRangeEnumValue(); > + > + return *m_animatedProperty; This function could call SVGAnimatedStaticPropertyTearOff::animVal to get the reference to the property rather than accessing m_property directly. Then we could leave m_property private. Not all that helpful, though, I guess since this returns a non-const reference to it anyway! It does not seem safe for this function to return a non-const reference to the constant out-of-range enum value. If the caller modifies it, then the value will be incorrect for future callers! Can we figure out if tear-offs can return const references instead of non-const? > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:80 > + // This method exists to allow the initialise on first use pattern, which avoids the global constructor required for a class variable. Word "method" is not so great for a C++ function. I would write this: // We use a function member instead of a data member here to avoid the global constructor that would be needed for an initialized static data member. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:81 > + inline unsigned& outOfRangeEnumValue() I think this should be a static member function, not a non-static member function. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:84 > + static unsigned oorValue = SVGEnumLimits<EnumType>::outOfRangeEnumValue(); > + return oorValue; As I mentioned above, returning a non-const reference here doesn’t seem safe. The way this code works properly is non-obvious! > Source/WebCore/svg/properties/SVGAnimatedStaticPropertyTearOff.h:109 > -private: > PropertyType& m_property; > PropertyType* m_animatedProperty; I think it would be better if these remained private. Is there any good reason we can’t use accessor functions instead of getting at the data members directly? > Source/WebCore/svg/properties/SVGPropertyTraits.h:63 > + static unsigned outOfRangeEnumValue() { return 0; } This seems dangerous. It’s possible to specialize highestExposedEnumValue and forget to specialize outOfRangeEnumValue, and then you’d get 0 instead of UNKNOWN. Would be nicer if that wasn’t possible. > Source/WebCore/svg/properties/SVGPropertyTraits.h:64 > + static unsigned highestEnumValue() { return 0; } I don’t think it’s valuable to define this function in this template. If the function returning 0 is ever called, it’s a programming error. It would be better to leave it out and get a failure at compile time like we would have before. Is there any way to retain that compile-time checking that we used to have by leaving this out entirely? If we can’t make this work without defining this function, at the very least we should leave out the function body and just declare this instead of defining it so we’d get an error at link time. > Source/WebCore/svg/properties/SVGPropertyTraits.h:65 > + static unsigned highestExposedEnumValue() { return highestEnumValue(); } Inelegant that we will compile in unneeded range checks for all the classes that use this default, and don’t hide any enum values. Not really generic programming at its best. 1156511 13 269253 nikos.andronikos 2016-01-18 18:49:42 -0800 Created attachment 269253 Patch 1156529 14 nikos.andronikos 2016-01-18 19:58:58 -0800 (In reply to comment #12) > Comment on attachment 269029 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=269029&action=review > > I am not sure this is the right approach, and I also see some smaller > problems. review- for now but perhaps I’d review+ if I understood the > strategy better. > > > Source/WebCore/ChangeLog:23 > > + Setters: > > + On setting baseVal, the following steps are run: > > + 1. ... > > + 2. If value is 0 or is not the numeric type value for any value of the reflected attribute, then set the reflected attribute to the empty string. > > The specification talks about extra work in setters, but we instead are > putting extra work in the animation process and getters. Is that right? Not quite, the spec isn't requiring extra work for setters - this hasn't changed from SVG 1.1. Out of range values have always been disallowed. The spec does now require extra work in the getters so as to not expose new values. This is noted in the spec in the line I quoted: 16 SVG 2 does not add numeric type values for new options, new options 17 should return UNKNOWN. This change doesn't affect the animation code path, only access through the DOM. E.g. document.querySelector("#svgfecompositeelement").operator.baseVal.value Otherwise we wouldn't be able to animate to the non exposed values (I have tests for this in the blocked bugs that I'll submit once this patch lands). > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:30 > > class SVGAnimatedEnumerationPropertyTearOff : public SVGAnimatedStaticPropertyTearOff<unsigned> { > > I think this class template should be marked final. Done. > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:37 > > + if (m_property > SVGEnumLimits<EnumType>::highestExposedEnumValue()) > > + return outOfRangeEnumValue(); > > + > > + return m_property; > > This function could call SVGAnimatedStaticPropertyTearOff::baseVal to get > the reference to the property rather than accessing m_property directly. > Then we could leave m_property private. Not all that helpful, though, I > guess since this returns a non-const reference to it anyway. But I think it > helps make clearer the relationship of this override to the underlying > function. Done. m_property and m_animatedProperty are back to being private and baseVal and animVal now use the getters from SVGAnimatedStaticPropertyTearOff. > > It does not seem safe for this function to return a non-const reference to > the constant out-of-range enum value. If the caller modifies it, then the > value will be incorrect for future callers! Can we figure out if tear-offs > can return const references instead of non-const? I've logged bug 153214 and will look into this. There's lots of refactoring that could be done in the SVG code =) > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:48 > > + if (!m_animatedProperty) > > + return baseVal(); > > + > > + if (*m_animatedProperty > SVGEnumLimits<EnumType>::highestExposedEnumValue()) > > + return outOfRangeEnumValue(); > > + > > + return *m_animatedProperty; > > This function could call SVGAnimatedStaticPropertyTearOff::animVal to get > the reference to the property rather than accessing m_property directly. > Then we could leave m_property private. Not all that helpful, though, I > guess since this returns a non-const reference to it anyway! > > It does not seem safe for this function to return a non-const reference to > the constant out-of-range enum value. If the caller modifies it, then the > value will be incorrect for future callers! Can we figure out if tear-offs > can return const references instead of non-const? > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:80 > > + // This method exists to allow the initialise on first use pattern, which avoids the global constructor required for a class variable. > > Word "method" is not so great for a C++ function. I would write this: > > // We use a function member instead of a data member here to avoid the > global constructor that would be needed for an initialized static data > member. Done. > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:81 > > + inline unsigned& outOfRangeEnumValue() > > I think this should be a static member function, not a non-static member > function. Agree. That was a mistake on my part. > > > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:84 > > + static unsigned oorValue = SVGEnumLimits<EnumType>::outOfRangeEnumValue(); > > + return oorValue; > > As I mentioned above, returning a non-const reference here doesn’t seem > safe. The way this code works properly is non-obvious! > > > Source/WebCore/svg/properties/SVGAnimatedStaticPropertyTearOff.h:109 > > -private: > > PropertyType& m_property; > > PropertyType* m_animatedProperty; > > I think it would be better if these remained private. Is there any good > reason we can’t use accessor functions instead of getting at the data > members directly? > > > Source/WebCore/svg/properties/SVGPropertyTraits.h:63 > > + static unsigned outOfRangeEnumValue() { return 0; } > > This seems dangerous. It’s possible to specialize highestExposedEnumValue > and forget to specialize outOfRangeEnumValue, and then you’d get 0 instead > of UNKNOWN. Would be nicer if that wasn’t possible. > > > Source/WebCore/svg/properties/SVGPropertyTraits.h:64 > > + static unsigned highestEnumValue() { return 0; } > > I don’t think it’s valuable to define this function in this template. If the > function returning 0 is ever called, it’s a programming error. It would be > better to leave it out and get a failure at compile time like we would have > before. Is there any way to retain that compile-time checking that we used > to have by leaving this out entirely? If we can’t make this work without > defining this function, at the very least we should leave out the function > body and just declare this instead of defining it so we’d get an error at > link time. I've made a number of changes to improve things. highestEnumValue is now back in SVGPropertyTraits so behaves as it did before - including the compile time checking that it's been implemented. I've renamed the new struct to SVGIDLEnumLimits and it only contains highestExposedEnumValue and outOfRangeEnumValue(). All the enum elements that represent UNKNOWN are equal to zero (and no more will ever be added to SVG), so this function doesn't need specializing unless we choose to do so for readability. > > > Source/WebCore/svg/properties/SVGPropertyTraits.h:65 > > + static unsigned highestExposedEnumValue() { return highestEnumValue(); } > > Inelegant that we will compile in unneeded range checks for all the classes > that use this default, and don’t hide any enum values. Not really generic > programming at its best. We limit the range checks to only enum types, which are the class of type that behave this way. Probably a large portion of the enum types will need limiting in SVG 2. We could specialise each specific enum type that needs limiting and perform the range check in the specialisation, but then we'd have to expose the behaviour from the tear off to each, which would be less elegant imo. 1156536 15 269253 darin 2016-01-18 20:20:15 -0800 Comment on attachment 269253 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=269253&action=review > Source/WebCore/svg/SVGFEDisplacementMapElement.h:30 > namespace WebCore { > - > + > template<> I don’t think we should land this whitespace-only change. > Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:84 > + static unsigned oorValue = SVGIDLEnumLimits<EnumType>::outOfRangeEnumValue(); I think that SVGIDLEnumLimits<EnumType>::outOfRangeEnumValue() is a really long way to write zero. Can we just skip that unneeded complexity and just have a static with a zero in it. I’m not even sure why this is in the class template instead of just a single global "reference to an unsigned with value 0" function. We don't need separate global variables for each class. > Source/WebCore/svg/properties/SVGPropertyTraits.h:66 > + // By convention, all enum values that represent UNKNOWN in SVG are equal to zero. > + static unsigned outOfRangeEnumValue() { return 0; } As I mentioned above we should just omit this, and the comment can move into the outOfRangeEnumValue function. 1156539 16 269256 nikos.andronikos 2016-01-18 21:09:50 -0800 Created attachment 269256 Patch 1156703 17 sabouhallawa 2016-01-19 13:05:23 -0800 Since Darin r+'ed your previous patch, you do not need to ask for a second review if your new patches just fixes his comments. So I am removing the r? and and I cq+ it. 1156704 18 269256 commit-queue 2016-01-19 13:10:07 -0800 Comment on attachment 269256 Patch Rejecting attachment 269256 from commit-queue. Failed to run "['/Volumes/Data/EWS/WebKit/Tools/Scripts/webkit-patch', '--status-host=webkit-queues.webkit.org', '--bot-id=webkit-cq-01', 'validate-changelog', '--check-oops', '--non-interactive', 269256, '--port=mac']" exit_code: 1 cwd: /Volumes/Data/EWS/WebKit ChangeLog entry in Source/WebCore/ChangeLog contains OOPS!. Full output: http://webkit-queues.webkit.org/results/713827 1156706 19 sabouhallawa 2016-01-19 13:21:20 -0800 Yes, it is my mistake. The patch will not be applied because the changeLog does not have a reviewer. Please do the following: 1. Change the Source/WebCore/ChangeLog: < Reviewed by NOBODY (OOPS!). > Reviewed by Darin Adler. 2. Upload the patch with --no-review flag. When you do that I will cq+. 1156715 20 269289 nikos.andronikos 2016-01-19 13:42:46 -0800 Created attachment 269289 Patch 1156725 21 269289 commit-queue 2016-01-19 14:02:08 -0800 Comment on attachment 269289 Patch Clearing flags on attachment: 269289 Committed r195315: <http://trac.webkit.org/changeset/195315> 1156726 22 commit-queue 2016-01-19 14:02:14 -0800 All reviewed patches have been landed. Closing bug. 268434 2016-01-06 18:53:48 -0800 2016-01-07 15:43:53 -0800 Patch bug-152814-20160107135314.patch text/plain 15338 nikos.andronikos U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0NjcxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTdhYjQwYWNjYTg5ODky NmMwOWVjNzgwODFlZjMwY2ZlNWRkNzk4Yy4uNWJmYWYxNjExNGI5YzE0YmExZmI2NjFlZTBiNDA3 Mjg0YzAyYjgyYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUzIEBACisyMDE2LTAxLTA2ICBOaWtv cyBBbmRyb25pa29zICA8bmlrb3MuYW5kcm9uaWtvcy13ZWJraXRAY2lzcmEuY2Fub24uY29tLmF1 PgorCisgICAgICAgIFNWRyAyIHJlcXVpcmVzIGEgbWVjaGFuaXNtIGZvciByZXN0cmljdGluZyBl bnVtIHZhbHVlcyBleHBvc2VkIHRocm91Z2ggdGhlIERPTQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyODE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChObyBjaGFuZ2UgaW4gZnVu Y3Rpb25hbGl0eSwgYmxvY2tlZCBidWdzIGFkZCBuZXcgdGVzdHMpLgorCisgICAgICAgIFRoaXMg cGF0Y2ggYWRkcyBhIG1lY2hhbmlzbSB0byByZXN0cmljdCB0aGUgdmFsdWVzIHJldHVybmVkIHRo cm91Z2ggdGhlCisgICAgICAgIFNWR0FuaW1hdGVkRW51bWVyYXRpb24gaW50ZXJmYWNlLgorICAg ICAgICBUaGlzIGlzIHJlcXVpcmVkIGZvciBTVkcgMiwgd2hpY2ggZG9lcyBub3QgZXhwb3NlIG5l dyBlbnVtZXJhdGlvbgorICAgICAgICB2YWx1ZXMgdGhyb3VnaCB0aGUgSURMLgorCisgICAgICAg ICogc3ZnL1NWR0NvbXBvbmVudFRyYW5zZmVyRnVuY3Rpb25FbGVtZW50Lmg6CisgICAgICAgIChX ZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxDb21wb25lbnRUcmFuc2ZlclR5cGU+OjpoaWdoZXN0 RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9TVkdGRUJsZW5kRWxlbWVu dC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8QmxlbmRNb2RlPjo6aGln aGVzdEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVDb2xvck1h dHJpeEVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPENvbG9y TWF0cml4VHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgICog c3ZnL1NWR0ZFQ29tcG9zaXRlRWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVy dHlUcmFpdHM8Q29tcG9zaXRlT3BlcmF0aW9uVHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVl KTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR0ZFQ29udm9sdmVNYXRyaXhFbGVtZW50Lmg6Cisg ICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxFZGdlTW9kZVR5cGU+OjpoaWdoZXN0 RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9TVkdGRURpc3BsYWNlbWVu dE1hcEVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPENoYW5u ZWxTZWxlY3RvclR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAg ICAqIHN2Zy9TVkdGRU1vcnBob2xvZ3lFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdQ cm9wZXJ0eVRyYWl0czxNb3JwaG9sb2d5T3BlcmF0b3JUeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVt VmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVUdXJidWxlbmNlRWxlbWVudC5oOgor ICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHU3RpdGNoT3B0aW9ucz46Omhp Z2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9w ZXJ0eVRyYWl0czxUdXJidWxlbmNlVHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRk ZWQuCisgICAgICAgICogc3ZnL1NWR0dyYWRpZW50RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29y ZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHU3ByZWFkTWV0aG9kVHlwZT46OmhpZ2hlc3RFeHBvc2Vk RW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR01hcmtlckVsZW1lbnQuaDoKKyAg ICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR01hcmtlclVuaXRzVHlwZT46Omhp Z2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9w ZXJ0eVRyYWl0czxTVkdNYXJrZXJPcmllbnRUeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUp OiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50Lmg6CisgICAgICAg IChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxTVkdMZW5ndGhBZGp1c3RUeXBlPjo6aGlnaGVz dEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHVGV4dFBhdGhFbGVt ZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0UGF0aE1l dGhvZFR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHVGV4dFBhdGhTcGFjaW5nVHlwZT46OmhpZ2hlc3RF eHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR1VuaXRUeXBlcy5oOgor ICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHVW5pdFR5cGVzOjpTVkdVbml0 VHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL3By b3BlcnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oOiBBZGQgZGVm aW5pdGlvbnMgZm9yIGJhc2VWYWwgYW5kIGFuaW1WYWwgbWV0aG9kcy4KKyAgICAgICAgKiBzdmcv cHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oOiBNYWtlIGJhc2VW YWwoKSBhbmQgYW5pbVZhbCgpIHZpcnR1YWwuCisgICAgICAgIChXZWJDb3JlOjpTVkdBbmltYXRl ZFN0YXRpY1Byb3BlcnR5VGVhck9mZjo6YmFzZVZhbCk6IE92ZXJyaWRlIGJhc2UgbWV0aG9kIGFu ZCBsaW1pdCByZXR1cm5lZAorICAgICAgICAgIHZhbHVlIHRvIGhpZ2hlc3RFeHBvc2VkRW51bVZh bHVlKCkgZm9yIHRoYXQgdHlwZS4KKyAgICAgICAgKFdlYkNvcmU6OlNWR0FuaW1hdGVkU3RhdGlj UHJvcGVydHlUZWFyT2ZmOjphbmltVmFsKTogT3ZlcnJpZGUgYmFzZSBtZXRob2QgYW5kIGxpbWl0 IHJldHVybmVkCisgICAgICAgICAgdmFsdWUgdG8gaGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSBm b3IgdGhhdCB0eXBlLgorCiAyMDE2LTAxLTA2ICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFwcGxl LmNvbT4KIAogICAgICAgICBNb2Rlcm4gSURCOiBzdG9yYWdlL2luZGV4ZWRkYi9vZGQtc3RyaW5n cy5odG1sIGlzIGZsYWt5LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0NvbXBv bmVudFRyYW5zZmVyRnVuY3Rpb25FbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHQ29t cG9uZW50VHJhbnNmZXJGdW5jdGlvbkVsZW1lbnQuaAppbmRleCBiZTRmZTk3MzFjZGI4NDc1ZGFi YTQxNjViY2NlYjkwOGI1ZTJhZmExLi4wNDIzYjkyNDM0M2Q3MDQxMjljYzgxZTlmZDQ4MjlkNDli MTkzNmRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHQ29tcG9uZW50VHJhbnNm ZXJGdW5jdGlvbkVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHQ29tcG9uZW50 VHJhbnNmZXJGdW5jdGlvbkVsZW1lbnQuaApAQCAtMzEsNiArMzEsNyBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiB0ZW1wbGF0ZTw+CiBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8Q29tcG9uZW50VHJh bnNmZXJUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJl dHVybiBGRUNPTVBPTkVOVFRSQU5TRkVSX1RZUEVfR0FNTUE7IH0KKyAgICBzdGF0aWMgdW5zaWdu ZWQgaGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSB7IHJldHVybiBGRUNPTVBPTkVOVFRSQU5TRkVS X1RZUEVfR0FNTUE7IH0KIAogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoQ29tcG9uZW50VHJh bnNmZXJUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NW R0ZFQmxlbmRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVCbGVuZEVsZW1lbnQu aAppbmRleCBlMGE3Y2EzMzEyZTVlMDRlYTMxNTNjZGFjNTE5OGQzM2Y5MWQwMDZlLi41NDA2NWFm Y2Y1OTZlOTljMTg1OTkxMGFjZGQwMGI1MjMzM2FkMTk5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHRkVCbGVuZEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZH RkVCbGVuZEVsZW1lbnQuaApAQCAtMzEsNiArMzEsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiB0 ZW1wbGF0ZTw+CiBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8QmxlbmRNb2RlPiB7CiAgICAgc3Rh dGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBCbGVuZE1vZGVMaWdodGVu OyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1 cm4gQmxlbmRNb2RlTGlnaHRlbjsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhCbGVu ZE1vZGUgdHlwZSkKICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVD b2xvck1hdHJpeEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4 RWxlbWVudC5oCmluZGV4IGQwOWM3NzZmNTc0YmI1ODM5ZDRkOTFlNWU4OGI5OTQ5Y2YzODI2YzEu Ljk1OGVhOTFiNzVkZjI5ZTY4ZWZjOTg4MjczNTE2YTA0ZTM2NTc4NWMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5oCkBAIC0zMSw2ICszMSw3IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxD b2xvck1hdHJpeFR5cGU+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgp IHsgcmV0dXJuIEZFQ09MT1JNQVRSSVhfVFlQRV9MVU1JTkFOQ0VUT0FMUEhBOyB9CisgICAgc3Rh dGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gRkVDT0xPUk1B VFJJWF9UWVBFX0xVTUlOQU5DRVRPQUxQSEE7IH0KIAogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJp bmcoQ29sb3JNYXRyaXhUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvc3ZnL1NWR0ZFQ29tcG9zaXRlRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZF Q29tcG9zaXRlRWxlbWVudC5oCmluZGV4IGFkZTY3MjJiMzhlYWM2Y2UyZjcyNjA0ZmVmMGM3ZDdk MTk0NDZiNTAuLjI3NTg0YTM3Y2QyOTBiYTNmYmJkOGJhMzhiN2YyYTU4NzJmZmVmYTAgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbXBvc2l0ZUVsZW1lbnQuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb21wb3NpdGVFbGVtZW50LmgKQEAgLTMxLDYgKzMxLDcg QEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJh aXRzPENvbXBvc2l0ZU9wZXJhdGlvblR5cGU+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVz dEVudW1WYWx1ZSgpIHsgcmV0dXJuIEZFQ09NUE9TSVRFX09QRVJBVE9SX0FSSVRITUVUSUM7IH0K KyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSB7IHJldHVybiBG RUNPTVBPU0lURV9PUEVSQVRPUl9BUklUSE1FVElDOyB9CiAKICAgICBzdGF0aWMgU3RyaW5nIHRv U3RyaW5nKENvbXBvc2l0ZU9wZXJhdGlvblR5cGUgdHlwZSkKICAgICB7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQuaCBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5oCmluZGV4IGQ2NmNkMWIxZjk3 Nzg1MjM1YWI1ZDAzODE3MjIxZjA0NWU5M2UyZWQuLmE2ZDk4MWM2M2M2ODJhZDk4NWY2YzlkYjgz YzFhZDFkYzVlODgwMDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbnZv bHZlTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbnZvbHZl TWF0cml4RWxlbWVudC5oCkBAIC0zMyw2ICszMyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIHRl bXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxFZGdlTW9kZVR5cGU+IHsKICAgICBz dGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIEVER0VNT0RFX05PTkU7 IH0KKyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSB7IHJldHVy biBFREdFTU9ERV9OT05FOyB9CiAKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKEVkZ2VNb2Rl VHlwZSB0eXBlKQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRURp c3BsYWNlbWVudE1hcEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRURpc3BsYWNl bWVudE1hcEVsZW1lbnQuaAppbmRleCBhNjRmODE5NjkyZTU1ZjEyOWIwZjY2Njk1NDk1OTg4Nzcy NjcyOGQxLi41YmYyYzZkODRiYzBkYzcyMTc1YTU3ZmM4ZTJjMmVkNDg3ZjI2OTA0IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50LmgKKysr IGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFRGlzcGxhY2VtZW50TWFwRWxlbWVudC5oCkBAIC0z MCw2ICszMCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQ cm9wZXJ0eVRyYWl0czxDaGFubmVsU2VsZWN0b3JUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVk IGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBDSEFOTkVMX0E7IH0KKyAgICBzdGF0aWMgdW5z aWduZWQgaGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSB7IHJldHVybiBDSEFOTkVMX0E7IH0KIAog ICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoQ2hhbm5lbFNlbGVjdG9yVHlwZSB0eXBlKQogICAg IHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRU1vcnBob2xvZ3lFbGVtZW50 LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVNb3JwaG9sb2d5RWxlbWVudC5oCmluZGV4IGEw MTY1NjZlNzAyMjkxZTExZGY3OGVkMTUyMTJmNTEzZGFjOTA0ZDUuLjUxMDE3Yjk2OWU2MTQ0NDFm YmY3M2MyZWQ4ZmQ0NDdjMmY4YjQxOGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9T VkdGRU1vcnBob2xvZ3lFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFTW9y cGhvbG9neUVsZW1lbnQuaApAQCAtMzAsNiArMzAsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiB0 ZW1wbGF0ZTw+CiBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8TW9ycGhvbG9neU9wZXJhdG9yVHlw ZT4gewogICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gRkVN T1JQSE9MT0dZX09QRVJBVE9SX0RJTEFURTsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0 RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIEZFTU9SUEhPTE9HWV9PUEVSQVRPUl9ESUxBVEU7 IH0KIAogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoTW9ycGhvbG9neU9wZXJhdG9yVHlwZSB0 eXBlKQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRVR1cmJ1bGVu Y2VFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVUdXJidWxlbmNlRWxlbWVudC5o CmluZGV4IGE0ZWYwMWZkM2JmZGYyYjRjY2QxYTEzOGFkY2VjZGQwYmEwOGJjYTQuLmQ0ZWJjNmM0 ZjM4N2QxMjBhODU4OWE0NTNiYTNiYzMxZDgyMGI0NjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdGRVR1cmJ1bGVuY2VFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3Zn L1NWR0ZFVHVyYnVsZW5jZUVsZW1lbnQuaApAQCAtMzgsNiArMzgsNyBAQCBlbnVtIFNWR1N0aXRj aE9wdGlvbnMgewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR1N0aXRj aE9wdGlvbnM+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0 dXJuIFNWR19TVElUQ0hUWVBFX05PU1RJVENIOyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hl c3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gU1ZHX1NUSVRDSFRZUEVfTk9TVElUQ0g7IH0K IAogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoU1ZHU3RpdGNoT3B0aW9ucyB0eXBlKQogICAg IHsKQEAgLTY3LDYgKzY4LDcgQEAgc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR1N0aXRjaE9w dGlvbnM+IHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxUdXJidWxlbmNl VHlwZT4gewogICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4g RkVUVVJCVUxFTkNFX1RZUEVfVFVSQlVMRU5DRTsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdo ZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIEZFVFVSQlVMRU5DRV9UWVBFX1RVUkJVTEVO Q0U7IH0KIAogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoVHVyYnVsZW5jZVR5cGUgdHlwZSkK ICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHR3JhZGllbnRFbGVtZW50 LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHR3JhZGllbnRFbGVtZW50LmgKaW5kZXggMTYyZGVm NDQ5YjUxZWI0NjM1MWRmZTZhMzk4NGVlYTg4MjM1NzEyOC4uYWEyZWRjZmI4ZTk4MTMxMjY4ZGUx MzA0MGMzMzdhZDFmNWNkODY0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0dy YWRpZW50RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdHcmFkaWVudEVsZW1l bnQuaApAQCAtNDMsNiArNDMsNyBAQCBlbnVtIFNWR1NwcmVhZE1ldGhvZFR5cGUgewogdGVtcGxh dGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR1NwcmVhZE1ldGhvZFR5cGU+IHsKICAg ICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIFNWR1NwcmVhZE1l dGhvZFJlcGVhdDsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSgpIHsgcmV0dXJuIFNWR1NwcmVhZE1ldGhvZFJlcGVhdDsgfQogCiAgICAgc3RhdGljIFN0cmlu ZyB0b1N0cmluZyhTVkdTcHJlYWRNZXRob2RUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvc3ZnL1NWR01hcmtlckVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2 Zy9TVkdNYXJrZXJFbGVtZW50LmgKaW5kZXggMDRiYzFjOWFhYzQ2MzI5OTY3N2Q0MjE1NTU4Yzky NzNkYjdjNDI3Ni4uNzlkOTI2OTI5ZWFmNmVjNTQ5NzVhZjJmOWJlNTFiYjIzYWIyYzliZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR01hcmtlckVsZW1lbnQuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9zdmcvU1ZHTWFya2VyRWxlbWVudC5oCkBAIC01MSw2ICs1MSw3IEBAIGVudW0g U1ZHTWFya2VyT3JpZW50VHlwZSB7CiB0ZW1wbGF0ZTw+CiBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFp dHM8U1ZHTWFya2VyVW5pdHNUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVt VmFsdWUoKSB7IHJldHVybiBTVkdNYXJrZXJVbml0c1N0cm9rZVdpZHRoOyB9CisgICAgc3RhdGlj IHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gU1ZHTWFya2VyVW5p dHNTdHJva2VXaWR0aDsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdNYXJrZXJV bml0c1R5cGUgdHlwZSkKICAgICB7CkBAIC04MCw2ICs4MSw3IEBAIHN0cnVjdCBTVkdQcm9wZXJ0 eVRyYWl0czxTVkdNYXJrZXJVbml0c1R5cGU+IHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9w ZXJ0eVRyYWl0czxTVkdNYXJrZXJPcmllbnRUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhp Z2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdNYXJrZXJPcmllbnRBbmdsZTsgfQorICAgIHN0 YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIFNWR01hcmtl ck9yaWVudEFuZ2xlOyB9CiAKICAgICAvLyB0b1N0cmluZyBpcyBub3QgbmVlZGVkLCBzeW5jaHJv bml6ZU9yaWVudFR5cGUoKSBoYW5kbGVzIHRoaXMgb24gaXRzIG93bi4KIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5oIGIvU291cmNlL1dlYkNv cmUvc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5oCmluZGV4IDQ0M2ExMDIyN2FhM2NiYTNlZGQy MWNjZGY2OWIzNGQxMjc2NTRlYWYuLjZkN2QwZDM1MzM1NGZkMzY1Njg0OTg0MmJmMTRiNGZmZDI5 YjM3NjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0Q29udGVudEVsZW1l bnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50LmgKQEAg LTM4LDYgKzM4LDcgQEAgZW51bSBTVkdMZW5ndGhBZGp1c3RUeXBlIHsKIHRlbXBsYXRlPD4KIHN0 cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdMZW5ndGhBZGp1c3RUeXBlPiB7CiAgICAgc3RhdGlj IHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdMZW5ndGhBZGp1c3RTcGFj aW5nQW5kR2x5cGhzOyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZh bHVlKCkgeyByZXR1cm4gU1ZHTGVuZ3RoQWRqdXN0U3BhY2luZ0FuZEdseXBoczsgfQogCiAgICAg c3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdMZW5ndGhBZGp1c3RUeXBlIHR5cGUpCiAgICAgewpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRQYXRoRWxlbWVudC5oIGIvU291 cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRQYXRoRWxlbWVudC5oCmluZGV4IDdlMzRhNWRmNmE5MmMy N2IwMmFjMjk3ZTU1MjkxZjkyMzY2NGFhMDMuLjJmYTYwNWM2ZTZlZTZjZTVhZDI3OWE4MzdlYTg2 YjBkM2MxYTg4NDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0UGF0aEVs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVGV4dFBhdGhFbGVtZW50LmgKQEAg LTQxLDYgKzQxLDcgQEAgZW51bSBTVkdUZXh0UGF0aFNwYWNpbmdUeXBlIHsKIHRlbXBsYXRlPD4K IHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0UGF0aE1ldGhvZFR5cGU+IHsKICAgICBz dGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIFNWR1RleHRQYXRoTWV0 aG9kU3RyZXRjaDsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSgpIHsgcmV0dXJuIFNWR1RleHRQYXRoTWV0aG9kU3RyZXRjaDsgfQogCiAgICAgc3RhdGljIFN0 cmluZyB0b1N0cmluZyhTVkdUZXh0UGF0aE1ldGhvZFR5cGUgdHlwZSkKICAgICB7CkBAIC03MCw2 ICs3MSw3IEBAIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0UGF0aE1ldGhvZFR5cGU+ IHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0UGF0aFNwYWNp bmdUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVy biBTVkdUZXh0UGF0aFNwYWNpbmdFeGFjdDsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0 RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIFNWR1RleHRQYXRoU3BhY2luZ0V4YWN0OyB9CiAK ICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKFNWR1RleHRQYXRoU3BhY2luZ1R5cGUgdHlwZSkK ICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVW5pdFR5cGVzLmggYi9T b3VyY2UvV2ViQ29yZS9zdmcvU1ZHVW5pdFR5cGVzLmgKaW5kZXggMWMzNDlkN2Q1N2UyNzQwOWQw NzU4YjE2MjViNjJjZGIzNzAxMGRmZi4uOGFhNTYxMjMzN2YyMGI2NmUwYWI0NjUzNWNmZDE2YmZi MjcyNjM3NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1VuaXRUeXBlcy5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdVbml0VHlwZXMuaApAQCAtNDAsNiArNDAsNyBAQCBw cml2YXRlOgogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR1VuaXRUeXBl czo6U1ZHVW5pdFR5cGU+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgp IHsgcmV0dXJuIFNWR1VuaXRUeXBlczo6U1ZHX1VOSVRfVFlQRV9PQkpFQ1RCT1VORElOR0JPWDsg fQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJu IFNWR1VuaXRUeXBlczo6U1ZHX1VOSVRfVFlQRV9PQkpFQ1RCT1VORElOR0JPWDsgfQogCiAgICAg c3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdVbml0VHlwZXM6OlNWR1VuaXRUeXBlIHR5cGUpCiAg ICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0 ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3Bl cnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oCmluZGV4IGQxZDJk MDMwM2JkZTAxZmQ2MTI3M2Y2OTllNTgxYWIyNGJlYWVhMjQuLmMwMTQwODRlMmYxZTEyODEwZWE5 NzdmMzMxZDJhNTU5NjI5ZGNmMjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9w ZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlU ZWFyT2ZmLmgKQEAgLTI5LDEwICsyOSwzMyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiB0ZW1wbGF0 ZTx0eXBlbmFtZSBFbnVtVHlwZT4KIGNsYXNzIFNWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0 eVRlYXJPZmYgOiBwdWJsaWMgU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY8dW5zaWdu ZWQ+IHsKIHB1YmxpYzoKKyAgICB2aXJ0dWFsIHVuc2lnbmVkJiBiYXNlVmFsKCkgb3ZlcnJpZGUK KyAgICB7CisgICAgICAgIHN0YXRpYyB1bnNpZ25lZCBvdXRPZlJhbmdlRW51bVZhbHVlID0gMDsK KworICAgICAgICBpZiAobV9wcm9wZXJ0eSA+IFNWR1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6 aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkKKyAgICAgICAgICAgIHJldHVybiBvdXRPZlJhbmdl RW51bVZhbHVlOworCisgICAgICAgIHJldHVybiBtX3Byb3BlcnR5OworICAgIH0KKworICAgIHZp cnR1YWwgdW5zaWduZWQmIGFuaW1WYWwoKSBvdmVycmlkZQorICAgIHsKKyAgICAgICAgc3RhdGlj IHVuc2lnbmVkIG91dE9mUmFuZ2VFbnVtVmFsdWUgPSAwOworCisgICAgICAgIGlmICghbV9hbmlt YXRlZFByb3BlcnR5KQorICAgICAgICAgICAgcmV0dXJuIGJhc2VWYWwoKTsKKworICAgICAgICBp ZiAoKm1fYW5pbWF0ZWRQcm9wZXJ0eSA+IFNWR1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6aGln aGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkKKyAgICAgICAgICAgIHJldHVybiBvdXRPZlJhbmdlRW51 bVZhbHVlOworCisgICAgICAgIHJldHVybiAqbV9hbmltYXRlZFByb3BlcnR5OworICAgIH0KKwog ICAgIHZpcnR1YWwgdm9pZCBzZXRCYXNlVmFsKGNvbnN0IHVuc2lnbmVkJiBwcm9wZXJ0eSwgRXhj ZXB0aW9uQ29kZSYgZWMpIG92ZXJyaWRlCiAgICAgewogICAgICAgICAvLyBBbGwgU1ZHIGVudW1l cmF0aW9uIHZhbHVlcywgdGhhdCBhcmUgYWxsb3dlZCB0byBiZSBzZXQgdmlhIFNWRyBET00gc3Rh cnQgd2l0aCAxLCAwIGNvcnJlc3BvbmRzIHRvIHVua25vd24gYW5kIGlzIG5vdCBzZXR0YWJsZSB0 aHJvdWdoIFNWRyBET00uCi0gICAgICAgIGlmICghcHJvcGVydHkgfHwgcHJvcGVydHkgPiBTVkdQ cm9wZXJ0eVRyYWl0czxFbnVtVHlwZT46OmhpZ2hlc3RFbnVtVmFsdWUoKSkgeworICAgICAgICBp ZiAoIXByb3BlcnR5IHx8IHByb3BlcnR5ID4gU1ZHUHJvcGVydHlUcmFpdHM8RW51bVR5cGU+Ojpo aWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHx8IHByb3BlcnR5ID4gU1ZHUHJvcGVydHlUcmFpdHM8 RW51bVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkpIHsKICAgICAgICAgICAgIGVjID0gU1ZHRXhj ZXB0aW9uOjpTVkdfSU5WQUxJRF9WQUxVRV9FUlI7CiAgICAgICAgICAgICByZXR1cm47CiAgICAg ICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1h dGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmLmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGll cy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oCmluZGV4IDc3ZjZlNDkxNzMzNjRj MTBiY2ZmOTgzODFkOTRlMmEwOGVjZjQxMWUuLjk5MzIzMTVlY2Q1YjY4OTUyODI4MzE2NjgxMDli MjQ5MzI3NTA4YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NW R0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmLmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3Zn L3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaApAQCAtMzAsMTIg KzMwLDEyIEBAIGNsYXNzIFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmIDogcHVibGlj IFNWR0FuaW1hdGVkUHJvcGVydHkgewogcHVibGljOgogICAgIHR5cGVkZWYgUHJvcGVydHlUeXBl IENvbnRlbnRUeXBlOwogCi0gICAgUHJvcGVydHlUeXBlJiBiYXNlVmFsKCkKKyAgICB2aXJ0dWFs IFByb3BlcnR5VHlwZSYgYmFzZVZhbCgpCiAgICAgewogICAgICAgICByZXR1cm4gbV9wcm9wZXJ0 eTsKICAgICB9CiAKLSAgICBQcm9wZXJ0eVR5cGUmIGFuaW1WYWwoKQorICAgIHZpcnR1YWwgUHJv cGVydHlUeXBlJiBhbmltVmFsKCkKICAgICB7CiAgICAgICAgIGlmIChtX2FuaW1hdGVkUHJvcGVy dHkpCiAgICAgICAgICAgICByZXR1cm4gKm1fYW5pbWF0ZWRQcm9wZXJ0eTsKQEAgLTEwNSw3ICsx MDUsNiBAQCBwcm90ZWN0ZWQ6CiAgICAgewogICAgIH0KIAotcHJpdmF0ZToKICAgICBQcm9wZXJ0 eVR5cGUmIG1fcHJvcGVydHk7CiAgICAgUHJvcGVydHlUeXBlKiBtX2FuaW1hdGVkUHJvcGVydHk7 CiB9Owo= 268502 2016-01-07 15:43:57 -0800 2016-01-07 16:39:47 -0800 Patch bug-152814-20160108104324.patch text/plain 15513 nikos.andronikos U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0NjcxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTdhYjQwYWNjYTg5ODky NmMwOWVjNzgwODFlZjMwY2ZlNWRkNzk4Yy4uNTk0ODBkZTdkYjU3NGU0OTI3YjkwNDg5MzcwNGJm YWRjNmMzODhiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUzIEBACisyMDE2LTAxLTA3ICBOaWtv cyBBbmRyb25pa29zICA8bmlrb3MuYW5kcm9uaWtvcy13ZWJraXRAY2lzcmEuY2Fub24uY29tLmF1 PgorCisgICAgICAgIFNWRyAyIHJlcXVpcmVzIGEgbWVjaGFuaXNtIGZvciByZXN0cmljdGluZyBl bnVtIHZhbHVlcyBleHBvc2VkIHRocm91Z2ggdGhlIERPTQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyODE0CisgCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoTm8gY2hhbmdlIGluIGZ1 bmN0aW9uYWxpdHksIGJsb2NrZWQgYnVncyBhZGQgbmV3IHRlc3RzKS4KKworICAgICAgICBUaGlz IHBhdGNoIGFkZHMgYSBtZWNoYW5pc20gdG8gcmVzdHJpY3QgdGhlIHZhbHVlcyByZXR1cm5lZCB0 aHJvdWdoIHRoZQorICAgICAgICBTVkdBbmltYXRlZEVudW1lcmF0aW9uIGludGVyZmFjZS4KKyAg ICAgICAgVGhpcyBpcyByZXF1aXJlZCBmb3IgU1ZHIDIsIHdoaWNoIGRvZXMgbm90IGV4cG9zZSBu ZXcgZW51bWVyYXRpb24KKyAgICAgICAgdmFsdWVzIHRocm91Z2ggdGhlIElETC4KKworICAgICAg ICAqIHN2Zy9TVkdDb21wb25lbnRUcmFuc2ZlckZ1bmN0aW9uRWxlbWVudC5oOgorICAgICAgICAo V2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8Q29tcG9uZW50VHJhbnNmZXJUeXBlPjo6aGlnaGVz dEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVCbGVuZEVsZW1l bnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPEJsZW5kTW9kZT46Omhp Z2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR0ZFQ29sb3JN YXRyaXhFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxDb2xv ck1hdHJpeFR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAq IHN2Zy9TVkdGRUNvbXBvc2l0ZUVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3Bl cnR5VHJhaXRzPENvbXBvc2l0ZU9wZXJhdGlvblR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5oOgor ICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8RWRnZU1vZGVUeXBlPjo6aGlnaGVz dEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVEaXNwbGFjZW1l bnRNYXBFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxDaGFu bmVsU2VsZWN0b3JUeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAg ICAgKiBzdmcvU1ZHRkVNb3JwaG9sb2d5RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZH UHJvcGVydHlUcmFpdHM8TW9ycGhvbG9neU9wZXJhdG9yVHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51 bVZhbHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR0ZFVHVyYnVsZW5jZUVsZW1lbnQuaDoK KyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR1N0aXRjaE9wdGlvbnM+Ojpo aWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJv cGVydHlUcmFpdHM8VHVyYnVsZW5jZVR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFk ZGVkLgorICAgICAgICAqIHN2Zy9TVkdHcmFkaWVudEVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNv cmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR1NwcmVhZE1ldGhvZFR5cGU+OjpoaWdoZXN0RXhwb3Nl ZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9TVkdNYXJrZXJFbGVtZW50Lmg6Cisg ICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxTVkdNYXJrZXJVbml0c1R5cGU+Ojpo aWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJv cGVydHlUcmFpdHM8U1ZHTWFya2VyT3JpZW50VHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVl KTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5oOgorICAgICAg ICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHTGVuZ3RoQWRqdXN0VHlwZT46OmhpZ2hl c3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR1RleHRQYXRoRWxl bWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHVGV4dFBhdGhN ZXRob2RUeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR1RleHRQYXRoU3BhY2luZ1R5cGU+OjpoaWdoZXN0 RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9TVkdVbml0VHlwZXMuaDoK KyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR1VuaXRUeXBlczo6U1ZHVW5p dFR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9w cm9wZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaDogQWRkIGRl ZmluaXRpb25zIGZvciBiYXNlVmFsIGFuZCBhbmltVmFsIG1ldGhvZHMuCisgICAgICAgICogc3Zn L3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaDogTWFrZSBiYXNl VmFsKCkgYW5kIGFuaW1WYWwoKSB2aXJ0dWFsLgorICAgICAgICAoV2ViQ29yZTo6U1ZHQW5pbWF0 ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmJhc2VWYWwpOiBPdmVycmlkZSBiYXNlIG1ldGhvZCBh bmQgbGltaXQgcmV0dXJuZWQKKyAgICAgICAgICB2YWx1ZSB0byBoaWdoZXN0RXhwb3NlZEVudW1W YWx1ZSgpIGZvciB0aGF0IHR5cGUuCisgICAgICAgIChXZWJDb3JlOjpTVkdBbmltYXRlZFN0YXRp Y1Byb3BlcnR5VGVhck9mZjo6YW5pbVZhbCk6IE92ZXJyaWRlIGJhc2UgbWV0aG9kIGFuZCBsaW1p dCByZXR1cm5lZAorICAgICAgICAgIHZhbHVlIHRvIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkg Zm9yIHRoYXQgdHlwZS4KKwogMjAxNi0wMS0wNiAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBs ZS5jb20+CiAKICAgICAgICAgTW9kZXJuIElEQjogc3RvcmFnZS9pbmRleGVkZGIvb2RkLXN0cmlu Z3MuaHRtbCBpcyBmbGFreS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdDb21w b25lbnRUcmFuc2ZlckZ1bmN0aW9uRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0Nv bXBvbmVudFRyYW5zZmVyRnVuY3Rpb25FbGVtZW50LmgKaW5kZXggYmU0ZmU5NzMxY2RiODQ3NWRh YmE0MTY1YmNjZWI5MDhiNWUyYWZhMS4uOTgxNTdiZDRlODNhY2FmN2I5ZGRlNWRhYWIyZDE4OGI1 YzhlNWFjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0NvbXBvbmVudFRyYW5z ZmVyRnVuY3Rpb25FbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0NvbXBvbmVu dFRyYW5zZmVyRnVuY3Rpb25FbGVtZW50LmgKQEAgLTMxLDYgKzMxLDcgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPENvbXBvbmVudFRy YW5zZmVyVHlwZT4gewogICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyBy ZXR1cm4gRkVDT01QT05FTlRUUkFOU0ZFUl9UWVBFX0dBTU1BOyB9CisgICAgc3RhdGljIHVuc2ln bmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1WYWx1ZSgp OyB9CiAKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKENvbXBvbmVudFRyYW5zZmVyVHlwZSB0 eXBlKQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUJsZW5kRWxl bWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQmxlbmRFbGVtZW50LmgKaW5kZXggZTBh N2NhMzMxMmU1ZTA0ZWEzMTUzY2RhYzUxOThkMzNmOTFkMDA2ZS4uMDE0Yzk0ZmUyMWI4OGI5MTA1 ODdiMTE2NWQzMzBlMmMzNTkzMmUwMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NW R0ZFQmxlbmRFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQmxlbmRFbGVt ZW50LmgKQEAgLTMxLDYgKzMxLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxhdGU8Pgog c3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPEJsZW5kTW9kZT4gewogICAgIHN0YXRpYyB1bnNpZ25l ZCBoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gQmxlbmRNb2RlTGlnaHRlbjsgfQorICAgIHN0 YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RF bnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhCbGVuZE1vZGUgdHlw ZSkKICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb2xvck1hdHJp eEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5o CmluZGV4IGQwOWM3NzZmNTc0YmI1ODM5ZDRkOTFlNWU4OGI5OTQ5Y2YzODI2YzEuLjQ5ZWNlNzY4 OTA2ZmFiOWNlY2YwYTE3YzdlMTdlNmVmOTJmODQ1ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2 Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5oCkBAIC0zMSw2ICszMSw3IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxDb2xvck1hdHJp eFR5cGU+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJu IEZFQ09MT1JNQVRSSVhfVFlQRV9MVU1JTkFOQ0VUT0FMUEhBOyB9CisgICAgc3RhdGljIHVuc2ln bmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1WYWx1ZSgp OyB9CiAKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKENvbG9yTWF0cml4VHlwZSB0eXBlKQog ICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbXBvc2l0ZUVsZW1l bnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbXBvc2l0ZUVsZW1lbnQuaAppbmRleCBh ZGU2NzIyYjM4ZWFjNmNlMmY3MjYwNGZlZjBjN2Q3ZDE5NDQ2YjUwLi4zYTY2NTM2NGVjMjI1NGJj NTlhOTYyNmRhNDYwMDhiMGI2ZmRmNTY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcv U1ZHRkVDb21wb3NpdGVFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQ29t cG9zaXRlRWxlbWVudC5oCkBAIC0zMSw2ICszMSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIHRl bXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxDb21wb3NpdGVPcGVyYXRpb25UeXBl PiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBGRUNP TVBPU0lURV9PUEVSQVRPUl9BUklUSE1FVElDOyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hl c3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1WYWx1ZSgpOyB9CiAKICAg ICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKENvbXBvc2l0ZU9wZXJhdGlvblR5cGUgdHlwZSkKICAg ICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb252b2x2ZU1hdHJpeEVs ZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5o CmluZGV4IGQ2NmNkMWIxZjk3Nzg1MjM1YWI1ZDAzODE3MjIxZjA0NWU5M2UyZWQuLmUyODExOTE3 NDI0MmIwMmUwNmU2Y2E0YWY2YzgzM2JiNzM3ODVkNDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3N2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5oCkBAIC0zMyw2ICszMyw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxFZGdl TW9kZVR5cGU+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0 dXJuIEVER0VNT0RFX05PTkU7IH0KKyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEV4cG9zZWRF bnVtVmFsdWUoKSB7IHJldHVybiBoaWdoZXN0RW51bVZhbHVlKCk7IH0KIAogICAgIHN0YXRpYyBT dHJpbmcgdG9TdHJpbmcoRWRnZU1vZGVUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFRGlzcGxhY2VtZW50TWFwRWxlbWVudC5oIGIvU291cmNlL1dl YkNvcmUvc3ZnL1NWR0ZFRGlzcGxhY2VtZW50TWFwRWxlbWVudC5oCmluZGV4IGE2NGY4MTk2OTJl NTVmMTI5YjBmNjY2OTU0OTU5ODg3NzI2NzI4ZDEuLjE2MmY2NGIzM2UwNTMwM2RmNTNmNGExNDNl NjAxMzE3MmMzMDI2MWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRURpc3Bs YWNlbWVudE1hcEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVEaXNwbGFj ZW1lbnRNYXBFbGVtZW50LmgKQEAgLTMwLDYgKzMwLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog dGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPENoYW5uZWxTZWxlY3RvclR5cGU+ IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIENIQU5O RUxfQTsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsg cmV0dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmlu ZyhDaGFubmVsU2VsZWN0b3JUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvc3ZnL1NWR0ZFTW9ycGhvbG9neUVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9T VkdGRU1vcnBob2xvZ3lFbGVtZW50LmgKaW5kZXggYTAxNjU2NmU3MDIyOTFlMTFkZjc4ZWQxNTIx MmY1MTNkYWM5MDRkNS4uN2RiZDBlMWRiMGI4N2RkNjZkNWMyZWI2NzFhZjRlZDkzYzFjYjZjMCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFTW9ycGhvbG9neUVsZW1lbnQuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVNb3JwaG9sb2d5RWxlbWVudC5oCkBAIC0zMCw2 ICszMCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9w ZXJ0eVRyYWl0czxNb3JwaG9sb2d5T3BlcmF0b3JUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVk IGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBGRU1PUlBIT0xPR1lfT1BFUkFUT1JfRElMQVRF OyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1 cm4gaGlnaGVzdEVudW1WYWx1ZSgpOyB9CiAKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKE1v cnBob2xvZ3lPcGVyYXRvclR5cGUgdHlwZSkKICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHRkVUdXJidWxlbmNlRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NW R0ZFVHVyYnVsZW5jZUVsZW1lbnQuaAppbmRleCBhNGVmMDFmZDNiZmRmMmI0Y2NkMWExMzhhZGNl Y2RkMGJhMDhiY2E0Li41NmI3MjQ0NzY0YWQyNTU3Nzc2MTRkMGQ4NmUzYjk3NzQ2NGFjMGUyIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVUdXJidWxlbmNlRWxlbWVudC5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRVR1cmJ1bGVuY2VFbGVtZW50LmgKQEAgLTM4LDYg KzM4LDcgQEAgZW51bSBTVkdTdGl0Y2hPcHRpb25zIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQ cm9wZXJ0eVRyYWl0czxTVkdTdGl0Y2hPcHRpb25zPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhp Z2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdfU1RJVENIVFlQRV9OT1NUSVRDSDsgfQorICAg IHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hl c3RFbnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdTdGl0Y2hP cHRpb25zIHR5cGUpCiAgICAgewpAQCAtNjcsNiArNjgsNyBAQCBzdHJ1Y3QgU1ZHUHJvcGVydHlU cmFpdHM8U1ZHU3RpdGNoT3B0aW9ucz4gewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5 VHJhaXRzPFR1cmJ1bGVuY2VUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVt VmFsdWUoKSB7IHJldHVybiBGRVRVUkJVTEVOQ0VfVFlQRV9UVVJCVUxFTkNFOyB9CisgICAgc3Rh dGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVu dW1WYWx1ZSgpOyB9CiAKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKFR1cmJ1bGVuY2VUeXBl IHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0dyYWRpZW50 RWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0dyYWRpZW50RWxlbWVudC5oCmluZGV4 IDE2MmRlZjQ0OWI1MWViNDYzNTFkZmU2YTM5ODRlZWE4ODIzNTcxMjguLjliNDNjNGFlOGY3ZjNm NTk0ZWUxYzBiYTczZjliNjYxYTk1YjQ5MjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2 Zy9TVkdHcmFkaWVudEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHR3JhZGll bnRFbGVtZW50LmgKQEAgLTQzLDYgKzQzLDcgQEAgZW51bSBTVkdTcHJlYWRNZXRob2RUeXBlIHsK IHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdTcHJlYWRNZXRob2RUeXBl PiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdT cHJlYWRNZXRob2RSZXBlYXQ7IH0KKyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEV4cG9zZWRF bnVtVmFsdWUoKSB7IHJldHVybiBoaWdoZXN0RW51bVZhbHVlKCk7IH0KIAogICAgIHN0YXRpYyBT dHJpbmcgdG9TdHJpbmcoU1ZHU3ByZWFkTWV0aG9kVHlwZSB0eXBlKQogICAgIHsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdNYXJrZXJFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29y ZS9zdmcvU1ZHTWFya2VyRWxlbWVudC5oCmluZGV4IDA0YmMxYzlhYWM0NjMyOTk2NzdkNDIxNTU1 OGM5MjczZGI3YzQyNzYuLjJjMmUzMTVkYTczYmE4NDYyMGUwYzlkN2IzM2NiNjE4NTYzMDYwZWIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdNYXJrZXJFbGVtZW50LmgKKysrIGIv U291cmNlL1dlYkNvcmUvc3ZnL1NWR01hcmtlckVsZW1lbnQuaApAQCAtNTEsNiArNTEsNyBAQCBl bnVtIFNWR01hcmtlck9yaWVudFR5cGUgewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5 VHJhaXRzPFNWR01hcmtlclVuaXRzVHlwZT4gewogICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0 RW51bVZhbHVlKCkgeyByZXR1cm4gU1ZHTWFya2VyVW5pdHNTdHJva2VXaWR0aDsgfQorICAgIHN0 YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RF bnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdNYXJrZXJVbml0 c1R5cGUgdHlwZSkKICAgICB7CkBAIC04MCw2ICs4MSw3IEBAIHN0cnVjdCBTVkdQcm9wZXJ0eVRy YWl0czxTVkdNYXJrZXJVbml0c1R5cGU+IHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0 eVRyYWl0czxTVkdNYXJrZXJPcmllbnRUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hl c3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdNYXJrZXJPcmllbnRBbmdsZTsgfQorICAgIHN0YXRp YyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RFbnVt VmFsdWUoKTsgfQogCiAgICAgLy8gdG9TdHJpbmcgaXMgbm90IG5lZWRlZCwgc3luY2hyb25pemVP cmllbnRUeXBlKCkgaGFuZGxlcyB0aGlzIG9uIGl0cyBvd24uCiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3N2Zy9TVkdUZXh0Q29udGVudEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2 Zy9TVkdUZXh0Q29udGVudEVsZW1lbnQuaAppbmRleCA0NDNhMTAyMjdhYTNjYmEzZWRkMjFjY2Rm NjliMzRkMTI3NjU0ZWFmLi5jZjAyYjUxYjFiNTI4ZGY2NGU2YzM1NmNiMTA2YzYyOGI0NzhjMzdk IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50LmgK KysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5oCkBAIC0zOCw2 ICszOCw3IEBAIGVudW0gU1ZHTGVuZ3RoQWRqdXN0VHlwZSB7CiB0ZW1wbGF0ZTw+CiBzdHJ1Y3Qg U1ZHUHJvcGVydHlUcmFpdHM8U1ZHTGVuZ3RoQWRqdXN0VHlwZT4gewogICAgIHN0YXRpYyB1bnNp Z25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gU1ZHTGVuZ3RoQWRqdXN0U3BhY2luZ0Fu ZEdseXBoczsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgp IHsgcmV0dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0 cmluZyhTVkdMZW5ndGhBZGp1c3RUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvc3ZnL1NWR1RleHRQYXRoRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NW R1RleHRQYXRoRWxlbWVudC5oCmluZGV4IDdlMzRhNWRmNmE5MmMyN2IwMmFjMjk3ZTU1MjkxZjky MzY2NGFhMDMuLjgzNmQwNDY1NjUxMmQ4M2JjNWU5OWY1NzAyM2EzZGU2OTdiMDAxNGUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0UGF0aEVsZW1lbnQuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9zdmcvU1ZHVGV4dFBhdGhFbGVtZW50LmgKQEAgLTQxLDYgKzQxLDcgQEAgZW51 bSBTVkdUZXh0UGF0aFNwYWNpbmdUeXBlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0 eVRyYWl0czxTVkdUZXh0UGF0aE1ldGhvZFR5cGU+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGln aGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIFNWR1RleHRQYXRoTWV0aG9kU3RyZXRjaDsgfQorICAg IHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hl c3RFbnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdUZXh0UGF0 aE1ldGhvZFR5cGUgdHlwZSkKICAgICB7CkBAIC03MCw2ICs3MSw3IEBAIHN0cnVjdCBTVkdQcm9w ZXJ0eVRyYWl0czxTVkdUZXh0UGF0aE1ldGhvZFR5cGU+IHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBT VkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0UGF0aFNwYWNpbmdUeXBlPiB7CiAgICAgc3RhdGljIHVu c2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdUZXh0UGF0aFNwYWNpbmdFeGFj dDsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0 dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhT VkdUZXh0UGF0aFNwYWNpbmdUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvc3ZnL1NWR1VuaXRUeXBlcy5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1VuaXRUeXBl cy5oCmluZGV4IDFjMzQ5ZDdkNTdlMjc0MDlkMDc1OGIxNjI1YjYyY2RiMzcwMTBkZmYuLmU1NWE2 OTg1OTg4MjYzMzBjMWQ3YjllOGEwZmIxZWRhZjY4MjkyM2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdVbml0VHlwZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVW5p dFR5cGVzLmgKQEAgLTQwLDYgKzQwLDcgQEAgcHJpdmF0ZToKIHRlbXBsYXRlPD4KIHN0cnVjdCBT VkdQcm9wZXJ0eVRyYWl0czxTVkdVbml0VHlwZXM6OlNWR1VuaXRUeXBlPiB7CiAgICAgc3RhdGlj IHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdVbml0VHlwZXM6OlNWR19V TklUX1RZUEVfT0JKRUNUQk9VTkRJTkdCT1g7IH0KKyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVz dEV4cG9zZWRFbnVtVmFsdWUoKSB7IHJldHVybiBoaWdoZXN0RW51bVZhbHVlKCk7IH0KIAogICAg IHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoU1ZHVW5pdFR5cGVzOjpTVkdVbml0VHlwZSB0eXBlKQog ICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1h dGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9w ZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaAppbmRleCBkMWQy ZDAzMDNiZGUwMWZkNjEyNzNmNjk5ZTU4MWFiMjRiZWFlYTI0Li5kYjQ1NmU1ZDQyNTc4OTA0NDZl MmE3Y2EzMDU4YmE4Y2ZkMzE1MDY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJv cGVydGllcy9TVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlUZWFyT2ZmLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5 VGVhck9mZi5oCkBAIC0yOSwxMCArMjksMjkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxh dGU8dHlwZW5hbWUgRW51bVR5cGU+CiBjbGFzcyBTVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVy dHlUZWFyT2ZmIDogcHVibGljIFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmPHVuc2ln bmVkPiB7CiBwdWJsaWM6CisgICAgdmlydHVhbCB1bnNpZ25lZCYgYmFzZVZhbCgpIG92ZXJyaWRl CisgICAgeworICAgICAgICBpZiAobV9wcm9wZXJ0eSA+IFNWR1Byb3BlcnR5VHJhaXRzPEVudW1U eXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkKKyAgICAgICAgICAgIHJldHVybiBtX291 dE9mUmFuZ2VFbnVtVmFsdWU7CisKKyAgICAgICAgcmV0dXJuIG1fcHJvcGVydHk7CisgICAgfQor CisgICAgdmlydHVhbCB1bnNpZ25lZCYgYW5pbVZhbCgpIG92ZXJyaWRlCisgICAgeworICAgICAg ICBpZiAoIW1fYW5pbWF0ZWRQcm9wZXJ0eSkKKyAgICAgICAgICAgIHJldHVybiBiYXNlVmFsKCk7 CisKKyAgICAgICAgaWYgKCptX2FuaW1hdGVkUHJvcGVydHkgPiBTVkdQcm9wZXJ0eVRyYWl0czxF bnVtVHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkpCisgICAgICAgICAgICByZXR1cm4g bV9vdXRPZlJhbmdlRW51bVZhbHVlOworCisgICAgICAgIHJldHVybiAqbV9hbmltYXRlZFByb3Bl cnR5OworICAgIH0KKwogICAgIHZpcnR1YWwgdm9pZCBzZXRCYXNlVmFsKGNvbnN0IHVuc2lnbmVk JiBwcm9wZXJ0eSwgRXhjZXB0aW9uQ29kZSYgZWMpIG92ZXJyaWRlCiAgICAgewogICAgICAgICAv LyBBbGwgU1ZHIGVudW1lcmF0aW9uIHZhbHVlcywgdGhhdCBhcmUgYWxsb3dlZCB0byBiZSBzZXQg dmlhIFNWRyBET00gc3RhcnQgd2l0aCAxLCAwIGNvcnJlc3BvbmRzIHRvIHVua25vd24gYW5kIGlz IG5vdCBzZXR0YWJsZSB0aHJvdWdoIFNWRyBET00uCi0gICAgICAgIGlmICghcHJvcGVydHkgfHwg cHJvcGVydHkgPiBTVkdQcm9wZXJ0eVRyYWl0czxFbnVtVHlwZT46OmhpZ2hlc3RFbnVtVmFsdWUo KSkgeworICAgICAgICBpZiAoIXByb3BlcnR5IHx8IHByb3BlcnR5ID4gU1ZHUHJvcGVydHlUcmFp dHM8RW51bVR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHx8IHByb3BlcnR5ID4gU1ZH UHJvcGVydHlUcmFpdHM8RW51bVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkpIHsKICAgICAgICAg ICAgIGVjID0gU1ZHRXhjZXB0aW9uOjpTVkdfSU5WQUxJRF9WQUxVRV9FUlI7CiAgICAgICAgICAg ICByZXR1cm47CiAgICAgICAgIH0KQEAgLTU3LDggKzc2LDE1IEBAIHByaXZhdGU6CiAgICAgICAg IDogU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY8dW5zaWduZWQ+KGNvbnRleHRFbGVt ZW50LCBhdHRyaWJ1dGVOYW1lLCBhbmltYXRlZFByb3BlcnR5VHlwZSwgcHJvcGVydHkpCiAgICAg ewogICAgIH0KKworICAgIHN0YXRpYyB1bnNpZ25lZCBtX291dE9mUmFuZ2VFbnVtVmFsdWU7CiB9 OwogCit0ZW1wbGF0ZTx0eXBlbmFtZSBFbnVtVHlwZT4KK3Vuc2lnbmVkIFNWR0FuaW1hdGVkRW51 bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmY8RW51bVR5cGU+OjptX291dE9mUmFuZ2VFbnVtVmFsdWUg PSAwOworCiB9CiAKKworCiAjZW5kaWYgLy8gU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5 VGVhck9mZl9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdB bmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3Bl cnRpZXMvU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaAppbmRleCA3N2Y2ZTQ5MTcz MzY0YzEwYmNmZjk4MzgxZDk0ZTJhMDhlY2Y0MTFlLi45OTMyMzE1ZWNkNWI2ODk1MjgyODMxNjY4 MTA5YjI0OTMyNzUwOGFmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGll cy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmLmgKQEAgLTMw LDEyICszMCwxMiBAQCBjbGFzcyBTVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZiA6IHB1 YmxpYyBTVkdBbmltYXRlZFByb3BlcnR5IHsKIHB1YmxpYzoKICAgICB0eXBlZGVmIFByb3BlcnR5 VHlwZSBDb250ZW50VHlwZTsKIAotICAgIFByb3BlcnR5VHlwZSYgYmFzZVZhbCgpCisgICAgdmly dHVhbCBQcm9wZXJ0eVR5cGUmIGJhc2VWYWwoKQogICAgIHsKICAgICAgICAgcmV0dXJuIG1fcHJv cGVydHk7CiAgICAgfQogCi0gICAgUHJvcGVydHlUeXBlJiBhbmltVmFsKCkKKyAgICB2aXJ0dWFs IFByb3BlcnR5VHlwZSYgYW5pbVZhbCgpCiAgICAgewogICAgICAgICBpZiAobV9hbmltYXRlZFBy b3BlcnR5KQogICAgICAgICAgICAgcmV0dXJuICptX2FuaW1hdGVkUHJvcGVydHk7CkBAIC0xMDUs NyArMTA1LDYgQEAgcHJvdGVjdGVkOgogICAgIHsKICAgICB9CiAKLXByaXZhdGU6CiAgICAgUHJv cGVydHlUeXBlJiBtX3Byb3BlcnR5OwogICAgIFByb3BlcnR5VHlwZSogbV9hbmltYXRlZFByb3Bl cnR5OwogfTsK 268504 2016-01-07 16:39:53 -0800 2016-01-14 03:00:08 -0800 Patch bug-152814-20160108113920.patch text/plain 16065 nikos.andronikos U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0NjcxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTdhYjQwYWNjYTg5ODky NmMwOWVjNzgwODFlZjMwY2ZlNWRkNzk4Yy4uYWVlZTNjNTEwZDY0OTc4ZTRhMzIxNjIzMjhmODY0 Y2M0ZTQzNzBlZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY0IEBACisyMDE2LTAxLTA3ICBOaWtv cyBBbmRyb25pa29zICA8bmlrb3MuYW5kcm9uaWtvcy13ZWJraXRAY2lzcmEuY2Fub24uY29tLmF1 PgorCisgICAgICAgIFNWRyAyIHJlcXVpcmVzIGEgbWVjaGFuaXNtIGZvciByZXN0cmljdGluZyBl bnVtIHZhbHVlcyBleHBvc2VkIHRocm91Z2ggdGhlIERPTQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyODE0CisgCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoTm8gY2hhbmdlIGluIGZ1 bmN0aW9uYWxpdHksIGJsb2NrZWQgYnVncyBhZGQgbmV3IHRlc3RzKS4KKworICAgICAgICBUaGlz IHBhdGNoIGFkZHMgYSBtZWNoYW5pc20gdG8gcmVzdHJpY3QgdGhlIHZhbHVlcyByZXR1cm5lZCB0 aHJvdWdoIHRoZQorICAgICAgICBTVkdBbmltYXRlZEVudW1lcmF0aW9uIGludGVyZmFjZS4KKyAg ICAgICAgVGhpcyBpcyByZXF1aXJlZCBmb3IgU1ZHIDIsIHdoaWNoIGRvZXMgbm90IGV4cG9zZSBu ZXcgZW51bWVyYXRpb24KKyAgICAgICAgdmFsdWVzIHRocm91Z2ggdGhlIElETC4KKyAgICAgICAg CisgICAgICAgIFNlZSBodHRwOi8vd3d3LnczLm9yZy9UUi9TVkcyL3R5cGVzLmh0bWwjSW50ZXJm YWNlU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvbgorICAgICAgICBHZXR0ZXJzOgorICAgICAgICBTVkcg MiBkb2VzIG5vdCBhZGQgbnVtZXJpYyB0eXBlIHZhbHVlcyBmb3IgbmV3IG9wdGlvbnMsIG5ldyBv cHRpb25zCisgICAgICAgIHNob3VsZCByZXR1cm4gVU5LTk9XTi4KKyAgICAgICAgRS5nLiBTZWUg dGhlIHRhYmxlIGRlZmluaW5nIG51bWVyaWMgdHlwZSB2YWx1ZXMgZm9yIG9yaWVudCBhdAorICAg ICAgICBodHRwOi8vd3d3LnczLm9yZy9UUi9TVkcyL3BhaW50aW5nLmh0bWwjSW50ZXJmYWNlU1ZH TWFya2VyRWxlbWVudAorICAgICAgICBTZXR0ZXJzOgorICAgICAgICBPbiBzZXR0aW5nIGJhc2VW YWwsIHRoZSBmb2xsb3dpbmcgc3RlcHMgYXJlIHJ1bjoKKyAgICAgICAgMS4gLi4uCisgICAgICAg IDIuIElmIHZhbHVlIGlzIDAgb3IgaXMgbm90IHRoZSBudW1lcmljIHR5cGUgdmFsdWUgZm9yIGFu eSB2YWx1ZSBvZiB0aGUgcmVmbGVjdGVkIGF0dHJpYnV0ZSwgdGhlbiBzZXQgdGhlIHJlZmxlY3Rl ZCBhdHRyaWJ1dGUgdG8gdGhlIGVtcHR5IHN0cmluZy4KKworICAgICAgICAqIHN2Zy9TVkdDb21w b25lbnRUcmFuc2ZlckZ1bmN0aW9uRWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJv cGVydHlUcmFpdHM8Q29tcG9uZW50VHJhbnNmZXJUeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFs dWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVCbGVuZEVsZW1lbnQuaDoKKyAgICAgICAg KFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPEJsZW5kTW9kZT46OmhpZ2hlc3RFeHBvc2VkRW51 bVZhbHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR0ZFQ29sb3JNYXRyaXhFbGVtZW50Lmg6 CisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxDb2xvck1hdHJpeFR5cGU+Ojpo aWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9TVkdGRUNvbXBv c2l0ZUVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPENvbXBv c2l0ZU9wZXJhdGlvblR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAg ICAgICAqIHN2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29y ZTo6U1ZHUHJvcGVydHlUcmFpdHM8RWRnZU1vZGVUeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFs dWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50Lmg6 CisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxDaGFubmVsU2VsZWN0b3JUeXBl Pjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVN b3JwaG9sb2d5RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8 TW9ycGhvbG9neU9wZXJhdG9yVHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQu CisgICAgICAgICogc3ZnL1NWR0ZFVHVyYnVsZW5jZUVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNv cmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR1N0aXRjaE9wdGlvbnM+OjpoaWdoZXN0RXhwb3NlZEVu dW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8VHVy YnVsZW5jZVR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAq IHN2Zy9TVkdHcmFkaWVudEVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5 VHJhaXRzPFNWR1NwcmVhZE1ldGhvZFR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6IEFk ZGVkLgorICAgICAgICAqIHN2Zy9TVkdNYXJrZXJFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3Jl OjpTVkdQcm9wZXJ0eVRyYWl0czxTVkdNYXJrZXJVbml0c1R5cGU+OjpoaWdoZXN0RXhwb3NlZEVu dW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZH TWFya2VyT3JpZW50VHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKTogQWRkZWQuCisgICAg ICAgICogc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZH UHJvcGVydHlUcmFpdHM8U1ZHTGVuZ3RoQWRqdXN0VHlwZT46OmhpZ2hlc3RFeHBvc2VkRW51bVZh bHVlKTogQWRkZWQuCisgICAgICAgICogc3ZnL1NWR1RleHRQYXRoRWxlbWVudC5oOgorICAgICAg ICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHVGV4dFBhdGhNZXRob2RUeXBlPjo6aGln aGVzdEV4cG9zZWRFbnVtVmFsdWUpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3Bl cnR5VHJhaXRzPFNWR1RleHRQYXRoU3BhY2luZ1R5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9TVkdVbml0VHlwZXMuaDoKKyAgICAgICAgKFdlYkNv cmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR1VuaXRUeXBlczo6U1ZHVW5pdFR5cGU+OjpoaWdoZXN0 RXhwb3NlZEVudW1WYWx1ZSk6IEFkZGVkLgorICAgICAgICAqIHN2Zy9wcm9wZXJ0aWVzL1NWR0Fu aW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaDogQWRkIGRlZmluaXRpb25zIGZvciBi YXNlVmFsIGFuZCBhbmltVmFsIG1ldGhvZHMuCisgICAgICAgICogc3ZnL3Byb3BlcnRpZXMvU1ZH QW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaDogTWFrZSBiYXNlVmFsKCkgYW5kIGFuaW1W YWwoKSB2aXJ0dWFsLgorICAgICAgICAoV2ViQ29yZTo6U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0 eVRlYXJPZmY6OmJhc2VWYWwpOiBPdmVycmlkZSBiYXNlIG1ldGhvZCBhbmQgbGltaXQgcmV0dXJu ZWQKKyAgICAgICAgICB2YWx1ZSB0byBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIGZvciB0aGF0 IHR5cGUuCisgICAgICAgIChXZWJDb3JlOjpTVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9m Zjo6YW5pbVZhbCk6IE92ZXJyaWRlIGJhc2UgbWV0aG9kIGFuZCBsaW1pdCByZXR1cm5lZAorICAg ICAgICAgIHZhbHVlIHRvIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgZm9yIHRoYXQgdHlwZS4K KwogMjAxNi0wMS0wNiAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5jb20+CiAKICAgICAg ICAgTW9kZXJuIElEQjogc3RvcmFnZS9pbmRleGVkZGIvb2RkLXN0cmluZ3MuaHRtbCBpcyBmbGFr eS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdDb21wb25lbnRUcmFuc2ZlckZ1 bmN0aW9uRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0NvbXBvbmVudFRyYW5zZmVy RnVuY3Rpb25FbGVtZW50LmgKaW5kZXggYmU0ZmU5NzMxY2RiODQ3NWRhYmE0MTY1YmNjZWI5MDhi NWUyYWZhMS4uOTgxNTdiZDRlODNhY2FmN2I5ZGRlNWRhYWIyZDE4OGI1YzhlNWFjNyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0NvbXBvbmVudFRyYW5zZmVyRnVuY3Rpb25FbGVt ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0NvbXBvbmVudFRyYW5zZmVyRnVuY3Rp b25FbGVtZW50LmgKQEAgLTMxLDYgKzMxLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxh dGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPENvbXBvbmVudFRyYW5zZmVyVHlwZT4gewog ICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gRkVDT01QT05F TlRUUkFOU0ZFUl9UWVBFX0dBTU1BOyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBv c2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1WYWx1ZSgpOyB9CiAKICAgICBzdGF0 aWMgU3RyaW5nIHRvU3RyaW5nKENvbXBvbmVudFRyYW5zZmVyVHlwZSB0eXBlKQogICAgIHsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUJsZW5kRWxlbWVudC5oIGIvU291cmNl L1dlYkNvcmUvc3ZnL1NWR0ZFQmxlbmRFbGVtZW50LmgKaW5kZXggZTBhN2NhMzMxMmU1ZTA0ZWEz MTUzY2RhYzUxOThkMzNmOTFkMDA2ZS4uMDE0Yzk0ZmUyMWI4OGI5MTA1ODdiMTE2NWQzMzBlMmMz NTkzMmUwMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQmxlbmRFbGVtZW50 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQmxlbmRFbGVtZW50LmgKQEAgLTMxLDYg KzMxLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3Bl cnR5VHJhaXRzPEJsZW5kTW9kZT4gewogICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZh bHVlKCkgeyByZXR1cm4gQmxlbmRNb2RlTGlnaHRlbjsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBo aWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsgfQog CiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhCbGVuZE1vZGUgdHlwZSkKICAgICB7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb2xvck1hdHJpeEVsZW1lbnQuaCBiL1Nv dXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5oCmluZGV4IGQwOWM3NzZm NTc0YmI1ODM5ZDRkOTFlNWU4OGI5OTQ5Y2YzODI2YzEuLjQ5ZWNlNzY4OTA2ZmFiOWNlY2YwYTE3 YzdlMTdlNmVmOTJmODQ1ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNv bG9yTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0 cml4RWxlbWVudC5oCkBAIC0zMSw2ICszMSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIHRlbXBs YXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxDb2xvck1hdHJpeFR5cGU+IHsKICAgICBz dGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIEZFQ09MT1JNQVRSSVhf VFlQRV9MVU1JTkFOQ0VUT0FMUEhBOyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBv c2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1WYWx1ZSgpOyB9CiAKICAgICBzdGF0 aWMgU3RyaW5nIHRvU3RyaW5nKENvbG9yTWF0cml4VHlwZSB0eXBlKQogICAgIHsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbXBvc2l0ZUVsZW1lbnQuaCBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdGRUNvbXBvc2l0ZUVsZW1lbnQuaAppbmRleCBhZGU2NzIyYjM4ZWFjNmNl MmY3MjYwNGZlZjBjN2Q3ZDE5NDQ2YjUwLi4zYTY2NTM2NGVjMjI1NGJjNTlhOTYyNmRhNDYwMDhi MGI2ZmRmNTY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb21wb3NpdGVF bGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQ29tcG9zaXRlRWxlbWVudC5o CkBAIC0zMSw2ICszMSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIHRlbXBsYXRlPD4KIHN0cnVj dCBTVkdQcm9wZXJ0eVRyYWl0czxDb21wb3NpdGVPcGVyYXRpb25UeXBlPiB7CiAgICAgc3RhdGlj IHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBGRUNPTVBPU0lURV9PUEVSQVRP Ul9BUklUSE1FVElDOyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZh bHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1WYWx1ZSgpOyB9CiAKICAgICBzdGF0aWMgU3RyaW5n IHRvU3RyaW5nKENvbXBvc2l0ZU9wZXJhdGlvblR5cGUgdHlwZSkKICAgICB7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQuaCBiL1NvdXJj ZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5oCmluZGV4IGQ2NmNkMWIx Zjk3Nzg1MjM1YWI1ZDAzODE3MjIxZjA0NWU5M2UyZWQuLmUyODExOTE3NDI0MmIwMmUwNmU2Y2E0 YWY2YzgzM2JiNzM3ODVkNDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNv bnZvbHZlTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbnZv bHZlTWF0cml4RWxlbWVudC5oCkBAIC0zMyw2ICszMyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK IHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxFZGdlTW9kZVR5cGU+IHsKICAg ICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIEVER0VNT0RFX05P TkU7IH0KKyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSB7IHJl dHVybiBoaWdoZXN0RW51bVZhbHVlKCk7IH0KIAogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmco RWRnZU1vZGVUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3Zn L1NWR0ZFRGlzcGxhY2VtZW50TWFwRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZF RGlzcGxhY2VtZW50TWFwRWxlbWVudC5oCmluZGV4IGE2NGY4MTk2OTJlNTVmMTI5YjBmNjY2OTU0 OTU5ODg3NzI2NzI4ZDEuLjE2MmY2NGIzM2UwNTMwM2RmNTNmNGExNDNlNjAxMzE3MmMzMDI2MWIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRURpc3BsYWNlbWVudE1hcEVsZW1l bnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50 LmgKQEAgLTMwLDYgKzMwLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxhdGU8Pgogc3Ry dWN0IFNWR1Byb3BlcnR5VHJhaXRzPENoYW5uZWxTZWxlY3RvclR5cGU+IHsKICAgICBzdGF0aWMg dW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIENIQU5ORUxfQTsgfQorICAgIHN0 YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RF bnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhDaGFubmVsU2VsZWN0 b3JUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZF TW9ycGhvbG9neUVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRU1vcnBob2xvZ3lF bGVtZW50LmgKaW5kZXggYTAxNjU2NmU3MDIyOTFlMTFkZjc4ZWQxNTIxMmY1MTNkYWM5MDRkNS4u N2RiZDBlMWRiMGI4N2RkNjZkNWMyZWI2NzFhZjRlZDkzYzFjYjZjMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFTW9ycGhvbG9neUVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHRkVNb3JwaG9sb2d5RWxlbWVudC5oCkBAIC0zMCw2ICszMCw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxNb3Jw aG9sb2d5T3BlcmF0b3JUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFs dWUoKSB7IHJldHVybiBGRU1PUlBIT0xPR1lfT1BFUkFUT1JfRElMQVRFOyB9CisgICAgc3RhdGlj IHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1W YWx1ZSgpOyB9CiAKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKE1vcnBob2xvZ3lPcGVyYXRv clR5cGUgdHlwZSkKICAgICB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVU dXJidWxlbmNlRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFVHVyYnVsZW5jZUVs ZW1lbnQuaAppbmRleCBhNGVmMDFmZDNiZmRmMmI0Y2NkMWExMzhhZGNlY2RkMGJhMDhiY2E0Li41 NmI3MjQ0NzY0YWQyNTU3Nzc2MTRkMGQ4NmUzYjk3NzQ2NGFjMGUyIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9zdmcvU1ZHRkVUdXJidWxlbmNlRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdGRVR1cmJ1bGVuY2VFbGVtZW50LmgKQEAgLTM4LDYgKzM4LDcgQEAgZW51bSBT VkdTdGl0Y2hPcHRpb25zIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxT VkdTdGl0Y2hPcHRpb25zPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUo KSB7IHJldHVybiBTVkdfU1RJVENIVFlQRV9OT1NUSVRDSDsgfQorICAgIHN0YXRpYyB1bnNpZ25l ZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsg fQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdTdGl0Y2hPcHRpb25zIHR5cGUpCiAg ICAgewpAQCAtNjcsNiArNjgsNyBAQCBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8U1ZHU3RpdGNo T3B0aW9ucz4gewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFR1cmJ1bGVu Y2VUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVy biBGRVRVUkJVTEVOQ0VfVFlQRV9UVVJCVUxFTkNFOyB9CisgICAgc3RhdGljIHVuc2lnbmVkIGhp Z2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVudW1WYWx1ZSgpOyB9CiAK ICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKFR1cmJ1bGVuY2VUeXBlIHR5cGUpCiAgICAgewpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0dyYWRpZW50RWxlbWVudC5oIGIvU291 cmNlL1dlYkNvcmUvc3ZnL1NWR0dyYWRpZW50RWxlbWVudC5oCmluZGV4IDE2MmRlZjQ0OWI1MWVi NDYzNTFkZmU2YTM5ODRlZWE4ODIzNTcxMjguLjliNDNjNGFlOGY3ZjNmNTk0ZWUxYzBiYTczZjli NjYxYTk1YjQ5MjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdHcmFkaWVudEVs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHR3JhZGllbnRFbGVtZW50LmgKQEAg LTQzLDYgKzQzLDcgQEAgZW51bSBTVkdTcHJlYWRNZXRob2RUeXBlIHsKIHRlbXBsYXRlPD4KIHN0 cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdTcHJlYWRNZXRob2RUeXBlPiB7CiAgICAgc3RhdGlj IHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdTcHJlYWRNZXRob2RSZXBl YXQ7IH0KKyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSB7IHJl dHVybiBoaWdoZXN0RW51bVZhbHVlKCk7IH0KIAogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmco U1ZHU3ByZWFkTWV0aG9kVHlwZSB0eXBlKQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdNYXJrZXJFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHTWFya2Vy RWxlbWVudC5oCmluZGV4IDA0YmMxYzlhYWM0NjMyOTk2NzdkNDIxNTU1OGM5MjczZGI3YzQyNzYu LjJjMmUzMTVkYTczYmE4NDYyMGUwYzlkN2IzM2NiNjE4NTYzMDYwZWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3N2Zy9TVkdNYXJrZXJFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUv c3ZnL1NWR01hcmtlckVsZW1lbnQuaApAQCAtNTEsNiArNTEsNyBAQCBlbnVtIFNWR01hcmtlck9y aWVudFR5cGUgewogdGVtcGxhdGU8Pgogc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR01hcmtl clVuaXRzVHlwZT4gewogICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyBy ZXR1cm4gU1ZHTWFya2VyVW5pdHNTdHJva2VXaWR0aDsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBo aWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsgfQog CiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdNYXJrZXJVbml0c1R5cGUgdHlwZSkKICAg ICB7CkBAIC04MCw2ICs4MSw3IEBAIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdNYXJrZXJV bml0c1R5cGU+IHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdNYXJr ZXJPcmllbnRUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7 IHJldHVybiBTVkdNYXJrZXJPcmllbnRBbmdsZTsgfQorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdo ZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsgfQogCiAg ICAgLy8gdG9TdHJpbmcgaXMgbm90IG5lZWRlZCwgc3luY2hyb25pemVPcmllbnRUeXBlKCkgaGFu ZGxlcyB0aGlzIG9uIGl0cyBvd24uCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9T VkdUZXh0Q29udGVudEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0Q29udGVu dEVsZW1lbnQuaAppbmRleCA0NDNhMTAyMjdhYTNjYmEzZWRkMjFjY2RmNjliMzRkMTI3NjU0ZWFm Li5jZjAyYjUxYjFiNTI4ZGY2NGU2YzM1NmNiMTA2YzYyOGI0NzhjMzdkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9zdmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50LmgKKysrIGIvU291cmNlL1dl YkNvcmUvc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5oCkBAIC0zOCw2ICszOCw3IEBAIGVudW0g U1ZHTGVuZ3RoQWRqdXN0VHlwZSB7CiB0ZW1wbGF0ZTw+CiBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFp dHM8U1ZHTGVuZ3RoQWRqdXN0VHlwZT4gewogICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51 bVZhbHVlKCkgeyByZXR1cm4gU1ZHTGVuZ3RoQWRqdXN0U3BhY2luZ0FuZEdseXBoczsgfQorICAg IHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hl c3RFbnVtVmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdMZW5ndGhB ZGp1c3RUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NW R1RleHRQYXRoRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRQYXRoRWxlbWVu dC5oCmluZGV4IDdlMzRhNWRmNmE5MmMyN2IwMmFjMjk3ZTU1MjkxZjkyMzY2NGFhMDMuLjgzNmQw NDY1NjUxMmQ4M2JjNWU5OWY1NzAyM2EzZGU2OTdiMDAxNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdUZXh0UGF0aEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcv U1ZHVGV4dFBhdGhFbGVtZW50LmgKQEAgLTQxLDYgKzQxLDcgQEAgZW51bSBTVkdUZXh0UGF0aFNw YWNpbmdUeXBlIHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0 UGF0aE1ldGhvZFR5cGU+IHsKICAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgp IHsgcmV0dXJuIFNWR1RleHRQYXRoTWV0aG9kU3RyZXRjaDsgfQorICAgIHN0YXRpYyB1bnNpZ25l ZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RFbnVtVmFsdWUoKTsg fQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdUZXh0UGF0aE1ldGhvZFR5cGUgdHlw ZSkKICAgICB7CkBAIC03MCw2ICs3MSw3IEBAIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdU ZXh0UGF0aE1ldGhvZFR5cGU+IHsKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0 czxTVkdUZXh0UGF0aFNwYWNpbmdUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RF bnVtVmFsdWUoKSB7IHJldHVybiBTVkdUZXh0UGF0aFNwYWNpbmdFeGFjdDsgfQorICAgIHN0YXRp YyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpIHsgcmV0dXJuIGhpZ2hlc3RFbnVt VmFsdWUoKTsgfQogCiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdUZXh0UGF0aFNwYWNp bmdUeXBlIHR5cGUpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1Vu aXRUeXBlcy5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1VuaXRUeXBlcy5oCmluZGV4IDFjMzQ5 ZDdkNTdlMjc0MDlkMDc1OGIxNjI1YjYyY2RiMzcwMTBkZmYuLmU1NWE2OTg1OTg4MjYzMzBjMWQ3 YjllOGEwZmIxZWRhZjY4MjkyM2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdV bml0VHlwZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVW5pdFR5cGVzLmgKQEAgLTQw LDYgKzQwLDcgQEAgcHJpdmF0ZToKIHRlbXBsYXRlPD4KIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0 czxTVkdVbml0VHlwZXM6OlNWR1VuaXRUeXBlPiB7CiAgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hl c3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdVbml0VHlwZXM6OlNWR19VTklUX1RZUEVfT0JKRUNU Qk9VTkRJTkdCT1g7IH0KKyAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEV4cG9zZWRFbnVtVmFs dWUoKSB7IHJldHVybiBoaWdoZXN0RW51bVZhbHVlKCk7IH0KIAogICAgIHN0YXRpYyBTdHJpbmcg dG9TdHJpbmcoU1ZHVW5pdFR5cGVzOjpTVkdVbml0VHlwZSB0eXBlKQogICAgIHsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Q cm9wZXJ0eVRlYXJPZmYuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1h dGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaAppbmRleCBkMWQyZDAzMDNiZGUwMWZkNjEy NzNmNjk5ZTU4MWFiMjRiZWFlYTI0Li5iZDllNzczNjMxZTM4NjQzYjFjYzcxNDVjYjNlYTViMDUy ZDFkODc5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmlt YXRlZEVudW1lcmF0aW9uUHJvcGVydHlUZWFyT2ZmLmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3Zn L3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oCkBAIC0y OSwxMCArMjksMzAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxhdGU8dHlwZW5hbWUgRW51 bVR5cGU+CiBjbGFzcyBTVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlUZWFyT2ZmIDogcHVi bGljIFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmPHVuc2lnbmVkPiB7CiBwdWJsaWM6 CisgICAgdmlydHVhbCB1bnNpZ25lZCYgYmFzZVZhbCgpIG92ZXJyaWRlCisgICAgeworICAgICAg ICBpZiAobV9wcm9wZXJ0eSA+IFNWR1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6aGlnaGVzdEV4 cG9zZWRFbnVtVmFsdWUoKSkKKyAgICAgICAgICAgIHJldHVybiBtX291dE9mUmFuZ2VFbnVtVmFs dWU7CisKKyAgICAgICAgcmV0dXJuIG1fcHJvcGVydHk7CisgICAgfQorCisgICAgdmlydHVhbCB1 bnNpZ25lZCYgYW5pbVZhbCgpIG92ZXJyaWRlCisgICAgeworICAgICAgICBpZiAoIW1fYW5pbWF0 ZWRQcm9wZXJ0eSkKKyAgICAgICAgICAgIHJldHVybiBiYXNlVmFsKCk7CisKKyAgICAgICAgaWYg KCptX2FuaW1hdGVkUHJvcGVydHkgPiBTVkdQcm9wZXJ0eVRyYWl0czxFbnVtVHlwZT46OmhpZ2hl c3RFeHBvc2VkRW51bVZhbHVlKCkpCisgICAgICAgICAgICByZXR1cm4gbV9vdXRPZlJhbmdlRW51 bVZhbHVlOworCisgICAgICAgIHJldHVybiAqbV9hbmltYXRlZFByb3BlcnR5OworICAgIH0KKwog ICAgIHZpcnR1YWwgdm9pZCBzZXRCYXNlVmFsKGNvbnN0IHVuc2lnbmVkJiBwcm9wZXJ0eSwgRXhj ZXB0aW9uQ29kZSYgZWMpIG92ZXJyaWRlCiAgICAgeworCiAgICAgICAgIC8vIEFsbCBTVkcgZW51 bWVyYXRpb24gdmFsdWVzLCB0aGF0IGFyZSBhbGxvd2VkIHRvIGJlIHNldCB2aWEgU1ZHIERPTSBz dGFydCB3aXRoIDEsIDAgY29ycmVzcG9uZHMgdG8gdW5rbm93biBhbmQgaXMgbm90IHNldHRhYmxl IHRocm91Z2ggU1ZHIERPTS4KLSAgICAgICAgaWYgKCFwcm9wZXJ0eSB8fCBwcm9wZXJ0eSA+IFNW R1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSgpKSB7CisgICAgICAg IGlmICghcHJvcGVydHkgfHwgcHJvcGVydHkgPiBTVkdQcm9wZXJ0eVRyYWl0czxFbnVtVHlwZT46 OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkpIHsKICAgICAgICAgICAgIGVjID0gU1ZHRXhjZXB0 aW9uOjpTVkdfSU5WQUxJRF9WQUxVRV9FUlI7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAg IH0KQEAgLTU3LDggKzc3LDE1IEBAIHByaXZhdGU6CiAgICAgICAgIDogU1ZHQW5pbWF0ZWRTdGF0 aWNQcm9wZXJ0eVRlYXJPZmY8dW5zaWduZWQ+KGNvbnRleHRFbGVtZW50LCBhdHRyaWJ1dGVOYW1l LCBhbmltYXRlZFByb3BlcnR5VHlwZSwgcHJvcGVydHkpCiAgICAgewogICAgIH0KKworICAgIHN0 YXRpYyB1bnNpZ25lZCBtX291dE9mUmFuZ2VFbnVtVmFsdWU7CiB9OwogCit0ZW1wbGF0ZTx0eXBl bmFtZSBFbnVtVHlwZT4KK3Vuc2lnbmVkIFNWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRl YXJPZmY8RW51bVR5cGU+OjptX291dE9mUmFuZ2VFbnVtVmFsdWUgPSAwOworCiB9CiAKKworCiAj ZW5kaWYgLy8gU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZl9oCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3Bl cnR5VGVhck9mZi5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRT dGF0aWNQcm9wZXJ0eVRlYXJPZmYuaAppbmRleCA3N2Y2ZTQ5MTczMzY0YzEwYmNmZjk4MzgxZDk0 ZTJhMDhlY2Y0MTFlLi45OTMyMzE1ZWNkNWI2ODk1MjgyODMxNjY4MTA5YjI0OTMyNzUwOGFmIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRp Y1Byb3BlcnR5VGVhck9mZi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NW R0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmLmgKQEAgLTMwLDEyICszMCwxMiBAQCBjbGFz cyBTVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZiA6IHB1YmxpYyBTVkdBbmltYXRlZFBy b3BlcnR5IHsKIHB1YmxpYzoKICAgICB0eXBlZGVmIFByb3BlcnR5VHlwZSBDb250ZW50VHlwZTsK IAotICAgIFByb3BlcnR5VHlwZSYgYmFzZVZhbCgpCisgICAgdmlydHVhbCBQcm9wZXJ0eVR5cGUm IGJhc2VWYWwoKQogICAgIHsKICAgICAgICAgcmV0dXJuIG1fcHJvcGVydHk7CiAgICAgfQogCi0g ICAgUHJvcGVydHlUeXBlJiBhbmltVmFsKCkKKyAgICB2aXJ0dWFsIFByb3BlcnR5VHlwZSYgYW5p bVZhbCgpCiAgICAgewogICAgICAgICBpZiAobV9hbmltYXRlZFByb3BlcnR5KQogICAgICAgICAg ICAgcmV0dXJuICptX2FuaW1hdGVkUHJvcGVydHk7CkBAIC0xMDUsNyArMTA1LDYgQEAgcHJvdGVj dGVkOgogICAgIHsKICAgICB9CiAKLXByaXZhdGU6CiAgICAgUHJvcGVydHlUeXBlJiBtX3Byb3Bl cnR5OwogICAgIFByb3BlcnR5VHlwZSogbV9hbmltYXRlZFByb3BlcnR5OwogfTsK 269029 2016-01-14 20:36:39 -0800 2016-01-18 18:49:37 -0800 Patch bug-152814-20160115153608.patch text/plain 21407 nikos.andronikos U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0OTgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjM2YTA2NDY2YWI5N2Vl YWFjNDY0YzJkYjg4M2I2Y2QyZjk4ZjY4My4uYzRlYjA4ODVhYjgwNTU2YTcxZjJlYWQzYjc5N2Ji M2FhZTk5ZDM2MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDgwIEBACisyMDE2LTAxLTE0ICBOaWtv cyBBbmRyb25pa29zICA8bmlrb3MuYW5kcm9uaWtvcy13ZWJraXRAY2lzcmEuY2Fub24uY29tLmF1 PgorCisgICAgICAgIFNWRyAyIHJlcXVpcmVzIGEgbWVjaGFuaXNtIGZvciByZXN0cmljdGluZyBl bnVtIHZhbHVlcyBleHBvc2VkIHRocm91Z2ggdGhlIERPTQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyODE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChObyBjaGFuZ2UgaW4gZnVu Y3Rpb25hbGl0eSwgYmxvY2tlZCBidWdzIGFkZCBuZXcgdGVzdHMpLgorCisgICAgICAgIFRoaXMg cGF0Y2ggYWRkcyBhIG1lY2hhbmlzbSB0byByZXN0cmljdCB0aGUgdmFsdWVzIHJldHVybmVkIHRo cm91Z2ggdGhlCisgICAgICAgIFNWR0FuaW1hdGVkRW51bWVyYXRpb24gaW50ZXJmYWNlLgorICAg ICAgICBUaGlzIGlzIHJlcXVpcmVkIGZvciBTVkcgMiwgd2hpY2ggZG9lcyBub3QgZXhwb3NlIG5l dyBlbnVtZXJhdGlvbgorICAgICAgICB2YWx1ZXMgdGhyb3VnaCB0aGUgSURMLgorICAgICAgICBT ZWUgaHR0cDovL3d3dy53My5vcmcvVFIvU1ZHMi90eXBlcy5odG1sI0ludGVyZmFjZVNWR0FuaW1h dGVkRW51bWVyYXRpb24KKyAgICAgICAgR2V0dGVyczoKKyAgICAgICAgU1ZHIDIgZG9lcyBub3Qg YWRkIG51bWVyaWMgdHlwZSB2YWx1ZXMgZm9yIG5ldyBvcHRpb25zLCBuZXcgb3B0aW9ucworICAg ICAgICBzaG91bGQgcmV0dXJuIFVOS05PV04uCisgICAgICAgIEUuZy4gU2VlIHRoZSB0YWJsZSBk ZWZpbmluZyBudW1lcmljIHR5cGUgdmFsdWVzIGZvciBvcmllbnQgYXQKKyAgICAgICAgaHR0cDov L3d3dy53My5vcmcvVFIvU1ZHMi9wYWludGluZy5odG1sI0ludGVyZmFjZVNWR01hcmtlckVsZW1l bnQKKyAgICAgICAgU2V0dGVyczoKKyAgICAgICAgT24gc2V0dGluZyBiYXNlVmFsLCB0aGUgZm9s bG93aW5nIHN0ZXBzIGFyZSBydW46CisgICAgICAgIDEuIC4uLgorICAgICAgICAyLiBJZiB2YWx1 ZSBpcyAwIG9yIGlzIG5vdCB0aGUgbnVtZXJpYyB0eXBlIHZhbHVlIGZvciBhbnkgdmFsdWUgb2Yg dGhlIHJlZmxlY3RlZCBhdHRyaWJ1dGUsIHRoZW4gc2V0IHRoZSByZWZsZWN0ZWQgYXR0cmlidXRl IHRvIHRoZSBlbXB0eSBzdHJpbmcuCisKKyAgICAgICAgKiBzdmcvU1ZHRkVCbGVuZEVsZW1lbnQu aDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR0VudW1MaW1pdHM8QmxlbmRNb2RlPjo6aGlnaGVzdEVu dW1WYWx1ZSk6IEVsZW1lbnQgZW51bSByYW5nZSBxdWVyaWVzIG1vdmVkIHRvIG5ldyBzdHJ1Y3Qu CisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxCbGVuZE1vZGU+OjpoaWdoZXN0 RW51bVZhbHVlKTogRGVsZXRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVDb2xvck1hdHJpeEVsZW1l bnQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR0VudW1MaW1pdHM8Q29sb3JNYXRyaXhUeXBlPjo6 aGlnaGVzdEVudW1WYWx1ZSk6IEVsZW1lbnQgZW51bSByYW5nZSBxdWVyaWVzIG1vdmVkIHRvIG5l dyBzdHJ1Y3QuCisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxDb2xvck1hdHJp eFR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKTogRGVsZXRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVD b21wb3NpdGVFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdFbnVtTGltaXRzPENvbXBv c2l0ZU9wZXJhdGlvblR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKTogRWxlbWVudCBlbnVtIHJhbmdl IHF1ZXJpZXMgbW92ZWQgdG8gbmV3IHN0cnVjdC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3Bl cnR5VHJhaXRzPENvbXBvc2l0ZU9wZXJhdGlvblR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKTogRGVs ZXRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQuaDoKKyAgICAg ICAgKFdlYkNvcmU6OlNWR0VudW1MaW1pdHM8RWRnZU1vZGVUeXBlPjo6aGlnaGVzdEVudW1WYWx1 ZSk6IEVsZW1lbnQgZW51bSByYW5nZSBxdWVyaWVzIG1vdmVkIHRvIG5ldyBzdHJ1Y3QuCisgICAg ICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxFZGdlTW9kZVR5cGU+OjpoaWdoZXN0RW51 bVZhbHVlKTogRGVsZXRlZC4KKyAgICAgICAgKiBzdmcvU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVt ZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdFbnVtTGltaXRzPENoYW5uZWxTZWxlY3RvclR5 cGU+OjpoaWdoZXN0RW51bVZhbHVlKTogRWxlbWVudCBlbnVtIHJhbmdlIHF1ZXJpZXMgbW92ZWQg dG8gbmV3IHN0cnVjdC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPENoYW5u ZWxTZWxlY3RvclR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKTogRGVsZXRlZC4KKyAgICAgICAgKiBz dmcvU1ZHRkVNb3JwaG9sb2d5RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHRW51bUxp bWl0czxNb3JwaG9sb2d5T3BlcmF0b3JUeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSk6IEVsZW1lbnQg ZW51bSByYW5nZSBxdWVyaWVzIG1vdmVkIHRvIG5ldyBzdHJ1Y3QuCisgICAgICAgIChXZWJDb3Jl OjpTVkdQcm9wZXJ0eVRyYWl0czxNb3JwaG9sb2d5T3BlcmF0b3JUeXBlPjo6aGlnaGVzdEVudW1W YWx1ZSk6IERlbGV0ZWQuCisgICAgICAgICogc3ZnL1NWR0ZFVHVyYnVsZW5jZUVsZW1lbnQuaDoK KyAgICAgICAgKFdlYkNvcmU6OlNWR0VudW1MaW1pdHM8U1ZHU3RpdGNoT3B0aW9ucz46OmhpZ2hl c3RFbnVtVmFsdWUpOiBFbGVtZW50IGVudW0gcmFuZ2UgcXVlcmllcyBtb3ZlZCB0byBuZXcgc3Ry dWN0LgorICAgICAgICAoV2ViQ29yZTo6U1ZHRW51bUxpbWl0czxUdXJidWxlbmNlVHlwZT46Omhp Z2hlc3RFbnVtVmFsdWUpOiBFbGVtZW50IGVudW0gcmFuZ2UgcXVlcmllcyBtb3ZlZCB0byBuZXcg c3RydWN0LgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHU3RpdGNoT3B0 aW9ucz46OmhpZ2hlc3RFbnVtVmFsdWUpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6U1ZH UHJvcGVydHlUcmFpdHM8VHVyYnVsZW5jZVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKTogRGVsZXRl ZC4KKyAgICAgICAgKiBzdmcvU1ZHR3JhZGllbnRFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3Jl OjpTVkdFbnVtTGltaXRzPFNWR1NwcmVhZE1ldGhvZFR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKTog RWxlbWVudCBlbnVtIHJhbmdlIHF1ZXJpZXMgbW92ZWQgdG8gbmV3IHN0cnVjdC4KKyAgICAgICAg KFdlYkNvcmU6OlNWR1Byb3BlcnR5VHJhaXRzPFNWR1NwcmVhZE1ldGhvZFR5cGU+OjpoaWdoZXN0 RW51bVZhbHVlKTogRGVsZXRlZC4KKyAgICAgICAgKiBzdmcvU1ZHTWFya2VyRWxlbWVudC5oOgor ICAgICAgICAoV2ViQ29yZTo6U1ZHRW51bUxpbWl0czxTVkdNYXJrZXJVbml0c1R5cGU+OjpoaWdo ZXN0RW51bVZhbHVlKTogRWxlbWVudCBlbnVtIHJhbmdlIHF1ZXJpZXMgbW92ZWQgdG8gbmV3IHN0 cnVjdC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR0VudW1MaW1pdHM8U1ZHTWFya2VyT3JpZW50VHlw ZT46OmhpZ2hlc3RFbnVtVmFsdWUpOiBFbGVtZW50IGVudW0gcmFuZ2UgcXVlcmllcyBtb3ZlZCB0 byBuZXcgc3RydWN0LgorICAgICAgICAoV2ViQ29yZTo6U1ZHUHJvcGVydHlUcmFpdHM8U1ZHTWFy a2VyVW5pdHNUeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSk6IERlbGV0ZWQuCisgICAgICAgIChXZWJD b3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxTVkdNYXJrZXJPcmllbnRUeXBlPjo6aGlnaGVzdEVudW1W YWx1ZSk6IERlbGV0ZWQuCisgICAgICAgICogc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5oOgor ICAgICAgICAoV2ViQ29yZTo6U1ZHRW51bUxpbWl0czxTVkdMZW5ndGhBZGp1c3RUeXBlPjo6aGln aGVzdEVudW1WYWx1ZSk6IEVsZW1lbnQgZW51bSByYW5nZSBxdWVyaWVzIG1vdmVkIHRvIG5ldyBz dHJ1Y3QuCisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxTVkdMZW5ndGhBZGp1 c3RUeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSk6IERlbGV0ZWQuCisgICAgICAgICogc3ZnL1NWR1Rl eHRQYXRoRWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHRW51bUxpbWl0czxTVkdUZXh0 UGF0aE1ldGhvZFR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKTogRWxlbWVudCBlbnVtIHJhbmdlIHF1 ZXJpZXMgbW92ZWQgdG8gbmV3IHN0cnVjdC4KKyAgICAgICAgKFdlYkNvcmU6OlNWR0VudW1MaW1p dHM8U1ZHVGV4dFBhdGhTcGFjaW5nVHlwZT46OmhpZ2hlc3RFbnVtVmFsdWUpOiBFbGVtZW50IGVu dW0gcmFuZ2UgcXVlcmllcyBtb3ZlZCB0byBuZXcgc3RydWN0LgorICAgICAgICAoV2ViQ29yZTo6 U1ZHUHJvcGVydHlUcmFpdHM8U1ZHVGV4dFBhdGhNZXRob2RUeXBlPjo6aGlnaGVzdEVudW1WYWx1 ZSk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpTVkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0 UGF0aFNwYWNpbmdUeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSk6IERlbGV0ZWQuCisgICAgICAgICog c3ZnL1NWR1VuaXRUeXBlcy5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHRW51bUxpbWl0czxTVkdV bml0VHlwZXM6OlNWR1VuaXRUeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSk6IEVsZW1lbnQgZW51bSBy YW5nZSBxdWVyaWVzIG1vdmVkIHRvIG5ldyBzdHJ1Y3QuCisgICAgICAgIChXZWJDb3JlOjpTVkdQ cm9wZXJ0eVRyYWl0czxTVkdVbml0VHlwZXM6OlNWR1VuaXRUeXBlPjo6aGlnaGVzdEVudW1WYWx1 ZSk6IERlbGV0ZWQuCisgICAgICAgICogc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJh dGlvblByb3BlcnR5VGVhck9mZi5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHQW5pbWF0ZWRFbnVt ZXJhdGlvblByb3BlcnR5VGVhck9mZjo6Y3VycmVudEFuaW1hdGVkVmFsdWUpOiBSZWFkIGxpbWl0 cyBmcm9tIG5ldyBzdHJ1Y3QuCisgICAgICAgIChXZWJDb3JlOjpTVkdBbmltYXRlZEVudW1lcmF0 aW9uUHJvcGVydHlUZWFyT2ZmOjpvdXRPZlJhbmdlRW51bVZhbHVlKTogSGVscGVyIG1ldGhvZCB0 byBhbGxvdyBpbml0aWFsaXNlIG9uIGZpcnN0IHVzZSByYXRoZXIgdGhhbiByZXF1aXJpbmcgYSBn bG9iYWwgY29uc3RydWN0b3IuCisgICAgICAgICogc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRT dGF0aWNQcm9wZXJ0eVRlYXJPZmYuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR0FuaW1hdGVkU3Rh dGljUHJvcGVydHlUZWFyT2ZmOjpiYXNlVmFsKTogTWFyayBtZXRob2QgYXMgdmlydHVhbCBhcyBp dCdzIG92ZXItcmlkZGVuIGZvciBlbnVtZXJhdGlvbnMuCisgICAgICAgIChXZWJDb3JlOjpTVkdB bmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZjo6YW5pbVZhbCk6IE1hcmsgbWV0aG9kIGFzIHZp cnR1YWwgYXMgaXQncyBvdmVyLXJpZGRlbiBmb3IgZW51bWVyYXRpb25zLgorICAgICAgICAqIHN2 Zy9wcm9wZXJ0aWVzL1NWR1Byb3BlcnR5VHJhaXRzLmg6CisgICAgICAgIChXZWJDb3JlOjpTVkdF bnVtTGltaXRzOjpvdXRPZlJhbmdlRW51bVZhbHVlKTogVGhlIHZhbHVlIHRoYXQgaXMgcmV0dXJu ZWQgd2hlbiB0aGUgaW50ZXJuYWwgZW51bWVyYXRpb24gdmFsdWUgZXhjZWVkcyBoaWdoZXN0RXhw b3NlZEVudW1WYWx1ZQorICAgICAgICAoV2ViQ29yZTo6U1ZHRW51bUxpbWl0czo6aGlnaGVzdEVu dW1WYWx1ZSk6IFRoZSBoaWdoZXN0IGFsbG93ZWQgdmFsdWUgZm9yIHRoZSBlbnVtZXJhdGlvbi4K KyAgICAgICAgKFdlYkNvcmU6OlNWR0VudW1MaW1pdHM6OmhpZ2hlc3RFeHBvc2VkRW51bVZhbHVl KTogVGhlIGhpZ2hlc3QgdmFsdWUgZXhwb3NlZCB0aHJvdWdoIHRoZSBJREwuCisKIDIwMTYtMDEt MTMgIENvbW1pdCBRdWV1ZSAgPGNvbW1pdC1xdWV1ZUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVu cmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIxOTQ5NjMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9zdmcvU1ZHQ29tcG9uZW50VHJhbnNmZXJGdW5jdGlvbkVsZW1lbnQuaCBiL1NvdXJjZS9XZWJD b3JlL3N2Zy9TVkdDb21wb25lbnRUcmFuc2ZlckZ1bmN0aW9uRWxlbWVudC5oCmluZGV4IGJlNGZl OTczMWNkYjg0NzVkYWJhNDE2NWJjY2ViOTA4YjVlMmFmYTEuLmJmYTRhZjZhOWNjOWI0OTQzYTM4 M2QxMGIxN2I4OGMwMjkzZGQzZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdD b21wb25lbnRUcmFuc2ZlckZ1bmN0aW9uRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2 Zy9TVkdDb21wb25lbnRUcmFuc2ZlckZ1bmN0aW9uRWxlbWVudC5oCkBAIC0yOSw5ICsyOSwxMCBA QAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiB0ZW1wbGF0ZTw+Ci1zdHJ1Y3QgU1ZHUHJvcGVydHlU cmFpdHM8Q29tcG9uZW50VHJhbnNmZXJUeXBlPiB7Ci0gICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hl c3RFbnVtVmFsdWUoKSB7IHJldHVybiBGRUNPTVBPTkVOVFRSQU5TRkVSX1RZUEVfR0FNTUE7IH0K K2lubGluZSB1bnNpZ25lZCBTVkdFbnVtTGltaXRzPENvbXBvbmVudFRyYW5zZmVyVHlwZT46Omhp Z2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBGRUNPTVBPTkVOVFRSQU5TRkVSX1RZUEVfR0FNTUE7 IH0KIAordGVtcGxhdGU8Pgorc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPENvbXBvbmVudFRyYW5z ZmVyVHlwZT4gewogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoQ29tcG9uZW50VHJhbnNmZXJU eXBlIHR5cGUpCiAgICAgewogICAgICAgICBzd2l0Y2ggKHR5cGUpIHsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUJsZW5kRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3Zn L1NWR0ZFQmxlbmRFbGVtZW50LmgKaW5kZXggZTBhN2NhMzMxMmU1ZTA0ZWEzMTUzY2RhYzUxOThk MzNmOTFkMDA2ZS4uMzI1Y2YxM2UxNWVkYjQ3ZjY5NTg5NjAzZmVlMGY1MjUwMzRhY2EyMSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQmxlbmRFbGVtZW50LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQmxlbmRFbGVtZW50LmgKQEAgLTI5LDkgKzI5LDEwIEBACiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIHRlbXBsYXRlPD4KLXN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0 czxCbGVuZE1vZGU+IHsKLSAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsg cmV0dXJuIEJsZW5kTW9kZUxpZ2h0ZW47IH0KK2lubGluZSB1bnNpZ25lZCBTVkdFbnVtTGltaXRz PEJsZW5kTW9kZT46OmhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBCbGVuZE1vZGVMaWdodGVu OyB9CiAKK3RlbXBsYXRlPD4KK3N0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxCbGVuZE1vZGU+IHsK ICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKEJsZW5kTW9kZSB0eXBlKQogICAgIHsKICAgICAg ICAgc3dpdGNoICh0eXBlKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVD b2xvck1hdHJpeEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4 RWxlbWVudC5oCmluZGV4IGQwOWM3NzZmNTc0YmI1ODM5ZDRkOTFlNWU4OGI5OTQ5Y2YzODI2YzEu LjVjN2JhN2M2NmQ3OWM0YTA4YWIyMzJlYTczNGQzMjc2YmQzNjVlN2UgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdGRUNvbG9yTWF0cml4RWxlbWVudC5oCkBAIC0yOSw5ICsyOSwxMCBAQAog bmFtZXNwYWNlIFdlYkNvcmUgewogCiB0ZW1wbGF0ZTw+Ci1zdHJ1Y3QgU1ZHUHJvcGVydHlUcmFp dHM8Q29sb3JNYXRyaXhUeXBlPiB7Ci0gICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFs dWUoKSB7IHJldHVybiBGRUNPTE9STUFUUklYX1RZUEVfTFVNSU5BTkNFVE9BTFBIQTsgfQoraW5s aW5lIHVuc2lnbmVkIFNWR0VudW1MaW1pdHM8Q29sb3JNYXRyaXhUeXBlPjo6aGlnaGVzdEVudW1W YWx1ZSgpIHsgcmV0dXJuIEZFQ09MT1JNQVRSSVhfVFlQRV9MVU1JTkFOQ0VUT0FMUEhBOyB9CiAK K3RlbXBsYXRlPD4KK3N0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxDb2xvck1hdHJpeFR5cGU+IHsK ICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKENvbG9yTWF0cml4VHlwZSB0eXBlKQogICAgIHsK ICAgICAgICAgc3dpdGNoICh0eXBlKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcv U1ZHRkVDb21wb3NpdGVFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb21wb3Np dGVFbGVtZW50LmgKaW5kZXggYWRlNjcyMmIzOGVhYzZjZTJmNzI2MDRmZWYwYzdkN2QxOTQ0NmI1 MC4uZGZiM2NkYzM1NWJiNDI1YjZiZmEzYmIyNzcyODkzNmNhZTJlNjQyNSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFQ29tcG9zaXRlRWxlbWVudC5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdGRUNvbXBvc2l0ZUVsZW1lbnQuaApAQCAtMjksOSArMjksMTAgQEAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAogdGVtcGxhdGU8Pgotc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRz PENvbXBvc2l0ZU9wZXJhdGlvblR5cGU+IHsKLSAgICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVu dW1WYWx1ZSgpIHsgcmV0dXJuIEZFQ09NUE9TSVRFX09QRVJBVE9SX0FSSVRITUVUSUM7IH0KK2lu bGluZSB1bnNpZ25lZCBTVkdFbnVtTGltaXRzPENvbXBvc2l0ZU9wZXJhdGlvblR5cGU+OjpoaWdo ZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gRkVDT01QT1NJVEVfT1BFUkFUT1JfQVJJVEhNRVRJQzsg fQogCit0ZW1wbGF0ZTw+CitzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8Q29tcG9zaXRlT3BlcmF0 aW9uVHlwZT4gewogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoQ29tcG9zaXRlT3BlcmF0aW9u VHlwZSB0eXBlKQogICAgIHsKICAgICAgICAgc3dpdGNoICh0eXBlKSB7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQuaCBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudC5oCmluZGV4IGQ2NmNkMWIxZjk3 Nzg1MjM1YWI1ZDAzODE3MjIxZjA0NWU5M2UyZWQuLjRhMTk3NWJhOTQwMTk1Y2QyMmFlM2FlNDJi NzAwY2M0NGQ5ODE4NGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbnZv bHZlTWF0cml4RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRUNvbnZvbHZl TWF0cml4RWxlbWVudC5oCkBAIC0zMSw5ICszMSwxMCBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewog CiB0ZW1wbGF0ZTw+Ci1zdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8RWRnZU1vZGVUeXBlPiB7Ci0g ICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBFREdFTU9ERV9O T05FOyB9CitpbmxpbmUgdW5zaWduZWQgU1ZHRW51bUxpbWl0czxFZGdlTW9kZVR5cGU+OjpoaWdo ZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gRURHRU1PREVfTk9ORTsgfQogCit0ZW1wbGF0ZTw+Citz dHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8RWRnZU1vZGVUeXBlPiB7CiAgICAgc3RhdGljIFN0cmlu ZyB0b1N0cmluZyhFZGdlTW9kZVR5cGUgdHlwZSkKICAgICB7CiAgICAgICAgIHN3aXRjaCAodHlw ZSkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFRGlzcGxhY2VtZW50TWFw RWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFRGlzcGxhY2VtZW50TWFwRWxlbWVu dC5oCmluZGV4IGE2NGY4MTk2OTJlNTVmMTI5YjBmNjY2OTU0OTU5ODg3NzI2NzI4ZDEuLjAyOTM1 OGJkMTY4ZWYzNDE2MGZlODhiYzM0OThiNzM2NDVhYzNhMGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdGRURpc3BsYWNlbWVudE1hcEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50LmgKQEAgLTI2LDExICsyNiwxMiBA QAogI2luY2x1ZGUgIlNWR0ZpbHRlclByaW1pdGl2ZVN0YW5kYXJkQXR0cmlidXRlcy5oIgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7Ci0gCisKIHRlbXBsYXRlPD4KLXN0cnVjdCBTVkdQcm9wZXJ0eVRy YWl0czxDaGFubmVsU2VsZWN0b3JUeXBlPiB7Ci0gICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RF bnVtVmFsdWUoKSB7IHJldHVybiBDSEFOTkVMX0E7IH0KK2lubGluZSB1bnNpZ25lZCBTVkdFbnVt TGltaXRzPENoYW5uZWxTZWxlY3RvclR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4g Q0hBTk5FTF9BOyB9CiAKK3RlbXBsYXRlPD4KK3N0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxDaGFu bmVsU2VsZWN0b3JUeXBlPiB7CiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhDaGFubmVsU2Vs ZWN0b3JUeXBlIHR5cGUpCiAgICAgewogICAgICAgICBzd2l0Y2ggKHR5cGUpIHsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRU1vcnBob2xvZ3lFbGVtZW50LmggYi9Tb3VyY2Uv V2ViQ29yZS9zdmcvU1ZHRkVNb3JwaG9sb2d5RWxlbWVudC5oCmluZGV4IGEwMTY1NjZlNzAyMjkx ZTExZGY3OGVkMTUyMTJmNTEzZGFjOTA0ZDUuLmM4YzNlZjk3MzUyMWFkMGZjNDczNWNkMTQ2MjJk MzVlMWVhMDViM2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRU1vcnBob2xv Z3lFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFTW9ycGhvbG9neUVsZW1l bnQuaApAQCAtMjgsOSArMjgsMTAgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogdGVtcGxhdGU8 Pgotc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPE1vcnBob2xvZ3lPcGVyYXRvclR5cGU+IHsKLSAg ICBzdGF0aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIEZFTU9SUEhPTE9H WV9PUEVSQVRPUl9ESUxBVEU7IH0KK2lubGluZSB1bnNpZ25lZCBTVkdFbnVtTGltaXRzPE1vcnBo b2xvZ3lPcGVyYXRvclR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gRkVNT1JQSE9M T0dZX09QRVJBVE9SX0RJTEFURTsgfQogCit0ZW1wbGF0ZTw+CitzdHJ1Y3QgU1ZHUHJvcGVydHlU cmFpdHM8TW9ycGhvbG9neU9wZXJhdG9yVHlwZT4gewogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJp bmcoTW9ycGhvbG9neU9wZXJhdG9yVHlwZSB0eXBlKQogICAgIHsKICAgICAgICAgc3dpdGNoICh0 eXBlKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVUdXJidWxlbmNlRWxl bWVudC5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFVHVyYnVsZW5jZUVsZW1lbnQuaAppbmRl eCBhNGVmMDFmZDNiZmRmMmI0Y2NkMWExMzhhZGNlY2RkMGJhMDhiY2E0Li5mZTc3ODQ5OWE1NGU2 YjNkNDRlZjc5Y2EwM2YzZGZiZGVmNjRmNzFlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9z dmcvU1ZHRkVUdXJidWxlbmNlRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdG RVR1cmJ1bGVuY2VFbGVtZW50LmgKQEAgLTM2LDkgKzM2LDEwIEBAIGVudW0gU1ZHU3RpdGNoT3B0 aW9ucyB7CiB9OwogCiB0ZW1wbGF0ZTw+Ci1zdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8U1ZHU3Rp dGNoT3B0aW9ucz4gewotICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyBy ZXR1cm4gU1ZHX1NUSVRDSFRZUEVfTk9TVElUQ0g7IH0KK2lubGluZSB1bnNpZ25lZCBTVkdFbnVt TGltaXRzPFNWR1N0aXRjaE9wdGlvbnM+OjpoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gU1ZH X1NUSVRDSFRZUEVfTk9TVElUQ0g7IH0KIAordGVtcGxhdGU8Pgorc3RydWN0IFNWR1Byb3BlcnR5 VHJhaXRzPFNWR1N0aXRjaE9wdGlvbnM+IHsKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKFNW R1N0aXRjaE9wdGlvbnMgdHlwZSkKICAgICB7CiAgICAgICAgIHN3aXRjaCAodHlwZSkgewpAQCAt NjUsOSArNjYsMTAgQEAgc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR1N0aXRjaE9wdGlvbnM+ IHsKIH07CiAKIHRlbXBsYXRlPD4KLXN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxUdXJidWxlbmNl VHlwZT4gewotICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4g RkVUVVJCVUxFTkNFX1RZUEVfVFVSQlVMRU5DRTsgfQoraW5saW5lIHVuc2lnbmVkIFNWR0VudW1M aW1pdHM8VHVyYnVsZW5jZVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4gRkVUVVJC VUxFTkNFX1RZUEVfVFVSQlVMRU5DRTsgfQogCit0ZW1wbGF0ZTw+CitzdHJ1Y3QgU1ZHUHJvcGVy dHlUcmFpdHM8VHVyYnVsZW5jZVR5cGU+IHsKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKFR1 cmJ1bGVuY2VUeXBlIHR5cGUpCiAgICAgewogICAgICAgICBzd2l0Y2ggKHR5cGUpIHsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdHcmFkaWVudEVsZW1lbnQuaCBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9TVkdHcmFkaWVudEVsZW1lbnQuaAppbmRleCAxNjJkZWY0NDliNTFlYjQ2MzUx ZGZlNmEzOTg0ZWVhODgyMzU3MTI4Li4wOWQ3Mjk1ODI2NDRhMzlkNmFlMmE3MTgxNDI4OWQ3OWNl NWZhODFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHR3JhZGllbnRFbGVtZW50 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0dyYWRpZW50RWxlbWVudC5oCkBAIC00MSw5 ICs0MSwxMCBAQCBlbnVtIFNWR1NwcmVhZE1ldGhvZFR5cGUgewogfTsKIAogdGVtcGxhdGU8Pgot c3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR1NwcmVhZE1ldGhvZFR5cGU+IHsKLSAgICBzdGF0 aWMgdW5zaWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIFNWR1NwcmVhZE1ldGhvZFJl cGVhdDsgfQoraW5saW5lIHVuc2lnbmVkIFNWR0VudW1MaW1pdHM8U1ZHU3ByZWFkTWV0aG9kVHlw ZT46OmhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdTcHJlYWRNZXRob2RSZXBlYXQ7IH0K IAordGVtcGxhdGU8Pgorc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR1NwcmVhZE1ldGhvZFR5 cGU+IHsKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKFNWR1NwcmVhZE1ldGhvZFR5cGUgdHlw ZSkKICAgICB7CiAgICAgICAgIHN3aXRjaCAodHlwZSkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvc3ZnL1NWR01hcmtlckVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdNYXJr ZXJFbGVtZW50LmgKaW5kZXggMDRiYzFjOWFhYzQ2MzI5OTY3N2Q0MjE1NTU4YzkyNzNkYjdjNDI3 Ni4uYzg3NTRhZTdkOTYwYzNmODAzNjUzZmU1ZTNjYTEzNzE3N2U2OWU1YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvc3ZnL1NWR01hcmtlckVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9zdmcvU1ZHTWFya2VyRWxlbWVudC5oCkBAIC00OSw5ICs0OSwxMCBAQCBlbnVtIFNWR01hcmtl ck9yaWVudFR5cGUgewogfTsKIAogdGVtcGxhdGU8Pgotc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRz PFNWR01hcmtlclVuaXRzVHlwZT4gewotICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RW51bVZh bHVlKCkgeyByZXR1cm4gU1ZHTWFya2VyVW5pdHNTdHJva2VXaWR0aDsgfQoraW5saW5lIHVuc2ln bmVkIFNWR0VudW1MaW1pdHM8U1ZHTWFya2VyVW5pdHNUeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSgp IHsgcmV0dXJuIFNWR01hcmtlclVuaXRzU3Ryb2tlV2lkdGg7IH0KIAordGVtcGxhdGU8Pgorc3Ry dWN0IFNWR1Byb3BlcnR5VHJhaXRzPFNWR01hcmtlclVuaXRzVHlwZT4gewogICAgIHN0YXRpYyBT dHJpbmcgdG9TdHJpbmcoU1ZHTWFya2VyVW5pdHNUeXBlIHR5cGUpCiAgICAgewogICAgICAgICBz d2l0Y2ggKHR5cGUpIHsKQEAgLTc4LDkgKzc5LDEwIEBAIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0 czxTVkdNYXJrZXJVbml0c1R5cGU+IHsKIH07CiAKIHRlbXBsYXRlPD4KLXN0cnVjdCBTVkdQcm9w ZXJ0eVRyYWl0czxTVkdNYXJrZXJPcmllbnRUeXBlPiB7Ci0gICAgc3RhdGljIHVuc2lnbmVkIGhp Z2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdNYXJrZXJPcmllbnRBbmdsZTsgfQoraW5saW5l IHVuc2lnbmVkIFNWR0VudW1MaW1pdHM8U1ZHTWFya2VyT3JpZW50VHlwZT46OmhpZ2hlc3RFbnVt VmFsdWUoKSB7IHJldHVybiBTVkdNYXJrZXJPcmllbnRBbmdsZTsgfQogCit0ZW1wbGF0ZTw+Citz dHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8U1ZHTWFya2VyT3JpZW50VHlwZT4gewogICAgIC8vIHRv U3RyaW5nIGlzIG5vdCBuZWVkZWQsIHN5bmNocm9uaXplT3JpZW50VHlwZSgpIGhhbmRsZXMgdGhp cyBvbiBpdHMgb3duLgogCiAgICAgc3RhdGljIFNWR01hcmtlck9yaWVudFR5cGUgZnJvbVN0cmlu Zyhjb25zdCBTdHJpbmcmIHZhbHVlLCBTVkdBbmdsZSYgYW5nbGUpCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9zdmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9z dmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50LmgKaW5kZXggNDQzYTEwMjI3YWEzY2JhM2VkZDIxY2Nk ZjY5YjM0ZDEyNzY1NGVhZi4uNmQ3YmJkNzk2NWI2NTJkNzI2N2QwYTFmYTE5NjlkYzcyZGY1MmIw MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRDb250ZW50RWxlbWVudC5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0Q29udGVudEVsZW1lbnQuaApAQCAtMzYs OSArMzYsMTAgQEAgZW51bSBTVkdMZW5ndGhBZGp1c3RUeXBlIHsKIH07CiAKIHRlbXBsYXRlPD4K LXN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdMZW5ndGhBZGp1c3RUeXBlPiB7Ci0gICAgc3Rh dGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdMZW5ndGhBZGp1c3RT cGFjaW5nQW5kR2x5cGhzOyB9CitpbmxpbmUgdW5zaWduZWQgU1ZHRW51bUxpbWl0czxTVkdMZW5n dGhBZGp1c3RUeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIFNWR0xlbmd0aEFkanVz dFNwYWNpbmdBbmRHbHlwaHM7IH0KIAordGVtcGxhdGU8Pgorc3RydWN0IFNWR1Byb3BlcnR5VHJh aXRzPFNWR0xlbmd0aEFkanVzdFR5cGU+IHsKICAgICBzdGF0aWMgU3RyaW5nIHRvU3RyaW5nKFNW R0xlbmd0aEFkanVzdFR5cGUgdHlwZSkKICAgICB7CiAgICAgICAgIHN3aXRjaCAodHlwZSkgewpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRQYXRoRWxlbWVudC5oIGIvU291 cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRQYXRoRWxlbWVudC5oCmluZGV4IDdlMzRhNWRmNmE5MmMy N2IwMmFjMjk3ZTU1MjkxZjkyMzY2NGFhMDMuLjFhMGQyNmM0Nzk3YmEyODk4OGRmNjlkMDFlNWVm ZWY3ZmYwNTQxMDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0UGF0aEVs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVGV4dFBhdGhFbGVtZW50LmgKQEAg LTM5LDkgKzM5LDEwIEBAIGVudW0gU1ZHVGV4dFBhdGhTcGFjaW5nVHlwZSB7CiB9OwogCiB0ZW1w bGF0ZTw+Ci1zdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8U1ZHVGV4dFBhdGhNZXRob2RUeXBlPiB7 Ci0gICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdUZXh0 UGF0aE1ldGhvZFN0cmV0Y2g7IH0KK2lubGluZSB1bnNpZ25lZCBTVkdFbnVtTGltaXRzPFNWR1Rl eHRQYXRoTWV0aG9kVHlwZT46OmhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdUZXh0UGF0 aE1ldGhvZFN0cmV0Y2g7IH0KIAordGVtcGxhdGU8Pgorc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRz PFNWR1RleHRQYXRoTWV0aG9kVHlwZT4gewogICAgIHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoU1ZH VGV4dFBhdGhNZXRob2RUeXBlIHR5cGUpCiAgICAgewogICAgICAgICBzd2l0Y2ggKHR5cGUpIHsK QEAgLTY4LDkgKzY5LDEwIEBAIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdUZXh0UGF0aE1l dGhvZFR5cGU+IHsKIH07CiAKIHRlbXBsYXRlPD4KLXN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxT VkdUZXh0UGF0aFNwYWNpbmdUeXBlPiB7Ci0gICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVt VmFsdWUoKSB7IHJldHVybiBTVkdUZXh0UGF0aFNwYWNpbmdFeGFjdDsgfQoraW5saW5lIHVuc2ln bmVkIFNWR0VudW1MaW1pdHM8U1ZHVGV4dFBhdGhTcGFjaW5nVHlwZT46OmhpZ2hlc3RFbnVtVmFs dWUoKSB7IHJldHVybiBTVkdUZXh0UGF0aFNwYWNpbmdFeGFjdDsgfQogCit0ZW1wbGF0ZTw+Citz dHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8U1ZHVGV4dFBhdGhTcGFjaW5nVHlwZT4gewogICAgIHN0 YXRpYyBTdHJpbmcgdG9TdHJpbmcoU1ZHVGV4dFBhdGhTcGFjaW5nVHlwZSB0eXBlKQogICAgIHsK ICAgICAgICAgc3dpdGNoICh0eXBlKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcv U1ZHVW5pdFR5cGVzLmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVW5pdFR5cGVzLmgKaW5kZXgg MWMzNDlkN2Q1N2UyNzQwOWQwNzU4YjE2MjViNjJjZGIzNzAxMGRmZi4uMmMyM2ZiNDk5ZjRiNzVl NjljMTMxYWVkNzhlMjUxMDRiYmY2MmI1OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3Zn L1NWR1VuaXRUeXBlcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdVbml0VHlwZXMuaApA QCAtMzgsOSArMzgsMTAgQEAgcHJpdmF0ZToKIH07CiAKIHRlbXBsYXRlPD4KLXN0cnVjdCBTVkdQ cm9wZXJ0eVRyYWl0czxTVkdVbml0VHlwZXM6OlNWR1VuaXRUeXBlPiB7Ci0gICAgc3RhdGljIHVu c2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiBTVkdVbml0VHlwZXM6OlNWR19VTklU X1RZUEVfT0JKRUNUQk9VTkRJTkdCT1g7IH0KK2lubGluZSB1bnNpZ25lZCBTVkdFbnVtTGltaXRz PFNWR1VuaXRUeXBlczo6U1ZHVW5pdFR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkgeyByZXR1cm4g U1ZHVW5pdFR5cGVzOjpTVkdfVU5JVF9UWVBFX09CSkVDVEJPVU5ESU5HQk9YOyB9CiAKK3RlbXBs YXRlPD4KK3N0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTVkdVbml0VHlwZXM6OlNWR1VuaXRUeXBl PiB7CiAgICAgc3RhdGljIFN0cmluZyB0b1N0cmluZyhTVkdVbml0VHlwZXM6OlNWR1VuaXRUeXBl IHR5cGUpCiAgICAgewogICAgICAgICBzd2l0Y2ggKHR5cGUpIHsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRl YXJPZmYuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVy YXRpb25Qcm9wZXJ0eVRlYXJPZmYuaAppbmRleCBkMWQyZDAzMDNiZGUwMWZkNjEyNzNmNjk5ZTU4 MWFiMjRiZWFlYTI0Li4zZDgwZDMyMTY0YTkyOGVkODAxYjA0MGIzMTQ0NjljZmYzZTBiMWJiIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZEVudW1l cmF0aW9uUHJvcGVydHlUZWFyT2ZmLmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRp ZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oCkBAIC0yOSwxMCArMjks MjkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogdGVtcGxhdGU8dHlwZW5hbWUgRW51bVR5cGU+CiBj bGFzcyBTVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlUZWFyT2ZmIDogcHVibGljIFNWR0Fu aW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmPHVuc2lnbmVkPiB7CiBwdWJsaWM6CisgICAgdmly dHVhbCB1bnNpZ25lZCYgYmFzZVZhbCgpIG92ZXJyaWRlCisgICAgeworICAgICAgICBpZiAobV9w cm9wZXJ0eSA+IFNWR0VudW1MaW1pdHM8RW51bVR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSgpKQorICAgICAgICAgICAgcmV0dXJuIG91dE9mUmFuZ2VFbnVtVmFsdWUoKTsKKworICAgICAg ICByZXR1cm4gbV9wcm9wZXJ0eTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHVuc2lnbmVkJiBhbmlt VmFsKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIGlmICghbV9hbmltYXRlZFByb3BlcnR5KQor ICAgICAgICAgICAgcmV0dXJuIGJhc2VWYWwoKTsKKworICAgICAgICBpZiAoKm1fYW5pbWF0ZWRQ cm9wZXJ0eSA+IFNWR0VudW1MaW1pdHM8RW51bVR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSgpKQorICAgICAgICAgICAgcmV0dXJuIG91dE9mUmFuZ2VFbnVtVmFsdWUoKTsKKworICAgICAg ICByZXR1cm4gKm1fYW5pbWF0ZWRQcm9wZXJ0eTsKKyAgICB9CisKICAgICB2aXJ0dWFsIHZvaWQg c2V0QmFzZVZhbChjb25zdCB1bnNpZ25lZCYgcHJvcGVydHksIEV4Y2VwdGlvbkNvZGUmIGVjKSBv dmVycmlkZQogICAgIHsKICAgICAgICAgLy8gQWxsIFNWRyBlbnVtZXJhdGlvbiB2YWx1ZXMsIHRo YXQgYXJlIGFsbG93ZWQgdG8gYmUgc2V0IHZpYSBTVkcgRE9NIHN0YXJ0IHdpdGggMSwgMCBjb3Jy ZXNwb25kcyB0byB1bmtub3duIGFuZCBpcyBub3Qgc2V0dGFibGUgdGhyb3VnaCBTVkcgRE9NLgot ICAgICAgICBpZiAoIXByb3BlcnR5IHx8IHByb3BlcnR5ID4gU1ZHUHJvcGVydHlUcmFpdHM8RW51 bVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkpIHsKKyAgICAgICAgaWYgKCFwcm9wZXJ0eSB8fCBw cm9wZXJ0eSA+IFNWR0VudW1MaW1pdHM8RW51bVR5cGU+OjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSgpKSB7CiAgICAgICAgICAgICBlYyA9IFNWR0V4Y2VwdGlvbjo6U1ZHX0lOVkFMSURfVkFMVUVf RVJSOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CkBAIC00OCw3ICs2Nyw3IEBAIHB1 YmxpYzoKICAgICBFbnVtVHlwZSYgY3VycmVudEFuaW1hdGVkVmFsdWUoKQogICAgIHsKICAgICAg ICAgdW5zaWduZWQmIGFuaW1hdGVkVmFsdWUgPSBTVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVh ck9mZjx1bnNpZ25lZD46OmN1cnJlbnRBbmltYXRlZFZhbHVlKCk7Ci0gICAgICAgIEFTU0VSVChh bmltYXRlZFZhbHVlIDw9IFNWR1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6aGlnaGVzdEVudW1W YWx1ZSgpKTsKKyAgICAgICAgQVNTRVJUKGFuaW1hdGVkVmFsdWUgPD0gU1ZHRW51bUxpbWl0czxF bnVtVHlwZT46OmhpZ2hlc3RFbnVtVmFsdWUoKSk7CiAgICAgICAgIHJldHVybiByZWludGVycHJl dF9jYXN0PEVudW1UeXBlJj4oYW5pbWF0ZWRWYWx1ZSk7CiAgICAgfQogCkBAIC01Nyw2ICs3Niwx MyBAQCBwcml2YXRlOgogICAgICAgICA6IFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2Zm PHVuc2lnbmVkPihjb250ZXh0RWxlbWVudCwgYXR0cmlidXRlTmFtZSwgYW5pbWF0ZWRQcm9wZXJ0 eVR5cGUsIHByb3BlcnR5KQogICAgIHsKICAgICB9CisKKyAgICAvLyBUaGlzIG1ldGhvZCBleGlz dHMgdG8gYWxsb3cgdGhlIGluaXRpYWxpc2Ugb24gZmlyc3QgdXNlIHBhdHRlcm4sIHdoaWNoIGF2 b2lkcyB0aGUgZ2xvYmFsIGNvbnN0cnVjdG9yIHJlcXVpcmVkIGZvciBhIGNsYXNzIHZhcmlhYmxl LgorICAgIGlubGluZSB1bnNpZ25lZCYgb3V0T2ZSYW5nZUVudW1WYWx1ZSgpCisgICAgeworICAg ICAgICBzdGF0aWMgdW5zaWduZWQgb29yVmFsdWUgPSBTVkdFbnVtTGltaXRzPEVudW1UeXBlPjo6 b3V0T2ZSYW5nZUVudW1WYWx1ZSgpOworICAgICAgICByZXR1cm4gb29yVmFsdWU7CisgICAgfQog fTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5p bWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0 aWVzL1NWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmLmgKaW5kZXggNzdmNmU0OTE3MzM2 NGMxMGJjZmY5ODM4MWQ5NGUyYTA4ZWNmNDExZS4uOTkzMjMxNWVjZDViNjg5NTI4MjgzMTY2ODEw OWIyNDkzMjc1MDhhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMv U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9z dmcvcHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oCkBAIC0zMCwx MiArMzAsMTIgQEAgY2xhc3MgU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYgOiBwdWJs aWMgU1ZHQW5pbWF0ZWRQcm9wZXJ0eSB7CiBwdWJsaWM6CiAgICAgdHlwZWRlZiBQcm9wZXJ0eVR5 cGUgQ29udGVudFR5cGU7CiAKLSAgICBQcm9wZXJ0eVR5cGUmIGJhc2VWYWwoKQorICAgIHZpcnR1 YWwgUHJvcGVydHlUeXBlJiBiYXNlVmFsKCkKICAgICB7CiAgICAgICAgIHJldHVybiBtX3Byb3Bl cnR5OwogICAgIH0KIAotICAgIFByb3BlcnR5VHlwZSYgYW5pbVZhbCgpCisgICAgdmlydHVhbCBQ cm9wZXJ0eVR5cGUmIGFuaW1WYWwoKQogICAgIHsKICAgICAgICAgaWYgKG1fYW5pbWF0ZWRQcm9w ZXJ0eSkKICAgICAgICAgICAgIHJldHVybiAqbV9hbmltYXRlZFByb3BlcnR5OwpAQCAtMTA1LDcg KzEwNSw2IEBAIHByb3RlY3RlZDoKICAgICB7CiAgICAgfQogCi1wcml2YXRlOgogICAgIFByb3Bl cnR5VHlwZSYgbV9wcm9wZXJ0eTsKICAgICBQcm9wZXJ0eVR5cGUqIG1fYW5pbWF0ZWRQcm9wZXJ0 eTsKIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdQcm9w ZXJ0eVRyYWl0cy5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHUHJvcGVydHlU cmFpdHMuaAppbmRleCBkYTc1N2ViNzE3MjViZDIzZWE2ZDYzYTQ3ZmNjMTRiZmZhYTUzMjBhLi43 OGM0ODI3YWQxOTFiZGE5ODg1MWZiNGVkMTZlNmE0YTczNTY0NjczIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdQcm9wZXJ0eVRyYWl0cy5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR1Byb3BlcnR5VHJhaXRzLmgKQEAgLTU4LDYgKzU4 LDEzIEBAIHN0cnVjdCBTVkdQcm9wZXJ0eVRyYWl0czxTdHJpbmc+IHsKICAgICBzdGF0aWMgU3Ry aW5nIHRvU3RyaW5nKGNvbnN0IFN0cmluZyYgdHlwZSkgeyByZXR1cm4gdHlwZTsgfQogfTsKIAor dGVtcGxhdGU8dHlwZW5hbWUgRW51bVR5cGU+CitzdHJ1Y3QgU1ZHRW51bUxpbWl0cyB7CisgICAg c3RhdGljIHVuc2lnbmVkIG91dE9mUmFuZ2VFbnVtVmFsdWUoKSB7IHJldHVybiAwOyB9CisgICAg c3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFbnVtVmFsdWUoKSB7IHJldHVybiAwOyB9CisgICAgc3Rh dGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4gaGlnaGVzdEVu dW1WYWx1ZSgpOyB9Cit9OworCiB9CiAKICNlbmRpZgo= 269253 2016-01-18 18:49:42 -0800 2016-01-18 21:09:41 -0800 Patch bug-152814-20160119134913.patch text/plain 7236 nikos.andronikos U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0OTgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjM2YTA2NDY2YWI5N2Vl YWFjNDY0YzJkYjg4M2I2Y2QyZjk4ZjY4My4uOTQ4NTIxN2M2NGVkZDgxM2ZmMzcwNTBkNzc5NDI4 MDA5NjZjNjhhYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ0IEBACisyMDE2LTAxLTE4ICBOaWtv cyBBbmRyb25pa29zICA8bmlrb3MuYW5kcm9uaWtvcy13ZWJraXRAY2lzcmEuY2Fub24uY29tLmF1 PgorCisgICAgICAgIFNWRyAyIHJlcXVpcmVzIGEgbWVjaGFuaXNtIGZvciByZXN0cmljdGluZyBl bnVtIHZhbHVlcyBleHBvc2VkIHRocm91Z2ggdGhlIERPTQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyODE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChObyBjaGFuZ2UgaW4gZnVu Y3Rpb25hbGl0eSwgYmxvY2tlZCBidWdzIGFkZCBuZXcgdGVzdHMpLgorIAorICAgICAgICBUaGlz IHBhdGNoIGFkZHMgYSBtZWNoYW5pc20gdG8gcmVzdHJpY3QgdGhlIHZhbHVlcyByZXR1cm5lZCB0 aHJvdWdoIHRoZQorICAgICAgICBTVkdBbmltYXRlZEVudW1lcmF0aW9uIGludGVyZmFjZS4KKyAg ICAgICAgVGhpcyBpcyByZXF1aXJlZCBmb3IgU1ZHIDIsIHdoaWNoIGRvZXMgbm90IGV4cG9zZSBu ZXcgZW51bWVyYXRpb24KKyAgICAgICAgdmFsdWVzIHRocm91Z2ggdGhlIElETC4KKyAgICAgICAg U2VlIGh0dHA6Ly93d3cudzMub3JnL1RSL1NWRzIvdHlwZXMuaHRtbCNJbnRlcmZhY2VTVkdBbmlt YXRlZEVudW1lcmF0aW9uCisgICAgICAgIEdldHRlcnM6CisgICAgICAgIFNWRyAyIGRvZXMgbm90 IGFkZCBudW1lcmljIHR5cGUgdmFsdWVzIGZvciBuZXcgb3B0aW9ucywgbmV3IG9wdGlvbnMKKyAg ICAgICAgc2hvdWxkIHJldHVybiBVTktOT1dOLgorICAgICAgICBFLmcuIFNlZSB0aGUgdGFibGUg ZGVmaW5pbmcgbnVtZXJpYyB0eXBlIHZhbHVlcyBmb3Igb3JpZW50IGF0CisgICAgICAgIGh0dHA6 Ly93d3cudzMub3JnL1RSL1NWRzIvcGFpbnRpbmcuaHRtbCNJbnRlcmZhY2VTVkdNYXJrZXJFbGVt ZW50CisgICAgICAgIFNldHRlcnM6CisgICAgICAgIE9uIHNldHRpbmcgYmFzZVZhbCwgdGhlIGZv bGxvd2luZyBzdGVwcyBhcmUgcnVuOgorICAgICAgICAxLiAuLi4KKyAgICAgICAgMi4gSWYgdmFs dWUgaXMgMCBvciBpcyBub3QgdGhlIG51bWVyaWMgdHlwZSB2YWx1ZSBmb3IgYW55IHZhbHVlIG9m IHRoZSByZWZsZWN0ZWQgYXR0cmlidXRlLCB0aGVuIHNldCB0aGUgcmVmbGVjdGVkIGF0dHJpYnV0 ZSB0byB0aGUgZW1wdHkgc3RyaW5nLgorCisgICAgICAgICogc3ZnL1NWR0ZFRGlzcGxhY2VtZW50 TWFwRWxlbWVudC5oOiBSZW1vdmVkIGV4dHJhIHNwYWNpbmcuCisgICAgICAgICogc3ZnL3Byb3Bl cnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oOgorICAgICAgICBP dmVycmlkZSBiYXNlVmFsKCkgYW5kIGFuaW1WYWwoKSB0byBwZXJmb3JtIHJhbmdlIGNoZWNrcyBh Z2FpbnN0CisgICAgICAgIHRoZSBoaWdoZXN0IGV4cG9zZWQgZW51bSB2YWx1ZS4KKyAgICAgICAg KiBzdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oOgorICAg ICAgICAoV2ViQ29yZTo6U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmJhc2VWYWwp OiBNYXJrIGZ1bmN0aW9uIGFzIHZpcnR1YWwgYXMgaXQncyBvdmVyLXJpZGRlbiBmb3IgZW51bWVy YXRpb25zLgorICAgICAgICAoV2ViQ29yZTo6U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJP ZmY6OmFuaW1WYWwpOiBNYXJrIGZ1bmN0aW9uIGFzIHZpcnR1YWwgYXMgaXQncyBvdmVyLXJpZGRl biBmb3IgZW51bWVyYXRpb25zLgorICAgICAgICAqIHN2Zy9wcm9wZXJ0aWVzL1NWR1Byb3BlcnR5 VHJhaXRzLmg6CisgICAgICAgIEFkZCBTVkdJRExFbnVtTGltaXRzIHN0cnVjdCB0aGF0IGNvbnRh aW5zIGZ1bmN0aW9ucyBmb3IgcXVlcnlpbmcgdGhlCisgICAgICAgIGhpZ2hlc3QgZXhwb3NlZCBl bnVtIHZhbHVlIGFuZCB0aGUgdmFsdWUgdG8gYmUgcmV0dXJuZWQgaW5zdGVhZCBvZgorICAgICAg ICBvdXQgb2YgcmFuZ2UgdmFsdWVzLgorICAgICAgICAoV2ViQ29yZTo6U1ZHSURMRW51bUxpbWl0 czo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUpOiBOZXcgZnVuY3Rpb24gdGhhdCByZXR1cm5zIHRo ZSBoaWdoZXN0IGVudW0gdmFsdWUgdGhhdCBzaG91bGQKKyAgICAgICAgYmUgZXhwb3NlZCB0aHJv dWdoIHRoZSBET00uIFRoaXMgZnVuY3Rpb24gc2hvdWxkIGJlIHNwZWNpYWxpemVkIGZvciBlbnVt IHR5cGVzIHRoYXQgbmVlZCB0byByZXN0cmljdCB0aGUgZXhwb3NlZAorICAgICAgICB2YWx1ZXMu CisgICAgICAgIChXZWJDb3JlOjpTVkdJRExFbnVtTGltaXRzOjpvdXRPZlJhbmdlRW51bVZhbHVl KTogTmV3IGZ1bmN0aW9uIHRoYXQgcmV0dXJucyB0aGUgdmFsdWUgdG8gYmUgdXNlZCBpbiBwbGFj ZSBvZgorICAgICAgICBvdXQgb2YgcmFuZ2UgdmFsdWVzLiAKKwogMjAxNi0wMS0xMyAgQ29tbWl0 IFF1ZXVlICA8Y29tbWl0LXF1ZXVlQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwg cm9sbGluZyBvdXQgcjE5NDk2My4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdG RURpc3BsYWNlbWVudE1hcEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdGRURpc3Bs YWNlbWVudE1hcEVsZW1lbnQuaAppbmRleCBhNjRmODE5NjkyZTU1ZjEyOWIwZjY2Njk1NDk1OTg4 NzcyNjcyOGQxLi42YWFkOTBmZTIyZWQxNWMwNDYzNzk1YjdkMzdjZDUzN2ViNGEyNWY2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50LmgK KysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0ZFRGlzcGxhY2VtZW50TWFwRWxlbWVudC5oCkBA IC0yNiw3ICsyNiw3IEBACiAjaW5jbHVkZSAiU1ZHRmlsdGVyUHJpbWl0aXZlU3RhbmRhcmRBdHRy aWJ1dGVzLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKLSAKKwogdGVtcGxhdGU8Pgogc3RydWN0 IFNWR1Byb3BlcnR5VHJhaXRzPENoYW5uZWxTZWxlY3RvclR5cGU+IHsKICAgICBzdGF0aWMgdW5z aWduZWQgaGlnaGVzdEVudW1WYWx1ZSgpIHsgcmV0dXJuIENIQU5ORUxfQTsgfQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblBy b3BlcnR5VGVhck9mZi5oIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0 ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oCmluZGV4IGQxZDJkMDMwM2JkZTAxZmQ2MTI3 M2Y2OTllNTgxYWIyNGJlYWVhMjQuLjcxNmMxMTYwMDgzNjljM2RmZjc3YzU2Y2I1Y2YzOWNjMjM3 ZWUyY2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1h dGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcv cHJvcGVydGllcy9TVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlUZWFyT2ZmLmgKQEAgLTI3 LDEyICsyNywzMiBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBF bnVtVHlwZT4KLWNsYXNzIFNWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYgOiBw dWJsaWMgU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY8dW5zaWduZWQ+IHsKK2NsYXNz IFNWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYgZmluYWwgOiBwdWJsaWMgU1ZH QW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY8dW5zaWduZWQ+IHsKIHB1YmxpYzoKKyAgICB2 aXJ0dWFsIHVuc2lnbmVkJiBiYXNlVmFsKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIHVuc2ln bmVkJiBiYXNlVmFsID0gU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmJhc2VWYWwo KTsKKworICAgICAgICBpZiAoYmFzZVZhbCA+IFNWR0lETEVudW1MaW1pdHM8RW51bVR5cGU+Ojpo aWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgpKQorICAgICAgICAgICAgcmV0dXJuIG91dE9mUmFuZ2VF bnVtVmFsdWUoKTsKKworICAgICAgICByZXR1cm4gYmFzZVZhbDsKKyAgICB9CisKKyAgICB2aXJ0 dWFsIHVuc2lnbmVkJiBhbmltVmFsKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIHVuc2lnbmVk JiBhbmltVmFsID0gU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmFuaW1WYWwoKTsK KworICAgICAgICBpZiAoYW5pbVZhbCA+IFNWR0lETEVudW1MaW1pdHM8RW51bVR5cGU+OjpoaWdo ZXN0RXhwb3NlZEVudW1WYWx1ZSgpKQorICAgICAgICAgICAgcmV0dXJuIG91dE9mUmFuZ2VFbnVt VmFsdWUoKTsKKworICAgICAgICByZXR1cm4gYW5pbVZhbDsKKyAgICB9CisKICAgICB2aXJ0dWFs IHZvaWQgc2V0QmFzZVZhbChjb25zdCB1bnNpZ25lZCYgcHJvcGVydHksIEV4Y2VwdGlvbkNvZGUm IGVjKSBvdmVycmlkZQogICAgIHsKICAgICAgICAgLy8gQWxsIFNWRyBlbnVtZXJhdGlvbiB2YWx1 ZXMsIHRoYXQgYXJlIGFsbG93ZWQgdG8gYmUgc2V0IHZpYSBTVkcgRE9NIHN0YXJ0IHdpdGggMSwg MCBjb3JyZXNwb25kcyB0byB1bmtub3duIGFuZCBpcyBub3Qgc2V0dGFibGUgdGhyb3VnaCBTVkcg RE9NLgotICAgICAgICBpZiAoIXByb3BlcnR5IHx8IHByb3BlcnR5ID4gU1ZHUHJvcGVydHlUcmFp dHM8RW51bVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCkpIHsKKyAgICAgICAgaWYgKCFwcm9wZXJ0 eSB8fCBwcm9wZXJ0eSA+IFNWR0lETEVudW1MaW1pdHM8RW51bVR5cGU+OjpoaWdoZXN0RXhwb3Nl ZEVudW1WYWx1ZSgpKSB7CiAgICAgICAgICAgICBlYyA9IFNWR0V4Y2VwdGlvbjo6U1ZHX0lOVkFM SURfVkFMVUVfRVJSOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CkBAIC01Nyw2ICs3 NywxMyBAQCBwcml2YXRlOgogICAgICAgICA6IFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFy T2ZmPHVuc2lnbmVkPihjb250ZXh0RWxlbWVudCwgYXR0cmlidXRlTmFtZSwgYW5pbWF0ZWRQcm9w ZXJ0eVR5cGUsIHByb3BlcnR5KQogICAgIHsKICAgICB9CisKKyAgICAvLyBXZSB1c2UgYSBmdW5j dGlvbiBtZW1iZXIgaW5zdGVhZCBvZiBhIGRhdGEgbWVtYmVyIGhlcmUgdG8gYXZvaWQgdGhlIGds b2JhbCBjb25zdHJ1Y3RvciB0aGF0IHdvdWxkIGJlIG5lZWRlZCBmb3IgYW4gaW5pdGlhbGl6ZWQg c3RhdGljIGRhdGEgbWVtYmVyLgorICAgIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQmIG91dE9mUmFu Z2VFbnVtVmFsdWUoKQorICAgIHsKKyAgICAgICAgc3RhdGljIHVuc2lnbmVkIG9vclZhbHVlID0g U1ZHSURMRW51bUxpbWl0czxFbnVtVHlwZT46Om91dE9mUmFuZ2VFbnVtVmFsdWUoKTsKKyAgICAg ICAgcmV0dXJuIG9vclZhbHVlOworICAgIH0KIH07CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmLmgg Yi9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5 VGVhck9mZi5oCmluZGV4IDc3ZjZlNDkxNzMzNjRjMTBiY2ZmOTgzODFkOTRlMmEwOGVjZjQxMWUu LjllY2Y0NGM3NzNkYzUwYzVlNTJiMGE5NjhkODRiN2Q0YTZkMzJmMDIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFy T2ZmLmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRTdGF0 aWNQcm9wZXJ0eVRlYXJPZmYuaApAQCAtMzAsMTIgKzMwLDEyIEBAIGNsYXNzIFNWR0FuaW1hdGVk U3RhdGljUHJvcGVydHlUZWFyT2ZmIDogcHVibGljIFNWR0FuaW1hdGVkUHJvcGVydHkgewogcHVi bGljOgogICAgIHR5cGVkZWYgUHJvcGVydHlUeXBlIENvbnRlbnRUeXBlOwogCi0gICAgUHJvcGVy dHlUeXBlJiBiYXNlVmFsKCkKKyAgICB2aXJ0dWFsIFByb3BlcnR5VHlwZSYgYmFzZVZhbCgpCiAg ICAgewogICAgICAgICByZXR1cm4gbV9wcm9wZXJ0eTsKICAgICB9CiAKLSAgICBQcm9wZXJ0eVR5 cGUmIGFuaW1WYWwoKQorICAgIHZpcnR1YWwgUHJvcGVydHlUeXBlJiBhbmltVmFsKCkKICAgICB7 CiAgICAgICAgIGlmIChtX2FuaW1hdGVkUHJvcGVydHkpCiAgICAgICAgICAgICByZXR1cm4gKm1f YW5pbWF0ZWRQcm9wZXJ0eTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0 aWVzL1NWR1Byb3BlcnR5VHJhaXRzLmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9T VkdQcm9wZXJ0eVRyYWl0cy5oCmluZGV4IGRhNzU3ZWI3MTcyNWJkMjNlYTZkNjNhNDdmY2MxNGJm ZmFhNTMyMGEuLmQxZDliN2FjNDcxNmQyMGRlYTNjMGEyNmU3YjViNGExY2U4YWI5YzcgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR1Byb3BlcnR5VHJhaXRzLmgK KysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHUHJvcGVydHlUcmFpdHMuaApA QCAtNTgsNiArNTgsMTQgQEAgc3RydWN0IFNWR1Byb3BlcnR5VHJhaXRzPFN0cmluZz4gewogICAg IHN0YXRpYyBTdHJpbmcgdG9TdHJpbmcoY29uc3QgU3RyaW5nJiB0eXBlKSB7IHJldHVybiB0eXBl OyB9CiB9OwogCit0ZW1wbGF0ZTx0eXBlbmFtZSBFbnVtVHlwZT4KK3N0cnVjdCBTVkdJRExFbnVt TGltaXRzIHsKKyAgICAvLyBTcGVjaWFsaXplIHRoaXMgZnVuY3Rpb24gZm9yIGEgcGFydGljdWxh ciBlbnVtZXJhdGlvbiB0byBsaW1pdCB0aGUgdmFsdWVzIHRoYXQgYXJlIGV4cG9zZWQgdGhyb3Vn aCB0aGUgRE9NLgorICAgIHN0YXRpYyB1bnNpZ25lZCBoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSgp IHsgcmV0dXJuIFNWR1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSgp OyB9CisgICAgLy8gQnkgY29udmVudGlvbiwgYWxsIGVudW0gdmFsdWVzIHRoYXQgcmVwcmVzZW50 IFVOS05PV04gaW4gU1ZHIGFyZSBlcXVhbCB0byB6ZXJvLgorICAgIHN0YXRpYyB1bnNpZ25lZCBv dXRPZlJhbmdlRW51bVZhbHVlKCkgeyByZXR1cm4gMDsgfQorfTsKKwogfQogCiAjZW5kaWYK 269256 2016-01-18 21:09:50 -0800 2016-01-19 13:42:37 -0800 Patch bug-152814-20160119160920.patch text/plain 6229 nikos.andronikos U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0OTgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjM2YTA2NDY2YWI5N2Vl YWFjNDY0YzJkYjg4M2I2Y2QyZjk4ZjY4My4uZmE5YmZiZDNhNzE4ZGUxNThlYTFiM2Y5MDZhZDcw ZjA1NDI4YWMzZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDE2LTAxLTE4ICBOaWtv cyBBbmRyb25pa29zICA8bmlrb3MuYW5kcm9uaWtvcy13ZWJraXRAY2lzcmEuY2Fub24uY29tLmF1 PgorCisgICAgICAgIFNWRyAyIHJlcXVpcmVzIGEgbWVjaGFuaXNtIGZvciByZXN0cmljdGluZyBl bnVtIHZhbHVlcyBleHBvc2VkIHRocm91Z2ggdGhlIERPTQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyODE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChObyBjaGFuZ2UgaW4gZnVu Y3Rpb25hbGl0eSwgYmxvY2tlZCBidWdzIGFkZCBuZXcgdGVzdHMpLgorIAorICAgICAgICBUaGlz IHBhdGNoIGFkZHMgYSBtZWNoYW5pc20gdG8gcmVzdHJpY3QgdGhlIHZhbHVlcyByZXR1cm5lZCB0 aHJvdWdoIHRoZQorICAgICAgICBTVkdBbmltYXRlZEVudW1lcmF0aW9uIGludGVyZmFjZS4KKyAg ICAgICAgVGhpcyBpcyByZXF1aXJlZCBmb3IgU1ZHIDIsIHdoaWNoIGRvZXMgbm90IGV4cG9zZSBu ZXcgZW51bWVyYXRpb24KKyAgICAgICAgdmFsdWVzIHRocm91Z2ggdGhlIElETC4KKyAgICAgICAg U2VlIGh0dHA6Ly93d3cudzMub3JnL1RSL1NWRzIvdHlwZXMuaHRtbCNJbnRlcmZhY2VTVkdBbmlt YXRlZEVudW1lcmF0aW9uCisgICAgICAgIEdldHRlcnM6CisgICAgICAgIFNWRyAyIGRvZXMgbm90 IGFkZCBudW1lcmljIHR5cGUgdmFsdWVzIGZvciBuZXcgb3B0aW9ucywgbmV3IG9wdGlvbnMKKyAg ICAgICAgc2hvdWxkIHJldHVybiBVTktOT1dOLgorICAgICAgICBFLmcuIFNlZSB0aGUgdGFibGUg ZGVmaW5pbmcgbnVtZXJpYyB0eXBlIHZhbHVlcyBmb3Igb3JpZW50IGF0CisgICAgICAgIGh0dHA6 Ly93d3cudzMub3JnL1RSL1NWRzIvcGFpbnRpbmcuaHRtbCNJbnRlcmZhY2VTVkdNYXJrZXJFbGVt ZW50CisgICAgICAgIFNldHRlcnM6CisgICAgICAgIE9uIHNldHRpbmcgYmFzZVZhbCwgdGhlIGZv bGxvd2luZyBzdGVwcyBhcmUgcnVuOgorICAgICAgICAxLiAuLi4KKyAgICAgICAgMi4gSWYgdmFs dWUgaXMgMCBvciBpcyBub3QgdGhlIG51bWVyaWMgdHlwZSB2YWx1ZSBmb3IgYW55IHZhbHVlIG9m IHRoZSByZWZsZWN0ZWQgYXR0cmlidXRlLCB0aGVuIHNldCB0aGUgcmVmbGVjdGVkIGF0dHJpYnV0 ZSB0byB0aGUgZW1wdHkgc3RyaW5nLgorCisgICAgICAgICogc3ZnL3Byb3BlcnRpZXMvU1ZHQW5p bWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oOgorICAgICAgICBPdmVycmlkZSBiYXNl VmFsKCkgYW5kIGFuaW1WYWwoKSB0byBwZXJmb3JtIHJhbmdlIGNoZWNrcyBhZ2FpbnN0CisgICAg ICAgIHRoZSBoaWdoZXN0IGV4cG9zZWQgZW51bSB2YWx1ZS4KKyAgICAgICAgKiBzdmcvcHJvcGVy dGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oOgorICAgICAgICAoV2ViQ29y ZTo6U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmJhc2VWYWwpOiBNYXJrIGZ1bmN0 aW9uIGFzIHZpcnR1YWwgYXMgaXQncyBvdmVyLXJpZGRlbiBmb3IgZW51bWVyYXRpb25zLgorICAg ICAgICAoV2ViQ29yZTo6U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmFuaW1WYWwp OiBNYXJrIGZ1bmN0aW9uIGFzIHZpcnR1YWwgYXMgaXQncyBvdmVyLXJpZGRlbiBmb3IgZW51bWVy YXRpb25zLgorICAgICAgICAqIHN2Zy9wcm9wZXJ0aWVzL1NWR1Byb3BlcnR5VHJhaXRzLmg6Cisg ICAgICAgIEFkZCBTVkdJRExFbnVtTGltaXRzIHN0cnVjdCB0aGF0IGNvbnRhaW5zIGZ1bmN0aW9u IGZvciBxdWVyeWluZyB0aGUKKyAgICAgICAgaGlnaGVzdCBleHBvc2VkIGVudW0gdmFsdWUuCisg ICAgICAgIChXZWJDb3JlOjpTVkdJRExFbnVtTGltaXRzOjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1 ZSk6IE5ldyBmdW5jdGlvbiB0aGF0IHJldHVybnMgdGhlIGhpZ2hlc3QgZW51bSB2YWx1ZSB0aGF0 IHNob3VsZAorICAgICAgICBiZSBleHBvc2VkIHRocm91Z2ggdGhlIERPTS4gVGhpcyBmdW5jdGlv biBzaG91bGQgYmUgc3BlY2lhbGl6ZWQgZm9yIGVudW0gdHlwZXMgdGhhdCBuZWVkIHRvIHJlc3Ry aWN0IHRoZSBleHBvc2VkCisgICAgICAgIHZhbHVlcy4KKwogMjAxNi0wMS0xMyAgQ29tbWl0IFF1 ZXVlICA8Y29tbWl0LXF1ZXVlQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9s bGluZyBvdXQgcjE5NDk2My4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0 aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaCBiL1NvdXJjZS9XZWJD b3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYu aAppbmRleCBkMWQyZDAzMDNiZGUwMWZkNjEyNzNmNjk5ZTU4MWFiMjRiZWFlYTI0Li40MTQyNDY2 Y2I4NWEyZWI0YjZkM2IxNDM1Njg0YTBkYzBjNzdkOTQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlUZWFyT2Zm LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJh dGlvblByb3BlcnR5VGVhck9mZi5oCkBAIC0yNywxMiArMjcsMzIgQEAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogdGVtcGxhdGU8dHlwZW5hbWUgRW51bVR5cGU+Ci1jbGFzcyBTVkdBbmltYXRlZEVu dW1lcmF0aW9uUHJvcGVydHlUZWFyT2ZmIDogcHVibGljIFNWR0FuaW1hdGVkU3RhdGljUHJvcGVy dHlUZWFyT2ZmPHVuc2lnbmVkPiB7CitjbGFzcyBTVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVy dHlUZWFyT2ZmIGZpbmFsIDogcHVibGljIFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2Zm PHVuc2lnbmVkPiB7CiBwdWJsaWM6CisgICAgdmlydHVhbCB1bnNpZ25lZCYgYmFzZVZhbCgpIG92 ZXJyaWRlCisgICAgeworICAgICAgICB1bnNpZ25lZCYgYmFzZVZhbCA9IFNWR0FuaW1hdGVkU3Rh dGljUHJvcGVydHlUZWFyT2ZmOjpiYXNlVmFsKCk7CisKKyAgICAgICAgaWYgKGJhc2VWYWwgPiBT VkdJRExFbnVtTGltaXRzPEVudW1UeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkKKyAg ICAgICAgICAgIHJldHVybiBtX291dE9mUmFuZ2VFbnVtVmFsdWU7CisKKyAgICAgICAgcmV0dXJu IGJhc2VWYWw7CisgICAgfQorCisgICAgdmlydHVhbCB1bnNpZ25lZCYgYW5pbVZhbCgpIG92ZXJy aWRlCisgICAgeworICAgICAgICB1bnNpZ25lZCYgYW5pbVZhbCA9IFNWR0FuaW1hdGVkU3RhdGlj UHJvcGVydHlUZWFyT2ZmOjphbmltVmFsKCk7CisKKyAgICAgICAgaWYgKGFuaW1WYWwgPiBTVkdJ RExFbnVtTGltaXRzPEVudW1UeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkKKyAgICAg ICAgICAgIHJldHVybiBtX291dE9mUmFuZ2VFbnVtVmFsdWU7CisKKyAgICAgICAgcmV0dXJuIGFu aW1WYWw7CisgICAgfQorCiAgICAgdmlydHVhbCB2b2lkIHNldEJhc2VWYWwoY29uc3QgdW5zaWdu ZWQmIHByb3BlcnR5LCBFeGNlcHRpb25Db2RlJiBlYykgb3ZlcnJpZGUKICAgICB7CiAgICAgICAg IC8vIEFsbCBTVkcgZW51bWVyYXRpb24gdmFsdWVzLCB0aGF0IGFyZSBhbGxvd2VkIHRvIGJlIHNl dCB2aWEgU1ZHIERPTSBzdGFydCB3aXRoIDEsIDAgY29ycmVzcG9uZHMgdG8gdW5rbm93biBhbmQg aXMgbm90IHNldHRhYmxlIHRocm91Z2ggU1ZHIERPTS4KLSAgICAgICAgaWYgKCFwcm9wZXJ0eSB8 fCBwcm9wZXJ0eSA+IFNWR1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6aGlnaGVzdEVudW1WYWx1 ZSgpKSB7CisgICAgICAgIGlmICghcHJvcGVydHkgfHwgcHJvcGVydHkgPiBTVkdJRExFbnVtTGlt aXRzPEVudW1UeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkgewogICAgICAgICAgICAg ZWMgPSBTVkdFeGNlcHRpb246OlNWR19JTlZBTElEX1ZBTFVFX0VSUjsKICAgICAgICAgICAgIHJl dHVybjsKICAgICAgICAgfQpAQCAtNTcsOCArNzcsMTQgQEAgcHJpdmF0ZToKICAgICAgICAgOiBT VkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZjx1bnNpZ25lZD4oY29udGV4dEVsZW1lbnQs IGF0dHJpYnV0ZU5hbWUsIGFuaW1hdGVkUHJvcGVydHlUeXBlLCBwcm9wZXJ0eSkKICAgICB7CiAg ICAgfQorCisgICAgc3RhdGljIHVuc2lnbmVkIG1fb3V0T2ZSYW5nZUVudW1WYWx1ZTsKIH07CiAK Ky8vIEJ5IGNvbnZlbnRpb24sIGFsbCBlbnVtIHZhbHVlcyB0aGF0IHJlcHJlc2VudCBVTktOT1dO IGluIFNWRyBhcmUgZXF1YWwgdG8gemVyby4KK3RlbXBsYXRlPHR5cGVuYW1lIEVudW1UeXBlPgor dW5zaWduZWQgU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZjxFbnVtVHlwZT46 Om1fb3V0T2ZSYW5nZUVudW1WYWx1ZSA9IDA7CisKIH0KIAogI2VuZGlmIC8vIFNWR0FuaW1hdGVk RW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmZfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv c3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaCBiL1NvdXJj ZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2Zm LmgKaW5kZXggNzdmNmU0OTE3MzM2NGMxMGJjZmY5ODM4MWQ5NGUyYTA4ZWNmNDExZS4uOWVjZjQ0 Yzc3M2RjNTBjNWU1MmIwYTk2OGQ4NGI3ZDRhNmQzMmYwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3Bl cnR5VGVhck9mZi5oCkBAIC0zMCwxMiArMzAsMTIgQEAgY2xhc3MgU1ZHQW5pbWF0ZWRTdGF0aWNQ cm9wZXJ0eVRlYXJPZmYgOiBwdWJsaWMgU1ZHQW5pbWF0ZWRQcm9wZXJ0eSB7CiBwdWJsaWM6CiAg ICAgdHlwZWRlZiBQcm9wZXJ0eVR5cGUgQ29udGVudFR5cGU7CiAKLSAgICBQcm9wZXJ0eVR5cGUm IGJhc2VWYWwoKQorICAgIHZpcnR1YWwgUHJvcGVydHlUeXBlJiBiYXNlVmFsKCkKICAgICB7CiAg ICAgICAgIHJldHVybiBtX3Byb3BlcnR5OwogICAgIH0KIAotICAgIFByb3BlcnR5VHlwZSYgYW5p bVZhbCgpCisgICAgdmlydHVhbCBQcm9wZXJ0eVR5cGUmIGFuaW1WYWwoKQogICAgIHsKICAgICAg ICAgaWYgKG1fYW5pbWF0ZWRQcm9wZXJ0eSkKICAgICAgICAgICAgIHJldHVybiAqbV9hbmltYXRl ZFByb3BlcnR5OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZH UHJvcGVydHlUcmFpdHMuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR1Byb3Bl cnR5VHJhaXRzLmgKaW5kZXggZGE3NTdlYjcxNzI1YmQyM2VhNmQ2M2E0N2ZjYzE0YmZmYWE1MzIw YS4uNjRlYTliODRmZGQyMzk4NTczYzAxZDA5NjBjYmU2NDk4ZjdhZjVmZiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHUHJvcGVydHlUcmFpdHMuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdQcm9wZXJ0eVRyYWl0cy5oCkBAIC01OCw2 ICs1OCwxMiBAQCBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8U3RyaW5nPiB7CiAgICAgc3RhdGlj IFN0cmluZyB0b1N0cmluZyhjb25zdCBTdHJpbmcmIHR5cGUpIHsgcmV0dXJuIHR5cGU7IH0KIH07 CiAKK3RlbXBsYXRlPHR5cGVuYW1lIEVudW1UeXBlPgorc3RydWN0IFNWR0lETEVudW1MaW1pdHMg eworICAgIC8vIFNwZWNpYWxpemUgdGhpcyBmdW5jdGlvbiBmb3IgYSBwYXJ0aWN1bGFyIGVudW1l cmF0aW9uIHRvIGxpbWl0IHRoZSB2YWx1ZXMgdGhhdCBhcmUgZXhwb3NlZCB0aHJvdWdoIHRoZSBE T00uCisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1 cm4gU1ZHUHJvcGVydHlUcmFpdHM8RW51bVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCk7IH0KK307 CisKIH0KIAogI2VuZGlmCg== 269289 2016-01-19 13:42:46 -0800 2016-01-19 14:02:08 -0800 Patch bug-152814-20160120084220.patch text/plain 6226 nikos.andronikos U3VidmVyc2lvbiBSZXZpc2lvbjogMTk0OTgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjM2YTA2NDY2YWI5N2Vl YWFjNDY0YzJkYjg4M2I2Y2QyZjk4ZjY4My4uMTk0NmYxMDY2NGM0NDBjOTNmMGQwMTkyOTcwNmYy YTJiMWVhZTU4ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDE2LTAxLTE4ICBOaWtv cyBBbmRyb25pa29zICA8bmlrb3MuYW5kcm9uaWtvcy13ZWJraXRAY2lzcmEuY2Fub24uY29tLmF1 PgorCisgICAgICAgIFNWRyAyIHJlcXVpcmVzIGEgbWVjaGFuaXNtIGZvciByZXN0cmljdGluZyBl bnVtIHZhbHVlcyBleHBvc2VkIHRocm91Z2ggdGhlIERPTQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUyODE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg RGFyaW4gQWRsZXIuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChObyBjaGFuZ2UgaW4gZnVuY3Rp b25hbGl0eSwgYmxvY2tlZCBidWdzIGFkZCBuZXcgdGVzdHMpLgorIAorICAgICAgICBUaGlzIHBh dGNoIGFkZHMgYSBtZWNoYW5pc20gdG8gcmVzdHJpY3QgdGhlIHZhbHVlcyByZXR1cm5lZCB0aHJv dWdoIHRoZQorICAgICAgICBTVkdBbmltYXRlZEVudW1lcmF0aW9uIGludGVyZmFjZS4KKyAgICAg ICAgVGhpcyBpcyByZXF1aXJlZCBmb3IgU1ZHIDIsIHdoaWNoIGRvZXMgbm90IGV4cG9zZSBuZXcg ZW51bWVyYXRpb24KKyAgICAgICAgdmFsdWVzIHRocm91Z2ggdGhlIElETC4KKyAgICAgICAgU2Vl IGh0dHA6Ly93d3cudzMub3JnL1RSL1NWRzIvdHlwZXMuaHRtbCNJbnRlcmZhY2VTVkdBbmltYXRl ZEVudW1lcmF0aW9uCisgICAgICAgIEdldHRlcnM6CisgICAgICAgIFNWRyAyIGRvZXMgbm90IGFk ZCBudW1lcmljIHR5cGUgdmFsdWVzIGZvciBuZXcgb3B0aW9ucywgbmV3IG9wdGlvbnMKKyAgICAg ICAgc2hvdWxkIHJldHVybiBVTktOT1dOLgorICAgICAgICBFLmcuIFNlZSB0aGUgdGFibGUgZGVm aW5pbmcgbnVtZXJpYyB0eXBlIHZhbHVlcyBmb3Igb3JpZW50IGF0CisgICAgICAgIGh0dHA6Ly93 d3cudzMub3JnL1RSL1NWRzIvcGFpbnRpbmcuaHRtbCNJbnRlcmZhY2VTVkdNYXJrZXJFbGVtZW50 CisgICAgICAgIFNldHRlcnM6CisgICAgICAgIE9uIHNldHRpbmcgYmFzZVZhbCwgdGhlIGZvbGxv d2luZyBzdGVwcyBhcmUgcnVuOgorICAgICAgICAxLiAuLi4KKyAgICAgICAgMi4gSWYgdmFsdWUg aXMgMCBvciBpcyBub3QgdGhlIG51bWVyaWMgdHlwZSB2YWx1ZSBmb3IgYW55IHZhbHVlIG9mIHRo ZSByZWZsZWN0ZWQgYXR0cmlidXRlLCB0aGVuIHNldCB0aGUgcmVmbGVjdGVkIGF0dHJpYnV0ZSB0 byB0aGUgZW1wdHkgc3RyaW5nLgorCisgICAgICAgICogc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0 ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZi5oOgorICAgICAgICBPdmVycmlkZSBiYXNlVmFs KCkgYW5kIGFuaW1WYWwoKSB0byBwZXJmb3JtIHJhbmdlIGNoZWNrcyBhZ2FpbnN0CisgICAgICAg IHRoZSBoaWdoZXN0IGV4cG9zZWQgZW51bSB2YWx1ZS4KKyAgICAgICAgKiBzdmcvcHJvcGVydGll cy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZi5oOgorICAgICAgICAoV2ViQ29yZTo6 U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmJhc2VWYWwpOiBNYXJrIGZ1bmN0aW9u IGFzIHZpcnR1YWwgYXMgaXQncyBvdmVyLXJpZGRlbiBmb3IgZW51bWVyYXRpb25zLgorICAgICAg ICAoV2ViQ29yZTo6U1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmY6OmFuaW1WYWwpOiBN YXJrIGZ1bmN0aW9uIGFzIHZpcnR1YWwgYXMgaXQncyBvdmVyLXJpZGRlbiBmb3IgZW51bWVyYXRp b25zLgorICAgICAgICAqIHN2Zy9wcm9wZXJ0aWVzL1NWR1Byb3BlcnR5VHJhaXRzLmg6CisgICAg ICAgIEFkZCBTVkdJRExFbnVtTGltaXRzIHN0cnVjdCB0aGF0IGNvbnRhaW5zIGZ1bmN0aW9uIGZv ciBxdWVyeWluZyB0aGUKKyAgICAgICAgaGlnaGVzdCBleHBvc2VkIGVudW0gdmFsdWUuCisgICAg ICAgIChXZWJDb3JlOjpTVkdJRExFbnVtTGltaXRzOjpoaWdoZXN0RXhwb3NlZEVudW1WYWx1ZSk6 IE5ldyBmdW5jdGlvbiB0aGF0IHJldHVybnMgdGhlIGhpZ2hlc3QgZW51bSB2YWx1ZSB0aGF0IHNo b3VsZAorICAgICAgICBiZSBleHBvc2VkIHRocm91Z2ggdGhlIERPTS4gVGhpcyBmdW5jdGlvbiBz aG91bGQgYmUgc3BlY2lhbGl6ZWQgZm9yIGVudW0gdHlwZXMgdGhhdCBuZWVkIHRvIHJlc3RyaWN0 IHRoZSBleHBvc2VkCisgICAgICAgIHZhbHVlcy4KKwogMjAxNi0wMS0xMyAgQ29tbWl0IFF1ZXVl ICA8Y29tbWl0LXF1ZXVlQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGlu ZyBvdXQgcjE5NDk2My4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVz L1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaCBiL1NvdXJjZS9XZWJDb3Jl L3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkRW51bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmYuaApp bmRleCBkMWQyZDAzMDNiZGUwMWZkNjEyNzNmNjk5ZTU4MWFiMjRiZWFlYTI0Li40MTQyNDY2Y2I4 NWEyZWI0YjZkM2IxNDM1Njg0YTBkYzBjNzdkOTQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlUZWFyT2ZmLmgK KysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRFbnVtZXJhdGlv blByb3BlcnR5VGVhck9mZi5oCkBAIC0yNywxMiArMjcsMzIgQEAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAogdGVtcGxhdGU8dHlwZW5hbWUgRW51bVR5cGU+Ci1jbGFzcyBTVkdBbmltYXRlZEVudW1l cmF0aW9uUHJvcGVydHlUZWFyT2ZmIDogcHVibGljIFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlU ZWFyT2ZmPHVuc2lnbmVkPiB7CitjbGFzcyBTVkdBbmltYXRlZEVudW1lcmF0aW9uUHJvcGVydHlU ZWFyT2ZmIGZpbmFsIDogcHVibGljIFNWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmPHVu c2lnbmVkPiB7CiBwdWJsaWM6CisgICAgdmlydHVhbCB1bnNpZ25lZCYgYmFzZVZhbCgpIG92ZXJy aWRlCisgICAgeworICAgICAgICB1bnNpZ25lZCYgYmFzZVZhbCA9IFNWR0FuaW1hdGVkU3RhdGlj UHJvcGVydHlUZWFyT2ZmOjpiYXNlVmFsKCk7CisKKyAgICAgICAgaWYgKGJhc2VWYWwgPiBTVkdJ RExFbnVtTGltaXRzPEVudW1UeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkKKyAgICAg ICAgICAgIHJldHVybiBtX291dE9mUmFuZ2VFbnVtVmFsdWU7CisKKyAgICAgICAgcmV0dXJuIGJh c2VWYWw7CisgICAgfQorCisgICAgdmlydHVhbCB1bnNpZ25lZCYgYW5pbVZhbCgpIG92ZXJyaWRl CisgICAgeworICAgICAgICB1bnNpZ25lZCYgYW5pbVZhbCA9IFNWR0FuaW1hdGVkU3RhdGljUHJv cGVydHlUZWFyT2ZmOjphbmltVmFsKCk7CisKKyAgICAgICAgaWYgKGFuaW1WYWwgPiBTVkdJRExF bnVtTGltaXRzPEVudW1UeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkKKyAgICAgICAg ICAgIHJldHVybiBtX291dE9mUmFuZ2VFbnVtVmFsdWU7CisKKyAgICAgICAgcmV0dXJuIGFuaW1W YWw7CisgICAgfQorCiAgICAgdmlydHVhbCB2b2lkIHNldEJhc2VWYWwoY29uc3QgdW5zaWduZWQm IHByb3BlcnR5LCBFeGNlcHRpb25Db2RlJiBlYykgb3ZlcnJpZGUKICAgICB7CiAgICAgICAgIC8v IEFsbCBTVkcgZW51bWVyYXRpb24gdmFsdWVzLCB0aGF0IGFyZSBhbGxvd2VkIHRvIGJlIHNldCB2 aWEgU1ZHIERPTSBzdGFydCB3aXRoIDEsIDAgY29ycmVzcG9uZHMgdG8gdW5rbm93biBhbmQgaXMg bm90IHNldHRhYmxlIHRocm91Z2ggU1ZHIERPTS4KLSAgICAgICAgaWYgKCFwcm9wZXJ0eSB8fCBw cm9wZXJ0eSA+IFNWR1Byb3BlcnR5VHJhaXRzPEVudW1UeXBlPjo6aGlnaGVzdEVudW1WYWx1ZSgp KSB7CisgICAgICAgIGlmICghcHJvcGVydHkgfHwgcHJvcGVydHkgPiBTVkdJRExFbnVtTGltaXRz PEVudW1UeXBlPjo6aGlnaGVzdEV4cG9zZWRFbnVtVmFsdWUoKSkgewogICAgICAgICAgICAgZWMg PSBTVkdFeGNlcHRpb246OlNWR19JTlZBTElEX1ZBTFVFX0VSUjsKICAgICAgICAgICAgIHJldHVy bjsKICAgICAgICAgfQpAQCAtNTcsOCArNzcsMTQgQEAgcHJpdmF0ZToKICAgICAgICAgOiBTVkdB bmltYXRlZFN0YXRpY1Byb3BlcnR5VGVhck9mZjx1bnNpZ25lZD4oY29udGV4dEVsZW1lbnQsIGF0 dHJpYnV0ZU5hbWUsIGFuaW1hdGVkUHJvcGVydHlUeXBlLCBwcm9wZXJ0eSkKICAgICB7CiAgICAg fQorCisgICAgc3RhdGljIHVuc2lnbmVkIG1fb3V0T2ZSYW5nZUVudW1WYWx1ZTsKIH07CiAKKy8v IEJ5IGNvbnZlbnRpb24sIGFsbCBlbnVtIHZhbHVlcyB0aGF0IHJlcHJlc2VudCBVTktOT1dOIGlu IFNWRyBhcmUgZXF1YWwgdG8gemVyby4KK3RlbXBsYXRlPHR5cGVuYW1lIEVudW1UeXBlPgordW5z aWduZWQgU1ZHQW5pbWF0ZWRFbnVtZXJhdGlvblByb3BlcnR5VGVhck9mZjxFbnVtVHlwZT46Om1f b3V0T2ZSYW5nZUVudW1WYWx1ZSA9IDA7CisKIH0KIAogI2VuZGlmIC8vIFNWR0FuaW1hdGVkRW51 bWVyYXRpb25Qcm9wZXJ0eVRlYXJPZmZfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3Zn L3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaCBiL1NvdXJjZS9X ZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR0FuaW1hdGVkU3RhdGljUHJvcGVydHlUZWFyT2ZmLmgK aW5kZXggNzdmNmU0OTE3MzM2NGMxMGJjZmY5ODM4MWQ5NGUyYTA4ZWNmNDExZS4uOWVjZjQ0Yzc3 M2RjNTBjNWU1MmIwYTk2OGQ4NGI3ZDRhNmQzMmYwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvc3ZnL3Byb3BlcnRpZXMvU1ZHQW5pbWF0ZWRTdGF0aWNQcm9wZXJ0eVRlYXJPZmYuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdBbmltYXRlZFN0YXRpY1Byb3BlcnR5 VGVhck9mZi5oCkBAIC0zMCwxMiArMzAsMTIgQEAgY2xhc3MgU1ZHQW5pbWF0ZWRTdGF0aWNQcm9w ZXJ0eVRlYXJPZmYgOiBwdWJsaWMgU1ZHQW5pbWF0ZWRQcm9wZXJ0eSB7CiBwdWJsaWM6CiAgICAg dHlwZWRlZiBQcm9wZXJ0eVR5cGUgQ29udGVudFR5cGU7CiAKLSAgICBQcm9wZXJ0eVR5cGUmIGJh c2VWYWwoKQorICAgIHZpcnR1YWwgUHJvcGVydHlUeXBlJiBiYXNlVmFsKCkKICAgICB7CiAgICAg ICAgIHJldHVybiBtX3Byb3BlcnR5OwogICAgIH0KIAotICAgIFByb3BlcnR5VHlwZSYgYW5pbVZh bCgpCisgICAgdmlydHVhbCBQcm9wZXJ0eVR5cGUmIGFuaW1WYWwoKQogICAgIHsKICAgICAgICAg aWYgKG1fYW5pbWF0ZWRQcm9wZXJ0eSkKICAgICAgICAgICAgIHJldHVybiAqbV9hbmltYXRlZFBy b3BlcnR5OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHUHJv cGVydHlUcmFpdHMuaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9wcm9wZXJ0aWVzL1NWR1Byb3BlcnR5 VHJhaXRzLmgKaW5kZXggZGE3NTdlYjcxNzI1YmQyM2VhNmQ2M2E0N2ZjYzE0YmZmYWE1MzIwYS4u NjRlYTliODRmZGQyMzk4NTczYzAxZDA5NjBjYmU2NDk4ZjdhZjVmZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvc3ZnL3Byb3BlcnRpZXMvU1ZHUHJvcGVydHlUcmFpdHMuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9zdmcvcHJvcGVydGllcy9TVkdQcm9wZXJ0eVRyYWl0cy5oCkBAIC01OCw2ICs1 OCwxMiBAQCBzdHJ1Y3QgU1ZHUHJvcGVydHlUcmFpdHM8U3RyaW5nPiB7CiAgICAgc3RhdGljIFN0 cmluZyB0b1N0cmluZyhjb25zdCBTdHJpbmcmIHR5cGUpIHsgcmV0dXJuIHR5cGU7IH0KIH07CiAK K3RlbXBsYXRlPHR5cGVuYW1lIEVudW1UeXBlPgorc3RydWN0IFNWR0lETEVudW1MaW1pdHMgewor ICAgIC8vIFNwZWNpYWxpemUgdGhpcyBmdW5jdGlvbiBmb3IgYSBwYXJ0aWN1bGFyIGVudW1lcmF0 aW9uIHRvIGxpbWl0IHRoZSB2YWx1ZXMgdGhhdCBhcmUgZXhwb3NlZCB0aHJvdWdoIHRoZSBET00u CisgICAgc3RhdGljIHVuc2lnbmVkIGhpZ2hlc3RFeHBvc2VkRW51bVZhbHVlKCkgeyByZXR1cm4g U1ZHUHJvcGVydHlUcmFpdHM8RW51bVR5cGU+OjpoaWdoZXN0RW51bVZhbHVlKCk7IH0KK307CisK IH0KIAogI2VuZGlmCg==