166878 2017-01-09 20:58:38 -0800 Streamline the GC barrier slowpath 2017-01-11 13:49:03 -0800 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build All All RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=166847 InRadar P2 Normal --- 165909 1 fpizlo fpizlo ggaren webkit-bug-importer oldest_to_newest 1265287 0 fpizlo 2017-01-09 20:58:38 -0800 Remove the write barrier buffer. Teach the barrier slow path to re-white unmarked-black objects. 1265288 1 298444 fpizlo 2017-01-09 21:00:39 -0800 Created attachment 298444 the patch 1265289 2 webkit-bug-importer 2017-01-09 21:01:48 -0800 <rdar://problem/29942167> 1265462 3 298444 ggaren 2017-01-10 11:33:45 -0800 Comment on attachment 298444 the patch View in context: https://bugs.webkit.org/attachment.cgi?id=298444&action=review r=me > Source/JavaScriptCore/heap/CellState.h:45 > +// The CellState of a cell is a kind of hint about what the state of the cell is. > enum class CellState : uint8_t { > // The object is either currently being scanned, or it has finished being scanned, or this > // is a full collection and it's actually a white object (you'd know because its mark bit > // would be clear). > - PossiblyOldOrBlack = 0, > + PossiblyBlack = 0, > > // The object is in eden. During GC, this means that the object has not been marked yet. > - DefinitelyNewAndWhite = 1, > + DefinitelyWhite = 1, > > - // The object is grey - i.e. it will be scanned. > - DefinitelyGrey = 2, > + // This sorta means that the object is grey - i.e. it will be scanned. Or it could be white > + // during a full collection if its mark bit is clear. That would happen if it had been black, > + // got barriered, and we did a full collection. > + PossiblyGrey = 2 It would help to explain that these values indicate an upper bound on the visiting state of an object: Black means the object has probably transitioned all the way to Black, but it might still be back at Grey or White. Grey means the object has probably transitioned to Grey, but it might still be back at White. White means White. Otherwise, "PossiblyGrey" is ambiguous, and it's not clear why it's OK to skip Black object behaviors when PossiblyGrey. You could even consider renaming to { White, GreyOrLower, BlackOrLower }, or renaming the enum to CellStateUpperBound. > Source/JavaScriptCore/heap/Heap.cpp:957 > + // During a full collection a store into an unmarked object that had surivived past > + // collections will manifest as a store to an unmarked black object. If the object gets > + // marked at some time after this then it will go down the normal marking path. We can > + // safely ignore these stores. Can we ASSERT here that we're doing a full collection? "store to an unmarked black object" => "store to an unmarked possibly black object" Instead of "If the object....", I would say: In this situation, the object is actually white. By synchronizing with the GC below, we can prove that the object is white and update its state so it doesn't take the slow path again. > Source/JavaScriptCore/heap/Heap.cpp:973 > + if (cell->atomicCompareExchangeCellStateStrong(CellState::PossiblyBlack, CellState::DefinitelyWhite) == CellState::PossiblyBlack) { > + // Now we protect against this race: > + // > + // 1) Object starts out black + unmarked. > + // --> We do isMarkedConcurrently here. > + // 2) Object is marked and greyed. > + // 3) Object is scanned and blacked. > + // --> We do atomicCompareExchangeCellStateStrong here. > + // > + // In this case we would have made the object white again, even though it should > + // be black. This check lets us correct our mistake. This relies on the fact that > + // isMarkedConcurrently converges monotonically to true. > + if (!isMarkedConcurrently(cell)) { > + // OK - the object really deserves to be white! > + return; > + } I wonder if it would be better (i.e., simpler and not more expensive) just to grey the object unconditionally. I think the advantage of this check-and-white approach is that it allows an old object to die even if we store to it during GC. I wonder if this advantage is really all that important for old objects, since it's impossible for the mutator to create a death spiral of old objects, and old objects tend to survive anyway. 1265475 4 fpizlo 2017-01-10 11:50:33 -0800 (In reply to comment #3) > Comment on attachment 298444 [details] > the patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=298444&action=review > > r=me > > > Source/JavaScriptCore/heap/CellState.h:45 > > +// The CellState of a cell is a kind of hint about what the state of the cell is. > > enum class CellState : uint8_t { > > // The object is either currently being scanned, or it has finished being scanned, or this > > // is a full collection and it's actually a white object (you'd know because its mark bit > > // would be clear). > > - PossiblyOldOrBlack = 0, > > + PossiblyBlack = 0, > > > > // The object is in eden. During GC, this means that the object has not been marked yet. > > - DefinitelyNewAndWhite = 1, > > + DefinitelyWhite = 1, > > > > - // The object is grey - i.e. it will be scanned. > > - DefinitelyGrey = 2, > > + // This sorta means that the object is grey - i.e. it will be scanned. Or it could be white > > + // during a full collection if its mark bit is clear. That would happen if it had been black, > > + // got barriered, and we did a full collection. > > + PossiblyGrey = 2 > > It would help to explain that these values indicate an upper bound on the > visiting state of an object: > > Black means the object has probably transitioned all the way to Black, but > it might still be back at Grey or White. > > Grey means the object has probably transitioned to Grey, but it might still > be back at White. > > White means White. > > Otherwise, "PossiblyGrey" is ambiguous, and it's not clear why it's OK to > skip Black object behaviors when PossiblyGrey. > > You could even consider renaming to { White, GreyOrLower, BlackOrLower }, or > renaming the enum to CellStateUpperBound. I get what "GreyOrLower" and "BlackOrLower" are supposed to mean, but I wouldn't have thought that without reading your explanation. There's a ton of nuance to these states. You're right that DefinitelyWhite is the only one that has guaranteed meaning. To understand the meaning of the other states, you have to consider the mark bit and possibly other information. That's why after many attempts at naming these states in a more descriptive way, I decided to go with the "Possibly" prefix for states whose meaning has caveats and the "Definitely" prefix for the state whose meaning has no caveats. > > > Source/JavaScriptCore/heap/Heap.cpp:957 > > + // During a full collection a store into an unmarked object that had surivived past > > + // collections will manifest as a store to an unmarked black object. If the object gets > > + // marked at some time after this then it will go down the normal marking path. We can > > + // safely ignore these stores. > > Can we ASSERT here that we're doing a full collection? > Yes. I added it. > "store to an unmarked black object" => "store to an unmarked possibly black > object" > > Instead of "If the object....", I would say: In this situation, the object > is actually white. By synchronizing with the GC below, we can prove that the > object is white and update its state so it doesn't take the slow path again. That doesn't mean the same thing. This is speaking of the span of time beginning immediately after the isMarkedConcurrently check, and ending at the end of GC. During any moment in that span of time, if the object gets marked, it will go down the normal marking path. This paragraph is justifying why we can ignore PossiblyBlack unmarked objects. It's not meant as a justification for the optimization below, which re-whites the object. I rewrote this paragraph: // During a full collection a store into an unmarked object that had surivived past // collections will manifest as a store to an unmarked PossiblyBlack object. If the // object gets marked at some time after this then it will go down the normal marking // path. So, we don't have to remember this object. We could return here. But we go // further and attempt to re-white the object. > > > Source/JavaScriptCore/heap/Heap.cpp:973 > > + if (cell->atomicCompareExchangeCellStateStrong(CellState::PossiblyBlack, CellState::DefinitelyWhite) == CellState::PossiblyBlack) { > > + // Now we protect against this race: > > + // > > + // 1) Object starts out black + unmarked. > > + // --> We do isMarkedConcurrently here. > > + // 2) Object is marked and greyed. > > + // 3) Object is scanned and blacked. > > + // --> We do atomicCompareExchangeCellStateStrong here. > > + // > > + // In this case we would have made the object white again, even though it should > > + // be black. This check lets us correct our mistake. This relies on the fact that > > + // isMarkedConcurrently converges monotonically to true. > > + if (!isMarkedConcurrently(cell)) { > > + // OK - the object really deserves to be white! > > + return; > > + } > > I wonder if it would be better (i.e., simpler and not more expensive) just > to grey the object unconditionally. We can't do that because that would be incorrect. A grey object will get ignored by the barrier. You cannot grey an object that might be black. The GC is changing the object's color using a naked store - no CAS. So, just as we change the object's color to grey the GC could be changing it to black. In between the !isMarkedConcurrently check and when we run our CAS, the object could have been greyed, blackened, and scanned. Now it still looks black. If we just change it to grey we will introduce a bug. > > I think the advantage of this check-and-white approach is that it allows an > old object to die even if we store to it during GC. I wonder if this > advantage is really all that important for old objects, since it's > impossible for the mutator to create a death spiral of old objects, and old > objects tend to survive anyway. This isn't an optimization. We can't unblacken an object without being extremely careful. The GC may have blackened the object to signal that the barrier is needed. We can't forget this information. That's why we first whiten it, and then check the mark bit again. We can prove that the bad interleaving that I speak of would get caught by this extra check. 1265476 5 298444 saam 2017-01-10 11:56:58 -0800 Comment on attachment 298444 the patch View in context: https://bugs.webkit.org/attachment.cgi?id=298444&action=review > Source/JavaScriptCore/heap/Heap.cpp:977 > + // It's difficult to work out whether the object should be grey or black at > + // this point. We say black conservatively. > + cell->setCellState(CellState::PossiblyBlack); What's the point of doing this if we fall through to the code below that does greying? Maybe it should return here? 1265477 6 298444 saam 2017-01-10 11:58:51 -0800 Comment on attachment 298444 the patch (I didn't mean to clear r+) 1265479 7 fpizlo 2017-01-10 12:02:04 -0800 (In reply to comment #5) > Comment on attachment 298444 [details] > the patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=298444&action=review > > > Source/JavaScriptCore/heap/Heap.cpp:977 > > + // It's difficult to work out whether the object should be grey or black at > > + // this point. We say black conservatively. > > + cell->setCellState(CellState::PossiblyBlack); > > What's the point of doing this if we fall through to the code below that > does greying? > Maybe it should return here? That's true - it *should* return here. We already confirmed above that the object was not marked immediately after the store that this barrier is protecting. This means that the object had since been marked normally, and has most likely been scanned the normal way. There is no need to barrier the object now. In fact, we can return early no matter what happens in the !isMarkedConcurrently path. There is no need to remember the object if it was not marked at the time that the barrier slow path ran. 1265480 8 fpizlo 2017-01-10 12:05:04 -0800 (In reply to comment #4) > (In reply to comment #3) > > Comment on attachment 298444 [details] > > the patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=298444&action=review > > > > r=me > > > > > Source/JavaScriptCore/heap/CellState.h:45 > > > +// The CellState of a cell is a kind of hint about what the state of the cell is. > > > enum class CellState : uint8_t { > > > // The object is either currently being scanned, or it has finished being scanned, or this > > > // is a full collection and it's actually a white object (you'd know because its mark bit > > > // would be clear). > > > - PossiblyOldOrBlack = 0, > > > + PossiblyBlack = 0, > > > > > > // The object is in eden. During GC, this means that the object has not been marked yet. > > > - DefinitelyNewAndWhite = 1, > > > + DefinitelyWhite = 1, > > > > > > - // The object is grey - i.e. it will be scanned. > > > - DefinitelyGrey = 2, > > > + // This sorta means that the object is grey - i.e. it will be scanned. Or it could be white > > > + // during a full collection if its mark bit is clear. That would happen if it had been black, > > > + // got barriered, and we did a full collection. > > > + PossiblyGrey = 2 > > > > It would help to explain that these values indicate an upper bound on the > > visiting state of an object: > > > > Black means the object has probably transitioned all the way to Black, but > > it might still be back at Grey or White. > > > > Grey means the object has probably transitioned to Grey, but it might still > > be back at White. > > > > White means White. > > > > Otherwise, "PossiblyGrey" is ambiguous, and it's not clear why it's OK to > > skip Black object behaviors when PossiblyGrey. > > > > You could even consider renaming to { White, GreyOrLower, BlackOrLower }, or > > renaming the enum to CellStateUpperBound. > > I get what "GreyOrLower" and "BlackOrLower" are supposed to mean, but I > wouldn't have thought that without reading your explanation. > > There's a ton of nuance to these states. You're right that DefinitelyWhite > is the only one that has guaranteed meaning. To understand the meaning of > the other states, you have to consider the mark bit and possibly other > information. That's why after many attempts at naming these states in a > more descriptive way, I decided to go with the "Possibly" prefix for states > whose meaning has caveats and the "Definitely" prefix for the state whose > meaning has no caveats. > > > > > > Source/JavaScriptCore/heap/Heap.cpp:957 > > > + // During a full collection a store into an unmarked object that had surivived past > > > + // collections will manifest as a store to an unmarked black object. If the object gets > > > + // marked at some time after this then it will go down the normal marking path. We can > > > + // safely ignore these stores. > > > > Can we ASSERT here that we're doing a full collection? > > > > Yes. I added it. > > > "store to an unmarked black object" => "store to an unmarked possibly black > > object" > > > > Instead of "If the object....", I would say: In this situation, the object > > is actually white. By synchronizing with the GC below, we can prove that the > > object is white and update its state so it doesn't take the slow path again. > > That doesn't mean the same thing. This is speaking of the span of time > beginning immediately after the isMarkedConcurrently check, and ending at > the end of GC. During any moment in that span of time, if the object gets > marked, it will go down the normal marking path. This paragraph is > justifying why we can ignore PossiblyBlack unmarked objects. It's not meant > as a justification for the optimization below, which re-whites the object. > > I rewrote this paragraph: > > // During a full collection a store into an unmarked object that > had surivived past > // collections will manifest as a store to an unmarked > PossiblyBlack object. If the > // object gets marked at some time after this then it will go > down the normal marking > // path. So, we don't have to remember this object. We could > return here. But we go > // further and attempt to re-white the object. > > > > > > Source/JavaScriptCore/heap/Heap.cpp:973 > > > + if (cell->atomicCompareExchangeCellStateStrong(CellState::PossiblyBlack, CellState::DefinitelyWhite) == CellState::PossiblyBlack) { > > > + // Now we protect against this race: > > > + // > > > + // 1) Object starts out black + unmarked. > > > + // --> We do isMarkedConcurrently here. > > > + // 2) Object is marked and greyed. > > > + // 3) Object is scanned and blacked. > > > + // --> We do atomicCompareExchangeCellStateStrong here. > > > + // > > > + // In this case we would have made the object white again, even though it should > > > + // be black. This check lets us correct our mistake. This relies on the fact that > > > + // isMarkedConcurrently converges monotonically to true. > > > + if (!isMarkedConcurrently(cell)) { > > > + // OK - the object really deserves to be white! > > > + return; > > > + } > > > > I wonder if it would be better (i.e., simpler and not more expensive) just > > to grey the object unconditionally. > > We can't do that because that would be incorrect. A grey object will get > ignored by the barrier. You cannot grey an object that might be black. The > GC is changing the object's color using a naked store - no CAS. So, just as > we change the object's color to grey the GC could be changing it to black. > In between the !isMarkedConcurrently check and when we run our CAS, the > object could have been greyed, blackened, and scanned. Now it still looks > black. If we just change it to grey we will introduce a bug. > > > > > I think the advantage of this check-and-white approach is that it allows an > > old object to die even if we store to it during GC. I wonder if this > > advantage is really all that important for old objects, since it's > > impossible for the mutator to create a death spiral of old objects, and old > > objects tend to survive anyway. > > This isn't an optimization. We can't unblacken an object without being > extremely careful. The GC may have blackened the object to signal that the > barrier is needed. We can't forget this information. That's why we first > whiten it, and then check the mark bit again. We can prove that the bad > interleaving that I speak of would get caught by this extra check. I think that the code did have a bug, see https://bugs.webkit.org/show_bug.cgi?id=166878#c7 You're right that we could just grey the object and fall through to the barrier. Regardless of whether that approach is a good idea or not, it's clearly a major change in behavior - much bigger than this patch is right now. Right now, the patch has no effect on floating garbage, wavefronts, etc. It's just trying to make the barrier remember the fact that the object doesn't need to hit the barrier slow path next time. In trunk, we alraedy return early for black-unmarked objects. But even though the slow path returns early for those objects, we still take the slow path every time we store to those objects. So - those objects are never seen by GC except in this slow path, which rejects them immediately. If we greyed those objects, then this is a big change in behavior. Now, the GC will see - and visit - every dead object we store to during a full collection. I don't think we want that! 1265482 9 fpizlo 2017-01-10 12:06:45 -0800 Here's the new version of that re-whitening code, incorporating all of the feedback: if (!isMarkedConcurrently(cell)) { // During a full collection a store into an unmarked object that had surivived past // collections will manifest as a store to an unmarked PossiblyBlack object. If the // object gets marked at some time after this then it will go down the normal marking // path. So, we don't have to remember this object. We could return here. But we go // further and attempt to re-white the object. RELEASE_ASSERT(m_collectionScope == CollectionScope::Full); if (cell->atomicCompareExchangeCellStateStrong(CellState::PossiblyBlack, CellState::DefinitelyWhite) == CellState::PossiblyBlack) { // Now we protect against this race: // // 1) Object starts out black + unmarked. // --> We do isMarkedConcurrently here. // 2) Object is marked and greyed. // 3) Object is scanned and blacked. // --> We do atomicCompareExchangeCellStateStrong here. // // In this case we would have made the object white again, even though it should // be black. This check lets us correct our mistake. This relies on the fact that // isMarkedConcurrently converges monotonically to true. if (isMarkedConcurrently(cell)) { // It's difficult to work out whether the object should be grey or black at // this point. We say black conservatively. cell->setCellState(CellState::PossiblyBlack); } // Either way, we can return. Most likely, the object was not marked, and so the // object is now labeled white. This means that future barrier executions will not // fire. In the unlikely even that the object had become marked, we can still // return anyway, since we proved that the object was not marked at the time that // we executed this slow path. } return; } 1265563 10 fpizlo 2017-01-10 15:43:15 -0800 Landed in https://trac.webkit.org/changeset/210565 1265882 11 ggaren 2017-01-11 12:47:50 -0800 > If we greyed those objects, then this is a big change in behavior. Now, the > GC will see - and visit - every dead object we store to during a full > collection. I don't think we want that! Every dead *old* object. New objects won't take this path because we allocate White. 1265899 12 fpizlo 2017-01-11 13:49:03 -0800 (In reply to comment #11) > > If we greyed those objects, then this is a big change in behavior. Now, the > > GC will see - and visit - every dead object we store to during a full > > collection. I don't think we want that! > > Every dead *old* object. New objects won't take this path because we > allocate White. Right! In splay a stray pointer from the past might keep a huge sub tree alive. We want to be precise about this. 298444 2017-01-09 21:00:39 -0800 2017-01-10 11:58:51 -0800 the patch blah.patch text/plain 35741 fpizlo SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjEwNTIxKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDQ3IEBA CisyMDE3LTAxLTA5ICBGaWxpcCBQaXpsbyAgPGZwaXpsb0BhcHBsZS5jb20+CisKKyAgICAgICAg U3RyZWFtbGluZSB0aGUgR0MgYmFycmllciBzbG93cGF0aAorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTY2ODc4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisgICAgICAgIAorICAgICAgICBUaGlzIGltcGxlbWVudHMgdHdvIG9w dGltaXphdGlvbnMgdG8gdGhlIGJhcnJpZXI6CisgICAgICAgIAorICAgICAgICAtIFJlbW92ZXMg dGhlIHdyaXRlIGJhcnJpZXIgYnVmZmVyLiBUaGlzIHdhcyBqdXN0IG92ZXJoZWFkLgorICAgICAg ICAKKyAgICAgICAgLSBUZWFjaGVzIHRoZSBzbG93IHBhdGggaG93IHRvIHdoaXRlIGFuIG9iamVj dCB0aGF0IHdhcyBibGFjayBidXQgdW5tYXJrZWQsIGVuc3VyaW5nIHRoYXQKKyAgICAgICAgICB3 ZSBkb24ndCB0YWtlIHNsb3cgcGF0aCBmb3IgdGhpcyBvYmplY3QgYWdhaW4uCisKKyAgICAgICAg KiBKYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIGRm Zy9ERkdTcGVjdWxhdGl2ZUpJVC5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6U3BlY3VsYXRpdmVK SVQ6OmNvbXBpbGVTdG9yZUJhcnJpZXIpOgorICAgICAgICAqIGZ0bC9GVExMb3dlckRGR1RvQjMu Y3BwOgorICAgICAgICAoSlNDOjpGVEw6OkRGRzo6TG93ZXJERkdUb0IzOjplbWl0U3RvcmVCYXJy aWVyKToKKyAgICAgICAgKiBoZWFwL0NlbGxTdGF0ZS5oOgorICAgICAgICAqIGhlYXAvSGVhcC5j cHA6CisgICAgICAgIChKU0M6OkhlYXA6OkhlYXApOgorICAgICAgICAoSlNDOjpIZWFwOjptYXJr VG9GaXhwb2ludCk6CisgICAgICAgIChKU0M6OkhlYXA6OmFkZFRvUmVtZW1iZXJlZFNldCk6Cisg ICAgICAgIChKU0M6OkhlYXA6OnN0b3BUaGVXb3JsZCk6CisgICAgICAgIChKU0M6OkhlYXA6Ondy aXRlQmFycmllclNsb3dQYXRoKToKKyAgICAgICAgKEpTQzo6SGVhcDo6YnVpbGRDb25zdHJhaW50 U2V0KToKKyAgICAgICAgKEpTQzo6SGVhcDo6Zmx1c2hXcml0ZUJhcnJpZXJCdWZmZXIpOiBEZWxl dGVkLgorICAgICAgICAqIGhlYXAvSGVhcC5oOgorICAgICAgICAoSlNDOjpIZWFwOjp3cml0ZUJh cnJpZXJCdWZmZXIpOiBEZWxldGVkLgorICAgICAgICAqIGhlYXAvU2xvdFZpc2l0b3IuY3BwOgor ICAgICAgICAoSlNDOjpTbG90VmlzaXRvcjo6YXBwZW5kSlNDZWxsT3JBdXhpbGlhcnkpOgorICAg ICAgICAoSlNDOjpTbG90VmlzaXRvcjo6c2V0TWFya2VkQW5kQXBwZW5kVG9NYXJrU3RhY2spOgor ICAgICAgICAoSlNDOjpTbG90VmlzaXRvcjo6YXBwZW5kVG9NYXJrU3RhY2spOgorICAgICAgICAo SlNDOjpTbG90VmlzaXRvcjo6dmlzaXRDaGlsZHJlbik6CisgICAgICAgICogaGVhcC9Xcml0ZUJh cnJpZXJCdWZmZXIuY3BwOiBSZW1vdmVkLgorICAgICAgICAqIGhlYXAvV3JpdGVCYXJyaWVyQnVm ZmVyLmg6IFJlbW92ZWQuCisgICAgICAgICogaml0L0pJVE9wZXJhdGlvbnMuY3BwOgorICAgICAg ICAqIGppdC9KSVRPcGVyYXRpb25zLmg6CisgICAgICAgICogcnVudGltZS9KU0NlbGxJbmxpbmVz Lmg6CisgICAgICAgIChKU0M6OkpTQ2VsbDo6SlNDZWxsKToKKyAgICAgICAgKiBydW50aW1lL1N0 cnVjdHVyZUlEQmxvYi5oOgorICAgICAgICAoSlNDOjpTdHJ1Y3R1cmVJREJsb2I6OlN0cnVjdHVy ZUlEQmxvYik6CisKIDIwMTctMDEtMDggIEZpbGlwIFBpemxvICA8ZnBpemxvQGFwcGxlLmNvbT4K IAogICAgICAgICBNYWtlIHRoZSBjb2xsZWN0b3IncyBmaXhwb2ludCBzbWFydCBhYm91dCBzY2hl ZHVsaW5nIHdvcmsKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DTWFrZUxpc3RzLnR4dAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvQ01ha2VMaXN0cy50eHQJKHJldmlz aW9uIDIxMDUyMSkKKysrIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DTWFrZUxpc3RzLnR4dAkod29y a2luZyBjb3B5KQpAQCAtNTEwLDcgKzUxMCw2IEBAIHNldChKYXZhU2NyaXB0Q29yZV9TT1VSQ0VT CiAgICAgaGVhcC9XZWFrQmxvY2suY3BwCiAgICAgaGVhcC9XZWFrSGFuZGxlT3duZXIuY3BwCiAg ICAgaGVhcC9XZWFrU2V0LmNwcAotICAgIGhlYXAvV3JpdGVCYXJyaWVyQnVmZmVyLmNwcAogICAg IGhlYXAvV3JpdGVCYXJyaWVyU3VwcG9ydC5jcHAKIAogICAgIGluc3BlY3Rvci9Db25zb2xlTWVz c2FnZS5jcHAKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAyMTA1 MjEpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpAQCAtMTIzMCw4ICsxMjMwLDYgQEAKIAkJMkEx MTEyNDYxOTJGQ0U3OTAwNUVFMThEIC8qIEN1c3RvbUdldHRlclNldHRlci5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkExMTEyNDQxOTJGQ0U3OTAwNUVF MThEIC8qIEN1c3RvbUdldHRlclNldHRlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCTJBNDhEMTkxMTc3MjM2NUIwMEM2NUE1RiAvKiBBUElDYWxs YmFja0Z1bmN0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBDMjExQjU3NDE3NkEyMjREMDAwRTJBMjMgLyogQVBJQ2FsbGJhY2tGdW5jdGlvbi5oICov OyB9OwogCQkyQTRCQjdGMzE4QTQxMTc5MDA4QTBGQ0QgLyogSlNNYW5hZ2VkVmFsdWVJbnRlcm5h bC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkE0QkI3 RjIxOEE0MTE3OTAwOEEwRkNEIC8qIEpTTWFuYWdlZFZhbHVlSW50ZXJuYWwuaCAqLzsgfTsKLQkJ MkE0RUM5MEIxODYwRDZDMjAwOTRGNzgyIC8qIFdyaXRlQmFycmllckJ1ZmZlci5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQTRFQzkwOTE4NjBENkMy MDA5NEY3ODIgLyogV3JpdGVCYXJyaWVyQnVmZmVyLmNwcCAqLzsgfTsKLQkJMkE0RUM5MEMxODYw RDZDMjAwOTRGNzgyIC8qIFdyaXRlQmFycmllckJ1ZmZlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkE0RUM5MEExODYwRDZDMjAwOTRGNzgyIC8qIFdy aXRlQmFycmllckJ1ZmZlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUs ICk7IH07IH07CiAJCTJBN0E1OEVGMTgwOEE0QzQwMDIwQkRGNyAvKiBEZWZlckdDLmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDJBN0E1OEVFMTgwOEE0 QzQwMDIwQkRGNyAvKiBEZWZlckdDLmNwcCAqLzsgfTsKIAkJMkE4MzYzODUxOEQ3RDBFRTAwMDBF QkNDIC8qIEVkZW5HQ0FjdGl2aXR5Q2FsbGJhY2suY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMkE4MzYzODMxOEQ3RDBFRTAwMDBFQkNDIC8qIEVkZW5H Q0FjdGl2aXR5Q2FsbGJhY2suY3BwICovOyB9OwogCQkyQTgzNjM4NjE4RDdEMEVFMDAwMEVCQ0Mg LyogRWRlbkdDQWN0aXZpdHlDYWxsYmFjay5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gMkE4MzYzODQxOEQ3RDBFRTAwMDBFQkNDIC8qIEVkZW5HQ0FjdGl2 aXR5Q2FsbGJhY2suaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9 OyB9OwpAQCAtMzYzNyw4ICszNjM1LDYgQEAKIAkJMkEzNDNGNzQxOEExNzQ4QjAwMzlCMDg1IC8q IEdDU2VnbWVudGVkQXJyYXkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gR0NT ZWdtZW50ZWRBcnJheS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkyQTM0M0Y3NzE4 QTE3NDlEMDAzOUIwODUgLyogR0NTZWdtZW50ZWRBcnJheUlubGluZXMuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gR0NTZWdtZW50ZWRBcnJheUlubGluZXMuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMkE0QkI3RjIxOEE0MTE3OTAwOEEwRkNEIC8qIEpTTWFuYWdl ZFZhbHVlSW50ZXJuYWwuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNNYW5h Z2VkVmFsdWVJbnRlcm5hbC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQkyQTRFQzkw OTE4NjBENkMyMDA5NEY3ODIgLyogV3JpdGVCYXJyaWVyQnVmZmVyLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdyaXRlQmFycmllckJ1ZmZlci5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07Ci0JCTJBNEVDOTBBMTg2MEQ2QzIwMDk0Rjc4MiAvKiBXcml0ZUJh cnJpZXJCdWZmZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV3JpdGVCYXJy aWVyQnVmZmVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTJBN0E1OEVFMTgwOEE0 QzQwMDIwQkRGNyAvKiBEZWZlckdDLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IERlZmVyR0MuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkyQTgzNjM4 MzE4RDdEMEVFMDAwMEVCQ0MgLyogRWRlbkdDQWN0aXZpdHlDYWxsYmFjay5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBFZGVuR0NBY3Rpdml0eUNhbGxiYWNrLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMkE4MzYzODQxOEQ3RDBFRTAwMDBFQkNDIC8q IEVkZW5HQ0FjdGl2aXR5Q2FsbGJhY2suaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gRWRlbkdDQWN0aXZpdHlDYWxsYmFjay5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpA QCAtNTgxNCw4ICs1ODEwLDYgQEAKIAkJCQkxNEU4NEY5QjE0RUUxQUNDMDBENkQ1RDQgLyogV2Vh a1NldC5jcHAgKi8sCiAJCQkJMTRFODRGOUMxNEVFMUFDQzAwRDZENUQ0IC8qIFdlYWtTZXQuaCAq LywKIAkJCQkxNDE1MDEzMjE1NEJCMTNGMDA1RDhDOTggLyogV2Vha1NldElubGluZXMuaCAqLywK LQkJCQkyQTRFQzkwOTE4NjBENkMyMDA5NEY3ODIgLyogV3JpdGVCYXJyaWVyQnVmZmVyLmNwcCAq LywKLQkJCQkyQTRFQzkwQTE4NjBENkMyMDA5NEY3ODIgLyogV3JpdGVCYXJyaWVyQnVmZmVyLmgg Ki8sCiAJCQkJMEZDODE1MDgxNDA0M0JDQTAwQ0ZBNjAzIC8qIFdyaXRlQmFycmllclN1cHBvcnQu Y3BwICovLAogCQkJCTBGQzgxNTA5MTQwNDNCRDIwMENGQTYwMyAvKiBXcml0ZUJhcnJpZXJTdXBw b3J0LmggKi8sCiAJCQkpOwpAQCAtOTEwMiw3ICs5MDk2LDYgQEAKIAkJCQlBREJDNTRENTFERjhF QTJCMDA1QkY3MzggLyogV2ViQXNzZW1ibHlUb0pTQ2FsbGVlLmggaW4gSGVhZGVycyAqLywKIAkJ CQlCQzE4QzQ3QTBFMTZGNUNEMDBCMzQ0NjAgLyogV2ViS2l0QXZhaWxhYmlsaXR5LmggaW4gSGVh ZGVycyAqLywKIAkJCQlBN0RDQjk3MzEyRTUxOTNGMDA5MTE5NDAgLyogV3JpdGVCYXJyaWVyLmgg aW4gSGVhZGVycyAqLywKLQkJCQkyQTRFQzkwQzE4NjBENkMyMDA5NEY3ODIgLyogV3JpdGVCYXJy aWVyQnVmZmVyLmggaW4gSGVhZGVycyAqLywKIAkJCQlDMkI2RDc1MzE4QTMzNzkzMDA0QTkzMDEg LyogV3JpdGVCYXJyaWVySW5saW5lcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEZDODE1MEExNDA0 M0JGNTAwQ0ZBNjAzIC8qIFdyaXRlQmFycmllclN1cHBvcnQuaCBpbiBIZWFkZXJzICovLAogCQkJ CTk2ODhDQjE2MEVEMTJCNEUwMDFENjQ5RiAvKiBYODZBc3NlbWJsZXIuaCBpbiBIZWFkZXJzICov LApAQCAtMTA0OTMsNyArMTA0ODYsNiBAQAogCQkJCUFEMkZDQkZDMURCNThEQUQwMEIzRTczNiAv KiBXZWJBc3NlbWJseVRhYmxlQ29uc3RydWN0b3IuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQUQy RkNCRkUxREI1OERBRDAwQjNFNzM2IC8qIFdlYkFzc2VtYmx5VGFibGVQcm90b3R5cGUuY3BwIGlu IFNvdXJjZXMgKi8sCiAJCQkJQURCQzU0RDQxREY4RUEyQjAwNUJGNzM4IC8qIFdlYkFzc2VtYmx5 VG9KU0NhbGxlZS5jcHAgaW4gU291cmNlcyAqLywKLQkJCQkyQTRFQzkwQjE4NjBENkMyMDA5NEY3 ODIgLyogV3JpdGVCYXJyaWVyQnVmZmVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTBGQzgxNTBC MTQwNDNDMEUwMENGQTYwMyAvKiBXcml0ZUJhcnJpZXJTdXBwb3J0LmNwcCBpbiBTb3VyY2VzICov LAogCQkJCUE3RTVBQjNBMTc5OUU0QjIwMEQyODMzRCAvKiBYODZEaXNhc3NlbWJsZXIuY3BwIGlu IFNvdXJjZXMgKi8sCiAJCQkJODYzQzZEOUMxNTIxMTExQTAwNTg1RTRFIC8qIFlhcnJDYW5vbmlj YWxpemVVQ1MyLmNwcCBpbiBTb3VyY2VzICovLApJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3Jl L2RmZy9ERkdTcGVjdWxhdGl2ZUpJVC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3Jp cHRDb3JlL2RmZy9ERkdTcGVjdWxhdGl2ZUpJVC5jcHAJKHJldmlzaW9uIDIxMDUyMSkKKysrIFNv dXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHU3BlY3VsYXRpdmVKSVQuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMS0yMDE2IEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMS0yMDE3IEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucwpAQCAtNjAsNyArNjAsNiBAQAogI2luY2x1ZGUgIlJlZ0V4cENvbnN0cnVjdG9yLmgiCiAj aW5jbHVkZSAiU2NvcGVkQXJndW1lbnRzLmgiCiAjaW5jbHVkZSAiU2NyYXRjaFJlZ2lzdGVyQWxs b2NhdG9yLmgiCi0jaW5jbHVkZSAiV3JpdGVCYXJyaWVyQnVmZmVyLmgiCiAjaW5jbHVkZSA8d3Rm L0JpdFZlY3Rvci5oPgogI2luY2x1ZGUgPHd0Zi9Cb3guaD4KICNpbmNsdWRlIDx3dGYvTWF0aEV4 dHJhcy5oPgpAQCAtODkwNSwxMSArODkwNCw5IEBAIHZvaWQgU3BlY3VsYXRpdmVKSVQ6OmNvbXBp bGVTdG9yZUJhcnJpZXIKICAgICAKICAgICBTcGVjdWxhdGVDZWxsT3BlcmFuZCBiYXNlKHRoaXMs IG5vZGUtPmNoaWxkMSgpKTsKICAgICBHUFJUZW1wb3Jhcnkgc2NyYXRjaDEodGhpcyk7Ci0gICAg R1BSVGVtcG9yYXJ5IHNjcmF0Y2gyKHRoaXMpOwogICAgIAogICAgIEdQUlJlZyBiYXNlR1BSID0g YmFzZS5ncHIoKTsKICAgICBHUFJSZWcgc2NyYXRjaDFHUFIgPSBzY3JhdGNoMS5ncHIoKTsKLSAg ICBHUFJSZWcgc2NyYXRjaDJHUFIgPSBzY3JhdGNoMi5ncHIoKTsKICAgICAKICAgICBKSVRDb21w aWxlcjo6SnVtcExpc3Qgb2s7CiAgICAgCkBAIC04OTIzLDIyICs4OTIwLDggQEAgdm9pZCBTcGVj dWxhdGl2ZUpJVDo6Y29tcGlsZVN0b3JlQmFycmllcgogICAgIH0gZWxzZQogICAgICAgICBvay5h cHBlbmQobV9qaXQuYmFycmllckJyYW5jaFdpdGhvdXRGZW5jZShiYXNlR1BSKSk7CiAKLSAgICBX cml0ZUJhcnJpZXJCdWZmZXImIHdyaXRlQmFycmllckJ1ZmZlciA9IG1faml0LnZtKCktPmhlYXAu bV93cml0ZUJhcnJpZXJCdWZmZXI7Ci0gICAgbV9qaXQubG9hZDMyKHdyaXRlQmFycmllckJ1ZmZl ci5jdXJyZW50SW5kZXhBZGRyZXNzKCksIHNjcmF0Y2gyR1BSKTsKLSAgICBKSVRDb21waWxlcjo6 SnVtcCBuZWVkVG9GbHVzaCA9IG1faml0LmJyYW5jaDMyKE1hY3JvQXNzZW1ibGVyOjpBYm92ZU9y RXF1YWwsIHNjcmF0Y2gyR1BSLCBNYWNyb0Fzc2VtYmxlcjo6VHJ1c3RlZEltbTMyKHdyaXRlQmFy cmllckJ1ZmZlci5jYXBhY2l0eSgpKSk7Ci0KLSAgICBtX2ppdC5hZGQzMihUcnVzdGVkSW1tMzIo MSksIHNjcmF0Y2gyR1BSKTsKLSAgICBtX2ppdC5zdG9yZTMyKHNjcmF0Y2gyR1BSLCB3cml0ZUJh cnJpZXJCdWZmZXIuY3VycmVudEluZGV4QWRkcmVzcygpKTsKLQotICAgIG1faml0Lm1vdmUoVHJ1 c3RlZEltbVB0cih3cml0ZUJhcnJpZXJCdWZmZXIuYnVmZmVyKCkpLCBzY3JhdGNoMUdQUik7Ci0g ICAgLy8gV2UgdXNlIGFuIG9mZnNldCBvZiAtc2l6ZW9mKHZvaWQqKSBiZWNhdXNlIHdlIGFscmVh ZHkgYWRkZWQgMSB0byBzY3JhdGNoMi4KLSAgICBtX2ppdC5zdG9yZVB0cihiYXNlR1BSLCBNYWNy b0Fzc2VtYmxlcjo6QmFzZUluZGV4KHNjcmF0Y2gxR1BSLCBzY3JhdGNoMkdQUiwgTWFjcm9Bc3Nl bWJsZXI6OlNjYWxlUHRyLCBzdGF0aWNfY2FzdDxpbnQzMl90Pigtc2l6ZW9mKHZvaWQqKSkpKTsK LQotICAgIG9rLmFwcGVuZChtX2ppdC5qdW1wKCkpOwotICAgIG5lZWRUb0ZsdXNoLmxpbmsoJm1f aml0KTsKLQogICAgIHNpbGVudFNwaWxsQWxsUmVnaXN0ZXJzKEludmFsaWRHUFJSZWcpOwotICAg IGNhbGxPcGVyYXRpb24ob3BlcmF0aW9uRmx1c2hXcml0ZUJhcnJpZXJCdWZmZXIsIGJhc2VHUFIp OworICAgIGNhbGxPcGVyYXRpb24ob3BlcmF0aW9uV3JpdGVCYXJyaWVyU2xvd1BhdGgsIGJhc2VH UFIpOwogICAgIHNpbGVudEZpbGxBbGxSZWdpc3RlcnMoSW52YWxpZEdQUlJlZyk7CiAKICAgICBv ay5saW5rKCZtX2ppdCk7CkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRsL0ZUTExvd2Vy REZHVG9CMy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2Z0bC9GVExM b3dlckRGR1RvQjMuY3BwCShyZXZpc2lvbiAyMTA1MjEpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENv cmUvZnRsL0ZUTExvd2VyREZHVG9CMy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw1IEBA CiAvKgotICogQ29weXJpZ2h0IChDKSAyMDEzLTIwMTYgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDEzLTIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0xMjk2MCw4ICsx Mjk2MCwxMyBAQCBwcml2YXRlOgogCiAgICAgdm9pZCBlbWl0U3RvcmVCYXJyaWVyKExWYWx1ZSBi YXNlLCBib29sIGlzRmVuY2VkKQogICAgIHsKKyAgICAgICAgTEJhc2ljQmxvY2sgcmVjaGVja1Bh dGggPSBudWxscHRyOworICAgICAgICBpZiAoaXNGZW5jZWQpCisgICAgICAgICAgICByZWNoZWNr UGF0aCA9IG1fb3V0Lm5ld0Jsb2NrKCk7CiAgICAgICAgIExCYXNpY0Jsb2NrIHNsb3dQYXRoID0g bV9vdXQubmV3QmxvY2soKTsKICAgICAgICAgTEJhc2ljQmxvY2sgY29udGludWF0aW9uID0gbV9v dXQubmV3QmxvY2soKTsKKyAgICAgICAgCisgICAgICAgIExCYXNpY0Jsb2NrIGxhc3ROZXh0ID0g bV9vdXQuaW5zZXJ0TmV3QmxvY2tzQmVmb3JlKGlzRmVuY2VkID8gcmVjaGVja1BhdGggOiBzbG93 UGF0aCk7CiAKICAgICAgICAgTFZhbHVlIHRocmVzaG9sZDsKICAgICAgICAgaWYgKGlzRmVuY2Vk KQpAQCAtMTI5NzEsNzYgKzEyOTc2LDIzIEBAIHByaXZhdGU6CiAgICAgICAgIAogICAgICAgICBt X291dC5icmFuY2goCiAgICAgICAgICAgICBtX291dC5hYm92ZShsb2FkQ2VsbFN0YXRlKGJhc2Up LCB0aHJlc2hvbGQpLAotICAgICAgICAgICAgdXN1YWxseShjb250aW51YXRpb24pLCByYXJlbHko c2xvd1BhdGgpKTsKLQotICAgICAgICBMQmFzaWNCbG9jayBsYXN0TmV4dCA9IG1fb3V0LmFwcGVu ZFRvKHNsb3dQYXRoLCBjb250aW51YXRpb24pOworICAgICAgICAgICAgdXN1YWxseShjb250aW51 YXRpb24pLCByYXJlbHkoaXNGZW5jZWQgPyByZWNoZWNrUGF0aCA6IHNsb3dQYXRoKSk7CiAgICAg ICAgIAotICAgICAgICAvLyBXZSBlbWl0IHRoZSBzdG9yZSBiYXJyaWVyIHNsb3cgcGF0aCBsYXpp bHkuIEluIGEgbG90IG9mIGNhc2VzLCB0aGlzIHdpbGwgbmV2ZXIgZmlyZS4gQW5kCi0gICAgICAg IC8vIHdoZW4gaXQgZG9lcyBmaXJlLCBpdCBtYWtlcyBzZW5zZSBmb3IgdXMgdG8gZ2VuZXJhdGUg dGhpcyBjb2RlIHVzaW5nIG91ciBKSVQgcmF0aGVyIHRoYW4KLSAgICAgICAgLy8gd2FzdGluZyBC MydzIHRpbWUgb3B0aW1pemluZyBpdC4KLSAgICAgICAgUGF0Y2hwb2ludFZhbHVlKiBwYXRjaHBv aW50ID0gbGF6eVNsb3dQYXRoKAotICAgICAgICAgICAgWz1dIChjb25zdCBWZWN0b3I8TG9jYXRp b24+JiBsb2NhdGlvbnMpIC0+IFJlZlB0cjxMYXp5U2xvd1BhdGg6OkdlbmVyYXRvcj4gewotICAg ICAgICAgICAgICAgIEdQUlJlZyBiYXNlR1BSID0gbG9jYXRpb25zWzFdLmRpcmVjdEdQUigpOwot Ci0gICAgICAgICAgICAgICAgcmV0dXJuIExhenlTbG93UGF0aDo6Y3JlYXRlR2VuZXJhdG9yKAot ICAgICAgICAgICAgICAgICAgICBbPV0gKENDYWxsSGVscGVycyYgaml0LCBMYXp5U2xvd1BhdGg6 OkdlbmVyYXRpb25QYXJhbXMmIHBhcmFtcykgewotICAgICAgICAgICAgICAgICAgICAgICAgaWYg KGlzRmVuY2VkKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpK dW1wIG5vRmVuY2UgPSBqaXQuanVtcElmTXV0YXRvckZlbmNlTm90TmVlZGVkKCk7Ci0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgaml0Lm1lbW9yeUZlbmNlKCk7Ci0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgcGFyYW1zLmRvbmVKdW1wcy5hcHBlbmQoaml0LmJhcnJpZXJCcmFuY2hXaXRo b3V0RmVuY2UoYmFzZUdQUikpOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5vRmVuY2Uu bGluaygmaml0KTsKLSAgICAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAg ICAgICAgIAotICAgICAgICAgICAgICAgICAgICAgICAgUmVnaXN0ZXJTZXQgdXNlZFJlZ2lzdGVy cyA9IHBhcmFtcy5sYXp5U2xvd1BhdGgtPnVzZWRSZWdpc3RlcnMoKTsKLSAgICAgICAgICAgICAg ICAgICAgICAgIFNjcmF0Y2hSZWdpc3RlckFsbG9jYXRvciBzY3JhdGNoUmVnaXN0ZXJBbGxvY2F0 b3IodXNlZFJlZ2lzdGVycyk7Ci0gICAgICAgICAgICAgICAgICAgICAgICBzY3JhdGNoUmVnaXN0 ZXJBbGxvY2F0b3IubG9jayhiYXNlR1BSKTsKLQotICAgICAgICAgICAgICAgICAgICAgICAgR1BS UmVnIHNjcmF0Y2gxID0gc2NyYXRjaFJlZ2lzdGVyQWxsb2NhdG9yLmFsbG9jYXRlU2NyYXRjaEdQ UigpOwotICAgICAgICAgICAgICAgICAgICAgICAgR1BSUmVnIHNjcmF0Y2gyID0gc2NyYXRjaFJl Z2lzdGVyQWxsb2NhdG9yLmFsbG9jYXRlU2NyYXRjaEdQUigpOwotCi0gICAgICAgICAgICAgICAg ICAgICAgICBTY3JhdGNoUmVnaXN0ZXJBbGxvY2F0b3I6OlByZXNlcnZlZFN0YXRlIHByZXNlcnZl ZFN0YXRlID0KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBzY3JhdGNoUmVnaXN0ZXJBbGxv Y2F0b3IucHJlc2VydmVSZXVzZWRSZWdpc3RlcnNCeVB1c2hpbmcoaml0LCBTY3JhdGNoUmVnaXN0 ZXJBbGxvY2F0b3I6OkV4dHJhU3RhY2tTcGFjZTo6U3BhY2VGb3JDQ2FsbCk7Ci0KLSAgICAgICAg ICAgICAgICAgICAgICAgIC8vIFdlJ3ZlIGFscmVhZHkgc2F2ZWQgdGhlc2UsIHNvIHdoZW4gd2Ug bWFrZSBhIHNsb3cgcGF0aCBjYWxsLCB3ZSBkb24ndCBoYXZlCi0gICAgICAgICAgICAgICAgICAg ICAgICAvLyB0byBzYXZlIHRoZW0gYWdhaW4uCi0gICAgICAgICAgICAgICAgICAgICAgICB1c2Vk UmVnaXN0ZXJzLmV4Y2x1ZGUoUmVnaXN0ZXJTZXQoc2NyYXRjaDEsIHNjcmF0Y2gyKSk7Ci0KLSAg ICAgICAgICAgICAgICAgICAgICAgIFdyaXRlQmFycmllckJ1ZmZlciYgd3JpdGVCYXJyaWVyQnVm ZmVyID0gaml0LnZtKCktPmhlYXAud3JpdGVCYXJyaWVyQnVmZmVyKCk7Ci0gICAgICAgICAgICAg ICAgICAgICAgICBqaXQubG9hZDMyKHdyaXRlQmFycmllckJ1ZmZlci5jdXJyZW50SW5kZXhBZGRy ZXNzKCksIHNjcmF0Y2gyKTsKLSAgICAgICAgICAgICAgICAgICAgICAgIENDYWxsSGVscGVyczo6 SnVtcCBuZWVkVG9GbHVzaCA9IGppdC5icmFuY2gzMigKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICBDQ2FsbEhlbHBlcnM6OkFib3ZlT3JFcXVhbCwgc2NyYXRjaDIsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgQ0NhbGxIZWxwZXJzOjpUcnVzdGVkSW1tMzIod3JpdGVCYXJyaWVyQnVm ZmVyLmNhcGFjaXR5KCkpKTsKLQotICAgICAgICAgICAgICAgICAgICAgICAgaml0LmFkZDMyKEND YWxsSGVscGVyczo6VHJ1c3RlZEltbTMyKDEpLCBzY3JhdGNoMik7Ci0gICAgICAgICAgICAgICAg ICAgICAgICBqaXQuc3RvcmUzMihzY3JhdGNoMiwgd3JpdGVCYXJyaWVyQnVmZmVyLmN1cnJlbnRJ bmRleEFkZHJlc3MoKSk7Ci0KLSAgICAgICAgICAgICAgICAgICAgICAgIGppdC5tb3ZlKENDYWxs SGVscGVyczo6VHJ1c3RlZEltbVB0cih3cml0ZUJhcnJpZXJCdWZmZXIuYnVmZmVyKCkpLCBzY3Jh dGNoMSk7Ci0gICAgICAgICAgICAgICAgICAgICAgICBqaXQuc3RvcmVQdHIoCi0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgYmFzZUdQUiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBD Q2FsbEhlbHBlcnM6OkJhc2VJbmRleCgKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg c2NyYXRjaDEsIHNjcmF0Y2gyLCBDQ2FsbEhlbHBlcnM6OlNjYWxlUHRyLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBzdGF0aWNfY2FzdDxpbnQzMl90Pigtc2l6ZW9mKHZvaWQqKSkp KTsKLQotICAgICAgICAgICAgICAgICAgICAgICAgc2NyYXRjaFJlZ2lzdGVyQWxsb2NhdG9yLnJl c3RvcmVSZXVzZWRSZWdpc3RlcnNCeVBvcHBpbmcoaml0LCBwcmVzZXJ2ZWRTdGF0ZSk7Ci0KLSAg ICAgICAgICAgICAgICAgICAgICAgIHBhcmFtcy5kb25lSnVtcHMuYXBwZW5kKGppdC5qdW1wKCkp OworICAgICAgICBpZiAoaXNGZW5jZWQpIHsKKyAgICAgICAgICAgIG1fb3V0LmFwcGVuZFRvKHJl Y2hlY2tQYXRoLCBzbG93UGF0aCk7CisgICAgICAgICAgICAKKyAgICAgICAgICAgIG1fb3V0LmZl bmNlKCZtX2hlYXBzLnJvb3QsICZtX2hlYXBzLkpTQ2VsbF9jZWxsU3RhdGUpOworICAgICAgICAg ICAgCisgICAgICAgICAgICBtX291dC5icmFuY2goCisgICAgICAgICAgICAgICAgbV9vdXQuYWJv dmUobG9hZENlbGxTdGF0ZShiYXNlKSwgbV9vdXQuY29uc3RJbnQzMihibGFja1RocmVzaG9sZCkp LAorICAgICAgICAgICAgICAgIHVzdWFsbHkoY29udGludWF0aW9uKSwgcmFyZWx5KHNsb3dQYXRo KSk7CisgICAgICAgIH0KIAotICAgICAgICAgICAgICAgICAgICAgICAgbmVlZFRvRmx1c2gubGlu aygmaml0KTsKLSAgICAgICAgICAgICAgICAgICAgICAgIGNhbGxPcGVyYXRpb24oCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgdXNlZFJlZ2lzdGVycywgaml0LCBwYXJhbXMubGF6eVNsb3dQ YXRoLT5jYWxsU2l0ZUluZGV4KCksCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcGFyYW1z LmV4Y2VwdGlvbkp1bXBzLCBvcGVyYXRpb25GbHVzaFdyaXRlQmFycmllckJ1ZmZlciwgSW52YWxp ZEdQUlJlZywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBiYXNlR1BSKTsKLSAgICAgICAg ICAgICAgICAgICAgICAgIHNjcmF0Y2hSZWdpc3RlckFsbG9jYXRvci5yZXN0b3JlUmV1c2VkUmVn aXN0ZXJzQnlQb3BwaW5nKGppdCwgcHJlc2VydmVkU3RhdGUpOwotICAgICAgICAgICAgICAgICAg ICAgICAgcGFyYW1zLmRvbmVKdW1wcy5hcHBlbmQoaml0Lmp1bXAoKSk7Ci0gICAgICAgICAgICAg ICAgICAgIH0pOwotICAgICAgICAgICAgfSwKLSAgICAgICAgICAgIGJhc2UpOworICAgICAgICBt X291dC5hcHBlbmRUbyhzbG93UGF0aCwgY29udGludWF0aW9uKTsKICAgICAgICAgCi0gICAgICAg IGlmIChpc0ZlbmNlZCkKLSAgICAgICAgICAgIG1faGVhcHMuZGVjb3JhdGVQYXRjaHBvaW50UmVh ZCgmbV9oZWFwcy5yb290LCBwYXRjaHBvaW50KTsKLSAgICAgICAgZWxzZQotICAgICAgICAgICAg bV9oZWFwcy5kZWNvcmF0ZVBhdGNocG9pbnRSZWFkKCZtX2hlYXBzLkpTQ2VsbF9jZWxsU3RhdGUs IHBhdGNocG9pbnQpOwotICAgICAgICBtX2hlYXBzLmRlY29yYXRlUGF0Y2hwb2ludFdyaXRlKCZt X2hlYXBzLkpTQ2VsbF9jZWxsU3RhdGUsIHBhdGNocG9pbnQpOworICAgICAgICBMVmFsdWUgY2Fs bCA9IHZtQ2FsbChWb2lkLCBtX291dC5vcGVyYXRpb24ob3BlcmF0aW9uV3JpdGVCYXJyaWVyU2xv d1BhdGgpLCBtX2NhbGxGcmFtZSwgYmFzZSk7CisgICAgICAgIG1faGVhcHMuZGVjb3JhdGVDQ2Fs bFJlYWQoJm1faGVhcHMucm9vdCwgY2FsbCk7CisgICAgICAgIG1faGVhcHMuZGVjb3JhdGVDQ2Fs bFdyaXRlKCZtX2hlYXBzLkpTQ2VsbF9jZWxsU3RhdGUsIGNhbGwpOwogICAgICAgICAKICAgICAg ICAgbV9vdXQuanVtcChjb250aW51YXRpb24pOwogCkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENv cmUvaGVhcC9DZWxsU3RhdGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUv aGVhcC9DZWxsU3RhdGUuaAkocmV2aXNpb24gMjEwNTIxKQorKysgU291cmNlL0phdmFTY3JpcHRD b3JlL2hlYXAvQ2VsbFN0YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw1IEBACiAvKgot ICogQ29weXJpZ2h0IChDKSAyMDE1LTIwMTYgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICogQ29weXJpZ2h0IChDKSAyMDE1LTIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOSwxNyArMjksMjAgQEAK IAogbmFtZXNwYWNlIEpTQyB7CiAKKy8vIFRoZSBDZWxsU3RhdGUgb2YgYSBjZWxsIGlzIGEga2lu ZCBvZiBoaW50IGFib3V0IHdoYXQgdGhlIHN0YXRlIG9mIHRoZSBjZWxsIGlzLgogZW51bSBjbGFz cyBDZWxsU3RhdGUgOiB1aW50OF90IHsKICAgICAvLyBUaGUgb2JqZWN0IGlzIGVpdGhlciBjdXJy ZW50bHkgYmVpbmcgc2Nhbm5lZCwgb3IgaXQgaGFzIGZpbmlzaGVkIGJlaW5nIHNjYW5uZWQsIG9y IHRoaXMKICAgICAvLyBpcyBhIGZ1bGwgY29sbGVjdGlvbiBhbmQgaXQncyBhY3R1YWxseSBhIHdo aXRlIG9iamVjdCAoeW91J2Qga25vdyBiZWNhdXNlIGl0cyBtYXJrIGJpdAogICAgIC8vIHdvdWxk IGJlIGNsZWFyKS4KLSAgICBQb3NzaWJseU9sZE9yQmxhY2sgPSAwLAorICAgIFBvc3NpYmx5Qmxh Y2sgPSAwLAogICAgIAogICAgIC8vIFRoZSBvYmplY3QgaXMgaW4gZWRlbi4gRHVyaW5nIEdDLCB0 aGlzIG1lYW5zIHRoYXQgdGhlIG9iamVjdCBoYXMgbm90IGJlZW4gbWFya2VkIHlldC4KLSAgICBE ZWZpbml0ZWx5TmV3QW5kV2hpdGUgPSAxLAorICAgIERlZmluaXRlbHlXaGl0ZSA9IDEsCiAKLSAg ICAvLyBUaGUgb2JqZWN0IGlzIGdyZXkgLSBpLmUuIGl0IHdpbGwgYmUgc2Nhbm5lZC4KLSAgICBE ZWZpbml0ZWx5R3JleSA9IDIsCisgICAgLy8gVGhpcyBzb3J0YSBtZWFucyB0aGF0IHRoZSBvYmpl Y3QgaXMgZ3JleSAtIGkuZS4gaXQgd2lsbCBiZSBzY2FubmVkLiBPciBpdCBjb3VsZCBiZSB3aGl0 ZQorICAgIC8vIGR1cmluZyBhIGZ1bGwgY29sbGVjdGlvbiBpZiBpdHMgbWFyayBiaXQgaXMgY2xl YXIuIFRoYXQgd291bGQgaGFwcGVuIGlmIGl0IGhhZCBiZWVuIGJsYWNrLAorICAgIC8vIGdvdCBi YXJyaWVyZWQsIGFuZCB3ZSBkaWQgYSBmdWxsIGNvbGxlY3Rpb24uCisgICAgUG9zc2libHlHcmV5 ID0gMgogfTsKIAogc3RhdGljIGNvbnN0IHVuc2lnbmVkIGJsYWNrVGhyZXNob2xkID0gMDsgLy8g eCA8PSBibGFja1RocmVzaG9sZCBtZWFucyB4IGlzIFBvc3NpYmx5T2xkT3JCbGFjay4KSW5kZXg6 IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXAuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXAuY3BwCShyZXZpc2lvbiAyMTA1MjEpCisrKyBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvaGVhcC9IZWFwLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjYzLDcg KzI2Myw2IEBAIEhlYXA6OkhlYXAoVk0qIHZtLCBIZWFwVHlwZSBoZWFwVHlwZSkKICAgICAsIG1f Y29kZUJsb2NrcyhzdGQ6Om1ha2VfdW5pcXVlPENvZGVCbG9ja1NldD4oKSkKICAgICAsIG1faml0 U3R1YlJvdXRpbmVzKHN0ZDo6bWFrZV91bmlxdWU8SklUU3R1YlJvdXRpbmVTZXQ+KCkpCiAgICAg LCBtX2lzU2FmZVRvQ29sbGVjdChmYWxzZSkKLSAgICAsIG1fd3JpdGVCYXJyaWVyQnVmZmVyKDI1 NikKICAgICAsIG1fdm0odm0pCiAgICAgLy8gV2Ugc2VlZCB3aXRoIDEwbXMgc28gdGhhdCBHQ0Fj dGl2aXR5Q2FsbGJhY2s6OmRpZEFsbG9jYXRlIGRvZXNuJ3QgY29udGludW91c2x5IAogICAgIC8v IHNjaGVkdWxlIHRoZSB0aW1lciBpZiB3ZSd2ZSBuZXZlciBkb25lIGEgY29sbGVjdGlvbi4KQEAg LTU4NCw3ICs1ODMsNyBAQCB2b2lkIEhlYXA6Om1hcmtUb0ZpeHBvaW50KGRvdWJsZSBnY1N0YXJ0 CiAgICAgCiAgICAgZm9yICh1bnNpZ25lZCBpdGVyYXRpb24gPSAxOyA7ICsraXRlcmF0aW9uKSB7 CiAgICAgICAgIGlmIChPcHRpb25zOjpsb2dHQygpKQotICAgICAgICAgICAgZGF0YUxvZygiaSMi LCBpdGVyYXRpb24sICIgIiwgc2xvdFZpc2l0b3IuY29sbGVjdG9yTWFya1N0YWNrKCkuc2l6ZSgp LCAiKyIsIG1fbXV0YXRvck1hcmtTdGFjay0+c2l6ZSgpICsgc2xvdFZpc2l0b3IubXV0YXRvck1h cmtTdGFjaygpLnNpemUoKSwgIiBiPSIsIG1fYmFycmllcnNFeGVjdXRlZCwgIiAiKTsKKyAgICAg ICAgICAgIGRhdGFMb2coImkjIiwgaXRlcmF0aW9uLCAiIGI9IiwgbV9iYXJyaWVyc0V4ZWN1dGVk LCAiICIpOwogICAgICAgICAKICAgICAgICAgaWYgKHNsb3RWaXNpdG9yLmRpZFJlYWNoVGVybWlu YXRpb24oKSkgewogICAgICAgICAgICAgYXNzZXJ0U2hhcmVkTWFya1N0YWNrc0VtcHR5KCk7CkBA IC02MTAsNiArNjA5LDkgQEAgdm9pZCBIZWFwOjptYXJrVG9GaXhwb2ludChkb3VibGUgZ2NTdGFy dAogICAgICAgICAgICAgbV9zY2hlZHVsZXItPmRpZEV4ZWN1dGVDb25zdHJhaW50cygpOwogICAg ICAgICB9CiAgICAgICAgIAorICAgICAgICBpZiAoT3B0aW9uczo6bG9nR0MoKSkKKyAgICAgICAg ICAgIGRhdGFMb2coc2xvdFZpc2l0b3IuY29sbGVjdG9yTWFya1N0YWNrKCkuc2l6ZSgpLCAiKyIs IG1fbXV0YXRvck1hcmtTdGFjay0+c2l6ZSgpICsgc2xvdFZpc2l0b3IubXV0YXRvck1hcmtTdGFj aygpLnNpemUoKSwgIiAiKTsKKyAgICAgICAgCiAgICAgICAgIHsKICAgICAgICAgICAgIFBhcmFs bGVsTW9kZUVuYWJsZXIgZW5hYmxlcihzbG90VmlzaXRvcik7CiAgICAgICAgICAgICBzbG90Vmlz aXRvci5kcmFpbkluUGFyYWxsZWwobV9zY2hlZHVsZXItPnRpbWVUb1Jlc3VtZSgpKTsKQEAgLTk0 MCwyNCArOTQyLDQ5IEBAIHZvaWQgSGVhcDo6ZGVsZXRlVW5tYXJrZWRDb21waWxlZENvZGUoKQog ICAgIG1faml0U3R1YlJvdXRpbmVzLT5kZWxldGVVbm1hcmtlZEpldHRpc29uZWRTdHViUm91dGlu ZXMoKTsKIH0KIAotdm9pZCBIZWFwOjphZGRUb1JlbWVtYmVyZWRTZXQoY29uc3QgSlNDZWxsKiBj ZWxsKQordm9pZCBIZWFwOjphZGRUb1JlbWVtYmVyZWRTZXQoY29uc3QgSlNDZWxsKiBjb25zdENl bGwpCiB7CisgICAgSlNDZWxsKiBjZWxsID0gY29uc3RfY2FzdDxKU0NlbGwqPihjb25zdENlbGwp OwogICAgIEFTU0VSVChjZWxsKTsKICAgICBBU1NFUlQoIU9wdGlvbnM6OnVzZUNvbmN1cnJlbnRK SVQoKSB8fCAhaXNDb21waWxhdGlvblRocmVhZCgpKTsKICAgICBtX2JhcnJpZXJzRXhlY3V0ZWQr KzsKLSAgICBpZiAoIUhlYXA6OmlzTWFya2VkQ29uY3VycmVudGx5KGNlbGwpKSB7Ci0gICAgICAg IC8vIER1cmluZyBhIGZ1bGwgY29sbGVjdGlvbiBhIHN0b3JlIGludG8gYW4gdW5tYXJrZWQgb2Jq ZWN0IHRoYXQgaGFkIHN1cml2aXZlZCBwYXN0Ci0gICAgICAgIC8vIGNvbGxlY3Rpb25zIHdpbGwg bWFuaWZlc3QgYXMgYSBzdG9yZSB0byBhbiB1bm1hcmtlZCBibGFjayBvYmplY3QuIElmIHRoZSBv YmplY3QgZ2V0cwotICAgICAgICAvLyBtYXJrZWQgYXQgc29tZSB0aW1lIGFmdGVyIHRoaXMgdGhl biBpdCB3aWxsIGdvIGRvd24gdGhlIG5vcm1hbCBtYXJraW5nIHBhdGguIFdlIGNhbgotICAgICAg ICAvLyBzYWZlbHkgaWdub3JlIHRoZXNlIHN0b3Jlcy4KLSAgICAgICAgcmV0dXJuOwotICAgIH0K KyAgICBpZiAobV9tdXRhdG9yU2hvdWxkQmVGZW5jZWQpIHsKKyAgICAgICAgV1RGOjpsb2FkTG9h ZEZlbmNlKCk7CisgICAgICAgIGlmICghaXNNYXJrZWRDb25jdXJyZW50bHkoY2VsbCkpIHsKKyAg ICAgICAgICAgIC8vIER1cmluZyBhIGZ1bGwgY29sbGVjdGlvbiBhIHN0b3JlIGludG8gYW4gdW5t YXJrZWQgb2JqZWN0IHRoYXQgaGFkIHN1cml2aXZlZCBwYXN0CisgICAgICAgICAgICAvLyBjb2xs ZWN0aW9ucyB3aWxsIG1hbmlmZXN0IGFzIGEgc3RvcmUgdG8gYW4gdW5tYXJrZWQgYmxhY2sgb2Jq ZWN0LiBJZiB0aGUgb2JqZWN0IGdldHMKKyAgICAgICAgICAgIC8vIG1hcmtlZCBhdCBzb21lIHRp bWUgYWZ0ZXIgdGhpcyB0aGVuIGl0IHdpbGwgZ28gZG93biB0aGUgbm9ybWFsIG1hcmtpbmcgcGF0 aC4gV2UgY2FuCisgICAgICAgICAgICAvLyBzYWZlbHkgaWdub3JlIHRoZXNlIHN0b3Jlcy4KKyAg ICAgICAgICAgIGlmIChjZWxsLT5hdG9taWNDb21wYXJlRXhjaGFuZ2VDZWxsU3RhdGVTdHJvbmco Q2VsbFN0YXRlOjpQb3NzaWJseUJsYWNrLCBDZWxsU3RhdGU6OkRlZmluaXRlbHlXaGl0ZSkgPT0g Q2VsbFN0YXRlOjpQb3NzaWJseUJsYWNrKSB7CisgICAgICAgICAgICAgICAgLy8gTm93IHdlIHBy b3RlY3QgYWdhaW5zdCB0aGlzIHJhY2U6CisgICAgICAgICAgICAgICAgLy8KKyAgICAgICAgICAg ICAgICAvLyAgICAgMSkgT2JqZWN0IHN0YXJ0cyBvdXQgYmxhY2sgKyB1bm1hcmtlZC4KKyAgICAg ICAgICAgICAgICAvLyAgICAgLS0+IFdlIGRvIGlzTWFya2VkQ29uY3VycmVudGx5IGhlcmUuCisg ICAgICAgICAgICAgICAgLy8gICAgIDIpIE9iamVjdCBpcyBtYXJrZWQgYW5kIGdyZXllZC4KKyAg ICAgICAgICAgICAgICAvLyAgICAgMykgT2JqZWN0IGlzIHNjYW5uZWQgYW5kIGJsYWNrZWQuCisg ICAgICAgICAgICAgICAgLy8gICAgIC0tPiBXZSBkbyBhdG9taWNDb21wYXJlRXhjaGFuZ2VDZWxs U3RhdGVTdHJvbmcgaGVyZS4KKyAgICAgICAgICAgICAgICAvLworICAgICAgICAgICAgICAgIC8v IEluIHRoaXMgY2FzZSB3ZSB3b3VsZCBoYXZlIG1hZGUgdGhlIG9iamVjdCB3aGl0ZSBhZ2Fpbiwg ZXZlbiB0aG91Z2ggaXQgc2hvdWxkCisgICAgICAgICAgICAgICAgLy8gYmUgYmxhY2suIFRoaXMg Y2hlY2sgbGV0cyB1cyBjb3JyZWN0IG91ciBtaXN0YWtlLiBUaGlzIHJlbGllcyBvbiB0aGUgZmFj dCB0aGF0CisgICAgICAgICAgICAgICAgLy8gaXNNYXJrZWRDb25jdXJyZW50bHkgY29udmVyZ2Vz IG1vbm90b25pY2FsbHkgdG8gdHJ1ZS4KKyAgICAgICAgICAgICAgICBpZiAoIWlzTWFya2VkQ29u Y3VycmVudGx5KGNlbGwpKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIE9LIC0gdGhlIG9iamVj dCByZWFsbHkgZGVzZXJ2ZXMgdG8gYmUgd2hpdGUhCisgICAgICAgICAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAg Ly8gSXQncyBkaWZmaWN1bHQgdG8gd29yayBvdXQgd2hldGhlciB0aGUgb2JqZWN0IHNob3VsZCBi ZSBncmV5IG9yIGJsYWNrIGF0CisgICAgICAgICAgICAgICAgLy8gdGhpcyBwb2ludC4gV2Ugc2F5 IGJsYWNrIGNvbnNlcnZhdGl2ZWx5LgorICAgICAgICAgICAgICAgIGNlbGwtPnNldENlbGxTdGF0 ZShDZWxsU3RhdGU6OlBvc3NpYmx5QmxhY2spOworICAgICAgICAgICAgfQorICAgICAgICB9Cisg ICAgfSBlbHNlCisgICAgICAgIEFTU0VSVChIZWFwOjppc01hcmtlZENvbmN1cnJlbnRseShjZWxs KSk7CiAgICAgLy8gSXQgY291bGQgYmUgdGhhdCB0aGUgb2JqZWN0IHdhcyAqanVzdCogbWFya2Vk LiBUaGlzIG1lYW5zIHRoYXQgdGhlIGNvbGxlY3RvciBtYXkgc2V0IHRoZQogICAgIC8vIHN0YXRl IHRvIERlZmluaXRlbHlHcmV5IGFuZCB0aGVuIHRvIFBvc3NpYmx5T2xkT3JCbGFjayBhdCBhbnkg dGltZS4gSXQncyBPSyBmb3IgdXMgdG8KICAgICAvLyByYWNlIHdpdGggdGhlIGNvbGxlY3RvciBo ZXJlLiBJZiB3ZSB3aW4gdGhlbiB0aGlzIGlzIGFjY3VyYXRlIGJlY2F1c2UgdGhlIG9iamVjdCBf d2lsbF8KICAgICAvLyBnZXQgc2Nhbm5lZCBhZ2Fpbi4gSWYgd2UgbG9zZSB0aGVuIHNvbWVvbmUg ZWxzZSB3aWxsIGJhcnJpZXIgdGhlIG9iamVjdCBhZ2Fpbi4gVGhhdCB3b3VsZAogICAgIC8vIGJl IHVuZm9ydHVuYXRlIGJ1dCBub3QgdGhlIGVuZCBvZiB0aGUgd29ybGQuCi0gICAgY2VsbC0+c2V0 Q2VsbFN0YXRlKENlbGxTdGF0ZTo6RGVmaW5pdGVseUdyZXkpOworICAgIGNlbGwtPnNldENlbGxT dGF0ZShDZWxsU3RhdGU6OlBvc3NpYmx5R3JleSk7CiAgICAgbV9tdXRhdG9yTWFya1N0YWNrLT5h cHBlbmQoY2VsbCk7CiB9CiAKQEAgLTExNzcsNyArMTIwNCw2IEBAIHZvaWQgSGVhcDo6c3RvcFRo ZVdvcmxkKCkKICAgICAKICAgICB2bSgpLT5zaGFkb3dDaGlja2VuKCkudXBkYXRlKCp2bSgpLCB2 bSgpLT50b3BDYWxsRnJhbWUpOwogICAgIAotICAgIGZsdXNoV3JpdGVCYXJyaWVyQnVmZmVyKCk7 CiAgICAgbV9zdHJ1Y3R1cmVJRFRhYmxlLmZsdXNoT2xkVGFibGVzKCk7CiAgICAgbV9vYmplY3RT cGFjZS5zdG9wQWxsb2NhdGluZygpOwogICAgIApAQCAtMTU5NywxMSArMTYyMyw2IEBAIHZvaWQg SGVhcDo6d2lsbFN0YXJ0Q29sbGVjdGlvbihzdGQ6Om9wdGkKICAgICAgICAgb2JzZXJ2ZXItPndp bGxHYXJiYWdlQ29sbGVjdCgpOwogfQogCi12b2lkIEhlYXA6OmZsdXNoV3JpdGVCYXJyaWVyQnVm ZmVyKCkKLXsKLSAgICBtX3dyaXRlQmFycmllckJ1ZmZlci5mbHVzaCgqdGhpcyk7Ci19Ci0KIHZv aWQgSGVhcDo6cHJlcGFyZUZvck1hcmtpbmcoKQogewogICAgIG1fb2JqZWN0U3BhY2UucHJlcGFy ZUZvck1hcmtpbmcoKTsKQEAgLTE4ODIsMTIgKzE5MDMsNiBAQCB2b2lkIEhlYXA6OnpvbWJpZnlE ZWFkT2JqZWN0cygpCiAgICAgbV9vYmplY3RTcGFjZS5mb3JFYWNoRGVhZENlbGwoaXRlcmF0aW9u U2NvcGUsIFpvbWJpZnkoKSk7CiB9CiAKLXZvaWQgSGVhcDo6Zmx1c2hXcml0ZUJhcnJpZXJCdWZm ZXIoSlNDZWxsKiBjZWxsKQotewotICAgIG1fd3JpdGVCYXJyaWVyQnVmZmVyLmZsdXNoKCp0aGlz KTsKLSAgICBtX3dyaXRlQmFycmllckJ1ZmZlci5hZGQoY2VsbCk7Ci19Ci0KIGJvb2wgSGVhcDo6 c2hvdWxkRG9GdWxsQ29sbGVjdGlvbihzdGQ6Om9wdGlvbmFsPENvbGxlY3Rpb25TY29wZT4gc2Nv cGUpIGNvbnN0CiB7CiAgICAgaWYgKCFPcHRpb25zOjp1c2VHZW5lcmF0aW9uYWxHQygpKQpAQCAt MTk2NSw3ICsxOTgwLDcgQEAgdm9pZCBIZWFwOjp3cml0ZUJhcnJpZXJTbG93UGF0aChjb25zdCBK UwogICAgICAgICAvLyBJbiB0aGlzIGNhc2UsIHRoZSBiYXJyaWVyVGhyZXNob2xkIGlzIHRoZSB0 YXV0b2xvZ2ljYWwgdGhyZXNob2xkLCBzbyBmcm9tIGNvdWxkIHN0aWxsIGJlCiAgICAgICAgIC8v IG5vdCBibGFjay4gQnV0IHdlIGNhbid0IGtub3cgZm9yIHN1cmUgdW50aWwgd2UgZmlyZSBvZmYg YSBmZW5jZS4KICAgICAgICAgV1RGOjpzdG9yZUxvYWRGZW5jZSgpOwotICAgICAgICBpZiAoZnJv bS0+Y2VsbFN0YXRlKCkgIT0gQ2VsbFN0YXRlOjpQb3NzaWJseU9sZE9yQmxhY2spCisgICAgICAg IGlmIChmcm9tLT5jZWxsU3RhdGUoKSAhPSBDZWxsU3RhdGU6OlBvc3NpYmx5QmxhY2spCiAgICAg ICAgICAgICByZXR1cm47CiAgICAgfQogICAgIApAQCAtMjIxMyw3ICsyMjI4LDcgQEAgdm9pZCBI ZWFwOjpidWlsZENvbnN0cmFpbnRTZXQoKQogICAgICAgICAgICAgICAgIFsmXSAoQ29kZUJsb2Nr KiBjb2RlQmxvY2spIHsKICAgICAgICAgICAgICAgICAgICAgLy8gVmlzaXQgdGhlIENvZGVCbG9j ayBhcyBhIGNvbnN0cmFpbnQgb25seSBpZiBpdCdzIGJsYWNrLgogICAgICAgICAgICAgICAgICAg ICBpZiAoSGVhcDo6aXNNYXJrZWQoY29kZUJsb2NrKQotICAgICAgICAgICAgICAgICAgICAgICAg JiYgY29kZUJsb2NrLT5jZWxsU3RhdGUoKSA9PSBDZWxsU3RhdGU6OlBvc3NpYmx5T2xkT3JCbGFj aykKKyAgICAgICAgICAgICAgICAgICAgICAgICYmIGNvZGVCbG9jay0+Y2VsbFN0YXRlKCkgPT0g Q2VsbFN0YXRlOjpQb3NzaWJseUJsYWNrKQogICAgICAgICAgICAgICAgICAgICAgICAgc2xvdFZp c2l0b3IudmlzaXRBc0NvbnN0cmFpbnQoY29kZUJsb2NrKTsKICAgICAgICAgICAgICAgICB9KTsK ICAgICAgICAgfSwKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXAuaAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9IZWFwLmgJKHJldmlzaW9uIDIx MDUyMSkKKysrIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXAuaAkod29ya2luZyBjb3B5 KQpAQCAtNDMsNyArNDMsNiBAQAogI2luY2x1ZGUgIlZpc2l0UmFjZUtleS5oIgogI2luY2x1ZGUg IldlYWtIYW5kbGVPd25lci5oIgogI2luY2x1ZGUgIldlYWtSZWZlcmVuY2VIYXJ2ZXN0ZXIuaCIK LSNpbmNsdWRlICJXcml0ZUJhcnJpZXJCdWZmZXIuaCIKICNpbmNsdWRlICJXcml0ZUJhcnJpZXJT dXBwb3J0LmgiCiAjaW5jbHVkZSA8d3RmL0F1dG9tYXRpY1RocmVhZC5oPgogI2luY2x1ZGUgPHd0 Zi9EZXF1ZS5oPgpAQCAtMTI1LDkgKzEyNCw2IEBAIHB1YmxpYzoKICAgICAvLyBUYWtlIHRoaXMg aWYgeW91IGtub3cgdGhhdCBmcm9tLT5jZWxsU3RhdGUoKSA8IGJhcnJpZXJUaHJlc2hvbGQuCiAg ICAgSlNfRVhQT1JUX1BSSVZBVEUgdm9pZCB3cml0ZUJhcnJpZXJTbG93UGF0aChjb25zdCBKU0Nl bGwqIGZyb20pOwogCi0gICAgV3JpdGVCYXJyaWVyQnVmZmVyJiB3cml0ZUJhcnJpZXJCdWZmZXIo KSB7IHJldHVybiBtX3dyaXRlQmFycmllckJ1ZmZlcjsgfQotICAgIHZvaWQgZmx1c2hXcml0ZUJh cnJpZXJCdWZmZXIoSlNDZWxsKik7Ci0gICAgCiAgICAgdm9pZCB3cml0ZUJhcnJpZXJPcGFxdWVS b290KHZvaWQqKTsKIAogICAgIEhlYXAoVk0qLCBIZWFwVHlwZSk7CkBAIC00NDUsNyArNDQxLDYg QEAgcHJpdmF0ZToKICAgICAKICAgICB2b2lkIHN1c3BlbmRDb21waWxlclRocmVhZHMoKTsKICAg ICB2b2lkIHdpbGxTdGFydENvbGxlY3Rpb24oc3RkOjpvcHRpb25hbDxDb2xsZWN0aW9uU2NvcGU+ KTsKLSAgICB2b2lkIGZsdXNoV3JpdGVCYXJyaWVyQnVmZmVyKCk7CiAgICAgdm9pZCBwcmVwYXJl Rm9yTWFya2luZygpOwogICAgIAogICAgIHZvaWQgbWFya1RvRml4cG9pbnQoZG91YmxlIGdjU3Rh cnRUaW1lKTsKQEAgLTU2NCw3ICs1NTksNiBAQCBwcml2YXRlOgogICAgIAogICAgIGJvb2wgbV9p c1NhZmVUb0NvbGxlY3Q7CiAKLSAgICBXcml0ZUJhcnJpZXJCdWZmZXIgbV93cml0ZUJhcnJpZXJC dWZmZXI7CiAgICAgYm9vbCBtX211dGF0b3JTaG91bGRCZUZlbmNlZCB7IE9wdGlvbnM6OmZvcmNl RmVuY2VkQmFycmllcigpIH07CiAgICAgdW5zaWduZWQgbV9iYXJyaWVyVGhyZXNob2xkIHsgT3B0 aW9uczo6Zm9yY2VGZW5jZWRCYXJyaWVyKCkgPyB0YXV0b2xvZ2ljYWxUaHJlc2hvbGQgOiBibGFj a1RocmVzaG9sZCB9OwogICAgIFZlY3Rvcjxib29sKj4gbV9tdXRhdG9yU2hvdWxkQmVGZW5jZWRD YWNoZXM7CkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9TbG90VmlzaXRvci5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvU2xvdFZpc2l0b3IuY3Bw CShyZXZpc2lvbiAyMTA1MjEpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9TbG90Vmlz aXRvci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIwNCw3ICsyMDQsNyBAQCB2b2lkIFNsb3RWaXNp dG9yOjphcHBlbmRKU0NlbGxPckF1eGlsaWFyCiAgICAgICAgIEpTQ2VsbCoganNDZWxsID0gc3Rh dGljX2Nhc3Q8SlNDZWxsKj4oaGVhcENlbGwpOwogICAgICAgICB2YWxpZGF0ZUNlbGwoanNDZWxs KTsKICAgICAgICAgCi0gICAgICAgIGpzQ2VsbC0+c2V0Q2VsbFN0YXRlKENlbGxTdGF0ZTo6RGVm aW5pdGVseUdyZXkpOworICAgICAgICBqc0NlbGwtPnNldENlbGxTdGF0ZShDZWxsU3RhdGU6OlBv c3NpYmx5R3JleSk7CiAKICAgICAgICAgYXBwZW5kVG9NYXJrU3RhY2soanNDZWxsKTsKICAgICAg ICAgcmV0dXJuOwpAQCAtMjY2LDcgKzI2Niw3IEBAIEFMV0FZU19JTkxJTkUgdm9pZCBTbG90Vmlz aXRvcjo6c2V0TWFya2UKICAgICAvLyBJbmRpY2F0ZSB0aGF0IHRoZSBvYmplY3QgaXMgZ3JleSBh bmQgdGhhdDoKICAgICAvLyBJbiBjYXNlIG9mIGNvbmN1cnJlbnQgR0M6IGl0J3MgdGhlIGZpcnN0 IHRpbWUgaXQgaXMgZ3JleSBpbiB0aGlzIEdDIGN5Y2xlLgogICAgIC8vIEluIGNhc2Ugb2YgZWRl biBjb2xsZWN0aW9uOiBpdCdzIGEgbmV3IG9iamVjdCB0aGF0IGJlY2FtZSBncmV5IHJhdGhlciB0 aGFuIGFuIG9sZCByZW1lbWJlcmVkIG9iamVjdC4KLSAgICBjZWxsLT5zZXRDZWxsU3RhdGUoQ2Vs bFN0YXRlOjpEZWZpbml0ZWx5R3JleSk7CisgICAgY2VsbC0+c2V0Q2VsbFN0YXRlKENlbGxTdGF0 ZTo6UG9zc2libHlHcmV5KTsKICAgICAKICAgICBhcHBlbmRUb01hcmtTdGFjayhjb250YWluZXIs IGNlbGwpOwogfQpAQCAtMjg0LDcgKzI4NCw3IEBAIEFMV0FZU19JTkxJTkUgdm9pZCBTbG90Vmlz aXRvcjo6YXBwZW5kVG8KIHsKICAgICBBU1NFUlQoSGVhcDo6aXNNYXJrZWRDb25jdXJyZW50bHko Y2VsbCkpOwogICAgIEFTU0VSVCghY2VsbC0+aXNaYXBwZWQoKSk7Ci0gICAgQVNTRVJUKGNlbGwt PmNlbGxTdGF0ZSgpID09IENlbGxTdGF0ZTo6RGVmaW5pdGVseUdyZXkpOworICAgIEFTU0VSVChj ZWxsLT5jZWxsU3RhdGUoKSA9PSBDZWxsU3RhdGU6OlBvc3NpYmx5R3JleSk7CiAgICAgCiAgICAg Y29udGFpbmVyLm5vdGVNYXJrZWQoKTsKICAgICAKQEAgLTM3MSw3ICszNzEsNyBAQCBBTFdBWVNf SU5MSU5FIHZvaWQgU2xvdFZpc2l0b3I6OnZpc2l0Q2hpCiAgICAgLy8gbm90IGNsZWFyIHRvIG1l IHRoYXQgaXQgd291bGQgYmUgY29ycmVjdCBvciBwcm9maXRhYmxlIHRvIGJhaWwgaGVyZSBpZiB0 aGUgb2JqZWN0IGlzIGFscmVhZHkKICAgICAvLyBibGFjay4KICAgICAKLSAgICBjZWxsLT5zZXRD ZWxsU3RhdGUoQ2VsbFN0YXRlOjpQb3NzaWJseU9sZE9yQmxhY2spOworICAgIGNlbGwtPnNldENl bGxTdGF0ZShDZWxsU3RhdGU6OlBvc3NpYmx5QmxhY2spOwogICAgIAogICAgIFdURjo6c3RvcmVM b2FkRmVuY2UoKTsKICAgICAKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL1dyaXRl QmFycmllckJ1ZmZlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2hl YXAvV3JpdGVCYXJyaWVyQnVmZmVyLmNwcAkocmV2aXNpb24gMjEwNTIxKQorKysgU291cmNlL0ph dmFTY3JpcHRDb3JlL2hlYXAvV3JpdGVCYXJyaWVyQnVmZmVyLmNwcAkobm9uZXhpc3RlbnQpCkBA IC0xLDY5ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTMgQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUg bWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKLSAqIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLAotICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCi0gKiBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExB UlksIE9SCi0gKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRgotICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCi0gKiBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTgotICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKLSAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKLSAqIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVk ZSAiV3JpdGVCYXJyaWVyQnVmZmVyLmgiCi0KLSNpbmNsdWRlICJHQ0Fzc2VydGlvbnMuaCIKLSNp bmNsdWRlICJIZWFwLmgiCi0jaW5jbHVkZSAiSlNDZWxsLmgiCi0jaW5jbHVkZSAiSlNDSW5saW5l cy5oIgotI2luY2x1ZGUgIlN0cnVjdHVyZS5oIgotCi1uYW1lc3BhY2UgSlNDIHsKLQotV3JpdGVC YXJyaWVyQnVmZmVyOjpXcml0ZUJhcnJpZXJCdWZmZXIodW5zaWduZWQgY2FwYWNpdHkpCi0gICAg OiBtX2N1cnJlbnRJbmRleCgwKQotICAgICwgbV9jYXBhY2l0eShjYXBhY2l0eSkKLSAgICAsIG1f YnVmZmVyKHN0YXRpY19jYXN0PEpTQ2VsbCoqPihmYXN0TWFsbG9jKHNpemVvZihKU0NlbGwqKSAq IGNhcGFjaXR5KSkpCi17Ci19Ci0KLVdyaXRlQmFycmllckJ1ZmZlcjo6fldyaXRlQmFycmllckJ1 ZmZlcigpCi17Ci0gICAgZmFzdEZyZWUobV9idWZmZXIpOwotfQotCi12b2lkIFdyaXRlQmFycmll ckJ1ZmZlcjo6Zmx1c2goSGVhcCYgaGVhcCkKLXsKLSAgICBBU1NFUlQobV9jdXJyZW50SW5kZXgg PD0gbV9jYXBhY2l0eSk7Ci0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2N1cnJlbnRJbmRl eDsgKytpKQotICAgICAgICBoZWFwLndyaXRlQmFycmllcihtX2J1ZmZlcltpXSk7Ci0gICAgbV9j dXJyZW50SW5kZXggPSAwOwotfQotCi12b2lkIFdyaXRlQmFycmllckJ1ZmZlcjo6cmVzZXQoKQot ewotICAgIG1fY3VycmVudEluZGV4ID0gMDsKLX0KLQotdm9pZCBXcml0ZUJhcnJpZXJCdWZmZXI6 OmFkZChKU0NlbGwqIGNlbGwpCi17Ci0gICAgQVNTRVJUX0dDX09CSkVDVF9MT09LU19WQUxJRChj ZWxsKTsKLSAgICBBU1NFUlQobV9jdXJyZW50SW5kZXggPCBtX2NhcGFjaXR5KTsKLSAgICBtX2J1 ZmZlclttX2N1cnJlbnRJbmRleCsrXSA9IGNlbGw7Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIEpTQwpJ bmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvV3JpdGVCYXJyaWVyQnVmZmVyLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvV3JpdGVCYXJyaWVyQnVmZmVy LmgJKHJldmlzaW9uIDIxMDUyMSkKKysrIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL1dyaXRl QmFycmllckJ1ZmZlci5oCShub25leGlzdGVudCkKQEAgLTEsNjUgKzAsMCBAQAotLyoKLSAqIENv cHlyaWdodCAoQykgMjAxMywgMjAxNSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0g KgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAot ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFO RCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJwotICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCi0gKiBUSEUgSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSCi0gKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKLSAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKLSAqIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5U IE9GCi0gKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKLSAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCi0gKiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKQotICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRgotICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgotICovCi0KLSNwcmFnbWEgb25jZQotCi0jaW5jbHVkZSA8d3RmL0Zhc3RNYWxsb2MuaD4KLQot bmFtZXNwYWNlIEpTQyB7Ci0KLWNsYXNzIEhlYXA7Ci1jbGFzcyBKU0NlbGw7Ci0KLWNsYXNzIFdy aXRlQmFycmllckJ1ZmZlciB7Ci1wdWJsaWM6Ci0gICAgV3JpdGVCYXJyaWVyQnVmZmVyKHVuc2ln bmVkIGNhcGFjaXR5KTsKLSAgICB+V3JpdGVCYXJyaWVyQnVmZmVyKCk7Ci0KLSAgICB2b2lkIGFk ZChKU0NlbGwqKTsKLSAgICB2b2lkIGZsdXNoKEhlYXAmKTsKLSAgICB2b2lkIHJlc2V0KCk7Ci0K LSAgICB1bnNpZ25lZCogY3VycmVudEluZGV4QWRkcmVzcygpCi0gICAgewotICAgICAgICByZXR1 cm4gJm1fY3VycmVudEluZGV4OwotICAgIH0KLQotICAgIHVuc2lnbmVkIGNhcGFjaXR5KCkgY29u c3QKLSAgICB7Ci0gICAgICAgIHJldHVybiBtX2NhcGFjaXR5OwotICAgIH0KLQotICAgIEpTQ2Vs bCoqIGJ1ZmZlcigpCi0gICAgewotICAgICAgICByZXR1cm4gbV9idWZmZXI7Ci0gICAgfQotCi1w cml2YXRlOgotICAgIHVuc2lnbmVkIG1fY3VycmVudEluZGV4OwotICAgIGNvbnN0IHVuc2lnbmVk IG1fY2FwYWNpdHk7Ci0gICAgSlNDZWxsKiogY29uc3QgbV9idWZmZXI7Ci19OwotCi19IC8vIG5h bWVzcGFjZSBKU0MKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9qaXQvSklUT3BlcmF0aW9u cy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2ppdC9KSVRPcGVyYXRp b25zLmNwcAkocmV2aXNpb24gMjEwNTIxKQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL2ppdC9K SVRPcGVyYXRpb25zLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBD b3B5cmlnaHQgKEMpIDIwMTMtMjAxNiBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KiBDb3B5cmlnaHQgKEMpIDIwMTMtMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTIxODgsMTMgKzIxODgsNiBAQCBj aGFyKiBKSVRfT1BFUkFUSU9OIG9wZXJhdGlvblJlYWxsb2NhdGVCCiAgICAgcmV0dXJuIHJlaW50 ZXJwcmV0X2Nhc3Q8Y2hhcio+KHJlc3VsdCk7CiB9CiAKLXZvaWQgSklUX09QRVJBVElPTiBvcGVy YXRpb25GbHVzaFdyaXRlQmFycmllckJ1ZmZlcihFeGVjU3RhdGUqIGV4ZWMsIEpTQ2VsbCogY2Vs bCkKLXsKLSAgICBWTSogdm0gPSAmZXhlYy0+dm0oKTsKLSAgICBOYXRpdmVDYWxsRnJhbWVUcmFj ZXIgdHJhY2VyKHZtLCBleGVjKTsKLSAgICB2bS0+aGVhcC5mbHVzaFdyaXRlQmFycmllckJ1ZmZl cihjZWxsKTsKLX0KLQogdm9pZCBKSVRfT1BFUkFUSU9OIG9wZXJhdGlvbk9TUldyaXRlQmFycmll cihFeGVjU3RhdGUqIGV4ZWMsIEpTQ2VsbCogY2VsbCkKIHsKICAgICBWTSogdm0gPSAmZXhlYy0+ dm0oKTsKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9qaXQvSklUT3BlcmF0aW9ucy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9qaXQvSklUT3BlcmF0aW9ucy5oCShy ZXZpc2lvbiAyMTA1MjEpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvaml0L0pJVE9wZXJhdGlv bnMuaAkod29ya2luZyBjb3B5KQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMp IDIwMTMtMjAxNiBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQg KEMpIDIwMTMtMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTQyNiw3ICs0MjYsNiBAQCB2b2lkIEpJVF9PUEVSQVRJ T04gb3BlcmF0aW9uUHV0VG9TY29wZShFCiBjaGFyKiBKSVRfT1BFUkFUSU9OIG9wZXJhdGlvblJl YWxsb2NhdGVCdXR0ZXJmbHlUb0hhdmVQcm9wZXJ0eVN0b3JhZ2VXaXRoSW5pdGlhbENhcGFjaXR5 KEV4ZWNTdGF0ZSosIEpTT2JqZWN0KikgV1RGX0lOVEVSTkFMOwogY2hhciogSklUX09QRVJBVElP TiBvcGVyYXRpb25SZWFsbG9jYXRlQnV0dGVyZmx5VG9Hcm93UHJvcGVydHlTdG9yYWdlKEV4ZWNT dGF0ZSosIEpTT2JqZWN0Kiwgc2l6ZV90IG5ld1NpemUpIFdURl9JTlRFUk5BTDsKIAotdm9pZCBK SVRfT1BFUkFUSU9OIG9wZXJhdGlvbkZsdXNoV3JpdGVCYXJyaWVyQnVmZmVyKEV4ZWNTdGF0ZSos IEpTQ2VsbCopOwogdm9pZCBKSVRfT1BFUkFUSU9OIG9wZXJhdGlvbldyaXRlQmFycmllclNsb3dQ YXRoKEV4ZWNTdGF0ZSosIEpTQ2VsbCopOwogdm9pZCBKSVRfT1BFUkFUSU9OIG9wZXJhdGlvbk9T UldyaXRlQmFycmllcihFeGVjU3RhdGUqLCBKU0NlbGwqKTsKIApJbmRleDogU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvSlNDZWxsSW5saW5lcy5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ2VsbElubGluZXMuaAkocmV2aXNpb24gMjEwNTIxKQor KysgU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDZWxsSW5saW5lcy5oCSh3b3JraW5n IGNvcHkpCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMi0yMDE2IEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMi0yMDE3 IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucwpAQCAtNDEsNyArNDEsNyBAQAogbmFtZXNwYWNlIEpTQyB7CiAKIGlubGluZSBKU0Nl bGw6OkpTQ2VsbChDcmVhdGluZ0Vhcmx5Q2VsbFRhZykKLSAgICA6IG1fY2VsbFN0YXRlKENlbGxT dGF0ZTo6RGVmaW5pdGVseU5ld0FuZFdoaXRlKQorICAgIDogbV9jZWxsU3RhdGUoQ2VsbFN0YXRl OjpEZWZpbml0ZWx5V2hpdGUpCiB7CiAgICAgQVNTRVJUKCFpc0NvbXBpbGF0aW9uVGhyZWFkKCkp OwogfQpAQCAtNTEsNyArNTEsNyBAQCBpbmxpbmUgSlNDZWxsOjpKU0NlbGwoVk0mLCBTdHJ1Y3R1 cmUqIHN0CiAgICAgLCBtX2luZGV4aW5nVHlwZUFuZE1pc2Moc3RydWN0dXJlLT5pbmRleGluZ1R5 cGVJbmNsdWRpbmdIaXN0b3J5KCkpCiAgICAgLCBtX3R5cGUoc3RydWN0dXJlLT50eXBlSW5mbygp LnR5cGUoKSkKICAgICAsIG1fZmxhZ3Moc3RydWN0dXJlLT50eXBlSW5mbygpLmlubGluZVR5cGVG bGFncygpKQotICAgICwgbV9jZWxsU3RhdGUoQ2VsbFN0YXRlOjpEZWZpbml0ZWx5TmV3QW5kV2hp dGUpCisgICAgLCBtX2NlbGxTdGF0ZShDZWxsU3RhdGU6OkRlZmluaXRlbHlXaGl0ZSkKIHsKICAg ICBBU1NFUlQoIWlzQ29tcGlsYXRpb25UaHJlYWQoKSk7CiB9CkluZGV4OiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvcnVudGltZS9TdHJ1Y3R1cmVJREJsb2IuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv SmF2YVNjcmlwdENvcmUvcnVudGltZS9TdHJ1Y3R1cmVJREJsb2IuaAkocmV2aXNpb24gMjEwNTIx KQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvU3RydWN0dXJlSURCbG9iLmgJKHdv cmtpbmcgY29weSkKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDE0LTIw MTYgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE0 LTIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAog ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCkBAIC00Niw3ICs0Niw3IEBAIHB1YmxpYzoKICAgICAgICAgdS5maWVsZHMu aW5kZXhpbmdUeXBlSW5jbHVkaW5nSGlzdG9yeSA9IGluZGV4aW5nVHlwZUluY2x1ZGluZ0hpc3Rv cnk7CiAgICAgICAgIHUuZmllbGRzLnR5cGUgPSB0eXBlSW5mby50eXBlKCk7CiAgICAgICAgIHUu ZmllbGRzLmlubGluZVR5cGVGbGFncyA9IHR5cGVJbmZvLmlubGluZVR5cGVGbGFncygpOwotICAg ICAgICB1LmZpZWxkcy5kZWZhdWx0Q2VsbFN0YXRlID0gQ2VsbFN0YXRlOjpEZWZpbml0ZWx5TmV3 QW5kV2hpdGU7CisgICAgICAgIHUuZmllbGRzLmRlZmF1bHRDZWxsU3RhdGUgPSBDZWxsU3RhdGU6 OkRlZmluaXRlbHlXaGl0ZTsKICAgICB9CiAKICAgICB2b2lkIG9wZXJhdG9yPShjb25zdCBTdHJ1 Y3R1cmVJREJsb2ImIG90aGVyKSB7IHUuZG91YmxlV29yZCA9IG90aGVyLnUuZG91YmxlV29yZDsg fQo=