44666 2010-08-25 23:13:56 -0700 Expose Vector3 and associated operations 2010-08-30 17:03:58 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) All All RESOLVED INVALID P2 Normal --- 44729 1 kbr kbr cmarrin crogers dglazkov jamesr senorblanco simon.fraser vangelis webkit.review.bot oldest_to_newest 269729 0 kbr 2010-08-25 23:13:56 -0700 In order to implement cross-platform GPU accelerated path rendering on top of GraphicsContext3D, a Vector3 class and certain basic operations (dot product, cross product, etc.) are needed. Since these operations mostly already exist in TransformationMatrix.cpp, we should move them to a Vector3 class in TransformationMatrix.h. 269744 1 65529 kbr 2010-08-25 23:32:27 -0700 Created attachment 65529 Patch Full LayoutTest run is still underway; will post an update if there appear to be any failures caused by these changes. 269851 2 65529 senorblanco 2010-08-26 06:28:03 -0700 Comment on attachment 65529 Patch WebCore/platform/graphics/transforms/TransformationMatrix.h:91 + Vector3& operator =(const Vector3& v) Normally operator= should check for self-assignment. Not deadly in this case, though. Looks good to me. 269941 3 kbr 2010-08-26 10:27:21 -0700 All layout tests passed with these changes. 269945 4 65529 dglazkov 2010-08-26 10:30:52 -0700 Comment on attachment 65529 Patch ok. 269955 5 kbr 2010-08-26 10:52:26 -0700 Committed r66113: <http://trac.webkit.org/changeset/66113> 270005 6 cmarrin 2010-08-26 11:44:10 -0700 Wow, that was fast. A change like this really needs to allow for more time to comment. Why didn't you just add the needed methods to FloatPoint3D and use that? I don't like the proliferation of redundant classes. If it's the fact that FloatPoint3D uses float and TransformationMatrix uses doubles, then we need to address that. Maybe FloatPoint3D should use doubles, or TransformationMatrix should use floats. If we do need a set of double-based point classes in addition to the float-based ones, we should at least name them better, like DoublePoint3D or something. 270015 7 kbr 2010-08-26 12:00:39 -0700 (In reply to comment #6) > Wow, that was fast. A change like this really needs to allow for more time to comment. Sorry, I have a bunch of dependent patches to land and really wanted to get unblocked. We can adjust the code as necessary. > Why didn't you just add the needed methods to FloatPoint3D and use that? I don't like the proliferation of redundant classes. If it's the fact that FloatPoint3D uses float and TransformationMatrix uses doubles, then we need to address that. Maybe FloatPoint3D should use doubles, or TransformationMatrix should use floats. If we do need a set of double-based point classes in addition to the float-based ones, we should at least name them better, like DoublePoint3D or something. I'd be very happy to use single precision arithmetic for the work I'm doing. The name "FloatPoint3D" seems a poor choice, especially when adding operations like cross products which conceptually operate on vectors. This is the primary reason I exposed the Vector3 class and moved the v3Dot, v3Cross, etc. operations from TransformationMatrix.cpp into it. My preference would be to rename FloatPoint to Vector2 and FloatPoint3D to Vector3, fill them out with the needed operations, and change TransformationMatrix to operate upon them. I'd also ideally like to change TransformationMatrix to use single-precision arithmetic. I gather that the latter change may require lots of layout tests to be rebaselined. One idea would be to parameterize the Vector2, Vector3 and TransformationMatrix types on float or double. 270017 8 simon.fraser 2010-08-26 12:02:24 -0700 (In reply to comment #7) > My preference would be to rename FloatPoint to Vector2 and FloatPoint3D to Vector3 I think we want to keep the names FloatPoint2D and FloatPoint3D in the rest of the code. But they could just inherit from Vector*. 270046 9 cmarrin 2010-08-26 12:47:29 -0700 Here is the change of TransformationMatrix to doubles: http://trac.webkit.org/changeset/40761 A lot of tests had to be changed, but the changes were minor and should be easy to change back. I agree with Simon that we should leave FloatPoint and FloatPoint3D as is. How about changing TransformationMatrix to use floats, and add a FloatVector3 (in a separate file) as a subclass of FloatPoint3D? I chose FloatVector3 rather than FloatVector3D because then the corresponding homogenous vector would be FloatVector4D which is not the right nomenclature. I'm not saying that we need a homogeneous vector right now, but we may well need one in the future, especially if we intend to do projection into a device coordinate space (in software), so we should provide for the possibility. 270232 10 kbr 2010-08-26 17:19:24 -0700 What about AffineTransform and the various TransformOperations, which also operate on doubles? There may ultimately be good reason for doing this arithmetic using doubles. For large displays I'm not sure single-precision floating point numbers can address sub-pixel locations with sufficient accuracy. Do you have any thoughts on this? What about the thought to make TransformMatrix a template class with double as the default type parameter, but allowing it to be constructed with float as the type parameter? We could then add similar Vector2, Vector3 and Vector4 classes, and change FloatPoint and FloatPoint3D to inherit from Vector2<float> and Vector3<float>. 271410 11 cmarrin 2010-08-30 06:53:33 -0700 (In reply to comment #10) > What about AffineTransform and the various TransformOperations, which also operate on doubles? > > There may ultimately be good reason for doing this arithmetic using doubles. For large displays I'm not sure single-precision floating point numbers can address sub-pixel locations with sufficient accuracy. Do you have any thoughts on this? That was certainly in my mind when I made this change. I believe the big motivation for this had to do with the fact that the TransformOperations use doubles because they are reflected in JS and JS uses doubles. And TransformationMatrix is reflected into JS via CSSMatrix. So the longer we stayed in doubles, the better off we were. We ultimately have to downcast to floats for WebGL and affine matrices for CG (and probably most other 2D libraries), so the question is just how long you stay in doubles. The problem with the way it was before is that we were bouncing back and forth between float and double on every JS call, which gets inefficient. Modern hardware (even mobile hardware) has a FP unit which can do double arithmetic as fast as float for most things (division is often a bit slower, but not much). So casting between double and float is the only expensive operation here. So, add in your argument of better precision and it's probably best to just stick with doubles. > > What about the thought to make TransformMatrix a template class with double as the default type parameter, but allowing it to be constructed with float as the type parameter? We could then add similar Vector2, Vector3 and Vector4 classes, and change FloatPoint and FloatPoint3D to inherit from Vector2<float> and Vector3<float>. I don't think we need to go that far, we just need to decide which we want and stick with that. So let's stick with doubles. Maybe it would be best to make a Point3 class, which is a double version of FloatPoint3D, and then subclass Vector3 from that. This gives us the opportunity to switch from FloatPoint3D to Point3 down the road. These classes should be in separate files. 271414 12 senorblanco 2010-08-30 07:01:37 -0700 (In reply to comment #11) > (In reply to comment #10) > > What about AffineTransform and the various TransformOperations, which also operate on doubles? > > > > There may ultimately be good reason for doing this arithmetic using doubles. For large displays I'm not sure single-precision floating point numbers can address sub-pixel locations with sufficient accuracy. Do you have any thoughts on this? > > That was certainly in my mind when I made this change. I believe the big motivation for this had to do with the fact that the TransformOperations use doubles because they are reflected in JS and JS uses doubles. And TransformationMatrix is reflected into JS via CSSMatrix. So the longer we stayed in doubles, the better off we were. We ultimately have to downcast to floats for WebGL and affine matrices for CG (and probably most other 2D libraries), so the question is just how long you stay in doubles. The problem with the way it was before is that we were bouncing back and forth between float and double on every JS call, which gets inefficient. > > Modern hardware (even mobile hardware) has a FP unit which can do double arithmetic as fast as float for most things (division is often a bit slower, but not much). So casting between double and float is the only expensive operation here. So, add in your argument of better precision and it's probably best to just stick with doubles. Just to play devil's advocate, it also means twice the cost of memory bandwidth for loads and stores. Also, SSE2 is capable of 4-wide single-precision ops, but only 2-wide double-precision ops, so it would halve the throughput too (although this code doesn't use SSE2 yet AFAIK). Finally, using doubles also means 80bit on x64 FPU, but then 64bit on other platforms and when using SSE2, which can cause differing test results. > > What about the thought to make TransformMatrix a template class with double as the default type parameter, but allowing it to be constructed with float as the type parameter? We could then add similar Vector2, Vector3 and Vector4 classes, and change FloatPoint and FloatPoint3D to inherit from Vector2<float> and Vector3<float>. > > I don't think we need to go that far, we just need to decide which we want and stick with that. > > So let's stick with doubles. Maybe it would be best to make a Point3 class, which is a double version of FloatPoint3D, and then subclass Vector3 from that. This gives us the opportunity to switch from FloatPoint3D to Point3 down the road. These classes should be in separate files. 271557 13 65937 kbr 2010-08-30 12:18:29 -0700 Created attachment 65937 Roll out of previous patch I'm rolling out the previous patch because we are definitely going to take a different approach. Most immediately I will probably add a cross product to FloatPoint3D, but regardless of how we proceed we definitely don't want the previous change. 271558 14 webkit.review.bot 2010-08-30 12:20:46 -0700 Attachment 65937 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/transforms/TransformationMatrix.cpp:265: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] WebCore/platform/graphics/transforms/TransformationMatrix.cpp:266: l is incorrectly named. Don't use the single letter 'l' as an identifier name. [readability/naming] [4] Total errors found: 2 in 2 files If any of these errors are false positives, please file a bug against check-webkit-style. 271679 15 65937 cmarrin 2010-08-30 15:16:19 -0700 Comment on attachment 65937 Roll out of previous patch r+ 271697 16 kbr 2010-08-30 15:24:47 -0700 Note: fixing OOPS in ChangeLog while landing. 271699 17 kbr 2010-08-30 15:28:23 -0700 Committed r66416: <http://trac.webkit.org/changeset/66416> 271700 18 kbr 2010-08-30 15:29:10 -0700 Updating the status of this bug to "Resolved Invalid". 271766 19 cmarrin 2010-08-30 16:57:17 -0700 (In reply to comment #12) > (In reply to comment #11) > > (In reply to comment #10) > > > What about AffineTransform and the various TransformOperations, which also operate on doubles? > > > > > > There may ultimately be good reason for doing this arithmetic using doubles. For large displays I'm not sure single-precision floating point numbers can address sub-pixel locations with sufficient accuracy. Do you have any thoughts on this? > > > > That was certainly in my mind when I made this change. I believe the big motivation for this had to do with the fact that the TransformOperations use doubles because they are reflected in JS and JS uses doubles. And TransformationMatrix is reflected into JS via CSSMatrix. So the longer we stayed in doubles, the better off we were. We ultimately have to downcast to floats for WebGL and affine matrices for CG (and probably most other 2D libraries), so the question is just how long you stay in doubles. The problem with the way it was before is that we were bouncing back and forth between float and double on every JS call, which gets inefficient. > > > > Modern hardware (even mobile hardware) has a FP unit which can do double arithmetic as fast as float for most things (division is often a bit slower, but not much). So casting between double and float is the only expensive operation here. So, add in your argument of better precision and it's probably best to just stick with doubles. > > Just to play devil's advocate, it also means twice the cost of memory bandwidth for loads and stores. Also, SSE2 is capable of 4-wide single-precision ops, but only 2-wide double-precision ops, so it would halve the throughput too (although this code doesn't use SSE2 yet AFAIK). Finally, using doubles also means 80bit on x64 FPU, but then 64bit on other platforms and when using SSE2, which can cause differing test results. This issue clearly intends to never die. Your memory bandwidth and 80 bit vs 64 bit arguments are unconvincing. Unfortunately, your SSE2 argument is a very good one :-) I've been thinking for a while that I wanted to make an SSE version of TransformationMatrix, along with some other changes that make it more WebGL friendly. So it really comes down to the choice between precision and performance. As far as precision goes, OpenGL seems to do quite well with single precision math. Of course, you can finesse the data sent to the GPU to expand the range while keeping within 32 bit floats. So there is still an argument for having the extra precision at the higher levels. Of course we don't give authors any tools at all to help finesse the numbers, so doing double arithmetic is most likely just wasted when it comes to WebGL or any other rendering library that uses 32 bit floats. Ken, you've said you will now put your Vector3 logic into FloatPoint3D. Is your intent to change FloatPoint3D to doubles? If not, then it seems clear that TransformationMatrix should be changed back to floats. All the TransformOperations are just interfaces to JS so we can keep doubles there and narrow them when sent into TransformationMatrix. If we (finally) agree, we should open a new bug for this work. I am happy to do it since I'm the one who got us into this in the first place. 271775 20 kbr 2010-08-30 17:03:58 -0700 (In reply to comment #19) > Ken, you've said you will now put your Vector3 logic into FloatPoint3D. Is your intent to change FloatPoint3D to doubles? If not, then it seems clear that TransformationMatrix should be changed back to floats. All the TransformOperations are just interfaces to JS so we can keep doubles there and narrow them when sent into TransformationMatrix. No, I'm going to leave FloatPoint3D as floats. From my standpoint the only operation missing on FloatPoint3D is cross product. > If we (finally) agree, we should open a new bug for this work. I am happy to do it since I'm the one who got us into this in the first place. Yes, I've already closed this one as invalid. Note that Chris Rogers recently landed wtf/Vector3.h, which I also hadn't realized when I landed the first of the above two patches. We'll want to avoid code and class duplication when deciding what refactoring to do. 65529 2010-08-25 23:32:27 -0700 2010-08-26 10:30:52 -0700 Patch transform.patch text/plain 9119 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjA4MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzcgQEAKKzIwMTAtMDgtMjUgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEV4 cG9zZSBWZWN0b3IzIGFuZCBhc3NvY2lhdGVkIG9wZXJhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NjY2CisKKyAgICAgICAgTm8gbmV3IHRl c3RzOyByYW4gc2V2ZXJhbCAzRCBDU1MgZGVtb3MgYW5kIGRpZCBmdWxsIGxheW91dCB0ZXN0Cisg ICAgICAgIHJ1bi4gTmV3IGNvZGUgcGF0aHMgaGF2ZSBhbHNvIGJlZW4gdGVzdGVkIGJ5IG5ldyBj YWxsaW5nIGNvZGUKKyAgICAgICAgd2hpY2ggd2lsbCBiZSBjaGVja2VkIGluIHNvb24uCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmRlY29tcG9zZSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvdHJhbnNmb3Jtcy9UcmFuc2Zvcm1hdGlvbk1hdHJpeC5oOgorICAgICAgICAoV2Vi Q29yZTo6VmVjdG9yMzo6VmVjdG9yMyk6CisgICAgICAgIChXZWJDb3JlOjpWZWN0b3IzOjp4KToK KyAgICAgICAgKFdlYkNvcmU6OlZlY3RvcjM6OnkpOgorICAgICAgICAoV2ViQ29yZTo6VmVjdG9y Mzo6eik6CisgICAgICAgIChXZWJDb3JlOjpWZWN0b3IzOjpzZXRYKToKKyAgICAgICAgKFdlYkNv cmU6OlZlY3RvcjM6OnNldFkpOgorICAgICAgICAoV2ViQ29yZTo6VmVjdG9yMzo6c2V0Wik6Cisg ICAgICAgIChXZWJDb3JlOjpWZWN0b3IzOjpzZXQpOgorICAgICAgICAoV2ViQ29yZTo6VmVjdG9y Mzo6b3BlcmF0b3IgPSk6CisgICAgICAgIChXZWJDb3JlOjpWZWN0b3IzOjpvcGVyYXRvciArKToK KyAgICAgICAgKFdlYkNvcmU6OlZlY3RvcjM6Om9wZXJhdG9yIC0pOgorICAgICAgICAoV2ViQ29y ZTo6VmVjdG9yMzo6b3BlcmF0b3JbXSk6CisgICAgICAgIChXZWJDb3JlOjpWZWN0b3IzOjpsZW5n dGgpOgorICAgICAgICAoV2ViQ29yZTo6VmVjdG9yMzo6bGVuZ3RoU3F1YXJlZCk6CisgICAgICAg IChXZWJDb3JlOjpWZWN0b3IzOjpzY2FsZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlZlY3RvcjM6 Om5vcm1hbGl6ZSk6CisgICAgICAgIChXZWJDb3JlOjpWZWN0b3IzOjpkb3QpOgorICAgICAgICAo V2ViQ29yZTo6VmVjdG9yMzo6Y29tYmluZSk6CisgICAgICAgIChXZWJDb3JlOjpWZWN0b3IzOjpj cm9zcyk6CisKIDIwMTAtMDgtMjUgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21h aWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2NjA3NC4KSW5kZXg6 IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3Jtcy9UcmFuc2Zvcm1hdGlvbk1hdHJp eC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1z L1RyYW5zZm9ybWF0aW9uTWF0cml4LmNwcAkocmV2aXNpb24gNjYwNzkpCisrKyBXZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvVHJhbnNmb3JtYXRpb25NYXRyaXguY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC03MSw3ICs3MSw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIC8vIG9wcG9z aXRlIG9wZXJhdGlvbnMuIFNvIHdlIGhhdmUgdG8gYmUgVkVSWSBjYXJlZnVsIHdoZW4gd2UgY2hh bmdlIHRoZW0uCiAKIHR5cGVkZWYgZG91YmxlIFZlY3RvcjRbNF07Ci10eXBlZGVmIGRvdWJsZSBW ZWN0b3IzWzNdOwogCiBjb25zdCBkb3VibGUgU01BTExfTlVNQkVSID0gMS5lLTg7CiAKQEAgLTI1 NCw0NCArMjUzLDYgQEAgc3RhdGljIHZvaWQgdjRNdWxQb2ludEJ5TWF0cml4KGNvbnN0IFZlYwog ICAgICAgICAgICAgICAgIChwWzJdICogbVsyXVszXSkgKyAocFszXSAqIG1bM11bM10pOwogfQog Ci1zdGF0aWMgZG91YmxlIHYzTGVuZ3RoKFZlY3RvcjMgYSkKLXsKLSAgICByZXR1cm4gc3FydCgo YVswXSAqIGFbMF0pICsgKGFbMV0gKiBhWzFdKSArIChhWzJdICogYVsyXSkpOwotfQotCi1zdGF0 aWMgdm9pZCB2M1NjYWxlKFZlY3RvcjMgdiwgZG91YmxlIGRlc2lyZWRMZW5ndGgpIAotewotICAg IGRvdWJsZSBsZW4gPSB2M0xlbmd0aCh2KTsKLSAgICBpZiAobGVuICE9IDApIHsKLSAgICAgICAg ZG91YmxlIGwgPSBkZXNpcmVkTGVuZ3RoIC8gbGVuOwotICAgICAgICB2WzBdICo9IGw7Ci0gICAg ICAgIHZbMV0gKj0gbDsKLSAgICAgICAgdlsyXSAqPSBsOwotICAgIH0KLX0KLQotc3RhdGljIGRv dWJsZSB2M0RvdChjb25zdCBWZWN0b3IzIGEsIGNvbnN0IFZlY3RvcjMgYikgCi17Ci0gICAgcmV0 dXJuIChhWzBdICogYlswXSkgKyAoYVsxXSAqIGJbMV0pICsgKGFbMl0gKiBiWzJdKTsKLX0KLQot Ly8gTWFrZSBhIGxpbmVhciBjb21iaW5hdGlvbiBvZiB0d28gdmVjdG9ycyBhbmQgcmV0dXJuIHRo ZSByZXN1bHQuCi0vLyByZXN1bHQgPSAoYSAqIGFzY2wpICsgKGIgKiBic2NsKQotc3RhdGljIHZv aWQgdjNDb21iaW5lKGNvbnN0IFZlY3RvcjMgYSwgY29uc3QgVmVjdG9yMyBiLCBWZWN0b3IzIHJl c3VsdCwgZG91YmxlIGFzY2wsIGRvdWJsZSBic2NsKQotewotICAgIHJlc3VsdFswXSA9IChhc2Ns ICogYVswXSkgKyAoYnNjbCAqIGJbMF0pOwotICAgIHJlc3VsdFsxXSA9IChhc2NsICogYVsxXSkg KyAoYnNjbCAqIGJbMV0pOwotICAgIHJlc3VsdFsyXSA9IChhc2NsICogYVsyXSkgKyAoYnNjbCAq IGJbMl0pOwotfQotCi0vLyBSZXR1cm4gdGhlIGNyb3NzIHByb2R1Y3QgcmVzdWx0ID0gYSBjcm9z cyBiICovCi1zdGF0aWMgdm9pZCB2M0Nyb3NzKGNvbnN0IFZlY3RvcjMgYSwgY29uc3QgVmVjdG9y MyBiLCBWZWN0b3IzIHJlc3VsdCkKLXsKLSAgICByZXN1bHRbMF0gPSAoYVsxXSAqIGJbMl0pIC0g KGFbMl0gKiBiWzFdKTsKLSAgICByZXN1bHRbMV0gPSAoYVsyXSAqIGJbMF0pIC0gKGFbMF0gKiBi WzJdKTsKLSAgICByZXN1bHRbMl0gPSAoYVswXSAqIGJbMV0pIC0gKGFbMV0gKiBiWzBdKTsKLX0K LQogc3RhdGljIGJvb2wgZGVjb21wb3NlKGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4OjpNYXRy aXg0JiBtYXQsIFRyYW5zZm9ybWF0aW9uTWF0cml4OjpEZWNvbXBvc2VkVHlwZSYgcmVzdWx0KQog ewogICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4OjpNYXRyaXg0IGxvY2FsTWF0cml4OwpAQCAtMzY5 LDM1ICszMzAsMzUgQEAgc3RhdGljIGJvb2wgZGVjb21wb3NlKGNvbnN0IFRyYW5zZm9ybWF0aQog ICAgIH0KIAogICAgIC8vIENvbXB1dGUgWCBzY2FsZSBmYWN0b3IgYW5kIG5vcm1hbGl6ZSBmaXJz dCByb3cuCi0gICAgcmVzdWx0LnNjYWxlWCA9IHYzTGVuZ3RoKHJvd1swXSk7Ci0gICAgdjNTY2Fs ZShyb3dbMF0sIDEuMCk7CisgICAgcmVzdWx0LnNjYWxlWCA9IHJvd1swXS5sZW5ndGgoKTsKKyAg ICByb3dbMF0uc2NhbGVUbygxLjApOwogCiAgICAgLy8gQ29tcHV0ZSBYWSBzaGVhciBmYWN0b3Ig YW5kIG1ha2UgMm5kIHJvdyBvcnRob2dvbmFsIHRvIDFzdC4KLSAgICByZXN1bHQuc2tld1hZID0g djNEb3Qocm93WzBdLCByb3dbMV0pOwotICAgIHYzQ29tYmluZShyb3dbMV0sIHJvd1swXSwgcm93 WzFdLCAxLjAsIC1yZXN1bHQuc2tld1hZKTsKKyAgICByZXN1bHQuc2tld1hZID0gcm93WzBdLmRv dChyb3dbMV0pOworICAgIHJvd1sxXS5jb21iaW5lKHJvd1sxXSwgcm93WzBdLCAxLjAsIC1yZXN1 bHQuc2tld1hZKTsKIAogICAgIC8vIE5vdywgY29tcHV0ZSBZIHNjYWxlIGFuZCBub3JtYWxpemUg Mm5kIHJvdy4KLSAgICByZXN1bHQuc2NhbGVZID0gdjNMZW5ndGgocm93WzFdKTsKLSAgICB2M1Nj YWxlKHJvd1sxXSwgMS4wKTsKKyAgICByZXN1bHQuc2NhbGVZID0gcm93WzFdLmxlbmd0aCgpOwor ICAgIHJvd1sxXS5zY2FsZVRvKDEuMCk7CiAgICAgcmVzdWx0LnNrZXdYWSAvPSByZXN1bHQuc2Nh bGVZOwogCiAgICAgLy8gQ29tcHV0ZSBYWiBhbmQgWVogc2hlYXJzLCBvcnRob2dvbmFsaXplIDNy ZCByb3cuCi0gICAgcmVzdWx0LnNrZXdYWiA9IHYzRG90KHJvd1swXSwgcm93WzJdKTsKLSAgICB2 M0NvbWJpbmUocm93WzJdLCByb3dbMF0sIHJvd1syXSwgMS4wLCAtcmVzdWx0LnNrZXdYWik7Ci0g ICAgcmVzdWx0LnNrZXdZWiA9IHYzRG90KHJvd1sxXSwgcm93WzJdKTsKLSAgICB2M0NvbWJpbmUo cm93WzJdLCByb3dbMV0sIHJvd1syXSwgMS4wLCAtcmVzdWx0LnNrZXdZWik7CisgICAgcmVzdWx0 LnNrZXdYWiA9IHJvd1swXS5kb3Qocm93WzJdKTsKKyAgICByb3dbMl0uY29tYmluZShyb3dbMl0s IHJvd1swXSwgMS4wLCAtcmVzdWx0LnNrZXdYWik7CisgICAgcmVzdWx0LnNrZXdZWiA9IHJvd1sx XS5kb3Qocm93WzJdKTsKKyAgICByb3dbMl0uY29tYmluZShyb3dbMl0sIHJvd1sxXSwgMS4wLCAt cmVzdWx0LnNrZXdZWik7CiAKICAgICAvLyBOZXh0LCBnZXQgWiBzY2FsZSBhbmQgbm9ybWFsaXpl IDNyZCByb3cuCi0gICAgcmVzdWx0LnNjYWxlWiA9IHYzTGVuZ3RoKHJvd1syXSk7Ci0gICAgdjNT Y2FsZShyb3dbMl0sIDEuMCk7CisgICAgcmVzdWx0LnNjYWxlWiA9IHJvd1syXS5sZW5ndGgoKTsK KyAgICByb3dbMl0uc2NhbGVUbygxLjApOwogICAgIHJlc3VsdC5za2V3WFogLz0gcmVzdWx0LnNj YWxlWjsKICAgICByZXN1bHQuc2tld1laIC89IHJlc3VsdC5zY2FsZVo7CiAgCiAgICAgLy8gQXQg dGhpcyBwb2ludCwgdGhlIG1hdHJpeCAoaW4gcm93c1tdKSBpcyBvcnRob25vcm1hbC4KICAgICAv LyBDaGVjayBmb3IgYSBjb29yZGluYXRlIHN5c3RlbSBmbGlwLiAgSWYgdGhlIGRldGVybWluYW50 CiAgICAgLy8gaXMgLTEsIHRoZW4gbmVnYXRlIHRoZSBtYXRyaXggYW5kIHRoZSBzY2FsaW5nIGZh Y3RvcnMuCi0gICAgdjNDcm9zcyhyb3dbMV0sIHJvd1syXSwgcGR1bTMpOwotICAgIGlmICh2M0Rv dChyb3dbMF0sIHBkdW0zKSA8IDApIHsKKyAgICBwZHVtMy5jcm9zcyhyb3dbMV0sIHJvd1syXSk7 CisgICAgaWYgKHJvd1swXS5kb3QocGR1bTMpIDwgMCkgewogICAgICAgICBmb3IgKGkgPSAwOyBp IDwgMzsgaSsrKSB7CiAgICAgICAgICAgICByZXN1bHQuc2NhbGVYICo9IC0xOwogICAgICAgICAg ICAgcm93W2ldWzBdICo9IC0xOwpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFu c2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmgJKHJldmlzaW9u IDY2MDc5KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy90cmFuc2Zvcm1zL1RyYW5zZm9y bWF0aW9uTWF0cml4LmgJKHdvcmtpbmcgY29weSkKQEAgLTYyLDYgKzYyLDEzMCBAQCBjbGFzcyBG bG9hdFBvaW50M0Q7CiBjbGFzcyBGbG9hdFJlY3Q7CiBjbGFzcyBGbG9hdFF1YWQ7CiAKK2NsYXNz IFZlY3RvcjMgOiBwdWJsaWMgRmFzdEFsbG9jQmFzZSB7CitwdWJsaWM6CisgICAgVmVjdG9yMygp IHsgc2V0KDAsIDAsIDApOyB9CisgICAgVmVjdG9yMyhjb25zdCBWZWN0b3IzJiB2KSB7ICp0aGlz ID0gdjsgfQorICAgIFZlY3RvcjMoZG91YmxlIHgsIGRvdWJsZSB5LCBkb3VibGUgeikgeyBzZXQo eCwgeSwgeik7IH0KKworICAgIGRvdWJsZSB4KCkgY29uc3QgeyByZXR1cm4gbV92ZWN0b3JbMF07 IH0KKyAgICBkb3VibGUgeSgpIGNvbnN0IHsgcmV0dXJuIG1fdmVjdG9yWzFdOyB9CisgICAgZG91 YmxlIHooKSBjb25zdCB7IHJldHVybiBtX3ZlY3RvclsyXTsgfQorICAgIHZvaWQgc2V0WChkb3Vi bGUgeCkgeyBtX3ZlY3RvclswXSA9IHg7IH0KKyAgICB2b2lkIHNldFkoZG91YmxlIHkpIHsgbV92 ZWN0b3JbMV0gPSB5OyB9CisgICAgdm9pZCBzZXRaKGRvdWJsZSB6KSB7IG1fdmVjdG9yWzJdID0g ejsgfQorCisgICAgdm9pZCBzZXQoZG91YmxlIHgsIGRvdWJsZSB5LCBkb3VibGUgeikKKyAgICB7 CisgICAgICAgIG1fdmVjdG9yWzBdID0geDsKKyAgICAgICAgbV92ZWN0b3JbMV0gPSB5OworICAg ICAgICBtX3ZlY3RvclsyXSA9IHo7CisgICAgfQorCisgICAgdm9pZCBzZXQoY29uc3QgVmVjdG9y MyYgdikKKyAgICB7CisgICAgICAgIGlmIChtX3ZlY3RvciAhPSB2Lm1fdmVjdG9yKQorICAgICAg ICAgICAgbWVtY3B5KG1fdmVjdG9yLCB2Lm1fdmVjdG9yLCBzaXplb2YobV92ZWN0b3IpKTsKKyAg ICB9CisKKyAgICBWZWN0b3IzJiBvcGVyYXRvciA9KGNvbnN0IFZlY3RvcjMmIHYpCisgICAgewor ICAgICAgICBzZXQodik7CisgICAgICAgIHJldHVybiAqdGhpczsKKyAgICB9CisKKyAgICBWZWN0 b3IzIG9wZXJhdG9yICsoY29uc3QgVmVjdG9yMyYgdikgY29uc3QKKyAgICB7CisgICAgICAgIHJl dHVybiBWZWN0b3IzKG1fdmVjdG9yWzBdICsgdlswXSwKKyAgICAgICAgICAgICAgICAgICAgICAg bV92ZWN0b3JbMV0gKyB2WzFdLAorICAgICAgICAgICAgICAgICAgICAgICBtX3ZlY3RvclsyXSAr IHZbMl0pOworICAgIH0KKworICAgIFZlY3RvcjMgb3BlcmF0b3IgLShjb25zdCBWZWN0b3IzJiB2 KSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIFZlY3RvcjMobV92ZWN0b3JbMF0gLSB2WzBd LAorICAgICAgICAgICAgICAgICAgICAgICBtX3ZlY3RvclsxXSAtIHZbMV0sCisgICAgICAgICAg ICAgICAgICAgICAgIG1fdmVjdG9yWzJdIC0gdlsyXSk7CisgICAgfQorCisgICAgZG91YmxlJiBv cGVyYXRvcltdKGludCBpbmRleCkKKyAgICB7CisgICAgICAgIEFTU0VSVChpbmRleCA+PSAwICYm IGluZGV4IDw9IDIpOworICAgICAgICByZXR1cm4gbV92ZWN0b3JbaW5kZXhdOworICAgIH0KKwor ICAgIGNvbnN0IGRvdWJsZSYgb3BlcmF0b3JbXShpbnQgaW5kZXgpIGNvbnN0CisgICAgeworICAg ICAgICBBU1NFUlQoaW5kZXggPj0gMCAmJiBpbmRleCA8PSAyKTsKKyAgICAgICAgcmV0dXJuIG1f dmVjdG9yW2luZGV4XTsKKyAgICB9CisKKyAgICBkb3VibGUgbGVuZ3RoKCkgY29uc3QKKyAgICB7 CisgICAgICAgIHJldHVybiBzcXJ0KGxlbmd0aFNxdWFyZWQoKSk7CisgICAgfQorCisgICAgZG91 YmxlIGxlbmd0aFNxdWFyZWQoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIChtX3ZlY3Rv clswXSAqIG1fdmVjdG9yWzBdKSArIChtX3ZlY3RvclsxXSAqIG1fdmVjdG9yWzFdKSArIChtX3Zl Y3RvclsyXSAqIG1fdmVjdG9yWzJdKTsKKyAgICB9CisKKyAgICB2b2lkIHNjYWxlVG8oZG91Ymxl IGRlc2lyZWRMZW5ndGgpCisgICAgeworICAgICAgICBkb3VibGUgbGVuID0gbGVuZ3RoKCk7Cisg ICAgICAgIGlmIChsZW4pIHsKKyAgICAgICAgICAgIGRvdWJsZSBzY2FsZUZhY3RvciA9IGRlc2ly ZWRMZW5ndGggLyBsZW47CisgICAgICAgICAgICBtX3ZlY3RvclswXSAqPSBzY2FsZUZhY3RvcjsK KyAgICAgICAgICAgIG1fdmVjdG9yWzFdICo9IHNjYWxlRmFjdG9yOworICAgICAgICAgICAgbV92 ZWN0b3JbMl0gKj0gc2NhbGVGYWN0b3I7CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2b2lkIG5v cm1hbGl6ZSgpCisgICAgeworICAgICAgICBzY2FsZVRvKDEuMCk7CisgICAgfQorCisgICAgZG91 YmxlIGRvdChjb25zdCBWZWN0b3IzJiB2KSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1f dmVjdG9yWzBdICogdlswXSArIG1fdmVjdG9yWzFdICogdlsxXSArIG1fdmVjdG9yWzJdICogdlsy XTsKKyAgICB9CisKKyAgICAvLyBTZXRzIHRoaXMgdG8gYSBsaW5lYXIgY29tYmluYXRpb24gb2Yg dHdvIHZlY3RvcnMuCisgICAgLy8gdGhpcyA9IChhICogYXNjbCkgKyAoYiAqIGJzY2wpLgorICAg IC8vIEl0IGlzIHNhZmUgZm9yICJ0aGlzIiB0byBiZSBlaXRoZXIgYSBvciBiLgorICAgIHZvaWQg Y29tYmluZShjb25zdCBWZWN0b3IzJiBhLCBjb25zdCBWZWN0b3IzJiBiLCBkb3VibGUgYXNjbCwg ZG91YmxlIGJzY2wpCisgICAgeworICAgICAgICBtX3ZlY3RvclswXSA9IChhc2NsICogYVswXSkg KyAoYnNjbCAqIGJbMF0pOworICAgICAgICBtX3ZlY3RvclsxXSA9IChhc2NsICogYVsxXSkgKyAo YnNjbCAqIGJbMV0pOworICAgICAgICBtX3ZlY3RvclsyXSA9IChhc2NsICogYVsyXSkgKyAoYnNj bCAqIGJbMl0pOworICAgIH0KKworICAgIC8vIFNldHMgdGhpcyB0byB0aGUgY3Jvc3MgcHJvZHVj dCBvZiBhIGFuZCBiLgorICAgIC8vIEl0IGlzIHNhZmUgZm9yICJ0aGlzIiB0byBiZSBlaXRoZXIg YSBvciBiLgorICAgIHZvaWQgY3Jvc3MoY29uc3QgVmVjdG9yMyYgYSwgY29uc3QgVmVjdG9yMyYg YikKKyAgICB7CisgICAgICAgIGRvdWJsZSB4ID0gKGFbMV0gKiBiWzJdKSAtIChhWzJdICogYlsx XSk7CisgICAgICAgIGRvdWJsZSB5ID0gKGFbMl0gKiBiWzBdKSAtIChhWzBdICogYlsyXSk7Cisg ICAgICAgIGRvdWJsZSB6ID0gKGFbMF0gKiBiWzFdKSAtIChhWzFdICogYlswXSk7CisgICAgICAg IG1fdmVjdG9yWzBdID0geDsKKyAgICAgICAgbV92ZWN0b3JbMV0gPSB5OworICAgICAgICBtX3Zl Y3RvclsyXSA9IHo7CisgICAgfQorCisgICAgLy8gQ29udmVuaWVuY2Ugcm91dGluZSB3aGljaCBy ZXR1cm5zIHRoZSByZXN1bHQgb2YgInRoaXMgY3Jvc3MgdiIKKyAgICAvLyBhcyBhIG5ldyBWZWN0 b3IzLgorICAgIFZlY3RvcjMgY3Jvc3MoY29uc3QgVmVjdG9yMyYgdikgY29uc3QKKyAgICB7Cisg ICAgICAgIFZlY3RvcjMgcmVzdWx0OworICAgICAgICByZXN1bHQuY3Jvc3MoKnRoaXMsIHYpOwor ICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKworcHJpdmF0ZToKKyAgICBkb3VibGUgbV92 ZWN0b3JbM107Cit9OworCiBjbGFzcyBUcmFuc2Zvcm1hdGlvbk1hdHJpeCA6IHB1YmxpYyBGYXN0 QWxsb2NCYXNlIHsKIHB1YmxpYzoKICAgICB0eXBlZGVmIGRvdWJsZSBNYXRyaXg0WzRdWzRdOwo= 65937 2010-08-30 12:18:29 -0700 2010-08-30 15:16:19 -0700 Roll out of previous patch vector-rollout.patch text/plain 8527 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjM5OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjMgQEAKKzIwMTAtMDgtMzAgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEV4 cG9zZSBWZWN0b3IzIGFuZCBhc3NvY2lhdGVkIG9wZXJhdGlvbnMKKyAgICAgICAgTmVlZCBhIHNo b3J0IGRlc2NyaXB0aW9uIGFuZCBidWcgVVJMIChPT1BTISkKKworICAgICAgICBSb2xsaW5nIG91 dCBlYXJsaWVyIHBhdGNoIGV4cG9zaW5nIFZlY3RvcjMgY2xhc3MgaW4KKyAgICAgICAgVHJhbnNm b3JtYXRpb25NYXRyaXguaC4gQSBkaWZmZXJlbnQgYXBwcm9hY2ggd2lsbCBiZSB0YWtlbiB1bmRl cgorICAgICAgICBhbm90aGVyIGJ1Zy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3Ry YW5zZm9ybXMvVHJhbnNmb3JtYXRpb25NYXRyaXguY3BwOgorICAgICAgICAoV2ViQ29yZTo6djNM ZW5ndGgpOgorICAgICAgICAoV2ViQ29yZTo6djNTY2FsZSk6CisgICAgICAgIChXZWJDb3JlOjp2 M0RvdCk6CisgICAgICAgIChXZWJDb3JlOjp2M0NvbWJpbmUpOgorICAgICAgICAoV2ViQ29yZTo6 djNDcm9zcyk6CisgICAgICAgIChXZWJDb3JlOjpkZWNvbXBvc2UpOgorICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvVHJhbnNmb3JtYXRpb25NYXRyaXguaGE6CisKIDIwMTAt MDgtMzAgIEFsZWphbmRybyBHLiBDYXN0cm8gIDxhbGV4QGlnYWxpYS5jb20+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgTWFydGluIFJvYmluc29uLgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy90cmFuc2Zvcm1zL1RyYW5zZm9ybWF0aW9uTWF0cml4LmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvVHJhbnNmb3JtYXRpb25NYXRyaXgu Y3BwCShyZXZpc2lvbiA2NjM5OSkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNm b3Jtcy9UcmFuc2Zvcm1hdGlvbk1hdHJpeC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTcxLDYgKzcx LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogLy8gb3Bwb3NpdGUgb3BlcmF0aW9ucy4gU28gd2Ug aGF2ZSB0byBiZSBWRVJZIGNhcmVmdWwgd2hlbiB3ZSBjaGFuZ2UgdGhlbS4KIAogdHlwZWRlZiBk b3VibGUgVmVjdG9yNFs0XTsKK3R5cGVkZWYgZG91YmxlIFZlY3RvcjNbM107CiAKIGNvbnN0IGRv dWJsZSBTTUFMTF9OVU1CRVIgPSAxLmUtODsKIApAQCAtMjUzLDYgKzI1NCw0NCBAQCBzdGF0aWMg dm9pZCB2NE11bFBvaW50QnlNYXRyaXgoY29uc3QgVmVjCiAgICAgICAgICAgICAgICAgKHBbMl0g KiBtWzJdWzNdKSArIChwWzNdICogbVszXVszXSk7CiB9CiAKK3N0YXRpYyBkb3VibGUgdjNMZW5n dGgoVmVjdG9yMyBhKQoreworICAgIHJldHVybiBzcXJ0KChhWzBdICogYVswXSkgKyAoYVsxXSAq IGFbMV0pICsgKGFbMl0gKiBhWzJdKSk7Cit9CisKK3N0YXRpYyB2b2lkIHYzU2NhbGUoVmVjdG9y MyB2LCBkb3VibGUgZGVzaXJlZExlbmd0aCkgCit7CisgICAgZG91YmxlIGxlbiA9IHYzTGVuZ3Ro KHYpOworICAgIGlmIChsZW4gIT0gMCkgeworICAgICAgICBkb3VibGUgbCA9IGRlc2lyZWRMZW5n dGggLyBsZW47CisgICAgICAgIHZbMF0gKj0gbDsKKyAgICAgICAgdlsxXSAqPSBsOworICAgICAg ICB2WzJdICo9IGw7CisgICAgfQorfQorCitzdGF0aWMgZG91YmxlIHYzRG90KGNvbnN0IFZlY3Rv cjMgYSwgY29uc3QgVmVjdG9yMyBiKSAKK3sKKyAgICByZXR1cm4gKGFbMF0gKiBiWzBdKSArIChh WzFdICogYlsxXSkgKyAoYVsyXSAqIGJbMl0pOworfQorCisvLyBNYWtlIGEgbGluZWFyIGNvbWJp bmF0aW9uIG9mIHR3byB2ZWN0b3JzIGFuZCByZXR1cm4gdGhlIHJlc3VsdC4KKy8vIHJlc3VsdCA9 IChhICogYXNjbCkgKyAoYiAqIGJzY2wpCitzdGF0aWMgdm9pZCB2M0NvbWJpbmUoY29uc3QgVmVj dG9yMyBhLCBjb25zdCBWZWN0b3IzIGIsIFZlY3RvcjMgcmVzdWx0LCBkb3VibGUgYXNjbCwgZG91 YmxlIGJzY2wpCit7CisgICAgcmVzdWx0WzBdID0gKGFzY2wgKiBhWzBdKSArIChic2NsICogYlsw XSk7CisgICAgcmVzdWx0WzFdID0gKGFzY2wgKiBhWzFdKSArIChic2NsICogYlsxXSk7CisgICAg cmVzdWx0WzJdID0gKGFzY2wgKiBhWzJdKSArIChic2NsICogYlsyXSk7Cit9CisKKy8vIFJldHVy biB0aGUgY3Jvc3MgcHJvZHVjdCByZXN1bHQgPSBhIGNyb3NzIGIgKi8KK3N0YXRpYyB2b2lkIHYz Q3Jvc3MoY29uc3QgVmVjdG9yMyBhLCBjb25zdCBWZWN0b3IzIGIsIFZlY3RvcjMgcmVzdWx0KQor eworICAgIHJlc3VsdFswXSA9IChhWzFdICogYlsyXSkgLSAoYVsyXSAqIGJbMV0pOworICAgIHJl c3VsdFsxXSA9IChhWzJdICogYlswXSkgLSAoYVswXSAqIGJbMl0pOworICAgIHJlc3VsdFsyXSA9 IChhWzBdICogYlsxXSkgLSAoYVsxXSAqIGJbMF0pOworfQorCiBzdGF0aWMgYm9vbCBkZWNvbXBv c2UoY29uc3QgVHJhbnNmb3JtYXRpb25NYXRyaXg6Ok1hdHJpeDQmIG1hdCwgVHJhbnNmb3JtYXRp b25NYXRyaXg6OkRlY29tcG9zZWRUeXBlJiByZXN1bHQpCiB7CiAgICAgVHJhbnNmb3JtYXRpb25N YXRyaXg6Ok1hdHJpeDQgbG9jYWxNYXRyaXg7CkBAIC0zMzAsMzUgKzM2OSwzNSBAQCBzdGF0aWMg Ym9vbCBkZWNvbXBvc2UoY29uc3QgVHJhbnNmb3JtYXRpCiAgICAgfQogCiAgICAgLy8gQ29tcHV0 ZSBYIHNjYWxlIGZhY3RvciBhbmQgbm9ybWFsaXplIGZpcnN0IHJvdy4KLSAgICByZXN1bHQuc2Nh bGVYID0gcm93WzBdLmxlbmd0aCgpOwotICAgIHJvd1swXS5zY2FsZVRvKDEuMCk7CisgICAgcmVz dWx0LnNjYWxlWCA9IHYzTGVuZ3RoKHJvd1swXSk7CisgICAgdjNTY2FsZShyb3dbMF0sIDEuMCk7 CiAKICAgICAvLyBDb21wdXRlIFhZIHNoZWFyIGZhY3RvciBhbmQgbWFrZSAybmQgcm93IG9ydGhv Z29uYWwgdG8gMXN0LgotICAgIHJlc3VsdC5za2V3WFkgPSByb3dbMF0uZG90KHJvd1sxXSk7Ci0g ICAgcm93WzFdLmNvbWJpbmUocm93WzFdLCByb3dbMF0sIDEuMCwgLXJlc3VsdC5za2V3WFkpOwor ICAgIHJlc3VsdC5za2V3WFkgPSB2M0RvdChyb3dbMF0sIHJvd1sxXSk7CisgICAgdjNDb21iaW5l KHJvd1sxXSwgcm93WzBdLCByb3dbMV0sIDEuMCwgLXJlc3VsdC5za2V3WFkpOwogCiAgICAgLy8g Tm93LCBjb21wdXRlIFkgc2NhbGUgYW5kIG5vcm1hbGl6ZSAybmQgcm93LgotICAgIHJlc3VsdC5z Y2FsZVkgPSByb3dbMV0ubGVuZ3RoKCk7Ci0gICAgcm93WzFdLnNjYWxlVG8oMS4wKTsKKyAgICBy ZXN1bHQuc2NhbGVZID0gdjNMZW5ndGgocm93WzFdKTsKKyAgICB2M1NjYWxlKHJvd1sxXSwgMS4w KTsKICAgICByZXN1bHQuc2tld1hZIC89IHJlc3VsdC5zY2FsZVk7CiAKICAgICAvLyBDb21wdXRl IFhaIGFuZCBZWiBzaGVhcnMsIG9ydGhvZ29uYWxpemUgM3JkIHJvdy4KLSAgICByZXN1bHQuc2tl d1haID0gcm93WzBdLmRvdChyb3dbMl0pOwotICAgIHJvd1syXS5jb21iaW5lKHJvd1syXSwgcm93 WzBdLCAxLjAsIC1yZXN1bHQuc2tld1haKTsKLSAgICByZXN1bHQuc2tld1laID0gcm93WzFdLmRv dChyb3dbMl0pOwotICAgIHJvd1syXS5jb21iaW5lKHJvd1syXSwgcm93WzFdLCAxLjAsIC1yZXN1 bHQuc2tld1laKTsKKyAgICByZXN1bHQuc2tld1haID0gdjNEb3Qocm93WzBdLCByb3dbMl0pOwor ICAgIHYzQ29tYmluZShyb3dbMl0sIHJvd1swXSwgcm93WzJdLCAxLjAsIC1yZXN1bHQuc2tld1ha KTsKKyAgICByZXN1bHQuc2tld1laID0gdjNEb3Qocm93WzFdLCByb3dbMl0pOworICAgIHYzQ29t YmluZShyb3dbMl0sIHJvd1sxXSwgcm93WzJdLCAxLjAsIC1yZXN1bHQuc2tld1laKTsKIAogICAg IC8vIE5leHQsIGdldCBaIHNjYWxlIGFuZCBub3JtYWxpemUgM3JkIHJvdy4KLSAgICByZXN1bHQu c2NhbGVaID0gcm93WzJdLmxlbmd0aCgpOwotICAgIHJvd1syXS5zY2FsZVRvKDEuMCk7CisgICAg cmVzdWx0LnNjYWxlWiA9IHYzTGVuZ3RoKHJvd1syXSk7CisgICAgdjNTY2FsZShyb3dbMl0sIDEu MCk7CiAgICAgcmVzdWx0LnNrZXdYWiAvPSByZXN1bHQuc2NhbGVaOwogICAgIHJlc3VsdC5za2V3 WVogLz0gcmVzdWx0LnNjYWxlWjsKICAKICAgICAvLyBBdCB0aGlzIHBvaW50LCB0aGUgbWF0cml4 IChpbiByb3dzW10pIGlzIG9ydGhvbm9ybWFsLgogICAgIC8vIENoZWNrIGZvciBhIGNvb3JkaW5h dGUgc3lzdGVtIGZsaXAuICBJZiB0aGUgZGV0ZXJtaW5hbnQKICAgICAvLyBpcyAtMSwgdGhlbiBu ZWdhdGUgdGhlIG1hdHJpeCBhbmQgdGhlIHNjYWxpbmcgZmFjdG9ycy4KLSAgICBwZHVtMy5jcm9z cyhyb3dbMV0sIHJvd1syXSk7Ci0gICAgaWYgKHJvd1swXS5kb3QocGR1bTMpIDwgMCkgeworICAg IHYzQ3Jvc3Mocm93WzFdLCByb3dbMl0sIHBkdW0zKTsKKyAgICBpZiAodjNEb3Qocm93WzBdLCBw ZHVtMykgPCAwKSB7CiAgICAgICAgIGZvciAoaSA9IDA7IGkgPCAzOyBpKyspIHsKICAgICAgICAg ICAgIHJlc3VsdC5zY2FsZVggKj0gLTE7CiAgICAgICAgICAgICByb3dbaV1bMF0gKj0gLTE7Cklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvVHJhbnNmb3JtYXRpb25N YXRyaXguaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9y bXMvVHJhbnNmb3JtYXRpb25NYXRyaXguaAkocmV2aXNpb24gNjYzOTkpCisrKyBXZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL3RyYW5zZm9ybXMvVHJhbnNmb3JtYXRpb25NYXRyaXguaAkod29ya2lu ZyBjb3B5KQpAQCAtNjIsMTMwICs2Miw2IEBAIGNsYXNzIEZsb2F0UG9pbnQzRDsKIGNsYXNzIEZs b2F0UmVjdDsKIGNsYXNzIEZsb2F0UXVhZDsKIAotY2xhc3MgVmVjdG9yMyA6IHB1YmxpYyBGYXN0 QWxsb2NCYXNlIHsKLXB1YmxpYzoKLSAgICBWZWN0b3IzKCkgeyBzZXQoMCwgMCwgMCk7IH0KLSAg ICBWZWN0b3IzKGNvbnN0IFZlY3RvcjMmIHYpIHsgKnRoaXMgPSB2OyB9Ci0gICAgVmVjdG9yMyhk b3VibGUgeCwgZG91YmxlIHksIGRvdWJsZSB6KSB7IHNldCh4LCB5LCB6KTsgfQotCi0gICAgZG91 YmxlIHgoKSBjb25zdCB7IHJldHVybiBtX3ZlY3RvclswXTsgfQotICAgIGRvdWJsZSB5KCkgY29u c3QgeyByZXR1cm4gbV92ZWN0b3JbMV07IH0KLSAgICBkb3VibGUgeigpIGNvbnN0IHsgcmV0dXJu IG1fdmVjdG9yWzJdOyB9Ci0gICAgdm9pZCBzZXRYKGRvdWJsZSB4KSB7IG1fdmVjdG9yWzBdID0g eDsgfQotICAgIHZvaWQgc2V0WShkb3VibGUgeSkgeyBtX3ZlY3RvclsxXSA9IHk7IH0KLSAgICB2 b2lkIHNldFooZG91YmxlIHopIHsgbV92ZWN0b3JbMl0gPSB6OyB9Ci0KLSAgICB2b2lkIHNldChk b3VibGUgeCwgZG91YmxlIHksIGRvdWJsZSB6KQotICAgIHsKLSAgICAgICAgbV92ZWN0b3JbMF0g PSB4OwotICAgICAgICBtX3ZlY3RvclsxXSA9IHk7Ci0gICAgICAgIG1fdmVjdG9yWzJdID0gejsK LSAgICB9Ci0KLSAgICB2b2lkIHNldChjb25zdCBWZWN0b3IzJiB2KQotICAgIHsKLSAgICAgICAg aWYgKG1fdmVjdG9yICE9IHYubV92ZWN0b3IpCi0gICAgICAgICAgICBtZW1jcHkobV92ZWN0b3Is IHYubV92ZWN0b3IsIHNpemVvZihtX3ZlY3RvcikpOwotICAgIH0KLQotICAgIFZlY3RvcjMmIG9w ZXJhdG9yID0oY29uc3QgVmVjdG9yMyYgdikKLSAgICB7Ci0gICAgICAgIHNldCh2KTsKLSAgICAg ICAgcmV0dXJuICp0aGlzOwotICAgIH0KLQotICAgIFZlY3RvcjMgb3BlcmF0b3IgKyhjb25zdCBW ZWN0b3IzJiB2KSBjb25zdAotICAgIHsKLSAgICAgICAgcmV0dXJuIFZlY3RvcjMobV92ZWN0b3Jb MF0gKyB2WzBdLAotICAgICAgICAgICAgICAgICAgICAgICBtX3ZlY3RvclsxXSArIHZbMV0sCi0g ICAgICAgICAgICAgICAgICAgICAgIG1fdmVjdG9yWzJdICsgdlsyXSk7Ci0gICAgfQotCi0gICAg VmVjdG9yMyBvcGVyYXRvciAtKGNvbnN0IFZlY3RvcjMmIHYpIGNvbnN0Ci0gICAgewotICAgICAg ICByZXR1cm4gVmVjdG9yMyhtX3ZlY3RvclswXSAtIHZbMF0sCi0gICAgICAgICAgICAgICAgICAg ICAgIG1fdmVjdG9yWzFdIC0gdlsxXSwKLSAgICAgICAgICAgICAgICAgICAgICAgbV92ZWN0b3Jb Ml0gLSB2WzJdKTsKLSAgICB9Ci0KLSAgICBkb3VibGUmIG9wZXJhdG9yW10oaW50IGluZGV4KQot ICAgIHsKLSAgICAgICAgQVNTRVJUKGluZGV4ID49IDAgJiYgaW5kZXggPD0gMik7Ci0gICAgICAg IHJldHVybiBtX3ZlY3RvcltpbmRleF07Ci0gICAgfQotCi0gICAgY29uc3QgZG91YmxlJiBvcGVy YXRvcltdKGludCBpbmRleCkgY29uc3QKLSAgICB7Ci0gICAgICAgIEFTU0VSVChpbmRleCA+PSAw ICYmIGluZGV4IDw9IDIpOwotICAgICAgICByZXR1cm4gbV92ZWN0b3JbaW5kZXhdOwotICAgIH0K LQotICAgIGRvdWJsZSBsZW5ndGgoKSBjb25zdAotICAgIHsKLSAgICAgICAgcmV0dXJuIHNxcnQo bGVuZ3RoU3F1YXJlZCgpKTsKLSAgICB9Ci0KLSAgICBkb3VibGUgbGVuZ3RoU3F1YXJlZCgpIGNv bnN0Ci0gICAgewotICAgICAgICByZXR1cm4gKG1fdmVjdG9yWzBdICogbV92ZWN0b3JbMF0pICsg KG1fdmVjdG9yWzFdICogbV92ZWN0b3JbMV0pICsgKG1fdmVjdG9yWzJdICogbV92ZWN0b3JbMl0p OwotICAgIH0KLQotICAgIHZvaWQgc2NhbGVUbyhkb3VibGUgZGVzaXJlZExlbmd0aCkKLSAgICB7 Ci0gICAgICAgIGRvdWJsZSBsZW4gPSBsZW5ndGgoKTsKLSAgICAgICAgaWYgKGxlbikgewotICAg ICAgICAgICAgZG91YmxlIHNjYWxlRmFjdG9yID0gZGVzaXJlZExlbmd0aCAvIGxlbjsKLSAgICAg ICAgICAgIG1fdmVjdG9yWzBdICo9IHNjYWxlRmFjdG9yOwotICAgICAgICAgICAgbV92ZWN0b3Jb MV0gKj0gc2NhbGVGYWN0b3I7Ci0gICAgICAgICAgICBtX3ZlY3RvclsyXSAqPSBzY2FsZUZhY3Rv cjsKLSAgICAgICAgfQotICAgIH0KLQotICAgIHZvaWQgbm9ybWFsaXplKCkKLSAgICB7Ci0gICAg ICAgIHNjYWxlVG8oMS4wKTsKLSAgICB9Ci0KLSAgICBkb3VibGUgZG90KGNvbnN0IFZlY3RvcjMm IHYpIGNvbnN0Ci0gICAgewotICAgICAgICByZXR1cm4gbV92ZWN0b3JbMF0gKiB2WzBdICsgbV92 ZWN0b3JbMV0gKiB2WzFdICsgbV92ZWN0b3JbMl0gKiB2WzJdOwotICAgIH0KLQotICAgIC8vIFNl dHMgdGhpcyB0byBhIGxpbmVhciBjb21iaW5hdGlvbiBvZiB0d28gdmVjdG9ycy4KLSAgICAvLyB0 aGlzID0gKGEgKiBhc2NsKSArIChiICogYnNjbCkuCi0gICAgLy8gSXQgaXMgc2FmZSBmb3IgInRo aXMiIHRvIGJlIGVpdGhlciBhIG9yIGIuCi0gICAgdm9pZCBjb21iaW5lKGNvbnN0IFZlY3RvcjMm IGEsIGNvbnN0IFZlY3RvcjMmIGIsIGRvdWJsZSBhc2NsLCBkb3VibGUgYnNjbCkKLSAgICB7Ci0g ICAgICAgIG1fdmVjdG9yWzBdID0gKGFzY2wgKiBhWzBdKSArIChic2NsICogYlswXSk7Ci0gICAg ICAgIG1fdmVjdG9yWzFdID0gKGFzY2wgKiBhWzFdKSArIChic2NsICogYlsxXSk7Ci0gICAgICAg IG1fdmVjdG9yWzJdID0gKGFzY2wgKiBhWzJdKSArIChic2NsICogYlsyXSk7Ci0gICAgfQotCi0g ICAgLy8gU2V0cyB0aGlzIHRvIHRoZSBjcm9zcyBwcm9kdWN0IG9mIGEgYW5kIGIuCi0gICAgLy8g SXQgaXMgc2FmZSBmb3IgInRoaXMiIHRvIGJlIGVpdGhlciBhIG9yIGIuCi0gICAgdm9pZCBjcm9z cyhjb25zdCBWZWN0b3IzJiBhLCBjb25zdCBWZWN0b3IzJiBiKQotICAgIHsKLSAgICAgICAgZG91 YmxlIHggPSAoYVsxXSAqIGJbMl0pIC0gKGFbMl0gKiBiWzFdKTsKLSAgICAgICAgZG91YmxlIHkg PSAoYVsyXSAqIGJbMF0pIC0gKGFbMF0gKiBiWzJdKTsKLSAgICAgICAgZG91YmxlIHogPSAoYVsw XSAqIGJbMV0pIC0gKGFbMV0gKiBiWzBdKTsKLSAgICAgICAgbV92ZWN0b3JbMF0gPSB4OwotICAg ICAgICBtX3ZlY3RvclsxXSA9IHk7Ci0gICAgICAgIG1fdmVjdG9yWzJdID0gejsKLSAgICB9Ci0K LSAgICAvLyBDb252ZW5pZW5jZSByb3V0aW5lIHdoaWNoIHJldHVybnMgdGhlIHJlc3VsdCBvZiAi dGhpcyBjcm9zcyB2IgotICAgIC8vIGFzIGEgbmV3IFZlY3RvcjMuCi0gICAgVmVjdG9yMyBjcm9z cyhjb25zdCBWZWN0b3IzJiB2KSBjb25zdAotICAgIHsKLSAgICAgICAgVmVjdG9yMyByZXN1bHQ7 Ci0gICAgICAgIHJlc3VsdC5jcm9zcygqdGhpcywgdik7Ci0gICAgICAgIHJldHVybiByZXN1bHQ7 Ci0gICAgfQotCi1wcml2YXRlOgotICAgIGRvdWJsZSBtX3ZlY3RvclszXTsKLX07Ci0KIGNsYXNz IFRyYW5zZm9ybWF0aW9uTWF0cml4IDogcHVibGljIEZhc3RBbGxvY0Jhc2UgewogcHVibGljOgog ICAgIHR5cGVkZWYgZG91YmxlIE1hdHJpeDRbNF1bNF07Cg==