72294 2011-11-14 11:47:36 -0800 Add contains() test to Region 2012-02-06 18:56:00 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 77592 0 danakj danakj andersca backer enne jamesr piman simon.fraser webkit.review.bot wjmaclean oldest_to_newest 502143 0 danakj 2011-11-14 11:47:36 -0800 This adds an occludes(const IntRect&) method to the Region class which tests if the Region fully occludes a given query rectangle. This code will be used by methods to determine opaque GraphicsLayers from the sum of their RenderObjects. 502147 1 danakj 2011-11-14 11:49:39 -0800 Includes a unit test to verify its functionality. 502152 2 114998 danakj 2011-11-14 11:55:01 -0800 Created attachment 114998 Patch 502175 3 114998 webkit-ews 2011-11-14 12:21:23 -0800 Comment on attachment 114998 Patch Attachment 114998 did not pass qt-ews (qt): Output: http://queues.webkit.org/results/10487012 502197 4 115009 danakj 2011-11-14 12:35:52 -0800 Created attachment 115009 make inner loop look like outer loop, work around qt warnings 502305 5 andersca 2011-11-14 14:24:56 -0800 Can't this be implemented in terms of the already existing region operators? 502351 6 danakj 2011-11-14 15:05:19 -0800 It is an intersection, but 1) As I understand it, you are not guaranteed to get back just a single rect if it is fully covered, so you would need a similar check of the resulting intersection. 2) It would require building a new Region which would mean a lot of memory allocation, and thus time, to . 502352 7 danakj 2011-11-14 15:05:48 -0800 misclick.. "... to compute." 502394 8 andersca 2011-11-14 15:40:25 -0800 (In reply to comment #7) > misclick.. > > "... to compute." That could be easily fixed by making the segment and span vectors have an inline capacity - then it'd just be stack allocation: // FIXME: These vectors should have inline sizes. Figure out a good optimal value. Vector<int> m_segments; Vector<Span> m_spans; 502412 9 danakj 2011-11-14 15:55:19 -0800 (In reply to comment #8) > (In reply to comment #7) > > misclick.. > > > > "... to compute." > > That could be easily fixed by making the segment and span vectors have an inline capacity - then it'd just be stack allocation: > > > // FIXME: These vectors should have inline sizes. Figure out a good optimal value. > Vector<int> m_segments; > Vector<Span> m_spans; From reading the code I don't see what you are suggesting. But please correct me where I am wrong.. If a Vector is given a size, then it will call VectorBufferBase::allocateBuffer() which calls fastMalloc() which calls malloc(). Where is there a stack allocation? Regarding point 1), I see nothing in Region::Shape::shapeOperation() that guarantees a single rect output for the intersection in the occludes() == true case. It simply adds segments as it goes along, there is nothing more global to consider pruning/combining segments/spans there. So, as I see it, the same test done in occludes() would need to be done on the result of the intersection() - the only change would be knowing that all segments intersect the query rect. 502433 10 andersca 2011-11-14 16:16:58 -0800 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > misclick.. > > > > > > "... to compute." > > > > That could be easily fixed by making the segment and span vectors have an inline capacity - then it'd just be stack allocation: > > > > > > // FIXME: These vectors should have inline sizes. Figure out a good optimal value. > > Vector<int> m_segments; > > Vector<Span> m_spans; > > From reading the code I don't see what you are suggesting. But please correct me where I am wrong.. If a Vector is given a size, then it will call VectorBufferBase::allocateBuffer() which calls fastMalloc() which calls malloc(). Where is there a stack allocation? You can give Vector an inline size, like so: Vector<int, 16> m_segments; and unless the size of the vector is greater than 16 elements, everything will be allocated as part of the Vector (which is part of the Region). > > Regarding point 1), I see nothing in Region::Shape::shapeOperation() that guarantees a single rect output for the intersection in the occludes() == true case. It simply adds segments as it goes along, there is nothing more global to consider pruning/combining segments/spans there. So, as I see it, the same test done in occludes() would need to be done on the result of the intersection() - the only change would be knowing that all segments intersect the query rect. Region::Shape::canCoalesce has the logic for coalescing segments - but I think there's an even simpler way to do this. Also, instead of occludes - let's call the function 'contains', because that's a more logical name. I think contains can be implemented like this: bool Region::contains(const Region& region) { Region result = intersect(*this, region); return result == region; } Which is much cleaner and reuses the already existing region operations. The region code is pretty complex as-is; let's not add more complexity to it if we can avoid it. 502476 11 115062 danakj 2011-11-14 16:54:30 -0800 Created attachment 115062 Patch 502484 12 danakj 2011-11-14 16:59:50 -0800 (In reply to comment #10) > (In reply to comment #9) > > (In reply to comment #8) > > > (In reply to comment #7) > > > > misclick.. > > > > > > > > "... to compute." > > > > > > That could be easily fixed by making the segment and span vectors have an inline capacity - then it'd just be stack allocation: > > > > > > > > > // FIXME: These vectors should have inline sizes. Figure out a good optimal value. > > > Vector<int> m_segments; > > > Vector<Span> m_spans; > > > > From reading the code I don't see what you are suggesting. But please correct me where I am wrong.. If a Vector is given a size, then it will call VectorBufferBase::allocateBuffer() which calls fastMalloc() which calls malloc(). Where is there a stack allocation? > > You can give Vector an inline size, like so: > > Vector<int, 16> m_segments; > > and unless the size of the vector is greater than 16 elements, everything will be allocated as part of the Vector (which is part of the Region). Okay, I see the inlineBuffer. I have to admit I don't like increasing the size of all Region objects, when walking the segments is sufficient. I expect Regions have very different use cases hence the lack of this magic inline size value. It's something we can consider, but see below regarding operator==. > > > > Regarding point 1), I see nothing in Region::Shape::shapeOperation() that guarantees a single rect output for the intersection in the occludes() == true case. It simply adds segments as it goes along, there is nothing more global to consider pruning/combining segments/spans there. So, as I see it, the same test done in occludes() would need to be done on the result of the intersection() - the only change would be knowing that all segments intersect the query rect. > > Region::Shape::canCoalesce has the logic for coalescing segments - but I think there's an even simpler way to do this. > > Also, instead of occludes - let's call the function 'contains', because that's a more logical name. I think contains can be implemented like this: > > bool Region::contains(const Region& region) > { > Region result = intersect(*this, region); > > return result == region; Region::Shape::canCoalesce() enables some simple compression, to merge adjacent spans that have exactly the same segments. There is no reason to believe that this will be the output of an intersection of an arbitrary region with a rectangle, though. In the contains() == true case, it will be a set of spans, where for each span, the union of segments within start at the query rect's left edge and end at its right edge. The same walk of the intersection must be done. I also definitely don't want to make this more complex than it needs to be, but: 1) I don't see the ability to do this operator== comparison at the moment. 2) While I can implement the current contains() as operator==(), it will be slower than just doing a single walk (at least two, with possible mallocs/frees). 3) The operator==() method will be /more/ complex than the current contains() code. It has to do a symmetric comparison rather than just testing one covering the other. > } > > Which is much cleaner and reuses the already existing region operations. The region code is pretty complex as-is; let's not add more complexity to it if we can avoid it. The Region::Shape code is somewhat complex but well structured to match its citation cleanly, so I put this function in the Region class instead to separate it from the Region::Shape implementation. The walk for Region::contains() is quite similar to Region::rects(), but simply looks for gaps between segments or spans that intersect with the query rectangle. I think it can be a little more clear, and I had some unneeded variables left over from a previous implementation, so I will resubmit it. From what I see, doing operator== will make for both a more complex and costly solution, will it not? 502485 13 115062 andersca 2011-11-14 17:03:06 -0800 Comment on attachment 115062 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115062&action=review This is looking better, but there are still two major problems with this: 1. You should just make Region::contains take another Region - There's a Region constructor that takes a rect. 2. Please implement contains in terms of intersects() instead of writing 60 lines of code. Like I said, the region code is very complex and we should re-use the already existing region operations (union, intersection and subtraction). I'd give m_segments an inline size of 32 and m_spans a size of 16 - that should cover most types of regions. Thanks for working on this! > Source/WebCore/platform/graphics/Region.h:44 > + // Returns true if the rect is contained fully in the areas covered by the Region. > + bool contains(const IntRect&) const; Please add a newline here. > Source/WebKit/chromium/tests/RegionContainsTest.cpp:31 > +#include "Region.h" > + Extra newlines. 502495 14 mrowe 2011-11-14 17:06:46 -0800 Is there some reason why you’re adding a Chromium-specific unit test rather than to the cross-platform unit testing harness? 502512 15 danakj 2011-11-14 17:14:58 -0800 (In reply to comment #14) > Is there some reason why you’re adding a Chromium-specific unit test rather than to the cross-platform unit testing harness? Only because I understood there is no cross-platform unit testing. Eg. https://lists.webkit.org/pipermail/webkit-dev/2011-April/016510.html Where should I be looking for said harness? 502525 16 mrowe 2011-11-14 17:26:47 -0800 Tools/TestWebKitAPI contains a harness that is used on Mac, Windows and Chromium. It doesn’t yet test any WebCore functionality, but it tests WTF, WebKit, and WebKit2 so should be easily extended to work with WebCore too. 502536 17 andersca 2011-11-14 17:33:31 -0800 (In reply to comment #12) > (In reply to comment #10) > > (In reply to comment #9) > > > (In reply to comment #8) > > > > (In reply to comment #7) > > > > > misclick.. > > > > > > > > > > "... to compute." > > > > > > > > That could be easily fixed by making the segment and span vectors have an inline capacity - then it'd just be stack allocation: > > > > > > > > > > > > // FIXME: These vectors should have inline sizes. Figure out a good optimal value. > > > > Vector<int> m_segments; > > > > Vector<Span> m_spans; > > > > > > From reading the code I don't see what you are suggesting. But please correct me where I am wrong.. If a Vector is given a size, then it will call VectorBufferBase::allocateBuffer() which calls fastMalloc() which calls malloc(). Where is there a stack allocation? > > > > You can give Vector an inline size, like so: > > > > Vector<int, 16> m_segments; > > > > and unless the size of the vector is greater than 16 elements, everything will be allocated as part of the Vector (which is part of the Region). > > Okay, I see the inlineBuffer. I have to admit I don't like increasing the size of all Region objects, when walking the segments is sufficient. I expect Regions have very different use cases hence the lack of this magic inline size value. It's something we can consider, but see below regarding operator==. > I think it's fine to increase the size of Region if it can avoid malloc traffic - Especially since regions are commonly stack-allocated. > > > > > > Regarding point 1), I see nothing in Region::Shape::shapeOperation() that guarantees a single rect output for the intersection in the occludes() == true case. It simply adds segments as it goes along, there is nothing more global to consider pruning/combining segments/spans there. So, as I see it, the same test done in occludes() would need to be done on the result of the intersection() - the only change would be knowing that all segments intersect the query rect. > > > > Region::Shape::canCoalesce has the logic for coalescing segments - but I think there's an even simpler way to do this. > > > > Also, instead of occludes - let's call the function 'contains', because that's a more logical name. I think contains can be implemented like this: > > > > bool Region::contains(const Region& region) > > { > > Region result = intersect(*this, region); > > > > return result == region; > > Region::Shape::canCoalesce() enables some simple compression, to merge adjacent spans that have exactly the same segments. There is no reason to believe that this will be the output of an intersection of an arbitrary region with a rectangle, though. In the contains() == true case, it will be a set of spans, where for each span, the union of segments within start at the query rect's left edge and end at its right edge. The same walk of the intersection must be done. > > I also definitely don't want to make this more complex than it needs to be, but: > > 1) I don't see the ability to do this operator== comparison at the moment. > 2) While I can implement the current contains() as operator==(), it will be slower than just doing a single walk (at least two, with possible mallocs/frees). 3) The operator==() method will be /more/ complex than the current contains() code. It has to do a symmetric comparison rather than just testing one covering the other. > If two regions are equal, they will have exactly the same segments and spans, so checking for equality is as simple as a memcmp. If you can find a case where this isn't true, please file a separate bug about that. > > } > > > > Which is much cleaner and reuses the already existing region operations. The region code is pretty complex as-is; let's not add more complexity to it if we can avoid it. > > The Region::Shape code is somewhat complex but well structured to match its citation cleanly, so I put this function in the Region class instead to separate it from the Region::Shape implementation. > > The walk for Region::contains() is quite similar to Region::rects(), but simply looks for gaps between segments or spans that intersect with the query rectangle. I think it can be a little more clear, and I had some unneeded variables left over from a previous implementation, so I will resubmit it. > > From what I see, doing operator== will make for both a more complex and costly solution, will it not? See my comment above. 502896 18 danakj 2011-11-15 07:35:19 -0800 (In reply to comment #17) > (In reply to comment #12) > > 1) I don't see the ability to do this operator== comparison at the moment. > > 2) While I can implement the current contains() as operator==(), it will be slower than just doing a single walk (at least two, with possible mallocs/frees). 3) The operator==() method will be /more/ complex than the current contains() code. It has to do a symmetric comparison rather than just testing one covering the other. > > > > If two regions are equal, they will have exactly the same segments and spans, so checking for equality is as simple as a memcmp. If you can find a case where this isn't true, please file a separate bug about that. We've been coming at this with different assumptions, mine being that the resulting intersecting region would not always have a single rect as its output if contains() was true. It seems however that it does, so doing a simple operator== test should be feasable. 502943 19 115172 danakj 2011-11-15 08:55:48 -0800 Created attachment 115172 Patch 502944 20 danakj 2011-11-15 08:56:27 -0800 Uses intersection and operator== to test contains. 502997 21 115172 andersca 2011-11-15 09:54:23 -0800 Comment on attachment 115172 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115172&action=review This is looking much better! It looks like it will break the Windows build though. > Source/WebCore/platform/graphics/Region.cpp:72 > + Region test(subset); > + test.intersect(*this); > + return test == subset; I think this can be written more as: return intersect(*this, subset) == subset; (And I'd rename subset to region). > Source/WebCore/platform/graphics/Region.cpp:103 > + Shape a = m_shape; > + Shape b = other.m_shape; > + > + Shape::SpanIterator aSpan = a.spans_begin(); > + Shape::SpanIterator bSpan = b.spans_begin(); > + const Shape::SpanIterator aSpanEnd = a.spans_end(); > + const Shape::SpanIterator bSpanEnd = b.spans_end(); > + > + if (aSpanEnd - aSpan != bSpanEnd - bSpan) // Test for equal number of spans > + return false; > + > + for (; aSpan != aSpanEnd; ++aSpan, ++bSpan) { > + if (aSpan->y != bSpan->y) // Test if spans are at same position > + return false; > + > + Shape::SegmentIterator aSegment = a.segments_begin(aSpan); > + Shape::SegmentIterator bSegment = b.segments_begin(bSpan); > + const Shape::SegmentIterator aSegmentEnd = a.segments_end(aSpan); > + const Shape::SegmentIterator bSegmentEnd = b.segments_end(bSpan); > + > + if (aSegmentEnd - aSegment != bSegmentEnd - bSegment) // Test for equal number of segments > + return false; > + if (!std::equal(aSegment, aSegmentEnd, bSegment)) // Test if segments are at same positions > + return false; > + } > + > + return true; If you write an operator== for Shape, I think this can become much simpler. 503045 22 115199 danakj 2011-11-15 10:45:05 -0800 Created attachment 115199 Patch 503046 23 danakj 2011-11-15 10:46:44 -0800 Hopefully this fixes the Windows build for the unit test. Moved Region::operator== to Region::Shape::operator==. You were right as this lets us just run through the m_spans and m_segments vectors directly. 503113 24 115212 danakj 2011-11-15 11:49:58 -0800 Created attachment 115212 Patch 503227 25 115212 darin 2011-11-15 13:52:03 -0800 Comment on attachment 115212 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115212&action=review > Source/WebCore/platform/graphics/Region.cpp:87 > + if (m_spans.size() != other.m_spans.size()) > + return false; > + if (m_segments.size() != other.m_segments.size()) > + return false; > + > + for (size_t i = 0; i < m_spans.size(); ++i) > + if (m_spans[i] != other.m_spans[i]) > + return false; > + for (size_t i = 0; i < m_segments.size(); ++i) > + if (m_segments[i] != other.m_segments[i]) > + return false; > + > + return true; Vector already handles ==. You should be able to write: return m_spans == other.m_spans && m_segments == other.m_segments; If you can’t, that’s a bug in Vector. 503229 26 115212 darin 2011-11-15 13:53:03 -0800 Comment on attachment 115212 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115212&action=review > Source/WebCore/platform/graphics/Region.h:67 > + inline bool operator!=(const Span& other) { return y != other.y || segmentIndex != other.segmentIndex; } As a matter of style we almost always implement either neither or both of == and != and implement != by calling ==. > Source/WebCore/platform/graphics/Region.h:93 > + bool operator==(const Shape& other); Ditto. 503235 27 andersca 2011-11-15 13:58:18 -0800 (In reply to comment #26) > (From update of attachment 115212 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=115212&action=review > > > Source/WebCore/platform/graphics/Region.h:67 > > + inline bool operator!=(const Span& other) { return y != other.y || segmentIndex != other.segmentIndex; } > > As a matter of style we almost always implement either neither or both of == and != and implement != by calling ==. > > > Source/WebCore/platform/graphics/Region.h:93 > > + bool operator==(const Shape& other); > > Ditto. I also prefer the operators to be free friend functions of Region. Something like class Region { ... friend bool operator==(const Region& a, const Region& b) { return a.m_spans == b.m_spans && a.m_segments == b.m_segments); } }: 504038 28 115406 danakj 2011-11-16 10:40:19 -0800 Created attachment 115406 Patch 504044 29 115406 darin 2011-11-16 10:45:12 -0800 Comment on attachment 115406 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115406&action=review > Source/WebCore/platform/graphics/Region.h:51 > + bool contains(const Region&) const { return WebCore::intersect(region, *this).m_shape == region.m_shape; } This won’t compile because the argument name, region, was omitted. > Source/WebCore/platform/graphics/Region.h:114 > + friend bool operator!=(const Shape&, const Shape&); I don’t think != needs to be a friend. 504052 30 danakj 2011-11-16 10:54:34 -0800 (In reply to comment #29) > (From update of attachment 115406 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=115406&action=review > > > Source/WebCore/platform/graphics/Region.h:51 > > + bool contains(const Region&) const { return WebCore::intersect(region, *this).m_shape == region.m_shape; } > > This won’t compile because the argument name, region, was omitted. Oh sorry, moved things last second. > > Source/WebCore/platform/graphics/Region.h:114 > > + friend bool operator!=(const Shape&, const Shape&); > > I don’t think != needs to be a friend. It does because Region::Shape is private, it won't compile otherwise. 504060 31 115410 danakj 2011-11-16 11:02:34 -0800 Created attachment 115410 Patch 505801 32 115812 danakj 2011-11-18 08:14:58 -0800 Created attachment 115812 Patch 505802 33 danakj 2011-11-18 08:15:36 -0800 (In reply to comment #30) > > > Source/WebCore/platform/graphics/Region.h:114 > > > + friend bool operator!=(const Shape&, const Shape&); > > > > I don’t think != needs to be a friend. > > It does because Region::Shape is private, it won't compile otherwise. Sorry, it occured to me you were referring to the friend declaration inside of Shape, and you're right. Uploading a patch with this change. Is there anything else blocking this patch? Thanks! 505818 34 115818 danakj 2011-11-18 08:39:12 -0800 Created attachment 115818 fixed ChangeLog 546198 35 124767 danakj 2012-01-31 10:19:23 -0800 Created attachment 124767 Patch rebased and removed the != operators as they are no longer needed, and not exposed externally. 546204 36 webkit.review.bot 2012-01-31 10:22:45 -0800 Attachment 124767 did not pass style-queue: Failed to run "['Tools/Scripts/update-webkit']" exit_code: 9 Updating OpenSource From git://git.webkit.org/WebKit 11be23e..9fc4aeb master -> origin/master Partial-rebuilding .git/svn/refs/remotes/origin/master/.rev_map.268f45cc-cd09-0410-ab3c-d52691b4dbfc ... Currently at 106366 = 11be23e25c7011a2675e260f91a1b3cbfa7052f9 r106368 = 9fc4aeb5a25445667675b8be04139afe13128677 Done rebuilding .git/svn/refs/remotes/origin/master/.rev_map.268f45cc-cd09-0410-ab3c-d52691b4dbfc First, rewinding head to replay your work on top of it... Applying: Fix compilation errors on build-webkit --debug --no-workers on mac. Using index info to reconstruct a base tree... Falling back to patching base and 3-way merge... Auto-merging LayoutTests/ChangeLog CONFLICT (content): Merge conflict in LayoutTests/ChangeLog Auto-merging LayoutTests/platform/qt/Skipped CONFLICT (content): Merge conflict in LayoutTests/platform/qt/Skipped Auto-merging Source/WebCore/ChangeLog CONFLICT (content): Merge conflict in Source/WebCore/ChangeLog Failed to merge in the changes. Patch failed at 0001 Fix compilation errors on build-webkit --debug --no-workers on mac. When you have resolved this problem run "git rebase --continue". If you would prefer to skip this patch, instead run "git rebase --skip". To restore the original branch and stop rebasing run "git rebase --abort". rebase refs/remotes/origin/master: command returned error: 1 Died at Tools/Scripts/update-webkit line 164. If any of these errors are false positives, please file a bug against check-webkit-style. 546484 37 124767 andersca 2012-01-31 14:11:00 -0800 Comment on attachment 124767 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=124767&action=review > Source/WebCore/platform/graphics/Region.cpp:70 > + return WebCore::intersect(region, *this).m_shape == region.m_shape; If you want to, you can add a Region::operator== that checks the bounds rect as well as the shape - that might be useful for other purposes as well. > Source/WebCore/platform/graphics/Region.h:149 > +inline bool operator==(const Region::Span& a, const Region::Span& b) { return a.y == b.y && a.segmentIndex == b.segmentIndex; } > +inline bool operator==(const Region::Shape& a, const Region::Shape& b) { return a.m_spans == b.m_spans && a.m_segments == b.m_segments; } > + According to our style guidelines, the { should be on a new line. 546500 38 124822 danakj 2012-01-31 14:29:21 -0800 Created attachment 124822 Patch comments addressed. added an operator== for Region with early-out check on the bounds, and using that for contains() 546569 39 124822 webkit.review.bot 2012-01-31 15:36:22 -0800 Comment on attachment 124822 Patch Clearing flags on attachment: 124822 Committed r106408: <http://trac.webkit.org/changeset/106408> 546570 40 webkit.review.bot 2012-01-31 15:36:28 -0800 All reviewed patches have been landed. Closing bug. 547566 41 danakj 2012-02-01 18:38:42 -0800 looks like the inline sizes break Vector and it tries to free the memory on the stack. https://bugs.webkit.org/show_bug.cgi?id=77592 550215 42 125695 danakj 2012-02-06 12:56:33 -0800 Created attachment 125695 Patch I verified on a mac that giving an inline size to the Vector in Region::Shape::shapeOperation makes the stack free() problem go away. Attached is new patch with that fix. I am not sure what the correct state for the bug should be now. 550336 43 125714 danakj 2012-02-06 15:16:01 -0800 Created attachment 125714 Patch for landing 550357 44 danakj 2012-02-06 15:34:25 -0800 unresolving for CQ 550358 45 125714 webkit.review.bot 2012-02-06 15:34:41 -0800 Comment on attachment 125714 Patch for landing Rejecting attachment 125714 from commit-queue. danakj@chromium.org does not have committer permissions according to http://trac.webkit.org/browser/trunk/Tools/Scripts/webkitpy/common/config/committers.py. - If you do not have committer rights please read http://webkit.org/coding/contributing.html for instructions on how to use bugzilla flags. - If you have committer rights please correct the error in Tools/Scripts/webkitpy/common/config/committers.py by adding yourself to the file (no review needed). The commit-queue restarts itself every 2 hours. After restart the commit-queue will correctly respect your committer rights. 550531 46 125714 webkit.review.bot 2012-02-06 18:55:41 -0800 Comment on attachment 125714 Patch for landing Clearing flags on attachment: 125714 Committed r106893: <http://trac.webkit.org/changeset/106893> 550532 47 webkit.review.bot 2012-02-06 18:56:00 -0800 All reviewed patches have been landed. Closing bug. 114998 2011-11-14 11:55:01 -0800 2011-11-14 12:35:45 -0800 Patch bug-72294-20111114145459.patch text/plain 10948 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uNTA5OTE4NTU2M2VkODgxZDcyZjM0OTQ3MmE2MDY3 MTMzMzY3MjBiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTExLTE0ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBvY2NsdWRlcygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZHMgY2hyb21pdW0gdW5pdCB0ZXN0IGZvciB0aGUgb2NjbHVkZXMoKSBtZXRob2Qu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmVnaW9uOjpvY2NsdWRlcyk6IFJldHVybnMgdHJ1ZSBpZiB0aGUgUmVnaW9uIGZ1bGx5 IGNvdmVycyB0aGUgZ2l2ZW4gcXVlcnkgUmVjdC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy9SZWdpb24uaDoKKwogMjAxMS0xMS0xMSAgTmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgU2luY2UgR3JhcGhpY3NDb250ZXh0M0Q6Om1ha2VDb250ZXh0Q3VycmVudCBj YW4gZmFpbCwgcmV0dXJuIGJvb2wuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDMyMjJm NzRmNTE3MmY0OTY2M2RmMzYzY2EyZTA3ZTFjMzY2NjMwZjguLjdiZTRjODE1YjVlNDlhM2RjYTky ODczNzEwNjI3YzY1NzQ1OTZiZDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTUgQEAKKzIwMTEtMTEtMTQgIERhbmEgSmFuc2VucyAgPGRhbmFrakBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgQWRkIG9jY2x1ZGVzKCkgdGVzdCB0byBSZWdpb24KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcyMjk0CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJLaXQuZ3lwaToKKyAgICAgICAg KiB0ZXN0cy9SZWdpb25PY2NsdWRlc1Rlc3QuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OnF1ZXJ5KToKKyAgICAgICAgKFdlYkNvcmU6OlRFU1QpOgorCiAyMDExLTExLTExICBOYXQgRHVj YSAgPG5kdWNhQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTaW5jZSBHcmFwaGljc0NvbnRleHQz RDo6bWFrZUNvbnRleHRDdXJyZW50IGNhbiBmYWlsLCByZXR1cm4gYm9vbC4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0MjdjNmM5MWQyMTYwZWI3 N2U4Mjc4N2FiMDlhZWY0MjFkNjYxMjcuLjViZWIzZmRlMzA2ZDJmNGY4ZTRjMWQ5MGUyNWJkMzNh N2Q0OTRlZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Jl Z2lvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNw cApAQCAtNjUsNiArNjUsNzcgQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6cmVjdHMoKSBjb25z dAogICAgIHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246Om9jY2x1ZGVzKGNvbnN0IElu dFJlY3QmIGNvdmVyUmVjdCkgY29uc3QKK3sKKyAgICBib29sIG9jY2x1ZGVzID0gdHJ1ZTsKKwor ICAgIGJvb2wgeUludGVyc2VjdHMgPSBmYWxzZTsKKyAgICBpbnQgeVVuaW9uU3RhcnQsIHlVbmlv bkVuZDsKKworICAgIGZvciAoU2hhcGU6OlNwYW5JdGVyYXRvciBzcGFuID0gbV9zaGFwZS5zcGFu c19iZWdpbigpLCBlbmQgPSBtX3NoYXBlLnNwYW5zX2VuZCgpOyBzcGFuICE9IGVuZCAmJiBzcGFu ICsgMSAhPSBlbmQ7ICsrc3BhbikgeworICAgICAgICBpbnQgeSA9IHNwYW4tPnk7CisgICAgICAg IGludCBtYXhZID0gKHNwYW4gKyAxKS0+eTsKKworICAgICAgICBpZiAoeSA+PSBjb3ZlclJlY3Qu bWF4WSgpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGlmIChtYXhZIDw9IGNvdmVyUmVj dC55KCkpCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgaWYgKCF5SW50ZXJzZWN0cykg eworICAgICAgICAgICAgaWYgKHkgPiBjb3ZlclJlY3QueSgpKQorICAgICAgICAgICAgICAgIG9j Y2x1ZGVzID0gZmFsc2U7CisgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgICAgICB5SW50 ZXJzZWN0cyA9IHRydWU7CisgICAgICAgICAgICAgICAgeVVuaW9uU3RhcnQgPSB5OworICAgICAg ICAgICAgICAgIHlVbmlvbkVuZCA9IG1heFk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICBpZiAoeSA+IHlVbmlvbkVuZCkKKyAgICAgICAgICAgICAgICBvY2Ns dWRlcyA9IGZhbHNlOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHlVbmlvbkVu ZCA9IG1heFk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKCFvY2NsdWRlcykKKyAgICAgICAgICAg IGJyZWFrOworCisgICAgICAgIGJvb2wgeEludGVyc2VjdHMgPSBmYWxzZTsKKyAgICAgICAgaW50 IHhVbmlvblN0YXJ0LCB4VW5pb25FbmQ7CisKKyAgICAgICAgZm9yIChTaGFwZTo6U2VnbWVudEl0 ZXJhdG9yIHNlZ21lbnQgPSBtX3NoYXBlLnNlZ21lbnRzX2JlZ2luKHNwYW4pLCBlbmQgPSBtX3No YXBlLnNlZ21lbnRzX2VuZChzcGFuKTsgc2VnbWVudCAhPSBlbmQgJiYgc2VnbWVudCArIDEgIT0g ZW5kOyBzZWdtZW50ICs9IDIpIHsKKyAgICAgICAgICAgIGludCB4ID0gKnNlZ21lbnQ7CisgICAg ICAgICAgICBpbnQgbWF4WCA9ICooc2VnbWVudCArIDEpOworCisgICAgICAgICAgICBpZiAoeCA8 IGNvdmVyUmVjdC5tYXhYKCkgJiYgbWF4WCA+IGNvdmVyUmVjdC54KCkpIHsKKyAgICAgICAgICAg ICAgICBpZiAoIXhJbnRlcnNlY3RzKSB7CisgICAgICAgICAgICAgICAgICAgIGlmICh4ID4gY292 ZXJSZWN0LngoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIG9jY2x1ZGVzID0gZmFsc2U7Cisg ICAgICAgICAgICAgICAgICAgIGVsc2UgeworICAgICAgICAgICAgICAgICAgICAgICAgeEludGVy c2VjdHMgPSB0cnVlOworICAgICAgICAgICAgICAgICAgICAgICAgeFVuaW9uU3RhcnQgPSB4Owor ICAgICAgICAgICAgICAgICAgICAgICAgeFVuaW9uRW5kID0gbWF4WDsKKyAgICAgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAgIGlm ICh4ID4geFVuaW9uRW5kKQorICAgICAgICAgICAgICAgICAgICAgICAgb2NjbHVkZXMgPSBmYWxz ZTsKKyAgICAgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgICAgeFVu aW9uRW5kID0gbWF4WDsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAg ICAgICBpZiAoIW9jY2x1ZGVzKQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisK KyAgICAgICAgaWYgKCF4SW50ZXJzZWN0cyB8fCB4VW5pb25FbmQgPCBjb3ZlclJlY3QubWF4WCgp KQorICAgICAgICAgICAgb2NjbHVkZXMgPSBmYWxzZTsKKyAgICAgICAgaWYgKCFvY2NsdWRlcykK KyAgICAgICAgICAgIGJyZWFrOworICAgIH0KKworICAgIGlmICgheUludGVyc2VjdHMgfHwgeVVu aW9uRW5kIDwgY292ZXJSZWN0Lm1heFkoKSkKKyAgICAgICAgb2NjbHVkZXMgPSBmYWxzZTsKKwor ICAgIHJldHVybiBvY2NsdWRlczsKK30KKwogUmVnaW9uOjpTaGFwZTo6U2hhcGUoKQogewogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAppbmRleCBiNTM1OWJiZTM5 YzAyNWMzZTJjNWU1NWIzOWZhNGE1NzU3ZDc5NzVmLi41YzlmYWRmMmRlYzNiZjI4ZGFjMTU0NjU4 YTZjODJkN2QwYzI4YmY4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9SZWdpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdp b24uaApAQCAtNDAsNiArNDAsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBpc0VtcHR5KCkgY29uc3Qg eyByZXR1cm4gbV9ib3VuZHMuaXNFbXB0eSgpOyB9CiAKICAgICBWZWN0b3I8SW50UmVjdD4gcmVj dHMoKSBjb25zdDsKKyAgICBib29sIG9jY2x1ZGVzKGNvbnN0IEludFJlY3QmKSBjb25zdDsKIAog ICAgIHZvaWQgdW5pdGUoY29uc3QgUmVnaW9uJik7CiAgICAgdm9pZCBpbnRlcnNlY3QoY29uc3Qg UmVnaW9uJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXBp IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwaQppbmRleCA2MDkzMjY2Yjk0YTFj MjdmNWQwMjc1MTA4MWY1ZWE4MDY4MGIxMjA5Li43YjA3NjVhNzFmMzU2YjdlNmM1OTI5Nzc5YTU2 MDA5N2E2NTE3MmIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5n eXBpCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cGkKQEAgLTgxLDYgKzgx LDcgQEAKICAgICAgICAgICAgICd0ZXN0cy9QT0RJbnRlcnZhbFRyZWVUZXN0LmNwcCcsCiAgICAg ICAgICAgICAndGVzdHMvUE9EUmVkQmxhY2tUcmVlVGVzdC5jcHAnLAogICAgICAgICAgICAgJ3Rl c3RzL1JlbmRlclRhYmxlQ2VsbFRlc3QuY3BwJywKKyAgICAgICAgICAgICd0ZXN0cy9SZWdpb25P Y2NsdWRlc1Rlc3QuY3BwJywKICAgICAgICAgICAgICd0ZXN0cy9UaWxpbmdEYXRhVGVzdC5jcHAn LAogICAgICAgICAgICAgJ3Rlc3RzL1RyZWVTeW5jaHJvbml6ZXJUZXN0LmNwcCcsCiAgICAgICAg ICAgICAndGVzdHMvVHJlZVRlc3RIZWxwZXJzLmNwcCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3Rlc3RzL1JlZ2lvbk9jY2x1ZGVzVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL1JlZ2lvbk9jY2x1ZGVzVGVzdC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTA4YTEy ZWJmYzY3MDgwM2FmMzNhYTVmYTE4NzVmZTAyNzFkZTNlNQotLS0gL2Rldi9udWxsCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvUmVnaW9uT2NjbHVkZXNUZXN0LmNwcApAQCAtMCww ICsxLDEzMyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0 OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisg KiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z CisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBP RiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisg KiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKy8vIFRlc3RzIGZvciB0aGUgaW50ZWdlciByZWN0IGVkZ2VzIGNs YXNzLgorCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJSZWdpb24uaCIKKworI2lu Y2x1ZGUgIkludFJlY3QuaCIKKyNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVkZSA8Z3Rlc3Qv Z3Rlc3QuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdl YkNvcmUgeworCitpbmxpbmUgYm9vbCBxdWVyeShjb25zdCBWZWN0b3I8SW50UmVjdD4mIHJlY3Rz LCBjb25zdCBJbnRSZWN0JiBjb3ZlclJlY3QpCit7CisgICAgUmVnaW9uIHJlZ2lvbjsKKyAgICBm b3IgKHNpemVfdCBpID0gMDsgaSA8IHJlY3RzLnNpemUoKTsgKytpKQorICAgICAgICByZWdpb24u dW5pdGUocmVjdHNbaV0pOworCisgICAgcmV0dXJuIHJlZ2lvbi5vY2NsdWRlcyhjb3ZlclJlY3Qp OworfQorCitURVNUKFJlZ2lvbk9jY2x1ZGVzVGVzdCwgVGVzdE5vSW50ZXJzZWN0aW9uKQorewor ICAgIFZlY3RvcjxJbnRSZWN0PiByZWN0czsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAw LCAxMDAsIDEwMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDEwMCwgMjAwLCAxMDAsIDEw MCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMTAwLCAwLCAx MCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAx MDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0 KDExMCwgMTEwLCAxMCwgMTApKSk7Cit9CisKK1RFU1QoUmVnaW9uT2NjbHVkZXNUZXN0LCBUZXN0 Tm9Db3ZlcikKK3sKKyAgICBWZWN0b3I8SW50UmVjdD4gcmVjdHM7CisgICAgcmVjdHMuYXBwZW5k KEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMTEs IDEwLCAxMCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwg MCwgMTAsIDIwKSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJl Y3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMTEsIDAsIDEwLCAx MCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMjAs IDEwKSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwg MCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMSwgMSwgMTAsIDEwKSk7Cisg ICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMSwgMTEpKSk7 CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwg MTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAxLCAxMCwgMTApKTsKKyAgICBFWFBF Q1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDExLCAxMSkpKTsKKyAgICBy ZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOwor ICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDEsIDAsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUShm YWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTEsIDExKSkpOworICAgIHJlY3RzLmNs ZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVj dHMuYXBwZW5kKEludFJlY3QoMSwgMSwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBx dWVyeShyZWN0cywgSW50UmVjdCgxLCAwLCAxMCwgMSkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2Us IHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDAsIDEwLCAyKSkpOworICAgIEVYUEVDVF9FUSh0cnVl LCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAxLCAxMCwgMikpKTsKKyAgICByZWN0cy5jbGVhcigp OworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDEsIDEsIDEwLCAxMCkpOworICAgIEVYUEVDVF9F UShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTIsIDEyKSkpOworICAgIEVYUEVD VF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTEsIDExKSkpOworICAgIEVY UEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwgMSwgMTEsIDExKSkpOworfQor CitURVNUKFJlZ2lvbk9jY2x1ZGVzVGVzdCwgVGVzdENvdmVyKQoreworICAgIFZlY3RvcjxJbnRS ZWN0PiByZWN0czsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAg ICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTAsIDEwKSkpOwor ICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAxLCA4LCA4KSkpOwor ICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAxLCA5LCA5KSkpOwor ICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCA5LCA5KSkpOwor ICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEw KSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMu YXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3Qo MCwgMCwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0 KDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJl Y3QoMSwgMSwgOCwgOCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJl Y3QoMSwgMSwgOSwgOSkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJl Y3QoMCwgMCwgOSwgOSkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVuZChJ bnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDUsIDUsIDEw LCAxMCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwg MTAsIDE1KSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAw LCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDUs IDUsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0 KDAsIDUsIDE1LCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRS ZWN0KDUsIDAsIDEwLCAxNSkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIElu dFJlY3QoMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMs IEludFJlY3QoNSwgNSwgMTUsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0 cywgSW50UmVjdCg1LCAwLCA1LCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVj dHMsIEludFJlY3QoNSwgMCwgNSwgMTUpKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0 cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVj dCgxMCwgMCwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRS ZWN0KDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIElu dFJlY3QoMCwgMCwgMTUsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywg SW50UmVjdCgwLCAwLCAyMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0 cywgSW50UmVjdCgwLCAwLCAyMCwgMTEpKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShy ZWN0cywgSW50UmVjdCgwLCAwLCAyMSwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5 KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDE4LCA4KSkpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCg== 115009 2011-11-14 12:35:52 -0800 2011-11-14 16:54:22 -0800 make inner loop look like outer loop, work around qt warnings bug-72294-20111114153550.patch text/plain 10961 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uNTA5OTE4NTU2M2VkODgxZDcyZjM0OTQ3MmE2MDY3 MTMzMzY3MjBiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTExLTE0ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBvY2NsdWRlcygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZHMgY2hyb21pdW0gdW5pdCB0ZXN0IGZvciB0aGUgb2NjbHVkZXMoKSBtZXRob2Qu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmVnaW9uOjpvY2NsdWRlcyk6IFJldHVybnMgdHJ1ZSBpZiB0aGUgUmVnaW9uIGZ1bGx5 IGNvdmVycyB0aGUgZ2l2ZW4gcXVlcnkgUmVjdC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy9SZWdpb24uaDoKKwogMjAxMS0xMS0xMSAgTmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgU2luY2UgR3JhcGhpY3NDb250ZXh0M0Q6Om1ha2VDb250ZXh0Q3VycmVudCBj YW4gZmFpbCwgcmV0dXJuIGJvb2wuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDMyMjJm NzRmNTE3MmY0OTY2M2RmMzYzY2EyZTA3ZTFjMzY2NjMwZjguLjdiZTRjODE1YjVlNDlhM2RjYTky ODczNzEwNjI3YzY1NzQ1OTZiZDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTUgQEAKKzIwMTEtMTEtMTQgIERhbmEgSmFuc2VucyAgPGRhbmFrakBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgQWRkIG9jY2x1ZGVzKCkgdGVzdCB0byBSZWdpb24KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcyMjk0CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJLaXQuZ3lwaToKKyAgICAgICAg KiB0ZXN0cy9SZWdpb25PY2NsdWRlc1Rlc3QuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OnF1ZXJ5KToKKyAgICAgICAgKFdlYkNvcmU6OlRFU1QpOgorCiAyMDExLTExLTExICBOYXQgRHVj YSAgPG5kdWNhQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTaW5jZSBHcmFwaGljc0NvbnRleHQz RDo6bWFrZUNvbnRleHRDdXJyZW50IGNhbiBmYWlsLCByZXR1cm4gYm9vbC4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0MjdjNmM5MWQyMTYwZWI3 N2U4Mjc4N2FiMDlhZWY0MjFkNjYxMjcuLmQ5ZWYzOTAyZDc0NDc1Nzg1ODM0NWY1Y2QyNGFjMzk1 MDcyMWQyZGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Jl Z2lvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNw cApAQCAtNjUsNiArNjUsNzkgQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6cmVjdHMoKSBjb25z dAogICAgIHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246Om9jY2x1ZGVzKGNvbnN0IElu dFJlY3QmIGNvdmVyUmVjdCkgY29uc3QKK3sKKyAgICBib29sIG9jY2x1ZGVzID0gdHJ1ZTsKKwor ICAgIGJvb2wgeUludGVyc2VjdHMgPSBmYWxzZTsKKyAgICBpbnQgeVVuaW9uU3RhcnQgPSAwLCB5 VW5pb25FbmQgPSAtMTsKKworICAgIGZvciAoU2hhcGU6OlNwYW5JdGVyYXRvciBzcGFuID0gbV9z aGFwZS5zcGFuc19iZWdpbigpLCBlbmQgPSBtX3NoYXBlLnNwYW5zX2VuZCgpOyBzcGFuICE9IGVu ZCAmJiBzcGFuICsgMSAhPSBlbmQ7ICsrc3BhbikgeworICAgICAgICBpbnQgeSA9IHNwYW4tPnk7 CisgICAgICAgIGludCBtYXhZID0gKHNwYW4gKyAxKS0+eTsKKworICAgICAgICBpZiAoeSA+PSBj b3ZlclJlY3QubWF4WSgpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGlmIChtYXhZIDw9 IGNvdmVyUmVjdC55KCkpCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgaWYgKCF5SW50 ZXJzZWN0cykgeworICAgICAgICAgICAgaWYgKHkgPiBjb3ZlclJlY3QueSgpKQorICAgICAgICAg ICAgICAgIG9jY2x1ZGVzID0gZmFsc2U7CisgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAg ICAgICB5SW50ZXJzZWN0cyA9IHRydWU7CisgICAgICAgICAgICAgICAgeVVuaW9uU3RhcnQgPSB5 OworICAgICAgICAgICAgICAgIHlVbmlvbkVuZCA9IG1heFk7CisgICAgICAgICAgICB9CisgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICBpZiAoeSA+IHlVbmlvbkVuZCkKKyAgICAgICAgICAg ICAgICBvY2NsdWRlcyA9IGZhbHNlOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAg IHlVbmlvbkVuZCA9IG1heFk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKCFvY2NsdWRlcykKKyAg ICAgICAgICAgIGJyZWFrOworCisgICAgICAgIGJvb2wgeEludGVyc2VjdHMgPSBmYWxzZTsKKyAg ICAgICAgaW50IHhVbmlvblN0YXJ0ID0gMCwgeFVuaW9uRW5kID0gLTE7CisKKyAgICAgICAgZm9y IChTaGFwZTo6U2VnbWVudEl0ZXJhdG9yIHNlZ21lbnQgPSBtX3NoYXBlLnNlZ21lbnRzX2JlZ2lu KHNwYW4pLCBlbmQgPSBtX3NoYXBlLnNlZ21lbnRzX2VuZChzcGFuKTsgc2VnbWVudCAhPSBlbmQg JiYgc2VnbWVudCArIDEgIT0gZW5kOyBzZWdtZW50ICs9IDIpIHsKKyAgICAgICAgICAgIGludCB4 ID0gKnNlZ21lbnQ7CisgICAgICAgICAgICBpbnQgbWF4WCA9ICooc2VnbWVudCArIDEpOworCisg ICAgICAgICAgICBpZiAoeCA+PSBjb3ZlclJlY3QubWF4WCgpKQorICAgICAgICAgICAgICAgIGJy ZWFrOworICAgICAgICAgICAgaWYgKG1heFggPD0gY292ZXJSZWN0LngoKSkKKyAgICAgICAgICAg ICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIGlmICgheEludGVyc2VjdHMpIHsKKyAgICAgICAg ICAgICAgICBpZiAoeCA+IGNvdmVyUmVjdC54KCkpCisgICAgICAgICAgICAgICAgICAgIG9jY2x1 ZGVzID0gZmFsc2U7CisgICAgICAgICAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAgICAgICAg IHhJbnRlcnNlY3RzID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICAgICAgeFVuaW9uU3RhcnQgPSB4 OworICAgICAgICAgICAgICAgICAgICB4VW5pb25FbmQgPSBtYXhYOworICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgaWYgKHggPiB4VW5pb25F bmQpCisgICAgICAgICAgICAgICAgICAgIG9jY2x1ZGVzID0gZmFsc2U7CisgICAgICAgICAgICAg ICAgZWxzZQorICAgICAgICAgICAgICAgICAgICB4VW5pb25FbmQgPSBtYXhYOworICAgICAgICAg ICAgfQorICAgICAgICAgICAgaWYgKCFvY2NsdWRlcykKKyAgICAgICAgICAgICAgICBicmVhazsK KyAgICAgICAgfQorCisgICAgICAgIGlmICgheEludGVyc2VjdHMgfHwgeFVuaW9uRW5kIDwgY292 ZXJSZWN0Lm1heFgoKSkKKyAgICAgICAgICAgIG9jY2x1ZGVzID0gZmFsc2U7CisgICAgICAgIGlm ICghb2NjbHVkZXMpCisgICAgICAgICAgICBicmVhazsKKyAgICB9CisKKyAgICBpZiAoIXlJbnRl cnNlY3RzIHx8IHlVbmlvbkVuZCA8IGNvdmVyUmVjdC5tYXhZKCkpCisgICAgICAgIG9jY2x1ZGVz ID0gZmFsc2U7CisKKyAgICByZXR1cm4gb2NjbHVkZXM7Cit9CisKIFJlZ2lvbjo6U2hhcGU6OlNo YXBlKCkKIHsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L1JlZ2lvbi5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmgKaW5k ZXggYjUzNTliYmUzOWMwMjVjM2UyYzVlNTViMzlmYTRhNTc1N2Q3OTc1Zi4uNWM5ZmFkZjJkZWMz YmYyOGRhYzE1NDY1OGE2YzgyZDdkMGMyOGJmOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUmVnaW9uLmgKQEAgLTQwLDYgKzQwLDcgQEAgcHVibGljOgogICAgIGJvb2wgaXNF bXB0eSgpIGNvbnN0IHsgcmV0dXJuIG1fYm91bmRzLmlzRW1wdHkoKTsgfQogCiAgICAgVmVjdG9y PEludFJlY3Q+IHJlY3RzKCkgY29uc3Q7CisgICAgYm9vbCBvY2NsdWRlcyhjb25zdCBJbnRSZWN0 JikgY29uc3Q7CiAKICAgICB2b2lkIHVuaXRlKGNvbnN0IFJlZ2lvbiYpOwogICAgIHZvaWQgaW50 ZXJzZWN0KGNvbnN0IFJlZ2lvbiYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9XZWJLaXQuZ3lwaSBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cGkKaW5kZXgg NjA5MzI2NmI5NGExYzI3ZjVkMDI3NTEwODFmNWVhODA2ODBiMTIwOS4uN2IwNzY1YTcxZjM1NmI3 ZTZjNTkyOTc3OWE1NjAwOTdhNjUxNzJiMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9XZWJLaXQuZ3lwaQorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXBp CkBAIC04MSw2ICs4MSw3IEBACiAgICAgICAgICAgICAndGVzdHMvUE9ESW50ZXJ2YWxUcmVlVGVz dC5jcHAnLAogICAgICAgICAgICAgJ3Rlc3RzL1BPRFJlZEJsYWNrVHJlZVRlc3QuY3BwJywKICAg ICAgICAgICAgICd0ZXN0cy9SZW5kZXJUYWJsZUNlbGxUZXN0LmNwcCcsCisgICAgICAgICAgICAn dGVzdHMvUmVnaW9uT2NjbHVkZXNUZXN0LmNwcCcsCiAgICAgICAgICAgICAndGVzdHMvVGlsaW5n RGF0YVRlc3QuY3BwJywKICAgICAgICAgICAgICd0ZXN0cy9UcmVlU3luY2hyb25pemVyVGVzdC5j cHAnLAogICAgICAgICAgICAgJ3Rlc3RzL1RyZWVUZXN0SGVscGVycy5jcHAnLApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9SZWdpb25PY2NsdWRlc1Rlc3QuY3BwIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9SZWdpb25PY2NsdWRlc1Rlc3QuY3BwCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjkwOGExMmViZmM2NzA4MDNhZjMzYWE1ZmExODc1ZmUwMjcxZGUzZTUKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1JlZ2lvbk9jY2x1ZGVzVGVz dC5jcHAKQEAgLTAsMCArMSwxMzMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJ UyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisvLyBUZXN0cyBmb3IgdGhlIGludGVnZXIg cmVjdCBlZGdlcyBjbGFzcy4KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiUmVn aW9uLmgiCisKKyNpbmNsdWRlICJJbnRSZWN0LmgiCisjaW5jbHVkZSAiTG9nZ2luZy5oIgorI2lu Y2x1ZGUgPGd0ZXN0L2d0ZXN0Lmg+CisjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKworaW5saW5lIGJvb2wgcXVlcnkoY29uc3QgVmVjdG9yPElu dFJlY3Q+JiByZWN0cywgY29uc3QgSW50UmVjdCYgY292ZXJSZWN0KQoreworICAgIFJlZ2lvbiBy ZWdpb247CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCByZWN0cy5zaXplKCk7ICsraSkKKyAg ICAgICAgcmVnaW9uLnVuaXRlKHJlY3RzW2ldKTsKKworICAgIHJldHVybiByZWdpb24ub2NjbHVk ZXMoY292ZXJSZWN0KTsKK30KKworVEVTVChSZWdpb25PY2NsdWRlc1Rlc3QsIFRlc3ROb0ludGVy c2VjdGlvbikKK3sKKyAgICBWZWN0b3I8SW50UmVjdD4gcmVjdHM7CisgICAgcmVjdHMuYXBwZW5k KEludFJlY3QoMCwgMCwgMTAwLCAxMDApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgxMDAs IDIwMCwgMTAwLCAxMDApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRS ZWN0KDEwMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMs IEludFJlY3QoMCwgMTAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShy ZWN0cywgSW50UmVjdCgxMTAsIDExMCwgMTAsIDEwKSkpOworfQorCitURVNUKFJlZ2lvbk9jY2x1 ZGVzVGVzdCwgVGVzdE5vQ292ZXIpCit7CisgICAgVmVjdG9yPEludFJlY3Q+IHJlY3RzOworICAg IHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJ bnRSZWN0KDAsIDExLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3Rz LCBJbnRSZWN0KDAsIDAsIDEwLCAyMCkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3Rz LmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0 KDExLCAwLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRS ZWN0KDAsIDAsIDIwLCAxMCkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVu ZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDEsIDEs IDEwLCAxMCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwg MCwgMTEsIDExKSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJl Y3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMSwgMTAsIDEw KSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMSwg MTEpKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAw LCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgxLCAwLCAxMCwgMTApKTsKKyAg ICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDExLCAxMSkpKTsK KyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAx MCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDEsIDEsIDEwLCAxMCkpOworICAgIEVYUEVD VF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwgMCwgMTAsIDEpKSk7CisgICAgRVhQ RUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAwLCAxMCwgMikpKTsKKyAgICBF WFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwgMSwgMTAsIDIpKSk7CisgICAg cmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgxLCAxLCAxMCwgMTApKTsK KyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDEyLCAxMikp KTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDExLCAx MSkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDEx LCAxMSkpKTsKK30KKworVEVTVChSZWdpb25PY2NsdWRlc1Rlc3QsIFRlc3RDb3ZlcikKK3sKKyAg ICBWZWN0b3I8SW50UmVjdD4gcmVjdHM7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwg MTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAs IDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwg MSwgOCwgOCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwg MSwgOSwgOSkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwg MCwgOSwgOSkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0 KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkp OworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFw cGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShy ZWN0cywgSW50UmVjdCgwLCAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5 KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDgsIDgpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5 KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDksIDkpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5 KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDksIDkpKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICBy ZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50 UmVjdCg1LCA1LCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJ bnRSZWN0KDAsIDAsIDEwLCAxNSkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMs IEludFJlY3QoMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0 cywgSW50UmVjdCg1LCA1LCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShy ZWN0cywgSW50UmVjdCgwLCA1LCAxNSwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVy eShyZWN0cywgSW50UmVjdCg1LCAwLCAxMCwgMTUpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1 ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2Us IHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDUsIDUsIDE1LCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1 ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoNSwgMCwgNSwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRy dWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDUsIDAsIDUsIDE1KSkpOworICAgIHJlY3RzLmNsZWFy KCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMu YXBwZW5kKEludFJlY3QoMTAsIDAsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVy eShyZWN0cywgSW50UmVjdCgwLCAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1 ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDE1LCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwg cXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMjAsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxz ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMjAsIDExKSkpOworICAgIEVYUEVDVF9FUShm YWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMjEsIDEwKSkpOworICAgIEVYUEVDVF9F USh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAxLCAxOCwgOCkpKTsKK30KKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQo= 115062 2011-11-14 16:54:30 -0800 2011-11-15 08:55:40 -0800 Patch bug-72294-20111114195428.patch text/plain 11013 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uOGJhYzE0ZjdhYjI0OTdkOGRlMmQ1ZTc5NmM4NzZl NzllYTRlNmE0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTExLTE0ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBvY2NsdWRlcygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZHMgY2hyb21pdW0gdW5pdCB0ZXN0IGZvciB0aGUgY29udGFpbnMoKSBtZXRob2Qu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwOgorICAgICAgICAoV2Vi Q29yZTo6UmVnaW9uOjpjb250YWlucyk6IFJldHVybnMgdHJ1ZSBpZiB0aGUgcXVlcnkgUmVjdCBp cyBmdWxseSBjb250YWluZWQgaW4gYXJlYXMgYmVsb25naW5nIHRvIHRoZSBSZWdpb24uCisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmg6CisKIDIwMTEtMTEtMTEgIE5hdCBEdWNh ICA8bmR1Y2FAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFNpbmNlIEdyYXBoaWNzQ29udGV4dDNE OjptYWtlQ29udGV4dEN1cnJlbnQgY2FuIGZhaWwsIHJldHVybiBib29sLgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZwppbmRleCAzMjIyZjc0ZjUxNzJmNDk2NjNkZjM2M2NhMmUwN2UxYzM2NjYzMGY4 Li4xNzEzMWY5OTU0OTg5MjBmMDUzMzI2ZjQ3NzdlOWUzMjA0Yjc2ZWUwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDExLTExLTE0ICBEYW5hIEphbnNlbnMg IDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBvY2NsdWRlcygpIHRlc3QgdG8g UmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03 MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog V2ViS2l0Lmd5cGk6CisgICAgICAgICogdGVzdHMvUmVnaW9uQ29udGFpbnNUZXN0LmNwcDogQWRk ZWQuCisgICAgICAgIChXZWJDb3JlOjpxdWVyeSk6CisgICAgICAgIChXZWJDb3JlOjpURVNUKToK KwogMjAxMS0xMS0xMSAgTmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg U2luY2UgR3JhcGhpY3NDb250ZXh0M0Q6Om1ha2VDb250ZXh0Q3VycmVudCBjYW4gZmFpbCwgcmV0 dXJuIGJvb2wuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9S ZWdpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcApp bmRleCA1NDI3YzZjOTFkMjE2MGViNzdlODI3ODdhYjA5YWVmNDIxZDY2MTI3Li5kMjIyOTg5NTVj Nzg1YjJiZjMwYTkwZDdhMThlNmY2ZGQ3ZDg3YjAxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAKQEAgLTY1LDYgKzY1LDc3IEBAIFZlY3RvcjxJbnRSZWN0 PiBSZWdpb246OnJlY3RzKCkgY29uc3QKICAgICByZXR1cm4gcmVjdHM7CiB9CiAKK2Jvb2wgUmVn aW9uOjpjb250YWlucyhjb25zdCBJbnRSZWN0JiBjb3ZlclJlY3QpIGNvbnN0Cit7CisgICAgYm9v bCBvY2NsdWRlcyA9IHRydWU7CisKKyAgICBib29sIHlJbnRlcnNlY3RzID0gZmFsc2U7CisgICAg aW50IHlDb250aWd1b3VzRW5kID0gMDsKKworICAgIGZvciAoU2hhcGU6OlNwYW5JdGVyYXRvciBz cGFuID0gbV9zaGFwZS5zcGFuc19iZWdpbigpLCBlbmQgPSBtX3NoYXBlLnNwYW5zX2VuZCgpOyBz cGFuICE9IGVuZCAmJiBzcGFuICsgMSAhPSBlbmQ7ICsrc3BhbikgeworICAgICAgICBpbnQgeSA9 IHNwYW4tPnk7CisgICAgICAgIGludCBtYXhZID0gKHNwYW4gKyAxKS0+eTsKKworICAgICAgICBp ZiAoeSA+PSBjb3ZlclJlY3QubWF4WSgpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGlm IChtYXhZIDw9IGNvdmVyUmVjdC55KCkpCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAg aWYgKCF5SW50ZXJzZWN0cykgeworICAgICAgICAgICAgaWYgKHkgPiBjb3ZlclJlY3QueSgpKQor ICAgICAgICAgICAgICAgIG9jY2x1ZGVzID0gZmFsc2U7CisgICAgICAgICAgICBlbHNlIHsKKyAg ICAgICAgICAgICAgICB5SW50ZXJzZWN0cyA9IHRydWU7CisgICAgICAgICAgICAgICAgeUNvbnRp Z3VvdXNFbmQgPSBtYXhZOworICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgaWYgKHkgPiB5Q29udGlndW91c0VuZCkKKyAgICAgICAgICAgICAgICBvY2NsdWRlcyA9 IGZhbHNlOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHlDb250aWd1b3VzRW5k ID0gbWF4WTsKKyAgICAgICAgfQorICAgICAgICBpZiAoIW9jY2x1ZGVzKQorICAgICAgICAgICAg YnJlYWs7CisKKyAgICAgICAgYm9vbCB4SW50ZXJzZWN0cyA9IGZhbHNlOworICAgICAgICBpbnQg eENvbnRpZ3VvdXNFbmQgPSAwOworCisgICAgICAgIGZvciAoU2hhcGU6OlNlZ21lbnRJdGVyYXRv ciBzZWdtZW50ID0gbV9zaGFwZS5zZWdtZW50c19iZWdpbihzcGFuKSwgZW5kID0gbV9zaGFwZS5z ZWdtZW50c19lbmQoc3Bhbik7IHNlZ21lbnQgIT0gZW5kICYmIHNlZ21lbnQgKyAxICE9IGVuZDsg c2VnbWVudCArPSAyKSB7CisgICAgICAgICAgICBpbnQgeCA9ICpzZWdtZW50OworICAgICAgICAg ICAgaW50IG1heFggPSAqKHNlZ21lbnQgKyAxKTsKKworICAgICAgICAgICAgaWYgKHggPj0gY292 ZXJSZWN0Lm1heFgoKSkKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIGlmICht YXhYIDw9IGNvdmVyUmVjdC54KCkpCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAg ICAgICBpZiAoIXhJbnRlcnNlY3RzKSB7CisgICAgICAgICAgICAgICAgaWYgKHggPiBjb3ZlclJl Y3QueCgpKQorICAgICAgICAgICAgICAgICAgICBvY2NsdWRlcyA9IGZhbHNlOworICAgICAgICAg ICAgICAgIGVsc2UgeworICAgICAgICAgICAgICAgICAgICB4SW50ZXJzZWN0cyA9IHRydWU7Cisg ICAgICAgICAgICAgICAgICAgIHhDb250aWd1b3VzRW5kID0gbWF4WDsKKyAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGlmICh4ID4geENvbnRp Z3VvdXNFbmQpCisgICAgICAgICAgICAgICAgICAgIG9jY2x1ZGVzID0gZmFsc2U7CisgICAgICAg ICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICB4Q29udGlndW91c0VuZCA9IG1heFg7 CisgICAgICAgICAgICB9CisgICAgICAgICAgICBpZiAoIW9jY2x1ZGVzKQorICAgICAgICAgICAg ICAgIGJyZWFrOworICAgICAgICB9CisKKyAgICAgICAgaWYgKCF4SW50ZXJzZWN0cyB8fCB4Q29u dGlndW91c0VuZCA8IGNvdmVyUmVjdC5tYXhYKCkpCisgICAgICAgICAgICBvY2NsdWRlcyA9IGZh bHNlOworICAgICAgICBpZiAoIW9jY2x1ZGVzKQorICAgICAgICAgICAgYnJlYWs7CisgICAgfQor CisgICAgaWYgKCF5SW50ZXJzZWN0cyB8fCB5Q29udGlndW91c0VuZCA8IGNvdmVyUmVjdC5tYXhZ KCkpCisgICAgICAgIG9jY2x1ZGVzID0gZmFsc2U7CisKKyAgICByZXR1cm4gb2NjbHVkZXM7Cit9 CisKIFJlZ2lvbjo6U2hhcGU6OlNoYXBlKCkKIHsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUmVnaW9uLmgKaW5kZXggYjUzNTliYmUzOWMwMjVjM2UyYzVlNTViMzlmYTRhNTc1 N2Q3OTc1Zi4uYTdhY2ViNzUzZTA0MjhmNDNhYzUwYWU3MmNjYTM4ZWY0ZWMxOTkzYiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmgKQEAgLTQwLDYgKzQwLDggQEAg cHVibGljOgogICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsgcmV0dXJuIG1fYm91bmRzLmlzRW1w dHkoKTsgfQogCiAgICAgVmVjdG9yPEludFJlY3Q+IHJlY3RzKCkgY29uc3Q7CisgICAgLy8gUmV0 dXJucyB0cnVlIGlmIHRoZSByZWN0IGlzIGNvbnRhaW5lZCBmdWxseSBpbiB0aGUgYXJlYXMgY292 ZXJlZCBieSB0aGUgUmVnaW9uLgorICAgIGJvb2wgY29udGFpbnMoY29uc3QgSW50UmVjdCYpIGNv bnN0OwogCiAgICAgdm9pZCB1bml0ZShjb25zdCBSZWdpb24mKTsKICAgICB2b2lkIGludGVyc2Vj dChjb25zdCBSZWdpb24mKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2Vi S2l0Lmd5cGkgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXBpCmluZGV4IDYwOTMy NjZiOTRhMWMyN2Y1ZDAyNzUxMDgxZjVlYTgwNjgwYjEyMDkuLmVjZmZiNjZjNmQ5OTIzYmI2YTFm Y2JiOWZiOGNlNTk2NDU5YjZiOTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v V2ViS2l0Lmd5cGkKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwaQpAQCAt ODEsNiArODEsNyBAQAogICAgICAgICAgICAgJ3Rlc3RzL1BPREludGVydmFsVHJlZVRlc3QuY3Bw JywKICAgICAgICAgICAgICd0ZXN0cy9QT0RSZWRCbGFja1RyZWVUZXN0LmNwcCcsCiAgICAgICAg ICAgICAndGVzdHMvUmVuZGVyVGFibGVDZWxsVGVzdC5jcHAnLAorICAgICAgICAgICAgJ3Rlc3Rz L1JlZ2lvbkNvbnRhaW5zVGVzdC5jcHAnLAogICAgICAgICAgICAgJ3Rlc3RzL1RpbGluZ0RhdGFU ZXN0LmNwcCcsCiAgICAgICAgICAgICAndGVzdHMvVHJlZVN5bmNocm9uaXplclRlc3QuY3BwJywK ICAgICAgICAgICAgICd0ZXN0cy9UcmVlVGVzdEhlbHBlcnMuY3BwJywKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvUmVnaW9uQ29udGFpbnNUZXN0LmNwcCBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvUmVnaW9uQ29udGFpbnNUZXN0LmNwcApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5kM2EzMjI4YzJjNWZkOGQ5YmMxOWE4NzNmZTkzYWI3YjYyNWNkZmZkCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9SZWdpb25Db250YWluc1Rlc3QuY3Bw CkBAIC0wLDAgKzEsMTMzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFO RCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Cisg KiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworLy8gVGVzdHMgZm9yIHRoZSBpbnRlZ2VyIHJlY3Qg ZWRnZXMgY2xhc3MuCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlJlZ2lvbi5o IgorCisjaW5jbHVkZSAiSW50UmVjdC5oIgorI2luY2x1ZGUgIkxvZ2dpbmcuaCIKKyNpbmNsdWRl IDxndGVzdC9ndGVzdC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK2lubGluZSBib29sIHF1ZXJ5KGNvbnN0IFZlY3RvcjxJbnRSZWN0 PiYgcmVjdHMsIGNvbnN0IEludFJlY3QmIGNvdmVyUmVjdCkKK3sKKyAgICBSZWdpb24gcmVnaW9u OworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcmVjdHMuc2l6ZSgpOyArK2kpCisgICAgICAg IHJlZ2lvbi51bml0ZShyZWN0c1tpXSk7CisKKyAgICByZXR1cm4gcmVnaW9uLmNvbnRhaW5zKGNv dmVyUmVjdCk7Cit9CisKK1RFU1QoUmVnaW9uQ29udGFpbnNUZXN0LCBUZXN0Tm9JbnRlcnNlY3Rp b24pCit7CisgICAgVmVjdG9yPEludFJlY3Q+IHJlY3RzOworICAgIHJlY3RzLmFwcGVuZChJbnRS ZWN0KDAsIDAsIDEwMCwgMTAwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMTAwLCAyMDAs IDEwMCwgMTAwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgx MDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRS ZWN0KDAsIDEwMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMs IEludFJlY3QoMTEwLCAxMTAsIDEwLCAxMCkpKTsKK30KKworVEVTVChSZWdpb25Db250YWluc1Rl c3QsIFRlc3ROb0NvdmVyKQoreworICAgIFZlY3RvcjxJbnRSZWN0PiByZWN0czsKKyAgICByZWN0 cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVj dCgwLCAxMSwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50 UmVjdCgwLCAwLCAxMCwgMjApKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBl bmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgxMSwg MCwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgw LCAwLCAyMCwgMTApKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50 UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgxLCAxLCAxMCwg MTApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDEx LCAxMSkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAs IDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDEsIDEwLCAxMCkpOwor ICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTEsIDExKSkp OworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAs IDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMSwgMCwgMTAsIDEwKSk7CisgICAgRVhQ RUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMSwgMTEpKSk7CisgICAg cmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsK KyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgxLCAxLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEo ZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDAsIDEwLCAxKSkpOworICAgIEVYUEVDVF9F UShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwgMCwgMTAsIDIpKSk7CisgICAgRVhQRUNU X0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDEwLCAyKSkpOworICAgIHJlY3Rz LmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMSwgMSwgMTAsIDEwKSk7CisgICAg RVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMiwgMTIpKSk7Cisg ICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMSwgMTEpKSk7 CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAxLCAxMSwgMTEp KSk7Cit9CisKK1RFU1QoUmVnaW9uQ29udGFpbnNUZXN0LCBUZXN0Q292ZXIpCit7CisgICAgVmVj dG9yPEludFJlY3Q+IHJlY3RzOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAx MCkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMCwg MTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDgs IDgpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDks IDkpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDks IDkpKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAw LCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAg ICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQo SW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMs IEludFJlY3QoMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0 cywgSW50UmVjdCgxLCAxLCA4LCA4KSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0 cywgSW50UmVjdCgxLCAxLCA5LCA5KSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0 cywgSW50UmVjdCgwLCAwLCA5LCA5KSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMu YXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3Qo NSwgNSwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVj dCgwLCAwLCAxMCwgMTUpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRS ZWN0KDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIElu dFJlY3QoNSwgNSwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMs IEludFJlY3QoMCwgNSwgMTUsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVj dHMsIEludFJlY3QoNSwgMCwgMTAsIDE1KSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShy ZWN0cywgSW50UmVjdCgwLCAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVy eShyZWN0cywgSW50UmVjdCg1LCA1LCAxNSwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1 ZXJ5KHJlY3RzLCBJbnRSZWN0KDUsIDAsIDUsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBx dWVyeShyZWN0cywgSW50UmVjdCg1LCAwLCA1LCAxNSkpKTsKKyAgICByZWN0cy5jbGVhcigpOwor ICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVu ZChJbnRSZWN0KDEwLCAwLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVj dHMsIEludFJlY3QoMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShy ZWN0cywgSW50UmVjdCgwLCAwLCAxNSwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5 KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDIwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1 ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDIwLCAxMSkpKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2Us IHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDIxLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1 ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwgMSwgMTgsIDgpKSk7Cit9CisKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUK 115172 2011-11-15 08:55:48 -0800 2011-11-15 10:44:57 -0800 Patch bug-72294-20111115115547.patch text/plain 11235 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uZGJjNjA0ZjlkNzg2ZWIwZTc1NGJkZmFiMzk4YjM5 YjY3ZWUzMjM3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDExLTExLTE1ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZHMgdGVzdCBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvUmVnaW9uQ29udGFp bnMuY3BwCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwOgorICAgICAg ICAoV2ViQ29yZTo6UmVnaW9uOjpjb250YWlucyk6IEEgY29udGFpbnMgQiBpZiBBLmludGVyc2Vj dChCKSA9PSBCLgorICAgICAgICAoV2ViQ29yZTo6UmVnaW9uOjpvcGVyYXRvcj09KTogVGVzdHMg YWxsIHNwYW5zL3NlZ21lbnRzIGFyZSBlcXVhbCBpbiB0d28gUmVnaW9ucy4KKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaDoKKwogMjAxMS0xMS0xMSAgTmF0IER1Y2EgIDxuZHVj YUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgU2luY2UgR3JhcGhpY3NDb250ZXh0M0Q6Om1ha2VD b250ZXh0Q3VycmVudCBjYW4gZmFpbCwgcmV0dXJuIGJvb2wuCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcAppbmRleCA1NDI3YzZjOTFkMjE2MGViNzdlODI3ODdh YjA5YWVmNDIxZDY2MTI3Li5lN2YwYmY5OTcyYWYyNjI3ZGY4OWQwMzY2NGMzYTIwMjc5NDg2NmU0 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAKQEAgLTY1 LDYgKzY1LDQ0IEBAIFZlY3RvcjxJbnRSZWN0PiBSZWdpb246OnJlY3RzKCkgY29uc3QKICAgICBy ZXR1cm4gcmVjdHM7CiB9CiAKK2Jvb2wgUmVnaW9uOjpjb250YWlucyhjb25zdCBSZWdpb24mIHN1 YnNldCkgY29uc3QKK3sKKyAgICBSZWdpb24gdGVzdChzdWJzZXQpOworICAgIHRlc3QuaW50ZXJz ZWN0KCp0aGlzKTsKKyAgICByZXR1cm4gdGVzdCA9PSBzdWJzZXQ7Cit9CisKK2Jvb2wgUmVnaW9u OjpvcGVyYXRvcj09KGNvbnN0IFJlZ2lvbiYgb3RoZXIpCit7CisgICAgU2hhcGUgYSA9IG1fc2hh cGU7CisgICAgU2hhcGUgYiA9IG90aGVyLm1fc2hhcGU7CisKKyAgICBTaGFwZTo6U3Bhbkl0ZXJh dG9yIGFTcGFuID0gYS5zcGFuc19iZWdpbigpOworICAgIFNoYXBlOjpTcGFuSXRlcmF0b3IgYlNw YW4gPSBiLnNwYW5zX2JlZ2luKCk7CisgICAgY29uc3QgU2hhcGU6OlNwYW5JdGVyYXRvciBhU3Bh bkVuZCA9IGEuc3BhbnNfZW5kKCk7CisgICAgY29uc3QgU2hhcGU6OlNwYW5JdGVyYXRvciBiU3Bh bkVuZCA9IGIuc3BhbnNfZW5kKCk7CisKKyAgICBpZiAoYVNwYW5FbmQgLSBhU3BhbiAhPSBiU3Bh bkVuZCAtIGJTcGFuKSAvLyBUZXN0IGZvciBlcXVhbCBudW1iZXIgb2Ygc3BhbnMKKyAgICAgICAg cmV0dXJuIGZhbHNlOworCisgICAgZm9yICg7IGFTcGFuICE9IGFTcGFuRW5kOyArK2FTcGFuLCAr K2JTcGFuKSB7CisgICAgICAgIGlmIChhU3Bhbi0+eSAhPSBiU3Bhbi0+eSkgLy8gVGVzdCBpZiBz cGFucyBhcmUgYXQgc2FtZSBwb3NpdGlvbgorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgICAgIFNoYXBlOjpTZWdtZW50SXRlcmF0b3IgYVNlZ21lbnQgPSBhLnNlZ21lbnRzX2JlZ2lu KGFTcGFuKTsKKyAgICAgICAgU2hhcGU6OlNlZ21lbnRJdGVyYXRvciBiU2VnbWVudCA9IGIuc2Vn bWVudHNfYmVnaW4oYlNwYW4pOworICAgICAgICBjb25zdCBTaGFwZTo6U2VnbWVudEl0ZXJhdG9y IGFTZWdtZW50RW5kID0gYS5zZWdtZW50c19lbmQoYVNwYW4pOworICAgICAgICBjb25zdCBTaGFw ZTo6U2VnbWVudEl0ZXJhdG9yIGJTZWdtZW50RW5kID0gYi5zZWdtZW50c19lbmQoYlNwYW4pOwor CisgICAgICAgIGlmIChhU2VnbWVudEVuZCAtIGFTZWdtZW50ICE9IGJTZWdtZW50RW5kIC0gYlNl Z21lbnQpIC8vIFRlc3QgZm9yIGVxdWFsIG51bWJlciBvZiBzZWdtZW50cworICAgICAgICAgICAg cmV0dXJuIGZhbHNlOworICAgICAgICBpZiAoIXN0ZDo6ZXF1YWwoYVNlZ21lbnQsIGFTZWdtZW50 RW5kLCBiU2VnbWVudCkpIC8vIFRlc3QgaWYgc2VnbWVudHMgYXJlIGF0IHNhbWUgcG9zaXRpb25z CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgcmV0dXJuIHRydWU7Cit9 CisKIFJlZ2lvbjo6U2hhcGU6OlNoYXBlKCkKIHsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUmVnaW9uLmgKaW5kZXggYjUzNTliYmUzOWMwMjVjM2UyYzVlNTViMzlmYTRhNTc1 N2Q3OTc1Zi4uNjFjNWIxYWViOWJiMTlhYTZjMGM0NzIzNmY1ZjIwYTEzZjVmZGVmMSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmgKQEAgLTQ3LDYgKzQ3LDExIEBA IHB1YmxpYzoKIAogICAgIHZvaWQgdHJhbnNsYXRlKGNvbnN0IEludFNpemUmKTsKIAorICAgIC8v IFJldHVybnMgdHJ1ZSBpZiB0aGUgcXVlcnkgcmVnaW9uIGlzIGEgc3Vic2V0IG9mIHRoaXMgcmVn aW9uLgorICAgIGJvb2wgY29udGFpbnMoY29uc3QgUmVnaW9uJikgY29uc3Q7CisKKyAgICBib29s IG9wZXJhdG9yPT0oY29uc3QgUmVnaW9uJik7CisKICNpZm5kZWYgTkRFQlVHCiAgICAgdm9pZCBk dW1wKCkgY29uc3Q7CiAjZW5kaWYKQEAgLTEwNCw5ICsxMDksOCBAQCBwcml2YXRlOgogCiAgICAg ICAgIGJvb2wgY2FuQ29hbGVzY2UoU2VnbWVudEl0ZXJhdG9yIGJlZ2luLCBTZWdtZW50SXRlcmF0 b3IgZW5kKTsKIAotICAgICAgICAvLyBGSVhNRTogVGhlc2UgdmVjdG9ycyBzaG91bGQgaGF2ZSBp bmxpbmUgc2l6ZXMuIEZpZ3VyZSBvdXQgYSBnb29kIG9wdGltYWwgdmFsdWUuCi0gICAgICAgIFZl Y3RvcjxpbnQ+IG1fc2VnbWVudHM7Ci0gICAgICAgIFZlY3RvcjxTcGFuPiBtX3NwYW5zOyAgICAg ICAgCisgICAgICAgIFZlY3RvcjxpbnQsIDMyPiBtX3NlZ21lbnRzOworICAgICAgICBWZWN0b3I8 U3BhbiwgMTY+IG1fc3BhbnM7CiAgICAgfTsKIAogICAgIEludFJlY3QgbV9ib3VuZHM7CmRpZmYg LS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZTZhMDUzYjAx NTMzOWJlNzJhYzliZjhhMGQ3ODQ0MzI4ODg3YWQ4Zi4uN2Y3OTdhM2RiYjkzMzBkOTRkMmJiZDg1 MjYwZGE5NjNlYWUyNjQ1NiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTExLTE1ICBEYW5hIEphbnNlbnMgIDxk YW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygpIHRlc3QgdG8gUmVn aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjI5 NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVGVz dFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLmd5cGk6IEFkZCBXZWJDb3JlL1JlZ2lvbkNvbnRhaW5z LmNwcAorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9SZWdpb25Db250YWlu cy5jcHA6IEFkZGVkLgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6cXVlcnkpOgorICAgICAgICAo VGVzdFdlYktpdEFQSTo6VEVTVCk6CisgICAgICAgICogVGVzdFdlYktpdEFQSS93aW4vVGVzdFdl YktpdEFQSS52Y3Byb2o6IEFkZCBXZWJDb3JlL1JlZ2lvbkNvbnRhaW5zLmNwcAorCiAyMDExLTEx LTExICBTdGVwaGVuIENoZW5uZXkgIDxzY2hlbm5leUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg W0Nocm9taXVtXSBEUlQgZG9lcyBub3QgaGF2ZSBMYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlU2l6 ZUFuZE1hcmdpbnNJblBpeGVscwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 V2ViS2l0QVBJLmd5cGkgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkuZ3lwaQpp bmRleCA4NWFhMjljZmViOWEyYzA3ZTY2ZDFiNGQzNmU4OTE1M2ZlMjBmMWE3Li4yNGUwNTVlZmYx NzRhMGRjMmNkNmRlZjkzMmFiYzI1ZDc5NWRhNTY5IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkuZ3lwaQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RX ZWJLaXRBUEkuZ3lwaQpAQCAtMzEsNiArMzEsNyBAQAogewogICAgICd2YXJpYWJsZXMnOiB7CiAg ICAgICAgICdUZXN0V2ViS2l0QVBJX2ZpbGVzJzogWworICAgICAgICAgICAgJ1Rlc3RzL1dlYkNv cmUvUmVnaW9uQ29udGFpbnMuY3BwJywKICAgICAgICAgICAgICdUZXN0cy9XVEYvQ2hlY2tlZEFy aXRobWV0aWNPcGVyYXRpb25zLmNwcCcsCiAgICAgICAgICAgICAnVGVzdHMvV1RGL1JlZEJsYWNr VHJlZS5jcHAnLAogICAgICAgICAgICAgJ1Rlc3RzL1dURi9TdHJpbmdCdWlsZGVyLmNwcCcsCmRp ZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvUmVnaW9uQ29udGFp bnMuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL1JlZ2lvbkNvbnRhaW5z LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi4xMDVkYmNlMDZjOTI1ZDIxZDBkNjIyZDFkOTQ3ZWZjNjE1NmNlZjZm Ci0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL1Jl Z2lvbkNvbnRhaW5zLmNwcApAQCAtMCwwICsxLDEzMCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9S UyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09O VFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVk ZSAiY29uZmlnLmgiCisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorI2luY2x1ZGUgPFdlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvSW50UmVjdC5oPgorI2luY2x1ZGUgPFdlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUmVnaW9uLmg+CisKK3VzaW5nIFdlYkNvcmU6OkludFJlY3Q7Cit1c2luZyBXZWJD b3JlOjpSZWdpb247CisKK25hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKKworaW5saW5lIGJvb2wg cXVlcnkoY29uc3QgVmVjdG9yPEludFJlY3Q+JiByZWN0cywgY29uc3QgSW50UmVjdCYgY292ZXJS ZWN0KQoreworICAgIFJlZ2lvbiByZWdpb247CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBy ZWN0cy5zaXplKCk7ICsraSkKKyAgICAgICAgcmVnaW9uLnVuaXRlKHJlY3RzW2ldKTsKKworICAg IHJldHVybiByZWdpb24uY29udGFpbnMoY292ZXJSZWN0KTsKK30KKworVEVTVChSZWdpb25Db250 YWluc1Rlc3QsIE5vSW50ZXJzZWN0aW9uKQoreworICAgIFZlY3RvcjxJbnRSZWN0PiByZWN0czsK KyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMDAsIDEwMCkpOworICAgIHJlY3RzLmFw cGVuZChJbnRSZWN0KDEwMCwgMjAwLCAxMDAsIDEwMCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwg cXVlcnkocmVjdHMsIEludFJlY3QoMTAwLCAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZh bHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAxMDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1Rf RVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDExMCwgMTEwLCAxMCwgMTApKSk7Cit9CisK K1RFU1QoUmVnaW9uQ29udGFpbnNUZXN0LCBOb0NvdmVyKQoreworICAgIFZlY3RvcjxJbnRSZWN0 PiByZWN0czsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICBy ZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAxMSwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNl LCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMCwgMjApKSk7CisgICAgcmVjdHMuY2xlYXIo KTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5h cHBlbmQoSW50UmVjdCgxMSwgMCwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVy eShyZWN0cywgSW50UmVjdCgwLCAwLCAyMCwgMTApKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAg ICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQo SW50UmVjdCgxLCAxLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3Rz LCBJbnRSZWN0KDAsIDAsIDExLCAxMSkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3Rz LmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0 KDAsIDEsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJl Y3QoMCwgMCwgMTEsIDExKSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5k KEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMSwgMCwg MTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAw LCAxMSwgMTEpKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVj dCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgxLCAxLCAxMCwgMTAp KTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDAsIDEwLCAx KSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwgMCwgMTAs IDIpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDEw LCAyKSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMSwg MSwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgw LCAwLCAxMiwgMTIpKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVj dCgwLCAwLCAxMSwgMTEpKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50 UmVjdCgxLCAxLCAxMSwgMTEpKSk7Cit9CisKK1RFU1QoUmVnaW9uQ29udGFpbnNUZXN0LCBDb3Zl cikKK3sKKyAgICBWZWN0b3I8SW50UmVjdD4gcmVjdHM7CisgICAgcmVjdHMuYXBwZW5kKEludFJl Y3QoMCwgMCwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRS ZWN0KDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIElu dFJlY3QoMSwgMSwgOCwgOCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIElu dFJlY3QoMSwgMSwgOSwgOSkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIElu dFJlY3QoMCwgMCwgOSwgOSkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVu ZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAs IDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAg IHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUSh0cnVl LCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRy dWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDgsIDgpKSk7CisgICAgRVhQRUNUX0VRKHRy dWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDEsIDksIDkpKSk7CisgICAgRVhQRUNUX0VRKHRy dWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDksIDkpKSk7CisgICAgcmVjdHMuY2xlYXIo KTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5h cHBlbmQoSW50UmVjdCg1LCA1LCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5 KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDEwLCAxNSkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVl cnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBx dWVyeShyZWN0cywgSW50UmVjdCg1LCA1LCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNl LCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCA1LCAxNSwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZh bHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCg1LCAwLCAxMCwgMTUpKSk7CisgICAgRVhQRUNUX0VR KHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1Rf RVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDUsIDUsIDE1LCAxMCkpKTsKKyAgICBFWFBF Q1RfRVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoNSwgMCwgNSwgMTApKSk7CisgICAgRVhQ RUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDUsIDAsIDUsIDE1KSkpOworICAgIHJl Y3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7Cisg ICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMTAsIDAsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUSh0 cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VR KHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDE1LCAxMCkpKTsKKyAgICBFWFBFQ1Rf RVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMjAsIDEwKSkpOworICAgIEVYUEVD VF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMjAsIDExKSkpOworICAgIEVY UEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMjEsIDEwKSkpOworICAg IEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAxLCAxOCwgOCkpKTsKK30K KworfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdl YktpdEFQSS93aW4vVGVzdFdlYktpdEFQSS52Y3Byb2ogYi9Ub29scy9UZXN0V2ViS2l0QVBJL3dp bi9UZXN0V2ViS2l0QVBJLnZjcHJvagppbmRleCA1MGVjMDgwYWJmYmUzYmMzYjA2OTk5OTk5YjU2 ZjBmNzIzZDc4MTU3Li41MWVjNTFkYjkwM2I1ZGQxZDU5Zjc0ODAwNTI3NGI0MjcwNmQzYWQ1IDEw MDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL3dpbi9UZXN0V2ViS2l0QVBJLnZjcHJvagor KysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL3dpbi9UZXN0V2ViS2l0QVBJLnZjcHJvagpAQCAtNjQ5 LDYgKzY0OSwxNCBAQAogCQkJCTwvRmlsZT4KIAkJCTwvRmlsdGVyPgogCQkJPEZpbHRlcgorCQkJ CU5hbWU9IldlYkNvcmUiCisJCQkJPgorCQkJCTxGaWxlCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5c VGVzdHNcV2ViQ29yZVxSZWdpb25Db250YWlucy5jcHAiCisJCQkJCT4KKwkJCQk8L0ZpbGU+CisJ CQk8L0ZpbHRlcj4KKwkJCTxGaWx0ZXIKIAkJCQlOYW1lPSJXZWJLaXQiCiAJCQkJPgogCQkJCTxG aWx0ZXIK 115199 2011-11-15 10:45:05 -0800 2011-11-15 11:49:50 -0800 Patch bug-72294-20111115134503.patch text/plain 11113 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uOWMyZTA2MWIwZGNlMDRlYWRlODk4M2MxNWU0NjMx YzA0NWQyMzIwYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDExLTExLTE1ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZHMgdW5pdCB0ZXN0IGluIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9SZWdp b25Db250YWlucy5jcHAKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZWdpb246OmNvbnRhaW5zKTogQSBjb250YWlucyBCIGlmIEEu aW50ZXJzZWN0KEIpID09IEIKKyAgICAgICAgKFdlYkNvcmU6OlJlZ2lvbjo6U2hhcGU6Om9wZXJh dG9yPT0pOiBUZXN0IGlmIHR3byBzaGFwZXMgYXJlIGV4YWN0bHkgaWRlbnRpY2FsIChzYW1lIHNw YW5zIGFuZCBzZWdtZW50cykuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmg6 CisgICAgICAgIChXZWJDb3JlOjpSZWdpb246OlNwYW46Om9wZXJhdG9yIT0pOiBIZWxwZXIgZnVu Y3Rpb24gdG8gbWFrZSBTaGFwZTo6b3BlcmF0b3I9PSBjbGVhbmVyLgorCiAyMDExLTExLTExICBO YXQgRHVjYSAgPG5kdWNhQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTaW5jZSBHcmFwaGljc0Nv bnRleHQzRDo6bWFrZUNvbnRleHRDdXJyZW50IGNhbiBmYWlsLCByZXR1cm4gYm9vbC4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0MjdjNmM5MWQy MTYwZWI3N2U4Mjc4N2FiMDlhZWY0MjFkNjYxMjcuLjZiMTE1MTk1NDFmNGRlYjFlYjllMmI2ZDAx NTc5ZGEwMzllYWYyMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL1JlZ2lvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVn aW9uLmNwcApAQCAtNjUsNiArNjUsMjggQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6cmVjdHMo KSBjb25zdAogICAgIHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246OmNvbnRhaW5zKGNv bnN0IFJlZ2lvbiYgcmVnaW9uKSBjb25zdAoreworICAgIHJldHVybiBXZWJDb3JlOjppbnRlcnNl Y3QocmVnaW9uLCAqdGhpcykubV9zaGFwZSA9PSByZWdpb24ubV9zaGFwZTsKK30KKworYm9vbCBS ZWdpb246OlNoYXBlOjpvcGVyYXRvcj09KGNvbnN0IFNoYXBlJiBvdGhlcikKK3sKKyAgICBpZiAo bV9zcGFucy5zaXplKCkgIT0gb3RoZXIubV9zcGFucy5zaXplKCkpCisgICAgICAgIHJldHVybiBm YWxzZTsKKyAgICBpZiAobV9zZWdtZW50cy5zaXplKCkgIT0gb3RoZXIubV9zZWdtZW50cy5zaXpl KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwg bV9zcGFucy5zaXplKCk7ICsraSkKKyAgICAgICAgaWYgKG1fc3BhbnNbaV0gIT0gb3RoZXIubV9z cGFuc1tpXSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBmb3IgKHNpemVfdCBpID0g MDsgaSA8IG1fc2VnbWVudHMuc2l6ZSgpOyArK2kpCisgICAgICAgIGlmIChtX3NlZ21lbnRzW2ld ICE9IG90aGVyLm1fc2VnbWVudHNbaV0pCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAg ICByZXR1cm4gdHJ1ZTsKK30KKwogUmVnaW9uOjpTaGFwZTo6U2hhcGUoKQogewogfQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAppbmRleCBiNTM1OWJiZTM5YzAyNWMz ZTJjNWU1NWIzOWZhNGE1NzU3ZDc5NzVmLi5lZWFkNmJjMzE5MTMwNzg0YWVhZTc0MGQ3NzJjYTBj NzRhNzhiOWQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9S ZWdpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaApA QCAtNDcsNiArNDcsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHRyYW5zbGF0ZShjb25zdCBJbnRT aXplJik7CiAKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhlIHF1ZXJ5IHJlZ2lvbiBpcyBhIHN1 YnNldCBvZiB0aGlzIHJlZ2lvbi4KKyAgICBib29sIGNvbnRhaW5zKGNvbnN0IFJlZ2lvbiYpIGNv bnN0OworCiAjaWZuZGVmIE5ERUJVRwogICAgIHZvaWQgZHVtcCgpIGNvbnN0OwogI2VuZGlmCkBA IC02MCw2ICs2Myw4IEBAIHByaXZhdGU6CiAKICAgICAgICAgaW50IHk7CiAgICAgICAgIHNpemVf dCBzZWdtZW50SW5kZXg7CisKKyAgICAgICAgaW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBT cGFuJiBvdGhlcikgeyByZXR1cm4geSAhPSBvdGhlci55IHx8IHNlZ21lbnRJbmRleCAhPSBvdGhl ci5zZWdtZW50SW5kZXg7IH0KICAgICB9OwogCiAgICAgY2xhc3MgU2hhcGUgewpAQCAtODUsNiAr OTAsOCBAQCBwcml2YXRlOgogICAgICAgICB2b2lkIHRyYW5zbGF0ZShjb25zdCBJbnRTaXplJik7 CiAgICAgICAgIHZvaWQgc3dhcChTaGFwZSYpOwogCisgICAgICAgIGJvb2wgb3BlcmF0b3I9PShj b25zdCBTaGFwZSYgb3RoZXIpOworCiAjaWZuZGVmIE5ERUJVRwogICAgICAgICB2b2lkIGR1bXAo KSBjb25zdDsKICNlbmRpZgpAQCAtMTA0LDkgKzExMSw4IEBAIHByaXZhdGU6CiAKICAgICAgICAg Ym9vbCBjYW5Db2FsZXNjZShTZWdtZW50SXRlcmF0b3IgYmVnaW4sIFNlZ21lbnRJdGVyYXRvciBl bmQpOwogCi0gICAgICAgIC8vIEZJWE1FOiBUaGVzZSB2ZWN0b3JzIHNob3VsZCBoYXZlIGlubGlu ZSBzaXplcy4gRmlndXJlIG91dCBhIGdvb2Qgb3B0aW1hbCB2YWx1ZS4KLSAgICAgICAgVmVjdG9y PGludD4gbV9zZWdtZW50czsKLSAgICAgICAgVmVjdG9yPFNwYW4+IG1fc3BhbnM7ICAgICAgICAK KyAgICAgICAgVmVjdG9yPGludCwgMzI+IG1fc2VnbWVudHM7CisgICAgICAgIFZlY3RvcjxTcGFu LCAxNj4gbV9zcGFuczsKICAgICB9OwogCiAgICAgSW50UmVjdCBtX2JvdW5kczsKZGlmZiAtLWdp dCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBlNmEwNTNiMDE1MzM5 YmU3MmFjOWJmOGEwZDc4NDQzMjg4ODdhZDhmLi5iOGNkNWNhYmRmNjkzNjAwYjhhMDJlY2FkOTc4 ODgzZThlNTJhYjg3IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMTEtMTUgIERhbmEgSmFuc2VucyAgPGRhbmFr akBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIGNvbnRhaW5zKCkgdGVzdCB0byBSZWdpb24K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcyMjk0CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBUZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkuZ3lwaToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYkNvcmUvUmVnaW9uQ29udGFpbnMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRB UEk6OnF1ZXJ5KToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorICAgICAgICAqIFRl c3RXZWJLaXRBUEkvd2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qOgorCiAyMDExLTExLTExICBTdGVw aGVuIENoZW5uZXkgIDxzY2hlbm5leUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW0Nocm9taXVt XSBEUlQgZG9lcyBub3QgaGF2ZSBMYXlvdXRUZXN0Q29udHJvbGxlci5wYWdlU2l6ZUFuZE1hcmdp bnNJblBpeGVscwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJ Lmd5cGkgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkuZ3lwaQppbmRleCA4NWFh MjljZmViOWEyYzA3ZTY2ZDFiNGQzNmU4OTE1M2ZlMjBmMWE3Li4yNGUwNTVlZmYxNzRhMGRjMmNk NmRlZjkzMmFiYzI1ZDc5NWRhNTY5IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RXZWJLaXRBUEkuZ3lwaQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEku Z3lwaQpAQCAtMzEsNiArMzEsNyBAQAogewogICAgICd2YXJpYWJsZXMnOiB7CiAgICAgICAgICdU ZXN0V2ViS2l0QVBJX2ZpbGVzJzogWworICAgICAgICAgICAgJ1Rlc3RzL1dlYkNvcmUvUmVnaW9u Q29udGFpbnMuY3BwJywKICAgICAgICAgICAgICdUZXN0cy9XVEYvQ2hlY2tlZEFyaXRobWV0aWNP cGVyYXRpb25zLmNwcCcsCiAgICAgICAgICAgICAnVGVzdHMvV1RGL1JlZEJsYWNrVHJlZS5jcHAn LAogICAgICAgICAgICAgJ1Rlc3RzL1dURi9TdHJpbmdCdWlsZGVyLmNwcCcsCmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvUmVnaW9uQ29udGFpbnMuY3BwIGIv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL1JlZ2lvbkNvbnRhaW5zLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi42NTJhODIxYzAyODY3YjY2NWI2MGM2YzVhNWU2Mjk5MWVjYTE0MWExCi0tLSAvZGV2 L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL1JlZ2lvbkNvbnRh aW5zLmNwcApAQCAtMCwwICsxLDEzNiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29n bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElT JycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JT CisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisg KiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQg KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAq IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCisjaWYgZGVmaW5lZChXSU4zMikgfHwgZGVm aW5lZChfV0lOMzIpCisjaW5jbHVkZSA8V2ViQ29yZS9JbnRSZWN0Lmg+CisjaW5jbHVkZSA8V2Vi Q29yZS9SZWdpb24uaD4KKyNlbHNlCisjaW5jbHVkZSA8V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9JbnRSZWN0Lmg+CisjaW5jbHVkZSA8V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24u aD4KKyNlbmRpZgorCit1c2luZyBXZWJDb3JlOjpJbnRSZWN0OwordXNpbmcgV2ViQ29yZTo6UmVn aW9uOworCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK2lubGluZSBib29sIHF1ZXJ5KGNv bnN0IFZlY3RvcjxJbnRSZWN0PiYgcmVjdHMsIGNvbnN0IEludFJlY3QmIGNvdmVyUmVjdCkKK3sK KyAgICBSZWdpb24gcmVnaW9uOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcmVjdHMuc2l6 ZSgpOyArK2kpCisgICAgICAgIHJlZ2lvbi51bml0ZShyZWN0c1tpXSk7CisKKyAgICByZXR1cm4g cmVnaW9uLmNvbnRhaW5zKGNvdmVyUmVjdCk7Cit9CisKK1RFU1QoUmVnaW9uQ29udGFpbnNUZXN0 LCBOb0ludGVyc2VjdGlvbikKK3sKKyAgICBWZWN0b3I8SW50UmVjdD4gcmVjdHM7CisgICAgcmVj dHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAwLCAxMDApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50 UmVjdCgxMDAsIDIwMCwgMTAwLCAxMDApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJl Y3RzLCBJbnRSZWN0KDEwMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVl cnkocmVjdHMsIEludFJlY3QoMCwgMTAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNl LCBxdWVyeShyZWN0cywgSW50UmVjdCgxMTAsIDExMCwgMTAsIDEwKSkpOworfQorCitURVNUKFJl Z2lvbkNvbnRhaW5zVGVzdCwgTm9Db3ZlcikKK3sKKyAgICBWZWN0b3I8SW50UmVjdD4gcmVjdHM7 CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBw ZW5kKEludFJlY3QoMCwgMTEsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnko cmVjdHMsIEludFJlY3QoMCwgMCwgMTAsIDIwKSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAg cmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKElu dFJlY3QoMTEsIDAsIDEwLCAxMCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMs IEludFJlY3QoMCwgMCwgMjAsIDEwKSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMu YXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3Qo MSwgMSwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVj dCgwLCAwLCAxMSwgMTEpKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQo SW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAxLCAx MCwgMTApKTsKKyAgICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAs IDExLCAxMSkpKTsKKyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0 KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDEsIDAsIDEwLCAxMCkp OworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTEsIDEx KSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwg MTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKEludFJlY3QoMSwgMSwgMTAsIDEwKSk7CisgICAg RVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAwLCAxMCwgMSkpKTsKKyAg ICBFWFBFQ1RfRVEoZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEsIDAsIDEwLCAyKSkpOwor ICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgxLCAxLCAxMCwgMikpKTsK KyAgICByZWN0cy5jbGVhcigpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDEsIDEsIDEwLCAx MCkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTIs IDEyKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMCwgMCwg MTEsIDExKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwg MSwgMTEsIDExKSkpOworfQorCitURVNUKFJlZ2lvbkNvbnRhaW5zVGVzdCwgQ292ZXIpCit7Cisg ICAgVmVjdG9yPEludFJlY3Q+IHJlY3RzOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAs IDEwLCAxMCkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCgwLCAw LCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEs IDEsIDgsIDgpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDEs IDEsIDksIDkpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAs IDAsIDksIDkpKSk7CisgICAgcmVjdHMuY2xlYXIoKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVj dCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTAp KTsKKyAgICByZWN0cy5hcHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICByZWN0cy5h cHBlbmQoSW50UmVjdCgwLCAwLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnko cmVjdHMsIEludFJlY3QoMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVy eShyZWN0cywgSW50UmVjdCgxLCAxLCA4LCA4KSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVy eShyZWN0cywgSW50UmVjdCgxLCAxLCA5LCA5KSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBxdWVy eShyZWN0cywgSW50UmVjdCgwLCAwLCA5LCA5KSkpOworICAgIHJlY3RzLmNsZWFyKCk7CisgICAg cmVjdHMuYXBwZW5kKEludFJlY3QoMCwgMCwgMTAsIDEwKSk7CisgICAgcmVjdHMuYXBwZW5kKElu dFJlY3QoNSwgNSwgMTAsIDEwKSk7CisgICAgRVhQRUNUX0VRKGZhbHNlLCBxdWVyeShyZWN0cywg SW50UmVjdCgwLCAwLCAxMCwgMTUpKSk7CisgICAgRVhQRUNUX0VRKHRydWUsIHF1ZXJ5KHJlY3Rz LCBJbnRSZWN0KDAsIDAsIDEwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVlcnkocmVj dHMsIEludFJlY3QoNSwgNSwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVlcnko cmVjdHMsIEludFJlY3QoMCwgNSwgMTUsIDEwKSkpOworICAgIEVYUEVDVF9FUShmYWxzZSwgcXVl cnkocmVjdHMsIEludFJlY3QoNSwgMCwgMTAsIDE1KSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBx dWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxMCwgMTApKSk7CisgICAgRVhQRUNUX0VRKGZhbHNl LCBxdWVyeShyZWN0cywgSW50UmVjdCg1LCA1LCAxNSwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRy dWUsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDUsIDAsIDUsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0 cnVlLCBxdWVyeShyZWN0cywgSW50UmVjdCg1LCAwLCA1LCAxNSkpKTsKKyAgICByZWN0cy5jbGVh cigpOworICAgIHJlY3RzLmFwcGVuZChJbnRSZWN0KDAsIDAsIDEwLCAxMCkpOworICAgIHJlY3Rz LmFwcGVuZChJbnRSZWN0KDEwLCAwLCAxMCwgMTApKTsKKyAgICBFWFBFQ1RfRVEodHJ1ZSwgcXVl cnkocmVjdHMsIEludFJlY3QoMCwgMCwgMTAsIDEwKSkpOworICAgIEVYUEVDVF9FUSh0cnVlLCBx dWVyeShyZWN0cywgSW50UmVjdCgwLCAwLCAxNSwgMTApKSk7CisgICAgRVhQRUNUX0VRKHRydWUs IHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDIwLCAxMCkpKTsKKyAgICBFWFBFQ1RfRVEoZmFs c2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDIwLCAxMSkpKTsKKyAgICBFWFBFQ1RfRVEo ZmFsc2UsIHF1ZXJ5KHJlY3RzLCBJbnRSZWN0KDAsIDAsIDIxLCAxMCkpKTsKKyAgICBFWFBFQ1Rf RVEodHJ1ZSwgcXVlcnkocmVjdHMsIEludFJlY3QoMSwgMSwgMTgsIDgpKSk7Cit9CisKK30gLy8g bmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv d2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQSS93aW4vVGVzdFdl YktpdEFQSS52Y3Byb2oKaW5kZXggNTBlYzA4MGFiZmJlM2JjM2IwNjk5OTk5OWI1NmYwZjcyM2Q3 ODE1Ny4uNTFlYzUxZGI5MDNiNWRkMWQ1OWY3NDgwMDUyNzRiNDI3MDZkM2FkNSAxMDA2NDQKLS0t IGEvVG9vbHMvVGVzdFdlYktpdEFQSS93aW4vVGVzdFdlYktpdEFQSS52Y3Byb2oKKysrIGIvVG9v bHMvVGVzdFdlYktpdEFQSS93aW4vVGVzdFdlYktpdEFQSS52Y3Byb2oKQEAgLTY0OSw2ICs2NDks MTQgQEAKIAkJCQk8L0ZpbGU+CiAJCQk8L0ZpbHRlcj4KIAkJCTxGaWx0ZXIKKwkJCQlOYW1lPSJX ZWJDb3JlIgorCQkJCT4KKwkJCQk8RmlsZQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXFRlc3RzXFdl YkNvcmVcUmVnaW9uQ29udGFpbnMuY3BwIgorCQkJCQk+CisJCQkJPC9GaWxlPgorCQkJPC9GaWx0 ZXI+CisJCQk8RmlsdGVyCiAJCQkJTmFtZT0iV2ViS2l0IgogCQkJCT4KIAkJCQk8RmlsdGVyCg== 115212 2011-11-15 11:49:58 -0800 2011-11-16 10:40:11 -0800 Patch bug-72294-20111115144957.patch text/plain 3246 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uMDZkOWIyMzhkODVkZGQwZTFiMzIyNWU0ZjNjMmJm YTJlYTFhNDQwYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTExLTE1ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlZ2lvbjo6Y29udGFpbnMpOiBBIGNvbnRhaW5zIEIgaWYgQS5pbnRlcnNlY3QoQikgPT0gQi4K KyAgICAgICAgKFdlYkNvcmU6OlJlZ2lvbjo6U2hhcGU6Om9wZXJhdG9yPT0pOiBUZXN0IGlmIHR3 byBzaGFwZXMgYXJlIGlkZW50aWNhbCAoc2FtZSBzcGFucy9zZWdtZW50cykuCisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmg6CisgICAgICAgIChXZWJDb3JlOjpSZWdpb246OlNw YW46Om9wZXJhdG9yIT0pOiBIZWxwZXIgZm9yIFNoYXBlOjpvcGVyYXRvcj09LgorCiAyMDExLTEx LTExICBOYXQgRHVjYSAgPG5kdWNhQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTaW5jZSBHcmFw aGljc0NvbnRleHQzRDo6bWFrZUNvbnRleHRDdXJyZW50IGNhbiBmYWlsLCByZXR1cm4gYm9vbC4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0Mjdj NmM5MWQyMTYwZWI3N2U4Mjc4N2FiMDlhZWY0MjFkNjYxMjcuLjZiMTE1MTk1NDFmNGRlYjFlYjll MmI2ZDAxNTc5ZGEwMzllYWYyMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL1JlZ2lvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvUmVnaW9uLmNwcApAQCAtNjUsNiArNjUsMjggQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6 cmVjdHMoKSBjb25zdAogICAgIHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246OmNvbnRh aW5zKGNvbnN0IFJlZ2lvbiYgcmVnaW9uKSBjb25zdAoreworICAgIHJldHVybiBXZWJDb3JlOjpp bnRlcnNlY3QocmVnaW9uLCAqdGhpcykubV9zaGFwZSA9PSByZWdpb24ubV9zaGFwZTsKK30KKwor Ym9vbCBSZWdpb246OlNoYXBlOjpvcGVyYXRvcj09KGNvbnN0IFNoYXBlJiBvdGhlcikKK3sKKyAg ICBpZiAobV9zcGFucy5zaXplKCkgIT0gb3RoZXIubV9zcGFucy5zaXplKCkpCisgICAgICAgIHJl dHVybiBmYWxzZTsKKyAgICBpZiAobV9zZWdtZW50cy5zaXplKCkgIT0gb3RoZXIubV9zZWdtZW50 cy5zaXplKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGZvciAoc2l6ZV90IGkgPSAw OyBpIDwgbV9zcGFucy5zaXplKCk7ICsraSkKKyAgICAgICAgaWYgKG1fc3BhbnNbaV0gIT0gb3Ro ZXIubV9zcGFuc1tpXSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBmb3IgKHNpemVf dCBpID0gMDsgaSA8IG1fc2VnbWVudHMuc2l6ZSgpOyArK2kpCisgICAgICAgIGlmIChtX3NlZ21l bnRzW2ldICE9IG90aGVyLm1fc2VnbWVudHNbaV0pCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7 CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogUmVnaW9uOjpTaGFwZTo6U2hhcGUoKQogewogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAppbmRleCBiNTM1OWJiZTM5 YzAyNWMzZTJjNWU1NWIzOWZhNGE1NzU3ZDc5NzVmLi5lZWFkNmJjMzE5MTMwNzg0YWVhZTc0MGQ3 NzJjYTBjNzRhNzhiOWQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9SZWdpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdp b24uaApAQCAtNDcsNiArNDcsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHRyYW5zbGF0ZShjb25z dCBJbnRTaXplJik7CiAKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhlIHF1ZXJ5IHJlZ2lvbiBp cyBhIHN1YnNldCBvZiB0aGlzIHJlZ2lvbi4KKyAgICBib29sIGNvbnRhaW5zKGNvbnN0IFJlZ2lv biYpIGNvbnN0OworCiAjaWZuZGVmIE5ERUJVRwogICAgIHZvaWQgZHVtcCgpIGNvbnN0OwogI2Vu ZGlmCkBAIC02MCw2ICs2Myw4IEBAIHByaXZhdGU6CiAKICAgICAgICAgaW50IHk7CiAgICAgICAg IHNpemVfdCBzZWdtZW50SW5kZXg7CisKKyAgICAgICAgaW5saW5lIGJvb2wgb3BlcmF0b3IhPShj b25zdCBTcGFuJiBvdGhlcikgeyByZXR1cm4geSAhPSBvdGhlci55IHx8IHNlZ21lbnRJbmRleCAh PSBvdGhlci5zZWdtZW50SW5kZXg7IH0KICAgICB9OwogCiAgICAgY2xhc3MgU2hhcGUgewpAQCAt ODUsNiArOTAsOCBAQCBwcml2YXRlOgogICAgICAgICB2b2lkIHRyYW5zbGF0ZShjb25zdCBJbnRT aXplJik7CiAgICAgICAgIHZvaWQgc3dhcChTaGFwZSYpOwogCisgICAgICAgIGJvb2wgb3BlcmF0 b3I9PShjb25zdCBTaGFwZSYgb3RoZXIpOworCiAjaWZuZGVmIE5ERUJVRwogICAgICAgICB2b2lk IGR1bXAoKSBjb25zdDsKICNlbmRpZgpAQCAtMTA0LDkgKzExMSw4IEBAIHByaXZhdGU6CiAKICAg ICAgICAgYm9vbCBjYW5Db2FsZXNjZShTZWdtZW50SXRlcmF0b3IgYmVnaW4sIFNlZ21lbnRJdGVy YXRvciBlbmQpOwogCi0gICAgICAgIC8vIEZJWE1FOiBUaGVzZSB2ZWN0b3JzIHNob3VsZCBoYXZl IGlubGluZSBzaXplcy4gRmlndXJlIG91dCBhIGdvb2Qgb3B0aW1hbCB2YWx1ZS4KLSAgICAgICAg VmVjdG9yPGludD4gbV9zZWdtZW50czsKLSAgICAgICAgVmVjdG9yPFNwYW4+IG1fc3BhbnM7ICAg ICAgICAKKyAgICAgICAgVmVjdG9yPGludCwgMzI+IG1fc2VnbWVudHM7CisgICAgICAgIFZlY3Rv cjxTcGFuLCAxNj4gbV9zcGFuczsKICAgICB9OwogCiAgICAgSW50UmVjdCBtX2JvdW5kczsK 115406 2011-11-16 10:40:19 -0800 2011-11-16 11:02:26 -0800 Patch bug-72294-20111116134017.patch text/plain 2963 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uZTE0MmE0YTI1NGMzNzI2YzFhOGEyMWYwMWY2ZDIy MDU5ZDYxYWY0ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDExLTExLTE2ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvUmVnaW9uLmg6CisgICAgICAgIChXZWJDb3JlOjpSZWdpb246OmNvbnRhaW5zKTogQSBjb250 YWlucyBCIGlmIEEuaW50ZXJzZWN0KEIpID09IEIuCisgICAgICAgIChXZWJDb3JlOjpvcGVyYXRv cj09KTogQ29tcGFyYXRvcnMgZm9yIHRlc3RpbmcgUmVnaW9uOjpTaGFwZSBhbmQgUmVnaW9uOjpT cGFuLCBmb3IgY29udGFpbnMoKQorICAgICAgICAoV2ViQ29yZTo6b3BlcmF0b3IhPSk6IENvbXBh cmF0b3JzIGZvciB0ZXN0aW5nIFJlZ2lvbjo6U2hhcGUgYW5kIFJlZ2lvbjo6U3BhbiwgZm9yIGNv bnRhaW5zKCkKKwogMjAxMS0xMS0xMSAgTmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgU2luY2UgR3JhcGhpY3NDb250ZXh0M0Q6Om1ha2VDb250ZXh0Q3VycmVudCBjYW4g ZmFpbCwgcmV0dXJuIGJvb2wuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9SZWdpb24uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lv bi5oCmluZGV4IGI1MzU5YmJlMzljMDI1YzNlMmM1ZTU1YjM5ZmE0YTU3NTdkNzk3NWYuLjU1MDI3 MTdhNTI4YmNlZGEwYWE3NjMzY2Q3OWQ0NzQ1NDdlMjcwMTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oCkBAIC00Nyw2ICs0Nyw5IEBAIHB1YmxpYzoKIAogICAg IHZvaWQgdHJhbnNsYXRlKGNvbnN0IEludFNpemUmKTsKIAorICAgIC8vIFJldHVybnMgdHJ1ZSBp ZiB0aGUgcXVlcnkgcmVnaW9uIGlzIGEgc3Vic2V0IG9mIHRoaXMgcmVnaW9uLgorICAgIGJvb2wg Y29udGFpbnMoY29uc3QgUmVnaW9uJikgY29uc3QgeyByZXR1cm4gV2ViQ29yZTo6aW50ZXJzZWN0 KHJlZ2lvbiwgKnRoaXMpLm1fc2hhcGUgPT0gcmVnaW9uLm1fc2hhcGU7IH0KKwogI2lmbmRlZiBO REVCVUcKICAgICB2b2lkIGR1bXAoKSBjb25zdDsKICNlbmRpZgpAQCAtMTA0LDEzICsxMDcsMjAg QEAgcHJpdmF0ZToKIAogICAgICAgICBib29sIGNhbkNvYWxlc2NlKFNlZ21lbnRJdGVyYXRvciBi ZWdpbiwgU2VnbWVudEl0ZXJhdG9yIGVuZCk7CiAKLSAgICAgICAgLy8gRklYTUU6IFRoZXNlIHZl Y3RvcnMgc2hvdWxkIGhhdmUgaW5saW5lIHNpemVzLiBGaWd1cmUgb3V0IGEgZ29vZCBvcHRpbWFs IHZhbHVlLgotICAgICAgICBWZWN0b3I8aW50PiBtX3NlZ21lbnRzOwotICAgICAgICBWZWN0b3I8 U3Bhbj4gbV9zcGFuczsgICAgICAgIAorICAgICAgICBWZWN0b3I8aW50LCAzMj4gbV9zZWdtZW50 czsKKyAgICAgICAgVmVjdG9yPFNwYW4sIDE2PiBtX3NwYW5zOworCisgICAgICAgIGZyaWVuZCBi b29sIG9wZXJhdG9yPT0oY29uc3QgU2hhcGUmLCBjb25zdCBTaGFwZSYpOworICAgICAgICBmcmll bmQgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFNoYXBlJiwgY29uc3QgU2hhcGUmKTsKICAgICB9Owog CiAgICAgSW50UmVjdCBtX2JvdW5kczsKICAgICBTaGFwZSBtX3NoYXBlOworCisgICAgZnJpZW5k IGJvb2wgb3BlcmF0b3I9PShjb25zdCBTaGFwZSYsIGNvbnN0IFNoYXBlJik7CisgICAgZnJpZW5k IGJvb2wgb3BlcmF0b3IhPShjb25zdCBTaGFwZSYsIGNvbnN0IFNoYXBlJik7CisgICAgZnJpZW5k IGJvb2wgb3BlcmF0b3I9PShjb25zdCBTcGFuJiwgY29uc3QgU3BhbiYpOworICAgIGZyaWVuZCBi b29sIG9wZXJhdG9yIT0oY29uc3QgU3BhbiYsIGNvbnN0IFNwYW4mKTsKIH07CiAKIHN0YXRpYyBp bmxpbmUgUmVnaW9uIGludGVyc2VjdChjb25zdCBSZWdpb24mIGEsIGNvbnN0IFJlZ2lvbiYgYikK QEAgLTEzNyw2ICsxNDcsMTIgQEAgc3RhdGljIGlubGluZSBSZWdpb24gdHJhbnNsYXRlKGNvbnN0 IFJlZ2lvbiYgcmVnaW9uLCBjb25zdCBJbnRTaXplJiBvZmZzZXQpCiAgICAgcmV0dXJuIHJlc3Vs dDsKIH0KIAoraW5saW5lIGJvb2wgb3BlcmF0b3I9PShjb25zdCBSZWdpb246OlNwYW4mIGEsIGNv bnN0IFJlZ2lvbjo6U3BhbiYgYikgeyByZXR1cm4gYS55ID09IGIueSAmJiBhLnNlZ21lbnRJbmRl eCA9PSBiLnNlZ21lbnRJbmRleDsgfQoraW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBSZWdp b246OlNwYW4mIGEsIGNvbnN0IFJlZ2lvbjo6U3BhbiYgYikgeyByZXR1cm4gIShhID09IGIpOyB9 CisKK2lubGluZSBib29sIG9wZXJhdG9yPT0oY29uc3QgUmVnaW9uOjpTaGFwZSYgYSwgY29uc3Qg UmVnaW9uOjpTaGFwZSYgYikgeyByZXR1cm4gYS5tX3NwYW5zID09IGIubV9zcGFucyAmJiBhLm1f c2VnbWVudHMgPT0gYi5tX3NlZ21lbnRzOyB9CitpbmxpbmUgYm9vbCBvcGVyYXRvciE9KGNvbnN0 IFJlZ2lvbjo6U2hhcGUmIGEsIGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGIpIHsgcmV0dXJuICEoYSA9 PSBiKTsgfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBSZWdpb25faAo= 115410 2011-11-16 11:02:34 -0800 2011-11-18 08:14:49 -0800 Patch bug-72294-20111116140233.patch text/plain 3441 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uOGEyY2RhYWZkZTEzNWJlNmMyMWEyYmViOTkwZTVm OTZlMzE3OTI1MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTExLTE2ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlZ2lvbjo6Y29udGFpbnMpOiBBIGNvbnRhaW5zIEIgaWYgQS5pbnRlcnNlY3QoQikgPT0gQgor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oOgorICAgICAgICAoV2ViQ29yZTo6 b3BlcmF0b3I9PSk6IENvbXBhcmF0b3JzIGZvciB0ZXN0aW5nIFJlZ2lvbjo6U2hhcGUgYW5kIFJl Z2lvbjo6U3BhbiwgZm9yIGNvbnRhaW5zKCkKKyAgICAgICAgKFdlYkNvcmU6Om9wZXJhdG9yIT0p OiBDb21wYXJhdG9ycyBmb3IgdGVzdGluZyBSZWdpb246OlNoYXBlIGFuZCBSZWdpb246OlNwYW4s IGZvciBjb250YWlucygpCisKIDIwMTEtMTEtMTEgIE5hdCBEdWNhICA8bmR1Y2FAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFNpbmNlIEdyYXBoaWNzQ29udGV4dDNEOjptYWtlQ29udGV4dEN1cnJl bnQgY2FuIGZhaWwsIHJldHVybiBib29sLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL1JlZ2lvbi5jcHAKaW5kZXggNTQyN2M2YzkxZDIxNjBlYjc3ZTgyNzg3YWIwOWFlZjQyMWQ2 NjEyNy4uNTNlZmJhNWIwNWNjZGJjMTYwMjJkYTM3MTNkMGQ2YjliNDU0MDVmNiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCkBAIC02NSw2ICs2NSwxMSBA QCBWZWN0b3I8SW50UmVjdD4gUmVnaW9uOjpyZWN0cygpIGNvbnN0CiAgICAgcmV0dXJuIHJlY3Rz OwogfQogCitib29sIFJlZ2lvbjo6Y29udGFpbnMoY29uc3QgUmVnaW9uJiByZWdpb24pIGNvbnN0 Cit7CisgICAgcmV0dXJuIFdlYkNvcmU6OmludGVyc2VjdChyZWdpb24sICp0aGlzKS5tX3NoYXBl ID09IHJlZ2lvbi5tX3NoYXBlOworfQorCiBSZWdpb246OlNoYXBlOjpTaGFwZSgpCiB7CiB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oCmluZGV4IGI1MzU5YmJlMzlj MDI1YzNlMmM1ZTU1YjM5ZmE0YTU3NTdkNzk3NWYuLmY4ZWZmODgxYzMzZjJkYzIwYmY0YmRmNjlk NTQ2ZTNjMmFjMzMwN2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL1JlZ2lvbi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lv bi5oCkBAIC00Nyw2ICs0Nyw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgdHJhbnNsYXRlKGNvbnN0 IEludFNpemUmKTsKIAorICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgcXVlcnkgcmVnaW9uIGlz IGEgc3Vic2V0IG9mIHRoaXMgcmVnaW9uLgorICAgIGJvb2wgY29udGFpbnMoY29uc3QgUmVnaW9u JikgY29uc3Q7CisKICNpZm5kZWYgTkRFQlVHCiAgICAgdm9pZCBkdW1wKCkgY29uc3Q7CiAjZW5k aWYKQEAgLTEwNCwxMyArMTA3LDIwIEBAIHByaXZhdGU6CiAKICAgICAgICAgYm9vbCBjYW5Db2Fs ZXNjZShTZWdtZW50SXRlcmF0b3IgYmVnaW4sIFNlZ21lbnRJdGVyYXRvciBlbmQpOwogCi0gICAg ICAgIC8vIEZJWE1FOiBUaGVzZSB2ZWN0b3JzIHNob3VsZCBoYXZlIGlubGluZSBzaXplcy4gRmln dXJlIG91dCBhIGdvb2Qgb3B0aW1hbCB2YWx1ZS4KLSAgICAgICAgVmVjdG9yPGludD4gbV9zZWdt ZW50czsKLSAgICAgICAgVmVjdG9yPFNwYW4+IG1fc3BhbnM7ICAgICAgICAKKyAgICAgICAgVmVj dG9yPGludCwgMzI+IG1fc2VnbWVudHM7CisgICAgICAgIFZlY3RvcjxTcGFuLCAxNj4gbV9zcGFu czsKKworICAgICAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNoYXBlJiwgY29uc3Qg U2hhcGUmKTsKKyAgICAgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3IhPShjb25zdCBTaGFwZSYsIGNv bnN0IFNoYXBlJik7CiAgICAgfTsKIAogICAgIEludFJlY3QgbV9ib3VuZHM7CiAgICAgU2hhcGUg bV9zaGFwZTsKKworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgU2hhcGUmLCBjb25z dCBTaGFwZSYpOworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yIT0oY29uc3QgU2hhcGUmLCBjb25z dCBTaGFwZSYpOworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgU3BhbiYsIGNvbnN0 IFNwYW4mKTsKKyAgICBmcmllbmQgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFNwYW4mLCBjb25zdCBT cGFuJik7CiB9OwogCiBzdGF0aWMgaW5saW5lIFJlZ2lvbiBpbnRlcnNlY3QoY29uc3QgUmVnaW9u JiBhLCBjb25zdCBSZWdpb24mIGIpCkBAIC0xMzcsNiArMTQ3LDEyIEBAIHN0YXRpYyBpbmxpbmUg UmVnaW9uIHRyYW5zbGF0ZShjb25zdCBSZWdpb24mIHJlZ2lvbiwgY29uc3QgSW50U2l6ZSYgb2Zm c2V0KQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKK2lubGluZSBib29sIG9wZXJhdG9yPT0oY29u c3QgUmVnaW9uOjpTcGFuJiBhLCBjb25zdCBSZWdpb246OlNwYW4mIGIpIHsgcmV0dXJuIGEueSA9 PSBiLnkgJiYgYS5zZWdtZW50SW5kZXggPT0gYi5zZWdtZW50SW5kZXg7IH0KK2lubGluZSBib29s IG9wZXJhdG9yIT0oY29uc3QgUmVnaW9uOjpTcGFuJiBhLCBjb25zdCBSZWdpb246OlNwYW4mIGIp IHsgcmV0dXJuICEoYSA9PSBiKTsgfQorCitpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFJl Z2lvbjo6U2hhcGUmIGEsIGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGIpIHsgcmV0dXJuIGEubV9zcGFu cyA9PSBiLm1fc3BhbnMgJiYgYS5tX3NlZ21lbnRzID09IGIubV9zZWdtZW50czsgfQoraW5saW5l IGJvb2wgb3BlcmF0b3IhPShjb25zdCBSZWdpb246OlNoYXBlJiBhLCBjb25zdCBSZWdpb246OlNo YXBlJiBiKSB7IHJldHVybiAhKGEgPT0gYik7IH0KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQog CiAjZW5kaWYgLy8gUmVnaW9uX2gK 115812 2011-11-18 08:14:58 -0800 2011-11-18 08:39:03 -0800 Patch bug-72294-20111118111456.patch text/plain 3336 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uNTgwYjM5M2ZmYWRhMzkxZmFkMDgzYzM5YjA4Yjkx OTZmNzFmZjBlNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDExLTExLTE4ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvUmVnaW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlZ2lvbjo6Y29udGFpbnMpOiBBIGNv bnRhaW5zIEIgPD0+IEEuaW50ZXJzZWN0KEIpID09IEIKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9SZWdpb24uaDoKKyAgICAgICAgKFdlYkNvcmU6Om9wZXJhdG9yPT0pOiBIZWxwZXIgZnVu Y3Rpb25zIGZvciBjb250YWlucygpCisgICAgICAgIChXZWJDb3JlOjpvcGVyYXRvciE9KTogSGVs cGVyIGZ1bmN0aW9ucyBmb3IgY29udGFpbnMoKQorCiAyMDExLTExLTExICBOYXQgRHVjYSAgPG5k dWNhQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTaW5jZSBHcmFwaGljc0NvbnRleHQzRDo6bWFr ZUNvbnRleHRDdXJyZW50IGNhbiBmYWlsLCByZXR1cm4gYm9vbC4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0MjdjNmM5MWQyMTYwZWI3N2U4Mjc4 N2FiMDlhZWY0MjFkNjYxMjcuLjUzZWZiYTViMDVjY2RiYzE2MDIyZGEzNzEzZDBkNmI5YjQ1NDA1 ZjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcApAQCAt NjUsNiArNjUsMTEgQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6cmVjdHMoKSBjb25zdAogICAg IHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246OmNvbnRhaW5zKGNvbnN0IFJlZ2lvbiYg cmVnaW9uKSBjb25zdAoreworICAgIHJldHVybiBXZWJDb3JlOjppbnRlcnNlY3QocmVnaW9uLCAq dGhpcykubV9zaGFwZSA9PSByZWdpb24ubV9zaGFwZTsKK30KKwogUmVnaW9uOjpTaGFwZTo6U2hh cGUoKQogewogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv UmVnaW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAppbmRl eCBiNTM1OWJiZTM5YzAyNWMzZTJjNWU1NWIzOWZhNGE1NzU3ZDc5NzVmLi40ZmUzNmVjNjMxY2Ez NTJjNzZiNGJkZmVhNTllZWUzMDFjZjg3NmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9SZWdpb24uaApAQCAtNDcsNiArNDcsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHRy YW5zbGF0ZShjb25zdCBJbnRTaXplJik7CiAKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhlIHF1 ZXJ5IHJlZ2lvbiBpcyBhIHN1YnNldCBvZiB0aGlzIHJlZ2lvbi4KKyAgICBib29sIGNvbnRhaW5z KGNvbnN0IFJlZ2lvbiYpIGNvbnN0OworCiAjaWZuZGVmIE5ERUJVRwogICAgIHZvaWQgZHVtcCgp IGNvbnN0OwogI2VuZGlmCkBAIC0xMDQsMTMgKzEwNywxOSBAQCBwcml2YXRlOgogCiAgICAgICAg IGJvb2wgY2FuQ29hbGVzY2UoU2VnbWVudEl0ZXJhdG9yIGJlZ2luLCBTZWdtZW50SXRlcmF0b3Ig ZW5kKTsKIAotICAgICAgICAvLyBGSVhNRTogVGhlc2UgdmVjdG9ycyBzaG91bGQgaGF2ZSBpbmxp bmUgc2l6ZXMuIEZpZ3VyZSBvdXQgYSBnb29kIG9wdGltYWwgdmFsdWUuCi0gICAgICAgIFZlY3Rv cjxpbnQ+IG1fc2VnbWVudHM7Ci0gICAgICAgIFZlY3RvcjxTcGFuPiBtX3NwYW5zOyAgICAgICAg CisgICAgICAgIFZlY3RvcjxpbnQsIDMyPiBtX3NlZ21lbnRzOworICAgICAgICBWZWN0b3I8U3Bh biwgMTY+IG1fc3BhbnM7CisKKyAgICAgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBT aGFwZSYsIGNvbnN0IFNoYXBlJik7CiAgICAgfTsKIAogICAgIEludFJlY3QgbV9ib3VuZHM7CiAg ICAgU2hhcGUgbV9zaGFwZTsKKworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgU2hh cGUmLCBjb25zdCBTaGFwZSYpOworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yIT0oY29uc3QgU2hh cGUmLCBjb25zdCBTaGFwZSYpOworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgU3Bh biYsIGNvbnN0IFNwYW4mKTsKKyAgICBmcmllbmQgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFNwYW4m LCBjb25zdCBTcGFuJik7CiB9OwogCiBzdGF0aWMgaW5saW5lIFJlZ2lvbiBpbnRlcnNlY3QoY29u c3QgUmVnaW9uJiBhLCBjb25zdCBSZWdpb24mIGIpCkBAIC0xMzcsNiArMTQ2LDEyIEBAIHN0YXRp YyBpbmxpbmUgUmVnaW9uIHRyYW5zbGF0ZShjb25zdCBSZWdpb24mIHJlZ2lvbiwgY29uc3QgSW50 U2l6ZSYgb2Zmc2V0KQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKK2lubGluZSBib29sIG9wZXJh dG9yPT0oY29uc3QgUmVnaW9uOjpTcGFuJiBhLCBjb25zdCBSZWdpb246OlNwYW4mIGIpIHsgcmV0 dXJuIGEueSA9PSBiLnkgJiYgYS5zZWdtZW50SW5kZXggPT0gYi5zZWdtZW50SW5kZXg7IH0KK2lu bGluZSBib29sIG9wZXJhdG9yIT0oY29uc3QgUmVnaW9uOjpTcGFuJiBhLCBjb25zdCBSZWdpb246 OlNwYW4mIGIpIHsgcmV0dXJuICEoYSA9PSBiKTsgfQorCitpbmxpbmUgYm9vbCBvcGVyYXRvcj09 KGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGEsIGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGIpIHsgcmV0dXJu IGEubV9zcGFucyA9PSBiLm1fc3BhbnMgJiYgYS5tX3NlZ21lbnRzID09IGIubV9zZWdtZW50czsg fQoraW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBSZWdpb246OlNoYXBlJiBhLCBjb25zdCBS ZWdpb246OlNoYXBlJiBiKSB7IHJldHVybiAhKGEgPT0gYik7IH0KKwogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQogCiAjZW5kaWYgLy8gUmVnaW9uX2gK 115818 2011-11-18 08:39:12 -0800 2012-01-31 10:19:13 -0800 fixed ChangeLog bug-72294-20111118113911.patch text/plain 3303 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdhODNlMmM0NTczNzU4 ZTE0NjFhZGQ2ODU1YWQzNzE2OGVkYzE3MC4uNGIwZTNkY2U1NjNhZmQzNzY4MGEzNDQzNTJhYjFi NzE2ZjNjNDcyMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDExLTExLTE4ICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlZ2lvbjo6Y29udGFpbnMpOiBBIGNvbnRhaW5zIEIgPD0+IEEuaW50ZXJzZWN0KEIpID09IEIK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaDoKKyAgICAgICAgKFdlYkNvcmU6 Om9wZXJhdG9yPT0pOiBIZWxwZXIgZnVuY3Rpb25zIGZvciBjb250YWlucygpCisgICAgICAgIChX ZWJDb3JlOjpvcGVyYXRvciE9KTogSGVscGVyIGZ1bmN0aW9ucyBmb3IgY29udGFpbnMoKQorCiAy MDExLTExLTExICBOYXQgRHVjYSAgPG5kdWNhQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTaW5j ZSBHcmFwaGljc0NvbnRleHQzRDo6bWFrZUNvbnRleHRDdXJyZW50IGNhbiBmYWlsLCByZXR1cm4g Ym9vbC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lv bi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4 IDU0MjdjNmM5MWQyMTYwZWI3N2U4Mjc4N2FiMDlhZWY0MjFkNjYxMjcuLjUzZWZiYTViMDVjY2Ri YzE2MDIyZGEzNzEzZDBkNmI5YjQ1NDA1ZjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvUmVnaW9uLmNwcApAQCAtNjUsNiArNjUsMTEgQEAgVmVjdG9yPEludFJlY3Q+IFJl Z2lvbjo6cmVjdHMoKSBjb25zdAogICAgIHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246 OmNvbnRhaW5zKGNvbnN0IFJlZ2lvbiYgcmVnaW9uKSBjb25zdAoreworICAgIHJldHVybiBXZWJD b3JlOjppbnRlcnNlY3QocmVnaW9uLCAqdGhpcykubV9zaGFwZSA9PSByZWdpb24ubV9zaGFwZTsK K30KKwogUmVnaW9uOjpTaGFwZTo6U2hhcGUoKQogewogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9SZWdpb24uaAppbmRleCBiNTM1OWJiZTM5YzAyNWMzZTJjNWU1NWIzOWZhNGE1 NzU3ZDc5NzVmLi40ZmUzNmVjNjMxY2EzNTJjNzZiNGJkZmVhNTllZWUzMDFjZjg3NmZjIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaApAQCAtNDcsNiArNDcsOSBA QCBwdWJsaWM6CiAKICAgICB2b2lkIHRyYW5zbGF0ZShjb25zdCBJbnRTaXplJik7CiAKKyAgICAv LyBSZXR1cm5zIHRydWUgaWYgdGhlIHF1ZXJ5IHJlZ2lvbiBpcyBhIHN1YnNldCBvZiB0aGlzIHJl Z2lvbi4KKyAgICBib29sIGNvbnRhaW5zKGNvbnN0IFJlZ2lvbiYpIGNvbnN0OworCiAjaWZuZGVm IE5ERUJVRwogICAgIHZvaWQgZHVtcCgpIGNvbnN0OwogI2VuZGlmCkBAIC0xMDQsMTMgKzEwNywx OSBAQCBwcml2YXRlOgogCiAgICAgICAgIGJvb2wgY2FuQ29hbGVzY2UoU2VnbWVudEl0ZXJhdG9y IGJlZ2luLCBTZWdtZW50SXRlcmF0b3IgZW5kKTsKIAotICAgICAgICAvLyBGSVhNRTogVGhlc2Ug dmVjdG9ycyBzaG91bGQgaGF2ZSBpbmxpbmUgc2l6ZXMuIEZpZ3VyZSBvdXQgYSBnb29kIG9wdGlt YWwgdmFsdWUuCi0gICAgICAgIFZlY3RvcjxpbnQ+IG1fc2VnbWVudHM7Ci0gICAgICAgIFZlY3Rv cjxTcGFuPiBtX3NwYW5zOyAgICAgICAgCisgICAgICAgIFZlY3RvcjxpbnQsIDMyPiBtX3NlZ21l bnRzOworICAgICAgICBWZWN0b3I8U3BhbiwgMTY+IG1fc3BhbnM7CisKKyAgICAgICAgZnJpZW5k IGJvb2wgb3BlcmF0b3I9PShjb25zdCBTaGFwZSYsIGNvbnN0IFNoYXBlJik7CiAgICAgfTsKIAog ICAgIEludFJlY3QgbV9ib3VuZHM7CiAgICAgU2hhcGUgbV9zaGFwZTsKKworICAgIGZyaWVuZCBi b29sIG9wZXJhdG9yPT0oY29uc3QgU2hhcGUmLCBjb25zdCBTaGFwZSYpOworICAgIGZyaWVuZCBi b29sIG9wZXJhdG9yIT0oY29uc3QgU2hhcGUmLCBjb25zdCBTaGFwZSYpOworICAgIGZyaWVuZCBi b29sIG9wZXJhdG9yPT0oY29uc3QgU3BhbiYsIGNvbnN0IFNwYW4mKTsKKyAgICBmcmllbmQgYm9v bCBvcGVyYXRvciE9KGNvbnN0IFNwYW4mLCBjb25zdCBTcGFuJik7CiB9OwogCiBzdGF0aWMgaW5s aW5lIFJlZ2lvbiBpbnRlcnNlY3QoY29uc3QgUmVnaW9uJiBhLCBjb25zdCBSZWdpb24mIGIpCkBA IC0xMzcsNiArMTQ2LDEyIEBAIHN0YXRpYyBpbmxpbmUgUmVnaW9uIHRyYW5zbGF0ZShjb25zdCBS ZWdpb24mIHJlZ2lvbiwgY29uc3QgSW50U2l6ZSYgb2Zmc2V0KQogICAgIHJldHVybiByZXN1bHQ7 CiB9CiAKK2lubGluZSBib29sIG9wZXJhdG9yPT0oY29uc3QgUmVnaW9uOjpTcGFuJiBhLCBjb25z dCBSZWdpb246OlNwYW4mIGIpIHsgcmV0dXJuIGEueSA9PSBiLnkgJiYgYS5zZWdtZW50SW5kZXgg PT0gYi5zZWdtZW50SW5kZXg7IH0KK2lubGluZSBib29sIG9wZXJhdG9yIT0oY29uc3QgUmVnaW9u OjpTcGFuJiBhLCBjb25zdCBSZWdpb246OlNwYW4mIGIpIHsgcmV0dXJuICEoYSA9PSBiKTsgfQor CitpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGEsIGNvbnN0IFJl Z2lvbjo6U2hhcGUmIGIpIHsgcmV0dXJuIGEubV9zcGFucyA9PSBiLm1fc3BhbnMgJiYgYS5tX3Nl Z21lbnRzID09IGIubV9zZWdtZW50czsgfQoraW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBS ZWdpb246OlNoYXBlJiBhLCBjb25zdCBSZWdpb246OlNoYXBlJiBiKSB7IHJldHVybiAhKGEgPT0g Yik7IH0KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gUmVnaW9uX2gK 124767 2012-01-31 10:19:23 -0800 2012-01-31 14:29:16 -0800 Patch bug-72294-20120131131921.patch text/plain 2921 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2MzY4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGIyZTkwZjk1MTI3ZmYz M2ZkOTFkOTk2YTA2OWQyMzM4NGM5MjhjOS4uNGI4ZDIyNDlkNzg3YzVlNjRmM2FjMTZhMzNjOWVl MmYxNThkMjAxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTAxLTMxICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlZ2lvbjo6Y29udGFpbnMpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvUmVnaW9uLmg6CisgICAgICAgIChSZWdpb24pOgorICAgICAgICAoU2hhcGUp OgorICAgICAgICAoV2ViQ29yZTo6b3BlcmF0b3I9PSk6CisgICAgICAgIChXZWJDb3JlKToKKwog MjAxMi0wMS0zMSAgQWxleGlzIE1lbmFyZCAgPGFsZXhpcy5tZW5hcmRAb3BlbmJvc3NhLm9yZz4K IAogICAgICAgICBVbnJldmlld2VkIGluY2x1ZGUgY2xlYW51cC4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0MjdjNmM5MWQyMTYwZWI3N2U4Mjc4 N2FiMDlhZWY0MjFkNjYxMjcuLjUzZWZiYTViMDVjY2RiYzE2MDIyZGEzNzEzZDBkNmI5YjQ1NDA1 ZjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcApAQCAt NjUsNiArNjUsMTEgQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6cmVjdHMoKSBjb25zdAogICAg IHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246OmNvbnRhaW5zKGNvbnN0IFJlZ2lvbiYg cmVnaW9uKSBjb25zdAoreworICAgIHJldHVybiBXZWJDb3JlOjppbnRlcnNlY3QocmVnaW9uLCAq dGhpcykubV9zaGFwZSA9PSByZWdpb24ubV9zaGFwZTsKK30KKwogUmVnaW9uOjpTaGFwZTo6U2hh cGUoKQogewogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv UmVnaW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAppbmRl eCBiNTM1OWJiZTM5YzAyNWMzZTJjNWU1NWIzOWZhNGE1NzU3ZDc5NzVmLi40YmNkMTg4NDA1NGFl MjU2N2U1NTc5MjA0MGYwMzA5YTI3OWFhZmY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9SZWdpb24uaApAQCAtNDcsNiArNDcsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHRy YW5zbGF0ZShjb25zdCBJbnRTaXplJik7CiAKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhlIHF1 ZXJ5IHJlZ2lvbiBpcyBhIHN1YnNldCBvZiB0aGlzIHJlZ2lvbi4KKyAgICBib29sIGNvbnRhaW5z KGNvbnN0IFJlZ2lvbiYpIGNvbnN0OworCiAjaWZuZGVmIE5ERUJVRwogICAgIHZvaWQgZHVtcCgp IGNvbnN0OwogI2VuZGlmCkBAIC0xMDQsMTMgKzEwNywxNyBAQCBwcml2YXRlOgogCiAgICAgICAg IGJvb2wgY2FuQ29hbGVzY2UoU2VnbWVudEl0ZXJhdG9yIGJlZ2luLCBTZWdtZW50SXRlcmF0b3Ig ZW5kKTsKIAotICAgICAgICAvLyBGSVhNRTogVGhlc2UgdmVjdG9ycyBzaG91bGQgaGF2ZSBpbmxp bmUgc2l6ZXMuIEZpZ3VyZSBvdXQgYSBnb29kIG9wdGltYWwgdmFsdWUuCi0gICAgICAgIFZlY3Rv cjxpbnQ+IG1fc2VnbWVudHM7Ci0gICAgICAgIFZlY3RvcjxTcGFuPiBtX3NwYW5zOyAgICAgICAg CisgICAgICAgIFZlY3RvcjxpbnQsIDMyPiBtX3NlZ21lbnRzOworICAgICAgICBWZWN0b3I8U3Bh biwgMTY+IG1fc3BhbnM7CisKKyAgICAgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBT aGFwZSYsIGNvbnN0IFNoYXBlJik7CiAgICAgfTsKIAogICAgIEludFJlY3QgbV9ib3VuZHM7CiAg ICAgU2hhcGUgbV9zaGFwZTsKKworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgU2hh cGUmLCBjb25zdCBTaGFwZSYpOworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgU3Bh biYsIGNvbnN0IFNwYW4mKTsKIH07CiAKIHN0YXRpYyBpbmxpbmUgUmVnaW9uIGludGVyc2VjdChj b25zdCBSZWdpb24mIGEsIGNvbnN0IFJlZ2lvbiYgYikKQEAgLTEzNyw2ICsxNDQsOSBAQCBzdGF0 aWMgaW5saW5lIFJlZ2lvbiB0cmFuc2xhdGUoY29uc3QgUmVnaW9uJiByZWdpb24sIGNvbnN0IElu dFNpemUmIG9mZnNldCkKICAgICByZXR1cm4gcmVzdWx0OwogfQogCitpbmxpbmUgYm9vbCBvcGVy YXRvcj09KGNvbnN0IFJlZ2lvbjo6U3BhbiYgYSwgY29uc3QgUmVnaW9uOjpTcGFuJiBiKSB7IHJl dHVybiBhLnkgPT0gYi55ICYmIGEuc2VnbWVudEluZGV4ID09IGIuc2VnbWVudEluZGV4OyB9Citp bmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGEsIGNvbnN0IFJlZ2lv bjo6U2hhcGUmIGIpIHsgcmV0dXJuIGEubV9zcGFucyA9PSBiLm1fc3BhbnMgJiYgYS5tX3NlZ21l bnRzID09IGIubV9zZWdtZW50czsgfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRp ZiAvLyBSZWdpb25faAo= 124822 2012-01-31 14:29:21 -0800 2012-02-06 12:56:27 -0800 Patch bug-72294-20120131172920.patch text/plain 3111 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2MzY4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGIyZTkwZjk1MTI3ZmYz M2ZkOTFkOTk2YTA2OWQyMzM4NGM5MjhjOS4uNGI4ZDIyNDlkNzg3YzVlNjRmM2FjMTZhMzNjOWVl MmYxNThkMjAxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTAxLTMxICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlZ2lvbjo6Y29udGFpbnMpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvUmVnaW9uLmg6CisgICAgICAgIChSZWdpb24pOgorICAgICAgICAoU2hhcGUp OgorICAgICAgICAoV2ViQ29yZTo6b3BlcmF0b3I9PSk6CisgICAgICAgIChXZWJDb3JlKToKKwog MjAxMi0wMS0zMSAgQWxleGlzIE1lbmFyZCAgPGFsZXhpcy5tZW5hcmRAb3BlbmJvc3NhLm9yZz4K IAogICAgICAgICBVbnJldmlld2VkIGluY2x1ZGUgY2xlYW51cC4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0MjdjNmM5MWQyMTYwZWI3N2U4Mjc4 N2FiMDlhZWY0MjFkNjYxMjcuLjczZTZkZGNmNWQxNDcyMzY3Yzg5OTBmNjA3MTYyMzU5ZThhYWI2 NDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcApAQCAt NjUsNiArNjUsMTEgQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6cmVjdHMoKSBjb25zdAogICAg IHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246OmNvbnRhaW5zKGNvbnN0IFJlZ2lvbiYg cmVnaW9uKSBjb25zdAoreworICAgIHJldHVybiBXZWJDb3JlOjppbnRlcnNlY3QocmVnaW9uLCAq dGhpcykgPT0gcmVnaW9uOworfQorCiBSZWdpb246OlNoYXBlOjpTaGFwZSgpCiB7CiB9CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oCmluZGV4IGI1MzU5YmJlMzljMDI1 YzNlMmM1ZTU1YjM5ZmE0YTU3NTdkNzk3NWYuLjkxNzBhZjRmMDY1ZDA4NzcxYWE3YmEyODUwMjhm ZTgxZTVkOTUwNjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L1JlZ2lvbi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5o CkBAIC00Nyw2ICs0Nyw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgdHJhbnNsYXRlKGNvbnN0IElu dFNpemUmKTsKIAorICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgcXVlcnkgcmVnaW9uIGlzIGEg c3Vic2V0IG9mIHRoaXMgcmVnaW9uLgorICAgIGJvb2wgY29udGFpbnMoY29uc3QgUmVnaW9uJikg Y29uc3Q7CisKICNpZm5kZWYgTkRFQlVHCiAgICAgdm9pZCBkdW1wKCkgY29uc3Q7CiAjZW5kaWYK QEAgLTEwNCwxMyArMTA3LDE4IEBAIHByaXZhdGU6CiAKICAgICAgICAgYm9vbCBjYW5Db2FsZXNj ZShTZWdtZW50SXRlcmF0b3IgYmVnaW4sIFNlZ21lbnRJdGVyYXRvciBlbmQpOwogCi0gICAgICAg IC8vIEZJWE1FOiBUaGVzZSB2ZWN0b3JzIHNob3VsZCBoYXZlIGlubGluZSBzaXplcy4gRmlndXJl IG91dCBhIGdvb2Qgb3B0aW1hbCB2YWx1ZS4KLSAgICAgICAgVmVjdG9yPGludD4gbV9zZWdtZW50 czsKLSAgICAgICAgVmVjdG9yPFNwYW4+IG1fc3BhbnM7ICAgICAgICAKKyAgICAgICAgVmVjdG9y PGludCwgMzI+IG1fc2VnbWVudHM7CisgICAgICAgIFZlY3RvcjxTcGFuLCAxNj4gbV9zcGFuczsK KworICAgICAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNoYXBlJiwgY29uc3QgU2hh cGUmKTsKICAgICB9OwogCiAgICAgSW50UmVjdCBtX2JvdW5kczsKICAgICBTaGFwZSBtX3NoYXBl OworCisgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBSZWdpb24mLCBjb25zdCBSZWdp b24mKTsKKyAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNoYXBlJiwgY29uc3QgU2hh cGUmKTsKKyAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNwYW4mLCBjb25zdCBTcGFu Jik7CiB9OwogCiBzdGF0aWMgaW5saW5lIFJlZ2lvbiBpbnRlcnNlY3QoY29uc3QgUmVnaW9uJiBh LCBjb25zdCBSZWdpb24mIGIpCkBAIC0xMzcsNiArMTQ1LDIxIEBAIHN0YXRpYyBpbmxpbmUgUmVn aW9uIHRyYW5zbGF0ZShjb25zdCBSZWdpb24mIHJlZ2lvbiwgY29uc3QgSW50U2l6ZSYgb2Zmc2V0 KQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKK2lubGluZSBib29sIG9wZXJhdG9yPT0oY29uc3Qg UmVnaW9uJiBhLCBjb25zdCBSZWdpb24mIGIpCit7CisgICAgcmV0dXJuIGEubV9ib3VuZHMgPT0g Yi5tX2JvdW5kcyAmJiBhLm1fc2hhcGUgPT0gYi5tX3NoYXBlOworfQorCitpbmxpbmUgYm9vbCBv cGVyYXRvcj09KGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGEsIGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGIp Cit7CisgICAgcmV0dXJuIGEubV9zcGFucyA9PSBiLm1fc3BhbnMgJiYgYS5tX3NlZ21lbnRzID09 IGIubV9zZWdtZW50czsKK30KKworaW5saW5lIGJvb2wgb3BlcmF0b3I9PShjb25zdCBSZWdpb246 OlNwYW4mIGEsIGNvbnN0IFJlZ2lvbjo6U3BhbiYgYikKK3sKKyAgICByZXR1cm4gYS55ID09IGIu eSAmJiBhLnNlZ21lbnRJbmRleCA9PSBiLnNlZ21lbnRJbmRleDsKK30KKwogfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gUmVnaW9uX2gK 125695 2012-02-06 12:56:33 -0800 2012-02-06 15:15:56 -0800 Patch bug-72294-20120206155632.patch text/plain 3579 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NTQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjBkYmNiYTI3OGNiZGVj ZTJkOTJiMzZkYTE2OWY5MmY4ZTUwNDA1MS4uYjZkMDFjMGRmOWRlZDY0MmY3MTEzMWEzZDQ2OTk0 NWNmNGM3MWUyMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTAxLTMxICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlZ2lvbjo6Y29udGFpbnMpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvUmVnaW9uLmg6CisgICAgICAgIChSZWdpb24pOgorICAgICAgICAoU2hhcGUp OgorICAgICAgICAoV2ViQ29yZTo6b3BlcmF0b3I9PSk6CisgICAgICAgIChXZWJDb3JlKToKKwog MjAxMi0wMi0wMiAgS2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgVGhlIHRoaXJkIGFyZ3VtZW50IG9mIGFkZEV2ZW50TGlzdGVuZXIvcmVtb3ZlRXZlbnRMaXN0 ZW5lciBvZiBQZWVyQ29ubmVjdGlvbiBzaG91bGQgYmUgb3B0aW9uYWwKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwCmluZGV4IDU0MjdjNmM5MWQyMTYwZWI3N2U4 Mjc4N2FiMDlhZWY0MjFkNjYxMjcuLjNmMzVlYjkyYjM4OWE4NjA3MzYwZDU1NmNkODc3NzliYjhm OGY1NDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lv bi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcApA QCAtNjUsNiArNjUsMTEgQEAgVmVjdG9yPEludFJlY3Q+IFJlZ2lvbjo6cmVjdHMoKSBjb25zdAog ICAgIHJldHVybiByZWN0czsKIH0KIAorYm9vbCBSZWdpb246OmNvbnRhaW5zKGNvbnN0IFJlZ2lv biYgcmVnaW9uKSBjb25zdAoreworICAgIHJldHVybiBXZWJDb3JlOjppbnRlcnNlY3QocmVnaW9u LCAqdGhpcykgPT0gcmVnaW9uOworfQorCiBSZWdpb246OlNoYXBlOjpTaGFwZSgpCiB7CiB9CkBA IC0yNzksNyArMjg0LDcgQEAgUmVnaW9uOjpTaGFwZSBSZWdpb246OlNoYXBlOjpzaGFwZU9wZXJh dGlvbihjb25zdCBTaGFwZSYgc2hhcGUxLCBjb25zdCBTaGFwZSYgc2gKICAgICAgICAgU2VnbWVu dEl0ZXJhdG9yIHMxID0gc2VnbWVudHMxOwogICAgICAgICBTZWdtZW50SXRlcmF0b3IgczIgPSBz ZWdtZW50czI7CiAKLSAgICAgICAgVmVjdG9yPGludD4gc2VnbWVudHM7CisgICAgICAgIFZlY3Rv cjxpbnQsIDMyPiBzZWdtZW50czsKIAogICAgICAgICAvLyBOb3cgaXRlcmF0ZSBvdmVyIHRoZSBz ZWdtZW50cyBpbiBlYWNoIHNwYW4gYW5kIGNvbnN0cnVjdCBhIG5ldyB2ZWN0b3Igb2Ygc2VnbWVu dHMuCiAgICAgICAgIHdoaWxlIChzMSAhPSBzZWdtZW50czFFbmQgJiYgczIgIT0gc2VnbWVudHMy RW5kKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdp b24uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5oCmluZGV4IGI1 MzU5YmJlMzljMDI1YzNlMmM1ZTU1YjM5ZmE0YTU3NTdkNzk3NWYuLjkxNzBhZjRmMDY1ZDA4Nzcx YWE3YmEyODUwMjhmZTgxZTVkOTUwNjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL1JlZ2lvbi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL1JlZ2lvbi5oCkBAIC00Nyw2ICs0Nyw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgdHJhbnNs YXRlKGNvbnN0IEludFNpemUmKTsKIAorICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgcXVlcnkg cmVnaW9uIGlzIGEgc3Vic2V0IG9mIHRoaXMgcmVnaW9uLgorICAgIGJvb2wgY29udGFpbnMoY29u c3QgUmVnaW9uJikgY29uc3Q7CisKICNpZm5kZWYgTkRFQlVHCiAgICAgdm9pZCBkdW1wKCkgY29u c3Q7CiAjZW5kaWYKQEAgLTEwNCwxMyArMTA3LDE4IEBAIHByaXZhdGU6CiAKICAgICAgICAgYm9v bCBjYW5Db2FsZXNjZShTZWdtZW50SXRlcmF0b3IgYmVnaW4sIFNlZ21lbnRJdGVyYXRvciBlbmQp OwogCi0gICAgICAgIC8vIEZJWE1FOiBUaGVzZSB2ZWN0b3JzIHNob3VsZCBoYXZlIGlubGluZSBz aXplcy4gRmlndXJlIG91dCBhIGdvb2Qgb3B0aW1hbCB2YWx1ZS4KLSAgICAgICAgVmVjdG9yPGlu dD4gbV9zZWdtZW50czsKLSAgICAgICAgVmVjdG9yPFNwYW4+IG1fc3BhbnM7ICAgICAgICAKKyAg ICAgICAgVmVjdG9yPGludCwgMzI+IG1fc2VnbWVudHM7CisgICAgICAgIFZlY3RvcjxTcGFuLCAx Nj4gbV9zcGFuczsKKworICAgICAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNoYXBl JiwgY29uc3QgU2hhcGUmKTsKICAgICB9OwogCiAgICAgSW50UmVjdCBtX2JvdW5kczsKICAgICBT aGFwZSBtX3NoYXBlOworCisgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBSZWdpb24m LCBjb25zdCBSZWdpb24mKTsKKyAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNoYXBl JiwgY29uc3QgU2hhcGUmKTsKKyAgICBmcmllbmQgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFNwYW4m LCBjb25zdCBTcGFuJik7CiB9OwogCiBzdGF0aWMgaW5saW5lIFJlZ2lvbiBpbnRlcnNlY3QoY29u c3QgUmVnaW9uJiBhLCBjb25zdCBSZWdpb24mIGIpCkBAIC0xMzcsNiArMTQ1LDIxIEBAIHN0YXRp YyBpbmxpbmUgUmVnaW9uIHRyYW5zbGF0ZShjb25zdCBSZWdpb24mIHJlZ2lvbiwgY29uc3QgSW50 U2l6ZSYgb2Zmc2V0KQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKK2lubGluZSBib29sIG9wZXJh dG9yPT0oY29uc3QgUmVnaW9uJiBhLCBjb25zdCBSZWdpb24mIGIpCit7CisgICAgcmV0dXJuIGEu bV9ib3VuZHMgPT0gYi5tX2JvdW5kcyAmJiBhLm1fc2hhcGUgPT0gYi5tX3NoYXBlOworfQorCitp bmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFJlZ2lvbjo6U2hhcGUmIGEsIGNvbnN0IFJlZ2lv bjo6U2hhcGUmIGIpCit7CisgICAgcmV0dXJuIGEubV9zcGFucyA9PSBiLm1fc3BhbnMgJiYgYS5t X3NlZ21lbnRzID09IGIubV9zZWdtZW50czsKK30KKworaW5saW5lIGJvb2wgb3BlcmF0b3I9PShj b25zdCBSZWdpb246OlNwYW4mIGEsIGNvbnN0IFJlZ2lvbjo6U3BhbiYgYikKK3sKKyAgICByZXR1 cm4gYS55ID09IGIueSAmJiBhLnNlZ21lbnRJbmRleCA9PSBiLnNlZ21lbnRJbmRleDsKK30KKwog fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gUmVnaW9uX2gK 125714 2012-02-06 15:16:01 -0800 2012-02-06 18:55:40 -0800 Patch for landing bug-72294-20120206181559.patch text/plain 3580 danakj U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NTQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjBkYmNiYTI3OGNiZGVj ZTJkOTJiMzZkYTE2OWY5MmY4ZTUwNDA1MS4uNGQxZTRkZTQ1OWVjYTQwNTIxYWY2NDBiNmMzMDMz MTVhMjY4MTk5ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTAxLTMxICBEYW5h IEphbnNlbnMgIDxkYW5ha2pAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBjb250YWlucygp IHRlc3QgdG8gUmVnaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjI5NAorCisgICAgICAgIFJldmlld2VkIGJ5IEFuZGVycyBDYXJsc3Nvbi4KKwor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpSZWdpb246OmNvbnRhaW5zKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL1JlZ2lvbi5oOgorICAgICAgICAoUmVnaW9uKToKKyAgICAgICAgKFNoYXBl KToKKyAgICAgICAgKFdlYkNvcmU6Om9wZXJhdG9yPT0pOgorICAgICAgICAoV2ViQ29yZSk6CisK IDIwMTItMDItMDIgIEtlbnRhcm8gSGFyYSAgPGhhcmFrZW5AY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFRoZSB0aGlyZCBhcmd1bWVudCBvZiBhZGRFdmVudExpc3RlbmVyL3JlbW92ZUV2ZW50TGlz dGVuZXIgb2YgUGVlckNvbm5lY3Rpb24gc2hvdWxkIGJlIG9wdGlvbmFsCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVnaW9uLmNwcAppbmRleCA1NDI3YzZjOTFkMjE2MGViNzdl ODI3ODdhYjA5YWVmNDIxZDY2MTI3Li4zZjM1ZWI5MmIzODlhODYwNzM2MGQ1NTZjZDg3Nzc5YmI4 ZjhmNTQ3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdp b24uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1JlZ2lvbi5jcHAK QEAgLTY1LDYgKzY1LDExIEBAIFZlY3RvcjxJbnRSZWN0PiBSZWdpb246OnJlY3RzKCkgY29uc3QK ICAgICByZXR1cm4gcmVjdHM7CiB9CiAKK2Jvb2wgUmVnaW9uOjpjb250YWlucyhjb25zdCBSZWdp b24mIHJlZ2lvbikgY29uc3QKK3sKKyAgICByZXR1cm4gV2ViQ29yZTo6aW50ZXJzZWN0KHJlZ2lv biwgKnRoaXMpID09IHJlZ2lvbjsKK30KKwogUmVnaW9uOjpTaGFwZTo6U2hhcGUoKQogewogfQpA QCAtMjc5LDcgKzI4NCw3IEBAIFJlZ2lvbjo6U2hhcGUgUmVnaW9uOjpTaGFwZTo6c2hhcGVPcGVy YXRpb24oY29uc3QgU2hhcGUmIHNoYXBlMSwgY29uc3QgU2hhcGUmIHNoCiAgICAgICAgIFNlZ21l bnRJdGVyYXRvciBzMSA9IHNlZ21lbnRzMTsKICAgICAgICAgU2VnbWVudEl0ZXJhdG9yIHMyID0g c2VnbWVudHMyOwogCi0gICAgICAgIFZlY3RvcjxpbnQ+IHNlZ21lbnRzOworICAgICAgICBWZWN0 b3I8aW50LCAzMj4gc2VnbWVudHM7CiAKICAgICAgICAgLy8gTm93IGl0ZXJhdGUgb3ZlciB0aGUg c2VnbWVudHMgaW4gZWFjaCBzcGFuIGFuZCBjb25zdHJ1Y3QgYSBuZXcgdmVjdG9yIG9mIHNlZ21l bnRzLgogICAgICAgICB3aGlsZSAoczEgIT0gc2VnbWVudHMxRW5kICYmIHMyICE9IHNlZ21lbnRz MkVuZCkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUmVn aW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9SZWdpb24uaAppbmRleCBi NTM1OWJiZTM5YzAyNWMzZTJjNWU1NWIzOWZhNGE1NzU3ZDc5NzVmLi45MTcwYWY0ZjA2NWQwODc3 MWFhN2JhMjg1MDI4ZmU4MWU1ZDk1MDY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9SZWdpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9SZWdpb24uaApAQCAtNDcsNiArNDcsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHRyYW5z bGF0ZShjb25zdCBJbnRTaXplJik7CiAKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhlIHF1ZXJ5 IHJlZ2lvbiBpcyBhIHN1YnNldCBvZiB0aGlzIHJlZ2lvbi4KKyAgICBib29sIGNvbnRhaW5zKGNv bnN0IFJlZ2lvbiYpIGNvbnN0OworCiAjaWZuZGVmIE5ERUJVRwogICAgIHZvaWQgZHVtcCgpIGNv bnN0OwogI2VuZGlmCkBAIC0xMDQsMTMgKzEwNywxOCBAQCBwcml2YXRlOgogCiAgICAgICAgIGJv b2wgY2FuQ29hbGVzY2UoU2VnbWVudEl0ZXJhdG9yIGJlZ2luLCBTZWdtZW50SXRlcmF0b3IgZW5k KTsKIAotICAgICAgICAvLyBGSVhNRTogVGhlc2UgdmVjdG9ycyBzaG91bGQgaGF2ZSBpbmxpbmUg c2l6ZXMuIEZpZ3VyZSBvdXQgYSBnb29kIG9wdGltYWwgdmFsdWUuCi0gICAgICAgIFZlY3Rvcjxp bnQ+IG1fc2VnbWVudHM7Ci0gICAgICAgIFZlY3RvcjxTcGFuPiBtX3NwYW5zOyAgICAgICAgCisg ICAgICAgIFZlY3RvcjxpbnQsIDMyPiBtX3NlZ21lbnRzOworICAgICAgICBWZWN0b3I8U3Bhbiwg MTY+IG1fc3BhbnM7CisKKyAgICAgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBTaGFw ZSYsIGNvbnN0IFNoYXBlJik7CiAgICAgfTsKIAogICAgIEludFJlY3QgbV9ib3VuZHM7CiAgICAg U2hhcGUgbV9zaGFwZTsKKworICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgUmVnaW9u JiwgY29uc3QgUmVnaW9uJik7CisgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBTaGFw ZSYsIGNvbnN0IFNoYXBlJik7CisgICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBTcGFu JiwgY29uc3QgU3BhbiYpOwogfTsKIAogc3RhdGljIGlubGluZSBSZWdpb24gaW50ZXJzZWN0KGNv bnN0IFJlZ2lvbiYgYSwgY29uc3QgUmVnaW9uJiBiKQpAQCAtMTM3LDYgKzE0NSwyMSBAQCBzdGF0 aWMgaW5saW5lIFJlZ2lvbiB0cmFuc2xhdGUoY29uc3QgUmVnaW9uJiByZWdpb24sIGNvbnN0IElu dFNpemUmIG9mZnNldCkKICAgICByZXR1cm4gcmVzdWx0OwogfQogCitpbmxpbmUgYm9vbCBvcGVy YXRvcj09KGNvbnN0IFJlZ2lvbiYgYSwgY29uc3QgUmVnaW9uJiBiKQoreworICAgIHJldHVybiBh Lm1fYm91bmRzID09IGIubV9ib3VuZHMgJiYgYS5tX3NoYXBlID09IGIubV9zaGFwZTsKK30KKwor aW5saW5lIGJvb2wgb3BlcmF0b3I9PShjb25zdCBSZWdpb246OlNoYXBlJiBhLCBjb25zdCBSZWdp b246OlNoYXBlJiBiKQoreworICAgIHJldHVybiBhLm1fc3BhbnMgPT0gYi5tX3NwYW5zICYmIGEu bV9zZWdtZW50cyA9PSBiLm1fc2VnbWVudHM7Cit9CisKK2lubGluZSBib29sIG9wZXJhdG9yPT0o Y29uc3QgUmVnaW9uOjpTcGFuJiBhLCBjb25zdCBSZWdpb246OlNwYW4mIGIpCit7CisgICAgcmV0 dXJuIGEueSA9PSBiLnkgJiYgYS5zZWdtZW50SW5kZXggPT0gYi5zZWdtZW50SW5kZXg7Cit9CisK IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIFJlZ2lvbl9oCg==