65277 2011-07-27 12:32:00 -0700 Make functions to find word boundaries more flexible 2012-06-15 07:31:02 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 25298 65773 1 xji webkit-unassigned amir.aharoni ap darin dtseng eric hausmann kenneth mifenton mitz rniwa tonikitoo vanlam webkit.review.bot oldest_to_newest 443094 0 xji 2011-07-27 12:32:00 -0700 one way to go might be: provide a flexible internal API which can return logical word break before or after space depending on passing-in parameter. expose the public API by passing the correct parameter so that the logical word break matches native platform's. --webkit-visual-word should use this internal API, so, some of the cases where word break in a box is collected will not be needed, instead, we could just use logical word break by passing in correct parameter depends on box and block's directionality. 443097 1 xji 2011-07-27 12:34:45 -0700 related issue: https://bugs.webkit.org/show_bug.cgi?id=64392 447449 2 103122 vanlam 2011-08-05 15:28:43 -0700 Created attachment 103122 WIP patch, would like some feedback Detailed description of changes: - Extracted functionality of findNextWordFromIndex into findNextWordFromIndexConsideringWordBreakPositioningRelativeToWord (this name is WIP) so that it can be parametrized with whether the word break should be logically before or after the word while maintaining existing functionality. - Added four new search functions to be passed into nextBoundary/previousBoundary to choose where the word break should be. This is what I'd like most feedback on as doing it this way results in some duplicate code. An alternative to adding four new search functions introducing some duplicate code is to add a parameter to each search function; while there is no duplicate code, this would require changing more code (which includes adding parameters that will be unused in search functions endWordBoundary, endSentenceBoundary, and nextSentencePositionBoundary). - In right/leftWordPositionAcrossBoundary, we never need to collect word breaks within a single box; this is an improvement because previously when moving right in an LTR block or left in an RTL block, word breaks would always be collected; this is significant for cases where runs of text of one directionality are very long. 448153 3 rniwa 2011-08-08 12:06:28 -0700 How does this improve the performance? Can you give us some metrics? 448200 4 xji 2011-08-08 13:08:17 -0700 We are using logical word break to get the visual word break. due to the way logical word break works (in terms of whether the word break is before or after the space), even when the start position is within the box, we are not able to correctly get the visual word break (in terms of before or after space) by directly using logical word break in 50% of the cases. Using moving left as example, Given a LTR box "abc def|" in LTR block, we can get visually left word break "abc |def" by directly using previousWordPosition(). Given a RTL box "FED CBA|" in LTR block, we can get the visually left word break "FED |CBA" by directly using nextWordPosition(). But given LTR box "abc def|" in RTL block, we are not able to get the visual word break "abc| def" (which is a position after previous word) by directly using previousWordPosition(). (please refer to http://trac.webkit.org/changeset/88359 for more details). Instead, we are collecting all word breaks in the box and compare offset to get the correct visual word break. Similar for a RTL box "FED CBA|" in RTL block. If we provide flexible logical word breaker (in terms of whether it breaks before or after space), we could always use that directly when start position is inside box, instead of collecting word breaks of the box and comparing the offset to get the correct word break for 50% cases. Also, we could use this flexible logical word breaker in some cases when start position is at the boundary. 448226 5 rniwa 2011-08-08 13:28:35 -0700 The question is whether this is really impacting the performance or not. You should use Shirk on Mac or some other means to measure the performance impact of this patch. 448227 6 rniwa 2011-08-08 13:29:39 -0700 Just running visual word movement tests with --repeat & measure timing is good. Make 10+ measurements and compute stdev. 448237 7 rniwa 2011-08-08 13:35:43 -0700 Also, this bug title is too general. With the current title, any patch that tries to improve the performance of --webkit-visual-word should be posted here. That's not ideal. If you have a specific fix that improves the performance measurably, then please file a separate bug as a blocker of this bug. 448385 8 rniwa 2011-08-08 17:37:46 -0700 I still don't understand the benefit of this change. Is there a mesurable difference after this change? Otherwise, it seems to bloats the code pretty badly. 448387 9 vanlam 2011-08-08 17:49:03 -0700 Hi Ryosuke. There is a strong performance improvement with this change. If you consider visual word movement code as doing either: 1) getting the next/previous word break within a box 2) collecting *all* the word breaks in a box using (1) and choosing the correct next word break This patch essentially makes the need for (2) much less frequent. Right now, if we have: |abc |def ... |xyz| (LTR context) for every word movement we'd collect every word break in the box. Now with this patch, we just get the correct next/previous word break in time proportional to the length of the next word (as opposed to the length of the entire box). I'll submit profiling results in a few. 448430 10 vanlam 2011-08-08 21:42:11 -0700 When I profiled the release build of DumpRenderTree with --repeat-each 5 on LayoutTests/editing/selection/move-by-word-visually*, I got the results (only showing relevant part): Before change: 3.8% rightWordPosition 1.9% collectWordBreaksInBox 1.7% rightWordBoundary 0.1% nextBoundary ... After change: 3.4% rightWordPosition 1.7% rightWordBoundary 1.2% collectWordBreaksInBox 0.3% nextBoundary ... Results for leftWordPosition are similar. This makes sense as, before the change, calls to collectWordBreaksInBox occurred when going right in LTR blocks and left in RTL blocks (roughly accounts for half of test cases). Now word breaks don't need to be collected for those cases; but they still need to be collected when the correct word break is at the logical end of line or when moving from one box to another. 448668 11 xji 2011-08-09 10:52:21 -0700 (In reply to comment #8) > I still don't understand the benefit of this change. Is there a mesurable difference after this change? Otherwise, it seems to bloats the code pretty badly. This patch provides 4 word search functions depends on the word break positions relative to word (before word or after word). The pro is cleaner code logic, and the con is code duplication (we could make existing function previousWordPositionBoundary call previousWordPositionBoundaryLogicallyAfterWord to reduce the duplication, if we want to fix the logical word break behavior across platform). An alternative is: add one more parameter in nextBoundary(), previousBoundary(), previousWordPositionBounary(), nextWordPositionBoundary(), findNextWordFromIndex(), and other 6 search functions in visible_unit.cpp (including startSentenceBoundary and endSentenceBounary, in which the newly added parameter is just a placeholder). Inside function findNextWordFromIndex(), depends on the passing in parameter, return logical word break before or after word. the word breaker search functions just pass in the IN parameter to findNextWordFromIndex(). the caller of nextBoundary()/previousBoundary() pass in the correct (before word or after word) parameter based on their usage: for visual word break, the value of the parameter depends on the platform, box directionality, and block directionality. For logical word break (previousWordPosition and nextWordPosition), the value of the parameter depends on the platform (editing behavior. related to https://bugs.webkit.org/show_bug.cgi?id=64392). The pro of the alternative: reduce code duplication, and it could be used to solve issue 64392 as well. The con of the alternative: adding placeholder parameters to the already heavily parameter-loaded search functions such as startSentenceBoundary(). We are debating on the approaches. Van prefer the approach in the patch, and I prefer the alternative. But we believe neither is ideal. Would appreciate your inputs! One more note, the uploaded patch provides findNextWordFromIndexConsideringWordBreakPositioningRelativeToWord() as a cross-platform function, the existing findNextWordFromIndex() is platform-dependent. 448677 12 xji 2011-08-09 11:02:49 -0700 (In reply to comment #10) > When I profiled the release build of DumpRenderTree with --repeat-each 5 on LayoutTests/editing/selection/move-by-word-visually*, I got the results (only showing relevant part): > > Before change: > 3.8% rightWordPosition > 1.9% collectWordBreaksInBox > 1.7% rightWordBoundary > 0.1% nextBoundary > ... > > After change: > 3.4% rightWordPosition > 1.7% rightWordBoundary > 1.2% collectWordBreaksInBox > 0.3% nextBoundary > ... > > Results for leftWordPosition are similar. This makes sense as, before the change, calls to collectWordBreaksInBox occurred when going right in LTR blocks and left in RTL blocks (roughly accounts for half of test cases). Now word breaks don't need to be collected for those cases; but they still need to be collected when the correct word break is at the logical end of line or when moving from one box to another. rightWordBoundary (and leftWordBoundary) could be improved using the same technic. currently, word breaks are collected in the box for 50% of the cases. Then, nextBoundary() and previousBoundary() will take even higher percentage of time, and we can continue work on reducing constructing of VisiblePosition. 450206 13 103716 vanlam 2011-08-11 18:24:44 -0700 Created attachment 103716 Proposed fix 450209 14 webkit.review.bot 2011-08-11 18:27:27 -0700 Attachment 103716 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/edit..." exit_code: 1 Source/WebCore/platform/text/TextBoundaries.h:33: Code inside a namespace should not be indented. [whitespace/indent] [4] Total errors found: 1 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 450212 15 103717 vanlam 2011-08-11 18:31:43 -0700 Created attachment 103717 Proposed fix Fixed style 450217 16 103717 webkit-ews 2011-08-11 18:38:30 -0700 Comment on attachment 103717 Proposed fix Attachment 103717 did not pass qt-ews (qt): Output: http://queues.webkit.org/results/9358439 450270 17 ap 2011-08-11 21:03:59 -0700 The measured performance improvements don't seem particularly large. Also, our problem is with calling these functions many times for each operation, not necessarily with them being slow. I think that prior to adding new code, we should better define the concepts it works with. Different ports return drastically different results for word boundaries, and considering how basic these operations are, that causes really ugly bugs (see e.g. bug 65898 or bug 65999). While we cannot even agree upon what word boundaries are, adding "word boundaries considering word break positioning" seems counter-productive. 450274 18 rniwa 2011-08-11 21:10:18 -0700 I agree with Alexey's sentiment here. We should try investigating different approaches to see which optimization pays off the most. When I did optimization in editing, the improvement I saw were in the order of 1-2% in release and 30-40% in debug. Anything below 1% seems ineffective at best. 450292 19 xji 2011-08-11 22:20:48 -0700 (In reply to comment #17) > The measured performance improvements don't seem particularly large. Also, our problem is with calling these functions many times for each operation, not necessarily with them being slow. Yes. you are right. The problem is calling these functions many times. And the improvement is to decrease the number of calls. When we compute visual word breaks, we are calling logical word break many times because logical word break does not return the correct (in terms of before or after space) word break position visual word breaker is looking for. For example, given a string "abc def hij", nextWordPosition() returns the following position "abc| def| hij", and previousWordPosition() returns the following position "|abc |def |hij". when start from beginning and move left to right, if the visual word break I am looking for is "abc |def |hij", then, I am not able to use nextWordPosition(). Instead, I collected the word breaks inside this box starting from end of the string and using previousWordPosition(), the collected word breaks are "abc def |hij", then, "abc |def hij", then, "|abc def hij". And by comparing the word break offset and current position offset, return "abc |def hij" as the visual word break. The proposed improvement is to provide an *internal* API which can return flexible logical word break in terms of space. Given the above example, if there is an *internal* API that returns "abc |def |hij" as logical next word breaker, then, I can use that to get the visual word breaker in one call. > > I think that prior to adding new code, we should better define the concepts it works with. Different ports return drastically different results for word boundaries, and considering how basic these operations are, that causes really ugly bugs (see e.g. bug 65898 or bug 65999). > While we cannot even agree upon what word boundaries are, adding "word boundaries considering word break positioning" seems counter-productive. 450294 20 rniwa 2011-08-11 22:25:56 -0700 (In reply to comment #19) > The proposed improvement is to provide an *internal* API which can return flexible logical word break in terms of space. Given the above example, if there is an *internal* API that returns "abc |def |hij" as logical next word breaker, then, I can use that to get the visual word breaker in one call. Regardless of how logical and rationale the improvement is, I don't think 0.4% performance improvement justifies the maintenance burden introduced by doubling the number of functions. For this to make sense, the performance improvement needs to be much more substantial. 450297 21 xji 2011-08-11 22:29:34 -0700 (In reply to comment #18) > I agree with Alexey's sentiment here. We should try investigating different approaches to see which optimization pays off the most. When I did optimization in editing, the improvement I saw were in the order of 1-2% in release and 30-40% in debug. Anything below 1% seems ineffective at best. when you say 1-2% and 30-40%, are you talking about relative or absolute numbers? For example, rightWordPosition from 3.8% to 3.4%, is the improvement 0.4% or ~10% (0.4/3.8)? collectWordbreakInBox has 30%+ gain (0.7/1.9). And I believe it and rightWordBoundary should improve further if we decrease the collectWordBreakInBox calls in rightWordBoundary. I think this is the 1st step of improvement (reduce the number of calls to nextBoundary()), after which, the cost of nextBoundary() will be more evident, and that is the next step for improvement. 450476 22 vanlam 2011-08-12 10:06:55 -0700 I should have clarified when I posted the profiling results the percentages are relative to running DRT; so originally 3.8% of the time was spent in rightWordPosition and after the change, 3.4%. This can be approximately seen as a ~10% speedup as Xiaomei pointed out. 450512 23 ap 2011-08-12 11:03:18 -0700 I don't think that we should focus much on performance of ad hoc tests. Move by word is not a very common editing operation. 451164 24 xji 2011-08-15 11:19:11 -0700 (In reply to comment #23) > I don't think that we should focus much on performance of ad hoc tests. Move by word is not a very common editing operation. hm... shift-arrow (alt-arrow in Mac) should move caret by word visually is the top #1 issue reported by chrome native users. 451183 25 vanlam 2011-08-15 11:46:58 -0700 Clarification on the patch: The overall performance speedup is 0.8% (going left and right) when running in DRT; about 7.5% is spent in visual word movement code. From within visual word movement code, however, this is about a 10% speedup; this might be improved to 15-20% if we more aggressively utilize this API within rightWordBoundary and leftWordBoundary. A secondary (probably more significant) purpose of this patch is that it will make future work much simpler to implement, most directly the Mac/Linux version (https://bugs.webkit.org/show_bug.cgi?id=65773). I've implemented a working Mac/Linux version but did not submit it for review just because it is not very understandable. I think with this change it would be much easier to implement and maintain. 451323 26 103963 vanlam 2011-08-15 15:23:18 -0700 Created attachment 103963 Proposed fix 451325 27 webkit.review.bot 2011-08-15 15:26:46 -0700 Attachment 103963 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/edit..." exit_code: 1 Source/WebCore/platform/text/TextBoundaries.h:33: Code inside a namespace should not be indented. [whitespace/indent] [4] Source/WebCore/platform/text/TextBoundaries.h:45: The parameter name "wordBreakPositioning" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/platform/text/brew/TextBoundariesBrew.cpp:39: Weird number of spaces at line-start. Are you using a 4-space indent? [whitespace/indent] [3] Source/WebCore/platform/text/brew/TextBoundariesBrew.cpp:40: Weird number of spaces at line-start. Are you using a 4-space indent? [whitespace/indent] [3] Total errors found: 4 in 7 files If any of these errors are false positives, please file a bug against check-webkit-style. 451349 28 103969 vanlam 2011-08-15 15:56:29 -0700 Created attachment 103969 Proposed fix 451354 29 103969 ap 2011-08-15 16:06:39 -0700 Comment on attachment 103969 Proposed fix View in context: https://bugs.webkit.org/attachment.cgi?id=103969&action=review > Source/WebCore/ChangeLog:21 > + (WebCore::previousWordPositionBoundaryLogicallyBeforeWord): > + (WebCore::previousWordPositionBoundaryLogicallyAfterWord): > + (WebCore::nextWordPositionBoundaryLogicallyBeforeWord): > + (WebCore::nextWordPositionBoundaryLogicallyAfterWord): > + (WebCore::leftWordPositionAcrossBoundary): > + (WebCore::rightWordPositionAcrossBoundary): I cannot really figure out from these function names what they are doing. Does "logically" have something to do with RTL languages? What is a "position across boundary"? 451382 30 vanlam 2011-08-15 16:38:16 -0700 (In reply to comment #29) > (From update of attachment 103969 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=103969&action=review > > > Source/WebCore/ChangeLog:21 > > + (WebCore::previousWordPositionBoundaryLogicallyBeforeWord): > > + (WebCore::previousWordPositionBoundaryLogicallyAfterWord): > > + (WebCore::nextWordPositionBoundaryLogicallyBeforeWord): > > + (WebCore::nextWordPositionBoundaryLogicallyAfterWord): > > + (WebCore::leftWordPositionAcrossBoundary): > > + (WebCore::rightWordPositionAcrossBoundary): > > I cannot really figure out from these function names what they are doing. Does "logically" have something to do with RTL languages? What is a "position across boundary"? I'm aiming to specify where word breaks should be. So "logically after word" means those boundaries that follow words: In LTR text: abc| def| RTL: |FED |CBA The usage of these functions is that one is passed into nextBoundary/previousBoundary to specify where the word break should be; it would mean the difference between: (calling nextBoundary) |abc def -> abc| def and |abc def -> abc |def Currently when calling nextBoundary, there is only one clear function to pass in at the word-movement level and that will always return the word break logically after the word; same goes for previousBoundary except it returns the word break logically before the word. An alternative is to specify visually (previousWordPositionBoundaryOnLeftOfWord, etc.). 451435 31 xji 2011-08-15 18:00:48 -0700 (In reply to comment #29) > (From update of attachment 103969 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=103969&action=review > > > Source/WebCore/ChangeLog:21 > > + (WebCore::previousWordPositionBoundaryLogicallyBeforeWord): > > + (WebCore::previousWordPositionBoundaryLogicallyAfterWord): > > + (WebCore::nextWordPositionBoundaryLogicallyBeforeWord): > > + (WebCore::nextWordPositionBoundaryLogicallyAfterWord): > > + (WebCore::leftWordPositionAcrossBoundary): > > + (WebCore::rightWordPositionAcrossBoundary): > > I cannot really figure out from these function names what they are doing. Does "logically" have something to do with RTL languages? What is a "position across boundary"? "position across boundary" is a position does not honor editable boundary. Maybe I should rename it to "right/leftWordPositionAcrossEditableBoundary". 451469 32 ap 2011-08-15 20:43:20 -0700 Both names mean that the result will always be across boundary, which is apparently untrue. 451473 33 rniwa 2011-08-15 20:58:02 -0700 I talked with Van on IRC, and the purpose of this patch is apparently not the performance but rather to implement Windows and Linux behaviors. So let's focus on that and not on the superfluous performance improvement. 451477 34 103969 rniwa 2011-08-15 21:04:38 -0700 Comment on attachment 103969 Proposed fix View in context: https://bugs.webkit.org/attachment.cgi?id=103969&action=review Why is there no change in platform/text/mac/TextBoundaries.mm? > Source/WebCore/ChangeLog:19 > + (WebCore::previousWordPositionBoundaryLogicallyBeforeWord): > + (WebCore::previousWordPositionBoundaryLogicallyAfterWord): > + (WebCore::nextWordPositionBoundaryLogicallyBeforeWord): > + (WebCore::nextWordPositionBoundaryLogicallyAfterWord): Before and after are logical concepts so "logically" is redundant. > Source/WebCore/platform/text/TextBoundaries.cpp:112 > +#if !PLATFORM(BREWMP) && !PLATFORM(MAC) && !PLATFORM(QT) We shouldn't be duplicating code in Brew and Qt and leaving Mac behind. r- because of this. > Source/WebCore/platform/text/qt/TextBoundariesQt.cpp:82 > +int findNextWordFromIndex(UChar const* buffer, int len, int position, bool forward) > +{ > + return findNextWordFromIndexConsideringWordBreakPositioningRelativeToWord > + (buffer, len, position, forward, forward ? LogicallyAfterWord : LogicallyBeforeWord); > +} > + What's the point of duplicating the function here? 451694 35 vanlam 2011-08-16 09:58:50 -0700 (In reply to comment #34) > (From update of attachment 103969 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=103969&action=review > > Why is there no change in platform/text/mac/TextBoundaries.mm? > > > Source/WebCore/ChangeLog:19 > > + (WebCore::previousWordPositionBoundaryLogicallyBeforeWord): > > + (WebCore::previousWordPositionBoundaryLogicallyAfterWord): > > + (WebCore::nextWordPositionBoundaryLogicallyBeforeWord): > > + (WebCore::nextWordPositionBoundaryLogicallyAfterWord): As far as visual word movement goes it seemed like the implementation in TextBoundaries.cpp works on Mac; but to make the change uniform across platforms I'll add the duplication. > > Before and after are logical concepts so "logically" is redundant. > > > Source/WebCore/platform/text/TextBoundaries.cpp:112 > > +#if !PLATFORM(BREWMP) && !PLATFORM(MAC) && !PLATFORM(QT) > > We shouldn't be duplicating code in Brew and Qt and leaving Mac behind. r- because of this. > > > Source/WebCore/platform/text/qt/TextBoundariesQt.cpp:82 > > +int findNextWordFromIndex(UChar const* buffer, int len, int position, bool forward) > > +{ > > + return findNextWordFromIndexConsideringWordBreakPositioningRelativeToWord > > + (buffer, len, position, forward, forward ? LogicallyAfterWord : LogicallyBeforeWord); > > +} > > + > > What's the point of duplicating the function here? Good catch; there only needs to be one copy of findNextWordFromIndex that delegates to the platform's findNextWordFromIndexConsideringWordBreakPositioningRelativeToWord. Thanks for the review. 452627 36 104254 vanlam 2011-08-17 15:07:16 -0700 Created attachment 104254 Proposed fix Modified patch following review and comments. Would like feedback on my changes in TextBoundaries.mm (not sure if my decision to use TextBreakIterator is correct). 452630 37 rniwa 2011-08-17 15:11:47 -0700 I don't think I'm qualified to review this patch. ap, darin, or eseidel should do. 452631 38 darin 2011-08-17 15:14:07 -0700 I think Dan also understand the issues here, perhaps better than I do. 452654 39 ap 2011-08-17 15:51:54 -0700 I have commented about function names above, and those comments still stand. This patch adds a good deal of confusion to an already confused area of code. 452717 40 vanlam 2011-08-17 16:34:13 -0700 (In reply to comment #39) > I have commented about function names above, and those comments still stand. This patch adds a good deal of confusion to an already confused area of code. Hi Alexey, I understand that the naming of right/leftWordPositionAcrossBoundary should change but thought that the renaming and several other stylistic to-dos would best be addressed in a separate cleanup patch. I also understand that this isn't a clean patch. I've considered an alternative to implement this based on the observation: You can chain calls to nextBoundary and previousBoundary to get the correct position. For example in the common case, you can get the next word break before word in LTR text by calling previousBoundary(nextBoundary(nextBoundary(currentVisiblePosition, nextWordPositionBoundary), nextWordPositionBoundary), previousWordPositionBoundary). While this avoids platform-level changes there are many cases to consider especially in bidi text and it is slower. I'm open to ideas on how best to implement this functionality as it's blocking https://bugs.webkit.org/show_bug.cgi?id=65773. Thanks 453535 41 104432 vanlam 2011-08-18 18:26:32 -0700 Created attachment 104432 Proposed (alternative) fix 454152 42 xji 2011-08-19 15:46:25 -0700 (In reply to comment #41) > Created an attachment (id=104432) [details] > Proposed (alternative) fix This seems the right fix for the code removed in http://trac.webkit.org/changeset/88359. 454153 43 104432 rniwa 2011-08-19 15:49:06 -0700 Comment on attachment 104432 Proposed (alternative) fix View in context: https://bugs.webkit.org/attachment.cgi?id=104432&action=review > Source/WebCore/editing/visible_units.cpp:1591 > +static VisiblePosition nextWordBoundaryBeforeWord(VisiblePosition startingPosition, InlineBox* startingBox, int startingOffset) Why do we ned startingBox and startingOffset? 454154 44 104432 xji 2011-08-19 15:50:39 -0700 Comment on attachment 104432 Proposed (alternative) fix View in context: https://bugs.webkit.org/attachment.cgi?id=104432&action=review > Source/WebCore/editing/visible_units.cpp:1601 > + if (currentOffset > startingOffset) should we checking (currentBox == startingBox &&....)? > Source/WebCore/editing/visible_units.cpp:1624 > + return prevNext; ditto 454159 45 vanlam 2011-08-19 15:59:07 -0700 (In reply to comment #43) > (From update of attachment 104432 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=104432&action=review > > > Source/WebCore/editing/visible_units.cpp:1591 > > +static VisiblePosition nextWordBoundaryBeforeWord(VisiblePosition startingPosition, InlineBox* startingBox, int startingOffset) > > Why do we ned startingBox and startingOffset? We could obtain these from the VisiblePosition passed in but since these two functions are called from right/leftWordPositionIgnoringEditingBoundary in which we've already called getInlineBoxAndOffset, I chose to just pass in the box and offset instead of recalculating. The actual box and offset are used to check if the result actually makes sense; since these two functions rely on next/previousBoundary which are logical functions, if the result is outside the box there's no guarantee that there's visual continuity. 454165 46 vanlam 2011-08-19 16:07:50 -0700 (In reply to comment #44) > (From update of attachment 104432 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=104432&action=review > > > Source/WebCore/editing/visible_units.cpp:1601 > > + if (currentOffset > startingOffset) > > should we checking (currentBox == startingBox &&....)? > > > Source/WebCore/editing/visible_units.cpp:1624 > > + return prevNext; > > ditto If we exit early because of this check then (In reply to comment #44) > (From update of attachment 104432 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=104432&action=review > > > Source/WebCore/editing/visible_units.cpp:1601 > > + if (currentOffset > startingOffset) > > should we checking (currentBox == startingBox &&....)? > > > Source/WebCore/editing/visible_units.cpp:1624 > > + return prevNext; > > ditto Right. I didn't catch this as the return values of these two functions are checked using positionIsInBoxButNotOnBoundary right after being called. But we should never return a position outside of startingBox to be safe. I'll resubmit with the additional check. 454189 47 104591 vanlam 2011-08-19 16:36:56 -0700 Created attachment 104591 Revised (alternative) fix Corrected previous patch following Xiaomei's comment. 456623 48 104591 rniwa 2011-08-24 20:03:10 -0700 Comment on attachment 104591 Revised (alternative) fix View in context: https://bugs.webkit.org/attachment.cgi?id=104591&action=review > Source/WebCore/editing/visible_units.cpp:1591 > +static VisiblePosition nextWordBoundaryBeforeWord(VisiblePosition startingPosition, InlineBox* startingBox, int startingOffset) This function's interface is quite confusing. Why does this function take BOTH startingPosition and startingBox & startingOffset. I'd rather make an extra call to getInlineBoxAndOffset than requiring callers to pass in the correct arguments. It appears that this function wants to take RenderedPosition as the argument after all. > Source/WebCore/editing/visible_units.cpp:1593 > + VisiblePosition next = nextBoundary(startingPosition, nextWordPositionBoundary); next is a very vague name. In this function, we're concerned about word boundary and on which side of the word boundary we're at. So your variable name should reflect that. nextPrev, nextNextPrev do not convey such information and should therefore be be avoided. > LayoutTests/ChangeLog:8 > + My change fixed this failure. You should explain what has been fixed and why it has been fixed. 457018 49 105225 vanlam 2011-08-25 11:34:47 -0700 Created attachment 105225 Revised (alternative) fix Thanks for the review. Here's my updated patch. 457742 50 vanlam 2011-08-26 13:37:03 -0700 Ping reviewers. Would really appreciate a review for my updated patch as I want to work on 65773. 457827 51 ap 2011-08-26 15:56:36 -0700 I'm having fairly hard time trying to understand what the new functions do. Let's look at nextWordBoundaryBeforeWord() for a specific example. What will it return in each of the following cases (vertical line denoting starting position)? te|st test te|st test test |test test test test| test test |test test test | test test +1|0 test +++++++|++++++ test U|.S.A. test "te|st" test 457829 52 ap 2011-08-26 16:01:46 -0700 Also, <p>te|st</p><p>test</p> (two words separated by a paragraph break). 457928 53 vanlam 2011-08-27 02:35:18 -0700 (In reply to comment #51) > I'm having fairly hard time trying to understand what the new functions do. > > Let's look at nextWordBoundaryBeforeWord() for a specific example. What will it return in each of the following cases (vertical line denoting starting position)? > > te|st > test te|st test > test |test test > test test| test > test |test test > test | test test > +1|0 > test +++++++|++++++ test > U|.S.A. > test "te|st" test Hi Alexey, nextWordBoundaryBeforeWord is based off the observation that in most cases, the next word boundary from a position somePosition that lies before a word is previousBoundary(nextBoundary(nextBoundary(somePosition, _), _), _); let the underscores be the appropriate search functions passed in (next/previousWordPositionBoundary). Example: Given text "a|bc def ghi" where | indicates the starting position, call nextBoundary: a|bc def ghi -> abc| def ghi call nextBoundary: abc| def ghi -> abc def| ghi call previousBoundary: abc def| ghi -> abc |def ghi This doesn't work when 1) the current position is at the end of a word or 2) when nextBoundary returns the last word boundary in the block. In the latter case, VisiblePosition() is returned to indicate that the desired word break is not in the box of the starting position. As for the cases: te|st -> VisiblePosition() test te|st test -> test test |test test |test test -> test test |test test |test test -> test test |test +1|0 -> VisiblePosition() test +++++++|++++++ test -> test ++++++++|+++++ test U|.S.A. -> VisiblePosition() test "te|st" test -> test "test" |test These are the results in Safari on Mac; results may differ slightly on other platforms as the functions eventually delegate to findNextWordFromIndex in TextBoundaries. 457931 54 vanlam 2011-08-27 03:17:10 -0700 (In reply to comment #52) > Also, <p>te|st</p><p>test</p> (two words separated by a paragraph break). In this case nextWordBoundaryBeforeWord returns VisiblePosition(). Because the two "test" strings are in different blocks (I think this is the correct term) the behavior of the function will work like: call nextBoundary: <p>te|st</p><p>test</p> -> <p>test|</p><p>test</p> call nextBoundary: <p>test|</p><p>test</p> -> <p>test|</p><p>test</p> (same position returned) At this point the code returns VisiblePosition() and the correct word break (at the end of the first line) is computed in another part of visual word movement code. 458247 55 ap 2011-08-29 09:29:58 -0700 Some comments: 1. It's important to know not just what function currently does, but what it's supposed to do. There are two ways to describe that in function name - either by telling what exactly it does, or when exactly it's supposed to be called. 2. nextWordBoundaryBeforeWord(VisiblePosition) looks as if it returned next word boundary before word that contained the VisiblePosition, which makes no sense. 3. You changed one of the test cases, so I'm unsure what happens for "test | test test". 4. You are saying that there are platform differences allowed in the results. What differences are OK? Mac version of findNextWordFromIndex() isn't based on ICU, and I don't know how different it can be. In particular, how will we avoid issues like bug 65898 going forward? 5. If implementing Windows style alt-arrow movement is the goal, perhaps the code should make this explicit. Also, being unable to move across paragraphs is incorrect for this use case. 458265 56 vanlam 2011-08-29 10:28:59 -0700 (In reply to comment #55) > Some comments: > 1. It's important to know not just what function currently does, but what it's supposed to do. There are two ways to describe that in function name - either by telling what exactly it does, or when exactly it's supposed to be called. > 2. nextWordBoundaryBeforeWord(VisiblePosition) looks as if it returned next word boundary before word that contained the VisiblePosition, which makes no sense. > 3. You changed one of the test cases, so I'm unsure what happens for "test | test test". > 4. You are saying that there are platform differences allowed in the results. What differences are OK? Mac version of findNextWordFromIndex() isn't based on ICU, and I don't know how different it can be. In particular, how will we avoid issues like bug 65898 going forward? > 5. If implementing Windows style alt-arrow movement is the goal, perhaps the code should make this explicit. Also, being unable to move across paragraphs is incorrect for this use case. 1) I should make it explicit that these functions work within a single box. 2) How's wordBoundaryBeforeNextWord? I think this is more clear. 3) Ah, I overlooked this test case. Here it is: test | test test -> test |test test 4) As far as I know every platform's findNextWordFromIndex returns the word boundary after the next word; the differences that will affect this function are which special non-alphanumeric characters get treated as parts of words. As for bug 65898, isn't this a problem that should be fixed within findWordBoundary and findNextWordFromIndex? Right now "foo bar _baz_" breaks the logical word movement as well (alt left arrow after "_baz_"). 5) The ultimate goal is to implement the Mac style alt-arrow movement (as the Windows version is already implemented); to do this we (Xiaomei and I) planned to return the correct word break based on box directionality, block directionality, movement direction, and editing behavior. Having these two functions would simplify the code a lot. I should point out that these two functions would mainly be used as helper functions within visual word movement code; in the end alt-arrow will move across paragraphs. Thanks for your feedback! 458292 57 ap 2011-08-29 11:00:09 -0700 > 3) Ah, I overlooked this test case. Here it is: test | test test -> test |test test This result seems substantially different from others. 458303 58 vanlam 2011-08-29 11:15:27 -0700 (In reply to comment #57) > > 3) Ah, I overlooked this test case. Here it is: test | test test -> test |test test > > This result seems substantially different from others. If you consider all word breaks before words, nextWordBoundaryBeforeWord will return the logically next one after the passed-in position. The behavior of this function on this case aligns with Windows alt-arrow behavior. 458311 59 darin 2011-08-29 11:21:19 -0700 (In reply to comment #58) > If you consider all word breaks before words, nextWordBoundaryBeforeWord I think you mean to say “word boundaries” not “word breaks”. And no, I don’t think that the term “word boundary” specifically means the place before a word. We’d need a more-specific term for that. A word boundary would mean both the place before a word and the place after a word. 458321 60 ap 2011-08-29 11:38:17 -0700 I think that we need better abstraction for code to be used in cursor movement iterator. For instance, there is no guarantee that Option-left arrow wants the same breaks as Option-delete. Current code is guilty of having lots of specialized functions with generic names in visible_units.cpp and then mistakenly reusing them when subtly different behavior is needed. Adding more of that is a step in a wrong direction. 458752 61 kenneth 2011-08-30 00:48:36 -0700 rniwa told me to add some comments here. Basically I am in the need for a method similar to VisualSelection.expandUsingGranularity(WordGranularity);, but that does not include spaces and never considers spaces to be a word. This is needed for injecting compositions into our virtual keyboard when clicking on a word in an editable field. 607316 62 105225 rniwa 2012-04-21 18:59:07 -0700 Comment on attachment 105225 Revised (alternative) fix This patch is obsolete after xji's rewrite of visual word movement patch. 103122 2011-08-05 15:28:43 -0700 2011-08-11 18:24:44 -0700 WIP patch, would like some feedback vanlam-internalapi text/plain 13786 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkyNTE3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTEtMDgtMDUgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBJbXByb3ZlIHBlcmZvcm1hbmNlIG9mIC0t d2Via2l0LXZpc3VhbC13b3JkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD02NTI3NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEV4dHJhY3RlZCBmdW5jdGlvbmFsaXR5IG9mIGZpbmROZXh0V29yZEJvdW5kYXJ5 IHRvIHBhcmFtZXRyaXplIGl0IHdpdGgKKyAgICAgICAgd2hlcmUgdGhlIHdvcmQgYnJlYWsgd291 bGQgYmUgcmVsYXRpdmUgdG8gdGhlIHdvcmQgKGxvZ2ljYWxseSBiZWZvcmUKKyAgICAgICAgb3Ig YWZ0ZXIpIHdoaWxlIG1haW50YWluaW5nIGV4aXN0aW5nIGZ1bmN0aW9uYWxpdHkuIEludHJvZHVj ZWQgZm91cgorICAgICAgICBzZWFyY2ggZnVuY3Rpb25zIHRvIGNob29zZSB3aGVyZSB0aGUgd29y ZCBicmVhayBzaG91bGQgYmUuIFV0aWxpemVkCisgICAgICAgIHRoZXNlIGNoYW5nZXMgaW4gcmln aHQvTGVmdFdvcmRQb3NpdGlvbkFjcm9zc0JvdW5kYXJ5IHRvIGF2b2lkCisgICAgICAgIGNvbGxl Y3RpbmcgYm91bmRhcmllcy4KKworICAgICAgICAqIGVkaXRpbmcvdmlzaWJsZV91bml0cy5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5 QmVmb3JlV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5k YXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKToKKyAgICAgICAgKFdlYkNvcmU6Om5leHRXb3JkUG9zaXRp b25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOgorICAgICAgICAoV2ViQ29yZTo6bmV4dFdv cmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKToKKyAgICAgICAgKFdlYkNvcmU6 OmxlZnRXb3JkUG9zaXRpb25BY3Jvc3NCb3VuZGFyeSk6CisgICAgICAgIChXZWJDb3JlOjpyaWdo dFdvcmRQb3NpdGlvbkFjcm9zc0JvdW5kYXJ5KToKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L1Rl eHRCb3VuZGFyaWVzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmZpbmROZXh0V29yZEZyb21JbmRl eCk6CisgICAgICAgIChXZWJDb3JlOjpmaW5kV29yZEJvdW5kYXJ5KToKKyAgICAgICAgKFdlYkNv cmU6OmZpbmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdS ZWxhdGl2ZVRvV29yZCk6CisgICAgICAgICogcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5o OgorCiAyMDExLTA4LTA1ICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAK ICAgICAgICAgRml4IENocm9taXVtIGJ1aWxkLgpJbmRleDogU291cmNlL1dlYkNvcmUvZWRpdGlu Zy92aXNpYmxlX3VuaXRzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5n L3Zpc2libGVfdW5pdHMuY3BwCShyZXZpc2lvbiA5MjUxNSkKKysrIFNvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvdmlzaWJsZV91bml0cy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUyLDYgKzUyLDcgQEAg dXNpbmcgbmFtZXNwYWNlIFdURjo6VW5pY29kZTsKIGVudW0gQm91bmRhcnlTZWFyY2hDb250ZXh0 QXZhaWxhYmlsaXR5IHsgRG9udEhhdmVNb3JlQ29udGV4dCwgTWF5SGF2ZU1vcmVDb250ZXh0IH07 CiAKIHR5cGVkZWYgdW5zaWduZWQgKCpCb3VuZGFyeVNlYXJjaEZ1bmN0aW9uKShjb25zdCBVQ2hh ciosIHVuc2lnbmVkIGxlbmd0aCwgdW5zaWduZWQgb2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRl eHRBdmFpbGFiaWxpdHksIGJvb2wmIG5lZWRNb3JlQ29udGV4dCk7Cit0eXBlZGVmIHVuc2lnbmVk ICgqQm91bmRhcnlTZWFyY2hGdW5jdGlvbkNvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmcp KGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBvZmZzZXQsIEJvdW5kYXJ5 U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSwgYm9vbCYgbmVlZE1vcmVDb250ZXh0LCBXb3JkQnJl YWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKTsKIAogc3RhdGljIFZpc2libGVQb3NpdGlvbiBw cmV2aW91c0JvdW5kYXJ5KGNvbnN0IFZpc2libGVQb3NpdGlvbiYgYywgQm91bmRhcnlTZWFyY2hG dW5jdGlvbiBzZWFyY2hGdW5jdGlvbikKIHsKQEAgLTI5NSw2ICsyOTYsMjYgQEAgc3RhdGljIHVu c2lnbmVkIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bgogICAgIHJldHVybiBmaW5kTmV4dFdvcmRG cm9tSW5kZXgoY2hhcmFjdGVycywgbGVuZ3RoLCBvZmZzZXQsIGZhbHNlKTsKIH0KIAorc3RhdGlj IHVuc2lnbmVkIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVXb3Jk KGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIG9mZnNl dCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5IG1heUhhdmVNb3JlQ29udGV4dCwg Ym9vbCYgbmVlZE1vcmVDb250ZXh0KQoreworICAgIGlmIChtYXlIYXZlTW9yZUNvbnRleHQgJiYg IXN0YXJ0T2ZMYXN0V29yZEJvdW5kYXJ5Q29udGV4dChjaGFyYWN0ZXJzLCBvZmZzZXQpKSB7Cisg ICAgICAgIG5lZWRNb3JlQ29udGV4dCA9IHRydWU7CisgICAgICAgIHJldHVybiAwOworICAgIH0K KyAgICBuZWVkTW9yZUNvbnRleHQgPSBmYWxzZTsKKyAgICByZXR1cm4gZmluZE5leHRXb3JkRnJv bUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKGNoYXJh Y3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCBmYWxzZSwgTG9naWNhbGx5QmVmb3JlV29yZCk7Cit9CisK K3N0YXRpYyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QWZ0 ZXJXb3JkKGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVk IG9mZnNldCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5IG1heUhhdmVNb3JlQ29u dGV4dCwgYm9vbCYgbmVlZE1vcmVDb250ZXh0KQoreworICAgIGlmIChtYXlIYXZlTW9yZUNvbnRl eHQgJiYgIXN0YXJ0T2ZMYXN0V29yZEJvdW5kYXJ5Q29udGV4dChjaGFyYWN0ZXJzLCBvZmZzZXQp KSB7CisgICAgICAgIG5lZWRNb3JlQ29udGV4dCA9IHRydWU7CisgICAgICAgIHJldHVybiAwOwor ICAgIH0KKyAgICBuZWVkTW9yZUNvbnRleHQgPSBmYWxzZTsKKyAgICByZXR1cm4gZmluZE5leHRX b3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3Jk KGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCBmYWxzZSwgTG9naWNhbGx5QWZ0ZXJXb3JkKTsK K30KKwogVmlzaWJsZVBvc2l0aW9uIHByZXZpb3VzV29yZFBvc2l0aW9uKGNvbnN0IFZpc2libGVQ b3NpdGlvbiAmYykKIHsKICAgICBWaXNpYmxlUG9zaXRpb24gcHJldiA9IHByZXZpb3VzQm91bmRh cnkoYywgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7CkBAIC0zMTEsNiArMzMyLDI2IEBA IHN0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkKICAgICByZXR1cm4gZmlu ZE5leHRXb3JkRnJvbUluZGV4KGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCB0cnVlKTsKIH0K IAorc3RhdGljIHVuc2lnbmVkIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9y ZVdvcmQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIHVuc2lnbmVkIGxlbmd0aCwgdW5zaWduZWQg b2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHkgbWF5SGF2ZU1vcmVDb250 ZXh0LCBib29sJiBuZWVkTW9yZUNvbnRleHQpCit7CisgICAgaWYgKG1heUhhdmVNb3JlQ29udGV4 dCAmJiBlbmRPZkZpcnN0V29yZEJvdW5kYXJ5Q29udGV4dChjaGFyYWN0ZXJzICsgb2Zmc2V0LCBs ZW5ndGggLSBvZmZzZXQpID09IHN0YXRpY19jYXN0PGludD4obGVuZ3RoIC0gb2Zmc2V0KSkgewor ICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4gbGVuZ3RoOwor ICAgIH0KKyAgICBuZWVkTW9yZUNvbnRleHQgPSBmYWxzZTsKKyAgICByZXR1cm4gZmluZE5leHRX b3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3Jk KGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCB0cnVlLCBMb2dpY2FsbHlCZWZvcmVXb3JkKTsK K30KKworc3RhdGljIHVuc2lnbmVkIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFm dGVyV29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25l ZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9yZUNv bnRleHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVDb250 ZXh0ICYmIGVuZE9mRmlyc3RXb3JkQm91bmRhcnlDb250ZXh0KGNoYXJhY3RlcnMgKyBvZmZzZXQs IGxlbmd0aCAtIG9mZnNldCkgPT0gc3RhdGljX2Nhc3Q8aW50PihsZW5ndGggLSBvZmZzZXQpKSB7 CisgICAgICAgIG5lZWRNb3JlQ29udGV4dCA9IHRydWU7CisgICAgICAgIHJldHVybiBsZW5ndGg7 CisgICAgfQorICAgIG5lZWRNb3JlQ29udGV4dCA9IGZhbHNlOworICAgIHJldHVybiBmaW5kTmV4 dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dv cmQoY2hhcmFjdGVycywgbGVuZ3RoLCBvZmZzZXQsIHRydWUsIExvZ2ljYWxseUFmdGVyV29yZCk7 Cit9CisKIFZpc2libGVQb3NpdGlvbiBuZXh0V29yZFBvc2l0aW9uKGNvbnN0IFZpc2libGVQb3Np dGlvbiAmYykKIHsKICAgICBWaXNpYmxlUG9zaXRpb24gbmV4dCA9IG5leHRCb3VuZGFyeShjLCBu ZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOyAgICAKQEAgLTE2MjUsMTQgKzE2NjYsMTQgQEAgc3Rh dGljIFZpc2libGVQb3NpdGlvbiBsZWZ0V29yZFBvc2l0aW9uQQogICAgIGlmIChvZmZzZXQgPT0g Ym94LT5jYXJldFJpZ2h0bW9zdE9mZnNldCgpKQogICAgICAgICByZXR1cm4gbGVmdFdvcmRCb3Vu ZGFyeShib3gsIG9mZnNldCwgYmxvY2tEaXJlY3Rpb24pOwogICAgIAotICAgIAogICAgIFZpc2li bGVQb3NpdGlvbiB3b3JkQnJlYWs7Ci0gICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IExUUikgewot ICAgICAgICBpZiAoYm94LT5kaXJlY3Rpb24oKSA9PSBibG9ja0RpcmVjdGlvbikKLSAgICAgICAg ICAgIHdvcmRCcmVhayA9IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91 c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKLSAgICAgICAgZWxzZQotICAgICAgICAgICAgd29yZEJy ZWFrID0gbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5k YXJ5KTsKLSAgICB9CisgICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IExUUikKKyAgICAgICAgd29y ZEJyZWFrID0gYm94LT5kaXJlY3Rpb24oKSA9PSBMVFIgPyBwcmV2aW91c0JvdW5kYXJ5KHZpc2li bGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdv cmQpCisgICAgICAgICAgICA6IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3Jk UG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFmdGVyV29yZCk7CisgICAgZWxzZQorICAgICAgICB3 b3JkQnJlYWsgPSBib3gtPmRpcmVjdGlvbigpID09IExUUiA/IHByZXZpb3VzQm91bmRhcnkodmlz aWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJX b3JkKQorICAgICAgICAgICAgOiBuZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29y ZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVXb3JkKTsKKyAgICAKICAgICBpZiAod29y ZEJyZWFrLmlzTm90TnVsbCgpICYmIHBvc2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91bmRhcnkod29y ZEJyZWFrLCBib3gpKQogICAgICAgICByZXR1cm4gd29yZEJyZWFrOwogICAgIApAQCAtMTY2NCwx MiArMTcwNSwxMyBAQCBzdGF0aWMgVmlzaWJsZVBvc2l0aW9uIHJpZ2h0V29yZFBvc2l0aW9uCiAg ICAgICAgIHJldHVybiByaWdodFdvcmRCb3VuZGFyeShyaWdodElubGluZUJveChib3gsIGJsb2Nr RGlyZWN0aW9uKSwgaW52YWxpZE9mZnNldCwgYmxvY2tEaXJlY3Rpb24pOwogIAogICAgIFZpc2li bGVQb3NpdGlvbiB3b3JkQnJlYWs7Ci0gICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IFJUTCkgewot ICAgICAgICBpZiAoYm94LT5kaXJlY3Rpb24oKSA9PSBibG9ja0RpcmVjdGlvbikKLSAgICAgICAg ICAgIHdvcmRCcmVhayA9IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91 c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKLSAgICAgICAgZWxzZQotICAgICAgICAgICAgd29yZEJy ZWFrID0gbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5k YXJ5KTsKLSAgICB9CisgICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IExUUikKKyAgICAgICAgd29y ZEJyZWFrID0gYm94LT5kaXJlY3Rpb24oKSA9PSBMVFIgPyBuZXh0Qm91bmRhcnkodmlzaWJsZVBv c2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVXb3JkKQorICAg ICAgICAgICAgOiBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgcHJldmlvdXNXb3Jk UG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFmdGVyV29yZCk7CisgICAgZWxzZQorICAgICAgICB3 b3JkQnJlYWsgPSBib3gtPmRpcmVjdGlvbigpID09IExUUiA/IG5leHRCb3VuZGFyeSh2aXNpYmxl UG9zaXRpb24sIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFmdGVyV29yZCkKKyAg ICAgICAgICAgIDogcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29y ZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVXb3JkKTsKKyAgICAgICAgICAgIAogICAg IGlmICh3b3JkQnJlYWsuaXNOb3ROdWxsKCkgJiYgcG9zaXRpb25Jc0luQm94QnV0Tm90T25Cb3Vu ZGFyeSh3b3JkQnJlYWssIGJveCkpCiAgICAgICAgIHJldHVybiB3b3JkQnJlYWs7CiAgICAgCklu ZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVzLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVzLmNw cAkocmV2aXNpb24gOTI0ODQpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRC b3VuZGFyaWVzLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjMsMTYgKzYzLDQwIEBAIGludCBzdGFy dE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY29uc3QKICNpZiAhUExBVEZPUk0oQlJFV01QKSAm JiAhUExBVEZPUk0oTUFDKSAmJiAhUExBVEZPUk0oUVQpCiAKIGludCBmaW5kTmV4dFdvcmRGcm9t SW5kZXgoY29uc3QgVUNoYXIqIGNoYXJzLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGJvb2wgZm9y d2FyZCkKK3sgICAgCisgICAgcmV0dXJuIGZpbmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5n V29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZAorICAgICAgICAoY2hhcnMsIGxlbiwg cG9zaXRpb24sIGZvcndhcmQsIGZvcndhcmQgPyBMb2dpY2FsbHlBZnRlcldvcmQgOiBMb2dpY2Fs bHlCZWZvcmVXb3JkKTsKK30KKwordm9pZCBmaW5kV29yZEJvdW5kYXJ5KGNvbnN0IFVDaGFyKiBj aGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBpbnQqIHN0YXJ0LCBpbnQqIGVuZCkKK3sKKyAg ICBUZXh0QnJlYWtJdGVyYXRvciogaXQgPSB3b3JkQnJlYWtJdGVyYXRvcihjaGFycywgbGVuKTsK KyAgICAqZW5kID0gdGV4dEJyZWFrRm9sbG93aW5nKGl0LCBwb3NpdGlvbik7CisgICAgaWYgKCpl bmQgPCAwKQorICAgICAgICAqZW5kID0gdGV4dEJyZWFrTGFzdChpdCk7CisgICAgKnN0YXJ0ID0g dGV4dEJyZWFrUHJldmlvdXMoaXQpOworfQorCisjZW5kaWYgLy8gIVBMQVRGT1JNKEJSRVdNUCkg JiYgIVBMQVRGT1JNKE1BQykgJiYgIVBMQVRGT1JNKFFUKQorCitpbnQgZmluZE5leHRXb3JkRnJv bUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKGNvbnN0 IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQsIFdvcmRC cmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQgd29yZEJyZWFrUG9zaXRpb25pbmcpCiB7CiAg ICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29yZEJyZWFrSXRlcmF0b3IoY2hhcnMsIGxlbik7 CiAKICAgICBpZiAoZm9yd2FyZCkgewogICAgICAgICBwb3NpdGlvbiA9IHRleHRCcmVha0ZvbGxv d2luZyhpdCwgcG9zaXRpb24pOwogICAgICAgICB3aGlsZSAocG9zaXRpb24gIT0gVGV4dEJyZWFr RG9uZSkgewotICAgICAgICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFj dGVyIHByZWNlZWRpbmcgdGhlIGJyZWFrCi0gICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMu Ci0gICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNb cG9zaXRpb24gLSAxXSkpCi0gICAgICAgICAgICAgICAgcmV0dXJuIHBvc2l0aW9uOworICAgICAg ICAgICAgaWYgKHdvcmRCcmVha1Bvc2l0aW9uaW5nID09IExvZ2ljYWxseUFmdGVyV29yZCkgewor ICAgICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNoaW5nIHdoZW4gdGhlIGNoYXJhY3RlciBw cmVjZWVkaW5nIHRoZSBicmVhaworICAgICAgICAgICAgICAgIC8vIGlzIGFscGhhbnVtZXJpYy4K KyAgICAgICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hh cnNbcG9zaXRpb24gLSAxXSkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsK KyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hp bmcgd2hlbiB0aGUgY2hhcmFjdGVyIGZvbGxvd2luZyB0aGUgYnJlYWsKKyAgICAgICAgICAgICAg ICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAgICAgICAgICAgICAgaWYgKHBvc2l0aW9uID4gMCAm JiBpc0FscGhhbnVtZXJpYyhjaGFyc1twb3NpdGlvbl0pKQorICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gcG9zaXRpb247CisgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIHBvc2l0aW9uID0g dGV4dEJyZWFrRm9sbG93aW5nKGl0LCBwb3NpdGlvbik7CiAgICAgICAgIH0KQEAgLTgxLDEwICsx MDUsMTcgQEAgaW50IGZpbmROZXh0V29yZEZyb21JbmRleChjb25zdCBVQ2hhciogYwogICAgIH0g ZWxzZSB7CiAgICAgICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrUHJlY2VkaW5nKGl0LCBwb3NpdGlv bik7CiAgICAgICAgIHdoaWxlIChwb3NpdGlvbiAhPSBUZXh0QnJlYWtEb25lKSB7Ci0gICAgICAg ICAgICAvLyBXZSBzdG9wIHNlYXJjaGluZyB3aGVuIHRoZSBjaGFyYWN0ZXIgZm9sbG93aW5nIHRo ZSBicmVhawotICAgICAgICAgICAgLy8gaXMgYWxwaGFudW1lcmljLgotICAgICAgICAgICAgaWYg KHBvc2l0aW9uID4gMCAmJiBpc0FscGhhbnVtZXJpYyhjaGFyc1twb3NpdGlvbl0pKQotICAgICAg ICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAgICAgICAgICAgIGlmICh3b3JkQnJlYWtQb3Np dGlvbmluZyA9PSBMb2dpY2FsbHlCZWZvcmVXb3JkKSB7CisgICAgICAgICAgICAgICAgLy8gV2Ug c3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIGZvbGxvd2luZyB0aGUgYnJlYWsKKyAg ICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAgICAgICAgICAgICAgaWYgKHBv c2l0aW9uID4gMCAmJiBpc0FscGhhbnVtZXJpYyhjaGFyc1twb3NpdGlvbl0pKQorICAgICAgICAg ICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNoaW5nIHdoZW4gdGhlIGNoYXJhY3RlciBwcmVjZWVk aW5nIHRoZSBicmVhaworICAgICAgICAgICAgICAgIC8vIGlzIGFscGhhbnVtZXJpYy4KKyAgICAg ICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9z aXRpb24gLSAxXSkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAgICAg ICAgICAgIH0KIAogICAgICAgICAgICAgcG9zaXRpb24gPSB0ZXh0QnJlYWtQcmVjZWRpbmcoaXQs IHBvc2l0aW9uKTsKICAgICAgICAgfQpAQCAtOTMsMTUgKzEyNCw0IEBAIGludCBmaW5kTmV4dFdv cmRGcm9tSW5kZXgoY29uc3QgVUNoYXIqIGMKICAgICB9CiB9CiAKLXZvaWQgZmluZFdvcmRCb3Vu ZGFyeShjb25zdCBVQ2hhciogY2hhcnMsIGludCBsZW4sIGludCBwb3NpdGlvbiwgaW50KiBzdGFy dCwgaW50KiBlbmQpCi17Ci0gICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29yZEJyZWFrSXRl cmF0b3IoY2hhcnMsIGxlbik7Ci0gICAgKmVuZCA9IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9z aXRpb24pOwotICAgIGlmICgqZW5kIDwgMCkKLSAgICAgICAgKmVuZCA9IHRleHRCcmVha0xhc3Qo aXQpOwotICAgICpzdGFydCA9IHRleHRCcmVha1ByZXZpb3VzKGl0KTsKLX0KLQotI2VuZGlmIC8v ICFQTEFURk9STShCUkVXTVApICYmICFQTEFURk9STShNQUMpICYmICFQTEFURk9STShRVCkKLQog fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4 dC9UZXh0Qm91bmRhcmllcy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L3RleHQvVGV4dEJvdW5kYXJpZXMuaAkocmV2aXNpb24gOTI0ODQpCisrKyBTb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVzLmgJKHdvcmtpbmcgY29weSkKQEAgLTMwLDYg KzMwLDggQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisgICAgZW51bSBXb3JkQnJlYWtQb3Np dGlvbmluZ1JlbGF0aXZlVG9Xb3JkIHsgTG9naWNhbGx5QmVmb3JlV29yZCwgTG9naWNhbGx5QWZ0 ZXJXb3JkIH07CisKICAgICBpbmxpbmUgYm9vbCByZXF1aXJlc0NvbnRleHRGb3JXb3JkQm91bmRh cnkoVUNoYXIzMiBjaCkKICAgICB7CiAgICAgICAgIHJldHVybiBXVEY6OlVuaWNvZGU6Omhhc0xp bmVCcmVha2luZ1Byb3BlcnR5Q29tcGxleENvbnRleHQoY2gpOwpAQCAtNDAsNiArNDIsNyBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICB2b2lkIGZpbmRXb3JkQm91bmRhcnkoY29uc3QgVUNo YXIqLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGludCogc3RhcnQsIGludCogZW5kKTsKICAgICBp bnQgZmluZE5leHRXb3JkRnJvbUluZGV4KGNvbnN0IFVDaGFyKiwgaW50IGxlbiwgaW50IHBvc2l0 aW9uLCBib29sIGZvcndhcmQpOworICAgIGludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRl cmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQoY29uc3QgVUNoYXIqLCBpbnQg bGVuLCBpbnQgcG9zaXRpb24sIGJvb2wgZm9yd2FyZCwgV29yZEJyZWFrUG9zaXRpb25pbmdSZWxh dGl2ZVRvV29yZCk7CiAKIH0KIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gOTI1MTcpCisrKyBMYXlvdXRU ZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wOC0w NSAgVmFuIExhbSAgPHZhbmxhbUBnb29nbGUuY29tPgorCisgICAgICAgIEltcHJvdmUgcGVyZm9y bWFuY2Ugb2YgLS13ZWJraXQtdmlzdWFsLXdvcmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTY1Mjc3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgTXkgZml4IHJlbW92ZWQgdGhpcyBmYWlsdXJlLgorCisgICAg ICAgICogZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFj ZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQ6CisKIDIwMTEtMDgtMDUgIEppYW4gTGkgIDxq aWFubGlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFNraXAgY2FudmFzLXB1dEltYWdlRGF0YS5o dG1sIGluIGNocm9taXVtLgpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92 ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50 eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13 b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQJKHJl dmlzaW9uIDkyNDg0KQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13 b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQJKHdv cmtpbmcgY29weSkKQEAgLTEzNyw5ICsxMzcsNiBAQCBUZXN0IDIwLCBSVEw6CiBNb3ZlIGxlZnQg Ynkgb25lIHdvcmQKICJBQkQgb3BxIHJzdCBEU1UgIlswLCA0LCA3LCAxMiwgMTZdLCAiYWJjIHV2 dyBBQUEgZGVmIGxtbiJbMTIsIDgsIDcsIDNdLCAiQUJXIGhpaiB4eXogRlhYIls0LCA3LCAxMiwg MTVdICAgIEZBSUwgZXhwZWN0ZWQ6IFsiQUJEIG9wcSByc3QgRFNVICJbIDAsICA0LCAgNywgIDEy LCAgMTYsIF0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1LCAgOCwgIDcsICAzLCBdIkFCVyBoaWog eHl6IEZYWCJbIDQsICA3LCAgMTIsICAxNV0KICJBQkQgb3BxIHJzdCBEU1UgIlsxNl0sICJhYmMg dXZ3IEFBQSBkZWYgbG1uIlsxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1u IlsgMTVdCi0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTgsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFi YyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KLSJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxNywgMTJdICAg RkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1XQotImFiYyB1dncgQUFBIGRl ZiBsbW4iWzE2LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgMTVd CiAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTUsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncg QUFBIGRlZiBsbW4iWyA4XQogImFiYyB1dncgQUFBIGRlZiBsbW4iWzE0LCAxMl0gICBGQUlMIGV4 cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0KICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsx MywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDhdCg== 103716 2011-08-11 18:24:44 -0700 2011-08-11 18:31:43 -0700 Proposed fix vanlam-internalapi text/plain 14267 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkyODk4KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTEtMDgtMTEgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBQcm92aWRlIGZsZXhpYmxlIChpbiB0ZXJt cyBvZiBwb3NpdGlvbiByZWxhdGl2ZSB0byBzcGFjZSkgbG9naWNhbCB3b3JkIGJyZWFrZXIgdG8g aW1wcm92ZSBwZXJmb3JtYW5jZSBvZiAtLXdlYmtpdC12aXN1YWwtd29yZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjUyNzcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBFeHRyYWN0ZWQgZnVuY3Rpb25hbGl0 eSBvZiBmaW5kTmV4dFdvcmRCb3VuZGFyeSB0byBwYXJhbWV0cml6ZSBpdCB3aXRoCisgICAgICAg IHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZSByZWxhdGl2ZSB0byB0aGUgd29yZCAobG9n aWNhbGx5IGJlZm9yZQorICAgICAgICBvciBhZnRlcikgd2hpbGUgbWFpbnRhaW5pbmcgZXhpc3Rp bmcgZnVuY3Rpb25hbGl0eS4gSW50cm9kdWNlZCBmb3VyCisgICAgICAgIHNlYXJjaCBmdW5jdGlv bnMgdG8gY2hvb3NlIHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZS4gVXRpbGl6ZWQKKyAg ICAgICAgdGhlc2UgY2hhbmdlcyBpbiByaWdodC9sZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91bmRh cnkgdG8gYXZvaWQKKyAgICAgICAgY29sbGVjdGluZyB3b3JkIGJvdW5kYXJpZXMuCisKKyAgICAg ICAgKiBlZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6cHJldmlv dXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOgorICAgICAgICAoV2Vi Q29yZTo6cHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFmdGVyV29yZCk6Cisg ICAgICAgIChXZWJDb3JlOjpuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVX b3JkKToKKyAgICAgICAgKFdlYkNvcmU6Om5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxs eUFmdGVyV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpyaWdodFdvcmRCb3VuZGFyeSk6CisgICAg ICAgIChXZWJDb3JlOjpsZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91bmRhcnkpOgorICAgICAgICAo V2ViQ29yZTo6cmlnaHRXb3JkUG9zaXRpb25BY3Jvc3NCb3VuZGFyeSk6CisgICAgICAgICogcGxh dGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpmaW5kTmV4 dFdvcmRGcm9tSW5kZXgpOgorICAgICAgICAoV2ViQ29yZTo6ZmluZFdvcmRCb3VuZGFyeSk6Cisg ICAgICAgIChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVh a1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvVGV4 dEJvdW5kYXJpZXMuaDoKKwogMjAxMS0wOC0xMSAgRGF2aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBw bGUuY29tPgogCiAgICAgICAgIDxodHRwOi8vd2Via2l0Lm9yZy9iLzY2MTEzPiBbQ0ZOZXR3b3Jr XSB3aWxsQ2FjaGVSZXNwb25zZSgpIGxlYWtzIENGQ2FjaGVkVVJMUmVzcG9uc2VSZWYgaWYgZGVs ZWdhdGUgY2hhbmdlcyBDYWNoZVN0b3JhZ2VQb2xpY3kKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvdmlzaWJsZV91bml0cy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvZWRp dGluZy92aXNpYmxlX3VuaXRzLmNwcAkocmV2aXNpb24gOTI4OTkpCisrKyBTb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01Miw2ICs1Miw3 IEBAIHVzaW5nIG5hbWVzcGFjZSBXVEY6OlVuaWNvZGU7CiBlbnVtIEJvdW5kYXJ5U2VhcmNoQ29u dGV4dEF2YWlsYWJpbGl0eSB7IERvbnRIYXZlTW9yZUNvbnRleHQsIE1heUhhdmVNb3JlQ29udGV4 dCB9OwogCiB0eXBlZGVmIHVuc2lnbmVkICgqQm91bmRhcnlTZWFyY2hGdW5jdGlvbikoY29uc3Qg VUNoYXIqLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIG9mZnNldCwgQm91bmRhcnlTZWFyY2hD b250ZXh0QXZhaWxhYmlsaXR5LCBib29sJiBuZWVkTW9yZUNvbnRleHQpOwordHlwZWRlZiB1bnNp Z25lZCAoKkJvdW5kYXJ5U2VhcmNoRnVuY3Rpb25Db25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9u aW5nKShjb25zdCBVQ2hhciosIHVuc2lnbmVkIGxlbmd0aCwgdW5zaWduZWQgb2Zmc2V0LCBCb3Vu ZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHksIGJvb2wmIG5lZWRNb3JlQ29udGV4dCwgV29y ZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZCk7CiAKIHN0YXRpYyBWaXNpYmxlUG9zaXRp b24gcHJldmlvdXNCb3VuZGFyeShjb25zdCBWaXNpYmxlUG9zaXRpb24mIGMsIEJvdW5kYXJ5U2Vh cmNoRnVuY3Rpb24gc2VhcmNoRnVuY3Rpb24pCiB7CkBAIC0yODksNiArMjkwLDI2IEBAIHN0YXRp YyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW4KICAgICByZXR1cm4gZmluZE5leHRX b3JkRnJvbUluZGV4KGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCBmYWxzZSk7CiB9CiAKK3N0 YXRpYyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3Jl V29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBv ZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9yZUNvbnRl eHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVDb250ZXh0 ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywgb2Zmc2V0KSkg eworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4gMDsKKyAg ICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmROZXh0V29y ZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZChj aGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUJlZm9yZVdvcmQpOwor fQorCitzdGF0aWMgdW5zaWduZWQgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxs eUFmdGVyV29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNp Z25lZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9y ZUNvbnRleHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVD b250ZXh0ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywgb2Zm c2V0KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4g MDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmRO ZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRv V29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUFmdGVyV29y ZCk7Cit9CisKIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c1dvcmRQb3NpdGlvbihjb25zdCBWaXNp YmxlUG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHByZXYgPSBwcmV2aW91c0Jv dW5kYXJ5KGMsIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwpAQCAtMzA1LDYgKzMyNiwy NiBAQCBzdGF0aWMgdW5zaWduZWQgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5CiAgICAgcmV0dXJu IGZpbmROZXh0V29yZEZyb21JbmRleChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1ZSk7 CiB9CiAKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlC ZWZvcmVXb3JkKGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2ln bmVkIG9mZnNldCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5IG1heUhhdmVNb3Jl Q29udGV4dCwgYm9vbCYgbmVlZE1vcmVDb250ZXh0KQoreworICAgIGlmIChtYXlIYXZlTW9yZUNv bnRleHQgJiYgZW5kT2ZGaXJzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycyArIG9mZnNl dCwgbGVuZ3RoIC0gb2Zmc2V0KSA9PSBzdGF0aWNfY2FzdDxpbnQ+KGxlbmd0aCAtIG9mZnNldCkp IHsKKyAgICAgICAgbmVlZE1vcmVDb250ZXh0ID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIGxlbmd0 aDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmRO ZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRv V29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1ZSwgTG9naWNhbGx5QmVmb3JlV29y ZCk7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2Fs bHlBZnRlcldvcmQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIHVuc2lnbmVkIGxlbmd0aCwgdW5z aWduZWQgb2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHkgbWF5SGF2ZU1v cmVDb250ZXh0LCBib29sJiBuZWVkTW9yZUNvbnRleHQpCit7CisgICAgaWYgKG1heUhhdmVNb3Jl Q29udGV4dCAmJiBlbmRPZkZpcnN0V29yZEJvdW5kYXJ5Q29udGV4dChjaGFyYWN0ZXJzICsgb2Zm c2V0LCBsZW5ndGggLSBvZmZzZXQpID09IHN0YXRpY19jYXN0PGludD4obGVuZ3RoIC0gb2Zmc2V0 KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4gbGVu Z3RoOworICAgIH0KKyAgICBuZWVkTW9yZUNvbnRleHQgPSBmYWxzZTsKKyAgICByZXR1cm4gZmlu ZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZl VG9Xb3JkKGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCB0cnVlLCBMb2dpY2FsbHlBZnRlcldv cmQpOworfQorCiBWaXNpYmxlUG9zaXRpb24gbmV4dFdvcmRQb3NpdGlvbihjb25zdCBWaXNpYmxl UG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIG5leHQgPSBuZXh0Qm91bmRhcnko YywgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsgICAgCkBAIC0xNjEzLDE1ICsxNjU0LDE1IEBA IHN0YXRpYyBWaXNpYmxlUG9zaXRpb24gbGVmdFdvcmRQb3NpdGlvbkEKICAgICAgICAgcmV0dXJu IGxlZnRXb3JkQm91bmRhcnkobGVmdElubGluZUJveChib3gsIGJsb2NrRGlyZWN0aW9uKSwgaW52 YWxpZE9mZnNldCwgYmxvY2tEaXJlY3Rpb24pOwogICAgIGlmIChvZmZzZXQgPT0gYm94LT5jYXJl dFJpZ2h0bW9zdE9mZnNldCgpKQogICAgICAgICByZXR1cm4gbGVmdFdvcmRCb3VuZGFyeShib3gs IG9mZnNldCwgYmxvY2tEaXJlY3Rpb24pOwotICAgIAotICAgIAorCiAgICAgVmlzaWJsZVBvc2l0 aW9uIHdvcmRCcmVhazsKLSAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKSB7Ci0gICAgICAg IGlmIChib3gtPmRpcmVjdGlvbigpID09IGJsb2NrRGlyZWN0aW9uKQotICAgICAgICAgICAgd29y ZEJyZWFrID0gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29yZFBv c2l0aW9uQm91bmRhcnkpOwotICAgICAgICBlbHNlCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBu ZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOwot ICAgIH0KKyAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKQorICAgICAgICB3b3JkQnJlYWsg PSBib3gtPmRpcmVjdGlvbigpID09IExUUiA/IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0 aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3JlV29yZCkKKyAg ICAgICAgICAgIDogbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlv bkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVh ayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9z aXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlBZnRlcldvcmQpCisg ICAgICAgICAgICA6IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRp b25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOworICAgIAogICAgIGlmICh3b3JkQnJlYWsu aXNOb3ROdWxsKCkgJiYgcG9zaXRpb25Jc0luQm94QnV0Tm90T25Cb3VuZGFyeSh3b3JkQnJlYWss IGJveCkpCiAgICAgICAgIHJldHVybiB3b3JkQnJlYWs7CiAgICAgCkBAIC0xNjUzLDEyICsxNjk0 LDEzIEBAIHN0YXRpYyBWaXNpYmxlUG9zaXRpb24gcmlnaHRXb3JkUG9zaXRpb24KICAgICAgICAg cmV0dXJuIHJpZ2h0V29yZEJvdW5kYXJ5KHJpZ2h0SW5saW5lQm94KGJveCwgYmxvY2tEaXJlY3Rp b24pLCBpbnZhbGlkT2Zmc2V0LCBibG9ja0RpcmVjdGlvbik7CiAgCiAgICAgVmlzaWJsZVBvc2l0 aW9uIHdvcmRCcmVhazsKLSAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gUlRMKSB7Ci0gICAgICAg IGlmIChib3gtPmRpcmVjdGlvbigpID09IGJsb2NrRGlyZWN0aW9uKQotICAgICAgICAgICAgd29y ZEJyZWFrID0gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29yZFBv c2l0aW9uQm91bmRhcnkpOwotICAgICAgICBlbHNlCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBu ZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOwot ICAgIH0KKyAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKQorICAgICAgICB3b3JkQnJlYWsg PSBib3gtPmRpcmVjdGlvbigpID09IExUUiA/IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24s IG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpCisgICAgICAgICAg ICA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlv bkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVh ayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlv biwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKQorICAgICAgICAg ICAgOiBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRp b25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOworICAgICAgICAgICAgICAgICAgICAKICAg ICBpZiAod29yZEJyZWFrLmlzTm90TnVsbCgpICYmIHBvc2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91 bmRhcnkod29yZEJyZWFrLCBib3gpKQogICAgICAgICByZXR1cm4gd29yZEJyZWFrOwogICAgIApJ bmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5j cHAJKHJldmlzaW9uIDkyODk4KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0 Qm91bmRhcmllcy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYzLDE2ICs2Myw0MCBAQCBpbnQgc3Rh cnRPZkxhc3RXb3JkQm91bmRhcnlDb250ZXh0KGNvbnN0CiAjaWYgIVBMQVRGT1JNKEJSRVdNUCkg JiYgIVBMQVRGT1JNKE1BQykgJiYgIVBMQVRGT1JNKFFUKQogCiBpbnQgZmluZE5leHRXb3JkRnJv bUluZGV4KGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZv cndhcmQpCit7ICAgIAorICAgIHJldHVybiBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmlu Z1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQKKyAgICAgICAgKGNoYXJzLCBsZW4s IHBvc2l0aW9uLCBmb3J3YXJkLCBmb3J3YXJkID8gTG9naWNhbGx5QWZ0ZXJXb3JkIDogTG9naWNh bGx5QmVmb3JlV29yZCk7Cit9CisKK3ZvaWQgZmluZFdvcmRCb3VuZGFyeShjb25zdCBVQ2hhciog Y2hhcnMsIGludCBsZW4sIGludCBwb3NpdGlvbiwgaW50KiBzdGFydCwgaW50KiBlbmQpCit7Cisg ICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29yZEJyZWFrSXRlcmF0b3IoY2hhcnMsIGxlbik7 CisgICAgKmVuZCA9IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9zaXRpb24pOworICAgIGlmICgq ZW5kIDwgMCkKKyAgICAgICAgKmVuZCA9IHRleHRCcmVha0xhc3QoaXQpOworICAgICpzdGFydCA9 IHRleHRCcmVha1ByZXZpb3VzKGl0KTsKK30KKworI2VuZGlmIC8vICFQTEFURk9STShCUkVXTVAp ICYmICFQTEFURk9STShNQUMpICYmICFQTEFURk9STShRVCkKKworaW50IGZpbmROZXh0V29yZEZy b21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZChjb25z dCBVQ2hhciogY2hhcnMsIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkLCBXb3Jk QnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkIHdvcmRCcmVha1Bvc2l0aW9uaW5nKQogewog ICAgIFRleHRCcmVha0l0ZXJhdG9yKiBpdCA9IHdvcmRCcmVha0l0ZXJhdG9yKGNoYXJzLCBsZW4p OwogCiAgICAgaWYgKGZvcndhcmQpIHsKICAgICAgICAgcG9zaXRpb24gPSB0ZXh0QnJlYWtGb2xs b3dpbmcoaXQsIHBvc2l0aW9uKTsKICAgICAgICAgd2hpbGUgKHBvc2l0aW9uICE9IFRleHRCcmVh a0RvbmUpIHsKLSAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNoaW5nIHdoZW4gdGhlIGNoYXJh Y3RlciBwcmVjZWVkaW5nIHRoZSBicmVhawotICAgICAgICAgICAgLy8gaXMgYWxwaGFudW1lcmlj LgotICAgICAgICAgICAgaWYgKHBvc2l0aW9uIDwgbGVuICYmIGlzQWxwaGFudW1lcmljKGNoYXJz W3Bvc2l0aW9uIC0gMV0pKQotICAgICAgICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAgICAg ICAgICAgIGlmICh3b3JkQnJlYWtQb3NpdGlvbmluZyA9PSBMb2dpY2FsbHlBZnRlcldvcmQpIHsK KyAgICAgICAgICAgICAgICAvLyBXZSBzdG9wIHNlYXJjaGluZyB3aGVuIHRoZSBjaGFyYWN0ZXIg cHJlY2VlZGluZyB0aGUgYnJlYWsKKyAgICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMu CisgICAgICAgICAgICAgICAgaWYgKHBvc2l0aW9uIDwgbGVuICYmIGlzQWxwaGFudW1lcmljKGNo YXJzW3Bvc2l0aW9uIC0gMV0pKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247 CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNo aW5nIHdoZW4gdGhlIGNoYXJhY3RlciBmb2xsb3dpbmcgdGhlIGJyZWFrCisgICAgICAgICAgICAg ICAgLy8gaXMgYWxwaGFudW1lcmljLgorICAgICAgICAgICAgICAgIGlmIChwb3NpdGlvbiA+IDAg JiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb25dKSkKKyAgICAgICAgICAgICAgICAgICAg cmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBwb3NpdGlvbiA9 IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9zaXRpb24pOwogICAgICAgICB9CkBAIC04MSwxMCAr MTA1LDE3IEBAIGludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXgoY29uc3QgVUNoYXIqIGMKICAgICB9 IGVsc2UgewogICAgICAgICBwb3NpdGlvbiA9IHRleHRCcmVha1ByZWNlZGluZyhpdCwgcG9zaXRp b24pOwogICAgICAgICB3aGlsZSAocG9zaXRpb24gIT0gVGV4dEJyZWFrRG9uZSkgewotICAgICAg ICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIGZvbGxvd2luZyB0 aGUgYnJlYWsKLSAgICAgICAgICAgIC8vIGlzIGFscGhhbnVtZXJpYy4KLSAgICAgICAgICAgIGlm IChwb3NpdGlvbiA+IDAgJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb25dKSkKLSAgICAg ICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAgICAgICAgICBpZiAod29yZEJyZWFrUG9z aXRpb25pbmcgPT0gTG9naWNhbGx5QmVmb3JlV29yZCkgeworICAgICAgICAgICAgICAgIC8vIFdl IHN0b3Agc2VhcmNoaW5nIHdoZW4gdGhlIGNoYXJhY3RlciBmb2xsb3dpbmcgdGhlIGJyZWFrCisg ICAgICAgICAgICAgICAgLy8gaXMgYWxwaGFudW1lcmljLgorICAgICAgICAgICAgICAgIGlmIChw b3NpdGlvbiA+IDAgJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb25dKSkKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAg ICAgICAgICAgICAvLyBXZSBzdG9wIHNlYXJjaGluZyB3aGVuIHRoZSBjaGFyYWN0ZXIgcHJlY2Vl ZGluZyB0aGUgYnJlYWsKKyAgICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAg ICAgICAgICAgICAgaWYgKHBvc2l0aW9uIDwgbGVuICYmIGlzQWxwaGFudW1lcmljKGNoYXJzW3Bv c2l0aW9uIC0gMV0pKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAg ICAgICAgICB9CiAKICAgICAgICAgICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrUHJlY2VkaW5nKGl0 LCBwb3NpdGlvbik7CiAgICAgICAgIH0KQEAgLTkzLDE1ICsxMjQsNCBAQCBpbnQgZmluZE5leHRX b3JkRnJvbUluZGV4KGNvbnN0IFVDaGFyKiBjCiAgICAgfQogfQogCi12b2lkIGZpbmRXb3JkQm91 bmRhcnkoY29uc3QgVUNoYXIqIGNoYXJzLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGludCogc3Rh cnQsIGludCogZW5kKQotewotICAgIFRleHRCcmVha0l0ZXJhdG9yKiBpdCA9IHdvcmRCcmVha0l0 ZXJhdG9yKGNoYXJzLCBsZW4pOwotICAgICplbmQgPSB0ZXh0QnJlYWtGb2xsb3dpbmcoaXQsIHBv c2l0aW9uKTsKLSAgICBpZiAoKmVuZCA8IDApCi0gICAgICAgICplbmQgPSB0ZXh0QnJlYWtMYXN0 KGl0KTsKLSAgICAqc3RhcnQgPSB0ZXh0QnJlYWtQcmV2aW91cyhpdCk7Ci19Ci0KLSNlbmRpZiAv LyAhUExBVEZPUk0oQlJFV01QKSAmJiAhUExBVEZPUk0oTUFDKSAmJiAhUExBVEZPUk0oUVQpCi0K IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Rl eHQvVGV4dEJvdW5kYXJpZXMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS90ZXh0L1RleHRCb3VuZGFyaWVzLmgJKHJldmlzaW9uIDkyODk4KQorKysgU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMCw2 ICszMCw4IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorICAgIGVudW0gV29yZEJyZWFrUG9z aXRpb25pbmdSZWxhdGl2ZVRvV29yZCB7IExvZ2ljYWxseUJlZm9yZVdvcmQsIExvZ2ljYWxseUFm dGVyV29yZCB9OworCiAgICAgaW5saW5lIGJvb2wgcmVxdWlyZXNDb250ZXh0Rm9yV29yZEJvdW5k YXJ5KFVDaGFyMzIgY2gpCiAgICAgewogICAgICAgICByZXR1cm4gV1RGOjpVbmljb2RlOjpoYXNM aW5lQnJlYWtpbmdQcm9wZXJ0eUNvbXBsZXhDb250ZXh0KGNoKTsKQEAgLTQwLDYgKzQyLDcgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgdm9pZCBmaW5kV29yZEJvdW5kYXJ5KGNvbnN0IFVD aGFyKiwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBpbnQqIHN0YXJ0LCBpbnQqIGVuZCk7CiAgICAg aW50IGZpbmROZXh0V29yZEZyb21JbmRleChjb25zdCBVQ2hhciosIGludCBsZW4sIGludCBwb3Np dGlvbiwgYm9vbCBmb3J3YXJkKTsKKyAgICBpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lk ZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKGNvbnN0IFVDaGFyKiwgaW50 IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQsIFdvcmRCcmVha1Bvc2l0aW9uaW5nUmVs YXRpdmVUb1dvcmQpOwogCiB9CiAKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDkyODk4KQorKysgTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDgt MTEgIFZhbiBMYW0gIDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBQcm92aWRlIGZsZXhp YmxlIChpbiB0ZXJtcyBvZiBwb3NpdGlvbiByZWxhdGl2ZSB0byBzcGFjZSkgbG9naWNhbCB3b3Jk IGJyZWFrZXIgdG8gaW1wcm92ZSBwZXJmb3JtYW5jZSBvZiAtLXdlYmtpdC12aXN1YWwtd29yZAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjUyNzcKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNeSBjaGFuZ2Ug Zml4ZWQgYSBmYWlsdXJlIGluIHRoaXMgdGVzdCBjYXNlLgorCisgICAgICAgICogZWRpdGluZy9z ZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVu dC1leHBlY3RlZC50eHQ6CisKIDIwMTEtMDgtMTEgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtp dC5vcmc+CiAKICAgICAgICAgU2hhcmUgY29kZSBiZXR3ZWVuIGlzU3R5bGVTcGFuT3JTcGFuV2l0 aE9ubHlTdHlsZUF0dHJpYnV0ZSwgaXNVbnN0eWxlZFN0eWxlU3BhbiwKSW5kZXg6IExheW91dFRl c3RzL2VkaXRpbmcvc2VsZWN0aW9uL21vdmUtYnktd29yZC12aXN1YWxseS1zaW5nbGUtc3BhY2Ut aW5saW5lLWVsZW1lbnQtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Vk aXRpbmcvc2VsZWN0aW9uL21vdmUtYnktd29yZC12aXN1YWxseS1zaW5nbGUtc3BhY2UtaW5saW5l LWVsZW1lbnQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiA5Mjg5OCkKKysrIExheW91dFRlc3RzL2Vk aXRpbmcvc2VsZWN0aW9uL21vdmUtYnktd29yZC12aXN1YWxseS1zaW5nbGUtc3BhY2UtaW5saW5l LWVsZW1lbnQtZXhwZWN0ZWQudHh0CSh3b3JraW5nIGNvcHkpCkBAIC0xMzcsOSArMTM3LDYgQEAg VGVzdCAyMCwgUlRMOgogTW92ZSBsZWZ0IGJ5IG9uZSB3b3JkCiAiQUJEIG9wcSByc3QgRFNVICJb MCwgNCwgNywgMTIsIDE2XSwgImFiYyB1dncgQUFBIGRlZiBsbW4iWzEyLCA4LCA3LCAzXSwgIkFC VyBoaWogeHl6IEZYWCJbNCwgNywgMTIsIDE1XSAgICBGQUlMIGV4cGVjdGVkOiBbIkFCRCBvcHEg cnN0IERTVSAiWyAwLCAgNCwgIDcsICAxMiwgIDE2LCBdImFiYyB1dncgQUFBIGRlZiBsbW4iWyAx NSwgIDgsICA3LCAgMywgXSJBQlcgaGlqIHh5eiBGWFgiWyA0LCAgNywgIDEyLCAgMTVdCiAiQUJE IG9wcSByc3QgRFNVICJbMTZdLCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTJdICAgRkFJTCBleHBl Y3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1XQotImFiYyB1dncgQUFBIGRlZiBsbW4iWzE4 LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgMTVdCi0iYWJjIHV2 dyBBQUEgZGVmIGxtbiJbMTcsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBs bW4iWyAxNV0KLSJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxNiwgMTJdICAgRkFJTCBleHBlY3RlZCAi YWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1XQogImFiYyB1dncgQUFBIGRlZiBsbW4iWzE1LCAxMl0g ICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0KICJhYmMgdXZ3IEFBQSBk ZWYgbG1uIlsxNCwgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDhd CiAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTMsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncg QUFBIGRlZiBsbW4iWyA4XQo= 103717 2011-08-11 18:31:43 -0700 2011-08-12 11:25:56 -0700 Proposed fix vanlam-internalapi text/plain 14827 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkyODk4KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTEtMDgtMTEgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBQcm92aWRlIGZsZXhpYmxlIChpbiB0ZXJt cyBvZiBwb3NpdGlvbiByZWxhdGl2ZSB0byBzcGFjZSkgbG9naWNhbCB3b3JkIGJyZWFrZXIgdG8g aW1wcm92ZSBwZXJmb3JtYW5jZSBvZiAtLXdlYmtpdC12aXN1YWwtd29yZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjUyNzcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBFeHRyYWN0ZWQgZnVuY3Rpb25hbGl0 eSBvZiBmaW5kTmV4dFdvcmRCb3VuZGFyeSB0byBwYXJhbWV0cml6ZSBpdCB3aXRoCisgICAgICAg IHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZSByZWxhdGl2ZSB0byB0aGUgd29yZCAobG9n aWNhbGx5IGJlZm9yZQorICAgICAgICBvciBhZnRlcikgd2hpbGUgbWFpbnRhaW5pbmcgZXhpc3Rp bmcgZnVuY3Rpb25hbGl0eS4gSW50cm9kdWNlZCBmb3VyCisgICAgICAgIHNlYXJjaCBmdW5jdGlv bnMgdG8gY2hvb3NlIHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZS4gVXRpbGl6ZWQKKyAg ICAgICAgdGhlc2UgY2hhbmdlcyBpbiByaWdodC9sZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91bmRh cnkgdG8gYXZvaWQKKyAgICAgICAgY29sbGVjdGluZyB3b3JkIGJvdW5kYXJpZXMuCisKKyAgICAg ICAgKiBlZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6cHJldmlv dXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOgorICAgICAgICAoV2Vi Q29yZTo6cHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFmdGVyV29yZCk6Cisg ICAgICAgIChXZWJDb3JlOjpuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVX b3JkKToKKyAgICAgICAgKFdlYkNvcmU6Om5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxs eUFmdGVyV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpyaWdodFdvcmRCb3VuZGFyeSk6CisgICAg ICAgIChXZWJDb3JlOjpsZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91bmRhcnkpOgorICAgICAgICAo V2ViQ29yZTo6cmlnaHRXb3JkUG9zaXRpb25BY3Jvc3NCb3VuZGFyeSk6CisgICAgICAgICogcGxh dGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpmaW5kTmV4 dFdvcmRGcm9tSW5kZXgpOgorICAgICAgICAoV2ViQ29yZTo6ZmluZFdvcmRCb3VuZGFyeSk6Cisg ICAgICAgIChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVh a1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvVGV4 dEJvdW5kYXJpZXMuaDoKKwogMjAxMS0wOC0xMSAgRGF2aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBw bGUuY29tPgogCiAgICAgICAgIDxodHRwOi8vd2Via2l0Lm9yZy9iLzY2MTEzPiBbQ0ZOZXR3b3Jr XSB3aWxsQ2FjaGVSZXNwb25zZSgpIGxlYWtzIENGQ2FjaGVkVVJMUmVzcG9uc2VSZWYgaWYgZGVs ZWdhdGUgY2hhbmdlcyBDYWNoZVN0b3JhZ2VQb2xpY3kKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvdmlzaWJsZV91bml0cy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvZWRp dGluZy92aXNpYmxlX3VuaXRzLmNwcAkocmV2aXNpb24gOTI4OTkpCisrKyBTb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01Miw2ICs1Miw3 IEBAIHVzaW5nIG5hbWVzcGFjZSBXVEY6OlVuaWNvZGU7CiBlbnVtIEJvdW5kYXJ5U2VhcmNoQ29u dGV4dEF2YWlsYWJpbGl0eSB7IERvbnRIYXZlTW9yZUNvbnRleHQsIE1heUhhdmVNb3JlQ29udGV4 dCB9OwogCiB0eXBlZGVmIHVuc2lnbmVkICgqQm91bmRhcnlTZWFyY2hGdW5jdGlvbikoY29uc3Qg VUNoYXIqLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIG9mZnNldCwgQm91bmRhcnlTZWFyY2hD b250ZXh0QXZhaWxhYmlsaXR5LCBib29sJiBuZWVkTW9yZUNvbnRleHQpOwordHlwZWRlZiB1bnNp Z25lZCAoKkJvdW5kYXJ5U2VhcmNoRnVuY3Rpb25Db25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9u aW5nKShjb25zdCBVQ2hhciosIHVuc2lnbmVkIGxlbmd0aCwgdW5zaWduZWQgb2Zmc2V0LCBCb3Vu ZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHksIGJvb2wmIG5lZWRNb3JlQ29udGV4dCwgV29y ZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZCk7CiAKIHN0YXRpYyBWaXNpYmxlUG9zaXRp b24gcHJldmlvdXNCb3VuZGFyeShjb25zdCBWaXNpYmxlUG9zaXRpb24mIGMsIEJvdW5kYXJ5U2Vh cmNoRnVuY3Rpb24gc2VhcmNoRnVuY3Rpb24pCiB7CkBAIC0yODksNiArMjkwLDI2IEBAIHN0YXRp YyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW4KICAgICByZXR1cm4gZmluZE5leHRX b3JkRnJvbUluZGV4KGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCBmYWxzZSk7CiB9CiAKK3N0 YXRpYyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3Jl V29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBv ZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9yZUNvbnRl eHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVDb250ZXh0 ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywgb2Zmc2V0KSkg eworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4gMDsKKyAg ICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmROZXh0V29y ZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZChj aGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUJlZm9yZVdvcmQpOwor fQorCitzdGF0aWMgdW5zaWduZWQgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxs eUFmdGVyV29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNp Z25lZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9y ZUNvbnRleHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVD b250ZXh0ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywgb2Zm c2V0KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4g MDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmRO ZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRv V29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUFmdGVyV29y ZCk7Cit9CisKIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c1dvcmRQb3NpdGlvbihjb25zdCBWaXNp YmxlUG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHByZXYgPSBwcmV2aW91c0Jv dW5kYXJ5KGMsIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwpAQCAtMzA1LDYgKzMyNiwy NiBAQCBzdGF0aWMgdW5zaWduZWQgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5CiAgICAgcmV0dXJu IGZpbmROZXh0V29yZEZyb21JbmRleChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1ZSk7 CiB9CiAKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlC ZWZvcmVXb3JkKGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2ln bmVkIG9mZnNldCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5IG1heUhhdmVNb3Jl Q29udGV4dCwgYm9vbCYgbmVlZE1vcmVDb250ZXh0KQoreworICAgIGlmIChtYXlIYXZlTW9yZUNv bnRleHQgJiYgZW5kT2ZGaXJzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycyArIG9mZnNl dCwgbGVuZ3RoIC0gb2Zmc2V0KSA9PSBzdGF0aWNfY2FzdDxpbnQ+KGxlbmd0aCAtIG9mZnNldCkp IHsKKyAgICAgICAgbmVlZE1vcmVDb250ZXh0ID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIGxlbmd0 aDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmRO ZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRv V29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1ZSwgTG9naWNhbGx5QmVmb3JlV29y ZCk7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2Fs bHlBZnRlcldvcmQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIHVuc2lnbmVkIGxlbmd0aCwgdW5z aWduZWQgb2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHkgbWF5SGF2ZU1v cmVDb250ZXh0LCBib29sJiBuZWVkTW9yZUNvbnRleHQpCit7CisgICAgaWYgKG1heUhhdmVNb3Jl Q29udGV4dCAmJiBlbmRPZkZpcnN0V29yZEJvdW5kYXJ5Q29udGV4dChjaGFyYWN0ZXJzICsgb2Zm c2V0LCBsZW5ndGggLSBvZmZzZXQpID09IHN0YXRpY19jYXN0PGludD4obGVuZ3RoIC0gb2Zmc2V0 KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4gbGVu Z3RoOworICAgIH0KKyAgICBuZWVkTW9yZUNvbnRleHQgPSBmYWxzZTsKKyAgICByZXR1cm4gZmlu ZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZl VG9Xb3JkKGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCB0cnVlLCBMb2dpY2FsbHlBZnRlcldv cmQpOworfQorCiBWaXNpYmxlUG9zaXRpb24gbmV4dFdvcmRQb3NpdGlvbihjb25zdCBWaXNpYmxl UG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIG5leHQgPSBuZXh0Qm91bmRhcnko YywgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsgICAgCkBAIC0xNjEzLDE1ICsxNjU0LDE1IEBA IHN0YXRpYyBWaXNpYmxlUG9zaXRpb24gbGVmdFdvcmRQb3NpdGlvbkEKICAgICAgICAgcmV0dXJu IGxlZnRXb3JkQm91bmRhcnkobGVmdElubGluZUJveChib3gsIGJsb2NrRGlyZWN0aW9uKSwgaW52 YWxpZE9mZnNldCwgYmxvY2tEaXJlY3Rpb24pOwogICAgIGlmIChvZmZzZXQgPT0gYm94LT5jYXJl dFJpZ2h0bW9zdE9mZnNldCgpKQogICAgICAgICByZXR1cm4gbGVmdFdvcmRCb3VuZGFyeShib3gs IG9mZnNldCwgYmxvY2tEaXJlY3Rpb24pOwotICAgIAotICAgIAorCiAgICAgVmlzaWJsZVBvc2l0 aW9uIHdvcmRCcmVhazsKLSAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKSB7Ci0gICAgICAg IGlmIChib3gtPmRpcmVjdGlvbigpID09IGJsb2NrRGlyZWN0aW9uKQotICAgICAgICAgICAgd29y ZEJyZWFrID0gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29yZFBv c2l0aW9uQm91bmRhcnkpOwotICAgICAgICBlbHNlCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBu ZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOwot ICAgIH0KKyAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKQorICAgICAgICB3b3JkQnJlYWsg PSBib3gtPmRpcmVjdGlvbigpID09IExUUiA/IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0 aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3JlV29yZCkKKyAg ICAgICAgICAgIDogbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlv bkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVh ayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9z aXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlBZnRlcldvcmQpCisg ICAgICAgICAgICA6IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRp b25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOworICAgIAogICAgIGlmICh3b3JkQnJlYWsu aXNOb3ROdWxsKCkgJiYgcG9zaXRpb25Jc0luQm94QnV0Tm90T25Cb3VuZGFyeSh3b3JkQnJlYWss IGJveCkpCiAgICAgICAgIHJldHVybiB3b3JkQnJlYWs7CiAgICAgCkBAIC0xNjUzLDEyICsxNjk0 LDEzIEBAIHN0YXRpYyBWaXNpYmxlUG9zaXRpb24gcmlnaHRXb3JkUG9zaXRpb24KICAgICAgICAg cmV0dXJuIHJpZ2h0V29yZEJvdW5kYXJ5KHJpZ2h0SW5saW5lQm94KGJveCwgYmxvY2tEaXJlY3Rp b24pLCBpbnZhbGlkT2Zmc2V0LCBibG9ja0RpcmVjdGlvbik7CiAgCiAgICAgVmlzaWJsZVBvc2l0 aW9uIHdvcmRCcmVhazsKLSAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gUlRMKSB7Ci0gICAgICAg IGlmIChib3gtPmRpcmVjdGlvbigpID09IGJsb2NrRGlyZWN0aW9uKQotICAgICAgICAgICAgd29y ZEJyZWFrID0gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29yZFBv c2l0aW9uQm91bmRhcnkpOwotICAgICAgICBlbHNlCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBu ZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOwot ICAgIH0KKyAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKQorICAgICAgICB3b3JkQnJlYWsg PSBib3gtPmRpcmVjdGlvbigpID09IExUUiA/IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24s IG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpCisgICAgICAgICAg ICA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlv bkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVh ayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlv biwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QWZ0ZXJXb3JkKQorICAgICAgICAg ICAgOiBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRp b25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOworICAgICAgICAgICAgICAgICAgICAKICAg ICBpZiAod29yZEJyZWFrLmlzTm90TnVsbCgpICYmIHBvc2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91 bmRhcnkod29yZEJyZWFrLCBib3gpKQogICAgICAgICByZXR1cm4gd29yZEJyZWFrOwogICAgIApJ bmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5j cHAJKHJldmlzaW9uIDkyODk4KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0 Qm91bmRhcmllcy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYzLDE2ICs2Myw0MCBAQCBpbnQgc3Rh cnRPZkxhc3RXb3JkQm91bmRhcnlDb250ZXh0KGNvbnN0CiAjaWYgIVBMQVRGT1JNKEJSRVdNUCkg JiYgIVBMQVRGT1JNKE1BQykgJiYgIVBMQVRGT1JNKFFUKQogCiBpbnQgZmluZE5leHRXb3JkRnJv bUluZGV4KGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZv cndhcmQpCit7ICAgIAorICAgIHJldHVybiBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmlu Z1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQKKyAgICAgICAgKGNoYXJzLCBsZW4s IHBvc2l0aW9uLCBmb3J3YXJkLCBmb3J3YXJkID8gTG9naWNhbGx5QWZ0ZXJXb3JkIDogTG9naWNh bGx5QmVmb3JlV29yZCk7Cit9CisKK3ZvaWQgZmluZFdvcmRCb3VuZGFyeShjb25zdCBVQ2hhciog Y2hhcnMsIGludCBsZW4sIGludCBwb3NpdGlvbiwgaW50KiBzdGFydCwgaW50KiBlbmQpCit7Cisg ICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29yZEJyZWFrSXRlcmF0b3IoY2hhcnMsIGxlbik7 CisgICAgKmVuZCA9IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9zaXRpb24pOworICAgIGlmICgq ZW5kIDwgMCkKKyAgICAgICAgKmVuZCA9IHRleHRCcmVha0xhc3QoaXQpOworICAgICpzdGFydCA9 IHRleHRCcmVha1ByZXZpb3VzKGl0KTsKK30KKworI2VuZGlmIC8vICFQTEFURk9STShCUkVXTVAp ICYmICFQTEFURk9STShNQUMpICYmICFQTEFURk9STShRVCkKKworaW50IGZpbmROZXh0V29yZEZy b21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZChjb25z dCBVQ2hhciogY2hhcnMsIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkLCBXb3Jk QnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkIHdvcmRCcmVha1Bvc2l0aW9uaW5nKQogewog ICAgIFRleHRCcmVha0l0ZXJhdG9yKiBpdCA9IHdvcmRCcmVha0l0ZXJhdG9yKGNoYXJzLCBsZW4p OwogCiAgICAgaWYgKGZvcndhcmQpIHsKICAgICAgICAgcG9zaXRpb24gPSB0ZXh0QnJlYWtGb2xs b3dpbmcoaXQsIHBvc2l0aW9uKTsKICAgICAgICAgd2hpbGUgKHBvc2l0aW9uICE9IFRleHRCcmVh a0RvbmUpIHsKLSAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNoaW5nIHdoZW4gdGhlIGNoYXJh Y3RlciBwcmVjZWVkaW5nIHRoZSBicmVhawotICAgICAgICAgICAgLy8gaXMgYWxwaGFudW1lcmlj LgotICAgICAgICAgICAgaWYgKHBvc2l0aW9uIDwgbGVuICYmIGlzQWxwaGFudW1lcmljKGNoYXJz W3Bvc2l0aW9uIC0gMV0pKQotICAgICAgICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAgICAg ICAgICAgIGlmICh3b3JkQnJlYWtQb3NpdGlvbmluZyA9PSBMb2dpY2FsbHlBZnRlcldvcmQpIHsK KyAgICAgICAgICAgICAgICAvLyBXZSBzdG9wIHNlYXJjaGluZyB3aGVuIHRoZSBjaGFyYWN0ZXIg cHJlY2VlZGluZyB0aGUgYnJlYWsKKyAgICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMu CisgICAgICAgICAgICAgICAgaWYgKHBvc2l0aW9uIDwgbGVuICYmIGlzQWxwaGFudW1lcmljKGNo YXJzW3Bvc2l0aW9uIC0gMV0pKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247 CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNo aW5nIHdoZW4gdGhlIGNoYXJhY3RlciBmb2xsb3dpbmcgdGhlIGJyZWFrCisgICAgICAgICAgICAg ICAgLy8gaXMgYWxwaGFudW1lcmljLgorICAgICAgICAgICAgICAgIGlmIChwb3NpdGlvbiA+IDAg JiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb25dKSkKKyAgICAgICAgICAgICAgICAgICAg cmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBwb3NpdGlvbiA9 IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9zaXRpb24pOwogICAgICAgICB9CkBAIC04MSwxMCAr MTA1LDE3IEBAIGludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXgoY29uc3QgVUNoYXIqIGMKICAgICB9 IGVsc2UgewogICAgICAgICBwb3NpdGlvbiA9IHRleHRCcmVha1ByZWNlZGluZyhpdCwgcG9zaXRp b24pOwogICAgICAgICB3aGlsZSAocG9zaXRpb24gIT0gVGV4dEJyZWFrRG9uZSkgewotICAgICAg ICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIGZvbGxvd2luZyB0 aGUgYnJlYWsKLSAgICAgICAgICAgIC8vIGlzIGFscGhhbnVtZXJpYy4KLSAgICAgICAgICAgIGlm IChwb3NpdGlvbiA+IDAgJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb25dKSkKLSAgICAg ICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAgICAgICAgICBpZiAod29yZEJyZWFrUG9z aXRpb25pbmcgPT0gTG9naWNhbGx5QmVmb3JlV29yZCkgeworICAgICAgICAgICAgICAgIC8vIFdl IHN0b3Agc2VhcmNoaW5nIHdoZW4gdGhlIGNoYXJhY3RlciBmb2xsb3dpbmcgdGhlIGJyZWFrCisg ICAgICAgICAgICAgICAgLy8gaXMgYWxwaGFudW1lcmljLgorICAgICAgICAgICAgICAgIGlmIChw b3NpdGlvbiA+IDAgJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb25dKSkKKyAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAg ICAgICAgICAgICAvLyBXZSBzdG9wIHNlYXJjaGluZyB3aGVuIHRoZSBjaGFyYWN0ZXIgcHJlY2Vl ZGluZyB0aGUgYnJlYWsKKyAgICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAg ICAgICAgICAgICAgaWYgKHBvc2l0aW9uIDwgbGVuICYmIGlzQWxwaGFudW1lcmljKGNoYXJzW3Bv c2l0aW9uIC0gMV0pKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAg ICAgICAgICB9CiAKICAgICAgICAgICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrUHJlY2VkaW5nKGl0 LCBwb3NpdGlvbik7CiAgICAgICAgIH0KQEAgLTkzLDE1ICsxMjQsNCBAQCBpbnQgZmluZE5leHRX b3JkRnJvbUluZGV4KGNvbnN0IFVDaGFyKiBjCiAgICAgfQogfQogCi12b2lkIGZpbmRXb3JkQm91 bmRhcnkoY29uc3QgVUNoYXIqIGNoYXJzLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGludCogc3Rh cnQsIGludCogZW5kKQotewotICAgIFRleHRCcmVha0l0ZXJhdG9yKiBpdCA9IHdvcmRCcmVha0l0 ZXJhdG9yKGNoYXJzLCBsZW4pOwotICAgICplbmQgPSB0ZXh0QnJlYWtGb2xsb3dpbmcoaXQsIHBv c2l0aW9uKTsKLSAgICBpZiAoKmVuZCA8IDApCi0gICAgICAgICplbmQgPSB0ZXh0QnJlYWtMYXN0 KGl0KTsKLSAgICAqc3RhcnQgPSB0ZXh0QnJlYWtQcmV2aW91cyhpdCk7Ci19Ci0KLSNlbmRpZiAv LyAhUExBVEZPUk0oQlJFV01QKSAmJiAhUExBVEZPUk0oTUFDKSAmJiAhUExBVEZPUk0oUVQpCi0K IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Rl eHQvVGV4dEJvdW5kYXJpZXMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS90ZXh0L1RleHRCb3VuZGFyaWVzLmgJKHJldmlzaW9uIDkyODk4KQorKysgU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMCwx NiArMzAsMTkgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi0gICAgaW5saW5lIGJvb2wgcmVx dWlyZXNDb250ZXh0Rm9yV29yZEJvdW5kYXJ5KFVDaGFyMzIgY2gpCi0gICAgewotICAgICAgICBy ZXR1cm4gV1RGOjpVbmljb2RlOjpoYXNMaW5lQnJlYWtpbmdQcm9wZXJ0eUNvbXBsZXhDb250ZXh0 KGNoKTsKLSAgICB9CitlbnVtIFdvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQgeyBM b2dpY2FsbHlCZWZvcmVXb3JkLCBMb2dpY2FsbHlBZnRlcldvcmQgfTsKIAotICAgIGludCBlbmRP ZkZpcnN0V29yZEJvdW5kYXJ5Q29udGV4dChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgaW50IGxl bmd0aCk7Ci0gICAgaW50IHN0YXJ0T2ZMYXN0V29yZEJvdW5kYXJ5Q29udGV4dChjb25zdCBVQ2hh ciogY2hhcmFjdGVycywgaW50IGxlbmd0aCk7CitpbmxpbmUgYm9vbCByZXF1aXJlc0NvbnRleHRG b3JXb3JkQm91bmRhcnkoVUNoYXIzMiBjaCkKK3sKKyAgICByZXR1cm4gV1RGOjpVbmljb2RlOjpo YXNMaW5lQnJlYWtpbmdQcm9wZXJ0eUNvbXBsZXhDb250ZXh0KGNoKTsKK30KKworaW50IGVuZE9m Rmlyc3RXb3JkQm91bmRhcnlDb250ZXh0KGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCBpbnQgbGVu Z3RoKTsKK2ludCBzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY29uc3QgVUNoYXIqIGNo YXJhY3RlcnMsIGludCBsZW5ndGgpOwogCi0gICAgdm9pZCBmaW5kV29yZEJvdW5kYXJ5KGNvbnN0 IFVDaGFyKiwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBpbnQqIHN0YXJ0LCBpbnQqIGVuZCk7Ci0g ICAgaW50IGZpbmROZXh0V29yZEZyb21JbmRleChjb25zdCBVQ2hhciosIGludCBsZW4sIGludCBw b3NpdGlvbiwgYm9vbCBmb3J3YXJkKTsKK3ZvaWQgZmluZFdvcmRCb3VuZGFyeShjb25zdCBVQ2hh ciosIGludCBsZW4sIGludCBwb3NpdGlvbiwgaW50KiBzdGFydCwgaW50KiBlbmQpOworaW50IGZp bmROZXh0V29yZEZyb21JbmRleChjb25zdCBVQ2hhciosIGludCBsZW4sIGludCBwb3NpdGlvbiwg Ym9vbCBmb3J3YXJkKTsKK2ludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRC cmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQoY29uc3QgVUNoYXIqLCBpbnQgbGVuLCBpbnQg cG9zaXRpb24sIGJvb2wgZm9yd2FyZCwgV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29y ZCk7CiAKIH0KIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gOTI4OTgpCisrKyBMYXlvdXRUZXN0cy9DaGFu Z2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wOC0xMSAgVmFuIExh bSAgPHZhbmxhbUBnb29nbGUuY29tPgorCisgICAgICAgIFByb3ZpZGUgZmxleGlibGUgKGluIHRl cm1zIG9mIHBvc2l0aW9uIHJlbGF0aXZlIHRvIHNwYWNlKSBsb2dpY2FsIHdvcmQgYnJlYWtlciB0 byBpbXByb3ZlIHBlcmZvcm1hbmNlIG9mIC0td2Via2l0LXZpc3VhbC13b3JkCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NTI3NworCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE15IGNoYW5nZSBmaXhlZCBhIGZh aWx1cmUgaW4gdGhpcyB0ZXN0IGNhc2UuCisKKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9t b3ZlLWJ5LXdvcmQtdmlzdWFsbHktc2luZ2xlLXNwYWNlLWlubGluZS1lbGVtZW50LWV4cGVjdGVk LnR4dDoKKwogMjAxMS0wOC0xMSAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KIAog ICAgICAgICBTaGFyZSBjb2RlIGJldHdlZW4gaXNTdHlsZVNwYW5PclNwYW5XaXRoT25seVN0eWxl QXR0cmlidXRlLCBpc1Vuc3R5bGVkU3R5bGVTcGFuLApJbmRleDogTGF5b3V0VGVzdHMvZWRpdGlu Zy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxl bWVudC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxl Y3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1l eHBlY3RlZC50eHQJKHJldmlzaW9uIDkyODk4KQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxl Y3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1l eHBlY3RlZC50eHQJKHdvcmtpbmcgY29weSkKQEAgLTEzNyw5ICsxMzcsNiBAQCBUZXN0IDIwLCBS VEw6CiBNb3ZlIGxlZnQgYnkgb25lIHdvcmQKICJBQkQgb3BxIHJzdCBEU1UgIlswLCA0LCA3LCAx MiwgMTZdLCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTIsIDgsIDcsIDNdLCAiQUJXIGhpaiB4eXog RlhYIls0LCA3LCAxMiwgMTVdICAgIEZBSUwgZXhwZWN0ZWQ6IFsiQUJEIG9wcSByc3QgRFNVICJb IDAsICA0LCAgNywgIDEyLCAgMTYsIF0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1LCAgOCwgIDcs ICAzLCBdIkFCVyBoaWogeHl6IEZYWCJbIDQsICA3LCAgMTIsICAxNV0KICJBQkQgb3BxIHJzdCBE U1UgIlsxNl0sICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMg dXZ3IEFBQSBkZWYgbG1uIlsgMTVdCi0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTgsIDEyXSAgIEZB SUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KLSJhYmMgdXZ3IEFBQSBkZWYg bG1uIlsxNywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1XQot ImFiYyB1dncgQUFBIGRlZiBsbW4iWzE2LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFB QSBkZWYgbG1uIlsgMTVdCiAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTUsIDEyXSAgIEZBSUwgZXhw ZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyA4XQogImFiYyB1dncgQUFBIGRlZiBsbW4iWzE0 LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0KICJhYmMgdXZ3 IEFBQSBkZWYgbG1uIlsxMywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxt biJbIDhdCg== 103963 2011-08-15 15:23:18 -0700 2011-08-15 15:56:29 -0700 Proposed fix vanlam-internalapi text/plain 16985 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkzMDYyKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTEtMDgtMTUgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBQcm92aWRlIGZsZXhpYmxlIChpbiB0ZXJt cyBvZiBwb3NpdGlvbiByZWxhdGl2ZSB0byBzcGFjZSkgbG9naWNhbCB3b3JkIGJyZWFrZXIgdG8g aW1wcm92ZSBwZXJmb3JtYW5jZSBvZiAtLXdlYmtpdC12aXN1YWwtd29yZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjUyNzcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBFeHRyYWN0ZWQgZnVuY3Rpb25hbGl0 eSBvZiBmaW5kTmV4dFdvcmRCb3VuZGFyeSB0byBwYXJhbWV0cml6ZSBpdCB3aXRoCisgICAgICAg IHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZSByZWxhdGl2ZSB0byB0aGUgd29yZCAobG9n aWNhbGx5IGJlZm9yZQorICAgICAgICBvciBhZnRlcikgd2hpbGUgbWFpbnRhaW5pbmcgZXhpc3Rp bmcgZnVuY3Rpb25hbGl0eS4gSW50cm9kdWNlZCBmb3VyCisgICAgICAgIHNlYXJjaCBmdW5jdGlv bnMgdG8gY2hvb3NlIHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZS4gVXRpbGl6ZWQKKyAg ICAgICAgdGhlc2UgY2hhbmdlcyBpbiByaWdodC9sZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91bmRh cnkgdG8gYXZvaWQKKyAgICAgICAgY29sbGVjdGluZyB3b3JkIGJvdW5kYXJpZXMuCisKKyAgICAg ICAgKiBlZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6cHJldmlv dXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOgorICAgICAgICAoV2Vi Q29yZTo6cHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFmdGVyV29yZCk6Cisg ICAgICAgIChXZWJDb3JlOjpuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVX b3JkKToKKyAgICAgICAgKFdlYkNvcmU6Om5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxs eUFmdGVyV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpsZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91 bmRhcnkpOgorICAgICAgICAoV2ViQ29yZTo6cmlnaHRXb3JkUG9zaXRpb25BY3Jvc3NCb3VuZGFy eSk6CisgICAgICAgICogcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHA6CisgICAgICAg IChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0 aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAoV2ViQ29yZTo6ZmluZE5leHRXb3JkRnJv bUluZGV4KToKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVzLmg6CisgICAg ICAgICogcGxhdGZvcm0vdGV4dC9icmV3L1RleHRCb3VuZGFyaWVzQnJldy5jcHA6CisgICAgICAg IChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0 aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvcXQvVGV4dEJv dW5kYXJpZXNRdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhD b25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAo V2ViQ29yZTo6ZmluZE5leHRXb3JkRnJvbUluZGV4KToKKwogMjAxMS0wOC0xNSAgTWFyayBIYWhu ZW5iZXJnICA8bWhhaG5lbmJlcmdAYXBwbGUuY29tPgogCiAgICAgICAgIFJlZmFjdG9yIEpTIG9i amVjdHMgdG8gYWxsb2NhdGUgaW4gc3RhdGljIGNyZWF0ZSBtZXRob2RzIHJhdGhlciB0aGFuIGNv bnN0cnVjdG9ycwpJbmRleDogU291cmNlL1dlYkNvcmUvZWRpdGluZy92aXNpYmxlX3VuaXRzLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3Bw CShyZXZpc2lvbiA5MzA2MikKKysrIFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvdmlzaWJsZV91bml0 cy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUzLDYgKzUzLDggQEAgZW51bSBCb3VuZGFyeVNlYXJj aENvbnRleHRBdmFpbGFiaWxpdHkgewogCiB0eXBlZGVmIHVuc2lnbmVkICgqQm91bmRhcnlTZWFy Y2hGdW5jdGlvbikoY29uc3QgVUNoYXIqLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIG9mZnNl dCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5LCBib29sJiBuZWVkTW9yZUNvbnRl eHQpOwogCit0eXBlZGVmIHVuc2lnbmVkICgqQm91bmRhcnlTZWFyY2hGdW5jdGlvbkNvbnNpZGVy aW5nV29yZEJyZWFrUG9zaXRpb25pbmcpKGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVuZ3RoLCB1 bnNpZ25lZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSwgYm9vbCYg bmVlZE1vcmVDb250ZXh0LCBXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKTsKKwog c3RhdGljIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c0JvdW5kYXJ5KGNvbnN0IFZpc2libGVQb3Np dGlvbiYgYywgQm91bmRhcnlTZWFyY2hGdW5jdGlvbiBzZWFyY2hGdW5jdGlvbikKIHsKICAgICBQ b3NpdGlvbiBwb3MgPSBjLmRlZXBFcXVpdmFsZW50KCk7CkBAIC0yODksNiArMjkxLDI2IEBAIHN0 YXRpYyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW4KICAgICByZXR1cm4gZmluZE5l eHRXb3JkRnJvbUluZGV4KGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCBmYWxzZSk7CiB9CiAK K3N0YXRpYyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVm b3JlV29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25l ZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9yZUNv bnRleHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVDb250 ZXh0ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywgb2Zmc2V0 KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4gMDsK KyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmROZXh0 V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29y ZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUJlZm9yZVdvcmQp OworfQorCitzdGF0aWMgdW5zaWduZWQgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2lj YWxseUFmdGVyV29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1 bnNpZ25lZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZl TW9yZUNvbnRleHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1v cmVDb250ZXh0ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywg b2Zmc2V0KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1 cm4gMDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZp bmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2 ZVRvV29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUFmdGVy V29yZCk7Cit9CisKIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c1dvcmRQb3NpdGlvbihjb25zdCBW aXNpYmxlUG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHByZXYgPSBwcmV2aW91 c0JvdW5kYXJ5KGMsIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwpAQCAtMzA1LDYgKzMy NywyNiBAQCBzdGF0aWMgdW5zaWduZWQgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5CiAgICAgcmV0 dXJuIGZpbmROZXh0V29yZEZyb21JbmRleChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1 ZSk7CiB9CiAKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2Fs bHlCZWZvcmVXb3JkKGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCB1bnNpZ25lZCBsZW5ndGgsIHVu c2lnbmVkIG9mZnNldCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5IG1heUhhdmVN b3JlQ29udGV4dCwgYm9vbCYgbmVlZE1vcmVDb250ZXh0KQoreworICAgIGlmIChtYXlIYXZlTW9y ZUNvbnRleHQgJiYgZW5kT2ZGaXJzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycyArIG9m ZnNldCwgbGVuZ3RoIC0gb2Zmc2V0KSA9PSBzdGF0aWNfY2FzdDxpbnQ+KGxlbmd0aCAtIG9mZnNl dCkpIHsKKyAgICAgICAgbmVlZE1vcmVDb250ZXh0ID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIGxl bmd0aDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZp bmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2 ZVRvV29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1ZSwgTG9naWNhbGx5QmVmb3Jl V29yZCk7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dp Y2FsbHlBZnRlcldvcmQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIHVuc2lnbmVkIGxlbmd0aCwg dW5zaWduZWQgb2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHkgbWF5SGF2 ZU1vcmVDb250ZXh0LCBib29sJiBuZWVkTW9yZUNvbnRleHQpCit7CisgICAgaWYgKG1heUhhdmVN b3JlQ29udGV4dCAmJiBlbmRPZkZpcnN0V29yZEJvdW5kYXJ5Q29udGV4dChjaGFyYWN0ZXJzICsg b2Zmc2V0LCBsZW5ndGggLSBvZmZzZXQpID09IHN0YXRpY19jYXN0PGludD4obGVuZ3RoIC0gb2Zm c2V0KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4g bGVuZ3RoOworICAgIH0KKyAgICBuZWVkTW9yZUNvbnRleHQgPSBmYWxzZTsKKyAgICByZXR1cm4g ZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0 aXZlVG9Xb3JkKGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCB0cnVlLCBMb2dpY2FsbHlBZnRl cldvcmQpOworfQorCiBWaXNpYmxlUG9zaXRpb24gbmV4dFdvcmRQb3NpdGlvbihjb25zdCBWaXNp YmxlUG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIG5leHQgPSBuZXh0Qm91bmRh cnkoYywgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsgICAgCkBAIC0xNjE0LDE0ICsxNjU2LDE1 IEBAIHN0YXRpYyBWaXNpYmxlUG9zaXRpb24gbGVmdFdvcmRQb3NpdGlvbkEKICAgICBpZiAob2Zm c2V0ID09IGJveC0+Y2FyZXRSaWdodG1vc3RPZmZzZXQoKSkKICAgICAgICAgcmV0dXJuIGxlZnRX b3JkQm91bmRhcnkoYm94LCBvZmZzZXQsIGJsb2NrRGlyZWN0aW9uKTsKICAgICAKLSAgICAKICAg ICBWaXNpYmxlUG9zaXRpb24gd29yZEJyZWFrOwotICAgIGlmIChibG9ja0RpcmVjdGlvbiA9PSBM VFIpIHsKLSAgICAgICAgaWYgKGJveC0+ZGlyZWN0aW9uKCkgPT0gYmxvY2tEaXJlY3Rpb24pCi0g ICAgICAgICAgICB3b3JkQnJlYWsgPSBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwg cHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAg IHdvcmRCcmVhayA9IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRp b25Cb3VuZGFyeSk7Ci0gICAgfQorICAgIAorICAgIGlmIChibG9ja0RpcmVjdGlvbiA9PSBMVFIp CisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gcHJldmlvdXNC b3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlMb2dp Y2FsbHlCZWZvcmVXb3JkKQorICAgICAgICAgICAgOiBuZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0 aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlBZnRlcldvcmQpOworICAgIGVs c2UKKyAgICAgICAgd29yZEJyZWFrID0gYm94LT5kaXJlY3Rpb24oKSA9PSBMVFIgPyBwcmV2aW91 c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxv Z2ljYWxseUFmdGVyV29yZCkKKyAgICAgICAgICAgIDogbmV4dEJvdW5kYXJ5KHZpc2libGVQb3Np dGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3JlV29yZCk7CisgICAg CiAgICAgaWYgKHdvcmRCcmVhay5pc05vdE51bGwoKSAmJiBwb3NpdGlvbklzSW5Cb3hCdXROb3RP bkJvdW5kYXJ5KHdvcmRCcmVhaywgYm94KSkKICAgICAgICAgcmV0dXJuIHdvcmRCcmVhazsKICAg ICAKQEAgLTE2NTMsMTIgKzE2OTYsMTQgQEAgc3RhdGljIFZpc2libGVQb3NpdGlvbiByaWdodFdv cmRQb3NpdGlvbgogICAgICAgICByZXR1cm4gcmlnaHRXb3JkQm91bmRhcnkocmlnaHRJbmxpbmVC b3goYm94LCBibG9ja0RpcmVjdGlvbiksIGludmFsaWRPZmZzZXQsIGJsb2NrRGlyZWN0aW9uKTsK ICAKICAgICBWaXNpYmxlUG9zaXRpb24gd29yZEJyZWFrOwotICAgIGlmIChibG9ja0RpcmVjdGlv biA9PSBSVEwpIHsKLSAgICAgICAgaWYgKGJveC0+ZGlyZWN0aW9uKCkgPT0gYmxvY2tEaXJlY3Rp b24pCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3Np dGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgICAgIGVsc2UKLSAgICAg ICAgICAgIHdvcmRCcmVhayA9IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3Jk UG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgfQorICAgIAorICAgIGlmIChibG9ja0RpcmVjdGlvbiA9 PSBMVFIpCisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gbmV4 dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNh bGx5QmVmb3JlV29yZCkKKyAgICAgICAgICAgIDogcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9z aXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlBZnRlcldvcmQpOwor ICAgIGVsc2UKKyAgICAgICAgd29yZEJyZWFrID0gYm94LT5kaXJlY3Rpb24oKSA9PSBMVFIgPyBu ZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dp Y2FsbHlBZnRlcldvcmQpCisgICAgICAgICAgICA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBv c2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3JlV29yZCk7 CisgICAgICAgICAgICAKICAgICBpZiAod29yZEJyZWFrLmlzTm90TnVsbCgpICYmIHBvc2l0aW9u SXNJbkJveEJ1dE5vdE9uQm91bmRhcnkod29yZEJyZWFrLCBib3gpKQogICAgICAgICByZXR1cm4g d29yZEJyZWFrOwogICAgIApJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0 Qm91bmRhcmllcy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4 dC9UZXh0Qm91bmRhcmllcy5jcHAJKHJldmlzaW9uIDkzMDYyKQorKysgU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYwLDE5 ICs2MCwyNiBAQCBpbnQgc3RhcnRPZkxhc3RXb3JkQm91bmRhcnlDb250ZXh0KGNvbnN0CiAgICAg cmV0dXJuIDA7CiB9CiAKLSNpZiAhUExBVEZPUk0oQlJFV01QKSAmJiAhUExBVEZPUk0oTUFDKSAm JiAhUExBVEZPUk0oUVQpCisjaWYgIVBMQVRGT1JNKFFUKQogCi1pbnQgZmluZE5leHRXb3JkRnJv bUluZGV4KGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZv cndhcmQpCitpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3Np dGlvbmluZ1JlbGF0aXZlVG9Xb3JkKGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBv c2l0aW9uLCBib29sIGZvcndhcmQsIFdvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQg d29yZEJyZWFrUG9zaXRpb25pbmcpCiB7CiAgICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29y ZEJyZWFrSXRlcmF0b3IoY2hhcnMsIGxlbik7CiAKICAgICBpZiAoZm9yd2FyZCkgewogICAgICAg ICBwb3NpdGlvbiA9IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9zaXRpb24pOwogICAgICAgICB3 aGlsZSAocG9zaXRpb24gIT0gVGV4dEJyZWFrRG9uZSkgewotICAgICAgICAgICAgLy8gV2Ugc3Rv cCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIHByZWNlZWRpbmcgdGhlIGJyZWFrCi0gICAg ICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCi0gICAgICAgICAgICBpZiAocG9zaXRpb24gPCBs ZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb24gLSAxXSkpCi0gICAgICAgICAgICAg ICAgcmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgaWYgKHdvcmRCcmVha1Bvc2l0aW9uaW5n ID09IExvZ2ljYWxseUFmdGVyV29yZCkgeworICAgICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2Vh cmNoaW5nIHdoZW4gdGhlIGNoYXJhY3RlciBwcmVjZWVkaW5nIHRoZSBicmVhaworICAgICAgICAg ICAgICAgIC8vIGlzIGFscGhhbnVtZXJpYy4KKyAgICAgICAgICAgICAgICBpZiAocG9zaXRpb24g PCBsZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb24gLSAxXSkpCisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIGZvbGxvd2lu ZyB0aGUgYnJlYWsKKyAgICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAgICAg ICAgICAgICAgaWYgKHBvc2l0aW9uID4gMCAmJiBpc0FscGhhbnVtZXJpYyhjaGFyc1twb3NpdGlv bl0pKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAgICAgICAgICB9 CiAKICAgICAgICAgICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrRm9sbG93aW5nKGl0LCBwb3NpdGlv bik7CiAgICAgICAgIH0KQEAgLTgxLDEwICs4OCwxNyBAQCBpbnQgZmluZE5leHRXb3JkRnJvbUlu ZGV4KGNvbnN0IFVDaGFyKiBjCiAgICAgfSBlbHNlIHsKICAgICAgICAgcG9zaXRpb24gPSB0ZXh0 QnJlYWtQcmVjZWRpbmcoaXQsIHBvc2l0aW9uKTsKICAgICAgICAgd2hpbGUgKHBvc2l0aW9uICE9 IFRleHRCcmVha0RvbmUpIHsKLSAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNoaW5nIHdoZW4g dGhlIGNoYXJhY3RlciBmb2xsb3dpbmcgdGhlIGJyZWFrCi0gICAgICAgICAgICAvLyBpcyBhbHBo YW51bWVyaWMuCi0gICAgICAgICAgICBpZiAocG9zaXRpb24gPiAwICYmIGlzQWxwaGFudW1lcmlj KGNoYXJzW3Bvc2l0aW9uXSkpCi0gICAgICAgICAgICAgICAgcmV0dXJuIHBvc2l0aW9uOworICAg ICAgICAgICAgaWYgKHdvcmRCcmVha1Bvc2l0aW9uaW5nID09IExvZ2ljYWxseUJlZm9yZVdvcmQp IHsKKyAgICAgICAgICAgICAgICAvLyBXZSBzdG9wIHNlYXJjaGluZyB3aGVuIHRoZSBjaGFyYWN0 ZXIgZm9sbG93aW5nIHRoZSBicmVhaworICAgICAgICAgICAgICAgIC8vIGlzIGFscGhhbnVtZXJp Yy4KKyAgICAgICAgICAgICAgICBpZiAocG9zaXRpb24gPiAwICYmIGlzQWxwaGFudW1lcmljKGNo YXJzW3Bvc2l0aW9uXSkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAg ICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hpbmcg d2hlbiB0aGUgY2hhcmFjdGVyIHByZWNlZWRpbmcgdGhlIGJyZWFrCisgICAgICAgICAgICAgICAg Ly8gaXMgYWxwaGFudW1lcmljLgorICAgICAgICAgICAgICAgIGlmIChwb3NpdGlvbiA8IGxlbiAm JiBpc0FscGhhbnVtZXJpYyhjaGFyc1twb3NpdGlvbiAtIDFdKSkKKyAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBwb3NpdGlv biA9IHRleHRCcmVha1ByZWNlZGluZyhpdCwgcG9zaXRpb24pOwogICAgICAgICB9CkBAIC05Myw2 ICsxMDcsMTYgQEAgaW50IGZpbmROZXh0V29yZEZyb21JbmRleChjb25zdCBVQ2hhciogYwogICAg IH0KIH0KIAorI2VuZGlmIC8vICFQTEFURk9STShRVCkKKworI2lmICFQTEFURk9STShCUkVXTVAp ICYmICFQTEFURk9STShNQUMpICYmICFQTEFURk9STShRVCkKKworaW50IGZpbmROZXh0V29yZEZy b21JbmRleChjb25zdCBVQ2hhciogY2hhcnMsIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBm b3J3YXJkKQoreyAgICAKKyAgICByZXR1cm4gZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJp bmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkCisgICAgICAgIChjaGFycywgbGVu LCBwb3NpdGlvbiwgZm9yd2FyZCwgZm9yd2FyZCA/IExvZ2ljYWxseUFmdGVyV29yZCA6IExvZ2lj YWxseUJlZm9yZVdvcmQpOworfQorCiB2b2lkIGZpbmRXb3JkQm91bmRhcnkoY29uc3QgVUNoYXIq IGNoYXJzLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGludCogc3RhcnQsIGludCogZW5kKQogewog ICAgIFRleHRCcmVha0l0ZXJhdG9yKiBpdCA9IHdvcmRCcmVha0l0ZXJhdG9yKGNoYXJzLCBsZW4p OwpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dEJvdW5kYXJpZXMu aAkocmV2aXNpb24gOTMwNjIpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRC b3VuZGFyaWVzLmgJKHdvcmtpbmcgY29weSkKQEAgLTMwLDYgKzMwLDggQEAKIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCisgICAgZW51bSBXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3Jk IHsgTG9naWNhbGx5QmVmb3JlV29yZCwgTG9naWNhbGx5QWZ0ZXJXb3JkIH07CisKICAgICBpbmxp bmUgYm9vbCByZXF1aXJlc0NvbnRleHRGb3JXb3JkQm91bmRhcnkoVUNoYXIzMiBjaCkKICAgICB7 CiAgICAgICAgIHJldHVybiBXVEY6OlVuaWNvZGU6Omhhc0xpbmVCcmVha2luZ1Byb3BlcnR5Q29t cGxleENvbnRleHQoY2gpOwpAQCAtNDAsNiArNDIsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK ICAgICB2b2lkIGZpbmRXb3JkQm91bmRhcnkoY29uc3QgVUNoYXIqLCBpbnQgbGVuLCBpbnQgcG9z aXRpb24sIGludCogc3RhcnQsIGludCogZW5kKTsKICAgICBpbnQgZmluZE5leHRXb3JkRnJvbUlu ZGV4KGNvbnN0IFVDaGFyKiwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQpOwor ICAgIGludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9u aW5nUmVsYXRpdmVUb1dvcmQoY29uc3QgVUNoYXIqLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGJv b2wgZm9yd2FyZCwgV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZCB3b3JkQnJlYWtQ b3NpdGlvbmluZyk7CiAKIH0KIApJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9i cmV3L1RleHRCb3VuZGFyaWVzQnJldy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vdGV4dC9icmV3L1RleHRCb3VuZGFyaWVzQnJldy5jcHAJKHJldmlzaW9uIDkzMDYy KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9icmV3L1RleHRCb3VuZGFyaWVzQnJl dy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM0LDYgKzM0LDEyIEBAIHVzaW5nIG5hbWVzcGFjZSBX VEY6OlVuaWNvZGU7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAoraW50IGZpbmROZXh0V29yZEZy b21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZChjb25z dCBVQ2hhciogYnVmZmVyLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGJvb2wgZm9yd2FyZCwgV29y ZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZCB3b3JkQnJlYWtQb3NpdGlvbmluZykKK3sK KyAgIG5vdEltcGxlbWVudGVkKCk7CisgICByZXR1cm4gMDsKK30KKwogaW50IGZpbmROZXh0V29y ZEZyb21JbmRleChjb25zdCBVQ2hhciogYnVmZmVyLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGJv b2wgZm9yd2FyZCkKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwpJbmRleDogU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vdGV4dC9xdC9UZXh0Qm91bmRhcmllc1F0LmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L3F0L1RleHRCb3VuZGFyaWVzUXQuY3BwCShyZXZp c2lvbiA5MzA2MikKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvcXQvVGV4dEJvdW5k YXJpZXNRdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQwLDcgKzQwLDcgQEAKIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCi1pbnQgZmluZE5leHRXb3JkRnJvbUluZGV4KFVDaGFyIGNvbnN0KiBidWZm ZXIsIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkKQoraW50IGZpbmROZXh0V29y ZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZChV Q2hhciBjb25zdCogYnVmZmVyLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGJvb2wgZm9yd2FyZCwg V29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZCB3b3JkQnJlYWtQb3NpdGlvbmluZykK IHsKICAgICBRU3RyaW5nIHN0cihyZWludGVycHJldF9jYXN0PFFDaGFyIGNvbnN0Kj4oYnVmZmVy KSwgbGVuKTsKICAgICBRVGV4dEJvdW5kYXJ5RmluZGVyIGl0ZXJhdG9yKFFUZXh0Qm91bmRhcnlG aW5kZXI6OldvcmQsIHN0cik7CkBAIC00OCwyMiArNDgsMzggQEAgaW50IGZpbmROZXh0V29yZEZy b21JbmRleChVQ2hhciBjb25zdCogYgogICAgIGlmIChmb3J3YXJkKSB7CiAgICAgICAgIGludCBw b3MgPSBpdGVyYXRvci50b05leHRCb3VuZGFyeSgpOwogICAgICAgICB3aGlsZSAocG9zID4gMCkg ewotICAgICAgICAgICAgaWYgKFFDaGFyKGJ1ZmZlcltwb3MtMV0pLmlzTGV0dGVyT3JOdW1iZXIo KSkKLSAgICAgICAgICAgICAgICByZXR1cm4gcG9zOworICAgICAgICAgICAgaWYgKHdvcmRCcmVh a1Bvc2l0aW9uaW5nID09IExvZ2ljYWxseUFmdGVyV29yZCkgeworICAgICAgICAgICAgICAgIGlm IChRQ2hhcihidWZmZXJbcG9zLTFdKS5pc0xldHRlck9yTnVtYmVyKCkpCisgICAgICAgICAgICAg ICAgICAgIHJldHVybiBwb3M7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAg IGlmIChRQ2hhcihidWZmZXJbcG9zXSkuaXNMZXR0ZXJPck51bWJlcigpKQorICAgICAgICAgICAg ICAgICAgICByZXR1cm4gcG9zOworICAgICAgICAgICAgfQogICAgICAgICAgICAgcG9zID0gaXRl cmF0b3IudG9OZXh0Qm91bmRhcnkoKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4gbGVuOwog ICAgIH0gZWxzZSB7CiAgICAgICAgIGludCBwb3MgPSBpdGVyYXRvci50b1ByZXZpb3VzQm91bmRh cnkoKTsKICAgICAgICAgd2hpbGUgKHBvcyA+IDApIHsKLSAgICAgICAgICAgIGlmIChRQ2hhcihi dWZmZXJbcG9zXSkuaXNMZXR0ZXJPck51bWJlcigpKQotICAgICAgICAgICAgICAgIHJldHVybiBw b3M7CisgICAgICAgICAgICBpZiAod29yZEJyZWFrUG9zaXRpb25pbmcgPT0gTG9naWNhbGx5QmVm b3JlV29yZCkgeworICAgICAgICAgICAgICAgIGlmIChRQ2hhcihidWZmZXJbcG9zXSkuaXNMZXR0 ZXJPck51bWJlcigpKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zOworICAgICAgICAg ICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICBpZiAoUUNoYXIoYnVmZmVyW3Bvcy0xXSkuaXNM ZXR0ZXJPck51bWJlcigpKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zOworICAgICAg ICAgICAgfQogICAgICAgICAgICAgcG9zID0gaXRlcmF0b3IudG9QcmV2aW91c0JvdW5kYXJ5KCk7 CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogfQogCitpbnQgZmluZE5leHRX b3JkRnJvbUluZGV4KFVDaGFyIGNvbnN0KiBidWZmZXIsIGludCBsZW4sIGludCBwb3NpdGlvbiwg Ym9vbCBmb3J3YXJkKQoreworICAgIHJldHVybiBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRl cmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQKKyAgICAgICAgKGJ1ZmZlciwg bGVuLCBwb3NpdGlvbiwgZm9yd2FyZCwgZm9yd2FyZCA/IExvZ2ljYWxseUFmdGVyV29yZCA6IExv Z2ljYWxseUJlZm9yZVdvcmQpOworfQorCiB2b2lkIGZpbmRXb3JkQm91bmRhcnkoVUNoYXIgY29u c3QqIGJ1ZmZlciwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBpbnQqIHN0YXJ0LCBpbnQqIGVuZCkK IHsKICAgICBRU3RyaW5nIHN0cihyZWludGVycHJldF9jYXN0PFFDaGFyIGNvbnN0Kj4oYnVmZmVy KSwgbGVuKTsKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDkzMDYyKQorKysgTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDgtMTUgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBQcm92aWRlIGZsZXhpYmxlIChpbiB0ZXJt cyBvZiBwb3NpdGlvbiByZWxhdGl2ZSB0byBzcGFjZSkgbG9naWNhbCB3b3JkIGJyZWFrZXIgdG8g aW1wcm92ZSBwZXJmb3JtYW5jZSBvZiAtLXdlYmtpdC12aXN1YWwtd29yZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjUyNzcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNeSBjaGFuZ2UgZml4ZWQgYSBmYWls dXJlIGluIHRoaXMgdGVzdCBjYXNlLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vbW92 ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50 eHQ6CisKIDIwMTEtMDgtMTUgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xlLmNvbT4KIAog ICAgICAgICBBZGQgc2hlbGwgaW1wbGVtZW50YXRpb24gZm9yIFdlYiBBdWRpbyBBUEkncyBNZWRp YUVsZW1lbnRBdWRpb1NvdXJjZU5vZGUKSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0 aW9uL21vdmUtYnktd29yZC12aXN1YWxseS1zaW5nbGUtc3BhY2UtaW5saW5lLWVsZW1lbnQtZXhw ZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL21v dmUtYnktd29yZC12aXN1YWxseS1zaW5nbGUtc3BhY2UtaW5saW5lLWVsZW1lbnQtZXhwZWN0ZWQu dHh0CShyZXZpc2lvbiA5MzA2MikKKysrIExheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL21v dmUtYnktd29yZC12aXN1YWxseS1zaW5nbGUtc3BhY2UtaW5saW5lLWVsZW1lbnQtZXhwZWN0ZWQu dHh0CSh3b3JraW5nIGNvcHkpCkBAIC0xMzcsOSArMTM3LDYgQEAgVGVzdCAyMCwgUlRMOgogTW92 ZSBsZWZ0IGJ5IG9uZSB3b3JkCiAiQUJEIG9wcSByc3QgRFNVICJbMCwgNCwgNywgMTIsIDE2XSwg ImFiYyB1dncgQUFBIGRlZiBsbW4iWzEyLCA4LCA3LCAzXSwgIkFCVyBoaWogeHl6IEZYWCJbNCwg NywgMTIsIDE1XSAgICBGQUlMIGV4cGVjdGVkOiBbIkFCRCBvcHEgcnN0IERTVSAiWyAwLCAgNCwg IDcsICAxMiwgIDE2LCBdImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNSwgIDgsICA3LCAgMywgXSJB QlcgaGlqIHh5eiBGWFgiWyA0LCAgNywgIDEyLCAgMTVdCiAiQUJEIG9wcSByc3QgRFNVICJbMTZd LCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEg ZGVmIGxtbiJbIDE1XQotImFiYyB1dncgQUFBIGRlZiBsbW4iWzE4LCAxMl0gICBGQUlMIGV4cGVj dGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgMTVdCi0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTcs IDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KLSJhYmMgdXZ3 IEFBQSBkZWYgbG1uIlsxNiwgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxt biJbIDE1XQogImFiYyB1dncgQUFBIGRlZiBsbW4iWzE1LCAxMl0gICBGQUlMIGV4cGVjdGVkICJh YmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0KICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxNCwgMTJdICAg RkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDhdCiAiYWJjIHV2dyBBQUEgZGVm IGxtbiJbMTMsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyA4XQo= 103969 2011-08-15 15:56:29 -0700 2011-08-17 15:07:16 -0700 Proposed fix vanlam-internalapi text/plain 17299 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkzMDYyKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTEtMDgtMTUgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBQcm92aWRlIGZsZXhpYmxlIChpbiB0ZXJt cyBvZiBwb3NpdGlvbiByZWxhdGl2ZSB0byBzcGFjZSkgbG9naWNhbCB3b3JkIGJyZWFrZXIgdG8g aW1wcm92ZSBwZXJmb3JtYW5jZSBvZiAtLXdlYmtpdC12aXN1YWwtd29yZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjUyNzcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBFeHRyYWN0ZWQgZnVuY3Rpb25hbGl0 eSBvZiBmaW5kTmV4dFdvcmRCb3VuZGFyeSB0byBwYXJhbWV0cml6ZSBpdCB3aXRoCisgICAgICAg IHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZSByZWxhdGl2ZSB0byB0aGUgd29yZCAobG9n aWNhbGx5IGJlZm9yZQorICAgICAgICBvciBhZnRlcikgd2hpbGUgbWFpbnRhaW5pbmcgZXhpc3Rp bmcgZnVuY3Rpb25hbGl0eS4gSW50cm9kdWNlZCBmb3VyCisgICAgICAgIHNlYXJjaCBmdW5jdGlv bnMgdG8gY2hvb3NlIHdoZXJlIHRoZSB3b3JkIGJyZWFrIHNob3VsZCBiZS4gVXRpbGl6ZWQKKyAg ICAgICAgdGhlc2UgY2hhbmdlcyBpbiByaWdodC9sZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91bmRh cnkgdG8gYXZvaWQKKyAgICAgICAgY29sbGVjdGluZyB3b3JkIGJvdW5kYXJpZXMuCisKKyAgICAg ICAgKiBlZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6cHJldmlv dXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUJlZm9yZVdvcmQpOgorICAgICAgICAoV2Vi Q29yZTo6cHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxseUFmdGVyV29yZCk6Cisg ICAgICAgIChXZWJDb3JlOjpuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlCZWZvcmVX b3JkKToKKyAgICAgICAgKFdlYkNvcmU6Om5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2ljYWxs eUFmdGVyV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpsZWZ0V29yZFBvc2l0aW9uQWNyb3NzQm91 bmRhcnkpOgorICAgICAgICAoV2ViQ29yZTo6cmlnaHRXb3JkUG9zaXRpb25BY3Jvc3NCb3VuZGFy eSk6CisgICAgICAgICogcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHA6CisgICAgICAg IChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0 aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAoV2ViQ29yZTo6ZmluZE5leHRXb3JkRnJv bUluZGV4KToKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVzLmg6CisgICAg ICAgICogcGxhdGZvcm0vdGV4dC9icmV3L1RleHRCb3VuZGFyaWVzQnJldy5jcHA6CisgICAgICAg IChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0 aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvcXQvVGV4dEJv dW5kYXJpZXNRdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhD b25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAo V2ViQ29yZTo6ZmluZE5leHRXb3JkRnJvbUluZGV4KToKKwogMjAxMS0wOC0xNSAgTWFyayBIYWhu ZW5iZXJnICA8bWhhaG5lbmJlcmdAYXBwbGUuY29tPgogCiAgICAgICAgIFJlZmFjdG9yIEpTIG9i amVjdHMgdG8gYWxsb2NhdGUgaW4gc3RhdGljIGNyZWF0ZSBtZXRob2RzIHJhdGhlciB0aGFuIGNv bnN0cnVjdG9ycwpJbmRleDogU291cmNlL1dlYkNvcmUvZWRpdGluZy92aXNpYmxlX3VuaXRzLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3Bw CShyZXZpc2lvbiA5MzA2MikKKysrIFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvdmlzaWJsZV91bml0 cy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUzLDYgKzUzLDggQEAgZW51bSBCb3VuZGFyeVNlYXJj aENvbnRleHRBdmFpbGFiaWxpdHkgewogCiB0eXBlZGVmIHVuc2lnbmVkICgqQm91bmRhcnlTZWFy Y2hGdW5jdGlvbikoY29uc3QgVUNoYXIqLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIG9mZnNl dCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5LCBib29sJiBuZWVkTW9yZUNvbnRl eHQpOwogCit0eXBlZGVmIHVuc2lnbmVkICgqQm91bmRhcnlTZWFyY2hGdW5jdGlvbkNvbnNpZGVy aW5nV29yZEJyZWFrUG9zaXRpb25pbmcpKGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVuZ3RoLCB1 bnNpZ25lZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSwgYm9vbCYg bmVlZE1vcmVDb250ZXh0LCBXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKTsKKwog c3RhdGljIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c0JvdW5kYXJ5KGNvbnN0IFZpc2libGVQb3Np dGlvbiYgYywgQm91bmRhcnlTZWFyY2hGdW5jdGlvbiBzZWFyY2hGdW5jdGlvbikKIHsKICAgICBQ b3NpdGlvbiBwb3MgPSBjLmRlZXBFcXVpdmFsZW50KCk7CkBAIC0yODksNiArMjkxLDI2IEBAIHN0 YXRpYyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW4KICAgICByZXR1cm4gZmluZE5l eHRXb3JkRnJvbUluZGV4KGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCBmYWxzZSk7CiB9CiAK K3N0YXRpYyB1bnNpZ25lZCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVm b3JlV29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25l ZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9yZUNv bnRleHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVDb250 ZXh0ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywgb2Zmc2V0 KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4gMDsK KyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZpbmROZXh0 V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29y ZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUJlZm9yZVdvcmQp OworfQorCitzdGF0aWMgdW5zaWduZWQgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxvZ2lj YWxseUFmdGVyV29yZChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1 bnNpZ25lZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZl TW9yZUNvbnRleHQsIGJvb2wmIG5lZWRNb3JlQ29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1v cmVDb250ZXh0ICYmICFzdGFydE9mTGFzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycywg b2Zmc2V0KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1 cm4gMDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZp bmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2 ZVRvV29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgZmFsc2UsIExvZ2ljYWxseUFmdGVy V29yZCk7Cit9CisKIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c1dvcmRQb3NpdGlvbihjb25zdCBW aXNpYmxlUG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHByZXYgPSBwcmV2aW91 c0JvdW5kYXJ5KGMsIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwpAQCAtMzA1LDYgKzMy NywyNiBAQCBzdGF0aWMgdW5zaWduZWQgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5CiAgICAgcmV0 dXJuIGZpbmROZXh0V29yZEZyb21JbmRleChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1 ZSk7CiB9CiAKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2Fs bHlCZWZvcmVXb3JkKGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCB1bnNpZ25lZCBsZW5ndGgsIHVu c2lnbmVkIG9mZnNldCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5IG1heUhhdmVN b3JlQ29udGV4dCwgYm9vbCYgbmVlZE1vcmVDb250ZXh0KQoreworICAgIGlmIChtYXlIYXZlTW9y ZUNvbnRleHQgJiYgZW5kT2ZGaXJzdFdvcmRCb3VuZGFyeUNvbnRleHQoY2hhcmFjdGVycyArIG9m ZnNldCwgbGVuZ3RoIC0gb2Zmc2V0KSA9PSBzdGF0aWNfY2FzdDxpbnQ+KGxlbmd0aCAtIG9mZnNl dCkpIHsKKyAgICAgICAgbmVlZE1vcmVDb250ZXh0ID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIGxl bmd0aDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7CisgICAgcmV0dXJuIGZp bmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2 ZVRvV29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1ZSwgTG9naWNhbGx5QmVmb3Jl V29yZCk7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dp Y2FsbHlBZnRlcldvcmQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIHVuc2lnbmVkIGxlbmd0aCwg dW5zaWduZWQgb2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHkgbWF5SGF2 ZU1vcmVDb250ZXh0LCBib29sJiBuZWVkTW9yZUNvbnRleHQpCit7CisgICAgaWYgKG1heUhhdmVN b3JlQ29udGV4dCAmJiBlbmRPZkZpcnN0V29yZEJvdW5kYXJ5Q29udGV4dChjaGFyYWN0ZXJzICsg b2Zmc2V0LCBsZW5ndGggLSBvZmZzZXQpID09IHN0YXRpY19jYXN0PGludD4obGVuZ3RoIC0gb2Zm c2V0KSkgeworICAgICAgICBuZWVkTW9yZUNvbnRleHQgPSB0cnVlOworICAgICAgICByZXR1cm4g bGVuZ3RoOworICAgIH0KKyAgICBuZWVkTW9yZUNvbnRleHQgPSBmYWxzZTsKKyAgICByZXR1cm4g ZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0 aXZlVG9Xb3JkKGNoYXJhY3RlcnMsIGxlbmd0aCwgb2Zmc2V0LCB0cnVlLCBMb2dpY2FsbHlBZnRl cldvcmQpOworfQorCiBWaXNpYmxlUG9zaXRpb24gbmV4dFdvcmRQb3NpdGlvbihjb25zdCBWaXNp YmxlUG9zaXRpb24gJmMpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIG5leHQgPSBuZXh0Qm91bmRh cnkoYywgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsgICAgCkBAIC0xNjE0LDE0ICsxNjU2LDE1 IEBAIHN0YXRpYyBWaXNpYmxlUG9zaXRpb24gbGVmdFdvcmRQb3NpdGlvbkEKICAgICBpZiAob2Zm c2V0ID09IGJveC0+Y2FyZXRSaWdodG1vc3RPZmZzZXQoKSkKICAgICAgICAgcmV0dXJuIGxlZnRX b3JkQm91bmRhcnkoYm94LCBvZmZzZXQsIGJsb2NrRGlyZWN0aW9uKTsKICAgICAKLSAgICAKICAg ICBWaXNpYmxlUG9zaXRpb24gd29yZEJyZWFrOwotICAgIGlmIChibG9ja0RpcmVjdGlvbiA9PSBM VFIpIHsKLSAgICAgICAgaWYgKGJveC0+ZGlyZWN0aW9uKCkgPT0gYmxvY2tEaXJlY3Rpb24pCi0g ICAgICAgICAgICB3b3JkQnJlYWsgPSBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwg cHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAg IHdvcmRCcmVhayA9IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRp b25Cb3VuZGFyeSk7Ci0gICAgfQorICAgIAorICAgIGlmIChibG9ja0RpcmVjdGlvbiA9PSBMVFIp CisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gcHJldmlvdXNC b3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlMb2dp Y2FsbHlCZWZvcmVXb3JkKQorICAgICAgICAgICAgOiBuZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0 aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlBZnRlcldvcmQpOworICAgIGVs c2UKKyAgICAgICAgd29yZEJyZWFrID0gYm94LT5kaXJlY3Rpb24oKSA9PSBMVFIgPyBwcmV2aW91 c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeUxv Z2ljYWxseUFmdGVyV29yZCkKKyAgICAgICAgICAgIDogbmV4dEJvdW5kYXJ5KHZpc2libGVQb3Np dGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3JlV29yZCk7CisgICAg CiAgICAgaWYgKHdvcmRCcmVhay5pc05vdE51bGwoKSAmJiBwb3NpdGlvbklzSW5Cb3hCdXROb3RP bkJvdW5kYXJ5KHdvcmRCcmVhaywgYm94KSkKICAgICAgICAgcmV0dXJuIHdvcmRCcmVhazsKICAg ICAKQEAgLTE2NTMsMTIgKzE2OTYsMTQgQEAgc3RhdGljIFZpc2libGVQb3NpdGlvbiByaWdodFdv cmRQb3NpdGlvbgogICAgICAgICByZXR1cm4gcmlnaHRXb3JkQm91bmRhcnkocmlnaHRJbmxpbmVC b3goYm94LCBibG9ja0RpcmVjdGlvbiksIGludmFsaWRPZmZzZXQsIGJsb2NrRGlyZWN0aW9uKTsK ICAKICAgICBWaXNpYmxlUG9zaXRpb24gd29yZEJyZWFrOwotICAgIGlmIChibG9ja0RpcmVjdGlv biA9PSBSVEwpIHsKLSAgICAgICAgaWYgKGJveC0+ZGlyZWN0aW9uKCkgPT0gYmxvY2tEaXJlY3Rp b24pCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3Np dGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgICAgIGVsc2UKLSAgICAg ICAgICAgIHdvcmRCcmVhayA9IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3Jk UG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgfQorICAgIAorICAgIGlmIChibG9ja0RpcmVjdGlvbiA9 PSBMVFIpCisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gbmV4 dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNh bGx5QmVmb3JlV29yZCkKKyAgICAgICAgICAgIDogcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9z aXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlMb2dpY2FsbHlBZnRlcldvcmQpOwor ICAgIGVsc2UKKyAgICAgICAgd29yZEJyZWFrID0gYm94LT5kaXJlY3Rpb24oKSA9PSBMVFIgPyBu ZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnlMb2dp Y2FsbHlBZnRlcldvcmQpCisgICAgICAgICAgICA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBv c2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5TG9naWNhbGx5QmVmb3JlV29yZCk7 CisgICAgICAgICAgICAKICAgICBpZiAod29yZEJyZWFrLmlzTm90TnVsbCgpICYmIHBvc2l0aW9u SXNJbkJveEJ1dE5vdE9uQm91bmRhcnkod29yZEJyZWFrLCBib3gpKQogICAgICAgICByZXR1cm4g d29yZEJyZWFrOwogICAgIApJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0 Qm91bmRhcmllcy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4 dC9UZXh0Qm91bmRhcmllcy5jcHAJKHJldmlzaW9uIDkzMDYyKQorKysgU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmllcy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYwLDM3 ICs2MCw2MSBAQCBpbnQgc3RhcnRPZkxhc3RXb3JkQm91bmRhcnlDb250ZXh0KGNvbnN0CiAgICAg cmV0dXJuIDA7CiB9CiAKLSNpZiAhUExBVEZPUk0oQlJFV01QKSAmJiAhUExBVEZPUk0oTUFDKSAm JiAhUExBVEZPUk0oUVQpCisjaWYgIVBMQVRGT1JNKFFUKQogCi1pbnQgZmluZE5leHRXb3JkRnJv bUluZGV4KGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZv cndhcmQpCitpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3Np dGlvbmluZ1JlbGF0aXZlVG9Xb3JkKGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBv c2l0aW9uLCBib29sIGZvcndhcmQsIFdvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQg d29yZEJyZWFrUG9zaXRpb25pbmcpCiB7CiAgICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29y ZEJyZWFrSXRlcmF0b3IoY2hhcnMsIGxlbik7CiAKICAgICBpZiAoZm9yd2FyZCkgewogICAgICAg ICBwb3NpdGlvbiA9IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9zaXRpb24pOwogICAgICAgICB3 aGlsZSAocG9zaXRpb24gIT0gVGV4dEJyZWFrRG9uZSkgewotICAgICAgICAgICAgLy8gV2Ugc3Rv cCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIHByZWNlZWRpbmcgdGhlIGJyZWFrCi0gICAg ICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCi0gICAgICAgICAgICBpZiAocG9zaXRpb24gPCBs ZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb24gLSAxXSkpCi0gICAgICAgICAgICAg ICAgcmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgaWYgKHdvcmRCcmVha1Bvc2l0aW9uaW5n ID09IExvZ2ljYWxseUFmdGVyV29yZCkgeworICAgICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2Vh cmNoaW5nIHdoZW4gdGhlIGNoYXJhY3RlciBwcmVjZWVkaW5nIHRoZSBicmVhaworICAgICAgICAg ICAgICAgIC8vIGlzIGFscGhhbnVtZXJpYy4KKyAgICAgICAgICAgICAgICBpZiAocG9zaXRpb24g PCBsZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb24gLSAxXSkpCisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIGZvbGxvd2lu ZyB0aGUgYnJlYWsKKyAgICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAgICAg ICAgICAgICAgaWYgKHBvc2l0aW9uID4gMCAmJiBpc0FscGhhbnVtZXJpYyhjaGFyc1twb3NpdGlv bl0pKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAgICAgICAgICB9 CiAKICAgICAgICAgICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrRm9sbG93aW5nKGl0LCBwb3NpdGlv bik7CiAgICAgICAgIH0KIAogICAgICAgICByZXR1cm4gbGVuOwotICAgIH0gZWxzZSB7Ci0gICAg ICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrUHJlY2VkaW5nKGl0LCBwb3NpdGlvbik7Ci0gICAgICAg IHdoaWxlIChwb3NpdGlvbiAhPSBUZXh0QnJlYWtEb25lKSB7CisgICAgfQorICAgIAorICAgIHBv c2l0aW9uID0gdGV4dEJyZWFrUHJlY2VkaW5nKGl0LCBwb3NpdGlvbik7CisgICAgd2hpbGUgKHBv c2l0aW9uICE9IFRleHRCcmVha0RvbmUpIHsKKyAgICAgICAgaWYgKHdvcmRCcmVha1Bvc2l0aW9u aW5nID09IExvZ2ljYWxseUJlZm9yZVdvcmQpIHsKICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2Vh cmNoaW5nIHdoZW4gdGhlIGNoYXJhY3RlciBmb2xsb3dpbmcgdGhlIGJyZWFrCiAgICAgICAgICAg ICAvLyBpcyBhbHBoYW51bWVyaWMuCiAgICAgICAgICAgICBpZiAocG9zaXRpb24gPiAwICYmIGlz QWxwaGFudW1lcmljKGNoYXJzW3Bvc2l0aW9uXSkpCiAgICAgICAgICAgICAgICAgcmV0dXJuIHBv c2l0aW9uOwotCi0gICAgICAgICAgICBwb3NpdGlvbiA9IHRleHRCcmVha1ByZWNlZGluZyhpdCwg cG9zaXRpb24pOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gV2Ugc3RvcCBzZWFy Y2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIHByZWNlZWRpbmcgdGhlIGJyZWFrCisgICAgICAgICAg ICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4gJiYg aXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb24gLSAxXSkpCisgICAgICAgICAgICAgICAgcmV0 dXJuIHBvc2l0aW9uOwogICAgICAgICB9CiAKLSAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIHBv c2l0aW9uID0gdGV4dEJyZWFrUHJlY2VkaW5nKGl0LCBwb3NpdGlvbik7CiAgICAgfQorCisgICAg cmV0dXJuIDA7Cit9CisKKyNlbmRpZiAvLyAhUExBVEZPUk0oUVQpCisKKyNpZiAhUExBVEZPUk0o QlJFV01QKSAmJiAhUExBVEZPUk0oTUFDKSAmJiAhUExBVEZPUk0oUVQpCisKK2ludCBmaW5kTmV4 dFdvcmRGcm9tSW5kZXgoY29uc3QgVUNoYXIqIGNoYXJzLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24s IGJvb2wgZm9yd2FyZCkKK3sgICAgCisgICAgcmV0dXJuIGZpbmROZXh0V29yZEZyb21JbmRleENv bnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZAorICAgICAgICAoY2hh cnMsIGxlbiwgcG9zaXRpb24sIGZvcndhcmQsIGZvcndhcmQgPyBMb2dpY2FsbHlBZnRlcldvcmQg OiBMb2dpY2FsbHlCZWZvcmVXb3JkKTsKIH0KIAogdm9pZCBmaW5kV29yZEJvdW5kYXJ5KGNvbnN0 IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBpbnQqIHN0YXJ0LCBpbnQqIGVu ZCkKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dEJvdW5kYXJpZXMuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVz LmgJKHJldmlzaW9uIDkzMDYyKQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0 Qm91bmRhcmllcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMCwxNiArMzAsMTkgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCi0gICAgaW5saW5lIGJvb2wgcmVxdWlyZXNDb250ZXh0Rm9yV29yZEJv dW5kYXJ5KFVDaGFyMzIgY2gpCi0gICAgewotICAgICAgICByZXR1cm4gV1RGOjpVbmljb2RlOjpo YXNMaW5lQnJlYWtpbmdQcm9wZXJ0eUNvbXBsZXhDb250ZXh0KGNoKTsKLSAgICB9CitlbnVtIFdv cmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQgeyBMb2dpY2FsbHlCZWZvcmVXb3JkLCBM b2dpY2FsbHlBZnRlcldvcmQgfTsKIAotICAgIGludCBlbmRPZkZpcnN0V29yZEJvdW5kYXJ5Q29u dGV4dChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgaW50IGxlbmd0aCk7Ci0gICAgaW50IHN0YXJ0 T2ZMYXN0V29yZEJvdW5kYXJ5Q29udGV4dChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgaW50IGxl bmd0aCk7CitpbmxpbmUgYm9vbCByZXF1aXJlc0NvbnRleHRGb3JXb3JkQm91bmRhcnkoVUNoYXIz MiBjaCkKK3sKKyAgICByZXR1cm4gV1RGOjpVbmljb2RlOjpoYXNMaW5lQnJlYWtpbmdQcm9wZXJ0 eUNvbXBsZXhDb250ZXh0KGNoKTsKK30KKworaW50IGVuZE9mRmlyc3RXb3JkQm91bmRhcnlDb250 ZXh0KGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCBpbnQgbGVuZ3RoKTsKK2ludCBzdGFydE9mTGFz dFdvcmRCb3VuZGFyeUNvbnRleHQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIGludCBsZW5ndGgp OwogCi0gICAgdm9pZCBmaW5kV29yZEJvdW5kYXJ5KGNvbnN0IFVDaGFyKiwgaW50IGxlbiwgaW50 IHBvc2l0aW9uLCBpbnQqIHN0YXJ0LCBpbnQqIGVuZCk7Ci0gICAgaW50IGZpbmROZXh0V29yZEZy b21JbmRleChjb25zdCBVQ2hhciosIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJk KTsKK3ZvaWQgZmluZFdvcmRCb3VuZGFyeShjb25zdCBVQ2hhciosIGludCBsZW4sIGludCBwb3Np dGlvbiwgaW50KiBzdGFydCwgaW50KiBlbmQpOworaW50IGZpbmROZXh0V29yZEZyb21JbmRleChj b25zdCBVQ2hhciosIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkKTsKK2ludCBm aW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRp dmVUb1dvcmQoY29uc3QgVUNoYXIqLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGJvb2wgZm9yd2Fy ZCwgV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZCk7CiAKIH0KIApJbmRleDogU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9icmV3L1RleHRCb3VuZGFyaWVzQnJldy5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9icmV3L1RleHRCb3VuZGFy aWVzQnJldy5jcHAJKHJldmlzaW9uIDkzMDYyKQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v dGV4dC9icmV3L1RleHRCb3VuZGFyaWVzQnJldy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM0LDYg KzM0LDEyIEBAIHVzaW5nIG5hbWVzcGFjZSBXVEY6OlVuaWNvZGU7CiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAoraW50IGZpbmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9z aXRpb25pbmdSZWxhdGl2ZVRvV29yZChjb25zdCBVQ2hhciogYnVmZmVyLCBpbnQgbGVuLCBpbnQg cG9zaXRpb24sIGJvb2wgZm9yd2FyZCwgV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29y ZCB3b3JkQnJlYWtQb3NpdGlvbmluZykKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIHJl dHVybiAwOworfQorCiBpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4KGNvbnN0IFVDaGFyKiBidWZm ZXIsIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkKQogewogICAgIG5vdEltcGxl bWVudGVkKCk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L3F0L1RleHRCb3Vu ZGFyaWVzUXQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQv cXQvVGV4dEJvdW5kYXJpZXNRdC5jcHAJKHJldmlzaW9uIDkzMDYyKQorKysgU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vdGV4dC9xdC9UZXh0Qm91bmRhcmllc1F0LmNwcAkod29ya2luZyBjb3B5KQpA QCAtNDAsNyArNDAsNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWludCBmaW5kTmV4dFdv cmRGcm9tSW5kZXgoVUNoYXIgY29uc3QqIGJ1ZmZlciwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBi b29sIGZvcndhcmQpCitpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJl YWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKFVDaGFyIGNvbnN0KiBidWZmZXIsIGludCBsZW4s IGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkLCBXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZl VG9Xb3JkIHdvcmRCcmVha1Bvc2l0aW9uaW5nKQogewogICAgIFFTdHJpbmcgc3RyKHJlaW50ZXJw cmV0X2Nhc3Q8UUNoYXIgY29uc3QqPihidWZmZXIpLCBsZW4pOwogICAgIFFUZXh0Qm91bmRhcnlG aW5kZXIgaXRlcmF0b3IoUVRleHRCb3VuZGFyeUZpbmRlcjo6V29yZCwgc3RyKTsKQEAgLTQ4LDIy ICs0OCwzOCBAQCBpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4KFVDaGFyIGNvbnN0KiBiCiAgICAg aWYgKGZvcndhcmQpIHsKICAgICAgICAgaW50IHBvcyA9IGl0ZXJhdG9yLnRvTmV4dEJvdW5kYXJ5 KCk7CiAgICAgICAgIHdoaWxlIChwb3MgPiAwKSB7Ci0gICAgICAgICAgICBpZiAoUUNoYXIoYnVm ZmVyW3Bvcy0xXSkuaXNMZXR0ZXJPck51bWJlcigpKQotICAgICAgICAgICAgICAgIHJldHVybiBw b3M7CisgICAgICAgICAgICBpZiAod29yZEJyZWFrUG9zaXRpb25pbmcgPT0gTG9naWNhbGx5QWZ0 ZXJXb3JkKSB7CisgICAgICAgICAgICAgICAgaWYgKFFDaGFyKGJ1ZmZlcltwb3MtMV0pLmlzTGV0 dGVyT3JOdW1iZXIoKSkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHBvczsKKyAgICAgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgaWYgKFFDaGFyKGJ1ZmZlcltwb3NdKS5pc0xl dHRlck9yTnVtYmVyKCkpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBwb3M7CisgICAgICAg ICAgICB9CiAgICAgICAgICAgICBwb3MgPSBpdGVyYXRvci50b05leHRCb3VuZGFyeSgpOwogICAg ICAgICB9CiAgICAgICAgIHJldHVybiBsZW47CiAgICAgfSBlbHNlIHsKICAgICAgICAgaW50IHBv cyA9IGl0ZXJhdG9yLnRvUHJldmlvdXNCb3VuZGFyeSgpOwogICAgICAgICB3aGlsZSAocG9zID4g MCkgewotICAgICAgICAgICAgaWYgKFFDaGFyKGJ1ZmZlcltwb3NdKS5pc0xldHRlck9yTnVtYmVy KCkpCi0gICAgICAgICAgICAgICAgcmV0dXJuIHBvczsKKyAgICAgICAgICAgIGlmICh3b3JkQnJl YWtQb3NpdGlvbmluZyA9PSBMb2dpY2FsbHlCZWZvcmVXb3JkKSB7CisgICAgICAgICAgICAgICAg aWYgKFFDaGFyKGJ1ZmZlcltwb3NdKS5pc0xldHRlck9yTnVtYmVyKCkpCisgICAgICAgICAgICAg ICAgICAgIHJldHVybiBwb3M7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAg IGlmIChRQ2hhcihidWZmZXJbcG9zLTFdKS5pc0xldHRlck9yTnVtYmVyKCkpCisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBwb3M7CisgICAgICAgICAgICB9CiAgICAgICAgICAgICBwb3MgPSBp dGVyYXRvci50b1ByZXZpb3VzQm91bmRhcnkoKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4g MDsKICAgICB9CiB9CiAKK2ludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXgoVUNoYXIgY29uc3QqIGJ1 ZmZlciwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQpCit7CisgICAgcmV0dXJu IGZpbmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxh dGl2ZVRvV29yZAorICAgICAgICAoYnVmZmVyLCBsZW4sIHBvc2l0aW9uLCBmb3J3YXJkLCBmb3J3 YXJkID8gTG9naWNhbGx5QWZ0ZXJXb3JkIDogTG9naWNhbGx5QmVmb3JlV29yZCk7Cit9CisKIHZv aWQgZmluZFdvcmRCb3VuZGFyeShVQ2hhciBjb25zdCogYnVmZmVyLCBpbnQgbGVuLCBpbnQgcG9z aXRpb24sIGludCogc3RhcnQsIGludCogZW5kKQogewogICAgIFFTdHJpbmcgc3RyKHJlaW50ZXJw cmV0X2Nhc3Q8UUNoYXIgY29uc3QqPihidWZmZXIpLCBsZW4pOwpJbmRleDogTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24g OTMwNjIpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyAr MSwxNCBAQAorMjAxMS0wOC0xNSAgVmFuIExhbSAgPHZhbmxhbUBnb29nbGUuY29tPgorCisgICAg ICAgIFByb3ZpZGUgZmxleGlibGUgKGluIHRlcm1zIG9mIHBvc2l0aW9uIHJlbGF0aXZlIHRvIHNw YWNlKSBsb2dpY2FsIHdvcmQgYnJlYWtlciB0byBpbXByb3ZlIHBlcmZvcm1hbmNlIG9mIC0td2Vi a2l0LXZpc3VhbC13b3JkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD02NTI3NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE15IGNoYW5nZSBmaXhlZCBhIGZhaWx1cmUgaW4gdGhpcyB0ZXN0IGNhc2UuCisKKyAg ICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9tb3ZlLWJ5LXdvcmQtdmlzdWFsbHktc2luZ2xlLXNw YWNlLWlubGluZS1lbGVtZW50LWV4cGVjdGVkLnR4dDoKKwogMjAxMS0wOC0xNSAgQ2hyaXMgUm9n ZXJzICA8Y3JvZ2Vyc0Bnb29nbGUuY29tPgogCiAgICAgICAgIEFkZCBzaGVsbCBpbXBsZW1lbnRh dGlvbiBmb3IgV2ViIEF1ZGlvIEFQSSdzIE1lZGlhRWxlbWVudEF1ZGlvU291cmNlTm9kZQpJbmRl eDogTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNp bmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1z cGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDkzMDYyKQorKysgTGF5 b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1z cGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQJKHdvcmtpbmcgY29weSkKQEAgLTEzNyw5 ICsxMzcsNiBAQCBUZXN0IDIwLCBSVEw6CiBNb3ZlIGxlZnQgYnkgb25lIHdvcmQKICJBQkQgb3Bx IHJzdCBEU1UgIlswLCA0LCA3LCAxMiwgMTZdLCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTIsIDgs IDcsIDNdLCAiQUJXIGhpaiB4eXogRlhYIls0LCA3LCAxMiwgMTVdICAgIEZBSUwgZXhwZWN0ZWQ6 IFsiQUJEIG9wcSByc3QgRFNVICJbIDAsICA0LCAgNywgIDEyLCAgMTYsIF0iYWJjIHV2dyBBQUEg ZGVmIGxtbiJbIDE1LCAgOCwgIDcsICAzLCBdIkFCVyBoaWogeHl6IEZYWCJbIDQsICA3LCAgMTIs ICAxNV0KICJBQkQgb3BxIHJzdCBEU1UgIlsxNl0sICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxMl0g ICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgMTVdCi0iYWJjIHV2dyBBQUEg ZGVmIGxtbiJbMTgsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAx NV0KLSJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxNywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2 dyBBQUEgZGVmIGxtbiJbIDE1XQotImFiYyB1dncgQUFBIGRlZiBsbW4iWzE2LCAxMl0gICBGQUlM IGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgMTVdCiAiYWJjIHV2dyBBQUEgZGVmIGxt biJbMTUsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyA4XQogImFi YyB1dncgQUFBIGRlZiBsbW4iWzE0LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBk ZWYgbG1uIlsgOF0KICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxMywgMTJdICAgRkFJTCBleHBlY3Rl ZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDhdCg== 104254 2011-08-17 15:07:16 -0700 2011-09-14 21:49:47 -0700 Proposed fix vanlam-internalapi text/plain 19182 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkzMjQ3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTEtMDgtMTcgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBNYWtlIGZ1bmN0aW9ucyB0byBmaW5kIHdv cmQgYm91bmRhcmllcyBtb3JlIGZsZXhpYmxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02NTI3NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEV4dHJhY3RlZCBmdW5jdGlvbmFsaXR5IG9mIG5leHRXb3JkQm91 bmRhcnkgdG8gcGFyYW1ldHJpemUgaXQgd2l0aAorICAgICAgICB3aGVyZSB0aGUgd29yZCBicmVh ayBzaG91bGQgYmUgcmVsYXRpdmUgdG8gdGhlIHdvcmQgKGJlZm9yZSBvciBhZnRlcikKKyAgICAg ICAgd2hpbGUgbWFpbnRhaW5pbmcgZXhpc3RpbmcgZnVuY3Rpb25hbGl0eS4gSW50cm9kdWNlZCBm b3VyIHNlYXJjaAorICAgICAgICBmdW5jdGlvbnMgdG8gY2hvb3NlIHdoZXJlIHRoZSB3b3JkIGJy ZWFrIHNob3VsZCBiZS4gVXRpbGl6ZWQgdGhlc2UKKyAgICAgICAgY2hhbmdlcyBpbiByaWdodC9s ZWZ0V29yZEJvdW5kYXJ5IHRvIGF2b2lkIGNvbGxlY3Rpbmcgd29yZCBib3VuZGFyaWVzCisgICAg ICAgIHdoZW4gbW92aW5nIHdpdGhpbiBib3hlcy4KKworICAgICAgICAqIGVkaXRpbmcvdmlzaWJs ZV91bml0cy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5k YXJ5QmVmb3JlV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpwcmV2aW91c1dvcmRQb3NpdGlvbkJv dW5kYXJ5QWZ0ZXJXb3JkKToKKyAgICAgICAgKFdlYkNvcmU6Om5leHRXb3JkUG9zaXRpb25Cb3Vu ZGFyeUJlZm9yZVdvcmQpOgorICAgICAgICAoV2ViQ29yZTo6bmV4dFdvcmRQb3NpdGlvbkJvdW5k YXJ5QWZ0ZXJXb3JkKToKKyAgICAgICAgKFdlYkNvcmU6OmxlZnRXb3JkUG9zaXRpb25BY3Jvc3NC b3VuZGFyeSk6CisgICAgICAgIChXZWJDb3JlOjpyaWdodFdvcmRQb3NpdGlvbkFjcm9zc0JvdW5k YXJ5KToKKyAgICAgICAgKiBwbGF0Zm9ybS90ZXh0L1RleHRCb3VuZGFyaWVzLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OmZpbmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9z aXRpb25pbmdSZWxhdGl2ZVRvV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpmaW5kTmV4dFdvcmRG cm9tSW5kZXgpOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvVGV4dEJvdW5kYXJpZXMuaDoKKyAg ICAgICAgKFdlYkNvcmU6OnJlcXVpcmVzQ29udGV4dEZvcldvcmRCb3VuZGFyeSk6CisgICAgICAg ICogcGxhdGZvcm0vdGV4dC9icmV3L1RleHRCb3VuZGFyaWVzQnJldy5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9u aW5nUmVsYXRpdmVUb1dvcmQpOgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvbWFjL1RleHRCb3Vu ZGFyaWVzLm1tOgorICAgICAgICAoV2ViQ29yZTo6ZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lk ZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKToKKyAgICAgICAgKiBwbGF0 Zm9ybS90ZXh0L3F0L1RleHRCb3VuZGFyaWVzUXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Zmlu ZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZl VG9Xb3JkKToKKwogMjAxMS0wOC0xNyAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5jb20+ CiAKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY2MzU0 IGFuZCA8cmRhcjovL3Byb2JsZW0vOTk2NTIwOT4KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2VkaXRp bmcvdmlzaWJsZV91bml0cy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvZWRpdGlu Zy92aXNpYmxlX3VuaXRzLmNwcAkocmV2aXNpb24gOTMyNDUpCisrKyBTb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01Myw2ICs1Myw4IEBA IGVudW0gQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxhYmlsaXR5IHsKIAogdHlwZWRlZiB1bnNp Z25lZCAoKkJvdW5kYXJ5U2VhcmNoRnVuY3Rpb24pKGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVu Z3RoLCB1bnNpZ25lZCBvZmZzZXQsIEJvdW5kYXJ5U2VhcmNoQ29udGV4dEF2YWlsYWJpbGl0eSwg Ym9vbCYgbmVlZE1vcmVDb250ZXh0KTsKIAordHlwZWRlZiB1bnNpZ25lZCAoKkJvdW5kYXJ5U2Vh cmNoRnVuY3Rpb25Db25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nKShjb25zdCBVQ2hhcios IHVuc2lnbmVkIGxlbmd0aCwgdW5zaWduZWQgb2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRB dmFpbGFiaWxpdHksIGJvb2wmIG5lZWRNb3JlQ29udGV4dCwgV29yZEJyZWFrUG9zaXRpb25pbmdS ZWxhdGl2ZVRvV29yZCk7CisKIHN0YXRpYyBWaXNpYmxlUG9zaXRpb24gcHJldmlvdXNCb3VuZGFy eShjb25zdCBWaXNpYmxlUG9zaXRpb24mIGMsIEJvdW5kYXJ5U2VhcmNoRnVuY3Rpb24gc2VhcmNo RnVuY3Rpb24pCiB7CiAgICAgUG9zaXRpb24gcG9zID0gYy5kZWVwRXF1aXZhbGVudCgpOwpAQCAt Mjg5LDYgKzI5MSwyNiBAQCBzdGF0aWMgdW5zaWduZWQgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3Vu CiAgICAgcmV0dXJuIGZpbmROZXh0V29yZEZyb21JbmRleChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9m ZnNldCwgZmFsc2UpOwogfQogCitzdGF0aWMgdW5zaWduZWQgcHJldmlvdXNXb3JkUG9zaXRpb25C b3VuZGFyeUJlZm9yZVdvcmQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIHVuc2lnbmVkIGxlbmd0 aCwgdW5zaWduZWQgb2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHkgbWF5 SGF2ZU1vcmVDb250ZXh0LCBib29sJiBuZWVkTW9yZUNvbnRleHQpCit7CisgICAgaWYgKG1heUhh dmVNb3JlQ29udGV4dCAmJiAhc3RhcnRPZkxhc3RXb3JkQm91bmRhcnlDb250ZXh0KGNoYXJhY3Rl cnMsIG9mZnNldCkpIHsKKyAgICAgICAgbmVlZE1vcmVDb250ZXh0ID0gdHJ1ZTsKKyAgICAgICAg cmV0dXJuIDA7CisgICAgfQorICAgIG5lZWRNb3JlQ29udGV4dCA9IGZhbHNlOworICAgIHJldHVy biBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVs YXRpdmVUb1dvcmQoY2hhcmFjdGVycywgbGVuZ3RoLCBvZmZzZXQsIGZhbHNlLCBCZWZvcmVXb3Jk KTsKK30KKworc3RhdGljIHVuc2lnbmVkIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlBZnRl cldvcmQoY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMsIHVuc2lnbmVkIGxlbmd0aCwgdW5zaWduZWQg b2Zmc2V0LCBCb3VuZGFyeVNlYXJjaENvbnRleHRBdmFpbGFiaWxpdHkgbWF5SGF2ZU1vcmVDb250 ZXh0LCBib29sJiBuZWVkTW9yZUNvbnRleHQpCit7CisgICAgaWYgKG1heUhhdmVNb3JlQ29udGV4 dCAmJiAhc3RhcnRPZkxhc3RXb3JkQm91bmRhcnlDb250ZXh0KGNoYXJhY3RlcnMsIG9mZnNldCkp IHsKKyAgICAgICAgbmVlZE1vcmVDb250ZXh0ID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIDA7Cisg ICAgfQorICAgIG5lZWRNb3JlQ29udGV4dCA9IGZhbHNlOworICAgIHJldHVybiBmaW5kTmV4dFdv cmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQo Y2hhcmFjdGVycywgbGVuZ3RoLCBvZmZzZXQsIGZhbHNlLCBBZnRlcldvcmQpOworfQorCiBWaXNp YmxlUG9zaXRpb24gcHJldmlvdXNXb3JkUG9zaXRpb24oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZj KQogewogICAgIFZpc2libGVQb3NpdGlvbiBwcmV2ID0gcHJldmlvdXNCb3VuZGFyeShjLCBwcmV2 aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKQEAgLTMwNSw2ICszMjcsMjYgQEAgc3RhdGljIHVu c2lnbmVkIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeQogICAgIHJldHVybiBmaW5kTmV4dFdvcmRG cm9tSW5kZXgoY2hhcmFjdGVycywgbGVuZ3RoLCBvZmZzZXQsIHRydWUpOwogfQogCitzdGF0aWMg dW5zaWduZWQgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5QmVmb3JlV29yZChjb25zdCBVQ2hhciog Y2hhcmFjdGVycywgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBvZmZzZXQsIEJvdW5kYXJ5U2Vh cmNoQ29udGV4dEF2YWlsYWJpbGl0eSBtYXlIYXZlTW9yZUNvbnRleHQsIGJvb2wmIG5lZWRNb3Jl Q29udGV4dCkKK3sKKyAgICBpZiAobWF5SGF2ZU1vcmVDb250ZXh0ICYmIGVuZE9mRmlyc3RXb3Jk Qm91bmRhcnlDb250ZXh0KGNoYXJhY3RlcnMgKyBvZmZzZXQsIGxlbmd0aCAtIG9mZnNldCkgPT0g c3RhdGljX2Nhc3Q8aW50PihsZW5ndGggLSBvZmZzZXQpKSB7CisgICAgICAgIG5lZWRNb3JlQ29u dGV4dCA9IHRydWU7CisgICAgICAgIHJldHVybiBsZW5ndGg7CisgICAgfQorICAgIG5lZWRNb3Jl Q29udGV4dCA9IGZhbHNlOworICAgIHJldHVybiBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRl cmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQoY2hhcmFjdGVycywgbGVuZ3Ro LCBvZmZzZXQsIHRydWUsIEJlZm9yZVdvcmQpOworfQorCitzdGF0aWMgdW5zaWduZWQgbmV4dFdv cmRQb3NpdGlvbkJvdW5kYXJ5QWZ0ZXJXb3JkKGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCB1bnNp Z25lZCBsZW5ndGgsIHVuc2lnbmVkIG9mZnNldCwgQm91bmRhcnlTZWFyY2hDb250ZXh0QXZhaWxh YmlsaXR5IG1heUhhdmVNb3JlQ29udGV4dCwgYm9vbCYgbmVlZE1vcmVDb250ZXh0KQoreworICAg IGlmIChtYXlIYXZlTW9yZUNvbnRleHQgJiYgZW5kT2ZGaXJzdFdvcmRCb3VuZGFyeUNvbnRleHQo Y2hhcmFjdGVycyArIG9mZnNldCwgbGVuZ3RoIC0gb2Zmc2V0KSA9PSBzdGF0aWNfY2FzdDxpbnQ+ KGxlbmd0aCAtIG9mZnNldCkpIHsKKyAgICAgICAgbmVlZE1vcmVDb250ZXh0ID0gdHJ1ZTsKKyAg ICAgICAgcmV0dXJuIGxlbmd0aDsKKyAgICB9CisgICAgbmVlZE1vcmVDb250ZXh0ID0gZmFsc2U7 CisgICAgcmV0dXJuIGZpbmROZXh0V29yZEZyb21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9z aXRpb25pbmdSZWxhdGl2ZVRvV29yZChjaGFyYWN0ZXJzLCBsZW5ndGgsIG9mZnNldCwgdHJ1ZSwg QWZ0ZXJXb3JkKTsKK30KKwogVmlzaWJsZVBvc2l0aW9uIG5leHRXb3JkUG9zaXRpb24oY29uc3Qg VmlzaWJsZVBvc2l0aW9uICZjKQogewogICAgIFZpc2libGVQb3NpdGlvbiBuZXh0ID0gbmV4dEJv dW5kYXJ5KGMsIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7ICAgIApAQCAtMTYxNCwxNCArMTY1 NiwxNCBAQCBzdGF0aWMgVmlzaWJsZVBvc2l0aW9uIGxlZnRXb3JkUG9zaXRpb25BCiAgICAgaWYg KG9mZnNldCA9PSBib3gtPmNhcmV0UmlnaHRtb3N0T2Zmc2V0KCkpCiAgICAgICAgIHJldHVybiBs ZWZ0V29yZEJvdW5kYXJ5KGJveCwgb2Zmc2V0LCBibG9ja0RpcmVjdGlvbik7CiAgICAgCi0gICAg CiAgICAgVmlzaWJsZVBvc2l0aW9uIHdvcmRCcmVhazsKLSAgICBpZiAoYmxvY2tEaXJlY3Rpb24g PT0gTFRSKSB7Ci0gICAgICAgIGlmIChib3gtPmRpcmVjdGlvbigpID09IGJsb2NrRGlyZWN0aW9u KQotICAgICAgICAgICAgd29yZEJyZWFrID0gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9zaXRp b24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwotICAgICAgICBlbHNlCi0gICAgICAg ICAgICB3b3JkQnJlYWsgPSBuZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBv c2l0aW9uQm91bmRhcnkpOwotICAgIH0KKyAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKQor ICAgICAgICB3b3JkQnJlYWsgPSBib3gtPmRpcmVjdGlvbigpID09IExUUiA/IHByZXZpb3VzQm91 bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5QmVmb3Jl V29yZCkKKyAgICAgICAgICAgIDogbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdv cmRQb3NpdGlvbkJvdW5kYXJ5QWZ0ZXJXb3JkKTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVh ayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9z aXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnlBZnRlcldvcmQpCisgICAgICAgICAg ICA6IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFy eUJlZm9yZVdvcmQpOworICAgIAogICAgIGlmICh3b3JkQnJlYWsuaXNOb3ROdWxsKCkgJiYgcG9z aXRpb25Jc0luQm94QnV0Tm90T25Cb3VuZGFyeSh3b3JkQnJlYWssIGJveCkpCiAgICAgICAgIHJl dHVybiB3b3JkQnJlYWs7CiAgICAgCkBAIC0xNjUzLDEyICsxNjk1LDEzIEBAIHN0YXRpYyBWaXNp YmxlUG9zaXRpb24gcmlnaHRXb3JkUG9zaXRpb24KICAgICAgICAgcmV0dXJuIHJpZ2h0V29yZEJv dW5kYXJ5KHJpZ2h0SW5saW5lQm94KGJveCwgYmxvY2tEaXJlY3Rpb24pLCBpbnZhbGlkT2Zmc2V0 LCBibG9ja0RpcmVjdGlvbik7CiAgCiAgICAgVmlzaWJsZVBvc2l0aW9uIHdvcmRCcmVhazsKLSAg ICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gUlRMKSB7Ci0gICAgICAgIGlmIChib3gtPmRpcmVjdGlv bigpID09IGJsb2NrRGlyZWN0aW9uKQotICAgICAgICAgICAgd29yZEJyZWFrID0gcHJldmlvdXNC b3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwot ICAgICAgICBlbHNlCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBuZXh0Qm91bmRhcnkodmlzaWJs ZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOwotICAgIH0KKyAgICBpZiAoYmxv Y2tEaXJlY3Rpb24gPT0gTFRSKQorICAgICAgICB3b3JkQnJlYWsgPSBib3gtPmRpcmVjdGlvbigp ID09IExUUiA/IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRpb25C b3VuZGFyeUJlZm9yZVdvcmQpCisgICAgICAgICAgICA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJs ZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5QWZ0ZXJXb3JkKTsKKyAgICBl bHNlCisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+ZGlyZWN0aW9uKCkgPT0gTFRSID8gbmV4dEJv dW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5QWZ0ZXJXb3Jk KQorICAgICAgICAgICAgOiBwcmV2aW91c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgcHJldmlv dXNXb3JkUG9zaXRpb25Cb3VuZGFyeUJlZm9yZVdvcmQpOworICAgICAgICAgICAgCiAgICAgaWYg KHdvcmRCcmVhay5pc05vdE51bGwoKSAmJiBwb3NpdGlvbklzSW5Cb3hCdXROb3RPbkJvdW5kYXJ5 KHdvcmRCcmVhaywgYm94KSkKICAgICAgICAgcmV0dXJuIHdvcmRCcmVhazsKICAgICAKSW5kZXg6 IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dEJvdW5kYXJpZXMuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dEJvdW5kYXJpZXMuY3BwCShy ZXZpc2lvbiA5MzI0NSkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dEJvdW5k YXJpZXMuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02MiwzNyArNjIsNjUgQEAgaW50IHN0YXJ0T2ZM YXN0V29yZEJvdW5kYXJ5Q29udGV4dChjb25zdAogCiAjaWYgIVBMQVRGT1JNKEJSRVdNUCkgJiYg IVBMQVRGT1JNKE1BQykgJiYgIVBMQVRGT1JNKFFUKQogCi1pbnQgZmluZE5leHRXb3JkRnJvbUlu ZGV4KGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndh cmQpCitpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlv bmluZ1JlbGF0aXZlVG9Xb3JkKGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0 aW9uLCBib29sIGZvcndhcmQsIFdvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQgd29y ZEJyZWFrUG9zaXRpb25pbmcpCiB7CiAgICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29yZEJy ZWFrSXRlcmF0b3IoY2hhcnMsIGxlbik7CiAKICAgICBpZiAoZm9yd2FyZCkgewogICAgICAgICBw b3NpdGlvbiA9IHRleHRCcmVha0ZvbGxvd2luZyhpdCwgcG9zaXRpb24pOwogICAgICAgICB3aGls ZSAocG9zaXRpb24gIT0gVGV4dEJyZWFrRG9uZSkgewotICAgICAgICAgICAgLy8gV2Ugc3RvcCBz ZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIHByZWNlZWRpbmcgdGhlIGJyZWFrCi0gICAgICAg ICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCi0gICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4g JiYgaXNBbHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb24gLSAxXSkpCi0gICAgICAgICAgICAgICAg cmV0dXJuIHBvc2l0aW9uOworICAgICAgICAgICAgaWYgKHdvcmRCcmVha1Bvc2l0aW9uaW5nID09 IEFmdGVyV29yZCkgeworICAgICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNoaW5nIHdoZW4g dGhlIGNoYXJhY3RlciBwcmVjZWVkaW5nIHRoZSBicmVhaworICAgICAgICAgICAgICAgIC8vIGlz IGFscGhhbnVtZXJpYy4KKyAgICAgICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4gJiYgaXNB bHBoYW51bWVyaWMoY2hhcnNbcG9zaXRpb24gLSAxXSkpCisgICAgICAgICAgICAgICAgICAgIHJl dHVybiBwb3NpdGlvbjsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgLy8g V2Ugc3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFjdGVyIGZvbGxvd2luZyB0aGUgYnJlYWsK KyAgICAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMuCisgICAgICAgICAgICAgICAgaWYg KHBvc2l0aW9uID4gMCAmJiBpc0FscGhhbnVtZXJpYyhjaGFyc1twb3NpdGlvbl0pKQorICAgICAg ICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAgICAgICAgICB9CiAKICAgICAgICAg ICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrRm9sbG93aW5nKGl0LCBwb3NpdGlvbik7CiAgICAgICAg IH0KIAogICAgICAgICByZXR1cm4gbGVuOwotICAgIH0gZWxzZSB7Ci0gICAgICAgIHBvc2l0aW9u ID0gdGV4dEJyZWFrUHJlY2VkaW5nKGl0LCBwb3NpdGlvbik7Ci0gICAgICAgIHdoaWxlIChwb3Np dGlvbiAhPSBUZXh0QnJlYWtEb25lKSB7CisgICAgfQorICAgIAorICAgIHBvc2l0aW9uID0gdGV4 dEJyZWFrUHJlY2VkaW5nKGl0LCBwb3NpdGlvbik7CisgICAgd2hpbGUgKHBvc2l0aW9uICE9IFRl eHRCcmVha0RvbmUpIHsKKyAgICAgICAgaWYgKHdvcmRCcmVha1Bvc2l0aW9uaW5nID09IEJlZm9y ZVdvcmQpIHsKICAgICAgICAgICAgIC8vIFdlIHN0b3Agc2VhcmNoaW5nIHdoZW4gdGhlIGNoYXJh Y3RlciBmb2xsb3dpbmcgdGhlIGJyZWFrCiAgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMu CiAgICAgICAgICAgICBpZiAocG9zaXRpb24gPiAwICYmIGlzQWxwaGFudW1lcmljKGNoYXJzW3Bv c2l0aW9uXSkpCiAgICAgICAgICAgICAgICAgcmV0dXJuIHBvc2l0aW9uOwotCi0gICAgICAgICAg ICBwb3NpdGlvbiA9IHRleHRCcmVha1ByZWNlZGluZyhpdCwgcG9zaXRpb24pOworICAgICAgICB9 IGVsc2UgeworICAgICAgICAgICAgLy8gV2Ugc3RvcCBzZWFyY2hpbmcgd2hlbiB0aGUgY2hhcmFj dGVyIHByZWNlZWRpbmcgdGhlIGJyZWFrCisgICAgICAgICAgICAvLyBpcyBhbHBoYW51bWVyaWMu CisgICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4gJiYgaXNBbHBoYW51bWVyaWMoY2hhcnNb cG9zaXRpb24gLSAxXSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIHBvc2l0aW9uOwogICAgICAg ICB9CiAKLSAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIHBvc2l0aW9uID0gdGV4dEJyZWFrUHJl Y2VkaW5nKGl0LCBwb3NpdGlvbik7CiAgICAgfQorCisgICAgcmV0dXJuIDA7Cit9CisKKyNlbmRp ZiAvLyAhUExBVEZPUk0oQlJFV01QKSAmJiAhUExBVEZPUk0oTUFDKSAmJiAhUExBVEZPUk0oUVQp CisKKyNpZiAhUExBVEZPUk0oQlJFV01QKQorCitpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4KGNv bnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQpCit7 ICAgIAorICAgIHJldHVybiBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRlcmluZ1dvcmRCcmVh a1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQKKyAgICAgICAgKGNoYXJzLCBsZW4sIHBvc2l0aW9u LCBmb3J3YXJkLCBmb3J3YXJkID8gQWZ0ZXJXb3JkIDogQmVmb3JlV29yZCk7CiB9CiAKKyNlbmRp ZiAvLyAhUExBVEZPUk0oQlJFV01QKQorCisjaWYgIVBMQVRGT1JNKEJSRVdNUCkgJiYgIVBMQVRG T1JNKE1BQykgJiYgIVBMQVRGT1JNKFFUKQorCiB2b2lkIGZpbmRXb3JkQm91bmRhcnkoY29uc3Qg VUNoYXIqIGNoYXJzLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGludCogc3RhcnQsIGludCogZW5k KQogewogICAgIFRleHRCcmVha0l0ZXJhdG9yKiBpdCA9IHdvcmRCcmVha0l0ZXJhdG9yKGNoYXJz LCBsZW4pOwpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9UZXh0Qm91bmRhcmll cy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvVGV4dEJvdW5k YXJpZXMuaAkocmV2aXNpb24gOTMyNDUpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0 L1RleHRCb3VuZGFyaWVzLmgJKHdvcmtpbmcgY29weSkKQEAgLTMwLDE2ICszMCwxOSBAQAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKLSAgICBpbmxpbmUgYm9vbCByZXF1aXJlc0NvbnRleHRGb3JX b3JkQm91bmRhcnkoVUNoYXIzMiBjaCkKLSAgICB7Ci0gICAgICAgIHJldHVybiBXVEY6OlVuaWNv ZGU6Omhhc0xpbmVCcmVha2luZ1Byb3BlcnR5Q29tcGxleENvbnRleHQoY2gpOwotICAgIH0KK2Vu dW0gV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZCB7IEJlZm9yZVdvcmQsIEFmdGVy V29yZCB9OwogCi0gICAgaW50IGVuZE9mRmlyc3RXb3JkQm91bmRhcnlDb250ZXh0KGNvbnN0IFVD aGFyKiBjaGFyYWN0ZXJzLCBpbnQgbGVuZ3RoKTsKLSAgICBpbnQgc3RhcnRPZkxhc3RXb3JkQm91 bmRhcnlDb250ZXh0KGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzLCBpbnQgbGVuZ3RoKTsKK2lubGlu ZSBib29sIHJlcXVpcmVzQ29udGV4dEZvcldvcmRCb3VuZGFyeShVQ2hhcjMyIGNoKQoreworICAg IHJldHVybiBXVEY6OlVuaWNvZGU6Omhhc0xpbmVCcmVha2luZ1Byb3BlcnR5Q29tcGxleENvbnRl eHQoY2gpOworfQorCitpbnQgZW5kT2ZGaXJzdFdvcmRCb3VuZGFyeUNvbnRleHQoY29uc3QgVUNo YXIqIGNoYXJhY3RlcnMsIGludCBsZW5ndGgpOworaW50IHN0YXJ0T2ZMYXN0V29yZEJvdW5kYXJ5 Q29udGV4dChjb25zdCBVQ2hhciogY2hhcmFjdGVycywgaW50IGxlbmd0aCk7CiAKLSAgICB2b2lk IGZpbmRXb3JkQm91bmRhcnkoY29uc3QgVUNoYXIqLCBpbnQgbGVuLCBpbnQgcG9zaXRpb24sIGlu dCogc3RhcnQsIGludCogZW5kKTsKLSAgICBpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4KGNvbnN0 IFVDaGFyKiwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQpOwordm9pZCBmaW5k V29yZEJvdW5kYXJ5KGNvbnN0IFVDaGFyKiwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBpbnQqIHN0 YXJ0LCBpbnQqIGVuZCk7CitpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4KGNvbnN0IFVDaGFyKiwg aW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQpOworaW50IGZpbmROZXh0V29yZEZy b21JbmRleENvbnNpZGVyaW5nV29yZEJyZWFrUG9zaXRpb25pbmdSZWxhdGl2ZVRvV29yZChjb25z dCBVQ2hhciosIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkLCBXb3JkQnJlYWtQ b3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkKTsKIAogfQogCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS90ZXh0L2JyZXcvVGV4dEJvdW5kYXJpZXNCcmV3LmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L2JyZXcvVGV4dEJvdW5kYXJpZXNCcmV3LmNwcAko cmV2aXNpb24gOTMyNDUpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L2JyZXcvVGV4 dEJvdW5kYXJpZXNCcmV3LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzQsNiArMzQsMTIgQEAgdXNp bmcgbmFtZXNwYWNlIFdURjo6VW5pY29kZTsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitpbnQg ZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0 aXZlVG9Xb3JkKGNvbnN0IFVDaGFyKiBidWZmZXIsIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9v bCBmb3J3YXJkLCBXb3JkQnJlYWtQb3NpdGlvbmluZ1JlbGF0aXZlVG9Xb3JkIHdvcmRCcmVha1Bv c2l0aW9uaW5nKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgcmV0dXJuIDA7Cit9CisK IGludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXgoY29uc3QgVUNoYXIqIGJ1ZmZlciwgaW50IGxlbiwg aW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKSW5k ZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvbWFjL1RleHRCb3VuZGFyaWVzLm1tCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvbWFjL1RleHRCb3VuZGFy aWVzLm1tCShyZXZpc2lvbiA5MzI0NSkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQv bWFjL1RleHRCb3VuZGFyaWVzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0yNiw2ICsyNiw4IEBACiAj aW1wb3J0ICJjb25maWcuaCIKICNpbXBvcnQgIlRleHRCb3VuZGFyaWVzLmgiCiAKKyNpbmNsdWRl ICJUZXh0QnJlYWtJdGVyYXRvci5oIgorCiB1c2luZyBuYW1lc3BhY2UgV1RGOjpVbmljb2RlOwog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00MiwxNSArNDQsMzIgQEAgdm9pZCBmaW5kV29yZEJv dW5kYXJ5KGNvbnN0IFVDaGFyKiBjaGFycwogICAgICplbmQgPSByYW5nZS5sb2NhdGlvbiArIHJh bmdlLmxlbmd0aDsKIH0KIAotaW50IGZpbmROZXh0V29yZEZyb21JbmRleChjb25zdCBVQ2hhciog Y2hhcnMsIGludCBsZW4sIGludCBwb3NpdGlvbiwgYm9vbCBmb3J3YXJkKQoteyAgIAotICAgIE5T U3RyaW5nKiBzdHJpbmcgPSBbW05TU3RyaW5nIGFsbG9jXSBpbml0V2l0aENoYXJhY3RlcnNOb0Nv cHk6Y29uc3RfY2FzdDx1bmljaGFyKj4oY2hhcnMpCi0gICAgICAgIGxlbmd0aDpsZW4gZnJlZVdo ZW5Eb25lOk5PXTsKLSAgICBOU0F0dHJpYnV0ZWRTdHJpbmcqIGF0dHIgPSBbW05TQXR0cmlidXRl ZFN0cmluZyBhbGxvY10gaW5pdFdpdGhTdHJpbmc6c3RyaW5nXTsKLSAgICBpbnQgcmVzdWx0ID0g W2F0dHIgbmV4dFdvcmRGcm9tSW5kZXg6cG9zaXRpb24gZm9yd2FyZDpmb3J3YXJkXTsKLSAgICBb YXR0ciByZWxlYXNlXTsKLSAgICBbc3RyaW5nIHJlbGVhc2VdOwotICAgIHJldHVybiByZXN1bHQ7 CitpbnQgZmluZE5leHRXb3JkRnJvbUluZGV4Q29uc2lkZXJpbmdXb3JkQnJlYWtQb3NpdGlvbmlu Z1JlbGF0aXZlVG9Xb3JkKGNvbnN0IFVDaGFyKiBjaGFycywgaW50IGxlbiwgaW50IHBvc2l0aW9u LCBib29sIGZvcndhcmQsIFdvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQgd29yZEJy ZWFrUG9zaXRpb25pbmcpCit7CisgICAgaWYgKChmb3J3YXJkICYmIHdvcmRCcmVha1Bvc2l0aW9u aW5nID09IEFmdGVyV29yZCkKKyAgICAgICAgfHwgKCFmb3J3YXJkICYmIHdvcmRCcmVha1Bvc2l0 aW9uaW5nID09IEJlZm9yZVdvcmQpKSB7CisgICAgICAgIE5TU3RyaW5nKiBzdHJpbmcgPSBbW05T U3RyaW5nIGFsbG9jXSBpbml0V2l0aENoYXJhY3RlcnNOb0NvcHk6Y29uc3RfY2FzdDx1bmljaGFy Kj4oY2hhcnMpCisgICAgICAgICAgICBsZW5ndGg6bGVuIGZyZWVXaGVuRG9uZTpOT107CisgICAg ICAgIE5TQXR0cmlidXRlZFN0cmluZyogYXR0ciA9IFtbTlNBdHRyaWJ1dGVkU3RyaW5nIGFsbG9j XSBpbml0V2l0aFN0cmluZzpzdHJpbmddOworICAgICAgICBpbnQgcmVzdWx0ID0gW2F0dHIgbmV4 dFdvcmRGcm9tSW5kZXg6cG9zaXRpb24gZm9yd2FyZDpmb3J3YXJkXTsKKyAgICAgICAgW2F0dHIg cmVsZWFzZV07CisgICAgICAgIFtzdHJpbmcgcmVsZWFzZV07CisgICAgICAgIHJldHVybiByZXN1 bHQ7CisgICAgfQorCisgICAgVGV4dEJyZWFrSXRlcmF0b3IqIGl0ID0gd29yZEJyZWFrSXRlcmF0 b3IoY2hhcnMsIGxlbik7CisgICAgcG9zaXRpb24gPSBmb3J3YXJkID8gdGV4dEJyZWFrRm9sbG93 aW5nKGl0LCBwb3NpdGlvbikgOiB0ZXh0QnJlYWtQcmVjZWRpbmcoaXQsIHBvc2l0aW9uKTsKKyAg ICB3aGlsZSAocG9zaXRpb24gIT0gVGV4dEJyZWFrRG9uZSkgeworICAgICAgICBpZiAoZm9yd2Fy ZCkgeworICAgICAgICAgICAgaWYgKHBvc2l0aW9uID4gMCAmJiBbW05TQ2hhcmFjdGVyU2V0IGFs cGhhbnVtZXJpY0NoYXJhY3RlclNldF0gY2hhcmFjdGVySXNNZW1iZXI6Y2hhcnNbcG9zaXRpb25d XSkKKyAgICAgICAgICAgICAgICByZXR1cm4gcG9zaXRpb247CisgICAgICAgIH0gZWxzZSB7Cisg ICAgICAgICAgICBpZiAocG9zaXRpb24gPCBsZW4gJiYgW1tOU0NoYXJhY3RlclNldCBhbHBoYW51 bWVyaWNDaGFyYWN0ZXJTZXRdIGNoYXJhY3RlcklzTWVtYmVyOmNoYXJzW3Bvc2l0aW9uIC0gMV1d KQorICAgICAgICAgICAgICAgIHJldHVybiBwb3NpdGlvbjsKKyAgICAgICAgfQorICAgICAgICBw b3NpdGlvbiA9IGZvcndhcmQgPyB0ZXh0QnJlYWtGb2xsb3dpbmcoaXQsIHBvc2l0aW9uKSA6IHRl eHRCcmVha1ByZWNlZGluZyhpdCwgcG9zaXRpb24pOworICAgIH0KKyAgICByZXR1cm4gZm9yd2Fy ZCA/IGxlbiA6IDA7CiB9CiAKIH0KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQv cXQvVGV4dEJvdW5kYXJpZXNRdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vdGV4dC9xdC9UZXh0Qm91bmRhcmllc1F0LmNwcAkocmV2aXNpb24gOTMyNDUpCisrKyBT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L3F0L1RleHRCb3VuZGFyaWVzUXQuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC00MCw3ICs0MCw3IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotaW50 IGZpbmROZXh0V29yZEZyb21JbmRleChVQ2hhciBjb25zdCogYnVmZmVyLCBpbnQgbGVuLCBpbnQg cG9zaXRpb24sIGJvb2wgZm9yd2FyZCkKK2ludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXhDb25zaWRl cmluZ1dvcmRCcmVha1Bvc2l0aW9uaW5nUmVsYXRpdmVUb1dvcmQoVUNoYXIgY29uc3QqIGJ1ZmZl ciwgaW50IGxlbiwgaW50IHBvc2l0aW9uLCBib29sIGZvcndhcmQsIFdvcmRCcmVha1Bvc2l0aW9u aW5nUmVsYXRpdmVUb1dvcmQgd29yZEJyZWFrUG9zaXRpb25pbmcpCiB7CiAgICAgUVN0cmluZyBz dHIocmVpbnRlcnByZXRfY2FzdDxRQ2hhciBjb25zdCo+KGJ1ZmZlciksIGxlbik7CiAgICAgUVRl eHRCb3VuZGFyeUZpbmRlciBpdGVyYXRvcihRVGV4dEJvdW5kYXJ5RmluZGVyOjpXb3JkLCBzdHIp OwpAQCAtNDgsMjAgKzQ4LDMwIEBAIGludCBmaW5kTmV4dFdvcmRGcm9tSW5kZXgoVUNoYXIgY29u c3QqIGIKICAgICBpZiAoZm9yd2FyZCkgewogICAgICAgICBpbnQgcG9zID0gaXRlcmF0b3IudG9O ZXh0Qm91bmRhcnkoKTsKICAgICAgICAgd2hpbGUgKHBvcyA+IDApIHsKLSAgICAgICAgICAgIGlm IChRQ2hhcihidWZmZXJbcG9zLTFdKS5pc0xldHRlck9yTnVtYmVyKCkpCi0gICAgICAgICAgICAg ICAgcmV0dXJuIHBvczsKKyAgICAgICAgICAgIGlmICh3b3JkQnJlYWtQb3NpdGlvbmluZyA9PSBB ZnRlcldvcmQpIHsKKyAgICAgICAgICAgICAgICBpZiAoUUNoYXIoYnVmZmVyW3Bvcy0xXSkuaXNM ZXR0ZXJPck51bWJlcigpKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gcG9zOworICAgICAg ICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICBpZiAoUUNoYXIoYnVmZmVyW3Bvc10pLmlz TGV0dGVyT3JOdW1iZXIoKSkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHBvczsKKyAgICAg ICAgICAgIH0KICAgICAgICAgICAgIHBvcyA9IGl0ZXJhdG9yLnRvTmV4dEJvdW5kYXJ5KCk7CiAg ICAgICAgIH0KICAgICAgICAgcmV0dXJuIGxlbjsKLSAgICB9IGVsc2UgewotICAgICAgICBpbnQg cG9zID0gaXRlcmF0b3IudG9QcmV2aW91c0JvdW5kYXJ5KCk7Ci0gICAgICAgIHdoaWxlIChwb3Mg PiAwKSB7CisgICAgfQorCisgICAgaW50IHBvcyA9IGl0ZXJhdG9yLnRvUHJldmlvdXNCb3VuZGFy eSgpOworICAgIHdoaWxlIChwb3MgPiAwKSB7CisgICAgICAgIGlmICh3b3JkQnJlYWtQb3NpdGlv bmluZyA9PSBCZWZvcmVXb3JkKSB7CiAgICAgICAgICAgICBpZiAoUUNoYXIoYnVmZmVyW3Bvc10p LmlzTGV0dGVyT3JOdW1iZXIoKSkKICAgICAgICAgICAgICAgICByZXR1cm4gcG9zOwotICAgICAg ICAgICAgcG9zID0gaXRlcmF0b3IudG9QcmV2aW91c0JvdW5kYXJ5KCk7CisgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICBpZiAoUUNoYXIoYnVmZmVyW3Bvcy0xXSkuaXNMZXR0ZXJPck51bWJl cigpKQorICAgICAgICAgICAgICAgIHJldHVybiBwb3M7CiAgICAgICAgIH0KLSAgICAgICAgcmV0 dXJuIDA7CisgICAgICAgIHBvcyA9IGl0ZXJhdG9yLnRvUHJldmlvdXNCb3VuZGFyeSgpOwogICAg IH0KKyAgICByZXR1cm4gMDsKIH0KIAogdm9pZCBmaW5kV29yZEJvdW5kYXJ5KFVDaGFyIGNvbnN0 KiBidWZmZXIsIGludCBsZW4sIGludCBwb3NpdGlvbiwgaW50KiBzdGFydCwgaW50KiBlbmQpCklu ZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCShyZXZpc2lvbiA5MzI0NykKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDExLTA4LTE3ICBWYW4gTGFtICA8dmFubGFtQGdv b2dsZS5jb20+CisKKyAgICAgICAgTWFrZSBmdW5jdGlvbnMgdG8gZmluZCB3b3JkIGJvdW5kYXJp ZXMgbW9yZSBmbGV4aWJsZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NjUyNzcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBNeSBjaGFuZ2UgZml4ZWQgYSBmYWlsdXJlIGluIHRoaXMgdGVzdCBjYXNlLgorCisg ICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1z cGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQ6CisKIDIwMTEtMDgtMTcgIEJyYWR5IEVp ZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02NjM1NCBhbmQgPHJkYXI6Ly9wcm9ibGVtLzk5NjUyMDk+Cklu ZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9tb3ZlLWJ5LXdvcmQtdmlzdWFsbHkt c2luZ2xlLXNwYWNlLWlubGluZS1lbGVtZW50LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBM YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9tb3ZlLWJ5LXdvcmQtdmlzdWFsbHktc2luZ2xl LXNwYWNlLWlubGluZS1lbGVtZW50LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gOTMyNDUpCisrKyBM YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9tb3ZlLWJ5LXdvcmQtdmlzdWFsbHktc2luZ2xl LXNwYWNlLWlubGluZS1lbGVtZW50LWV4cGVjdGVkLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMTM3 LDkgKzEzNyw2IEBAIFRlc3QgMjAsIFJUTDoKIE1vdmUgbGVmdCBieSBvbmUgd29yZAogIkFCRCBv cHEgcnN0IERTVSAiWzAsIDQsIDcsIDEyLCAxNl0sICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxMiwg OCwgNywgM10sICJBQlcgaGlqIHh5eiBGWFgiWzQsIDcsIDEyLCAxNV0gICAgRkFJTCBleHBlY3Rl ZDogWyJBQkQgb3BxIHJzdCBEU1UgIlsgMCwgIDQsICA3LCAgMTIsICAxNiwgXSJhYmMgdXZ3IEFB QSBkZWYgbG1uIlsgMTUsICA4LCAgNywgIDMsIF0iQUJXIGhpaiB4eXogRlhYIlsgNCwgIDcsICAx MiwgIDE1XQogIkFCRCBvcHEgcnN0IERTVSAiWzE2XSwgImFiYyB1dncgQUFBIGRlZiBsbW4iWzEy XSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KLSJhYmMgdXZ3IEFB QSBkZWYgbG1uIlsxOCwgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJb IDE1XQotImFiYyB1dncgQUFBIGRlZiBsbW4iWzE3LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMg dXZ3IEFBQSBkZWYgbG1uIlsgMTVdCi0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTYsIDEyXSAgIEZB SUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KICJhYmMgdXZ3IEFBQSBkZWYg bG1uIlsxNSwgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDhdCiAi YWJjIHV2dyBBQUEgZGVmIGxtbiJbMTQsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFB IGRlZiBsbW4iWyA4XQogImFiYyB1dncgQUFBIGRlZiBsbW4iWzEzLCAxMl0gICBGQUlMIGV4cGVj dGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0K 104432 2011-08-18 18:26:32 -0700 2011-08-19 16:36:56 -0700 Proposed (alternative) fix vanlam-internalapi text/plain 7195 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkzMzgwKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTEtMDgtMTggIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBNYWtlIGZ1bmN0aW9ucyB0byBmaW5kIHdv cmQgYm91bmRhcmllcyBtb3JlIGZsZXhpYmxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02NTI3NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZGVkIHR3byBmdW5jdGlvbnMgdG8gMSkgZmluZCBuZXh0IHdv cmQgYm91bmRhcnkgYmVmb3JlIHdvcmQgYW5kCisgICAgICAgIDIpIGZpbmQgcHJldmlvdXMgd29y ZCBib3VuZGFyeSBhZnRlciB3b3JkLiBUaGVzZSBmdW5jdGlvbnMgdXNlCisgICAgICAgIG5leHRC b3VuZGFyeSAoZmluZHMgbmV4dCB3b3JkIGJvdW5kYXJ5IGFmdGVyIHdvcmQpIGFuZCBwcmV2aW91 c0JvdW5kYXJ5CisgICAgICAgIChmaW5kcyBwcmV2aW91cyB3b3JkIGJyZWFrIGJlZm9yZSB3b3Jk KSB0byBmaW5kIHRoZSBkZXNpcmVkIHdvcmQKKyAgICAgICAgYm91bmRhcnkuIFVzZWQgdGhlc2Ug ZnVuY3Rpb25zIGluCisgICAgICAgIHJpZ2h0L0xlZnRXb3JkUG9zaXRpb25JZ25vcmluZ0VkaXRp bmdCb3VuZGFyeSB0byBhdm9pZCBjb2xsZWN0aW5nIHdvcmQKKyAgICAgICAgYm91bmRhcmllcyB3 aGVuIG1vdmluZyBieSB3b3JkIHdpdGhpbiBhIGJveC4KKworICAgICAgICAqIGVkaXRpbmcvdmlz aWJsZV91bml0cy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpuZXh0V29yZEJvdW5kYXJ5QmVmb3Jl V29yZCk6CisgICAgICAgIChXZWJDb3JlOjpwcmV2aW91c1dvcmRCb3VuZGFyeUFmdGVyV29yZCk6 CisgICAgICAgIChXZWJDb3JlOjpsZWZ0V29yZFBvc2l0aW9uSWdub3JpbmdFZGl0aW5nQm91bmRh cnkpOgorICAgICAgICAoV2ViQ29yZTo6cmlnaHRXb3JkUG9zaXRpb25JZ25vcmluZ0VkaXRpbmdC b3VuZGFyeSk6CisKIDIwMTEtMDgtMTggIEplZmZyZXkgUGZhdSAgPGpwZmF1QGFwcGxlLmNvbT4K IAogICAgICAgICBOZXcgWE1MIHBhcnNlcjogc2NyaXB0aW5nIHN1cHBvcnQKSW5kZXg6IFNvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvdmlzaWJsZV91bml0cy5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvZWRpdGluZy92aXNpYmxlX3VuaXRzLmNwcAkocmV2aXNpb24gOTMzNzgpCisrKyBT b3VyY2UvV2ViQ29yZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0xNTg3LDYgKzE1ODcsNTAgQEAgc3RhdGljIFZpc2libGVQb3NpdGlvbiByaWdodFdvcmRCb3Vu ZGFyeQogICAgIH0KICAgICByZXR1cm4gVmlzaWJsZVBvc2l0aW9uKCk7CiB9CisKK3N0YXRpYyBW aXNpYmxlUG9zaXRpb24gbmV4dFdvcmRCb3VuZGFyeUJlZm9yZVdvcmQoVmlzaWJsZVBvc2l0aW9u IHN0YXJ0aW5nUG9zaXRpb24sIElubGluZUJveCogc3RhcnRpbmdCb3gsIGludCBzdGFydGluZ09m ZnNldCkKK3sKKyAgICBWaXNpYmxlUG9zaXRpb24gbmV4dCA9IG5leHRCb3VuZGFyeShzdGFydGlu Z1Bvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIGlmIChuZXh0ID09IHN0 YXJ0aW5nUG9zaXRpb24pCisgICAgICAgIHJldHVybiBzdGFydGluZ1Bvc2l0aW9uOworICAgIAor ICAgIElubGluZUJveCogY3VycmVudEJveDsKKyAgICBpbnQgY3VycmVudE9mZnNldDsKKyAgICBW aXNpYmxlUG9zaXRpb24gbmV4dFByZXYgPSBwcmV2aW91c0JvdW5kYXJ5KG5leHQsIHByZXZpb3Vz V29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIG5leHRQcmV2LmdldElubGluZUJveEFuZE9mZnNl dChjdXJyZW50Qm94LCBjdXJyZW50T2Zmc2V0KTsKKyAgICBpZiAoY3VycmVudE9mZnNldCA+IHN0 YXJ0aW5nT2Zmc2V0KQorICAgICAgICByZXR1cm4gbmV4dFByZXY7CisgICAgCisgICAgVmlzaWJs ZVBvc2l0aW9uIG5leHROZXh0ID0gbmV4dEJvdW5kYXJ5KG5leHQsIG5leHRXb3JkUG9zaXRpb25C b3VuZGFyeSk7CisgICAgaWYgKG5leHQgPT0gbmV4dE5leHQpCisgICAgICAgIHJldHVybiBWaXNp YmxlUG9zaXRpb24oKTsKKyAgICAKKyAgICBWaXNpYmxlUG9zaXRpb24gbmV4dE5leHRQcmV2ID0g cHJldmlvdXNCb3VuZGFyeShuZXh0TmV4dCwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7 CisgICAgbmV4dE5leHRQcmV2LmdldElubGluZUJveEFuZE9mZnNldChjdXJyZW50Qm94LCBjdXJy ZW50T2Zmc2V0KTsKKyAgICByZXR1cm4gY3VycmVudEJveCA9PSBzdGFydGluZ0JveCAmJiBjdXJy ZW50T2Zmc2V0ID4gc3RhcnRpbmdPZmZzZXQgPyBuZXh0TmV4dFByZXYgOiBWaXNpYmxlUG9zaXRp b24oKTsKK30KKworc3RhdGljIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c1dvcmRCb3VuZGFyeUFm dGVyV29yZChWaXNpYmxlUG9zaXRpb24gc3RhcnRpbmdQb3NpdGlvbiwgSW5saW5lQm94KiBzdGFy dGluZ0JveCwgaW50IHN0YXJ0aW5nT2Zmc2V0KQoreworICAgIFZpc2libGVQb3NpdGlvbiBwcmV2 ID0gcHJldmlvdXNCb3VuZGFyeShzdGFydGluZ1Bvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlv bkJvdW5kYXJ5KTsKKyAgICBpZiAocHJldiA9PSBzdGFydGluZ1Bvc2l0aW9uKQorICAgICAgICBy ZXR1cm4gc3RhcnRpbmdQb3NpdGlvbjsKKyAgICAKKyAgICBJbmxpbmVCb3gqIGN1cnJlbnRCb3g7 CisgICAgaW50IGN1cnJlbnRPZmZzZXQ7CisgICAgVmlzaWJsZVBvc2l0aW9uIHByZXZOZXh0ID0g bmV4dEJvdW5kYXJ5KHByZXYsIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7CisgICAgcHJldk5l eHQuZ2V0SW5saW5lQm94QW5kT2Zmc2V0KGN1cnJlbnRCb3gsIGN1cnJlbnRPZmZzZXQpOworICAg IGlmIChjdXJyZW50T2Zmc2V0IDwgc3RhcnRpbmdPZmZzZXQpCisgICAgICAgIHJldHVybiBwcmV2 TmV4dDsKKyAgICAgICAgCisgICAgVmlzaWJsZVBvc2l0aW9uIHByZXZQcmV2ID0gcHJldmlvdXNC b3VuZGFyeShwcmV2LCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKKyAgICBpZiAocHJl diA9PSBwcmV2UHJldikKKyAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlvbigpOworICAgIAor ICAgIFZpc2libGVQb3NpdGlvbiBwcmV2UHJldk5leHQgPSBuZXh0Qm91bmRhcnkocHJldlByZXYs IG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7CisgICAgcHJldlByZXZOZXh0LmdldElubGluZUJv eEFuZE9mZnNldChjdXJyZW50Qm94LCBjdXJyZW50T2Zmc2V0KTsKKyAgICByZXR1cm4gY3VycmVu dEJveCA9PSBzdGFydGluZ0JveCAmJiBjdXJyZW50T2Zmc2V0IDwgc3RhcnRpbmdPZmZzZXQgPyBw cmV2UHJldk5leHQgOiBWaXNpYmxlUG9zaXRpb24oKTsKK30KICAgICAKIHN0YXRpYyBib29sIHBv c2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91bmRhcnkoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiB3b3Jk QnJlYWssIGNvbnN0IElubGluZUJveCogYm94KQogewpAQCAtMTYxNiwxMiArMTY2MCwxMCBAQCBz dGF0aWMgVmlzaWJsZVBvc2l0aW9uIGxlZnRXb3JkUG9zaXRpb25JCiAgICAgCiAgICAgCiAgICAg VmlzaWJsZVBvc2l0aW9uIHdvcmRCcmVhazsKLSAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRS KSB7Ci0gICAgICAgIGlmIChib3gtPmRpcmVjdGlvbigpID09IGJsb2NrRGlyZWN0aW9uKQotICAg ICAgICAgICAgd29yZEJyZWFrID0gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIHBy ZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwotICAgICAgICBlbHNlCi0gICAgICAgICAgICB3 b3JkQnJlYWsgPSBuZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9u Qm91bmRhcnkpOwotICAgIH0KKyAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0gTFRSKQorICAgICAg ICB3b3JkQnJlYWsgPSBib3gtPmlzTGVmdFRvUmlnaHREaXJlY3Rpb24oKSA/IHByZXZpb3VzQm91 bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KSA6IG5l eHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Cisg ICAgZWxzZQorICAgICAgICB3b3JkQnJlYWsgPSBib3gtPmlzTGVmdFRvUmlnaHREaXJlY3Rpb24o KSA/IHByZXZpb3VzV29yZEJvdW5kYXJ5QWZ0ZXJXb3JkKHZpc2libGVQb3NpdGlvbiwgYm94LCBv ZmZzZXQpIDogbmV4dFdvcmRCb3VuZGFyeUJlZm9yZVdvcmQodmlzaWJsZVBvc2l0aW9uLCBib3gs IG9mZnNldCk7CiAgICAgaWYgKHdvcmRCcmVhay5pc05vdE51bGwoKSAmJiBwb3NpdGlvbklzSW5C b3hCdXROb3RPbkJvdW5kYXJ5KHdvcmRCcmVhaywgYm94KSkKICAgICAgICAgcmV0dXJuIHdvcmRC cmVhazsKICAgICAKQEAgLTE2NTMsMTIgKzE2OTUsMTAgQEAgc3RhdGljIFZpc2libGVQb3NpdGlv biByaWdodFdvcmRQb3NpdGlvbgogICAgICAgICByZXR1cm4gcmlnaHRXb3JkQm91bmRhcnkocmln aHRJbmxpbmVCb3goYm94LCBibG9ja0RpcmVjdGlvbiksIGludmFsaWRPZmZzZXQsIGJsb2NrRGly ZWN0aW9uKTsKICAKICAgICBWaXNpYmxlUG9zaXRpb24gd29yZEJyZWFrOwotICAgIGlmIChibG9j a0RpcmVjdGlvbiA9PSBSVEwpIHsKLSAgICAgICAgaWYgKGJveC0+ZGlyZWN0aW9uKCkgPT0gYmxv Y2tEaXJlY3Rpb24pCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBwcmV2aW91c0JvdW5kYXJ5KHZp c2libGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgICAgIGVs c2UKLSAgICAgICAgICAgIHdvcmRCcmVhayA9IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24s IG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgfQorICAgIGlmIChibG9ja0RpcmVjdGlv biA9PSBMVFIpCisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+aXNMZWZ0VG9SaWdodERpcmVjdGlv bigpID8gbmV4dFdvcmRCb3VuZGFyeUJlZm9yZVdvcmQodmlzaWJsZVBvc2l0aW9uLCBib3gsIG9m ZnNldCkgOiBwcmV2aW91c1dvcmRCb3VuZGFyeUFmdGVyV29yZCh2aXNpYmxlUG9zaXRpb24sIGJv eCwgb2Zmc2V0KTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+aXNMZWZ0VG9S aWdodERpcmVjdGlvbigpID8gbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQ b3NpdGlvbkJvdW5kYXJ5KSA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2 aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKICAgICBpZiAod29yZEJyZWFrLmlzTm90TnVsbCgp ICYmIHBvc2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91bmRhcnkod29yZEJyZWFrLCBib3gpKQogICAg ICAgICByZXR1cm4gd29yZEJyZWFrOwogICAgIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9n Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gOTMzODApCisr KyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAor MjAxMS0wOC0xOCAgVmFuIExhbSAgPHZhbmxhbUBnb29nbGUuY29tPgorCisgICAgICAgIE1ha2Ug ZnVuY3Rpb25zIHRvIGZpbmQgd29yZCBib3VuZGFyaWVzIG1vcmUgZmxleGlibGUKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY1Mjc3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTXkgY2hhbmdlIGZpeGVkIHRo aXMgZmFpbHVyZS4KKworICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL21vdmUtYnktd29yZC12 aXN1YWxseS1zaW5nbGUtc3BhY2UtaW5saW5lLWVsZW1lbnQtZXhwZWN0ZWQudHh0OgorCiAyMDEx LTA4LTE4ICBUb255IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW2Nocm9t aXVtXSBGaXggcmVzdWx0cy4gIEp1c3QgY29weSBvdmVyIHRoZSBwbGF0Zm9ybSBpbmRlcGVuZGVu dCByZXN1bHRzLgpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13 b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZp c3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQJKHJldmlzaW9u IDkzMzc4KQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZp c3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQJKHdvcmtpbmcg Y29weSkKQEAgLTEzOSw3ICsxMzksNiBAQCBNb3ZlIGxlZnQgYnkgb25lIHdvcmQKICJBQkQgb3Bx IHJzdCBEU1UgIlsxNl0sICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxMl0gICBGQUlMIGV4cGVjdGVk ICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgMTVdCiAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTgsIDEy XSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KICJhYmMgdXZ3IEFB QSBkZWYgbG1uIlsxNywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJb IDE1XQotImFiYyB1dncgQUFBIGRlZiBsbW4iWzE2LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMg dXZ3IEFBQSBkZWYgbG1uIlsgMTVdCiAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTUsIDEyXSAgIEZB SUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyA4XQogImFiYyB1dncgQUFBIGRlZiBs bW4iWzE0LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0KICJh YmMgdXZ3IEFBQSBkZWYgbG1uIlsxMywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEg ZGVmIGxtbiJbIDhdCg== 104591 2011-08-19 16:36:56 -0700 2011-08-25 11:34:47 -0700 Revised (alternative) fix vanlam-internalapi text/plain 7528 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkzNDUxKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTEtMDgtMTkgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBNYWtlIGZ1bmN0aW9ucyB0byBmaW5kIHdv cmQgYm91bmRhcmllcyBtb3JlIGZsZXhpYmxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02NTI3NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZGVkIHR3byBmdW5jdGlvbnMgdG8gMSkgZmluZCBuZXh0IHdv cmQgYm91bmRhcnkgYmVmb3JlIHdvcmQgYW5kCisgICAgICAgIDIpIGZpbmQgcHJldmlvdXMgd29y ZCBib3VuZGFyeSBhZnRlciB3b3JkLiBUaGVzZSBmdW5jdGlvbnMgdXNlCisgICAgICAgIG5leHRC b3VuZGFyeSAoZmluZHMgbmV4dCB3b3JkIGJvdW5kYXJ5IGFmdGVyIHdvcmQpIGFuZCBwcmV2aW91 c0JvdW5kYXJ5CisgICAgICAgIChmaW5kcyBwcmV2aW91cyB3b3JkIGJyZWFrIGJlZm9yZSB3b3Jk KSB0byBmaW5kIHRoZSBkZXNpcmVkIHdvcmQKKyAgICAgICAgYm91bmRhcnkuIFVzZWQgdGhlc2Ug ZnVuY3Rpb25zIGluCisgICAgICAgIHJpZ2h0L0xlZnRXb3JkUG9zaXRpb25JZ25vcmluZ0VkaXRp bmdCb3VuZGFyeSB0byBhdm9pZCBjb2xsZWN0aW5nIHdvcmQKKyAgICAgICAgYm91bmRhcmllcyB3 aGVuIG1vdmluZyBieSB3b3JkIHdpdGhpbiBhIGJveC4KKworICAgICAgICAqIGVkaXRpbmcvdmlz aWJsZV91bml0cy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpuZXh0V29yZEJvdW5kYXJ5QmVmb3Jl V29yZCk6CisgICAgICAgIChXZWJDb3JlOjpwcmV2aW91c1dvcmRCb3VuZGFyeUFmdGVyV29yZCk6 CisgICAgICAgIChXZWJDb3JlOjpsZWZ0V29yZFBvc2l0aW9uSWdub3JpbmdFZGl0aW5nQm91bmRh cnkpOgorICAgICAgICAoV2ViQ29yZTo6cmlnaHRXb3JkUG9zaXRpb25JZ25vcmluZ0VkaXRpbmdC b3VuZGFyeSk6CisKIDIwMTEtMDgtMTkgIEJldGggRGFraW4gIDxiZGFraW5AYXBwbGUuY29tPgog CiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NjU5MApJ bmRleDogU291cmNlL1dlYkNvcmUvZWRpdGluZy92aXNpYmxlX3VuaXRzLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvV2ViQ29yZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwCShyZXZpc2lvbiA5 MzQ0OCkKKysrIFNvdXJjZS9XZWJDb3JlL2VkaXRpbmcvdmlzaWJsZV91bml0cy5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTE1ODcsNiArMTU4Nyw1MCBAQCBzdGF0aWMgVmlzaWJsZVBvc2l0aW9uIHJp Z2h0V29yZEJvdW5kYXJ5CiAgICAgfQogICAgIHJldHVybiBWaXNpYmxlUG9zaXRpb24oKTsKIH0K Kworc3RhdGljIFZpc2libGVQb3NpdGlvbiBuZXh0V29yZEJvdW5kYXJ5QmVmb3JlV29yZChWaXNp YmxlUG9zaXRpb24gc3RhcnRpbmdQb3NpdGlvbiwgSW5saW5lQm94KiBzdGFydGluZ0JveCwgaW50 IHN0YXJ0aW5nT2Zmc2V0KQoreworICAgIFZpc2libGVQb3NpdGlvbiBuZXh0ID0gbmV4dEJvdW5k YXJ5KHN0YXJ0aW5nUG9zaXRpb24sIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7CisgICAgaWYg KG5leHQgPT0gc3RhcnRpbmdQb3NpdGlvbikKKyAgICAgICAgcmV0dXJuIHN0YXJ0aW5nUG9zaXRp b247CisgICAgCisgICAgSW5saW5lQm94KiBjdXJyZW50Qm94OworICAgIGludCBjdXJyZW50T2Zm c2V0OworICAgIFZpc2libGVQb3NpdGlvbiBuZXh0UHJldiA9IHByZXZpb3VzQm91bmRhcnkobmV4 dCwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7CisgICAgbmV4dFByZXYuZ2V0SW5saW5l Qm94QW5kT2Zmc2V0KGN1cnJlbnRCb3gsIGN1cnJlbnRPZmZzZXQpOworICAgIGlmIChjdXJyZW50 Qm94ID09IHN0YXJ0aW5nQm94ICYmIGN1cnJlbnRPZmZzZXQgPiBzdGFydGluZ09mZnNldCkKKyAg ICAgICAgcmV0dXJuIG5leHRQcmV2OworICAgIAorICAgIFZpc2libGVQb3NpdGlvbiBuZXh0TmV4 dCA9IG5leHRCb3VuZGFyeShuZXh0LCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIGlm IChuZXh0ID09IG5leHROZXh0KQorICAgICAgICByZXR1cm4gVmlzaWJsZVBvc2l0aW9uKCk7Cisg ICAgCisgICAgVmlzaWJsZVBvc2l0aW9uIG5leHROZXh0UHJldiA9IHByZXZpb3VzQm91bmRhcnko bmV4dE5leHQsIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIG5leHROZXh0UHJl di5nZXRJbmxpbmVCb3hBbmRPZmZzZXQoY3VycmVudEJveCwgY3VycmVudE9mZnNldCk7CisgICAg cmV0dXJuIGN1cnJlbnRCb3ggPT0gc3RhcnRpbmdCb3ggJiYgY3VycmVudE9mZnNldCA+IHN0YXJ0 aW5nT2Zmc2V0ID8gbmV4dE5leHRQcmV2IDogVmlzaWJsZVBvc2l0aW9uKCk7Cit9CisKK3N0YXRp YyBWaXNpYmxlUG9zaXRpb24gcHJldmlvdXNXb3JkQm91bmRhcnlBZnRlcldvcmQoVmlzaWJsZVBv c2l0aW9uIHN0YXJ0aW5nUG9zaXRpb24sIElubGluZUJveCogc3RhcnRpbmdCb3gsIGludCBzdGFy dGluZ09mZnNldCkKK3sKKyAgICBWaXNpYmxlUG9zaXRpb24gcHJldiA9IHByZXZpb3VzQm91bmRh cnkoc3RhcnRpbmdQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7CisgICAg aWYgKHByZXYgPT0gc3RhcnRpbmdQb3NpdGlvbikKKyAgICAgICAgcmV0dXJuIHN0YXJ0aW5nUG9z aXRpb247CisgICAgCisgICAgSW5saW5lQm94KiBjdXJyZW50Qm94OworICAgIGludCBjdXJyZW50 T2Zmc2V0OworICAgIFZpc2libGVQb3NpdGlvbiBwcmV2TmV4dCA9IG5leHRCb3VuZGFyeShwcmV2 LCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIHByZXZOZXh0LmdldElubGluZUJveEFu ZE9mZnNldChjdXJyZW50Qm94LCBjdXJyZW50T2Zmc2V0KTsKKyAgICBpZiAoY3VycmVudEJveCA9 PSBzdGFydGluZ0JveCAmJiBjdXJyZW50T2Zmc2V0IDwgc3RhcnRpbmdPZmZzZXQpCisgICAgICAg IHJldHVybiBwcmV2TmV4dDsKKyAgICAgICAgCisgICAgVmlzaWJsZVBvc2l0aW9uIHByZXZQcmV2 ID0gcHJldmlvdXNCb3VuZGFyeShwcmV2LCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsK KyAgICBpZiAocHJldiA9PSBwcmV2UHJldikKKyAgICAgICAgcmV0dXJuIFZpc2libGVQb3NpdGlv bigpOworICAgIAorICAgIFZpc2libGVQb3NpdGlvbiBwcmV2UHJldk5leHQgPSBuZXh0Qm91bmRh cnkocHJldlByZXYsIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7CisgICAgcHJldlByZXZOZXh0 LmdldElubGluZUJveEFuZE9mZnNldChjdXJyZW50Qm94LCBjdXJyZW50T2Zmc2V0KTsKKyAgICBy ZXR1cm4gY3VycmVudEJveCA9PSBzdGFydGluZ0JveCAmJiBjdXJyZW50T2Zmc2V0IDwgc3RhcnRp bmdPZmZzZXQgPyBwcmV2UHJldk5leHQgOiBWaXNpYmxlUG9zaXRpb24oKTsKK30KICAgICAKIHN0 YXRpYyBib29sIHBvc2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91bmRhcnkoY29uc3QgVmlzaWJsZVBv c2l0aW9uJiB3b3JkQnJlYWssIGNvbnN0IElubGluZUJveCogYm94KQogewpAQCAtMTYxNiwxMiAr MTY2MCwxMCBAQCBzdGF0aWMgVmlzaWJsZVBvc2l0aW9uIGxlZnRXb3JkUG9zaXRpb25JCiAgICAg CiAgICAgCiAgICAgVmlzaWJsZVBvc2l0aW9uIHdvcmRCcmVhazsKLSAgICBpZiAoYmxvY2tEaXJl Y3Rpb24gPT0gTFRSKSB7Ci0gICAgICAgIGlmIChib3gtPmRpcmVjdGlvbigpID09IGJsb2NrRGly ZWN0aW9uKQotICAgICAgICAgICAgd29yZEJyZWFrID0gcHJldmlvdXNCb3VuZGFyeSh2aXNpYmxl UG9zaXRpb24sIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOwotICAgICAgICBlbHNlCi0g ICAgICAgICAgICB3b3JkQnJlYWsgPSBuZXh0Qm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBuZXh0 V29yZFBvc2l0aW9uQm91bmRhcnkpOwotICAgIH0KKyAgICBpZiAoYmxvY2tEaXJlY3Rpb24gPT0g TFRSKQorICAgICAgICB3b3JkQnJlYWsgPSBib3gtPmlzTGVmdFRvUmlnaHREaXJlY3Rpb24oKSA/ IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJv dW5kYXJ5KSA6IG5leHRCb3VuZGFyeSh2aXNpYmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRpb25C b3VuZGFyeSk7CisgICAgZWxzZQorICAgICAgICB3b3JkQnJlYWsgPSBib3gtPmlzTGVmdFRvUmln aHREaXJlY3Rpb24oKSA/IHByZXZpb3VzV29yZEJvdW5kYXJ5QWZ0ZXJXb3JkKHZpc2libGVQb3Np dGlvbiwgYm94LCBvZmZzZXQpIDogbmV4dFdvcmRCb3VuZGFyeUJlZm9yZVdvcmQodmlzaWJsZVBv c2l0aW9uLCBib3gsIG9mZnNldCk7CiAgICAgaWYgKHdvcmRCcmVhay5pc05vdE51bGwoKSAmJiBw b3NpdGlvbklzSW5Cb3hCdXROb3RPbkJvdW5kYXJ5KHdvcmRCcmVhaywgYm94KSkKICAgICAgICAg cmV0dXJuIHdvcmRCcmVhazsKICAgICAKQEAgLTE2NTMsMTIgKzE2OTUsMTAgQEAgc3RhdGljIFZp c2libGVQb3NpdGlvbiByaWdodFdvcmRQb3NpdGlvbgogICAgICAgICByZXR1cm4gcmlnaHRXb3Jk Qm91bmRhcnkocmlnaHRJbmxpbmVCb3goYm94LCBibG9ja0RpcmVjdGlvbiksIGludmFsaWRPZmZz ZXQsIGJsb2NrRGlyZWN0aW9uKTsKICAKICAgICBWaXNpYmxlUG9zaXRpb24gd29yZEJyZWFrOwot ICAgIGlmIChibG9ja0RpcmVjdGlvbiA9PSBSVEwpIHsKLSAgICAgICAgaWYgKGJveC0+ZGlyZWN0 aW9uKCkgPT0gYmxvY2tEaXJlY3Rpb24pCi0gICAgICAgICAgICB3b3JkQnJlYWsgPSBwcmV2aW91 c0JvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSk7 Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgIHdvcmRCcmVhayA9IG5leHRCb3VuZGFyeSh2aXNp YmxlUG9zaXRpb24sIG5leHRXb3JkUG9zaXRpb25Cb3VuZGFyeSk7Ci0gICAgfQorICAgIGlmIChi bG9ja0RpcmVjdGlvbiA9PSBMVFIpCisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+aXNMZWZ0VG9S aWdodERpcmVjdGlvbigpID8gbmV4dFdvcmRCb3VuZGFyeUJlZm9yZVdvcmQodmlzaWJsZVBvc2l0 aW9uLCBib3gsIG9mZnNldCkgOiBwcmV2aW91c1dvcmRCb3VuZGFyeUFmdGVyV29yZCh2aXNpYmxl UG9zaXRpb24sIGJveCwgb2Zmc2V0KTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVhayA9IGJv eC0+aXNMZWZ0VG9SaWdodERpcmVjdGlvbigpID8gbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlv biwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KSA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBv c2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKICAgICBpZiAod29yZEJyZWFr LmlzTm90TnVsbCgpICYmIHBvc2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91bmRhcnkod29yZEJyZWFr LCBib3gpKQogICAgICAgICByZXR1cm4gd29yZEJyZWFrOwogICAgIApJbmRleDogTGF5b3V0VGVz dHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNp b24gOTM0NTEpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEs MyArMSwxNCBAQAorMjAxMS0wOC0xOSAgVmFuIExhbSAgPHZhbmxhbUBnb29nbGUuY29tPgorCisg ICAgICAgIE1ha2UgZnVuY3Rpb25zIHRvIGZpbmQgd29yZCBib3VuZGFyaWVzIG1vcmUgZmxleGli bGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY1Mjc3 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTXkgY2hh bmdlIGZpeGVkIHRoaXMgZmFpbHVyZS4KKworICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL21v dmUtYnktd29yZC12aXN1YWxseS1zaW5nbGUtc3BhY2UtaW5saW5lLWVsZW1lbnQtZXhwZWN0ZWQu dHh0OgorCiAyMDExLTA4LTE5ICBUb255IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CiAKICAg ICAgICAgW2Nocm9taXVtXSBDbGVhbnVwIHNvbWUgb2xkIHBsdWdpbiB0ZXN0cy4gIFJlYmFzZSBw bHVnaW4tamF2YXNjcmlwdC1hY2Nlc3MuaHRtbApJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9z ZWxlY3Rpb24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVu dC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rp b24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBl Y3RlZC50eHQJKHJldmlzaW9uIDkzNDQ4KQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rp b24vbW92ZS1ieS13b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBl Y3RlZC50eHQJKHdvcmtpbmcgY29weSkKQEAgLTEzNyw5ICsxMzcsNiBAQCBUZXN0IDIwLCBSVEw6 CiBNb3ZlIGxlZnQgYnkgb25lIHdvcmQKICJBQkQgb3BxIHJzdCBEU1UgIlswLCA0LCA3LCAxMiwg MTZdLCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTIsIDgsIDcsIDNdLCAiQUJXIGhpaiB4eXogRlhY Ils0LCA3LCAxMiwgMTVdICAgIEZBSUwgZXhwZWN0ZWQ6IFsiQUJEIG9wcSByc3QgRFNVICJbIDAs ICA0LCAgNywgIDEyLCAgMTYsIF0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1LCAgOCwgIDcsICAz LCBdIkFCVyBoaWogeHl6IEZYWCJbIDQsICA3LCAgMTIsICAxNV0KICJBQkQgb3BxIHJzdCBEU1Ug IlsxNl0sICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3 IEFBQSBkZWYgbG1uIlsgMTVdCi0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTgsIDEyXSAgIEZBSUwg ZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KLSJhYmMgdXZ3IEFBQSBkZWYgbG1u IlsxNywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1XQotImFi YyB1dncgQUFBIGRlZiBsbW4iWzE2LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBk ZWYgbG1uIlsgMTVdCiAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTUsIDEyXSAgIEZBSUwgZXhwZWN0 ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyA4XQogImFiYyB1dncgQUFBIGRlZiBsbW4iWzE0LCAx Ml0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0KICJhYmMgdXZ3IEFB QSBkZWYgbG1uIlsxMywgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJb IDhdCg== 105225 2011-08-25 11:34:47 -0700 2012-04-21 18:59:18 -0700 Revised (alternative) fix vanlam-internalapi text/plain 8859 vanlam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkzNzk3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTEtMDgtMjUgIFZhbiBMYW0g IDx2YW5sYW1AZ29vZ2xlLmNvbT4KKworICAgICAgICBNYWtlIGZ1bmN0aW9ucyB0byBmaW5kIHdv cmQgYm91bmRhcmllcyBtb3JlIGZsZXhpYmxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02NTI3NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZGVkIHR3byBmdW5jdGlvbnMgdG8gMSkgZmluZCBuZXh0IHdv cmQgYm91bmRhcnkgYmVmb3JlIHdvcmQgYW5kCisgICAgICAgIDIpIGZpbmQgcHJldmlvdXMgd29y ZCBib3VuZGFyeSBhZnRlciB3b3JkLiBUaGVzZSBmdW5jdGlvbnMgdXNlCisgICAgICAgIG5leHRC b3VuZGFyeSAoZmluZHMgbmV4dCB3b3JkIGJvdW5kYXJ5IGFmdGVyIHdvcmQpIGFuZCBwcmV2aW91 c0JvdW5kYXJ5CisgICAgICAgIChmaW5kcyBwcmV2aW91cyB3b3JkIGJvdW5kYXJ5IGJlZm9yZSB3 b3JkKSB0byBmaW5kIHRoZSBkZXNpcmVkIHdvcmQKKyAgICAgICAgYm91bmRhcnkuIFVzZWQgdGhl c2UgZnVuY3Rpb25zIGluCisgICAgICAgIHJpZ2h0L0xlZnRXb3JkUG9zaXRpb25JZ25vcmluZ0Vk aXRpbmdCb3VuZGFyeSB0byBhdm9pZCBjb2xsZWN0aW5nIHdvcmQKKyAgICAgICAgYm91bmRhcmll cyB3aGVuIG1vdmluZyBieSB3b3JkIHdpdGhpbiBhIGJveC4KKworICAgICAgICAqIGVkaXRpbmcv dmlzaWJsZV91bml0cy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpuZXh0V29yZEJvdW5kYXJ5QmVm b3JlV29yZCk6CisgICAgICAgIChXZWJDb3JlOjpwcmV2aW91c1dvcmRCb3VuZGFyeUFmdGVyV29y ZCk6CisgICAgICAgIChXZWJDb3JlOjpsZWZ0V29yZFBvc2l0aW9uSWdub3JpbmdFZGl0aW5nQm91 bmRhcnkpOgorICAgICAgICAoV2ViQ29yZTo6cmlnaHRXb3JkUG9zaXRpb25JZ25vcmluZ0VkaXRp bmdCb3VuZGFyeSk6CisKIDIwMTEtMDgtMjQgIEFkcmllbm5lIFdhbGtlciAgPGVubmVAZ29vZ2xl LmNvbT4KIAogICAgICAgICBbY2hyb21pdW1dIFVwZGF0ZSBWaWRlb0xheWVyQ2hyb21pdW0gdG8g bm90IGFjY2VzcyBHQzNEIG9uIHRoZSBtYWluIHRocmVhZApJbmRleDogU291cmNlL1dlYkNvcmUv ZWRpdGluZy92aXNpYmxlX3VuaXRzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwCShyZXZpc2lvbiA5Mzc5NykKKysrIFNvdXJjZS9XZWJD b3JlL2VkaXRpbmcvdmlzaWJsZV91bml0cy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE1ODcsNiAr MTU4Nyw1OCBAQCBzdGF0aWMgVmlzaWJsZVBvc2l0aW9uIHJpZ2h0V29yZEJvdW5kYXJ5CiAgICAg fQogICAgIHJldHVybiBWaXNpYmxlUG9zaXRpb24oKTsKIH0KKworc3RhdGljIFZpc2libGVQb3Np dGlvbiBuZXh0V29yZEJvdW5kYXJ5QmVmb3JlV29yZChWaXNpYmxlUG9zaXRpb24gc3RhcnRpbmdQ b3NpdGlvbikKK3sKKyAgICBJbmxpbmVCb3gqIHN0YXJ0aW5nQm94OworICAgIGludCBzdGFydGlu Z09mZnNldDsKKyAgICBzdGFydGluZ1Bvc2l0aW9uLmdldElubGluZUJveEFuZE9mZnNldChzdGFy dGluZ0JveCwgc3RhcnRpbmdPZmZzZXQpOworCisgICAgVmlzaWJsZVBvc2l0aW9uIG5leHRCb3Vu ZGFyeUFmdGVyV29yZCA9IG5leHRCb3VuZGFyeShzdGFydGluZ1Bvc2l0aW9uLCBuZXh0V29yZFBv c2l0aW9uQm91bmRhcnkpOworICAgIGlmIChuZXh0Qm91bmRhcnlBZnRlcldvcmQgPT0gc3RhcnRp bmdQb3NpdGlvbikKKyAgICAgICAgcmV0dXJuIHN0YXJ0aW5nUG9zaXRpb247CisgICAgCisgICAg SW5saW5lQm94KiBjdXJyZW50Qm94OworICAgIGludCBjdXJyZW50T2Zmc2V0OworICAgIFZpc2li bGVQb3NpdGlvbiBwcmV2aW91c0JvdW5kYXJ5QmVmb3JlV29yZEFmdGVyTmV4dEJvdW5kYXJ5QWZ0 ZXJXb3JkID0gcHJldmlvdXNCb3VuZGFyeShuZXh0Qm91bmRhcnlBZnRlcldvcmQsIHByZXZpb3Vz V29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIHByZXZpb3VzQm91bmRhcnlCZWZvcmVXb3JkQWZ0 ZXJOZXh0Qm91bmRhcnlBZnRlcldvcmQuZ2V0SW5saW5lQm94QW5kT2Zmc2V0KGN1cnJlbnRCb3gs IGN1cnJlbnRPZmZzZXQpOworICAgIGlmIChjdXJyZW50Qm94ID09IHN0YXJ0aW5nQm94ICYmIGN1 cnJlbnRPZmZzZXQgPiBzdGFydGluZ09mZnNldCkKKyAgICAgICAgcmV0dXJuIHByZXZpb3VzQm91 bmRhcnlCZWZvcmVXb3JkQWZ0ZXJOZXh0Qm91bmRhcnlBZnRlcldvcmQ7CisgICAgCisgICAgVmlz aWJsZVBvc2l0aW9uIG5leHRCb3VuZGFyeUFmdGVyV29yZEFmdGVyTmV4dEJvdW5kYXJ5QWZ0ZXJX b3JkID0gbmV4dEJvdW5kYXJ5KG5leHRCb3VuZGFyeUFmdGVyV29yZCwgbmV4dFdvcmRQb3NpdGlv bkJvdW5kYXJ5KTsKKyAgICBpZiAobmV4dEJvdW5kYXJ5QWZ0ZXJXb3JkID09IG5leHRCb3VuZGFy eUFmdGVyV29yZEFmdGVyTmV4dEJvdW5kYXJ5QWZ0ZXJXb3JkKQorICAgICAgICByZXR1cm4gVmlz aWJsZVBvc2l0aW9uKCk7CisgICAgCisgICAgVmlzaWJsZVBvc2l0aW9uIG5leHRCb3VuZGFyeUJl Zm9yZVdvcmQgPSBwcmV2aW91c0JvdW5kYXJ5KG5leHRCb3VuZGFyeUFmdGVyV29yZEFmdGVyTmV4 dEJvdW5kYXJ5QWZ0ZXJXb3JkLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKKyAgICBu ZXh0Qm91bmRhcnlCZWZvcmVXb3JkLmdldElubGluZUJveEFuZE9mZnNldChjdXJyZW50Qm94LCBj dXJyZW50T2Zmc2V0KTsKKyAgICByZXR1cm4gY3VycmVudEJveCA9PSBzdGFydGluZ0JveCAmJiBj dXJyZW50T2Zmc2V0ID4gc3RhcnRpbmdPZmZzZXQgPyBuZXh0Qm91bmRhcnlCZWZvcmVXb3JkIDog VmlzaWJsZVBvc2l0aW9uKCk7Cit9CisKK3N0YXRpYyBWaXNpYmxlUG9zaXRpb24gcHJldmlvdXNX b3JkQm91bmRhcnlBZnRlcldvcmQoVmlzaWJsZVBvc2l0aW9uIHN0YXJ0aW5nUG9zaXRpb24pCit7 CisgICAgSW5saW5lQm94KiBzdGFydGluZ0JveDsKKyAgICBpbnQgc3RhcnRpbmdPZmZzZXQ7Cisg ICAgc3RhcnRpbmdQb3NpdGlvbi5nZXRJbmxpbmVCb3hBbmRPZmZzZXQoc3RhcnRpbmdCb3gsIHN0 YXJ0aW5nT2Zmc2V0KTsKKworICAgIFZpc2libGVQb3NpdGlvbiBwcmV2aW91c0JvdW5kYXJ5QmVm b3JlV29yZCA9IHByZXZpb3VzQm91bmRhcnkoc3RhcnRpbmdQb3NpdGlvbiwgcHJldmlvdXNXb3Jk UG9zaXRpb25Cb3VuZGFyeSk7CisgICAgaWYgKHByZXZpb3VzQm91bmRhcnlCZWZvcmVXb3JkID09 IHN0YXJ0aW5nUG9zaXRpb24pCisgICAgICAgIHJldHVybiBzdGFydGluZ1Bvc2l0aW9uOworICAg IAorICAgIElubGluZUJveCogY3VycmVudEJveDsKKyAgICBpbnQgY3VycmVudE9mZnNldDsKKyAg ICBWaXNpYmxlUG9zaXRpb24gbmV4dEJvdW5kYXJ5QWZ0ZXJXb3JkQWZ0ZXJQcmV2aW91c0JvdW5k YXJ5QmVmb3JlV29yZCA9IG5leHRCb3VuZGFyeShwcmV2aW91c0JvdW5kYXJ5QmVmb3JlV29yZCwg bmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKKyAgICBuZXh0Qm91bmRhcnlBZnRlcldvcmRBZnRl clByZXZpb3VzQm91bmRhcnlCZWZvcmVXb3JkLmdldElubGluZUJveEFuZE9mZnNldChjdXJyZW50 Qm94LCBjdXJyZW50T2Zmc2V0KTsKKyAgICBpZiAoY3VycmVudEJveCA9PSBzdGFydGluZ0JveCAm JiBjdXJyZW50T2Zmc2V0IDwgc3RhcnRpbmdPZmZzZXQpCisgICAgICAgIHJldHVybiBuZXh0Qm91 bmRhcnlBZnRlcldvcmRBZnRlclByZXZpb3VzQm91bmRhcnlCZWZvcmVXb3JkOworICAgICAgICAK KyAgICBWaXNpYmxlUG9zaXRpb24gcHJldmlvdXNCb3VuZGFyeUJlZm9yZVdvcmRCZWZvcmVQcmV2 aW91c0JvdW5kYXJ5QmVmb3JlV29yZCA9IHByZXZpb3VzQm91bmRhcnkocHJldmlvdXNCb3VuZGFy eUJlZm9yZVdvcmQsIHByZXZpb3VzV29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIGlmIChwcmV2 aW91c0JvdW5kYXJ5QmVmb3JlV29yZCA9PSBwcmV2aW91c0JvdW5kYXJ5QmVmb3JlV29yZEJlZm9y ZVByZXZpb3VzQm91bmRhcnlCZWZvcmVXb3JkKQorICAgICAgICByZXR1cm4gVmlzaWJsZVBvc2l0 aW9uKCk7CisgICAgCisgICAgVmlzaWJsZVBvc2l0aW9uIHByZXZpb3VzQm91bmRhcnlBZnRlcldv cmQgPSBuZXh0Qm91bmRhcnkocHJldmlvdXNCb3VuZGFyeUJlZm9yZVdvcmRCZWZvcmVQcmV2aW91 c0JvdW5kYXJ5QmVmb3JlV29yZCwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKKyAgICBwcmV2 aW91c0JvdW5kYXJ5QWZ0ZXJXb3JkLmdldElubGluZUJveEFuZE9mZnNldChjdXJyZW50Qm94LCBj dXJyZW50T2Zmc2V0KTsKKyAgICByZXR1cm4gY3VycmVudEJveCA9PSBzdGFydGluZ0JveCAmJiBj dXJyZW50T2Zmc2V0IDwgc3RhcnRpbmdPZmZzZXQgPyBwcmV2aW91c0JvdW5kYXJ5QWZ0ZXJXb3Jk IDogVmlzaWJsZVBvc2l0aW9uKCk7Cit9CiAgICAgCiBzdGF0aWMgYm9vbCBwb3NpdGlvbklzSW5C b3hCdXROb3RPbkJvdW5kYXJ5KGNvbnN0IFZpc2libGVQb3NpdGlvbiYgd29yZEJyZWFrLCBjb25z dCBJbmxpbmVCb3gqIGJveCkKIHsKQEAgLTE2MTYsMTIgKzE2NjgsMTAgQEAgc3RhdGljIFZpc2li bGVQb3NpdGlvbiBsZWZ0V29yZFBvc2l0aW9uSQogICAgIAogICAgIAogICAgIFZpc2libGVQb3Np dGlvbiB3b3JkQnJlYWs7Ci0gICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IExUUikgewotICAgICAg ICBpZiAoYm94LT5kaXJlY3Rpb24oKSA9PSBibG9ja0RpcmVjdGlvbikKLSAgICAgICAgICAgIHdv cmRCcmVhayA9IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQ b3NpdGlvbkJvdW5kYXJ5KTsKLSAgICAgICAgZWxzZQotICAgICAgICAgICAgd29yZEJyZWFrID0g bmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsK LSAgICB9CisgICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IExUUikKKyAgICAgICAgd29yZEJyZWFr ID0gYm94LT5pc0xlZnRUb1JpZ2h0RGlyZWN0aW9uKCkgPyBwcmV2aW91c0JvdW5kYXJ5KHZpc2li bGVQb3NpdGlvbiwgcHJldmlvdXNXb3JkUG9zaXRpb25Cb3VuZGFyeSkgOiBuZXh0Qm91bmRhcnko dmlzaWJsZVBvc2l0aW9uLCBuZXh0V29yZFBvc2l0aW9uQm91bmRhcnkpOworICAgIGVsc2UKKyAg ICAgICAgd29yZEJyZWFrID0gYm94LT5pc0xlZnRUb1JpZ2h0RGlyZWN0aW9uKCkgPyBwcmV2aW91 c1dvcmRCb3VuZGFyeUFmdGVyV29yZCh2aXNpYmxlUG9zaXRpb24pIDogbmV4dFdvcmRCb3VuZGFy eUJlZm9yZVdvcmQodmlzaWJsZVBvc2l0aW9uKTsKICAgICBpZiAod29yZEJyZWFrLmlzTm90TnVs bCgpICYmIHBvc2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91bmRhcnkod29yZEJyZWFrLCBib3gpKQog ICAgICAgICByZXR1cm4gd29yZEJyZWFrOwogICAgIApAQCAtMTY1MywxMiArMTcwMywxMCBAQCBz dGF0aWMgVmlzaWJsZVBvc2l0aW9uIHJpZ2h0V29yZFBvc2l0aW9uCiAgICAgICAgIHJldHVybiBy aWdodFdvcmRCb3VuZGFyeShyaWdodElubGluZUJveChib3gsIGJsb2NrRGlyZWN0aW9uKSwgaW52 YWxpZE9mZnNldCwgYmxvY2tEaXJlY3Rpb24pOwogIAogICAgIFZpc2libGVQb3NpdGlvbiB3b3Jk QnJlYWs7Ci0gICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IFJUTCkgewotICAgICAgICBpZiAoYm94 LT5kaXJlY3Rpb24oKSA9PSBibG9ja0RpcmVjdGlvbikKLSAgICAgICAgICAgIHdvcmRCcmVhayA9 IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dvcmRQb3NpdGlvbkJv dW5kYXJ5KTsKLSAgICAgICAgZWxzZQotICAgICAgICAgICAgd29yZEJyZWFrID0gbmV4dEJvdW5k YXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlvbkJvdW5kYXJ5KTsKLSAgICB9Cisg ICAgaWYgKGJsb2NrRGlyZWN0aW9uID09IExUUikKKyAgICAgICAgd29yZEJyZWFrID0gYm94LT5p c0xlZnRUb1JpZ2h0RGlyZWN0aW9uKCkgPyBuZXh0V29yZEJvdW5kYXJ5QmVmb3JlV29yZCh2aXNp YmxlUG9zaXRpb24pIDogcHJldmlvdXNXb3JkQm91bmRhcnlBZnRlcldvcmQodmlzaWJsZVBvc2l0 aW9uKTsKKyAgICBlbHNlCisgICAgICAgIHdvcmRCcmVhayA9IGJveC0+aXNMZWZ0VG9SaWdodERp cmVjdGlvbigpID8gbmV4dEJvdW5kYXJ5KHZpc2libGVQb3NpdGlvbiwgbmV4dFdvcmRQb3NpdGlv bkJvdW5kYXJ5KSA6IHByZXZpb3VzQm91bmRhcnkodmlzaWJsZVBvc2l0aW9uLCBwcmV2aW91c1dv cmRQb3NpdGlvbkJvdW5kYXJ5KTsKICAgICBpZiAod29yZEJyZWFrLmlzTm90TnVsbCgpICYmIHBv c2l0aW9uSXNJbkJveEJ1dE5vdE9uQm91bmRhcnkod29yZEJyZWFrLCBib3gpKQogICAgICAgICBy ZXR1cm4gd29yZEJyZWFrOwogICAgIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gOTM3OTcpCisrKyBMYXlv dXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxOSBAQAorMjAxMS0w OC0yNSAgVmFuIExhbSAgPHZhbmxhbUBnb29nbGUuY29tPgorCisgICAgICAgIE1ha2UgZnVuY3Rp b25zIHRvIGZpbmQgd29yZCBib3VuZGFyaWVzIG1vcmUgZmxleGlibGUKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY1Mjc3CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTXkgY2hhbmdlIGZpeGVkIHRoaXMgZmFp bHVyZTsgdGhlIG9yaWdpbmFsIGZhaWx1cmUgd2FzIGJlY2F1c2UgYSB3b3JkCisgICAgICAgIGJy ZWFrIHRoYXQgc2hvdWxkbid0IGhhdmUgYmVlbiBjb2xsZWN0ZWQgd2FzIGNvbGxlY3RlZC4gU3Bl Y2lmaWNhbGx5CisgICAgICAgIHdoZW4gbW92aW5nIGxlZnQgYnkgd29yZCBpbiB0aGUgd29yZCBs bW4sIGNvbGxlY3RXb3JkQnJlYWtzSW5Cb3gKKyAgICAgICAgY29sbGVjdHMgd2hhdCBzZWVtcyB0 byBiZSB0aGUgd29yZCBicmVhayBhZnRlciBsbW4sIGJ1dCBhY3R1YWxseQorICAgICAgICBpcyB0 aGUgd29yZCBicmVhayBiZWZvcmUgZGVmLiBUaGUgbG9naWMgaW50cm9kdWNlZCBpbiB0aGlzIHBh dGNoCisgICAgICAgIGF2b2lkcyBjb2xsZWN0aW5nIGJveGVzIGluIG1vc3QgY2FzZXMgYW5kIGhh bmRsZXMgdGhpcyBjYXNlLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vbW92ZS1ieS13 b3JkLXZpc3VhbGx5LXNpbmdsZS1zcGFjZS1pbmxpbmUtZWxlbWVudC1leHBlY3RlZC50eHQ6CisK IDIwMTEtMDgtMjQgIFBldGVyIEthc3RpbmcgIDxwa2FzdGluZ0Bnb29nbGUuY29tPgogCiAgICAg ICAgIFtjaHJvbWl1bV0gU2V2ZXJhbCB0ZXN0IGV4cGVjdGF0aW9uIHVwZGF0ZXMuCkluZGV4OiBM YXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9tb3ZlLWJ5LXdvcmQtdmlzdWFsbHktc2luZ2xl LXNwYWNlLWlubGluZS1lbGVtZW50LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRU ZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9tb3ZlLWJ5LXdvcmQtdmlzdWFsbHktc2luZ2xlLXNwYWNl LWlubGluZS1lbGVtZW50LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gOTM3OTcpCisrKyBMYXlvdXRU ZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9tb3ZlLWJ5LXdvcmQtdmlzdWFsbHktc2luZ2xlLXNwYWNl LWlubGluZS1lbGVtZW50LWV4cGVjdGVkLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMTM3LDkgKzEz Nyw2IEBAIFRlc3QgMjAsIFJUTDoKIE1vdmUgbGVmdCBieSBvbmUgd29yZAogIkFCRCBvcHEgcnN0 IERTVSAiWzAsIDQsIDcsIDEyLCAxNl0sICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsxMiwgOCwgNywg M10sICJBQlcgaGlqIHh5eiBGWFgiWzQsIDcsIDEyLCAxNV0gICAgRkFJTCBleHBlY3RlZDogWyJB QkQgb3BxIHJzdCBEU1UgIlsgMCwgIDQsICA3LCAgMTIsICAxNiwgXSJhYmMgdXZ3IEFBQSBkZWYg bG1uIlsgMTUsICA4LCAgNywgIDMsIF0iQUJXIGhpaiB4eXogRlhYIlsgNCwgIDcsICAxMiwgIDE1 XQogIkFCRCBvcHEgcnN0IERTVSAiWzE2XSwgImFiYyB1dncgQUFBIGRlZiBsbW4iWzEyXSAgIEZB SUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KLSJhYmMgdXZ3IEFBQSBkZWYg bG1uIlsxOCwgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDE1XQot ImFiYyB1dncgQUFBIGRlZiBsbW4iWzE3LCAxMl0gICBGQUlMIGV4cGVjdGVkICJhYmMgdXZ3IEFB QSBkZWYgbG1uIlsgMTVdCi0iYWJjIHV2dyBBQUEgZGVmIGxtbiJbMTYsIDEyXSAgIEZBSUwgZXhw ZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBsbW4iWyAxNV0KICJhYmMgdXZ3IEFBQSBkZWYgbG1uIlsx NSwgMTJdICAgRkFJTCBleHBlY3RlZCAiYWJjIHV2dyBBQUEgZGVmIGxtbiJbIDhdCiAiYWJjIHV2 dyBBQUEgZGVmIGxtbiJbMTQsIDEyXSAgIEZBSUwgZXhwZWN0ZWQgImFiYyB1dncgQUFBIGRlZiBs bW4iWyA4XQogImFiYyB1dncgQUFBIGRlZiBsbW4iWzEzLCAxMl0gICBGQUlMIGV4cGVjdGVkICJh YmMgdXZ3IEFBQSBkZWYgbG1uIlsgOF0K