73454 2011-11-30 08:48:13 -0800 [chromium] When rendering goes idle, do not count that time against frame rate 2012-04-11 15:49:05 -0700 1 1 1 Unclassified WebKit WebKit Misc. 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 83703 1 nduca anicolao anicolao cc-bugs jamesr nduca simonjam webkit.review.bot oldest_to_newest 511783 0 nduca 2011-11-30 08:48:13 -0800 The CCHeadsUpDisplay currently computes FPS based on timestamps between CCLayerTreeHostImpl::present() calls. This is a decent approximation of frame rate when rendering is happening, but when there is no screen damage for a few seconds, we treat that as a very very long frame. This leads to bad frame rate measurements. We should fix this, somehow. Whoever picks this bug up, shout at me and we can brainstorm. 521196 1 119277 anicolao 2011-12-14 12:41:26 -0800 Created attachment 119277 Patch 521213 2 119277 jamesr 2011-12-14 12:55:21 -0800 Comment on attachment 119277 Patch This looks like something Nat should review. 521233 3 119277 nduca 2011-12-14 13:19:36 -0800 Comment on attachment 119277 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=119277&action=review Thanks so much for poking at this! A bunch of food for thought, let me know how you want to proceed. I'll get the patch to unofficial LGTM stage and then JamesR will nail you to the wall with a strict review. ;) > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:88 > + m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 1)]; /me can't remember, -1 % N is still -1, right? Point being, wraparound might be wrong, if my memory is right at least. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:89 > + m_badFrame[FRAME_INDEX(m_currentFrameNumber)] = (delta < 1.0 / 70) || (delta > 5.0 / 60); When we have vsync turned off, eg --disable-gpu-vsync, this would mean frame rate peaks at 70fps, right? We're going to be getting rid of these fast frames over time, so I'd rather get correct numbers for very fast framerates... thoughts? > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:204 > // Filter the frame times to avoid spikes. Might want to explain the filtering algorithm here sort of how you did in the changelog. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:210 > + // don't filter the time if this is the first frame after a period of no drawing; pretend this don't -> Don't. Complete sentences for comments throughout the file. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:216 > + if (secForThirdLastFrame > 0.5 || m_averageFPSCount > 60*2) { Should we pull the various constants to kBlahBlahBlah? What is this check adding over the m_badFrame[FRAME_NUMBER(m_cur - 3)] check? I'm sure its something, I just can't figure out what it is in my head. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:230 > + Hey, crazy question? Its probably ~100 frames history that we keep right? That should be like stupid fast to compute an average for... we only run this when they ask for it, so paying a few usec for this is totally fine by me. The reason I ask is because this code is getting a bit hard to read. Not your fault... its just we're doing a few different things here. Thats not bad, but suppose down the road we decide instead of stddev, we need a metric like "number of frames that we dropped." At that point, I'd love it if the code was really easy to hack on. If we just go to "compute everything every time from a frame history", does the code get cleaner? I personally like having less state and state overlap in that case.... > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:233 > + String text(String::format("FPS: XXX.X (XX.X XXX.XXX)")); Is there a way to re-use the format string here? > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:236 > + text = String::format("FPS: %03.01f (%02.01f %03.03f)", 1.0 / m_filteredFrameTime, m_averageFPS, stdDeviation); I'm not sure the average person from the street is going to understand the variance vs average, much less stddev. I also have thrown around the idea of reporting late "% frames we dropped" instead of variance at all, since stddev is really funky for fps (2ms variance on 60fps is 60 fps+/- something strange). What if we report out filtered fps and let people see variance from the graph? I'm all for leaving calculations in place because we've had requests for a follow-on patch that exposes frame rate metrics to javascript for people who have test harnesses/etc. Within that context, I imagine we could expose a few different values... > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:278 > + if (!m_badFrame[j]) { Might want to explain what this block of code does. It kind of breaks my head > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:290 > + if (minimumOutlier != noOutlierFound) { What's the value add of showing the outlier? 521293 4 119277 anicolao 2011-12-14 14:28:35 -0800 Comment on attachment 119277 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=119277&action=review >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:88 >> + m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 1)]; > > /me can't remember, -1 % N is still -1, right? Point being, wraparound might be wrong, if my memory is right at least. You're absolutely right. Originally I'd had the macro as ((frame) + kBegin)%kBegin but I was looking at that thinking this extra kBegin doesn't look meaningful and I broke it just prior to review while going through my own diff. How embarrassing :( I'll fix the macro again. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:89 >> + m_badFrame[FRAME_INDEX(m_currentFrameNumber)] = (delta < 1.0 / 70) || (delta > 5.0 / 60); > > When we have vsync turned off, eg --disable-gpu-vsync, this would mean frame rate peaks at 70fps, right? We're going to be getting rid of these fast frames over time, so I'd rather get correct numbers for very fast framerates... thoughts? No, the effect of this will be that if you have --disable-gpu-vsync the FPS meter will refuse to show you data because the data are wrong. I preferred to have an empty graph rather than show the user false frame rates - we are painting frames the user will never see in this case. In addition this filtering is ultimately what detects the spike due to startup after a pause, since the early swapbuffers calls are nonblocking and all get assigned silly high frame rates (like 110FPS). How critical is seeing the bad data for the no vsync case? I'm open to suggestions. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:204 >> // Filter the frame times to avoid spikes. > > Might want to explain the filtering algorithm here sort of how you did in the changelog. Happy to do so but this is the pre-existing code. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:210 >> + // don't filter the time if this is the first frame after a period of no drawing; pretend this > > don't -> Don't. > Complete sentences for comments throughout the file. Sorry will fix, not used to webkit style. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:216 >> + if (secForThirdLastFrame > 0.5 || m_averageFPSCount > 60*2) { > > Should we pull the various constants to kBlahBlahBlah? > > What is this check adding over the m_badFrame[FRAME_NUMBER(m_cur - 3)] check? I'm sure its something, I just can't figure out what it is in my head. Bad frames can occur within the sample. So if you stop doing anything and then you start to scroll, you'll get a few bad frames at the start of the sample, and m_badFrame lets you skip those so they don't mess up the average and standard deviation; while this check determines that since the third last frame was so very long (> 0.5s, or whatever threshold we choose) we should start a new set of samples for timing the animation. Deciding if something is a bad frame or not is a separate set of heuristics/constants than deciding how long a pause is needed to consider the sample data a new stream of frames for a new animation. The second half of the if is ensuring that we don't take samples longer than 2s; the assumption is that in a long running animation, you'd prefer to see problems with variance in a reasonably small window, whereas if you accumulated thousands of datapoints the outliers wouldn't be able to move the average of the variance and that would hide problems. So if you run something like poster circle the stats keep resetting and glitches impact the variance quite a bit. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:230 >> + > > Hey, crazy question? Its probably ~100 frames history that we keep right? That should be like stupid fast to compute an average for... we only run this when they ask for it, so paying a few usec for this is totally fine by me. > > The reason I ask is because this code is getting a bit hard to read. Not your fault... its just we're doing a few different things here. Thats not bad, but suppose down the road we decide instead of stddev, we need a metric like "number of frames that we dropped." At that point, I'd love it if the code was really easy to hack on. > > If we just go to "compute everything every time from a frame history", does the code get cleaner? I personally like having less state and state overlap in that case.... We are only keeping 64 data points. We could loop over them and compute every time, and I don't think it would be ridiculously inefficient though it depends on the platform (on ARM, computing this from scratch might matter). I wasn't primarily worried about computation time here but rather about not introducing floating point errors. I don't know of a technique for computing these metrics that is both simple and correct - do you have a reference? If I was to take your suggestion I'd just put this existing code in a loop which wouldn't really help with the complexity of this block. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:233 >> + String text(String::format("FPS: XXX.X (XX.X XXX.XXX)")); > > Is there a way to re-use the format string here? I was using the wrong format string, I can change it to %5.1f (%4.1f %7.1f) to get the effect, will do. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:236 >> + text = String::format("FPS: %03.01f (%02.01f %03.03f)", 1.0 / m_filteredFrameTime, m_averageFPS, stdDeviation); > > I'm not sure the average person from the street is going to understand the variance vs average, much less stddev. I also have thrown around the idea of reporting late "% frames we dropped" instead of variance at all, since stddev is really funky for fps (2ms variance on 60fps is 60 fps+/- something strange). > > What if we report out filtered fps and let people see variance from the graph? I'm all for leaving calculations in place because we've had requests for a follow-on patch that exposes frame rate metrics to javascript for people who have test harnesses/etc. Within that context, I imagine we could expose a few different values... The variance reported is in FPS, so the numbers are average +/- multiple of stddev. I really need the stddev to do anything statistically meaningful. What about making it verbose like X FPS, Y% of values in {LOW, HIGH} s = stddev? >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:278 >> + if (!m_badFrame[j]) { > > Might want to explain what this block of code does. It kind of breaks my head I'd rather reorder it to be clearer. Is it the inner if that's the problem? or the whole block? >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:290 >> + if (minimumOutlier != noOutlierFound) { > > What's the value add of showing the outlier? Easiest to see if you run the code, since there's no scale on the graph it's nice to see the little 30.0 floating under the downspike as it scrolls by in the graph. Could remove, but helps you see how bad the bad frames are. 521351 5 119277 nduca 2011-12-14 15:22:24 -0800 Comment on attachment 119277 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=119277&action=review >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:89 >>> + m_badFrame[FRAME_INDEX(m_currentFrameNumber)] = (delta < 1.0 / 70) || (delta > 5.0 / 60); >> >> When we have vsync turned off, eg --disable-gpu-vsync, this would mean frame rate peaks at 70fps, right? We're going to be getting rid of these fast frames over time, so I'd rather get correct numbers for very fast framerates... thoughts? > > No, the effect of this will be that if you have --disable-gpu-vsync the FPS meter will refuse to show you data because the data are wrong. I preferred to have an empty graph rather than show the user false frame rates - we are painting frames the user will never see in this case. In addition this filtering is ultimately what detects the spike due to startup after a pause, since the early swapbuffers calls are nonblocking and all get assigned silly high frame rates (like 110FPS). > > How critical is seeing the bad data for the no vsync case? I'm open to suggestions. I guess we have disagreeing interpretations of frame rate. I had taken this counter to indicate *chrome* rendering FPS, not window manager FPS --- if you want that, people tend to use their window manager's FPS counter [on OSX and Windows, there are tools to measure that]. On aura, we'd turn on FPS counter int he browser compositor :) If we are swapping at 110fps, thats actually a meaningful value, its just a matter of perspective. I agree that a user might say "i see 110 but i've got a camera pointed at my screen and see 60." However, people doing rendering optimizations run with vsync off in order to get that 110 fps number: it indicates the peak rate that you could run at, and shows how gpu-bound you are. E.g. danakj's culling work impact on GPU perf can be measured from FPS without vsync... Anyway, food for thought. What do you think with some of that data in mind? >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:204 >>> // Filter the frame times to avoid spikes. >> >> Might want to explain the filtering algorithm here sort of how you did in the changelog. > > Happy to do so but this is the pre-existing code. Yeah, sorry! Darn those commons! :) >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:210 >>> + // don't filter the time if this is the first frame after a period of no drawing; pretend this >> >> don't -> Don't. >> Complete sentences for comments throughout the file. > > Sorry will fix, not used to webkit style. it breaks my head too. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:214 > m_filteredFrameTime = ((1.0 - alpha) * m_filteredFrameTime) + (alpha * secForLastFrame); Is there a reason we don't don't reset the filtered frame time for long frames? >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:216 >>> + if (secForThirdLastFrame > 0.5 || m_averageFPSCount > 60*2) { >> >> Should we pull the various constants to kBlahBlahBlah? >> >> What is this check adding over the m_badFrame[FRAME_NUMBER(m_cur - 3)] check? I'm sure its something, I just can't figure out what it is in my head. > > Bad frames can occur within the sample. So if you stop doing anything and then you start to scroll, you'll get a few bad frames at the start of the sample, and m_badFrame lets you skip those so they don't mess up the average and standard deviation; while this check determines that since the third last frame was so very long (> 0.5s, or whatever threshold we choose) we should start a new set of samples for timing the animation. Deciding if something is a bad frame or not is a separate set of heuristics/constants than deciding how long a pause is needed to consider the sample data a new stream of frames for a new animation. > > The second half of the if is ensuring that we don't take samples longer than 2s; the assumption is that in a long running animation, you'd prefer to see problems with variance in a reasonably small window, whereas if you accumulated thousands of datapoints the outliers wouldn't be able to move the average of the variance and that would hide problems. So if you run something like poster circle the stats keep resetting and glitches impact the variance quite a bit. Ah.... so a "bad frame" doesn't count against the average. A long frame resets the average. Is that a fair summary? But why do we reset the fps every 120 samples? Can we just drop expontentially weighted frame time and use the average and stddev only? This reset logic fixes the problem the expontential weighting was introduced for --- chiefly, making it converge on something sane with big pauses sometimes... > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:231 > // Create & measure FPS text. Been tuning android all day this week, I'm not worried about cpu time... we spend a good half millisecond putting this data into textures, then to the gpu process, in a very inefficient way. The calculation is probably epsilon on that. If we go to stddev and average as the only metric, then isn't it just a matter of walking [with wraparound] from the oldest frame to the newest frame doing the calculations above as you go? The nice thing is that we could make this into a getFPSAndStdDev(double& fps, double& stddev) const, where our only member vars are m_frameBeginTime and maaaayybe of m_badFrame... >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:236 >>> + text = String::format("FPS: %03.01f (%02.01f %03.03f)", 1.0 / m_filteredFrameTime, m_averageFPS, stdDeviation); >> >> I'm not sure the average person from the street is going to understand the variance vs average, much less stddev. I also have thrown around the idea of reporting late "% frames we dropped" instead of variance at all, since stddev is really funky for fps (2ms variance on 60fps is 60 fps+/- something strange). >> >> What if we report out filtered fps and let people see variance from the graph? I'm all for leaving calculations in place because we've had requests for a follow-on patch that exposes frame rate metrics to javascript for people who have test harnesses/etc. Within that context, I imagine we could expose a few different values... > > The variance reported is in FPS, so the numbers are average +/- multiple of stddev. I really need the stddev to do anything statistically meaningful. > What about making it verbose like X FPS, Y% of values in {LOW, HIGH} s = stddev? If we go to just average, then I'm down with whatever you think is the clearest way to present it. Lets be kind to people who leave this onscreen and not eat the entire top part of the screen, of course. :) >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:278 >>> + if (!m_badFrame[j]) { >> >> Might want to explain what this block of code does. It kind of breaks my head > > I'd rather reorder it to be clearer. Is it the inner if that's the problem? or the whole block? 278-287 was really hard to read. If you can reorder it, that's cool. Or just some docs... That 5-part if statement on fps is what really was hard. Temp vars maybe? >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:290 >>> + if (minimumOutlier != noOutlierFound) { >> >> What's the value add of showing the outlier? > > Easiest to see if you run the code, since there's no scale on the graph it's nice to see the little 30.0 floating under the downspike as it scrolls by in the graph. Could remove, but helps you see how bad the bad frames are. I think I get it. This is a cool idea! 546808 6 124885 anicolao 2012-01-31 22:17:15 -0800 Created attachment 124885 Patch 546811 7 anicolao 2012-01-31 22:19:42 -0800 Nat, I think I made all the changes we'd discussed save one: I couldn't find the boolean to make ignoring the fast frames conditional on whether or not the scheduler is turned on. Sorry can you remind me where that flag is? I thought I'd post this anyway because you might want to give it another once over looking for problems. I removed the outlier code which was just difficult to make easy on the eyes, as well as the EMA code that isn't really needed any more so I think overall the patch looks a little nicer/smaller. PTAL and let me know what more we need to do to get this landed. I'll be faster than a month for this next iteration :-) 547085 8 124885 nduca 2012-02-01 07:50:25 -0800 Comment on attachment 124885 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=124885&action=review To test for non-threaded mode, which is the one that does the doubleframe thing, bool bSchedulerDoesDoubleframes = !CCProxy::hasImplThread(). Have to catch a bus. Will look more if it has wifi. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:82 > +// works on -1 Nice. Webkit Style devil say comments are complete sentences. :) > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:91 > + m_badFrame[FRAME_INDEX(m_currentFrameNumber)] = (delta < kFrameTooFast) || (delta > kFrameTooSlow); Can't we reconstruct this at draw time rather than storing it? I'd love to avoid redundant state. 548032 9 124885 anicolao 2012-02-02 11:53:17 -0800 Comment on attachment 124885 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=124885&action=review >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:82 >> +// works on -1 > > Nice. Webkit Style devil say comments are complete sentences. :) fixed >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:91 >> + m_badFrame[FRAME_INDEX(m_currentFrameNumber)] = (delta < kFrameTooFast) || (delta > kFrameTooSlow); > > Can't we reconstruct this at draw time rather than storing it? I'd love to avoid redundant state. I did this as you asked (see the upcoming patch) but I wouldn't normally make the tradeoff this way. If I can trade a constant thing for an O(n) thing, I take the constant thing; in this case, it's constant space versus O(n) time to recompute for every call; constant space would be the winner for me (as the HUD is essentially a singleton). If it was O(n) space versus O(n) time it'd depend on how many objects, and if it was O(n) space versus constant time I'd take recomputation. In this instance I really think it makes no difference as the computation is small, so I just switched it out. I just don't think anyone would ever notice the difference either way in this example. 548048 10 125159 anicolao 2012-02-02 12:14:42 -0800 Created attachment 125159 Patch 557943 11 125159 nduca 2012-02-15 23:33:58 -0800 Comment on attachment 125159 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125159&action=review Thanks so much! I think if we can ditch the kLongAnimationTriggersReset, I'd be happy with this. I think we will need to do a followup patch that improves the numerical stability of the FPS average for long running apps that are always animating. For that case, we'd never get a FPS reset, and so the FPS and Count values would constantly grow. It seems to me that we have a history value lying around and the awesome new FRAME_INDEX() macro. In the followup patch, I think we can simply make a function that is getAverageFPSAndVariance() that walks back from the current frame number until a long frame is reached or we wrap around to the start point. Once the "gesture start index" is found, we walk forward through the timestamps to the current frame number, running your existing FPS accumulation logic and discarding "bad" frames. Voila, stable FPS. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:54 > + , m_varianceNumerator(0) Under the heading of tormenting you to death: m_averageFPSSampleCount m_fpsVarianceNumerator [or m_frameDurationNumerator, depending on whether the variance is 1/x or x] > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:209 > + double secForThirdLastFrame = m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 3)] - might want a comment explaining why 3rd and not 2nd. Iirw, its because of doubleframes, right? > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:216 > + // the scheduler is not active in order to represent the true frame rate in scheduler is not active -> the single threaded scheduler is active something like that. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:219 > + if (secForThirdLastFrame > kIdleSecondsTriggersReset || m_averageFPSCount > kLongAnimationTriggersReset) { Shouldn't the isBadFrame()'s low value being set to say, 10fps, eliminate these frames entirely? I'd prefer that because then we have a proper running average, rather than an average of the last 120 frames. The 120-frame average bugs me because for a sample(i), the amount of "support" that it has is based on i%120. E.g. sample 0 is going to have zero support and be exaclty that value, whereas sample 127 is going to be highly filtered by the preecindg samples. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:267 > + if (!isBadFrame(j)) { Might be cleaner if you say if(isBadFrame(j)) continue; > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:89 > + static const double kFrameTooFast = 1.0 / 70; I'm thinking 1/150 might be better here. 6.6ms will still catch the doubleframes, but will give us better protection against people with fancy 120hz monitors. Might put the units on this. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:90 > + static const double kFrameTooSlow = 5.0 / 60; Can we fram this instead as 1 / 12? That way its more obviously 12fps Units. 561574 12 125159 jamesr 2012-02-21 21:08:01 -0800 Comment on attachment 125159 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125159&action=review > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:84 > +#define FRAME_INDEX(frame) SAFE_MOD(frame, kBeginFrameHistorySize) does this really have to be a macro? i think this would be much better as a simple static function so we could get useful type checking and easier debugging > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:175 > + bool bSchedulerAllowsDoubleFrames = !CCProxy::hasImplThread(); webkit style is for not prefix variable names with a "b" or other suffix like this. I think schedulerAllowsDoubleFrames would be fine > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:237 > + float textWidth = m_mediumFont->width(text) + 2.0f; just "+ 2;". See http://www.webkit.org/coding/coding-style.html#float-suffixes >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:267 >> + if (!isBadFrame(j)) { > > Might be cleaner if you say > if(isBadFrame(j)) > continue; agree, especially since we use 4-space indents in WebKit it's good to use early outs instead of nesting to try to keep indentation under control and avoid unnecessary churn on lines > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:268 > + double p = 1 - ((fps - loFPS) / (hiFPS - loFPS)); use a full word. other than loop counters or x/y/z for coordinates we pretty much never use one-letter variable names in WebKit. I realize that this file in particular has a lot of style violations - I was pretty lax when initially reviewing it - but it's good to get into good habits in order to keep the codebase consistent where possible > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:84 > + static const double kIdleSecondsTriggersReset = 0.5; constants should not have the 'k' prefix (although I realize that other constants here are incorrectly named) - just name them like normal variables. I can't tell why these are in the header and not simply statics in the .cpp 561611 13 125159 anicolao 2012-02-21 22:13:24 -0800 Comment on attachment 125159 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125159&action=review >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:54 >> + , m_varianceNumerator(0) > > Under the heading of tormenting you to death: > > m_averageFPSSampleCount > m_fpsVarianceNumerator [or m_frameDurationNumerator, depending on whether the variance is 1/x or x] Fixed. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:84 >> +#define FRAME_INDEX(frame) SAFE_MOD(frame, kBeginFrameHistorySize) > > does this really have to be a macro? i think this would be much better as a simple static function so we could get useful type checking and easier debugging I don't really care, will switch. No useful type checking to do here, static member has to be a class member for access to kBeginFrameHistorySize. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:175 >> + bool bSchedulerAllowsDoubleFrames = !CCProxy::hasImplThread(); > > webkit style is for not prefix variable names with a "b" or other suffix like this. I think schedulerAllowsDoubleFrames would be fine Name taken directly from nduca's review, will change. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:209 >> + double secForThirdLastFrame = m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 3)] - > > might want a comment explaining why 3rd and not 2nd. Iirw, its because of doubleframes, right? Hmm. I will look into this and explain or modify, in this current version of the patch I see no need for this. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:216 >> + // the scheduler is not active in order to represent the true frame rate in > > scheduler is not active -> the single threaded scheduler is active > > something like that. OK will fix. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:219 >> + if (secForThirdLastFrame > kIdleSecondsTriggersReset || m_averageFPSCount > kLongAnimationTriggersReset) { > > Shouldn't the isBadFrame()'s low value being set to say, 10fps, eliminate these frames entirely? I'd prefer that because then we have a proper running average, rather than an average of the last 120 frames. The 120-frame average bugs me because for a sample(i), the amount of "support" that it has is based on i%120. E.g. sample 0 is going to have zero support and be exaclty that value, whereas sample 127 is going to be highly filtered by the preecindg samples. To get a true moving average we'd have to recompute on every cycle. We could just set kLongAnimationTriggersReset to a much bigger value? But that defeats the purpose of the reset, since its goal is to expose jank. If we really need this gone, I'd rather recompute every time as you've suggested in your overview comment. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:237 >> + float textWidth = m_mediumFont->width(text) + 2.0f; > > just "+ 2;". See http://www.webkit.org/coding/coding-style.html#float-suffixes OK will fix. >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:267 >>> + if (!isBadFrame(j)) { >> >> Might be cleaner if you say >> if(isBadFrame(j)) >> continue; > > agree, especially since we use 4-space indents in WebKit it's good to use early outs instead of nesting to try to keep indentation under control and avoid unnecessary churn on lines This means repeating the line x += 1 from 240/278 here. I don't care enough to argue the point, but maybe just confirm that's what you want? >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:268 >> + double p = 1 - ((fps - loFPS) / (hiFPS - loFPS)); > > use a full word. other than loop counters or x/y/z for coordinates we pretty much never use one-letter variable names in WebKit. I realize that this file in particular has a lot of style violations - I was pretty lax when initially reviewing it - but it's good to get into good habits in order to keep the codebase consistent where possible This is a pre-existing variable name from 231 of the original code. Can I do a separate renaming/refactoring patch to fix up the name and then apply this patch to get the logic, or can I follow this patch with a renaming patch? >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:84 >> + static const double kIdleSecondsTriggersReset = 0.5; > > constants should not have the 'k' prefix (although I realize that other constants here are incorrectly named) - just name them like normal variables. > > I can't tell why these are in the header and not simply statics in the .cpp Pure case of monkey-see, monkey-do. Again, I'd prefer to make these changes in a refactoring patch to land before or after this one to avoid muddying the waters. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:89 >> + static const double kFrameTooFast = 1.0 / 70; > > I'm thinking 1/150 might be better here. 6.6ms will still catch the doubleframes, but will give us better protection against people with fancy 120hz monitors. > > Might put the units on this. I'll try it and take the change if it works. This also will make the graph 50% taller. >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:90 >> + static const double kFrameTooSlow = 5.0 / 60; > > Can we fram this instead as 1 / 12? That way its more obviously 12fps > > Units. I thought it was more intuitive to think of it as 5 missed frames than think of it as slower than 12 fps, but really don't care either way. You ask for units, do you care about the naming? kFrameTooSlowMS? 562381 14 nduca 2012-02-22 14:15:53 -0800 (In reply to comment #13) > Name taken directly from nduca's review, will change. sorry. I think jamesr, we can let the 'x' and 'p' slide. This code is non normative due to me screwing up previously. I think its perfectly acceptable to finish this patch and file a followup bug about making this file more normative. > To get a true moving average we'd have to recompute on every cycle. We could just set kLongAnimationTriggersReset to a much bigger value? But that defeats the purpose of the reset, since its goal is to expose jank. If we really need this gone, I'd rather recompute every time as you've suggested in your overview comment. Yeah, lets get a true windowed average. If one-off spikes prove to be an issue once that is done, computing-every-frame gives us a clean way to then switch from an average to median or 75th percentile. > This means repeating the line x += 1 from 240/278 here. I don't care enough to argue the point, but maybe just confirm that's what you want? Go for it. :) > > >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:268 > >> + double p = 1 - ((fps - loFPS) / (hiFPS - loFPS)); > > > > use a full word. other than loop counters or x/y/z for coordinates we pretty much never use one-letter variable names in WebKit. I realize that this file in particular has a lot of style violations - I was pretty lax when initially reviewing it - but it's good to get into good habits in order to keep the codebase consistent where possible > > This is a pre-existing variable name from 231 of the original code. Can I do a separate renaming/refactoring patch to fix up the name and then apply this patch to get the logic, or can I follow this patch with a renaming patch? I think fixing this is beyond the scope of this patch. File a bug, assign to me if you want. I'm hoping james will be ok with this compromise. > I'll try it and take the change if it works. This also will make the graph 50% taller. Oh, hm. Lets just decouple the graph dimensions then. I think your graph sizing was well chosen --- there's little reason the two have to be coupled. > >> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:90 > >> + static const double kFrameTooSlow = 5.0 / 60; > > > > Can we fram this instead as 1 / 12? That way its more obviously 12fps > I thought it was more intuitive to think of it as 5 missed frames than think of it as slower than 12 fps, but really don't care either way. You ask for units, do you care about the naming? kFrameTooSlowMS? Ah, I understand your rationale. But for that, then i'd name the constant numMissedFramesBeforeReset or something like that and do the conversion to ms on the fly. 572487 15 125159 anicolao 2012-03-06 20:54:13 -0800 Comment on attachment 125159 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125159&action=review >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:84 >>> +#define FRAME_INDEX(frame) SAFE_MOD(frame, kBeginFrameHistorySize) >> >> does this really have to be a macro? i think this would be much better as a simple static function so we could get useful type checking and easier debugging > > I don't really care, will switch. No useful type checking to do here, static member has to be a class member for access to kBeginFrameHistorySize. Done >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:175 >>> + bool bSchedulerAllowsDoubleFrames = !CCProxy::hasImplThread(); >> >> webkit style is for not prefix variable names with a "b" or other suffix like this. I think schedulerAllowsDoubleFrames would be fine > > Name taken directly from nduca's review, will change. Done. >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:209 >>> + double secForThirdLastFrame = m_beginTimeHistoryInSec[FRAME_INDEX(m_currentFrameNumber - 3)] - >> >> might want a comment explaining why 3rd and not 2nd. Iirw, its because of doubleframes, right? > > Hmm. I will look into this and explain or modify, in this current version of the patch I see no need for this. This is not necessary now (I will be kind to myself and assume in the first iteration it was). I changed it to use the second last. >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:216 >>> + // the scheduler is not active in order to represent the true frame rate in >> >> scheduler is not active -> the single threaded scheduler is active >> >> something like that. > > OK will fix. Done >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:237 >>> + float textWidth = m_mediumFont->width(text) + 2.0f; >> >> just "+ 2;". See http://www.webkit.org/coding/coding-style.html#float-suffixes > > OK will fix. Done >>>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:267 >>>> + if (!isBadFrame(j)) { >>> >>> Might be cleaner if you say >>> if(isBadFrame(j)) >>> continue; >> >> agree, especially since we use 4-space indents in WebKit it's good to use early outs instead of nesting to try to keep indentation under control and avoid unnecessary churn on lines > > This means repeating the line x += 1 from 240/278 here. I don't care enough to argue the point, but maybe just confirm that's what you want? Done. >>> Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.h:89 >>> + static const double kFrameTooFast = 1.0 / 70; >> >> I'm thinking 1/150 might be better here. 6.6ms will still catch the doubleframes, but will give us better protection against people with fancy 120hz monitors. >> >> Might put the units on this. > > I'll try it and take the change if it works. This also will make the graph 50% taller. This doesn't work well for me. On debug builds on my Z600 I get spikes up to about 78-80FPS regularly that are fake. 572495 16 130531 anicolao 2012-03-06 21:04:26 -0800 Created attachment 130531 Patch 572514 17 130539 anicolao 2012-03-06 21:37:17 -0800 Created attachment 130539 Patch 572515 18 anicolao 2012-03-06 21:38:46 -0800 The latest patch has all the proposed changes except renamings which I'd still be happy to do in a follow-up or prereq patch. The second from last patch has all changes except factoring out the average to be a moving average so that trivial responses to comments can be seen without the code being completely rearranged. You can ignore it or use it to tick off old comments. 595171 19 130539 nduca 2012-04-03 20:03:11 -0700 Comment on attachment 130539 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=130539&action=review LGTM with nits. Thanks again for putting up with us. :) You'll probably need to rebase as james just landed some very minor changes this morning that fix the HUD for threaded mode. > Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:208 > +void CCHeadsUpDisplay::getAverageFPSAndStandardDeviation(double *average, double *standardDeviation) const Little style nit. /me wonders if we should just make a little struct on CCHeadsUpDisplay so we can avoid passing by pointer, then convering to reference awkwardness... struct FrameStats { avg stdev } FrameRate getFrameStats() ... Or, you could just keep as is, but make double& averageFPS ==> double averageFPS and assign to the out value only at the end... 595174 20 130539 jamesr 2012-04-03 20:08:36 -0700 Comment on attachment 130539 Patch Looks good but you are going to have merge conflicts due to http://trac.webkit.org/changeset/113081 (sorry!). Please rebase and consider Nat's feedback. 600056 21 136629 anicolao 2012-04-10 23:21:27 -0700 Created attachment 136629 Patch 600058 22 anicolao 2012-04-10 23:24:21 -0700 Patch in previous upload (https://bugs.webkit.org/show_bug.cgi?id=73454#c21) is teh patch as it builds and tests against gclient just prior to the upload. I will in a few minutes upload the patch against tot. 600068 23 136634 anicolao 2012-04-10 23:39:04 -0700 Created attachment 136634 Patch 600069 24 anicolao 2012-04-10 23:39:39 -0700 The latest patch builds and runs on tot. 600093 25 nduca 2012-04-11 00:35:01 -0700 Awesome. @jamesr for final review and cq. 600333 26 136634 jamesr 2012-04-11 09:44:59 -0700 Comment on attachment 136634 Patch OK! 600344 27 136634 webkit.review.bot 2012-04-11 09:57:33 -0700 Comment on attachment 136634 Patch Clearing flags on attachment: 136634 Committed r113872: <http://trac.webkit.org/changeset/113872> 600345 28 webkit.review.bot 2012-04-11 09:57:39 -0700 All reviewed patches have been landed. Closing bug. 600381 29 simonjam 2012-04-11 10:35:26 -0700 This is being rolled out. It broke the mac and windows builds: 3>c:\b\build\slave\webkit-win-latest-rel\build\src\third_party\webkit\source\webcore\platform\graphics\chromium\cc/CCHeadsUpDisplay.h(87) : error C2864: 'WebCore::CCHeadsUpDisplay::kIdleSecondsTriggersReset' : only static const integral data members can be initialized within a class 3>c:\b\build\slave\webkit-win-latest-rel\build\src\third_party\webkit\source\webcore\platform\graphics\chromium\cc/CCHeadsUpDisplay.h(89) : error C2864: 'WebCore::CCHeadsUpDisplay::kFrameTooFast' : only static const integral data members can be initialized within a class 600400 30 136696 anicolao 2012-04-11 10:45:08 -0700 Created attachment 136696 Patch 600404 31 anicolao 2012-04-11 10:46:34 -0700 The new patch should fix the windows compile but I haven't verified it on Windows yet. It does still build and work on linux and does resolve the error from the compiler. 600613 32 anicolao 2012-04-11 14:56:58 -0700 I validated the patch builds and the --show-fps-counter flag works on Windows by testing manually. 600622 33 136696 jamesr 2012-04-11 15:11:03 -0700 Comment on attachment 136696 Patch Cool 600652 34 136696 webkit.review.bot 2012-04-11 15:48:59 -0700 Comment on attachment 136696 Patch Clearing flags on attachment: 136696 Committed r113918: <http://trac.webkit.org/changeset/113918> 600653 35 webkit.review.bot 2012-04-11 15:49:05 -0700 All reviewed patches have been landed. Closing bug. 119277 2011-12-14 12:41:26 -0800 2012-01-31 22:17:11 -0800 Patch bug-73454-20111214154124.patch text/plain 11049 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTAyNTkwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjhiYjJlNWQ5Y2Y3MTk5 OTk1NmQ1YjM1NmZhYWRjYzZmNDExNTMyOS4uOTU4MmJiNmRlNDYzNjk5N2QyZWIzYWMxNTM0OTlh OWZkOTJmOGQ3ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDExLTEyLTE0ICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBzbyB0aGF0IG91dGxpZXIgZGF0YSBwb2lu dHMgYXJlIGxhYmVsbGVkIHdpdGggdGhlaXIKKyAgICAgICAgZnJhbWUgcmF0ZSBzbyB0aGF0IHlv dSBjYW4gc2VlIGhvdyBzbG93IHRoZSBmcmFtZSBpcyB0aGF0IGlzCisgICAgICAgIGNhdXNpbmcg dGhlIGphbms7IGFuZCB0byBrZWVwIHN0YXRpc3RpY3Mgb24gZnJhbWUgcmF0ZSBiZXR3ZWVuCisg ICAgICAgIHBhdXNlcyBpbiB0aGUgYWN0aXZpdHkgaW4gdGhlIFVJIHNvIHRoYXQgeW91IGNhbiB0 cmlnZ2VyIGEKKyAgICAgICAgdHJhbnNpdGlvbiBhbmQgcmVhZCBvZmYgdGhlIGF2ZXJhZ2UgYW5k IHN0YW5kYXJkIGRldmlhdGlvbiBmb3IKKyAgICAgICAgdGhhdCB0cmFuc2l0aW9uIHRvIGp1ZGdl IGl0IHNtb290aCBlbm91Z2ggb3Igbm90LgorCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgSFVEIGlzIG5vdCB0ZXN0YWJsZSBpbiB3ZWJraXQuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OkNDSGVhZHNVcERpc3BsYXkp OgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6b25GcmFtZUJlZ2luKToKKyAg ICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OmRyYXdIdWRDb250ZW50cyk6CisgICAg ICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcik6CisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oOgorCiAy MDExLTEyLTEyICBNYXJ5IFd1ICA8bWFyeS53dUB0b3JjaG1vYmlsZS5jb20uY24+CiAKICAgICAg ICAgVXBzdHJlYW0gMyBmaWxlcyBpbnRvIFdlYkNvcmUvcGxhdGZvcm0vYmxhY2tiZXJyeQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NI ZWFkc1VwRGlzcGxheS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAppbmRleCA3MDhiY2ZmODgwMWI3ODg4MTA2MGI1 Mjk4NThiMjg5Yjk1MzI4YWVjLi45N2U4ZmZlM2E3YjU3NzlkNTc3MjAyYmNhZTg3ZDBlMDc4OGFm ZGFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcApAQCAtNTAsNiArNTAsOSBA QCB1c2luZyBuYW1lc3BhY2Ugc3RkOwogQ0NIZWFkc1VwRGlzcGxheTo6Q0NIZWFkc1VwRGlzcGxh eShMYXllclJlbmRlcmVyQ2hyb21pdW0qIG93bmVyKQogICAgIDogbV9jdXJyZW50RnJhbWVOdW1i ZXIoMSkKICAgICAsIG1fZmlsdGVyZWRGcmFtZVRpbWUoMCkKKyAgICAsIG1fYXZlcmFnZUZQUygw KQorICAgICwgbV9hdmVyYWdlRlBTQ291bnQoMCkKKyAgICAsIG1fdmFyaWFuY2VOdW1lcmF0b3Io MCkKICAgICAsIG1fbGF5ZXJSZW5kZXJlcihvd25lcikKICAgICAsIG1fdXNlTWFwU3ViRm9yVXBs b2Fkcyhvd25lci0+Y29udGV4dFN1cHBvcnRzTWFwU3ViKCkpCiB7CkBAIC02MCw3ICs2Myw3IEBA IENDSGVhZHNVcERpc3BsYXk6OkNDSGVhZHNVcERpc3BsYXkoTGF5ZXJSZW5kZXJlckNocm9taXVt KiBvd25lcikKIAogICAgIEZvbnREZXNjcmlwdGlvbiBtZWRpdW1Gb250RGVzYzsKICAgICBtZWRp dW1Gb250RGVzYy5zZXRHZW5lcmljRmFtaWx5KEZvbnREZXNjcmlwdGlvbjo6TW9ub3NwYWNlRmFt aWx5KTsKLSAgICBtZWRpdW1Gb250RGVzYy5zZXRDb21wdXRlZFNpemUoMjApOworICAgIG1lZGl1 bUZvbnREZXNjLnNldENvbXB1dGVkU2l6ZSgxMik7CiAKICAgICBtX21lZGl1bUZvbnQgPSBhZG9w dFB0cihuZXcgRm9udChtZWRpdW1Gb250RGVzYywgMCwgMCkpOwogICAgIG1fbWVkaXVtRm9udC0+ dXBkYXRlKDApOwpAQCAtNzcsOSArODAsMTMgQEAgQ0NIZWFkc1VwRGlzcGxheTo6fkNDSGVhZHNV cERpc3BsYXkoKQogewogfQogCisjZGVmaW5lIEZSQU1FX0lOREVYKGZyYW1lKSAoKGZyYW1lKSAl IGtCZWdpbkZyYW1lSGlzdG9yeVNpemUpCiB2b2lkIENDSGVhZHNVcERpc3BsYXk6Om9uRnJhbWVC ZWdpbihkb3VibGUgdGltZXN0YW1wKQogewotICAgIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW21f Y3VycmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV0gPSB0aW1lc3RhbXA7 CisgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgobV9jdXJyZW50RnJhbWVO dW1iZXIpXSA9IHRpbWVzdGFtcDsKKyAgICBkb3VibGUgZGVsdGEgPSBtX2JlZ2luVGltZUhpc3Rv cnlJblNlY1tGUkFNRV9JTkRFWChtX2N1cnJlbnRGcmFtZU51bWJlcildIC0KKyAgICAgICAgICAg ICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tGUkFNRV9JTkRFWChtX2N1cnJlbnRGcmFt ZU51bWJlciAtIDEpXTsKKyAgICBtX2JhZEZyYW1lW0ZSQU1FX0lOREVYKG1fY3VycmVudEZyYW1l TnVtYmVyKV0gPSAoZGVsdGEgPCAxLjAgLyA3MCkgfHwgKGRlbHRhID4gNS4wIC8gNjApOwogfQog CiB2b2lkIENDSGVhZHNVcERpc3BsYXk6Om9uU3dhcEJ1ZmZlcnMoKQpAQCAtMTcwLDExICsxNzcs MTEgQEAgdm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3SHVkQ29udGVudHMoR3JhcGhpY3NDb250 ZXh0KiBjdHgsIGNvbnN0IEludFNpemUmIGh1ZFMKICAgICAgICAgY3R4LT5maWxsUmVjdChGbG9h dFJlY3QoMCwgMCwgaHVkU2l6ZS53aWR0aCgpLCBodWRTaXplLmhlaWdodCgpKSk7CiAgICAgfQog Ci0gICAgaW50IGZwc0NvdW50ZXJIZWlnaHQgPSBtX21lZGl1bUZvbnQtPmZvbnRNZXRyaWNzKCku ZmxvYXRIZWlnaHQoKSArIDI7CisgICAgaW50IGZwc0NvdW50ZXJIZWlnaHQgPSBtX21lZGl1bUZv bnQtPmZvbnRNZXRyaWNzKCkuZmxvYXRIZWlnaHQoKSArIDQwOwogICAgIGludCBmcHNDb3VudGVy VG9wID0gMjsKICAgICBpbnQgcGxhdGZvcm1MYXllclRyZWVUb3A7CiAgICAgaWYgKHNldHRpbmdz KCkuc2hvd0ZQU0NvdW50ZXIpCi0gICAgICAgIHBsYXRmb3JtTGF5ZXJUcmVlVG9wID0gZnBzQ291 bnRlclRvcCArIGZwc0NvdW50ZXJIZWlnaHQgKyAyOworICAgICAgICBwbGF0Zm9ybUxheWVyVHJl ZVRvcCA9IGZwc0NvdW50ZXJUb3AgKyBmcHNDb3VudGVySGVpZ2h0OwogICAgIGVsc2UKICAgICAg ICAgcGxhdGZvcm1MYXllclRyZWVUb3AgPSAwOwogCkBAIC0xODksNDIgKzE5Niw3NiBAQCB2b2lk IENDSGVhZHNVcERpc3BsYXk6OmRyYXdGUFNDb3VudGVyKEdyYXBoaWNzQ29udGV4dCogY3R4LCBp bnQgdG9wLCBpbnQgaGVpZ2h0KQogewogICAgIC8vIE5vdGUgdGhhdCBzaW5jZSB3ZSBoYXZlbid0 IGZpbmlzaGVkIHRoZSBjdXJyZW50IGZyYW1lLCB0aGUgRlBTIGNvdW50ZXIKICAgICAvLyBhY3R1 YWxseSByZXBvcnRzIHRoZSBsYXN0IGZyYW1lJ3MgdGltZS4KLSAgICBkb3VibGUgc2VjRm9yTGFz dEZyYW1lID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbKG1fY3VycmVudEZyYW1lTnVtYmVyICsg a0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSAtIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV0gLQot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1sobV9j dXJyZW50RnJhbWVOdW1iZXIgKyBrQmVnaW5GcmFtZUhpc3RvcnlTaXplIC0gMikgJSBrQmVnaW5G cmFtZUhpc3RvcnlTaXplXTsKKyAgICBkb3VibGUgc2VjRm9yTGFzdEZyYW1lID0gbV9iZWdpblRp bWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgobV9jdXJyZW50RnJhbWVOdW1iZXIgLSAxKV0gLQor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tGUkFN RV9JTkRFWChtX2N1cnJlbnRGcmFtZU51bWJlciAtIDIpXTsKKyAgICBkb3VibGUgc2VjRm9yVGhp cmRMYXN0RnJhbWUgPSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tGUkFNRV9JTkRFWChtX2N1cnJl bnRGcmFtZU51bWJlciAtIDMpXSAtCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg bV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgobV9jdXJyZW50RnJhbWVOdW1iZXIg LSA0KV07CiAKICAgICAvLyBGaWx0ZXIgdGhlIGZyYW1lIHRpbWVzIHRvIGF2b2lkIHNwaWtlcy4K ICAgICBjb25zdCBmbG9hdCBhbHBoYSA9IDAuMTsKICAgICBpZiAoIW1fZmlsdGVyZWRGcmFtZVRp bWUpIHsKICAgICAgICAgaWYgKG1fY3VycmVudEZyYW1lTnVtYmVyID09IDIpCiAgICAgICAgICAg ICBtX2ZpbHRlcmVkRnJhbWVUaW1lID0gc2VjRm9yTGFzdEZyYW1lOwotICAgIH0gZWxzZQorICAg IH0gZWxzZSBpZiAoc2VjRm9yTGFzdEZyYW1lID4gMC41KSB7CisgICAgICAgIC8vIGRvbid0IGZp bHRlciB0aGUgdGltZSBpZiB0aGlzIGlzIHRoZSBmaXJzdCBmcmFtZSBhZnRlciBhIHBlcmlvZCBv ZiBubyBkcmF3aW5nOyBwcmV0ZW5kIHRoaXMKKyAgICAgICAgLy8gZnJhbWUgdG9vayBhcyBsb25n IGFzIHRoZSBwcmV2aW91cyBmcmFtZSBkcmF3IGluc3RlYWQKKyAgICAgICAgbV9maWx0ZXJlZEZy YW1lVGltZSA9IG1fZmlsdGVyZWRGcmFtZVRpbWU7CisgICAgfSBlbHNlIHsKICAgICAgICAgbV9m aWx0ZXJlZEZyYW1lVGltZSA9ICgoMS4wIC0gYWxwaGEpICogbV9maWx0ZXJlZEZyYW1lVGltZSkg KyAoYWxwaGEgKiBzZWNGb3JMYXN0RnJhbWUpOwogCisgICAgICAgIGlmIChzZWNGb3JUaGlyZExh c3RGcmFtZSA+IDAuNSB8fCBtX2F2ZXJhZ2VGUFNDb3VudCA+IDYwKjIpIHsKKyAgICAgICAgICAg IC8vIHJlc3RhcnQgdGhlIGZyYW1lIHN0YXRpc3RpY3MKKyAgICAgICAgICAgIG1fYXZlcmFnZUZQ UyA9IDA7CisgICAgICAgICAgICBtX2F2ZXJhZ2VGUFNDb3VudCA9IDA7CisgICAgICAgICAgICBt X3ZhcmlhbmNlTnVtZXJhdG9yID0gMDsKKyAgICAgICAgfSBlbHNlIGlmICghbV9iYWRGcmFtZVtG UkFNRV9JTkRFWChtX2N1cnJlbnRGcmFtZU51bWJlciAtIDEpXSkgeworICAgICAgICAgICAgbV9h dmVyYWdlRlBTQ291bnQrKzsKKyAgICAgICAgICAgIGRvdWJsZSB4ID0gMS4wIC8gc2VjRm9yTGFz dEZyYW1lOworICAgICAgICAgICAgZG91YmxlIGRlbHRhRnJvbUF2ZXJhZ2UgPSB4IC0gbV9hdmVy YWdlRlBTOworICAgICAgICAgICAgLy8gQ2hhbmdlIHdpdGggY2F1dGlvbiAtIG51bWVyaWNzLiBo dHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL1N0YW5kYXJkX2RldmlhdGlvbgorICAgICAgICAg ICAgbV9hdmVyYWdlRlBTID0gbV9hdmVyYWdlRlBTICsgZGVsdGFGcm9tQXZlcmFnZSAvIG1fYXZl cmFnZUZQU0NvdW50OworICAgICAgICAgICAgbV92YXJpYW5jZU51bWVyYXRvciA9IG1fdmFyaWFu Y2VOdW1lcmF0b3IgKyBkZWx0YUZyb21BdmVyYWdlICogKHggLSBtX2F2ZXJhZ2VGUFMpOworICAg ICAgICB9CisgICAgfQorCiAgICAgLy8gQ3JlYXRlICYgbWVhc3VyZSBGUFMgdGV4dC4KLSAgICBT dHJpbmcgdGV4dChTdHJpbmc6OmZvcm1hdCgiRlBTOiAlNS4xZiIsIDEuMCAvIG1fZmlsdGVyZWRG cmFtZVRpbWUpKTsKKyAgICBkb3VibGUgc3RkRGV2aWF0aW9uID0gc3FydChtX3ZhcmlhbmNlTnVt ZXJhdG9yIC8gbV9hdmVyYWdlRlBTQ291bnQpOworICAgIFN0cmluZyB0ZXh0KFN0cmluZzo6Zm9y bWF0KCJGUFM6IFhYWC5YIChYWC5YIFhYWC5YWFgpIikpOworICAgIFRleHRSdW4gd2lkdGhSdW4o dGV4dCk7CisgICAgZmxvYXQgdGV4dFdpZHRoID0gbV9tZWRpdW1Gb250LT53aWR0aCh3aWR0aFJ1 bikgKyAyLjBmOworICAgIHRleHQgPSBTdHJpbmc6OmZvcm1hdCgiRlBTOiAlMDMuMDFmICglMDIu MDFmICUwMy4wM2YpIiwgMS4wIC8gbV9maWx0ZXJlZEZyYW1lVGltZSwgbV9hdmVyYWdlRlBTLCBz dGREZXZpYXRpb24pOwogICAgIFRleHRSdW4gcnVuKHRleHQpOwotICAgIGZsb2F0IHRleHRXaWR0 aCA9IG1fbWVkaXVtRm9udC0+d2lkdGgocnVuKSArIDIuMGY7CiAgICAgZmxvYXQgZ3JhcGhXaWR0 aCA9IGtCZWdpbkZyYW1lSGlzdG9yeVNpemU7CiAKICAgICAvLyBEcmF3IGJhY2tncm91bmQuCiAg ICAgY3R4LT5zZXRGaWxsQ29sb3IoQ29sb3IoMCwgMCwgMCwgMjU1KSwgQ29sb3JTcGFjZURldmlj ZVJHQik7Ci0gICAgY3R4LT5maWxsUmVjdChGbG9hdFJlY3QoMiwgdG9wLCB0ZXh0V2lkdGggKyBn cmFwaFdpZHRoLCBoZWlnaHQpKTsKKyAgICBkb3VibGUgZm9udEhlaWdodCA9IG1fbWVkaXVtRm9u dC0+Zm9udE1ldHJpY3MoKS5mbG9hdEhlaWdodCgpICsgMjsKKyAgICBjdHgtPmZpbGxSZWN0KEZs b2F0UmVjdCgyLCB0b3AsIHRleHRXaWR0aCwgZm9udEhlaWdodCkpOworICAgIGN0eC0+ZmlsbFJl Y3QoRmxvYXRSZWN0KDIgKyB0ZXh0V2lkdGgsIHRvcCwgZ3JhcGhXaWR0aCwgaGVpZ2h0KSk7CiAK ICAgICAvLyBEcmF3IEZQUyB0ZXh0LgogICAgIGlmIChtX2ZpbHRlcmVkRnJhbWVUaW1lKSB7Ci0g ICAgICAgIGN0eC0+c2V0RmlsbENvbG9yKENvbG9yKDI1NSwgMCwgMCksIENvbG9yU3BhY2VEZXZp Y2VSR0IpOwotICAgICAgICBjdHgtPmRyYXdUZXh0KCptX21lZGl1bUZvbnQsIHJ1biwgSW50UG9p bnQoMywgdG9wICsgaGVpZ2h0IC0gNikpOworICAgICAgICBjdHgtPnNldEZpbGxDb2xvcihDb2xv cigyMDAsIDIwMCwgMjAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CisgICAgICAgIGN0eC0+ZHJh d1RleHQoKm1fbWVkaXVtRm9udCwgcnVuLCBJbnRQb2ludCgzLCB0b3AgKyBmb250SGVpZ2h0IC0g NCkpOwogICAgIH0KIAogICAgIC8vIERyYXcgRlBTIGdyYXBoLgogICAgIGNvbnN0IGRvdWJsZSBs b0ZQUyA9IDAuMDsKLSAgICBjb25zdCBkb3VibGUgaGlGUFMgPSAxMjAuMDsKKyAgICBjb25zdCBk b3VibGUgaGlGUFMgPSA4MC4wOwogICAgIGN0eC0+c2V0U3Ryb2tlU3R5bGUoU29saWRTdHJva2Up OworICAgIGN0eC0+c2V0RmlsbENvbG9yKENvbG9yKDE1NCwgMjA1LCA1MCksIENvbG9yU3BhY2VE ZXZpY2VSR0IpOworICAgIGN0eC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIgKyB0ZXh0V2lkdGgsIHRv cCwgZ3JhcGhXaWR0aCwgaGVpZ2h0IC8gMikpOworICAgIGN0eC0+c2V0RmlsbENvbG9yKENvbG9y KDI1NSwgMjUwLCAyMDUpLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjdHgtPmZpbGxSZWN0 KEZsb2F0UmVjdCgyICsgdGV4dFdpZHRoLCB0b3AgKyBoZWlnaHQgLyAyLCBncmFwaFdpZHRoLCBo ZWlnaHQgLyAyKSk7CiAgICAgY3R4LT5zZXRTdHJva2VDb2xvcihDb2xvcigyNTUsIDAsIDApLCBD b2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjdHgtPnNldEZpbGxDb2xvcihDb2xvcigyNTUsIDAs IDApLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKICAgICBpbnQgZ3JhcGhMZWZ0ID0gc3RhdGljX2Nh c3Q8aW50Pih0ZXh0V2lkdGggKyAzKTsKICAgICBJbnRQb2ludCBwcmV2KC0xLCAwKTsKICAgICBp bnQgeCA9IDA7CiAgICAgZG91YmxlIGggPSBzdGF0aWNfY2FzdDxkb3VibGU+KGhlaWdodCAtIDIp OworICAgIGNvbnN0IGRvdWJsZSBub091dGxpZXJGb3VuZCA9IDEwMDsKKyAgICBkb3VibGUgbWlu aW11bU91dGxpZXIgPSBub091dGxpZXJGb3VuZDsKKyAgICBJbnRQb2ludCBvdXRsaWVyUG9zaXRp b247CiAgICAgZm9yIChpbnQgaSA9IG1fY3VycmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVI aXN0b3J5U2l6ZTsgaSAhPSAobV9jdXJyZW50RnJhbWVOdW1iZXIgLSAxKSAlIGtCZWdpbkZyYW1l SGlzdG9yeVNpemU7IGkgPSAoaSArIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSkgewogICAg ICAgICBpbnQgaiA9IChpICsgMSkgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOwogICAgICAgICBk b3VibGUgZnBzID0gMS4wIC8gKG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2pdIC0gbV9iZWdpblRp bWVIaXN0b3J5SW5TZWNbaV0pOwpAQCAtMjM0LDExICsyNzUsMjMgQEAgdm9pZCBDQ0hlYWRzVXBE aXNwbGF5OjpkcmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRleHQqIGN0eCwgaW50IHRvcCwgaW50 IGhlaWdodCkKICAgICAgICAgaWYgKHAgPiAxKQogICAgICAgICAgICAgcCA9IDE7CiAgICAgICAg IEludFBvaW50IGN1cihncmFwaExlZnQgKyB4LCAxICsgdG9wICsgcCpoKTsKLSAgICAgICAgaWYg KHByZXYueCgpICE9IC0xKQotICAgICAgICAgICAgY3R4LT5kcmF3TGluZShwcmV2LCBjdXIpOwot ICAgICAgICBwcmV2ID0gY3VyOworICAgICAgICBpZiAoIW1fYmFkRnJhbWVbal0pIHsKKyAgICAg ICAgICAgIGlmIChwcmV2LngoKSAhPSAtMSAmJiAhbV9iYWRGcmFtZVtqXSkgeworICAgICAgICAg ICAgICAgIGN0eC0+ZHJhd0xpbmUocHJldiwgY3VyKTsKKyAgICAgICAgICAgICAgICBpZiAoZnBz ID4gMS4wICYmIGZwcyA8IDQwICYmIGZwcyA8IG1pbmltdW1PdXRsaWVyICYmIGFicyhmcHMgLSBt X2F2ZXJhZ2VGUFMpID4gNipzdGREZXZpYXRpb24gJiYgc3RkRGV2aWF0aW9uID4gMC4wMSAmJiAh aXNuYW4oc3RkRGV2aWF0aW9uKSkgeworICAgICAgICAgICAgICAgICAgICBtaW5pbXVtT3V0bGll ciA9IGZwczsKKyAgICAgICAgICAgICAgICAgICAgb3V0bGllclBvc2l0aW9uID0gY3VyOworICAg ICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHByZXYgPSBjdXI7Cisg ICAgICAgIH0KICAgICAgICAgeCArPSAxOwogICAgIH0KKyAgICBpZiAobWluaW11bU91dGxpZXIg IT0gbm9PdXRsaWVyRm91bmQpIHsKKyAgICAgICAgU3RyaW5nIHRleHQoU3RyaW5nOjpmb3JtYXQo IiUyLjFmIiwgKChpbnQpbWluaW11bU91dGxpZXIqMTApIC8gMTAuMCkpOworICAgICAgICBUZXh0 UnVuIHJ1bih0ZXh0KTsKKyAgICAgICAgY3R4LT5kcmF3VGV4dCgqbV9tZWRpdW1Gb250LCBydW4s IEludFBvaW50KG91dGxpZXJQb3NpdGlvbi54KCksIG91dGxpZXJQb3NpdGlvbi55KCkgKyBmb250 SGVpZ2h0IC0gNCkpOworICAgIH0KIH0KIAogdm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3UGxh dGZvcm1MYXllclRyZWUoR3JhcGhpY3NDb250ZXh0KiBjdHgsIGludCB0b3ApCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBE aXNwbGF5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0hlYWRzVXBEaXNwbGF5LmgKaW5kZXggMDVjYjIwZDUyNjk3OTg1OTI2OGU0MTc3NGZjYWE0YTRj ZTFiYTJhNC4uMDI1ZWU3YTM4YjA5OWI4OGZjMDAwNmI3OTVlYTA2NTkyMzE1ZjFmMCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFk c1VwRGlzcGxheS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDSGVhZHNVcERpc3BsYXkuaApAQCAtNzAsNiArNzAsOSBAQCBwcml2YXRlOgogICAg IGludCBtX2N1cnJlbnRGcmFtZU51bWJlcjsKIAogICAgIGRvdWJsZSBtX2ZpbHRlcmVkRnJhbWVU aW1lOworICAgIGRvdWJsZSBtX2F2ZXJhZ2VGUFM7CisgICAgaW50IG1fYXZlcmFnZUZQU0NvdW50 OworICAgIGRvdWJsZSBtX3ZhcmlhbmNlTnVtZXJhdG9yOwogCiAgICAgT3duUHRyPE1hbmFnZWRU ZXh0dXJlPiBtX2h1ZFRleHR1cmU7CiAKQEAgLTc3LDYgKzgwLDcgQEAgcHJpdmF0ZToKIAogICAg IHN0YXRpYyBjb25zdCBpbnQga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSA9IDY0OwogICAgIGRvdWJs ZSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1trQmVnaW5GcmFtZUhpc3RvcnlTaXplXTsKKyAgICBi b29sIG1fYmFkRnJhbWVba0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV07CiAKICAgICBPd25QdHI8Rm9u dD4gbV9zbWFsbEZvbnQ7CiAgICAgT3duUHRyPEZvbnQ+IG1fbWVkaXVtRm9udDsK 124885 2012-01-31 22:17:15 -0800 2012-02-02 12:14:37 -0800 Patch bug-73454-20120201011714.patch text/plain 11275 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NDE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWE4MDdjYTlhNjEwMzk2 OGUwNWYwMzM0M2M5ZjVhMDU5ODMzZmYxZi4uZDk1Mjk4MTNiZTg4ZDZlNWI1NDMxMTMzZTEyZjQ5 NmIzNmE2MGM1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTAyLTAxICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBzbyB0aGF0IG91dGxpZXIgZGF0YSBwb2lu dHMgYXJlIGxhYmVsbGVkIHdpdGggdGhlaXIKKyAgICAgICAgZnJhbWUgcmF0ZSBzbyB0aGF0IHlv dSBjYW4gc2VlIGhvdyBzbG93IHRoZSBmcmFtZSBpcyB0aGF0IGlzCisgICAgICAgIGNhdXNpbmcg dGhlIGphbms7IGFuZCB0byBrZWVwIHN0YXRpc3RpY3Mgb24gZnJhbWUgcmF0ZSBiZXR3ZWVuCisg ICAgICAgIHBhdXNlcyBpbiB0aGUgYWN0aXZpdHkgaW4gdGhlIFVJIHNvIHRoYXQgeW91IGNhbiB0 cmlnZ2VyIGEKKyAgICAgICAgdHJhbnNpdGlvbiBhbmQgcmVhZCBvZmYgdGhlIGF2ZXJhZ2UgYW5k IHN0YW5kYXJkIGRldmlhdGlvbiBmb3IKKyAgICAgICAgdGhhdCB0cmFuc2l0aW9uIHRvIGp1ZGdl IGl0IHNtb290aCBlbm91Z2ggb3Igbm90LgorCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgSFVEIGlzIG5vdCB0ZXN0YWJsZSBpbiB3ZWJraXQuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OkNDSGVhZHNVcERpc3BsYXkp OgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6b25GcmFtZUJlZ2luKToKKyAg ICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OmRyYXdIdWRDb250ZW50cyk6CisgICAg ICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcik6CisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oOgorCiAy MDEyLTAxLTMxICBBZGFtIEtsZWluICA8YWRhbWtAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFBy b2Nlc3NpbmdJbnN0cnVjdGlvbiBzaG91bGQgbm90IGJlIGEgQ29udGFpbmVyTm9kZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFk c1VwRGlzcGxheS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAppbmRleCA3MDhiY2ZmODgwMWI3ODg4MTA2MGI1Mjk4 NThiMjg5Yjk1MzI4YWVjLi44YTU1YjEzNTBlZjZjZDNiMGQ1ZTFiMzlkNzgzM2UzMzllZWJhY2Qy IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcApAQCAtNDksNyArNDksOSBAQCB1 c2luZyBuYW1lc3BhY2Ugc3RkOwogCiBDQ0hlYWRzVXBEaXNwbGF5OjpDQ0hlYWRzVXBEaXNwbGF5 KExheWVyUmVuZGVyZXJDaHJvbWl1bSogb3duZXIpCiAgICAgOiBtX2N1cnJlbnRGcmFtZU51bWJl cigxKQotICAgICwgbV9maWx0ZXJlZEZyYW1lVGltZSgwKQorICAgICwgbV9hdmVyYWdlRlBTKDAp CisgICAgLCBtX2F2ZXJhZ2VGUFNDb3VudCgwKQorICAgICwgbV92YXJpYW5jZU51bWVyYXRvcigw KQogICAgICwgbV9sYXllclJlbmRlcmVyKG93bmVyKQogICAgICwgbV91c2VNYXBTdWJGb3JVcGxv YWRzKG93bmVyLT5jb250ZXh0U3VwcG9ydHNNYXBTdWIoKSkKIHsKQEAgLTYwLDcgKzYyLDcgQEAg Q0NIZWFkc1VwRGlzcGxheTo6Q0NIZWFkc1VwRGlzcGxheShMYXllclJlbmRlcmVyQ2hyb21pdW0q IG93bmVyKQogCiAgICAgRm9udERlc2NyaXB0aW9uIG1lZGl1bUZvbnREZXNjOwogICAgIG1lZGl1 bUZvbnREZXNjLnNldEdlbmVyaWNGYW1pbHkoRm9udERlc2NyaXB0aW9uOjpNb25vc3BhY2VGYW1p bHkpOwotICAgIG1lZGl1bUZvbnREZXNjLnNldENvbXB1dGVkU2l6ZSgyMCk7CisgICAgbWVkaXVt Rm9udERlc2Muc2V0Q29tcHV0ZWRTaXplKDEyKTsKIAogICAgIG1fbWVkaXVtRm9udCA9IGFkb3B0 UHRyKG5ldyBGb250KG1lZGl1bUZvbnREZXNjLCAwLCAwKSk7CiAgICAgbV9tZWRpdW1Gb250LT51 cGRhdGUoMCk7CkBAIC03Nyw5ICs3OSwxNiBAQCBDQ0hlYWRzVXBEaXNwbGF5Ojp+Q0NIZWFkc1Vw RGlzcGxheSgpCiB7CiB9CiAKKy8vIHdvcmtzIG9uIC0xCisjZGVmaW5lIFNBRkVfTU9EKG4sIG0p ICgoKG4pICsgKG0pKSAlIChtKSkKKyNkZWZpbmUgRlJBTUVfSU5ERVgoZnJhbWUpIFNBRkVfTU9E KGZyYW1lLCBrQmVnaW5GcmFtZUhpc3RvcnlTaXplKQorCiB2b2lkIENDSGVhZHNVcERpc3BsYXk6 Om9uRnJhbWVCZWdpbihkb3VibGUgdGltZXN0YW1wKQogewotICAgIG1fYmVnaW5UaW1lSGlzdG9y eUluU2VjW21fY3VycmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV0gPSB0 aW1lc3RhbXA7CisgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgobV9jdXJy ZW50RnJhbWVOdW1iZXIpXSA9IHRpbWVzdGFtcDsKKyAgICBkb3VibGUgZGVsdGEgPSBtX2JlZ2lu VGltZUhpc3RvcnlJblNlY1tGUkFNRV9JTkRFWChtX2N1cnJlbnRGcmFtZU51bWJlcildIC0KKyAg ICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tGUkFNRV9JTkRFWChtX2N1 cnJlbnRGcmFtZU51bWJlciAtIDEpXTsKKyAgICBtX2JhZEZyYW1lW0ZSQU1FX0lOREVYKG1fY3Vy cmVudEZyYW1lTnVtYmVyKV0gPSAoZGVsdGEgPCBrRnJhbWVUb29GYXN0KSB8fCAoZGVsdGEgPiBr RnJhbWVUb29TbG93KTsKIH0KIAogdm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpvblN3YXBCdWZmZXJz KCkKQEAgLTE3MCwxMSArMTc5LDExIEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0h1ZENv bnRlbnRzKEdyYXBoaWNzQ29udGV4dCogY3R4LCBjb25zdCBJbnRTaXplJiBodWRTCiAgICAgICAg IGN0eC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDAsIDAsIGh1ZFNpemUud2lkdGgoKSwgaHVkU2l6ZS5o ZWlnaHQoKSkpOwogICAgIH0KIAotICAgIGludCBmcHNDb3VudGVySGVpZ2h0ID0gbV9tZWRpdW1G b250LT5mb250TWV0cmljcygpLmZsb2F0SGVpZ2h0KCkgKyAyOworICAgIGludCBmcHNDb3VudGVy SGVpZ2h0ID0gbV9tZWRpdW1Gb250LT5mb250TWV0cmljcygpLmZsb2F0SGVpZ2h0KCkgKyA0MDsK ICAgICBpbnQgZnBzQ291bnRlclRvcCA9IDI7CiAgICAgaW50IHBsYXRmb3JtTGF5ZXJUcmVlVG9w OwogICAgIGlmIChzZXR0aW5ncygpLnNob3dGUFNDb3VudGVyKQotICAgICAgICBwbGF0Zm9ybUxh eWVyVHJlZVRvcCA9IGZwc0NvdW50ZXJUb3AgKyBmcHNDb3VudGVySGVpZ2h0ICsgMjsKKyAgICAg ICAgcGxhdGZvcm1MYXllclRyZWVUb3AgPSBmcHNDb3VudGVyVG9wICsgZnBzQ291bnRlckhlaWdo dDsKICAgICBlbHNlCiAgICAgICAgIHBsYXRmb3JtTGF5ZXJUcmVlVG9wID0gMDsKIApAQCAtMTg5 LDM4ICsxOTgsNjAgQEAgdm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcihHcmFw aGljc0NvbnRleHQqIGN0eCwgaW50IHRvcCwgaW50IGhlaWdodCkKIHsKICAgICAvLyBOb3RlIHRo YXQgc2luY2Ugd2UgaGF2ZW4ndCBmaW5pc2hlZCB0aGUgY3VycmVudCBmcmFtZSwgdGhlIEZQUyBj b3VudGVyCiAgICAgLy8gYWN0dWFsbHkgcmVwb3J0cyB0aGUgbGFzdCBmcmFtZSdzIHRpbWUuCi0g ICAgZG91YmxlIHNlY0Zvckxhc3RGcmFtZSA9IG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjWyhtX2N1 cnJlbnRGcmFtZU51bWJlciArIGtCZWdpbkZyYW1lSGlzdG9yeVNpemUgLSAxKSAlIGtCZWdpbkZy YW1lSGlzdG9yeVNpemVdIC0KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV9iZWdpblRp bWVIaXN0b3J5SW5TZWNbKG1fY3VycmVudEZyYW1lTnVtYmVyICsga0JlZ2luRnJhbWVIaXN0b3J5 U2l6ZSAtIDIpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV07Ci0KLSAgICAvLyBGaWx0ZXIgdGhl IGZyYW1lIHRpbWVzIHRvIGF2b2lkIHNwaWtlcy4KLSAgICBjb25zdCBmbG9hdCBhbHBoYSA9IDAu MTsKLSAgICBpZiAoIW1fZmlsdGVyZWRGcmFtZVRpbWUpIHsKLSAgICAgICAgaWYgKG1fY3VycmVu dEZyYW1lTnVtYmVyID09IDIpCi0gICAgICAgICAgICBtX2ZpbHRlcmVkRnJhbWVUaW1lID0gc2Vj Rm9yTGFzdEZyYW1lOwotICAgIH0gZWxzZQotICAgICAgICBtX2ZpbHRlcmVkRnJhbWVUaW1lID0g KCgxLjAgLSBhbHBoYSkgKiBtX2ZpbHRlcmVkRnJhbWVUaW1lKSArIChhbHBoYSAqIHNlY0Zvckxh c3RGcmFtZSk7CisgICAgZG91YmxlIHNlY0Zvckxhc3RGcmFtZSA9IG1fYmVnaW5UaW1lSGlzdG9y eUluU2VjW0ZSQU1FX0lOREVYKG1fY3VycmVudEZyYW1lTnVtYmVyIC0gMSldIC0KKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgo bV9jdXJyZW50RnJhbWVOdW1iZXIgLSAyKV07CisgICAgZG91YmxlIHNlY0ZvclRoaXJkTGFzdEZy YW1lID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgobV9jdXJyZW50RnJhbWVO dW1iZXIgLSAzKV0gLQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fYmVnaW5U aW1lSGlzdG9yeUluU2VjW0ZSQU1FX0lOREVYKG1fY3VycmVudEZyYW1lTnVtYmVyIC0gNCldOwor CisgICAgLy8gRmlsdGVyIHRoZSBmcmFtZSB0aW1lcyB0byBhdm9pZCBzcGlrZXMuIFNwZWNpZmlj YWxseSwga2VlcCBhIHJ1bm5pbmcKKyAgICAvLyBhdmVyYWdlIGZyYW1lIHJhdGUgYW5kIGEgcnVu bmluZyB2YXJpYW5jZSB3aGlsZSBpZ25vcmluZyBmcmFtZXMgaW4KKyAgICAvLyBtX2JhZEZyYW1l IHdoaWNoIGFyZSBlaXRoZXIgdG9vIHNsb3cgb3IgdG9vIGZhc3QuIFNsb3cgZnJhbWVzIG9jY3Vy CisgICAgLy8ganVzdCBiZWNhdXNlIHRoZSB1c2VyIGlzIGluYWN0aXZlLCBhbmQgc2hvdWxkIGJl IGlnbm9yZWQuIEZhc3QgZnJhbWVzCisgICAgLy8gYXJlIGlnbm9yZWQgaWYgdGhlIHNjaGVkdWxl ciBpcyBub3QgYWN0aXZlIGluIG9yZGVyIHRvIHJlcHJlc2VudCB0aGUKKyAgICAvLyB0cnVlIGZy YW1lIHJhdGUgaW4gc3BpdGUgb2YgdGhlIGZhY3QgdGhhdCB0aGUgZmlyc3QgZmV3IHN3YXBidWZm ZXJzCisgICAgLy8gaGFwcGVuIGluc3RhbnRseSB3aGljaCBza2V3cyB0aGUgc3RhdGlzdGljcyB0 b28gbXVjaCBmb3Igc2hvcnQgbGl2ZWQKKyAgICAvLyBhbmltYXRpb25zLgorICAgIGlmIChzZWNG b3JUaGlyZExhc3RGcmFtZSA+IGtJZGxlU2Vjb25kc1RyaWdnZXJzUmVzZXQgfHwgbV9hdmVyYWdl RlBTQ291bnQgPiBrTG9uZ0FuaW1hdGlvblRyaWdnZXJzUmVzZXQpIHsKKyAgICAgICAgLy8gcmVz dGFydCB0aGUgZnJhbWUgc3RhdGlzdGljcworICAgICAgICBtX2F2ZXJhZ2VGUFMgPSAwOworICAg ICAgICBtX2F2ZXJhZ2VGUFNDb3VudCA9IDA7CisgICAgICAgIG1fdmFyaWFuY2VOdW1lcmF0b3Ig PSAwOworICAgIH0gZWxzZSBpZiAoIW1fYmFkRnJhbWVbRlJBTUVfSU5ERVgobV9jdXJyZW50RnJh bWVOdW1iZXIgLSAxKV0pIHsKKyAgICAgICAgbV9hdmVyYWdlRlBTQ291bnQrKzsKKyAgICAgICAg ZG91YmxlIHggPSAxLjAgLyBzZWNGb3JMYXN0RnJhbWU7CisgICAgICAgIGRvdWJsZSBkZWx0YUZy b21BdmVyYWdlID0geCAtIG1fYXZlcmFnZUZQUzsKKyAgICAgICAgLy8gQ2hhbmdlIHdpdGggY2F1 dGlvbiAtIG51bWVyaWNzLiBodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL1N0YW5kYXJkX2Rl dmlhdGlvbgorICAgICAgICBtX2F2ZXJhZ2VGUFMgPSBtX2F2ZXJhZ2VGUFMgKyBkZWx0YUZyb21B dmVyYWdlIC8gbV9hdmVyYWdlRlBTQ291bnQ7CisgICAgICAgIG1fdmFyaWFuY2VOdW1lcmF0b3Ig PSBtX3ZhcmlhbmNlTnVtZXJhdG9yICsgZGVsdGFGcm9tQXZlcmFnZSAqICh4IC0gbV9hdmVyYWdl RlBTKTsKKyAgICB9CiAKICAgICAvLyBDcmVhdGUgJiBtZWFzdXJlIEZQUyB0ZXh0LgotICAgIFN0 cmluZyB0ZXh0KFN0cmluZzo6Zm9ybWF0KCJGUFM6ICU1LjFmIiwgMS4wIC8gbV9maWx0ZXJlZEZy YW1lVGltZSkpOwotICAgIFRleHRSdW4gcnVuKHRleHQpOwotICAgIGZsb2F0IHRleHRXaWR0aCA9 IG1fbWVkaXVtRm9udC0+d2lkdGgocnVuKSArIDIuMGY7CisgICAgZG91YmxlIHN0ZERldmlhdGlv biA9IHNxcnQobV92YXJpYW5jZU51bWVyYXRvciAvIG1fYXZlcmFnZUZQU0NvdW50KTsKKyAgICBT dHJpbmcgZnBzKFN0cmluZzo6Zm9ybWF0KCJGUFM6ICU0LjFmICsvLSUzLjFmIiwgbV9hdmVyYWdl RlBTLCBzdGREZXZpYXRpb24pKTsKKyAgICBUZXh0UnVuIHRleHQoZnBzKTsKKyAgICBmbG9hdCB0 ZXh0V2lkdGggPSBtX21lZGl1bUZvbnQtPndpZHRoKHRleHQpICsgMi4wZjsKICAgICBmbG9hdCBn cmFwaFdpZHRoID0ga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZTsKIAogICAgIC8vIERyYXcgYmFja2dy b3VuZC4KICAgICBjdHgtPnNldEZpbGxDb2xvcihDb2xvcigwLCAwLCAwLCAyNTUpLCBDb2xvclNw YWNlRGV2aWNlUkdCKTsKLSAgICBjdHgtPmZpbGxSZWN0KEZsb2F0UmVjdCgyLCB0b3AsIHRleHRX aWR0aCArIGdyYXBoV2lkdGgsIGhlaWdodCkpOworICAgIGRvdWJsZSBmb250SGVpZ2h0ID0gbV9t ZWRpdW1Gb250LT5mb250TWV0cmljcygpLmZsb2F0SGVpZ2h0KCkgKyAyOworICAgIGN0eC0+Zmls bFJlY3QoRmxvYXRSZWN0KDIsIHRvcCwgdGV4dFdpZHRoLCBmb250SGVpZ2h0KSk7CisgICAgY3R4 LT5maWxsUmVjdChGbG9hdFJlY3QoMiArIHRleHRXaWR0aCwgdG9wLCBncmFwaFdpZHRoLCBoZWln aHQpKTsKIAogICAgIC8vIERyYXcgRlBTIHRleHQuCi0gICAgaWYgKG1fZmlsdGVyZWRGcmFtZVRp bWUpIHsKLSAgICAgICAgY3R4LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JT cGFjZURldmljZVJHQik7Ci0gICAgICAgIGN0eC0+ZHJhd1RleHQoKm1fbWVkaXVtRm9udCwgcnVu LCBJbnRQb2ludCgzLCB0b3AgKyBoZWlnaHQgLSA2KSk7Ci0gICAgfQorICAgIGN0eC0+c2V0Rmls bENvbG9yKENvbG9yKDIwMCwgMjAwLCAyMDApLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBj dHgtPmRyYXdUZXh0KCptX21lZGl1bUZvbnQsIHRleHQsIEludFBvaW50KDMsIHRvcCArIGZvbnRI ZWlnaHQgLSA0KSk7CiAKICAgICAvLyBEcmF3IEZQUyBncmFwaC4KICAgICBjb25zdCBkb3VibGUg bG9GUFMgPSAwLjA7Ci0gICAgY29uc3QgZG91YmxlIGhpRlBTID0gMTIwLjA7CisgICAgY29uc3Qg ZG91YmxlIGhpRlBTID0gODAuMDsKICAgICBjdHgtPnNldFN0cm9rZVN0eWxlKFNvbGlkU3Ryb2tl KTsKKyAgICBjdHgtPnNldEZpbGxDb2xvcihDb2xvcigxNTQsIDIwNSwgNTApLCBDb2xvclNwYWNl RGV2aWNlUkdCKTsKKyAgICBjdHgtPmZpbGxSZWN0KEZsb2F0UmVjdCgyICsgdGV4dFdpZHRoLCB0 b3AsIGdyYXBoV2lkdGgsIGhlaWdodCAvIDIpKTsKKyAgICBjdHgtPnNldEZpbGxDb2xvcihDb2xv cigyNTUsIDI1MCwgMjA1KSwgQ29sb3JTcGFjZURldmljZVJHQik7CisgICAgY3R4LT5maWxsUmVj dChGbG9hdFJlY3QoMiArIHRleHRXaWR0aCwgdG9wICsgaGVpZ2h0IC8gMiwgZ3JhcGhXaWR0aCwg aGVpZ2h0IC8gMikpOwogICAgIGN0eC0+c2V0U3Ryb2tlQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwg Q29sb3JTcGFjZURldmljZVJHQik7CisgICAgY3R4LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAw LCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CiAgICAgaW50IGdyYXBoTGVmdCA9IHN0YXRpY19j YXN0PGludD4odGV4dFdpZHRoICsgMyk7CiAgICAgSW50UG9pbnQgcHJldigtMSwgMCk7CiAgICAg aW50IHggPSAwOwpAQCAtMjI4LDE1ICsyNTksMTcgQEAgdm9pZCBDQ0hlYWRzVXBEaXNwbGF5Ojpk cmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRleHQqIGN0eCwgaW50IHRvcCwgaW50IGhlaWdodCkK ICAgICBmb3IgKGludCBpID0gbV9jdXJyZW50RnJhbWVOdW1iZXIgJSBrQmVnaW5GcmFtZUhpc3Rv cnlTaXplOyBpICE9IChtX2N1cnJlbnRGcmFtZU51bWJlciAtIDEpICUga0JlZ2luRnJhbWVIaXN0 b3J5U2l6ZTsgaSA9IChpICsgMSkgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplKSB7CiAgICAgICAg IGludCBqID0gKGkgKyAxKSAlIGtCZWdpbkZyYW1lSGlzdG9yeVNpemU7CiAgICAgICAgIGRvdWJs ZSBmcHMgPSAxLjAgLyAobV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbal0gLSBtX2JlZ2luVGltZUhp c3RvcnlJblNlY1tpXSk7Ci0gICAgICAgIGRvdWJsZSBwID0gMSAtICgoZnBzIC0gbG9GUFMpIC8g KGhpRlBTIC0gbG9GUFMpKTsKLSAgICAgICAgaWYgKHAgPCAwKQotICAgICAgICAgICAgcCA9IDA7 Ci0gICAgICAgIGlmIChwID4gMSkKLSAgICAgICAgICAgIHAgPSAxOwotICAgICAgICBJbnRQb2lu dCBjdXIoZ3JhcGhMZWZ0ICsgeCwgMSArIHRvcCArIHAqaCk7Ci0gICAgICAgIGlmIChwcmV2Lngo KSAhPSAtMSkKLSAgICAgICAgICAgIGN0eC0+ZHJhd0xpbmUocHJldiwgY3VyKTsKLSAgICAgICAg cHJldiA9IGN1cjsKKyAgICAgICAgaWYgKCFtX2JhZEZyYW1lW2pdKSB7CisgICAgICAgICAgICBk b3VibGUgcCA9IDEgLSAoKGZwcyAtIGxvRlBTKSAvIChoaUZQUyAtIGxvRlBTKSk7CisgICAgICAg ICAgICBpZiAocCA8IDApCisgICAgICAgICAgICAgICAgcCA9IDA7CisgICAgICAgICAgICBpZiAo cCA+IDEpCisgICAgICAgICAgICAgICAgcCA9IDE7CisgICAgICAgICAgICBJbnRQb2ludCBjdXIo Z3JhcGhMZWZ0ICsgeCwgMSArIHRvcCArIHAqaCk7CisgICAgICAgICAgICBpZiAocHJldi54KCkg IT0gLTEpCisgICAgICAgICAgICAgICAgY3R4LT5kcmF3TGluZShwcmV2LCBjdXIpOworICAgICAg ICAgICAgcHJldiA9IGN1cjsKKyAgICAgICAgfQogICAgICAgICB4ICs9IDE7CiAgICAgfQogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NIZWFkc1VwRGlzcGxheS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oCmluZGV4IDA1Y2IyMGQ1MjY5Nzk4NTkyNjhlNDE3 NzRmY2FhNGE0Y2UxYmEyYTQuLmIyYTNmZjUxNWU1ODhlMTZhNjIwY2ZjYTNhMmNmMTU0ZTUzMzE3 M2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L2NjL0NDSGVhZHNVcERpc3BsYXkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmgKQEAgLTY5LDE0ICs2OSwyNSBAQCBw cml2YXRlOgogCiAgICAgaW50IG1fY3VycmVudEZyYW1lTnVtYmVyOwogCi0gICAgZG91YmxlIG1f ZmlsdGVyZWRGcmFtZVRpbWU7CisgICAgZG91YmxlIG1fYXZlcmFnZUZQUzsKKyAgICBpbnQgbV9h dmVyYWdlRlBTQ291bnQ7CisgICAgZG91YmxlIG1fdmFyaWFuY2VOdW1lcmF0b3I7CiAKICAgICBP d25QdHI8TWFuYWdlZFRleHR1cmU+IG1faHVkVGV4dHVyZTsKIAogICAgIExheWVyUmVuZGVyZXJD aHJvbWl1bSogbV9sYXllclJlbmRlcmVyOwogCiAgICAgc3RhdGljIGNvbnN0IGludCBrQmVnaW5G cmFtZUhpc3RvcnlTaXplID0gNjQ7CisgICAgLy8gVGhlIG51bWJlciBvZiBzZWNvbmRzIG9mIG5v IGZyYW1lcyBtYWtlcyB1cyBkZWNpZGUgdGhhdCB0aGUgcHJldmlvdXMKKyAgICAvLyBhbmltYXRp b24gaXMgb3Zlci4KKyAgICBzdGF0aWMgY29uc3QgZG91YmxlIGtJZGxlU2Vjb25kc1RyaWdnZXJz UmVzZXQgPSAwLjU7CisgICAgLy8gVGhlIG51bWJlciBvZiBmcmFtZXMgdGhhdCBjYXVzZSB1cyB0 byByZXNldCB0aGUgRlBTIHN0YXRpc3RpY3Mgc28gdGhhdAorICAgIC8vIHRoZSBhdmVyYWdlIG9m IHppbGxpb25zIG9mIGZyYW1lcyBkb2Vzbid0IGRyb3duIG91dCBhIG1vbWVudGFyeSBqYW5rLgor ICAgIHN0YXRpYyBjb25zdCBpbnQga0xvbmdBbmltYXRpb25UcmlnZ2Vyc1Jlc2V0ID0gNjAqMjsK ICAgICBkb3VibGUgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNba0JlZ2luRnJhbWVIaXN0b3J5U2l6 ZV07CisgICAgYm9vbCBtX2JhZEZyYW1lW2tCZWdpbkZyYW1lSGlzdG9yeVNpemVdOworICAgIHN0 YXRpYyBjb25zdCBkb3VibGUga0ZyYW1lVG9vRmFzdCA9IDEuMCAvIDcwOworICAgIHN0YXRpYyBj b25zdCBkb3VibGUga0ZyYW1lVG9vU2xvdyA9IDUuMCAvIDYwOwogCiAgICAgT3duUHRyPEZvbnQ+ IG1fc21hbGxGb250OwogICAgIE93blB0cjxGb250PiBtX21lZGl1bUZvbnQ7Cg== 125159 2012-02-02 12:14:42 -0800 2012-03-06 21:04:21 -0800 Patch bug-73454-20120202151440.patch text/plain 11812 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NDE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWE4MDdjYTlhNjEwMzk2 OGUwNWYwMzM0M2M5ZjVhMDU5ODMzZmYxZi4uZDk1Mjk4MTNiZTg4ZDZlNWI1NDMxMTMzZTEyZjQ5 NmIzNmE2MGM1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTAyLTAxICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBzbyB0aGF0IG91dGxpZXIgZGF0YSBwb2lu dHMgYXJlIGxhYmVsbGVkIHdpdGggdGhlaXIKKyAgICAgICAgZnJhbWUgcmF0ZSBzbyB0aGF0IHlv dSBjYW4gc2VlIGhvdyBzbG93IHRoZSBmcmFtZSBpcyB0aGF0IGlzCisgICAgICAgIGNhdXNpbmcg dGhlIGphbms7IGFuZCB0byBrZWVwIHN0YXRpc3RpY3Mgb24gZnJhbWUgcmF0ZSBiZXR3ZWVuCisg ICAgICAgIHBhdXNlcyBpbiB0aGUgYWN0aXZpdHkgaW4gdGhlIFVJIHNvIHRoYXQgeW91IGNhbiB0 cmlnZ2VyIGEKKyAgICAgICAgdHJhbnNpdGlvbiBhbmQgcmVhZCBvZmYgdGhlIGF2ZXJhZ2UgYW5k IHN0YW5kYXJkIGRldmlhdGlvbiBmb3IKKyAgICAgICAgdGhhdCB0cmFuc2l0aW9uIHRvIGp1ZGdl IGl0IHNtb290aCBlbm91Z2ggb3Igbm90LgorCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgSFVEIGlzIG5vdCB0ZXN0YWJsZSBpbiB3ZWJraXQuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OkNDSGVhZHNVcERpc3BsYXkp OgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6b25GcmFtZUJlZ2luKToKKyAg ICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OmRyYXdIdWRDb250ZW50cyk6CisgICAg ICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcik6CisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oOgorCiAy MDEyLTAxLTMxICBBZGFtIEtsZWluICA8YWRhbWtAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFBy b2Nlc3NpbmdJbnN0cnVjdGlvbiBzaG91bGQgbm90IGJlIGEgQ29udGFpbmVyTm9kZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFk c1VwRGlzcGxheS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAppbmRleCA3MDhiY2ZmODgwMWI3ODg4MTA2MGI1Mjk4 NThiMjg5Yjk1MzI4YWVjLi5iOWI2NDE2ODg0MjhmNTEwMWU2MjljZDRiZjcxMDA5NDIzMjY0NGQ3 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcApAQCAtNDksNyArNDksOSBAQCB1 c2luZyBuYW1lc3BhY2Ugc3RkOwogCiBDQ0hlYWRzVXBEaXNwbGF5OjpDQ0hlYWRzVXBEaXNwbGF5 KExheWVyUmVuZGVyZXJDaHJvbWl1bSogb3duZXIpCiAgICAgOiBtX2N1cnJlbnRGcmFtZU51bWJl cigxKQotICAgICwgbV9maWx0ZXJlZEZyYW1lVGltZSgwKQorICAgICwgbV9hdmVyYWdlRlBTKDAp CisgICAgLCBtX2F2ZXJhZ2VGUFNDb3VudCgwKQorICAgICwgbV92YXJpYW5jZU51bWVyYXRvcigw KQogICAgICwgbV9sYXllclJlbmRlcmVyKG93bmVyKQogICAgICwgbV91c2VNYXBTdWJGb3JVcGxv YWRzKG93bmVyLT5jb250ZXh0U3VwcG9ydHNNYXBTdWIoKSkKIHsKQEAgLTYwLDcgKzYyLDcgQEAg Q0NIZWFkc1VwRGlzcGxheTo6Q0NIZWFkc1VwRGlzcGxheShMYXllclJlbmRlcmVyQ2hyb21pdW0q IG93bmVyKQogCiAgICAgRm9udERlc2NyaXB0aW9uIG1lZGl1bUZvbnREZXNjOwogICAgIG1lZGl1 bUZvbnREZXNjLnNldEdlbmVyaWNGYW1pbHkoRm9udERlc2NyaXB0aW9uOjpNb25vc3BhY2VGYW1p bHkpOwotICAgIG1lZGl1bUZvbnREZXNjLnNldENvbXB1dGVkU2l6ZSgyMCk7CisgICAgbWVkaXVt Rm9udERlc2Muc2V0Q29tcHV0ZWRTaXplKDEyKTsKIAogICAgIG1fbWVkaXVtRm9udCA9IGFkb3B0 UHRyKG5ldyBGb250KG1lZGl1bUZvbnREZXNjLCAwLCAwKSk7CiAgICAgbV9tZWRpdW1Gb250LT51 cGRhdGUoMCk7CkBAIC03Nyw5ICs3OSwxMyBAQCBDQ0hlYWRzVXBEaXNwbGF5Ojp+Q0NIZWFkc1Vw RGlzcGxheSgpCiB7CiB9CiAKKy8vIFNBRkVfTU9EIHdvcmtzIG9uIC0xLCByZXR1cm5pbmcgbS0x IGluIHRoYXQgY2FzZS4KKyNkZWZpbmUgU0FGRV9NT0QobiwgbSkgKCgobikgKyAobSkpICUgKG0p KQorI2RlZmluZSBGUkFNRV9JTkRFWChmcmFtZSkgU0FGRV9NT0QoZnJhbWUsIGtCZWdpbkZyYW1l SGlzdG9yeVNpemUpCisKIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6b25GcmFtZUJlZ2luKGRvdWJs ZSB0aW1lc3RhbXApCiB7Ci0gICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbbV9jdXJyZW50RnJh bWVOdW1iZXIgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplXSA9IHRpbWVzdGFtcDsKKyAgICBtX2Jl Z2luVGltZUhpc3RvcnlJblNlY1tGUkFNRV9JTkRFWChtX2N1cnJlbnRGcmFtZU51bWJlcildID0g dGltZXN0YW1wOwogfQogCiB2b2lkIENDSGVhZHNVcERpc3BsYXk6Om9uU3dhcEJ1ZmZlcnMoKQpA QCAtMTYxLDYgKzE2NywxNSBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXcoKQogICAgIG1f aHVkVGV4dHVyZS0+dW5yZXNlcnZlKCk7CiB9CiAKK2Jvb2wgQ0NIZWFkc1VwRGlzcGxheTo6aXNC YWRGcmFtZShpbnQgZnJhbWVOdW1iZXIpIGNvbnN0Cit7CisgICAgZG91YmxlIGRlbHRhID0gbV9i ZWdpblRpbWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgoZnJhbWVOdW1iZXIpXSAtCisgICAgICAg ICAgICAgICAgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbRlJBTUVfSU5ERVgoZnJhbWVOdW1i ZXIgLSAxKV07CisgICAgYm9vbCB0b29TbG93ID0gZGVsdGEgPiBrRnJhbWVUb29TbG93OworICAg IGJvb2wgYlNjaGVkdWxlckFsbG93c0RvdWJsZUZyYW1lcyA9ICFDQ1Byb3h5OjpoYXNJbXBsVGhy ZWFkKCk7CisgICAgcmV0dXJuIChiU2NoZWR1bGVyQWxsb3dzRG91YmxlRnJhbWVzICYmIGRlbHRh IDwga0ZyYW1lVG9vRmFzdCkgfHwgdG9vU2xvdzsKK30KKwogdm9pZCBDQ0hlYWRzVXBEaXNwbGF5 OjpkcmF3SHVkQ29udGVudHMoR3JhcGhpY3NDb250ZXh0KiBjdHgsIGNvbnN0IEludFNpemUmIGh1 ZFNpemUpCiB7CiAgICAgRm9udENhY2hlUHVyZ2VQcmV2ZW50ZXIgZm9udENhY2hlUHVyZ2VQcmV2 ZW50ZXI7CkBAIC0xNzAsMTEgKzE4NSwxMSBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXdI dWRDb250ZW50cyhHcmFwaGljc0NvbnRleHQqIGN0eCwgY29uc3QgSW50U2l6ZSYgaHVkUwogICAg ICAgICBjdHgtPmZpbGxSZWN0KEZsb2F0UmVjdCgwLCAwLCBodWRTaXplLndpZHRoKCksIGh1ZFNp emUuaGVpZ2h0KCkpKTsKICAgICB9CiAKLSAgICBpbnQgZnBzQ291bnRlckhlaWdodCA9IG1fbWVk aXVtRm9udC0+Zm9udE1ldHJpY3MoKS5mbG9hdEhlaWdodCgpICsgMjsKKyAgICBpbnQgZnBzQ291 bnRlckhlaWdodCA9IG1fbWVkaXVtRm9udC0+Zm9udE1ldHJpY3MoKS5mbG9hdEhlaWdodCgpICsg NDA7CiAgICAgaW50IGZwc0NvdW50ZXJUb3AgPSAyOwogICAgIGludCBwbGF0Zm9ybUxheWVyVHJl ZVRvcDsKICAgICBpZiAoc2V0dGluZ3MoKS5zaG93RlBTQ291bnRlcikKLSAgICAgICAgcGxhdGZv cm1MYXllclRyZWVUb3AgPSBmcHNDb3VudGVyVG9wICsgZnBzQ291bnRlckhlaWdodCArIDI7Cisg ICAgICAgIHBsYXRmb3JtTGF5ZXJUcmVlVG9wID0gZnBzQ291bnRlclRvcCArIGZwc0NvdW50ZXJI ZWlnaHQ7CiAgICAgZWxzZQogICAgICAgICBwbGF0Zm9ybUxheWVyVHJlZVRvcCA9IDA7CiAKQEAg LTE4OSwzOCArMjA0LDU5IEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0ZQU0NvdW50ZXIo R3JhcGhpY3NDb250ZXh0KiBjdHgsIGludCB0b3AsIGludCBoZWlnaHQpCiB7CiAgICAgLy8gTm90 ZSB0aGF0IHNpbmNlIHdlIGhhdmVuJ3QgZmluaXNoZWQgdGhlIGN1cnJlbnQgZnJhbWUsIHRoZSBG UFMgY291bnRlcgogICAgIC8vIGFjdHVhbGx5IHJlcG9ydHMgdGhlIGxhc3QgZnJhbWUncyB0aW1l LgotICAgIGRvdWJsZSBzZWNGb3JMYXN0RnJhbWUgPSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1so bV9jdXJyZW50RnJhbWVOdW1iZXIgKyBrQmVnaW5GcmFtZUhpc3RvcnlTaXplIC0gMSkgJSBrQmVn aW5GcmFtZUhpc3RvcnlTaXplXSAtCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fYmVn aW5UaW1lSGlzdG9yeUluU2VjWyhtX2N1cnJlbnRGcmFtZU51bWJlciArIGtCZWdpbkZyYW1lSGlz dG9yeVNpemUgLSAyKSAlIGtCZWdpbkZyYW1lSGlzdG9yeVNpemVdOwotCi0gICAgLy8gRmlsdGVy IHRoZSBmcmFtZSB0aW1lcyB0byBhdm9pZCBzcGlrZXMuCi0gICAgY29uc3QgZmxvYXQgYWxwaGEg PSAwLjE7Ci0gICAgaWYgKCFtX2ZpbHRlcmVkRnJhbWVUaW1lKSB7Ci0gICAgICAgIGlmIChtX2N1 cnJlbnRGcmFtZU51bWJlciA9PSAyKQotICAgICAgICAgICAgbV9maWx0ZXJlZEZyYW1lVGltZSA9 IHNlY0Zvckxhc3RGcmFtZTsKLSAgICB9IGVsc2UKLSAgICAgICAgbV9maWx0ZXJlZEZyYW1lVGlt ZSA9ICgoMS4wIC0gYWxwaGEpICogbV9maWx0ZXJlZEZyYW1lVGltZSkgKyAoYWxwaGEgKiBzZWNG b3JMYXN0RnJhbWUpOworICAgIGRvdWJsZSBzZWNGb3JMYXN0RnJhbWUgPSBtX2JlZ2luVGltZUhp c3RvcnlJblNlY1tGUkFNRV9JTkRFWChtX2N1cnJlbnRGcmFtZU51bWJlciAtIDEpXSAtCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW0ZSQU1FX0lO REVYKG1fY3VycmVudEZyYW1lTnVtYmVyIC0gMildOworICAgIGRvdWJsZSBzZWNGb3JUaGlyZExh c3RGcmFtZSA9IG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW0ZSQU1FX0lOREVYKG1fY3VycmVudEZy YW1lTnVtYmVyIC0gMyldIC0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX2Jl Z2luVGltZUhpc3RvcnlJblNlY1tGUkFNRV9JTkRFWChtX2N1cnJlbnRGcmFtZU51bWJlciAtIDQp XTsKKworICAgIC8vIEZpbHRlciB0aGUgZnJhbWUgdGltZXMgdG8gYXZvaWQgc3Bpa2VzLiBTcGVj aWZpY2FsbHksIGtlZXAgYSBydW5uaW5nCisgICAgLy8gYXZlcmFnZSBmcmFtZSByYXRlIGFuZCBh IHJ1bm5pbmcgdmFyaWFuY2Ugd2hpbGUgaWdub3JpbmcgYmFkIGZyYW1lcworICAgIC8vIHdoaWNo IGFyZSBlaXRoZXIgdG9vIHNsb3cgb3IgdG9vIGZhc3QuIFNsb3cgZnJhbWVzIG9jY3VyIGp1c3Qg YmVjYXVzZQorICAgIC8vIHRoZSB1c2VyIGlzIGluYWN0aXZlLCBhbmQgc2hvdWxkIGJlIGlnbm9y ZWQuIEZhc3QgZnJhbWVzIGFyZSBpZ25vcmVkIGlmCisgICAgLy8gdGhlIHNjaGVkdWxlciBpcyBu b3QgYWN0aXZlIGluIG9yZGVyIHRvIHJlcHJlc2VudCB0aGUgdHJ1ZSBmcmFtZSByYXRlIGluCisg ICAgLy8gc3BpdGUgb2YgdGhlIGZhY3QgdGhhdCB0aGUgZmlyc3QgZmV3IHN3YXBidWZmZXJzIGhh cHBlbiBpbnN0YW50bHkgd2hpY2gKKyAgICAvLyBza2V3cyB0aGUgc3RhdGlzdGljcyB0b28gbXVj aCBmb3Igc2hvcnQgbGl2ZWQgYW5pbWF0aW9ucy4KKyAgICBpZiAoc2VjRm9yVGhpcmRMYXN0RnJh bWUgPiBrSWRsZVNlY29uZHNUcmlnZ2Vyc1Jlc2V0IHx8IG1fYXZlcmFnZUZQU0NvdW50ID4ga0xv bmdBbmltYXRpb25UcmlnZ2Vyc1Jlc2V0KSB7CisgICAgICAgIC8vIHJlc3RhcnQgdGhlIGZyYW1l IHN0YXRpc3RpY3MKKyAgICAgICAgbV9hdmVyYWdlRlBTID0gMDsKKyAgICAgICAgbV9hdmVyYWdl RlBTQ291bnQgPSAwOworICAgICAgICBtX3ZhcmlhbmNlTnVtZXJhdG9yID0gMDsKKyAgICB9IGVs c2UgaWYgKCFpc0JhZEZyYW1lKG1fY3VycmVudEZyYW1lTnVtYmVyIC0gMSkpIHsKKyAgICAgICAg bV9hdmVyYWdlRlBTQ291bnQrKzsKKyAgICAgICAgZG91YmxlIHggPSAxLjAgLyBzZWNGb3JMYXN0 RnJhbWU7CisgICAgICAgIGRvdWJsZSBkZWx0YUZyb21BdmVyYWdlID0geCAtIG1fYXZlcmFnZUZQ UzsKKyAgICAgICAgLy8gQ2hhbmdlIHdpdGggY2F1dGlvbiAtIG51bWVyaWNzLiBodHRwOi8vZW4u d2lraXBlZGlhLm9yZy93aWtpL1N0YW5kYXJkX2RldmlhdGlvbgorICAgICAgICBtX2F2ZXJhZ2VG UFMgPSBtX2F2ZXJhZ2VGUFMgKyBkZWx0YUZyb21BdmVyYWdlIC8gbV9hdmVyYWdlRlBTQ291bnQ7 CisgICAgICAgIG1fdmFyaWFuY2VOdW1lcmF0b3IgPSBtX3ZhcmlhbmNlTnVtZXJhdG9yICsgZGVs dGFGcm9tQXZlcmFnZSAqICh4IC0gbV9hdmVyYWdlRlBTKTsKKyAgICB9CiAKICAgICAvLyBDcmVh dGUgJiBtZWFzdXJlIEZQUyB0ZXh0LgotICAgIFN0cmluZyB0ZXh0KFN0cmluZzo6Zm9ybWF0KCJG UFM6ICU1LjFmIiwgMS4wIC8gbV9maWx0ZXJlZEZyYW1lVGltZSkpOwotICAgIFRleHRSdW4gcnVu KHRleHQpOwotICAgIGZsb2F0IHRleHRXaWR0aCA9IG1fbWVkaXVtRm9udC0+d2lkdGgocnVuKSAr IDIuMGY7CisgICAgZG91YmxlIHN0ZERldmlhdGlvbiA9IHNxcnQobV92YXJpYW5jZU51bWVyYXRv ciAvIG1fYXZlcmFnZUZQU0NvdW50KTsKKyAgICBTdHJpbmcgZnBzKFN0cmluZzo6Zm9ybWF0KCJG UFM6ICU0LjFmICsvLSUzLjFmIiwgbV9hdmVyYWdlRlBTLCBzdGREZXZpYXRpb24pKTsKKyAgICBU ZXh0UnVuIHRleHQoZnBzKTsKKyAgICBmbG9hdCB0ZXh0V2lkdGggPSBtX21lZGl1bUZvbnQtPndp ZHRoKHRleHQpICsgMi4wZjsKICAgICBmbG9hdCBncmFwaFdpZHRoID0ga0JlZ2luRnJhbWVIaXN0 b3J5U2l6ZTsKIAogICAgIC8vIERyYXcgYmFja2dyb3VuZC4KICAgICBjdHgtPnNldEZpbGxDb2xv cihDb2xvcigwLCAwLCAwLCAyNTUpLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKLSAgICBjdHgtPmZp bGxSZWN0KEZsb2F0UmVjdCgyLCB0b3AsIHRleHRXaWR0aCArIGdyYXBoV2lkdGgsIGhlaWdodCkp OworICAgIGRvdWJsZSBmb250SGVpZ2h0ID0gbV9tZWRpdW1Gb250LT5mb250TWV0cmljcygpLmZs b2F0SGVpZ2h0KCkgKyAyOworICAgIGN0eC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIsIHRvcCwgdGV4 dFdpZHRoLCBmb250SGVpZ2h0KSk7CisgICAgY3R4LT5maWxsUmVjdChGbG9hdFJlY3QoMiArIHRl eHRXaWR0aCwgdG9wLCBncmFwaFdpZHRoLCBoZWlnaHQpKTsKIAogICAgIC8vIERyYXcgRlBTIHRl eHQuCi0gICAgaWYgKG1fZmlsdGVyZWRGcmFtZVRpbWUpIHsKLSAgICAgICAgY3R4LT5zZXRGaWxs Q29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7Ci0gICAgICAgIGN0 eC0+ZHJhd1RleHQoKm1fbWVkaXVtRm9udCwgcnVuLCBJbnRQb2ludCgzLCB0b3AgKyBoZWlnaHQg LSA2KSk7Ci0gICAgfQorICAgIGN0eC0+c2V0RmlsbENvbG9yKENvbG9yKDIwMCwgMjAwLCAyMDAp LCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjdHgtPmRyYXdUZXh0KCptX21lZGl1bUZvbnQs IHRleHQsIEludFBvaW50KDMsIHRvcCArIGZvbnRIZWlnaHQgLSA0KSk7CiAKICAgICAvLyBEcmF3 IEZQUyBncmFwaC4KICAgICBjb25zdCBkb3VibGUgbG9GUFMgPSAwLjA7Ci0gICAgY29uc3QgZG91 YmxlIGhpRlBTID0gMTIwLjA7CisgICAgY29uc3QgZG91YmxlIGhpRlBTID0gODAuMDsKICAgICBj dHgtPnNldFN0cm9rZVN0eWxlKFNvbGlkU3Ryb2tlKTsKKyAgICBjdHgtPnNldEZpbGxDb2xvcihD b2xvcigxNTQsIDIwNSwgNTApLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjdHgtPmZpbGxS ZWN0KEZsb2F0UmVjdCgyICsgdGV4dFdpZHRoLCB0b3AsIGdyYXBoV2lkdGgsIGhlaWdodCAvIDIp KTsKKyAgICBjdHgtPnNldEZpbGxDb2xvcihDb2xvcigyNTUsIDI1MCwgMjA1KSwgQ29sb3JTcGFj ZURldmljZVJHQik7CisgICAgY3R4LT5maWxsUmVjdChGbG9hdFJlY3QoMiArIHRleHRXaWR0aCwg dG9wICsgaGVpZ2h0IC8gMiwgZ3JhcGhXaWR0aCwgaGVpZ2h0IC8gMikpOwogICAgIGN0eC0+c2V0 U3Ryb2tlQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CisgICAg Y3R4LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7 CiAgICAgaW50IGdyYXBoTGVmdCA9IHN0YXRpY19jYXN0PGludD4odGV4dFdpZHRoICsgMyk7CiAg ICAgSW50UG9pbnQgcHJldigtMSwgMCk7CiAgICAgaW50IHggPSAwOwpAQCAtMjI4LDE1ICsyNjQs MTcgQEAgdm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRl eHQqIGN0eCwgaW50IHRvcCwgaW50IGhlaWdodCkKICAgICBmb3IgKGludCBpID0gbV9jdXJyZW50 RnJhbWVOdW1iZXIgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOyBpICE9IChtX2N1cnJlbnRGcmFt ZU51bWJlciAtIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZTsgaSA9IChpICsgMSkgJSBrQmVn aW5GcmFtZUhpc3RvcnlTaXplKSB7CiAgICAgICAgIGludCBqID0gKGkgKyAxKSAlIGtCZWdpbkZy YW1lSGlzdG9yeVNpemU7CiAgICAgICAgIGRvdWJsZSBmcHMgPSAxLjAgLyAobV9iZWdpblRpbWVI aXN0b3J5SW5TZWNbal0gLSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tpXSk7Ci0gICAgICAgIGRv dWJsZSBwID0gMSAtICgoZnBzIC0gbG9GUFMpIC8gKGhpRlBTIC0gbG9GUFMpKTsKLSAgICAgICAg aWYgKHAgPCAwKQotICAgICAgICAgICAgcCA9IDA7Ci0gICAgICAgIGlmIChwID4gMSkKLSAgICAg ICAgICAgIHAgPSAxOwotICAgICAgICBJbnRQb2ludCBjdXIoZ3JhcGhMZWZ0ICsgeCwgMSArIHRv cCArIHAqaCk7Ci0gICAgICAgIGlmIChwcmV2LngoKSAhPSAtMSkKLSAgICAgICAgICAgIGN0eC0+ ZHJhd0xpbmUocHJldiwgY3VyKTsKLSAgICAgICAgcHJldiA9IGN1cjsKKyAgICAgICAgaWYgKCFp c0JhZEZyYW1lKGopKSB7CisgICAgICAgICAgICBkb3VibGUgcCA9IDEgLSAoKGZwcyAtIGxvRlBT KSAvIChoaUZQUyAtIGxvRlBTKSk7CisgICAgICAgICAgICBpZiAocCA8IDApCisgICAgICAgICAg ICAgICAgcCA9IDA7CisgICAgICAgICAgICBpZiAocCA+IDEpCisgICAgICAgICAgICAgICAgcCA9 IDE7CisgICAgICAgICAgICBJbnRQb2ludCBjdXIoZ3JhcGhMZWZ0ICsgeCwgMSArIHRvcCArIHAq aCk7CisgICAgICAgICAgICBpZiAocHJldi54KCkgIT0gLTEpCisgICAgICAgICAgICAgICAgY3R4 LT5kcmF3TGluZShwcmV2LCBjdXIpOworICAgICAgICAgICAgcHJldiA9IGN1cjsKKyAgICAgICAg fQogICAgICAgICB4ICs9IDE7CiAgICAgfQogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5o CmluZGV4IDA1Y2IyMGQ1MjY5Nzk4NTkyNjhlNDE3NzRmY2FhNGE0Y2UxYmEyYTQuLjM3Y2ViZGM1 NmIxZWMyOTE2YWMxYzQyZGYzNzllOGEzNDJkZWU5NTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDSGVhZHNVcERpc3BsYXkuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBE aXNwbGF5LmgKQEAgLTY2LDE3ICs2NiwyOCBAQCBwcml2YXRlOgogICAgIHZvaWQgZHJhd0ZQU0Nv dW50ZXIoR3JhcGhpY3NDb250ZXh0KiwgaW50IHRvcCwgaW50IGhlaWdodCk7CiAgICAgdm9pZCBk cmF3UGxhdGZvcm1MYXllclRyZWUoR3JhcGhpY3NDb250ZXh0KiwgaW50IHRvcCk7CiAgICAgY29u c3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MoKSBjb25zdDsKKyAgICBib29sIGlzQmFkRnJhbWUoaW50 IGZyYW1lTnVtYmVyKSBjb25zdDsKIAogICAgIGludCBtX2N1cnJlbnRGcmFtZU51bWJlcjsKIAot ICAgIGRvdWJsZSBtX2ZpbHRlcmVkRnJhbWVUaW1lOworICAgIGRvdWJsZSBtX2F2ZXJhZ2VGUFM7 CisgICAgaW50IG1fYXZlcmFnZUZQU0NvdW50OworICAgIGRvdWJsZSBtX3ZhcmlhbmNlTnVtZXJh dG9yOwogCiAgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBtX2h1ZFRleHR1cmU7CiAKICAgICBM YXllclJlbmRlcmVyQ2hyb21pdW0qIG1fbGF5ZXJSZW5kZXJlcjsKIAogICAgIHN0YXRpYyBjb25z dCBpbnQga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSA9IDY0OworICAgIC8vIFRoZSBudW1iZXIgb2Yg c2Vjb25kcyBvZiBubyBmcmFtZXMgbWFrZXMgdXMgZGVjaWRlIHRoYXQgdGhlIHByZXZpb3VzCisg ICAgLy8gYW5pbWF0aW9uIGlzIG92ZXIuCisgICAgc3RhdGljIGNvbnN0IGRvdWJsZSBrSWRsZVNl Y29uZHNUcmlnZ2Vyc1Jlc2V0ID0gMC41OworICAgIC8vIFRoZSBudW1iZXIgb2YgZnJhbWVzIHRo YXQgY2F1c2UgdXMgdG8gcmVzZXQgdGhlIEZQUyBzdGF0aXN0aWNzIHNvIHRoYXQKKyAgICAvLyB0 aGUgYXZlcmFnZSBvZiB6aWxsaW9ucyBvZiBmcmFtZXMgZG9lc24ndCBkcm93biBvdXQgYSBtb21l bnRhcnkgamFuay4KKyAgICBzdGF0aWMgY29uc3QgaW50IGtMb25nQW5pbWF0aW9uVHJpZ2dlcnNS ZXNldCA9IDYwKjI7CiAgICAgZG91YmxlIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2tCZWdpbkZy YW1lSGlzdG9yeVNpemVdOworICAgIHN0YXRpYyBjb25zdCBkb3VibGUga0ZyYW1lVG9vRmFzdCA9 IDEuMCAvIDcwOworICAgIHN0YXRpYyBjb25zdCBkb3VibGUga0ZyYW1lVG9vU2xvdyA9IDUuMCAv IDYwOwogCiAgICAgT3duUHRyPEZvbnQ+IG1fc21hbGxGb250OwogICAgIE93blB0cjxGb250PiBt X21lZGl1bUZvbnQ7Cg== 130531 2012-03-06 21:04:26 -0800 2012-03-06 21:37:12 -0800 Patch bug-73454-20120307000425.patch text/plain 11592 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTA5OTk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOTg1NjViZTA3NWE1MWU0 YmUzNGIzNWVjN2I5OGI5ZmQ0ZDE1MDE1MS4uYWVlNGMyZThkYzljMmM1MGY0ZTViZjQyOGE4ZWQz NzdjYWE2YTZhMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTAzLTA3ICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBzbyB0aGF0IG91dGxpZXIgZGF0YSBwb2lu dHMgYXJlIGxhYmVsbGVkIHdpdGggdGhlaXIKKyAgICAgICAgZnJhbWUgcmF0ZSBzbyB0aGF0IHlv dSBjYW4gc2VlIGhvdyBzbG93IHRoZSBmcmFtZSBpcyB0aGF0IGlzCisgICAgICAgIGNhdXNpbmcg dGhlIGphbms7IGFuZCB0byBrZWVwIHN0YXRpc3RpY3Mgb24gZnJhbWUgcmF0ZSBiZXR3ZWVuCisg ICAgICAgIHBhdXNlcyBpbiB0aGUgYWN0aXZpdHkgaW4gdGhlIFVJIHNvIHRoYXQgeW91IGNhbiB0 cmlnZ2VyIGEKKyAgICAgICAgdHJhbnNpdGlvbiBhbmQgcmVhZCBvZmYgdGhlIGF2ZXJhZ2UgYW5k IHN0YW5kYXJkIGRldmlhdGlvbiBmb3IKKyAgICAgICAgdGhhdCB0cmFuc2l0aW9uIHRvIGp1ZGdl IGl0IHNtb290aCBlbm91Z2ggb3Igbm90LgorCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgSFVEIGlzIG5vdCB0ZXN0YWJsZSBpbiB3ZWJraXQuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OkNDSGVhZHNVcERpc3BsYXkp OgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6b25GcmFtZUJlZ2luKToKKyAg ICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OmRyYXdIdWRDb250ZW50cyk6CisgICAg ICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcik6CisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oOgorCiAy MDEyLTAzLTA2ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgW2Nocm9taXVtXSBGaXggdGhyZWFkZWQgY29tcG9zaXRpbmcgaXNzdWVzIGluIFdlYkdMTGF5 ZXJDaHJvbWl1bSAoZXhjZXB0IGZvciBwcmludGluZykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDSGVhZHNVcERpc3BsYXkuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlz cGxheS5jcHAKaW5kZXggM2RkYzEyM2MwZjU5ODNiZDI0NTg4OTUxNDI3ZTQ0OTExOTAzOGFlYS4u Y2U2ZmI5MmQwYjJjY2U2YmZiNzdhYzRhNGY2NmEwOWE1YzI2NTljMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxh eS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NIZWFkc1VwRGlzcGxheS5jcHAKQEAgLTUwLDcgKzUwLDkgQEAgdXNpbmcgbmFtZXNwYWNlIHN0 ZDsKIAogQ0NIZWFkc1VwRGlzcGxheTo6Q0NIZWFkc1VwRGlzcGxheShMYXllclJlbmRlcmVyQ2hy b21pdW0qIG93bmVyKQogICAgIDogbV9jdXJyZW50RnJhbWVOdW1iZXIoMSkKLSAgICAsIG1fZmls dGVyZWRGcmFtZVRpbWUoMCkKKyAgICAsIG1fYXZlcmFnZUZQUygwKQorICAgICwgbV9hdmVyYWdl RlBTQ291bnQoMCkKKyAgICAsIG1fZnBzVmFyaWFuY2VOdW1lcmF0b3IoMCkKICAgICAsIG1fbGF5 ZXJSZW5kZXJlcihvd25lcikKICAgICAsIG1fdXNlTWFwU3ViRm9yVXBsb2Fkcyhvd25lci0+Y29u dGV4dFN1cHBvcnRzTWFwU3ViKCkpCiB7CkBAIC02MSw3ICs2Myw3IEBAIENDSGVhZHNVcERpc3Bs YXk6OkNDSGVhZHNVcERpc3BsYXkoTGF5ZXJSZW5kZXJlckNocm9taXVtKiBvd25lcikKIAogICAg IEZvbnREZXNjcmlwdGlvbiBtZWRpdW1Gb250RGVzYzsKICAgICBtZWRpdW1Gb250RGVzYy5zZXRH ZW5lcmljRmFtaWx5KEZvbnREZXNjcmlwdGlvbjo6TW9ub3NwYWNlRmFtaWx5KTsKLSAgICBtZWRp dW1Gb250RGVzYy5zZXRDb21wdXRlZFNpemUoMjApOworICAgIG1lZGl1bUZvbnREZXNjLnNldENv bXB1dGVkU2l6ZSgxMik7CiAKICAgICBtX21lZGl1bUZvbnQgPSBhZG9wdFB0cihuZXcgRm9udCht ZWRpdW1Gb250RGVzYywgMCwgMCkpOwogICAgIG1fbWVkaXVtRm9udC0+dXBkYXRlKDApOwpAQCAt NzgsOSArODAsMjAgQEAgQ0NIZWFkc1VwRGlzcGxheTo6fkNDSGVhZHNVcERpc3BsYXkoKQogewog fQogCisvLyBzYWZlTW9kIHdvcmtzIG9uIC0xLCByZXR1cm5pbmcgbS0xIGluIHRoYXQgY2FzZS4K K3N0YXRpYyBpbmxpbmUgaW50IHNhZmVNb2QoaW50IG51bWJlciwgaW50IG1vZHVsdXMpCit7Cisg ICAgcmV0dXJuIChudW1iZXIgKyBtb2R1bHVzKSAlIG1vZHVsdXM7Cit9CisKK2lubGluZSBpbnQg Q0NIZWFkc1VwRGlzcGxheTo6ZnJhbWVJbmRleChpbnQgZnJhbWUpIGNvbnN0Cit7CisgICAgcmV0 dXJuIHNhZmVNb2QoZnJhbWUsIGtCZWdpbkZyYW1lSGlzdG9yeVNpemUpOworfQorCiB2b2lkIEND SGVhZHNVcERpc3BsYXk6Om9uRnJhbWVCZWdpbihkb3VibGUgdGltZXN0YW1wKQogewotICAgIG1f YmVnaW5UaW1lSGlzdG9yeUluU2VjW21fY3VycmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVI aXN0b3J5U2l6ZV0gPSB0aW1lc3RhbXA7CisgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbZnJh bWVJbmRleChtX2N1cnJlbnRGcmFtZU51bWJlcildID0gdGltZXN0YW1wOwogfQogCiB2b2lkIEND SGVhZHNVcERpc3BsYXk6Om9uU3dhcEJ1ZmZlcnMoKQpAQCAtMTYyLDYgKzE3NSwxNSBAQCB2b2lk IENDSGVhZHNVcERpc3BsYXk6OmRyYXcoKQogICAgIG1faHVkVGV4dHVyZS0+dW5yZXNlcnZlKCk7 CiB9CiAKK2Jvb2wgQ0NIZWFkc1VwRGlzcGxheTo6aXNCYWRGcmFtZShpbnQgZnJhbWVOdW1iZXIp IGNvbnN0Cit7CisgICAgZG91YmxlIGRlbHRhID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbZnJh bWVJbmRleChmcmFtZU51bWJlcildIC0KKyAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhp c3RvcnlJblNlY1tmcmFtZUluZGV4KGZyYW1lTnVtYmVyIC0gMSldOworICAgIGJvb2wgdG9vU2xv dyA9IGRlbHRhID4gKGtOdW1NaXNzZWRGcmFtZXNGb3JSZXNldCAvIDYwLjApOworICAgIGJvb2wg c2NoZWR1bGVyQWxsb3dzRG91YmxlRnJhbWVzID0gIUNDUHJveHk6Omhhc0ltcGxUaHJlYWQoKTsK KyAgICByZXR1cm4gKHNjaGVkdWxlckFsbG93c0RvdWJsZUZyYW1lcyAmJiBkZWx0YSA8IGtGcmFt ZVRvb0Zhc3QpIHx8IHRvb1Nsb3c7Cit9CisKIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0h1 ZENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCogY3R4LCBjb25zdCBJbnRTaXplJiBodWRTaXplKQog ewogICAgIEZvbnRDYWNoZVB1cmdlUHJldmVudGVyIGZvbnRDYWNoZVB1cmdlUHJldmVudGVyOwpA QCAtMTcxLDExICsxOTMsMTEgQEAgdm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3SHVkQ29udGVu dHMoR3JhcGhpY3NDb250ZXh0KiBjdHgsIGNvbnN0IEludFNpemUmIGh1ZFMKICAgICAgICAgY3R4 LT5maWxsUmVjdChGbG9hdFJlY3QoMCwgMCwgaHVkU2l6ZS53aWR0aCgpLCBodWRTaXplLmhlaWdo dCgpKSk7CiAgICAgfQogCi0gICAgaW50IGZwc0NvdW50ZXJIZWlnaHQgPSBtX21lZGl1bUZvbnQt PmZvbnRNZXRyaWNzKCkuZmxvYXRIZWlnaHQoKSArIDI7CisgICAgaW50IGZwc0NvdW50ZXJIZWln aHQgPSBtX21lZGl1bUZvbnQtPmZvbnRNZXRyaWNzKCkuZmxvYXRIZWlnaHQoKSArIDQwOwogICAg IGludCBmcHNDb3VudGVyVG9wID0gMjsKICAgICBpbnQgcGxhdGZvcm1MYXllclRyZWVUb3A7CiAg ICAgaWYgKHNldHRpbmdzKCkuc2hvd0ZQU0NvdW50ZXIpCi0gICAgICAgIHBsYXRmb3JtTGF5ZXJU cmVlVG9wID0gZnBzQ291bnRlclRvcCArIGZwc0NvdW50ZXJIZWlnaHQgKyAyOworICAgICAgICBw bGF0Zm9ybUxheWVyVHJlZVRvcCA9IGZwc0NvdW50ZXJUb3AgKyBmcHNDb3VudGVySGVpZ2h0Owog ICAgIGVsc2UKICAgICAgICAgcGxhdGZvcm1MYXllclRyZWVUb3AgPSAwOwogCkBAIC0xOTAsMzgg KzIxMiw2MCBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXdGUFNDb3VudGVyKEdyYXBoaWNz Q29udGV4dCogY3R4LCBpbnQgdG9wLCBpbnQgaGVpZ2h0KQogewogICAgIC8vIE5vdGUgdGhhdCBz aW5jZSB3ZSBoYXZlbid0IGZpbmlzaGVkIHRoZSBjdXJyZW50IGZyYW1lLCB0aGUgRlBTIGNvdW50 ZXIKICAgICAvLyBhY3R1YWxseSByZXBvcnRzIHRoZSBsYXN0IGZyYW1lJ3MgdGltZS4KLSAgICBk b3VibGUgc2VjRm9yTGFzdEZyYW1lID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbKG1fY3VycmVu dEZyYW1lTnVtYmVyICsga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSAtIDEpICUga0JlZ2luRnJhbWVI aXN0b3J5U2l6ZV0gLQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhp c3RvcnlJblNlY1sobV9jdXJyZW50RnJhbWVOdW1iZXIgKyBrQmVnaW5GcmFtZUhpc3RvcnlTaXpl IC0gMikgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplXTsKLQotICAgIC8vIEZpbHRlciB0aGUgZnJh bWUgdGltZXMgdG8gYXZvaWQgc3Bpa2VzLgotICAgIGNvbnN0IGZsb2F0IGFscGhhID0gMC4xOwot ICAgIGlmICghbV9maWx0ZXJlZEZyYW1lVGltZSkgewotICAgICAgICBpZiAobV9jdXJyZW50RnJh bWVOdW1iZXIgPT0gMikKLSAgICAgICAgICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSBzZWNGb3JM YXN0RnJhbWU7Ci0gICAgfSBlbHNlCi0gICAgICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSAoKDEu MCAtIGFscGhhKSAqIG1fZmlsdGVyZWRGcmFtZVRpbWUpICsgKGFscGhhICogc2VjRm9yTGFzdEZy YW1lKTsKKyAgICBkb3VibGUgc2VjRm9yTGFzdEZyYW1lID0gbV9iZWdpblRpbWVIaXN0b3J5SW5T ZWNbZnJhbWVJbmRleChtX2N1cnJlbnRGcmFtZU51bWJlciAtIDEpXSAtCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2ZyYW1lSW5kZXgobV9jdXJy ZW50RnJhbWVOdW1iZXIgLSAyKV07CisgICAgZG91YmxlIHNlY0ZvclNlY29uZExhc3RGcmFtZSA9 IG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2ZyYW1lSW5kZXgobV9jdXJyZW50RnJhbWVOdW1iZXIg LSAyKV0gLQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fYmVnaW5UaW1lSGlz dG9yeUluU2VjW2ZyYW1lSW5kZXgobV9jdXJyZW50RnJhbWVOdW1iZXIgLSAzKV07CisKKyAgICAv LyBGaWx0ZXIgdGhlIGZyYW1lIHRpbWVzIHRvIGF2b2lkIHNwaWtlcy4gU3BlY2lmaWNhbGx5LCBr ZWVwIGEgcnVubmluZworICAgIC8vIGF2ZXJhZ2UgZnJhbWUgcmF0ZSBhbmQgYSBydW5uaW5nIHZh cmlhbmNlIHdoaWxlIGlnbm9yaW5nIGJhZCBmcmFtZXMKKyAgICAvLyB3aGljaCBhcmUgZWl0aGVy IHRvbyBzbG93IG9yIHRvbyBmYXN0LiBTbG93IGZyYW1lcyBvY2N1ciBqdXN0IGJlY2F1c2UKKyAg ICAvLyB0aGUgdXNlciBpcyBpbmFjdGl2ZSwgYW5kIHNob3VsZCBiZSBpZ25vcmVkLiBGYXN0IGZy YW1lcyBhcmUgaWdub3JlZCBpZgorICAgIC8vIHRoZSBzY2hlZHVsZXIgaXMgaW4gc2luZ2xlLXRo cmVhZCBtb2RlIGluIG9yZGVyIHRvIHJlcHJlc2VudCB0aGUgdHJ1ZQorICAgIC8vIGZyYW1lIHJh dGUgaW4gc3BpdGUgb2YgdGhlIGZhY3QgdGhhdCB0aGUgZmlyc3QgZmV3IHN3YXBidWZmZXJzIGhh cHBlbgorICAgIC8vIGluc3RhbnRseSB3aGljaCBza2V3cyB0aGUgc3RhdGlzdGljcyB0b28gbXVj aCBmb3Igc2hvcnQgbGl2ZWQKKyAgICAvLyBhbmltYXRpb25zLgorICAgIGlmIChzZWNGb3JTZWNv bmRMYXN0RnJhbWUgPiBrSWRsZVNlY29uZHNUcmlnZ2Vyc1Jlc2V0IHx8IG1fYXZlcmFnZUZQU0Nv dW50ID4ga0xvbmdBbmltYXRpb25UcmlnZ2Vyc1Jlc2V0KSB7CisgICAgICAgIC8vIHJlc3RhcnQg dGhlIGZyYW1lIHN0YXRpc3RpY3MKKyAgICAgICAgbV9hdmVyYWdlRlBTID0gMDsKKyAgICAgICAg bV9hdmVyYWdlRlBTQ291bnQgPSAwOworICAgICAgICBtX2Zwc1ZhcmlhbmNlTnVtZXJhdG9yID0g MDsKKyAgICB9IGVsc2UgaWYgKCFpc0JhZEZyYW1lKG1fY3VycmVudEZyYW1lTnVtYmVyIC0gMSkp IHsKKyAgICAgICAgbV9hdmVyYWdlRlBTQ291bnQrKzsKKyAgICAgICAgZG91YmxlIHggPSAxLjAg LyBzZWNGb3JMYXN0RnJhbWU7CisgICAgICAgIGRvdWJsZSBkZWx0YUZyb21BdmVyYWdlID0geCAt IG1fYXZlcmFnZUZQUzsKKyAgICAgICAgLy8gQ2hhbmdlIHdpdGggY2F1dGlvbiAtIG51bWVyaWNz LiBodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL1N0YW5kYXJkX2RldmlhdGlvbgorICAgICAg ICBtX2F2ZXJhZ2VGUFMgPSBtX2F2ZXJhZ2VGUFMgKyBkZWx0YUZyb21BdmVyYWdlIC8gbV9hdmVy YWdlRlBTQ291bnQ7CisgICAgICAgIG1fZnBzVmFyaWFuY2VOdW1lcmF0b3IgPSBtX2Zwc1Zhcmlh bmNlTnVtZXJhdG9yICsgZGVsdGFGcm9tQXZlcmFnZSAqICh4IC0gbV9hdmVyYWdlRlBTKTsKKyAg ICB9CiAKICAgICAvLyBDcmVhdGUgJiBtZWFzdXJlIEZQUyB0ZXh0LgotICAgIFN0cmluZyB0ZXh0 KFN0cmluZzo6Zm9ybWF0KCJGUFM6ICU1LjFmIiwgMS4wIC8gbV9maWx0ZXJlZEZyYW1lVGltZSkp OwotICAgIFRleHRSdW4gcnVuKHRleHQpOwotICAgIGZsb2F0IHRleHRXaWR0aCA9IG1fbWVkaXVt Rm9udC0+d2lkdGgocnVuKSArIDIuMGY7CisgICAgZG91YmxlIHN0ZERldmlhdGlvbiA9IHNxcnQo bV9mcHNWYXJpYW5jZU51bWVyYXRvciAvIG1fYXZlcmFnZUZQU0NvdW50KTsKKyAgICBTdHJpbmcg ZnBzKFN0cmluZzo6Zm9ybWF0KCJGUFM6ICU0LjFmICsvLSUzLjFmIiwgbV9hdmVyYWdlRlBTLCBz dGREZXZpYXRpb24pKTsKKyAgICBUZXh0UnVuIHRleHQoZnBzKTsKKyAgICBmbG9hdCB0ZXh0V2lk dGggPSBtX21lZGl1bUZvbnQtPndpZHRoKHRleHQpICsgMjsKICAgICBmbG9hdCBncmFwaFdpZHRo ID0ga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZTsKIAogICAgIC8vIERyYXcgYmFja2dyb3VuZC4KICAg ICBjdHgtPnNldEZpbGxDb2xvcihDb2xvcigwLCAwLCAwLCAyNTUpLCBDb2xvclNwYWNlRGV2aWNl UkdCKTsKLSAgICBjdHgtPmZpbGxSZWN0KEZsb2F0UmVjdCgyLCB0b3AsIHRleHRXaWR0aCArIGdy YXBoV2lkdGgsIGhlaWdodCkpOworICAgIGRvdWJsZSBmb250SGVpZ2h0ID0gbV9tZWRpdW1Gb250 LT5mb250TWV0cmljcygpLmZsb2F0SGVpZ2h0KCkgKyAyOworICAgIGN0eC0+ZmlsbFJlY3QoRmxv YXRSZWN0KDIsIHRvcCwgdGV4dFdpZHRoLCBmb250SGVpZ2h0KSk7CisgICAgY3R4LT5maWxsUmVj dChGbG9hdFJlY3QoMiArIHRleHRXaWR0aCwgdG9wLCBncmFwaFdpZHRoLCBoZWlnaHQpKTsKIAog ICAgIC8vIERyYXcgRlBTIHRleHQuCi0gICAgaWYgKG1fZmlsdGVyZWRGcmFtZVRpbWUpIHsKLSAg ICAgICAgY3R4LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmlj ZVJHQik7Ci0gICAgICAgIGN0eC0+ZHJhd1RleHQoKm1fbWVkaXVtRm9udCwgcnVuLCBJbnRQb2lu dCgzLCB0b3AgKyBoZWlnaHQgLSA2KSk7Ci0gICAgfQorICAgIGN0eC0+c2V0RmlsbENvbG9yKENv bG9yKDIwMCwgMjAwLCAyMDApLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjdHgtPmRyYXdU ZXh0KCptX21lZGl1bUZvbnQsIHRleHQsIEludFBvaW50KDMsIHRvcCArIGZvbnRIZWlnaHQgLSA0 KSk7CiAKICAgICAvLyBEcmF3IEZQUyBncmFwaC4KLSAgICBjb25zdCBkb3VibGUgbG9GUFMgPSAw LjA7Ci0gICAgY29uc3QgZG91YmxlIGhpRlBTID0gMTIwLjA7CisgICAgY29uc3QgZG91YmxlIGxv RlBTID0gMDsKKyAgICBjb25zdCBkb3VibGUgaGlGUFMgPSA4MDsKICAgICBjdHgtPnNldFN0cm9r ZVN0eWxlKFNvbGlkU3Ryb2tlKTsKKyAgICBjdHgtPnNldEZpbGxDb2xvcihDb2xvcigxNTQsIDIw NSwgNTApLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjdHgtPmZpbGxSZWN0KEZsb2F0UmVj dCgyICsgdGV4dFdpZHRoLCB0b3AsIGdyYXBoV2lkdGgsIGhlaWdodCAvIDIpKTsKKyAgICBjdHgt PnNldEZpbGxDb2xvcihDb2xvcigyNTUsIDI1MCwgMjA1KSwgQ29sb3JTcGFjZURldmljZVJHQik7 CisgICAgY3R4LT5maWxsUmVjdChGbG9hdFJlY3QoMiArIHRleHRXaWR0aCwgdG9wICsgaGVpZ2h0 IC8gMiwgZ3JhcGhXaWR0aCwgaGVpZ2h0IC8gMikpOwogICAgIGN0eC0+c2V0U3Ryb2tlQ29sb3Io Q29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CisgICAgY3R4LT5zZXRGaWxs Q29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CiAgICAgaW50IGdy YXBoTGVmdCA9IHN0YXRpY19jYXN0PGludD4odGV4dFdpZHRoICsgMyk7CiAgICAgSW50UG9pbnQg cHJldigtMSwgMCk7CiAgICAgaW50IHggPSAwOwpAQCAtMjI5LDYgKzI3MywxMCBAQCB2b2lkIEND SGVhZHNVcERpc3BsYXk6OmRyYXdGUFNDb3VudGVyKEdyYXBoaWNzQ29udGV4dCogY3R4LCBpbnQg dG9wLCBpbnQgaGVpZ2h0KQogICAgIGZvciAoaW50IGkgPSBtX2N1cnJlbnRGcmFtZU51bWJlciAl IGtCZWdpbkZyYW1lSGlzdG9yeVNpemU7IGkgIT0gKG1fY3VycmVudEZyYW1lTnVtYmVyIC0gMSkg JSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOyBpID0gKGkgKyAxKSAlIGtCZWdpbkZyYW1lSGlzdG9y eVNpemUpIHsKICAgICAgICAgaW50IGogPSAoaSArIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6 ZTsKICAgICAgICAgZG91YmxlIGZwcyA9IDEuMCAvIChtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tq XSAtIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2ldKTsKKyAgICAgICAgaWYgKGlzQmFkRnJhbWUo aikpIHsKKyAgICAgICAgICAgIHggKz0gMTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICB9CiAgICAgICAgIGRvdWJsZSBwID0gMSAtICgoZnBzIC0gbG9GUFMpIC8gKGhpRlBTIC0gbG9G UFMpKTsKICAgICAgICAgaWYgKHAgPCAwKQogICAgICAgICAgICAgcCA9IDA7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBE aXNwbGF5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0hlYWRzVXBEaXNwbGF5LmgKaW5kZXggMDVjYjIwZDUyNjk3OTg1OTI2OGU0MTc3NGZjYWE0YTRj ZTFiYTJhNC4uOGYxNjkyYTljZGNkZjMyODhkMjFlNzEyYzk0OGY2ZjlmZWRkMWM5MSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFk c1VwRGlzcGxheS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDSGVhZHNVcERpc3BsYXkuaApAQCAtNjYsMTcgKzY2LDI5IEBAIHByaXZhdGU6CiAg ICAgdm9pZCBkcmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRleHQqLCBpbnQgdG9wLCBpbnQgaGVp Z2h0KTsKICAgICB2b2lkIGRyYXdQbGF0Zm9ybUxheWVyVHJlZShHcmFwaGljc0NvbnRleHQqLCBp bnQgdG9wKTsKICAgICBjb25zdCBDQ1NldHRpbmdzJiBzZXR0aW5ncygpIGNvbnN0OworICAgIGJv b2wgaXNCYWRGcmFtZShpbnQgZnJhbWVOdW1iZXIpIGNvbnN0OworICAgIGludCBmcmFtZUluZGV4 KGludCBmcmFtZU51bWJlcikgY29uc3Q7CiAKICAgICBpbnQgbV9jdXJyZW50RnJhbWVOdW1iZXI7 CiAKLSAgICBkb3VibGUgbV9maWx0ZXJlZEZyYW1lVGltZTsKKyAgICBkb3VibGUgbV9hdmVyYWdl RlBTOworICAgIGludCBtX2F2ZXJhZ2VGUFNDb3VudDsKKyAgICBkb3VibGUgbV9mcHNWYXJpYW5j ZU51bWVyYXRvcjsKIAogICAgIE93blB0cjxNYW5hZ2VkVGV4dHVyZT4gbV9odWRUZXh0dXJlOwog CiAgICAgTGF5ZXJSZW5kZXJlckNocm9taXVtKiBtX2xheWVyUmVuZGVyZXI7CiAKICAgICBzdGF0 aWMgY29uc3QgaW50IGtCZWdpbkZyYW1lSGlzdG9yeVNpemUgPSA2NDsKKyAgICAvLyBUaGUgbnVt YmVyIG9mIHNlY29uZHMgb2Ygbm8gZnJhbWVzIG1ha2VzIHVzIGRlY2lkZSB0aGF0IHRoZSBwcmV2 aW91cworICAgIC8vIGFuaW1hdGlvbiBpcyBvdmVyLgorICAgIHN0YXRpYyBjb25zdCBkb3VibGUg a0lkbGVTZWNvbmRzVHJpZ2dlcnNSZXNldCA9IDAuNTsKKyAgICAvLyBUaGUgbnVtYmVyIG9mIGZy YW1lcyB0aGF0IGNhdXNlIHVzIHRvIHJlc2V0IHRoZSBGUFMgc3RhdGlzdGljcyBzbyB0aGF0Cisg ICAgLy8gdGhlIGF2ZXJhZ2Ugb2YgemlsbGlvbnMgb2YgZnJhbWVzIGRvZXNuJ3QgZHJvd24gb3V0 IGEgbW9tZW50YXJ5IGphbmsuCisgICAgc3RhdGljIGNvbnN0IGludCBrTG9uZ0FuaW1hdGlvblRy aWdnZXJzUmVzZXQgPSA2MCoyOwogICAgIGRvdWJsZSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tr QmVnaW5GcmFtZUhpc3RvcnlTaXplXTsKKyAgICBzdGF0aWMgY29uc3QgZG91YmxlIGtGcmFtZVRv b0Zhc3QgPSAxLjAgLyA3MDsKKyAgICBzdGF0aWMgY29uc3QgaW50IGtOdW1NaXNzZWRGcmFtZXNG b3JSZXNldCA9IDU7CiAKICAgICBPd25QdHI8Rm9udD4gbV9zbWFsbEZvbnQ7CiAgICAgT3duUHRy PEZvbnQ+IG1fbWVkaXVtRm9udDsK 130539 2012-03-06 21:37:17 -0800 2012-04-10 23:21:22 -0700 Patch bug-73454-20120307003716.patch text/plain 11903 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTA5OTk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOTg1NjViZTA3NWE1MWU0 YmUzNGIzNWVjN2I5OGI5ZmQ0ZDE1MDE1MS4uYWVlNGMyZThkYzljMmM1MGY0ZTViZjQyOGE4ZWQz NzdjYWE2YTZhMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTAzLTA3ICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBzbyB0aGF0IG91dGxpZXIgZGF0YSBwb2lu dHMgYXJlIGxhYmVsbGVkIHdpdGggdGhlaXIKKyAgICAgICAgZnJhbWUgcmF0ZSBzbyB0aGF0IHlv dSBjYW4gc2VlIGhvdyBzbG93IHRoZSBmcmFtZSBpcyB0aGF0IGlzCisgICAgICAgIGNhdXNpbmcg dGhlIGphbms7IGFuZCB0byBrZWVwIHN0YXRpc3RpY3Mgb24gZnJhbWUgcmF0ZSBiZXR3ZWVuCisg ICAgICAgIHBhdXNlcyBpbiB0aGUgYWN0aXZpdHkgaW4gdGhlIFVJIHNvIHRoYXQgeW91IGNhbiB0 cmlnZ2VyIGEKKyAgICAgICAgdHJhbnNpdGlvbiBhbmQgcmVhZCBvZmYgdGhlIGF2ZXJhZ2UgYW5k IHN0YW5kYXJkIGRldmlhdGlvbiBmb3IKKyAgICAgICAgdGhhdCB0cmFuc2l0aW9uIHRvIGp1ZGdl IGl0IHNtb290aCBlbm91Z2ggb3Igbm90LgorCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgSFVEIGlzIG5vdCB0ZXN0YWJsZSBpbiB3ZWJraXQuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OkNDSGVhZHNVcERpc3BsYXkp OgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6b25GcmFtZUJlZ2luKToKKyAg ICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3BsYXk6OmRyYXdIdWRDb250ZW50cyk6CisgICAg ICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcik6CisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oOgorCiAy MDEyLTAzLTA2ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgW2Nocm9taXVtXSBGaXggdGhyZWFkZWQgY29tcG9zaXRpbmcgaXNzdWVzIGluIFdlYkdMTGF5 ZXJDaHJvbWl1bSAoZXhjZXB0IGZvciBwcmludGluZykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDSGVhZHNVcERpc3BsYXkuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlz cGxheS5jcHAKaW5kZXggM2RkYzEyM2MwZjU5ODNiZDI0NTg4OTUxNDI3ZTQ0OTExOTAzOGFlYS4u N2YyODI5MzMwMWViYmNmYzE1ODQ0ZDI1MGZiNWNjZTljMDI2YjQ0ZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxh eS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NIZWFkc1VwRGlzcGxheS5jcHAKQEAgLTUwLDcgKzUwLDYgQEAgdXNpbmcgbmFtZXNwYWNlIHN0 ZDsKIAogQ0NIZWFkc1VwRGlzcGxheTo6Q0NIZWFkc1VwRGlzcGxheShMYXllclJlbmRlcmVyQ2hy b21pdW0qIG93bmVyKQogICAgIDogbV9jdXJyZW50RnJhbWVOdW1iZXIoMSkKLSAgICAsIG1fZmls dGVyZWRGcmFtZVRpbWUoMCkKICAgICAsIG1fbGF5ZXJSZW5kZXJlcihvd25lcikKICAgICAsIG1f dXNlTWFwU3ViRm9yVXBsb2Fkcyhvd25lci0+Y29udGV4dFN1cHBvcnRzTWFwU3ViKCkpCiB7CkBA IC02MSw3ICs2MCw3IEBAIENDSGVhZHNVcERpc3BsYXk6OkNDSGVhZHNVcERpc3BsYXkoTGF5ZXJS ZW5kZXJlckNocm9taXVtKiBvd25lcikKIAogICAgIEZvbnREZXNjcmlwdGlvbiBtZWRpdW1Gb250 RGVzYzsKICAgICBtZWRpdW1Gb250RGVzYy5zZXRHZW5lcmljRmFtaWx5KEZvbnREZXNjcmlwdGlv bjo6TW9ub3NwYWNlRmFtaWx5KTsKLSAgICBtZWRpdW1Gb250RGVzYy5zZXRDb21wdXRlZFNpemUo MjApOworICAgIG1lZGl1bUZvbnREZXNjLnNldENvbXB1dGVkU2l6ZSgxMik7CiAKICAgICBtX21l ZGl1bUZvbnQgPSBhZG9wdFB0cihuZXcgRm9udChtZWRpdW1Gb250RGVzYywgMCwgMCkpOwogICAg IG1fbWVkaXVtRm9udC0+dXBkYXRlKDApOwpAQCAtNzgsOSArNzcsMjAgQEAgQ0NIZWFkc1VwRGlz cGxheTo6fkNDSGVhZHNVcERpc3BsYXkoKQogewogfQogCisvLyBzYWZlTW9kIHdvcmtzIG9uIC0x LCByZXR1cm5pbmcgbS0xIGluIHRoYXQgY2FzZS4KK3N0YXRpYyBpbmxpbmUgaW50IHNhZmVNb2Qo aW50IG51bWJlciwgaW50IG1vZHVsdXMpCit7CisgICAgcmV0dXJuIChudW1iZXIgKyBtb2R1bHVz KSAlIG1vZHVsdXM7Cit9CisKK2lubGluZSBpbnQgQ0NIZWFkc1VwRGlzcGxheTo6ZnJhbWVJbmRl eChpbnQgZnJhbWUpIGNvbnN0Cit7CisgICAgcmV0dXJuIHNhZmVNb2QoZnJhbWUsIGtCZWdpbkZy YW1lSGlzdG9yeVNpemUpOworfQorCiB2b2lkIENDSGVhZHNVcERpc3BsYXk6Om9uRnJhbWVCZWdp bihkb3VibGUgdGltZXN0YW1wKQogewotICAgIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW21fY3Vy cmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV0gPSB0aW1lc3RhbXA7Cisg ICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbZnJhbWVJbmRleChtX2N1cnJlbnRGcmFtZU51bWJl cildID0gdGltZXN0YW1wOwogfQogCiB2b2lkIENDSGVhZHNVcERpc3BsYXk6Om9uU3dhcEJ1ZmZl cnMoKQpAQCAtMTYyLDYgKzE3MiwxNSBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXcoKQog ICAgIG1faHVkVGV4dHVyZS0+dW5yZXNlcnZlKCk7CiB9CiAKK2Jvb2wgQ0NIZWFkc1VwRGlzcGxh eTo6aXNCYWRGcmFtZShpbnQgZnJhbWVOdW1iZXIpIGNvbnN0Cit7CisgICAgZG91YmxlIGRlbHRh ID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbZnJhbWVJbmRleChmcmFtZU51bWJlcildIC0KKyAg ICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tmcmFtZUluZGV4KGZyYW1l TnVtYmVyIC0gMSldOworICAgIGJvb2wgdG9vU2xvdyA9IGRlbHRhID4gKGtOdW1NaXNzZWRGcmFt ZXNGb3JSZXNldCAvIDYwLjApOworICAgIGJvb2wgc2NoZWR1bGVyQWxsb3dzRG91YmxlRnJhbWVz ID0gIUNDUHJveHk6Omhhc0ltcGxUaHJlYWQoKTsKKyAgICByZXR1cm4gKHNjaGVkdWxlckFsbG93 c0RvdWJsZUZyYW1lcyAmJiBkZWx0YSA8IGtGcmFtZVRvb0Zhc3QpIHx8IHRvb1Nsb3c7Cit9CisK IHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0h1ZENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCog Y3R4LCBjb25zdCBJbnRTaXplJiBodWRTaXplKQogewogICAgIEZvbnRDYWNoZVB1cmdlUHJldmVu dGVyIGZvbnRDYWNoZVB1cmdlUHJldmVudGVyOwpAQCAtMTcxLDExICsxOTAsMTEgQEAgdm9pZCBD Q0hlYWRzVXBEaXNwbGF5OjpkcmF3SHVkQ29udGVudHMoR3JhcGhpY3NDb250ZXh0KiBjdHgsIGNv bnN0IEludFNpemUmIGh1ZFMKICAgICAgICAgY3R4LT5maWxsUmVjdChGbG9hdFJlY3QoMCwgMCwg aHVkU2l6ZS53aWR0aCgpLCBodWRTaXplLmhlaWdodCgpKSk7CiAgICAgfQogCi0gICAgaW50IGZw c0NvdW50ZXJIZWlnaHQgPSBtX21lZGl1bUZvbnQtPmZvbnRNZXRyaWNzKCkuZmxvYXRIZWlnaHQo KSArIDI7CisgICAgaW50IGZwc0NvdW50ZXJIZWlnaHQgPSBtX21lZGl1bUZvbnQtPmZvbnRNZXRy aWNzKCkuZmxvYXRIZWlnaHQoKSArIDQwOwogICAgIGludCBmcHNDb3VudGVyVG9wID0gMjsKICAg ICBpbnQgcGxhdGZvcm1MYXllclRyZWVUb3A7CiAgICAgaWYgKHNldHRpbmdzKCkuc2hvd0ZQU0Nv dW50ZXIpCi0gICAgICAgIHBsYXRmb3JtTGF5ZXJUcmVlVG9wID0gZnBzQ291bnRlclRvcCArIGZw c0NvdW50ZXJIZWlnaHQgKyAyOworICAgICAgICBwbGF0Zm9ybUxheWVyVHJlZVRvcCA9IGZwc0Nv dW50ZXJUb3AgKyBmcHNDb3VudGVySGVpZ2h0OwogICAgIGVsc2UKICAgICAgICAgcGxhdGZvcm1M YXllclRyZWVUb3AgPSAwOwogCkBAIC0xODYsNDIgKzIwNSw4MSBAQCB2b2lkIENDSGVhZHNVcERp c3BsYXk6OmRyYXdIdWRDb250ZW50cyhHcmFwaGljc0NvbnRleHQqIGN0eCwgY29uc3QgSW50U2l6 ZSYgaHVkUwogICAgICAgICBkcmF3UGxhdGZvcm1MYXllclRyZWUoY3R4LCBwbGF0Zm9ybUxheWVy VHJlZVRvcCk7CiB9CiAKLXZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0ZQU0NvdW50ZXIoR3Jh cGhpY3NDb250ZXh0KiBjdHgsIGludCB0b3AsIGludCBoZWlnaHQpCit2b2lkIENDSGVhZHNVcERp c3BsYXk6OmdldEF2ZXJhZ2VGUFNBbmRTdGFuZGFyZERldmlhdGlvbihkb3VibGUgKmF2ZXJhZ2Us IGRvdWJsZSAqc3RhbmRhcmREZXZpYXRpb24pIGNvbnN0CiB7Ci0gICAgLy8gTm90ZSB0aGF0IHNp bmNlIHdlIGhhdmVuJ3QgZmluaXNoZWQgdGhlIGN1cnJlbnQgZnJhbWUsIHRoZSBGUFMgY291bnRl cgotICAgIC8vIGFjdHVhbGx5IHJlcG9ydHMgdGhlIGxhc3QgZnJhbWUncyB0aW1lLgotICAgIGRv dWJsZSBzZWNGb3JMYXN0RnJhbWUgPSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1sobV9jdXJyZW50 RnJhbWVOdW1iZXIgKyBrQmVnaW5GcmFtZUhpc3RvcnlTaXplIC0gMSkgJSBrQmVnaW5GcmFtZUhp c3RvcnlTaXplXSAtCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fYmVnaW5UaW1lSGlz dG9yeUluU2VjWyhtX2N1cnJlbnRGcmFtZU51bWJlciArIGtCZWdpbkZyYW1lSGlzdG9yeVNpemUg LSAyKSAlIGtCZWdpbkZyYW1lSGlzdG9yeVNpemVdOwotCi0gICAgLy8gRmlsdGVyIHRoZSBmcmFt ZSB0aW1lcyB0byBhdm9pZCBzcGlrZXMuCi0gICAgY29uc3QgZmxvYXQgYWxwaGEgPSAwLjE7Ci0g ICAgaWYgKCFtX2ZpbHRlcmVkRnJhbWVUaW1lKSB7Ci0gICAgICAgIGlmIChtX2N1cnJlbnRGcmFt ZU51bWJlciA9PSAyKQotICAgICAgICAgICAgbV9maWx0ZXJlZEZyYW1lVGltZSA9IHNlY0Zvckxh c3RGcmFtZTsKLSAgICB9IGVsc2UKLSAgICAgICAgbV9maWx0ZXJlZEZyYW1lVGltZSA9ICgoMS4w IC0gYWxwaGEpICogbV9maWx0ZXJlZEZyYW1lVGltZSkgKyAoYWxwaGEgKiBzZWNGb3JMYXN0RnJh bWUpOworICAgIGRvdWJsZSYgYXZlcmFnZUZQUyA9ICphdmVyYWdlOworCisgICAgaW50IGZyYW1l ID0gbV9jdXJyZW50RnJhbWVOdW1iZXIgLSAxOyAKKyAgICBhdmVyYWdlRlBTID0gMDsKKyAgICBp bnQgYXZlcmFnZUZQU0NvdW50ID0gMDsKKyAgICBkb3VibGUgZnBzVmFyaWFuY2VOdW1lcmF0b3Ig PSAwOworCisgICAgLy8gV2FsayBiYWNrd2FyZHMgdGhyb3VnaCB0aGUgc2FtcGxlcyBsb29raW5n IGZvciBhIHJ1biBvZiBnb29kIGZyYW1lCisgICAgLy8gdGltaW5ncyBmcm9tIHdoaWNoIHRvIGNv bXB1dGUgdGhlIG1lYW4gYW5kIHN0YW5kYXJkIGRldmlhdGlvbi4KKyAgICAvLworICAgIC8vIFNs b3cgZnJhbWVzIG9jY3VyIGp1c3QgYmVjYXVzZSB0aGUgdXNlciBpcyBpbmFjdGl2ZSwgYW5kIHNo b3VsZCBiZQorICAgIC8vIGlnbm9yZWQuIEZhc3QgZnJhbWVzIGFyZSBpZ25vcmVkIGlmIHRoZSBz Y2hlZHVsZXIgaXMgaW4gc2luZ2xlLXRocmVhZAorICAgIC8vIG1vZGUgaW4gb3JkZXIgdG8gcmVw cmVzZW50IHRoZSB0cnVlIGZyYW1lIHJhdGUgaW4gc3BpdGUgb2YgdGhlIGZhY3QgdGhhdAorICAg IC8vIHRoZSBmaXJzdCBmZXcgc3dhcGJ1ZmZlcnMgaGFwcGVuIGluc3RhbnRseSB3aGljaCBza2V3 cyB0aGUgc3RhdGlzdGljcworICAgIC8vIHRvbyBtdWNoIGZvciBzaG9ydCBsaXZlZCBhbmltYXRp b25zLgorICAgIC8vCisgICAgLy8gaXNCYWRGcmFtZSBlbmNhcHN1bGF0ZXMgdGhlIGZyYW1lIHRv byBzbG93L2ZyYW1lIHRvbyBmYXN0IGxvZ2ljLgorICAgIHdoaWxlICgxKSB7CisgICAgICAgIGlm ICghaXNCYWRGcmFtZShmcmFtZSkpIHsKKyAgICAgICAgICAgIGF2ZXJhZ2VGUFNDb3VudCsrOwor ICAgICAgICAgICAgZG91YmxlIHNlY0Zvckxhc3RGcmFtZSA9IG1fYmVnaW5UaW1lSGlzdG9yeUlu U2VjW2ZyYW1lSW5kZXgoZnJhbWUpXSAtCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbZnJhbWVJbmRleChmcmFtZSAtIDEpXTsKKyAg ICAgICAgICAgIGRvdWJsZSB4ID0gMS4wIC8gc2VjRm9yTGFzdEZyYW1lOworICAgICAgICAgICAg ZG91YmxlIGRlbHRhRnJvbUF2ZXJhZ2UgPSB4IC0gYXZlcmFnZUZQUzsKKyAgICAgICAgICAgIC8v IENoYW5nZSB3aXRoIGNhdXRpb24gLSBudW1lcmljcy4gaHR0cDovL2VuLndpa2lwZWRpYS5vcmcv d2lraS9TdGFuZGFyZF9kZXZpYXRpb24KKyAgICAgICAgICAgIGF2ZXJhZ2VGUFMgPSBhdmVyYWdl RlBTICsgZGVsdGFGcm9tQXZlcmFnZSAvIGF2ZXJhZ2VGUFNDb3VudDsKKyAgICAgICAgICAgIGZw c1ZhcmlhbmNlTnVtZXJhdG9yID0gZnBzVmFyaWFuY2VOdW1lcmF0b3IgKyBkZWx0YUZyb21BdmVy YWdlICogKHggLSBhdmVyYWdlRlBTKTsKKyAgICAgICAgfQorICAgICAgICBpZiAoYXZlcmFnZUZQ U0NvdW50ICYmIGlzQmFkRnJhbWUoZnJhbWUpKSB7CisgICAgICAgICAgICAvLyBXZSd2ZSBnYXRo ZXJlZCBhIHJ1biBvZiBnb29kIHNhbXBsZXMsIHNvIHN0b3AuCisgICAgICAgICAgICBicmVhazsK KyAgICAgICAgfQorICAgICAgICAtLWZyYW1lOworICAgICAgICBpZiAoZnJhbWVJbmRleChmcmFt ZSkgPT0gZnJhbWVJbmRleChtX2N1cnJlbnRGcmFtZU51bWJlcikgfHwgZnJhbWUgPCAwKSB7Cisg ICAgICAgICAgICAvLyBXZSd2ZSBnb25lIHRocm91Z2ggYWxsIGF2YWlsYWJsZSBoaXN0b3JpY2Fs IGRhdGEsIHNvIHN0b3AuCisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorICAgIH0KIAog ICAgIC8vIENyZWF0ZSAmIG1lYXN1cmUgRlBTIHRleHQuCi0gICAgU3RyaW5nIHRleHQoU3RyaW5n Ojpmb3JtYXQoIkZQUzogJTUuMWYiLCAxLjAgLyBtX2ZpbHRlcmVkRnJhbWVUaW1lKSk7Ci0gICAg VGV4dFJ1biBydW4odGV4dCk7Ci0gICAgZmxvYXQgdGV4dFdpZHRoID0gbV9tZWRpdW1Gb250LT53 aWR0aChydW4pICsgMi4wZjsKKyAgICAqc3RhbmRhcmREZXZpYXRpb24gPSBzcXJ0KGZwc1Zhcmlh bmNlTnVtZXJhdG9yIC8gYXZlcmFnZUZQU0NvdW50KTsKK30KKwordm9pZCBDQ0hlYWRzVXBEaXNw bGF5OjpkcmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRleHQqIGN0eCwgaW50IHRvcCwgaW50IGhl aWdodCkKK3sKKyAgICBkb3VibGUgYXZlcmFnZUZQUywgc3RkRGV2aWF0aW9uOworCisgICAgZ2V0 QXZlcmFnZUZQU0FuZFN0YW5kYXJkRGV2aWF0aW9uKCZhdmVyYWdlRlBTLCAmc3RkRGV2aWF0aW9u KTsKKyAgICBTdHJpbmcgZnBzKFN0cmluZzo6Zm9ybWF0KCJGUFM6ICU0LjFmICsvLSUzLjFmIiwg YXZlcmFnZUZQUywgc3RkRGV2aWF0aW9uKSk7CisgICAgVGV4dFJ1biB0ZXh0KGZwcyk7CisgICAg ZmxvYXQgdGV4dFdpZHRoID0gbV9tZWRpdW1Gb250LT53aWR0aCh0ZXh0KSArIDI7CiAgICAgZmxv YXQgZ3JhcGhXaWR0aCA9IGtCZWdpbkZyYW1lSGlzdG9yeVNpemU7CiAKICAgICAvLyBEcmF3IGJh Y2tncm91bmQuCiAgICAgY3R4LT5zZXRGaWxsQ29sb3IoQ29sb3IoMCwgMCwgMCwgMjU1KSwgQ29s b3JTcGFjZURldmljZVJHQik7Ci0gICAgY3R4LT5maWxsUmVjdChGbG9hdFJlY3QoMiwgdG9wLCB0 ZXh0V2lkdGggKyBncmFwaFdpZHRoLCBoZWlnaHQpKTsKKyAgICBkb3VibGUgZm9udEhlaWdodCA9 IG1fbWVkaXVtRm9udC0+Zm9udE1ldHJpY3MoKS5mbG9hdEhlaWdodCgpICsgMjsKKyAgICBjdHgt PmZpbGxSZWN0KEZsb2F0UmVjdCgyLCB0b3AsIHRleHRXaWR0aCwgZm9udEhlaWdodCkpOworICAg IGN0eC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIgKyB0ZXh0V2lkdGgsIHRvcCwgZ3JhcGhXaWR0aCwg aGVpZ2h0KSk7CiAKICAgICAvLyBEcmF3IEZQUyB0ZXh0LgotICAgIGlmIChtX2ZpbHRlcmVkRnJh bWVUaW1lKSB7Ci0gICAgICAgIGN0eC0+c2V0RmlsbENvbG9yKENvbG9yKDI1NSwgMCwgMCksIENv bG9yU3BhY2VEZXZpY2VSR0IpOwotICAgICAgICBjdHgtPmRyYXdUZXh0KCptX21lZGl1bUZvbnQs IHJ1biwgSW50UG9pbnQoMywgdG9wICsgaGVpZ2h0IC0gNikpOwotICAgIH0KKyAgICBjdHgtPnNl dEZpbGxDb2xvcihDb2xvcigyMDAsIDIwMCwgMjAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7Cisg ICAgY3R4LT5kcmF3VGV4dCgqbV9tZWRpdW1Gb250LCB0ZXh0LCBJbnRQb2ludCgzLCB0b3AgKyBm b250SGVpZ2h0IC0gNCkpOwogCiAgICAgLy8gRHJhdyBGUFMgZ3JhcGguCi0gICAgY29uc3QgZG91 YmxlIGxvRlBTID0gMC4wOwotICAgIGNvbnN0IGRvdWJsZSBoaUZQUyA9IDEyMC4wOworICAgIGNv bnN0IGRvdWJsZSBsb0ZQUyA9IDA7CisgICAgY29uc3QgZG91YmxlIGhpRlBTID0gODA7CiAgICAg Y3R4LT5zZXRTdHJva2VTdHlsZShTb2xpZFN0cm9rZSk7CisgICAgY3R4LT5zZXRGaWxsQ29sb3Io Q29sb3IoMTU0LCAyMDUsIDUwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CisgICAgY3R4LT5maWxs UmVjdChGbG9hdFJlY3QoMiArIHRleHRXaWR0aCwgdG9wLCBncmFwaFdpZHRoLCBoZWlnaHQgLyAy KSk7CisgICAgY3R4LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAyNTAsIDIwNSksIENvbG9yU3Bh Y2VEZXZpY2VSR0IpOworICAgIGN0eC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIgKyB0ZXh0V2lkdGgs IHRvcCArIGhlaWdodCAvIDIsIGdyYXBoV2lkdGgsIGhlaWdodCAvIDIpKTsKICAgICBjdHgtPnNl dFN0cm9rZUNvbG9yKENvbG9yKDI1NSwgMCwgMCksIENvbG9yU3BhY2VEZXZpY2VSR0IpOworICAg IGN0eC0+c2V0RmlsbENvbG9yKENvbG9yKDI1NSwgMCwgMCksIENvbG9yU3BhY2VEZXZpY2VSR0Ip OwogICAgIGludCBncmFwaExlZnQgPSBzdGF0aWNfY2FzdDxpbnQ+KHRleHRXaWR0aCArIDMpOwog ICAgIEludFBvaW50IHByZXYoLTEsIDApOwogICAgIGludCB4ID0gMDsKQEAgLTIyOSw2ICsyODcs MTAgQEAgdm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRl eHQqIGN0eCwgaW50IHRvcCwgaW50IGhlaWdodCkKICAgICBmb3IgKGludCBpID0gbV9jdXJyZW50 RnJhbWVOdW1iZXIgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOyBpICE9IChtX2N1cnJlbnRGcmFt ZU51bWJlciAtIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZTsgaSA9IChpICsgMSkgJSBrQmVn aW5GcmFtZUhpc3RvcnlTaXplKSB7CiAgICAgICAgIGludCBqID0gKGkgKyAxKSAlIGtCZWdpbkZy YW1lSGlzdG9yeVNpemU7CiAgICAgICAgIGRvdWJsZSBmcHMgPSAxLjAgLyAobV9iZWdpblRpbWVI aXN0b3J5SW5TZWNbal0gLSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tpXSk7CisgICAgICAgIGlm IChpc0JhZEZyYW1lKGopKSB7CisgICAgICAgICAgICB4ICs9IDE7CisgICAgICAgICAgICBjb250 aW51ZTsKKyAgICAgICAgfQogICAgICAgICBkb3VibGUgcCA9IDEgLSAoKGZwcyAtIGxvRlBTKSAv IChoaUZQUyAtIGxvRlBTKSk7CiAgICAgICAgIGlmIChwIDwgMCkKICAgICAgICAgICAgIHAgPSAw OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NIZWFkc1VwRGlzcGxheS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oCmluZGV4IDA1Y2IyMGQ1MjY5Nzk4NTkyNjhl NDE3NzRmY2FhNGE0Y2UxYmEyYTQuLmNhZjIwYWU4ZGFiMWMwOTgyY2IyMGIwMjlkNzMyNWYwNTEz ZWYyMjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDSGVhZHNVcERpc3BsYXkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmgKQEAgLTY2LDE3ICs2NiwyMyBA QCBwcml2YXRlOgogICAgIHZvaWQgZHJhd0ZQU0NvdW50ZXIoR3JhcGhpY3NDb250ZXh0KiwgaW50 IHRvcCwgaW50IGhlaWdodCk7CiAgICAgdm9pZCBkcmF3UGxhdGZvcm1MYXllclRyZWUoR3JhcGhp Y3NDb250ZXh0KiwgaW50IHRvcCk7CiAgICAgY29uc3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MoKSBj b25zdDsKKyAgICBib29sIGlzQmFkRnJhbWUoaW50IGZyYW1lTnVtYmVyKSBjb25zdDsKKyAgICBp bnQgZnJhbWVJbmRleChpbnQgZnJhbWVOdW1iZXIpIGNvbnN0OworICAgIHZvaWQgZ2V0QXZlcmFn ZUZQU0FuZFN0YW5kYXJkRGV2aWF0aW9uKGRvdWJsZSAqYXZlcmFnZSwgZG91YmxlICpzdGFuZGFy ZERldmlhdGlvbikgY29uc3Q7CiAKICAgICBpbnQgbV9jdXJyZW50RnJhbWVOdW1iZXI7CiAKLSAg ICBkb3VibGUgbV9maWx0ZXJlZEZyYW1lVGltZTsKLQogICAgIE93blB0cjxNYW5hZ2VkVGV4dHVy ZT4gbV9odWRUZXh0dXJlOwogCiAgICAgTGF5ZXJSZW5kZXJlckNocm9taXVtKiBtX2xheWVyUmVu ZGVyZXI7CiAKLSAgICBzdGF0aWMgY29uc3QgaW50IGtCZWdpbkZyYW1lSGlzdG9yeVNpemUgPSA2 NDsKKyAgICBzdGF0aWMgY29uc3QgaW50IGtCZWdpbkZyYW1lSGlzdG9yeVNpemUgPSAxMjA7Cisg ICAgLy8gVGhlIG51bWJlciBvZiBzZWNvbmRzIG9mIG5vIGZyYW1lcyBtYWtlcyB1cyBkZWNpZGUg dGhhdCB0aGUgcHJldmlvdXMKKyAgICAvLyBhbmltYXRpb24gaXMgb3Zlci4KKyAgICBzdGF0aWMg Y29uc3QgZG91YmxlIGtJZGxlU2Vjb25kc1RyaWdnZXJzUmVzZXQgPSAwLjU7CiAgICAgZG91Ymxl IG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2tCZWdpbkZyYW1lSGlzdG9yeVNpemVdOworICAgIHN0 YXRpYyBjb25zdCBkb3VibGUga0ZyYW1lVG9vRmFzdCA9IDEuMCAvIDcwOworICAgIHN0YXRpYyBj b25zdCBpbnQga051bU1pc3NlZEZyYW1lc0ZvclJlc2V0ID0gNTsKIAogICAgIE93blB0cjxGb250 PiBtX3NtYWxsRm9udDsKICAgICBPd25QdHI8Rm9udD4gbV9tZWRpdW1Gb250Owo= 136629 2012-04-10 23:21:27 -0700 2012-04-10 23:38:59 -0700 Patch bug-73454-20120411022126.patch text/plain 12490 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzNjcxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmJiYWY4MDk2ZjljOWE4 N2E5NjhkYzRhM2ZlYWQxNDc5OWZhMGJmZi4uOTkzMmMzNmFlNDI1MzQzYzMyZTAxMzgxOWY1NWI1 OTU5MzgwYmM5YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDEyLTA0LTExICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBhbmQgdG8ga2VlcCBzdGF0aXN0aWNzIG9u IGZyYW1lIHJhdGUgYmV0d2VlbgorICAgICAgICBwYXVzZXMgaW4gdGhlIGFjdGl2aXR5IGluIHRo ZSBVSSBzbyB0aGF0IHlvdSBjYW4gdHJpZ2dlciBhCisgICAgICAgIHRyYW5zaXRpb24gYW5kIHJl YWQgb2ZmIHRoZSBhdmVyYWdlIGFuZCBzdGFuZGFyZCBkZXZpYXRpb24gZm9yCisgICAgICAgIHRo YXQgdHJhbnNpdGlvbiB0byBqdWRnZSBpdCBzbW9vdGggZW5vdWdoIG9yIG5vdC4KKworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhVRCBpcyBub3QgdGVz dGFibGUgaW4gd2Via2l0LgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NIZWFkc1VwRGlzcGxheS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNw bGF5OjpDQ0hlYWRzVXBEaXNwbGF5KToKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3Bs YXk6Om9uRnJhbWVCZWdpbik6CisgICAgICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5Ojpk cmF3SHVkQ29udGVudHMpOgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6ZHJh d0ZQU0NvdW50ZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND SGVhZHNVcERpc3BsYXkuaDoKKworMjAxMi0wMy0wNiAgSmFtZXMgUm9iaW5zb24gIDxqYW1lc3JA Y2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gRml4IHRocmVhZGVkIGNvbXBvc2l0 aW5nIGlzc3VlcyBpbiBXZWJHTExheWVyQ2hyb21pdW0gKGV4Y2VwdCBmb3IgcHJpbnRpbmcpCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MDQ1OQorCiAy MDEyLTA0LTA5ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAog ICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTEzNjU2LgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxh eS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hl YWRzVXBEaXNwbGF5LmNwcAppbmRleCBlNGIxNWQ3MjFmNzNhYmI5NWJlYWE5OGNkNDAzNzUxOTcx YTA1YTE4Li4wNjM3MTY4Y2QyYWY2MjFjOGYwNDJhZWZiYzg4ZTFhNDBkYzI0MGQ3IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRz VXBEaXNwbGF5LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcApAQCAtNTAsNyArNTAsNiBAQCB1c2luZyBuYW1l c3BhY2Ugc3RkOwogCiBDQ0hlYWRzVXBEaXNwbGF5OjpDQ0hlYWRzVXBEaXNwbGF5KExheWVyUmVu ZGVyZXJDaHJvbWl1bSogb3duZXIpCiAgICAgOiBtX2N1cnJlbnRGcmFtZU51bWJlcigxKQotICAg ICwgbV9maWx0ZXJlZEZyYW1lVGltZSgwKQogICAgICwgbV9sYXllclJlbmRlcmVyKG93bmVyKQog ICAgICwgbV91c2VNYXBTdWJGb3JVcGxvYWRzKG93bmVyLT5jb250ZXh0U3VwcG9ydHNNYXBTdWIo KSkKIHsKQEAgLTc0LDcgKzczLDcgQEAgdm9pZCBDQ0hlYWRzVXBEaXNwbGF5Ojppbml0aWFsaXpl Rm9udHMoKQogICAgIEFTU0VSVCghQ0NQcm94eTo6aW1wbFRocmVhZCgpKTsKICAgICBGb250RGVz Y3JpcHRpb24gbWVkaXVtRm9udERlc2M7CiAgICAgbWVkaXVtRm9udERlc2Muc2V0R2VuZXJpY0Zh bWlseShGb250RGVzY3JpcHRpb246Ok1vbm9zcGFjZUZhbWlseSk7Ci0gICAgbWVkaXVtRm9udERl c2Muc2V0Q29tcHV0ZWRTaXplKDIwKTsKKyAgICBtZWRpdW1Gb250RGVzYy5zZXRDb21wdXRlZFNp emUoMTIpOwogCiAgICAgbV9tZWRpdW1Gb250ID0gYWRvcHRQdHIobmV3IEZvbnQobWVkaXVtRm9u dERlc2MsIDAsIDApKTsKICAgICBtX21lZGl1bUZvbnQtPnVwZGF0ZSgwKTsKQEAgLTg3LDkgKzg2 LDIwIEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6aW5pdGlhbGl6ZUZvbnRzKCkKICAgICBtX3Nt YWxsRm9udC0+dXBkYXRlKDApOwogfQogCisvLyBzYWZlTW9kIHdvcmtzIG9uIC0xLCByZXR1cm5p bmcgbS0xIGluIHRoYXQgY2FzZS4KK3N0YXRpYyBpbmxpbmUgaW50IHNhZmVNb2QoaW50IG51bWJl ciwgaW50IG1vZHVsdXMpCit7CisgICAgcmV0dXJuIChudW1iZXIgKyBtb2R1bHVzKSAlIG1vZHVs dXM7Cit9CisKK2lubGluZSBpbnQgQ0NIZWFkc1VwRGlzcGxheTo6ZnJhbWVJbmRleChpbnQgZnJh bWUpIGNvbnN0Cit7CisgICAgcmV0dXJuIHNhZmVNb2QoZnJhbWUsIGtCZWdpbkZyYW1lSGlzdG9y eVNpemUpOworfQorCiB2b2lkIENDSGVhZHNVcERpc3BsYXk6Om9uRnJhbWVCZWdpbihkb3VibGUg dGltZXN0YW1wKQogewotICAgIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW21fY3VycmVudEZyYW1l TnVtYmVyICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV0gPSB0aW1lc3RhbXA7CisgICAgbV9iZWdp blRpbWVIaXN0b3J5SW5TZWNbZnJhbWVJbmRleChtX2N1cnJlbnRGcmFtZU51bWJlcildID0gdGlt ZXN0YW1wOwogfQogCiB2b2lkIENDSGVhZHNVcERpc3BsYXk6Om9uU3dhcEJ1ZmZlcnMoKQpAQCAt MTc0LDYgKzE4NCwxNSBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXcoKQogICAgIG1faHVk VGV4dHVyZS0+dW5yZXNlcnZlKCk7CiB9CiAKK2Jvb2wgQ0NIZWFkc1VwRGlzcGxheTo6aXNCYWRG cmFtZShpbnQgZnJhbWVOdW1iZXIpIGNvbnN0Cit7CisgICAgZG91YmxlIGRlbHRhID0gbV9iZWdp blRpbWVIaXN0b3J5SW5TZWNbZnJhbWVJbmRleChmcmFtZU51bWJlcildIC0KKyAgICAgICAgICAg ICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tmcmFtZUluZGV4KGZyYW1lTnVtYmVyIC0g MSldOworICAgIGJvb2wgdG9vU2xvdyA9IGRlbHRhID4gKGtOdW1NaXNzZWRGcmFtZXNGb3JSZXNl dCAvIDYwLjApOworICAgIGJvb2wgc2NoZWR1bGVyQWxsb3dzRG91YmxlRnJhbWVzID0gIUNDUHJv eHk6Omhhc0ltcGxUaHJlYWQoKTsKKyAgICByZXR1cm4gKHNjaGVkdWxlckFsbG93c0RvdWJsZUZy YW1lcyAmJiBkZWx0YSA8IGtGcmFtZVRvb0Zhc3QpIHx8IHRvb1Nsb3c7Cit9CisKIHZvaWQgQ0NI ZWFkc1VwRGlzcGxheTo6ZHJhd0h1ZENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwg Y29uc3QgSW50U2l6ZSYgaHVkU2l6ZSkKIHsKICAgICBpZiAoc2hvd1BsYXRmb3JtTGF5ZXJUcmVl KCkpIHsKQEAgLTE4MSwxMSArMjAwLDExIEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0h1 ZENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgSW50U2l6ZSYKICAgICAg ICAgY29udGV4dC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDAsIDAsIGh1ZFNpemUud2lkdGgoKSwgaHVk U2l6ZS5oZWlnaHQoKSkpOwogICAgIH0KIAotICAgIGludCBmcHNDb3VudGVySGVpZ2h0ID0gMjU7 CisgICAgaW50IGZwc0NvdW50ZXJIZWlnaHQgPSBtX21lZGl1bUZvbnQtPmZvbnRNZXRyaWNzKCku ZmxvYXRIZWlnaHQoKSArIDQwOwogICAgIGludCBmcHNDb3VudGVyVG9wID0gMjsKICAgICBpbnQg cGxhdGZvcm1MYXllclRyZWVUb3A7CiAgICAgaWYgKHNldHRpbmdzKCkuc2hvd0ZQU0NvdW50ZXIp Ci0gICAgICAgIHBsYXRmb3JtTGF5ZXJUcmVlVG9wID0gZnBzQ291bnRlclRvcCArIGZwc0NvdW50 ZXJIZWlnaHQgKyAyOworICAgICAgICBwbGF0Zm9ybUxheWVyVHJlZVRvcCA9IGZwc0NvdW50ZXJU b3AgKyBmcHNDb3VudGVySGVpZ2h0OwogICAgIGVsc2UKICAgICAgICAgcGxhdGZvcm1MYXllclRy ZWVUb3AgPSAwOwogCkBAIC0xOTYsMzYgKzIxNSw2OSBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6 OmRyYXdIdWRDb250ZW50cyhHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFNpemUm CiAgICAgICAgIGRyYXdQbGF0Zm9ybUxheWVyVHJlZShjb250ZXh0LCBwbGF0Zm9ybUxheWVyVHJl ZVRvcCk7CiB9CiAKLXZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0ZQU0NvdW50ZXIoR3JhcGhp Y3NDb250ZXh0KiBjb250ZXh0LCBpbnQgdG9wLCBpbnQgaGVpZ2h0KQordm9pZCBDQ0hlYWRzVXBE aXNwbGF5OjpnZXRBdmVyYWdlRlBTQW5kU3RhbmRhcmREZXZpYXRpb24oZG91YmxlICphdmVyYWdl LCBkb3VibGUgKnN0YW5kYXJkRGV2aWF0aW9uKSBjb25zdAogewotICAgIC8vIE5vdGUgdGhhdCBz aW5jZSB3ZSBoYXZlbid0IGZpbmlzaGVkIHRoZSBjdXJyZW50IGZyYW1lLCB0aGUgRlBTIGNvdW50 ZXIKLSAgICAvLyBhY3R1YWxseSByZXBvcnRzIHRoZSBsYXN0IGZyYW1lJ3MgdGltZS4KLSAgICBk b3VibGUgc2VjRm9yTGFzdEZyYW1lID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbKG1fY3VycmVu dEZyYW1lTnVtYmVyICsga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSAtIDEpICUga0JlZ2luRnJhbWVI aXN0b3J5U2l6ZV0gLQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhp c3RvcnlJblNlY1sobV9jdXJyZW50RnJhbWVOdW1iZXIgKyBrQmVnaW5GcmFtZUhpc3RvcnlTaXpl IC0gMikgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplXTsKLQotICAgIC8vIEZpbHRlciB0aGUgZnJh bWUgdGltZXMgdG8gYXZvaWQgc3Bpa2VzLgotICAgIGNvbnN0IGZsb2F0IGFscGhhID0gMC4xOwot ICAgIGlmICghbV9maWx0ZXJlZEZyYW1lVGltZSkgewotICAgICAgICBpZiAobV9jdXJyZW50RnJh bWVOdW1iZXIgPT0gMikKLSAgICAgICAgICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSBzZWNGb3JM YXN0RnJhbWU7Ci0gICAgfSBlbHNlCi0gICAgICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSAoKDEu MCAtIGFscGhhKSAqIG1fZmlsdGVyZWRGcmFtZVRpbWUpICsgKGFscGhhICogc2VjRm9yTGFzdEZy YW1lKTsKKyAgICBkb3VibGUmIGF2ZXJhZ2VGUFMgPSAqYXZlcmFnZTsKKworICAgIGludCBmcmFt ZSA9IG1fY3VycmVudEZyYW1lTnVtYmVyIC0gMTsgCisgICAgYXZlcmFnZUZQUyA9IDA7CisgICAg aW50IGF2ZXJhZ2VGUFNDb3VudCA9IDA7CisgICAgZG91YmxlIGZwc1ZhcmlhbmNlTnVtZXJhdG9y ID0gMDsKKworICAgIC8vIFdhbGsgYmFja3dhcmRzIHRocm91Z2ggdGhlIHNhbXBsZXMgbG9va2lu ZyBmb3IgYSBydW4gb2YgZ29vZCBmcmFtZQorICAgIC8vIHRpbWluZ3MgZnJvbSB3aGljaCB0byBj b21wdXRlIHRoZSBtZWFuIGFuZCBzdGFuZGFyZCBkZXZpYXRpb24uCisgICAgLy8KKyAgICAvLyBT bG93IGZyYW1lcyBvY2N1ciBqdXN0IGJlY2F1c2UgdGhlIHVzZXIgaXMgaW5hY3RpdmUsIGFuZCBz aG91bGQgYmUKKyAgICAvLyBpZ25vcmVkLiBGYXN0IGZyYW1lcyBhcmUgaWdub3JlZCBpZiB0aGUg c2NoZWR1bGVyIGlzIGluIHNpbmdsZS10aHJlYWQKKyAgICAvLyBtb2RlIGluIG9yZGVyIHRvIHJl cHJlc2VudCB0aGUgdHJ1ZSBmcmFtZSByYXRlIGluIHNwaXRlIG9mIHRoZSBmYWN0IHRoYXQKKyAg ICAvLyB0aGUgZmlyc3QgZmV3IHN3YXBidWZmZXJzIGhhcHBlbiBpbnN0YW50bHkgd2hpY2ggc2tl d3MgdGhlIHN0YXRpc3RpY3MKKyAgICAvLyB0b28gbXVjaCBmb3Igc2hvcnQgbGl2ZWQgYW5pbWF0 aW9ucy4KKyAgICAvLworICAgIC8vIGlzQmFkRnJhbWUgZW5jYXBzdWxhdGVzIHRoZSBmcmFtZSB0 b28gc2xvdy9mcmFtZSB0b28gZmFzdCBsb2dpYy4KKyAgICB3aGlsZSAoMSkgeworICAgICAgICBp ZiAoIWlzQmFkRnJhbWUoZnJhbWUpKSB7CisgICAgICAgICAgICBhdmVyYWdlRlBTQ291bnQrKzsK KyAgICAgICAgICAgIGRvdWJsZSBzZWNGb3JMYXN0RnJhbWUgPSBtX2JlZ2luVGltZUhpc3RvcnlJ blNlY1tmcmFtZUluZGV4KGZyYW1lKV0gLQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2ZyYW1lSW5kZXgoZnJhbWUgLSAxKV07Cisg ICAgICAgICAgICBkb3VibGUgeCA9IDEuMCAvIHNlY0Zvckxhc3RGcmFtZTsKKyAgICAgICAgICAg IGRvdWJsZSBkZWx0YUZyb21BdmVyYWdlID0geCAtIGF2ZXJhZ2VGUFM7CisgICAgICAgICAgICAv LyBDaGFuZ2Ugd2l0aCBjYXV0aW9uIC0gbnVtZXJpY3MuIGh0dHA6Ly9lbi53aWtpcGVkaWEub3Jn L3dpa2kvU3RhbmRhcmRfZGV2aWF0aW9uCisgICAgICAgICAgICBhdmVyYWdlRlBTID0gYXZlcmFn ZUZQUyArIGRlbHRhRnJvbUF2ZXJhZ2UgLyBhdmVyYWdlRlBTQ291bnQ7CisgICAgICAgICAgICBm cHNWYXJpYW5jZU51bWVyYXRvciA9IGZwc1ZhcmlhbmNlTnVtZXJhdG9yICsgZGVsdGFGcm9tQXZl cmFnZSAqICh4IC0gYXZlcmFnZUZQUyk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKGF2ZXJhZ2VG UFNDb3VudCAmJiBpc0JhZEZyYW1lKGZyYW1lKSkgeworICAgICAgICAgICAgLy8gV2UndmUgZ2F0 aGVyZWQgYSBydW4gb2YgZ29vZCBzYW1wbGVzLCBzbyBzdG9wLgorICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgIH0KKyAgICAgICAgLS1mcmFtZTsKKyAgICAgICAgaWYgKGZyYW1lSW5kZXgoZnJh bWUpID09IGZyYW1lSW5kZXgobV9jdXJyZW50RnJhbWVOdW1iZXIpIHx8IGZyYW1lIDwgMCkgewor ICAgICAgICAgICAgLy8gV2UndmUgZ29uZSB0aHJvdWdoIGFsbCBhdmFpbGFibGUgaGlzdG9yaWNh bCBkYXRhLCBzbyBzdG9wLgorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisK KyAgICAqc3RhbmRhcmREZXZpYXRpb24gPSBzcXJ0KGZwc1ZhcmlhbmNlTnVtZXJhdG9yIC8gYXZl cmFnZUZQU0NvdW50KTsKK30KIAordm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRl cihHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGludCB0b3AsIGludCBoZWlnaHQpCit7CiAgICAg ZmxvYXQgdGV4dFdpZHRoID0gMDsKICAgICBpZiAoIUNDUHJveHk6OmltcGxUaHJlYWQoKSkKICAg ICAgICAgdGV4dFdpZHRoID0gZHJhd0ZQU0NvdW50ZXJUZXh0KGNvbnRleHQsIHRvcCwgaGVpZ2h0 KTsKIAogICAgIGZsb2F0IGdyYXBoV2lkdGggPSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOwogCi0g ICAgLy8gRHJhdyBiYWNrZ3JvdW5kIGZvciBncmFwaAotICAgIGNvbnRleHQtPnNldEZpbGxDb2xv cihDb2xvcigwLCAwLCAwLCAyNTUpLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKLSAgICBjb250ZXh0 LT5maWxsUmVjdChGbG9hdFJlY3QoMiArIHRleHRXaWR0aCwgdG9wLCBncmFwaFdpZHRoLCBoZWln aHQpKTsKLQogICAgIC8vIERyYXcgRlBTIGdyYXBoLgotICAgIGNvbnN0IGRvdWJsZSBsb0ZQUyA9 IDAuMDsKLSAgICBjb25zdCBkb3VibGUgaGlGUFMgPSAxMjAuMDsKKyAgICBjb25zdCBkb3VibGUg bG9GUFMgPSAwOworICAgIGNvbnN0IGRvdWJsZSBoaUZQUyA9IDgwOwogICAgIGNvbnRleHQtPnNl dFN0cm9rZVN0eWxlKFNvbGlkU3Ryb2tlKTsKKyAgICBjb250ZXh0LT5zZXRGaWxsQ29sb3IoQ29s b3IoMTU0LCAyMDUsIDUwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CisgICAgY29udGV4dC0+Zmls bFJlY3QoRmxvYXRSZWN0KDIgKyB0ZXh0V2lkdGgsIHRvcCwgZ3JhcGhXaWR0aCwgaGVpZ2h0IC8g MikpOworICAgIGNvbnRleHQtPnNldEZpbGxDb2xvcihDb2xvcigyNTUsIDI1MCwgMjA1KSwgQ29s b3JTcGFjZURldmljZVJHQik7CisgICAgY29udGV4dC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIgKyB0 ZXh0V2lkdGgsIHRvcCArIGhlaWdodCAvIDIsIGdyYXBoV2lkdGgsIGhlaWdodCAvIDIpKTsKICAg ICBjb250ZXh0LT5zZXRTdHJva2VDb2xvcihDb2xvcigyNTUsIDAsIDApLCBDb2xvclNwYWNlRGV2 aWNlUkdCKTsKKyAgICBjb250ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29s b3JTcGFjZURldmljZVJHQik7CisKICAgICBpbnQgZ3JhcGhMZWZ0ID0gc3RhdGljX2Nhc3Q8aW50 Pih0ZXh0V2lkdGggKyAzKTsKICAgICBJbnRQb2ludCBwcmV2KC0xLCAwKTsKICAgICBpbnQgeCA9 IDA7CkBAIC0yMzMsNiArMjg1LDEwIEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0ZQU0Nv dW50ZXIoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBpbnQgdG9wLCBpbnQgaGVpCiAgICAgZm9y IChpbnQgaSA9IG1fY3VycmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZTsg aSAhPSAobV9jdXJyZW50RnJhbWVOdW1iZXIgLSAxKSAlIGtCZWdpbkZyYW1lSGlzdG9yeVNpemU7 IGkgPSAoaSArIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSkgewogICAgICAgICBpbnQgaiA9 IChpICsgMSkgJSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOwogICAgICAgICBkb3VibGUgZnBzID0g MS4wIC8gKG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW2pdIC0gbV9iZWdpblRpbWVIaXN0b3J5SW5T ZWNbaV0pOworICAgICAgICBpZiAoaXNCYWRGcmFtZShqKSkgeworICAgICAgICAgICAgeCArPSAx OworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KICAgICAgICAgZG91YmxlIHAgPSAx IC0gKChmcHMgLSBsb0ZQUykgLyAoaGlGUFMgLSBsb0ZQUykpOwogICAgICAgICBpZiAocCA8IDAp CiAgICAgICAgICAgICBwID0gMDsKQEAgLTI1MSwyMSArMzA3LDIyIEBAIGZsb2F0IENDSGVhZHNV cERpc3BsYXk6OmRyYXdGUFNDb3VudGVyVGV4dChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGlu dCB0b3AsIGluCiAgICAgQVNTRVJUKCFDQ1Byb3h5OjppbXBsVGhyZWFkKCkpOwogCiAgICAgRm9u dENhY2hlUHVyZ2VQcmV2ZW50ZXIgZm9udENhY2hlUHVyZ2VQcmV2ZW50ZXI7CisgICAgZG91Ymxl IGF2ZXJhZ2VGUFMsIHN0ZERldmlhdGlvbjsKKworICAgIGdldEF2ZXJhZ2VGUFNBbmRTdGFuZGFy ZERldmlhdGlvbigmYXZlcmFnZUZQUywgJnN0ZERldmlhdGlvbik7CiAKLSAgICAvLyBDcmVhdGUg JiBtZWFzdXJlIEZQUyB0ZXh0LgotICAgIFN0cmluZyB0ZXh0KFN0cmluZzo6Zm9ybWF0KCJGUFM6 ICU1LjFmIiwgMS4wIC8gbV9maWx0ZXJlZEZyYW1lVGltZSkpOwotICAgIFRleHRSdW4gcnVuKHRl eHQpOwotICAgIGZsb2F0IHRleHRXaWR0aCA9IG1fbWVkaXVtRm9udC0+d2lkdGgocnVuKSArIDIu MGY7CisgICAgU3RyaW5nIGZwcyhTdHJpbmc6OmZvcm1hdCgiRlBTOiAlNC4xZiArLy0lMy4xZiIs IGF2ZXJhZ2VGUFMsIHN0ZERldmlhdGlvbikpOworICAgIFRleHRSdW4gdGV4dChmcHMpOworICAg IGZsb2F0IHRleHRXaWR0aCA9IG1fbWVkaXVtRm9udC0+d2lkdGgodGV4dCkgKyAyOwogCiAgICAg Ly8gRHJhdyBiYWNrZ3JvdW5kLgogICAgIGNvbnRleHQtPnNldEZpbGxDb2xvcihDb2xvcigwLCAw LCAwLCAyNTUpLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKLSAgICBjb250ZXh0LT5maWxsUmVjdChG bG9hdFJlY3QoMiwgdG9wLCB0ZXh0V2lkdGgsIGhlaWdodCkpOworICAgIGRvdWJsZSBmb250SGVp Z2h0ID0gbV9tZWRpdW1Gb250LT5mb250TWV0cmljcygpLmZsb2F0SGVpZ2h0KCkgKyAyOworICAg IGNvbnRleHQtPmZpbGxSZWN0KEZsb2F0UmVjdCgyLCB0b3AsIHRleHRXaWR0aCwgZm9udEhlaWdo dCkpOwogCiAgICAgLy8gRHJhdyBGUFMgdGV4dC4KLSAgICBpZiAobV9maWx0ZXJlZEZyYW1lVGlt ZSkgewotICAgICAgICBjb250ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29s b3JTcGFjZURldmljZVJHQik7Ci0gICAgICAgIGNvbnRleHQtPmRyYXdUZXh0KCptX21lZGl1bUZv bnQsIHJ1biwgSW50UG9pbnQoMywgdG9wICsgaGVpZ2h0IC0gNikpOwotICAgIH0KKyAgICBjb250 ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjAwLCAyMDAsIDIwMCksIENvbG9yU3BhY2VEZXZpY2VS R0IpOworICAgIGNvbnRleHQtPmRyYXdUZXh0KCptX21lZGl1bUZvbnQsIHRleHQsIEludFBvaW50 KDMsIHRvcCArIGZvbnRIZWlnaHQgLSA0KSk7CiAKICAgICByZXR1cm4gdGV4dFdpZHRoOwogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NIZWFkc1VwRGlzcGxheS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oCmluZGV4IDVhZGM5ZTkwNmI4ZmY1OGVhODM3ZjNi MjMyNjdjMDYwODUzMWM4MDAuLjM4ZWY5N2RkZDczNzljODJjZDMzZDM1YjY3Y2EyNTY4ZWE4YzUz NjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L2NjL0NDSGVhZHNVcERpc3BsYXkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmgKQEAgLTY3LDYgKzY3LDkgQEAgcHJp dmF0ZToKICAgICBmbG9hdCBkcmF3RlBTQ291bnRlclRleHQoR3JhcGhpY3NDb250ZXh0KiwgaW50 IHRvcCwgaW50IGhlaWdodCk7CiAgICAgdm9pZCBkcmF3UGxhdGZvcm1MYXllclRyZWUoR3JhcGhp Y3NDb250ZXh0KiwgaW50IHRvcCk7CiAgICAgY29uc3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MoKSBj b25zdDsKKyAgICBib29sIGlzQmFkRnJhbWUoaW50IGZyYW1lTnVtYmVyKSBjb25zdDsKKyAgICBp bnQgZnJhbWVJbmRleChpbnQgZnJhbWVOdW1iZXIpIGNvbnN0OworICAgIHZvaWQgZ2V0QXZlcmFn ZUZQU0FuZFN0YW5kYXJkRGV2aWF0aW9uKGRvdWJsZSAqYXZlcmFnZSwgZG91YmxlICpzdGFuZGFy ZERldmlhdGlvbikgY29uc3Q7CiAKICAgICBib29sIHNob3dQbGF0Zm9ybUxheWVyVHJlZSgpIGNv bnN0OwogCkBAIC03NCwxNCArNzcsMTcgQEAgcHJpdmF0ZToKIAogICAgIGludCBtX2N1cnJlbnRG cmFtZU51bWJlcjsKIAotICAgIGRvdWJsZSBtX2ZpbHRlcmVkRnJhbWVUaW1lOwotCiAgICAgT3du UHRyPE1hbmFnZWRUZXh0dXJlPiBtX2h1ZFRleHR1cmU7CiAKICAgICBMYXllclJlbmRlcmVyQ2hy b21pdW0qIG1fbGF5ZXJSZW5kZXJlcjsKIAotICAgIHN0YXRpYyBjb25zdCBpbnQga0JlZ2luRnJh bWVIaXN0b3J5U2l6ZSA9IDY0OworICAgIHN0YXRpYyBjb25zdCBpbnQga0JlZ2luRnJhbWVIaXN0 b3J5U2l6ZSA9IDEyMDsKKyAgICAvLyBUaGUgbnVtYmVyIG9mIHNlY29uZHMgb2Ygbm8gZnJhbWVz IG1ha2VzIHVzIGRlY2lkZSB0aGF0IHRoZSBwcmV2aW91cworICAgIC8vIGFuaW1hdGlvbiBpcyBv dmVyLgorICAgIHN0YXRpYyBjb25zdCBkb3VibGUga0lkbGVTZWNvbmRzVHJpZ2dlcnNSZXNldCA9 IDAuNTsKICAgICBkb3VibGUgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNba0JlZ2luRnJhbWVIaXN0 b3J5U2l6ZV07CisgICAgc3RhdGljIGNvbnN0IGRvdWJsZSBrRnJhbWVUb29GYXN0ID0gMS4wIC8g NzA7CisgICAgc3RhdGljIGNvbnN0IGludCBrTnVtTWlzc2VkRnJhbWVzRm9yUmVzZXQgPSA1Owog CiAgICAgT3duUHRyPEZvbnQ+IG1fc21hbGxGb250OwogICAgIE93blB0cjxGb250PiBtX21lZGl1 bUZvbnQ7Cg== 136634 2012-04-10 23:39:04 -0700 2012-04-11 10:45:03 -0700 Patch bug-73454-20120411023902.patch text/plain 12295 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzODEzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWFlYWM0MDVhOWFkZWJi NjAwY2U2NmYwMTc1NjMyMzY5NjU4ZTcxZC4uMDAxMTAzMDdmMDAwMDA3NThmNjdhOGY0MjkwMWI3 M2FhNTYxN2ViMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEyLTA0LTExICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBhbmQgdG8ga2VlcCBzdGF0aXN0aWNzIG9u IGZyYW1lIHJhdGUgYmV0d2VlbgorICAgICAgICBwYXVzZXMgaW4gdGhlIGFjdGl2aXR5IGluIHRo ZSBVSSBzbyB0aGF0IHlvdSBjYW4gdHJpZ2dlciBhCisgICAgICAgIHRyYW5zaXRpb24gYW5kIHJl YWQgb2ZmIHRoZSBhdmVyYWdlIGFuZCBzdGFuZGFyZCBkZXZpYXRpb24gZm9yCisgICAgICAgIHRo YXQgdHJhbnNpdGlvbiB0byBqdWRnZSBpdCBzbW9vdGggZW5vdWdoIG9yIG5vdC4KKworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhVRCBpcyBub3QgdGVz dGFibGUgaW4gd2Via2l0LgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NIZWFkc1VwRGlzcGxheS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNw bGF5OjpDQ0hlYWRzVXBEaXNwbGF5KToKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3Bs YXk6Om9uRnJhbWVCZWdpbik6CisgICAgICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5Ojpk cmF3SHVkQ29udGVudHMpOgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6ZHJh d0ZQU0NvdW50ZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND SGVhZHNVcERpc3BsYXkuaDoKKwogMjAxMi0wNC0xMCAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgQWRkIGEgZnVuY3Rpb24gdG8gc2V0IGVtcHR5IGNsaWVudHMg dG8gYSBQYWdlQ2xpZW50cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAppbmRleCBl NGIxNWQ3MjFmNzNhYmI5NWJlYWE5OGNkNDAzNzUxOTcxYTA1YTE4Li4wNjM3MTY4Y2QyYWY2MjFj OGYwNDJhZWZiYzg4ZTFhNDBkYzI0MGQ3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5 LmNwcApAQCAtNTAsNyArNTAsNiBAQCB1c2luZyBuYW1lc3BhY2Ugc3RkOwogCiBDQ0hlYWRzVXBE aXNwbGF5OjpDQ0hlYWRzVXBEaXNwbGF5KExheWVyUmVuZGVyZXJDaHJvbWl1bSogb3duZXIpCiAg ICAgOiBtX2N1cnJlbnRGcmFtZU51bWJlcigxKQotICAgICwgbV9maWx0ZXJlZEZyYW1lVGltZSgw KQogICAgICwgbV9sYXllclJlbmRlcmVyKG93bmVyKQogICAgICwgbV91c2VNYXBTdWJGb3JVcGxv YWRzKG93bmVyLT5jb250ZXh0U3VwcG9ydHNNYXBTdWIoKSkKIHsKQEAgLTc0LDcgKzczLDcgQEAg dm9pZCBDQ0hlYWRzVXBEaXNwbGF5Ojppbml0aWFsaXplRm9udHMoKQogICAgIEFTU0VSVCghQ0NQ cm94eTo6aW1wbFRocmVhZCgpKTsKICAgICBGb250RGVzY3JpcHRpb24gbWVkaXVtRm9udERlc2M7 CiAgICAgbWVkaXVtRm9udERlc2Muc2V0R2VuZXJpY0ZhbWlseShGb250RGVzY3JpcHRpb246Ok1v bm9zcGFjZUZhbWlseSk7Ci0gICAgbWVkaXVtRm9udERlc2Muc2V0Q29tcHV0ZWRTaXplKDIwKTsK KyAgICBtZWRpdW1Gb250RGVzYy5zZXRDb21wdXRlZFNpemUoMTIpOwogCiAgICAgbV9tZWRpdW1G b250ID0gYWRvcHRQdHIobmV3IEZvbnQobWVkaXVtRm9udERlc2MsIDAsIDApKTsKICAgICBtX21l ZGl1bUZvbnQtPnVwZGF0ZSgwKTsKQEAgLTg3LDkgKzg2LDIwIEBAIHZvaWQgQ0NIZWFkc1VwRGlz cGxheTo6aW5pdGlhbGl6ZUZvbnRzKCkKICAgICBtX3NtYWxsRm9udC0+dXBkYXRlKDApOwogfQog CisvLyBzYWZlTW9kIHdvcmtzIG9uIC0xLCByZXR1cm5pbmcgbS0xIGluIHRoYXQgY2FzZS4KK3N0 YXRpYyBpbmxpbmUgaW50IHNhZmVNb2QoaW50IG51bWJlciwgaW50IG1vZHVsdXMpCit7CisgICAg cmV0dXJuIChudW1iZXIgKyBtb2R1bHVzKSAlIG1vZHVsdXM7Cit9CisKK2lubGluZSBpbnQgQ0NI ZWFkc1VwRGlzcGxheTo6ZnJhbWVJbmRleChpbnQgZnJhbWUpIGNvbnN0Cit7CisgICAgcmV0dXJu IHNhZmVNb2QoZnJhbWUsIGtCZWdpbkZyYW1lSGlzdG9yeVNpemUpOworfQorCiB2b2lkIENDSGVh ZHNVcERpc3BsYXk6Om9uRnJhbWVCZWdpbihkb3VibGUgdGltZXN0YW1wKQogewotICAgIG1fYmVn aW5UaW1lSGlzdG9yeUluU2VjW21fY3VycmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVIaXN0 b3J5U2l6ZV0gPSB0aW1lc3RhbXA7CisgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbZnJhbWVJ bmRleChtX2N1cnJlbnRGcmFtZU51bWJlcildID0gdGltZXN0YW1wOwogfQogCiB2b2lkIENDSGVh ZHNVcERpc3BsYXk6Om9uU3dhcEJ1ZmZlcnMoKQpAQCAtMTc0LDYgKzE4NCwxNSBAQCB2b2lkIEND SGVhZHNVcERpc3BsYXk6OmRyYXcoKQogICAgIG1faHVkVGV4dHVyZS0+dW5yZXNlcnZlKCk7CiB9 CiAKK2Jvb2wgQ0NIZWFkc1VwRGlzcGxheTo6aXNCYWRGcmFtZShpbnQgZnJhbWVOdW1iZXIpIGNv bnN0Cit7CisgICAgZG91YmxlIGRlbHRhID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbZnJhbWVJ bmRleChmcmFtZU51bWJlcildIC0KKyAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhpc3Rv cnlJblNlY1tmcmFtZUluZGV4KGZyYW1lTnVtYmVyIC0gMSldOworICAgIGJvb2wgdG9vU2xvdyA9 IGRlbHRhID4gKGtOdW1NaXNzZWRGcmFtZXNGb3JSZXNldCAvIDYwLjApOworICAgIGJvb2wgc2No ZWR1bGVyQWxsb3dzRG91YmxlRnJhbWVzID0gIUNDUHJveHk6Omhhc0ltcGxUaHJlYWQoKTsKKyAg ICByZXR1cm4gKHNjaGVkdWxlckFsbG93c0RvdWJsZUZyYW1lcyAmJiBkZWx0YSA8IGtGcmFtZVRv b0Zhc3QpIHx8IHRvb1Nsb3c7Cit9CisKIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0h1ZENv bnRlbnRzKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgSW50U2l6ZSYgaHVkU2l6ZSkK IHsKICAgICBpZiAoc2hvd1BsYXRmb3JtTGF5ZXJUcmVlKCkpIHsKQEAgLTE4MSwxMSArMjAwLDEx IEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0h1ZENvbnRlbnRzKEdyYXBoaWNzQ29udGV4 dCogY29udGV4dCwgY29uc3QgSW50U2l6ZSYKICAgICAgICAgY29udGV4dC0+ZmlsbFJlY3QoRmxv YXRSZWN0KDAsIDAsIGh1ZFNpemUud2lkdGgoKSwgaHVkU2l6ZS5oZWlnaHQoKSkpOwogICAgIH0K IAotICAgIGludCBmcHNDb3VudGVySGVpZ2h0ID0gMjU7CisgICAgaW50IGZwc0NvdW50ZXJIZWln aHQgPSBtX21lZGl1bUZvbnQtPmZvbnRNZXRyaWNzKCkuZmxvYXRIZWlnaHQoKSArIDQwOwogICAg IGludCBmcHNDb3VudGVyVG9wID0gMjsKICAgICBpbnQgcGxhdGZvcm1MYXllclRyZWVUb3A7CiAg ICAgaWYgKHNldHRpbmdzKCkuc2hvd0ZQU0NvdW50ZXIpCi0gICAgICAgIHBsYXRmb3JtTGF5ZXJU cmVlVG9wID0gZnBzQ291bnRlclRvcCArIGZwc0NvdW50ZXJIZWlnaHQgKyAyOworICAgICAgICBw bGF0Zm9ybUxheWVyVHJlZVRvcCA9IGZwc0NvdW50ZXJUb3AgKyBmcHNDb3VudGVySGVpZ2h0Owog ICAgIGVsc2UKICAgICAgICAgcGxhdGZvcm1MYXllclRyZWVUb3AgPSAwOwogCkBAIC0xOTYsMzYg KzIxNSw2OSBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXdIdWRDb250ZW50cyhHcmFwaGlj c0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFNpemUmCiAgICAgICAgIGRyYXdQbGF0Zm9ybUxh eWVyVHJlZShjb250ZXh0LCBwbGF0Zm9ybUxheWVyVHJlZVRvcCk7CiB9CiAKLXZvaWQgQ0NIZWFk c1VwRGlzcGxheTo6ZHJhd0ZQU0NvdW50ZXIoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBpbnQg dG9wLCBpbnQgaGVpZ2h0KQordm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpnZXRBdmVyYWdlRlBTQW5k U3RhbmRhcmREZXZpYXRpb24oZG91YmxlICphdmVyYWdlLCBkb3VibGUgKnN0YW5kYXJkRGV2aWF0 aW9uKSBjb25zdAogewotICAgIC8vIE5vdGUgdGhhdCBzaW5jZSB3ZSBoYXZlbid0IGZpbmlzaGVk IHRoZSBjdXJyZW50IGZyYW1lLCB0aGUgRlBTIGNvdW50ZXIKLSAgICAvLyBhY3R1YWxseSByZXBv cnRzIHRoZSBsYXN0IGZyYW1lJ3MgdGltZS4KLSAgICBkb3VibGUgc2VjRm9yTGFzdEZyYW1lID0g bV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbKG1fY3VycmVudEZyYW1lTnVtYmVyICsga0JlZ2luRnJh bWVIaXN0b3J5U2l6ZSAtIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV0gLQotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1sobV9jdXJyZW50RnJh bWVOdW1iZXIgKyBrQmVnaW5GcmFtZUhpc3RvcnlTaXplIC0gMikgJSBrQmVnaW5GcmFtZUhpc3Rv cnlTaXplXTsKLQotICAgIC8vIEZpbHRlciB0aGUgZnJhbWUgdGltZXMgdG8gYXZvaWQgc3Bpa2Vz LgotICAgIGNvbnN0IGZsb2F0IGFscGhhID0gMC4xOwotICAgIGlmICghbV9maWx0ZXJlZEZyYW1l VGltZSkgewotICAgICAgICBpZiAobV9jdXJyZW50RnJhbWVOdW1iZXIgPT0gMikKLSAgICAgICAg ICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSBzZWNGb3JMYXN0RnJhbWU7Ci0gICAgfSBlbHNlCi0g ICAgICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSAoKDEuMCAtIGFscGhhKSAqIG1fZmlsdGVyZWRG cmFtZVRpbWUpICsgKGFscGhhICogc2VjRm9yTGFzdEZyYW1lKTsKKyAgICBkb3VibGUmIGF2ZXJh Z2VGUFMgPSAqYXZlcmFnZTsKKworICAgIGludCBmcmFtZSA9IG1fY3VycmVudEZyYW1lTnVtYmVy IC0gMTsgCisgICAgYXZlcmFnZUZQUyA9IDA7CisgICAgaW50IGF2ZXJhZ2VGUFNDb3VudCA9IDA7 CisgICAgZG91YmxlIGZwc1ZhcmlhbmNlTnVtZXJhdG9yID0gMDsKKworICAgIC8vIFdhbGsgYmFj a3dhcmRzIHRocm91Z2ggdGhlIHNhbXBsZXMgbG9va2luZyBmb3IgYSBydW4gb2YgZ29vZCBmcmFt ZQorICAgIC8vIHRpbWluZ3MgZnJvbSB3aGljaCB0byBjb21wdXRlIHRoZSBtZWFuIGFuZCBzdGFu ZGFyZCBkZXZpYXRpb24uCisgICAgLy8KKyAgICAvLyBTbG93IGZyYW1lcyBvY2N1ciBqdXN0IGJl Y2F1c2UgdGhlIHVzZXIgaXMgaW5hY3RpdmUsIGFuZCBzaG91bGQgYmUKKyAgICAvLyBpZ25vcmVk LiBGYXN0IGZyYW1lcyBhcmUgaWdub3JlZCBpZiB0aGUgc2NoZWR1bGVyIGlzIGluIHNpbmdsZS10 aHJlYWQKKyAgICAvLyBtb2RlIGluIG9yZGVyIHRvIHJlcHJlc2VudCB0aGUgdHJ1ZSBmcmFtZSBy YXRlIGluIHNwaXRlIG9mIHRoZSBmYWN0IHRoYXQKKyAgICAvLyB0aGUgZmlyc3QgZmV3IHN3YXBi dWZmZXJzIGhhcHBlbiBpbnN0YW50bHkgd2hpY2ggc2tld3MgdGhlIHN0YXRpc3RpY3MKKyAgICAv LyB0b28gbXVjaCBmb3Igc2hvcnQgbGl2ZWQgYW5pbWF0aW9ucy4KKyAgICAvLworICAgIC8vIGlz QmFkRnJhbWUgZW5jYXBzdWxhdGVzIHRoZSBmcmFtZSB0b28gc2xvdy9mcmFtZSB0b28gZmFzdCBs b2dpYy4KKyAgICB3aGlsZSAoMSkgeworICAgICAgICBpZiAoIWlzQmFkRnJhbWUoZnJhbWUpKSB7 CisgICAgICAgICAgICBhdmVyYWdlRlBTQ291bnQrKzsKKyAgICAgICAgICAgIGRvdWJsZSBzZWNG b3JMYXN0RnJhbWUgPSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tmcmFtZUluZGV4KGZyYW1lKV0g LQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fYmVnaW5UaW1lSGlzdG9y eUluU2VjW2ZyYW1lSW5kZXgoZnJhbWUgLSAxKV07CisgICAgICAgICAgICBkb3VibGUgeCA9IDEu MCAvIHNlY0Zvckxhc3RGcmFtZTsKKyAgICAgICAgICAgIGRvdWJsZSBkZWx0YUZyb21BdmVyYWdl ID0geCAtIGF2ZXJhZ2VGUFM7CisgICAgICAgICAgICAvLyBDaGFuZ2Ugd2l0aCBjYXV0aW9uIC0g bnVtZXJpY3MuIGh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvU3RhbmRhcmRfZGV2aWF0aW9u CisgICAgICAgICAgICBhdmVyYWdlRlBTID0gYXZlcmFnZUZQUyArIGRlbHRhRnJvbUF2ZXJhZ2Ug LyBhdmVyYWdlRlBTQ291bnQ7CisgICAgICAgICAgICBmcHNWYXJpYW5jZU51bWVyYXRvciA9IGZw c1ZhcmlhbmNlTnVtZXJhdG9yICsgZGVsdGFGcm9tQXZlcmFnZSAqICh4IC0gYXZlcmFnZUZQUyk7 CisgICAgICAgIH0KKyAgICAgICAgaWYgKGF2ZXJhZ2VGUFNDb3VudCAmJiBpc0JhZEZyYW1lKGZy YW1lKSkgeworICAgICAgICAgICAgLy8gV2UndmUgZ2F0aGVyZWQgYSBydW4gb2YgZ29vZCBzYW1w bGVzLCBzbyBzdG9wLgorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICAgICAgLS1m cmFtZTsKKyAgICAgICAgaWYgKGZyYW1lSW5kZXgoZnJhbWUpID09IGZyYW1lSW5kZXgobV9jdXJy ZW50RnJhbWVOdW1iZXIpIHx8IGZyYW1lIDwgMCkgeworICAgICAgICAgICAgLy8gV2UndmUgZ29u ZSB0aHJvdWdoIGFsbCBhdmFpbGFibGUgaGlzdG9yaWNhbCBkYXRhLCBzbyBzdG9wLgorICAgICAg ICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICAqc3RhbmRhcmREZXZpYXRpb24g PSBzcXJ0KGZwc1ZhcmlhbmNlTnVtZXJhdG9yIC8gYXZlcmFnZUZQU0NvdW50KTsKK30KIAordm9p ZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRleHQqIGNvbnRl eHQsIGludCB0b3AsIGludCBoZWlnaHQpCit7CiAgICAgZmxvYXQgdGV4dFdpZHRoID0gMDsKICAg ICBpZiAoIUNDUHJveHk6OmltcGxUaHJlYWQoKSkKICAgICAgICAgdGV4dFdpZHRoID0gZHJhd0ZQ U0NvdW50ZXJUZXh0KGNvbnRleHQsIHRvcCwgaGVpZ2h0KTsKIAogICAgIGZsb2F0IGdyYXBoV2lk dGggPSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOwogCi0gICAgLy8gRHJhdyBiYWNrZ3JvdW5kIGZv ciBncmFwaAotICAgIGNvbnRleHQtPnNldEZpbGxDb2xvcihDb2xvcigwLCAwLCAwLCAyNTUpLCBD b2xvclNwYWNlRGV2aWNlUkdCKTsKLSAgICBjb250ZXh0LT5maWxsUmVjdChGbG9hdFJlY3QoMiAr IHRleHRXaWR0aCwgdG9wLCBncmFwaFdpZHRoLCBoZWlnaHQpKTsKLQogICAgIC8vIERyYXcgRlBT IGdyYXBoLgotICAgIGNvbnN0IGRvdWJsZSBsb0ZQUyA9IDAuMDsKLSAgICBjb25zdCBkb3VibGUg aGlGUFMgPSAxMjAuMDsKKyAgICBjb25zdCBkb3VibGUgbG9GUFMgPSAwOworICAgIGNvbnN0IGRv dWJsZSBoaUZQUyA9IDgwOwogICAgIGNvbnRleHQtPnNldFN0cm9rZVN0eWxlKFNvbGlkU3Ryb2tl KTsKKyAgICBjb250ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3IoMTU0LCAyMDUsIDUwKSwgQ29sb3JT cGFjZURldmljZVJHQik7CisgICAgY29udGV4dC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIgKyB0ZXh0 V2lkdGgsIHRvcCwgZ3JhcGhXaWR0aCwgaGVpZ2h0IC8gMikpOworICAgIGNvbnRleHQtPnNldEZp bGxDb2xvcihDb2xvcigyNTUsIDI1MCwgMjA1KSwgQ29sb3JTcGFjZURldmljZVJHQik7CisgICAg Y29udGV4dC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIgKyB0ZXh0V2lkdGgsIHRvcCArIGhlaWdodCAv IDIsIGdyYXBoV2lkdGgsIGhlaWdodCAvIDIpKTsKICAgICBjb250ZXh0LT5zZXRTdHJva2VDb2xv cihDb2xvcigyNTUsIDAsIDApLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjb250ZXh0LT5z ZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7CisKICAg ICBpbnQgZ3JhcGhMZWZ0ID0gc3RhdGljX2Nhc3Q8aW50Pih0ZXh0V2lkdGggKyAzKTsKICAgICBJ bnRQb2ludCBwcmV2KC0xLCAwKTsKICAgICBpbnQgeCA9IDA7CkBAIC0yMzMsNiArMjg1LDEwIEBA IHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0ZQU0NvdW50ZXIoR3JhcGhpY3NDb250ZXh0KiBj b250ZXh0LCBpbnQgdG9wLCBpbnQgaGVpCiAgICAgZm9yIChpbnQgaSA9IG1fY3VycmVudEZyYW1l TnVtYmVyICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZTsgaSAhPSAobV9jdXJyZW50RnJhbWVOdW1i ZXIgLSAxKSAlIGtCZWdpbkZyYW1lSGlzdG9yeVNpemU7IGkgPSAoaSArIDEpICUga0JlZ2luRnJh bWVIaXN0b3J5U2l6ZSkgewogICAgICAgICBpbnQgaiA9IChpICsgMSkgJSBrQmVnaW5GcmFtZUhp c3RvcnlTaXplOwogICAgICAgICBkb3VibGUgZnBzID0gMS4wIC8gKG1fYmVnaW5UaW1lSGlzdG9y eUluU2VjW2pdIC0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbaV0pOworICAgICAgICBpZiAoaXNC YWRGcmFtZShqKSkgeworICAgICAgICAgICAgeCArPSAxOworICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgIH0KICAgICAgICAgZG91YmxlIHAgPSAxIC0gKChmcHMgLSBsb0ZQUykgLyAoaGlG UFMgLSBsb0ZQUykpOwogICAgICAgICBpZiAocCA8IDApCiAgICAgICAgICAgICBwID0gMDsKQEAg LTI1MSwyMSArMzA3LDIyIEBAIGZsb2F0IENDSGVhZHNVcERpc3BsYXk6OmRyYXdGUFNDb3VudGVy VGV4dChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGludCB0b3AsIGluCiAgICAgQVNTRVJUKCFD Q1Byb3h5OjppbXBsVGhyZWFkKCkpOwogCiAgICAgRm9udENhY2hlUHVyZ2VQcmV2ZW50ZXIgZm9u dENhY2hlUHVyZ2VQcmV2ZW50ZXI7CisgICAgZG91YmxlIGF2ZXJhZ2VGUFMsIHN0ZERldmlhdGlv bjsKKworICAgIGdldEF2ZXJhZ2VGUFNBbmRTdGFuZGFyZERldmlhdGlvbigmYXZlcmFnZUZQUywg JnN0ZERldmlhdGlvbik7CiAKLSAgICAvLyBDcmVhdGUgJiBtZWFzdXJlIEZQUyB0ZXh0LgotICAg IFN0cmluZyB0ZXh0KFN0cmluZzo6Zm9ybWF0KCJGUFM6ICU1LjFmIiwgMS4wIC8gbV9maWx0ZXJl ZEZyYW1lVGltZSkpOwotICAgIFRleHRSdW4gcnVuKHRleHQpOwotICAgIGZsb2F0IHRleHRXaWR0 aCA9IG1fbWVkaXVtRm9udC0+d2lkdGgocnVuKSArIDIuMGY7CisgICAgU3RyaW5nIGZwcyhTdHJp bmc6OmZvcm1hdCgiRlBTOiAlNC4xZiArLy0lMy4xZiIsIGF2ZXJhZ2VGUFMsIHN0ZERldmlhdGlv bikpOworICAgIFRleHRSdW4gdGV4dChmcHMpOworICAgIGZsb2F0IHRleHRXaWR0aCA9IG1fbWVk aXVtRm9udC0+d2lkdGgodGV4dCkgKyAyOwogCiAgICAgLy8gRHJhdyBiYWNrZ3JvdW5kLgogICAg IGNvbnRleHQtPnNldEZpbGxDb2xvcihDb2xvcigwLCAwLCAwLCAyNTUpLCBDb2xvclNwYWNlRGV2 aWNlUkdCKTsKLSAgICBjb250ZXh0LT5maWxsUmVjdChGbG9hdFJlY3QoMiwgdG9wLCB0ZXh0V2lk dGgsIGhlaWdodCkpOworICAgIGRvdWJsZSBmb250SGVpZ2h0ID0gbV9tZWRpdW1Gb250LT5mb250 TWV0cmljcygpLmZsb2F0SGVpZ2h0KCkgKyAyOworICAgIGNvbnRleHQtPmZpbGxSZWN0KEZsb2F0 UmVjdCgyLCB0b3AsIHRleHRXaWR0aCwgZm9udEhlaWdodCkpOwogCiAgICAgLy8gRHJhdyBGUFMg dGV4dC4KLSAgICBpZiAobV9maWx0ZXJlZEZyYW1lVGltZSkgewotICAgICAgICBjb250ZXh0LT5z ZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7Ci0gICAg ICAgIGNvbnRleHQtPmRyYXdUZXh0KCptX21lZGl1bUZvbnQsIHJ1biwgSW50UG9pbnQoMywgdG9w ICsgaGVpZ2h0IC0gNikpOwotICAgIH0KKyAgICBjb250ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3Io MjAwLCAyMDAsIDIwMCksIENvbG9yU3BhY2VEZXZpY2VSR0IpOworICAgIGNvbnRleHQtPmRyYXdU ZXh0KCptX21lZGl1bUZvbnQsIHRleHQsIEludFBvaW50KDMsIHRvcCArIGZvbnRIZWlnaHQgLSA0 KSk7CiAKICAgICByZXR1cm4gdGV4dFdpZHRoOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxh eS5oCmluZGV4IDVhZGM5ZTkwNmI4ZmY1OGVhODM3ZjNiMjMyNjdjMDYwODUzMWM4MDAuLjM4ZWY5 N2RkZDczNzljODJjZDMzZDM1YjY3Y2EyNTY4ZWE4YzUzNjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDSGVhZHNVcERpc3BsYXkuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRz VXBEaXNwbGF5LmgKQEAgLTY3LDYgKzY3LDkgQEAgcHJpdmF0ZToKICAgICBmbG9hdCBkcmF3RlBT Q291bnRlclRleHQoR3JhcGhpY3NDb250ZXh0KiwgaW50IHRvcCwgaW50IGhlaWdodCk7CiAgICAg dm9pZCBkcmF3UGxhdGZvcm1MYXllclRyZWUoR3JhcGhpY3NDb250ZXh0KiwgaW50IHRvcCk7CiAg ICAgY29uc3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MoKSBjb25zdDsKKyAgICBib29sIGlzQmFkRnJh bWUoaW50IGZyYW1lTnVtYmVyKSBjb25zdDsKKyAgICBpbnQgZnJhbWVJbmRleChpbnQgZnJhbWVO dW1iZXIpIGNvbnN0OworICAgIHZvaWQgZ2V0QXZlcmFnZUZQU0FuZFN0YW5kYXJkRGV2aWF0aW9u KGRvdWJsZSAqYXZlcmFnZSwgZG91YmxlICpzdGFuZGFyZERldmlhdGlvbikgY29uc3Q7CiAKICAg ICBib29sIHNob3dQbGF0Zm9ybUxheWVyVHJlZSgpIGNvbnN0OwogCkBAIC03NCwxNCArNzcsMTcg QEAgcHJpdmF0ZToKIAogICAgIGludCBtX2N1cnJlbnRGcmFtZU51bWJlcjsKIAotICAgIGRvdWJs ZSBtX2ZpbHRlcmVkRnJhbWVUaW1lOwotCiAgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBtX2h1 ZFRleHR1cmU7CiAKICAgICBMYXllclJlbmRlcmVyQ2hyb21pdW0qIG1fbGF5ZXJSZW5kZXJlcjsK IAotICAgIHN0YXRpYyBjb25zdCBpbnQga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSA9IDY0OworICAg IHN0YXRpYyBjb25zdCBpbnQga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSA9IDEyMDsKKyAgICAvLyBU aGUgbnVtYmVyIG9mIHNlY29uZHMgb2Ygbm8gZnJhbWVzIG1ha2VzIHVzIGRlY2lkZSB0aGF0IHRo ZSBwcmV2aW91cworICAgIC8vIGFuaW1hdGlvbiBpcyBvdmVyLgorICAgIHN0YXRpYyBjb25zdCBk b3VibGUga0lkbGVTZWNvbmRzVHJpZ2dlcnNSZXNldCA9IDAuNTsKICAgICBkb3VibGUgbV9iZWdp blRpbWVIaXN0b3J5SW5TZWNba0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV07CisgICAgc3RhdGljIGNv bnN0IGRvdWJsZSBrRnJhbWVUb29GYXN0ID0gMS4wIC8gNzA7CisgICAgc3RhdGljIGNvbnN0IGlu dCBrTnVtTWlzc2VkRnJhbWVzRm9yUmVzZXQgPSA1OwogCiAgICAgT3duUHRyPEZvbnQ+IG1fc21h bGxGb250OwogICAgIE93blB0cjxGb250PiBtX21lZGl1bUZvbnQ7Cg== 136696 2012-04-11 10:45:08 -0700 2012-04-11 15:48:59 -0700 Patch bug-73454-20120411134507.patch text/plain 12455 anicolao U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzODEzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWFlYWM0MDVhOWFkZWJi NjAwY2U2NmYwMTc1NjMyMzY5NjU4ZTcxZC4uMDAxMTAzMDdmMDAwMDA3NThmNjdhOGY0MjkwMWI3 M2FhNTYxN2ViMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEyLTA0LTExICBBbGV4 IE5pY29sYW91ICA8YW5pY29sYW9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0g V2hlbiByZW5kZXJpbmcgZ29lcyBpZGxlLCBkbyBub3QgY291bnQgdGhhdCB0aW1lIGFnYWluc3Qg ZnJhbWUgcmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NzM0NTQKKworICAgICAgICBUaGUgRlBTIGNvdW50ZXIgaGFkIGEgZmV3IGlzc3VlcyB3aXRo IGl0cyByZXBvcnRpbmcuIFRoZSBmaXJzdAorICAgICAgICAzIHN3YXBidWZmZXJzIGFyZSBub24t YmxvY2tpbmcgYW5kIGNyZWF0ZSBGUFMgcmF0ZXMgdGhhdCBhcmUKKyAgICAgICAgdW5yZWFsaXN0 aWNhbGx5IGhpZ2gsIHRocm93aW5nIG9mZiB0aGUgbW92aW5nIGF2ZXJhZ2VzIGFuZAorICAgICAg ICBpbnRyb2R1Y2luZyBmYWxzZSBzcGlrZXMgaW50byB0aGUgRlBTIGdyYXBoLiBUaGVyZSB3YXMg YWxzbyBubworICAgICAgICB3YXkgdG8gbW9uaXRvciB0aGUgc21vb3RobmVzcyBvZiB0aGUgYW5p bWF0aW9uLCBvciB0byBmb2N1cyBpbgorICAgICAgICBvbiBhIHBhcnRpY3VsYXIgYW5pbWF0aW9u IG9yIHRyYW5zaXRpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCB1cGRhdGVzIHRoZSBGUFMgY291 bnRlciBjb2RlIHNvIHRoYXQgYmFkIGRhdGEgcG9pbnRzCisgICAgICAgIGFyZSB0cmltbWVkIGFu ZCBub3QgZ3JhcGhlZDsgc28gdGhhdCB0aGUgZ3JhcGggaXRzZWxmIGlzIHRhbGxlcgorICAgICAg ICBhbmQgbW9yZSBsZWdpYmxlOyBzbyB0aGF0IHRoZXJlIGlzIGEgY2xlYXIgYm91bmRhcnkgYmV0 d2VlbiA0MEZQUworICAgICAgICBhbmQgYmV0dGVyOyBhbmQgdG8ga2VlcCBzdGF0aXN0aWNzIG9u IGZyYW1lIHJhdGUgYmV0d2VlbgorICAgICAgICBwYXVzZXMgaW4gdGhlIGFjdGl2aXR5IGluIHRo ZSBVSSBzbyB0aGF0IHlvdSBjYW4gdHJpZ2dlciBhCisgICAgICAgIHRyYW5zaXRpb24gYW5kIHJl YWQgb2ZmIHRoZSBhdmVyYWdlIGFuZCBzdGFuZGFyZCBkZXZpYXRpb24gZm9yCisgICAgICAgIHRo YXQgdHJhbnNpdGlvbiB0byBqdWRnZSBpdCBzbW9vdGggZW5vdWdoIG9yIG5vdC4KKworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEhVRCBpcyBub3QgdGVz dGFibGUgaW4gd2Via2l0LgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NIZWFkc1VwRGlzcGxheS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNw bGF5OjpDQ0hlYWRzVXBEaXNwbGF5KToKKyAgICAgICAgKFdlYkNvcmU6OkNDSGVhZHNVcERpc3Bs YXk6Om9uRnJhbWVCZWdpbik6CisgICAgICAgIChXZWJDb3JlOjpDQ0hlYWRzVXBEaXNwbGF5Ojpk cmF3SHVkQ29udGVudHMpOgorICAgICAgICAoV2ViQ29yZTo6Q0NIZWFkc1VwRGlzcGxheTo6ZHJh d0ZQU0NvdW50ZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND SGVhZHNVcERpc3BsYXkuaDoKKwogMjAxMi0wNC0xMCAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgQWRkIGEgZnVuY3Rpb24gdG8gc2V0IGVtcHR5IGNsaWVudHMg dG8gYSBQYWdlQ2xpZW50cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAppbmRleCBl NGIxNWQ3MjFmNzNhYmI5NWJlYWE5OGNkNDAzNzUxOTcxYTA1YTE4Li41OGYzZDA1YzhjNDcyZDdm Nzc1OGQ2NTNhYjczNjc1NTQ4MmYxNDkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5 LmNwcApAQCAtNTAsNyArNTAsNiBAQCB1c2luZyBuYW1lc3BhY2Ugc3RkOwogCiBDQ0hlYWRzVXBE aXNwbGF5OjpDQ0hlYWRzVXBEaXNwbGF5KExheWVyUmVuZGVyZXJDaHJvbWl1bSogb3duZXIpCiAg ICAgOiBtX2N1cnJlbnRGcmFtZU51bWJlcigxKQotICAgICwgbV9maWx0ZXJlZEZyYW1lVGltZSgw KQogICAgICwgbV9sYXllclJlbmRlcmVyKG93bmVyKQogICAgICwgbV91c2VNYXBTdWJGb3JVcGxv YWRzKG93bmVyLT5jb250ZXh0U3VwcG9ydHNNYXBTdWIoKSkKIHsKQEAgLTY5LDEyICs2OCwxNSBA QCBDQ0hlYWRzVXBEaXNwbGF5Ojp+Q0NIZWFkc1VwRGlzcGxheSgpCiB7CiB9CiAKK2NvbnN0IGRv dWJsZSBDQ0hlYWRzVXBEaXNwbGF5OjprSWRsZVNlY29uZHNUcmlnZ2Vyc1Jlc2V0ID0gMC41Owor Y29uc3QgZG91YmxlIENDSGVhZHNVcERpc3BsYXk6OmtGcmFtZVRvb0Zhc3QgPSAxLjAgLyA3MDsK Kwogdm9pZCBDQ0hlYWRzVXBEaXNwbGF5Ojppbml0aWFsaXplRm9udHMoKQogewogICAgIEFTU0VS VCghQ0NQcm94eTo6aW1wbFRocmVhZCgpKTsKICAgICBGb250RGVzY3JpcHRpb24gbWVkaXVtRm9u dERlc2M7CiAgICAgbWVkaXVtRm9udERlc2Muc2V0R2VuZXJpY0ZhbWlseShGb250RGVzY3JpcHRp b246Ok1vbm9zcGFjZUZhbWlseSk7Ci0gICAgbWVkaXVtRm9udERlc2Muc2V0Q29tcHV0ZWRTaXpl KDIwKTsKKyAgICBtZWRpdW1Gb250RGVzYy5zZXRDb21wdXRlZFNpemUoMTIpOwogCiAgICAgbV9t ZWRpdW1Gb250ID0gYWRvcHRQdHIobmV3IEZvbnQobWVkaXVtRm9udERlc2MsIDAsIDApKTsKICAg ICBtX21lZGl1bUZvbnQtPnVwZGF0ZSgwKTsKQEAgLTg3LDkgKzg5LDIwIEBAIHZvaWQgQ0NIZWFk c1VwRGlzcGxheTo6aW5pdGlhbGl6ZUZvbnRzKCkKICAgICBtX3NtYWxsRm9udC0+dXBkYXRlKDAp OwogfQogCisvLyBzYWZlTW9kIHdvcmtzIG9uIC0xLCByZXR1cm5pbmcgbS0xIGluIHRoYXQgY2Fz ZS4KK3N0YXRpYyBpbmxpbmUgaW50IHNhZmVNb2QoaW50IG51bWJlciwgaW50IG1vZHVsdXMpCit7 CisgICAgcmV0dXJuIChudW1iZXIgKyBtb2R1bHVzKSAlIG1vZHVsdXM7Cit9CisKK2lubGluZSBp bnQgQ0NIZWFkc1VwRGlzcGxheTo6ZnJhbWVJbmRleChpbnQgZnJhbWUpIGNvbnN0Cit7CisgICAg cmV0dXJuIHNhZmVNb2QoZnJhbWUsIGtCZWdpbkZyYW1lSGlzdG9yeVNpemUpOworfQorCiB2b2lk IENDSGVhZHNVcERpc3BsYXk6Om9uRnJhbWVCZWdpbihkb3VibGUgdGltZXN0YW1wKQogewotICAg IG1fYmVnaW5UaW1lSGlzdG9yeUluU2VjW21fY3VycmVudEZyYW1lTnVtYmVyICUga0JlZ2luRnJh bWVIaXN0b3J5U2l6ZV0gPSB0aW1lc3RhbXA7CisgICAgbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNb ZnJhbWVJbmRleChtX2N1cnJlbnRGcmFtZU51bWJlcildID0gdGltZXN0YW1wOwogfQogCiB2b2lk IENDSGVhZHNVcERpc3BsYXk6Om9uU3dhcEJ1ZmZlcnMoKQpAQCAtMTc0LDYgKzE4NywxNSBAQCB2 b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXcoKQogICAgIG1faHVkVGV4dHVyZS0+dW5yZXNlcnZl KCk7CiB9CiAKK2Jvb2wgQ0NIZWFkc1VwRGlzcGxheTo6aXNCYWRGcmFtZShpbnQgZnJhbWVOdW1i ZXIpIGNvbnN0Cit7CisgICAgZG91YmxlIGRlbHRhID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNb ZnJhbWVJbmRleChmcmFtZU51bWJlcildIC0KKyAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGlt ZUhpc3RvcnlJblNlY1tmcmFtZUluZGV4KGZyYW1lTnVtYmVyIC0gMSldOworICAgIGJvb2wgdG9v U2xvdyA9IGRlbHRhID4gKGtOdW1NaXNzZWRGcmFtZXNGb3JSZXNldCAvIDYwLjApOworICAgIGJv b2wgc2NoZWR1bGVyQWxsb3dzRG91YmxlRnJhbWVzID0gIUNDUHJveHk6Omhhc0ltcGxUaHJlYWQo KTsKKyAgICByZXR1cm4gKHNjaGVkdWxlckFsbG93c0RvdWJsZUZyYW1lcyAmJiBkZWx0YSA8IGtG cmFtZVRvb0Zhc3QpIHx8IHRvb1Nsb3c7Cit9CisKIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJh d0h1ZENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgSW50U2l6ZSYgaHVk U2l6ZSkKIHsKICAgICBpZiAoc2hvd1BsYXRmb3JtTGF5ZXJUcmVlKCkpIHsKQEAgLTE4MSwxMSAr MjAzLDExIEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0h1ZENvbnRlbnRzKEdyYXBoaWNz Q29udGV4dCogY29udGV4dCwgY29uc3QgSW50U2l6ZSYKICAgICAgICAgY29udGV4dC0+ZmlsbFJl Y3QoRmxvYXRSZWN0KDAsIDAsIGh1ZFNpemUud2lkdGgoKSwgaHVkU2l6ZS5oZWlnaHQoKSkpOwog ICAgIH0KIAotICAgIGludCBmcHNDb3VudGVySGVpZ2h0ID0gMjU7CisgICAgaW50IGZwc0NvdW50 ZXJIZWlnaHQgPSBtX21lZGl1bUZvbnQtPmZvbnRNZXRyaWNzKCkuZmxvYXRIZWlnaHQoKSArIDQw OwogICAgIGludCBmcHNDb3VudGVyVG9wID0gMjsKICAgICBpbnQgcGxhdGZvcm1MYXllclRyZWVU b3A7CiAgICAgaWYgKHNldHRpbmdzKCkuc2hvd0ZQU0NvdW50ZXIpCi0gICAgICAgIHBsYXRmb3Jt TGF5ZXJUcmVlVG9wID0gZnBzQ291bnRlclRvcCArIGZwc0NvdW50ZXJIZWlnaHQgKyAyOworICAg ICAgICBwbGF0Zm9ybUxheWVyVHJlZVRvcCA9IGZwc0NvdW50ZXJUb3AgKyBmcHNDb3VudGVySGVp Z2h0OwogICAgIGVsc2UKICAgICAgICAgcGxhdGZvcm1MYXllclRyZWVUb3AgPSAwOwogCkBAIC0x OTYsMzYgKzIxOCw2OSBAQCB2b2lkIENDSGVhZHNVcERpc3BsYXk6OmRyYXdIdWRDb250ZW50cyhH cmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEludFNpemUmCiAgICAgICAgIGRyYXdQbGF0 Zm9ybUxheWVyVHJlZShjb250ZXh0LCBwbGF0Zm9ybUxheWVyVHJlZVRvcCk7CiB9CiAKLXZvaWQg Q0NIZWFkc1VwRGlzcGxheTo6ZHJhd0ZQU0NvdW50ZXIoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0 LCBpbnQgdG9wLCBpbnQgaGVpZ2h0KQordm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpnZXRBdmVyYWdl RlBTQW5kU3RhbmRhcmREZXZpYXRpb24oZG91YmxlICphdmVyYWdlLCBkb3VibGUgKnN0YW5kYXJk RGV2aWF0aW9uKSBjb25zdAogewotICAgIC8vIE5vdGUgdGhhdCBzaW5jZSB3ZSBoYXZlbid0IGZp bmlzaGVkIHRoZSBjdXJyZW50IGZyYW1lLCB0aGUgRlBTIGNvdW50ZXIKLSAgICAvLyBhY3R1YWxs eSByZXBvcnRzIHRoZSBsYXN0IGZyYW1lJ3MgdGltZS4KLSAgICBkb3VibGUgc2VjRm9yTGFzdEZy YW1lID0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbKG1fY3VycmVudEZyYW1lTnVtYmVyICsga0Jl Z2luRnJhbWVIaXN0b3J5U2l6ZSAtIDEpICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV0gLQotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1sobV9jdXJy ZW50RnJhbWVOdW1iZXIgKyBrQmVnaW5GcmFtZUhpc3RvcnlTaXplIC0gMikgJSBrQmVnaW5GcmFt ZUhpc3RvcnlTaXplXTsKLQotICAgIC8vIEZpbHRlciB0aGUgZnJhbWUgdGltZXMgdG8gYXZvaWQg c3Bpa2VzLgotICAgIGNvbnN0IGZsb2F0IGFscGhhID0gMC4xOwotICAgIGlmICghbV9maWx0ZXJl ZEZyYW1lVGltZSkgewotICAgICAgICBpZiAobV9jdXJyZW50RnJhbWVOdW1iZXIgPT0gMikKLSAg ICAgICAgICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSBzZWNGb3JMYXN0RnJhbWU7Ci0gICAgfSBl bHNlCi0gICAgICAgIG1fZmlsdGVyZWRGcmFtZVRpbWUgPSAoKDEuMCAtIGFscGhhKSAqIG1fZmls dGVyZWRGcmFtZVRpbWUpICsgKGFscGhhICogc2VjRm9yTGFzdEZyYW1lKTsKKyAgICBkb3VibGUm IGF2ZXJhZ2VGUFMgPSAqYXZlcmFnZTsKKworICAgIGludCBmcmFtZSA9IG1fY3VycmVudEZyYW1l TnVtYmVyIC0gMTsgCisgICAgYXZlcmFnZUZQUyA9IDA7CisgICAgaW50IGF2ZXJhZ2VGUFNDb3Vu dCA9IDA7CisgICAgZG91YmxlIGZwc1ZhcmlhbmNlTnVtZXJhdG9yID0gMDsKKworICAgIC8vIFdh bGsgYmFja3dhcmRzIHRocm91Z2ggdGhlIHNhbXBsZXMgbG9va2luZyBmb3IgYSBydW4gb2YgZ29v ZCBmcmFtZQorICAgIC8vIHRpbWluZ3MgZnJvbSB3aGljaCB0byBjb21wdXRlIHRoZSBtZWFuIGFu ZCBzdGFuZGFyZCBkZXZpYXRpb24uCisgICAgLy8KKyAgICAvLyBTbG93IGZyYW1lcyBvY2N1ciBq dXN0IGJlY2F1c2UgdGhlIHVzZXIgaXMgaW5hY3RpdmUsIGFuZCBzaG91bGQgYmUKKyAgICAvLyBp Z25vcmVkLiBGYXN0IGZyYW1lcyBhcmUgaWdub3JlZCBpZiB0aGUgc2NoZWR1bGVyIGlzIGluIHNp bmdsZS10aHJlYWQKKyAgICAvLyBtb2RlIGluIG9yZGVyIHRvIHJlcHJlc2VudCB0aGUgdHJ1ZSBm cmFtZSByYXRlIGluIHNwaXRlIG9mIHRoZSBmYWN0IHRoYXQKKyAgICAvLyB0aGUgZmlyc3QgZmV3 IHN3YXBidWZmZXJzIGhhcHBlbiBpbnN0YW50bHkgd2hpY2ggc2tld3MgdGhlIHN0YXRpc3RpY3MK KyAgICAvLyB0b28gbXVjaCBmb3Igc2hvcnQgbGl2ZWQgYW5pbWF0aW9ucy4KKyAgICAvLworICAg IC8vIGlzQmFkRnJhbWUgZW5jYXBzdWxhdGVzIHRoZSBmcmFtZSB0b28gc2xvdy9mcmFtZSB0b28g ZmFzdCBsb2dpYy4KKyAgICB3aGlsZSAoMSkgeworICAgICAgICBpZiAoIWlzQmFkRnJhbWUoZnJh bWUpKSB7CisgICAgICAgICAgICBhdmVyYWdlRlBTQ291bnQrKzsKKyAgICAgICAgICAgIGRvdWJs ZSBzZWNGb3JMYXN0RnJhbWUgPSBtX2JlZ2luVGltZUhpc3RvcnlJblNlY1tmcmFtZUluZGV4KGZy YW1lKV0gLQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fYmVnaW5UaW1l SGlzdG9yeUluU2VjW2ZyYW1lSW5kZXgoZnJhbWUgLSAxKV07CisgICAgICAgICAgICBkb3VibGUg eCA9IDEuMCAvIHNlY0Zvckxhc3RGcmFtZTsKKyAgICAgICAgICAgIGRvdWJsZSBkZWx0YUZyb21B dmVyYWdlID0geCAtIGF2ZXJhZ2VGUFM7CisgICAgICAgICAgICAvLyBDaGFuZ2Ugd2l0aCBjYXV0 aW9uIC0gbnVtZXJpY3MuIGh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvU3RhbmRhcmRfZGV2 aWF0aW9uCisgICAgICAgICAgICBhdmVyYWdlRlBTID0gYXZlcmFnZUZQUyArIGRlbHRhRnJvbUF2 ZXJhZ2UgLyBhdmVyYWdlRlBTQ291bnQ7CisgICAgICAgICAgICBmcHNWYXJpYW5jZU51bWVyYXRv ciA9IGZwc1ZhcmlhbmNlTnVtZXJhdG9yICsgZGVsdGFGcm9tQXZlcmFnZSAqICh4IC0gYXZlcmFn ZUZQUyk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKGF2ZXJhZ2VGUFNDb3VudCAmJiBpc0JhZEZy YW1lKGZyYW1lKSkgeworICAgICAgICAgICAgLy8gV2UndmUgZ2F0aGVyZWQgYSBydW4gb2YgZ29v ZCBzYW1wbGVzLCBzbyBzdG9wLgorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICAg ICAgLS1mcmFtZTsKKyAgICAgICAgaWYgKGZyYW1lSW5kZXgoZnJhbWUpID09IGZyYW1lSW5kZXgo bV9jdXJyZW50RnJhbWVOdW1iZXIpIHx8IGZyYW1lIDwgMCkgeworICAgICAgICAgICAgLy8gV2Un dmUgZ29uZSB0aHJvdWdoIGFsbCBhdmFpbGFibGUgaGlzdG9yaWNhbCBkYXRhLCBzbyBzdG9wLgor ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICAqc3RhbmRhcmREZXZp YXRpb24gPSBzcXJ0KGZwc1ZhcmlhbmNlTnVtZXJhdG9yIC8gYXZlcmFnZUZQU0NvdW50KTsKK30K IAordm9pZCBDQ0hlYWRzVXBEaXNwbGF5OjpkcmF3RlBTQ291bnRlcihHcmFwaGljc0NvbnRleHQq IGNvbnRleHQsIGludCB0b3AsIGludCBoZWlnaHQpCit7CiAgICAgZmxvYXQgdGV4dFdpZHRoID0g MDsKICAgICBpZiAoIUNDUHJveHk6OmltcGxUaHJlYWQoKSkKICAgICAgICAgdGV4dFdpZHRoID0g ZHJhd0ZQU0NvdW50ZXJUZXh0KGNvbnRleHQsIHRvcCwgaGVpZ2h0KTsKIAogICAgIGZsb2F0IGdy YXBoV2lkdGggPSBrQmVnaW5GcmFtZUhpc3RvcnlTaXplOwogCi0gICAgLy8gRHJhdyBiYWNrZ3Jv dW5kIGZvciBncmFwaAotICAgIGNvbnRleHQtPnNldEZpbGxDb2xvcihDb2xvcigwLCAwLCAwLCAy NTUpLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKLSAgICBjb250ZXh0LT5maWxsUmVjdChGbG9hdFJl Y3QoMiArIHRleHRXaWR0aCwgdG9wLCBncmFwaFdpZHRoLCBoZWlnaHQpKTsKLQogICAgIC8vIERy YXcgRlBTIGdyYXBoLgotICAgIGNvbnN0IGRvdWJsZSBsb0ZQUyA9IDAuMDsKLSAgICBjb25zdCBk b3VibGUgaGlGUFMgPSAxMjAuMDsKKyAgICBjb25zdCBkb3VibGUgbG9GUFMgPSAwOworICAgIGNv bnN0IGRvdWJsZSBoaUZQUyA9IDgwOwogICAgIGNvbnRleHQtPnNldFN0cm9rZVN0eWxlKFNvbGlk U3Ryb2tlKTsKKyAgICBjb250ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3IoMTU0LCAyMDUsIDUwKSwg Q29sb3JTcGFjZURldmljZVJHQik7CisgICAgY29udGV4dC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIg KyB0ZXh0V2lkdGgsIHRvcCwgZ3JhcGhXaWR0aCwgaGVpZ2h0IC8gMikpOworICAgIGNvbnRleHQt PnNldEZpbGxDb2xvcihDb2xvcigyNTUsIDI1MCwgMjA1KSwgQ29sb3JTcGFjZURldmljZVJHQik7 CisgICAgY29udGV4dC0+ZmlsbFJlY3QoRmxvYXRSZWN0KDIgKyB0ZXh0V2lkdGgsIHRvcCArIGhl aWdodCAvIDIsIGdyYXBoV2lkdGgsIGhlaWdodCAvIDIpKTsKICAgICBjb250ZXh0LT5zZXRTdHJv a2VDb2xvcihDb2xvcigyNTUsIDAsIDApLCBDb2xvclNwYWNlRGV2aWNlUkdCKTsKKyAgICBjb250 ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7 CisKICAgICBpbnQgZ3JhcGhMZWZ0ID0gc3RhdGljX2Nhc3Q8aW50Pih0ZXh0V2lkdGggKyAzKTsK ICAgICBJbnRQb2ludCBwcmV2KC0xLCAwKTsKICAgICBpbnQgeCA9IDA7CkBAIC0yMzMsNiArMjg4 LDEwIEBAIHZvaWQgQ0NIZWFkc1VwRGlzcGxheTo6ZHJhd0ZQU0NvdW50ZXIoR3JhcGhpY3NDb250 ZXh0KiBjb250ZXh0LCBpbnQgdG9wLCBpbnQgaGVpCiAgICAgZm9yIChpbnQgaSA9IG1fY3VycmVu dEZyYW1lTnVtYmVyICUga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZTsgaSAhPSAobV9jdXJyZW50RnJh bWVOdW1iZXIgLSAxKSAlIGtCZWdpbkZyYW1lSGlzdG9yeVNpemU7IGkgPSAoaSArIDEpICUga0Jl Z2luRnJhbWVIaXN0b3J5U2l6ZSkgewogICAgICAgICBpbnQgaiA9IChpICsgMSkgJSBrQmVnaW5G cmFtZUhpc3RvcnlTaXplOwogICAgICAgICBkb3VibGUgZnBzID0gMS4wIC8gKG1fYmVnaW5UaW1l SGlzdG9yeUluU2VjW2pdIC0gbV9iZWdpblRpbWVIaXN0b3J5SW5TZWNbaV0pOworICAgICAgICBp ZiAoaXNCYWRGcmFtZShqKSkgeworICAgICAgICAgICAgeCArPSAxOworICAgICAgICAgICAgY29u dGludWU7CisgICAgICAgIH0KICAgICAgICAgZG91YmxlIHAgPSAxIC0gKChmcHMgLSBsb0ZQUykg LyAoaGlGUFMgLSBsb0ZQUykpOwogICAgICAgICBpZiAocCA8IDApCiAgICAgICAgICAgICBwID0g MDsKQEAgLTI1MSwyMSArMzEwLDIyIEBAIGZsb2F0IENDSGVhZHNVcERpc3BsYXk6OmRyYXdGUFND b3VudGVyVGV4dChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGludCB0b3AsIGluCiAgICAgQVNT RVJUKCFDQ1Byb3h5OjppbXBsVGhyZWFkKCkpOwogCiAgICAgRm9udENhY2hlUHVyZ2VQcmV2ZW50 ZXIgZm9udENhY2hlUHVyZ2VQcmV2ZW50ZXI7CisgICAgZG91YmxlIGF2ZXJhZ2VGUFMsIHN0ZERl dmlhdGlvbjsKKworICAgIGdldEF2ZXJhZ2VGUFNBbmRTdGFuZGFyZERldmlhdGlvbigmYXZlcmFn ZUZQUywgJnN0ZERldmlhdGlvbik7CiAKLSAgICAvLyBDcmVhdGUgJiBtZWFzdXJlIEZQUyB0ZXh0 LgotICAgIFN0cmluZyB0ZXh0KFN0cmluZzo6Zm9ybWF0KCJGUFM6ICU1LjFmIiwgMS4wIC8gbV9m aWx0ZXJlZEZyYW1lVGltZSkpOwotICAgIFRleHRSdW4gcnVuKHRleHQpOwotICAgIGZsb2F0IHRl eHRXaWR0aCA9IG1fbWVkaXVtRm9udC0+d2lkdGgocnVuKSArIDIuMGY7CisgICAgU3RyaW5nIGZw cyhTdHJpbmc6OmZvcm1hdCgiRlBTOiAlNC4xZiArLy0lMy4xZiIsIGF2ZXJhZ2VGUFMsIHN0ZERl dmlhdGlvbikpOworICAgIFRleHRSdW4gdGV4dChmcHMpOworICAgIGZsb2F0IHRleHRXaWR0aCA9 IG1fbWVkaXVtRm9udC0+d2lkdGgodGV4dCkgKyAyOwogCiAgICAgLy8gRHJhdyBiYWNrZ3JvdW5k LgogICAgIGNvbnRleHQtPnNldEZpbGxDb2xvcihDb2xvcigwLCAwLCAwLCAyNTUpLCBDb2xvclNw YWNlRGV2aWNlUkdCKTsKLSAgICBjb250ZXh0LT5maWxsUmVjdChGbG9hdFJlY3QoMiwgdG9wLCB0 ZXh0V2lkdGgsIGhlaWdodCkpOworICAgIGRvdWJsZSBmb250SGVpZ2h0ID0gbV9tZWRpdW1Gb250 LT5mb250TWV0cmljcygpLmZsb2F0SGVpZ2h0KCkgKyAyOworICAgIGNvbnRleHQtPmZpbGxSZWN0 KEZsb2F0UmVjdCgyLCB0b3AsIHRleHRXaWR0aCwgZm9udEhlaWdodCkpOwogCiAgICAgLy8gRHJh dyBGUFMgdGV4dC4KLSAgICBpZiAobV9maWx0ZXJlZEZyYW1lVGltZSkgewotICAgICAgICBjb250 ZXh0LT5zZXRGaWxsQ29sb3IoQ29sb3IoMjU1LCAwLCAwKSwgQ29sb3JTcGFjZURldmljZVJHQik7 Ci0gICAgICAgIGNvbnRleHQtPmRyYXdUZXh0KCptX21lZGl1bUZvbnQsIHJ1biwgSW50UG9pbnQo MywgdG9wICsgaGVpZ2h0IC0gNikpOwotICAgIH0KKyAgICBjb250ZXh0LT5zZXRGaWxsQ29sb3Io Q29sb3IoMjAwLCAyMDAsIDIwMCksIENvbG9yU3BhY2VEZXZpY2VSR0IpOworICAgIGNvbnRleHQt PmRyYXdUZXh0KCptX21lZGl1bUZvbnQsIHRleHQsIEludFBvaW50KDMsIHRvcCArIGZvbnRIZWln aHQgLSA0KSk7CiAKICAgICByZXR1cm4gdGV4dFdpZHRoOwogfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1Vw RGlzcGxheS5oCmluZGV4IDVhZGM5ZTkwNmI4ZmY1OGVhODM3ZjNiMjMyNjdjMDYwODUzMWM4MDAu LmY5NjU5ZmQ4YTMwYWY2MGI3NDU1MmEwMzhlNTczNTk4NmYyYjg5OTQgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDSGVhZHNVcERpc3Bs YXkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0hlYWRzVXBEaXNwbGF5LmgKQEAgLTY3LDYgKzY3LDkgQEAgcHJpdmF0ZToKICAgICBmbG9hdCBk cmF3RlBTQ291bnRlclRleHQoR3JhcGhpY3NDb250ZXh0KiwgaW50IHRvcCwgaW50IGhlaWdodCk7 CiAgICAgdm9pZCBkcmF3UGxhdGZvcm1MYXllclRyZWUoR3JhcGhpY3NDb250ZXh0KiwgaW50IHRv cCk7CiAgICAgY29uc3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MoKSBjb25zdDsKKyAgICBib29sIGlz QmFkRnJhbWUoaW50IGZyYW1lTnVtYmVyKSBjb25zdDsKKyAgICBpbnQgZnJhbWVJbmRleChpbnQg ZnJhbWVOdW1iZXIpIGNvbnN0OworICAgIHZvaWQgZ2V0QXZlcmFnZUZQU0FuZFN0YW5kYXJkRGV2 aWF0aW9uKGRvdWJsZSAqYXZlcmFnZSwgZG91YmxlICpzdGFuZGFyZERldmlhdGlvbikgY29uc3Q7 CiAKICAgICBib29sIHNob3dQbGF0Zm9ybUxheWVyVHJlZSgpIGNvbnN0OwogCkBAIC03NCwxNCAr NzcsMTcgQEAgcHJpdmF0ZToKIAogICAgIGludCBtX2N1cnJlbnRGcmFtZU51bWJlcjsKIAotICAg IGRvdWJsZSBtX2ZpbHRlcmVkRnJhbWVUaW1lOwotCiAgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJl PiBtX2h1ZFRleHR1cmU7CiAKICAgICBMYXllclJlbmRlcmVyQ2hyb21pdW0qIG1fbGF5ZXJSZW5k ZXJlcjsKIAotICAgIHN0YXRpYyBjb25zdCBpbnQga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSA9IDY0 OworICAgIHN0YXRpYyBjb25zdCBpbnQga0JlZ2luRnJhbWVIaXN0b3J5U2l6ZSA9IDEyMDsKKyAg ICAvLyBUaGUgbnVtYmVyIG9mIHNlY29uZHMgb2Ygbm8gZnJhbWVzIG1ha2VzIHVzIGRlY2lkZSB0 aGF0IHRoZSBwcmV2aW91cworICAgIC8vIGFuaW1hdGlvbiBpcyBvdmVyLgorICAgIHN0YXRpYyBj b25zdCBkb3VibGUga0lkbGVTZWNvbmRzVHJpZ2dlcnNSZXNldDsKICAgICBkb3VibGUgbV9iZWdp blRpbWVIaXN0b3J5SW5TZWNba0JlZ2luRnJhbWVIaXN0b3J5U2l6ZV07CisgICAgc3RhdGljIGNv bnN0IGRvdWJsZSBrRnJhbWVUb29GYXN0OworICAgIHN0YXRpYyBjb25zdCBpbnQga051bU1pc3Nl ZEZyYW1lc0ZvclJlc2V0ID0gNTsKIAogICAgIE93blB0cjxGb250PiBtX3NtYWxsRm9udDsKICAg ICBPd25QdHI8Rm9udD4gbV9tZWRpdW1Gb250Owo=