45142 2010-09-02 15:48:58 -0700 [Qt] V8 port for Qt platform: Use DateMath from WTF 2010-09-20 12:33:21 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) All All RESOLVED INVALID Qt, QtTriaged P3 Normal --- 45136 1 vladbph webkit-qt-unassigned antonm christian.webkit hausmann kent.hansen kling luiz oldest_to_newest 273633 0 vladbph 2010-09-02 15:48:58 -0700 Add getDSTOffset, cachedUTCOffset to global object as hidden properties 273684 1 66435 vladbph 2010-09-02 17:15:42 -0700 Created attachment 66435 Use DateMath from WTF 273980 2 66435 kling 2010-09-03 09:51:07 -0700 Comment on attachment 66435 Use DateMath from WTF > + [Qt] V8 port for QT platform: Use DateMath from WTF I'm sure there's a reason we need this from WTF, but could you expand on why? :-) > - if (*dateString != ':') { > + if (*dateString != ':') > offset = ((o / 100) * 60 + (o % 100)) * sgn; > - } else { // GMT+05:00 > + else { // GMT+05:00 While correct, please avoid making unrelated style changes as it makes "svn blame" harder to use. 274014 3 vladbph 2010-09-03 10:20:23 -0700 DateMath is used by /bridge/qt/qt_runtime... (In reply to comment #2) > (From update of attachment 66435 [details]) > > + [Qt] V8 port for QT platform: Use DateMath from WTF > > I'm sure there's a reason we need this from WTF, but could you expand on why? :-) I got style failure, so I went and fixed that... > > > - if (*dateString != ':') { > > + if (*dateString != ':') > > offset = ((o / 100) * 60 + (o % 100)) * sgn; > > - } else { // GMT+05:00 > > + else { // GMT+05:00 > > While correct, please avoid making unrelated style changes as it makes "svn blame" harder to use. 274132 4 vladbph 2010-09-03 12:47:16 -0700 These API is used by /bridge/qt/qt_runtime void msToGregorianDateTime(v8::Handle<v8::Context> context, double, bool outputIsUTC, GregorianDateTime&); double gregorianDateTimeToMS(v8::Handle<v8::Context> context, const GregorianDateTime&, double, bool inputIsUTC); double getUTCOffset(v8::Handle<v8::Context> context); double parseDateFromNullTerminatedCharacters(v8::Handle<v8::Context> context, const char* dateString); 274137 5 66536 vladbph 2010-09-03 12:53:49 -0700 Created attachment 66536 Updated according to comments 274503 6 66536 abarth 2010-09-05 23:36:47 -0700 Comment on attachment 66536 Updated according to comments View in context: https://bugs.webkit.org/attachment.cgi?id=66536&action=prettypatch I was tempted to R- this patch because of the dependency issue, but I don't really understand the contraints here in enough detail. > JavaScriptCore/wtf/DateMath.cpp:866 > #if USE(JSC) > namespace JSC { > +#elif USE(V8) > +namespace V8 { > +#endif Woah, crazy. > JavaScriptCore/wtf/DateMath.h:54 > +#if USE(V8) && PLATFORM(QT) > +#include <v8.h> > +#endif This seems like a bad dependency. I don't think code outside of WebCore/bindings/v8 is supposed to depend on v8.h. 274558 7 66536 kling 2010-09-06 04:52:10 -0700 Comment on attachment 66536 Updated according to comments Yeah, this isn't gonna work, we don't want to put V8 stuff in JavaScriptCore/ I'd rather we implement these methods where they're needed in the Qt bridge. Or better yet, remove the dependency altogether (if possible.) 275629 8 vladbph 2010-09-07 23:22:51 -0700 Sorry guys, but if datemath has direct references to JSC, why it cannot depends on V8? Datemath API is used in QT-v8 based implementation. I cannot use v8 api without including v8.h #ifdef USE(JSC) #elif USE(V8) #endif based on other comments for the same metabug. Crazy would be copying the same implementation to another location, IMHO. 275759 9 kling 2010-09-08 05:00:12 -0700 It reads to me like the bridge code could be written using Qt date/time types only -- do you really need something that JSC's GregorianDateTime provides? 275836 10 kent.hansen 2010-09-08 07:49:25 -0700 (In reply to comment #8) > Sorry guys, but if datemath has direct references to JSC, why it cannot depends on V8? Datemath API is used in QT-v8 based implementation. I cannot use v8 api without including v8.h > > #ifdef USE(JSC) > #elif USE(V8) > #endif > based on other comments for the same metabug. > Crazy would be copying the same implementation to another location, IMHO. Granted, the DateMath dependency on JSC isn't the best ever (an ExecState just to get to a DST/UTCOffset cache?!). But wtf/DateMath does live under JavaScriptCore/, after all, so it's a rather pragmatic solution. Seems like the two options are either to generalize DateMath (so it doesn't have the JSC dependency), or, like Andreas suggested, use QDateTime directly. I'm in favor of the latter, we should at least figure out why QDateTime isn't sufficient (and extend it if appropriate). For example, instead of msToGregorianDateTime() it should be possible to base the conversion on QDateTime::fromTime_t() (http://doc.trolltech.com/4.6/qdatetime.html#fromTime_t). 277759 11 hausmann 2010-09-11 11:29:27 -0700 Closing as invalid. I agree with Kent and as discussed with Andreas we're closing this as invalid and instead will use QDateTime for landing. 281491 12 antonm 2010-09-20 04:21:28 -0700 Vlad, may I ask you to post patches as plain patches, not zipped sources? It's more convenient to review them, esp. with the tools Adam is working on these days. First round of comments: qt_instancev8.h: (stylistic issue, feel free to ignore): typedef enum { MetaProperty, DynamicProperty, ChildObject } QtFieldType; Why not enum QtFieldType etc.? It looks more C++-ish to me. static v8::Handle<v8::Value> GetProperty(v8::Local<v8::String> propname, const v8::AccessorInfo &info); I think WebKit code style requires method names to start with lower case. Ditto for SetProperty, SetAccessors. BTW, there are scripts under WebKitTools\Scripts which should have warn you about style violations. qt_instancev8.cpp: : m_context(v8::Persistent<v8::Context>::New(context)) Do you clear the handle somewhere? Please note that destructor won't clean it up. You should add explicit invocation of Dispose, probably followed by Clear to make it easier to catch errors. v8::Handle<v8::FunctionTemplate> v8ClassTempl = v8::Persistent<v8::FunctionTemplate>::New(v8::FunctionTemplate::New()); Persistent handles are heavyweight and should be avoided unless really needed. They should be used when you want to have a reference to the object out of HandleScope, for example maps from native objects to v8 wrappers. Apparently in your case you should just use HandleScope (unless it's already been created) and use local handles which are cheaper and has better (imho) semantics. m_v8Obj->SetPointerInInternalField(QtInstanceIndexId, (void*)QtInstanceGeneric); That is somewhat tricky. I'd rather not trick and cast numbers to pointers, v8's ints might be a better choice here (unless it's really necessary from performance point of view). And even for performance, in your case you're lucky to have even number (0) and that would be stored rather efficiently, however if it'd been odd, performance would suffer and memory usage would be bigger. methodlPropTempl->SetAccessor( v8::String::New("connect"), fieldGetter, fieldSetter, v8::String::New("connect"), v8::DEFAULT, v8::DontDelete); methodlPropTempl->SetAccessor( v8::String::New("disconnect"), fieldGetter, fieldSetter, v8::String::New("disconnect"), v8::DEFAULT, v8::DontDelete); Indentation is apparently off (compare first argument to others). methodFunc->SetHiddenValue(v8::String::New("__qt_hidden_marker__"), v8::External::Wrap(this)); Just in case, hidden values are somewhat slow. QtInstance::CreateV8Object: you may want to refactor wrapping logic of creation connect/disconnect methods. void QtInstance::GcCallback(v8::Persistent<v8::Value> obj, void*) { v8::HandleScope scope; obj.Dispose(); } As you don't create local handles here, you apparently don't need HandleScope. // The garbage collector removes instances, but it may happen that the wrapped // QObject dies before the gc kicks in. To handle that case we have to do an additional // check if to see if the instance's wrapped object is still alive. If it isn't, then // we have to create a new wrapper. Minor: indentation is off. More principal: you would probably loose all the properties on the object (so named expando properties). That might be fine, but typically those should be preserved. // Sorry v8 cannot do fallback - no way to add accessors on the fly, when object exists... // v8 patch is coming for that, but ...not going to use it. That is not true anymore :) qt_pixmapruntimev8.cpp HTMLImageElement* imageElement = V8HTMLImageElement::toNative(v8::Handle<v8::Object>::Cast(object)); Apparently cast is not needed. v8::Handle<v8::Object> global = instance->context()->Global(); toV8(imageElement->document()); return v8::Undefined(); Probably just in work, but you never use global, and doing toV8 conversion which is not used later as well. Overall, might be prone to persistent handles leaks: nor m_context, nor m_v8Obj is cleaned. qt_runtimev8.cpp object = value->ToObject(); Probably the simple cast will do. I am a paranoid about performance, so feel free to ignore, but object->GetIdentityHash() might be pretty expensive. If you have pointers to Qt objects and those are never moved, it might be faster to use those pointers to check if object has been processed before. v8::Handle<v8::Value> v = thisObject->Get(args[1]->ToString()); That may throw, so you might consider using TryCatches around. v8::Handle<v8::Value> QtRuntimeConnectionMethod::lengthGetter(v8::Local<v8::String> propname, const v8::AccessorInfo& info) If it always returns 1, maybe it should be a plain property? 281622 13 vladbph 2010-09-20 10:08:23 -0700 Thank you very much for the review, you helped a lot! Qt guys decided to discontinue direct injection of QObjects into JS, so this code became obsolete :( BTW, your comments are for https://bugs.webkit.org/show_bug.cgi?id=45150 (In reply to comment #12) > Vlad, may I ask you to post patches as plain patches, not zipped sources? It's more convenient to review them, esp. with the tools Adam is working on these days. > > First round of comments: > > qt_instancev8.h: > > (stylistic issue, feel free to ignore): > > typedef enum { > MetaProperty, > DynamicProperty, > ChildObject > } QtFieldType; > > Why not enum QtFieldType etc.? It looks more C++-ish to me. > > static v8::Handle<v8::Value> GetProperty(v8::Local<v8::String> propname, const v8::AccessorInfo &info); > > I think WebKit code style requires method names to start with lower case. Ditto for SetProperty, SetAccessors. BTW, there are scripts under WebKitTools\Scripts which should have warn you about style violations. > > qt_instancev8.cpp: > > : m_context(v8::Persistent<v8::Context>::New(context)) > > Do you clear the handle somewhere? Please note that destructor won't clean it up. You should add explicit invocation of Dispose, probably followed by Clear to make it easier to catch errors. > > v8::Handle<v8::FunctionTemplate> v8ClassTempl = v8::Persistent<v8::FunctionTemplate>::New(v8::FunctionTemplate::New()); > > Persistent handles are heavyweight and should be avoided unless really needed. They should be used when you want to have a reference to the object out of HandleScope, for example maps from native objects to v8 wrappers. > > Apparently in your case you should just use HandleScope (unless it's already been created) and use local handles which are cheaper and has better (imho) semantics. > > > m_v8Obj->SetPointerInInternalField(QtInstanceIndexId, (void*)QtInstanceGeneric); > > That is somewhat tricky. I'd rather not trick and cast numbers to pointers, v8's ints might be a better choice here (unless it's really necessary from performance point of view). > > And even for performance, in your case you're lucky to have even number (0) and that would be stored rather efficiently, however if it'd been odd, performance would suffer and memory usage would be bigger. > > methodlPropTempl->SetAccessor( > v8::String::New("connect"), > fieldGetter, > fieldSetter, > v8::String::New("connect"), > v8::DEFAULT, > v8::DontDelete); > methodlPropTempl->SetAccessor( > v8::String::New("disconnect"), > fieldGetter, > fieldSetter, > v8::String::New("disconnect"), > v8::DEFAULT, > v8::DontDelete); > > > Indentation is apparently off (compare first argument to others). > > methodFunc->SetHiddenValue(v8::String::New("__qt_hidden_marker__"), v8::External::Wrap(this)); > > Just in case, hidden values are somewhat slow. > > QtInstance::CreateV8Object: > > you may want to refactor wrapping logic of creation connect/disconnect methods. > > void QtInstance::GcCallback(v8::Persistent<v8::Value> obj, void*) > { > v8::HandleScope scope; > obj.Dispose(); > } > > > As you don't create local handles here, you apparently don't need HandleScope. > > // The garbage collector removes instances, but it may happen that the wrapped > // QObject dies before the gc kicks in. To handle that case we have to do an additional > // check if to see if the instance's wrapped object is still alive. If it isn't, then > // we have to create a new wrapper. > > Minor: indentation is off. > > More principal: you would probably loose all the properties on the object (so named expando properties). That might be fine, but typically those should be preserved. > > > // Sorry v8 cannot do fallback - no way to add accessors on the fly, when object exists... > // v8 patch is coming for that, but ...not going to use it. > > > That is not true anymore :) > > qt_pixmapruntimev8.cpp > > HTMLImageElement* imageElement = V8HTMLImageElement::toNative(v8::Handle<v8::Object>::Cast(object)); > > Apparently cast is not needed. > > > v8::Handle<v8::Object> global = instance->context()->Global(); > > toV8(imageElement->document()); > return v8::Undefined(); > > Probably just in work, but you never use global, and doing toV8 conversion which is not used later as well. > > Overall, might be prone to persistent handles leaks: nor m_context, nor m_v8Obj is cleaned. > > qt_runtimev8.cpp > > object = value->ToObject(); > > Probably the simple cast will do. > > I am a paranoid about performance, so feel free to ignore, but > > object->GetIdentityHash() > > might be pretty expensive. If you have pointers to Qt objects and those are never moved, it might be faster to use those pointers to check if object has been processed before. > > v8::Handle<v8::Value> v = thisObject->Get(args[1]->ToString()); > > That may throw, so you might consider using TryCatches around. > > v8::Handle<v8::Value> QtRuntimeConnectionMethod::lengthGetter(v8::Local<v8::String> propname, const v8::AccessorInfo& info) > > If it always returns 1, maybe it should be a plain property? 281661 14 antonm 2010-09-20 10:52:59 -0700 (In reply to comment #13) > Thank you very much for the review, you helped a lot! Qt guys decided to discontinue direct injection of QObjects into JS, so this code became obsolete :( > BTW, your comments are for https://bugs.webkit.org/show_bug.cgi?id=45150 I am sorry. > > (In reply to comment #12) > > Vlad, may I ask you to post patches as plain patches, not zipped sources? It's more convenient to review them, esp. with the tools Adam is working on these days. > > > > First round of comments: > > > > qt_instancev8.h: > > > > (stylistic issue, feel free to ignore): > > > > typedef enum { > > MetaProperty, > > DynamicProperty, > > ChildObject > > } QtFieldType; > > > > Why not enum QtFieldType etc.? It looks more C++-ish to me. > > > > static v8::Handle<v8::Value> GetProperty(v8::Local<v8::String> propname, const v8::AccessorInfo &info); > > > > I think WebKit code style requires method names to start with lower case. Ditto for SetProperty, SetAccessors. BTW, there are scripts under WebKitTools\Scripts which should have warn you about style violations. > > > > qt_instancev8.cpp: > > > > : m_context(v8::Persistent<v8::Context>::New(context)) > > > > Do you clear the handle somewhere? Please note that destructor won't clean it up. You should add explicit invocation of Dispose, probably followed by Clear to make it easier to catch errors. > > > > v8::Handle<v8::FunctionTemplate> v8ClassTempl = v8::Persistent<v8::FunctionTemplate>::New(v8::FunctionTemplate::New()); > > > > Persistent handles are heavyweight and should be avoided unless really needed. They should be used when you want to have a reference to the object out of HandleScope, for example maps from native objects to v8 wrappers. > > > > Apparently in your case you should just use HandleScope (unless it's already been created) and use local handles which are cheaper and has better (imho) semantics. > > > > > > m_v8Obj->SetPointerInInternalField(QtInstanceIndexId, (void*)QtInstanceGeneric); > > > > That is somewhat tricky. I'd rather not trick and cast numbers to pointers, v8's ints might be a better choice here (unless it's really necessary from performance point of view). > > > > And even for performance, in your case you're lucky to have even number (0) and that would be stored rather efficiently, however if it'd been odd, performance would suffer and memory usage would be bigger. > > > > methodlPropTempl->SetAccessor( > > v8::String::New("connect"), > > fieldGetter, > > fieldSetter, > > v8::String::New("connect"), > > v8::DEFAULT, > > v8::DontDelete); > > methodlPropTempl->SetAccessor( > > v8::String::New("disconnect"), > > fieldGetter, > > fieldSetter, > > v8::String::New("disconnect"), > > v8::DEFAULT, > > v8::DontDelete); > > > > > > Indentation is apparently off (compare first argument to others). > > > > methodFunc->SetHiddenValue(v8::String::New("__qt_hidden_marker__"), v8::External::Wrap(this)); > > > > Just in case, hidden values are somewhat slow. > > > > QtInstance::CreateV8Object: > > > > you may want to refactor wrapping logic of creation connect/disconnect methods. > > > > void QtInstance::GcCallback(v8::Persistent<v8::Value> obj, void*) > > { > > v8::HandleScope scope; > > obj.Dispose(); > > } > > > > > > As you don't create local handles here, you apparently don't need HandleScope. > > > > // The garbage collector removes instances, but it may happen that the wrapped > > // QObject dies before the gc kicks in. To handle that case we have to do an additional > > // check if to see if the instance's wrapped object is still alive. If it isn't, then > > // we have to create a new wrapper. > > > > Minor: indentation is off. > > > > More principal: you would probably loose all the properties on the object (so named expando properties). That might be fine, but typically those should be preserved. > > > > > > // Sorry v8 cannot do fallback - no way to add accessors on the fly, when object exists... > > // v8 patch is coming for that, but ...not going to use it. > > > > > > That is not true anymore :) > > > > qt_pixmapruntimev8.cpp > > > > HTMLImageElement* imageElement = V8HTMLImageElement::toNative(v8::Handle<v8::Object>::Cast(object)); > > > > Apparently cast is not needed. > > > > > > v8::Handle<v8::Object> global = instance->context()->Global(); > > > > toV8(imageElement->document()); > > return v8::Undefined(); > > > > Probably just in work, but you never use global, and doing toV8 conversion which is not used later as well. > > > > Overall, might be prone to persistent handles leaks: nor m_context, nor m_v8Obj is cleaned. > > > > qt_runtimev8.cpp > > > > object = value->ToObject(); > > > > Probably the simple cast will do. > > > > I am a paranoid about performance, so feel free to ignore, but > > > > object->GetIdentityHash() > > > > might be pretty expensive. If you have pointers to Qt objects and those are never moved, it might be faster to use those pointers to check if object has been processed before. > > > > v8::Handle<v8::Value> v = thisObject->Get(args[1]->ToString()); > > > > That may throw, so you might consider using TryCatches around. > > > > v8::Handle<v8::Value> QtRuntimeConnectionMethod::lengthGetter(v8::Local<v8::String> propname, const v8::AccessorInfo& info) > > > > If it always returns 1, maybe it should be a plain property? 281747 15 vladbph 2010-09-20 12:33:21 -0700 Dont be:) What I meant was that the exposure is not happening via qt bridge code any longer, but through QtScript engine now. Thanks again. 66435 2010-09-02 17:15:42 -0700 2010-09-03 12:53:49 -0700 Use DateMath from WTF v8_datemath.patch text/plain 9821 vladbph SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZw0KPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIEphdmFTY3Jp cHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gNjY2OTIpDQorKysgSmF2YVNjcmlwdENvcmUvQ2hh bmdlTG9nCSh3b3JraW5nIGNvcHkpDQpAQCAtMSwzICsxLDIxIEBADQorMjAxMC0wOS0wMiAgVmxh ZCBCdXJsaWsgIDx2b2xvZGltaXIuYnVybGlrQG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIFY4IHBvcnQgZm9yIFFUIHBsYXRm b3JtOiBVc2UgRGF0ZU1hdGggZnJvbSBXVEYgCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD00NTE0MgorCisgICAgICAgIEFkZCBnZXREU1RPZmZzZXQsIGNh Y2hlZFVUQ09mZnNldCB0byBnbG9iYWwgb2JqZWN0IGFzIGhpZGRlbiBwcm9wZXJ0aWVzCisKKyAg ICAgICAgKiBNYWtlZmlsZToKKyAgICAgICAgKiB3dGYvRGF0ZU1hdGguY3BwOgorICAgICAgICAo V1RGOjpwYXJzZURhdGVGcm9tTnVsbFRlcm1pbmF0ZWRDaGFyYWN0ZXJzKToKKyAgICAgICAgKEpT Qzo6Vjg6OmdldERTVE9mZnNldCk6CisgICAgICAgICogd3RmL0RhdGVNYXRoLmg6CisgICAgICAg IChKU0M6OlY4OjpEU1RPZmZzZXRDYWNoZTo6RFNUT2Zmc2V0Q2FjaGUpOgorICAgICAgICAoSlND OjpWODo6RFNUT2Zmc2V0Q2FjaGU6OnJlc2V0KToKKyAgICAgICAgKEpTQzo6Vjg6OkdyZWdvcmlh bkRhdGVUaW1lOjpHcmVnb3JpYW5EYXRlVGltZSk6CisKIDIwMTAtMDktMDIgIEFkYW0gQmFydGgg IDxhYmFydGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4K SW5kZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9EYXRlTWF0aC5jcHANCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBK YXZhU2NyaXB0Q29yZS93dGYvRGF0ZU1hdGguY3BwCShyZXZpc2lvbiA2NjY5MikNCisrKyBKYXZh U2NyaXB0Q29yZS93dGYvRGF0ZU1hdGguY3BwCSh3b3JraW5nIGNvcHkpDQpAQCAtNzgyLDkgKzc4 Miw5IEBADQogCiAgICAgICAgICAgICBpbnQgc2duID0gKG8gPCAwKSA/IC0xIDogMTsKICAgICAg ICAgICAgIG8gPSBsYWJzKG8pOwotICAgICAgICAgICAgaWYgKCpkYXRlU3RyaW5nICE9ICc6Jykg eworICAgICAgICAgICAgaWYgKCpkYXRlU3RyaW5nICE9ICc6JykKICAgICAgICAgICAgICAgICBv ZmZzZXQgPSAoKG8gLyAxMDApICogNjAgKyAobyAlIDEwMCkpICogc2duOwotICAgICAgICAgICAg fSBlbHNlIHsgLy8gR01UKzA1OjAwCisgICAgICAgICAgICBlbHNlIHsgLy8gR01UKzA1OjAwCiAg ICAgICAgICAgICAgICAgbG9uZyBvMjsKICAgICAgICAgICAgICAgICBpZiAoIXBhcnNlTG9uZyhk YXRlU3RyaW5nLCAmbmV3UG9zU3RyLCAxMCwgJm8yKSkKICAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIE5hTjsKQEAgLTg1NiwxNyArODU2LDQwIEBADQogfQogfSAvLyBuYW1lc3BhY2UgV1RGCiAK KworI2lmICFQTEFURk9STShDSFJPTUlVTSkKKwogI2lmIFVTRShKU0MpCiBuYW1lc3BhY2UgSlND IHsKKyNlbHNlCituYW1lc3BhY2UgVjggeworI2VuZGlmCiAKKwogLy8gR2V0IHRoZSBEU1Qgb2Zm c2V0IGZvciB0aGUgdGltZSBwYXNzZWQgaW4uCiAvLwogLy8gTk9URTogVGhlIGltcGxlbWVudGF0 aW9uIHJlbGllcyBvbiB0aGUgZmFjdCB0aGF0IG5vIHRpbWUgem9uZXMgaGF2ZQogLy8gbW9yZSB0 aGFuIG9uZSBkYXlsaWdodCBzYXZpbmdzIG9mZnNldCBjaGFuZ2UgcGVyIG1vbnRoLgogLy8gSWYg dGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgd2l0aCBOYU4gaXQgcmV0dXJucyBOYU4uCisjaWYgVVNF KEpTQykKIHN0YXRpYyBkb3VibGUgZ2V0RFNUT2Zmc2V0KEV4ZWNTdGF0ZSogZXhlYywgZG91Ymxl IG1zLCBkb3VibGUgdXRjT2Zmc2V0KQogewogICAgIERTVE9mZnNldENhY2hlJiBjYWNoZSA9IGV4 ZWMtPmdsb2JhbERhdGEoKS5kc3RPZmZzZXRDYWNoZTsKKyNlbHNlCitzdGF0aWMgZG91YmxlIGdl dERTVE9mZnNldCh2ODo6SGFuZGxlPHY4OjpDb250ZXh0PiBleGVjLCBkb3VibGUgbXMsIGRvdWJs ZSB1dGNPZmZzZXQpCit7CisgICAgRFNUT2Zmc2V0Q2FjaGUqIGRzdGNhY2hlOworICAgIHY4OjpI YW5kbGU8djg6OlZhbHVlPiB2YWx1ZSA9IGV4ZWMtPkdsb2JhbCgpLT5HZXRIaWRkZW5WYWx1ZSh2 ODo6U3RyaW5nOjpOZXcoImdldERTVE9mZnNldCIpKTsKKyAgICBpZiAodmFsdWUuSXNFbXB0eSgp KSB7CisgICAgICAgIC8vIFRCRDpOZWVkIHRvIGRpc3Bvc2UgaXQgLi4uLgorICAgICAgICBkc3Rj YWNoZSA9IG5ldyBEU1RPZmZzZXRDYWNoZTsKKyAgICAgICAgZXhlYy0+R2xvYmFsKCktPlNldEhp ZGRlblZhbHVlKHY4OjpTdHJpbmc6Ok5ldygiZ2V0RFNUT2Zmc2V0IiksIHY4OjpFeHRlcm5hbDo6 V3JhcCgodm9pZCopZHN0Y2FjaGUpKTsKKyAgICB9IGVsc2UgeworICAgICAgICB2YWx1ZSA9IGV4 ZWMtPkdsb2JhbCgpLT5HZXRIaWRkZW5WYWx1ZSh2ODo6U3RyaW5nOjpOZXcoImdldERTVE9mZnNl dCIpKTsKKyAgICAgICAgZHN0Y2FjaGUgPSBzdGF0aWNfY2FzdDxEU1RPZmZzZXRDYWNoZSo+KHY4 OjpFeHRlcm5hbDo6VW53cmFwKHZhbHVlKSk7CisgICAgfQorICAgIERTVE9mZnNldENhY2hlJiBj YWNoZSA9ICpkc3RjYWNoZTsKKyNlbmRpZgogICAgIGRvdWJsZSBzdGFydCA9IGNhY2hlLnN0YXJ0 OwogICAgIGRvdWJsZSBlbmQgPSBjYWNoZS5lbmQ7CiAKQEAgLTg4NiwyNyArOTA5LDI2IEBADQog ICAgICAgICAgICAgICAgIGNhY2hlLmVuZCA9IG5ld0VuZDsKICAgICAgICAgICAgICAgICBjYWNo ZS5pbmNyZW1lbnQgPSBtc1Blck1vbnRoOwogICAgICAgICAgICAgICAgIHJldHVybiBlbmRPZmZz ZXQ7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBkb3VibGUgb2Zmc2V0ID0gY2FsY3VsYXRl RFNUT2Zmc2V0KG1zLCB1dGNPZmZzZXQpOworICAgICAgICAgICAgaWYgKG9mZnNldCA9PSBlbmRP ZmZzZXQpIHsKKyAgICAgICAgICAgICAgICAvLyBUaGUgb2Zmc2V0IGF0IHRoZSBnaXZlbiB0aW1l IGlzIGVxdWFsIHRvIHRoZSBvZmZzZXQgYXQgdGhlCisgICAgICAgICAgICAgICAgLy8gbmV3IGVu ZCBvZiB0aGUgaW50ZXJ2YWwsIHNvIHRoYXQgbWVhbnMgdGhhdCB3ZSd2ZSBqdXN0IHNraXBwZWQK KyAgICAgICAgICAgICAgICAvLyB0aGUgcG9pbnQgaW4gdGltZSB3aGVyZSB0aGUgRFNUIG9mZnNl dCBjaGFuZ2Ugb2NjdXJyZWQuIFVwZGF0ZWQKKyAgICAgICAgICAgICAgICAvLyB0aGUgaW50ZXJ2 YWwgdG8gcmVmbGVjdCB0aGlzIGFuZCByZXNldCB0aGUgaW5jcmVtZW50LgorICAgICAgICAgICAg ICAgIGNhY2hlLnN0YXJ0ID0gbXM7CisgICAgICAgICAgICAgICAgY2FjaGUuZW5kID0gbmV3RW5k OworICAgICAgICAgICAgICAgIGNhY2hlLmluY3JlbWVudCA9IG1zUGVyTW9udGg7CiAgICAgICAg ICAgICB9IGVsc2UgewotICAgICAgICAgICAgICAgIGRvdWJsZSBvZmZzZXQgPSBjYWxjdWxhdGVE U1RPZmZzZXQobXMsIHV0Y09mZnNldCk7Ci0gICAgICAgICAgICAgICAgaWYgKG9mZnNldCA9PSBl bmRPZmZzZXQpIHsKLSAgICAgICAgICAgICAgICAgICAgLy8gVGhlIG9mZnNldCBhdCB0aGUgZ2l2 ZW4gdGltZSBpcyBlcXVhbCB0byB0aGUgb2Zmc2V0IGF0IHRoZQotICAgICAgICAgICAgICAgICAg ICAvLyBuZXcgZW5kIG9mIHRoZSBpbnRlcnZhbCwgc28gdGhhdCBtZWFucyB0aGF0IHdlJ3ZlIGp1 c3Qgc2tpcHBlZAotICAgICAgICAgICAgICAgICAgICAvLyB0aGUgcG9pbnQgaW4gdGltZSB3aGVy ZSB0aGUgRFNUIG9mZnNldCBjaGFuZ2Ugb2NjdXJyZWQuIFVwZGF0ZWQKLSAgICAgICAgICAgICAg ICAgICAgLy8gdGhlIGludGVydmFsIHRvIHJlZmxlY3QgdGhpcyBhbmQgcmVzZXQgdGhlIGluY3Jl bWVudC4KLSAgICAgICAgICAgICAgICAgICAgY2FjaGUuc3RhcnQgPSBtczsKLSAgICAgICAgICAg ICAgICAgICAgY2FjaGUuZW5kID0gbmV3RW5kOwotICAgICAgICAgICAgICAgICAgICBjYWNoZS5p bmNyZW1lbnQgPSBtc1Blck1vbnRoOwotICAgICAgICAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAg ICAgICAgICAgICAgIC8vIFRoZSBpbnRlcnZhbCBjb250YWlucyBhIERTVCBvZmZzZXQgY2hhbmdl IGFuZCB0aGUgZ2l2ZW4gdGltZSBpcwotICAgICAgICAgICAgICAgICAgICAvLyBiZWZvcmUgaXQu IEFkanVzdCB0aGUgaW5jcmVtZW50IHRvIGF2b2lkIGEgbGluZWFyIHNlYXJjaCBmb3IKLSAgICAg ICAgICAgICAgICAgICAgLy8gdGhlIG9mZnNldCBjaGFuZ2UgcG9pbnQgYW5kIGNoYW5nZSB0aGUg ZW5kIG9mIHRoZSBpbnRlcnZhbC4KLSAgICAgICAgICAgICAgICAgICAgY2FjaGUuaW5jcmVtZW50 IC89IDM7Ci0gICAgICAgICAgICAgICAgICAgIGNhY2hlLmVuZCA9IG1zOwotICAgICAgICAgICAg ICAgIH0KLSAgICAgICAgICAgICAgICAvLyBVcGRhdGUgdGhlIG9mZnNldCBpbiB0aGUgY2FjaGUg YW5kIHJldHVybiBpdC4KLSAgICAgICAgICAgICAgICBjYWNoZS5vZmZzZXQgPSBvZmZzZXQ7Ci0g ICAgICAgICAgICAgICAgcmV0dXJuIG9mZnNldDsKKyAgICAgICAgICAgICAgICAvLyBUaGUgaW50 ZXJ2YWwgY29udGFpbnMgYSBEU1Qgb2Zmc2V0IGNoYW5nZSBhbmQgdGhlIGdpdmVuIHRpbWUgaXMK KyAgICAgICAgICAgICAgICAvLyBiZWZvcmUgaXQuIEFkanVzdCB0aGUgaW5jcmVtZW50IHRvIGF2 b2lkIGEgbGluZWFyIHNlYXJjaCBmb3IKKyAgICAgICAgICAgICAgICAvLyB0aGUgb2Zmc2V0IGNo YW5nZSBwb2ludCBhbmQgY2hhbmdlIHRoZSBlbmQgb2YgdGhlIGludGVydmFsLgorICAgICAgICAg ICAgICAgIGNhY2hlLmluY3JlbWVudCAvPSAzOworICAgICAgICAgICAgICAgIGNhY2hlLmVuZCA9 IG1zOwogICAgICAgICAgICAgfQorICAgICAgICAgICAgLy8gVXBkYXRlIHRoZSBvZmZzZXQgaW4g dGhlIGNhY2hlIGFuZCByZXR1cm4gaXQuCisgICAgICAgICAgICBjYWNoZS5vZmZzZXQgPSBvZmZz ZXQ7CisgICAgICAgICAgICByZXR1cm4gb2Zmc2V0OwogICAgICAgICB9CiAgICAgfQogCkBAIC05 MjUsNiArOTQ3LDcgQEANCiAgKiBHZXQgdGhlIGRpZmZlcmVuY2UgaW4gbWlsbGlzZWNvbmRzIGJl dHdlZW4gdGhpcyB0aW1lIHpvbmUgYW5kIFVUQyAoR01UKQogICogTk9UIGluY2x1ZGluZyBEU1Qu CiAgKi8KKyNpZiBVU0UoSlNDKQogZG91YmxlIGdldFVUQ09mZnNldChFeGVjU3RhdGUqIGV4ZWMp CiB7CiAgICAgZG91YmxlIHV0Y09mZnNldCA9IGV4ZWMtPmdsb2JhbERhdGEoKS5jYWNoZWRVVENP ZmZzZXQ7CkBAIC05MzMsOCArOTU2LDI3IEBADQogICAgIGV4ZWMtPmdsb2JhbERhdGEoKS5jYWNo ZWRVVENPZmZzZXQgPSBjYWxjdWxhdGVVVENPZmZzZXQoKTsKICAgICByZXR1cm4gZXhlYy0+Z2xv YmFsRGF0YSgpLmNhY2hlZFVUQ09mZnNldDsKIH0KKyNlbHNlCitkb3VibGUgZ2V0VVRDT2Zmc2V0 KHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGV4ZWMpCit7CisgICAgdjg6OkhhbmRsZTx2ODo6VmFs dWU+IHZhbHVlID0gZXhlYy0+R2xvYmFsKCktPkdldEhpZGRlblZhbHVlKHY4OjpTdHJpbmc6Ok5l dygiY2FjaGVkVVRDT2Zmc2V0IikpOworICAgIGRvdWJsZSogdXRjT2Zmc2V0OworICAgIGlmICh2 YWx1ZS5Jc0VtcHR5KCkpIHsKKyAgICAgICAgdXRjT2Zmc2V0ID0gKGRvdWJsZSAqKW5ldyBkb3Vi bGU7CisgICAgICAgICp1dGNPZmZzZXQgPSBjYWxjdWxhdGVVVENPZmZzZXQoKTsKKyAgICAgICAg ZXhlYy0+R2xvYmFsKCktPlNldEhpZGRlblZhbHVlKHY4OjpTdHJpbmc6Ok5ldygiY2FjaGVkVVRD T2Zmc2V0IiksIHY4OjpFeHRlcm5hbDo6V3JhcCh1dGNPZmZzZXQpKTsKKyAgICAgICAgcmV0dXJu ICp1dGNPZmZzZXQ7CisgICAgfQorICAgIHV0Y09mZnNldCA9IHN0YXRpY19jYXN0PGRvdWJsZSo+ KHY4OjpFeHRlcm5hbDo6VW53cmFwKHZhbHVlKSk7CisgICAgcmV0dXJuICp1dGNPZmZzZXQ7Cit9 CisjZW5kaWYKIAorI2lmIFVTRShKU0MpCiBkb3VibGUgZ3JlZ29yaWFuRGF0ZVRpbWVUb01TKEV4 ZWNTdGF0ZSogZXhlYywgY29uc3QgR3JlZ29yaWFuRGF0ZVRpbWUmIHQsIGRvdWJsZSBtaWxsaVNl Y29uZHMsIGJvb2wgaW5wdXRJc1VUQykKKyNlbHNlCitkb3VibGUgZ3JlZ29yaWFuRGF0ZVRpbWVU b01TKHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGV4ZWMsIGNvbnN0IEdyZWdvcmlhbkRhdGVUaW1l JiB0LCBkb3VibGUgbWlsbGlTZWNvbmRzLCBib29sIGlucHV0SXNVVEMpCisjZW5kaWYKIHsKICAg ICBkb3VibGUgZGF5ID0gZGF0ZVRvRGF5c0Zyb20xOTcwKHQueWVhciArIDE5MDAsIHQubW9udGgs IHQubW9udGhEYXkpOwogICAgIGRvdWJsZSBtcyA9IHRpbWVUb01TKHQuaG91ciwgdC5taW51dGUs IHQuc2Vjb25kLCBtaWxsaVNlY29uZHMpOwpAQCAtOTUwLDcgKzk5MiwxMSBAQA0KIH0KIAogLy8g aW5wdXQgaXMgVVRDCisjaWYgVVNFKEpTQykKIHZvaWQgbXNUb0dyZWdvcmlhbkRhdGVUaW1lKEV4 ZWNTdGF0ZSogZXhlYywgZG91YmxlIG1zLCBib29sIG91dHB1dElzVVRDLCBHcmVnb3JpYW5EYXRl VGltZSYgdG0pCisjZWxzZQordm9pZCBtc1RvR3JlZ29yaWFuRGF0ZVRpbWUodjg6OkhhbmRsZTx2 ODo6Q29udGV4dD4gZXhlYywgZG91YmxlIG1zLCBib29sIG91dHB1dElzVVRDLCBHcmVnb3JpYW5E YXRlVGltZSYgdG0pCisjZW5kaWYKIHsKICAgICBkb3VibGUgZHN0T2ZmID0gMC4wOwogICAgIGRv dWJsZSB1dGNPZmYgPSAwLjA7CkBAIC05NzMsMTAgKzEwMTksMTcgQEANCiAgICAgdG0udXRjT2Zm c2V0ID0gc3RhdGljX2Nhc3Q8bG9uZz4oKGRzdE9mZiArIHV0Y09mZikgLyBXVEY6Om1zUGVyU2Vj b25kKTsKICAgICB0bS50aW1lWm9uZSA9IE5VTEw7CiB9Ci0KKyNpZiBVU0UoSlNDKQogZG91Ymxl IHBhcnNlRGF0ZUZyb21OdWxsVGVybWluYXRlZENoYXJhY3RlcnMoRXhlY1N0YXRlKiBleGVjLCBj b25zdCBjaGFyKiBkYXRlU3RyaW5nKQorI2Vsc2UKK2RvdWJsZSBwYXJzZURhdGVGcm9tTnVsbFRl cm1pbmF0ZWRDaGFyYWN0ZXJzKHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGV4ZWMsIGNvbnN0IGNo YXIqIGRhdGVTdHJpbmcpCisjZW5kaWYKIHsKKyNpZiBVU0UoSlNDKQogICAgIEFTU0VSVChleGVj KTsKKyNlbHNlCisgICAgQVNTRVJUKCFleGVjLklzRW1wdHkoKSk7CisjZW5kaWYKICAgICBib29s IGhhdmVUWjsKICAgICBpbnQgb2Zmc2V0OwogICAgIGRvdWJsZSBtcyA9IFdURjo6cGFyc2VEYXRl RnJvbU51bGxUZXJtaW5hdGVkQ2hhcmFjdGVycyhkYXRlU3RyaW5nLCBoYXZlVFosIG9mZnNldCk7 CkBAIC05OTIsNSArMTA0NSw1IEBADQogICAgIHJldHVybiBtcyAtIChvZmZzZXQgKiBXVEY6Om1z UGVyTWludXRlKTsKIH0KIAotfSAvLyBuYW1lc3BhY2UgSlNDCi0jZW5kaWYgLy8gVVNFKEpTQykK K30gLy8gbmFtZXNwYWNlIEpTQy9WOAorI2VuZGlmIC8vICFQTEFURk9STShDSFJPTUlVTSkKSW5k ZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9EYXRlTWF0aC5oDQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gSmF2YVNj cmlwdENvcmUvd3RmL0RhdGVNYXRoLmgJKHJldmlzaW9uIDY2NjkyKQ0KKysrIEphdmFTY3JpcHRD b3JlL3d0Zi9EYXRlTWF0aC5oCSh3b3JraW5nIGNvcHkpDQpAQCAtNDksNiArNDksMTAgQEANCiAj aW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1VudXNlZFBhcmFtLmg+ CiAKKyNpZiAhVVNFKEpTQykgJiYgUExBVEZPUk0oUVQpCisjaW5jbHVkZSA8djguaD4KKyNlbmRp ZgorCiBuYW1lc3BhY2UgV1RGIHsKIHZvaWQgaW5pdGlhbGl6ZURhdGVzKCk7CiBpbnQgZXF1aXZh bGVudFllYXJGb3JEU1QoaW50IHllYXIpOwpAQCAtOTUsMTYgKzk5LDQ4IEBADQogdXNpbmcgV1RG Ojptc1RvWWVhcjsKIHVzaW5nIFdURjo6c2Vjb25kc1Blck1pbnV0ZTsKIAorCisjaWYgIVBMQVRG T1JNKENIUk9NSVVNKQogI2lmIFVTRShKU0MpCiBuYW1lc3BhY2UgSlNDIHsKKwogY2xhc3MgRXhl Y1N0YXRlOwogc3RydWN0IEdyZWdvcmlhbkRhdGVUaW1lOwotCiB2b2lkIG1zVG9HcmVnb3JpYW5E YXRlVGltZShFeGVjU3RhdGUqLCBkb3VibGUsIGJvb2wgb3V0cHV0SXNVVEMsIEdyZWdvcmlhbkRh dGVUaW1lJik7CiBkb3VibGUgZ3JlZ29yaWFuRGF0ZVRpbWVUb01TKEV4ZWNTdGF0ZSosIGNvbnN0 IEdyZWdvcmlhbkRhdGVUaW1lJiwgZG91YmxlLCBib29sIGlucHV0SXNVVEMpOwogZG91YmxlIGdl dFVUQ09mZnNldChFeGVjU3RhdGUqKTsKIGRvdWJsZSBwYXJzZURhdGVGcm9tTnVsbFRlcm1pbmF0 ZWRDaGFyYWN0ZXJzKEV4ZWNTdGF0ZSosIGNvbnN0IGNoYXIqIGRhdGVTdHJpbmcpOwogCisjZWxz ZQorbmFtZXNwYWNlIFY4IHsKKworc3RydWN0IEdyZWdvcmlhbkRhdGVUaW1lOwordm9pZCBtc1Rv R3JlZ29yaWFuRGF0ZVRpbWUodjg6OkhhbmRsZTx2ODo6Q29udGV4dD4gY29udGV4dCwgZG91Ymxl LCBib29sIG91dHB1dElzVVRDLCBHcmVnb3JpYW5EYXRlVGltZSYpOworZG91YmxlIGdyZWdvcmlh bkRhdGVUaW1lVG9NUyh2ODo6SGFuZGxlPHY4OjpDb250ZXh0PiBjb250ZXh0LCBjb25zdCBHcmVn b3JpYW5EYXRlVGltZSYsIGRvdWJsZSwgYm9vbCBpbnB1dElzVVRDKTsKK2RvdWJsZSBnZXRVVENP ZmZzZXQodjg6OkhhbmRsZTx2ODo6Q29udGV4dD4gY29udGV4dCk7Citkb3VibGUgcGFyc2VEYXRl RnJvbU51bGxUZXJtaW5hdGVkQ2hhcmFjdGVycyh2ODo6SGFuZGxlPHY4OjpDb250ZXh0PiBjb250 ZXh0LCBjb25zdCBjaGFyKiBkYXRlU3RyaW5nKTsKKworY2xhc3MgRFNUT2Zmc2V0Q2FjaGUgewor cHVibGljOgorICAgIERTVE9mZnNldENhY2hlKCkKKyAgICB7CisgICAgICAgIHJlc2V0KCk7Cisg ICAgfQorICAgIHZvaWQgcmVzZXQoKQorICAgIHsKKyAgICAgICAgb2Zmc2V0ID0gMC4wOworICAg ICAgICBzdGFydCA9IDAuMDsKKyAgICAgICAgZW5kID0gLTEuMDsKKyAgICAgICAgaW5jcmVtZW50 ID0gMC4wOworICAgIH0KKyAgICBkb3VibGUgb2Zmc2V0OworICAgIGRvdWJsZSBzdGFydDsKKyAg ICBkb3VibGUgZW5kOworICAgIGRvdWJsZSBpbmNyZW1lbnQ7Cit9OworI2VuZGlmCisKKwogLy8g SW50ZW50aW9uYWxseSBvdmVycmlkZGluZyB0aGUgZGVmYXVsdCB0bSBvZiB0aGUgc3lzdGVtLgog Ly8gVGhlIG1lbWJlcnMgb2YgdG0gZGlmZmVyIG9uIHZhcmlvdXMgb3BlcmF0aW5nIHN5c3RlbXMu CiBzdHJ1Y3QgR3JlZ29yaWFuRGF0ZVRpbWUgOiBOb25jb3B5YWJsZSB7CkBAIC0xMjcsOCArMTYz LDExIEBADQogICAgIHsKICAgICAgICAgZGVsZXRlIFtdIHRpbWVab25lOwogICAgIH0KLQorI2lm IFVTRShKU0MpCiAgICAgR3JlZ29yaWFuRGF0ZVRpbWUoRXhlY1N0YXRlKiBleGVjLCBjb25zdCB0 bSYgaW5UbSkKKyNlbHNlCisgICAgR3JlZ29yaWFuRGF0ZVRpbWUodjg6OkhhbmRsZTx2ODo6Q29u dGV4dD4gZXhlYywgY29uc3QgdG0mIGluVG0pCisjZW5kaWYKICAgICAgICAgOiBzZWNvbmQoaW5U bS50bV9zZWMpCiAgICAgICAgICwgbWludXRlKGluVG0udG1fbWluKQogICAgICAgICAsIGhvdXIo aW5UbS50bV9ob3VyKQpAQCAtMjE3LDcgKzI1Niw5IEBADQogewogICAgIHJldHVybiB0LnV0Y09m ZnNldDsKIH0KLX0gLy8gbmFtZXNwYWNlIEpTQwotI2VuZGlmIC8vIFVTRShKU0MpCiAKK30gLy8g bmFtZXNwYWNlIEpTQy9WOAorCisKICNlbmRpZiAvLyBEYXRlTWF0aF9oCisjZW5kaWYgLy8gIVBM QVRGT1JNKENIUk9NSVVNKQo= 66536 2010-09-03 12:53:49 -0700 2010-09-06 04:52:10 -0700 Updated according to comments v8_datemath.patch text/plain 9945 vladbph SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZw0KPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIEphdmFTY3Jp cHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gNjY3MzUpDQorKysgSmF2YVNjcmlwdENvcmUvQ2hh bmdlTG9nCSh3b3JraW5nIGNvcHkpDQpAQCAtMSwzICsxLDIxIEBADQorMjAxMC0wOS0wMyAgVmxh ZCBCdXJsaWsgIDx2b2xvZGltaXIuYnVybGlrQG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIFY4IHBvcnQgZm9yIFFUIHBsYXRm b3JtOiBVc2UgRGF0ZU1hdGggZnJvbSBXVEYKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTQ1MTQyCisKKyAgICAgICAgR3JlZ29yaWFuRGF0ZVRpbWUgQVBJ IGlzIHVzZWQgYnkgL2JyaWRnZS9xdC9xdF9ydW50aW1lLiBBZGQgZ2V0RFNUT2Zmc2V0LCBjYWNo ZWRVVENPZmZzZXQgCisgICAgICAgIHRvIGdsb2JhbCBvYmplY3QgYXMgaGlkZGVuIHByb3BlcnRp ZXMuCisKKyAgICAgICAgKiB3dGYvRGF0ZU1hdGguY3BwOgorICAgICAgICAoV1RGOjpwYXJzZURh dGVGcm9tTnVsbFRlcm1pbmF0ZWRDaGFyYWN0ZXJzKToKKyAgICAgICAgKEpTQzo6Vjg6OmdldERT VE9mZnNldCk6CisgICAgICAgICogd3RmL0RhdGVNYXRoLmg6CisgICAgICAgIChKU0M6OlY4OjpE U1RPZmZzZXRDYWNoZTo6RFNUT2Zmc2V0Q2FjaGUpOgorICAgICAgICAoSlNDOjpWODo6RFNUT2Zm c2V0Q2FjaGU6OnJlc2V0KToKKyAgICAgICAgKEpTQzo6Vjg6OkdyZWdvcmlhbkRhdGVUaW1lOjpH cmVnb3JpYW5EYXRlVGltZSk6CisKIDIwMTAtMDktMDMgIENzYWJhIE9zenRyb2dvbsOhYyAgPG9z c3lAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4KSW5k ZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9EYXRlTWF0aC5jcHANCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBKYXZh U2NyaXB0Q29yZS93dGYvRGF0ZU1hdGguY3BwCShyZXZpc2lvbiA2NjczNSkNCisrKyBKYXZhU2Ny aXB0Q29yZS93dGYvRGF0ZU1hdGguY3BwCSh3b3JraW5nIGNvcHkpDQpAQCAtNzgyLDkgKzc4Miw5 IEBADQogCiAgICAgICAgICAgICBpbnQgc2duID0gKG8gPCAwKSA/IC0xIDogMTsKICAgICAgICAg ICAgIG8gPSBsYWJzKG8pOwotICAgICAgICAgICAgaWYgKCpkYXRlU3RyaW5nICE9ICc6Jykgewor ICAgICAgICAgICAgaWYgKCpkYXRlU3RyaW5nICE9ICc6JykKICAgICAgICAgICAgICAgICBvZmZz ZXQgPSAoKG8gLyAxMDApICogNjAgKyAobyAlIDEwMCkpICogc2duOwotICAgICAgICAgICAgfSBl bHNlIHsgLy8gR01UKzA1OjAwCisgICAgICAgICAgICBlbHNlIHsgLy8gR01UKzA1OjAwCiAgICAg ICAgICAgICAgICAgbG9uZyBvMjsKICAgICAgICAgICAgICAgICBpZiAoIXBhcnNlTG9uZyhkYXRl U3RyaW5nLCAmbmV3UG9zU3RyLCAxMCwgJm8yKSkKICAgICAgICAgICAgICAgICAgICAgcmV0dXJu IE5hTjsKQEAgLTg1NiwxNyArODU2LDQwIEBADQogfQogfSAvLyBuYW1lc3BhY2UgV1RGCiAKKwor I2lmICFQTEFURk9STShDSFJPTUlVTSkKKwogI2lmIFVTRShKU0MpCiBuYW1lc3BhY2UgSlNDIHsK KyNlbGlmIFVTRShWOCkKK25hbWVzcGFjZSBWOCB7CisjZW5kaWYKIAorCiAvLyBHZXQgdGhlIERT VCBvZmZzZXQgZm9yIHRoZSB0aW1lIHBhc3NlZCBpbi4KIC8vCiAvLyBOT1RFOiBUaGUgaW1wbGVt ZW50YXRpb24gcmVsaWVzIG9uIHRoZSBmYWN0IHRoYXQgbm8gdGltZSB6b25lcyBoYXZlCiAvLyBt b3JlIHRoYW4gb25lIGRheWxpZ2h0IHNhdmluZ3Mgb2Zmc2V0IGNoYW5nZSBwZXIgbW9udGguCiAv LyBJZiB0aGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCB3aXRoIE5hTiBpdCByZXR1cm5zIE5hTi4KKyNp ZiBVU0UoSlNDKQogc3RhdGljIGRvdWJsZSBnZXREU1RPZmZzZXQoRXhlY1N0YXRlKiBleGVjLCBk b3VibGUgbXMsIGRvdWJsZSB1dGNPZmZzZXQpCiB7CiAgICAgRFNUT2Zmc2V0Q2FjaGUmIGNhY2hl ID0gZXhlYy0+Z2xvYmFsRGF0YSgpLmRzdE9mZnNldENhY2hlOworI2VsaWYgVVNFKFY4KQorc3Rh dGljIGRvdWJsZSBnZXREU1RPZmZzZXQodjg6OkhhbmRsZTx2ODo6Q29udGV4dD4gZXhlYywgZG91 YmxlIG1zLCBkb3VibGUgdXRjT2Zmc2V0KQoreworICAgIERTVE9mZnNldENhY2hlKiBkc3RjYWNo ZTsKKyAgICB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4gdmFsdWUgPSBleGVjLT5HbG9iYWwoKS0+R2V0 SGlkZGVuVmFsdWUodjg6OlN0cmluZzo6TmV3KCJnZXREU1RPZmZzZXQiKSk7CisgICAgaWYgKHZh bHVlLklzRW1wdHkoKSkgeworICAgICAgICAvLyBUQkQ6TmVlZCB0byBkaXNwb3NlIGl0IC4uLi4K KyAgICAgICAgZHN0Y2FjaGUgPSBuZXcgRFNUT2Zmc2V0Q2FjaGU7CisgICAgICAgIGV4ZWMtPkds b2JhbCgpLT5TZXRIaWRkZW5WYWx1ZSh2ODo6U3RyaW5nOjpOZXcoImdldERTVE9mZnNldCIpLCB2 ODo6RXh0ZXJuYWw6OldyYXAoKHZvaWQqKWRzdGNhY2hlKSk7CisgICAgfSBlbHNlIHsKKyAgICAg ICAgdmFsdWUgPSBleGVjLT5HbG9iYWwoKS0+R2V0SGlkZGVuVmFsdWUodjg6OlN0cmluZzo6TmV3 KCJnZXREU1RPZmZzZXQiKSk7CisgICAgICAgIGRzdGNhY2hlID0gc3RhdGljX2Nhc3Q8RFNUT2Zm c2V0Q2FjaGUqPih2ODo6RXh0ZXJuYWw6OlVud3JhcCh2YWx1ZSkpOworICAgIH0KKyAgICBEU1RP ZmZzZXRDYWNoZSYgY2FjaGUgPSAqZHN0Y2FjaGU7CisjZW5kaWYKICAgICBkb3VibGUgc3RhcnQg PSBjYWNoZS5zdGFydDsKICAgICBkb3VibGUgZW5kID0gY2FjaGUuZW5kOwogCkBAIC04ODYsMjcg KzkwOSwyNiBAQA0KICAgICAgICAgICAgICAgICBjYWNoZS5lbmQgPSBuZXdFbmQ7CiAgICAgICAg ICAgICAgICAgY2FjaGUuaW5jcmVtZW50ID0gbXNQZXJNb250aDsKICAgICAgICAgICAgICAgICBy ZXR1cm4gZW5kT2Zmc2V0OworICAgICAgICAgICAgfQorICAgICAgICAgICAgZG91YmxlIG9mZnNl dCA9IGNhbGN1bGF0ZURTVE9mZnNldChtcywgdXRjT2Zmc2V0KTsKKyAgICAgICAgICAgIGlmIChv ZmZzZXQgPT0gZW5kT2Zmc2V0KSB7CisgICAgICAgICAgICAgICAgLy8gVGhlIG9mZnNldCBhdCB0 aGUgZ2l2ZW4gdGltZSBpcyBlcXVhbCB0byB0aGUgb2Zmc2V0IGF0IHRoZQorICAgICAgICAgICAg ICAgIC8vIG5ldyBlbmQgb2YgdGhlIGludGVydmFsLCBzbyB0aGF0IG1lYW5zIHRoYXQgd2UndmUg anVzdCBza2lwcGVkCisgICAgICAgICAgICAgICAgLy8gdGhlIHBvaW50IGluIHRpbWUgd2hlcmUg dGhlIERTVCBvZmZzZXQgY2hhbmdlIG9jY3VycmVkLiBVcGRhdGVkCisgICAgICAgICAgICAgICAg Ly8gdGhlIGludGVydmFsIHRvIHJlZmxlY3QgdGhpcyBhbmQgcmVzZXQgdGhlIGluY3JlbWVudC4K KyAgICAgICAgICAgICAgICBjYWNoZS5zdGFydCA9IG1zOworICAgICAgICAgICAgICAgIGNhY2hl LmVuZCA9IG5ld0VuZDsKKyAgICAgICAgICAgICAgICBjYWNoZS5pbmNyZW1lbnQgPSBtc1Blck1v bnRoOwogICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAgICBkb3VibGUgb2Zmc2V0 ID0gY2FsY3VsYXRlRFNUT2Zmc2V0KG1zLCB1dGNPZmZzZXQpOwotICAgICAgICAgICAgICAgIGlm IChvZmZzZXQgPT0gZW5kT2Zmc2V0KSB7Ci0gICAgICAgICAgICAgICAgICAgIC8vIFRoZSBvZmZz ZXQgYXQgdGhlIGdpdmVuIHRpbWUgaXMgZXF1YWwgdG8gdGhlIG9mZnNldCBhdCB0aGUKLSAgICAg ICAgICAgICAgICAgICAgLy8gbmV3IGVuZCBvZiB0aGUgaW50ZXJ2YWwsIHNvIHRoYXQgbWVhbnMg dGhhdCB3ZSd2ZSBqdXN0IHNraXBwZWQKLSAgICAgICAgICAgICAgICAgICAgLy8gdGhlIHBvaW50 IGluIHRpbWUgd2hlcmUgdGhlIERTVCBvZmZzZXQgY2hhbmdlIG9jY3VycmVkLiBVcGRhdGVkCi0g ICAgICAgICAgICAgICAgICAgIC8vIHRoZSBpbnRlcnZhbCB0byByZWZsZWN0IHRoaXMgYW5kIHJl c2V0IHRoZSBpbmNyZW1lbnQuCi0gICAgICAgICAgICAgICAgICAgIGNhY2hlLnN0YXJ0ID0gbXM7 Ci0gICAgICAgICAgICAgICAgICAgIGNhY2hlLmVuZCA9IG5ld0VuZDsKLSAgICAgICAgICAgICAg ICAgICAgY2FjaGUuaW5jcmVtZW50ID0gbXNQZXJNb250aDsKLSAgICAgICAgICAgICAgICB9IGVs c2UgewotICAgICAgICAgICAgICAgICAgICAvLyBUaGUgaW50ZXJ2YWwgY29udGFpbnMgYSBEU1Qg b2Zmc2V0IGNoYW5nZSBhbmQgdGhlIGdpdmVuIHRpbWUgaXMKLSAgICAgICAgICAgICAgICAgICAg Ly8gYmVmb3JlIGl0LiBBZGp1c3QgdGhlIGluY3JlbWVudCB0byBhdm9pZCBhIGxpbmVhciBzZWFy Y2ggZm9yCi0gICAgICAgICAgICAgICAgICAgIC8vIHRoZSBvZmZzZXQgY2hhbmdlIHBvaW50IGFu ZCBjaGFuZ2UgdGhlIGVuZCBvZiB0aGUgaW50ZXJ2YWwuCi0gICAgICAgICAgICAgICAgICAgIGNh Y2hlLmluY3JlbWVudCAvPSAzOwotICAgICAgICAgICAgICAgICAgICBjYWNoZS5lbmQgPSBtczsK LSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgLy8gVXBkYXRlIHRoZSBvZmZzZXQg aW4gdGhlIGNhY2hlIGFuZCByZXR1cm4gaXQuCi0gICAgICAgICAgICAgICAgY2FjaGUub2Zmc2V0 ID0gb2Zmc2V0OwotICAgICAgICAgICAgICAgIHJldHVybiBvZmZzZXQ7CisgICAgICAgICAgICAg ICAgLy8gVGhlIGludGVydmFsIGNvbnRhaW5zIGEgRFNUIG9mZnNldCBjaGFuZ2UgYW5kIHRoZSBn aXZlbiB0aW1lIGlzCisgICAgICAgICAgICAgICAgLy8gYmVmb3JlIGl0LiBBZGp1c3QgdGhlIGlu Y3JlbWVudCB0byBhdm9pZCBhIGxpbmVhciBzZWFyY2ggZm9yCisgICAgICAgICAgICAgICAgLy8g dGhlIG9mZnNldCBjaGFuZ2UgcG9pbnQgYW5kIGNoYW5nZSB0aGUgZW5kIG9mIHRoZSBpbnRlcnZh bC4KKyAgICAgICAgICAgICAgICBjYWNoZS5pbmNyZW1lbnQgLz0gMzsKKyAgICAgICAgICAgICAg ICBjYWNoZS5lbmQgPSBtczsKICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIC8vIFVwZGF0ZSB0 aGUgb2Zmc2V0IGluIHRoZSBjYWNoZSBhbmQgcmV0dXJuIGl0LgorICAgICAgICAgICAgY2FjaGUu b2Zmc2V0ID0gb2Zmc2V0OworICAgICAgICAgICAgcmV0dXJuIG9mZnNldDsKICAgICAgICAgfQog ICAgIH0KIApAQCAtOTI1LDYgKzk0Nyw3IEBADQogICogR2V0IHRoZSBkaWZmZXJlbmNlIGluIG1p bGxpc2Vjb25kcyBiZXR3ZWVuIHRoaXMgdGltZSB6b25lIGFuZCBVVEMgKEdNVCkKICAqIE5PVCBp bmNsdWRpbmcgRFNULgogICovCisjaWYgVVNFKEpTQykKIGRvdWJsZSBnZXRVVENPZmZzZXQoRXhl Y1N0YXRlKiBleGVjKQogewogICAgIGRvdWJsZSB1dGNPZmZzZXQgPSBleGVjLT5nbG9iYWxEYXRh KCkuY2FjaGVkVVRDT2Zmc2V0OwpAQCAtOTMzLDggKzk1NiwyNyBAQA0KICAgICBleGVjLT5nbG9i YWxEYXRhKCkuY2FjaGVkVVRDT2Zmc2V0ID0gY2FsY3VsYXRlVVRDT2Zmc2V0KCk7CiAgICAgcmV0 dXJuIGV4ZWMtPmdsb2JhbERhdGEoKS5jYWNoZWRVVENPZmZzZXQ7CiB9CisjZWxpZiBVU0UoVjgp Citkb3VibGUgZ2V0VVRDT2Zmc2V0KHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGV4ZWMpCit7Cisg ICAgdjg6OkhhbmRsZTx2ODo6VmFsdWU+IHZhbHVlID0gZXhlYy0+R2xvYmFsKCktPkdldEhpZGRl blZhbHVlKHY4OjpTdHJpbmc6Ok5ldygiY2FjaGVkVVRDT2Zmc2V0IikpOworICAgIGRvdWJsZSog dXRjT2Zmc2V0OworICAgIGlmICh2YWx1ZS5Jc0VtcHR5KCkpIHsKKyAgICAgICAgdXRjT2Zmc2V0 ID0gKGRvdWJsZSAqKW5ldyBkb3VibGU7CisgICAgICAgICp1dGNPZmZzZXQgPSBjYWxjdWxhdGVV VENPZmZzZXQoKTsKKyAgICAgICAgZXhlYy0+R2xvYmFsKCktPlNldEhpZGRlblZhbHVlKHY4OjpT dHJpbmc6Ok5ldygiY2FjaGVkVVRDT2Zmc2V0IiksIHY4OjpFeHRlcm5hbDo6V3JhcCh1dGNPZmZz ZXQpKTsKKyAgICAgICAgcmV0dXJuICp1dGNPZmZzZXQ7CisgICAgfQorICAgIHV0Y09mZnNldCA9 IHN0YXRpY19jYXN0PGRvdWJsZSo+KHY4OjpFeHRlcm5hbDo6VW53cmFwKHZhbHVlKSk7CisgICAg cmV0dXJuICp1dGNPZmZzZXQ7Cit9CisjZW5kaWYKIAorI2lmIFVTRShKU0MpCiBkb3VibGUgZ3Jl Z29yaWFuRGF0ZVRpbWVUb01TKEV4ZWNTdGF0ZSogZXhlYywgY29uc3QgR3JlZ29yaWFuRGF0ZVRp bWUmIHQsIGRvdWJsZSBtaWxsaVNlY29uZHMsIGJvb2wgaW5wdXRJc1VUQykKKyNlbGlmIFVTRShW OCkKK2RvdWJsZSBncmVnb3JpYW5EYXRlVGltZVRvTVModjg6OkhhbmRsZTx2ODo6Q29udGV4dD4g ZXhlYywgY29uc3QgR3JlZ29yaWFuRGF0ZVRpbWUmIHQsIGRvdWJsZSBtaWxsaVNlY29uZHMsIGJv b2wgaW5wdXRJc1VUQykKKyNlbmRpZgogewogICAgIGRvdWJsZSBkYXkgPSBkYXRlVG9EYXlzRnJv bTE5NzAodC55ZWFyICsgMTkwMCwgdC5tb250aCwgdC5tb250aERheSk7CiAgICAgZG91YmxlIG1z ID0gdGltZVRvTVModC5ob3VyLCB0Lm1pbnV0ZSwgdC5zZWNvbmQsIG1pbGxpU2Vjb25kcyk7CkBA IC05NTAsNyArOTkyLDExIEBADQogfQogCiAvLyBpbnB1dCBpcyBVVEMKKyNpZiBVU0UoSlNDKQog dm9pZCBtc1RvR3JlZ29yaWFuRGF0ZVRpbWUoRXhlY1N0YXRlKiBleGVjLCBkb3VibGUgbXMsIGJv b2wgb3V0cHV0SXNVVEMsIEdyZWdvcmlhbkRhdGVUaW1lJiB0bSkKKyNlbGlmIFVTRShWOCkKK3Zv aWQgbXNUb0dyZWdvcmlhbkRhdGVUaW1lKHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGV4ZWMsIGRv dWJsZSBtcywgYm9vbCBvdXRwdXRJc1VUQywgR3JlZ29yaWFuRGF0ZVRpbWUmIHRtKQorI2VuZGlm CiB7CiAgICAgZG91YmxlIGRzdE9mZiA9IDAuMDsKICAgICBkb3VibGUgdXRjT2ZmID0gMC4wOwpA QCAtOTczLDEwICsxMDE5LDE3IEBADQogICAgIHRtLnV0Y09mZnNldCA9IHN0YXRpY19jYXN0PGxv bmc+KChkc3RPZmYgKyB1dGNPZmYpIC8gV1RGOjptc1BlclNlY29uZCk7CiAgICAgdG0udGltZVpv bmUgPSBOVUxMOwogfQotCisjaWYgVVNFKEpTQykKIGRvdWJsZSBwYXJzZURhdGVGcm9tTnVsbFRl cm1pbmF0ZWRDaGFyYWN0ZXJzKEV4ZWNTdGF0ZSogZXhlYywgY29uc3QgY2hhciogZGF0ZVN0cmlu ZykKKyNlbGlmIFVTRShWOCkKK2RvdWJsZSBwYXJzZURhdGVGcm9tTnVsbFRlcm1pbmF0ZWRDaGFy YWN0ZXJzKHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGV4ZWMsIGNvbnN0IGNoYXIqIGRhdGVTdHJp bmcpCisjZW5kaWYKIHsKKyNpZiBVU0UoSlNDKQogICAgIEFTU0VSVChleGVjKTsKKyNlbGlmIFVT RShWOCkKKyAgICBBU1NFUlQoIWV4ZWMuSXNFbXB0eSgpKTsKKyNlbmRpZgogICAgIGJvb2wgaGF2 ZVRaOwogICAgIGludCBvZmZzZXQ7CiAgICAgZG91YmxlIG1zID0gV1RGOjpwYXJzZURhdGVGcm9t TnVsbFRlcm1pbmF0ZWRDaGFyYWN0ZXJzKGRhdGVTdHJpbmcsIGhhdmVUWiwgb2Zmc2V0KTsKQEAg LTk5Miw1ICsxMDQ1LDUgQEANCiAgICAgcmV0dXJuIG1zIC0gKG9mZnNldCAqIFdURjo6bXNQZXJN aW51dGUpOwogfQogCi19IC8vIG5hbWVzcGFjZSBKU0MKLSNlbmRpZiAvLyBVU0UoSlNDKQorfSAv LyBuYW1lc3BhY2UgSlNDL1Y4CisjZW5kaWYgLy8gIVBMQVRGT1JNKENIUk9NSVVNKQpJbmRleDog SmF2YVNjcmlwdENvcmUvd3RmL0RhdGVNYXRoLmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBKYXZhU2NyaXB0 Q29yZS93dGYvRGF0ZU1hdGguaAkocmV2aXNpb24gNjY3MzUpDQorKysgSmF2YVNjcmlwdENvcmUv d3RmL0RhdGVNYXRoLmgJKHdvcmtpbmcgY29weSkNCkBAIC00OSw2ICs0OSwxMCBAQA0KICNpbmNs dWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvVW51c2VkUGFyYW0uaD4KIAor I2lmIFVTRShWOCkgJiYgUExBVEZPUk0oUVQpCisjaW5jbHVkZSA8djguaD4KKyNlbmRpZgorCiBu YW1lc3BhY2UgV1RGIHsKIHZvaWQgaW5pdGlhbGl6ZURhdGVzKCk7CiBpbnQgZXF1aXZhbGVudFll YXJGb3JEU1QoaW50IHllYXIpOwpAQCAtOTUsMTYgKzk5LDQ4IEBADQogdXNpbmcgV1RGOjptc1Rv WWVhcjsKIHVzaW5nIFdURjo6c2Vjb25kc1Blck1pbnV0ZTsKIAorCisjaWYgIVBMQVRGT1JNKENI Uk9NSVVNKQogI2lmIFVTRShKU0MpCiBuYW1lc3BhY2UgSlNDIHsKKwogY2xhc3MgRXhlY1N0YXRl Owogc3RydWN0IEdyZWdvcmlhbkRhdGVUaW1lOwotCiB2b2lkIG1zVG9HcmVnb3JpYW5EYXRlVGlt ZShFeGVjU3RhdGUqLCBkb3VibGUsIGJvb2wgb3V0cHV0SXNVVEMsIEdyZWdvcmlhbkRhdGVUaW1l Jik7CiBkb3VibGUgZ3JlZ29yaWFuRGF0ZVRpbWVUb01TKEV4ZWNTdGF0ZSosIGNvbnN0IEdyZWdv cmlhbkRhdGVUaW1lJiwgZG91YmxlLCBib29sIGlucHV0SXNVVEMpOwogZG91YmxlIGdldFVUQ09m ZnNldChFeGVjU3RhdGUqKTsKIGRvdWJsZSBwYXJzZURhdGVGcm9tTnVsbFRlcm1pbmF0ZWRDaGFy YWN0ZXJzKEV4ZWNTdGF0ZSosIGNvbnN0IGNoYXIqIGRhdGVTdHJpbmcpOwogCisjZWxpZiBVU0Uo VjgpCituYW1lc3BhY2UgVjggeworCitzdHJ1Y3QgR3JlZ29yaWFuRGF0ZVRpbWU7Cit2b2lkIG1z VG9HcmVnb3JpYW5EYXRlVGltZSh2ODo6SGFuZGxlPHY4OjpDb250ZXh0PiBjb250ZXh0LCBkb3Vi bGUsIGJvb2wgb3V0cHV0SXNVVEMsIEdyZWdvcmlhbkRhdGVUaW1lJik7Citkb3VibGUgZ3JlZ29y aWFuRGF0ZVRpbWVUb01TKHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGNvbnRleHQsIGNvbnN0IEdy ZWdvcmlhbkRhdGVUaW1lJiwgZG91YmxlLCBib29sIGlucHV0SXNVVEMpOworZG91YmxlIGdldFVU Q09mZnNldCh2ODo6SGFuZGxlPHY4OjpDb250ZXh0PiBjb250ZXh0KTsKK2RvdWJsZSBwYXJzZURh dGVGcm9tTnVsbFRlcm1pbmF0ZWRDaGFyYWN0ZXJzKHY4OjpIYW5kbGU8djg6OkNvbnRleHQ+IGNv bnRleHQsIGNvbnN0IGNoYXIqIGRhdGVTdHJpbmcpOworCitjbGFzcyBEU1RPZmZzZXRDYWNoZSB7 CitwdWJsaWM6CisgICAgRFNUT2Zmc2V0Q2FjaGUoKQorICAgIHsKKyAgICAgICAgcmVzZXQoKTsK KyAgICB9CisgICAgdm9pZCByZXNldCgpCisgICAgeworICAgICAgICBvZmZzZXQgPSAwLjA7Cisg ICAgICAgIHN0YXJ0ID0gMC4wOworICAgICAgICBlbmQgPSAtMS4wOworICAgICAgICBpbmNyZW1l bnQgPSAwLjA7CisgICAgfQorICAgIGRvdWJsZSBvZmZzZXQ7CisgICAgZG91YmxlIHN0YXJ0Owor ICAgIGRvdWJsZSBlbmQ7CisgICAgZG91YmxlIGluY3JlbWVudDsKK307CisjZW5kaWYKKworCiAv LyBJbnRlbnRpb25hbGx5IG92ZXJyaWRkaW5nIHRoZSBkZWZhdWx0IHRtIG9mIHRoZSBzeXN0ZW0u CiAvLyBUaGUgbWVtYmVycyBvZiB0bSBkaWZmZXIgb24gdmFyaW91cyBvcGVyYXRpbmcgc3lzdGVt cy4KIHN0cnVjdCBHcmVnb3JpYW5EYXRlVGltZSA6IE5vbmNvcHlhYmxlIHsKQEAgLTEyNyw4ICsx NjMsMTEgQEANCiAgICAgewogICAgICAgICBkZWxldGUgW10gdGltZVpvbmU7CiAgICAgfQotCisj aWYgVVNFKEpTQykKICAgICBHcmVnb3JpYW5EYXRlVGltZShFeGVjU3RhdGUqIGV4ZWMsIGNvbnN0 IHRtJiBpblRtKQorI2VsaWYgVVNFKFY4KQorICAgIEdyZWdvcmlhbkRhdGVUaW1lKHY4OjpIYW5k bGU8djg6OkNvbnRleHQ+IGV4ZWMsIGNvbnN0IHRtJiBpblRtKQorI2VuZGlmCiAgICAgICAgIDog c2Vjb25kKGluVG0udG1fc2VjKQogICAgICAgICAsIG1pbnV0ZShpblRtLnRtX21pbikKICAgICAg ICAgLCBob3VyKGluVG0udG1faG91cikKQEAgLTIxNyw3ICsyNTYsOSBAQA0KIHsKICAgICByZXR1 cm4gdC51dGNPZmZzZXQ7CiB9Ci19IC8vIG5hbWVzcGFjZSBKU0MKLSNlbmRpZiAvLyBVU0UoSlND KQogCit9IC8vIG5hbWVzcGFjZSBKU0MvVjgKKworCiAjZW5kaWYgLy8gRGF0ZU1hdGhfaAorI2Vu ZGlmIC8vICFQTEFURk9STShDSFJPTUlVTSkK