211695 2020-05-10 03:48:24 -0700 [Web Animations] Refactor animation comparison by composite order in a single utility function 2020-05-11 02:15:17 -0700 1 1 1 Unclassified WebKit Animations WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 211697 1 graouts graouts cdumez darin dino esprehn+autocc ews-watchlist graouts kangil.han webkit-bug-importer oldest_to_newest 1651080 0 graouts 2020-05-10 03:48:24 -0700 [Web Animations] Refactor animation comparison by composite order in a single utility function 1651081 1 398972 graouts 2020-05-10 03:56:25 -0700 Created attachment 398972 Patch 1651134 2 398972 darin 2020-05-10 16:07:47 -0700 Comment on attachment 398972 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=398972&action=review One problem here is that functions named "compare" functions aren’t obviously C++ standard library "operator<" functions. There’s another tradition of compare based on the C standard library that uses int and -1/0/1. I think the names probably need something to make it clear that it's the "<" style. I worry they will make it a bit inelegant. I mention some style issues, but also some actual mistakes that I think you should consider fixing. > Source/WebCore/animation/WebAnimationUtilities.cpp:41 > +inline bool compareDeclarativeAnimationOwningElementPositionsInDocumentTreeOrder(Element* lhsOwningElement, Element* rhsOwningElement) I think this code is easier to read with "a" and "b". Our rule against abbreviations doesn’t have an exception for "lhs" and "rhs" and so long as we are abbreviating, we should use something easy to see, rather than something with so many repeated identical letters. In fact, I don’t even know if I would use the words "owning element", just "a" and "b", given the context of the function. There’s no need to mark this inline. The compiler will make a good decision about inlining either way. So "inline" basically means "hope it’s OK I put this in the header file". Here we should use just "static". In fact, even if we were using "inline" we’d still also want to use "static" to give these internal linkage. > Source/WebCore/animation/WebAnimationUtilities.cpp:47 > + // With regard to pseudo-elements, the sort order is as follows: > + // - element > + // - ::before > + // - ::after > + // - element children Another way to implement this that could be a little easier to get right is to add an integer for sorting elements and pseudo elements, call it the typeIndex: Set it to 0 for an element and set the referenceElement to the element. Set it to 1 for the before element and set the referenceElement to the hostElement. Set it to 2 for the before element and set the referenceElement to the hostElement. Then, after computing that for both a and b, we just write: if (aReferenceElement == bReferenceElement) return aTypeIndex < bTypeIndex; return isBefore(aReferenceElement, bReferenceElement)); What’s nice about this is that we don’t have to write repeated, similar but slightly different, code for the before and after elements. > Source/WebCore/animation/WebAnimationUtilities.cpp:54 > + if (lhsPseudoElement->hostElement() == rhsPseudoElement->hostElement()) > + return lhsPseudoElement->isBeforePseudoElement(); I think that this function should correctly return *false* when both elements are the same, even if the element is a before pseudo element, so I suggest adding that check somewhere. > Source/WebCore/animation/WebAnimationUtilities.cpp:58 > + // Or comparing a pseudo-element that is compared to another non-pseudo element, in which case > + // we want to see if it's hosted on that other element, and if not use its host element to compare. This comment says we are comparing to a non-pseudo element, but that’s too specific. This is used any time the two elements are not comparing to the sam host. > Source/WebCore/animation/WebAnimationUtilities.cpp:60 > + auto* lhsHostElement = downcast<PseudoElement>(lhsOwningElement)->hostElement(); Do we have a strong guarantee that we will never be passed a pseudo element with a host element of null? > Source/WebCore/animation/WebAnimationUtilities.cpp:76 > +inline bool compareCSSTransitions(const CSSTransition& lhsTransition, const CSSTransition& rhsTransition) Same thoughts about "a" and "b" and inline. > Source/WebCore/animation/WebAnimationUtilities.cpp:79 > + auto* lhsOwningElement = lhsTransition.owningElement(); > + auto* rhsOwningElement = rhsTransition.owningElement(); Are these possibly null or guaranteed non-null? If guaranteed non-null, please use references. If possibly null, then compareDeclarativeAnimationOwningElementPositionsInDocumentTreeOrder has a null dereference error where it calls compareDocumentPosition without checking for null. > Source/WebCore/animation/WebAnimationUtilities.cpp:94 > +inline bool compareCSSAnimations(const CSSAnimation& lhs, const CSSAnimation& rhs) Same thoughts about "a" and "b" and inline. > Source/WebCore/animation/WebAnimationUtilities.cpp:98 > + auto* lhsOwningElement = lhs.owningElement(); > + auto* rhsOwningElement = rhs.owningElement(); Same thoughts about null. > Source/WebCore/animation/WebAnimationUtilities.cpp:105 > + auto* cssAnimationList = lhsOwningElement->ensureKeyframeEffectStack().cssAnimationList(); If this can’t be null, then it should return a reference. > Source/WebCore/animation/WebAnimationUtilities.cpp:114 > + if (animation == lhsBackingAnimation) > + return true; This does the wrong thing if both lhsBackingAnimation == rhsBackingAnimation. We need to return false in that case. One way to fix that is to do the check for rhsBackingAnimation first. Another is to check for == before this function. Of course if this can never happen then my comment is silly, but also we could assert they are not the same. If so, then guarantees we aren’t ever passed the same CSSAnimation for both a and b. 1651213 3 graouts 2020-05-11 02:05:23 -0700 (In reply to Darin Adler from comment #2) > Comment on attachment 398972 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=398972&action=review > > One problem here is that functions named "compare" functions aren’t > obviously C++ standard library "operator<" functions. There’s another > tradition of compare based on the C standard library that uses int and > -1/0/1. I think the names probably need something to make it clear that it's > the "<" style. I worry they will make it a bit inelegant. > > I mention some style issues, but also some actual mistakes that I think you > should consider fixing. > > > Source/WebCore/animation/WebAnimationUtilities.cpp:41 > > +inline bool compareDeclarativeAnimationOwningElementPositionsInDocumentTreeOrder(Element* lhsOwningElement, Element* rhsOwningElement) > > I think this code is easier to read with "a" and "b". Our rule against > abbreviations doesn’t have an exception for "lhs" and "rhs" and so long as > we are abbreviating, we should use something easy to see, rather than > something with so many repeated identical letters. In fact, I don’t even > know if I would use the words "owning element", just "a" and "b", given the > context of the function. I'll rename the parameters to all the functions to just `a` and `b`. > There’s no need to mark this inline. The compiler will make a good decision > about inlining either way. So "inline" basically means "hope it’s OK I put > this in the header file". Here we should use just "static". In fact, even if > we were using "inline" we’d still also want to use "static" to give these > internal linkage. Cool! I'll remove `inline`. > > Source/WebCore/animation/WebAnimationUtilities.cpp:47 > > + // With regard to pseudo-elements, the sort order is as follows: > > + // - element > > + // - ::before > > + // - ::after > > + // - element children > > Another way to implement this that could be a little easier to get right is > to add an integer for sorting elements and pseudo elements, call it the > typeIndex: > > Set it to 0 for an element and set the referenceElement to the element. > Set it to 1 for the before element and set the referenceElement to the > hostElement. > Set it to 2 for the before element and set the referenceElement to the > hostElement. > > Then, after computing that for both a and b, we just write: > > if (aReferenceElement == bReferenceElement) > return aTypeIndex < bTypeIndex; > return isBefore(aReferenceElement, bReferenceElement)); > > What’s nice about this is that we don’t have to write repeated, similar but > slightly different, code for the before and after elements. Sounds good, will rewrite using this approach. > > Source/WebCore/animation/WebAnimationUtilities.cpp:54 > > + if (lhsPseudoElement->hostElement() == rhsPseudoElement->hostElement()) > > + return lhsPseudoElement->isBeforePseudoElement(); > > I think that this function should correctly return *false* when both > elements are the same, even if the element is a before pseudo element, so I > suggest adding that check somewhere. You mean if both a and b are equal (and not their host elements in case they're both pseudos)? That case can't happen as it stands because the only call sites have a check to prevent this. In those cases, the compare function wouldn't be consistent anymore. I'll add a RELEASE_ASSERT() that the function is never called with a == b, just like we do for compareAnimationsByCompositeOrder(). > > Source/WebCore/animation/WebAnimationUtilities.cpp:58 > > + // Or comparing a pseudo-element that is compared to another non-pseudo element, in which case > > + // we want to see if it's hosted on that other element, and if not use its host element to compare. > > This comment says we are comparing to a non-pseudo element, but that’s too > specific. This is used any time the two elements are not comparing to the > sam host. > > > Source/WebCore/animation/WebAnimationUtilities.cpp:60 > > + auto* lhsHostElement = downcast<PseudoElement>(lhsOwningElement)->hostElement(); > > Do we have a strong guarantee that we will never be passed a pseudo element > with a host element of null? Not within the function itself, only through usage. We only ever sort animations that are "relevant", ie. they're not idle. A CSS-originated animation would be idle as soon as its target is no longer connected to the DOM, and this comparison function is only ever used for CSS-originated animations. I can add an ASSERT for this case. > > Source/WebCore/animation/WebAnimationUtilities.cpp:76 > > +inline bool compareCSSTransitions(const CSSTransition& lhsTransition, const CSSTransition& rhsTransition) > > Same thoughts about "a" and "b" and inline. > > > Source/WebCore/animation/WebAnimationUtilities.cpp:79 > > + auto* lhsOwningElement = lhsTransition.owningElement(); > > + auto* rhsOwningElement = rhsTransition.owningElement(); > > Are these possibly null or guaranteed non-null? If guaranteed non-null, > please use references. If possibly null, then > compareDeclarativeAnimationOwningElementPositionsInDocumentTreeOrder has a > null dereference error where it calls compareDocumentPosition without > checking for null. They are guaranteed non-null from the call site, so I'll add an ASSERT() and use references. > > Source/WebCore/animation/WebAnimationUtilities.cpp:94 > > +inline bool compareCSSAnimations(const CSSAnimation& lhs, const CSSAnimation& rhs) > > Same thoughts about "a" and "b" and inline. > > > Source/WebCore/animation/WebAnimationUtilities.cpp:98 > > + auto* lhsOwningElement = lhs.owningElement(); > > + auto* rhsOwningElement = rhs.owningElement(); > > Same thoughts about null. > > > Source/WebCore/animation/WebAnimationUtilities.cpp:105 > > + auto* cssAnimationList = lhsOwningElement->ensureKeyframeEffectStack().cssAnimationList(); > > If this can’t be null, then it should return a reference. That method can definitely return null in case there are no CSS Animations in a keyframe effect stack. However, it should definitely not return null if there is a CSSAnimation with an owning element, hence the ASSERT() right after that call in this context. > > Source/WebCore/animation/WebAnimationUtilities.cpp:114 > > + if (animation == lhsBackingAnimation) > > + return true; > > This does the wrong thing if both lhsBackingAnimation == > rhsBackingAnimation. We need to return false in that case. One way to fix > that is to do the check for rhsBackingAnimation first. Another is to check > for == before this function. Of course if this can never happen then my > comment is silly, but also we could assert they are not the same. If so, > then guarantees we aren’t ever passed the same CSSAnimation for both a and b. lhsBackingAnimation and rhsBackingAnimation cannot be the same. This is because one given Animation object can only be associated with one DeclarativeAnimation at any given time, and we have an assertion first thing in this function that checks that lhs and rhs (now a and b) are not the same. 1651214 4 graouts 2020-05-11 02:14:45 -0700 Committed r261470: <https://trac.webkit.org/changeset/261470> 1651215 5 webkit-bug-importer 2020-05-11 02:15:17 -0700 <rdar://problem/63081540> 398972 2020-05-10 03:56:25 -0700 2020-05-10 16:07:47 -0700 Patch bug-211695-20200510125623.patch text/plain 23153 graouts U3VidmVyc2lvbiBSZXZpc2lvbjogMjYxMzcyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmEwMGE5ZTQ3ZDYwZDUx YjY5OWVkMTk0N2ZhMjkwYmM0ZmM0OTAzMy4uZTBlZDU4MjQyNjg0ZWQ5NjYwNTU3NDJlYTA0YjNi ZTNhZGUzMDQwYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ0IEBACisyMDIwLTA1LTEwICBBbnRv aW5lIFF1aW50ICA8Z3Jhb3V0c0BhcHBsZS5jb20+CisKKyAgICAgICAgW1dlYiBBbmltYXRpb25z XSBSZWZhY3RvciBhbmltYXRpb24gY29tcGFyaXNvbiBieSBjb21wb3NpdGUgb3JkZXIgaW4gYSBz aW5nbGUgdXRpbGl0eSBmdW5jdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjExNjk1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgV2UgdXNlZCB0byBzcGxpdCBzb3J0aW5nIG9mIGFuaW1hdGlvbnMgYnkg Y29tcG9zaXRlIG9yZGVyIGFjcm9zcyBzZXZlcmFsIGZ1bmN0aW9ucyBhbmQgZmlsZXMuIFNwZWNp ZmljYWxseSwKKyAgICAgICAgRG9jdW1lbnRUaW1lbGluZTo6Z2V0QW5pbWF0aW9ucygpIHdvdWxk IGZpcnN0IGNvbGxlY3QgYW5pbWF0aW9ucyBieSBjbGFzcyAoQ1NTIFRyYW5zaXRpb25zLCB0aGVu IENTUworICAgICAgICBBbmltYXRpb25zLCB0aGVuIEpTLW9yaWdpbmF0ZWQgYW5pbWF0aW9ucyks IGFuZCB0aGVuIHNvcnQgZWFjaCBjbGFzcywgY2FsbGluZyBpbnRvIHRoZSBzdGF0aWMgZnVuY3Rp b24KKyAgICAgICAgY29tcGFyZURlY2xhcmF0aXZlQW5pbWF0aW9uT3duaW5nRWxlbWVudFBvc2l0 aW9uc0luRG9jdW1lbnRUcmVlT3JkZXIoKSBpbiBzb21lIGNhc2VzIGFuZCBpbnRvIHRoZQorICAg ICAgICBXZWJBbmltYXRpb25VdGlsaXRpZXMgY29tcGFyZUFuaW1hdGlvbnNCeUNvbXBvc2l0ZU9y ZGVyKCkgZnVuY3Rpb24gaW4gb3RoZXIuCisKKyAgICAgICAgU2luY2Ugd2UgbmVlZCB0byBiZSBh YmxlIHRvIHNvcnQgYW5pbWF0aW9ucyBieSBjb21wb3NpdGUgb3JkZXIgaW4gb3RoZXIgc2l0dWF0 aW9ucywgZm9yIGluc3RhbmNlIHdoZW4gc29ydGluZworICAgICAgICBldmVudHMgd2hlbiB1cGRh dGluZyBhbmltYXRpb25zIGFuZCBzZW5kaW5nIGV2ZW50cyAod2hpY2ggd2Ugd2lsbCBkbyBpbiBh IGZ1dHVyZSBwYXRjaCksIHdlIHJlZmFjdG9yIGFsbAorICAgICAgICBvZiB0aGUgY29tcGFyaXNv biBsb2dpYyBpbnRvIGNvbXBhcmVBbmltYXRpb25zQnlDb21wb3NpdGVPcmRlcigpLCByZW1vdmlu ZyB0aGUgbmVlZCB0byBwcm92aWRlIGFuIEFuaW1hdGlvbkxpc3QsCisgICAgICAgIHdoaWNoIGlz IHNwZWNpZmljIHRvIHRoZSBjYXNlIHdoZXJlIHdlIGtub3cgd2UgYXJlIGNvbXBhcmluZyBDU1NB bmltYXRpb24gb2JqZWN0cyB0YXJnZXRpbmcgYSBzaGFyZWQgZWxlbWVudC4KKworICAgICAgICBU aGlzIGVmZmVjdGl2ZWx5IGVtcHRpZXMgRG9jdW1lbnRUaW1lbGluZTo6Z2V0QW5pbWF0aW9ucygp IHNvIHdlIHJlbW92ZSB0aGlzIGZ1bmN0aW9uIGFuZCBmaWx0ZXIgcmVsZXZhbnQKKyAgICAgICAg YW5pbWF0aW9ucyBpbiBEb2N1bWVudDo6bWF0Y2hpbmdBbmltYXRpb25zKCkgYW5kIGNhbGwgY29t cGFyZUFuaW1hdGlvbnNCeUNvbXBvc2l0ZU9yZGVyKCkgYmVmb3JlIHJldHVybmluZworICAgICAg ICB0aGUgY29tcGlsZWQgYW5pbWF0aW9ucy4KKworICAgICAgICBObyBuZXcgdGVzdHMgc2luY2Ug dGhlcmUgaXMgbm8gY2hhbmdlIG9mIGJlaGF2aW9yLgorCisgICAgICAgICogYW5pbWF0aW9uL0Rv Y3VtZW50VGltZWxpbmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y29tcGFyZURlY2xhcmF0aXZl QW5pbWF0aW9uT3duaW5nRWxlbWVudFBvc2l0aW9uc0luRG9jdW1lbnRUcmVlT3JkZXIpOiBEZWxl dGVkLgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRUaW1lbGluZTo6Z2V0QW5pbWF0aW9ucyBj b25zdCk6IERlbGV0ZWQuCisgICAgICAgICogYW5pbWF0aW9uL0RvY3VtZW50VGltZWxpbmUuaDoK KyAgICAgICAgKiBhbmltYXRpb24vS2V5ZnJhbWVFZmZlY3RTdGFjay5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpLZXlmcmFtZUVmZmVjdFN0YWNrOjplbnN1cmVFZmZlY3RzQXJlU29ydGVkKToKKyAg ICAgICAgKiBhbmltYXRpb24vV2ViQW5pbWF0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Oldl YkFuaW1hdGlvbjo6Y29tbWl0U3R5bGVzKToKKyAgICAgICAgKiBhbmltYXRpb24vV2ViQW5pbWF0 aW9uVXRpbGl0aWVzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmNvbXBhcmVEZWNsYXJhdGl2ZUFu aW1hdGlvbk93bmluZ0VsZW1lbnRQb3NpdGlvbnNJbkRvY3VtZW50VHJlZU9yZGVyKToKKyAgICAg ICAgKFdlYkNvcmU6OmNvbXBhcmVDU1NUcmFuc2l0aW9ucyk6CisgICAgICAgIChXZWJDb3JlOjpj b21wYXJlQ1NTQW5pbWF0aW9ucyk6CisgICAgICAgIChXZWJDb3JlOjpjb21wYXJlQW5pbWF0aW9u c0J5Q29tcG9zaXRlT3JkZXIpOgorICAgICAgICAqIGFuaW1hdGlvbi9XZWJBbmltYXRpb25VdGls aXRpZXMuaDoKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 RG9jdW1lbnQ6Om1hdGNoaW5nQW5pbWF0aW9ucyk6CisKIDIwMjAtMDUtMDcgIFNpbW9uIEZyYXNl ciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAgICAgTWF5QmVnaW4gd2hlZWwgZXZl bnQgaW4gYSA8c2VsZWN0PiBkb2Vzbid0IGZsYXNoIHRoZSBzY3JvbGxlcnMKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2FuaW1hdGlvbi9Eb2N1bWVudFRpbWVsaW5lLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL2FuaW1hdGlvbi9Eb2N1bWVudFRpbWVsaW5lLmNwcAppbmRleCBlNDhlMGY2NzE5YmJm ZWMzMzcwMDEyMDZjMDQ0NDJkNzZiMjYwZTA3Li42NDIwYzhmY2UwMmFmNzFkMTBhZGVhNTQ0MTFk Njg3N2IxNmQyMGE1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vRG9jdW1l bnRUaW1lbGluZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL0RvY3VtZW50VGlt ZWxpbmUuY3BwCkBAIC0yNyw3ICsyNyw2IEBACiAjaW5jbHVkZSAiRG9jdW1lbnRUaW1lbGluZS5o IgogCiAjaW5jbHVkZSAiQW5pbWF0aW9uRXZlbnRCYXNlLmgiCi0jaW5jbHVkZSAiQ1NTQW5pbWF0 aW9uLmgiCiAjaW5jbHVkZSAiQ1NTVHJhbnNpdGlvbi5oIgogI2luY2x1ZGUgIkRlY2xhcmF0aXZl QW5pbWF0aW9uLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKQEAgLTM4LDcgKzM3LDYgQEAKICNp bmNsdWRlICJLZXlmcmFtZUVmZmVjdFN0YWNrLmgiCiAjaW5jbHVkZSAiTm9kZS5oIgogI2luY2x1 ZGUgIlBhZ2UuaCIKLSNpbmNsdWRlICJQc2V1ZG9FbGVtZW50LmgiCiAjaW5jbHVkZSAiUmVuZGVy RWxlbWVudC5oIgogI2luY2x1ZGUgIlJlbmRlckxheWVyLmgiCiAjaW5jbHVkZSAiUmVuZGVyTGF5 ZXJCYWNraW5nLmgiCkBAIC0xMDAsMTE0ICs5OCw2IEBAIHZvaWQgRG9jdW1lbnRUaW1lbGluZTo6 ZGV0YWNoRnJvbURvY3VtZW50KCkKICAgICBtX2RvY3VtZW50ID0gbnVsbHB0cjsKIH0KIAotc3Rh dGljIGlubGluZSBib29sIGNvbXBhcmVEZWNsYXJhdGl2ZUFuaW1hdGlvbk93bmluZ0VsZW1lbnRQ b3NpdGlvbnNJbkRvY3VtZW50VHJlZU9yZGVyKEVsZW1lbnQqIGxoc093bmluZ0VsZW1lbnQsIEVs ZW1lbnQqIHJoc093bmluZ0VsZW1lbnQpCi17Ci0gICAgLy8gV2l0aCByZWdhcmQgdG8gcHNldWRv LWVsZW1lbnRzLCB0aGUgc29ydCBvcmRlciBpcyBhcyBmb2xsb3dzOgotICAgIC8vICAgICAtIGVs ZW1lbnQKLSAgICAvLyAgICAgLSA6OmJlZm9yZQotICAgIC8vICAgICAtIDo6YWZ0ZXIKLSAgICAv LyAgICAgLSBlbGVtZW50IGNoaWxkcmVuCi0gICAgCi0gICAgLy8gV2UgY291bGQgYmUgY29tcGFy aW5nIHR3byBwc2V1ZG8tZWxlbWVudHMgdGhhdCBhcmUgaG9zdGVkIG9uIHRoZSBzYW1lIGVsZW1l bnQuCi0gICAgaWYgKGlzPFBzZXVkb0VsZW1lbnQ+KGxoc093bmluZ0VsZW1lbnQpICYmIGlzPFBz ZXVkb0VsZW1lbnQ+KHJoc093bmluZ0VsZW1lbnQpKSB7Ci0gICAgICAgIGF1dG8qIGxoc1BzZXVk b0VsZW1lbnQgPSBkb3duY2FzdDxQc2V1ZG9FbGVtZW50PihsaHNPd25pbmdFbGVtZW50KTsKLSAg ICAgICAgYXV0byogcmhzUHNldWRvRWxlbWVudCA9IGRvd25jYXN0PFBzZXVkb0VsZW1lbnQ+KHJo c093bmluZ0VsZW1lbnQpOwotICAgICAgICBpZiAobGhzUHNldWRvRWxlbWVudC0+aG9zdEVsZW1l bnQoKSA9PSByaHNQc2V1ZG9FbGVtZW50LT5ob3N0RWxlbWVudCgpKQotICAgICAgICAgICAgcmV0 dXJuIGxoc1BzZXVkb0VsZW1lbnQtPmlzQmVmb3JlUHNldWRvRWxlbWVudCgpOwotICAgIH0KLQot ICAgIC8vIE9yIGNvbXBhcmluZyBhIHBzZXVkby1lbGVtZW50IHRoYXQgaXMgY29tcGFyZWQgdG8g YW5vdGhlciBub24tcHNldWRvIGVsZW1lbnQsIGluIHdoaWNoIGNhc2UKLSAgICAvLyB3ZSB3YW50 IHRvIHNlZSBpZiBpdCdzIGhvc3RlZCBvbiB0aGF0IG90aGVyIGVsZW1lbnQsIGFuZCBpZiBub3Qg dXNlIGl0cyBob3N0IGVsZW1lbnQgdG8gY29tcGFyZS4KLSAgICBpZiAoaXM8UHNldWRvRWxlbWVu dD4obGhzT3duaW5nRWxlbWVudCkpIHsKLSAgICAgICAgYXV0byogbGhzSG9zdEVsZW1lbnQgPSBk b3duY2FzdDxQc2V1ZG9FbGVtZW50PihsaHNPd25pbmdFbGVtZW50KS0+aG9zdEVsZW1lbnQoKTsK LSAgICAgICAgaWYgKHJoc093bmluZ0VsZW1lbnQgPT0gbGhzSG9zdEVsZW1lbnQpCi0gICAgICAg ICAgICByZXR1cm4gZmFsc2U7Ci0gICAgICAgIGxoc093bmluZ0VsZW1lbnQgPSBsaHNIb3N0RWxl bWVudDsKLSAgICB9Ci0KLSAgICBpZiAoaXM8UHNldWRvRWxlbWVudD4ocmhzT3duaW5nRWxlbWVu dCkpIHsKLSAgICAgICAgYXV0byogcmhzSG9zdEVsZW1lbnQgPSBkb3duY2FzdDxQc2V1ZG9FbGVt ZW50PihyaHNPd25pbmdFbGVtZW50KS0+aG9zdEVsZW1lbnQoKTsKLSAgICAgICAgaWYgKGxoc093 bmluZ0VsZW1lbnQgPT0gcmhzSG9zdEVsZW1lbnQpCi0gICAgICAgICAgICByZXR1cm4gdHJ1ZTsK LSAgICAgICAgcmhzT3duaW5nRWxlbWVudCA9IHJoc0hvc3RFbGVtZW50OwotICAgIH0KLQotICAg IHJldHVybiBsaHNPd25pbmdFbGVtZW50LT5jb21wYXJlRG9jdW1lbnRQb3NpdGlvbigqcmhzT3du aW5nRWxlbWVudCkgJiBOb2RlOjpET0NVTUVOVF9QT1NJVElPTl9GT0xMT1dJTkc7Ci19Ci0KLVZl Y3RvcjxSZWZQdHI8V2ViQW5pbWF0aW9uPj4gRG9jdW1lbnRUaW1lbGluZTo6Z2V0QW5pbWF0aW9u cygpIGNvbnN0Ci17Ci0gICAgQVNTRVJUKG1fZG9jdW1lbnQpOwotCi0gICAgVmVjdG9yPFJlZlB0 cjxXZWJBbmltYXRpb24+PiBjc3NUcmFuc2l0aW9uczsKLSAgICBWZWN0b3I8UmVmUHRyPFdlYkFu aW1hdGlvbj4+IGNzc0FuaW1hdGlvbnM7Ci0gICAgVmVjdG9yPFJlZlB0cjxXZWJBbmltYXRpb24+ PiB3ZWJBbmltYXRpb25zOwotCi0gICAgLy8gRmlyc3QsIGxldCdzIGdldCBhbGwgcXVhbGlmeWlu ZyBhbmltYXRpb25zIGluIHRoZWlyIHJpZ2h0IGdyb3VwLgotICAgIGZvciAoY29uc3QgYXV0byYg YW5pbWF0aW9uIDogbV9hbmltYXRpb25zKSB7Ci0gICAgICAgIGlmICghYW5pbWF0aW9uIHx8ICFh bmltYXRpb24tPmlzUmVsZXZhbnQoKSB8fCBhbmltYXRpb24tPnRpbWVsaW5lKCkgIT0gdGhpcyB8 fCAhaXM8S2V5ZnJhbWVFZmZlY3Q+KGFuaW1hdGlvbi0+ZWZmZWN0KCkpKQotICAgICAgICAgICAg Y29udGludWU7Ci0KLSAgICAgICAgYXV0byogdGFyZ2V0ID0gZG93bmNhc3Q8S2V5ZnJhbWVFZmZl Y3Q+KGFuaW1hdGlvbi0+ZWZmZWN0KCkpLT50YXJnZXQoKTsKLSAgICAgICAgaWYgKCF0YXJnZXQg fHwgIXRhcmdldC0+aXNEZXNjZW5kYW50T2YoKm1fZG9jdW1lbnQpKQotICAgICAgICAgICAgY29u dGludWU7Ci0KLSAgICAgICAgaWYgKGlzPENTU1RyYW5zaXRpb24+KGFuaW1hdGlvbi5nZXQoKSkg JiYgZG93bmNhc3Q8Q1NTVHJhbnNpdGlvbj4oYW5pbWF0aW9uLmdldCgpKS0+b3duaW5nRWxlbWVu dCgpKQotICAgICAgICAgICAgY3NzVHJhbnNpdGlvbnMuYXBwZW5kKGFuaW1hdGlvbik7Ci0gICAg ICAgIGVsc2UgaWYgKGlzPENTU0FuaW1hdGlvbj4oYW5pbWF0aW9uLmdldCgpKSAmJiBkb3duY2Fz dDxDU1NBbmltYXRpb24+KGFuaW1hdGlvbi5nZXQoKSktPm93bmluZ0VsZW1lbnQoKSkKLSAgICAg ICAgICAgIGNzc0FuaW1hdGlvbnMuYXBwZW5kKGFuaW1hdGlvbik7Ci0gICAgICAgIGVsc2UKLSAg ICAgICAgICAgIHdlYkFuaW1hdGlvbnMuYXBwZW5kKGFuaW1hdGlvbik7Ci0gICAgfQotCi0gICAg Ly8gTm93IHNvcnQgQ1NTIFRyYW5zaXRpb25zIGJ5IHRoZWlyIGNvbXBvc2l0ZSBvcmRlci4KLSAg ICBzdGQ6OnN0YWJsZV9zb3J0KGNzc1RyYW5zaXRpb25zLmJlZ2luKCksIGNzc1RyYW5zaXRpb25z LmVuZCgpLCBbXShhdXRvJiBsaHMsIGF1dG8mIHJocykgewotICAgICAgICAvLyBodHRwczovL2Ry YWZ0cy5jc3N3Zy5vcmcvY3NzLXRyYW5zaXRpb25zLTIvI2FuaW1hdGlvbi1jb21wb3NpdGUtb3Jk ZXIKLSAgICAgICAgYXV0byogbGhzVHJhbnNpdGlvbiA9IGRvd25jYXN0PENTU1RyYW5zaXRpb24+ KGxocy5nZXQoKSk7Ci0gICAgICAgIGF1dG8qIHJoc1RyYW5zaXRpb24gPSBkb3duY2FzdDxDU1NU cmFuc2l0aW9uPihyaHMuZ2V0KCkpOwotCi0gICAgICAgIGF1dG8qIGxoc093bmluZ0VsZW1lbnQg PSBsaHNUcmFuc2l0aW9uLT5vd25pbmdFbGVtZW50KCk7Ci0gICAgICAgIGF1dG8qIHJoc093bmlu Z0VsZW1lbnQgPSByaHNUcmFuc2l0aW9uLT5vd25pbmdFbGVtZW50KCk7Ci0KLSAgICAgICAgLy8g SWYgdGhlIG93bmluZyBlbGVtZW50IG9mIEEgYW5kIEIgZGlmZmVycywgc29ydCBBIGFuZCBCIGJ5 IHRyZWUgb3JkZXIgb2YgdGhlaXIgY29ycmVzcG9uZGluZyBvd25pbmcgZWxlbWVudHMuCi0gICAg ICAgIGlmIChsaHNPd25pbmdFbGVtZW50ICE9IHJoc093bmluZ0VsZW1lbnQpCi0gICAgICAgICAg ICByZXR1cm4gY29tcGFyZURlY2xhcmF0aXZlQW5pbWF0aW9uT3duaW5nRWxlbWVudFBvc2l0aW9u c0luRG9jdW1lbnRUcmVlT3JkZXIobGhzT3duaW5nRWxlbWVudCwgcmhzT3duaW5nRWxlbWVudCk7 Ci0KLSAgICAgICAgLy8gT3RoZXJ3aXNlLCBpZiBBIGFuZCBCIGhhdmUgZGlmZmVyZW50IHRyYW5z aXRpb24gZ2VuZXJhdGlvbiB2YWx1ZXMsIHNvcnQgYnkgdGhlaXIgY29ycmVzcG9uZGluZyB0cmFu c2l0aW9uIGdlbmVyYXRpb24gaW4gYXNjZW5kaW5nIG9yZGVyLgotICAgICAgICBpZiAobGhzVHJh bnNpdGlvbi0+Z2VuZXJhdGlvblRpbWUoKSAhPSByaHNUcmFuc2l0aW9uLT5nZW5lcmF0aW9uVGlt ZSgpKQotICAgICAgICAgICAgcmV0dXJuIGxoc1RyYW5zaXRpb24tPmdlbmVyYXRpb25UaW1lKCkg PCByaHNUcmFuc2l0aW9uLT5nZW5lcmF0aW9uVGltZSgpOwotCi0gICAgICAgIC8vIE90aGVyd2lz ZSwgc29ydCBBIGFuZCBCIGluIGFzY2VuZGluZyBvcmRlciBieSB0aGUgVW5pY29kZSBjb2RlcG9p bnRzIHRoYXQgbWFrZSB1cCB0aGUgZXhwYW5kZWQgdHJhbnNpdGlvbiBwcm9wZXJ0eSBuYW1lIG9m IGVhY2ggdHJhbnNpdGlvbgotICAgICAgICAvLyAoaS5lLiB3aXRob3V0IGF0dGVtcHRpbmcgY2Fz ZSBjb252ZXJzaW9uIGFuZCBzdWNoIHRoYXQg4oCYLW1vei1jb2x1bW4td2lkdGjigJkgc29ydHMg YmVmb3JlIOKAmGNvbHVtbi13aWR0aOKAmSkuCi0gICAgICAgIHJldHVybiBsaHNUcmFuc2l0aW9u LT50cmFuc2l0aW9uUHJvcGVydHkoKS51dGY4KCkgPCByaHNUcmFuc2l0aW9uLT50cmFuc2l0aW9u UHJvcGVydHkoKS51dGY4KCk7Ci0gICAgfSk7Ci0KLSAgICAvLyBOb3cgc29ydCBDU1MgQW5pbWF0 aW9ucyBieSB0aGVpciBjb21wb3NpdGUgb3JkZXIuCi0gICAgc3RkOjpzdGFibGVfc29ydChjc3NB bmltYXRpb25zLmJlZ2luKCksIGNzc0FuaW1hdGlvbnMuZW5kKCksIFtdKGF1dG8mIGxocywgYXV0 byYgcmhzKSB7Ci0gICAgICAgIC8vIGh0dHBzOi8vZHJhZnRzLmNzc3dnLm9yZy9jc3MtYW5pbWF0 aW9ucy0yLyNhbmltYXRpb24tY29tcG9zaXRlLW9yZGVyCi0gICAgICAgIGF1dG8qIGxoc093bmlu Z0VsZW1lbnQgPSBkb3duY2FzdDxDU1NBbmltYXRpb24+KGxocy5nZXQoKSktPm93bmluZ0VsZW1l bnQoKTsKLSAgICAgICAgYXV0byogcmhzT3duaW5nRWxlbWVudCA9IGRvd25jYXN0PENTU0FuaW1h dGlvbj4ocmhzLmdldCgpKS0+b3duaW5nRWxlbWVudCgpOwotCi0gICAgICAgIC8vIElmIHRoZSBv d25pbmcgZWxlbWVudCBvZiBBIGFuZCBCIGRpZmZlcnMsIHNvcnQgQSBhbmQgQiBieSB0cmVlIG9y ZGVyIG9mIHRoZWlyIGNvcnJlc3BvbmRpbmcgb3duaW5nIGVsZW1lbnRzLgotICAgICAgICBpZiAo bGhzT3duaW5nRWxlbWVudCAhPSByaHNPd25pbmdFbGVtZW50KQotICAgICAgICAgICAgcmV0dXJu IGNvbXBhcmVEZWNsYXJhdGl2ZUFuaW1hdGlvbk93bmluZ0VsZW1lbnRQb3NpdGlvbnNJbkRvY3Vt ZW50VHJlZU9yZGVyKGxoc093bmluZ0VsZW1lbnQsIHJoc093bmluZ0VsZW1lbnQpOwotCi0gICAg ICAgIC8vIE90aGVyd2lzZSwgc29ydCBBIGFuZCBCIGJhc2VkIG9uIHRoZWlyIHBvc2l0aW9uIGlu IHRoZSBjb21wdXRlZCB2YWx1ZSBvZiB0aGUgYW5pbWF0aW9uLW5hbWUgcHJvcGVydHkgb2YgdGhl IChjb21tb24pIG93bmluZyBlbGVtZW50LgotICAgICAgICByZXR1cm4gY29tcGFyZUFuaW1hdGlv bnNCeUNvbXBvc2l0ZU9yZGVyKCpsaHMsICpyaHMsIGxoc093bmluZ0VsZW1lbnQtPmVuc3VyZUtl eWZyYW1lRWZmZWN0U3RhY2soKS5jc3NBbmltYXRpb25MaXN0KCkpOwotICAgIH0pOwotCi0gICAg c3RkOjpzdGFibGVfc29ydCh3ZWJBbmltYXRpb25zLmJlZ2luKCksIHdlYkFuaW1hdGlvbnMuZW5k KCksIFtdKGF1dG8mIGxocywgYXV0byYgcmhzKSB7Ci0gICAgICAgIHJldHVybiBsaHMtPmdsb2Jh bFBvc2l0aW9uKCkgPCByaHMtPmdsb2JhbFBvc2l0aW9uKCk7Ci0gICAgfSk7Ci0KLSAgICAvLyBG aW5hbGx5LCB3ZSBjYW4gY29uY2F0ZW5hdGUgdGhlIHNvcnRlZCBDU1MgVHJhbnNpdGlvbnMsIENT UyBBbmltYXRpb25zIGFuZCBXZWIgQW5pbWF0aW9ucyBpbiB0aGVpciByZWxhdGl2ZSBjb21wb3Np dGUgb3JkZXIuCi0gICAgVmVjdG9yPFJlZlB0cjxXZWJBbmltYXRpb24+PiBhbmltYXRpb25zOwot ICAgIGFuaW1hdGlvbnMuYXBwZW5kUmFuZ2UoY3NzVHJhbnNpdGlvbnMuYmVnaW4oKSwgY3NzVHJh bnNpdGlvbnMuZW5kKCkpOwotICAgIGFuaW1hdGlvbnMuYXBwZW5kUmFuZ2UoY3NzQW5pbWF0aW9u cy5iZWdpbigpLCBjc3NBbmltYXRpb25zLmVuZCgpKTsKLSAgICBhbmltYXRpb25zLmFwcGVuZFJh bmdlKHdlYkFuaW1hdGlvbnMuYmVnaW4oKSwgd2ViQW5pbWF0aW9ucy5lbmQoKSk7Ci0gICAgcmV0 dXJuIGFuaW1hdGlvbnM7Ci19Ci0KIFNlY29uZHMgRG9jdW1lbnRUaW1lbGluZTo6YW5pbWF0aW9u SW50ZXJ2YWwoKSBjb25zdAogewogICAgIGlmICghbV9kb2N1bWVudCB8fCAhbV9kb2N1bWVudC0+ cGFnZSgpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL0RvY3VtZW50VGlt ZWxpbmUuaCBiL1NvdXJjZS9XZWJDb3JlL2FuaW1hdGlvbi9Eb2N1bWVudFRpbWVsaW5lLmgKaW5k ZXggNTA3OTJiYWE1YzZjYTNjZDgzYTEzMGRmN2MwNzVmZTQwM2NmYzYzMC4uZjE5ZmJjNmI0ZmI0 NDJiNTA1MGE3NzY1NGVhNTQ3YzdmNGE5YjMyMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv YW5pbWF0aW9uL0RvY3VtZW50VGltZWxpbmUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hbmltYXRp b24vRG9jdW1lbnRUaW1lbGluZS5oCkBAIC00Niw4ICs0Niw2IEBAIHB1YmxpYzoKIAogICAgIGJv b2wgaXNEb2N1bWVudFRpbWVsaW5lKCkgY29uc3QgZmluYWwgeyByZXR1cm4gdHJ1ZTsgfQogCi0g ICAgVmVjdG9yPFJlZlB0cjxXZWJBbmltYXRpb24+PiBnZXRBbmltYXRpb25zKCkgY29uc3Q7Ci0K ICAgICBEb2N1bWVudCogZG9jdW1lbnQoKSBjb25zdCB7IHJldHVybiBtX2RvY3VtZW50LmdldCgp OyB9CiAKICAgICBPcHRpb25hbDxTZWNvbmRzPiBjdXJyZW50VGltZSgpIG92ZXJyaWRlOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL0tleWZyYW1lRWZmZWN0U3RhY2suY3Bw IGIvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL0tleWZyYW1lRWZmZWN0U3RhY2suY3BwCmluZGV4 IDgwODJiNjUwNDQ5ZTc4MmRmNDYwZDc0MWE0M2IyOWRmZjAyMWM3YTAuLjdjMGJlMGYxYzE2N2Rh MDc4NzgyOThkMzMyNjU1ZDdmMGNmYTljODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Fu aW1hdGlvbi9LZXlmcmFtZUVmZmVjdFN0YWNrLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hbmlt YXRpb24vS2V5ZnJhbWVFZmZlY3RTdGFjay5jcHAKQEAgLTk4LDcgKzk4LDcgQEAgdm9pZCBLZXlm cmFtZUVmZmVjdFN0YWNrOjplbnN1cmVFZmZlY3RzQXJlU29ydGVkKCkKICAgICAgICAgUkVMRUFT RV9BU1NFUlQobGhzQW5pbWF0aW9uKTsKICAgICAgICAgUkVMRUFTRV9BU1NFUlQocmhzQW5pbWF0 aW9uKTsKIAotICAgICAgICByZXR1cm4gY29tcGFyZUFuaW1hdGlvbnNCeUNvbXBvc2l0ZU9yZGVy KCpsaHNBbmltYXRpb24sICpyaHNBbmltYXRpb24sIG1fY3NzQW5pbWF0aW9uTGlzdC5nZXQoKSk7 CisgICAgICAgIHJldHVybiBjb21wYXJlQW5pbWF0aW9uc0J5Q29tcG9zaXRlT3JkZXIoKmxoc0Fu aW1hdGlvbiwgKnJoc0FuaW1hdGlvbik7CiAgICAgfSk7CiAKICAgICBtX2lzU29ydGVkID0gdHJ1 ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FuaW1hdGlvbi9XZWJBbmltYXRpb24uY3Bw IGIvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL1dlYkFuaW1hdGlvbi5jcHAKaW5kZXggMDA1MTYz ZjQ1YzAwMTcxNjQxNmI4YzgyNTM3OTkwYzUzN2FjZWYzZi4uZjg0ODBkYTMzMDkxYjc4YWU4YjA3 Mjg5NDVmMGRkNzI1MTVkOTZlMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9u L1dlYkFuaW1hdGlvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL1dlYkFuaW1h dGlvbi5jcHAKQEAgLTE0MDUsNyArMTQwNSw2IEBAIEV4Y2VwdGlvbk9yPHZvaWQ+IFdlYkFuaW1h dGlvbjo6Y29tbWl0U3R5bGVzKCkKICAgICBpbmxpbmVTdHlsZS0+c2V0Q3NzVGV4dChzdHlsZWRF bGVtZW50LmdldEF0dHJpYnV0ZSgic3R5bGUiKSk7CiAKICAgICBhdXRvJiBrZXlmcmFtZVN0YWNr ID0gc3R5bGVkRWxlbWVudC5lbnN1cmVLZXlmcmFtZUVmZmVjdFN0YWNrKCk7Ci0gICAgYXV0byog Y3NzQW5pbWF0aW9uTGlzdCA9IGtleWZyYW1lU3RhY2suY3NzQW5pbWF0aW9uTGlzdCgpOwogCiAg ICAgLy8gMi41IEZvciBlYWNoIHByb3BlcnR5LCBwcm9wZXJ0eSwgaW4gdGFyZ2V0ZWQgcHJvcGVy dGllczoKICAgICBmb3IgKGF1dG8gcHJvcGVydHkgOiBlZmZlY3QtPmFuaW1hdGVkUHJvcGVydGll cygpKSB7CkBAIC0xNDIyLDcgKzE0MjEsNyBAQCBFeGNlcHRpb25Pcjx2b2lkPiBXZWJBbmltYXRp b246OmNvbW1pdFN0eWxlcygpCiAgICAgICAgIC8vIGVmZmVjdCBzdGFjayBhbmQgc3RvcCB3aGVu IHdlJ3ZlIGZvdW5kIHRoaXMgYW5pbWF0aW9uJ3MgZWZmZWN0IG9yIHdoZW4gd2UndmUgZm91bmQg YW4gZWZmZWN0IGFzc29jaWF0ZWQgd2l0aCBhbiBhbmltYXRpb24gd2l0aCBhIGhpZ2hlciBjb21w b3NpdGUgb3JkZXIuCiAgICAgICAgIGF1dG8gYW5pbWF0ZWRTdHlsZSA9IFJlbmRlclN0eWxlOjpj bG9uZVB0cihzdHlsZSk7CiAgICAgICAgIGZvciAoY29uc3QgYXV0byYgZWZmZWN0SW5TdGFjayA6 IGtleWZyYW1lU3RhY2suc29ydGVkRWZmZWN0cygpKSB7Ci0gICAgICAgICAgICBpZiAoZWZmZWN0 SW5TdGFjay0+YW5pbWF0aW9uKCkgIT0gdGhpcyAmJiAhY29tcGFyZUFuaW1hdGlvbnNCeUNvbXBv c2l0ZU9yZGVyKCplZmZlY3RJblN0YWNrLT5hbmltYXRpb24oKSwgKnRoaXMsIGNzc0FuaW1hdGlv bkxpc3QpKQorICAgICAgICAgICAgaWYgKGVmZmVjdEluU3RhY2stPmFuaW1hdGlvbigpICE9IHRo aXMgJiYgIWNvbXBhcmVBbmltYXRpb25zQnlDb21wb3NpdGVPcmRlcigqZWZmZWN0SW5TdGFjay0+ YW5pbWF0aW9uKCksICp0aGlzKSkKICAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAg IGlmIChlZmZlY3RJblN0YWNrLT5hbmltYXRlZFByb3BlcnRpZXMoKS5jb250YWlucyhwcm9wZXJ0 eSkpCiAgICAgICAgICAgICAgICAgZWZmZWN0SW5TdGFjay0+YW5pbWF0aW9uKCktPnJlc29sdmUo KmFuaW1hdGVkU3R5bGUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYW5pbWF0aW9uL1dl YkFuaW1hdGlvblV0aWxpdGllcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vV2ViQW5p bWF0aW9uVXRpbGl0aWVzLmNwcAppbmRleCBmN2RhYzVjYzk5MGY3NTRlZTYyOTI4MDc1ZTgzMWEx MTQyM2IzNGM1Li43MTYyNTA3MDhjNzY5ZmRjZDU3NjAwOGI2OTdiMTc5ZmVhYjM3ODMzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vV2ViQW5pbWF0aW9uVXRpbGl0aWVzLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vV2ViQW5pbWF0aW9uVXRpbGl0aWVzLmNw cApAQCAtMzEsMTEgKzMxLDk2IEBACiAjaW5jbHVkZSAiQ1NTQW5pbWF0aW9uLmgiCiAjaW5jbHVk ZSAiQ1NTVHJhbnNpdGlvbi5oIgogI2luY2x1ZGUgIkRlY2xhcmF0aXZlQW5pbWF0aW9uLmgiCisj aW5jbHVkZSAiRWxlbWVudC5oIgorI2luY2x1ZGUgIktleWZyYW1lRWZmZWN0U3RhY2suaCIKKyNp bmNsdWRlICJQc2V1ZG9FbGVtZW50LmgiCiAjaW5jbHVkZSAiV2ViQW5pbWF0aW9uLmgiCiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAotYm9vbCBjb21wYXJlQW5pbWF0aW9uc0J5Q29tcG9zaXRlT3Jk ZXIoV2ViQW5pbWF0aW9uJiBsaHNBbmltYXRpb24sIFdlYkFuaW1hdGlvbiYgcmhzQW5pbWF0aW9u LCBjb25zdCBBbmltYXRpb25MaXN0KiBjc3NBbmltYXRpb25MaXN0KQoraW5saW5lIGJvb2wgY29t cGFyZURlY2xhcmF0aXZlQW5pbWF0aW9uT3duaW5nRWxlbWVudFBvc2l0aW9uc0luRG9jdW1lbnRU cmVlT3JkZXIoRWxlbWVudCogbGhzT3duaW5nRWxlbWVudCwgRWxlbWVudCogcmhzT3duaW5nRWxl bWVudCkKK3sKKyAgICAvLyBXaXRoIHJlZ2FyZCB0byBwc2V1ZG8tZWxlbWVudHMsIHRoZSBzb3J0 IG9yZGVyIGlzIGFzIGZvbGxvd3M6CisgICAgLy8gICAgIC0gZWxlbWVudAorICAgIC8vICAgICAt IDo6YmVmb3JlCisgICAgLy8gICAgIC0gOjphZnRlcgorICAgIC8vICAgICAtIGVsZW1lbnQgY2hp bGRyZW4KKworICAgIC8vIFdlIGNvdWxkIGJlIGNvbXBhcmluZyB0d28gcHNldWRvLWVsZW1lbnRz IHRoYXQgYXJlIGhvc3RlZCBvbiB0aGUgc2FtZSBlbGVtZW50LgorICAgIGlmIChpczxQc2V1ZG9F bGVtZW50PihsaHNPd25pbmdFbGVtZW50KSAmJiBpczxQc2V1ZG9FbGVtZW50PihyaHNPd25pbmdF bGVtZW50KSkgeworICAgICAgICBhdXRvKiBsaHNQc2V1ZG9FbGVtZW50ID0gZG93bmNhc3Q8UHNl dWRvRWxlbWVudD4obGhzT3duaW5nRWxlbWVudCk7CisgICAgICAgIGF1dG8qIHJoc1BzZXVkb0Vs ZW1lbnQgPSBkb3duY2FzdDxQc2V1ZG9FbGVtZW50PihyaHNPd25pbmdFbGVtZW50KTsKKyAgICAg ICAgaWYgKGxoc1BzZXVkb0VsZW1lbnQtPmhvc3RFbGVtZW50KCkgPT0gcmhzUHNldWRvRWxlbWVu dC0+aG9zdEVsZW1lbnQoKSkKKyAgICAgICAgICAgIHJldHVybiBsaHNQc2V1ZG9FbGVtZW50LT5p c0JlZm9yZVBzZXVkb0VsZW1lbnQoKTsKKyAgICB9CisKKyAgICAvLyBPciBjb21wYXJpbmcgYSBw c2V1ZG8tZWxlbWVudCB0aGF0IGlzIGNvbXBhcmVkIHRvIGFub3RoZXIgbm9uLXBzZXVkbyBlbGVt ZW50LCBpbiB3aGljaCBjYXNlCisgICAgLy8gd2Ugd2FudCB0byBzZWUgaWYgaXQncyBob3N0ZWQg b24gdGhhdCBvdGhlciBlbGVtZW50LCBhbmQgaWYgbm90IHVzZSBpdHMgaG9zdCBlbGVtZW50IHRv IGNvbXBhcmUuCisgICAgaWYgKGlzPFBzZXVkb0VsZW1lbnQ+KGxoc093bmluZ0VsZW1lbnQpKSB7 CisgICAgICAgIGF1dG8qIGxoc0hvc3RFbGVtZW50ID0gZG93bmNhc3Q8UHNldWRvRWxlbWVudD4o bGhzT3duaW5nRWxlbWVudCktPmhvc3RFbGVtZW50KCk7CisgICAgICAgIGlmIChyaHNPd25pbmdF bGVtZW50ID09IGxoc0hvc3RFbGVtZW50KQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAg ICAgICBsaHNPd25pbmdFbGVtZW50ID0gbGhzSG9zdEVsZW1lbnQ7CisgICAgfQorCisgICAgaWYg KGlzPFBzZXVkb0VsZW1lbnQ+KHJoc093bmluZ0VsZW1lbnQpKSB7CisgICAgICAgIGF1dG8qIHJo c0hvc3RFbGVtZW50ID0gZG93bmNhc3Q8UHNldWRvRWxlbWVudD4ocmhzT3duaW5nRWxlbWVudCkt Pmhvc3RFbGVtZW50KCk7CisgICAgICAgIGlmIChsaHNPd25pbmdFbGVtZW50ID09IHJoc0hvc3RF bGVtZW50KQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIHJoc093bmluZ0VsZW1l bnQgPSByaHNIb3N0RWxlbWVudDsKKyAgICB9CisKKyAgICByZXR1cm4gbGhzT3duaW5nRWxlbWVu dC0+Y29tcGFyZURvY3VtZW50UG9zaXRpb24oKnJoc093bmluZ0VsZW1lbnQpICYgTm9kZTo6RE9D VU1FTlRfUE9TSVRJT05fRk9MTE9XSU5HOworfQorCitpbmxpbmUgYm9vbCBjb21wYXJlQ1NTVHJh bnNpdGlvbnMoY29uc3QgQ1NTVHJhbnNpdGlvbiYgbGhzVHJhbnNpdGlvbiwgY29uc3QgQ1NTVHJh bnNpdGlvbiYgcmhzVHJhbnNpdGlvbikKK3sKKyAgICBhdXRvKiBsaHNPd25pbmdFbGVtZW50ID0g bGhzVHJhbnNpdGlvbi5vd25pbmdFbGVtZW50KCk7CisgICAgYXV0byogcmhzT3duaW5nRWxlbWVu dCA9IHJoc1RyYW5zaXRpb24ub3duaW5nRWxlbWVudCgpOworCisgICAgLy8gSWYgdGhlIG93bmlu ZyBlbGVtZW50IG9mIEEgYW5kIEIgZGlmZmVycywgc29ydCBBIGFuZCBCIGJ5IHRyZWUgb3JkZXIg b2YgdGhlaXIgY29ycmVzcG9uZGluZyBvd25pbmcgZWxlbWVudHMuCisgICAgaWYgKGxoc093bmlu Z0VsZW1lbnQgIT0gcmhzT3duaW5nRWxlbWVudCkKKyAgICAgICAgcmV0dXJuIGNvbXBhcmVEZWNs YXJhdGl2ZUFuaW1hdGlvbk93bmluZ0VsZW1lbnRQb3NpdGlvbnNJbkRvY3VtZW50VHJlZU9yZGVy KGxoc093bmluZ0VsZW1lbnQsIHJoc093bmluZ0VsZW1lbnQpOworCisgICAgLy8gT3RoZXJ3aXNl LCBpZiBBIGFuZCBCIGhhdmUgZGlmZmVyZW50IHRyYW5zaXRpb24gZ2VuZXJhdGlvbiB2YWx1ZXMs IHNvcnQgYnkgdGhlaXIgY29ycmVzcG9uZGluZyB0cmFuc2l0aW9uIGdlbmVyYXRpb24gaW4gYXNj ZW5kaW5nIG9yZGVyLgorICAgIGlmIChsaHNUcmFuc2l0aW9uLmdlbmVyYXRpb25UaW1lKCkgIT0g cmhzVHJhbnNpdGlvbi5nZW5lcmF0aW9uVGltZSgpKQorICAgICAgICByZXR1cm4gbGhzVHJhbnNp dGlvbi5nZW5lcmF0aW9uVGltZSgpIDwgcmhzVHJhbnNpdGlvbi5nZW5lcmF0aW9uVGltZSgpOwor CisgICAgLy8gT3RoZXJ3aXNlLCBzb3J0IEEgYW5kIEIgaW4gYXNjZW5kaW5nIG9yZGVyIGJ5IHRo ZSBVbmljb2RlIGNvZGVwb2ludHMgdGhhdCBtYWtlIHVwIHRoZSBleHBhbmRlZCB0cmFuc2l0aW9u IHByb3BlcnR5IG5hbWUgb2YgZWFjaCB0cmFuc2l0aW9uCisgICAgLy8gKGkuZS4gd2l0aG91dCBh dHRlbXB0aW5nIGNhc2UgY29udmVyc2lvbiBhbmQgc3VjaCB0aGF0IOKAmC1tb3otY29sdW1uLXdp ZHRo4oCZIHNvcnRzIGJlZm9yZSDigJhjb2x1bW4td2lkdGjigJkpLgorICAgIHJldHVybiBsaHNU cmFuc2l0aW9uLnRyYW5zaXRpb25Qcm9wZXJ0eSgpLnV0ZjgoKSA8IHJoc1RyYW5zaXRpb24udHJh bnNpdGlvblByb3BlcnR5KCkudXRmOCgpOworfQorCitpbmxpbmUgYm9vbCBjb21wYXJlQ1NTQW5p bWF0aW9ucyhjb25zdCBDU1NBbmltYXRpb24mIGxocywgY29uc3QgQ1NTQW5pbWF0aW9uJiByaHMp Cit7CisgICAgLy8gaHR0cHM6Ly9kcmFmdHMuY3Nzd2cub3JnL2Nzcy1hbmltYXRpb25zLTIvI2Fu aW1hdGlvbi1jb21wb3NpdGUtb3JkZXIKKyAgICBhdXRvKiBsaHNPd25pbmdFbGVtZW50ID0gbGhz Lm93bmluZ0VsZW1lbnQoKTsKKyAgICBhdXRvKiByaHNPd25pbmdFbGVtZW50ID0gcmhzLm93bmlu Z0VsZW1lbnQoKTsKKworICAgIC8vIElmIHRoZSBvd25pbmcgZWxlbWVudCBvZiBBIGFuZCBCIGRp ZmZlcnMsIHNvcnQgQSBhbmQgQiBieSB0cmVlIG9yZGVyIG9mIHRoZWlyIGNvcnJlc3BvbmRpbmcg b3duaW5nIGVsZW1lbnRzLgorICAgIGlmIChsaHNPd25pbmdFbGVtZW50ICE9IHJoc093bmluZ0Vs ZW1lbnQpCisgICAgICAgIHJldHVybiBjb21wYXJlRGVjbGFyYXRpdmVBbmltYXRpb25Pd25pbmdF bGVtZW50UG9zaXRpb25zSW5Eb2N1bWVudFRyZWVPcmRlcihsaHNPd25pbmdFbGVtZW50LCByaHNP d25pbmdFbGVtZW50KTsKKworICAgIC8vIFNvcnQgQSBhbmQgQiBiYXNlZCBvbiB0aGVpciBwb3Np dGlvbiBpbiB0aGUgY29tcHV0ZWQgdmFsdWUgb2YgdGhlIGFuaW1hdGlvbi1uYW1lIHByb3BlcnR5 IG9mIHRoZSAoY29tbW9uKSBvd25pbmcgZWxlbWVudC4KKyAgICBhdXRvKiBjc3NBbmltYXRpb25M aXN0ID0gbGhzT3duaW5nRWxlbWVudC0+ZW5zdXJlS2V5ZnJhbWVFZmZlY3RTdGFjaygpLmNzc0Fu aW1hdGlvbkxpc3QoKTsKKyAgICBBU1NFUlQoY3NzQW5pbWF0aW9uTGlzdCk7CisgICAgQVNTRVJU KCFjc3NBbmltYXRpb25MaXN0LT5pc0VtcHR5KCkpOworCisgICAgYXV0byYgbGhzQmFja2luZ0Fu aW1hdGlvbiA9IGxocy5iYWNraW5nQW5pbWF0aW9uKCk7CisgICAgYXV0byYgcmhzQmFja2luZ0Fu aW1hdGlvbiA9IHJocy5iYWNraW5nQW5pbWF0aW9uKCk7CisgICAgZm9yIChzaXplX3QgaSA9IDA7 IGkgPCBjc3NBbmltYXRpb25MaXN0LT5zaXplKCk7ICsraSkgeworICAgICAgICBhdXRvJiBhbmlt YXRpb24gPSBjc3NBbmltYXRpb25MaXN0LT5hbmltYXRpb24oaSk7CisgICAgICAgIGlmIChhbmlt YXRpb24gPT0gbGhzQmFja2luZ0FuaW1hdGlvbikKKyAgICAgICAgICAgIHJldHVybiB0cnVlOwor ICAgICAgICBpZiAoYW5pbWF0aW9uID09IHJoc0JhY2tpbmdBbmltYXRpb24pCisgICAgICAgICAg ICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgLy8gV2Ugc2hvdWxkIGhhdmUgZm91bmQgZWl0 aGVyIG9mIHRob3NlIENTUyBhbmltYXRpb25zIGluIHRoZSBDU1MgYW5pbWF0aW9ucyBsaXN0Lgor ICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7Cit9CisKK2Jvb2wgY29tcGFyZUFuaW1h dGlvbnNCeUNvbXBvc2l0ZU9yZGVyKGNvbnN0IFdlYkFuaW1hdGlvbiYgbGhzQW5pbWF0aW9uLCBj b25zdCBXZWJBbmltYXRpb24mIHJoc0FuaW1hdGlvbikKIHsKICAgICAvLyBXZSBzaG91bGQgbm90 IGV2ZXIgYmUgY2FsbGluZyB0aGlzIGZ1bmN0aW9uIHdpdGggdHdvIFdlYkFuaW1hdGlvbiBvYmpl Y3RzIHRoYXQgYXJlIHRoZSBzYW1lLiBJZiB0aGF0IHdlcmUgdGhlIGNhc2UsCiAgICAgLy8gdGhl biBjb21wYXJpbmcgb2JqZWN0cyBvZiB0aGlzIGtpbmQgd291bGQgeWllbGQgaW5jb25zaXN0ZW50 IHJlc3VsdHMgd2hlbiBjb21wYXJpbmcgQSA9PSBCIGFuZCBCID09IEEuIEFzIHN1Y2gsCkBAIC00 OSw0NyArMTM0LDE4IEBAIGJvb2wgY29tcGFyZUFuaW1hdGlvbnNCeUNvbXBvc2l0ZU9yZGVyKFdl YkFuaW1hdGlvbiYgbGhzQW5pbWF0aW9uLCBXZWJBbmltYXRpb24mCiAgICAgYm9vbCBsaHNJc0NT U1RyYW5zaXRpb24gPSBsaHNIYXNPd25pbmdFbGVtZW50ICYmIGlzPENTU1RyYW5zaXRpb24+KGxo c0FuaW1hdGlvbik7CiAgICAgYm9vbCByaHNJc0NTU1RyYW5zaXRpb24gPSByaHNIYXNPd25pbmdF bGVtZW50ICYmIGlzPENTU1RyYW5zaXRpb24+KHJoc0FuaW1hdGlvbik7CiAgICAgaWYgKGxoc0lz Q1NTVHJhbnNpdGlvbiB8fCByaHNJc0NTU1RyYW5zaXRpb24pIHsKLSAgICAgICAgaWYgKGxoc0lz Q1NTVHJhbnNpdGlvbiAhPSByaHNJc0NTU1RyYW5zaXRpb24pCi0gICAgICAgICAgICByZXR1cm4g IXJoc0lzQ1NTVHJhbnNpdGlvbjsKLQotICAgICAgICAvLyBTb3J0IHRyYW5zaXRpb25zIGZpcnN0 IGJ5IHRoZWlyIGdlbmVyYXRpb24gdGltZSwgYW5kIHRoZW4gYnkgdHJhbnNpdGlvbi1wcm9wZXJ0 eS4KLSAgICAgICAgLy8gaHR0cHM6Ly9kcmFmdHMuY3Nzd2cub3JnL2Nzcy10cmFuc2l0aW9ucy0y LyNhbmltYXRpb24tY29tcG9zaXRlLW9yZGVyCi0gICAgICAgIGF1dG8mIGxoc0NTU1RyYW5zaXRp b24gPSBkb3duY2FzdDxDU1NUcmFuc2l0aW9uPihsaHNBbmltYXRpb24pOwotICAgICAgICBhdXRv JiByaHNDU1NUcmFuc2l0aW9uID0gZG93bmNhc3Q8Q1NTVHJhbnNpdGlvbj4ocmhzQW5pbWF0aW9u KTsKLSAgICAgICAgaWYgKGxoc0NTU1RyYW5zaXRpb24uZ2VuZXJhdGlvblRpbWUoKSAhPSByaHND U1NUcmFuc2l0aW9uLmdlbmVyYXRpb25UaW1lKCkpCi0gICAgICAgICAgICByZXR1cm4gbGhzQ1NT VHJhbnNpdGlvbi5nZW5lcmF0aW9uVGltZSgpIDwgcmhzQ1NTVHJhbnNpdGlvbi5nZW5lcmF0aW9u VGltZSgpOwotICAgICAgICBhdXRvIGxoc0NTU1RyYW5zaXRpb25Qcm9wZXJ0eSA9IGxoc0NTU1Ry YW5zaXRpb24udHJhbnNpdGlvblByb3BlcnR5KCkudXRmOCgpOwotICAgICAgICBhdXRvIHJoc0NT U1RyYW5zaXRpb25Qcm9wZXJ0eSA9IHJoc0NTU1RyYW5zaXRpb24udHJhbnNpdGlvblByb3BlcnR5 KCkudXRmOCgpOwotICAgICAgICBpZiAobGhzQ1NTVHJhbnNpdGlvblByb3BlcnR5ICE9IHJoc0NT U1RyYW5zaXRpb25Qcm9wZXJ0eSkKLSAgICAgICAgICAgIHJldHVybiBsaHNDU1NUcmFuc2l0aW9u UHJvcGVydHkgPCByaHNDU1NUcmFuc2l0aW9uUHJvcGVydHk7CisgICAgICAgIGlmIChsaHNJc0NT U1RyYW5zaXRpb24gPT0gcmhzSXNDU1NUcmFuc2l0aW9uKQorICAgICAgICAgICAgcmV0dXJuIGNv bXBhcmVDU1NUcmFuc2l0aW9ucyhkb3duY2FzdDxDU1NUcmFuc2l0aW9uPihsaHNBbmltYXRpb24p LCBkb3duY2FzdDxDU1NUcmFuc2l0aW9uPihyaHNBbmltYXRpb24pKTsKKyAgICAgICAgcmV0dXJu ICFyaHNJc0NTU1RyYW5zaXRpb247CiAgICAgfQogCiAgICAgLy8gQ1NTIEFuaW1hdGlvbnMgc29y dCBuZXh0LgogICAgIGJvb2wgbGhzSXNDU1NBbmltYXRpb24gPSBsaHNIYXNPd25pbmdFbGVtZW50 ICYmIGlzPENTU0FuaW1hdGlvbj4obGhzQW5pbWF0aW9uKTsKICAgICBib29sIHJoc0lzQ1NTQW5p bWF0aW9uID0gcmhzSGFzT3duaW5nRWxlbWVudCAmJiBpczxDU1NBbmltYXRpb24+KHJoc0FuaW1h dGlvbik7CiAgICAgaWYgKGxoc0lzQ1NTQW5pbWF0aW9uIHx8IHJoc0lzQ1NTQW5pbWF0aW9uKSB7 Ci0gICAgICAgIGlmIChsaHNJc0NTU0FuaW1hdGlvbiAhPSByaHNJc0NTU0FuaW1hdGlvbikKLSAg ICAgICAgICAgIHJldHVybiAhcmhzSXNDU1NBbmltYXRpb247Ci0KLSAgICAgICAgLy8gV2UgbXVz dCBoYXZlIGEgbGlzdCBvZiBDU1MgQW5pbWF0aW9ucyBpZiB3ZSBoYXZlIENTUyBBbmltYXRpb25z IHRvIHNvcnQgdGhyb3VnaC4KLSAgICAgICAgQVNTRVJUKGNzc0FuaW1hdGlvbkxpc3QpOwotICAg ICAgICBBU1NFUlQoIWNzc0FuaW1hdGlvbkxpc3QtPmlzRW1wdHkoKSk7Ci0KLSAgICAgICAgLy8g aHR0cHM6Ly9kcmFmdHMuY3Nzd2cub3JnL2Nzcy1hbmltYXRpb25zLTIvI2FuaW1hdGlvbi1jb21w b3NpdGUtb3JkZXIKLSAgICAgICAgLy8gU29ydCBBIGFuZCBCIGJhc2VkIG9uIHRoZWlyIHBvc2l0 aW9uIGluIHRoZSBjb21wdXRlZCB2YWx1ZSBvZiB0aGUgYW5pbWF0aW9uLW5hbWUgcHJvcGVydHkg b2YgdGhlIChjb21tb24pIG93bmluZyBlbGVtZW50LgotICAgICAgICBhdXRvJiBsaHNCYWNraW5n QW5pbWF0aW9uID0gZG93bmNhc3Q8Q1NTQW5pbWF0aW9uPihsaHNBbmltYXRpb24pLmJhY2tpbmdB bmltYXRpb24oKTsKLSAgICAgICAgYXV0byYgcmhzQmFja2luZ0FuaW1hdGlvbiA9IGRvd25jYXN0 PENTU0FuaW1hdGlvbj4ocmhzQW5pbWF0aW9uKS5iYWNraW5nQW5pbWF0aW9uKCk7Ci0KLSAgICAg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBjc3NBbmltYXRpb25MaXN0LT5zaXplKCk7ICsraSkg ewotICAgICAgICAgICAgYXV0byYgYW5pbWF0aW9uID0gY3NzQW5pbWF0aW9uTGlzdC0+YW5pbWF0 aW9uKGkpOwotICAgICAgICAgICAgaWYgKGFuaW1hdGlvbiA9PSBsaHNCYWNraW5nQW5pbWF0aW9u KQotICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOwotICAgICAgICAgICAgaWYgKGFuaW1hdGlv biA9PSByaHNCYWNraW5nQW5pbWF0aW9uKQotICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsK LSAgICAgICAgfQotCi0gICAgICAgIC8vIFdlIHNob3VsZCBoYXZlIGZvdW5kIGVpdGhlciBvZiB0 aG9zZSBDU1MgYW5pbWF0aW9ucyBpbiB0aGUgQ1NTIGFuaW1hdGlvbnMgbGlzdC4KLSAgICAgICAg UkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgaWYgKGxoc0lzQ1NTQW5pbWF0 aW9uID09IHJoc0lzQ1NTQW5pbWF0aW9uKQorICAgICAgICAgICAgcmV0dXJuIGNvbXBhcmVDU1NB bmltYXRpb25zKGRvd25jYXN0PENTU0FuaW1hdGlvbj4obGhzQW5pbWF0aW9uKSwgZG93bmNhc3Q8 Q1NTQW5pbWF0aW9uPihyaHNBbmltYXRpb24pKTsKKyAgICAgICAgcmV0dXJuICFyaHNJc0NTU0Fu aW1hdGlvbjsKICAgICB9CiAKICAgICAvLyBKUy1vcmlnaW5hdGVkIGFuaW1hdGlvbnMgc29ydCBs YXN0IGJhc2VkIG9uIHRoZWlyIHBvc2l0aW9uIGluIHRoZSBnbG9iYWwgYW5pbWF0aW9uIGxpc3Qu CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vV2ViQW5pbWF0aW9uVXRpbGl0 aWVzLmggYi9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24vV2ViQW5pbWF0aW9uVXRpbGl0aWVzLmgK aW5kZXggZmI5MTM3MDEwYWU5YTZhMzNlMzE4N2M4MWE4NjRmYWNjM2IyOTJkMy4uYzg1Yjk3OWQ3 OGUyN2I4MjNkYTRkYjZlYjI5M2JkNDYxMTdhZjJkOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvYW5pbWF0aW9uL1dlYkFuaW1hdGlvblV0aWxpdGllcy5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2FuaW1hdGlvbi9XZWJBbmltYXRpb25VdGlsaXRpZXMuaApAQCAtMzEsNyArMzEsNyBAQAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIEFuaW1hdGlvbkxpc3Q7CitjbGFzcyBFbGVtZW50 OwogY2xhc3MgV2ViQW5pbWF0aW9uOwogCiBpbmxpbmUgZG91YmxlIHNlY29uZHNUb1dlYkFuaW1h dGlvbnNBUElUaW1lKGNvbnN0IFNlY29uZHMgdGltZSkKQEAgLTUwLDcgKzUwLDcgQEAgaW5saW5l IGRvdWJsZSBzZWNvbmRzVG9XZWJBbmltYXRpb25zQVBJVGltZShjb25zdCBTZWNvbmRzIHRpbWUp CiAKIGNvbnN0IGF1dG8gdGltZUVwc2lsb24gPSBTZWNvbmRzOjpmcm9tTWlsbGlzZWNvbmRzKDAu MDAxKTsKIAotYm9vbCBjb21wYXJlQW5pbWF0aW9uc0J5Q29tcG9zaXRlT3JkZXIoV2ViQW5pbWF0 aW9uJiwgV2ViQW5pbWF0aW9uJiwgY29uc3QgQW5pbWF0aW9uTGlzdCopOworYm9vbCBjb21wYXJl QW5pbWF0aW9uc0J5Q29tcG9zaXRlT3JkZXIoY29uc3QgV2ViQW5pbWF0aW9uJiwgY29uc3QgV2Vi QW5pbWF0aW9uJik7CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5jcHAKaW5kZXggZjEzZjgzNzcyYTM2ODU2NWVkYTNmODdkNTE4MTViZTc4ZmYxYWY2MS4uNGQ1 N2EzZGFiNDNlZWFjNzY4YWIwNjNiODI4MDljZjc5OWQ4Mjc0NyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1l bnQuY3BwCkBAIC0yMzMsNiArMjMzLDcgQEAKICNpbmNsdWRlICJWaXNpdGVkTGlua1N0YXRlLmgi CiAjaW5jbHVkZSAiVmlzdWFsVmlld3BvcnQuaCIKICNpbmNsdWRlICJXZWJBbmltYXRpb24uaCIK KyNpbmNsdWRlICJXZWJBbmltYXRpb25VdGlsaXRpZXMuaCIKICNpbmNsdWRlICJXaGVlbEV2ZW50 LmgiCiAjaW5jbHVkZSAiV2luZG93RXZlbnRMb29wLmgiCiAjaW5jbHVkZSAiV2luZG93RmVhdHVy ZXMuaCIKQEAgLTgxMzksMTQgKzgxNDAsMTkgQEAgVmVjdG9yPFJlZlB0cjxXZWJBbmltYXRpb24+ PiBEb2N1bWVudDo6bWF0Y2hpbmdBbmltYXRpb25zKGNvbnN0IFdURjo6RnVuY3Rpb248Ym8KICAg ICAgICAgcmV0dXJuIHsgfTsKIAogICAgIFZlY3RvcjxSZWZQdHI8V2ViQW5pbWF0aW9uPj4gYW5p bWF0aW9uczsKLSAgICBmb3IgKGF1dG8mIGFuaW1hdGlvbiA6IG1fdGltZWxpbmUtPmdldEFuaW1h dGlvbnMoKSkgewotICAgICAgICBhdXRvKiBlZmZlY3QgPSBhbmltYXRpb24tPmVmZmVjdCgpOwot ICAgICAgICBBU1NFUlQoaXM8S2V5ZnJhbWVFZmZlY3Q+KGFuaW1hdGlvbi0+ZWZmZWN0KCkpKTsK LSAgICAgICAgYXV0byogdGFyZ2V0ID0gZG93bmNhc3Q8S2V5ZnJhbWVFZmZlY3Q+KCplZmZlY3Qp LnRhcmdldEVsZW1lbnRPclBzZXVkb0VsZW1lbnQoKTsKLSAgICAgICAgQVNTRVJUKHRhcmdldCk7 Ci0gICAgICAgIGlmIChmdW5jdGlvbigqdGFyZ2V0KSkKKyAgICBmb3IgKGF1dG8mIGFuaW1hdGlv biA6IG1fdGltZWxpbmUtPnJlbGV2YW50QW5pbWF0aW9ucygpKSB7CisgICAgICAgIGlmICghYW5p bWF0aW9uIHx8ICFhbmltYXRpb24tPmlzUmVsZXZhbnQoKSB8fCAhaXM8S2V5ZnJhbWVFZmZlY3Q+ KGFuaW1hdGlvbi0+ZWZmZWN0KCkpKQorICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAg YXV0byogdGFyZ2V0ID0gZG93bmNhc3Q8S2V5ZnJhbWVFZmZlY3Q+KCphbmltYXRpb24tPmVmZmVj dCgpKS50YXJnZXRFbGVtZW50T3JQc2V1ZG9FbGVtZW50KCk7CisgICAgICAgIGlmICh0YXJnZXQg JiYgdGFyZ2V0LT5pc0Rlc2NlbmRhbnRPZih0aGlzKSAmJiBmdW5jdGlvbigqdGFyZ2V0KSkKICAg ICAgICAgICAgIGFuaW1hdGlvbnMuYXBwZW5kKGFuaW1hdGlvbik7CiAgICAgfQorCisgICAgc3Rk OjpzdGFibGVfc29ydChhbmltYXRpb25zLmJlZ2luKCksIGFuaW1hdGlvbnMuZW5kKCksIFtdKGF1 dG8mIGxocywgYXV0byYgcmhzKSB7CisgICAgICAgIHJldHVybiBjb21wYXJlQW5pbWF0aW9uc0J5 Q29tcG9zaXRlT3JkZXIoKmxocywgKnJocyk7CisgICAgfSk7CisKICAgICByZXR1cm4gYW5pbWF0 aW9uczsKIH0KIAo=