161847 2016-09-11 10:45:55 -0700 FastBitVector should have efficient and easy-to-use vector-vector operations 2016-09-11 21:06:10 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build All All RESOLVED FIXED P2 Normal --- 161581 161849 1 fpizlo fpizlo commit-queue saam oldest_to_newest 1228613 0 fpizlo 2016-09-11 10:45:55 -0700 Given this: FastBitVector a; FastBitVector b; FastBitVector c; I want to be able to say things like: Set a to some weird combination of the others, with the implementation being a single loop and no copying: a = ((~a) & b) + c; Express merge, filter, and exclude using operators, to be consistent: a &= ~c; Rapidly iterate over some combination of vectors. (a & ~(b | c)).forEachSetBit([&] (size_t index) { ... }); We can make this work by having operator&, operator|, and operator~ return a view of the input bitvectors, which supports all immutable FastBitVector operations and combines the uint32_t* words array on-the-fly. For example, if you do: auto merge = a | b; Then 'merge' will have an internal FastBitVector type that supports all const FastBitVector ops. While a FastBitVector points to a uint32_t* m_words and accesses that words array directly on each bit access, the 'merge' vector uses a FastBitVectorOWords adapter that, when asked for a word at an index, will or together the words at that index in a and b. Template magic makes this invisible and free. 1228614 1 288529 fpizlo 2016-09-11 10:46:49 -0700 Created attachment 288529 work in progress 1228633 2 288536 fpizlo 2016-09-11 15:46:05 -0700 Created attachment 288536 the patch 1228634 3 commit-queue 2016-09-11 15:48:43 -0700 Attachment 288536 did not pass style-queue: ERROR: Source/WTF/wtf/FastBitVector.h:330: Missing spaces around | [whitespace/operators] [3] ERROR: Source/JavaScriptCore/dfg/DFGLiveCatchVariablePreservationPhase.cpp:76: When wrapping a line, only indent 4 spaces. [whitespace/indent] [3] Total errors found: 2 in 15 files If any of these errors are false positives, please file a bug against check-webkit-style. 1228635 4 fpizlo 2016-09-11 15:50:24 -0700 (In reply to comment #3) > Attachment 288536 [details] did not pass style-queue: > > > ERROR: Source/WTF/wtf/FastBitVector.h:330: Missing spaces around | > [whitespace/operators] [3] No. > ERROR: > Source/JavaScriptCore/dfg/DFGLiveCatchVariablePreservationPhase.cpp:76: > When wrapping a line, only indent 4 spaces. [whitespace/indent] [3] Fixed. > Total errors found: 2 in 15 files > > > If any of these errors are false positives, please file a bug against > check-webkit-style. 1228652 5 288536 saam 2016-09-11 17:51:09 -0700 Comment on attachment 288536 the patch View in context: https://bugs.webkit.org/attachment.cgi?id=288536&action=review r=me with comments/suggestions. > Source/WTF/ChangeLog:38 > + uint32_t word(size_t index) { return b.m_words.word(index) | ~c.m_words.word(index); } It's cool to do this on the fly, I like that strategy. > Source/WTF/ChangeLog:52 > + I think that it's harder to see what is going on here, then using operators, because infix I agree. FWIW, I've never been a fan of the name 'filter' over set language like 'intersection'. > Source/WTF/wtf/FastBitVector.h:37 > +inline size_t fastBitVectorArrayLength(size_t numBits) { return (numBits + 31) >> 5; } Nit: I think it is easier to understand what this is doing if you wrote it as "/ 32" instead of ">> 5". > Source/WTF/wtf/FastBitVector.h:96 > + memcpy(m_words, other.m_words, length * 4); Style: I'm not a big fan of using 4 everywhere. Even though it's more verbose, I think everything is clearer if you defined a constant somewhere as sizeof(uint32_t) and used it instead of 4. > Source/WTF/wtf/FastBitVector.h:99 > uint32_t* newArray = static_cast<uint32_t*>(fastCalloc(length, 4)); Why calloc if you're going to memcpy afterwords? Why not just fast malloc? > Source/WTF/wtf/FastBitVector.h:117 > + memset(m_words, 255, arrayLength() * 4); Nit: I'd use std::numeric_limits here or UCHAR_MAX > Source/WTF/wtf/FastBitVector.h:180 > +template<typename Left, typename Right> > +class FastBitVectorAndWords { > +public: Suggestion: another possibility is to define a template over a third type which is some sort of enum like: BinaryOp { And, Or } and then have the `uint32_t word(size_t index)` switch over the BinaryOp. That way you don't have two classes that are doing almost the same thing. > Source/WTF/wtf/FastBitVector.h:255 > + return !m_view.word(index); This should be "~", right? > Source/WTF/wtf/FastBitVector.h:346 > unsigned j = i << 5; Style: ditto about *32 instead of <<. And this should be a size_t and not unsigned. > Source/WTF/wtf/FastBitVector.h:359 > + // I'm pretty sure that this is the most efficient way to do this. I don't think this comment adds anything. I also think I agree with it since the above loop bails on words early if they are empty. I'm not sure how you'd do the same thing if you manually wrote such a loop for clear bits. > Source/WTF/wtf/FastBitVector.h:370 > + void forEachBit(bool value, const Func& func) const > + { > + if (value) > + forEachSetBit(func); > + else > + forEachClearBit(func); > + } What's this going to be used for? > Source/WTF/wtf/FastBitVector.h:378 > + ALWAYS_INLINE size_t findBit(size_t startIndex, bool value) const Is this going to be used for some GC stuff? If the only use is that loop, then shouldn't we just use forEachSetBit instead? > Source/WTF/wtf/FastBitVector.h:380 > + uint32_t skipValue = -(static_cast<uint32_t>(value) ^ 1); Since this will always be inlined, I'd just write this as: uint32_t skipValue = value ? 0 : UINT_MAX; Otherwise, it's just super confusing to read what this code is doing. At first, I thought it was a bug for it to be "-", and not "~", but then I realized that's intended. > Source/WTF/wtf/FastBitVector.h:384 > + size_t wordIndex = startIndex >> 5; > + size_t startIndexInWord = startIndex - (wordIndex << 5); Style: ditto shifts for division/multiplication. > Source/WTF/wtf/FastBitVector.h:419 > + // You'd think that we could remove this friend if we used protected, but you'd be wrong, > + // because templates. Nit: I don't think this comment adds much. But it is quite funny that templates cause this. > Source/WTF/wtf/FastBitVector.h:487 > + for (unsigned i = arrayLength(); i--;) > + m_words.word(i) |= other.m_words.word(i); I wonder if there is any way to do this lazily like you do with "|" and "&" and "~" operators. Do you think it'd be worth it? > Source/WTF/wtf/FastBitVector.h:543 > + BitReference at(size_t index) > + { > + ASSERT_WITH_SECURITY_IMPLICATION(index < numBits()); > + return BitReference(&m_words.word(index >> 5), 1 << (index & 31)); > + } Why not just return a bool? Or is this a way to cache a live update view on the bit vector? > Source/WTF/wtf/StdLibExtras.h:321 > +bool findBitInWord(T word, size_t& index, size_t endIndex, bool value) I wonder if we should enforce unsigned type here. Otherwise, the shift below can cause a loop to never terminate. Maybe it's worth a static_assert that T is unsigned? 1228661 6 fpizlo 2016-09-11 18:25:11 -0700 (In reply to comment #5) > Comment on attachment 288536 [details] > the patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=288536&action=review > > r=me with comments/suggestions. > > > Source/WTF/ChangeLog:38 > > + uint32_t word(size_t index) { return b.m_words.word(index) | ~c.m_words.word(index); } > > It's cool to do this on the fly, I like that strategy. > > > Source/WTF/ChangeLog:52 > > + I think that it's harder to see what is going on here, then using operators, because infix > > I agree. FWIW, I've never been a fan of the name 'filter' over set language > like 'intersection'. > > > Source/WTF/wtf/FastBitVector.h:37 > > +inline size_t fastBitVectorArrayLength(size_t numBits) { return (numBits + 31) >> 5; } > > Nit: I think it is easier to understand what this is doing if you wrote it > as "/ 32" instead of ">> 5". I once got bit by expecting this strength reduction to happen, but forgetting that I was using signed. Once I realized my mistake I vowed to always say ">>" when that's what I meant. I guess that was a long time ago. I'll change it. > > > Source/WTF/wtf/FastBitVector.h:96 > > + memcpy(m_words, other.m_words, length * 4); > > Style: I'm not a big fan of using 4 everywhere. Even though it's more > verbose, I think everything is clearer if you defined a constant somewhere > as sizeof(uint32_t) and used it instead of 4. FWIW that was copied from the code that was there already. I'll change it. > > > Source/WTF/wtf/FastBitVector.h:99 > > uint32_t* newArray = static_cast<uint32_t*>(fastCalloc(length, 4)); > > Why calloc if you're going to memcpy afterwords? Why not just fast malloc? Security shmecurity: fastCalloc() does the length * 4 in an overflow-safe way. We could make this call fastMalloc, but then we'd have to be careful. I'd rather not worry about it in this patch. > > > Source/WTF/wtf/FastBitVector.h:117 > > + memset(m_words, 255, arrayLength() * 4); > > Nit: I'd use std::numeric_limits here or UCHAR_MAX I'll keep this one alone. I think that 255 is pretty clear. > > > Source/WTF/wtf/FastBitVector.h:180 > > +template<typename Left, typename Right> > > +class FastBitVectorAndWords { > > +public: > > Suggestion: another possibility is to define a template over a third type > which is some sort of enum like: > BinaryOp { > And, Or > } > and then have the `uint32_t word(size_t index)` switch over the BinaryOp. > That way you don't > have two classes that are doing almost the same thing. True. I was already getting lost in the abstractions in this code, so I didn't want to add any more abstractions on top of that. To me, the code duplication here is less evil than additional abstraction. > > > Source/WTF/wtf/FastBitVector.h:255 > > + return !m_view.word(index); > > This should be "~", right? Of course! Ooops! > > > Source/WTF/wtf/FastBitVector.h:346 > > unsigned j = i << 5; > > Style: ditto about *32 instead of <<. And this should be a size_t and not > unsigned. Right. > > > Source/WTF/wtf/FastBitVector.h:359 > > + // I'm pretty sure that this is the most efficient way to do this. > > I don't think this comment adds anything. I also think I agree with it since > the above loop bails on words early if they are empty. I'm not sure how > you'd do the same thing if you manually wrote such a loop for clear bits. That's the thing, there is possibly a better way: downshift with carry. Just as you can downshift with zero extend or sign extend, you can also downshift with arbitrary bits used as the extend. This is used for implementing 64-bit >> on 32-bit systems: you do a 32-bit downshift "with carry", which fills the upper part of the word with bits shifted out of some other register. Here we'd want the word>>=1 to do a 1-fill. I think we could do that with an rshift w/ carry. That would let us avoid the bitnot instruction. And here's the kicker: this would mean that we could have common code for the forEachSetBit and forEachClearBit paths, because we could do either 0-fill or 1-fill depending on 'value' (0-fill if the skip value is 0 or 1-fill if the skip value is -1). I'll remove the comment. > > > Source/WTF/wtf/FastBitVector.h:370 > > + void forEachBit(bool value, const Func& func) const > > + { > > + if (value) > > + forEachSetBit(func); > > + else > > + forEachClearBit(func); > > + } > > What's this going to be used for? Probably one of the GC passes. I wanted an API that felt complete so that I could start brainstorming the GC stuff. Here's a possible example: void forEachBlockIn(Generation generation, const Func& func) { m_eden.forEachBit(generation == Eden, [&] (size_t blockIndex) { func(m_blocks[blockIndex]); }); } > > > Source/WTF/wtf/FastBitVector.h:378 > > + ALWAYS_INLINE size_t findBit(size_t startIndex, bool value) const > > Is this going to be used for some GC stuff? If the only use is that loop, > then shouldn't we just use forEachSetBit instead? This is going to be used in the GC. It's not supposed to be used for that loop, but it's useful to remember that loop when understanding the semantics of findBit(). Our GC does lots of incremental block walks. With the bitvector approach, you'd remember the last index you looked at, and then you'd findBit(lastIndex + 1, true). > > > Source/WTF/wtf/FastBitVector.h:380 > > + uint32_t skipValue = -(static_cast<uint32_t>(value) ^ 1); > > Since this will always be inlined, I'd just write this as: > uint32_t skipValue = value ? 0 : UINT_MAX; No, because your code isn't necessarily as efficient when 'value' is a variable. Just because the code is inlined does not mean that the caller statically knew the value of 'value'! Maybe LLVM would know how to reduce select(value, 0, UINT_MAX) to what I wrote. But why risk that? > > Otherwise, it's just super confusing to read what this code is doing. At > first, I thought it was a bug for it to be "-", and not "~", but then I > realized that's intended. I know it's confusing, but I think we need it. > > > Source/WTF/wtf/FastBitVector.h:384 > > + size_t wordIndex = startIndex >> 5; > > + size_t startIndexInWord = startIndex - (wordIndex << 5); > > Style: ditto shifts for division/multiplication. OK. > > > Source/WTF/wtf/FastBitVector.h:419 > > + // You'd think that we could remove this friend if we used protected, but you'd be wrong, > > + // because templates. > > Nit: I don't think this comment adds much. But it is quite funny that > templates cause this. > > > Source/WTF/wtf/FastBitVector.h:487 > > + for (unsigned i = arrayLength(); i--;) > > + m_words.word(i) |= other.m_words.word(i); > > I wonder if there is any way to do this lazily like you do with "|" and "&" > and "~" operators. Do you think it'd be worth it? This is easier to compile, and makes it way obvious to the compiler that the load from m_words.word(i) and the store back to m_words.word(i) can be combined into a single instruction without changing program behavior. If we abstracted this behind operator= and operator|, then the load wouldn't be so obviously close to the store anymore. > > > Source/WTF/wtf/FastBitVector.h:543 > > + BitReference at(size_t index) > > + { > > + ASSERT_WITH_SECURITY_IMPLICATION(index < numBits()); > > + return BitReference(&m_words.word(index >> 5), 1 << (index & 31)); > > + } > > Why not just return a bool? Or is this a way to cache a live update view on > the bit vector? Then 'bitVector[index] = true' wouldn't work. > > > Source/WTF/wtf/StdLibExtras.h:321 > > +bool findBitInWord(T word, size_t& index, size_t endIndex, bool value) > > I wonder if we should enforce unsigned type here. Otherwise, the shift below > can cause a loop to never terminate. Maybe it's worth a static_assert that T > is unsigned? OK. 1228664 7 saam 2016-09-11 18:40:08 -0700 (In reply to comment #6) > (In reply to comment #5) > > Comment on attachment 288536 [details] > > the patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=288536&action=review > > > > r=me with comments/suggestions. > > > > > Source/WTF/ChangeLog:38 > > > + uint32_t word(size_t index) { return b.m_words.word(index) | ~c.m_words.word(index); } > > > > It's cool to do this on the fly, I like that strategy. > > > > > Source/WTF/ChangeLog:52 > > > + I think that it's harder to see what is going on here, then using operators, because infix > > > > I agree. FWIW, I've never been a fan of the name 'filter' over set language > > like 'intersection'. > > > > > Source/WTF/wtf/FastBitVector.h:37 > > > +inline size_t fastBitVectorArrayLength(size_t numBits) { return (numBits + 31) >> 5; } > > > > Nit: I think it is easier to understand what this is doing if you wrote it > > as "/ 32" instead of ">> 5". > > I once got bit by expecting this strength reduction to happen, but > forgetting that I was using signed. Once I realized my mistake I vowed to > always say ">>" when that's what I meant. > > I guess that was a long time ago. I'll change it. > > > > > > Source/WTF/wtf/FastBitVector.h:96 > > > + memcpy(m_words, other.m_words, length * 4); > > > > Style: I'm not a big fan of using 4 everywhere. Even though it's more > > verbose, I think everything is clearer if you defined a constant somewhere > > as sizeof(uint32_t) and used it instead of 4. > > FWIW that was copied from the code that was there already. I'll change it. > > > > > > Source/WTF/wtf/FastBitVector.h:99 > > > uint32_t* newArray = static_cast<uint32_t*>(fastCalloc(length, 4)); > > > > Why calloc if you're going to memcpy afterwords? Why not just fast malloc? > > Security shmecurity: fastCalloc() does the length * 4 in an overflow-safe > way. > > We could make this call fastMalloc, but then we'd have to be careful. I'd > rather not worry about it in this patch. > > > > > > Source/WTF/wtf/FastBitVector.h:117 > > > + memset(m_words, 255, arrayLength() * 4); > > > > Nit: I'd use std::numeric_limits here or UCHAR_MAX > > I'll keep this one alone. I think that 255 is pretty clear. > > > > > > Source/WTF/wtf/FastBitVector.h:180 > > > +template<typename Left, typename Right> > > > +class FastBitVectorAndWords { > > > +public: > > > > Suggestion: another possibility is to define a template over a third type > > which is some sort of enum like: > > BinaryOp { > > And, Or > > } > > and then have the `uint32_t word(size_t index)` switch over the BinaryOp. > > That way you don't > > have two classes that are doing almost the same thing. > > True. I was already getting lost in the abstractions in this code, so I > didn't want to add any more abstractions on top of that. To me, the code > duplication here is less evil than additional abstraction. > > > > > > Source/WTF/wtf/FastBitVector.h:255 > > > + return !m_view.word(index); > > > > This should be "~", right? > > Of course! Ooops! > > > > > > Source/WTF/wtf/FastBitVector.h:346 > > > unsigned j = i << 5; > > > > Style: ditto about *32 instead of <<. And this should be a size_t and not > > unsigned. > > Right. > > > > > > Source/WTF/wtf/FastBitVector.h:359 > > > + // I'm pretty sure that this is the most efficient way to do this. > > > > I don't think this comment adds anything. I also think I agree with it since > > the above loop bails on words early if they are empty. I'm not sure how > > you'd do the same thing if you manually wrote such a loop for clear bits. > > That's the thing, there is possibly a better way: downshift with carry. Just > as you can downshift with zero extend or sign extend, you can also downshift > with arbitrary bits used as the extend. This is used for implementing 64-bit > >> on 32-bit systems: you do a 32-bit downshift "with carry", which fills > the upper part of the word with bits shifted out of some other register. > > Here we'd want the word>>=1 to do a 1-fill. I think we could do that with > an rshift w/ carry. > > That would let us avoid the bitnot instruction. > > And here's the kicker: this would mean that we could have common code for > the forEachSetBit and forEachClearBit paths, because we could do either > 0-fill or 1-fill depending on 'value' (0-fill if the skip value is 0 or > 1-fill if the skip value is -1). > > I'll remove the comment. > > > > > > Source/WTF/wtf/FastBitVector.h:370 > > > + void forEachBit(bool value, const Func& func) const > > > + { > > > + if (value) > > > + forEachSetBit(func); > > > + else > > > + forEachClearBit(func); > > > + } > > > > What's this going to be used for? > > Probably one of the GC passes. I wanted an API that felt complete so that I > could start brainstorming the GC stuff. > > Here's a possible example: > > void forEachBlockIn(Generation generation, const Func& func) > { > m_eden.forEachBit(generation == Eden, [&] (size_t blockIndex) { > func(m_blocks[blockIndex]); }); > } > > > > > > Source/WTF/wtf/FastBitVector.h:378 > > > + ALWAYS_INLINE size_t findBit(size_t startIndex, bool value) const > > > > Is this going to be used for some GC stuff? If the only use is that loop, > > then shouldn't we just use forEachSetBit instead? > > This is going to be used in the GC. It's not supposed to be used for that > loop, but it's useful to remember that loop when understanding the semantics > of findBit(). > > Our GC does lots of incremental block walks. With the bitvector approach, > you'd remember the last index you looked at, and then you'd > findBit(lastIndex + 1, true). > > > > > > Source/WTF/wtf/FastBitVector.h:380 > > > + uint32_t skipValue = -(static_cast<uint32_t>(value) ^ 1); > > > > Since this will always be inlined, I'd just write this as: > > uint32_t skipValue = value ? 0 : UINT_MAX; > > No, because your code isn't necessarily as efficient when 'value' is a > variable. Just because the code is inlined does not mean that the caller > statically knew the value of 'value'! > > Maybe LLVM would know how to reduce select(value, 0, UINT_MAX) to what I > wrote. But why risk that? Yeah, I wasn't thinking about the case where 'value' wasn't a constant. I agree with keeping this how it is. However, this is one of those rare occasions where I'd advocate for a comment with the more obvious code above it to describe what's happening. > > > > > Otherwise, it's just super confusing to read what this code is doing. At > > first, I thought it was a bug for it to be "-", and not "~", but then I > > realized that's intended. > > I know it's confusing, but I think we need it. > > > > > > Source/WTF/wtf/FastBitVector.h:384 > > > + size_t wordIndex = startIndex >> 5; > > > + size_t startIndexInWord = startIndex - (wordIndex << 5); > > > > Style: ditto shifts for division/multiplication. > > OK. > > > > > > Source/WTF/wtf/FastBitVector.h:419 > > > + // You'd think that we could remove this friend if we used protected, but you'd be wrong, > > > + // because templates. > > > > Nit: I don't think this comment adds much. But it is quite funny that > > templates cause this. > > > > > Source/WTF/wtf/FastBitVector.h:487 > > > + for (unsigned i = arrayLength(); i--;) > > > + m_words.word(i) |= other.m_words.word(i); > > > > I wonder if there is any way to do this lazily like you do with "|" and "&" > > and "~" operators. Do you think it'd be worth it? > > This is easier to compile, and makes it way obvious to the compiler that the > load from m_words.word(i) and the store back to m_words.word(i) can be > combined into a single instruction without changing program behavior. If we > abstracted this behind operator= and operator|, then the load wouldn't be so > obviously close to the store anymore. > > > > > > Source/WTF/wtf/FastBitVector.h:543 > > > + BitReference at(size_t index) > > > + { > > > + ASSERT_WITH_SECURITY_IMPLICATION(index < numBits()); > > > + return BitReference(&m_words.word(index >> 5), 1 << (index & 31)); > > > + } > > > > Why not just return a bool? Or is this a way to cache a live update view on > > the bit vector? > > Then 'bitVector[index] = true' wouldn't work. > > > > > > Source/WTF/wtf/StdLibExtras.h:321 > > > +bool findBitInWord(T word, size_t& index, size_t endIndex, bool value) > > > > I wonder if we should enforce unsigned type here. Otherwise, the shift below > > can cause a loop to never terminate. Maybe it's worth a static_assert that T > > is unsigned? > > OK. 1228674 8 fpizlo 2016-09-11 21:06:10 -0700 Landed in https://trac.webkit.org/changeset/205794 288529 2016-09-11 10:46:49 -0700 2016-09-11 15:46:05 -0700 work in progress blah.patch text/plain 32853 fpizlo SW5kZXg6IFNvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkocmV2aXNpb24g MjA1NzY3KQorKysgU291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkod29y a2luZyBjb3B5KQpAQCAtMzEsNyArMzEsNiBAQAogCQkwRjgyNEE2ODFCNzQ0M0EwMDAyRTM0NUQg LyogUGFya2luZ0xvdC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSAwRjgyNEE2NDFCNzQ0M0EwMDAyRTM0NUQgLyogUGFya2luZ0xvdC5jcHAgKi87IH07 CiAJCTBGODI0QTY5MUI3NDQzQTAwMDJFMzQ1RCAvKiBQYXJraW5nTG90LmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwRjgyNEE2NTFCNzQ0M0EwMDAyRTM0 NUQgLyogUGFya2luZ0xvdC5oICovOyB9OwogCQkwRjg3MTA1QTE2NjQzRjE5MDA5MEIwQUQgLyog UmF3UG9pbnRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gMEY4NzEwNTkxNjY0M0YxOTAwOTBCMEFEIC8qIFJhd1BvaW50ZXIuaCAqLzsgfTsKLQkJMEY4 ODVFMEYxODQ1QUVBOTAwRjFFM0ZBIC8qIEZhc3RCaXRWZWN0b3IuY3BwIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMEY4ODVFMEUxODQ1QUU5RjAwRjFFM0ZB IC8qIEZhc3RCaXRWZWN0b3IuY3BwICovOyB9OwogCQkwRjhGMkI5MTE3MkUwMEZDMDA3REJEQTUg LyogQ29tcGlsYXRpb25UaHJlYWQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDBGOEYyQjkwMTcyRTAwRjAwMDdEQkRBNSAvKiBDb21waWxhdGlvblRocmVh ZC5oICovOyB9OwogCQkwRjhGMkI5MjE3MkUwMTAzMDA3REJEQTUgLyogQ29tcGlsYXRpb25UaHJl YWQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMEY4 RjJCOEYxNzJFMDBGMDAwN0RCREE1IC8qIENvbXBpbGF0aW9uVGhyZWFkLmNwcCAqLzsgfTsKIAkJ MEY4RjJCOUMxNzJGMjU5NjAwN0RCREE1IC8qIENvbnZlcnNpb25Nb2RlLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwRjhGMkI5QjE3MkYyNTk0MDA3REJE QTUgLyogQ29udmVyc2lvbk1vZGUuaCAqLzsgfTsKQEAgLTExMSw2ICsxMTAsNyBAQAogCQkyQ0RF RDBGMzE4MTE1Qzg1MDA0REJBNzAgLyogUnVuTG9vcC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQ0RFRDBGMTE4MTE1Qzg1MDA0REJBNzAgLyogUnVu TG9vcC5jcHAgKi87IH07CiAJCTJDREVEMEY0MTgxMTVDODUwMDREQkE3MCAvKiBSdW5Mb29wLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyQ0RFRDBGMjE4 MTE1Qzg1MDA0REJBNzAgLyogUnVuTG9vcC5oICovOyB9OwogCQk0MzBCNDc4OTFBQUFBQzFBMDAx MjIzREEgLyogU3RyaW5nQ29tbW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA0MzBCNDc4NzFBQUFBQzFBMDAxMjIzREEgLyogU3RyaW5nQ29tbW9uLmgg Ki87IH07CisJCTRCMjY4MEREOUI5NzQ0MDI4OTlFRDU3MiAvKiBJbmRleGVkQ29udGFpbmVySXRl cmF0b3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDlD NjdDNTQyNTg5MzQ4RTI4NUI0OTY5OSAvKiBJbmRleGVkQ29udGFpbmVySXRlcmF0b3IuaCAqLzsg fTsKIAkJNTEzRTE3MEIxQ0Q3RDVCRjAwRTM2NTBCIC8qIExvZ2dpbmdBY2N1bXVsYXRvci5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTEzRTE3MEExQ0Q3 RDVCRjAwRTM2NTBCIC8qIExvZ2dpbmdBY2N1bXVsYXRvci5oICovOyB9OwogCQk1MTVGNzk0RTFD RkM5RjRBMDBDQ0VEOTMgLyogQ3Jvc3NUaHJlYWRDb3BpZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE1Rjc5NEIxQ0ZDOUY0QTAwQ0NFRDkzIC8q IENyb3NzVGhyZWFkQ29waWVyLmNwcCAqLzsgfTsKIAkJNTE1Rjc5NEYxQ0ZDOUY0QTAwQ0NFRDkz IC8qIENyb3NzVGhyZWFkQ29waWVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1MTVGNzk0QzFDRkM5RjRBMDBDQ0VEOTMgLyogQ3Jvc3NUaHJlYWRDb3Bp ZXIuaCAqLzsgfTsKQEAgLTMxNSw2ICszMTUsOCBAQAogCQlBOEE0NzQ4QzE1MUE4MjY0MDA0MTIz RkYgLyogY29uZmlnLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBBOEE0NzQ4QjE1MUE4MjY0MDA0MTIzRkYgLyogY29uZmlnLmggKi87IH07CiAJCUIzOEZE N0JEMTY4OTUzRTgwMDY1Qzk2OSAvKiBGZWF0dXJlRGVmaW5lcy5oIGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQjM4RkQ3QkMxNjg5NTNFODAwNjVDOTY5IC8q IEZlYXR1cmVEZWZpbmVzLmggKi87IH07CiAJCUM0RjhBOTM3MTlDNjVFQjQwMEIyQjE1RCAvKiBT dG9wd2F0Y2guaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEM0RjhBOTM2MTlDNjVFQjQwMEIyQjE1RCAvKiBTdG9wd2F0Y2guaCAqLzsgfTsKKwkJQzhCMEUx QTFFMDFBNDg2RUI5NUUwRDExIC8qIEluZGV4U2V0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzMTM3RTFEN0RCRDg0QUMzOEZBRTREMzQgLyogSW5kZXhT ZXQuaCAqLzsgfTsKKwkJQzkxNkI5NzVGMDJGNEY3RThCNEFCMTJEIC8qIEluZGV4TWFwLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1QjQzMzgzQTVEMEI0 NjNDOTQzM0Q5MzMgLyogSW5kZXhNYXAuaCAqLzsgfTsKIAkJQ0Q1NDk3QUMxNTg1N0QwMzAwQjVC QzMwIC8qIE1lZGlhVGltZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBDRDU0OTdBQTE1ODU3RDAzMDBCNUJDMzAgLyogTWVkaWFUaW1lLmNwcCAqLzsg fTsKIAkJQ0Q1NDk3QUQxNTg1N0QwMzAwQjVCQzMwIC8qIE1lZGlhVGltZS5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0Q1NDk3QUIxNTg1N0QwMzAwQjVC QzMwIC8qIE1lZGlhVGltZS5oICovOyB9OwogCQlDRTQ2NTE2RTE5REIxRkI0MDAzRUNBMDUgLyog TlNNYXBUYWJsZVNQSS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gQ0U0NjUxNkQxOURCMUZCNDAwM0VDQTA1IC8qIE5TTWFwVGFibGVTUEkuaCAqLzsgfTsK QEAgLTMzNiw5ICszMzgsNiBAQAogCQlGRTg5MjVCMDFEMDBEQUVDMDA0NjkwN0UgLyogSW5kZW50 ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFODky NUFGMUQwMERBRUMwMDQ2OTA3RSAvKiBJbmRlbnRlci5oICovOyB9OwogCQlGRURBQ0QzRDE2MzBG ODNGMDBDNjk2MzQgLyogU3RhY2tTdGF0cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBGRURBQ0QzQjE2MzBGODNGMDBDNjk2MzQgLyogU3RhY2tTdGF0 cy5jcHAgKi87IH07CiAJCUZFREFDRDNFMTYzMEY4M0YwMEM2OTYzNCAvKiBTdGFja1N0YXRzLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRURBQ0QzQzE2 MzBGODNGMDBDNjk2MzQgLyogU3RhY2tTdGF0cy5oICovOyB9OwotCQlDOEIwRTFBMUUwMUE0ODZF Qjk1RTBEMTEgLyogSW5kZXhTZXQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDMxMzdFMUQ3REJEODRBQzM4RkFFNEQzNCAvKiBJbmRleFNldC5oICovOyB9 OwotCQlDOTE2Qjk3NUYwMkY0RjdFOEI0QUIxMkQgLyogSW5kZXhNYXAuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDVCNDMzODNBNUQwQjQ2M0M5NDMzRDkz MyAvKiBJbmRleE1hcC5oICovOyB9OwotCQk0QjI2ODBERDlCOTc0NDAyODk5RUQ1NzIgLyogSW5k ZXhlZENvbnRhaW5lckl0ZXJhdG9yLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA5QzY3QzU0MjU4OTM0OEUyODVCNDk2OTkgLyogSW5kZXhlZENvbnRhaW5l ckl0ZXJhdG9yLmggKi87IH07CiAvKiBFbmQgUEJYQnVpbGRGaWxlIHNlY3Rpb24gKi8KIAogLyog QmVnaW4gUEJYQ29udGFpbmVySXRlbVByb3h5IHNlY3Rpb24gKi8KQEAgLTM3MCw3ICszNjksNiBA QAogCQkwRjgyNEE2NDFCNzQ0M0EwMDAyRTM0NUQgLyogUGFya2luZ0xvdC5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBQYXJraW5nTG90LmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJMEY4MjRBNjUxQjc0NDNBMDAwMkUzNDVEIC8qIFBhcmtpbmdMb3Qu aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGFya2luZ0xvdC5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQkwRjg3MTA1OTE2NjQzRjE5MDA5MEIwQUQgLyogUmF3UG9p bnRlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSYXdQb2ludGVyLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0JCTBGODg1RTBFMTg0NUFFOUYwMEYxRTNGQSAvKiBG YXN0Qml0VmVjdG9yLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZhc3RCaXRWZWN0b3IuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwRjhGMkI4RjE3MkUwMEYwMDA3REJEQTUgLyog Q29tcGlsYXRpb25UaHJlYWQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQ29tcGlsYXRpb25UaHJl YWQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkwRjhGMkI5MDE3MkUwMEYwMDA3 REJEQTUgLyogQ29tcGlsYXRpb25UaHJlYWQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQ29tcGlsYXRpb25U aHJlYWQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMEY4RjJCOUIxNzJGMjU5NDAw N0RCREE1IC8qIENvbnZlcnNpb25Nb2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvbnZlcnNpb25Nb2Rl Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC00NTMsNiArNDUxLDcgQEAKIAkJMkNE RUQwRUUxODExNUMzODAwNERCQTcwIC8qIFJ1bkxvb3BDRi5jcHAgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBSdW5Mb29wQ0YuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQkyQ0RFRDBGMTE4MTE1Qzg1MDA0REJBNzAgLyogUnVuTG9vcC5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSdW5Mb29wLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJMkNERUQwRjIxODExNUM4NTAwNERCQTcwIC8qIFJ1bkxvb3AuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUnVuTG9vcC5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OworCQkzMTM3RTFEN0RCRDg0QUMzOEZBRTREMzQgLyogSW5kZXhTZXQuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5kZXhTZXQuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJNDMwQjQ3ODcxQUFBQUMxQTAwMTIyM0RBIC8qIFN0cmluZ0NvbW1vbi5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTdHJpbmdDb21tb24uaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTEzRTE3MEExQ0Q3RDVCRjAwRTM2NTBCIC8qIExvZ2dp bmdBY2N1bXVsYXRvci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBMb2dnaW5n QWNjdW11bGF0b3IuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE1Rjc5NEIxQ0ZD OUY0QTAwQ0NFRDkzIC8qIENyb3NzVGhyZWFkQ29waWVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IENyb3NzVGhyZWFkQ29waWVyLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKQEAgLTQ2MSw2ICs0NjAsNyBAQAogCQk1MTVGNzk1NTFDRkQzQTY5MDBDQ0VE OTMgLyogQ3Jvc3NUaHJlYWRRdWV1ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBDcm9zc1RocmVhZFF1ZXVlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTUzOUVC MDYyMUQ1NTI4NDIwMEM4MkVGNyAvKiBMRUJEZWNvZGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IExFQkRlY29kZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ NTUzMDcxQzkxQzQwNDI3MjAwMzg0ODk4IC8qIFRpbnlMUlVDYWNoZS5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBUaW55TFJVQ2FjaGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJNUI0MzM4M0E1RDBCNDYzQzk0MzNEOTMzIC8qIEluZGV4TWFwLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEluZGV4TWFwLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTVDN0M4OEQzMUQwQTNBMEEwMDlEMkY2RCAvKiBVbmlxdWVSZWYuaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVW5pcXVlUmVmLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTVEMjQ3QjYyMTQ2ODlCODYwMEU3OEI3NiAvKiBsaWJXVEYuYSAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBleHBsaWNpdEZpbGVUeXBlID0gYXJjaGl2ZS5hcjsgaW5j bHVkZUluSW5kZXggPSAwOyBwYXRoID0gbGliV1RGLmE7IHNvdXJjZVRyZWUgPSBCVUlMVF9QUk9E VUNUU19ESVI7IH07CiAJCTVEMjQ3QjZFMTQ2ODlDNDcwMEU3OEI3NiAvKiBCYXNlLnhjY29uZmln ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC54 Y2NvbmZpZzsgcGF0aCA9IEJhc2UueGNjb25maWc7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC00OTEsNiArNDkxLDcgQEAKIAkJOTc0Q0ZDOEQxNkE0RjMyNzAwNkQ1NDA0IC8qIFdlYWtQ dHIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2Vha1B0ci5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk5QkM3MEYwNDE3NkMzNzlEMDAxMDFERUMgLyogQXRvbWlj U3RyaW5nVGFibGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXRv bWljU3RyaW5nVGFibGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk5QkQ4RjQw QTE3NkMyQUQ4MDAwMkQ4NjUgLyogQXRvbWljU3RyaW5nVGFibGUuaCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g QXRvbWljU3RyaW5nVGFibGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOUM2N0M1 NDI1ODkzNDhFMjg1QjQ5Njk5IC8qIEluZGV4ZWRDb250YWluZXJJdGVyYXRvci5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBJbmRleGVkQ29udGFpbmVySXRlcmF0b3IuaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQTUwOThBRkYxQzE2OUUwNzAwMDg3Nzk3IC8qIFNh bmRib3hTUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU2FuZGJveFNQSS5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBNTA5OEIwMTFDMTZBNEY5MDAwODc3OTcg LyogU2VjdXJpdHlTUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU2VjdXJp dHlTUEkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQTVCQTE1RjIxODI0MzNBOTAw QTgyRTY5IC8qIFN0cmluZ01hYy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsg bmFtZSA9IFN0cmluZ01hYy5tbTsgcGF0aCA9IG1hYy9TdHJpbmdNYWMubW07IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CkBAIC02ODcsOSArNjg4LDYgQEAKIAkJRkU4OTI1QUYxRDAwREFFQzAw NDY5MDdFIC8qIEluZGVudGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IElu ZGVudGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFREFDRDNCMTYzMEY4M0Yw MEM2OTYzNCAvKiBTdGFja1N0YXRzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IFN0YWNrU3RhdHMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRURB Q0QzQzE2MzBGODNGMDBDNjk2MzQgLyogU3RhY2tTdGF0cy5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBTdGFja1N0YXRzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0J CTMxMzdFMUQ3REJEODRBQzM4RkFFNEQzNCAvKiBJbmRleFNldC5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IG5hbWUgPSBJbmRleFNldC5oOyBwYXRoID0gSW5kZXhTZXQuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKLQkJNUI0MzM4M0E1RDBCNDYzQzk0MzNEOTMzIC8qIEluZGV4TWFw LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IEluZGV4TWFwLmg7IHBhdGggPSBJ bmRleE1hcC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQk5QzY3QzU0MjU4OTM0OEUy ODVCNDk2OTkgLyogSW5kZXhlZENvbnRhaW5lckl0ZXJhdG9yLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgbmFtZSA9IEluZGV4ZWRDb250YWluZXJJdGVyYXRvci5oOyBwYXRoID0gSW5kZXhl ZENvbnRhaW5lckl0ZXJhdG9yLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAvKiBFbmQg UEJYRmlsZVJlZmVyZW5jZSBzZWN0aW9uICovCiAKIC8qIEJlZ2luIFBCWEZyYW1ld29ya3NCdWls ZFBoYXNlIHNlY3Rpb24gKi8KQEAgLTg4Miw3ICs4ODAsNiBAQAogCQkJCUE4QTQ3Mjk4MTUxQTgy NUEwMDQxMjNGRiAvKiBkdG9hLmggKi8sCiAJCQkJMUFFQTg4RTExRDZCQkNGNDAwRTVBRDY0IC8q IEVudW1UcmFpdHMuaCAqLywKIAkJCQlBOEE0NzI5RjE1MUE4MjVBMDA0MTIzRkYgLyogRXhwb3J0 TWFjcm9zLmggKi8sCi0JCQkJMEY4ODVFMEUxODQ1QUU5RjAwRjFFM0ZBIC8qIEZhc3RCaXRWZWN0 b3IuY3BwICovLAogCQkJCTBGRDgxQUM0MTU0RkIyMkUwMDk4M0U3MiAvKiBGYXN0Qml0VmVjdG9y LmggKi8sCiAJCQkJQThBNDcyQTExNTFBODI1QTAwNDEyM0ZGIC8qIEZhc3RNYWxsb2MuY3BwICov LAogCQkJCUE4QTQ3MkEyMTUxQTgyNUEwMDQxMjNGRiAvKiBGYXN0TWFsbG9jLmggKi8sCkBAIC0x NTg0LDcgKzE1ODEsNiBAQAogCQkJCUE4QTQ3M0IwMTUxQTgyNUIwMDQxMjNGRiAvKiBkb3VibGUt Y29udmVyc2lvbi5jYyBpbiBTb3VyY2VzICovLAogCQkJCUE4QTQ3M0JBMTUxQTgyNUIwMDQxMjNG RiAvKiBkdG9hLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUE4QTQ3M0IzMTUxQTgyNUIwMDQxMjNG RiAvKiBmYXN0LWR0b2EuY2MgaW4gU291cmNlcyAqLywKLQkJCQkwRjg4NUUwRjE4NDVBRUE5MDBG MUUzRkEgLyogRmFzdEJpdFZlY3Rvci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBOEE0NzNDMzE1 MUE4MjVCMDA0MTIzRkYgLyogRmFzdE1hbGxvYy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkwRjlE MzM2MDE2NURCQTczMDA1QUQzODcgLyogRmlsZVByaW50U3RyZWFtLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCUE4QTQ3M0I1MTUxQTgyNUIwMDQxMjNGRiAvKiBmaXhlZC1kdG9hLmNjIGluIFNvdXJj ZXMgKi8sCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9CaXRWZWN0b3IuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV1RGL3d0Zi9CaXRWZWN0b3IuaAkocmV2aXNpb24gMjA1NzY3KQorKysgU291cmNlL1dU Ri93dGYvQml0VmVjdG9yLmgJKHdvcmtpbmcgY29weSkKQEAgLTQwMywyMSArNDAzLDYgQEAgcHJp dmF0ZToKICAgICAgICAgcmV0dXJuIHNpemUoKTsKICAgICB9CiAgICAgCi0gICAgc3RhdGljIGJv b2wgZmluZEJpdEluV29yZCh1aW50cHRyX3Qgd29yZCwgc2l6ZV90JiBpbmRleCwgc2l6ZV90IGVu ZEluZGV4LCBib29sIHZhbHVlKQotICAgIHsKLSAgICAgICAgd29yZCA+Pj0gaW5kZXg7Ci0gICAg ICAgIAotICAgICAgICB3aGlsZSAoaW5kZXggPCBlbmRJbmRleCkgewotICAgICAgICAgICAgaWYg KCh3b3JkICYgMSkgPT0gc3RhdGljX2Nhc3Q8dWludHB0cl90Pih2YWx1ZSkpCi0gICAgICAgICAg ICAgICAgcmV0dXJuIHRydWU7Ci0gICAgICAgICAgICBpbmRleCsrOwotICAgICAgICAgICAgd29y ZCA+Pj0gMTsKLSAgICAgICAgfQotCi0gICAgICAgIGluZGV4ID0gZW5kSW5kZXg7Ci0gICAgICAg IHJldHVybiBmYWxzZTsKLSAgICB9Ci0gICAgCiAgICAgY2xhc3MgT3V0T2ZMaW5lQml0cyB7CiAg ICAgcHVibGljOgogICAgICAgICBzaXplX3QgbnVtQml0cygpIGNvbnN0IHsgcmV0dXJuIG1fbnVt Qml0czsgfQpJbmRleDogU291cmNlL1dURi93dGYvQ01ha2VMaXN0cy50eHQKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dURi93dGYvQ01ha2VMaXN0cy50eHQJKHJldmlzaW9uIDIwNTc2NykKKysrIFNv dXJjZS9XVEYvd3RmL0NNYWtlTGlzdHMudHh0CSh3b3JraW5nIGNvcHkpCkBAIC0xODEsNyArMTgx LDYgQEAgc2V0KFdURl9TT1VSQ0VTCiAgICAgRGF0YUxvZy5jcHAKICAgICBEYXRlTWF0aC5jcHAK ICAgICBEZWNpbWFsTnVtYmVyLmNwcAotICAgIEZhc3RCaXRWZWN0b3IuY3BwCiAgICAgRmFzdE1h bGxvYy5jcHAKICAgICBGaWxlUHJpbnRTdHJlYW0uY3BwCiAgICAgRnVuY3Rpb25EaXNwYXRjaGVy LmNwcApJbmRleDogU291cmNlL1dURi93dGYvRmFzdEJpdFZlY3Rvci5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dURi93dGYvRmFzdEJpdFZlY3Rvci5jcHAJKHJldmlzaW9uIDIwNTc2NykKKysr IFNvdXJjZS9XVEYvd3RmL0Zhc3RCaXRWZWN0b3IuY3BwCShub25leGlzdGVudCkKQEAgLTEsNDAg KzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMyBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0g KiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK LSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBB UFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFO VElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQotICogSU1QTElFRCBXQVJS QU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCi0g KiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBP UgotICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsCi0gKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCi0gKiBQUk9DVVJFTUVOVCBPRiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKLSAqIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkKLSAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAotICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCi0gKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLiAKLSAqLwotCi0j aW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiRmFzdEJpdFZlY3Rvci5oIgotCi0jaW5jbHVk ZSAiUHJpbnRTdHJlYW0uaCIKLQotbmFtZXNwYWNlIFdURiB7Ci0KLXZvaWQgRmFzdEJpdFZlY3Rv cjo6ZHVtcChQcmludFN0cmVhbSYgb3V0KSBjb25zdAotewotICAgIGZvciAodW5zaWduZWQgaSA9 IDA7IGkgPCBtX251bUJpdHM7ICsraSkKLSAgICAgICAgb3V0LnByaW50KGdldChpKSA/ICIxIiA6 ICItIik7Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFdURgotCkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9G YXN0Qml0VmVjdG9yLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvRmFzdEJpdFZlY3Rv ci5oCShyZXZpc2lvbiAyMDU3NjcpCisrKyBTb3VyY2UvV1RGL3d0Zi9GYXN0Qml0VmVjdG9yLmgJ KHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDEy LCAyMDEzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykg MjAxMiwgMjAxMywgMjAxNiBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTMzLDQyICszMywxMDkgQEAgbmFtZXNwYWNlIFdU RiB7CiAKIGNsYXNzIFByaW50U3RyZWFtOwogCi1jbGFzcyBGYXN0Qml0VmVjdG9yIHsKK2lubGlu ZSBzaXplX3QgZmFzdEJpdFZlY3RvckFycmF5TGVuZ3RoKHNpemVfdCBudW1CaXRzKSB7IHJldHVy biAobnVtQml0cyArIDMxKSA+PiA1OyB9CisKK2NsYXNzIEZhc3RCaXRWZWN0b3JXb3JkVmlldyB7 CiBwdWJsaWM6Ci0gICAgRmFzdEJpdFZlY3RvcigpID0gZGVmYXVsdDsKKyAgICB0eXBlZGVmIEZh c3RCaXRWZWN0b3JXb3JkVmlldyBWaWV3VHlwZTsKKyAgICAKKyAgICBGYXN0Qml0VmVjdG9yV29y ZFZpZXcoKSB7IH0KKyAgICAKKyAgICBGYXN0Qml0VmVjdG9yV29yZFZpZXcoY29uc3QgdWludDMy X3QqIGFycmF5LCBzaXplX3QgbnVtQml0cykKKyAgICAgICAgOiBtX3dvcmRzKGFycmF5KQorICAg ICAgICAsIG1fbnVtQml0cyhudW1CaXRzKQorICAgIHsKKyAgICB9CisgICAgCisgICAgc2l6ZV90 IG51bUJpdHMoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fbnVtQml0czsKKyAgICB9 CisgICAgCisgICAgdWludDMyX3Qgd29yZChzaXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAg ICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihpbmRleCA8IGZhc3RCaXRWZWN0 b3JBcnJheUxlbmd0aChudW1CaXRzKCkpKTsKKyAgICAgICAgcmV0dXJuIG1fd29yZHNbaW5kZXhd OworICAgIH0KKyAgICAKK3ByaXZhdGU6CisgICAgY29uc3QgdWludDMyX3QqIG1fd29yZHMgeyBu dWxscHRyIH07CisgICAgc2l6ZV90IG1fbnVtQml0cyB7IDAgfTsKK307CiAKLSAgICBGYXN0Qml0 VmVjdG9yKEZhc3RCaXRWZWN0b3ImJiBvdGhlcikKLSAgICAgICAgOiBtX2FycmF5KHN0ZDo6ZXhj aGFuZ2Uob3RoZXIubV9hcnJheSwgbnVsbHB0cikpCitjbGFzcyBGYXN0Qml0VmVjdG9yV29yZE93 bmVyIHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIEZhc3RCaXRWZWN0b3JXb3JkVmlldyBWaWV3VHlw ZTsKKyAgICAKKyAgICBGYXN0Qml0VmVjdG9yV29yZE93bmVyKCkgPSBkZWZhdWx0OworICAgIAor ICAgIEZhc3RCaXRWZWN0b3JXb3JkT3duZXIoRmFzdEJpdFZlY3RvcldvcmRPd25lciYmIG90aGVy KQorICAgICAgICA6IG1fd29yZHMoc3RkOjpleGNoYW5nZShvdGhlci5tX3dvcmRzLCBudWxscHRy KSkKICAgICAgICAgLCBtX251bUJpdHMoc3RkOjpleGNoYW5nZShvdGhlci5tX251bUJpdHMsIDAp KQogICAgIHsKICAgICB9CiAKLSAgICBGYXN0Qml0VmVjdG9yKGNvbnN0IEZhc3RCaXRWZWN0b3Im IG90aGVyKQotICAgICAgICA6IG1fYXJyYXkoMCkKLSAgICAgICAgLCBtX251bUJpdHMoMCkKKyAg ICBGYXN0Qml0VmVjdG9yV29yZE93bmVyKGNvbnN0IEZhc3RCaXRWZWN0b3JXb3JkT3duZXImIG90 aGVyKQogICAgIHsKICAgICAgICAgKnRoaXMgPSBvdGhlcjsKICAgICB9CiAgICAgCi0gICAgfkZh c3RCaXRWZWN0b3IoKQorICAgIH5GYXN0Qml0VmVjdG9yV29yZE93bmVyKCkKICAgICB7Ci0gICAg ICAgIGlmIChtX2FycmF5KQotICAgICAgICAgICAgZmFzdEZyZWUobV9hcnJheSk7CisgICAgICAg IGlmIChtX3dvcmRzKQorICAgICAgICAgICAgZmFzdEZyZWUobV93b3Jkcyk7CiAgICAgfQogICAg IAotICAgIEZhc3RCaXRWZWN0b3ImIG9wZXJhdG9yPShjb25zdCBGYXN0Qml0VmVjdG9yJiBvdGhl cikKKyAgICBGYXN0Qml0VmVjdG9yV29yZFZpZXcgdmlldygpIGNvbnN0IHsgcmV0dXJuIEZhc3RC aXRWZWN0b3JXb3JkVmlldyhtX3dvcmRzLCBtX251bUJpdHMpOyB9CisgICAgCisgICAgRmFzdEJp dFZlY3RvcldvcmRPd25lciYgb3BlcmF0b3I9KGNvbnN0IEZhc3RCaXRWZWN0b3JXb3JkT3duZXIm IG90aGVyKQogICAgIHsKICAgICAgICAgc2l6ZV90IGxlbmd0aCA9IG90aGVyLmFycmF5TGVuZ3Ro KCk7CisgICAgICAgIGlmIChsZW5ndGggPT0gYXJyYXlMZW5ndGgoKSkgeworICAgICAgICAgICAg bWVtY3B5KG1fd29yZHMsIG90aGVyLm1fd29yZHMsIGxlbmd0aCAqIDQpOworICAgICAgICAgICAg cmV0dXJuICp0aGlzOworICAgICAgICB9CiAgICAgICAgIHVpbnQzMl90KiBuZXdBcnJheSA9IHN0 YXRpY19jYXN0PHVpbnQzMl90Kj4oZmFzdENhbGxvYyhsZW5ndGgsIDQpKTsKLSAgICAgICAgbWVt Y3B5KG5ld0FycmF5LCBvdGhlci5tX2FycmF5LCBsZW5ndGggKiA0KTsKLSAgICAgICAgaWYgKG1f YXJyYXkpCi0gICAgICAgICAgICBmYXN0RnJlZShtX2FycmF5KTsKLSAgICAgICAgbV9hcnJheSA9 IG5ld0FycmF5OworICAgICAgICBtZW1jcHkobmV3QXJyYXksIG90aGVyLm1fd29yZHMsIGxlbmd0 aCAqIDQpOworICAgICAgICBpZiAobV93b3JkcykKKyAgICAgICAgICAgIGZhc3RGcmVlKG1fd29y ZHMpOworICAgICAgICBtX3dvcmRzID0gbmV3QXJyYXk7CiAgICAgICAgIG1fbnVtQml0cyA9IG90 aGVyLm1fbnVtQml0czsKICAgICAgICAgcmV0dXJuICp0aGlzOwogICAgIH0KICAgICAKLSAgICBz aXplX3QgbnVtQml0cygpIGNvbnN0IHsgcmV0dXJuIG1fbnVtQml0czsgfQorICAgIEZhc3RCaXRW ZWN0b3JXb3JkT3duZXImIG9wZXJhdG9yPShGYXN0Qml0VmVjdG9yV29yZE93bmVyJiYgb3RoZXIp CisgICAgeworICAgICAgICBzdGQ6OnN3YXAobV93b3Jkcywgb3RoZXIubV93b3Jkcyk7CisgICAg ICAgIHN0ZDo6c3dhcChtX251bUJpdHMsIG90aGVyLm1fbnVtQml0cyk7CisgICAgICAgIHJldHVy biAqdGhpczsKKyAgICB9CisgICAgCisgICAgdm9pZCBzZXRBbGwoKQorICAgIHsKKyAgICAgICAg bWVtc2V0KG1fd29yZHMsIDI1NSwgYXJyYXlMZW5ndGgoKSAqIDQpOworICAgIH0KKyAgICAKKyAg ICB2b2lkIGNsZWFyQWxsKCkKKyAgICB7CisgICAgICAgIG1lbXNldChtX3dvcmRzLCAwLCBhcnJh eUxlbmd0aCgpICogNCk7CisgICAgfQorICAgIAorICAgIHZvaWQgc2V0KGNvbnN0IEZhc3RCaXRW ZWN0b3JXb3JkT3duZXImIG90aGVyKQorICAgIHsKKyAgICAgICAgQVNTRVJUX1dJVEhfU0VDVVJJ VFlfSU1QTElDQVRJT04obV9udW1CaXRzID09IG90aGVyLm1fbnVtQml0cyk7CisgICAgICAgIG1l bWNweShtX3dvcmRzLCBvdGhlci5tX3dvcmRzLCBhcnJheUxlbmd0aCgpICogNCk7CisgICAgfQor ICAgIAorICAgIHNpemVfdCBudW1CaXRzKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBt X251bUJpdHM7CisgICAgfQorICAgIAorICAgIHNpemVfdCBhcnJheUxlbmd0aCgpIGNvbnN0Cisg ICAgeworICAgICAgICByZXR1cm4gZmFzdEJpdFZlY3RvckFycmF5TGVuZ3RoKG51bUJpdHMoKSk7 CisgICAgfQogICAgIAogICAgIHZvaWQgcmVzaXplKHNpemVfdCBudW1CaXRzKQogICAgIHsKQEAg LTc4LDEzMyArMTQ1LDM3NyBAQCBwdWJsaWM6CiAgICAgICAgIC8vIFVzZSBmYXN0Q2FsbG9jIGlu c3RlYWQgb2YgZmFzdFJlYWxsb2MgYmVjYXVzZSB3ZSBleHBlY3QgdGhlIGNvbW1vbgogICAgICAg ICAvLyB1c2UgY2FzZSBmb3IgdGhpcyBtZXRob2QgdG8gYmUgaW5pdGlhbGl6aW5nIHRoZSBzaXpl IG9mIHRoZSBiaXR2ZWN0b3IuCiAgICAgICAgIAotICAgICAgICBzaXplX3QgbmV3TGVuZ3RoID0g YXJyYXlMZW5ndGgobnVtQml0cyk7CisgICAgICAgIHNpemVfdCBuZXdMZW5ndGggPSBmYXN0Qml0 VmVjdG9yQXJyYXlMZW5ndGgobnVtQml0cyk7CiAgICAgICAgIHVpbnQzMl90KiBuZXdBcnJheSA9 IHN0YXRpY19jYXN0PHVpbnQzMl90Kj4oZmFzdENhbGxvYyhuZXdMZW5ndGgsIDQpKTsKLSAgICAg ICAgbWVtY3B5KG5ld0FycmF5LCBtX2FycmF5LCBhcnJheUxlbmd0aCgpICogNCk7Ci0gICAgICAg IGlmIChtX2FycmF5KQotICAgICAgICAgICAgZmFzdEZyZWUobV9hcnJheSk7Ci0gICAgICAgIG1f YXJyYXkgPSBuZXdBcnJheTsKKyAgICAgICAgbWVtY3B5KG5ld0FycmF5LCBtX3dvcmRzLCBhcnJh eUxlbmd0aCgpICogNCk7CisgICAgICAgIGlmIChtX3dvcmRzKQorICAgICAgICAgICAgZmFzdEZy ZWUobV93b3Jkcyk7CisgICAgICAgIG1fd29yZHMgPSBuZXdBcnJheTsKICAgICAgICAgbV9udW1C aXRzID0gbnVtQml0czsKICAgICB9CiAgICAgCi0gICAgdm9pZCBzZXRBbGwoKQorICAgIHVpbnQz Ml90IHdvcmQoc2l6ZV90IGluZGV4KSBjb25zdAogICAgIHsKLSAgICAgICAgbWVtc2V0KG1fYXJy YXksIDI1NSwgYXJyYXlMZW5ndGgoKSAqIDQpOworICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklU WV9JTVBMSUNBVElPTihpbmRleCA8IGFycmF5TGVuZ3RoKCkpOworICAgICAgICByZXR1cm4gbV93 b3Jkc1tpbmRleF07CiAgICAgfQogICAgIAotICAgIHZvaWQgY2xlYXJBbGwoKQorICAgIHVpbnQz Ml90JiB3b3JkKHNpemVfdCBpbmRleCkKICAgICB7Ci0gICAgICAgIG1lbXNldChtX2FycmF5LCAw LCBhcnJheUxlbmd0aCgpICogNCk7CisgICAgICAgIEFTU0VSVF9XSVRIX1NFQ1VSSVRZX0lNUExJ Q0FUSU9OKGluZGV4IDwgYXJyYXlMZW5ndGgoKSk7CisgICAgICAgIHJldHVybiBtX3dvcmRzW2lu ZGV4XTsKICAgICB9CiAgICAgCi0gICAgdm9pZCBzZXQoY29uc3QgRmFzdEJpdFZlY3RvciYgb3Ro ZXIpCisgICAgY29uc3QgdWludDMyX3QqIHdvcmRzKCkgY29uc3QgeyByZXR1cm4gbV93b3Jkczsg fQorICAgIHVpbnQzMl90KiB3b3JkcygpIHsgcmV0dXJuIG1fd29yZHM7IH0KKworcHJpdmF0ZToK KyAgICB1aW50MzJfdCogbV93b3JkcyB7IG51bGxwdHIgfTsKKyAgICBzaXplX3QgbV9udW1CaXRz IHsgMCB9OworfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgTGVmdCwgdHlwZW5hbWUgUmlnaHQ+Citj bGFzcyBGYXN0Qml0VmVjdG9yQW5kV29yZHMgeworcHVibGljOgorICAgIHR5cGVkZWYgRmFzdEJp dFZlY3RvckFuZFdvcmRzIFZpZXdUeXBlOworICAgIAorICAgIEZhc3RCaXRWZWN0b3JBbmRXb3Jk cyhjb25zdCBMZWZ0JiBsZWZ0LCBjb25zdCBSaWdodCYgcmlnaHQpCisgICAgICAgIDogbV9sZWZ0 KGxlZnQpCisgICAgICAgICwgbV9yaWdodChyaWdodCkKICAgICB7Ci0gICAgICAgIEFTU0VSVCht X251bUJpdHMgPT0gb3RoZXIubV9udW1CaXRzKTsKLSAgICAgICAgbWVtY3B5KG1fYXJyYXksIG90 aGVyLm1fYXJyYXksIGFycmF5TGVuZ3RoKCkgKiA0KTsKKyAgICAgICAgQVNTRVJUX1dJVEhfU0VD VVJJVFlfSU1QTElDQVRJT04obV9sZWZ0Lm51bUJpdHMoKSA9PSBtX3JpZ2h0Lm51bUJpdHMoKSk7 CiAgICAgfQogICAgIAotICAgIGJvb2wgc2V0QW5kQ2hlY2soY29uc3QgRmFzdEJpdFZlY3RvciYg b3RoZXIpCisgICAgRmFzdEJpdFZlY3RvckFuZFdvcmRzIHZpZXcoKSBjb25zdCB7IHJldHVybiAq dGhpczsgfQorICAgIAorICAgIHNpemVfdCBudW1CaXRzKCkgY29uc3QKICAgICB7Ci0gICAgICAg IGJvb2wgY2hhbmdlZCA9IGZhbHNlOwotICAgICAgICBBU1NFUlQobV9udW1CaXRzID09IG90aGVy Lm1fbnVtQml0cyk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IGFycmF5TGVuZ3RoKCk7IGkt LTspIHsKLSAgICAgICAgICAgIGNoYW5nZWQgfD0gbV9hcnJheVtpXSAhPSBvdGhlci5tX2FycmF5 W2ldOwotICAgICAgICAgICAgbV9hcnJheVtpXSA9IG90aGVyLm1fYXJyYXlbaV07Ci0gICAgICAg IH0KLSAgICAgICAgcmV0dXJuIGNoYW5nZWQ7CisgICAgICAgIHJldHVybiBtX2xlZnQubnVtQml0 cygpOwogICAgIH0KICAgICAKLSAgICBib29sIGVxdWFscyhjb25zdCBGYXN0Qml0VmVjdG9yJiBv dGhlcikgY29uc3QKKyAgICB1aW50MzJfdCB3b3JkKHNpemVfdCBpbmRleCkgY29uc3QKICAgICB7 Ci0gICAgICAgIEFTU0VSVChtX251bUJpdHMgPT0gb3RoZXIubV9udW1CaXRzKTsKLSAgICAgICAg Ly8gVXNlIG15IG93biBjb21wYXJpc29uIGxvb3AgYmVjYXVzZSBtZW1jbXAgZG9lcyBtb3JlIHRo YW4gd2hhdCBJIHdhbnQKLSAgICAgICAgLy8gYW5kIGJjbXAgaXMgbm90IGFzIHN0YW5kYXJkLgot ICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSBhcnJheUxlbmd0aCgpOyBpLS07KSB7Ci0gICAgICAg ICAgICBpZiAobV9hcnJheVtpXSAhPSBvdGhlci5tX2FycmF5W2ldKQotICAgICAgICAgICAgICAg IHJldHVybiBmYWxzZTsKLSAgICAgICAgfQotICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAg cmV0dXJuIG1fbGVmdC53b3JkKGluZGV4KSAmIG1fcmlnaHQud29yZChpbmRleCk7CiAgICAgfQog ICAgIAotICAgIHZvaWQgbWVyZ2UoY29uc3QgRmFzdEJpdFZlY3RvciYgb3RoZXIpCitwcml2YXRl OgorICAgIExlZnQgbV9sZWZ0OworICAgIFJpZ2h0IG1fcmlnaHQ7Cit9OworICAgIAordGVtcGxh dGU8dHlwZW5hbWUgTGVmdCwgdHlwZW5hbWUgUmlnaHQ+CitjbGFzcyBGYXN0Qml0VmVjdG9yT3JX b3JkcyB7CitwdWJsaWM6CisgICAgdHlwZWRlZiBGYXN0Qml0VmVjdG9yT3JXb3JkcyBWaWV3VHlw ZTsKKyAgICAKKyAgICBGYXN0Qml0VmVjdG9yT3JXb3Jkcyhjb25zdCBMZWZ0JiBsZWZ0LCBjb25z dCBSaWdodCYgcmlnaHQpCisgICAgICAgIDogbV9sZWZ0KGxlZnQpCisgICAgICAgICwgbV9yaWdo dChyaWdodCkKICAgICB7Ci0gICAgICAgIEFTU0VSVChtX251bUJpdHMgPT0gb3RoZXIubV9udW1C aXRzKTsKLSAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gYXJyYXlMZW5ndGgoKTsgaS0tOykKLSAg ICAgICAgICAgIG1fYXJyYXlbaV0gfD0gb3RoZXIubV9hcnJheVtpXTsKKyAgICAgICAgQVNTRVJU X1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04obV9sZWZ0Lm51bUJpdHMoKSA9PSBtX3JpZ2h0Lm51 bUJpdHMoKSk7CiAgICAgfQogICAgIAotICAgIHZvaWQgZmlsdGVyKGNvbnN0IEZhc3RCaXRWZWN0 b3ImIG90aGVyKQorICAgIEZhc3RCaXRWZWN0b3JPcldvcmRzIHZpZXcoKSBjb25zdCB7IHJldHVy biAqdGhpczsgfQorICAgIAorICAgIHNpemVfdCBudW1CaXRzKCkgY29uc3QKICAgICB7Ci0gICAg ICAgIEFTU0VSVChtX251bUJpdHMgPT0gb3RoZXIubV9udW1CaXRzKTsKLSAgICAgICAgZm9yICh1 bnNpZ25lZCBpID0gYXJyYXlMZW5ndGgoKTsgaS0tOykKLSAgICAgICAgICAgIG1fYXJyYXlbaV0g Jj0gb3RoZXIubV9hcnJheVtpXTsKKyAgICAgICAgcmV0dXJuIG1fbGVmdC5udW1CaXRzKCk7CiAg ICAgfQogICAgIAotICAgIHZvaWQgZXhjbHVkZShjb25zdCBGYXN0Qml0VmVjdG9yJiBvdGhlcikK KyAgICB1aW50MzJfdCB3b3JkKHNpemVfdCBpbmRleCkgY29uc3QKICAgICB7Ci0gICAgICAgIEFT U0VSVChtX251bUJpdHMgPT0gb3RoZXIubV9udW1CaXRzKTsKLSAgICAgICAgZm9yICh1bnNpZ25l ZCBpID0gYXJyYXlMZW5ndGgoKTsgaS0tOykKLSAgICAgICAgICAgIG1fYXJyYXlbaV0gJj0gfm90 aGVyLm1fYXJyYXlbaV07CisgICAgICAgIHJldHVybiBtX2xlZnQud29yZChpbmRleCkgfCBtX3Jp Z2h0LndvcmQoaW5kZXgpOworICAgIH0KKyAgICAKK3ByaXZhdGU6CisgICAgTGVmdCBtX2xlZnQ7 CisgICAgUmlnaHQgbV9yaWdodDsKK307CisgICAgCit0ZW1wbGF0ZTx0eXBlbmFtZSBWaWV3Pgor Y2xhc3MgRmFzdEJpdFZlY3Rvck5vdFdvcmRzIHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIEZhc3RC aXRWZWN0b3JOb3RXb3JkcyBWaWV3VHlwZTsKKyAgICAKKyAgICBGYXN0Qml0VmVjdG9yTm90V29y ZHMoY29uc3QgVmlldyYgdmlldykKKyAgICAgICAgOiBtX3ZpZXcodmlldykKKyAgICB7CisgICAg fQorICAgIAorICAgIEZhc3RCaXRWZWN0b3JOb3RXb3JkcyB2aWV3KCkgY29uc3QgeyByZXR1cm4g KnRoaXM7IH0KKyAgICAKKyAgICBzaXplX3QgbnVtQml0cygpIGNvbnN0CisgICAgeworICAgICAg ICByZXR1cm4gbV92aWV3Lm51bUJpdHMoKTsKICAgICB9CiAgICAgCi0gICAgdm9pZCBzZXQoc2l6 ZV90IGkpCisgICAgdWludDMyX3Qgd29yZChzaXplX3QgaW5kZXgpIGNvbnN0CiAgICAgewotICAg ICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihpIDwgbV9udW1CaXRzKTsKLSAg ICAgICAgbV9hcnJheVtpID4+IDVdIHw9ICgxIDw8IChpICYgMzEpKTsKKyAgICAgICAgcmV0dXJu ICFtX3ZpZXcud29yZChpbmRleCk7CiAgICAgfQogICAgIAotICAgIHZvaWQgY2xlYXIoc2l6ZV90 IGkpCitwcml2YXRlOgorICAgIFZpZXcgbV92aWV3OworfTsKKyAgICAKK3RlbXBsYXRlPHR5cGVu YW1lIFdvcmRzPgorY2xhc3MgRmFzdEJpdFZlY3RvckltcGwgeworcHVibGljOgorICAgIEZhc3RC aXRWZWN0b3JJbXBsKCkKKyAgICAgICAgOiBtX3dvcmRzKCkKICAgICB7Ci0gICAgICAgIEFTU0VS VF9XSVRIX1NFQ1VSSVRZX0lNUExJQ0FUSU9OKGkgPCBtX251bUJpdHMpOwotICAgICAgICBtX2Fy cmF5W2kgPj4gNV0gJj0gfigxIDw8IChpICYgMzEpKTsKICAgICB9CiAgICAgCi0gICAgdm9pZCBz ZXQoc2l6ZV90IGksIGJvb2wgdmFsdWUpCisgICAgRmFzdEJpdFZlY3RvckltcGwoY29uc3QgV29y ZHMmIHdvcmRzKQorICAgICAgICA6IG1fd29yZHMod29yZHMpCiAgICAgewotICAgICAgICBpZiAo dmFsdWUpCi0gICAgICAgICAgICBzZXQoaSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgIGNs ZWFyKGkpOwogICAgIH0KICAgICAKLSAgICBib29sIGdldChzaXplX3QgaSkgY29uc3QKKyAgICBG YXN0Qml0VmVjdG9ySW1wbChXb3JkcyYmIHdvcmRzKQorICAgICAgICA6IG1fd29yZHMoV1RGTW92 ZSh3b3JkcykpCiAgICAgewotICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElP TihpIDwgbV9udW1CaXRzKTsKLSAgICAgICAgcmV0dXJuICEhKG1fYXJyYXlbaSA+PiA1XSAmICgx IDw8IChpICYgMzEpKSk7CisgICAgfQorCisgICAgc2l6ZV90IG51bUJpdHMoKSBjb25zdCB7IHJl dHVybiBtX3dvcmRzLm51bUJpdHMoKTsgfQorICAgIHNpemVfdCBzaXplKCkgY29uc3QgeyByZXR1 cm4gbnVtQml0cygpOyB9CisgICAgCisgICAgc2l6ZV90IGFycmF5TGVuZ3RoKCkgY29uc3QgeyBy ZXR1cm4gZmFzdEJpdFZlY3RvckFycmF5TGVuZ3RoKG51bUJpdHMoKSk7IH0KKyAgICAKKyAgICB0 ZW1wbGF0ZTx0eXBlbmFtZSBPdGhlcj4KKyAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgT3RoZXIm IG90aGVyKSBjb25zdAorICAgIHsKKyAgICAgICAgaWYgKG51bUJpdHMoKSAhPSBvdGhlci5udW1C aXRzKCkpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIGZvciAoc2l6ZV90IGkg PSBhcnJheUxlbmd0aCgpOyBpLS07KSB7CisgICAgICAgICAgICBpZiAobV93b3Jkcy53b3JkKGkp ICE9IG90aGVyLm1fd29yZHMud29yZChpKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7 CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIAorICAgIHRlbXBs YXRlPHR5cGVuYW1lIE90aGVyPgorICAgIGJvb2wgb3BlcmF0b3IhPShjb25zdCBPdGhlciYgb3Ro ZXIpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gISgqdGhpcyA9PSBvdGhlcik7CisgICAg fQorICAgIAorICAgIGJvb2wgYXQoc2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAg QVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04oaW5kZXggPCBudW1CaXRzKCkpOworICAg ICAgICByZXR1cm4gISEobV93b3Jkcy53b3JkKGluZGV4ID4+IDUpICYgKDEgPDwgKGluZGV4ICYg MzEpKSk7CisgICAgfQorICAgIAorICAgIGJvb2wgb3BlcmF0b3JbXShzaXplX3QgaW5kZXgpIGNv bnN0CisgICAgeworICAgICAgICByZXR1cm4gYXQoaW5kZXgpOwogICAgIH0KICAgICAKICAgICBz aXplX3QgYml0Q291bnQoKSBjb25zdAogICAgIHsKICAgICAgICAgc2l6ZV90IHJlc3VsdCA9IDA7 Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IGFycmF5TGVuZ3RoKCk7IGktLTspCi0gICAgICAg ICAgICByZXN1bHQgKz0gV1RGOjpiaXRDb3VudChtX2FycmF5W2ldKTsKKyAgICAgICAgZm9yIChz aXplX3QgaW5kZXggPSBhcnJheUxlbmd0aCgpOyBpbmRleC0tOykKKyAgICAgICAgICAgIHJlc3Vs dCArPSBXVEY6OmJpdENvdW50KG1fd29yZHMud29yZChpbmRleCkpOwogICAgICAgICByZXR1cm4g cmVzdWx0OwogICAgIH0KICAgICAKLSAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBGdW5jdG9yPgotICAg IHZvaWQgZm9yRWFjaFNldEJpdChjb25zdCBGdW5jdG9yJiBmdW5jdG9yKSBjb25zdAorICAgIHRl bXBsYXRlPHR5cGVuYW1lIE90aGVyV29yZHM+CisgICAgRmFzdEJpdFZlY3RvckltcGw8RmFzdEJp dFZlY3RvckFuZFdvcmRzPHR5cGVuYW1lIFdvcmRzOjpWaWV3VHlwZSwgdHlwZW5hbWUgT3RoZXJX b3Jkczo6Vmlld1R5cGU+PiBvcGVyYXRvciYoY29uc3QgRmFzdEJpdFZlY3RvckltcGw8T3RoZXJX b3Jkcz4mIG90aGVyKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIEZhc3RCaXRWZWN0b3JJ bXBsPEZhc3RCaXRWZWN0b3JBbmRXb3Jkczx0eXBlbmFtZSBXb3Jkczo6Vmlld1R5cGUsIHR5cGVu YW1lIE90aGVyV29yZHM6OlZpZXdUeXBlPj4oRmFzdEJpdFZlY3RvckFuZFdvcmRzPHR5cGVuYW1l IFdvcmRzOjpWaWV3VHlwZSwgdHlwZW5hbWUgT3RoZXJXb3Jkczo6Vmlld1R5cGU+KG1fd29yZHMu dmlldygpLCBvdGhlci5tX3dvcmRzLnZpZXcoKSkpOworICAgIH0KKyAgICAKKyAgICB0ZW1wbGF0 ZTx0eXBlbmFtZSBPdGhlcldvcmRzPgorICAgIEZhc3RCaXRWZWN0b3JJbXBsPEZhc3RCaXRWZWN0 b3JPcldvcmRzPHR5cGVuYW1lIFdvcmRzOjpWaWV3VHlwZSwgdHlwZW5hbWUgT3RoZXJXb3Jkczo6 Vmlld1R5cGU+PiBvcGVyYXRvcnwoY29uc3QgRmFzdEJpdFZlY3RvckltcGw8T3RoZXJXb3Jkcz4m IG90aGVyKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIEZhc3RCaXRWZWN0b3JJbXBsPEZh c3RCaXRWZWN0b3JPcldvcmRzPHR5cGVuYW1lIFdvcmRzOjpWaWV3VHlwZSwgdHlwZW5hbWUgT3Ro ZXJXb3Jkczo6Vmlld1R5cGU+PihGYXN0Qml0VmVjdG9yT3JXb3Jkczx0eXBlbmFtZSBXb3Jkczo6 Vmlld1R5cGUsIHR5cGVuYW1lIE90aGVyV29yZHM6OlZpZXdUeXBlPihtX3dvcmRzLnZpZXcoKSwg b3RoZXIubV93b3Jkcy52aWV3KCkpKTsKKyAgICB9CisgICAgCisgICAgRmFzdEJpdFZlY3Rvcklt cGw8RmFzdEJpdFZlY3Rvck5vdFdvcmRzPHR5cGVuYW1lIFdvcmRzOjpWaWV3VHlwZT4+IG9wZXJh dG9yfigpIGNvbnN0CiAgICAgewotICAgICAgICB1bnNpZ25lZCBuID0gYXJyYXlMZW5ndGgoKTsK LSAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG47ICsraSkgewotICAgICAgICAgICAg dWludDMyX3Qgd29yZCA9IG1fYXJyYXlbaV07CisgICAgICAgIHJldHVybiBGYXN0Qml0VmVjdG9y SW1wbDxGYXN0Qml0VmVjdG9yTm90V29yZHM8dHlwZW5hbWUgV29yZHM6OlZpZXdUeXBlPj4oRmFz dEJpdFZlY3Rvck5vdFdvcmRzPHR5cGVuYW1lIFdvcmRzOjpWaWV3VHlwZT4obV93b3Jkcy52aWV3 KCkpKTsKKyAgICB9CisgICAgCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgRnVuYz4KKyAgICBBTFdB WVNfSU5MSU5FIHZvaWQgZm9yRWFjaFNldEJpdChjb25zdCBGdW5jJiBmdW5jKQorICAgIHsKKyAg ICAgICAgc2l6ZV90IG4gPSBtX3dvcmRzLmFycmF5TGVuZ3RoKCk7CisgICAgICAgIGZvciAoc2l6 ZV90IGkgPSAwOyBpIDwgbjsgKytpKSB7CisgICAgICAgICAgICB1aW50MzJfdCB3b3JkID0gbV93 b3Jkcy53b3JkKGkpOwogICAgICAgICAgICAgdW5zaWduZWQgaiA9IGkgPDwgNTsKICAgICAgICAg ICAgIHdoaWxlICh3b3JkKSB7CiAgICAgICAgICAgICAgICAgaWYgKHdvcmQgJiAxKQotICAgICAg ICAgICAgICAgICAgICBmdW5jdG9yKGopOworICAgICAgICAgICAgICAgICAgICBmdW5jKGopOwog ICAgICAgICAgICAgICAgIHdvcmQgPj49IDE7CiAgICAgICAgICAgICAgICAgaisrOwogICAgICAg ICAgICAgfQogICAgICAgICB9CiAgICAgfQorICAgIAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIEZ1 bmM+CisgICAgQUxXQVlTX0lOTElORSB2b2lkIGZvckVhY2hDbGVhckJpdChjb25zdCBGdW5jJiBm dW5jKQorICAgIHsKKyAgICAgICAgLy8gSSdtIHByZXR0eSBzdXJlIHRoYXQgdGhpcyBpcyB0aGUg bW9zdCBlZmZpY2llbnQgd2F5IHRvIGRvIHRoaXMuCisgICAgICAgICh+KnRoaXMpLmZvckVhY2hT ZXRCaXQoZnVuYyk7CisgICAgfQorICAgIAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIEZ1bmM+Cisg ICAgdm9pZCBmb3JFYWNoQml0KGJvb2wgdmFsdWUsIGNvbnN0IEZ1bmMmIGZ1bmMpCisgICAgewor ICAgICAgICBpZiAodmFsdWUpCisgICAgICAgICAgICBmb3JFYWNoU2V0Qml0KGZ1bmMpOworICAg ICAgICBlbHNlCisgICAgICAgICAgICBmb3JFYWNoQ2xlYXJCaXQoZnVuYyk7CisgICAgfQorICAg IAorICAgIEFMV0FZU19JTkxJTkUgc2l6ZV90IGZpbmRCaXQoc2l6ZV90IHN0YXJ0SW5kZXgsIGJv b2wgdmFsdWUpCisgICAgeworICAgICAgICB1aW50MzJfdCBza2lwVmFsdWUgPSAtKHN0YXRpY19j YXN0PHVpbnQzMl90Pih2YWx1ZSkgXiAxKTsKKyAgICAgICAgc2l6ZV90IG51bVdvcmRzID0gbV93 b3Jkcy5hcnJheUxlbmd0aCgpOworICAgICAgICAKKyAgICAgICAgc2l6ZV90IHdvcmRJbmRleCA9 IHN0YXJ0SW5kZXggPj4gNTsKKyAgICAgICAgc2l6ZV90IHN0YXJ0SW5kZXhJbldvcmQgPSBzdGFy dEluZGV4IC0gKHdvcmRJbmRleCA8PCA1KTsKKyAgICAgICAgCisgICAgICAgIHdoaWxlICh3b3Jk SW5kZXggPCBudW1Xb3JkcykgeworICAgICAgICAgICAgdWludDMyX3Qgd29yZCA9IG1fd29yZHMu d29yZCh3b3JkSW5kZXgpOworICAgICAgICAgICAgaWYgKHdvcmQgIT0gc2tpcFZhbHVlKSB7Cisg ICAgICAgICAgICAgICAgc2l6ZV90IGluZGV4ID0gc3RhcnRJbmRleEluV29yZDsKKyAgICAgICAg ICAgICAgICBpZiAoZmluZEJpdEluV29yZCh3b3JkLCBpbmRleCwgMzIsIHZhbHVlKSkKKyAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIHdvcmRJbmRleCAqIDMyICsgaW5kZXg7CisgICAgICAgICAg ICB9CisgICAgICAgICAgICAKKyAgICAgICAgICAgIHdvcmRJbmRleCsrOworICAgICAgICAgICAg c3RhcnRJbmRleEluV29yZCA9IDA7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIHJldHVy biBudW1CaXRzKCk7CisgICAgfQorICAgIAorICAgIEFMV0FZU19JTkxJTkUgc2l6ZV90IGZpbmRT ZXRCaXQoc2l6ZV90IGluZGV4KQorICAgIHsKKyAgICAgICAgcmV0dXJuIGZpbmRCaXQoaW5kZXgs IHRydWUpOworICAgIH0KKyAgICAKKyAgICBBTFdBWVNfSU5MSU5FIHNpemVfdCBmaW5kQ2xlYXJC aXQoc2l6ZV90IGluZGV4KQorICAgIHsKKyAgICAgICAgcmV0dXJuIGZpbmRCaXQoaW5kZXgsIGZh bHNlKTsKKyAgICB9CisgICAgCisgICAgdm9pZCBkdW1wKFByaW50U3RyZWFtJiBvdXQpIGNvbnN0 CisgICAgeworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG51bUJpdHMoKTsgKytpKQor ICAgICAgICAgICAgb3V0LnByaW50KCgqdGhpcylbaV0gPyAiMSIgOiAiLSIpOworICAgIH0KKyAg ICAKK3Byb3RlY3RlZDoKKyAgICBXb3JkcyBtX3dvcmRzOworfTsKIAotICAgIFdURl9FWFBPUlRf UFJJVkFURSB2b2lkIGR1bXAoUHJpbnRTdHJlYW0mKSBjb25zdDsKK2NsYXNzIEZhc3RCaXRWZWN0 b3IgOiBwdWJsaWMgRmFzdEJpdFZlY3RvckltcGw8RmFzdEJpdFZlY3RvcldvcmRPd25lcj4gewor cHVibGljOgorICAgIEZhc3RCaXRWZWN0b3IoY29uc3QgRmFzdEJpdFZlY3RvciYpID0gZGVmYXVs dDsKKyAgICBGYXN0Qml0VmVjdG9yJiBvcGVyYXRvcj0oY29uc3QgRmFzdEJpdFZlY3RvciYpID0g ZGVmYXVsdDsKICAgICAKLXByaXZhdGU6Ci0gICAgc3RhdGljIHNpemVfdCBhcnJheUxlbmd0aChz aXplX3QgbnVtQml0cykgeyByZXR1cm4gKG51bUJpdHMgKyAzMSkgPj4gNTsgfQotICAgIHNpemVf dCBhcnJheUxlbmd0aCgpIGNvbnN0IHsgcmV0dXJuIGFycmF5TGVuZ3RoKG1fbnVtQml0cyk7IH0K KyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBPdGhlcldvcmRzPgorICAgIEZhc3RCaXRWZWN0b3IoY29u c3QgRmFzdEJpdFZlY3RvckltcGw8T3RoZXJXb3Jkcz4mIG90aGVyKQorICAgIHsKKyAgICAgICAg KnRoaXMgPSBvdGhlcjsKKyAgICB9CiAgICAgCi0gICAgdWludDMyX3QqIG1fYXJyYXkgeyBudWxs cHRyIH07IC8vIE5vLCB0aGlzIGNhbid0IGJlIGFuIHN0ZDo6dW5pcXVlX3B0cjx1aW50MzJfdFtd Pi4KLSAgICBzaXplX3QgbV9udW1CaXRzIHsgMCB9OworICAgIHRlbXBsYXRlPHR5cGVuYW1lIE90 aGVyV29yZHM+CisgICAgRmFzdEJpdFZlY3RvciYgb3BlcmF0b3I9KGNvbnN0IEZhc3RCaXRWZWN0 b3JJbXBsPE90aGVyV29yZHM+JiBvdGhlcikKKyAgICB7CisgICAgICAgIGlmIChVTkxJS0VMWShu dW1CaXRzKCkgIT0gb3RoZXIubnVtQml0cygpKSkKKyAgICAgICAgICAgIHJlc2l6ZShvdGhlci5u dW1CaXRzKCkpOworICAgICAgICAKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gYXJyYXlMZW5n dGgoKTsgaS0tOykKKyAgICAgICAgICAgIG1fd29yZHMud29yZChpKSA9IG90aGVyLm1fd29yZHMu d29yZChpKTsKKyAgICAgICAgcmV0dXJuICp0aGlzOworICAgIH0KKyAgICAKKyAgICB2b2lkIHJl c2l6ZShzaXplX3QgbnVtQml0cykKKyAgICB7CisgICAgICAgIG1fd29yZHMucmVzaXplKG51bUJp dHMpOworICAgIH0KKyAgICAKKyAgICB2b2lkIHNldEFsbCgpCisgICAgeworICAgICAgICBtX3dv cmRzLnNldEFsbCgpOworICAgIH0KKyAgICAKKyAgICB2b2lkIGNsZWFyQWxsKCkKKyAgICB7Cisg ICAgICAgIG1fd29yZHMuY2xlYXJBbGwoKTsKKyAgICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFt ZSBPdGhlcldvcmRzPgorICAgIGJvb2wgc2V0QW5kQ2hlY2soY29uc3QgRmFzdEJpdFZlY3Rvcklt cGw8T3RoZXJXb3Jkcz4mIG90aGVyKQorICAgIHsKKyAgICAgICAgYm9vbCBjaGFuZ2VkID0gZmFs c2U7CisgICAgICAgIEFTU0VSVF9XSVRIX1NFQ1VSSVRZX0lNUExJQ0FUSU9OKG51bUJpdHMoKSA9 PSBvdGhlci5udW1CaXRzKCkpOworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSBhcnJheUxlbmd0 aCgpOyBpLS07KSB7CisgICAgICAgICAgICBjaGFuZ2VkIHw9IG1fd29yZHMud29yZChpKSAhPSBv dGhlci5tX3dvcmRzLndvcmQoaSk7CisgICAgICAgICAgICBtX3dvcmRzLndvcmQoaSkgPSBvdGhl ci5tX3dvcmRzLndvcmQoaSk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIGNoYW5nZWQ7Cisg ICAgfQorICAgIAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIE90aGVyV29yZHM+CisgICAgRmFzdEJp dFZlY3RvciYgb3BlcmF0b3J8PShjb25zdCBGYXN0Qml0VmVjdG9ySW1wbDxPdGhlcldvcmRzPiYg b3RoZXIpCisgICAgeworICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihu dW1CaXRzKCkgPT0gb3RoZXIubnVtQml0cygpKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0g YXJyYXlMZW5ndGgoKTsgaS0tOykKKyAgICAgICAgICAgIG1fd29yZHMud29yZChpKSB8PSBvdGhl ci5tX3dvcmRzLndvcmQoaSk7CisgICAgICAgIHJldHVybiAqdGhpczsKKyAgICB9CisgICAgCisg ICAgdGVtcGxhdGU8dHlwZW5hbWUgT3RoZXJXb3Jkcz4KKyAgICBGYXN0Qml0VmVjdG9yJiBvcGVy YXRvciY9KGNvbnN0IEZhc3RCaXRWZWN0b3JJbXBsPE90aGVyV29yZHM+JiBvdGhlcikKKyAgICB7 CisgICAgICAgIEFTU0VSVF9XSVRIX1NFQ1VSSVRZX0lNUExJQ0FUSU9OKG51bUJpdHMoKSA9PSBv dGhlci5udW1CaXRzKCkpOworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSBhcnJheUxlbmd0aCgp OyBpLS07KQorICAgICAgICAgICAgbV93b3Jkcy53b3JkKGkpICY9IG90aGVyLm1fd29yZHMud29y ZChpKTsKKyAgICAgICAgcmV0dXJuICp0aGlzOworICAgIH0KKyAgICAKKyAgICBjbGFzcyBCaXRS ZWZlcmVuY2UgeworICAgIHB1YmxpYzoKKyAgICAgICAgQml0UmVmZXJlbmNlKCkgeyB9CisgICAg ICAgIAorICAgICAgICBCaXRSZWZlcmVuY2UodWludDMyX3QqIHdvcmQsIHVpbnQzMl90IG1hc2sp CisgICAgICAgICAgICA6IG1fd29yZCh3b3JkKQorICAgICAgICAgICAgLCBtX21hc2sobWFzaykK KyAgICAgICAgeworICAgICAgICB9CisgICAgICAgIAorICAgICAgICBleHBsaWNpdCBvcGVyYXRv ciBib29sKCkgY29uc3QKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuICEhKCptX3dvcmQg JiBtX21hc2spOworICAgICAgICB9CisgICAgICAgIAorICAgICAgICBCaXRSZWZlcmVuY2UmIG9w ZXJhdG9yPShib29sIHZhbHVlKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAodmFsdWUpCisg ICAgICAgICAgICAgICAgKm1fd29yZCB8PSBtX21hc2s7CisgICAgICAgICAgICBlbHNlCisgICAg ICAgICAgICAgICAgKm1fd29yZCAmPSB+bV9tYXNrOworICAgICAgICAgICAgcmV0dXJuICp0aGlz OworICAgICAgICB9CisgICAgICAgIAorICAgIHByaXZhdGU6CisgICAgICAgIHVpbnQzMl90KiBt X3dvcmQgeyBudWxscHRyIH07CisgICAgICAgIHVpbnQzMl90IG1fbWFzayB7IDAgfTsKKyAgICB9 OworICAgIAorICAgIEJpdFJlZmVyZW5jZSBhdChzaXplX3QgaW5kZXgpCisgICAgeworICAgICAg ICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihpbmRleCA8IG51bUJpdHMoKSk7Cisg ICAgICAgIHJldHVybiBCaXRSZWZlcmVuY2UoJm1fd29yZHMud29yZChpbmRleCA+PiA1KSwgMSA8 PCAoaW5kZXggJiAzMSkpOworICAgIH0KKyAgICAKKyAgICBCaXRSZWZlcmVuY2Ugb3BlcmF0b3Jb XShzaXplX3QgaW5kZXgpCisgICAgeworICAgICAgICByZXR1cm4gYXQoaW5kZXgpOworICAgIH0K IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdURgpJbmRleDogU291cmNlL1dURi93dGYvU3RkTGliRXh0 cmFzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvU3RkTGliRXh0cmFzLmgJKHJldmlz aW9uIDIwNTc2NykKKysrIFNvdXJjZS9XVEYvd3RmL1N0ZExpYkV4dHJhcy5oCSh3b3JraW5nIGNv cHkpCkBAIC0zMTcsNiArMzE3LDIyIEBAIGJvb2wgY2hlY2tBbmRTZXQoVCYgbGVmdCwgVSByaWdo dCkKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2Jvb2wgZmlu ZEJpdEluV29yZChUIHdvcmQsIHNpemVfdCYgaW5kZXgsIHNpemVfdCBlbmRJbmRleCwgYm9vbCB2 YWx1ZSkKK3sKKyAgICB3b3JkID4+PSBpbmRleDsKKyAgICAKKyAgICB3aGlsZSAoaW5kZXggPCBl bmRJbmRleCkgeworICAgICAgICBpZiAoKHdvcmQgJiAxKSA9PSBzdGF0aWNfY2FzdDxUPih2YWx1 ZSkpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgaW5kZXgrKzsKKyAgICAgICAg d29yZCA+Pj0gMTsKKyAgICB9CisgICAgCisgICAgaW5kZXggPSBlbmRJbmRleDsKKyAgICByZXR1 cm4gZmFsc2U7Cit9CisKIC8vIFZpc2l0b3IgYWRhcHRlZCBmcm9tIGh0dHA6Ly9zdGFja292ZXJm bG93LmNvbS9xdWVzdGlvbnMvMjUzMzg3OTUvaXMtdGhlcmUtYS1uYW1lLWZvci10aGlzLXR1cGxl LWNyZWF0aW9uLWlkaW9tCiAKIHRlbXBsYXRlIDxjbGFzcyBBLCBjbGFzcy4uLiBCPgpAQCAtNDIx LDYgKzQzNyw3IEBAIHVzaW5nIFdURjo6YmluYXJ5U2VhcmNoOwogdXNpbmcgV1RGOjpiaXR3aXNl X2Nhc3Q7CiB1c2luZyBXVEY6OmNhbGxTdGF0ZWxlc3NMYW1iZGE7CiB1c2luZyBXVEY6OmNoZWNr QW5kU2V0OwordXNpbmcgV1RGOjpmaW5kQml0SW5Xb3JkOwogdXNpbmcgV1RGOjppbnNlcnRJbnRv Qm91bmRlZFZlY3RvcjsKIHVzaW5nIFdURjo6aXNDb21waWxhdGlvblRocmVhZDsKIHVzaW5nIFdU Rjo6aXNQb2ludGVyQWxpZ25lZDsK 288536 2016-09-11 15:46:05 -0700 2016-09-11 17:51:09 -0700 the patch blah.patch text/plain 55653 fpizlo SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMjA1NzkxKQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDM1IEBA CisyMDE2LTA5LTExICBGaWxpcCBQaXpsbyAgPGZwaXpsb0BhcHBsZS5jb20+CisKKyAgICAgICAg RmFzdEJpdFZlY3RvciBzaG91bGQgaGF2ZSBlZmZpY2llbnQgYW5kIGVhc3ktdG8tdXNlIHZlY3Rv ci12ZWN0b3Igb3BlcmF0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTYxODQ3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisgICAgICAgIAorICAgICAgICBBZGFwdCBleGlzdGluZyB1c2VycyBvZiBGYXN0Qml0VmVjdG9y IHRvIHRoZSBuZXcgQVBJLgorCisgICAgICAgICogYnl0ZWNvZGUvQnl0ZWNvZGVMaXZlbmVzc0Fu YWx5c2lzLmNwcDoKKyAgICAgICAgKEpTQzo6Qnl0ZWNvZGVMaXZlbmVzc0FuYWx5c2lzOjpjb21w dXRlS2lsbHMpOgorICAgICAgICAoSlNDOjpCeXRlY29kZUxpdmVuZXNzQW5hbHlzaXM6OmR1bXBS ZXN1bHRzKToKKyAgICAgICAgKiBieXRlY29kZS9CeXRlY29kZUxpdmVuZXNzQW5hbHlzaXNJbmxp bmVzLmg6CisgICAgICAgIChKU0M6Om9wZXJhbmRUaGF0SXNOb3RBbHdheXNMaXZlSXNMaXZlKToK KyAgICAgICAgKEpTQzo6Qnl0ZWNvZGVMaXZlbmVzc1Byb3BhZ2F0aW9uPERlcml2ZWRBbmFseXNp cz46OnN0ZXBPdmVySW5zdHJ1Y3Rpb24pOgorICAgICAgICAoSlNDOjpCeXRlY29kZUxpdmVuZXNz UHJvcGFnYXRpb248RGVyaXZlZEFuYWx5c2lzPjo6cnVuTGl2ZW5lc3NGaXhwb2ludCk6CisgICAg ICAgICogYnl0ZWNvZGUvQ29kZUJsb2NrLmNwcDoKKyAgICAgICAgKEpTQzo6Q29kZUJsb2NrOjp2 YWxpZGF0ZSk6CisgICAgICAgICogZGZnL0RGR0J5dGVDb2RlUGFyc2VyLmNwcDoKKyAgICAgICAg KEpTQzo6REZHOjpCeXRlQ29kZVBhcnNlcjo6Zmx1c2hGb3JUZXJtaW5hbCk6CisgICAgICAgICog ZGZnL0RGR0ZvckFsbEtpbGxzLmg6CisgICAgICAgIChKU0M6OkRGRzo6Zm9yQWxsS2lsbGVkT3Bl cmFuZHMpOgorICAgICAgICAqIGRmZy9ERkdHcmFwaC5oOgorICAgICAgICAoSlNDOjpERkc6Okdy YXBoOjpmb3JBbGxMb2NhbHNMaXZlSW5CeXRlY29kZSk6CisgICAgICAgICogZGZnL0RGR0xpdmVD YXRjaFZhcmlhYmxlUHJlc2VydmF0aW9uUGhhc2UuY3BwOgorICAgICAgICAoSlNDOjpERkc6Okxp dmVDYXRjaFZhcmlhYmxlUHJlc2VydmF0aW9uUGhhc2U6OndpbGxDYXRjaEV4Y2VwdGlvbik6Cisg ICAgICAgIChKU0M6OkRGRzo6TGl2ZUNhdGNoVmFyaWFibGVQcmVzZXJ2YXRpb25QaGFzZTo6aGFu ZGxlQmxvY2spOgorICAgICAgICAqIGRmZy9ERkdOYXR1cmFsTG9vcHMuY3BwOgorICAgICAgICAo SlNDOjpERkc6Ok5hdHVyYWxMb29wczo6TmF0dXJhbExvb3BzKToKKyAgICAgICAgKiBkZmcvREZH UGxhbi5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6UGxhbjo6Y2xlYW5NdXN0SGFuZGxlVmFsdWVz SWZOZWNlc3NhcnkpOgorCiAyMDE2LTA5LTEwICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5j b20+CiAKICAgICAgICAgcGFyc2VIVE1MSW50ZWdlcigpIHNob3VsZCB0YWtlIGEgU3RyaW5nVmll dyBpbiBwYXJhbWV0ZXIKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ieXRlY29kZS9CeXRl Y29kZUxpdmVuZXNzQW5hbHlzaXMuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ieXRlY29kZS9CeXRlY29kZUxpdmVuZXNzQW5hbHlzaXMuY3BwCShyZXZpc2lvbiAyMDU3 OTApCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvYnl0ZWNvZGUvQnl0ZWNvZGVMaXZlbmVzc0Fu YWx5c2lzLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTIxLDE0ICsxMjEsMTQgQEAgdm9pZCBCeXRl Y29kZUxpdmVuZXNzQW5hbHlzaXM6OmNvbXB1dGVLaQogICAgICAgICAgICAgICAgIG1fZ3JhcGgs IGJ5dGVjb2RlT2Zmc2V0LCBvdXQsCiAgICAgICAgICAgICAgICAgWyZdICh1bnNpZ25lZCBpbmRl eCkgewogICAgICAgICAgICAgICAgICAgICAvLyBUaGlzIGlzIGZvciB1c2VzLgotICAgICAgICAg ICAgICAgICAgICBpZiAob3V0LmdldChpbmRleCkpCisgICAgICAgICAgICAgICAgICAgIGlmIChv dXRbaW5kZXhdKQogICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICAg ICAgICAgICByZXN1bHQubV9raWxsU2V0c1tieXRlY29kZU9mZnNldF0uYWRkKGluZGV4KTsKLSAg ICAgICAgICAgICAgICAgICAgb3V0LnNldChpbmRleCk7CisgICAgICAgICAgICAgICAgICAgIG91 dFtpbmRleF0gPSB0cnVlOwogICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAgWyZd ICh1bnNpZ25lZCBpbmRleCkgewogICAgICAgICAgICAgICAgICAgICAvLyBUaGlzIGlzIGZvciBk ZWZzLgotICAgICAgICAgICAgICAgICAgICBvdXQuY2xlYXIoaW5kZXgpOworICAgICAgICAgICAg ICAgICAgICBvdXRbaW5kZXhdID0gZmFsc2U7CiAgICAgICAgICAgICAgICAgfSk7CiAgICAgICAg IH0KICAgICB9CkBAIC0xNjMsNyArMTYzLDcgQEAgdm9pZCBCeXRlY29kZUxpdmVuZXNzQW5hbHlz aXM6OmR1bXBSZXN1bAogICAgICAgICAgICAgZGF0YUxvZ0YoIkxpdmUgdmFyaWFibGVzOiAiKTsK ICAgICAgICAgICAgIEZhc3RCaXRWZWN0b3IgbGl2ZUJlZm9yZSA9IGdldExpdmVuZXNzSW5mb0F0 Qnl0ZWNvZGVPZmZzZXQoYnl0ZWNvZGVPZmZzZXQpOwogICAgICAgICAgICAgZm9yICh1bnNpZ25l ZCBqID0gMDsgaiA8IGxpdmVCZWZvcmUubnVtQml0cygpOyBqKyspIHsKLSAgICAgICAgICAgICAg ICBpZiAobGl2ZUJlZm9yZS5nZXQoaikpCisgICAgICAgICAgICAgICAgaWYgKGxpdmVCZWZvcmVb al0pCiAgICAgICAgICAgICAgICAgICAgIGRhdGFMb2dGKCIldSAiLCBqKTsKICAgICAgICAgICAg IH0KICAgICAgICAgICAgIGRhdGFMb2dGKCJcbiIpOwpAQCAtMTc3LDcgKzE3Nyw3IEBAIHZvaWQg Qnl0ZWNvZGVMaXZlbmVzc0FuYWx5c2lzOjpkdW1wUmVzdWwKICAgICAgICAgZGF0YUxvZ0YoIkxp dmUgdmFyaWFibGVzOiAiKTsKICAgICAgICAgRmFzdEJpdFZlY3RvciBsaXZlQWZ0ZXIgPSBibG9j ay0+b3V0KCk7CiAgICAgICAgIGZvciAodW5zaWduZWQgaiA9IDA7IGogPCBsaXZlQWZ0ZXIubnVt Qml0cygpOyBqKyspIHsKLSAgICAgICAgICAgIGlmIChsaXZlQWZ0ZXIuZ2V0KGopKQorICAgICAg ICAgICAgaWYgKGxpdmVBZnRlcltqXSkKICAgICAgICAgICAgICAgICBkYXRhTG9nRigiJXUgIiwg aik7CiAgICAgICAgIH0KICAgICAgICAgZGF0YUxvZ0YoIlxuIik7CkluZGV4OiBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvYnl0ZWNvZGUvQnl0ZWNvZGVMaXZlbmVzc0FuYWx5c2lzSW5saW5lcy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ieXRlY29kZS9CeXRlY29kZUxpdmVu ZXNzQW5hbHlzaXNJbmxpbmVzLmgJKHJldmlzaW9uIDIwNTc5MCkKKysrIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ieXRlY29kZS9CeXRlY29kZUxpdmVuZXNzQW5hbHlzaXNJbmxpbmVzLmgJKHdvcmtp bmcgY29weSkKQEAgLTQzLDcgKzQzLDcgQEAgaW5saW5lIGJvb2wgb3BlcmFuZFRoYXRJc05vdEFs d2F5c0xpdmVJcwogICAgIHVuc2lnbmVkIGxvY2FsID0gVmlydHVhbFJlZ2lzdGVyKG9wZXJhbmQp LnRvTG9jYWwoKTsKICAgICBpZiAobG9jYWwgPj0gb3V0Lm51bUJpdHMoKSkKICAgICAgICAgcmV0 dXJuIGZhbHNlOwotICAgIHJldHVybiBvdXQuZ2V0KGxvY2FsKTsKKyAgICByZXR1cm4gb3V0W2xv Y2FsXTsKIH0KIAogaW5saW5lIGJvb2wgb3BlcmFuZElzTGl2ZShjb25zdCBGYXN0Qml0VmVjdG9y JiBvdXQsIGludCBvcGVyYW5kKQpAQCAtMTE3LDExICsxMTcsMTEgQEAgaW5saW5lIHZvaWQgQnl0 ZWNvZGVMaXZlbmVzc1Byb3BhZ2F0aW9uPAogICAgICAgICBncmFwaCwgYnl0ZWNvZGVPZmZzZXQs IG91dCwKICAgICAgICAgWyZdICh1bnNpZ25lZCBiaXRJbmRleCkgewogICAgICAgICAgICAgLy8g VGhpcyBpcyB0aGUgdXNlIGZ1bmN0b3IsIHNvIHdlIHNldCB0aGUgYml0LgotICAgICAgICAgICAg b3V0LnNldChiaXRJbmRleCk7CisgICAgICAgICAgICBvdXRbYml0SW5kZXhdID0gdHJ1ZTsKICAg ICAgICAgfSwKICAgICAgICAgWyZdICh1bnNpZ25lZCBiaXRJbmRleCkgewogICAgICAgICAgICAg Ly8gVGhpcyBpcyB0aGUgZGVmIGZ1bmN0b3IsIHNvIHdlIGNsZWFyIHRoZSBiaXQuCi0gICAgICAg ICAgICBvdXQuY2xlYXIoYml0SW5kZXgpOworICAgICAgICAgICAgb3V0W2JpdEluZGV4XSA9IGZh bHNlOwogICAgICAgICB9KTsKIH0KIApAQCAtMTkxLDggKzE5MSw4IEBAIGlubGluZSB2b2lkIEJ5 dGVjb2RlTGl2ZW5lc3NQcm9wYWdhdGlvbjwKICAgICAgICAgZm9yIChzdGQ6OnVuaXF1ZV9wdHI8 Qnl0ZWNvZGVCYXNpY0Jsb2NrPiYgYmxvY2sgOiBncmFwaC5iYXNpY0Jsb2Nrc0luUmV2ZXJzZU9y ZGVyKCkpIHsKICAgICAgICAgICAgIG5ld091dC5jbGVhckFsbCgpOwogICAgICAgICAgICAgZm9y IChCeXRlY29kZUJhc2ljQmxvY2sqIHN1Y2Nlc3NvciA6IGJsb2NrLT5zdWNjZXNzb3JzKCkpCi0g ICAgICAgICAgICAgICAgbmV3T3V0Lm1lcmdlKHN1Y2Nlc3Nvci0+aW4oKSk7Ci0gICAgICAgICAg ICBibG9jay0+b3V0KCkuc2V0KG5ld091dCk7CisgICAgICAgICAgICAgICAgbmV3T3V0IHw9IHN1 Y2Nlc3Nvci0+aW4oKTsKKyAgICAgICAgICAgIGJsb2NrLT5vdXQoKSA9IG5ld091dDsKICAgICAg ICAgICAgIGNoYW5nZWQgfD0gY29tcHV0ZUxvY2FsTGl2ZW5lc3NGb3JCbG9jayhncmFwaCwgYmxv Y2suZ2V0KCkpOwogICAgICAgICB9CiAgICAgfSB3aGlsZSAoY2hhbmdlZCk7CkluZGV4OiBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvYnl0ZWNvZGUvQ29kZUJsb2NrLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvSmF2YVNjcmlwdENvcmUvYnl0ZWNvZGUvQ29kZUJsb2NrLmNwcAkocmV2aXNpb24gMjA1 NzkwKQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL2J5dGVjb2RlL0NvZGVCbG9jay5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTQyOTIsNyArNDI5Miw3IEBAIHZvaWQgQ29kZUJsb2NrOjp2YWxpZGF0 ZSgpCiAgICAgZm9yICh1bnNpZ25lZCBpID0gbV9udW1DYWxsZWVMb2NhbHM7IGktLTspIHsKICAg ICAgICAgVmlydHVhbFJlZ2lzdGVyIHJlZyA9IHZpcnR1YWxSZWdpc3RlckZvckxvY2FsKGkpOwog ICAgICAgICAKLSAgICAgICAgaWYgKGxpdmVBdEhlYWQuZ2V0KGkpKSB7CisgICAgICAgIGlmIChs aXZlQXRIZWFkW2ldKSB7CiAgICAgICAgICAgICBiZWdpblZhbGlkYXRpb25EaWRGYWlsKCk7CiAg ICAgICAgICAgICBkYXRhTG9nKCIgICAgVmFyaWFibGUgIiwgcmVnLCAiIGlzIGV4cGVjdGVkIHRv IGJlIGRlYWQuXG4iKTsKICAgICAgICAgICAgIGRhdGFMb2coIiAgICBSZXN1bHQ6ICIsIGxpdmVB dEhlYWQsICJcbiIpOwpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdCeXRlQ29k ZVBhcnNlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdC eXRlQ29kZVBhcnNlci5jcHAJKHJldmlzaW9uIDIwNTc5MCkKKysrIFNvdXJjZS9KYXZhU2NyaXB0 Q29yZS9kZmcvREZHQnl0ZUNvZGVQYXJzZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02MzgsNyAr NjM4LDcgQEAgcHJpdmF0ZToKICAgICAgICAgICAgIGNvbnN0IEZhc3RCaXRWZWN0b3ImIGxpdmVu ZXNzQXRCeXRlY29kZSA9IGZ1bGxMaXZlbmVzcy5nZXRMaXZlbmVzcyhieXRlY29kZUluZGV4KTsK IAogICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBsb2NhbCA9IGNvZGVCbG9jay0+bV9udW1DYWxs ZWVMb2NhbHM7IGxvY2FsLS07KSB7Ci0gICAgICAgICAgICAgICAgaWYgKGxpdmVuZXNzQXRCeXRl Y29kZS5nZXQobG9jYWwpKSB7CisgICAgICAgICAgICAgICAgaWYgKGxpdmVuZXNzQXRCeXRlY29k ZVtsb2NhbF0pIHsKICAgICAgICAgICAgICAgICAgICAgVmlydHVhbFJlZ2lzdGVyIHJlZyA9IHZp cnR1YWxSZWdpc3RlckZvckxvY2FsKGxvY2FsKTsKICAgICAgICAgICAgICAgICAgICAgaWYgKGlu bGluZUNhbGxGcmFtZSkKICAgICAgICAgICAgICAgICAgICAgICAgIHJlZyA9IGlubGluZVN0YWNr RW50cnktPnJlbWFwT3BlcmFuZChyZWcpOwpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2Rm Zy9ERkdGb3JBbGxLaWxscy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9k ZmcvREZHRm9yQWxsS2lsbHMuaAkocmV2aXNpb24gMjA1NzkwKQorKysgU291cmNlL0phdmFTY3Jp cHRDb3JlL2RmZy9ERkdGb3JBbGxLaWxscy5oCSh3b3JraW5nIGNvcHkpCkBAIC03Niw4ICs3Niwx MSBAQCB2b2lkIGZvckFsbEtpbGxlZE9wZXJhbmRzKEdyYXBoJiBncmFwaCwgCiAgICAgICAgIGNv bnN0IEZhc3RCaXRWZWN0b3ImIGxpdmVCZWZvcmUgPSBmdWxsTGl2ZW5lc3MuZ2V0TGl2ZW5lc3Mo YmVmb3JlLmJ5dGVjb2RlSW5kZXgpOwogICAgICAgICBjb25zdCBGYXN0Qml0VmVjdG9yJiBsaXZl QWZ0ZXIgPSBmdWxsTGl2ZW5lc3MuZ2V0TGl2ZW5lc3MoYWZ0ZXIuYnl0ZWNvZGVJbmRleCk7CiAg ICAgICAgIAorICAgICAgICAvLyBGSVhNRTogQ29uc2lkZXIgZG9pbmcgdGhpcyBpbnN0ZWFkOgor ICAgICAgICAvLyAobGl2ZUJlZm9yZSAmIH5saXZlQWZ0ZXIpLmZvckVhY2hTZXRCaXQoLi4uKQor ICAgICAgICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYxODQ5 CiAgICAgICAgIGZvciAodW5zaWduZWQgcmVsYXRpdmVMb2NhbCA9IGNvZGVCbG9jay0+bV9udW1D YWxsZWVMb2NhbHM7IHJlbGF0aXZlTG9jYWwtLTspIHsKLSAgICAgICAgICAgIGlmIChsaXZlQmVm b3JlLmdldChyZWxhdGl2ZUxvY2FsKSAmJiAhbGl2ZUFmdGVyLmdldChyZWxhdGl2ZUxvY2FsKSkK KyAgICAgICAgICAgIGlmIChsaXZlQmVmb3JlW3JlbGF0aXZlTG9jYWxdICYmICFsaXZlQWZ0ZXJb cmVsYXRpdmVMb2NhbF0pCiAgICAgICAgICAgICAgICAgZnVuY3Rvcih2aXJ0dWFsUmVnaXN0ZXJG b3JMb2NhbChyZWxhdGl2ZUxvY2FsKSArIHN0YWNrT2Zmc2V0KTsKICAgICAgICAgfQogICAgICAg ICAKSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHR3JhcGguaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR0dyYXBoLmgJKHJldmlzaW9uIDIwNTc5 MCkKKysrIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHR3JhcGguaAkod29ya2luZyBjb3B5 KQpAQCAtNzQ1LDcgKzc0NSw3IEBAIHB1YmxpYzoKICAgICAgICAgICAgICAgICBpZiAocmVnID49 IGV4Y2x1c2lvblN0YXJ0ICYmIHJlZyA8IGV4Y2x1c2lvbkVuZCkKICAgICAgICAgICAgICAgICAg ICAgY29udGludWU7CiAgICAgICAgICAgICAgICAgCi0gICAgICAgICAgICAgICAgaWYgKGxpdmVu ZXNzLmdldChyZWxhdGl2ZUxvY2FsKSkKKyAgICAgICAgICAgICAgICBpZiAobGl2ZW5lc3NbcmVs YXRpdmVMb2NhbF0pCiAgICAgICAgICAgICAgICAgICAgIGZ1bmN0b3IocmVnKTsKICAgICAgICAg ICAgIH0KICAgICAgICAgICAgIApJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdM aXZlQ2F0Y2hWYXJpYWJsZVByZXNlcnZhdGlvblBoYXNlLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR0xpdmVDYXRjaFZhcmlhYmxlUHJlc2VydmF0aW9uUGhh c2UuY3BwCShyZXZpc2lvbiAyMDU3OTApCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RG R0xpdmVDYXRjaFZhcmlhYmxlUHJlc2VydmF0aW9uUGhhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNSBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUtMjAxNiBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTcz LDcgKzczLDcgQEAgcHVibGljOgogICAgICAgICAgICAgaWYgKEhhbmRsZXJJbmZvKiBoYW5kbGVy ID0gY29kZUJsb2NrLT5oYW5kbGVyRm9yQnl0ZWNvZGVPZmZzZXQoYnl0ZWNvZGVJbmRleFRvQ2hl Y2spKSB7CiAgICAgICAgICAgICAgICAgdW5zaWduZWQgY2F0Y2hCeXRlY29kZUluZGV4ID0gaGFu ZGxlci0+dGFyZ2V0OwogICAgICAgICAgICAgICAgIG1fZ3JhcGguZm9yQWxsTG9jYWxzTGl2ZUlu Qnl0ZWNvZGUoQ29kZU9yaWdpbihjYXRjaEJ5dGVjb2RlSW5kZXgsIGlubGluZUNhbGxGcmFtZSks IFsmXSAoVmlydHVhbFJlZ2lzdGVyIG9wZXJhbmQpIHsKLSAgICAgICAgICAgICAgICAgICAgbV9j dXJyZW50QmxvY2tMaXZlbmVzcy5zZXQob3BlcmFuZC50b0xvY2FsKCksIHRydWUpOyAKKyAgICAg ICAgICAgICAgICAgICAgICAgIG1fY3VycmVudEJsb2NrTGl2ZW5lc3Nbb3BlcmFuZC50b0xvY2Fs KCldID0gdHJ1ZTsgCiAgICAgICAgICAgICAgICAgfSk7CiAgICAgICAgICAgICAgICAgcmV0dXJu IHRydWU7CiAgICAgICAgICAgICB9CkBAIC0xMTAsNyArMTEwLDcgQEAgcHVibGljOgogICAgICAg ICAgICAgICAgICAgICBWaXJ0dWFsUmVnaXN0ZXIgb3BlcmFuZCA9IG5vZGUtPmxvY2FsKCk7CiAK ICAgICAgICAgICAgICAgICAgICAgaW50IHN0YWNrT2Zmc2V0ID0gaW5saW5lQ2FsbEZyYW1lID8g aW5saW5lQ2FsbEZyYW1lLT5zdGFja09mZnNldCA6IDA7Ci0gICAgICAgICAgICAgICAgICAgIGlm ICgob3BlcmFuZC5pc0xvY2FsKCkgJiYgbV9jdXJyZW50QmxvY2tMaXZlbmVzcy5nZXQob3BlcmFu ZC50b0xvY2FsKCkpKQorICAgICAgICAgICAgICAgICAgICBpZiAoKG9wZXJhbmQuaXNMb2NhbCgp ICYmIG1fY3VycmVudEJsb2NrTGl2ZW5lc3Nbb3BlcmFuZC50b0xvY2FsKCldKQogICAgICAgICAg ICAgICAgICAgICAgICAgfHwgKG9wZXJhbmQub2Zmc2V0KCkgPT0gc3RhY2tPZmZzZXQgKyBDYWxs RnJhbWU6OnRoaXNBcmd1bWVudE9mZnNldCgpKSkgewogCiAgICAgICAgICAgICAgICAgICAgICAg ICBWYXJpYWJsZUFjY2Vzc0RhdGEqIHZhcmlhYmxlQWNjZXNzRGF0YSA9IGN1cnJlbnRCbG9ja0Fj Y2Vzc0RhdGEub3BlcmFuZChvcGVyYW5kKTsKQEAgLTEzMSw3ICsxMzEsNyBAQCBwdWJsaWM6CiAg ICAgICAgIHsKICAgICAgICAgICAgIE5vZGVPcmlnaW4gb3JpZ2luID0gYmxvY2stPmF0KGJsb2Nr LT5zaXplKCkgLSAxKS0+b3JpZ2luOwogICAgICAgICAgICAgYXV0byBwcmVzZXJ2ZUxpdmVuZXNz QXRFbmRPZkJsb2NrID0gWyZdIChWaXJ0dWFsUmVnaXN0ZXIgb3BlcmFuZCwgYm9vbCBhbHdheXNJ bnNlcnQpIHsKLSAgICAgICAgICAgICAgICBpZiAoKG9wZXJhbmQuaXNMb2NhbCgpICYmIG1fY3Vy cmVudEJsb2NrTGl2ZW5lc3MuZ2V0KG9wZXJhbmQudG9Mb2NhbCgpKSkgCisgICAgICAgICAgICAg ICAgaWYgKChvcGVyYW5kLmlzTG9jYWwoKSAmJiBtX2N1cnJlbnRCbG9ja0xpdmVuZXNzW29wZXJh bmQudG9Mb2NhbCgpXSkgCiAgICAgICAgICAgICAgICAgICAgIHx8IG9wZXJhbmQuaXNBcmd1bWVu dCgpCiAgICAgICAgICAgICAgICAgICAgIHx8IGFsd2F5c0luc2VydCkgewogICAgICAgICAgICAg ICAgICAgICBWYXJpYWJsZUFjY2Vzc0RhdGEqIGFjY2Vzc0RhdGEgPSBjdXJyZW50QmxvY2tBY2Nl c3NEYXRhLm9wZXJhbmQob3BlcmFuZCk7CkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZn L0RGR05hdHVyYWxMb29wcy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3Jl L2RmZy9ERkdOYXR1cmFsTG9vcHMuY3BwCShyZXZpc2lvbiAyMDU3OTApCisrKyBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvZGZnL0RGR05hdHVyYWxMb29wcy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEw NSw3ICsxMDUsNyBAQCBOYXR1cmFsTG9vcHM6Ok5hdHVyYWxMb29wcyhHcmFwaCYgZ3JhcGgpCiAg ICAgICAgICAgICBkYXRhTG9nKCJEZWFsaW5nIHdpdGggbG9vcCAiLCBsb29wLCAiXG4iKTsKICAg ICAgICAgCiAgICAgICAgIGZvciAodW5zaWduZWQgaiA9IGxvb3Auc2l6ZSgpOyBqLS07KSB7Ci0g ICAgICAgICAgICBzZWVuQmxvY2tzLnNldChsb29wW2pdLT5pbmRleCk7CisgICAgICAgICAgICBz ZWVuQmxvY2tzW2xvb3Bbal0tPmluZGV4XSA9IHRydWU7CiAgICAgICAgICAgICBibG9ja1dvcmts aXN0LmFwcGVuZChsb29wW2pdKTsKICAgICAgICAgfQogICAgICAgICAKQEAgLTEyMCwxMiArMTIw LDEyIEBAIE5hdHVyYWxMb29wczo6TmF0dXJhbExvb3BzKEdyYXBoJiBncmFwaCkKICAgICAgICAg ICAgIAogICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBqID0gYmxvY2stPnByZWRlY2Vzc29ycy5z aXplKCk7IGotLTspIHsKICAgICAgICAgICAgICAgICBCYXNpY0Jsb2NrKiBwcmVkZWNlc3NvciA9 IGJsb2NrLT5wcmVkZWNlc3NvcnNbal07Ci0gICAgICAgICAgICAgICAgaWYgKHNlZW5CbG9ja3Mu Z2V0KHByZWRlY2Vzc29yLT5pbmRleCkpCisgICAgICAgICAgICAgICAgaWYgKHNlZW5CbG9ja3Nb cHJlZGVjZXNzb3ItPmluZGV4XSkKICAgICAgICAgICAgICAgICAgICAgY29udGludWU7CiAgICAg ICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgbG9vcC5hZGRCbG9jayhwcmVkZWNlc3Nvcik7 CiAgICAgICAgICAgICAgICAgYmxvY2tXb3JrbGlzdC5hcHBlbmQocHJlZGVjZXNzb3IpOwotICAg ICAgICAgICAgICAgIHNlZW5CbG9ja3Muc2V0KHByZWRlY2Vzc29yLT5pbmRleCk7CisgICAgICAg ICAgICAgICAgc2VlbkJsb2Nrc1twcmVkZWNlc3Nvci0+aW5kZXhdID0gdHJ1ZTsKICAgICAgICAg ICAgIH0KICAgICAgICAgfQogICAgIH0KSW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcv REZHUGxhbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdQ bGFuLmNwcAkocmV2aXNpb24gMjA1NzkwKQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9E RkdQbGFuLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjkxLDcgKzY5MSw3IEBAIHZvaWQgUGxhbjo6 Y2xlYW5NdXN0SGFuZGxlVmFsdWVzSWZOZWNlc3MKICAgICBGYXN0Qml0VmVjdG9yIGxpdmVuZXNz ID0gY29kZUJsb2NrLT5hbHRlcm5hdGl2ZSgpLT5saXZlbmVzc0FuYWx5c2lzKCkuZ2V0TGl2ZW5l c3NJbmZvQXRCeXRlY29kZU9mZnNldChvc3JFbnRyeUJ5dGVjb2RlSW5kZXgpOwogICAgIAogICAg IGZvciAodW5zaWduZWQgbG9jYWwgPSBtdXN0SGFuZGxlVmFsdWVzLm51bWJlck9mTG9jYWxzKCk7 IGxvY2FsLS07KSB7Ci0gICAgICAgIGlmICghbGl2ZW5lc3MuZ2V0KGxvY2FsKSkKKyAgICAgICAg aWYgKCFsaXZlbmVzc1tsb2NhbF0pCiAgICAgICAgICAgICBtdXN0SGFuZGxlVmFsdWVzLmxvY2Fs KGxvY2FsKSA9IGpzVW5kZWZpbmVkKCk7CiAgICAgfQogfQpJbmRleDogU291cmNlL1dURi9DaGFu Z2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi9DaGFuZ2VMb2cJKHJldmlzaW9uIDIwNTc5 MCkKKysrIFNvdXJjZS9XVEYvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQz IEBACisyMDE2LTA5LTExICBGaWxpcCBQaXpsbyAgPGZwaXpsb0BhcHBsZS5jb20+CisKKyAgICAg ICAgRmFzdEJpdFZlY3RvciBzaG91bGQgaGF2ZSBlZmZpY2llbnQgYW5kIGVhc3ktdG8tdXNlIHZl Y3Rvci12ZWN0b3Igb3BlcmF0aW9ucworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTYxODQ3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisgICAgICAgIAorICAgICAgICBGYXN0Qml0VmVjdG9yIGlzIGEgYml0dmVjdG9yIHJlcHJl c2VudGF0aW9uIHRoYXQgc3VwcG9ydHMgbWFudWFsIGR5bmFtaWMgcmVzaXppbmcgYW5kIGlzCisg ICAgICAgIG9wdGltaXplZCBmb3Igc3BlZWQsIG5vdCBzcGFjZS4gKEJpdFZlY3RvciBzdXBwb3J0 cyBhdXRvbWF0aWMgZHluYW1pYyByZXNpemluZyBhbmQgaXMKKyAgICAgICAgb3B0aW1pemVkIGZv ciBzcGFjZSwgd2hpbGUgQml0bWFwIGlzIHNpemVkIHN0YXRpY2FsbHkgYW5kIGlzIG9wdGltaXpl ZCBmb3IgYm90aCBzcGVlZCBhbmQKKyAgICAgICAgc3BhY2UuKSBUaGlzIGNoYW5nZSBncmVhdGx5 IGluY3JlYXNlcyB0aGUgcG93ZXIgb2YgRmFzdEJpdFZlY3Rvci4gV2Ugd2lsbCB1c2UgdGhlc2Ug bmV3CisgICAgICAgIHBvd2VycyBmb3IgY2hhbmdpbmcgdGhlIEpTQyBHQyB0byB1c2UgRmFzdEJp dFZlY3RvcnMgdG8gdHJhY2sgc2V0cyBvZiBNYXJrZWRCbG9ja3MgKGJ1ZworICAgICAgICAxNjE1 ODEpIGluc3RlYWQgb2YgdXNpbmcgYSBjb21iaW5hdGlvbiBvZiBWZWN0b3JzIGFuZCBkb3VibHkt bGlua2VkIGxpc3RzLgorICAgICAgICAKKyAgICAgICAgVGhpcyBjaGFuZ2Ugc3BsaXRzIEZhc3RC aXRWZWN0b3IgaW50byB0d28gcGFydHM6CisgICAgICAgIAorICAgICAgICAtIEEgdGhpbmcgdGhh dCBtYW5hZ2VzIHRoZSBzdG9yYWdlIG9mIGEgYml0dmVjdG9yOiBhIHVpbnQzMl90IGFycmF5IGFu ZCBhIHNpemVfdCBudW1CaXRzLgorICAgICAgICAgIFdlIGNhbGwgdGhpcyB0aGUgd29yZCB2aWV3 LgorICAgICAgICAtIEEgdGhpbmcgdGhhdCB0YWtlcyBzb21lIGtpbmQgb2YgYWJzdHJhY3QgYXJy YXkgb2YgdWludDMyX3QncyBhbmQgZG9lcyBiaXR2ZWN0b3IKKyAgICAgICAgICBvcGVyYXRpb25z IHRvIGl0LiBXZSBjYWxsIHRoaXMgdGhlIEZhc3RCaXRWZWN0b3JJbXBsLgorICAgICAgICAKKyAg ICAgICAgRmFzdEJpdFZlY3RvckltcGwgYW5kIHdvcmQgdmlld3MgYXJlIGltbXV0YWJsZS4gVGhl IEZhc3RCaXRWZWN0b3IgY2xhc3MgaXMgYSBzdWJjbGFzcyBvZgorICAgICAgICBGYXN0Qml0VmVj dG9ySW1wbCBzcGVjaWFsaXplZCBvbiBhIHdvcmQgdmlldyB0aGF0IG93bnMgaXRzIHdvcmRzIGFu ZCBoYXMgYWRkaXRpb25hbAorICAgICAgICBzdXBwb3J0IGZvciBtdXRhYmxlIG9wZXJhdGlvbnMu CisgICAgICAgIAorICAgICAgICBEb2luZyB0aGlzIGFsbG93cyB1cyB0byBlZmZpY2llbnRseSBz dXBwb3J0IHRoaW5ncyBsaWtlIHRoaXMgd2l0aG91dCBhbnkgdW5uZWNlc3NhcnkKKyAgICAgICAg bWVtb3J5IGFsbG9jYXRpb24gb3IgY29weWluZzoKKyAgICAgICAgCisgICAgICAgIEZhc3RCaXRW ZWN0b3IgYSwgYiwgYzsgLy8gQXNzdW1lIHRoYXQgdGhlcmUgaXMgY29kZSB0byBpbml0aWFsaXpl IHRoZXNlLgorICAgICAgICBhICY9IGIgfCB+YzsKKyAgICAgICAgCisgICAgICAgIFByZXZpb3Vz bHksIHRoaXMga2luZCBvZiBvcGVyYXRpb24gd291bGQgbm90IGJlIGVmZmljaWVudCwgYmVjYXVz ZSAifmMiIHdvdWxkIGhhdmUgdG8KKyAgICAgICAgY3JlYXRlIGEgd2hvbGUgbmV3IEZhc3RCaXRW ZWN0b3IuIEJ1dCBub3csIGl0IGp1c3QgcmV0dXJucyBhIEZhc3RCaXRWZWN0b3JJbXBsIHdob3Nl CisgICAgICAgIHVuZGVybHlpbmcgd29yZCB2aWV3IGJpdG5vdHMgKH4pIGl0cyB3b3JkcyBvbiB0 aGUgZmx5LiBVc2luZyB0ZW1wbGF0ZSBtYWdpYywgdGhpcyBjYW4gZ2V0CisgICAgICAgIHByZXR0 eSBjb21wbGV4LiBGb3IgZXhhbXBsZSAiYiB8IH5jIiByZXR1cm5zIGEgRmFzdEJpdFZlY3Rvcklt cGwgdGhhdCB3cmFwcyBhIHdvcmQgdmlldworICAgICAgICB3aG9zZSBpbXBsZW1lbnRhdGlvbiBv ZiBXb3JkVmlldzo6d29yZChzaXplX3QgaW5kZXgpIGlzIHNvbWV0aGluZyBsaWtlOgorICAgICAg ICAKKyAgICAgICAgdWludDMyX3Qgd29yZChzaXplX3QgaW5kZXgpIHsgcmV0dXJuIGIubV93b3Jk cy53b3JkKGluZGV4KSB8IH5jLm1fd29yZHMud29yZChpbmRleCk7IH0KKyAgICAgICAgCisgICAg ICAgIEZhc3RCaXRWZWN0b3JJbXBsIHN1cHBvcnRzIGFsbCBvZiB0aGUgZmFzdCBidWxrIGJpdHZl Y3RvciBvcGVyYXRpb25zLCBsaWtlCisgICAgICAgIGZvckVhY2hTZXRCaXQoKSwgYml0Q291bnQo KSwgZXRjLiBTbywgd2hlbiB5b3Ugc2F5ICJhICY9IGIgfCB+YyIsIHRoZSBhY3R1YWwKKyAgICAg ICAgaW1wbGVtZW50YXRpb24gaXMgZ29pbmcgdG8gcnVuIHRoZXNlIGJpdCBvcGVyYXRpb25zIG9u IHdvcmQgZ3JhbnVsYXJpdHkgZGlyZWN0bHkgb3ZlciB0aGUKKyAgICAgICAgc3RvcmFnZSBpbnNp ZGUgYSwgYiwgYy4KKyAgICAgICAgCisgICAgICAgIFRoZSB1c2Ugb2Ygb3BlcmF0b3Igb3Zlcmxv YWRpbmcgaXMgd29ydGggZXhwbGFpbmluZyBhIGJpdC4gUHJldmlvdXNseSwgRmFzdEJpdFZlY3Rv cgorICAgICAgICBhdm9pZGVkIG9wZXJhdG9yIG92ZXJsb2FkaW5nLiBGb3IgZXhhbXBsZSwgdGhl ICY9IG9wZXJhdGlvbiB3YXMgY2FsbGVkIGZpbHRlcigpLiBJIHRoaW5rCisgICAgICAgIHRoYXQg dGhpcyB3YXMgYSBwcmV0dHkgZ29vZCBhcHByb2FjaCBhdCB0aGUgdGltZS4gSSB0cmllZCB1c2lu ZyBub24tb3BlcmF0b3IgbWV0aG9kcyBpbgorICAgICAgICB0aGlzIEZhc3RCaXRWZWN0b3IgcmV3 cml0ZSwgYnV0IEkgZm91bmQgaXQgdmVyeSBvZGQgdG8gc2F5IHRoaW5ncyBsaWtlOgorICAgICAg ICAKKyAgICAgICAgYS5maWx0ZXIoYi5iaXRPcihjLmJpdE5vdCgpKSk7CisgICAgICAgIAorICAg ICAgICBJIHRoaW5rIHRoYXQgaXQncyBoYXJkZXIgdG8gc2VlIHdoYXQgaXMgZ29pbmcgb24gaGVy ZSwgdGhlbiB1c2luZyBvcGVyYXRvcnMsIGJlY2F1c2UgaW5maXgKKyAgICAgICAgbm90YXRpb24g aXMgYWx3YXlzIGJldHRlci4KKworICAgICAgICAqIFdURi54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qOgorICAgICAgICAqIHd0Zi9CaXRWZWN0b3IuaDoKKyAgICAgICAgKFdURjo6Qml0VmVjdG9y OjpmaW5kQml0SW5Xb3JkKTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvQ01ha2VMaXN0cy50eHQ6 CisgICAgICAgICogd3RmL0RvbWluYXRvcnMuaDoKKyAgICAgICAgKFdURjo6RG9taW5hdG9yczo6 TmFpdmVEb21pbmF0b3JzOjpOYWl2ZURvbWluYXRvcnMpOgorICAgICAgICAoV1RGOjpEb21pbmF0 b3JzOjpOYWl2ZURvbWluYXRvcnM6OmRvbWluYXRlcyk6CisgICAgICAgIChXVEY6OkRvbWluYXRv cnM6Ok5haXZlRG9taW5hdG9yczo6cHJ1bmVEb21pbmF0b3JzKToKKyAgICAgICAgKiB3dGYvRmFz dEJpdFZlY3Rvci5jcHA6IFJlbW92ZWQuCisgICAgICAgICogd3RmL0Zhc3RCaXRWZWN0b3IuaDoK KyAgICAgICAgKFdURjo6ZmFzdEJpdFZlY3RvckFycmF5TGVuZ3RoKToKKyAgICAgICAgKFdURjo6 RmFzdEJpdFZlY3RvcldvcmRWaWV3OjpGYXN0Qml0VmVjdG9yV29yZFZpZXcpOgorICAgICAgICAo V1RGOjpGYXN0Qml0VmVjdG9yV29yZFZpZXc6Om51bUJpdHMpOgorICAgICAgICAoV1RGOjpGYXN0 Qml0VmVjdG9yV29yZFZpZXc6OndvcmQpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yV29y ZE93bmVyOjpGYXN0Qml0VmVjdG9yV29yZE93bmVyKToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZl Y3RvcldvcmRPd25lcjo6fkZhc3RCaXRWZWN0b3JXb3JkT3duZXIpOgorICAgICAgICAoV1RGOjpG YXN0Qml0VmVjdG9yV29yZE93bmVyOjp2aWV3KToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rv cldvcmRPd25lcjo6b3BlcmF0b3I9KToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3RvcldvcmRP d25lcjo6c2V0QWxsKToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3RvcldvcmRPd25lcjo6Y2xl YXJBbGwpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yV29yZE93bmVyOjpzZXQpOgorICAg ICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yV29yZE93bmVyOjpudW1CaXRzKToKKyAgICAgICAgKFdU Rjo6RmFzdEJpdFZlY3RvcldvcmRPd25lcjo6YXJyYXlMZW5ndGgpOgorICAgICAgICAoV1RGOjpG YXN0Qml0VmVjdG9yV29yZE93bmVyOjpyZXNpemUpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVj dG9yV29yZE93bmVyOjp3b3JkKToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3RvcldvcmRPd25l cjo6d29yZHMpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yQW5kV29yZHM6OkZhc3RCaXRW ZWN0b3JBbmRXb3Jkcyk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JBbmRXb3Jkczo6dmll dyk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JBbmRXb3Jkczo6bnVtQml0cyk6CisgICAg ICAgIChXVEY6OkZhc3RCaXRWZWN0b3JBbmRXb3Jkczo6d29yZCk6CisgICAgICAgIChXVEY6OkZh c3RCaXRWZWN0b3JPcldvcmRzOjpGYXN0Qml0VmVjdG9yT3JXb3Jkcyk6CisgICAgICAgIChXVEY6 OkZhc3RCaXRWZWN0b3JPcldvcmRzOjp2aWV3KToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rv ck9yV29yZHM6Om51bUJpdHMpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yT3JXb3Jkczo6 d29yZCk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JOb3RXb3Jkczo6RmFzdEJpdFZlY3Rv ck5vdFdvcmRzKToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvck5vdFdvcmRzOjp2aWV3KToK KyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvck5vdFdvcmRzOjpudW1CaXRzKToKKyAgICAgICAg KFdURjo6RmFzdEJpdFZlY3Rvck5vdFdvcmRzOjp3b3JkKToKKyAgICAgICAgKFdURjo6RmFzdEJp dFZlY3RvckltcGw6OkZhc3RCaXRWZWN0b3JJbXBsKToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZl Y3RvckltcGw6Om51bUJpdHMpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9ySW1wbDo6c2l6 ZSk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JJbXBsOjphcnJheUxlbmd0aCk6CisgICAg ICAgIChXVEY6OkZhc3RCaXRWZWN0b3JJbXBsOjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdURjo6 RmFzdEJpdFZlY3RvckltcGw6Om9wZXJhdG9yIT0pOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVj dG9ySW1wbDo6YXQpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9ySW1wbDo6b3BlcmF0b3Jb XSk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JJbXBsOjpiaXRDb3VudCk6CisgICAgICAg IChXVEY6OkZhc3RCaXRWZWN0b3JJbXBsOjpvcGVyYXRvciYpOgorICAgICAgICAoV1RGOjpGYXN0 Qml0VmVjdG9ySW1wbDo6b3BlcmF0b3J8KToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcklt cGw6Om9wZXJhdG9yfik6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JJbXBsOjpmb3JFYWNo U2V0Qml0KToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3RvckltcGw6OmZvckVhY2hDbGVhckJp dCk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JJbXBsOjpmb3JFYWNoQml0KToKKyAgICAg ICAgKFdURjo6RmFzdEJpdFZlY3RvckltcGw6OmZpbmRCaXQpOgorICAgICAgICAoV1RGOjpGYXN0 Qml0VmVjdG9ySW1wbDo6ZmluZFNldEJpdCk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JJ bXBsOjpmaW5kQ2xlYXJCaXQpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9ySW1wbDo6ZHVt cCk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3JJbXBsOjphdEltcGwpOgorICAgICAgICAo V1RGOjpGYXN0Qml0VmVjdG9yOjpGYXN0Qml0VmVjdG9yKToKKyAgICAgICAgKFdURjo6RmFzdEJp dFZlY3Rvcjo6b3BlcmF0b3I9KToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcjo6cmVzaXpl KToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcjo6c2V0QWxsKToKKyAgICAgICAgKFdURjo6 RmFzdEJpdFZlY3Rvcjo6Y2xlYXJBbGwpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yOjpz ZXRBbmRDaGVjayk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3I6Om9wZXJhdG9yfD0pOgor ICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yOjpvcGVyYXRvciY9KToKKyAgICAgICAgKFdURjo6 RmFzdEJpdFZlY3Rvcjo6YXQpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yOjpvcGVyYXRv cltdKToKKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcjo6Qml0UmVmZXJlbmNlOjpCaXRSZWZl cmVuY2UpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yOjpCaXRSZWZlcmVuY2U6Om9wZXJh dG9yIGJvb2wpOgorICAgICAgICAoV1RGOjpGYXN0Qml0VmVjdG9yOjpCaXRSZWZlcmVuY2U6Om9w ZXJhdG9yPSk6CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3I6On5GYXN0Qml0VmVjdG9yKTog RGVsZXRlZC4KKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcjo6bnVtQml0cyk6IERlbGV0ZWQu CisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3I6OnNldCk6IERlbGV0ZWQuCisgICAgICAgIChX VEY6OkZhc3RCaXRWZWN0b3I6OmVxdWFscyk6IERlbGV0ZWQuCisgICAgICAgIChXVEY6OkZhc3RC aXRWZWN0b3I6Om1lcmdlKTogRGVsZXRlZC4KKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcjo6 ZmlsdGVyKTogRGVsZXRlZC4KKyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcjo6ZXhjbHVkZSk6 IERlbGV0ZWQuCisgICAgICAgIChXVEY6OkZhc3RCaXRWZWN0b3I6OmNsZWFyKTogRGVsZXRlZC4K KyAgICAgICAgKFdURjo6RmFzdEJpdFZlY3Rvcjo6Z2V0KTogRGVsZXRlZC4KKyAgICAgICAgKFdU Rjo6RmFzdEJpdFZlY3Rvcjo6Yml0Q291bnQpOiBEZWxldGVkLgorICAgICAgICAoV1RGOjpGYXN0 Qml0VmVjdG9yOjpmb3JFYWNoU2V0Qml0KTogRGVsZXRlZC4KKyAgICAgICAgKFdURjo6RmFzdEJp dFZlY3Rvcjo6YXJyYXlMZW5ndGgpOiBEZWxldGVkLgorICAgICAgICAqIHd0Zi9TdGRMaWJFeHRy YXMuaDoKKyAgICAgICAgKFdURjo6ZmluZEJpdEluV29yZCk6CisKIDIwMTYtMDktMTAgIENocmlz IER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAgICAgICBwYXJzZUhUTUxJbnRlZ2VyKCkg c2hvdWxkIHRha2UgYSBTdHJpbmdWaWV3IGluIHBhcmFtZXRlcgpJbmRleDogU291cmNlL1dURi9X VEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL1dU Ri54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAyMDU3OTApCisrKyBTb3VyY2Uv V1RGL1dURi54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC0zMSw3 ICszMSw2IEBACiAJCTBGODI0QTY4MUI3NDQzQTAwMDJFMzQ1RCAvKiBQYXJraW5nTG90LmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDBGODI0QTY0MUI3 NDQzQTAwMDJFMzQ1RCAvKiBQYXJraW5nTG90LmNwcCAqLzsgfTsKIAkJMEY4MjRBNjkxQjc0NDNB MDAwMkUzNDVEIC8qIFBhcmtpbmdMb3QuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDBGODI0QTY1MUI3NDQzQTAwMDJFMzQ1RCAvKiBQYXJraW5nTG90Lmgg Ki87IH07CiAJCTBGODcxMDVBMTY2NDNGMTkwMDkwQjBBRCAvKiBSYXdQb2ludGVyLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwRjg3MTA1OTE2NjQzRjE5 MDA5MEIwQUQgLyogUmF3UG9pbnRlci5oICovOyB9OwotCQkwRjg4NUUwRjE4NDVBRUE5MDBGMUUz RkEgLyogRmFzdEJpdFZlY3Rvci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSAwRjg4NUUwRTE4NDVBRTlGMDBGMUUzRkEgLyogRmFzdEJpdFZlY3Rvci5j cHAgKi87IH07CiAJCTBGOEYyQjkxMTcyRTAwRkMwMDdEQkRBNSAvKiBDb21waWxhdGlvblRocmVh ZC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMEY4RjJC OTAxNzJFMDBGMDAwN0RCREE1IC8qIENvbXBpbGF0aW9uVGhyZWFkLmggKi87IH07CiAJCTBGOEYy QjkyMTcyRTAxMDMwMDdEQkRBNSAvKiBDb21waWxhdGlvblRocmVhZC5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAwRjhGMkI4RjE3MkUwMEYwMDA3REJE QTUgLyogQ29tcGlsYXRpb25UaHJlYWQuY3BwICovOyB9OwogCQkwRjhGMkI5QzE3MkYyNTk2MDA3 REJEQTUgLyogQ29udmVyc2lvbk1vZGUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDBGOEYyQjlCMTcyRjI1OTQwMDdEQkRBNSAvKiBDb252ZXJzaW9uTW9k ZS5oICovOyB9OwpAQCAtMTExLDYgKzExMCw3IEBACiAJCTJDREVEMEYzMTgxMTVDODUwMDREQkE3 MCAvKiBSdW5Mb29wLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDJDREVEMEYxMTgxMTVDODUwMDREQkE3MCAvKiBSdW5Mb29wLmNwcCAqLzsgfTsKIAkJ MkNERUQwRjQxODExNUM4NTAwNERCQTcwIC8qIFJ1bkxvb3AuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDJDREVEMEYyMTgxMTVDODUwMDREQkE3MCAvKiBS dW5Mb29wLmggKi87IH07CiAJCTQzMEI0Nzg5MUFBQUFDMUEwMDEyMjNEQSAvKiBTdHJpbmdDb21t b24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQzMEI0 Nzg3MUFBQUFDMUEwMDEyMjNEQSAvKiBTdHJpbmdDb21tb24uaCAqLzsgfTsKKwkJNEIyNjgwREQ5 Qjk3NDQwMjg5OUVENTcyIC8qIEluZGV4ZWRDb250YWluZXJJdGVyYXRvci5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOUM2N0M1NDI1ODkzNDhFMjg1QjQ5 Njk5IC8qIEluZGV4ZWRDb250YWluZXJJdGVyYXRvci5oICovOyB9OwogCQk1MTNFMTcwQjFDRDdE NUJGMDBFMzY1MEIgLyogTG9nZ2luZ0FjY3VtdWxhdG9yLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTNFMTcwQTFDRDdENUJGMDBFMzY1MEIgLyogTG9n Z2luZ0FjY3VtdWxhdG9yLmggKi87IH07CiAJCTUxNUY3OTRFMUNGQzlGNEEwMENDRUQ5MyAvKiBD cm9zc1RocmVhZENvcGllci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA1MTVGNzk0QjFDRkM5RjRBMDBDQ0VEOTMgLyogQ3Jvc3NUaHJlYWRDb3BpZXIu Y3BwICovOyB9OwogCQk1MTVGNzk0RjFDRkM5RjRBMDBDQ0VEOTMgLyogQ3Jvc3NUaHJlYWRDb3Bp ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxNUY3 OTRDMUNGQzlGNEEwMENDRUQ5MyAvKiBDcm9zc1RocmVhZENvcGllci5oICovOyB9OwpAQCAtMzE1 LDYgKzMxNSw4IEBACiAJCUE4QTQ3NDhDMTUxQTgyNjQwMDQxMjNGRiAvKiBjb25maWcuaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4QTQ3NDhCMTUxQTgy NjQwMDQxMjNGRiAvKiBjb25maWcuaCAqLzsgfTsKIAkJQjM4RkQ3QkQxNjg5NTNFODAwNjVDOTY5 IC8qIEZlYXR1cmVEZWZpbmVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBCMzhGRDdCQzE2ODk1M0U4MDA2NUM5NjkgLyogRmVhdHVyZURlZmluZXMuaCAq LzsgfTsKIAkJQzRGOEE5MzcxOUM2NUVCNDAwQjJCMTVEIC8qIFN0b3B3YXRjaC5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzRGOEE5MzYxOUM2NUVCNDAw QjJCMTVEIC8qIFN0b3B3YXRjaC5oICovOyB9OworCQlDOEIwRTFBMUUwMUE0ODZFQjk1RTBEMTEg LyogSW5kZXhTZXQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDMxMzdFMUQ3REJEODRBQzM4RkFFNEQzNCAvKiBJbmRleFNldC5oICovOyB9OworCQlDOTE2 Qjk3NUYwMkY0RjdFOEI0QUIxMkQgLyogSW5kZXhNYXAuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDVCNDMzODNBNUQwQjQ2M0M5NDMzRDkzMyAvKiBJbmRl eE1hcC5oICovOyB9OwogCQlDRDU0OTdBQzE1ODU3RDAzMDBCNUJDMzAgLyogTWVkaWFUaW1lLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IENENTQ5N0FB MTU4NTdEMDMwMEI1QkMzMCAvKiBNZWRpYVRpbWUuY3BwICovOyB9OwogCQlDRDU0OTdBRDE1ODU3 RDAzMDBCNUJDMzAgLyogTWVkaWFUaW1lLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBDRDU0OTdBQjE1ODU3RDAzMDBCNUJDMzAgLyogTWVkaWFUaW1lLmgg Ki87IH07CiAJCUNFNDY1MTZFMTlEQjFGQjQwMDNFQ0EwNSAvKiBOU01hcFRhYmxlU1BJLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRTQ2NTE2RDE5REIx RkI0MDAzRUNBMDUgLyogTlNNYXBUYWJsZVNQSS5oICovOyB9OwpAQCAtMzM2LDkgKzMzOCw2IEBA CiAJCUZFODkyNUIwMUQwMERBRUMwMDQ2OTA3RSAvKiBJbmRlbnRlci5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkU4OTI1QUYxRDAwREFFQzAwNDY5MDdF IC8qIEluZGVudGVyLmggKi87IH07CiAJCUZFREFDRDNEMTYzMEY4M0YwMEM2OTYzNCAvKiBTdGFj a1N0YXRzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEZFREFDRDNCMTYzMEY4M0YwMEM2OTYzNCAvKiBTdGFja1N0YXRzLmNwcCAqLzsgfTsKIAkJRkVE QUNEM0UxNjMwRjgzRjAwQzY5NjM0IC8qIFN0YWNrU3RhdHMuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFREFDRDNDMTYzMEY4M0YwMEM2OTYzNCAvKiBT dGFja1N0YXRzLmggKi87IH07Ci0JCUM4QjBFMUExRTAxQTQ4NkVCOTVFMEQxMSAvKiBJbmRleFNl dC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMzEzN0Ux RDdEQkQ4NEFDMzhGQUU0RDM0IC8qIEluZGV4U2V0LmggKi87IH07Ci0JCUM5MTZCOTc1RjAyRjRG N0U4QjRBQjEyRCAvKiBJbmRleE1hcC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNUI0MzM4M0E1RDBCNDYzQzk0MzNEOTMzIC8qIEluZGV4TWFwLmggKi87 IH07Ci0JCTRCMjY4MEREOUI5NzQ0MDI4OTlFRDU3MiAvKiBJbmRleGVkQ29udGFpbmVySXRlcmF0 b3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDlDNjdD NTQyNTg5MzQ4RTI4NUI0OTY5OSAvKiBJbmRleGVkQ29udGFpbmVySXRlcmF0b3IuaCAqLzsgfTsK IC8qIEVuZCBQQlhCdWlsZEZpbGUgc2VjdGlvbiAqLwogCiAvKiBCZWdpbiBQQlhDb250YWluZXJJ dGVtUHJveHkgc2VjdGlvbiAqLwpAQCAtMzcwLDcgKzM2OSw2IEBACiAJCTBGODI0QTY0MUI3NDQz QTAwMDJFMzQ1RCAvKiBQYXJraW5nTG90LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IFBhcmtpbmdMb3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkw RjgyNEE2NTFCNzQ0M0EwMDAyRTM0NUQgLyogUGFya2luZ0xvdC5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBQYXJraW5nTG90Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTBGODcxMDU5MTY2NDNGMTkwMDkwQjBBRCAvKiBSYXdQb2ludGVyLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFJhd1BvaW50ZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKLQkJMEY4ODVFMEUxODQ1QUU5RjAwRjFFM0ZBIC8qIEZhc3RCaXRWZWN0b3IuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gRmFzdEJpdFZlY3Rvci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTBGOEYyQjhGMTcyRTAwRjAwMDdEQkRBNSAvKiBDb21waWxhdGlvblRocmVhZC5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBDb21waWxhdGlvblRocmVhZC5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTBGOEYyQjkwMTcyRTAwRjAwMDdEQkRBNSAvKiBDb21waWxhdGlv blRocmVhZC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb21waWxhdGlvblRocmVhZC5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQkwRjhGMkI5QjE3MkYyNTk0MDA3REJEQTUgLyogQ29udmVyc2lv bk1vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQ29udmVyc2lvbk1vZGUuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKQEAgLTQ1Myw2ICs0NTEsNyBAQAogCQkyQ0RFRDBFRTE4MTE1QzM4MDA0REJB NzAgLyogUnVuTG9vcENGLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IFJ1bkxvb3BDRi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTJDREVEMEYxMTgx MTVDODUwMDREQkE3MCAvKiBSdW5Mb29wLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IFJ1bkxvb3AuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkyQ0RF RDBGMjE4MTE1Qzg1MDA0REJBNzAgLyogUnVuTG9vcC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBSdW5Mb29wLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTMxMzdF MUQ3REJEODRBQzM4RkFFNEQzNCAvKiBJbmRleFNldC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBJbmRleFNldC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0MzBC NDc4NzFBQUFBQzFBMDAxMjIzREEgLyogU3RyaW5nQ29tbW9uLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IFN0cmluZ0NvbW1vbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk1MTNFMTcwQTFDRDdENUJGMDBFMzY1MEIgLyogTG9nZ2luZ0FjY3VtdWxhdG9yLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IExvZ2dpbmdBY2N1bXVsYXRvci5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MTVGNzk0QjFDRkM5RjRBMDBDQ0VEOTMgLyogQ3Jv c3NUaHJlYWRDb3BpZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g Q3Jvc3NUaHJlYWRDb3BpZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNDYx LDYgKzQ2MCw3IEBACiAJCTUxNUY3OTU1MUNGRDNBNjkwMENDRUQ5MyAvKiBDcm9zc1RocmVhZFF1 ZXVlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENyb3NzVGhyZWFkUXVldWUu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTM5RUIwNjIxRDU1Mjg0MjAwQzgyRUY3 IC8qIExFQkRlY29kZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTEVCRGVj b2Rlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1NTMwNzFDOTFDNDA0MjcyMDAz ODQ4OTggLyogVGlueUxSVUNhY2hlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IFRpbnlMUlVDYWNoZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk1QjQzMzgzQTVE MEI0NjNDOTQzM0Q5MzMgLyogSW5kZXhNYXAuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gSW5kZXhNYXAuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNUM3Qzg4RDMx RDBBM0EwQTAwOUQyRjZEIC8qIFVuaXF1ZVJlZi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBVbmlxdWVSZWYuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNUQyNDdC NjIxNDY4OUI4NjAwRTc4Qjc2IC8qIGxpYldURi5hICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGV4cGxpY2l0RmlsZVR5cGUgPSBhcmNoaXZlLmFyOyBpbmNsdWRlSW5JbmRleCA9IDA7IHBh dGggPSBsaWJXVEYuYTsgc291cmNlVHJlZSA9IEJVSUxUX1BST0RVQ1RTX0RJUjsgfTsKIAkJNUQy NDdCNkUxNDY4OUM0NzAwRTc4Qjc2IC8qIEJhc2UueGNjb25maWcgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnhjY29uZmlnOyBwYXRoID0gQmFz ZS54Y2NvbmZpZzsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTQ5MSw2ICs0OTEsNyBA QAogCQk5NzRDRkM4RDE2QTRGMzI3MDA2RDU0MDQgLyogV2Vha1B0ci5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBXZWFrUHRyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTlCQzcwRjA0MTc2QzM3OUQwMDEwMURFQyAvKiBBdG9taWNTdHJpbmdUYWJsZS5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBdG9taWNTdHJpbmdUYWJsZS5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTlCRDhGNDBBMTc2QzJBRDgwMDAyRDg2NSAv KiBBdG9taWNTdHJpbmdUYWJsZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBdG9taWNTdHJpbmdUYWJsZS5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5QzY3QzU0MjU4OTM0OEUyODVCNDk2OTkg LyogSW5kZXhlZENvbnRhaW5lckl0ZXJhdG9yLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IEluZGV4ZWRDb250YWluZXJJdGVyYXRvci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlBNTA5OEFGRjFDMTY5RTA3MDAwODc3OTcgLyogU2FuZGJveFNQSS5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTYW5kYm94U1BJLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUE1MDk4QjAxMUMxNkE0RjkwMDA4Nzc5NyAvKiBTZWN1cml0eVNQSS5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTZWN1cml0eVNQSS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQlBNUJBMTVGMjE4MjQzM0E5MDBBODJFNjkgLyogU3RyaW5nTWFj Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBuYW1lID0gU3RyaW5nTWFjLm1t OyBwYXRoID0gbWFjL1N0cmluZ01hYy5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAg LTY4Nyw5ICs2ODgsNiBAQAogCQlGRTg5MjVBRjFEMDBEQUVDMDA0NjkwN0UgLyogSW5kZW50ZXIu aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSW5kZW50ZXIuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkVEQUNEM0IxNjMwRjgzRjAwQzY5NjM0IC8qIFN0YWNrU3Rh dHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gU3RhY2tTdGF0cy5j cHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFREFDRDNDMTYzMEY4M0YwMEM2OTYz NCAvKiBTdGFja1N0YXRzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFN0YWNr U3RhdHMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKLQkJMzEzN0UxRDdEQkQ4NEFDMzhG QUU0RDM0IC8qIEluZGV4U2V0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IElu ZGV4U2V0Lmg7IHBhdGggPSBJbmRleFNldC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owot CQk1QjQzMzgzQTVEMEI0NjNDOTQzM0Q5MzMgLyogSW5kZXhNYXAuaCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuYy5oOyBuYW1lID0gSW5kZXhNYXAuaDsgcGF0aCA9IEluZGV4TWFwLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07Ci0JCTlDNjdDNTQyNTg5MzQ4RTI4NUI0OTY5OSAvKiBJbmRleGVk Q29udGFpbmVySXRlcmF0b3IuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gSW5k ZXhlZENvbnRhaW5lckl0ZXJhdG9yLmg7IHBhdGggPSBJbmRleGVkQ29udGFpbmVySXRlcmF0b3Iu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIC8qIEVuZCBQQlhGaWxlUmVmZXJlbmNlIHNl Y3Rpb24gKi8KIAogLyogQmVnaW4gUEJYRnJhbWV3b3Jrc0J1aWxkUGhhc2Ugc2VjdGlvbiAqLwpA QCAtODgyLDcgKzg4MCw2IEBACiAJCQkJQThBNDcyOTgxNTFBODI1QTAwNDEyM0ZGIC8qIGR0b2Eu aCAqLywKIAkJCQkxQUVBODhFMTFENkJCQ0Y0MDBFNUFENjQgLyogRW51bVRyYWl0cy5oICovLAog CQkJCUE4QTQ3MjlGMTUxQTgyNUEwMDQxMjNGRiAvKiBFeHBvcnRNYWNyb3MuaCAqLywKLQkJCQkw Rjg4NUUwRTE4NDVBRTlGMDBGMUUzRkEgLyogRmFzdEJpdFZlY3Rvci5jcHAgKi8sCiAJCQkJMEZE ODFBQzQxNTRGQjIyRTAwOTgzRTcyIC8qIEZhc3RCaXRWZWN0b3IuaCAqLywKIAkJCQlBOEE0NzJB MTE1MUE4MjVBMDA0MTIzRkYgLyogRmFzdE1hbGxvYy5jcHAgKi8sCiAJCQkJQThBNDcyQTIxNTFB ODI1QTAwNDEyM0ZGIC8qIEZhc3RNYWxsb2MuaCAqLywKQEAgLTE1ODQsNyArMTU4MSw2IEBACiAJ CQkJQThBNDczQjAxNTFBODI1QjAwNDEyM0ZGIC8qIGRvdWJsZS1jb252ZXJzaW9uLmNjIGluIFNv dXJjZXMgKi8sCiAJCQkJQThBNDczQkExNTFBODI1QjAwNDEyM0ZGIC8qIGR0b2EuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJQThBNDczQjMxNTFBODI1QjAwNDEyM0ZGIC8qIGZhc3QtZHRvYS5jYyBp biBTb3VyY2VzICovLAotCQkJCTBGODg1RTBGMTg0NUFFQTkwMEYxRTNGQSAvKiBGYXN0Qml0VmVj dG9yLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUE4QTQ3M0MzMTUxQTgyNUIwMDQxMjNGRiAvKiBG YXN0TWFsbG9jLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTBGOUQzMzYwMTY1REJBNzMwMDVBRDM4 NyAvKiBGaWxlUHJpbnRTdHJlYW0uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQThBNDczQjUxNTFB ODI1QjAwNDEyM0ZGIC8qIGZpeGVkLWR0b2EuY2MgaW4gU291cmNlcyAqLywKSW5kZXg6IFNvdXJj ZS9XVEYvd3RmL0JpdFZlY3Rvci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL0JpdFZl Y3Rvci5oCShyZXZpc2lvbiAyMDU3OTApCisrKyBTb3VyY2UvV1RGL3d0Zi9CaXRWZWN0b3IuaAko d29ya2luZyBjb3B5KQpAQCAtNDAzLDIxICs0MDMsNiBAQCBwcml2YXRlOgogICAgICAgICByZXR1 cm4gc2l6ZSgpOwogICAgIH0KICAgICAKLSAgICBzdGF0aWMgYm9vbCBmaW5kQml0SW5Xb3JkKHVp bnRwdHJfdCB3b3JkLCBzaXplX3QmIGluZGV4LCBzaXplX3QgZW5kSW5kZXgsIGJvb2wgdmFsdWUp Ci0gICAgewotICAgICAgICB3b3JkID4+PSBpbmRleDsKLSAgICAgICAgCi0gICAgICAgIHdoaWxl IChpbmRleCA8IGVuZEluZGV4KSB7Ci0gICAgICAgICAgICBpZiAoKHdvcmQgJiAxKSA9PSBzdGF0 aWNfY2FzdDx1aW50cHRyX3Q+KHZhbHVlKSkKLSAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsK LSAgICAgICAgICAgIGluZGV4Kys7Ci0gICAgICAgICAgICB3b3JkID4+PSAxOwotICAgICAgICB9 Ci0KLSAgICAgICAgaW5kZXggPSBlbmRJbmRleDsKLSAgICAgICAgcmV0dXJuIGZhbHNlOwotICAg IH0KLSAgICAKICAgICBjbGFzcyBPdXRPZkxpbmVCaXRzIHsKICAgICBwdWJsaWM6CiAgICAgICAg IHNpemVfdCBudW1CaXRzKCkgY29uc3QgeyByZXR1cm4gbV9udW1CaXRzOyB9CkluZGV4OiBTb3Vy Y2UvV1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9D TWFrZUxpc3RzLnR4dAkocmV2aXNpb24gMjA1NzkwKQorKysgU291cmNlL1dURi93dGYvQ01ha2VM aXN0cy50eHQJKHdvcmtpbmcgY29weSkKQEAgLTE4MSw3ICsxODEsNiBAQCBzZXQoV1RGX1NPVVJD RVMKICAgICBEYXRhTG9nLmNwcAogICAgIERhdGVNYXRoLmNwcAogICAgIERlY2ltYWxOdW1iZXIu Y3BwCi0gICAgRmFzdEJpdFZlY3Rvci5jcHAKICAgICBGYXN0TWFsbG9jLmNwcAogICAgIEZpbGVQ cmludFN0cmVhbS5jcHAKICAgICBGdW5jdGlvbkRpc3BhdGNoZXIuY3BwCkluZGV4OiBTb3VyY2Uv V1RGL3d0Zi9Eb21pbmF0b3JzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvRG9taW5h dG9ycy5oCShyZXZpc2lvbiAyMDU3OTApCisrKyBTb3VyY2UvV1RGL3d0Zi9Eb21pbmF0b3JzLmgJ KHdvcmtpbmcgY29weSkKQEAgLTUxNSwxNCArNTE1LDE0IEBAIHByaXZhdGU6CiAKICAgICAgICAg ICAgIC8vIFdlIGtub3cgdGhhdCB0aGUgZW50cnkgYmxvY2sgaXMgb25seSBkb21pbmF0ZWQgYnkg aXRzZWxmLgogICAgICAgICAgICAgbV9yZXN1bHRzWzBdLmNsZWFyQWxsKCk7Ci0gICAgICAgICAg ICBtX3Jlc3VsdHNbMF0uc2V0KDApOworICAgICAgICAgICAgbV9yZXN1bHRzWzBdWzBdID0gdHJ1 ZTsKIAogICAgICAgICAgICAgLy8gRmluZCBhbGwgb2YgdGhlIHZhbGlkIGJsb2Nrcy4KICAgICAg ICAgICAgIG1fc2NyYXRjaC5jbGVhckFsbCgpOwogICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBp ID0gbnVtQmxvY2tzOyBpLS07KSB7CiAgICAgICAgICAgICAgICAgaWYgKCFncmFwaC5ub2RlKGkp KQogICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgICAgICAgICBtX3NjcmF0 Y2guc2V0KGkpOworICAgICAgICAgICAgICAgIG1fc2NyYXRjaFtpXSA9IHRydWU7CiAgICAgICAg ICAgICB9CiAgICAgCiAgICAgICAgICAgICAvLyBNYXJrIGFsbCBub2RlcyBhcyBkb21pbmF0ZWQg YnkgZXZlcnl0aGluZy4KQEAgLTUzMCw3ICs1MzAsNyBAQCBwcml2YXRlOgogICAgICAgICAgICAg ICAgIGlmICghZ3JhcGgubm9kZShpKSB8fCAhZ3JhcGgucHJlZGVjZXNzb3JzKGdyYXBoLm5vZGUo aSkpLnNpemUoKSkKICAgICAgICAgICAgICAgICAgICAgbV9yZXN1bHRzW2ldLmNsZWFyQWxsKCk7 CiAgICAgICAgICAgICAgICAgZWxzZQotICAgICAgICAgICAgICAgICAgICBtX3Jlc3VsdHNbaV0u c2V0KG1fc2NyYXRjaCk7CisgICAgICAgICAgICAgICAgICAgIG1fcmVzdWx0c1tpXSA9IG1fc2Ny YXRjaDsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgLy8gSXRlcmF0aXZlbHkgZWxpbWlu YXRlIG5vZGVzIHRoYXQgYXJlIG5vdCBkb21pbmF0b3IuCkBAIC01NTMsNyArNTUzLDcgQEAgcHJp dmF0ZToKICAgICAgICAgCiAgICAgICAgIGJvb2wgZG9taW5hdGVzKHVuc2lnbmVkIGZyb20sIHVu c2lnbmVkIHRvKSBjb25zdAogICAgICAgICB7Ci0gICAgICAgICAgICByZXR1cm4gbV9yZXN1bHRz W3RvXS5nZXQoZnJvbSk7CisgICAgICAgICAgICByZXR1cm4gbV9yZXN1bHRzW3RvXVtmcm9tXTsK ICAgICAgICAgfQogICAgIAogICAgICAgICBib29sIGRvbWluYXRlcyh0eXBlbmFtZSBHcmFwaDo6 Tm9kZSBmcm9tLCB0eXBlbmFtZSBHcmFwaDo6Tm9kZSB0bykgY29uc3QKQEAgLTU4NiwxMiArNTg2 LDEyIEBAIHByaXZhdGU6CiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgICAg ICAgICAvLyBGaW5kIHRoZSBpbnRlcnNlY3Rpb24gb2YgZG9tKHByZWRzKS4KLSAgICAgICAgICAg IG1fc2NyYXRjaC5zZXQobV9yZXN1bHRzW21fZ3JhcGguaW5kZXgobV9ncmFwaC5wcmVkZWNlc3Nv cnMoYmxvY2spWzBdKV0pOworICAgICAgICAgICAgbV9zY3JhdGNoID0gbV9yZXN1bHRzW21fZ3Jh cGguaW5kZXgobV9ncmFwaC5wcmVkZWNlc3NvcnMoYmxvY2spWzBdKV07CiAgICAgICAgICAgICBm b3IgKHVuc2lnbmVkIGogPSBtX2dyYXBoLnByZWRlY2Vzc29ycyhibG9jaykuc2l6ZSgpOyBqLS0g PiAxOykKLSAgICAgICAgICAgICAgICBtX3NjcmF0Y2guZmlsdGVyKG1fcmVzdWx0c1ttX2dyYXBo LmluZGV4KG1fZ3JhcGgucHJlZGVjZXNzb3JzKGJsb2NrKVtqXSldKTsKKyAgICAgICAgICAgICAg ICBtX3NjcmF0Y2ggJj0gbV9yZXN1bHRzW21fZ3JhcGguaW5kZXgobV9ncmFwaC5wcmVkZWNlc3Nv cnMoYmxvY2spW2pdKV07CiAKICAgICAgICAgICAgIC8vIFRoZSBibG9jayBpcyBhbHNvIGRvbWlu YXRlZCBieSBpdHNlbGYuCi0gICAgICAgICAgICBtX3NjcmF0Y2guc2V0KGlkeCk7CisgICAgICAg ICAgICBtX3NjcmF0Y2hbaWR4XSA9IHRydWU7CiAKICAgICAgICAgICAgIHJldHVybiBtX3Jlc3Vs dHNbaWR4XS5zZXRBbmRDaGVjayhtX3NjcmF0Y2gpOwogICAgICAgICB9CkluZGV4OiBTb3VyY2Uv V1RGL3d0Zi9GYXN0Qml0VmVjdG9yLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9G YXN0Qml0VmVjdG9yLmNwcAkocmV2aXNpb24gMjA1NzkwKQorKysgU291cmNlL1dURi93dGYvRmFz dEJpdFZlY3Rvci5jcHAJKG5vbmV4aXN0ZW50KQpAQCAtMSw0MCArMCwwIEBACi0vKgotICogQ29w eXJpZ2h0IChDKSAyMDEzIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K LSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycn IEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFCi0gKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKLSAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCi0gKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK LSAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKLSAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgotICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKLSAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIK LSNpbmNsdWRlICJGYXN0Qml0VmVjdG9yLmgiCi0KLSNpbmNsdWRlICJQcmludFN0cmVhbS5oIgot Ci1uYW1lc3BhY2UgV1RGIHsKLQotdm9pZCBGYXN0Qml0VmVjdG9yOjpkdW1wKFByaW50U3RyZWFt JiBvdXQpIGNvbnN0Ci17Ci0gICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG1fbnVtQml0czsg KytpKQotICAgICAgICBvdXQucHJpbnQoZ2V0KGkpID8gIjEiIDogIi0iKTsKLX0KLQotfSAvLyBu YW1lc3BhY2UgV1RGCi0KSW5kZXg6IFNvdXJjZS9XVEYvd3RmL0Zhc3RCaXRWZWN0b3IuaAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV1RGL3d0Zi9GYXN0Qml0VmVjdG9yLmgJKHJldmlzaW9uIDIwNTc5 MCkKKysrIFNvdXJjZS9XVEYvd3RmL0Zhc3RCaXRWZWN0b3IuaAkod29ya2luZyBjb3B5KQpAQCAt MSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTIsIDIwMTMgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDEyLCAyMDEzLCAyMDE2IEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucwpAQCAtMjcsNDggKzI3LDExNiBAQAogCiAjaW5jbHVkZSA8c3RyaW5nLmg+CiAjaW5jbHVk ZSA8d3RmL0Zhc3RNYWxsb2MuaD4KKyNpbmNsdWRlIDx3dGYvUHJpbnRTdHJlYW0uaD4KICNpbmNs dWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAKIG5hbWVzcGFjZSBXVEYgewogCiBjbGFzcyBQcmlu dFN0cmVhbTsKIAotY2xhc3MgRmFzdEJpdFZlY3RvciB7CitpbmxpbmUgc2l6ZV90IGZhc3RCaXRW ZWN0b3JBcnJheUxlbmd0aChzaXplX3QgbnVtQml0cykgeyByZXR1cm4gKG51bUJpdHMgKyAzMSkg Pj4gNTsgfQorCitjbGFzcyBGYXN0Qml0VmVjdG9yV29yZFZpZXcgewogcHVibGljOgotICAgIEZh c3RCaXRWZWN0b3IoKSA9IGRlZmF1bHQ7CisgICAgdHlwZWRlZiBGYXN0Qml0VmVjdG9yV29yZFZp ZXcgVmlld1R5cGU7CisgICAgCisgICAgRmFzdEJpdFZlY3RvcldvcmRWaWV3KCkgeyB9CisgICAg CisgICAgRmFzdEJpdFZlY3RvcldvcmRWaWV3KGNvbnN0IHVpbnQzMl90KiBhcnJheSwgc2l6ZV90 IG51bUJpdHMpCisgICAgICAgIDogbV93b3JkcyhhcnJheSkKKyAgICAgICAgLCBtX251bUJpdHMo bnVtQml0cykKKyAgICB7CisgICAgfQorICAgIAorICAgIHNpemVfdCBudW1CaXRzKCkgY29uc3QK KyAgICB7CisgICAgICAgIHJldHVybiBtX251bUJpdHM7CisgICAgfQorICAgIAorICAgIHVpbnQz Ml90IHdvcmQoc2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAgICAgQVNTRVJUX1dJVEhf U0VDVVJJVFlfSU1QTElDQVRJT04oaW5kZXggPCBmYXN0Qml0VmVjdG9yQXJyYXlMZW5ndGgobnVt Qml0cygpKSk7CisgICAgICAgIHJldHVybiBtX3dvcmRzW2luZGV4XTsKKyAgICB9CisgICAgCitw cml2YXRlOgorICAgIGNvbnN0IHVpbnQzMl90KiBtX3dvcmRzIHsgbnVsbHB0ciB9OworICAgIHNp emVfdCBtX251bUJpdHMgeyAwIH07Cit9OwogCi0gICAgRmFzdEJpdFZlY3RvcihGYXN0Qml0VmVj dG9yJiYgb3RoZXIpCi0gICAgICAgIDogbV9hcnJheShzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fYXJy YXksIG51bGxwdHIpKQorY2xhc3MgRmFzdEJpdFZlY3RvcldvcmRPd25lciB7CitwdWJsaWM6Cisg ICAgdHlwZWRlZiBGYXN0Qml0VmVjdG9yV29yZFZpZXcgVmlld1R5cGU7CisgICAgCisgICAgRmFz dEJpdFZlY3RvcldvcmRPd25lcigpID0gZGVmYXVsdDsKKyAgICAKKyAgICBGYXN0Qml0VmVjdG9y V29yZE93bmVyKEZhc3RCaXRWZWN0b3JXb3JkT3duZXImJiBvdGhlcikKKyAgICAgICAgOiBtX3dv cmRzKHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV93b3JkcywgbnVsbHB0cikpCiAgICAgICAgICwgbV9u dW1CaXRzKHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV9udW1CaXRzLCAwKSkKICAgICB7CiAgICAgfQog Ci0gICAgRmFzdEJpdFZlY3Rvcihjb25zdCBGYXN0Qml0VmVjdG9yJiBvdGhlcikKLSAgICAgICAg OiBtX2FycmF5KDApCi0gICAgICAgICwgbV9udW1CaXRzKDApCisgICAgRmFzdEJpdFZlY3Rvcldv cmRPd25lcihjb25zdCBGYXN0Qml0VmVjdG9yV29yZE93bmVyJiBvdGhlcikKICAgICB7CiAgICAg ICAgICp0aGlzID0gb3RoZXI7CiAgICAgfQogICAgIAotICAgIH5GYXN0Qml0VmVjdG9yKCkKKyAg ICB+RmFzdEJpdFZlY3RvcldvcmRPd25lcigpCiAgICAgewotICAgICAgICBpZiAobV9hcnJheSkK LSAgICAgICAgICAgIGZhc3RGcmVlKG1fYXJyYXkpOworICAgICAgICBpZiAobV93b3JkcykKKyAg ICAgICAgICAgIGZhc3RGcmVlKG1fd29yZHMpOwogICAgIH0KICAgICAKLSAgICBGYXN0Qml0VmVj dG9yJiBvcGVyYXRvcj0oY29uc3QgRmFzdEJpdFZlY3RvciYgb3RoZXIpCisgICAgRmFzdEJpdFZl Y3RvcldvcmRWaWV3IHZpZXcoKSBjb25zdCB7IHJldHVybiBGYXN0Qml0VmVjdG9yV29yZFZpZXco bV93b3JkcywgbV9udW1CaXRzKTsgfQorICAgIAorICAgIEZhc3RCaXRWZWN0b3JXb3JkT3duZXIm IG9wZXJhdG9yPShjb25zdCBGYXN0Qml0VmVjdG9yV29yZE93bmVyJiBvdGhlcikKICAgICB7CiAg ICAgICAgIHNpemVfdCBsZW5ndGggPSBvdGhlci5hcnJheUxlbmd0aCgpOworICAgICAgICBpZiAo bGVuZ3RoID09IGFycmF5TGVuZ3RoKCkpIHsKKyAgICAgICAgICAgIG1lbWNweShtX3dvcmRzLCBv dGhlci5tX3dvcmRzLCBsZW5ndGggKiA0KTsKKyAgICAgICAgICAgIHJldHVybiAqdGhpczsKKyAg ICAgICAgfQogICAgICAgICB1aW50MzJfdCogbmV3QXJyYXkgPSBzdGF0aWNfY2FzdDx1aW50MzJf dCo+KGZhc3RDYWxsb2MobGVuZ3RoLCA0KSk7Ci0gICAgICAgIG1lbWNweShuZXdBcnJheSwgb3Ro ZXIubV9hcnJheSwgbGVuZ3RoICogNCk7Ci0gICAgICAgIGlmIChtX2FycmF5KQotICAgICAgICAg ICAgZmFzdEZyZWUobV9hcnJheSk7Ci0gICAgICAgIG1fYXJyYXkgPSBuZXdBcnJheTsKKyAgICAg ICAgbWVtY3B5KG5ld0FycmF5LCBvdGhlci5tX3dvcmRzLCBsZW5ndGggKiA0KTsKKyAgICAgICAg aWYgKG1fd29yZHMpCisgICAgICAgICAgICBmYXN0RnJlZShtX3dvcmRzKTsKKyAgICAgICAgbV93 b3JkcyA9IG5ld0FycmF5OwogICAgICAgICBtX251bUJpdHMgPSBvdGhlci5tX251bUJpdHM7CiAg ICAgICAgIHJldHVybiAqdGhpczsKICAgICB9CiAgICAgCi0gICAgc2l6ZV90IG51bUJpdHMoKSBj b25zdCB7IHJldHVybiBtX251bUJpdHM7IH0KKyAgICBGYXN0Qml0VmVjdG9yV29yZE93bmVyJiBv cGVyYXRvcj0oRmFzdEJpdFZlY3RvcldvcmRPd25lciYmIG90aGVyKQorICAgIHsKKyAgICAgICAg c3RkOjpzd2FwKG1fd29yZHMsIG90aGVyLm1fd29yZHMpOworICAgICAgICBzdGQ6OnN3YXAobV9u dW1CaXRzLCBvdGhlci5tX251bUJpdHMpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQor ICAgIAorICAgIHZvaWQgc2V0QWxsKCkKKyAgICB7CisgICAgICAgIG1lbXNldChtX3dvcmRzLCAy NTUsIGFycmF5TGVuZ3RoKCkgKiA0KTsKKyAgICB9CisgICAgCisgICAgdm9pZCBjbGVhckFsbCgp CisgICAgeworICAgICAgICBtZW1zZXQobV93b3JkcywgMCwgYXJyYXlMZW5ndGgoKSAqIDQpOwor ICAgIH0KKyAgICAKKyAgICB2b2lkIHNldChjb25zdCBGYXN0Qml0VmVjdG9yV29yZE93bmVyJiBv dGhlcikKKyAgICB7CisgICAgICAgIEFTU0VSVF9XSVRIX1NFQ1VSSVRZX0lNUExJQ0FUSU9OKG1f bnVtQml0cyA9PSBvdGhlci5tX251bUJpdHMpOworICAgICAgICBtZW1jcHkobV93b3Jkcywgb3Ro ZXIubV93b3JkcywgYXJyYXlMZW5ndGgoKSAqIDQpOworICAgIH0KKyAgICAKKyAgICBzaXplX3Qg bnVtQml0cygpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gbV9udW1CaXRzOworICAgIH0K KyAgICAKKyAgICBzaXplX3QgYXJyYXlMZW5ndGgoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0 dXJuIGZhc3RCaXRWZWN0b3JBcnJheUxlbmd0aChudW1CaXRzKCkpOworICAgIH0KICAgICAKICAg ICB2b2lkIHJlc2l6ZShzaXplX3QgbnVtQml0cykKICAgICB7CkBAIC03OCwxMzMgKzE0Niw0MDYg QEAgcHVibGljOgogICAgICAgICAvLyBVc2UgZmFzdENhbGxvYyBpbnN0ZWFkIG9mIGZhc3RSZWFs bG9jIGJlY2F1c2Ugd2UgZXhwZWN0IHRoZSBjb21tb24KICAgICAgICAgLy8gdXNlIGNhc2UgZm9y IHRoaXMgbWV0aG9kIHRvIGJlIGluaXRpYWxpemluZyB0aGUgc2l6ZSBvZiB0aGUgYml0dmVjdG9y LgogICAgICAgICAKLSAgICAgICAgc2l6ZV90IG5ld0xlbmd0aCA9IGFycmF5TGVuZ3RoKG51bUJp dHMpOworICAgICAgICBzaXplX3QgbmV3TGVuZ3RoID0gZmFzdEJpdFZlY3RvckFycmF5TGVuZ3Ro KG51bUJpdHMpOwogICAgICAgICB1aW50MzJfdCogbmV3QXJyYXkgPSBzdGF0aWNfY2FzdDx1aW50 MzJfdCo+KGZhc3RDYWxsb2MobmV3TGVuZ3RoLCA0KSk7Ci0gICAgICAgIG1lbWNweShuZXdBcnJh eSwgbV9hcnJheSwgYXJyYXlMZW5ndGgoKSAqIDQpOwotICAgICAgICBpZiAobV9hcnJheSkKLSAg ICAgICAgICAgIGZhc3RGcmVlKG1fYXJyYXkpOwotICAgICAgICBtX2FycmF5ID0gbmV3QXJyYXk7 CisgICAgICAgIG1lbWNweShuZXdBcnJheSwgbV93b3JkcywgYXJyYXlMZW5ndGgoKSAqIDQpOwor ICAgICAgICBpZiAobV93b3JkcykKKyAgICAgICAgICAgIGZhc3RGcmVlKG1fd29yZHMpOworICAg ICAgICBtX3dvcmRzID0gbmV3QXJyYXk7CiAgICAgICAgIG1fbnVtQml0cyA9IG51bUJpdHM7CiAg ICAgfQogICAgIAotICAgIHZvaWQgc2V0QWxsKCkKKyAgICB1aW50MzJfdCB3b3JkKHNpemVfdCBp bmRleCkgY29uc3QKICAgICB7Ci0gICAgICAgIG1lbXNldChtX2FycmF5LCAyNTUsIGFycmF5TGVu Z3RoKCkgKiA0KTsKKyAgICAgICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04oaW5k ZXggPCBhcnJheUxlbmd0aCgpKTsKKyAgICAgICAgcmV0dXJuIG1fd29yZHNbaW5kZXhdOwogICAg IH0KICAgICAKLSAgICB2b2lkIGNsZWFyQWxsKCkKKyAgICB1aW50MzJfdCYgd29yZChzaXplX3Qg aW5kZXgpCiAgICAgewotICAgICAgICBtZW1zZXQobV9hcnJheSwgMCwgYXJyYXlMZW5ndGgoKSAq IDQpOworICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihpbmRleCA8IGFy cmF5TGVuZ3RoKCkpOworICAgICAgICByZXR1cm4gbV93b3Jkc1tpbmRleF07CiAgICAgfQogICAg IAotICAgIHZvaWQgc2V0KGNvbnN0IEZhc3RCaXRWZWN0b3ImIG90aGVyKQorICAgIGNvbnN0IHVp bnQzMl90KiB3b3JkcygpIGNvbnN0IHsgcmV0dXJuIG1fd29yZHM7IH0KKyAgICB1aW50MzJfdCog d29yZHMoKSB7IHJldHVybiBtX3dvcmRzOyB9CisKK3ByaXZhdGU6CisgICAgdWludDMyX3QqIG1f d29yZHMgeyBudWxscHRyIH07CisgICAgc2l6ZV90IG1fbnVtQml0cyB7IDAgfTsKK307CisKK3Rl bXBsYXRlPHR5cGVuYW1lIExlZnQsIHR5cGVuYW1lIFJpZ2h0PgorY2xhc3MgRmFzdEJpdFZlY3Rv ckFuZFdvcmRzIHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIEZhc3RCaXRWZWN0b3JBbmRXb3JkcyBW aWV3VHlwZTsKKyAgICAKKyAgICBGYXN0Qml0VmVjdG9yQW5kV29yZHMoY29uc3QgTGVmdCYgbGVm dCwgY29uc3QgUmlnaHQmIHJpZ2h0KQorICAgICAgICA6IG1fbGVmdChsZWZ0KQorICAgICAgICAs IG1fcmlnaHQocmlnaHQpCiAgICAgewotICAgICAgICBBU1NFUlQobV9udW1CaXRzID09IG90aGVy Lm1fbnVtQml0cyk7Ci0gICAgICAgIG1lbWNweShtX2FycmF5LCBvdGhlci5tX2FycmF5LCBhcnJh eUxlbmd0aCgpICogNCk7CisgICAgICAgIEFTU0VSVF9XSVRIX1NFQ1VSSVRZX0lNUExJQ0FUSU9O KG1fbGVmdC5udW1CaXRzKCkgPT0gbV9yaWdodC5udW1CaXRzKCkpOwogICAgIH0KICAgICAKLSAg ICBib29sIHNldEFuZENoZWNrKGNvbnN0IEZhc3RCaXRWZWN0b3ImIG90aGVyKQorICAgIEZhc3RC aXRWZWN0b3JBbmRXb3JkcyB2aWV3KCkgY29uc3QgeyByZXR1cm4gKnRoaXM7IH0KKyAgICAKKyAg ICBzaXplX3QgbnVtQml0cygpIGNvbnN0CiAgICAgewotICAgICAgICBib29sIGNoYW5nZWQgPSBm YWxzZTsKLSAgICAgICAgQVNTRVJUKG1fbnVtQml0cyA9PSBvdGhlci5tX251bUJpdHMpOwotICAg ICAgICBmb3IgKHVuc2lnbmVkIGkgPSBhcnJheUxlbmd0aCgpOyBpLS07KSB7Ci0gICAgICAgICAg ICBjaGFuZ2VkIHw9IG1fYXJyYXlbaV0gIT0gb3RoZXIubV9hcnJheVtpXTsKLSAgICAgICAgICAg IG1fYXJyYXlbaV0gPSBvdGhlci5tX2FycmF5W2ldOwotICAgICAgICB9Ci0gICAgICAgIHJldHVy biBjaGFuZ2VkOworICAgICAgICByZXR1cm4gbV9sZWZ0Lm51bUJpdHMoKTsKICAgICB9CiAgICAg Ci0gICAgYm9vbCBlcXVhbHMoY29uc3QgRmFzdEJpdFZlY3RvciYgb3RoZXIpIGNvbnN0CisgICAg dWludDMyX3Qgd29yZChzaXplX3QgaW5kZXgpIGNvbnN0CiAgICAgewotICAgICAgICBBU1NFUlQo bV9udW1CaXRzID09IG90aGVyLm1fbnVtQml0cyk7Ci0gICAgICAgIC8vIFVzZSBteSBvd24gY29t cGFyaXNvbiBsb29wIGJlY2F1c2UgbWVtY21wIGRvZXMgbW9yZSB0aGFuIHdoYXQgSSB3YW50Ci0g ICAgICAgIC8vIGFuZCBiY21wIGlzIG5vdCBhcyBzdGFuZGFyZC4KLSAgICAgICAgZm9yICh1bnNp Z25lZCBpID0gYXJyYXlMZW5ndGgoKTsgaS0tOykgewotICAgICAgICAgICAgaWYgKG1fYXJyYXlb aV0gIT0gb3RoZXIubV9hcnJheVtpXSkKLSAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7Ci0g ICAgICAgIH0KLSAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIHJldHVybiBtX2xlZnQud29y ZChpbmRleCkgJiBtX3JpZ2h0LndvcmQoaW5kZXgpOwogICAgIH0KICAgICAKLSAgICB2b2lkIG1l cmdlKGNvbnN0IEZhc3RCaXRWZWN0b3ImIG90aGVyKQorcHJpdmF0ZToKKyAgICBMZWZ0IG1fbGVm dDsKKyAgICBSaWdodCBtX3JpZ2h0OworfTsKKyAgICAKK3RlbXBsYXRlPHR5cGVuYW1lIExlZnQs IHR5cGVuYW1lIFJpZ2h0PgorY2xhc3MgRmFzdEJpdFZlY3Rvck9yV29yZHMgeworcHVibGljOgor ICAgIHR5cGVkZWYgRmFzdEJpdFZlY3Rvck9yV29yZHMgVmlld1R5cGU7CisgICAgCisgICAgRmFz dEJpdFZlY3Rvck9yV29yZHMoY29uc3QgTGVmdCYgbGVmdCwgY29uc3QgUmlnaHQmIHJpZ2h0KQor ICAgICAgICA6IG1fbGVmdChsZWZ0KQorICAgICAgICAsIG1fcmlnaHQocmlnaHQpCiAgICAgewot ICAgICAgICBBU1NFUlQobV9udW1CaXRzID09IG90aGVyLm1fbnVtQml0cyk7Ci0gICAgICAgIGZv ciAodW5zaWduZWQgaSA9IGFycmF5TGVuZ3RoKCk7IGktLTspCi0gICAgICAgICAgICBtX2FycmF5 W2ldIHw9IG90aGVyLm1fYXJyYXlbaV07CisgICAgICAgIEFTU0VSVF9XSVRIX1NFQ1VSSVRZX0lN UExJQ0FUSU9OKG1fbGVmdC5udW1CaXRzKCkgPT0gbV9yaWdodC5udW1CaXRzKCkpOwogICAgIH0K ICAgICAKLSAgICB2b2lkIGZpbHRlcihjb25zdCBGYXN0Qml0VmVjdG9yJiBvdGhlcikKKyAgICBG YXN0Qml0VmVjdG9yT3JXb3JkcyB2aWV3KCkgY29uc3QgeyByZXR1cm4gKnRoaXM7IH0KKyAgICAK KyAgICBzaXplX3QgbnVtQml0cygpIGNvbnN0CiAgICAgewotICAgICAgICBBU1NFUlQobV9udW1C aXRzID09IG90aGVyLm1fbnVtQml0cyk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IGFycmF5 TGVuZ3RoKCk7IGktLTspCi0gICAgICAgICAgICBtX2FycmF5W2ldICY9IG90aGVyLm1fYXJyYXlb aV07CisgICAgICAgIHJldHVybiBtX2xlZnQubnVtQml0cygpOwogICAgIH0KICAgICAKLSAgICB2 b2lkIGV4Y2x1ZGUoY29uc3QgRmFzdEJpdFZlY3RvciYgb3RoZXIpCisgICAgdWludDMyX3Qgd29y ZChzaXplX3QgaW5kZXgpIGNvbnN0CiAgICAgewotICAgICAgICBBU1NFUlQobV9udW1CaXRzID09 IG90aGVyLm1fbnVtQml0cyk7Ci0gICAgICAgIGZvciAodW5zaWduZWQgaSA9IGFycmF5TGVuZ3Ro KCk7IGktLTspCi0gICAgICAgICAgICBtX2FycmF5W2ldICY9IH5vdGhlci5tX2FycmF5W2ldOwor ICAgICAgICByZXR1cm4gbV9sZWZ0LndvcmQoaW5kZXgpIHwgbV9yaWdodC53b3JkKGluZGV4KTsK ICAgICB9CiAgICAgCi0gICAgdm9pZCBzZXQoc2l6ZV90IGkpCitwcml2YXRlOgorICAgIExlZnQg bV9sZWZ0OworICAgIFJpZ2h0IG1fcmlnaHQ7Cit9OworICAgIAordGVtcGxhdGU8dHlwZW5hbWUg Vmlldz4KK2NsYXNzIEZhc3RCaXRWZWN0b3JOb3RXb3JkcyB7CitwdWJsaWM6CisgICAgdHlwZWRl ZiBGYXN0Qml0VmVjdG9yTm90V29yZHMgVmlld1R5cGU7CisgICAgCisgICAgRmFzdEJpdFZlY3Rv ck5vdFdvcmRzKGNvbnN0IFZpZXcmIHZpZXcpCisgICAgICAgIDogbV92aWV3KHZpZXcpCiAgICAg ewotICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihpIDwgbV9udW1CaXRz KTsKLSAgICAgICAgbV9hcnJheVtpID4+IDVdIHw9ICgxIDw8IChpICYgMzEpKTsKICAgICB9CiAg ICAgCi0gICAgdm9pZCBjbGVhcihzaXplX3QgaSkKKyAgICBGYXN0Qml0VmVjdG9yTm90V29yZHMg dmlldygpIGNvbnN0IHsgcmV0dXJuICp0aGlzOyB9CisgICAgCisgICAgc2l6ZV90IG51bUJpdHMo KSBjb25zdAogICAgIHsKLSAgICAgICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04o aSA8IG1fbnVtQml0cyk7Ci0gICAgICAgIG1fYXJyYXlbaSA+PiA1XSAmPSB+KDEgPDwgKGkgJiAz MSkpOworICAgICAgICByZXR1cm4gbV92aWV3Lm51bUJpdHMoKTsKICAgICB9CiAgICAgCi0gICAg dm9pZCBzZXQoc2l6ZV90IGksIGJvb2wgdmFsdWUpCisgICAgdWludDMyX3Qgd29yZChzaXplX3Qg aW5kZXgpIGNvbnN0CiAgICAgewotICAgICAgICBpZiAodmFsdWUpCi0gICAgICAgICAgICBzZXQo aSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgIGNsZWFyKGkpOworICAgICAgICByZXR1cm4g IW1fdmlldy53b3JkKGluZGV4KTsKKyAgICB9CisgICAgCitwcml2YXRlOgorICAgIFZpZXcgbV92 aWV3OworfTsKKyAgICAKK2NsYXNzIEZhc3RCaXRWZWN0b3I7CisKK3RlbXBsYXRlPHR5cGVuYW1l IFdvcmRzPgorY2xhc3MgRmFzdEJpdFZlY3RvckltcGwgeworcHVibGljOgorICAgIEZhc3RCaXRW ZWN0b3JJbXBsKCkKKyAgICAgICAgOiBtX3dvcmRzKCkKKyAgICB7CisgICAgfQorICAgIAorICAg IEZhc3RCaXRWZWN0b3JJbXBsKGNvbnN0IFdvcmRzJiB3b3JkcykKKyAgICAgICAgOiBtX3dvcmRz KHdvcmRzKQorICAgIHsKKyAgICB9CisgICAgCisgICAgRmFzdEJpdFZlY3RvckltcGwoV29yZHMm JiB3b3JkcykKKyAgICAgICAgOiBtX3dvcmRzKFdURk1vdmUod29yZHMpKQorICAgIHsKKyAgICB9 CisKKyAgICBzaXplX3QgbnVtQml0cygpIGNvbnN0IHsgcmV0dXJuIG1fd29yZHMubnVtQml0cygp OyB9CisgICAgc2l6ZV90IHNpemUoKSBjb25zdCB7IHJldHVybiBudW1CaXRzKCk7IH0KKyAgICAK KyAgICBzaXplX3QgYXJyYXlMZW5ndGgoKSBjb25zdCB7IHJldHVybiBmYXN0Qml0VmVjdG9yQXJy YXlMZW5ndGgobnVtQml0cygpKTsgfQorICAgIAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIE90aGVy PgorICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBPdGhlciYgb3RoZXIpIGNvbnN0CisgICAgewor ICAgICAgICBpZiAobnVtQml0cygpICE9IG90aGVyLm51bUJpdHMoKSkKKyAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IGFycmF5TGVuZ3RoKCk7IGktLTsp IHsKKyAgICAgICAgICAgIGlmIChtX3dvcmRzLndvcmQoaSkgIT0gb3RoZXIubV93b3Jkcy53b3Jk KGkpKQorICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfQorICAgICAgICBy ZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgT3RoZXI+Cisg ICAgYm9vbCBvcGVyYXRvciE9KGNvbnN0IE90aGVyJiBvdGhlcikgY29uc3QKKyAgICB7CisgICAg ICAgIHJldHVybiAhKCp0aGlzID09IG90aGVyKTsKKyAgICB9CisgICAgCisgICAgYm9vbCBhdChz aXplX3QgaW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gYXRJbXBsKGluZGV4KTsK ICAgICB9CiAgICAgCi0gICAgYm9vbCBnZXQoc2l6ZV90IGkpIGNvbnN0CisgICAgYm9vbCBvcGVy YXRvcltdKHNpemVfdCBpbmRleCkgY29uc3QKICAgICB7Ci0gICAgICAgIEFTU0VSVF9XSVRIX1NF Q1VSSVRZX0lNUExJQ0FUSU9OKGkgPCBtX251bUJpdHMpOwotICAgICAgICByZXR1cm4gISEobV9h cnJheVtpID4+IDVdICYgKDEgPDwgKGkgJiAzMSkpKTsKKyAgICAgICAgcmV0dXJuIGF0SW1wbChp bmRleCk7CiAgICAgfQogICAgIAogICAgIHNpemVfdCBiaXRDb3VudCgpIGNvbnN0CiAgICAgewog ICAgICAgICBzaXplX3QgcmVzdWx0ID0gMDsKLSAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gYXJy YXlMZW5ndGgoKTsgaS0tOykKLSAgICAgICAgICAgIHJlc3VsdCArPSBXVEY6OmJpdENvdW50KG1f YXJyYXlbaV0pOworICAgICAgICBmb3IgKHNpemVfdCBpbmRleCA9IGFycmF5TGVuZ3RoKCk7IGlu ZGV4LS07KQorICAgICAgICAgICAgcmVzdWx0ICs9IFdURjo6Yml0Q291bnQobV93b3Jkcy53b3Jk KGluZGV4KSk7CiAgICAgICAgIHJldHVybiByZXN1bHQ7CiAgICAgfQogICAgIAotICAgIHRlbXBs YXRlPHR5cGVuYW1lIEZ1bmN0b3I+Ci0gICAgdm9pZCBmb3JFYWNoU2V0Qml0KGNvbnN0IEZ1bmN0 b3ImIGZ1bmN0b3IpIGNvbnN0CisgICAgdGVtcGxhdGU8dHlwZW5hbWUgT3RoZXJXb3Jkcz4KKyAg ICBGYXN0Qml0VmVjdG9ySW1wbDxGYXN0Qml0VmVjdG9yQW5kV29yZHM8dHlwZW5hbWUgV29yZHM6 OlZpZXdUeXBlLCB0eXBlbmFtZSBPdGhlcldvcmRzOjpWaWV3VHlwZT4+IG9wZXJhdG9yJihjb25z dCBGYXN0Qml0VmVjdG9ySW1wbDxPdGhlcldvcmRzPiYgb3RoZXIpIGNvbnN0CisgICAgeworICAg ICAgICByZXR1cm4gRmFzdEJpdFZlY3RvckltcGw8RmFzdEJpdFZlY3RvckFuZFdvcmRzPHR5cGVu YW1lIFdvcmRzOjpWaWV3VHlwZSwgdHlwZW5hbWUgT3RoZXJXb3Jkczo6Vmlld1R5cGU+PihGYXN0 Qml0VmVjdG9yQW5kV29yZHM8dHlwZW5hbWUgV29yZHM6OlZpZXdUeXBlLCB0eXBlbmFtZSBPdGhl cldvcmRzOjpWaWV3VHlwZT4obV93b3Jkcy52aWV3KCksIG90aGVyLm1fd29yZHMudmlldygpKSk7 CisgICAgfQorICAgIAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIE90aGVyV29yZHM+CisgICAgRmFz dEJpdFZlY3RvckltcGw8RmFzdEJpdFZlY3Rvck9yV29yZHM8dHlwZW5hbWUgV29yZHM6OlZpZXdU eXBlLCB0eXBlbmFtZSBPdGhlcldvcmRzOjpWaWV3VHlwZT4+IG9wZXJhdG9yfChjb25zdCBGYXN0 Qml0VmVjdG9ySW1wbDxPdGhlcldvcmRzPiYgb3RoZXIpIGNvbnN0CisgICAgeworICAgICAgICBy ZXR1cm4gRmFzdEJpdFZlY3RvckltcGw8RmFzdEJpdFZlY3Rvck9yV29yZHM8dHlwZW5hbWUgV29y ZHM6OlZpZXdUeXBlLCB0eXBlbmFtZSBPdGhlcldvcmRzOjpWaWV3VHlwZT4+KEZhc3RCaXRWZWN0 b3JPcldvcmRzPHR5cGVuYW1lIFdvcmRzOjpWaWV3VHlwZSwgdHlwZW5hbWUgT3RoZXJXb3Jkczo6 Vmlld1R5cGU+KG1fd29yZHMudmlldygpLCBvdGhlci5tX3dvcmRzLnZpZXcoKSkpOworICAgIH0K KyAgICAKKyAgICBGYXN0Qml0VmVjdG9ySW1wbDxGYXN0Qml0VmVjdG9yTm90V29yZHM8dHlwZW5h bWUgV29yZHM6OlZpZXdUeXBlPj4gb3BlcmF0b3J+KCkgY29uc3QKICAgICB7Ci0gICAgICAgIHVu c2lnbmVkIG4gPSBhcnJheUxlbmd0aCgpOwotICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBp IDwgbjsgKytpKSB7Ci0gICAgICAgICAgICB1aW50MzJfdCB3b3JkID0gbV9hcnJheVtpXTsKKyAg ICAgICAgcmV0dXJuIEZhc3RCaXRWZWN0b3JJbXBsPEZhc3RCaXRWZWN0b3JOb3RXb3Jkczx0eXBl bmFtZSBXb3Jkczo6Vmlld1R5cGU+PihGYXN0Qml0VmVjdG9yTm90V29yZHM8dHlwZW5hbWUgV29y ZHM6OlZpZXdUeXBlPihtX3dvcmRzLnZpZXcoKSkpOworICAgIH0KKyAgICAKKyAgICB0ZW1wbGF0 ZTx0eXBlbmFtZSBGdW5jPgorICAgIEFMV0FZU19JTkxJTkUgdm9pZCBmb3JFYWNoU2V0Qml0KGNv bnN0IEZ1bmMmIGZ1bmMpIGNvbnN0CisgICAgeworICAgICAgICBzaXplX3QgbiA9IG1fd29yZHMu YXJyYXlMZW5ndGgoKTsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBuOyArK2kpIHsK KyAgICAgICAgICAgIHVpbnQzMl90IHdvcmQgPSBtX3dvcmRzLndvcmQoaSk7CiAgICAgICAgICAg ICB1bnNpZ25lZCBqID0gaSA8PCA1OwogICAgICAgICAgICAgd2hpbGUgKHdvcmQpIHsKICAgICAg ICAgICAgICAgICBpZiAod29yZCAmIDEpCi0gICAgICAgICAgICAgICAgICAgIGZ1bmN0b3Ioaik7 CisgICAgICAgICAgICAgICAgICAgIGZ1bmMoaik7CiAgICAgICAgICAgICAgICAgd29yZCA+Pj0g MTsKICAgICAgICAgICAgICAgICBqKys7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICB9 Ci0KLSAgICBXVEZfRVhQT1JUX1BSSVZBVEUgdm9pZCBkdW1wKFByaW50U3RyZWFtJikgY29uc3Q7 CisgICAgCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgRnVuYz4KKyAgICBBTFdBWVNfSU5MSU5FIHZv aWQgZm9yRWFjaENsZWFyQml0KGNvbnN0IEZ1bmMmIGZ1bmMpIGNvbnN0CisgICAgeworICAgICAg ICAvLyBJJ20gcHJldHR5IHN1cmUgdGhhdCB0aGlzIGlzIHRoZSBtb3N0IGVmZmljaWVudCB3YXkg dG8gZG8gdGhpcy4KKyAgICAgICAgKH4qdGhpcykuZm9yRWFjaFNldEJpdChmdW5jKTsKKyAgICB9 CisgICAgCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgRnVuYz4KKyAgICB2b2lkIGZvckVhY2hCaXQo Ym9vbCB2YWx1ZSwgY29uc3QgRnVuYyYgZnVuYykgY29uc3QKKyAgICB7CisgICAgICAgIGlmICh2 YWx1ZSkKKyAgICAgICAgICAgIGZvckVhY2hTZXRCaXQoZnVuYyk7CisgICAgICAgIGVsc2UKKyAg ICAgICAgICAgIGZvckVhY2hDbGVhckJpdChmdW5jKTsKKyAgICB9CisgICAgCisgICAgLy8gU3Rh cnRzIGxvb2tpbmcgZm9yIGJpdHMgYXQgdGhlIGluZGV4IHlvdSBwYXNzLiBJZiB0aGF0IGluZGV4 IGNvbnRhaW5zIHRoZSB2YWx1ZSB5b3Ugd2FudCwKKyAgICAvLyB0aGVuIGl0IHdpbGwgcmV0dXJu IHRoYXQgaW5kZXguIFJldHVybnMgbnVtQml0cyB3aGVuIHdlIGdldCB0byB0aGUgZW5kLiBGb3Ig ZXhhbXBsZSwgeW91CisgICAgLy8gY2FuIHdyaXRlIGEgbG9vcCB0byBpdGVyYXRlIG92ZXIgYWxs IHNldCBiaXRzIGxpa2UgdGhpczoKKyAgICAvLworICAgIC8vIGZvciAoc2l6ZV90IGkgPSAwOyBp IDwgYml0cy5udW1CaXRzKCk7IGkgPSBiaXRzLmZpbmRCaXQoaSArIDEsIHRydWUpKQorICAgIC8v ICAgICAuLi4KKyAgICBBTFdBWVNfSU5MSU5FIHNpemVfdCBmaW5kQml0KHNpemVfdCBzdGFydElu ZGV4LCBib29sIHZhbHVlKSBjb25zdAorICAgIHsKKyAgICAgICAgdWludDMyX3Qgc2tpcFZhbHVl ID0gLShzdGF0aWNfY2FzdDx1aW50MzJfdD4odmFsdWUpIF4gMSk7CisgICAgICAgIHNpemVfdCBu dW1Xb3JkcyA9IG1fd29yZHMuYXJyYXlMZW5ndGgoKTsKKyAgICAgICAgCisgICAgICAgIHNpemVf dCB3b3JkSW5kZXggPSBzdGFydEluZGV4ID4+IDU7CisgICAgICAgIHNpemVfdCBzdGFydEluZGV4 SW5Xb3JkID0gc3RhcnRJbmRleCAtICh3b3JkSW5kZXggPDwgNSk7CisgICAgICAgIAorICAgICAg ICB3aGlsZSAod29yZEluZGV4IDwgbnVtV29yZHMpIHsKKyAgICAgICAgICAgIHVpbnQzMl90IHdv cmQgPSBtX3dvcmRzLndvcmQod29yZEluZGV4KTsKKyAgICAgICAgICAgIGlmICh3b3JkICE9IHNr aXBWYWx1ZSkgeworICAgICAgICAgICAgICAgIHNpemVfdCBpbmRleCA9IHN0YXJ0SW5kZXhJbldv cmQ7CisgICAgICAgICAgICAgICAgaWYgKGZpbmRCaXRJbldvcmQod29yZCwgaW5kZXgsIDMyLCB2 YWx1ZSkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiB3b3JkSW5kZXggKiAzMiArIGluZGV4 OworICAgICAgICAgICAgfQorICAgICAgICAgICAgCisgICAgICAgICAgICB3b3JkSW5kZXgrKzsK KyAgICAgICAgICAgIHN0YXJ0SW5kZXhJbldvcmQgPSAwOworICAgICAgICB9CisgICAgICAgIAor ICAgICAgICByZXR1cm4gbnVtQml0cygpOworICAgIH0KKyAgICAKKyAgICBBTFdBWVNfSU5MSU5F IHNpemVfdCBmaW5kU2V0Qml0KHNpemVfdCBpbmRleCkgY29uc3QKKyAgICB7CisgICAgICAgIHJl dHVybiBmaW5kQml0KGluZGV4LCB0cnVlKTsKKyAgICB9CisgICAgCisgICAgQUxXQVlTX0lOTElO RSBzaXplX3QgZmluZENsZWFyQml0KHNpemVfdCBpbmRleCkgY29uc3QKKyAgICB7CisgICAgICAg IHJldHVybiBmaW5kQml0KGluZGV4LCBmYWxzZSk7CisgICAgfQorICAgIAorICAgIHZvaWQgZHVt cChQcmludFN0cmVhbSYgb3V0KSBjb25zdAorICAgIHsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9 IDA7IGkgPCBudW1CaXRzKCk7ICsraSkKKyAgICAgICAgICAgIG91dC5wcmludCgoKnRoaXMpW2ld ID8gIjEiIDogIi0iKTsKKyAgICB9CiAgICAgCiBwcml2YXRlOgotICAgIHN0YXRpYyBzaXplX3Qg YXJyYXlMZW5ndGgoc2l6ZV90IG51bUJpdHMpIHsgcmV0dXJuIChudW1CaXRzICsgMzEpID4+IDU7 IH0KLSAgICBzaXplX3QgYXJyYXlMZW5ndGgoKSBjb25zdCB7IHJldHVybiBhcnJheUxlbmd0aCht X251bUJpdHMpOyB9CisgICAgLy8gWW91J2QgdGhpbmsgdGhhdCB3ZSBjb3VsZCByZW1vdmUgdGhp cyBmcmllbmQgaWYgd2UgdXNlZCBwcm90ZWN0ZWQsIGJ1dCB5b3UnZCBiZSB3cm9uZywKKyAgICAv LyBiZWNhdXNlIHRlbXBsYXRlcy4KKyAgICBmcmllbmQgY2xhc3MgRmFzdEJpdFZlY3RvcjsKICAg ICAKLSAgICB1aW50MzJfdCogbV9hcnJheSB7IG51bGxwdHIgfTsgLy8gTm8sIHRoaXMgY2FuJ3Qg YmUgYW4gc3RkOjp1bmlxdWVfcHRyPHVpbnQzMl90W10+LgotICAgIHNpemVfdCBtX251bUJpdHMg eyAwIH07CisgICAgYm9vbCBhdEltcGwoc2l6ZV90IGluZGV4KSBjb25zdAorICAgIHsKKyAgICAg ICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04oaW5kZXggPCBudW1CaXRzKCkpOwor ICAgICAgICByZXR1cm4gISEobV93b3Jkcy53b3JkKGluZGV4ID4+IDUpICYgKDEgPDwgKGluZGV4 ICYgMzEpKSk7CisgICAgfQorICAgIAorICAgIFdvcmRzIG1fd29yZHM7Cit9OworCitjbGFzcyBG YXN0Qml0VmVjdG9yIDogcHVibGljIEZhc3RCaXRWZWN0b3JJbXBsPEZhc3RCaXRWZWN0b3JXb3Jk T3duZXI+IHsKK3B1YmxpYzoKKyAgICBGYXN0Qml0VmVjdG9yKCkgeyB9CisgICAgCisgICAgRmFz dEJpdFZlY3Rvcihjb25zdCBGYXN0Qml0VmVjdG9yJikgPSBkZWZhdWx0OworICAgIEZhc3RCaXRW ZWN0b3ImIG9wZXJhdG9yPShjb25zdCBGYXN0Qml0VmVjdG9yJikgPSBkZWZhdWx0OworICAgIAor ICAgIHRlbXBsYXRlPHR5cGVuYW1lIE90aGVyV29yZHM+CisgICAgRmFzdEJpdFZlY3Rvcihjb25z dCBGYXN0Qml0VmVjdG9ySW1wbDxPdGhlcldvcmRzPiYgb3RoZXIpCisgICAgeworICAgICAgICAq dGhpcyA9IG90aGVyOworICAgIH0KKyAgICAKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBPdGhlcldv cmRzPgorICAgIEZhc3RCaXRWZWN0b3ImIG9wZXJhdG9yPShjb25zdCBGYXN0Qml0VmVjdG9ySW1w bDxPdGhlcldvcmRzPiYgb3RoZXIpCisgICAgeworICAgICAgICBpZiAoVU5MSUtFTFkobnVtQml0 cygpICE9IG90aGVyLm51bUJpdHMoKSkpCisgICAgICAgICAgICByZXNpemUob3RoZXIubnVtQml0 cygpKTsKKyAgICAgICAgCisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IGFycmF5TGVuZ3RoKCk7 IGktLTspCisgICAgICAgICAgICBtX3dvcmRzLndvcmQoaSkgPSBvdGhlci5tX3dvcmRzLndvcmQo aSk7CisgICAgICAgIHJldHVybiAqdGhpczsKKyAgICB9CisgICAgCisgICAgdm9pZCByZXNpemUo c2l6ZV90IG51bUJpdHMpCisgICAgeworICAgICAgICBtX3dvcmRzLnJlc2l6ZShudW1CaXRzKTsK KyAgICB9CisgICAgCisgICAgdm9pZCBzZXRBbGwoKQorICAgIHsKKyAgICAgICAgbV93b3Jkcy5z ZXRBbGwoKTsKKyAgICB9CisgICAgCisgICAgdm9pZCBjbGVhckFsbCgpCisgICAgeworICAgICAg ICBtX3dvcmRzLmNsZWFyQWxsKCk7CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgT3Ro ZXJXb3Jkcz4KKyAgICBib29sIHNldEFuZENoZWNrKGNvbnN0IEZhc3RCaXRWZWN0b3JJbXBsPE90 aGVyV29yZHM+JiBvdGhlcikKKyAgICB7CisgICAgICAgIGJvb2wgY2hhbmdlZCA9IGZhbHNlOwor ICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihudW1CaXRzKCkgPT0gb3Ro ZXIubnVtQml0cygpKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gYXJyYXlMZW5ndGgoKTsg aS0tOykgeworICAgICAgICAgICAgY2hhbmdlZCB8PSBtX3dvcmRzLndvcmQoaSkgIT0gb3RoZXIu bV93b3Jkcy53b3JkKGkpOworICAgICAgICAgICAgbV93b3Jkcy53b3JkKGkpID0gb3RoZXIubV93 b3Jkcy53b3JkKGkpOworICAgICAgICB9CisgICAgICAgIHJldHVybiBjaGFuZ2VkOworICAgIH0K KyAgICAKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBPdGhlcldvcmRzPgorICAgIEZhc3RCaXRWZWN0 b3ImIG9wZXJhdG9yfD0oY29uc3QgRmFzdEJpdFZlY3RvckltcGw8T3RoZXJXb3Jkcz4mIG90aGVy KQorICAgIHsKKyAgICAgICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04obnVtQml0 cygpID09IG90aGVyLm51bUJpdHMoKSk7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IGFycmF5 TGVuZ3RoKCk7IGktLTspCisgICAgICAgICAgICBtX3dvcmRzLndvcmQoaSkgfD0gb3RoZXIubV93 b3Jkcy53b3JkKGkpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorICAgIAorICAgIHRl bXBsYXRlPHR5cGVuYW1lIE90aGVyV29yZHM+CisgICAgRmFzdEJpdFZlY3RvciYgb3BlcmF0b3Im PShjb25zdCBGYXN0Qml0VmVjdG9ySW1wbDxPdGhlcldvcmRzPiYgb3RoZXIpCisgICAgeworICAg ICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihudW1CaXRzKCkgPT0gb3RoZXIu bnVtQml0cygpKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gYXJyYXlMZW5ndGgoKTsgaS0t OykKKyAgICAgICAgICAgIG1fd29yZHMud29yZChpKSAmPSBvdGhlci5tX3dvcmRzLndvcmQoaSk7 CisgICAgICAgIHJldHVybiAqdGhpczsKKyAgICB9CisgICAgCisgICAgYm9vbCBhdChzaXplX3Qg aW5kZXgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gYXRJbXBsKGluZGV4KTsKKyAgICB9 CisgICAgCisgICAgYm9vbCBvcGVyYXRvcltdKHNpemVfdCBpbmRleCkgY29uc3QKKyAgICB7Cisg ICAgICAgIHJldHVybiBhdEltcGwoaW5kZXgpOworICAgIH0KKyAgICAKKyAgICBjbGFzcyBCaXRS ZWZlcmVuY2UgeworICAgIHB1YmxpYzoKKyAgICAgICAgQml0UmVmZXJlbmNlKCkgeyB9CisgICAg ICAgIAorICAgICAgICBCaXRSZWZlcmVuY2UodWludDMyX3QqIHdvcmQsIHVpbnQzMl90IG1hc2sp CisgICAgICAgICAgICA6IG1fd29yZCh3b3JkKQorICAgICAgICAgICAgLCBtX21hc2sobWFzaykK KyAgICAgICAgeworICAgICAgICB9CisgICAgICAgIAorICAgICAgICBleHBsaWNpdCBvcGVyYXRv ciBib29sKCkgY29uc3QKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuICEhKCptX3dvcmQg JiBtX21hc2spOworICAgICAgICB9CisgICAgICAgIAorICAgICAgICBCaXRSZWZlcmVuY2UmIG9w ZXJhdG9yPShib29sIHZhbHVlKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAodmFsdWUpCisg ICAgICAgICAgICAgICAgKm1fd29yZCB8PSBtX21hc2s7CisgICAgICAgICAgICBlbHNlCisgICAg ICAgICAgICAgICAgKm1fd29yZCAmPSB+bV9tYXNrOworICAgICAgICAgICAgcmV0dXJuICp0aGlz OworICAgICAgICB9CisgICAgICAgIAorICAgIHByaXZhdGU6CisgICAgICAgIHVpbnQzMl90KiBt X3dvcmQgeyBudWxscHRyIH07CisgICAgICAgIHVpbnQzMl90IG1fbWFzayB7IDAgfTsKKyAgICB9 OworICAgIAorICAgIEJpdFJlZmVyZW5jZSBhdChzaXplX3QgaW5kZXgpCisgICAgeworICAgICAg ICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihpbmRleCA8IG51bUJpdHMoKSk7Cisg ICAgICAgIHJldHVybiBCaXRSZWZlcmVuY2UoJm1fd29yZHMud29yZChpbmRleCA+PiA1KSwgMSA8 PCAoaW5kZXggJiAzMSkpOworICAgIH0KKyAgICAKKyAgICBCaXRSZWZlcmVuY2Ugb3BlcmF0b3Jb XShzaXplX3QgaW5kZXgpCisgICAgeworICAgICAgICByZXR1cm4gYXQoaW5kZXgpOworICAgIH0K IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdURgpJbmRleDogU291cmNlL1dURi93dGYvU3RkTGliRXh0 cmFzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvU3RkTGliRXh0cmFzLmgJKHJldmlz aW9uIDIwNTc5MCkKKysrIFNvdXJjZS9XVEYvd3RmL1N0ZExpYkV4dHJhcy5oCSh3b3JraW5nIGNv cHkpCkBAIC0zMTcsNiArMzE3LDIyIEBAIGJvb2wgY2hlY2tBbmRTZXQoVCYgbGVmdCwgVSByaWdo dCkKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2Jvb2wgZmlu ZEJpdEluV29yZChUIHdvcmQsIHNpemVfdCYgaW5kZXgsIHNpemVfdCBlbmRJbmRleCwgYm9vbCB2 YWx1ZSkKK3sKKyAgICB3b3JkID4+PSBpbmRleDsKKyAgICAKKyAgICB3aGlsZSAoaW5kZXggPCBl bmRJbmRleCkgeworICAgICAgICBpZiAoKHdvcmQgJiAxKSA9PSBzdGF0aWNfY2FzdDxUPih2YWx1 ZSkpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgaW5kZXgrKzsKKyAgICAgICAg d29yZCA+Pj0gMTsKKyAgICB9CisgICAgCisgICAgaW5kZXggPSBlbmRJbmRleDsKKyAgICByZXR1 cm4gZmFsc2U7Cit9CisKIC8vIFZpc2l0b3IgYWRhcHRlZCBmcm9tIGh0dHA6Ly9zdGFja292ZXJm bG93LmNvbS9xdWVzdGlvbnMvMjUzMzg3OTUvaXMtdGhlcmUtYS1uYW1lLWZvci10aGlzLXR1cGxl LWNyZWF0aW9uLWlkaW9tCiAKIHRlbXBsYXRlIDxjbGFzcyBBLCBjbGFzcy4uLiBCPgpAQCAtNDIx LDYgKzQzNyw3IEBAIHVzaW5nIFdURjo6YmluYXJ5U2VhcmNoOwogdXNpbmcgV1RGOjpiaXR3aXNl X2Nhc3Q7CiB1c2luZyBXVEY6OmNhbGxTdGF0ZWxlc3NMYW1iZGE7CiB1c2luZyBXVEY6OmNoZWNr QW5kU2V0OwordXNpbmcgV1RGOjpmaW5kQml0SW5Xb3JkOwogdXNpbmcgV1RGOjppbnNlcnRJbnRv Qm91bmRlZFZlY3RvcjsKIHVzaW5nIFdURjo6aXNDb21waWxhdGlvblRocmVhZDsKIHVzaW5nIFdU Rjo6aXNQb2ludGVyQWxpZ25lZDsK