34452 2010-02-01 15:21:43 -0800 Initial patch for audio engine: AudioBus and helper classes 2010-09-03 12:10:30 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Mac (Intel) OS X 10.5 RESOLVED FIXED P2 Normal --- 34907 0 crogers webkit-unassigned cmarrin dino eric.carlson kbr michaeln simon.fraser webkit.review.bot oldest_to_newest 186592 0 crogers 2010-02-01 15:21:43 -0800 This patch represents the first code for a new web audio engine explained here: https://lists.webkit.org/pipermail/webkit-dev/2010-February/011508.html This first patch includes the helper classes: AudioFloatArray, AudioDoubleArray, AudioChannel, AudioBus which are extensively used by the rest of the engine There are no javascript APIs yet to directly call this code so no layout tests. 186608 1 47874 crogers 2010-02-01 15:43:51 -0800 Created attachment 47874 patch for some initial audio engine support classes The AudioChannel, AudioBus, AudioFloatArray, and AudioDoubleArray classes are fundamental building blocks for the audio engine. 186613 2 webkit.review.bot 2010-02-01 15:46:46 -0800 Attachment 47874 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/platform/audio/AudioFloatArray.h:46: Code inside a namespace should not be indented. [whitespace/indent] [4] WebCore/platform/audio/AudioFloatArray.h:69: One space before end of line comments [whitespace/comments] [5] WebCore/platform/audio/AudioBus.cpp:187: More than one command on the same line in if [whitespace/parens] [4] WebCore/platform/audio/AudioBus.cpp:214: More than one command on the same line in if [whitespace/parens] [4] WebCore/platform/audio/AudioBus.cpp:301: More than one command on the same line in if [whitespace/parens] [4] WebCore/platform/audio/AudioBus.h:43: Code inside a namespace should not be indented. [whitespace/indent] [4] Total errors found: 6 If any of these errors are false positives, please file a bug against check-webkit-style. 186713 3 47884 crogers 2010-02-01 17:17:17 -0800 Created attachment 47884 patch for some initial audio engine support classes: fixes some minor style problems with the initial patch fixes some minor style problems with the initial patch 186724 4 simon.fraser 2010-02-01 17:37:58 -0800 The naming of "AudioChannel" and "AudioBus" are a little confusing to me. AudioChannel to me represents some higher-level concept ("the left channel"); it seems wrong for it to own samples. Would it be better to have an AudioSampleBuffer object that has an AudioDescription that says if the contents are interleaved, for example? 186780 5 crogers 2010-02-01 20:38:52 -0800 Hi Simon, thanks for having a look. If you think about it in CoreAudio terms, the AudioChannel is very similar to the "AudioBuffer" type in CoreAudio. The AudioBus is similar to "AudioBufferList". But, of course, since these are C++ classes they are somewhat easier to work with than the CoreAudio versions. Please note that these data types are used internally in the engine implementation and are not expected to be exposed through the javascript API, so I don't think we'll confuse our javascript developers with the naming conventions. For audio software engineers, a "bus" is a very common term in audio engineering and is used to denote a grouping of "channels". In schematic diagrams for audio devices they are often shown as a line with a small diagonal slash. From my perspective as an audio engineer, these terms are not at all surprising and I think they make a lot of sense. In the current engine code and any code I can envision for the future there will be no place for interleaved audio. Non-interleaved (planar) Float32 PCM (nominal -1 -> +1) will be the canonical format. The file-loading code I have written already takes care of the details of getting interleaved file data loaded into the right format. All of the AudioUnits I wrote at Apple conformed to this format. The AudioChannel and AudioBus classes have served very well as building blocks for the engine so far, and I'm very confident they will be sufficient to support future engine improvements like the modular routing we talked about. 187828 6 cmarrin 2010-02-04 09:12:40 -0800 I don't like the fact that there is an AudioFloatArray/AudioDoubleArray here. I thought you were using the WebGL buffer classes? We are looking at moving these to a separate spec, which would mean they would get a more generic name. But for now you should use WebGLFloatArray. You should also create a WebGLDoubleArray, which I believe will makes its way into the ArrayBuffer spec. Later on we can change the names as needed. 187879 7 crogers 2010-02-04 11:35:55 -0800 Hi Chris, we'll definitely use WebGLFloatArray and friends when exposing anything to javascript as we discussed. I really do like this idea. In fact, I'm already using one for the realtime spectrum analyser. But AudioFloatArray is really an "under-the-hood" lower-level building block (not exposed to javascript) and needs to be directly useable as a stack-based object and even more importantly directly embeddable as an ivar (object composition). WebGLFloatArray needs to be created explicitly by calling create(), making it not useable in quite such a simple way. I'm not saying it's impossible to write code using WebGLFloatArray, just that in the particular cases which appear frequently in audio processing code, it's a bit heavier. 187971 8 cmarrin 2010-02-04 15:36:54 -0800 I see the need for a lighter weight array object. But I don't see the need for these types. They don't really do anything that the underlying Vector object does. So why not just use Vector directly? 187976 9 crogers 2010-02-04 15:43:11 -0800 I have a comment in AudioFloatArray.h: // The main feature AudioFloatArray implements beyond Vector<float> is the ability // to zero out the float array very efficiently using all the optimizations in memset() // This is important for real-time audio algorithms (for example, convolution reverb) // where performance is critical. 188186 10 cmarrin 2010-02-05 07:26:24 -0800 But you can use memset without wrapping it in an entire class. That seems like overkill. 188234 11 crogers 2010-02-05 11:41:47 -0800 Overkill? I guess that's a matter of opinion. What's better? floatBuffer.zero(); or memset(floatBuffer.data(), 0, sizeof(float) * floatBuffer.size()); Then, you have to remember whether it's sizeof(float) or sizeof(double) depending on whether it's a float of double array... This method is used a fair bit throughout the engine code, and I think it much better to have a concise method for this. 188242 12 crogers 2010-02-05 12:05:29 -0800 Instead of subclassing, I could add the zero() (with memset) method directly to the Vector class. Technically, this is not quite correct since it's possible to have a vector of objects where calling zero() might put the objects into a bad state, destructors not getting called, etc. But I think it would be OK, since people are generally going to be aware of these issues and would not have a use for calling zero() in these cases anyway. Another option we can consider... 197397 13 47884 abarth 2010-03-08 16:42:37 -0800 Comment on attachment 47884 patch for some initial audio engine support classes: fixes some minor style problems with the initial patch Please add the zero() method to Vector instead of creating these subclasses. You can use a trait to ensure that the method can't be used on a type that causes problems. 270746 14 65766 crogers 2010-08-27 14:20:02 -0700 Created attachment 65766 Patch 270752 15 crogers 2010-08-27 14:24:23 -0700 I've put in a patch for wtf/Vector to add the zero() method which is still being sorted through: https://bugs.webkit.org/show_bug.cgi?id=36849 But in the meantime, although this patch is not yet quite perfect (still need to get rid of my use of AudioFloatArray and use Vector instead), it would be good to get the rest of the content reviewed. 271725 16 65766 kbr 2010-08-30 16:15:39 -0700 Comment on attachment 65766 Patch The core mixing logic, including adjustment of the mix gain, looks fine, but there are some structural problems for which I'm marking this r-. See below. > Index: WebCore/platform/audio/Accelerate.cpp > =================================================================== > --- WebCore/platform/audio/Accelerate.cpp (revision 0) > +++ WebCore/platform/audio/Accelerate.cpp (revision 0) > @@ -0,0 +1,70 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +// On the Mac use the highly optimized versions in Accelerate.framework > + > +#include "config.h" > + > +#if ENABLE(WEB_AUDIO) > + > +#include "Accelerate.h" > + > +#if !OS(DARWIN) > + > +void vsmul(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess) > +{ > + // FIXME: optimize for SSE > + int n = framesToProcess; > + float k = *scale; > + while (n--) { > + float sample = *sourceP; > + *destP = k * sample; > + > + sourceP += sourceStride; > + destP += destStride; > + } > +} > + > +void vadd(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess) > +{ > + // FIXME: optimize for SSE > + int n = framesToProcess; > + while (n--) { > + float sample1 = *source1P; > + float sample2 = *source2P; > + *destP = sample1 + sample2; > + > + source1P += sourceStride1; > + source2P += sourceStride2; > + destP += destStride; > + } > +} > + > +#endif // !OS(DARWIN) > + > +#endif // ENABLE(WEB_AUDIO) > Index: WebCore/platform/audio/Accelerate.h > =================================================================== > --- WebCore/platform/audio/Accelerate.h (revision 0) > +++ WebCore/platform/audio/Accelerate.h (revision 0) > @@ -0,0 +1,53 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#ifndef Accelerate_h > +#define Accelerate_h > + > +// Defines the interface for several vector math functions whose implementation will ideally be optimized > + > +#if OS(DARWIN) > +// On the Mac use the highly optimized versions in Accelerate.framework > +#include <Accelerate/Accelerate.h> > + > +#ifndef vadd > +#define vadd vDSP_vadd > +#endif > + > +#ifndef vsmul > +#define vsmul vDSP_vsmul > +#endif > + > + > +#else > +void vsmul(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess); > +void vadd(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess); I think you should consider exposing these routines to the rest of WebCore either as static functions on a class or in a sub-namespace Accelerate, for better encapsulation. My opinion only though. > +#endif > + > +#endif // Accelerate_h > Index: WebCore/platform/audio/AudioBus.cpp > =================================================================== > --- WebCore/platform/audio/AudioBus.cpp (revision 0) > +++ WebCore/platform/audio/AudioBus.cpp (revision 0) > @@ -0,0 +1,425 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#include "config.h" > + > +#if ENABLE(WEB_AUDIO) > + > +#include "AudioBus.h" > + > +#include "Accelerate.h" > +#include <assert.h> > +#include <math.h> > +#include <wtf/OwnPtr.h> > + > +namespace WebCore { > + > +void AudioChannel::scale(double scale) > +{ > + float s = static_cast<float>(scale); > + vsmul(data(), 1, &s, data(), 1, frameSize()); frameSize() is very poorly named. To a person just coming in to this code it sounds like the size in samples of one frame, but it's actually the number of frames. Please change it to something more descriptive like numberOfFrames(). > +} > + > +void AudioChannel::copyFrom(const AudioChannel& sourceChannel) > +{ > + bool isSafe = (sourceChannel.frameSize() >= frameSize()); > + ASSERT(isSafe); > + if (!isSafe) > + return; > + > + memcpy(data(), sourceChannel.constData(), sizeof(float) * frameSize()); > +} > + > +void AudioChannel::sumFrom(const AudioChannel& sourceChannel) > +{ > + bool isSafe = (sourceChannel.frameSize() >= frameSize()); > + ASSERT(isSafe); > + if (!isSafe) > + return; > + > + vadd(data(), 1, sourceChannel.constData(), 1, data(), 1, frameSize()); > +} > + > +float AudioChannel::maxAbsValue() const > +{ > + const float* p = constData(); > + int n = frameSize(); > + > + float max = 0.0f; > + while (n--) { > + float value = *p++; > + float absValue = fabsf(value); > + if (absValue > max) > + max = absValue; > + } > + > + return max; > +} > + > +AudioBus::AudioBus(unsigned numberOfChannels, size_t frameSize, bool allocate) > + : m_frameSize(frameSize) > + , m_busGain(1.0) > + , m_isFirstTime(true) > + , m_sampleRate(0.0) > +{ > + m_channels.reserveInitialCapacity(numberOfChannels); > + > + for (unsigned i = 0; i < numberOfChannels; ++i) { > + AudioChannel* channel = allocate ? new AudioChannel(frameSize) : new AudioChannel(0, frameSize); Naked operator new. This should use adoptPtr if at all possible (and I think it is). > + m_channels.append(channel); > + } > + > + m_layout = LayoutCanonical; // for now this is the only layout we define > +} > + > +void AudioBus::setChannelMemory(unsigned channelIndex, float* storage, size_t frameSize) > +{ > + if (channelIndex < m_channels.size()) { > + channel(channelIndex)->set(storage, frameSize); > + m_frameSize = frameSize; > + } > +} > + > +void AudioBus::zero() > +{ > + for (unsigned i = 0; i < m_channels.size(); ++i) > + m_channels[i]->zero(); > +} > + > +AudioChannel* AudioBus::channel(unsigned channel) > +{ > + if (channel < m_channels.size()) > + return m_channels[channel].get(); > + > + return 0; Why does this function attempt to be safe? Is it expected that callers may pass in out-of-range channel numbers? If not, just remove the check and let Vector's ASSERT take care of it. > +} > + > +AudioChannel* AudioBus::channelByType(unsigned channelType) > +{ > + // For now we only support canonical channel layouts... > + if (m_layout != LayoutCanonical) > + return 0; > + > + switch (numberOfChannels()) { > + case 1: // mono > + if (channelType == ChannelMono || channelType == ChannelLeft) > + return channel(0); > + return 0; > + > + case 2: // stereo > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + default: return 0; > + } > + > + case 4: // quad > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + case ChannelSurroundLeft: return channel(2); > + case ChannelSurroundRight: return channel(3); > + default: return 0; > + } > + > + case 5: // 5.0 > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + case ChannelCenter: return channel(2); > + case ChannelSurroundLeft: return channel(3); > + case ChannelSurroundRight: return channel(4); > + default: return 0; > + } > + > + case 6: // 5.1 > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + case ChannelCenter: return channel(2); > + case ChannelLFE: return channel(3); > + case ChannelSurroundLeft: return channel(4); > + case ChannelSurroundRight: return channel(5); > + default: return 0; > + } > + > + default: // unknown canonical layout > + return 0; This default case clause is unnecessary. If you want to catch invalid uses in debug builds, use ASSERT_NOT_REACHED. > + } > + > + return 0; > +} > + > +// Returns true if the channel count and frame-size match. > +bool AudioBus::topologyMatches(const AudioBus& bus) const > +{ > + if (numberOfChannels() != bus.numberOfChannels()) > + return false; // channel mismatch > + > + // Make sure source bus has enough frames. > + if (frameSize() > bus.frameSize()) > + return false; // frame-size mismatch > + > + return true; > +} > + > +// Just copies the samples from the source bus to this one. > +// This is just a simple copy if the number of channels match, otherwise a mixup or mixdown is done. > +// For now, we just support a mixup from mono -> stereo. > +void AudioBus::copyFrom(const AudioBus& sourceBus) > +{ > + if (&sourceBus == this) > + return; > + > + size_t frameSize = sourceBus.frameSize(); > + > + if (numberOfChannels() == sourceBus.numberOfChannels()) { > + // Simple copy > + for (unsigned i = 0; i < numberOfChannels(); ++i) { > + AudioChannel* sourceChannel = const_cast<AudioBus&>(sourceBus).channel(i); > + channel(i)->copyFrom(*sourceChannel); > + } > + } else if (numberOfChannels() == 2 && sourceBus.numberOfChannels() == 1) { > + // Handle mono -> stereo case (for now simply copy mono channel into both left and right) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + const float* source = const_cast<AudioBus&>(sourceBus).channel(0)->data(); > + float* destinationL = channel(0)->data(); > + float* destinationR = channel(1)->data(); > + memcpy(destinationL, source, sizeof(float) * frameSize); > + memcpy(destinationR, source, sizeof(float) * frameSize); Where are there checks that there is enough storage allocated in channel(0) and channel(1)? Also, it seems to me that these memory copies should be in AudioChannel, not here. > + } else { > + // Case not handled > + ASSERT_NOT_REACHED(); > + } > +} > + > +PassOwnPtr<AudioBus> AudioBus::createBufferFromRange(AudioBus* sourceBuffer, unsigned startFrame, unsigned endFrame) > +{ > + size_t numberOfSourceFrames = sourceBuffer->frameSize(); > + unsigned numberOfChannels = sourceBuffer->numberOfChannels(); > + > + // Sanity checking > + bool isRangeSafe = startFrame < endFrame && endFrame <= numberOfSourceFrames; > + > + ASSERT(isRangeSafe); > + if (!isRangeSafe) > + return 0; > + > + size_t rangeSize = endFrame - startFrame; > + > + PassOwnPtr<AudioBus> audioBus = new AudioBus(numberOfChannels, rangeSize); > + audioBus->setSampleRate(sourceBuffer->sampleRate()); > + > + for (unsigned i = 0; i < numberOfChannels; ++i) { > + float* source = sourceBuffer->channel(i)->data(); > + float* destination = audioBus->channel(i)->data(); > + memcpy(destination, source + startFrame, sizeof(float) * rangeSize); Same comment about encapsulating these memcpy's in AudioChannel. > + } > + > + return audioBus; > +} > + > +float AudioBus::maxAbsValue() const > +{ > + float max = 0.0f; > + for (unsigned i = 0; i < numberOfChannels(); ++i) { > + AudioChannel* channel = const_cast<AudioBus*>(this)->channel(i); > + float channelMax = channel->maxAbsValue(); > + if (channelMax > max) > + max = channelMax; > + } > + > + return max; > +} > + > +void AudioBus::normalize() > +{ > + float max = maxAbsValue(); > + if (max) > + scale(1.0f / max); > +} > + > +void AudioBus::scale(double scale) > +{ > + for (unsigned i = 0; i < numberOfChannels(); ++i) > + channel(i)->scale(scale); > +} > + > +void AudioBus::sumFrom(const AudioBus &sourceBus) > +{ > + if (numberOfChannels() == sourceBus.numberOfChannels()) { > + for (unsigned i = 0; i < numberOfChannels(); ++i) > + channel(i)->sumFrom(*const_cast<AudioBus&>(sourceBus).channel(i)); This const_cast is pretty ugly. You ought to be able to provide enough overloaded const variants of methods on AudioBus and AudioChannel to avoid it. Also, it isn't clear to me why you are introducing an asymmetry in the API where channel() returns AudioBus* but these routines take AudioBus&. > + } else if (numberOfChannels() == 2 && sourceBus.numberOfChannels() == 1) { > + // Handle mono -> stereo case (for now simply sum mono channel into both left and right) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + AudioChannel* sourceChannel = const_cast<AudioBus&>(sourceBus).channel(0); > + channel(0)->sumFrom(*sourceChannel); > + channel(1)->sumFrom(*sourceChannel); Same comments about const_cast and dereferencing. > + } else { > + // Case not handled > + ASSERT_NOT_REACHED(); > + } > +} > + > +void AudioBus::processWithGainFromMonoStereo(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus) > +{ > + // We don't want to suddenly change the gain from mixing one time slice to the next, > + // so we "de-zipper" by slowly changing the gain each sample-frame until we've achieved the target gain. > + > + // FIXME: optimize this method (SSE, etc.) > + // FIXME: Need fast path here when gain has converged on targetGain. In this case, de-zippering is no longer needed. > + // FIXME: Need fast path when this==sourceBus && lastMixGain==targetGain==1.0 && sumToBus==false (this is a NOP) > + > + // Take master bus gain into account as well as the targetGain. > + double totalDesiredGain = m_busGain * targetGain; > + > + // First time, snap directly to totalDesiredGain. > + double gain = m_isFirstTime ? totalDesiredGain : *lastMixGain; > + m_isFirstTime = false; > + > + int numberOfSourceChannels = sourceBus.numberOfChannels(); > + int numberOfDestinationChannels = numberOfChannels(); > + > + AudioBus& sourceBusSafe = const_cast<AudioBus&>(sourceBus); > + const float* sourceL = sourceBusSafe.channelByType(ChannelLeft)->data(); > + const float* sourceR = numberOfSourceChannels > 1 ? sourceBusSafe.channelByType(ChannelRight)->data() : 0; > + > + float* destinationL = channelByType(ChannelLeft)->data(); > + float* destinationR = numberOfDestinationChannels > 1 ? channelByType(ChannelRight)->data() : 0; > + > + const double DezipperRate = 0.005; > + int framesToProcess = frameSize(); > + > + if (sumToBus) { > + // Sum to our bus > + if (sourceR && destinationR) { > + // Stereo > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + float sampleR = *sourceR++; > + *destinationL++ += static_cast<float>(gain * sampleL); > + *destinationR++ += static_cast<float>(gain * sampleR); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else if (destinationR) { > + // Mono -> stereo (mix equally into L and R) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + while (framesToProcess--) { > + float sample = *sourceL++; > + *destinationL++ += static_cast<float>(gain * sample); > + *destinationR++ += static_cast<float>(gain * sample); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else { > + // Mono > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + *destinationL++ += static_cast<float>(gain * sampleL); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } > + } else { > + // Process directly (without summing) to our bus > + if (sourceR && destinationR) { > + // Stereo > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + float sampleR = *sourceR++; > + *destinationL++ = static_cast<float>(gain * sampleL); > + *destinationR++ = static_cast<float>(gain * sampleR); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else if (destinationR) { > + // Mono -> stereo (mix equally into L and R) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + while (framesToProcess--) { > + float sample = *sourceL++; > + *destinationL++ = static_cast<float>(gain * sample); > + *destinationR++ = static_cast<float>(gain * sample); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else { > + // Mono > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + *destinationL++ = static_cast<float>(gain * sampleL); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } > + } > + > + // Save the target gain as the starting point for next time around. > + *lastMixGain = gain; > +} > + > +void AudioBus::processWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus) > +{ > + // Make sure we're summing from same type of bus. > + // We *are* able to sum from mono -> stereo > + if (sourceBus.numberOfChannels() != 1 && !topologyMatches(sourceBus)) > + return; > + > + // Dispatch for different channel layouts > + switch (numberOfChannels()) { > + case 1: // mono > + case 2: // stereo > + processWithGainFromMonoStereo(sourceBus, lastMixGain, targetGain, sumToBus); > + break; > + case 4: // FIXME: implement quad > + case 5: // FIXME: implement 5.0 > + default: > + ASSERT_NOT_REACHED(); > + break; > + } > +} > + > +void AudioBus::sumWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain) > +{ > + processWithGainFrom(sourceBus, lastMixGain, targetGain, true); > +} > + > +void AudioBus::copyWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain) > +{ > + processWithGainFrom(sourceBus, lastMixGain, targetGain, false); > +} > + > +} // WebCore > + > +#endif // ENABLE(WEB_AUDIO) > Index: WebCore/platform/audio/AudioBus.h > =================================================================== > --- WebCore/platform/audio/AudioBus.h (revision 0) > +++ WebCore/platform/audio/AudioBus.h (revision 0) > @@ -0,0 +1,215 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#ifndef AudioBus_h > +#define AudioBus_h > + > +#include "AudioFloatArray.h" > +#include <wtf/Noncopyable.h> > +#include <wtf/PassOwnPtr.h> > +#include <wtf/Vector.h> > + > +namespace WebCore { > + > +// An AudioChannel represents a buffer of non-interleaved floating-point audio samples. > +// The PCM samples are normally assumed to be in a nominal range -1.0 -> +1.0 > +class AudioChannel : public Noncopyable { AudioChannel should be in its own header and have its own implementation file. > +public: > + // Memory can be externally referenced, or can be internally allocated with an AudioFloatArray. > + > + // Reference an external buffer. > + AudioChannel(float* storage, size_t frameSize) > + : m_frameSize(frameSize), m_rawPointer(storage), m_memBuffer(0) { } > + > + // Manage storage for us. > + explicit AudioChannel(size_t frameSize) > + : m_frameSize(frameSize) > + , m_rawPointer(0) > + { > + m_memBuffer = new AudioFloatArray(frameSize); > + } > + > + // A "blank" audio channel -- must call set() before it's useful... > + AudioChannel() > + : m_frameSize(0) > + , m_rawPointer(0) > + , m_memBuffer(0) > + { > + } > + > + // Redefine the memory for this channel. > + // storage represents external memory not managed by this object. > + void set(float* storage, size_t frameSize) > + { > + m_memBuffer.clear(); // cleanup managed storage > + m_rawPointer = storage; > + m_frameSize = frameSize; > + } > + > + // How many sample-frames do we contain? > + size_t frameSize() const { return m_frameSize; } As mentioned above, this method is very poorly named. Please change it. Suggestion: numberOfFrames(). > + > + // Direct access to PCM sample data > + float* data() { return m_rawPointer ? m_rawPointer : m_memBuffer->data(); } > + const float* constData() const { return const_cast<AudioChannel*>(this)->data(); } You should be able to provide a const overload of AudioFloatArray::data() to avoid this const_cast. You also shouldn't need the separately named constData(), just a const overload of data() returning const float*. > + > + // Zeroes out all sample values in buffer. > + void zero() > + { > + if (m_memBuffer.get()) > + m_memBuffer->zero(); > + else > + memset(m_rawPointer, 0, sizeof(float) * m_frameSize); > + } > + > + // Scales all samples by the same amount. > + void scale(double scale); > + > + // A simple memcpy() from the source channel > + void copyFrom(const AudioChannel &sourceChannel); > + > + // Sums (with unity gain) from the source channel. > + void sumFrom(const AudioChannel &sourceChannel); > + > + // Returns maximum absolute value (useful for normalization). > + float maxAbsValue() const; > + > +private: > + size_t m_frameSize; > + > + float* m_rawPointer; > + OwnPtr<AudioFloatArray> m_memBuffer; > +}; > + > +// An AudioBus represents a collection of one or more AudioChannels. > +// The data layout is "planar" as opposed to "interleaved". > +// An AudioBus with one channel is mono, an AudioBus with two channels is stereo, etc. > +class AudioBus : public Noncopyable { > +public: > + enum { > + ChannelLeft = 0, > + ChannelRight = 1, > + ChannelCenter = 2, // center and mono are the same > + ChannelMono = 2, > + ChannelLFE = 3, > + ChannelSurroundLeft = 4, > + ChannelSurroundRight = 5, > + }; > + > + enum { > + LayoutCanonical = 0 > + // Can define non-standard layouts here > + }; > + > + // allocate indicates whether or not to initially have the AudioChannels created with managed storage. > + // Normal usage is to pass true here, in which case the AudioChannels will memory-manage their own storage. > + // If allocate is false then setChannelMemory() has to be called later on for each channel before the AudioBus is useable... > + AudioBus(unsigned numberOfChannels, size_t frameSize, bool allocate = true); > + > + // Tells the given channel to use an externally allocated buffer. > + void setChannelMemory(unsigned channelIndex, float* storage, size_t frameSize); > + > + // Channels > + unsigned numberOfChannels() const { return m_channels.size(); } > + AudioChannel* channel(unsigned channel); > + AudioChannel* channelByType(unsigned type); > + > + // Number of sample-frames > + size_t frameSize() const { return m_frameSize; } > + > + // Sample-rate : 0.0 if unknown or "don't care" > + double sampleRate() const { return m_sampleRate; } > + void setSampleRate(double sampleRate) { m_sampleRate = sampleRate; } > + > + // Zeroes all channels. > + void zero(); > + > + // Returns true if the channel count and frame-size match. > + bool topologyMatches(const AudioBus &sourceBus) const; > + > + // Assuming sourceBus has the same topology, copies sample data from each channel of sourceBus to our corresponding channel. > + void copyFrom(const AudioBus &sourceBus); > + > + // Creates a new buffer from a range in the source buffer. > + // 0 may be returned if the range does not fit in the sourceBuffer > + static PassOwnPtr<AudioBus> createBufferFromRange(AudioBus* sourceBuffer, unsigned startFrame, unsigned endFrame); > + > + // Scales all samples by the same amount. > + void scale(double scale); > + > + // Master gain for this bus - used with sumWithGainFrom() below > + void setGain(double gain) { m_busGain = gain; } > + double gain() { return m_busGain; } > + > + void reset() { m_isFirstTime = true; } // for de-zippering > + > + // Sums the sourceBus into our bus with unity gain. > + // Our own internal gain m_busGain is ignored. > + void sumFrom(const AudioBus &sourceBus); > + > + // Sum or copy each channel from sourceBus into our corresponding channel. > + // We scale by targetGain (and our own internal gain m_busGain), performing "de-zippering" to smoothly change from *lastMixGain to (targetGain*m_busGain). > + // The caller is responsible for setting up lastMixGain to point to storage which is unique for every "stream" which will be summed to this bus. > + // This represents the dezippering memory. > + void sumWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain); > + void copyWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain); > + > + // Returns maximum absolute value across all channels (useful for normalization). > + float maxAbsValue() const; > + > + // Makes maximum absolute value == 1.0 (if possible). > + void normalize(); > + > +protected: > + AudioBus() { }; > + > + void processWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus); > + void processWithGainFromMonoStereo(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus); > + > + size_t m_frameSize; > + > + Vector<OwnPtr<AudioChannel> > m_channels; > + > + int m_layout; > + > + double m_busGain; > + bool m_isFirstTime; > + double m_sampleRate; // 0.0 if unknown or N/A > +}; > + > +// Abstract base-class for a pull-model client. > +// provideInput() gets called repeatedly to render time-slices of a continuous audio stream. > +class AudioSourceProvider { This class should be in its own header as well. > +public: > + virtual void provideInput(AudioBus* bus, size_t framesToProcess) = 0; > + virtual ~AudioSourceProvider() { } > +}; > + > +} // WebCore > + > +#endif // AudioBus_h 271849 17 65995 crogers 2010-08-30 18:42:12 -0700 Created attachment 65995 Patch 272557 18 65995 kbr 2010-08-31 18:22:38 -0700 Comment on attachment 65995 Patch This looks good to me; r=me. A couple of minor issues which you can fix upon commit if you're using webkit-patch land, or upload a new patch if you're going to use the commit queue. > Index: WebCore/platform/audio/AudioBus.cpp > =================================================================== > --- WebCore/platform/audio/AudioBus.cpp (revision 0) > +++ WebCore/platform/audio/AudioBus.cpp (revision 0) > @@ -0,0 +1,364 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#include "config.h" > + > +#if ENABLE(WEB_AUDIO) > + > +#include "AudioBus.h" > + > +#include "Accelerate.h" > +#include <assert.h> > +#include <math.h> > +#include <wtf/OwnPtr.h> > +#include <wtf/PassOwnPtr.h> > + > +namespace WebCore { > + > +AudioBus::AudioBus(unsigned numberOfChannels, size_t length, bool allocate) > + : m_length(length) > + , m_busGain(1.0) > + , m_isFirstTime(true) > + , m_sampleRate(0.0) > +{ > + m_channels.reserveInitialCapacity(numberOfChannels); > + > + for (unsigned i = 0; i < numberOfChannels; ++i) { > + PassOwnPtr<AudioChannel> channel = allocate ? adoptPtr(new AudioChannel(length)) : adoptPtr(new AudioChannel(0, length)); > + m_channels.append(channel); > + } > + > + m_layout = LayoutCanonical; // for now this is the only layout we define > +} > + > +void AudioBus::setChannelMemory(unsigned channelIndex, float* storage, size_t length) > +{ > + if (channelIndex < m_channels.size()) { > + channel(channelIndex)->set(storage, length); > + m_length = length; This still looks fishy to me; only one of the channels is having its storage set, but the overall length of the AudioBus is being updated. > + } > +} > + > +void AudioBus::zero() > +{ > + for (unsigned i = 0; i < m_channels.size(); ++i) > + m_channels[i]->zero(); > +} > + > +AudioChannel* AudioBus::channelByType(unsigned channelType) > +{ > + // For now we only support canonical channel layouts... > + if (m_layout != LayoutCanonical) > + return 0; > + > + switch (numberOfChannels()) { > + case 1: // mono > + if (channelType == ChannelMono || channelType == ChannelLeft) > + return channel(0); > + return 0; > + > + case 2: // stereo > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + default: return 0; > + } > + > + case 4: // quad > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + case ChannelSurroundLeft: return channel(2); > + case ChannelSurroundRight: return channel(3); > + default: return 0; > + } > + > + case 5: // 5.0 > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + case ChannelCenter: return channel(2); > + case ChannelSurroundLeft: return channel(3); > + case ChannelSurroundRight: return channel(4); > + default: return 0; > + } > + > + case 6: // 5.1 > + switch (channelType) { > + case ChannelLeft: return channel(0); > + case ChannelRight: return channel(1); > + case ChannelCenter: return channel(2); > + case ChannelLFE: return channel(3); > + case ChannelSurroundLeft: return channel(4); > + case ChannelSurroundRight: return channel(5); > + default: return 0; > + } > + } > + > + ASSERT_NOT_REACHED(); > + return 0; > +} > + > +// Returns true if the channel count and frame-size match. > +bool AudioBus::topologyMatches(const AudioBus& bus) const > +{ > + if (numberOfChannels() != bus.numberOfChannels()) > + return false; // channel mismatch > + > + // Make sure source bus has enough frames. > + if (length() > bus.length()) > + return false; // frame-size mismatch > + > + return true; > +} > + > +PassOwnPtr<AudioBus> AudioBus::createBufferFromRange(AudioBus* sourceBuffer, unsigned startFrame, unsigned endFrame) > +{ > + size_t numberOfSourceFrames = sourceBuffer->length(); > + unsigned numberOfChannels = sourceBuffer->numberOfChannels(); > + > + // Sanity checking > + bool isRangeSafe = startFrame < endFrame && endFrame <= numberOfSourceFrames; > + ASSERT(isRangeSafe); > + if (!isRangeSafe) > + return 0; > + > + size_t rangeLength = endFrame - startFrame; > + > + PassOwnPtr<AudioBus> audioBus = adoptPtr(new AudioBus(numberOfChannels, rangeLength)); If this were a PassRefPtr, holding on to it as one instead of as a RefPtr would be incorrect. To match the preferred style, use OwnPtr<AudioBus> here; see below for the return value. > + audioBus->setSampleRate(sourceBuffer->sampleRate()); > + > + for (unsigned i = 0; i < numberOfChannels; ++i) > + audioBus->channel(i)->copyFromRange(sourceBuffer->channel(i), startFrame, endFrame); > + > + return audioBus; Here, use "return audioBus.release()". > +} > + > +float AudioBus::maxAbsValue() const > +{ > + float max = 0.0f; > + for (unsigned i = 0; i < numberOfChannels(); ++i) { > + AudioChannel* channel = const_cast<AudioBus*>(this)->channel(i); Shouldn't you be able to write "const AudioChannel* channel = ..." now, and get rid of the const_cast? > + float channelMax = channel->maxAbsValue(); > + if (channelMax > max) > + max = channelMax; Could just write "max = std::max(max, channel->maxAbsValue()". > + } > + > + return max; > +} > + > +void AudioBus::normalize() > +{ > + float max = maxAbsValue(); > + if (max) > + scale(1.0f / max); > +} > + > +void AudioBus::scale(double scale) > +{ > + for (unsigned i = 0; i < numberOfChannels(); ++i) > + channel(i)->scale(scale); > +} > + > +// Just copies the samples from the source bus to this one. > +// This is just a simple copy if the number of channels match, otherwise a mixup or mixdown is done. > +// For now, we just support a mixup from mono -> stereo. > +void AudioBus::copyFrom(const AudioBus& sourceBus) > +{ > + if (&sourceBus == this) > + return; > + > + if (numberOfChannels() == sourceBus.numberOfChannels()) { > + for (unsigned i = 0; i < numberOfChannels(); ++i) > + channel(i)->copyFrom(sourceBus.channel(i)); > + } else if (numberOfChannels() == 2 && sourceBus.numberOfChannels() == 1) { > + // Handle mono -> stereo case (for now simply copy mono channel into both left and right) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + const AudioChannel* sourceChannel = sourceBus.channel(0); > + channel(0)->copyFrom(sourceChannel); > + channel(1)->copyFrom(sourceChannel); > + } else { > + // Case not handled > + ASSERT_NOT_REACHED(); > + } > +} > + > +void AudioBus::sumFrom(const AudioBus &sourceBus) > +{ > + if (numberOfChannels() == sourceBus.numberOfChannels()) { > + for (unsigned i = 0; i < numberOfChannels(); ++i) > + channel(i)->sumFrom(sourceBus.channel(i)); > + } else if (numberOfChannels() == 2 && sourceBus.numberOfChannels() == 1) { > + // Handle mono -> stereo case (for now simply sum mono channel into both left and right) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + const AudioChannel* sourceChannel = sourceBus.channel(0); > + channel(0)->sumFrom(sourceChannel); > + channel(1)->sumFrom(sourceChannel); > + } else { > + // Case not handled > + ASSERT_NOT_REACHED(); > + } > +} > + > +void AudioBus::processWithGainFromMonoStereo(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus) > +{ > + // We don't want to suddenly change the gain from mixing one time slice to the next, > + // so we "de-zipper" by slowly changing the gain each sample-frame until we've achieved the target gain. > + > + // FIXME: optimize this method (SSE, etc.) > + // FIXME: Need fast path here when gain has converged on targetGain. In this case, de-zippering is no longer needed. > + // FIXME: Need fast path when this==sourceBus && lastMixGain==targetGain==1.0 && sumToBus==false (this is a NOP) > + > + // Take master bus gain into account as well as the targetGain. > + double totalDesiredGain = m_busGain * targetGain; > + > + // First time, snap directly to totalDesiredGain. > + double gain = m_isFirstTime ? totalDesiredGain : *lastMixGain; > + m_isFirstTime = false; > + > + int numberOfSourceChannels = sourceBus.numberOfChannels(); > + int numberOfDestinationChannels = numberOfChannels(); > + > + AudioBus& sourceBusSafe = const_cast<AudioBus&>(sourceBus); > + const float* sourceL = sourceBusSafe.channelByType(ChannelLeft)->data(); > + const float* sourceR = numberOfSourceChannels > 1 ? sourceBusSafe.channelByType(ChannelRight)->data() : 0; > + > + float* destinationL = channelByType(ChannelLeft)->data(); > + float* destinationR = numberOfDestinationChannels > 1 ? channelByType(ChannelRight)->data() : 0; > + > + const double DezipperRate = 0.005; > + int framesToProcess = length(); > + > + if (sumToBus) { > + // Sum to our bus > + if (sourceR && destinationR) { > + // Stereo > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + float sampleR = *sourceR++; > + *destinationL++ += static_cast<float>(gain * sampleL); > + *destinationR++ += static_cast<float>(gain * sampleR); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else if (destinationR) { > + // Mono -> stereo (mix equally into L and R) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + while (framesToProcess--) { > + float sample = *sourceL++; > + *destinationL++ += static_cast<float>(gain * sample); > + *destinationR++ += static_cast<float>(gain * sample); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else { > + // Mono > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + *destinationL++ += static_cast<float>(gain * sampleL); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } > + } else { > + // Process directly (without summing) to our bus > + if (sourceR && destinationR) { > + // Stereo > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + float sampleR = *sourceR++; > + *destinationL++ = static_cast<float>(gain * sampleL); > + *destinationR++ = static_cast<float>(gain * sampleR); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else if (destinationR) { > + // Mono -> stereo (mix equally into L and R) > + // FIXME: Really we should apply an equal-power scaling factor here, since we're effectively panning center... > + while (framesToProcess--) { > + float sample = *sourceL++; > + *destinationL++ = static_cast<float>(gain * sample); > + *destinationR++ = static_cast<float>(gain * sample); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } else { > + // Mono > + while (framesToProcess--) { > + float sampleL = *sourceL++; > + *destinationL++ = static_cast<float>(gain * sampleL); > + > + // Slowly change gain to desired gain. > + gain += (totalDesiredGain - gain) * DezipperRate; > + } > + } > + } > + > + // Save the target gain as the starting point for next time around. > + *lastMixGain = gain; > +} > + > +void AudioBus::processWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus) > +{ > + // Make sure we're summing from same type of bus. > + // We *are* able to sum from mono -> stereo > + if (sourceBus.numberOfChannels() != 1 && !topologyMatches(sourceBus)) > + return; > + > + // Dispatch for different channel layouts > + switch (numberOfChannels()) { > + case 1: // mono > + case 2: // stereo > + processWithGainFromMonoStereo(sourceBus, lastMixGain, targetGain, sumToBus); > + break; > + case 4: // FIXME: implement quad > + case 5: // FIXME: implement 5.0 > + default: > + ASSERT_NOT_REACHED(); > + break; > + } > +} > + > +void AudioBus::copyWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain) > +{ > + processWithGainFrom(sourceBus, lastMixGain, targetGain, false); > +} > + > +void AudioBus::sumWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain) > +{ > + processWithGainFrom(sourceBus, lastMixGain, targetGain, true); > +} > + > +} // WebCore > + > +#endif // ENABLE(WEB_AUDIO) > Index: WebCore/platform/audio/AudioBus.h > =================================================================== > --- WebCore/platform/audio/AudioBus.h (revision 0) > +++ WebCore/platform/audio/AudioBus.h (revision 0) > @@ -0,0 +1,139 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#ifndef AudioBus_h > +#define AudioBus_h > + > +#include "AudioChannel.h" > +#include <wtf/Noncopyable.h> > +#include <wtf/PassOwnPtr.h> > +#include <wtf/Vector.h> > + > +namespace WebCore { > + > +// An AudioBus represents a collection of one or more AudioChannels. > +// The data layout is "planar" as opposed to "interleaved". > +// An AudioBus with one channel is mono, an AudioBus with two channels is stereo, etc. > +class AudioBus : public Noncopyable { > +public: > + enum { > + ChannelLeft = 0, > + ChannelRight = 1, > + ChannelCenter = 2, // center and mono are the same > + ChannelMono = 2, > + ChannelLFE = 3, > + ChannelSurroundLeft = 4, > + ChannelSurroundRight = 5, > + }; > + > + enum { > + LayoutCanonical = 0 > + // Can define non-standard layouts here > + }; > + > + // allocate indicates whether or not to initially have the AudioChannels created with managed storage. > + // Normal usage is to pass true here, in which case the AudioChannels will memory-manage their own storage. > + // If allocate is false then setChannelMemory() has to be called later on for each channel before the AudioBus is useable... > + AudioBus(unsigned numberOfChannels, size_t length, bool allocate = true); > + > + // Tells the given channel to use an externally allocated buffer. > + void setChannelMemory(unsigned channelIndex, float* storage, size_t length); > + > + // Channels > + unsigned numberOfChannels() const { return m_channels.size(); } > + > + AudioChannel* channel(unsigned channel) { return m_channels[channel].get(); } > + const AudioChannel* channel(unsigned channel) const { return const_cast<AudioBus*>(this)->m_channels[channel].get(); } > + AudioChannel* channelByType(unsigned type); > + > + // Number of sample-frames > + size_t length() const { return m_length; } > + > + // Sample-rate : 0.0 if unknown or "don't care" > + double sampleRate() const { return m_sampleRate; } > + void setSampleRate(double sampleRate) { m_sampleRate = sampleRate; } > + > + // Zeroes all channels. > + void zero(); > + > + // Returns true if the channel count and frame-size match. > + bool topologyMatches(const AudioBus &sourceBus) const; > + > + // Creates a new buffer from a range in the source buffer. > + // 0 may be returned if the range does not fit in the sourceBuffer > + static PassOwnPtr<AudioBus> createBufferFromRange(AudioBus* sourceBuffer, unsigned startFrame, unsigned endFrame); > + > + // Scales all samples by the same amount. > + void scale(double scale); > + > + // Master gain for this bus - used with sumWithGainFrom() below > + void setGain(double gain) { m_busGain = gain; } > + double gain() { return m_busGain; } > + > + void reset() { m_isFirstTime = true; } // for de-zippering > + > + // Assuming sourceBus has the same topology, copies sample data from each channel of sourceBus to our corresponding channel. > + void copyFrom(const AudioBus &sourceBus); > + > + // Sums the sourceBus into our bus with unity gain. > + // Our own internal gain m_busGain is ignored. > + void sumFrom(const AudioBus &sourceBus); > + > + // Copy or sum each channel from sourceBus into our corresponding channel. > + // We scale by targetGain (and our own internal gain m_busGain), performing "de-zippering" to smoothly change from *lastMixGain to (targetGain*m_busGain). > + // The caller is responsible for setting up lastMixGain to point to storage which is unique for every "stream" which will be summed to this bus. > + // This represents the dezippering memory. > + void copyWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain); > + void sumWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain); > + > + // Returns maximum absolute value across all channels (useful for normalization). > + float maxAbsValue() const; > + > + // Makes maximum absolute value == 1.0 (if possible). > + void normalize(); > + > +protected: > + AudioBus() { }; > + > + void processWithGainFrom(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus); > + void processWithGainFromMonoStereo(const AudioBus &sourceBus, double* lastMixGain, double targetGain, bool sumToBus); > + > + size_t m_length; > + > + Vector<OwnPtr<AudioChannel> > m_channels; > + > + int m_layout; > + > + double m_busGain; > + bool m_isFirstTime; > + double m_sampleRate; // 0.0 if unknown or N/A > +}; > + > +} // WebCore > + > +#endif // AudioBus_h > Index: WebCore/platform/audio/AudioSourceProvider.h > =================================================================== > --- WebCore/platform/audio/AudioSourceProvider.h (revision 0) > +++ WebCore/platform/audio/AudioSourceProvider.h (revision 0) > @@ -0,0 +1,46 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#ifndef AudioSourceProvider_h > +#define AudioSourceProvider_h > + > +namespace WebCore { > + > +class AudioBus; > + > +// Abstract base-class for a pull-model client. > +// provideInput() gets called repeatedly to render time-slices of a continuous audio stream. > +class AudioSourceProvider { > +public: > + virtual void provideInput(AudioBus* bus, size_t framesToProcess) = 0; > + virtual ~AudioSourceProvider() { } > +}; > + > +} // WebCore > + > +#endif // AudioSourceProvider_h 272920 19 66242 crogers 2010-09-01 12:07:13 -0700 Created attachment 66242 Patch 272922 20 crogers 2010-09-01 12:08:13 -0700 Hi Ken, I addressed your comments. You previously approved this - thanks. 273647 21 66242 kbr 2010-09-02 16:06:21 -0700 Comment on attachment 66242 Patch Looks good; r=me again. 273706 22 66242 commit-queue 2010-09-02 18:01:17 -0700 Comment on attachment 66242 Patch Rejecting patch 66242 from commit-queue. crogers@google.com does not have committer permissions according to http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/common/config/committers.py. - If you do not have committer rights please read http://webkit.org/coding/contributing.html for instructions on how to use bugzilla flags. - If you have committer rights please correct the error in WebKitTools/Scripts/webkitpy/common/config/committers.py by adding yourself to the file (no review needed). The commit-queue restarts itself every 2 hours. After restart the commit-queue will correctly respect your committer rights. 274102 23 66242 crogers 2010-09-03 12:10:24 -0700 Comment on attachment 66242 Patch Clearing flags on attachment: 66242 Committed r66755: <http://trac.webkit.org/changeset/66755> 274103 24 crogers 2010-09-03 12:10:30 -0700 All reviewed patches have been landed. Closing bug. 47874 2010-02-01 15:43:51 -0800 2010-02-01 17:17:17 -0800 patch for some initial audio engine support classes ttt text/plain 31881 crogers SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1NDE1OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNjQgQEAKKzIwMTAtMDItMDEgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJ bml0aWFsIHBhdGNoIGZvciBhdWRpbyBlbmdpbmU6IEF1ZGlvQnVzIGFuZCBoZWxwZXIgY2xhc3Nl cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQ0NTIK KworICAgICAgICBObyB0ZXN0cyBzaW5jZSB0aGlzIGlzIHRoZSBmaXJzdCBiaXQgb2YgbmV3IGF1 ZGlvIGVuZ2luZSBjb2RlIChubyBJREwgZmlsZXMgeWV0KQorCisgICAgICAgICogcGxhdGZvcm0v YXVkaW86IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2F1ZGlvL0FjY2VsZXJhdGUuY3BwOiBB ZGRlZC4KKyAgICAgICAgKHZzbXVsKToKKyAgICAgICAgKHZhZGQpOgorICAgICAgICAqIHBsYXRm b3JtL2F1ZGlvL0FjY2VsZXJhdGUuaDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vYXVkaW8v QXVkaW9CdXMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6c2Nh bGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9DaGFubmVsOjpzdW1Gcm9tKToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6bWF4QWJzVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9CdXM6OkF1ZGlvQnVzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjp+QXVkaW9C dXMpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnNldENoYW5uZWxNZW1vcnkpOgorICAg ICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Onplcm8pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9C dXM6OmNoYW5uZWwpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OmNoYW5uZWxCeVR5cGUp OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnRvcG9sb2d5TWF0Y2hlcyk6CisgICAgICAg IChXZWJDb3JlOjpBdWRpb0J1czo6Y29weUZyb20pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9C dXM6OmNyZWF0ZUJ1ZmZlckZyb21SYW5nZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6 bWF4QWJzVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Om5vcm1hbGl6ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVk aW9CdXM6OnN1bUZyb20pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnN1bUZyb21JbXBs KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpzdW1XaXRoR2FpbkZyb20pOgorICAgICAg ICAqIHBsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9DaGFubmVsOjpBdWRpb0NoYW5uZWwpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9DaGFu bmVsOjp+QXVkaW9DaGFubmVsKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6c2V0 KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6ZnJhbWVTaXplKToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0No YW5uZWw6OmNvbnN0RGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NoYW5uZWw6Onplcm8p OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Oik6CisgICAgICAgIChXZWJDb3JlOjpBdWRp b0J1czo6bnVtYmVyT2ZDaGFubmVscyk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6ZnJh bWVTaXplKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpzYW1wbGVSYXRlKToKKyAgICAg ICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpzZXRTYW1wbGVSYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvQnVzOjpzZXRHYWluKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpnYWluKToK KyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpyZXNldCk6CisgICAgICAgIChXZWJDb3JlOjpB dWRpb0J1czo6QXVkaW9CdXMpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Tb3VyY2VQcm92aWRl cjo6fkF1ZGlvU291cmNlUHJvdmlkZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2F1ZGlvL0F1ZGlv RmxvYXRBcnJheS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvRmxvYXRBcnJheTo6 QXVkaW9GbG9hdEFycmF5KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvRmxvYXRBcnJheTo6YWxs b2NhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9GbG9hdEFycmF5Ojp6ZXJvKToKKyAgICAg ICAgKFdlYkNvcmU6OkF1ZGlvRmxvYXRBcnJheTo6b3BlcmF0b3IgZmxvYXQqICk6CisgICAgICAg IChXZWJDb3JlOjpBdWRpb0RvdWJsZUFycmF5OjpBdWRpb0RvdWJsZUFycmF5KToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvRG91YmxlQXJyYXk6OmFsbG9jYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvRG91YmxlQXJyYXk6Onplcm8pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Eb3VibGVB cnJheTo6b3BlcmF0b3IgZG91YmxlKiApOgorCiAyMDEwLTAyLTAxICBTYW0gV2VpbmlnICA8c2Ft QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQmV0aCBEYWtpbi4KSW5kZXg6IFdl YkNvcmUvcGxhdGZvcm0vYXVkaW8vQWNjZWxlcmF0ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9wbGF0Zm9ybS9hdWRpby9BY2NlbGVyYXRlLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUv cGxhdGZvcm0vYXVkaW8vQWNjZWxlcmF0ZS5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNzYg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisg KiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxl IENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNv bnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdy aXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1Q TElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAor ICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisvLyBPbiB0aGUgTWFjIHVzZSB0aGUgaGlnaGx5IG9wdGltaXplZCB2ZXJzaW9ucyBpbiBB Y2NlbGVyYXRlLmZyYW1ld29yaworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQWNj ZWxlcmF0ZS5oIgorCisjaWYgIVBMQVRGT1JNKE1BQykKKwordm9pZCB2c211bChjb25zdCBmbG9h dCogc291cmNlUCwKKyAgICAgICAgICAgaW50IHNvdXJjZVN0cmlkZSwKKyAgICAgICAgICAgY29u c3QgZmxvYXQqIHNjYWxlLAorICAgICAgICAgICBmbG9hdCogZGVzdFAsCisgICAgICAgICAgIGlu dCBkZXN0U3RyaWRlLAorICAgICAgICAgICBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKQoreworICAg IC8vIEZJWE1FKGNyb2dlcnMpIDogb3B0aW1pemUgZm9yIFNTRQorICAgIGludCBuID0gZnJhbWVz VG9Qcm9jZXNzOworICAgIGZsb2F0IGsgPSAqc2NhbGU7CisgICAgd2hpbGUgKG4tLSkgeworICAg ICAgICBmbG9hdCBzYW1wbGUgPSAqc291cmNlUDsKKyAgICAgICAgKmRlc3RQID0gayAqIHNhbXBs ZTsKKworICAgICAgICBzb3VyY2VQICs9IHNvdXJjZVN0cmlkZTsKKyAgICAgICAgZGVzdFAgKz0g ZGVzdFN0cmlkZTsKKyAgICB9Cit9CisKK3ZvaWQgdmFkZChjb25zdCBmbG9hdCogc291cmNlMVAs CisgICAgICAgICAgaW50IHNvdXJjZVN0cmlkZTEsCisgICAgICAgICAgY29uc3QgZmxvYXQqIHNv dXJjZTJQLAorICAgICAgICAgIGludCBzb3VyY2VTdHJpZGUyLAorICAgICAgICAgIGZsb2F0KiBk ZXN0UCwKKyAgICAgICAgICBpbnQgZGVzdFN0cmlkZSwKKyAgICAgICAgICBzaXplX3QgZnJhbWVz VG9Qcm9jZXNzKQoreworICAgIC8vIEZJWE1FKGNyb2dlcnMpIDogb3B0aW1pemUgZm9yIFNTRQor ICAgIGludCBuID0gZnJhbWVzVG9Qcm9jZXNzOworICAgIHdoaWxlIChuLS0pIHsKKyAgICAgICAg ZmxvYXQgc2FtcGxlMSA9ICpzb3VyY2UxUDsKKyAgICAgICAgZmxvYXQgc2FtcGxlMiA9ICpzb3Vy Y2UyUDsKKyAgICAgICAgKmRlc3RQID0gc2FtcGxlMSArIHNhbXBsZTI7CisKKyAgICAgICAgc291 cmNlMVAgKz0gc291cmNlU3RyaWRlMTsKKyAgICAgICAgc291cmNlMlAgKz0gc291cmNlU3RyaWRl MjsKKyAgICAgICAgZGVzdFAgKz0gZGVzdFN0cmlkZTsKKyAgICB9Cit9ICAgICAgICAgIAorCisj ZW5kaWYgLy8gIVBMQVRGT1JNKE1BQykKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQWNj ZWxlcmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQWNjZWxlcmF0 ZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BY2NlbGVyYXRlLmgJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkg R29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMu ICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3Ig dGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRv cnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2Fy ZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJ UyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIEFjY2VsZXJhdGVfaAorI2Rl ZmluZSBBY2NlbGVyYXRlX2gKKworI2luY2x1ZGUgPHd0Zi9QbGF0Zm9ybS5oPgorCisvLyBEZWZp bmVzIHRoZSBpbnRlcmZhY2UgZm9yIHNldmVyYWwgdmVjdG9yIG1hdGggZnVuY3Rpb25zIHdob3Nl IGltcGxlbWVudGF0aW9uCisvLyB3aWxsIGlkZWFsbHkgYmUgb3B0aW1pemVkCisKKyNpZiBQTEFU Rk9STShNQUMpCisgICAgLy8gT24gdGhlIE1hYyB1c2UgdGhlIGhpZ2hseSBvcHRpbWl6ZWQgdmVy c2lvbnMgaW4gQWNjZWxlcmF0ZS5mcmFtZXdvcmsKKyAgICAjaW5jbHVkZSA8QWNjZWxlcmF0ZS9B Y2NlbGVyYXRlLmg+CisjZWxzZQorICAgIHZvaWQgdnNtdWwoY29uc3QgZmxvYXQqIHNvdXJjZVAs CisgICAgICAgICAgICAgICBpbnQgc291cmNlU3RyaWRlLAorICAgICAgICAgICAgICAgY29uc3Qg ZmxvYXQqIHNjYWxlLAorICAgICAgICAgICAgICAgZmxvYXQqIGRlc3RQLAorICAgICAgICAgICAg ICAgaW50IGRlc3RTdHJpZGUsCisgICAgICAgICAgICAgICBzaXplX3QgZnJhbWVzVG9Qcm9jZXNz KTsKKworICAgIHZvaWQgdmFkZChjb25zdCBmbG9hdCogc291cmNlMVAsCisgICAgICAgICAgICAg IGludCBzb3VyY2VTdHJpZGUxLAorICAgICAgICAgICAgICBjb25zdCBmbG9hdCogc291cmNlMlAs CisgICAgICAgICAgICAgIGludCBzb3VyY2VTdHJpZGUyLAorICAgICAgICAgICAgICBmbG9hdCog ZGVzdFAsCisgICAgICAgICAgICAgIGludCBkZXN0U3RyaWRlLAorICAgICAgICAgICAgICBzaXpl X3QgZnJhbWVzVG9Qcm9jZXNzKTsKKyNlbmRpZgorCisjZW5kaWYgLy8gQWNjZWxlcmF0ZV9oCklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNv cmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9CdXMuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMy MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoK KyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhlIG5hbWUgb2YgQXBw bGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAqICAgICBpdHMg Y29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBk ZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E CisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBdWRpb0J1cy5oIgorCisjaW5j bHVkZSAiQWNjZWxlcmF0ZS5oIgorI2luY2x1ZGUgPGFzc2VydC5oPgorI2luY2x1ZGUgPG1hdGgu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIEF1ZGlvQ2hhbm5lbDo6c2NhbGUoZmxv YXQgc2NhbGUpCit7CisgICAgZmxvYXQgcyA9IHNjYWxlOworICAgIHZzbXVsKGRhdGEoKSwgMSwg JnMsIGRhdGEoKSwgMSwgZnJhbWVTaXplKCkpOworfQorCit2b2lkIEF1ZGlvQ2hhbm5lbDo6c3Vt RnJvbShjb25zdCBBdWRpb0NoYW5uZWwmIHNvdXJjZUNoYW5uZWwpCit7CisgICAgdmFkZChkYXRh KCksIDEsIGNvbnN0X2Nhc3Q8QXVkaW9DaGFubmVsJj4oc291cmNlQ2hhbm5lbCkuZGF0YSgpLCAx LCBkYXRhKCksIDEsIGZyYW1lU2l6ZSgpKTsKK30KKworZmxvYXQgQXVkaW9DaGFubmVsOjptYXhB YnNWYWx1ZSgpIGNvbnN0Cit7CisgICAgY29uc3QgZmxvYXQqIHAgPSBjb25zdERhdGEoKTsKKyAg ICBpbnQgbiA9IGZyYW1lU2l6ZSgpOworCisgICAgZmxvYXQgbWF4ID0gMC4wOworICAgIHdoaWxl IChuLS0pIHsKKyAgICAgICAgZmxvYXQgdmFsdWUgPSAqcCsrOworICAgICAgICBmbG9hdCBhYnNW YWx1ZSA9IGZhYnModmFsdWUpOworICAgICAgICBpZiAoYWJzVmFsdWUgPiBtYXgpCisgICAgICAg ICAgICBtYXggPSBhYnNWYWx1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gbWF4OworfQorCitBdWRp b0J1czo6QXVkaW9CdXMoc2l6ZV90IG5jaGFubmVscywgc2l6ZV90IGZyYW1lU2l6ZSwgYm9vbCBh bGxvY2F0ZSkKKyAgICA6IG1fZnJhbWVTaXplKGZyYW1lU2l6ZSkKKyAgICAsIG1fYnVzR2Fpbigx LjApCisgICAgLCBtX2lzRmlyc3RUaW1lKHRydWUpCisgICAgLCBtX3NhbXBsZVJhdGUoMC4wKQor eworICAgIG1fY2hhbm5lbHMucmVzZXJ2ZUluaXRpYWxDYXBhY2l0eShuY2hhbm5lbHMpOworCisg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBuY2hhbm5lbHM7ICsraSkgeworICAgICAgICBBdWRp b0NoYW5uZWwqIGNoYW5uZWwgPSBhbGxvY2F0ZSA/IG5ldyBBdWRpb0NoYW5uZWwoZnJhbWVTaXpl KSA6IG5ldyBBdWRpb0NoYW5uZWwoMCwgZnJhbWVTaXplKTsKKyAgICAgICAgbV9jaGFubmVscy5h cHBlbmQoY2hhbm5lbCk7CisgICAgfQorCisgICAgbV9sYXlvdXQgPSBMYXlvdXRDYW5vbmljYWw7 IC8vIGZvciBub3cgdGhpcyBpcyB0aGUgb25seSBsYXlvdXQgd2UgZGVmaW5lCit9CisKK0F1ZGlv QnVzOjp+QXVkaW9CdXMoKQoreworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9jaGFubmVs cy5zaXplKCk7ICsraSkKKyAgICAgICAgZGVsZXRlIG1fY2hhbm5lbHNbaV07Cit9CisKK3ZvaWQg QXVkaW9CdXM6OnNldENoYW5uZWxNZW1vcnkoc2l6ZV90IGNoYW5uZWxJbmRleCwgZmxvYXQqIHN0 b3JhZ2UsIHNpemVfdCBmcmFtZVNpemUpCit7CisgICAgaWYgKGNoYW5uZWxJbmRleCA+PSAwICYm IGNoYW5uZWxJbmRleCA8IG1fY2hhbm5lbHMuc2l6ZSgpKSB7CisgICAgICAgIGNoYW5uZWwoY2hh bm5lbEluZGV4KS0+c2V0KHN0b3JhZ2UsIGZyYW1lU2l6ZSk7CisgICAgICAgIG1fZnJhbWVTaXpl ID0gZnJhbWVTaXplOworICAgIH0KK30KKwordm9pZCBBdWRpb0J1czo6emVybygpCit7CisgICAg Zm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2NoYW5uZWxzLnNpemUoKTsgKytpKQorICAgICAgICBt X2NoYW5uZWxzW2ldLT56ZXJvKCk7Cit9CisKK0F1ZGlvQ2hhbm5lbCogQXVkaW9CdXM6OmNoYW5u ZWwodW5zaWduZWQgY2hhbm5lbCkKK3sKKyAgICBpZiAoY2hhbm5lbCA8IG1fY2hhbm5lbHMuc2l6 ZSgpKQorICAgICAgICByZXR1cm4gbV9jaGFubmVsc1tjaGFubmVsXTsKKworICAgIHJldHVybiAw OworfQorCitBdWRpb0NoYW5uZWwqIEF1ZGlvQnVzOjpjaGFubmVsQnlUeXBlKHVuc2lnbmVkIGNo YW5uZWxUeXBlKQoreworICAgIGlmIChtX2xheW91dCA9PSBMYXlvdXRDYW5vbmljYWwpIHsKKyAg ICAgICAgaWYgKGNoYW5uZWxUeXBlID09IENoYW5uZWxNb25vICYmIG51bWJlck9mQ2hhbm5lbHMo KSA9PSAxKQorICAgICAgICAgICAgcmV0dXJuIGNoYW5uZWwoMCk7CisgICAgICAgIHJldHVybiBj aGFubmVsKGNoYW5uZWxUeXBlKTsgLy8gY2hhbm5lbCB0eXBlIG1hcHMgZGlyZWN0bHkgdG8gaW5k ZXgKKyAgICB9CisgICAgLy8gZm9yIG5vdywgd2UgZG9uJ3Qgc3VwcG9ydCBhbnkgb3RoZXIgY2hh bm5lbCBvcmRlcmluZ3MuLi4KKyAgICByZXR1cm4gMDsKK30KKworLy8gUmV0dXJucyB8dHJ1ZXwg aWYgdGhlIGNoYW5uZWwgY291bnQgYW5kIGZyYW1lLXNpemUgbWF0Y2gKK2Jvb2wgQXVkaW9CdXM6 OnRvcG9sb2d5TWF0Y2hlcyhjb25zdCBBdWRpb0J1cyYgYnVzKSBjb25zdAoreworICAgIGlmIChu dW1iZXJPZkNoYW5uZWxzKCkgIT0gYnVzLm51bWJlck9mQ2hhbm5lbHMoKSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOyAvLyBjaGFubmVsIG1pc21hdGNoCisKKyAgICAvLyBNYWtlIHN1cmUgc291cmNl IGJ1cyBoYXMgZW5vdWdoIGZyYW1lcworICAgIGlmIChmcmFtZVNpemUoKSA+IGJ1cy5mcmFtZVNp emUoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOyAvLyBmcmFtZS1zaXplIG1pc21hdGNoCisKKyAg ICByZXR1cm4gdHJ1ZTsKK30KKworLy8gSnVzdCBjb3BpZXMgdGhlIHNhbXBsZXMgZnJvbSB0aGUg c291cmNlIGJ1cyB0byB0aGlzIG9uZQorLy8gT2YgY291cnNlLCB0aGUgY2hhbm5lbCBjb3VudCBh bmQgZnJhbWUtc2l6ZSBtdXN0IG1hdGNoIQorLy8KK3ZvaWQgQXVkaW9CdXM6OmNvcHlGcm9tKGNv bnN0IEF1ZGlvQnVzJiBzb3VyY2VCdXMpCit7CisgICAgaWYgKCF0b3BvbG9neU1hdGNoZXMoc291 cmNlQnVzKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gQ29weSB0aGUgc2FtcGxlIGRhdGEg Zm9yIGVhY2ggY2hhbm5lbAorICAgIGludCBuID0gc291cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMo KTsKKworICAgIHNpemVfdCBmcmFtZVNpemUgPSBzb3VyY2VCdXMuZnJhbWVTaXplKCk7CisKKyAg ICBmb3IgKGludCBpID0gMDsgaSA8IG47ICsraSkgeworICAgICAgICBBdWRpb0NoYW5uZWwqIHNv dXJjZUNoYW5uZWwgPSBjb25zdF9jYXN0PEF1ZGlvQnVzJj4oc291cmNlQnVzKS5jaGFubmVsKGkp OworICAgICAgICBjb25zdCBmbG9hdCogc291cmNlUCA9IHNvdXJjZUNoYW5uZWwtPmNvbnN0RGF0 YSgpOworICAgICAgICBmbG9hdCogZGVzdFAgPSBjaGFubmVsKGkpLT5kYXRhKCk7CisgICAgICAg IG1lbWNweShkZXN0UCwgc291cmNlUCwgc2l6ZW9mKGZsb2F0KSAqIGZyYW1lU2l6ZSk7CisgICAg fQorfQorCitQYXNzT3duUHRyPEF1ZGlvQnVzPiBBdWRpb0J1czo6Y3JlYXRlQnVmZmVyRnJvbVJh bmdlKEF1ZGlvQnVzKiBzb3VyY2VCdWZmZXIsIHNpemVfdCBzdGFydEZyYW1lLCBzaXplX3QgZW5k RnJhbWUpCit7CisgICAgc2l6ZV90IG51bVNvdXJjZUZyYW1lcyA9IHNvdXJjZUJ1ZmZlci0+ZnJh bWVTaXplKCk7CisgICAgc2l6ZV90IG5jaGFubmVscyA9IHNvdXJjZUJ1ZmZlci0+bnVtYmVyT2ZD aGFubmVscygpOworCisgICAgLy8gc2FuaXR5IGNoZWNraW5nCisgICAgaWYgKHN0YXJ0RnJhbWUg Pj0gZW5kRnJhbWUpCisgICAgICAgIHJldHVybiAwOworICAgIGlmIChzdGFydEZyYW1lIDwgMCB8 fCBlbmRGcmFtZSA+IG51bVNvdXJjZUZyYW1lcykKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBz aXplX3QgcmFuZ2VTaXplID0gZW5kRnJhbWUgLSBzdGFydEZyYW1lOworCisgICAgUGFzc093blB0 cjxBdWRpb0J1cz4gYXVkaW9CdXMgPSBuZXcgQXVkaW9CdXMobmNoYW5uZWxzLCByYW5nZVNpemUp OworICAgIGF1ZGlvQnVzLT5zZXRTYW1wbGVSYXRlKHNvdXJjZUJ1ZmZlci0+c2FtcGxlUmF0ZSgp KTsKKworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbmNoYW5uZWxzOyArK2kpIHsKKyAgICAg ICAgZmxvYXQqIHNvdXJjZVAgPSBzb3VyY2VCdWZmZXItPmNoYW5uZWwoaSktPmRhdGEoKTsKKyAg ICAgICAgZmxvYXQqIGRlc3RQID0gYXVkaW9CdXMtPmNoYW5uZWwoaSktPmRhdGEoKTsKKyAgICAg ICAgbWVtY3B5KGRlc3RQLCBzb3VyY2VQICsgc3RhcnRGcmFtZSwgc2l6ZW9mKGZsb2F0KSAqIHJh bmdlU2l6ZSk7CisgICAgfQorCisgICAgcmV0dXJuIGF1ZGlvQnVzOworfQorCitmbG9hdCBBdWRp b0J1czo6bWF4QWJzVmFsdWUoKSBjb25zdAoreyAgCisgICAgZmxvYXQgbWF4ID0gMC4wOworICAg IGludCBuY2hhbm5lbHMgPSBudW1iZXJPZkNoYW5uZWxzKCk7CisKKyAgICBmb3IgKGludCBpID0g MDsgaSA8IG5jaGFubmVsczsgKytpKSB7CisgICAgICAgIEF1ZGlvQ2hhbm5lbCogY2hhbm5lbCA9 IGNvbnN0X2Nhc3Q8QXVkaW9CdXMqPih0aGlzKS0+Y2hhbm5lbChpKTsKKyAgICAgICAgZmxvYXQg Y2hhbm5lbE1heCA9IGNoYW5uZWwtPm1heEFic1ZhbHVlKCk7ICAgIAorICAgICAgICBpZiAoY2hh bm5lbE1heCA+IG1heCkgbWF4ID0gY2hhbm5lbE1heDsKKyAgICB9CisKKyAgICByZXR1cm4gbWF4 OworfQorCit2b2lkIEF1ZGlvQnVzOjpub3JtYWxpemUoKQoreworICAgIGZsb2F0IG1heCA9IG1h eEFic1ZhbHVlKCk7CisgICAgaWYgKG1heCkKKyAgICAgICAgc2NhbGUoMS4wIC8gbWF4KTsKK30K Kwordm9pZCBBdWRpb0J1czo6c2NhbGUoZmxvYXQgc2NhbGUpCit7CisgICAgaW50IG5jaGFubmVs cyA9IG51bWJlck9mQ2hhbm5lbHMoKTsKKworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbmNoYW5u ZWxzOyArK2kpIHsKKyAgICAgICAgQXVkaW9DaGFubmVsKiBjaGFubmVsID0gdGhpcy0+Y2hhbm5l bChpKTsKKyAgICAgICAgY2hhbm5lbC0+c2NhbGUoc2NhbGUpOworICAgIH0KK30KKwordm9pZCBB dWRpb0J1czo6c3VtRnJvbShjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzKQoreworICAgIGJvb2wg aXNUb3BvbG9neUdvb2QgPSB0b3BvbG9neU1hdGNoZXMoc291cmNlQnVzKTsKKyAgICBhc3NlcnQo aXNUb3BvbG9neUdvb2QpOworICAgIGlmICghaXNUb3BvbG9neUdvb2QpIHJldHVybjsKKworICAg IHNpemVfdCBuY2hhbm5lbHMgPSBudW1iZXJPZkNoYW5uZWxzKCk7CisKKyAgICBmb3IgKHNpemVf dCBpID0gMDsgaSA8IG5jaGFubmVsczsgKytpKSB7CisgICAgICAgIGNvbnN0IGZsb2F0KiBzb3Vy Y2VQID0gY29uc3RfY2FzdDxBdWRpb0J1cyY+KHNvdXJjZUJ1cykuY2hhbm5lbChpKS0+ZGF0YSgp OworICAgICAgICBmbG9hdCogZGVzdFAgPSBjaGFubmVsKGkpLT5kYXRhKCk7CisKKyAgICAgICAg dmFkZChzb3VyY2VQLCAxLCBkZXN0UCwgMSwgZGVzdFAsIDEsIGZyYW1lU2l6ZSgpKTsKKyAgICB9 Cit9CisKK3ZvaWQgIEF1ZGlvQnVzOjpzdW1Gcm9tSW1wbChjb25zdCBBdWRpb0J1cyAmc291cmNl QnVzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0KiBsYXN0TWl4R2FpblAsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgdGFyZ2V0R2FpbikKK3sKKyAgICAvLyBG SVhNRShjcm9nZXJzKSA6IE5lZWQgZmFzdCBwYXRoIGhlcmUgd2hlbiBnYWluIGhhcyBjb252ZXJn ZWQgb24gdGFyZ2V0R2FpbgorCisgICAgZG91YmxlIGxhc3RNaXhHYWluID0gKmxhc3RNaXhHYWlu UDsKKworICAgIC8vIFdlIGRvbid0IHdhbnQgdG8gc3VkZGVubHkgY2hhbmdlIHRoZSBnYWluIGZy b20gbWl4aW5nIG9uZSB0aW1lIHNsaWNlCisgICAgLy8gdG8gdGhlIG5leHQsIHNvIHdlICJkZS16 aXBwZXIiIGJ5IHNsb3dseSBjaGFuZ2luZyB0aGUgZ2FpbiBlYWNoCisgICAgLy8gc2FtcGxlIHVu dGlsIHdlJ3ZlIGFjaGlldmVkIHRoZSB0YXJnZXQgZ2FpbgorCisgICAgLy8gVGFrZSBtYXN0ZXIg YnVzIGdhaW4gaW50byBhY2NvdW50IGFzIHdlbGwgYXMgdGhlIHRhcmdldEdhaW4gIAorICAgIGRv dWJsZSB0b3RhbERlc2lyZWRHYWluID0gbV9idXNHYWluICogdGFyZ2V0R2FpbjsKKworICAgIC8v IEZpcnN0IHRpbWUsIHNuYXAgZGlyZWN0bHkgdG8gdG90YWxEZXNpcmVkR2FpbgorICAgIGRvdWJs ZSBnYWluID0gbV9pc0ZpcnN0VGltZSA/IHRvdGFsRGVzaXJlZEdhaW4gOiBsYXN0TWl4R2FpbjsK KyAgICBtX2lzRmlyc3RUaW1lID0gZmFsc2U7CisKKyAgICBpbnQgbmNoYW5uZWxzU291cmNlID0g c291cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMoKTsKKyAgICBpbnQgbmNoYW5uZWxzRGVzdCA9IG51 bWJlck9mQ2hhbm5lbHMoKTsKKworICAgIEF1ZGlvQnVzJiBzb3VyY2VCdXNTYWZlID0gY29uc3Rf Y2FzdDxBdWRpb0J1cyY+KHNvdXJjZUJ1cyk7CisgICAgY29uc3QgZmxvYXQqIHNvdXJjZUwgPSBz b3VyY2VCdXNTYWZlLmNoYW5uZWxCeVR5cGUoQ2hhbm5lbExlZnQpLT5kYXRhKCk7CisgICAgY29u c3QgZmxvYXQqIHNvdXJjZVIgPSBuY2hhbm5lbHNTb3VyY2UgPiAxID8gc291cmNlQnVzU2FmZS5j aGFubmVsQnlUeXBlKENoYW5uZWxSaWdodCktPmRhdGEoKSA6IDA7CisKKyAgICBmbG9hdCogZGVz dEwgPSBjaGFubmVsQnlUeXBlKENoYW5uZWxMZWZ0KS0+ZGF0YSgpOworICAgIGZsb2F0KiBkZXN0 UiA9IG5jaGFubmVsc0Rlc3QgPiAxID8gY2hhbm5lbEJ5VHlwZShDaGFubmVsUmlnaHQpLT5kYXRh KCkgOiAwOworCisgICAgY29uc3QgZG91YmxlIGtEZXppcHBlclJhdGUgPSAwLjAwNTsKKyAgICBp bnQgbiA9IGZyYW1lU2l6ZSgpOworCisgICAgaWYgKHNvdXJjZVIgJiYgZGVzdFIpIHsKKyAgICAg ICAgLy8gU3RlcmVvCisgICAgICAgIHdoaWxlIChuLS0pIHsKKyAgICAgICAgICAgIGZsb2F0IHNh bXBsZUwgPSAqc291cmNlTCsrOworICAgICAgICAgICAgZmxvYXQgc2FtcGxlUiA9ICpzb3VyY2VS Kys7CisgICAgICAgICAgICAqZGVzdEwrKyArPSBnYWluICogc2FtcGxlTDsKKyAgICAgICAgICAg ICpkZXN0UisrICs9IGdhaW4gKiBzYW1wbGVSOworCisgICAgICAgICAgICAvLyBTbG93bHkgY2hh bmdlIGdhaW4gdG8gZGVzaXJlZCBnYWluCisgICAgICAgICAgICBnYWluICs9ICh0b3RhbERlc2ly ZWRHYWluIC0gZ2FpbikgKiBrRGV6aXBwZXJSYXRlOworICAgICAgICB9CisgICAgfSBlbHNlIGlm IChkZXN0UikgeworICAgICAgICAvLyBNb25vIC0+IHN0ZXJlbyAobWl4IGVxdWFsbHkgaW50byBM IGFuZCBSKQorICAgICAgICB3aGlsZSAobi0tKSB7CisgICAgICAgICAgICBmbG9hdCBzYW1wbGUg PSAqc291cmNlTCsrOworICAgICAgICAgICAgKmRlc3RMKysgKz0gZ2FpbiAqIHNhbXBsZTsKKyAg ICAgICAgICAgICpkZXN0UisrICs9IGdhaW4gKiBzYW1wbGU7CisKKyAgICAgICAgICAgIC8vIFNs b3dseSBjaGFuZ2UgZ2FpbiB0byBkZXNpcmVkIGdhaW4KKyAgICAgICAgICAgIGdhaW4gKz0gKHRv dGFsRGVzaXJlZEdhaW4gLSBnYWluKSAqIGtEZXppcHBlclJhdGU7CisgICAgICAgIH0KKyAgICB9 IGVsc2UgeworICAgICAgICAvLyBNb25vCisgICAgICAgIHdoaWxlIChuLS0pIHsKKyAgICAgICAg ICAgIGZsb2F0IHNhbXBsZUwgPSAqc291cmNlTCsrOworICAgICAgICAgICAgKmRlc3RMKysgKz0g Z2FpbiAqIHNhbXBsZUw7CisKKyAgICAgICAgICAgIC8vIFNsb3dseSBjaGFuZ2UgZ2FpbiB0byBk ZXNpcmVkIGdhaW4KKyAgICAgICAgICAgIGdhaW4gKz0gKHRvdGFsRGVzaXJlZEdhaW4gLSBnYWlu KSAqIGtEZXppcHBlclJhdGU7CisgICAgICAgIH0gICAgCisgICAgfQorCisgICAgLy8gU2F2ZSB0 aGUgdGFyZ2V0IGdhaW4gYXMgdGhlIHN0YXJ0aW5nIHBvaW50IGZvciBuZXh0IHRpbWUgYXJvdW5k CisgICAgKmxhc3RNaXhHYWluUCA9IGdhaW47Cit9CisKK3ZvaWQgQXVkaW9CdXM6OnN1bVdpdGhH YWluRnJvbShjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGZsb2F0KiBsYXN0TWl4R2FpblAsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgZmxvYXQgdGFyZ2V0R2FpbikKK3sKKyAgICAvLyBGSVhNRShjcm9nZXJzKSA6IG9wdGlt aXplIHRoaXMgbWV0aG9kIChTU0UsIGV0Yy4pCisKKyAgICAvLyBXZSAqYXJlKiBhYmxlIHRvIHN1 bSBmcm9tIG1vbm8gLT4gc3RlcmVvCisgICAgaWYgKCEoc291cmNlQnVzLm51bWJlck9mQ2hhbm5l bHMoKSA9PSAxKSAmJiAhdG9wb2xvZ3lNYXRjaGVzKHNvdXJjZUJ1cykpIHJldHVybjsKKworICAg IC8vIENvcHkgdGhlIHNhbXBsZSBkYXRhIGZvciBlYWNoIGNoYW5uZWwKKyAgICBpbnQgbmNoYW5u ZWxzID0gbnVtYmVyT2ZDaGFubmVscygpOworCisgICAgc3dpdGNoIChuY2hhbm5lbHMpIHsKKyAg ICBjYXNlIDE6IC8vIG1vbm8KKyAgICBjYXNlIDI6IC8vIHN0ZXJlbworICAgICAgICBzdW1Gcm9t SW1wbChzb3VyY2VCdXMsIGxhc3RNaXhHYWluUCwgdGFyZ2V0R2Fpbik7CisgICAgICAgIGJyZWFr OworICAgIGNhc2UgNDogLy8gcXVhZAorICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIlFVQUQgbWl4 aW5nIHVuaW1wbGVtZW50ZWRcbiIpOworICAgICAgICBicmVhazsKKworICAgIGNhc2UgNTogLy8g NS4wCisgICAgICAgIGZwcmludGYoc3RkZXJyLCAiNS4wIG1peGluZyB1bmltcGxlbWVudGVkXG4i KTsKKyAgICAgICAgYnJlYWs7CisgICAgfQorfQorCit9IC8vIFdlYkNvcmUKSW5kZXg6IFdlYkNv cmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9CdXMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRm b3JtL2F1ZGlvL0F1ZGlvQnVzLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2F1 ZGlvL0F1ZGlvQnVzLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjM1IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0 cmlidXRpb24uCisgKiAzLiAgTmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5j LiAoIkFwcGxlIikgbm9yIHRoZSBuYW1lcyBvZgorICogICAgIGl0cyBjb250cmlidXRvcnMgbWF5 IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQKKyAqICAgICBm cm9tIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Np b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENP TlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVP UlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBB dWRpb0J1c19oCisjZGVmaW5lIEF1ZGlvQnVzX2gKKworI2luY2x1ZGUgIkF1ZGlvRmxvYXRBcnJh eS5oIgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3du UHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK KyAgICAvLyB+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKyAgICAvLyBBbiBBdWRpb0NoYW5uZWwgcmVw cmVzZW50cyBhIGJ1ZmZlciBvZiBub24taW50ZXJsZWF2ZWQgZmxvYXRpbmctcG9pbnQgYXVkaW8g c2FtcGxlcworICAgIC8vIFRoZSBQQ00gc2FtcGxlcyBhcmUgbm9ybWFsbHkgYXNzdW1lZCB0byBi ZSBpbiBhIG5vbWluYWwgcmFuZ2UgLTEuMCAtPiArMS4wCisgICAgLy8KKyAgICBjbGFzcyBBdWRp b0NoYW5uZWwgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgIHB1YmxpYzoKKyAgICAgICAgLy8g TWVtb3J5IGNhbiBiZSBleHRlcm5hbGx5IHJlZmVyZW5jZWQsIG9yIGNhbiBiZSBpbnRlcm5hbGx5 IGFsbG9jYXRlZCB3aXRoIGFuIEF1ZGlvRmxvYXRBcnJheQorCisgICAgICAgIC8vIFJlZmVyZW5j ZSBhbiBleHRlcm5hbCBidWZmZXIKKyAgICAgICAgQXVkaW9DaGFubmVsKGZsb2F0KiBzdG9yYWdl LCBzaXplX3QgZnJhbWVTaXplKQorICAgICAgICAgICAgOiBtX2ZyYW1lU2l6ZShmcmFtZVNpemUp LCBtX3Jhd1BvaW50ZXIoc3RvcmFnZSksIG1fbWVtQnVmZmVyKDApIHsgfQorCisgICAgICAgIC8v IE1hbmFnZSBzdG9yYWdlIGZvciB1cworICAgICAgICBleHBsaWNpdCBBdWRpb0NoYW5uZWwoc2l6 ZV90IGZyYW1lU2l6ZSkKKyAgICAgICAgICAgIDogbV9mcmFtZVNpemUoZnJhbWVTaXplKQorICAg ICAgICAgICAgLCBtX3Jhd1BvaW50ZXIoMCkKKyAgICAgICAgeworICAgICAgICAgICAgbV9tZW1C dWZmZXIgPSBuZXcgQXVkaW9GbG9hdEFycmF5KGZyYW1lU2l6ZSk7CisgICAgICAgIH0KKworICAg ICAgICAvLyBBICJibGFuayIgYXVkaW8gY2hhbm5lbCAtLSBtdXN0IGNhbGwgc2V0KCkgYmVmb3Jl IGl0J3MgdXNlZnVsLi4uCisgICAgICAgIEF1ZGlvQ2hhbm5lbCgpCisgICAgICAgICAgICA6IG1f ZnJhbWVTaXplKDApCisgICAgICAgICAgICAsIG1fcmF3UG9pbnRlcigwKQorICAgICAgICAgICAg LCBtX21lbUJ1ZmZlcigwKQorICAgICAgICB7CisgICAgICAgIH0KKworICAgICAgICB2aXJ0dWFs IH5BdWRpb0NoYW5uZWwoKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAobV9tZW1CdWZmZXIp CisgICAgICAgICAgICAgICAgZGVsZXRlIG1fbWVtQnVmZmVyOyAvLyBjbGVhbnVwIG1hbmFnZWQg c3RvcmFnZQorICAgICAgICB9CisKKyAgICAgICAgLy8gUmVkZWZpbmUgdGhlIG1lbW9yeSBmb3Ig dGhpcyBjaGFubmVsCisgICAgICAgIC8vIHxzdG9yYWdlfCByZXByZXNlbnRzIG1lbW9yeSBub3Qg bWFuYWdlZCBieSB0aGlzIG9iamVjdAorICAgICAgICB2b2lkIHNldChmbG9hdCogc3RvcmFnZSwg c2l6ZV90IGZyYW1lU2l6ZSkKKyAgICAgICAgeworICAgICAgICAgICAgaWYgKG1fbWVtQnVmZmVy KSB7CisgICAgICAgICAgICAgICAgZGVsZXRlIG1fbWVtQnVmZmVyOyAvLyBjbGVhbnVwIG1hbmFn ZWQgc3RvcmFnZQorICAgICAgICAgICAgICAgIG1fbWVtQnVmZmVyID0gMDsKKyAgICAgICAgICAg IH0KKyAgICAgICAgICAgIG1fcmF3UG9pbnRlciA9IHN0b3JhZ2U7CisgICAgICAgICAgICBtX2Zy YW1lU2l6ZSA9IGZyYW1lU2l6ZTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEhvdyBtYW55IHNh bXBsZS1mcmFtZXMgZG8gd2UgY29udGFpbj8KKyAgICAgICAgc2l6ZV90IGZyYW1lU2l6ZSgpIGNv bnN0IHsgcmV0dXJuIG1fZnJhbWVTaXplOyB9CisKKyAgICAgICAgLy8gRGlyZWN0IGFjY2VzcyB0 byBQQ00gc2FtcGxlIGRhdGEKKyAgICAgICAgZmxvYXQqIGRhdGEoKSB7IHJldHVybiBtX3Jhd1Bv aW50ZXIgPyBtX3Jhd1BvaW50ZXIgOiBtX21lbUJ1ZmZlci0+ZGF0YSgpOyB9CisgICAgICAgIGNv bnN0IGZsb2F0KiBjb25zdERhdGEoKSBjb25zdCB7IHJldHVybiBjb25zdF9jYXN0PEF1ZGlvQ2hh bm5lbCo+KHRoaXMpLT5kYXRhKCk7IH0KKworICAgICAgICAvLyBaZXJvZXMgb3V0IGFsbCBzYW1w bGUgdmFsdWVzIGluIGJ1ZmZlcgorICAgICAgICB2b2lkIHplcm8oKQorICAgICAgICB7CisgICAg ICAgICAgICBpZiAobV9tZW1CdWZmZXIpCisgICAgICAgICAgICAgICAgbV9tZW1CdWZmZXItPnpl cm8oKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBtZW1zZXQobV9yYXdQb2lu dGVyLCAwLCBzaXplb2YoZmxvYXQpICogbV9mcmFtZVNpemUpOworICAgICAgICB9CisKKyAgICAg ICAgLy8gU2NhbGVzIGFsbCBzYW1wbGVzIGJ5IHRoZSBzYW1lIGFtb3VudAorICAgICAgICB2b2lk IHNjYWxlKGZsb2F0IHNjYWxlKTsKKworICAgICAgICAvLyBTdW1zICh3aXRoIHVuaXR5IGdhaW4p IGZyb20gdGhlIHNvdXJjZSBjaGFubmVsCisgICAgICAgIHZvaWQgc3VtRnJvbShjb25zdCBBdWRp b0NoYW5uZWwgJnNvdXJjZUNoYW5uZWwpOworCisgICAgICAgIC8vIFJldHVybnMgbWF4aW11bSBh YnNvbHV0ZSB2YWx1ZSAodXNlZnVsIGZvciBub3JtYWxpemF0aW9uKQorICAgICAgICBmbG9hdCBt YXhBYnNWYWx1ZSgpIGNvbnN0OworCisgICAgcHJvdGVjdGVkOgorICAgICAgICBzaXplX3QgbV9m cmFtZVNpemU7CisKKyAgICAgICAgZmxvYXQqIG1fcmF3UG9pbnRlcjsKKyAgICAgICAgQXVkaW9G bG9hdEFycmF5KiBtX21lbUJ1ZmZlcjsKKyAgICB9OworCisgICAgLy8gfn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+CisgICAgLy8gQW4gQXVkaW9CdXMgcmVwcmVzZW50cyBhIGNvbGxlY3Rpb24gb2Ygb25l IG9yIG1vcmUgQXVkaW9DaGFubmVscworICAgIC8vIFRoZSBkYXRhIGxheW91dCBpcyAicGxhbmFy IiBhcyBvcHBvc2VkIHRvICJpbnRlcmxlYXZlZCIKKyAgICAvLyBBbiBBdWRpb0J1cyB3aXRoIG9u ZSBjaGFubmVsIGlzIG1vbm8sIGFuIEF1ZGlvQnVzIHdpdGggdHdvIGNoYW5uZWxzIGlzIHN0ZXJl bywgZXRjLgorICAgIC8vCisgICAgY2xhc3MgQXVkaW9CdXMgIDogcHVibGljIE5vbmNvcHlhYmxl IHsKKyAgICBwdWJsaWM6CisgICAgICAgIGVudW0geworICAgICAgICAgICAgQ2hhbm5lbExlZnQg PSAwLAorICAgICAgICAgICAgQ2hhbm5lbFJpZ2h0ID0gMSwKKyAgICAgICAgICAgIENoYW5uZWxT dXJyb3VuZExlZnQgPSAyLAorICAgICAgICAgICAgQ2hhbm5lbFN1cnJvdW5kUmlnaHQgPSAzLAor ICAgICAgICAgICAgQ2hhbm5lbENlbnRlciA9IDQsIC8vIGNlbnRlciBhbmQgbW9ubyBhcmUgdGhl IHNhbWUKKyAgICAgICAgICAgIENoYW5uZWxNb25vID0gNAorICAgICAgICB9OworCisgICAgICAg IC8vIEZvciBub3cgd2UgZG9uJ3QgZGVmaW5lIGFueSBsYXlvdXRzCisgICAgICAgIGVudW0gewor ICAgICAgICAgICAgTGF5b3V0Q2Fub25pY2FsID0gMAorICAgICAgICAgICAgLy8gRklYTUU6IGFk ZCBzb21lIGxheW91dHMgc3VjaCBhcyBzdGVyZW8sIHF1YWQsIC4uLgorICAgICAgICAgICAgLy8g c3RlcmVvOiAobGVmdCwgcmlnaHQpCisgICAgICAgICAgICAvLyBxdWFkOiAobGVmdCwgcmlnaHQs IHN1cnJvdW5kIGxlZnQsIHN1cnJvdW5kIHJpZ2h0KQorICAgICAgICB9OworCisgICAgICAgIC8v IHxhbGxvY2F0ZXwgaW5kaWNhdGVzIHdoZXRoZXIgb3Igbm90IHRvIGluaXRpYWxseSBoYXZlIHRo ZSBBdWRpb0NoYW5uZWxzIGNyZWF0ZWQKKyAgICAgICAgLy8gd2l0aCBtYW5hZ2VkIHN0b3JhZ2Uu ICBOb3JtYWwgdXNhZ2UgaXMgdG8gcGFzcyB8dHJ1ZXwgaGVyZSwgaW4gd2hpY2ggY2FzZSB0aGUK KyAgICAgICAgLy8gQXVkaW9DaGFubmVscyB3aWxsIG1lbW9yeS1tYW5hZ2UgdGhlaXIgb3duIHN0 b3JhZ2UuICBJZiB8YWxsb2NhdGV8IGlzIHxmYWxzZXwgdGhlbiBzZXRDaGFubmVsTWVtb3J5KCkg aGFzCisgICAgICAgIC8vIHRvIGJlIGNhbGxlZCBsYXRlciBvbiBmb3IgZWFjaCBjaGFubmVsIGJl Zm9yZSB0aGUgQXVkaW9CdXMgaXMgdXNlYWJsZS4uLgorICAgICAgICBBdWRpb0J1cyhzaXplX3Qg bmNoYW5uZWxzLCBzaXplX3QgZnJhbWVTaXplLCBib29sIGFsbG9jYXRlID0gdHJ1ZSk7CisKKyAg ICAgICAgdmlydHVhbCB+QXVkaW9CdXMoKTsKKworICAgICAgICAvLyBUZWxscyB0aGUgZ2l2ZW4g Y2hhbm5lbCB0byB1c2UgYW4gZXh0ZXJuYWxseSBhbGxvY2F0ZWQgYnVmZmVyCisgICAgICAgIHZv aWQgc2V0Q2hhbm5lbE1lbW9yeShzaXplX3QgY2hhbm5lbEluZGV4LCBmbG9hdCogc3RvcmFnZSwg c2l6ZV90IGZyYW1lU2l6ZSk7CisKKyAgICAgICAgLy8gQ2hhbm5lbHMKKyAgICAgICAgc2l6ZV90 IG51bWJlck9mQ2hhbm5lbHMoKSBjb25zdCB7IHJldHVybiBtX2NoYW5uZWxzLnNpemUoKTsgfQor ICAgICAgICBBdWRpb0NoYW5uZWwqIGNoYW5uZWwodW5zaWduZWQgY2hhbm5lbCk7CisgICAgICAg IEF1ZGlvQ2hhbm5lbCogY2hhbm5lbEJ5VHlwZSh1bnNpZ25lZCB0eXBlKTsKKworICAgICAgICAv LyBOdW1iZXIgb2Ygc2FtcGxlLWZyYW1lcworICAgICAgICBzaXplX3QgZnJhbWVTaXplKCkgY29u c3QgeyByZXR1cm4gbV9mcmFtZVNpemU7IH0KKworICAgICAgICAvLyBTYW1wbGUtcmF0ZSA6IDAu MCBpZiB1bmtub3duIG9yICJkb24ndCBjYXJlIgorICAgICAgICBkb3VibGUgc2FtcGxlUmF0ZSgp IGNvbnN0IHsgcmV0dXJuIG1fc2FtcGxlUmF0ZTsgfQorICAgICAgICB2b2lkIHNldFNhbXBsZVJh dGUoZG91YmxlIHNhbXBsZVJhdGUpIHsgbV9zYW1wbGVSYXRlID0gc2FtcGxlUmF0ZTsgfQorCisg ICAgICAgIC8vIFplcm9lcyBhbGwgY2hhbm5lbHMKKyAgICAgICAgdm9pZCB6ZXJvKCk7CisKKyAg ICAgICAgLy8gUmV0dXJucyB8dHJ1ZXwgaWYgdGhlIGNoYW5uZWwgY291bnQgYW5kIGZyYW1lLXNp emUgbWF0Y2gKKyAgICAgICAgYm9vbCB0b3BvbG9neU1hdGNoZXMoY29uc3QgQXVkaW9CdXMgJnNv dXJjZUJ1cykgY29uc3Q7CisKKyAgICAgICAgLy8gQXNzdW1pbmcgfHNvdXJjZUJ1c3wgaGFzIHRo ZSBzYW1lIHRvcG9sb2d5LCBjb3BpZXMgc2FtcGxlIGRhdGEgZnJvbQorICAgICAgICAvLyBlYWNo IGNoYW5uZWwgb2YgfHNvdXJjZUJ1c3wgdG8gb3VyIGNvcnJlc3BvbmRpbmcgY2hhbm5lbAorICAg ICAgICB2b2lkIGNvcHlGcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMpOworCisgICAgICAg IC8vIENyZWF0ZXMgYSBuZXcgYnVmZmVyIGZyb20gYSByYW5nZSBpbiB0aGUgc291cmNlIGJ1ZmZl cgorICAgICAgICAvLyAwIG1heSBiZSByZXR1cm5lZCBpZiB0aGUgcmFuZ2UgZG9lcyBub3QgZml0 IGluIHRoZSBzb3VyY2VCdWZmZXIKKyAgICAgICAgc3RhdGljIFBhc3NPd25QdHI8QXVkaW9CdXM+ IGNyZWF0ZUJ1ZmZlckZyb21SYW5nZShBdWRpb0J1cyogc291cmNlQnVmZmVyLCBzaXplX3Qgc3Rh cnRGcmFtZSwgc2l6ZV90IGVuZEZyYW1lKTsKKworICAgICAgICAvLyBTY2FsZXMgYWxsIHNhbXBs ZXMgYnkgdGhlIHNhbWUgYW1vdW50CisgICAgICAgIHZvaWQgc2NhbGUoZmxvYXQgc2NhbGUpOwor CisgICAgICAgIC8vIFN1bXMgdGhlIHxzb3VyY2VCdXN8IGludG8gb3VyIGJ1cyB3aXRoIHVuaXR5 IGdhaW4KKyAgICAgICAgLy8gb3VyIG93biBpbnRlcm5hbCBnYWluIHxtX2J1c0dhaW58IGlzIGln bm9yZWQKKyAgICAgICAgdm9pZCBzdW1Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMpOwor CisgICAgICAgIC8vIE1hc3RlciBnYWluIGZvciB0aGlzIGJ1cyAtIHVzZWQgd2l0aCBzdW1XaXRo R2FpbkZyb20oKSBiZWxvdworICAgICAgICB2b2lkIHNldEdhaW4oZG91YmxlIGdhaW4pIHsgbV9i dXNHYWluID0gZ2FpbjsgfQorICAgICAgICBkb3VibGUgZ2FpbigpIHsgcmV0dXJuIG1fYnVzR2Fp bjsgfQorICAgIAorICAgICAgICB2b2lkIHJlc2V0KCkgeyBtX2lzRmlyc3RUaW1lID0gdHJ1ZTsg fSAvLyBmb3IgZGUtemlwcGVyaW5nCisKKyAgICAgICAgLy8gU3VtcyBlYWNoIGNoYW5uZWwgZnJv bSB8c291cmNlQnVzfCBpbnRvIG91ciBjb3JyZXNwb25kaW5nIGNoYW5uZWwKKyAgICAgICAgLy8g V2Ugc2NhbGUgYnkgfHRhcmdldEdhaW58IChhbmQgb3VyIG93biBpbnRlcm5hbCBnYWluIHxtX2J1 c0dhaW58KSwKKyAgICAgICAgLy8gcGVyZm9ybWluZyAiZGUtemlwcGVyaW5nIiB0byBzbW9vdGhs eSBjaGFuZ2UgZnJvbSAqbGFzdE1peEdhaW5QIHRvICh0YXJnZXRHYWluKm1fYnVzR2FpbikKKyAg ICAgICAgLy8gVGhlIGNhbGxlciBpcyByZXNwb25zaWJsZSBmb3Igc2V0dGluZyB1cCB8bGFzdE1p eEdhaW5QfCB0byBwb2ludCB0byBzdG9yYWdlIHdoaWNoIGlzIHVuaXF1ZQorICAgICAgICAvLyBm b3IgZXZlcnkgInN0cmVhbSIgd2hpY2ggd2lsbCBiZSBzdW1tZWQgdG8gdGhpcyBidXMuICBUaGlz IHJlcHJlc2VudHMgdGhlIGRlemlwcGVyaW5nIG1lbW9yeS4KKyAgICAgICAgdm9pZCBzdW1XaXRo R2FpbkZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cywKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZmxvYXQqIGxhc3RNaXhHYWluUCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgZmxvYXQgdGFyZ2V0R2Fpbik7CisKKyAgICAgICAgLy8gUmV0dXJucyBtYXhpbXVtIGFic29s dXRlIHZhbHVlIGFjcm9zcyBhbGwgY2hhbm5lbHMgKHVzZWZ1bCBmb3Igbm9ybWFsaXphdGlvbikK KyAgICAgICAgZmxvYXQgbWF4QWJzVmFsdWUoKSBjb25zdDsKKworICAgICAgICAvLyBNYWtlcyBt YXhpbXVtIGFic29sdXRlIHZhbHVlID09IDEuMCAoaWYgcG9zc2libGUpCisgICAgICAgIHZvaWQg bm9ybWFsaXplKCk7CisKKyAgICBwcm90ZWN0ZWQ6CisgICAgICAgIEF1ZGlvQnVzKCkgeyB9OyAv LyBkaXNhbGxvdworCisgICAgICAgIHZvaWQgc3VtRnJvbUltcGwoY29uc3QgQXVkaW9CdXMgJnNv dXJjZUJ1cywKKyAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCogbGFzdE1peEdhaW5QLAor ICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IHRhcmdldEdhaW4pOworCisgICAgICAgIHNp emVfdCBtX2ZyYW1lU2l6ZTsKKworICAgICAgICBWZWN0b3I8QXVkaW9DaGFubmVsKj4gbV9jaGFu bmVsczsKKworICAgICAgICBpbnQgbV9sYXlvdXQ7IAorCisgICAgICAgIGRvdWJsZSBtX2J1c0dh aW47CisgICAgICAgIGJvb2wgbV9pc0ZpcnN0VGltZTsKKyAgICAgICAgZG91YmxlIG1fc2FtcGxl UmF0ZTsgLy8gMC4wIGlmIHVua25vd24gb3IgTi9BCisgICAgfTsKKworICAgIC8vIH5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fgorICAgIC8vIEFic3RyYWN0IGJhc2UtY2xhc3MgZm9yIGEgcHVsbC1tb2Rl bCBjbGllbnQuICB8cHJvdmlkZUlucHV0fCBnZXRzIGNhbGxlZAorICAgIC8vIHJlcGVhdGVkbHkg dG8gcmVuZGVyIHBpZWNlcyBvZiBhIGNvbnRpbnVvdXMgYXVkaW8gc3RyZWFtCisgICAgY2xhc3Mg QXVkaW9Tb3VyY2VQcm92aWRlciB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIHZvaWQg cHJvdmlkZUlucHV0KEF1ZGlvQnVzKiBidXMsIHNpemVfdCBuZnJhbWVzKSA9IDA7ICAKKyAgICAg ICAgdmlydHVhbCB+QXVkaW9Tb3VyY2VQcm92aWRlcigpIHsgfQorICAgIH07CisKK30gLy8gV2Vi Q29yZQorCisjZW5kaWYgLy8gQXVkaW9CdXNfaApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9hdWRp by9BdWRpb0Zsb2F0QXJyYXkuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlv L0F1ZGlvRmxvYXRBcnJheS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9hdWRp by9BdWRpb0Zsb2F0QXJyYXkuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAg ICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUg ZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhlIG5hbWUgb2YgQXBwbGUgQ29tcHV0ZXIs IEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAqICAgICBpdHMgY29udHJpYnV0b3Jz IG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisgKiAg ICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJt aXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElU UyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJ VFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwor ICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5k ZWYgQXVkaW9GbG9hdEFycmF5X2gKKyNkZWZpbmUgQXVkaW9GbG9hdEFycmF5X2gKKworI2luY2x1 ZGUgPHN0cmluZy5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNv cmUgeworICAgIC8vIFRoZSBtYWluIGZlYXR1cmUgQXVkaW9GbG9hdEFycmF5IGltcGxlbWVudHMg YmV5b25kIFZlY3RvcjxmbG9hdD4gaXMgdGhlIGFiaWxpdHkKKyAgICAvLyB0byB6ZXJvIG91dCB0 aGUgZmxvYXQgYXJyYXkgdmVyeSBlZmZpY2llbnRseSB1c2luZyBhbGwgdGhlIG9wdGltaXphdGlv bnMgaW4gbWVtc2V0KCkKKyAgICAvLyBUaGlzIGlzIGltcG9ydGFudCBmb3IgcmVhbC10aW1lIGF1 ZGlvIGFsZ29yaXRobXMgKGZvciBleGFtcGxlLCBjb252b2x1dGlvbiByZXZlcmIpCisgICAgLy8g d2hlcmUgcGVyZm9ybWFuY2UgaXMgY3JpdGljYWwuCisKKyAgICAvLyBUaGUgcmVhc29uIEkgZG9u J3QgdXNlIGEgdGVtcGxhdGUgY2xhc3MgaGVyZSwgaXMgYmVjYXVzZSBpdCB3b3VsZCBiZSBiYWQg dG8gY2FsbAorICAgIC8vIHRoZSB6ZXJvKCkgbWV0aG9kIGlmIHRoZSB0ZW1wbGF0ZSB0eXBlIFQg aGFkIGEgbm9uLXRyaXZpYWwgZGVzdHJ1Y3RvcgorICAgIC8vIChvciB0aGUgY29uc3RydWN0b3Ig ZGlkIG5vdCBzZXQgbWVtb3J5IHRvIGFsbCB6ZXJvZXMuLi4pCisgICAgLy8gV2Ugb25seSBuZWVk IHRoZXNlIHNwZWNpYWxpemVkIHR5cGVzLgorICAgIAorICAgIGNsYXNzIEF1ZGlvRmxvYXRBcnJh eSA6IHB1YmxpYyBWZWN0b3I8ZmxvYXQ+IHsKKyAgICBwdWJsaWM6CisgICAgICAgIGV4cGxpY2l0 IEF1ZGlvRmxvYXRBcnJheSgpIDogVmVjdG9yPGZsb2F0PigwKSB7IH0gLy8gbXVzdCBjYWxsIGFs bG9jYXRlKCkgbGF0ZXIuLi4KKyAgICAgICAgZXhwbGljaXQgQXVkaW9GbG9hdEFycmF5KHNpemVf dCBuKSA6IFZlY3RvcjxmbG9hdD4obiwgMCkgeyB9CisKKyAgICAgICAgdm9pZCBhbGxvY2F0ZShz aXplX3QgbikgeyByZXNpemUobik7IH0KKyAgICAgICAgdm9pZCB6ZXJvKCkgeyBtZW1zZXQoZGF0 YSgpLCAwLCBzaXplb2YoZmxvYXQpICogc2l6ZSgpKTsgfQorICAgICAgICBvcGVyYXRvciBmbG9h dCogKCkgeyByZXR1cm4gZGF0YSgpOyB9CisgICAgfTsKKworICAgIC8vIFRoZSA8ZG91YmxlPiB2 ZXJzaW9uIG9mIEF1ZGlvRmxvYXRBcnJheQorICAgIGNsYXNzIEF1ZGlvRG91YmxlQXJyYXkgOiBw dWJsaWMgVmVjdG9yPGRvdWJsZT4geworICAgIHB1YmxpYzoKKyAgICAgIGV4cGxpY2l0IEF1ZGlv RG91YmxlQXJyYXkoKSA6IFZlY3Rvcjxkb3VibGU+KDApIHsgfSAvLyBtdXN0IGNhbGwgYWxsb2Nh dGUoKSBsYXRlci4uLgorICAgICAgZXhwbGljaXQgQXVkaW9Eb3VibGVBcnJheShzaXplX3Qgbikg OiBWZWN0b3I8ZG91YmxlPihuLCAwKSB7IH0KKyAgCisgICAgICB2b2lkIGFsbG9jYXRlKHNpemVf dCBuKSB7IHJlc2l6ZShuKTsgfQorICAgICAgdm9pZCB6ZXJvKCkgeyBtZW1zZXQoZGF0YSgpLCAw LCBzaXplb2YoZG91YmxlKSAqIHNpemUoKSk7IH0KKyAgICAgIG9wZXJhdG9yIGRvdWJsZSogKCkg eyByZXR1cm4gZGF0YSgpOyB9CisgICAgfTsKKworfSAvLyBXZWJDb3JlCisKKyNlbmRpZiAgLy8g QXVkaW9GbG9hdEFycmF5X2gK 47884 2010-02-01 17:17:17 -0800 2010-08-27 14:19:58 -0700 patch for some initial audio engine support classes: fixes some minor style problems with the initial patch ttt text/plain 31197 crogers SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1NDE1OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNjQgQEAKKzIwMTAtMDItMDEgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJ bml0aWFsIHBhdGNoIGZvciBhdWRpbyBlbmdpbmU6IEF1ZGlvQnVzIGFuZCBoZWxwZXIgY2xhc3Nl cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQ0NTIK KworICAgICAgICBObyB0ZXN0cyBzaW5jZSB0aGlzIGlzIHRoZSBmaXJzdCBiaXQgb2YgbmV3IGF1 ZGlvIGVuZ2luZSBjb2RlIChubyBJREwgZmlsZXMgeWV0KQorCisgICAgICAgICogcGxhdGZvcm0v YXVkaW86IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2F1ZGlvL0FjY2VsZXJhdGUuY3BwOiBB ZGRlZC4KKyAgICAgICAgKHZzbXVsKToKKyAgICAgICAgKHZhZGQpOgorICAgICAgICAqIHBsYXRm b3JtL2F1ZGlvL0FjY2VsZXJhdGUuaDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vYXVkaW8v QXVkaW9CdXMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6c2Nh bGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9DaGFubmVsOjpzdW1Gcm9tKToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6bWF4QWJzVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9CdXM6OkF1ZGlvQnVzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjp+QXVkaW9C dXMpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnNldENoYW5uZWxNZW1vcnkpOgorICAg ICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Onplcm8pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9C dXM6OmNoYW5uZWwpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OmNoYW5uZWxCeVR5cGUp OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnRvcG9sb2d5TWF0Y2hlcyk6CisgICAgICAg IChXZWJDb3JlOjpBdWRpb0J1czo6Y29weUZyb20pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9C dXM6OmNyZWF0ZUJ1ZmZlckZyb21SYW5nZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6 bWF4QWJzVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Om5vcm1hbGl6ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVk aW9CdXM6OnN1bUZyb20pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnN1bUZyb21JbXBs KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpzdW1XaXRoR2FpbkZyb20pOgorICAgICAg ICAqIHBsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9DaGFubmVsOjpBdWRpb0NoYW5uZWwpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9DaGFu bmVsOjp+QXVkaW9DaGFubmVsKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6c2V0 KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6ZnJhbWVTaXplKToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0No YW5uZWw6OmNvbnN0RGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NoYW5uZWw6Onplcm8p OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Oik6CisgICAgICAgIChXZWJDb3JlOjpBdWRp b0J1czo6bnVtYmVyT2ZDaGFubmVscyk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6ZnJh bWVTaXplKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpzYW1wbGVSYXRlKToKKyAgICAg ICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpzZXRTYW1wbGVSYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvQnVzOjpzZXRHYWluKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpnYWluKToK KyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpyZXNldCk6CisgICAgICAgIChXZWJDb3JlOjpB dWRpb0J1czo6QXVkaW9CdXMpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Tb3VyY2VQcm92aWRl cjo6fkF1ZGlvU291cmNlUHJvdmlkZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2F1ZGlvL0F1ZGlv RmxvYXRBcnJheS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvRmxvYXRBcnJheTo6 QXVkaW9GbG9hdEFycmF5KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvRmxvYXRBcnJheTo6YWxs b2NhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9GbG9hdEFycmF5Ojp6ZXJvKToKKyAgICAg ICAgKFdlYkNvcmU6OkF1ZGlvRmxvYXRBcnJheTo6b3BlcmF0b3IgZmxvYXQqICk6CisgICAgICAg IChXZWJDb3JlOjpBdWRpb0RvdWJsZUFycmF5OjpBdWRpb0RvdWJsZUFycmF5KToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvRG91YmxlQXJyYXk6OmFsbG9jYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvRG91YmxlQXJyYXk6Onplcm8pOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Eb3VibGVB cnJheTo6b3BlcmF0b3IgZG91YmxlKiApOgorCiAyMDEwLTAyLTAxICBTYW0gV2VpbmlnICA8c2Ft QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQmV0aCBEYWtpbi4KSW5kZXg6IFdl YkNvcmUvcGxhdGZvcm0vYXVkaW8vQWNjZWxlcmF0ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9wbGF0Zm9ybS9hdWRpby9BY2NlbGVyYXRlLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUv cGxhdGZvcm0vYXVkaW8vQWNjZWxlcmF0ZS5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNzYg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisg KiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxl IENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNv bnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdy aXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1Q TElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAor ICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisvLyBPbiB0aGUgTWFjIHVzZSB0aGUgaGlnaGx5IG9wdGltaXplZCB2ZXJzaW9ucyBpbiBB Y2NlbGVyYXRlLmZyYW1ld29yaworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQWNj ZWxlcmF0ZS5oIgorCisjaWYgIVBMQVRGT1JNKE1BQykKKwordm9pZCB2c211bChjb25zdCBmbG9h dCogc291cmNlUCwKKyAgICAgICAgICAgaW50IHNvdXJjZVN0cmlkZSwKKyAgICAgICAgICAgY29u c3QgZmxvYXQqIHNjYWxlLAorICAgICAgICAgICBmbG9hdCogZGVzdFAsCisgICAgICAgICAgIGlu dCBkZXN0U3RyaWRlLAorICAgICAgICAgICBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKQoreworICAg IC8vIEZJWE1FKGNyb2dlcnMpIDogb3B0aW1pemUgZm9yIFNTRQorICAgIGludCBuID0gZnJhbWVz VG9Qcm9jZXNzOworICAgIGZsb2F0IGsgPSAqc2NhbGU7CisgICAgd2hpbGUgKG4tLSkgeworICAg ICAgICBmbG9hdCBzYW1wbGUgPSAqc291cmNlUDsKKyAgICAgICAgKmRlc3RQID0gayAqIHNhbXBs ZTsKKworICAgICAgICBzb3VyY2VQICs9IHNvdXJjZVN0cmlkZTsKKyAgICAgICAgZGVzdFAgKz0g ZGVzdFN0cmlkZTsKKyAgICB9Cit9CisKK3ZvaWQgdmFkZChjb25zdCBmbG9hdCogc291cmNlMVAs CisgICAgICAgICAgaW50IHNvdXJjZVN0cmlkZTEsCisgICAgICAgICAgY29uc3QgZmxvYXQqIHNv dXJjZTJQLAorICAgICAgICAgIGludCBzb3VyY2VTdHJpZGUyLAorICAgICAgICAgIGZsb2F0KiBk ZXN0UCwKKyAgICAgICAgICBpbnQgZGVzdFN0cmlkZSwKKyAgICAgICAgICBzaXplX3QgZnJhbWVz VG9Qcm9jZXNzKQoreworICAgIC8vIEZJWE1FKGNyb2dlcnMpIDogb3B0aW1pemUgZm9yIFNTRQor ICAgIGludCBuID0gZnJhbWVzVG9Qcm9jZXNzOworICAgIHdoaWxlIChuLS0pIHsKKyAgICAgICAg ZmxvYXQgc2FtcGxlMSA9ICpzb3VyY2UxUDsKKyAgICAgICAgZmxvYXQgc2FtcGxlMiA9ICpzb3Vy Y2UyUDsKKyAgICAgICAgKmRlc3RQID0gc2FtcGxlMSArIHNhbXBsZTI7CisKKyAgICAgICAgc291 cmNlMVAgKz0gc291cmNlU3RyaWRlMTsKKyAgICAgICAgc291cmNlMlAgKz0gc291cmNlU3RyaWRl MjsKKyAgICAgICAgZGVzdFAgKz0gZGVzdFN0cmlkZTsKKyAgICB9Cit9ICAgICAgICAgIAorCisj ZW5kaWYgLy8gIVBMQVRGT1JNKE1BQykKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQWNj ZWxlcmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQWNjZWxlcmF0 ZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BY2NlbGVyYXRlLmgJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkg R29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMu ICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3Ig dGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRv cnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2Fy ZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJ UyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIEFjY2VsZXJhdGVfaAorI2Rl ZmluZSBBY2NlbGVyYXRlX2gKKworI2luY2x1ZGUgPHd0Zi9QbGF0Zm9ybS5oPgorCisvLyBEZWZp bmVzIHRoZSBpbnRlcmZhY2UgZm9yIHNldmVyYWwgdmVjdG9yIG1hdGggZnVuY3Rpb25zIHdob3Nl IGltcGxlbWVudGF0aW9uCisvLyB3aWxsIGlkZWFsbHkgYmUgb3B0aW1pemVkCisKKyNpZiBQTEFU Rk9STShNQUMpCisgICAgLy8gT24gdGhlIE1hYyB1c2UgdGhlIGhpZ2hseSBvcHRpbWl6ZWQgdmVy c2lvbnMgaW4gQWNjZWxlcmF0ZS5mcmFtZXdvcmsKKyAgICAjaW5jbHVkZSA8QWNjZWxlcmF0ZS9B Y2NlbGVyYXRlLmg+CisjZWxzZQorICAgIHZvaWQgdnNtdWwoY29uc3QgZmxvYXQqIHNvdXJjZVAs CisgICAgICAgICAgICAgICBpbnQgc291cmNlU3RyaWRlLAorICAgICAgICAgICAgICAgY29uc3Qg ZmxvYXQqIHNjYWxlLAorICAgICAgICAgICAgICAgZmxvYXQqIGRlc3RQLAorICAgICAgICAgICAg ICAgaW50IGRlc3RTdHJpZGUsCisgICAgICAgICAgICAgICBzaXplX3QgZnJhbWVzVG9Qcm9jZXNz KTsKKworICAgIHZvaWQgdmFkZChjb25zdCBmbG9hdCogc291cmNlMVAsCisgICAgICAgICAgICAg IGludCBzb3VyY2VTdHJpZGUxLAorICAgICAgICAgICAgICBjb25zdCBmbG9hdCogc291cmNlMlAs CisgICAgICAgICAgICAgIGludCBzb3VyY2VTdHJpZGUyLAorICAgICAgICAgICAgICBmbG9hdCog ZGVzdFAsCisgICAgICAgICAgICAgIGludCBkZXN0U3RyaWRlLAorICAgICAgICAgICAgICBzaXpl X3QgZnJhbWVzVG9Qcm9jZXNzKTsKKyNlbmRpZgorCisjZW5kaWYgLy8gQWNjZWxlcmF0ZV9oCklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNv cmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9CdXMuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMy NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoK KyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhlIG5hbWUgb2YgQXBw bGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAqICAgICBpdHMg Y29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBk ZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E CisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBdWRpb0J1cy5oIgorCisjaW5j bHVkZSAiQWNjZWxlcmF0ZS5oIgorI2luY2x1ZGUgPGFzc2VydC5oPgorI2luY2x1ZGUgPG1hdGgu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIEF1ZGlvQ2hhbm5lbDo6c2NhbGUoZmxv YXQgc2NhbGUpCit7CisgICAgZmxvYXQgcyA9IHNjYWxlOworICAgIHZzbXVsKGRhdGEoKSwgMSwg JnMsIGRhdGEoKSwgMSwgZnJhbWVTaXplKCkpOworfQorCit2b2lkIEF1ZGlvQ2hhbm5lbDo6c3Vt RnJvbShjb25zdCBBdWRpb0NoYW5uZWwmIHNvdXJjZUNoYW5uZWwpCit7CisgICAgdmFkZChkYXRh KCksIDEsIGNvbnN0X2Nhc3Q8QXVkaW9DaGFubmVsJj4oc291cmNlQ2hhbm5lbCkuZGF0YSgpLCAx LCBkYXRhKCksIDEsIGZyYW1lU2l6ZSgpKTsKK30KKworZmxvYXQgQXVkaW9DaGFubmVsOjptYXhB YnNWYWx1ZSgpIGNvbnN0Cit7CisgICAgY29uc3QgZmxvYXQqIHAgPSBjb25zdERhdGEoKTsKKyAg ICBpbnQgbiA9IGZyYW1lU2l6ZSgpOworCisgICAgZmxvYXQgbWF4ID0gMC4wOworICAgIHdoaWxl IChuLS0pIHsKKyAgICAgICAgZmxvYXQgdmFsdWUgPSAqcCsrOworICAgICAgICBmbG9hdCBhYnNW YWx1ZSA9IGZhYnModmFsdWUpOworICAgICAgICBpZiAoYWJzVmFsdWUgPiBtYXgpCisgICAgICAg ICAgICBtYXggPSBhYnNWYWx1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gbWF4OworfQorCitBdWRp b0J1czo6QXVkaW9CdXMoc2l6ZV90IG5jaGFubmVscywgc2l6ZV90IGZyYW1lU2l6ZSwgYm9vbCBh bGxvY2F0ZSkKKyAgICA6IG1fZnJhbWVTaXplKGZyYW1lU2l6ZSkKKyAgICAsIG1fYnVzR2Fpbigx LjApCisgICAgLCBtX2lzRmlyc3RUaW1lKHRydWUpCisgICAgLCBtX3NhbXBsZVJhdGUoMC4wKQor eworICAgIG1fY2hhbm5lbHMucmVzZXJ2ZUluaXRpYWxDYXBhY2l0eShuY2hhbm5lbHMpOworCisg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBuY2hhbm5lbHM7ICsraSkgeworICAgICAgICBBdWRp b0NoYW5uZWwqIGNoYW5uZWwgPSBhbGxvY2F0ZSA/IG5ldyBBdWRpb0NoYW5uZWwoZnJhbWVTaXpl KSA6IG5ldyBBdWRpb0NoYW5uZWwoMCwgZnJhbWVTaXplKTsKKyAgICAgICAgbV9jaGFubmVscy5h cHBlbmQoY2hhbm5lbCk7CisgICAgfQorCisgICAgbV9sYXlvdXQgPSBMYXlvdXRDYW5vbmljYWw7 IC8vIGZvciBub3cgdGhpcyBpcyB0aGUgb25seSBsYXlvdXQgd2UgZGVmaW5lCit9CisKK0F1ZGlv QnVzOjp+QXVkaW9CdXMoKQoreworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9jaGFubmVs cy5zaXplKCk7ICsraSkKKyAgICAgICAgZGVsZXRlIG1fY2hhbm5lbHNbaV07Cit9CisKK3ZvaWQg QXVkaW9CdXM6OnNldENoYW5uZWxNZW1vcnkoc2l6ZV90IGNoYW5uZWxJbmRleCwgZmxvYXQqIHN0 b3JhZ2UsIHNpemVfdCBmcmFtZVNpemUpCit7CisgICAgaWYgKGNoYW5uZWxJbmRleCA+PSAwICYm IGNoYW5uZWxJbmRleCA8IG1fY2hhbm5lbHMuc2l6ZSgpKSB7CisgICAgICAgIGNoYW5uZWwoY2hh bm5lbEluZGV4KS0+c2V0KHN0b3JhZ2UsIGZyYW1lU2l6ZSk7CisgICAgICAgIG1fZnJhbWVTaXpl ID0gZnJhbWVTaXplOworICAgIH0KK30KKwordm9pZCBBdWRpb0J1czo6emVybygpCit7CisgICAg Zm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2NoYW5uZWxzLnNpemUoKTsgKytpKQorICAgICAgICBt X2NoYW5uZWxzW2ldLT56ZXJvKCk7Cit9CisKK0F1ZGlvQ2hhbm5lbCogQXVkaW9CdXM6OmNoYW5u ZWwodW5zaWduZWQgY2hhbm5lbCkKK3sKKyAgICBpZiAoY2hhbm5lbCA8IG1fY2hhbm5lbHMuc2l6 ZSgpKQorICAgICAgICByZXR1cm4gbV9jaGFubmVsc1tjaGFubmVsXTsKKworICAgIHJldHVybiAw OworfQorCitBdWRpb0NoYW5uZWwqIEF1ZGlvQnVzOjpjaGFubmVsQnlUeXBlKHVuc2lnbmVkIGNo YW5uZWxUeXBlKQoreworICAgIGlmIChtX2xheW91dCA9PSBMYXlvdXRDYW5vbmljYWwpIHsKKyAg ICAgICAgaWYgKGNoYW5uZWxUeXBlID09IENoYW5uZWxNb25vICYmIG51bWJlck9mQ2hhbm5lbHMo KSA9PSAxKQorICAgICAgICAgICAgcmV0dXJuIGNoYW5uZWwoMCk7CisgICAgICAgIHJldHVybiBj aGFubmVsKGNoYW5uZWxUeXBlKTsgLy8gY2hhbm5lbCB0eXBlIG1hcHMgZGlyZWN0bHkgdG8gaW5k ZXgKKyAgICB9CisgICAgLy8gZm9yIG5vdywgd2UgZG9uJ3Qgc3VwcG9ydCBhbnkgb3RoZXIgY2hh bm5lbCBvcmRlcmluZ3MuLi4KKyAgICByZXR1cm4gMDsKK30KKworLy8gUmV0dXJucyB8dHJ1ZXwg aWYgdGhlIGNoYW5uZWwgY291bnQgYW5kIGZyYW1lLXNpemUgbWF0Y2gKK2Jvb2wgQXVkaW9CdXM6 OnRvcG9sb2d5TWF0Y2hlcyhjb25zdCBBdWRpb0J1cyYgYnVzKSBjb25zdAoreworICAgIGlmIChu dW1iZXJPZkNoYW5uZWxzKCkgIT0gYnVzLm51bWJlck9mQ2hhbm5lbHMoKSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOyAvLyBjaGFubmVsIG1pc21hdGNoCisKKyAgICAvLyBNYWtlIHN1cmUgc291cmNl IGJ1cyBoYXMgZW5vdWdoIGZyYW1lcworICAgIGlmIChmcmFtZVNpemUoKSA+IGJ1cy5mcmFtZVNp emUoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOyAvLyBmcmFtZS1zaXplIG1pc21hdGNoCisKKyAg ICByZXR1cm4gdHJ1ZTsKK30KKworLy8gSnVzdCBjb3BpZXMgdGhlIHNhbXBsZXMgZnJvbSB0aGUg c291cmNlIGJ1cyB0byB0aGlzIG9uZQorLy8gT2YgY291cnNlLCB0aGUgY2hhbm5lbCBjb3VudCBh bmQgZnJhbWUtc2l6ZSBtdXN0IG1hdGNoIQorLy8KK3ZvaWQgQXVkaW9CdXM6OmNvcHlGcm9tKGNv bnN0IEF1ZGlvQnVzJiBzb3VyY2VCdXMpCit7CisgICAgaWYgKCF0b3BvbG9neU1hdGNoZXMoc291 cmNlQnVzKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gQ29weSB0aGUgc2FtcGxlIGRhdGEg Zm9yIGVhY2ggY2hhbm5lbAorICAgIGludCBuID0gc291cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMo KTsKKworICAgIHNpemVfdCBmcmFtZVNpemUgPSBzb3VyY2VCdXMuZnJhbWVTaXplKCk7CisKKyAg ICBmb3IgKGludCBpID0gMDsgaSA8IG47ICsraSkgeworICAgICAgICBBdWRpb0NoYW5uZWwqIHNv dXJjZUNoYW5uZWwgPSBjb25zdF9jYXN0PEF1ZGlvQnVzJj4oc291cmNlQnVzKS5jaGFubmVsKGkp OworICAgICAgICBjb25zdCBmbG9hdCogc291cmNlUCA9IHNvdXJjZUNoYW5uZWwtPmNvbnN0RGF0 YSgpOworICAgICAgICBmbG9hdCogZGVzdFAgPSBjaGFubmVsKGkpLT5kYXRhKCk7CisgICAgICAg IG1lbWNweShkZXN0UCwgc291cmNlUCwgc2l6ZW9mKGZsb2F0KSAqIGZyYW1lU2l6ZSk7CisgICAg fQorfQorCitQYXNzT3duUHRyPEF1ZGlvQnVzPiBBdWRpb0J1czo6Y3JlYXRlQnVmZmVyRnJvbVJh bmdlKEF1ZGlvQnVzKiBzb3VyY2VCdWZmZXIsIHNpemVfdCBzdGFydEZyYW1lLCBzaXplX3QgZW5k RnJhbWUpCit7CisgICAgc2l6ZV90IG51bVNvdXJjZUZyYW1lcyA9IHNvdXJjZUJ1ZmZlci0+ZnJh bWVTaXplKCk7CisgICAgc2l6ZV90IG5jaGFubmVscyA9IHNvdXJjZUJ1ZmZlci0+bnVtYmVyT2ZD aGFubmVscygpOworCisgICAgLy8gc2FuaXR5IGNoZWNraW5nCisgICAgaWYgKHN0YXJ0RnJhbWUg Pj0gZW5kRnJhbWUpCisgICAgICAgIHJldHVybiAwOworICAgIGlmIChzdGFydEZyYW1lIDwgMCB8 fCBlbmRGcmFtZSA+IG51bVNvdXJjZUZyYW1lcykKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBz aXplX3QgcmFuZ2VTaXplID0gZW5kRnJhbWUgLSBzdGFydEZyYW1lOworCisgICAgUGFzc093blB0 cjxBdWRpb0J1cz4gYXVkaW9CdXMgPSBuZXcgQXVkaW9CdXMobmNoYW5uZWxzLCByYW5nZVNpemUp OworICAgIGF1ZGlvQnVzLT5zZXRTYW1wbGVSYXRlKHNvdXJjZUJ1ZmZlci0+c2FtcGxlUmF0ZSgp KTsKKworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbmNoYW5uZWxzOyArK2kpIHsKKyAgICAg ICAgZmxvYXQqIHNvdXJjZVAgPSBzb3VyY2VCdWZmZXItPmNoYW5uZWwoaSktPmRhdGEoKTsKKyAg ICAgICAgZmxvYXQqIGRlc3RQID0gYXVkaW9CdXMtPmNoYW5uZWwoaSktPmRhdGEoKTsKKyAgICAg ICAgbWVtY3B5KGRlc3RQLCBzb3VyY2VQICsgc3RhcnRGcmFtZSwgc2l6ZW9mKGZsb2F0KSAqIHJh bmdlU2l6ZSk7CisgICAgfQorCisgICAgcmV0dXJuIGF1ZGlvQnVzOworfQorCitmbG9hdCBBdWRp b0J1czo6bWF4QWJzVmFsdWUoKSBjb25zdAoreyAgCisgICAgZmxvYXQgbWF4ID0gMC4wOworICAg IGludCBuY2hhbm5lbHMgPSBudW1iZXJPZkNoYW5uZWxzKCk7CisKKyAgICBmb3IgKGludCBpID0g MDsgaSA8IG5jaGFubmVsczsgKytpKSB7CisgICAgICAgIEF1ZGlvQ2hhbm5lbCogY2hhbm5lbCA9 IGNvbnN0X2Nhc3Q8QXVkaW9CdXMqPih0aGlzKS0+Y2hhbm5lbChpKTsKKyAgICAgICAgZmxvYXQg Y2hhbm5lbE1heCA9IGNoYW5uZWwtPm1heEFic1ZhbHVlKCk7ICAgIAorICAgICAgICBpZiAoY2hh bm5lbE1heCA+IG1heCkKKyAgICAgICAgICAgIG1heCA9IGNoYW5uZWxNYXg7CisgICAgfQorCisg ICAgcmV0dXJuIG1heDsKK30KKwordm9pZCBBdWRpb0J1czo6bm9ybWFsaXplKCkKK3sKKyAgICBm bG9hdCBtYXggPSBtYXhBYnNWYWx1ZSgpOworICAgIGlmIChtYXgpCisgICAgICAgIHNjYWxlKDEu MCAvIG1heCk7Cit9CisKK3ZvaWQgQXVkaW9CdXM6OnNjYWxlKGZsb2F0IHNjYWxlKQoreworICAg IGludCBuY2hhbm5lbHMgPSBudW1iZXJPZkNoYW5uZWxzKCk7CisKKyAgICBmb3IgKGludCBpID0g MDsgaSA8IG5jaGFubmVsczsgKytpKSB7CisgICAgICAgIEF1ZGlvQ2hhbm5lbCogY2hhbm5lbCA9 IHRoaXMtPmNoYW5uZWwoaSk7CisgICAgICAgIGNoYW5uZWwtPnNjYWxlKHNjYWxlKTsKKyAgICB9 Cit9CisKK3ZvaWQgQXVkaW9CdXM6OnN1bUZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cykK K3sKKyAgICBib29sIGlzVG9wb2xvZ3lHb29kID0gdG9wb2xvZ3lNYXRjaGVzKHNvdXJjZUJ1cyk7 CisgICAgYXNzZXJ0KGlzVG9wb2xvZ3lHb29kKTsKKyAgICBpZiAoIWlzVG9wb2xvZ3lHb29kKQor ICAgICAgICByZXR1cm47CisKKyAgICBzaXplX3QgbmNoYW5uZWxzID0gbnVtYmVyT2ZDaGFubmVs cygpOworCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBuY2hhbm5lbHM7ICsraSkgeworICAg ICAgICBjb25zdCBmbG9hdCogc291cmNlUCA9IGNvbnN0X2Nhc3Q8QXVkaW9CdXMmPihzb3VyY2VC dXMpLmNoYW5uZWwoaSktPmRhdGEoKTsKKyAgICAgICAgZmxvYXQqIGRlc3RQID0gY2hhbm5lbChp KS0+ZGF0YSgpOworCisgICAgICAgIHZhZGQoc291cmNlUCwgMSwgZGVzdFAsIDEsIGRlc3RQLCAx LCBmcmFtZVNpemUoKSk7CisgICAgfQorfQorCit2b2lkICBBdWRpb0J1czo6c3VtRnJvbUltcGwo Y29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBm bG9hdCogbGFzdE1peEdhaW5QLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IHRh cmdldEdhaW4pCit7CisgICAgLy8gRklYTUUoY3JvZ2VycykgOiBOZWVkIGZhc3QgcGF0aCBoZXJl IHdoZW4gZ2FpbiBoYXMgY29udmVyZ2VkIG9uIHRhcmdldEdhaW4KKworICAgIGRvdWJsZSBsYXN0 TWl4R2FpbiA9ICpsYXN0TWl4R2FpblA7CisKKyAgICAvLyBXZSBkb24ndCB3YW50IHRvIHN1ZGRl bmx5IGNoYW5nZSB0aGUgZ2FpbiBmcm9tIG1peGluZyBvbmUgdGltZSBzbGljZQorICAgIC8vIHRv IHRoZSBuZXh0LCBzbyB3ZSAiZGUtemlwcGVyIiBieSBzbG93bHkgY2hhbmdpbmcgdGhlIGdhaW4g ZWFjaAorICAgIC8vIHNhbXBsZSB1bnRpbCB3ZSd2ZSBhY2hpZXZlZCB0aGUgdGFyZ2V0IGdhaW4K KworICAgIC8vIFRha2UgbWFzdGVyIGJ1cyBnYWluIGludG8gYWNjb3VudCBhcyB3ZWxsIGFzIHRo ZSB0YXJnZXRHYWluICAKKyAgICBkb3VibGUgdG90YWxEZXNpcmVkR2FpbiA9IG1fYnVzR2FpbiAq IHRhcmdldEdhaW47CisKKyAgICAvLyBGaXJzdCB0aW1lLCBzbmFwIGRpcmVjdGx5IHRvIHRvdGFs RGVzaXJlZEdhaW4KKyAgICBkb3VibGUgZ2FpbiA9IG1faXNGaXJzdFRpbWUgPyB0b3RhbERlc2ly ZWRHYWluIDogbGFzdE1peEdhaW47CisgICAgbV9pc0ZpcnN0VGltZSA9IGZhbHNlOworCisgICAg aW50IG5jaGFubmVsc1NvdXJjZSA9IHNvdXJjZUJ1cy5udW1iZXJPZkNoYW5uZWxzKCk7CisgICAg aW50IG5jaGFubmVsc0Rlc3QgPSBudW1iZXJPZkNoYW5uZWxzKCk7CisKKyAgICBBdWRpb0J1cyYg c291cmNlQnVzU2FmZSA9IGNvbnN0X2Nhc3Q8QXVkaW9CdXMmPihzb3VyY2VCdXMpOworICAgIGNv bnN0IGZsb2F0KiBzb3VyY2VMID0gc291cmNlQnVzU2FmZS5jaGFubmVsQnlUeXBlKENoYW5uZWxM ZWZ0KS0+ZGF0YSgpOworICAgIGNvbnN0IGZsb2F0KiBzb3VyY2VSID0gbmNoYW5uZWxzU291cmNl ID4gMSA/IHNvdXJjZUJ1c1NhZmUuY2hhbm5lbEJ5VHlwZShDaGFubmVsUmlnaHQpLT5kYXRhKCkg OiAwOworCisgICAgZmxvYXQqIGRlc3RMID0gY2hhbm5lbEJ5VHlwZShDaGFubmVsTGVmdCktPmRh dGEoKTsKKyAgICBmbG9hdCogZGVzdFIgPSBuY2hhbm5lbHNEZXN0ID4gMSA/IGNoYW5uZWxCeVR5 cGUoQ2hhbm5lbFJpZ2h0KS0+ZGF0YSgpIDogMDsKKworICAgIGNvbnN0IGRvdWJsZSBrRGV6aXBw ZXJSYXRlID0gMC4wMDU7CisgICAgaW50IG4gPSBmcmFtZVNpemUoKTsKKworICAgIGlmIChzb3Vy Y2VSICYmIGRlc3RSKSB7CisgICAgICAgIC8vIFN0ZXJlbworICAgICAgICB3aGlsZSAobi0tKSB7 CisgICAgICAgICAgICBmbG9hdCBzYW1wbGVMID0gKnNvdXJjZUwrKzsKKyAgICAgICAgICAgIGZs b2F0IHNhbXBsZVIgPSAqc291cmNlUisrOworICAgICAgICAgICAgKmRlc3RMKysgKz0gZ2FpbiAq IHNhbXBsZUw7CisgICAgICAgICAgICAqZGVzdFIrKyArPSBnYWluICogc2FtcGxlUjsKKworICAg ICAgICAgICAgLy8gU2xvd2x5IGNoYW5nZSBnYWluIHRvIGRlc2lyZWQgZ2FpbgorICAgICAgICAg ICAgZ2FpbiArPSAodG90YWxEZXNpcmVkR2FpbiAtIGdhaW4pICoga0RlemlwcGVyUmF0ZTsKKyAg ICAgICAgfQorICAgIH0gZWxzZSBpZiAoZGVzdFIpIHsKKyAgICAgICAgLy8gTW9ubyAtPiBzdGVy ZW8gKG1peCBlcXVhbGx5IGludG8gTCBhbmQgUikKKyAgICAgICAgd2hpbGUgKG4tLSkgeworICAg ICAgICAgICAgZmxvYXQgc2FtcGxlID0gKnNvdXJjZUwrKzsKKyAgICAgICAgICAgICpkZXN0TCsr ICs9IGdhaW4gKiBzYW1wbGU7CisgICAgICAgICAgICAqZGVzdFIrKyArPSBnYWluICogc2FtcGxl OworCisgICAgICAgICAgICAvLyBTbG93bHkgY2hhbmdlIGdhaW4gdG8gZGVzaXJlZCBnYWluCisg ICAgICAgICAgICBnYWluICs9ICh0b3RhbERlc2lyZWRHYWluIC0gZ2FpbikgKiBrRGV6aXBwZXJS YXRlOworICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gTW9ubworICAgICAgICB3 aGlsZSAobi0tKSB7CisgICAgICAgICAgICBmbG9hdCBzYW1wbGVMID0gKnNvdXJjZUwrKzsKKyAg ICAgICAgICAgICpkZXN0TCsrICs9IGdhaW4gKiBzYW1wbGVMOworCisgICAgICAgICAgICAvLyBT bG93bHkgY2hhbmdlIGdhaW4gdG8gZGVzaXJlZCBnYWluCisgICAgICAgICAgICBnYWluICs9ICh0 b3RhbERlc2lyZWRHYWluIC0gZ2FpbikgKiBrRGV6aXBwZXJSYXRlOworICAgICAgICB9ICAgIAor ICAgIH0KKworICAgIC8vIFNhdmUgdGhlIHRhcmdldCBnYWluIGFzIHRoZSBzdGFydGluZyBwb2lu dCBmb3IgbmV4dCB0aW1lIGFyb3VuZAorICAgICpsYXN0TWl4R2FpblAgPSBnYWluOworfQorCit2 b2lkIEF1ZGlvQnVzOjpzdW1XaXRoR2FpbkZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCogbGFzdE1peEdhaW5QLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IHRhcmdldEdhaW4pCit7CisgICAgLy8g RklYTUUoY3JvZ2VycykgOiBvcHRpbWl6ZSB0aGlzIG1ldGhvZCAoU1NFLCBldGMuKQorCisgICAg Ly8gV2UgKmFyZSogYWJsZSB0byBzdW0gZnJvbSBtb25vIC0+IHN0ZXJlbworICAgIGlmICghKHNv dXJjZUJ1cy5udW1iZXJPZkNoYW5uZWxzKCkgPT0gMSkgJiYgIXRvcG9sb2d5TWF0Y2hlcyhzb3Vy Y2VCdXMpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBDb3B5IHRoZSBzYW1wbGUgZGF0YSBm b3IgZWFjaCBjaGFubmVsCisgICAgaW50IG5jaGFubmVscyA9IG51bWJlck9mQ2hhbm5lbHMoKTsK KworICAgIHN3aXRjaCAobmNoYW5uZWxzKSB7CisgICAgY2FzZSAxOiAvLyBtb25vCisgICAgY2Fz ZSAyOiAvLyBzdGVyZW8KKyAgICAgICAgc3VtRnJvbUltcGwoc291cmNlQnVzLCBsYXN0TWl4R2Fp blAsIHRhcmdldEdhaW4pOworICAgICAgICBicmVhazsKKyAgICBjYXNlIDQ6IC8vIHF1YWQKKyAg ICAgICAgZnByaW50ZihzdGRlcnIsICJRVUFEIG1peGluZyB1bmltcGxlbWVudGVkXG4iKTsKKyAg ICAgICAgYnJlYWs7CisKKyAgICBjYXNlIDU6IC8vIDUuMAorICAgICAgICBmcHJpbnRmKHN0ZGVy ciwgIjUuMCBtaXhpbmcgdW5pbXBsZW1lbnRlZFxuIik7CisgICAgICAgIGJyZWFrOworICAgIH0K K30KKworfSAvLyBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVz LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5oCShyZXZp c2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5oCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDIzNSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIg dGhlIG5hbWUgb2YgQXBwbGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMg b2YKKyAqICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQg c3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5Z CisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9T UyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9G CisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQXVkaW9CdXNfaAorI2RlZmluZSBBdWRpb0J1 c19oCisKKyNpbmNsdWRlICJBdWRpb0Zsb2F0QXJyYXkuaCIKKyNpbmNsdWRlIDx3dGYvTm9uY29w eWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyB+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4K Ky8vIEFuIEF1ZGlvQ2hhbm5lbCByZXByZXNlbnRzIGEgYnVmZmVyIG9mIG5vbi1pbnRlcmxlYXZl ZCBmbG9hdGluZy1wb2ludCBhdWRpbyBzYW1wbGVzCisvLyBUaGUgUENNIHNhbXBsZXMgYXJlIG5v cm1hbGx5IGFzc3VtZWQgdG8gYmUgaW4gYSBub21pbmFsIHJhbmdlIC0xLjAgLT4gKzEuMAorLy8K K2NsYXNzIEF1ZGlvQ2hhbm5lbCA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CitwdWJsaWM6CisgICAg Ly8gTWVtb3J5IGNhbiBiZSBleHRlcm5hbGx5IHJlZmVyZW5jZWQsIG9yIGNhbiBiZSBpbnRlcm5h bGx5IGFsbG9jYXRlZCB3aXRoIGFuIEF1ZGlvRmxvYXRBcnJheQorCisgICAgLy8gUmVmZXJlbmNl IGFuIGV4dGVybmFsIGJ1ZmZlcgorICAgIEF1ZGlvQ2hhbm5lbChmbG9hdCogc3RvcmFnZSwgc2l6 ZV90IGZyYW1lU2l6ZSkKKyAgICAgICAgOiBtX2ZyYW1lU2l6ZShmcmFtZVNpemUpLCBtX3Jhd1Bv aW50ZXIoc3RvcmFnZSksIG1fbWVtQnVmZmVyKDApIHsgfQorCisgICAgLy8gTWFuYWdlIHN0b3Jh Z2UgZm9yIHVzCisgICAgZXhwbGljaXQgQXVkaW9DaGFubmVsKHNpemVfdCBmcmFtZVNpemUpCisg ICAgICAgIDogbV9mcmFtZVNpemUoZnJhbWVTaXplKQorICAgICAgICAsIG1fcmF3UG9pbnRlcigw KQorICAgIHsKKyAgICAgICAgbV9tZW1CdWZmZXIgPSBuZXcgQXVkaW9GbG9hdEFycmF5KGZyYW1l U2l6ZSk7CisgICAgfQorCisgICAgLy8gQSAiYmxhbmsiIGF1ZGlvIGNoYW5uZWwgLS0gbXVzdCBj YWxsIHNldCgpIGJlZm9yZSBpdCdzIHVzZWZ1bC4uLgorICAgIEF1ZGlvQ2hhbm5lbCgpCisgICAg ICAgIDogbV9mcmFtZVNpemUoMCkKKyAgICAgICAgLCBtX3Jhd1BvaW50ZXIoMCkKKyAgICAgICAg LCBtX21lbUJ1ZmZlcigwKQorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIH5BdWRpb0NoYW5u ZWwoKQorICAgIHsKKyAgICAgICAgaWYgKG1fbWVtQnVmZmVyKQorICAgICAgICAgICAgZGVsZXRl IG1fbWVtQnVmZmVyOyAvLyBjbGVhbnVwIG1hbmFnZWQgc3RvcmFnZQorICAgIH0KKworICAgIC8v IFJlZGVmaW5lIHRoZSBtZW1vcnkgZm9yIHRoaXMgY2hhbm5lbAorICAgIC8vIHxzdG9yYWdlfCBy ZXByZXNlbnRzIG1lbW9yeSBub3QgbWFuYWdlZCBieSB0aGlzIG9iamVjdAorICAgIHZvaWQgc2V0 KGZsb2F0KiBzdG9yYWdlLCBzaXplX3QgZnJhbWVTaXplKQorICAgIHsKKyAgICAgICAgaWYgKG1f bWVtQnVmZmVyKSB7CisgICAgICAgICAgICBkZWxldGUgbV9tZW1CdWZmZXI7IC8vIGNsZWFudXAg bWFuYWdlZCBzdG9yYWdlCisgICAgICAgICAgICBtX21lbUJ1ZmZlciA9IDA7CisgICAgICAgIH0K KyAgICAgICAgbV9yYXdQb2ludGVyID0gc3RvcmFnZTsKKyAgICAgICAgbV9mcmFtZVNpemUgPSBm cmFtZVNpemU7CisgICAgfQorCisgICAgLy8gSG93IG1hbnkgc2FtcGxlLWZyYW1lcyBkbyB3ZSBj b250YWluPworICAgIHNpemVfdCBmcmFtZVNpemUoKSBjb25zdCB7IHJldHVybiBtX2ZyYW1lU2l6 ZTsgfQorCisgICAgLy8gRGlyZWN0IGFjY2VzcyB0byBQQ00gc2FtcGxlIGRhdGEKKyAgICBmbG9h dCogZGF0YSgpIHsgcmV0dXJuIG1fcmF3UG9pbnRlciA/IG1fcmF3UG9pbnRlciA6IG1fbWVtQnVm ZmVyLT5kYXRhKCk7IH0KKyAgICBjb25zdCBmbG9hdCogY29uc3REYXRhKCkgY29uc3QgeyByZXR1 cm4gY29uc3RfY2FzdDxBdWRpb0NoYW5uZWwqPih0aGlzKS0+ZGF0YSgpOyB9CisKKyAgICAvLyBa ZXJvZXMgb3V0IGFsbCBzYW1wbGUgdmFsdWVzIGluIGJ1ZmZlcgorICAgIHZvaWQgemVybygpCisg ICAgeworICAgICAgICBpZiAobV9tZW1CdWZmZXIpCisgICAgICAgICAgICBtX21lbUJ1ZmZlci0+ emVybygpOworICAgICAgICBlbHNlCisgICAgICAgICAgICBtZW1zZXQobV9yYXdQb2ludGVyLCAw LCBzaXplb2YoZmxvYXQpICogbV9mcmFtZVNpemUpOworICAgIH0KKworICAgIC8vIFNjYWxlcyBh bGwgc2FtcGxlcyBieSB0aGUgc2FtZSBhbW91bnQKKyAgICB2b2lkIHNjYWxlKGZsb2F0IHNjYWxl KTsKKworICAgIC8vIFN1bXMgKHdpdGggdW5pdHkgZ2FpbikgZnJvbSB0aGUgc291cmNlIGNoYW5u ZWwKKyAgICB2b2lkIHN1bUZyb20oY29uc3QgQXVkaW9DaGFubmVsICZzb3VyY2VDaGFubmVsKTsK KworICAgIC8vIFJldHVybnMgbWF4aW11bSBhYnNvbHV0ZSB2YWx1ZSAodXNlZnVsIGZvciBub3Jt YWxpemF0aW9uKQorICAgIGZsb2F0IG1heEFic1ZhbHVlKCkgY29uc3Q7CisKK3Byb3RlY3RlZDoK KyAgICBzaXplX3QgbV9mcmFtZVNpemU7CisKKyAgICBmbG9hdCogbV9yYXdQb2ludGVyOworICAg IEF1ZGlvRmxvYXRBcnJheSogbV9tZW1CdWZmZXI7Cit9OworCisvLyB+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn4KKy8vIEFuIEF1ZGlvQnVzIHJlcHJlc2VudHMgYSBjb2xsZWN0aW9uIG9mIG9uZSBvciBt b3JlIEF1ZGlvQ2hhbm5lbHMKKy8vIFRoZSBkYXRhIGxheW91dCBpcyAicGxhbmFyIiBhcyBvcHBv c2VkIHRvICJpbnRlcmxlYXZlZCIKKy8vIEFuIEF1ZGlvQnVzIHdpdGggb25lIGNoYW5uZWwgaXMg bW9ubywgYW4gQXVkaW9CdXMgd2l0aCB0d28gY2hhbm5lbHMgaXMgc3RlcmVvLCBldGMuCisvLwor Y2xhc3MgQXVkaW9CdXMgIDogcHVibGljIE5vbmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBlbnVt IHsKKyAgICAgICAgQ2hhbm5lbExlZnQgPSAwLAorICAgICAgICBDaGFubmVsUmlnaHQgPSAxLAor ICAgICAgICBDaGFubmVsU3Vycm91bmRMZWZ0ID0gMiwKKyAgICAgICAgQ2hhbm5lbFN1cnJvdW5k UmlnaHQgPSAzLAorICAgICAgICBDaGFubmVsQ2VudGVyID0gNCwgLy8gY2VudGVyIGFuZCBtb25v IGFyZSB0aGUgc2FtZQorICAgICAgICBDaGFubmVsTW9ubyA9IDQKKyAgICB9OworCisgICAgLy8g Rm9yIG5vdyB3ZSBkb24ndCBkZWZpbmUgYW55IGxheW91dHMKKyAgICBlbnVtIHsKKyAgICAgICAg TGF5b3V0Q2Fub25pY2FsID0gMAorICAgICAgICAvLyBGSVhNRTogYWRkIHNvbWUgbGF5b3V0cyBz dWNoIGFzIHN0ZXJlbywgcXVhZCwgLi4uCisgICAgICAgIC8vIHN0ZXJlbzogKGxlZnQsIHJpZ2h0 KQorICAgICAgICAvLyBxdWFkOiAobGVmdCwgcmlnaHQsIHN1cnJvdW5kIGxlZnQsIHN1cnJvdW5k IHJpZ2h0KQorICAgIH07CisKKyAgICAvLyB8YWxsb2NhdGV8IGluZGljYXRlcyB3aGV0aGVyIG9y IG5vdCB0byBpbml0aWFsbHkgaGF2ZSB0aGUgQXVkaW9DaGFubmVscyBjcmVhdGVkCisgICAgLy8g d2l0aCBtYW5hZ2VkIHN0b3JhZ2UuICBOb3JtYWwgdXNhZ2UgaXMgdG8gcGFzcyB8dHJ1ZXwgaGVy ZSwgaW4gd2hpY2ggY2FzZSB0aGUKKyAgICAvLyBBdWRpb0NoYW5uZWxzIHdpbGwgbWVtb3J5LW1h bmFnZSB0aGVpciBvd24gc3RvcmFnZS4gIElmIHxhbGxvY2F0ZXwgaXMgfGZhbHNlfCB0aGVuIHNl dENoYW5uZWxNZW1vcnkoKSBoYXMKKyAgICAvLyB0byBiZSBjYWxsZWQgbGF0ZXIgb24gZm9yIGVh Y2ggY2hhbm5lbCBiZWZvcmUgdGhlIEF1ZGlvQnVzIGlzIHVzZWFibGUuLi4KKyAgICBBdWRpb0J1 cyhzaXplX3QgbmNoYW5uZWxzLCBzaXplX3QgZnJhbWVTaXplLCBib29sIGFsbG9jYXRlID0gdHJ1 ZSk7CisKKyAgICB2aXJ0dWFsIH5BdWRpb0J1cygpOworCisgICAgLy8gVGVsbHMgdGhlIGdpdmVu IGNoYW5uZWwgdG8gdXNlIGFuIGV4dGVybmFsbHkgYWxsb2NhdGVkIGJ1ZmZlcgorICAgIHZvaWQg c2V0Q2hhbm5lbE1lbW9yeShzaXplX3QgY2hhbm5lbEluZGV4LCBmbG9hdCogc3RvcmFnZSwgc2l6 ZV90IGZyYW1lU2l6ZSk7CisKKyAgICAvLyBDaGFubmVscworICAgIHNpemVfdCBudW1iZXJPZkNo YW5uZWxzKCkgY29uc3QgeyByZXR1cm4gbV9jaGFubmVscy5zaXplKCk7IH0KKyAgICBBdWRpb0No YW5uZWwqIGNoYW5uZWwodW5zaWduZWQgY2hhbm5lbCk7CisgICAgQXVkaW9DaGFubmVsKiBjaGFu bmVsQnlUeXBlKHVuc2lnbmVkIHR5cGUpOworCisgICAgLy8gTnVtYmVyIG9mIHNhbXBsZS1mcmFt ZXMKKyAgICBzaXplX3QgZnJhbWVTaXplKCkgY29uc3QgeyByZXR1cm4gbV9mcmFtZVNpemU7IH0K KworICAgIC8vIFNhbXBsZS1yYXRlIDogMC4wIGlmIHVua25vd24gb3IgImRvbid0IGNhcmUiCisg ICAgZG91YmxlIHNhbXBsZVJhdGUoKSBjb25zdCB7IHJldHVybiBtX3NhbXBsZVJhdGU7IH0KKyAg ICB2b2lkIHNldFNhbXBsZVJhdGUoZG91YmxlIHNhbXBsZVJhdGUpIHsgbV9zYW1wbGVSYXRlID0g c2FtcGxlUmF0ZTsgfQorCisgICAgLy8gWmVyb2VzIGFsbCBjaGFubmVscworICAgIHZvaWQgemVy bygpOworCisgICAgLy8gUmV0dXJucyB8dHJ1ZXwgaWYgdGhlIGNoYW5uZWwgY291bnQgYW5kIGZy YW1lLXNpemUgbWF0Y2gKKyAgICBib29sIHRvcG9sb2d5TWF0Y2hlcyhjb25zdCBBdWRpb0J1cyAm c291cmNlQnVzKSBjb25zdDsKKworICAgIC8vIEFzc3VtaW5nIHxzb3VyY2VCdXN8IGhhcyB0aGUg c2FtZSB0b3BvbG9neSwgY29waWVzIHNhbXBsZSBkYXRhIGZyb20KKyAgICAvLyBlYWNoIGNoYW5u ZWwgb2YgfHNvdXJjZUJ1c3wgdG8gb3VyIGNvcnJlc3BvbmRpbmcgY2hhbm5lbAorICAgIHZvaWQg Y29weUZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cyk7CisKKyAgICAvLyBDcmVhdGVzIGEg bmV3IGJ1ZmZlciBmcm9tIGEgcmFuZ2UgaW4gdGhlIHNvdXJjZSBidWZmZXIKKyAgICAvLyAwIG1h eSBiZSByZXR1cm5lZCBpZiB0aGUgcmFuZ2UgZG9lcyBub3QgZml0IGluIHRoZSBzb3VyY2VCdWZm ZXIKKyAgICBzdGF0aWMgUGFzc093blB0cjxBdWRpb0J1cz4gY3JlYXRlQnVmZmVyRnJvbVJhbmdl KEF1ZGlvQnVzKiBzb3VyY2VCdWZmZXIsIHNpemVfdCBzdGFydEZyYW1lLCBzaXplX3QgZW5kRnJh bWUpOworCisgICAgLy8gU2NhbGVzIGFsbCBzYW1wbGVzIGJ5IHRoZSBzYW1lIGFtb3VudAorICAg IHZvaWQgc2NhbGUoZmxvYXQgc2NhbGUpOworCisgICAgLy8gU3VtcyB0aGUgfHNvdXJjZUJ1c3wg aW50byBvdXIgYnVzIHdpdGggdW5pdHkgZ2FpbgorICAgIC8vIG91ciBvd24gaW50ZXJuYWwgZ2Fp biB8bV9idXNHYWlufCBpcyBpZ25vcmVkCisgICAgdm9pZCBzdW1Gcm9tKGNvbnN0IEF1ZGlvQnVz ICZzb3VyY2VCdXMpOworCisgICAgLy8gTWFzdGVyIGdhaW4gZm9yIHRoaXMgYnVzIC0gdXNlZCB3 aXRoIHN1bVdpdGhHYWluRnJvbSgpIGJlbG93CisgICAgdm9pZCBzZXRHYWluKGRvdWJsZSBnYWlu KSB7IG1fYnVzR2FpbiA9IGdhaW47IH0KKyAgICBkb3VibGUgZ2FpbigpIHsgcmV0dXJuIG1fYnVz R2FpbjsgfQorCisgICAgdm9pZCByZXNldCgpIHsgbV9pc0ZpcnN0VGltZSA9IHRydWU7IH0gLy8g Zm9yIGRlLXppcHBlcmluZworCisgICAgLy8gU3VtcyBlYWNoIGNoYW5uZWwgZnJvbSB8c291cmNl QnVzfCBpbnRvIG91ciBjb3JyZXNwb25kaW5nIGNoYW5uZWwKKyAgICAvLyBXZSBzY2FsZSBieSB8 dGFyZ2V0R2FpbnwgKGFuZCBvdXIgb3duIGludGVybmFsIGdhaW4gfG1fYnVzR2FpbnwpLAorICAg IC8vIHBlcmZvcm1pbmcgImRlLXppcHBlcmluZyIgdG8gc21vb3RobHkgY2hhbmdlIGZyb20gKmxh c3RNaXhHYWluUCB0byAodGFyZ2V0R2FpbiptX2J1c0dhaW4pCisgICAgLy8gVGhlIGNhbGxlciBp cyByZXNwb25zaWJsZSBmb3Igc2V0dGluZyB1cCB8bGFzdE1peEdhaW5QfCB0byBwb2ludCB0byBz dG9yYWdlIHdoaWNoIGlzIHVuaXF1ZQorICAgIC8vIGZvciBldmVyeSAic3RyZWFtIiB3aGljaCB3 aWxsIGJlIHN1bW1lZCB0byB0aGlzIGJ1cy4gIFRoaXMgcmVwcmVzZW50cyB0aGUgZGV6aXBwZXJp bmcgbWVtb3J5LgorICAgIHZvaWQgc3VtV2l0aEdhaW5Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3Vy Y2VCdXMsCisgICAgICAgICAgICAgICAgICAgICAgICAgZmxvYXQqIGxhc3RNaXhHYWluUCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCB0YXJnZXRHYWluKTsKKworICAgIC8vIFJldHVy bnMgbWF4aW11bSBhYnNvbHV0ZSB2YWx1ZSBhY3Jvc3MgYWxsIGNoYW5uZWxzICh1c2VmdWwgZm9y IG5vcm1hbGl6YXRpb24pCisgICAgZmxvYXQgbWF4QWJzVmFsdWUoKSBjb25zdDsKKworICAgIC8v IE1ha2VzIG1heGltdW0gYWJzb2x1dGUgdmFsdWUgPT0gMS4wIChpZiBwb3NzaWJsZSkKKyAgICB2 b2lkIG5vcm1hbGl6ZSgpOworCitwcm90ZWN0ZWQ6CisgICAgQXVkaW9CdXMoKSB7IH07IC8vIGRp c2FsbG93CisKKyAgICB2b2lkIHN1bUZyb21JbXBsKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMs CisgICAgICAgICAgICAgICAgICAgICBmbG9hdCogbGFzdE1peEdhaW5QLAorICAgICAgICAgICAg ICAgICAgICAgZmxvYXQgdGFyZ2V0R2Fpbik7CisKKyAgICBzaXplX3QgbV9mcmFtZVNpemU7CisK KyAgICBWZWN0b3I8QXVkaW9DaGFubmVsKj4gbV9jaGFubmVsczsKKworICAgIGludCBtX2xheW91 dDsgCisKKyAgICBkb3VibGUgbV9idXNHYWluOworICAgIGJvb2wgbV9pc0ZpcnN0VGltZTsKKyAg ICBkb3VibGUgbV9zYW1wbGVSYXRlOyAvLyAwLjAgaWYgdW5rbm93biBvciBOL0EKK307CisKKy8v IH5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorLy8gQWJzdHJhY3QgYmFzZS1jbGFzcyBmb3IgYSBwdWxs LW1vZGVsIGNsaWVudC4gIHxwcm92aWRlSW5wdXR8IGdldHMgY2FsbGVkCisvLyByZXBlYXRlZGx5 IHRvIHJlbmRlciBwaWVjZXMgb2YgYSBjb250aW51b3VzIGF1ZGlvIHN0cmVhbQorY2xhc3MgQXVk aW9Tb3VyY2VQcm92aWRlciB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2b2lkIHByb3ZpZGVJbnB1 dChBdWRpb0J1cyogYnVzLCBzaXplX3QgbmZyYW1lcykgPSAwOyAgCisgICAgdmlydHVhbCB+QXVk aW9Tb3VyY2VQcm92aWRlcigpIHsgfQorfTsKKworfSAvLyBXZWJDb3JlCisKKyNlbmRpZiAvLyBB dWRpb0J1c19oCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvRmxvYXRBcnJheS5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9GbG9hdEFycmF5LmgJ KHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvRmxvYXRBcnJheS5o CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEw IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKiAz LiAgTmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAoIkFwcGxlIikgbm9y IHRoZSBuYW1lcyBvZgorICogICAgIGl0cyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5k b3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQKKyAqICAgICBmcm9tIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMg SVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBBdWRpb0Zsb2F0QXJyYXlf aAorI2RlZmluZSBBdWRpb0Zsb2F0QXJyYXlfaAorCisjaW5jbHVkZSA8c3RyaW5nLmg+CisjaW5j bHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8vIFRoZSBtYWlu IGZlYXR1cmUgQXVkaW9GbG9hdEFycmF5IGltcGxlbWVudHMgYmV5b25kIFZlY3RvcjxmbG9hdD4g aXMgdGhlIGFiaWxpdHkKKy8vIHRvIHplcm8gb3V0IHRoZSBmbG9hdCBhcnJheSB2ZXJ5IGVmZmlj aWVudGx5IHVzaW5nIGFsbCB0aGUgb3B0aW1pemF0aW9ucyBpbiBtZW1zZXQoKQorLy8gVGhpcyBp cyBpbXBvcnRhbnQgZm9yIHJlYWwtdGltZSBhdWRpbyBhbGdvcml0aG1zIChmb3IgZXhhbXBsZSwg Y29udm9sdXRpb24gcmV2ZXJiKQorLy8gd2hlcmUgcGVyZm9ybWFuY2UgaXMgY3JpdGljYWwuCisK Ky8vIFRoZSByZWFzb24gSSBkb24ndCB1c2UgYSB0ZW1wbGF0ZSBjbGFzcyBoZXJlLCBpcyBiZWNh dXNlIGl0IHdvdWxkIGJlIGJhZCB0byBjYWxsCisvLyB0aGUgemVybygpIG1ldGhvZCBpZiB0aGUg dGVtcGxhdGUgdHlwZSBUIGhhZCBhIG5vbi10cml2aWFsIGRlc3RydWN0b3IKKy8vIChvciB0aGUg Y29uc3RydWN0b3IgZGlkIG5vdCBzZXQgbWVtb3J5IHRvIGFsbCB6ZXJvZXMuLi4pCisvLyBXZSBv bmx5IG5lZWQgdGhlc2Ugc3BlY2lhbGl6ZWQgdHlwZXMuCisKK2NsYXNzIEF1ZGlvRmxvYXRBcnJh eSA6IHB1YmxpYyBWZWN0b3I8ZmxvYXQ+IHsKK3B1YmxpYzoKKyAgICBleHBsaWNpdCBBdWRpb0Zs b2F0QXJyYXkoKSA6IFZlY3RvcjxmbG9hdD4oMCkgeyB9IC8vIG11c3QgY2FsbCBhbGxvY2F0ZSgp IGxhdGVyLi4uCisgICAgZXhwbGljaXQgQXVkaW9GbG9hdEFycmF5KHNpemVfdCBuKSA6IFZlY3Rv cjxmbG9hdD4obiwgMCkgeyB9CisKKyAgICB2b2lkIGFsbG9jYXRlKHNpemVfdCBuKSB7IHJlc2l6 ZShuKTsgfQorICAgIHZvaWQgemVybygpIHsgbWVtc2V0KGRhdGEoKSwgMCwgc2l6ZW9mKGZsb2F0 KSAqIHNpemUoKSk7IH0KKyAgICBvcGVyYXRvciBmbG9hdCogKCkgeyByZXR1cm4gZGF0YSgpOyB9 Cit9OworCisvLyBUaGUgPGRvdWJsZT4gdmVyc2lvbiBvZiBBdWRpb0Zsb2F0QXJyYXkKK2NsYXNz IEF1ZGlvRG91YmxlQXJyYXkgOiBwdWJsaWMgVmVjdG9yPGRvdWJsZT4geworcHVibGljOgorICAg IGV4cGxpY2l0IEF1ZGlvRG91YmxlQXJyYXkoKSA6IFZlY3Rvcjxkb3VibGU+KDApIHsgfSAvLyBt dXN0IGNhbGwgYWxsb2NhdGUoKSBsYXRlci4uLgorICAgIGV4cGxpY2l0IEF1ZGlvRG91YmxlQXJy YXkoc2l6ZV90IG4pIDogVmVjdG9yPGRvdWJsZT4obiwgMCkgeyB9CisKKyAgICB2b2lkIGFsbG9j YXRlKHNpemVfdCBuKSB7IHJlc2l6ZShuKTsgfQorICAgIHZvaWQgemVybygpIHsgbWVtc2V0KGRh dGEoKSwgMCwgc2l6ZW9mKGRvdWJsZSkgKiBzaXplKCkpOyB9CisgICAgb3BlcmF0b3IgZG91Ymxl KiAoKSB7IHJldHVybiBkYXRhKCk7IH0KK307CisKK30gLy8gV2ViQ29yZQorCisjZW5kaWYgLy8g QXVkaW9GbG9hdEFycmF5X2gK 65766 2010-08-27 14:20:02 -0700 2010-08-30 18:42:08 -0700 Patch bug-34452-20100827142000.patch text/plain 31967 crogers SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjI1NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNTcgQEAKKzIwMTAtMDgtMjcgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJ bml0aWFsIHBhdGNoIGZvciBhdWRpbyBlbmdpbmU6IEF1ZGlvQnVzIGFuZCBoZWxwZXIgY2xhc3Nl cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQ0NTIK KworICAgICAgICBObyBuZXcgdGVzdHMgc2luY2UgYXVkaW8gQVBJIGlzIG5vdCB5ZXQgaW1wbGVt ZW50ZWQuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9hdWRpbzogQWRkZWQuCisgICAgICAgICogcGxh dGZvcm0vYXVkaW8vQWNjZWxlcmF0ZS5jcHA6IEFkZGVkLgorICAgICAgICAodnNtdWwpOgorICAg ICAgICAodmFkZCk6CisgICAgICAgICogcGxhdGZvcm0vYXVkaW8vQWNjZWxlcmF0ZS5oOiBBZGRl ZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5jcHA6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6QXVkaW9DaGFubmVsOjpzY2FsZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRp b0NoYW5uZWw6OmNvcHlGcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQ2hhbm5lbDo6c3Vt RnJvbSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NoYW5uZWw6Om1heEFic1ZhbHVlKToKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpBdWRpb0J1cyk6CisgICAgICAgIChXZWJDb3JlOjpB dWRpb0J1czo6c2V0Q2hhbm5lbE1lbW9yeSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6 emVybyk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6Y2hhbm5lbCk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb0J1czo6Y2hhbm5lbEJ5VHlwZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRp b0J1czo6dG9wb2xvZ3lNYXRjaGVzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpjb3B5 RnJvbSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6Y3JlYXRlQnVmZmVyRnJvbVJhbmdl KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjptYXhBYnNWYWx1ZSk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb0J1czo6bm9ybWFsaXplKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVz OjpzY2FsZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c3VtRnJvbSk6CisgICAgICAg IChXZWJDb3JlOjpBdWRpb0J1czo6cHJvY2Vzc1dpdGhHYWluRnJvbU1vbm9TdGVyZW8pOgorICAg ICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnByb2Nlc3NXaXRoR2FpbkZyb20pOgorICAgICAgICAo V2ViQ29yZTo6QXVkaW9CdXM6OnN1bVdpdGhHYWluRnJvbSk6CisgICAgICAgIChXZWJDb3JlOjpB dWRpb0J1czo6Y29weVdpdGhHYWluRnJvbSk6CisgICAgICAgICogcGxhdGZvcm0vYXVkaW8vQXVk aW9CdXMuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NoYW5uZWw6OkF1ZGlvQ2hh bm5lbCk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NoYW5uZWw6OnNldCk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb0NoYW5uZWw6OmZyYW1lU2l6ZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRp b0NoYW5uZWw6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9DaGFubmVsOjpjb25zdERh dGEpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9DaGFubmVsOjp6ZXJvKToKKyAgICAgICAgKFdl YkNvcmU6OkF1ZGlvQnVzOjopOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Om51bWJlck9m Q2hhbm5lbHMpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OmZyYW1lU2l6ZSk6CisgICAg ICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c2FtcGxlUmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpB dWRpb0J1czo6c2V0U2FtcGxlUmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c2V0 R2Fpbik6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6Z2Fpbik6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb0J1czo6cmVzZXQpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OkF1ZGlv QnVzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvU291cmNlUHJvdmlkZXI6On5BdWRpb1NvdXJj ZVByb3ZpZGVyKToKKyAgICAgICAgKiBwbGF0Zm9ybS9hdWRpby9tYWM6IEFkZGVkLgorCiAyMDEw LTA4LTI3ICBLaW51a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBEYXJpbiBGaXNoZXIuCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0Fj Y2VsZXJhdGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQWNjZWxl cmF0ZS5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0FjY2VsZXJh dGUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKiAzLiAgTmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAoIkFwcGxl Iikgbm9yIHRoZSBuYW1lcyBvZgorICogICAgIGl0cyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQKKyAqICAgICBmcm9tIHRoaXMg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9S UyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUK KyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworLy8gT24gdGhlIE1hYyB1c2Ug dGhlIGhpZ2hseSBvcHRpbWl6ZWQgdmVyc2lvbnMgaW4gQWNjZWxlcmF0ZS5mcmFtZXdvcmsKKwor I2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKFdFQl9BVURJTykKKworI2luY2x1ZGUg IkFjY2VsZXJhdGUuaCIKKworI2lmICFPUyhEQVJXSU4pCisKK3ZvaWQgdnNtdWwoY29uc3QgZmxv YXQqIHNvdXJjZVAsIGludCBzb3VyY2VTdHJpZGUsIGNvbnN0IGZsb2F0KiBzY2FsZSwgZmxvYXQq IGRlc3RQLCBpbnQgZGVzdFN0cmlkZSwgc2l6ZV90IGZyYW1lc1RvUHJvY2VzcykKK3sKKyAgICAv LyBGSVhNRTogb3B0aW1pemUgZm9yIFNTRQorICAgIGludCBuID0gZnJhbWVzVG9Qcm9jZXNzOwor ICAgIGZsb2F0IGsgPSAqc2NhbGU7CisgICAgd2hpbGUgKG4tLSkgeworICAgICAgICBmbG9hdCBz YW1wbGUgPSAqc291cmNlUDsKKyAgICAgICAgKmRlc3RQID0gayAqIHNhbXBsZTsKKworICAgICAg ICBzb3VyY2VQICs9IHNvdXJjZVN0cmlkZTsKKyAgICAgICAgZGVzdFAgKz0gZGVzdFN0cmlkZTsK KyAgICB9Cit9CisKK3ZvaWQgdmFkZChjb25zdCBmbG9hdCogc291cmNlMVAsIGludCBzb3VyY2VT dHJpZGUxLCBjb25zdCBmbG9hdCogc291cmNlMlAsIGludCBzb3VyY2VTdHJpZGUyLCBmbG9hdCog ZGVzdFAsIGludCBkZXN0U3RyaWRlLCBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKQoreworICAgIC8v IEZJWE1FOiBvcHRpbWl6ZSBmb3IgU1NFCisgICAgaW50IG4gPSBmcmFtZXNUb1Byb2Nlc3M7Cisg ICAgd2hpbGUgKG4tLSkgeworICAgICAgICBmbG9hdCBzYW1wbGUxID0gKnNvdXJjZTFQOworICAg ICAgICBmbG9hdCBzYW1wbGUyID0gKnNvdXJjZTJQOworICAgICAgICAqZGVzdFAgPSBzYW1wbGUx ICsgc2FtcGxlMjsKKworICAgICAgICBzb3VyY2UxUCArPSBzb3VyY2VTdHJpZGUxOworICAgICAg ICBzb3VyY2UyUCArPSBzb3VyY2VTdHJpZGUyOworICAgICAgICBkZXN0UCArPSBkZXN0U3RyaWRl OworICAgIH0KK30KKworI2VuZGlmIC8vICFPUyhEQVJXSU4pCisKKyNlbmRpZiAvLyBFTkFCTEUo V0VCX0FVRElPKQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BY2NlbGVyYXRlLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BY2NlbGVyYXRlLmgJKHJldmlzaW9u IDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0FjY2VsZXJhdGUuaAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSw1MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhl IG5hbWUgb2YgQXBwbGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YK KyAqICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisg KiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z CisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBP RiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisg KiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQWNjZWxlcmF0ZV9oCisjZGVmaW5lIEFjY2VsZXJh dGVfaAorCisvLyBEZWZpbmVzIHRoZSBpbnRlcmZhY2UgZm9yIHNldmVyYWwgdmVjdG9yIG1hdGgg ZnVuY3Rpb25zIHdob3NlIGltcGxlbWVudGF0aW9uIHdpbGwgaWRlYWxseSBiZSBvcHRpbWl6ZWQK KworI2lmIE9TKERBUldJTikKKy8vIE9uIHRoZSBNYWMgdXNlIHRoZSBoaWdobHkgb3B0aW1pemVk IHZlcnNpb25zIGluIEFjY2VsZXJhdGUuZnJhbWV3b3JrCisjaW5jbHVkZSA8QWNjZWxlcmF0ZS9B Y2NlbGVyYXRlLmg+CisKKyNpZm5kZWYgdmFkZAorI2RlZmluZSB2YWRkIHZEU1BfdmFkZAorI2Vu ZGlmCisKKyNpZm5kZWYgdnNtdWwKKyNkZWZpbmUgdnNtdWwgdkRTUF92c211bAorI2VuZGlmCisK KworI2Vsc2UKK3ZvaWQgdnNtdWwoY29uc3QgZmxvYXQqIHNvdXJjZVAsIGludCBzb3VyY2VTdHJp ZGUsIGNvbnN0IGZsb2F0KiBzY2FsZSwgZmxvYXQqIGRlc3RQLCBpbnQgZGVzdFN0cmlkZSwgc2l6 ZV90IGZyYW1lc1RvUHJvY2Vzcyk7Cit2b2lkIHZhZGQoY29uc3QgZmxvYXQqIHNvdXJjZTFQLCBp bnQgc291cmNlU3RyaWRlMSwgY29uc3QgZmxvYXQqIHNvdXJjZTJQLCBpbnQgc291cmNlU3RyaWRl MiwgZmxvYXQqIGRlc3RQLCBpbnQgZGVzdFN0cmlkZSwgc2l6ZV90IGZyYW1lc1RvUHJvY2Vzcyk7 CisKKyNlbmRpZgorCisjZW5kaWYgLy8gQWNjZWxlcmF0ZV9oCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL2F1ZGlvL0F1ZGlvQnVzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2F1 ZGlvL0F1ZGlvQnVzLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8v QXVkaW9CdXMuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQyNSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhlIG5hbWUgb2YgQXBwbGUgQ29tcHV0ZXIsIEluYy4g KCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAqICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBi ZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisgKiAgICAgZnJv bSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05U UklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKworI2lmIEVOQUJMRShXRUJfQVVESU8pCisKKyNpbmNsdWRlICJBdWRpb0J1cy5o IgorCisjaW5jbHVkZSAiQWNjZWxlcmF0ZS5oIgorI2luY2x1ZGUgPGFzc2VydC5oPgorI2luY2x1 ZGUgPG1hdGguaD4KKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKwordm9pZCBBdWRpb0NoYW5uZWw6OnNjYWxlKGRvdWJsZSBzY2FsZSkKK3sKKyAgICBmbG9h dCBzID0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KHNjYWxlKTsKKyAgICB2c211bChkYXRhKCksIDEsICZz LCBkYXRhKCksIDEsIGZyYW1lU2l6ZSgpKTsKK30KKwordm9pZCBBdWRpb0NoYW5uZWw6OmNvcHlG cm9tKGNvbnN0IEF1ZGlvQ2hhbm5lbCYgc291cmNlQ2hhbm5lbCkKK3sKKyAgICBib29sIGlzU2Fm ZSA9IChzb3VyY2VDaGFubmVsLmZyYW1lU2l6ZSgpID49IGZyYW1lU2l6ZSgpKTsKKyAgICBBU1NF UlQoaXNTYWZlKTsKKyAgICBpZiAoIWlzU2FmZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgbWVt Y3B5KGRhdGEoKSwgc291cmNlQ2hhbm5lbC5jb25zdERhdGEoKSwgc2l6ZW9mKGZsb2F0KSAqIGZy YW1lU2l6ZSgpKTsKK30KKwordm9pZCBBdWRpb0NoYW5uZWw6OnN1bUZyb20oY29uc3QgQXVkaW9D aGFubmVsJiBzb3VyY2VDaGFubmVsKQoreworICAgIGJvb2wgaXNTYWZlID0gKHNvdXJjZUNoYW5u ZWwuZnJhbWVTaXplKCkgPj0gZnJhbWVTaXplKCkpOworICAgIEFTU0VSVChpc1NhZmUpOworICAg IGlmICghaXNTYWZlKQorICAgICAgICByZXR1cm47CisKKyAgICB2YWRkKGRhdGEoKSwgMSwgc291 cmNlQ2hhbm5lbC5jb25zdERhdGEoKSwgMSwgZGF0YSgpLCAxLCBmcmFtZVNpemUoKSk7Cit9CisK K2Zsb2F0IEF1ZGlvQ2hhbm5lbDo6bWF4QWJzVmFsdWUoKSBjb25zdAoreworICAgIGNvbnN0IGZs b2F0KiBwID0gY29uc3REYXRhKCk7CisgICAgaW50IG4gPSBmcmFtZVNpemUoKTsKKworICAgIGZs b2F0IG1heCA9IDAuMGY7CisgICAgd2hpbGUgKG4tLSkgeworICAgICAgICBmbG9hdCB2YWx1ZSA9 ICpwKys7CisgICAgICAgIGZsb2F0IGFic1ZhbHVlID0gZmFic2YodmFsdWUpOworICAgICAgICBp ZiAoYWJzVmFsdWUgPiBtYXgpCisgICAgICAgICAgICBtYXggPSBhYnNWYWx1ZTsKKyAgICB9CisK KyAgICByZXR1cm4gbWF4OworfQorCitBdWRpb0J1czo6QXVkaW9CdXModW5zaWduZWQgbnVtYmVy T2ZDaGFubmVscywgc2l6ZV90IGZyYW1lU2l6ZSwgYm9vbCBhbGxvY2F0ZSkKKyAgICA6IG1fZnJh bWVTaXplKGZyYW1lU2l6ZSkKKyAgICAsIG1fYnVzR2FpbigxLjApCisgICAgLCBtX2lzRmlyc3RU aW1lKHRydWUpCisgICAgLCBtX3NhbXBsZVJhdGUoMC4wKQoreworICAgIG1fY2hhbm5lbHMucmVz ZXJ2ZUluaXRpYWxDYXBhY2l0eShudW1iZXJPZkNoYW5uZWxzKTsKKworICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5uZWxzOyArK2kpIHsKKyAgICAgICAgQXVkaW9DaGFu bmVsKiBjaGFubmVsID0gYWxsb2NhdGUgPyBuZXcgQXVkaW9DaGFubmVsKGZyYW1lU2l6ZSkgOiBu ZXcgQXVkaW9DaGFubmVsKDAsIGZyYW1lU2l6ZSk7CisgICAgICAgIG1fY2hhbm5lbHMuYXBwZW5k KGNoYW5uZWwpOworICAgIH0KKworICAgIG1fbGF5b3V0ID0gTGF5b3V0Q2Fub25pY2FsOyAvLyBm b3Igbm93IHRoaXMgaXMgdGhlIG9ubHkgbGF5b3V0IHdlIGRlZmluZQorfQorCit2b2lkIEF1ZGlv QnVzOjpzZXRDaGFubmVsTWVtb3J5KHVuc2lnbmVkIGNoYW5uZWxJbmRleCwgZmxvYXQqIHN0b3Jh Z2UsIHNpemVfdCBmcmFtZVNpemUpCit7CisgICAgaWYgKGNoYW5uZWxJbmRleCA8IG1fY2hhbm5l bHMuc2l6ZSgpKSB7CisgICAgICAgIGNoYW5uZWwoY2hhbm5lbEluZGV4KS0+c2V0KHN0b3JhZ2Us IGZyYW1lU2l6ZSk7CisgICAgICAgIG1fZnJhbWVTaXplID0gZnJhbWVTaXplOworICAgIH0KK30K Kwordm9pZCBBdWRpb0J1czo6emVybygpCit7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8 IG1fY2hhbm5lbHMuc2l6ZSgpOyArK2kpCisgICAgICAgIG1fY2hhbm5lbHNbaV0tPnplcm8oKTsK K30KKworQXVkaW9DaGFubmVsKiBBdWRpb0J1czo6Y2hhbm5lbCh1bnNpZ25lZCBjaGFubmVsKQor eworICAgIGlmIChjaGFubmVsIDwgbV9jaGFubmVscy5zaXplKCkpCisgICAgICAgIHJldHVybiBt X2NoYW5uZWxzW2NoYW5uZWxdLmdldCgpOworCisgICAgcmV0dXJuIDA7Cit9CisKK0F1ZGlvQ2hh bm5lbCogQXVkaW9CdXM6OmNoYW5uZWxCeVR5cGUodW5zaWduZWQgY2hhbm5lbFR5cGUpCit7Cisg ICAgLy8gRm9yIG5vdyB3ZSBvbmx5IHN1cHBvcnQgY2Fub25pY2FsIGNoYW5uZWwgbGF5b3V0cy4u LgorICAgIGlmIChtX2xheW91dCAhPSBMYXlvdXRDYW5vbmljYWwpCisgICAgICAgIHJldHVybiAw OworCisgICAgc3dpdGNoIChudW1iZXJPZkNoYW5uZWxzKCkpIHsKKyAgICBjYXNlIDE6IC8vIG1v bm8KKyAgICAgICAgaWYgKGNoYW5uZWxUeXBlID09IENoYW5uZWxNb25vIHx8IGNoYW5uZWxUeXBl ID09IENoYW5uZWxMZWZ0KQorICAgICAgICAgICAgcmV0dXJuIGNoYW5uZWwoMCk7CisgICAgICAg IHJldHVybiAwOworCisgICAgY2FzZSAyOiAvLyBzdGVyZW8KKyAgICAgICAgc3dpdGNoIChjaGFu bmVsVHlwZSkgeworICAgICAgICBjYXNlIENoYW5uZWxMZWZ0OiByZXR1cm4gY2hhbm5lbCgwKTsK KyAgICAgICAgY2FzZSBDaGFubmVsUmlnaHQ6IHJldHVybiBjaGFubmVsKDEpOworICAgICAgICBk ZWZhdWx0OiByZXR1cm4gMDsKKyAgICAgICAgfQorCisgICAgY2FzZSA0OiAvLyBxdWFkCisgICAg ICAgIHN3aXRjaCAoY2hhbm5lbFR5cGUpIHsKKyAgICAgICAgY2FzZSBDaGFubmVsTGVmdDogcmV0 dXJuIGNoYW5uZWwoMCk7CisgICAgICAgIGNhc2UgQ2hhbm5lbFJpZ2h0OiByZXR1cm4gY2hhbm5l bCgxKTsKKyAgICAgICAgY2FzZSBDaGFubmVsU3Vycm91bmRMZWZ0OiByZXR1cm4gY2hhbm5lbCgy KTsKKyAgICAgICAgY2FzZSBDaGFubmVsU3Vycm91bmRSaWdodDogcmV0dXJuIGNoYW5uZWwoMyk7 CisgICAgICAgIGRlZmF1bHQ6IHJldHVybiAwOworICAgICAgICB9CisKKyAgICBjYXNlIDU6IC8v IDUuMAorICAgICAgICBzd2l0Y2ggKGNoYW5uZWxUeXBlKSB7CisgICAgICAgIGNhc2UgQ2hhbm5l bExlZnQ6IHJldHVybiBjaGFubmVsKDApOworICAgICAgICBjYXNlIENoYW5uZWxSaWdodDogcmV0 dXJuIGNoYW5uZWwoMSk7CisgICAgICAgIGNhc2UgQ2hhbm5lbENlbnRlcjogcmV0dXJuIGNoYW5u ZWwoMik7CisgICAgICAgIGNhc2UgQ2hhbm5lbFN1cnJvdW5kTGVmdDogcmV0dXJuIGNoYW5uZWwo Myk7CisgICAgICAgIGNhc2UgQ2hhbm5lbFN1cnJvdW5kUmlnaHQ6IHJldHVybiBjaGFubmVsKDQp OworICAgICAgICBkZWZhdWx0OiByZXR1cm4gMDsKKyAgICAgICAgfQorCisgICAgY2FzZSA2OiAv LyA1LjEKKyAgICAgICAgc3dpdGNoIChjaGFubmVsVHlwZSkgeworICAgICAgICBjYXNlIENoYW5u ZWxMZWZ0OiByZXR1cm4gY2hhbm5lbCgwKTsKKyAgICAgICAgY2FzZSBDaGFubmVsUmlnaHQ6IHJl dHVybiBjaGFubmVsKDEpOworICAgICAgICBjYXNlIENoYW5uZWxDZW50ZXI6IHJldHVybiBjaGFu bmVsKDIpOworICAgICAgICBjYXNlIENoYW5uZWxMRkU6IHJldHVybiBjaGFubmVsKDMpOworICAg ICAgICBjYXNlIENoYW5uZWxTdXJyb3VuZExlZnQ6IHJldHVybiBjaGFubmVsKDQpOworICAgICAg ICBjYXNlIENoYW5uZWxTdXJyb3VuZFJpZ2h0OiByZXR1cm4gY2hhbm5lbCg1KTsKKyAgICAgICAg ZGVmYXVsdDogcmV0dXJuIDA7CisgICAgICAgIH0KKworICAgIGRlZmF1bHQ6IC8vIHVua25vd24g Y2Fub25pY2FsIGxheW91dAorICAgICAgICByZXR1cm4gMDsKKyAgICB9CisgICAgCisgICAgcmV0 dXJuIDA7Cit9CisKKy8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgY2hhbm5lbCBjb3VudCBhbmQgZnJh bWUtc2l6ZSBtYXRjaC4KK2Jvb2wgQXVkaW9CdXM6OnRvcG9sb2d5TWF0Y2hlcyhjb25zdCBBdWRp b0J1cyYgYnVzKSBjb25zdAoreworICAgIGlmIChudW1iZXJPZkNoYW5uZWxzKCkgIT0gYnVzLm51 bWJlck9mQ2hhbm5lbHMoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOyAvLyBjaGFubmVsIG1pc21h dGNoCisKKyAgICAvLyBNYWtlIHN1cmUgc291cmNlIGJ1cyBoYXMgZW5vdWdoIGZyYW1lcy4KKyAg ICBpZiAoZnJhbWVTaXplKCkgPiBidXMuZnJhbWVTaXplKCkpCisgICAgICAgIHJldHVybiBmYWxz ZTsgLy8gZnJhbWUtc2l6ZSBtaXNtYXRjaAorCisgICAgcmV0dXJuIHRydWU7Cit9CisKKy8vIEp1 c3QgY29waWVzIHRoZSBzYW1wbGVzIGZyb20gdGhlIHNvdXJjZSBidXMgdG8gdGhpcyBvbmUuCisv LyBUaGlzIGlzIGp1c3QgYSBzaW1wbGUgY29weSBpZiB0aGUgbnVtYmVyIG9mIGNoYW5uZWxzIG1h dGNoLCBvdGhlcndpc2UgYSBtaXh1cCBvciBtaXhkb3duIGlzIGRvbmUuCisvLyBGb3Igbm93LCB3 ZSBqdXN0IHN1cHBvcnQgYSBtaXh1cCBmcm9tIG1vbm8gLT4gc3RlcmVvLgordm9pZCBBdWRpb0J1 czo6Y29weUZyb20oY29uc3QgQXVkaW9CdXMmIHNvdXJjZUJ1cykKK3sKKyAgICBpZiAoJnNvdXJj ZUJ1cyA9PSB0aGlzKQorICAgICAgICByZXR1cm47CisKKyAgICBzaXplX3QgZnJhbWVTaXplID0g c291cmNlQnVzLmZyYW1lU2l6ZSgpOworCisgICAgaWYgKG51bWJlck9mQ2hhbm5lbHMoKSA9PSBz b3VyY2VCdXMubnVtYmVyT2ZDaGFubmVscygpKSB7CisgICAgICAgIC8vIFNpbXBsZSBjb3B5Cisg ICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5uZWxzKCk7ICsraSkg eworICAgICAgICAgICAgQXVkaW9DaGFubmVsKiBzb3VyY2VDaGFubmVsID0gY29uc3RfY2FzdDxB dWRpb0J1cyY+KHNvdXJjZUJ1cykuY2hhbm5lbChpKTsKKyAgICAgICAgICAgIGNoYW5uZWwoaSkt PmNvcHlGcm9tKCpzb3VyY2VDaGFubmVsKTsKKyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAobnVt YmVyT2ZDaGFubmVscygpID09IDIgJiYgc291cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMoKSA9PSAx KSB7CisgICAgICAgIC8vIEhhbmRsZSBtb25vIC0+IHN0ZXJlbyBjYXNlIChmb3Igbm93IHNpbXBs eSBjb3B5IG1vbm8gY2hhbm5lbCBpbnRvIGJvdGggbGVmdCBhbmQgcmlnaHQpCisgICAgICAgIC8v IEZJWE1FOiBSZWFsbHkgd2Ugc2hvdWxkIGFwcGx5IGFuIGVxdWFsLXBvd2VyIHNjYWxpbmcgZmFj dG9yIGhlcmUsIHNpbmNlIHdlJ3JlIGVmZmVjdGl2ZWx5IHBhbm5pbmcgY2VudGVyLi4uCisgICAg ICAgIGNvbnN0IGZsb2F0KiBzb3VyY2UgPSBjb25zdF9jYXN0PEF1ZGlvQnVzJj4oc291cmNlQnVz KS5jaGFubmVsKDApLT5kYXRhKCk7CisgICAgICAgIGZsb2F0KiBkZXN0aW5hdGlvbkwgPSBjaGFu bmVsKDApLT5kYXRhKCk7CisgICAgICAgIGZsb2F0KiBkZXN0aW5hdGlvblIgPSBjaGFubmVsKDEp LT5kYXRhKCk7CisgICAgICAgIG1lbWNweShkZXN0aW5hdGlvbkwsIHNvdXJjZSwgc2l6ZW9mKGZs b2F0KSAqIGZyYW1lU2l6ZSk7CisgICAgICAgIG1lbWNweShkZXN0aW5hdGlvblIsIHNvdXJjZSwg c2l6ZW9mKGZsb2F0KSAqIGZyYW1lU2l6ZSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gQ2Fz ZSBub3QgaGFuZGxlZAorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9Cit9CisK K1Bhc3NPd25QdHI8QXVkaW9CdXM+IEF1ZGlvQnVzOjpjcmVhdGVCdWZmZXJGcm9tUmFuZ2UoQXVk aW9CdXMqIHNvdXJjZUJ1ZmZlciwgdW5zaWduZWQgc3RhcnRGcmFtZSwgdW5zaWduZWQgZW5kRnJh bWUpCit7CisgICAgc2l6ZV90IG51bWJlck9mU291cmNlRnJhbWVzID0gc291cmNlQnVmZmVyLT5m cmFtZVNpemUoKTsKKyAgICB1bnNpZ25lZCBudW1iZXJPZkNoYW5uZWxzID0gc291cmNlQnVmZmVy LT5udW1iZXJPZkNoYW5uZWxzKCk7CisKKyAgICAvLyBTYW5pdHkgY2hlY2tpbmcKKyAgICBib29s IGlzUmFuZ2VTYWZlID0gc3RhcnRGcmFtZSA8IGVuZEZyYW1lICYmIGVuZEZyYW1lIDw9IG51bWJl ck9mU291cmNlRnJhbWVzOworICAgIEFTU0VSVChpc1JhbmdlU2FmZSk7CisgICAgaWYgKCFpc1Jh bmdlU2FmZSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBzaXplX3QgcmFuZ2VTaXplID0gZW5k RnJhbWUgLSBzdGFydEZyYW1lOworCisgICAgUGFzc093blB0cjxBdWRpb0J1cz4gYXVkaW9CdXMg PSBuZXcgQXVkaW9CdXMobnVtYmVyT2ZDaGFubmVscywgcmFuZ2VTaXplKTsKKyAgICBhdWRpb0J1 cy0+c2V0U2FtcGxlUmF0ZShzb3VyY2VCdWZmZXItPnNhbXBsZVJhdGUoKSk7CisKKyAgICBmb3Ig KHVuc2lnbmVkIGkgPSAwOyBpIDwgbnVtYmVyT2ZDaGFubmVsczsgKytpKSB7CisgICAgICAgIGZs b2F0KiBzb3VyY2UgPSBzb3VyY2VCdWZmZXItPmNoYW5uZWwoaSktPmRhdGEoKTsKKyAgICAgICAg ZmxvYXQqIGRlc3RpbmF0aW9uID0gYXVkaW9CdXMtPmNoYW5uZWwoaSktPmRhdGEoKTsKKyAgICAg ICAgbWVtY3B5KGRlc3RpbmF0aW9uLCBzb3VyY2UgKyBzdGFydEZyYW1lLCBzaXplb2YoZmxvYXQp ICogcmFuZ2VTaXplKTsKKyAgICB9CisKKyAgICByZXR1cm4gYXVkaW9CdXM7Cit9CisKK2Zsb2F0 IEF1ZGlvQnVzOjptYXhBYnNWYWx1ZSgpIGNvbnN0Cit7CisgICAgZmxvYXQgbWF4ID0gMC4wZjsK KyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbnVtYmVyT2ZDaGFubmVscygpOyArK2kpIHsK KyAgICAgICAgQXVkaW9DaGFubmVsKiBjaGFubmVsID0gY29uc3RfY2FzdDxBdWRpb0J1cyo+KHRo aXMpLT5jaGFubmVsKGkpOworICAgICAgICBmbG9hdCBjaGFubmVsTWF4ID0gY2hhbm5lbC0+bWF4 QWJzVmFsdWUoKTsKKyAgICAgICAgaWYgKGNoYW5uZWxNYXggPiBtYXgpCisgICAgICAgICAgICBt YXggPSBjaGFubmVsTWF4OworICAgIH0KKworICAgIHJldHVybiBtYXg7Cit9CisKK3ZvaWQgQXVk aW9CdXM6Om5vcm1hbGl6ZSgpCit7CisgICAgZmxvYXQgbWF4ID0gbWF4QWJzVmFsdWUoKTsKKyAg ICBpZiAobWF4KQorICAgICAgICBzY2FsZSgxLjBmIC8gbWF4KTsKK30KKwordm9pZCBBdWRpb0J1 czo6c2NhbGUoZG91YmxlIHNjYWxlKQoreworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBu dW1iZXJPZkNoYW5uZWxzKCk7ICsraSkKKyAgICAgICAgY2hhbm5lbChpKS0+c2NhbGUoc2NhbGUp OworfQorCit2b2lkIEF1ZGlvQnVzOjpzdW1Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMp Cit7CisgICAgaWYgKG51bWJlck9mQ2hhbm5lbHMoKSA9PSBzb3VyY2VCdXMubnVtYmVyT2ZDaGFu bmVscygpKSB7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5u ZWxzKCk7ICsraSkKKyAgICAgICAgICAgIGNoYW5uZWwoaSktPnN1bUZyb20oKmNvbnN0X2Nhc3Q8 QXVkaW9CdXMmPihzb3VyY2VCdXMpLmNoYW5uZWwoaSkpOworICAgIH0gZWxzZSBpZiAobnVtYmVy T2ZDaGFubmVscygpID09IDIgJiYgc291cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMoKSA9PSAxKSB7 CisgICAgICAgIC8vIEhhbmRsZSBtb25vIC0+IHN0ZXJlbyBjYXNlIChmb3Igbm93IHNpbXBseSBz dW0gbW9ubyBjaGFubmVsIGludG8gYm90aCBsZWZ0IGFuZCByaWdodCkKKyAgICAgICAgLy8gRklY TUU6IFJlYWxseSB3ZSBzaG91bGQgYXBwbHkgYW4gZXF1YWwtcG93ZXIgc2NhbGluZyBmYWN0b3Ig aGVyZSwgc2luY2Ugd2UncmUgZWZmZWN0aXZlbHkgcGFubmluZyBjZW50ZXIuLi4KKyAgICAgICAg QXVkaW9DaGFubmVsKiBzb3VyY2VDaGFubmVsID0gY29uc3RfY2FzdDxBdWRpb0J1cyY+KHNvdXJj ZUJ1cykuY2hhbm5lbCgwKTsKKyAgICAgICAgY2hhbm5lbCgwKS0+c3VtRnJvbSgqc291cmNlQ2hh bm5lbCk7CisgICAgICAgIGNoYW5uZWwoMSktPnN1bUZyb20oKnNvdXJjZUNoYW5uZWwpOworICAg IH0gZWxzZSB7CisgICAgICAgIC8vIENhc2Ugbm90IGhhbmRsZWQKKyAgICAgICAgQVNTRVJUX05P VF9SRUFDSEVEKCk7CisgICAgfQorfQorCit2b2lkIEF1ZGlvQnVzOjpwcm9jZXNzV2l0aEdhaW5G cm9tTW9ub1N0ZXJlbyhjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzLCBkb3VibGUqIGxhc3RNaXhH YWluLCBkb3VibGUgdGFyZ2V0R2FpbiwgYm9vbCBzdW1Ub0J1cykKK3sKKyAgICAvLyBXZSBkb24n dCB3YW50IHRvIHN1ZGRlbmx5IGNoYW5nZSB0aGUgZ2FpbiBmcm9tIG1peGluZyBvbmUgdGltZSBz bGljZSB0byB0aGUgbmV4dCwKKyAgICAvLyBzbyB3ZSAiZGUtemlwcGVyIiBieSBzbG93bHkgY2hh bmdpbmcgdGhlIGdhaW4gZWFjaCBzYW1wbGUtZnJhbWUgdW50aWwgd2UndmUgYWNoaWV2ZWQgdGhl IHRhcmdldCBnYWluLgorCisgICAgLy8gRklYTUU6IG9wdGltaXplIHRoaXMgbWV0aG9kIChTU0Us IGV0Yy4pCisgICAgLy8gRklYTUU6IE5lZWQgZmFzdCBwYXRoIGhlcmUgd2hlbiBnYWluIGhhcyBj b252ZXJnZWQgb24gdGFyZ2V0R2Fpbi4gSW4gdGhpcyBjYXNlLCBkZS16aXBwZXJpbmcgaXMgbm8g bG9uZ2VyIG5lZWRlZC4KKyAgICAvLyBGSVhNRTogTmVlZCBmYXN0IHBhdGggd2hlbiB0aGlzPT1z b3VyY2VCdXMgJiYgbGFzdE1peEdhaW49PXRhcmdldEdhaW49PTEuMCAmJiBzdW1Ub0J1cz09ZmFs c2UgKHRoaXMgaXMgYSBOT1ApCisKKyAgICAvLyBUYWtlIG1hc3RlciBidXMgZ2FpbiBpbnRvIGFj Y291bnQgYXMgd2VsbCBhcyB0aGUgdGFyZ2V0R2Fpbi4KKyAgICBkb3VibGUgdG90YWxEZXNpcmVk R2FpbiA9IG1fYnVzR2FpbiAqIHRhcmdldEdhaW47CisKKyAgICAvLyBGaXJzdCB0aW1lLCBzbmFw IGRpcmVjdGx5IHRvIHRvdGFsRGVzaXJlZEdhaW4uCisgICAgZG91YmxlIGdhaW4gPSBtX2lzRmly c3RUaW1lID8gdG90YWxEZXNpcmVkR2FpbiA6ICpsYXN0TWl4R2FpbjsKKyAgICBtX2lzRmlyc3RU aW1lID0gZmFsc2U7CisKKyAgICBpbnQgbnVtYmVyT2ZTb3VyY2VDaGFubmVscyA9IHNvdXJjZUJ1 cy5udW1iZXJPZkNoYW5uZWxzKCk7CisgICAgaW50IG51bWJlck9mRGVzdGluYXRpb25DaGFubmVs cyA9IG51bWJlck9mQ2hhbm5lbHMoKTsKKworICAgIEF1ZGlvQnVzJiBzb3VyY2VCdXNTYWZlID0g Y29uc3RfY2FzdDxBdWRpb0J1cyY+KHNvdXJjZUJ1cyk7CisgICAgY29uc3QgZmxvYXQqIHNvdXJj ZUwgPSBzb3VyY2VCdXNTYWZlLmNoYW5uZWxCeVR5cGUoQ2hhbm5lbExlZnQpLT5kYXRhKCk7Cisg ICAgY29uc3QgZmxvYXQqIHNvdXJjZVIgPSBudW1iZXJPZlNvdXJjZUNoYW5uZWxzID4gMSA/IHNv dXJjZUJ1c1NhZmUuY2hhbm5lbEJ5VHlwZShDaGFubmVsUmlnaHQpLT5kYXRhKCkgOiAwOworCisg ICAgZmxvYXQqIGRlc3RpbmF0aW9uTCA9IGNoYW5uZWxCeVR5cGUoQ2hhbm5lbExlZnQpLT5kYXRh KCk7CisgICAgZmxvYXQqIGRlc3RpbmF0aW9uUiA9IG51bWJlck9mRGVzdGluYXRpb25DaGFubmVs cyA+IDEgPyBjaGFubmVsQnlUeXBlKENoYW5uZWxSaWdodCktPmRhdGEoKSA6IDA7CisKKyAgICBj b25zdCBkb3VibGUgRGV6aXBwZXJSYXRlID0gMC4wMDU7CisgICAgaW50IGZyYW1lc1RvUHJvY2Vz cyA9IGZyYW1lU2l6ZSgpOworCisgICAgaWYgKHN1bVRvQnVzKSB7CisgICAgICAgIC8vIFN1bSB0 byBvdXIgYnVzCisgICAgICAgIGlmIChzb3VyY2VSICYmIGRlc3RpbmF0aW9uUikgeworICAgICAg ICAgICAgLy8gU3RlcmVvCisgICAgICAgICAgICB3aGlsZSAoZnJhbWVzVG9Qcm9jZXNzLS0pIHsK KyAgICAgICAgICAgICAgICBmbG9hdCBzYW1wbGVMID0gKnNvdXJjZUwrKzsKKyAgICAgICAgICAg ICAgICBmbG9hdCBzYW1wbGVSID0gKnNvdXJjZVIrKzsKKyAgICAgICAgICAgICAgICAqZGVzdGlu YXRpb25MKysgKz0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KGdhaW4gKiBzYW1wbGVMKTsKKyAgICAgICAg ICAgICAgICAqZGVzdGluYXRpb25SKysgKz0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KGdhaW4gKiBzYW1w bGVSKTsKKworICAgICAgICAgICAgICAgIC8vIFNsb3dseSBjaGFuZ2UgZ2FpbiB0byBkZXNpcmVk IGdhaW4uCisgICAgICAgICAgICAgICAgZ2FpbiArPSAodG90YWxEZXNpcmVkR2FpbiAtIGdhaW4p ICogRGV6aXBwZXJSYXRlOworICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgaWYgKGRlc3Rp bmF0aW9uUikgeworICAgICAgICAgICAgLy8gTW9ubyAtPiBzdGVyZW8gKG1peCBlcXVhbGx5IGlu dG8gTCBhbmQgUikKKyAgICAgICAgICAgIC8vIEZJWE1FOiBSZWFsbHkgd2Ugc2hvdWxkIGFwcGx5 IGFuIGVxdWFsLXBvd2VyIHNjYWxpbmcgZmFjdG9yIGhlcmUsIHNpbmNlIHdlJ3JlIGVmZmVjdGl2 ZWx5IHBhbm5pbmcgY2VudGVyLi4uCisgICAgICAgICAgICB3aGlsZSAoZnJhbWVzVG9Qcm9jZXNz LS0pIHsKKyAgICAgICAgICAgICAgICBmbG9hdCBzYW1wbGUgPSAqc291cmNlTCsrOworICAgICAg ICAgICAgICAgICpkZXN0aW5hdGlvbkwrKyArPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAqIHNh bXBsZSk7CisgICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uUisrICs9IHN0YXRpY19jYXN0PGZs b2F0PihnYWluICogc2FtcGxlKTsKKworICAgICAgICAgICAgICAgIC8vIFNsb3dseSBjaGFuZ2Ug Z2FpbiB0byBkZXNpcmVkIGdhaW4uCisgICAgICAgICAgICAgICAgZ2FpbiArPSAodG90YWxEZXNp cmVkR2FpbiAtIGdhaW4pICogRGV6aXBwZXJSYXRlOworICAgICAgICAgICAgfQorICAgICAgICB9 IGVsc2UgeworICAgICAgICAgICAgLy8gTW9ubworICAgICAgICAgICAgd2hpbGUgKGZyYW1lc1Rv UHJvY2Vzcy0tKSB7CisgICAgICAgICAgICAgICAgZmxvYXQgc2FtcGxlTCA9ICpzb3VyY2VMKys7 CisgICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uTCsrICs9IHN0YXRpY19jYXN0PGZsb2F0Pihn YWluICogc2FtcGxlTCk7CisKKyAgICAgICAgICAgICAgICAvLyBTbG93bHkgY2hhbmdlIGdhaW4g dG8gZGVzaXJlZCBnYWluLgorICAgICAgICAgICAgICAgIGdhaW4gKz0gKHRvdGFsRGVzaXJlZEdh aW4gLSBnYWluKSAqIERlemlwcGVyUmF0ZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAg IH0gZWxzZSB7CisgICAgICAgIC8vIFByb2Nlc3MgZGlyZWN0bHkgKHdpdGhvdXQgc3VtbWluZykg dG8gb3VyIGJ1cworICAgICAgICBpZiAoc291cmNlUiAmJiBkZXN0aW5hdGlvblIpIHsKKyAgICAg ICAgICAgIC8vIFN0ZXJlbworICAgICAgICAgICAgd2hpbGUgKGZyYW1lc1RvUHJvY2Vzcy0tKSB7 CisgICAgICAgICAgICAgICAgZmxvYXQgc2FtcGxlTCA9ICpzb3VyY2VMKys7CisgICAgICAgICAg ICAgICAgZmxvYXQgc2FtcGxlUiA9ICpzb3VyY2VSKys7CisgICAgICAgICAgICAgICAgKmRlc3Rp bmF0aW9uTCsrID0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KGdhaW4gKiBzYW1wbGVMKTsKKyAgICAgICAg ICAgICAgICAqZGVzdGluYXRpb25SKysgPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAqIHNhbXBs ZVIpOworCisgICAgICAgICAgICAgICAgLy8gU2xvd2x5IGNoYW5nZSBnYWluIHRvIGRlc2lyZWQg Z2Fpbi4KKyAgICAgICAgICAgICAgICBnYWluICs9ICh0b3RhbERlc2lyZWRHYWluIC0gZ2Fpbikg KiBEZXppcHBlclJhdGU7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSBpZiAoZGVzdGlu YXRpb25SKSB7CisgICAgICAgICAgICAvLyBNb25vIC0+IHN0ZXJlbyAobWl4IGVxdWFsbHkgaW50 byBMIGFuZCBSKQorICAgICAgICAgICAgLy8gRklYTUU6IFJlYWxseSB3ZSBzaG91bGQgYXBwbHkg YW4gZXF1YWwtcG93ZXIgc2NhbGluZyBmYWN0b3IgaGVyZSwgc2luY2Ugd2UncmUgZWZmZWN0aXZl bHkgcGFubmluZyBjZW50ZXIuLi4KKyAgICAgICAgICAgIHdoaWxlIChmcmFtZXNUb1Byb2Nlc3Mt LSkgeworICAgICAgICAgICAgICAgIGZsb2F0IHNhbXBsZSA9ICpzb3VyY2VMKys7CisgICAgICAg ICAgICAgICAgKmRlc3RpbmF0aW9uTCsrID0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KGdhaW4gKiBzYW1w bGUpOworICAgICAgICAgICAgICAgICpkZXN0aW5hdGlvblIrKyA9IHN0YXRpY19jYXN0PGZsb2F0 PihnYWluICogc2FtcGxlKTsKKworICAgICAgICAgICAgICAgIC8vIFNsb3dseSBjaGFuZ2UgZ2Fp biB0byBkZXNpcmVkIGdhaW4uCisgICAgICAgICAgICAgICAgZ2FpbiArPSAodG90YWxEZXNpcmVk R2FpbiAtIGdhaW4pICogRGV6aXBwZXJSYXRlOworICAgICAgICAgICAgfQorICAgICAgICB9IGVs c2UgeworICAgICAgICAgICAgLy8gTW9ubworICAgICAgICAgICAgd2hpbGUgKGZyYW1lc1RvUHJv Y2Vzcy0tKSB7CisgICAgICAgICAgICAgICAgZmxvYXQgc2FtcGxlTCA9ICpzb3VyY2VMKys7Cisg ICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uTCsrID0gc3RhdGljX2Nhc3Q8ZmxvYXQ+KGdhaW4g KiBzYW1wbGVMKTsKKworICAgICAgICAgICAgICAgIC8vIFNsb3dseSBjaGFuZ2UgZ2FpbiB0byBk ZXNpcmVkIGdhaW4uCisgICAgICAgICAgICAgICAgZ2FpbiArPSAodG90YWxEZXNpcmVkR2FpbiAt IGdhaW4pICogRGV6aXBwZXJSYXRlOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQor CisgICAgLy8gU2F2ZSB0aGUgdGFyZ2V0IGdhaW4gYXMgdGhlIHN0YXJ0aW5nIHBvaW50IGZvciBu ZXh0IHRpbWUgYXJvdW5kLgorICAgICpsYXN0TWl4R2FpbiA9IGdhaW47Cit9CisKK3ZvaWQgQXVk aW9CdXM6OnByb2Nlc3NXaXRoR2FpbkZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cywgZG91 YmxlKiBsYXN0TWl4R2FpbiwgZG91YmxlIHRhcmdldEdhaW4sIGJvb2wgc3VtVG9CdXMpCit7Cisg ICAgLy8gTWFrZSBzdXJlIHdlJ3JlIHN1bW1pbmcgZnJvbSBzYW1lIHR5cGUgb2YgYnVzLgorICAg IC8vIFdlICphcmUqIGFibGUgdG8gc3VtIGZyb20gbW9ubyAtPiBzdGVyZW8KKyAgICBpZiAoc291 cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMoKSAhPSAxICYmICF0b3BvbG9neU1hdGNoZXMoc291cmNl QnVzKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gRGlzcGF0Y2ggZm9yIGRpZmZlcmVudCBj aGFubmVsIGxheW91dHMKKyAgICBzd2l0Y2ggKG51bWJlck9mQ2hhbm5lbHMoKSkgeworICAgIGNh c2UgMTogLy8gbW9ubworICAgIGNhc2UgMjogLy8gc3RlcmVvCisgICAgICAgIHByb2Nlc3NXaXRo R2FpbkZyb21Nb25vU3RlcmVvKHNvdXJjZUJ1cywgbGFzdE1peEdhaW4sIHRhcmdldEdhaW4sIHN1 bVRvQnVzKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSA0OiAvLyBGSVhNRTogaW1wbGVtZW50 IHF1YWQKKyAgICBjYXNlIDU6IC8vIEZJWE1FOiBpbXBsZW1lbnQgNS4wCisgICAgZGVmYXVsdDoK KyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIGJyZWFrOworICAgIH0KK30K Kwordm9pZCBBdWRpb0J1czo6c3VtV2l0aEdhaW5Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VC dXMsIGRvdWJsZSogbGFzdE1peEdhaW4sIGRvdWJsZSB0YXJnZXRHYWluKQoreworICAgIHByb2Nl c3NXaXRoR2FpbkZyb20oc291cmNlQnVzLCBsYXN0TWl4R2FpbiwgdGFyZ2V0R2FpbiwgdHJ1ZSk7 Cit9CisKK3ZvaWQgQXVkaW9CdXM6OmNvcHlXaXRoR2FpbkZyb20oY29uc3QgQXVkaW9CdXMgJnNv dXJjZUJ1cywgZG91YmxlKiBsYXN0TWl4R2FpbiwgZG91YmxlIHRhcmdldEdhaW4pCit7CisgICAg cHJvY2Vzc1dpdGhHYWluRnJvbShzb3VyY2VCdXMsIGxhc3RNaXhHYWluLCB0YXJnZXRHYWluLCBm YWxzZSk7Cit9CisKK30gLy8gV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFdFQl9BVURJTykK SW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9CdXMuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3Jl L3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjE1IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICog MS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKiAzLiAgTmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBD b21wdXRlciwgSW5jLiAoIkFwcGxlIikgbm9yIHRoZSBuYW1lcyBvZgorICogICAgIGl0cyBjb250 cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2 ZWQKKyAqICAgICBmcm9tIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0 dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJ RUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAq IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2lmbmRlZiBBdWRpb0J1c19oCisjZGVmaW5lIEF1ZGlvQnVzX2gKKworI2luY2x1ZGUgIkF1 ZGlvRmxvYXRBcnJheS5oIgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUg PHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2Ug V2ViQ29yZSB7CisKKy8vIEFuIEF1ZGlvQ2hhbm5lbCByZXByZXNlbnRzIGEgYnVmZmVyIG9mIG5v bi1pbnRlcmxlYXZlZCBmbG9hdGluZy1wb2ludCBhdWRpbyBzYW1wbGVzLgorLy8gVGhlIFBDTSBz YW1wbGVzIGFyZSBub3JtYWxseSBhc3N1bWVkIHRvIGJlIGluIGEgbm9taW5hbCByYW5nZSAtMS4w IC0+ICsxLjAKK2NsYXNzIEF1ZGlvQ2hhbm5lbCA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CitwdWJs aWM6CisgICAgLy8gTWVtb3J5IGNhbiBiZSBleHRlcm5hbGx5IHJlZmVyZW5jZWQsIG9yIGNhbiBi ZSBpbnRlcm5hbGx5IGFsbG9jYXRlZCB3aXRoIGFuIEF1ZGlvRmxvYXRBcnJheS4KKworICAgIC8v IFJlZmVyZW5jZSBhbiBleHRlcm5hbCBidWZmZXIuCisgICAgQXVkaW9DaGFubmVsKGZsb2F0KiBz dG9yYWdlLCBzaXplX3QgZnJhbWVTaXplKQorICAgICAgICA6IG1fZnJhbWVTaXplKGZyYW1lU2l6 ZSksIG1fcmF3UG9pbnRlcihzdG9yYWdlKSwgbV9tZW1CdWZmZXIoMCkgeyB9CisKKyAgICAvLyBN YW5hZ2Ugc3RvcmFnZSBmb3IgdXMuCisgICAgZXhwbGljaXQgQXVkaW9DaGFubmVsKHNpemVfdCBm cmFtZVNpemUpCisgICAgICAgIDogbV9mcmFtZVNpemUoZnJhbWVTaXplKQorICAgICAgICAsIG1f cmF3UG9pbnRlcigwKQorICAgIHsKKyAgICAgICAgbV9tZW1CdWZmZXIgPSBuZXcgQXVkaW9GbG9h dEFycmF5KGZyYW1lU2l6ZSk7CisgICAgfQorCisgICAgLy8gQSAiYmxhbmsiIGF1ZGlvIGNoYW5u ZWwgLS0gbXVzdCBjYWxsIHNldCgpIGJlZm9yZSBpdCdzIHVzZWZ1bC4uLgorICAgIEF1ZGlvQ2hh bm5lbCgpCisgICAgICAgIDogbV9mcmFtZVNpemUoMCkKKyAgICAgICAgLCBtX3Jhd1BvaW50ZXIo MCkKKyAgICAgICAgLCBtX21lbUJ1ZmZlcigwKQorICAgIHsKKyAgICB9CisKKyAgICAvLyBSZWRl ZmluZSB0aGUgbWVtb3J5IGZvciB0aGlzIGNoYW5uZWwuCisgICAgLy8gc3RvcmFnZSByZXByZXNl bnRzIGV4dGVybmFsIG1lbW9yeSBub3QgbWFuYWdlZCBieSB0aGlzIG9iamVjdC4KKyAgICB2b2lk IHNldChmbG9hdCogc3RvcmFnZSwgc2l6ZV90IGZyYW1lU2l6ZSkKKyAgICB7CisgICAgICAgIG1f bWVtQnVmZmVyLmNsZWFyKCk7IC8vIGNsZWFudXAgbWFuYWdlZCBzdG9yYWdlCisgICAgICAgIG1f cmF3UG9pbnRlciA9IHN0b3JhZ2U7CisgICAgICAgIG1fZnJhbWVTaXplID0gZnJhbWVTaXplOwor ICAgIH0KKworICAgIC8vIEhvdyBtYW55IHNhbXBsZS1mcmFtZXMgZG8gd2UgY29udGFpbj8KKyAg ICBzaXplX3QgZnJhbWVTaXplKCkgY29uc3QgeyByZXR1cm4gbV9mcmFtZVNpemU7IH0KKworICAg IC8vIERpcmVjdCBhY2Nlc3MgdG8gUENNIHNhbXBsZSBkYXRhCisgICAgZmxvYXQqIGRhdGEoKSB7 IHJldHVybiBtX3Jhd1BvaW50ZXIgPyBtX3Jhd1BvaW50ZXIgOiBtX21lbUJ1ZmZlci0+ZGF0YSgp OyB9CisgICAgY29uc3QgZmxvYXQqIGNvbnN0RGF0YSgpIGNvbnN0IHsgcmV0dXJuIGNvbnN0X2Nh c3Q8QXVkaW9DaGFubmVsKj4odGhpcyktPmRhdGEoKTsgfQorCisgICAgLy8gWmVyb2VzIG91dCBh bGwgc2FtcGxlIHZhbHVlcyBpbiBidWZmZXIuCisgICAgdm9pZCB6ZXJvKCkKKyAgICB7CisgICAg ICAgIGlmIChtX21lbUJ1ZmZlci5nZXQoKSkKKyAgICAgICAgICAgIG1fbWVtQnVmZmVyLT56ZXJv KCk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIG1lbXNldChtX3Jhd1BvaW50ZXIsIDAsIHNp emVvZihmbG9hdCkgKiBtX2ZyYW1lU2l6ZSk7CisgICAgfQorCisgICAgLy8gU2NhbGVzIGFsbCBz YW1wbGVzIGJ5IHRoZSBzYW1lIGFtb3VudC4KKyAgICB2b2lkIHNjYWxlKGRvdWJsZSBzY2FsZSk7 CisKKyAgICAvLyBBIHNpbXBsZSBtZW1jcHkoKSBmcm9tIHRoZSBzb3VyY2UgY2hhbm5lbAorICAg IHZvaWQgY29weUZyb20oY29uc3QgQXVkaW9DaGFubmVsICZzb3VyY2VDaGFubmVsKTsKKworICAg IC8vIFN1bXMgKHdpdGggdW5pdHkgZ2FpbikgZnJvbSB0aGUgc291cmNlIGNoYW5uZWwuCisgICAg dm9pZCBzdW1Gcm9tKGNvbnN0IEF1ZGlvQ2hhbm5lbCAmc291cmNlQ2hhbm5lbCk7CisKKyAgICAv LyBSZXR1cm5zIG1heGltdW0gYWJzb2x1dGUgdmFsdWUgKHVzZWZ1bCBmb3Igbm9ybWFsaXphdGlv bikuCisgICAgZmxvYXQgbWF4QWJzVmFsdWUoKSBjb25zdDsKKworcHJpdmF0ZToKKyAgICBzaXpl X3QgbV9mcmFtZVNpemU7CisKKyAgICBmbG9hdCogbV9yYXdQb2ludGVyOworICAgIE93blB0cjxB dWRpb0Zsb2F0QXJyYXk+IG1fbWVtQnVmZmVyOworfTsKKworLy8gQW4gQXVkaW9CdXMgcmVwcmVz ZW50cyBhIGNvbGxlY3Rpb24gb2Ygb25lIG9yIG1vcmUgQXVkaW9DaGFubmVscy4KKy8vIFRoZSBk YXRhIGxheW91dCBpcyAicGxhbmFyIiBhcyBvcHBvc2VkIHRvICJpbnRlcmxlYXZlZCIuCisvLyBB biBBdWRpb0J1cyB3aXRoIG9uZSBjaGFubmVsIGlzIG1vbm8sIGFuIEF1ZGlvQnVzIHdpdGggdHdv IGNoYW5uZWxzIGlzIHN0ZXJlbywgZXRjLgorY2xhc3MgQXVkaW9CdXMgIDogcHVibGljIE5vbmNv cHlhYmxlIHsKK3B1YmxpYzoKKyAgICBlbnVtIHsKKyAgICAgICAgQ2hhbm5lbExlZnQgPSAwLAor ICAgICAgICBDaGFubmVsUmlnaHQgPSAxLAorICAgICAgICBDaGFubmVsQ2VudGVyID0gMiwgLy8g Y2VudGVyIGFuZCBtb25vIGFyZSB0aGUgc2FtZQorICAgICAgICBDaGFubmVsTW9ubyA9IDIsCisg ICAgICAgIENoYW5uZWxMRkUgPSAzLAorICAgICAgICBDaGFubmVsU3Vycm91bmRMZWZ0ID0gNCwK KyAgICAgICAgQ2hhbm5lbFN1cnJvdW5kUmlnaHQgPSA1LAorICAgIH07CisKKyAgICBlbnVtIHsK KyAgICAgICAgTGF5b3V0Q2Fub25pY2FsID0gMAorICAgICAgICAvLyBDYW4gZGVmaW5lIG5vbi1z dGFuZGFyZCBsYXlvdXRzIGhlcmUKKyAgICB9OworCisgICAgLy8gYWxsb2NhdGUgaW5kaWNhdGVz IHdoZXRoZXIgb3Igbm90IHRvIGluaXRpYWxseSBoYXZlIHRoZSBBdWRpb0NoYW5uZWxzIGNyZWF0 ZWQgd2l0aCBtYW5hZ2VkIHN0b3JhZ2UuCisgICAgLy8gTm9ybWFsIHVzYWdlIGlzIHRvIHBhc3Mg dHJ1ZSBoZXJlLCBpbiB3aGljaCBjYXNlIHRoZSBBdWRpb0NoYW5uZWxzIHdpbGwgbWVtb3J5LW1h bmFnZSB0aGVpciBvd24gc3RvcmFnZS4KKyAgICAvLyBJZiBhbGxvY2F0ZSBpcyBmYWxzZSB0aGVu IHNldENoYW5uZWxNZW1vcnkoKSBoYXMgdG8gYmUgY2FsbGVkIGxhdGVyIG9uIGZvciBlYWNoIGNo YW5uZWwgYmVmb3JlIHRoZSBBdWRpb0J1cyBpcyB1c2VhYmxlLi4uCisgICAgQXVkaW9CdXModW5z aWduZWQgbnVtYmVyT2ZDaGFubmVscywgc2l6ZV90IGZyYW1lU2l6ZSwgYm9vbCBhbGxvY2F0ZSA9 IHRydWUpOworCisgICAgLy8gVGVsbHMgdGhlIGdpdmVuIGNoYW5uZWwgdG8gdXNlIGFuIGV4dGVy bmFsbHkgYWxsb2NhdGVkIGJ1ZmZlci4KKyAgICB2b2lkIHNldENoYW5uZWxNZW1vcnkodW5zaWdu ZWQgY2hhbm5lbEluZGV4LCBmbG9hdCogc3RvcmFnZSwgc2l6ZV90IGZyYW1lU2l6ZSk7CisKKyAg ICAvLyBDaGFubmVscworICAgIHVuc2lnbmVkIG51bWJlck9mQ2hhbm5lbHMoKSBjb25zdCB7IHJl dHVybiBtX2NoYW5uZWxzLnNpemUoKTsgfQorICAgIEF1ZGlvQ2hhbm5lbCogY2hhbm5lbCh1bnNp Z25lZCBjaGFubmVsKTsKKyAgICBBdWRpb0NoYW5uZWwqIGNoYW5uZWxCeVR5cGUodW5zaWduZWQg dHlwZSk7CisKKyAgICAvLyBOdW1iZXIgb2Ygc2FtcGxlLWZyYW1lcworICAgIHNpemVfdCBmcmFt ZVNpemUoKSBjb25zdCB7IHJldHVybiBtX2ZyYW1lU2l6ZTsgfQorCisgICAgLy8gU2FtcGxlLXJh dGUgOiAwLjAgaWYgdW5rbm93biBvciAiZG9uJ3QgY2FyZSIKKyAgICBkb3VibGUgc2FtcGxlUmF0 ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2FtcGxlUmF0ZTsgfQorICAgIHZvaWQgc2V0U2FtcGxlUmF0 ZShkb3VibGUgc2FtcGxlUmF0ZSkgeyBtX3NhbXBsZVJhdGUgPSBzYW1wbGVSYXRlOyB9CisKKyAg ICAvLyBaZXJvZXMgYWxsIGNoYW5uZWxzLgorICAgIHZvaWQgemVybygpOworCisgICAgLy8gUmV0 dXJucyB0cnVlIGlmIHRoZSBjaGFubmVsIGNvdW50IGFuZCBmcmFtZS1zaXplIG1hdGNoLgorICAg IGJvb2wgdG9wb2xvZ3lNYXRjaGVzKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMpIGNvbnN0Owor CisgICAgLy8gQXNzdW1pbmcgc291cmNlQnVzIGhhcyB0aGUgc2FtZSB0b3BvbG9neSwgY29waWVz IHNhbXBsZSBkYXRhIGZyb20gZWFjaCBjaGFubmVsIG9mIHNvdXJjZUJ1cyB0byBvdXIgY29ycmVz cG9uZGluZyBjaGFubmVsLgorICAgIHZvaWQgY29weUZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJj ZUJ1cyk7CisKKyAgICAvLyBDcmVhdGVzIGEgbmV3IGJ1ZmZlciBmcm9tIGEgcmFuZ2UgaW4gdGhl IHNvdXJjZSBidWZmZXIuCisgICAgLy8gMCBtYXkgYmUgcmV0dXJuZWQgaWYgdGhlIHJhbmdlIGRv ZXMgbm90IGZpdCBpbiB0aGUgc291cmNlQnVmZmVyCisgICAgc3RhdGljIFBhc3NPd25QdHI8QXVk aW9CdXM+IGNyZWF0ZUJ1ZmZlckZyb21SYW5nZShBdWRpb0J1cyogc291cmNlQnVmZmVyLCB1bnNp Z25lZCBzdGFydEZyYW1lLCB1bnNpZ25lZCBlbmRGcmFtZSk7CisKKyAgICAvLyBTY2FsZXMgYWxs IHNhbXBsZXMgYnkgdGhlIHNhbWUgYW1vdW50LgorICAgIHZvaWQgc2NhbGUoZG91YmxlIHNjYWxl KTsKKworICAgIC8vIE1hc3RlciBnYWluIGZvciB0aGlzIGJ1cyAtIHVzZWQgd2l0aCBzdW1XaXRo R2FpbkZyb20oKSBiZWxvdworICAgIHZvaWQgc2V0R2Fpbihkb3VibGUgZ2FpbikgeyBtX2J1c0dh aW4gPSBnYWluOyB9CisgICAgZG91YmxlIGdhaW4oKSB7IHJldHVybiBtX2J1c0dhaW47IH0KKwor ICAgIHZvaWQgcmVzZXQoKSB7IG1faXNGaXJzdFRpbWUgPSB0cnVlOyB9IC8vIGZvciBkZS16aXBw ZXJpbmcKKworICAgIC8vIFN1bXMgdGhlIHNvdXJjZUJ1cyBpbnRvIG91ciBidXMgd2l0aCB1bml0 eSBnYWluLgorICAgIC8vIE91ciBvd24gaW50ZXJuYWwgZ2FpbiBtX2J1c0dhaW4gaXMgaWdub3Jl ZC4KKyAgICB2b2lkIHN1bUZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cyk7CisKKyAgICAv LyBTdW0gb3IgY29weSBlYWNoIGNoYW5uZWwgZnJvbSBzb3VyY2VCdXMgaW50byBvdXIgY29ycmVz cG9uZGluZyBjaGFubmVsLgorICAgIC8vIFdlIHNjYWxlIGJ5IHRhcmdldEdhaW4gKGFuZCBvdXIg b3duIGludGVybmFsIGdhaW4gbV9idXNHYWluKSwgcGVyZm9ybWluZyAiZGUtemlwcGVyaW5nIiB0 byBzbW9vdGhseSBjaGFuZ2UgZnJvbSAqbGFzdE1peEdhaW4gdG8gKHRhcmdldEdhaW4qbV9idXNH YWluKS4KKyAgICAvLyBUaGUgY2FsbGVyIGlzIHJlc3BvbnNpYmxlIGZvciBzZXR0aW5nIHVwIGxh c3RNaXhHYWluIHRvIHBvaW50IHRvIHN0b3JhZ2Ugd2hpY2ggaXMgdW5pcXVlIGZvciBldmVyeSAi c3RyZWFtIiB3aGljaCB3aWxsIGJlIHN1bW1lZCB0byB0aGlzIGJ1cy4KKyAgICAvLyBUaGlzIHJl cHJlc2VudHMgdGhlIGRlemlwcGVyaW5nIG1lbW9yeS4KKyAgICB2b2lkIHN1bVdpdGhHYWluRnJv bShjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzLCBkb3VibGUqIGxhc3RNaXhHYWluLCBkb3VibGUg dGFyZ2V0R2Fpbik7CisgICAgdm9pZCBjb3B5V2l0aEdhaW5Gcm9tKGNvbnN0IEF1ZGlvQnVzICZz b3VyY2VCdXMsIGRvdWJsZSogbGFzdE1peEdhaW4sIGRvdWJsZSB0YXJnZXRHYWluKTsKKworICAg IC8vIFJldHVybnMgbWF4aW11bSBhYnNvbHV0ZSB2YWx1ZSBhY3Jvc3MgYWxsIGNoYW5uZWxzICh1 c2VmdWwgZm9yIG5vcm1hbGl6YXRpb24pLgorICAgIGZsb2F0IG1heEFic1ZhbHVlKCkgY29uc3Q7 CisKKyAgICAvLyBNYWtlcyBtYXhpbXVtIGFic29sdXRlIHZhbHVlID09IDEuMCAoaWYgcG9zc2li bGUpLgorICAgIHZvaWQgbm9ybWFsaXplKCk7CisKK3Byb3RlY3RlZDoKKyAgICBBdWRpb0J1cygp IHsgfTsKKworICAgIHZvaWQgcHJvY2Vzc1dpdGhHYWluRnJvbShjb25zdCBBdWRpb0J1cyAmc291 cmNlQnVzLCBkb3VibGUqIGxhc3RNaXhHYWluLCBkb3VibGUgdGFyZ2V0R2FpbiwgYm9vbCBzdW1U b0J1cyk7CisgICAgdm9pZCBwcm9jZXNzV2l0aEdhaW5Gcm9tTW9ub1N0ZXJlbyhjb25zdCBBdWRp b0J1cyAmc291cmNlQnVzLCBkb3VibGUqIGxhc3RNaXhHYWluLCBkb3VibGUgdGFyZ2V0R2Fpbiwg Ym9vbCBzdW1Ub0J1cyk7CisKKyAgICBzaXplX3QgbV9mcmFtZVNpemU7CisKKyAgICBWZWN0b3I8 T3duUHRyPEF1ZGlvQ2hhbm5lbD4gPiBtX2NoYW5uZWxzOworCisgICAgaW50IG1fbGF5b3V0Owor CisgICAgZG91YmxlIG1fYnVzR2FpbjsKKyAgICBib29sIG1faXNGaXJzdFRpbWU7CisgICAgZG91 YmxlIG1fc2FtcGxlUmF0ZTsgLy8gMC4wIGlmIHVua25vd24gb3IgTi9BCit9OworCisvLyBBYnN0 cmFjdCBiYXNlLWNsYXNzIGZvciBhIHB1bGwtbW9kZWwgY2xpZW50LgorLy8gcHJvdmlkZUlucHV0 KCkgZ2V0cyBjYWxsZWQgcmVwZWF0ZWRseSB0byByZW5kZXIgdGltZS1zbGljZXMgb2YgYSBjb250 aW51b3VzIGF1ZGlvIHN0cmVhbS4KK2NsYXNzIEF1ZGlvU291cmNlUHJvdmlkZXIgeworcHVibGlj OgorICAgIHZpcnR1YWwgdm9pZCBwcm92aWRlSW5wdXQoQXVkaW9CdXMqIGJ1cywgc2l6ZV90IGZy YW1lc1RvUHJvY2VzcykgPSAwOworICAgIHZpcnR1YWwgfkF1ZGlvU291cmNlUHJvdmlkZXIoKSB7 IH0KK307CisKK30gLy8gV2ViQ29yZQorCisjZW5kaWYgLy8gQXVkaW9CdXNfaAo= 65995 2010-08-30 18:42:12 -0700 2010-09-01 12:07:09 -0700 Patch bug-34452-20100830184211.patch text/plain 24210 crogers SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjQ0MykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDEgQEAKKzIwMTAtMDgtMzAgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJ bml0aWFsIHBhdGNoIGZvciBhdWRpbyBlbmdpbmU6IEF1ZGlvQnVzIGFuZCBoZWxwZXIgY2xhc3Nl cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQ0NTIK KworICAgICAgICBObyBuZXcgdGVzdHMgc2luY2UgYXVkaW8gQVBJIGlzIG5vdCB5ZXQgaW1wbGVt ZW50ZWQuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5jcHA6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OkF1ZGlvQnVzKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvQnVzOjpzZXRDaGFubmVsTWVtb3J5KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVz Ojp6ZXJvKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpjaGFubmVsQnlUeXBlKToKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjp0b3BvbG9neU1hdGNoZXMpOgorICAgICAgICAoV2Vi Q29yZTo6QXVkaW9CdXM6OmNyZWF0ZUJ1ZmZlckZyb21SYW5nZSk6CisgICAgICAgIChXZWJDb3Jl OjpBdWRpb0J1czo6bWF4QWJzVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Om5v cm1hbGl6ZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c2NhbGUpOgorICAgICAgICAo V2ViQ29yZTo6QXVkaW9CdXM6OmNvcHlGcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVz OjpzdW1Gcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpwcm9jZXNzV2l0aEdhaW5G cm9tTW9ub1N0ZXJlbyk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6cHJvY2Vzc1dpdGhH YWluRnJvbSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6Y29weVdpdGhHYWluRnJvbSk6 CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c3VtV2l0aEdhaW5Gcm9tKToKKyAgICAgICAg KiBwbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkF1 ZGlvQnVzOjpudW1iZXJPZkNoYW5uZWxzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpj aGFubmVsKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpsZW5ndGgpOgorICAgICAgICAo V2ViQ29yZTo6QXVkaW9CdXM6OnNhbXBsZVJhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9C dXM6OnNldFNhbXBsZVJhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnNldEdhaW4p OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OmdhaW4pOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9CdXM6OnJlc2V0KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpBdWRpb0J1cyk6 CisgICAgICAgICogcGxhdGZvcm0vYXVkaW8vQXVkaW9Tb3VyY2VQcm92aWRlci5oOiBBZGRlZC4K KyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvU291cmNlUHJvdmlkZXI6On5BdWRpb1NvdXJjZVByb3Zp ZGVyKToKKwogMjAxMC0wOC0zMCAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IEVyaWMgU2VpZGVsLgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9h dWRpby9BdWRpb0J1cy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9B dWRpb0J1cy5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlv QnVzLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNjQgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBw bGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNl ZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVU T1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisKKyNpZiBFTkFCTEUoV0VCX0FVRElPKQorCisjaW5jbHVkZSAiQXVkaW9CdXMuaCIKKwor I2luY2x1ZGUgIkFjY2VsZXJhdGUuaCIKKyNpbmNsdWRlIDxhc3NlcnQuaD4KKyNpbmNsdWRlIDxt YXRoLmg+CisjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRy Lmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworQXVkaW9CdXM6OkF1ZGlvQnVzKHVuc2lnbmVk IG51bWJlck9mQ2hhbm5lbHMsIHNpemVfdCBsZW5ndGgsIGJvb2wgYWxsb2NhdGUpCisgICAgOiBt X2xlbmd0aChsZW5ndGgpCisgICAgLCBtX2J1c0dhaW4oMS4wKQorICAgICwgbV9pc0ZpcnN0VGlt ZSh0cnVlKQorICAgICwgbV9zYW1wbGVSYXRlKDAuMCkKK3sKKyAgICBtX2NoYW5uZWxzLnJlc2Vy dmVJbml0aWFsQ2FwYWNpdHkobnVtYmVyT2ZDaGFubmVscyk7CisKKyAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgbnVtYmVyT2ZDaGFubmVsczsgKytpKSB7CisgICAgICAgIFBhc3NPd25QdHI8 QXVkaW9DaGFubmVsPiBjaGFubmVsID0gYWxsb2NhdGUgPyBhZG9wdFB0cihuZXcgQXVkaW9DaGFu bmVsKGxlbmd0aCkpIDogYWRvcHRQdHIobmV3IEF1ZGlvQ2hhbm5lbCgwLCBsZW5ndGgpKTsKKyAg ICAgICAgbV9jaGFubmVscy5hcHBlbmQoY2hhbm5lbCk7CisgICAgfQorCisgICAgbV9sYXlvdXQg PSBMYXlvdXRDYW5vbmljYWw7IC8vIGZvciBub3cgdGhpcyBpcyB0aGUgb25seSBsYXlvdXQgd2Ug ZGVmaW5lCit9CisKK3ZvaWQgQXVkaW9CdXM6OnNldENoYW5uZWxNZW1vcnkodW5zaWduZWQgY2hh bm5lbEluZGV4LCBmbG9hdCogc3RvcmFnZSwgc2l6ZV90IGxlbmd0aCkKK3sKKyAgICBpZiAoY2hh bm5lbEluZGV4IDwgbV9jaGFubmVscy5zaXplKCkpIHsKKyAgICAgICAgY2hhbm5lbChjaGFubmVs SW5kZXgpLT5zZXQoc3RvcmFnZSwgbGVuZ3RoKTsKKyAgICAgICAgbV9sZW5ndGggPSBsZW5ndGg7 CisgICAgfQorfQorCit2b2lkIEF1ZGlvQnVzOjp6ZXJvKCkKK3sKKyAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgbV9jaGFubmVscy5zaXplKCk7ICsraSkKKyAgICAgICAgbV9jaGFubmVsc1tp XS0+emVybygpOworfQorCitBdWRpb0NoYW5uZWwqIEF1ZGlvQnVzOjpjaGFubmVsQnlUeXBlKHVu c2lnbmVkIGNoYW5uZWxUeXBlKQoreworICAgIC8vIEZvciBub3cgd2Ugb25seSBzdXBwb3J0IGNh bm9uaWNhbCBjaGFubmVsIGxheW91dHMuLi4KKyAgICBpZiAobV9sYXlvdXQgIT0gTGF5b3V0Q2Fu b25pY2FsKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHN3aXRjaCAobnVtYmVyT2ZDaGFubmVs cygpKSB7CisgICAgY2FzZSAxOiAvLyBtb25vCisgICAgICAgIGlmIChjaGFubmVsVHlwZSA9PSBD aGFubmVsTW9ubyB8fCBjaGFubmVsVHlwZSA9PSBDaGFubmVsTGVmdCkKKyAgICAgICAgICAgIHJl dHVybiBjaGFubmVsKDApOworICAgICAgICByZXR1cm4gMDsKKworICAgIGNhc2UgMjogLy8gc3Rl cmVvCisgICAgICAgIHN3aXRjaCAoY2hhbm5lbFR5cGUpIHsKKyAgICAgICAgY2FzZSBDaGFubmVs TGVmdDogcmV0dXJuIGNoYW5uZWwoMCk7CisgICAgICAgIGNhc2UgQ2hhbm5lbFJpZ2h0OiByZXR1 cm4gY2hhbm5lbCgxKTsKKyAgICAgICAgZGVmYXVsdDogcmV0dXJuIDA7CisgICAgICAgIH0KKwor ICAgIGNhc2UgNDogLy8gcXVhZAorICAgICAgICBzd2l0Y2ggKGNoYW5uZWxUeXBlKSB7CisgICAg ICAgIGNhc2UgQ2hhbm5lbExlZnQ6IHJldHVybiBjaGFubmVsKDApOworICAgICAgICBjYXNlIENo YW5uZWxSaWdodDogcmV0dXJuIGNoYW5uZWwoMSk7CisgICAgICAgIGNhc2UgQ2hhbm5lbFN1cnJv dW5kTGVmdDogcmV0dXJuIGNoYW5uZWwoMik7CisgICAgICAgIGNhc2UgQ2hhbm5lbFN1cnJvdW5k UmlnaHQ6IHJldHVybiBjaGFubmVsKDMpOworICAgICAgICBkZWZhdWx0OiByZXR1cm4gMDsKKyAg ICAgICAgfQorCisgICAgY2FzZSA1OiAvLyA1LjAKKyAgICAgICAgc3dpdGNoIChjaGFubmVsVHlw ZSkgeworICAgICAgICBjYXNlIENoYW5uZWxMZWZ0OiByZXR1cm4gY2hhbm5lbCgwKTsKKyAgICAg ICAgY2FzZSBDaGFubmVsUmlnaHQ6IHJldHVybiBjaGFubmVsKDEpOworICAgICAgICBjYXNlIENo YW5uZWxDZW50ZXI6IHJldHVybiBjaGFubmVsKDIpOworICAgICAgICBjYXNlIENoYW5uZWxTdXJy b3VuZExlZnQ6IHJldHVybiBjaGFubmVsKDMpOworICAgICAgICBjYXNlIENoYW5uZWxTdXJyb3Vu ZFJpZ2h0OiByZXR1cm4gY2hhbm5lbCg0KTsKKyAgICAgICAgZGVmYXVsdDogcmV0dXJuIDA7Cisg ICAgICAgIH0KKworICAgIGNhc2UgNjogLy8gNS4xCisgICAgICAgIHN3aXRjaCAoY2hhbm5lbFR5 cGUpIHsKKyAgICAgICAgY2FzZSBDaGFubmVsTGVmdDogcmV0dXJuIGNoYW5uZWwoMCk7CisgICAg ICAgIGNhc2UgQ2hhbm5lbFJpZ2h0OiByZXR1cm4gY2hhbm5lbCgxKTsKKyAgICAgICAgY2FzZSBD aGFubmVsQ2VudGVyOiByZXR1cm4gY2hhbm5lbCgyKTsKKyAgICAgICAgY2FzZSBDaGFubmVsTEZF OiByZXR1cm4gY2hhbm5lbCgzKTsKKyAgICAgICAgY2FzZSBDaGFubmVsU3Vycm91bmRMZWZ0OiBy ZXR1cm4gY2hhbm5lbCg0KTsKKyAgICAgICAgY2FzZSBDaGFubmVsU3Vycm91bmRSaWdodDogcmV0 dXJuIGNoYW5uZWwoNSk7CisgICAgICAgIGRlZmF1bHQ6IHJldHVybiAwOworICAgICAgICB9Cisg ICAgfQorICAgIAorICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiAwOworfQor CisvLyBSZXR1cm5zIHRydWUgaWYgdGhlIGNoYW5uZWwgY291bnQgYW5kIGZyYW1lLXNpemUgbWF0 Y2guCitib29sIEF1ZGlvQnVzOjp0b3BvbG9neU1hdGNoZXMoY29uc3QgQXVkaW9CdXMmIGJ1cykg Y29uc3QKK3sKKyAgICBpZiAobnVtYmVyT2ZDaGFubmVscygpICE9IGJ1cy5udW1iZXJPZkNoYW5u ZWxzKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsgLy8gY2hhbm5lbCBtaXNtYXRjaAorCisgICAg Ly8gTWFrZSBzdXJlIHNvdXJjZSBidXMgaGFzIGVub3VnaCBmcmFtZXMuCisgICAgaWYgKGxlbmd0 aCgpID4gYnVzLmxlbmd0aCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7IC8vIGZyYW1lLXNpemUg bWlzbWF0Y2gKKworICAgIHJldHVybiB0cnVlOworfQorCitQYXNzT3duUHRyPEF1ZGlvQnVzPiBB dWRpb0J1czo6Y3JlYXRlQnVmZmVyRnJvbVJhbmdlKEF1ZGlvQnVzKiBzb3VyY2VCdWZmZXIsIHVu c2lnbmVkIHN0YXJ0RnJhbWUsIHVuc2lnbmVkIGVuZEZyYW1lKQoreworICAgIHNpemVfdCBudW1i ZXJPZlNvdXJjZUZyYW1lcyA9IHNvdXJjZUJ1ZmZlci0+bGVuZ3RoKCk7CisgICAgdW5zaWduZWQg bnVtYmVyT2ZDaGFubmVscyA9IHNvdXJjZUJ1ZmZlci0+bnVtYmVyT2ZDaGFubmVscygpOworCisg ICAgLy8gU2FuaXR5IGNoZWNraW5nCisgICAgYm9vbCBpc1JhbmdlU2FmZSA9IHN0YXJ0RnJhbWUg PCBlbmRGcmFtZSAmJiBlbmRGcmFtZSA8PSBudW1iZXJPZlNvdXJjZUZyYW1lczsKKyAgICBBU1NF UlQoaXNSYW5nZVNhZmUpOworICAgIGlmICghaXNSYW5nZVNhZmUpCisgICAgICAgIHJldHVybiAw OworCisgICAgc2l6ZV90IHJhbmdlTGVuZ3RoID0gZW5kRnJhbWUgLSBzdGFydEZyYW1lOworCisg ICAgUGFzc093blB0cjxBdWRpb0J1cz4gYXVkaW9CdXMgPSBhZG9wdFB0cihuZXcgQXVkaW9CdXMo bnVtYmVyT2ZDaGFubmVscywgcmFuZ2VMZW5ndGgpKTsKKyAgICBhdWRpb0J1cy0+c2V0U2FtcGxl UmF0ZShzb3VyY2VCdWZmZXItPnNhbXBsZVJhdGUoKSk7CisKKyAgICBmb3IgKHVuc2lnbmVkIGkg PSAwOyBpIDwgbnVtYmVyT2ZDaGFubmVsczsgKytpKQorICAgICAgICBhdWRpb0J1cy0+Y2hhbm5l bChpKS0+Y29weUZyb21SYW5nZShzb3VyY2VCdWZmZXItPmNoYW5uZWwoaSksIHN0YXJ0RnJhbWUs IGVuZEZyYW1lKTsKKworICAgIHJldHVybiBhdWRpb0J1czsKK30KKworZmxvYXQgQXVkaW9CdXM6 Om1heEFic1ZhbHVlKCkgY29uc3QKK3sKKyAgICBmbG9hdCBtYXggPSAwLjBmOworICAgIGZvciAo dW5zaWduZWQgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5uZWxzKCk7ICsraSkgeworICAgICAgICBB dWRpb0NoYW5uZWwqIGNoYW5uZWwgPSBjb25zdF9jYXN0PEF1ZGlvQnVzKj4odGhpcyktPmNoYW5u ZWwoaSk7CisgICAgICAgIGZsb2F0IGNoYW5uZWxNYXggPSBjaGFubmVsLT5tYXhBYnNWYWx1ZSgp OworICAgICAgICBpZiAoY2hhbm5lbE1heCA+IG1heCkKKyAgICAgICAgICAgIG1heCA9IGNoYW5u ZWxNYXg7CisgICAgfQorCisgICAgcmV0dXJuIG1heDsKK30KKwordm9pZCBBdWRpb0J1czo6bm9y bWFsaXplKCkKK3sKKyAgICBmbG9hdCBtYXggPSBtYXhBYnNWYWx1ZSgpOworICAgIGlmIChtYXgp CisgICAgICAgIHNjYWxlKDEuMGYgLyBtYXgpOworfQorCit2b2lkIEF1ZGlvQnVzOjpzY2FsZShk b3VibGUgc2NhbGUpCit7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG51bWJlck9mQ2hh bm5lbHMoKTsgKytpKQorICAgICAgICBjaGFubmVsKGkpLT5zY2FsZShzY2FsZSk7Cit9CisKKy8v IEp1c3QgY29waWVzIHRoZSBzYW1wbGVzIGZyb20gdGhlIHNvdXJjZSBidXMgdG8gdGhpcyBvbmUu CisvLyBUaGlzIGlzIGp1c3QgYSBzaW1wbGUgY29weSBpZiB0aGUgbnVtYmVyIG9mIGNoYW5uZWxz IG1hdGNoLCBvdGhlcndpc2UgYSBtaXh1cCBvciBtaXhkb3duIGlzIGRvbmUuCisvLyBGb3Igbm93 LCB3ZSBqdXN0IHN1cHBvcnQgYSBtaXh1cCBmcm9tIG1vbm8gLT4gc3RlcmVvLgordm9pZCBBdWRp b0J1czo6Y29weUZyb20oY29uc3QgQXVkaW9CdXMmIHNvdXJjZUJ1cykKK3sKKyAgICBpZiAoJnNv dXJjZUJ1cyA9PSB0aGlzKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAobnVtYmVyT2ZDaGFu bmVscygpID09IHNvdXJjZUJ1cy5udW1iZXJPZkNoYW5uZWxzKCkpIHsKKyAgICAgICAgZm9yICh1 bnNpZ25lZCBpID0gMDsgaSA8IG51bWJlck9mQ2hhbm5lbHMoKTsgKytpKQorICAgICAgICAgICAg Y2hhbm5lbChpKS0+Y29weUZyb20oc291cmNlQnVzLmNoYW5uZWwoaSkpOworICAgIH0gZWxzZSBp ZiAobnVtYmVyT2ZDaGFubmVscygpID09IDIgJiYgc291cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMo KSA9PSAxKSB7CisgICAgICAgIC8vIEhhbmRsZSBtb25vIC0+IHN0ZXJlbyBjYXNlIChmb3Igbm93 IHNpbXBseSBjb3B5IG1vbm8gY2hhbm5lbCBpbnRvIGJvdGggbGVmdCBhbmQgcmlnaHQpCisgICAg ICAgIC8vIEZJWE1FOiBSZWFsbHkgd2Ugc2hvdWxkIGFwcGx5IGFuIGVxdWFsLXBvd2VyIHNjYWxp bmcgZmFjdG9yIGhlcmUsIHNpbmNlIHdlJ3JlIGVmZmVjdGl2ZWx5IHBhbm5pbmcgY2VudGVyLi4u CisgICAgICAgIGNvbnN0IEF1ZGlvQ2hhbm5lbCogc291cmNlQ2hhbm5lbCA9IHNvdXJjZUJ1cy5j aGFubmVsKDApOworICAgICAgICBjaGFubmVsKDApLT5jb3B5RnJvbShzb3VyY2VDaGFubmVsKTsK KyAgICAgICAgY2hhbm5lbCgxKS0+Y29weUZyb20oc291cmNlQ2hhbm5lbCk7CisgICAgfSBlbHNl IHsKKyAgICAgICAgLy8gQ2FzZSBub3QgaGFuZGxlZAorICAgICAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKKyAgICB9Cit9CisKK3ZvaWQgQXVkaW9CdXM6OnN1bUZyb20oY29uc3QgQXVkaW9CdXMg JnNvdXJjZUJ1cykKK3sKKyAgICBpZiAobnVtYmVyT2ZDaGFubmVscygpID09IHNvdXJjZUJ1cy5u dW1iZXJPZkNoYW5uZWxzKCkpIHsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IG51 bWJlck9mQ2hhbm5lbHMoKTsgKytpKQorICAgICAgICAgICAgY2hhbm5lbChpKS0+c3VtRnJvbShz b3VyY2VCdXMuY2hhbm5lbChpKSk7CisgICAgfSBlbHNlIGlmIChudW1iZXJPZkNoYW5uZWxzKCkg PT0gMiAmJiBzb3VyY2VCdXMubnVtYmVyT2ZDaGFubmVscygpID09IDEpIHsKKyAgICAgICAgLy8g SGFuZGxlIG1vbm8gLT4gc3RlcmVvIGNhc2UgKGZvciBub3cgc2ltcGx5IHN1bSBtb25vIGNoYW5u ZWwgaW50byBib3RoIGxlZnQgYW5kIHJpZ2h0KQorICAgICAgICAvLyBGSVhNRTogUmVhbGx5IHdl IHNob3VsZCBhcHBseSBhbiBlcXVhbC1wb3dlciBzY2FsaW5nIGZhY3RvciBoZXJlLCBzaW5jZSB3 ZSdyZSBlZmZlY3RpdmVseSBwYW5uaW5nIGNlbnRlci4uLgorICAgICAgICBjb25zdCBBdWRpb0No YW5uZWwqIHNvdXJjZUNoYW5uZWwgPSBzb3VyY2VCdXMuY2hhbm5lbCgwKTsKKyAgICAgICAgY2hh bm5lbCgwKS0+c3VtRnJvbShzb3VyY2VDaGFubmVsKTsKKyAgICAgICAgY2hhbm5lbCgxKS0+c3Vt RnJvbShzb3VyY2VDaGFubmVsKTsKKyAgICB9IGVsc2UgeworICAgICAgICAvLyBDYXNlIG5vdCBo YW5kbGVkCisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0KK30KKwordm9pZCBB dWRpb0J1czo6cHJvY2Vzc1dpdGhHYWluRnJvbU1vbm9TdGVyZW8oY29uc3QgQXVkaW9CdXMgJnNv dXJjZUJ1cywgZG91YmxlKiBsYXN0TWl4R2FpbiwgZG91YmxlIHRhcmdldEdhaW4sIGJvb2wgc3Vt VG9CdXMpCit7CisgICAgLy8gV2UgZG9uJ3Qgd2FudCB0byBzdWRkZW5seSBjaGFuZ2UgdGhlIGdh aW4gZnJvbSBtaXhpbmcgb25lIHRpbWUgc2xpY2UgdG8gdGhlIG5leHQsCisgICAgLy8gc28gd2Ug ImRlLXppcHBlciIgYnkgc2xvd2x5IGNoYW5naW5nIHRoZSBnYWluIGVhY2ggc2FtcGxlLWZyYW1l IHVudGlsIHdlJ3ZlIGFjaGlldmVkIHRoZSB0YXJnZXQgZ2Fpbi4KKworICAgIC8vIEZJWE1FOiBv cHRpbWl6ZSB0aGlzIG1ldGhvZCAoU1NFLCBldGMuKQorICAgIC8vIEZJWE1FOiBOZWVkIGZhc3Qg cGF0aCBoZXJlIHdoZW4gZ2FpbiBoYXMgY29udmVyZ2VkIG9uIHRhcmdldEdhaW4uIEluIHRoaXMg Y2FzZSwgZGUtemlwcGVyaW5nIGlzIG5vIGxvbmdlciBuZWVkZWQuCisgICAgLy8gRklYTUU6IE5l ZWQgZmFzdCBwYXRoIHdoZW4gdGhpcz09c291cmNlQnVzICYmIGxhc3RNaXhHYWluPT10YXJnZXRH YWluPT0xLjAgJiYgc3VtVG9CdXM9PWZhbHNlICh0aGlzIGlzIGEgTk9QKQorCisgICAgLy8gVGFr ZSBtYXN0ZXIgYnVzIGdhaW4gaW50byBhY2NvdW50IGFzIHdlbGwgYXMgdGhlIHRhcmdldEdhaW4u CisgICAgZG91YmxlIHRvdGFsRGVzaXJlZEdhaW4gPSBtX2J1c0dhaW4gKiB0YXJnZXRHYWluOwor CisgICAgLy8gRmlyc3QgdGltZSwgc25hcCBkaXJlY3RseSB0byB0b3RhbERlc2lyZWRHYWluLgor ICAgIGRvdWJsZSBnYWluID0gbV9pc0ZpcnN0VGltZSA/IHRvdGFsRGVzaXJlZEdhaW4gOiAqbGFz dE1peEdhaW47CisgICAgbV9pc0ZpcnN0VGltZSA9IGZhbHNlOworCisgICAgaW50IG51bWJlck9m U291cmNlQ2hhbm5lbHMgPSBzb3VyY2VCdXMubnVtYmVyT2ZDaGFubmVscygpOworICAgIGludCBu dW1iZXJPZkRlc3RpbmF0aW9uQ2hhbm5lbHMgPSBudW1iZXJPZkNoYW5uZWxzKCk7CisKKyAgICBB dWRpb0J1cyYgc291cmNlQnVzU2FmZSA9IGNvbnN0X2Nhc3Q8QXVkaW9CdXMmPihzb3VyY2VCdXMp OworICAgIGNvbnN0IGZsb2F0KiBzb3VyY2VMID0gc291cmNlQnVzU2FmZS5jaGFubmVsQnlUeXBl KENoYW5uZWxMZWZ0KS0+ZGF0YSgpOworICAgIGNvbnN0IGZsb2F0KiBzb3VyY2VSID0gbnVtYmVy T2ZTb3VyY2VDaGFubmVscyA+IDEgPyBzb3VyY2VCdXNTYWZlLmNoYW5uZWxCeVR5cGUoQ2hhbm5l bFJpZ2h0KS0+ZGF0YSgpIDogMDsKKworICAgIGZsb2F0KiBkZXN0aW5hdGlvbkwgPSBjaGFubmVs QnlUeXBlKENoYW5uZWxMZWZ0KS0+ZGF0YSgpOworICAgIGZsb2F0KiBkZXN0aW5hdGlvblIgPSBu dW1iZXJPZkRlc3RpbmF0aW9uQ2hhbm5lbHMgPiAxID8gY2hhbm5lbEJ5VHlwZShDaGFubmVsUmln aHQpLT5kYXRhKCkgOiAwOworCisgICAgY29uc3QgZG91YmxlIERlemlwcGVyUmF0ZSA9IDAuMDA1 OworICAgIGludCBmcmFtZXNUb1Byb2Nlc3MgPSBsZW5ndGgoKTsKKworICAgIGlmIChzdW1Ub0J1 cykgeworICAgICAgICAvLyBTdW0gdG8gb3VyIGJ1cworICAgICAgICBpZiAoc291cmNlUiAmJiBk ZXN0aW5hdGlvblIpIHsKKyAgICAgICAgICAgIC8vIFN0ZXJlbworICAgICAgICAgICAgd2hpbGUg KGZyYW1lc1RvUHJvY2Vzcy0tKSB7CisgICAgICAgICAgICAgICAgZmxvYXQgc2FtcGxlTCA9ICpz b3VyY2VMKys7CisgICAgICAgICAgICAgICAgZmxvYXQgc2FtcGxlUiA9ICpzb3VyY2VSKys7Cisg ICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uTCsrICs9IHN0YXRpY19jYXN0PGZsb2F0PihnYWlu ICogc2FtcGxlTCk7CisgICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uUisrICs9IHN0YXRpY19j YXN0PGZsb2F0PihnYWluICogc2FtcGxlUik7CisKKyAgICAgICAgICAgICAgICAvLyBTbG93bHkg Y2hhbmdlIGdhaW4gdG8gZGVzaXJlZCBnYWluLgorICAgICAgICAgICAgICAgIGdhaW4gKz0gKHRv dGFsRGVzaXJlZEdhaW4gLSBnYWluKSAqIERlemlwcGVyUmF0ZTsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgfSBlbHNlIGlmIChkZXN0aW5hdGlvblIpIHsKKyAgICAgICAgICAgIC8vIE1vbm8gLT4g c3RlcmVvIChtaXggZXF1YWxseSBpbnRvIEwgYW5kIFIpCisgICAgICAgICAgICAvLyBGSVhNRTog UmVhbGx5IHdlIHNob3VsZCBhcHBseSBhbiBlcXVhbC1wb3dlciBzY2FsaW5nIGZhY3RvciBoZXJl LCBzaW5jZSB3ZSdyZSBlZmZlY3RpdmVseSBwYW5uaW5nIGNlbnRlci4uLgorICAgICAgICAgICAg d2hpbGUgKGZyYW1lc1RvUHJvY2Vzcy0tKSB7CisgICAgICAgICAgICAgICAgZmxvYXQgc2FtcGxl ID0gKnNvdXJjZUwrKzsKKyAgICAgICAgICAgICAgICAqZGVzdGluYXRpb25MKysgKz0gc3RhdGlj X2Nhc3Q8ZmxvYXQ+KGdhaW4gKiBzYW1wbGUpOworICAgICAgICAgICAgICAgICpkZXN0aW5hdGlv blIrKyArPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAqIHNhbXBsZSk7CisKKyAgICAgICAgICAg ICAgICAvLyBTbG93bHkgY2hhbmdlIGdhaW4gdG8gZGVzaXJlZCBnYWluLgorICAgICAgICAgICAg ICAgIGdhaW4gKz0gKHRvdGFsRGVzaXJlZEdhaW4gLSBnYWluKSAqIERlemlwcGVyUmF0ZTsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIE1vbm8KKyAgICAg ICAgICAgIHdoaWxlIChmcmFtZXNUb1Byb2Nlc3MtLSkgeworICAgICAgICAgICAgICAgIGZsb2F0 IHNhbXBsZUwgPSAqc291cmNlTCsrOworICAgICAgICAgICAgICAgICpkZXN0aW5hdGlvbkwrKyAr PSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAqIHNhbXBsZUwpOworCisgICAgICAgICAgICAgICAg Ly8gU2xvd2x5IGNoYW5nZSBnYWluIHRvIGRlc2lyZWQgZ2Fpbi4KKyAgICAgICAgICAgICAgICBn YWluICs9ICh0b3RhbERlc2lyZWRHYWluIC0gZ2FpbikgKiBEZXppcHBlclJhdGU7CisgICAgICAg ICAgICB9CisgICAgICAgIH0KKyAgICB9IGVsc2UgeworICAgICAgICAvLyBQcm9jZXNzIGRpcmVj dGx5ICh3aXRob3V0IHN1bW1pbmcpIHRvIG91ciBidXMKKyAgICAgICAgaWYgKHNvdXJjZVIgJiYg ZGVzdGluYXRpb25SKSB7CisgICAgICAgICAgICAvLyBTdGVyZW8KKyAgICAgICAgICAgIHdoaWxl IChmcmFtZXNUb1Byb2Nlc3MtLSkgeworICAgICAgICAgICAgICAgIGZsb2F0IHNhbXBsZUwgPSAq c291cmNlTCsrOworICAgICAgICAgICAgICAgIGZsb2F0IHNhbXBsZVIgPSAqc291cmNlUisrOwor ICAgICAgICAgICAgICAgICpkZXN0aW5hdGlvbkwrKyA9IHN0YXRpY19jYXN0PGZsb2F0PihnYWlu ICogc2FtcGxlTCk7CisgICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uUisrID0gc3RhdGljX2Nh c3Q8ZmxvYXQ+KGdhaW4gKiBzYW1wbGVSKTsKKworICAgICAgICAgICAgICAgIC8vIFNsb3dseSBj aGFuZ2UgZ2FpbiB0byBkZXNpcmVkIGdhaW4uCisgICAgICAgICAgICAgICAgZ2FpbiArPSAodG90 YWxEZXNpcmVkR2FpbiAtIGdhaW4pICogRGV6aXBwZXJSYXRlOworICAgICAgICAgICAgfQorICAg ICAgICB9IGVsc2UgaWYgKGRlc3RpbmF0aW9uUikgeworICAgICAgICAgICAgLy8gTW9ubyAtPiBz dGVyZW8gKG1peCBlcXVhbGx5IGludG8gTCBhbmQgUikKKyAgICAgICAgICAgIC8vIEZJWE1FOiBS ZWFsbHkgd2Ugc2hvdWxkIGFwcGx5IGFuIGVxdWFsLXBvd2VyIHNjYWxpbmcgZmFjdG9yIGhlcmUs IHNpbmNlIHdlJ3JlIGVmZmVjdGl2ZWx5IHBhbm5pbmcgY2VudGVyLi4uCisgICAgICAgICAgICB3 aGlsZSAoZnJhbWVzVG9Qcm9jZXNzLS0pIHsKKyAgICAgICAgICAgICAgICBmbG9hdCBzYW1wbGUg PSAqc291cmNlTCsrOworICAgICAgICAgICAgICAgICpkZXN0aW5hdGlvbkwrKyA9IHN0YXRpY19j YXN0PGZsb2F0PihnYWluICogc2FtcGxlKTsKKyAgICAgICAgICAgICAgICAqZGVzdGluYXRpb25S KysgPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAqIHNhbXBsZSk7CisKKyAgICAgICAgICAgICAg ICAvLyBTbG93bHkgY2hhbmdlIGdhaW4gdG8gZGVzaXJlZCBnYWluLgorICAgICAgICAgICAgICAg IGdhaW4gKz0gKHRvdGFsRGVzaXJlZEdhaW4gLSBnYWluKSAqIERlemlwcGVyUmF0ZTsKKyAgICAg ICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIE1vbm8KKyAgICAgICAg ICAgIHdoaWxlIChmcmFtZXNUb1Byb2Nlc3MtLSkgeworICAgICAgICAgICAgICAgIGZsb2F0IHNh bXBsZUwgPSAqc291cmNlTCsrOworICAgICAgICAgICAgICAgICpkZXN0aW5hdGlvbkwrKyA9IHN0 YXRpY19jYXN0PGZsb2F0PihnYWluICogc2FtcGxlTCk7CisKKyAgICAgICAgICAgICAgICAvLyBT bG93bHkgY2hhbmdlIGdhaW4gdG8gZGVzaXJlZCBnYWluLgorICAgICAgICAgICAgICAgIGdhaW4g Kz0gKHRvdGFsRGVzaXJlZEdhaW4gLSBnYWluKSAqIERlemlwcGVyUmF0ZTsKKyAgICAgICAgICAg IH0KKyAgICAgICAgfQorICAgIH0KKworICAgIC8vIFNhdmUgdGhlIHRhcmdldCBnYWluIGFzIHRo ZSBzdGFydGluZyBwb2ludCBmb3IgbmV4dCB0aW1lIGFyb3VuZC4KKyAgICAqbGFzdE1peEdhaW4g PSBnYWluOworfQorCit2b2lkIEF1ZGlvQnVzOjpwcm9jZXNzV2l0aEdhaW5Gcm9tKGNvbnN0IEF1 ZGlvQnVzICZzb3VyY2VCdXMsIGRvdWJsZSogbGFzdE1peEdhaW4sIGRvdWJsZSB0YXJnZXRHYWlu LCBib29sIHN1bVRvQnVzKQoreworICAgIC8vIE1ha2Ugc3VyZSB3ZSdyZSBzdW1taW5nIGZyb20g c2FtZSB0eXBlIG9mIGJ1cy4KKyAgICAvLyBXZSAqYXJlKiBhYmxlIHRvIHN1bSBmcm9tIG1vbm8g LT4gc3RlcmVvCisgICAgaWYgKHNvdXJjZUJ1cy5udW1iZXJPZkNoYW5uZWxzKCkgIT0gMSAmJiAh dG9wb2xvZ3lNYXRjaGVzKHNvdXJjZUJ1cykpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIERp c3BhdGNoIGZvciBkaWZmZXJlbnQgY2hhbm5lbCBsYXlvdXRzCisgICAgc3dpdGNoIChudW1iZXJP ZkNoYW5uZWxzKCkpIHsKKyAgICBjYXNlIDE6IC8vIG1vbm8KKyAgICBjYXNlIDI6IC8vIHN0ZXJl bworICAgICAgICBwcm9jZXNzV2l0aEdhaW5Gcm9tTW9ub1N0ZXJlbyhzb3VyY2VCdXMsIGxhc3RN aXhHYWluLCB0YXJnZXRHYWluLCBzdW1Ub0J1cyk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2Ug NDogLy8gRklYTUU6IGltcGxlbWVudCBxdWFkCisgICAgY2FzZSA1OiAvLyBGSVhNRTogaW1wbGVt ZW50IDUuMAorICAgIGRlZmF1bHQ6CisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg ICAgICBicmVhazsKKyAgICB9Cit9CisKK3ZvaWQgQXVkaW9CdXM6OmNvcHlXaXRoR2FpbkZyb20o Y29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cywgZG91YmxlKiBsYXN0TWl4R2FpbiwgZG91YmxlIHRh cmdldEdhaW4pCit7CisgICAgcHJvY2Vzc1dpdGhHYWluRnJvbShzb3VyY2VCdXMsIGxhc3RNaXhH YWluLCB0YXJnZXRHYWluLCBmYWxzZSk7Cit9CisKK3ZvaWQgQXVkaW9CdXM6OnN1bVdpdGhHYWlu RnJvbShjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzLCBkb3VibGUqIGxhc3RNaXhHYWluLCBkb3Vi bGUgdGFyZ2V0R2FpbikKK3sKKyAgICBwcm9jZXNzV2l0aEdhaW5Gcm9tKHNvdXJjZUJ1cywgbGFz dE1peEdhaW4sIHRhcmdldEdhaW4sIHRydWUpOworfQorCit9IC8vIFdlYkNvcmUKKworI2VuZGlm IC8vIEVOQUJMRShXRUJfQVVESU8pCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlv QnVzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5oCShy ZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5oCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDEzOSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRo ZXIgdGhlIG5hbWUgb2YgQXBwbGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFt ZXMgb2YKKyAqICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3Ig cHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQg QU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICog TE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF IE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQXVkaW9CdXNfaAorI2RlZmluZSBBdWRp b0J1c19oCisKKyNpbmNsdWRlICJBdWRpb0NoYW5uZWwuaCIKKyNpbmNsdWRlIDx3dGYvTm9uY29w eWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBBbiBBdWRpb0J1cyByZXByZXNlbnRz IGEgY29sbGVjdGlvbiBvZiBvbmUgb3IgbW9yZSBBdWRpb0NoYW5uZWxzLgorLy8gVGhlIGRhdGEg bGF5b3V0IGlzICJwbGFuYXIiIGFzIG9wcG9zZWQgdG8gImludGVybGVhdmVkIi4KKy8vIEFuIEF1 ZGlvQnVzIHdpdGggb25lIGNoYW5uZWwgaXMgbW9ubywgYW4gQXVkaW9CdXMgd2l0aCB0d28gY2hh bm5lbHMgaXMgc3RlcmVvLCBldGMuCitjbGFzcyBBdWRpb0J1cyAgOiBwdWJsaWMgTm9uY29weWFi bGUgeworcHVibGljOgorICAgIGVudW0geworICAgICAgICBDaGFubmVsTGVmdCA9IDAsCisgICAg ICAgIENoYW5uZWxSaWdodCA9IDEsCisgICAgICAgIENoYW5uZWxDZW50ZXIgPSAyLCAvLyBjZW50 ZXIgYW5kIG1vbm8gYXJlIHRoZSBzYW1lCisgICAgICAgIENoYW5uZWxNb25vID0gMiwKKyAgICAg ICAgQ2hhbm5lbExGRSA9IDMsCisgICAgICAgIENoYW5uZWxTdXJyb3VuZExlZnQgPSA0LAorICAg ICAgICBDaGFubmVsU3Vycm91bmRSaWdodCA9IDUsCisgICAgfTsKKworICAgIGVudW0geworICAg ICAgICBMYXlvdXRDYW5vbmljYWwgPSAwCisgICAgICAgIC8vIENhbiBkZWZpbmUgbm9uLXN0YW5k YXJkIGxheW91dHMgaGVyZQorICAgIH07CisKKyAgICAvLyBhbGxvY2F0ZSBpbmRpY2F0ZXMgd2hl dGhlciBvciBub3QgdG8gaW5pdGlhbGx5IGhhdmUgdGhlIEF1ZGlvQ2hhbm5lbHMgY3JlYXRlZCB3 aXRoIG1hbmFnZWQgc3RvcmFnZS4KKyAgICAvLyBOb3JtYWwgdXNhZ2UgaXMgdG8gcGFzcyB0cnVl IGhlcmUsIGluIHdoaWNoIGNhc2UgdGhlIEF1ZGlvQ2hhbm5lbHMgd2lsbCBtZW1vcnktbWFuYWdl IHRoZWlyIG93biBzdG9yYWdlLgorICAgIC8vIElmIGFsbG9jYXRlIGlzIGZhbHNlIHRoZW4gc2V0 Q2hhbm5lbE1lbW9yeSgpIGhhcyB0byBiZSBjYWxsZWQgbGF0ZXIgb24gZm9yIGVhY2ggY2hhbm5l bCBiZWZvcmUgdGhlIEF1ZGlvQnVzIGlzIHVzZWFibGUuLi4KKyAgICBBdWRpb0J1cyh1bnNpZ25l ZCBudW1iZXJPZkNoYW5uZWxzLCBzaXplX3QgbGVuZ3RoLCBib29sIGFsbG9jYXRlID0gdHJ1ZSk7 CisKKyAgICAvLyBUZWxscyB0aGUgZ2l2ZW4gY2hhbm5lbCB0byB1c2UgYW4gZXh0ZXJuYWxseSBh bGxvY2F0ZWQgYnVmZmVyLgorICAgIHZvaWQgc2V0Q2hhbm5lbE1lbW9yeSh1bnNpZ25lZCBjaGFu bmVsSW5kZXgsIGZsb2F0KiBzdG9yYWdlLCBzaXplX3QgbGVuZ3RoKTsKKworICAgIC8vIENoYW5u ZWxzCisgICAgdW5zaWduZWQgbnVtYmVyT2ZDaGFubmVscygpIGNvbnN0IHsgcmV0dXJuIG1fY2hh bm5lbHMuc2l6ZSgpOyB9CisKKyAgICBBdWRpb0NoYW5uZWwqIGNoYW5uZWwodW5zaWduZWQgY2hh bm5lbCkgeyByZXR1cm4gbV9jaGFubmVsc1tjaGFubmVsXS5nZXQoKTsgfQorICAgIGNvbnN0IEF1 ZGlvQ2hhbm5lbCogY2hhbm5lbCh1bnNpZ25lZCBjaGFubmVsKSBjb25zdCB7IHJldHVybiBjb25z dF9jYXN0PEF1ZGlvQnVzKj4odGhpcyktPm1fY2hhbm5lbHNbY2hhbm5lbF0uZ2V0KCk7IH0KKyAg ICBBdWRpb0NoYW5uZWwqIGNoYW5uZWxCeVR5cGUodW5zaWduZWQgdHlwZSk7CisKKyAgICAvLyBO dW1iZXIgb2Ygc2FtcGxlLWZyYW1lcworICAgIHNpemVfdCBsZW5ndGgoKSBjb25zdCB7IHJldHVy biBtX2xlbmd0aDsgfQorCisgICAgLy8gU2FtcGxlLXJhdGUgOiAwLjAgaWYgdW5rbm93biBvciAi ZG9uJ3QgY2FyZSIKKyAgICBkb3VibGUgc2FtcGxlUmF0ZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2Ft cGxlUmF0ZTsgfQorICAgIHZvaWQgc2V0U2FtcGxlUmF0ZShkb3VibGUgc2FtcGxlUmF0ZSkgeyBt X3NhbXBsZVJhdGUgPSBzYW1wbGVSYXRlOyB9CisKKyAgICAvLyBaZXJvZXMgYWxsIGNoYW5uZWxz LgorICAgIHZvaWQgemVybygpOworCisgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRoZSBjaGFubmVs IGNvdW50IGFuZCBmcmFtZS1zaXplIG1hdGNoLgorICAgIGJvb2wgdG9wb2xvZ3lNYXRjaGVzKGNv bnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMpIGNvbnN0OworCisgICAgLy8gQ3JlYXRlcyBhIG5ldyBi dWZmZXIgZnJvbSBhIHJhbmdlIGluIHRoZSBzb3VyY2UgYnVmZmVyLgorICAgIC8vIDAgbWF5IGJl IHJldHVybmVkIGlmIHRoZSByYW5nZSBkb2VzIG5vdCBmaXQgaW4gdGhlIHNvdXJjZUJ1ZmZlcgor ICAgIHN0YXRpYyBQYXNzT3duUHRyPEF1ZGlvQnVzPiBjcmVhdGVCdWZmZXJGcm9tUmFuZ2UoQXVk aW9CdXMqIHNvdXJjZUJ1ZmZlciwgdW5zaWduZWQgc3RhcnRGcmFtZSwgdW5zaWduZWQgZW5kRnJh bWUpOworCisgICAgLy8gU2NhbGVzIGFsbCBzYW1wbGVzIGJ5IHRoZSBzYW1lIGFtb3VudC4KKyAg ICB2b2lkIHNjYWxlKGRvdWJsZSBzY2FsZSk7CisKKyAgICAvLyBNYXN0ZXIgZ2FpbiBmb3IgdGhp cyBidXMgLSB1c2VkIHdpdGggc3VtV2l0aEdhaW5Gcm9tKCkgYmVsb3cKKyAgICB2b2lkIHNldEdh aW4oZG91YmxlIGdhaW4pIHsgbV9idXNHYWluID0gZ2FpbjsgfQorICAgIGRvdWJsZSBnYWluKCkg eyByZXR1cm4gbV9idXNHYWluOyB9CisKKyAgICB2b2lkIHJlc2V0KCkgeyBtX2lzRmlyc3RUaW1l ID0gdHJ1ZTsgfSAvLyBmb3IgZGUtemlwcGVyaW5nCisKKyAgICAvLyBBc3N1bWluZyBzb3VyY2VC dXMgaGFzIHRoZSBzYW1lIHRvcG9sb2d5LCBjb3BpZXMgc2FtcGxlIGRhdGEgZnJvbSBlYWNoIGNo YW5uZWwgb2Ygc291cmNlQnVzIHRvIG91ciBjb3JyZXNwb25kaW5nIGNoYW5uZWwuCisgICAgdm9p ZCBjb3B5RnJvbShjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzKTsKKworICAgIC8vIFN1bXMgdGhl IHNvdXJjZUJ1cyBpbnRvIG91ciBidXMgd2l0aCB1bml0eSBnYWluLgorICAgIC8vIE91ciBvd24g aW50ZXJuYWwgZ2FpbiBtX2J1c0dhaW4gaXMgaWdub3JlZC4KKyAgICB2b2lkIHN1bUZyb20oY29u c3QgQXVkaW9CdXMgJnNvdXJjZUJ1cyk7CisKKyAgICAvLyBDb3B5IG9yIHN1bSBlYWNoIGNoYW5u ZWwgZnJvbSBzb3VyY2VCdXMgaW50byBvdXIgY29ycmVzcG9uZGluZyBjaGFubmVsLgorICAgIC8v IFdlIHNjYWxlIGJ5IHRhcmdldEdhaW4gKGFuZCBvdXIgb3duIGludGVybmFsIGdhaW4gbV9idXNH YWluKSwgcGVyZm9ybWluZyAiZGUtemlwcGVyaW5nIiB0byBzbW9vdGhseSBjaGFuZ2UgZnJvbSAq bGFzdE1peEdhaW4gdG8gKHRhcmdldEdhaW4qbV9idXNHYWluKS4KKyAgICAvLyBUaGUgY2FsbGVy IGlzIHJlc3BvbnNpYmxlIGZvciBzZXR0aW5nIHVwIGxhc3RNaXhHYWluIHRvIHBvaW50IHRvIHN0 b3JhZ2Ugd2hpY2ggaXMgdW5pcXVlIGZvciBldmVyeSAic3RyZWFtIiB3aGljaCB3aWxsIGJlIHN1 bW1lZCB0byB0aGlzIGJ1cy4KKyAgICAvLyBUaGlzIHJlcHJlc2VudHMgdGhlIGRlemlwcGVyaW5n IG1lbW9yeS4KKyAgICB2b2lkIGNvcHlXaXRoR2FpbkZyb20oY29uc3QgQXVkaW9CdXMgJnNvdXJj ZUJ1cywgZG91YmxlKiBsYXN0TWl4R2FpbiwgZG91YmxlIHRhcmdldEdhaW4pOworICAgIHZvaWQg c3VtV2l0aEdhaW5Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMsIGRvdWJsZSogbGFzdE1p eEdhaW4sIGRvdWJsZSB0YXJnZXRHYWluKTsKKworICAgIC8vIFJldHVybnMgbWF4aW11bSBhYnNv bHV0ZSB2YWx1ZSBhY3Jvc3MgYWxsIGNoYW5uZWxzICh1c2VmdWwgZm9yIG5vcm1hbGl6YXRpb24p LgorICAgIGZsb2F0IG1heEFic1ZhbHVlKCkgY29uc3Q7CisKKyAgICAvLyBNYWtlcyBtYXhpbXVt IGFic29sdXRlIHZhbHVlID09IDEuMCAoaWYgcG9zc2libGUpLgorICAgIHZvaWQgbm9ybWFsaXpl KCk7CisKK3Byb3RlY3RlZDoKKyAgICBBdWRpb0J1cygpIHsgfTsKKworICAgIHZvaWQgcHJvY2Vz c1dpdGhHYWluRnJvbShjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzLCBkb3VibGUqIGxhc3RNaXhH YWluLCBkb3VibGUgdGFyZ2V0R2FpbiwgYm9vbCBzdW1Ub0J1cyk7CisgICAgdm9pZCBwcm9jZXNz V2l0aEdhaW5Gcm9tTW9ub1N0ZXJlbyhjb25zdCBBdWRpb0J1cyAmc291cmNlQnVzLCBkb3VibGUq IGxhc3RNaXhHYWluLCBkb3VibGUgdGFyZ2V0R2FpbiwgYm9vbCBzdW1Ub0J1cyk7CisKKyAgICBz aXplX3QgbV9sZW5ndGg7CisKKyAgICBWZWN0b3I8T3duUHRyPEF1ZGlvQ2hhbm5lbD4gPiBtX2No YW5uZWxzOworCisgICAgaW50IG1fbGF5b3V0OworCisgICAgZG91YmxlIG1fYnVzR2FpbjsKKyAg ICBib29sIG1faXNGaXJzdFRpbWU7CisgICAgZG91YmxlIG1fc2FtcGxlUmF0ZTsgLy8gMC4wIGlm IHVua25vd24gb3IgTi9BCit9OworCit9IC8vIFdlYkNvcmUKKworI2VuZGlmIC8vIEF1ZGlvQnVz X2gKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9Tb3VyY2VQcm92aWRlci5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9Tb3VyY2VQcm92aWRlci5o CShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BdWRpb1NvdXJjZVByb3Zp ZGVyLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUi KSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0 byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JT ICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQor ICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIEF1ZGlvU291cmNl UHJvdmlkZXJfaAorI2RlZmluZSBBdWRpb1NvdXJjZVByb3ZpZGVyX2gKKworbmFtZXNwYWNlIFdl YkNvcmUgeworCitjbGFzcyBBdWRpb0J1czsKKyAgICAKKy8vIEFic3RyYWN0IGJhc2UtY2xhc3Mg Zm9yIGEgcHVsbC1tb2RlbCBjbGllbnQuCisvLyBwcm92aWRlSW5wdXQoKSBnZXRzIGNhbGxlZCBy ZXBlYXRlZGx5IHRvIHJlbmRlciB0aW1lLXNsaWNlcyBvZiBhIGNvbnRpbnVvdXMgYXVkaW8gc3Ry ZWFtLgorY2xhc3MgQXVkaW9Tb3VyY2VQcm92aWRlciB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2 b2lkIHByb3ZpZGVJbnB1dChBdWRpb0J1cyogYnVzLCBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKSA9 IDA7CisgICAgdmlydHVhbCB+QXVkaW9Tb3VyY2VQcm92aWRlcigpIHsgfQorfTsKKworfSAvLyBX ZWJDb3JlCisKKyNlbmRpZiAvLyBBdWRpb1NvdXJjZVByb3ZpZGVyX2gK 66242 2010-09-01 12:07:13 -0700 2010-09-03 12:10:24 -0700 Patch bug-34452-20100901120712.patch text/plain 24250 crogers SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjYxMikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDEgQEAKKzIwMTAtMDktMDEgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJ bml0aWFsIHBhdGNoIGZvciBhdWRpbyBlbmdpbmU6IEF1ZGlvQnVzIGFuZCBoZWxwZXIgY2xhc3Nl cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQ0NTIK KworICAgICAgICBObyBuZXcgdGVzdHMgc2luY2UgYXVkaW8gQVBJIGlzIG5vdCB5ZXQgaW1wbGVt ZW50ZWQuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5jcHA6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OkF1ZGlvQnVzKToKKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvQnVzOjpzZXRDaGFubmVsTWVtb3J5KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVz Ojp6ZXJvKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpjaGFubmVsQnlUeXBlKToKKyAg ICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjp0b3BvbG9neU1hdGNoZXMpOgorICAgICAgICAoV2Vi Q29yZTo6QXVkaW9CdXM6OmNyZWF0ZUJ1ZmZlckZyb21SYW5nZSk6CisgICAgICAgIChXZWJDb3Jl OjpBdWRpb0J1czo6bWF4QWJzVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6Om5v cm1hbGl6ZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c2NhbGUpOgorICAgICAgICAo V2ViQ29yZTo6QXVkaW9CdXM6OmNvcHlGcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVz OjpzdW1Gcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpwcm9jZXNzV2l0aEdhaW5G cm9tTW9ub1N0ZXJlbyk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6cHJvY2Vzc1dpdGhH YWluRnJvbSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6Y29weVdpdGhHYWluRnJvbSk6 CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0J1czo6c3VtV2l0aEdhaW5Gcm9tKToKKyAgICAgICAg KiBwbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkF1 ZGlvQnVzOjpudW1iZXJPZkNoYW5uZWxzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpj aGFubmVsKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpsZW5ndGgpOgorICAgICAgICAo V2ViQ29yZTo6QXVkaW9CdXM6OnNhbXBsZVJhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9C dXM6OnNldFNhbXBsZVJhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OnNldEdhaW4p OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9CdXM6OmdhaW4pOgorICAgICAgICAoV2ViQ29yZTo6 QXVkaW9CdXM6OnJlc2V0KToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvQnVzOjpBdWRpb0J1cyk6 CisgICAgICAgICogcGxhdGZvcm0vYXVkaW8vQXVkaW9Tb3VyY2VQcm92aWRlci5oOiBBZGRlZC4K KyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvU291cmNlUHJvdmlkZXI6On5BdWRpb1NvdXJjZVByb3Zp ZGVyKToKKwogMjAxMC0wOS0wMSAgRGF2ZSBIeWF0dCAgPGh5YXR0QGFwcGxlLmNvbT4KIAogICAg ICAgICBSZXZpZXdlZCBieSBEYW4gQmVybnN0ZWluIGFuZCBTaW1vbiBGcmFzZXIuCkluZGV4OiBX ZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BsYXRmb3JtL2F1ZGlvL0F1ZGlvQnVzLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxh dGZvcm0vYXVkaW8vQXVkaW9CdXMuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM2MyBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEu ICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhlIG5hbWUgb2YgQXBwbGUgQ29t cHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAqICAgICBpdHMgY29udHJp YnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVk CisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRl biBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUg QU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE CisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBT VUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBS T0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBP TiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkg QVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisK KyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIEVOQUJMRShXRUJfQVVESU8pCisKKyNpbmNsdWRl ICJBdWRpb0J1cy5oIgorCisjaW5jbHVkZSAiQWNjZWxlcmF0ZS5oIgorI2luY2x1ZGUgPGFsZ29y aXRobT4KKyNpbmNsdWRlIDxhc3NlcnQuaD4KKyNpbmNsdWRlIDxtYXRoLmg+CisjaW5jbHVkZSA8 d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworQXVkaW9CdXM6OkF1ZGlvQnVzKHVuc2lnbmVkIG51bWJlck9mQ2hhbm5lbHMs IHNpemVfdCBsZW5ndGgsIGJvb2wgYWxsb2NhdGUpCisgICAgOiBtX2xlbmd0aChsZW5ndGgpCisg ICAgLCBtX2J1c0dhaW4oMS4wKQorICAgICwgbV9pc0ZpcnN0VGltZSh0cnVlKQorICAgICwgbV9z YW1wbGVSYXRlKDAuMCkKK3sKKyAgICBtX2NoYW5uZWxzLnJlc2VydmVJbml0aWFsQ2FwYWNpdHko bnVtYmVyT2ZDaGFubmVscyk7CisKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbnVtYmVy T2ZDaGFubmVsczsgKytpKSB7CisgICAgICAgIFBhc3NPd25QdHI8QXVkaW9DaGFubmVsPiBjaGFu bmVsID0gYWxsb2NhdGUgPyBhZG9wdFB0cihuZXcgQXVkaW9DaGFubmVsKGxlbmd0aCkpIDogYWRv cHRQdHIobmV3IEF1ZGlvQ2hhbm5lbCgwLCBsZW5ndGgpKTsKKyAgICAgICAgbV9jaGFubmVscy5h cHBlbmQoY2hhbm5lbCk7CisgICAgfQorCisgICAgbV9sYXlvdXQgPSBMYXlvdXRDYW5vbmljYWw7 IC8vIGZvciBub3cgdGhpcyBpcyB0aGUgb25seSBsYXlvdXQgd2UgZGVmaW5lCit9CisKK3ZvaWQg QXVkaW9CdXM6OnNldENoYW5uZWxNZW1vcnkodW5zaWduZWQgY2hhbm5lbEluZGV4LCBmbG9hdCog c3RvcmFnZSwgc2l6ZV90IGxlbmd0aCkKK3sKKyAgICBpZiAoY2hhbm5lbEluZGV4IDwgbV9jaGFu bmVscy5zaXplKCkpIHsKKyAgICAgICAgY2hhbm5lbChjaGFubmVsSW5kZXgpLT5zZXQoc3RvcmFn ZSwgbGVuZ3RoKTsKKyAgICAgICAgbV9sZW5ndGggPSBsZW5ndGg7IC8vIEZJWE1FOiB2ZXJpZnkg dGhhdCB0aGlzIGxlbmd0aCBtYXRjaGVzIGFsbCB0aGUgb3RoZXIgY2hhbm5lbCBsZW5ndGhzCisg ICAgfQorfQorCit2b2lkIEF1ZGlvQnVzOjp6ZXJvKCkKK3sKKyAgICBmb3IgKHVuc2lnbmVkIGkg PSAwOyBpIDwgbV9jaGFubmVscy5zaXplKCk7ICsraSkKKyAgICAgICAgbV9jaGFubmVsc1tpXS0+ emVybygpOworfQorCitBdWRpb0NoYW5uZWwqIEF1ZGlvQnVzOjpjaGFubmVsQnlUeXBlKHVuc2ln bmVkIGNoYW5uZWxUeXBlKQoreworICAgIC8vIEZvciBub3cgd2Ugb25seSBzdXBwb3J0IGNhbm9u aWNhbCBjaGFubmVsIGxheW91dHMuLi4KKyAgICBpZiAobV9sYXlvdXQgIT0gTGF5b3V0Q2Fub25p Y2FsKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHN3aXRjaCAobnVtYmVyT2ZDaGFubmVscygp KSB7CisgICAgY2FzZSAxOiAvLyBtb25vCisgICAgICAgIGlmIChjaGFubmVsVHlwZSA9PSBDaGFu bmVsTW9ubyB8fCBjaGFubmVsVHlwZSA9PSBDaGFubmVsTGVmdCkKKyAgICAgICAgICAgIHJldHVy biBjaGFubmVsKDApOworICAgICAgICByZXR1cm4gMDsKKworICAgIGNhc2UgMjogLy8gc3RlcmVv CisgICAgICAgIHN3aXRjaCAoY2hhbm5lbFR5cGUpIHsKKyAgICAgICAgY2FzZSBDaGFubmVsTGVm dDogcmV0dXJuIGNoYW5uZWwoMCk7CisgICAgICAgIGNhc2UgQ2hhbm5lbFJpZ2h0OiByZXR1cm4g Y2hhbm5lbCgxKTsKKyAgICAgICAgZGVmYXVsdDogcmV0dXJuIDA7CisgICAgICAgIH0KKworICAg IGNhc2UgNDogLy8gcXVhZAorICAgICAgICBzd2l0Y2ggKGNoYW5uZWxUeXBlKSB7CisgICAgICAg IGNhc2UgQ2hhbm5lbExlZnQ6IHJldHVybiBjaGFubmVsKDApOworICAgICAgICBjYXNlIENoYW5u ZWxSaWdodDogcmV0dXJuIGNoYW5uZWwoMSk7CisgICAgICAgIGNhc2UgQ2hhbm5lbFN1cnJvdW5k TGVmdDogcmV0dXJuIGNoYW5uZWwoMik7CisgICAgICAgIGNhc2UgQ2hhbm5lbFN1cnJvdW5kUmln aHQ6IHJldHVybiBjaGFubmVsKDMpOworICAgICAgICBkZWZhdWx0OiByZXR1cm4gMDsKKyAgICAg ICAgfQorCisgICAgY2FzZSA1OiAvLyA1LjAKKyAgICAgICAgc3dpdGNoIChjaGFubmVsVHlwZSkg eworICAgICAgICBjYXNlIENoYW5uZWxMZWZ0OiByZXR1cm4gY2hhbm5lbCgwKTsKKyAgICAgICAg Y2FzZSBDaGFubmVsUmlnaHQ6IHJldHVybiBjaGFubmVsKDEpOworICAgICAgICBjYXNlIENoYW5u ZWxDZW50ZXI6IHJldHVybiBjaGFubmVsKDIpOworICAgICAgICBjYXNlIENoYW5uZWxTdXJyb3Vu ZExlZnQ6IHJldHVybiBjaGFubmVsKDMpOworICAgICAgICBjYXNlIENoYW5uZWxTdXJyb3VuZFJp Z2h0OiByZXR1cm4gY2hhbm5lbCg0KTsKKyAgICAgICAgZGVmYXVsdDogcmV0dXJuIDA7CisgICAg ICAgIH0KKworICAgIGNhc2UgNjogLy8gNS4xCisgICAgICAgIHN3aXRjaCAoY2hhbm5lbFR5cGUp IHsKKyAgICAgICAgY2FzZSBDaGFubmVsTGVmdDogcmV0dXJuIGNoYW5uZWwoMCk7CisgICAgICAg IGNhc2UgQ2hhbm5lbFJpZ2h0OiByZXR1cm4gY2hhbm5lbCgxKTsKKyAgICAgICAgY2FzZSBDaGFu bmVsQ2VudGVyOiByZXR1cm4gY2hhbm5lbCgyKTsKKyAgICAgICAgY2FzZSBDaGFubmVsTEZFOiBy ZXR1cm4gY2hhbm5lbCgzKTsKKyAgICAgICAgY2FzZSBDaGFubmVsU3Vycm91bmRMZWZ0OiByZXR1 cm4gY2hhbm5lbCg0KTsKKyAgICAgICAgY2FzZSBDaGFubmVsU3Vycm91bmRSaWdodDogcmV0dXJu IGNoYW5uZWwoNSk7CisgICAgICAgIGRlZmF1bHQ6IHJldHVybiAwOworICAgICAgICB9CisgICAg fQorICAgIAorICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiAwOworfQorCisv LyBSZXR1cm5zIHRydWUgaWYgdGhlIGNoYW5uZWwgY291bnQgYW5kIGZyYW1lLXNpemUgbWF0Y2gu Citib29sIEF1ZGlvQnVzOjp0b3BvbG9neU1hdGNoZXMoY29uc3QgQXVkaW9CdXMmIGJ1cykgY29u c3QKK3sKKyAgICBpZiAobnVtYmVyT2ZDaGFubmVscygpICE9IGJ1cy5udW1iZXJPZkNoYW5uZWxz KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsgLy8gY2hhbm5lbCBtaXNtYXRjaAorCisgICAgLy8g TWFrZSBzdXJlIHNvdXJjZSBidXMgaGFzIGVub3VnaCBmcmFtZXMuCisgICAgaWYgKGxlbmd0aCgp ID4gYnVzLmxlbmd0aCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7IC8vIGZyYW1lLXNpemUgbWlz bWF0Y2gKKworICAgIHJldHVybiB0cnVlOworfQorCitQYXNzT3duUHRyPEF1ZGlvQnVzPiBBdWRp b0J1czo6Y3JlYXRlQnVmZmVyRnJvbVJhbmdlKEF1ZGlvQnVzKiBzb3VyY2VCdWZmZXIsIHVuc2ln bmVkIHN0YXJ0RnJhbWUsIHVuc2lnbmVkIGVuZEZyYW1lKQoreworICAgIHNpemVfdCBudW1iZXJP ZlNvdXJjZUZyYW1lcyA9IHNvdXJjZUJ1ZmZlci0+bGVuZ3RoKCk7CisgICAgdW5zaWduZWQgbnVt YmVyT2ZDaGFubmVscyA9IHNvdXJjZUJ1ZmZlci0+bnVtYmVyT2ZDaGFubmVscygpOworCisgICAg Ly8gU2FuaXR5IGNoZWNraW5nCisgICAgYm9vbCBpc1JhbmdlU2FmZSA9IHN0YXJ0RnJhbWUgPCBl bmRGcmFtZSAmJiBlbmRGcmFtZSA8PSBudW1iZXJPZlNvdXJjZUZyYW1lczsKKyAgICBBU1NFUlQo aXNSYW5nZVNhZmUpOworICAgIGlmICghaXNSYW5nZVNhZmUpCisgICAgICAgIHJldHVybiAwOwor CisgICAgc2l6ZV90IHJhbmdlTGVuZ3RoID0gZW5kRnJhbWUgLSBzdGFydEZyYW1lOworCisgICAg T3duUHRyPEF1ZGlvQnVzPiBhdWRpb0J1cyA9IGFkb3B0UHRyKG5ldyBBdWRpb0J1cyhudW1iZXJP ZkNoYW5uZWxzLCByYW5nZUxlbmd0aCkpOworICAgIGF1ZGlvQnVzLT5zZXRTYW1wbGVSYXRlKHNv dXJjZUJ1ZmZlci0+c2FtcGxlUmF0ZSgpKTsKKworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkg PCBudW1iZXJPZkNoYW5uZWxzOyArK2kpCisgICAgICAgIGF1ZGlvQnVzLT5jaGFubmVsKGkpLT5j b3B5RnJvbVJhbmdlKHNvdXJjZUJ1ZmZlci0+Y2hhbm5lbChpKSwgc3RhcnRGcmFtZSwgZW5kRnJh bWUpOworCisgICAgcmV0dXJuIGF1ZGlvQnVzLnJlbGVhc2UoKTsKK30KKworZmxvYXQgQXVkaW9C dXM6Om1heEFic1ZhbHVlKCkgY29uc3QKK3sKKyAgICBmbG9hdCBtYXggPSAwLjBmOworICAgIGZv ciAodW5zaWduZWQgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5uZWxzKCk7ICsraSkgeworICAgICAg ICBjb25zdCBBdWRpb0NoYW5uZWwqIGNoYW5uZWwgPSB0aGlzLT5jaGFubmVsKGkpOworICAgICAg ICBtYXggPSBzdGQ6Om1heChtYXgsIGNoYW5uZWwtPm1heEFic1ZhbHVlKCkpOworICAgIH0KKwor ICAgIHJldHVybiBtYXg7Cit9CisKK3ZvaWQgQXVkaW9CdXM6Om5vcm1hbGl6ZSgpCit7CisgICAg ZmxvYXQgbWF4ID0gbWF4QWJzVmFsdWUoKTsKKyAgICBpZiAobWF4KQorICAgICAgICBzY2FsZSgx LjBmIC8gbWF4KTsKK30KKwordm9pZCBBdWRpb0J1czo6c2NhbGUoZG91YmxlIHNjYWxlKQorewor ICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5uZWxzKCk7ICsraSkKKyAg ICAgICAgY2hhbm5lbChpKS0+c2NhbGUoc2NhbGUpOworfQorCisvLyBKdXN0IGNvcGllcyB0aGUg c2FtcGxlcyBmcm9tIHRoZSBzb3VyY2UgYnVzIHRvIHRoaXMgb25lLgorLy8gVGhpcyBpcyBqdXN0 IGEgc2ltcGxlIGNvcHkgaWYgdGhlIG51bWJlciBvZiBjaGFubmVscyBtYXRjaCwgb3RoZXJ3aXNl IGEgbWl4dXAgb3IgbWl4ZG93biBpcyBkb25lLgorLy8gRm9yIG5vdywgd2UganVzdCBzdXBwb3J0 IGEgbWl4dXAgZnJvbSBtb25vIC0+IHN0ZXJlby4KK3ZvaWQgQXVkaW9CdXM6OmNvcHlGcm9tKGNv bnN0IEF1ZGlvQnVzJiBzb3VyY2VCdXMpCit7CisgICAgaWYgKCZzb3VyY2VCdXMgPT0gdGhpcykK KyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKG51bWJlck9mQ2hhbm5lbHMoKSA9PSBzb3VyY2VC dXMubnVtYmVyT2ZDaGFubmVscygpKSB7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkg PCBudW1iZXJPZkNoYW5uZWxzKCk7ICsraSkKKyAgICAgICAgICAgIGNoYW5uZWwoaSktPmNvcHlG cm9tKHNvdXJjZUJ1cy5jaGFubmVsKGkpKTsKKyAgICB9IGVsc2UgaWYgKG51bWJlck9mQ2hhbm5l bHMoKSA9PSAyICYmIHNvdXJjZUJ1cy5udW1iZXJPZkNoYW5uZWxzKCkgPT0gMSkgeworICAgICAg ICAvLyBIYW5kbGUgbW9ubyAtPiBzdGVyZW8gY2FzZSAoZm9yIG5vdyBzaW1wbHkgY29weSBtb25v IGNoYW5uZWwgaW50byBib3RoIGxlZnQgYW5kIHJpZ2h0KQorICAgICAgICAvLyBGSVhNRTogUmVh bGx5IHdlIHNob3VsZCBhcHBseSBhbiBlcXVhbC1wb3dlciBzY2FsaW5nIGZhY3RvciBoZXJlLCBz aW5jZSB3ZSdyZSBlZmZlY3RpdmVseSBwYW5uaW5nIGNlbnRlci4uLgorICAgICAgICBjb25zdCBB dWRpb0NoYW5uZWwqIHNvdXJjZUNoYW5uZWwgPSBzb3VyY2VCdXMuY2hhbm5lbCgwKTsKKyAgICAg ICAgY2hhbm5lbCgwKS0+Y29weUZyb20oc291cmNlQ2hhbm5lbCk7CisgICAgICAgIGNoYW5uZWwo MSktPmNvcHlGcm9tKHNvdXJjZUNoYW5uZWwpOworICAgIH0gZWxzZSB7CisgICAgICAgIC8vIENh c2Ugbm90IGhhbmRsZWQKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorfQor Cit2b2lkIEF1ZGlvQnVzOjpzdW1Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMpCit7Cisg ICAgaWYgKG51bWJlck9mQ2hhbm5lbHMoKSA9PSBzb3VyY2VCdXMubnVtYmVyT2ZDaGFubmVscygp KSB7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5uZWxzKCk7 ICsraSkKKyAgICAgICAgICAgIGNoYW5uZWwoaSktPnN1bUZyb20oc291cmNlQnVzLmNoYW5uZWwo aSkpOworICAgIH0gZWxzZSBpZiAobnVtYmVyT2ZDaGFubmVscygpID09IDIgJiYgc291cmNlQnVz Lm51bWJlck9mQ2hhbm5lbHMoKSA9PSAxKSB7CisgICAgICAgIC8vIEhhbmRsZSBtb25vIC0+IHN0 ZXJlbyBjYXNlIChmb3Igbm93IHNpbXBseSBzdW0gbW9ubyBjaGFubmVsIGludG8gYm90aCBsZWZ0 IGFuZCByaWdodCkKKyAgICAgICAgLy8gRklYTUU6IFJlYWxseSB3ZSBzaG91bGQgYXBwbHkgYW4g ZXF1YWwtcG93ZXIgc2NhbGluZyBmYWN0b3IgaGVyZSwgc2luY2Ugd2UncmUgZWZmZWN0aXZlbHkg cGFubmluZyBjZW50ZXIuLi4KKyAgICAgICAgY29uc3QgQXVkaW9DaGFubmVsKiBzb3VyY2VDaGFu bmVsID0gc291cmNlQnVzLmNoYW5uZWwoMCk7CisgICAgICAgIGNoYW5uZWwoMCktPnN1bUZyb20o c291cmNlQ2hhbm5lbCk7CisgICAgICAgIGNoYW5uZWwoMSktPnN1bUZyb20oc291cmNlQ2hhbm5l bCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gQ2FzZSBub3QgaGFuZGxlZAorICAgICAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9Cit9CisKK3ZvaWQgQXVkaW9CdXM6OnByb2Nlc3NX aXRoR2FpbkZyb21Nb25vU3RlcmVvKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMsIGRvdWJsZSog bGFzdE1peEdhaW4sIGRvdWJsZSB0YXJnZXRHYWluLCBib29sIHN1bVRvQnVzKQoreworICAgIC8v IFdlIGRvbid0IHdhbnQgdG8gc3VkZGVubHkgY2hhbmdlIHRoZSBnYWluIGZyb20gbWl4aW5nIG9u ZSB0aW1lIHNsaWNlIHRvIHRoZSBuZXh0LAorICAgIC8vIHNvIHdlICJkZS16aXBwZXIiIGJ5IHNs b3dseSBjaGFuZ2luZyB0aGUgZ2FpbiBlYWNoIHNhbXBsZS1mcmFtZSB1bnRpbCB3ZSd2ZSBhY2hp ZXZlZCB0aGUgdGFyZ2V0IGdhaW4uCisKKyAgICAvLyBGSVhNRTogb3B0aW1pemUgdGhpcyBtZXRo b2QgKFNTRSwgZXRjLikKKyAgICAvLyBGSVhNRTogTmVlZCBmYXN0IHBhdGggaGVyZSB3aGVuIGdh aW4gaGFzIGNvbnZlcmdlZCBvbiB0YXJnZXRHYWluLiBJbiB0aGlzIGNhc2UsIGRlLXppcHBlcmlu ZyBpcyBubyBsb25nZXIgbmVlZGVkLgorICAgIC8vIEZJWE1FOiBOZWVkIGZhc3QgcGF0aCB3aGVu IHRoaXM9PXNvdXJjZUJ1cyAmJiBsYXN0TWl4R2Fpbj09dGFyZ2V0R2Fpbj09MS4wICYmIHN1bVRv QnVzPT1mYWxzZSAodGhpcyBpcyBhIE5PUCkKKworICAgIC8vIFRha2UgbWFzdGVyIGJ1cyBnYWlu IGludG8gYWNjb3VudCBhcyB3ZWxsIGFzIHRoZSB0YXJnZXRHYWluLgorICAgIGRvdWJsZSB0b3Rh bERlc2lyZWRHYWluID0gbV9idXNHYWluICogdGFyZ2V0R2FpbjsKKworICAgIC8vIEZpcnN0IHRp bWUsIHNuYXAgZGlyZWN0bHkgdG8gdG90YWxEZXNpcmVkR2Fpbi4KKyAgICBkb3VibGUgZ2FpbiA9 IG1faXNGaXJzdFRpbWUgPyB0b3RhbERlc2lyZWRHYWluIDogKmxhc3RNaXhHYWluOworICAgIG1f aXNGaXJzdFRpbWUgPSBmYWxzZTsKKworICAgIGludCBudW1iZXJPZlNvdXJjZUNoYW5uZWxzID0g c291cmNlQnVzLm51bWJlck9mQ2hhbm5lbHMoKTsKKyAgICBpbnQgbnVtYmVyT2ZEZXN0aW5hdGlv bkNoYW5uZWxzID0gbnVtYmVyT2ZDaGFubmVscygpOworCisgICAgQXVkaW9CdXMmIHNvdXJjZUJ1 c1NhZmUgPSBjb25zdF9jYXN0PEF1ZGlvQnVzJj4oc291cmNlQnVzKTsKKyAgICBjb25zdCBmbG9h dCogc291cmNlTCA9IHNvdXJjZUJ1c1NhZmUuY2hhbm5lbEJ5VHlwZShDaGFubmVsTGVmdCktPmRh dGEoKTsKKyAgICBjb25zdCBmbG9hdCogc291cmNlUiA9IG51bWJlck9mU291cmNlQ2hhbm5lbHMg PiAxID8gc291cmNlQnVzU2FmZS5jaGFubmVsQnlUeXBlKENoYW5uZWxSaWdodCktPmRhdGEoKSA6 IDA7CisKKyAgICBmbG9hdCogZGVzdGluYXRpb25MID0gY2hhbm5lbEJ5VHlwZShDaGFubmVsTGVm dCktPmRhdGEoKTsKKyAgICBmbG9hdCogZGVzdGluYXRpb25SID0gbnVtYmVyT2ZEZXN0aW5hdGlv bkNoYW5uZWxzID4gMSA/IGNoYW5uZWxCeVR5cGUoQ2hhbm5lbFJpZ2h0KS0+ZGF0YSgpIDogMDsK KworICAgIGNvbnN0IGRvdWJsZSBEZXppcHBlclJhdGUgPSAwLjAwNTsKKyAgICBpbnQgZnJhbWVz VG9Qcm9jZXNzID0gbGVuZ3RoKCk7CisKKyAgICBpZiAoc3VtVG9CdXMpIHsKKyAgICAgICAgLy8g U3VtIHRvIG91ciBidXMKKyAgICAgICAgaWYgKHNvdXJjZVIgJiYgZGVzdGluYXRpb25SKSB7Cisg ICAgICAgICAgICAvLyBTdGVyZW8KKyAgICAgICAgICAgIHdoaWxlIChmcmFtZXNUb1Byb2Nlc3Mt LSkgeworICAgICAgICAgICAgICAgIGZsb2F0IHNhbXBsZUwgPSAqc291cmNlTCsrOworICAgICAg ICAgICAgICAgIGZsb2F0IHNhbXBsZVIgPSAqc291cmNlUisrOworICAgICAgICAgICAgICAgICpk ZXN0aW5hdGlvbkwrKyArPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAqIHNhbXBsZUwpOworICAg ICAgICAgICAgICAgICpkZXN0aW5hdGlvblIrKyArPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAq IHNhbXBsZVIpOworCisgICAgICAgICAgICAgICAgLy8gU2xvd2x5IGNoYW5nZSBnYWluIHRvIGRl c2lyZWQgZ2Fpbi4KKyAgICAgICAgICAgICAgICBnYWluICs9ICh0b3RhbERlc2lyZWRHYWluIC0g Z2FpbikgKiBEZXppcHBlclJhdGU7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSBpZiAo ZGVzdGluYXRpb25SKSB7CisgICAgICAgICAgICAvLyBNb25vIC0+IHN0ZXJlbyAobWl4IGVxdWFs bHkgaW50byBMIGFuZCBSKQorICAgICAgICAgICAgLy8gRklYTUU6IFJlYWxseSB3ZSBzaG91bGQg YXBwbHkgYW4gZXF1YWwtcG93ZXIgc2NhbGluZyBmYWN0b3IgaGVyZSwgc2luY2Ugd2UncmUgZWZm ZWN0aXZlbHkgcGFubmluZyBjZW50ZXIuLi4KKyAgICAgICAgICAgIHdoaWxlIChmcmFtZXNUb1By b2Nlc3MtLSkgeworICAgICAgICAgICAgICAgIGZsb2F0IHNhbXBsZSA9ICpzb3VyY2VMKys7Cisg ICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uTCsrICs9IHN0YXRpY19jYXN0PGZsb2F0PihnYWlu ICogc2FtcGxlKTsKKyAgICAgICAgICAgICAgICAqZGVzdGluYXRpb25SKysgKz0gc3RhdGljX2Nh c3Q8ZmxvYXQ+KGdhaW4gKiBzYW1wbGUpOworCisgICAgICAgICAgICAgICAgLy8gU2xvd2x5IGNo YW5nZSBnYWluIHRvIGRlc2lyZWQgZ2Fpbi4KKyAgICAgICAgICAgICAgICBnYWluICs9ICh0b3Rh bERlc2lyZWRHYWluIC0gZ2FpbikgKiBEZXppcHBlclJhdGU7CisgICAgICAgICAgICB9CisgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICAvLyBNb25vCisgICAgICAgICAgICB3aGlsZSAoZnJh bWVzVG9Qcm9jZXNzLS0pIHsKKyAgICAgICAgICAgICAgICBmbG9hdCBzYW1wbGVMID0gKnNvdXJj ZUwrKzsKKyAgICAgICAgICAgICAgICAqZGVzdGluYXRpb25MKysgKz0gc3RhdGljX2Nhc3Q8Zmxv YXQ+KGdhaW4gKiBzYW1wbGVMKTsKKworICAgICAgICAgICAgICAgIC8vIFNsb3dseSBjaGFuZ2Ug Z2FpbiB0byBkZXNpcmVkIGdhaW4uCisgICAgICAgICAgICAgICAgZ2FpbiArPSAodG90YWxEZXNp cmVkR2FpbiAtIGdhaW4pICogRGV6aXBwZXJSYXRlOworICAgICAgICAgICAgfQorICAgICAgICB9 CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gUHJvY2VzcyBkaXJlY3RseSAod2l0aG91dCBzdW1t aW5nKSB0byBvdXIgYnVzCisgICAgICAgIGlmIChzb3VyY2VSICYmIGRlc3RpbmF0aW9uUikgewor ICAgICAgICAgICAgLy8gU3RlcmVvCisgICAgICAgICAgICB3aGlsZSAoZnJhbWVzVG9Qcm9jZXNz LS0pIHsKKyAgICAgICAgICAgICAgICBmbG9hdCBzYW1wbGVMID0gKnNvdXJjZUwrKzsKKyAgICAg ICAgICAgICAgICBmbG9hdCBzYW1wbGVSID0gKnNvdXJjZVIrKzsKKyAgICAgICAgICAgICAgICAq ZGVzdGluYXRpb25MKysgPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAqIHNhbXBsZUwpOworICAg ICAgICAgICAgICAgICpkZXN0aW5hdGlvblIrKyA9IHN0YXRpY19jYXN0PGZsb2F0PihnYWluICog c2FtcGxlUik7CisKKyAgICAgICAgICAgICAgICAvLyBTbG93bHkgY2hhbmdlIGdhaW4gdG8gZGVz aXJlZCBnYWluLgorICAgICAgICAgICAgICAgIGdhaW4gKz0gKHRvdGFsRGVzaXJlZEdhaW4gLSBn YWluKSAqIERlemlwcGVyUmF0ZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIGlmIChk ZXN0aW5hdGlvblIpIHsKKyAgICAgICAgICAgIC8vIE1vbm8gLT4gc3RlcmVvIChtaXggZXF1YWxs eSBpbnRvIEwgYW5kIFIpCisgICAgICAgICAgICAvLyBGSVhNRTogUmVhbGx5IHdlIHNob3VsZCBh cHBseSBhbiBlcXVhbC1wb3dlciBzY2FsaW5nIGZhY3RvciBoZXJlLCBzaW5jZSB3ZSdyZSBlZmZl Y3RpdmVseSBwYW5uaW5nIGNlbnRlci4uLgorICAgICAgICAgICAgd2hpbGUgKGZyYW1lc1RvUHJv Y2Vzcy0tKSB7CisgICAgICAgICAgICAgICAgZmxvYXQgc2FtcGxlID0gKnNvdXJjZUwrKzsKKyAg ICAgICAgICAgICAgICAqZGVzdGluYXRpb25MKysgPSBzdGF0aWNfY2FzdDxmbG9hdD4oZ2FpbiAq IHNhbXBsZSk7CisgICAgICAgICAgICAgICAgKmRlc3RpbmF0aW9uUisrID0gc3RhdGljX2Nhc3Q8 ZmxvYXQ+KGdhaW4gKiBzYW1wbGUpOworCisgICAgICAgICAgICAgICAgLy8gU2xvd2x5IGNoYW5n ZSBnYWluIHRvIGRlc2lyZWQgZ2Fpbi4KKyAgICAgICAgICAgICAgICBnYWluICs9ICh0b3RhbERl c2lyZWRHYWluIC0gZ2FpbikgKiBEZXppcHBlclJhdGU7CisgICAgICAgICAgICB9CisgICAgICAg IH0gZWxzZSB7CisgICAgICAgICAgICAvLyBNb25vCisgICAgICAgICAgICB3aGlsZSAoZnJhbWVz VG9Qcm9jZXNzLS0pIHsKKyAgICAgICAgICAgICAgICBmbG9hdCBzYW1wbGVMID0gKnNvdXJjZUwr KzsKKyAgICAgICAgICAgICAgICAqZGVzdGluYXRpb25MKysgPSBzdGF0aWNfY2FzdDxmbG9hdD4o Z2FpbiAqIHNhbXBsZUwpOworCisgICAgICAgICAgICAgICAgLy8gU2xvd2x5IGNoYW5nZSBnYWlu IHRvIGRlc2lyZWQgZ2Fpbi4KKyAgICAgICAgICAgICAgICBnYWluICs9ICh0b3RhbERlc2lyZWRH YWluIC0gZ2FpbikgKiBEZXppcHBlclJhdGU7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAg ICB9CisKKyAgICAvLyBTYXZlIHRoZSB0YXJnZXQgZ2FpbiBhcyB0aGUgc3RhcnRpbmcgcG9pbnQg Zm9yIG5leHQgdGltZSBhcm91bmQuCisgICAgKmxhc3RNaXhHYWluID0gZ2FpbjsKK30KKwordm9p ZCBBdWRpb0J1czo6cHJvY2Vzc1dpdGhHYWluRnJvbShjb25zdCBBdWRpb0J1cyAmc291cmNlQnVz LCBkb3VibGUqIGxhc3RNaXhHYWluLCBkb3VibGUgdGFyZ2V0R2FpbiwgYm9vbCBzdW1Ub0J1cykK K3sKKyAgICAvLyBNYWtlIHN1cmUgd2UncmUgc3VtbWluZyBmcm9tIHNhbWUgdHlwZSBvZiBidXMu CisgICAgLy8gV2UgKmFyZSogYWJsZSB0byBzdW0gZnJvbSBtb25vIC0+IHN0ZXJlbworICAgIGlm IChzb3VyY2VCdXMubnVtYmVyT2ZDaGFubmVscygpICE9IDEgJiYgIXRvcG9sb2d5TWF0Y2hlcyhz b3VyY2VCdXMpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBEaXNwYXRjaCBmb3IgZGlmZmVy ZW50IGNoYW5uZWwgbGF5b3V0cworICAgIHN3aXRjaCAobnVtYmVyT2ZDaGFubmVscygpKSB7Cisg ICAgY2FzZSAxOiAvLyBtb25vCisgICAgY2FzZSAyOiAvLyBzdGVyZW8KKyAgICAgICAgcHJvY2Vz c1dpdGhHYWluRnJvbU1vbm9TdGVyZW8oc291cmNlQnVzLCBsYXN0TWl4R2FpbiwgdGFyZ2V0R2Fp biwgc3VtVG9CdXMpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIDQ6IC8vIEZJWE1FOiBpbXBs ZW1lbnQgcXVhZAorICAgIGNhc2UgNTogLy8gRklYTUU6IGltcGxlbWVudCA1LjAKKyAgICBkZWZh dWx0OgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgYnJlYWs7CisgICAg fQorfQorCit2b2lkIEF1ZGlvQnVzOjpjb3B5V2l0aEdhaW5Gcm9tKGNvbnN0IEF1ZGlvQnVzICZz b3VyY2VCdXMsIGRvdWJsZSogbGFzdE1peEdhaW4sIGRvdWJsZSB0YXJnZXRHYWluKQoreworICAg IHByb2Nlc3NXaXRoR2FpbkZyb20oc291cmNlQnVzLCBsYXN0TWl4R2FpbiwgdGFyZ2V0R2Fpbiwg ZmFsc2UpOworfQorCit2b2lkIEF1ZGlvQnVzOjpzdW1XaXRoR2FpbkZyb20oY29uc3QgQXVkaW9C dXMgJnNvdXJjZUJ1cywgZG91YmxlKiBsYXN0TWl4R2FpbiwgZG91YmxlIHRhcmdldEdhaW4pCit7 CisgICAgcHJvY2Vzc1dpdGhHYWluRnJvbShzb3VyY2VCdXMsIGxhc3RNaXhHYWluLCB0YXJnZXRH YWluLCB0cnVlKTsKK30KKworfSAvLyBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoV0VCX0FV RElPKQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9BdWRpb0J1cy5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9CdXMuaAkocmV2aXNpb24gMCkKKysrIFdl YkNvcmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9CdXMuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwx MzkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq CisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFw cGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRz IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9y IHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaWZuZGVmIEF1ZGlvQnVzX2gKKyNkZWZpbmUgQXVkaW9CdXNfaAorCisjaW5jbHVk ZSAiQXVkaW9DaGFubmVsLmgiCisjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVk ZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKworLy8gQW4gQXVkaW9CdXMgcmVwcmVzZW50cyBhIGNvbGxlY3Rpb24gb2Yg b25lIG9yIG1vcmUgQXVkaW9DaGFubmVscy4KKy8vIFRoZSBkYXRhIGxheW91dCBpcyAicGxhbmFy IiBhcyBvcHBvc2VkIHRvICJpbnRlcmxlYXZlZCIuCisvLyBBbiBBdWRpb0J1cyB3aXRoIG9uZSBj aGFubmVsIGlzIG1vbm8sIGFuIEF1ZGlvQnVzIHdpdGggdHdvIGNoYW5uZWxzIGlzIHN0ZXJlbywg ZXRjLgorY2xhc3MgQXVkaW9CdXMgIDogcHVibGljIE5vbmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAg ICBlbnVtIHsKKyAgICAgICAgQ2hhbm5lbExlZnQgPSAwLAorICAgICAgICBDaGFubmVsUmlnaHQg PSAxLAorICAgICAgICBDaGFubmVsQ2VudGVyID0gMiwgLy8gY2VudGVyIGFuZCBtb25vIGFyZSB0 aGUgc2FtZQorICAgICAgICBDaGFubmVsTW9ubyA9IDIsCisgICAgICAgIENoYW5uZWxMRkUgPSAz LAorICAgICAgICBDaGFubmVsU3Vycm91bmRMZWZ0ID0gNCwKKyAgICAgICAgQ2hhbm5lbFN1cnJv dW5kUmlnaHQgPSA1LAorICAgIH07CisKKyAgICBlbnVtIHsKKyAgICAgICAgTGF5b3V0Q2Fub25p Y2FsID0gMAorICAgICAgICAvLyBDYW4gZGVmaW5lIG5vbi1zdGFuZGFyZCBsYXlvdXRzIGhlcmUK KyAgICB9OworCisgICAgLy8gYWxsb2NhdGUgaW5kaWNhdGVzIHdoZXRoZXIgb3Igbm90IHRvIGlu aXRpYWxseSBoYXZlIHRoZSBBdWRpb0NoYW5uZWxzIGNyZWF0ZWQgd2l0aCBtYW5hZ2VkIHN0b3Jh Z2UuCisgICAgLy8gTm9ybWFsIHVzYWdlIGlzIHRvIHBhc3MgdHJ1ZSBoZXJlLCBpbiB3aGljaCBj YXNlIHRoZSBBdWRpb0NoYW5uZWxzIHdpbGwgbWVtb3J5LW1hbmFnZSB0aGVpciBvd24gc3RvcmFn ZS4KKyAgICAvLyBJZiBhbGxvY2F0ZSBpcyBmYWxzZSB0aGVuIHNldENoYW5uZWxNZW1vcnkoKSBo YXMgdG8gYmUgY2FsbGVkIGxhdGVyIG9uIGZvciBlYWNoIGNoYW5uZWwgYmVmb3JlIHRoZSBBdWRp b0J1cyBpcyB1c2VhYmxlLi4uCisgICAgQXVkaW9CdXModW5zaWduZWQgbnVtYmVyT2ZDaGFubmVs cywgc2l6ZV90IGxlbmd0aCwgYm9vbCBhbGxvY2F0ZSA9IHRydWUpOworCisgICAgLy8gVGVsbHMg dGhlIGdpdmVuIGNoYW5uZWwgdG8gdXNlIGFuIGV4dGVybmFsbHkgYWxsb2NhdGVkIGJ1ZmZlci4K KyAgICB2b2lkIHNldENoYW5uZWxNZW1vcnkodW5zaWduZWQgY2hhbm5lbEluZGV4LCBmbG9hdCog c3RvcmFnZSwgc2l6ZV90IGxlbmd0aCk7CisKKyAgICAvLyBDaGFubmVscworICAgIHVuc2lnbmVk IG51bWJlck9mQ2hhbm5lbHMoKSBjb25zdCB7IHJldHVybiBtX2NoYW5uZWxzLnNpemUoKTsgfQor CisgICAgQXVkaW9DaGFubmVsKiBjaGFubmVsKHVuc2lnbmVkIGNoYW5uZWwpIHsgcmV0dXJuIG1f Y2hhbm5lbHNbY2hhbm5lbF0uZ2V0KCk7IH0KKyAgICBjb25zdCBBdWRpb0NoYW5uZWwqIGNoYW5u ZWwodW5zaWduZWQgY2hhbm5lbCkgY29uc3QgeyByZXR1cm4gY29uc3RfY2FzdDxBdWRpb0J1cyo+ KHRoaXMpLT5tX2NoYW5uZWxzW2NoYW5uZWxdLmdldCgpOyB9CisgICAgQXVkaW9DaGFubmVsKiBj aGFubmVsQnlUeXBlKHVuc2lnbmVkIHR5cGUpOworCisgICAgLy8gTnVtYmVyIG9mIHNhbXBsZS1m cmFtZXMKKyAgICBzaXplX3QgbGVuZ3RoKCkgY29uc3QgeyByZXR1cm4gbV9sZW5ndGg7IH0KKwor ICAgIC8vIFNhbXBsZS1yYXRlIDogMC4wIGlmIHVua25vd24gb3IgImRvbid0IGNhcmUiCisgICAg ZG91YmxlIHNhbXBsZVJhdGUoKSBjb25zdCB7IHJldHVybiBtX3NhbXBsZVJhdGU7IH0KKyAgICB2 b2lkIHNldFNhbXBsZVJhdGUoZG91YmxlIHNhbXBsZVJhdGUpIHsgbV9zYW1wbGVSYXRlID0gc2Ft cGxlUmF0ZTsgfQorCisgICAgLy8gWmVyb2VzIGFsbCBjaGFubmVscy4KKyAgICB2b2lkIHplcm8o KTsKKworICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgY2hhbm5lbCBjb3VudCBhbmQgZnJhbWUt c2l6ZSBtYXRjaC4KKyAgICBib29sIHRvcG9sb2d5TWF0Y2hlcyhjb25zdCBBdWRpb0J1cyAmc291 cmNlQnVzKSBjb25zdDsKKworICAgIC8vIENyZWF0ZXMgYSBuZXcgYnVmZmVyIGZyb20gYSByYW5n ZSBpbiB0aGUgc291cmNlIGJ1ZmZlci4KKyAgICAvLyAwIG1heSBiZSByZXR1cm5lZCBpZiB0aGUg cmFuZ2UgZG9lcyBub3QgZml0IGluIHRoZSBzb3VyY2VCdWZmZXIKKyAgICBzdGF0aWMgUGFzc093 blB0cjxBdWRpb0J1cz4gY3JlYXRlQnVmZmVyRnJvbVJhbmdlKEF1ZGlvQnVzKiBzb3VyY2VCdWZm ZXIsIHVuc2lnbmVkIHN0YXJ0RnJhbWUsIHVuc2lnbmVkIGVuZEZyYW1lKTsKKworICAgIC8vIFNj YWxlcyBhbGwgc2FtcGxlcyBieSB0aGUgc2FtZSBhbW91bnQuCisgICAgdm9pZCBzY2FsZShkb3Vi bGUgc2NhbGUpOworCisgICAgLy8gTWFzdGVyIGdhaW4gZm9yIHRoaXMgYnVzIC0gdXNlZCB3aXRo IHN1bVdpdGhHYWluRnJvbSgpIGJlbG93CisgICAgdm9pZCBzZXRHYWluKGRvdWJsZSBnYWluKSB7 IG1fYnVzR2FpbiA9IGdhaW47IH0KKyAgICBkb3VibGUgZ2FpbigpIHsgcmV0dXJuIG1fYnVzR2Fp bjsgfQorCisgICAgdm9pZCByZXNldCgpIHsgbV9pc0ZpcnN0VGltZSA9IHRydWU7IH0gLy8gZm9y IGRlLXppcHBlcmluZworCisgICAgLy8gQXNzdW1pbmcgc291cmNlQnVzIGhhcyB0aGUgc2FtZSB0 b3BvbG9neSwgY29waWVzIHNhbXBsZSBkYXRhIGZyb20gZWFjaCBjaGFubmVsIG9mIHNvdXJjZUJ1 cyB0byBvdXIgY29ycmVzcG9uZGluZyBjaGFubmVsLgorICAgIHZvaWQgY29weUZyb20oY29uc3Qg QXVkaW9CdXMgJnNvdXJjZUJ1cyk7CisKKyAgICAvLyBTdW1zIHRoZSBzb3VyY2VCdXMgaW50byBv dXIgYnVzIHdpdGggdW5pdHkgZ2Fpbi4KKyAgICAvLyBPdXIgb3duIGludGVybmFsIGdhaW4gbV9i dXNHYWluIGlzIGlnbm9yZWQuCisgICAgdm9pZCBzdW1Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3Vy Y2VCdXMpOworCisgICAgLy8gQ29weSBvciBzdW0gZWFjaCBjaGFubmVsIGZyb20gc291cmNlQnVz IGludG8gb3VyIGNvcnJlc3BvbmRpbmcgY2hhbm5lbC4KKyAgICAvLyBXZSBzY2FsZSBieSB0YXJn ZXRHYWluIChhbmQgb3VyIG93biBpbnRlcm5hbCBnYWluIG1fYnVzR2FpbiksIHBlcmZvcm1pbmcg ImRlLXppcHBlcmluZyIgdG8gc21vb3RobHkgY2hhbmdlIGZyb20gKmxhc3RNaXhHYWluIHRvICh0 YXJnZXRHYWluKm1fYnVzR2FpbikuCisgICAgLy8gVGhlIGNhbGxlciBpcyByZXNwb25zaWJsZSBm b3Igc2V0dGluZyB1cCBsYXN0TWl4R2FpbiB0byBwb2ludCB0byBzdG9yYWdlIHdoaWNoIGlzIHVu aXF1ZSBmb3IgZXZlcnkgInN0cmVhbSIgd2hpY2ggd2lsbCBiZSBzdW1tZWQgdG8gdGhpcyBidXMu CisgICAgLy8gVGhpcyByZXByZXNlbnRzIHRoZSBkZXppcHBlcmluZyBtZW1vcnkuCisgICAgdm9p ZCBjb3B5V2l0aEdhaW5Gcm9tKGNvbnN0IEF1ZGlvQnVzICZzb3VyY2VCdXMsIGRvdWJsZSogbGFz dE1peEdhaW4sIGRvdWJsZSB0YXJnZXRHYWluKTsKKyAgICB2b2lkIHN1bVdpdGhHYWluRnJvbShj b25zdCBBdWRpb0J1cyAmc291cmNlQnVzLCBkb3VibGUqIGxhc3RNaXhHYWluLCBkb3VibGUgdGFy Z2V0R2Fpbik7CisKKyAgICAvLyBSZXR1cm5zIG1heGltdW0gYWJzb2x1dGUgdmFsdWUgYWNyb3Nz IGFsbCBjaGFubmVscyAodXNlZnVsIGZvciBub3JtYWxpemF0aW9uKS4KKyAgICBmbG9hdCBtYXhB YnNWYWx1ZSgpIGNvbnN0OworCisgICAgLy8gTWFrZXMgbWF4aW11bSBhYnNvbHV0ZSB2YWx1ZSA9 PSAxLjAgKGlmIHBvc3NpYmxlKS4KKyAgICB2b2lkIG5vcm1hbGl6ZSgpOworCitwcm90ZWN0ZWQ6 CisgICAgQXVkaW9CdXMoKSB7IH07CisKKyAgICB2b2lkIHByb2Nlc3NXaXRoR2FpbkZyb20oY29u c3QgQXVkaW9CdXMgJnNvdXJjZUJ1cywgZG91YmxlKiBsYXN0TWl4R2FpbiwgZG91YmxlIHRhcmdl dEdhaW4sIGJvb2wgc3VtVG9CdXMpOworICAgIHZvaWQgcHJvY2Vzc1dpdGhHYWluRnJvbU1vbm9T dGVyZW8oY29uc3QgQXVkaW9CdXMgJnNvdXJjZUJ1cywgZG91YmxlKiBsYXN0TWl4R2FpbiwgZG91 YmxlIHRhcmdldEdhaW4sIGJvb2wgc3VtVG9CdXMpOworCisgICAgc2l6ZV90IG1fbGVuZ3RoOwor CisgICAgVmVjdG9yPE93blB0cjxBdWRpb0NoYW5uZWw+ID4gbV9jaGFubmVsczsKKworICAgIGlu dCBtX2xheW91dDsKKworICAgIGRvdWJsZSBtX2J1c0dhaW47CisgICAgYm9vbCBtX2lzRmlyc3RU aW1lOworICAgIGRvdWJsZSBtX3NhbXBsZVJhdGU7IC8vIDAuMCBpZiB1bmtub3duIG9yIE4vQQor fTsKKworfSAvLyBXZWJDb3JlCisKKyNlbmRpZiAvLyBBdWRpb0J1c19oCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2F1ZGlvL0F1ZGlvU291cmNlUHJvdmlkZXIuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BsYXRmb3JtL2F1ZGlvL0F1ZGlvU291cmNlUHJvdmlkZXIuaAkocmV2aXNpb24gMCkKKysr IFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vQXVkaW9Tb3VyY2VQcm92aWRlci5oCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDQ2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKiAzLiAgTmVpdGhlciB0 aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAoIkFwcGxlIikgbm9yIHRoZSBuYW1lcyBv ZgorICogICAgIGl0cyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9t b3RlIHByb2R1Y3RzIGRlcml2ZWQKKyAqICAgICBmcm9tIHRoaXMgc29mdHdhcmUgd2l0aG91dCBz cGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkK KyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NT IE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YK KyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBBdWRpb1NvdXJjZVByb3ZpZGVyX2gKKyNkZWZp bmUgQXVkaW9Tb3VyY2VQcm92aWRlcl9oCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3Mg QXVkaW9CdXM7CisgICAgCisvLyBBYnN0cmFjdCBiYXNlLWNsYXNzIGZvciBhIHB1bGwtbW9kZWwg Y2xpZW50LgorLy8gcHJvdmlkZUlucHV0KCkgZ2V0cyBjYWxsZWQgcmVwZWF0ZWRseSB0byByZW5k ZXIgdGltZS1zbGljZXMgb2YgYSBjb250aW51b3VzIGF1ZGlvIHN0cmVhbS4KK2NsYXNzIEF1ZGlv U291cmNlUHJvdmlkZXIgeworcHVibGljOgorICAgIHZpcnR1YWwgdm9pZCBwcm92aWRlSW5wdXQo QXVkaW9CdXMqIGJ1cywgc2l6ZV90IGZyYW1lc1RvUHJvY2VzcykgPSAwOworICAgIHZpcnR1YWwg fkF1ZGlvU291cmNlUHJvdmlkZXIoKSB7IH0KK307CisKK30gLy8gV2ViQ29yZQorCisjZW5kaWYg Ly8gQXVkaW9Tb3VyY2VQcm92aWRlcl9oCg==