48031 2010-10-20 17:02:07 -0700 Make AffineTransform and TransformationMatrix do matrix multiplication in the correct order (Column Major) 2011-02-15 18:04:18 -0800 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 48026 48215 52551 0 shanestephens shanestephens cmarrin commit-queue eric fujisawa.jun krit oliver simon.fraser webkit.review.bot zimmermann oldest_to_newest 297148 0 shanestephens 2010-10-20 17:02:07 -0700 The result of a matrix multiplication is dependent on the order of the operands. if I have the following code: AffineTransform a = ... AffineTransform b = ... AffineTransform c = a * b; currently c is given the value of b * a, not a * b. Looking through the code, we see: // result = *this * t (i.e. a multRight) AffineTransform operator*(const AffineTransform& t) const { AffineTransform result = t; result.multLeft(*this); return result; } multLeft is a post-multiply - i.e. result.multLeft(*this) assigns result * this to result. This means that we return t * this, not this * t as expected. Note that this is fairly difficult to fix as a lot of code uses the incorrect definition, with reversed arguments to generate the correct behaviour. I'd also be interested in renaming the multLeft method to something less confusing (e.g. postMultiply) in order to reduce the chance of this happening again. 299866 1 shanestephens 2010-10-26 16:00:27 -0700 I'm preparing a patch for this but would like to wait for 48026 and 48215 to be committed first, to keep the switching of argument order consistent in all places where it is required. 300015 2 krit 2010-10-26 23:10:41 -0700 Hm, I'm a bit confused. You say that *operator is wrong. But you want to change the operand order there first to get correct results. But after these patches you want to fix AffineTransform (have not lookad at AffineTransform yet). Won't you break SVGText and SVGStyledTransformable again? 300022 3 shanestephens 2010-10-26 23:23:49 -0700 Yeah - I want to fix SVGText and SVGStyledTransformable first as they are definitely producing incorrect behaviour and have small, self-contained fixes. Once they are in and protected by layout tests, I want to fix AffineTransform operator* and switch operand order for ALL cases that use it (including the fixed versions in SVGText and SVGStyledTranformable). This is a relatively invasive change so I want to simplify it as much as possible; it's also a change that (hopefully) won't change any behaviour and is thus much less urgent than the SVGText and SVGStyledTransformable fixes. 300054 4 krit 2010-10-27 01:07:48 -0700 Sounds good! 322249 5 76578 shanestephens 2010-12-14 15:06:32 -0800 Created attachment 76578 Patch 322576 6 zimmermann 2010-12-15 05:27:29 -0800 Hi Shane, I didn't yet look into your patch in detail. Just noticed that on trunk LayoutTests/svg/W3C-SVG-1.1/animate-elem-24-t.svg is broken, which worked some weeks (months?) ago. Is it maybe caused by one of your patches? Thanks in advance, Niko 322629 7 76578 krit 2010-12-15 09:18:16 -0800 Comment on attachment 76578 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=76578&action=review > WebCore/platform/graphics/cg/PatternCG.cpp:57 > + AffineTransform patternTransform = userSpaceTransformation * m_patternSpaceTransformation; I'm unsure if multLeft could be faster, since it memcopy's the values for affine1 = affine2 IIRC. And might have some additional improvements. Can you check this please? It's some time ago that I looked at AffineTransform :-P 322817 8 shanestephens 2010-12-15 14:45:27 -0800 I looked at performance in some detail, as I didn't want to cause degradation. The story is basically this: The old multLeft didn't really multLeft, and is now called postMultiply - same implementation and same performance characteristics. The old operator* code: AffineTransform operator*(const AffineTransform& t) const { AffineTransform result = t; result.multLeft(*this); return result; } This contains two copies of AffineTransform - once when t is assigned to result, and once when result is returned by value. The old operator*= is implemented in terms of operator*, and multiply in terms of operator*=. Thus all of these operations cost at least 2 copies of AffineTransform plus the implementation of multLeft. The new multiply and operator*= implementations use postMultiply directly, and are thus cheaper by at least 2 copies of AffineTransform. The new operator* is implemented in the same way as the old operator*: AffineTransform result = *this; result *= t; return result; and incurs the same 2 copies, costing the same as the old operator*. Hence, by replacing the old use of multiply with operator* here, I'm not incurring any additional cost. Actually, by eliminating an assignment I'm reducing the cost by one AffineTransform copy. I think you're right that doing the following: AffineTransform patternTransform = userSpaceTransformation; patternTransform.multiply(m_patternSpaceTransformation); Would reduce the cost still further, so I'm going to roll that into this patch. 322821 9 shanestephens 2010-12-15 14:50:13 -0800 Niko, that test is passing for me locally - can you show me a buildbot server or something where it's failing so I can see what the failure mode is? 322911 10 shanestephens 2010-12-15 16:05:59 -0800 Actually my analysis is wrong, RVO means that 1 of these copies will not happen anyway, so I don't think we buy anything by this change. 323074 11 zimmermann 2010-12-16 01:12:38 -0800 (In reply to comment #9) > Niko, that test is passing for me locally - can you show me a buildbot server or something where it's failing so I can see what the failure mode is? The test will pass when running it with run-webkit-tests. That's because of the fact that the actual animations are _not_ executed. The test is sampled at it's initial state. Any test containing <animate>/... elements that doesn't use the "SVG animation snapshot API" (as the tests in svg/animations) will not actually execute the animation. So you have to manually open it. You'll notice that the "It's alive" text is flying in the wrong location. Can you confirm? 324230 12 shanestephens 2010-12-19 15:07:07 -0800 Yes, this test is failing locally and it's probably failing as a result of 48215. Unfortunately the bug I fixed in 48215 introduced another bug that's now evident in LayoutTests/svg/W3C-SVG-1.1/animate-elem-24-t.svg :( The messy details: SVGStyledTransformableElement instances have a TransformList and a supplementalTransform. While AnimateTransform elements update values in the TransformList, AnimateMotion elements update the supplementalTransform. Crucially, transform values provided in the transform attribute of an element also appear in the TransformList. The order in which these matrices are accumulated matters - for example, a rotate followed by a translate does not produce the same result as a translate followed by a rotate. The problem that I fixed in 48215 was caused by the AnimateMotion's transform being applied first, before anything in the TransformList; whereas the specification indicates that this transform should be applied after values in the transform attribute. Unfortunately, what I did was move the application of AnimateMotion to the end - i.e. after everything in the TransformList. From the animate-elem-24-t.svg test, it appears that this is also wrong. In fact, it's possible that the supplementalTransform needs to apply after some TransformList values but before others, in which case it might make sense to remove the supplementalTransform altogether and use the TransformList for AnimateMotion as well. I'll read the specification carefully and seek guidance on the svg-wg list if necessary to determine what's appropriate. This current bug, however, is unrelated in that it doesn't (or at least, shouldn't) change the behaviour of any of the code - it's simply about fixing the order of operands in matrix multiplication. So I'd like to propose filing the fact that animate-elem-24-t.svg fails as a separate bug. While we're at it, it seems like we should be modifying or copying any animation tests in this directory so that we have versions that actually work with run-webkit-tests. If this test was actually testing when I was working on 48215 I probably would have picked up the issue then. 326773 13 eric 2010-12-24 17:07:25 -0800 I'm entertained by this, since I believe we had * reversed for SVGMatrix for the longest time. We might still? 326871 14 zimmermann 2010-12-26 03:33:15 -0800 (In reply to comment #12) > Yes, this test is failing locally and it's probably failing as a result of 48215. Unfortunately the bug I fixed in 48215 introduced another bug that's now evident in LayoutTests/svg/W3C-SVG-1.1/animate-elem-24-t.svg :( Okay. > > The messy details: > > SVGStyledTransformableElement instances have a TransformList and a supplementalTransform. While AnimateTransform elements update values in the TransformList, AnimateMotion elements update the supplementalTransform. Crucially, transform values provided in the transform attribute of an element also appear in the TransformList. Yes, in my opinion the supplementalTransform stuff is a huge hack anyway, as it forces each element transformable element to store another AffineTransform object, even when not animated. It was a crude hack, when animation was implemented in the beginning, to get Acid3 going... > > The order in which these matrices are accumulated matters - for example, a rotate followed by a translate does not produce the same result as a translate followed by a rotate. > > The problem that I fixed in 48215 was caused by the AnimateMotion's transform being applied first, before anything in the TransformList; whereas the specification indicates that this transform should be applied after values in the transform attribute. Right. > > Unfortunately, what I did was move the application of AnimateMotion to the end - i.e. after everything in the TransformList. From the animate-elem-24-t.svg test, it appears that this is also wrong. In fact, it's possible that the supplementalTransform needs to apply after some TransformList values but before others, in which case it might make sense to remove the supplementalTransform altogether and use the TransformList for AnimateMotion as well. I'll read the specification carefully and seek guidance on the svg-wg list if necessary to determine what's appropriate. Great. I think you should investigate to use TransformList directly. When we have animVal support, this is the way to go anyways. (transformList.animVal needs to reflect any animation done by animateTransform and/or animateMotion). > > This current bug, however, is unrelated in that it doesn't (or at least, shouldn't) change the behaviour of any of the code - it's simply about fixing the order of operands in matrix multiplication. So I'd like to propose filing the fact that animate-elem-24-t.svg fails as a separate bug. Fine with me! I'll review this patch soon. > While we're at it, it seems like we should be modifying or copying any animation tests in this directory so that we have versions that actually work with run-webkit-tests. If this test was actually testing when I was working on 48215 I probably would have picked up the issue then. That would be great! You'd need to copy the tests from svg/W3C-SVG-1.1/animate* to svg/animations, and extend them to use the SVG Animation snapshot API. But it will take a huge amount of time to convert them all to use the DRT snapshot API, as you have to write JS code for each sampling point, checking the values, whether they are correct etc etc. If you want to work on that, it would be highly appreciated! Cheers, Niko 326872 15 zimmermann 2010-12-26 03:34:11 -0800 (In reply to comment #13) > I'm entertained by this, since I believe we had * reversed for SVGMatrix for the longest time. We might still? Indeed, SVGMatrix is working around the * reversal a long time :-) The SVGMatrix exposed API works as expected, but only as foo * bar, is rewritten as foo.postMultiply(bar) internally :-) Thanks to Shane, the root of the confusion is now fixed. 328406 16 76578 krit 2011-01-02 11:23:59 -0800 Comment on attachment 76578 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=76578&action=review The patch looks good in general, but I'd prefer to use multiply and postMultiply where ever possible. Another question, would it make sense to rename multiply with preMultiply corresponding to postMultiply? r- for the questions above and the wrong comment style. > WebCore/platform/graphics/transforms/AffineTransform.cpp:170 > +/** > + * Multiplies this AffineTransform by the provided AffineTransform - i.e. > + * this = this * other; > + */ Comments with // 328414 17 simon.fraser 2011-01-02 12:16:37 -0800 Bug 16062 gives some back story into the various matrix multiplication issues. But I'm not convinced that there is a bug here. > multLeft is a post-multiply - i.e. result.multLeft(*this) assigns result * this to result. This means that we return t * this, not this * t as expected. In my reading result.multLeft(*this) is result = *this * result. TransformationMatrix has the same code. If you fix AffineTransform, please fix that as well. BTW, if you're working on a bug, please assign it to yourself. 328752 18 shanestephens 2011-01-03 13:34:59 -0800 Dirk: both multiply and postMultiply do the same thing. The following all produce the same result: a *= b a.multiply(b) a.postMultiply(b) Furthermore, the same result can be obtained in a fresh AffineTransform using: a * b The reason I'm keener on using a *=b and a * b over multiply, postMultiply or a new preMultiply function is that I think there's significant potential for confusion of what postMultiply and preMultiply *mean*, and multiply could conceivably mean either one or the other. On the other hand, I think a * b is unambiguous and has a reasonably obvious meaning - there's only one correct answer, which is to multiply a on the left by b on the right. Similarly a *= b is well understood to be equivalent to a = a * b. Simon: For the clearest example of why this is a bug, look at the implementation of a * b. The result is currently b * a. Say that 'a' is a translation matrix (1, 0, 0, 1, 100, 10), and 'b' is a scale matrix (1.5, 0, 0, 1.2, 0, 0). [ 1 0 100] [1.5 0 0 ] [1.5 0 100] [ 0 1 10 ]x[ 0 1.2 0 ]=[ 0 1.2 10 ] [(0) (0) (1)] [(0) (0) (1)] [(0) (0) (1)] However AffineTransform's operand gives (1.5, 0, 0, 1.2, 150, 12), which is b * a. This is independent of 16062 - as you can see this notation already uses SVG's column vector orientation and does not arise because of translation to CG matrices. 328753 19 shanestephens 2011-01-03 13:35:48 -0800 I can't assign this bug to myself :( 328755 20 simon.fraser 2011-01-03 13:36:47 -0800 (In reply to comment #19) > I can't assign this bug to myself :( Ask for editbugs privs on webkit-dev. 328790 21 krit 2011-01-03 14:24:31 -0800 (In reply to comment #18) > Dirk: both multiply and postMultiply do the same thing. The following all produce the same result: > > a *= b > a.multiply(b) > a.postMultiply(b) > > Furthermore, the same result can be obtained in a fresh AffineTransform using: > > a * b > > The reason I'm keener on using a *=b and a * b over multiply, postMultiply or a new preMultiply function is that I think there's significant potential for confusion of what postMultiply and preMultiply *mean*, and multiply could conceivably mean either one or the other. > > On the other hand, I think a * b is unambiguous and has a reasonably obvious meaning - there's only one correct answer, which is to multiply a on the left by b on the right. Similarly a *= b is well understood to be equivalent to a = a * b. > > Simon: For the clearest example of why this is a bug, look at the implementation of a * b. The result is currently b * a. Say that 'a' is a translation matrix (1, 0, 0, 1, 100, 10), and 'b' is a scale matrix (1.5, 0, 0, 1.2, 0, 0). > > [ 1 0 100] [1.5 0 0 ] [1.5 0 100] > [ 0 1 10 ]x[ 0 1.2 0 ]=[ 0 1.2 10 ] > [(0) (0) (1)] [(0) (0) (1)] [(0) (0) (1)] > > However AffineTransform's operand gives (1.5, 0, 0, 1.2, 150, 12), which is b * a. This is independent of 16062 - as you can see this notation already uses SVG's column vector orientation and does not arise because of translation to CG matrices. Independent of what AffineTransfrom is doing right now, I don't want multiple function names for the same operation. To be honest a.multiply(b) already sounds like a = a * b; for me, why I would prefer multiply against postMultiply. And multLeft should do the opposite. 328792 22 shanestephens 2011-01-03 14:30:37 -0800 Yes, that seems fair. There's never actually been a multLeft / preMultiply - the function that was called multLeft was implemented incorrectly and actually did a multRight. I can add one if you want - it'll make some code paths slightly faster. If I do, I'd like to call it preMultiply, keep postMultiply, and remove multiply. Alternatively, if we don't want to add a preMultiply, I'd like to remove postMultiply altogether, and just have multiply, * and *=. In other words, I think we should either have multiply / * / *=, all of which do the same thing, or preMultiply / postMultiply / * / *=, with preMultiply doing the opposite of the rest. What do you think? 328815 23 cmarrin 2011-01-03 15:52:00 -0800 Simon and I discussed this issue just now. We've agreed for a while now (and the 3D CSS Transform spec says this) that we use "column-major" matrices throughout. That means you can look at an affine transform as: A C tx B D ty where (AB) forms a 2D vector which defines the X axis transformation, and (CD) defines the Y axis. That's column-major because the row index changes more quickly than the column index, as you extract the vectors (A is row 0, column 0, B is row 1, column 0). An identity matrix is: 1 0 0 0 1 0 The first column is a vector along the X axis and the second column is a vector along the Y axis. That would be the same if this were a row-major matrix, too, of course. But if you rotate the vectors by 45 degrees, you get an X vector at (0.707, 0.707) and a Y vector at (-0.707, 0.707). Plug those in and you get: 0.707 -0.707 0 0.707 0.707 0 If this were a row-major matrix the -0.707, would be in the lower left corner instead. Move these concepts to the 4x4 matrix and you get the translation values in the rightmost column, the X vector in the first column and so on. I think the most confusing thing in the implementation currently (except for misnaming multLeft) is that the attributes for the 4x4 matrix go column, row, rather than row, column. So tx is in m41. But I think this is the right labeling since the numbering goes MAJOR, minor. Column is the major index, so it goes first. One other thing we discussed is what it means to "multiply". What happens when you multiply: translate(0, 5) * rotate(45deg)? That is a translation matrix and to its right, a rotation matrix. If you start with the identity matrix and multiply that by the translation matrix (with the translation on the right), you get the translation matrix of course. But what is happening is that you are changing the local coordinate space by the translation value. So now, point (0,0,0) in the local coordinate space is actually (0,5,0) in the global coordinate space. Now when you rotate that you are rotating about (0,0,0) in the local coordinate space. If you start with a box at (0,0,0) you will end up with a box rotated 45 degrees whose center is at (0,5,0). So that's the definition of multRight. If we had done it in the opposite order (rotate and then translate) we would end up with a box still rotated 45 degrees, but whose center is (-3.54, 3.54, 0). That's because you first rotate the local coordinate space so that now the Y axis goes up and to the left, at a 45 degree angle. We translate along that axis and end up with a box out in the middle of quadrant 2. If you look at TransformationMatrix.cpp you'll see a function called multLeft(). But if you look at what it's multiplying it's actually a multRight. AffineMatrix also has a translateRight() function which is actually doing a multLeft! I like the fact that your patch gets rid of any multRight or multLeft functions and just has the one postMultiply, which is doing a multRight. I think we should also get rid of translateRight and change the call sites to use multiply() or operator*. In TransformationMatrix I think we should also get rid of the incorrectly named functions in a similar way. I hope this makes things more clear rather than less! I know I feel more clear on it. 332159 24 78494 shanestephens 2011-01-10 22:25:12 -0800 Created attachment 78494 Patch 332161 25 webkit.review.bot 2011-01-10 22:27:22 -0800 Attachment 78494 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 Source/WebCore/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] Source/WebCore/ChangeLog:9: Line contains tab character. [whitespace/tab] [5] Total errors found: 2 in 22 files If any of these errors are false positives, please file a bug against check-webkit-style. 332162 26 78495 shanestephens 2011-01-10 22:31:24 -0800 Created attachment 78495 Patch 332163 27 shanestephens 2011-01-10 22:31:49 -0800 This patch removes postMultiply from AffineTransform altogether and fixes the style issues commented on. I'd like to update AffineTransform's translateRight and fix the TransformationMatrix issues as two additional bugs - each is quite large and I've not yet completely gotten across the internals of TransformationMatrix. Accordingly, I think this patch is ready to go - it fixes the operand order issue in AffineTransform, makes sure that the arguments are switched appropriately in all the call sites, and ensures that the multiplication calls in AffineTransform are easier to understand. Let me know if this is OK, and I'll file separate bugs for translateRight and TransformationMatrix and start working on them :) 333610 28 78495 zimmermann 2011-01-13 02:49:48 -0800 Comment on attachment 78495 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=78495&action=review Looks good, though still some things to resolve IMHO. > Source/WebCore/platform/graphics/transforms/AffineTransform.h:149 > + return this->multiply(t); s/this->// it's not needed. > Source/WebCore/platform/graphics/transforms/AffineTransform.h:183 > + AffineTransform& postMultiply(const AffineTransform&); Where is postMultiply defined/used?? > Source/WebCore/rendering/svg/RenderSVGResourceContainer.cpp:18 > + * Looks unrelated. > Source/WebCore/rendering/svg/RenderSVGResourceGradient.cpp:21 > + * Ditto. > Source/WebCore/rendering/svg/RenderSVGResourcePattern.cpp:19 > + * Ditto. > Source/WebCore/rendering/svg/SVGImageBufferTools.cpp:46 > - absoluteTransform.multiply(current->localToParentTransform()); > + absoluteTransform = current->localToParentTransform() * absoluteTransform; This is a place, where your postMultiply method would be useful, no? absoluteTransform.postMultiply(current->localToParentTransform()). I think this would be easier to read/understand, as the current solution, and it's for sure faster, as it avoids the assignment operator usage, after the multiplication. > Source/WebCore/rendering/svg/SVGImageBufferTools.cpp:87 > - contentTransformation.multiply(subtreeContentTransformation); > + contentTransformation = subtreeContentTransformation * contentTransformation; > Ditto. > Source/WebCore/rendering/svg/SVGTextLayoutEngine.cpp:324 > - transform.multiply(textBoxTransformation); > + transform = textBoxTransformation * transform; Ditto. (Several more places which could make use of postMultiply, didn't mention all of them) 334010 29 78871 shanestephens 2011-01-13 16:17:27 -0800 Created attachment 78871 Patch 334030 30 shanestephens 2011-01-13 16:48:26 -0800 Just a note about postMultiply - the old function (multLeft) was in fact a postMultiply. I was going to rename it to that (and did in the first patch), but now I'm just renaming it to multiply instead. What that function (multLeft / postMultiply / multiply) does is the following: a.multiply(b) causes a to take on the value of a * b. There has never been an efficient function in AffineTransform to do a true multLeft (also called preMultiply) - i.e. a.preMultiply(b) taking a to b * a. The current (pre this patch) implementations of *, multiply, and *= all performed this, but quite inefficiently. This patch is actually all about removing the confusing state of affairs we currently have, where multLeft really does a multRight, and multiply, * and *= do a multLeft - the opposite of what you'd expect. To see what I mean by inefficiently, have a look at the pre-patch version of operator*: AffineTransform operator*(const AffineTransform& t) const { AffineTransform result = t; result.multLeft(*this); return result; } and operator*=: AffineTransform& operator*=(const AffineTransform& t) { *this = *this * t; return *this; } So to do a *=, we (1) calculate *this * t, which: (a) copies t into result (b) does a multLeft (which is really a postMultiply, remember) (c) returns the result (2) copy the result back into *this That's just a postMultiply with two copies! (I think - RVO doesn't apply here because the input and the output to operator* are the same object), which is exactly what happens with this: absoluteTransform = current->localToParentTransform() * absoluteTransform; This is actually potentially faster as there's one less function call :) It's also easier to read than what previously existed, because what previously existed was actually wrong (the inputs were switched around): absoluteTransform.multiply(current->localToParentTransform()); But note that if we were to try and write this more efficiently, we'd actually want a *preMultiply*, not a postMultiply - i.e. something like: absoluteTransform.preMultiply(current->localToParentTransform()); Now, I could implement one of these, and I'd be very happy to, either in this bug or as a new one (I'd prefer doing it in a separate bug as I think the current change stands on its own as clearing up an important confusion). But it's important to remember that: (1) what was called multLeft was misnamed and in fact should be called multRight, multiply or postMultiply. (2) operator*, operator*= and multiply all currently don't do what they advertise - they should do a multRight but they do a multLeft (3) there has *never* been a genuine, fast multLeft / preMultiply - operator*, operator*= and multiply provide this functionality but only by switching the arguments around and using multLeft's postMultiply functionality. So this patch is strictly an improvement. I've fixed the other problems that you noticed, thanks for having a look at the patch! 334188 31 zimmermann 2011-01-14 01:53:48 -0800 (In reply to comment #30) > Just a note about postMultiply - the old function (multLeft) was in fact a postMultiply. I was going to rename it to that (and did in the first patch), but now I'm just renaming it to multiply instead. What that function (multLeft / postMultiply / multiply) does is the following: > a.multiply(b) causes a to take on the value of a * b. > > There has never been an efficient function in AffineTransform to do a true multLeft (also called preMultiply) - i.e. a.preMultiply(b) taking a to b * a. The current (pre this patch) implementations of *, multiply, and *= all performed this, but quite inefficiently. > > This patch is actually all about removing the confusing state of affairs we currently have, where multLeft really does a multRight, and multiply, * and *= do a multLeft - the opposite of what you'd expect. > > To see what I mean by inefficiently, have a look at the pre-patch version of operator*: > AffineTransform operator*(const AffineTransform& t) const > { > AffineTransform result = t; > result.multLeft(*this); > return result; > } > > and operator*=: > AffineTransform& operator*=(const AffineTransform& t) > { > *this = *this * t; > return *this; > } > > > So to do a *=, we > (1) calculate *this * t, which: > (a) copies t into result > (b) does a multLeft (which is really a postMultiply, remember) > (c) returns the result > (2) copy the result back into *this > > That's just a postMultiply with two copies! (I think - RVO doesn't apply here because the input and the output to operator* are the same object), which is exactly what happens with this: > > absoluteTransform = current->localToParentTransform() * absoluteTransform; > > This is actually potentially faster as there's one less function call :) It's also easier to read than what previously existed, because what previously existed was actually wrong (the inputs were switched around): > > absoluteTransform.multiply(current->localToParentTransform()); > > But note that if we were to try and write this more efficiently, we'd actually want a *preMultiply*, not a postMultiply - i.e. something like: > > absoluteTransform.preMultiply(current->localToParentTransform()); > > Now, I could implement one of these, and I'd be very happy to, either in this bug or as a new one (I'd prefer doing it in a separate bug as I think the current change stands on its own as clearing up an important confusion). But it's important to remember that: > (1) what was called multLeft was misnamed and in fact should be called multRight, multiply or postMultiply. > (2) operator*, operator*= and multiply all currently don't do what they advertise - they should do a multRight but they do a multLeft > (3) there has *never* been a genuine, fast multLeft / preMultiply - operator*, operator*= and multiply provide this functionality but only by switching the arguments around and using multLeft's postMultiply functionality. > So this patch is strictly an improvement. > > I've fixed the other problems that you noticed, thanks for having a look at the patch! Okay, fair enough, I follow your argumentation. I'm only worried if we shouldn't just agree on a single way to do pre-multiplications / post-multiplications. eg. either a = a * b or a *= b a = b * a or a.preMultiply(b) (a = b * a) a.postMultiply(b) (a = a * b) Instead of having multiple choices... what do you think? 334191 32 krit 2011-01-14 01:56:37 -0800 > eg. either > a = a * b or a *= b > a = b * a > > or > a.preMultiply(b) (a = b * a) > a.postMultiply(b) (a = a * b) > > Instead of having multiple choices... what do you think? In my opinion we should use pre- and postMultiply in all places. But that's my opinion. 334644 33 cmarrin 2011-01-14 15:02:40 -0800 It would be much better now and in the future if we just did matrix multiplication in one direction. There should be a multiply function where a.multiply(b) is the same as a * b, operator* which does the obvious order and operator *= where a *= b is the same as a = a * b. It needs to be made clear somewhere that for matrix math a * b != b * a. But I think anyone using these functions will already know that. The problem we have had in the past has been with the confusion of row-major vs column-major, which changes the meaning of 'multLeft' and 'multRight'. The terms pre- and postMultiply don't help either. We should have one way to do things and give it the simplest name. If someone wants b * a, he can change the order when making the call. 334659 34 krit 2011-01-14 15:20:50 -0800 (In reply to comment #33) > It would be much better now and in the future if we just did matrix multiplication in one direction. There should be a multiply function where a.multiply(b) is the same as a * b, operator* which does the obvious order and operator *= where a *= b is the same as a = a * b. It needs to be made clear somewhere that for matrix math a * b != b * a. But I think anyone using these functions will already know that. That matrices are no commutative should be clear and sometimes it is necessary to take b * a instead of a * b. > The problem we have had in the past has been with the confusion of row-major vs column-major, which changes the meaning of 'multLeft' and 'multRight'. The terms pre- and postMultiply don't help either. We should have one way to do things and give it the simplest name. If someone wants b * a, he can change the order when making the call. Ok so we don't use names at all but just operators? I guess this is less confusing and may shorten the discussion about the correct naming of a multiplication :-P. 334704 35 cmarrin 2011-01-14 16:08:29 -0800 (In reply to comment #34) > (In reply to comment #33) > > It would be much better now and in the future if we just did matrix multiplication in one direction. There should be a multiply function where a.multiply(b) is the same as a * b, operator* which does the obvious order and operator *= where a *= b is the same as a = a * b. It needs to be made clear somewhere that for matrix math a * b != b * a. But I think anyone using these functions will already know that. > That matrices are no commutative should be clear and sometimes it is necessary to take b * a instead of a * b. > > > The problem we have had in the past has been with the confusion of row-major vs column-major, which changes the meaning of 'multLeft' and 'multRight'. The terms pre- and postMultiply don't help either. We should have one way to do things and give it the simplest name. If someone wants b * a, he can change the order when making the call. > > Ok so we don't use names at all but just operators? I guess this is less confusing and may shorten the discussion about the correct naming of a multiplication :-P. I'd like to see us have a multiply() function which does the same thing as operator*. There are many cases where I want to use a function name to clarify chained operations. Of course, per my recent thread, maybe multiply() should be the same as operator*=. Or maybe we should have multiply which is the same as operator* and applyMutiplication() which is the same as operator*=. Help me, Mr. Wizard! For now, it would probably be the simplest and most sane, to have operator*, operator*= and multiply(), which does the same thing as operator*. I think that's the closest to the way it is today, right? 335088 36 shanestephens 2011-01-16 14:40:39 -0800 Almost - with this patch we have operator*, operator*= and multiply; however multiply does the same thing as *=. I'm not sure that it makes sense for multiply (a normal instance method) to do the same thing as operator* - I think there's an expectation that instance methods operate directly on the instance. 335141 37 shanestephens 2011-01-16 22:25:15 -0800 I've removed translateRight from AffineTransform as a separate patch in 52551. That patch relies on this one to work correctly. 335377 38 cmarrin 2011-01-17 10:19:05 -0800 (In reply to comment #36) > Almost - with this patch we have operator*, operator*= and multiply; however multiply does the same thing as *=. > > I'm not sure that it makes sense for multiply (a normal instance method) to do the same thing as operator* - I think there's an expectation that instance methods operate directly on the instance. The problem with that is CSSMatrix and SVGMatrix both have multiply() functions which are immutable. I would not mind having a function which does what operator*= does, but we should call it something else: applyMultiplication (ick), applyMultiply (bad grammar), applyMatrix (maybe)? I don't have any better ideas. 335520 39 shanestephens 2011-01-17 14:24:20 -0800 In that case, in the interests of consistency, I think we should rename SVGMatrix::multiply with SVGMatrix::operator*, then provide a new multiply method that acts in-place (SVGMatrix is based on AffineTransform so this is trivial to do) and make use of it where we can. We should of course also do the same thing with CSSMatrix :) If you're amenable to this I'll track it and supply a patch in a separate bug. 335525 40 cmarrin 2011-01-17 14:30:54 -0800 (In reply to comment #39) > In that case, in the interests of consistency, I think we should rename SVGMatrix::multiply with SVGMatrix::operator*, then provide a new multiply method that acts in-place (SVGMatrix is based on AffineTransform so this is trivial to do) and make use of it where we can. We should of course also do the same thing with CSSMatrix :) But making multiply() mutable is the opposite of what the JavaScript methods do. So for now, I'd rather any function named "multiply()" is immutable. We can deal with making a consistent set of mutable functions later. 335539 41 shanestephens 2011-01-17 14:56:33 -0800 Ah, that is a shame. I tend to feel that methods should operate on the instance they're called on, in the sense that operator*= does. Binary operators like an immutable multiply should instead be functions of two arguments in this world view. Of course this is complicated because C++ treats operator* as a method even though it should never modify the called instance. I guess we have to stick with what we've got, though :) Given that multiply is currently identical to *=, I could just remove multiply altogether for this patch? On the other hand, there is currently a multiply function in AffineTransform, and it does currently do the same thing as *=. Another alternative is to restrict an immutable understanding of multiply() to the Javascript API. 335826 42 zimmermann 2011-01-18 07:52:59 -0800 (In reply to comment #38) > (In reply to comment #36) > > Almost - with this patch we have operator*, operator*= and multiply; however multiply does the same thing as *=. > > > > I'm not sure that it makes sense for multiply (a normal instance method) to do the same thing as operator* - I think there's an expectation that instance methods operate directly on the instance. > > The problem with that is CSSMatrix and SVGMatrix both have multiply() functions which are immutable. I would not mind having a function which does what operator*= does, but we should call it something else: applyMultiplication (ick), applyMultiply (bad grammar), applyMatrix (maybe)? I don't have any better ideas. I think we should clarify what you meant with an immutable multiply() function. I assume you mean that eg. SVGMatrix::multiply() returns a new SVGMatrix, which you can mutate freely, it just doesn't have any effect on the original SVGMatrix object, where you invoked the multiply() function from. In JS words: Let "var someMatrix" point to an existing SVGMatrix object, e.g. by declaring a <rect id="myRect" transform="matrix(....)".. in the markup and retrieving it from JS using "someMatrix = myRect.transform.baseVal.at(0));". 'someMatrix' is tied to the 'myRect' <rect> element. someMatrix.a += 2 from JS takes immediate effect on 'myRect'. Let "var otherMatrix" point to another existing SVGMatrix object (eg. representing a scale operation). When using "resultMatrix = someMatrix.multiply(otherMatrix)" a new SVGMatrix object is created, not tied to any DOM element. That means you can still call "resultMatrix.a += 2" without any problem, but it takes no effect on any DOM element. Is my interpretation of your 'immutable' definition, correct? I'm asking because I think in C++ in WebCore "a.multiply(b)" should NOT return a new AffineTransform object, but rather mutate the underlying AffineTransform (this). I'd like a.multiply(b) to behave like a *= b, aka. a = a * b, _internally_. The demand for the JS bindings to return 'new' SVGMatrix objects can easily be implemented in SVGMatrix, as SVGMatrix just inherits from AffineTransform, and thus can override any function it wants, especially provide an overloaded multiply() function, taking a SVGMatrix. That's exactly what we do now: SVGMatrix multiply(const SVGMatrix& other) { AffineTransform copy = *this; copy.multLeft(static_cast<const AffineTransform&>(other)); return static_cast<SVGMatrix>(copy); } (With Shanes patch that would just have to say "copy.multiply(other)", not multLeft, but that's another story) --> We can choose freely how our internal usage of AffineTransform/TransformationMatrix should happen in C++, the bindings to JS can always implement their demand on top of that. To summarize: I'd like a.multiply(b) to behave like "a *= b" inside WebCore, for any outside usage through the JS bindings a.multiply(b) should behave like "a * b". Do we agree on that? 336057 43 cmarrin 2011-01-18 13:30:48 -0800 (In reply to comment #42) ... > The demand for the JS bindings to return 'new' SVGMatrix objects can easily be implemented in SVGMatrix, as SVGMatrix just inherits from AffineTransform, and thus can override any function it wants, especially provide an overloaded multiply() function, taking a SVGMatrix. That's exactly what we do now: > > SVGMatrix multiply(const SVGMatrix& other) > { > AffineTransform copy = *this; > copy.multLeft(static_cast<const AffineTransform&>(other)); > return static_cast<SVGMatrix>(copy); > } > > (With Shanes patch that would just have to say "copy.multiply(other)", not multLeft, but that's another story) > > --> We can choose freely how our internal usage of AffineTransform/TransformationMatrix should happen in C++, the bindings to JS can always implement their demand on top of that. > > To summarize: > I'd like a.multiply(b) to behave like "a *= b" inside WebCore, for any outside usage through the JS bindings a.multiply(b) should behave like "a * b". > > Do we agree on that? I believe we are trying to avoid confusion. What looks better programmatically is very subjective and I don't think we should make this decision based on personal preference. There is a well known programming philosophy which states that a function returning an object should not also mutate that object. So if you have: Matrix multiply(const Matrix&) const; (1) That function would not mutate 'this'. But: void multiply(const Matrix&); (2) would. The multiply operation exposed in SVGMatrix and CSSMatrix follows this convention using signature (1). So either way we go, we should be consistent with the above convention. My preference is that we follow signature (1) simply because it would reduce confusion with the related JavaScript calls. But I would be fine with (2) if it allows us to achieve consensus. But the current proposal both mutates and returns the object, which I am against. 336106 44 shanestephens 2011-01-18 14:43:38 -0800 The current proposal returns a reference to the current object, not a new object. This is effectively proposal (2) with allowances made for chaining. Thus, I take it we're all sufficiently in agreement for this patch to proceed? 336120 45 cmarrin 2011-01-18 14:56:16 -0800 (In reply to comment #44) > The current proposal returns a reference to the current object, not a new object. This is effectively proposal (2) with allowances made for chaining. > > Thus, I take it we're all sufficiently in agreement for this patch to proceed? Since we're having difficulty with this, I think it would be best for now to remove any multiply() functions in either AffineTransform or TransformationMatrix. That avoids the multiply() issue and allows us to define it later when we tackle the bigger issue of making mutable matrix functions available to JavaScript. 336137 46 shanestephens 2011-01-18 15:14:20 -0800 As I've mentioned before, this patch deals with AffineTransform only. TransformationMatrix work will take place in a separate bug. It seems to me that we are all sufficiently in agreement as to how the multiply method works for it to remain. We all agree that it should either return a new object or multiply in-place and there seems to be a majority opinion in favour of multiplication in-place. I really don't care whether multiply returns a reference to an AffineTransform or not, however: * returning a reference is not the same as returning a new object * returning a reference does clearly indicate that the method is performing in-place modification * returning a reference allows chaining of matrix modification calls * there is a strong precedence within the class (scale, scaleNonUniform, rotate, rotateFromVector, translate, shear, flipX, flipY, skew, skewX, skewY) for calls that in-place modify and return a reference * it seems bizarre that multiply should be treated differently to these methods, just because it also has operators So overall, I'm in favour of submitting this patch as-is and getting on with fixing the myriad of other issues that have been identified. 336278 47 78871 cmarrin 2011-01-18 18:32:25 -0800 Comment on attachment 78871 Patch You win :-) But seriously, I concur with your implementation. Now on to TransformationMatrix! 336305 48 shanestephens 2011-01-18 19:28:45 -0800 Great! This needs to go on the commit queue, and once it's through there's 52551 (for translateRight) which is ready to go. A TransformationMatrix patch will be ready soon. 336401 49 zimmermann 2011-01-19 01:51:18 -0800 (In reply to comment #46) > As I've mentioned before, this patch deals with AffineTransform only. TransformationMatrix work will take place in a separate bug. > > It seems to me that we are all sufficiently in agreement as to how the multiply method works for it to remain. We all agree that it should either return a new object or multiply in-place and there seems to be a majority opinion in favour of multiplication in-place. > > I really don't care whether multiply returns a reference to an AffineTransform or not, however: > * returning a reference is not the same as returning a new object > * returning a reference does clearly indicate that the method is performing in-place modification > * returning a reference allows chaining of matrix modification calls > * there is a strong precedence within the class (scale, scaleNonUniform, rotate, rotateFromVector, translate, shear, flipX, flipY, skew, skewX, skewY) for calls that in-place modify and return a reference > * it seems bizarre that multiply should be treated differently to these methods, just because it also has operators > > So overall, I'm in favour of submitting this patch as-is and getting on with fixing the myriad of other issues that have been identified. Completly fine with me. multiply shoul behave as the other methods, for now. We should first fix the other issues, align with TransformationMatrix, then we can think again about optimizing/changing the multiply concept to align better with the demands of the bindings. 336419 50 78871 commit-queue 2011-01-19 03:49:48 -0800 Comment on attachment 78871 Patch Rejecting attachment 78871 from commit-queue. Failed to run "['./Tools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '--bot-id=eseidel-sf-cq', 'bu..." exit_code: 2 Last 500 characters of output: ests/css .... http/tests/eventsource ....... http/tests/eventsource/workers . http/tests/globalhistory .... http/tests/history ............................. http/tests/incremental ...... http/tests/inspector-enabled . http/tests/inspector ...... http/tests/inspector/extensions-resources-redirect.html -> failed Exiting early after 1 failures. 21476 tests run. 542.17s total testing time 21475 test cases (99%) succeeded 1 test case (<1%) had incorrect layout 11 test cases (<1%) had stderr output Full output: http://queues.webkit.org/results/7602184 336422 51 commit-queue 2011-01-19 04:07:02 -0800 The commit-queue encountered the following flaky tests while processing attachment 78871: http/tests/inspector/extensions-resources-redirect.html bug 52709 (author: caseq@chromium.org) The commit-queue is continuing to process your patch. 336642 52 78871 eric 2011-01-19 10:55:46 -0800 Comment on attachment 78871 Patch Two instances of the queue grabbed your patch (due to a cq bug), and one of them failed out due to flaky tests, the other saw the test was flaky and didn't fail out, but then stopped because the first instance had already cq-'d the patch. sorry for the confusion. 336687 53 78871 commit-queue 2011-01-19 12:10:25 -0800 Comment on attachment 78871 Patch Clearing flags on attachment: 78871 Committed r76146: <http://trac.webkit.org/changeset/76146> 336688 54 commit-queue 2011-01-19 12:10:36 -0800 All reviewed patches have been landed. Closing bug. 337092 55 shanestephens 2011-01-19 20:51:46 -0800 fyi: there's now a patch to fix TransformationMatrix multiply operations in https://bugs.webkit.org/show_bug.cgi?id=52780. 76578 2010-12-14 15:06:32 -0800 2011-01-10 22:25:04 -0800 Patch bug-48031-20101215100629.patch text/plain 22963 shanestephens ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MzJlNWMwY2VkMmRmOTdkYWUyNDEzZjNmNTNiZjhkNjIwNzY5YzU0OC4uMTRjZjlkY2ZhNjk1NGUz ZDI5YzM0OTZlZjBjYmI3MWQwZmE3M2JiMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2OSBAQAorMjAxMC0xMi0xNCAgU2hh bmUgU3RlcGhlbnMgIDxzaGFuZXN0ZXBoZW5zQGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWZmaW5lVHJhbnNmb3JtIG9wZXJhdG9y KiByZXZlcnNlcyBvcmRlciBvZiBvcGVyYW5kcy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTQ4MDMxCisKKyAgICAgICAgRml4ZWQgcmV2ZXJzYWwsIHJl bmFtZWQgbWF0cml4IG1ldGhvZHMgdG8gYmUgY2xlYXJlciwgZm91bmQgYWxsIGV4YW1wbGVzIG9m IG9wZXJhdG9yKiBhbmQKKyAgICAgICAgb3BlcmF0b3IqPSB1c2FnZSBhbmQgc3dpdGNoZWQgb3Bl cmFuZCBvcmRlcgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyBhcyB0aGlzIHJlZmFjdG9yIGRvZXNu J3QgYWRkIGZ1bmN0aW9uYWxpdHkuCisKKyAgICAgICAgKiBodG1sL0hUTUxDYW52YXNFbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxDYW52YXNFbGVtZW50OjpiYXNlVHJhbnNmb3Jt KToKKyAgICAgICAgKiBodG1sL2NhbnZhcy9DYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6Q2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjp0cmFuc2Zvcm0pOgor ICAgICAgICAoV2ViQ29yZTo6Q2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjpzZXRUcmFuc2Zvcm0p OgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdHRlcm5DRy5jcHA6CisgICAgICAg IChXZWJDb3JlOjpQYXR0ZXJuOjpjcmVhdGVQbGF0Zm9ybVBhdHRlcm4pOgorICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFzLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkdMRVMyQ2FudmFzOjpmaWxsUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpHTEVTMkNhbnZh czo6Y29uY2F0Q1RNKToKKyAgICAgICAgKFdlYkNvcmU6OkdMRVMyQ2FudmFzOjpkcmF3UXVhZCk6 CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVHJhbnNwYXJlbmN5V2luLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlRyYW5zcGFyZW5jeVdpbjo6c2V0dXBMYXllckZvck9wYXF1 ZUNvbXBvc2l0ZUxheWVyKToKKyAgICAgICAgKFdlYkNvcmU6OlRyYW5zcGFyZW5jeVdpbjo6c2V0 dXBUcmFuc2Zvcm1Gb3JLZWVwVHJhbnNmb3JtKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy90cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBZmZp bmVUcmFuc2Zvcm06OnBvc3RNdWx0aXBseSk6CisgICAgICAgIChXZWJDb3JlOjpBZmZpbmVUcmFu c2Zvcm06OnJvdGF0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9B ZmZpbmVUcmFuc2Zvcm0uaDoKKyAgICAgICAgKFdlYkNvcmU6OkFmZmluZVRyYW5zZm9ybTo6bXVs dGlwbHkpOgorICAgICAgICAoV2ViQ29yZTo6QWZmaW5lVHJhbnNmb3JtOjpvcGVyYXRvcio9KToK KyAgICAgICAgKFdlYkNvcmU6OkFmZmluZVRyYW5zZm9ybTo6b3BlcmF0b3IqKToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGljc0NvbnRleHRXaW5DRS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRQbGF0Zm9ybVByaXZhdGU6OmNvbmNhdENUTSk6 CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvU2hhcmVkQml0bWFwLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlNoYXJlZEJpdG1hcDo6ZHJhd1BhdHRlcm4pOgorICAgICAgICAqIHJl bmRlcmluZy9SZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpSZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lcjo6dHJhbnNmb3JtT25Ob25TY2FsaW5nU3Ryb2tl KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyU1ZHUmVzb3VyY2VHcmFkaWVudC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpjbGlwVG9UZXh0TWFzayk6CisgICAgICAgIChXZWJDb3JlOjpSZW5k ZXJTVkdSZXNvdXJjZUdyYWRpZW50OjphcHBseVJlc291cmNlKToKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVyU1ZHUmVzb3VyY2VQYXR0ZXJuLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRl clNWR1Jlc291cmNlUGF0dGVybjo6YXBwbHlSZXNvdXJjZSk6CisgICAgICAgICogcmVuZGVyaW5n L1JlbmRlclNWR1Jvb3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyU1ZHUm9vdDo6bG9j YWxUb0JvcmRlckJveFRyYW5zZm9ybSk6CisgICAgICAgICogcmVuZGVyaW5nL1NWR0ltYWdlQnVm ZmVyVG9vbHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHSW1hZ2VCdWZmZXJUb29sczo6Y2Fs Y3VsYXRlVHJhbnNmb3JtYXRpb25Ub091dGVybW9zdFNWR0Nvb3JkaW5hdGVTeXN0ZW0pOgorICAg ICAgICAoV2ViQ29yZTo6U1ZHSW1hZ2VCdWZmZXJUb29sczo6cmVuZGVyU3VidHJlZVRvSW1hZ2VC dWZmZXIpOgorICAgICAgICAqIHJlbmRlcmluZy9zdmcvU1ZHVGV4dExheW91dEVuZ2luZS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpTVkdUZXh0TGF5b3V0RW5naW5lOjpmaW5hbGl6ZVRyYW5zZm9y bU1hdHJpY2VzKToKKyAgICAgICAgKiBzdmcvU1ZHTG9jYXRhYmxlLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlNWR0xvY2F0YWJsZTo6Y29tcHV0ZUNUTSk6CisgICAgICAgIChXZWJDb3JlOjpTVkdM b2NhdGFibGU6OmdldFRyYW5zZm9ybVRvRWxlbWVudCk6CisgICAgICAgICogc3ZnL1NWR01hdHJp eC5oOgorICAgICAgICAoV2ViQ29yZTo6U1ZHTWF0cml4OjptdWx0aXBseSk6CisgICAgICAgICog c3ZnL1NWR1NWR0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHU1ZHRWxlbWVudDo6 bG9jYWxDb29yZGluYXRlU3BhY2VUcmFuc2Zvcm0pOgorICAgICAgICAoV2ViQ29yZTo6U1ZHU1ZH RWxlbWVudDo6dmlld0JveFRvVmlld1RyYW5zZm9ybSk6CisgICAgICAgICogc3ZnL1NWR1N0eWxl ZFRyYW5zZm9ybWFibGVFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1N0eWxlZFRy YW5zZm9ybWFibGVFbGVtZW50OjphbmltYXRlZExvY2FsVHJhbnNmb3JtKToKKyAgICAgICAgKiBz dmcvU1ZHVGV4dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHVGV4dEVsZW1lbnQ6 OmFuaW1hdGVkTG9jYWxUcmFuc2Zvcm0pOgorICAgICAgICAqIHN2Zy9TVkdUcmFuc2Zvcm1MaXN0 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1RyYW5zZm9ybUxpc3Q6OmNvbmNhdGVuYXRlKToK KwogMjAxMC0xMi0xNCAgS3lvdW5nYSBSYSAgPGt5b3VuZ2EucmFAZ21haWwuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRN TENhbnZhc0VsZW1lbnQuY3BwIGIvV2ViQ29yZS9odG1sL0hUTUxDYW52YXNFbGVtZW50LmNwcApp bmRleCA2ZThlNzA4NzRhMWNhYjQ5NWY2MjVlN2E5NjI4YWE4Y2FmOWNiMWVlLi5lNjM2YjM1NzE5 YmUwMjMxZDRhOTg5MjAwZGM4OWI2ZDBhNTk0YzkxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwv SFRNTENhbnZhc0VsZW1lbnQuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MQ2FudmFzRWxlbWVu dC5jcHAKQEAgLTQzNiw4ICs0MzYsNyBAQCBBZmZpbmVUcmFuc2Zvcm0gSFRNTENhbnZhc0VsZW1l bnQ6OmJhc2VUcmFuc2Zvcm0oKSBjb25zdAogICAgIEFmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm07 CiAgICAgaWYgKHNpemUud2lkdGgoKSAmJiBzaXplLmhlaWdodCgpKQogICAgICAgICB0cmFuc2Zv cm0uc2NhbGVOb25Vbmlmb3JtKHNpemUud2lkdGgoKSAvIHVuc2NhbGVkU2l6ZS53aWR0aCgpLCBz aXplLmhlaWdodCgpIC8gdW5zY2FsZWRTaXplLmhlaWdodCgpKTsKLSAgICB0cmFuc2Zvcm0ubXVs dGlwbHkobV9pbWFnZUJ1ZmZlci0+YmFzZVRyYW5zZm9ybSgpKTsKLSAgICByZXR1cm4gdHJhbnNm b3JtOworICAgIHJldHVybiBtX2ltYWdlQnVmZmVyLT5iYXNlVHJhbnNmb3JtKCkgKiB0cmFuc2Zv cm07CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVy aW5nQ29udGV4dDJELmNwcCBiL1dlYkNvcmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVyaW5nQ29u dGV4dDJELmNwcAppbmRleCA3YTliYzRkOTQxYzA2YmM1MzhjODAzMThjODZmN2FkMzUyNjVhYmFl Li44M2VlZDlmMGJhMmIwNDBmYjk5OTVkMDJlNGQzMTViNWRmNGU5YmZiIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2h0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAKKysrIGIvV2Vi Q29yZS9odG1sL2NhbnZhcy9DYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwCkBAIC01MzcsNyAr NTM3LDcgQEAgdm9pZCBDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OnRyYW5zZm9ybShmbG9hdCBt MTEsIGZsb2F0IG0xMiwgZmxvYXQgbTIxLCBmbG9hdAogICAgICAgICByZXR1cm47CiAKICAgICBB ZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtKG0xMSwgbTEyLCBtMjEsIG0yMiwgZHgsIGR5KTsKLSAg ICBBZmZpbmVUcmFuc2Zvcm0gbmV3VHJhbnNmb3JtID0gdHJhbnNmb3JtICogc3RhdGUoKS5tX3Ry YW5zZm9ybTsKKyAgICBBZmZpbmVUcmFuc2Zvcm0gbmV3VHJhbnNmb3JtID0gc3RhdGUoKS5tX3Ry YW5zZm9ybSAqIHRyYW5zZm9ybTsKICAgICBpZiAoIW5ld1RyYW5zZm9ybS5pc0ludmVydGlibGUo KSkgewogICAgICAgICBzdGF0ZSgpLm1faW52ZXJ0aWJsZUNUTSA9IGZhbHNlOwogICAgICAgICBy ZXR1cm47CkBAIC01NjIsNyArNTYyLDcgQEAgdm9pZCBDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6 OnNldFRyYW5zZm9ybShmbG9hdCBtMTEsIGZsb2F0IG0xMiwgZmxvYXQgbTIxLCBmbG8KICAgICAg ICAgcmV0dXJuOwogICAgIGMtPmNvbmNhdENUTShjLT5nZXRDVE0oKS5pbnZlcnNlKCkpOwogICAg IGMtPmNvbmNhdENUTShjYW52YXMoKS0+YmFzZVRyYW5zZm9ybSgpKTsKLSAgICBzdGF0ZSgpLm1f dHJhbnNmb3JtLm11bHRpcGx5KGN0bS5pbnZlcnNlKCkpOworICAgIHN0YXRlKCkubV90cmFuc2Zv cm0gPSBjdG0uaW52ZXJzZSgpICogc3RhdGUoKS5tX3RyYW5zZm9ybTsKICAgICBtX3BhdGgudHJh bnNmb3JtKGN0bSk7CiAKICAgICBzdGF0ZSgpLm1faW52ZXJ0aWJsZUNUTSA9IHRydWU7CmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdHRlcm5DRy5jcHAgYi9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdHRlcm5DRy5jcHAKaW5kZXggOTRmMzdiMmZmMWNm NjE5NjdlYmVmZjg3MWQ2NTRjZTRhY2RlNDQyOS4uY2ZhYzE1YzM3ZjY2YzBkZmE0MzY0NWQ3OTAz NmExMWU5ZjY5MzBmNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9Q YXR0ZXJuQ0cuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0dGVybkNH LmNwcApAQCAtNTQsOCArNTQsNyBAQCBDR1BhdHRlcm5SZWYgUGF0dGVybjo6Y3JlYXRlUGxhdGZv cm1QYXR0ZXJuKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgdXNlclNwYWNlVHJhbgogewogICAgIElu dFJlY3QgdGlsZVJlY3QgPSB0aWxlSW1hZ2UoKS0+cmVjdCgpOwogCi0gICAgQWZmaW5lVHJhbnNm b3JtIHBhdHRlcm5UcmFuc2Zvcm0gPSBtX3BhdHRlcm5TcGFjZVRyYW5zZm9ybWF0aW9uOwotICAg IHBhdHRlcm5UcmFuc2Zvcm0ubXVsdGlwbHkodXNlclNwYWNlVHJhbnNmb3JtYXRpb24pOworICAg IEFmZmluZVRyYW5zZm9ybSBwYXR0ZXJuVHJhbnNmb3JtID0gdXNlclNwYWNlVHJhbnNmb3JtYXRp b24gKiBtX3BhdHRlcm5TcGFjZVRyYW5zZm9ybWF0aW9uOwogICAgIHBhdHRlcm5UcmFuc2Zvcm0u c2NhbGVOb25Vbmlmb3JtKDEsIC0xKTsKICAgICBwYXR0ZXJuVHJhbnNmb3JtLnRyYW5zbGF0ZSgw LCAtdGlsZVJlY3QuaGVpZ2h0KCkpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFzLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vR0xFUzJDYW52YXMuY3BwCmluZGV4IDY5N2NmNWU5MmQ1NTkzZWI2MmZjODM1 ZTI2Y2Y0YmI4NTBmMTA3MmUuLmFlMDE3ZGVlY2RlNTQyNWEzNWY5Y2ZkZTQzNTRiZWQ4NmUzNDE3 ZTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJD YW52YXMuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJD YW52YXMuY3BwCkBAIC0xMDgsNyArMTA4LDcgQEAgdm9pZCBHTEVTMkNhbnZhczo6ZmlsbFJlY3Qo Y29uc3QgRmxvYXRSZWN0JiByZWN0LCBjb25zdCBDb2xvciYgY29sb3IsIENvbG9yU3BhY2UKICAg ICBtX2NvbnRleHQtPnVzZVF1YWRWZXJ0aWNlcygpOwogCiAgICAgQWZmaW5lVHJhbnNmb3JtIG1h dHJpeChtX2ZsaXBNYXRyaXgpOwotICAgIG1hdHJpeC5tdWx0TGVmdChtX3N0YXRlLT5tX2N0bSk7 CisgICAgbWF0cml4ICo9IG1fc3RhdGUtPm1fY3RtOwogICAgIG1hdHJpeC50cmFuc2xhdGUocmVj dC54KCksIHJlY3QueSgpKTsKICAgICBtYXRyaXguc2NhbGUocmVjdC53aWR0aCgpLCByZWN0Lmhl aWdodCgpKTsKIApAQCAtMTUwLDcgKzE1MCw3IEBAIHZvaWQgR0xFUzJDYW52YXM6OnNjYWxlKGNv bnN0IEZsb2F0U2l6ZSYgc2l6ZSkKIAogdm9pZCBHTEVTMkNhbnZhczo6Y29uY2F0Q1RNKGNvbnN0 IEFmZmluZVRyYW5zZm9ybSYgYWZmaW5lKQogewotICAgIG1fc3RhdGUtPm1fY3RtLm11bHRMZWZ0 KGFmZmluZSk7CisgICAgbV9zdGF0ZS0+bV9jdG0gKj0gYWZmaW5lOwogfQogCiB2b2lkIEdMRVMy Q2FudmFzOjpzYXZlKCkKQEAgLTIyMCw3ICsyMjAsNyBAQCB2b2lkIEdMRVMyQ2FudmFzOjpkcmF3 VGV4dHVyZWRSZWN0VGlsZShUZXh0dXJlKiB0ZXh0dXJlLCBpbnQgdGlsZSwgY29uc3QgRmxvYXRS ZQogdm9pZCBHTEVTMkNhbnZhczo6ZHJhd1F1YWQoY29uc3QgSW50U2l6ZSYgdGV4dHVyZVNpemUs IGNvbnN0IEZsb2F0UmVjdCYgc3JjUmVjdCwgY29uc3QgRmxvYXRSZWN0JiBkc3RSZWN0LCBjb25z dCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSwgZmxvYXQgYWxwaGEpCiB7CiAgICAgQWZmaW5l VHJhbnNmb3JtIG1hdHJpeChtX2ZsaXBNYXRyaXgpOwotICAgIG1hdHJpeC5tdWx0TGVmdCh0cmFu c2Zvcm0pOworICAgIG1hdHJpeCAqPSB0cmFuc2Zvcm07CiAgICAgbWF0cml4LnRyYW5zbGF0ZShk c3RSZWN0LngoKSwgZHN0UmVjdC55KCkpOwogICAgIG1hdHJpeC5zY2FsZShkc3RSZWN0LndpZHRo KCksIGRzdFJlY3QuaGVpZ2h0KCkpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHAKaW5kZXggNGRjMjE1NzA0ODgwZDE0 Zjg5ZjU1ZjE5YTRiYjU5OTM1MzFiZTFkYy4uYmE2NmVhZTQ2NDQzZDMzNjdlOGU1MDM2NWUzNDIz NjFiODU0NjFlNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9UcmFuc3BhcmVuY3lXaW4uY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vVHJhbnNwYXJlbmN5V2luLmNwcApAQCAtMjUyLDcgKzI1Miw3IEBAIHZvaWQgVHJhbnNw YXJlbmN5V2luOjpzZXR1cExheWVyRm9yT3BhcXVlQ29tcG9zaXRlTGF5ZXIoKQogICAgIGlmICht X3RyYW5zZm9ybU1vZGUgPT0gVW50cmFuc2Zvcm0peyAKICAgICAgICAgLy8gQ29tcHV0ZSB0aGUg aW52ZXJzZSBtYXBwaW5nIGZyb20gdGhlIGNhbnZhcyBzcGFjZSB0byB0aGUKICAgICAgICAgLy8g Y29vcmRpbmF0ZSBzcGFjZSBvZiBvdXIgYml0bWFwLgotICAgICAgICBtYXBwaW5nID0gbV9vcmdU cmFuc2Zvcm0uaW52ZXJzZSgpICogbWFwcGluZzsKKyAgICAgICAgbWFwcGluZyAqPSBtX29yZ1Ry YW5zZm9ybS5pbnZlcnNlKCk7CiAgICAgfQogICAgIGNvbXBvc2l0ZVRvQ29weSgqbV9kZXN0Q29u dGV4dCwgKm1fZHJhd0NvbnRleHQsIG1hcHBpbmcpOwogCkBAIC0zMTMsNyArMzEzLDcgQEAgdm9p ZCBUcmFuc3BhcmVuY3lXaW46OnNldHVwVHJhbnNmb3JtRm9yS2VlcFRyYW5zZm9ybShjb25zdCBJ bnRSZWN0JiByZWdpb24pCiAgICAgICAgIC8vIFdlJ3JlIG1ha2luZyBhIGxheWVyLCBzbyBhcHBs eSB0aGUgb2xkIHRyYW5zZm9ybSB0byB0aGUgbmV3IG9uZQogICAgICAgICAvLyBzbyBpdCdzIG1h aW50YWluZWQuIFdlIGtub3cgdGhlIG5ldyBsYXllciBoYXMgdGhlIGlkZW50aXR5CiAgICAgICAg IC8vIHRyYW5zZm9ybSBub3csIHdlIHdlIGNhbiBqdXN0IG11bHRpcGx5IGl0LgotICAgICAgICB4 Zm9ybSA9IG1fb3JnVHJhbnNmb3JtICogeGZvcm07CisgICAgICAgIHhmb3JtICo9IG1fb3JnVHJh bnNmb3JtOwogICAgICAgICBtX2RyYXdDb250ZXh0LT5jb25jYXRDVE0oeGZvcm0pOwogICAgIH0K ICAgICBtX2RyYXdSZWN0ID0gbV9zb3VyY2VSZWN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5jcHAgYi9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmNwcAppbmRleCBmMjc1 NTI2YmQ0MDYzYmIxNmU3ZTAyNmJjZDM3MzA3OTZhNTVkYWM1Li4wY2U3ODMzMWM1MTYyM2Q4ZGI0 OTk3OTdkMzFjNmU4MTk0Nzk2MGVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmNwcApAQCAtMTY0LDEyICsxNjQs MTEgQEAgQWZmaW5lVHJhbnNmb3JtIEFmZmluZVRyYW5zZm9ybTo6aW52ZXJzZSgpIGNvbnN0CiAg ICAgcmV0dXJuIHJlc3VsdDsKIH0KIAotQWZmaW5lVHJhbnNmb3JtJiBBZmZpbmVUcmFuc2Zvcm06 Om11bHRpcGx5KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgb3RoZXIpCi17Ci0gICAgcmV0dXJuICgq dGhpcykgKj0gb3RoZXI7Ci19Ci0KLUFmZmluZVRyYW5zZm9ybSYgQWZmaW5lVHJhbnNmb3JtOjpt dWx0TGVmdChjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIG90aGVyKQorLyoqCisgKiBNdWx0aXBsaWVz IHRoaXMgQWZmaW5lVHJhbnNmb3JtIGJ5IHRoZSBwcm92aWRlZCBBZmZpbmVUcmFuc2Zvcm0gLSBp LmUuCisgKiB0aGlzID0gdGhpcyAqIG90aGVyOworICovCitBZmZpbmVUcmFuc2Zvcm0mIEFmZmlu ZVRyYW5zZm9ybTo6cG9zdE11bHRpcGx5KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgb3RoZXIpCiB7 CiAgICAgQWZmaW5lVHJhbnNmb3JtIHRyYW5zOwogICAgIApAQCAtMTkyLDcgKzE5MSw3IEBAIEFm ZmluZVRyYW5zZm9ybSYgQWZmaW5lVHJhbnNmb3JtOjpyb3RhdGUoZG91YmxlIGEpCiAgICAgZG91 YmxlIHNpbkFuZ2xlID0gc2luKGEpOwogICAgIEFmZmluZVRyYW5zZm9ybSByb3QoY29zQW5nbGUs IHNpbkFuZ2xlLCAtc2luQW5nbGUsIGNvc0FuZ2xlLCAwLCAwKTsKIAotICAgIG11bHRMZWZ0KHJv dCk7CisgICAgcG9zdE11bHRpcGx5KHJvdCk7CiAgICAgcmV0dXJuICp0aGlzOwogfQogCmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNm b3JtLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNm b3JtLmgKaW5kZXggYmFlZTEwMmE5NTZjYTgyMzkyNGY2YTlhNTBhYmU3NzA4OTA1ODQ3OS4uYzcw MzYzODRjYTI5ZDhlYzk5MjJmYWQ0NjgwMzg2YzNlZDBjMmRkMyAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5oCisrKyBiL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uaApAQCAt OTUsOCArOTUsNiBAQCBwdWJsaWM6CiAKICAgICB2b2lkIG1ha2VJZGVudGl0eSgpOwogCi0gICAg QWZmaW5lVHJhbnNmb3JtJiBtdWx0aXBseShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKLSAgICBB ZmZpbmVUcmFuc2Zvcm0mIG11bHRMZWZ0KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYpOwogICAgIEFm ZmluZVRyYW5zZm9ybSYgc2NhbGUoZG91YmxlKTsgCiAgICAgQWZmaW5lVHJhbnNmb3JtJiBzY2Fs ZShkb3VibGUgc3gsIGRvdWJsZSBzeSk7IAogICAgIEFmZmluZVRyYW5zZm9ybSYgc2NhbGVOb25V bmlmb3JtKGRvdWJsZSBzeCwgZG91YmxlIHN5KTsKQEAgLTE0NCwxOCArMTQyLDIyIEBAIHB1Ymxp YzoKIAogICAgIGJvb2wgb3BlcmF0b3IhPShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIG90aGVyKSBj b25zdCB7IHJldHVybiAhKCp0aGlzID09IG90aGVyKTsgfQogCisgICAgQWZmaW5lVHJhbnNmb3Jt JiBtdWx0aXBseShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHQpCisgICAgeworICAgICAgICByZXR1 cm4gdGhpcy0+cG9zdE11bHRpcGx5KHQpOworICAgIH0KKwogICAgIC8vICp0aGlzID0gKnRoaXMg KiB0IChpLmUuLCBhIG11bHRSaWdodCkKICAgICBBZmZpbmVUcmFuc2Zvcm0mIG9wZXJhdG9yKj0o Y29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0KQogICAgIHsKLSAgICAgICAgKnRoaXMgPSAqdGhpcyAq IHQ7Ci0gICAgICAgIHJldHVybiAqdGhpczsKKyAgICAgICAgcmV0dXJuIHRoaXMtPnBvc3RNdWx0 aXBseSh0KTsKICAgICB9CiAgICAgCiAgICAgLy8gcmVzdWx0ID0gKnRoaXMgKiB0IChpLmUuLCBh IG11bHRSaWdodCkKICAgICBBZmZpbmVUcmFuc2Zvcm0gb3BlcmF0b3IqKGNvbnN0IEFmZmluZVRy YW5zZm9ybSYgdCkgY29uc3QKICAgICB7Ci0gICAgICAgIEFmZmluZVRyYW5zZm9ybSByZXN1bHQg PSB0OwotICAgICAgICByZXN1bHQubXVsdExlZnQoKnRoaXMpOworICAgICAgICBBZmZpbmVUcmFu c2Zvcm0gcmVzdWx0ID0gKnRoaXM7CisgICAgICAgIHJlc3VsdCAqPSB0OwogICAgICAgICByZXR1 cm4gcmVzdWx0OwogICAgIH0KIApAQCAtMTgxLDYgKzE4Myw4IEBAIHByaXZhdGU6CiAgICAgfQog CiAgICAgVHJhbnNmb3JtIG1fdHJhbnNmb3JtOworCisgICAgQWZmaW5lVHJhbnNmb3JtJiBwb3N0 TXVsdGlwbHkoY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CiB9OwogCiBBZmZpbmVUcmFuc2Zvcm0g bWFrZU1hcEJldHdlZW5SZWN0cyhjb25zdCBGbG9hdFJlY3QmIHNvdXJjZSwgY29uc3QgRmxvYXRS ZWN0JiBkZXN0KTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2Uv R3JhcGhpY3NDb250ZXh0V2luQ0UuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5j ZS9HcmFwaGljc0NvbnRleHRXaW5DRS5jcHAKaW5kZXggYjAxZmZmNTQwMzE2ZjY0ZTBiNDU0ZDAw ZjI0YzAyMjRkZWMzMDgwOC4uOWJlZjI2YTA5NTFlNGUyMTljMDlkOGMxNjVhMWNkMDIwYjBlM2Fh MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGljc0Nv bnRleHRXaW5DRS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFw aGljc0NvbnRleHRXaW5DRS5jcHAKQEAgLTIwOSw3ICsyMDksNyBAQCBwdWJsaWM6CiAKICAgICB2 b2lkICBjb25jYXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCiAgICAgewot ICAgICAgICBtX3RyYW5zZm9ybSA9IHRyYW5zZm9ybSAqIG1fdHJhbnNmb3JtOworICAgICAgICBt X3RyYW5zZm9ybSAqPSB0cmFuc2Zvcm07CiAgICAgfQogCiAgICAgSW50UmVjdCBtYXBSZWN0KGNv bnN0IEludFJlY3QmIHJlY3QpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL3dpbmNlL1NoYXJlZEJpdG1hcC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L3dpbmNlL1NoYXJlZEJpdG1hcC5jcHAKaW5kZXggMDVkMTUzNWZlOWE5ZGY3N2I3YzZmZWU1NTA4 NGY3MTJkMGJiODRjMy4uMTY4YTVlMjMwODE0YmYwN2Q5ZjNjMWI0ZWNkZjkyZGIwOGIzMzY1MyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9TaGFyZWRCaXRtYXAu Y3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvU2hhcmVkQml0bWFwLmNw cApAQCAtNDQ1LDggKzQ0NSw3IEBAIHZvaWQgU2hhcmVkQml0bWFwOjpkcmF3UGF0dGVybihIREMg aGRjLCBjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSwgY29uc3QKICAgICAgICAgYm1w SGVpZ2h0ID0gdGlsZVJlY3QuaGVpZ2h0KCk7CiAgICAgfQogCi0gICAgQWZmaW5lVHJhbnNmb3Jt IHRmID0gdHJhbnNmb3JtOwotICAgIHRmICo9IHBhdHRlcm5UcmFuc2Zvcm07CisgICAgQWZmaW5l VHJhbnNmb3JtIHRmID0gcGF0dGVyblRyYW5zZm9ybSAqIHRyYW5zZm9ybTsKIAogICAgIEZsb2F0 UmVjdCB0clJlY3QgPSB0Zi5tYXBSZWN0KGRlc3RSZWN0KTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyU1ZHUmVzb3VyY2VDb250YWluZXIuY3BwIGIvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyU1ZHUmVzb3VyY2VDb250YWluZXIuY3BwCmluZGV4IGZiMzBlZmRiNjMxODU5 ZGNhY2JiMDYyN2U1ZDJmYTZkYzJhMTAwOGQuLmQ1YmNkZjg1OTRlOGIyOGM5YWY4OTExNGVhMDE3 ODk1MWUyNTM1OGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclNWR1Jlc291 cmNlQ29udGFpbmVyLmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJTVkdSZXNvdXJj ZUNvbnRhaW5lci5jcHAKQEAgLTE4Myw4ICsxODMsOCBAQCBBZmZpbmVUcmFuc2Zvcm0gUmVuZGVy U1ZHUmVzb3VyY2VDb250YWluZXI6OnRyYW5zZm9ybU9uTm9uU2NhbGluZ1N0cm9rZShSZW5kZXJP YgogICAgICAgICByZXR1cm4gcmVzb3VyY2VUcmFuc2Zvcm07CiAKICAgICBTVkdTdHlsZWRUcmFu c2Zvcm1hYmxlRWxlbWVudCogZWxlbWVudCA9IHN0YXRpY19jYXN0PFNWR1N0eWxlZFRyYW5zZm9y bWFibGVFbGVtZW50Kj4ob2JqZWN0LT5ub2RlKCkpOwotICAgIEFmZmluZVRyYW5zZm9ybSB0cmFu c2Zvcm0gPSByZXNvdXJjZVRyYW5zZm9ybTsKLSAgICB0cmFuc2Zvcm0ubXVsdGlwbHkoZWxlbWVu dC0+Z2V0U2NyZWVuQ1RNKFNWR0xvY2F0YWJsZTo6RGlzYWxsb3dTdHlsZVVwZGF0ZSkpOworICAg IEFmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm0gPSBlbGVtZW50LT5nZXRTY3JlZW5DVE0oU1ZHTG9j YXRhYmxlOjpEaXNhbGxvd1N0eWxlVXBkYXRlKTsKKyAgICB0cmFuc2Zvcm0gKj0gcmVzb3VyY2VU cmFuc2Zvcm07CiAgICAgcmV0dXJuIHRyYW5zZm9ybTsKIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyU1ZHUmVzb3VyY2VHcmFkaWVudC5jcHAgYi9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJTVkdSZXNvdXJjZUdyYWRpZW50LmNwcAppbmRleCA3YzM4M2QwYTNmYzU5OWJi M2RhNTU5YWUzNjkyM2EzNWU0NmYwM2VhLi44NTIyZjhhMjI1ZjA5ODE1ODVhN2NjNWVjZWM4ZDRj NzhmYzJjMWFmIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJTVkdSZXNvdXJj ZUdyYWRpZW50LmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJTVkdSZXNvdXJjZUdy YWRpZW50LmNwcApAQCAtMTM0LDcgKzEzNCw3IEBAIHN0YXRpYyBpbmxpbmUgQWZmaW5lVHJhbnNm b3JtIGNsaXBUb1RleHRNYXNrKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwKICAgICAgICAgbWF0 cml4LnRyYW5zbGF0ZShtYXNrQm91bmRpbmdCb3gueCgpLCBtYXNrQm91bmRpbmdCb3gueSgpKTsK ICAgICAgICAgbWF0cml4LnNjYWxlTm9uVW5pZm9ybShtYXNrQm91bmRpbmdCb3gud2lkdGgoKSwg bWFza0JvdW5kaW5nQm94LmhlaWdodCgpKTsKICAgICB9Ci0gICAgbWF0cml4Lm11bHRMZWZ0KGdy YWRpZW50VHJhbnNmb3JtKTsKKyAgICBtYXRyaXggKj0gZ3JhZGllbnRUcmFuc2Zvcm07CiAgICAg cmV0dXJuIG1hdHJpeDsKIH0KICNlbmRpZgpAQCAtMTkxLDcgKzE5MSw3IEBAIGJvb2wgUmVuZGVy U1ZHUmVzb3VyY2VHcmFkaWVudDo6YXBwbHlSZXNvdXJjZShSZW5kZXJPYmplY3QqIG9iamVjdCwg UmVuZGVyU3R5bGUqCiAgICAgICAgIEFmZmluZVRyYW5zZm9ybSBncmFkaWVudFRyYW5zZm9ybTsK ICAgICAgICAgY2FsY3VsYXRlR3JhZGllbnRUcmFuc2Zvcm0oZ3JhZGllbnRUcmFuc2Zvcm0pOwog Ci0gICAgICAgIGdyYWRpZW50RGF0YS0+dXNlcnNwYWNlVHJhbnNmb3JtLm11bHRMZWZ0KGdyYWRp ZW50VHJhbnNmb3JtKTsKKyAgICAgICAgZ3JhZGllbnREYXRhLT51c2Vyc3BhY2VUcmFuc2Zvcm0g Kj0gZ3JhZGllbnRUcmFuc2Zvcm07CiAgICAgICAgIGdyYWRpZW50RGF0YS0+Z3JhZGllbnQtPnNl dEdyYWRpZW50U3BhY2VUcmFuc2Zvcm0oZ3JhZGllbnREYXRhLT51c2Vyc3BhY2VUcmFuc2Zvcm0p OwogICAgIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyU1ZHUmVzb3Vy Y2VQYXR0ZXJuLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclNWR1Jlc291cmNlUGF0dGVy bi5jcHAKaW5kZXggY2Q2NDE4MzJjMDRjMTI0MGIxNGVmYTk4YWYzNWExNGViYjc3ZDkxNi4uMzRm NjdhZTc1NjFjNGQ4NGNlOTFjMmU0ZDJhNzE1NzdmZDAxYmZhOCAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyU1ZHUmVzb3VyY2VQYXR0ZXJuLmNwcAorKysgYi9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJTVkdSZXNvdXJjZVBhdHRlcm4uY3BwCkBAIC0xNDAsNyArMTQwLDcgQEAg Ym9vbCBSZW5kZXJTVkdSZXNvdXJjZVBhdHRlcm46OmFwcGx5UmVzb3VyY2UoUmVuZGVyT2JqZWN0 KiBvYmplY3QsIFJlbmRlclN0eWxlKgogCiAgICAgICAgIEFmZmluZVRyYW5zZm9ybSBwYXR0ZXJu VHJhbnNmb3JtID0gbV9hdHRyaWJ1dGVzLnBhdHRlcm5UcmFuc2Zvcm0oKTsKICAgICAgICAgaWYg KCFwYXR0ZXJuVHJhbnNmb3JtLmlzSWRlbnRpdHkoKSkKLSAgICAgICAgICAgIHBhdHRlcm5EYXRh LT50cmFuc2Zvcm0ubXVsdGlwbHkocGF0dGVyblRyYW5zZm9ybSk7CisgICAgICAgICAgICBwYXR0 ZXJuRGF0YS0+dHJhbnNmb3JtID0gcGF0dGVyblRyYW5zZm9ybSAqIHBhdHRlcm5EYXRhLT50cmFu c2Zvcm07CiAKICAgICAgICAgcGF0dGVybkRhdGEtPnBhdHRlcm4tPnNldFBhdHRlcm5TcGFjZVRy YW5zZm9ybShwYXR0ZXJuRGF0YS0+dHJhbnNmb3JtKTsKICAgICB9CmRpZmYgLS1naXQgYS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJTVkdSb290LmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl clNWR1Jvb3QuY3BwCmluZGV4IDIxNWFhYzcyMTJjNzQ3YzY4YzZmMzQxMWU1MzJjZmZlNWRkZDNl YWQuLjU1NTAzMDMyOTVhODA5ZjE0MzBkMzBhYjQzMjU5M2Q5YzYyMjcyMWYgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclNWR1Jvb3QuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlclNWR1Jvb3QuY3BwCkBAIC0yNDYsNyArMjQ2LDcgQEAgQWZmaW5lVHJhbnNmb3Jt IFJlbmRlclNWR1Jvb3Q6OmxvY2FsVG9Cb3JkZXJCb3hUcmFuc2Zvcm0oKSBjb25zdAogICAgIGZs b2F0IHNjYWxlID0gc3ZnLT5jdXJyZW50U2NhbGUoKTsKICAgICBGbG9hdFBvaW50IHRyYW5zbGF0 ZSA9IHN2Zy0+Y3VycmVudFRyYW5zbGF0ZSgpOwogICAgIEFmZmluZVRyYW5zZm9ybSBjdG0oc2Nh bGUsIDAsIDAsIHNjYWxlLCBib3JkZXJBbmRQYWRkaW5nLndpZHRoKCkgKyB0cmFuc2xhdGUueCgp LCBib3JkZXJBbmRQYWRkaW5nLmhlaWdodCgpICsgdHJhbnNsYXRlLnkoKSk7Ci0gICAgcmV0dXJu IHN2Zy0+dmlld0JveFRvVmlld1RyYW5zZm9ybSh3aWR0aCgpIC8gc2NhbGUsIGhlaWdodCgpIC8g c2NhbGUpICogY3RtOworICAgIHJldHVybiBjdG0gKiBzdmctPnZpZXdCb3hUb1ZpZXdUcmFuc2Zv cm0od2lkdGgoKSAvIHNjYWxlLCBoZWlnaHQoKSAvIHNjYWxlKTsKIH0KIAogSW50U2l6ZSBSZW5k ZXJTVkdSb290OjpwYXJlbnRPcmlnaW5Ub0JvcmRlckJveCgpIGNvbnN0CmRpZmYgLS1naXQgYS9X ZWJDb3JlL3JlbmRlcmluZy9TVkdJbWFnZUJ1ZmZlclRvb2xzLmNwcCBiL1dlYkNvcmUvcmVuZGVy aW5nL1NWR0ltYWdlQnVmZmVyVG9vbHMuY3BwCmluZGV4IDIwZjQ1YjExYzU2MjY0YmVmNDIyYjk3 YmU0NWFjNjhlYTFkMTcyZjUuLmI1NjA1NjZlODAyMmFlMzc2MGY2OWY5MGVhNGQ2ZjhlOTk1NjY1 YmYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1NWR0ltYWdlQnVmZmVyVG9vbHMuY3Bw CisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL1NWR0ltYWdlQnVmZmVyVG9vbHMuY3BwCkBAIC00Myw3 ICs0Myw3IEBAIHZvaWQgU1ZHSW1hZ2VCdWZmZXJUb29sczo6Y2FsY3VsYXRlVHJhbnNmb3JtYXRp b25Ub091dGVybW9zdFNWR0Nvb3JkaW5hdGVTeXN0ZW0oCiAKICAgICBhYnNvbHV0ZVRyYW5zZm9y bSA9IGN1cnJlbnRDb250ZW50VHJhbnNmb3JtYXRpb24oKTsKICAgICB3aGlsZSAoY3VycmVudCkg ewotICAgICAgICBhYnNvbHV0ZVRyYW5zZm9ybS5tdWx0aXBseShjdXJyZW50LT5sb2NhbFRvUGFy ZW50VHJhbnNmb3JtKCkpOworICAgICAgICBhYnNvbHV0ZVRyYW5zZm9ybSA9IGN1cnJlbnQtPmxv Y2FsVG9QYXJlbnRUcmFuc2Zvcm0oKSAqIGFic29sdXRlVHJhbnNmb3JtOwogICAgICAgICBpZiAo Y3VycmVudC0+aXNTVkdSb290KCkpCiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY3VycmVu dCA9IGN1cnJlbnQtPnBhcmVudCgpOwpAQCAtOTEsNyArOTEsNyBAQCB2b2lkIFNWR0ltYWdlQnVm ZmVyVG9vbHM6OnJlbmRlclN1YnRyZWVUb0ltYWdlQnVmZmVyKEltYWdlQnVmZmVyKiBpbWFnZSwg UmVuZGVyTwogCiAgICAgQWZmaW5lVHJhbnNmb3JtJiBjb250ZW50VHJhbnNmb3JtYXRpb24gPSBj dXJyZW50Q29udGVudFRyYW5zZm9ybWF0aW9uKCk7CiAgICAgQWZmaW5lVHJhbnNmb3JtIHNhdmVk Q29udGVudFRyYW5zZm9ybWF0aW9uID0gY29udGVudFRyYW5zZm9ybWF0aW9uOwotICAgIGNvbnRl bnRUcmFuc2Zvcm1hdGlvbi5tdWx0aXBseShzdWJ0cmVlQ29udGVudFRyYW5zZm9ybWF0aW9uKTsK KyAgICBjb250ZW50VHJhbnNmb3JtYXRpb24gPSBzdWJ0cmVlQ29udGVudFRyYW5zZm9ybWF0aW9u ICogY29udGVudFRyYW5zZm9ybWF0aW9uOwogCiAgICAgaXRlbS0+bGF5b3V0SWZOZWVkZWQoKTsK ICAgICBpdGVtLT5wYWludChpbmZvLCAwLCAwKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVy aW5nL3N2Zy9TVkdUZXh0TGF5b3V0RW5naW5lLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9T VkdUZXh0TGF5b3V0RW5naW5lLmNwcAppbmRleCA3ZWVmYWQ2NTY2MzZkOTJlNTI2Yjk4OTRiNDll N2I1MTA0ZWY2ZGNmLi4zYjI4ZDJiZDE2ZTdiNTZmMzZkOWViYmIxNGUxNmRlODNjOGEwMWNkIDEw MDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvU1ZHVGV4dExheW91dEVuZ2luZS5jcHAK KysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1NWR1RleHRMYXlvdXRFbmdpbmUuY3BwCkBAIC0z MjEsNyArMzIxLDcgQEAgdm9pZCBTVkdUZXh0TGF5b3V0RW5naW5lOjpmaW5hbGl6ZVRyYW5zZm9y bU1hdHJpY2VzKFZlY3RvcjxTVkdJbmxpbmVUZXh0Qm94Kj4mIGIKICAgICAgICAgICAgIGlmICh0 cmFuc2Zvcm0uaXNJZGVudGl0eSgpKQogICAgICAgICAgICAgICAgIHRyYW5zZm9ybSA9IHRleHRC b3hUcmFuc2Zvcm1hdGlvbjsKICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICB0cmFu c2Zvcm0ubXVsdGlwbHkodGV4dEJveFRyYW5zZm9ybWF0aW9uKTsKKyAgICAgICAgICAgICAgICB0 cmFuc2Zvcm0gPSB0ZXh0Qm94VHJhbnNmb3JtYXRpb24gKiB0cmFuc2Zvcm07CiAgICAgICAgIH0K ICAgICB9CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3ZnL1NWR0xvY2F0YWJsZS5jcHAgYi9XZWJD b3JlL3N2Zy9TVkdMb2NhdGFibGUuY3BwCmluZGV4IDQzOTYxZDk1NDE5YmFhMzk2NDkyNmRkMTUw YTJmNDUyMTIzYjVkMTcuLjJhN2M5YmUwOWZkNjg1OGI3ZjAzYTZmMDc3ZThlMjQ2OGQzNWZkMzMg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3ZnL1NWR0xvY2F0YWJsZS5jcHAKKysrIGIvV2ViQ29yZS9z dmcvU1ZHTG9jYXRhYmxlLmNwcApAQCAtOTEsNyArOTEsOCBAQCBBZmZpbmVUcmFuc2Zvcm0gU1ZH TG9jYXRhYmxlOjpjb21wdXRlQ1RNKGNvbnN0IFNWR0VsZW1lbnQqIGVsZW1lbnQsIENUTVNjb3Bl IG1vZAogICAgIHdoaWxlIChjdXJyZW50ICYmIGN1cnJlbnQtPmlzU1ZHRWxlbWVudCgpKSB7CiAg ICAgICAgIFNWR0VsZW1lbnQqIGN1cnJlbnRFbGVtZW50ID0gc3RhdGljX2Nhc3Q8U1ZHRWxlbWVu dCo+KGN1cnJlbnQpOwogICAgICAgICBpZiAoY3VycmVudEVsZW1lbnQtPmlzU3R5bGVkKCkpCi0g ICAgICAgICAgICBjdG0gPSBzdGF0aWNfY2FzdDxTVkdTdHlsZWRFbGVtZW50Kj4oY3VycmVudEVs ZW1lbnQpLT5sb2NhbENvb3JkaW5hdGVTcGFjZVRyYW5zZm9ybShtb2RlKS5tdWx0TGVmdChjdG0p OworICAgICAgICAgICAgLy8gbm90ZSB0aGF0IHRoaXMgbW9kaWZpZXMgdGhlIEFmZmluZVRyYW5z Zm9ybSByZXR1cm5lZCBieSBsb2NhbENvb3JkaW5hdGVTcGFjZVRyYW5zZm9ybShtb2RlKSB0b28u CisgICAgICAgICAgICBjdG0gPSBzdGF0aWNfY2FzdDxTVkdTdHlsZWRFbGVtZW50Kj4oY3VycmVu dEVsZW1lbnQpLT5sb2NhbENvb3JkaW5hdGVTcGFjZVRyYW5zZm9ybShtb2RlKS5tdWx0aXBseShj dG0pOwogCiAgICAgICAgIC8vIEZvciBnZXRDVE0oKSBjb21wdXRhdGlvbiwgc3RvcCBhdCB0aGUg bmVhcmVzdCB2aWV3cG9ydCBlbGVtZW50CiAgICAgICAgIGlmIChjdXJyZW50RWxlbWVudCA9PSBz dG9wQXRFbGVtZW50KQpAQCAtMTEzLDcgKzExNCw3IEBAIEFmZmluZVRyYW5zZm9ybSBTVkdMb2Nh dGFibGU6OmdldFRyYW5zZm9ybVRvRWxlbWVudChTVkdFbGVtZW50KiB0YXJnZXQsIEV4Y2VwdGlv CiAgICAgICAgICAgICBlYyA9IFNWR0V4Y2VwdGlvbjo6U1ZHX01BVFJJWF9OT1RfSU5WRVJUQUJM RTsKICAgICAgICAgICAgIHJldHVybiBjdG07CiAgICAgICAgIH0KLSAgICAgICAgY3RtICo9IHRh cmdldENUTS5pbnZlcnNlKCk7CisgICAgICAgIGN0bSA9IHRhcmdldENUTS5pbnZlcnNlKCkgKiBj dG07CiAgICAgfQogCiAgICAgcmV0dXJuIGN0bTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3ZnL1NW R01hdHJpeC5oIGIvV2ViQ29yZS9zdmcvU1ZHTWF0cml4LmgKaW5kZXggODA3YjcwMzM4ZDc0N2U1 MWExMzIwZDNhNTQ5ZDc1OTU4MWE2ODdjNS4uMDc3ZWIwMzgzNDg2NjQ4NzRmN2JjNWJjMzBhYmFl MzNjMmY2Y2M3OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdmcvU1ZHTWF0cml4LmgKKysrIGIvV2Vi Q29yZS9zdmcvU1ZHTWF0cml4LmgKQEAgLTk2LDExICs5NiwxMCBAQCBwdWJsaWM6CiAgICAgICAg IHJldHVybiBzdGF0aWNfY2FzdDxTVkdNYXRyaXg+KGNvcHkpOwogICAgIH0KIAotICAgIC8vIFNW R01hdHJpeDo6bXVsdGlwbHkgbmVlZHMgdG8gY2FsbCBTVkdNYXRyaXg6Om11bHRMZWZ0LgogICAg IFNWR01hdHJpeCBtdWx0aXBseShjb25zdCBTVkdNYXRyaXgmIG90aGVyKQogICAgIHsKICAgICAg ICAgQWZmaW5lVHJhbnNmb3JtIGNvcHkgPSAqdGhpczsKLSAgICAgICAgY29weS5tdWx0TGVmdChz dGF0aWNfY2FzdDxjb25zdCBBZmZpbmVUcmFuc2Zvcm0mPihvdGhlcikpOworICAgICAgICBjb3B5 ICo9IHN0YXRpY19jYXN0PGNvbnN0IEFmZmluZVRyYW5zZm9ybSY+KG90aGVyKTsKICAgICAgICAg cmV0dXJuIHN0YXRpY19jYXN0PFNWR01hdHJpeD4oY29weSk7CiAgICAgfQogCmRpZmYgLS1naXQg YS9XZWJDb3JlL3N2Zy9TVkdTVkdFbGVtZW50LmNwcCBiL1dlYkNvcmUvc3ZnL1NWR1NWR0VsZW1l bnQuY3BwCmluZGV4IDhiMzNjODlmOGFlNWFmYmU4MWFlNmU3NjAyNTQ0NzE4Y2Y0YmUwZGUuLmMy MjI5MDg2ZjgyNjU4OThiMzc1MmFhYTk3MTk2N2Y4MTVmMDA2ZjMgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvc3ZnL1NWR1NWR0VsZW1lbnQuY3BwCisrKyBiL1dlYkNvcmUvc3ZnL1NWR1NWR0VsZW1lbnQu Y3BwCkBAIC01MDIsNyArNTAyLDcgQEAgQWZmaW5lVHJhbnNmb3JtIFNWR1NWR0VsZW1lbnQ6Omxv Y2FsQ29vcmRpbmF0ZVNwYWNlVHJhbnNmb3JtKFNWR0xvY2F0YWJsZTo6Q1RNU2MKICAgICAgICAg fQogICAgIH0KIAotICAgIHJldHVybiB0cmFuc2Zvcm0ubXVsdExlZnQodmlld0JveFRyYW5zZm9y bSk7CisgICAgcmV0dXJuIHRyYW5zZm9ybS5tdWx0aXBseSh2aWV3Qm94VHJhbnNmb3JtKTsKIH0K IAogUmVuZGVyT2JqZWN0KiBTVkdTVkdFbGVtZW50OjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVu YSogYXJlbmEsIFJlbmRlclN0eWxlKikKQEAgLTU4NywxMiArNTg3LDExIEBAIEFmZmluZVRyYW5z Zm9ybSBTVkdTVkdFbGVtZW50Ojp2aWV3Qm94VG9WaWV3VHJhbnNmb3JtKGZsb2F0IHZpZXdXaWR0 aCwgZmxvYXQgdmllCiAgICAgICAgIHZpZXdCb3hSZWN0ID0gdmlld0JveCgpOwogCiAgICAgQWZm aW5lVHJhbnNmb3JtIGN0bSA9IFNWR0ZpdFRvVmlld0JveDo6dmlld0JveFRvVmlld1RyYW5zZm9y bSh2aWV3Qm94UmVjdCwgcHJlc2VydmVBc3BlY3RSYXRpbygpLCB2aWV3V2lkdGgsIHZpZXdIZWln aHQpOworCiAgICAgaWYgKHVzZUN1cnJlbnRWaWV3KCkgJiYgY3VycmVudFZpZXcoKSkgewogICAg ICAgICBBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtOwotICAgICAgICBpZiAoIWN1cnJlbnRWaWV3 KCktPnRyYW5zZm9ybSgpLmNvbmNhdGVuYXRlKHRyYW5zZm9ybSkpCi0gICAgICAgICAgICByZXR1 cm4gY3RtOwotCi0gICAgICAgIHJldHVybiB0cmFuc2Zvcm0gKiBjdG07CisgICAgICAgIGlmIChj dXJyZW50VmlldygpLT50cmFuc2Zvcm0oKS5jb25jYXRlbmF0ZSh0cmFuc2Zvcm0pKQorICAgICAg ICAgICAgY3RtICo9IHRyYW5zZm9ybTsKICAgICB9CiAKICAgICByZXR1cm4gY3RtOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9zdmcvU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQuY3BwIGIvV2Vi Q29yZS9zdmcvU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQuY3BwCmluZGV4IDcxYmUwMWRl NThlZWI4YjkwYzc0NTJiZmU1ZDQ2NmJmZmUxZjFkM2IuLjVhMmVlYmJlNWY2MmM5OTk4N2JmOTJi NDI0MTk0OTFiOTliNjNhMGQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3ZnL1NWR1N0eWxlZFRyYW5z Zm9ybWFibGVFbGVtZW50LmNwcAorKysgYi9XZWJDb3JlL3N2Zy9TVkdTdHlsZWRUcmFuc2Zvcm1h YmxlRWxlbWVudC5jcHAKQEAgLTU2LDcgKzU2LDkgQEAgQWZmaW5lVHJhbnNmb3JtIFNWR1N0eWxl ZFRyYW5zZm9ybWFibGVFbGVtZW50OjphbmltYXRlZExvY2FsVHJhbnNmb3JtKCkgY29uc3QKIHsK ICAgICBBZmZpbmVUcmFuc2Zvcm0gbWF0cml4OwogICAgIHRyYW5zZm9ybSgpLmNvbmNhdGVuYXRl KG1hdHJpeCk7Ci0gICAgcmV0dXJuIG1fc3VwcGxlbWVudGFsVHJhbnNmb3JtID8gKm1fc3VwcGxl bWVudGFsVHJhbnNmb3JtICogbWF0cml4IDogbWF0cml4OworICAgIGlmIChtX3N1cHBsZW1lbnRh bFRyYW5zZm9ybSkKKyAgICAgICAgbWF0cml4ICo9ICptX3N1cHBsZW1lbnRhbFRyYW5zZm9ybTsK KyAgICByZXR1cm4gbWF0cml4OwogfQogCiBBZmZpbmVUcmFuc2Zvcm0qIFNWR1N0eWxlZFRyYW5z Zm9ybWFibGVFbGVtZW50OjpzdXBwbGVtZW50YWxUcmFuc2Zvcm0oKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9zdmcvU1ZHVGV4dEVsZW1lbnQuY3BwIGIvV2ViQ29yZS9zdmcvU1ZHVGV4dEVsZW1lbnQu Y3BwCmluZGV4IDcyMjk4MjQ1YzU2ZmU0MjU2ZTg1YTQ0YTlmNzU5NjFhMTc2NjRiM2QuLmI2MDk0 YzkwMTY3ZjA1NGM0ODQwYjgwZGIzMDNhNmMzZjIxMmE1ZDggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv c3ZnL1NWR1RleHRFbGVtZW50LmNwcAorKysgYi9XZWJDb3JlL3N2Zy9TVkdUZXh0RWxlbWVudC5j cHAKQEAgLTg5LDcgKzg5LDkgQEAgQWZmaW5lVHJhbnNmb3JtIFNWR1RleHRFbGVtZW50Ojphbmlt YXRlZExvY2FsVHJhbnNmb3JtKCkgY29uc3QKIHsKICAgICBBZmZpbmVUcmFuc2Zvcm0gbWF0cml4 OwogICAgIHRyYW5zZm9ybSgpLmNvbmNhdGVuYXRlKG1hdHJpeCk7Ci0gICAgcmV0dXJuIG1fc3Vw cGxlbWVudGFsVHJhbnNmb3JtID8gKm1fc3VwcGxlbWVudGFsVHJhbnNmb3JtICogbWF0cml4IDog bWF0cml4OworICAgIGlmIChtX3N1cHBsZW1lbnRhbFRyYW5zZm9ybSkKKyAgICAgICAgbWF0cml4 ICo9ICptX3N1cHBsZW1lbnRhbFRyYW5zZm9ybTsKKyAgICByZXR1cm4gbWF0cml4OwogfQogCiBB ZmZpbmVUcmFuc2Zvcm0qIFNWR1RleHRFbGVtZW50OjpzdXBwbGVtZW50YWxUcmFuc2Zvcm0oKQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9zdmcvU1ZHVHJhbnNmb3JtTGlzdC5jcHAgYi9XZWJDb3JlL3N2 Zy9TVkdUcmFuc2Zvcm1MaXN0LmNwcAppbmRleCA3NTliMDY0NDMwNDU2ZDFlMTJlYTM1MGRmOTUw OGIxYTA5MWQwNDc5Li40NzZlOTQ5ZGE2NWM0ODFiMWVkNzVjOWJlNzMzY2YzMTBhNTU3NWRhIDEw MDY0NAotLS0gYS9XZWJDb3JlL3N2Zy9TVkdUcmFuc2Zvcm1MaXN0LmNwcAorKysgYi9XZWJDb3Jl L3N2Zy9TVkdUcmFuc2Zvcm1MaXN0LmNwcApAQCAtNTUsNyArNTUsNyBAQCBib29sIFNWR1RyYW5z Zm9ybUxpc3Q6OmNvbmNhdGVuYXRlKEFmZmluZVRyYW5zZm9ybSYgcmVzdWx0KSBjb25zdAogICAg ICAgICByZXR1cm4gZmFsc2U7CiAKICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgc2l6ZTsg KytpKQotICAgICAgICByZXN1bHQgPSBhdChpKS5tYXRyaXgoKSAqIHJlc3VsdDsKKyAgICAgICAg cmVzdWx0ICo9IGF0KGkpLm1hdHJpeCgpOwogCiAgICAgcmV0dXJuIHRydWU7CiB9Cg== 78494 2011-01-10 22:25:12 -0800 2011-01-10 22:31:15 -0800 Patch bug-48031-20110111172509.patch text/plain 24187 shanestephens ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxZTUzNTA1ZGQ4YTYzY2E5ZTA5MjFiYTBmZDM0ODcyMjc5MDJiMmVlLi44 NzViNTg1ZTk4YzI5ZTkxODkyNTVhMjllZDcyYTM4Yzc0ZTA0YWJmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsNjggQEAKKzIwMTEtMDEtMTAgIFNoYW5lIFN0ZXBoZW5zICA8c2hhbmVzdGVwaGVuc0Bn b29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE1ha2UgQWZmaW5lVHJhbnNmb3JtIGFuZCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBkbyBtYXRy aXggbXVsdGlwbGljYXRpb24gaW4gdGhlIGNvcnJlY3Qgb3JkZXIgKENvbHVtbiBNYWpvcikKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ4MDMxCisKKwlG aXhlZCByZXZlcnNhbCwgcmVuYW1lZCBtYXRyaXggbWV0aG9kcyB0byBiZSBjbGVhcmVyLCBmb3Vu ZCBhbGwgZXhhbXBsZXMgb2Ygb3BlcmF0b3IqIGFuZAorCW9wZXJhdG9yKj0gdXNhZ2UgYW5kIHN3 aXRjaGVkIG9wZXJhbmQgb3JkZXIuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIGFzIHRoaXMgcmVm YWN0b3IgZG9lc24ndCBhZGQgZnVuY3Rpb25hbGl0eS4KKworICAgICAgICAqIGh0bWwvSFRNTENh bnZhc0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTENhbnZhc0VsZW1lbnQ6OmJh c2VUcmFuc2Zvcm0pOgorICAgICAgICAqIGh0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRl eHQyRC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OnRy YW5zZm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OnNl dFRyYW5zZm9ybSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0dGVybkNHLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlBhdHRlcm46OmNyZWF0ZVBsYXRmb3JtUGF0dGVybik6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJDYW52YXMuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6R0xFUzJDYW52YXM6OmZpbGxSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6 OkdMRVMyQ2FudmFzOjpjb25jYXRDVE0pOgorICAgICAgICAoV2ViQ29yZTo6R0xFUzJDYW52YXM6 OmRyYXdRdWFkKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UcmFuc3Bh cmVuY3lXaW4uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VHJhbnNwYXJlbmN5V2luOjpzZXR1cExh eWVyRm9yT3BhcXVlQ29tcG9zaXRlTGF5ZXIpOgorICAgICAgICAoV2ViQ29yZTo6VHJhbnNwYXJl bmN5V2luOjpzZXR1cFRyYW5zZm9ybUZvcktlZXBUcmFuc2Zvcm0pOgorICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkFmZmluZVRyYW5zZm9ybTo6bXVsdGlwbHkpOgorICAgICAgICAoV2ViQ29yZTo6QWZm aW5lVHJhbnNmb3JtOjpyb3RhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3RyYW5z Zm9ybXMvQWZmaW5lVHJhbnNmb3JtLmg6CisgICAgICAgIChXZWJDb3JlOjpBZmZpbmVUcmFuc2Zv cm06Om9wZXJhdG9yKj0pOgorICAgICAgICAoV2ViQ29yZTo6QWZmaW5lVHJhbnNmb3JtOjpvcGVy YXRvciopOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL0dyYXBoaWNzQ29udGV4 dFdpbkNFLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dFBsYXRmb3JtUHJp dmF0ZTo6Y29uY2F0Q1RNKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9TaGFy ZWRCaXRtYXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQml0bWFwOjpkcmF3UGF0dGVy bik6CisgICAgICAgICogcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lcjo6dHJhbnNm b3JtT25Ob25TY2FsaW5nU3Ryb2tlKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1JlbmRlclNW R1Jlc291cmNlR3JhZGllbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y2xpcFRvVGV4dE1hc2sp OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyU1ZHUmVzb3VyY2VHcmFkaWVudDo6YXBwbHlSZXNv dXJjZSk6CisgICAgICAgICogcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZVBhdHRlcm4u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyU1ZHUmVzb3VyY2VQYXR0ZXJuOjphcHBseVJl c291cmNlKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jvb3QuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6UmVuZGVyU1ZHUm9vdDo6bG9jYWxUb0JvcmRlckJveFRyYW5zZm9ybSk6 CisgICAgICAgICogcmVuZGVyaW5nL3N2Zy9TVkdJbWFnZUJ1ZmZlclRvb2xzLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlNWR0ltYWdlQnVmZmVyVG9vbHM6OmNhbGN1bGF0ZVRyYW5zZm9ybWF0aW9u VG9PdXRlcm1vc3RTVkdDb29yZGluYXRlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OlNWR0lt YWdlQnVmZmVyVG9vbHM6OnJlbmRlclN1YnRyZWVUb0ltYWdlQnVmZmVyKToKKyAgICAgICAgKiBy ZW5kZXJpbmcvc3ZnL1NWR1RleHRMYXlvdXRFbmdpbmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 U1ZHVGV4dExheW91dEVuZ2luZTo6ZmluYWxpemVUcmFuc2Zvcm1NYXRyaWNlcyk6CisgICAgICAg ICogc3ZnL1NWR0xvY2F0YWJsZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTVkdMb2NhdGFibGU6 OmNvbXB1dGVDVE0pOgorICAgICAgICAoV2ViQ29yZTo6U1ZHTG9jYXRhYmxlOjpnZXRUcmFuc2Zv cm1Ub0VsZW1lbnQpOgorICAgICAgICAqIHN2Zy9TVkdNYXRyaXguaDoKKyAgICAgICAgKFdlYkNv cmU6OlNWR01hdHJpeDo6bXVsdGlwbHkpOgorICAgICAgICAqIHN2Zy9TVkdTVkdFbGVtZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1NWR0VsZW1lbnQ6OmxvY2FsQ29vcmRpbmF0ZVNwYWNl VHJhbnNmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OlNWR1NWR0VsZW1lbnQ6OnZpZXdCb3hUb1Zp ZXdUcmFuc2Zvcm0pOgorICAgICAgICAqIHN2Zy9TVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVu dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVudDo6 YW5pbWF0ZWRMb2NhbFRyYW5zZm9ybSk6CisgICAgICAgICogc3ZnL1NWR1RleHRFbGVtZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1RleHRFbGVtZW50OjphbmltYXRlZExvY2FsVHJhbnNm b3JtKToKKyAgICAgICAgKiBzdmcvU1ZHVHJhbnNmb3JtTGlzdC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpTVkdUcmFuc2Zvcm1MaXN0Ojpjb25jYXRlbmF0ZSk6CisKIDIwMTAtMTAtMTAgIERhdmlk IEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9uIEZy YXNlci4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTENhbnZhc0VsZW1lbnQu Y3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQ2FudmFzRWxlbWVudC5jcHAKaW5kZXggZjI4 Njc0OTM2OGE5NTM4NDBiMDU3NmY0MDc3MDk0N2FmNzM4ODE2Zi4uOWQxNWU0NjE0NzJhZmMxNDFh ZDA0OTI3YzY5YjExYzgxYjYyNTY4NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MQ2FudmFzRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQ2FudmFz RWxlbWVudC5jcHAKQEAgLTQ0Niw4ICs0NDYsNyBAQCBBZmZpbmVUcmFuc2Zvcm0gSFRNTENhbnZh c0VsZW1lbnQ6OmJhc2VUcmFuc2Zvcm0oKSBjb25zdAogICAgIEFmZmluZVRyYW5zZm9ybSB0cmFu c2Zvcm07CiAgICAgaWYgKHNpemUud2lkdGgoKSAmJiBzaXplLmhlaWdodCgpKQogICAgICAgICB0 cmFuc2Zvcm0uc2NhbGVOb25Vbmlmb3JtKHNpemUud2lkdGgoKSAvIHVuc2NhbGVkU2l6ZS53aWR0 aCgpLCBzaXplLmhlaWdodCgpIC8gdW5zY2FsZWRTaXplLmhlaWdodCgpKTsKLSAgICB0cmFuc2Zv cm0ubXVsdGlwbHkobV9pbWFnZUJ1ZmZlci0+YmFzZVRyYW5zZm9ybSgpKTsKLSAgICByZXR1cm4g dHJhbnNmb3JtOworICAgIHJldHVybiBtX2ltYWdlQnVmZmVyLT5iYXNlVHJhbnNmb3JtKCkgKiB0 cmFuc2Zvcm07CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFz L0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZh cy9DYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwCmluZGV4IDYyYzU3OTM3YTYxNWNjNTQ4ZjZm MmU2MDM3ZDdlMTdhYjM3NDM2YjAuLmQ0Y2JiMTc3Y2JkOWU2MzdmN2YzMDA3NDlmNzY3OWYwN2Uz N2FjNzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL0NhbnZhc1JlbmRl cmluZ0NvbnRleHQyRC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvQ2FudmFz UmVuZGVyaW5nQ29udGV4dDJELmNwcApAQCAtNTM3LDcgKzUzNyw3IEBAIHZvaWQgQ2FudmFzUmVu ZGVyaW5nQ29udGV4dDJEOjp0cmFuc2Zvcm0oZmxvYXQgbTExLCBmbG9hdCBtMTIsIGZsb2F0IG0y MSwgZmxvYXQKICAgICAgICAgcmV0dXJuOwogCiAgICAgQWZmaW5lVHJhbnNmb3JtIHRyYW5zZm9y bShtMTEsIG0xMiwgbTIxLCBtMjIsIGR4LCBkeSk7Ci0gICAgQWZmaW5lVHJhbnNmb3JtIG5ld1Ry YW5zZm9ybSA9IHRyYW5zZm9ybSAqIHN0YXRlKCkubV90cmFuc2Zvcm07CisgICAgQWZmaW5lVHJh bnNmb3JtIG5ld1RyYW5zZm9ybSA9IHN0YXRlKCkubV90cmFuc2Zvcm0gKiB0cmFuc2Zvcm07CiAg ICAgaWYgKCFuZXdUcmFuc2Zvcm0uaXNJbnZlcnRpYmxlKCkpIHsKICAgICAgICAgc3RhdGUoKS5t X2ludmVydGlibGVDVE0gPSBmYWxzZTsKICAgICAgICAgcmV0dXJuOwpAQCAtNTYyLDcgKzU2Miw3 IEBAIHZvaWQgQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjpzZXRUcmFuc2Zvcm0oZmxvYXQgbTEx LCBmbG9hdCBtMTIsIGZsb2F0IG0yMSwgZmxvCiAgICAgICAgIHJldHVybjsKICAgICBjLT5jb25j YXRDVE0oYy0+Z2V0Q1RNKCkuaW52ZXJzZSgpKTsKICAgICBjLT5jb25jYXRDVE0oY2FudmFzKCkt PmJhc2VUcmFuc2Zvcm0oKSk7Ci0gICAgc3RhdGUoKS5tX3RyYW5zZm9ybS5tdWx0aXBseShjdG0u aW52ZXJzZSgpKTsKKyAgICBzdGF0ZSgpLm1fdHJhbnNmb3JtID0gY3RtLmludmVyc2UoKSAqIHN0 YXRlKCkubV90cmFuc2Zvcm07CiAgICAgbV9wYXRoLnRyYW5zZm9ybShjdG0pOwogCiAgICAgc3Rh dGUoKS5tX2ludmVydGlibGVDVE0gPSB0cnVlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0dGVybkNHLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2NnL1BhdHRlcm5DRy5jcHAKaW5kZXggOTRmMzdiMmZmMWNmNjE5NjdlYmVm Zjg3MWQ2NTRjZTRhY2RlNDQyOS4uY2ZhYzE1YzM3ZjY2YzBkZmE0MzY0NWQ3OTAzNmExMWU5ZjY5 MzBmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0 dGVybkNHLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXR0 ZXJuQ0cuY3BwCkBAIC01NCw4ICs1NCw3IEBAIENHUGF0dGVyblJlZiBQYXR0ZXJuOjpjcmVhdGVQ bGF0Zm9ybVBhdHRlcm4oY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB1c2VyU3BhY2VUcmFuCiB7CiAg ICAgSW50UmVjdCB0aWxlUmVjdCA9IHRpbGVJbWFnZSgpLT5yZWN0KCk7CiAKLSAgICBBZmZpbmVU cmFuc2Zvcm0gcGF0dGVyblRyYW5zZm9ybSA9IG1fcGF0dGVyblNwYWNlVHJhbnNmb3JtYXRpb247 Ci0gICAgcGF0dGVyblRyYW5zZm9ybS5tdWx0aXBseSh1c2VyU3BhY2VUcmFuc2Zvcm1hdGlvbik7 CisgICAgQWZmaW5lVHJhbnNmb3JtIHBhdHRlcm5UcmFuc2Zvcm0gPSB1c2VyU3BhY2VUcmFuc2Zv cm1hdGlvbiAqIG1fcGF0dGVyblNwYWNlVHJhbnNmb3JtYXRpb247CiAgICAgcGF0dGVyblRyYW5z Zm9ybS5zY2FsZU5vblVuaWZvcm0oMSwgLTEpOwogICAgIHBhdHRlcm5UcmFuc2Zvcm0udHJhbnNs YXRlKDAsIC10aWxlUmVjdC5oZWlnaHQoKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFzLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFzLmNwcAppbmRleCA2OTdj ZjVlOTJkNTU5M2ViNjJmYzgzNWUyNmNmNGJiODUwZjEwNzJlLi5hZTAxN2RlZWNkZTU0MjVhMzVm OWNmZGU0MzU0YmVkODZlMzQxN2UwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9HTEVTMkNhbnZhcy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJDYW52YXMuY3BwCkBAIC0xMDgsNyArMTA4 LDcgQEAgdm9pZCBHTEVTMkNhbnZhczo6ZmlsbFJlY3QoY29uc3QgRmxvYXRSZWN0JiByZWN0LCBj b25zdCBDb2xvciYgY29sb3IsIENvbG9yU3BhY2UKICAgICBtX2NvbnRleHQtPnVzZVF1YWRWZXJ0 aWNlcygpOwogCiAgICAgQWZmaW5lVHJhbnNmb3JtIG1hdHJpeChtX2ZsaXBNYXRyaXgpOwotICAg IG1hdHJpeC5tdWx0TGVmdChtX3N0YXRlLT5tX2N0bSk7CisgICAgbWF0cml4ICo9IG1fc3RhdGUt Pm1fY3RtOwogICAgIG1hdHJpeC50cmFuc2xhdGUocmVjdC54KCksIHJlY3QueSgpKTsKICAgICBt YXRyaXguc2NhbGUocmVjdC53aWR0aCgpLCByZWN0LmhlaWdodCgpKTsKIApAQCAtMTUwLDcgKzE1 MCw3IEBAIHZvaWQgR0xFUzJDYW52YXM6OnNjYWxlKGNvbnN0IEZsb2F0U2l6ZSYgc2l6ZSkKIAog dm9pZCBHTEVTMkNhbnZhczo6Y29uY2F0Q1RNKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgYWZmaW5l KQogewotICAgIG1fc3RhdGUtPm1fY3RtLm11bHRMZWZ0KGFmZmluZSk7CisgICAgbV9zdGF0ZS0+ bV9jdG0gKj0gYWZmaW5lOwogfQogCiB2b2lkIEdMRVMyQ2FudmFzOjpzYXZlKCkKQEAgLTIyMCw3 ICsyMjAsNyBAQCB2b2lkIEdMRVMyQ2FudmFzOjpkcmF3VGV4dHVyZWRSZWN0VGlsZShUZXh0dXJl KiB0ZXh0dXJlLCBpbnQgdGlsZSwgY29uc3QgRmxvYXRSZQogdm9pZCBHTEVTMkNhbnZhczo6ZHJh d1F1YWQoY29uc3QgSW50U2l6ZSYgdGV4dHVyZVNpemUsIGNvbnN0IEZsb2F0UmVjdCYgc3JjUmVj dCwgY29uc3QgRmxvYXRSZWN0JiBkc3RSZWN0LCBjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5z Zm9ybSwgZmxvYXQgYWxwaGEpCiB7CiAgICAgQWZmaW5lVHJhbnNmb3JtIG1hdHJpeChtX2ZsaXBN YXRyaXgpOwotICAgIG1hdHJpeC5tdWx0TGVmdCh0cmFuc2Zvcm0pOworICAgIG1hdHJpeCAqPSB0 cmFuc2Zvcm07CiAgICAgbWF0cml4LnRyYW5zbGF0ZShkc3RSZWN0LngoKSwgZHN0UmVjdC55KCkp OwogICAgIG1hdHJpeC5zY2FsZShkc3RSZWN0LndpZHRoKCksIGRzdFJlY3QuaGVpZ2h0KCkpOwog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U cmFuc3BhcmVuY3lXaW4uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vVHJhbnNwYXJlbmN5V2luLmNwcAppbmRleCA0ZGMyMTU3MDQ4ODBkMTRmODlmNTVmMTlh NGJiNTk5MzUzMWJlMWRjLi5iYTY2ZWFlNDY0NDNkMzM2N2U4ZTUwMzY1ZTM0MjM2MWI4NTQ2MWU1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U cmFuc3BhcmVuY3lXaW4uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHAKQEAgLTI1Miw3ICsyNTIsNyBAQCB2b2lkIFRy YW5zcGFyZW5jeVdpbjo6c2V0dXBMYXllckZvck9wYXF1ZUNvbXBvc2l0ZUxheWVyKCkKICAgICBp ZiAobV90cmFuc2Zvcm1Nb2RlID09IFVudHJhbnNmb3JtKXsgCiAgICAgICAgIC8vIENvbXB1dGUg dGhlIGludmVyc2UgbWFwcGluZyBmcm9tIHRoZSBjYW52YXMgc3BhY2UgdG8gdGhlCiAgICAgICAg IC8vIGNvb3JkaW5hdGUgc3BhY2Ugb2Ygb3VyIGJpdG1hcC4KLSAgICAgICAgbWFwcGluZyA9IG1f b3JnVHJhbnNmb3JtLmludmVyc2UoKSAqIG1hcHBpbmc7CisgICAgICAgIG1hcHBpbmcgKj0gbV9v cmdUcmFuc2Zvcm0uaW52ZXJzZSgpOwogICAgIH0KICAgICBjb21wb3NpdGVUb0NvcHkoKm1fZGVz dENvbnRleHQsICptX2RyYXdDb250ZXh0LCBtYXBwaW5nKTsKIApAQCAtMzEzLDcgKzMxMyw3IEBA IHZvaWQgVHJhbnNwYXJlbmN5V2luOjpzZXR1cFRyYW5zZm9ybUZvcktlZXBUcmFuc2Zvcm0oY29u c3QgSW50UmVjdCYgcmVnaW9uKQogICAgICAgICAvLyBXZSdyZSBtYWtpbmcgYSBsYXllciwgc28g YXBwbHkgdGhlIG9sZCB0cmFuc2Zvcm0gdG8gdGhlIG5ldyBvbmUKICAgICAgICAgLy8gc28gaXQn cyBtYWludGFpbmVkLiBXZSBrbm93IHRoZSBuZXcgbGF5ZXIgaGFzIHRoZSBpZGVudGl0eQogICAg ICAgICAvLyB0cmFuc2Zvcm0gbm93LCB3ZSB3ZSBjYW4ganVzdCBtdWx0aXBseSBpdC4KLSAgICAg ICAgeGZvcm0gPSBtX29yZ1RyYW5zZm9ybSAqIHhmb3JtOworICAgICAgICB4Zm9ybSAqPSBtX29y Z1RyYW5zZm9ybTsKICAgICAgICAgbV9kcmF3Q29udGV4dC0+Y29uY2F0Q1RNKHhmb3JtKTsKICAg ICB9CiAgICAgbV9kcmF3UmVjdCA9IG1fc291cmNlUmVjdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNm b3JtLmNwcAppbmRleCBmMjc1NTI2YmQ0MDYzYmIxNmU3ZTAyNmJjZDM3MzA3OTZhNTVkYWM1Li4z Zjg4MTQwNjhjNGQ4YjI0NjI4ZmEyM2Y3MzZkNDBiZWVmN2RiZDkxIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZp bmVUcmFuc2Zvcm0uY3BwCkBAIC0xNjQsMTIgKzE2NCwxMCBAQCBBZmZpbmVUcmFuc2Zvcm0gQWZm aW5lVHJhbnNmb3JtOjppbnZlcnNlKCkgY29uc3QKICAgICByZXR1cm4gcmVzdWx0OwogfQogCi1B ZmZpbmVUcmFuc2Zvcm0mIEFmZmluZVRyYW5zZm9ybTo6bXVsdGlwbHkoY29uc3QgQWZmaW5lVHJh bnNmb3JtJiBvdGhlcikKLXsKLSAgICByZXR1cm4gKCp0aGlzKSAqPSBvdGhlcjsKLX0KIAotQWZm aW5lVHJhbnNmb3JtJiBBZmZpbmVUcmFuc2Zvcm06Om11bHRMZWZ0KGNvbnN0IEFmZmluZVRyYW5z Zm9ybSYgb3RoZXIpCisvLyBNdWx0aXBsaWVzIHRoaXMgQWZmaW5lVHJhbnNmb3JtIGJ5IHRoZSBw cm92aWRlZCBBZmZpbmVUcmFuc2Zvcm0gLSBpLmUuCisvLyB0aGlzID0gdGhpcyAqIG90aGVyOwor QWZmaW5lVHJhbnNmb3JtJiBBZmZpbmVUcmFuc2Zvcm06Om11bHRpcGx5KGNvbnN0IEFmZmluZVRy YW5zZm9ybSYgb3RoZXIpCiB7CiAgICAgQWZmaW5lVHJhbnNmb3JtIHRyYW5zOwogICAgIApAQCAt MTkyLDcgKzE5MCw3IEBAIEFmZmluZVRyYW5zZm9ybSYgQWZmaW5lVHJhbnNmb3JtOjpyb3RhdGUo ZG91YmxlIGEpCiAgICAgZG91YmxlIHNpbkFuZ2xlID0gc2luKGEpOwogICAgIEFmZmluZVRyYW5z Zm9ybSByb3QoY29zQW5nbGUsIHNpbkFuZ2xlLCAtc2luQW5nbGUsIGNvc0FuZ2xlLCAwLCAwKTsK IAotICAgIG11bHRMZWZ0KHJvdCk7CisgICAgbXVsdGlwbHkocm90KTsKICAgICByZXR1cm4gKnRo aXM7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3Ry YW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy90cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5oCmluZGV4IGJhZWUxMDJhOTU2Y2E4MjM5 MjRmNmE5YTUwYWJlNzcwODkwNTg0NzkuLmMwYjUwMWQxOWE1NTY1YTM5ZGRiZDhlZGRmMmQ4OWVi YzA1NDFhNjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3Ry YW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uaApAQCAtOTUsOCArOTUsNyBAQCBw dWJsaWM6CiAKICAgICB2b2lkIG1ha2VJZGVudGl0eSgpOwogCi0gICAgQWZmaW5lVHJhbnNmb3Jt JiBtdWx0aXBseShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKLSAgICBBZmZpbmVUcmFuc2Zvcm0m IG11bHRMZWZ0KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYpOworICAgIEFmZmluZVRyYW5zZm9ybSYg bXVsdGlwbHkoY29uc3QgQWZmaW5lVHJhbnNmb3JtJiBvdGhlcik7CiAgICAgQWZmaW5lVHJhbnNm b3JtJiBzY2FsZShkb3VibGUpOyAKICAgICBBZmZpbmVUcmFuc2Zvcm0mIHNjYWxlKGRvdWJsZSBz eCwgZG91YmxlIHN5KTsgCiAgICAgQWZmaW5lVHJhbnNmb3JtJiBzY2FsZU5vblVuaWZvcm0oZG91 YmxlIHN4LCBkb3VibGUgc3kpOwpAQCAtMTQ3LDE1ICsxNDYsMTQgQEAgcHVibGljOgogICAgIC8v ICp0aGlzID0gKnRoaXMgKiB0IChpLmUuLCBhIG11bHRSaWdodCkKICAgICBBZmZpbmVUcmFuc2Zv cm0mIG9wZXJhdG9yKj0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0KQogICAgIHsKLSAgICAgICAg KnRoaXMgPSAqdGhpcyAqIHQ7Ci0gICAgICAgIHJldHVybiAqdGhpczsKKyAgICAgICAgcmV0dXJu IHRoaXMtPm11bHRpcGx5KHQpOwogICAgIH0KICAgICAKICAgICAvLyByZXN1bHQgPSAqdGhpcyAq IHQgKGkuZS4sIGEgbXVsdFJpZ2h0KQogICAgIEFmZmluZVRyYW5zZm9ybSBvcGVyYXRvciooY29u c3QgQWZmaW5lVHJhbnNmb3JtJiB0KSBjb25zdAogICAgIHsKLSAgICAgICAgQWZmaW5lVHJhbnNm b3JtIHJlc3VsdCA9IHQ7Ci0gICAgICAgIHJlc3VsdC5tdWx0TGVmdCgqdGhpcyk7CisgICAgICAg IEFmZmluZVRyYW5zZm9ybSByZXN1bHQgPSAqdGhpczsKKyAgICAgICAgcmVzdWx0ICo9IHQ7CiAg ICAgICAgIHJldHVybiByZXN1bHQ7CiAgICAgfQogCkBAIC0xODEsNiArMTc5LDggQEAgcHJpdmF0 ZToKICAgICB9CiAKICAgICBUcmFuc2Zvcm0gbV90cmFuc2Zvcm07CisKKyAgICBBZmZpbmVUcmFu c2Zvcm0mIHBvc3RNdWx0aXBseShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKIH07CiAKIEFmZmlu ZVRyYW5zZm9ybSBtYWtlTWFwQmV0d2VlblJlY3RzKGNvbnN0IEZsb2F0UmVjdCYgc291cmNlLCBj b25zdCBGbG9hdFJlY3QmIGRlc3QpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250ZXh0V2luQ0UuY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250ZXh0V2luQ0UuY3BwCmluZGV4 IDJkZWY2YWI4OTY2MGYxZTA5MDQ4OWU5OTRlYTNkNGU2NjA5MWQxODEuLjFiOGE3MDQ3YTQ0OTIx ODg3OTYwOTJiMDZmNTA3NjI5MjVmZGI1NGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL3dpbmNlL0dyYXBoaWNzQ29udGV4dFdpbkNFLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGljc0NvbnRleHRXaW5DRS5j cHAKQEAgLTIwOSw3ICsyMDksNyBAQCBwdWJsaWM6CiAKICAgICB2b2lkICBjb25jYXRDVE0oY29u c3QgQWZmaW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0pCiAgICAgewotICAgICAgICBtX3RyYW5zZm9y bSA9IHRyYW5zZm9ybSAqIG1fdHJhbnNmb3JtOworICAgICAgICBtX3RyYW5zZm9ybSAqPSB0cmFu c2Zvcm07CiAgICAgfQogCiAgICAgSW50UmVjdCBtYXBSZWN0KGNvbnN0IEludFJlY3QmIHJlY3Qp IGNvbnN0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5j ZS9TaGFyZWRCaXRtYXAuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2lu Y2UvU2hhcmVkQml0bWFwLmNwcAppbmRleCAwNWQxNTM1ZmU5YTlkZjc3YjdjNmZlZTU1MDg0Zjcx MmQwYmI4NGMzLi4xNjhhNWUyMzA4MTRiZjA3ZDlmM2MxYjRlY2RmOTJkYjA4YjMzNjUzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9TaGFyZWRCaXRt YXAuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL1NoYXJl ZEJpdG1hcC5jcHAKQEAgLTQ0NSw4ICs0NDUsNyBAQCB2b2lkIFNoYXJlZEJpdG1hcDo6ZHJhd1Bh dHRlcm4oSERDIGhkYywgY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0sIGNvbnN0CiAg ICAgICAgIGJtcEhlaWdodCA9IHRpbGVSZWN0LmhlaWdodCgpOwogICAgIH0KIAotICAgIEFmZmlu ZVRyYW5zZm9ybSB0ZiA9IHRyYW5zZm9ybTsKLSAgICB0ZiAqPSBwYXR0ZXJuVHJhbnNmb3JtOwor ICAgIEFmZmluZVRyYW5zZm9ybSB0ZiA9IHBhdHRlcm5UcmFuc2Zvcm0gKiB0cmFuc2Zvcm07CiAK ICAgICBGbG9hdFJlY3QgdHJSZWN0ID0gdGYubWFwUmVjdChkZXN0UmVjdCk7CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUmVzb3VyY2VDb250YWlu ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZUNv bnRhaW5lci5jcHAKaW5kZXggMmE4YTQ3ZmI5MzQ0N2FjZDViNjhjMmIxNjc1YWY1ODYxYWZiY2E5 OC4uZDViY2RmODU5NGU4YjI4YzlhZjg5MTE0ZWEwMTc4OTUxZTI1MzU4YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lci5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZUNv bnRhaW5lci5jcHAKQEAgLTE1LDYgKzE1LDcgQEAKICAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5 OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCiAgKiB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZs b29yLAogICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKgogICovCiAKICNpbmNsdWRl ICJjb25maWcuaCIKQEAgLTE4Miw4ICsxODMsOCBAQCBBZmZpbmVUcmFuc2Zvcm0gUmVuZGVyU1ZH UmVzb3VyY2VDb250YWluZXI6OnRyYW5zZm9ybU9uTm9uU2NhbGluZ1N0cm9rZShSZW5kZXJPYgog ICAgICAgICByZXR1cm4gcmVzb3VyY2VUcmFuc2Zvcm07CiAKICAgICBTVkdTdHlsZWRUcmFuc2Zv cm1hYmxlRWxlbWVudCogZWxlbWVudCA9IHN0YXRpY19jYXN0PFNWR1N0eWxlZFRyYW5zZm9ybWFi bGVFbGVtZW50Kj4ob2JqZWN0LT5ub2RlKCkpOwotICAgIEFmZmluZVRyYW5zZm9ybSB0cmFuc2Zv cm0gPSByZXNvdXJjZVRyYW5zZm9ybTsKLSAgICB0cmFuc2Zvcm0ubXVsdGlwbHkoZWxlbWVudC0+ Z2V0U2NyZWVuQ1RNKFNWR0xvY2F0YWJsZTo6RGlzYWxsb3dTdHlsZVVwZGF0ZSkpOworICAgIEFm ZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm0gPSBlbGVtZW50LT5nZXRTY3JlZW5DVE0oU1ZHTG9jYXRh YmxlOjpEaXNhbGxvd1N0eWxlVXBkYXRlKTsKKyAgICB0cmFuc2Zvcm0gKj0gcmVzb3VyY2VUcmFu c2Zvcm07CiAgICAgcmV0dXJuIHRyYW5zZm9ybTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZUdyYWRpZW50LmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUmVzb3VyY2VHcmFkaWVudC5jcHAKaW5k ZXggNWFkNWQ4NDNhZmU1NGEwOWYxZDMxNmQzYzdkNTg1NGI5NWQzZDJlNS4uODUyMmY4YTIyNWYw OTgxNTg1YTdjYzVlY2VjOGQ0Yzc4ZmMyYzFhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZUdyYWRpZW50LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291cmNlR3JhZGllbnQuY3BwCkBAIC0x OCw2ICsxOCw3IEBACiAgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwogICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKICAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgorICoKICAqLwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCkBAIC0x MzMsNyArMTM0LDcgQEAgc3RhdGljIGlubGluZSBBZmZpbmVUcmFuc2Zvcm0gY2xpcFRvVGV4dE1h c2soR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LAogICAgICAgICBtYXRyaXgudHJhbnNsYXRlKG1h c2tCb3VuZGluZ0JveC54KCksIG1hc2tCb3VuZGluZ0JveC55KCkpOwogICAgICAgICBtYXRyaXgu c2NhbGVOb25Vbmlmb3JtKG1hc2tCb3VuZGluZ0JveC53aWR0aCgpLCBtYXNrQm91bmRpbmdCb3gu aGVpZ2h0KCkpOwogICAgIH0KLSAgICBtYXRyaXgubXVsdExlZnQoZ3JhZGllbnRUcmFuc2Zvcm0p OworICAgIG1hdHJpeCAqPSBncmFkaWVudFRyYW5zZm9ybTsKICAgICByZXR1cm4gbWF0cml4Owog fQogI2VuZGlmCkBAIC0xOTAsNyArMTkxLDcgQEAgYm9vbCBSZW5kZXJTVkdSZXNvdXJjZUdyYWRp ZW50OjphcHBseVJlc291cmNlKFJlbmRlck9iamVjdCogb2JqZWN0LCBSZW5kZXJTdHlsZSoKICAg ICAgICAgQWZmaW5lVHJhbnNmb3JtIGdyYWRpZW50VHJhbnNmb3JtOwogICAgICAgICBjYWxjdWxh dGVHcmFkaWVudFRyYW5zZm9ybShncmFkaWVudFRyYW5zZm9ybSk7CiAKLSAgICAgICAgZ3JhZGll bnREYXRhLT51c2Vyc3BhY2VUcmFuc2Zvcm0ubXVsdExlZnQoZ3JhZGllbnRUcmFuc2Zvcm0pOwor ICAgICAgICBncmFkaWVudERhdGEtPnVzZXJzcGFjZVRyYW5zZm9ybSAqPSBncmFkaWVudFRyYW5z Zm9ybTsKICAgICAgICAgZ3JhZGllbnREYXRhLT5ncmFkaWVudC0+c2V0R3JhZGllbnRTcGFjZVRy YW5zZm9ybShncmFkaWVudERhdGEtPnVzZXJzcGFjZVRyYW5zZm9ybSk7CiAgICAgfQogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291cmNlUGF0 dGVybi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291cmNl UGF0dGVybi5jcHAKaW5kZXggMzMwYTIxYWMyMGFiNGRlMjFhOGI5ZTBlZjU1Y2Q0MWZkMTEyOGNk ZC4uMzRmNjdhZTc1NjFjNGQ4NGNlOTFjMmU0ZDJhNzE1NzdmZDAxYmZhOCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZVBhdHRlcm4uY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUmVzb3VyY2VQYXR0 ZXJuLmNwcApAQCAtMTYsNiArMTYsNyBAQAogICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNl ZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KICAqIHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is CiAgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqCiAgKi8KIAogI2luY2x1ZGUgImNv bmZpZy5oIgpAQCAtMTM5LDcgKzE0MCw3IEBAIGJvb2wgUmVuZGVyU1ZHUmVzb3VyY2VQYXR0ZXJu OjphcHBseVJlc291cmNlKFJlbmRlck9iamVjdCogb2JqZWN0LCBSZW5kZXJTdHlsZSoKIAogICAg ICAgICBBZmZpbmVUcmFuc2Zvcm0gcGF0dGVyblRyYW5zZm9ybSA9IG1fYXR0cmlidXRlcy5wYXR0 ZXJuVHJhbnNmb3JtKCk7CiAgICAgICAgIGlmICghcGF0dGVyblRyYW5zZm9ybS5pc0lkZW50aXR5 KCkpCi0gICAgICAgICAgICBwYXR0ZXJuRGF0YS0+dHJhbnNmb3JtLm11bHRpcGx5KHBhdHRlcm5U cmFuc2Zvcm0pOworICAgICAgICAgICAgcGF0dGVybkRhdGEtPnRyYW5zZm9ybSA9IHBhdHRlcm5U cmFuc2Zvcm0gKiBwYXR0ZXJuRGF0YS0+dHJhbnNmb3JtOwogCiAgICAgICAgIHBhdHRlcm5EYXRh LT5wYXR0ZXJuLT5zZXRQYXR0ZXJuU3BhY2VUcmFuc2Zvcm0ocGF0dGVybkRhdGEtPnRyYW5zZm9y bSk7CiAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5k ZXJTVkdSb290LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUm9v dC5jcHAKaW5kZXggYWE4N2IwOWRmZmE1NzM3ZjM0NmVhNWZmNzIzMmRhZDhiNmYwMjE5OS4uM2E4 ZGNlOWZmMjRjZDFlMDBhNWQyM2ViM2VlZTE1ZjcyNjMwZDFmZCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSb290LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jvb3QuY3BwCkBAIC0yNDYsNyArMjQ2LDcgQEAg QWZmaW5lVHJhbnNmb3JtIFJlbmRlclNWR1Jvb3Q6OmxvY2FsVG9Cb3JkZXJCb3hUcmFuc2Zvcm0o KSBjb25zdAogICAgIGZsb2F0IHNjYWxlID0gc3ZnLT5jdXJyZW50U2NhbGUoKTsKICAgICBGbG9h dFBvaW50IHRyYW5zbGF0ZSA9IHN2Zy0+Y3VycmVudFRyYW5zbGF0ZSgpOwogICAgIEFmZmluZVRy YW5zZm9ybSBjdG0oc2NhbGUsIDAsIDAsIHNjYWxlLCBib3JkZXJBbmRQYWRkaW5nLndpZHRoKCkg KyB0cmFuc2xhdGUueCgpLCBib3JkZXJBbmRQYWRkaW5nLmhlaWdodCgpICsgdHJhbnNsYXRlLnko KSk7Ci0gICAgcmV0dXJuIHN2Zy0+dmlld0JveFRvVmlld1RyYW5zZm9ybSh3aWR0aCgpIC8gc2Nh bGUsIGhlaWdodCgpIC8gc2NhbGUpICogY3RtOworICAgIHJldHVybiBjdG0gKiBzdmctPnZpZXdC b3hUb1ZpZXdUcmFuc2Zvcm0od2lkdGgoKSAvIHNjYWxlLCBoZWlnaHQoKSAvIHNjYWxlKTsKIH0K IAogSW50U2l6ZSBSZW5kZXJTVkdSb290OjpwYXJlbnRPcmlnaW5Ub0JvcmRlckJveCgpIGNvbnN0 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1NWR0ltYWdlQnVmZmVy VG9vbHMuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9TVkdJbWFnZUJ1ZmZlclRv b2xzLmNwcAppbmRleCBmMDY1N2FmMTg0Njk5ZTUxYmY0MDg2NWUzYTRhNzJiNGFiNTFlZTM5Li42 NzI2Njk0ZDEwM2YxOTIyODRmYjA0ZTU2NjIwMzgzNzkzZmNkMTQ5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1NWR0ltYWdlQnVmZmVyVG9vbHMuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvU1ZHSW1hZ2VCdWZmZXJUb29scy5jcHAKQEAgLTQz LDcgKzQzLDcgQEAgdm9pZCBTVkdJbWFnZUJ1ZmZlclRvb2xzOjpjYWxjdWxhdGVUcmFuc2Zvcm1h dGlvblRvT3V0ZXJtb3N0U1ZHQ29vcmRpbmF0ZVN5c3RlbSgKIAogICAgIGFic29sdXRlVHJhbnNm b3JtID0gY3VycmVudENvbnRlbnRUcmFuc2Zvcm1hdGlvbigpOwogICAgIHdoaWxlIChjdXJyZW50 KSB7Ci0gICAgICAgIGFic29sdXRlVHJhbnNmb3JtLm11bHRpcGx5KGN1cnJlbnQtPmxvY2FsVG9Q YXJlbnRUcmFuc2Zvcm0oKSk7CisgICAgICAgIGFic29sdXRlVHJhbnNmb3JtID0gY3VycmVudC0+ bG9jYWxUb1BhcmVudFRyYW5zZm9ybSgpICogYWJzb2x1dGVUcmFuc2Zvcm07CiAgICAgICAgIGlm IChjdXJyZW50LT5pc1NWR1Jvb3QoKSkKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjdXJy ZW50ID0gY3VycmVudC0+cGFyZW50KCk7CkBAIC04Myw3ICs4Myw3IEBAIHZvaWQgU1ZHSW1hZ2VC dWZmZXJUb29sczo6cmVuZGVyU3VidHJlZVRvSW1hZ2VCdWZmZXIoSW1hZ2VCdWZmZXIqIGltYWdl LCBSZW5kZXJPCiAKICAgICBBZmZpbmVUcmFuc2Zvcm0mIGNvbnRlbnRUcmFuc2Zvcm1hdGlvbiA9 IGN1cnJlbnRDb250ZW50VHJhbnNmb3JtYXRpb24oKTsKICAgICBBZmZpbmVUcmFuc2Zvcm0gc2F2 ZWRDb250ZW50VHJhbnNmb3JtYXRpb24gPSBjb250ZW50VHJhbnNmb3JtYXRpb247Ci0gICAgY29u dGVudFRyYW5zZm9ybWF0aW9uLm11bHRpcGx5KHN1YnRyZWVDb250ZW50VHJhbnNmb3JtYXRpb24p OworICAgIGNvbnRlbnRUcmFuc2Zvcm1hdGlvbiA9IHN1YnRyZWVDb250ZW50VHJhbnNmb3JtYXRp b24gKiBjb250ZW50VHJhbnNmb3JtYXRpb247CiAKICAgICBpdGVtLT5sYXlvdXRJZk5lZWRlZCgp OwogICAgIGl0ZW0tPnBhaW50KGluZm8sIDAsIDApOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL3N2Zy9TVkdUZXh0TGF5b3V0RW5naW5lLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9zdmcvU1ZHVGV4dExheW91dEVuZ2luZS5jcHAKaW5kZXggN2VlZmFkNjU2NjM2 ZDkyZTUyNmI5ODk0YjQ5ZTdiNTEwNGVmNmRjZi4uM2IyOGQyYmQxNmU3YjU2ZjM2ZDllYmJiMTRl MTZkZTgzYzhhMDFjZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9T VkdUZXh0TGF5b3V0RW5naW5lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3Zn L1NWR1RleHRMYXlvdXRFbmdpbmUuY3BwCkBAIC0zMjEsNyArMzIxLDcgQEAgdm9pZCBTVkdUZXh0 TGF5b3V0RW5naW5lOjpmaW5hbGl6ZVRyYW5zZm9ybU1hdHJpY2VzKFZlY3RvcjxTVkdJbmxpbmVU ZXh0Qm94Kj4mIGIKICAgICAgICAgICAgIGlmICh0cmFuc2Zvcm0uaXNJZGVudGl0eSgpKQogICAg ICAgICAgICAgICAgIHRyYW5zZm9ybSA9IHRleHRCb3hUcmFuc2Zvcm1hdGlvbjsKICAgICAgICAg ICAgIGVsc2UKLSAgICAgICAgICAgICAgICB0cmFuc2Zvcm0ubXVsdGlwbHkodGV4dEJveFRyYW5z Zm9ybWF0aW9uKTsKKyAgICAgICAgICAgICAgICB0cmFuc2Zvcm0gPSB0ZXh0Qm94VHJhbnNmb3Jt YXRpb24gKiB0cmFuc2Zvcm07CiAgICAgICAgIH0KICAgICB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3N2Zy9TVkdMb2NhdGFibGUuY3BwIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0xv Y2F0YWJsZS5jcHAKaW5kZXggNDM5NjFkOTU0MTliYWEzOTY0OTI2ZGQxNTBhMmY0NTIxMjNiNWQx Ny4uMmE3YzliZTA5ZmQ2ODU4YjdmMDNhNmYwNzdlOGUyNDY4ZDM1ZmQzMyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvc3ZnL1NWR0xvY2F0YWJsZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv c3ZnL1NWR0xvY2F0YWJsZS5jcHAKQEAgLTkxLDcgKzkxLDggQEAgQWZmaW5lVHJhbnNmb3JtIFNW R0xvY2F0YWJsZTo6Y29tcHV0ZUNUTShjb25zdCBTVkdFbGVtZW50KiBlbGVtZW50LCBDVE1TY29w ZSBtb2QKICAgICB3aGlsZSAoY3VycmVudCAmJiBjdXJyZW50LT5pc1NWR0VsZW1lbnQoKSkgewog ICAgICAgICBTVkdFbGVtZW50KiBjdXJyZW50RWxlbWVudCA9IHN0YXRpY19jYXN0PFNWR0VsZW1l bnQqPihjdXJyZW50KTsKICAgICAgICAgaWYgKGN1cnJlbnRFbGVtZW50LT5pc1N0eWxlZCgpKQot ICAgICAgICAgICAgY3RtID0gc3RhdGljX2Nhc3Q8U1ZHU3R5bGVkRWxlbWVudCo+KGN1cnJlbnRF bGVtZW50KS0+bG9jYWxDb29yZGluYXRlU3BhY2VUcmFuc2Zvcm0obW9kZSkubXVsdExlZnQoY3Rt KTsKKyAgICAgICAgICAgIC8vIG5vdGUgdGhhdCB0aGlzIG1vZGlmaWVzIHRoZSBBZmZpbmVUcmFu c2Zvcm0gcmV0dXJuZWQgYnkgbG9jYWxDb29yZGluYXRlU3BhY2VUcmFuc2Zvcm0obW9kZSkgdG9v LgorICAgICAgICAgICAgY3RtID0gc3RhdGljX2Nhc3Q8U1ZHU3R5bGVkRWxlbWVudCo+KGN1cnJl bnRFbGVtZW50KS0+bG9jYWxDb29yZGluYXRlU3BhY2VUcmFuc2Zvcm0obW9kZSkubXVsdGlwbHko Y3RtKTsKIAogICAgICAgICAvLyBGb3IgZ2V0Q1RNKCkgY29tcHV0YXRpb24sIHN0b3AgYXQgdGhl IG5lYXJlc3Qgdmlld3BvcnQgZWxlbWVudAogICAgICAgICBpZiAoY3VycmVudEVsZW1lbnQgPT0g c3RvcEF0RWxlbWVudCkKQEAgLTExMyw3ICsxMTQsNyBAQCBBZmZpbmVUcmFuc2Zvcm0gU1ZHTG9j YXRhYmxlOjpnZXRUcmFuc2Zvcm1Ub0VsZW1lbnQoU1ZHRWxlbWVudCogdGFyZ2V0LCBFeGNlcHRp bwogICAgICAgICAgICAgZWMgPSBTVkdFeGNlcHRpb246OlNWR19NQVRSSVhfTk9UX0lOVkVSVEFC TEU7CiAgICAgICAgICAgICByZXR1cm4gY3RtOwogICAgICAgICB9Ci0gICAgICAgIGN0bSAqPSB0 YXJnZXRDVE0uaW52ZXJzZSgpOworICAgICAgICBjdG0gPSB0YXJnZXRDVE0uaW52ZXJzZSgpICog Y3RtOwogICAgIH0KIAogICAgIHJldHVybiBjdG07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9zdmcvU1ZHTWF0cml4LmggYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHTWF0cml4LmgKaW5kZXgg ODA3YjcwMzM4ZDc0N2U1MWExMzIwZDNhNTQ5ZDc1OTU4MWE2ODdjNS4uMDc3ZWIwMzgzNDg2NjQ4 NzRmN2JjNWJjMzBhYmFlMzNjMmY2Y2M3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3Zn L1NWR01hdHJpeC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdNYXRyaXguaApAQCAtOTYs MTEgKzk2LDEwIEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PFNWR01hdHJp eD4oY29weSk7CiAgICAgfQogCi0gICAgLy8gU1ZHTWF0cml4OjptdWx0aXBseSBuZWVkcyB0byBj YWxsIFNWR01hdHJpeDo6bXVsdExlZnQuCiAgICAgU1ZHTWF0cml4IG11bHRpcGx5KGNvbnN0IFNW R01hdHJpeCYgb3RoZXIpCiAgICAgewogICAgICAgICBBZmZpbmVUcmFuc2Zvcm0gY29weSA9ICp0 aGlzOwotICAgICAgICBjb3B5Lm11bHRMZWZ0KHN0YXRpY19jYXN0PGNvbnN0IEFmZmluZVRyYW5z Zm9ybSY+KG90aGVyKSk7CisgICAgICAgIGNvcHkgKj0gc3RhdGljX2Nhc3Q8Y29uc3QgQWZmaW5l VHJhbnNmb3JtJj4ob3RoZXIpOwogICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8U1ZHTWF0cml4 Pihjb3B5KTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdTVkdF bGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdTVkdFbGVtZW50LmNwcAppbmRleCA3 ZTA0ZjVkYjAxYjZhZmZjM2YyYmRiNWM3ZDI1ZjhkNWU5YjJiNzcxLi40ODNlNDVmOGZmNTUxOWYz NDVmMTkzYjE4MzNkN2IzYTEwNGRlOThkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcv U1ZHU1ZHRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1NWR0VsZW1lbnQu Y3BwCkBAIC01MDIsNyArNTAyLDcgQEAgQWZmaW5lVHJhbnNmb3JtIFNWR1NWR0VsZW1lbnQ6Omxv Y2FsQ29vcmRpbmF0ZVNwYWNlVHJhbnNmb3JtKFNWR0xvY2F0YWJsZTo6Q1RNU2MKICAgICAgICAg fQogICAgIH0KIAotICAgIHJldHVybiB0cmFuc2Zvcm0ubXVsdExlZnQodmlld0JveFRyYW5zZm9y bSk7CisgICAgcmV0dXJuIHRyYW5zZm9ybS5tdWx0aXBseSh2aWV3Qm94VHJhbnNmb3JtKTsKIH0K IAogUmVuZGVyT2JqZWN0KiBTVkdTVkdFbGVtZW50OjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVu YSogYXJlbmEsIFJlbmRlclN0eWxlKikKQEAgLTU4NywxMiArNTg3LDExIEBAIEFmZmluZVRyYW5z Zm9ybSBTVkdTVkdFbGVtZW50Ojp2aWV3Qm94VG9WaWV3VHJhbnNmb3JtKGZsb2F0IHZpZXdXaWR0 aCwgZmxvYXQgdmllCiAgICAgICAgIHZpZXdCb3hSZWN0ID0gdmlld0JveCgpOwogCiAgICAgQWZm aW5lVHJhbnNmb3JtIGN0bSA9IFNWR0ZpdFRvVmlld0JveDo6dmlld0JveFRvVmlld1RyYW5zZm9y bSh2aWV3Qm94UmVjdCwgcHJlc2VydmVBc3BlY3RSYXRpbygpLCB2aWV3V2lkdGgsIHZpZXdIZWln aHQpOworCiAgICAgaWYgKHVzZUN1cnJlbnRWaWV3KCkgJiYgY3VycmVudFZpZXcoKSkgewogICAg ICAgICBBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtOwotICAgICAgICBpZiAoIWN1cnJlbnRWaWV3 KCktPnRyYW5zZm9ybSgpLmNvbmNhdGVuYXRlKHRyYW5zZm9ybSkpCi0gICAgICAgICAgICByZXR1 cm4gY3RtOwotCi0gICAgICAgIHJldHVybiB0cmFuc2Zvcm0gKiBjdG07CisgICAgICAgIGlmIChj dXJyZW50VmlldygpLT50cmFuc2Zvcm0oKS5jb25jYXRlbmF0ZSh0cmFuc2Zvcm0pKQorICAgICAg ICAgICAgY3RtICo9IHRyYW5zZm9ybTsKICAgICB9CiAKICAgICByZXR1cm4gY3RtOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50LmNw cCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVudC5jcHAK aW5kZXggMjMzNDk0M2M1NjJlYjQwOTg5YWYwZDE0NmMxYTBiZTYyZWE2MzI2Mi4uMTU1MjhlMDkz MjllMjM5MDNmMGUzMjRiZTNmOTg0ODQ3YjgwMDRkOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvc3ZnL1NWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQuY3BwCkBAIC01Niw3ICs1Niw5 IEBAIEFmZmluZVRyYW5zZm9ybSBTVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVudDo6YW5pbWF0 ZWRMb2NhbFRyYW5zZm9ybSgpIGNvbnN0CiB7CiAgICAgQWZmaW5lVHJhbnNmb3JtIG1hdHJpeDsK ICAgICB0cmFuc2Zvcm0oKS5jb25jYXRlbmF0ZShtYXRyaXgpOwotICAgIHJldHVybiBtX3N1cHBs ZW1lbnRhbFRyYW5zZm9ybSA/ICptX3N1cHBsZW1lbnRhbFRyYW5zZm9ybSAqIG1hdHJpeCA6IG1h dHJpeDsKKyAgICBpZiAobV9zdXBwbGVtZW50YWxUcmFuc2Zvcm0pCisgICAgICAgIG1hdHJpeCAq PSAqbV9zdXBwbGVtZW50YWxUcmFuc2Zvcm07CisgICAgcmV0dXJuIG1hdHJpeDsKIH0KIAogQWZm aW5lVHJhbnNmb3JtKiBTVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVudDo6c3VwcGxlbWVudGFs VHJhbnNmb3JtKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0RWxlbWVu dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVGV4dEVsZW1lbnQuY3BwCmluZGV4IDcyMjk4 MjQ1YzU2ZmU0MjU2ZTg1YTQ0YTlmNzU5NjFhMTc2NjRiM2QuLmI2MDk0YzkwMTY3ZjA1NGM0ODQw YjgwZGIzMDNhNmMzZjIxMmE1ZDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdU ZXh0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRFbGVtZW50LmNw cApAQCAtODksNyArODksOSBAQCBBZmZpbmVUcmFuc2Zvcm0gU1ZHVGV4dEVsZW1lbnQ6OmFuaW1h dGVkTG9jYWxUcmFuc2Zvcm0oKSBjb25zdAogewogICAgIEFmZmluZVRyYW5zZm9ybSBtYXRyaXg7 CiAgICAgdHJhbnNmb3JtKCkuY29uY2F0ZW5hdGUobWF0cml4KTsKLSAgICByZXR1cm4gbV9zdXBw bGVtZW50YWxUcmFuc2Zvcm0gPyAqbV9zdXBwbGVtZW50YWxUcmFuc2Zvcm0gKiBtYXRyaXggOiBt YXRyaXg7CisgICAgaWYgKG1fc3VwcGxlbWVudGFsVHJhbnNmb3JtKQorICAgICAgICBtYXRyaXgg Kj0gKm1fc3VwcGxlbWVudGFsVHJhbnNmb3JtOworICAgIHJldHVybiBtYXRyaXg7CiB9CiAKIEFm ZmluZVRyYW5zZm9ybSogU1ZHVGV4dEVsZW1lbnQ6OnN1cHBsZW1lbnRhbFRyYW5zZm9ybSgpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHVHJhbnNmb3JtTGlzdC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9zdmcvU1ZHVHJhbnNmb3JtTGlzdC5jcHAKaW5kZXggNTJiZmM4NTI1YzdhZjcy ZDljYzMyMDE1NDc0MTY3Zjk0NzU3ZDkwYy4uMTgwMGIxZWMwM2ZhNWE5YjBkOWMzYjcwYjgyODdi MGM2MmIwOTg4ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RyYW5zZm9ybUxp c3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUcmFuc2Zvcm1MaXN0LmNwcApAQCAt NTYsNyArNTYsNyBAQCBib29sIFNWR1RyYW5zZm9ybUxpc3Q6OmNvbmNhdGVuYXRlKEFmZmluZVRy YW5zZm9ybSYgcmVzdWx0KSBjb25zdAogICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICBmb3Ig KHVuc2lnbmVkIGkgPSAwOyBpIDwgc2l6ZTsgKytpKQotICAgICAgICByZXN1bHQgPSBhdChpKS5t YXRyaXgoKSAqIHJlc3VsdDsKKyAgICAgICAgcmVzdWx0ICo9IGF0KGkpLm1hdHJpeCgpOwogCiAg ICAgcmV0dXJuIHRydWU7CiB9Cg== 78495 2011-01-10 22:31:24 -0800 2011-01-13 16:17:19 -0800 Patch bug-48031-20110111173120.patch text/plain 24201 shanestephens ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxZTUzNTA1ZGQ4YTYzY2E5ZTA5MjFiYTBmZDM0ODcyMjc5MDJiMmVlLi41 NzlkYjEyZWFhOWU3YjI5ZDZmZDMwYzYwZDQ3ZjhiNGRhOThiMzUwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsNjggQEAKKzIwMTEtMDEtMTAgIFNoYW5lIFN0ZXBoZW5zICA8c2hhbmVzdGVwaGVuc0Bn b29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE1ha2UgQWZmaW5lVHJhbnNmb3JtIGFuZCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBkbyBtYXRy aXggbXVsdGlwbGljYXRpb24gaW4gdGhlIGNvcnJlY3Qgb3JkZXIgKENvbHVtbiBNYWpvcikKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ4MDMxCisKKyAg ICAgICAgRml4ZWQgcmV2ZXJzYWwsIHJlbmFtZWQgbWF0cml4IG1ldGhvZHMgdG8gYmUgY2xlYXJl ciwgZm91bmQgYWxsIGV4YW1wbGVzIG9mIG9wZXJhdG9yKiBhbmQKKyAgICAgICAgb3BlcmF0b3Iq PSB1c2FnZSBhbmQgc3dpdGNoZWQgb3BlcmFuZCBvcmRlci4KKworICAgICAgICBObyBuZXcgdGVz dHMgYXMgdGhpcyByZWZhY3RvciBkb2Vzbid0IGFkZCBmdW5jdGlvbmFsaXR5LgorCisgICAgICAg ICogaHRtbC9IVE1MQ2FudmFzRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MQ2Fu dmFzRWxlbWVudDo6YmFzZVRyYW5zZm9ybSk6CisgICAgICAgICogaHRtbC9jYW52YXMvQ2FudmFz UmVuZGVyaW5nQ29udGV4dDJELmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNhbnZhc1JlbmRlcmlu Z0NvbnRleHQyRDo6dHJhbnNmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OkNhbnZhc1JlbmRlcmlu Z0NvbnRleHQyRDo6c2V0VHJhbnNmb3JtKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9j Zy9QYXR0ZXJuQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0dGVybjo6Y3JlYXRlUGxhdGZv cm1QYXR0ZXJuKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9HTEVTMkNh bnZhcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHTEVTMkNhbnZhczo6ZmlsbFJlY3QpOgorICAg ICAgICAoV2ViQ29yZTo6R0xFUzJDYW52YXM6OmNvbmNhdENUTSk6CisgICAgICAgIChXZWJDb3Jl OjpHTEVTMkNhbnZhczo6ZHJhd1F1YWQpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUcmFuc3BhcmVu Y3lXaW46OnNldHVwTGF5ZXJGb3JPcGFxdWVDb21wb3NpdGVMYXllcik6CisgICAgICAgIChXZWJD b3JlOjpUcmFuc3BhcmVuY3lXaW46OnNldHVwVHJhbnNmb3JtRm9yS2VlcFRyYW5zZm9ybSk6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3Bw OgorICAgICAgICAoV2ViQ29yZTo6QWZmaW5lVHJhbnNmb3JtOjptdWx0aXBseSk6CisgICAgICAg IChXZWJDb3JlOjpBZmZpbmVUcmFuc2Zvcm06OnJvdGF0ZSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkFmZmluZVRyYW5zZm9ybTo6b3BlcmF0b3IqPSk6CisgICAgICAgIChXZWJDb3JlOjpBZmZpbmVU cmFuc2Zvcm06Om9wZXJhdG9yKik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2Uv R3JhcGhpY3NDb250ZXh0V2luQ0UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250 ZXh0UGxhdGZvcm1Qcml2YXRlOjpjb25jYXRDVE0pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL3dpbmNlL1NoYXJlZEJpdG1hcC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCaXRt YXA6OmRyYXdQYXR0ZXJuKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291 cmNlQ29udGFpbmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclNWR1Jlc291cmNlQ29u dGFpbmVyOjp0cmFuc2Zvcm1Pbk5vblNjYWxpbmdTdHJva2UpOgorICAgICAgICAqIHJlbmRlcmlu Zy9zdmcvUmVuZGVyU1ZHUmVzb3VyY2VHcmFkaWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpj bGlwVG9UZXh0TWFzayk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJTVkdSZXNvdXJjZUdyYWRp ZW50OjphcHBseVJlc291cmNlKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jl c291cmNlUGF0dGVybi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJTVkdSZXNvdXJjZVBh dHRlcm46OmFwcGx5UmVzb3VyY2UpOgorICAgICAgICAqIHJlbmRlcmluZy9zdmcvUmVuZGVyU1ZH Um9vdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJTVkdSb290Ojpsb2NhbFRvQm9yZGVy Qm94VHJhbnNmb3JtKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1NWR0ltYWdlQnVmZmVyVG9v bHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHSW1hZ2VCdWZmZXJUb29sczo6Y2FsY3VsYXRl VHJhbnNmb3JtYXRpb25Ub091dGVybW9zdFNWR0Nvb3JkaW5hdGVTeXN0ZW0pOgorICAgICAgICAo V2ViQ29yZTo6U1ZHSW1hZ2VCdWZmZXJUb29sczo6cmVuZGVyU3VidHJlZVRvSW1hZ2VCdWZmZXIp OgorICAgICAgICAqIHJlbmRlcmluZy9zdmcvU1ZHVGV4dExheW91dEVuZ2luZS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTVkdUZXh0TGF5b3V0RW5naW5lOjpmaW5hbGl6ZVRyYW5zZm9ybU1hdHJp Y2VzKToKKyAgICAgICAgKiBzdmcvU1ZHTG9jYXRhYmxlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlNWR0xvY2F0YWJsZTo6Y29tcHV0ZUNUTSk6CisgICAgICAgIChXZWJDb3JlOjpTVkdMb2NhdGFi bGU6OmdldFRyYW5zZm9ybVRvRWxlbWVudCk6CisgICAgICAgICogc3ZnL1NWR01hdHJpeC5oOgor ICAgICAgICAoV2ViQ29yZTo6U1ZHTWF0cml4OjptdWx0aXBseSk6CisgICAgICAgICogc3ZnL1NW R1NWR0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHU1ZHRWxlbWVudDo6bG9jYWxD b29yZGluYXRlU3BhY2VUcmFuc2Zvcm0pOgorICAgICAgICAoV2ViQ29yZTo6U1ZHU1ZHRWxlbWVu dDo6dmlld0JveFRvVmlld1RyYW5zZm9ybSk6CisgICAgICAgICogc3ZnL1NWR1N0eWxlZFRyYW5z Zm9ybWFibGVFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1N0eWxlZFRyYW5zZm9y bWFibGVFbGVtZW50OjphbmltYXRlZExvY2FsVHJhbnNmb3JtKToKKyAgICAgICAgKiBzdmcvU1ZH VGV4dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHVGV4dEVsZW1lbnQ6OmFuaW1h dGVkTG9jYWxUcmFuc2Zvcm0pOgorICAgICAgICAqIHN2Zy9TVkdUcmFuc2Zvcm1MaXN0LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlNWR1RyYW5zZm9ybUxpc3Q6OmNvbmNhdGVuYXRlKToKKwogMjAx MC0xMC0xMCAgRGF2aWQgSHlhdHQgIDxoeWF0dEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgU2ltb24gRnJhc2VyLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M Q2FudmFzRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxDYW52YXNFbGVtZW50 LmNwcAppbmRleCBmMjg2NzQ5MzY4YTk1Mzg0MGIwNTc2ZjQwNzcwOTQ3YWY3Mzg4MTZmLi45ZDE1 ZTQ2MTQ3MmFmYzE0MWFkMDQ5MjdjNjliMTFjODFiNjI1Njg3IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxDYW52YXNFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxDYW52YXNFbGVtZW50LmNwcApAQCAtNDQ2LDggKzQ0Niw3IEBAIEFmZmluZVRyYW5z Zm9ybSBIVE1MQ2FudmFzRWxlbWVudDo6YmFzZVRyYW5zZm9ybSgpIGNvbnN0CiAgICAgQWZmaW5l VHJhbnNmb3JtIHRyYW5zZm9ybTsKICAgICBpZiAoc2l6ZS53aWR0aCgpICYmIHNpemUuaGVpZ2h0 KCkpCiAgICAgICAgIHRyYW5zZm9ybS5zY2FsZU5vblVuaWZvcm0oc2l6ZS53aWR0aCgpIC8gdW5z Y2FsZWRTaXplLndpZHRoKCksIHNpemUuaGVpZ2h0KCkgLyB1bnNjYWxlZFNpemUuaGVpZ2h0KCkp OwotICAgIHRyYW5zZm9ybS5tdWx0aXBseShtX2ltYWdlQnVmZmVyLT5iYXNlVHJhbnNmb3JtKCkp OwotICAgIHJldHVybiB0cmFuc2Zvcm07CisgICAgcmV0dXJuIG1faW1hZ2VCdWZmZXItPmJhc2VU cmFuc2Zvcm0oKSAqIHRyYW5zZm9ybTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmNwcCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAKaW5kZXggNjJjNTc5 MzdhNjE1Y2M1NDhmNmYyZTYwMzdkN2UxN2FiMzc0MzZiMC4uZDRjYmIxNzdjYmQ5ZTYzN2Y3ZjMw MDc0OWY3Njc5ZjA3ZTM3YWM3MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52 YXMvQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L2NhbnZhcy9DYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwCkBAIC01MzcsNyArNTM3LDcgQEAg dm9pZCBDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OnRyYW5zZm9ybShmbG9hdCBtMTEsIGZsb2F0 IG0xMiwgZmxvYXQgbTIxLCBmbG9hdAogICAgICAgICByZXR1cm47CiAKICAgICBBZmZpbmVUcmFu c2Zvcm0gdHJhbnNmb3JtKG0xMSwgbTEyLCBtMjEsIG0yMiwgZHgsIGR5KTsKLSAgICBBZmZpbmVU cmFuc2Zvcm0gbmV3VHJhbnNmb3JtID0gdHJhbnNmb3JtICogc3RhdGUoKS5tX3RyYW5zZm9ybTsK KyAgICBBZmZpbmVUcmFuc2Zvcm0gbmV3VHJhbnNmb3JtID0gc3RhdGUoKS5tX3RyYW5zZm9ybSAq IHRyYW5zZm9ybTsKICAgICBpZiAoIW5ld1RyYW5zZm9ybS5pc0ludmVydGlibGUoKSkgewogICAg ICAgICBzdGF0ZSgpLm1faW52ZXJ0aWJsZUNUTSA9IGZhbHNlOwogICAgICAgICByZXR1cm47CkBA IC01NjIsNyArNTYyLDcgQEAgdm9pZCBDYW52YXNSZW5kZXJpbmdDb250ZXh0MkQ6OnNldFRyYW5z Zm9ybShmbG9hdCBtMTEsIGZsb2F0IG0xMiwgZmxvYXQgbTIxLCBmbG8KICAgICAgICAgcmV0dXJu OwogICAgIGMtPmNvbmNhdENUTShjLT5nZXRDVE0oKS5pbnZlcnNlKCkpOwogICAgIGMtPmNvbmNh dENUTShjYW52YXMoKS0+YmFzZVRyYW5zZm9ybSgpKTsKLSAgICBzdGF0ZSgpLm1fdHJhbnNmb3Jt Lm11bHRpcGx5KGN0bS5pbnZlcnNlKCkpOworICAgIHN0YXRlKCkubV90cmFuc2Zvcm0gPSBjdG0u aW52ZXJzZSgpICogc3RhdGUoKS5tX3RyYW5zZm9ybTsKICAgICBtX3BhdGgudHJhbnNmb3JtKGN0 bSk7CiAKICAgICBzdGF0ZSgpLm1faW52ZXJ0aWJsZUNUTSA9IHRydWU7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9QYXR0ZXJuQ0cuY3BwIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0dGVybkNHLmNwcAppbmRleCA5NGYzN2Iy ZmYxY2Y2MTk2N2ViZWZmODcxZDY1NGNlNGFjZGU0NDI5Li5jZmFjMTVjMzdmNjZjMGRmYTQzNjQ1 ZDc5MDM2YTExZTlmNjkzMGY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jZy9QYXR0ZXJuQ0cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2NnL1BhdHRlcm5DRy5jcHAKQEAgLTU0LDggKzU0LDcgQEAgQ0dQYXR0ZXJuUmVmIFBh dHRlcm46OmNyZWF0ZVBsYXRmb3JtUGF0dGVybihjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHVzZXJT cGFjZVRyYW4KIHsKICAgICBJbnRSZWN0IHRpbGVSZWN0ID0gdGlsZUltYWdlKCktPnJlY3QoKTsK IAotICAgIEFmZmluZVRyYW5zZm9ybSBwYXR0ZXJuVHJhbnNmb3JtID0gbV9wYXR0ZXJuU3BhY2VU cmFuc2Zvcm1hdGlvbjsKLSAgICBwYXR0ZXJuVHJhbnNmb3JtLm11bHRpcGx5KHVzZXJTcGFjZVRy YW5zZm9ybWF0aW9uKTsKKyAgICBBZmZpbmVUcmFuc2Zvcm0gcGF0dGVyblRyYW5zZm9ybSA9IHVz ZXJTcGFjZVRyYW5zZm9ybWF0aW9uICogbV9wYXR0ZXJuU3BhY2VUcmFuc2Zvcm1hdGlvbjsKICAg ICBwYXR0ZXJuVHJhbnNmb3JtLnNjYWxlTm9uVW5pZm9ybSgxLCAtMSk7CiAgICAgcGF0dGVyblRy YW5zZm9ybS50cmFuc2xhdGUoMCwgLXRpbGVSZWN0LmhlaWdodCgpKTsKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJDYW52YXMuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJDYW52YXMu Y3BwCmluZGV4IDY5N2NmNWU5MmQ1NTkzZWI2MmZjODM1ZTI2Y2Y0YmI4NTBmMTA3MmUuLmFlMDE3 ZGVlY2RlNTQyNWEzNWY5Y2ZkZTQzNTRiZWQ4NmUzNDE3ZTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFzLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9HTEVTMkNhbnZhcy5jcHAK QEAgLTEwOCw3ICsxMDgsNyBAQCB2b2lkIEdMRVMyQ2FudmFzOjpmaWxsUmVjdChjb25zdCBGbG9h dFJlY3QmIHJlY3QsIGNvbnN0IENvbG9yJiBjb2xvciwgQ29sb3JTcGFjZQogICAgIG1fY29udGV4 dC0+dXNlUXVhZFZlcnRpY2VzKCk7CiAKICAgICBBZmZpbmVUcmFuc2Zvcm0gbWF0cml4KG1fZmxp cE1hdHJpeCk7Ci0gICAgbWF0cml4Lm11bHRMZWZ0KG1fc3RhdGUtPm1fY3RtKTsKKyAgICBtYXRy aXggKj0gbV9zdGF0ZS0+bV9jdG07CiAgICAgbWF0cml4LnRyYW5zbGF0ZShyZWN0LngoKSwgcmVj dC55KCkpOwogICAgIG1hdHJpeC5zY2FsZShyZWN0LndpZHRoKCksIHJlY3QuaGVpZ2h0KCkpOwog CkBAIC0xNTAsNyArMTUwLDcgQEAgdm9pZCBHTEVTMkNhbnZhczo6c2NhbGUoY29uc3QgRmxvYXRT aXplJiBzaXplKQogCiB2b2lkIEdMRVMyQ2FudmFzOjpjb25jYXRDVE0oY29uc3QgQWZmaW5lVHJh bnNmb3JtJiBhZmZpbmUpCiB7Ci0gICAgbV9zdGF0ZS0+bV9jdG0ubXVsdExlZnQoYWZmaW5lKTsK KyAgICBtX3N0YXRlLT5tX2N0bSAqPSBhZmZpbmU7CiB9CiAKIHZvaWQgR0xFUzJDYW52YXM6OnNh dmUoKQpAQCAtMjIwLDcgKzIyMCw3IEBAIHZvaWQgR0xFUzJDYW52YXM6OmRyYXdUZXh0dXJlZFJl Y3RUaWxlKFRleHR1cmUqIHRleHR1cmUsIGludCB0aWxlLCBjb25zdCBGbG9hdFJlCiB2b2lkIEdM RVMyQ2FudmFzOjpkcmF3UXVhZChjb25zdCBJbnRTaXplJiB0ZXh0dXJlU2l6ZSwgY29uc3QgRmxv YXRSZWN0JiBzcmNSZWN0LCBjb25zdCBGbG9hdFJlY3QmIGRzdFJlY3QsIGNvbnN0IEFmZmluZVRy YW5zZm9ybSYgdHJhbnNmb3JtLCBmbG9hdCBhbHBoYSkKIHsKICAgICBBZmZpbmVUcmFuc2Zvcm0g bWF0cml4KG1fZmxpcE1hdHJpeCk7Ci0gICAgbWF0cml4Lm11bHRMZWZ0KHRyYW5zZm9ybSk7Cisg ICAgbWF0cml4ICo9IHRyYW5zZm9ybTsKICAgICBtYXRyaXgudHJhbnNsYXRlKGRzdFJlY3QueCgp LCBkc3RSZWN0LnkoKSk7CiAgICAgbWF0cml4LnNjYWxlKGRzdFJlY3Qud2lkdGgoKSwgZHN0UmVj dC5oZWlnaHQoKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UcmFuc3BhcmVuY3lXaW4uY3BwCmluZGV4IDRkYzIxNTcwNDg4 MGQxNGY4OWY1NWYxOWE0YmI1OTkzNTMxYmUxZGMuLmJhNjZlYWU0NjQ0M2QzMzY3ZThlNTAzNjVl MzQyMzYxYjg1NDYxZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVHJhbnNwYXJlbmN5V2luLmNwcApAQCAtMjUyLDcgKzI1 Miw3IEBAIHZvaWQgVHJhbnNwYXJlbmN5V2luOjpzZXR1cExheWVyRm9yT3BhcXVlQ29tcG9zaXRl TGF5ZXIoKQogICAgIGlmIChtX3RyYW5zZm9ybU1vZGUgPT0gVW50cmFuc2Zvcm0peyAKICAgICAg ICAgLy8gQ29tcHV0ZSB0aGUgaW52ZXJzZSBtYXBwaW5nIGZyb20gdGhlIGNhbnZhcyBzcGFjZSB0 byB0aGUKICAgICAgICAgLy8gY29vcmRpbmF0ZSBzcGFjZSBvZiBvdXIgYml0bWFwLgotICAgICAg ICBtYXBwaW5nID0gbV9vcmdUcmFuc2Zvcm0uaW52ZXJzZSgpICogbWFwcGluZzsKKyAgICAgICAg bWFwcGluZyAqPSBtX29yZ1RyYW5zZm9ybS5pbnZlcnNlKCk7CiAgICAgfQogICAgIGNvbXBvc2l0 ZVRvQ29weSgqbV9kZXN0Q29udGV4dCwgKm1fZHJhd0NvbnRleHQsIG1hcHBpbmcpOwogCkBAIC0z MTMsNyArMzEzLDcgQEAgdm9pZCBUcmFuc3BhcmVuY3lXaW46OnNldHVwVHJhbnNmb3JtRm9yS2Vl cFRyYW5zZm9ybShjb25zdCBJbnRSZWN0JiByZWdpb24pCiAgICAgICAgIC8vIFdlJ3JlIG1ha2lu ZyBhIGxheWVyLCBzbyBhcHBseSB0aGUgb2xkIHRyYW5zZm9ybSB0byB0aGUgbmV3IG9uZQogICAg ICAgICAvLyBzbyBpdCdzIG1haW50YWluZWQuIFdlIGtub3cgdGhlIG5ldyBsYXllciBoYXMgdGhl IGlkZW50aXR5CiAgICAgICAgIC8vIHRyYW5zZm9ybSBub3csIHdlIHdlIGNhbiBqdXN0IG11bHRp cGx5IGl0LgotICAgICAgICB4Zm9ybSA9IG1fb3JnVHJhbnNmb3JtICogeGZvcm07CisgICAgICAg IHhmb3JtICo9IG1fb3JnVHJhbnNmb3JtOwogICAgICAgICBtX2RyYXdDb250ZXh0LT5jb25jYXRD VE0oeGZvcm0pOwogICAgIH0KICAgICBtX2RyYXdSZWN0ID0gbV9zb3VyY2VSZWN0OwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVU cmFuc2Zvcm0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jt cy9BZmZpbmVUcmFuc2Zvcm0uY3BwCmluZGV4IGYyNzU1MjZiZDQwNjNiYjE2ZTdlMDI2YmNkMzcz MDc5NmE1NWRhYzUuLjNmODgxNDA2OGM0ZDhiMjQ2MjhmYTIzZjczNmQ0MGJlZWY3ZGJkOTEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZm aW5lVHJhbnNmb3JtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90 cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5jcHAKQEAgLTE2NCwxMiArMTY0LDEwIEBAIEFmZmlu ZVRyYW5zZm9ybSBBZmZpbmVUcmFuc2Zvcm06OmludmVyc2UoKSBjb25zdAogICAgIHJldHVybiBy ZXN1bHQ7CiB9CiAKLUFmZmluZVRyYW5zZm9ybSYgQWZmaW5lVHJhbnNmb3JtOjptdWx0aXBseShj b25zdCBBZmZpbmVUcmFuc2Zvcm0mIG90aGVyKQotewotICAgIHJldHVybiAoKnRoaXMpICo9IG90 aGVyOwotfQogCi1BZmZpbmVUcmFuc2Zvcm0mIEFmZmluZVRyYW5zZm9ybTo6bXVsdExlZnQoY29u c3QgQWZmaW5lVHJhbnNmb3JtJiBvdGhlcikKKy8vIE11bHRpcGxpZXMgdGhpcyBBZmZpbmVUcmFu c2Zvcm0gYnkgdGhlIHByb3ZpZGVkIEFmZmluZVRyYW5zZm9ybSAtIGkuZS4KKy8vIHRoaXMgPSB0 aGlzICogb3RoZXI7CitBZmZpbmVUcmFuc2Zvcm0mIEFmZmluZVRyYW5zZm9ybTo6bXVsdGlwbHko Y29uc3QgQWZmaW5lVHJhbnNmb3JtJiBvdGhlcikKIHsKICAgICBBZmZpbmVUcmFuc2Zvcm0gdHJh bnM7CiAgICAgCkBAIC0xOTIsNyArMTkwLDcgQEAgQWZmaW5lVHJhbnNmb3JtJiBBZmZpbmVUcmFu c2Zvcm06OnJvdGF0ZShkb3VibGUgYSkKICAgICBkb3VibGUgc2luQW5nbGUgPSBzaW4oYSk7CiAg ICAgQWZmaW5lVHJhbnNmb3JtIHJvdChjb3NBbmdsZSwgc2luQW5nbGUsIC1zaW5BbmdsZSwgY29z QW5nbGUsIDAsIDApOwogCi0gICAgbXVsdExlZnQocm90KTsKKyAgICBtdWx0aXBseShyb3QpOwog ICAgIHJldHVybiAqdGhpczsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uaCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmgKaW5kZXggYmFl ZTEwMmE5NTZjYTgyMzkyNGY2YTlhNTBhYmU3NzA4OTA1ODQ3OS4uYzBiNTAxZDE5YTU1NjVhMzlk ZGJkOGVkZGYyZDg5ZWJjMDU0MWE2MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5oCkBAIC05 NSw4ICs5NSw3IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgbWFrZUlkZW50aXR5KCk7CiAKLSAgICBB ZmZpbmVUcmFuc2Zvcm0mIG11bHRpcGx5KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYpOwotICAgIEFm ZmluZVRyYW5zZm9ybSYgbXVsdExlZnQoY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CisgICAgQWZm aW5lVHJhbnNmb3JtJiBtdWx0aXBseShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIG90aGVyKTsKICAg ICBBZmZpbmVUcmFuc2Zvcm0mIHNjYWxlKGRvdWJsZSk7IAogICAgIEFmZmluZVRyYW5zZm9ybSYg c2NhbGUoZG91YmxlIHN4LCBkb3VibGUgc3kpOyAKICAgICBBZmZpbmVUcmFuc2Zvcm0mIHNjYWxl Tm9uVW5pZm9ybShkb3VibGUgc3gsIGRvdWJsZSBzeSk7CkBAIC0xNDcsMTUgKzE0NiwxNCBAQCBw dWJsaWM6CiAgICAgLy8gKnRoaXMgPSAqdGhpcyAqIHQgKGkuZS4sIGEgbXVsdFJpZ2h0KQogICAg IEFmZmluZVRyYW5zZm9ybSYgb3BlcmF0b3IqPShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHQpCiAg ICAgewotICAgICAgICAqdGhpcyA9ICp0aGlzICogdDsKLSAgICAgICAgcmV0dXJuICp0aGlzOwor ICAgICAgICByZXR1cm4gdGhpcy0+bXVsdGlwbHkodCk7CiAgICAgfQogICAgIAogICAgIC8vIHJl c3VsdCA9ICp0aGlzICogdCAoaS5lLiwgYSBtdWx0UmlnaHQpCiAgICAgQWZmaW5lVHJhbnNmb3Jt IG9wZXJhdG9yKihjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHQpIGNvbnN0CiAgICAgewotICAgICAg ICBBZmZpbmVUcmFuc2Zvcm0gcmVzdWx0ID0gdDsKLSAgICAgICAgcmVzdWx0Lm11bHRMZWZ0KCp0 aGlzKTsKKyAgICAgICAgQWZmaW5lVHJhbnNmb3JtIHJlc3VsdCA9ICp0aGlzOworICAgICAgICBy ZXN1bHQgKj0gdDsKICAgICAgICAgcmV0dXJuIHJlc3VsdDsKICAgICB9CiAKQEAgLTE4MSw2ICsx NzksOCBAQCBwcml2YXRlOgogICAgIH0KIAogICAgIFRyYW5zZm9ybSBtX3RyYW5zZm9ybTsKKwor ICAgIEFmZmluZVRyYW5zZm9ybSYgcG9zdE11bHRpcGx5KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYp OwogfTsKIAogQWZmaW5lVHJhbnNmb3JtIG1ha2VNYXBCZXR3ZWVuUmVjdHMoY29uc3QgRmxvYXRS ZWN0JiBzb3VyY2UsIGNvbnN0IEZsb2F0UmVjdCYgZGVzdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGljc0NvbnRleHRXaW5DRS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGljc0NvbnRleHRX aW5DRS5jcHAKaW5kZXggMmRlZjZhYjg5NjYwZjFlMDkwNDg5ZTk5NGVhM2Q0ZTY2MDkxZDE4MS4u MWI4YTcwNDdhNDQ5MjE4ODc5NjA5MmIwNmY1MDc2MjkyNWZkYjU0YyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250ZXh0V2luQ0Uu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL0dyYXBoaWNz Q29udGV4dFdpbkNFLmNwcApAQCAtMjA5LDcgKzIwOSw3IEBAIHB1YmxpYzoKIAogICAgIHZvaWQg IGNvbmNhdENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSkKICAgICB7Ci0gICAg ICAgIG1fdHJhbnNmb3JtID0gdHJhbnNmb3JtICogbV90cmFuc2Zvcm07CisgICAgICAgIG1fdHJh bnNmb3JtICo9IHRyYW5zZm9ybTsKICAgICB9CiAKICAgICBJbnRSZWN0IG1hcFJlY3QoY29uc3Qg SW50UmVjdCYgcmVjdCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL3dpbmNlL1NoYXJlZEJpdG1hcC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy93aW5jZS9TaGFyZWRCaXRtYXAuY3BwCmluZGV4IDA1ZDE1MzVmZTlhOWRmNzdi N2M2ZmVlNTUwODRmNzEyZDBiYjg0YzMuLjE2OGE1ZTIzMDgxNGJmMDdkOWYzYzFiNGVjZGY5MmRi MDhiMzM2NTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dp bmNlL1NoYXJlZEJpdG1hcC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3Mvd2luY2UvU2hhcmVkQml0bWFwLmNwcApAQCAtNDQ1LDggKzQ0NSw3IEBAIHZvaWQgU2hhcmVk Qml0bWFwOjpkcmF3UGF0dGVybihIREMgaGRjLCBjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5z Zm9ybSwgY29uc3QKICAgICAgICAgYm1wSGVpZ2h0ID0gdGlsZVJlY3QuaGVpZ2h0KCk7CiAgICAg fQogCi0gICAgQWZmaW5lVHJhbnNmb3JtIHRmID0gdHJhbnNmb3JtOwotICAgIHRmICo9IHBhdHRl cm5UcmFuc2Zvcm07CisgICAgQWZmaW5lVHJhbnNmb3JtIHRmID0gcGF0dGVyblRyYW5zZm9ybSAq IHRyYW5zZm9ybTsKIAogICAgIEZsb2F0UmVjdCB0clJlY3QgPSB0Zi5tYXBSZWN0KGRlc3RSZWN0 KTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdS ZXNvdXJjZUNvbnRhaW5lci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRl clNWR1Jlc291cmNlQ29udGFpbmVyLmNwcAppbmRleCAyYThhNDdmYjkzNDQ3YWNkNWI2OGMyYjE2 NzVhZjU4NjFhZmJjYTk4Li5kNWJjZGY4NTk0ZThiMjhjOWFmODkxMTRlYTAxNzg5NTFlMjUzNThi IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291 cmNlQ29udGFpbmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRl clNWR1Jlc291cmNlQ29udGFpbmVyLmNwcApAQCAtMTUsNiArMTUsNyBAQAogICogYWxvbmcgd2l0 aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUg dG8KICAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0 cmVldCwgRmlmdGggRmxvb3IsCiAgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqCiAg Ki8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgpAQCAtMTgyLDggKzE4Myw4IEBAIEFmZmluZVRyYW5z Zm9ybSBSZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lcjo6dHJhbnNmb3JtT25Ob25TY2FsaW5nU3Ry b2tlKFJlbmRlck9iCiAgICAgICAgIHJldHVybiByZXNvdXJjZVRyYW5zZm9ybTsKIAogICAgIFNW R1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50KiBlbGVtZW50ID0gc3RhdGljX2Nhc3Q8U1ZHU3R5 bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQqPihvYmplY3QtPm5vZGUoKSk7Ci0gICAgQWZmaW5lVHJh bnNmb3JtIHRyYW5zZm9ybSA9IHJlc291cmNlVHJhbnNmb3JtOwotICAgIHRyYW5zZm9ybS5tdWx0 aXBseShlbGVtZW50LT5nZXRTY3JlZW5DVE0oU1ZHTG9jYXRhYmxlOjpEaXNhbGxvd1N0eWxlVXBk YXRlKSk7CisgICAgQWZmaW5lVHJhbnNmb3JtIHRyYW5zZm9ybSA9IGVsZW1lbnQtPmdldFNjcmVl bkNUTShTVkdMb2NhdGFibGU6OkRpc2FsbG93U3R5bGVVcGRhdGUpOworICAgIHRyYW5zZm9ybSAq PSByZXNvdXJjZVRyYW5zZm9ybTsKICAgICByZXR1cm4gdHJhbnNmb3JtOwogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291cmNlR3JhZGll bnQuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdSZXNvdXJjZUdy YWRpZW50LmNwcAppbmRleCA1YWQ1ZDg0M2FmZTU0YTA5ZjFkMzE2ZDNjN2Q1ODU0Yjk1ZDNkMmU1 Li44NTIyZjhhMjI1ZjA5ODE1ODVhN2NjNWVjZWM4ZDRjNzhmYzJjMWFmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291cmNlR3JhZGllbnQuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUmVzb3VyY2VHcmFk aWVudC5jcHAKQEAgLTE4LDYgKzE4LDcgQEAKICAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBz ZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCiAgKiB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LAogICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKgogICovCiAKICNpbmNsdWRlICJj b25maWcuaCIKQEAgLTEzMyw3ICsxMzQsNyBAQCBzdGF0aWMgaW5saW5lIEFmZmluZVRyYW5zZm9y bSBjbGlwVG9UZXh0TWFzayhHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsCiAgICAgICAgIG1hdHJp eC50cmFuc2xhdGUobWFza0JvdW5kaW5nQm94LngoKSwgbWFza0JvdW5kaW5nQm94LnkoKSk7CiAg ICAgICAgIG1hdHJpeC5zY2FsZU5vblVuaWZvcm0obWFza0JvdW5kaW5nQm94LndpZHRoKCksIG1h c2tCb3VuZGluZ0JveC5oZWlnaHQoKSk7CiAgICAgfQotICAgIG1hdHJpeC5tdWx0TGVmdChncmFk aWVudFRyYW5zZm9ybSk7CisgICAgbWF0cml4ICo9IGdyYWRpZW50VHJhbnNmb3JtOwogICAgIHJl dHVybiBtYXRyaXg7CiB9CiAjZW5kaWYKQEAgLTE5MCw3ICsxOTEsNyBAQCBib29sIFJlbmRlclNW R1Jlc291cmNlR3JhZGllbnQ6OmFwcGx5UmVzb3VyY2UoUmVuZGVyT2JqZWN0KiBvYmplY3QsIFJl bmRlclN0eWxlKgogICAgICAgICBBZmZpbmVUcmFuc2Zvcm0gZ3JhZGllbnRUcmFuc2Zvcm07CiAg ICAgICAgIGNhbGN1bGF0ZUdyYWRpZW50VHJhbnNmb3JtKGdyYWRpZW50VHJhbnNmb3JtKTsKIAot ICAgICAgICBncmFkaWVudERhdGEtPnVzZXJzcGFjZVRyYW5zZm9ybS5tdWx0TGVmdChncmFkaWVu dFRyYW5zZm9ybSk7CisgICAgICAgIGdyYWRpZW50RGF0YS0+dXNlcnNwYWNlVHJhbnNmb3JtICo9 IGdyYWRpZW50VHJhbnNmb3JtOwogICAgICAgICBncmFkaWVudERhdGEtPmdyYWRpZW50LT5zZXRH cmFkaWVudFNwYWNlVHJhbnNmb3JtKGdyYWRpZW50RGF0YS0+dXNlcnNwYWNlVHJhbnNmb3JtKTsK ICAgICB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVy U1ZHUmVzb3VyY2VQYXR0ZXJuLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVu ZGVyU1ZHUmVzb3VyY2VQYXR0ZXJuLmNwcAppbmRleCAzMzBhMjFhYzIwYWI0ZGUyMWE4YjllMGVm NTVjZDQxZmQxMTI4Y2RkLi4zNGY2N2FlNzU2MWM0ZDg0Y2U5MWMyZTRkMmE3MTU3N2ZkMDFiZmE4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291 cmNlUGF0dGVybi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJT VkdSZXNvdXJjZVBhdHRlcm4uY3BwCkBAIC0xNiw2ICsxNiw3IEBACiAgKiBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwog ICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKICAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICoKICAqLwog CiAjaW5jbHVkZSAiY29uZmlnLmgiCkBAIC0xMzksNyArMTQwLDcgQEAgYm9vbCBSZW5kZXJTVkdS ZXNvdXJjZVBhdHRlcm46OmFwcGx5UmVzb3VyY2UoUmVuZGVyT2JqZWN0KiBvYmplY3QsIFJlbmRl clN0eWxlKgogCiAgICAgICAgIEFmZmluZVRyYW5zZm9ybSBwYXR0ZXJuVHJhbnNmb3JtID0gbV9h dHRyaWJ1dGVzLnBhdHRlcm5UcmFuc2Zvcm0oKTsKICAgICAgICAgaWYgKCFwYXR0ZXJuVHJhbnNm b3JtLmlzSWRlbnRpdHkoKSkKLSAgICAgICAgICAgIHBhdHRlcm5EYXRhLT50cmFuc2Zvcm0ubXVs dGlwbHkocGF0dGVyblRyYW5zZm9ybSk7CisgICAgICAgICAgICBwYXR0ZXJuRGF0YS0+dHJhbnNm b3JtID0gcGF0dGVyblRyYW5zZm9ybSAqIHBhdHRlcm5EYXRhLT50cmFuc2Zvcm07CiAKICAgICAg ICAgcGF0dGVybkRhdGEtPnBhdHRlcm4tPnNldFBhdHRlcm5TcGFjZVRyYW5zZm9ybShwYXR0ZXJu RGF0YS0+dHJhbnNmb3JtKTsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvc3ZnL1JlbmRlclNWR1Jvb3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2 Zy9SZW5kZXJTVkdSb290LmNwcAppbmRleCBhYTg3YjA5ZGZmYTU3MzdmMzQ2ZWE1ZmY3MjMyZGFk OGI2ZjAyMTk5Li4zYThkY2U5ZmYyNGNkMWUwMGE1ZDIzZWIzZWVlMTVmNzI2MzBkMWZkIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jvb3QuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUm9vdC5jcHAKQEAgLTI0 Niw3ICsyNDYsNyBAQCBBZmZpbmVUcmFuc2Zvcm0gUmVuZGVyU1ZHUm9vdDo6bG9jYWxUb0JvcmRl ckJveFRyYW5zZm9ybSgpIGNvbnN0CiAgICAgZmxvYXQgc2NhbGUgPSBzdmctPmN1cnJlbnRTY2Fs ZSgpOwogICAgIEZsb2F0UG9pbnQgdHJhbnNsYXRlID0gc3ZnLT5jdXJyZW50VHJhbnNsYXRlKCk7 CiAgICAgQWZmaW5lVHJhbnNmb3JtIGN0bShzY2FsZSwgMCwgMCwgc2NhbGUsIGJvcmRlckFuZFBh ZGRpbmcud2lkdGgoKSArIHRyYW5zbGF0ZS54KCksIGJvcmRlckFuZFBhZGRpbmcuaGVpZ2h0KCkg KyB0cmFuc2xhdGUueSgpKTsKLSAgICByZXR1cm4gc3ZnLT52aWV3Qm94VG9WaWV3VHJhbnNmb3Jt KHdpZHRoKCkgLyBzY2FsZSwgaGVpZ2h0KCkgLyBzY2FsZSkgKiBjdG07CisgICAgcmV0dXJuIGN0 bSAqIHN2Zy0+dmlld0JveFRvVmlld1RyYW5zZm9ybSh3aWR0aCgpIC8gc2NhbGUsIGhlaWdodCgp IC8gc2NhbGUpOwogfQogCiBJbnRTaXplIFJlbmRlclNWR1Jvb3Q6OnBhcmVudE9yaWdpblRvQm9y ZGVyQm94KCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcv U1ZHSW1hZ2VCdWZmZXJUb29scy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1NW R0ltYWdlQnVmZmVyVG9vbHMuY3BwCmluZGV4IGYwNjU3YWYxODQ2OTllNTFiZjQwODY1ZTNhNGE3 MmI0YWI1MWVlMzkuLjY3MjY2OTRkMTAzZjE5MjI4NGZiMDRlNTY2MjAzODM3OTNmY2QxNDkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvU1ZHSW1hZ2VCdWZmZXJUb29s cy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9TVkdJbWFnZUJ1ZmZlclRv b2xzLmNwcApAQCAtNDMsNyArNDMsNyBAQCB2b2lkIFNWR0ltYWdlQnVmZmVyVG9vbHM6OmNhbGN1 bGF0ZVRyYW5zZm9ybWF0aW9uVG9PdXRlcm1vc3RTVkdDb29yZGluYXRlU3lzdGVtKAogCiAgICAg YWJzb2x1dGVUcmFuc2Zvcm0gPSBjdXJyZW50Q29udGVudFRyYW5zZm9ybWF0aW9uKCk7CiAgICAg d2hpbGUgKGN1cnJlbnQpIHsKLSAgICAgICAgYWJzb2x1dGVUcmFuc2Zvcm0ubXVsdGlwbHkoY3Vy cmVudC0+bG9jYWxUb1BhcmVudFRyYW5zZm9ybSgpKTsKKyAgICAgICAgYWJzb2x1dGVUcmFuc2Zv cm0gPSBjdXJyZW50LT5sb2NhbFRvUGFyZW50VHJhbnNmb3JtKCkgKiBhYnNvbHV0ZVRyYW5zZm9y bTsKICAgICAgICAgaWYgKGN1cnJlbnQtPmlzU1ZHUm9vdCgpKQogICAgICAgICAgICAgYnJlYWs7 CiAgICAgICAgIGN1cnJlbnQgPSBjdXJyZW50LT5wYXJlbnQoKTsKQEAgLTgzLDcgKzgzLDcgQEAg dm9pZCBTVkdJbWFnZUJ1ZmZlclRvb2xzOjpyZW5kZXJTdWJ0cmVlVG9JbWFnZUJ1ZmZlcihJbWFn ZUJ1ZmZlciogaW1hZ2UsIFJlbmRlck8KIAogICAgIEFmZmluZVRyYW5zZm9ybSYgY29udGVudFRy YW5zZm9ybWF0aW9uID0gY3VycmVudENvbnRlbnRUcmFuc2Zvcm1hdGlvbigpOwogICAgIEFmZmlu ZVRyYW5zZm9ybSBzYXZlZENvbnRlbnRUcmFuc2Zvcm1hdGlvbiA9IGNvbnRlbnRUcmFuc2Zvcm1h dGlvbjsKLSAgICBjb250ZW50VHJhbnNmb3JtYXRpb24ubXVsdGlwbHkoc3VidHJlZUNvbnRlbnRU cmFuc2Zvcm1hdGlvbik7CisgICAgY29udGVudFRyYW5zZm9ybWF0aW9uID0gc3VidHJlZUNvbnRl bnRUcmFuc2Zvcm1hdGlvbiAqIGNvbnRlbnRUcmFuc2Zvcm1hdGlvbjsKIAogICAgIGl0ZW0tPmxh eW91dElmTmVlZGVkKCk7CiAgICAgaXRlbS0+cGFpbnQoaW5mbywgMCwgMCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1NWR1RleHRMYXlvdXRFbmdpbmUuY3BwIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9TVkdUZXh0TGF5b3V0RW5naW5lLmNwcAppbmRl eCA3ZWVmYWQ2NTY2MzZkOTJlNTI2Yjk4OTRiNDllN2I1MTA0ZWY2ZGNmLi4zYjI4ZDJiZDE2ZTdi NTZmMzZkOWViYmIxNGUxNmRlODNjOGEwMWNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvc3ZnL1NWR1RleHRMYXlvdXRFbmdpbmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9zdmcvU1ZHVGV4dExheW91dEVuZ2luZS5jcHAKQEAgLTMyMSw3ICszMjEsNyBA QCB2b2lkIFNWR1RleHRMYXlvdXRFbmdpbmU6OmZpbmFsaXplVHJhbnNmb3JtTWF0cmljZXMoVmVj dG9yPFNWR0lubGluZVRleHRCb3gqPiYgYgogICAgICAgICAgICAgaWYgKHRyYW5zZm9ybS5pc0lk ZW50aXR5KCkpCiAgICAgICAgICAgICAgICAgdHJhbnNmb3JtID0gdGV4dEJveFRyYW5zZm9ybWF0 aW9uOwogICAgICAgICAgICAgZWxzZQotICAgICAgICAgICAgICAgIHRyYW5zZm9ybS5tdWx0aXBs eSh0ZXh0Qm94VHJhbnNmb3JtYXRpb24pOworICAgICAgICAgICAgICAgIHRyYW5zZm9ybSA9IHRl eHRCb3hUcmFuc2Zvcm1hdGlvbiAqIHRyYW5zZm9ybTsKICAgICAgICAgfQogICAgIH0KIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0xvY2F0YWJsZS5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHTG9jYXRhYmxlLmNwcAppbmRleCA0Mzk2MWQ5NTQxOWJhYTM5NjQ5MjZkZDE1 MGEyZjQ1MjEyM2I1ZDE3Li4yYTdjOWJlMDlmZDY4NThiN2YwM2E2ZjA3N2U4ZTI0NjhkMzVmZDMz IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHTG9jYXRhYmxlLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9zdmcvU1ZHTG9jYXRhYmxlLmNwcApAQCAtOTEsNyArOTEsOCBAQCBBZmZp bmVUcmFuc2Zvcm0gU1ZHTG9jYXRhYmxlOjpjb21wdXRlQ1RNKGNvbnN0IFNWR0VsZW1lbnQqIGVs ZW1lbnQsIENUTVNjb3BlIG1vZAogICAgIHdoaWxlIChjdXJyZW50ICYmIGN1cnJlbnQtPmlzU1ZH RWxlbWVudCgpKSB7CiAgICAgICAgIFNWR0VsZW1lbnQqIGN1cnJlbnRFbGVtZW50ID0gc3RhdGlj X2Nhc3Q8U1ZHRWxlbWVudCo+KGN1cnJlbnQpOwogICAgICAgICBpZiAoY3VycmVudEVsZW1lbnQt PmlzU3R5bGVkKCkpCi0gICAgICAgICAgICBjdG0gPSBzdGF0aWNfY2FzdDxTVkdTdHlsZWRFbGVt ZW50Kj4oY3VycmVudEVsZW1lbnQpLT5sb2NhbENvb3JkaW5hdGVTcGFjZVRyYW5zZm9ybShtb2Rl KS5tdWx0TGVmdChjdG0pOworICAgICAgICAgICAgLy8gbm90ZSB0aGF0IHRoaXMgbW9kaWZpZXMg dGhlIEFmZmluZVRyYW5zZm9ybSByZXR1cm5lZCBieSBsb2NhbENvb3JkaW5hdGVTcGFjZVRyYW5z Zm9ybShtb2RlKSB0b28uCisgICAgICAgICAgICBjdG0gPSBzdGF0aWNfY2FzdDxTVkdTdHlsZWRF bGVtZW50Kj4oY3VycmVudEVsZW1lbnQpLT5sb2NhbENvb3JkaW5hdGVTcGFjZVRyYW5zZm9ybSht b2RlKS5tdWx0aXBseShjdG0pOwogCiAgICAgICAgIC8vIEZvciBnZXRDVE0oKSBjb21wdXRhdGlv biwgc3RvcCBhdCB0aGUgbmVhcmVzdCB2aWV3cG9ydCBlbGVtZW50CiAgICAgICAgIGlmIChjdXJy ZW50RWxlbWVudCA9PSBzdG9wQXRFbGVtZW50KQpAQCAtMTEzLDcgKzExNCw3IEBAIEFmZmluZVRy YW5zZm9ybSBTVkdMb2NhdGFibGU6OmdldFRyYW5zZm9ybVRvRWxlbWVudChTVkdFbGVtZW50KiB0 YXJnZXQsIEV4Y2VwdGlvCiAgICAgICAgICAgICBlYyA9IFNWR0V4Y2VwdGlvbjo6U1ZHX01BVFJJ WF9OT1RfSU5WRVJUQUJMRTsKICAgICAgICAgICAgIHJldHVybiBjdG07CiAgICAgICAgIH0KLSAg ICAgICAgY3RtICo9IHRhcmdldENUTS5pbnZlcnNlKCk7CisgICAgICAgIGN0bSA9IHRhcmdldENU TS5pbnZlcnNlKCkgKiBjdG07CiAgICAgfQogCiAgICAgcmV0dXJuIGN0bTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdNYXRyaXguaCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdN YXRyaXguaAppbmRleCA4MDdiNzAzMzhkNzQ3ZTUxYTEzMjBkM2E1NDlkNzU5NTgxYTY4N2M1Li4w NzdlYjAzODM0ODY2NDg3NGY3YmM1YmMzMGFiYWUzM2MyZjZjYzc4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9zdmcvU1ZHTWF0cml4LmgKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR01h dHJpeC5oCkBAIC05NiwxMSArOTYsMTAgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gc3RhdGlj X2Nhc3Q8U1ZHTWF0cml4Pihjb3B5KTsKICAgICB9CiAKLSAgICAvLyBTVkdNYXRyaXg6Om11bHRp cGx5IG5lZWRzIHRvIGNhbGwgU1ZHTWF0cml4OjptdWx0TGVmdC4KICAgICBTVkdNYXRyaXggbXVs dGlwbHkoY29uc3QgU1ZHTWF0cml4JiBvdGhlcikKICAgICB7CiAgICAgICAgIEFmZmluZVRyYW5z Zm9ybSBjb3B5ID0gKnRoaXM7Ci0gICAgICAgIGNvcHkubXVsdExlZnQoc3RhdGljX2Nhc3Q8Y29u c3QgQWZmaW5lVHJhbnNmb3JtJj4ob3RoZXIpKTsKKyAgICAgICAgY29weSAqPSBzdGF0aWNfY2Fz dDxjb25zdCBBZmZpbmVUcmFuc2Zvcm0mPihvdGhlcik7CiAgICAgICAgIHJldHVybiBzdGF0aWNf Y2FzdDxTVkdNYXRyaXg+KGNvcHkpOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvc3ZnL1NWR1NWR0VsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1NWR0VsZW1l bnQuY3BwCmluZGV4IDdlMDRmNWRiMDFiNmFmZmMzZjJiZGI1YzdkMjVmOGQ1ZTliMmI3NzEuLjQ4 M2U0NWY4ZmY1NTE5ZjM0NWYxOTNiMTgzM2Q3YjNhMTA0ZGU5OGQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3N2Zy9TVkdTVkdFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcv U1ZHU1ZHRWxlbWVudC5jcHAKQEAgLTUwMiw3ICs1MDIsNyBAQCBBZmZpbmVUcmFuc2Zvcm0gU1ZH U1ZHRWxlbWVudDo6bG9jYWxDb29yZGluYXRlU3BhY2VUcmFuc2Zvcm0oU1ZHTG9jYXRhYmxlOjpD VE1TYwogICAgICAgICB9CiAgICAgfQogCi0gICAgcmV0dXJuIHRyYW5zZm9ybS5tdWx0TGVmdCh2 aWV3Qm94VHJhbnNmb3JtKTsKKyAgICByZXR1cm4gdHJhbnNmb3JtLm11bHRpcGx5KHZpZXdCb3hU cmFuc2Zvcm0pOwogfQogCiBSZW5kZXJPYmplY3QqIFNWR1NWR0VsZW1lbnQ6OmNyZWF0ZVJlbmRl cmVyKFJlbmRlckFyZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqKQpAQCAtNTg3LDEyICs1ODcsMTEg QEAgQWZmaW5lVHJhbnNmb3JtIFNWR1NWR0VsZW1lbnQ6OnZpZXdCb3hUb1ZpZXdUcmFuc2Zvcm0o ZmxvYXQgdmlld1dpZHRoLCBmbG9hdCB2aWUKICAgICAgICAgdmlld0JveFJlY3QgPSB2aWV3Qm94 KCk7CiAKICAgICBBZmZpbmVUcmFuc2Zvcm0gY3RtID0gU1ZHRml0VG9WaWV3Qm94Ojp2aWV3Qm94 VG9WaWV3VHJhbnNmb3JtKHZpZXdCb3hSZWN0LCBwcmVzZXJ2ZUFzcGVjdFJhdGlvKCksIHZpZXdX aWR0aCwgdmlld0hlaWdodCk7CisKICAgICBpZiAodXNlQ3VycmVudFZpZXcoKSAmJiBjdXJyZW50 VmlldygpKSB7CiAgICAgICAgIEFmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm07Ci0gICAgICAgIGlm ICghY3VycmVudFZpZXcoKS0+dHJhbnNmb3JtKCkuY29uY2F0ZW5hdGUodHJhbnNmb3JtKSkKLSAg ICAgICAgICAgIHJldHVybiBjdG07Ci0KLSAgICAgICAgcmV0dXJuIHRyYW5zZm9ybSAqIGN0bTsK KyAgICAgICAgaWYgKGN1cnJlbnRWaWV3KCktPnRyYW5zZm9ybSgpLmNvbmNhdGVuYXRlKHRyYW5z Zm9ybSkpCisgICAgICAgICAgICBjdG0gKj0gdHJhbnNmb3JtOwogICAgIH0KIAogICAgIHJldHVy biBjdG07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHU3R5bGVkVHJhbnNmb3Jt YWJsZUVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1N0eWxlZFRyYW5zZm9ybWFi bGVFbGVtZW50LmNwcAppbmRleCAyMzM0OTQzYzU2MmViNDA5ODlhZjBkMTQ2YzFhMGJlNjJlYTYz MjYyLi4xNTUyOGUwOTMyOWUyMzkwM2YwZTMyNGJlM2Y5ODQ4NDdiODAwNGQ5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVudC5jcHAK QEAgLTU2LDcgKzU2LDkgQEAgQWZmaW5lVHJhbnNmb3JtIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVF bGVtZW50OjphbmltYXRlZExvY2FsVHJhbnNmb3JtKCkgY29uc3QKIHsKICAgICBBZmZpbmVUcmFu c2Zvcm0gbWF0cml4OwogICAgIHRyYW5zZm9ybSgpLmNvbmNhdGVuYXRlKG1hdHJpeCk7Ci0gICAg cmV0dXJuIG1fc3VwcGxlbWVudGFsVHJhbnNmb3JtID8gKm1fc3VwcGxlbWVudGFsVHJhbnNmb3Jt ICogbWF0cml4IDogbWF0cml4OworICAgIGlmIChtX3N1cHBsZW1lbnRhbFRyYW5zZm9ybSkKKyAg ICAgICAgbWF0cml4ICo9ICptX3N1cHBsZW1lbnRhbFRyYW5zZm9ybTsKKyAgICByZXR1cm4gbWF0 cml4OwogfQogCiBBZmZpbmVUcmFuc2Zvcm0qIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50 OjpzdXBwbGVtZW50YWxUcmFuc2Zvcm0oKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3Zn L1NWR1RleHRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0RWxlbWVudC5j cHAKaW5kZXggNzIyOTgyNDVjNTZmZTQyNTZlODVhNDRhOWY3NTk2MWExNzY2NGIzZC4uYjYwOTRj OTAxNjdmMDU0YzQ4NDBiODBkYjMwM2E2YzNmMjEyYTVkOCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvc3ZnL1NWR1RleHRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZH VGV4dEVsZW1lbnQuY3BwCkBAIC04OSw3ICs4OSw5IEBAIEFmZmluZVRyYW5zZm9ybSBTVkdUZXh0 RWxlbWVudDo6YW5pbWF0ZWRMb2NhbFRyYW5zZm9ybSgpIGNvbnN0CiB7CiAgICAgQWZmaW5lVHJh bnNmb3JtIG1hdHJpeDsKICAgICB0cmFuc2Zvcm0oKS5jb25jYXRlbmF0ZShtYXRyaXgpOwotICAg IHJldHVybiBtX3N1cHBsZW1lbnRhbFRyYW5zZm9ybSA/ICptX3N1cHBsZW1lbnRhbFRyYW5zZm9y bSAqIG1hdHJpeCA6IG1hdHJpeDsKKyAgICBpZiAobV9zdXBwbGVtZW50YWxUcmFuc2Zvcm0pCisg ICAgICAgIG1hdHJpeCAqPSAqbV9zdXBwbGVtZW50YWxUcmFuc2Zvcm07CisgICAgcmV0dXJuIG1h dHJpeDsKIH0KIAogQWZmaW5lVHJhbnNmb3JtKiBTVkdUZXh0RWxlbWVudDo6c3VwcGxlbWVudGFs VHJhbnNmb3JtKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUcmFuc2Zvcm1M aXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUcmFuc2Zvcm1MaXN0LmNwcAppbmRleCA1 MmJmYzg1MjVjN2FmNzJkOWNjMzIwMTU0NzQxNjdmOTQ3NTdkOTBjLi4xODAwYjFlYzAzZmE1YTli MGQ5YzNiNzBiODI4N2IwYzYyYjA5ODhkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcv U1ZHVHJhbnNmb3JtTGlzdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1RyYW5zZm9y bUxpc3QuY3BwCkBAIC01Niw3ICs1Niw3IEBAIGJvb2wgU1ZHVHJhbnNmb3JtTGlzdDo6Y29uY2F0 ZW5hdGUoQWZmaW5lVHJhbnNmb3JtJiByZXN1bHQpIGNvbnN0CiAgICAgICAgIHJldHVybiBmYWxz ZTsKIAogICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBzaXplOyArK2kpCi0gICAgICAgIHJl c3VsdCA9IGF0KGkpLm1hdHJpeCgpICogcmVzdWx0OworICAgICAgICByZXN1bHQgKj0gYXQoaSku bWF0cml4KCk7CiAKICAgICByZXR1cm4gdHJ1ZTsKIH0K 78871 2011-01-13 16:17:27 -0800 2011-01-19 12:10:25 -0800 Patch bug-48031-20110114111724.patch text/plain 23298 shanestephens ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBkM2MyZDc0MmZjNjc0MjM3YTBhOTA3ZmU2NzA1MWQzZDE5MjM1ZmMxLi5k M2IxZmEyMTY0NzQ4OTdjY2ZiMTRlYzVmMTcxOTFlMDU2NWE0NjM3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsNjggQEAKKzIwMTEtMDEtMTQgIFNoYW5lIFN0ZXBoZW5zICA8c2hhbmVzdGVwaGVuc0Bn b29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE1ha2UgQWZmaW5lVHJhbnNmb3JtIGFuZCBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBkbyBtYXRy aXggbXVsdGlwbGljYXRpb24gaW4gdGhlIGNvcnJlY3Qgb3JkZXIgKENvbHVtbiBNYWpvcikKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ4MDMxCisKKyAg ICAgICAgRml4ZWQgcmV2ZXJzYWwsIHJlbmFtZWQgbWF0cml4IG1ldGhvZHMgdG8gYmUgY2xlYXJl ciwgZm91bmQgYWxsIGV4YW1wbGVzIG9mIG9wZXJhdG9yKiBhbmQKKyAgICAgICAgb3BlcmF0b3Iq PSB1c2FnZSBhbmQgc3dpdGNoZWQgb3BlcmFuZCBvcmRlci4KKworICAgICAgICBObyBuZXcgdGVz dHMgYXMgdGhpcyByZWZhY3RvciBkb2Vzbid0IGFkZCBmdW5jdGlvbmFsaXR5LgorCisgICAgICAg ICogaHRtbC9IVE1MQ2FudmFzRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MQ2Fu dmFzRWxlbWVudDo6YmFzZVRyYW5zZm9ybSk6CisgICAgICAgICogaHRtbC9jYW52YXMvQ2FudmFz UmVuZGVyaW5nQ29udGV4dDJELmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNhbnZhc1JlbmRlcmlu Z0NvbnRleHQyRDo6dHJhbnNmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OkNhbnZhc1JlbmRlcmlu Z0NvbnRleHQyRDo6c2V0VHJhbnNmb3JtKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9j Zy9QYXR0ZXJuQ0cuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGF0dGVybjo6Y3JlYXRlUGxhdGZv cm1QYXR0ZXJuKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9HTEVTMkNh bnZhcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHTEVTMkNhbnZhczo6ZmlsbFJlY3QpOgorICAg ICAgICAoV2ViQ29yZTo6R0xFUzJDYW52YXM6OmNvbmNhdENUTSk6CisgICAgICAgIChXZWJDb3Jl OjpHTEVTMkNhbnZhczo6ZHJhd1F1YWQpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUcmFuc3BhcmVu Y3lXaW46OnNldHVwTGF5ZXJGb3JPcGFxdWVDb21wb3NpdGVMYXllcik6CisgICAgICAgIChXZWJD b3JlOjpUcmFuc3BhcmVuY3lXaW46OnNldHVwVHJhbnNmb3JtRm9yS2VlcFRyYW5zZm9ybSk6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3Bw OgorICAgICAgICAoV2ViQ29yZTo6QWZmaW5lVHJhbnNmb3JtOjptdWx0aXBseSk6CisgICAgICAg IChXZWJDb3JlOjpBZmZpbmVUcmFuc2Zvcm06OnJvdGF0ZSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uaDoKKyAgICAgICAgKFdlYkNvcmU6 OkFmZmluZVRyYW5zZm9ybTo6b3BlcmF0b3IqPSk6CisgICAgICAgIChXZWJDb3JlOjpBZmZpbmVU cmFuc2Zvcm06Om9wZXJhdG9yKik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2Uv R3JhcGhpY3NDb250ZXh0V2luQ0UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250 ZXh0UGxhdGZvcm1Qcml2YXRlOjpjb25jYXRDVE0pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL3dpbmNlL1NoYXJlZEJpdG1hcC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCaXRt YXA6OmRyYXdQYXR0ZXJuKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291 cmNlQ29udGFpbmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclNWR1Jlc291cmNlQ29u dGFpbmVyOjp0cmFuc2Zvcm1Pbk5vblNjYWxpbmdTdHJva2UpOgorICAgICAgICAqIHJlbmRlcmlu Zy9zdmcvUmVuZGVyU1ZHUmVzb3VyY2VHcmFkaWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpj bGlwVG9UZXh0TWFzayk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJTVkdSZXNvdXJjZUdyYWRp ZW50OjphcHBseVJlc291cmNlKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jl c291cmNlUGF0dGVybi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJTVkdSZXNvdXJjZVBh dHRlcm46OmFwcGx5UmVzb3VyY2UpOgorICAgICAgICAqIHJlbmRlcmluZy9zdmcvUmVuZGVyU1ZH Um9vdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJTVkdSb290Ojpsb2NhbFRvQm9yZGVy Qm94VHJhbnNmb3JtKToKKyAgICAgICAgKiByZW5kZXJpbmcvc3ZnL1NWR0ltYWdlQnVmZmVyVG9v bHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHSW1hZ2VCdWZmZXJUb29sczo6Y2FsY3VsYXRl VHJhbnNmb3JtYXRpb25Ub091dGVybW9zdFNWR0Nvb3JkaW5hdGVTeXN0ZW0pOgorICAgICAgICAo V2ViQ29yZTo6U1ZHSW1hZ2VCdWZmZXJUb29sczo6cmVuZGVyU3VidHJlZVRvSW1hZ2VCdWZmZXIp OgorICAgICAgICAqIHJlbmRlcmluZy9zdmcvU1ZHVGV4dExheW91dEVuZ2luZS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTVkdUZXh0TGF5b3V0RW5naW5lOjpmaW5hbGl6ZVRyYW5zZm9ybU1hdHJp Y2VzKToKKyAgICAgICAgKiBzdmcvU1ZHTG9jYXRhYmxlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlNWR0xvY2F0YWJsZTo6Y29tcHV0ZUNUTSk6CisgICAgICAgIChXZWJDb3JlOjpTVkdMb2NhdGFi bGU6OmdldFRyYW5zZm9ybVRvRWxlbWVudCk6CisgICAgICAgICogc3ZnL1NWR01hdHJpeC5oOgor ICAgICAgICAoV2ViQ29yZTo6U1ZHTWF0cml4OjptdWx0aXBseSk6CisgICAgICAgICogc3ZnL1NW R1NWR0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHU1ZHRWxlbWVudDo6bG9jYWxD b29yZGluYXRlU3BhY2VUcmFuc2Zvcm0pOgorICAgICAgICAoV2ViQ29yZTo6U1ZHU1ZHRWxlbWVu dDo6dmlld0JveFRvVmlld1RyYW5zZm9ybSk6CisgICAgICAgICogc3ZnL1NWR1N0eWxlZFRyYW5z Zm9ybWFibGVFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNWR1N0eWxlZFRyYW5zZm9y bWFibGVFbGVtZW50OjphbmltYXRlZExvY2FsVHJhbnNmb3JtKToKKyAgICAgICAgKiBzdmcvU1ZH VGV4dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1ZHVGV4dEVsZW1lbnQ6OmFuaW1h dGVkTG9jYWxUcmFuc2Zvcm0pOgorICAgICAgICAqIHN2Zy9TVkdUcmFuc2Zvcm1MaXN0LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlNWR1RyYW5zZm9ybUxpc3Q6OmNvbmNhdGVuYXRlKToKKwogMjAx MS0wMS0xMyAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29tPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IEtlbm5ldGggUnVzc2VsbC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTENhbnZhc0VsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQ2FudmFz RWxlbWVudC5jcHAKaW5kZXggZjI4Njc0OTM2OGE5NTM4NDBiMDU3NmY0MDc3MDk0N2FmNzM4ODE2 Zi4uOWQxNWU0NjE0NzJhZmMxNDFhZDA0OTI3YzY5YjExYzgxYjYyNTY4NyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQ2FudmFzRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MQ2FudmFzRWxlbWVudC5jcHAKQEAgLTQ0Niw4ICs0NDYsNyBAQCBBZmZp bmVUcmFuc2Zvcm0gSFRNTENhbnZhc0VsZW1lbnQ6OmJhc2VUcmFuc2Zvcm0oKSBjb25zdAogICAg IEFmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm07CiAgICAgaWYgKHNpemUud2lkdGgoKSAmJiBzaXpl LmhlaWdodCgpKQogICAgICAgICB0cmFuc2Zvcm0uc2NhbGVOb25Vbmlmb3JtKHNpemUud2lkdGgo KSAvIHVuc2NhbGVkU2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgpIC8gdW5zY2FsZWRTaXplLmhl aWdodCgpKTsKLSAgICB0cmFuc2Zvcm0ubXVsdGlwbHkobV9pbWFnZUJ1ZmZlci0+YmFzZVRyYW5z Zm9ybSgpKTsKLSAgICByZXR1cm4gdHJhbnNmb3JtOworICAgIHJldHVybiBtX2ltYWdlQnVmZmVy LT5iYXNlVHJhbnNmb3JtKCkgKiB0cmFuc2Zvcm07CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL2NhbnZhcy9DYW52YXNSZW5kZXJpbmdDb250ZXh0MkQuY3BwCmluZGV4 IDYyYzU3OTM3YTYxNWNjNTQ4ZjZmMmU2MDM3ZDdlMTdhYjM3NDM2YjAuLmQ0Y2JiMTc3Y2JkOWU2 MzdmN2YzMDA3NDlmNzY3OWYwN2UzN2FjNzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvY2FudmFzL0NhbnZhc1JlbmRlcmluZ0NvbnRleHQyRC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvaHRtbC9jYW52YXMvQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJELmNwcApAQCAtNTM3LDcgKzUz Nyw3IEBAIHZvaWQgQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjp0cmFuc2Zvcm0oZmxvYXQgbTEx LCBmbG9hdCBtMTIsIGZsb2F0IG0yMSwgZmxvYXQKICAgICAgICAgcmV0dXJuOwogCiAgICAgQWZm aW5lVHJhbnNmb3JtIHRyYW5zZm9ybShtMTEsIG0xMiwgbTIxLCBtMjIsIGR4LCBkeSk7Ci0gICAg QWZmaW5lVHJhbnNmb3JtIG5ld1RyYW5zZm9ybSA9IHRyYW5zZm9ybSAqIHN0YXRlKCkubV90cmFu c2Zvcm07CisgICAgQWZmaW5lVHJhbnNmb3JtIG5ld1RyYW5zZm9ybSA9IHN0YXRlKCkubV90cmFu c2Zvcm0gKiB0cmFuc2Zvcm07CiAgICAgaWYgKCFuZXdUcmFuc2Zvcm0uaXNJbnZlcnRpYmxlKCkp IHsKICAgICAgICAgc3RhdGUoKS5tX2ludmVydGlibGVDVE0gPSBmYWxzZTsKICAgICAgICAgcmV0 dXJuOwpAQCAtNTYyLDcgKzU2Miw3IEBAIHZvaWQgQ2FudmFzUmVuZGVyaW5nQ29udGV4dDJEOjpz ZXRUcmFuc2Zvcm0oZmxvYXQgbTExLCBmbG9hdCBtMTIsIGZsb2F0IG0yMSwgZmxvCiAgICAgICAg IHJldHVybjsKICAgICBjLT5jb25jYXRDVE0oYy0+Z2V0Q1RNKCkuaW52ZXJzZSgpKTsKICAgICBj LT5jb25jYXRDVE0oY2FudmFzKCktPmJhc2VUcmFuc2Zvcm0oKSk7Ci0gICAgc3RhdGUoKS5tX3Ry YW5zZm9ybS5tdWx0aXBseShjdG0uaW52ZXJzZSgpKTsKKyAgICBzdGF0ZSgpLm1fdHJhbnNmb3Jt ID0gY3RtLmludmVyc2UoKSAqIHN0YXRlKCkubV90cmFuc2Zvcm07CiAgICAgbV9wYXRoLnRyYW5z Zm9ybShjdG0pOwogCiAgICAgc3RhdGUoKS5tX2ludmVydGlibGVDVE0gPSB0cnVlOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvUGF0dGVybkNHLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL1BhdHRlcm5DRy5jcHAKaW5kZXgg OTRmMzdiMmZmMWNmNjE5NjdlYmVmZjg3MWQ2NTRjZTRhY2RlNDQyOS4uY2ZhYzE1YzM3ZjY2YzBk ZmE0MzY0NWQ3OTAzNmExMWU5ZjY5MzBmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2cvUGF0dGVybkNHLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jZy9QYXR0ZXJuQ0cuY3BwCkBAIC01NCw4ICs1NCw3IEBAIENHUGF0dGVy blJlZiBQYXR0ZXJuOjpjcmVhdGVQbGF0Zm9ybVBhdHRlcm4oY29uc3QgQWZmaW5lVHJhbnNmb3Jt JiB1c2VyU3BhY2VUcmFuCiB7CiAgICAgSW50UmVjdCB0aWxlUmVjdCA9IHRpbGVJbWFnZSgpLT5y ZWN0KCk7CiAKLSAgICBBZmZpbmVUcmFuc2Zvcm0gcGF0dGVyblRyYW5zZm9ybSA9IG1fcGF0dGVy blNwYWNlVHJhbnNmb3JtYXRpb247Ci0gICAgcGF0dGVyblRyYW5zZm9ybS5tdWx0aXBseSh1c2Vy U3BhY2VUcmFuc2Zvcm1hdGlvbik7CisgICAgQWZmaW5lVHJhbnNmb3JtIHBhdHRlcm5UcmFuc2Zv cm0gPSB1c2VyU3BhY2VUcmFuc2Zvcm1hdGlvbiAqIG1fcGF0dGVyblNwYWNlVHJhbnNmb3JtYXRp b247CiAgICAgcGF0dGVyblRyYW5zZm9ybS5zY2FsZU5vblVuaWZvcm0oMSwgLTEpOwogICAgIHBh dHRlcm5UcmFuc2Zvcm0udHJhbnNsYXRlKDAsIC10aWxlUmVjdC5oZWlnaHQoKSk7CiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMyQ2Fu dmFzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMy Q2FudmFzLmNwcAppbmRleCA2OTdjZjVlOTJkNTU5M2ViNjJmYzgzNWUyNmNmNGJiODUwZjEwNzJl Li5hZTAxN2RlZWNkZTU0MjVhMzVmOWNmZGU0MzU0YmVkODZlMzQxN2UwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9HTEVTMkNhbnZhcy5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJDYW52 YXMuY3BwCkBAIC0xMDgsNyArMTA4LDcgQEAgdm9pZCBHTEVTMkNhbnZhczo6ZmlsbFJlY3QoY29u c3QgRmxvYXRSZWN0JiByZWN0LCBjb25zdCBDb2xvciYgY29sb3IsIENvbG9yU3BhY2UKICAgICBt X2NvbnRleHQtPnVzZVF1YWRWZXJ0aWNlcygpOwogCiAgICAgQWZmaW5lVHJhbnNmb3JtIG1hdHJp eChtX2ZsaXBNYXRyaXgpOwotICAgIG1hdHJpeC5tdWx0TGVmdChtX3N0YXRlLT5tX2N0bSk7Cisg ICAgbWF0cml4ICo9IG1fc3RhdGUtPm1fY3RtOwogICAgIG1hdHJpeC50cmFuc2xhdGUocmVjdC54 KCksIHJlY3QueSgpKTsKICAgICBtYXRyaXguc2NhbGUocmVjdC53aWR0aCgpLCByZWN0LmhlaWdo dCgpKTsKIApAQCAtMTUwLDcgKzE1MCw3IEBAIHZvaWQgR0xFUzJDYW52YXM6OnNjYWxlKGNvbnN0 IEZsb2F0U2l6ZSYgc2l6ZSkKIAogdm9pZCBHTEVTMkNhbnZhczo6Y29uY2F0Q1RNKGNvbnN0IEFm ZmluZVRyYW5zZm9ybSYgYWZmaW5lKQogewotICAgIG1fc3RhdGUtPm1fY3RtLm11bHRMZWZ0KGFm ZmluZSk7CisgICAgbV9zdGF0ZS0+bV9jdG0gKj0gYWZmaW5lOwogfQogCiB2b2lkIEdMRVMyQ2Fu dmFzOjpzYXZlKCkKQEAgLTIyMCw3ICsyMjAsNyBAQCB2b2lkIEdMRVMyQ2FudmFzOjpkcmF3VGV4 dHVyZWRSZWN0VGlsZShUZXh0dXJlKiB0ZXh0dXJlLCBpbnQgdGlsZSwgY29uc3QgRmxvYXRSZQog dm9pZCBHTEVTMkNhbnZhczo6ZHJhd1F1YWQoY29uc3QgSW50U2l6ZSYgdGV4dHVyZVNpemUsIGNv bnN0IEZsb2F0UmVjdCYgc3JjUmVjdCwgY29uc3QgRmxvYXRSZWN0JiBkc3RSZWN0LCBjb25zdCBB ZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSwgZmxvYXQgYWxwaGEpCiB7CiAgICAgQWZmaW5lVHJh bnNmb3JtIG1hdHJpeChtX2ZsaXBNYXRyaXgpOwotICAgIG1hdHJpeC5tdWx0TGVmdCh0cmFuc2Zv cm0pOworICAgIG1hdHJpeCAqPSB0cmFuc2Zvcm07CiAgICAgbWF0cml4LnRyYW5zbGF0ZShkc3RS ZWN0LngoKSwgZHN0UmVjdC55KCkpOwogICAgIG1hdHJpeC5zY2FsZShkc3RSZWN0LndpZHRoKCks IGRzdFJlY3QuaGVpZ2h0KCkpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UcmFuc3BhcmVuY3lXaW4uY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVHJhbnNwYXJlbmN5V2luLmNwcAppbmRleCA0ZGMy MTU3MDQ4ODBkMTRmODlmNTVmMTlhNGJiNTk5MzUzMWJlMWRjLi5iYTY2ZWFlNDY0NDNkMzM2N2U4 ZTUwMzY1ZTM0MjM2MWI4NTQ2MWU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UcmFuc3BhcmVuY3lXaW4uY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RyYW5zcGFyZW5jeVdpbi5jcHAKQEAgLTI1 Miw3ICsyNTIsNyBAQCB2b2lkIFRyYW5zcGFyZW5jeVdpbjo6c2V0dXBMYXllckZvck9wYXF1ZUNv bXBvc2l0ZUxheWVyKCkKICAgICBpZiAobV90cmFuc2Zvcm1Nb2RlID09IFVudHJhbnNmb3JtKXsg CiAgICAgICAgIC8vIENvbXB1dGUgdGhlIGludmVyc2UgbWFwcGluZyBmcm9tIHRoZSBjYW52YXMg c3BhY2UgdG8gdGhlCiAgICAgICAgIC8vIGNvb3JkaW5hdGUgc3BhY2Ugb2Ygb3VyIGJpdG1hcC4K LSAgICAgICAgbWFwcGluZyA9IG1fb3JnVHJhbnNmb3JtLmludmVyc2UoKSAqIG1hcHBpbmc7Cisg ICAgICAgIG1hcHBpbmcgKj0gbV9vcmdUcmFuc2Zvcm0uaW52ZXJzZSgpOwogICAgIH0KICAgICBj b21wb3NpdGVUb0NvcHkoKm1fZGVzdENvbnRleHQsICptX2RyYXdDb250ZXh0LCBtYXBwaW5nKTsK IApAQCAtMzEzLDcgKzMxMyw3IEBAIHZvaWQgVHJhbnNwYXJlbmN5V2luOjpzZXR1cFRyYW5zZm9y bUZvcktlZXBUcmFuc2Zvcm0oY29uc3QgSW50UmVjdCYgcmVnaW9uKQogICAgICAgICAvLyBXZSdy ZSBtYWtpbmcgYSBsYXllciwgc28gYXBwbHkgdGhlIG9sZCB0cmFuc2Zvcm0gdG8gdGhlIG5ldyBv bmUKICAgICAgICAgLy8gc28gaXQncyBtYWludGFpbmVkLiBXZSBrbm93IHRoZSBuZXcgbGF5ZXIg aGFzIHRoZSBpZGVudGl0eQogICAgICAgICAvLyB0cmFuc2Zvcm0gbm93LCB3ZSB3ZSBjYW4ganVz dCBtdWx0aXBseSBpdC4KLSAgICAgICAgeGZvcm0gPSBtX29yZ1RyYW5zZm9ybSAqIHhmb3JtOwor ICAgICAgICB4Zm9ybSAqPSBtX29yZ1RyYW5zZm9ybTsKICAgICAgICAgbV9kcmF3Q29udGV4dC0+ Y29uY2F0Q1RNKHhmb3JtKTsKICAgICB9CiAgICAgbV9kcmF3UmVjdCA9IG1fc291cmNlUmVjdDsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMv QWZmaW5lVHJhbnNmb3JtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3Ry YW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmNwcAppbmRleCBmMjc1NTI2YmQ0MDYzYmIxNmU3ZTAy NmJjZDM3MzA3OTZhNTVkYWM1Li4zZjg4MTQwNjhjNGQ4YjI0NjI4ZmEyM2Y3MzZkNDBiZWVmN2Ri ZDkxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zv cm1zL0FmZmluZVRyYW5zZm9ybS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0uY3BwCkBAIC0xNjQsMTIgKzE2NCwxMCBA QCBBZmZpbmVUcmFuc2Zvcm0gQWZmaW5lVHJhbnNmb3JtOjppbnZlcnNlKCkgY29uc3QKICAgICBy ZXR1cm4gcmVzdWx0OwogfQogCi1BZmZpbmVUcmFuc2Zvcm0mIEFmZmluZVRyYW5zZm9ybTo6bXVs dGlwbHkoY29uc3QgQWZmaW5lVHJhbnNmb3JtJiBvdGhlcikKLXsKLSAgICByZXR1cm4gKCp0aGlz KSAqPSBvdGhlcjsKLX0KIAotQWZmaW5lVHJhbnNmb3JtJiBBZmZpbmVUcmFuc2Zvcm06Om11bHRM ZWZ0KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgb3RoZXIpCisvLyBNdWx0aXBsaWVzIHRoaXMgQWZm aW5lVHJhbnNmb3JtIGJ5IHRoZSBwcm92aWRlZCBBZmZpbmVUcmFuc2Zvcm0gLSBpLmUuCisvLyB0 aGlzID0gdGhpcyAqIG90aGVyOworQWZmaW5lVHJhbnNmb3JtJiBBZmZpbmVUcmFuc2Zvcm06Om11 bHRpcGx5KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYgb3RoZXIpCiB7CiAgICAgQWZmaW5lVHJhbnNm b3JtIHRyYW5zOwogICAgIApAQCAtMTkyLDcgKzE5MCw3IEBAIEFmZmluZVRyYW5zZm9ybSYgQWZm aW5lVHJhbnNmb3JtOjpyb3RhdGUoZG91YmxlIGEpCiAgICAgZG91YmxlIHNpbkFuZ2xlID0gc2lu KGEpOwogICAgIEFmZmluZVRyYW5zZm9ybSByb3QoY29zQW5nbGUsIHNpbkFuZ2xlLCAtc2luQW5n bGUsIGNvc0FuZ2xlLCAwLCAwKTsKIAotICAgIG11bHRMZWZ0KHJvdCk7CisgICAgbXVsdGlwbHko cm90KTsKICAgICByZXR1cm4gKnRoaXM7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL0FmZmluZVRyYW5zZm9ybS5oCmlu ZGV4IGJhZWUxMDJhOTU2Y2E4MjM5MjRmNmE5YTUwYWJlNzcwODkwNTg0NzkuLjJhZGJiMzkzMjM0 NzgzMzBlODhkZDhhZGY4YzgwMDAyMzM5YTc0YjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvQWZmaW5lVHJhbnNmb3JtLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9BZmZpbmVUcmFuc2Zvcm0u aApAQCAtOTUsOCArOTUsNyBAQCBwdWJsaWM6CiAKICAgICB2b2lkIG1ha2VJZGVudGl0eSgpOwog Ci0gICAgQWZmaW5lVHJhbnNmb3JtJiBtdWx0aXBseShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsK LSAgICBBZmZpbmVUcmFuc2Zvcm0mIG11bHRMZWZ0KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYpOwor ICAgIEFmZmluZVRyYW5zZm9ybSYgbXVsdGlwbHkoY29uc3QgQWZmaW5lVHJhbnNmb3JtJiBvdGhl cik7CiAgICAgQWZmaW5lVHJhbnNmb3JtJiBzY2FsZShkb3VibGUpOyAKICAgICBBZmZpbmVUcmFu c2Zvcm0mIHNjYWxlKGRvdWJsZSBzeCwgZG91YmxlIHN5KTsgCiAgICAgQWZmaW5lVHJhbnNmb3Jt JiBzY2FsZU5vblVuaWZvcm0oZG91YmxlIHN4LCBkb3VibGUgc3kpOwpAQCAtMTQ3LDE1ICsxNDYs MTQgQEAgcHVibGljOgogICAgIC8vICp0aGlzID0gKnRoaXMgKiB0IChpLmUuLCBhIG11bHRSaWdo dCkKICAgICBBZmZpbmVUcmFuc2Zvcm0mIG9wZXJhdG9yKj0oY29uc3QgQWZmaW5lVHJhbnNmb3Jt JiB0KQogICAgIHsKLSAgICAgICAgKnRoaXMgPSAqdGhpcyAqIHQ7Ci0gICAgICAgIHJldHVybiAq dGhpczsKKyAgICAgICAgcmV0dXJuIG11bHRpcGx5KHQpOwogICAgIH0KICAgICAKICAgICAvLyBy ZXN1bHQgPSAqdGhpcyAqIHQgKGkuZS4sIGEgbXVsdFJpZ2h0KQogICAgIEFmZmluZVRyYW5zZm9y bSBvcGVyYXRvciooY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0KSBjb25zdAogICAgIHsKLSAgICAg ICAgQWZmaW5lVHJhbnNmb3JtIHJlc3VsdCA9IHQ7Ci0gICAgICAgIHJlc3VsdC5tdWx0TGVmdCgq dGhpcyk7CisgICAgICAgIEFmZmluZVRyYW5zZm9ybSByZXN1bHQgPSAqdGhpczsKKyAgICAgICAg cmVzdWx0ICo9IHQ7CiAgICAgICAgIHJldHVybiByZXN1bHQ7CiAgICAgfQogCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGljc0NvbnRleHRX aW5DRS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9HcmFwaGlj c0NvbnRleHRXaW5DRS5jcHAKaW5kZXggMmRlZjZhYjg5NjYwZjFlMDkwNDg5ZTk5NGVhM2Q0ZTY2 MDkxZDE4MS4uMWI4YTcwNDdhNDQ5MjE4ODc5NjA5MmIwNmY1MDc2MjkyNWZkYjU0YyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvR3JhcGhpY3NDb250 ZXh0V2luQ0UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNl L0dyYXBoaWNzQ29udGV4dFdpbkNFLmNwcApAQCAtMjA5LDcgKzIwOSw3IEBAIHB1YmxpYzoKIAog ICAgIHZvaWQgIGNvbmNhdENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRyYW5zZm9ybSkKICAg ICB7Ci0gICAgICAgIG1fdHJhbnNmb3JtID0gdHJhbnNmb3JtICogbV90cmFuc2Zvcm07CisgICAg ICAgIG1fdHJhbnNmb3JtICo9IHRyYW5zZm9ybTsKICAgICB9CiAKICAgICBJbnRSZWN0IG1hcFJl Y3QoY29uc3QgSW50UmVjdCYgcmVjdCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL1NoYXJlZEJpdG1hcC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9TaGFyZWRCaXRtYXAuY3BwCmluZGV4IDA1ZDE1MzVm ZTlhOWRmNzdiN2M2ZmVlNTUwODRmNzEyZDBiYjg0YzMuLjE2OGE1ZTIzMDgxNGJmMDdkOWYzYzFi NGVjZGY5MmRiMDhiMzM2NTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL3dpbmNlL1NoYXJlZEJpdG1hcC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3Mvd2luY2UvU2hhcmVkQml0bWFwLmNwcApAQCAtNDQ1LDggKzQ0NSw3IEBAIHZv aWQgU2hhcmVkQml0bWFwOjpkcmF3UGF0dGVybihIREMgaGRjLCBjb25zdCBBZmZpbmVUcmFuc2Zv cm0mIHRyYW5zZm9ybSwgY29uc3QKICAgICAgICAgYm1wSGVpZ2h0ID0gdGlsZVJlY3QuaGVpZ2h0 KCk7CiAgICAgfQogCi0gICAgQWZmaW5lVHJhbnNmb3JtIHRmID0gdHJhbnNmb3JtOwotICAgIHRm ICo9IHBhdHRlcm5UcmFuc2Zvcm07CisgICAgQWZmaW5lVHJhbnNmb3JtIHRmID0gcGF0dGVyblRy YW5zZm9ybSAqIHRyYW5zZm9ybTsKIAogICAgIEZsb2F0UmVjdCB0clJlY3QgPSB0Zi5tYXBSZWN0 KGRlc3RSZWN0KTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9S ZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv c3ZnL1JlbmRlclNWR1Jlc291cmNlQ29udGFpbmVyLmNwcAppbmRleCAyYThhNDdmYjkzNDQ3YWNk NWI2OGMyYjE2NzVhZjU4NjFhZmJjYTk4Li4wMjE1ZThlZGRkZGM3ZTE1YjcwOTgzNTg1ZDYwZmRj OTQzYjkzOGE1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRl clNWR1Jlc291cmNlQ29udGFpbmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv c3ZnL1JlbmRlclNWR1Jlc291cmNlQ29udGFpbmVyLmNwcApAQCAtMTgyLDggKzE4Miw4IEBAIEFm ZmluZVRyYW5zZm9ybSBSZW5kZXJTVkdSZXNvdXJjZUNvbnRhaW5lcjo6dHJhbnNmb3JtT25Ob25T Y2FsaW5nU3Ryb2tlKFJlbmRlck9iCiAgICAgICAgIHJldHVybiByZXNvdXJjZVRyYW5zZm9ybTsK IAogICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50KiBlbGVtZW50ID0gc3RhdGljX2Nh c3Q8U1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQqPihvYmplY3QtPm5vZGUoKSk7Ci0gICAg QWZmaW5lVHJhbnNmb3JtIHRyYW5zZm9ybSA9IHJlc291cmNlVHJhbnNmb3JtOwotICAgIHRyYW5z Zm9ybS5tdWx0aXBseShlbGVtZW50LT5nZXRTY3JlZW5DVE0oU1ZHTG9jYXRhYmxlOjpEaXNhbGxv d1N0eWxlVXBkYXRlKSk7CisgICAgQWZmaW5lVHJhbnNmb3JtIHRyYW5zZm9ybSA9IGVsZW1lbnQt PmdldFNjcmVlbkNUTShTVkdMb2NhdGFibGU6OkRpc2FsbG93U3R5bGVVcGRhdGUpOworICAgIHRy YW5zZm9ybSAqPSByZXNvdXJjZVRyYW5zZm9ybTsKICAgICByZXR1cm4gdHJhbnNmb3JtOwogfQog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291 cmNlR3JhZGllbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9SZW5kZXJTVkdS ZXNvdXJjZUdyYWRpZW50LmNwcAppbmRleCA1YWQ1ZDg0M2FmZTU0YTA5ZjFkMzE2ZDNjN2Q1ODU0 Yjk1ZDNkMmU1Li45ZjJiYjhkNWEwNWEwYTcxNzUyNTk1YmVhYTc3ODNlZDQ0MjhhZGRmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jlc291cmNlR3Jh ZGllbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUmVz b3VyY2VHcmFkaWVudC5jcHAKQEAgLTEzMyw3ICsxMzMsNyBAQCBzdGF0aWMgaW5saW5lIEFmZmlu ZVRyYW5zZm9ybSBjbGlwVG9UZXh0TWFzayhHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsCiAgICAg ICAgIG1hdHJpeC50cmFuc2xhdGUobWFza0JvdW5kaW5nQm94LngoKSwgbWFza0JvdW5kaW5nQm94 LnkoKSk7CiAgICAgICAgIG1hdHJpeC5zY2FsZU5vblVuaWZvcm0obWFza0JvdW5kaW5nQm94Lndp ZHRoKCksIG1hc2tCb3VuZGluZ0JveC5oZWlnaHQoKSk7CiAgICAgfQotICAgIG1hdHJpeC5tdWx0 TGVmdChncmFkaWVudFRyYW5zZm9ybSk7CisgICAgbWF0cml4ICo9IGdyYWRpZW50VHJhbnNmb3Jt OwogICAgIHJldHVybiBtYXRyaXg7CiB9CiAjZW5kaWYKQEAgLTE5MCw3ICsxOTAsNyBAQCBib29s IFJlbmRlclNWR1Jlc291cmNlR3JhZGllbnQ6OmFwcGx5UmVzb3VyY2UoUmVuZGVyT2JqZWN0KiBv YmplY3QsIFJlbmRlclN0eWxlKgogICAgICAgICBBZmZpbmVUcmFuc2Zvcm0gZ3JhZGllbnRUcmFu c2Zvcm07CiAgICAgICAgIGNhbGN1bGF0ZUdyYWRpZW50VHJhbnNmb3JtKGdyYWRpZW50VHJhbnNm b3JtKTsKIAotICAgICAgICBncmFkaWVudERhdGEtPnVzZXJzcGFjZVRyYW5zZm9ybS5tdWx0TGVm dChncmFkaWVudFRyYW5zZm9ybSk7CisgICAgICAgIGdyYWRpZW50RGF0YS0+dXNlcnNwYWNlVHJh bnNmb3JtICo9IGdyYWRpZW50VHJhbnNmb3JtOwogICAgICAgICBncmFkaWVudERhdGEtPmdyYWRp ZW50LT5zZXRHcmFkaWVudFNwYWNlVHJhbnNmb3JtKGdyYWRpZW50RGF0YS0+dXNlcnNwYWNlVHJh bnNmb3JtKTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9z dmcvUmVuZGVyU1ZHUmVzb3VyY2VQYXR0ZXJuLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9zdmcvUmVuZGVyU1ZHUmVzb3VyY2VQYXR0ZXJuLmNwcAppbmRleCAzMzBhMjFhYzIwYWI0ZGUy MWE4YjllMGVmNTVjZDQxZmQxMTI4Y2RkLi4yMTEzYTI1MDQzYmY3NmVmMjdhOGVlYWEwYzc2NWFh ZmQ4MmFkNTk0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRl clNWR1Jlc291cmNlUGF0dGVybi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2 Zy9SZW5kZXJTVkdSZXNvdXJjZVBhdHRlcm4uY3BwCkBAIC0xMzksNyArMTM5LDcgQEAgYm9vbCBS ZW5kZXJTVkdSZXNvdXJjZVBhdHRlcm46OmFwcGx5UmVzb3VyY2UoUmVuZGVyT2JqZWN0KiBvYmpl Y3QsIFJlbmRlclN0eWxlKgogCiAgICAgICAgIEFmZmluZVRyYW5zZm9ybSBwYXR0ZXJuVHJhbnNm b3JtID0gbV9hdHRyaWJ1dGVzLnBhdHRlcm5UcmFuc2Zvcm0oKTsKICAgICAgICAgaWYgKCFwYXR0 ZXJuVHJhbnNmb3JtLmlzSWRlbnRpdHkoKSkKLSAgICAgICAgICAgIHBhdHRlcm5EYXRhLT50cmFu c2Zvcm0ubXVsdGlwbHkocGF0dGVyblRyYW5zZm9ybSk7CisgICAgICAgICAgICBwYXR0ZXJuRGF0 YS0+dHJhbnNmb3JtID0gcGF0dGVyblRyYW5zZm9ybSAqIHBhdHRlcm5EYXRhLT50cmFuc2Zvcm07 CiAKICAgICAgICAgcGF0dGVybkRhdGEtPnBhdHRlcm4tPnNldFBhdHRlcm5TcGFjZVRyYW5zZm9y bShwYXR0ZXJuRGF0YS0+dHJhbnNmb3JtKTsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jvb3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL3N2Zy9SZW5kZXJTVkdSb290LmNwcAppbmRleCBhYTg3YjA5ZGZmYTU3MzdmMzQ2ZWE1 ZmY3MjMyZGFkOGI2ZjAyMTk5Li4zYThkY2U5ZmYyNGNkMWUwMGE1ZDIzZWIzZWVlMTVmNzI2MzBk MWZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1JlbmRlclNWR1Jv b3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvUmVuZGVyU1ZHUm9vdC5j cHAKQEAgLTI0Niw3ICsyNDYsNyBAQCBBZmZpbmVUcmFuc2Zvcm0gUmVuZGVyU1ZHUm9vdDo6bG9j YWxUb0JvcmRlckJveFRyYW5zZm9ybSgpIGNvbnN0CiAgICAgZmxvYXQgc2NhbGUgPSBzdmctPmN1 cnJlbnRTY2FsZSgpOwogICAgIEZsb2F0UG9pbnQgdHJhbnNsYXRlID0gc3ZnLT5jdXJyZW50VHJh bnNsYXRlKCk7CiAgICAgQWZmaW5lVHJhbnNmb3JtIGN0bShzY2FsZSwgMCwgMCwgc2NhbGUsIGJv cmRlckFuZFBhZGRpbmcud2lkdGgoKSArIHRyYW5zbGF0ZS54KCksIGJvcmRlckFuZFBhZGRpbmcu aGVpZ2h0KCkgKyB0cmFuc2xhdGUueSgpKTsKLSAgICByZXR1cm4gc3ZnLT52aWV3Qm94VG9WaWV3 VHJhbnNmb3JtKHdpZHRoKCkgLyBzY2FsZSwgaGVpZ2h0KCkgLyBzY2FsZSkgKiBjdG07CisgICAg cmV0dXJuIGN0bSAqIHN2Zy0+dmlld0JveFRvVmlld1RyYW5zZm9ybSh3aWR0aCgpIC8gc2NhbGUs IGhlaWdodCgpIC8gc2NhbGUpOwogfQogCiBJbnRTaXplIFJlbmRlclNWR1Jvb3Q6OnBhcmVudE9y aWdpblRvQm9yZGVyQm94KCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9zdmcvU1ZHSW1hZ2VCdWZmZXJUb29scy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvc3ZnL1NWR0ltYWdlQnVmZmVyVG9vbHMuY3BwCmluZGV4IGYwNjU3YWYxODQ2OTllNTFiZjQw ODY1ZTNhNGE3MmI0YWI1MWVlMzkuLjY3MjY2OTRkMTAzZjE5MjI4NGZiMDRlNTY2MjAzODM3OTNm Y2QxNDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvU1ZHSW1hZ2VC dWZmZXJUb29scy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9TVkdJbWFn ZUJ1ZmZlclRvb2xzLmNwcApAQCAtNDMsNyArNDMsNyBAQCB2b2lkIFNWR0ltYWdlQnVmZmVyVG9v bHM6OmNhbGN1bGF0ZVRyYW5zZm9ybWF0aW9uVG9PdXRlcm1vc3RTVkdDb29yZGluYXRlU3lzdGVt KAogCiAgICAgYWJzb2x1dGVUcmFuc2Zvcm0gPSBjdXJyZW50Q29udGVudFRyYW5zZm9ybWF0aW9u KCk7CiAgICAgd2hpbGUgKGN1cnJlbnQpIHsKLSAgICAgICAgYWJzb2x1dGVUcmFuc2Zvcm0ubXVs dGlwbHkoY3VycmVudC0+bG9jYWxUb1BhcmVudFRyYW5zZm9ybSgpKTsKKyAgICAgICAgYWJzb2x1 dGVUcmFuc2Zvcm0gPSBjdXJyZW50LT5sb2NhbFRvUGFyZW50VHJhbnNmb3JtKCkgKiBhYnNvbHV0 ZVRyYW5zZm9ybTsKICAgICAgICAgaWYgKGN1cnJlbnQtPmlzU1ZHUm9vdCgpKQogICAgICAgICAg ICAgYnJlYWs7CiAgICAgICAgIGN1cnJlbnQgPSBjdXJyZW50LT5wYXJlbnQoKTsKQEAgLTgzLDcg KzgzLDcgQEAgdm9pZCBTVkdJbWFnZUJ1ZmZlclRvb2xzOjpyZW5kZXJTdWJ0cmVlVG9JbWFnZUJ1 ZmZlcihJbWFnZUJ1ZmZlciogaW1hZ2UsIFJlbmRlck8KIAogICAgIEFmZmluZVRyYW5zZm9ybSYg Y29udGVudFRyYW5zZm9ybWF0aW9uID0gY3VycmVudENvbnRlbnRUcmFuc2Zvcm1hdGlvbigpOwog ICAgIEFmZmluZVRyYW5zZm9ybSBzYXZlZENvbnRlbnRUcmFuc2Zvcm1hdGlvbiA9IGNvbnRlbnRU cmFuc2Zvcm1hdGlvbjsKLSAgICBjb250ZW50VHJhbnNmb3JtYXRpb24ubXVsdGlwbHkoc3VidHJl ZUNvbnRlbnRUcmFuc2Zvcm1hdGlvbik7CisgICAgY29udGVudFRyYW5zZm9ybWF0aW9uID0gc3Vi dHJlZUNvbnRlbnRUcmFuc2Zvcm1hdGlvbiAqIGNvbnRlbnRUcmFuc2Zvcm1hdGlvbjsKIAogICAg IGl0ZW0tPmxheW91dElmTmVlZGVkKCk7CiAgICAgaXRlbS0+cGFpbnQoaW5mbywgMCwgMCk7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1NWR1RleHRMYXlvdXRFbmdp bmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3N2Zy9TVkdUZXh0TGF5b3V0RW5naW5l LmNwcAppbmRleCA3ZWVmYWQ2NTY2MzZkOTJlNTI2Yjk4OTRiNDllN2I1MTA0ZWY2ZGNmLi4zYjI4 ZDJiZDE2ZTdiNTZmMzZkOWViYmIxNGUxNmRlODNjOGEwMWNkIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvc3ZnL1NWR1RleHRMYXlvdXRFbmdpbmUuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcvU1ZHVGV4dExheW91dEVuZ2luZS5jcHAKQEAgLTMyMSw3 ICszMjEsNyBAQCB2b2lkIFNWR1RleHRMYXlvdXRFbmdpbmU6OmZpbmFsaXplVHJhbnNmb3JtTWF0 cmljZXMoVmVjdG9yPFNWR0lubGluZVRleHRCb3gqPiYgYgogICAgICAgICAgICAgaWYgKHRyYW5z Zm9ybS5pc0lkZW50aXR5KCkpCiAgICAgICAgICAgICAgICAgdHJhbnNmb3JtID0gdGV4dEJveFRy YW5zZm9ybWF0aW9uOwogICAgICAgICAgICAgZWxzZQotICAgICAgICAgICAgICAgIHRyYW5zZm9y bS5tdWx0aXBseSh0ZXh0Qm94VHJhbnNmb3JtYXRpb24pOworICAgICAgICAgICAgICAgIHRyYW5z Zm9ybSA9IHRleHRCb3hUcmFuc2Zvcm1hdGlvbiAqIHRyYW5zZm9ybTsKICAgICAgICAgfQogICAg IH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvc3ZnL1NWR0xvY2F0YWJsZS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9zdmcvU1ZHTG9jYXRhYmxlLmNwcAppbmRleCA0Mzk2MWQ5NTQxOWJhYTM5 NjQ5MjZkZDE1MGEyZjQ1MjEyM2I1ZDE3Li4yYTdjOWJlMDlmZDY4NThiN2YwM2E2ZjA3N2U4ZTI0 NjhkMzVmZDMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHTG9jYXRhYmxlLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHTG9jYXRhYmxlLmNwcApAQCAtOTEsNyArOTEs OCBAQCBBZmZpbmVUcmFuc2Zvcm0gU1ZHTG9jYXRhYmxlOjpjb21wdXRlQ1RNKGNvbnN0IFNWR0Vs ZW1lbnQqIGVsZW1lbnQsIENUTVNjb3BlIG1vZAogICAgIHdoaWxlIChjdXJyZW50ICYmIGN1cnJl bnQtPmlzU1ZHRWxlbWVudCgpKSB7CiAgICAgICAgIFNWR0VsZW1lbnQqIGN1cnJlbnRFbGVtZW50 ID0gc3RhdGljX2Nhc3Q8U1ZHRWxlbWVudCo+KGN1cnJlbnQpOwogICAgICAgICBpZiAoY3VycmVu dEVsZW1lbnQtPmlzU3R5bGVkKCkpCi0gICAgICAgICAgICBjdG0gPSBzdGF0aWNfY2FzdDxTVkdT dHlsZWRFbGVtZW50Kj4oY3VycmVudEVsZW1lbnQpLT5sb2NhbENvb3JkaW5hdGVTcGFjZVRyYW5z Zm9ybShtb2RlKS5tdWx0TGVmdChjdG0pOworICAgICAgICAgICAgLy8gbm90ZSB0aGF0IHRoaXMg bW9kaWZpZXMgdGhlIEFmZmluZVRyYW5zZm9ybSByZXR1cm5lZCBieSBsb2NhbENvb3JkaW5hdGVT cGFjZVRyYW5zZm9ybShtb2RlKSB0b28uCisgICAgICAgICAgICBjdG0gPSBzdGF0aWNfY2FzdDxT VkdTdHlsZWRFbGVtZW50Kj4oY3VycmVudEVsZW1lbnQpLT5sb2NhbENvb3JkaW5hdGVTcGFjZVRy YW5zZm9ybShtb2RlKS5tdWx0aXBseShjdG0pOwogCiAgICAgICAgIC8vIEZvciBnZXRDVE0oKSBj b21wdXRhdGlvbiwgc3RvcCBhdCB0aGUgbmVhcmVzdCB2aWV3cG9ydCBlbGVtZW50CiAgICAgICAg IGlmIChjdXJyZW50RWxlbWVudCA9PSBzdG9wQXRFbGVtZW50KQpAQCAtMTEzLDcgKzExNCw3IEBA IEFmZmluZVRyYW5zZm9ybSBTVkdMb2NhdGFibGU6OmdldFRyYW5zZm9ybVRvRWxlbWVudChTVkdF bGVtZW50KiB0YXJnZXQsIEV4Y2VwdGlvCiAgICAgICAgICAgICBlYyA9IFNWR0V4Y2VwdGlvbjo6 U1ZHX01BVFJJWF9OT1RfSU5WRVJUQUJMRTsKICAgICAgICAgICAgIHJldHVybiBjdG07CiAgICAg ICAgIH0KLSAgICAgICAgY3RtICo9IHRhcmdldENUTS5pbnZlcnNlKCk7CisgICAgICAgIGN0bSA9 IHRhcmdldENUTS5pbnZlcnNlKCkgKiBjdG07CiAgICAgfQogCiAgICAgcmV0dXJuIGN0bTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdNYXRyaXguaCBiL1NvdXJjZS9XZWJDb3Jl L3N2Zy9TVkdNYXRyaXguaAppbmRleCA4MDdiNzAzMzhkNzQ3ZTUxYTEzMjBkM2E1NDlkNzU5NTgx YTY4N2M1Li4wNzdlYjAzODM0ODY2NDg3NGY3YmM1YmMzMGFiYWUzM2MyZjZjYzc4IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHTWF0cml4LmgKKysrIGIvU291cmNlL1dlYkNvcmUv c3ZnL1NWR01hdHJpeC5oCkBAIC05NiwxMSArOTYsMTAgQEAgcHVibGljOgogICAgICAgICByZXR1 cm4gc3RhdGljX2Nhc3Q8U1ZHTWF0cml4Pihjb3B5KTsKICAgICB9CiAKLSAgICAvLyBTVkdNYXRy aXg6Om11bHRpcGx5IG5lZWRzIHRvIGNhbGwgU1ZHTWF0cml4OjptdWx0TGVmdC4KICAgICBTVkdN YXRyaXggbXVsdGlwbHkoY29uc3QgU1ZHTWF0cml4JiBvdGhlcikKICAgICB7CiAgICAgICAgIEFm ZmluZVRyYW5zZm9ybSBjb3B5ID0gKnRoaXM7Ci0gICAgICAgIGNvcHkubXVsdExlZnQoc3RhdGlj X2Nhc3Q8Y29uc3QgQWZmaW5lVHJhbnNmb3JtJj4ob3RoZXIpKTsKKyAgICAgICAgY29weSAqPSBz dGF0aWNfY2FzdDxjb25zdCBBZmZpbmVUcmFuc2Zvcm0mPihvdGhlcik7CiAgICAgICAgIHJldHVy biBzdGF0aWNfY2FzdDxTVkdNYXRyaXg+KGNvcHkpOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvc3ZnL1NWR1NWR0VsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NW R1NWR0VsZW1lbnQuY3BwCmluZGV4IDdlMDRmNWRiMDFiNmFmZmMzZjJiZGI1YzdkMjVmOGQ1ZTli MmI3NzEuLjQ4M2U0NWY4ZmY1NTE5ZjM0NWYxOTNiMTgzM2Q3YjNhMTA0ZGU5OGQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdTVkdFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHU1ZHRWxlbWVudC5jcHAKQEAgLTUwMiw3ICs1MDIsNyBAQCBBZmZpbmVUcmFu c2Zvcm0gU1ZHU1ZHRWxlbWVudDo6bG9jYWxDb29yZGluYXRlU3BhY2VUcmFuc2Zvcm0oU1ZHTG9j YXRhYmxlOjpDVE1TYwogICAgICAgICB9CiAgICAgfQogCi0gICAgcmV0dXJuIHRyYW5zZm9ybS5t dWx0TGVmdCh2aWV3Qm94VHJhbnNmb3JtKTsKKyAgICByZXR1cm4gdHJhbnNmb3JtLm11bHRpcGx5 KHZpZXdCb3hUcmFuc2Zvcm0pOwogfQogCiBSZW5kZXJPYmplY3QqIFNWR1NWR0VsZW1lbnQ6OmNy ZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqKQpAQCAtNTg3LDEy ICs1ODcsMTEgQEAgQWZmaW5lVHJhbnNmb3JtIFNWR1NWR0VsZW1lbnQ6OnZpZXdCb3hUb1ZpZXdU cmFuc2Zvcm0oZmxvYXQgdmlld1dpZHRoLCBmbG9hdCB2aWUKICAgICAgICAgdmlld0JveFJlY3Qg PSB2aWV3Qm94KCk7CiAKICAgICBBZmZpbmVUcmFuc2Zvcm0gY3RtID0gU1ZHRml0VG9WaWV3Qm94 Ojp2aWV3Qm94VG9WaWV3VHJhbnNmb3JtKHZpZXdCb3hSZWN0LCBwcmVzZXJ2ZUFzcGVjdFJhdGlv KCksIHZpZXdXaWR0aCwgdmlld0hlaWdodCk7CisKICAgICBpZiAodXNlQ3VycmVudFZpZXcoKSAm JiBjdXJyZW50VmlldygpKSB7CiAgICAgICAgIEFmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm07Ci0g ICAgICAgIGlmICghY3VycmVudFZpZXcoKS0+dHJhbnNmb3JtKCkuY29uY2F0ZW5hdGUodHJhbnNm b3JtKSkKLSAgICAgICAgICAgIHJldHVybiBjdG07Ci0KLSAgICAgICAgcmV0dXJuIHRyYW5zZm9y bSAqIGN0bTsKKyAgICAgICAgaWYgKGN1cnJlbnRWaWV3KCktPnRyYW5zZm9ybSgpLmNvbmNhdGVu YXRlKHRyYW5zZm9ybSkpCisgICAgICAgICAgICBjdG0gKj0gdHJhbnNmb3JtOwogICAgIH0KIAog ICAgIHJldHVybiBjdG07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHU3R5bGVk VHJhbnNmb3JtYWJsZUVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NWR1N0eWxlZFRy YW5zZm9ybWFibGVFbGVtZW50LmNwcAppbmRleCAyMzM0OTQzYzU2MmViNDA5ODlhZjBkMTQ2YzFh MGJlNjJlYTYzMjYyLi4xNTUyOGUwOTMyOWUyMzkwM2YwZTMyNGJlM2Y5ODQ4NDdiODAwNGQ5IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9zdmcvU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1l bnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxl bWVudC5jcHAKQEAgLTU2LDcgKzU2LDkgQEAgQWZmaW5lVHJhbnNmb3JtIFNWR1N0eWxlZFRyYW5z Zm9ybWFibGVFbGVtZW50OjphbmltYXRlZExvY2FsVHJhbnNmb3JtKCkgY29uc3QKIHsKICAgICBB ZmZpbmVUcmFuc2Zvcm0gbWF0cml4OwogICAgIHRyYW5zZm9ybSgpLmNvbmNhdGVuYXRlKG1hdHJp eCk7Ci0gICAgcmV0dXJuIG1fc3VwcGxlbWVudGFsVHJhbnNmb3JtID8gKm1fc3VwcGxlbWVudGFs VHJhbnNmb3JtICogbWF0cml4IDogbWF0cml4OworICAgIGlmIChtX3N1cHBsZW1lbnRhbFRyYW5z Zm9ybSkKKyAgICAgICAgbWF0cml4ICo9ICptX3N1cHBsZW1lbnRhbFRyYW5zZm9ybTsKKyAgICBy ZXR1cm4gbWF0cml4OwogfQogCiBBZmZpbmVUcmFuc2Zvcm0qIFNWR1N0eWxlZFRyYW5zZm9ybWFi bGVFbGVtZW50OjpzdXBwbGVtZW50YWxUcmFuc2Zvcm0oKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvc3ZnL1NWR1RleHRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUZXh0 RWxlbWVudC5jcHAKaW5kZXggNzIyOTgyNDVjNTZmZTQyNTZlODVhNDRhOWY3NTk2MWExNzY2NGIz ZC4uYjYwOTRjOTAxNjdmMDU0YzQ4NDBiODBkYjMwM2E2YzNmMjEyYTVkOCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvc3ZnL1NWR1RleHRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9zdmcvU1ZHVGV4dEVsZW1lbnQuY3BwCkBAIC04OSw3ICs4OSw5IEBAIEFmZmluZVRyYW5zZm9y bSBTVkdUZXh0RWxlbWVudDo6YW5pbWF0ZWRMb2NhbFRyYW5zZm9ybSgpIGNvbnN0CiB7CiAgICAg QWZmaW5lVHJhbnNmb3JtIG1hdHJpeDsKICAgICB0cmFuc2Zvcm0oKS5jb25jYXRlbmF0ZShtYXRy aXgpOwotICAgIHJldHVybiBtX3N1cHBsZW1lbnRhbFRyYW5zZm9ybSA/ICptX3N1cHBsZW1lbnRh bFRyYW5zZm9ybSAqIG1hdHJpeCA6IG1hdHJpeDsKKyAgICBpZiAobV9zdXBwbGVtZW50YWxUcmFu c2Zvcm0pCisgICAgICAgIG1hdHJpeCAqPSAqbV9zdXBwbGVtZW50YWxUcmFuc2Zvcm07CisgICAg cmV0dXJuIG1hdHJpeDsKIH0KIAogQWZmaW5lVHJhbnNmb3JtKiBTVkdUZXh0RWxlbWVudDo6c3Vw cGxlbWVudGFsVHJhbnNmb3JtKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdU cmFuc2Zvcm1MaXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3N2Zy9TVkdUcmFuc2Zvcm1MaXN0LmNw cAppbmRleCA1MmJmYzg1MjVjN2FmNzJkOWNjMzIwMTU0NzQxNjdmOTQ3NTdkOTBjLi4xODAwYjFl YzAzZmE1YTliMGQ5YzNiNzBiODI4N2IwYzYyYjA5ODhkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9zdmcvU1ZHVHJhbnNmb3JtTGlzdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvc3ZnL1NW R1RyYW5zZm9ybUxpc3QuY3BwCkBAIC01Niw3ICs1Niw3IEBAIGJvb2wgU1ZHVHJhbnNmb3JtTGlz dDo6Y29uY2F0ZW5hdGUoQWZmaW5lVHJhbnNmb3JtJiByZXN1bHQpIGNvbnN0CiAgICAgICAgIHJl dHVybiBmYWxzZTsKIAogICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBzaXplOyArK2kpCi0g ICAgICAgIHJlc3VsdCA9IGF0KGkpLm1hdHJpeCgpICogcmVzdWx0OworICAgICAgICByZXN1bHQg Kj0gYXQoaSkubWF0cml4KCk7CiAKICAgICByZXR1cm4gdHJ1ZTsKIH0K