36466 2010-03-22 16:29:22 -0700 audio engine: add Reverb class 2010-08-30 15:16:42 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 0 crogers webkit-unassigned cmarrin dino eric.carlson eric jorlow kbr simon.fraser oldest_to_newest 202825 0 crogers 2010-03-22 16:29:22 -0700 audio engine: add Reverb class 202826 1 51369 crogers 2010-03-22 16:30:51 -0700 Created attachment 51369 Patch 202827 2 51370 crogers 2010-03-22 16:33:47 -0700 Created attachment 51370 image describing operation of Reverb class Adding diagram describing operation of Reverb class 202828 3 crogers 2010-03-22 16:36:43 -0700 This is the top-level DSP object for multi-channel convolution reverb. It uses several ReverbConvolver objects along with channel matrixing. Please see attached diagram. 203149 4 51369 jorlow 2010-03-23 12:30:15 -0700 Comment on attachment 51369 Patch > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index 1f2d874..5761d36 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,23 @@ > +2010-03-22 Chris Rogers <crogers@google.com> > + > + Reviewed by NOBODY (OOPS!). > + > + audio engine: add Reverb class > + https://bugs.webkit.org/show_bug.cgi?id=36466 > + > + No tests since not yet connected to javascript API > + > + * platform/audio/Reverb.cpp: Added. > + (WebCore::calculateNormalizationScale): > + (WebCore::normalizeResponse): > + (WebCore::Reverb::Reverb): > + (WebCore::Reverb::initialize): > + (WebCore::Reverb::process): > + (WebCore::Reverb::reset): > + (WebCore::Reverb::impulseResponseLength): > + * platform/audio/Reverb.h: Added. > + (WebCore::Reverb::): > + > 2010-03-05 Csaba Osztrogonác <ossy@webkit.org> > > Unreviewed buildfix after r55593. (To fix Qt --minimal build.) > diff --git a/WebCore/platform/audio/Reverb.cpp b/WebCore/platform/audio/Reverb.cpp > new file mode 100644 > index 0000000..2d163ba > --- /dev/null > +++ b/WebCore/platform/audio/Reverb.cpp > @@ -0,0 +1,201 @@ > +/* > + * 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" > +#include "Reverb.h" > + > +#include "AudioBus.h" > +#include "AudioFileReader.h" > +#include "ReverbConvolver.h" > +#include <math.h> > +#include <wtf/OwnPtr.h> > +#include <wtf/PassOwnPtr.h> > + > +namespace WebCore { > + > +static double calculateNormalizationScale(AudioBus* response) > +{ > + // Normalize by RMS power > + size_t numberOfChannels = response->numberOfChannels(); > + size_t frameSize = response->frameSize(); > + > + double power = 0.0; > + > + for (size_t i = 0; i < numberOfChannels; ++i) { > + int n = frameSize; > + float* p = response->channel(i)->data(); > + > + while (n--) { > + float sample = *p++; > + power += sample * sample; > + } > + } > + > + power = sqrt(power / (numberOfChannels * frameSize)); > + > + // Protect against accidental overload > + const double MinPower = 0.000125; > + if (std::isinf(power) || std::isnan(power) || power < MinPower) Is this a normal code path? If a developer hit this, it seems like it might be worth asserting, though we should definitely still handle the case gracefully. > + power = MinPower; > + > + double scale = 1.0 / power; > + > + // Empirical gain calibration tested across many impulse responses to ensure perceived volume is same as dry (unprocessed) signal > + scale *= pow(10.0, -58.0 * 0.05); // -58dB gain reduction Constants like this should probably be put at the header of the file. > + > + // True-stereo compensation > + if (response->numberOfChannels() == 4) > + scale *= 0.5; > + > + return scale; > +} > + > +static void normalizeResponse(AudioBus* response) > +{ > + double scale = calculateNormalizationScale(response); > + response->scale(scale); > +} > + > +Reverb::Reverb(const char* filePath, size_t renderSliceSize, size_t maxFFTSize, size_t numberOfChannels, double sampleRate, bool useBackgroundThreads) > +{ > + OwnPtr<AudioBus> impulseResponse = createBusFromAudioFile(filePath, false, sampleRate); > + normalizeResponse(impulseResponse.get()); > + > + initialize(impulseResponse.get(), renderSliceSize, maxFFTSize, numberOfChannels, useBackgroundThreads); > +} > + > +Reverb::Reverb(AudioBus* impulseResponse, size_t renderSliceSize, size_t maxFFTSize, size_t numberOfChannels, bool useBackgroundThreads) > +{ > + double scale = calculateNormalizationScale(impulseResponse); > + if (scale) Why if (scale)? If anything shouldn't this check to see if it's 1.0? > + impulseResponse->scale(scale); > + > + initialize(impulseResponse, renderSliceSize, maxFFTSize, numberOfChannels, useBackgroundThreads); > + > + // Undo scaling since this shouldn't be a destructive operation on impulseResponse > + if (scale) > + impulseResponse->scale(1.0 / scale); > +} > + > +void Reverb::initialize(AudioBus* impulseResponseBuffer, size_t renderSliceSize, size_t maxFFTSize, size_t numberOfChannels, bool useBackgroundThreads) > +{ > + m_impulseResponseLength = impulseResponseBuffer->frameSize(); > + > + // The reverb can handle a mono impulse response and still do stereo processing > + size_t numResponseChannels = impulseResponseBuffer->numberOfChannels(); > + m_convolvers.reserveCapacity(numberOfChannels); > + > + int convolverRenderPhase = 0; > + for (size_t i = 0; i < numResponseChannels; ++i) { > + AudioChannel* channel = impulseResponseBuffer->channel(i); > + > + ReverbConvolver* convolver = new ReverbConvolver(channel, renderSliceSize, maxFFTSize, convolverRenderPhase, useBackgroundThreads); > + m_convolvers.append(convolver); > + > + convolverRenderPhase += renderSliceSize; > + } > + > + // For "True" stereo processing Can you add a bit more of a comment about why this is needed? Is it just an optimization so you don't keep allocating and deallocating memory? > + if (numResponseChannels == 4) > + m_tempBuffer = new AudioBus(2, MaxFrameSize); > +} > + > +void Reverb::process(AudioBus* sourceBus, AudioBus* destinationBus, size_t framesToProcess) > +{ > + bool isSafeToProcess = sourceBus && destinationBus && framesToProcess <= MaxFrameSize && framesToProcess <= sourceBus->frameSize() && framesToProcess <= destinationBus->frameSize(); > + > + ASSERT(isSafeToProcess); > + if (!isSafeToProcess) > + return; > + > + // For now only handle mono or stereo output > + if (destinationBus->numberOfChannels() > 2) > + return; > + > + float* destinationL = destinationBus->channel(0)->data(); > + float* sourceL = sourceBus->channel(0)->data(); > + > + // Handle input -> output matrixing... > + size_t numInputChannels = sourceBus->numberOfChannels(); > + size_t numOutputChannels = destinationBus->numberOfChannels(); > + size_t numReverbChannels = m_convolvers.size(); > + > + // 2 -> 2 -> 2 > + if (numInputChannels == 2 && numReverbChannels == 2 && numOutputChannels == 2) { I almost wonder if you should handle the various cases with just an enum... I.e. have various modes. I'm not sure how general purpose this code really is. > + float* sourceR = sourceBus->channel(1)->data(); > + float* destinationR = destinationBus->channel(1)->data(); > + m_convolvers[0]->process(sourceL, destinationL, framesToProcess); > + m_convolvers[1]->process(sourceR, destinationR, framesToProcess); > + } else if (numInputChannels == 1 && numOutputChannels == 2 && numReverbChannels == 2) { > + // 1 -> 2 -> 2 > + for (int i = 0; i < 2; ++i) { > + float* destinationP = destinationBus->channel(i)->data(); > + m_convolvers[i]->process(sourceL, destinationP, framesToProcess); > + } > + } else if (numInputChannels == 1 && numReverbChannels == 1 && numOutputChannels == 2) { > + // 1 -> 1 -> 2 > + m_convolvers[0]->process(sourceL, destinationL, framesToProcess); > + > + // simply copy L -> R > + float* destinationR = destinationBus->channel(1)->data(); > + memcpy(destinationR, destinationL, sizeof(float) * framesToProcess); > + } else if (numInputChannels == 1 && numReverbChannels == 1 && numOutputChannels == 1) Since this is multiple lines (with the comment) I think it's proper to put {}'s around it. > + // 1 -> 1 -> 1 > + m_convolvers[0]->process(sourceL, destinationL, framesToProcess); > + else if (numInputChannels == 2 && numReverbChannels == 4 && numOutputChannels == 2) { > + // 2 -> 4 -> 2 ("True" stereo) > + float* sourceR = sourceBus->channel(1)->data(); > + float* destinationR = destinationBus->channel(1)->data(); All of this stuff scares me...does WebKit have an equivilent of a CHECK (a DCHECK that fires even in release)? If not, can we add one? And then whenever you do anything like this, can you check that what's happening is safe. Also, ideally I'd like to pass around real objects (that can check their bounds and such) as much as possible and avoid this raw pointer stuff. > + > + float* tempL = m_tempBuffer->channel(0)->data(); > + float* tempR = m_tempBuffer->channel(1)->data(); > + > + // Process left virtual source > + m_convolvers[0]->process(sourceL, destinationL, framesToProcess); > + m_convolvers[1]->process(sourceL, destinationR, framesToProcess); > + > + // Process right virtual source > + m_convolvers[2]->process(sourceR, tempL, framesToProcess); > + m_convolvers[3]->process(sourceR, tempR, framesToProcess); > + > + destinationBus->sumFrom(*m_tempBuffer); > + } Maybe have an else with an ASSERT(0) or something? (IIRC, there's a macro for this, but I can't remember what it is...maybe take a look for it?) > +} > + > +void Reverb::reset() > +{ > + for (size_t i = 0; i < m_convolvers.size(); ++i) > + m_convolvers[i]->reset(); > +} > + > +size_t Reverb::impulseResponseLength() const > +{ > + return m_impulseResponseLength; Could have been done inline if you wanted. > +} > + > +} // namespace WebCore > diff --git a/WebCore/platform/audio/Reverb.h b/WebCore/platform/audio/Reverb.h > new file mode 100644 > index 0000000..4cfa659 > --- /dev/null > +++ b/WebCore/platform/audio/Reverb.h > @@ -0,0 +1,66 @@ > +/* > + * 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 Reverb_h > +#define Reverb_h > + > +#include "AudioBus.h" > +#include "ReverbConvolver.h" These two could be just forward declared if you declared the destructor and implemented it in a .cpp file (that does include them). > +#include <wtf/Vector.h> > + > +namespace WebCore { > + > +// Multi-channel convolution reverb with channel matrixing - one or more ReverbConvolver objects are used internally. > + > +class Reverb { > +public: > + enum {MaxFrameSize = 256}; I believe a space after and before the { and } is the norm. Actually, it seems like usually these are static const variables, but the enum method seems like a good one. > + > + // renderSliceSize is a rendering hint, so the FFTs can be optimized to not all occur at the same time (very bad when rendering on a real-time thread). > + Reverb(AudioBus* impulseResponseBuffer, size_t renderSliceSize, size_t maxFFTSize, size_t numberOfChannels, bool useBackgroundThreads); > + Reverb(const char* filePath, size_t renderSliceSize, size_t maxFFTSize, size_t numberOfChannels, double sampleRate, bool useBackgroundThreads); How are file paths expressed elsewhere? I doubt via const char* strings. Not sure size_t is the right way to express number of channels. Kinda weird that your sample rate is not an integer...but I don't really care. > + > + virtual void process(AudioBus* sourceBus, AudioBus* destinationBus, size_t framesToProcess); > + virtual void reset(); Why virtual? > + > + size_t impulseResponseLength() const; > + > +private: > + void initialize(AudioBus* impulseResponseBuffer, size_t renderSliceSize, size_t maxFFTSize, size_t numberOfChannels, bool useBackgroundThreads); > + > + size_t m_impulseResponseLength; > + > + Vector<OwnPtr<ReverbConvolver> > m_convolvers; > + > + // For "True" stereo processing > + OwnPtr<AudioBus> m_tempBuffer; > +}; > + > +} // namespace WebCore > + > +#endif // Reverb_h 203263 5 51463 crogers 2010-03-23 15:41:36 -0700 Created attachment 51463 Patch 203278 6 crogers 2010-03-23 16:22:36 -0700 Addressed most of your comments. > Is this a normal code path? If a developer hit this, it seems like it might be > worth asserting, though we should definitely still handle the case gracefully. It's not really an ASSERT case (which I usually consider to be sanity checking of the correctness of the code itself). It *is* possible for a user to load up an impulse response which is badly formed, like a completely silent audio file. In this case, I want to make sure that we don't have divide by zero errors which can disrupt the audio output stream. In other cases, it's trying to protect from generating an extremely loud output. > Constants like this should probably be put at the header of the file. I put them at the top of the file. Since the constants are really related to internal implementation details I didn't want to expose them in the interface (header) file. I hope that's OK. > Why if (scale)? If anything shouldn't this check to see if it's 1.0? It's basically to avoid a divide-by-zero, since this check works in tandem with the similar check at the end of the method. If you like, I could add the optimization for the 1.0 case, but I think it will be extremely rare that the scale value will be *exactly* 1.0 so maybe not worth it - it's up to you though. > I almost wonder if you should handle the various cases with just an enum... > I.e. have various modes. I'm not sure how general purpose this code really is. I wanted to make the processing code dynamically adaptable at runtime without any required re-configuration when channel valences change which is now possible with the new modular dynamic routing. Also, I think an enum would require somewhat more logic to configure the enum value (and reconfigure if it changes) so I prefer this more direct approach. Additional, if clauses can easily be added to handle more cases such as 5.1 and 7.2 matrixing in the future. > All of this stuff scares me...does WebKit have an equivilent of a CHECK (a > DCHECK that fires even in release)? If not, can we add one? And then whenever > you do anything like this, can you check that what's happening is safe. Also, > ideally I'd like to pass around real objects (that can check their bounds and > such) as much as possible and avoid this raw pointer stuff. As far as CHECK, I'm not sure, but if there is one, I could change all my ASSERTs. If there's a precedent for that in WebKit I'm happy to do it. I added a comprehensive safety check at the top of the method which validates the source and destination AudioBus objects. This validation, along with the checks for numberOfChannels should be sufficient to guarantee the pointer values are valid and that the pointers point to buffers which are large enough. In general, I agree about passing real objects with bound-checking and that's why I use the AudioBus objects so much (you'll see later in other parts of the code). But at a low enough level of the code, it becomes extremely difficult to avoid the direct pointers, because there can be multiple sources for the data: AudioFloatArray, AudioChannel, a pointer value provided from an OS-level callback, a pointer to somewhere other than the beginning of an AudioFloatArray, etc. In this particular case, I could change ReverbConvolver::process() to take AudioChannel arguments, which I think is what you're looking for here (and I'm happy to do it :). > Maybe have an else with an ASSERT(0) or something? (IIRC, there's a macro for > this, but I can't remember what it is...maybe take a look for it?) For now, I'm handling the un-handled case by just gracefully outputting silence. I'm a bit torn between this and just using ASSERT - so if you feel strongly... > These two could be just forward declared if you declared the destructor and > implemented it in a .cpp file (that does include them). I was able to do this for AudioBus, but ReverbConvolver (presumably since I'm using a Vector of them) seems to require the header file. I'm not sure what you mean by "declaring the destructor"?? > How are file paths expressed elsewhere? I doubt via const char* strings. This was an old code-path used for testing/bring-up (I've removed this constructor) > Not sure size_t is the right way to express number of channels. Should I use "unsigned"? > Kinda weird that your sample rate is not an integer...but I don't really care. This is how we designed the CoreAudio APIs and it has worked out well. It avoids a conversion from int -> float which is almost always required when doing the math using it. It also supports sample-rates which are non-integer, which although rare can exist. 203371 7 jorlow 2010-03-24 03:26:13 -0700 (In reply to comment #6) > > Why if (scale)? If anything shouldn't this check to see if it's 1.0? > > It's basically to avoid a divide-by-zero, since this check works in tandem with > the similar check at the end of the method. If you like, I could add the > optimization for the 1.0 case, but I think it will be extremely rare that the > scale value will be *exactly* 1.0 so maybe not worth it - it's up to you > though. Is it possible for the normalization scale to ever ben 0? If so, is there some better default action we can take here? > > I almost wonder if you should handle the various cases with just an enum... > > I.e. have various modes. I'm not sure how general purpose this code really is. > > I wanted to make the processing code dynamically adaptable at runtime without > any required re-configuration when channel valences change which is now > possible with the new modular dynamic routing. Also, I think an enum would > require somewhat more logic to configure the enum value (and reconfigure if it > changes) so I prefer this more direct approach. Additional, if clauses can > easily be added to handle more cases such as 5.1 and 7.2 matrixing in the > future. Hm...that's fine...as long as you handle the cases that slip between the cracks. > > All of this stuff scares me...does WebKit have an equivilent of a CHECK (a > > DCHECK that fires even in release)? If not, can we add one? And then whenever > > you do anything like this, can you check that what's happening is safe. Also, > > ideally I'd like to pass around real objects (that can check their bounds and > > such) as much as possible and avoid this raw pointer stuff. > > As far as CHECK, I'm not sure, but if there is one, I could change all my > ASSERTs. If there's a precedent for that in WebKit I'm happy to do it. I > added a comprehensive safety check at the top of the method which validates the > source and destination AudioBus objects. This validation, along with the > checks for numberOfChannels should be sufficient to guarantee the pointer > values are valid and that the pointers point to buffers which are large enough. > In general, I agree about passing real objects with bound-checking and that's > why I use the AudioBus objects so much (you'll see later in other parts of the > code). But at a low enough level of the code, it becomes extremely difficult > to avoid the direct pointers, because there can be multiple sources for the > data: AudioFloatArray, AudioChannel, a pointer value provided from an OS-level > callback, a pointer to somewhere other than the beginning of an > AudioFloatArray, etc. In this particular case, I could change > ReverbConvolver::process() to take AudioChannel arguments, which I think is > what you're looking for here (and I'm happy to do it :). I think that would help. And I'd encourage you to check as many assumptions as are possible with some sort of fatal assert. Speaking of which, I've asked for Jeremy to make one here: https://bugs.webkit.org/show_bug.cgi?id=36426 > > Maybe have an else with an ASSERT(0) or something? (IIRC, there's a macro for > > this, but I can't remember what it is...maybe take a look for it?) > > For now, I'm handling the un-handled case by just gracefully outputting > silence. I'm a bit torn between this and just using ASSERT - so if you feel > strongly... I think an assert while debugging and silence during normal operation is a good balance. > > These two could be just forward declared if you declared the destructor and > > implemented it in a .cpp file (that does include them). > > I was able to do this for AudioBus, but ReverbConvolver (presumably since I'm > using a Vector of them) seems to require the header file. I'm not sure what > you mean by "declaring the destructor"?? If you ommit the destructor or put |~ClassName() { }| in the . h file, then anything that might destroy ClassName needs to know how to destroy all the Own/RefPtr's the class owns. But if you do |~ClassName();| and put the definition in the .cpp file, then only that file needs to know how to destroy the class (and thus destroy anything you have Own/RefPtrs of). I say this because having a RefPtr/OwnPtr<ClassName>, ClassName*, or ClassName& in the header does not require you to include the .h, but RefPtr/OwnPtr<ClassName>'s and a destructor that's in the .h file (whether implicit or explicit) does require you to include the .h file rather than just forward declaring. > > Not sure size_t is the right way to express number of channels. > > Should I use "unsigned"? Yeah. size_t is fine for the length of an array and such, but unsigned is probably better for things like number of channels. 203530 8 51463 jorlow 2010-03-24 12:08:28 -0700 Comment on attachment 51463 Patch Please address my previous comments, but this looks really good. 205702 9 51976 crogers 2010-03-29 15:30:34 -0700 Created attachment 51976 Patch 205710 10 crogers 2010-03-29 15:37:49 -0700 > Is it possible for the normalization scale to ever ben 0? If so, is there some > better default action we can take here? It is possible if the user un-intentionally (or intentionally in some cases) loads up an impulse response which represents "dead silence". In this case, the code will work correctly (do the mathematically correct thing) and generate silent output. That said, there is the opportunity for an optimization in this case (avoid doing the convolution altogether and simply note this edge case and zero out the destination buffers directly). But I think the case is rare enough that an optimization isn't really necessary and would actually make the code a little harder to read. > I think that would help. And I'd encourage you to check as many assumptions as > are possible with some sort of fatal assert. I did change ReverbConvolver::process() to take AudioChannels (instead of raw pointers). 205998 11 jorlow 2010-03-30 07:28:36 -0700 (In reply to comment #10) > > Is it possible for the normalization scale to ever ben 0? If so, is there some > > better default action we can take here? > > It is possible if the user un-intentionally (or intentionally in some cases) > loads up an impulse response which represents "dead silence". In this case, > the code will work correctly (do the mathematically correct thing) and > generate silent output. That said, there is the opportunity for an > optimization in this case (avoid doing the convolution altogether and simply > note this edge case and zero out the destination buffers directly). But I > think the case is rare enough that an optimization isn't really necessary and > would actually make the code a little harder to read. Please put a concise comment about the divide by zero case and the fact that it needn't be normalized because the algorithm will generate silence anyway. 206001 12 51976 jorlow 2010-03-30 07:33:11 -0700 Comment on attachment 51976 Patch r=me, but as with the other engine patches, this should go into the branch. > +void Reverb::process(AudioBus* sourceBus, AudioBus* destinationBus, size_t framesToProcess) > +{ > + // Do a fairly comprehensive sanity check. > + // If these conditions are satisfied, all of the source and destination pointers will be valid for the various matrixing cases. > + bool isSafeToProcess = sourceBus && destinationBus && sourceBus->numberOfChannels() > 0 && destinationBus->numberOfChannels() > 0 > + && framesToProcess <= MaxFrameSize && framesToProcess <= sourceBus->frameSize() && framesToProcess <= destinationBus->frameSize(); nit: probably better to line up on |sourceBus| i.e. bool isSafeToProcess = sourceBus && destinationBus && sourceBus->numberOfChannels() > 0 && destinationBus->numberOfChannels() > 0 && framesToProcess <= MaxFrameSize && framesToProcess <= sourceBus->frameSize() && framesToProcess <= destinationBus->frameSize(); 219964 13 eric 2010-05-02 19:14:48 -0700 Was this landed in the big audio branch landing? If so, please close so it's not in webkit.org/pending-commit anymore. 220215 14 crogers 2010-05-03 11:39:47 -0700 (In reply to comment #13) > Was this landed in the big audio branch landing? If so, please close so it's > not in webkit.org/pending-commit anymore. Hi Eric, I still need to land these bugs in trunk. There may be some slight reorganization of directory layout as soon as other reviewers and I hash that out by looking at my branch... 226172 15 51976 abarth 2010-05-14 23:56:15 -0700 Comment on attachment 51976 Patch Remove review while you sort out whether this is landing in trunk or branch. 270113 16 65618 crogers 2010-08-26 14:26:18 -0700 Created attachment 65618 Patch 270115 17 crogers 2010-08-26 14:30:46 -0700 This was previously R+ by Jeremy Orlow. This adds a WEB_AUDIO feature enable. It also introduces a small amount of new code to handle the 1 -> 4 -> 2 case. 271536 18 65618 cmarrin 2010-08-30 11:54:11 -0700 Comment on attachment 65618 Patch This patch is ready to land 271537 19 65618 commit-queue 2010-08-30 11:54:39 -0700 Comment on attachment 65618 Patch Rejecting patch 65618 from review queue. cmarrin@apple.com does not have reviewer permissions according to http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/common/config/committers.py. - If you do not have reviewer rights please read http://webkit.org/coding/contributing.html for instructions on how to use bugzilla flags. - If you have reviewer 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 reviewer rights. 271540 20 crogers 2010-08-30 11:56:48 -0700 Thanks Chris, I can have somebody here do the formalities... 271546 21 65618 cmarrin 2010-08-30 12:04:00 -0700 Comment on attachment 65618 Patch Try r+ again after fixing committers.py 271548 22 eric 2010-08-30 12:07:54 -0700 The cq probably hasn't done it's restart yet. :( (restarts about every 2 hours) I need to add a manual restart button to queues.webkit.org. 271565 23 65618 commit-queue 2010-08-30 12:27:33 -0700 Comment on attachment 65618 Patch Rejecting patch 65618 from commit-queue. Unexpected failure when processing patch! Please file a bug against webkit-patch. Failed to run "['./WebKitTools/Scripts/webkit-patch', '--status-host=queues.webkit.org', 'land-attachment', '--force-clean', '--build', '--non-interactive', '--ignore-builders', '--build-style=both', '--quiet', 65618, '--test', '--parent-command=commit-queue', '--no-update']" exit_code: 1 Last 500 characters of output: &ctype=xml Processing 1 patch from 1 bug. Cleaning working directory Processing patch 65618 from bug 36466. Warning, attachment 65618 on bug 36466 has invalid reviewer (cmarrin@apple.com) NOBODY (OOPS!) found in /Users/eseidel/Projects/CommitQueue/WebCore/ChangeLog does not appear to be a valid reviewer according to committers.py. ERROR: /Users/eseidel/Projects/CommitQueue/WebCore/ChangeLog neither lists a valid reviewer nor contains the string "Unreviewed" or "Rubber stamp" (case insensitive). 271574 24 eric 2010-08-30 12:44:06 -0700 I restarted the cq by hand it should respect cmarrin now. 271601 25 cmarrin 2010-08-30 13:12:04 -0700 (In reply to comment #24) > I restarted the cq by hand it should respect cmarrin now. Is this where I start my Rodney Dangerfield routine? 271675 26 crogers 2010-08-30 15:10:49 -0700 Committed r66412: <http://trac.webkit.org/changeset/66412> 271676 27 crogers 2010-08-30 15:12:33 -0700 re-opening because patch did not actually land 271681 28 65618 crogers 2010-08-30 15:16:35 -0700 Comment on attachment 65618 Patch Clearing flags on attachment: 65618 Committed r66413: <http://trac.webkit.org/changeset/66413> 271682 29 crogers 2010-08-30 15:16:42 -0700 All reviewed patches have been landed. Closing bug. 51369 2010-03-22 16:30:51 -0700 2010-03-23 15:41:32 -0700 Patch bug-36466-20100322163050.patch text/plain 12336 crogers ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MWYyZDg3NC4uNTc2MWQzNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wMy0yMiAgQ2hyaXMgUm9nZXJz ICA8Y3JvZ2Vyc0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGF1ZGlvIGVuZ2luZTogYWRkIFJldmVyYiBjbGFzcworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzY0NjYKKworICAgICAgICBO byB0ZXN0cyBzaW5jZSBub3QgeWV0IGNvbm5lY3RlZCB0byBqYXZhc2NyaXB0IEFQSQorCisgICAg ICAgICogcGxhdGZvcm0vYXVkaW8vUmV2ZXJiLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3Jl OjpjYWxjdWxhdGVOb3JtYWxpemF0aW9uU2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6bm9ybWFs aXplUmVzcG9uc2UpOgorICAgICAgICAoV2ViQ29yZTo6UmV2ZXJiOjpSZXZlcmIpOgorICAgICAg ICAoV2ViQ29yZTo6UmV2ZXJiOjppbml0aWFsaXplKToKKyAgICAgICAgKFdlYkNvcmU6OlJldmVy Yjo6cHJvY2Vzcyk6CisgICAgICAgIChXZWJDb3JlOjpSZXZlcmI6OnJlc2V0KToKKyAgICAgICAg KFdlYkNvcmU6OlJldmVyYjo6aW1wdWxzZVJlc3BvbnNlTGVuZ3RoKToKKyAgICAgICAgKiBwbGF0 Zm9ybS9hdWRpby9SZXZlcmIuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpSZXZlcmI6Oik6 CisKIDIwMTAtMDMtMDUgIENzYWJhIE9zenRyb2dvbsOhYyAgPG9zc3lAd2Via2l0Lm9yZz4KIAog ICAgICAgICBVbnJldmlld2VkIGJ1aWxkZml4IGFmdGVyIHI1NTU5My4gKFRvIGZpeCBRdCAtLW1p bmltYWwgYnVpbGQuKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmIu Y3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmIuY3BwCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLjJkMTYzYmEKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL2F1ZGlvL1JldmVyYi5jcHAKQEAgLTAsMCArMSwyMDEgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1 dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgi QXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20g dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJ QlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisjaW5jbHVkZSAiUmV2ZXJiLmgiCisKKyNpbmNsdWRlICJBdWRpb0J1cy5oIgorI2lu Y2x1ZGUgIkF1ZGlvRmlsZVJlYWRlci5oIgorI2luY2x1ZGUgIlJldmVyYkNvbnZvbHZlci5oIgor I2luY2x1ZGUgPG1hdGguaD4KKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CisjaW5jbHVkZSA8d3Rm L1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdGF0aWMgZG91YmxlIGNh bGN1bGF0ZU5vcm1hbGl6YXRpb25TY2FsZShBdWRpb0J1cyogcmVzcG9uc2UpCit7CisgICAgLy8g Tm9ybWFsaXplIGJ5IFJNUyBwb3dlcgorICAgIHNpemVfdCBudW1iZXJPZkNoYW5uZWxzID0gcmVz cG9uc2UtPm51bWJlck9mQ2hhbm5lbHMoKTsKKyAgICBzaXplX3QgZnJhbWVTaXplID0gcmVzcG9u c2UtPmZyYW1lU2l6ZSgpOworCisgICAgZG91YmxlIHBvd2VyID0gMC4wOworCisgICAgZm9yIChz aXplX3QgaSA9IDA7IGkgPCBudW1iZXJPZkNoYW5uZWxzOyArK2kpIHsKKyAgICAgICAgaW50IG4g PSBmcmFtZVNpemU7CisgICAgICAgIGZsb2F0KiBwID0gcmVzcG9uc2UtPmNoYW5uZWwoaSktPmRh dGEoKTsKKworICAgICAgICB3aGlsZSAobi0tKSB7CisgICAgICAgICAgICBmbG9hdCBzYW1wbGUg PSAqcCsrOworICAgICAgICAgICAgcG93ZXIgKz0gc2FtcGxlICogc2FtcGxlOworICAgICAgICB9 CisgICAgfQorCisgICAgcG93ZXIgPSBzcXJ0KHBvd2VyIC8gKG51bWJlck9mQ2hhbm5lbHMgKiBm cmFtZVNpemUpKTsKKworICAgIC8vIFByb3RlY3QgYWdhaW5zdCBhY2NpZGVudGFsIG92ZXJsb2Fk CisgICAgY29uc3QgZG91YmxlIE1pblBvd2VyID0gMC4wMDAxMjU7CisgICAgaWYgKHN0ZDo6aXNp bmYocG93ZXIpIHx8IHN0ZDo6aXNuYW4ocG93ZXIpIHx8IHBvd2VyIDwgTWluUG93ZXIpCisgICAg ICAgIHBvd2VyID0gTWluUG93ZXI7CisKKyAgICBkb3VibGUgc2NhbGUgPSAxLjAgLyBwb3dlcjsK KworICAgIC8vIEVtcGlyaWNhbCBnYWluIGNhbGlicmF0aW9uIHRlc3RlZCBhY3Jvc3MgbWFueSBp bXB1bHNlIHJlc3BvbnNlcyB0byBlbnN1cmUgcGVyY2VpdmVkIHZvbHVtZSBpcyBzYW1lIGFzIGRy eSAodW5wcm9jZXNzZWQpIHNpZ25hbAorICAgIHNjYWxlICo9IHBvdygxMC4wLCAtNTguMCAqIDAu MDUpOyAvLyAtNThkQiBnYWluIHJlZHVjdGlvbgorCisgICAgLy8gVHJ1ZS1zdGVyZW8gY29tcGVu c2F0aW9uCisgICAgaWYgKHJlc3BvbnNlLT5udW1iZXJPZkNoYW5uZWxzKCkgPT0gNCkKKyAgICAg ICAgc2NhbGUgKj0gMC41OworCisgICAgcmV0dXJuIHNjYWxlOworfQorCitzdGF0aWMgdm9pZCBu b3JtYWxpemVSZXNwb25zZShBdWRpb0J1cyogcmVzcG9uc2UpCit7CisgICAgZG91YmxlIHNjYWxl ID0gY2FsY3VsYXRlTm9ybWFsaXphdGlvblNjYWxlKHJlc3BvbnNlKTsKKyAgICByZXNwb25zZS0+ c2NhbGUoc2NhbGUpOworfQorCitSZXZlcmI6OlJldmVyYihjb25zdCBjaGFyKiBmaWxlUGF0aCwg c2l6ZV90IHJlbmRlclNsaWNlU2l6ZSwgc2l6ZV90IG1heEZGVFNpemUsIHNpemVfdCBudW1iZXJP ZkNoYW5uZWxzLCAgZG91YmxlIHNhbXBsZVJhdGUsIGJvb2wgdXNlQmFja2dyb3VuZFRocmVhZHMp Cit7CisgICAgT3duUHRyPEF1ZGlvQnVzPiBpbXB1bHNlUmVzcG9uc2UgPSBjcmVhdGVCdXNGcm9t QXVkaW9GaWxlKGZpbGVQYXRoLCBmYWxzZSwgc2FtcGxlUmF0ZSk7CisgICAgbm9ybWFsaXplUmVz cG9uc2UoaW1wdWxzZVJlc3BvbnNlLmdldCgpKTsKKworICAgIGluaXRpYWxpemUoaW1wdWxzZVJl c3BvbnNlLmdldCgpLCByZW5kZXJTbGljZVNpemUsIG1heEZGVFNpemUsIG51bWJlck9mQ2hhbm5l bHMsIHVzZUJhY2tncm91bmRUaHJlYWRzKTsKK30KKworUmV2ZXJiOjpSZXZlcmIoQXVkaW9CdXMq IGltcHVsc2VSZXNwb25zZSwgc2l6ZV90IHJlbmRlclNsaWNlU2l6ZSwgc2l6ZV90IG1heEZGVFNp emUsIHNpemVfdCBudW1iZXJPZkNoYW5uZWxzLCBib29sIHVzZUJhY2tncm91bmRUaHJlYWRzKQor eworICAgIGRvdWJsZSBzY2FsZSA9IGNhbGN1bGF0ZU5vcm1hbGl6YXRpb25TY2FsZShpbXB1bHNl UmVzcG9uc2UpOworICAgIGlmIChzY2FsZSkKKyAgICAgICAgaW1wdWxzZVJlc3BvbnNlLT5zY2Fs ZShzY2FsZSk7CisKKyAgICBpbml0aWFsaXplKGltcHVsc2VSZXNwb25zZSwgcmVuZGVyU2xpY2VT aXplLCBtYXhGRlRTaXplLCBudW1iZXJPZkNoYW5uZWxzLCB1c2VCYWNrZ3JvdW5kVGhyZWFkcyk7 CisKKyAgICAvLyBVbmRvIHNjYWxpbmcgc2luY2UgdGhpcyBzaG91bGRuJ3QgYmUgYSBkZXN0cnVj dGl2ZSBvcGVyYXRpb24gb24gaW1wdWxzZVJlc3BvbnNlCisgICAgaWYgKHNjYWxlKQorICAgICAg ICBpbXB1bHNlUmVzcG9uc2UtPnNjYWxlKDEuMCAvIHNjYWxlKTsKK30KKwordm9pZCBSZXZlcmI6 OmluaXRpYWxpemUoQXVkaW9CdXMqIGltcHVsc2VSZXNwb25zZUJ1ZmZlciwgc2l6ZV90IHJlbmRl clNsaWNlU2l6ZSwgc2l6ZV90IG1heEZGVFNpemUsIHNpemVfdCBudW1iZXJPZkNoYW5uZWxzLCBi b29sIHVzZUJhY2tncm91bmRUaHJlYWRzKQoreworICAgIG1faW1wdWxzZVJlc3BvbnNlTGVuZ3Ro ID0gaW1wdWxzZVJlc3BvbnNlQnVmZmVyLT5mcmFtZVNpemUoKTsKKworICAgIC8vIFRoZSByZXZl cmIgY2FuIGhhbmRsZSBhIG1vbm8gaW1wdWxzZSByZXNwb25zZSBhbmQgc3RpbGwgZG8gc3RlcmVv IHByb2Nlc3NpbmcKKyAgICBzaXplX3QgbnVtUmVzcG9uc2VDaGFubmVscyA9IGltcHVsc2VSZXNw b25zZUJ1ZmZlci0+bnVtYmVyT2ZDaGFubmVscygpOworICAgIG1fY29udm9sdmVycy5yZXNlcnZl Q2FwYWNpdHkobnVtYmVyT2ZDaGFubmVscyk7CisKKyAgICBpbnQgY29udm9sdmVyUmVuZGVyUGhh c2UgPSAwOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbnVtUmVzcG9uc2VDaGFubmVsczsg KytpKSB7CisgICAgICAgIEF1ZGlvQ2hhbm5lbCogY2hhbm5lbCA9IGltcHVsc2VSZXNwb25zZUJ1 ZmZlci0+Y2hhbm5lbChpKTsKKworICAgICAgICBSZXZlcmJDb252b2x2ZXIqIGNvbnZvbHZlciA9 IG5ldyBSZXZlcmJDb252b2x2ZXIoY2hhbm5lbCwgcmVuZGVyU2xpY2VTaXplLCBtYXhGRlRTaXpl LCBjb252b2x2ZXJSZW5kZXJQaGFzZSwgdXNlQmFja2dyb3VuZFRocmVhZHMpOworICAgICAgICBt X2NvbnZvbHZlcnMuYXBwZW5kKGNvbnZvbHZlcik7CisKKyAgICAgICAgY29udm9sdmVyUmVuZGVy UGhhc2UgKz0gcmVuZGVyU2xpY2VTaXplOworICAgIH0KKworICAgIC8vIEZvciAiVHJ1ZSIgc3Rl cmVvIHByb2Nlc3NpbmcKKyAgICBpZiAobnVtUmVzcG9uc2VDaGFubmVscyA9PSA0KQorICAgICAg ICBtX3RlbXBCdWZmZXIgPSBuZXcgQXVkaW9CdXMoMiwgTWF4RnJhbWVTaXplKTsKK30KKwordm9p ZCBSZXZlcmI6OnByb2Nlc3MoQXVkaW9CdXMqIHNvdXJjZUJ1cywgQXVkaW9CdXMqIGRlc3RpbmF0 aW9uQnVzLCBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKQoreworICAgIGJvb2wgaXNTYWZlVG9Qcm9j ZXNzID0gc291cmNlQnVzICYmIGRlc3RpbmF0aW9uQnVzICYmIGZyYW1lc1RvUHJvY2VzcyA8PSBN YXhGcmFtZVNpemUgJiYgZnJhbWVzVG9Qcm9jZXNzIDw9IHNvdXJjZUJ1cy0+ZnJhbWVTaXplKCkg JiYgZnJhbWVzVG9Qcm9jZXNzIDw9IGRlc3RpbmF0aW9uQnVzLT5mcmFtZVNpemUoKTsgCisgICAg CisgICAgQVNTRVJUKGlzU2FmZVRvUHJvY2Vzcyk7CisgICAgaWYgKCFpc1NhZmVUb1Byb2Nlc3Mp CisgICAgICAgIHJldHVybjsKKworICAgIC8vIEZvciBub3cgb25seSBoYW5kbGUgbW9ubyBvciBz dGVyZW8gb3V0cHV0CisgICAgaWYgKGRlc3RpbmF0aW9uQnVzLT5udW1iZXJPZkNoYW5uZWxzKCkg PiAyKQorICAgICAgICByZXR1cm47CisKKyAgICBmbG9hdCogZGVzdGluYXRpb25MID0gZGVzdGlu YXRpb25CdXMtPmNoYW5uZWwoMCktPmRhdGEoKTsKKyAgICBmbG9hdCogc291cmNlTCA9IHNvdXJj ZUJ1cy0+Y2hhbm5lbCgwKS0+ZGF0YSgpOworCisgICAgLy8gSGFuZGxlIGlucHV0IC0+IG91dHB1 dCBtYXRyaXhpbmcuLi4KKyAgICBzaXplX3QgbnVtSW5wdXRDaGFubmVscyA9IHNvdXJjZUJ1cy0+ bnVtYmVyT2ZDaGFubmVscygpOworICAgIHNpemVfdCBudW1PdXRwdXRDaGFubmVscyA9IGRlc3Rp bmF0aW9uQnVzLT5udW1iZXJPZkNoYW5uZWxzKCk7CisgICAgc2l6ZV90IG51bVJldmVyYkNoYW5u ZWxzID0gbV9jb252b2x2ZXJzLnNpemUoKTsKKworICAgIC8vIDIgLT4gMiAtPiAyCisgICAgaWYg KG51bUlucHV0Q2hhbm5lbHMgPT0gMiAmJiBudW1SZXZlcmJDaGFubmVscyA9PSAyICYmIG51bU91 dHB1dENoYW5uZWxzID09IDIpIHsKKyAgICAgICAgZmxvYXQqIHNvdXJjZVIgPSBzb3VyY2VCdXMt PmNoYW5uZWwoMSktPmRhdGEoKTsKKyAgICAgICAgZmxvYXQqIGRlc3RpbmF0aW9uUiA9IGRlc3Rp bmF0aW9uQnVzLT5jaGFubmVsKDEpLT5kYXRhKCk7CisgICAgICAgIG1fY29udm9sdmVyc1swXS0+ cHJvY2Vzcyhzb3VyY2VMLCBkZXN0aW5hdGlvbkwsIGZyYW1lc1RvUHJvY2Vzcyk7CisgICAgICAg IG1fY29udm9sdmVyc1sxXS0+cHJvY2Vzcyhzb3VyY2VSLCBkZXN0aW5hdGlvblIsIGZyYW1lc1Rv UHJvY2Vzcyk7CisgICAgfSBlbHNlICBpZiAobnVtSW5wdXRDaGFubmVscyA9PSAxICYmIG51bU91 dHB1dENoYW5uZWxzID09IDIgJiYgbnVtUmV2ZXJiQ2hhbm5lbHMgPT0gMikgeworICAgICAgICAv LyAxIC0+IDIgLT4gMgorICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IDI7ICsraSkgeworICAg ICAgICAgICAgZmxvYXQqIGRlc3RpbmF0aW9uUCA9IGRlc3RpbmF0aW9uQnVzLT5jaGFubmVsKGkp LT5kYXRhKCk7CisgICAgICAgICAgICBtX2NvbnZvbHZlcnNbaV0tPnByb2Nlc3Moc291cmNlTCwg ZGVzdGluYXRpb25QLCBmcmFtZXNUb1Byb2Nlc3MpOworICAgICAgICB9CisgICAgfSBlbHNlIGlm IChudW1JbnB1dENoYW5uZWxzID09IDEgJiYgbnVtUmV2ZXJiQ2hhbm5lbHMgPT0gMSAmJiBudW1P dXRwdXRDaGFubmVscyA9PSAyKSB7CisgICAgICAgIC8vIDEgLT4gMSAtPiAyCisgICAgICAgIG1f Y29udm9sdmVyc1swXS0+cHJvY2Vzcyhzb3VyY2VMLCBkZXN0aW5hdGlvbkwsIGZyYW1lc1RvUHJv Y2Vzcyk7CisKKyAgICAgICAgLy8gc2ltcGx5IGNvcHkgTCAtPiBSCisgICAgICAgIGZsb2F0KiBk ZXN0aW5hdGlvblIgPSBkZXN0aW5hdGlvbkJ1cy0+Y2hhbm5lbCgxKS0+ZGF0YSgpOworICAgICAg ICBtZW1jcHkoZGVzdGluYXRpb25SLCBkZXN0aW5hdGlvbkwsIHNpemVvZihmbG9hdCkgKiBmcmFt ZXNUb1Byb2Nlc3MpOworICAgIH0gZWxzZSBpZiAobnVtSW5wdXRDaGFubmVscyA9PSAxICYmIG51 bVJldmVyYkNoYW5uZWxzID09IDEgJiYgbnVtT3V0cHV0Q2hhbm5lbHMgPT0gMSkKKyAgICAgICAg Ly8gMSAtPiAxIC0+IDEKKyAgICAgICAgbV9jb252b2x2ZXJzWzBdLT5wcm9jZXNzKHNvdXJjZUws IGRlc3RpbmF0aW9uTCwgZnJhbWVzVG9Qcm9jZXNzKTsKKyAgICBlbHNlIGlmIChudW1JbnB1dENo YW5uZWxzID09IDIgJiYgbnVtUmV2ZXJiQ2hhbm5lbHMgPT0gNCAmJiBudW1PdXRwdXRDaGFubmVs cyA9PSAyKSB7CisgICAgICAgIC8vIDIgLT4gNCAtPiAyICgiVHJ1ZSIgc3RlcmVvKQorICAgICAg ICBmbG9hdCogc291cmNlUiA9IHNvdXJjZUJ1cy0+Y2hhbm5lbCgxKS0+ZGF0YSgpOworICAgICAg ICBmbG9hdCogZGVzdGluYXRpb25SID0gZGVzdGluYXRpb25CdXMtPmNoYW5uZWwoMSktPmRhdGEo KTsKKworICAgICAgICBmbG9hdCogdGVtcEwgPSBtX3RlbXBCdWZmZXItPmNoYW5uZWwoMCktPmRh dGEoKTsKKyAgICAgICAgZmxvYXQqIHRlbXBSID0gbV90ZW1wQnVmZmVyLT5jaGFubmVsKDEpLT5k YXRhKCk7CisKKyAgICAgICAgLy8gUHJvY2VzcyBsZWZ0IHZpcnR1YWwgc291cmNlCisgICAgICAg IG1fY29udm9sdmVyc1swXS0+cHJvY2Vzcyhzb3VyY2VMLCBkZXN0aW5hdGlvbkwsIGZyYW1lc1Rv UHJvY2Vzcyk7CisgICAgICAgIG1fY29udm9sdmVyc1sxXS0+cHJvY2Vzcyhzb3VyY2VMLCBkZXN0 aW5hdGlvblIsIGZyYW1lc1RvUHJvY2Vzcyk7CisKKyAgICAgICAgLy8gUHJvY2VzcyByaWdodCB2 aXJ0dWFsIHNvdXJjZQorICAgICAgICBtX2NvbnZvbHZlcnNbMl0tPnByb2Nlc3Moc291cmNlUiwg dGVtcEwsIGZyYW1lc1RvUHJvY2Vzcyk7CisgICAgICAgIG1fY29udm9sdmVyc1szXS0+cHJvY2Vz cyhzb3VyY2VSLCB0ZW1wUiwgZnJhbWVzVG9Qcm9jZXNzKTsKKworICAgICAgICBkZXN0aW5hdGlv bkJ1cy0+c3VtRnJvbSgqbV90ZW1wQnVmZmVyKTsKKyAgICB9Cit9CisKK3ZvaWQgUmV2ZXJiOjpy ZXNldCgpCit7CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2NvbnZvbHZlcnMuc2l6ZSgp OyArK2kpCisgICAgICAgIG1fY29udm9sdmVyc1tpXS0+cmVzZXQoKTsKK30KKworc2l6ZV90IFJl dmVyYjo6aW1wdWxzZVJlc3BvbnNlTGVuZ3RoKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9pbXB1 bHNlUmVzcG9uc2VMZW5ndGg7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vYXVkaW8vUmV2ZXJiLmggYi9XZWJDb3JlL3BsYXRmb3JtL2F1 ZGlvL1JldmVyYi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRjZmE2NTkK LS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1JldmVyYi5oCkBAIC0w LDAgKzEsNjYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1l IG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAg ICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJv ZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmlj IHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICog RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNF LCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjaWZuZGVmIFJldmVyYl9oCisjZGVmaW5lIFJldmVyYl9oCisKKyNpbmNs dWRlICJBdWRpb0J1cy5oIgorI2luY2x1ZGUgIlJldmVyYkNvbnZvbHZlci5oIgorI2luY2x1ZGUg PHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBNdWx0aS1jaGFubmVs IGNvbnZvbHV0aW9uIHJldmVyYiB3aXRoIGNoYW5uZWwgbWF0cml4aW5nIC0gb25lIG9yIG1vcmUg UmV2ZXJiQ29udm9sdmVyIG9iamVjdHMgYXJlIHVzZWQgaW50ZXJuYWxseS4KKworY2xhc3MgUmV2 ZXJiIHsKK3B1YmxpYzoKKyAgICBlbnVtIHtNYXhGcmFtZVNpemUgPSAyNTZ9OworCisgICAgLy8g cmVuZGVyU2xpY2VTaXplIGlzIGEgcmVuZGVyaW5nIGhpbnQsIHNvIHRoZSBGRlRzIGNhbiBiZSBv cHRpbWl6ZWQgdG8gbm90IGFsbCBvY2N1ciBhdCB0aGUgc2FtZSB0aW1lICh2ZXJ5IGJhZCB3aGVu IHJlbmRlcmluZyBvbiBhIHJlYWwtdGltZSB0aHJlYWQpLgorICAgIFJldmVyYihBdWRpb0J1cyog aW1wdWxzZVJlc3BvbnNlQnVmZmVyLCBzaXplX3QgcmVuZGVyU2xpY2VTaXplLCBzaXplX3QgbWF4 RkZUU2l6ZSwgc2l6ZV90IG51bWJlck9mQ2hhbm5lbHMsIGJvb2wgdXNlQmFja2dyb3VuZFRocmVh ZHMpOworICAgIFJldmVyYihjb25zdCBjaGFyKiBmaWxlUGF0aCwgc2l6ZV90IHJlbmRlclNsaWNl U2l6ZSwgc2l6ZV90IG1heEZGVFNpemUsIHNpemVfdCBudW1iZXJPZkNoYW5uZWxzLCBkb3VibGUg c2FtcGxlUmF0ZSwgYm9vbCB1c2VCYWNrZ3JvdW5kVGhyZWFkcyk7CisKKyAgICB2aXJ0dWFsIHZv aWQgcHJvY2VzcyhBdWRpb0J1cyogc291cmNlQnVzLCBBdWRpb0J1cyogZGVzdGluYXRpb25CdXMs IHNpemVfdCBmcmFtZXNUb1Byb2Nlc3MpOworICAgIHZpcnR1YWwgdm9pZCByZXNldCgpOworCisg ICAgc2l6ZV90IGltcHVsc2VSZXNwb25zZUxlbmd0aCgpIGNvbnN0OworCitwcml2YXRlOgorICAg IHZvaWQgaW5pdGlhbGl6ZShBdWRpb0J1cyogaW1wdWxzZVJlc3BvbnNlQnVmZmVyLCBzaXplX3Qg cmVuZGVyU2xpY2VTaXplLCBzaXplX3QgbWF4RkZUU2l6ZSwgc2l6ZV90IG51bWJlck9mQ2hhbm5l bHMsIGJvb2wgdXNlQmFja2dyb3VuZFRocmVhZHMpOworCisgICAgc2l6ZV90IG1faW1wdWxzZVJl c3BvbnNlTGVuZ3RoOworCisgICAgVmVjdG9yPE93blB0cjxSZXZlcmJDb252b2x2ZXI+ID4gbV9j b252b2x2ZXJzOworCisgICAgLy8gRm9yICJUcnVlIiBzdGVyZW8gcHJvY2Vzc2luZworICAgIE93 blB0cjxBdWRpb0J1cz4gbV90ZW1wQnVmZmVyOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQorCisjZW5kaWYgLy8gUmV2ZXJiX2gK 51370 2010-03-22 16:33:47 -0700 2010-03-22 16:33:47 -0700 image describing operation of Reverb class reverb-matrixing.png image/png 68867 crogers iVBORw0KGgoAAAANSUhEUgAAAdUAAAMDCAIAAAB7Ixi7AAACPmlDQ1BJQ0MgUHJvZmlsZQAAeAGt k01r1FAUht/MUKpYixbpdKNkIepilJApVFdOOx9l2jCGmSmj7jJJJhmdZGKSGbUq9Ae4cueiIH6A C7dSLQh1J0LxoyD2H7ivqCA1npuYtAuLG09I7pPDe84999x7gfRXxXG6KQCW7bu12Rn+4qXL/PAm OAzhADLYr6ieMy3LEkn2sG+fSE22cZrleiesf994uHLsycvV5bsfz9/ZIyh2j7o0IcBlyXHEiDjP uBVxg/F13/FJYzJWTUUjvk2cdRu1AvFT4lEj4heMWxG/YTxQDRb7mViwtY4NpPYRn9V0TyXOExua p1rElIeDZfUof5rlPKU6LsWm3xMfZ32hkaw3S+G/yH9vx6dQHc+pCxO7fCfmgbGjwAq3o9saD3vF jb/12jkxTMeNuMDQjyDYIu3wKrDtBsHP5SDYfkxzbAJr19S+Owi1VCC3DvzrP1pzlB34QGsgC/fo 7xz1JVQJwKM1oLEESDTep/FkBjh8C5BB/jxSuVz8Rj0kN3CwWJIkXpwUppplJvyvZnX7tFehjdF3 xG5VL9A4Qe8Xx5cbMXuDeinmdqdciVlTirQXkX7RLFRjbrvlWsxXlDlWd5hTtxfqMTvd8Oz/mWsm 0eteKdEsmo1mrHf7tYWYr/bmE72mF5Pa7G6V3acwZ8evJPWjiBIkeniImISAKTRRhhydSYrAoWfA g4w4J9VfvwqWmGe3+fqNcK8LPeem2zFMn5+mG6ln+YqtnsnyoiCcw2+PgrJyQ/6A/QAAIABJREFU eAHs3XmgvUP9B/BIoURSlihakFCkJEmSpUhZkqwRSZFEyhISrUgiEiqE0oLSIqJkS0KFUpZUSEW0 KUq/1/f7yfyennPuueeee8695zn3M3+cM888s75n5j2f+czyzPGf//znEWkSgUQgEUgEphyBOac8 xUwwEUgEEoFEYBYCyb/ZDhKBRCARmB4Ekn+nB/dMNRFIBBKB5N9sA4lAIpAITA8Cyb/Tg3ummggk AolA8m+2gUQgEUgEpgeB5N/pwT1TTQQSgUQg+TfbQCKQCCQC04NA8u/04J6pJgKJQCKQ/JttIBFI BBKB6UEg+Xd6cM9UE4FEIBGYKyGYSgTa3rbR1nEqc5VpDScCc8wxR9uMjeXe1nM6DjMCc2Tnn4Lq CZDLb7FMQdKZxAggUAiXJezV3xEo4IwtQsq/A696bMs89NBDUiq/YSkuA89EJtBYBOacc87ZrDtL Fi724hJE3NjCzfSMJ/8OtgUU8g0K/vdsE/byKwfsg81Hxt40BAqx4txCu2F/5CMfGS5+Fav4bFoR M7+PSP4dYCPAqgzKJe0y//rXv9gXXHDBASaZUY86Avfee69GFRSsrEHEo17okS1f8u8Aq1Y/CeYN 8n3wwQdRsPS4DzDVjHp0ESDq/vOf/9ScHvWoR6Fgj9HGQhAe3XKPbMmSfwdYtfpGdI9g3gceeEDn GWB6GfUMQEATinb16Ec/OjQPiHgGlHs0i5j8O6h61UlEHQpfYq9uw/zjH/8YVHoZ78xA4P7774+C 1rTAM6P0o1bK5N9B1WhIvqaKKBj/EoHx79///vdBpZfxzgwE8C+xl5lrrrmoHULzoLFxmRkAjFQp k38HWJ1BwciXoXwg/Cb/DhDumRE1/iX5Il+GhTHGBwvPDABGqpR5/nhQ1Rnk67cq/6b+YVBwz5h4 zaKM5UyotjQwZsaUftQKmvw72Bolm+ge5N/QP4wM/9oFVcrC4nGwOGbsDyNA/g3y1ai0LsabpOCH 4WnYf/LvQCqs9AcWcopOEtKKnjNWevPOO+9std6sH5PKZz7zmQcffHD0rrGC9Oz+tKc9bbHFFusQ /Jvf/GbJTLG87W1vE+TXv/7105/+dLuYTzrpJI9bbLHFYx7zmNe85jUdYmt9deeddx599NGXXHJJ 66t06YyAgZxBvtGuNLABNZLO2ci3fUEg9b99gbF9JPpGGL2FiZ7T3uts17nnnnvfffdl/etf/3ra aae9973vRXO77757hyC9vYrBYNywK6644qte9ari7UUvehH7V77ylVtvvfXtb3/7BhtscPvtt595 5pkveMEL3v/+9xdv3Vhuvvlm5XrHO96xxhprdOM//RQENKSovocbVyofCjbNs6T8O6g60z1E7TfE E7+zSXjW+YuxDP49aLY57LDD9t9/f96uuuoqv3/84x+33377pzzlKcstt9y73vUu8ZiEvuQlL1lr rbV0RR6+853vrLbaakcccQT7ZZdd9tKXvnThhRdeffXVcSUXZOftkUceie/WWWcdLmE+8YlPYNiV VlrphBNOeNjtf/5XWWWVD1TMRhtt9OlPf/qoo47iieh67rnnvva1r2W/4447vvCFL7C0Js2RdmLv vfd+1rOe9ZznPGfPPffE3TfddNNee+3llewdcsghLGm6RyCEX82JCQruPmz6HDYEkn8HWCNBwRKI 3uI36HKsJHkwu2euu+66s846i7eXvexlItl4440/97nPvfjFL0bBqHmXXXahrCAaf+9737viiit4 Q38/+MEPnv/8599yyy1rr732z372s0033fSuu+7CjzQJyNpb2oyPfexjJQM4/YMf/CAthyA777zz 1Vdf3ZorfOpVMXh28cUXD8WFgEssscSzn/1soZ74xCei17ZJe7vbbrsdfvjh/Cy66KLGgE022UTm BffqSU960lJLLcWSpnsESlsqrav7sOlz6BCIITR/+4uATkJOoUa4++678en1119/6aWXEhg/+9nP agFt05pnnnlqjQNz8RnM+MpXvhJj/v73v3/qU59KTL7vvvtM/Pnfb7/9+EGLiEyiob447rjjeP72 t7/Nw6tf/eqf/vSnLCTiiy++OJLG41yIoh7POOMM9gMOOCBexe83vvENjqGJnr3HadaPUngbSXzr W99iv+aaa3jbcccdi3staQjYGiXPFN/hZ+utt/7zn//8/e9/X0DyOMc03SMAtNNPP/2888678sor b7zxRvqfP/3pT8ZXU6LuI0mfw4NA6n816Skyar1zSij44x//OD9kSUT2qU996q1vfSs7F2IsEbIE 1/EQ6+Mf/3hEScj1iEDRJVUDP2+ZbcJzuLBTQVBZlBjQccie3DkGIZa3YXnDG97wmc98puY41mPb pG+77TajAjHZfQUCUmaMFTzdu0Sg2oqq9i6Dp7ehQiD5d7DVUUZayYS9Q3pO9L/pTW8KDyj11FNP pV6IqTq2RcfxSjy42Pb7173udRzDfdttt/V2kUUW8XviiSfGuhmfvP3ud7/jON9880Xw+P3DbEMD QFnBZdVVV62+7cHeNunHzTaSighPOeUUOx+IvT3En0EKAtVGxdFjeZWWZiGQ+t8hrS9zdjkzu1x5 5ZWf/OQnk3OZc8455xnPeMa6664b552Cc62e2Zmw9NJL87/hhhv6tbULcVvJo6s95phj2pZQp6Uj tgRnTawErPn87ne/a3tZMfvss0/NQ/WxbdJUJa94xSt+9KMf2SAhVzvttBMljGHGqCDsT37yk2uv vbYaSdoTgZmFQBlL09JHBIr+lx7WHNx6Gv3vV7/61ZjOt02I8mH++ecvrzCjhkjC5WIdLKRgLniW 1rV4sxWXI2VFcbHYZUNuNGLBaWBD/7vVVlsVP/S/xFUycuztRYvW5cpbFlwfMVR/n/e853k1lv7X q9akOWLYssimFMRtjjZFxIBhDPCYpksEVIeNiZTvFlR//vOf//a3vzVCO9Se+t8uARw2b/n9tyrD 9M2umjFaXHj2t7/97S9/+YsVM2txzA477ODtRFNC6BSsFsEcnUCanYPrkPZ4WZRbaKGFOvs0PIiz j1fCt00aFDIv2/i3ZB4ITs0RhKkoOmcy3xYEoId/VasqW2CBBeiUHvvYx5pkmFKox+ItLU1BIPW/ zagpCocQGLvJLvnXZttufFbX9LrxP66ftkmjhmWWWaYWFpX0kfdrkedjItAIBFL/24hqykwmAonA CCKQ/DuClZpFSgQSgUYgkPzbiGrKTCYCicAIIpD8O4KVmkVKBBKBRiCQ/NuIaspMJgKJwAgikPw7 gpWaRUoEEoFGIJD824hqykwmAonACCKQ+39HsFI7F8ltDC5hcAmZUyFOx7nW0vnmzkHybSKQCAwC geTfQaA6XHE6e+Yuyh/+8IdOrDIyt+SSSzo35eCZA1Tuf3CMdbhyPHy5cf6FcczMRW5+jVhOfjuL 6Gi1e+7d0eHt8OU6czTsCCT/DnsN9Zw/hOtqnvPPP98x6PXWW2/NNdd09NlF6e486znOmRzQhc5u MfbrOLU7PdwL6gJl49knP/lJA5hvjrgXyY1ILgWdyShl2SeEQPLvhOBqgGdXsbh/krnnnnt8MXOP PfaIr1Q0IOvDnUWSLxN5dAOD24hKfql0LrroIpcWvec97/EpUvcZGe3K27QkAmMhkJOmsZBppLsv Ern5wWXthx56KLWDm3aTfKegIk0pXDXn4yYkYrqIN77xjS7t9N2TKUg6k2g0Asm/ja6+/888sdfn Ksx/3bTrmmC37pabxv7fU9oGjMATnvAEY547Nn0p1ddLTzrppAEnmNE3G4HUPzS7/iL3lJK+a+nu MerIcvnvMBTMtZnumWx7NaKbKn2YI+4vHoas9jEP1BTvfe97adt9oJrK2Neg+hh5RjVKCKT8Owq1 Se3oIl1f0uyZfF3pjTWoNRmzaZ8j8oXHyUPjstrWrw1hXqK6u4C33HJL2pIjjjhi8gmVGL7zne9s tNFG5bE3iw9/vO997+stbAllk8nll1/uC35xlX5xT0siUBBI+bdA0VTLV77ylY985CPkrLZiZvel sqDkqwr8k1h9VvnNb35zfN64+xi69GlJ0Cd7qUpdHG6R8PnPf77NA367DD5Qb7ZFf/rTnz722GMn /0E8+Vx00UXpIuywtii3xBJLDDTnGXkTERgR+deWIKaJFTDJPKPdd77znb5RX5bmJxmh4BTHPnfv wzbsPpCx+eab+xidHWwW9JzXQNO+5eGVr1f47pwMoGkUYzOsD9H72IeKMO/+8Ic/HN8AxbNrrLEG fahBwithrVP5zDPyFQmF6Re/+EX6E3YebKflOb4o6htF66yzzoEHHkhSfuELX/irX/3qox/96Ic+ 9CE+GRa764jS22+/PUnT90kvvPDCeOW31aekfb9OVNSy1if58Ym83XfffZtttjn44INLQBEyK6yw QnGZpMWGP7OTd7/73ZOMZ1SDaz/G+1Et3bjl6p1/9THtXmONNGwy1W9112qSxvz4+FjVcUJ2deO7 jdE/OwTEQdadOniY/Csc1/0XKCafXJcxwP/3v//9Siut1KX/Dt6IoqiQOf7449/1rnfhJp4/+MEP Lr/88jfeeKNJvW+1Oa/h6MHXvvY1r84++2yAOIzgm82+9QkfHEdw9srX7G2JFQ+7ubwJOLXAWWed xf2Xv/wl/QbB0KswCBGPc//c5z53wQUXoFGW66+/nu5YKE3ohhtuQN/Wsmzqsq8uQuHotddem35D B/YdT0m8/e1vl4F42+rT5jBf4bMnGnHbn3DXXXcZKnw372Uve1l8gTQCypgixLdEw2Xyv0YUxZl8 PBOKYbXVVlM16rSE+vznP6+HGheLS/eWLrthNcJf/OIXPnhYdWlrtwAQZ4Lavu2Loy8WRrPsS2z9 jaR3/pUPk7XOrOfDkcsuu+xkcqwTIgLkPplIRjgsjQHy6stWB8eR8SMjTkJrfJroy1/+MssXvvAF zOubcr5fZ4sFR5CeeeaZ1LiOIRgA7rjjDpsu9KUQQmlCELcP0PFGcH7uc5+LtbfeemvETewl2KrW WqVgc3u2yKdYg8SNLHiYd955d955Zy62c8gSHQUx/8c//jHdtMh9ClqoXXfd1ZfQfFHUJ45wfUTb 6tO4QkKXydtvv91noS+55BI+eSOzD/oDdHakmTpQuUTepuzXSZAqA6q1no/e9NANffTa8DZlhW1o QpPiX1ISiEkuYxUedf7mN78hnlgLNvDqn4Qd/Yd/6xu0bBtssIGeSSFo+xRH803dLGJj11Us63t8 yUteUgRtj8QcE7qFF16Yks5kNvzbA8+zruVDv8HXSMEKj46KAkhSvLXNibmqnOjzfKIA7MAn4cgu er2afFRbiSLj041KSFlCYRoZmJZfM+XAc/Kpm81QCzAUoKbkpFdQKKyTtWRMU5AjjzwSe5rpW1ZS rYRi4LBw5IEhPMbXkbng68iSagoLGjVOEJkpLqqQHnbYYRqD3bLFp8YQBF2WExF6zFKD/Y0HqF+0 bUNFcjWf8om7I5+77LLLiiuuyFvfP38XSdd+AaW1GEtq7oN+pP+JkVJC2P/iiy9WX7VE4Uw9og9q /PaMB8idu6GJrwmKKZcBL+JHtTpOxHzVVVdR6RBp999/f+KXE0DVFPXo9ddfn9LJXKq0W0c0X/CC F1A9Fb6mIJIKrZeoYkrdtpPSkhmADaJG1mOOOSYS0sctJ+i5FFMExGrqEBAkNmtrhNVX02WfFP8q pIl/DeJqSVQG3sRlKgwbWmTXydU3P6YnJgVoFPpuJ4gPnsMu6I8H1YNGjzrqKPaTTz652nxNNkXl i+76rfVlcln4ee1rX/ulL31JooQdLqpEuzcv3m677XbbbTdtq21O9Ew5ef3rX2//AF6IsBiWrCdj LISv6jzOeVO8IKumsaQzCU2jsV0BNylCf/NgaNHu55lnHr0FYyomC4HXrREqwvScC8RQs8k1utT9 uGjZrUt2joSoR36+/vWvG27FaWBD5aFTotVVm7oK/QYPRlYNQGPgs22JCNH0GHw678CDUCHi2cpG 01U9dVbzqcOHNC0tQWwXaRv/IBxhMi2nYOhnjJTBQeeddx4hxhBYKyDJwytihIkLZY6OxkPnbihO Qo+OZu6rKg1pVgXoiCJmduRL0iJ74ejaxF87oRDXtTUqM48Iot/p5gcccAAmMU7op3vvvTdi0ZF5 CAZo20nVuGnWZz7zGZ5pn1CNwr785S+32mkap7A6fiQRv+LnUx836mh11VfTZZ9sK9xrr72IS7rE WB0mCmaGaATDFMqvA4QjEcZIxW5hRI8iWIV79dcY6FF1VqfYUiR6q0IGG2oB/BBgdTkWdBkaJTRh 5osyCIlctAxv2+ZEZ95ss8283Xjjjfm09GT+i9aNyTSPVI0YoXQhY7jezrOZb6tAwX0qDToLSEPA 71fSJBQt3jVpBkizE63cLIciPmqBaKng0THUKWFZ3wYs3IrAVXIiKrpI4FMX8MadwKtjELgMxgRY Clm1bKSUCrTVpn4rSExiSjxhEcSQI+z888/PxRBIWMMF+r9xndxd/Nd8mgnRU1snlKLZmBZVZlol yCAsMAFXVd4fRCpt49Q2UPC5555rRqhezA5JLTWf9OmYiyDFXXtGhaV7Vn3WuqEapyliTjnlFEJl 69ov7ltkkUWIKaq1xEPkwt1U/DJmf7QZUojbFg/cYcSoQX50aoKwpqIlSMIyacRQ66ThSGY3lWE+ 8IEPaKL0+2o2FPpcyPVErvBpvKcoMxcxSCOQmmhcMjnFlsnyrxavH6o584UOWVcZOioPQC+KMEBH ENMHa9+14GUtpebukdCko4Z7GeLK/h6EG8oKMhc+JX1Ul7Pb5kQ9RWwRlk7TCFl2IKlCVF74VyvR gTUsop+Buri35nNqXPCjEUKX0I57TtGgxZTguDIwVEyzSEMRC3DCg7qOnhOPqkAP1/pNSKOWqZLj FephdCTaIaQZjqjTtNH0gtFbQhTVh12hgBN1zui0em/MPYUyuDIRvCh5Peqf8saowWBk4g/T6pOq gZRgEiahUINWfYb/8ks0K9JZcezBogWSu03LzK97CD75IFI3n5MBQq7hs5V/dSV7SyIhdaGaaom2 7Yal5xJQTEOrfV+RazGUR2np6eqXi7kIgTdeBfuza2DIwSuSr8HSVhnVWnTWtU4aYYtjEIuWQCgu iiy9WBsLn+pdN0HNRAqA2FcT7tP7Oyn9Q2QdNyE4o02HkrS9na/0UpChxQgeHdsrgsNYEZrCEM3i LfVFzL6j55cg2g1SQA2alMZX3NvmpOZIlEMKuMCAyVjKrx5hkpB2rCcTmcUfYnWJf+ot8qO9EijI lQNKHc0V8m2bBLiMiLUqKD5JQ4V8iyMxFl/X9AD6Z5Bv8TauRQzaQ5DvuJ6r/Xlcz5P0oAWaCFvc o62eZFQ9B9c3jWr0LdYA217MZnNLuX2UbGgtN9Lq3A2L8KjnxlYWTBcBTS+qY3M156pJbwpCJ43S ScbbWu+jOrBWZEKsj5PNy8S35q1tWD3XYs/sXjvrR2YKuRMCiNikBAMGlqeeruZtuux94F9Z/9jH PkYPMNEyODhgtMRfJkdkScHNGUO6Of300yM26MM9ZLESP60fD+anaogSo23DQt+GPksQgp966qkl bDcWLIAvIg/IPTZglYBSpI4wxpKCdf6isC4ept6ik9tQRX9njhmj0dTnIVOsImDSQCo0xmjkbYmj 6nlwdg0D6RD6CMJtU9FB9A5tGGnSVLhCk7dxu6GVAN7wtfk+yubfhZzEWywcG1e81TXKTDeSpsTQ syiLPFI0xy7GeFX9pQCkNjQDQw6GrrHYvBqk2KnFjDdol4v+qwoKfRszDEJkakcuqaGrKzol+NRb +sO/5KPYLjqhApgykIBiLmNSIKzFNPGA3mqASuWi7Vr5oRAsehyOiM9eTtMlWkIL7m33D5lv0mRB nLn22mtNAOlJu8weOY6GSMx0CwztikhKWDmkitLspG7RaWrW0EvqY1mMBwQHhyNklUaozC3G8p/u A0IAE1nspS3RbLBMTcAfUKIdosW8VixI4m390A7ZvaD/mr6Y+OtrvI3bDbU0KleKCys36IwWgqJZ DCQVvTIS0uOc/aOgr6ZLXWvJTnKUIbFVpvo27KBD5VaAzappgekP7Rps9dbWRZe0yIZSdFvxV+8/ 0k/NBkyAZJWmzgJS2xim2HGOCQ0vfcycnSUWQ8zfQ8tTYsazZgoLLrhgcWGxWaRVyCXoQXOsOW8E JyCbOJucmvWIhDxSjbaznXxthJdEK8MSrjURdVxd8KnGBlUpioFkoUTYUDFn6TvvvtvgMVDMbTXV tizHQZjgU/pDNXtp7zsC6hQrWWT2a+CnDmorFkwyXdKcWY5mrIOYa5NgNG+NkIanc0fokK6Galau j2jqxVuHbig5hK6TykBVK2UGZq21uhZHycBb1Y/4uVDrV9MqiVYtmjEJzOhFblW60BpXPXSwi18O jQcC1rzptqRyr2ru0/U42fW3SeZb3dSqp9VFEq3ky7FodjrkoSgTtc4Jka84tTNje9vItX6m7atp dzR7oM8x8FhENsLJp60pRn6ixLTLYtMOTt8zgKdsVqWPoq80BSF8mfaWbct9T24QEeoaNLO1mMft hq0EWpZwSlS4uErH4Y4TW8OWIMWiGYe9S81+CchCYGqVmcIDUb3qc9rt08a/pkWxqWXaIRjJDBh4 bI42zzJ9ww7miTQ25n1GFMahRA3UyjLTdmwbSUwmUyjiLanKko7lXJMY6042sdony8XAZoSznj5s fXsy5e0Q1v6fZg0wHcoy7a+mTf8w7SUfaAamUf8wVrkoQ1AwymDMwswWUQlj/TOWpMcKmO4QMHUw UJFwjViGLgKjNSIjmSGt54l/D8AOQv/QQzYySL8QmDb5t18FyHi6RIA6xZoG06X/9JYIJAKDRqA/ +x8GncuMPxFIBBKB0UMg+Xf06jRLlAgkAs1AIPm3GfWUuUwEEoHRQ2DE+ddJGJthrTuNXs1liRKB ZiFgUdp9Pc7KNivbA83tKK+/OdjjThnX01Xv3xkomhl5IpAItEXA0WRn4chDTjm39TAzHUdW/i3k G18hm5m1m6VOBIYBgSr55t7hao2MJv9OL/naoO4eBseicl9ttamlfWYiML3k69SMU9HOIpVr3oaq FkaQf6eXfNWuuxfc+OMyeCek3f/vcP1QVXlmJhGYMgSml3wV03VIrqFwtb+TMi4McntG7Va2KYOi bUKjxr/TTr5Qjivv3Lnj6hD3qFGAMO5kGKqKb9sa0jER6CMC006+URZ3KLoGy/lPXyFxkTdx2NVU LggdiumpRcluTB9rZWZGFVcxWQxU/G4AH2E/ZoJuxa0VUH9wmWzN0fWvzknXHGfyo8ZDgpuZPaiP pQ4JybfTpr0tdSv/TntGx82Ab0A4mO9S53F9DtpD+YhAtBgLDsjXLS0+dNbHNtTcqMxRfNW0ln/f Q4zBqerudlp3yFZd0g4Bn1/xxUz3lBvJXIXq6wSuKh90q55Q/ERLnylwG7r74SYUsO+e0UL1BjWX deiProF3U2jcOT69LWpE9p8Ng9qhVpE41zDrohYN0dc9KKFmX//7369R1TzPqEcfWnVtWK3I5Ws0 VXdzxupj2huBwJCoHQpW8sPuOmbkbkQ39rs7qbydXsso8O+wka/R9frrr3cVrCU4N2aV+9ent6Yz 9URgChAYNvJ1X50b/nxrVX90TWjrfcRTgEmHJBrPv8NGvrD2KTzXV2uI8f2LDujnq0RglBAYNvKF rUvGLYMP4lskfam4bvW/fUms75EMIfkqo8oOBX/fy5sRJgJDi8AQkm9gNbTkK3sN5t/hJN+h7R6Z sURgcAgMLfkOrsh9ibmp/Gvx1/LlWWedZWttX4DISBKBRKBnBBww86F7X7rK48UTwrCp+l/7Ci64 4IIJFTU9JwKJwIAQ8L3nAcU82tE2Vf4d7VrJ0iUCicBMQCD5dybUcpYxEUgEhhGBpuofhhHL4c6T zXC/+MUv6M2d6L3vvvtcT8Gcc845t99++3BnfPpzFx8/drrSZtKFFlpo2WWX9eXjFVdckRJs2PaT Tj9YmYOJIJD8OxG0mub3N7/5zbe//e3zzz/f1QrOqj7jGc9AGW5lm2+++XxNncVVmYsttljTijXV +XVuyjWGzB/+8AfnfX/605+effbZhxxyCHhXW201u/oZwE51tjK95iOQ/Nv8OmwpgYPO7l078cQT 77nnnnXXXXf99dc/9NBDncpz+L3FbzqMj4Dd3CRfZrnlluP7Na95TYRxq5bhzaK/b+rMO++8u+66 6w477DDMu03HL2r6mFoEUv87tXgPOLVbb711yy23JOfecMMNZ5xxhmsWTj/9dKTg8tMk375jP888 87jLwnFHn9U59dRTXeFmSoGF77333r6nlRGOJALJvyNSrQ5ZHnzwwc+fbbCwu8R8gyOP4U1Z7a66 6qqf//zn3dZGEKYgPvPMMx1JmLLUM6GGIpD6h4ZW3P9k+84771xvvfV0e9/dIIL9z7t8mEIEKNMP P/xwUxD3fLvj2KVu1u6mMP1MqmEIpPzbsAprzS4lg6NHO++885e+9KWhIl9XbrbmlovLan2TaSi+ PtA2f5N2XGWVVdzPS/m+8sorj3AxJ41TRtDk+x+y9iCgey+yyCLu1mN6A8QiEjWFbVWMLVbW8U86 6aTeoqqFEhUOqjm695qQuN1225HW3/rWt7o7vOah50dQTGbti+pgySWXjNRhYt3yta997VhDyLiZ BKkPsBoOlXFcz+lhxiKQ8m+zq/4jH/kIOttzzz0nWQy70+yasMXKUv6b3vQmu6wmGWHb4BYD7cr4 8Y9/fPnll1shtJ3ruOOOa+tzGh1tlN54442NRvS5k9nea8FTDD7IorDTWJxMepgRSP4d5toZJ2/E NHRpb+84/ibyeq211rKC5ICGQOhy+eWXJ8ZieY/Umj7tHJFtttlmdM2hINxtAAAgAElEQVT4evPN N3fFKu3zzTff7NXRRx/tM0s+thS3c7AvtdRSPF9zzTXeHnnkkS4KePKTn8zu+yAf//jHvWW/5ZZb pGvbxk477RSfi37961/vre8ULL300jZ4uULbcmLkyu4CX3h64IEH7P169rOf7RzEAQccYPlRPExb n1J/8YtfbAfejjvu6Dp83gjgxx57LBkchrPD/fdHtJtssgny9Zm1yatuffmGOji/O1VFOO1VBJJ/ q2g0zE5+NM9dfPHFJ59vi0Vf/OIXrRdtv/3266yzDlqkOjjwwAMdkGO8ctUctaY9bdKyv8Lln8jR Z70R9I033rjRRhttuummXlFG248l4JprrukRY5JzvX3HO97h0RyfSpQlDMkdNbMjUH4cz/O43377 ccHIkvDxrr333lsqDoxgbbKkV84+IGWSKZWLr8Y5DUFLYPtXxNnqE9GT6A866KCrr76ajiLiVwRF tkvBHrII6Fc8MnDeeeftv//+/dqup7w+hlKSSEsiUEUg+beKRsPs6Iz015dMX3rppd///vcvueQS ygEKZXGiOQIjF9NnfHfhhRdutdVW5557LgpDx76jhfq//OUvUxn7SjHWu+mmm2gwBCQmU55iPfbd dtvNhYS+gIej6TTmnnvuED+recZ63/3ud3fffXeU98pXvvKKK65wMJoHG2mRrA22uNKjFCXHgjRF iJrJ3b7wyMV3nsz0WcLUfKJyo8Idd9xhIHn605+uIOENs9e+A2YbyaKLLoqgScc9a34fzsV//+28 duD7/vvvr7nnYyIAgeTfBjeDF77whcixL/tMjzjiCPN9ois5195hfOFwLbo0H2coBwiGJFD3Hnzv e9/DgBjKzJ3+Yc455+QBW9Et8A9NjFww9fk7dkyNSf2a7/t2b3kr8xQX9AnhgbuTvmLzyB43ySJl jh4RMf9yhcrRriMPEblXNlRUQaj5rBYEve67776CMNV8hgt5/FOf+hRJ2WP8hvtkfgndRi8qnclE kmFHFYHk3wbXLIYiq5IE+1gG2l6iK06kT6BUpZC1s+22224jxEmFaEkXbM6OU/w62czCAwtS9tW7 Wk7M5bnQUFNouHGCxuCUU06JqNA3NQVJ1rlekixtA5+EUxRPmq7F4xGFbbjhhtKiGkb6iBsdh6RM k+AGhhKk5tPHpxH0FltsIay0QhNdPFctMUhQ+9JmGI0uvvji6tve7ErUrzlKbxnIUMOMQG4OH+ba GSdv+AJNmO/TMFb1mOMEG+/1E57wBNtX7QFwmM6qF/LCnm7qEQ4pO1lA1I04fIJkjz32oJ+1aGbl LeTWavSY8YQTTqCiDf2ArF533XUo3qwcp2NStMj/Pvvss/baa6+00kp82sVcjaFqx/4k36OOOoqj rWZis2OMSsEmNmtxY/kkQTsZaElwgQUWoAMJJUbVc6vdPQ+u15HcT37yE6FaPXTpIjhtBtVHl/7T 20xDYI6Y3M20Yg+6vFClJ43vH5fvz1OPMm5j6C/mpEI7BGgAJr9e3woLEVieKYJbXxUXml8z91bh NzxgH4ReHR7QJfJFndVv1di3QFFgC0QojkvknS0Uu3KIgknEnX0aRQwSyyyzDDru7LNfb23po182 VtHV9CtOI5yNGbZnLLjgggYGEwWwU/sAbcrK1a+yZDwQSP4dSDOYSv5VAJvAkJqeaY4/kPJkpBNE wF6Ol7/85XvttZf5wQSDdvKe/NsJnQa+G0dqaGCJZmKW7UAgolrdcu3kTCz/MJXZpIdahrrDtt/+ ku8wlTLz0h8Ekn/7g+P0xmL2fcwxx1jscrrMXRAnn3xybnia+hr53e9+RxVuFLTA6HCKXXFTn4dM sVkIJP82q7465db6lW285rz25zqUQfhyYIF6tFOYfDdpBHzAyX4Ja4lW7WxVtg/ks5/9LIX4pCPO CEYfgdz/MFJ1TD9ooy5j8YcUHLsj8IIDu/YwWKdibFmzccKKjXUblpEq/8AKQ6swayP0Aw9YVv3V r37lsLVjHSxOjthTYVeG/XAmH213zg0sUxlx4xFI/m18FbYtwBJLLOEQLYMybCaz6RVfIAu/Dhbb e8sdpzi2UD250DaqdKTesbfEiBXG3MI+DSOZ/XmO7a2wwgqtG+8StESgGwSSf7tBqcF+UIa1IKbB ZcisJwIjikDqf0e0YrNYiUAiMPQIJP8OfRVlBhOBRGBEEUj+HdGKzWIlAonA0COQ/Dv0VZQZTAQS gRFFIPl3RCs2i5UIJAJDj0Dy79RVUe5SmjqsM6VEoAkIJP8OsJYQbjGSCfsA08uoZwYCpVGxzIwS j2wpk3+nqGqjq2SHmSK4RzcZh0GCf0sRa4/FPS3Dj0Dy71TUkR6i2zB5SetUwD3SaQTblt+RLuvo Fy75d4B1HJ0E7Qb/It/k3wHCPTOidhJaK4pGNTNKPMqlzPPHg6pdnCvqKvPqOXHfTbwaVMIZ70gj EPw7eyifxcJJxI2u7eTfAVYfng2jkwT5uo3BByh9NZJxCY6PVvhuUNyq1d+PEg2wVBn1lCCg5Wgz Goxr6nxRlHG5mm8Oxa11s4l3ljqLtynJTiYyEASSfwcCa0Sqb+gnOknILHF7lo7kW2RuHQtH/Mu4 1TDvIRtgTTQt6mg5Go8Jk0/nBQX71Bu7VsSRCfLlJym4adX7//lN/v1/LPpoiy5RepGuUsgX1RJ1 ubj+kSPyDTpO/u0j/iMQVRm5NRL8y/hcKRN0HIN3kK9mxoxAkWdgEZJ/B1Xp+gae1TFQLWkFvQbP cvRK/yEIo2CODMfk30HVRDPjDW6dLenO+sHCs3QQs03QcZWCm1nEzPUjkn8H2wiQr34S6gXdBs9K L7oTxxB+WZjB5iNjbyACWg4T43eh4JB/PcaroOkGFi6zPAuB5N8BtgPCr+7B6C2SqYrDelFIvsRe 5Bu8HL8DzFBG3RAEQp8Qk6fgWSwcigi/Gk/wr6YVPhtSrMxmHYHk3zoi/XrWMcLoOUGsHnUY3UkX IvkG88avRJN8+4X8aMRTGg+LNhOjeDQev8VwZ/gZjVLPtFIk/w6wxoNwEaveIpnSo3Bu6Hz9cueB CcsAc5NRNweB4NNoMMGwfg3kDMk3LH7DQ3OKlTmtIzBH9Py6cz73CYHZ1DprbY2hZ6hayitJZS30 Ce+RiibotcbCQcSFlJOCG13lyb8Drz6cKw0My1J+g3yDduN34PnIBBqIAHqV67ZEXNwbWKzM8n8R SP6doqZQWLhwbo12a49TlK1MZigRCNqtZq1Kwdzjseoh7U1EIPl3qmutlWdbXaY6T5nesCLQloiH NbOZrwkjkPw7YcgyQCKQCCQCfUEg75/sC4wZSSKQCCQCE0Yg+XfCkGWARCARSAT6gkDyb19gzEgS gUQgEZgwAsm/E4YsAyQCiUAi0BcEkn/7AmNGkggkAonAhBFI/p0wZBkgEUgEEoG+IJD82xcYM5JE IBFIBCaMQPLvhCHLAIlAIpAI9AWB5N++wJiRJAKJQCIwYQSSfycMWQZIBBKBRKAvCCT/9gXGjCQR SAQSgQkjkPw7YcgyQCKQCCQCfUEg+bcvMGYkiUAikAhMGIHk3wlDlgESgUQgEegLAsm/fYExI0kE EoFEYMIIJP9OGLIMkAgkAolAXxBI/u0LjBlJIpAIJAITRiD5d8KQZYBEIBFIBPqCQPJvX2DMSBKB RCARmDACyb8ThiwDJAKJQCLQFwSSf/sCY0aSCCQCicCEEUj+nTBkGSARSAQSgb4gkPzbFxgzkkQg EUgEJoxA8u+EIcsAiUAikAj0BYHk377AOEMj+clPfvKCh81vfvObQOHOO+982O0FN9xwwwyFJoud CHSBwFxd+EkviUB7BP76179eddVV8e773//+VlttxX7ppZcWx7/97W/tQ6ZrIpAIPOIRKf9mK5gs Ak960pMe+chHXnbZZRER/p1rrrme+MQnTjbeDJ8IjDoCyb+jXsODL9988823wgoroN1IChGvvPLK 88wzTzXlCy64YM0113zCE56w+OKLb7TRRjfeeGO8fe9737vOOut89atf3W233ZZddtlXv/rVp512 WglIlbHlllsutdRSCyywwGqrrXbGGWeUV2lJBEYBgf+kSQR6RSA4Fz++5S1vmXPOOf/85z///e9/ f9SjHvX2t78dz+oeV155pbjPOuusOeaYwyOfj3/841ke+9jH/vKXv/Rq00039bjgggs+9alPLSLz +eef79U999yz6KKLevuYxzxmmWWWYWGOOuqoXjOb4RKBoUMg5d/o1/k7KQRe/OIXP/TQQ1dcccUP f/jDBx98cPXVV69Gt/fee2v47373u2+66abf/va36623Hr3wgQceWPystNJKt956669+9SsLdxyD 1g8//PDf/e53RGkre+RlzOuVUKlTLrilpekIJP82vQaHIv9BuHgztMDouGTrD3/4A9r1uP3221MT k3y32GILj5dffnnxs8EGGxCfvcK2HC3r+Y2oNtlkE1oLj9ttt53g9913X+6pKLilpekI5P6Hptfg UOT/aU97Gl0B/qX2pUkI5UPk7P777w9LaB7Yw0JTUbI+//zzhz3UFGEPDyUULcSjH/1osVUDlhjS kgg0EYGUf5tYa8OYZyLwD37wA0JrVfiV0ac85SlWz1i+/e1vR77PO+88lhVXXDEex/oND+GZH/vb kC8xefnllx8rSLonAs1CIPm3WfU1vLnFv3/5y18smtWUv0Raml/5ftOb3kSHQPn7qU99yuM+++zT uTDvfOc77WP7+te/LsI3v/nNr3nNa/jfaaedyjJd5+D5NhEYfgRS/zD8ddSMHBbarcm/cm/9DTV/ +MMfPvXUUz3ar3bMMcfYdta5YM961rO+9rWvveENb6ApDmXxDjvscOSRR3YOlW8TgQYhMIeF6QZl N7PaXATsW7B0Nu+889rna49alwX597//ffPNNxOrl1tuudBjdBkwvSUCw49A8u/w11HmMBFIBEYT gdQ/TFu95sxj2qBvVMLVPSGNynhmdnwEkn/Hx6gvPhxPiHjCEuSbFNwXbEc4kiBfv2GUtFhGuNQz p2jJvwOv6yBcvwzCLcbjwNPOBJqPgE0gUQh775Bv/HJhaX7hZnoJUv87wBZQpVrrSLMZ+L8/XlXp eICZyKgbiACelevCtizO/iFcv+HIwkNScAPr9n+ynPLv/8DR34fg33/9618sflFwOc3V34QythmC gBuOMK/mpLzI1xCeFNzoqh8R/g2C635X0xTUWZBviL1+3UrDSDc6zxRkIJMYMQRIvv/85z81coZd 6UIKbmIxH3jggVKKJua/X3nujwrp9ttv32yzzVrz9I53vOOAAw5odZ+Qyze+8Y1xr1xx89bznve8 CUXbg+dnPOMZ1157bZcB8WzoGpCv1sboPF2GTW+JQFsENCENyUAe43qM8W19huNYHbNDkOor8R99 9NEhN1TdO9h/8YtfuM25g4d49fSnP/3nP//5uN4m4+Hqq69eeumlJxPDFISdLP8613Tcccdtvvnm jue3Zhf57rnnnq3uE3I58cQT0euEgky75+gYfvUTmgdGzyk30Ux79jIDDUXgH//4B/6NFhWj+1gF 6dwxxwpVc5fE7rvvPiG54Uc/+hFCqMWTj2Mh0Af+NeItueSSbRP43Oc+9+Uvf9mrV77ylWefffbz n/98F2U5e8rlkksu2WOPPfbaay/3s6y99trufuXoiOoJJ5zAwnzoQx86+eSTDb8XXXTR+973vnPO OSfc49e1AM6nCqt9BK8hOx9TcMO3VK677rrwdtBBB/HmetkPfOAD4dKaEx+RdLBV0sbkVVZZ5cc/ /nH4dE3Bs2ebj3/84+Ey0V/NN/g3hN/k34kCmP5rCGhCIQKjYK1Lm/db8xOP+LdDxxTqPe95z5Of /GQ31R166KHiEcqJcLcwR3B2srPLPz2+5CUvcefcWmutpTvrSu7Cj06NauMqUX588W+bbbYh0u6/ //7uYHrb294W8cSvqNZff333iLpuv/Qvt+y77lmHLXz9zW9+UyruzxPVH//4R2E/+tGPHnvsscQ7 +ZSW4Ydjaxfm6HSlu0EQwste9jK3/ke68Ssq94cstthiercroqqvpt8O+skbBfYRsNZ4MKxq5g6+ VVddFdMhXysGwMKnLIgV80Jn66235u2tb33rwQcfHPH4pAIKvvvuu93Y8sEPftDKQ4lfEHfFmubQ S/gsDW+qnEbMN2wk4Ys1PmPDswmICr7++us1CxmgOuDYmhNhbfHB4y751uBe9apX8Wa00DK+9a1v iRCDa3kcEfQ111zDMq7RvnGuYv7pT3/yER0naMUjIfU9btj0kAi0RUDjcb39z372s1//+te///3v 9Qh0jIjbeg7HsTomsYaYIh5dQ/P+zGc+w78urENFQJccabS33HKLRDGm9uzyz5e//OW+WnLmmWda RjYMfPe73/XdqfBPSMJuHF3Q4UNTd9xxR7jHrytB9C/Jvetd7+KNo26o57qw1OyWFhu/S8LNdm78 uOuuu7BB8AYCcej8S1/60ve+9z398ZRTTomwNTLhKMjGG28s/z5S5XMqeMPw8MxnPtOrQw45RDwQ Qz7Pec5zuAyPmbr1N8OsGwUZoqhaVK9ujIUy3jziiCPIxSqAY80YM1Htwgsv/LjHPa68wobGZ58R 46IlhezsDlmfSMDpSPyNb3yjV2ru9NNPVwduD1Df6uO5z30u99ac8Gmk1Q7cueWacH4+8YlP7Lrr rgZtdl/T0eZUMHv3Juo4pop+0XGM3t3HkD4TgRoCmhAeZCxeRX+JZhbLcTXPHR6xnlZNWuRHO8dZ 0exrQYiiXIgdET/ZSG9i8ODFF18sDzX/MrbIIou4qZmwWV4Rw12f5AOA7oY2Q3X7kjx7a27qziYG CfBDV0sQJmvrKZIoKsfXve51sbaEXovKuNaF5fPzn/+8a/5xtHtCzFwtGpm7Rh5I3z6kwq6kpOOS sWGwTB3/muxEgVVAzMShHPWKYfFmATe8mbmPBRDChXK8NYwzKlj8IuEotojfVS/k66985SuG6yr3 teZEo4ml5JI3dUnW+MhHPiJC6w9khLEy09Y9Wlj0kFBBiGRCerS20fbmKBvmleD17R+fljAzZc49 91yNvrcIZ04orcLYTDAMo8USoBjtAddMPQ5akbFci2JUKxMtbaI50YNe+MIXRij06hsltRjEX3Px WJaz0BzRla6g+JGrYq9ZpEW6iu+x6pJlQT7Yn+fosF5RYrik1CdO9FCARzylt/JWrt4vjtFhyemg IBRHEPPODTfcsPAvfqdgNCSsscYaruIr7rV8Tsvj1PFvkGO1kFggHk0NTDqIw+gYjuFotqJlVP0X O/I1nY9HorTBjQIhCLT4YSFom/7zQDQOYTnetuak1UWvM20JmRd3l4qvxt/ZXihYUw4p2MDeOUgf 3xL5SRxUbJQeJpKwRRnw1MrNJDRf/Fu6Ux/THb2ozGTRE8Niegs37eq2226j2vLZpOjnExU/e0bJ EB4UrJswvZGv1M30DcbBRNRuL3rRiyJLEaGOqeO0ZpLGw0yU+09/+lNaPhZ5CG9661iZ0fB0cL1A D5X5L3zhC9S7QtU6nQV8azBo3S4j8nX51nXNWyRXc9RbMQAhA0fzIPNzzz13keekS5FICyxpN1Cr O6wd8Uz77yyBcboMzSwjddfColSqBvMI8w58Z8wMbam34At5tuSTivY73/kOHFWqaRTuLq+qFhWw 7rrrIl8Vo17Hah/VIMVuSVBtyQlj8KQhKa+6tEhudh+Z1UmCgjW+LsP27M04YWoZyxpQpe0xL9Mc 4akJWspQEHNAy55Jvl2CvNBCC2EQ82Lz3/322w+eWBikVJlIR1M0qh122GFtCavLJLr3piExWhTT fahWn7KteWjb4jGi6Cb8WEWn0mWhtYsgxhVMV4QPWjju+NrUEGXzrw9qWto5WCIIHqz1Vp2a/EuH y4MVdRre8Fn71VupB5EvYUXXm1ABxU/BGNn2tVaji0yW+F0hTR1h5NCRZU+py6tpt0wn/5rFUO5o 3HS4se2BosfQyt06GAYMdDQOc5ZYcg0XK7AakIBIxDQwVmlbobQcZ+qhoWy77bbGvfe///333ntv q7e2LpZxyTvqVSNjiS84tPXZwXFWL5lNvhpo9JwOnif5yvBO8b3EEkvoTuQIedbQLXqgYDLvJCPP 4DUEtDrCr/UcQ7ulWvttNJUdd9yRoFfz2d9H3BRtqQztvcWvR8TyFLlH84h1Du1Hg8GAF154oWYv ZuTrlT0PZvQeiaiaE8WFb5dQwuinOqkY8F2Zqhr7rRDGAkzJG3WtzQm0N3r6vvvuW9yrFpscULnV OWt6RjsL3bUtT1XPNTsR7dOf/rSYSfQMPW98yDW8KRSewQNW/Hbeeefh+n5KcMTU/wKXLhwrmR1r TCUDXOjLy2NYTIi0vJojisGnNcfao6HbEB2OxOTa286PckV3wXT21vatUpACyETKEvKCr5/FlKqt /8k4UmtYuNCqtD+D/2SiyrA9I4B5SQmEZXVhotNzPB0CYhOLGURUyje8L0X9Qu1Xu0+H4LVXOhSi rPU1ywM0VzWfmjEXQw4lDP/8VD3Q/slD1cVjzY+3NCe1tKpBit26S6BHC6wHFfduLARbWzVkstWz QtkNFfJ+69tpdJm2+3fsHvvYxz5mpK0NZaPxqEtoherbAKAtakxagAGDQlll97GMIjcv1rh1e4JD H2POqHpAgGrCZkoimLbd92kHbQD+paaznkyrRokpCYpOc+opUEBLCIEOl/DYQw0NWZBp0z/4CA29 zJCh0bfsxIgqumLpW9SViJC7vZZ6u4nhUJGv4ccMoJLT/7fKc+wq/X+nEbKpCxuzlNFq+yDU/SHq Aqwqsk0NflR5NpZNTVozJ5Xk3yGta+Kzbtw5c7bN0Wr1fDxP5Bbl7OI0a2bs+LGDp3Z2qHMGxnp7 2mmnufqj9lZxjLiUgJbOaQ97WNKsRVh9tB5b3eJSfdW93dTehsXu/bf1SRS1tEU7TKHZ1kNDHWlX msi/dMrDDPi08e8wgzIMecOqNtNstdVWDmq3zY/VXsqHyZBvROveIooRhj7RASfT57bJTd7RGSQa PYpLZ0AxnRMu9ntOPtq+xGBnFY2BxZl+7Yn+7Gc/S7vazU00fcl/RtIWAccCrItaIbTzp/u197ZR Dcgx+XdAwE422iACG3GcdifnOixkt1OJ1OKJU9eIzMpvcZykheAmrdhHRXtgjZusaj3aqXxEj6Zp sSWhHRO6iedWqJ0rjXX/WB+3yURDp1nyFs/a7q7pO8MiNmFRktGCGlEklJhf/OIXY4ZuZdK03cI6 CQsPUpo73HjggQdK3VI7+YV2pdyuR87FkmIQrfV3STjsVAre1qeBygK93TJxmsYGRwvitqA6zVUC ks2ZPupwrFYdf/zxdgqPpYcpSadlcAhYi6Mot7PNZkGdyGZtG9GGqka6On9hi4Ld2m1hGkvxP8Pd 1TFyYWIJDj0hIAaG1mH9jouP9Tre6PtwH2NLGfpAUuRT+5zEb6XYLL5tpUzIUUKoUBAW9wDgJnbN 1J4q2zyJqFjV1RmObNjQhrZst4ptf44q4Rf7jagabIx1+BvnOvhvl6gFehIuyZ1OA3VSa1gsYncM pOQNs7PTY7qr5ZOf/KTNMBjfzN0mTSRrw5C1LFR70kkn4WWx2drhxBQPVN42pTiD7oCJvaXI2jAQ 0eLrmk+FQuXULBCTeTnXIa1VSlESJTMypgjSco9BcZykxbYt29v1HYOlqJS0FmHNpfNjhDUaGSAV wdwoFt8Qfay/1YK3pljzUHscSf/aYRQz5AOt2git62kJqtuW4VqNTP1jV/x73nnnEcTaZq61FsPb DHdXfCaWoeJX/49+aCMkiLztjGftUEmcXbY5WnD8SzomeMaZzrbxdO9oD5NGyT+WR6CxwI2RxR8b MC0lYVI7Ru2x13DRq+Mb1tDoK7AtP/Z+BoOLxPlOu+i1e7cmxW0btnwgbtcLGIpAUTu5hN9xaJzK 59MWVPyLWULIfcUrXmE7M4rBlZb+XcnkRJ89pNjTbVgEZClSs8pYnIVt9RkFCR0O8rXfxnYRB9Zh 2D1Evfm0S4GYLyG6HTG0jrg1l86PkQdlN+NhwBi/QhVTyyf3qkvnx9YcjoB/m+JrHU1r17rM0uxr bgz/6hVMtS7T3hkBbGsOjjQNvHjNtJogph+imJB/Owf3Fs8Sx8KbJTKdDc0RFcXA0YSaOoIqQCcf N6rOHuy0L0pkvGbWTOAlbCJiRRB2l112IXeTPR015G47M7pE2TQJ4YHwWDbVl/1JcVBVcJyoJ+M+ ubW4Zw985MeZMepgBSk+jU8I2tuyzqPU0X+wP+kYApJ2flrZi+xfQkW0NZ8yXPKJo53cUTUlkxFk QL92aylgjG19SQKMFi2tlLrfCwhl/5nmUePKviQ3ApHQv2sPURCzBEA5oORYFjHC0DgMBUz97zDU wph50M0wLJ2AjeUms6iQS/jGXLY6jRmypxd0AkQGQd3TGkIouVUj1nY9Up8RS1//+tcTviheER8h lAvFAl1wLUEXBhp++HFTs80ARHUjissJ6WT4NI+2/iZyYrJFElIJRxIun7V44tEtWfb5k/5iz6Kt DqLFpGRqk8pqqJpPBTH4SVo+ncSpzSraptUvRwgYt/oVW8bTGwJqX5dhKO4M/yaOetOQkK8SdaV/ 6K3kGWoyCJhxk93M9Ok3a3N20XIhtLrm2ElN0tBkEqqG1S4l6sJiW8Sod+lVSZoUAgRP3ogSxE96 XnaSqfUrqbv6hEayejo8IhQVUZfs7zwrbxwJvCRrkz4St2itH9I8cJcWF0lYAbMWF8Fbf20FMSGw Q8Mr2XAltMU9Ajg1q4SofUuQqk8MSNtg8dBIYL3OJtZyr0jxPwiL0cJMhb5oEJFnnF0ioAG/9KUv 1YksLJMhugw1ld6m7fzbVBZy6tPqoH+oKaQmkzcLX3ZN4bi49n8ybkMAACAASURBVGkyUbUNS71r yka8bfuWI1KzFGZSj45b/SBHC9A1LdusnW53341tq/2BKpmcwrF1pGmNtrjQVhOrq1fNllc1i8gl SqNdcx/Qo+RsESGVG3L6mAQlg1tsUv/QR0inPaphHBOmHZSmZMB0Hvm6n8giWAeW7Lk45ZbVsWLA oYTQsd7S/NbIl89ZJz0WWqgWhAq4aIFrrzo8ds+nNgwwHaLq4yuzB9KWSukv+fYxhxnV8CCQ+t/h qYtecuLeOAoK+2fpRvsoWfeSlRkfxuLh4YcfTuNBo2JeMuPxSADGRyD5d3yMhtyHI7MW4ojAtuKi YxLxkGd49LJH4WBPMU207cPOd/R2W+nowZIlGheB5N9xIWqAB0oAhxEcNHBWzUYx9586JREn2RqQ +8Zm0Z5CezYsrFtIxLwOyNiVEbuSG1umzPiUIpD63ymFe6CJ2Q7BWHn3lQE7eW1XsOvW3gPsYGmL oY21UEYty1hYG2hmRiZyq4j2zPm1pmpziEU/Z09sZTPnYAGvO8gtQg5C/z4yGGZBxkIg+XcsZJrq 7jSE+S9jc4INjw6YoYwgC9sM8EgYbJL64nHr2H4MI5axKgYt2Fr0M5LZ8mEPv51tbTd+jBttekgE AoHk35FtCTYnzPq69+qrj2wJs2CJQMMRSP1vwysws58IJAKNRSD5t7FVlxlPBBKBhiOQ/DtFFZg3 pEwR0DMjmWxOo1HPyb+DqsfoIX7DMqhkMt6ZhID1QEaJo11l02p65Sf/DqQGS8colugzA0ksI53B CFQb2AyGoalFT/6dipoLsSUkl6lIL9MYUQQ0IYRbGlKSb9PrOfl34DUY5Gs3WO4VHTjWo56AJlQo OMl3BGo79/8OsBJDVIk+o9vEkbPsNgNEfNSjNorHQB5NS3GzOTW6zpN/B1V90UNCWtFnkC9z2mmn uauF8WUaxucbnG11FM3VWX05jSaSEk9YxnocVLFHN95guirfsZfHsJTHycAgEmN2NBgXHPvOkF/3 Z7rqnqNXYSaTRIYdEgSSfwdSEboQU9U86Dk+RMboSwg3pBiO+NdB4VmsOcYXOXvOXzXOtpG3dew5 uZEMqBJby1Ucw1IeW3325iJCLUcLcejZZ58YbcavxhOkjH+jafntLYkMNSQIJP8OqiKiW0Y/0W30 Jb3IhyqwnlchEZN/ke+UXcUQhJu021uVR4XGb28xdB9KswmqDQrGvPjXZ0k1oXDXfviRmanJT/c5 T58TQiD5d0JwTcCzjhHzRB0GyepCoWpAf9x1pLgHJ/g3vvs7gdjT60gjoIVgWAb/ajl+jdz4Fwuz exutK8g3Kbi5bSH5d1B1p1cw0ZFQMIZluOhUwcX4l+QbygevBpWPjLdpCMxuOLNUEJqN1uI3WBj/ ajmMR4688dO0wmV+/weB5N//gaNfD/qGqHQPJqSYiDkedSG0W1besHC/0s14RgMB7cfIrbXgWZZC wbPpd5YWmCMzq3klBTe5ypN/B1V7IZ7oJBQOIa2ECzvmJfCG5sHbMIPKR8bbNASqgzd6NX5rRZpN mNA/zCbeFH6bVrUt+U3+bYGkTw6lF+k/7GF0JLSrC81SRjz0UKy84d8+pZnRjA4CGkxIuH7ZCwt7 DIOCo1GNTplnXkmSfwdV5/oGYvUbM8Sw6DmkmCBfv9L2m/w7qDpocryFXrUczSZ+YywP4ZcL0+Qi Zt4fMYsjEobBIVBItmqBedUMLvWMudEIoNcYvAsX15g33ja6jDM888m/A28AQbWSCQoujywDTzsT aD4CIeTOknUfpmNlSuZtfsXOKkHy79TVY2HeWpJJxDVA8hEC2LYVh6TdVkwa7ZL82+jqy8wnAolA gxHILSwNrrzMeiKQCDQageTfRldfZj4RSAQajEDyb4MrL7OeCCQCjUYg+bfR1ZeZTwQSgQYjkPzb 4MrLrCcCiUCjEUj+bXT1ZeYTgUSgwQgk/za48jLriUAi0GgEkn8bXX2Z+UQgEWgwAsm/Da68zHoi kAg0GoHk30ZXX2Y+EUgEGoxA8m+DKy+znggkAo1GIPm30dWXmU8EEoEGI5D82+DKy6wnAolAoxFI /m109WXmE4FEoMEIJP82uPIy64lAItBoBJJ/G119mflEIBFoMALJvw2uvMx6IpAINBqB5N9GV19m PhFIBBqMQPJvgysvs54IJAKNRiD5t9HVl5lPBBKBBiOQ/NvgysusJwKJQKMRSP5tdPVl5hOBRKDB CCT/NrjyMuuJQCLQaASSfxtdfZn5RCARaDACyb8NrrzMeiKQCDQageTfRldfZj4RSAQajEDyb4Mr L7OeCCQCjUYg+bfR1ZeZTwQSgQYjkPzb4MrLrCcCiUCjEUj+bXT1ZeYTgUSgwQgk/za48jLriUAi 0GgEkn8bXX2Z+UQgEWgwAsm/Da68zHoikAg0GoHk30ZXX2Y+EWgqAv/5z38efPDBpua+T/lO/u0T kBlNIjB8CPztb3975zvf+bKXvWzvvfe+9tpre8vgL37xi69+9asTCvuNb3zjhhtu6BzkiiuueN7z ntfZz+TfPuMZz+i54JNPfdwYkn/HhSg9jDgCpLA//elPI1nIN7zhDT/5yU/e9773Pfe5z33Ri150 11139VDMH/3oR8cdd9yEAp544onodUJBZqbn5N/hrfcNNtjgBbPNZz7zmZJLPSocP/7xjxfHwVnu vPPOm2++mRjVQxJf+9rXSF4LLbTQUksttdlmm5GJeoikGmT33Xd/5jOfqW9XHce1b7LJJqutttqP f/zjVp9nn332c57znHnnnfcJs8073vGOe++9N7z95S9/UfDeCKs1oWlxMcG/4IILNJ6XvOQl22yz jWZz1llnVXOicl/1qlctsMACK6200ne/+12vUO0WW2wRfq666iqhfv7zn++///6XXXbZ2972tksu uWSPPfbYa6+9nvKUp6y99tq/+tWv+Pzwhz98wgknRJAPfehDJ5988tFHH33RRRch/XPOOSfc4/fr X//6s571LGHV4/33389RDt/73vdqHs9//vOvu+668HbQQQfxJksf+MAHwuWVr3ylmuLnaU972jHH HMPRoLLDDjtI+ulPf/oqq6xSKvdTn/rUs2eb1t5x5JFHrrDCCmI4/PDDI9qh+AVBmuFEYPHFF48m svHGG0cO//nPf84999zhaEY5BdleZ511JHfmmWdONC39KvJZfuecc049c6LxVP2/7nWvE9thhx1W dRzXvuSSSwp18cUX13ziiDnmmMOrueaaa/755498rrfeev/+97/5PP7447lsvvnmtVANelSQm266 KTL85z//+XGPexyOq+YfL++zzz733HPPF7/4RQMQOsbCSCr8wAe1aXKYa80117zjjjvwqUpErJj3 zW9+89Zbb83nW9/61oMPPjiCvOUtb0HBd999Nxg/+MEPSrQkJ8hjH/tYegx6CcMhbzgd/rvtthsy 3XLLLV/96lfzfPXVVxsnrr/+eryv/VMdcGRZddVVeUO+MkAaEFat4fEbb7zR+GoU4Q1Ho/Jvfetb fGLwz33ucxwR9DXXXPOzn/1MuX77299qBksssYRQXg2DSfk3+t3w/i622GJaW+SPeKI/cBne7M7O GY3h+9//flZir/7mkdj+0EMPkZ4mI1Hq0oSybbfdti/F/9jHPqYHYtg//vGP9A/HHnusaL/97W9f eeWVfYl/2iNBVbSfsoFu1lhjDVLk8ssvX3L1y1/+8tJLL913330XXHDB1772teiJfFreFsujH/3o RRZZ5DGPeUy0ukUXXfQ973mPIe2II46AlTotPosFlaPahRdeGOMXR2xoLN9oo42WW245w3BkzLB3 1FFHrbjiikgcRfJMGD/99NOJsE960pPQrgYfMRx66KG87brrrjIg5+Hzox/96DLLLEPBrYBcPvGJ T/Cw/vrr8/n2t7+d0BBh/Ro8fv/73//hD38w5Fx++eUiKa+m15L8O734j586YUHTiTanwwjApRrM HJN4otFrr9p3tEUeSKBaPImDiLHsssuSL0477bQSkLBD6CAvaPEiPOOMM8qrYjHljJmdKZs+w51I pSdQJs4333w60p577hkTyRIkLB/5yEcoVWkePv/5z/O29NJLUxpIS/AvfOELnePB0WuttZa+TbqR bfbzzz8/oj311FNNfmOmzIWsREWj1OaqcvKPf/wjvJGPoshmrDIQjq2/t956K8dXvOIVEEBVu+yy i05rxm2Eg8YnP/lJb418UIqw5rYvfOELdV1KFWwSjt/85jflkEj+6U9/2lszdO5tfXLvBvOIto+/ BHma3+23374GheITEovgT07UzKrp/utf/6o+hp3+JyYNGBZopNSqH/Vbfazayb9aQrioF4zP/uQn P1kkLGKLhkQXhNkxvjz/7ne/KzHwGXYNL3zy88hHPpJjcSHsG/XxPmNcqRaHtmS77bbTTfC+mhKk xDzNlmEQwjMPbRHALBoHLvNLi8ePqZaGiKG4hP6BRi/6A3Z7/OMfz11TRtY8b7rpph5JN0996lOf +MQnsjO4zCtTzhAByDUkiHhFEvGqapBRxKnnUMZ5ZcoZnqlNo+cQrAhB1VDsppC8EX6r7rwVnx3i eelLXyqsbMtbKFsU8Hvf+56oqvoHM1MzUD7lDYGyyIn+z5vO5pExJgn7qEc9ir1V/7DVVltxV8A3 velNX/7yl/X2klujhTHDW7itu+663CklPUrRkn0U3Kycu87MHXlFLVx44YVj+ewS85KHvlhOOukk NVW0ENU4TcaBHIhxx3cUDsY2smd4E1Zh2QmkRikW+oeVV1453sY8hqqByKnI4cgbxQK7hip4OMYv VjUHCrv5kOowthVdh6GUWsBbAycF9H333cdOqxCR6AhmURFWcyXAVsMSESKsYTh0DnziaHljCf0D tb5R2QhtEcIQ8pWvfCVim/bfWSrwNMOJQPCvXqHb4wiZNOYTHKr8qzHp/+9+97tJK3/961/p3TwS 2XgO/iWs6WNeBScSir3ab7/9eNOXoo1iXo9YjLcaFFX9r07CG/ODH/yANyxPWvFoDKiFCkI0o6+5 x2PneIJ/CZV6y29+85t4VC5hq/yrc0o6BiFdi8jj0eiiY7OQjEjQgpTFulb+RUAEQJ6LefGLX0zy jUxW9b+0EzESUE14GwuJUnzggQeCf5GvtSDCIBIfy2f3mEcGJv+r3o0u9iHAJ4xJSTVaDSA0+7/+ 9a+NNAR/QrHx26+wBp7gX37UgoD4lzoilMimREY+jgpuyo/vhCJNB/9qpXS11bRMy7AkKVhDpQmh ca5yaOFf7U2VCXjLLbcYHsLeJf+aA5n/yQnz+te/HuDiCf61QmgGEIONVxFtNXvTZU/9Q+l9Q2rR H8z3aR5iOR5HlIzSZxFtPGpbGIfPWLwmIBQ/ZujkNa90No4Y1q+m75eQQkJkMTUTnNDRec9mREu5 ZjFEKNQf5BixcSlGcuwheBbHYukmnje+8Y2ITI/deeedBWzNWGzqpA5WZEvhwXrGKost/Jvhog+W HXfcMcpYUi8Wvdo6D4lVR1UQgxyQDV1kruInLIgVN80zzzxIR3I4F+Ga3goeHsxq3/Wud9GW4KCx fPaGeS0nE3pElOQ+yiXVEYYQWo2BJlfL0TDAdeCBB+JWsyizB8RKU4y5wrORm3JWjXjkwSho3KKP im0PZjk//elPuWtOZeYB/AMOOMCsoiRHbjVkCmhiISGey6uqhfwrV4RxWn7Nkj6h7Eipemtrt0+D PGGHA/U0C6GkeKPlNwArkZjpglFweTW9llkzuDRDjsDqq69OmrCdSz7Zb7vttsiwcT4soSVgD8vf //73cPdbFHwxQQ738FBCmenrEmKrBiwxFEstFPfW5MKzzqaVBxWW4JSk6ImE0k08RWES+ae4KPGE JQYSw0a8ontl9G2iHA9Uz8W/ohV7sZB36DQ8CmWKwKLH0kiQmmmosXbxyRJpIeiSDaTDPcR/Fn0+ /HfwWSt1l5hHtL390jwoZoewZkhEV+M6YioqUQsGdAsGrTJ84lZzBcL+d77zHYOW9QZirCJHizL2 mKYQ/IuKVopGTWAWfCIPNhHjU1UW0yNUiLjjlTFAJOyvec1rzHUIFpRmHg2N2pjUw5vfsrxRwipm hJVn+nfF4S3mhSzxyGIIofewrGcS6XFITMq/Q1IRnbKBc3UkWgINOsTY8G0rZTRlrBEu5513HgsR tVN0D3sIz3x+//vfR77E5Or6eGsMEa35LEnZW7M5HZKlNblYXaGzLqqGc889lzyiB5pUdhNPqBFE bjuR39Kd2MMQNlnofM1kGVt3qRfJX+FTPySH8kBMri7j/DfwIx6BO0hYmLfsXUXZoaIhKhZvwV+R lik87Y20KBmlRXKMRXyeQyPM0sFnlHqimJecDMiisPirkG+kgqEK+YaLxwKLwuLr6nDOpUq+EUSc qLaWbRQZLbbmXn3UyIN8OYZaqfq2s12uNIBoAzWfhmHq5qEi31k51MLSDCcCof+lcywCrwVcWa3q f2OPuraFTWLGrU5jkS30v/SYUTobNr2yWccjWYA055EMQlSJrsXSioNdE7wRSWxOIv3FgVFbkWxO 0Am9kknEVAtIx0dn4i21AAnLfJadsaDHZ+d4Qqche+a5ZT5rCUjAqv7XPn8REo7sYCWuogASpQ0G JNDAje7ClBkLBFO06n8POeSQ2ZmaRZo2rlLU8MkQAKVlr4W3IqHf9BjqZis8QoUKKJakQv+rjPyE Gctn95g/HNPQ/dPDfPaznx26bDU5Q8m/w1t7hX9lMex21bBX+deKCscif6Gb0kM68K9IbJyqChdU qK00yhsVXswiKeM8mugZA4K2/BIo6EC5txoysiAlY/jU1jFSdvjsEE/wr61vseGUDEUhiLIFrPKv RztDilBG/opRh7sRC29GJq1bUm6yt/KvOI1e5PFSHJGccsopkUNz8BhgFJ+LGXEI9eHZMhEFC/dW /h3LJ89dYh4ZyN+ZgMAcClnaX1oaigDqtEKFKYhytZljhxJRINCO2RdVtnC19UyYpRslXZbt9LjJ up9JIgVI2yDFkdITQUuobRJt47HzgWbWngqqwFg0r82OS+QsCJ1cyYMpZ+F67lIEiD129H1V/612 ak1aaTlBvhSdMS0Ib7qGnQ+KXwYqa27W5ak+x53GjuWzS8xb89nBRQ1CoK2au0OofNWKgGYwbs22 hpqUy0wYZLKMDUIg5N/WPW0NKsJUZtUuPXono0hrouZJpg6t7uO6OHVmPBvXW88eTOYcEZ5o8DhP YXox0YCt/i3q2s1i8sQg3A033JCKjzeKrB/+8Iet/gfnkutvkxq9MnAiML0IOINLLdN20mMHmC2x 05u9tqnbihcLlW3fTo2jrYqWChizH/dU2PcmXUvElkmw7dTkQSrJv1MGdSbUFQIOSTvZUdYSuwoz Uz3RZlgejIN8brHAHZTmLs1xQAYk9mnEDlznHei17bSzcdsJN5ct0I9bHogtcRQ+fFpatGuwumOX 7sWGEPJmoLvTTju54KaKdOt9ZvbhWBKww8H+PHN5nl3W4xiOtU3qHfI4ZQ5Hi7exY4wUbLpDi2Uz CRL0qrUU1RS7sZNknQGhMevGMz+0dgYwK7fs9i9Sstlg12XYyXtL/p08hhlDPxEwOTX5NTHsZ6Qj Ghf1vR0gVPPK58IKFoxm10ccWiHZxc4ZW2VdSeG+IZsXrRxiHNsB6dbjLg7HYazZfulLX7I5F8lS ZQRaViaJ1XEpD3LE0XHuJt6K2VEUe7pxrjm7+x5RKhfHsuWK2t2KLp+23NrDS660OspnHB10agb1 i/PlL385Lb/tj5TXVmvbliKS6/4XgdKf0NFTJsQhnbZhrRxYNWFkRvFtSw9vBPOym7NtwP465vmL /uI5TmzW3PmoTnCq9nEC5+uZh4D9cKXQYZ+1Re5hR2uPiCY83H777bHT2YUMcaKkBGShi7DXkLyM a1wXab3OnkLkGH64GPMYYrKNIuXEoGNjTv0QTu3Cto2EDFviRMeoPGjLWTgnMuzYk0RMXERo8TNE WnulQ6dvpyA2jx2N4nGs2Q6T0JDYiCJybNi5FCX1Vgso4gImArg92uRZO7tlDz720jhuV11ZFbxs bWQ3aeAn4rSnm2qiNf4BuST/DgjY/4k2aLf6WzT6/+MvHxKBFgSCbWez7iwuts0j7CwINDYmcrfU RuREJc6kuBbDNTrVmGJDHjHTrpXYT4KPbF4MP3HZELsdIA5hF2GQGsHdOk6y2BONi6sR1u4zw862 +hUB2aKWGUzoLkrkqDAuk4p4bKEhmJe9JXoHpUHnUlQzULPTIdjxwpEYjsrh4ES1E8k0KjZ305xU L//jzQkdChkWh+tcSkllQZPj0dnlGDbYp8CMDv8a2+HVeuRmCkDsnISGxQThssgnO4tQ8RuvOkeS b2cgAmVHXVj8FoOCNRu/oWYFjpZPSqU/pVUwlw/NQwFNwGJvtWCc4EGEWO7b5A1ZOxJJdSDmoKcS 1oZCuo54pK8nevNZvmFBjMW/sYHal0TCm8iru7uoicngRadsPzXSVJxaKWK0KOmOZRF57ZUIaV1c teMoUFxeUfUArpCIDTn05nEnCQ8ALFOKqv8B2fvGv04oGe7coFrLqIHXtvPWI6o1bx0etTO3H7ie te0ibwnoZBeNlUGvuPTd4jQtDZfW1n3MGJZRBLTLWH8Il/Ib5Ou3+zjT5wxBIEjTL54N5sUaQRzx ytFhXSPQMM03iXb6jhTsjuaYjHcJFFUALS2NcGhyY5UswhJ7SZHuzSmCdrhLiKoXy+vgej2CKy5E SPIy7YRs8+yyR/K4/BBFyeYlS5QkpE73dWB57OFsN3G+tRQ1/rUqGGUXD323bWQlwmJxp5JFP2oE K5MGj3L8snioWYw9NkKEI6V5bepQ89zfxz7wL7Hfbk2V0fZWIXtN4qrZnvONqiyYalWd+bfn+AcX sHCrBh3kyzLuiYDB5SdjHgEECGh6BNmNsT+B4Ek/4Jy3PoIryXrkTetv5QKjbopsBYyEZOZORYvT y60dwlJBOLjY+v3Ncp8ZoVUQClYDA87l7pC6XBXBFoFytN6F16p3krmYzYBBO0HlSvNLoSy5cUsh qlIinBNnQYsLi/M+IqEEp+mucXfVW9Xu6g/iM2YnwDlfQx1RfTtYe+GIni106lCw60WZWyOxvknR 445kWnzDHdle9ViX5JOS3idDbI5RhYbQuJzUkigIIh522pnQRtkfo5JK/IjMjX+4TBOMu8nlwSY+ n0pD9+ZQxluezYOMCvRBlgVsK+HSNifu5ZMTB0z5pEiKY7KGREuohncbdOLG24nuS5dJq8mWenUJ tWsDuSauOksp0pIITAgBjUePMNHUnHQHjZyI58MWEYmDcKgzWn730VIKi1BP0eBbQ7n+0XJcXIje +pbGloequ1k/gUzLD0cX7RNFxSz+qrdilzQ2MIQUl95KUYKXpItL9xb91CKkDtt9kEn67BsXmP63 5d8460IKNlwbl8xxDJWmKvKtbuiAbEikNjJHcLszR5Sq/qJUxnB7WdCxZoc3DfultC4DM+qasFBu 2E9DJ4B/bT0xitKsG1StxvLsbgQ3YxmNPZpDiaFtToSVE1twnHylD4pLAGQPm8uMO7kNjJrahPhX WpqCzqCfBPmarMWKcylFWhKBCSGgI5BmULCxHCdqWlq+3QUTiqTmOfi35hiP7rfTC/SOtm+7cQz+ 7cbnMPixnW6Kr2bvg/5Bm+jGIDhndUxSMDVZOIKMtTelGiH1kEe6/FAnxSv3npB/8Sxj52NsWjT/ Ut88uJvKXU0sThaakVkKsCuFS2h52uaE2GuqJQjO5RNjEiu0dXRsbKDIt3VxooohTSrUDkR7RGyQ jx3vUYT8TQR6QEAT0hEYXYkm1OEFk3pCqI3APcQmiC0HsYO4NbjVMFe76Rqtr7p0ccoj+m+X/qfX G8119ZalKcjM1PGvpU8tRpEoZUzwo2zYMyy1vSnhiLzC0vpb3f4SO7f5iU02LAg3mI4Eik9dBI5/ SyRtc0LzEB4iLKGbAFv20xA0UPmE+FdwJihYQYwQKDj5t9RCWnpDQCsK5vUbFro1lt5iE8rW4LHC VvdCjOWns3tcwtfZz/C8re2xm4KMTR3/llXLaqkoXOKxujcFZ3EMnWnVc9VOmRBHBjla4vTIUmuF WI92zEfLHWhBf9QUEUPbnNQcycgUJhZD0bFQxGFLHCFTRyRd/qJg2SD/GgnIv2Xg6TJ4eksEaggY wi1EM/QGmpZWqo1pvSTims98HH4EOu0KnILc25uCmKgFyt4UUwAaYUnbkhIZ0LA0r5rkaFGOB4yG hSkx2k6+kCalLV2z4HGddvclIo/TXEceLJrZ20hz3X3w8DlLAJ5tlNEAgIVleKKRpP9EoIqAhhRt CflqXCGsVD2kvUEITJ382xaU1r0pLgdxkMaGBCdqcLFQ2JMSyv4HSw0hjXK0Hc3GCUph479FtnI1 bTUVy3cUzc68W8D1CR87Jaqq56rPVjtRmorZfMQel9iXI57qvpzWIFWX6BV+Gf2ECfl36vlXBiwh WvcjvDO2W5pYhDE+mcxWs532VgQ0P5tM3VjImBXRU1kPMN9yUYAmEd/9bA01OBdNKKZTWlTwryoe XHIZ80ARmM77132NxqdcaG+t5Bb1q9JSthrhbTmolrztCgNmFLCmdqiGYicgY22dBwmKpPplxprP 1kdtndgriQntphSPLqFvKIUYFIdBefjO3honOKagw+BZapkwtpfTs6MMxvYaiy2GK0ahzGFbS50u NQRUnxNijEq0icVVA0Yy0oCtphqwQ1w0sHbj1EIN4tFc0JSRPGEk0KRVJa2aMUA9GicGkWLGOVAE pln+VTbkyFQL2eribVsNw7jfXxDQ5uKIHE1PiHyF0rJ77ldBslhYPCH/xm9kZkC/ZCKca8elDcs2 w5s3mEnUTi4NKOkRjjYaZDSk+JpRFBYjO2pldcHmcYOcHGOLCwAAIABJREFUqZstNLXG3HdYVDGj LaXw23dspz7C6eTfZu1N6aFuCgWzMPoM00M8XQZxqaAd1sYYRECfnrJtl7j17I0EancNo3KBb9hz 0NaNtxRog5NGC+2GpefMZ8BhQGCa+XcYIJiaPMxm4P9eu9P3FO3Gc5STqsQyY3ydt+9JZIQdEKAW sCDM0LO7CcEeflxsvaFDkJ5fGcKTeXtGb9gCps5ogDUSnOtXGvE7iMScHsS5Dq2HOnIQSWScXSLg dgLHL42FuPi8887rMtREvdXaUjSziUaS/ntDwG0Erbdh9BaVUNMp//ac6cYFjA4zCLHFcXvHTzWI yRxSGhCelultU22N3FZCJ8LjcsLWtyPgYknZhkWaYlw8oOlIcG6NiEcAuplWhJR/h7fG8fXJJ58c Z6bb5hLBWVtzwGQy5GsLmukzrTFjR4Q9EieddFLb5CbkaGuKK5lqQTCvzdr2YDhYZWHT2mDNw2Qe Tcxt6phMDMLaMN6XQ1DK7iJz33pwv8wks5TBJ4MAvbw6nUwMAw2b/DtQeCcVudtAXN3vQiKM4ExK q7Bz+OGH29ccH/uaVEqzb9XSTN1t6Cthlo9slZtkhG2Du8nFCUCnCm3PUCLbBnx9q63PaXGkPbc7 sFzFPck8qBoXe7u8cZLxZPCeEXDxAEWQ/aP2CLqS2L6RnqMaUMDk3wEB259o7SAmn9rMoBnZ4eSq FORVoja2+2ZieeyLhXrLllI7somTboMlqxLlXDInckKrC7EiFRutXBuIr40NLljRvt1U55Wpt6Un ZxNkG9Vuu+22DtG4XNRNLuJ0JasPNcaZBZtYfaeLCC+ULVzu1nAFrbsIbOri4tZQPt2dZOeym49c UBu3I3klDzHk+JiN25Fc6e12JO5h2vp0jpFCgGgf379RNMX0QQdnIx8ON+tfJqVYdZmk3Xjj+2mT jCSD94yAGaQ9KjqRTZlOGzhS4I5GVx30HGHfA3ar/1UAvUXy5qptM5HuAUvgEOo5/dyQi2K0ACYo iTfH8AqGHXC74oorQub1SwvBkIjJvC44ttXBwT8M2DrHLzFPyGJXv/1qTovgdBuH8RrisLLngwhE VKwaabmK06XMxgBXcaIqBcFrruu04m83oTtCvaKS9j0FZ8bcHuerCm6niwu8kR1ZvnoZf2Re6SxY 8eaDCBifEKqTuP8ITUva5c4ULDiXvEynYcc3D2uuuabjD+4adacz9pdhalb0qsg+6lXz6cyLr6L4 qo3q0AkROrVA3Dh+/PHHV1FSHKNIfBW46t6z3ZBJJSJOV4z3HEkG7AsCzs6Ix1CtRSFiSyblS6B9 ib+3SLrlX3eGxc7zYITWxNI9MAkc/Bp7Z22U/9esmx/wGmGQ9jP25FY5qANurTv57SrlnzvWZvHY +exfazWN5UJZidBlFYfG/f+GW5dguJRZEEcPLCW5zMjd+VjMK4KtPBDMcRbCco4c24aizR5Y1Iwr aZNpe2XSvfgsBFgjEFhqe2ORLA6NT/a6PtTmZfwrUb+W73QSO2rhRsdtkKCQIQr44C6+pisgnvNJ BndZqA/YsLf6jILIv7fI14kJccINrXf5fQQBezaqPjLZcwy1gHHDas0xH7tEQPNT9XF1cpdBBuqt W/61WsIMNCujFDlyxFP6HsaJw8eqHD0xZMOq/Nuh1NoKruFBiyFOOgGIm9xoUc5qkz3JoX35XIql sLgfzslaegDX2weBYmQZ8PE9jtLVBlxRrwgEYUWjf0Cm4cdFGaFYKGe1WYJqcSKyxn3Of1955ZU+ PBOlJs4blpSCnBguhiulDntcSqvsMURhfNKxXROYmlDpgHVpkNVQwtZ8KoiMRSapHeIDNlymgHxV dww5Y81yoqTd/4rHd3ytlJLgHEFWBIOxskAYUN3HM0N86h2+Mx8aLVhpJz7+oBNVP0PXAxR6tElV BCS1UHH0EEkESf1vz9ANPKAehcTRouk/qc1XD0znC/lKntb1hBNO6G8+zOJ1ZkRJnyBpmlaMb+1C O5MQaqNCNRggU7/ON7Pww4KUawK7eTcjFCF6gw024H+nnXZC06HzdWbE+pvIlcKSV0wPSbh8ti2R 5Sy71ki+RGkeKMR9+Ao+CI6CuBqq5lNB9EBJy6fbGyh528Y/CEcfHFC6fpHvIHI48nGqeuOTszAU DoZDKwGTJF+ImeHN3i4068ctYJPCkHCRpu8IEOKwDI0tCVGfp0g1wcdidE9qq/vkfBIJv4zl3ytz W6LoWB66cSeByhLdSPHsGnsfVLVxyslaXObRsli8VSIkS4kWj7YxvOhFLyKQRhCOGjd9Agv5lNKT NpbaitBKL8zRJMD3AGmBOZJ53TDHkTGuEOiog10tRlzlosNYJ2HxoR1DzixP//nPQQcdJCGcy06e Jcxif+t74iTaMGSc2R7/xycX36CiEiFou0RfSas+w3/5pUWxpa88TsZi8R2wtOGTiaQWVoTkX7ps yJupGJLtVIkS1XzmIwR0Q4sEOuDQojGd959pTKNq1PdY+gc3Z3rbr4JbiCOxoktc2a84q/GgD0pY jFl1rNlxFgVxTfgNP0qKT5FmVec7Swtz991xd2iJCs8SVThWfZa3Y1nQOrG6XLE0ljfuIpcojXYH P3185Y40eiFaaWuDfYw29Q99BHMYoupW/zsMec08tCJgpxc5y/Tf3Nz8ekLk1Rpbq0tV3dH6Nlw6 rC/hi9bPf8XcrRYbcZipOY772D2fUtJNRk83bk6qHmhRLB6aJfSXfKtJpH00EEj+bXw9upnempit /jq8DbZlVarxBWtgASgEjIJu4SHO2/X8oQ99iGzO2PESlrB7bHsyu4ElzixPCoHk30nBNySBqSBQ MM2gDz/TctqkRR3Rd1l4SAo7nNm46KKLrPBYJvU1Yop+mkczEnf/h2G3Fl/s1gDtZmnl5cLRU7A3 YzhhnGm5Sv4dnRq3M9T2GpsNnCG24mRLgO8yOC5ho9LoFHKYSmLp8uKLL7ZHMK46M+zZlexcX+SR 4qVV9xKvqMUtb6LjwtE2ilih/S9b33knvU3h4qrsLDhFdklimMDIvPSCQK6/9YLauGGmbP1trJxY /3FoGDU46EUitk+AjExZzBLfHyJhTf62mrFSHzF3Gwxsj2Ns/LRtzpqnvQdWHX0P0IEUgxw9r30g fSy1tAoXF47m4ryfipMfe6upy1Gz3RrFBGWncqOPFTHoqJJ/B4LwtPNvKZV9Wma+8f1NxGEvzmwm +YudZLpxOexQ/KelhgA1jg2kxirGCp4FScOYwcw5DhvmplhREPsfTGhid42qtFPbHkfSNJ1GUDYL D4WLa3K0/E9xnmt45mMVgdQ/VNEYQbvDFESz/kpnIwhTo4rkLIwdgWOdfzP2Y+Tg4pCd7dK77LLL wm5DIRKv6jRqdjHz0Cg8GpzZ5N8GV15mPRFoRQB74lBmrJ0wpOaqToOdOqXwNYHaZS+k5hovFzk6 d260Yt6zS/Jvz9BlwESgkQiELsVKQNvcO7cZ7Fw42gbzYmehhClc3MrRU7bJum3mG+eY/DvYKiOM MINNI2OfYQjUWlTtcZJgEG9d8sm0jYdywzHCEJb9omMrCi5KDbtfimkq5lZeDsouVzK1jXwGOib/ TkWlRw+xktPfrjIVWc80hgyBaEJ+w0xx7iSKQxn34bVN2hYRKuYiL2Nkq75+w1Bu2LYRXNyWoy1X tI22Z0f3RLvMul86E7c4ue06Mul6LHMIV6O4fqTn7CX/9gzd+AE11pqnVpeah3xMBLpHoDSnYuk+ 7IB8ugYEKzFt43fzUaHmsLhv2nVCxZH6oi0vo2zuPexkpwSnUXHrnnOJ9rG0zdWEHH0rIL5baO+Q ++3cPe0uyp63lCT/Tgj83j0bLVP+7R2+DPkwAlpRmOHh3IezNv6/nRsuY2LG8mrnRuFiIrPLm1wY HbIzd0xKuRFcHEJ01W7JETLVmFGk/Zd+9913X4Iq4/LfuOe66q03u7Rcx+ouSnlO/u0Nw8GGKj0k moXfuEV3sKlm7CONgFbEaFrRuuJ3ZEocyo0VVlihbYnsWKfcQMeFo21sL3ZXcaLgKi8TxmkefAaB VkSEPkN18MEH4+Ldd9+97XV9bROtORoDIja0S6yWVfqNmp/uH1P+7R6rXnzqKiH5Yl6W4N8R6zO9 4JJhekUAoWhITLBwr9E0Mpyjmy7bG+u+PcqNcgglONrJIz0O/0Zp0TfLIYcc4r5pV4P6flUPKPgC AFMCuuuj2HuwJP/2AFpXQWbJJw+b6DDU9jRQrihzDbk9mJqFCwTMjxirxn05imZ5OjJXtRS7V8Ve LF0VZsZ7UpOBQbF4jOqtuVc9TAY2xIFhsa0LjvGOX/vGKEC1ohjLvQ3TrxQnk9thCAuWOIpdMkOz HF/wChfdkNjrqwUrr7xyz6D5prXvZolQF/ZhWbfc+RRLSXGiluTfiSI2Yf9BvhqHvsRQP5nCoD92 r5CvR+TbF/6tZq7KsMVeLFWfae8egdJvi0XYqr37qDr7xK2ah2aDebWZwsIxikej4kfSYTrHNjPf koLJOsYtnOuqaN9ddSmVT2XHBobeMIG5ShHWF1vcdeeLNtQRPWszkn97q4VxQukSfPjVT6IjYVu1 riOZJZF2vfLIEfkyaJHjOJH243WVf6v2fsQ9snFEbZbi1R6Le38t0XKi2SBfMydSsPbDEmN5ULDM TE1++lu6qYkN29octs0227gFEF32PdH4YkB8lKu3yJN/e8Nt/FB6BeYt5Ksj6UWFfHUhtMvFL8mX uxiTEMeHdWb4CErVSJigYL/4l5zlFwUbvL2KBpb8O1ajcJD67LPPHuvt5N3tllML7iC1C6232PL+ s95wGz8UViXSItZZ8u2DD5oB0fYWE2oHvzwwokvyHR/TmeQjxm9Crh6ObRm0G1qIkII9MkHQiDhZ uImtI+XfQdVa9B8dQw/BxfqP33Aky2DkYF4czSDf5N9B1UQz49VyZFzjCQoOnkW4KJjRnLSiooJo ZhEz149I/h1gIwi2lYCuEslEh9F58G8IyPEbb5OCB1gZjYq6CLNol72wcNCu5sRwLGJv8d+oUmZm k38H1gZ0CXwaUoxfHYYLg4LZybyYl4cUfgdWA42POBqPBsPCsOBcRvuJgTzcNarGF3WmFiDl3wHW fHQMv/oMnpWSDlPE3iBfjizMAPORUTcQgdJ45L1QcLBweWTxNvm3gdX73yzn+ttg665wK9otJhyr v4PNRMbeWARwazHIN+xol8WjYsVvY8s30zOe/DsVLQDzSqbKxZFqoeCpyESm0TQEkKwsB+dG3muc m+TbtCqt5zf5t47I4J6DhSN+zDu4hDLm0UMguDjKVWXk0SvpjCpR8u/0V3dy8fTXwVDmoMq5Q5nB zNRkEUj+nSyCGT4RSAQSgd4Q+J/rinuLIkMlAolAIpAI9IBA8m8PoGWQRCARSAT6gEDybx9AzCgS gUQgEegBgeTfHkDLIIlAIpAI9AGB5N8+gJhRJAKJQCLQAwLJvz2AlkESgUQgEegDAsm/fQAxo0gE EoFEoAcEkn97AC2DJAKJQCLQBwSSf/sAYkaRCCQCiUAPCCT/9gBaBkkEEoFEoA8IJP/2AcSMIhFI BBKBHhBI/u0BtAySCCQCiUAfEEj+7QOIGUUikAgkAj0gkPzbA2gZJBFIBBKBPiCQ/NsHEDOKRCAR SAR6QCD5twfQMkgikAgkAn1AIPm3DyBmFIlAIpAI9IBA8m8PoGWQRCARSAT6gEDybx9AzCgSgUQg EegBgeTfHkDLIIlAIpAI9AGB5N8+gJhRJAKJQCLQAwLJvz2AlkESgUQgEegDAsm/fQAxo0gEEoFE oAcEkn97AC2DJAKJQCLQBwSSf/sAYkaRCCQCiUAPCCT/9gBaBkkEEoFEoA8IJP/2AcSMIhFIBBKB HhBI/u0BtAySCCQCiUAfEEj+7QOIGUUikAgkAj0gkPzbA2gZJBFIBBKBPiCQ/NsHEDOKRCARSAR6 QCD5twfQMkgikAgkAn1AIPm3DyBmFIlAIpAI9IBA8m8PoGWQqUbg7rvvfuihh6Y61UwvERgwAsm/ AwZ4uqP/6Ec/+oLZZuutty55OfXUU8Px1a9+dXEcnOUvf/nLzTfffNddd000iZtuummTTTZ57GMf +8QnPnHeeeddf/31r7766ogEHYvzlltumWic6T8RGCIE/pNmpBHYY489orU96lGP+vvf/x5l3Xzz zcNxySWXnILSH3/88ZKT6ITS+utf//q0pz0t8rnQQguF5fGPfzzOFc+f/vSncJlQnOk5ERgqBFL+ jV484r+LLbbYgw8+eOWVV0Y5L7vsMi5DXuZzzjnn1ltvfdKTnvTLX/7yj3/8o9/555//3nvvPeaY Y4Y855m9RKBLBJJ/uwSq2d5WW201Bbj00kv9/vrXv7799tvDpZTqzjvv3HLLLZdaaqkFFljAqzPO OCNemeavM9v84Ac/2GyzzZZeeulddtnlmmuuibf//ve/Dz300Oc+97nzzTffcsstt+eee95///0l zrCI6pOf/CQ70pdEOF5wwQVrrrnmE57whMUXX3yjjTa68cYba6E8hm5hlVVWeeYzn+nR77HHHrvN Ntssssgit91227bbbhtBNt100x/96EfsVBMbbLCBCFdaaSU5+cc//sFRftZaa60NN9zw2muvpcrY Z599OCLxXXfd9VnPepbyKtTPf/7ziMpvNxkrntOSCEwWgaGSxjMzfUcg9A/vfOc7CZLoSfynn366 RnPYYYf5Df3DPffcs+iii3p8zGMes8wyy0STOuqoo3jGsPFIA7DCCis88pGP9IgB//nPf3pbdMrP ec5z5pxz1li+xhproOxqKU488USs7RUd7rrrruvVWWedNcccc3BBf/QJLDS8xNtqqPDmFSPbxx13 3PXXX19ipvldffXV4y0ex+zoda655uJiGDCEsMiJzFM9s88zzzxLLLEEy1ve8hbzALllV6LI2IIL Lnjdddd1n7FaPvMxEegZgUf0HDIDNgKB4N+9997bUhuiQWG77bbb3HPPfeGFF+Kg4N/99tuPfeWV V7bNQKEwr0csRgNb+Pfoo4/2Ck95xdxwww1lKYxo7BUCtUTmFXqtIVPT/4Y8++53v/tf//qXJNZb bz2hiMa1ULK64447zkrsYYNDDz74YJpfPmv631e96lV8KaZXf/vb3xZeeGGP559/fvAvOw9XXXWV Ap5yyikel112WQIyzzvssIPHnXfemb3LjPGZJhHoCwKpf9D7ZoQhMOIsvEkL8bznPY9IWIpNfmQ3 PacQYNluu+3Iuffddx/PxQ8tAfvyyy8fEivevPzyy7msuOKKq666KgvyeulLX8oSsbG0NX/4wx/s avBq++23lwrJd4sttvAYsVWDkJHJzlQTRx55JC2BvP32t7896KCDwn/VJzv51y+G9RalGmA8XnTR RcXbIYccQpUhkvCJ3BWT51B9GI26z9j/sXfXAfMV1f/Av3bXz8DuxEZCUBSTsFARMTAIURAQsACR EBAUFcGmREFJQULEQhARQUVQRLELFbtbf6/Pc2S83o1n4959dvc588fu3LmT586858yZM2dKnulJ CoxJgcTfMQk4M8ljwX7mmWdecsklD3vYw6r1phfhMYCVhxTi2te+Nk+ER0x7X+EJOUN5W1IJCX81 VSSp/hYBcUnYKxVe+9Of/jQkxcKfcMIJ1Nfe9KY3yepjH/sYAW41T37zgV+ADli5NdZYY6ONNgrx QsQsqhS1mLe97W3FfPSjHz14xWpF52NSYGQKJP6OTLoZS7jqqqtSQSNGIFIowtNoAx6WBzTH42c+ 8xlgBGdxu30aGanOP/98nLJosv3kJz/JE+GdCa3XBN7hDncI+SwYjThRbmeqww8//FGPehRm9m9/ +5uYxLuPecxjwhPsbSSPX/IEHjLf4xfcDjvs8PznPx+qljhl2oiYcjvuuOPEJQcXc7PNNhu8YiXP 9CQFxqVAI1KMzGRqKVDkv2oYggI95qc//WlICUL+e9lll8Xm1ZprrkkSSiYgTohEi/zXHl20MWQU VNmwmeQYYlJl22677e5617vyUz8gfq1Rw3EPr0hv999/f6/23Xdfj1hsOgx25Pg5stpaKloWIVDG IItJ86GIR8RUSmwG2lq0HXfkkUfKREwaDqTG0BYXT6mjyH9/97vfRf6EGOTgIpM477rrrvhf/sMO O2zwitXqmY9JgZEpkPtvI5NuNhJW8Tf8d7vb3VS9ir8ezzjjjNizAkYcrjNgtA/+SvXDH/6Q+kEk 8UtBgpZCJ12IDgKd4am3NBB23nnnwpDSXXvve9/bmUoIbTDKbSV//LvNw4LvKhmvTjvtNJHf8IY3 xMwhEKoGoHfir5gYfMpnkdbEQ6asmcIHr5jI6ZIC41PgarIo/Ts9y5kCMAgjic8tKlwDUgO82lK7 4x3vaAnfK4luZvePwkNBeTBqfw8iEwgA1j4JaStT+AXTQPxGN7pRNSZZM8YWXxwCa2ITvLyYNgML vlfjFz/mnX4xyYnG4pRLOM+AFasmSX9SYDQKJP6ORrdMlRRICiQFxqVA7r+NS8FMnxRICiQFRqNA 4u9odMtUSYGkQFJgXAqsOLI5Hy52imJPfDpbFNL6Wt1S/l4jSD4WCsQp7fLII6QzsBphVvzTP1on Q8nG5L+sCjhBtP3229fqTevI3nqndmctWp9HCMXkFbMvfXZpJKfySa/ota99bZ+sxnzlxK0TUw7a DpWPrZ6IH574rWJxQvBQ9FwmkQvOxkbiAvCuMJpR9hWLpxdBKPCx/kzX0NHzTTbZhAGQXjH7hH/k Ix9hpmPllVfuE6f6atZHa7UtE/A3wP/axXbk3yFR37izxvScwrZL56sBQwAW9VLKRv3xd8DcJhxN 5QNqecIfqk4RmMg74c8xc8UF7MavtR3M1Yv8Fk+vFlHtoFvtXAlTcKwXnXzyyXE6plf8XuGOgDOd MTj+qt7sjtZeRGgvvAH8/d73vsc8q0myay19DMdG6fQAaEqXTLHgUh1tote51157sYlFedOR/I03 3viAAw6gjMnY4SGHHBKnRfnp1bNZJee1116b4YKiKgTFWI054ogjlLv11lszJiAOBpwRAyeynJvy yimpK664YqeddjrnnHMc5WLwxQEqp287a4JNYA+BuQCzhTNUCvWozth5p7MoMzk4UA4vdG1m18AA XL+cCoeLx/hNFO5KtwxEAZgLZHnALr9f2nt+w0UEvSjidFLMKKDYRyfaKwONQrRBariVmM4fgmYa 3EYZw55s2unkNPm23HJLcfbbbz/Hauj2GRSWfWzFXXzxxTM6WjXcQZtTTjkFEbTU2fRChKX3FAgY 0+MYEpuqnZk4EAXy4BpshcXMnYBIM6qYrBc6iuqMv5P+1DDZ2xZolYShjnx8bxqpYQfW59fbSv5s dLEiePnllxNu0CElE3C4gHLoUUcdde655zr478yVyPT8ySUswTxCfzl0rYm0asLIwNlnnw3QmciS VvU23HBDlWHB1pzBdBY7s7C41KG/B9oaMM7O0lF1CoDJAv1g6b931mCWKaAT6kg4A8bbdC19rDoo qh0S/6vbR4iT1hjY6ls2oJ0VBMFYlq222mr99df3Fh/DvFxEw/SAYMWxTvf6178eEM/uaGV6yQC/ 8soriTGBRpUOS+5vgP8dsD8DOGym2RtSB7sqoaP3YTTLsdHTTz+963VkFPvFpHuPCyhl4aBf+cpX wlmOee8wEeCGm7BIu95664VRbYa3MdqORTmaJSRsr3StCQackS35w1wxHRY45phjHCsAx+aG97zn PQRhg6/Cop7GBmeQOFgVWCzcJy+tSE9SYHAK6P/MLlelcMH8VsdFyY29pDCZZGPGocG3v/3t5RUP dsRZ8zj8DXNJCCFsNUL4scPGjiMzcexlRker8zumIi3CIFoZdzZzCUMmp39mgQN8NdXxpGJrCnpG 4wkc4naGKi0gV/Wx6if0AIsRwpBgIKO9vgjRacIKF9SDp/jo6sZg15qEHQDJpVU9TDfoJHPQ+Tgm bp3yqlagvz/mVTmoQDgjp7S6f9p8mxToRQFsr44U07nexfWZzsXEUuyxxx44m3LzSOT83e9+t8jT DAd9HiNcLbTr0JvR0fqa17zGioE4xU0oGl5t5pL7J8f/dhVUleP5X/nKV/SDIEd0Ka+Kje1OMhEm sK4S4U76x3H+wPcSWR969rOfbfVknYVBDmMu3natSS0Qj0xg4mvpmpKoCWly9aKaUkovT0CwOsDf AN/E3160yvABKYCr0K8wvLpr/PJESC0Hvc6SDmNrZHWai7MdUkzpYw918lhfAvTIh4BCSC3PGR2t YOGjH/0o6d+xxx6LV4uz7LWmLdXj5Pjfri380Ic+pKMQC5x44ok2vsRhkYtEmCeuyeGJfhb8rMdw zIGLANegsGVR2JC96uV//oEmARZZsz4aJrhqEfo84sdJrqMO9ij01zDU3SdJ9ZUhoSsH+OJWoD9X a0I1fvqTAoNQQBfS52NFFcyvntY1IZ6D9Ix1TZ1QKq4a06DAtUAiaW1M2YIzygj67NphsS0ubZNE tsCr8A0zOlrhA+GhVSwdKkyVBnal2JIELjH+kkW4cCzWNfQTkMAmgG06NrpcSQCLhUDPdddd16WK FhGFRkhpAjdFuyzSJlvNLEtEI3YgaHatDkfFYrXVViN6Ljn09+h2RMxyJtngSI5k0j9J9W30dSOE MwBAsE5sDFTjTN6vVkYvRgBfX1tvTr4yWeIIFPD5OHM5CNavOB2saz7uE7F1bBmHtw1XXXrbRoa5 hh4pMB0JWykyIazALNvwsENeTCeTEe+2227YIxFmdLTCE0sBLYUVrKqCha4UW5LAxs5fjFB7Fl1d xGBFYK+2iF/lA2f1MCoH1Txt+3YyuThTCWtih2oqfgyy/mcvQmeVCU2aWoQ+j/o6tlcRQ30zMGdU BNtrstUcztpNM2OjuU+Jzb4iMKF7R0uEh0Mu+Zst8RAKAAAgAElEQVSrOPPBUBLtZis2K7mZ+3FM tB4Jr/xazkMu7IJf8lOLpEk2BIuKq9WT4wuqEi1Jht/UUD1HqImhYURA4TKC9FtbVdXBKFvLU2Xh Imd3tFoKY+oxUp2imBHo1mCSycl/e1U6Jufq284QbzvBV2Afg4clQ3L38OtkQ4GvVL5W3JVbchvK E8yvX9yKGWUyCx+47zgMgZexqsn4F3hBe5qIHGqUkTZUQ5ZzZHOwhYvpiscEZlFP2dFKnEoT+KNR zmEY+SdAJR9XXyr9ykzPjVyuoVFGR2QCx2vgKxzbW4roHJudISJP22jFzNX4udKipfUsJf4+7WlP C92ypSVBS6XHwIihgvUOCG6prMiWrjSZiQNLRCXk44QnIdhptdC5z9wczMXoxfBW7c2zNexQGfXw bbfd1jLOYTNqjq0SJPA3hA86mN41Dv4OVdX5Hq1DkaLByEuMvw22ZKqyKuCrVgG+Rg5PS5XEoDnj dNhhhxHpuNzBirKlgjLbKgVoQHK0a61taYhbatA3d2xhKGlVNcNF/dGLAnYnCb4qBn8XrV5GGJYC o4iNhi1jecYvEMwTDtvSBinIGcgWaBFZFztaneDbBpH752nPyqV2UJhwFiKbCPvHH/mtKRzshtOp Rs4nE04JBRJ/J/Ehrhoy3beqx6kBlUY8Lz05CnZdhW7jZD5OWpxa1+RYdWdbur6a9UBiCic8aU/S +oo7RhtvUSJv4yRd2gwTf9ui/wTYE9dTbrHFFiykhOr0CC2xJWhX3bYkZ9WMj26Ed7NP9ZCHPKRW H8hrD90eoLNYdjVZZapFGOcRY0grYJwcpKUt7gj7mJlQFWeBhMEXa5Exs+pMHgupWvgEelqtxGX7 6AQdY3INNj/xt0Fi1rOK0RLDA+cy1DgBYXQwO89klzJclEngSM/BgC+Bo3lcyQ566AUfeOCBzF/1 OXY4Wv6RisIALQJaqA5zYxJZJPjCF74wTobNprWAYNyZ2uz42ZrJkJRE3m3Q4+fWmUO1Xw3VqTqz mu8Q2nV2RCEmz3S2NPF3Or/LiuN/dtIYEqJz6gh/qO5W6+q4iuMkVDKrgWP6Te80PekpYydZRMKr YmNZmJMtprUYkKWo7zwLvMYt0mBhIovqhTh0ANj3Y/YQWw1qN910UydoWN6gaCxPl8wfdNBBFuli Muxy/PHHh4yC/JpiJgv99PzDCgxD0mIynER/w8kldAjTSBKqAxV6HqcGSF0x/ja+PIbrGhMlTVFY +zDGqGmaydaiM2BXpVvxr5LVu+6rr0bwOzyJFEyLjZA2kzRFAd3SfP+KV7zCILI1qif7+k1l3kg+ ib+NkLH5TILHofoOF2ypQyJ2S48++mi4FoVdcMEF+LVGCqbNCg2Z7nRc0LEouAb1HC+88MILFU2t Sh0AMUUrxenQ7HCCKoY14lg2XbfYHPdKVqwdUoalJ4t/dwSL2iwGxN4gy6KGQamwDB1J0kzKW3hh J6/AcRwTJyBWBO7YyFGKhuOXYwYSwSkmuakt8YtDkjyFzeyMaZXgShSmTTltpBmtAmAaf8oUdakM j8nM2ctqyJh+ZGE5d9oG/JiNmrnkDqc4/aQT6tLGi4nfOozi4JSsGwbSPzMCHUA0qMJVLeDF9yBD 7Pphlmd4fNqy52YE8lN+CHYP6BRa9aEPgChdRO+RBOBi/ey26U8ytNvuTHbJahwPKYdu6oQII8tO asgKVNF1hVn8VPQJNFkyWmWVVbTFK4ytmusSMMsGIP18aEuCITLEBM2w0hqctJc+P/UsHgwspli1 aye1gCwOOqwCsh0KAR31lo9f3Yw9Uqt4R7ycH4XsjNKyWnDwwQezOGosYc/FxIOzFGqJwN8ZMxqi /t6aw+C1PB1CAevVYwXeNu7kj+lGN5ZnZV6+ZhTU/7FXfLYifSlOE1DSrw/B47d/hrW3vfKPunW+ 7QypZVh7nJL4ulx1/gv7QSZ71sMJ6Pfee+/S3qXyXHOQgmnyW1TGGVa/vrdHfSucNWZtUJU8O79K vJrvcK3z1aEtRMOu2nfy4a2srcH32WcfW+SD0Aej5x6QEhOFnX911sjsbQkfA4+gdrRLvUq24bEV RuzA7+OSA+idAaDqL9DNewIdi7Jpxj499hYjrGeTP6hVxLHXFIIFsBt58kSvgInQAfaRwZlCcK8R gZIA4uCgGUaJEFMUgA5/XHSimdFVID55CHMfkNo+G+tc5VxiNZW0tZgaomJRSWKHUM4T0jb4RivU 0wIi+BVEiMD47f8oTmcEUyPJTNfzx9Efxsy/T/Ku9Zn++BZGm2++eaknkhpBvj4+Jq75KK+WyjMQ /ho8YRwnaknVlPiPsz6FEe74MYrwYuGwPxq5VO2ZhnIDfzGtQKpYfsAeBodY5X/71NYaOUYgpAAx Fvi4v6LnoAiH3FywSPbaJ5NhX5lQwSWgVBw7ALop5OInlJAVaCNCtQbSHzwyisRjD5AZLb281qGJ 3jh2lDDRG2ywgVRUNcA0cQE8wrxjQ9imcK4My2x+gqo4XDG71nmttdZSH5yvyCJY2pOuWpaZ5Kwr g/mNhLWYKk9krGiTAZaHPZqu+bcRCHwR0+lk4NhU/vgemiqIpiE6RqCJUhosoqmqTkM+WJ+oBkIZ RLqNBZZpuDa3LWFVB8LfWv3sLXDk2RFORumGoUBkeyzkhuygX4XGK/47T5TXMszHTgpYVWCiGXlh vQmIBH9aoulA0Me6pNnhLX8CMvoJdtvgqc09IMLUXJiCVQ1zQFGrMiVjxi3kSWMhY61PkyqQJ2gC CWxs3GF4bdDpOZoWjGGcPleWEEUYLfbiShtrHgt5unHaKxwXrFwnHUwPOljhqSNJNSbOfdVVVyU5 MfzItZnirmXb3iOZCXl6ImN7FF40ZxOVdSeOMEygNbLowVHp0lE0QZDlyKLV6BOhLjbqE3XAV4Yc m2EBx/ErYRWOzeHz3Sn78L+wLBbUgxDTOgNa9Ylpg8uOEyTqE2ecV1Y2eNX+Ig6SXwLiriseLbX8 NxmHICJqEusAaKvvlrqRkBonAqsxy9teHtt92OqaBZmukWWu3EmaKyOSNq9YAIVYpmuthg00w9mA Tf53KLrZOi4XOwyVsGtkvDMRXHllsdVHQ7RE6+NpHn87CzOMq3BsZ6kmr2hkXuosd6lCmsLfResP VqxDGW+lTbVo5IwwMQoQpBCak87h6xssNPG3QWJOSVb/5UHaqxD5A1dEexj4Iq9w0zB5hbdVBrk/ 09dePWcuZ2sfZtRJYPGPILhsZM1cQ+amwkQoFDZwqbikZsF3bkiUDalSYBL4Wy2P31rVHlTZhiKv YCA8GGRa9zw2watwbFNovuUVNfoM9UjNwFCnSeOcDwimnRa77UNlkpHHp4BFj7OIDly4z9shunIV 7Pg5Zw5zTIFJyB+GJR+z/FV5hb2aqrwCNE+5vGJi8ocqYanaOMjgvAOlBZ7+QttqwvSPSQHrOWfw 6GNgLKjuwd8xM+yVPOUPvSgzu+FLwP8uSiw7KpyreiKmNV2RV9Be4q/JK5LXQChTlMMFFHjpddnh xA47u8zZ+l+U4BlhBApYtDnPiud1ZyVdIJI0e6FD7R+OUGgmmTMKTCP/25/EpBNFXhFsMtWimryi urfeP7c23i4J/1ttiBmLai1o4JzRIMCBzhwPG5WUcsJVk6S/FwVscqIhlSPHZyh7WGdwcYAVi2CG owxHaa9X8gbDk/9tkJhTktXs4W8n4Wjm1+QVNEOriDy+ZcLOQvuELDn+VutGmAMsAjUciIAj0IRz 5IHkvRoz/Z0UsPHgJJ7pCsJyFJZjJmMwaPLba4m/nR9o1kOmUf4wLE1ZdVmx0l5vvUiI+2PMJRCZ 7SvyChGqcDzIrZ3D1mFq44cwp1wnPrX1zIolBZYhBeYBf2ufDcNCEsdFOHmFA1oBxzZJeOLQVEFk zPLSyitq9c/HpEBSYJlQYA7xt/blbInYj+KKtUZHYgKOmQ6Ia7tq8ooxzxTWKpCPSYGkQFKgKwXm H387m+08ItsxXLxihavIKxwbJa9wkKFwxzxhpqAzn+kPwekz8Gi7kl4ER5OP2Deco7HF2Nj0N2Sp amjydoDY/kE4ijcmctuY7KgxKzHlepBLRbQsd3AKLEf8rVGHaRtmbrgIh0q2uYNBZmeWB1RV4Riz POVnHGgB03xgy4bdWwZo2MkFGayXsUZGRzWgpKvFhhpl8hEFbCfEjMXDbBvbJuwTOeHGQjzdPocP GYcrh4mSYkmBoSgwD/oPQzV4hMhO9wYcxy+zL+Csisg1q4ZLpf8AIE455RQybgYhnfZmmtK2W61u IzQ/k3SlgGUTJT/24M8880yaCSzDxfUKXSM3Epj6D42QcaoySfwd+nNgh4u8AiK7M8Jhsyock1dQ 7epq/3co+2dD1QxHxjYuvSgWTjfccMM8CDAU9caM7OSLO5ZcRM1IPJucLW3nJv6O+ZmmMHni77gf Bbdb5BXBIDuQyuSohT9JhSU/7TecadhdbAN/CXaZHbBGPvLIIxU6bnsy/agUYNiP0WQyCljMUOGo 2fRMl/jbkzQz+yLxt/lPR17h4kXyQfdT2M0jDcARc/b93NzjdonBZQIY7f6Qysihe3xdC8bsw1Tx vG6m6ColNxU5LxMG3Zsn/RTkePLJJ5NFOAXOXH2z1Un8bZae05Bb3n/c/FcgjrAnYx3qhl139LKG ZVlKMkDvTWGsa7qIgYjArTnGKnapVw1c+uuWs4022gigd43jnmD3QRxxxBGszY4GvmQpRjWT3hxT auTa7pjoWtZQgcyuu964lgTyuojTZiDD5Nrl0rlahHEeCXzsK46Tgx1LV3MCTRcmjaMZ4ssSR7hv lFx4nPpk2kYoQAWokXwiExdZue2J3guHi6IDE3fUjlxE4u/IpBs0IQUmggi7YTQQpCEoAMoMRTJb ceihh7rSjU0Gy1V47fYmEoy4JllM1/Y4/3rqqae6uIFlzhookC8TbtDQKIaVB61QRzwLZ+IR92ke eOCBVtBOJ3dEaSBAA+1Z2b2kP2BqwSHSjWsg3yayMAuaG9hzYMzeZGlXbZxcfW4LINtxDn+Pk0+m HZMCbpAx+oy1MW+pqFaDcUE3rnGGietQXb/NX40wlD/xdyhyNRAZv4kHxNUy2nvaaafBPuJj95Kx 4ha4jI8jPgYHuGNsnQkc57jLLrvQPIVcpQauUmZ2y11nJWR8j2mANh5DM8oFQ+qJjWXlS86Y1rjG jR9zZ56A1zofuYqphWUJ4a53o32hnthqUGu+YSRh++23x/jL0+xiFon7eNhScDN8zDT05CwOiFl2 2203xm7ko1uLiQju93RGxlWkShTOqQNJC4+bQC0jzF5sPy68WfHTNaYz6GF7SBJxNE0z2UomtykJ rVHidjtXybm3LZpc3o7gcTuq+/FcOzZC2kzSFAXMf0YToR/jBLZhrDipwDeVuRWnHq4PGwij52n7 KF2zFMCo+ipmRR+G8NcFH6ZfmmEEBb7TomUBL4wh1rhTRRc4utTS/p5MHLCm/7Robv0jQElVYtXT rfJuvMeyWYNLorbAnbEe4Kjjkti6PdMlx14RekBVbdxxxx133313cwOsJE/wChqSh4Dm6OWHH344 ItgbFI2c2uGFzsrIx1kGC3avANbb3vY2ntVWWw2Um3gIcOSJ04fX8vTKtERC4kQJvHas3Cu3sqOw xYQlYWdMfL1Vgph2Ka0W3QwkppHz0pe+1MzXWR/SeaY7oXznq2FDfH0HKTVw2IS94vtStFzISUzD mqP+WDD016JeSSYWrplVZ5KrOZWsOgOk6nzrmvMpq86gqDr9tubQoeqMEc58XD3Lau53YaDexVio ZegIxDEECv9rzYS30FtGyKckWRwOStT0DEgBHVHfGhl/oxRDq3P/KsxxGYfyBzd62IBV6hVNJ5ab /SK9ClCS/5I/iGxih1AmDA4rd8IJJ1jK2T80hHCOuHVxoLBrj0WAs2xugBtYCR28gpWkyUYgvy1E 5xTsQ8LQCBFY3AUXXEBWHo/iyIHfCAExPPgX4nIeAm6yEQMSiOORcbJWD5EK+quPiiFIZ0xgLf+F dhyBhdcoMRG26/Ajy8Pyu8/UF4zMx/wF/e6QxoKpW82ZXKsOAavORFtzgMOXUnOOCDJ+eXq5hYj/ /aESV3U6Us2Zk6rOKq3qFD2Uq6YNfzVz/lrp1bqF/79VX/DVmglJaw59qi6oJw6qdtZcbqRhI3xc +FvLDacyQj4lSZ5/q9FzWh5DEGzQ6r4mdtiH43POyqrcqBYII8BZI9W1Faa/ygpXpRSXONhAA6BY EoGwTyDgw+S66winbEGHGQG4BlLEcSm9vi6yVFElHm/59XW1JUnAWkLbclc8hhr6kwyUa+sgo0ZF 8hg2RqmeKsR8QB5Ca4KxXXAG31UmYlZTdcbUEBWLShI74LXFEYKwkbz8gl3MvuFEelsCx/Qol4Ce iAYFalnVQvo/SisCmhC2mMZsGHAB39qCwjBr/PyrOQxSn2r86fTTQapa/kNAveURj3gEboPQbLQ6 A25dV1pT+E477YQFftKTnjRaVlLVP9vIGWXCZingPDSZL4YU9kGEQLdqEU586F4wpRo4pl9xBjOg JAwlcyBphSD8WEg5A0GMJy4DmHpkQIPHAVwyFnwBxrlaOokwZ6rAVNohlMreMZgm68DQWLvZfyM/ YVrXsRFdGaoSDvTaS3TRt/pgt0VWih5P0LzZZptZBxAQk+uVomsxVZ4wQdEmg1133bWX5h9dBdJ2 UuCYM0pu43horWiX9ek4mdTS+jp6AmLGb3gEmqhqMfMxKKADIw5yEaOBXX2Yqs84xNFDYrbTdUnM LK0sQ82Fo+WZ+2+j0a31VOZqO2y6C5ztBF/F2z7CqDZeD+yVtb+lOiMS1s4AlPQg1HVhGYMSJLBR qM5HsIu/IDSwrq9xTJg+omqSBAwgoJQE10CAQJ4gkPBaWnHArrKIMghnTzzxxJJ5Z7vsNDIkT77s FS7Yhp5pyYSh6xeeOlJVY5q95KwJcNBJRdLtzpyFEEAzUW+RQXeQa2TfjFL2OJxR13pm4FAU0Nks 1LARZlbcANZ1TPCtlR5Lt3H0H/L8RY2kDTxaMpMMwBrf3tyICQIWjZ9/w/qRzOpSmLsGKt0tiyuu uAKvCo+6vfxPGOUNJt67zv/oYPlPr6PKVAYdAHp1yYxVJNUVWI3Zp9B4RZUNA6j0RWPKXLnU+BaN 2VSE8847z+ylXf2pN1RxZjj7bxAE54WRJ0JBdnNz8r9DkXGcyMYayhfVdcNcD6RgQxFotGxT/jAa 3ZY+FWQ8/fTT6WAZgdjkNipE5rtotjasesWBFzjc2lvwwdUC8RHBStTC+z8Ojqc2wav74P2zHf8t 5d+nPOUplhENgu/4tcocxqcAraRqJiQb2KBqyLD+lD8MS7Epim/ZbkluY8rSfsx+MEWtmvGq0G0i xSbmLhZNZ7xBWf0WKZD42yJxJ5A1ASjlYmoJBJ0NHvKZQM3nrwhayUThNgkdWSzW/eevmdmiBimQ +NsgMZcmKyII5+hoJjhnaV+LFbTkhSf5JYi5aa05YeUkCEEQsYMNxklWIMuaXQqk/Hd2v93/1NzO PvMF9KgoZjFigP+i4Ug5zJ7+/8TLh4YoYE+PZhuVYUdO6DYxu0x/o+s+ZEMFZjZzSIHE3/n5qHbk KKVxtGsB8UknnUTh0Q6YQwfEFBwPgIjNqEnuR800iWkX0WCBtn4R1hEVMncHmunnkTaY5CAv4c9M tzErv1QUSPxdKsq3WC6JhMPEHP0Yx39BBkcoCT7gSDiKceWwWYtVmfGs6cM5GUhJ2XRF8Yg+qWnM 2oKCcC+97BlvcVZ/ohRI/J0ouSdcGP2YuBhpwuVmcUmBpMAgFMj9t0GolHGSAkmBpEDzFEj8bZ6m mWNSICmQFBiEAom/g1Ap4yQFpoUCNTsb01KtrMdIFEj8HYlsAyQyTooT3U6OxwHSZZSkwCIUqPar 7FSLEGu6Xyf+TuL7BPjmUJkEree6jLBPFB2pdKfimeumz2fjEn/b+q5lVAT4+k0jrW3Retnkqwtx ulbpXcum6fPZ0MTfFr+rQWK0QN5wzke0WFhmvQwooCOVHrUAwinRmu2vnvq/rXy/YE9ihMSYAb5h 8TZetVJqZjrvFGBrVC8qEKxrZXea6W+e+NvW5wvw9Wu0AN+4OYZZQsdYOdbZ3X7GQLsLqZxSY8OF G78qkUnnr5xr+dcexy96XnOoAVx5DE/1FwXK23GoIRMOzkafiaskHRx3AE9H4ryKFVXEHKesTLu0 FEj8bZ7+RoVM/Rokwa3EsDGcjKVA2wjHzrBVFiHN1qMKr8VfPM2WtXxyiy8bH7e0ugSWkPE9Zc0U N7z5hb86jw4T+BsQXHra+CVmDktCgcTftsge+BsQbLQYOYYQqFWeQI8GlcsBhbDDwE0AHDuL6Axp ixwzmG8nsHaGtNGs6DmWTdFtggt2H2AwwgHB3ooWMduoQ+Y5GQok/rZCZwgLUg0PQ4gzhAJn4Z1H LAyxAxFECB/EVImEwla+xAxmuoCrK36iq+g8nNm64K/HWFHpZqLNYBOzyv+hQOJvW13B2MCkwFaj BbYGvAo0cowlYgfOWxAc+NtWPTLfGaRAQPCKqXvB6TPYXg4E6zx6lGB9iZvBxmWV/0uBxN//0qJx n+EBgiGvASNzg8qjsRTIiyMGvt6GUKLx0jPDmaaArhL9J6A2IFhHgsL83nIB08kCz+6HTvxt5dvF wFjBnyxswUUZBX9DFlEF3+COW6lKZjqDFNBVovNEnwG1UNgv/C3gWyLMYPuyyv+hQOJvW13ByJG1 MePX4PFrwBg8IfMFwTC3uLYqkfnOLAX0n3C6UEBtQLDHEhIRZraJWfH/S/xtqxMYG+DVyFEAPw85 L9g1eIrAl0ectmqQ+c44BfQZPUcjwuO36hJ8Z/zzrqj+CoyYg2ZMbROCw1U9UMuFx2+EJ/Gn9sNN ScUCZAsKw18Vq/5OST2zGqNRIPF3NLoNnSrAV7KCyOEfOqNMsJwoEMirxYG50fSqfzkRYw7bmvi7 ZB81md8lI/1MFVwgeKZqnZUdiAKJvwORKSMlBZICSYHGKZD6242TNDNMCiQFkgIDUSDxdyAyZaSk QFIgKdA4BRJ/GydpZpgUSAokBQaiQOLvQGTKSEmBpEBSoHEKJP42TtLMMCmQFEgKDESBxN+ByJSR kgJJgaRA4xRI/G2cpJlhUiApkBQYiAKJvwORKSMlBZICSYHGKZD42zhJM8OkQFIgKTAQBRJ/ByJT RkoKJAWSAo1TIPG3cZJmhkmBpEBSYCAKJP4ORKaMlBRICiQFGqdA4m/jJM0MkwJJgaTAQBRI/B2I TBkpKZAUSAo0ToHE38ZJmhkmBZICSYGBKJD4OxCZMlJSICmQFGicAom/jZM0M0wKJAWSAgNRIPF3 IDJlpKRAUiAp0DgFEn8bJ2lmmBRICiQFBqJA4u9AZMpISYGkQFKgcQok/jZO0swwKZAUSAoMRIHE 34HIlJGSAkmBpEDjFEj8bZykmWFSICmQFBiIAom/A5EpIyUFkgJJgcYpkPjbOEkzw6RAUiApMBAF En8HIlNGSgokBZICjVMg8bdxkmaGSYGkQFJgIAok/g5EpoyUFEgKJAUap0Dib+MkzQybocDf//73 X//6183klbkkBaaSAom/U/lZWqjUJZdcstqC+8hHPlKyf/Ob3yzs4IMPLiET8zz0oQ9V9M9//vPO Ek8++eQHPOAB17ve9f7fgtthhx1+85vfRLTf//733/72t3/2s591psqQpMDMUSDxd+Y+2YgV/sMf /vCFBQfOsJaRyw9/+ENhfkfMdIxkX/ziFxVdalJy+vSnP/20pz3tK1/5ytWudrUb3/jGWOADDzzw mc985r/+9S9xPvjBD9797nffdtttS/z0JAVmlwKJv7P77Uas+eWXX/6Od7xjxMTtJ4O2//73v5/x jGf84he/AL5R1Y997GMXXHBB+4VnCUmBiVIg8Xei5F7ywm5wgxtc85rX3GuvvX71q191VuYTn/jE Ix7xCIv+293udk960pO+8Y1vRJwzzjhjnXXWeeMb33j44YevscYa55577qte9arHPvaxp5122ote 9KJ73eteT33qU0UmN5D8Hve4x84771wYW3Ee/ehH3/GOdyRweNnLXgb9O8uthnz3u9/1uN56693k Jje5+tWv/uIXv3j77bd/7nOf+9e//hXz+653vcvb884771nPelakes973qNKt771rR/1qEcdddRR EdhZYeFf+tKXNthgA0170IMetOOOO/7lL3+JyP/85z/33nvvBz7wgTe84Q3vc5/7ePXnP/85XuVv UqBdCuA10i0HCnz2s5/Vk+585zuDMx6/Wg0Q+V/xilfwn3TSSZb8EeemN70pD7D+5je/6RXY9XjX u941InzqU5963OMeJ0S0m93sZjzcne50p2tc4xq3uMUt4vEtb3mLhCQMHsEo8CU34AfEwjnTgMcf //jH8Vh+n/3sZwuX85ZbbnniiSf+9Kc/La8OPfRQ4O6tUlRA+O677+5RVqussopS+KPczgp/+ctf jhIhLGQX8+EPfzjklclznvMcjxyhc2TiFXFHKTc9SYGWKPB/LeWb2U4bBQr+2su61a1uda1rXQvH WsXfwEeM7T/+8Q/C4sc//vEgCZupIQFnwHf//ff/+te/jj0M/MWW4iKxvQvw9X+HHXYYRHvBC17g ccMNN5RQCMYZi8r/gx/8IKL96Ec/8tgLf729973vHTHj92EPexjOVxLu3e9+t0DSCX7Sietc5zoe iSY8xr6ipv3tb3/rrPATn/hEMWOm+eMf/yiax49//OOYYh7u85//vEzMN/b9PJqNPKZLCrRKgRU8 SLplRQHc33777bfZZpsBIyxttJ0ewre+9S1+6ImNxfna8iJ1/dznPleIc7e73e2Vr3xleeQhbYCA a6+9dgSCRfwjVvS9733vn/70J4FKsa6HjMsiih8AACAASURBVE9+8pODFxYIHyN+11/ygUsvvfTs s88mDDFnFAc0N99882oSMwGhxHWve90DDjhAOI7VDHHllVdKHtGqFcb/ClQH7eIJ4D7rrLMU5/H+ 97//6quvzmMSeuQjH/nRj36UiMMUIiRdUqA9CqT8tz3aTm/OQJbM9JRTTqFsELUsEs+QPAgMT8Bo xLnLXe4SnvIbq/X4FRgsbbwNSQX+d9VVV8U1Y7df/epXw8qStqsHr6FK55xzjurts88+/OQPwYkf e+yxtSSYdCEKhbwc/9Of/vSNNtooGFiP1QpHZFNLRJa/mKQZ0cDSaqk6Gy4wXVKgDQok/9sGVac9 T+D4tre9DQYFV6i6d7jDHfDFv/3tb/G8z3ve84SceeaZfjGGpTEFZ0tIH0/gb2gv+JXnxRdfXLa8 eiWUatNNNyWCoAURcuqb3/zm1ITVCkteUoFpfvt+fvHFe+yxx33ve1+8MHmCHLC9uFevqhUWmYSB YDdExiLYgSTwveyyy8Q8//zztR0FyE8++clPCqk23GO6pEAbFEj+tw2qzkCe2NLqch5skfyqt10v WInlJLT1iGkdpzEhU4aeRx999Ete8pLIKnjVXtlutdVWXhFMkwJvvfXWT3jCE/bdd1/VI8oQfv3r X98vuHzDG95gziDVhcXE0BQYHvOYx9DZMK9U2fBSiqz4wTrdjC222ILMhCDi2te+tpYSmNDWsC8H 8e95z3sSxRBKmAZK2vQkBdqiQKvS5cx8eihAkKoP0X8oVQI0ob0Qu1IwCDYVnpEyFjFuRI7trHXX Xbekjf03CglCyilha3mPBx10kILWX399fjtjIQQgf6DXdb/73c+rI444wqte+2/QGeAWtQrxb3vb 277vfe+ThHPyLWTWhAweNYEYQZxwVOKuuOIK4Z0VFgiyCxMtT8yyQM7xE4Lsq/L4P5UkQY5X+ZsU aJUCV5N76XnpSQpYzn/ta1+DbhbsQLMRgsgQ7gfrOmCG9ugoAkNbQCltlaXVYyE+JY3QYZChPbfv fOc7gH6llVbqnz8xN4GDqQVjXmaaSKIsO5DU47DV/TPJt0mBpigw8/hLYIcW9lWaokjmkxRICiQF JkOB0eW/GKWXv/zlDh1ZvZZtnFLp29/+9o7wl8cRPNgcdmHKMapeOaiDjfJebxsJpyIaav+N5JaZ JAWSAkmBoMDo+Pv85z+fSS0nWSl4rrnmmjWTVPaXY3t6ZEKTA2633XY2tUfOIRMmBZICSYFppsCI +Is5pR5vI8U+st1nGkLOC1XbCTptawDoF77whdQ/7Zk85CEPoYEkDsimkOQkPtGebW6CPIF2TuLg f/gdS2VSgF/+VRVU0gbb9AR/tOXtDonA2YQR+Ta3uY2jq4HXNmEc3LKLbXc71Im61oT1RTVxakBM u+GhHYWvtz9OCIi1r9l8YRHG7ryCtIUyU5Sev0mBpEBSYEQKQNIRHBy0WREJf/e7393oRjf66le/ Ws0HooE8XLCdE1jsqCuIDG0hx+0pWlKtl4TSz4c//GEJb3nLW9qliRyc7mfj1Y6KJoFsjHDJ+a1v fSudTTZcGFixR+S0KARXOsMrjMKQErz//e8X2T4+K4tU9z1SY5JD15pIqyYnnHCC01Y2eWKTXfUc fFIZZ17twv/yl79kKdF2jWxf97rXSWK3h5KTapRaDeVRmeKQMV1SoA8FSlfhGaqbTXNkLBc3zTWc WN1GPH9h75iWO3wErBtvvDFlIwrwXWcAAIfNtD9GUOvYVcQhu3DKk5966emnn+5wamdaO9ECi82X iECvyBFYOMsxhRUnWTGwYUKF0SxnUsWkNEoqQtmILpGQOPvUtSYq79CUJDBXTBvrxxxzjKkFHJsb 6MA6O7vyyitH6bhymM6/zTbb4I4jcJBfgyeihcfXLamq/hKYnqQACtB6DjoUT9HZKJ5ehLrooouM O93V4Npkk03wN71i9gnX+Q2E0v/7xIxXOjPWhMm6/pozoABn89rXvnbRDEeOYM/GihZ/NnIOk0k4 Iv5G5RhDwWnutttuuMJe1aUSFMoJlH7KIVfoGfHpDNHKrKXFDtRCyuP3vvc9sBiPcUyL315fhADc EFaYXeGpLhgKp/G2a03IQKppMd0gMkwBCCeLAOWl/73mNa8hTiF/cIzKrmMJjxy6/gbgll8efbQ0 kJ+TMH675pCBy5ACAbh+iwfg8vsNT/Qo/q7EcZaPgrYTK3Su3/nOdzKQFFK4rpH7BNLvtmYdpJ9H JmplsWuM9MffPiUut1ej4y9WlPD0wgsvDEa4F+G6dhG3yER8OhJFZzMwyKuiz9+ZJ2HCT37ykwin Px+GsmrKZ9CNIPj1r3+9Y1cY5GINoGtNaoF4ZAITkuhQ1FcThlqCp1aoglhmIQVmiwD6f//73zep dFayhATaapcq8XOx7Aq/aMVTkqQnKVAooHNyAbt+dT+P8bvw5ur6D0+JXzzOB9r9Ds7GdgsmQ6ct pkFFMzRAsx0a+y5GsTFok4bdZ6cfvWWeCZNBrsg+EUbSEXBiQMmZcqbpZMnI4JFhIu0hhxwS52v4 jzzyyDjiaM/GYZ+i7q3z77LLLvaKsNJOIcYiOPZs1NM60iujzJ7NTjvtxPSHlbQ9HqcZCTBZEzXG 8Xn4ZYBjUYupZ0VExUgUsUEK9YhPcnbRiXlyQg0p/JO2aPiuu+7K1AkiaKkz94VKU+GBDiM4NGWm BPm0PBxFsWo+Rf6LA41wnxCjyk9W4PCr+KCWZW7LEIFC3v72t/OEgW3yX0XoW9QqInn8OmYKW22U +VrRRbDee+65Z7wlzSD29Wl9TnJbgXGIVk/ytTprUk3rI0kLH/WSYi9REfpfkf/azTv11FNlq+b2 ABUU5Xb9DbQ1AagtEmFJupo8n4pOkJWYEQroQjqzRZ5OZQQZI7pZZ/fT2UgeIvy4447DwFbjMARq 8IJgHdh+cpxUhIxlHIFREGwE6fD4GCUu8z2bKvWa9Y/I/9o6Y0aWUe3Sb32wMCBQQvp4sI0O2hNH 6BmRyuc3977pTW8CxCx5Swt8HXh1VQEhTjk2ammjuxAKm36JPuy8dZZiojbHPvjBDzafr7XWWnQz qqLnzvjVEMyFaZZA2cSLOwDo8gHBEcfayiuTMPx170OVoahmEv74ToaHQWKohPNKeGfkDEkKLEoB LLDpPPpVLPCFcJ0J3ZvHCf/ABz7w0pe+FGdTjWNTmsJonCCHua4OgbDVCOE3fIw7fEaMsuW2Z9NJ kDZCRsTf2P3vUyEmrOJtOYUhCUSLQEsY63ezdBG/AlaBulf14D/xP5Qv4Cut+Pho+fDASiGAMvL0 a64OPyaamEJCvRD8ycQaqrMm1bQ460hrQWSfzb6iIgJh2WcJQT5ZsFdk0KaNMCBbiq55CvgGFwx8 KcZpXS1aPiYFhqIAtlePiiSMB/H3gmD9zUpRn7e/DW2rpRCvlRU6yYNhghGuRjBkqo/hXz57Np1t by9kRPwdv0K+OlfNpzPE26ph1hJ5kBP6RAcRH0wD35J2EA9sNVt0jWl6qM4QXeOUwAK+kNd4KNuP JUJ6kgJDUSC6UPC8OjaPZaLJvsYFE6PhZjC28LeTUSBgtX6NcvETxl1oGRVkJ6AQUquYNV+EyHOO 92xqrW77sYvwvu0i3S5OJtB2KUubvyERsjkjAfMLf42c6kGSpa1elj6jFLCRgAXWnfQuLpZZnW0h 26VD6b5UcfQ6TswSjUqDvWu7x0JsTNk6A9/UPW3nyNzyzmZJRAbxhWn40Ic+pDNT5XQpn40vEcgJ w34/KUfEj/lAcfEYv4yCioD/sCQlxOjKUdnoJm5WMdMJ8Ug1+aJ+G4B2m6IOVsZmF4vXkkqJltGk KFbYhJYaWF5Ng2cJ+F/4Ow0tb7UO0d0xFJxea8D48LV+2WoFMvO5pIBeRPILR+I3OlgI4qrtdWuU A0SUeUqgDe3C0lISgLk2YAjWbNPF9X204B1usvls4WhXPBKSEdsCwUd7XA57NoVcE/PMvP2ziVFq qILwHbHhhn3gcA22OMi7Y695qKzGj4yzoELHYW0wUBaSnE3F6ddOH7/tY+YA2izPya/C4fho0bga gxMyZubDJsddOvRvN8yuBjSkWEm2QAoMi2vyh0Fyxo3aF4HCBb6hOTguWzKRia6rIFykW1BrezYi 6E54i5pETradTG51z6ZX9Tr3bHrF7AzHX1f3bKoRMNeD7NlUk0zMvwT878TatlQFlbVesCchgggp xMSqBFstQi0zaWIqmhIlZwvFUDGAOUbj+ituT6yqU16QWdMExoEVVCU5pdHFQLsTZWZTjrpr0XVt uy1QRll61Arpw4L8QYn62wj4i8/lqhW29q+Br7dVDffOHZrOEEk6wVfgrOzZVAkyAX/ib1tENio4 EBxDxZgxeNoq7Kp8aZvTZqf+oSzKm45g0pAf7ezpVVku93+reC4W76GzFRRxupIREmozEJmxJ2pe tGLaJlYsqqJHRQfz23ah8iczDHsAEyhrWRWxBPtvy4G+MSqAb0BwsMB+22u7jWxK8jhcgj8Whej/ UWSGCwm+LdGcYrhjXZ/5zGfsdNEHIFF1iVFRFW+pUPirF8W6asL4SzG/pUbNYrbrrLOOg93j1zzx d3wads+hQHBBYWxL96jjhWJ1nQelMEc0yX4F/hc0jJdlph6CAgTB7lSmTuDYGHEERpiwYoj0w0QN 5C2/0ceGySDjThcFEn8n8T2CC24Df23rOSVIDYipYgcCazshk2hblrFAAZtgVhs2OfGnzoXa8GmD MLpQgG8bmWeek6dA4m9bNK/yJlV/g+XRrLDmxfYyjDJtm2lWyl1bSgkvLDt3fTvrgeY/wncmUiml 1g6VNdI0HamzL3WGNFJWZjIBCoyCvzqW/VZbPROo30wXsTBY/jNgQgoxVHMoA/WPTx2KgQsWV/tH 6/OWPqlPGcpVDlvTkTjssMP6xB/wFWUjV4TUIkNeakyUT/GJpCVsfdQijPOIMaTUMU4O0pIbsO8x ZiaSs2Ti6kKfptckNGYR1X6V4NufmO6paekr9C93wLej4O+AWWe0cSjAxCX1ILpNPF0VJ1z4ZCKk Mz9OKZHWZh3oMaEeeOCBsKOP/c9xymJtDsPO+IAhQWDCKMwXvvCFcTJsNq1jV9RFnFxoJFtSYJNZ p23rRjLPTAakANUUsiCGhIjm2Y0ZMNUkoyX+TpLaQ5QFpyjGu1QJIFrVOj1ZvYwON43DcrCS2HGI TBeLaleXsj2NV+ykg094VWwsLSvpMK3FhrezUuzAwmvcIrUkim6OV4lDP5+JVZZnsdWgdtNNN8Wh M8zKiKg83dd30EEHhTkCQ+L4448PxoSeMs0tJxoY8g9DXO5rEJOdOeoc2kjHIO4oUYQ6sDzHA9oc 1nIQNkyMCuG6xnQy1ZnUgoaappmsxDrtGqniVyWVWA0Z068J6jbNzNeYDZz+5BgXZ1UcIaGFaTlC idCqqw250MikWBr9X4cCRq7x9Ce0JDTIDbxi9iHs/wa4DNh2GzixtHRWTZNxZwCLZjs4dg0HaDaf N6Xn4Gi/Y1Q6KzkyPSq4xswx3oFxfSwqVIW2gNiFeKximxgYRAZVrHrCNZfmuSWBfqj6eMUus+MJ TGLTyqKeRRjKqDZNHWBHEy5OssYXDAGFNm677baiMTsH8TXT3U4ExGBa0XQ52LSDufhlMg06/CIQ eTsH4cY/h8Ggvwo7mgVeZcu6di0mg7kMTLOa74u4KBagu48HTIN7Vr2rfUlzzCJWG9XAcfxEwGYd lsLjO5asao/CayF9HikdE7M4E+EURpx/MwHrDFwj+UcmfSrQWdvOkP7JJxlfh4zK+PrEXx51Bpa+ 6dKZgHWbaO9ovwZ1sejtRHgY/Bw2qyXAX7ybDYphKzpD8eOTxz61X9/enng4rRiw7cWAZzRcJr63 3PbYYw9XHwF3flZFGiGLKUEHMlvAUBIPecJ68OFqVH5iEGw4Y4bMBaiGVxhbUmN2WGAWwAIH0DaU rtQNNMNK0mTSXkeqrMR5MLCYYnUWUq0zkIWhwFcg/WVmoOEvv1/IAitd32BuYM3LJGEV6UQfxh9e kxVgz8XEg7uyD1n4O2NGQ9TfW+D7qU99Sp7QCqxXT3Z524ZToimkjNIoovOsWi2kz6PmayPne3Ea gp5+q0mq/q4l1iLUHiWphfR/nOb4+qQuF0SIXyjsu+vwWIox8VdX5yJbzPWAfFW1MvxLgL96zGh1 rVV9ah/hL5zCTkIcoImBLWdYiREGbDt79vjcaKPxhmguvmMAfqONNorTrmw+NcUCW5RhppRFfQpj SKYcAAqRBbpOUaCTqTbNXBSNvcUIaxr5g1pFHJaUQ7BQbNLzeCu5yhvAkMj5XSKUYrOfdS4yChx0 mUVMUWW0RBshS0xmEB93bP0IqTGADCQWA6HVVIqrxdQQFYtKEjswdyCOkAmAr9ZZQ7Al1pSMCBlN 3jZLyaMcydMEx3+1BYURSrvS1ShgoVZsCUX/dJ+DQeQu9ujwtfiDP1pmDR65T8z/YUb6xMtXk6cA EDfGAJlp1qk2Z6vc61GAg/DBhVfN1soq3mAGlOQJOihJqxKZKMRqKQi0kbqSLQBTv/SOecThAcqw oFoZa3lOCCZ6gw02EH+LLbYA0yEPJV2x/yZzsmNbXiFjweGKWc2k+PEXtEFwvlhpgUwaMiuOPqYB AuJqqlpMDSH2UbR6OiJByFvybNtDrk01MEjXdlmZfy8K+PqGDMEXaZhVGhubVnJjgm+vskYIH53/ tUseDI5ScSsG2AjFZ5JeFLAHBfj23XffRz7ykbUFYCTBP2JLHbhqdtfIzhj9BLttBM0WaDhNPHtY P4BlJADl0hAXR1FpsJAnjYWMtUqSKpAngEirbwJcdVZhomRsu0052WLwxRGuLCGKsDaEWb0IYtjQ jSOAFgEXrFwLAowtjqbw1JG2GhOJCPtITrDJ5NplSdGrlKbCLQ7cwE26UiNLU/lnPoNQwPznmlH9 dkxRwyBljRZnFPuTNhDLmjFKNSYNxdFqMH+p+ssfYkHdSKvJXsE0NjPwsZE8q5nYTLN27m9BAk9B QFxjfiMTLbX8d+lqmaeFE8lxKlxlDK+88kp8isBqzGpNuvptp5j1a0a8usaUuUJJtLu+bTwQO08x w1Thst4GMwflRx99dMofGiTpkmc1Cv9rQDYIIktOgtmtgD0oy3lD3RocG9h4QzqtEXYWEZtgneFC 4EVwuNW3cdajGsJvOq/N6LUIXR8Hx1N706NtT3ctt38g0QqGi1ZGswdM+heab2eUAin/ndEP959q 06ly/o0UgmSAnuNsN2bGa0/YQluDXh2JSoLvjH/MCVU/8XdChG6vGNzWZZddZjlvN4wJnjm2rtAe DcfMmUTOzqSDJ5dccgnFpqKWNGa2mXzuKZD4Ow+f2LkMO2CUW4kjbEbRB6BdQJlsHto2xW0g3Xao L451uPzmyCOPZHl5kIseprhNWbWJUmAU+e9EK5iFDUwB+gAMAbtYiCKXs2H0DeggUxWwr8U6GkEt BQD7afaswg2c8bKOGHrcFN3oWtiQtN9ow9PWn0N01LptstEwdep6YvLlZf0x5q7xib/z9knpmZM/ choGJuj/wwvq4k4JuyMDjoSLE3Tz1vim20Mfg2AnpitKo3aeTWMmM2egnaum3tR0gZnf8qJA4u88 f28aAoMrCcwzIbJtSYGppEDKf6fys2SlkgJJgWVAgcTfZfCRs4lJgaTAVFIg8XcqP0tWKimQFFgG FEj8XQYfOZuYFEgKTCUFcv9tKj9Lc5Vi0ZGxG7rAFFQdjXVGjnUCv0wjsgfWXDnzmRO7jmxLsUkU jp0gBjOpPfhlSGg+25ytmiAFEn8nSOxJFQVzncJiq5tjcI+5WIYlnc5yQA6axAUKrKblSYFBPgjb PUy4ccxyUv699NJLmb504JAm9XoLjv4va7yDZJVxkgI1CiT+1ggy249uzXDVlWvHnIh73OMe5+41 RizDlvlsN2zpar9guufGjq6oQjHmzQ+CXWvkJg72OZmadM0Hyw9pbXLpPtRMlpzy35n8bJ2VdsjC zTpuhcCpnXPOOdDB/Y/slCf4dtKqkRCnDXfYYQcm8J1CJo5wDdJqq60WFx01kn9mMs0UYNHfTQUs u3NWP2xMx2Vdw9Y58XdYik1dfFcc7b777quvvjqGF//LEAQ5w9TVcn4rRJ7D4I75z92Ojh1ihx1T nt/mZsv+QwH3xtpH4dxEwQy3CZh/WOok/g5LsemKz6y4RbG9NZa3dIjkdpfq8zipbP1h2cHA8Zpr rnn55ZcvVU2y3AlTwKd3NZcD/S49GbbolP8OS7Epio/zdbGKywRdxjNF1Vqoiu7Y9d5Jlwy5ya2l CzuWnAhWo0wgue7Ibqe1SOpILPkXaa8CergBKH+w6wIgWjGxSTBUiSPyv0QezJEsSD9W3G33xCc+ kZLTUAVn5EUpgIeKi3t7xbTJZudnHPBli8eWUdxJ4aJPahLuWOtV3ODhRKI2o2rxIa/bM9mvsUgn p27WQjnb5+QAtRKHerSZhoFlTJkgr1zDPFQOJbIL6Fw7b2pE3hKYnslTgO6KS69d2uQu6sZLJ+gL AAS7rgx3VeMIRYyIv0o666yzFqQff2BkSzvt/45QfCbpQwE8lM1392C6+bgzmkvgMZh7771356th Q3Bq5Bim8QMPPFBx5FnD5jBIfDcEGgZ6i/s92WNjodj1lIMknEAcmtHmBteIuODdRff09sYs1NXO tuPYAh0zn0w+DgXcDHvhhRe++MUvpr7tNtjPfvaz4+RWS6s/Y4E5O96E/nSNahEGeRwdf0vuGOGN N974Jz/5SQlJTyMUoPzP+CxOirVDcyx7vu6pjJzdv0fP7OSTT67eYjl+oZgFX5NZW+wkGMKrYmPP OOMMOWNa4xpj/qc//en0i+G1PQc3vLlD3u6TcNcbs4Rr2sD3gVpCMQcW9Eu3vsuTqXIqGcxjimk8 HH/88fouvzuPV155ZRcV77bbbiZyIXYzxKShbCPR1XYs7SpROKcObpLncd8Emrj7jrLdwpsVP11j fuADH6CfgLWXRBxN08z999/foq0k/NznPofzdYcT6/U6czS5vB3Ng8H37dy7PFryTNUIBQwQbKIO ecwxx1DXtljfY489Glmsh21S+dOvdxc4xiLEEUNVe3T5rwEW5dlzMLSs3QYv2IxhXho8/mzFBI4W sMCF9MCHt+7mIEuAC42loZoDL9CZo+Tg+nQAsd1228Gjiy66qKk7N9lrp0wD60877TQXR8K1U089 1QE53wiLClWhLSDGcTM3rp998YtfBI4vf/nL4dr73vc+loWB18UXX+yVrf/jjjuOwVxHFXbZZRfq sezkvvOd7wR2jOfq/aXtIaBAK9uGorETD/Hf//73b7PNNq5QAtOKhl+kKzAXv0ym4cCICGYjfM1R Rx3Fxjz0V2ErffAq5zXWWKMWU0+jlkC2gIxxUYWOCqbB/bvf/e5SGbML59E8gRqWk+XVyB51M0Zw SWW0126t7f+o3FoEIaYNix7OsDc9c1CAC73jWvz+j535z198o8Z3jy9oSMZ6fb/99ttzzz2NJkAc r8b/jdtj5d/1IvA++Y+Ov1VddHeAG0V9iqm9cvK12au5a/kv7aN+zPnenM/PYYJgcbB7gzdcJtWG GMxQkm6vg1hYTm9xkdUII/uty4xnNYSha6+9tnwwpwwHh0qjj0utlUzTtpK2eIWxNeBPPPFEEHzs sceSgkFbEgwJaWKBZlhJmmxFDxoIpnhMGKYiBBFSrSeQhVPAV6AV4tZbbw1/+f1CGVjpRkutxpOC RfwpyQC5G7x29zP2XEw8ONYmxlJnzGhIqOXipl3RJE+wBdZVu1oTfmdVzBabb7551Kf2doRHNEQN HyvS1k5n9H+UpBYBV77uuusSSam5cW6lYp4rWNwZv5a89rgc4mMNa7hkk8DAIS7Q2eKjNPLroxhB xqbeOFSGo+OvPo3dUBjpoUFrVjE5D1j2gx/84GHZwAFznoZoPjCcintrzMDsLeCqwBPnww/ecF80 mmPkGHJGGq1v8tnAHbAFLoOLHLPVVsoGs0yYicAY4v4CQGP3j/hMoLvobZqdffbZ2FuMMDAlfwCm Ecf+bwgWwG5UhiegFiaqP+wzbVxwwQX494hAnGJGwUGXm+fNUgA63oYiHaCMSQji445pTUBGQwhH qTIRs5pKSC2mhqhYVJLY4Z73vKc4QjrBFyKThIBgBysi5zF/ffqvfe1rvnj5jmNmKLkVj81SC14b 4IHC2oLCCDV+5vOXA7LErKN7G5JgytrR7YjjfxFrviq5FBTcVTVwEP//MCODJChxFKkZnOXqVltt ZblaXqWnEQroMdgcA+wpT3kK7s8lu2a4AF/5O3JDXNBIQSUTq3iDGVCSJ+iyJK32kUCSrywOaCNC xXMBU794MR5xeIBybeVFIhxCYUy0Hi++yQNMRze132X/TeZ4Q7JXU5T8tVHMUpmqZ6211qK1hvPF Sgt3ro8RBvQxDRAQV1PVYmoIsY+i1dOqiyS6mm3xmxQJ0wk6mgJfOZPhgMtExkLkyXuwpb6+adtG qMu3CKysfqIzT74yXUscnf+tZoeFIfuohqR/fAqADHvolt66UWduoBDzaEshViGdEUYLIdOgn0AY itEmV8Vp4uBCXTd2qGBo5GzPgXAT20gaCxlry1vsuSUeiCSBhWuSYHiJkqnE2pSTrQWTOMKVJUQR pOQ40F7VJgChG0cALQIuWLmwEmML4wpPHWmrMXHuJiqSE2wyRoEAvWv+5BIM66y00krxVpVsAHaN OWCg2UImFig1sgyYPKM1QgH8gT0J372R3NrI5Gqxvhs2a8sfLEPp90SBhit+x8po2KzmL35/+cNo BO9KJfwvThBw0B/oGmHMQJtphB72zfrkQ/JLQFxjfiO+llr+3/72t6/KfEMOA22rbAi9juBTqjH7 FBqvDC1stdIXjSlz5U7sKjxTjiNw906l7AAAIABJREFUph9bf4vWbfAIoJwqa8ofBqfY9MccEX+n v2FLWMOJ4a82mvnsWZ100knW3UvY5Cy6UMBZcAsF+zANbq9H5om/hchz4xld/js3JJjphtArOPLI IynMWtqT2850W2a98kTbZDKENvbcGwffWSdO1r8rBRJ/u5JllgKJgOnZ0E8g7bK9a899lmo/F3Wl AkSflHyD2Jc4iMbIXDQrG9E6BRJ/WyfxBAogfrWdRbuLRQg7VLanqJQ5NNGgrHkCrZi5Imw80kS2 BLHLR+ZL4cFapGzizVxzssKTp0Az+g+Tr3eW2EkB/JfTChgx+3IUCRxQprIGi2120VrjeOynUSwL 15lDhnRSgB43PWWOB59rv5FzQs8hOpHNdrQDHcZD0s60GZIU6E+BxN/+9Jm9txROIQKn6hQYnG2j l4I1ZgaBNgKF2UATmlvlsMPsNXJSNaaPQU8jpitHQvC2MZNRO3GGlcBnUhXJcuaTAom/8/ldo1WE wsMeiJxncmTbkgJTRoGU/07ZB8nqJAX6UiAPdPQlz4y9TPxt8YMZKuGUYSXL32JhmfWyocBV3WpF d8pONdOfPfG3rc9XHRhVf1vlZb7LgALVjlT8xbMMCDBvTUz8bf2LGh6YX9tiXOuFZQFzTQGbgfoS N9etXEaNyw/Z1scOriRGS/xWLR60VWrmO9cU0JHM4tGddLDoY3Pd4jlvXOo/tPKBY2CUccIDfAN/ c8y0QvHlkakuVMPf7E4z/eUTf9v6fAZGuBVyh2tcw8EHlnzd1sPWLXNc9HA5Kv2MBjCNqBKjnVWT KhKGJ/yh2MtfNHxLyMgFtUWmGcnXp1TT8hse02oExocuv9WYI7Qv8tFhos/QO9Zz2CDlwtp6QeGI OUIRmWRKKJD42/yHMCoiU+MT8hotBhK75hx7iXFfgxDhhlOcgwj0HLkqAbuRSdUvwwLB1SIizsjF LcOE8U2rvwG+SFFFYY/jY6IcSs/RYcJBYcdAdKHoTvqVOFyUuAy/yHw0OfG3re8Yw8OvAbOAvdc2 hNgjV57Bg/MVGMwviCwoOWZtCshWPZFnCelaRCJylSyBs9WQ8FexNeKU3+LpTDVCSHSb6DkmaS7w Fxbzx6QuTrU+I5SSSZacAom/rXyCMhpjqATnC3zhbAwtvAzOFy8MgmFf4HKzVSmAW8XWqr/Z4uY+ t/im0czyfT1Ww5sigm4TrrpyYmUpWODggkUICG6q0Mxn8hRI/G2F5sak4QFtsTCw1YDhh33CjShc THC+XnHxqpV6dGSa+NtBkkED2sDZXmUHsOpCwQL7xfaGIKJIIbxVpUnWqldtM3xkCiT+jky6xRMa RQYJwI2ohopHAwn4gl3MLwcQwy2eXcZYNhTQVXSe6D/Al8cUzoHg8AjUl4SvAOCr9huWDXnmp6GJ v618yxgVhgdsNVSUIcQjf4DvAuO7gvPlaaUGmemMU6B0GN0G1HI6D/CNnVuPEcHvjDd0WVc/8bet z29gcAaPAsLv1xAyfoLtBb6ctzC6rUpkvrNJAV1FxaP/+F2A3xX4yxOzeIByRJvNJmatV1Ag799s sR8EvPoNIe8KuF1wIXDgDeSNxxbrkVnPGgUAa2ArnOVU36+QwN+FsBU/C7GS/521r1upb+JvhRgt eIGsXAvgxmMgb4BvvG2h5MxytikQ+FsQtqBt8Wge/2w3ctnXPvF3El0gYFdJxVPAV2DVP4naZBmz QIHA36hp+AvaFlCehXZkHftRIPG3H3XaeNeJtp0hbZSbec4WBar4q+a1x9lqS9a2FwUSf3tRJsOT AkmBpEC7FEj5Ubv0zdyTAkmBpEAvCiT+9qJMhicFkgJJgXYpkPjbLn0z96RAUiAp0IsCib+9KJPh SYGkQFKgXQok/rZL38w9KZAUSAr0okDiby/KZHhSICmQFGiXAom/7dI3c08KJAWSAr0okPjbizIZ nhRICiQF2qVA4m+79M3ckwJJgaRALwok/vaiTIYnBZICSYF2KZD42y59M/ekQFIgKdCLAom/vSiT 4UmBpEBSoF0KJP62S9/MPSmQFEgK9KJA4m8vymR4UiApkBRolwKJv+3SN3NPCiQFkgK9KJD424sy GZ4USAokBdqlQOJvu/TN3JMCSYGkQC8KJP72okyGJwWSAkmBdimQ+NsufTP3pEBSICnQiwKJv70o k+FJgaRAUqBdCiT+tkvfzD0pkBRICvSiQOJvL8pkeFIgKZAUaJcCib/t0jdzTwokBZICvSiQ+NuL MhmeFEgKJAXapUDib7v0zdyTAkmBpEAvCiT+9qJMhicFkgJJgXYpkPjbLn0z96RAUiAp0IsCib+9 KJPhSYGkQFKgXQok/rZL38w9KZAUSAr0okDiby/KZHhSICmQFGiXAom/7dI3c08KJAWSAr0okPjb izIZPlEK/P3vf//1r3890SKzsKTAUlMg8Xepv8BEyj/yyCNXW201vzvttBPPl770JcX+6le/4u/q dt111/Hr1bXQzmxPPvnkBzzgAde73vX+34LbYYcdfvOb30S03//+99/+9rd/9rOfdabKkKTAHFDg mnPQhmzCohT485///IUvfOEvf/nLL3/5S55rXnPFd8dy8ndNe/e7371r+FCBXQut5fDpT3/6aU97 2r///W9VuvGNb4wFPvDAA7/2ta+dccYZV7/61T/4wQ9utdVWz3jGM4477rhawnxMCswBBZL/nYOP uHgTbn7zm4t0i1vcAovJE483u9nNPnmVu/3tby982223jYDXvOY1i2e6WIyuhdYSQVvgC2F/8Ytf AN93vOMdInzsYx+74IILajHzMSkwfxRI/J2/b9qlRQV2AxPj99rXvvajr3I3uMENJLvnPe8ZAXe9 613XWWedJzzhCV/+8pef+tSnvvrVryYlEPLKV74ycj/77LM9vuQlL4lHEoNtttnm3ve+953vfOen P/3pX//614V3LTTil9/vfve7/Outt95NbnITDO+LX/zi7bff/rnPfe5f//pXzO+73vUub88777xn PetZkeQ973nPGmuscetb3/pRj3rUUUcdFYGYZZV54xvfePjhh3t77rnnCidj2WCDDW53u9s96EEP 2nHHHfH+Efmf//zn3nvv/cAHPvCGN7zhfe5zH6/w6fEqf5MCk6YA7iPd3FPg0ksvBY5g8QMf+AA8 6mzvve51Lz3v4IMPjlcErx6ve93rBl8MZ9/+9rcLWXfddSPCCSec4JHs2CM5BgGuR7B+j3vcgwdn /dWvfnXRQqV99rOfLf5Nb3rTLbfc8sQTT/zpT38a+fs99NBDIzds++Me9zghu+++u8gkFaussgqw 5n/LW94iHOzymzOudrWr8XzqU58ybYSMBcJCdoEPf/jDIa/Iz3nOczxy6hyZePWvf/3Lq3RJgQlT 4P8mXF4WN50U6Iq/QOqJT3wiGTGpcR/8fd/73iemHPCYWvfCF77Q44te9KJBWvqjH/3IxCB+cQ97 2MNwvpH23e9+t3DSCY+kE9e5znU8Ek14/MhHPsJ/q1vd6m9/+1vgL/Ddf//9zTH4WdX29hWveIWY f/zjH0Xz+PGPfzw2Hvk///nPe/XNb37Tvp/Hk046yWO6pMCEKbBiHyZdUqAXBV73utfhl3u9jXDM Jg8W8nnPex4PSPWLCY23/X/JB7DJpBmf+MQnPltxQHPzzTevpgWshBJY8gMOOEC44gDulVdeKXlE u9vd7lbEI1ElM8czn/lMbwO4zzrrLMV5vP/977/66qvz2GZ85CMf+dGPfpSIY8MNN4x88jcpMDEK JP5OjNQzWdBd7nKXrvUGhSX8D3/4A/81rnENmMhz29vedqONNgrhb4nT1YPXgLxeEdqS5/JgtEkk 7L8de+yxNfyNUkgVohSRCZr9BgPLU61qrUry50gz7PKJSdzhN1z4//SnP10VkP9JgclRIPF3crSe xZJCQqrmUNXvj3/842jFF7/4xdKckF1ARlpieNLvfe97hL+3vOUtS4ReHpE33XRT/DItCNtuopEg kynD39gPjIRgmidKwRfvscce973vfU0A5AlywPbiXkUoVY3IJAwEuyEyFoGyM4HvZZdd5u3555// 29/+llyYRJi+hxAcsd90SYFJU2DC8o4sbjop0Ev++7vf/S4q/K1vfSu65kMf+lD6CbG7FftvANSG m7e0FBzcCKQ+7LDDBmkp+UZkqwJ2+WgsgFTulFNOkfz973+/t/YACXY9hlSXPEQqYmKvKE4ID/lv 2RsU4uiHt3hbmhv4aNB8/etf/yc/+Qne2d6dV7e5zW222247W3b8hBJgXap0SYEJUyD33yZM8Ckt blH8VW+MJ5U1gAUQAzcDf736zGc+U7bRQDOuM5QNFm0tQNx3330DvuXMgW8bepHQybeASEIGIT// +c9JNiKa38c+9rFXXHGF8E78FfiGN7yhMNHyxCxHnj/84Q8f8YhHlEzud7/7kSDHq/xNCkyYAldT XumL6UkK9KeAVT/Iu8Md7hD8bzUyJP3Od75jXU/lC7NZfbWonw4DRWBoCyhpEFcz1z9pPvzjH/8I HQZZ2XNTEGnvSiut1D9nihAEDvR87bNVpRNSKQtHf8c73lFb+meSb5MC7VFg5vEXn4U6Nn/ao1Hm nBRICjRLgRy2Qc/Rz78Rmb385S+3bU3LMtR9ql/IEvUrX/lKNWRYP8bHcQC6/f0TqsM+++zTP86Y bymNxkGAMfPJ5EmBSVLgoosusr3p6IpxRHQzWtH0rJnjGDxtDtvBaSXm6Pj7/Oc//5JLLtlrr70c 5VxzzTVrRqrsOIdIcajaVCNbz9ohqeo5Vd/Oul83TZcUGJACI/R2giDIa5uRHBwntMkmm4yQiSRO IVIXGTztfA/bwekwYMwR8Ve/oTB/xBFHrL322nbD7cM4QVQtEnTa6ADQTkPZvLaL8pCHPOTiiy8W B2Qzs2Knm7DvZS97GdGeQHspYQog/PScmB3gl39VN9Oy5VWvehVRIP359773vSJw5naRdTWqo4HX ZJT24u1rP/7xjw8Fo641efOb36wmjleJSVE/TATg67fYYgtiQax9zQoM7VHmuBSkLdSbovRBfpFL vwynvZyGhCd/kwL9KVC6ylU9aIWS9aIOaGKAgO+DH/xgI87Zk9B9Lgkp+dl7pIRHjTqYJ+P0kEMO iQj77bcfHRKMs4SSf/jDH16Gw7bQqj3P6PhLAzROE7EVQP4AKKu1dPQIbsIyRlKgoSNGd7rTncKq 1uWXX77LLruAUVvSOkEcJIWPxUIKmAajb33rW2WoExQFe49OwcrKOSm9Yeuttw6lKHFsi7NIoNDj jz9etLe97W1QktzAiayXvvSl4K9rTcwQaoI1cOAV1EZaCOsUgIrxUG+iN1raxRyMnSVV3WyzzZyv LeF9PGXM8BhmxCnxa8cpnJamSwp0pUD0kOgzBaNLj+rT67yyJP3Qhz4UcWin2BRlRqMk0fMxHKxn MK9MUzuOjP/gBz+gohdx+NniYCsDo8MoEqtMy2rYFkK17Rnx/IXdZHrvKveNb3xj4403Xn/99anE d62rCRabaX+MoPYFL3hBxCG7cO6Tn3rm6aef/uQnP7kzrb1pgcWoSkSgaeSMKWksBw11UOEY2DCq Ai7D8hbDXaQi1I/M8ELiNFTXmqh8HKNy/FRMW+3HHHMMWLcLr8uytmV6WHnllaN0XLlOyc/WV5zX ivBev4aKV2XA8OBlghcWHh6/vZJn+DKnAD1oA80vOvBwxpEOw/HrTis0pRfedhKKMWVOOItLWJAw 31GiUawG0AQUQvbcc0/25Ch6l7fF4xCjQWS5eaMb3UjgMhm2pfkT8IyIv1Ez5lF23nnn3XbbjRih V10pCYVyAjWgYugPekZ8WkSWSLW0QKoWUh6drQKL8RjWBvjt9UWIvhLCCswCPLX/AH9L2q41IQOp pqXYpFuHcQDhuGZQXvAX/45TwFk7WGXXsYSXIqoeg8RjYK5fVfJbPflajZz+pMAgFGDnk3JeAHEM q174Kzc8NYkc4S8WB9pW8yfrK53cuDBwaht0Xcfgchi2VSpNwD86/mJFCU8vvPDCYIR71VVf6XwV 5g2F6xxFizMAyytMaGeSCKHkX5ZIxBeh8x8dsSTRdXS717/+9WQIGOQivuhak1ogHln/1jv1SBmG za3gqT0qiPSDHI11Auj//e9/36RSyq15VnAp//63ygT4wt/g1gXWYuZjUmAQCoBaXUj/Kcir93rs CsH6m7UdxtYQC/ND1SKsVp0RjxCrOr09Fpr6agSSPwipJuFfDsO21uS2H7uA4yBF+k5uErM8xwxi OTnfe5CEEYdkSnxiASZf8ZICSYddRcNjuRRx9CrdS87xGL9PetKTRDCxQ2Groa7sJNAkwHVWVfI4 wFrNob8fP06oHXUgI9NNCVhKEiUSR1iO4YLBdBFYlwjFY1RwqMRpKRGeyH3il4TpSQr0oUCIiU3q 4fQu3axrfMwHMRqb9GIuDNA/VWMaHdgXDIS0jnrb/TbcSPzs2umlVplhUsNbWF+WrXM/bLtSstXA EfHX5GkpxBSAmTPcm970psErim101UIsZ2zESWgzjcoEVprdQlgsBHo60e+wPyFAyRnwKdrMrGii jxBLlbfhsc9A0Gzbl7MxSDeD6LkWp9ej3oavlzPZAkfOK5MSWQ3xFJZySrf/Vt3QKHGqHsND74e/ 2Bau9ONqnPQnBQangC4UfUmnWjG3L+BvFVhLVp/73Ofo7VrPXTVAb2BVV946EAhzjUGdmQAw7Hba CMEs2/mgTWTDLSKTERMw4pM8LpNhW6g0Ac8SnH+jr8Z4ivU7FcUiftVUOKtvVU0BCITynUwuzlTC WIX1ohEGWc+zBQEBZRI37vSKXAvHZWB7FdGJsJhr3AFo7lzTVTMxMJSL7eXkhqcIHoTiWtfRUk2b /qRAVwpgUfETNHA4dpCvda1rMcfhF6fSVQTRNZNqoDFiaEDhMpT0WzvM1VEpvnUqIZ7F39wP2ypx JuMfXf47Zv1iWq5m0hnibSf4ChzkzD7BSGSubw0FvlLB1rhQJ3Ko/poeajNE9W3xA9lwgcKxbKzJ Ukrk9CQFBqQA/ld/Dgd2g/8dMG1nNGOkDJN4K88a+AqvbnJ0DtLOEElmdNh2kqjtkCXAX/eNh25Z 221b2vyNDS7kD1aLWOCUPyztF5mD0nWhYHv1q5jg9TFwPIGmLZNhOwFKVotYGvyt1mD+/AZGNKrg bxFELGFj1coxJ2tJu9icbcb+iitLWNUsuhcFCOjM5eFAsA4mpi87mvyhVyldw+Fv1/AMHIcCS4C/ 41R3htIGe+LXIDFgYttkkvXHcZ9zzjnOPjm5RIXOL8kJ0aFNS46Yz+2Tk6zPLJZlPY67JI8KR/XF pMXZAV511VXtzYowyXYRZAUE61S6lqLjd5J1yLIapEDib4PE/G9WMSpikPgNKYSR898YrfkcmKbC ceaZZ9oBBxD2r5/ylKdQMmENgKiutWLnNmNfLcT3FjFO0juwyznaftBBB9GcdYyTqoAt5WH3GEaj lzroS5xOFS7xdzRKTkmqxN+2PkQMDEOFJ4YKf1uFLeTLLAaNbKZSHMjedtttaWvic1stcTlkTseA C0raraLBUlrNEjzzNBRpccTsSbEKQqmrvG3DoyNZSxXkTfBtg8iTzHOiq6dJNmx6yirga+S0VKsw lcLYK7UNR6hZsWJSI8G3JWqXbIkjWLFhoZFKIkVap/CdVg+bUCVOs54AX7CbyNssYZcqt8TfSVC+ 1dHitjTX9zq0QmfZocRBLn6fRJuXUxnUrSw4HF5glcnZHMb5Wmp9dKTqb0sFZbaToUDib1t0NkiK UwYu2GPjhbEtxyoQUa9bLGkmNZ7/yBmSVHZNSwkah9711awHUkJw0hIKMxLiPGd7zan2q/C3V1bm 3CoFRsFfppJ0tZo551ZrmZl3pYB9Njazga/jpF0jLBpIR8KntHfEOezHntFhhx22aKpFIzigWJWT RnzI6wyVqjKNT04y1IH1RUskWx9f3sJsCNH5omX1j0BGTCL8zne+02n1/jFHe9vGLD5aTZZbqnXW WcdnbbbVo+BvszXI3LpSgHIYS5unnXZar127H/3oR5tvvrn9H5q8XXMYPFBWoMeEeuCBB2655ZZ9 7M8NnmdnTOJRxwdYIXB1CFtLLNKyl98ZbalCmGoizDWZjV8BeiZoyEheI7mNX59lm4MNUoqDrFtM rapl4u+Udk4WT2jsMqRJaRcnVawFlupa6rKcwhJFCRnfY4Z30p9dDqDPND5eFRt7xhlnyBnTGjc5 8TPUwhABvMYtOsrokicqWcLZ9GCSlKJbHPazH0gqvf322zv3IU/3RdHZMh7EJKR220jIKFjq0goi bHZewgq4G0nEZEGfhSYG56gwh418CdUhbh7RdpZiGM+j8iE8XNeYrNmxY4e1D0vTmqaZ1g1sgF2V bsW/SiqxGjKOn0SYXJ4UgtxpnHwy7TgUsA6ju4KrsN5iClxX6Wpmfpwixkyb+DsmAVtMTjIQZ9Ws etZYYw12UtzHVe5DcksT+3CNFE9TDRq6KYrdOBpUcA3qQXzGnd0DRq0KNgFitzQpDgPr6ilQxcJy 2OdkFDQOR3klq+OOO451GGoAFGOZ4KI8q/4YEPfcMEdbKixDOgNW03au8MLEpuA47IUSECsCd8zI vVK0Hb9sLEkrgg0uuantJz7xCdbyeC699NLItjMmcr32ta+lk8dpY9xSCKax/G4PKJXhMZ81K7Sl GuzYS3tKL9XKp78XBRyQ0a8wBDrJjjvuSGWFOjzt+F77E73yaSl8CfR/9ci412TBkNP1J3yCqCU6 VrMNCZ3f0Dzzi+fiYigOyGRZOhVJn4Qc0LGSwgszFAfUGK+q3u5RrcCwforDzBk7aADT4x4/UMUU MsySFYHmueeeixNfZZVVtMIrjK25AYcOs6yy2WeBtiQYIkNMDYSVpMmkvT6uy294MLDGAFLUPjeQ xUHHZU4ukYKAbH7Kx6/tRFp0dAmwMMx+QvaXvOQlRKsmIVdPkRWE1BsP7sqoPfbYQ6rOmNEQ9fcW Nw2v5elIG1ivmpXxtnFnEsJ20QumnRaZlw86yKM4tfhCfH0EDOeRx69vwXXGryWvPS6H+EZNtdVh yZa9Y2I9V6b5RYSldUuAv4a60eJyIGtY49aocEyLnV+/1tpLS45GSvfJ4ZQJFkqSePrqrC5YgLP1 t/vuu1uWDlKKvTW3iJaYiAaPGH6DQQa2qctjp6nAEn8oj62wuCUEv0YO4ObTANA4sOf6RYHMYkGT s88+G3uLEQam5A/Gf8Rxk2MIForFTp5AB5gIHXxlzXfJKe416sY0OOLgoLEkEWK0AOjwayAPoIzx A/HJQ5z6hdT22dzOoDKdqYTUYmqIikUliR2sIcQR0jb4KkXN0dPc5ntFVQMlw++3/2NnBDMiEY0x wqovImiCr6YtekKY4OmfYe1tZ/61CLXHWYzvInP8gZpXnW5pNE2gA1QL7eVfAvxVFQuBqJARaExi T/A1QNn6lESPmVG/MVR61XuawwN/gS+QAr5kCMAXexgc4oD8bzEMaKQZCSQD5J7QKhquCABkDuu0 FjgOZQhJwSWgJE8A7kqEXPxxrAu0EaFCE2CqFNIPHuebXaNgJ9DGXbXohWO633YwDBONB5TKYADT xAXwAktI5sA8BTTBMiORZuJwxaxmUvxrrbWW+uB8RRZI4kHQTDBikiMqCeY3ItdiqjyRsaKNul13 3RVylTzb9pCikAKThmtvU2WR4dBUCQiGIDb64K9PFvjbVClzk4+1USf+mrTsWMQdN0ve0tHx1w5v MDjagFspk/xQTUILYjJOKphC5giLLRKtOiFXwWIrX51sqJxnPbLpBzPoRmfrd7+1AQaRHbWwGoWM RmCDjSUaop9gtw2emghxmu4ciavAYBnuG4ZGcWxKUGmwkCcYgYw1dolUgTzBOoAENjbuMLw26Ghr 2JSTLclymCFVlhBFUFCzF9erLQQgdOMe85jHiIALVi79ENODlVPhqSNtNSbOnaEc/QdzTa5NV7pX /o2Hk+TgMxoE38ZrOPcZRgerNhPg2BDeZ599qoGD+4FS2YDBRMcN04Mn74w5yv0X9H/LmjFyNCb7 XIHcWeogIYybwGLLN780AWzXBF+MwcFWDJLDUsXpw//CMm8HrJgZrr9AZqONNsIE0SsYMMNhozE3 Az7wXH0SkiBh1bta9tFSy3+3U5d5Wj6xDoC2um/JlrDbxrTAaszytpfHdp9ZvywUekUTLnPlWr/3 idPsK+diTJBAvzZxjlOKGe7oo49O/ndRGhL3WUsR9DGTZJlohW2dLRXwtelqGbdoDl0jkF+Rv5VX gAg6lcfRPKPg72gljZMKQalSBhbjzjAygcV+JzmoBmxCU/i7aHG4P1MRttSiftHIGWFiFCBawezT Huk/dQ1bn8Tf/hSz2KISQ0Pm1FNPtaS22CKnMvXiAEyEWASiKkvq/plM+O1/eZAJFzxUcbg8ckZO KlS2cQeL7WPG3Z0Fiy1FG2Q3hqrhkkQmk7EJZkOfPMuYD7HsktQkCw0KYOSxvZQ69M9mwTcp3IcC 9HZwuxYHBFnYWxvIVgkR31ewTKTqQKNx5GOifYoe89Xs6f9CWLIIok8b8SGjAED0TO1QYQbJQ+3G 2M3DMo9JmplITvJuVrdtRQZKqmXrbCaqPX+VtNdKPO0giR1Ra7XxDyXOH4kab5Hhb51BxE+l10Cg 1m1xbL+kgG+UaKuWqGoKwVf1ZoP/7fPlyB84BrDFgT7nnXceefHee++NB7H1XHbw5ng84IIJ32nI 0g0w/1OMxYJpex+i5asGKUAR2wkr4IstoNHR7InEBus5N1nZBKN7Ts6ApaVXDl4N89r2b7Wxk1R6 qZY7iH/m8bfaSPwvTpATSDPJ54HFlPNNiaQ/BYtpcQ21z1MtYmr92C7rL1ujdhgcPLMziw6UzKkK LCuZzMQ+0Pnnn+9ktsUHPTPn3kECAAAgAElEQVRrL5s8oSUysQost4KKeJfg0VYY5UgL32aVfyZP 0tnYfxufLjQoijaF07T2LkNqvPrqq9sVHT//ag4T23+rFlr1U1yjGgwaAIRzvVZe1mgc1oxChdWZ wxG1NVo1efqrFLCoojtBzk7xiKYdenKXXXaZpYbpzSTnFPVklCOX7f4b8S5uF3tBn4x4l8Li3PTe 5YK/1RFlLBUsvuSSSwBT2cGr6dVVUw3uX3L8rVbVYg1YBGrQFdP2QJMwslONmf5OClg62PuNGctO DsxdmMju7+T35Fe1yw1/qT/CXMhLh4GAkT7D7J7J6uxaEbIc8bdKC9smVo6h2UZ2bIwVLHYYrBpz cP9U4e/g1c6YU06BZYK/RbxrC4fqAobXSZY+4t0p/2r9qzdX8t/+Te36lgL/Ixact3CTkSRYzNoW XQIcIpFxSI2doZrMGrNrJTMwKTD3FCDedU4St0u8S3uXeJfS2KyLdxf9assdf6sEMsdaV3JbbbWV cPvaxBQcXTdLeGdYA4sxyP2PpVXznE6/mcb+ZM4o0/l1llutyABDe5d5Kdyuw7TFitPckyLxt+cn drCV/Q5ODGsi+92wmF1w5gV0lMBiv9O8682uDaGKXSOGuNzOyeoNtWiBmoPxJ3vp2fh8sUABejJm KSLgcLQYiSDp9vldbbXVpvwc/JR/wyLetdAEu472zp94d9FPkPi7KIlWRKC+xvJLGH+xUDJjw2IK BrvssovHgsUO4FXNGgyUdQuRSLRdAekQCi0I5zKciyPLdt0DDzX1MF3YQrHzmSXTASYtjscERpGG lSh23M3H9Emc9+Eo+c2rgLLxj2ruZ5yBnIF4l/YuI6tzLN5dlHrLff9tUQItGoH1RVgcO3iO2VBo o9zGwWKsk96G3yz2J4eyv7No0bUISmFu3GUTwIJqpOPaJNuj2aWr5ZyPnRQgwLG2YHDAZQosJbGS zN5b9YKPziRjhoB4+gCUMWbR/iSdyDDOQLyrW2J4ddHsnIm/Yw6K/0kOAeMAHkR2+sPBPFJjAmUa uPhiil8t4S95rrutXLRDF5WJyKbuJfqftuVDbwrghU179otsFbBJ0hKszCj+hniXiaiivbt8xLu9 u8x/3iT+LkqioSOE/hkmlBzAmXTWAGAx/GWM3Pl0xoPokDZ4AI92OvvidoqPOOKINMEz9NdqLoHD h+5PYvOQLSQmm5vL+D85zRb+Eu+ycU7O4AALbncutXfH/8SJv+PTsJ5D4G/t/gsnIBgkZCWAKFbX xKiG1NiVkWSy9SwWnuVj94/JcKKMrhEEMjhAiMb+gMVvrzhLEm553tX0OCPrbrKY5k3LMclF7O44 svuVwybJmLlVk88E/lbFuyyjQl7SBjWvNiT9hQKzZ/+sVH22POwzAFx1psrGYgBGyake2OrEB5Gx ixKYFHEwutoozLIDxJCaYIEB0+qr8LP69oQnPIEduJHBlwqEsUGkyFkVmhvMEJ0FDRvC7DpjNLVU kNdFnEQxzo+yiu3SuVqEcR7tgtpXHCcHO5YkkiDDhUnlGroRMiR2t+iBO3HX8gg5zGISFHN3iVbr 5zqkBRkm49BDD6XJm+Db54Om/kMf4rT1CtgZ6pwCsMn4YvJi11i48sf1P0WbQiBYEQFUufLSrjHB RakTOGNISKDN9xI4msdl7GEEAwYxaACD2lBwZqSNCoEtSqISthQcaTE4/Y5W52ZTUWwwN7Bc6hJY MnoC3HFk6Lh7B3nswZqEOq/AabbmS54b8S4hA/HuMtTeHZ/4yf+OT8OxcgBGANflvoz226CzO2zc Ql7qYvvuuy/wlTuodZ0lNrnKCAMLpiaf+tSnjlX8/yZmVgoQ20WE+6qEV4UgeHCxMK1xjRs/iQcp NlMSxCPwhfV31RNOxscYIPVYbDWoxQ0xmOC6LXy9PE0wtKe1V0zTDFUNMgp+fBNFLlOLy32tCYRs sskmYrqolDibkh92UonCOXVwMorHTaCuQUE6G48Lb1b8dI1JCmmiwtpLIo6maSb5AAqXhGT0Zh1b l9T1WPKMJpe3I3i0yAfaZpttRkg7E0mcTjrggAN8I3dM0PNxZNRux7bbbpt7a8N9PkLGdM1SwFoM sth/g1C006iL0k4DrPbHfJvBy+q8VI2kGCZiV2VC/x9MD55b15hQUpUwL9aMuBiAjisXU21JNnCp wJFOFYktQ9cuOfaK8ASqaiOZye67725ugJXkCV5BQyrSoNn1mrI9/PDDEcFhQtHw+FamnXWQD617 N656RXOANiiPpoFytyuxpSlPkxC8lqdXuFQSEkq48Nq5Eq9oj6Iw+YwjEp0xTWm2PeMECl7bckFM m59MkgYZa1WyWURfBcrXwkd4RD1V0sAR0nZNgqT0z6xRCKYcqFF/em/or0Vd47cR6IM6q0bG4uyJ /gB2G2xgGxWe8jyT/9Wrp9GBmFq1cKZ2tMCf+6wADTlyp4y1lmTAR9MDzhGaU6VYaaWVpMKcUp4j CXXFgHOAXjn1R78K8+gVxpZQj8Aas+N+byjDshqkk5ANeDwRj1ew0hQC6bD22F5MsbFaqxIlfBx0 iFBIsRlrjgg4R401GZBXYK/wpKATItvdwnSffPLJpgpTkVceS6quMTVE/XG4uGlAL39WzVyf3GmS 36wDo1VjfJGOUshwFOEz1Zo8i48+HMqbFLUoxLv43xTvjv8pU/47Pg1byQHvbCsZfoE/QGMFjU8E JWSLmEHYZGKHwo2ompIvh/wXV4WvdH2WDTQACu+0zckCgbhXTK5DooYfYTQwVUOMZMRxZj8EC2X5 yRM6djARWMM+rKUlarkrHkON+9auYvMTH1cAOnRCAKVmqgPEJw/Rdshonw0vrDJB92qqzpgaomJR SWKHOOEqxJwRycsvRMbsg2DX2pfAMT2O3vRSbhkz54klp7eD4bVCMuv7CrqKHeOJlT73BSX+Tukn JgW21usUQZTqOtmBeYwj0SVwTA8hKbgElIShZA4krZCL3xFbORt+RKgQP7SM7VDxWIqSsViK2jys lk4izFn7Y6Lt6UllTxxMG8kmD/tdlGQpz2ESscxwCqricMWsZlL8qKE+Bx98sMgCyRwJmjfbbDNy HgJiktZeMVWeMEHRJoNdd921l9FeZ9jw1HjkmDNKbuN4VNgsRUg9TiZLlRZ7G7Z3iTh8d3KGvNGq jW+R8oc2qNpMnn3AVwF23rCQzZRUyQVzTbxot41yG0tvABTQh7ouLLOQJ1WI6MS1BLvuOiKiJWSo qRmRKljIk+S+613vApSSqC2G3QJWIK1nacUBu8oiULbwJ9AomVdq9B8vAYi1fMw3uGAbehhVEwYq FZ46olZj4tzlHKcQSVdC56Qzc3IJGgtkL5g7zjG2zjjDhrz85S9nvnbYVEsbnzTZBGlmtX9oMUSy b3JlizXBt6XvkucvmiesJXPojWF/2rP/oAhARtW/EbDoSgUqnHhVeNT1bQSS/JKQdJ0q0MHy37q1 ylQSE3MAvWqoyLXtNB8EVmP2KTReEQ1jq5W+aEyZK5T0ZtGYTUU466yzzEy24BrU5DPDtWT/gdjH KsEGrMWK/UwMrxuF0bYpaixVPgRcVDKo0/gWQ3WtrhW2iiKKsUD0lmTM4o/GDkJ1jTxgYMofBiTU 1EXTA2yIYSd1CCLaNupH5rtotmTTveLACxxu7e3CUY+b1wKJgIsUuPaqz+PgeOo2Uq5PVs2+YgPE hiHJaYPg22wNS27zLd61pqF9aMcCG0FERp7Wp7sWmvTxQHMScBHMWG9+85vt/YaWS58k/V+l/KE/ fab6LXykDrHffvsRgIYm2VRXdxlUzrBkiIdoiCyFHtvUtphsGo44107L0PxNvEtB0EKq/1pnapvT q2I4AMhrdwFK2lUmjOIOOeSQUDPvlWqQcNy0VYLtB7vQg8TvFSf5316UmY1wPCDtMaq4BHZOItgN m416z2MtnQQj6abwQFWrqGfYsaR9HM0NXY7S9P6PotUiCCFMp7wBMTkCHA4QhOuMX0vuka4IiZA5 mzTGcTWdR7exF7rXXnstmnzRCLXipiE+FWkCQDXhQgeGqrhpBiNMOj/C9gnAjQzBrs1kU+yY+6uJ v/F1ZviXCIISLvmdTTADkmWJOEE7w02aqarjea1w6WPQ97AWwRZVq2+TsEghaluU/R9lUovgAKHc aM6RttMX5KAw/i5QuDN+Sa6GdlPN0+zw2UlzmNCGpLQlQlS4/2Of/Lsmn4b4jvPYJonqlV+7Mvx0 h0rI4B4aOFyJT1ux+Efz5P7baHTrlwojMIH9t84aKJR+LiCwm09jzLFgG9nYnM6YGTI+BbCQ+FyK a36BmmnPWr7VPSv4OOz+G3YvtHeJqpyeoGoyZxKG/t/RvOicTi2OBQqbVo6Ym7pqr/o/2n+jrhNc M5nGTjvtRG5jMdE/Vf+3yf/2p88svbUjZ5+XI92DC04T7Lzzzs5BOHSAb+LABO6JDqzNqF6asLPU 4InUlRY2XTeOx2CjA8e5TI/2BTU4M5w7qEIheiLVGagQHSC0d00S+HHzMUW9gVLOUSQqzPbfag0y QTrIw+5gjdmvRev1SNRjteGtNQ39SxYF4pBUr/iLhif+Lkqi2YvAYgNFWg4nbuEJLEAGNo05BTsP oMQvNLEsnb22TbbGxptlvrkqHF0605jtNb9kfzEUJ1ujfqXR3mX0EsNLgzusQi9D84+6OiJQpHOC 34oEO4JL1dV9LJyvUzaNHC73GUJjp/8hqX5fa+Fd4u+iJJrhCCZ5B3y5GW5DVn0xCgAX6sa0d4GL szD2AKFPq5KQxWo06fcoQOdPq1GAeNcEyXaguQfmOjG0/vrri+AkEZmDzZKmKmcRKX9nOGmhjZxn 4u/IpMuESYElpoDFDXNIzA+BFXIGBiGXlXgX1FrVwVz7YCjgKASBLwvO1a/iDKftSufaLf6GFfhW 8+Fnb6gaQtxHHaIaMoI/8XcEos18Ejt1us6yYpFm/ptVGkCqy1YGq3IsdThs7V7hZbXEocyr7bhd DWcCcMMNN2QX2xH2CoX+67UEdDvqmFpi/82uaV/ib9MUnab8iHppHYX1W1JgZ/nt23J0IYEvceE0 VXYa60L+S08rVL7sfTvrbA/Tfibn8DdbGROutK9JtutTUm5x6IaWi++ohhOuxpIUR08Zq8u54ZSe O9jFkA7yCaYWfJEx8XdJ+lK7hbLjxUq3pZnTpdZfYb6S9Rzb9LYg4Ig9pXZrMEe5O1hoj8U2t+mK 3UvYxzCNk98EjrAYAnKsAo22nz4IncguKTAQ74oMf0kznXxlKsis0F6hg1RsMnEuuuii2E+jz8B8 knMTCD43S7fU/22+Fy2V/q/VqIMY9H/JFvRUPILdmDDL23wjl32OzpKZ5yyBqfq5ed41Hy48HsRi xuCUo70Ldhkkw3cT77pAb1j938HLmqqYaEtpIfbTQK39NLJdSruWI1NVz/Erk/zv+DRc+hwgPrMD LDq66xtz1KxR4KVv3lTWwN43U2Hcnnvuya68k8FsC7i2gzrwmNwZ7V1WYyCvQ64wHcRTd0MD+DuV lGisUtYZVBRIGE4//XQKyzCXDvv/b+/+de4mmjCAd1+Z2+EKkGjoKVLQRNCQKE0aSpIiSEiICgkR KRSkSAruIOnTpIE7AClcxffLO2hZfI79+vjPOV6fcXHefe31enfWfvbZ2ZnZaPtiz9hYQYm/G+uQ 06tjgia2E60CzWAE6j29jLxjlgRsjeoAl1zAAYfQ8ixPTy0xrHfBrn7E+IyjNuy4Bg2D8QbVddgE y4yNYldsIDbspwqwxfyJvy322r91Nk1jfsgnXZDTf89uIEUHctTcB8r43nY5TnA1ZApGV0tXYDcj /r5j+qG23qWsF9CZuvMaFPTU6DfLab9JGK40nPYMjRgjtN3kSfxtuCstr9lE3WSNqfm0ZrCg9KnH IjKqBUFs8INNTyut3CXIli9KPLByRgLy2uDdqqCQFBa1uOfxoK8zzEmzqLMjL9OOyYVEnASaViOZ Na7J5XC4skomtJilzuH9L3jHxkNxPZAtUtqEIMiT63mRGw02rMHALrZrSRPVffz4MZpPmXOR+lz8 oVfa7IvLfX4FwJkgh97jyeBb6iBMXxAuVhMs1VlKlJBdJc/8BPUl2BU2wZIgE07bAqm53/klzy/B Sho1Lv8Ffsbwl+sqNJ9cLIMnnhHWi9ioHdqlFvWuVTuwW9S7kx+3/RvtO2Xc9a5ylGC5AXYpuJfa vXv7zR+o4d7WEwea2twl5roW1vqqzebcBmt9G5r13TV8HhMBxKyG0UlhShiu+UgsibhL6CwhLuN2 sQXevXtH3Un1YYcLtqhCL7pkxs36glUWWg1qgQv0efDgwfv375UpfKL9xMIeA+PmuBXuQ9ZYRKG1 eGU3lwiMDQHltI89gznba1ILemI8Wh0Eb5XGFsEcdaGox3HJ79GcPnXuCdSybpFH0zTz6dOnpg7l RqIWk4XWFXtlw2BiUS5NS1g1ElRXULRyu/FSTTBrlxg2UO+aJVBT7Hh9yd6d1Nn6jleesU0vI79m RSST4PvPi+ELz2NZCZhkQRaLuRDKh+1jMyE18ouWROgjnwXgZIaGdILeV1pFBdb3Yo6Krc9MSENJ T2HhxHHTpyJYH0BXjtpSIGCpwNHsGGUTdo9ewiUxwKCqNgr6zuICrMBKTNwlaMj0Qs3ZySr22bNn 6swwSzbbK8C1wxoqhy+D1rkkoJSArRJoIyjnJMJnVJnYE7xWpku0Fj///DN+Cq/5lbjEAoGEWSyx hz3MyVWM4394oJAYtzE5mTFZKMP6O/Ux0tBC2mtZ93UuTfgX+vB89TgMV7Uxa+ALgklsQmluIVL2 Z+YoFujoTNXfI5TmEdMKXOku7/z3338vzA1lLqpr3PUhrPSs1otN/uut3uJh/kuBCB+B7DfffIOa OQNKgCC3HwQTBomivUjVPQJzFKnEDsGmh8pETmkwTRj//PNPKlGX+LlyOkAeXUJsKYttsUNfbM0E 8NmFE9K5kfoYb5VwCegAIEjHWxTtVWdo26mwMNgYdISkQuetX0UGhlyW7wwG9BX8u2ynBjohsmks 0k2BaKhAz13yb7nraE4NUX8aBmwa0Cuf5z7ieRiKxe2Cqmgyk5JOPSf8q78Ik/QePXpkpx/9hcub RoSqZ0KBG7/FuMslT0u9lkgudZN5j7VEr4FN/zZe+UtVL/W/l5L8Lc8FvgArMqFj5u/SuCcaaBcD Ma5gmQwzTU2jfOY+AQpYFV5ppyxTYwAaW7bY3NNJ7BXJFd8dU37x4oVHIzWIZOSxF0soFtwVZUqE tTxQA9awj3sIO9myVzxCbXShGSiLTnhcAWjNVw6gRHAkID59CKuJYFWEoDLxoPquw5waomJRSWoH XFseZ4wZcXv8UmsY2ygfHKoN0HHwOsO0NPqP8PLXmnb79u8ifAHAYj3NeIntmsGYQETXb7/+F69h 8t8LdwF8gRHMyLBa4dIRPaox1AlSBAaV+uGSLAewTkTD+y3OEyAuVxdJUJKCS0BpCQ4i07Saj9NF xPI0EKRChfjA1K/Q4xLySABl1avrQCMcSmEk2pqe/LYPANOh8+XLz0hW4XTHmGnYLWC4ctaFlLRP mg6EmR0y5eSnn37K6gMZNwwglfVdnZwaQqfs0eppXoyRlTLrBIUvhWygv0GO0qO+Oi3NX1YNdwm+ TBdevXrlfTB2GhdpqPSCORAlL9El+I5/YZL/jpfV3JzIgiK8qYFN3lcJXzuqiHyZTfuFF34dNJ6g BDa5BRCDRYTRxm4oYdSDbZNFpMVd3TyXetE0+d69e1TPmKaHhrmuujEgg6FRAepac0wTedpVyNjx FKBVoE8AQJTIsXCn/rS6Zv3Ux4q1VVrsTu9ZzngEVSZ1cxR++EsBQvMb7cWCY+UKsTXhLZw67qpz Yu7UvmbEhG+9ziLbYcnOqAOAFlKdeDFr+H4020kn6cfpRk66ZeOZjV4GY2zXNAjO8k/zBi7rcr1x CSxevYz/sLhIP6ywoZCxSw2tH3iixIQ4VkvgEbYYCBuAK92nQ4CASDHw5dLqY+7oDRXF5wqiMTBY vg03Jf71118mlcMhZY0iVJwd8hv1CWpvz4iaEFETO6BtbfL5999/Y6lO1jlvbRSpEp2n35pT4R5K ETyck0EYvURHzsO39F2laDZUeA0su/XlOfW8Ee4i8R+8wxEBh1GdJURKBhOOa3OUOLWzRuZP/B0p qN5sSEHNZ6VBkgkaYMXvoI9FGKQSQuFWVs9CodlbXHUB/Fm8GgiyZ0oOfWjcrFZV92XywhKw3Aek kMRlw/KeE3+9pWzF6I6wXaNXRMAx7Tjq03hhcbf8+NQ/jO09fBOHDagNkI1f/LTwWdpMaTwOZ2QL RTsJiCk3rZ7d0L4PFgLjDzM7KtGB/PRuOKCvAhDjyIsQt4HH5aVbJeAlEQiJvQrkWhZ8b330Ihm8 tJRFsZ5Gt0vDwDZxIz4yizRwa4Uk/h7pEbhJLRv62QK4Vm/gXUCtX0pGv3QIhxMx3MF3eKTcFU7R aQpEKygqr4effvqJcmOFh2SRoyRgXZRdCoUDCKNKHnXPNjLRkzAuNGbQvzMfRN7D2mQbtdtzLa4d f715gbM12rKsgmuhn2WHQOcVrNYi2AbfBSoIakEWFLytTFH9QoHkwmfrKWNthF02QluPMjCf7dEz H8TwBtV1sAukrcZ2kfdiQTiz8Lx9jASuBX9xUurUQmaLAsGyeOCsX/YGTGpAbWfJaIwcL56HcSs3 MMaYPIA58rJjpQz55JNPwsbg4tXbXwUs1nEGEXwdZ8R2xRKyKhVG0BtvLOeIWE+jT2Ppcf/+fa9K DtgX6bUd4i8LU0yk5rPQlj7BxBC2xsH3P2B3T6M94wEo7LAkCBQczK1E0kHhud6LM0BHYX2fHOK4 yAvX3EP5UFDfO+jxvUVsAFi2MAkAXjTvFD68q2n8N94uJN3YHOtp3hPraVyE2RcWc8aN13+v1ZuF vz5jBpjRhT5senrk65yEy+pWobQFcPmPMjINeIW24gME5h61kdplv7K4QOQdWH/sVwY1KCWZUgSU +AUrxdlsl0JYpFGgCjGM4YpTjImRkYxVL0cVy2u1Cd0ij1u8EB8Ihk7DQL3rK6BhkGhLN724TDZV 4Cz81ZLXr1+H9TtfUlyAvRQL7TVaaLpXoDYSABeOBLb6ZTZvVJegut3+h7GGiA7LpA6GFA4rKodX 88xeJeBjQXUdbOB8nnr/aLyLvTa/oXbNxd/SVDSB7+zz58/LmWkJpExgJwhb+GykGR4WqDXFZkiL 4abvzTQh5127lABPn5vltN+sBFg0thLIegx532Vj99GoufiL9prjkAWlmEBzJ4WjpbugUCusNgBX ZIDaH5eXLdgFtWZ/+5D4BVtBHcHAkx7TwWxu2LHtgvXMR4+XgD7lLy7CHLbLmIeGQWBoiult2uqM b9eV5JyLv9bZi6QYQn311Vfl376E1XmhZqkOoIBbqAtMkKnVRCoBtZYy+vxx+wrM830SMChadbFY JLAZRTB7IxoJyOsQbKEvGE1faVd4nv6XLouLjemdX4p1IYccXtSPPvroVofm9SSGu3BxdohZzLuS 5g37EbNN/6730Cx5cQnMxV+ull5E1aI0sNIlqAoTyOFaWoWnQLAgCwI4/kMBBjFcHng3eL/L0fl3 jR1xhuvZ6FXmH2KkWXVhHQU7mBaZPdjph9glcr371G41Y/CimudJeMnN8WOa//DhQ0SB2SwKIjLR eUiDmvhYBE3mHIyysB6L7YuyW0/t1o3knxX/gWrJd16iT9lKT7wugQEntA3+cqKFxeXo/OvN6yBy 518sYMJz17jFlNDo4nM99D8WS8zVNR6qTJocW04wchDuy5f58ccfY2orPSuLJQHTC1YlxjksRCAk bi/Cra0hGbhPsWtyyb5YvDczRbuTMDRi0uMMVUPi7xpiP0OZc/lvXUUO46ya6jPj0+gDRYSj7xZw 1kFkNMR7X/Dao2tErtPBqXcchJ8K3h5F9jcS8tFOFgx++8SY5xeUAJNqB5sf9ua2oePtYtXLFHAp o3JRiWM9zaJIhMTkn2bN2VwwV9UW7McLFrUk/gI4b4woi2voCozzosQ6+oRFI1YDtDQ+KDZCAWjq 5qLckOgAtH8x6BbVZ/wsRKqkYaDnzVXKvtdj1fNeyydPnlj4EkEfIjP2EvF92hPNnLAKsGs9zVSJ 6ZjA8ILtYriMi5rwr5vW8Ou8a5b+oS2RAeiCxRI1WMe/ABqFLxh9CNAGmDEAfU79g51yTEu5ky6y ZcOCHUoNfTRWIT0SyW/fYWyyKH7//Xc7/nJ++frrr8cXQixUeTCXfwQ0B7ssGcoeS1GOd+8i8X/H tyJzniqBJfnvqc8+c35qMvv3OPqeCzI6AG1eKTRJnIQabDYKQHfQOQi1iecYgO6rQOe83TB9zLZm 6CsT87VrQyzFdO4d+S8NtZX9UJ17ivrbQJNt9cjb+7IxtKCgtFJUZwAxts+gLdUFlrPsJCRmQp1h ThptxP2NoHMKca8dl/lPUuZMLodfHALLto9gRc0fLoejBNMxbDf8mGCu2JUDr+hwaXm1OQlcEf7e 2jf4GgdTR19OwXoKQAd9BjQWowtAM8D04cFohwS+TE/HM5t22/zx1JU32AqCbfNjPguFO2ss9vXh cGjrYuvgfRUeed7yDrCQ2d7mgshYzV9Dg2SzIrArYLFJtMrzVqcz2VRsWaOduItsuUbKrS+bYYxI rcUxPjnq7EszFhFwDFE68bPPPmORmSrdPnnu+TxQyGMpCWDQ2JNtMc0if/zxR5bOuCREs6Wm1WpA 7E3ClM0rGSeYoorba1e0X375xdwT1MJ0PK5UpkzS3QjQUTOLkOWqknHV8u+0BEBUJcw0bvcvK1cQ aaSB+6xcmVLYsM5VGMHUKbIBaDu04268Y5A1beE745IW2VXT6h9NNFu3u3fvarXwWtplZDK82ZIy SvBr3KKdl9B2OlM4JRgn90QAAAogSURBVFqQGYYz9pa3BzMpKYQ5DRNmT4wb1YGyW5qZo3m6CDLE 4l8VJqWjOc3ZDVHM79wSOeG+VTIMPcqMX1MBpdlBPWxU6kvT0naJFlGv3Muxk6OEMPkq4x344osv CLbu0JKzL6GntMUYqRwG3SDeWou+0/a+W/L8xiXwYbOyPJaVgC8NELPHEEeYBoMzKJYqLAb7BJ+Q MJjAy1fEYB4imKIyWmBRBIBQZiQX1KJOQA0Uyl8Oxkam2FZjFK7C4Ont27czax74y0vVBsYoGODj wahMtQVPWCoVB00LADVOQHyXuCwCPm1Uc6G/fP8//PCDyrhEB80eVhhyscFUmzEcIQAa2VTVwv1h bZUDr/kRuATx7aUkwY+AORd9PWxVJpCiIVGmS7QWduGE70TEAMYlVuckHPh7mNO2I0YROQEWrm0/ ETl5VTBagF91fdjzKtlYuBT+UoaYVZCPvv7yyy+5Ghlm8Gv6Iq2uHz0yTaSJvyNl1Uq21D8UfDtT wnfo6HsY/otXUmigirhenS38vK3qOAAiZGcKWmeYnDY88NSAdzg4OFPOy5cvOXdZDpJWWwpNwQRw YdVzCc+lLOblgb8LPY544r+QTmaU3AYK1DLm4LAykE7CkhSCCXecqeuJBePI/GWdNA4JHh972fnF lw0GVLEU90KLgM5QH9tr2dzCUIEdu0s0MouQeKv0Yc5oiPq7yhoa0CvTIEelE9MR5x200my8jG0G oTgz/1f5BipjauwoIRROmmPPl+rOSkj83VaHggZ80yGEJjRB6NTPSeQXfnE1NOVHlu/cueO86afP e34Dvvvuu9D/Iol4pbl/AChEVjju5iT2iuQCEUzZzFplsHtgGnlsSh+mUWA36iMRUKsVwBr0UEFY zCzeOgg19m21Ct+PWzBTAB3p4P4ajsg4A/FjRxxIzXkaF1aZw7sOc2qIikUleV2GZbQzNfi6S/0p jugljHzqaUtpQojy5/wqjUcS6c0pJO/dsQT+Q0Z23M7mmmbuD3yBl+mzlStU1FyefpM6lQIRKmGj 9BjLtksgDk8EQPStENkC4Oeff04XEfE8geC3335rLRGY+rVwJCGPBFDuhFeOsEqqp+Y04PIziQVz lCdOIps0xQq3QgWhwm4Bw5XzaIsoUlF+zBeVloEzAr0wMm4YoEWt7+rk1BDb93q0epoxAMSj5dPA 0BLg0ZAXTFOYHM120kmDBBnOXx096aGZuS0JJP/daH9hasimr7cwyrqiGCVvV5SQvhVJrC/NTNO0 Wt5hbmGZy3oUEKEPjZVAWEYDAEPjEdS1BgYTedpVyKhK9aNpFegTQKSBhJOuSwgvrS5eb1auWCtg 8jjvWc54BFUpdXNdSJ2mAKGf1V4nsWDPpU5FbClhCqeO/HVO3JPa11iFXPOutMRXl1nSYYHnX4Yf qHf5t2SYkKAzMVos2zsTqpG3bFkCV+R/cbZuQE7hDvaKnVHaIneW9WP/+WXjPwAjS1WAbKWmWSqk hB1WcdD8UhB3yG/UhxxM/9nz1TrfkAO0DU4dOYVhwlKdrHPe2ih2Gmj1gDK9lKBwzz1nuDIqGsOA FyDUMqUmcxJGuPS/mCPADd6b/HeDnTK2Suz2KYLBHDuKsfeckm9MePtYBDtaKrwIhltfZRPtqM9I UwEXLXDn0sC/4/GUlBwDRS17iSLFzICOZUHwXbaGWdpGJJD63410xJRqWIliLGHOjlajkFOKyHsW lQAVCqUQJfKbN28oVRYtOwvboQQSf9vuVNphamIqAubD7Itjob/tJrVZe7MQK4EWMNlRWFGkm26z HVnrs0og8fes4l7jYWbWzBIEEGC7ar7P6a5vlX+Np2eZVPzWJJmCsMvWBY4BF/YUV0qglkDiby2N htMMaTkX4MLW+rAwbhQiIvKEbrhJ2646Hzw2wgL+QltyZsHmlwXxtmudtduWBHL9bVv9MbM2ohzw BmYRIQo7g1YRGJh/gWPo7JAQ5IVxFSsrx8xnXcntbCf4uRAjs2hGzWL0OP744w/NB74si9kkLGKv diXyzGbWEkj8raWxkzQLVj4RDvNibgvAAmTEZgoBJX5ZxTGS20mDV2sG613CNFZBWAf1jmGMz4jf Q9OO1WqRBe9WAom/u+3aaFh4M9fbVO+8wdm8lEA7Ekj9bzt9lTVNCaQE9iWBxN999We2JiWQEmhH Aom/a/UV769yeAbPWv+u9bAs9zokEK9Q/V5F+jpav8NWJv6eo1N9JPDXcY6H5TP2KwEvkiVBv/tt 4nW1LBFhrf6OjwTmBvj6rSPOrPXULHfXEgC+9Ru167ZeReMSf1fp5gK+SvfNQF6HxCoPy0KvRgLx FgUFDiC+mqbvs6Fpf7ZWvxYI9rU4BHIU2tzD4vxaT81ydy0Bb1FC8J56OPF3+d4sCCsBefEU3wzw FY3w119/5fhgJwuRYR1iBNsPInZjnFMPwV/cXn4PE6XwcqmcycStEqg7NDLHGb8l4Xzn31uLHcig qHhnvDYcQLw5IizzXfRvwd/gv1GBgaLy0pYlkPi7Vu/4POLwwTgwF1+Rbwna+mZ8SA7hymIz47Lv 2czaBLwqpMbZoydnPujabi8wF4nhf+cLx5tj5PbaCDDvtXHAXy+PDY2kvUvxanUqM/+5WcKZJZD4 u4rA48Mo+AtqfUi2wAmXX59WfFfOLMJ/j7ahhmAZCgofzZwnR0qgIK/80vW/I0sYk63gb6CtX8gb RPhm4P4fCPYWOeQcU2Dm2aYEEn9X6RefZfmEcFuw6wiSG6QmmG+Ar0urVKK/0MTiftkcv7ISzh5/ 2M1Z70kgbAAuCIa/DiN30QJ/gP+0RRsQ4uYvJf6u1UXxbfiEfEg+IZAXZ3w8YDcOiBxHAuJa3dBg uQGpwW29PHEECof+QdrJQn4Tghvs5H+qnPi7St8F1KLAvhPY6ogzvhnMNxQRkFfCJQm/q9QjC21T At4cL0xMoeItMmzHERoJ75XzjgTfNnv4n1on/q7VffH9KB3m+o1PJbhMcN7QSEhHDRKC1+qJ1sot kBoM168z8eaAYP/Gb7xRJXNrrcz6fpBA7j+/4nsQxLag7Qcd8M3hjL8eHBkSeVfsg2aLjvHbbyQK FkvEUS4128SseOLvyu9AQdiCwkXhUGC3JFauSxbfkgTAa1S38FywG2m/Dlfjt6VWZV3/K4Hkv/+V xwr/Qd4otWCxf8vJBN8VRL6TImsI1qQO5ib47qCbE3/P14mgtoO2nX/PV5V8UgsSKPhbKhs6h/Jv JlqXQOJv6z2Y9U8JpARalUA6z7Tac1nvlEBKoHUJJP623oNZ/5RASqBVCST+ttpzWe+UQEqgdQkk /rbeg1n/lEBKoFUJJP622nNZ75RASqB1CST+tt6DWf+UQEqgVQkk/rbac1nvlEBKoHUJJP623oNZ /5RASqBVCST+ttpzWe+UQEqgdQkk/rbeg1n/lEBKoFUJJP622nNZ75RASqB1CfwfzugwRkWL3bEA AAAASUVORK5CYII= 51463 2010-03-23 15:41:36 -0700 2010-03-29 15:30:30 -0700 Patch bug-36466-20100323154134.patch text/plain 12349 crogers ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MWYyZDg3NC4uN2MzNGUzZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAxMC0wMy0yMyAgQ2hyaXMgUm9nZXJz ICA8Y3JvZ2Vyc0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGF1ZGlvIGVuZ2luZTogYWRkIFJldmVyYiBjbGFzcworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzY0NjYKKworICAgICAgICBO byB0ZXN0cyBzaW5jZSBub3QgeWV0IGNvbm5lY3RlZCB0byBqYXZhc2NyaXB0IEFQSQorCisgICAg ICAgICogcGxhdGZvcm0vYXVkaW8vUmV2ZXJiLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3Jl OjpjYWxjdWxhdGVOb3JtYWxpemF0aW9uU2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6UmV2ZXJi OjpSZXZlcmIpOgorICAgICAgICAoV2ViQ29yZTo6UmV2ZXJiOjppbml0aWFsaXplKToKKyAgICAg ICAgKFdlYkNvcmU6OlJldmVyYjo6cHJvY2Vzcyk6CisgICAgICAgIChXZWJDb3JlOjpSZXZlcmI6 OnJlc2V0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9hdWRpby9SZXZlcmIuaDogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjpSZXZlcmI6Oik6CisgICAgICAgIChXZWJDb3JlOjpSZXZlcmI6OmltcHVs c2VSZXNwb25zZUxlbmd0aCk6CisKIDIwMTAtMDMtMDUgIENzYWJhIE9zenRyb2dvbsOhYyAgPG9z c3lAd2Via2l0Lm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIGJ1aWxkZml4IGFmdGVyIHI1NTU5 My4gKFRvIGZpeCBRdCAtLW1pbmltYWwgYnVpbGQuKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9hdWRpby9SZXZlcmIuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmIuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM1ZGNmYWMKLS0tIC9kZXYvbnVs bAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1JldmVyYi5jcHAKQEAgLTAsMCArMSwxOTYg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl 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 LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiUmV2ZXJiLmgiCisKKyNpbmNsdWRl ICJBdWRpb0J1cy5oIgorI2luY2x1ZGUgIkF1ZGlvRmlsZVJlYWRlci5oIgorI2luY2x1ZGUgIlJl dmVyYkNvbnZvbHZlci5oIgorI2luY2x1ZGUgPG1hdGguaD4KKyNpbmNsdWRlIDx3dGYvT3duUHRy Lmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgewor CisvLyBFbXBpcmljYWwgZ2FpbiBjYWxpYnJhdGlvbiB0ZXN0ZWQgYWNyb3NzIG1hbnkgaW1wdWxz ZSByZXNwb25zZXMgdG8gZW5zdXJlIHBlcmNlaXZlZCB2b2x1bWUgaXMgc2FtZSBhcyBkcnkgKHVu cHJvY2Vzc2VkKSBzaWduYWwKK2NvbnN0IGRvdWJsZSBHYWluQ2FsaWJyYXRpb24gPSAtNTguMDsK KworLy8gQSBtaW5pbXVtIHBvd2VyIHZhbHVlIHRvIHdoZW4gbm9ybWFsaXppbmcgYSBzaWxlbnQg KG9yIHZlcnkgcXVpZXQpIGltcHVsc2UgcmVzcG9uc2UKK2NvbnN0IGRvdWJsZSBNaW5Qb3dlciA9 IDAuMDAwMTI1OworICAgIAorc3RhdGljIGRvdWJsZSBjYWxjdWxhdGVOb3JtYWxpemF0aW9uU2Nh bGUoQXVkaW9CdXMqIHJlc3BvbnNlKQoreworICAgIC8vIE5vcm1hbGl6ZSBieSBSTVMgcG93ZXIK KyAgICBzaXplX3QgbnVtYmVyT2ZDaGFubmVscyA9IHJlc3BvbnNlLT5udW1iZXJPZkNoYW5uZWxz KCk7CisgICAgc2l6ZV90IGZyYW1lU2l6ZSA9IHJlc3BvbnNlLT5mcmFtZVNpemUoKTsKKworICAg IGRvdWJsZSBwb3dlciA9IDAuMDsKKworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbnVtYmVy T2ZDaGFubmVsczsgKytpKSB7CisgICAgICAgIGludCBuID0gZnJhbWVTaXplOworICAgICAgICBm bG9hdCogcCA9IHJlc3BvbnNlLT5jaGFubmVsKGkpLT5kYXRhKCk7CisKKyAgICAgICAgd2hpbGUg KG4tLSkgeworICAgICAgICAgICAgZmxvYXQgc2FtcGxlID0gKnArKzsKKyAgICAgICAgICAgIHBv d2VyICs9IHNhbXBsZSAqIHNhbXBsZTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHBvd2VyID0g c3FydChwb3dlciAvIChudW1iZXJPZkNoYW5uZWxzICogZnJhbWVTaXplKSk7CisKKyAgICAvLyBQ cm90ZWN0IGFnYWluc3QgYWNjaWRlbnRhbCBvdmVybG9hZAorICAgIGlmIChzdGQ6OmlzaW5mKHBv d2VyKSB8fCBzdGQ6OmlzbmFuKHBvd2VyKSB8fCBwb3dlciA8IE1pblBvd2VyKQorICAgICAgICBw b3dlciA9IE1pblBvd2VyOworCisgICAgZG91YmxlIHNjYWxlID0gMS4wIC8gcG93ZXI7CisKKyAg ICBzY2FsZSAqPSBwb3coMTAuMCwgR2FpbkNhbGlicmF0aW9uICogMC4wNSk7IC8vIGNhbGlicmF0 ZSB0byBtYWtlIHBlcmNlaXZlZCB2b2x1bWUgc2FtZSBhcyB1bnByb2Nlc3NlZAorCisgICAgLy8g VHJ1ZS1zdGVyZW8gY29tcGVuc2F0aW9uCisgICAgaWYgKHJlc3BvbnNlLT5udW1iZXJPZkNoYW5u ZWxzKCkgPT0gNCkKKyAgICAgICAgc2NhbGUgKj0gMC41OworCisgICAgcmV0dXJuIHNjYWxlOwor fQorCitSZXZlcmI6OlJldmVyYihBdWRpb0J1cyogaW1wdWxzZVJlc3BvbnNlLCBzaXplX3QgcmVu ZGVyU2xpY2VTaXplLCBzaXplX3QgbWF4RkZUU2l6ZSwgc2l6ZV90IG51bWJlck9mQ2hhbm5lbHMs IGJvb2wgdXNlQmFja2dyb3VuZFRocmVhZHMpCit7CisgICAgZG91YmxlIHNjYWxlID0gY2FsY3Vs YXRlTm9ybWFsaXphdGlvblNjYWxlKGltcHVsc2VSZXNwb25zZSk7CisgICAgaWYgKHNjYWxlKQor ICAgICAgICBpbXB1bHNlUmVzcG9uc2UtPnNjYWxlKHNjYWxlKTsKKworICAgIGluaXRpYWxpemUo aW1wdWxzZVJlc3BvbnNlLCByZW5kZXJTbGljZVNpemUsIG1heEZGVFNpemUsIG51bWJlck9mQ2hh bm5lbHMsIHVzZUJhY2tncm91bmRUaHJlYWRzKTsKKworICAgIC8vIFVuZG8gc2NhbGluZyBzaW5j ZSB0aGlzIHNob3VsZG4ndCBiZSBhIGRlc3RydWN0aXZlIG9wZXJhdGlvbiBvbiBpbXB1bHNlUmVz cG9uc2UKKyAgICBpZiAoc2NhbGUpCisgICAgICAgIGltcHVsc2VSZXNwb25zZS0+c2NhbGUoMS4w IC8gc2NhbGUpOworfQorCit2b2lkIFJldmVyYjo6aW5pdGlhbGl6ZShBdWRpb0J1cyogaW1wdWxz ZVJlc3BvbnNlQnVmZmVyLCBzaXplX3QgcmVuZGVyU2xpY2VTaXplLCBzaXplX3QgbWF4RkZUU2l6 ZSwgc2l6ZV90IG51bWJlck9mQ2hhbm5lbHMsIGJvb2wgdXNlQmFja2dyb3VuZFRocmVhZHMpCit7 CisgICAgbV9pbXB1bHNlUmVzcG9uc2VMZW5ndGggPSBpbXB1bHNlUmVzcG9uc2VCdWZmZXItPmZy YW1lU2l6ZSgpOworCisgICAgLy8gVGhlIHJldmVyYiBjYW4gaGFuZGxlIGEgbW9ubyBpbXB1bHNl IHJlc3BvbnNlIGFuZCBzdGlsbCBkbyBzdGVyZW8gcHJvY2Vzc2luZworICAgIHNpemVfdCBudW1S ZXNwb25zZUNoYW5uZWxzID0gaW1wdWxzZVJlc3BvbnNlQnVmZmVyLT5udW1iZXJPZkNoYW5uZWxz KCk7CisgICAgbV9jb252b2x2ZXJzLnJlc2VydmVDYXBhY2l0eShudW1iZXJPZkNoYW5uZWxzKTsK KworICAgIGludCBjb252b2x2ZXJSZW5kZXJQaGFzZSA9IDA7CisgICAgZm9yIChzaXplX3QgaSA9 IDA7IGkgPCBudW1SZXNwb25zZUNoYW5uZWxzOyArK2kpIHsKKyAgICAgICAgQXVkaW9DaGFubmVs KiBjaGFubmVsID0gaW1wdWxzZVJlc3BvbnNlQnVmZmVyLT5jaGFubmVsKGkpOworCisgICAgICAg IFJldmVyYkNvbnZvbHZlciogY29udm9sdmVyID0gbmV3IFJldmVyYkNvbnZvbHZlcihjaGFubmVs LCByZW5kZXJTbGljZVNpemUsIG1heEZGVFNpemUsIGNvbnZvbHZlclJlbmRlclBoYXNlLCB1c2VC YWNrZ3JvdW5kVGhyZWFkcyk7CisgICAgICAgIG1fY29udm9sdmVycy5hcHBlbmQoY29udm9sdmVy KTsKKworICAgICAgICBjb252b2x2ZXJSZW5kZXJQaGFzZSArPSByZW5kZXJTbGljZVNpemU7Cisg ICAgfQorCisgICAgLy8gRm9yICJUcnVlIiBzdGVyZW8gcHJvY2Vzc2luZyB3ZSBhbGxvY2F0ZSBh IHRlbXBvcmFyeSBidWZmZXIgdG8gYXZvaWQgcmVwZWF0ZWRseSBhbGxvY2F0aW5nIGl0IGluIHRo ZSBwcm9jZXNzKCkgbWV0aG9kLgorICAgIC8vIEl0IGNhbiBiZSBiYWQgdG8gYWxsb2NhdGUgbWVt b3J5IGluIGEgcmVhbC10aW1lIHRocmVhZC4KKyAgICBpZiAobnVtUmVzcG9uc2VDaGFubmVscyA9 PSA0KQorICAgICAgICBtX3RlbXBCdWZmZXIgPSBuZXcgQXVkaW9CdXMoMiwgTWF4RnJhbWVTaXpl KTsKK30KKwordm9pZCBSZXZlcmI6OnByb2Nlc3MoQXVkaW9CdXMqIHNvdXJjZUJ1cywgQXVkaW9C dXMqIGRlc3RpbmF0aW9uQnVzLCBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKQoreworICAgIC8vIERv IGEgZmFpcmx5IGNvbXByZWhlbnNpdmUgc2FuaXR5IGNoZWNrLgorICAgIC8vIElmIHRoZXNlIGNv bmRpdGlvbnMgYXJlIHNhdGlzZmllZCwgYWxsIG9mIHRoZSBzb3VyY2UgYW5kIGRlc3RpbmF0aW9u IHBvaW50ZXJzIHdpbGwgYmUgdmFsaWQgZm9yIHRoZSB2YXJpb3VzIG1hdHJpeGluZyBjYXNlcy4K KyAgICBib29sIGlzU2FmZVRvUHJvY2VzcyA9IHNvdXJjZUJ1cyAmJiBkZXN0aW5hdGlvbkJ1cyAm JiBzb3VyY2VCdXMtPm51bWJlck9mQ2hhbm5lbHMoKSA+IDAgJiYgZGVzdGluYXRpb25CdXMtPm51 bWJlck9mQ2hhbm5lbHMoKSA+IDAKKyAgICAgICAgJiYgZnJhbWVzVG9Qcm9jZXNzIDw9IE1heEZy YW1lU2l6ZSAmJiBmcmFtZXNUb1Byb2Nlc3MgPD0gc291cmNlQnVzLT5mcmFtZVNpemUoKSAmJiBm cmFtZXNUb1Byb2Nlc3MgPD0gZGVzdGluYXRpb25CdXMtPmZyYW1lU2l6ZSgpOyAKKyAgICAKKyAg ICBBU1NFUlQoaXNTYWZlVG9Qcm9jZXNzKTsKKyAgICBpZiAoIWlzU2FmZVRvUHJvY2VzcykKKyAg ICAgICAgcmV0dXJuOworCisgICAgLy8gRm9yIG5vdyBvbmx5IGhhbmRsZSBtb25vIG9yIHN0ZXJl byBvdXRwdXQKKyAgICBpZiAoZGVzdGluYXRpb25CdXMtPm51bWJlck9mQ2hhbm5lbHMoKSA+IDIp IHsKKyAgICAgICAgZGVzdGluYXRpb25CdXMtPnplcm8oKTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKworICAgIGZsb2F0KiBkZXN0aW5hdGlvbkwgPSBkZXN0aW5hdGlvbkJ1cy0+Y2hhbm5lbCgw KS0+ZGF0YSgpOworICAgIGZsb2F0KiBzb3VyY2VMID0gc291cmNlQnVzLT5jaGFubmVsKDApLT5k YXRhKCk7CisKKyAgICAvLyBIYW5kbGUgaW5wdXQgLT4gb3V0cHV0IG1hdHJpeGluZy4uLgorICAg IHNpemVfdCBudW1JbnB1dENoYW5uZWxzID0gc291cmNlQnVzLT5udW1iZXJPZkNoYW5uZWxzKCk7 CisgICAgc2l6ZV90IG51bU91dHB1dENoYW5uZWxzID0gZGVzdGluYXRpb25CdXMtPm51bWJlck9m Q2hhbm5lbHMoKTsKKyAgICBzaXplX3QgbnVtUmV2ZXJiQ2hhbm5lbHMgPSBtX2NvbnZvbHZlcnMu c2l6ZSgpOworCisgICAgaWYgKG51bUlucHV0Q2hhbm5lbHMgPT0gMiAmJiBudW1SZXZlcmJDaGFu bmVscyA9PSAyICYmIG51bU91dHB1dENoYW5uZWxzID09IDIpIHsKKyAgICAgICAgLy8gMiAtPiAy IC0+IDIKKyAgICAgICAgZmxvYXQqIHNvdXJjZVIgPSBzb3VyY2VCdXMtPmNoYW5uZWwoMSktPmRh dGEoKTsKKyAgICAgICAgZmxvYXQqIGRlc3RpbmF0aW9uUiA9IGRlc3RpbmF0aW9uQnVzLT5jaGFu bmVsKDEpLT5kYXRhKCk7CisgICAgICAgIG1fY29udm9sdmVyc1swXS0+cHJvY2Vzcyhzb3VyY2VM LCBkZXN0aW5hdGlvbkwsIGZyYW1lc1RvUHJvY2Vzcyk7CisgICAgICAgIG1fY29udm9sdmVyc1sx XS0+cHJvY2Vzcyhzb3VyY2VSLCBkZXN0aW5hdGlvblIsIGZyYW1lc1RvUHJvY2Vzcyk7CisgICAg fSBlbHNlICBpZiAobnVtSW5wdXRDaGFubmVscyA9PSAxICYmIG51bU91dHB1dENoYW5uZWxzID09 IDIgJiYgbnVtUmV2ZXJiQ2hhbm5lbHMgPT0gMikgeworICAgICAgICAvLyAxIC0+IDIgLT4gMgor ICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IDI7ICsraSkgeworICAgICAgICAgICAgZmxvYXQq IGRlc3RpbmF0aW9uID0gZGVzdGluYXRpb25CdXMtPmNoYW5uZWwoaSktPmRhdGEoKTsKKyAgICAg ICAgICAgIG1fY29udm9sdmVyc1tpXS0+cHJvY2Vzcyhzb3VyY2VMLCBkZXN0aW5hdGlvbiwgZnJh bWVzVG9Qcm9jZXNzKTsKKyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAobnVtSW5wdXRDaGFubmVs cyA9PSAxICYmIG51bVJldmVyYkNoYW5uZWxzID09IDEgJiYgbnVtT3V0cHV0Q2hhbm5lbHMgPT0g MikgeworICAgICAgICAvLyAxIC0+IDEgLT4gMgorICAgICAgICBtX2NvbnZvbHZlcnNbMF0tPnBy b2Nlc3Moc291cmNlTCwgZGVzdGluYXRpb25MLCBmcmFtZXNUb1Byb2Nlc3MpOworCisgICAgICAg IC8vIHNpbXBseSBjb3B5IEwgLT4gUgorICAgICAgICBmbG9hdCogZGVzdGluYXRpb25SID0gZGVz dGluYXRpb25CdXMtPmNoYW5uZWwoMSktPmRhdGEoKTsKKyAgICAgICAgbWVtY3B5KGRlc3RpbmF0 aW9uUiwgZGVzdGluYXRpb25MLCBzaXplb2YoZmxvYXQpICogZnJhbWVzVG9Qcm9jZXNzKTsKKyAg ICB9IGVsc2UgaWYgKG51bUlucHV0Q2hhbm5lbHMgPT0gMSAmJiBudW1SZXZlcmJDaGFubmVscyA9 PSAxICYmIG51bU91dHB1dENoYW5uZWxzID09IDEpIHsKKyAgICAgICAgLy8gMSAtPiAxIC0+IDEK KyAgICAgICAgbV9jb252b2x2ZXJzWzBdLT5wcm9jZXNzKHNvdXJjZUwsIGRlc3RpbmF0aW9uTCwg ZnJhbWVzVG9Qcm9jZXNzKTsKKyAgICB9IGVsc2UgaWYgKG51bUlucHV0Q2hhbm5lbHMgPT0gMiAm JiBudW1SZXZlcmJDaGFubmVscyA9PSA0ICYmIG51bU91dHB1dENoYW5uZWxzID09IDIpIHsKKyAg ICAgICAgLy8gMiAtPiA0IC0+IDIgKCJUcnVlIiBzdGVyZW8pCisgICAgICAgIGZsb2F0KiBzb3Vy Y2VSID0gc291cmNlQnVzLT5jaGFubmVsKDEpLT5kYXRhKCk7CisgICAgICAgIGZsb2F0KiBkZXN0 aW5hdGlvblIgPSBkZXN0aW5hdGlvbkJ1cy0+Y2hhbm5lbCgxKS0+ZGF0YSgpOworCisgICAgICAg IGZsb2F0KiB0ZW1wTCA9IG1fdGVtcEJ1ZmZlci0+Y2hhbm5lbCgwKS0+ZGF0YSgpOworICAgICAg ICBmbG9hdCogdGVtcFIgPSBtX3RlbXBCdWZmZXItPmNoYW5uZWwoMSktPmRhdGEoKTsKKworICAg ICAgICAvLyBQcm9jZXNzIGxlZnQgdmlydHVhbCBzb3VyY2UKKyAgICAgICAgbV9jb252b2x2ZXJz WzBdLT5wcm9jZXNzKHNvdXJjZUwsIGRlc3RpbmF0aW9uTCwgZnJhbWVzVG9Qcm9jZXNzKTsKKyAg ICAgICAgbV9jb252b2x2ZXJzWzFdLT5wcm9jZXNzKHNvdXJjZUwsIGRlc3RpbmF0aW9uUiwgZnJh bWVzVG9Qcm9jZXNzKTsKKworICAgICAgICAvLyBQcm9jZXNzIHJpZ2h0IHZpcnR1YWwgc291cmNl CisgICAgICAgIG1fY29udm9sdmVyc1syXS0+cHJvY2Vzcyhzb3VyY2VSLCB0ZW1wTCwgZnJhbWVz VG9Qcm9jZXNzKTsKKyAgICAgICAgbV9jb252b2x2ZXJzWzNdLT5wcm9jZXNzKHNvdXJjZVIsIHRl bXBSLCBmcmFtZXNUb1Byb2Nlc3MpOworCisgICAgICAgIGRlc3RpbmF0aW9uQnVzLT5zdW1Gcm9t KCptX3RlbXBCdWZmZXIpOworICAgIH0gZWxzZSB7CisgICAgICAgIC8vIEhhbmRsZSBncmFjZWZ1 bGx5IGFueSB1bmV4cGVjdGVkIC8gdW5zdXBwb3J0ZWQgbWF0cml4aW5nCisgICAgICAgIC8vIEZJ WE1FOiBhZGQgY29kZSBmb3IgNS4xIHN1cHBvcnQuLi4KKyAgICAgICAgZGVzdGluYXRpb25CdXMt Pnplcm8oKTsKKyAgICB9Cit9CisKK3ZvaWQgUmV2ZXJiOjpyZXNldCgpCit7CisgICAgZm9yIChz aXplX3QgaSA9IDA7IGkgPCBtX2NvbnZvbHZlcnMuc2l6ZSgpOyArK2kpCisgICAgICAgIG1fY29u dm9sdmVyc1tpXS0+cmVzZXQoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmIuaCBiL1dlYkNvcmUvcGxhdGZvcm0v YXVkaW8vUmV2ZXJiLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODIyYmZl ZAotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vYXVkaW8vUmV2ZXJiLmgKQEAg LTAsMCArMSw2NyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUg bWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhlIG5h bWUgb2YgQXBwbGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAq ICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lm aWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisg KiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpZm5kZWYgUmV2ZXJiX2gKKyNkZWZpbmUgUmV2ZXJiX2gKKworI2lu Y2x1ZGUgIlJldmVyYkNvbnZvbHZlci5oIgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKyNpbmNs dWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXVkaW9C dXM7CisgICAgCisvLyBNdWx0aS1jaGFubmVsIGNvbnZvbHV0aW9uIHJldmVyYiB3aXRoIGNoYW5u ZWwgbWF0cml4aW5nIC0gb25lIG9yIG1vcmUgUmV2ZXJiQ29udm9sdmVyIG9iamVjdHMgYXJlIHVz ZWQgaW50ZXJuYWxseS4KKworY2xhc3MgUmV2ZXJiIHsKK3B1YmxpYzoKKyAgICBlbnVtIHsgTWF4 RnJhbWVTaXplID0gMjU2IH07CisKKyAgICAvLyByZW5kZXJTbGljZVNpemUgaXMgYSByZW5kZXJp bmcgaGludCwgc28gdGhlIEZGVHMgY2FuIGJlIG9wdGltaXplZCB0byBub3QgYWxsIG9jY3VyIGF0 IHRoZSBzYW1lIHRpbWUgKHZlcnkgYmFkIHdoZW4gcmVuZGVyaW5nIG9uIGEgcmVhbC10aW1lIHRo cmVhZCkuCisgICAgUmV2ZXJiKEF1ZGlvQnVzKiBpbXB1bHNlUmVzcG9uc2VCdWZmZXIsIHNpemVf dCByZW5kZXJTbGljZVNpemUsIHNpemVfdCBtYXhGRlRTaXplLCBzaXplX3QgbnVtYmVyT2ZDaGFu bmVscywgYm9vbCB1c2VCYWNrZ3JvdW5kVGhyZWFkcyk7CisKKyAgICB2b2lkIHByb2Nlc3MoQXVk aW9CdXMqIHNvdXJjZUJ1cywgQXVkaW9CdXMqIGRlc3RpbmF0aW9uQnVzLCBzaXplX3QgZnJhbWVz VG9Qcm9jZXNzKTsKKyAgICB2b2lkIHJlc2V0KCk7CisKKyAgICBzaXplX3QgaW1wdWxzZVJlc3Bv bnNlTGVuZ3RoKCkgY29uc3QgeyByZXR1cm4gbV9pbXB1bHNlUmVzcG9uc2VMZW5ndGg7IH0KKwor cHJpdmF0ZToKKyAgICB2b2lkIGluaXRpYWxpemUoQXVkaW9CdXMqIGltcHVsc2VSZXNwb25zZUJ1 ZmZlciwgc2l6ZV90IHJlbmRlclNsaWNlU2l6ZSwgc2l6ZV90IG1heEZGVFNpemUsIHNpemVfdCBu dW1iZXJPZkNoYW5uZWxzLCBib29sIHVzZUJhY2tncm91bmRUaHJlYWRzKTsKKworICAgIHNpemVf dCBtX2ltcHVsc2VSZXNwb25zZUxlbmd0aDsKKworICAgIFZlY3RvcjxPd25QdHI8UmV2ZXJiQ29u dm9sdmVyPiA+IG1fY29udm9sdmVyczsKKworICAgIC8vIEZvciAiVHJ1ZSIgc3RlcmVvIHByb2Nl c3NpbmcKKyAgICBPd25QdHI8QXVkaW9CdXM+IG1fdGVtcEJ1ZmZlcjsKK307CisKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFJldmVyYl9oCg== 51976 2010-03-29 15:30:34 -0700 2010-08-26 14:26:09 -0700 Patch bug-36466-20100329153032.patch text/plain 12774 crogers ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YmFhMDU1Mi4uMmM4Yjk5OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAxMC0wMy0yOSAgQ2hyaXMgUm9nZXJz ICA8Y3JvZ2Vyc0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGF1ZGlvIGVuZ2luZTogYWRkIFJldmVyYiBjbGFzcworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzY0NjYKKworICAgICAgICBO byB0ZXN0cyBzaW5jZSBub3QgeWV0IGNvbm5lY3RlZCB0byBqYXZhc2NyaXB0IEFQSQorCisgICAg ICAgICogcGxhdGZvcm0vYXVkaW8vUmV2ZXJiLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3Jl OjpjYWxjdWxhdGVOb3JtYWxpemF0aW9uU2NhbGUpOgorICAgICAgICAoV2ViQ29yZTo6UmV2ZXJi OjpSZXZlcmIpOgorICAgICAgICAoV2ViQ29yZTo6UmV2ZXJiOjppbml0aWFsaXplKToKKyAgICAg ICAgKFdlYkNvcmU6OlJldmVyYjo6cHJvY2Vzcyk6CisgICAgICAgIChXZWJDb3JlOjpSZXZlcmI6 OnJlc2V0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9hdWRpby9SZXZlcmIuaDogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjpSZXZlcmI6Oik6CisgICAgICAgIChXZWJDb3JlOjpSZXZlcmI6OmltcHVs c2VSZXNwb25zZUxlbmd0aCk6CisKIDIwMTAtMDMtMjkgIEtlbm5ldGggUnVzc2VsbCAgPGtickBn b29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEZpc2hlci4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vYXVkaW8vUmV2ZXJiLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0v YXVkaW8vUmV2ZXJiLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iM2Yy NWZmCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmIuY3Bw CkBAIC0wLDAgKzEsMjAwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu 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 U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlJldmVy Yi5oIgorCisjaW5jbHVkZSAiQXVkaW9CdXMuaCIKKyNpbmNsdWRlICJBdWRpb0ZpbGVSZWFkZXIu aCIKKyNpbmNsdWRlICJSZXZlcmJDb252b2x2ZXIuaCIKKyNpbmNsdWRlIDxtYXRoLmg+CisjaW5j bHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworLy8gRW1waXJpY2FsIGdhaW4gY2FsaWJyYXRpb24gdGVzdGVkIGFj cm9zcyBtYW55IGltcHVsc2UgcmVzcG9uc2VzIHRvIGVuc3VyZSBwZXJjZWl2ZWQgdm9sdW1lIGlz IHNhbWUgYXMgZHJ5ICh1bnByb2Nlc3NlZCkgc2lnbmFsCitjb25zdCBkb3VibGUgR2FpbkNhbGli cmF0aW9uID0gLTU4LjA7CisKKy8vIEEgbWluaW11bSBwb3dlciB2YWx1ZSB0byB3aGVuIG5vcm1h bGl6aW5nIGEgc2lsZW50IChvciB2ZXJ5IHF1aWV0KSBpbXB1bHNlIHJlc3BvbnNlCitjb25zdCBk b3VibGUgTWluUG93ZXIgPSAwLjAwMDEyNTsKKyAgICAKK3N0YXRpYyBkb3VibGUgY2FsY3VsYXRl Tm9ybWFsaXphdGlvblNjYWxlKEF1ZGlvQnVzKiByZXNwb25zZSkKK3sKKyAgICAvLyBOb3JtYWxp emUgYnkgUk1TIHBvd2VyCisgICAgc2l6ZV90IG51bWJlck9mQ2hhbm5lbHMgPSByZXNwb25zZS0+ bnVtYmVyT2ZDaGFubmVscygpOworICAgIHNpemVfdCBmcmFtZVNpemUgPSByZXNwb25zZS0+ZnJh bWVTaXplKCk7CisKKyAgICBkb3VibGUgcG93ZXIgPSAwLjA7CisKKyAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IG51bWJlck9mQ2hhbm5lbHM7ICsraSkgeworICAgICAgICBpbnQgbiA9IGZyYW1l U2l6ZTsKKyAgICAgICAgZmxvYXQqIHAgPSByZXNwb25zZS0+Y2hhbm5lbChpKS0+ZGF0YSgpOwor CisgICAgICAgIHdoaWxlIChuLS0pIHsKKyAgICAgICAgICAgIGZsb2F0IHNhbXBsZSA9ICpwKys7 CisgICAgICAgICAgICBwb3dlciArPSBzYW1wbGUgKiBzYW1wbGU7CisgICAgICAgIH0KKyAgICB9 CisKKyAgICBwb3dlciA9IHNxcnQocG93ZXIgLyAobnVtYmVyT2ZDaGFubmVscyAqIGZyYW1lU2l6 ZSkpOworCisgICAgLy8gUHJvdGVjdCBhZ2FpbnN0IGFjY2lkZW50YWwgb3ZlcmxvYWQKKyAgICBp ZiAoc3RkOjppc2luZihwb3dlcikgfHwgc3RkOjppc25hbihwb3dlcikgfHwgcG93ZXIgPCBNaW5Q b3dlcikKKyAgICAgICAgcG93ZXIgPSBNaW5Qb3dlcjsKKworICAgIGRvdWJsZSBzY2FsZSA9IDEu MCAvIHBvd2VyOworCisgICAgc2NhbGUgKj0gcG93KDEwLjAsIEdhaW5DYWxpYnJhdGlvbiAqIDAu MDUpOyAvLyBjYWxpYnJhdGUgdG8gbWFrZSBwZXJjZWl2ZWQgdm9sdW1lIHNhbWUgYXMgdW5wcm9j ZXNzZWQKKworICAgIC8vIFRydWUtc3RlcmVvIGNvbXBlbnNhdGlvbgorICAgIGlmIChyZXNwb25z ZS0+bnVtYmVyT2ZDaGFubmVscygpID09IDQpCisgICAgICAgIHNjYWxlICo9IDAuNTsKKworICAg IHJldHVybiBzY2FsZTsKK30KKworUmV2ZXJiOjpSZXZlcmIoQXVkaW9CdXMqIGltcHVsc2VSZXNw b25zZSwgc2l6ZV90IHJlbmRlclNsaWNlU2l6ZSwgc2l6ZV90IG1heEZGVFNpemUsIHNpemVfdCBu dW1iZXJPZkNoYW5uZWxzLCBib29sIHVzZUJhY2tncm91bmRUaHJlYWRzKQoreworICAgIGRvdWJs ZSBzY2FsZSA9IGNhbGN1bGF0ZU5vcm1hbGl6YXRpb25TY2FsZShpbXB1bHNlUmVzcG9uc2UpOwor ICAgIGlmIChzY2FsZSkKKyAgICAgICAgaW1wdWxzZVJlc3BvbnNlLT5zY2FsZShzY2FsZSk7CisK KyAgICBpbml0aWFsaXplKGltcHVsc2VSZXNwb25zZSwgcmVuZGVyU2xpY2VTaXplLCBtYXhGRlRT aXplLCBudW1iZXJPZkNoYW5uZWxzLCB1c2VCYWNrZ3JvdW5kVGhyZWFkcyk7CisKKyAgICAvLyBV bmRvIHNjYWxpbmcgc2luY2UgdGhpcyBzaG91bGRuJ3QgYmUgYSBkZXN0cnVjdGl2ZSBvcGVyYXRp b24gb24gaW1wdWxzZVJlc3BvbnNlCisgICAgaWYgKHNjYWxlKQorICAgICAgICBpbXB1bHNlUmVz cG9uc2UtPnNjYWxlKDEuMCAvIHNjYWxlKTsKK30KKwordm9pZCBSZXZlcmI6OmluaXRpYWxpemUo QXVkaW9CdXMqIGltcHVsc2VSZXNwb25zZUJ1ZmZlciwgc2l6ZV90IHJlbmRlclNsaWNlU2l6ZSwg c2l6ZV90IG1heEZGVFNpemUsIHNpemVfdCBudW1iZXJPZkNoYW5uZWxzLCBib29sIHVzZUJhY2tn cm91bmRUaHJlYWRzKQoreworICAgIG1faW1wdWxzZVJlc3BvbnNlTGVuZ3RoID0gaW1wdWxzZVJl c3BvbnNlQnVmZmVyLT5mcmFtZVNpemUoKTsKKworICAgIC8vIFRoZSByZXZlcmIgY2FuIGhhbmRs ZSBhIG1vbm8gaW1wdWxzZSByZXNwb25zZSBhbmQgc3RpbGwgZG8gc3RlcmVvIHByb2Nlc3NpbmcK KyAgICBzaXplX3QgbnVtUmVzcG9uc2VDaGFubmVscyA9IGltcHVsc2VSZXNwb25zZUJ1ZmZlci0+ bnVtYmVyT2ZDaGFubmVscygpOworICAgIG1fY29udm9sdmVycy5yZXNlcnZlQ2FwYWNpdHkobnVt YmVyT2ZDaGFubmVscyk7CisKKyAgICBpbnQgY29udm9sdmVyUmVuZGVyUGhhc2UgPSAwOworICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbnVtUmVzcG9uc2VDaGFubmVsczsgKytpKSB7CisgICAg ICAgIEF1ZGlvQ2hhbm5lbCogY2hhbm5lbCA9IGltcHVsc2VSZXNwb25zZUJ1ZmZlci0+Y2hhbm5l bChpKTsKKworICAgICAgICBSZXZlcmJDb252b2x2ZXIqIGNvbnZvbHZlciA9IG5ldyBSZXZlcmJD b252b2x2ZXIoY2hhbm5lbCwgcmVuZGVyU2xpY2VTaXplLCBtYXhGRlRTaXplLCBjb252b2x2ZXJS ZW5kZXJQaGFzZSwgdXNlQmFja2dyb3VuZFRocmVhZHMpOworICAgICAgICBtX2NvbnZvbHZlcnMu YXBwZW5kKGNvbnZvbHZlcik7CisKKyAgICAgICAgY29udm9sdmVyUmVuZGVyUGhhc2UgKz0gcmVu ZGVyU2xpY2VTaXplOworICAgIH0KKworICAgIC8vIEZvciAiVHJ1ZSIgc3RlcmVvIHByb2Nlc3Np bmcgd2UgYWxsb2NhdGUgYSB0ZW1wb3JhcnkgYnVmZmVyIHRvIGF2b2lkIHJlcGVhdGVkbHkgYWxs b2NhdGluZyBpdCBpbiB0aGUgcHJvY2VzcygpIG1ldGhvZC4KKyAgICAvLyBJdCBjYW4gYmUgYmFk IHRvIGFsbG9jYXRlIG1lbW9yeSBpbiBhIHJlYWwtdGltZSB0aHJlYWQuCisgICAgaWYgKG51bVJl c3BvbnNlQ2hhbm5lbHMgPT0gNCkKKyAgICAgICAgbV90ZW1wQnVmZmVyID0gbmV3IEF1ZGlvQnVz KDIsIE1heEZyYW1lU2l6ZSk7Cit9CisKK3ZvaWQgUmV2ZXJiOjpwcm9jZXNzKEF1ZGlvQnVzKiBz b3VyY2VCdXMsIEF1ZGlvQnVzKiBkZXN0aW5hdGlvbkJ1cywgc2l6ZV90IGZyYW1lc1RvUHJvY2Vz cykKK3sKKyAgICAvLyBEbyBhIGZhaXJseSBjb21wcmVoZW5zaXZlIHNhbml0eSBjaGVjay4KKyAg ICAvLyBJZiB0aGVzZSBjb25kaXRpb25zIGFyZSBzYXRpc2ZpZWQsIGFsbCBvZiB0aGUgc291cmNl IGFuZCBkZXN0aW5hdGlvbiBwb2ludGVycyB3aWxsIGJlIHZhbGlkIGZvciB0aGUgdmFyaW91cyBt YXRyaXhpbmcgY2FzZXMuCisgICAgYm9vbCBpc1NhZmVUb1Byb2Nlc3MgPSBzb3VyY2VCdXMgJiYg ZGVzdGluYXRpb25CdXMgJiYgc291cmNlQnVzLT5udW1iZXJPZkNoYW5uZWxzKCkgPiAwICYmIGRl c3RpbmF0aW9uQnVzLT5udW1iZXJPZkNoYW5uZWxzKCkgPiAwCisgICAgICAgICYmIGZyYW1lc1Rv UHJvY2VzcyA8PSBNYXhGcmFtZVNpemUgJiYgZnJhbWVzVG9Qcm9jZXNzIDw9IHNvdXJjZUJ1cy0+ ZnJhbWVTaXplKCkgJiYgZnJhbWVzVG9Qcm9jZXNzIDw9IGRlc3RpbmF0aW9uQnVzLT5mcmFtZVNp emUoKTsgCisgICAgCisgICAgQVNTRVJUKGlzU2FmZVRvUHJvY2Vzcyk7CisgICAgaWYgKCFpc1Nh ZmVUb1Byb2Nlc3MpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIEZvciBub3cgb25seSBoYW5k bGUgbW9ubyBvciBzdGVyZW8gb3V0cHV0CisgICAgaWYgKGRlc3RpbmF0aW9uQnVzLT5udW1iZXJP ZkNoYW5uZWxzKCkgPiAyKSB7CisgICAgICAgIGRlc3RpbmF0aW9uQnVzLT56ZXJvKCk7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICBBdWRpb0NoYW5uZWwqIGRlc3RpbmF0aW9uQ2hhbm5l bEwgPSBkZXN0aW5hdGlvbkJ1cy0+Y2hhbm5lbCgwKTsKKyAgICBBdWRpb0NoYW5uZWwqIHNvdXJj ZUNoYW5uZWxMID0gc291cmNlQnVzLT5jaGFubmVsKDApOworCisgICAgLy8gSGFuZGxlIGlucHV0 IC0+IG91dHB1dCBtYXRyaXhpbmcuLi4KKyAgICBzaXplX3QgbnVtSW5wdXRDaGFubmVscyA9IHNv dXJjZUJ1cy0+bnVtYmVyT2ZDaGFubmVscygpOworICAgIHNpemVfdCBudW1PdXRwdXRDaGFubmVs cyA9IGRlc3RpbmF0aW9uQnVzLT5udW1iZXJPZkNoYW5uZWxzKCk7CisgICAgc2l6ZV90IG51bVJl dmVyYkNoYW5uZWxzID0gbV9jb252b2x2ZXJzLnNpemUoKTsKKworICAgIGlmIChudW1JbnB1dENo YW5uZWxzID09IDIgJiYgbnVtUmV2ZXJiQ2hhbm5lbHMgPT0gMiAmJiBudW1PdXRwdXRDaGFubmVs cyA9PSAyKSB7CisgICAgICAgIC8vIDIgLT4gMiAtPiAyCisgICAgICAgIEF1ZGlvQ2hhbm5lbCog c291cmNlQ2hhbm5lbFIgPSBzb3VyY2VCdXMtPmNoYW5uZWwoMSk7CisgICAgICAgIEF1ZGlvQ2hh bm5lbCogZGVzdGluYXRpb25DaGFubmVsUiA9IGRlc3RpbmF0aW9uQnVzLT5jaGFubmVsKDEpOwor ICAgICAgICBtX2NvbnZvbHZlcnNbMF0tPnByb2Nlc3Moc291cmNlQ2hhbm5lbEwsIGRlc3RpbmF0 aW9uQ2hhbm5lbEwsIGZyYW1lc1RvUHJvY2Vzcyk7CisgICAgICAgIG1fY29udm9sdmVyc1sxXS0+ cHJvY2Vzcyhzb3VyY2VDaGFubmVsUiwgZGVzdGluYXRpb25DaGFubmVsUiwgZnJhbWVzVG9Qcm9j ZXNzKTsKKyAgICB9IGVsc2UgIGlmIChudW1JbnB1dENoYW5uZWxzID09IDEgJiYgbnVtT3V0cHV0 Q2hhbm5lbHMgPT0gMiAmJiBudW1SZXZlcmJDaGFubmVscyA9PSAyKSB7CisgICAgICAgIC8vIDEg LT4gMiAtPiAyCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMjsgKytpKSB7CisgICAgICAg ICAgICBBdWRpb0NoYW5uZWwqIGRlc3RpbmF0aW9uQ2hhbm5lbCA9IGRlc3RpbmF0aW9uQnVzLT5j aGFubmVsKGkpOworICAgICAgICAgICAgbV9jb252b2x2ZXJzW2ldLT5wcm9jZXNzKHNvdXJjZUNo YW5uZWxMLCBkZXN0aW5hdGlvbkNoYW5uZWwsIGZyYW1lc1RvUHJvY2Vzcyk7CisgICAgICAgIH0K KyAgICB9IGVsc2UgaWYgKG51bUlucHV0Q2hhbm5lbHMgPT0gMSAmJiBudW1SZXZlcmJDaGFubmVs cyA9PSAxICYmIG51bU91dHB1dENoYW5uZWxzID09IDIpIHsKKyAgICAgICAgLy8gMSAtPiAxIC0+ IDIKKyAgICAgICAgbV9jb252b2x2ZXJzWzBdLT5wcm9jZXNzKHNvdXJjZUNoYW5uZWxMLCBkZXN0 aW5hdGlvbkNoYW5uZWxMLCBmcmFtZXNUb1Byb2Nlc3MpOworCisgICAgICAgIC8vIHNpbXBseSBj b3B5IEwgLT4gUgorICAgICAgICBBdWRpb0NoYW5uZWwqIGRlc3RpbmF0aW9uQ2hhbm5lbFIgPSBk ZXN0aW5hdGlvbkJ1cy0+Y2hhbm5lbCgxKTsKKyAgICAgICAgYm9vbCBpc0NvcHlTYWZlID0gZGVz dGluYXRpb25DaGFubmVsTC0+ZGF0YSgpICYmIGRlc3RpbmF0aW9uQ2hhbm5lbFItPmRhdGEoKSAm JiBkZXN0aW5hdGlvbkNoYW5uZWxMLT5mcmFtZVNpemUoKSA+PSBmcmFtZXNUb1Byb2Nlc3MgJiYg ZGVzdGluYXRpb25DaGFubmVsUi0+ZnJhbWVTaXplKCkgPj0gZnJhbWVzVG9Qcm9jZXNzOworICAg ICAgICBBU1NFUlQoaXNDb3B5U2FmZSk7CisgICAgICAgIGlmICghaXNDb3B5U2FmZSkKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICAgICAgbWVtY3B5KGRlc3RpbmF0aW9uQ2hhbm5lbFItPmRhdGEo KSwgZGVzdGluYXRpb25DaGFubmVsTC0+ZGF0YSgpLCBzaXplb2YoZmxvYXQpICogZnJhbWVzVG9Q cm9jZXNzKTsKKyAgICB9IGVsc2UgaWYgKG51bUlucHV0Q2hhbm5lbHMgPT0gMSAmJiBudW1SZXZl cmJDaGFubmVscyA9PSAxICYmIG51bU91dHB1dENoYW5uZWxzID09IDEpIHsKKyAgICAgICAgLy8g MSAtPiAxIC0+IDEKKyAgICAgICAgbV9jb252b2x2ZXJzWzBdLT5wcm9jZXNzKHNvdXJjZUNoYW5u ZWxMLCBkZXN0aW5hdGlvbkNoYW5uZWxMLCBmcmFtZXNUb1Byb2Nlc3MpOworICAgIH0gZWxzZSBp ZiAobnVtSW5wdXRDaGFubmVscyA9PSAyICYmIG51bVJldmVyYkNoYW5uZWxzID09IDQgJiYgbnVt T3V0cHV0Q2hhbm5lbHMgPT0gMikgeworICAgICAgICAvLyAyIC0+IDQgLT4gMiAoIlRydWUiIHN0 ZXJlbykKKyAgICAgICAgQXVkaW9DaGFubmVsKiBzb3VyY2VDaGFubmVsUiA9IHNvdXJjZUJ1cy0+ Y2hhbm5lbCgxKTsKKyAgICAgICAgQXVkaW9DaGFubmVsKiBkZXN0aW5hdGlvbkNoYW5uZWxSID0g ZGVzdGluYXRpb25CdXMtPmNoYW5uZWwoMSk7CisKKyAgICAgICAgQXVkaW9DaGFubmVsKiB0ZW1w Q2hhbm5lbEwgPSBtX3RlbXBCdWZmZXItPmNoYW5uZWwoMCk7CisgICAgICAgIEF1ZGlvQ2hhbm5l bCogdGVtcENoYW5uZWxSID0gbV90ZW1wQnVmZmVyLT5jaGFubmVsKDEpOworCisgICAgICAgIC8v IFByb2Nlc3MgbGVmdCB2aXJ0dWFsIHNvdXJjZQorICAgICAgICBtX2NvbnZvbHZlcnNbMF0tPnBy b2Nlc3Moc291cmNlQ2hhbm5lbEwsIGRlc3RpbmF0aW9uQ2hhbm5lbEwsIGZyYW1lc1RvUHJvY2Vz cyk7CisgICAgICAgIG1fY29udm9sdmVyc1sxXS0+cHJvY2Vzcyhzb3VyY2VDaGFubmVsTCwgZGVz dGluYXRpb25DaGFubmVsUiwgZnJhbWVzVG9Qcm9jZXNzKTsKKworICAgICAgICAvLyBQcm9jZXNz IHJpZ2h0IHZpcnR1YWwgc291cmNlCisgICAgICAgIG1fY29udm9sdmVyc1syXS0+cHJvY2Vzcyhz b3VyY2VDaGFubmVsUiwgdGVtcENoYW5uZWxMLCBmcmFtZXNUb1Byb2Nlc3MpOworICAgICAgICBt X2NvbnZvbHZlcnNbM10tPnByb2Nlc3Moc291cmNlQ2hhbm5lbFIsIHRlbXBDaGFubmVsUiwgZnJh bWVzVG9Qcm9jZXNzKTsKKworICAgICAgICBkZXN0aW5hdGlvbkJ1cy0+c3VtRnJvbSgqbV90ZW1w QnVmZmVyKTsKKyAgICB9IGVsc2UgeworICAgICAgICAvLyBIYW5kbGUgZ3JhY2VmdWxseSBhbnkg dW5leHBlY3RlZCAvIHVuc3VwcG9ydGVkIG1hdHJpeGluZworICAgICAgICAvLyBGSVhNRTogYWRk IGNvZGUgZm9yIDUuMSBzdXBwb3J0Li4uCisgICAgICAgIGRlc3RpbmF0aW9uQnVzLT56ZXJvKCk7 CisgICAgfQorfQorCit2b2lkIFJldmVyYjo6cmVzZXQoKQoreworICAgIGZvciAoc2l6ZV90IGkg PSAwOyBpIDwgbV9jb252b2x2ZXJzLnNpemUoKTsgKytpKQorICAgICAgICBtX2NvbnZvbHZlcnNb aV0tPnJlc2V0KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vYXVkaW8vUmV2ZXJiLmggYi9XZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1Jl dmVyYi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI2ZjVmOGUKLS0tIC9k ZXYvbnVsbAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1JldmVyYi5oCkBAIC0wLDAgKzEs NjYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyBy 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 KyAqLworCisjaWZuZGVmIFJldmVyYl9oCisjZGVmaW5lIFJldmVyYl9oCisKKyNpbmNsdWRlICJS ZXZlcmJDb252b2x2ZXIuaCIKKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworY2xhc3MgQXVkaW9CdXM7CisgICAgCisvLyBNdWx0aS1jaGFubmVsIGNvbnZv bHV0aW9uIHJldmVyYiB3aXRoIGNoYW5uZWwgbWF0cml4aW5nIC0gb25lIG9yIG1vcmUgUmV2ZXJi Q29udm9sdmVyIG9iamVjdHMgYXJlIHVzZWQgaW50ZXJuYWxseS4KKworY2xhc3MgUmV2ZXJiIHsK K3B1YmxpYzoKKyAgICBlbnVtIHsgTWF4RnJhbWVTaXplID0gMjU2IH07CisKKyAgICAvLyByZW5k ZXJTbGljZVNpemUgaXMgYSByZW5kZXJpbmcgaGludCwgc28gdGhlIEZGVHMgY2FuIGJlIG9wdGlt aXplZCB0byBub3QgYWxsIG9jY3VyIGF0IHRoZSBzYW1lIHRpbWUgKHZlcnkgYmFkIHdoZW4gcmVu ZGVyaW5nIG9uIGEgcmVhbC10aW1lIHRocmVhZCkuCisgICAgUmV2ZXJiKEF1ZGlvQnVzKiBpbXB1 bHNlUmVzcG9uc2VCdWZmZXIsIHNpemVfdCByZW5kZXJTbGljZVNpemUsIHNpemVfdCBtYXhGRlRT aXplLCBzaXplX3QgbnVtYmVyT2ZDaGFubmVscywgYm9vbCB1c2VCYWNrZ3JvdW5kVGhyZWFkcyk7 CisKKyAgICB2b2lkIHByb2Nlc3MoQXVkaW9CdXMqIHNvdXJjZUJ1cywgQXVkaW9CdXMqIGRlc3Rp bmF0aW9uQnVzLCBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKTsKKyAgICB2b2lkIHJlc2V0KCk7CisK KyAgICB1bnNpZ25lZCBpbXB1bHNlUmVzcG9uc2VMZW5ndGgoKSBjb25zdCB7IHJldHVybiBtX2lt cHVsc2VSZXNwb25zZUxlbmd0aDsgfQorCitwcml2YXRlOgorICAgIHZvaWQgaW5pdGlhbGl6ZShB dWRpb0J1cyogaW1wdWxzZVJlc3BvbnNlQnVmZmVyLCBzaXplX3QgcmVuZGVyU2xpY2VTaXplLCBz aXplX3QgbWF4RkZUU2l6ZSwgc2l6ZV90IG51bWJlck9mQ2hhbm5lbHMsIGJvb2wgdXNlQmFja2dy b3VuZFRocmVhZHMpOworCisgICAgc2l6ZV90IG1faW1wdWxzZVJlc3BvbnNlTGVuZ3RoOworCisg ICAgVmVjdG9yPE93blB0cjxSZXZlcmJDb252b2x2ZXI+ID4gbV9jb252b2x2ZXJzOworCisgICAg Ly8gRm9yICJUcnVlIiBzdGVyZW8gcHJvY2Vzc2luZworICAgIE93blB0cjxBdWRpb0J1cz4gbV90 ZW1wQnVmZmVyOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gUmV2 ZXJiX2gK 65618 2010-08-26 14:26:18 -0700 2010-08-30 15:16:35 -0700 Patch bug-36466-20100826142613.patch text/plain 13990 crogers SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjEzNCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjMgQEAKKzIwMTAtMDgtMjYgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBh dWRpbyBlbmdpbmU6IGFkZCBSZXZlcmIgY2xhc3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTM2NDY2CisKKyAgICAgICAgTm8gbmV3IHRlc3RzIHNpbmNl IGF1ZGlvIEFQSSBpcyBub3QgeWV0IGltcGxlbWVudGVkLgorCisgICAgICAgICogcGxhdGZvcm0v YXVkaW86IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2F1ZGlvL1JldmVyYi5jcHA6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZTo6Y2FsY3VsYXRlTm9ybWFsaXphdGlvblNjYWxlKToKKyAgICAg ICAgKFdlYkNvcmU6OlJldmVyYjo6UmV2ZXJiKToKKyAgICAgICAgKFdlYkNvcmU6OlJldmVyYjo6 aW5pdGlhbGl6ZSk6CisgICAgICAgIChXZWJDb3JlOjpSZXZlcmI6OnByb2Nlc3MpOgorICAgICAg ICAoV2ViQ29yZTo6UmV2ZXJiOjpyZXNldCk6CisgICAgICAgICogcGxhdGZvcm0vYXVkaW8vUmV2 ZXJiLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6UmV2ZXJiOjopOgorICAgICAgICAoV2Vi Q29yZTo6UmV2ZXJiOjppbXB1bHNlUmVzcG9uc2VMZW5ndGgpOgorCiAyMDEwLTA4LTI2ICBUb255 IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQg SHlhdHQuCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1JldmVyYi5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmIuY3BwCShyZXZpc2lvbiAwKQorKysg V2ViQ29yZS9wbGF0Zm9ybS9hdWRpby9SZXZlcmIuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDIyNyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICogMy4gIE5laXRoZXIgdGhlIG5hbWUgb2Yg QXBwbGUgQ29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAqICAgICBp dHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0 cyBkZXJpdmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJp b3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIEVOQUJMRShXRUJfQVVESU8pCisK KyNpbmNsdWRlICJSZXZlcmIuaCIKKworI2luY2x1ZGUgIkF1ZGlvQnVzLmgiCisjaW5jbHVkZSAi QXVkaW9GaWxlUmVhZGVyLmgiCisjaW5jbHVkZSAiUmV2ZXJiQ29udm9sdmVyLmgiCisjaW5jbHVk ZSA8bWF0aC5oPgorI2luY2x1ZGUgPHd0Zi9NYXRoRXh0cmFzLmg+CisjaW5jbHVkZSA8d3RmL093 blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKKyNpZiBPUyhEQVJXSU4pCit1 c2luZyBuYW1lc3BhY2Ugc3RkOworI2VuZGlmCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworLy8g RW1waXJpY2FsIGdhaW4gY2FsaWJyYXRpb24gdGVzdGVkIGFjcm9zcyBtYW55IGltcHVsc2UgcmVz cG9uc2VzIHRvIGVuc3VyZSBwZXJjZWl2ZWQgdm9sdW1lIGlzIHNhbWUgYXMgZHJ5ICh1bnByb2Nl c3NlZCkgc2lnbmFsCitjb25zdCBkb3VibGUgR2FpbkNhbGlicmF0aW9uID0gLTU4LjA7CisKKy8v IEEgbWluaW11bSBwb3dlciB2YWx1ZSB0byB3aGVuIG5vcm1hbGl6aW5nIGEgc2lsZW50IChvciB2 ZXJ5IHF1aWV0KSBpbXB1bHNlIHJlc3BvbnNlCitjb25zdCBkb3VibGUgTWluUG93ZXIgPSAwLjAw MDEyNTsKKyAgICAKK3N0YXRpYyBkb3VibGUgY2FsY3VsYXRlTm9ybWFsaXphdGlvblNjYWxlKEF1 ZGlvQnVzKiByZXNwb25zZSkKK3sKKyAgICAvLyBOb3JtYWxpemUgYnkgUk1TIHBvd2VyCisgICAg c2l6ZV90IG51bWJlck9mQ2hhbm5lbHMgPSByZXNwb25zZS0+bnVtYmVyT2ZDaGFubmVscygpOwor ICAgIHNpemVfdCBmcmFtZVNpemUgPSByZXNwb25zZS0+ZnJhbWVTaXplKCk7CisKKyAgICBkb3Vi bGUgcG93ZXIgPSAwLjA7CisKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG51bWJlck9mQ2hh bm5lbHM7ICsraSkgeworICAgICAgICBpbnQgbiA9IGZyYW1lU2l6ZTsKKyAgICAgICAgZmxvYXQq IHAgPSByZXNwb25zZS0+Y2hhbm5lbChpKS0+ZGF0YSgpOworCisgICAgICAgIHdoaWxlIChuLS0p IHsKKyAgICAgICAgICAgIGZsb2F0IHNhbXBsZSA9ICpwKys7CisgICAgICAgICAgICBwb3dlciAr PSBzYW1wbGUgKiBzYW1wbGU7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBwb3dlciA9IHNxcnQo cG93ZXIgLyAobnVtYmVyT2ZDaGFubmVscyAqIGZyYW1lU2l6ZSkpOworCisgICAgLy8gUHJvdGVj dCBhZ2FpbnN0IGFjY2lkZW50YWwgb3ZlcmxvYWQKKyAgICBpZiAoaXNpbmYocG93ZXIpIHx8IGlz bmFuKHBvd2VyKSB8fCBwb3dlciA8IE1pblBvd2VyKQorICAgICAgICBwb3dlciA9IE1pblBvd2Vy OworCisgICAgZG91YmxlIHNjYWxlID0gMS4wIC8gcG93ZXI7CisKKyAgICBzY2FsZSAqPSBwb3co MTAuMCwgR2FpbkNhbGlicmF0aW9uICogMC4wNSk7IC8vIGNhbGlicmF0ZSB0byBtYWtlIHBlcmNl aXZlZCB2b2x1bWUgc2FtZSBhcyB1bnByb2Nlc3NlZAorCisgICAgLy8gVHJ1ZS1zdGVyZW8gY29t cGVuc2F0aW9uCisgICAgaWYgKHJlc3BvbnNlLT5udW1iZXJPZkNoYW5uZWxzKCkgPT0gNCkKKyAg ICAgICAgc2NhbGUgKj0gMC41OworCisgICAgcmV0dXJuIHNjYWxlOworfQorCitSZXZlcmI6OlJl dmVyYihBdWRpb0J1cyogaW1wdWxzZVJlc3BvbnNlLCBzaXplX3QgcmVuZGVyU2xpY2VTaXplLCBz aXplX3QgbWF4RkZUU2l6ZSwgc2l6ZV90IG51bWJlck9mQ2hhbm5lbHMsIGJvb2wgdXNlQmFja2dy b3VuZFRocmVhZHMpCit7CisgICAgZG91YmxlIHNjYWxlID0gY2FsY3VsYXRlTm9ybWFsaXphdGlv blNjYWxlKGltcHVsc2VSZXNwb25zZSk7CisgICAgaWYgKHNjYWxlKQorICAgICAgICBpbXB1bHNl UmVzcG9uc2UtPnNjYWxlKHNjYWxlKTsKKworICAgIGluaXRpYWxpemUoaW1wdWxzZVJlc3BvbnNl LCByZW5kZXJTbGljZVNpemUsIG1heEZGVFNpemUsIG51bWJlck9mQ2hhbm5lbHMsIHVzZUJhY2tn cm91bmRUaHJlYWRzKTsKKworICAgIC8vIFVuZG8gc2NhbGluZyBzaW5jZSB0aGlzIHNob3VsZG4n dCBiZSBhIGRlc3RydWN0aXZlIG9wZXJhdGlvbiBvbiBpbXB1bHNlUmVzcG9uc2UKKyAgICBpZiAo c2NhbGUpCisgICAgICAgIGltcHVsc2VSZXNwb25zZS0+c2NhbGUoMS4wIC8gc2NhbGUpOworfQor Cit2b2lkIFJldmVyYjo6aW5pdGlhbGl6ZShBdWRpb0J1cyogaW1wdWxzZVJlc3BvbnNlQnVmZmVy LCBzaXplX3QgcmVuZGVyU2xpY2VTaXplLCBzaXplX3QgbWF4RkZUU2l6ZSwgc2l6ZV90IG51bWJl ck9mQ2hhbm5lbHMsIGJvb2wgdXNlQmFja2dyb3VuZFRocmVhZHMpCit7CisgICAgbV9pbXB1bHNl UmVzcG9uc2VMZW5ndGggPSBpbXB1bHNlUmVzcG9uc2VCdWZmZXItPmZyYW1lU2l6ZSgpOworCisg ICAgLy8gVGhlIHJldmVyYiBjYW4gaGFuZGxlIGEgbW9ubyBpbXB1bHNlIHJlc3BvbnNlIGFuZCBz dGlsbCBkbyBzdGVyZW8gcHJvY2Vzc2luZworICAgIHNpemVfdCBudW1SZXNwb25zZUNoYW5uZWxz ID0gaW1wdWxzZVJlc3BvbnNlQnVmZmVyLT5udW1iZXJPZkNoYW5uZWxzKCk7CisgICAgbV9jb252 b2x2ZXJzLnJlc2VydmVDYXBhY2l0eShudW1iZXJPZkNoYW5uZWxzKTsKKworICAgIGludCBjb252 b2x2ZXJSZW5kZXJQaGFzZSA9IDA7CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBudW1SZXNw b25zZUNoYW5uZWxzOyArK2kpIHsKKyAgICAgICAgQXVkaW9DaGFubmVsKiBjaGFubmVsID0gaW1w dWxzZVJlc3BvbnNlQnVmZmVyLT5jaGFubmVsKGkpOworCisgICAgICAgIFJldmVyYkNvbnZvbHZl ciogY29udm9sdmVyID0gbmV3IFJldmVyYkNvbnZvbHZlcihjaGFubmVsLCByZW5kZXJTbGljZVNp emUsIG1heEZGVFNpemUsIGNvbnZvbHZlclJlbmRlclBoYXNlLCB1c2VCYWNrZ3JvdW5kVGhyZWFk cyk7CisgICAgICAgIG1fY29udm9sdmVycy5hcHBlbmQoY29udm9sdmVyKTsKKworICAgICAgICBj b252b2x2ZXJSZW5kZXJQaGFzZSArPSByZW5kZXJTbGljZVNpemU7CisgICAgfQorCisgICAgLy8g Rm9yICJUcnVlIiBzdGVyZW8gcHJvY2Vzc2luZyB3ZSBhbGxvY2F0ZSBhIHRlbXBvcmFyeSBidWZm ZXIgdG8gYXZvaWQgcmVwZWF0ZWRseSBhbGxvY2F0aW5nIGl0IGluIHRoZSBwcm9jZXNzKCkgbWV0 aG9kLgorICAgIC8vIEl0IGNhbiBiZSBiYWQgdG8gYWxsb2NhdGUgbWVtb3J5IGluIGEgcmVhbC10 aW1lIHRocmVhZC4KKyAgICBpZiAobnVtUmVzcG9uc2VDaGFubmVscyA9PSA0KQorICAgICAgICBt X3RlbXBCdWZmZXIgPSBuZXcgQXVkaW9CdXMoMiwgTWF4RnJhbWVTaXplKTsKK30KKwordm9pZCBS ZXZlcmI6OnByb2Nlc3MoQXVkaW9CdXMqIHNvdXJjZUJ1cywgQXVkaW9CdXMqIGRlc3RpbmF0aW9u QnVzLCBzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKQoreworICAgIC8vIERvIGEgZmFpcmx5IGNvbXBy ZWhlbnNpdmUgc2FuaXR5IGNoZWNrLgorICAgIC8vIElmIHRoZXNlIGNvbmRpdGlvbnMgYXJlIHNh dGlzZmllZCwgYWxsIG9mIHRoZSBzb3VyY2UgYW5kIGRlc3RpbmF0aW9uIHBvaW50ZXJzIHdpbGwg YmUgdmFsaWQgZm9yIHRoZSB2YXJpb3VzIG1hdHJpeGluZyBjYXNlcy4KKyAgICBib29sIGlzU2Fm ZVRvUHJvY2VzcyA9IHNvdXJjZUJ1cyAmJiBkZXN0aW5hdGlvbkJ1cyAmJiBzb3VyY2VCdXMtPm51 bWJlck9mQ2hhbm5lbHMoKSA+IDAgJiYgZGVzdGluYXRpb25CdXMtPm51bWJlck9mQ2hhbm5lbHMo KSA+IDAKKyAgICAgICAgJiYgZnJhbWVzVG9Qcm9jZXNzIDw9IE1heEZyYW1lU2l6ZSAmJiBmcmFt ZXNUb1Byb2Nlc3MgPD0gc291cmNlQnVzLT5mcmFtZVNpemUoKSAmJiBmcmFtZXNUb1Byb2Nlc3Mg PD0gZGVzdGluYXRpb25CdXMtPmZyYW1lU2l6ZSgpOyAKKyAgICAKKyAgICBBU1NFUlQoaXNTYWZl VG9Qcm9jZXNzKTsKKyAgICBpZiAoIWlzU2FmZVRvUHJvY2VzcykKKyAgICAgICAgcmV0dXJuOwor CisgICAgLy8gRm9yIG5vdyBvbmx5IGhhbmRsZSBtb25vIG9yIHN0ZXJlbyBvdXRwdXQKKyAgICBp ZiAoZGVzdGluYXRpb25CdXMtPm51bWJlck9mQ2hhbm5lbHMoKSA+IDIpIHsKKyAgICAgICAgZGVz dGluYXRpb25CdXMtPnplcm8oKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEF1ZGlv Q2hhbm5lbCogZGVzdGluYXRpb25DaGFubmVsTCA9IGRlc3RpbmF0aW9uQnVzLT5jaGFubmVsKDAp OworICAgIEF1ZGlvQ2hhbm5lbCogc291cmNlQ2hhbm5lbEwgPSBzb3VyY2VCdXMtPmNoYW5uZWwo MCk7CisKKyAgICAvLyBIYW5kbGUgaW5wdXQgLT4gb3V0cHV0IG1hdHJpeGluZy4uLgorICAgIHNp emVfdCBudW1JbnB1dENoYW5uZWxzID0gc291cmNlQnVzLT5udW1iZXJPZkNoYW5uZWxzKCk7Cisg ICAgc2l6ZV90IG51bU91dHB1dENoYW5uZWxzID0gZGVzdGluYXRpb25CdXMtPm51bWJlck9mQ2hh bm5lbHMoKTsKKyAgICBzaXplX3QgbnVtUmV2ZXJiQ2hhbm5lbHMgPSBtX2NvbnZvbHZlcnMuc2l6 ZSgpOworCisgICAgaWYgKG51bUlucHV0Q2hhbm5lbHMgPT0gMiAmJiBudW1SZXZlcmJDaGFubmVs cyA9PSAyICYmIG51bU91dHB1dENoYW5uZWxzID09IDIpIHsKKyAgICAgICAgLy8gMiAtPiAyIC0+ IDIKKyAgICAgICAgQXVkaW9DaGFubmVsKiBzb3VyY2VDaGFubmVsUiA9IHNvdXJjZUJ1cy0+Y2hh bm5lbCgxKTsKKyAgICAgICAgQXVkaW9DaGFubmVsKiBkZXN0aW5hdGlvbkNoYW5uZWxSID0gZGVz dGluYXRpb25CdXMtPmNoYW5uZWwoMSk7CisgICAgICAgIG1fY29udm9sdmVyc1swXS0+cHJvY2Vz cyhzb3VyY2VDaGFubmVsTCwgZGVzdGluYXRpb25DaGFubmVsTCwgZnJhbWVzVG9Qcm9jZXNzKTsK KyAgICAgICAgbV9jb252b2x2ZXJzWzFdLT5wcm9jZXNzKHNvdXJjZUNoYW5uZWxSLCBkZXN0aW5h dGlvbkNoYW5uZWxSLCBmcmFtZXNUb1Byb2Nlc3MpOworICAgIH0gZWxzZSAgaWYgKG51bUlucHV0 Q2hhbm5lbHMgPT0gMSAmJiBudW1PdXRwdXRDaGFubmVscyA9PSAyICYmIG51bVJldmVyYkNoYW5u ZWxzID09IDIpIHsKKyAgICAgICAgLy8gMSAtPiAyIC0+IDIKKyAgICAgICAgZm9yIChpbnQgaSA9 IDA7IGkgPCAyOyArK2kpIHsKKyAgICAgICAgICAgIEF1ZGlvQ2hhbm5lbCogZGVzdGluYXRpb25D aGFubmVsID0gZGVzdGluYXRpb25CdXMtPmNoYW5uZWwoaSk7CisgICAgICAgICAgICBtX2NvbnZv bHZlcnNbaV0tPnByb2Nlc3Moc291cmNlQ2hhbm5lbEwsIGRlc3RpbmF0aW9uQ2hhbm5lbCwgZnJh bWVzVG9Qcm9jZXNzKTsKKyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAobnVtSW5wdXRDaGFubmVs cyA9PSAxICYmIG51bVJldmVyYkNoYW5uZWxzID09IDEgJiYgbnVtT3V0cHV0Q2hhbm5lbHMgPT0g MikgeworICAgICAgICAvLyAxIC0+IDEgLT4gMgorICAgICAgICBtX2NvbnZvbHZlcnNbMF0tPnBy b2Nlc3Moc291cmNlQ2hhbm5lbEwsIGRlc3RpbmF0aW9uQ2hhbm5lbEwsIGZyYW1lc1RvUHJvY2Vz cyk7CisKKyAgICAgICAgLy8gc2ltcGx5IGNvcHkgTCAtPiBSCisgICAgICAgIEF1ZGlvQ2hhbm5l bCogZGVzdGluYXRpb25DaGFubmVsUiA9IGRlc3RpbmF0aW9uQnVzLT5jaGFubmVsKDEpOworICAg ICAgICBib29sIGlzQ29weVNhZmUgPSBkZXN0aW5hdGlvbkNoYW5uZWxMLT5kYXRhKCkgJiYgZGVz dGluYXRpb25DaGFubmVsUi0+ZGF0YSgpICYmIGRlc3RpbmF0aW9uQ2hhbm5lbEwtPmZyYW1lU2l6 ZSgpID49IGZyYW1lc1RvUHJvY2VzcyAmJiBkZXN0aW5hdGlvbkNoYW5uZWxSLT5mcmFtZVNpemUo KSA+PSBmcmFtZXNUb1Byb2Nlc3M7CisgICAgICAgIEFTU0VSVChpc0NvcHlTYWZlKTsKKyAgICAg ICAgaWYgKCFpc0NvcHlTYWZlKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBtZW1jcHko ZGVzdGluYXRpb25DaGFubmVsUi0+ZGF0YSgpLCBkZXN0aW5hdGlvbkNoYW5uZWxMLT5kYXRhKCks IHNpemVvZihmbG9hdCkgKiBmcmFtZXNUb1Byb2Nlc3MpOworICAgIH0gZWxzZSBpZiAobnVtSW5w dXRDaGFubmVscyA9PSAxICYmIG51bVJldmVyYkNoYW5uZWxzID09IDEgJiYgbnVtT3V0cHV0Q2hh bm5lbHMgPT0gMSkgeworICAgICAgICAvLyAxIC0+IDEgLT4gMQorICAgICAgICBtX2NvbnZvbHZl cnNbMF0tPnByb2Nlc3Moc291cmNlQ2hhbm5lbEwsIGRlc3RpbmF0aW9uQ2hhbm5lbEwsIGZyYW1l c1RvUHJvY2Vzcyk7CisgICAgfSBlbHNlIGlmIChudW1JbnB1dENoYW5uZWxzID09IDIgJiYgbnVt UmV2ZXJiQ2hhbm5lbHMgPT0gNCAmJiBudW1PdXRwdXRDaGFubmVscyA9PSAyKSB7CisgICAgICAg IC8vIDIgLT4gNCAtPiAyICgiVHJ1ZSIgc3RlcmVvKQorICAgICAgICBBdWRpb0NoYW5uZWwqIHNv dXJjZUNoYW5uZWxSID0gc291cmNlQnVzLT5jaGFubmVsKDEpOworICAgICAgICBBdWRpb0NoYW5u ZWwqIGRlc3RpbmF0aW9uQ2hhbm5lbFIgPSBkZXN0aW5hdGlvbkJ1cy0+Y2hhbm5lbCgxKTsKKwor ICAgICAgICBBdWRpb0NoYW5uZWwqIHRlbXBDaGFubmVsTCA9IG1fdGVtcEJ1ZmZlci0+Y2hhbm5l bCgwKTsKKyAgICAgICAgQXVkaW9DaGFubmVsKiB0ZW1wQ2hhbm5lbFIgPSBtX3RlbXBCdWZmZXIt PmNoYW5uZWwoMSk7CisKKyAgICAgICAgLy8gUHJvY2VzcyBsZWZ0IHZpcnR1YWwgc291cmNlCisg ICAgICAgIG1fY29udm9sdmVyc1swXS0+cHJvY2Vzcyhzb3VyY2VDaGFubmVsTCwgZGVzdGluYXRp b25DaGFubmVsTCwgZnJhbWVzVG9Qcm9jZXNzKTsKKyAgICAgICAgbV9jb252b2x2ZXJzWzFdLT5w cm9jZXNzKHNvdXJjZUNoYW5uZWxMLCBkZXN0aW5hdGlvbkNoYW5uZWxSLCBmcmFtZXNUb1Byb2Nl c3MpOworCisgICAgICAgIC8vIFByb2Nlc3MgcmlnaHQgdmlydHVhbCBzb3VyY2UKKyAgICAgICAg bV9jb252b2x2ZXJzWzJdLT5wcm9jZXNzKHNvdXJjZUNoYW5uZWxSLCB0ZW1wQ2hhbm5lbEwsIGZy YW1lc1RvUHJvY2Vzcyk7CisgICAgICAgIG1fY29udm9sdmVyc1szXS0+cHJvY2Vzcyhzb3VyY2VD aGFubmVsUiwgdGVtcENoYW5uZWxSLCBmcmFtZXNUb1Byb2Nlc3MpOworCisgICAgICAgIGRlc3Rp bmF0aW9uQnVzLT5zdW1Gcm9tKCptX3RlbXBCdWZmZXIpOworICAgIH0gZWxzZSBpZiAobnVtSW5w dXRDaGFubmVscyA9PSAxICYmIG51bVJldmVyYkNoYW5uZWxzID09IDQgJiYgbnVtT3V0cHV0Q2hh bm5lbHMgPT0gMikgeworICAgICAgICAvLyAxIC0+IDQgLT4gMiAoUHJvY2Vzc2luZyBtb25vIHdp dGggIlRydWUiIHN0ZXJlbyBpbXB1bHNlIHJlc3BvbnNlKQorICAgICAgICAvLyBUaGlzIGlzIGFu IGluZWZmaWNpZW50IHVzZSBvZiBhIGZvdXItY2hhbm5lbCBpbXB1bHNlIHJlc3BvbnNlLCBidXQg d2Ugc2hvdWxkIGhhbmRsZSB0aGUgY2FzZS4KKyAgICAgICAgQXVkaW9DaGFubmVsKiBkZXN0aW5h dGlvbkNoYW5uZWxSID0gZGVzdGluYXRpb25CdXMtPmNoYW5uZWwoMSk7CisKKyAgICAgICAgQXVk aW9DaGFubmVsKiB0ZW1wQ2hhbm5lbEwgPSBtX3RlbXBCdWZmZXItPmNoYW5uZWwoMCk7CisgICAg ICAgIEF1ZGlvQ2hhbm5lbCogdGVtcENoYW5uZWxSID0gbV90ZW1wQnVmZmVyLT5jaGFubmVsKDEp OworCisgICAgICAgIC8vIFByb2Nlc3MgbGVmdCB2aXJ0dWFsIHNvdXJjZQorICAgICAgICBtX2Nv bnZvbHZlcnNbMF0tPnByb2Nlc3Moc291cmNlQ2hhbm5lbEwsIGRlc3RpbmF0aW9uQ2hhbm5lbEws IGZyYW1lc1RvUHJvY2Vzcyk7CisgICAgICAgIG1fY29udm9sdmVyc1sxXS0+cHJvY2Vzcyhzb3Vy Y2VDaGFubmVsTCwgZGVzdGluYXRpb25DaGFubmVsUiwgZnJhbWVzVG9Qcm9jZXNzKTsKKworICAg ICAgICAvLyBQcm9jZXNzIHJpZ2h0IHZpcnR1YWwgc291cmNlCisgICAgICAgIG1fY29udm9sdmVy c1syXS0+cHJvY2Vzcyhzb3VyY2VDaGFubmVsTCwgdGVtcENoYW5uZWxMLCBmcmFtZXNUb1Byb2Nl c3MpOworICAgICAgICBtX2NvbnZvbHZlcnNbM10tPnByb2Nlc3Moc291cmNlQ2hhbm5lbEwsIHRl bXBDaGFubmVsUiwgZnJhbWVzVG9Qcm9jZXNzKTsKKworICAgICAgICBkZXN0aW5hdGlvbkJ1cy0+ c3VtRnJvbSgqbV90ZW1wQnVmZmVyKTsKKyAgICB9IGVsc2UgeworICAgICAgICAvLyBIYW5kbGUg Z3JhY2VmdWxseSBhbnkgdW5leHBlY3RlZCAvIHVuc3VwcG9ydGVkIG1hdHJpeGluZworICAgICAg ICAvLyBGSVhNRTogYWRkIGNvZGUgZm9yIDUuMSBzdXBwb3J0Li4uCisgICAgICAgIGRlc3RpbmF0 aW9uQnVzLT56ZXJvKCk7CisgICAgfQorfQorCit2b2lkIFJldmVyYjo6cmVzZXQoKQoreworICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9jb252b2x2ZXJzLnNpemUoKTsgKytpKQorICAgICAg ICBtX2NvbnZvbHZlcnNbaV0tPnJlc2V0KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUK KworI2VuZGlmIC8vIEVOQUJMRShXRUJfQVVESU8pCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2F1 ZGlvL1JldmVyYi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vYXVkaW8vUmV2ZXJi LmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2F1ZGlvL1JldmVyYi5oCShyZXZp c2lvbiAwKQpAQCAtMCwwICsxLDY2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2ds ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKiAzLiAgTmVp dGhlciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAoIkFwcGxlIikgbm9yIHRoZSBu YW1lcyBvZgorICogICAgIGl0cyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBv ciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQKKyAqICAgICBmcm9tIHRoaXMgc29mdHdhcmUgd2l0 aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFO RCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7Cisg KiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBSZXZlcmJfaAorI2RlZmluZSBSZXZl cmJfaAorCisjaW5jbHVkZSAiUmV2ZXJiQ29udm9sdmVyLmgiCisjaW5jbHVkZSA8d3RmL1ZlY3Rv ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEF1ZGlvQnVzOworICAgIAorLy8g TXVsdGktY2hhbm5lbCBjb252b2x1dGlvbiByZXZlcmIgd2l0aCBjaGFubmVsIG1hdHJpeGluZyAt IG9uZSBvciBtb3JlIFJldmVyYkNvbnZvbHZlciBvYmplY3RzIGFyZSB1c2VkIGludGVybmFsbHku CisKK2NsYXNzIFJldmVyYiB7CitwdWJsaWM6CisgICAgZW51bSB7IE1heEZyYW1lU2l6ZSA9IDI1 NiB9OworCisgICAgLy8gcmVuZGVyU2xpY2VTaXplIGlzIGEgcmVuZGVyaW5nIGhpbnQsIHNvIHRo ZSBGRlRzIGNhbiBiZSBvcHRpbWl6ZWQgdG8gbm90IGFsbCBvY2N1ciBhdCB0aGUgc2FtZSB0aW1l ICh2ZXJ5IGJhZCB3aGVuIHJlbmRlcmluZyBvbiBhIHJlYWwtdGltZSB0aHJlYWQpLgorICAgIFJl dmVyYihBdWRpb0J1cyogaW1wdWxzZVJlc3BvbnNlQnVmZmVyLCBzaXplX3QgcmVuZGVyU2xpY2VT aXplLCBzaXplX3QgbWF4RkZUU2l6ZSwgc2l6ZV90IG51bWJlck9mQ2hhbm5lbHMsIGJvb2wgdXNl QmFja2dyb3VuZFRocmVhZHMpOworCisgICAgdm9pZCBwcm9jZXNzKEF1ZGlvQnVzKiBzb3VyY2VC dXMsIEF1ZGlvQnVzKiBkZXN0aW5hdGlvbkJ1cywgc2l6ZV90IGZyYW1lc1RvUHJvY2Vzcyk7Cisg ICAgdm9pZCByZXNldCgpOworCisgICAgdW5zaWduZWQgaW1wdWxzZVJlc3BvbnNlTGVuZ3RoKCkg Y29uc3QgeyByZXR1cm4gbV9pbXB1bHNlUmVzcG9uc2VMZW5ndGg7IH0KKworcHJpdmF0ZToKKyAg ICB2b2lkIGluaXRpYWxpemUoQXVkaW9CdXMqIGltcHVsc2VSZXNwb25zZUJ1ZmZlciwgc2l6ZV90 IHJlbmRlclNsaWNlU2l6ZSwgc2l6ZV90IG1heEZGVFNpemUsIHNpemVfdCBudW1iZXJPZkNoYW5u ZWxzLCBib29sIHVzZUJhY2tncm91bmRUaHJlYWRzKTsKKworICAgIHNpemVfdCBtX2ltcHVsc2VS ZXNwb25zZUxlbmd0aDsKKworICAgIFZlY3RvcjxPd25QdHI8UmV2ZXJiQ29udm9sdmVyPiA+IG1f Y29udm9sdmVyczsKKworICAgIC8vIEZvciAiVHJ1ZSIgc3RlcmVvIHByb2Nlc3NpbmcKKyAgICBP d25QdHI8QXVkaW9CdXM+IG1fdGVtcEJ1ZmZlcjsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNv cmUKKworI2VuZGlmIC8vIFJldmVyYl9oCg==