28019 2009-08-05 07:57:08 -0700 Single-threaded storage/database solution 2012-04-17 08:52:12 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Other Other RESOLVED WONTFIX P2 Normal --- 23154 0 yong.li.webkit yong.li.webkit dglazkov dumi eric joenotcharles jorlow laszlo.gombos manyoso mario.bensi michaeln staikos tonikitoo oldest_to_newest 137305 0 yong.li.webkit 2009-08-05 07:57:08 -0700 The patch works with those files in WebCore/storage/wince, and provide a single-thread Storage solution with timers. See bug 27657 137306 1 34135 yong.li.webkit 2009-08-05 08:10:14 -0700 Created attachment 34135 the patch This patch is actually a single-thread solution. Probably PLATFORM(WINCE) should be replaced with USE(XXXX_SINGLE_THREAD)? ENABLE(JSC_MULTIPLE_THREADS) seems not suitable here, because they are not JSC files. 137318 2 34135 staikos 2009-08-05 09:24:49 -0700 Comment on attachment 34135 the patch Should we use WINCE or a special USE(SINGLETHREADED_STORAGE)? 137319 3 yong.li.webkit 2009-08-05 09:26:25 -0700 (In reply to comment #2) > (From update of attachment 34135 [details]) > Should we use WINCE or a special USE(SINGLETHREADED_STORAGE)? That's my question, too :) See above 137320 4 yong.li.webkit 2009-08-05 09:28:51 -0700 (In reply to comment #2) > (From update of attachment 34135 [details]) > Should we use WINCE or a special USE(SINGLETHREADED_STORAGE)? WebCore/storage/wince has already been committed. If we change to USE(SINGLETHREADED_STORAGE), then we also should change WebCore/storage/wince to WebCore/storage/singlethreaded, and also change the file names. 137335 5 staikos 2009-08-05 10:29:25 -0700 (In reply to comment #4) > (In reply to comment #2) > > (From update of attachment 34135 [details] [details]) > > Should we use WINCE or a special USE(SINGLETHREADED_STORAGE)? > > WebCore/storage/wince has already been committed. > > If we change to USE(SINGLETHREADED_STORAGE), then we also should change > WebCore/storage/wince to WebCore/storage/singlethreaded, and also change the > file names. Well let's see if anyone else actually wants this feature, otherwise I see no reason to bother changing it just yet. 137664 6 34135 eric 2009-08-06 14:47:32 -0700 Comment on attachment 34135 the patch This seems like the wrong approach. Please engage some of the other Database hackers and get them to make positive comments on the bug first before proceeding. 137667 7 yong.li.webkit 2009-08-06 14:58:26 -0700 (In reply to comment #6) > (From update of attachment 34135 [details]) > This seems like the wrong approach. Please engage some of the other Database > hackers and get them to make positive comments on the bug first before > proceeding. Any more information about why it's wrong approach? 138649 8 34135 eric 2009-08-10 07:58:43 -0700 Comment on attachment 34135 the patch Well, I don't know what this change is doing from the ChangeLog. I assume you're trying to make it possible to run Database operations on the main thread? Redirecting to a platform-specific header is generally never the right approach: #if PLATFORM(WINCE) 35 36 #include "wince/DatabaseThreadWince.h" 37 38 #else The abstraction (whatever you're trying to do there) likely belongs at a different/higher level. It would be bad, for example if 5 ports all had redirects there. 138652 9 staikos 2009-08-10 08:06:43 -0700 (In reply to comment #8) > (From update of attachment 34135 [details]) > Well, I don't know what this change is doing from the ChangeLog. I assume > you're trying to make it possible to run Database operations on the main > thread? > > Redirecting to a platform-specific header is generally never the right > approach: > #if PLATFORM(WINCE) > 35 > 36 #include "wince/DatabaseThreadWince.h" > 37 > 38 #else > > The abstraction (whatever you're trying to do there) likely belongs at a > different/higher level. It would be bad, for example if 5 ports all had > redirects there. Your assumption is correct. We are of the understanding that few if any will actually want this. If it's desired by others, I agree it should be refactored. In KDE we had a policy that something doesn't become an API until at least 2 separate users of it exist, otherwise it's a special case. I think that's prudent for WebKit too. I don't see the reason to burden the main code until we have evidence that someone else wants to use it too. Quite honestly, it's a bit ugly to have a multithreaded and a singlethreaded version in the same place so I'd rather bury this ugly one away. 138654 10 yong.li.webkit 2009-08-10 08:11:32 -0700 (In reply to comment #8) > (From update of attachment 34135 [details]) > Well, I don't know what this change is doing from the ChangeLog. I assume > you're trying to make it possible to run Database operations on the main > thread? > > Redirecting to a platform-specific header is generally never the right > approach: > #if PLATFORM(WINCE) > 35 > 36 #include "wince/DatabaseThreadWince.h" > 37 > 38 #else > > The abstraction (whatever you're trying to do there) likely belongs at a > different/higher level. It would be bad, for example if 5 ports all had > redirects there. Platform-independent webkit code could always work with single-threaded application. But the storage/database implemenation broke that. It forces using multiple threads. But threading is expensive on some platforms or is unwanted by some products. Our patch is single-threaded solution. If other ports or products want use this solution, we can change the name from "Wince" to "SingleThreaded". 141175 11 laszlo.gombos 2009-08-18 13:00:15 -0700 (In reply to comment #10) > (In reply to comment #8) > > (From update of attachment 34135 [details] [details]) > > Well, I don't know what this change is doing from the ChangeLog. I assume > > you're trying to make it possible to run Database operations on the main > > thread? > > > > Redirecting to a platform-specific header is generally never the right > > approach: > > #if PLATFORM(WINCE) > > 35 > > 36 #include "wince/DatabaseThreadWince.h" > > 37 > > 38 #else > > > > The abstraction (whatever you're trying to do there) likely belongs at a > > different/higher level. It would be bad, for example if 5 ports all had > > redirects there. > > Platform-independent webkit code could always work with single-threaded > application. But the storage/database implemenation broke that. It forces using > multiple threads. But threading is expensive on some platforms or is unwanted > by some products. > > Our patch is single-threaded solution. If other ports or products want use this > solution, we can change the name from "Wince" to "SingleThreaded". QtWebKit has a build time flag called ENABLE_SINGLE_THREADED to turn off ENABLE_JSC_MULTIPLE_THREADS and WebCore features that create additional threads. I'm interested to make this feature available for QtWebKit (and maybe other ports) as well, not just to the WINCE port. See http://trac.webkit.org/changeset/44411. 141176 12 jorlow 2009-08-18 13:01:09 -0700 This is going to make things quite a bit uglier. Maybe (In reply to comment #9) > (In reply to comment #8) > > (From update of attachment 34135 [details] [details]) > > Well, I don't know what this change is doing from the ChangeLog. I assume > > you're trying to make it possible to run Database operations on the main > > thread? > > > > Redirecting to a platform-specific header is generally never the right > > approach: > > #if PLATFORM(WINCE) > > 35 > > 36 #include "wince/DatabaseThreadWince.h" > > 37 > > 38 #else > > > > The abstraction (whatever you're trying to do there) likely belongs at a > > different/higher level. It would be bad, for example if 5 ports all had > > redirects there. > > Your assumption is correct. We are of the understanding that few if any will > actually want this. If it's desired by others, I agree it should be > refactored. In KDE we had a policy that something doesn't become an API until > at least 2 separate users of it exist, otherwise it's a special case. I think > that's prudent for WebKit too. I don't see the reason to burden the main code > until we have evidence that someone else wants to use it too. Quite honestly, > it's a bit ugly to have a multithreaded and a singlethreaded version in the > same place so I'd rather bury this ugly one away. Adding ifdefs like this really uglies up the code and is not necessary. The abstraction layer is already there: it's StorageAreaSync. The class's API is as follows: void scheduleFinalSync(); void blockUntilImportComplete() const; void scheduleItemForSync(const String& key, const String& value); void scheduleClear(); blockUntilImportComplete could synchronously read in the data. scheduleItemForSync could immediately write an item out. scheduleClear could immediately clear the data. scheduleFinalSync could be a no-op. I believe you can easily/cleanly change things so the StorageSyncManager needn't be instantiated for your port. If you needed ideas on how, I could take a closer look. For WINCE, you could just not compile LocalStorageThread.cpp, LocalStorageTask.cpp, StorageAreaSync.cpp, and StorageAreaManager.cpp and instead provide your own versions (if any) of these files (which would be in a singleThread or wince directory). We use this trick all the time in Chromium (for example, with StorageNamespace.cpp). Let me know if you need any more specific advice, but please don't commit this patch as is. 141178 13 yong.li.webkit 2009-08-18 13:07:48 -0700 > Adding ifdefs like this really uglies up the code and is not necessary. The > abstraction layer is already there: it's StorageAreaSync. The class's API is > as follows: "single-threaded" is a little different from "sync". Our single-threaded solution is also "async". It performs one task every time when timer is fired. > > void scheduleFinalSync(); > void blockUntilImportComplete() const; > void scheduleItemForSync(const String& key, const String& value); > void scheduleClear(); > > blockUntilImportComplete could synchronously read in the data. > scheduleItemForSync could immediately write an item out. scheduleClear could > immediately clear the data. scheduleFinalSync could be a no-op. > > I believe you can easily/cleanly change things so the StorageSyncManager > needn't be instantiated for your port. If you needed ideas on how, I could > take a closer look. > > For WINCE, you could just not compile LocalStorageThread.cpp, > LocalStorageTask.cpp, StorageAreaSync.cpp, and StorageAreaManager.cpp and > instead provide your own versions (if any) of these files (which would be in a > singleThread or wince directory). We use this trick all the time in Chromium > (for example, with StorageNamespace.cpp). This is what we're doing right now. but when upstream multi-threaded solution changes, we have to change again. > > Let me know if you need any more specific advice, but please don't commit this > patch as is. 141182 14 yong.li.webkit 2009-08-18 13:13:08 -0700 > > Let me know if you need any more specific advice, but please don't commit this > patch as is. We could implement and maintain any file by our own. but the point is trying to share code with other ports without adding pains. Not saying we're going to commit it as it is. but I cannot see why a single-threaded solution shouldn't go in. 141189 15 34135 fishd 2009-08-18 13:26:43 -0700 Comment on attachment 34135 the patch r- based on comment #14 to get this out of the review queue. 141193 16 jorlow 2009-08-18 13:32:39 -0700 First of all, good point on being sync and single threaded being different. Got mixed up there. (In reply to comment #14) > > > > Let me know if you need any more specific advice, but please don't commit this > > patch as is. > > We could implement and maintain any file by our own. but the point is trying to > share code with other ports without adding pains. Not saying we're going to > commit it as it is. but I cannot see why a single-threaded solution shouldn't > go in. I think a single-threaded solution should go in, but not as a pile of #ifdefs. I'd be OK with having _one_ section of StorageAreaSync and and StorageSyncManager within #ifdef's, but I'm not a reviewer so I'm not sure if even that is typically acceptable. Here are some specific comments: > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index e597233..53be1d0 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,25 @@ > +2009-08-05 Yong Li <yong.li@torchmobile.com> > + > + Reviewed by NOBODY (OOPS!). > + > + Need a short description and bug URL (OOPS!) > + https://bugs.webkit.org/show_bug.cgi?id=28019 > + > + * storage/DatabaseThread.h: > + * storage/LocalStorageThread.h: > + * storage/StorageAreaSync.cpp: > + (WebCore::StorageAreaSync::StorageAreaSync): > + (WebCore::StorageAreaSync::performImport): > + (WebCore::StorageAreaSync::sync): > + (WebCore::StorageAreaSync::performSync): > + * storage/StorageAreaSync.h: > + (WebCore::StorageAreaSync::blockUntilImportComplete): > + (WebCore::StorageAreaSync::markImported): > + * storage/StorageSyncManager.cpp: > + (WebCore::StorageSyncManager::close): > + (WebCore::StorageSyncManager::scheduleImport): > + (WebCore::StorageSyncManager::scheduleSync): > + > 2009-07-21 Yong Li <yong.li@torchmobile.com> > > Reviewed by NOBODY (OOPS!). > diff --git a/WebCore/storage/DatabaseThread.h b/WebCore/storage/DatabaseThread.h > index 5aab5fd..c744b86 100644 > --- a/WebCore/storage/DatabaseThread.h > +++ b/WebCore/storage/DatabaseThread.h > @@ -1,5 +1,6 @@ > /* > * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. > + * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved. > * > * Redistribution and use in source and binary forms, with or without > * modification, are permitted provided that the following conditions > @@ -29,6 +30,13 @@ > #define DatabaseThread_h > > #if ENABLE(DATABASE) > + > +#if PLATFORM(WINCE) > + > +#include "wince/DatabaseThreadWince.h" > + > +#else > + > #include <wtf/Deque.h> > #include <wtf/HashMap.h> > #include <wtf/HashSet.h> > @@ -79,5 +87,7 @@ private: > > } // namespace WebCore > > +#endif // PLATFORM(WINCE) > + > #endif // ENABLE(DATABASE) > #endif // DatabaseThread_h > diff --git a/WebCore/storage/LocalStorageThread.h b/WebCore/storage/LocalStorageThread.h > index 3d58427..45178e8 100644 > --- a/WebCore/storage/LocalStorageThread.h > +++ b/WebCore/storage/LocalStorageThread.h > @@ -1,5 +1,6 @@ > /* > * Copyright (C) 2008 Apple Inc. All Rights Reserved. > + * Copyright (C) 2009 Torch Mobile, Inc. All Rights Reserved. > * > * Redistribution and use in source and binary forms, with or without > * modification, are permitted provided that the following conditions > @@ -28,6 +29,12 @@ > > #if ENABLE(DOM_STORAGE) > > +#if PLATFORM(WINCE) > + > +#include "wince/LocalStorageThreadWince.h" Is there anything in this file? Maybe the above #if should say ENABLE(DOM_STORAGE) && !PLATFORM(WINCE) ? Or maybe you can (with few or no ifdefs) eliminate any .h file dependencies on this? > + > +#else > + > #include <wtf/HashSet.h> > #include <wtf/MessageQueue.h> > #include <wtf/PassRefPtr.h> > @@ -71,6 +78,8 @@ namespace WebCore { > > } // namespace WebCore > > +#endif // PLATFORM(WINCE) > + > #endif // ENABLE(DOM_STORAGE) > > #endif // LocalStorageThread_h > diff --git a/WebCore/storage/StorageAreaSync.cpp b/WebCore/storage/StorageAreaSync.cpp > index 01d2a65..5182fd6 100644 > --- a/WebCore/storage/StorageAreaSync.cpp > +++ b/WebCore/storage/StorageAreaSync.cpp > @@ -55,8 +55,13 @@ StorageAreaSync::StorageAreaSync(PassRefPtr<StorageSyncManager> storageSyncManag > , m_syncManager(storageSyncManager) > , m_clearItemsWhileSyncing(false) > , m_syncScheduled(false) > +#if !PLATFORM(WINCE) > , m_importComplete(false) > +#endif > { > +#if PLATFORM(WINCE) > + performImport(); > +#else > ASSERT(m_storageArea); > ASSERT(m_syncManager); > > @@ -64,6 +69,7 @@ StorageAreaSync::StorageAreaSync(PassRefPtr<StorageSyncManager> storageSyncManag > // not silently ignoring it. https://bugs.webkit.org/show_bug.cgi?id=25894 > if (!m_syncManager->scheduleImport(this)) > m_importComplete = true; > +#endif Why not just implement your own syncManager and have it work as you'd like it to? > } > > StorageAreaSync::~StorageAreaSync() > @@ -160,7 +166,9 @@ void StorageAreaSync::syncTimerFired(Timer<StorageAreaSync>*) > > void StorageAreaSync::performImport() > { > +#if !PLATFORM(WINCE) > ASSERT(!isMainThread()); > +#endif > ASSERT(!m_database.isOpen()); > > String databaseFilename = m_syncManager->fullDatabaseFilename(m_storageArea->securityOrigin()); > @@ -204,7 +212,9 @@ void StorageAreaSync::performImport() > return; > } > > +#if !PLATFORM(WINCE) > MutexLocker locker(m_importLock); > +#endif > > HashMap<String, String>::iterator it = itemMap.begin(); > HashMap<String, String>::iterator end = itemMap.end(); > @@ -212,12 +222,15 @@ void StorageAreaSync::performImport() > for (; it != end; ++it) > m_storageArea->importItem(it->first, it->second); > > +#if !PLATFORM(WINCE) > // Break the (ref count) cycle. > m_storageArea = 0; > m_importComplete = true; > m_importCondition.signal(); > +#endif > } > > +#if !PLATFORM(WINCE) > void StorageAreaSync::markImported() > { > ASSERT(!isMainThread()); > @@ -250,10 +263,13 @@ void StorageAreaSync::blockUntilImportComplete() const > ASSERT(m_importComplete); > ASSERT(!m_storageArea); > } > +#endif > > void StorageAreaSync::sync(bool clearItems, const HashMap<String, String>& items) > { > +#if !PLATFORM(WINCE) > ASSERT(!isMainThread()); > +#endif > > if (!m_database.isOpen()) > return; > @@ -309,7 +325,9 @@ void StorageAreaSync::sync(bool clearItems, const HashMap<String, String>& items > > void StorageAreaSync::performSync() > { > +#if !PLATFORM(WINCE) > ASSERT(!isMainThread()); > +#endif How about making this a function somewhere. isBackgroundThread. This could be implemented either here or the StorageSyncManager. The implementation for single threaded could just return true. The normal implementation could be !isMainThread(); > > bool clearItems; > HashMap<String, String> items; > diff --git a/WebCore/storage/StorageAreaSync.h b/WebCore/storage/StorageAreaSync.h > index e436bef..fa64984 100644 > --- a/WebCore/storage/StorageAreaSync.h > +++ b/WebCore/storage/StorageAreaSync.h > @@ -46,7 +46,11 @@ namespace WebCore { > ~StorageAreaSync(); > > void scheduleFinalSync(); > +#if PLATFORM(WINCE) > + void blockUntilImportComplete() const {} > +#else > void blockUntilImportComplete() const; > +#endif There's no need to make this inline. > > void scheduleItemForSync(const String& key, const String& value); > void scheduleClear(); > @@ -83,10 +87,14 @@ namespace WebCore { > bool m_clearItemsWhileSyncing; > bool m_syncScheduled; > > +#if PLATFORM(WINCE) > + void markImported() {} > +#else > mutable Mutex m_importLock; > mutable ThreadCondition m_importCondition; > mutable bool m_importComplete; > void markImported(); > +#endif It's a nit, but I don't see why markImported should be inlined here. The mutex and condition could just be ifdef'ed off with no #else. > diff --git a/WebCore/storage/StorageSyncManager.cpp b/WebCore/storage/StorageSyncManager.cpp > index a935242..b90d180 100644 > --- a/WebCore/storage/StorageSyncManager.cpp > +++ b/WebCore/storage/StorageSyncManager.cpp > @@ -72,7 +72,9 @@ String StorageSyncManager::fullDatabaseFilename(SecurityOrigin* origin) > > void StorageSyncManager::close() > { > +#if !PLATFORM(WINCE) > ASSERT(isMainThread()); > +#endif Why are these necessary? Since there's only one thread, wouldn't it always be on the main thread? If it's absolutely necessary, it could be factored into a function like I mentioned above. 141198 17 yong.li.webkit 2009-08-18 13:41:18 -0700 (In reply to comment #16) > > Here are some specific comments: Reviewing is appreciated no matter you're reviewer or not. Thanks. > > Is there anything in this file? Maybe the above #if should say > ENABLE(DOM_STORAGE) && !PLATFORM(WINCE) ? Going to change this to ENABLE(SINGLE_THREADED) to make it help QtWebkit > Why not just implement your own syncManager and have it work as you'd like it > to? Create another SyncManager is a cleaner option. But the point is sharing as much code as possible. I'm afraid some reviewers would suggest I share the same file. > > How about making this a function somewhere. isBackgroundThread. This could be > implemented either here or the StorageSyncManager. > > The implementation for single threaded could just return true. The normal > implementation could be !isMainThread(); > > There's no need to make this inline. > > It's a nit, but I don't see why markImported should be inlined here. The mutex > and condition could just be ifdef'ed off with no #else. > > > Why are these necessary? Since there's only one thread, wouldn't it always be > on the main thread? > > If it's absolutely necessary, it could be factored into a function like I > mentioned above. good ideas. Thanks! 141203 18 jorlow 2009-08-18 13:47:15 -0700 (In reply to comment #17) > (In reply to comment #16) > > Why not just implement your own syncManager and have it work as you'd like it > > to? > > Create another SyncManager is a cleaner option. But the point is sharing as > much code as possible. I'm afraid some reviewers would suggest I share the same > file. What about this: """ // License #includes void some function { } void more functions { } #if !USE(SINGLE_THREAD) void multi-threaded function { } void more multi-threaded funcitons { } #endif """ And then implement these in another file within storage/single_thread/blah.cpp (or even in an #else statement below). The biggest thing I'm against here is spaghetti code. If it's between code copying and spaghetti code we should DEFINITELY pick the former. That said, I think 75% of the #ifdefs can be eliminated by a couple tiny refactorings. 141274 19 35081 yong.li.webkit 2009-08-18 15:10:57 -0700 Created attachment 35081 refactored 1. change storage/wince to storage/single-threaded 2. use ENABLE(SINGLE_THREADED) so that it can be used by QtWebkit 3. create a separate StorageSyncManager.cpp for single-threaded solution, leaving the old one not touched now, changes on existing files are only for headers. 141295 20 jorlow 2009-08-18 15:32:49 -0700 Looking better! Here's some comments: Ignoring all DB code. (Not sure, but it might be best if you broke it into its own patch/bug.) > diff --git a/WebCore/storage/LocalStorageThread.h b/WebCore/storage/LocalStorageThread.h > index 3d58427..176e279 100644 > --- a/WebCore/storage/LocalStorageThread.h > +++ b/WebCore/storage/LocalStorageThread.h > @@ -1,5 +1,6 @@ > /* > * Copyright (C) 2008 Apple Inc. All Rights Reserved. > + * Copyright (C) 2009 Torch Mobile, Inc. All Rights Reserved. My understanding is that copyright changes should only be made for substantial contributions to a file. (This applies to many of the other files below as well. > * > * Redistribution and use in source and binary forms, with or without > * modification, are permitted provided that the following conditions > @@ -28,6 +29,12 @@ > > #if ENABLE(DOM_STORAGE) > > +#if ENABLE(SINGLE_THREADED) > + > +#include "single-threaded/LocalStorageThread.h" > + > +#else Instead of this, please do what you did for StorageAreaSync.h. It's much cleaner, IMHO. Sharing .cpp code is nice, but I think sharing .h code is essential. > diff --git a/WebCore/storage/single-threaded/LocalStorageThread.cpp b/WebCore/storage/single-threaded/LocalStorageThread.cpp > new file mode 100644 > index 0000000..8dcb902 > --- /dev/null > +++ b/WebCore/storage/single-threaded/LocalStorageThread.cpp > @@ -0,0 +1,83 @@ > +/* > + * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved. There are still chunks of existing code in here, right? If so, you should probably add Apple's name back to the copyright. > diff --git a/WebCore/storage/single-threaded/StorageAreaSync.cpp b/WebCore/storage/single-threaded/StorageAreaSync.cpp > new file mode 100644 > index 0000000..ac21e7c > --- /dev/null > +++ b/WebCore/storage/single-threaded/StorageAreaSync.cpp There sure is a lot of copied code in here. Why not just put the functions that are completely different in here, #ifdef out the ones you define here in the main file...but do it in _one_ chunk (i.e. move them all to the end so you can do it with one ifdef), and factor out any little differences into their own functions? Also, if there are any files that you copy whole-sale, you probably need to svn cp them. I know you use git and git can't do this, but I think it's worth it to be able to see what's copied and what's not. 141308 21 yong.li.webkit 2009-08-18 16:25:42 -0700 > Instead of this, please do what you did for StorageAreaSync.h. It's much > cleaner, IMHO. Sharing .cpp code is nice, but I think sharing .h code is > essential. will think about it > > > diff --git a/WebCore/storage/single-threaded/LocalStorageThread.cpp b/WebCore/storage/single-threaded/LocalStorageThread.cpp > > new file mode 100644 > > index 0000000..8dcb902 > > --- /dev/null > > +++ b/WebCore/storage/single-threaded/LocalStorageThread.cpp > > @@ -0,0 +1,83 @@ > > +/* > > + * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved. > > There are still chunks of existing code in here, right? If so, you should > probably add Apple's name back to the copyright. Which chunk? > > > diff --git a/WebCore/storage/single-threaded/StorageAreaSync.cpp b/WebCore/storage/single-threaded/StorageAreaSync.cpp > > new file mode 100644 > > index 0000000..ac21e7c > > --- /dev/null > > +++ b/WebCore/storage/single-threaded/StorageAreaSync.cpp > > There sure is a lot of copied code in here. Apple's copyright is still remained in this file. Why not just put the functions > that are completely different in here, #ifdef out the ones you define here in > the main file...but do it in _one_ chunk (i.e. move them all to the end so you > can do it with one ifdef), and factor out any little differences into their own > functions? Don't how different multithreaded and single-threaded will be in the future. same consideration for header files... 141311 22 jorlow 2009-08-18 16:30:01 -0700 (In reply to comment #21) > > Instead of this, please do what you did for StorageAreaSync.h. It's much > > cleaner, IMHO. Sharing .cpp code is nice, but I think sharing .h code is > > essential. > > will think about it > > > > > > diff --git a/WebCore/storage/single-threaded/LocalStorageThread.cpp b/WebCore/storage/single-threaded/LocalStorageThread.cpp > > > new file mode 100644 > > > index 0000000..8dcb902 > > > --- /dev/null > > > +++ b/WebCore/storage/single-threaded/LocalStorageThread.cpp > > > @@ -0,0 +1,83 @@ > > > +/* > > > + * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved. > > > > There are still chunks of existing code in here, right? If so, you should > > probably add Apple's name back to the copyright. > > Which chunk? I didn't compare anything specifically, but some of it looked familiar. If not, ignore this comment. > > > > > > diff --git a/WebCore/storage/single-threaded/StorageAreaSync.cpp b/WebCore/storage/single-threaded/StorageAreaSync.cpp > > > new file mode 100644 > > > index 0000000..ac21e7c > > > --- /dev/null > > > +++ b/WebCore/storage/single-threaded/StorageAreaSync.cpp > > > > There sure is a lot of copied code in here. > > Apple's copyright is still remained in this file. My point was that we can minimize the copied code (not that there were copyright issues). > > Why not just put the functions > > that are completely different in here, #ifdef out the ones you define here in > > the main file...but do it in _one_ chunk (i.e. move them all to the end so you > > can do it with one ifdef), and factor out any little differences into their own > > functions? > > Don't how different multithreaded and single-threaded will be in the future. > same consideration for header files... I don't understand this comment. If you're saying that things might diverge more in the future, so you wanted to just split them now, then I'd say that you should code for the way things are now and let future patch authors split it if necessary. 141470 23 35120 yong.li.webkit 2009-08-19 07:41:14 -0700 Created attachment 35120 more refactoring 1. remove headers for single-threaded, instead, directly modify on the existing headers 2. single-threaded StorageAreaSync.cpp only contains those functions that are very different with multi-threaded StorageAreaSync.cpp 141865 24 yong.li.webkit 2009-08-21 06:56:59 -0700 > This could queue up another task right? Is it ever possible it could go first? No, it's FIFO >Even if not now, maybe you should remove the item before running the task to >avoid regressions in the future? ok. >I think you can ASSERT_NOT_REACHED() here since terminate is what normally >calls this, IIRC. I see this in LocalStorageTask::performTask() case TerminateThread: m_thread->performTerminate(); break; >I'm fine with you factoring out the initialization done in StorageAreaSync's >constructor into another function so that you only need to redefine that. The >only price you'd pay is that m_importComplete would be there again and you >don't use it...but it's only one bool. I'm worried that you're going to break >a lot as people add/remove items from this constructor. >This is a nasty function to fork in order to get rid of only one mutex. I >can't think of any clean way to do it without forking or an #ifdef, though. >If you want to switch it back to an ifdef, I guess it might be better. Your >choice. sigh. k. I'll try to make a new patch. >This is wrong. It should simply explain that the import is done upon >initialization, so this function is a no-op. >On the other hand, maybe you should just do initialization lazily upon the >first call to this? good point. 141866 25 yong.li.webkit 2009-08-21 07:11:06 -0700 > >On the other hand, maybe you should just do initialization lazily upon the > >first call to this? > > good point. Hm... I just found that if I do lazy initialization, blockUntilImportComplete() will be broken. That's why I have to performImport in the constructor. 141870 26 38369 yong.li.webkit 2009-08-21 07:51:51 -0700 Created attachment 38369 more cleanup share more code of multi-threaded solution 141871 27 38370 yong.li.webkit 2009-08-21 07:59:01 -0700 Created attachment 38370 fix a problem in last patch oops, need to add "const" to ImportMutexLocker input 141872 28 38371 yong.li.webkit 2009-08-21 08:02:32 -0700 Created attachment 38371 more refactoring sorry for uploading too frequently. hope this can be the last one 141873 29 38372 yong.li.webkit 2009-08-21 08:16:09 -0700 Created attachment 38372 onImported => didImport 141958 30 jorlow 2009-08-21 13:34:01 -0700 Almost there (as far as I can tell). Only one major issue. I took a quick look at the DB code as well and it looked good, but I'm not an expert in that area. > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index a2a5dec..211f92a 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,36 @@ > +2009-08-21 Yong Li <yong.li@torchmobile.com> > + > + Reviewed by NOBODY (OOPS!). > + > + Single-threaded Storage/Dababase solution > + This patch also replaces storage/wince > + with storage/single-threaded More detail would be nice. Especially about the single-threaded implementation. > diff --git a/WebCore/storage/StorageAreaSync.cpp b/WebCore/storage/StorageAreaSync.cpp > index 01d2a65..680c1a0 100644 > --- a/WebCore/storage/StorageAreaSync.cpp > +++ b/WebCore/storage/StorageAreaSync.cpp > @@ -332,6 +305,47 @@ void StorageAreaSync::performSync() > enableSuddenTermination(); > } > > +#if !ENABLE(SINGLE_THREADED) > + > +// FIXME: In the future, we should allow use of StorageAreas while it's importing (when safe to do so). > +// Blocking everything until the import is complete is by far the simplest and safest thing to do, but > +// there is certainly room for safe optimization: Key/length will never be able to make use of such an > +// optimization (since the order of iteration can change as items are being added). Get can return any > +// item currently in the map. Get/remove can work whether or not it's in the map, but we'll need a list > +// of items the import should not overwrite. Clear can also work, but it'll need to kill the import > +// job first. > +void StorageAreaSync::blockUntilImportComplete() const > +{ > + ASSERT(isMainThread()); > + > + // Fast path to avoid locking. > + if (m_importComplete) > + return; > + > + MutexLocker locker(m_importLock); > + while (!m_importComplete) > + m_importCondition.wait(m_importLock); > + ASSERT(m_importComplete); > + ASSERT(!m_storageArea); > +} > + > +void StorageAreaSync::scheduleImport() > +{ > + m_importComplete = false; > + // FIXME: If it can't import, then the default WebKit behavior should be that of private browsing, > + // not silently ignoring it. https://bugs.webkit.org/show_bug.cgi?id=25894 > + if (!m_syncManager->scheduleImport(this)) > + m_importComplete = true; > +} > + > +void StorageAreaSync::didImport() > +{ > + m_importComplete = true; > + m_importCondition.signal(); Why not move the setting m_storageArea (and its comment) here too? There should be a comment somewhere that this function needs to happen under a lock. It's not obvious to me the difference between "markImported" and "didImport". I can't think of much better, so maybe a 1 line comment above them to the effect of "// Must be called under the m_importLock. Otherwise, call markImported" and "// If you already hold the m_importLock, use didImport". I'm also not wild about the name. Maybe importComplete? I guess I kind of am bike-shedding, though. And yes, all of this is a nit...but I think it's worth cleaning up. > +} > + > +#endif > + > } // namespace WebCore > > #endif // ENABLE(DOM_STORAGE) > diff --git a/WebCore/storage/StorageAreaSync.h b/WebCore/storage/StorageAreaSync.h > index e436bef..94ce59d 100644 > --- a/WebCore/storage/StorageAreaSync.h > +++ b/WebCore/storage/StorageAreaSync.h > @@ -1,5 +1,6 @@ > /* > * Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved. > + * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved. > * > * Redistribution and use in source and binary forms, with or without > * modification, are permitted provided that the following conditions > @@ -78,15 +79,41 @@ namespace WebCore { > void syncTimerFired(Timer<StorageAreaSync>*); > void sync(bool clearItems, const HashMap<String, String>& items); > > - Mutex m_syncLock; > HashMap<String, String> m_itemsPendingSync; > bool m_clearItemsWhileSyncing; > bool m_syncScheduled; > > + void markImported(); > + void scheduleImport(); > + void didImport(); > + > +#if ENABLE(SINGLE_THREADED) > + bool isBackgroundThread() const { return true; } > + struct SyncMutexLocker > + { > + SyncMutexLocker(void*) {} > + }; > + struct ImportMutexLocker > + { > + ImportMutexLocker(const void*) {} > + }; > +#else > + Mutex m_syncLock; > + mutable bool m_importComplete; > mutable Mutex m_importLock; > mutable ThreadCondition m_importCondition; > - mutable bool m_importComplete; > - void markImported(); > + bool isBackgroundThread() const { return !isMainThread(); } > + friend class SyncMutexLocker; > + friend class ImportMutexLocker; > + struct SyncMutexLocker: private MutextLocker > + { > + SyncMutexLocker(StorageAreaSync* storageAreaSync) : MutextLocker(storageAreaSync->m_syncLock) {} > + }; > + struct ImportMutexLocker: private MutextLocker > + { > + ImportMutexLocker(const StorageAreaSync* storageAreaSync) : MutextLocker(storageAreaSync->m_importLock) {} > + }; I'm sorry, but this feels really ugly to me. Why not create a dummy Mutex class (where locks and unlocks are inline no-ops)? Maybe stick it in the WTF? Then all the code is identical, and the only difference is when you define the m_syncLock here. Any halfway sane compiler will inline the no-op and thus it'll be 0 perf penalty. > +#endif > }; > > } // namespace WebCore > diff --git a/WebCore/storage/single-threaded/LocalStorageThread.cpp b/WebCore/storage/single-threaded/LocalStorageThread.cpp > new file mode 100644 > index 0000000..bc6f2ab > --- /dev/null > +++ b/WebCore/storage/single-threaded/LocalStorageThread.cpp > @@ -0,0 +1,90 @@ > +/* > + * Copyright (C) 2009 Torch Mobile, 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. > + * > + * This library is distributed in the hope that i will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Library General Public License for more details. > + * > + * You should have received a copy of the GNU Library General Public License > + * along with this library; see the file COPYING.LIB. If not, write to > + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, > + * Boston, MA 02110-1301, USA. > + */ > + > +#include "config.h" > +#include "LocalStorageThread.h" > + > +#if ENABLE(DOM_STORAGE) > +#if ENABLE(SINGLE_THREADED) > + > +#include "LocalStorageTask.h" > +#include "StorageAreaSync.h" > + > +namespace WebCore { > + > +PassRefPtr<LocalStorageThread> LocalStorageThread::create() > +{ > + return adoptRef(new LocalStorageThread); > +} > + > +LocalStorageThread::LocalStorageThread() > +: m_timer(this, &LocalStorageThread::timerFired) > +{ > +} > + > +bool LocalStorageThread::start() > +{ > + return true; > +} > + > +void LocalStorageThread::timerFired(Timer<LocalStorageThread>*) > +{ > + if (m_queue.isEmpty()) > + return; > + > + RefPtr<LocalStorageTask> task = m_queue.first(); > + m_queue.removeFirst(); > + task->performTask(); > + if (!m_queue.isEmpty()) > + m_timer.startOneShot(0); > +} > + > +void LocalStorageThread::scheduleImport(PassRefPtr<StorageAreaSync> area) > +{ > + m_queue.append(LocalStorageTask::createImport(area)); > + if (!m_timer.isActive()) > + m_timer.startOneShot(0); > +} > + > +void LocalStorageThread::scheduleSync(PassRefPtr<StorageAreaSync> area) > +{ > + m_queue.append(LocalStorageTask::createSync(area)); > + if (!m_timer.isActive()) > + m_timer.startOneShot(0); > +} > + > +void LocalStorageThread::terminate() > +{ > + m_queue.clear(); > + m_timer.stop(); > +} > + > +void LocalStorageThread::performTerminate() > +{ > + m_queue.clear(); > + m_timer.stop(); I said: >I think you can ASSERT_NOT_REACHED() here since terminate is what normally >calls this, IIRC. You said: >I see this in LocalStorageTask::performTask() > case TerminateThread: > m_thread->performTerminate(); > break; I'm pretty sure this task is only ever created by the terminate() call above...which, in your version of this class does NOT schedule such a task. So I think the assert shoudl go in. > +} > + > +} > +#endif // ENABLE(SINGLE_THREADED) > +#endif // ENABLE(DOM_STORAGE) > diff --git a/WebCore/storage/single-threaded/StorageAreaSync.cpp b/WebCore/storage/single-threaded/StorageAreaSync.cpp > new file mode 100644 > index 0000000..6a224f9 > --- /dev/null > +++ b/WebCore/storage/single-threaded/StorageAreaSync.cpp > @@ -0,0 +1,51 @@ > +/* > + * Copyright (C) 2009 Torch Mobile, 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. > + * > + * This library is distributed in the hope that i will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Library General Public License for more details. > + * > + * You should have received a copy of the GNU Library General Public License > + * along with this library; see the file COPYING.LIB. If not, write to > + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, > + * Boston, MA 02110-1301, USA. > + */ > + > +#include "config.h" > +#include "StorageAreaSync.h" > + > +#if ENABLE(DOM_STORAGE) > +#if ENABLE(SINGLE_THREADED) > + > +namespace WebCore { > + > +void StorageAreaSync::scheduleImport() > +{ > + // Do a blocking import because we cannot "blockUntilImportComplete" with one thread nit: Maybe end these sentences with periods? > + performImport(); > +} > + > +void StorageAreaSync::didImport() > +{ > +} > + > +void StorageAreaSync::blockUntilImportComplete() const > +{ > + // We have already imported in scheduleImport() > +} > + > +} // namespace WebCore > + > +#endif // ENABLE(SINGLE_THREADED) > +#endif // ENABLE(DOM_STORAGE) > + 141960 31 yong.li.webkit 2009-08-21 13:48:59 -0700 (In reply to comment #30) > > Why not move the setting m_storageArea (and its comment) here too? > thought about that too. > It's not obvious to me the difference between "markImported" and "didImport". > I can't think of much better, so maybe a 1 line comment above them to the > effect of "// Must be called under the m_importLock. Otherwise, call > markImported" and "// If you already hold the m_importLock, use didImport". > > I'm also not wild about the name. Maybe importComplete? I guess I kind of am > bike-shedding, though. > > And yes, all of this is a nit...but I think it's worth cleaning up. > solution: markImportedWithoutLockingMutex() > I'm sorry, but this feels really ugly to me. > > Why not create a dummy Mutex class (where locks and unlocks are inline no-ops)? > Maybe stick it in the WTF? Then all the code is identical, and the only > difference is when you define the m_syncLock here. Any halfway sane compiler > will inline the no-op and thus it'll be 0 perf penalty. good idea. > > I said: > >I think you can ASSERT_NOT_REACHED() here since terminate is what normally > >calls this, IIRC. > > You said: > >I see this in LocalStorageTask::performTask() > > case TerminateThread: > > m_thread->performTerminate(); > > break; > > I'm pretty sure this task is only ever created by the terminate() call > above...which, in your version of this class does NOT schedule such a task. So > I think the assert shoudl go in. you're right 141963 32 jorlow 2009-08-21 13:53:32 -0700 (In reply to comment #31) > (In reply to comment #30) > > > > > Why not move the setting m_storageArea (and its comment) here too? > > > thought about that too. Oops, I thought I removed that comment. I'm fine with it either way, but if you do change it, be sure to add it to the single-threaded version of the function as well. > > > It's not obvious to me the difference between "markImported" and "didImport". > > I can't think of much better, so maybe a 1 line comment above them to the > > effect of "// Must be called under the m_importLock. Otherwise, call > > markImported" and "// If you already hold the m_importLock, use didImport". > > > > I'm also not wild about the name. Maybe importComplete? I guess I kind of am > > bike-shedding, though. > > > > And yes, all of this is a nit...but I think it's worth cleaning up. > > > > solution: markImportedWithoutLockingMutex() Duh...yeah, that is the webkit way. My bad. 141968 33 38393 yong.li.webkit 2009-08-21 14:08:20 -0700 Created attachment 38393 more refactoring less modification in StorageAreaSync.cpp 141973 34 38393 yong.li.webkit 2009-08-21 14:14:28 -0700 Comment on attachment 38393 more refactoring oops. found a bug 141976 35 38396 yong.li.webkit 2009-08-21 14:21:48 -0700 Created attachment 38396 fixed is it perfect now? also removed "mutable" for m_importCompleted, because that's not necessary even in old code. 142020 36 jorlow 2009-08-21 15:22:52 -0700 LGTM > diff --git a/WebCore/storage/StorageAreaSync.h b/WebCore/storage/StorageAreaSync.h > index e436bef..c167864 100644 > --- a/WebCore/storage/StorageAreaSync.h > +++ b/WebCore/storage/StorageAreaSync.h > @@ -1,5 +1,6 @@ > /* > * Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved. > + * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved. > * > * Redistribution and use in source and binary forms, with or without > * modification, are permitted provided that the following conditions > @@ -78,15 +79,31 @@ namespace WebCore { > void syncTimerFired(Timer<StorageAreaSync>*); > void sync(bool clearItems, const HashMap<String, String>& items); > > - Mutex m_syncLock; > HashMap<String, String> m_itemsPendingSync; > bool m_clearItemsWhileSyncing; > bool m_syncScheduled; > > + void scheduleImport(); > + void markImported(); > + void markImportedWithoutLockingMutex(); > + > +#if ENABLE(SINGLE_THREADED) > + bool isBackgroundThread() const { return true; } > + // Hack WTF::MutexLocker and just do nothing > + enum DummyMutex { > + m_syncLock, > + m_importLock, > + }; > + struct MutexLocker { > + MutexLocker(DummyMutex) {} > + }; Not exactly how I would have done it, but if a real reviewer is fine with it, then I don't care that much. > +#else > + Mutex m_syncLock; > + bool m_importComplete; > mutable Mutex m_importLock; > mutable ThreadCondition m_importCondition; > - mutable bool m_importComplete; > - void markImported(); > + bool isBackgroundThread() const { return !isMainThread(); } > +#endif > }; > > } // namespace WebCore 142022 37 yong.li.webkit 2009-08-21 15:29:29 -0700 (In reply to comment #36) > LGTM > > > > > + // Hack WTF::MutexLocker and just do nothing > > + enum DummyMutex { > > + m_syncLock, > > + m_importLock, > > + }; > > + struct MutexLocker { > > + MutexLocker(DummyMutex) {} > > + }; > > Not exactly how I would have done it, but if a real reviewer is fine with it, > then I don't care that much. I have to declare m_syncLock and m_importLock in order to make MutexLocker locker(m_syncLock) compile for single-threaded solution. The best way I can do is use an enum which won't have any overhead. 144673 38 yong.li.webkit 2009-09-03 19:42:59 -0700 change the tile 147830 39 michaeln 2009-09-17 10:26:20 -0700 I haven't fully looked thru this, but here are some comments... 62 void DatabaseThread::timerFired(Timer<DatabaseThread>*) 63 { 64 if (m_queue.isEmpty()) 65 return; 66 67 RefPtr<DatabaseTask> task = m_queue.first(); 68 task->performTask(); 69 m_queue.removeFirst(); 70 if (!m_queue.isEmpty()) 71 m_timer.startOneShot(0); 72 } 73 74 void DatabaseThread::scheduleTask(PassRefPtr<DatabaseTask> task) 75 { 76 m_queue.append(task); 77 if (!m_timer.isActive()) 78 m_timer.startOneShot(0); 79 } 80 81 void DatabaseThread::scheduleImmediateTask(PassRefPtr<DatabaseTask> task) 82 { 83 task->performTask(); 84 } As written, this will recursively execute immediate tasks when called during task execution (which can happen). I think thats a little dicey as the caller may depend on execution to be deferred. You could rework this slightly to avoid any potential problems along those lines... here's one way to do that void timerFired() { ASSERT(immedQ.isEmpty()); if (Q.isEmpty()) return; task = Q.first(); Q.removeFirst(); performTask(task); performAllImmediateTasks(); set timer if Q is not empty } void performTask(task) { isPerformingTask = true; task->perform(); isPerformingTask = false; } void scheduleImmediateTask(PassRefPtr<DatabaseTask> task) { immediateQ.prepend(task); // prepend to get the order the multi-threaded system gets i think if (!isPerformingTask ) performAllImmediateTasks(); } void performAllImmediateTasks(PassRefPtr<DatabaseTask> task) { while (!immediateQ.isEmpty()) { task = immediateQ.first(); immediateQ.removeFirst(); // remove before calling perform! performTask(task); } } * WebCore/storage/DatabaseThread.h What is with the diffs here? Its picking most of the file as "changed", but I think the only material changes are around the #if ENABLE(SINGLE_THREADED) mods... is that right? 147841 40 michaeln 2009-09-17 10:36:02 -0700 I think these assertions can be made too... > void performTask(task) { ASSERT(!isPerformingTask); > isPerformingTask = true; > task->perform(); > isPerformingTask = false; > } > > void scheduleImmediateTask(PassRefPtr<DatabaseTask> task) { ASSERT(isPerformingTask || immediateQ.isEmpty()); > immediateQ.prepend(task); > if (!isPerformingTask ) > performAllImmediateTasks(); > } 147849 41 yong.li.webkit 2009-09-17 11:01:40 -0700 (In reply to comment #39) > * WebCore/storage/DatabaseThread.h > > What is with the diffs here? Its picking most of the file as "changed", but I > think the only material changes are around the #if ENABLE(SINGLE_THREADED) > mods... is that right? Hm.. I lost the diff for this one. I'll update soon. Re: scheduleImmediateTask The caller of scheduleImmediateTask() generally blocks until the task finishes. With single-threaded solution, we have no choice except performing it immediately. If scheduleImmediateTask() just returns without performing the task, the application could hang up forever. 147852 42 yong.li.webkit 2009-09-17 11:08:08 -0700 (In reply to comment #41) > (In reply to comment #39) > > > * WebCore/storage/DatabaseThread.h > > > > What is with the diffs here? Its picking most of the file as "changed", but I > > think the only material changes are around the #if ENABLE(SINGLE_THREADED) > > mods... is that right? > > Hm.. I lost the diff for this one. I'll update soon. > never mind. the patch is OK. Yeah, the changes are all in side #if ENABLE(SINGLE_THREADED). I just added indentation to follow webkit coding guideline 147937 43 michaeln 2009-09-17 14:14:16 -0700 (In reply to comment #41) > (In reply to comment #39) > > > * WebCore/storage/DatabaseThread.h > > > > What is with the diffs here? Its picking most of the file as "changed", but I > > think the only material changes are around the #if ENABLE(SINGLE_THREADED) > > mods... is that right? > > Hm.. I lost the diff for this one. I'll update soon. > > Re: scheduleImmediateTask > > The caller of scheduleImmediateTask() generally blocks until the task finishes. > With single-threaded solution, we have no choice except performing it > immediately. If scheduleImmediateTask() just returns without performing the > task, the application could hang up forever. You're missing a use case. Let me point it out for you... What you say is true of calls to scheduleImmediateTask() made on the main thread, but not true of the calls to scheduleImmediateTask() made on the database thread. There are instances where the database thread schedules tasks back on it self for the purposes of unwinding the stack prior to continuing. The lockAcquired() method is called on the database thread in the multiproces impl while running a DatabaseTask. void SQLTransaction::lockAcquired() { m_lockAcquired = true; m_nextStep = &SQLTransaction::openTransactionAndPreflight; LOG(StorageAPI, "Scheduling openTransactionAndPreflight immediately for transaction %p\n", this); m_database->scheduleTransactionStep(this, true); } Notice that call to scheduleTransactionStep(this, TRUE) above. void Database::scheduleTransactionStep(SQLTransaction* transaction, bool immediately) { if (!m_document->databaseThread()) return; RefPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction); LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get()); if (immediately) m_document->databaseThread()->scheduleImmediateTask(task.release()); else m_document->databaseThread()->scheduleTask(task.release()); } In your impl, you've just gone recursive. 147938 44 michaeln 2009-09-17 14:15:55 -0700 r- see previous comment 147940 45 yong.li.webkit 2009-09-17 14:27:44 -0700 (In reply to comment #43) > (In reply to comment #41) > > (In reply to comment #39) > > > > void Database::scheduleTransactionStep(SQLTransaction* transaction, bool > immediately) > { > if (!m_document->databaseThread()) > return; > > RefPtr<DatabaseTransactionTask> task = > DatabaseTransactionTask::create(transaction); > LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction > step\n", task.get()); > if (immediately) > m_document->databaseThread()->scheduleImmediateTask(task.release()); > else > m_document->databaseThread()->scheduleTask(task.release()); > } > > In your impl, you've just gone recursive. Hm.. this case must be introduced after I implement the single-threaded database. All other cases of using scheduleImmediateTask is like this: task->lockForSynchronousScheduling(); m_document->databaseThread()->scheduleImmediateTask(task); task->waitForSynchronousCompletion(); The solution you provide above will make this hang up forever. Probably we should add an argument to scheduleImmediateTask(task, waitUntilFinish). What do you think? 147947 46 michaeln 2009-09-17 14:51:11 -0700 > Hm.. this case must be introduced after I implement the single-threaded > database. All other cases of using scheduleImmediateTask is like this: > > task->lockForSynchronousScheduling(); > m_document->databaseThread()->scheduleImmediateTask(task); > task->waitForSynchronousCompletion(); > > The solution you provide above will make this hang up forever. Hmmmm... void scheduleImmediateTask(PassRefPtr<DatabaseTask> task) { immediateQ.prepend(task); if (!isPerformingTask ) performAllImmediateTasks(); } That will execute the task prior to return provided we're not nested. Sooo... Where are calls of this nature made... > task->lockForSynchronousScheduling(); > m_document->databaseThread()->scheduleImmediateTask(task); > task->waitForSynchronousCompletion(); If none of these callsites are nested within 'callbacks' from database thread there would't be a deadlock. But that's difficult for me to ASSERT as by thinking it true, especially since the callbacks run script, which call .open(newDatabase), which runs the block of code above. > Probably we should add an argument to scheduleImmediateTask(task, > waitUntilFinish). What do you think? I think we may already have a proxy for such a flag buried in there. How 'bout this... DatabaseTask::isSynchronous() { return m_synchronousMutex.get() ? true : false; } void performTask(task) { bool saveIsPerformingTask = isPerformingTask isPerformingTask = true; task->perform(); isPerformingTask = saveIsPerformingTask; } void scheduleImmediateTask(PassRefPtr<DatabaseTask> task) { if (task->isSynchronous()) performTask(task); else immediateQ.prepend(task); if (!isPerformingTask ) performAllImmediateTasks(); } 147969 47 39734 yong.li.webkit 2009-09-17 16:20:10 -0700 Created attachment 39734 fix scheduleImmediateTask() problem Add an argument waitUntilFinish to scheduleImmediateTask() When it's true, multi-threaded solution calls waitSync...., and single-threaded solution just performs the task. The caller is responsible to protect deadlock problems. when it's false, just put the task to the head of the queue. 147970 48 yong.li.webkit 2009-09-17 16:25:24 -0700 (In reply to comment #46) > > Hm.. this case must be introduced after I implement the single-threaded > > database. All other cases of using scheduleImmediateTask is like this: > > > > task->lockForSynchronousScheduling(); > > m_document->databaseThread()->scheduleImmediateTask(task); > > task->waitForSynchronousCompletion(); > > > > The solution you provide above will make this hang up forever. > > Hmmmm... > > void scheduleImmediateTask(PassRefPtr<DatabaseTask> task) { > immediateQ.prepend(task); > if (!isPerformingTask ) > performAllImmediateTasks(); > } > > That will execute the task prior to return provided we're not nested. Sooo... > > Where are calls of this nature made... > > > task->lockForSynchronousScheduling(); > > m_document->databaseThread()->scheduleImmediateTask(task); > > task->waitForSynchronousCompletion(); > > If none of these callsites are nested within 'callbacks' from database thread > there would't be a deadlock. But that's difficult for me to ASSERT as by > thinking it true, especially since the callbacks run script, which call > .open(newDatabase), which runs the block of code above. > > > Probably we should add an argument to scheduleImmediateTask(task, > > waitUntilFinish). What do you think? > > I think we may already have a proxy for such a flag buried in there. > > How 'bout this... > > DatabaseTask::isSynchronous() { > return m_synchronousMutex.get() ? true : false; > } > > void performTask(task) { > bool saveIsPerformingTask = isPerformingTask > isPerformingTask = true; > task->perform(); > isPerformingTask = saveIsPerformingTask; > } > > void scheduleImmediateTask(PassRefPtr<DatabaseTask> task) { > if (task->isSynchronous()) > performTask(task); > else > immediateQ.prepend(task); > > if (!isPerformingTask ) > performAllImmediateTasks(); > } Ha, I didn't see your message while implementing it. Check my new patch. I don't use another immediate queue, instead, just put the task to the head of the existing queue. 147971 49 michaeln 2009-09-17 16:28:17 -0700 > Ha, I didn't see your message while implementing it. > > Check my new patch. I don't use another immediate queue, instead, just put the > task to the head of the existing queue. I think what you've got works for me, thnx :) No second Q is definitely a feature. LGTM 147973 50 michaeln 2009-09-17 16:32:25 -0700 Wait... i take that lgtm back... 109 // Make this task the first one in the queue 110 m_queue.prepend(task); 111 if (!m_timer.isActive()) 112 m_timer.startOneShot(0); If we do this while waiting to finish a sync task that needs this immediate 'task' to complete... i think we're hosed. 147985 51 michaeln 2009-09-17 17:45:41 -0700 (In reply to comment #50) > Wait... i take that lgtm back... > > 109 // Make this task the first one in the queue > 110 m_queue.prepend(task); > 111 if (!m_timer.isActive()) > 112 m_timer.startOneShot(0); > > > If we do this while waiting to finish a sync task that needs this immediate > 'task' to complete... i think we're hosed. Hi again, You may be able implement performAllImmediateTasks without a secondQ, just keep track of how many immediate tasks have been prepended. Also I think keeping the 'sync' task callsites looking different than callsites scheduling async tasks may actually be a good thing, the trailing true or false 'wait' argument is a little subtle for this. > DatabaseTask::isSynchronous() { > return m_synchronousMutex.get() ? true : false; > } > > void performTask(task) { > bool saveIsPerformingTask = isPerformingTask > isPerformingTask = true; > task->perform(); > isPerformingTask = saveIsPerformingTask; > } > void scheduleImmediateTask(PassRefPtr<DatabaseTask> task) { if (task->isSynchronous()) performTask(task); else { numImmediate++; Q.prepend(task); } if (!isPerformingTask ) performAllImmediateTasks(); } void performAllImmediateTasks(PassRefPtr<DatabaseTask> task) { ASSERT(numImmediate >= 0); while (numImmediate) { task = Q.first(); Q.removeFirst(); // remove before calling perform! numImmediate--; performTask(task); } } 148093 52 yong.li.webkit 2009-09-18 07:16:41 -0700 (In reply to comment #50) > Wait... i take that lgtm back... > > 109 // Make this task the first one in the queue > 110 m_queue.prepend(task); > 111 if (!m_timer.isActive()) > 112 m_timer.startOneShot(0); > > > If we do this while waiting to finish a sync task that needs this immediate > 'task' to complete... i think we're hosed. In that case, waitUntilFinish should true. (In reply to comment #51) 1) I still like an argument for this. It at least can save duplicate code for calling "lockSync..." and "waitSync...". Also, we can even remove those sync methods and objects for #if ENABLE(SINGLE_THREADED)... 2) I don't like performImmediateTasks, because this could block UI. When "waitUntilFinish" is false, "immediate" just means the task should be inserted to the first position of the task queue. So we don't have to perform them all together in one shot. We can still perform one task every time, so that UI won't be blocked by running too many tasks. 148245 53 michaeln 2009-09-18 10:56:57 -0700 (In reply to comment #52) > (In reply to comment #50) > > Wait... i take that lgtm back... > > > > 109 // Make this task the first one in the queue > > 110 m_queue.prepend(task); > > 111 if (!m_timer.isActive()) > > 112 m_timer.startOneShot(0); > > > > > > If we do this while waiting to finish a sync task that needs this immediate > > 'task' to complete... i think we're hosed. > > In that case, waitUntilFinish should true. I think you have to look again. In the usage of scheduleImmediateTask that I pointed out earlier, the 'wait' value will always be false. Now consider what happens if that particular usage is scheduleImmediateTask is invoked in the act of performing Database::openAndVerifyVersion(). 148345 54 yong.li.webkit 2009-09-18 13:20:09 -0700 (In reply to comment #53) > (In reply to comment #52) > > (In reply to comment #50) > > > Wait... i take that lgtm back... > > > > > > 109 // Make this task the first one in the queue > > > 110 m_queue.prepend(task); > > > 111 if (!m_timer.isActive()) > > > 112 m_timer.startOneShot(0); > > > > > > > > > If we do this while waiting to finish a sync task that needs this immediate > > > 'task' to complete... i think we're hosed. > > > > In that case, waitUntilFinish should true. > > I think you have to look again. > > In the usage of scheduleImmediateTask that I pointed out earlier, the 'wait' > value will always be false. Now consider what happens if that particular usage > is scheduleImmediateTask is invoked in the act of performing > Database::openAndVerifyVersion(). In Database::openAndVerifyVersion(), we have to perform the task immediately for single-threaded version. "wait" must be true here. 148359 55 michaeln 2009-09-18 13:36:04 -0700 > > > > If we do this while waiting to finish a sync task that needs this immediate > > > > 'task' to complete... i think we're hosed. > > > > > > In that case, waitUntilFinish should true. > > > > I think you have to look again. > > > > In the usage of scheduleImmediateTask that I pointed out earlier, the 'wait' > > value will always be false. Now consider what happens if that particular usage > > is scheduleImmediateTask is invoked in the act of performing > > Database::openAndVerifyVersion(). > > In Database::openAndVerifyVersion(), we have to perform the task immediately > for single-threaded version. "wait" must be true here. Nothing in your CL makes 'wait' true in at the callsite i referred to earlier. Furthermore, if it did... it would preform the task recursively which we don't want. Right? 148399 56 yong.li.webkit 2009-09-18 14:53:23 -0700 (In reply to comment #55) > > Nothing in your CL makes 'wait' true in at the callsite i referred to earlier. ? I don't understand. I pass "true" to scheduleImmeidateTask() in this case. Check the patch. > Furthermore, if it did... it would preform the task recursively which we don't > want. > > Right? I just know how to depend myself now :) Don't worry about recursive when "wait" is true. See this: 1) In which thread can waitForSynchronousCompletion() be called? I would assume it's definitely the main thread. because the database worker thread cannot wait itself (deadlock!). and there's no reason that other threads call it, right? So, only main thread calls waitForSynchronousCompletion(). 2) in multi-threaded solution: tasks are performed only in database worker thread. right? With 1) and 2), even with multi-threaded solution, you cannot waitForSynchronousCompletion() when performing a task. Otherwise, you get deadlock! Conclusion: waitForSynchronousCompletion() should never be called when performing a task (for both multi & single threaded). So why do I worry about that? :) 148577 57 michaeln 2009-09-20 15:57:19 -0700 First some follow up with you on scheduleImmediate, but then a new topic. (In reply to comment #56) > (In reply to comment #55) > > > > Nothing in your CL makes 'wait' true in at the callsite i referred to earlier. > > ? I don't understand. I pass "true" to scheduleImmeidateTask() in this case. > Check the patch. Sure, but that's not the callsite i'm referring you to. Again, notice the call to m_database->scheduleTransactionStep(this, true) in SQLTransaction::lockAcquired(). That results in a call to scheduleImmediateTask with 'wait' being false. If the processing of any 'sync' tasks involved an additional 'immediate' task like this, the single-threaded impl would get wedged. I just looked thru all of the 'sync' tasks. So as of right now, none of them involve additional immediate tasks. But imo, depending on that remaining true going forward is a little dicey. In particular, it looks like the DatabaseTableNamesTask needs some work. Irrespective of your patch, that particular sync task can wedge the system. I'm not sure what the solution to that will be, it may or may not involve the kind of immediate tasks (schedule from the db thread back onto itself) that will give your single-threaded impl grief. > > Furthermore, if it did... it would preform the task recursively which we don't > > want. > > > > Right? > > I just know how to depend myself now :) Don't worry about recursive when "wait" > is true. See this: > > 1) In which thread can waitForSynchronousCompletion() be called? > > I would assume it's definitely the main thread. because the database worker > thread cannot wait itself (deadlock!). and there's no reason that other threads > call it, right? Yes, only the main thread. > > So, only main thread calls waitForSynchronousCompletion(). > > 2) in multi-threaded solution: tasks are performed only in database worker > thread. right? > > With 1) and 2), even with multi-threaded solution, you cannot > waitForSynchronousCompletion() when performing a task. Otherwise, you get > deadlock! > > Conclusion: waitForSynchronousCompletion() should never be called when > performing a task (for both multi & single threaded). So why do I worry about > that? :) Here's why... There is a difference between 'immediate' and 'synchronious'. The background thread can schedule 'immediate' tasks to be performed. And if and when that happens while performing a 'sync' task on behalf of the main thread, your single-threaded impl is going to be in trouble. As of right now, there are no 'immediate' tasks scheduled while performing any of the 'sync' tasks... but that might change. ***** New topic... The number of DatabaseThread instances in the single-threaded impl. Looks like the single-threaded impl still has one instance per document. I think you probably want to have one instance <period> for your use case. Superficially this makes some sense given in your single-threaded imple DatabaseThread==MainThread, and there's only one of those. But also for a deeper reason... Take a close look at what SQLTransactionCoordinator does. There's logic in there to ensure that two transactions on the same database file (thru different Database instances) don't wedge the system. Each DatabaseThread instance has its own coordinator to keep transactions from butting heads on its particular thread. So... i think you want one instance of DatabaseThread/Coordinator in your world. You're going to have to look more closely at this one. **** Overall... I think your pretty close to a single-threaded solution that won't be too difficult to maintain going forward. Have you run this stuff thru the database layout tests yet? 148578 58 staikos 2009-09-20 16:09:02 -0700 I'm failing to see the reason why this patch is held up anymore. It seems perfectly reasonable and forcing multithreading has never been done in the past. I'm not sure why storage should mandate it. On platforms that Torch Mobile has worked on this requirement has been unacceptable and we had to remove it with a patch similar to this. As long as it doesn't affect others adversely let's get it checked in and then adjust it as appropriate if other platforms also desire the feature. 148580 59 michaeln 2009-09-20 16:26:52 -0700 (In reply to comment #58) > I'm failing to see the reason why this patch is held up anymore. It seems > perfectly reasonable and forcing multithreading has never been done in the > past. I'm not sure why storage should mandate it. On platforms that Torch > Mobile has worked on this requirement has been unacceptable and we had to > remove it with a patch similar to this. As long as it doesn't affect others > adversely let's get it checked in and then adjust it as appropriate if other > platforms also desire the feature. I didn't mean to "hold it up" or to "force multithreading". Was just trying to help out with a review given my understanding of the Database system. Care to comment specifically on the DatabaseThread/SQLTransactionCoordinator issue i just mentioned... it looks like theres some work to be done on that dimension before you've got something that works when multiple documents (or frames) open connections to the same database file. 148587 60 yong.li.webkit 2009-09-20 18:09:25 -0700 > > **** Overall... > I think your pretty close to a single-threaded solution that won't be too > difficult to maintain going forward. Have you run this stuff thru the database > layout tests yet? I've run it though the tests in LayoutTest/storage, and also on real websites. Yes, "sync" is different from "immediate". But in fact, at 4 places in current code, scheduleImmeidateTask() is used as sync with another 2 methods together. (These 4 cases are actually simulating single-threaded thing, and it breaks one of the reasons of using multi-threaded database solution: don't let database failure ruin the main app. In these 4 cases, when database thread crashes, the app will keep hanging up. Also, it blocks UI) My solution is add this argument to distinguish 'sync' and 'immediate'. Another solution is adding another method for 'sync'. I don't need to worry about scheduleImmediateTask(true) being called when performing a task, because if that happens, the multi-threaded solution must also get deadlock. I think you've pointed out a bug for the use of SQLTransactionCoordinator in my code. Thanks a lot. I'll fix that 148588 61 yong.li.webkit 2009-09-20 18:12:59 -0700 Oops, I just checked the code. I think multiple instances of DatabaseThread and its coordinator is correct way. Because the coordinator should be able to cancel all pending transactions that belongs to the DatabaseThread/Document 148594 62 michaeln 2009-09-20 19:53:52 -0700 (In reply to comment #61) > Oops, I just checked the code. I think multiple instances of DatabaseThread and > its coordinator is correct way. Because the coordinator should be able to > cancel all pending transactions that belongs to the DatabaseThread/Document Yea... thats why i said "you're going to have to look more closely at this one". I think the single-threaded impl has to reconcile the difference in some way. I doubt any of the existing layout tests will tickle this issue. Since there's an implicit assumption that each Document has its down DBThread, I don't think there are many tests that try to induce deadlocks with multiple Documents involved. 152489 63 40668 yong.li.webkit 2009-10-05 15:26:50 -0700 Created attachment 40668 new patch 152515 64 michaeln 2009-10-05 16:27:44 -0700 > Created an attachment (id=40668) [details] > new patch Can you describe what changed since the last patch? Specifically I'm wondering about the thread and transaction coordinator arrangement. 152713 65 yong.li.webkit 2009-10-06 07:22:26 -0700 (In reply to comment #64) > > Created an attachment (id=40668) [details] [details] > > new patch > > Can you describe what changed since the last patch? Specifically I'm wondering > about the thread and transaction coordinator arrangement. The changes are made according to Nikolas Zimmermann's suggestions: 1. coding style: remove /t in previous patch 2. replace the code that hacks MutexLocker with a new class StorageMutextLocker. For single-threaded solution, it does nothing. 152817 66 michaeln 2009-10-06 12:08:59 -0700 > The changes are made according to Nikolas Zimmermann's suggestions: > > 1. coding style: remove /t in previous patch > 2. replace the code that hacks MutexLocker with a new class > StorageMutextLocker. For single-threaded solution, it does nothing. I see, if that's the case, I think you've probably got a bug in the single-threaded impl. If i'm right, here's how you should be able to demonstrate the bug. * pageA with a nested iframeB (you need two documents with different DatabaseThreads and accompanying DatabaseCoordinators) * onload, have pageA and iframeB open the same database file (so you have two different Database objects) * start a write transaction in pageA by calling db.transaction(..., false) * in the transaction callback - first call a function in iframeB to start separate write transaction using that nested frames Database object - then call transaction.executeSql(sql) That second transaction started in iframeB will block trying to BEGIN a transaction on a locked database file. After 30 seconds it will time out and fail. Once that timeout expires, the sql statement issued by pageA will execute. I'm relying on tickling the bug by calling into iframeB at just the wrong time, but that's just to make things deterministic. If a second write transaction against the same database file is started while the first is not yet complete, it will block regardless of how that situation arose. 152855 67 yong.li.webkit 2009-10-06 14:07:06 -0700 (In reply to comment #66) > > The changes are made according to Nikolas Zimmermann's suggestions: > > > > 1. coding style: remove /t in previous patch > > 2. replace the code that hacks MutexLocker with a new class > > StorageMutextLocker. For single-threaded solution, it does nothing. > > I see, if that's the case, I think you've probably got a bug in the > single-threaded impl. If i'm right, here's how you should be able to > demonstrate the bug. > > * pageA with a nested iframeB (you need two documents with different > DatabaseThreads and accompanying DatabaseCoordinators) > > * onload, have pageA and iframeB open the same database file (so you have two > different Database objects) > > * start a write transaction in pageA by calling db.transaction(..., false) > > * in the transaction callback > - first call a function in iframeB to start separate write transaction > using that nested frames Database object > - then call transaction.executeSql(sql) > > That second transaction started in iframeB will block trying to BEGIN a > transaction on a locked database file. After 30 seconds it will time out and > fail. Once that timeout expires, the sql statement issued by pageA will > execute. > > I'm relying on tickling the bug by calling into iframeB at just the wrong time, > but that's just to make things deterministic. If a second write transaction > against the same database file is started while the first is not yet complete, > it will block regardless of how that situation arose. Hm... This IS a problem. So before running the task when timer fires, I should check if database is locked by another transaction. if yes, I would just delay it and yield. What do you think? 152870 68 michaeln 2009-10-06 14:58:07 -0700 > Hm... This IS a problem. So before running the task when timer fires, I should > check if database is locked by another transaction. if yes, I would just delay > it and yield. What do you think? Ah... i finally got your attention, good ;) You don't want to serialize ALL tasks in that fashion. Only particular tasks operating on 'locked' databases. This is exactly what the transaction coordinator does. For it to do its job, it has to have knowledge of ALL transactions being scheduled on a particular thread. In your case, everything is happening on the 'main' thread. You have some options... a) Have one DatabaseThread (instance) per process instead of one per document. I think this is the most natural arrangment. You may have to poke at the document shutdown logic to detach its particular Databases from the DatabaseThread upon doc going away. b) Have one DatabaseThread (instance) per Document (as it is today), but have them share a TransactionCoordinator, and upon shutdown, unplug that "threads" databases from the coordinator. Either approach seems workable, but option a) makes more sense from the 20000 foot perspective. 153031 69 yong.li.webkit 2009-10-07 07:19:27 -0700 (In reply to comment #68) > > Hm... This IS a problem. So before running the task when timer fires, I should > > check if database is locked by another transaction. if yes, I would just delay > > it and yield. What do you think? > > Ah... i finally got your attention, good ;) > > You don't want to serialize ALL tasks in that fashion. Only particular tasks > operating on 'locked' databases. > > This is exactly what the transaction coordinator does. For it to do its job, it > has to have knowledge of ALL transactions being scheduled on a particular > thread. In your case, everything is happening on the 'main' thread. > > You have some options... > > a) Have one DatabaseThread (instance) per process instead of one per document. > I think this is the most natural arrangment. You may have to poke at the > document shutdown logic to detach its particular Databases from the > DatabaseThread upon doc going away. > > b) Have one DatabaseThread (instance) per Document (as it is today), but have > them share a TransactionCoordinator, and upon shutdown, unplug that "threads" > databases from the coordinator. > > Either approach seems workable, but option a) makes more sense from the 20000 > foot perspective. Totally agree. Thanks a lot! 153058 70 yong.li.webkit 2009-10-07 09:08:10 -0700 Hi, Michael, I just took a look at the code. I still don't understand the problem very well. It's single-threaded solution, so only one task is performing at one time. Is there a case that a transaction is made up of multiple tasks? 153098 71 michaeln 2009-10-07 10:08:21 -0700 > Is there a case that a transaction is made up of multiple tasks? Yes! Every case. There are many 'steps' to a transaction. Some are performed on the background database thread (sqlite operations), some are performed on the main ui thread (invoking script callbacks to gather statements to be executed and to report results and errors (which may involve additional statements being queued for execution)). Messages (tasks) ping/pongs back and forth between main/database threads until the transaction is complete. 153121 72 yong.li.webkit 2009-10-07 11:13:31 -0700 (In reply to comment #71) > > Is there a case that a transaction is made up of multiple tasks? > > Yes! Every case. > > There are many 'steps' to a transaction. Some are performed on the background > database thread (sqlite operations), some are performed on the main ui thread > (invoking script callbacks to gather statements to be executed and to report > results and errors (which may involve additional statements being queued for > execution)). > > Messages (tasks) ping/pongs back and forth between main/database threads until > the transaction is complete. Get it now. But a) has a problem: when the page is closed, how can the DatabaseThread remove all tasks that belongs to the page? 153133 73 michaeln 2009-10-07 11:38:23 -0700 > Get it now. But a) has a problem: when the page is closed, how can the > DatabaseThread remove all tasks that belongs to the page? This is exactly what you need to dig into. You may not have to 'remove all tasks that belong to the page'. If the Database instances for that page are 'closed' in some way such that when tasks execute on their behalf they short circuit. I haven't looked at the details. 153495 74 jorlow 2009-10-08 13:03:29 -0700 Some comments. Btw, I really like how you cleaned up the mutex thing. > diff --git a/WebCore/storage/StorageAreaSync.cpp b/WebCore/storage/StorageAreaSync.cpp > index bec45aa..c8243c0 100644 > --- a/WebCore/storage/StorageAreaSync.cpp > +++ b/WebCore/storage/StorageAreaSync.cpp > @@ -1,5 +1,6 @@ > /* > * Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved. > + * Copyright (C) 2009 Torch Mobile, Inc. > * > * Redistribution and use in source and binary forms, with or without > * modification, are permitted provided that the following conditions > @@ -55,16 +56,12 @@ StorageAreaSync::StorageAreaSync(PassRefPtr<StorageSyncManager> storageSyncManag > , m_syncManager(storageSyncManager) > , m_clearItemsWhileSyncing(false) > , m_syncScheduled(false) > - , m_importComplete(false) I really don't like that this is being removed since, but I see why you're doing it. I think we should leave the variable in (it's only 1 byte!) and you should just ignore it in the single threaded code. > void StorageAreaSync::markImported() > { > - ASSERT(!isMainThread()); > - > - MutexLocker locker(m_importLock); > - // Break the (ref count) cycle. > - m_storageArea = 0; > - m_importComplete = true; > - m_importCondition.signal(); > -} > - > -// FIXME: In the future, we should allow use of StorageAreas while it's importing (when safe to do so). > -// Blocking everything until the import is complete is by far the simplest and safest thing to do, but > -// there is certainly room for safe optimization: Key/length will never be able to make use of such an > -// optimization (since the order of iteration can change as items are being added). Get can return any > -// item currently in the map. Get/remove can work whether or not it's in the map, but we'll need a list > -// of items the import should not overwrite. Clear can also work, but it'll need to kill the import > -// job first. > -void StorageAreaSync::blockUntilImportComplete() const > -{ > - ASSERT(isMainThread()); > + ASSERT(isBackgroundThread()); > > - // Fast path to avoid locking. > - if (m_importComplete) > - return; > - > - MutexLocker locker(m_importLock); > - while (!m_importComplete) > - m_importCondition.wait(m_importLock); > - ASSERT(m_importComplete); > - ASSERT(!m_storageArea); > + StorageMutexLocker locker(m_importLock); > + markImportedWithoutLockingMutex(); Isn't there only one or two calls to markImported? If so, rename markImportedWithoutLockingMutex to markImported(), have the few callsites to the old version grab the mutex themselves, and add a comment above the function in the header file to state that the caller should hold the import lock when calling. > + > +void StorageAreaSync::scheduleImport() > +{ > + m_importComplete = false; This isn't necessary if you follow my request above. > + // FIXME: If it can't import, then the default WebKit behavior should be that of private browsing, > + // not silently ignoring it. https://bugs.webkit.org/show_bug.cgi?id=25894 > + if (!m_syncManager->scheduleImport(this)) > + m_importComplete = true; > +} > + > +void StorageAreaSync::markImportedWithoutLockingMutex() > +{ Add back in the assert for main thread? > + // Break the (ref count) cycle. > + m_storageArea = 0; > + m_importComplete = true; > + m_importCondition.signal(); > +} > + > +#endif > + > } // namespace WebCore > > #endif // ENABLE(DOM_STORAGE) > diff --git a/WebCore/storage/StorageAreaSync.h b/WebCore/storage/StorageAreaSync.h > index 9d6436f..813a0b8 100644 > --- a/WebCore/storage/StorageAreaSync.h > +++ b/WebCore/storage/StorageAreaSync.h > - mutable Mutex m_importLock; > - mutable ThreadCondition m_importCondition; > - mutable bool m_importComplete; > + void scheduleImport(); > void markImported(); > + void markImportedWithoutLockingMutex(); See my comment towards the end about this... > + > +#if ENABLE(SINGLE_THREADED) > + bool isBackgroundThread() const { return true; } > + struct StorageMutexLocker { nit: might be better to make this a class and then add a public: The main reason is that if someone tries to forward declare this or do anything else somewhat fancy, the difference between struct and class do matter. If you feel strongly, you can leave it though. > + // Do nothing here nit: not sure this comment is very informative. :-) > + StorageMutexLocker(Mutex&) {} nit: isn't a space between the {}'s normal? > + }; > +#else > + typedef MutexLocker StorageMutexLocker; > + bool m_importComplete; > + mutable ThreadCondition m_importCondition; > + bool isBackgroundThread() const { return !isMainThread(); } nit: put above the variables...if nothing else to match how it is in the #if section. > +#endif > + Mutex m_syncLock; > + mutable Mutex m_importLock; > }; > > } // namespace WebCore > diff --git a/WebCore/storage/single-threaded/LocalStorageThread.cpp b/WebCore/storage/single-threaded/LocalStorageThread.cpp > new file mode 100644 > index 0000000..12f11a1 > --- /dev/null > +++ b/WebCore/storage/single-threaded/LocalStorageThread.cpp > + > +PassRefPtr<LocalStorageThread> LocalStorageThread::create() > +{ > + return adoptRef(new LocalStorageThread); > +} > + > +LocalStorageThread::LocalStorageThread() > +: m_timer(this, &LocalStorageThread::timerFired) indent 4 spaces > +{ > +} > +void LocalStorageThread::terminate() > +{ > + m_queue.clear(); > + m_timer.stop(); I believe the multi-threaded code allows the thread to finish processing. If so, then this should probably process all pending events. If you want to exactly match behavior, it would copy the queue and process that so it's impossible for any new items to be added. 162260 75 eric 2009-11-10 15:56:31 -0800 Ping? No comments from reviewers in over a month. I don't personally feel qualified to review this. I'm not sure who the database experts are these days... 162272 76 jorlow 2009-11-10 16:16:43 -0800 (In reply to comment #75) > Ping? No comments from reviewers in over a month. I don't personally feel > qualified to review this. I'm not sure who the database experts are these > days... I feel like this is getting fairly close, but there are still some open questions and I know I've made enough changes to LocalStorage that it won't apply cleanly anymore. Is there any chance you could address Michaeln's comments and re-roll another patch? Either way, I think the current one is a clear r-. 162273 77 40668 eric 2009-11-10 16:19:52 -0800 Comment on attachment 40668 new patch I agree with Jeremy. Michael's comments are unaddressed. Marking r- officially. That reminds me, jorlow is probably pretty close to needing a reviewer nomination. I should check... 162304 78 staikos 2009-11-10 17:56:52 -0800 (In reply to comment #76) > (In reply to comment #75) > > Ping? No comments from reviewers in over a month. I don't personally feel > > qualified to review this. I'm not sure who the database experts are these > > days... > > I feel like this is getting fairly close, but there are still some open > questions and I know I've made enough changes to LocalStorage that it won't > apply cleanly anymore. > > Is there any chance you could address Michaeln's comments and re-roll another > patch? > > Either way, I think the current one is a clear r-. I believe this is the plan but it will take some time. Suggest the bug is left open with the patches r-/clear until that happens. 34135 2009-08-05 08:10:14 -0700 2009-08-18 15:10:57 -0700 the patch 28019.patch text/plain 7230 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZTU5NzIzMy4uNTNiZTFkMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAwOS0wOC0wNSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIE5lZWQgYSBzaG9ydCBkZXNjcmlwdGlvbiBhbmQgYnVnIFVSTCAoT09Q UyEpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yODAx OQorCisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oOgorICAgICAgICAqIHN0b3Jh Z2UvTG9jYWxTdG9yYWdlVGhyZWFkLmg6CisgICAgICAgICogc3RvcmFnZS9TdG9yYWdlQXJlYVN5 bmMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpTdG9yYWdlQXJlYVN5 bmMpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpwZXJmb3JtSW1wb3J0KToK KyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6c3luYyk6CisgICAgICAgIChXZWJD b3JlOjpTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1TeW5jKToKKyAgICAgICAgKiBzdG9yYWdlL1N0 b3JhZ2VBcmVhU3luYy5oOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpibG9j a1VudGlsSW1wb3J0Q29tcGxldGUpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5j OjptYXJrSW1wb3J0ZWQpOgorICAgICAgICAqIHN0b3JhZ2UvU3RvcmFnZVN5bmNNYW5hZ2VyLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VTeW5jTWFuYWdlcjo6Y2xvc2UpOgorICAgICAg ICAoV2ViQ29yZTo6U3RvcmFnZVN5bmNNYW5hZ2VyOjpzY2hlZHVsZUltcG9ydCk6CisgICAgICAg IChXZWJDb3JlOjpTdG9yYWdlU3luY01hbmFnZXI6OnNjaGVkdWxlU3luYyk6CisKIDIwMDktMDct MjEgIFlvbmcgTGkgIDx5b25nLmxpQHRvcmNobW9iaWxlLmNvbT4KIAogICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJh c2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCmluZGV4IDVhYWI1 ZmQuLmM3NDRiODYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5o CisrKyBiL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCkBAIC0xLDUgKzEsNiBAQAog LyoKICAqIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI5LDYgKzMw LDEzIEBACiAjZGVmaW5lIERhdGFiYXNlVGhyZWFkX2gKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkK KworI2lmIFBMQVRGT1JNKFdJTkNFKQorCisjaW5jbHVkZSAid2luY2UvRGF0YWJhc2VUaHJlYWRX aW5jZS5oIgorCisjZWxzZQorCiAjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3Rm L0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgpAQCAtNzksNSArODcsNyBAQCBw cml2YXRlOgogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKKyNlbmRpZiAvLyBQTEFURk9STShX SU5DRSkKKwogI2VuZGlmIC8vIEVOQUJMRShEQVRBQkFTRSkKICNlbmRpZiAvLyBEYXRhYmFzZVRo cmVhZF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9yYWdlVGhyZWFkLmgg Yi9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9yYWdlVGhyZWFkLmgKaW5kZXggM2Q1ODQyNy4uNDUx NzhlOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oCisr KyBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaApAQCAtMSw1ICsxLDYgQEAK IC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVk LgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgUmlnaHRzIFJl c2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOCw2ICsyOSwxMiBA QAogCiAjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQogCisjaWYgUExBVEZPUk0oV0lOQ0UpCisKKyNp bmNsdWRlICJ3aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oIgorCisjZWxzZQorCiAjaW5j bHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTWVzc2FnZVF1ZXVlLmg+CiAjaW5j bHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KQEAgLTcxLDYgKzc4LDggQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKKyNlbmRpZiAvLyBQTEFURk9STShXSU5D RSkKKwogI2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKIAogI2VuZGlmIC8vIExvY2FsU3Rv cmFnZVRocmVhZF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5j LmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3BwCmluZGV4IDAxZDJhNjUu LjUxODJmZDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3Bw CisrKyBiL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3BwCkBAIC01NSw4ICs1NSwx MyBAQCBTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VBcmVhU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VT eW5jTWFuYWdlcj4gc3RvcmFnZVN5bmNNYW5hZwogICAgICwgbV9zeW5jTWFuYWdlcihzdG9yYWdl U3luY01hbmFnZXIpCiAgICAgLCBtX2NsZWFySXRlbXNXaGlsZVN5bmNpbmcoZmFsc2UpCiAgICAg LCBtX3N5bmNTY2hlZHVsZWQoZmFsc2UpCisjaWYgIVBMQVRGT1JNKFdJTkNFKQogICAgICwgbV9p bXBvcnRDb21wbGV0ZShmYWxzZSkKKyNlbmRpZgogeworI2lmIFBMQVRGT1JNKFdJTkNFKQorICAg IHBlcmZvcm1JbXBvcnQoKTsKKyNlbHNlCiAgICAgQVNTRVJUKG1fc3RvcmFnZUFyZWEpOwogICAg IEFTU0VSVChtX3N5bmNNYW5hZ2VyKTsKIApAQCAtNjQsNiArNjksNyBAQCBTdG9yYWdlQXJlYVN5 bmM6OlN0b3JhZ2VBcmVhU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VTeW5jTWFuYWdlcj4gc3RvcmFn ZVN5bmNNYW5hZwogICAgIC8vIG5vdCBzaWxlbnRseSBpZ25vcmluZyBpdC4gIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5NAogICAgIGlmICghbV9zeW5jTWFuYWdl ci0+c2NoZWR1bGVJbXBvcnQodGhpcykpCiAgICAgICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVl OworI2VuZGlmCiB9CiAKIFN0b3JhZ2VBcmVhU3luYzo6flN0b3JhZ2VBcmVhU3luYygpCkBAIC0x NjAsNyArMTY2LDkgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKFRpbWVy PFN0b3JhZ2VBcmVhU3luYz4qKQogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9y dCgpCiB7CisjaWYgIVBMQVRGT1JNKFdJTkNFKQogICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkp OworI2VuZGlmCiAgICAgQVNTRVJUKCFtX2RhdGFiYXNlLmlzT3BlbigpKTsKIAogICAgIFN0cmlu ZyBkYXRhYmFzZUZpbGVuYW1lID0gbV9zeW5jTWFuYWdlci0+ZnVsbERhdGFiYXNlRmlsZW5hbWUo bV9zdG9yYWdlQXJlYS0+c2VjdXJpdHlPcmlnaW4oKSk7CkBAIC0yMDQsNyArMjEyLDkgQEAgdm9p ZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQogICAgICAgICByZXR1cm47CiAgICAg fQogCisjaWYgIVBMQVRGT1JNKFdJTkNFKQogICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX2ltcG9y dExvY2spOworI2VuZGlmCiAgICAgCiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJh dG9yIGl0ID0gaXRlbU1hcC5iZWdpbigpOwogICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+Ojpp dGVyYXRvciBlbmQgPSBpdGVtTWFwLmVuZCgpOwpAQCAtMjEyLDEyICsyMjIsMTUgQEAgdm9pZCBT dG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQogICAgIGZvciAoOyBpdCAhPSBlbmQ7ICsr aXQpCiAgICAgICAgIG1fc3RvcmFnZUFyZWEtPmltcG9ydEl0ZW0oaXQtPmZpcnN0LCBpdC0+c2Vj b25kKTsKICAgICAKKyNpZiAhUExBVEZPUk0oV0lOQ0UpCiAgICAgLy8gQnJlYWsgdGhlIChyZWYg Y291bnQpIGN5Y2xlLgogICAgIG1fc3RvcmFnZUFyZWEgPSAwOwogICAgIG1faW1wb3J0Q29tcGxl dGUgPSB0cnVlOwogICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25hbCgpOworI2VuZGlmCiB9CiAK KyNpZiAhUExBVEZPUk0oV0lOQ0UpCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6bWFya0ltcG9ydGVk KCkKIHsKICAgICBBU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKQEAgLTI1MCwxMCArMjYzLDEzIEBA IHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9ja1VudGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAog ICAgIEFTU0VSVChtX2ltcG9ydENvbXBsZXRlKTsKICAgICBBU1NFUlQoIW1fc3RvcmFnZUFyZWEp OwogfQorI2VuZGlmCiAKIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpzeW5jKGJvb2wgY2xlYXJJdGVt cywgY29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4mIGl0ZW1zKQogeworI2lmICFQTEFURk9S TShXSU5DRSkKICAgICBBU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKyNlbmRpZgogCiAgICAgaWYg KCFtX2RhdGFiYXNlLmlzT3BlbigpKQogICAgICAgICByZXR1cm47CkBAIC0zMDksNyArMzI1LDkg QEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnN5bmMoYm9vbCBjbGVhckl0ZW1zLCBjb25zdCBIYXNo TWFwPFN0cmluZywgU3RyaW5nPiYgaXRlbXMKIAogdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZv cm1TeW5jKCkKIHsKKyNpZiAhUExBVEZPUk0oV0lOQ0UpCiAgICAgQVNTRVJUKCFpc01haW5UaHJl YWQoKSk7CisjZW5kaWYKIAogICAgIGJvb2wgY2xlYXJJdGVtczsKICAgICBIYXNoTWFwPFN0cmlu ZywgU3RyaW5nPiBpdGVtczsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJl YVN5bmMuaCBiL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaAppbmRleCBlNDM2YmVm Li5mYTY0OTg0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgK KysrIGIvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCkBAIC00Niw3ICs0NiwxMSBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIH5TdG9yYWdlQXJlYVN5bmMoKTsKIAogICAg ICAgICB2b2lkIHNjaGVkdWxlRmluYWxTeW5jKCk7CisjaWYgUExBVEZPUk0oV0lOQ0UpCisgICAg ICAgIHZvaWQgYmxvY2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3Qge30KKyNlbHNlCiAgICAg ICAgIHZvaWQgYmxvY2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3Q7CisjZW5kaWYKIAogICAg ICAgICB2b2lkIHNjaGVkdWxlSXRlbUZvclN5bmMoY29uc3QgU3RyaW5nJiBrZXksIGNvbnN0IFN0 cmluZyYgdmFsdWUpOwogICAgICAgICB2b2lkIHNjaGVkdWxlQ2xlYXIoKTsKQEAgLTgzLDEwICs4 NywxNCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIGJvb2wgbV9jbGVhckl0ZW1zV2hp bGVTeW5jaW5nOwogICAgICAgICBib29sIG1fc3luY1NjaGVkdWxlZDsKIAorI2lmIFBMQVRGT1JN KFdJTkNFKQorICAgICAgICB2b2lkIG1hcmtJbXBvcnRlZCgpIHt9CisjZWxzZQogICAgICAgICBt dXRhYmxlIE11dGV4IG1faW1wb3J0TG9jazsKICAgICAgICAgbXV0YWJsZSBUaHJlYWRDb25kaXRp b24gbV9pbXBvcnRDb25kaXRpb247CiAgICAgICAgIG11dGFibGUgYm9vbCBtX2ltcG9ydENvbXBs ZXRlOwogICAgICAgICB2b2lkIG1hcmtJbXBvcnRlZCgpOworI2VuZGlmCiAgICAgfTsKIAogfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VT eW5jTWFuYWdlci5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZVN5bmNNYW5hZ2VyLmNwcApp bmRleCBhOTM1MjQyLi5iOTBkMTgwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFn ZVN5bmNNYW5hZ2VyLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZVN5bmNNYW5hZ2Vy LmNwcApAQCAtNzIsNyArNzIsOSBAQCBTdHJpbmcgU3RvcmFnZVN5bmNNYW5hZ2VyOjpmdWxsRGF0 YWJhc2VGaWxlbmFtZShTZWN1cml0eU9yaWdpbiogb3JpZ2luKQogCiB2b2lkIFN0b3JhZ2VTeW5j TWFuYWdlcjo6Y2xvc2UoKQogeworI2lmICFQTEFURk9STShXSU5DRSkKICAgICBBU1NFUlQoaXNN YWluVGhyZWFkKCkpOworI2VuZGlmCiAKICAgICBpZiAobV90aHJlYWQpIHsKICAgICAgICAgbV90 aHJlYWQtPnRlcm1pbmF0ZSgpOwpAQCAtODIsNyArODQsOSBAQCB2b2lkIFN0b3JhZ2VTeW5jTWFu YWdlcjo6Y2xvc2UoKQogCiBib29sIFN0b3JhZ2VTeW5jTWFuYWdlcjo6c2NoZWR1bGVJbXBvcnQo UGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCiB7CisjaWYgIVBMQVRGT1JNKFdJTkNF KQogICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisjZW5kaWYKIAogICAgIGlmIChtX3RocmVh ZCkKICAgICAgICAgbV90aHJlYWQtPnNjaGVkdWxlSW1wb3J0KGFyZWEpOwpAQCAtOTIsNyArOTYs OSBAQCBib29sIFN0b3JhZ2VTeW5jTWFuYWdlcjo6c2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxT dG9yYWdlQXJlYVN5bmM+IGFyZWEpCiAKIHZvaWQgU3RvcmFnZVN5bmNNYW5hZ2VyOjpzY2hlZHVs ZVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCiB7CisjaWYgIVBMQVRGT1JN KFdJTkNFKQogICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisjZW5kaWYKIAogICAgIGlmICht X3RocmVhZCkKICAgICAgICAgbV90aHJlYWQtPnNjaGVkdWxlU3luYyhhcmVhKTsK 35081 2009-08-18 15:10:57 -0700 2009-08-19 07:41:14 -0700 refactored 28019.patch text/plain 34015 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg OGQ3ZDUxNS4uZmQ4OTUzNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAwOS0wOC0xOCAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u CisgICAgICAgIFRoaXMgcGF0Y2ggYWxzbyByZXBsYWNlcyBzdG9yYWdlL3dpbmNlCisgICAgICAg IHdpdGggc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI4MDE5CisKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmg6CisgICAgICAgICogc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaDoKKyAgICAg ICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oOgorICAgICAgICAqIHN0b3JhZ2Uvc2luZ2xl LXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcDogUmVuYW1lZCBmcm9tIFdlYkNvcmUvc3RvcmFn ZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNlLmNwcC4KKyAgICAgICAgKiBzdG9yYWdlL3Npbmds ZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5oOiBSZW5hbWVkIGZyb20gV2ViQ29yZS9zdG9yYWdl L3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaC4KKyAgICAgICAgKiBzdG9yYWdlL3NpbmdsZS10 aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3BwOiBSZW5hbWVkIGZyb20gV2ViQ29yZS9zdG9y YWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNwcC4KKyAgICAgICAgKiBzdG9yYWdl L3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuaDogUmVuYW1lZCBmcm9tIFdlYkNv cmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oLgorICAgICAgICAqIHN0 b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL1N0b3JhZ2VBcmVhU3luYy5jcHA6IEFkZGVkLgorIAogMjAw OS0wOC0xOCAgQXJpeWEgSGlkYXlhdCAgPGFyaXlhLmhpZGF5YXRAbm9raWEuY29tPgogCiAgICAg ICAgIFVucmV2aWV3ZWQsIGJ1aWxkIGZpeC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9E YXRhYmFzZVRocmVhZC5oIGIvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgKaW5kZXgg NTlkN2E1ZC4uODlmYzIxMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhy ZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgKQEAgLTEsNSArMSw2 IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA3LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjks NiArMzAsMTMgQEAKICNkZWZpbmUgRGF0YWJhc2VUaHJlYWRfaAogCiAjaWYgRU5BQkxFKERBVEFC QVNFKQorCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKworI2luY2x1ZGUgInNpbmdsZS10 aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5oIgorCisjZWxzZQorCiAjaW5jbHVkZSA8d3RmL0RlcXVl Lmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgpA QCAtODUsNSArOTMsNyBAQCBwcml2YXRlOgogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKKyNl bmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorCiAjZW5kaWYgLy8gRU5BQkxFKERBVEFC QVNFKQogI2VuZGlmIC8vIERhdGFiYXNlVGhyZWFkX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3Rv cmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VU aHJlYWQuaAppbmRleCAzZDU4NDI3Li4xNzZlMjc5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3Jh Z2UvTG9jYWxTdG9yYWdlVGhyZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFn ZVRocmVhZC5oCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBcHBs ZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2gg TW9iaWxlLCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKQEAgLTI4LDYgKzI5LDEyIEBACiAKICNpZiBFTkFCTEUoRE9NX1NUT1JBR0UpCiAK KyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorCisjaW5jbHVkZSAic2luZ2xlLXRocmVhZGVk L0xvY2FsU3RvcmFnZVRocmVhZC5oIgorCisjZWxzZQorCiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQu aD4KICNpbmNsdWRlIDx3dGYvTWVzc2FnZVF1ZXVlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQ dHIuaD4KQEAgLTcxLDYgKzc4LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiB9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCiAKKyNlbmRpZiAvLyAjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKwog I2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKIAogI2VuZGlmIC8vIExvY2FsU3RvcmFnZVRo cmVhZF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmggYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKaW5kZXggZTQzNmJlZi4uOGUyYmM2MiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCisrKyBiL1dlYkNv cmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaApAQCAtNzgsMTUgKzc4LDE3IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzeW5jVGltZXJGaXJlZChUaW1lcjxTdG9yYWdlQXJl YVN5bmM+Kik7CiAgICAgICAgIHZvaWQgc3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hN YXA8U3RyaW5nLCBTdHJpbmc+JiBpdGVtcyk7CiAKLSAgICAgICAgTXV0ZXggbV9zeW5jTG9jazsK ICAgICAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4gbV9pdGVtc1BlbmRpbmdTeW5jOwogICAg ICAgICBib29sIG1fY2xlYXJJdGVtc1doaWxlU3luY2luZzsKICAgICAgICAgYm9vbCBtX3N5bmNT Y2hlZHVsZWQ7CiAKKyNpZiAhRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyAgICAgICAgTXV0ZXgg bV9zeW5jTG9jazsKICAgICAgICAgbXV0YWJsZSBNdXRleCBtX2ltcG9ydExvY2s7CiAgICAgICAg IG11dGFibGUgVGhyZWFkQ29uZGl0aW9uIG1faW1wb3J0Q29uZGl0aW9uOwogICAgICAgICBtdXRh YmxlIGJvb2wgbV9pbXBvcnRDb21wbGV0ZTsKICAgICAgICAgdm9pZCBtYXJrSW1wb3J0ZWQoKTsK KyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dl YkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3BwIGIvV2ViQ29y ZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDgxMTQ1ZAotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNv cmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3BwCkBAIC0wLDAgKzEs OTUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJh cnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqICB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRo IEZsb29yLAorICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgorCisjaW5jbHVkZSAiRGF0 YWJhc2UuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitEYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQorOiBtX3RpbWVyKHRoaXMsICZE YXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZCkKK3sKK30KKworRGF0YWJhc2VUaHJlYWQ6On5EYXRh YmFzZVRocmVhZCgpCit7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5h dGlvbigpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworfQorCitib29sIERhdGFiYXNlVGhyZWFk Ojp0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcXVldWUuaXNF bXB0eSgpOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPERhdGFi YXNlVGhyZWFkPiopCit7CisgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkgeworICAgICAgICBS ZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOworICAgICAgICB0YXNr LT5wZXJmb3JtVGFzaygpOworICAgICAgICBtX3F1ZXVlLnJlbW92ZUZpcnN0KCk7CisgICAgICAg IGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpCisgICAgICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hv dCgwKTsKKyAgICB9Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlVGFzayhQYXNz UmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKK3sKKyAgICBtX3F1ZXVlLmFwcGVuZCh0YXNrKTsK KyAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKKyAgICAgICAgbV90aW1lci5zdGFydE9uZVNo b3QoMCk7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlSW1tZWRpYXRlVGFzayhQ YXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKK3sKKyAgICB0YXNrLT5wZXJmb3JtVGFzaygp OworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRh YmFzZSogZGF0YWJhc2UpCit7CisgICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiByZXNl cnZlZFRhc2tzOworICAgIGZvciAoRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPjo6Y29uc3Rf aXRlcmF0b3IgaSA9IG1fcXVldWUuYmVnaW4oKTsgaSAhPSBtX3F1ZXVlLmVuZCgpOyArK2kpIHsK KyAgICAgICAgaWYgKCgqaSktPmRhdGFiYXNlKCkgIT0gZGF0YWJhc2UpCisgICAgICAgICAgICBy ZXNlcnZlZFRhc2tzLmFwcGVuZCgqaSk7CisgICAgfQorCisgICAgbV9xdWV1ZS5zd2FwKHJlc2Vy dmVkVGFza3MpOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZU9wZW4o RGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQg RGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKiBkYXRhYmFzZSkK K3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFk LmggYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmFmYzc5MQotLS0gL2Rldi9udWxsCisr KyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuaApAQCAt MCwwICsxLDY1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg KiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisj aWZuZGVmIERhdGFiYXNlVGhyZWFkV2luY2VfaAorI2RlZmluZSBEYXRhYmFzZVRocmVhZFdpbmNl X2gKKworI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+ CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworICAgIGNsYXNzIERhdGFiYXNlOworICAgIGNsYXNz IERhdGFiYXNlVGFzazsKKworICAgIGNsYXNzIERhdGFiYXNlVGhyZWFkOiBwdWJsaWMgV1RGOjpS ZWZDb3VudGVkPERhdGFiYXNlVGhyZWFkPiB7CisKKyAgICBwdWJsaWM6CisgICAgICAgIHN0YXRp YyBQYXNzUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBhZG9wdFJlZihu ZXcgRGF0YWJhc2VUaHJlYWQpOyB9CisgICAgICAgIH5EYXRhYmFzZVRocmVhZCgpOworCisgICAg ICAgIGJvb2wgc3RhcnQoKSB7IHJldHVybiB0cnVlOyB9CisgICAgICAgIHZvaWQgcmVxdWVzdFRl cm1pbmF0aW9uKCk7CisgICAgICAgIGJvb2wgdGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsK KworICAgICAgICB2b2lkIHNjaGVkdWxlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOwor ICAgICAgICB2b2lkIHNjaGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFz az4pOworICAgICAgICB2b2lkIHVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNlKik7Cisg ICAgICAgIHZvaWQgcmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7CisgICAgICAgIHZvaWQg cmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqKTsKKyNpZm5kZWYgTkRFQlVHCisgICAgICAg IFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSBjb25zdCB7IHJldHVybiBjdXJyZW50VGhy ZWFkKCk7IH0KKyNlbmRpZgorCisgICAgcHJpdmF0ZToKKyAgICAgICAgRGF0YWJhc2VUaHJlYWQo KTsKKworICAgICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+Kik7CisK KyAgICAgICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOworICAgICAgICBU aW1lcjxEYXRhYmFzZVRocmVhZD4gbV90aW1lcjsKKyAgICB9OworCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBEYXRhYmFzZVRocmVhZFdpbmNlCmRpZmYgLS1naXQgYS9XZWJD b3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHAgYi9XZWJD b3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHAKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGRjYjkwMgotLS0gL2Rldi9udWxsCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNwcApA QCAtMCwwICsxLDgzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAorICogIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3Ry ZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhyZWFkLmgiCisK KyNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCisjaW5jbHVkZSAiU3RvcmFnZUFyZWFTeW5j LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworTG9jYWxTdG9yYWdlVGhyZWFkOjpMb2NhbFN0 b3JhZ2VUaHJlYWQoKQorOiBtX3RpbWVyKHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVy RmlyZWQpCit7Cit9CisKK0xvY2FsU3RvcmFnZVRocmVhZDo6fkxvY2FsU3RvcmFnZVRocmVhZCgp Cit7Cit9CisKK2Jvb2wgTG9jYWxTdG9yYWdlVGhyZWFkOjpzdGFydCgpCit7CisgICAgcmV0dXJu IHRydWU7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPExv Y2FsU3RvcmFnZVRocmVhZD4qKQoreworICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpIHsKKyAg ICAgICAgUmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7Cisg ICAgICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7CisgICAgICAgIG1fcXVldWUucmVtb3ZlRmlyc3Qo KTsKKyAgICAgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIG1fdGltZXIu c3RhcnRPbmVTaG90KDApOworICAgIH0KK30KKwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnNj aGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQoreworICAgIG1f cXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0ZUltcG9ydChhcmVhKSk7CisgICAg aWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDAp OworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1bGVTeW5jKFBhc3NSZWZQdHI8 U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQoreworICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFn ZVRhc2s6OmNyZWF0ZVN5bmMoYXJlYSkpOworICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQor ICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBMb2NhbFN0b3JhZ2VU aHJlYWQ6OnRlcm1pbmF0ZSgpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1fdGltZXIu c3RvcCgpOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6cGVyZm9ybVRlcm1pbmF0ZSgp Cit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1fdGltZXIuc3RvcCgpOworfQorCit9CmRp ZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRo cmVhZC5oIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJl YWQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMDBhYmI1Ci0tLSAvZGV2 L251bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VU aHJlYWQuaApAQCAtMCwwICsxLDU4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNo IE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVs LAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVT QS4KKyAqLworCisKKyNpZm5kZWYgTG9jYWxTdG9yYWdlVGhyZWFkV2luY2VfaAorI2RlZmluZSBM b2NhbFN0b3JhZ2VUaHJlYWRXaW5jZV9oCisKKyNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KKyNpbmNs dWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKyAgICBjbGFz cyBTdG9yYWdlQXJlYVN5bmM7CisgICAgY2xhc3MgTG9jYWxTdG9yYWdlVGFzazsKKworICAgIGNs YXNzIExvY2FsU3RvcmFnZVRocmVhZCA6IHB1YmxpYyBSZWZDb3VudGVkPExvY2FsU3RvcmFnZVRo cmVhZD4geworICAgIHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxTdG9y YWdlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxTdG9yYWdlVGhy ZWFkKTsgfQorCisgICAgICAgIH5Mb2NhbFN0b3JhZ2VUaHJlYWQoKTsKKyAgICAgICAgYm9vbCBz dGFydCgpOworICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFy ZWFTeW5jPik7CisgICAgICAgIHZvaWQgc2NoZWR1bGVTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZUFy ZWFTeW5jPik7CisgICAgICAgIHZvaWQgdGVybWluYXRlKCk7CisgICAgICAgIHZvaWQgcGVyZm9y bVRlcm1pbmF0ZSgpOworCisgICAgcHJpdmF0ZToKKyAgICAgICAgTG9jYWxTdG9yYWdlVGhyZWFk KCk7CisKKyAgICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPExvY2FsU3RvcmFnZVRocmVhZD4q KTsKKworICAgICAgICBEZXF1ZTxSZWZQdHI8TG9jYWxTdG9yYWdlVGFzaz4gPiBtX3F1ZXVlOwor ICAgICAgICBUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IG1fdGltZXI7CisgICAgfTsKKworfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gTG9jYWxTdG9yYWdlVGhyZWFkV2luY2Vf aApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJl YVN5bmMuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJlYVN5 bmMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFjMjFlN2MKLS0tIC9k ZXYvbnVsbAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL1N0b3JhZ2VBcmVh U3luYy5jcHAKQEAgLTAsMCArMSwyNzkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIw MDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5 IFRvcmNoIE1vYmlsZSwgSW5jLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S CisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4g CisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5o IgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorI2lu Y2x1ZGUgIkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJIVE1MRWxlbWVudC5oIgorI2luY2x1ZGUg IlNRTGl0ZVN0YXRlbWVudC5oIgorI2luY2x1ZGUgIlN0b3JhZ2VBcmVhSW1wbC5oIgorI2luY2x1 ZGUgIlN0b3JhZ2VTeW5jTWFuYWdlci5oIgorI2luY2x1ZGUgIlN1ZGRlblRlcm1pbmF0aW9uLmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworLy8gSWYgdGhlIFN0b3JhZ2VBcmVhIHVuZGVyZ29l cyByYXBpZCBjaGFuZ2VzLCBkb24ndCBzeW5jIGVhY2ggY2hhbmdlIHRvIGRpc2suCisvLyBJbnN0 ZWFkLCBxdWV1ZSB1cCBhIGJhdGNoIG9mIGl0ZW1zIHRvIHN5bmMgYW5kIGFjdHVhbGx5IGRvIHRo ZSBzeW5jIGF0IHRoZSBmb2xsb3dpbmcgaW50ZXJ2YWwuCitzdGF0aWMgY29uc3QgZG91YmxlIFN0 b3JhZ2VTeW5jSW50ZXJ2YWwgPSAxLjA7CisKK1Bhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBT dG9yYWdlQXJlYVN5bmM6OmNyZWF0ZShQYXNzUmVmUHRyPFN0b3JhZ2VTeW5jTWFuYWdlcj4gc3Rv cmFnZVN5bmNNYW5hZ2VyLCBQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhSW1wbD4gc3RvcmFnZUFyZWEp Cit7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBTdG9yYWdlQXJlYVN5bmMoc3RvcmFnZVN5bmNN YW5hZ2VyLCBzdG9yYWdlQXJlYSkpOworfQorCitTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VBcmVh U3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VTeW5jTWFuYWdlcj4gc3RvcmFnZVN5bmNNYW5hZ2VyLCBQ YXNzUmVmUHRyPFN0b3JhZ2VBcmVhSW1wbD4gc3RvcmFnZUFyZWEpCisgICAgOiBtX3N5bmNUaW1l cih0aGlzLCAmU3RvcmFnZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZCkKKyAgICAsIG1faXRlbXND bGVhcmVkKGZhbHNlKQorICAgICwgbV9maW5hbFN5bmNTY2hlZHVsZWQoZmFsc2UpCisgICAgLCBt X3N0b3JhZ2VBcmVhKHN0b3JhZ2VBcmVhKQorICAgICwgbV9zeW5jTWFuYWdlcihzdG9yYWdlU3lu Y01hbmFnZXIpCisgICAgLCBtX2NsZWFySXRlbXNXaGlsZVN5bmNpbmcoZmFsc2UpCisgICAgLCBt X3N5bmNTY2hlZHVsZWQoZmFsc2UpCit7CisgICAgcGVyZm9ybUltcG9ydCgpOworfQorCitTdG9y YWdlQXJlYVN5bmM6On5TdG9yYWdlQXJlYVN5bmMoKQoreworICAgIEFTU0VSVCghbV9zeW5jVGlt ZXIuaXNBY3RpdmUoKSk7Cit9CisKK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjpzY2hlZHVsZUZpbmFs U3luYygpCit7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICAvLyBGSVhNRTogV2Ug ZG8gdGhpcyB0byBhdm9pZCByYWNlcywgYnV0IGl0J2QgYmUgYmV0dGVyIHRvIG1ha2UgdGhpbmdz IHNhZmUgd2l0aG91dCBibG9ja2luZy4KKyAgICBibG9ja1VudGlsSW1wb3J0Q29tcGxldGUoKTsK KyAgICAKKyAgICBpZiAobV9zeW5jVGltZXIuaXNBY3RpdmUoKSkKKyAgICAgICAgbV9zeW5jVGlt ZXIuc3RvcCgpOworICAgIGVsc2UgeworICAgICAgICAvLyBUaGUgZm9sbG93aW5nIGlzIGJhbGFu Y2VkIGJ5IHRoZSBjYWxsIHRvIGVuYWJsZVN1ZGRlblRlcm1pbmF0aW9uIGluIHRoZQorICAgICAg ICAvLyBzeW5jVGltZXJGaXJlZCBmdW5jdGlvbi4KKyAgICAgICAgZGlzYWJsZVN1ZGRlblRlcm1p bmF0aW9uKCk7CisgICAgfQorICAgIC8vIEZJWE1FOiBUaGlzIGlzIHN5bmNocm9ub3VzLiAgV2Ug c2hvdWxkIGRvIGl0IG9uIHRoZSBiYWNrZ3JvdW5kIHByb2Nlc3MsIGJ1dAorICAgIC8vIHdlIHNo b3VsZCBkbyBpdCBzYWZlbHkuCisgICAgc3luY1RpbWVyRmlyZWQoJm1fc3luY1RpbWVyKTsKKyAg ICBtX2ZpbmFsU3luY1NjaGVkdWxlZCA9IHRydWU7Cit9CisKK3ZvaWQgU3RvcmFnZUFyZWFTeW5j OjpzY2hlZHVsZUl0ZW1Gb3JTeW5jKGNvbnN0IFN0cmluZyYga2V5LCBjb25zdCBTdHJpbmcmIHZh bHVlKQoreworICAgIEFTU0VSVCghbV9maW5hbFN5bmNTY2hlZHVsZWQpOworCisgICAgbV9jaGFu Z2VkSXRlbXMuc2V0KGtleSwgdmFsdWUpOworICAgIGlmICghbV9zeW5jVGltZXIuaXNBY3RpdmUo KSkgeworICAgICAgICBtX3N5bmNUaW1lci5zdGFydE9uZVNob3QoU3RvcmFnZVN5bmNJbnRlcnZh bCk7CisKKyAgICAgICAgLy8gVGhlIGZvbGxvd2luZyBpcyBiYWxhbmNlZCBieSB0aGUgY2FsbCB0 byBlbmFibGVTdWRkZW5UZXJtaW5hdGlvbiBpbiB0aGUKKyAgICAgICAgLy8gc3luY1RpbWVyRmly ZWQgZnVuY3Rpb24uCisgICAgICAgIGRpc2FibGVTdWRkZW5UZXJtaW5hdGlvbigpOworICAgIH0K K30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OnNjaGVkdWxlQ2xlYXIoKQoreworICAgIEFTU0VS VCghbV9maW5hbFN5bmNTY2hlZHVsZWQpOworCisgICAgbV9jaGFuZ2VkSXRlbXMuY2xlYXIoKTsK KyAgICBtX2l0ZW1zQ2xlYXJlZCA9IHRydWU7CisgICAgaWYgKCFtX3N5bmNUaW1lci5pc0FjdGl2 ZSgpKSB7CisgICAgICAgIG1fc3luY1RpbWVyLnN0YXJ0T25lU2hvdChTdG9yYWdlU3luY0ludGVy dmFsKTsKKworICAgICAgICAvLyBUaGUgZm9sbG93aW5nIGlzIGJhbGFuY2VkIGJ5IHRoZSBjYWxs IHRvIGVuYWJsZVN1ZGRlblRlcm1pbmF0aW9uIGluIHRoZQorICAgICAgICAvLyBzeW5jVGltZXJG aXJlZCBmdW5jdGlvbi4KKyAgICAgICAgZGlzYWJsZVN1ZGRlblRlcm1pbmF0aW9uKCk7CisgICAg fQorfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luY1RpbWVyRmlyZWQoVGltZXI8U3RvcmFn ZUFyZWFTeW5jPiopCit7CisgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGl0 ID0gbV9jaGFuZ2VkSXRlbXMuYmVnaW4oKTsKKyAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPjo6 aXRlcmF0b3IgZW5kID0gbV9jaGFuZ2VkSXRlbXMuZW5kKCk7CisgICAgCisgICAgeworICAgICAg ICBpZiAobV9pdGVtc0NsZWFyZWQpIHsKKyAgICAgICAgICAgIG1faXRlbXNQZW5kaW5nU3luYy5j bGVhcigpOworICAgICAgICAgICAgbV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nID0gdHJ1ZTsKKyAg ICAgICAgICAgIG1faXRlbXNDbGVhcmVkID0gZmFsc2U7CisgICAgICAgIH0KKworICAgICAgICBm b3IgKDsgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICAgICAgbV9pdGVtc1BlbmRpbmdTeW5jLnNl dChpdC0+Zmlyc3QuY29weSgpLCBpdC0+c2Vjb25kLmNvcHkoKSk7CisKKyAgICAgICAgaWYgKCFt X3N5bmNTY2hlZHVsZWQpIHsKKyAgICAgICAgICAgIG1fc3luY1NjaGVkdWxlZCA9IHRydWU7CisK KyAgICAgICAgICAgIC8vIFRoZSBmb2xsb3dpbmcgaXMgYmFsYW5jZWQgYnkgdGhlIGNhbGwgdG8g ZW5hYmxlU3VkZGVuVGVybWluYXRpb24gaW4gdGhlCisgICAgICAgICAgICAvLyBwZXJmb3JtU3lu YyBmdW5jdGlvbi4KKyAgICAgICAgICAgIGRpc2FibGVTdWRkZW5UZXJtaW5hdGlvbigpOworCisg ICAgICAgICAgICBtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZVN5bmModGhpcyk7CisgICAgICAgIH0K KyAgICB9CisKKyAgICAvLyBUaGUgZm9sbG93aW5nIGlzIGJhbGFuY2VkIGJ5IHRoZSBjYWxscyB0 byBkaXNhYmxlU3VkZGVuVGVybWluYXRpb24gaW4gdGhlCisgICAgLy8gc2NoZWR1bGVJdGVtRm9y U3luYywgc2NoZWR1bGVDbGVhciwgYW5kIHNjaGVkdWxlRmluYWxTeW5jIGZ1bmN0aW9ucy4KKyAg ICBlbmFibGVTdWRkZW5UZXJtaW5hdGlvbigpOworCisgICAgbV9jaGFuZ2VkSXRlbXMuY2xlYXIo KTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQoreworICAgIEFT U0VSVCghbV9kYXRhYmFzZS5pc09wZW4oKSk7CisKKyAgICBTdHJpbmcgZGF0YWJhc2VGaWxlbmFt ZSA9IG1fc3luY01hbmFnZXItPmZ1bGxEYXRhYmFzZUZpbGVuYW1lKG1fc3RvcmFnZUFyZWEtPnNl Y3VyaXR5T3JpZ2luKCkpOworCisgICAgaWYgKGRhdGFiYXNlRmlsZW5hbWUuaXNFbXB0eSgpKSB7 CisgICAgICAgIExPR19FUlJPUigiRmlsZW5hbWUgZm9yIGxvY2FsIHN0b3JhZ2UgZGF0YWJhc2Ug aXMgZW1wdHkgLSBjYW5ub3Qgb3BlbiBmb3IgcGVyc2lzdGVudCBzdG9yYWdlIik7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoIW1fZGF0YWJhc2Uub3BlbihkYXRhYmFzZUZpbGVu YW1lKSkgeworICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0byBvcGVuIGRhdGFiYXNlIGZpbGUg JXMgZm9yIGxvY2FsIHN0b3JhZ2UiLCBkYXRhYmFzZUZpbGVuYW1lLnV0ZjgoKS5kYXRhKCkpOwor ICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKCFtX2RhdGFiYXNlLmV4ZWN1dGVDb21t YW5kKCJDUkVBVEUgVEFCTEUgSUYgTk9UIEVYSVNUUyBJdGVtVGFibGUgKGtleSBURVhUIFVOSVFV RSBPTiBDT05GTElDVCBSRVBMQUNFLCB2YWx1ZSBURVhUIE5PVCBOVUxMIE9OIENPTkZMSUNUIEZB SUwpIikpIHsKKyAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIHRhYmxlIEl0ZW1U YWJsZSBmb3IgbG9jYWwgc3RvcmFnZSIpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIAor ICAgIFNRTGl0ZVN0YXRlbWVudCBxdWVyeShtX2RhdGFiYXNlLCAiU0VMRUNUIGtleSwgdmFsdWUg RlJPTSBJdGVtVGFibGUiKTsKKyAgICBpZiAocXVlcnkucHJlcGFyZSgpICE9IFNRTFJlc3VsdE9r KSB7CisgICAgICAgIExPR19FUlJPUigiVW5hYmxlIHRvIHNlbGVjdCBpdGVtcyBmcm9tIEl0ZW1U YWJsZSBmb3IgbG9jYWwgc3RvcmFnZSIpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIAor ICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+IGl0ZW1NYXA7CisKKyAgICBpbnQgcmVzdWx0ID0g cXVlcnkuc3RlcCgpOworICAgIHdoaWxlIChyZXN1bHQgPT0gU1FMUmVzdWx0Um93KSB7CisgICAg ICAgIGl0ZW1NYXAuc2V0KHF1ZXJ5LmdldENvbHVtblRleHQoMCksIHF1ZXJ5LmdldENvbHVtblRl eHQoMSkpOworICAgICAgICByZXN1bHQgPSBxdWVyeS5zdGVwKCk7CisgICAgfQorCisgICAgaWYg KHJlc3VsdCAhPSBTUUxSZXN1bHREb25lKSB7CisgICAgICAgIExPR19FUlJPUigiRXJyb3IgcmVh ZGluZyBpdGVtcyBmcm9tIEl0ZW1UYWJsZSBmb3IgbG9jYWwgc3RvcmFnZSIpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGl0 ID0gaXRlbU1hcC5iZWdpbigpOworICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+OjppdGVyYXRv ciBlbmQgPSBpdGVtTWFwLmVuZCgpOworICAgIAorICAgIGZvciAoOyBpdCAhPSBlbmQ7ICsraXQp CisgICAgICAgIG1fc3RvcmFnZUFyZWEtPmltcG9ydEl0ZW0oaXQtPmZpcnN0LCBpdC0+c2Vjb25k KTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50aWxJbXBvcnRDb21wbGV0ZSgp IGNvbnN0Cit7CisgICAgLy8gRklYTUU6IHdlIGNhbm5vdCBzdXBwb3J0IHRoaXMKK30KKwordm9p ZCBTdG9yYWdlQXJlYVN5bmM6OnN5bmMoYm9vbCBjbGVhckl0ZW1zLCBjb25zdCBIYXNoTWFwPFN0 cmluZywgU3RyaW5nPiYgaXRlbXMpCit7CisgICAgaWYgKCFtX2RhdGFiYXNlLmlzT3BlbigpKQor ICAgICAgICByZXR1cm47CisKKyAgICAvLyBJZiB0aGUgY2xlYXIgZmxhZyBpcyBzZXQsIHRoZW4g d2UgY2xlYXIgYWxsIGl0ZW1zIG91dCBiZWZvcmUgd2Ugd3JpdGUgYW55IG5ldyBvbmVzIGluLgor ICAgIGlmIChjbGVhckl0ZW1zKSB7CisgICAgICAgIFNRTGl0ZVN0YXRlbWVudCBjbGVhcihtX2Rh dGFiYXNlLCAiREVMRVRFIEZST00gSXRlbVRhYmxlIik7CisgICAgICAgIGlmIChjbGVhci5wcmVw YXJlKCkgIT0gU1FMUmVzdWx0T2spIHsKKyAgICAgICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRv IHByZXBhcmUgY2xlYXIgc3RhdGVtZW50IC0gY2Fubm90IHdyaXRlIHRvIGxvY2FsIHN0b3JhZ2Ug ZGF0YWJhc2UiKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICAKKyAg ICAgICAgaW50IHJlc3VsdCA9IGNsZWFyLnN0ZXAoKTsKKyAgICAgICAgaWYgKHJlc3VsdCAhPSBT UUxSZXN1bHREb25lKSB7CisgICAgICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0byBjbGVhciBh bGwgaXRlbXMgaW4gdGhlIGxvY2FsIHN0b3JhZ2UgZGF0YWJhc2UgLSAlaSIsIHJlc3VsdCk7Cisg ICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBTUUxpdGVTdGF0ZW1l bnQgaW5zZXJ0KG1fZGF0YWJhc2UsICJJTlNFUlQgSU5UTyBJdGVtVGFibGUgVkFMVUVTICg/LCA/ KSIpOworICAgIGlmIChpbnNlcnQucHJlcGFyZSgpICE9IFNRTFJlc3VsdE9rKSB7CisgICAgICAg IExPR19FUlJPUigiRmFpbGVkIHRvIHByZXBhcmUgaW5zZXJ0IHN0YXRlbWVudCAtIGNhbm5vdCB3 cml0ZSB0byBsb2NhbCBzdG9yYWdlIGRhdGFiYXNlIik7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBTUUxpdGVTdGF0ZW1lbnQgcmVtb3ZlKG1fZGF0YWJhc2UsICJERUxFVEUgRlJPTSBJ dGVtVGFibGUgV0hFUkUga2V5PT8iKTsKKyAgICBpZiAocmVtb3ZlLnByZXBhcmUoKSAhPSBTUUxS ZXN1bHRPaykgeworICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0byBwcmVwYXJlIGRlbGV0ZSBz dGF0ZW1lbnQgLSBjYW5ub3Qgd3JpdGUgdG8gbG9jYWwgc3RvcmFnZSBkYXRhYmFzZSIpOworICAg ICAgICByZXR1cm47CisgICAgfQorCisgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46OmNvbnN0 X2l0ZXJhdG9yIGVuZCA9IGl0ZW1zLmVuZCgpOworCisgICAgZm9yIChIYXNoTWFwPFN0cmluZywg U3RyaW5nPjo6Y29uc3RfaXRlcmF0b3IgaXQgPSBpdGVtcy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsr aXQpIHsKKyAgICAgICAgLy8gQmFzZWQgb24gdGhlIG51bGwtbmVzcyBvZiB0aGUgc2Vjb25kIGFy Z3VtZW50LCBkZWNpZGUgd2hldGhlciB0aGlzIGlzIGFuIGluc2VydCBvciBhIGRlbGV0ZS4KKyAg ICAgICAgU1FMaXRlU3RhdGVtZW50JiBxdWVyeSA9IGl0LT5zZWNvbmQuaXNOdWxsKCkgPyByZW1v dmUgOiBpbnNlcnQ7ICAgICAgICAKKworICAgICAgICBxdWVyeS5iaW5kVGV4dCgxLCBpdC0+Zmly c3QpOworCisgICAgICAgIC8vIElmIHRoZSBzZWNvbmQgYXJndW1lbnQgaXMgbm9uLW51bGwsIHdl J3JlIGRvaW5nIGFuIGluc2VydCwgc28gYmluZCBpdCBhcyB0aGUgdmFsdWUuIAorICAgICAgICBp ZiAoIWl0LT5zZWNvbmQuaXNOdWxsKCkpCisgICAgICAgICAgICBxdWVyeS5iaW5kVGV4dCgyLCBp dC0+c2Vjb25kKTsKKworICAgICAgICBpbnQgcmVzdWx0ID0gcXVlcnkuc3RlcCgpOworICAgICAg ICBpZiAocmVzdWx0ICE9IFNRTFJlc3VsdERvbmUpIHsKKyAgICAgICAgICAgIExPR19FUlJPUigi RmFpbGVkIHRvIHVwZGF0ZSBpdGVtIGluIHRoZSBsb2NhbCBzdG9yYWdlIGRhdGFiYXNlIC0gJWki LCByZXN1bHQpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKworICAgICAgICBxdWVy eS5yZXNldCgpOworICAgIH0KK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1TeW5j KCkKK3sKKyAgICBib29sIGNsZWFySXRlbXM7CisgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4g aXRlbXM7CisgICAgeworICAgICAgICBBU1NFUlQobV9zeW5jU2NoZWR1bGVkKTsKKworICAgICAg ICBjbGVhckl0ZW1zID0gbV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nOworICAgICAgICBtX2l0ZW1z UGVuZGluZ1N5bmMuc3dhcChpdGVtcyk7CisKKyAgICAgICAgbV9jbGVhckl0ZW1zV2hpbGVTeW5j aW5nID0gZmFsc2U7CisgICAgICAgIG1fc3luY1NjaGVkdWxlZCA9IGZhbHNlOworICAgIH0KKwor ICAgIHN5bmMoY2xlYXJJdGVtcywgaXRlbXMpOworCisgICAgLy8gVGhlIGZvbGxvd2luZyBpcyBi YWxhbmNlZCBieSB0aGUgY2FsbCB0byBkaXNhYmxlU3VkZGVuVGVybWluYXRpb24gaW4gdGhlCisg ICAgLy8gc3luY1RpbWVyRmlyZWQgZnVuY3Rpb24uCisgICAgZW5hYmxlU3VkZGVuVGVybWluYXRp b24oKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKERP TV9TVE9SQUdFKQorCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VU aHJlYWRXaW5jZS5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5j ZS5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ4MTE0NWQuLjAwMDAwMDAKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwCisrKyAvZGV2 L251bGwKQEAgLTEsOTUgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBN b2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBs aWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwK LSAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgotICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bwotICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5r bGluIFN0cmVldCwgRmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0Eu Ci0gKi8KLQotI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgi Ci0KLSNpbmNsdWRlICJEYXRhYmFzZS5oIgotI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgotCi1u YW1lc3BhY2UgV2ViQ29yZSB7Ci0KLURhdGFiYXNlVGhyZWFkOjpEYXRhYmFzZVRocmVhZCgpCi06 IG1fdGltZXIodGhpcywgJkRhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKQotewotfQotCi1EYXRh YmFzZVRocmVhZDo6fkRhdGFiYXNlVGhyZWFkKCkKLXsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVh ZDo6cmVxdWVzdFRlcm1pbmF0aW9uKCkKLXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7Ci19Ci0KLWJv b2wgRGF0YWJhc2VUaHJlYWQ6OnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkgY29uc3QKLXsKLSAgICBy ZXR1cm4gbV9xdWV1ZS5pc0VtcHR5KCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnRpbWVy RmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+KikKLXsKLSAgICBpZiAoIW1fcXVldWUuaXNFbXB0 eSgpKSB7Ci0gICAgICAgIFJlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0 KCk7Ci0gICAgICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Ci0gICAgICAgIG1fcXVldWUucmVtb3Zl Rmlyc3QoKTsKLSAgICAgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKLSAgICAgICAgICAgIG1f dGltZXIuc3RhcnRPbmVTaG90KDApOwotICAgIH0KLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6 c2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrKQotewotICAgIG1fcXVl dWUuYXBwZW5kKHRhc2spOwotICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQotICAgICAgICBt X3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1 bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrKQotewotICAgIHRh c2stPnBlcmZvcm1UYXNrKCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVE YXRhYmFzZVRhc2tzKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBEZXF1ZTxSZWZQdHI8RGF0 YWJhc2VUYXNrPiA+IHJlc2VydmVkVGFza3M7Ci0gICAgZm9yIChEZXF1ZTxSZWZQdHI8RGF0YWJh c2VUYXNrPiA+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9xdWV1ZS5iZWdpbigpOyBpICE9IG1fcXVl dWUuZW5kKCk7ICsraSkgewotICAgICAgICBpZiAoKCppKS0+ZGF0YWJhc2UoKSAhPSBkYXRhYmFz ZSkKLSAgICAgICAgICAgIHJlc2VydmVkVGFza3MuYXBwZW5kKCppKTsKLSAgICB9Ci0KLSAgICBt X3F1ZXVlLnN3YXAocmVzZXJ2ZWRUYXNrcyk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJl Y29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgbm90SW1wbGVtZW50 ZWQoKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0 YWJhc2UqIGRhdGFiYXNlKQotewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci19Ci0KLX0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFz ZVRocmVhZFdpbmNlLmggYi9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5j ZS5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmYWZjNzkxLi4wMDAwMDAwCi0tLSBh L1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNlLmgKKysrIC9kZXYvbnVs bApAQCAtMSw2NSArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmls ZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAotICog IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KLSAq LwotCi0jaWZuZGVmIERhdGFiYXNlVGhyZWFkV2luY2VfaAotI2RlZmluZSBEYXRhYmFzZVRocmVh ZFdpbmNlX2gKLQotI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgotI2luY2x1ZGUgPHd0Zi9SZWZDb3Vu dGVkLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotICAgIGNsYXNzIERhdGFiYXNlOwotICAg IGNsYXNzIERhdGFiYXNlVGFzazsKLQotICAgIGNsYXNzIERhdGFiYXNlVGhyZWFkOiBwdWJsaWMg V1RGOjpSZWZDb3VudGVkPERhdGFiYXNlVGhyZWFkPiB7Ci0KLSAgICBwdWJsaWM6Ci0gICAgICAg IHN0YXRpYyBQYXNzUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBhZG9w dFJlZihuZXcgRGF0YWJhc2VUaHJlYWQpOyB9Ci0gICAgICAgIH5EYXRhYmFzZVRocmVhZCgpOwot Ci0gICAgICAgIGJvb2wgc3RhcnQoKSB7IHJldHVybiB0cnVlOyB9Ci0gICAgICAgIHZvaWQgcmVx dWVzdFRlcm1pbmF0aW9uKCk7Ci0gICAgICAgIGJvb2wgdGVybWluYXRpb25SZXF1ZXN0ZWQoKSBj b25zdDsKLQotICAgICAgICB2b2lkIHNjaGVkdWxlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFz az4pOwotICAgICAgICB2b2lkIHNjaGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVmUHRyPERhdGFi YXNlVGFzaz4pOwotICAgICAgICB2b2lkIHVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNl Kik7Ci0gICAgICAgIHZvaWQgcmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7Ci0gICAgICAg IHZvaWQgcmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqKTsKLSNpZm5kZWYgTkRFQlVHCi0g ICAgICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSBjb25zdCB7IHJldHVybiBjdXJy ZW50VGhyZWFkKCk7IH0KLSNlbmRpZgotCi0gICAgcHJpdmF0ZToKLSAgICAgICAgRGF0YWJhc2VU aHJlYWQoKTsKLQotICAgICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+ Kik7Ci0KLSAgICAgICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOwotICAg ICAgICBUaW1lcjxEYXRhYmFzZVRocmVhZD4gbV90aW1lcjsKLSAgICB9OwotCi19IC8vIG5hbWVz cGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBEYXRhYmFzZVRocmVhZFdpbmNlCmRpZmYgLS1naXQg YS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3BwIGIvV2Vi Q29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNwcApkZWxldGVkIGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggOGRjYjkwMi4uMDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3Jh Z2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3BwCisrKyAvZGV2L251bGwKQEAgLTEs ODMgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICog YXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgot ICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwotICog IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0gKi8KLQotI2lu Y2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRocmVhZC5oIgotCi0jaW5j bHVkZSAiTG9jYWxTdG9yYWdlVGFzay5oIgotI2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5oIgot Ci1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLUxvY2FsU3RvcmFnZVRocmVhZDo6TG9jYWxTdG9yYWdl VGhyZWFkKCkKLTogbV90aW1lcih0aGlzLCAmTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVk KQotewotfQotCi1Mb2NhbFN0b3JhZ2VUaHJlYWQ6On5Mb2NhbFN0b3JhZ2VUaHJlYWQoKQotewot fQotCi1ib29sIExvY2FsU3RvcmFnZVRocmVhZDo6c3RhcnQoKQotewotICAgIHJldHVybiB0cnVl OwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxMb2NhbFN0 b3JhZ2VUaHJlYWQ+KikKLXsKLSAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKSB7Ci0gICAgICAg IFJlZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOwotICAgICAg ICB0YXNrLT5wZXJmb3JtVGFzaygpOwotICAgICAgICBtX3F1ZXVlLnJlbW92ZUZpcnN0KCk7Ci0g ICAgICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpCi0gICAgICAgICAgICBtX3RpbWVyLnN0YXJ0 T25lU2hvdCgwKTsKLSAgICB9Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVs ZUltcG9ydChQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4gYXJlYSkKLXsKLSAgICBtX3F1ZXVl LmFwcGVuZChMb2NhbFN0b3JhZ2VUYXNrOjpjcmVhdGVJbXBvcnQoYXJlYSkpOwotICAgIGlmICgh bV90aW1lci5pc0FjdGl2ZSgpKQotICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0K LQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0b3Jh Z2VBcmVhU3luYz4gYXJlYSkKLXsKLSAgICBtX3F1ZXVlLmFwcGVuZChMb2NhbFN0b3JhZ2VUYXNr OjpjcmVhdGVTeW5jKGFyZWEpKTsKLSAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAgICAg ICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFk Ojp0ZXJtaW5hdGUoKQotewotICAgIG1fcXVldWUuY2xlYXIoKTsKLSAgICBtX3RpbWVyLnN0b3Ao KTsKLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnBlcmZvcm1UZXJtaW5hdGUoKQotewot ICAgIG1fcXVldWUuY2xlYXIoKTsKLSAgICBtX3RpbWVyLnN0b3AoKTsKLX0KLQotfQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmggYi9X ZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuaApkZWxldGVkIGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMzAwYWJiNS4uMDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3Jh Z2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuaAorKysgL2Rldi9udWxsCkBAIC0xLDU4 ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFy ZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAq ICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBT ZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBH TlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0aCB0aGlzIGxp YnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KLSAqICB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgotICovCi0KLQotI2lm bmRlZiBMb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZV9oCi0jZGVmaW5lIExvY2FsU3RvcmFnZVRocmVh ZFdpbmNlX2gKLQotI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgotI2luY2x1ZGUgPHd0Zi9QYXNzUmVm UHRyLmg+Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotICAgIGNsYXNzIFN0b3JhZ2VBcmVhU3lu YzsKLSAgICBjbGFzcyBMb2NhbFN0b3JhZ2VUYXNrOwotCi0gICAgY2xhc3MgTG9jYWxTdG9yYWdl VGhyZWFkIDogcHVibGljIFJlZkNvdW50ZWQ8TG9jYWxTdG9yYWdlVGhyZWFkPiB7Ci0gICAgcHVi bGljOgotICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IGNyZWF0 ZSgpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbFN0b3JhZ2VUaHJlYWQpOyB9Ci0KLSAgICAg ICAgfkxvY2FsU3RvcmFnZVRocmVhZCgpOwotICAgICAgICBib29sIHN0YXJ0KCk7Ci0gICAgICAg IHZvaWQgc2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+KTsKLSAgICAg ICAgdm9pZCBzY2hlZHVsZVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+KTsKLSAgICAg ICAgdm9pZCB0ZXJtaW5hdGUoKTsKLSAgICAgICAgdm9pZCBwZXJmb3JtVGVybWluYXRlKCk7Ci0K LSAgICBwcml2YXRlOgotICAgICAgICBMb2NhbFN0b3JhZ2VUaHJlYWQoKTsKLQotICAgICAgICB2 b2lkIHRpbWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOwotCi0gICAgICAgIERl cXVlPFJlZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7Ci0gICAgICAgIFRpbWVyPExv Y2FsU3RvcmFnZVRocmVhZD4gbV90aW1lcjsKLSAgICB9OwotCi19IC8vIG5hbWVzcGFjZSBXZWJD b3JlCi0KLSNlbmRpZiAvLyBMb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZV9oCg== 35120 2009-08-19 07:41:14 -0700 2009-08-21 07:51:51 -0700 more refactoring 28019.patch text/plain 31632 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg OGQ3ZDUxNS4uZGZjZWFmNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNyBAQAorMjAwOS0wOC0xOSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u CisgICAgICAgIFRoaXMgcGF0Y2ggYWxzbyByZXBsYWNlcyBzdG9yYWdlL3dpbmNlCisgICAgICAg IHdpdGggc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI4MDE5CisKKworICAgICAgICAqIHN0b3JhZ2UvRGF0YWJh c2VUaHJlYWQuaDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpjcmVhdGUpOgor ICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OmdldFRocmVhZElEKToKKyAgICAgICAg KFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjp0cmFuc2FjdGlvbkNvb3JkaW5hdG9yKToKKyAgICAg ICAgKiBzdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oOgorICAgICAgICAqIHN0b3JhZ2UvU3Rv cmFnZUFyZWFTeW5jLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6cGVy Zm9ybUltcG9ydCk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6Om1hcmtJbXBv cnRlZCk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnN5bmMpOgorICAgICAg ICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpwZXJmb3JtU3luYyk6CisgICAgICAgICogc3Rv cmFnZS9TdG9yYWdlQXJlYVN5bmMuaDoKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3lu Yzo6aXNCYWNrZ3JvdW5kVGhyZWFkKToKKyAgICAgICAgKiBzdG9yYWdlL3NpbmdsZS10aHJlYWRl ZC9EYXRhYmFzZVRocmVhZC5jcHA6IEFkZGVkLgorICAgICAgICAqIHN0b3JhZ2Uvc2luZ2xlLXRo cmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHA6IEFkZGVkLgorICAgICAgICAqIHN0b3JhZ2Uv c2luZ2xlLXRocmVhZGVkL1N0b3JhZ2VBcmVhU3luYy5jcHA6IEFkZGVkLgorICAgICAgICAoV2Vi Q29yZTo6U3RvcmFnZUFyZWFTeW5jOjpTdG9yYWdlQXJlYVN5bmMpOgorICAgICAgICAoV2ViQ29y ZTo6U3RvcmFnZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpT dG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFn ZUFyZWFTeW5jOjpibG9ja1VudGlsSW1wb3J0Q29tcGxldGUpOgorICAgICAgICAqIHN0b3JhZ2Uv d2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5jcHA6IFJlbW92ZWQuCisgICAgICAgICogc3RvcmFn ZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNlLmg6IFJlbW92ZWQuCisgICAgICAgICogc3RvcmFn ZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHA6IFJlbW92ZWQuCisgICAgICAgICog c3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oOiBSZW1vdmVkLgorIAogMjAw OS0wOC0xOCAgQXJpeWEgSGlkYXlhdCAgPGFyaXlhLmhpZGF5YXRAbm9raWEuY29tPgogCiAgICAg ICAgIFVucmV2aWV3ZWQsIGJ1aWxkIGZpeC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9E YXRhYmFzZVRocmVhZC5oIGIvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgKaW5kZXgg NTlkN2E1ZC4uZTYzYTcxOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhy ZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgKQEAgLTEsNSArMSw2 IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA3LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjks NiArMzAsNyBAQAogI2RlZmluZSBEYXRhYmFzZVRocmVhZF9oCiAKICNpZiBFTkFCTEUoREFUQUJB U0UpCisKICNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgog I2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CkBAIC00MCw0OCArNDIsNTggQEAKIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCi1jbGFzcyBEYXRhYmFzZTsKLWNsYXNzIERhdGFiYXNlVGFzazsKLWNsYXNz IERvY3VtZW50OwotY2xhc3MgU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcjsKLQotY2xhc3MgRGF0 YWJhc2VUaHJlYWQgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxEYXRhYmFzZVRocmVhZD4gewot cHVibGljOgotICAgIHN0YXRpYyBQYXNzUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBjcmVhdGUoKSB7 IHJldHVybiBhZG9wdFJlZihuZXcgRGF0YWJhc2VUaHJlYWQpOyB9Ci0gICAgfkRhdGFiYXNlVGhy ZWFkKCk7Ci0KLSAgICBib29sIHN0YXJ0KCk7Ci0gICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24o KTsKLSAgICBib29sIHRlcm1pbmF0aW9uUmVxdWVzdGVkKCkgY29uc3Q7Ci0KLSAgICB2b2lkIHNj aGVkdWxlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOwotICAgIHZvaWQgc2NoZWR1bGVJ bW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPik7IC8vIFRoaXMganVzdCBhZGRz IHRoZSB0YXNrIHRvIHRoZSBmcm9udCBvZiB0aGUgcXVldWUgLSB0aGUgY2FsbGVyIG5lZWRzIHRv IGJlIGV4dHJlbWVseSBjYXJlZnVsIG5vdCB0byBjcmVhdGUgZGVhZGxvY2tzIHdoZW4gd2FpdGlu ZyBmb3IgY29tcGxldGlvbi4KLSAgICB2b2lkIHVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFi YXNlKik7Ci0KLSAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOwotICAgIHZv aWQgcmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqKTsKLSAgICBUaHJlYWRJZGVudGlmaWVy IGdldFRocmVhZElEKCkgeyByZXR1cm4gbV90aHJlYWRJRDsgfQotCi0gICAgU1FMVHJhbnNhY3Rp b25Db29yZGluYXRvciogdHJhbnNhY3Rpb25Db29yZGluYXRvcigpIHsgcmV0dXJuIG1fdHJhbnNh Y3Rpb25Db29yZGluYXRvci5nZXQoKTsgfQotCi1wcml2YXRlOgotICAgIERhdGFiYXNlVGhyZWFk KCk7Ci0KLSAgICBzdGF0aWMgdm9pZCogZGF0YWJhc2VUaHJlYWRTdGFydCh2b2lkKik7Ci0gICAg dm9pZCogZGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIE11dGV4IG1fdGhyZWFkQ3JlYXRpb25NdXRl eDsKLSAgICBUaHJlYWRJZGVudGlmaWVyIG1fdGhyZWFkSUQ7Ci0gICAgUmVmUHRyPERhdGFiYXNl VGhyZWFkPiBtX3NlbGZSZWY7Ci0KLSAgICBNZXNzYWdlUXVldWU8UmVmUHRyPERhdGFiYXNlVGFz az4gPiBtX3F1ZXVlOwotCi0gICAgLy8gVGhpcyBzZXQga2VlcHMgdHJhY2sgb2YgdGhlIG9wZW4g ZGF0YWJhc2VzIHRoYXQgaGF2ZSBiZWVuIHVzZWQgb24gdGhpcyB0aHJlYWQuCi0gICAgdHlwZWRl ZiBIYXNoU2V0PFJlZlB0cjxEYXRhYmFzZT4gPiBEYXRhYmFzZVNldDsKLSAgICBEYXRhYmFzZVNl dCBtX29wZW5EYXRhYmFzZVNldDsKLQotICAgIE93blB0cjxTUUxUcmFuc2FjdGlvbkNvb3JkaW5h dG9yPiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3I7Ci19OworICAgIGNsYXNzIERhdGFiYXNlOwor ICAgIGNsYXNzIERhdGFiYXNlVGFzazsKKyAgICBjbGFzcyBEb2N1bWVudDsKKyAgICBjbGFzcyBT UUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOworCisgICAgY2xhc3MgRGF0YWJhc2VUaHJlYWQgOiBw dWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxEYXRhYmFzZVRocmVhZD4geworICAgIHB1YmxpYzoKKyAg ICAgICAgc3RhdGljIFBhc3NSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJu IGFkb3B0UmVmKG5ldyBEYXRhYmFzZVRocmVhZCk7IH0KKyAgICAgICAgfkRhdGFiYXNlVGhyZWFk KCk7CisKKyAgICAgICAgYm9vbCBzdGFydCgpOworICAgICAgICB2b2lkIHJlcXVlc3RUZXJtaW5h dGlvbigpOworICAgICAgICBib29sIHRlcm1pbmF0aW9uUmVxdWVzdGVkKCkgY29uc3Q7CisKKyAg ICAgICAgdm9pZCBzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsKKyAgICAg ICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsg Ly8gVGhpcyBqdXN0IGFkZHMgdGhlIHRhc2sgdG8gdGhlIGZyb250IG9mIHRoZSBxdWV1ZSAtIHRo ZSBjYWxsZXIgbmVlZHMgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwgbm90IHRvIGNyZWF0ZSBkZWFk bG9ja3Mgd2hlbiB3YWl0aW5nIGZvciBjb21wbGV0aW9uLgorICAgICAgICB2b2lkIHVuc2NoZWR1 bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNlKik7CisKKyAgICAgICAgdm9pZCByZWNvcmREYXRhYmFz ZU9wZW4oRGF0YWJhc2UqKTsKKyAgICAgICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChEYXRh YmFzZSopOworI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisgICAgICAgIFRocmVhZElkZW50 aWZpZXIgZ2V0VGhyZWFkSUQoKSB7IHJldHVybiBjdXJyZW50VGhyZWFkKCk7IH0KKyNlbHNlCisg ICAgICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSB7IHJldHVybiBtX3RocmVhZElE OyB9CisjZW5kaWYKKworICAgICAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2Fj dGlvbkNvb3JkaW5hdG9yKCkgeyByZXR1cm4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmdldCgp OyB9CisKKyAgICBwcml2YXRlOgorICAgICAgICBEYXRhYmFzZVRocmVhZCgpOworCisjaWYgRU5B QkxFKFNJTkdMRV9USFJFQURFRCkKKyAgICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPERhdGFi YXNlVGhyZWFkPiopOworCisgICAgICAgIERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9x dWV1ZTsKKyAgICAgICAgVGltZXI8RGF0YWJhc2VUaHJlYWQ+IG1fdGltZXI7CisjZWxzZQorICAg ICAgICBzdGF0aWMgdm9pZCogZGF0YWJhc2VUaHJlYWRTdGFydCh2b2lkKik7CisgICAgICAgIHZv aWQqIGRhdGFiYXNlVGhyZWFkKCk7CisKKyAgICAgICAgTXV0ZXggbV90aHJlYWRDcmVhdGlvbk11 dGV4OworICAgICAgICBUaHJlYWRJZGVudGlmaWVyIG1fdGhyZWFkSUQ7CisgICAgICAgIFJlZlB0 cjxEYXRhYmFzZVRocmVhZD4gbV9zZWxmUmVmOworCisgICAgICAgIE1lc3NhZ2VRdWV1ZTxSZWZQ dHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7CisKKyAgICAgICAgLy8gVGhpcyBzZXQga2VlcHMg dHJhY2sgb2YgdGhlIG9wZW4gZGF0YWJhc2VzIHRoYXQgaGF2ZSBiZWVuIHVzZWQgb24gdGhpcyB0 aHJlYWQuCisgICAgICAgIHR5cGVkZWYgSGFzaFNldDxSZWZQdHI8RGF0YWJhc2U+ID4gRGF0YWJh c2VTZXQ7CisgICAgICAgIERhdGFiYXNlU2V0IG1fb3BlbkRhdGFiYXNlU2V0OworI2VuZGlmCisg ICAgICAgIE93blB0cjxTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yPiBtX3RyYW5zYWN0aW9uQ29v cmRpbmF0b3I7CisgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCmRpZmYgLS1naXQg YS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9yYWdlVGhyZWFkLmggYi9XZWJDb3JlL3N0b3JhZ2Uv TG9jYWxTdG9yYWdlVGhyZWFkLmgKaW5kZXggM2Q1ODQyNy4uYjAxOWE1NiAxMDA2NDQKLS0tIGEv V2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oCisrKyBiL1dlYkNvcmUvc3RvcmFn ZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQg KEMpIDIwMDggQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICogQ29weXJpZ2h0IChD KSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgogICoKICAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOCw2ICsyOSw3IEBACiAKICNpZiBFTkFCTEUoRE9N X1NUT1JBR0UpCiAKKyNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KICNpbmNsdWRlIDx3dGYvSGFzaFNl dC5oPgogI2luY2x1ZGUgPHd0Zi9NZXNzYWdlUXVldWUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1Jl ZlB0ci5oPgpAQCAtNTYsNiArNTgsMTIgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIHByaXZh dGU6CiAgICAgICAgIExvY2FsU3RvcmFnZVRocmVhZCgpOwogCisjaWYgRU5BQkxFKFNJTkdMRV9U SFJFQURFRCkKKyAgICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPExvY2FsU3RvcmFnZVRocmVh ZD4qKTsKKworICAgICAgICBEZXF1ZTxSZWZQdHI8TG9jYWxTdG9yYWdlVGFzaz4gPiBtX3F1ZXVl OworICAgICAgICBUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IG1fdGltZXI7CisjZWxzZQogICAg ICAgICBzdGF0aWMgdm9pZCogbG9jYWxTdG9yYWdlVGhyZWFkU3RhcnQodm9pZCopOwogICAgICAg ICB2b2lkKiBsb2NhbFN0b3JhZ2VUaHJlYWQoKTsKIApAQCAtNjcsNiArNzUsNyBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAgICAgICAgIAogICAgICAgICBNdXRleCBtX3Rlcm1pbmF0ZUxvY2s7CiAg ICAgICAgIFRocmVhZENvbmRpdGlvbiBtX3Rlcm1pbmF0ZUNvbmRpdGlvbjsKKyNlbmRpZgogICAg IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFn ZS9TdG9yYWdlQXJlYVN5bmMuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5j cHAKaW5kZXggMDFkMmE2NS4uOTM2MTM0YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0 b3JhZ2VBcmVhU3luYy5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5j cHAKQEAgLTQ3LDYgKzQ3LDcgQEAgUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IFN0b3JhZ2VB cmVhU3luYzo6Y3JlYXRlKFBhc3NSZWZQdHI8U3RvcmFnZVN5bmNNYW5hZ2UKICAgICByZXR1cm4g YWRvcHRSZWYobmV3IFN0b3JhZ2VBcmVhU3luYyhzdG9yYWdlU3luY01hbmFnZXIsIHN0b3JhZ2VB cmVhKSk7CiB9CiAKKyNpZiAhRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKIFN0b3JhZ2VBcmVhU3lu Yzo6U3RvcmFnZUFyZWFTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZVN5bmNNYW5hZ2VyPiBzdG9yYWdl U3luY01hbmFnZXIsIFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFJbXBsPiBzdG9yYWdlQXJlYSkKICAg ICA6IG1fc3luY1RpbWVyKHRoaXMsICZTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKQog ICAgICwgbV9pdGVtc0NsZWFyZWQoZmFsc2UpCkBAIC02NSw2ICs2Niw3IEBAIFN0b3JhZ2VBcmVh U3luYzo6U3RvcmFnZUFyZWFTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZVN5bmNNYW5hZ2VyPiBzdG9y YWdlU3luY01hbmFnCiAgICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0aGlz KSkKICAgICAgICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7CiB9CisjZW5kaWYKIAogU3RvcmFn ZUFyZWFTeW5jOjp+U3RvcmFnZUFyZWFTeW5jKCkKIHsKQEAgLTEyMSw2ICsxMjMsNyBAQCB2b2lk IFN0b3JhZ2VBcmVhU3luYzo6c2NoZWR1bGVDbGVhcigpCiAgICAgfQogfQogCisjaWYgIUVOQUJM RShTSU5HTEVfVEhSRUFERUQpCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luY1RpbWVyRmlyZWQo VGltZXI8U3RvcmFnZUFyZWFTeW5jPiopCiB7CiAgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsK QEAgLTE2MCw3ICsxNjMsNyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luY1RpbWVyRmlyZWQo VGltZXI8U3RvcmFnZUFyZWFTeW5jPiopCiAKIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3Jt SW1wb3J0KCkKIHsKLSAgICBBU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoaXNC YWNrZ3JvdW5kVGhyZWFkKCkpOwogICAgIEFTU0VSVCghbV9kYXRhYmFzZS5pc09wZW4oKSk7CiAK ICAgICBTdHJpbmcgZGF0YWJhc2VGaWxlbmFtZSA9IG1fc3luY01hbmFnZXItPmZ1bGxEYXRhYmFz ZUZpbGVuYW1lKG1fc3RvcmFnZUFyZWEtPnNlY3VyaXR5T3JpZ2luKCkpOwpAQCAtMjIwLDcgKzIy Myw3IEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3JtSW1wb3J0KCkKIAogdm9pZCBTdG9y YWdlQXJlYVN5bmM6Om1hcmtJbXBvcnRlZCgpCiB7Ci0gICAgQVNTRVJUKCFpc01haW5UaHJlYWQo KSk7CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsKIAogICAgIE11dGV4TG9ja2Vy IGxvY2tlcihtX2ltcG9ydExvY2spOwogICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNs ZS4KQEAgLTI1MCwxMCArMjUzLDExIEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9ja1VudGls SW1wb3J0Q29tcGxldGUoKSBjb25zdAogICAgIEFTU0VSVChtX2ltcG9ydENvbXBsZXRlKTsKICAg ICBBU1NFUlQoIW1fc3RvcmFnZUFyZWEpOwogfQorI2VuZGlmCiAKIHZvaWQgU3RvcmFnZUFyZWFT eW5jOjpzeW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4m IGl0ZW1zKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0Jh Y2tncm91bmRUaHJlYWQoKSk7CiAKICAgICBpZiAoIW1fZGF0YWJhc2UuaXNPcGVuKCkpCiAgICAg ICAgIHJldHVybjsKQEAgLTMwOSwxMiArMzEzLDE0IEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpz eW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4mIGl0ZW1z CiAKIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3JtU3luYygpCiB7Ci0gICAgQVNTRVJUKCFp c01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsKIAogICAg IGJvb2wgY2xlYXJJdGVtczsKICAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiBpdGVtczsKICAg ICB7CisjaWYgIUVOQUJMRShTSU5HTEVfVEhSRUFERUQpCiAgICAgICAgIE11dGV4TG9ja2VyIGxv Y2tlcihtX3N5bmNMb2NrKTsKKyNlbmRpZgogCiAgICAgICAgIEFTU0VSVChtX3N5bmNTY2hlZHVs ZWQpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmggYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKaW5kZXggZTQzNmJlZi4uZTJmYmMzNCAx MDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCisrKyBiL1dlYkNv cmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaApAQCAtNzgsMTUgKzc4LDIwIEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgdm9pZCBzeW5jVGltZXJGaXJlZChUaW1lcjxTdG9yYWdlQXJl YVN5bmM+Kik7CiAgICAgICAgIHZvaWQgc3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hN YXA8U3RyaW5nLCBTdHJpbmc+JiBpdGVtcyk7CiAKLSAgICAgICAgTXV0ZXggbV9zeW5jTG9jazsK ICAgICAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4gbV9pdGVtc1BlbmRpbmdTeW5jOwogICAg ICAgICBib29sIG1fY2xlYXJJdGVtc1doaWxlU3luY2luZzsKICAgICAgICAgYm9vbCBtX3N5bmNT Y2hlZHVsZWQ7CiAKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICBib29sIGlz QmFja2dyb3VuZFRocmVhZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyNlbHNlCisgICAgICAg IE11dGV4IG1fc3luY0xvY2s7CiAgICAgICAgIG11dGFibGUgTXV0ZXggbV9pbXBvcnRMb2NrOwog ICAgICAgICBtdXRhYmxlIFRocmVhZENvbmRpdGlvbiBtX2ltcG9ydENvbmRpdGlvbjsKICAgICAg ICAgbXV0YWJsZSBib29sIG1faW1wb3J0Q29tcGxldGU7CiAgICAgICAgIHZvaWQgbWFya0ltcG9y dGVkKCk7CisgICAgICAgIGJvb2wgaXNCYWNrZ3JvdW5kVGhyZWFkKCkgY29uc3QgeyByZXR1cm4g IWlzTWFpblRocmVhZCgpOyB9CisjZW5kaWYKICAgICB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNl VGhyZWFkLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJl YWQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNkNjljNjAKLS0tIC9k ZXYvbnVsbAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhy ZWFkLmNwcApAQCAtMCwwICsxLDEwNyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBUb3Jj aCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiAgVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1 bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZl ZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqICBh bG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90 LCB3cml0ZSB0bworICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZy YW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBV U0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFk LmgiCisKKyNpZiBFTkFCTEUoRE9NX1NUT1JBR0UpCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURF RCkKKworI2luY2x1ZGUgIkRhdGFiYXNlLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUYXNrLmgiCisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKworRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkK KzogbV90aW1lcih0aGlzLCAmRGF0YWJhc2VUaHJlYWQ6OnRpbWVyRmlyZWQpCit7Cit9CisKK0Rh dGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQoKQoreworfQorCitib29sIERhdGFiYXNlVGhy ZWFkOjpzdGFydCgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJl YWQ6OnJlcXVlc3RUZXJtaW5hdGlvbigpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworfQorCiti b29sIERhdGFiYXNlVGhyZWFkOjp0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0Cit7CisgICAg cmV0dXJuIG1fcXVldWUuaXNFbXB0eSgpOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjp0aW1l ckZpcmVkKFRpbWVyPERhdGFiYXNlVGhyZWFkPiopCit7CisgICAgaWYgKG1fcXVldWUuaXNFbXB0 eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrID0g bV9xdWV1ZS5maXJzdCgpOworICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7CisgICAgbV9xdWV1ZS5y ZW1vdmVGaXJzdCgpOworICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpCisgICAgICAgIG1fdGlt ZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjpzY2hlZHVsZVRh c2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCit7CisgICAgbV9xdWV1ZS5hcHBlbmQo dGFzayk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3Rh cnRPbmVTaG90KDApOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjpzY2hlZHVsZUltbWVkaWF0 ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCit7CisgICAgdGFzay0+cGVyZm9y bVRhc2soKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6dW5zY2hlZHVsZURhdGFiYXNlVGFz a3MoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ ID4gcmVzZXJ2ZWRUYXNrczsKKyAgICBmb3IgKERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID46 OmNvbnN0X2l0ZXJhdG9yIGkgPSBtX3F1ZXVlLmJlZ2luKCk7IGkgIT0gbV9xdWV1ZS5lbmQoKTsg KytpKSB7CisgICAgICAgIGlmICgoKmkpLT5kYXRhYmFzZSgpICE9IGRhdGFiYXNlKQorICAgICAg ICAgICAgcmVzZXJ2ZWRUYXNrcy5hcHBlbmQoKmkpOworICAgIH0KKworICAgIG1fcXVldWUuc3dh cChyZXNlcnZlZFRhc2tzKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6cmVjb3JkRGF0YWJh c2VPcGVuKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQor Cit2b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZUNsb3NlZChEYXRhYmFzZSogZGF0 YWJhc2UpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyNlbmRpZiAvLyBFTkFC TEUoRE9NX1NUT1JBR0UpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVh ZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVh ZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uMzVhZGRhOAotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUt dGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNwcApAQCAtMCwwICsxLDkwIEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhv cGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAg WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZp bGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBC b3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhyZWFkLmgiCisKKyNpZiBFTkFCTEUoRE9NX1NUT1JBR0Up CisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKworI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRh c2suaCIKKyNpbmNsdWRlICJTdG9yYWdlQXJlYVN5bmMuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitQYXNzUmVmUHRyPExvY2FsU3RvcmFnZVRocmVhZD4gTG9jYWxTdG9yYWdlVGhyZWFkOjpj cmVhdGUoKQoreworICAgIHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxTdG9yYWdlVGhyZWFkKTsK K30KKworTG9jYWxTdG9yYWdlVGhyZWFkOjpMb2NhbFN0b3JhZ2VUaHJlYWQoKQorOiBtX3RpbWVy KHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVyRmlyZWQpCit7Cit9CisKK2Jvb2wgTG9j YWxTdG9yYWdlVGhyZWFkOjpzdGFydCgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQg TG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPExvY2FsU3RvcmFnZVRocmVhZD4q KQoreworICAgIGlmIChtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAg UmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7CisgICAgdGFz ay0+cGVyZm9ybVRhc2soKTsKKyAgICBtX3F1ZXVlLnJlbW92ZUZpcnN0KCk7CisgICAgaWYgKCFt X3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisK K3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZUltcG9ydChQYXNzUmVmUHRyPFN0b3Jh Z2VBcmVhU3luYz4gYXJlYSkKK3sKKyAgICBtX3F1ZXVlLmFwcGVuZChMb2NhbFN0b3JhZ2VUYXNr OjpjcmVhdGVJbXBvcnQoYXJlYSkpOworICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQorICAg ICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBMb2NhbFN0b3JhZ2VUaHJl YWQ6OnNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4gYXJlYSkKK3sKKyAg ICBtX3F1ZXVlLmFwcGVuZChMb2NhbFN0b3JhZ2VUYXNrOjpjcmVhdGVTeW5jKGFyZWEpKTsKKyAg ICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKKyAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3Qo MCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0ZXJtaW5hdGUoKQoreworICAgIG1f cXVldWUuY2xlYXIoKTsKKyAgICBtX3RpbWVyLnN0b3AoKTsKK30KKwordm9pZCBMb2NhbFN0b3Jh Z2VUaHJlYWQ6OnBlcmZvcm1UZXJtaW5hdGUoKQoreworICAgIG1fcXVldWUuY2xlYXIoKTsKKyAg ICBtX3RpbWVyLnN0b3AoKTsKK30KKworfQorI2VuZGlmIC8vIEVOQUJMRShTSU5HTEVfVEhSRUFE RUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9SQUdFKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9z dG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMuY3BwIGIvV2ViQ29yZS9zdG9y YWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMuY3BwCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLjQzZTlhOTgKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3N0 b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL1N0b3JhZ2VBcmVhU3luYy5jcHAKQEAgLTAsMCArMSwxNDQg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRz IFJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFT IElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2luY2x1ZGUgImNvbmZp Zy5oIgorI2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9S QUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKyNpbmNsdWRlICJDU3RyaW5nLmgi CisjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgorI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCisjaW5j bHVkZSAiU1FMaXRlU3RhdGVtZW50LmgiCisjaW5jbHVkZSAiU3RvcmFnZUFyZWFJbXBsLmgiCisj aW5jbHVkZSAiU3RvcmFnZVN5bmNNYW5hZ2VyLmgiCisjaW5jbHVkZSAiU3VkZGVuVGVybWluYXRp b24uaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VB cmVhU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VTeW5jTWFuYWdlcj4gc3RvcmFnZVN5bmNNYW5hZ2Vy LCBQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhSW1wbD4gc3RvcmFnZUFyZWEpCisgICAgOiBtX3N5bmNU aW1lcih0aGlzLCAmU3RvcmFnZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZCkKKyAgICAsIG1faXRl bXNDbGVhcmVkKGZhbHNlKQorICAgICwgbV9maW5hbFN5bmNTY2hlZHVsZWQoZmFsc2UpCisgICAg LCBtX3N0b3JhZ2VBcmVhKHN0b3JhZ2VBcmVhKQorICAgICwgbV9zeW5jTWFuYWdlcihzdG9yYWdl U3luY01hbmFnZXIpCisgICAgLCBtX2NsZWFySXRlbXNXaGlsZVN5bmNpbmcoZmFsc2UpCisgICAg LCBtX3N5bmNTY2hlZHVsZWQoZmFsc2UpCit7CisgICAgcGVyZm9ybUltcG9ydCgpOworfQorCit2 b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luY1RpbWVyRmlyZWQoVGltZXI8U3RvcmFnZUFyZWFTeW5j PiopCit7CisgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGl0ID0gbV9jaGFu Z2VkSXRlbXMuYmVnaW4oKTsKKyAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPjo6aXRlcmF0b3Ig ZW5kID0gbV9jaGFuZ2VkSXRlbXMuZW5kKCk7CisgICAgCisgICAgeworICAgICAgICBpZiAobV9p dGVtc0NsZWFyZWQpIHsKKyAgICAgICAgICAgIG1faXRlbXNQZW5kaW5nU3luYy5jbGVhcigpOwor ICAgICAgICAgICAgbV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nID0gdHJ1ZTsKKyAgICAgICAgICAg IG1faXRlbXNDbGVhcmVkID0gZmFsc2U7CisgICAgICAgIH0KKworICAgICAgICBmb3IgKDsgaXQg IT0gZW5kOyArK2l0KQorICAgICAgICAgICAgbV9pdGVtc1BlbmRpbmdTeW5jLnNldChpdC0+Zmly c3QuY29weSgpLCBpdC0+c2Vjb25kLmNvcHkoKSk7CisKKyAgICAgICAgaWYgKCFtX3N5bmNTY2hl ZHVsZWQpIHsKKyAgICAgICAgICAgIG1fc3luY1NjaGVkdWxlZCA9IHRydWU7CisKKyAgICAgICAg ICAgIC8vIFRoZSBmb2xsb3dpbmcgaXMgYmFsYW5jZWQgYnkgdGhlIGNhbGwgdG8gZW5hYmxlU3Vk ZGVuVGVybWluYXRpb24gaW4gdGhlCisgICAgICAgICAgICAvLyBwZXJmb3JtU3luYyBmdW5jdGlv bi4KKyAgICAgICAgICAgIGRpc2FibGVTdWRkZW5UZXJtaW5hdGlvbigpOworCisgICAgICAgICAg ICBtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZVN5bmModGhpcyk7CisgICAgICAgIH0KKyAgICB9CisK KyAgICAvLyBUaGUgZm9sbG93aW5nIGlzIGJhbGFuY2VkIGJ5IHRoZSBjYWxscyB0byBkaXNhYmxl U3VkZGVuVGVybWluYXRpb24gaW4gdGhlCisgICAgLy8gc2NoZWR1bGVJdGVtRm9yU3luYywgc2No ZWR1bGVDbGVhciwgYW5kIHNjaGVkdWxlRmluYWxTeW5jIGZ1bmN0aW9ucy4KKyAgICBlbmFibGVT dWRkZW5UZXJtaW5hdGlvbigpOworCisgICAgbV9jaGFuZ2VkSXRlbXMuY2xlYXIoKTsKK30KKwor dm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQoreworICAgIEFTU0VSVCghbV9k YXRhYmFzZS5pc09wZW4oKSk7CisKKyAgICBTdHJpbmcgZGF0YWJhc2VGaWxlbmFtZSA9IG1fc3lu Y01hbmFnZXItPmZ1bGxEYXRhYmFzZUZpbGVuYW1lKG1fc3RvcmFnZUFyZWEtPnNlY3VyaXR5T3Jp Z2luKCkpOworCisgICAgaWYgKGRhdGFiYXNlRmlsZW5hbWUuaXNFbXB0eSgpKSB7CisgICAgICAg IExPR19FUlJPUigiRmlsZW5hbWUgZm9yIGxvY2FsIHN0b3JhZ2UgZGF0YWJhc2UgaXMgZW1wdHkg LSBjYW5ub3Qgb3BlbiBmb3IgcGVyc2lzdGVudCBzdG9yYWdlIik7CisgICAgICAgIHJldHVybjsK KyAgICB9CisKKyAgICBpZiAoIW1fZGF0YWJhc2Uub3BlbihkYXRhYmFzZUZpbGVuYW1lKSkgewor ICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0byBvcGVuIGRhdGFiYXNlIGZpbGUgJXMgZm9yIGxv Y2FsIHN0b3JhZ2UiLCBkYXRhYmFzZUZpbGVuYW1lLnV0ZjgoKS5kYXRhKCkpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgaWYgKCFtX2RhdGFiYXNlLmV4ZWN1dGVDb21tYW5kKCJDUkVB VEUgVEFCTEUgSUYgTk9UIEVYSVNUUyBJdGVtVGFibGUgKGtleSBURVhUIFVOSVFVRSBPTiBDT05G TElDVCBSRVBMQUNFLCB2YWx1ZSBURVhUIE5PVCBOVUxMIE9OIENPTkZMSUNUIEZBSUwpIikpIHsK KyAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIHRhYmxlIEl0ZW1UYWJsZSBmb3Ig bG9jYWwgc3RvcmFnZSIpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIAorICAgIFNRTGl0 ZVN0YXRlbWVudCBxdWVyeShtX2RhdGFiYXNlLCAiU0VMRUNUIGtleSwgdmFsdWUgRlJPTSBJdGVt VGFibGUiKTsKKyAgICBpZiAocXVlcnkucHJlcGFyZSgpICE9IFNRTFJlc3VsdE9rKSB7CisgICAg ICAgIExPR19FUlJPUigiVW5hYmxlIHRvIHNlbGVjdCBpdGVtcyBmcm9tIEl0ZW1UYWJsZSBmb3Ig bG9jYWwgc3RvcmFnZSIpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIAorICAgIEhhc2hN YXA8U3RyaW5nLCBTdHJpbmc+IGl0ZW1NYXA7CisKKyAgICBpbnQgcmVzdWx0ID0gcXVlcnkuc3Rl cCgpOworICAgIHdoaWxlIChyZXN1bHQgPT0gU1FMUmVzdWx0Um93KSB7CisgICAgICAgIGl0ZW1N YXAuc2V0KHF1ZXJ5LmdldENvbHVtblRleHQoMCksIHF1ZXJ5LmdldENvbHVtblRleHQoMSkpOwor ICAgICAgICByZXN1bHQgPSBxdWVyeS5zdGVwKCk7CisgICAgfQorCisgICAgaWYgKHJlc3VsdCAh PSBTUUxSZXN1bHREb25lKSB7CisgICAgICAgIExPR19FUlJPUigiRXJyb3IgcmVhZGluZyBpdGVt cyBmcm9tIEl0ZW1UYWJsZSBmb3IgbG9jYWwgc3RvcmFnZSIpOworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGl0ID0gaXRlbU1h cC5iZWdpbigpOworICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+OjppdGVyYXRvciBlbmQgPSBp dGVtTWFwLmVuZCgpOworICAgIAorICAgIGZvciAoOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAg IG1fc3RvcmFnZUFyZWEtPmltcG9ydEl0ZW0oaXQtPmZpcnN0LCBpdC0+c2Vjb25kKTsKK30KKwor dm9pZCBTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50aWxJbXBvcnRDb21wbGV0ZSgpIGNvbnN0Cit7 CisgICAgLy8gRklYTUU6IHdlIGNhbm5vdCBzdXBwb3J0IHRoaXMKK30KKworfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyNlbmRpZiAv LyBFTkFCTEUoRE9NX1NUT1JBR0UpCisKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5j ZS9EYXRhYmFzZVRocmVhZFdpbmNlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFz ZVRocmVhZFdpbmNlLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDgxMTQ1ZC4u MDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5j cHAKKysrIC9kZXYvbnVsbApAQCAtMSw5NSArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAy MDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K LSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoK LSAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwg YmUgdXNlZnVsLAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZl IHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZQotICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIu ICBJZiBub3QsIHdyaXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiRGF0YWJh c2VUaHJlYWQuaCIKLQotI2luY2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VU YXNrLmgiCi0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNl VGhyZWFkKCkKLTogbV90aW1lcih0aGlzLCAmRGF0YWJhc2VUaHJlYWQ6OnRpbWVyRmlyZWQpCi17 Ci19Ci0KLURhdGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQoKQotewotfQotCi12b2lkIERh dGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRpb24oKQotewotICAgIG1fcXVldWUuY2xlYXIo KTsKLX0KLQotYm9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25z dAotewotICAgIHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRo cmVhZDo6dGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKQotewotICAgIGlmICghbV9x dWV1ZS5pc0VtcHR5KCkpIHsKLSAgICAgICAgUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1f cXVldWUuZmlyc3QoKTsKLSAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLSAgICAgICAgbV9x dWV1ZS5yZW1vdmVGaXJzdCgpOwotICAgICAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQotICAg ICAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci0gICAgfQotfQotCi12b2lkIERhdGFi YXNlVGhyZWFkOjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCi17 Ci0gICAgbV9xdWV1ZS5hcHBlbmQodGFzayk7Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkp Ci0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwotfQotCi12b2lkIERhdGFiYXNlVGhy ZWFkOjpzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2sp Ci17Ci0gICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6 dW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIERlcXVl PFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gcmVzZXJ2ZWRUYXNrczsKLSAgICBmb3IgKERlcXVlPFJl ZlB0cjxEYXRhYmFzZVRhc2s+ID46OmNvbnN0X2l0ZXJhdG9yIGkgPSBtX3F1ZXVlLmJlZ2luKCk7 IGkgIT0gbV9xdWV1ZS5lbmQoKTsgKytpKSB7Ci0gICAgICAgIGlmICgoKmkpLT5kYXRhYmFzZSgp ICE9IGRhdGFiYXNlKQotICAgICAgICAgICAgcmVzZXJ2ZWRUYXNrcy5hcHBlbmQoKmkpOwotICAg IH0KLQotICAgIG1fcXVldWUuc3dhcChyZXNlcnZlZFRhc2tzKTsKLX0KLQotdm9pZCBEYXRhYmFz ZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFz ZUNsb3NlZChEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLX0K LQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dp bmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFz ZVRocmVhZFdpbmNlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhZmM3OTEuLjAw MDAwMDAKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaAor KysgL2Rldi9udWxsCkBAIC0xLDY1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkg VG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICog IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1 c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0g KiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElm IG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMw MSwgVVNBLgotICovCi0KLSNpZm5kZWYgRGF0YWJhc2VUaHJlYWRXaW5jZV9oCi0jZGVmaW5lIERh dGFiYXNlVGhyZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8 d3RmL1JlZkNvdW50ZWQuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgRGF0 YWJhc2U7Ci0gICAgY2xhc3MgRGF0YWJhc2VUYXNrOwotCi0gICAgY2xhc3MgRGF0YWJhc2VUaHJl YWQ6IHB1YmxpYyBXVEY6OlJlZkNvdW50ZWQ8RGF0YWJhc2VUaHJlYWQ+IHsKLQotICAgIHB1Ymxp YzoKLSAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsg cmV0dXJuIGFkb3B0UmVmKG5ldyBEYXRhYmFzZVRocmVhZCk7IH0KLSAgICAgICAgfkRhdGFiYXNl VGhyZWFkKCk7Ci0KLSAgICAgICAgYm9vbCBzdGFydCgpIHsgcmV0dXJuIHRydWU7IH0KLSAgICAg ICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oKTsKLSAgICAgICAgYm9vbCB0ZXJtaW5hdGlvblJl cXVlc3RlZCgpIGNvbnN0OwotCi0gICAgICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2VUYXNrPik7Ci0gICAgICAgIHZvaWQgc2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NS ZWZQdHI8RGF0YWJhc2VUYXNrPik7Ci0gICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFz a3MoRGF0YWJhc2UqKTsKLSAgICAgICAgdm9pZCByZWNvcmREYXRhYmFzZU9wZW4oRGF0YWJhc2Uq KTsKLSAgICAgICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChEYXRhYmFzZSopOwotI2lmbmRl ZiBOREVCVUcKLSAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIGNvbnN0IHsg cmV0dXJuIGN1cnJlbnRUaHJlYWQoKTsgfQotI2VuZGlmCi0KLSAgICBwcml2YXRlOgotICAgICAg ICBEYXRhYmFzZVRocmVhZCgpOwotCi0gICAgICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxEYXRh YmFzZVRocmVhZD4qKTsKLQotICAgICAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1f cXVldWU7Ci0gICAgICAgIFRpbWVyPERhdGFiYXNlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0K LX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIERhdGFiYXNlVGhyZWFkV2luY2UK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5j ZS5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3Bw CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZGNiOTAyLi4wMDAwMDAwCi0tLSBhL1dl YkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAKKysrIC9kZXYv bnVsbApAQCAtMSw4MyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1v YmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAot ICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25n IHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdy aXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4K LSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhyZWFk LmgiCi0KLSNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCi0jaW5jbHVkZSAiU3RvcmFnZUFy ZWFTeW5jLmgiCi0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotTG9jYWxTdG9yYWdlVGhyZWFkOjpM b2NhbFN0b3JhZ2VUaHJlYWQoKQotOiBtX3RpbWVyKHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJlYWQ6 OnRpbWVyRmlyZWQpCi17Ci19Ci0KLUxvY2FsU3RvcmFnZVRocmVhZDo6fkxvY2FsU3RvcmFnZVRo cmVhZCgpCi17Ci19Ci0KLWJvb2wgTG9jYWxTdG9yYWdlVGhyZWFkOjpzdGFydCgpCi17Ci0gICAg cmV0dXJuIHRydWU7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKFRp bWVyPExvY2FsU3RvcmFnZVRocmVhZD4qKQotewotICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkp IHsKLSAgICAgICAgUmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0 KCk7Ci0gICAgICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Ci0gICAgICAgIG1fcXVldWUucmVtb3Zl Rmlyc3QoKTsKLSAgICAgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKLSAgICAgICAgICAgIG1f dGltZXIuc3RhcnRPbmVTaG90KDApOwotICAgIH0KLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJl YWQ6OnNjaGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQotewot ICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0ZUltcG9ydChhcmVhKSk7 Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVT aG90KDApOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1bGVTeW5jKFBhc3NS ZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQotewotICAgIG1fcXVldWUuYXBwZW5kKExvY2Fs U3RvcmFnZVRhc2s6OmNyZWF0ZVN5bmMoYXJlYSkpOwotICAgIGlmICghbV90aW1lci5pc0FjdGl2 ZSgpKQotICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9pZCBMb2NhbFN0 b3JhZ2VUaHJlYWQ6OnRlcm1pbmF0ZSgpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1f dGltZXIuc3RvcCgpOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6cGVyZm9ybVRlcm1p bmF0ZSgpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1fdGltZXIuc3RvcCgpOwotfQot Ci19CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFk V2luY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5o CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMDBhYmI1Li4wMDAwMDAwCi0tLSBhL1dl YkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oCisrKyAvZGV2L251 bGwKQEAgLTEsNTggKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2Jp bGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAq ICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgotICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS4gIFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bwotICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0g Ki8KLQotCi0jaWZuZGVmIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gKLSNkZWZpbmUgTG9jYWxT dG9yYWdlVGhyZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8 d3RmL1Bhc3NSZWZQdHIuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgU3Rv cmFnZUFyZWFTeW5jOwotICAgIGNsYXNzIExvY2FsU3RvcmFnZVRhc2s7Ci0KLSAgICBjbGFzcyBM b2NhbFN0b3JhZ2VUaHJlYWQgOiBwdWJsaWMgUmVmQ291bnRlZDxMb2NhbFN0b3JhZ2VUaHJlYWQ+ IHsKLSAgICBwdWJsaWM6Ci0gICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsU3RvcmFnZVRo cmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsU3RvcmFnZVRocmVhZCk7 IH0KLQotICAgICAgICB+TG9jYWxTdG9yYWdlVGhyZWFkKCk7Ci0gICAgICAgIGJvb2wgc3RhcnQo KTsKLSAgICAgICAgdm9pZCBzY2hlZHVsZUltcG9ydChQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3lu Yz4pOwotICAgICAgICB2b2lkIHNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3lu Yz4pOwotICAgICAgICB2b2lkIHRlcm1pbmF0ZSgpOwotICAgICAgICB2b2lkIHBlcmZvcm1UZXJt aW5hdGUoKTsKLQotICAgIHByaXZhdGU6Ci0gICAgICAgIExvY2FsU3RvcmFnZVRocmVhZCgpOwot Ci0gICAgICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+Kik7Ci0K LSAgICAgICAgRGVxdWU8UmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+ID4gbV9xdWV1ZTsKLSAgICAg ICAgVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0KLX0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gK 38369 2009-08-21 07:51:51 -0700 2009-08-21 07:59:01 -0700 more cleanup 28019.patch text/plain 32996 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTJhNWRlYy4uMjExZjkyYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAwOS0wOC0yMSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u CisgICAgICAgIFRoaXMgcGF0Y2ggYWxzbyByZXBsYWNlcyBzdG9yYWdlL3dpbmNlCisgICAgICAg IHdpdGggc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI4MDE5CisKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmg6IG1vZGlmaWVkCisgICAgICAgICogc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQu aDogbW9kaWZpZWQKKyAgICAgICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VBcmVhU3luYyk6CisgICAgICAg IChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKToKKyAgICAgICAgKFdl YkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9ydCk6CisgICAgICAgIChXZWJDb3Jl OjpTdG9yYWdlQXJlYVN5bmM6Om1hcmtJbXBvcnRlZCk6CisgICAgICAgIChXZWJDb3JlOjpTdG9y YWdlQXJlYVN5bmM6OnN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpw ZXJmb3JtU3luYyk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50 aWxJbXBvcnRDb21wbGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnNj aGVkdWxlSW1wb3J0KTogQWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6 b25JbXBvcnRlZCk6IEFkZGVkCisgICAgICAgICogc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaDoK KyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6aXNCYWNrZ3JvdW5kVGhyZWFkKTog QWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6U3luY011dGV4TG9ja2Vy OjpTeW5jTXV0ZXhMb2NrZXIpOiBBZGRlZAorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFT eW5jOjpJbXBvcnRNdXRleExvY2tlcjo6SW1wb3J0TXV0ZXhMb2NrZXIpOiBBZGRlZAorICAgICAg ICAqIHN0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcDogQWRkZWQuCisg ICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNwcDog QWRkZWQuCisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5j LmNwcDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNl LmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2lu Y2UuaDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVh ZFdpbmNlLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFn ZVRocmVhZFdpbmNlLmg6IFJlbW92ZWQuCisKIDIwMDktMDgtMTkgIEphbiBNaWNoYWVsIEFsb256 byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6 LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmggYi9XZWJDb3Jl L3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAppbmRleCA1OWQ3YTVkLi5lNjNhNzE5IDEwMDY0NAot LS0gYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvRGF0YWJhc2VUaHJlYWQuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMp IDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0 IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOSw2ICszMCw3IEBACiAjZGVmaW5lIERhdGFi YXNlVGhyZWFkX2gKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKKwogI2luY2x1ZGUgPHd0Zi9EZXF1 ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4K QEAgLTQwLDQ4ICs0Miw1OCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIERhdGFi YXNlOwotY2xhc3MgRGF0YWJhc2VUYXNrOwotY2xhc3MgRG9jdW1lbnQ7Ci1jbGFzcyBTUUxUcmFu c2FjdGlvbkNvb3JkaW5hdG9yOwotCi1jbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJl YWRTYWZlU2hhcmVkPERhdGFiYXNlVGhyZWFkPiB7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NS ZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBEYXRh YmFzZVRocmVhZCk7IH0KLSAgICB+RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIGJvb2wgc3RhcnQo KTsKLSAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAgIGJvb2wgdGVybWluYXRpb25S ZXF1ZXN0ZWQoKSBjb25zdDsKLQotICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0 YWJhc2VUYXNrPik7Ci0gICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxE YXRhYmFzZVRhc2s+KTsgLy8gVGhpcyBqdXN0IGFkZHMgdGhlIHRhc2sgdG8gdGhlIGZyb250IG9m IHRoZSBxdWV1ZSAtIHRoZSBjYWxsZXIgbmVlZHMgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwgbm90 IHRvIGNyZWF0ZSBkZWFkbG9ja3Mgd2hlbiB3YWl0aW5nIGZvciBjb21wbGV0aW9uLgotICAgIHZv aWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqKTsKLQotICAgIHZvaWQgcmVjb3Jk RGF0YWJhc2VPcGVuKERhdGFiYXNlKik7Ci0gICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChE YXRhYmFzZSopOwotICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSB7IHJldHVybiBt X3RocmVhZElEOyB9Ci0KLSAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2FjdGlv bkNvb3JkaW5hdG9yKCkgeyByZXR1cm4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmdldCgpOyB9 Ci0KLXByaXZhdGU6Ci0gICAgRGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIHN0YXRpYyB2b2lkKiBk YXRhYmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKLSAgICB2b2lkKiBkYXRhYmFzZVRocmVhZCgpOwot Ci0gICAgTXV0ZXggbV90aHJlYWRDcmVhdGlvbk11dGV4OwotICAgIFRocmVhZElkZW50aWZpZXIg bV90aHJlYWRJRDsKLSAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fc2VsZlJlZjsKLQotICAg IE1lc3NhZ2VRdWV1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7Ci0KLSAgICAvLyBU aGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFzZXMgdGhhdCBoYXZlIGJlZW4g dXNlZCBvbiB0aGlzIHRocmVhZC4KLSAgICB0eXBlZGVmIEhhc2hTZXQ8UmVmUHRyPERhdGFiYXNl PiA+IERhdGFiYXNlU2V0OwotICAgIERhdGFiYXNlU2V0IG1fb3BlbkRhdGFiYXNlU2V0OwotCi0g ICAgT3duUHRyPFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGlu YXRvcjsKLX07CisgICAgY2xhc3MgRGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNrOwor ICAgIGNsYXNzIERvY3VtZW50OworICAgIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I7 CisKKyAgICBjbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVkPERh dGFiYXNlVGhyZWFkPiB7CisgICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxE YXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFiYXNlVGhy ZWFkKTsgfQorICAgICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKKworICAgICAgICBib29sIHN0YXJ0 KCk7CisgICAgICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7CisgICAgICAgIGJvb2wgdGVy bWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsKKworICAgICAgICB2b2lkIHNjaGVkdWxlVGFzayhQ YXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOworICAgICAgICB2b2lkIHNjaGVkdWxlSW1tZWRpYXRl VGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOyAvLyBUaGlzIGp1c3QgYWRkcyB0aGUgdGFz ayB0byB0aGUgZnJvbnQgb2YgdGhlIHF1ZXVlIC0gdGhlIGNhbGxlciBuZWVkcyB0byBiZSBleHRy ZW1lbHkgY2FyZWZ1bCBub3QgdG8gY3JlYXRlIGRlYWRsb2NrcyB3aGVuIHdhaXRpbmcgZm9yIGNv bXBsZXRpb24uCisgICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2Uq KTsKKworICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOworICAgICAg ICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7CisjaWYgRU5BQkxFKFNJTkdM RV9USFJFQURFRCkKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsgcmV0 dXJuIGN1cnJlbnRUaHJlYWQoKTsgfQorI2Vsc2UKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBn ZXRUaHJlYWRJRCgpIHsgcmV0dXJuIG1fdGhyZWFkSUQ7IH0KKyNlbmRpZgorCisgICAgICAgIFNR TFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSB7IHJldHVy biBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0KKworICAgIHByaXZhdGU6CisgICAg ICAgIERhdGFiYXNlVGhyZWFkKCk7CisKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAg ICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+Kik7CisKKyAgICAgICAg RGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOworICAgICAgICBUaW1lcjxEYXRh YmFzZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCisgICAgICAgIHN0YXRpYyB2b2lkKiBkYXRhYmFz ZVRocmVhZFN0YXJ0KHZvaWQqKTsKKyAgICAgICAgdm9pZCogZGF0YWJhc2VUaHJlYWQoKTsKKwor ICAgICAgICBNdXRleCBtX3RocmVhZENyZWF0aW9uTXV0ZXg7CisgICAgICAgIFRocmVhZElkZW50 aWZpZXIgbV90aHJlYWRJRDsKKyAgICAgICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX3NlbGZS ZWY7CisKKyAgICAgICAgTWVzc2FnZVF1ZXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9xdWV1 ZTsKKworICAgICAgICAvLyBUaGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFz ZXMgdGhhdCBoYXZlIGJlZW4gdXNlZCBvbiB0aGlzIHRocmVhZC4KKyAgICAgICAgdHlwZWRlZiBI YXNoU2V0PFJlZlB0cjxEYXRhYmFzZT4gPiBEYXRhYmFzZVNldDsKKyAgICAgICAgRGF0YWJhc2VT ZXQgbV9vcGVuRGF0YWJhc2VTZXQ7CisjZW5kaWYKKyAgICAgICAgT3duUHRyPFNRTFRyYW5zYWN0 aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGluYXRvcjsKKyAgICB9OwogCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0 b3JhZ2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaAppbmRl eCAzZDU4NDI3Li5iMDE5YTU2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9y YWdlVGhyZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oCkBA IC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFsbCBS aWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMu IEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAg LTI4LDYgKzI5LDcgQEAKIAogI2lmIEVOQUJMRShET01fU1RPUkFHRSkKIAorI2luY2x1ZGUgPHd0 Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL01lc3Nh Z2VRdWV1ZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CkBAIC01Niw2ICs1OCwxMiBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgTG9jYWxTdG9yYWdl VGhyZWFkKCk7CiAKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICB2b2lkIHRp bWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOworCisgICAgICAgIERlcXVlPFJl ZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7CisgICAgICAgIFRpbWVyPExvY2FsU3Rv cmFnZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCiAgICAgICAgIHN0YXRpYyB2b2lkKiBsb2NhbFN0 b3JhZ2VUaHJlYWRTdGFydCh2b2lkKik7CiAgICAgICAgIHZvaWQqIGxvY2FsU3RvcmFnZVRocmVh ZCgpOwogCkBAIC02Nyw2ICs3NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAg ICAgICAgIE11dGV4IG1fdGVybWluYXRlTG9jazsKICAgICAgICAgVGhyZWFkQ29uZGl0aW9uIG1f dGVybWluYXRlQ29uZGl0aW9uOworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAppbmRleCAwMWQyYTY1Li40NGE0MmFm IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtNTUsMTUgKzU1LDExIEBAIFN0 b3JhZ2VBcmVhU3luYzo6U3RvcmFnZUFyZWFTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZVN5bmNNYW5h Z2VyPiBzdG9yYWdlU3luY01hbmFnCiAgICAgLCBtX3N5bmNNYW5hZ2VyKHN0b3JhZ2VTeW5jTWFu YWdlcikKICAgICAsIG1fY2xlYXJJdGVtc1doaWxlU3luY2luZyhmYWxzZSkKICAgICAsIG1fc3lu Y1NjaGVkdWxlZChmYWxzZSkKLSAgICAsIG1faW1wb3J0Q29tcGxldGUoZmFsc2UpCiB7CiAgICAg QVNTRVJUKG1fc3RvcmFnZUFyZWEpOwogICAgIEFTU0VSVChtX3N5bmNNYW5hZ2VyKTsKIAotICAg IC8vIEZJWE1FOiBJZiBpdCBjYW4ndCBpbXBvcnQsIHRoZW4gdGhlIGRlZmF1bHQgV2ViS2l0IGJl aGF2aW9yIHNob3VsZCBiZSB0aGF0IG9mIHByaXZhdGUgYnJvd3NpbmcsCi0gICAgLy8gbm90IHNp bGVudGx5IGlnbm9yaW5nIGl0LiAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTI1ODk0Ci0gICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0aGlzKSkK LSAgICAgICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7CisgICAgc2NoZWR1bGVJbXBvcnQoKTsK IH0KIAogU3RvcmFnZUFyZWFTeW5jOjp+U3RvcmFnZUFyZWFTeW5jKCkKQEAgLTEyOSw3ICsxMjUs NyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luY1RpbWVyRmlyZWQoVGltZXI8U3RvcmFnZUFy ZWFTeW5jPiopCiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGVuZCA9IG1f Y2hhbmdlZEl0ZW1zLmVuZCgpOwogICAgIAogICAgIHsKLSAgICAgICAgTXV0ZXhMb2NrZXIgbG9j a2VyKG1fc3luY0xvY2spOworICAgICAgICBTeW5jTXV0ZXhMb2NrZXIgbG9ja2VyKHRoaXMpOwog CiAgICAgICAgIGlmIChtX2l0ZW1zQ2xlYXJlZCkgewogICAgICAgICAgICAgbV9pdGVtc1BlbmRp bmdTeW5jLmNsZWFyKCk7CkBAIC0xNjAsNyArMTU2LDcgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6 OnN5bmNUaW1lckZpcmVkKFRpbWVyPFN0b3JhZ2VBcmVhU3luYz4qKQogCiB2b2lkIFN0b3JhZ2VB cmVhU3luYzo6cGVyZm9ybUltcG9ydCgpCiB7Ci0gICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7 CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsKICAgICBBU1NFUlQoIW1fZGF0YWJh c2UuaXNPcGVuKCkpOwogCiAgICAgU3RyaW5nIGRhdGFiYXNlRmlsZW5hbWUgPSBtX3N5bmNNYW5h Z2VyLT5mdWxsRGF0YWJhc2VGaWxlbmFtZShtX3N0b3JhZ2VBcmVhLT5zZWN1cml0eU9yaWdpbigp KTsKQEAgLTIwNCw3ICsyMDAsNyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9y dCgpCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBNdXRleExvY2tlciBsb2NrZXIobV9p bXBvcnRMb2NrKTsKKyAgICBJbXBvcnRNdXRleExvY2tlciBsb2NrZXIodGhpcyk7CiAgICAgCiAg ICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGl0ID0gaXRlbU1hcC5iZWdpbigp OwogICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+OjppdGVyYXRvciBlbmQgPSBpdGVtTWFwLmVu ZCgpOwpAQCAtMjE0LDQ2ICsyMTAsMjIgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1J bXBvcnQoKQogICAgIAogICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KICAgICBt X3N0b3JhZ2VBcmVhID0gMDsKLSAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1ZTsKLSAgICBtX2lt cG9ydENvbmRpdGlvbi5zaWduYWwoKTsKKyAgICBvbkltcG9ydGVkKCk7CiB9CiAKIHZvaWQgU3Rv cmFnZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWQoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFk KCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAKLSAgICBNdXRleExvY2tl ciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKKyAgICBJbXBvcnRNdXRleExvY2tlciBsb2NrZXIodGhp cyk7CiAgICAgLy8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xlLgogICAgIG1fc3RvcmFnZUFy ZWEgPSAwOwotICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOwotICAgIG1faW1wb3J0Q29uZGl0 aW9uLnNpZ25hbCgpOwotfQotCi0vLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFs bG93IHVzZSBvZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0 byBkbyBzbykuCi0vLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29t cGxldGUgaXMgYnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQK LS8vIHRoZXJlIGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xl bmd0aCB3aWxsIG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgotLy8gb3B0aW1p emF0aW9uIChzaW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMg YXJlIGJlaW5nIGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55Ci0vLyBpdGVtIGN1cnJlbnRseSBp biB0aGUgbWFwLiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhl IG1hcCwgYnV0IHdlJ2xsIG5lZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3Vs ZCBub3Qgb3ZlcndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBr aWxsIHRoZSBpbXBvcnQKLS8vIGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9j a1VudGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQo KSk7Ci0KLSAgICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KLSAgICBpZiAobV9pbXBv cnRDb21wbGV0ZSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1f aW1wb3J0TG9jayk7Ci0gICAgd2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQotICAgICAgICBtX2lt cG9ydENvbmRpdGlvbi53YWl0KG1faW1wb3J0TG9jayk7Ci0gICAgQVNTRVJUKG1faW1wb3J0Q29t cGxldGUpOwotICAgIEFTU0VSVCghbV9zdG9yYWdlQXJlYSk7CisgICAgb25JbXBvcnRlZCgpOwog fQogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhh c2hNYXA8U3RyaW5nLCBTdHJpbmc+JiBpdGVtcykKIHsKLSAgICBBU1NFUlQoIWlzTWFpblRocmVh ZCgpKTsKKyAgICBBU1NFUlQoaXNCYWNrZ3JvdW5kVGhyZWFkKCkpOwogCiAgICAgaWYgKCFtX2Rh dGFiYXNlLmlzT3BlbigpKQogICAgICAgICByZXR1cm47CkBAIC0zMDksMTIgKzI4MSwxMiBAQCB2 b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hNYXA8 U3RyaW5nLCBTdHJpbmc+JiBpdGVtcwogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybVN5 bmMoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tn cm91bmRUaHJlYWQoKSk7CiAKICAgICBib29sIGNsZWFySXRlbXM7CiAgICAgSGFzaE1hcDxTdHJp bmcsIFN0cmluZz4gaXRlbXM7CiAgICAgewotICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9z eW5jTG9jayk7CisgICAgICAgIFN5bmNNdXRleExvY2tlciBsb2NrZXIodGhpcyk7CiAKICAgICAg ICAgQVNTRVJUKG1fc3luY1NjaGVkdWxlZCk7CiAKQEAgLTMzMiw2ICszMDQsNDcgQEAgdm9pZCBT dG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1TeW5jKCkKICAgICBlbmFibGVTdWRkZW5UZXJtaW5hdGlv bigpOwogfQogCisjaWYgIUVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKy8vIEZJWE1FOiBJbiB0 aGUgZnV0dXJlLCB3ZSBzaG91bGQgYWxsb3cgdXNlIG9mIFN0b3JhZ2VBcmVhcyB3aGlsZSBpdCdz IGltcG9ydGluZyAod2hlbiBzYWZlIHRvIGRvIHNvKS4KKy8vIEJsb2NraW5nIGV2ZXJ5dGhpbmcg dW50aWwgdGhlIGltcG9ydCBpcyBjb21wbGV0ZSBpcyBieSBmYXIgdGhlIHNpbXBsZXN0IGFuZCBz YWZlc3QgdGhpbmcgdG8gZG8sIGJ1dAorLy8gdGhlcmUgaXMgY2VydGFpbmx5IHJvb20gZm9yIHNh ZmUgb3B0aW1pemF0aW9uOiBLZXkvbGVuZ3RoIHdpbGwgbmV2ZXIgYmUgYWJsZSB0byBtYWtlIHVz ZSBvZiBzdWNoIGFuCisvLyBvcHRpbWl6YXRpb24gKHNpbmNlIHRoZSBvcmRlciBvZiBpdGVyYXRp b24gY2FuIGNoYW5nZSBhcyBpdGVtcyBhcmUgYmVpbmcgYWRkZWQpLiBHZXQgY2FuIHJldHVybiBh bnkKKy8vIGl0ZW0gY3VycmVudGx5IGluIHRoZSBtYXAuIEdldC9yZW1vdmUgY2FuIHdvcmsgd2hl dGhlciBvciBub3QgaXQncyBpbiB0aGUgbWFwLCBidXQgd2UnbGwgbmVlZCBhIGxpc3QKKy8vIG9m IGl0ZW1zIHRoZSBpbXBvcnQgc2hvdWxkIG5vdCBvdmVyd3JpdGUuIENsZWFyIGNhbiBhbHNvIHdv cmssIGJ1dCBpdCdsbCBuZWVkIHRvIGtpbGwgdGhlIGltcG9ydAorLy8gam9iIGZpcnN0Lgordm9p ZCBTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50aWxJbXBvcnRDb21wbGV0ZSgpIGNvbnN0Cit7Cisg ICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKworICAgIC8vIEZhc3QgcGF0aCB0byBhdm9pZCBs b2NraW5nLgorICAgIGlmIChtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICByZXR1cm47CisKKyAg ICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKKyAgICB3aGlsZSAoIW1faW1wb3J0 Q29tcGxldGUpCisgICAgICAgIG1faW1wb3J0Q29uZGl0aW9uLndhaXQobV9pbXBvcnRMb2NrKTsK KyAgICBBU1NFUlQobV9pbXBvcnRDb21wbGV0ZSk7CisgICAgQVNTRVJUKCFtX3N0b3JhZ2VBcmVh KTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OnNjaGVkdWxlSW1wb3J0KCkKK3sKKyAgICBt X2ltcG9ydENvbXBsZXRlID0gZmFsc2U7CisgICAgLy8gRklYTUU6IElmIGl0IGNhbid0IGltcG9y dCwgdGhlbiB0aGUgZGVmYXVsdCBXZWJLaXQgYmVoYXZpb3Igc2hvdWxkIGJlIHRoYXQgb2YgcHJp dmF0ZSBicm93c2luZywKKyAgICAvLyBub3Qgc2lsZW50bHkgaWdub3JpbmcgaXQuICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTQKKyAgICBpZiAoIW1fc3luY01h bmFnZXItPnNjaGVkdWxlSW1wb3J0KHRoaXMpKQorICAgICAgICBtX2ltcG9ydENvbXBsZXRlID0g dHJ1ZTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6Om9uSW1wb3J0ZWQoKQoreworICAgIG1f aW1wb3J0Q29tcGxldGUgPSB0cnVlOworICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25hbCgpOwor fQorCisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxF KERPTV9TVE9SQUdFKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3lu Yy5oIGIvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCmluZGV4IGU0MzZiZWYuLjkx ZDI0ZDcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKQEAgLTc4LDE1ICs3OCw0MSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc3luY1RpbWVyRmlyZWQoVGltZXI8U3Rv cmFnZUFyZWFTeW5jPiopOwogICAgICAgICB2b2lkIHN5bmMoYm9vbCBjbGVhckl0ZW1zLCBjb25z dCBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiYgaXRlbXMpOwogCi0gICAgICAgIE11dGV4IG1fc3lu Y0xvY2s7CiAgICAgICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+IG1faXRlbXNQZW5kaW5nU3lu YzsKICAgICAgICAgYm9vbCBtX2NsZWFySXRlbXNXaGlsZVN5bmNpbmc7CiAgICAgICAgIGJvb2wg bV9zeW5jU2NoZWR1bGVkOwogCisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAg IHZvaWQgc2NoZWR1bGVJbXBvcnQoKTsKKyAgICAgICAgdm9pZCBvbkltcG9ydGVkKCk7CisKKyNp ZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICBib29sIGlzQmFja2dyb3VuZFRocmVh ZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyAgICAgICAgc3RydWN0IFN5bmNNdXRleExvY2tl cgorICAgICAgICB7CisgICAgICAgICAgICBTeW5jTXV0ZXhMb2NrZXIodm9pZCopIHt9CisgICAg ICAgIH07CisgICAgICAgIHN0cnVjdCBJbXBvcnRNdXRleExvY2tlcgorICAgICAgICB7CisgICAg ICAgICAgICBJbXBvcnRNdXRleExvY2tlcih2b2lkKikge30KKyAgICAgICAgfTsKKyNlbHNlCisg ICAgICAgIE11dGV4IG1fc3luY0xvY2s7CisgICAgICAgIG11dGFibGUgYm9vbCBtX2ltcG9ydENv bXBsZXRlOwogICAgICAgICBtdXRhYmxlIE11dGV4IG1faW1wb3J0TG9jazsKICAgICAgICAgbXV0 YWJsZSBUaHJlYWRDb25kaXRpb24gbV9pbXBvcnRDb25kaXRpb247Ci0gICAgICAgIG11dGFibGUg Ym9vbCBtX2ltcG9ydENvbXBsZXRlOwotICAgICAgICB2b2lkIG1hcmtJbXBvcnRlZCgpOworICAg ICAgICBib29sIGlzQmFja2dyb3VuZFRocmVhZCgpIGNvbnN0IHsgcmV0dXJuICFpc01haW5UaHJl YWQoKTsgfQorICAgICAgICBmcmllbmQgY2xhc3MgU3luY011dGV4TG9ja2VyOworICAgICAgICBm cmllbmQgY2xhc3MgSW1wb3J0TXV0ZXhMb2NrZXI7CisgICAgICAgIHN0cnVjdCBTeW5jTXV0ZXhM b2NrZXI6IHByaXZhdGUgTXV0ZXh0TG9ja2VyCisgICAgICAgIHsKKyAgICAgICAgICAgIFN5bmNN dXRleExvY2tlcihTdG9yYWdlQXJlYVN5bmMqIHN0b3JhZ2VBcmVhU3luYykgOiBNdXRleHRMb2Nr ZXIoc3RvcmFnZUFyZWFTeW5jLT5tX3N5bmNMb2NrKSB7fQorICAgICAgICB9OworICAgICAgICBz dHJ1Y3QgSW1wb3J0TXV0ZXhMb2NrZXI6IHByaXZhdGUgTXV0ZXh0TG9ja2VyCisgICAgICAgIHsK KyAgICAgICAgICAgIEltcG9ydE11dGV4TG9ja2VyKFN0b3JhZ2VBcmVhU3luYyogc3RvcmFnZUFy ZWFTeW5jKSA6IE11dGV4dExvY2tlcihzdG9yYWdlQXJlYVN5bmMtPm1faW1wb3J0TG9jaykge30K KyAgICAgICAgfTsKKyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQu Y3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGNjYTdmOAotLS0gL2Rldi9udWxs CisrKyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3Bw CkBAIC0wLDAgKzEsMTEwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmls ZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlzIGxpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAorICog IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKKwor I2lmIEVOQUJMRShET01fU1RPUkFHRSkKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorCisj aW5jbHVkZSAiRGF0YWJhc2UuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKKyNpbmNsdWRl ICJTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor RGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKKyAgICA6IG1fdGltZXIodGhpcywgJkRh dGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKQorICAgICwgbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9y KG5ldyBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkpCit7Cit9CisKK0RhdGFiYXNlVGhyZWFk Ojp+RGF0YWJhc2VUaHJlYWQoKQoreworfQorCitib29sIERhdGFiYXNlVGhyZWFkOjpzdGFydCgp Cit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RU ZXJtaW5hdGlvbigpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1fdHJhbnNhY3Rpb25D b29yZGluYXRvci0+c2h1dGRvd24oKTsKK30KKworYm9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWlu YXRpb25SZXF1ZXN0ZWQoKSBjb25zdAoreworICAgIHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsK K30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVh ZD4qKQoreworICAgIGlmIChtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3QoKTsKKyAgICB0YXNr LT5wZXJmb3JtVGFzaygpOworICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICBpZiAoIW1f cXVldWUuaXNFbXB0eSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwor dm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNr PiB0YXNrKQoreworICAgIG1fcXVldWUuYXBwZW5kKHRhc2spOworICAgIGlmICghbV90aW1lci5p c0FjdGl2ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBE YXRhYmFzZVRocmVhZDo6c2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VU YXNrPiB0YXNrKQoreworICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Cit9CisKK3ZvaWQgRGF0YWJh c2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sK KyAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IHJlc2VydmVkVGFza3M7CisgICAgZm9y IChEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9xdWV1 ZS5iZWdpbigpOyBpICE9IG1fcXVldWUuZW5kKCk7ICsraSkgeworICAgICAgICBpZiAoKCppKS0+ ZGF0YWJhc2UoKSAhPSBkYXRhYmFzZSkKKyAgICAgICAgICAgIHJlc2VydmVkVGFza3MuYXBwZW5k KCppKTsKKyAgICB9CisKKyAgICBtX3F1ZXVlLnN3YXAocmVzZXJ2ZWRUYXNrcyk7Cit9CisKK3Zv aWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSogZGF0YWJhc2Up Cit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6cmVj b3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIG5vdEltcGxlbWVu dGVkKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShT SU5HTEVfVEhSRUFERUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9SQUdFKQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3Bw IGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJjNmYyYWIKLS0tIC9kZXYvbnVs bAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVh ZC5jcHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBN b2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiAgVGhpcyBs aWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwK KyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqICBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bworICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5r bGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0Eu CisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRocmVh ZC5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFE RUQpCisKKyNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCisjaW5jbHVkZSAiU3RvcmFnZUFy ZWFTeW5jLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUGFzc1JlZlB0cjxMb2NhbFN0b3Jh Z2VUaHJlYWQ+IExvY2FsU3RvcmFnZVRocmVhZDo6Y3JlYXRlKCkKK3sKKyAgICByZXR1cm4gYWRv cHRSZWYobmV3IExvY2FsU3RvcmFnZVRocmVhZCk7Cit9CisKK0xvY2FsU3RvcmFnZVRocmVhZDo6 TG9jYWxTdG9yYWdlVGhyZWFkKCkKKzogbV90aW1lcih0aGlzLCAmTG9jYWxTdG9yYWdlVGhyZWFk Ojp0aW1lckZpcmVkKQoreworfQorCitib29sIExvY2FsU3RvcmFnZVRocmVhZDo6c3RhcnQoKQor eworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJG aXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+KikKK3sKKyAgICBpZiAobV9xdWV1ZS5pc0Vt cHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiB0 YXNrID0gbV9xdWV1ZS5maXJzdCgpOworICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICB0 YXNrLT5wZXJmb3JtVGFzaygpOworICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpCisgICAgICAg IG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6 c2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCit7CisgICAg bV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlSW1wb3J0KGFyZWEpKTsKKyAg ICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKKyAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3Qo MCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZVN5bmMoUGFzc1JlZlB0 cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCit7CisgICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9y YWdlVGFzazo6Y3JlYXRlU3luYyhhcmVhKSk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkp CisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3RvcmFn ZVRocmVhZDo6dGVybWluYXRlKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7CisgICAgbV90aW1l ci5zdG9wKCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpwZXJmb3JtVGVybWluYXRl KCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7CisgICAgbV90aW1lci5zdG9wKCk7Cit9CisKK30K KyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorI2VuZGlmIC8vIEVOQUJMRShET01f U1RPUkFHRSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3Rv cmFnZUFyZWFTeW5jLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFn ZUFyZWFTeW5jLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNDQ0MDA4 Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9y YWdlQXJlYVN5bmMuY3BwCkBAIC0wLDAgKzEsNjIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICogQ29weXJpZ2h0IChD KSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUK KyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERB VEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4gCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlN0b3JhZ2VBcmVh U3luYy5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhS RUFERUQpCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgor I2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCisjaW5jbHVkZSAiU1FMaXRlU3RhdGVtZW50LmgiCisj aW5jbHVkZSAiU3RvcmFnZUFyZWFJbXBsLmgiCisjaW5jbHVkZSAiU3RvcmFnZVN5bmNNYW5hZ2Vy LmgiCisjaW5jbHVkZSAiU3VkZGVuVGVybWluYXRpb24uaCIKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c2NoZWR1bGVJbXBvcnQoKQoreworICAgIC8vIERv IGEgYmxvY2tpbmcgaW1wb3J0IGJlY2F1c2Ugd2UgY2Fubm90ICJibG9ja1VudGlsSW1wb3J0Q29t cGxldGUiIHdpdGggb25lIHRocmVhZAorICAgIHBlcmZvcm1JbXBvcnQoKTsKK30KKwordm9pZCBT dG9yYWdlQXJlYVN5bmM6Om9uSW1wb3J0ZWQoKQoreworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3lu Yzo6YmxvY2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3QKK3sKKyAgICAvLyBXZSBoYXZlIGFs cmVhZHkgaW1wb3J0ZWQgaW4gc2NoZWR1bGVJbXBvcnQoKQorfQorCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorI2VuZGlmIC8vIEVO QUJMRShET01fU1RPUkFHRSkKKwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0Rh dGFiYXNlVGhyZWFkV2luY2UuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhy ZWFkV2luY2UuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkODExNDVkLi4wMDAw MDAwCi0tLSBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNlLmNwcAor KysgL2Rldi9udWxsCkBAIC0xLDk1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkg VG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICog IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1 c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0g KiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElm IG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMw MSwgVVNBLgotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJEYXRhYmFzZVRo cmVhZC5oIgotCi0jaW5jbHVkZSAiRGF0YWJhc2UuaCIKLSNpbmNsdWRlICJEYXRhYmFzZVRhc2su aCIKLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1EYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJl YWQoKQotOiBtX3RpbWVyKHRoaXMsICZEYXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZCkKLXsKLX0K LQotRGF0YWJhc2VUaHJlYWQ6On5EYXRhYmFzZVRocmVhZCgpCi17Ci19Ci0KLXZvaWQgRGF0YWJh c2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbigpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwot fQotCi1ib29sIERhdGFiYXNlVGhyZWFkOjp0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0Ci17 Ci0gICAgcmV0dXJuIG1fcXVldWUuaXNFbXB0eSgpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFk Ojp0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNlVGhyZWFkPiopCi17Ci0gICAgaWYgKCFtX3F1ZXVl LmlzRW1wdHkoKSkgewotICAgICAgICBSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrID0gbV9xdWV1 ZS5maXJzdCgpOwotICAgICAgICB0YXNrLT5wZXJmb3JtVGFzaygpOwotICAgICAgICBtX3F1ZXVl LnJlbW92ZUZpcnN0KCk7Ci0gICAgICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpCi0gICAgICAg ICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLSAgICB9Ci19Ci0KLXZvaWQgRGF0YWJhc2VU aHJlYWQ6OnNjaGVkdWxlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKLXsKLSAg ICBtX3F1ZXVlLmFwcGVuZCh0YXNrKTsKLSAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAg ICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6 OnNjaGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKLXsK LSAgICB0YXNrLT5wZXJmb3JtVGFzaygpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNj aGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgRGVxdWU8UmVm UHRyPERhdGFiYXNlVGFzaz4gPiByZXNlcnZlZFRhc2tzOwotICAgIGZvciAoRGVxdWU8UmVmUHRy PERhdGFiYXNlVGFzaz4gPjo6Y29uc3RfaXRlcmF0b3IgaSA9IG1fcXVldWUuYmVnaW4oKTsgaSAh PSBtX3F1ZXVlLmVuZCgpOyArK2kpIHsKLSAgICAgICAgaWYgKCgqaSktPmRhdGFiYXNlKCkgIT0g ZGF0YWJhc2UpCi0gICAgICAgICAgICByZXNlcnZlZFRhc2tzLmFwcGVuZCgqaSk7Ci0gICAgfQot Ci0gICAgbV9xdWV1ZS5zd2FwKHJlc2VydmVkVGFza3MpOwotfQotCi12b2lkIERhdGFiYXNlVGhy ZWFkOjpyZWNvcmREYXRhYmFzZU9wZW4oRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIG5vdElt cGxlbWVudGVkKCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlQ2xv c2VkKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotfQotCi19 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2Uv RGF0YWJhc2VUaHJlYWRXaW5jZS5oIGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhy ZWFkV2luY2UuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmFmYzc5MS4uMDAwMDAw MAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5oCisrKyAv ZGV2L251bGwKQEAgLTEsNjUgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3Jj aCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1 bCwKLSAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgotICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZl ZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBh bG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90 LCB3cml0ZSB0bwotICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZy YW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBV U0EuCi0gKi8KLQotI2lmbmRlZiBEYXRhYmFzZVRocmVhZFdpbmNlX2gKLSNkZWZpbmUgRGF0YWJh c2VUaHJlYWRXaW5jZV9oCi0KLSNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KLSNpbmNsdWRlIDx3dGYv UmVmQ291bnRlZC5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLSAgICBjbGFzcyBEYXRhYmFz ZTsKLSAgICBjbGFzcyBEYXRhYmFzZVRhc2s7Ci0KLSAgICBjbGFzcyBEYXRhYmFzZVRocmVhZDog cHVibGljIFdURjo6UmVmQ291bnRlZDxEYXRhYmFzZVRocmVhZD4gewotCi0gICAgcHVibGljOgot ICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxEYXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1 cm4gYWRvcHRSZWYobmV3IERhdGFiYXNlVGhyZWFkKTsgfQotICAgICAgICB+RGF0YWJhc2VUaHJl YWQoKTsKLQotICAgICAgICBib29sIHN0YXJ0KCkgeyByZXR1cm4gdHJ1ZTsgfQotICAgICAgICB2 b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAgICAgICBib29sIHRlcm1pbmF0aW9uUmVxdWVz dGVkKCkgY29uc3Q7Ci0KLSAgICAgICAgdm9pZCBzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRh YmFzZVRhc2s+KTsKLSAgICAgICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0 cjxEYXRhYmFzZVRhc2s+KTsKLSAgICAgICAgdm9pZCB1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhE YXRhYmFzZSopOwotICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOwot ICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7Ci0jaWZuZGVmIE5E RUJVRwotICAgICAgICBUaHJlYWRJZGVudGlmaWVyIGdldFRocmVhZElEKCkgY29uc3QgeyByZXR1 cm4gY3VycmVudFRocmVhZCgpOyB9Ci0jZW5kaWYKLQotICAgIHByaXZhdGU6Ci0gICAgICAgIERh dGFiYXNlVGhyZWFkKCk7Ci0KLSAgICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNl VGhyZWFkPiopOwotCi0gICAgICAgIERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9xdWV1 ZTsKLSAgICAgICAgVGltZXI8RGF0YWJhc2VUaHJlYWQ+IG1fdGltZXI7Ci0gICAgfTsKLQotfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRGF0YWJhc2VUaHJlYWRXaW5jZQpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNw cCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAKZGVs ZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhkY2I5MDIuLjAwMDAwMDAKLS0tIGEvV2ViQ29y ZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNwcAorKysgL2Rldi9udWxs CkBAIC0xLDgzICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxl LCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK LSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAg YnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0 aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUg dG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBT dHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgotICov Ci0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUaHJlYWQuaCIK LQotI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRhc2suaCIKLSNpbmNsdWRlICJTdG9yYWdlQXJlYVN5 bmMuaCIKLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1Mb2NhbFN0b3JhZ2VUaHJlYWQ6OkxvY2Fs U3RvcmFnZVRocmVhZCgpCi06IG1fdGltZXIodGhpcywgJkxvY2FsU3RvcmFnZVRocmVhZDo6dGlt ZXJGaXJlZCkKLXsKLX0KLQotTG9jYWxTdG9yYWdlVGhyZWFkOjp+TG9jYWxTdG9yYWdlVGhyZWFk KCkKLXsKLX0KLQotYm9vbCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnN0YXJ0KCkKLXsKLSAgICByZXR1 cm4gdHJ1ZTsKLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVyRmlyZWQoVGltZXI8 TG9jYWxTdG9yYWdlVGhyZWFkPiopCi17Ci0gICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkgewot ICAgICAgICBSZWZQdHI8TG9jYWxTdG9yYWdlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3QoKTsK LSAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLSAgICAgICAgbV9xdWV1ZS5yZW1vdmVGaXJz dCgpOwotICAgICAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQotICAgICAgICAgICAgbV90aW1l ci5zdGFydE9uZVNob3QoMCk7Ci0gICAgfQotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6 c2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCi17Ci0gICAg bV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlSW1wb3J0KGFyZWEpKTsKLSAg ICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3Qo MCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZVN5bmMoUGFzc1JlZlB0 cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCi17Ci0gICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9y YWdlVGFzazo6Y3JlYXRlU3luYyhhcmVhKSk7Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkp Ci0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwotfQotCi12b2lkIExvY2FsU3RvcmFn ZVRocmVhZDo6dGVybWluYXRlKCkKLXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7Ci0gICAgbV90aW1l ci5zdG9wKCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpwZXJmb3JtVGVybWluYXRl KCkKLXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7Ci0gICAgbV90aW1lci5zdG9wKCk7Ci19Ci0KLX0K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5j ZS5oIGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmgKZGVs ZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMwMGFiYjUuLjAwMDAwMDAKLS0tIGEvV2ViQ29y ZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmgKKysrIC9kZXYvbnVsbApA QCAtMSw1OCArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z Ci0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0g KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAotICogIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv Ci0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3Ry ZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KLSAqLwot Ci0KLSNpZm5kZWYgTG9jYWxTdG9yYWdlVGhyZWFkV2luY2VfaAotI2RlZmluZSBMb2NhbFN0b3Jh Z2VUaHJlYWRXaW5jZV9oCi0KLSNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KLSNpbmNsdWRlIDx3dGYv UGFzc1JlZlB0ci5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLSAgICBjbGFzcyBTdG9yYWdl QXJlYVN5bmM7Ci0gICAgY2xhc3MgTG9jYWxTdG9yYWdlVGFzazsKLQotICAgIGNsYXNzIExvY2Fs U3RvcmFnZVRocmVhZCA6IHB1YmxpYyBSZWZDb3VudGVkPExvY2FsU3RvcmFnZVRocmVhZD4gewot ICAgIHB1YmxpYzoKLSAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxTdG9yYWdlVGhyZWFk PiBjcmVhdGUoKSB7IHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxTdG9yYWdlVGhyZWFkKTsgfQot Ci0gICAgICAgIH5Mb2NhbFN0b3JhZ2VUaHJlYWQoKTsKLSAgICAgICAgYm9vbCBzdGFydCgpOwot ICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPik7 Ci0gICAgICAgIHZvaWQgc2NoZWR1bGVTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPik7 Ci0gICAgICAgIHZvaWQgdGVybWluYXRlKCk7Ci0gICAgICAgIHZvaWQgcGVyZm9ybVRlcm1pbmF0 ZSgpOwotCi0gICAgcHJpdmF0ZToKLSAgICAgICAgTG9jYWxTdG9yYWdlVGhyZWFkKCk7Ci0KLSAg ICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPExvY2FsU3RvcmFnZVRocmVhZD4qKTsKLQotICAg ICAgICBEZXF1ZTxSZWZQdHI8TG9jYWxTdG9yYWdlVGFzaz4gPiBtX3F1ZXVlOwotICAgICAgICBU aW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IG1fdGltZXI7Ci0gICAgfTsKLQotfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gTG9jYWxTdG9yYWdlVGhyZWFkV2luY2VfaAo= 38370 2009-08-21 07:59:01 -0700 2009-08-21 08:02:32 -0700 fix a problem in last patch 28019.patch text/plain 33008 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTJhNWRlYy4uMjExZjkyYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAwOS0wOC0yMSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u CisgICAgICAgIFRoaXMgcGF0Y2ggYWxzbyByZXBsYWNlcyBzdG9yYWdlL3dpbmNlCisgICAgICAg IHdpdGggc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI4MDE5CisKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmg6IG1vZGlmaWVkCisgICAgICAgICogc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQu aDogbW9kaWZpZWQKKyAgICAgICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VBcmVhU3luYyk6CisgICAgICAg IChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKToKKyAgICAgICAgKFdl YkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9ydCk6CisgICAgICAgIChXZWJDb3Jl OjpTdG9yYWdlQXJlYVN5bmM6Om1hcmtJbXBvcnRlZCk6CisgICAgICAgIChXZWJDb3JlOjpTdG9y YWdlQXJlYVN5bmM6OnN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpw ZXJmb3JtU3luYyk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50 aWxJbXBvcnRDb21wbGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnNj aGVkdWxlSW1wb3J0KTogQWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6 b25JbXBvcnRlZCk6IEFkZGVkCisgICAgICAgICogc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaDoK KyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6aXNCYWNrZ3JvdW5kVGhyZWFkKTog QWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6U3luY011dGV4TG9ja2Vy OjpTeW5jTXV0ZXhMb2NrZXIpOiBBZGRlZAorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFT eW5jOjpJbXBvcnRNdXRleExvY2tlcjo6SW1wb3J0TXV0ZXhMb2NrZXIpOiBBZGRlZAorICAgICAg ICAqIHN0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcDogQWRkZWQuCisg ICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNwcDog QWRkZWQuCisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5j LmNwcDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNl LmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2lu Y2UuaDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVh ZFdpbmNlLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFn ZVRocmVhZFdpbmNlLmg6IFJlbW92ZWQuCisKIDIwMDktMDgtMTkgIEphbiBNaWNoYWVsIEFsb256 byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6 LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmggYi9XZWJDb3Jl L3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAppbmRleCA1OWQ3YTVkLi5lNjNhNzE5IDEwMDY0NAot LS0gYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvRGF0YWJhc2VUaHJlYWQuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMp IDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0 IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOSw2ICszMCw3IEBACiAjZGVmaW5lIERhdGFi YXNlVGhyZWFkX2gKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKKwogI2luY2x1ZGUgPHd0Zi9EZXF1 ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4K QEAgLTQwLDQ4ICs0Miw1OCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIERhdGFi YXNlOwotY2xhc3MgRGF0YWJhc2VUYXNrOwotY2xhc3MgRG9jdW1lbnQ7Ci1jbGFzcyBTUUxUcmFu c2FjdGlvbkNvb3JkaW5hdG9yOwotCi1jbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJl YWRTYWZlU2hhcmVkPERhdGFiYXNlVGhyZWFkPiB7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NS ZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBEYXRh YmFzZVRocmVhZCk7IH0KLSAgICB+RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIGJvb2wgc3RhcnQo KTsKLSAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAgIGJvb2wgdGVybWluYXRpb25S ZXF1ZXN0ZWQoKSBjb25zdDsKLQotICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0 YWJhc2VUYXNrPik7Ci0gICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxE YXRhYmFzZVRhc2s+KTsgLy8gVGhpcyBqdXN0IGFkZHMgdGhlIHRhc2sgdG8gdGhlIGZyb250IG9m IHRoZSBxdWV1ZSAtIHRoZSBjYWxsZXIgbmVlZHMgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwgbm90 IHRvIGNyZWF0ZSBkZWFkbG9ja3Mgd2hlbiB3YWl0aW5nIGZvciBjb21wbGV0aW9uLgotICAgIHZv aWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqKTsKLQotICAgIHZvaWQgcmVjb3Jk RGF0YWJhc2VPcGVuKERhdGFiYXNlKik7Ci0gICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChE YXRhYmFzZSopOwotICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSB7IHJldHVybiBt X3RocmVhZElEOyB9Ci0KLSAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2FjdGlv bkNvb3JkaW5hdG9yKCkgeyByZXR1cm4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmdldCgpOyB9 Ci0KLXByaXZhdGU6Ci0gICAgRGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIHN0YXRpYyB2b2lkKiBk YXRhYmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKLSAgICB2b2lkKiBkYXRhYmFzZVRocmVhZCgpOwot Ci0gICAgTXV0ZXggbV90aHJlYWRDcmVhdGlvbk11dGV4OwotICAgIFRocmVhZElkZW50aWZpZXIg bV90aHJlYWRJRDsKLSAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fc2VsZlJlZjsKLQotICAg IE1lc3NhZ2VRdWV1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7Ci0KLSAgICAvLyBU aGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFzZXMgdGhhdCBoYXZlIGJlZW4g dXNlZCBvbiB0aGlzIHRocmVhZC4KLSAgICB0eXBlZGVmIEhhc2hTZXQ8UmVmUHRyPERhdGFiYXNl PiA+IERhdGFiYXNlU2V0OwotICAgIERhdGFiYXNlU2V0IG1fb3BlbkRhdGFiYXNlU2V0OwotCi0g ICAgT3duUHRyPFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGlu YXRvcjsKLX07CisgICAgY2xhc3MgRGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNrOwor ICAgIGNsYXNzIERvY3VtZW50OworICAgIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I7 CisKKyAgICBjbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVkPERh dGFiYXNlVGhyZWFkPiB7CisgICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxE YXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFiYXNlVGhy ZWFkKTsgfQorICAgICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKKworICAgICAgICBib29sIHN0YXJ0 KCk7CisgICAgICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7CisgICAgICAgIGJvb2wgdGVy bWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsKKworICAgICAgICB2b2lkIHNjaGVkdWxlVGFzayhQ YXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOworICAgICAgICB2b2lkIHNjaGVkdWxlSW1tZWRpYXRl VGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOyAvLyBUaGlzIGp1c3QgYWRkcyB0aGUgdGFz ayB0byB0aGUgZnJvbnQgb2YgdGhlIHF1ZXVlIC0gdGhlIGNhbGxlciBuZWVkcyB0byBiZSBleHRy ZW1lbHkgY2FyZWZ1bCBub3QgdG8gY3JlYXRlIGRlYWRsb2NrcyB3aGVuIHdhaXRpbmcgZm9yIGNv bXBsZXRpb24uCisgICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2Uq KTsKKworICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOworICAgICAg ICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7CisjaWYgRU5BQkxFKFNJTkdM RV9USFJFQURFRCkKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsgcmV0 dXJuIGN1cnJlbnRUaHJlYWQoKTsgfQorI2Vsc2UKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBn ZXRUaHJlYWRJRCgpIHsgcmV0dXJuIG1fdGhyZWFkSUQ7IH0KKyNlbmRpZgorCisgICAgICAgIFNR TFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSB7IHJldHVy biBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0KKworICAgIHByaXZhdGU6CisgICAg ICAgIERhdGFiYXNlVGhyZWFkKCk7CisKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAg ICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+Kik7CisKKyAgICAgICAg RGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOworICAgICAgICBUaW1lcjxEYXRh YmFzZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCisgICAgICAgIHN0YXRpYyB2b2lkKiBkYXRhYmFz ZVRocmVhZFN0YXJ0KHZvaWQqKTsKKyAgICAgICAgdm9pZCogZGF0YWJhc2VUaHJlYWQoKTsKKwor ICAgICAgICBNdXRleCBtX3RocmVhZENyZWF0aW9uTXV0ZXg7CisgICAgICAgIFRocmVhZElkZW50 aWZpZXIgbV90aHJlYWRJRDsKKyAgICAgICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX3NlbGZS ZWY7CisKKyAgICAgICAgTWVzc2FnZVF1ZXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9xdWV1 ZTsKKworICAgICAgICAvLyBUaGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFz ZXMgdGhhdCBoYXZlIGJlZW4gdXNlZCBvbiB0aGlzIHRocmVhZC4KKyAgICAgICAgdHlwZWRlZiBI YXNoU2V0PFJlZlB0cjxEYXRhYmFzZT4gPiBEYXRhYmFzZVNldDsKKyAgICAgICAgRGF0YWJhc2VT ZXQgbV9vcGVuRGF0YWJhc2VTZXQ7CisjZW5kaWYKKyAgICAgICAgT3duUHRyPFNRTFRyYW5zYWN0 aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGluYXRvcjsKKyAgICB9OwogCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0 b3JhZ2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaAppbmRl eCAzZDU4NDI3Li5iMDE5YTU2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9y YWdlVGhyZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oCkBA IC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFsbCBS aWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMu IEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAg LTI4LDYgKzI5LDcgQEAKIAogI2lmIEVOQUJMRShET01fU1RPUkFHRSkKIAorI2luY2x1ZGUgPHd0 Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL01lc3Nh Z2VRdWV1ZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CkBAIC01Niw2ICs1OCwxMiBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgTG9jYWxTdG9yYWdl VGhyZWFkKCk7CiAKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICB2b2lkIHRp bWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOworCisgICAgICAgIERlcXVlPFJl ZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7CisgICAgICAgIFRpbWVyPExvY2FsU3Rv cmFnZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCiAgICAgICAgIHN0YXRpYyB2b2lkKiBsb2NhbFN0 b3JhZ2VUaHJlYWRTdGFydCh2b2lkKik7CiAgICAgICAgIHZvaWQqIGxvY2FsU3RvcmFnZVRocmVh ZCgpOwogCkBAIC02Nyw2ICs3NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAg ICAgICAgIE11dGV4IG1fdGVybWluYXRlTG9jazsKICAgICAgICAgVGhyZWFkQ29uZGl0aW9uIG1f dGVybWluYXRlQ29uZGl0aW9uOworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAppbmRleCAwMWQyYTY1Li40NGE0MmFm IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtNTUsMTUgKzU1LDExIEBAIFN0 b3JhZ2VBcmVhU3luYzo6U3RvcmFnZUFyZWFTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZVN5bmNNYW5h Z2VyPiBzdG9yYWdlU3luY01hbmFnCiAgICAgLCBtX3N5bmNNYW5hZ2VyKHN0b3JhZ2VTeW5jTWFu YWdlcikKICAgICAsIG1fY2xlYXJJdGVtc1doaWxlU3luY2luZyhmYWxzZSkKICAgICAsIG1fc3lu Y1NjaGVkdWxlZChmYWxzZSkKLSAgICAsIG1faW1wb3J0Q29tcGxldGUoZmFsc2UpCiB7CiAgICAg QVNTRVJUKG1fc3RvcmFnZUFyZWEpOwogICAgIEFTU0VSVChtX3N5bmNNYW5hZ2VyKTsKIAotICAg IC8vIEZJWE1FOiBJZiBpdCBjYW4ndCBpbXBvcnQsIHRoZW4gdGhlIGRlZmF1bHQgV2ViS2l0IGJl aGF2aW9yIHNob3VsZCBiZSB0aGF0IG9mIHByaXZhdGUgYnJvd3NpbmcsCi0gICAgLy8gbm90IHNp bGVudGx5IGlnbm9yaW5nIGl0LiAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTI1ODk0Ci0gICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0aGlzKSkK LSAgICAgICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7CisgICAgc2NoZWR1bGVJbXBvcnQoKTsK IH0KIAogU3RvcmFnZUFyZWFTeW5jOjp+U3RvcmFnZUFyZWFTeW5jKCkKQEAgLTEyOSw3ICsxMjUs NyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luY1RpbWVyRmlyZWQoVGltZXI8U3RvcmFnZUFy ZWFTeW5jPiopCiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGVuZCA9IG1f Y2hhbmdlZEl0ZW1zLmVuZCgpOwogICAgIAogICAgIHsKLSAgICAgICAgTXV0ZXhMb2NrZXIgbG9j a2VyKG1fc3luY0xvY2spOworICAgICAgICBTeW5jTXV0ZXhMb2NrZXIgbG9ja2VyKHRoaXMpOwog CiAgICAgICAgIGlmIChtX2l0ZW1zQ2xlYXJlZCkgewogICAgICAgICAgICAgbV9pdGVtc1BlbmRp bmdTeW5jLmNsZWFyKCk7CkBAIC0xNjAsNyArMTU2LDcgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6 OnN5bmNUaW1lckZpcmVkKFRpbWVyPFN0b3JhZ2VBcmVhU3luYz4qKQogCiB2b2lkIFN0b3JhZ2VB cmVhU3luYzo6cGVyZm9ybUltcG9ydCgpCiB7Ci0gICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7 CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsKICAgICBBU1NFUlQoIW1fZGF0YWJh c2UuaXNPcGVuKCkpOwogCiAgICAgU3RyaW5nIGRhdGFiYXNlRmlsZW5hbWUgPSBtX3N5bmNNYW5h Z2VyLT5mdWxsRGF0YWJhc2VGaWxlbmFtZShtX3N0b3JhZ2VBcmVhLT5zZWN1cml0eU9yaWdpbigp KTsKQEAgLTIwNCw3ICsyMDAsNyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9y dCgpCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBNdXRleExvY2tlciBsb2NrZXIobV9p bXBvcnRMb2NrKTsKKyAgICBJbXBvcnRNdXRleExvY2tlciBsb2NrZXIodGhpcyk7CiAgICAgCiAg ICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGl0ID0gaXRlbU1hcC5iZWdpbigp OwogICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+OjppdGVyYXRvciBlbmQgPSBpdGVtTWFwLmVu ZCgpOwpAQCAtMjE0LDQ2ICsyMTAsMjIgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1J bXBvcnQoKQogICAgIAogICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KICAgICBt X3N0b3JhZ2VBcmVhID0gMDsKLSAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1ZTsKLSAgICBtX2lt cG9ydENvbmRpdGlvbi5zaWduYWwoKTsKKyAgICBvbkltcG9ydGVkKCk7CiB9CiAKIHZvaWQgU3Rv cmFnZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWQoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFk KCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAKLSAgICBNdXRleExvY2tl ciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKKyAgICBJbXBvcnRNdXRleExvY2tlciBsb2NrZXIodGhp cyk7CiAgICAgLy8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xlLgogICAgIG1fc3RvcmFnZUFy ZWEgPSAwOwotICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOwotICAgIG1faW1wb3J0Q29uZGl0 aW9uLnNpZ25hbCgpOwotfQotCi0vLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFs bG93IHVzZSBvZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0 byBkbyBzbykuCi0vLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29t cGxldGUgaXMgYnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQK LS8vIHRoZXJlIGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xl bmd0aCB3aWxsIG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgotLy8gb3B0aW1p emF0aW9uIChzaW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMg YXJlIGJlaW5nIGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55Ci0vLyBpdGVtIGN1cnJlbnRseSBp biB0aGUgbWFwLiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhl IG1hcCwgYnV0IHdlJ2xsIG5lZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3Vs ZCBub3Qgb3ZlcndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBr aWxsIHRoZSBpbXBvcnQKLS8vIGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9j a1VudGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQo KSk7Ci0KLSAgICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KLSAgICBpZiAobV9pbXBv cnRDb21wbGV0ZSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1f aW1wb3J0TG9jayk7Ci0gICAgd2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQotICAgICAgICBtX2lt cG9ydENvbmRpdGlvbi53YWl0KG1faW1wb3J0TG9jayk7Ci0gICAgQVNTRVJUKG1faW1wb3J0Q29t cGxldGUpOwotICAgIEFTU0VSVCghbV9zdG9yYWdlQXJlYSk7CisgICAgb25JbXBvcnRlZCgpOwog fQogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhh c2hNYXA8U3RyaW5nLCBTdHJpbmc+JiBpdGVtcykKIHsKLSAgICBBU1NFUlQoIWlzTWFpblRocmVh ZCgpKTsKKyAgICBBU1NFUlQoaXNCYWNrZ3JvdW5kVGhyZWFkKCkpOwogCiAgICAgaWYgKCFtX2Rh dGFiYXNlLmlzT3BlbigpKQogICAgICAgICByZXR1cm47CkBAIC0zMDksMTIgKzI4MSwxMiBAQCB2 b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hNYXA8 U3RyaW5nLCBTdHJpbmc+JiBpdGVtcwogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybVN5 bmMoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tn cm91bmRUaHJlYWQoKSk7CiAKICAgICBib29sIGNsZWFySXRlbXM7CiAgICAgSGFzaE1hcDxTdHJp bmcsIFN0cmluZz4gaXRlbXM7CiAgICAgewotICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9z eW5jTG9jayk7CisgICAgICAgIFN5bmNNdXRleExvY2tlciBsb2NrZXIodGhpcyk7CiAKICAgICAg ICAgQVNTRVJUKG1fc3luY1NjaGVkdWxlZCk7CiAKQEAgLTMzMiw2ICszMDQsNDcgQEAgdm9pZCBT dG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1TeW5jKCkKICAgICBlbmFibGVTdWRkZW5UZXJtaW5hdGlv bigpOwogfQogCisjaWYgIUVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKy8vIEZJWE1FOiBJbiB0 aGUgZnV0dXJlLCB3ZSBzaG91bGQgYWxsb3cgdXNlIG9mIFN0b3JhZ2VBcmVhcyB3aGlsZSBpdCdz IGltcG9ydGluZyAod2hlbiBzYWZlIHRvIGRvIHNvKS4KKy8vIEJsb2NraW5nIGV2ZXJ5dGhpbmcg dW50aWwgdGhlIGltcG9ydCBpcyBjb21wbGV0ZSBpcyBieSBmYXIgdGhlIHNpbXBsZXN0IGFuZCBz YWZlc3QgdGhpbmcgdG8gZG8sIGJ1dAorLy8gdGhlcmUgaXMgY2VydGFpbmx5IHJvb20gZm9yIHNh ZmUgb3B0aW1pemF0aW9uOiBLZXkvbGVuZ3RoIHdpbGwgbmV2ZXIgYmUgYWJsZSB0byBtYWtlIHVz ZSBvZiBzdWNoIGFuCisvLyBvcHRpbWl6YXRpb24gKHNpbmNlIHRoZSBvcmRlciBvZiBpdGVyYXRp b24gY2FuIGNoYW5nZSBhcyBpdGVtcyBhcmUgYmVpbmcgYWRkZWQpLiBHZXQgY2FuIHJldHVybiBh bnkKKy8vIGl0ZW0gY3VycmVudGx5IGluIHRoZSBtYXAuIEdldC9yZW1vdmUgY2FuIHdvcmsgd2hl dGhlciBvciBub3QgaXQncyBpbiB0aGUgbWFwLCBidXQgd2UnbGwgbmVlZCBhIGxpc3QKKy8vIG9m IGl0ZW1zIHRoZSBpbXBvcnQgc2hvdWxkIG5vdCBvdmVyd3JpdGUuIENsZWFyIGNhbiBhbHNvIHdv cmssIGJ1dCBpdCdsbCBuZWVkIHRvIGtpbGwgdGhlIGltcG9ydAorLy8gam9iIGZpcnN0Lgordm9p ZCBTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50aWxJbXBvcnRDb21wbGV0ZSgpIGNvbnN0Cit7Cisg ICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKworICAgIC8vIEZhc3QgcGF0aCB0byBhdm9pZCBs b2NraW5nLgorICAgIGlmIChtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICByZXR1cm47CisKKyAg ICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKKyAgICB3aGlsZSAoIW1faW1wb3J0 Q29tcGxldGUpCisgICAgICAgIG1faW1wb3J0Q29uZGl0aW9uLndhaXQobV9pbXBvcnRMb2NrKTsK KyAgICBBU1NFUlQobV9pbXBvcnRDb21wbGV0ZSk7CisgICAgQVNTRVJUKCFtX3N0b3JhZ2VBcmVh KTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OnNjaGVkdWxlSW1wb3J0KCkKK3sKKyAgICBt X2ltcG9ydENvbXBsZXRlID0gZmFsc2U7CisgICAgLy8gRklYTUU6IElmIGl0IGNhbid0IGltcG9y dCwgdGhlbiB0aGUgZGVmYXVsdCBXZWJLaXQgYmVoYXZpb3Igc2hvdWxkIGJlIHRoYXQgb2YgcHJp dmF0ZSBicm93c2luZywKKyAgICAvLyBub3Qgc2lsZW50bHkgaWdub3JpbmcgaXQuICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTQKKyAgICBpZiAoIW1fc3luY01h bmFnZXItPnNjaGVkdWxlSW1wb3J0KHRoaXMpKQorICAgICAgICBtX2ltcG9ydENvbXBsZXRlID0g dHJ1ZTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6Om9uSW1wb3J0ZWQoKQoreworICAgIG1f aW1wb3J0Q29tcGxldGUgPSB0cnVlOworICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25hbCgpOwor fQorCisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxF KERPTV9TVE9SQUdFKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3lu Yy5oIGIvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCmluZGV4IGU0MzZiZWYuLmRl NDg4OWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKQEAgLTc4LDE1ICs3OCw0MSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc3luY1RpbWVyRmlyZWQoVGltZXI8U3Rv cmFnZUFyZWFTeW5jPiopOwogICAgICAgICB2b2lkIHN5bmMoYm9vbCBjbGVhckl0ZW1zLCBjb25z dCBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiYgaXRlbXMpOwogCi0gICAgICAgIE11dGV4IG1fc3lu Y0xvY2s7CiAgICAgICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+IG1faXRlbXNQZW5kaW5nU3lu YzsKICAgICAgICAgYm9vbCBtX2NsZWFySXRlbXNXaGlsZVN5bmNpbmc7CiAgICAgICAgIGJvb2wg bV9zeW5jU2NoZWR1bGVkOwogCisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAg IHZvaWQgc2NoZWR1bGVJbXBvcnQoKTsKKyAgICAgICAgdm9pZCBvbkltcG9ydGVkKCk7CisKKyNp ZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICBib29sIGlzQmFja2dyb3VuZFRocmVh ZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyAgICAgICAgc3RydWN0IFN5bmNNdXRleExvY2tl cgorICAgICAgICB7CisgICAgICAgICAgICBTeW5jTXV0ZXhMb2NrZXIodm9pZCopIHt9CisgICAg ICAgIH07CisgICAgICAgIHN0cnVjdCBJbXBvcnRNdXRleExvY2tlcgorICAgICAgICB7CisgICAg ICAgICAgICBJbXBvcnRNdXRleExvY2tlcihjb25zdCB2b2lkKikge30KKyAgICAgICAgfTsKKyNl bHNlCisgICAgICAgIE11dGV4IG1fc3luY0xvY2s7CisgICAgICAgIG11dGFibGUgYm9vbCBtX2lt cG9ydENvbXBsZXRlOwogICAgICAgICBtdXRhYmxlIE11dGV4IG1faW1wb3J0TG9jazsKICAgICAg ICAgbXV0YWJsZSBUaHJlYWRDb25kaXRpb24gbV9pbXBvcnRDb25kaXRpb247Ci0gICAgICAgIG11 dGFibGUgYm9vbCBtX2ltcG9ydENvbXBsZXRlOwotICAgICAgICB2b2lkIG1hcmtJbXBvcnRlZCgp OworICAgICAgICBib29sIGlzQmFja2dyb3VuZFRocmVhZCgpIGNvbnN0IHsgcmV0dXJuICFpc01h aW5UaHJlYWQoKTsgfQorICAgICAgICBmcmllbmQgY2xhc3MgU3luY011dGV4TG9ja2VyOworICAg ICAgICBmcmllbmQgY2xhc3MgSW1wb3J0TXV0ZXhMb2NrZXI7CisgICAgICAgIHN0cnVjdCBTeW5j TXV0ZXhMb2NrZXI6IHByaXZhdGUgTXV0ZXh0TG9ja2VyCisgICAgICAgIHsKKyAgICAgICAgICAg IFN5bmNNdXRleExvY2tlcihTdG9yYWdlQXJlYVN5bmMqIHN0b3JhZ2VBcmVhU3luYykgOiBNdXRl eHRMb2NrZXIoc3RvcmFnZUFyZWFTeW5jLT5tX3N5bmNMb2NrKSB7fQorICAgICAgICB9OworICAg ICAgICBzdHJ1Y3QgSW1wb3J0TXV0ZXhMb2NrZXI6IHByaXZhdGUgTXV0ZXh0TG9ja2VyCisgICAg ICAgIHsKKyAgICAgICAgICAgIEltcG9ydE11dGV4TG9ja2VyKGNvbnN0IFN0b3JhZ2VBcmVhU3lu Yyogc3RvcmFnZUFyZWFTeW5jKSA6IE11dGV4dExvY2tlcihzdG9yYWdlQXJlYVN5bmMtPm1faW1w b3J0TG9jaykge30KKyAgICAgICAgfTsKKyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0 YWJhc2VUaHJlYWQuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFz ZVRocmVhZC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGNjYTdmOAot LS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJh c2VUaHJlYWQuY3BwCkBAIC0wLDAgKzEsMTEwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5 IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq ICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUg dXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQor ICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJ ZiBub3QsIHdyaXRlIHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwg NTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEz MDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VU aHJlYWQuaCIKKworI2lmIEVOQUJMRShET01fU1RPUkFHRSkKKyNpZiBFTkFCTEUoU0lOR0xFX1RI UkVBREVEKQorCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2su aCIKKyNpbmNsdWRlICJTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKKyAgICA6IG1fdGlt ZXIodGhpcywgJkRhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKQorICAgICwgbV90cmFuc2FjdGlv bkNvb3JkaW5hdG9yKG5ldyBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkpCit7Cit9CisKK0Rh dGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQoKQoreworfQorCitib29sIERhdGFiYXNlVGhy ZWFkOjpzdGFydCgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJl YWQ6OnJlcXVlc3RUZXJtaW5hdGlvbigpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1f dHJhbnNhY3Rpb25Db29yZGluYXRvci0+c2h1dGRvd24oKTsKK30KKworYm9vbCBEYXRhYmFzZVRo cmVhZDo6dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdAoreworICAgIHJldHVybiBtX3F1ZXVl LmlzRW1wdHkoKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxE YXRhYmFzZVRocmVhZD4qKQoreworICAgIGlmIChtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3Qo KTsKKyAgICB0YXNrLT5wZXJmb3JtVGFzaygpOworICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsK KyAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hv dCgwKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2VUYXNrPiB0YXNrKQoreworICAgIG1fcXVldWUuYXBwZW5kKHRhc2spOworICAgIGlm ICghbV90aW1lci5pc0FjdGl2ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsK K30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQ dHI8RGF0YWJhc2VUYXNrPiB0YXNrKQoreworICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Cit9CisK K3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNlKiBk YXRhYmFzZSkKK3sKKyAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IHJlc2VydmVkVGFz a3M7CisgICAgZm9yIChEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+Ojpjb25zdF9pdGVyYXRv ciBpID0gbV9xdWV1ZS5iZWdpbigpOyBpICE9IG1fcXVldWUuZW5kKCk7ICsraSkgeworICAgICAg ICBpZiAoKCppKS0+ZGF0YWJhc2UoKSAhPSBkYXRhYmFzZSkKKyAgICAgICAgICAgIHJlc2VydmVk VGFza3MuYXBwZW5kKCppKTsKKyAgICB9CisKKyAgICBtX3F1ZXVlLnN3YXAocmVzZXJ2ZWRUYXNr cyk7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFz ZSogZGF0YWJhc2UpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBEYXRhYmFz ZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAg IG5vdEltcGxlbWVudGVkKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlm IC8vIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9SQUdF KQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3Jh Z2VUaHJlYWQuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3Jh Z2VUaHJlYWQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJjNmYyYWIK LS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2Fs U3RvcmFnZVRocmVhZC5jcHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAq CisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxs IGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2 ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UKKyAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElC LiAgSWYgbm90LCB3cml0ZSB0bworICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjEx MC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkxvY2Fs U3RvcmFnZVRocmVhZC5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShT SU5HTEVfVEhSRUFERUQpCisKKyNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCisjaW5jbHVk ZSAiU3RvcmFnZUFyZWFTeW5jLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUGFzc1JlZlB0 cjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IExvY2FsU3RvcmFnZVRocmVhZDo6Y3JlYXRlKCkKK3sKKyAg ICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsU3RvcmFnZVRocmVhZCk7Cit9CisKK0xvY2FsU3Rv cmFnZVRocmVhZDo6TG9jYWxTdG9yYWdlVGhyZWFkKCkKKzogbV90aW1lcih0aGlzLCAmTG9jYWxT dG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKQoreworfQorCitib29sIExvY2FsU3RvcmFnZVRocmVh ZDo6c3RhcnQoKQoreworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRo cmVhZDo6dGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+KikKK3sKKyAgICBpZiAo bV9xdWV1ZS5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxMb2NhbFN0 b3JhZ2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOworICAgIG1fcXVldWUucmVtb3ZlRmly c3QoKTsKKyAgICB0YXNrLT5wZXJmb3JtVGFzaygpOworICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5 KCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3Rv cmFnZVRocmVhZDo6c2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFy ZWEpCit7CisgICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlSW1wb3J0 KGFyZWEpKTsKKyAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKKyAgICAgICAgbV90aW1lci5z dGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZVN5 bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCit7CisgICAgbV9xdWV1ZS5hcHBl bmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlU3luYyhhcmVhKSk7CisgICAgaWYgKCFtX3RpbWVy LmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lk IExvY2FsU3RvcmFnZVRocmVhZDo6dGVybWluYXRlKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7 CisgICAgbV90aW1lci5zdG9wKCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpwZXJm b3JtVGVybWluYXRlKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7CisgICAgbV90aW1lci5zdG9w KCk7Cit9CisKK30KKyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorI2VuZGlmIC8v IEVOQUJMRShET01fU1RPUkFHRSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUt dGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhy ZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi5lNDQ0MDA4Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10 aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMuY3BwCkBAIC0wLDAgKzEsNjIgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICog Q29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQor ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IlN0b3JhZ2VBcmVhU3luYy5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJM RShTSU5HTEVfVEhSRUFERUQpCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAiRXZl bnROYW1lcy5oIgorI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCisjaW5jbHVkZSAiU1FMaXRlU3Rh dGVtZW50LmgiCisjaW5jbHVkZSAiU3RvcmFnZUFyZWFJbXBsLmgiCisjaW5jbHVkZSAiU3RvcmFn ZVN5bmNNYW5hZ2VyLmgiCisjaW5jbHVkZSAiU3VkZGVuVGVybWluYXRpb24uaCIKKworbmFtZXNw YWNlIFdlYkNvcmUgeworCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c2NoZWR1bGVJbXBvcnQoKQor eworICAgIC8vIERvIGEgYmxvY2tpbmcgaW1wb3J0IGJlY2F1c2Ugd2UgY2Fubm90ICJibG9ja1Vu dGlsSW1wb3J0Q29tcGxldGUiIHdpdGggb25lIHRocmVhZAorICAgIHBlcmZvcm1JbXBvcnQoKTsK K30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6Om9uSW1wb3J0ZWQoKQoreworfQorCit2b2lkIFN0 b3JhZ2VBcmVhU3luYzo6YmxvY2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3QKK3sKKyAgICAv LyBXZSBoYXZlIGFscmVhZHkgaW1wb3J0ZWQgaW4gc2NoZWR1bGVJbXBvcnQoKQorfQorCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQor I2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKKwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9y YWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNl L0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBk ODExNDVkLi4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVh ZFdpbmNlLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDk1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmln aHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgot ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZ SU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRl ICJEYXRhYmFzZVRocmVhZC5oIgotCi0jaW5jbHVkZSAiRGF0YWJhc2UuaCIKLSNpbmNsdWRlICJE YXRhYmFzZVRhc2suaCIKLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1EYXRhYmFzZVRocmVhZDo6 RGF0YWJhc2VUaHJlYWQoKQotOiBtX3RpbWVyKHRoaXMsICZEYXRhYmFzZVRocmVhZDo6dGltZXJG aXJlZCkKLXsKLX0KLQotRGF0YWJhc2VUaHJlYWQ6On5EYXRhYmFzZVRocmVhZCgpCi17Ci19Ci0K LXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbigpCi17Ci0gICAgbV9xdWV1 ZS5jbGVhcigpOwotfQotCi1ib29sIERhdGFiYXNlVGhyZWFkOjp0ZXJtaW5hdGlvblJlcXVlc3Rl ZCgpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fcXVldWUuaXNFbXB0eSgpOwotfQotCi12b2lkIERh dGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNlVGhyZWFkPiopCi17Ci0gICAg aWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkgewotICAgICAgICBSZWZQdHI8RGF0YWJhc2VUYXNrPiB0 YXNrID0gbV9xdWV1ZS5maXJzdCgpOwotICAgICAgICB0YXNrLT5wZXJmb3JtVGFzaygpOwotICAg ICAgICBtX3F1ZXVlLnJlbW92ZUZpcnN0KCk7Ci0gICAgICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5 KCkpCi0gICAgICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLSAgICB9Ci19Ci0KLXZv aWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4g dGFzaykKLXsKLSAgICBtX3F1ZXVlLmFwcGVuZCh0YXNrKTsKLSAgICBpZiAoIW1fdGltZXIuaXNB Y3RpdmUoKSkKLSAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci19Ci0KLXZvaWQgRGF0 YWJhc2VUaHJlYWQ6OnNjaGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFz az4gdGFzaykKLXsKLSAgICB0YXNrLT5wZXJmb3JtVGFzaygpOwotfQotCi12b2lkIERhdGFiYXNl VGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0g ICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiByZXNlcnZlZFRhc2tzOwotICAgIGZvciAo RGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPjo6Y29uc3RfaXRlcmF0b3IgaSA9IG1fcXVldWUu YmVnaW4oKTsgaSAhPSBtX3F1ZXVlLmVuZCgpOyArK2kpIHsKLSAgICAgICAgaWYgKCgqaSktPmRh dGFiYXNlKCkgIT0gZGF0YWJhc2UpCi0gICAgICAgICAgICByZXNlcnZlZFRhc2tzLmFwcGVuZCgq aSk7Ci0gICAgfQotCi0gICAgbV9xdWV1ZS5zd2FwKHJlc2VydmVkVGFza3MpOwotfQotCi12b2lk IERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZU9wZW4oRGF0YWJhc2UqIGRhdGFiYXNlKQot ewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29y ZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOwotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0 b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5oIGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNl L0RhdGFiYXNlVGhyZWFkV2luY2UuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZmFm Yzc5MS4uMDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRX aW5jZS5oCisrKyAvZGV2L251bGwKQEAgLTEsNjUgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAo QykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K LSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3 aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQg aGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bwotICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24s IEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAw MjExMC0xMzAxLCBVU0EuCi0gKi8KLQotI2lmbmRlZiBEYXRhYmFzZVRocmVhZFdpbmNlX2gKLSNk ZWZpbmUgRGF0YWJhc2VUaHJlYWRXaW5jZV9oCi0KLSNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KLSNp bmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLSAgICBj bGFzcyBEYXRhYmFzZTsKLSAgICBjbGFzcyBEYXRhYmFzZVRhc2s7Ci0KLSAgICBjbGFzcyBEYXRh YmFzZVRocmVhZDogcHVibGljIFdURjo6UmVmQ291bnRlZDxEYXRhYmFzZVRocmVhZD4gewotCi0g ICAgcHVibGljOgotICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxEYXRhYmFzZVRocmVhZD4gY3Jl YXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFiYXNlVGhyZWFkKTsgfQotICAgICAgICB+ RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgICAgICBib29sIHN0YXJ0KCkgeyByZXR1cm4gdHJ1ZTsg fQotICAgICAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAgICAgICBib29sIHRlcm1p bmF0aW9uUmVxdWVzdGVkKCkgY29uc3Q7Ci0KLSAgICAgICAgdm9pZCBzY2hlZHVsZVRhc2soUGFz c1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsKLSAgICAgICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRh c2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsKLSAgICAgICAgdm9pZCB1bnNjaGVkdWxlRGF0 YWJhc2VUYXNrcyhEYXRhYmFzZSopOwotICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihE YXRhYmFzZSopOwotICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7 Ci0jaWZuZGVmIE5ERUJVRwotICAgICAgICBUaHJlYWRJZGVudGlmaWVyIGdldFRocmVhZElEKCkg Y29uc3QgeyByZXR1cm4gY3VycmVudFRocmVhZCgpOyB9Ci0jZW5kaWYKLQotICAgIHByaXZhdGU6 Ci0gICAgICAgIERhdGFiYXNlVGhyZWFkKCk7Ci0KLSAgICAgICAgdm9pZCB0aW1lckZpcmVkKFRp bWVyPERhdGFiYXNlVGhyZWFkPiopOwotCi0gICAgICAgIERlcXVlPFJlZlB0cjxEYXRhYmFzZVRh c2s+ID4gbV9xdWV1ZTsKLSAgICAgICAgVGltZXI8RGF0YWJhc2VUaHJlYWQ+IG1fdGltZXI7Ci0g ICAgfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gRGF0YWJhc2VUaHJl YWRXaW5jZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRo cmVhZFdpbmNlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRX aW5jZS5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhkY2I5MDIuLjAwMDAwMDAK LS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNwcAor KysgL2Rldi9udWxsCkBAIC0xLDgzICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkg VG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICog IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1 c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0g KiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElm IG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMw MSwgVVNBLgotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJMb2NhbFN0b3Jh Z2VUaHJlYWQuaCIKLQotI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRhc2suaCIKLSNpbmNsdWRlICJT dG9yYWdlQXJlYVN5bmMuaCIKLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1Mb2NhbFN0b3JhZ2VU aHJlYWQ6OkxvY2FsU3RvcmFnZVRocmVhZCgpCi06IG1fdGltZXIodGhpcywgJkxvY2FsU3RvcmFn ZVRocmVhZDo6dGltZXJGaXJlZCkKLXsKLX0KLQotTG9jYWxTdG9yYWdlVGhyZWFkOjp+TG9jYWxT dG9yYWdlVGhyZWFkKCkKLXsKLX0KLQotYm9vbCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnN0YXJ0KCkK LXsKLSAgICByZXR1cm4gdHJ1ZTsKLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVy RmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopCi17Ci0gICAgaWYgKCFtX3F1ZXVlLmlz RW1wdHkoKSkgewotICAgICAgICBSZWZQdHI8TG9jYWxTdG9yYWdlVGFzaz4gdGFzayA9IG1fcXVl dWUuZmlyc3QoKTsKLSAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLSAgICAgICAgbV9xdWV1 ZS5yZW1vdmVGaXJzdCgpOwotICAgICAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQotICAgICAg ICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci0gICAgfQotfQotCi12b2lkIExvY2FsU3Rv cmFnZVRocmVhZDo6c2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFy ZWEpCi17Ci0gICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlSW1wb3J0 KGFyZWEpKTsKLSAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAgICAgICAgbV90aW1lci5z dGFydE9uZVNob3QoMCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZVN5 bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCi17Ci0gICAgbV9xdWV1ZS5hcHBl bmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlU3luYyhhcmVhKSk7Ci0gICAgaWYgKCFtX3RpbWVy LmlzQWN0aXZlKCkpCi0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwotfQotCi12b2lk IExvY2FsU3RvcmFnZVRocmVhZDo6dGVybWluYXRlKCkKLXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7 Ci0gICAgbV90aW1lci5zdG9wKCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpwZXJm b3JtVGVybWluYXRlKCkKLXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7Ci0gICAgbV90aW1lci5zdG9w KCk7Ci19Ci0KLX0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3Jh Z2VUaHJlYWRXaW5jZS5oIGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVh ZFdpbmNlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMwMGFiYjUuLjAwMDAwMDAK LS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmgKKysr IC9kZXYvbnVsbApAQCAtMSw1OCArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRv cmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAot ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBU aGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNl ZnVsLAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICog IGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBu b3QsIHdyaXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEg RnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEs IFVTQS4KLSAqLwotCi0KLSNpZm5kZWYgTG9jYWxTdG9yYWdlVGhyZWFkV2luY2VfaAotI2RlZmlu ZSBMb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZV9oCi0KLSNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KLSNp bmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLSAgICBj bGFzcyBTdG9yYWdlQXJlYVN5bmM7Ci0gICAgY2xhc3MgTG9jYWxTdG9yYWdlVGFzazsKLQotICAg IGNsYXNzIExvY2FsU3RvcmFnZVRocmVhZCA6IHB1YmxpYyBSZWZDb3VudGVkPExvY2FsU3RvcmFn ZVRocmVhZD4gewotICAgIHB1YmxpYzoKLSAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8TG9jYWxT dG9yYWdlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBhZG9wdFJlZihuZXcgTG9jYWxTdG9yYWdl VGhyZWFkKTsgfQotCi0gICAgICAgIH5Mb2NhbFN0b3JhZ2VUaHJlYWQoKTsKLSAgICAgICAgYm9v bCBzdGFydCgpOwotICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFn ZUFyZWFTeW5jPik7Ci0gICAgICAgIHZvaWQgc2NoZWR1bGVTeW5jKFBhc3NSZWZQdHI8U3RvcmFn ZUFyZWFTeW5jPik7Ci0gICAgICAgIHZvaWQgdGVybWluYXRlKCk7Ci0gICAgICAgIHZvaWQgcGVy Zm9ybVRlcm1pbmF0ZSgpOwotCi0gICAgcHJpdmF0ZToKLSAgICAgICAgTG9jYWxTdG9yYWdlVGhy ZWFkKCk7Ci0KLSAgICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPExvY2FsU3RvcmFnZVRocmVh ZD4qKTsKLQotICAgICAgICBEZXF1ZTxSZWZQdHI8TG9jYWxTdG9yYWdlVGFzaz4gPiBtX3F1ZXVl OwotICAgICAgICBUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IG1fdGltZXI7Ci0gICAgfTsKLQot fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gTG9jYWxTdG9yYWdlVGhyZWFkV2lu Y2VfaAo= 38371 2009-08-21 08:02:32 -0700 2009-08-21 08:16:09 -0700 more refactoring 28019.patch text/plain 32747 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTJhNWRlYy4uMjExZjkyYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAwOS0wOC0yMSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u CisgICAgICAgIFRoaXMgcGF0Y2ggYWxzbyByZXBsYWNlcyBzdG9yYWdlL3dpbmNlCisgICAgICAg IHdpdGggc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI4MDE5CisKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmg6IG1vZGlmaWVkCisgICAgICAgICogc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQu aDogbW9kaWZpZWQKKyAgICAgICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VBcmVhU3luYyk6CisgICAgICAg IChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKToKKyAgICAgICAgKFdl YkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9ydCk6CisgICAgICAgIChXZWJDb3Jl OjpTdG9yYWdlQXJlYVN5bmM6Om1hcmtJbXBvcnRlZCk6CisgICAgICAgIChXZWJDb3JlOjpTdG9y YWdlQXJlYVN5bmM6OnN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpw ZXJmb3JtU3luYyk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50 aWxJbXBvcnRDb21wbGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnNj aGVkdWxlSW1wb3J0KTogQWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6 b25JbXBvcnRlZCk6IEFkZGVkCisgICAgICAgICogc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaDoK KyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6aXNCYWNrZ3JvdW5kVGhyZWFkKTog QWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6U3luY011dGV4TG9ja2Vy OjpTeW5jTXV0ZXhMb2NrZXIpOiBBZGRlZAorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFT eW5jOjpJbXBvcnRNdXRleExvY2tlcjo6SW1wb3J0TXV0ZXhMb2NrZXIpOiBBZGRlZAorICAgICAg ICAqIHN0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcDogQWRkZWQuCisg ICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNwcDog QWRkZWQuCisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5j LmNwcDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNl LmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2lu Y2UuaDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVh ZFdpbmNlLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFn ZVRocmVhZFdpbmNlLmg6IFJlbW92ZWQuCisKIDIwMDktMDgtMTkgIEphbiBNaWNoYWVsIEFsb256 byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6 LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmggYi9XZWJDb3Jl L3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAppbmRleCA1OWQ3YTVkLi5lNjNhNzE5IDEwMDY0NAot LS0gYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvRGF0YWJhc2VUaHJlYWQuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMp IDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0 IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOSw2ICszMCw3IEBACiAjZGVmaW5lIERhdGFi YXNlVGhyZWFkX2gKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKKwogI2luY2x1ZGUgPHd0Zi9EZXF1 ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4K QEAgLTQwLDQ4ICs0Miw1OCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIERhdGFi YXNlOwotY2xhc3MgRGF0YWJhc2VUYXNrOwotY2xhc3MgRG9jdW1lbnQ7Ci1jbGFzcyBTUUxUcmFu c2FjdGlvbkNvb3JkaW5hdG9yOwotCi1jbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJl YWRTYWZlU2hhcmVkPERhdGFiYXNlVGhyZWFkPiB7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NS ZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBEYXRh YmFzZVRocmVhZCk7IH0KLSAgICB+RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIGJvb2wgc3RhcnQo KTsKLSAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAgIGJvb2wgdGVybWluYXRpb25S ZXF1ZXN0ZWQoKSBjb25zdDsKLQotICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0 YWJhc2VUYXNrPik7Ci0gICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxE YXRhYmFzZVRhc2s+KTsgLy8gVGhpcyBqdXN0IGFkZHMgdGhlIHRhc2sgdG8gdGhlIGZyb250IG9m IHRoZSBxdWV1ZSAtIHRoZSBjYWxsZXIgbmVlZHMgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwgbm90 IHRvIGNyZWF0ZSBkZWFkbG9ja3Mgd2hlbiB3YWl0aW5nIGZvciBjb21wbGV0aW9uLgotICAgIHZv aWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqKTsKLQotICAgIHZvaWQgcmVjb3Jk RGF0YWJhc2VPcGVuKERhdGFiYXNlKik7Ci0gICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChE YXRhYmFzZSopOwotICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSB7IHJldHVybiBt X3RocmVhZElEOyB9Ci0KLSAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2FjdGlv bkNvb3JkaW5hdG9yKCkgeyByZXR1cm4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmdldCgpOyB9 Ci0KLXByaXZhdGU6Ci0gICAgRGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIHN0YXRpYyB2b2lkKiBk YXRhYmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKLSAgICB2b2lkKiBkYXRhYmFzZVRocmVhZCgpOwot Ci0gICAgTXV0ZXggbV90aHJlYWRDcmVhdGlvbk11dGV4OwotICAgIFRocmVhZElkZW50aWZpZXIg bV90aHJlYWRJRDsKLSAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fc2VsZlJlZjsKLQotICAg IE1lc3NhZ2VRdWV1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7Ci0KLSAgICAvLyBU aGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFzZXMgdGhhdCBoYXZlIGJlZW4g dXNlZCBvbiB0aGlzIHRocmVhZC4KLSAgICB0eXBlZGVmIEhhc2hTZXQ8UmVmUHRyPERhdGFiYXNl PiA+IERhdGFiYXNlU2V0OwotICAgIERhdGFiYXNlU2V0IG1fb3BlbkRhdGFiYXNlU2V0OwotCi0g ICAgT3duUHRyPFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGlu YXRvcjsKLX07CisgICAgY2xhc3MgRGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNrOwor ICAgIGNsYXNzIERvY3VtZW50OworICAgIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I7 CisKKyAgICBjbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVkPERh dGFiYXNlVGhyZWFkPiB7CisgICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxE YXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFiYXNlVGhy ZWFkKTsgfQorICAgICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKKworICAgICAgICBib29sIHN0YXJ0 KCk7CisgICAgICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7CisgICAgICAgIGJvb2wgdGVy bWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsKKworICAgICAgICB2b2lkIHNjaGVkdWxlVGFzayhQ YXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOworICAgICAgICB2b2lkIHNjaGVkdWxlSW1tZWRpYXRl VGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOyAvLyBUaGlzIGp1c3QgYWRkcyB0aGUgdGFz ayB0byB0aGUgZnJvbnQgb2YgdGhlIHF1ZXVlIC0gdGhlIGNhbGxlciBuZWVkcyB0byBiZSBleHRy ZW1lbHkgY2FyZWZ1bCBub3QgdG8gY3JlYXRlIGRlYWRsb2NrcyB3aGVuIHdhaXRpbmcgZm9yIGNv bXBsZXRpb24uCisgICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2Uq KTsKKworICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOworICAgICAg ICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7CisjaWYgRU5BQkxFKFNJTkdM RV9USFJFQURFRCkKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsgcmV0 dXJuIGN1cnJlbnRUaHJlYWQoKTsgfQorI2Vsc2UKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBn ZXRUaHJlYWRJRCgpIHsgcmV0dXJuIG1fdGhyZWFkSUQ7IH0KKyNlbmRpZgorCisgICAgICAgIFNR TFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSB7IHJldHVy biBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0KKworICAgIHByaXZhdGU6CisgICAg ICAgIERhdGFiYXNlVGhyZWFkKCk7CisKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAg ICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+Kik7CisKKyAgICAgICAg RGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOworICAgICAgICBUaW1lcjxEYXRh YmFzZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCisgICAgICAgIHN0YXRpYyB2b2lkKiBkYXRhYmFz ZVRocmVhZFN0YXJ0KHZvaWQqKTsKKyAgICAgICAgdm9pZCogZGF0YWJhc2VUaHJlYWQoKTsKKwor ICAgICAgICBNdXRleCBtX3RocmVhZENyZWF0aW9uTXV0ZXg7CisgICAgICAgIFRocmVhZElkZW50 aWZpZXIgbV90aHJlYWRJRDsKKyAgICAgICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX3NlbGZS ZWY7CisKKyAgICAgICAgTWVzc2FnZVF1ZXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9xdWV1 ZTsKKworICAgICAgICAvLyBUaGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFz ZXMgdGhhdCBoYXZlIGJlZW4gdXNlZCBvbiB0aGlzIHRocmVhZC4KKyAgICAgICAgdHlwZWRlZiBI YXNoU2V0PFJlZlB0cjxEYXRhYmFzZT4gPiBEYXRhYmFzZVNldDsKKyAgICAgICAgRGF0YWJhc2VT ZXQgbV9vcGVuRGF0YWJhc2VTZXQ7CisjZW5kaWYKKyAgICAgICAgT3duUHRyPFNRTFRyYW5zYWN0 aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGluYXRvcjsKKyAgICB9OwogCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0 b3JhZ2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaAppbmRl eCAzZDU4NDI3Li5iMDE5YTU2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9y YWdlVGhyZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oCkBA IC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFsbCBS aWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMu IEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAg LTI4LDYgKzI5LDcgQEAKIAogI2lmIEVOQUJMRShET01fU1RPUkFHRSkKIAorI2luY2x1ZGUgPHd0 Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL01lc3Nh Z2VRdWV1ZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CkBAIC01Niw2ICs1OCwxMiBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgTG9jYWxTdG9yYWdl VGhyZWFkKCk7CiAKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICB2b2lkIHRp bWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOworCisgICAgICAgIERlcXVlPFJl ZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7CisgICAgICAgIFRpbWVyPExvY2FsU3Rv cmFnZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCiAgICAgICAgIHN0YXRpYyB2b2lkKiBsb2NhbFN0 b3JhZ2VUaHJlYWRTdGFydCh2b2lkKik7CiAgICAgICAgIHZvaWQqIGxvY2FsU3RvcmFnZVRocmVh ZCgpOwogCkBAIC02Nyw2ICs3NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAg ICAgICAgIE11dGV4IG1fdGVybWluYXRlTG9jazsKICAgICAgICAgVGhyZWFkQ29uZGl0aW9uIG1f dGVybWluYXRlQ29uZGl0aW9uOworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAppbmRleCAwMWQyYTY1Li40NGE0MmFm IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtNTUsMTUgKzU1LDExIEBAIFN0 b3JhZ2VBcmVhU3luYzo6U3RvcmFnZUFyZWFTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZVN5bmNNYW5h Z2VyPiBzdG9yYWdlU3luY01hbmFnCiAgICAgLCBtX3N5bmNNYW5hZ2VyKHN0b3JhZ2VTeW5jTWFu YWdlcikKICAgICAsIG1fY2xlYXJJdGVtc1doaWxlU3luY2luZyhmYWxzZSkKICAgICAsIG1fc3lu Y1NjaGVkdWxlZChmYWxzZSkKLSAgICAsIG1faW1wb3J0Q29tcGxldGUoZmFsc2UpCiB7CiAgICAg QVNTRVJUKG1fc3RvcmFnZUFyZWEpOwogICAgIEFTU0VSVChtX3N5bmNNYW5hZ2VyKTsKIAotICAg IC8vIEZJWE1FOiBJZiBpdCBjYW4ndCBpbXBvcnQsIHRoZW4gdGhlIGRlZmF1bHQgV2ViS2l0IGJl aGF2aW9yIHNob3VsZCBiZSB0aGF0IG9mIHByaXZhdGUgYnJvd3NpbmcsCi0gICAgLy8gbm90IHNp bGVudGx5IGlnbm9yaW5nIGl0LiAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTI1ODk0Ci0gICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0aGlzKSkK LSAgICAgICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7CisgICAgc2NoZWR1bGVJbXBvcnQoKTsK IH0KIAogU3RvcmFnZUFyZWFTeW5jOjp+U3RvcmFnZUFyZWFTeW5jKCkKQEAgLTEyOSw3ICsxMjUs NyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luY1RpbWVyRmlyZWQoVGltZXI8U3RvcmFnZUFy ZWFTeW5jPiopCiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGVuZCA9IG1f Y2hhbmdlZEl0ZW1zLmVuZCgpOwogICAgIAogICAgIHsKLSAgICAgICAgTXV0ZXhMb2NrZXIgbG9j a2VyKG1fc3luY0xvY2spOworICAgICAgICBTeW5jTXV0ZXhMb2NrZXIgbG9ja2VyKHRoaXMpOwog CiAgICAgICAgIGlmIChtX2l0ZW1zQ2xlYXJlZCkgewogICAgICAgICAgICAgbV9pdGVtc1BlbmRp bmdTeW5jLmNsZWFyKCk7CkBAIC0xNjAsNyArMTU2LDcgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6 OnN5bmNUaW1lckZpcmVkKFRpbWVyPFN0b3JhZ2VBcmVhU3luYz4qKQogCiB2b2lkIFN0b3JhZ2VB cmVhU3luYzo6cGVyZm9ybUltcG9ydCgpCiB7Ci0gICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7 CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsKICAgICBBU1NFUlQoIW1fZGF0YWJh c2UuaXNPcGVuKCkpOwogCiAgICAgU3RyaW5nIGRhdGFiYXNlRmlsZW5hbWUgPSBtX3N5bmNNYW5h Z2VyLT5mdWxsRGF0YWJhc2VGaWxlbmFtZShtX3N0b3JhZ2VBcmVhLT5zZWN1cml0eU9yaWdpbigp KTsKQEAgLTIwNCw3ICsyMDAsNyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9y dCgpCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBNdXRleExvY2tlciBsb2NrZXIobV9p bXBvcnRMb2NrKTsKKyAgICBJbXBvcnRNdXRleExvY2tlciBsb2NrZXIodGhpcyk7CiAgICAgCiAg ICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz46Oml0ZXJhdG9yIGl0ID0gaXRlbU1hcC5iZWdpbigp OwogICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+OjppdGVyYXRvciBlbmQgPSBpdGVtTWFwLmVu ZCgpOwpAQCAtMjE0LDQ2ICsyMTAsMjIgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1J bXBvcnQoKQogICAgIAogICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KICAgICBt X3N0b3JhZ2VBcmVhID0gMDsKLSAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1ZTsKLSAgICBtX2lt cG9ydENvbmRpdGlvbi5zaWduYWwoKTsKKyAgICBvbkltcG9ydGVkKCk7CiB9CiAKIHZvaWQgU3Rv cmFnZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWQoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFk KCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAKLSAgICBNdXRleExvY2tl ciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKKyAgICBJbXBvcnRNdXRleExvY2tlciBsb2NrZXIodGhp cyk7CiAgICAgLy8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xlLgogICAgIG1fc3RvcmFnZUFy ZWEgPSAwOwotICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOwotICAgIG1faW1wb3J0Q29uZGl0 aW9uLnNpZ25hbCgpOwotfQotCi0vLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFs bG93IHVzZSBvZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0 byBkbyBzbykuCi0vLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29t cGxldGUgaXMgYnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQK LS8vIHRoZXJlIGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xl bmd0aCB3aWxsIG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgotLy8gb3B0aW1p emF0aW9uIChzaW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMg YXJlIGJlaW5nIGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55Ci0vLyBpdGVtIGN1cnJlbnRseSBp biB0aGUgbWFwLiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhl IG1hcCwgYnV0IHdlJ2xsIG5lZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3Vs ZCBub3Qgb3ZlcndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBr aWxsIHRoZSBpbXBvcnQKLS8vIGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9j a1VudGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQo KSk7Ci0KLSAgICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KLSAgICBpZiAobV9pbXBv cnRDb21wbGV0ZSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1f aW1wb3J0TG9jayk7Ci0gICAgd2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQotICAgICAgICBtX2lt cG9ydENvbmRpdGlvbi53YWl0KG1faW1wb3J0TG9jayk7Ci0gICAgQVNTRVJUKG1faW1wb3J0Q29t cGxldGUpOwotICAgIEFTU0VSVCghbV9zdG9yYWdlQXJlYSk7CisgICAgb25JbXBvcnRlZCgpOwog fQogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhh c2hNYXA8U3RyaW5nLCBTdHJpbmc+JiBpdGVtcykKIHsKLSAgICBBU1NFUlQoIWlzTWFpblRocmVh ZCgpKTsKKyAgICBBU1NFUlQoaXNCYWNrZ3JvdW5kVGhyZWFkKCkpOwogCiAgICAgaWYgKCFtX2Rh dGFiYXNlLmlzT3BlbigpKQogICAgICAgICByZXR1cm47CkBAIC0zMDksMTIgKzI4MSwxMiBAQCB2 b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hNYXA8 U3RyaW5nLCBTdHJpbmc+JiBpdGVtcwogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybVN5 bmMoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tn cm91bmRUaHJlYWQoKSk7CiAKICAgICBib29sIGNsZWFySXRlbXM7CiAgICAgSGFzaE1hcDxTdHJp bmcsIFN0cmluZz4gaXRlbXM7CiAgICAgewotICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9z eW5jTG9jayk7CisgICAgICAgIFN5bmNNdXRleExvY2tlciBsb2NrZXIodGhpcyk7CiAKICAgICAg ICAgQVNTRVJUKG1fc3luY1NjaGVkdWxlZCk7CiAKQEAgLTMzMiw2ICszMDQsNDcgQEAgdm9pZCBT dG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1TeW5jKCkKICAgICBlbmFibGVTdWRkZW5UZXJtaW5hdGlv bigpOwogfQogCisjaWYgIUVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKy8vIEZJWE1FOiBJbiB0 aGUgZnV0dXJlLCB3ZSBzaG91bGQgYWxsb3cgdXNlIG9mIFN0b3JhZ2VBcmVhcyB3aGlsZSBpdCdz IGltcG9ydGluZyAod2hlbiBzYWZlIHRvIGRvIHNvKS4KKy8vIEJsb2NraW5nIGV2ZXJ5dGhpbmcg dW50aWwgdGhlIGltcG9ydCBpcyBjb21wbGV0ZSBpcyBieSBmYXIgdGhlIHNpbXBsZXN0IGFuZCBz YWZlc3QgdGhpbmcgdG8gZG8sIGJ1dAorLy8gdGhlcmUgaXMgY2VydGFpbmx5IHJvb20gZm9yIHNh ZmUgb3B0aW1pemF0aW9uOiBLZXkvbGVuZ3RoIHdpbGwgbmV2ZXIgYmUgYWJsZSB0byBtYWtlIHVz ZSBvZiBzdWNoIGFuCisvLyBvcHRpbWl6YXRpb24gKHNpbmNlIHRoZSBvcmRlciBvZiBpdGVyYXRp b24gY2FuIGNoYW5nZSBhcyBpdGVtcyBhcmUgYmVpbmcgYWRkZWQpLiBHZXQgY2FuIHJldHVybiBh bnkKKy8vIGl0ZW0gY3VycmVudGx5IGluIHRoZSBtYXAuIEdldC9yZW1vdmUgY2FuIHdvcmsgd2hl dGhlciBvciBub3QgaXQncyBpbiB0aGUgbWFwLCBidXQgd2UnbGwgbmVlZCBhIGxpc3QKKy8vIG9m IGl0ZW1zIHRoZSBpbXBvcnQgc2hvdWxkIG5vdCBvdmVyd3JpdGUuIENsZWFyIGNhbiBhbHNvIHdv cmssIGJ1dCBpdCdsbCBuZWVkIHRvIGtpbGwgdGhlIGltcG9ydAorLy8gam9iIGZpcnN0Lgordm9p ZCBTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50aWxJbXBvcnRDb21wbGV0ZSgpIGNvbnN0Cit7Cisg ICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKworICAgIC8vIEZhc3QgcGF0aCB0byBhdm9pZCBs b2NraW5nLgorICAgIGlmIChtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICByZXR1cm47CisKKyAg ICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKKyAgICB3aGlsZSAoIW1faW1wb3J0 Q29tcGxldGUpCisgICAgICAgIG1faW1wb3J0Q29uZGl0aW9uLndhaXQobV9pbXBvcnRMb2NrKTsK KyAgICBBU1NFUlQobV9pbXBvcnRDb21wbGV0ZSk7CisgICAgQVNTRVJUKCFtX3N0b3JhZ2VBcmVh KTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OnNjaGVkdWxlSW1wb3J0KCkKK3sKKyAgICBt X2ltcG9ydENvbXBsZXRlID0gZmFsc2U7CisgICAgLy8gRklYTUU6IElmIGl0IGNhbid0IGltcG9y dCwgdGhlbiB0aGUgZGVmYXVsdCBXZWJLaXQgYmVoYXZpb3Igc2hvdWxkIGJlIHRoYXQgb2YgcHJp dmF0ZSBicm93c2luZywKKyAgICAvLyBub3Qgc2lsZW50bHkgaWdub3JpbmcgaXQuICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTQKKyAgICBpZiAoIW1fc3luY01h bmFnZXItPnNjaGVkdWxlSW1wb3J0KHRoaXMpKQorICAgICAgICBtX2ltcG9ydENvbXBsZXRlID0g dHJ1ZTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6Om9uSW1wb3J0ZWQoKQoreworICAgIG1f aW1wb3J0Q29tcGxldGUgPSB0cnVlOworICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25hbCgpOwor fQorCisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxF KERPTV9TVE9SQUdFKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3lu Yy5oIGIvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCmluZGV4IGU0MzZiZWYuLmRl NDg4OWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKQEAgLTc4LDE1ICs3OCw0MSBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc3luY1RpbWVyRmlyZWQoVGltZXI8U3Rv cmFnZUFyZWFTeW5jPiopOwogICAgICAgICB2b2lkIHN5bmMoYm9vbCBjbGVhckl0ZW1zLCBjb25z dCBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiYgaXRlbXMpOwogCi0gICAgICAgIE11dGV4IG1fc3lu Y0xvY2s7CiAgICAgICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+IG1faXRlbXNQZW5kaW5nU3lu YzsKICAgICAgICAgYm9vbCBtX2NsZWFySXRlbXNXaGlsZVN5bmNpbmc7CiAgICAgICAgIGJvb2wg bV9zeW5jU2NoZWR1bGVkOwogCisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAg IHZvaWQgc2NoZWR1bGVJbXBvcnQoKTsKKyAgICAgICAgdm9pZCBvbkltcG9ydGVkKCk7CisKKyNp ZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICBib29sIGlzQmFja2dyb3VuZFRocmVh ZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyAgICAgICAgc3RydWN0IFN5bmNNdXRleExvY2tl cgorICAgICAgICB7CisgICAgICAgICAgICBTeW5jTXV0ZXhMb2NrZXIodm9pZCopIHt9CisgICAg ICAgIH07CisgICAgICAgIHN0cnVjdCBJbXBvcnRNdXRleExvY2tlcgorICAgICAgICB7CisgICAg ICAgICAgICBJbXBvcnRNdXRleExvY2tlcihjb25zdCB2b2lkKikge30KKyAgICAgICAgfTsKKyNl bHNlCisgICAgICAgIE11dGV4IG1fc3luY0xvY2s7CisgICAgICAgIG11dGFibGUgYm9vbCBtX2lt cG9ydENvbXBsZXRlOwogICAgICAgICBtdXRhYmxlIE11dGV4IG1faW1wb3J0TG9jazsKICAgICAg ICAgbXV0YWJsZSBUaHJlYWRDb25kaXRpb24gbV9pbXBvcnRDb25kaXRpb247Ci0gICAgICAgIG11 dGFibGUgYm9vbCBtX2ltcG9ydENvbXBsZXRlOwotICAgICAgICB2b2lkIG1hcmtJbXBvcnRlZCgp OworICAgICAgICBib29sIGlzQmFja2dyb3VuZFRocmVhZCgpIGNvbnN0IHsgcmV0dXJuICFpc01h aW5UaHJlYWQoKTsgfQorICAgICAgICBmcmllbmQgY2xhc3MgU3luY011dGV4TG9ja2VyOworICAg ICAgICBmcmllbmQgY2xhc3MgSW1wb3J0TXV0ZXhMb2NrZXI7CisgICAgICAgIHN0cnVjdCBTeW5j TXV0ZXhMb2NrZXI6IHByaXZhdGUgTXV0ZXh0TG9ja2VyCisgICAgICAgIHsKKyAgICAgICAgICAg IFN5bmNNdXRleExvY2tlcihTdG9yYWdlQXJlYVN5bmMqIHN0b3JhZ2VBcmVhU3luYykgOiBNdXRl eHRMb2NrZXIoc3RvcmFnZUFyZWFTeW5jLT5tX3N5bmNMb2NrKSB7fQorICAgICAgICB9OworICAg ICAgICBzdHJ1Y3QgSW1wb3J0TXV0ZXhMb2NrZXI6IHByaXZhdGUgTXV0ZXh0TG9ja2VyCisgICAg ICAgIHsKKyAgICAgICAgICAgIEltcG9ydE11dGV4TG9ja2VyKGNvbnN0IFN0b3JhZ2VBcmVhU3lu Yyogc3RvcmFnZUFyZWFTeW5jKSA6IE11dGV4dExvY2tlcihzdG9yYWdlQXJlYVN5bmMtPm1faW1w b3J0TG9jaykge30KKyAgICAgICAgfTsKKyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0 YWJhc2VUaHJlYWQuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFz ZVRocmVhZC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGNjYTdmOAot LS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJh c2VUaHJlYWQuY3BwCkBAIC0wLDAgKzEsMTEwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5 IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq ICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUg dXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQor ICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJ ZiBub3QsIHdyaXRlIHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwg NTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEz MDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VU aHJlYWQuaCIKKworI2lmIEVOQUJMRShET01fU1RPUkFHRSkKKyNpZiBFTkFCTEUoU0lOR0xFX1RI UkVBREVEKQorCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2su aCIKKyNpbmNsdWRlICJTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKKyAgICA6IG1fdGlt ZXIodGhpcywgJkRhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKQorICAgICwgbV90cmFuc2FjdGlv bkNvb3JkaW5hdG9yKG5ldyBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkpCit7Cit9CisKK0Rh dGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQoKQoreworfQorCitib29sIERhdGFiYXNlVGhy ZWFkOjpzdGFydCgpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJl YWQ6OnJlcXVlc3RUZXJtaW5hdGlvbigpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1f dHJhbnNhY3Rpb25Db29yZGluYXRvci0+c2h1dGRvd24oKTsKK30KKworYm9vbCBEYXRhYmFzZVRo cmVhZDo6dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdAoreworICAgIHJldHVybiBtX3F1ZXVl LmlzRW1wdHkoKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxE YXRhYmFzZVRocmVhZD4qKQoreworICAgIGlmIChtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3Qo KTsKKyAgICB0YXNrLT5wZXJmb3JtVGFzaygpOworICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsK KyAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hv dCgwKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2VUYXNrPiB0YXNrKQoreworICAgIG1fcXVldWUuYXBwZW5kKHRhc2spOworICAgIGlm ICghbV90aW1lci5pc0FjdGl2ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsK K30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQ dHI8RGF0YWJhc2VUYXNrPiB0YXNrKQoreworICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Cit9CisK K3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNlKiBk YXRhYmFzZSkKK3sKKyAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IHJlc2VydmVkVGFz a3M7CisgICAgZm9yIChEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+Ojpjb25zdF9pdGVyYXRv ciBpID0gbV9xdWV1ZS5iZWdpbigpOyBpICE9IG1fcXVldWUuZW5kKCk7ICsraSkgeworICAgICAg ICBpZiAoKCppKS0+ZGF0YWJhc2UoKSAhPSBkYXRhYmFzZSkKKyAgICAgICAgICAgIHJlc2VydmVk VGFza3MuYXBwZW5kKCppKTsKKyAgICB9CisKKyAgICBtX3F1ZXVlLnN3YXAocmVzZXJ2ZWRUYXNr cyk7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFz ZSogZGF0YWJhc2UpCit7CisgICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBEYXRhYmFz ZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAg IG5vdEltcGxlbWVudGVkKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlm IC8vIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9SQUdF KQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3Jh Z2VUaHJlYWQuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3Jh Z2VUaHJlYWQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJjNmYyYWIK LS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2Fs U3RvcmFnZVRocmVhZC5jcHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAq CisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxs IGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2 ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UKKyAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElC LiAgSWYgbm90LCB3cml0ZSB0bworICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjEx MC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkxvY2Fs U3RvcmFnZVRocmVhZC5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShT SU5HTEVfVEhSRUFERUQpCisKKyNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCisjaW5jbHVk ZSAiU3RvcmFnZUFyZWFTeW5jLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUGFzc1JlZlB0 cjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IExvY2FsU3RvcmFnZVRocmVhZDo6Y3JlYXRlKCkKK3sKKyAg ICByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsU3RvcmFnZVRocmVhZCk7Cit9CisKK0xvY2FsU3Rv cmFnZVRocmVhZDo6TG9jYWxTdG9yYWdlVGhyZWFkKCkKKzogbV90aW1lcih0aGlzLCAmTG9jYWxT dG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKQoreworfQorCitib29sIExvY2FsU3RvcmFnZVRocmVh ZDo6c3RhcnQoKQoreworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRo cmVhZDo6dGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+KikKK3sKKyAgICBpZiAo bV9xdWV1ZS5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxMb2NhbFN0 b3JhZ2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOworICAgIG1fcXVldWUucmVtb3ZlRmly c3QoKTsKKyAgICB0YXNrLT5wZXJmb3JtVGFzaygpOworICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5 KCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3Rv cmFnZVRocmVhZDo6c2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFy ZWEpCit7CisgICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlSW1wb3J0 KGFyZWEpKTsKKyAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKKyAgICAgICAgbV90aW1lci5z dGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZVN5 bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCit7CisgICAgbV9xdWV1ZS5hcHBl bmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlU3luYyhhcmVhKSk7CisgICAgaWYgKCFtX3RpbWVy LmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lk IExvY2FsU3RvcmFnZVRocmVhZDo6dGVybWluYXRlKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7 CisgICAgbV90aW1lci5zdG9wKCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpwZXJm b3JtVGVybWluYXRlKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7CisgICAgbV90aW1lci5zdG9w KCk7Cit9CisKK30KKyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorI2VuZGlmIC8v IEVOQUJMRShET01fU1RPUkFHRSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUt dGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhy ZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi4yNzYyMTJiCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10 aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMuY3BwCkBAIC0wLDAgKzEsNTMgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLiAKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiU3Rv cmFnZUFyZWFTeW5jLmgiCisKKyNpZiBFTkFCTEUoRE9NX1NUT1JBR0UpCisjaWYgRU5BQkxFKFNJ TkdMRV9USFJFQURFRCkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIFN0b3JhZ2VBcmVh U3luYzo6c2NoZWR1bGVJbXBvcnQoKQoreworICAgIC8vIERvIGEgYmxvY2tpbmcgaW1wb3J0IGJl Y2F1c2Ugd2UgY2Fubm90ICJibG9ja1VudGlsSW1wb3J0Q29tcGxldGUiIHdpdGggb25lIHRocmVh ZAorICAgIHBlcmZvcm1JbXBvcnQoKTsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6Om9uSW1w b3J0ZWQoKQoreworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6YmxvY2tVbnRpbEltcG9ydENv bXBsZXRlKCkgY29uc3QKK3sKKyAgICAvLyBXZSBoYXZlIGFscmVhZHkgaW1wb3J0ZWQgaW4gc2No ZWR1bGVJbXBvcnQoKQorfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBF TkFCTEUoU0lOR0xFX1RIUkVBREVEKQorI2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKKwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3Bw IGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkODExNDVkLi4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3Rv cmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNlLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDk1 ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFy ZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAq ICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBT ZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBH TlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0aCB0aGlzIGxp YnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KLSAqICB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgotICovCi0KLSNpbmNs dWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgotCi0jaW5jbHVkZSAi RGF0YWJhc2UuaCIKLSNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKLQotbmFtZXNwYWNlIFdlYkNv cmUgewotCi1EYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQotOiBtX3RpbWVyKHRoaXMs ICZEYXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZCkKLXsKLX0KLQotRGF0YWJhc2VUaHJlYWQ6On5E YXRhYmFzZVRocmVhZCgpCi17Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJt aW5hdGlvbigpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotfQotCi1ib29sIERhdGFiYXNlVGhy ZWFkOjp0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fcXVldWUu aXNFbXB0eSgpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPERh dGFiYXNlVGhyZWFkPiopCi17Ci0gICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkgewotICAgICAg ICBSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOwotICAgICAgICB0 YXNrLT5wZXJmb3JtVGFzaygpOwotICAgICAgICBtX3F1ZXVlLnJlbW92ZUZpcnN0KCk7Ci0gICAg ICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpCi0gICAgICAgICAgICBtX3RpbWVyLnN0YXJ0T25l U2hvdCgwKTsKLSAgICB9Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlVGFzayhQ YXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKLXsKLSAgICBtX3F1ZXVlLmFwcGVuZCh0YXNr KTsKLSAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAgICAgICAgbV90aW1lci5zdGFydE9u ZVNob3QoMCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlSW1tZWRpYXRlVGFz ayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKLXsKLSAgICB0YXNrLT5wZXJmb3JtVGFz aygpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhE YXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBy ZXNlcnZlZFRhc2tzOwotICAgIGZvciAoRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPjo6Y29u c3RfaXRlcmF0b3IgaSA9IG1fcXVldWUuYmVnaW4oKTsgaSAhPSBtX3F1ZXVlLmVuZCgpOyArK2kp IHsKLSAgICAgICAgaWYgKCgqaSktPmRhdGFiYXNlKCkgIT0gZGF0YWJhc2UpCi0gICAgICAgICAg ICByZXNlcnZlZFRhc2tzLmFwcGVuZCgqaSk7Ci0gICAgfQotCi0gICAgbV9xdWV1ZS5zd2FwKHJl c2VydmVkVGFza3MpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZU9w ZW4oRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci19Ci0KLXZv aWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKiBkYXRhYmFz ZSkKLXsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5o IGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaApkZWxldGVkIGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggZmFmYzc5MS4uMDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3Jh Z2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5oCisrKyAvZGV2L251bGwKQEAgLTEsNjUgKzAs MCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1l dDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFy eTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwotICogIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGgg Rmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0gKi8KLQotI2lmbmRlZiBE YXRhYmFzZVRocmVhZFdpbmNlX2gKLSNkZWZpbmUgRGF0YWJhc2VUaHJlYWRXaW5jZV9oCi0KLSNp bmNsdWRlIDx3dGYvRGVxdWUuaD4KLSNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgotCi1uYW1l c3BhY2UgV2ViQ29yZSB7Ci0KLSAgICBjbGFzcyBEYXRhYmFzZTsKLSAgICBjbGFzcyBEYXRhYmFz ZVRhc2s7Ci0KLSAgICBjbGFzcyBEYXRhYmFzZVRocmVhZDogcHVibGljIFdURjo6UmVmQ291bnRl ZDxEYXRhYmFzZVRocmVhZD4gewotCi0gICAgcHVibGljOgotICAgICAgICBzdGF0aWMgUGFzc1Jl ZlB0cjxEYXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFi YXNlVGhyZWFkKTsgfQotICAgICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgICAgICBib29s IHN0YXJ0KCkgeyByZXR1cm4gdHJ1ZTsgfQotICAgICAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlv bigpOwotICAgICAgICBib29sIHRlcm1pbmF0aW9uUmVxdWVzdGVkKCkgY29uc3Q7Ci0KLSAgICAg ICAgdm9pZCBzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsKLSAgICAgICAg dm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsKLSAg ICAgICAgdm9pZCB1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRhYmFzZSopOwotICAgICAgICB2 b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOwotICAgICAgICB2b2lkIHJlY29yZERh dGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7Ci0jaWZuZGVmIE5ERUJVRwotICAgICAgICBUaHJlYWRJ ZGVudGlmaWVyIGdldFRocmVhZElEKCkgY29uc3QgeyByZXR1cm4gY3VycmVudFRocmVhZCgpOyB9 Ci0jZW5kaWYKLQotICAgIHByaXZhdGU6Ci0gICAgICAgIERhdGFiYXNlVGhyZWFkKCk7Ci0KLSAg ICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNlVGhyZWFkPiopOwotCi0gICAgICAg IERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9xdWV1ZTsKLSAgICAgICAgVGltZXI8RGF0 YWJhc2VUaHJlYWQ+IG1fdGltZXI7Ci0gICAgfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQot Ci0jZW5kaWYgLy8gRGF0YWJhc2VUaHJlYWRXaW5jZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9y YWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS93 aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDhkY2I5MDIuLjAwMDAwMDAKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2Fs U3RvcmFnZVRocmVhZFdpbmNlLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDgzICswLDAgQEAKLS8q Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0 aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQot ICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoK LSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0 aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAot ICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgotICovCi0KLSNpbmNsdWRlICJjb25maWcu aCIKLSNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUaHJlYWQuaCIKLQotI2luY2x1ZGUgIkxvY2FsU3Rv cmFnZVRhc2suaCIKLSNpbmNsdWRlICJTdG9yYWdlQXJlYVN5bmMuaCIKLQotbmFtZXNwYWNlIFdl YkNvcmUgewotCi1Mb2NhbFN0b3JhZ2VUaHJlYWQ6OkxvY2FsU3RvcmFnZVRocmVhZCgpCi06IG1f dGltZXIodGhpcywgJkxvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJGaXJlZCkKLXsKLX0KLQotTG9j YWxTdG9yYWdlVGhyZWFkOjp+TG9jYWxTdG9yYWdlVGhyZWFkKCkKLXsKLX0KLQotYm9vbCBMb2Nh bFN0b3JhZ2VUaHJlYWQ6OnN0YXJ0KCkKLXsKLSAgICByZXR1cm4gdHJ1ZTsKLX0KLQotdm9pZCBM b2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiop Ci17Ci0gICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkgewotICAgICAgICBSZWZQdHI8TG9jYWxT dG9yYWdlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3QoKTsKLSAgICAgICAgdGFzay0+cGVyZm9y bVRhc2soKTsKLSAgICAgICAgbV9xdWV1ZS5yZW1vdmVGaXJzdCgpOwotICAgICAgICBpZiAoIW1f cXVldWUuaXNFbXB0eSgpKQotICAgICAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci0g ICAgfQotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1bGVJbXBvcnQoUGFzc1Jl ZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCi17Ci0gICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxT dG9yYWdlVGFzazo6Y3JlYXRlSW1wb3J0KGFyZWEpKTsKLSAgICBpZiAoIW1fdGltZXIuaXNBY3Rp dmUoKSkKLSAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci19Ci0KLXZvaWQgTG9jYWxT dG9yYWdlVGhyZWFkOjpzY2hlZHVsZVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFy ZWEpCi17Ci0gICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlU3luYyhh cmVhKSk7Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAgIG1fdGltZXIuc3Rh cnRPbmVTaG90KDApOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6dGVybWluYXRlKCkK LXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7Ci0gICAgbV90aW1lci5zdG9wKCk7Ci19Ci0KLXZvaWQg TG9jYWxTdG9yYWdlVGhyZWFkOjpwZXJmb3JtVGVybWluYXRlKCkKLXsKLSAgICBtX3F1ZXVlLmNs ZWFyKCk7Ci0gICAgbV90aW1lci5zdG9wKCk7Ci19Ci0KLX0KZGlmZiAtLWdpdCBhL1dlYkNvcmUv c3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oIGIvV2ViQ29yZS9zdG9yYWdl L3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDMwMGFiYjUuLjAwMDAwMDAKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2Fs U3RvcmFnZVRocmVhZFdpbmNlLmgKKysrIC9kZXYvbnVsbApAQCAtMSw1OCArMCwwIEBACi0vKgot ICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4g UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAg ICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUg ZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhl IGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5U WTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAq ICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0g KiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhl IGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAq ICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KLSAqLwotCi0KLSNpZm5kZWYgTG9jYWxTdG9y YWdlVGhyZWFkV2luY2VfaAotI2RlZmluZSBMb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZV9oCi0KLSNp bmNsdWRlIDx3dGYvRGVxdWUuaD4KLSNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgotCi1uYW1l c3BhY2UgV2ViQ29yZSB7Ci0KLSAgICBjbGFzcyBTdG9yYWdlQXJlYVN5bmM7Ci0gICAgY2xhc3Mg TG9jYWxTdG9yYWdlVGFzazsKLQotICAgIGNsYXNzIExvY2FsU3RvcmFnZVRocmVhZCA6IHB1Ymxp YyBSZWZDb3VudGVkPExvY2FsU3RvcmFnZVRocmVhZD4gewotICAgIHB1YmxpYzoKLSAgICAgICAg c3RhdGljIFBhc3NSZWZQdHI8TG9jYWxTdG9yYWdlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBh ZG9wdFJlZihuZXcgTG9jYWxTdG9yYWdlVGhyZWFkKTsgfQotCi0gICAgICAgIH5Mb2NhbFN0b3Jh Z2VUaHJlYWQoKTsKLSAgICAgICAgYm9vbCBzdGFydCgpOwotICAgICAgICB2b2lkIHNjaGVkdWxl SW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPik7Ci0gICAgICAgIHZvaWQgc2NoZWR1 bGVTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPik7Ci0gICAgICAgIHZvaWQgdGVybWlu YXRlKCk7Ci0gICAgICAgIHZvaWQgcGVyZm9ybVRlcm1pbmF0ZSgpOwotCi0gICAgcHJpdmF0ZToK LSAgICAgICAgTG9jYWxTdG9yYWdlVGhyZWFkKCk7Ci0KLSAgICAgICAgdm9pZCB0aW1lckZpcmVk KFRpbWVyPExvY2FsU3RvcmFnZVRocmVhZD4qKTsKLQotICAgICAgICBEZXF1ZTxSZWZQdHI8TG9j YWxTdG9yYWdlVGFzaz4gPiBtX3F1ZXVlOwotICAgICAgICBUaW1lcjxMb2NhbFN0b3JhZ2VUaHJl YWQ+IG1fdGltZXI7Ci0gICAgfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYg Ly8gTG9jYWxTdG9yYWdlVGhyZWFkV2luY2VfaAo= 38372 2009-08-21 08:16:09 -0700 2009-08-21 14:08:20 -0700 onImported => didImport 28019.patch text/plain 33080 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTJhNWRlYy4uMjExZjkyYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAwOS0wOC0yMSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u CisgICAgICAgIFRoaXMgcGF0Y2ggYWxzbyByZXBsYWNlcyBzdG9yYWdlL3dpbmNlCisgICAgICAg IHdpdGggc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI4MDE5CisKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmg6IG1vZGlmaWVkCisgICAgICAgICogc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQu aDogbW9kaWZpZWQKKyAgICAgICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VBcmVhU3luYyk6CisgICAgICAg IChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKToKKyAgICAgICAgKFdl YkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9ydCk6CisgICAgICAgIChXZWJDb3Jl OjpTdG9yYWdlQXJlYVN5bmM6Om1hcmtJbXBvcnRlZCk6CisgICAgICAgIChXZWJDb3JlOjpTdG9y YWdlQXJlYVN5bmM6OnN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpw ZXJmb3JtU3luYyk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50 aWxJbXBvcnRDb21wbGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OnNj aGVkdWxlSW1wb3J0KTogQWRkZWQKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6 ZGlkSW1wb3J0KTogQWRkZWQKKyAgICAgICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oOgor ICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjppc0JhY2tncm91bmRUaHJlYWQpOiBB ZGRlZAorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpTeW5jTXV0ZXhMb2NrZXI6 OlN5bmNNdXRleExvY2tlcik6IEFkZGVkCisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5 bmM6OkltcG9ydE11dGV4TG9ja2VyOjpJbXBvcnRNdXRleExvY2tlcik6IEFkZGVkCisgICAgICAg ICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3BwOiBBZGRlZC4KKyAg ICAgICAgKiBzdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3BwOiBB ZGRlZC4KKyAgICAgICAgKiBzdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMu Y3BwOiBBZGRlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2Uu Y3BwOiBSZW1vdmVkLgorICAgICAgICAqIHN0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5j ZS5oOiBSZW1vdmVkLgorICAgICAgICAqIHN0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFk V2luY2UuY3BwOiBSZW1vdmVkLgorICAgICAgICAqIHN0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdl VGhyZWFkV2luY2UuaDogUmVtb3ZlZC4KKwogMjAwOS0wOC0xOSAgSmFuIE1pY2hhZWwgQWxvbnpv ICA8am1hbG9uem9Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBYYW4gTG9wZXou CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaCBiL1dlYkNvcmUv c3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCmluZGV4IDU5ZDdhNWQuLmU2M2E3MTkgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCisrKyBiL1dlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRocmVhZC5oCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykg MjAwNywgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQg KEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI5LDYgKzMwLDcgQEAKICNkZWZpbmUgRGF0YWJh c2VUaHJlYWRfaAogCiAjaWYgRU5BQkxFKERBVEFCQVNFKQorCiAjaW5jbHVkZSA8d3RmL0RlcXVl Lmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgpA QCAtNDAsNDggKzQyLDU4IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotY2xhc3MgRGF0YWJh c2U7Ci1jbGFzcyBEYXRhYmFzZVRhc2s7Ci1jbGFzcyBEb2N1bWVudDsKLWNsYXNzIFNRTFRyYW5z YWN0aW9uQ29vcmRpbmF0b3I7Ci0KLWNsYXNzIERhdGFiYXNlVGhyZWFkIDogcHVibGljIFRocmVh ZFNhZmVTaGFyZWQ8RGF0YWJhc2VUaHJlYWQ+IHsKLXB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1Jl ZlB0cjxEYXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFi YXNlVGhyZWFkKTsgfQotICAgIH5EYXRhYmFzZVRocmVhZCgpOwotCi0gICAgYm9vbCBzdGFydCgp OwotICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7Ci0gICAgYm9vbCB0ZXJtaW5hdGlvblJl cXVlc3RlZCgpIGNvbnN0OwotCi0gICAgdm9pZCBzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRh YmFzZVRhc2s+KTsKLSAgICB2b2lkIHNjaGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVmUHRyPERh dGFiYXNlVGFzaz4pOyAvLyBUaGlzIGp1c3QgYWRkcyB0aGUgdGFzayB0byB0aGUgZnJvbnQgb2Yg dGhlIHF1ZXVlIC0gdGhlIGNhbGxlciBuZWVkcyB0byBiZSBleHRyZW1lbHkgY2FyZWZ1bCBub3Qg dG8gY3JlYXRlIGRlYWRsb2NrcyB3aGVuIHdhaXRpbmcgZm9yIGNvbXBsZXRpb24uCi0gICAgdm9p ZCB1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRhYmFzZSopOwotCi0gICAgdm9pZCByZWNvcmRE YXRhYmFzZU9wZW4oRGF0YWJhc2UqKTsKLSAgICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERh dGFiYXNlKik7Ci0gICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsgcmV0dXJuIG1f dGhyZWFkSUQ7IH0KLQotICAgIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9u Q29vcmRpbmF0b3IoKSB7IHJldHVybiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0K LQotcHJpdmF0ZToKLSAgICBEYXRhYmFzZVRocmVhZCgpOwotCi0gICAgc3RhdGljIHZvaWQqIGRh dGFiYXNlVGhyZWFkU3RhcnQodm9pZCopOwotICAgIHZvaWQqIGRhdGFiYXNlVGhyZWFkKCk7Ci0K LSAgICBNdXRleCBtX3RocmVhZENyZWF0aW9uTXV0ZXg7Ci0gICAgVGhyZWFkSWRlbnRpZmllciBt X3RocmVhZElEOwotICAgIFJlZlB0cjxEYXRhYmFzZVRocmVhZD4gbV9zZWxmUmVmOwotCi0gICAg TWVzc2FnZVF1ZXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9xdWV1ZTsKLQotICAgIC8vIFRo aXMgc2V0IGtlZXBzIHRyYWNrIG9mIHRoZSBvcGVuIGRhdGFiYXNlcyB0aGF0IGhhdmUgYmVlbiB1 c2VkIG9uIHRoaXMgdGhyZWFkLgotICAgIHR5cGVkZWYgSGFzaFNldDxSZWZQdHI8RGF0YWJhc2U+ ID4gRGF0YWJhc2VTZXQ7Ci0gICAgRGF0YWJhc2VTZXQgbV9vcGVuRGF0YWJhc2VTZXQ7Ci0KLSAg ICBPd25QdHI8U1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcj4gbV90cmFuc2FjdGlvbkNvb3JkaW5h dG9yOwotfTsKKyAgICBjbGFzcyBEYXRhYmFzZTsKKyAgICBjbGFzcyBEYXRhYmFzZVRhc2s7Cisg ICAgY2xhc3MgRG9jdW1lbnQ7CisgICAgY2xhc3MgU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcjsK KworICAgIGNsYXNzIERhdGFiYXNlVGhyZWFkIDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8RGF0 YWJhc2VUaHJlYWQ+IHsKKyAgICBwdWJsaWM6CisgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPERh dGFiYXNlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBhZG9wdFJlZihuZXcgRGF0YWJhc2VUaHJl YWQpOyB9CisgICAgICAgIH5EYXRhYmFzZVRocmVhZCgpOworCisgICAgICAgIGJvb2wgc3RhcnQo KTsKKyAgICAgICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oKTsKKyAgICAgICAgYm9vbCB0ZXJt aW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0OworCisgICAgICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBh c3NSZWZQdHI8RGF0YWJhc2VUYXNrPik7CisgICAgICAgIHZvaWQgc2NoZWR1bGVJbW1lZGlhdGVU YXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPik7IC8vIFRoaXMganVzdCBhZGRzIHRoZSB0YXNr IHRvIHRoZSBmcm9udCBvZiB0aGUgcXVldWUgLSB0aGUgY2FsbGVyIG5lZWRzIHRvIGJlIGV4dHJl bWVseSBjYXJlZnVsIG5vdCB0byBjcmVhdGUgZGVhZGxvY2tzIHdoZW4gd2FpdGluZyBmb3IgY29t cGxldGlvbi4KKyAgICAgICAgdm9pZCB1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRhYmFzZSop OworCisgICAgICAgIHZvaWQgcmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7CisgICAgICAg IHZvaWQgcmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqKTsKKyNpZiBFTkFCTEUoU0lOR0xF X1RIUkVBREVEKQorICAgICAgICBUaHJlYWRJZGVudGlmaWVyIGdldFRocmVhZElEKCkgeyByZXR1 cm4gY3VycmVudFRocmVhZCgpOyB9CisjZWxzZQorICAgICAgICBUaHJlYWRJZGVudGlmaWVyIGdl dFRocmVhZElEKCkgeyByZXR1cm4gbV90aHJlYWRJRDsgfQorI2VuZGlmCisKKyAgICAgICAgU1FM VHJhbnNhY3Rpb25Db29yZGluYXRvciogdHJhbnNhY3Rpb25Db29yZGluYXRvcigpIHsgcmV0dXJu IG1fdHJhbnNhY3Rpb25Db29yZGluYXRvci5nZXQoKTsgfQorCisgICAgcHJpdmF0ZToKKyAgICAg ICAgRGF0YWJhc2VUaHJlYWQoKTsKKworI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisgICAg ICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKTsKKworICAgICAgICBE ZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7CisgICAgICAgIFRpbWVyPERhdGFi YXNlVGhyZWFkPiBtX3RpbWVyOworI2Vsc2UKKyAgICAgICAgc3RhdGljIHZvaWQqIGRhdGFiYXNl VGhyZWFkU3RhcnQodm9pZCopOworICAgICAgICB2b2lkKiBkYXRhYmFzZVRocmVhZCgpOworCisg ICAgICAgIE11dGV4IG1fdGhyZWFkQ3JlYXRpb25NdXRleDsKKyAgICAgICAgVGhyZWFkSWRlbnRp ZmllciBtX3RocmVhZElEOworICAgICAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fc2VsZlJl ZjsKKworICAgICAgICBNZXNzYWdlUXVldWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVl OworCisgICAgICAgIC8vIFRoaXMgc2V0IGtlZXBzIHRyYWNrIG9mIHRoZSBvcGVuIGRhdGFiYXNl cyB0aGF0IGhhdmUgYmVlbiB1c2VkIG9uIHRoaXMgdGhyZWFkLgorICAgICAgICB0eXBlZGVmIEhh c2hTZXQ8UmVmUHRyPERhdGFiYXNlPiA+IERhdGFiYXNlU2V0OworICAgICAgICBEYXRhYmFzZVNl dCBtX29wZW5EYXRhYmFzZVNldDsKKyNlbmRpZgorICAgICAgICBPd25QdHI8U1FMVHJhbnNhY3Rp b25Db29yZGluYXRvcj4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yOworICAgIH07CiAKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3Rv cmFnZVRocmVhZC5oIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oCmluZGV4 IDNkNTg0MjcuLmIwMTlhNTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3Jh Z2VUaHJlYWQuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9yYWdlVGhyZWFkLmgKQEAg LTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA4IEFwcGxlIEluYy4gQWxsIFJp Z2h0cyBSZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4g QWxsIFJpZ2h0cyBSZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAt MjgsNiArMjksNyBAQAogCiAjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQogCisjaW5jbHVkZSA8d3Rm L0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTWVzc2Fn ZVF1ZXVlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KQEAgLTU2LDYgKzU4LDEyIEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBwcml2YXRlOgogICAgICAgICBMb2NhbFN0b3JhZ2VU aHJlYWQoKTsKIAorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisgICAgICAgIHZvaWQgdGlt ZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+Kik7CisKKyAgICAgICAgRGVxdWU8UmVm UHRyPExvY2FsU3RvcmFnZVRhc2s+ID4gbV9xdWV1ZTsKKyAgICAgICAgVGltZXI8TG9jYWxTdG9y YWdlVGhyZWFkPiBtX3RpbWVyOworI2Vsc2UKICAgICAgICAgc3RhdGljIHZvaWQqIGxvY2FsU3Rv cmFnZVRocmVhZFN0YXJ0KHZvaWQqKTsKICAgICAgICAgdm9pZCogbG9jYWxTdG9yYWdlVGhyZWFk KCk7CiAKQEAgLTY3LDYgKzc1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAKICAg ICAgICAgTXV0ZXggbV90ZXJtaW5hdGVMb2NrOwogICAgICAgICBUaHJlYWRDb25kaXRpb24gbV90 ZXJtaW5hdGVDb25kaXRpb247CisjZW5kaWYKICAgICB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcCBiL1dl YkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3BwCmluZGV4IDAxZDJhNjUuLjY4MGMxYTAg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3BwCisrKyBiL1dl YkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAq IENvcHlyaWdodCAoQykgMjAwOCwgMjAwOSBBcHBsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQu CisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuCiAgKgogICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKQEAgLTU1LDE1ICs1NiwxMSBAQCBTdG9yYWdlQXJlYVN5bmM6OlN0 b3JhZ2VBcmVhU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VTeW5jTWFuYWdlcj4gc3RvcmFnZVN5bmNN YW5hZwogICAgICwgbV9zeW5jTWFuYWdlcihzdG9yYWdlU3luY01hbmFnZXIpCiAgICAgLCBtX2Ns ZWFySXRlbXNXaGlsZVN5bmNpbmcoZmFsc2UpCiAgICAgLCBtX3N5bmNTY2hlZHVsZWQoZmFsc2Up Ci0gICAgLCBtX2ltcG9ydENvbXBsZXRlKGZhbHNlKQogewogICAgIEFTU0VSVChtX3N0b3JhZ2VB cmVhKTsKICAgICBBU1NFUlQobV9zeW5jTWFuYWdlcik7CiAKLSAgICAvLyBGSVhNRTogSWYgaXQg Y2FuJ3QgaW1wb3J0LCB0aGVuIHRoZSBkZWZhdWx0IFdlYktpdCBiZWhhdmlvciBzaG91bGQgYmUg dGhhdCBvZiBwcml2YXRlIGJyb3dzaW5nLAotICAgIC8vIG5vdCBzaWxlbnRseSBpZ25vcmluZyBp dC4gIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5NAotICAgIGlm ICghbV9zeW5jTWFuYWdlci0+c2NoZWR1bGVJbXBvcnQodGhpcykpCi0gICAgICAgIG1faW1wb3J0 Q29tcGxldGUgPSB0cnVlOworICAgIHNjaGVkdWxlSW1wb3J0KCk7CiB9CiAKIFN0b3JhZ2VBcmVh U3luYzo6flN0b3JhZ2VBcmVhU3luYygpCkBAIC0xMjksNyArMTI2LDcgQEAgdm9pZCBTdG9yYWdl QXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKFRpbWVyPFN0b3JhZ2VBcmVhU3luYz4qKQogICAgIEhh c2hNYXA8U3RyaW5nLCBTdHJpbmc+OjppdGVyYXRvciBlbmQgPSBtX2NoYW5nZWRJdGVtcy5lbmQo KTsKICAgICAKICAgICB7Ci0gICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3N5bmNMb2NrKTsK KyAgICAgICAgU3luY011dGV4TG9ja2VyIGxvY2tlcih0aGlzKTsKIAogICAgICAgICBpZiAobV9p dGVtc0NsZWFyZWQpIHsKICAgICAgICAgICAgIG1faXRlbXNQZW5kaW5nU3luYy5jbGVhcigpOwpA QCAtMTYwLDcgKzE1Nyw3IEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZChU aW1lcjxTdG9yYWdlQXJlYVN5bmM+KikKIAogdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1J bXBvcnQoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0Jh Y2tncm91bmRUaHJlYWQoKSk7CiAgICAgQVNTRVJUKCFtX2RhdGFiYXNlLmlzT3BlbigpKTsKIAog ICAgIFN0cmluZyBkYXRhYmFzZUZpbGVuYW1lID0gbV9zeW5jTWFuYWdlci0+ZnVsbERhdGFiYXNl RmlsZW5hbWUobV9zdG9yYWdlQXJlYS0+c2VjdXJpdHlPcmlnaW4oKSk7CkBAIC0yMDQsNyArMjAx LDcgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQogICAgICAgICByZXR1 cm47CiAgICAgfQogCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1faW1wb3J0TG9jayk7CisgICAg SW1wb3J0TXV0ZXhMb2NrZXIgbG9ja2VyKHRoaXMpOwogICAgIAogICAgIEhhc2hNYXA8U3RyaW5n LCBTdHJpbmc+OjppdGVyYXRvciBpdCA9IGl0ZW1NYXAuYmVnaW4oKTsKICAgICBIYXNoTWFwPFN0 cmluZywgU3RyaW5nPjo6aXRlcmF0b3IgZW5kID0gaXRlbU1hcC5lbmQoKTsKQEAgLTIxNCw0NiAr MjExLDIyIEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3JtSW1wb3J0KCkKICAgICAKICAg ICAvLyBCcmVhayB0aGUgKHJlZiBjb3VudCkgY3ljbGUuCiAgICAgbV9zdG9yYWdlQXJlYSA9IDA7 Ci0gICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7Ci0gICAgbV9pbXBvcnRDb25kaXRpb24uc2ln bmFsKCk7CisgICAgZGlkSW1wb3J0KCk7CiB9CiAKIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjptYXJr SW1wb3J0ZWQoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChp c0JhY2tncm91bmRUaHJlYWQoKSk7CiAKLSAgICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRM b2NrKTsKKyAgICBJbXBvcnRNdXRleExvY2tlciBsb2NrZXIodGhpcyk7CiAgICAgLy8gQnJlYWsg dGhlIChyZWYgY291bnQpIGN5Y2xlLgogICAgIG1fc3RvcmFnZUFyZWEgPSAwOwotICAgIG1faW1w b3J0Q29tcGxldGUgPSB0cnVlOwotICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25hbCgpOwotfQot Ci0vLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFsbG93IHVzZSBvZiBTdG9yYWdl QXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0byBkbyBzbykuCi0vLyBCbG9j a2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29tcGxldGUgaXMgYnkgZmFyIHRo ZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQKLS8vIHRoZXJlIGlzIGNlcnRh aW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xlbmd0aCB3aWxsIG5ldmVyIGJl IGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgotLy8gb3B0aW1pemF0aW9uIChzaW5jZSB0aGUg b3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMgYXJlIGJlaW5nIGFkZGVkKS4g R2V0IGNhbiByZXR1cm4gYW55Ci0vLyBpdGVtIGN1cnJlbnRseSBpbiB0aGUgbWFwLiBHZXQvcmVt b3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhlIG1hcCwgYnV0IHdlJ2xsIG5l ZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3VsZCBub3Qgb3ZlcndyaXRlLiBD bGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBraWxsIHRoZSBpbXBvcnQKLS8v IGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9ja1VudGlsSW1wb3J0Q29tcGxl dGUoKSBjb25zdAotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Ci0KLSAgICAvLyBGYXN0 IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KLSAgICBpZiAobV9pbXBvcnRDb21wbGV0ZSkKLSAgICAg ICAgcmV0dXJuOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1faW1wb3J0TG9jayk7Ci0gICAg d2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQotICAgICAgICBtX2ltcG9ydENvbmRpdGlvbi53YWl0 KG1faW1wb3J0TG9jayk7Ci0gICAgQVNTRVJUKG1faW1wb3J0Q29tcGxldGUpOwotICAgIEFTU0VS VCghbV9zdG9yYWdlQXJlYSk7CisgICAgZGlkSW1wb3J0KCk7CiB9CiAKIHZvaWQgU3RvcmFnZUFy ZWFTeW5jOjpzeW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmlu Zz4mIGl0ZW1zKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChp c0JhY2tncm91bmRUaHJlYWQoKSk7CiAKICAgICBpZiAoIW1fZGF0YWJhc2UuaXNPcGVuKCkpCiAg ICAgICAgIHJldHVybjsKQEAgLTMwOSwxMiArMjgyLDEyIEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5j OjpzeW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4mIGl0 ZW1zCiAKIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3JtU3luYygpCiB7Ci0gICAgQVNTRVJU KCFpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsKIAog ICAgIGJvb2wgY2xlYXJJdGVtczsKICAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiBpdGVtczsK ICAgICB7Ci0gICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3N5bmNMb2NrKTsKKyAgICAgICAg U3luY011dGV4TG9ja2VyIGxvY2tlcih0aGlzKTsKIAogICAgICAgICBBU1NFUlQobV9zeW5jU2No ZWR1bGVkKTsKIApAQCAtMzMyLDYgKzMwNSw0NyBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVy Zm9ybVN5bmMoKQogICAgIGVuYWJsZVN1ZGRlblRlcm1pbmF0aW9uKCk7CiB9CiAKKyNpZiAhRU5B QkxFKFNJTkdMRV9USFJFQURFRCkKKworLy8gRklYTUU6IEluIHRoZSBmdXR1cmUsIHdlIHNob3Vs ZCBhbGxvdyB1c2Ugb2YgU3RvcmFnZUFyZWFzIHdoaWxlIGl0J3MgaW1wb3J0aW5nICh3aGVuIHNh ZmUgdG8gZG8gc28pLgorLy8gQmxvY2tpbmcgZXZlcnl0aGluZyB1bnRpbCB0aGUgaW1wb3J0IGlz IGNvbXBsZXRlIGlzIGJ5IGZhciB0aGUgc2ltcGxlc3QgYW5kIHNhZmVzdCB0aGluZyB0byBkbywg YnV0CisvLyB0aGVyZSBpcyBjZXJ0YWlubHkgcm9vbSBmb3Igc2FmZSBvcHRpbWl6YXRpb246IEtl eS9sZW5ndGggd2lsbCBuZXZlciBiZSBhYmxlIHRvIG1ha2UgdXNlIG9mIHN1Y2ggYW4KKy8vIG9w dGltaXphdGlvbiAoc2luY2UgdGhlIG9yZGVyIG9mIGl0ZXJhdGlvbiBjYW4gY2hhbmdlIGFzIGl0 ZW1zIGFyZSBiZWluZyBhZGRlZCkuIEdldCBjYW4gcmV0dXJuIGFueQorLy8gaXRlbSBjdXJyZW50 bHkgaW4gdGhlIG1hcC4gR2V0L3JlbW92ZSBjYW4gd29yayB3aGV0aGVyIG9yIG5vdCBpdCdzIGlu IHRoZSBtYXAsIGJ1dCB3ZSdsbCBuZWVkIGEgbGlzdAorLy8gb2YgaXRlbXMgdGhlIGltcG9ydCBz aG91bGQgbm90IG92ZXJ3cml0ZS4gQ2xlYXIgY2FuIGFsc28gd29yaywgYnV0IGl0J2xsIG5lZWQg dG8ga2lsbCB0aGUgaW1wb3J0CisvLyBqb2IgZmlyc3QuCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6 YmxvY2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3QKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhy ZWFkKCkpOworCisgICAgLy8gRmFzdCBwYXRoIHRvIGF2b2lkIGxvY2tpbmcuCisgICAgaWYgKG1f aW1wb3J0Q29tcGxldGUpCisgICAgICAgIHJldHVybjsKKworICAgIE11dGV4TG9ja2VyIGxvY2tl cihtX2ltcG9ydExvY2spOworICAgIHdoaWxlICghbV9pbXBvcnRDb21wbGV0ZSkKKyAgICAgICAg bV9pbXBvcnRDb25kaXRpb24ud2FpdChtX2ltcG9ydExvY2spOworICAgIEFTU0VSVChtX2ltcG9y dENvbXBsZXRlKTsKKyAgICBBU1NFUlQoIW1fc3RvcmFnZUFyZWEpOworfQorCit2b2lkIFN0b3Jh Z2VBcmVhU3luYzo6c2NoZWR1bGVJbXBvcnQoKQoreworICAgIG1faW1wb3J0Q29tcGxldGUgPSBm YWxzZTsKKyAgICAvLyBGSVhNRTogSWYgaXQgY2FuJ3QgaW1wb3J0LCB0aGVuIHRoZSBkZWZhdWx0 IFdlYktpdCBiZWhhdmlvciBzaG91bGQgYmUgdGhhdCBvZiBwcml2YXRlIGJyb3dzaW5nLAorICAg IC8vIG5vdCBzaWxlbnRseSBpZ25vcmluZyBpdC4gIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yNTg5NAorICAgIGlmICghbV9zeW5jTWFuYWdlci0+c2NoZWR1bGVJbXBv cnQodGhpcykpCisgICAgICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOworfQorCit2b2lkIFN0 b3JhZ2VBcmVhU3luYzo6ZGlkSW1wb3J0KCkKK3sKKyAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1 ZTsKKyAgICBtX2ltcG9ydENvbmRpdGlvbi5zaWduYWwoKTsKK30KKworI2VuZGlmCisKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKZGlmZiAt LWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaCBiL1dlYkNvcmUvc3RvcmFn ZS9TdG9yYWdlQXJlYVN5bmMuaAppbmRleCBlNDM2YmVmLi45NGNlNTlkIDEwMDY0NAotLS0gYS9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL1N0 b3JhZ2VBcmVhU3luYy5oCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAw OCwgMjAwOSBBcHBsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMp IDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTc4LDE1ICs3OSw0MSBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIHZvaWQgc3luY1RpbWVyRmlyZWQoVGltZXI8U3RvcmFnZUFyZWFTeW5jPiop OwogICAgICAgICB2b2lkIHN5bmMoYm9vbCBjbGVhckl0ZW1zLCBjb25zdCBIYXNoTWFwPFN0cmlu ZywgU3RyaW5nPiYgaXRlbXMpOwogCi0gICAgICAgIE11dGV4IG1fc3luY0xvY2s7CiAgICAgICAg IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+IG1faXRlbXNQZW5kaW5nU3luYzsKICAgICAgICAgYm9v bCBtX2NsZWFySXRlbXNXaGlsZVN5bmNpbmc7CiAgICAgICAgIGJvb2wgbV9zeW5jU2NoZWR1bGVk OwogCisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAgIHZvaWQgc2NoZWR1bGVJ bXBvcnQoKTsKKyAgICAgICAgdm9pZCBkaWRJbXBvcnQoKTsKKworI2lmIEVOQUJMRShTSU5HTEVf VEhSRUFERUQpCisgICAgICAgIGJvb2wgaXNCYWNrZ3JvdW5kVGhyZWFkKCkgY29uc3QgeyByZXR1 cm4gdHJ1ZTsgfQorICAgICAgICBzdHJ1Y3QgU3luY011dGV4TG9ja2VyCisgICAgICAgIHsKKyAg ICAgICAgICAgIFN5bmNNdXRleExvY2tlcih2b2lkKikge30KKyAgICAgICAgfTsKKyAgICAgICAg c3RydWN0IEltcG9ydE11dGV4TG9ja2VyCisgICAgICAgIHsKKyAgICAgICAgICAgIEltcG9ydE11 dGV4TG9ja2VyKGNvbnN0IHZvaWQqKSB7fQorICAgICAgICB9OworI2Vsc2UKKyAgICAgICAgTXV0 ZXggbV9zeW5jTG9jazsKKyAgICAgICAgbXV0YWJsZSBib29sIG1faW1wb3J0Q29tcGxldGU7CiAg ICAgICAgIG11dGFibGUgTXV0ZXggbV9pbXBvcnRMb2NrOwogICAgICAgICBtdXRhYmxlIFRocmVh ZENvbmRpdGlvbiBtX2ltcG9ydENvbmRpdGlvbjsKLSAgICAgICAgbXV0YWJsZSBib29sIG1faW1w b3J0Q29tcGxldGU7Ci0gICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAgIGJvb2wg aXNCYWNrZ3JvdW5kVGhyZWFkKCkgY29uc3QgeyByZXR1cm4gIWlzTWFpblRocmVhZCgpOyB9Cisg ICAgICAgIGZyaWVuZCBjbGFzcyBTeW5jTXV0ZXhMb2NrZXI7CisgICAgICAgIGZyaWVuZCBjbGFz cyBJbXBvcnRNdXRleExvY2tlcjsKKyAgICAgICAgc3RydWN0IFN5bmNNdXRleExvY2tlcjogcHJp dmF0ZSBNdXRleHRMb2NrZXIKKyAgICAgICAgeworICAgICAgICAgICAgU3luY011dGV4TG9ja2Vy KFN0b3JhZ2VBcmVhU3luYyogc3RvcmFnZUFyZWFTeW5jKSA6IE11dGV4dExvY2tlcihzdG9yYWdl QXJlYVN5bmMtPm1fc3luY0xvY2spIHt9CisgICAgICAgIH07CisgICAgICAgIHN0cnVjdCBJbXBv cnRNdXRleExvY2tlcjogcHJpdmF0ZSBNdXRleHRMb2NrZXIKKyAgICAgICAgeworICAgICAgICAg ICAgSW1wb3J0TXV0ZXhMb2NrZXIoY29uc3QgU3RvcmFnZUFyZWFTeW5jKiBzdG9yYWdlQXJlYVN5 bmMpIDogTXV0ZXh0TG9ja2VyKHN0b3JhZ2VBcmVhU3luYy0+bV9pbXBvcnRMb2NrKSB7fQorICAg ICAgICB9OworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wY2NhN2Y4Ci0tLSAvZGV2L251bGwKKysr IGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAKQEAg LTAsMCArMSwxMTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0aCB0 aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8K KyAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJl ZXQsIEZpZnRoIEZsb29yLAorICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisK KyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgorCisjaWYg RU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKyNpbmNs dWRlICJEYXRhYmFzZS5oIgorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgorI2luY2x1ZGUgIlNR TFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitEYXRh YmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQorICAgIDogbV90aW1lcih0aGlzLCAmRGF0YWJh c2VUaHJlYWQ6OnRpbWVyRmlyZWQpCisgICAgLCBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IobmV3 IFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSkKK3sKK30KKworRGF0YWJhc2VUaHJlYWQ6On5E YXRhYmFzZVRocmVhZCgpCit7Cit9CisKK2Jvb2wgRGF0YWJhc2VUaHJlYWQ6OnN0YXJ0KCkKK3sK KyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6cmVxdWVzdFRlcm1p bmF0aW9uKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7CisgICAgbV90cmFuc2FjdGlvbkNvb3Jk aW5hdG9yLT5zaHV0ZG93bigpOworfQorCitib29sIERhdGFiYXNlVGhyZWFkOjp0ZXJtaW5hdGlv blJlcXVlc3RlZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcXVldWUuaXNFbXB0eSgpOworfQor Cit2b2lkIERhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNlVGhyZWFkPiop Cit7CisgICAgaWYgKG1fcXVldWUuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBS ZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOworICAgIHRhc2stPnBl cmZvcm1UYXNrKCk7CisgICAgbV9xdWV1ZS5yZW1vdmVGaXJzdCgpOworICAgIGlmICghbV9xdWV1 ZS5pc0VtcHR5KCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lk IERhdGFiYXNlVGhyZWFkOjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRh c2spCit7CisgICAgbV9xdWV1ZS5hcHBlbmQodGFzayk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0 aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIERhdGFi YXNlVGhyZWFkOjpzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+ IHRhc2spCit7CisgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKK30KKwordm9pZCBEYXRhYmFzZVRo cmVhZDo6dW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAg IERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gcmVzZXJ2ZWRUYXNrczsKKyAgICBmb3IgKERl cXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID46OmNvbnN0X2l0ZXJhdG9yIGkgPSBtX3F1ZXVlLmJl Z2luKCk7IGkgIT0gbV9xdWV1ZS5lbmQoKTsgKytpKSB7CisgICAgICAgIGlmICgoKmkpLT5kYXRh YmFzZSgpICE9IGRhdGFiYXNlKQorICAgICAgICAgICAgcmVzZXJ2ZWRUYXNrcy5hcHBlbmQoKmkp OworICAgIH0KKworICAgIG1fcXVldWUuc3dhcChyZXNlcnZlZFRhc2tzKTsKK30KKwordm9pZCBE YXRhYmFzZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sK KyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmRE YXRhYmFzZUNsb3NlZChEYXRhYmFzZSogZGF0YWJhc2UpCit7CisgICAgbm90SW1wbGVtZW50ZWQo KTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFNJTkdM RV9USFJFQURFRCkKKyNlbmRpZiAvLyBFTkFCTEUoRE9NX1NUT1JBR0UpCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmM2ZjJhYgotLS0gL2Rldi9udWxsCisr KyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNw cApAQCAtMCwwICsxLDkwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmls ZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlzIGxpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAorICog IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhyZWFkLmgi CisKKyNpZiBFTkFCTEUoRE9NX1NUT1JBR0UpCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkK KworI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRhc2suaCIKKyNpbmNsdWRlICJTdG9yYWdlQXJlYVN5 bmMuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzUmVmUHRyPExvY2FsU3RvcmFnZVRo cmVhZD4gTG9jYWxTdG9yYWdlVGhyZWFkOjpjcmVhdGUoKQoreworICAgIHJldHVybiBhZG9wdFJl ZihuZXcgTG9jYWxTdG9yYWdlVGhyZWFkKTsKK30KKworTG9jYWxTdG9yYWdlVGhyZWFkOjpMb2Nh bFN0b3JhZ2VUaHJlYWQoKQorOiBtX3RpbWVyKHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRp bWVyRmlyZWQpCit7Cit9CisKK2Jvb2wgTG9jYWxTdG9yYWdlVGhyZWFkOjpzdGFydCgpCit7Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVk KFRpbWVyPExvY2FsU3RvcmFnZVRocmVhZD4qKQoreworICAgIGlmIChtX3F1ZXVlLmlzRW1wdHko KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgUmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+IHRhc2sg PSBtX3F1ZXVlLmZpcnN0KCk7CisgICAgbV9xdWV1ZS5yZW1vdmVGaXJzdCgpOworICAgIHRhc2st PnBlcmZvcm1UYXNrKCk7CisgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgbV90 aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hl ZHVsZUltcG9ydChQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4gYXJlYSkKK3sKKyAgICBtX3F1 ZXVlLmFwcGVuZChMb2NhbFN0b3JhZ2VUYXNrOjpjcmVhdGVJbXBvcnQoYXJlYSkpOworICAgIGlm ICghbV90aW1lci5pc0FjdGl2ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsK K30KKwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0 b3JhZ2VBcmVhU3luYz4gYXJlYSkKK3sKKyAgICBtX3F1ZXVlLmFwcGVuZChMb2NhbFN0b3JhZ2VU YXNrOjpjcmVhdGVTeW5jKGFyZWEpKTsKKyAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKKyAg ICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhy ZWFkOjp0ZXJtaW5hdGUoKQoreworICAgIG1fcXVldWUuY2xlYXIoKTsKKyAgICBtX3RpbWVyLnN0 b3AoKTsKK30KKwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnBlcmZvcm1UZXJtaW5hdGUoKQor eworICAgIG1fcXVldWUuY2xlYXIoKTsKKyAgICBtX3RpbWVyLnN0b3AoKTsKK30KKworfQorI2Vu ZGlmIC8vIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9S QUdFKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdl QXJlYVN5bmMuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJl YVN5bmMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjZhMjI0ZjkKLS0t IC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL1N0b3JhZ2VB cmVhU3luYy5jcHAKQEAgLTAsMCArMSw1MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBU b3JjaCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiAg VGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVz ZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNl aXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAq ICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYg bm90LCB3cml0ZSB0bworICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUx IEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAx LCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlN0b3JhZ2VBcmVh U3luYy5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhS RUFERUQpCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OnNj aGVkdWxlSW1wb3J0KCkKK3sKKyAgICAvLyBEbyBhIGJsb2NraW5nIGltcG9ydCBiZWNhdXNlIHdl IGNhbm5vdCAiYmxvY2tVbnRpbEltcG9ydENvbXBsZXRlIiB3aXRoIG9uZSB0aHJlYWQKKyAgICBw ZXJmb3JtSW1wb3J0KCk7Cit9CisKK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjpkaWRJbXBvcnQoKQor eworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6YmxvY2tVbnRpbEltcG9ydENvbXBsZXRlKCkg Y29uc3QKK3sKKyAgICAvLyBXZSBoYXZlIGFscmVhZHkgaW1wb3J0ZWQgaW4gc2NoZWR1bGVJbXBv cnQoKQorfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoU0lO R0xFX1RIUkVBREVEKQorI2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKKwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwIGIvV2ViQ29y ZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwCmRlbGV0ZWQgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCBkODExNDVkLi4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3RvcmFnZS93aW5j ZS9EYXRhYmFzZVRocmVhZFdpbmNlLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDk1ICswLDAgQEAK LS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0g KiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK LSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdO VQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgot ICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNl ZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgotICovCi0KLSNpbmNsdWRlICJjb25m aWcuaCIKLSNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgotCi0jaW5jbHVkZSAiRGF0YWJhc2Uu aCIKLSNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1E YXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQotOiBtX3RpbWVyKHRoaXMsICZEYXRhYmFz ZVRocmVhZDo6dGltZXJGaXJlZCkKLXsKLX0KLQotRGF0YWJhc2VUaHJlYWQ6On5EYXRhYmFzZVRo cmVhZCgpCi17Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbigp Ci17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotfQotCi1ib29sIERhdGFiYXNlVGhyZWFkOjp0ZXJt aW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fcXVldWUuaXNFbXB0eSgp OwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNlVGhy ZWFkPiopCi17Ci0gICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkgewotICAgICAgICBSZWZQdHI8 RGF0YWJhc2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOwotICAgICAgICB0YXNrLT5wZXJm b3JtVGFzaygpOwotICAgICAgICBtX3F1ZXVlLnJlbW92ZUZpcnN0KCk7Ci0gICAgICAgIGlmICgh bV9xdWV1ZS5pc0VtcHR5KCkpCi0gICAgICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsK LSAgICB9Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlVGFzayhQYXNzUmVmUHRy PERhdGFiYXNlVGFzaz4gdGFzaykKLXsKLSAgICBtX3F1ZXVlLmFwcGVuZCh0YXNrKTsKLSAgICBp ZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7 Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVm UHRyPERhdGFiYXNlVGFzaz4gdGFzaykKLXsKLSAgICB0YXNrLT5wZXJmb3JtVGFzaygpOwotfQot Ci12b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRhYmFzZSog ZGF0YWJhc2UpCi17Ci0gICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiByZXNlcnZlZFRh c2tzOwotICAgIGZvciAoRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPjo6Y29uc3RfaXRlcmF0 b3IgaSA9IG1fcXVldWUuYmVnaW4oKTsgaSAhPSBtX3F1ZXVlLmVuZCgpOyArK2kpIHsKLSAgICAg ICAgaWYgKCgqaSktPmRhdGFiYXNlKCkgIT0gZGF0YWJhc2UpCi0gICAgICAgICAgICByZXNlcnZl ZFRhc2tzLmFwcGVuZCgqaSk7Ci0gICAgfQotCi0gICAgbV9xdWV1ZS5zd2FwKHJlc2VydmVkVGFz a3MpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZU9wZW4oRGF0YWJh c2UqIGRhdGFiYXNlKQotewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci19Ci0KLXZvaWQgRGF0YWJh c2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAg ICBub3RJbXBsZW1lbnRlZCgpOwotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1n aXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5oIGIvV2ViQ29y ZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaApkZWxldGVkIGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggZmFmYzc5MS4uMDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2Uv RGF0YWJhc2VUaHJlYWRXaW5jZS5oCisrKyAvZGV2L251bGwKQEAgLTEsNjUgKzAsMCBAQAotLyoK LSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEu IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICog ICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl IGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogIE1FUkNIQU5UQUJJ TElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCi0g KiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgot ICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRo ZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwotICogIHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCi0g KiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0gKi8KLQotI2lmbmRlZiBEYXRhYmFzZVRo cmVhZFdpbmNlX2gKLSNkZWZpbmUgRGF0YWJhc2VUaHJlYWRXaW5jZV9oCi0KLSNpbmNsdWRlIDx3 dGYvRGVxdWUuaD4KLSNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgotCi1uYW1lc3BhY2UgV2Vi Q29yZSB7Ci0KLSAgICBjbGFzcyBEYXRhYmFzZTsKLSAgICBjbGFzcyBEYXRhYmFzZVRhc2s7Ci0K LSAgICBjbGFzcyBEYXRhYmFzZVRocmVhZDogcHVibGljIFdURjo6UmVmQ291bnRlZDxEYXRhYmFz ZVRocmVhZD4gewotCi0gICAgcHVibGljOgotICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxEYXRh YmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFiYXNlVGhyZWFk KTsgfQotICAgICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgICAgICBib29sIHN0YXJ0KCkg eyByZXR1cm4gdHJ1ZTsgfQotICAgICAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAg ICAgICBib29sIHRlcm1pbmF0aW9uUmVxdWVzdGVkKCkgY29uc3Q7Ci0KLSAgICAgICAgdm9pZCBz Y2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsKLSAgICAgICAgdm9pZCBzY2hl ZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+KTsKLSAgICAgICAgdm9p ZCB1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRhYmFzZSopOwotICAgICAgICB2b2lkIHJlY29y ZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOwotICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlQ2xv c2VkKERhdGFiYXNlKik7Ci0jaWZuZGVmIE5ERUJVRwotICAgICAgICBUaHJlYWRJZGVudGlmaWVy IGdldFRocmVhZElEKCkgY29uc3QgeyByZXR1cm4gY3VycmVudFRocmVhZCgpOyB9Ci0jZW5kaWYK LQotICAgIHByaXZhdGU6Ci0gICAgICAgIERhdGFiYXNlVGhyZWFkKCk7Ci0KLSAgICAgICAgdm9p ZCB0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNlVGhyZWFkPiopOwotCi0gICAgICAgIERlcXVlPFJl ZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9xdWV1ZTsKLSAgICAgICAgVGltZXI8RGF0YWJhc2VUaHJl YWQ+IG1fdGltZXI7Ci0gICAgfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYg Ly8gRGF0YWJhc2VUaHJlYWRXaW5jZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNl L0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2Nh bFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhk Y2I5MDIuLjAwMDAwMDAKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRo cmVhZFdpbmNlLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDgzICswLDAgQEAKLS8qCi0gKiBDb3B5 cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0g KgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAot ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJh cnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBD T1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3Rv biwgTUEgMDIxMTAtMTMwMSwgVVNBLgotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNs dWRlICJMb2NhbFN0b3JhZ2VUaHJlYWQuaCIKLQotI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRhc2su aCIKLSNpbmNsdWRlICJTdG9yYWdlQXJlYVN5bmMuaCIKLQotbmFtZXNwYWNlIFdlYkNvcmUgewot Ci1Mb2NhbFN0b3JhZ2VUaHJlYWQ6OkxvY2FsU3RvcmFnZVRocmVhZCgpCi06IG1fdGltZXIodGhp cywgJkxvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJGaXJlZCkKLXsKLX0KLQotTG9jYWxTdG9yYWdl VGhyZWFkOjp+TG9jYWxTdG9yYWdlVGhyZWFkKCkKLXsKLX0KLQotYm9vbCBMb2NhbFN0b3JhZ2VU aHJlYWQ6OnN0YXJ0KCkKLXsKLSAgICByZXR1cm4gdHJ1ZTsKLX0KLQotdm9pZCBMb2NhbFN0b3Jh Z2VUaHJlYWQ6OnRpbWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopCi17Ci0gICAg aWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkgewotICAgICAgICBSZWZQdHI8TG9jYWxTdG9yYWdlVGFz az4gdGFzayA9IG1fcXVldWUuZmlyc3QoKTsKLSAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsK LSAgICAgICAgbV9xdWV1ZS5yZW1vdmVGaXJzdCgpOwotICAgICAgICBpZiAoIW1fcXVldWUuaXNF bXB0eSgpKQotICAgICAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci0gICAgfQotfQot Ci12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9y YWdlQXJlYVN5bmM+IGFyZWEpCi17Ci0gICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFz azo6Y3JlYXRlSW1wb3J0KGFyZWEpKTsKLSAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAg ICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhy ZWFkOjpzY2hlZHVsZVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCi17Ci0g ICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlU3luYyhhcmVhKSk7Ci0g ICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90 KDApOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6dGVybWluYXRlKCkKLXsKLSAgICBt X3F1ZXVlLmNsZWFyKCk7Ci0gICAgbV90aW1lci5zdG9wKCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9y YWdlVGhyZWFkOjpwZXJmb3JtVGVybWluYXRlKCkKLXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7Ci0g ICAgbV90aW1lci5zdG9wKCk7Ci19Ci0KLX0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93 aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oIGIvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xv Y2FsU3RvcmFnZVRocmVhZFdpbmNlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMw MGFiYjUuLjAwMDAwMDAKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRo cmVhZFdpbmNlLmgKKysrIC9kZXYvbnVsbApAQCAtMSw1OCArMCwwIEBACi0vKgotICogQ29weXJp Z2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoK LSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpIHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91 dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNo b3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZQotICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09Q WUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24s IE1BIDAyMTEwLTEzMDEsIFVTQS4KLSAqLwotCi0KLSNpZm5kZWYgTG9jYWxTdG9yYWdlVGhyZWFk V2luY2VfaAotI2RlZmluZSBMb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZV9oCi0KLSNpbmNsdWRlIDx3 dGYvRGVxdWUuaD4KLSNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgotCi1uYW1lc3BhY2UgV2Vi Q29yZSB7Ci0KLSAgICBjbGFzcyBTdG9yYWdlQXJlYVN5bmM7Ci0gICAgY2xhc3MgTG9jYWxTdG9y YWdlVGFzazsKLQotICAgIGNsYXNzIExvY2FsU3RvcmFnZVRocmVhZCA6IHB1YmxpYyBSZWZDb3Vu dGVkPExvY2FsU3RvcmFnZVRocmVhZD4gewotICAgIHB1YmxpYzoKLSAgICAgICAgc3RhdGljIFBh c3NSZWZQdHI8TG9jYWxTdG9yYWdlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBhZG9wdFJlZihu ZXcgTG9jYWxTdG9yYWdlVGhyZWFkKTsgfQotCi0gICAgICAgIH5Mb2NhbFN0b3JhZ2VUaHJlYWQo KTsKLSAgICAgICAgYm9vbCBzdGFydCgpOwotICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KFBh c3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPik7Ci0gICAgICAgIHZvaWQgc2NoZWR1bGVTeW5jKFBh c3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPik7Ci0gICAgICAgIHZvaWQgdGVybWluYXRlKCk7Ci0g ICAgICAgIHZvaWQgcGVyZm9ybVRlcm1pbmF0ZSgpOwotCi0gICAgcHJpdmF0ZToKLSAgICAgICAg TG9jYWxTdG9yYWdlVGhyZWFkKCk7Ci0KLSAgICAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPExv Y2FsU3RvcmFnZVRocmVhZD4qKTsKLQotICAgICAgICBEZXF1ZTxSZWZQdHI8TG9jYWxTdG9yYWdl VGFzaz4gPiBtX3F1ZXVlOwotICAgICAgICBUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IG1fdGlt ZXI7Ci0gICAgfTsKLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotCi0jZW5kaWYgLy8gTG9jYWxT dG9yYWdlVGhyZWFkV2luY2VfaAo= 38393 2009-08-21 14:08:20 -0700 2009-08-21 14:14:28 -0700 more refactoring 28019.patch text/plain 31780 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTJhNWRlYy4uZmFhMjEyYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAwOS0wOC0yMSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u OiB1c2UgVGltZXIgdG8gZG8gYXN5bmMKKyAgICAgICAgZGF0YWJhc2UgdGFza3MKKyAgICAgICAg VGhpcyBwYXRjaCBhbHNvIHJlcGxhY2VzIHN0b3JhZ2Uvd2luY2Ugd2l0aCBzdG9yYWdlL3Npbmds ZS10aHJlYWRlZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjgwMTkKKworICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaDoKKyAgICAgICAg KiBzdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oOgorICAgICAgICAqIHN0b3JhZ2UvU3RvcmFn ZUFyZWFTeW5jLmNwcDoKKyAgICAgICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oOgorICAg ICAgICAqIHN0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcDogQWRkZWQu CisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNw cDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFT eW5jLmNwcDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdp bmNlLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFk V2luY2UuaDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRo cmVhZFdpbmNlLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3Rv cmFnZVRocmVhZFdpbmNlLmg6IFJlbW92ZWQuCisKIDIwMDktMDgtMTkgIEphbiBNaWNoYWVsIEFs b256byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExv cGV6LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmggYi9XZWJD b3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAppbmRleCA1OWQ3YTVkLi5lNjNhNzE5IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQg KEMpIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJp Z2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoK ICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOSw2ICszMCw3IEBACiAjZGVmaW5lIERh dGFiYXNlVGhyZWFkX2gKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKKwogI2luY2x1ZGUgPHd0Zi9E ZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQu aD4KQEAgLTQwLDQ4ICs0Miw1OCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIERh dGFiYXNlOwotY2xhc3MgRGF0YWJhc2VUYXNrOwotY2xhc3MgRG9jdW1lbnQ7Ci1jbGFzcyBTUUxU cmFuc2FjdGlvbkNvb3JkaW5hdG9yOwotCi1jbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBU aHJlYWRTYWZlU2hhcmVkPERhdGFiYXNlVGhyZWFkPiB7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBh c3NSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBE YXRhYmFzZVRocmVhZCk7IH0KLSAgICB+RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIGJvb2wgc3Rh cnQoKTsKLSAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAgIGJvb2wgdGVybWluYXRp b25SZXF1ZXN0ZWQoKSBjb25zdDsKLQotICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2VUYXNrPik7Ci0gICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0 cjxEYXRhYmFzZVRhc2s+KTsgLy8gVGhpcyBqdXN0IGFkZHMgdGhlIHRhc2sgdG8gdGhlIGZyb250 IG9mIHRoZSBxdWV1ZSAtIHRoZSBjYWxsZXIgbmVlZHMgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwg bm90IHRvIGNyZWF0ZSBkZWFkbG9ja3Mgd2hlbiB3YWl0aW5nIGZvciBjb21wbGV0aW9uLgotICAg IHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqKTsKLQotICAgIHZvaWQgcmVj b3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7Ci0gICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3Nl ZChEYXRhYmFzZSopOwotICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSB7IHJldHVy biBtX3RocmVhZElEOyB9Ci0KLSAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2Fj dGlvbkNvb3JkaW5hdG9yKCkgeyByZXR1cm4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmdldCgp OyB9Ci0KLXByaXZhdGU6Ci0gICAgRGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIHN0YXRpYyB2b2lk KiBkYXRhYmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKLSAgICB2b2lkKiBkYXRhYmFzZVRocmVhZCgp OwotCi0gICAgTXV0ZXggbV90aHJlYWRDcmVhdGlvbk11dGV4OwotICAgIFRocmVhZElkZW50aWZp ZXIgbV90aHJlYWRJRDsKLSAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fc2VsZlJlZjsKLQot ICAgIE1lc3NhZ2VRdWV1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7Ci0KLSAgICAv LyBUaGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFzZXMgdGhhdCBoYXZlIGJl ZW4gdXNlZCBvbiB0aGlzIHRocmVhZC4KLSAgICB0eXBlZGVmIEhhc2hTZXQ8UmVmUHRyPERhdGFi YXNlPiA+IERhdGFiYXNlU2V0OwotICAgIERhdGFiYXNlU2V0IG1fb3BlbkRhdGFiYXNlU2V0Owot Ci0gICAgT3duUHRyPFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29y ZGluYXRvcjsKLX07CisgICAgY2xhc3MgRGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNr OworICAgIGNsYXNzIERvY3VtZW50OworICAgIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0 b3I7CisKKyAgICBjbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVk PERhdGFiYXNlVGhyZWFkPiB7CisgICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0 cjxEYXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFiYXNl VGhyZWFkKTsgfQorICAgICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKKworICAgICAgICBib29sIHN0 YXJ0KCk7CisgICAgICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7CisgICAgICAgIGJvb2wg dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsKKworICAgICAgICB2b2lkIHNjaGVkdWxlVGFz ayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOworICAgICAgICB2b2lkIHNjaGVkdWxlSW1tZWRp YXRlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOyAvLyBUaGlzIGp1c3QgYWRkcyB0aGUg dGFzayB0byB0aGUgZnJvbnQgb2YgdGhlIHF1ZXVlIC0gdGhlIGNhbGxlciBuZWVkcyB0byBiZSBl eHRyZW1lbHkgY2FyZWZ1bCBub3QgdG8gY3JlYXRlIGRlYWRsb2NrcyB3aGVuIHdhaXRpbmcgZm9y IGNvbXBsZXRpb24uCisgICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJh c2UqKTsKKworICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOworICAg ICAgICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7CisjaWYgRU5BQkxFKFNJ TkdMRV9USFJFQURFRCkKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsg cmV0dXJuIGN1cnJlbnRUaHJlYWQoKTsgfQorI2Vsc2UKKyAgICAgICAgVGhyZWFkSWRlbnRpZmll ciBnZXRUaHJlYWRJRCgpIHsgcmV0dXJuIG1fdGhyZWFkSUQ7IH0KKyNlbmRpZgorCisgICAgICAg IFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSB7IHJl dHVybiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0KKworICAgIHByaXZhdGU6Cisg ICAgICAgIERhdGFiYXNlVGhyZWFkKCk7CisKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQor ICAgICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+Kik7CisKKyAgICAg ICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOworICAgICAgICBUaW1lcjxE YXRhYmFzZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCisgICAgICAgIHN0YXRpYyB2b2lkKiBkYXRh YmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKKyAgICAgICAgdm9pZCogZGF0YWJhc2VUaHJlYWQoKTsK KworICAgICAgICBNdXRleCBtX3RocmVhZENyZWF0aW9uTXV0ZXg7CisgICAgICAgIFRocmVhZElk ZW50aWZpZXIgbV90aHJlYWRJRDsKKyAgICAgICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX3Nl bGZSZWY7CisKKyAgICAgICAgTWVzc2FnZVF1ZXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9x dWV1ZTsKKworICAgICAgICAvLyBUaGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRh YmFzZXMgdGhhdCBoYXZlIGJlZW4gdXNlZCBvbiB0aGlzIHRocmVhZC4KKyAgICAgICAgdHlwZWRl ZiBIYXNoU2V0PFJlZlB0cjxEYXRhYmFzZT4gPiBEYXRhYmFzZVNldDsKKyAgICAgICAgRGF0YWJh c2VTZXQgbV9vcGVuRGF0YWJhc2VTZXQ7CisjZW5kaWYKKyAgICAgICAgT3duUHRyPFNRTFRyYW5z YWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGluYXRvcjsKKyAgICB9OwogCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9Mb2Nh bFN0b3JhZ2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaApp bmRleCAzZDU4NDI3Li5iMDE5YTU2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxT dG9yYWdlVGhyZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5o CkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFs bCBSaWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJ bmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK QEAgLTI4LDYgKzI5LDcgQEAKIAogI2lmIEVOQUJMRShET01fU1RPUkFHRSkKIAorI2luY2x1ZGUg PHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL01l c3NhZ2VRdWV1ZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CkBAIC01Niw2ICs1OCwx MiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgTG9jYWxTdG9y YWdlVGhyZWFkKCk7CiAKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICB2b2lk IHRpbWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOworCisgICAgICAgIERlcXVl PFJlZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7CisgICAgICAgIFRpbWVyPExvY2Fs U3RvcmFnZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCiAgICAgICAgIHN0YXRpYyB2b2lkKiBsb2Nh bFN0b3JhZ2VUaHJlYWRTdGFydCh2b2lkKik7CiAgICAgICAgIHZvaWQqIGxvY2FsU3RvcmFnZVRo cmVhZCgpOwogCkBAIC02Nyw2ICs3NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAg CiAgICAgICAgIE11dGV4IG1fdGVybWluYXRlTG9jazsKICAgICAgICAgVGhyZWFkQ29uZGl0aW9u IG1fdGVybWluYXRlQ29uZGl0aW9uOworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAppbmRleCAwMWQyYTY1Li42ZjA5 MWI3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8q CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgogICoKICAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC01NSwxNSArNTYsMTEgQEAgU3RvcmFnZUFyZWFTeW5j OjpTdG9yYWdlQXJlYVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlU3luY01hbmFnZXI+IHN0b3JhZ2VT eW5jTWFuYWcKICAgICAsIG1fc3luY01hbmFnZXIoc3RvcmFnZVN5bmNNYW5hZ2VyKQogICAgICwg bV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nKGZhbHNlKQogICAgICwgbV9zeW5jU2NoZWR1bGVkKGZh bHNlKQotICAgICwgbV9pbXBvcnRDb21wbGV0ZShmYWxzZSkKIHsKICAgICBBU1NFUlQobV9zdG9y YWdlQXJlYSk7CiAgICAgQVNTRVJUKG1fc3luY01hbmFnZXIpOwogCi0gICAgLy8gRklYTUU6IElm IGl0IGNhbid0IGltcG9ydCwgdGhlbiB0aGUgZGVmYXVsdCBXZWJLaXQgYmVoYXZpb3Igc2hvdWxk IGJlIHRoYXQgb2YgcHJpdmF0ZSBicm93c2luZywKLSAgICAvLyBub3Qgc2lsZW50bHkgaWdub3Jp bmcgaXQuICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTQKLSAg ICBpZiAoIW1fc3luY01hbmFnZXItPnNjaGVkdWxlSW1wb3J0KHRoaXMpKQotICAgICAgICBtX2lt cG9ydENvbXBsZXRlID0gdHJ1ZTsKKyAgICBzY2hlZHVsZUltcG9ydCgpOwogfQogCiBTdG9yYWdl QXJlYVN5bmM6On5TdG9yYWdlQXJlYVN5bmMoKQpAQCAtMTYwLDcgKzE1Nyw3IEBAIHZvaWQgU3Rv cmFnZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZChUaW1lcjxTdG9yYWdlQXJlYVN5bmM+KikKIAog dm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQogewotICAgIEFTU0VSVCghaXNN YWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAgICAgQVNT RVJUKCFtX2RhdGFiYXNlLmlzT3BlbigpKTsKIAogICAgIFN0cmluZyBkYXRhYmFzZUZpbGVuYW1l ID0gbV9zeW5jTWFuYWdlci0+ZnVsbERhdGFiYXNlRmlsZW5hbWUobV9zdG9yYWdlQXJlYS0+c2Vj dXJpdHlPcmlnaW4oKSk7CkBAIC0yMTIsNDggKzIwOSwyMCBAQCB2b2lkIFN0b3JhZ2VBcmVhU3lu Yzo6cGVyZm9ybUltcG9ydCgpCiAgICAgZm9yICg7IGl0ICE9IGVuZDsgKytpdCkKICAgICAgICAg bV9zdG9yYWdlQXJlYS0+aW1wb3J0SXRlbShpdC0+Zmlyc3QsIGl0LT5zZWNvbmQpOwogICAgIAot ICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KLSAgICBtX3N0b3JhZ2VBcmVhID0g MDsKLSAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1ZTsKLSAgICBtX2ltcG9ydENvbmRpdGlvbi5z aWduYWwoKTsKKyAgICBtYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCk7CiB9CiAKIHZv aWQgU3RvcmFnZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWQoKQogewotICAgIEFTU0VSVCghaXNNYWlu VGhyZWFkKCkpOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1faW1wb3J0TG9jayk7Ci0gICAg Ly8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xlLgotICAgIG1fc3RvcmFnZUFyZWEgPSAwOwot ICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOwotICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25h bCgpOwotfQotCi0vLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFsbG93IHVzZSBv ZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0byBkbyBzbyku Ci0vLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29tcGxldGUgaXMg YnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQKLS8vIHRoZXJl IGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xlbmd0aCB3aWxs IG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgotLy8gb3B0aW1pemF0aW9uIChz aW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMgYXJlIGJlaW5n IGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55Ci0vLyBpdGVtIGN1cnJlbnRseSBpbiB0aGUgbWFw LiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhlIG1hcCwgYnV0 IHdlJ2xsIG5lZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3VsZCBub3Qgb3Zl cndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBraWxsIHRoZSBp bXBvcnQKLS8vIGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9ja1VudGlsSW1w b3J0Q29tcGxldGUoKSBjb25zdAotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Ci0KLSAg ICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KLSAgICBpZiAobV9pbXBvcnRDb21wbGV0 ZSkKLSAgICAgICAgcmV0dXJuOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAK ICAgICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKLSAgICB3aGlsZSAoIW1faW1w b3J0Q29tcGxldGUpCi0gICAgICAgIG1faW1wb3J0Q29uZGl0aW9uLndhaXQobV9pbXBvcnRMb2Nr KTsKLSAgICBBU1NFUlQobV9pbXBvcnRDb21wbGV0ZSk7Ci0gICAgQVNTRVJUKCFtX3N0b3JhZ2VB cmVhKTsKKyAgICBtYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCk7CiB9CiAKIHZvaWQg U3RvcmFnZUFyZWFTeW5jOjpzeW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1hcDxTdHJp bmcsIFN0cmluZz4mIGl0ZW1zKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAg IEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAKICAgICBpZiAoIW1fZGF0YWJhc2UuaXNP cGVuKCkpCiAgICAgICAgIHJldHVybjsKQEAgLTMwOSw3ICsyNzgsNyBAQCB2b2lkIFN0b3JhZ2VB cmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hNYXA8U3RyaW5nLCBTdHJp bmc+JiBpdGVtcwogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybVN5bmMoKQogewotICAg IEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQo KSk7CiAKICAgICBib29sIGNsZWFySXRlbXM7CiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4g aXRlbXM7CkBAIC0zMzIsNiArMzAxLDQ5IEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3Jt U3luYygpCiAgICAgZW5hYmxlU3VkZGVuVGVybWluYXRpb24oKTsKIH0KIAorI2lmICFFTkFCTEUo U0lOR0xFX1RIUkVBREVEKQorCisvLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFs bG93IHVzZSBvZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0 byBkbyBzbykuCisvLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29t cGxldGUgaXMgYnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQK Ky8vIHRoZXJlIGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xl bmd0aCB3aWxsIG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgorLy8gb3B0aW1p emF0aW9uIChzaW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMg YXJlIGJlaW5nIGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55CisvLyBpdGVtIGN1cnJlbnRseSBp biB0aGUgbWFwLiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhl IG1hcCwgYnV0IHdlJ2xsIG5lZWQgYSBsaXN0CisvLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3Vs ZCBub3Qgb3ZlcndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBr aWxsIHRoZSBpbXBvcnQKKy8vIGpvYiBmaXJzdC4KK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9j a1VudGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQo KSk7CisKKyAgICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KKyAgICBpZiAobV9pbXBv cnRDb21wbGV0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1f aW1wb3J0TG9jayk7CisgICAgd2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICBtX2lt cG9ydENvbmRpdGlvbi53YWl0KG1faW1wb3J0TG9jayk7CisgICAgQVNTRVJUKG1faW1wb3J0Q29t cGxldGUpOworICAgIEFTU0VSVCghbV9zdG9yYWdlQXJlYSk7Cit9CisKK3ZvaWQgU3RvcmFnZUFy ZWFTeW5jOjpzY2hlZHVsZUltcG9ydCgpCit7CisgICAgbV9pbXBvcnRDb21wbGV0ZSA9IGZhbHNl OworICAgIC8vIEZJWE1FOiBJZiBpdCBjYW4ndCBpbXBvcnQsIHRoZW4gdGhlIGRlZmF1bHQgV2Vi S2l0IGJlaGF2aW9yIHNob3VsZCBiZSB0aGF0IG9mIHByaXZhdGUgYnJvd3NpbmcsCisgICAgLy8g bm90IHNpbGVudGx5IGlnbm9yaW5nIGl0LiAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTI1ODk0CisgICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0 aGlzKSkKKyAgICAgICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7Cit9CisKK3ZvaWQgU3RvcmFn ZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCkKK3sKKyAgICAvLyBC cmVhayB0aGUgKHJlZiBjb3VudCkgY3ljbGUuCisgICAgbV9zdG9yYWdlQXJlYSA9IDA7CisgICAg bV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7CisgICAgbV9pbXBvcnRDb25kaXRpb24uc2lnbmFsKCk7 Cit9CisKKyNlbmRpZgorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFC TEUoRE9NX1NUT1JBR0UpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFT eW5jLmggYi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKaW5kZXggZTQzNmJlZi4u NTA5ZjZiYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCisr KyBiL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaApAQCAtMSw1ICsxLDYgQEAKIC8q CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC03OCwxNSArNzks MzEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHN5bmNUaW1lckZpcmVkKFRp bWVyPFN0b3JhZ2VBcmVhU3luYz4qKTsKICAgICAgICAgdm9pZCBzeW5jKGJvb2wgY2xlYXJJdGVt cywgY29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4mIGl0ZW1zKTsKIAotICAgICAgICBNdXRl eCBtX3N5bmNMb2NrOwogICAgICAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiBtX2l0ZW1zUGVu ZGluZ1N5bmM7CiAgICAgICAgIGJvb2wgbV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nOwogICAgICAg ICBib29sIG1fc3luY1NjaGVkdWxlZDsKIAorICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KCk7 CisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVk V2l0aG91dExvY2tpbmdNdXRleCgpOworCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyAg ICAgICAgYm9vbCBpc0JhY2tncm91bmRUaHJlYWQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9Cisg ICAgICAgIC8vIEhhY2sgV1RGOjpNdXRleExvY2tlciBhbmQganVzdCBkbyBub3RoaW5nCisgICAg ICAgIGVudW0gRHVtbXlNdXRleCB7CisgICAgICAgICAgICBtX3N5bmNMb2NrLAorICAgICAgICAg ICAgbV9pbXBvcnRMb2NrLAorICAgICAgICB9OworICAgICAgICBzdHJ1Y3QgTXV0ZXhMb2NrZXIg eworICAgICAgICAgICAgTXV0ZXhMb2NrZXIoRHVtbXlNdXRleCkge30KKyAgICAgICAgfTsKKyNl bHNlCisgICAgICAgIE11dGV4IG1fc3luY0xvY2s7CisgICAgICAgIG11dGFibGUgYm9vbCBtX2lt cG9ydENvbXBsZXRlOwogICAgICAgICBtdXRhYmxlIE11dGV4IG1faW1wb3J0TG9jazsKICAgICAg ICAgbXV0YWJsZSBUaHJlYWRDb25kaXRpb24gbV9pbXBvcnRDb25kaXRpb247Ci0gICAgICAgIG11 dGFibGUgYm9vbCBtX2ltcG9ydENvbXBsZXRlOwotICAgICAgICB2b2lkIG1hcmtJbXBvcnRlZCgp OworICAgICAgICBib29sIGlzQmFja2dyb3VuZFRocmVhZCgpIGNvbnN0IHsgcmV0dXJuICFpc01h aW5UaHJlYWQoKTsgfQorI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVh ZC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNw cApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wY2NhN2Y4Ci0tLSAvZGV2L251 bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5j cHAKQEAgLTAsMCArMSwxMTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9i aWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCisg KiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xp biBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgor CisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisK KyNpbmNsdWRlICJEYXRhYmFzZS5oIgorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgorI2luY2x1 ZGUgIlNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitEYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQorICAgIDogbV90aW1lcih0aGlzLCAm RGF0YWJhc2VUaHJlYWQ6OnRpbWVyRmlyZWQpCisgICAgLCBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0 b3IobmV3IFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSkKK3sKK30KKworRGF0YWJhc2VUaHJl YWQ6On5EYXRhYmFzZVRocmVhZCgpCit7Cit9CisKK2Jvb2wgRGF0YWJhc2VUaHJlYWQ6OnN0YXJ0 KCkKK3sKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6cmVxdWVz dFRlcm1pbmF0aW9uKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7CisgICAgbV90cmFuc2FjdGlv bkNvb3JkaW5hdG9yLT5zaHV0ZG93bigpOworfQorCitib29sIERhdGFiYXNlVGhyZWFkOjp0ZXJt aW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcXVldWUuaXNFbXB0eSgp OworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNlVGhy ZWFkPiopCit7CisgICAgaWYgKG1fcXVldWUuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisK KyAgICBSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOworICAgIHRh c2stPnBlcmZvcm1UYXNrKCk7CisgICAgbV9xdWV1ZS5yZW1vdmVGaXJzdCgpOworICAgIGlmICgh bV9xdWV1ZS5pc0VtcHR5KCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQor Cit2b2lkIERhdGFiYXNlVGhyZWFkOjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRh c2s+IHRhc2spCit7CisgICAgbV9xdWV1ZS5hcHBlbmQodGFzayk7CisgICAgaWYgKCFtX3RpbWVy LmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lk IERhdGFiYXNlVGhyZWFkOjpzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFz ZVRhc2s+IHRhc2spCit7CisgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKK30KKwordm9pZCBEYXRh YmFzZVRocmVhZDo6dW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqIGRhdGFiYXNlKQor eworICAgIERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gcmVzZXJ2ZWRUYXNrczsKKyAgICBm b3IgKERlcXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID46OmNvbnN0X2l0ZXJhdG9yIGkgPSBtX3F1 ZXVlLmJlZ2luKCk7IGkgIT0gbV9xdWV1ZS5lbmQoKTsgKytpKSB7CisgICAgICAgIGlmICgoKmkp LT5kYXRhYmFzZSgpICE9IGRhdGFiYXNlKQorICAgICAgICAgICAgcmVzZXJ2ZWRUYXNrcy5hcHBl bmQoKmkpOworICAgIH0KKworICAgIG1fcXVldWUuc3dhcChyZXNlcnZlZFRhc2tzKTsKK30KKwor dm9pZCBEYXRhYmFzZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKiBkYXRhYmFz ZSkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjpy ZWNvcmREYXRhYmFzZUNsb3NlZChEYXRhYmFzZSogZGF0YWJhc2UpCit7CisgICAgbm90SW1wbGVt ZW50ZWQoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxF KFNJTkdMRV9USFJFQURFRCkKKyNlbmRpZiAvLyBFTkFCTEUoRE9NX1NUT1JBR0UpCmRpZmYgLS1n aXQgYS9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5j cHAgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTJmMTFhMQotLS0gL2Rldi9u dWxsCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhy ZWFkLmNwcApAQCAtMCwwICsxLDkwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNo IE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVs LAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVT QS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhy ZWFkLmgiCisKKyNpZiBFTkFCTEUoRE9NX1NUT1JBR0UpCisjaWYgRU5BQkxFKFNJTkdMRV9USFJF QURFRCkKKworI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRhc2suaCIKKyNpbmNsdWRlICJTdG9yYWdl QXJlYVN5bmMuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzUmVmUHRyPExvY2FsU3Rv cmFnZVRocmVhZD4gTG9jYWxTdG9yYWdlVGhyZWFkOjpjcmVhdGUoKQoreworICAgIHJldHVybiBh ZG9wdFJlZihuZXcgTG9jYWxTdG9yYWdlVGhyZWFkKTsKK30KKworTG9jYWxTdG9yYWdlVGhyZWFk OjpMb2NhbFN0b3JhZ2VUaHJlYWQoKQorOiBtX3RpbWVyKHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJl YWQ6OnRpbWVyRmlyZWQpCit7Cit9CisKK2Jvb2wgTG9jYWxTdG9yYWdlVGhyZWFkOjpzdGFydCgp Cit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1l ckZpcmVkKFRpbWVyPExvY2FsU3RvcmFnZVRocmVhZD4qKQoreworICAgIGlmIChtX3F1ZXVlLmlz RW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgUmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+ IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7CisgICAgbV9xdWV1ZS5yZW1vdmVGaXJzdCgpOworICAg IHRhc2stPnBlcmZvcm1UYXNrKCk7CisgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAg ICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFk OjpzY2hlZHVsZUltcG9ydChQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4gYXJlYSkKK3sKKyAg ICBtX3F1ZXVlLmFwcGVuZChMb2NhbFN0b3JhZ2VUYXNrOjpjcmVhdGVJbXBvcnQoYXJlYSkpOwor ICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hv dCgwKTsKK30KKwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnNjaGVkdWxlU3luYyhQYXNzUmVm UHRyPFN0b3JhZ2VBcmVhU3luYz4gYXJlYSkKK3sKKyAgICBtX3F1ZXVlLmFwcGVuZChMb2NhbFN0 b3JhZ2VUYXNrOjpjcmVhdGVTeW5jKGFyZWEpKTsKKyAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUo KSkKKyAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9y YWdlVGhyZWFkOjp0ZXJtaW5hdGUoKQoreworICAgIG1fcXVldWUuY2xlYXIoKTsKKyAgICBtX3Rp bWVyLnN0b3AoKTsKK30KKwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnBlcmZvcm1UZXJtaW5h dGUoKQoreworICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHRlcm1pbmF0ZSgpOworfQor Cit9CisjZW5kaWYgLy8gRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyNlbmRpZiAvLyBFTkFCTEUo RE9NX1NUT1JBR0UpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVk L1N0b3JhZ2VBcmVhU3luYy5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL1N0 b3JhZ2VBcmVhU3luYy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjg4 MmNmNwotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQv U3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtMCwwICsxLDU2IEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDA4LCAyMDA5IEFwcGxlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqIENvcHlyaWdo dCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg VEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVO VCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAq IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuIAorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTdG9yYWdl QXJlYVN5bmMuaCIKKworI2lmIEVOQUJMRShET01fU1RPUkFHRSkKKyNpZiBFTkFCTEUoU0lOR0xF X1RIUkVBREVEKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3ZvaWQgU3RvcmFnZUFyZWFTeW5j OjpzY2hlZHVsZUltcG9ydCgpCit7CisgICAgLy8gRG8gYSBibG9ja2luZyBpbXBvcnQsIGJlY2F1 c2Ugd2UgY2Fubm90ICJibG9ja1VudGlsSW1wb3J0Q29tcGxldGUiIHdpdGggb25lIHRocmVhZC4K KyAgICBwZXJmb3JtSW1wb3J0KCk7Cit9CisKK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjpkaWRJbXBv cnQoKQoreworICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KKyAgICBtX3N0b3Jh Z2VBcmVhID0gMDsKK30KKwordm9pZCBTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50aWxJbXBvcnRD b21wbGV0ZSgpIGNvbnN0Cit7CisgICAgLy8gV2UgaGF2ZSBhbHJlYWR5IGltcG9ydGVkIGluIHNj aGVkdWxlSW1wb3J0KCkuCit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8v IEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9SQUdFKQor CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5j cHAgYi9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5jcHAKZGVsZXRl ZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ4MTE0NWQuLjAwMDAwMDAKLS0tIGEvV2ViQ29yZS9z dG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwCisrKyAvZGV2L251bGwKQEAgLTEs OTUgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICog YXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgot ICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwotICog IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0gKi8KLQotI2lu Y2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCi0KLSNpbmNsdWRl ICJEYXRhYmFzZS5oIgotI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgotCi1uYW1lc3BhY2UgV2Vi Q29yZSB7Ci0KLURhdGFiYXNlVGhyZWFkOjpEYXRhYmFzZVRocmVhZCgpCi06IG1fdGltZXIodGhp cywgJkRhdGFiYXNlVGhyZWFkOjp0aW1lckZpcmVkKQotewotfQotCi1EYXRhYmFzZVRocmVhZDo6 fkRhdGFiYXNlVGhyZWFkKCkKLXsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6cmVxdWVzdFRl cm1pbmF0aW9uKCkKLXsKLSAgICBtX3F1ZXVlLmNsZWFyKCk7Ci19Ci0KLWJvb2wgRGF0YWJhc2VU aHJlYWQ6OnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkgY29uc3QKLXsKLSAgICByZXR1cm4gbV9xdWV1 ZS5pc0VtcHR5KCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnRpbWVyRmlyZWQoVGltZXI8 RGF0YWJhc2VUaHJlYWQ+KikKLXsKLSAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKSB7Ci0gICAg ICAgIFJlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7Ci0gICAgICAg IHRhc2stPnBlcmZvcm1UYXNrKCk7Ci0gICAgICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsKLSAg ICAgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKLSAgICAgICAgICAgIG1fdGltZXIuc3RhcnRP bmVTaG90KDApOwotICAgIH0KLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1bGVUYXNr KFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrKQotewotICAgIG1fcXVldWUuYXBwZW5kKHRh c2spOwotICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQotICAgICAgICBtX3RpbWVyLnN0YXJ0 T25lU2hvdCgwKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1bGVJbW1lZGlhdGVU YXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrKQotewotICAgIHRhc2stPnBlcmZvcm1U YXNrKCk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tz KERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+ IHJlc2VydmVkVGFza3M7Ci0gICAgZm9yIChEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+Ojpj b25zdF9pdGVyYXRvciBpID0gbV9xdWV1ZS5iZWdpbigpOyBpICE9IG1fcXVldWUuZW5kKCk7ICsr aSkgewotICAgICAgICBpZiAoKCppKS0+ZGF0YWJhc2UoKSAhPSBkYXRhYmFzZSkKLSAgICAgICAg ICAgIHJlc2VydmVkVGFza3MuYXBwZW5kKCppKTsKLSAgICB9Ci0KLSAgICBtX3F1ZXVlLnN3YXAo cmVzZXJ2ZWRUYXNrcyk7Ci19Ci0KLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNl T3BlbihEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLX0KLQot dm9pZCBEYXRhYmFzZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqIGRhdGFi YXNlKQotewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNl LmggYi9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5oCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmYWZjNzkxLi4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3Rv cmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdpbmNlLmgKKysrIC9kZXYvbnVsbApAQCAtMSw2NSAr MCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUg bWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAg TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25nIHdpdGggdGhpcyBsaWJy YXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCi0gKiAgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0 aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KLSAqLwotCi0jaWZuZGVm IERhdGFiYXNlVGhyZWFkV2luY2VfaAotI2RlZmluZSBEYXRhYmFzZVRocmVhZFdpbmNlX2gKLQot I2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgotI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+Ci0KLW5h bWVzcGFjZSBXZWJDb3JlIHsKLQotICAgIGNsYXNzIERhdGFiYXNlOwotICAgIGNsYXNzIERhdGFi YXNlVGFzazsKLQotICAgIGNsYXNzIERhdGFiYXNlVGhyZWFkOiBwdWJsaWMgV1RGOjpSZWZDb3Vu dGVkPERhdGFiYXNlVGhyZWFkPiB7Ci0KLSAgICBwdWJsaWM6Ci0gICAgICAgIHN0YXRpYyBQYXNz UmVmUHRyPERhdGFiYXNlVGhyZWFkPiBjcmVhdGUoKSB7IHJldHVybiBhZG9wdFJlZihuZXcgRGF0 YWJhc2VUaHJlYWQpOyB9Ci0gICAgICAgIH5EYXRhYmFzZVRocmVhZCgpOwotCi0gICAgICAgIGJv b2wgc3RhcnQoKSB7IHJldHVybiB0cnVlOyB9Ci0gICAgICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0 aW9uKCk7Ci0gICAgICAgIGJvb2wgdGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsKLQotICAg ICAgICB2b2lkIHNjaGVkdWxlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOwotICAgICAg ICB2b2lkIHNjaGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOwot ICAgICAgICB2b2lkIHVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNlKik7Ci0gICAgICAg IHZvaWQgcmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7Ci0gICAgICAgIHZvaWQgcmVjb3Jk RGF0YWJhc2VDbG9zZWQoRGF0YWJhc2UqKTsKLSNpZm5kZWYgTkRFQlVHCi0gICAgICAgIFRocmVh ZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSBjb25zdCB7IHJldHVybiBjdXJyZW50VGhyZWFkKCk7 IH0KLSNlbmRpZgotCi0gICAgcHJpdmF0ZToKLSAgICAgICAgRGF0YWJhc2VUaHJlYWQoKTsKLQot ICAgICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+Kik7Ci0KLSAgICAg ICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOwotICAgICAgICBUaW1lcjxE YXRhYmFzZVRocmVhZD4gbV90aW1lcjsKLSAgICB9OwotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3Jl Ci0KLSNlbmRpZiAvLyBEYXRhYmFzZVRocmVhZFdpbmNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0 b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3BwIGIvV2ViQ29yZS9zdG9yYWdl L3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggOGRjYjkwMi4uMDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9j YWxTdG9yYWdlVGhyZWFkV2luY2UuY3BwCisrKyAvZGV2L251bGwKQEAgLTEsODMgKzAsMCBAQAot LyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQot ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V Ci0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0g KgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2Vl IHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwotICogIHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is Ci0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0gKi8KLQotI2luY2x1ZGUgImNvbmZp Zy5oIgotI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRocmVhZC5oIgotCi0jaW5jbHVkZSAiTG9jYWxT dG9yYWdlVGFzay5oIgotI2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5oIgotCi1uYW1lc3BhY2Ug V2ViQ29yZSB7Ci0KLUxvY2FsU3RvcmFnZVRocmVhZDo6TG9jYWxTdG9yYWdlVGhyZWFkKCkKLTog bV90aW1lcih0aGlzLCAmTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKQotewotfQotCi1M b2NhbFN0b3JhZ2VUaHJlYWQ6On5Mb2NhbFN0b3JhZ2VUaHJlYWQoKQotewotfQotCi1ib29sIExv Y2FsU3RvcmFnZVRocmVhZDo6c3RhcnQoKQotewotICAgIHJldHVybiB0cnVlOwotfQotCi12b2lk IExvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+ KikKLXsKLSAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKSB7Ci0gICAgICAgIFJlZlB0cjxMb2Nh bFN0b3JhZ2VUYXNrPiB0YXNrID0gbV9xdWV1ZS5maXJzdCgpOwotICAgICAgICB0YXNrLT5wZXJm b3JtVGFzaygpOwotICAgICAgICBtX3F1ZXVlLnJlbW92ZUZpcnN0KCk7Ci0gICAgICAgIGlmICgh bV9xdWV1ZS5pc0VtcHR5KCkpCi0gICAgICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsK LSAgICB9Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZUltcG9ydChQYXNz UmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4gYXJlYSkKLXsKLSAgICBtX3F1ZXVlLmFwcGVuZChMb2Nh bFN0b3JhZ2VUYXNrOjpjcmVhdGVJbXBvcnQoYXJlYSkpOwotICAgIGlmICghbV90aW1lci5pc0Fj dGl2ZSgpKQotICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9pZCBMb2Nh bFN0b3JhZ2VUaHJlYWQ6OnNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4g YXJlYSkKLXsKLSAgICBtX3F1ZXVlLmFwcGVuZChMb2NhbFN0b3JhZ2VUYXNrOjpjcmVhdGVTeW5j KGFyZWEpKTsKLSAgICBpZiAoIW1fdGltZXIuaXNBY3RpdmUoKSkKLSAgICAgICAgbV90aW1lci5z dGFydE9uZVNob3QoMCk7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0ZXJtaW5hdGUo KQotewotICAgIG1fcXVldWUuY2xlYXIoKTsKLSAgICBtX3RpbWVyLnN0b3AoKTsKLX0KLQotdm9p ZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnBlcmZvcm1UZXJtaW5hdGUoKQotewotICAgIG1fcXVldWUu Y2xlYXIoKTsKLSAgICBtX3RpbWVyLnN0b3AoKTsKLX0KLQotfQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9zdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRocmVhZFdpbmNlLmggYi9XZWJDb3JlL3N0b3Jh Z2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMzAwYWJiNS4uMDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9j YWxTdG9yYWdlVGhyZWFkV2luY2UuaAorKysgL2Rldi9udWxsCkBAIC0xLDU4ICswLDAgQEAKLS8q Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0 aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQot ICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoK LSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0 aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAot ICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgotICovCi0KLQotI2lmbmRlZiBMb2NhbFN0 b3JhZ2VUaHJlYWRXaW5jZV9oCi0jZGVmaW5lIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gKLQot I2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgotI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+Ci0KLW5h bWVzcGFjZSBXZWJDb3JlIHsKLQotICAgIGNsYXNzIFN0b3JhZ2VBcmVhU3luYzsKLSAgICBjbGFz cyBMb2NhbFN0b3JhZ2VUYXNrOwotCi0gICAgY2xhc3MgTG9jYWxTdG9yYWdlVGhyZWFkIDogcHVi bGljIFJlZkNvdW50ZWQ8TG9jYWxTdG9yYWdlVGhyZWFkPiB7Ci0gICAgcHVibGljOgotICAgICAg ICBzdGF0aWMgUGFzc1JlZlB0cjxMb2NhbFN0b3JhZ2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJu IGFkb3B0UmVmKG5ldyBMb2NhbFN0b3JhZ2VUaHJlYWQpOyB9Ci0KLSAgICAgICAgfkxvY2FsU3Rv cmFnZVRocmVhZCgpOwotICAgICAgICBib29sIHN0YXJ0KCk7Ci0gICAgICAgIHZvaWQgc2NoZWR1 bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+KTsKLSAgICAgICAgdm9pZCBzY2hl ZHVsZVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+KTsKLSAgICAgICAgdm9pZCB0ZXJt aW5hdGUoKTsKLSAgICAgICAgdm9pZCBwZXJmb3JtVGVybWluYXRlKCk7Ci0KLSAgICBwcml2YXRl OgotICAgICAgICBMb2NhbFN0b3JhZ2VUaHJlYWQoKTsKLQotICAgICAgICB2b2lkIHRpbWVyRmly ZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOwotCi0gICAgICAgIERlcXVlPFJlZlB0cjxM b2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7Ci0gICAgICAgIFRpbWVyPExvY2FsU3RvcmFnZVRo cmVhZD4gbV90aW1lcjsKLSAgICB9OwotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRp ZiAvLyBMb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZV9oCg== 38396 2009-08-21 14:21:48 -0700 2009-09-17 16:20:30 -0700 fixed 28019.patch text/plain 31794 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTJhNWRlYy4uZmFhMjEyYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAwOS0wOC0yMSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u OiB1c2UgVGltZXIgdG8gZG8gYXN5bmMKKyAgICAgICAgZGF0YWJhc2UgdGFza3MKKyAgICAgICAg VGhpcyBwYXRjaCBhbHNvIHJlcGxhY2VzIHN0b3JhZ2Uvd2luY2Ugd2l0aCBzdG9yYWdlL3Npbmds ZS10aHJlYWRlZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjgwMTkKKworICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaDoKKyAgICAgICAg KiBzdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oOgorICAgICAgICAqIHN0b3JhZ2UvU3RvcmFn ZUFyZWFTeW5jLmNwcDoKKyAgICAgICAgKiBzdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oOgorICAg ICAgICAqIHN0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcDogQWRkZWQu CisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNw cDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFT eW5jLmNwcDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdp bmNlLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFk V2luY2UuaDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3RvcmFnZVRo cmVhZFdpbmNlLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBzdG9yYWdlL3dpbmNlL0xvY2FsU3Rv cmFnZVRocmVhZFdpbmNlLmg6IFJlbW92ZWQuCisKIDIwMDktMDgtMTkgIEphbiBNaWNoYWVsIEFs b256byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWGFuIExv cGV6LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmggYi9XZWJD b3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAppbmRleCA1OWQ3YTVkLi5lNjNhNzE5IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQg KEMpIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJp Z2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoK ICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOSw2ICszMCw3IEBACiAjZGVmaW5lIERh dGFiYXNlVGhyZWFkX2gKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKKwogI2luY2x1ZGUgPHd0Zi9E ZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQu aD4KQEAgLTQwLDQ4ICs0Miw1OCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIERh dGFiYXNlOwotY2xhc3MgRGF0YWJhc2VUYXNrOwotY2xhc3MgRG9jdW1lbnQ7Ci1jbGFzcyBTUUxU cmFuc2FjdGlvbkNvb3JkaW5hdG9yOwotCi1jbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBU aHJlYWRTYWZlU2hhcmVkPERhdGFiYXNlVGhyZWFkPiB7Ci1wdWJsaWM6Ci0gICAgc3RhdGljIFBh c3NSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBE YXRhYmFzZVRocmVhZCk7IH0KLSAgICB+RGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIGJvb2wgc3Rh cnQoKTsKLSAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOwotICAgIGJvb2wgdGVybWluYXRp b25SZXF1ZXN0ZWQoKSBjb25zdDsKLQotICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2VUYXNrPik7Ci0gICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0 cjxEYXRhYmFzZVRhc2s+KTsgLy8gVGhpcyBqdXN0IGFkZHMgdGhlIHRhc2sgdG8gdGhlIGZyb250 IG9mIHRoZSBxdWV1ZSAtIHRoZSBjYWxsZXIgbmVlZHMgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwg bm90IHRvIGNyZWF0ZSBkZWFkbG9ja3Mgd2hlbiB3YWl0aW5nIGZvciBjb21wbGV0aW9uLgotICAg IHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqKTsKLQotICAgIHZvaWQgcmVj b3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7Ci0gICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3Nl ZChEYXRhYmFzZSopOwotICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQoKSB7IHJldHVy biBtX3RocmVhZElEOyB9Ci0KLSAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2Fj dGlvbkNvb3JkaW5hdG9yKCkgeyByZXR1cm4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmdldCgp OyB9Ci0KLXByaXZhdGU6Ci0gICAgRGF0YWJhc2VUaHJlYWQoKTsKLQotICAgIHN0YXRpYyB2b2lk KiBkYXRhYmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKLSAgICB2b2lkKiBkYXRhYmFzZVRocmVhZCgp OwotCi0gICAgTXV0ZXggbV90aHJlYWRDcmVhdGlvbk11dGV4OwotICAgIFRocmVhZElkZW50aWZp ZXIgbV90aHJlYWRJRDsKLSAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fc2VsZlJlZjsKLQot ICAgIE1lc3NhZ2VRdWV1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7Ci0KLSAgICAv LyBUaGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRhYmFzZXMgdGhhdCBoYXZlIGJl ZW4gdXNlZCBvbiB0aGlzIHRocmVhZC4KLSAgICB0eXBlZGVmIEhhc2hTZXQ8UmVmUHRyPERhdGFi YXNlPiA+IERhdGFiYXNlU2V0OwotICAgIERhdGFiYXNlU2V0IG1fb3BlbkRhdGFiYXNlU2V0Owot Ci0gICAgT3duUHRyPFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29y ZGluYXRvcjsKLX07CisgICAgY2xhc3MgRGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNr OworICAgIGNsYXNzIERvY3VtZW50OworICAgIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0 b3I7CisKKyAgICBjbGFzcyBEYXRhYmFzZVRocmVhZCA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVk PERhdGFiYXNlVGhyZWFkPiB7CisgICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0 cjxEYXRhYmFzZVRocmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IERhdGFiYXNl VGhyZWFkKTsgfQorICAgICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKKworICAgICAgICBib29sIHN0 YXJ0KCk7CisgICAgICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7CisgICAgICAgIGJvb2wg dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsKKworICAgICAgICB2b2lkIHNjaGVkdWxlVGFz ayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOworICAgICAgICB2b2lkIHNjaGVkdWxlSW1tZWRp YXRlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4pOyAvLyBUaGlzIGp1c3QgYWRkcyB0aGUg dGFzayB0byB0aGUgZnJvbnQgb2YgdGhlIHF1ZXVlIC0gdGhlIGNhbGxlciBuZWVkcyB0byBiZSBl eHRyZW1lbHkgY2FyZWZ1bCBub3QgdG8gY3JlYXRlIGRlYWRsb2NrcyB3aGVuIHdhaXRpbmcgZm9y IGNvbXBsZXRpb24uCisgICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJh c2UqKTsKKworICAgICAgICB2b2lkIHJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSopOworICAg ICAgICB2b2lkIHJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKik7CisjaWYgRU5BQkxFKFNJ TkdMRV9USFJFQURFRCkKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsg cmV0dXJuIGN1cnJlbnRUaHJlYWQoKTsgfQorI2Vsc2UKKyAgICAgICAgVGhyZWFkSWRlbnRpZmll ciBnZXRUaHJlYWRJRCgpIHsgcmV0dXJuIG1fdGhyZWFkSUQ7IH0KKyNlbmRpZgorCisgICAgICAg IFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSB7IHJl dHVybiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0KKworICAgIHByaXZhdGU6Cisg ICAgICAgIERhdGFiYXNlVGhyZWFkKCk7CisKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQor ICAgICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0YWJhc2VUaHJlYWQ+Kik7CisKKyAgICAg ICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOworICAgICAgICBUaW1lcjxE YXRhYmFzZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCisgICAgICAgIHN0YXRpYyB2b2lkKiBkYXRh YmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKKyAgICAgICAgdm9pZCogZGF0YWJhc2VUaHJlYWQoKTsK KworICAgICAgICBNdXRleCBtX3RocmVhZENyZWF0aW9uTXV0ZXg7CisgICAgICAgIFRocmVhZElk ZW50aWZpZXIgbV90aHJlYWRJRDsKKyAgICAgICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX3Nl bGZSZWY7CisKKyAgICAgICAgTWVzc2FnZVF1ZXVlPFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gbV9x dWV1ZTsKKworICAgICAgICAvLyBUaGlzIHNldCBrZWVwcyB0cmFjayBvZiB0aGUgb3BlbiBkYXRh YmFzZXMgdGhhdCBoYXZlIGJlZW4gdXNlZCBvbiB0aGlzIHRocmVhZC4KKyAgICAgICAgdHlwZWRl ZiBIYXNoU2V0PFJlZlB0cjxEYXRhYmFzZT4gPiBEYXRhYmFzZVNldDsKKyAgICAgICAgRGF0YWJh c2VTZXQgbV9vcGVuRGF0YWJhc2VTZXQ7CisjZW5kaWYKKyAgICAgICAgT3duUHRyPFNRTFRyYW5z YWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25Db29yZGluYXRvcjsKKyAgICB9OwogCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9Mb2Nh bFN0b3JhZ2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaApp bmRleCAzZDU4NDI3Li5iMDE5YTU2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxT dG9yYWdlVGhyZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5o CkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFs bCBSaWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJ bmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK QEAgLTI4LDYgKzI5LDcgQEAKIAogI2lmIEVOQUJMRShET01fU1RPUkFHRSkKIAorI2luY2x1ZGUg PHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL01l c3NhZ2VRdWV1ZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CkBAIC01Niw2ICs1OCwx MiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgTG9jYWxTdG9y YWdlVGhyZWFkKCk7CiAKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICB2b2lk IHRpbWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOworCisgICAgICAgIERlcXVl PFJlZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7CisgICAgICAgIFRpbWVyPExvY2Fs U3RvcmFnZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCiAgICAgICAgIHN0YXRpYyB2b2lkKiBsb2Nh bFN0b3JhZ2VUaHJlYWRTdGFydCh2b2lkKik7CiAgICAgICAgIHZvaWQqIGxvY2FsU3RvcmFnZVRo cmVhZCgpOwogCkBAIC02Nyw2ICs3NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAg CiAgICAgICAgIE11dGV4IG1fdGVybWluYXRlTG9jazsKICAgICAgICAgVGhyZWFkQ29uZGl0aW9u IG1fdGVybWluYXRlQ29uZGl0aW9uOworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAppbmRleCAwMWQyYTY1Li42ZjA5 MWI3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8q CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgogICoKICAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC01NSwxNSArNTYsMTEgQEAgU3RvcmFnZUFyZWFTeW5j OjpTdG9yYWdlQXJlYVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlU3luY01hbmFnZXI+IHN0b3JhZ2VT eW5jTWFuYWcKICAgICAsIG1fc3luY01hbmFnZXIoc3RvcmFnZVN5bmNNYW5hZ2VyKQogICAgICwg bV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nKGZhbHNlKQogICAgICwgbV9zeW5jU2NoZWR1bGVkKGZh bHNlKQotICAgICwgbV9pbXBvcnRDb21wbGV0ZShmYWxzZSkKIHsKICAgICBBU1NFUlQobV9zdG9y YWdlQXJlYSk7CiAgICAgQVNTRVJUKG1fc3luY01hbmFnZXIpOwogCi0gICAgLy8gRklYTUU6IElm IGl0IGNhbid0IGltcG9ydCwgdGhlbiB0aGUgZGVmYXVsdCBXZWJLaXQgYmVoYXZpb3Igc2hvdWxk IGJlIHRoYXQgb2YgcHJpdmF0ZSBicm93c2luZywKLSAgICAvLyBub3Qgc2lsZW50bHkgaWdub3Jp bmcgaXQuICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTQKLSAg ICBpZiAoIW1fc3luY01hbmFnZXItPnNjaGVkdWxlSW1wb3J0KHRoaXMpKQotICAgICAgICBtX2lt cG9ydENvbXBsZXRlID0gdHJ1ZTsKKyAgICBzY2hlZHVsZUltcG9ydCgpOwogfQogCiBTdG9yYWdl QXJlYVN5bmM6On5TdG9yYWdlQXJlYVN5bmMoKQpAQCAtMTYwLDcgKzE1Nyw3IEBAIHZvaWQgU3Rv cmFnZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZChUaW1lcjxTdG9yYWdlQXJlYVN5bmM+KikKIAog dm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQogewotICAgIEFTU0VSVCghaXNN YWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAgICAgQVNT RVJUKCFtX2RhdGFiYXNlLmlzT3BlbigpKTsKIAogICAgIFN0cmluZyBkYXRhYmFzZUZpbGVuYW1l ID0gbV9zeW5jTWFuYWdlci0+ZnVsbERhdGFiYXNlRmlsZW5hbWUobV9zdG9yYWdlQXJlYS0+c2Vj dXJpdHlPcmlnaW4oKSk7CkBAIC0yMTIsNDggKzIwOSwyMCBAQCB2b2lkIFN0b3JhZ2VBcmVhU3lu Yzo6cGVyZm9ybUltcG9ydCgpCiAgICAgZm9yICg7IGl0ICE9IGVuZDsgKytpdCkKICAgICAgICAg bV9zdG9yYWdlQXJlYS0+aW1wb3J0SXRlbShpdC0+Zmlyc3QsIGl0LT5zZWNvbmQpOwogICAgIAot ICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KLSAgICBtX3N0b3JhZ2VBcmVhID0g MDsKLSAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1ZTsKLSAgICBtX2ltcG9ydENvbmRpdGlvbi5z aWduYWwoKTsKKyAgICBtYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCk7CiB9CiAKIHZv aWQgU3RvcmFnZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWQoKQogewotICAgIEFTU0VSVCghaXNNYWlu VGhyZWFkKCkpOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1faW1wb3J0TG9jayk7Ci0gICAg Ly8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xlLgotICAgIG1fc3RvcmFnZUFyZWEgPSAwOwot ICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOwotICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25h bCgpOwotfQotCi0vLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFsbG93IHVzZSBv ZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0byBkbyBzbyku Ci0vLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29tcGxldGUgaXMg YnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQKLS8vIHRoZXJl IGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xlbmd0aCB3aWxs IG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgotLy8gb3B0aW1pemF0aW9uIChz aW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMgYXJlIGJlaW5n IGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55Ci0vLyBpdGVtIGN1cnJlbnRseSBpbiB0aGUgbWFw LiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhlIG1hcCwgYnV0 IHdlJ2xsIG5lZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3VsZCBub3Qgb3Zl cndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBraWxsIHRoZSBp bXBvcnQKLS8vIGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9ja1VudGlsSW1w b3J0Q29tcGxldGUoKSBjb25zdAotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Ci0KLSAg ICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KLSAgICBpZiAobV9pbXBvcnRDb21wbGV0 ZSkKLSAgICAgICAgcmV0dXJuOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAK ICAgICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKLSAgICB3aGlsZSAoIW1faW1w b3J0Q29tcGxldGUpCi0gICAgICAgIG1faW1wb3J0Q29uZGl0aW9uLndhaXQobV9pbXBvcnRMb2Nr KTsKLSAgICBBU1NFUlQobV9pbXBvcnRDb21wbGV0ZSk7Ci0gICAgQVNTRVJUKCFtX3N0b3JhZ2VB cmVhKTsKKyAgICBtYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCk7CiB9CiAKIHZvaWQg U3RvcmFnZUFyZWFTeW5jOjpzeW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1hcDxTdHJp bmcsIFN0cmluZz4mIGl0ZW1zKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAg IEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAKICAgICBpZiAoIW1fZGF0YWJhc2UuaXNP cGVuKCkpCiAgICAgICAgIHJldHVybjsKQEAgLTMwOSw3ICsyNzgsNyBAQCB2b2lkIFN0b3JhZ2VB cmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hNYXA8U3RyaW5nLCBTdHJp bmc+JiBpdGVtcwogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybVN5bmMoKQogewotICAg IEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQo KSk7CiAKICAgICBib29sIGNsZWFySXRlbXM7CiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4g aXRlbXM7CkBAIC0zMzIsNiArMzAxLDQ5IEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3Jt U3luYygpCiAgICAgZW5hYmxlU3VkZGVuVGVybWluYXRpb24oKTsKIH0KIAorI2lmICFFTkFCTEUo U0lOR0xFX1RIUkVBREVEKQorCisvLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFs bG93IHVzZSBvZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0 byBkbyBzbykuCisvLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29t cGxldGUgaXMgYnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQK Ky8vIHRoZXJlIGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xl bmd0aCB3aWxsIG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgorLy8gb3B0aW1p emF0aW9uIChzaW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMg YXJlIGJlaW5nIGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55CisvLyBpdGVtIGN1cnJlbnRseSBp biB0aGUgbWFwLiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhl IG1hcCwgYnV0IHdlJ2xsIG5lZWQgYSBsaXN0CisvLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3Vs ZCBub3Qgb3ZlcndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBr aWxsIHRoZSBpbXBvcnQKKy8vIGpvYiBmaXJzdC4KK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9j a1VudGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQo KSk7CisKKyAgICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KKyAgICBpZiAobV9pbXBv cnRDb21wbGV0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1f aW1wb3J0TG9jayk7CisgICAgd2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICBtX2lt cG9ydENvbmRpdGlvbi53YWl0KG1faW1wb3J0TG9jayk7CisgICAgQVNTRVJUKG1faW1wb3J0Q29t cGxldGUpOworICAgIEFTU0VSVCghbV9zdG9yYWdlQXJlYSk7Cit9CisKK3ZvaWQgU3RvcmFnZUFy ZWFTeW5jOjpzY2hlZHVsZUltcG9ydCgpCit7CisgICAgbV9pbXBvcnRDb21wbGV0ZSA9IGZhbHNl OworICAgIC8vIEZJWE1FOiBJZiBpdCBjYW4ndCBpbXBvcnQsIHRoZW4gdGhlIGRlZmF1bHQgV2Vi S2l0IGJlaGF2aW9yIHNob3VsZCBiZSB0aGF0IG9mIHByaXZhdGUgYnJvd3NpbmcsCisgICAgLy8g bm90IHNpbGVudGx5IGlnbm9yaW5nIGl0LiAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTI1ODk0CisgICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0 aGlzKSkKKyAgICAgICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7Cit9CisKK3ZvaWQgU3RvcmFn ZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCkKK3sKKyAgICAvLyBC cmVhayB0aGUgKHJlZiBjb3VudCkgY3ljbGUuCisgICAgbV9zdG9yYWdlQXJlYSA9IDA7CisgICAg bV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7CisgICAgbV9pbXBvcnRDb25kaXRpb24uc2lnbmFsKCk7 Cit9CisKKyNlbmRpZgorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFC TEUoRE9NX1NUT1JBR0UpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFT eW5jLmggYi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKaW5kZXggZTQzNmJlZi4u YzE2Nzg2NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCisr KyBiL1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaApAQCAtMSw1ICsxLDYgQEAKIC8q CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC03OCwxNSArNzks MzEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHN5bmNUaW1lckZpcmVkKFRp bWVyPFN0b3JhZ2VBcmVhU3luYz4qKTsKICAgICAgICAgdm9pZCBzeW5jKGJvb2wgY2xlYXJJdGVt cywgY29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4mIGl0ZW1zKTsKIAotICAgICAgICBNdXRl eCBtX3N5bmNMb2NrOwogICAgICAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiBtX2l0ZW1zUGVu ZGluZ1N5bmM7CiAgICAgICAgIGJvb2wgbV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nOwogICAgICAg ICBib29sIG1fc3luY1NjaGVkdWxlZDsKIAorICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KCk7 CisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVk V2l0aG91dExvY2tpbmdNdXRleCgpOworCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyAg ICAgICAgYm9vbCBpc0JhY2tncm91bmRUaHJlYWQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9Cisg ICAgICAgIC8vIEhhY2sgV1RGOjpNdXRleExvY2tlciBhbmQganVzdCBkbyBub3RoaW5nCisgICAg ICAgIGVudW0gRHVtbXlNdXRleCB7CisgICAgICAgICAgICBtX3N5bmNMb2NrLAorICAgICAgICAg ICAgbV9pbXBvcnRMb2NrLAorICAgICAgICB9OworICAgICAgICBzdHJ1Y3QgTXV0ZXhMb2NrZXIg eworICAgICAgICAgICAgTXV0ZXhMb2NrZXIoRHVtbXlNdXRleCkge30KKyAgICAgICAgfTsKKyNl bHNlCisgICAgICAgIE11dGV4IG1fc3luY0xvY2s7CisgICAgICAgIGJvb2wgbV9pbXBvcnRDb21w bGV0ZTsKICAgICAgICAgbXV0YWJsZSBNdXRleCBtX2ltcG9ydExvY2s7CiAgICAgICAgIG11dGFi bGUgVGhyZWFkQ29uZGl0aW9uIG1faW1wb3J0Q29uZGl0aW9uOwotICAgICAgICBtdXRhYmxlIGJv b2wgbV9pbXBvcnRDb21wbGV0ZTsKLSAgICAgICAgdm9pZCBtYXJrSW1wb3J0ZWQoKTsKKyAgICAg ICAgYm9vbCBpc0JhY2tncm91bmRUaHJlYWQoKSBjb25zdCB7IHJldHVybiAhaXNNYWluVGhyZWFk KCk7IH0KKyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdp dCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3BwIGIv V2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGNjYTdmOAotLS0gL2Rldi9udWxsCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3BwCkBAIC0w LDAgKzEsMTEwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg KiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKKworI2lmIEVO QUJMRShET01fU1RPUkFHRSkKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorCisjaW5jbHVk ZSAiRGF0YWJhc2UuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKKyNpbmNsdWRlICJTUUxU cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworRGF0YWJh c2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKKyAgICA6IG1fdGltZXIodGhpcywgJkRhdGFiYXNl VGhyZWFkOjp0aW1lckZpcmVkKQorICAgICwgbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yKG5ldyBT UUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkpCit7Cit9CisKK0RhdGFiYXNlVGhyZWFkOjp+RGF0 YWJhc2VUaHJlYWQoKQoreworfQorCitib29sIERhdGFiYXNlVGhyZWFkOjpzdGFydCgpCit7Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5h dGlvbigpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1fdHJhbnNhY3Rpb25Db29yZGlu YXRvci0+c2h1dGRvd24oKTsKK30KKworYm9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWluYXRpb25S ZXF1ZXN0ZWQoKSBjb25zdAoreworICAgIHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsKK30KKwor dm9pZCBEYXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKQor eworICAgIGlmIChtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgUmVm UHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3QoKTsKKyAgICB0YXNrLT5wZXJm b3JtVGFzaygpOworICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICBpZiAoIW1fcXVldWUu aXNFbXB0eSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBE YXRhYmFzZVRocmVhZDo6c2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNr KQoreworICAgIG1fcXVldWUuYXBwZW5kKHRhc2spOworICAgIGlmICghbV90aW1lci5pc0FjdGl2 ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBEYXRhYmFz ZVRocmVhZDo6c2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiB0 YXNrKQoreworICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJl YWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sKKyAgICBE ZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IHJlc2VydmVkVGFza3M7CisgICAgZm9yIChEZXF1 ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9xdWV1ZS5iZWdp bigpOyBpICE9IG1fcXVldWUuZW5kKCk7ICsraSkgeworICAgICAgICBpZiAoKCppKS0+ZGF0YWJh c2UoKSAhPSBkYXRhYmFzZSkKKyAgICAgICAgICAgIHJlc2VydmVkVGFza3MuYXBwZW5kKCppKTsK KyAgICB9CisKKyAgICBtX3F1ZXVlLnN3YXAocmVzZXJ2ZWRUYXNrcyk7Cit9CisKK3ZvaWQgRGF0 YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlT3BlbihEYXRhYmFzZSogZGF0YWJhc2UpCit7Cisg ICAgbm90SW1wbGVtZW50ZWQoKTsKK30KKwordm9pZCBEYXRhYmFzZVRocmVhZDo6cmVjb3JkRGF0 YWJhc2VDbG9zZWQoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7 Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShTSU5HTEVf VEhSRUFERUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9SQUdFKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3BwIGIvV2Vi Q29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3BwCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEyZjExYTEKLS0tIC9kZXYvbnVsbAorKysg Yi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2FsU3RvcmFnZVRocmVhZC5jcHAK QEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUs IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKKyAqICBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkg b2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqICBhbG9uZyB3aXRo IHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0 bworICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0 cmVldCwgRmlmdGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkxvY2FsU3RvcmFnZVRocmVhZC5oIgor CisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisK KyNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCisjaW5jbHVkZSAiU3RvcmFnZUFyZWFTeW5j LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUGFzc1JlZlB0cjxMb2NhbFN0b3JhZ2VUaHJl YWQ+IExvY2FsU3RvcmFnZVRocmVhZDo6Y3JlYXRlKCkKK3sKKyAgICByZXR1cm4gYWRvcHRSZWYo bmV3IExvY2FsU3RvcmFnZVRocmVhZCk7Cit9CisKK0xvY2FsU3RvcmFnZVRocmVhZDo6TG9jYWxT dG9yYWdlVGhyZWFkKCkKKzogbV90aW1lcih0aGlzLCAmTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1l ckZpcmVkKQoreworfQorCitib29sIExvY2FsU3RvcmFnZVRocmVhZDo6c3RhcnQoKQoreworICAg IHJldHVybiB0cnVlOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJGaXJlZChU aW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+KikKK3sKKyAgICBpZiAobV9xdWV1ZS5pc0VtcHR5KCkp CisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiB0YXNrID0g bV9xdWV1ZS5maXJzdCgpOworICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICB0YXNrLT5w ZXJmb3JtVGFzaygpOworICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpCisgICAgICAgIG1fdGlt ZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1 bGVJbXBvcnQoUGFzc1JlZlB0cjxTdG9yYWdlQXJlYVN5bmM+IGFyZWEpCit7CisgICAgbV9xdWV1 ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFzazo6Y3JlYXRlSW1wb3J0KGFyZWEpKTsKKyAgICBpZiAo IW1fdGltZXIuaXNBY3RpdmUoKSkKKyAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9 CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpzY2hlZHVsZVN5bmMoUGFzc1JlZlB0cjxTdG9y YWdlQXJlYVN5bmM+IGFyZWEpCit7CisgICAgbV9xdWV1ZS5hcHBlbmQoTG9jYWxTdG9yYWdlVGFz azo6Y3JlYXRlU3luYyhhcmVhKSk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisgICAg ICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVh ZDo6dGVybWluYXRlKCkKK3sKKyAgICBtX3F1ZXVlLmNsZWFyKCk7CisgICAgbV90aW1lci5zdG9w KCk7Cit9CisKK3ZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjpwZXJmb3JtVGVybWluYXRlKCkKK3sK KyAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB0ZXJtaW5hdGUoKTsKK30KKworfQorI2Vu ZGlmIC8vIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisjZW5kaWYgLy8gRU5BQkxFKERPTV9TVE9S QUdFKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdl QXJlYVN5bmMuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJl YVN5bmMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ1NDFjNGEKLS0t IC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL1N0b3JhZ2VB cmVhU3luYy5jcHAKQEAgLTAsMCArMSw1NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOCwg MjAwOSBBcHBsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIw MDkgVG9yY2ggTW9iaWxlLCBJbmMuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICog SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LiAKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiU3RvcmFnZUFyZWFTeW5j LmgiCisKKyNpZiBFTkFCTEUoRE9NX1NUT1JBR0UpCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURF RCkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c2NoZWR1 bGVJbXBvcnQoKQoreworICAgIC8vIERvIGEgYmxvY2tpbmcgaW1wb3J0LCBiZWNhdXNlIHdlIGNh bm5vdCAiYmxvY2tVbnRpbEltcG9ydENvbXBsZXRlIiB3aXRoIG9uZSB0aHJlYWQuCisgICAgcGVy Zm9ybUltcG9ydCgpOworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6bWFya0ltcG9ydGVkV2l0 aG91dExvY2tpbmdNdXRleCgpCit7CisgICAgLy8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xl LgorICAgIG1fc3RvcmFnZUFyZWEgPSAwOworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6Ymxv Y2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3QKK3sKKyAgICAvLyBXZSBoYXZlIGFscmVhZHkg aW1wb3J0ZWQgaW4gc2NoZWR1bGVJbXBvcnQoKS4KK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQorCisjZW5kaWYgLy8gRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyNlbmRpZiAvLyBFTkFCTEUo RE9NX1NUT1JBR0UpCisKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFz ZVRocmVhZFdpbmNlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdp bmNlLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDgxMTQ1ZC4uMDAwMDAwMAot LS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5jcHAKKysrIC9k ZXYvbnVsbApAQCAtMSw5NSArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNo IE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVs LAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVT QS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQu aCIKLQotI2luY2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VUYXNrLmgiCi0K LW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkK LTogbV90aW1lcih0aGlzLCAmRGF0YWJhc2VUaHJlYWQ6OnRpbWVyRmlyZWQpCi17Ci19Ci0KLURh dGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQoKQotewotfQotCi12b2lkIERhdGFiYXNlVGhy ZWFkOjpyZXF1ZXN0VGVybWluYXRpb24oKQotewotICAgIG1fcXVldWUuY2xlYXIoKTsKLX0KLQot Ym9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdAotewotICAg IHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6dGlt ZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKQotewotICAgIGlmICghbV9xdWV1ZS5pc0Vt cHR5KCkpIHsKLSAgICAgICAgUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1fcXVldWUuZmly c3QoKTsKLSAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLSAgICAgICAgbV9xdWV1ZS5yZW1v dmVGaXJzdCgpOwotICAgICAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQotICAgICAgICAgICAg bV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci0gICAgfQotfQotCi12b2lkIERhdGFiYXNlVGhyZWFk OjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCi17Ci0gICAgbV9x dWV1ZS5hcHBlbmQodGFzayk7Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAg IG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpzY2hl ZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCi17Ci0gICAg dGFzay0+cGVyZm9ybVRhc2soKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6dW5zY2hlZHVs ZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIERlcXVlPFJlZlB0cjxE YXRhYmFzZVRhc2s+ID4gcmVzZXJ2ZWRUYXNrczsKLSAgICBmb3IgKERlcXVlPFJlZlB0cjxEYXRh YmFzZVRhc2s+ID46OmNvbnN0X2l0ZXJhdG9yIGkgPSBtX3F1ZXVlLmJlZ2luKCk7IGkgIT0gbV9x dWV1ZS5lbmQoKTsgKytpKSB7Ci0gICAgICAgIGlmICgoKmkpLT5kYXRhYmFzZSgpICE9IGRhdGFi YXNlKQotICAgICAgICAgICAgcmVzZXJ2ZWRUYXNrcy5hcHBlbmQoKmkpOwotICAgIH0KLQotICAg IG1fcXVldWUuc3dhcChyZXNlcnZlZFRhc2tzKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6 cmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBub3RJbXBsZW1l bnRlZCgpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZUNsb3NlZChE YXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLX0KLQotfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFi YXNlVGhyZWFkV2luY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdp bmNlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhZmM3OTEuLjAwMDAwMDAKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaAorKysgL2Rldi9u dWxsCkBAIC0xLDY1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9i aWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0g KiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xp biBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgot ICovCi0KLSNpZm5kZWYgRGF0YWJhc2VUaHJlYWRXaW5jZV9oCi0jZGVmaW5lIERhdGFiYXNlVGhy ZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgRGF0YWJhc2U7Ci0g ICAgY2xhc3MgRGF0YWJhc2VUYXNrOwotCi0gICAgY2xhc3MgRGF0YWJhc2VUaHJlYWQ6IHB1Ymxp YyBXVEY6OlJlZkNvdW50ZWQ8RGF0YWJhc2VUaHJlYWQ+IHsKLQotICAgIHB1YmxpYzoKLSAgICAg ICAgc3RhdGljIFBhc3NSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJuIGFk b3B0UmVmKG5ldyBEYXRhYmFzZVRocmVhZCk7IH0KLSAgICAgICAgfkRhdGFiYXNlVGhyZWFkKCk7 Ci0KLSAgICAgICAgYm9vbCBzdGFydCgpIHsgcmV0dXJuIHRydWU7IH0KLSAgICAgICAgdm9pZCBy ZXF1ZXN0VGVybWluYXRpb24oKTsKLSAgICAgICAgYm9vbCB0ZXJtaW5hdGlvblJlcXVlc3RlZCgp IGNvbnN0OwotCi0gICAgICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VU YXNrPik7Ci0gICAgICAgIHZvaWQgc2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0 YWJhc2VUYXNrPik7Ci0gICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJh c2UqKTsKLSAgICAgICAgdm9pZCByZWNvcmREYXRhYmFzZU9wZW4oRGF0YWJhc2UqKTsKLSAgICAg ICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChEYXRhYmFzZSopOwotI2lmbmRlZiBOREVCVUcK LSAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIGNvbnN0IHsgcmV0dXJuIGN1 cnJlbnRUaHJlYWQoKTsgfQotI2VuZGlmCi0KLSAgICBwcml2YXRlOgotICAgICAgICBEYXRhYmFz ZVRocmVhZCgpOwotCi0gICAgICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVh ZD4qKTsKLQotICAgICAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7Ci0g ICAgICAgIFRpbWVyPERhdGFiYXNlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0KLX0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIERhdGFiYXNlVGhyZWFkV2luY2UKZGlmZiAtLWdp dCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3BwCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZGNiOTAyLi4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3Rv cmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAKKysrIC9kZXYvbnVsbApAQCAt MSw4MyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0g KiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m Ci0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCi0g KiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KLSAqLwotCi0j aW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhyZWFkLmgiCi0KLSNp bmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCi0jaW5jbHVkZSAiU3RvcmFnZUFyZWFTeW5jLmgi Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotTG9jYWxTdG9yYWdlVGhyZWFkOjpMb2NhbFN0b3Jh Z2VUaHJlYWQoKQotOiBtX3RpbWVyKHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVyRmly ZWQpCi17Ci19Ci0KLUxvY2FsU3RvcmFnZVRocmVhZDo6fkxvY2FsU3RvcmFnZVRocmVhZCgpCi17 Ci19Ci0KLWJvb2wgTG9jYWxTdG9yYWdlVGhyZWFkOjpzdGFydCgpCi17Ci0gICAgcmV0dXJuIHRy dWU7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPExvY2Fs U3RvcmFnZVRocmVhZD4qKQotewotICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpIHsKLSAgICAg ICAgUmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7Ci0gICAg ICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Ci0gICAgICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsK LSAgICAgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKLSAgICAgICAgICAgIG1fdGltZXIuc3Rh cnRPbmVTaG90KDApOwotICAgIH0KLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnNjaGVk dWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQotewotICAgIG1fcXVl dWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0ZUltcG9ydChhcmVhKSk7Ci0gICAgaWYg KCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwot fQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1bGVTeW5jKFBhc3NSZWZQdHI8U3Rv cmFnZUFyZWFTeW5jPiBhcmVhKQotewotICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRh c2s6OmNyZWF0ZVN5bmMoYXJlYSkpOwotICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQotICAg ICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJl YWQ6OnRlcm1pbmF0ZSgpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1fdGltZXIuc3Rv cCgpOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6cGVyZm9ybVRlcm1pbmF0ZSgpCi17 Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1fdGltZXIuc3RvcCgpOwotfQotCi19CmRpZmYg LS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuaCBi L1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMDBhYmI1Li4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3Rv cmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oCisrKyAvZGV2L251bGwKQEAgLTEs NTggKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICog YXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgot ICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwotICog IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0gKi8KLQotCi0j aWZuZGVmIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gKLSNkZWZpbmUgTG9jYWxTdG9yYWdlVGhy ZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8d3RmL1Bhc3NS ZWZQdHIuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgU3RvcmFnZUFyZWFT eW5jOwotICAgIGNsYXNzIExvY2FsU3RvcmFnZVRhc2s7Ci0KLSAgICBjbGFzcyBMb2NhbFN0b3Jh Z2VUaHJlYWQgOiBwdWJsaWMgUmVmQ291bnRlZDxMb2NhbFN0b3JhZ2VUaHJlYWQ+IHsKLSAgICBw dWJsaWM6Ci0gICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsU3RvcmFnZVRocmVhZD4gY3Jl YXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsU3RvcmFnZVRocmVhZCk7IH0KLQotICAg ICAgICB+TG9jYWxTdG9yYWdlVGhyZWFkKCk7Ci0gICAgICAgIGJvb2wgc3RhcnQoKTsKLSAgICAg ICAgdm9pZCBzY2hlZHVsZUltcG9ydChQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4pOwotICAg ICAgICB2b2lkIHNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4pOwotICAg ICAgICB2b2lkIHRlcm1pbmF0ZSgpOwotICAgICAgICB2b2lkIHBlcmZvcm1UZXJtaW5hdGUoKTsK LQotICAgIHByaXZhdGU6Ci0gICAgICAgIExvY2FsU3RvcmFnZVRocmVhZCgpOwotCi0gICAgICAg IHZvaWQgdGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+Kik7Ci0KLSAgICAgICAg RGVxdWU8UmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+ID4gbV9xdWV1ZTsKLSAgICAgICAgVGltZXI8 TG9jYWxTdG9yYWdlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0KLX0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKLQotI2VuZGlmIC8vIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gK 39734 2009-09-17 16:20:10 -0700 2009-10-05 15:26:50 -0700 fix scheduleImmediateTask() problem 28019.patch text/plain 33741 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NDE0NTE5NC4uOGJmYjgxZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOSBAQAorMjAwOS0wOS0xNyAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u OiB1c2UgVGltZXIgdG8gZG8gYXN5bmMKKyAgICAgICAgZGF0YWJhc2UgdGFza3MKKyAgICAgICAg VGhpcyBwYXRjaCBhbHNvIHJlcGxhY2VzIHN0b3JhZ2Uvd2luY2Ugd2l0aCBzdG9yYWdlL3Npbmds ZS10aHJlYWRlZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjgwMTkKKworICAgICAgICBObyBuZXcgdGVzdHMuIChPT1BTISkKKworICAgICAgICAqIHN0 b3JhZ2UvRGF0YWJhc2UuY3BwOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUYXNrLmg6Cisg ICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHA6CisgICAgICAgICogc3RvcmFnZS9E YXRhYmFzZVRocmVhZC5oOgorICAgICAgICAqIHN0b3JhZ2UvTG9jYWxTdG9yYWdlVGhyZWFkLmg6 CisgICAgICAgICogc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3BwOgorICAgICAgICAqIHN0b3Jh Z2UvU3RvcmFnZUFyZWFTeW5jLmg6CisgICAgICAgICogc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQv RGF0YWJhc2VUaHJlYWQuY3BwOiBBZGRlZC4KKyAgICAgICAgKiBzdG9yYWdlL3NpbmdsZS10aHJl YWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3BwOiBBZGRlZC4KKyAgICAgICAgKiBzdG9yYWdlL3Np bmdsZS10aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMuY3BwOiBBZGRlZC4KKyAgICAgICAgKiBzdG9y YWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuY3BwOiBSZW1vdmVkLgorICAgICAgICAqIHN0 b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5oOiBSZW1vdmVkLgorICAgICAgICAqIHN0 b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3BwOiBSZW1vdmVkLgorICAgICAg ICAqIHN0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuaDogUmVtb3ZlZC4KKwog MjAwOS0wOC0yMSAgQmV0aCBEYWtpbiAgPGJkYWtpbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9EYXRh YmFzZS5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3BwCmluZGV4IGMzMjY5OTcuLjM4 ODdlZjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAKKysrIGIvV2Vi Q29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcApAQCAtMjA0LDkgKzIwNCw3IEBAIGJvb2wgRGF0YWJh c2U6Om9wZW5BbmRWZXJpZnlWZXJzaW9uKEV4Y2VwdGlvbkNvZGUmIGUpCiAKICAgICBSZWZQdHI8 RGF0YWJhc2VPcGVuVGFzaz4gdGFzayA9IERhdGFiYXNlT3BlblRhc2s6OmNyZWF0ZSh0aGlzKTsK IAotICAgIHRhc2stPmxvY2tGb3JTeW5jaHJvbm91c1NjaGVkdWxpbmcoKTsKLSAgICBtX2RvY3Vt ZW50LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzayk7Ci0gICAg dGFzay0+d2FpdEZvclN5bmNocm9ub3VzQ29tcGxldGlvbigpOworICAgIG1fZG9jdW1lbnQtPmRh dGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLCB0cnVlKTsKIAogICAg IEFTU0VSVCh0YXNrLT5pc0NvbXBsZXRlKCkpOwogICAgIGUgPSB0YXNrLT5leGNlcHRpb25Db2Rl KCk7CkBAIC0zMTUsOSArMzEzLDcgQEAgdm9pZCBEYXRhYmFzZTo6bWFya0FzRGVsZXRlZEFuZENs b3NlKCkKIAogICAgIFJlZlB0cjxEYXRhYmFzZUNsb3NlVGFzaz4gdGFzayA9IERhdGFiYXNlQ2xv c2VUYXNrOjpjcmVhdGUodGhpcyk7CiAKLSAgICB0YXNrLT5sb2NrRm9yU3luY2hyb25vdXNTY2hl ZHVsaW5nKCk7Ci0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1l ZGlhdGVUYXNrKHRhc2spOwotICAgIHRhc2stPndhaXRGb3JTeW5jaHJvbm91c0NvbXBsZXRpb24o KTsKKyAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRh c2sodGFzaywgdHJ1ZSk7CiB9CiAKIHZvaWQgRGF0YWJhc2U6OmNsb3NlKCkKQEAgLTU1MCw3ICs1 NDYsNyBAQCB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uU3RlcChTUUxUcmFuc2Fj dGlvbiogdHJhbnNhY3Rpb24sIGJvb2wgaW1tZWRpYQogICAgIFJlZlB0cjxEYXRhYmFzZVRyYW5z YWN0aW9uVGFzaz4gdGFzayA9IERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrOjpjcmVhdGUodHJhbnNh Y3Rpb24pOwogICAgIExPRyhTdG9yYWdlQVBJLCAiU2NoZWR1bGluZyBEYXRhYmFzZVRyYW5zYWN0 aW9uVGFzayAlcCBmb3IgdGhlIHRyYW5zYWN0aW9uIHN0ZXBcbiIsIHRhc2suZ2V0KCkpOwogICAg IGlmIChpbW1lZGlhdGVseSkKLSAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+ c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAgICAgbV9kb2N1bWVu dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgp LCBmYWxzZSk7CiAgICAgZWxzZQogICAgICAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgp LT5zY2hlZHVsZVRhc2sodGFzay5yZWxlYXNlKCkpOwogfQpAQCAtNjIxLDkgKzYxNyw3IEBAIFZl Y3RvcjxTdHJpbmc+IERhdGFiYXNlOjp0YWJsZU5hbWVzKCkKICAgICAgICAgcmV0dXJuIFZlY3Rv cjxTdHJpbmc+KCk7CiAgICAgUmVmUHRyPERhdGFiYXNlVGFibGVOYW1lc1Rhc2s+IHRhc2sgPSBE YXRhYmFzZVRhYmxlTmFtZXNUYXNrOjpjcmVhdGUodGhpcyk7CiAKLSAgICB0YXNrLT5sb2NrRm9y U3luY2hyb25vdXNTY2hlZHVsaW5nKCk7Ci0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQo KS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2spOwotICAgIHRhc2stPndhaXRGb3JTeW5jaHJv bm91c0NvbXBsZXRpb24oKTsKKyAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hl ZHVsZUltbWVkaWF0ZVRhc2sodGFzaywgdHJ1ZSk7CiAKICAgICByZXR1cm4gdGFzay0+dGFibGVO YW1lcygpOwogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5oIGIv V2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5oCmluZGV4IDRhZWY4OTIuLjMwYTJjM2QgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRhc2suaAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvRGF0YWJhc2VUYXNrLmgKQEAgLTU1LDYgKzU1LDkgQEAgcHVibGljOgogICAgIERhdGFi YXNlKiBkYXRhYmFzZSgpIGNvbnN0IHsgcmV0dXJuIG1fZGF0YWJhc2U7IH0KICAgICBib29sIGlz Q29tcGxldGUoKSBjb25zdCB7IHJldHVybiBtX2NvbXBsZXRlOyB9CiAKKyAgICB2b2lkIGxvY2tG b3JTeW5jaHJvbm91c1NjaGVkdWxpbmcoKTsKKyAgICB2b2lkIHdhaXRGb3JTeW5jaHJvbm91c0Nv bXBsZXRpb24oKTsKKwogcHJvdGVjdGVkOgogICAgIERhdGFiYXNlVGFzayhEYXRhYmFzZSopOwog CkBAIC02NCw5ICs2Nyw2IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBjb25zdCBjaGFyKiBkZWJ1 Z1Rhc2tOYW1lKCkgY29uc3QgPSAwOwogI2VuZGlmCiAKLSAgICB2b2lkIGxvY2tGb3JTeW5jaHJv bm91c1NjaGVkdWxpbmcoKTsKLSAgICB2b2lkIHdhaXRGb3JTeW5jaHJvbm91c0NvbXBsZXRpb24o KTsKLQogICAgIERhdGFiYXNlKiBtX2RhdGFiYXNlOwogCiAgICAgYm9vbCBtX2NvbXBsZXRlOwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNwcCBiL1dlYkNvcmUv c3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHAKaW5kZXggOTNkNDY2Ny4uZWVhMmQ5YiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNwcAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvRGF0YWJhc2VUaHJlYWQuY3BwCkBAIC0xNDcsOSArMTQ3LDE0IEBAIHZvaWQgRGF0YWJh c2VUaHJlYWQ6OnNjaGVkdWxlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKICAg ICBtX3F1ZXVlLmFwcGVuZCh0YXNrKTsKIH0KIAotdm9pZCBEYXRhYmFzZVRocmVhZDo6c2NoZWR1 bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiB0YXNrKQordm9pZCBEYXRh YmFzZVRocmVhZDo6c2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNr PiB0YXNrLCBib29sIHdhaXRVbnRpbEZpbmlzaCkKIHsKKyAgICBSZWZQdHI8PERhdGFiYXNlVGFz az4gdGFzazsKKyAgICBpZiAod2FpdFVudGlsRmluaXNoKQorICAgICAgICB0YXNrLT5sb2NrRm9y U3luY2hyb25vdXNTY2hlZHVsaW5nKCk7CiAgICAgbV9xdWV1ZS5wcmVwZW5kKHRhc2spOworICAg IGlmICh3YWl0VW50aWxGaW5pc2gpCisgICAgICAgIHRhc2stPndhaXRGb3JTeW5jaHJvbm91c0Nv bXBsZXRpb24oKTsKIH0KIAogdm9pZCBEYXRhYmFzZVRocmVhZDo6dW5zY2hlZHVsZURhdGFiYXNl VGFza3MoRGF0YWJhc2UqIGRhdGFiYXNlKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0Rh dGFiYXNlVGhyZWFkLmggYi9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAppbmRleCA4 M2IxYmFmLi4zMTNlMTI3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJl YWQuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaApAQCAtMSw1ICsxLDYg QEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yOSw2 ICszMCw3IEBACiAjZGVmaW5lIERhdGFiYXNlVGhyZWFkX2gKIAogI2lmIEVOQUJMRShEQVRBQkFT RSkKKwogI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAj aW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KQEAgLTYxLDcgKzYzLDExIEBAIHB1YmxpYzoKIAogICAg IHZvaWQgcmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7CiAgICAgdm9pZCByZWNvcmREYXRh YmFzZUNsb3NlZChEYXRhYmFzZSopOwotICAgIFRocmVhZElkZW50aWZpZXIgZ2V0VGhyZWFkSUQo KSB7IHJldHVybiBtX3RocmVhZElEOyB9CisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyAg ICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsgcmV0dXJuIGN1cnJlbnRUaHJl YWQoKTsgfQorI2Vsc2UKKyAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsg cmV0dXJuIG1fdGhyZWFkSUQ7IH0KKyNlbmRpZgogCiAgICAgU1FMVHJhbnNhY3Rpb25DbGllbnQq IHRyYW5zYWN0aW9uQ2xpZW50KCkgeyByZXR1cm4gbV90cmFuc2FjdGlvbkNsaWVudC5nZXQoKTsg fQogICAgIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3Io KSB7IHJldHVybiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0KQEAgLTY5LDYgKzc1 LDE2IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgRGF0YWJhc2VUaHJlYWQoKTsKIAorI2lmIEVO QUJMRShTSU5HTEVfVEhSRUFERUQpCisgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPERhdGFiYXNl VGhyZWFkPiopOworCisgICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiBtX3F1ZXVlOwor ICAgIFRpbWVyPERhdGFiYXNlVGhyZWFkPiBtX3RpbWVyOworI2lmbmRlZiBOREVCVUcKKyAgICBi b29sIG1faXNQZXJmb3JtaW5nVGFzazsKKyNlbmRpZgorCisjZWxzZQogICAgIHN0YXRpYyB2b2lk KiBkYXRhYmFzZVRocmVhZFN0YXJ0KHZvaWQqKTsKICAgICB2b2lkKiBkYXRhYmFzZVRocmVhZCgp OwogCkBAIC04NCw2ICsxMDAsNyBAQCBwcml2YXRlOgogCiAgICAgT3duUHRyPFNRTFRyYW5zYWN0 aW9uQ2xpZW50PiBtX3RyYW5zYWN0aW9uQ2xpZW50OwogICAgIE93blB0cjxTUUxUcmFuc2FjdGlv bkNvb3JkaW5hdG9yPiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3I7CisjZW5kaWYKIH07CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0 b3JhZ2VUaHJlYWQuaCBiL1dlYkNvcmUvc3RvcmFnZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaAppbmRl eCAzZDU4NDI3Li5iMDE5YTU2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9y YWdlVGhyZWFkLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oCkBA IC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFsbCBS aWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMu IEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAg LTI4LDYgKzI5LDcgQEAKIAogI2lmIEVOQUJMRShET01fU1RPUkFHRSkKIAorI2luY2x1ZGUgPHd0 Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL01lc3Nh Z2VRdWV1ZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CkBAIC01Niw2ICs1OCwxMiBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgcHJpdmF0ZToKICAgICAgICAgTG9jYWxTdG9yYWdl VGhyZWFkKCk7CiAKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorICAgICAgICB2b2lkIHRp bWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopOworCisgICAgICAgIERlcXVlPFJl ZlB0cjxMb2NhbFN0b3JhZ2VUYXNrPiA+IG1fcXVldWU7CisgICAgICAgIFRpbWVyPExvY2FsU3Rv cmFnZVRocmVhZD4gbV90aW1lcjsKKyNlbHNlCiAgICAgICAgIHN0YXRpYyB2b2lkKiBsb2NhbFN0 b3JhZ2VUaHJlYWRTdGFydCh2b2lkKik7CiAgICAgICAgIHZvaWQqIGxvY2FsU3RvcmFnZVRocmVh ZCgpOwogCkBAIC02Nyw2ICs3NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAg ICAgICAgIE11dGV4IG1fdGVybWluYXRlTG9jazsKICAgICAgICAgVGhyZWFkQ29uZGl0aW9uIG1f dGVybWluYXRlQ29uZGl0aW9uOworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAppbmRleCAwMWQyYTY1Li42ZjA5MWI3 IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAg KiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVk LgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgogICoKICAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCkBAIC01NSwxNSArNTYsMTEgQEAgU3RvcmFnZUFyZWFTeW5jOjpT dG9yYWdlQXJlYVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlU3luY01hbmFnZXI+IHN0b3JhZ2VTeW5j TWFuYWcKICAgICAsIG1fc3luY01hbmFnZXIoc3RvcmFnZVN5bmNNYW5hZ2VyKQogICAgICwgbV9j bGVhckl0ZW1zV2hpbGVTeW5jaW5nKGZhbHNlKQogICAgICwgbV9zeW5jU2NoZWR1bGVkKGZhbHNl KQotICAgICwgbV9pbXBvcnRDb21wbGV0ZShmYWxzZSkKIHsKICAgICBBU1NFUlQobV9zdG9yYWdl QXJlYSk7CiAgICAgQVNTRVJUKG1fc3luY01hbmFnZXIpOwogCi0gICAgLy8gRklYTUU6IElmIGl0 IGNhbid0IGltcG9ydCwgdGhlbiB0aGUgZGVmYXVsdCBXZWJLaXQgYmVoYXZpb3Igc2hvdWxkIGJl IHRoYXQgb2YgcHJpdmF0ZSBicm93c2luZywKLSAgICAvLyBub3Qgc2lsZW50bHkgaWdub3Jpbmcg aXQuICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTQKLSAgICBp ZiAoIW1fc3luY01hbmFnZXItPnNjaGVkdWxlSW1wb3J0KHRoaXMpKQotICAgICAgICBtX2ltcG9y dENvbXBsZXRlID0gdHJ1ZTsKKyAgICBzY2hlZHVsZUltcG9ydCgpOwogfQogCiBTdG9yYWdlQXJl YVN5bmM6On5TdG9yYWdlQXJlYVN5bmMoKQpAQCAtMTYwLDcgKzE1Nyw3IEBAIHZvaWQgU3RvcmFn ZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZChUaW1lcjxTdG9yYWdlQXJlYVN5bmM+KikKIAogdm9p ZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1JbXBvcnQoKQogewotICAgIEFTU0VSVCghaXNNYWlu VGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAgICAgQVNTRVJU KCFtX2RhdGFiYXNlLmlzT3BlbigpKTsKIAogICAgIFN0cmluZyBkYXRhYmFzZUZpbGVuYW1lID0g bV9zeW5jTWFuYWdlci0+ZnVsbERhdGFiYXNlRmlsZW5hbWUobV9zdG9yYWdlQXJlYS0+c2VjdXJp dHlPcmlnaW4oKSk7CkBAIC0yMTIsNDggKzIwOSwyMCBAQCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6 cGVyZm9ybUltcG9ydCgpCiAgICAgZm9yICg7IGl0ICE9IGVuZDsgKytpdCkKICAgICAgICAgbV9z dG9yYWdlQXJlYS0+aW1wb3J0SXRlbShpdC0+Zmlyc3QsIGl0LT5zZWNvbmQpOwogICAgIAotICAg IC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KLSAgICBtX3N0b3JhZ2VBcmVhID0gMDsK LSAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1ZTsKLSAgICBtX2ltcG9ydENvbmRpdGlvbi5zaWdu YWwoKTsKKyAgICBtYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCk7CiB9CiAKIHZvaWQg U3RvcmFnZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWQoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhy ZWFkKCkpOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1faW1wb3J0TG9jayk7Ci0gICAgLy8g QnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xlLgotICAgIG1fc3RvcmFnZUFyZWEgPSAwOwotICAg IG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOwotICAgIG1faW1wb3J0Q29uZGl0aW9uLnNpZ25hbCgp OwotfQotCi0vLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFsbG93IHVzZSBvZiBT dG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0byBkbyBzbykuCi0v LyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29tcGxldGUgaXMgYnkg ZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQKLS8vIHRoZXJlIGlz IGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xlbmd0aCB3aWxsIG5l dmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgotLy8gb3B0aW1pemF0aW9uIChzaW5j ZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMgYXJlIGJlaW5nIGFk ZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55Ci0vLyBpdGVtIGN1cnJlbnRseSBpbiB0aGUgbWFwLiBH ZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhlIG1hcCwgYnV0IHdl J2xsIG5lZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3VsZCBub3Qgb3Zlcndy aXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBraWxsIHRoZSBpbXBv cnQKLS8vIGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9ja1VudGlsSW1wb3J0 Q29tcGxldGUoKSBjb25zdAotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Ci0KLSAgICAv LyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KLSAgICBpZiAobV9pbXBvcnRDb21wbGV0ZSkK LSAgICAgICAgcmV0dXJuOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAKICAg ICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRMb2NrKTsKLSAgICB3aGlsZSAoIW1faW1wb3J0 Q29tcGxldGUpCi0gICAgICAgIG1faW1wb3J0Q29uZGl0aW9uLndhaXQobV9pbXBvcnRMb2NrKTsK LSAgICBBU1NFUlQobV9pbXBvcnRDb21wbGV0ZSk7Ci0gICAgQVNTRVJUKCFtX3N0b3JhZ2VBcmVh KTsKKyAgICBtYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCk7CiB9CiAKIHZvaWQgU3Rv cmFnZUFyZWFTeW5jOjpzeW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1hcDxTdHJpbmcs IFN0cmluZz4mIGl0ZW1zKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFT U0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7CiAKICAgICBpZiAoIW1fZGF0YWJhc2UuaXNPcGVu KCkpCiAgICAgICAgIHJldHVybjsKQEAgLTMwOSw3ICsyNzgsNyBAQCB2b2lkIFN0b3JhZ2VBcmVh U3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+ JiBpdGVtcwogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybVN5bmMoKQogewotICAgIEFT U0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0JhY2tncm91bmRUaHJlYWQoKSk7 CiAKICAgICBib29sIGNsZWFySXRlbXM7CiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4gaXRl bXM7CkBAIC0zMzIsNiArMzAxLDQ5IEBAIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjpwZXJmb3JtU3lu YygpCiAgICAgZW5hYmxlU3VkZGVuVGVybWluYXRpb24oKTsKIH0KIAorI2lmICFFTkFCTEUoU0lO R0xFX1RIUkVBREVEKQorCisvLyBGSVhNRTogSW4gdGhlIGZ1dHVyZSwgd2Ugc2hvdWxkIGFsbG93 IHVzZSBvZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRpbmcgKHdoZW4gc2FmZSB0byBk byBzbykuCisvLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRoZSBpbXBvcnQgaXMgY29tcGxl dGUgaXMgYnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRoaW5nIHRvIGRvLCBidXQKKy8v IHRoZXJlIGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGltaXphdGlvbjogS2V5L2xlbmd0 aCB3aWxsIG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3VjaCBhbgorLy8gb3B0aW1pemF0 aW9uIChzaW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBjaGFuZ2UgYXMgaXRlbXMgYXJl IGJlaW5nIGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55CisvLyBpdGVtIGN1cnJlbnRseSBpbiB0 aGUgbWFwLiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Igbm90IGl0J3MgaW4gdGhlIG1h cCwgYnV0IHdlJ2xsIG5lZWQgYSBsaXN0CisvLyBvZiBpdGVtcyB0aGUgaW1wb3J0IHNob3VsZCBu b3Qgb3ZlcndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQgaXQnbGwgbmVlZCB0byBraWxs IHRoZSBpbXBvcnQKKy8vIGpvYiBmaXJzdC4KK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjpibG9ja1Vu dGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7 CisKKyAgICAvLyBGYXN0IHBhdGggdG8gYXZvaWQgbG9ja2luZy4KKyAgICBpZiAobV9pbXBvcnRD b21wbGV0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1faW1w b3J0TG9jayk7CisgICAgd2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICBtX2ltcG9y dENvbmRpdGlvbi53YWl0KG1faW1wb3J0TG9jayk7CisgICAgQVNTRVJUKG1faW1wb3J0Q29tcGxl dGUpOworICAgIEFTU0VSVCghbV9zdG9yYWdlQXJlYSk7Cit9CisKK3ZvaWQgU3RvcmFnZUFyZWFT eW5jOjpzY2hlZHVsZUltcG9ydCgpCit7CisgICAgbV9pbXBvcnRDb21wbGV0ZSA9IGZhbHNlOwor ICAgIC8vIEZJWE1FOiBJZiBpdCBjYW4ndCBpbXBvcnQsIHRoZW4gdGhlIGRlZmF1bHQgV2ViS2l0 IGJlaGF2aW9yIHNob3VsZCBiZSB0aGF0IG9mIHByaXZhdGUgYnJvd3NpbmcsCisgICAgLy8gbm90 IHNpbGVudGx5IGlnbm9yaW5nIGl0LiAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTI1ODk0CisgICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0aGlz KSkKKyAgICAgICAgbV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7Cit9CisKK3ZvaWQgU3RvcmFnZUFy ZWFTeW5jOjptYXJrSW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCkKK3sKKyAgICAvLyBCcmVh ayB0aGUgKHJlZiBjb3VudCkgY3ljbGUuCisgICAgbV9zdG9yYWdlQXJlYSA9IDA7CisgICAgbV9p bXBvcnRDb21wbGV0ZSA9IHRydWU7CisgICAgbV9pbXBvcnRDb25kaXRpb24uc2lnbmFsKCk7Cit9 CisKKyNlbmRpZgorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUo RE9NX1NUT1JBR0UpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5j LmggYi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKaW5kZXggZTQzNmJlZi4uYzE2 Nzg2NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAg KiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVk LgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC03OCwxNSArNzksMzEg QEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHN5bmNUaW1lckZpcmVkKFRpbWVy PFN0b3JhZ2VBcmVhU3luYz4qKTsKICAgICAgICAgdm9pZCBzeW5jKGJvb2wgY2xlYXJJdGVtcywg Y29uc3QgSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4mIGl0ZW1zKTsKIAotICAgICAgICBNdXRleCBt X3N5bmNMb2NrOwogICAgICAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiBtX2l0ZW1zUGVuZGlu Z1N5bmM7CiAgICAgICAgIGJvb2wgbV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nOwogICAgICAgICBi b29sIG1fc3luY1NjaGVkdWxlZDsKIAorICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KCk7Cisg ICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkV2l0 aG91dExvY2tpbmdNdXRleCgpOworCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyAgICAg ICAgYm9vbCBpc0JhY2tncm91bmRUaHJlYWQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisgICAg ICAgIC8vIEhhY2sgV1RGOjpNdXRleExvY2tlciBhbmQganVzdCBkbyBub3RoaW5nCisgICAgICAg IGVudW0gRHVtbXlNdXRleCB7CisgICAgICAgICAgICBtX3N5bmNMb2NrLAorICAgICAgICAgICAg bV9pbXBvcnRMb2NrLAorICAgICAgICB9OworICAgICAgICBzdHJ1Y3QgTXV0ZXhMb2NrZXIgewor ICAgICAgICAgICAgTXV0ZXhMb2NrZXIoRHVtbXlNdXRleCkge30KKyAgICAgICAgfTsKKyNlbHNl CisgICAgICAgIE11dGV4IG1fc3luY0xvY2s7CisgICAgICAgIGJvb2wgbV9pbXBvcnRDb21wbGV0 ZTsKICAgICAgICAgbXV0YWJsZSBNdXRleCBtX2ltcG9ydExvY2s7CiAgICAgICAgIG11dGFibGUg VGhyZWFkQ29uZGl0aW9uIG1faW1wb3J0Q29uZGl0aW9uOwotICAgICAgICBtdXRhYmxlIGJvb2wg bV9pbXBvcnRDb21wbGV0ZTsKLSAgICAgICAgdm9pZCBtYXJrSW1wb3J0ZWQoKTsKKyAgICAgICAg Ym9vbCBpc0JhY2tncm91bmRUaHJlYWQoKSBjb25zdCB7IHJldHVybiAhaXNNYWluVGhyZWFkKCk7 IH0KKyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBh L1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3BwIGIvV2Vi Q29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzZjZDg5YQotLS0gL2Rldi9udWxsCisrKyBiL1dl YkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvRGF0YWJhc2VUaHJlYWQuY3BwCkBAIC0wLDAg KzEsMTM5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisg KiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdpdGggdGhpcyBs aWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiAg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBG aWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKKworI2lmIEVOQUJM RShET01fU1RPUkFHRSkKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorCisjaW5jbHVkZSAi RGF0YWJhc2UuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKKyNpbmNsdWRlICJTUUxUcmFu c2FjdGlvbkNvb3JkaW5hdG9yLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworRGF0YWJhc2VU aHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKKyAgICA6IG1fdGltZXIodGhpcywgJkRhdGFiYXNlVGhy ZWFkOjp0aW1lckZpcmVkKQorICAgICwgbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yKG5ldyBTUUxU cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkpCisjaWZuZGVmIE5ERUJVRworICAgICwgbV9pc1BlcmZv cm1pbmdUYXNrKGZhbHNlKQorI2VuZGlmCit7Cit9CisKK0RhdGFiYXNlVGhyZWFkOjp+RGF0YWJh c2VUaHJlYWQoKQoreworfQorCitib29sIERhdGFiYXNlVGhyZWFkOjpzdGFydCgpCit7CisgICAg cmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlv bigpCit7CisgICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1fdHJhbnNhY3Rpb25Db29yZGluYXRv ci0+c2h1dGRvd24oKTsKK30KKworYm9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWluYXRpb25SZXF1 ZXN0ZWQoKSBjb25zdAoreworICAgIHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsKK30KKwordm9p ZCBEYXRhYmFzZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKQorewor ICAgIGlmIChtX3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisjaWZuZGVmIE5E RUJVRworICAgIG1faXNQZXJmb3JtaW5nVGFzayA9IHRydWU7CisjZW5kaWYKKworICAgIFJlZlB0 cjxEYXRhYmFzZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7CisgICAgbV9xdWV1ZS5yZW1v dmVGaXJzdCgpOworICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7CisKKyNpZm5kZWYgTkRFQlVHCisg ICAgbV9pc1BlcmZvcm1pbmdUYXNrID0gZmFsc2U7CisjZW5kaWYKKworICAgIGlmICghbV9xdWV1 ZS5pc0VtcHR5KCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lk IERhdGFiYXNlVGhyZWFkOjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRh c2spCit7CisgICAgbV9xdWV1ZS5hcHBlbmQodGFzayk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0 aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIERhdGFi YXNlVGhyZWFkOjpzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+ IHRhc2ssIGJvb2wgd2FpdFVudGlsRmluaXNoKQoreworICAgIGlmICh3YWl0VW50aWxGaW5pc2gp IHsKKyAgICAgICAgdGFzay0+bG9ja0ZvclN5bmNocm9ub3VzU2NoZWR1bGluZygpOworI2lmbmRl ZiBOREVCVUcKKyAgICAgICAgLy8gVGhlIGNhbGxlciBtdXN0IHByZXZlbnQgdGhpcyBmcm9tIG9j Y3VyaW5nLgorICAgICAgICBBU1NFUlQoIW1faXNQZXJmb3JtaW5nVGFzayk7CisgICAgICAgIG1f aXNQZXJmb3JtaW5nVGFzayA9IHRydWU7CisjZW5kaWYKKyAgICAgICAgdGFzay0+cGVyZm9ybVRh c2soKTsKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgIG1faXNQZXJmb3JtaW5nVGFzayA9IGZhbHNl OworI2VuZGlmCisgICAgICAgIHJldHVybjsKKyAgICB9DQorDQorICAgIC8vIE1ha2UgdGhpcyB0 YXNrIHRoZSBmaXJzdCBvbmUgaW4gdGhlIHF1ZXVlDQorICAgIG1fcXVldWUucHJlcGVuZCh0YXNr KTsNCisgICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRP bmVTaG90KDApOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VU YXNrcyhEYXRhYmFzZSogZGF0YWJhc2UpCit7CisgICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFz az4gPiByZXNlcnZlZFRhc2tzOworICAgIGZvciAoRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4g Pjo6Y29uc3RfaXRlcmF0b3IgaSA9IG1fcXVldWUuYmVnaW4oKTsgaSAhPSBtX3F1ZXVlLmVuZCgp OyArK2kpIHsKKyAgICAgICAgaWYgKCgqaSktPmRhdGFiYXNlKCkgIT0gZGF0YWJhc2UpCisgICAg ICAgICAgICByZXNlcnZlZFRhc2tzLmFwcGVuZCgqaSk7CisgICAgfQorCisgICAgbV9xdWV1ZS5z d2FwKHJlc2VydmVkVGFza3MpOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRh YmFzZU9wZW4oRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9 CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKiBk YXRhYmFzZSkKK3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorI2VuZGlmIC8vIEVO QUJMRShET01fU1RPUkFHRSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhy ZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhy ZWFkZWQvTG9jYWxTdG9yYWdlVGhyZWFkLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi4xMmYxMWExCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdlL3Npbmds ZS10aHJlYWRlZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3BwCkBAIC0wLDAgKzEsOTAgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICog IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAq ICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqICB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICog IEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KyNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUaHJlYWQuaCIKKworI2lmIEVOQUJMRShET01fU1RPUkFH RSkKKyNpZiBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorCisjaW5jbHVkZSAiTG9jYWxTdG9yYWdl VGFzay5oIgorI2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5oIgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK1Bhc3NSZWZQdHI8TG9jYWxTdG9yYWdlVGhyZWFkPiBMb2NhbFN0b3JhZ2VUaHJlYWQ6 OmNyZWF0ZSgpCit7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbFN0b3JhZ2VUaHJlYWQp OworfQorCitMb2NhbFN0b3JhZ2VUaHJlYWQ6OkxvY2FsU3RvcmFnZVRocmVhZCgpCis6IG1fdGlt ZXIodGhpcywgJkxvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJGaXJlZCkKK3sKK30KKworYm9vbCBM b2NhbFN0b3JhZ2VUaHJlYWQ6OnN0YXJ0KCkKK3sKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9p ZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFk PiopCit7CisgICAgaWYgKG1fcXVldWUuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAg ICBSZWZQdHI8TG9jYWxTdG9yYWdlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3QoKTsKKyAgICBt X3F1ZXVlLnJlbW92ZUZpcnN0KCk7CisgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKKyAgICBpZiAo IW1fcXVldWUuaXNFbXB0eSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30K Kwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnNjaGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3Rv cmFnZUFyZWFTeW5jPiBhcmVhKQoreworICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRh c2s6OmNyZWF0ZUltcG9ydChhcmVhKSk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisg ICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRo cmVhZDo6c2NoZWR1bGVTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQorewor ICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0ZVN5bmMoYXJlYSkpOwor ICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hv dCgwKTsKK30KKwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRlcm1pbmF0ZSgpCit7CisgICAg bV9xdWV1ZS5jbGVhcigpOworICAgIG1fdGltZXIuc3RvcCgpOworfQorCit2b2lkIExvY2FsU3Rv cmFnZVRocmVhZDo6cGVyZm9ybVRlcm1pbmF0ZSgpCit7CisgICAgQVNTRVJUX05PVF9SRUFDSEVE KCk7CisgICAgdGVybWluYXRlKCk7Cit9CisKK30KKyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RI UkVBREVEKQorI2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKZGlmZiAtLWdpdCBhL1dlYkNv cmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcCBiL1dlYkNvcmUv c3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi5hNDAxZmI4Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29y ZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMuY3BwCkBAIC0wLDAgKzEs NTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmln aHRzIFJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBg YEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2luY2x1ZGUgImNv bmZpZy5oIgorI2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5oIgorCisjaWYgRU5BQkxFKERPTV9T VE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKyNpbmNsdWRlICJTdG9yYWdl QXJlYUltcGwuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIFN0b3JhZ2VBcmVhU3lu Yzo6c2NoZWR1bGVJbXBvcnQoKQoreworICAgIC8vIERvIGEgYmxvY2tpbmcgaW1wb3J0LCBiZWNh dXNlIHdlIGNhbm5vdCAiYmxvY2tVbnRpbEltcG9ydENvbXBsZXRlIiB3aXRoIG9uZSB0aHJlYWQu CisgICAgcGVyZm9ybUltcG9ydCgpOworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6bWFya0lt cG9ydGVkV2l0aG91dExvY2tpbmdNdXRleCgpCit7CisgICAgLy8gQnJlYWsgdGhlIChyZWYgY291 bnQpIGN5Y2xlLgorICAgIG1fc3RvcmFnZUFyZWEgPSAwOworfQorCit2b2lkIFN0b3JhZ2VBcmVh U3luYzo6YmxvY2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3QKK3sKKyAgICAvLyBXZSBoYXZl IGFscmVhZHkgaW1wb3J0ZWQgaW4gc2NoZWR1bGVJbXBvcnQoKS4KK30KKworfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyNlbmRpZiAv LyBFTkFCTEUoRE9NX1NUT1JBR0UpCisKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5j ZS9EYXRhYmFzZVRocmVhZFdpbmNlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFz ZVRocmVhZFdpbmNlLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDgxMTQ1ZC4u MDAwMDAwMAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5j cHAKKysrIC9kZXYvbnVsbApAQCAtMSw5NSArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAy MDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K LSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoK LSAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwg YmUgdXNlZnVsLAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZl IHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZQotICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIu ICBJZiBub3QsIHdyaXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiRGF0YWJh c2VUaHJlYWQuaCIKLQotI2luY2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VU YXNrLmgiCi0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNl VGhyZWFkKCkKLTogbV90aW1lcih0aGlzLCAmRGF0YWJhc2VUaHJlYWQ6OnRpbWVyRmlyZWQpCi17 Ci19Ci0KLURhdGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQoKQotewotfQotCi12b2lkIERh dGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRpb24oKQotewotICAgIG1fcXVldWUuY2xlYXIo KTsKLX0KLQotYm9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25z dAotewotICAgIHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRo cmVhZDo6dGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKQotewotICAgIGlmICghbV9x dWV1ZS5pc0VtcHR5KCkpIHsKLSAgICAgICAgUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1f cXVldWUuZmlyc3QoKTsKLSAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLSAgICAgICAgbV9x dWV1ZS5yZW1vdmVGaXJzdCgpOwotICAgICAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQotICAg ICAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci0gICAgfQotfQotCi12b2lkIERhdGFi YXNlVGhyZWFkOjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCi17 Ci0gICAgbV9xdWV1ZS5hcHBlbmQodGFzayk7Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkp Ci0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwotfQotCi12b2lkIERhdGFiYXNlVGhy ZWFkOjpzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2sp Ci17Ci0gICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6 dW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIERlcXVl PFJlZlB0cjxEYXRhYmFzZVRhc2s+ID4gcmVzZXJ2ZWRUYXNrczsKLSAgICBmb3IgKERlcXVlPFJl ZlB0cjxEYXRhYmFzZVRhc2s+ID46OmNvbnN0X2l0ZXJhdG9yIGkgPSBtX3F1ZXVlLmJlZ2luKCk7 IGkgIT0gbV9xdWV1ZS5lbmQoKTsgKytpKSB7Ci0gICAgICAgIGlmICgoKmkpLT5kYXRhYmFzZSgp ICE9IGRhdGFiYXNlKQotICAgICAgICAgICAgcmVzZXJ2ZWRUYXNrcy5hcHBlbmQoKmkpOwotICAg IH0KLQotICAgIG1fcXVldWUuc3dhcChyZXNlcnZlZFRhc2tzKTsKLX0KLQotdm9pZCBEYXRhYmFz ZVRocmVhZDo6cmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFz ZUNsb3NlZChEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLX0K LQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dp bmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFz ZVRocmVhZFdpbmNlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhZmM3OTEuLjAw MDAwMDAKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaAor KysgL2Rldi9udWxsCkBAIC0xLDY1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkg VG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICog IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1 c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0g KiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElm IG5vdCwgd3JpdGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMw MSwgVVNBLgotICovCi0KLSNpZm5kZWYgRGF0YWJhc2VUaHJlYWRXaW5jZV9oCi0jZGVmaW5lIERh dGFiYXNlVGhyZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8 d3RmL1JlZkNvdW50ZWQuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgRGF0 YWJhc2U7Ci0gICAgY2xhc3MgRGF0YWJhc2VUYXNrOwotCi0gICAgY2xhc3MgRGF0YWJhc2VUaHJl YWQ6IHB1YmxpYyBXVEY6OlJlZkNvdW50ZWQ8RGF0YWJhc2VUaHJlYWQ+IHsKLQotICAgIHB1Ymxp YzoKLSAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsg cmV0dXJuIGFkb3B0UmVmKG5ldyBEYXRhYmFzZVRocmVhZCk7IH0KLSAgICAgICAgfkRhdGFiYXNl VGhyZWFkKCk7Ci0KLSAgICAgICAgYm9vbCBzdGFydCgpIHsgcmV0dXJuIHRydWU7IH0KLSAgICAg ICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oKTsKLSAgICAgICAgYm9vbCB0ZXJtaW5hdGlvblJl cXVlc3RlZCgpIGNvbnN0OwotCi0gICAgICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2VUYXNrPik7Ci0gICAgICAgIHZvaWQgc2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NS ZWZQdHI8RGF0YWJhc2VUYXNrPik7Ci0gICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFz a3MoRGF0YWJhc2UqKTsKLSAgICAgICAgdm9pZCByZWNvcmREYXRhYmFzZU9wZW4oRGF0YWJhc2Uq KTsKLSAgICAgICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChEYXRhYmFzZSopOwotI2lmbmRl ZiBOREVCVUcKLSAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIGNvbnN0IHsg cmV0dXJuIGN1cnJlbnRUaHJlYWQoKTsgfQotI2VuZGlmCi0KLSAgICBwcml2YXRlOgotICAgICAg ICBEYXRhYmFzZVRocmVhZCgpOwotCi0gICAgICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxEYXRh YmFzZVRocmVhZD4qKTsKLQotICAgICAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1f cXVldWU7Ci0gICAgICAgIFRpbWVyPERhdGFiYXNlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0K LX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIERhdGFiYXNlVGhyZWFkV2luY2UK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5j ZS5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3Bw CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZGNiOTAyLi4wMDAwMDAwCi0tLSBhL1dl YkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAKKysrIC9kZXYv bnVsbApAQCAtMSw4MyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1v YmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAot ICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25n IHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdy aXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4K LSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhyZWFk LmgiCi0KLSNpbmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCi0jaW5jbHVkZSAiU3RvcmFnZUFy ZWFTeW5jLmgiCi0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotTG9jYWxTdG9yYWdlVGhyZWFkOjpM b2NhbFN0b3JhZ2VUaHJlYWQoKQotOiBtX3RpbWVyKHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJlYWQ6 OnRpbWVyRmlyZWQpCi17Ci19Ci0KLUxvY2FsU3RvcmFnZVRocmVhZDo6fkxvY2FsU3RvcmFnZVRo cmVhZCgpCi17Ci19Ci0KLWJvb2wgTG9jYWxTdG9yYWdlVGhyZWFkOjpzdGFydCgpCi17Ci0gICAg cmV0dXJuIHRydWU7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKFRp bWVyPExvY2FsU3RvcmFnZVRocmVhZD4qKQotewotICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkp IHsKLSAgICAgICAgUmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0 KCk7Ci0gICAgICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Ci0gICAgICAgIG1fcXVldWUucmVtb3Zl Rmlyc3QoKTsKLSAgICAgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKLSAgICAgICAgICAgIG1f dGltZXIuc3RhcnRPbmVTaG90KDApOwotICAgIH0KLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJl YWQ6OnNjaGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQotewot ICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0ZUltcG9ydChhcmVhKSk7 Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVT aG90KDApOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1bGVTeW5jKFBhc3NS ZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQotewotICAgIG1fcXVldWUuYXBwZW5kKExvY2Fs U3RvcmFnZVRhc2s6OmNyZWF0ZVN5bmMoYXJlYSkpOwotICAgIGlmICghbV90aW1lci5pc0FjdGl2 ZSgpKQotICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9pZCBMb2NhbFN0 b3JhZ2VUaHJlYWQ6OnRlcm1pbmF0ZSgpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1f dGltZXIuc3RvcCgpOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6cGVyZm9ybVRlcm1p bmF0ZSgpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1fdGltZXIuc3RvcCgpOwotfQot Ci19CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFk V2luY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5o CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMDBhYmI1Li4wMDAwMDAwCi0tLSBhL1dl YkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oCisrKyAvZGV2L251 bGwKQEAgLTEsNTggKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2Jp bGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdo dAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAq ICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgotICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS4gIFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bwotICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0g Ki8KLQotCi0jaWZuZGVmIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gKLSNkZWZpbmUgTG9jYWxT dG9yYWdlVGhyZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8 d3RmL1Bhc3NSZWZQdHIuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgU3Rv cmFnZUFyZWFTeW5jOwotICAgIGNsYXNzIExvY2FsU3RvcmFnZVRhc2s7Ci0KLSAgICBjbGFzcyBM b2NhbFN0b3JhZ2VUaHJlYWQgOiBwdWJsaWMgUmVmQ291bnRlZDxMb2NhbFN0b3JhZ2VUaHJlYWQ+ IHsKLSAgICBwdWJsaWM6Ci0gICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsU3RvcmFnZVRo cmVhZD4gY3JlYXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsU3RvcmFnZVRocmVhZCk7 IH0KLQotICAgICAgICB+TG9jYWxTdG9yYWdlVGhyZWFkKCk7Ci0gICAgICAgIGJvb2wgc3RhcnQo KTsKLSAgICAgICAgdm9pZCBzY2hlZHVsZUltcG9ydChQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3lu Yz4pOwotICAgICAgICB2b2lkIHNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3lu Yz4pOwotICAgICAgICB2b2lkIHRlcm1pbmF0ZSgpOwotICAgICAgICB2b2lkIHBlcmZvcm1UZXJt aW5hdGUoKTsKLQotICAgIHByaXZhdGU6Ci0gICAgICAgIExvY2FsU3RvcmFnZVRocmVhZCgpOwot Ci0gICAgICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+Kik7Ci0K LSAgICAgICAgRGVxdWU8UmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+ID4gbV9xdWV1ZTsKLSAgICAg ICAgVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0KLX0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gK 40668 2009-10-05 15:26:50 -0700 2010-06-10 20:56:05 -0700 new patch 28019.patch text/plain 36126 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YjEzYzFkZi4uYmVkNmE1YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NCBAQAorMjAwOS0xMC0wNSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFNpbmdsZS10aHJlYWRlZCBTdG9yYWdlL0RhYmFiYXNlIHNvbHV0aW9u OiB1c2UgVGltZXIgdG8gZG8gYXN5bmMKKyAgICAgICAgZGF0YWJhc2UgdGFza3MKKyAgICAgICAg VGhpcyBwYXRjaCBhbHNvIHJlcGxhY2VzIHN0b3JhZ2Uvd2luY2Ugd2l0aCBzdG9yYWdlL3Npbmds ZS10aHJlYWRlZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjgwMTkgCisgCisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpEYXRhYmFzZTo6b3BlbkFuZFZlcmlmeVZlcnNpb24pOgorICAgICAgICAoV2ViQ29y ZTo6RGF0YWJhc2U6Om1hcmtBc0RlbGV0ZWRBbmRDbG9zZSk6CisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZTo6c2NoZWR1bGVUcmFuc2FjdGlvblN0ZXApOgorICAgICAgICAoV2ViQ29yZTo6RGF0 YWJhc2U6OnRhYmxlTmFtZXMpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUYXNrLmg6Cisg ICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZVRocmVhZDo6c2NoZWR1bGVJbW1lZGlhdGVUYXNrKToKKyAgICAgICAgKiBzdG9yYWdl L0RhdGFiYXNlVGhyZWFkLmg6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6Z2V0 VGhyZWFkSUQpOgorICAgICAgICAqIHN0b3JhZ2UvTG9jYWxTdG9yYWdlVGhyZWFkLmg6CisgICAg ICAgICogc3RvcmFnZS9TdG9yYWdlQXJlYVN5bmMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3Rv cmFnZUFyZWFTeW5jOjpTdG9yYWdlQXJlYVN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFn ZUFyZWFTeW5jOjpzeW5jVGltZXJGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJl YVN5bmM6OnBlcmZvcm1JbXBvcnQpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5j OjptYXJrSW1wb3J0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpzeW5j KToKKyAgICAgICAgKFdlYkNvcmU6OlN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybVN5bmMpOgorICAg ICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpibG9ja1VudGlsSW1wb3J0Q29tcGxldGUp OgorICAgICAgICAoV2ViQ29yZTo6U3RvcmFnZUFyZWFTeW5jOjpzY2hlZHVsZUltcG9ydCk6Cisg ICAgICAgIChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6Om1hcmtJbXBvcnRlZFdpdGhvdXRMb2Nr aW5nTXV0ZXgpOgorICAgICAgICAqIHN0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmg6CisgICAgICAg IChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OmlzQmFja2dyb3VuZFRocmVhZCk6CisgICAgICAg IChXZWJDb3JlOjpTdG9yYWdlQXJlYVN5bmM6OlN0b3JhZ2VNdXRleExvY2tlcjo6U3RvcmFnZU11 dGV4TG9ja2VyKToKKyAgICAgICAgKiBzdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRo cmVhZC5jcHA6IEFkZGVkLgorICAgICAgICAqIHN0b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0xvY2Fs U3RvcmFnZVRocmVhZC5jcHA6IEFkZGVkLgorICAgICAgICAqIHN0b3JhZ2Uvc2luZ2xlLXRocmVh ZGVkL1N0b3JhZ2VBcmVhU3luYy5jcHA6IEFkZGVkLgorICAgICAgICAqIHN0b3JhZ2Uvd2luY2Uv RGF0YWJhc2VUaHJlYWRXaW5jZS5jcHA6IFJlbW92ZWQuCisgICAgICAgICogc3RvcmFnZS93aW5j ZS9EYXRhYmFzZVRocmVhZFdpbmNlLmg6IFJlbW92ZWQuCisgICAgICAgICogc3RvcmFnZS93aW5j ZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHA6IFJlbW92ZWQuCisgICAgICAgICogc3RvcmFn ZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oOiBSZW1vdmVkLgorCiAyMDA5LTEwLTA1 ICBEYXZlIEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNh bSBXZWluaWcuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3BwIGIvV2Vi Q29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAppbmRleCAxNTE1ZWIzLi5lOTExMTYwIDEwMDY0NAot LS0gYS9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9E YXRhYmFzZS5jcHAKQEAgLTIwOCw5ICsyMDgsNyBAQCBib29sIERhdGFiYXNlOjpvcGVuQW5kVmVy aWZ5VmVyc2lvbihFeGNlcHRpb25Db2RlJiBlKQogCiAgICAgUmVmUHRyPERhdGFiYXNlT3BlblRh c2s+IHRhc2sgPSBEYXRhYmFzZU9wZW5UYXNrOjpjcmVhdGUodGhpcyk7CiAKLSAgICB0YXNrLT5s b2NrRm9yU3luY2hyb25vdXNTY2hlZHVsaW5nKCk7Ci0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VU aHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2spOwotICAgIHRhc2stPndhaXRGb3JT eW5jaHJvbm91c0NvbXBsZXRpb24oKTsKKyAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgp LT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzaywgdHJ1ZSk7CiAKICAgICBBU1NFUlQodGFzay0+ aXNDb21wbGV0ZSgpKTsKICAgICBlID0gdGFzay0+ZXhjZXB0aW9uQ29kZSgpOwpAQCAtMzIxLDkg KzMxOSw3IEBAIHZvaWQgRGF0YWJhc2U6Om1hcmtBc0RlbGV0ZWRBbmRDbG9zZSgpCiAKICAgICBS ZWZQdHI8RGF0YWJhc2VDbG9zZVRhc2s+IHRhc2sgPSBEYXRhYmFzZUNsb3NlVGFzazo6Y3JlYXRl KHRoaXMpOwogCi0gICAgdGFzay0+bG9ja0ZvclN5bmNocm9ub3VzU2NoZWR1bGluZygpOwotICAg IG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNr KTsKLSAgICB0YXNrLT53YWl0Rm9yU3luY2hyb25vdXNDb21wbGV0aW9uKCk7CisgICAgbV9kb2N1 bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2ssIHRydWUp OwogfQogCiB2b2lkIERhdGFiYXNlOjpjbG9zZSgpCkBAIC01NjMsNyArNTU5LDcgQEAgdm9pZCBE YXRhYmFzZTo6c2NoZWR1bGVUcmFuc2FjdGlvblN0ZXAoU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0 aW9uLCBib29sIGltbWVkaWEKICAgICBSZWZQdHI8RGF0YWJhc2VUcmFuc2FjdGlvblRhc2s+IHRh c2sgPSBEYXRhYmFzZVRyYW5zYWN0aW9uVGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uKTsKICAgICBM T0coU3RvcmFnZUFQSSwgIlNjaGVkdWxpbmcgRGF0YWJhc2VUcmFuc2FjdGlvblRhc2sgJXAgZm9y IHRoZSB0cmFuc2FjdGlvbiBzdGVwXG4iLCB0YXNrLmdldCgpKTsKICAgICBpZiAoaW1tZWRpYXRl bHkpCi0gICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRp YXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CisgICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhy ZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSwgZmFsc2UpOwogICAg IGVsc2UKICAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVUYXNr KHRhc2sucmVsZWFzZSgpKTsKIH0KQEAgLTYzNCw5ICs2MzAsNyBAQCBWZWN0b3I8U3RyaW5nPiBE YXRhYmFzZTo6dGFibGVOYW1lcygpCiAgICAgICAgIHJldHVybiBWZWN0b3I8U3RyaW5nPigpOwog ICAgIFJlZlB0cjxEYXRhYmFzZVRhYmxlTmFtZXNUYXNrPiB0YXNrID0gRGF0YWJhc2VUYWJsZU5h bWVzVGFzazo6Y3JlYXRlKHRoaXMpOwogCi0gICAgdGFzay0+bG9ja0ZvclN5bmNocm9ub3VzU2No ZWR1bGluZygpOwotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1t ZWRpYXRlVGFzayh0YXNrKTsKLSAgICB0YXNrLT53YWl0Rm9yU3luY2hyb25vdXNDb21wbGV0aW9u KCk7CisgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVU YXNrKHRhc2ssIHRydWUpOwogCiAgICAgcmV0dXJuIHRhc2stPnRhYmxlTmFtZXMoKTsKIH0KZGlm ZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRhc2suaCBiL1dlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRhc2suaAppbmRleCA0YWVmODkyLi4zMGEyYzNkIDEwMDY0NAotLS0gYS9XZWJD b3JlL3N0b3JhZ2UvRGF0YWJhc2VUYXNrLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNl VGFzay5oCkBAIC01NSw2ICs1NSw5IEBAIHB1YmxpYzoKICAgICBEYXRhYmFzZSogZGF0YWJhc2Uo KSBjb25zdCB7IHJldHVybiBtX2RhdGFiYXNlOyB9CiAgICAgYm9vbCBpc0NvbXBsZXRlKCkgY29u c3QgeyByZXR1cm4gbV9jb21wbGV0ZTsgfQogCisgICAgdm9pZCBsb2NrRm9yU3luY2hyb25vdXNT Y2hlZHVsaW5nKCk7CisgICAgdm9pZCB3YWl0Rm9yU3luY2hyb25vdXNDb21wbGV0aW9uKCk7CisK IHByb3RlY3RlZDoKICAgICBEYXRhYmFzZVRhc2soRGF0YWJhc2UqKTsKIApAQCAtNjQsOSArNjcs NiBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgY29uc3QgY2hhciogZGVidWdUYXNrTmFtZSgpIGNv bnN0ID0gMDsKICNlbmRpZgogCi0gICAgdm9pZCBsb2NrRm9yU3luY2hyb25vdXNTY2hlZHVsaW5n KCk7Ci0gICAgdm9pZCB3YWl0Rm9yU3luY2hyb25vdXNDb21wbGV0aW9uKCk7Ci0KICAgICBEYXRh YmFzZSogbV9kYXRhYmFzZTsKIAogICAgIGJvb2wgbV9jb21wbGV0ZTsKZGlmZiAtLWdpdCBhL1dl YkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvRGF0YWJh c2VUaHJlYWQuY3BwCmluZGV4IDllM2FmZGQuLjhjNGIwNmQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv c3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmNwcApAQCAtMTQ3LDkgKzE0NywxNCBAQCB2b2lkIERhdGFiYXNlVGhyZWFkOjpzY2hl ZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCiAgICAgbV9xdWV1ZS5hcHBl bmQodGFzayk7CiB9CiAKLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNjaGVkdWxlSW1tZWRpYXRlVGFz ayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaykKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnNj aGVkdWxlSW1tZWRpYXRlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzaywgYm9vbCB3 YWl0VW50aWxGaW5pc2gpCiB7CisgICAgUmVmUHRyPDxEYXRhYmFzZVRhc2s+IHRhc2s7CisgICAg aWYgKHdhaXRVbnRpbEZpbmlzaCkKKyAgICAgICAgdGFzay0+bG9ja0ZvclN5bmNocm9ub3VzU2No ZWR1bGluZygpOwogICAgIG1fcXVldWUucHJlcGVuZCh0YXNrKTsKKyAgICBpZiAod2FpdFVudGls RmluaXNoKQorICAgICAgICB0YXNrLT53YWl0Rm9yU3luY2hyb25vdXNDb21wbGV0aW9uKCk7CiB9 CiAKIHZvaWQgRGF0YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKERhdGFiYXNl KiBkYXRhYmFzZSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5o IGIvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgKaW5kZXggODNiMWJhZi4uNzY5NmVh ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgKKysrIGIvV2Vi Q29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29w eXJpZ2h0IChDKSAyMDA3LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq IENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjksNiArMzAsNyBAQAogI2Rl ZmluZSBEYXRhYmFzZVRocmVhZF9oCiAKICNpZiBFTkFCTEUoREFUQUJBU0UpCisKICNpbmNsdWRl IDx3dGYvRGVxdWUuaD4KICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9I YXNoU2V0Lmg+CkBAIC01NiwxMiArNTgsMTggQEAgcHVibGljOgogICAgIGJvb2wgdGVybWluYXRp b25SZXF1ZXN0ZWQoKSBjb25zdDsKIAogICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2VUYXNrPik7Ci0gICAgdm9pZCBzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0 cjxEYXRhYmFzZVRhc2s+KTsgLy8gVGhpcyBqdXN0IGFkZHMgdGhlIHRhc2sgdG8gdGhlIGZyb250 IG9mIHRoZSBxdWV1ZSAtIHRoZSBjYWxsZXIgbmVlZHMgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwg bm90IHRvIGNyZWF0ZSBkZWFkbG9ja3Mgd2hlbiB3YWl0aW5nIGZvciBjb21wbGV0aW9uLgorICAg IC8vIFRoaXMganVzdCBhZGRzIHRoZSB0YXNrIHRvIHRoZSBmcm9udCBvZiB0aGUgcXVldWUgLSB0 aGUgY2FsbGVyIG5lZWRzIHRvIGJlIGV4dHJlbWVseSBjYXJlZnVsIG5vdCB0byBjcmVhdGUgZGVh ZGxvY2tzIHdoZW4gd2FpdGluZyBmb3IgY29tcGxldGlvbi4KKyAgICAvLyBXaGVuIHdhaXQgaXMg dHJ1ZSwgdGhlIGZ1bmN0aW9uIGJsb2NrcyB1bnRpbCB0aGUgam9iIGlzIGZpbmlzaGVkLgorICAg IHZvaWQgc2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VUYXNrPiwgYm9v bCB3YWl0VW50aWxGaW5pc2gpOwogICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0 YWJhc2UqKTsKIAogICAgIHZvaWQgcmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKik7CiAgICAg dm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChEYXRhYmFzZSopOworI2lmIEVOQUJMRShTSU5HTEVf VEhSRUFERUQpCisgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIHsgcmV0dXJuIGN1 cnJlbnRUaHJlYWQoKTsgfQorI2Vsc2UKICAgICBUaHJlYWRJZGVudGlmaWVyIGdldFRocmVhZElE KCkgeyByZXR1cm4gbV90aHJlYWRJRDsgfQorI2VuZGlmCiAKICAgICBTUUxUcmFuc2FjdGlvbkNs aWVudCogdHJhbnNhY3Rpb25DbGllbnQoKSB7IHJldHVybiBtX3RyYW5zYWN0aW9uQ2xpZW50Lmdl dCgpOyB9CiAgICAgU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvciogdHJhbnNhY3Rpb25Db29yZGlu YXRvcigpIHsgcmV0dXJuIG1fdHJhbnNhY3Rpb25Db29yZGluYXRvci5nZXQoKTsgfQpAQCAtNjks NiArNzcsMTYgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBEYXRhYmFzZVRocmVhZCgpOwogCisj aWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8RGF0 YWJhc2VUaHJlYWQ+Kik7CisKKyAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVl dWU7CisgICAgVGltZXI8RGF0YWJhc2VUaHJlYWQ+IG1fdGltZXI7CisjaWZuZGVmIE5ERUJVRwor ICAgIGJvb2wgbV9pc1BlcmZvcm1pbmdUYXNrOworI2VuZGlmCisKKyNlbHNlCiAgICAgc3RhdGlj IHZvaWQqIGRhdGFiYXNlVGhyZWFkU3RhcnQodm9pZCopOwogICAgIHZvaWQqIGRhdGFiYXNlVGhy ZWFkKCk7CiAKQEAgLTgyLDYgKzEwMCw3IEBAIHByaXZhdGU6CiAgICAgdHlwZWRlZiBIYXNoU2V0 PFJlZlB0cjxEYXRhYmFzZT4gPiBEYXRhYmFzZVNldDsKICAgICBEYXRhYmFzZVNldCBtX29wZW5E YXRhYmFzZVNldDsKIAorI2VuZGlmCiAgICAgT3duUHRyPFNRTFRyYW5zYWN0aW9uQ2xpZW50PiBt X3RyYW5zYWN0aW9uQ2xpZW50OwogICAgIE93blB0cjxTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9y PiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3I7CiB9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9y YWdlL0xvY2FsU3RvcmFnZVRocmVhZC5oIGIvV2ViQ29yZS9zdG9yYWdlL0xvY2FsU3RvcmFnZVRo cmVhZC5oCmluZGV4IGU5ZTJiNTguLmI3NTMyN2UgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFn ZS9Mb2NhbFN0b3JhZ2VUaHJlYWQuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvTG9jYWxTdG9yYWdl VGhyZWFkLmgKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA4IEFwcGxl IEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBN b2JpbGUsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucwpAQCAtMjgsNiArMjksNyBAQAogCiAjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQogCisj aW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRl IDx3dGYvTWVzc2FnZVF1ZXVlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KQEAgLTU2 LDYgKzU4LDEyIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBwcml2YXRlOgogICAgICAgICBM b2NhbFN0b3JhZ2VUaHJlYWQoKTsKIAorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisgICAg ICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+Kik7CisKKyAgICAg ICAgRGVxdWU8UmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+ID4gbV9xdWV1ZTsKKyAgICAgICAgVGlt ZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiBtX3RpbWVyOworI2Vsc2UKICAgICAgICAgc3RhdGljIHZv aWQqIGxvY2FsU3RvcmFnZVRocmVhZFN0YXJ0KHZvaWQqKTsKICAgICAgICAgdm9pZCogbG9jYWxT dG9yYWdlVGhyZWFkKCk7CiAKQEAgLTY3LDYgKzc1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog CiAgICAgICAgIE11dGV4IG1fdGVybWluYXRlTG9jazsKICAgICAgICAgVGhyZWFkQ29uZGl0aW9u IG1fdGVybWluYXRlQ29uZGl0aW9uOworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAppbmRleCBiZWM0NWFhLi5jODI0 M2MwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8q CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgogICoKICAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC01NSwxNiArNTYsMTIgQEAgU3RvcmFnZUFyZWFTeW5j OjpTdG9yYWdlQXJlYVN5bmMoUGFzc1JlZlB0cjxTdG9yYWdlU3luY01hbmFnZXI+IHN0b3JhZ2VT eW5jTWFuYWcKICAgICAsIG1fc3luY01hbmFnZXIoc3RvcmFnZVN5bmNNYW5hZ2VyKQogICAgICwg bV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nKGZhbHNlKQogICAgICwgbV9zeW5jU2NoZWR1bGVkKGZh bHNlKQotICAgICwgbV9pbXBvcnRDb21wbGV0ZShmYWxzZSkKIHsKICAgICBBU1NFUlQoaXNNYWlu VGhyZWFkKCkpOwogICAgIEFTU0VSVChtX3N0b3JhZ2VBcmVhKTsKICAgICBBU1NFUlQobV9zeW5j TWFuYWdlcik7CiAKLSAgICAvLyBGSVhNRTogSWYgaXQgY2FuJ3QgaW1wb3J0LCB0aGVuIHRoZSBk ZWZhdWx0IFdlYktpdCBiZWhhdmlvciBzaG91bGQgYmUgdGhhdCBvZiBwcml2YXRlIGJyb3dzaW5n LAotICAgIC8vIG5vdCBzaWxlbnRseSBpZ25vcmluZyBpdC4gIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5NAotICAgIGlmICghbV9zeW5jTWFuYWdlci0+c2NoZWR1 bGVJbXBvcnQodGhpcykpCi0gICAgICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOworICAgIHNj aGVkdWxlSW1wb3J0KCk7CiB9CiAKIFN0b3JhZ2VBcmVhU3luYzo6flN0b3JhZ2VBcmVhU3luYygp CkBAIC0xMzEsNyArMTI4LDcgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVk KFRpbWVyPFN0b3JhZ2VBcmVhU3luYz4qKQogICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+Ojpp dGVyYXRvciBlbmQgPSBtX2NoYW5nZWRJdGVtcy5lbmQoKTsKIAogICAgIHsKLSAgICAgICAgTXV0 ZXhMb2NrZXIgbG9ja2VyKG1fc3luY0xvY2spOworICAgICAgICBTdG9yYWdlTXV0ZXhMb2NrZXIg bG9ja2VyKG1fc3luY0xvY2spOwogCiAgICAgICAgIGlmIChtX2l0ZW1zQ2xlYXJlZCkgewogICAg ICAgICAgICAgbV9pdGVtc1BlbmRpbmdTeW5jLmNsZWFyKCk7CkBAIC0xNjIsNyArMTU5LDcgQEAg dm9pZCBTdG9yYWdlQXJlYVN5bmM6OnN5bmNUaW1lckZpcmVkKFRpbWVyPFN0b3JhZ2VBcmVhU3lu Yz4qKQogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9ybUltcG9ydCgpCiB7Ci0gICAgQVNT RVJUKCFpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsK ICAgICBBU1NFUlQoIW1fZGF0YWJhc2UuaXNPcGVuKCkpOwogCiAgICAgU3RyaW5nIGRhdGFiYXNl RmlsZW5hbWUgPSBtX3N5bmNNYW5hZ2VyLT5mdWxsRGF0YWJhc2VGaWxlbmFtZShtX3N0b3JhZ2VB cmVhLT5zZWN1cml0eU9yaWdpbigpKTsKQEAgLTIwNiw1NiArMjAzLDI4IEBAIHZvaWQgU3RvcmFn ZUFyZWFTeW5jOjpwZXJmb3JtSW1wb3J0KCkKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAg IE11dGV4TG9ja2VyIGxvY2tlcihtX2ltcG9ydExvY2spOwotCisgICAgU3RvcmFnZU11dGV4TG9j a2VyIGxvY2tlcihtX2ltcG9ydExvY2spOworICAgIAogICAgIEhhc2hNYXA8U3RyaW5nLCBTdHJp bmc+OjppdGVyYXRvciBpdCA9IGl0ZW1NYXAuYmVnaW4oKTsKICAgICBIYXNoTWFwPFN0cmluZywg U3RyaW5nPjo6aXRlcmF0b3IgZW5kID0gaXRlbU1hcC5lbmQoKTsKIAogICAgIGZvciAoOyBpdCAh PSBlbmQ7ICsraXQpCiAgICAgICAgIG1fc3RvcmFnZUFyZWEtPmltcG9ydEl0ZW0oaXQtPmZpcnN0 LCBpdC0+c2Vjb25kKTsKLQotICAgIC8vIEJyZWFrIHRoZSAocmVmIGNvdW50KSBjeWNsZS4KLSAg ICBtX3N0b3JhZ2VBcmVhID0gMDsKLSAgICBtX2ltcG9ydENvbXBsZXRlID0gdHJ1ZTsKLSAgICBt X2ltcG9ydENvbmRpdGlvbi5zaWduYWwoKTsKKyAgICAKKyAgICBtYXJrSW1wb3J0ZWRXaXRob3V0 TG9ja2luZ011dGV4KCk7CiB9CiAKIHZvaWQgU3RvcmFnZUFyZWFTeW5jOjptYXJrSW1wb3J0ZWQo KQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOwotCi0gICAgTXV0ZXhMb2NrZXIgbG9j a2VyKG1faW1wb3J0TG9jayk7Ci0gICAgLy8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xlLgot ICAgIG1fc3RvcmFnZUFyZWEgPSAwOwotICAgIG1faW1wb3J0Q29tcGxldGUgPSB0cnVlOwotICAg IG1faW1wb3J0Q29uZGl0aW9uLnNpZ25hbCgpOwotfQotCi0vLyBGSVhNRTogSW4gdGhlIGZ1dHVy ZSwgd2Ugc2hvdWxkIGFsbG93IHVzZSBvZiBTdG9yYWdlQXJlYXMgd2hpbGUgaXQncyBpbXBvcnRp bmcgKHdoZW4gc2FmZSB0byBkbyBzbykuCi0vLyBCbG9ja2luZyBldmVyeXRoaW5nIHVudGlsIHRo ZSBpbXBvcnQgaXMgY29tcGxldGUgaXMgYnkgZmFyIHRoZSBzaW1wbGVzdCBhbmQgc2FmZXN0IHRo aW5nIHRvIGRvLCBidXQKLS8vIHRoZXJlIGlzIGNlcnRhaW5seSByb29tIGZvciBzYWZlIG9wdGlt aXphdGlvbjogS2V5L2xlbmd0aCB3aWxsIG5ldmVyIGJlIGFibGUgdG8gbWFrZSB1c2Ugb2Ygc3Vj aCBhbgotLy8gb3B0aW1pemF0aW9uIChzaW5jZSB0aGUgb3JkZXIgb2YgaXRlcmF0aW9uIGNhbiBj aGFuZ2UgYXMgaXRlbXMgYXJlIGJlaW5nIGFkZGVkKS4gR2V0IGNhbiByZXR1cm4gYW55Ci0vLyBp dGVtIGN1cnJlbnRseSBpbiB0aGUgbWFwLiBHZXQvcmVtb3ZlIGNhbiB3b3JrIHdoZXRoZXIgb3Ig bm90IGl0J3MgaW4gdGhlIG1hcCwgYnV0IHdlJ2xsIG5lZWQgYSBsaXN0Ci0vLyBvZiBpdGVtcyB0 aGUgaW1wb3J0IHNob3VsZCBub3Qgb3ZlcndyaXRlLiBDbGVhciBjYW4gYWxzbyB3b3JrLCBidXQg aXQnbGwgbmVlZCB0byBraWxsIHRoZSBpbXBvcnQKLS8vIGpvYiBmaXJzdC4KLXZvaWQgU3RvcmFn ZUFyZWFTeW5jOjpibG9ja1VudGlsSW1wb3J0Q29tcGxldGUoKSBjb25zdAotewotICAgIEFTU0VS VChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzQmFja2dyb3VuZFRocmVhZCgpKTsKIAot ICAgIC8vIEZhc3QgcGF0aCB0byBhdm9pZCBsb2NraW5nLgotICAgIGlmIChtX2ltcG9ydENvbXBs ZXRlKQotICAgICAgICByZXR1cm47Ci0KLSAgICBNdXRleExvY2tlciBsb2NrZXIobV9pbXBvcnRM b2NrKTsKLSAgICB3aGlsZSAoIW1faW1wb3J0Q29tcGxldGUpCi0gICAgICAgIG1faW1wb3J0Q29u ZGl0aW9uLndhaXQobV9pbXBvcnRMb2NrKTsKLSAgICBBU1NFUlQobV9pbXBvcnRDb21wbGV0ZSk7 Ci0gICAgQVNTRVJUKCFtX3N0b3JhZ2VBcmVhKTsKKyAgICBTdG9yYWdlTXV0ZXhMb2NrZXIgbG9j a2VyKG1faW1wb3J0TG9jayk7CisgICAgbWFya0ltcG9ydGVkV2l0aG91dExvY2tpbmdNdXRleCgp OwogfQogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0 IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+JiBpdGVtcykKIHsKLSAgICBBU1NFUlQoIWlzTWFpblRo cmVhZCgpKTsKKyAgICBBU1NFUlQoaXNCYWNrZ3JvdW5kVGhyZWFkKCkpOwogCiAgICAgaWYgKCFt X2RhdGFiYXNlLmlzT3BlbigpKQogICAgICAgICByZXR1cm47CkBAIC0zMTEsMTIgKzI4MCwxMiBA QCB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c3luYyhib29sIGNsZWFySXRlbXMsIGNvbnN0IEhhc2hN YXA8U3RyaW5nLCBTdHJpbmc+JiBpdGVtcwogCiB2b2lkIFN0b3JhZ2VBcmVhU3luYzo6cGVyZm9y bVN5bmMoKQogewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0Jh Y2tncm91bmRUaHJlYWQoKSk7CiAKICAgICBib29sIGNsZWFySXRlbXM7CiAgICAgSGFzaE1hcDxT dHJpbmcsIFN0cmluZz4gaXRlbXM7CiAgICAgewotICAgICAgICBNdXRleExvY2tlciBsb2NrZXIo bV9zeW5jTG9jayk7CisgICAgICAgIFN0b3JhZ2VNdXRleExvY2tlciBsb2NrZXIobV9zeW5jTG9j ayk7CiAKICAgICAgICAgQVNTRVJUKG1fc3luY1NjaGVkdWxlZCk7CiAKQEAgLTMzNCw2ICszMDMs NDkgQEAgdm9pZCBTdG9yYWdlQXJlYVN5bmM6OnBlcmZvcm1TeW5jKCkKICAgICBlbmFibGVTdWRk ZW5UZXJtaW5hdGlvbigpOwogfQogCisjaWYgIUVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKy8v IEZJWE1FOiBJbiB0aGUgZnV0dXJlLCB3ZSBzaG91bGQgYWxsb3cgdXNlIG9mIFN0b3JhZ2VBcmVh cyB3aGlsZSBpdCdzIGltcG9ydGluZyAod2hlbiBzYWZlIHRvIGRvIHNvKS4KKy8vIEJsb2NraW5n IGV2ZXJ5dGhpbmcgdW50aWwgdGhlIGltcG9ydCBpcyBjb21wbGV0ZSBpcyBieSBmYXIgdGhlIHNp bXBsZXN0IGFuZCBzYWZlc3QgdGhpbmcgdG8gZG8sIGJ1dAorLy8gdGhlcmUgaXMgY2VydGFpbmx5 IHJvb20gZm9yIHNhZmUgb3B0aW1pemF0aW9uOiBLZXkvbGVuZ3RoIHdpbGwgbmV2ZXIgYmUgYWJs ZSB0byBtYWtlIHVzZSBvZiBzdWNoIGFuCisvLyBvcHRpbWl6YXRpb24gKHNpbmNlIHRoZSBvcmRl ciBvZiBpdGVyYXRpb24gY2FuIGNoYW5nZSBhcyBpdGVtcyBhcmUgYmVpbmcgYWRkZWQpLiBHZXQg Y2FuIHJldHVybiBhbnkKKy8vIGl0ZW0gY3VycmVudGx5IGluIHRoZSBtYXAuIEdldC9yZW1vdmUg Y2FuIHdvcmsgd2hldGhlciBvciBub3QgaXQncyBpbiB0aGUgbWFwLCBidXQgd2UnbGwgbmVlZCBh IGxpc3QKKy8vIG9mIGl0ZW1zIHRoZSBpbXBvcnQgc2hvdWxkIG5vdCBvdmVyd3JpdGUuIENsZWFy IGNhbiBhbHNvIHdvcmssIGJ1dCBpdCdsbCBuZWVkIHRvIGtpbGwgdGhlIGltcG9ydAorLy8gam9i IGZpcnN0Lgordm9pZCBTdG9yYWdlQXJlYVN5bmM6OmJsb2NrVW50aWxJbXBvcnRDb21wbGV0ZSgp IGNvbnN0Cit7CisgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKworICAgIC8vIEZhc3QgcGF0 aCB0byBhdm9pZCBsb2NraW5nLgorICAgIGlmIChtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICBy ZXR1cm47CisKKyAgICBTdG9yYWdlTXV0ZXhMb2NrZXIgbG9ja2VyKG1faW1wb3J0TG9jayk7Cisg ICAgd2hpbGUgKCFtX2ltcG9ydENvbXBsZXRlKQorICAgICAgICBtX2ltcG9ydENvbmRpdGlvbi53 YWl0KG1faW1wb3J0TG9jayk7CisgICAgQVNTRVJUKG1faW1wb3J0Q29tcGxldGUpOworICAgIEFT U0VSVCghbV9zdG9yYWdlQXJlYSk7Cit9CisKK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjpzY2hlZHVs ZUltcG9ydCgpCit7CisgICAgbV9pbXBvcnRDb21wbGV0ZSA9IGZhbHNlOworICAgIC8vIEZJWE1F OiBJZiBpdCBjYW4ndCBpbXBvcnQsIHRoZW4gdGhlIGRlZmF1bHQgV2ViS2l0IGJlaGF2aW9yIHNo b3VsZCBiZSB0aGF0IG9mIHByaXZhdGUgYnJvd3NpbmcsCisgICAgLy8gbm90IHNpbGVudGx5IGln bm9yaW5nIGl0LiAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1ODk0 CisgICAgaWYgKCFtX3N5bmNNYW5hZ2VyLT5zY2hlZHVsZUltcG9ydCh0aGlzKSkKKyAgICAgICAg bV9pbXBvcnRDb21wbGV0ZSA9IHRydWU7Cit9CisKK3ZvaWQgU3RvcmFnZUFyZWFTeW5jOjptYXJr SW1wb3J0ZWRXaXRob3V0TG9ja2luZ011dGV4KCkKK3sKKyAgICAvLyBCcmVhayB0aGUgKHJlZiBj b3VudCkgY3ljbGUuCisgICAgbV9zdG9yYWdlQXJlYSA9IDA7CisgICAgbV9pbXBvcnRDb21wbGV0 ZSA9IHRydWU7CisgICAgbV9pbXBvcnRDb25kaXRpb24uc2lnbmFsKCk7Cit9CisKKyNlbmRpZgor CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoRE9NX1NUT1JBR0Up CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmggYi9XZWJDb3Jl L3N0b3JhZ2UvU3RvcmFnZUFyZWFTeW5jLmgKaW5kZXggOWQ2NDM2Zi4uODEzYTBiOCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9zdG9yYWdlL1N0b3JhZ2VBcmVhU3luYy5oCisrKyBiL1dlYkNvcmUvc3Rv cmFnZS9TdG9yYWdlQXJlYVN5bmMuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQg KEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICogQ29weXJp Z2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoK ICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC03OCwxNSArNzksMjggQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICB2b2lkIHN5bmNUaW1lckZpcmVkKFRpbWVyPFN0b3JhZ2VBcmVh U3luYz4qKTsKICAgICAgICAgdm9pZCBzeW5jKGJvb2wgY2xlYXJJdGVtcywgY29uc3QgSGFzaE1h cDxTdHJpbmcsIFN0cmluZz4mIGl0ZW1zKTsKIAotICAgICAgICBNdXRleCBtX3N5bmNMb2NrOwog ICAgICAgICBIYXNoTWFwPFN0cmluZywgU3RyaW5nPiBtX2l0ZW1zUGVuZGluZ1N5bmM7CiAgICAg ICAgIGJvb2wgbV9jbGVhckl0ZW1zV2hpbGVTeW5jaW5nOwogICAgICAgICBib29sIG1fc3luY1Nj aGVkdWxlZDsKIAotICAgICAgICBtdXRhYmxlIE11dGV4IG1faW1wb3J0TG9jazsKLSAgICAgICAg bXV0YWJsZSBUaHJlYWRDb25kaXRpb24gbV9pbXBvcnRDb25kaXRpb247Ci0gICAgICAgIG11dGFi bGUgYm9vbCBtX2ltcG9ydENvbXBsZXRlOworICAgICAgICB2b2lkIHNjaGVkdWxlSW1wb3J0KCk7 CiAgICAgICAgIHZvaWQgbWFya0ltcG9ydGVkKCk7CisgICAgICAgIHZvaWQgbWFya0ltcG9ydGVk V2l0aG91dExvY2tpbmdNdXRleCgpOworCisjaWYgRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyAg ICAgICAgYm9vbCBpc0JhY2tncm91bmRUaHJlYWQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9Cisg ICAgICAgIHN0cnVjdCBTdG9yYWdlTXV0ZXhMb2NrZXIgeworICAgICAgICAgICAgLy8gRG8gbm90 aGluZyBoZXJlCisgICAgICAgICAgICBTdG9yYWdlTXV0ZXhMb2NrZXIoTXV0ZXgmKSB7fQorICAg ICAgICB9OworI2Vsc2UKKyAgICAgICAgdHlwZWRlZiBNdXRleExvY2tlciBTdG9yYWdlTXV0ZXhM b2NrZXI7CisgICAgICAgIGJvb2wgbV9pbXBvcnRDb21wbGV0ZTsKKyAgICAgICAgbXV0YWJsZSBU aHJlYWRDb25kaXRpb24gbV9pbXBvcnRDb25kaXRpb247CisgICAgICAgIGJvb2wgaXNCYWNrZ3Jv dW5kVGhyZWFkKCkgY29uc3QgeyByZXR1cm4gIWlzTWFpblRocmVhZCgpOyB9CisjZW5kaWYKKyAg ICAgICAgTXV0ZXggbV9zeW5jTG9jazsKKyAgICAgICAgbXV0YWJsZSBNdXRleCBtX2ltcG9ydExv Y2s7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAgYi9XZWJDb3JlL3N0 b3JhZ2Uvc2luZ2xlLXRocmVhZGVkL0RhdGFiYXNlVGhyZWFkLmNwcApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi5kNjc4NDk3Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9z dG9yYWdlL3NpbmdsZS10aHJlYWRlZC9EYXRhYmFzZVRocmVhZC5jcHAKQEAgLTAsMCArMSwxNDAg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6 CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0 aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJD SEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhl IEdOVQorICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7 IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqICB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZs b29yLAorICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgorCisjaWYgRU5BQkxFKERPTV9T VE9SQUdFKQorI2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKyNpbmNsdWRlICJEYXRhYmFz ZS5oIgorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgorI2luY2x1ZGUgIlNRTFRyYW5zYWN0aW9u Q29vcmRpbmF0b3IuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitEYXRhYmFzZVRocmVhZDo6 RGF0YWJhc2VUaHJlYWQoKQorICAgIDogbV90aW1lcih0aGlzLCAmRGF0YWJhc2VUaHJlYWQ6OnRp bWVyRmlyZWQpCisgICAgLCBtX3RyYW5zYWN0aW9uQ2xpZW50KG5ldyBTUUxUcmFuc2FjdGlvbkNs aWVudCgpKQorICAgICwgbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yKG5ldyBTUUxUcmFuc2FjdGlv bkNvb3JkaW5hdG9yKCkpCisjaWZuZGVmIE5ERUJVRworICAgICwgbV9pc1BlcmZvcm1pbmdUYXNr KGZhbHNlKQorI2VuZGlmCit7Cit9CisKK0RhdGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQo KQoreworfQorCitib29sIERhdGFiYXNlVGhyZWFkOjpzdGFydCgpCit7CisgICAgcmV0dXJuIHRy dWU7Cit9CisKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbigpCit7Cisg ICAgbV9xdWV1ZS5jbGVhcigpOworICAgIG1fdHJhbnNhY3Rpb25Db29yZGluYXRvci0+c2h1dGRv d24oKTsKK30KKworYm9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBj b25zdAoreworICAgIHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsKK30KKwordm9pZCBEYXRhYmFz ZVRocmVhZDo6dGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKQoreworICAgIGlmICht X3F1ZXVlLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisjaWZuZGVmIE5ERUJVRworICAg IG1faXNQZXJmb3JtaW5nVGFzayA9IHRydWU7CisjZW5kaWYKKworICAgIFJlZlB0cjxEYXRhYmFz ZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7CisgICAgbV9xdWV1ZS5yZW1vdmVGaXJzdCgp OworICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7CisKKyNpZm5kZWYgTkRFQlVHCisgICAgbV9pc1Bl cmZvcm1pbmdUYXNrID0gZmFsc2U7CisjZW5kaWYKKworICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5 KCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIERhdGFiYXNl VGhyZWFkOjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCit7Cisg ICAgbV9xdWV1ZS5hcHBlbmQodGFzayk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisg ICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFk OjpzY2hlZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2ssIGJv b2wgd2FpdFVudGlsRmluaXNoKQoreworICAgIGlmICh3YWl0VW50aWxGaW5pc2gpIHsKKyAgICAg ICAgdGFzay0+bG9ja0ZvclN5bmNocm9ub3VzU2NoZWR1bGluZygpOworI2lmbmRlZiBOREVCVUcK KyAgICAgICAgLy8gVGhlIGNhbGxlciBtdXN0IHByZXZlbnQgdGhpcyBmcm9tIG9jY3VyaW5nLgor ICAgICAgICBBU1NFUlQoIW1faXNQZXJmb3JtaW5nVGFzayk7CisgICAgICAgIG1faXNQZXJmb3Jt aW5nVGFzayA9IHRydWU7CisjZW5kaWYKKyAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKKyNp Zm5kZWYgTkRFQlVHCisgICAgICAgIG1faXNQZXJmb3JtaW5nVGFzayA9IGZhbHNlOworI2VuZGlm CisgICAgICAgIHJldHVybjsKKyAgICB9DQorDQorICAgIC8vIE1ha2UgdGhpcyB0YXNrIHRoZSBm aXJzdCBvbmUgaW4gdGhlIHF1ZXVlDQorICAgIG1fcXVldWUucHJlcGVuZCh0YXNrKTsNCisgICAg aWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDAp OworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyhEYXRh YmFzZSogZGF0YWJhc2UpCit7CisgICAgRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPiByZXNl cnZlZFRhc2tzOworICAgIGZvciAoRGVxdWU8UmVmUHRyPERhdGFiYXNlVGFzaz4gPjo6Y29uc3Rf aXRlcmF0b3IgaSA9IG1fcXVldWUuYmVnaW4oKTsgaSAhPSBtX3F1ZXVlLmVuZCgpOyArK2kpIHsK KyAgICAgICAgaWYgKCgqaSktPmRhdGFiYXNlKCkgIT0gZGF0YWJhc2UpCisgICAgICAgICAgICBy ZXNlcnZlZFRhc2tzLmFwcGVuZCgqaSk7CisgICAgfQorCisgICAgbV9xdWV1ZS5zd2FwKHJlc2Vy dmVkVGFza3MpOworfQorCit2b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZU9wZW4o RGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIG5vdEltcGxlbWVudGVkKCk7Cit9CisKK3ZvaWQg RGF0YWJhc2VUaHJlYWQ6OnJlY29yZERhdGFiYXNlQ2xvc2VkKERhdGFiYXNlKiBkYXRhYmFzZSkK K3sKKyAgICBub3RJbXBsZW1lbnRlZCgpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisK KyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQorI2VuZGlmIC8vIEVOQUJMRShET01f U1RPUkFHRSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9j YWxTdG9yYWdlVGhyZWFkLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9zaW5nbGUtdGhyZWFkZWQvTG9j YWxTdG9yYWdlVGhyZWFkLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4x MmYxMWExCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdlL3NpbmdsZS10aHJlYWRl ZC9Mb2NhbFN0b3JhZ2VUaHJlYWQuY3BwCkBAIC0wLDAgKzEsOTAgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGkgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZ SU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJMb2NhbFN0b3JhZ2VUaHJlYWQuaCIKKworI2lmIEVOQUJMRShET01fU1RPUkFHRSkKKyNpZiBF TkFCTEUoU0lOR0xFX1RIUkVBREVEKQorCisjaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGFzay5oIgor I2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bh c3NSZWZQdHI8TG9jYWxTdG9yYWdlVGhyZWFkPiBMb2NhbFN0b3JhZ2VUaHJlYWQ6OmNyZWF0ZSgp Cit7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBMb2NhbFN0b3JhZ2VUaHJlYWQpOworfQorCitM b2NhbFN0b3JhZ2VUaHJlYWQ6OkxvY2FsU3RvcmFnZVRocmVhZCgpCis6IG1fdGltZXIodGhpcywg JkxvY2FsU3RvcmFnZVRocmVhZDo6dGltZXJGaXJlZCkKK3sKK30KKworYm9vbCBMb2NhbFN0b3Jh Z2VUaHJlYWQ6OnN0YXJ0KCkKK3sKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9pZCBMb2NhbFN0 b3JhZ2VUaHJlYWQ6OnRpbWVyRmlyZWQoVGltZXI8TG9jYWxTdG9yYWdlVGhyZWFkPiopCit7Cisg ICAgaWYgKG1fcXVldWUuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBSZWZQdHI8 TG9jYWxTdG9yYWdlVGFzaz4gdGFzayA9IG1fcXVldWUuZmlyc3QoKTsKKyAgICBtX3F1ZXVlLnJl bW92ZUZpcnN0KCk7CisgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKKyAgICBpZiAoIW1fcXVldWUu aXNFbXB0eSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBM b2NhbFN0b3JhZ2VUaHJlYWQ6OnNjaGVkdWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFT eW5jPiBhcmVhKQoreworICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0 ZUltcG9ydChhcmVhKSk7CisgICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1f dGltZXIuc3RhcnRPbmVTaG90KDApOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2No ZWR1bGVTeW5jKFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQoreworICAgIG1fcXVl dWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0ZVN5bmMoYXJlYSkpOworICAgIGlmICgh bV90aW1lci5pc0FjdGl2ZSgpKQorICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30K Kwordm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRlcm1pbmF0ZSgpCit7CisgICAgbV9xdWV1ZS5j bGVhcigpOworICAgIG1fdGltZXIuc3RvcCgpOworfQorCit2b2lkIExvY2FsU3RvcmFnZVRocmVh ZDo6cGVyZm9ybVRlcm1pbmF0ZSgpCit7CisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAg dGVybWluYXRlKCk7Cit9CisKK30KKyNlbmRpZiAvLyBFTkFCTEUoU0lOR0xFX1RIUkVBREVEKQor I2VuZGlmIC8vIEVOQUJMRShET01fU1RPUkFHRSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFn ZS9zaW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9z aW5nbGUtdGhyZWFkZWQvU3RvcmFnZUFyZWFTeW5jLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi5hNDAxZmI4Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9zdG9yYWdl L3NpbmdsZS10aHJlYWRlZC9TdG9yYWdlQXJlYVN5bmMuY3BwCkBAIC0wLDAgKzEsNTggQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5jLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycg QU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAor ICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIlN0b3JhZ2VBcmVhU3luYy5oIgorCisjaWYgRU5BQkxFKERPTV9TVE9SQUdFKQor I2lmIEVOQUJMRShTSU5HTEVfVEhSRUFERUQpCisKKyNpbmNsdWRlICJTdG9yYWdlQXJlYUltcGwu aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6c2NoZWR1 bGVJbXBvcnQoKQoreworICAgIC8vIERvIGEgYmxvY2tpbmcgaW1wb3J0LCBiZWNhdXNlIHdlIGNh bm5vdCAiYmxvY2tVbnRpbEltcG9ydENvbXBsZXRlIiB3aXRoIG9uZSB0aHJlYWQuCisgICAgcGVy Zm9ybUltcG9ydCgpOworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6bWFya0ltcG9ydGVkV2l0 aG91dExvY2tpbmdNdXRleCgpCit7CisgICAgLy8gQnJlYWsgdGhlIChyZWYgY291bnQpIGN5Y2xl LgorICAgIG1fc3RvcmFnZUFyZWEgPSAwOworfQorCit2b2lkIFN0b3JhZ2VBcmVhU3luYzo6Ymxv Y2tVbnRpbEltcG9ydENvbXBsZXRlKCkgY29uc3QKK3sKKyAgICAvLyBXZSBoYXZlIGFscmVhZHkg aW1wb3J0ZWQgaW4gc2NoZWR1bGVJbXBvcnQoKS4KK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQorCisjZW5kaWYgLy8gRU5BQkxFKFNJTkdMRV9USFJFQURFRCkKKyNlbmRpZiAvLyBFTkFCTEUo RE9NX1NUT1JBR0UpCisKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFz ZVRocmVhZFdpbmNlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdp bmNlLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDgxMTQ1ZC4uMDAwMDAwMAot LS0gYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvRGF0YWJhc2VUaHJlYWRXaW5jZS5jcHAKKysrIC9k ZXYvbnVsbApAQCAtMSw5NSArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNo IE1vYmlsZSwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVs LAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCi0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVT QS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQu aCIKLQotI2luY2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VUYXNrLmgiCi0K LW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkK LTogbV90aW1lcih0aGlzLCAmRGF0YWJhc2VUaHJlYWQ6OnRpbWVyRmlyZWQpCi17Ci19Ci0KLURh dGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQoKQotewotfQotCi12b2lkIERhdGFiYXNlVGhy ZWFkOjpyZXF1ZXN0VGVybWluYXRpb24oKQotewotICAgIG1fcXVldWUuY2xlYXIoKTsKLX0KLQot Ym9vbCBEYXRhYmFzZVRocmVhZDo6dGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdAotewotICAg IHJldHVybiBtX3F1ZXVlLmlzRW1wdHkoKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6dGlt ZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVhZD4qKQotewotICAgIGlmICghbV9xdWV1ZS5pc0Vt cHR5KCkpIHsKLSAgICAgICAgUmVmUHRyPERhdGFiYXNlVGFzaz4gdGFzayA9IG1fcXVldWUuZmly c3QoKTsKLSAgICAgICAgdGFzay0+cGVyZm9ybVRhc2soKTsKLSAgICAgICAgbV9xdWV1ZS5yZW1v dmVGaXJzdCgpOwotICAgICAgICBpZiAoIW1fcXVldWUuaXNFbXB0eSgpKQotICAgICAgICAgICAg bV90aW1lci5zdGFydE9uZVNob3QoMCk7Ci0gICAgfQotfQotCi12b2lkIERhdGFiYXNlVGhyZWFk OjpzY2hlZHVsZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCi17Ci0gICAgbV9x dWV1ZS5hcHBlbmQodGFzayk7Ci0gICAgaWYgKCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAg IG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpzY2hl ZHVsZUltbWVkaWF0ZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZVRhc2s+IHRhc2spCi17Ci0gICAg dGFzay0+cGVyZm9ybVRhc2soKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6dW5zY2hlZHVs ZURhdGFiYXNlVGFza3MoRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIERlcXVlPFJlZlB0cjxE YXRhYmFzZVRhc2s+ID4gcmVzZXJ2ZWRUYXNrczsKLSAgICBmb3IgKERlcXVlPFJlZlB0cjxEYXRh YmFzZVRhc2s+ID46OmNvbnN0X2l0ZXJhdG9yIGkgPSBtX3F1ZXVlLmJlZ2luKCk7IGkgIT0gbV9x dWV1ZS5lbmQoKTsgKytpKSB7Ci0gICAgICAgIGlmICgoKmkpLT5kYXRhYmFzZSgpICE9IGRhdGFi YXNlKQotICAgICAgICAgICAgcmVzZXJ2ZWRUYXNrcy5hcHBlbmQoKmkpOwotICAgIH0KLQotICAg IG1fcXVldWUuc3dhcChyZXNlcnZlZFRhc2tzKTsKLX0KLQotdm9pZCBEYXRhYmFzZVRocmVhZDo6 cmVjb3JkRGF0YWJhc2VPcGVuKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBub3RJbXBsZW1l bnRlZCgpOwotfQotCi12b2lkIERhdGFiYXNlVGhyZWFkOjpyZWNvcmREYXRhYmFzZUNsb3NlZChE YXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLX0KLQotfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFi YXNlVGhyZWFkV2luY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9EYXRhYmFzZVRocmVhZFdp bmNlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZhZmM3OTEuLjAwMDAwMDAKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL3dpbmNlL0RhdGFiYXNlVGhyZWFkV2luY2UuaAorKysgL2Rldi9u dWxsCkBAIC0xLDY1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDkgVG9yY2ggTW9i aWxlLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGkgd2lsbCBiZSB1c2VmdWwsCi0g KiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KLSAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xp biBTdHJlZXQsIEZpZnRoIEZsb29yLAotICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgot ICovCi0KLSNpZm5kZWYgRGF0YWJhc2VUaHJlYWRXaW5jZV9oCi0jZGVmaW5lIERhdGFiYXNlVGhy ZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgRGF0YWJhc2U7Ci0g ICAgY2xhc3MgRGF0YWJhc2VUYXNrOwotCi0gICAgY2xhc3MgRGF0YWJhc2VUaHJlYWQ6IHB1Ymxp YyBXVEY6OlJlZkNvdW50ZWQ8RGF0YWJhc2VUaHJlYWQ+IHsKLQotICAgIHB1YmxpYzoKLSAgICAg ICAgc3RhdGljIFBhc3NSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IGNyZWF0ZSgpIHsgcmV0dXJuIGFk b3B0UmVmKG5ldyBEYXRhYmFzZVRocmVhZCk7IH0KLSAgICAgICAgfkRhdGFiYXNlVGhyZWFkKCk7 Ci0KLSAgICAgICAgYm9vbCBzdGFydCgpIHsgcmV0dXJuIHRydWU7IH0KLSAgICAgICAgdm9pZCBy ZXF1ZXN0VGVybWluYXRpb24oKTsKLSAgICAgICAgYm9vbCB0ZXJtaW5hdGlvblJlcXVlc3RlZCgp IGNvbnN0OwotCi0gICAgICAgIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2VU YXNrPik7Ci0gICAgICAgIHZvaWQgc2NoZWR1bGVJbW1lZGlhdGVUYXNrKFBhc3NSZWZQdHI8RGF0 YWJhc2VUYXNrPik7Ci0gICAgICAgIHZvaWQgdW5zY2hlZHVsZURhdGFiYXNlVGFza3MoRGF0YWJh c2UqKTsKLSAgICAgICAgdm9pZCByZWNvcmREYXRhYmFzZU9wZW4oRGF0YWJhc2UqKTsKLSAgICAg ICAgdm9pZCByZWNvcmREYXRhYmFzZUNsb3NlZChEYXRhYmFzZSopOwotI2lmbmRlZiBOREVCVUcK LSAgICAgICAgVGhyZWFkSWRlbnRpZmllciBnZXRUaHJlYWRJRCgpIGNvbnN0IHsgcmV0dXJuIGN1 cnJlbnRUaHJlYWQoKTsgfQotI2VuZGlmCi0KLSAgICBwcml2YXRlOgotICAgICAgICBEYXRhYmFz ZVRocmVhZCgpOwotCi0gICAgICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxEYXRhYmFzZVRocmVh ZD4qKTsKLQotICAgICAgICBEZXF1ZTxSZWZQdHI8RGF0YWJhc2VUYXNrPiA+IG1fcXVldWU7Ci0g ICAgICAgIFRpbWVyPERhdGFiYXNlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0KLX0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKLQotI2VuZGlmIC8vIERhdGFiYXNlVGhyZWFkV2luY2UKZGlmZiAtLWdp dCBhL1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuY3BwCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZGNiOTAyLi4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3Rv cmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5jcHAKKysrIC9kZXYvbnVsbApAQCAt MSw4MyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5IFRvcmNoIE1vYmlsZSwgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0g KiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpIHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m Ci0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKLSAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCi0g KiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKLSAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KLSAqLwotCi0j aW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiTG9jYWxTdG9yYWdlVGhyZWFkLmgiCi0KLSNp bmNsdWRlICJMb2NhbFN0b3JhZ2VUYXNrLmgiCi0jaW5jbHVkZSAiU3RvcmFnZUFyZWFTeW5jLmgi Ci0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotTG9jYWxTdG9yYWdlVGhyZWFkOjpMb2NhbFN0b3Jh Z2VUaHJlYWQoKQotOiBtX3RpbWVyKHRoaXMsICZMb2NhbFN0b3JhZ2VUaHJlYWQ6OnRpbWVyRmly ZWQpCi17Ci19Ci0KLUxvY2FsU3RvcmFnZVRocmVhZDo6fkxvY2FsU3RvcmFnZVRocmVhZCgpCi17 Ci19Ci0KLWJvb2wgTG9jYWxTdG9yYWdlVGhyZWFkOjpzdGFydCgpCi17Ci0gICAgcmV0dXJuIHRy dWU7Ci19Ci0KLXZvaWQgTG9jYWxTdG9yYWdlVGhyZWFkOjp0aW1lckZpcmVkKFRpbWVyPExvY2Fs U3RvcmFnZVRocmVhZD4qKQotewotICAgIGlmICghbV9xdWV1ZS5pc0VtcHR5KCkpIHsKLSAgICAg ICAgUmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+IHRhc2sgPSBtX3F1ZXVlLmZpcnN0KCk7Ci0gICAg ICAgIHRhc2stPnBlcmZvcm1UYXNrKCk7Ci0gICAgICAgIG1fcXVldWUucmVtb3ZlRmlyc3QoKTsK LSAgICAgICAgaWYgKCFtX3F1ZXVlLmlzRW1wdHkoKSkKLSAgICAgICAgICAgIG1fdGltZXIuc3Rh cnRPbmVTaG90KDApOwotICAgIH0KLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJlYWQ6OnNjaGVk dWxlSW1wb3J0KFBhc3NSZWZQdHI8U3RvcmFnZUFyZWFTeW5jPiBhcmVhKQotewotICAgIG1fcXVl dWUuYXBwZW5kKExvY2FsU3RvcmFnZVRhc2s6OmNyZWF0ZUltcG9ydChhcmVhKSk7Ci0gICAgaWYg KCFtX3RpbWVyLmlzQWN0aXZlKCkpCi0gICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOwot fQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6c2NoZWR1bGVTeW5jKFBhc3NSZWZQdHI8U3Rv cmFnZUFyZWFTeW5jPiBhcmVhKQotewotICAgIG1fcXVldWUuYXBwZW5kKExvY2FsU3RvcmFnZVRh c2s6OmNyZWF0ZVN5bmMoYXJlYSkpOwotICAgIGlmICghbV90aW1lci5pc0FjdGl2ZSgpKQotICAg ICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKLX0KLQotdm9pZCBMb2NhbFN0b3JhZ2VUaHJl YWQ6OnRlcm1pbmF0ZSgpCi17Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1fdGltZXIuc3Rv cCgpOwotfQotCi12b2lkIExvY2FsU3RvcmFnZVRocmVhZDo6cGVyZm9ybVRlcm1pbmF0ZSgpCi17 Ci0gICAgbV9xdWV1ZS5jbGVhcigpOwotICAgIG1fdGltZXIuc3RvcCgpOwotfQotCi19CmRpZmYg LS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uvd2luY2UvTG9jYWxTdG9yYWdlVGhyZWFkV2luY2UuaCBi L1dlYkNvcmUvc3RvcmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzMDBhYmI1Li4wMDAwMDAwCi0tLSBhL1dlYkNvcmUvc3Rv cmFnZS93aW5jZS9Mb2NhbFN0b3JhZ2VUaHJlYWRXaW5jZS5oCisrKyAvZGV2L251bGwKQEAgLTEs NTggKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICog YXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaSB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgot ICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUgR05VCi0gKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqICBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwotICog IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCi0gKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCi0gKi8KLQotCi0j aWZuZGVmIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gKLSNkZWZpbmUgTG9jYWxTdG9yYWdlVGhy ZWFkV2luY2VfaAotCi0jaW5jbHVkZSA8d3RmL0RlcXVlLmg+Ci0jaW5jbHVkZSA8d3RmL1Bhc3NS ZWZQdHIuaD4KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi0gICAgY2xhc3MgU3RvcmFnZUFyZWFT eW5jOwotICAgIGNsYXNzIExvY2FsU3RvcmFnZVRhc2s7Ci0KLSAgICBjbGFzcyBMb2NhbFN0b3Jh Z2VUaHJlYWQgOiBwdWJsaWMgUmVmQ291bnRlZDxMb2NhbFN0b3JhZ2VUaHJlYWQ+IHsKLSAgICBw dWJsaWM6Ci0gICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPExvY2FsU3RvcmFnZVRocmVhZD4gY3Jl YXRlKCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IExvY2FsU3RvcmFnZVRocmVhZCk7IH0KLQotICAg ICAgICB+TG9jYWxTdG9yYWdlVGhyZWFkKCk7Ci0gICAgICAgIGJvb2wgc3RhcnQoKTsKLSAgICAg ICAgdm9pZCBzY2hlZHVsZUltcG9ydChQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4pOwotICAg ICAgICB2b2lkIHNjaGVkdWxlU3luYyhQYXNzUmVmUHRyPFN0b3JhZ2VBcmVhU3luYz4pOwotICAg ICAgICB2b2lkIHRlcm1pbmF0ZSgpOwotICAgICAgICB2b2lkIHBlcmZvcm1UZXJtaW5hdGUoKTsK LQotICAgIHByaXZhdGU6Ci0gICAgICAgIExvY2FsU3RvcmFnZVRocmVhZCgpOwotCi0gICAgICAg IHZvaWQgdGltZXJGaXJlZChUaW1lcjxMb2NhbFN0b3JhZ2VUaHJlYWQ+Kik7Ci0KLSAgICAgICAg RGVxdWU8UmVmUHRyPExvY2FsU3RvcmFnZVRhc2s+ID4gbV9xdWV1ZTsKLSAgICAgICAgVGltZXI8 TG9jYWxTdG9yYWdlVGhyZWFkPiBtX3RpbWVyOwotICAgIH07Ci0KLX0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKLQotI2VuZGlmIC8vIExvY2FsU3RvcmFnZVRocmVhZFdpbmNlX2gK