22725 2008-12-07 03:39:23 -0800 Refactor database and worker code to prep the way for DB in Workers 2010-02-23 11:59:39 -0800 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) All All RESOLVED FIXED InRadar P4 Enhancement --- 34990 1 ap webkit-unassigned atwilson bedney commit-queue dglazkov dimich ericu laszlo.gombos michaeln mikko.honkala webkit.review.bot yael oldest_to_newest 101730 0 ap 2008-12-07 03:39:23 -0800 It would be nice to have HTML5 SQL Databases available in Workers. The Database API should likely be extended to support synchronous operation to make it more easily usable, as there is no danger of blocking UI thread with Workers. 101742 1 ap 2008-12-07 04:00:10 -0800 <rdar://problem/6425815> 106764 2 dglazkov 2009-01-23 09:14:12 -0800 One proposed sync API is here: http://code.google.com/p/gears/wiki/Database2API 143688 3 bedney 2009-08-31 11:33:30 -0700 All - I'd add that the latest draft of what is now called the 'Web Database' specification was updated today and is here: http://dev.w3.org/html5/webdatabase/ I noticed that a 'synchronous' API has been added since Webkit/Safari implemented the HTML5 DB functionality a while back. Having that synchronous API (with or without Worker support) would be a definite plus for those of us out here who need it :-). Cheers, - Bill 178815 4 46164 ericu 2010-01-08 14:42:23 -0800 Created attachment 46164 Infrastructure and refactoring to prepare the way for this feature. No new APIs exposed yet. This is just the first changelist for this bug. It prepares the way for the JSC bindings, which I'll work on next. I've tested this briefly with V8 bindings, but they'll be in a separate patch. Since no new APIs are exposed, there are no new layout tests yet. This touches a large number of files, but most of the changes are quite small. The big stuff is concentrated in just a few areas [worker thread shutdown, Document/WorkerContext/ScriptExecutionContext, and of course the Database classes]. 178817 5 webkit.review.bot 2010-01-08 14:44:13 -0800 Attachment 46164 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/workers/WorkerContext.h:50: Code inside a namespace should not be indented. [whitespace/indent] [4] WebCore/dom/Document.h:440: Use 0 instead of NULL. [readability/null] [4] Total errors found: 2 178852 6 dimich 2010-01-08 15:56:38 -0800 Since I've reviewed early version of this change, I'll take a look. 178898 7 46164 dimich 2010-01-08 17:32:25 -0800 Comment on attachment 46164 Infrastructure and refactoring to prepare the way for this feature. No new APIs exposed yet. Database in Workers is great, and the patch look good. Here is the first look's result (not complete yet): > Index: WebCore/ChangeLog This is quite a significant change, and ChangeLog could use more comments on what and why was actually refactored. Right now, it has no comments at all except the generic description on top. Depending on how people search trac or ChangeLogs, more info is useful. > Index: WebCore/bindings/v8/custom/V8DOMWindowCustom.cpp > +#if ENABLE(DATABASE) > +#include "Database.h" > +#endif Database.h already contains this #ifdef inside. No need to duplicate. > Index: WebCore/dom/Document.cpp > +bool Document::isDatabaseReadOnly() const > +{ > + Page* page = document()->page(); > + if (!page || page->settings()->privateBrowsingEnabled()) > + return true; > + return false; > +} > + > +void Document::databaseExceededQuota(const String& name) > +{ > + Page* currentPage = page(); > + ASSERT(currentPage); > + currentPage->chrome()->client()->exceededDatabaseQuota(document()->frame(), name); > +} One of those expects page() to be possibly 0, while another asserts on it. If there is indeed such a difference in expectations, it'd be nice to have a comment explaining it. > +bool Document::isJavaScriptThread() const > +{ > + return WTF::isMainThread(); > +} I think this new virtual function is redundant. For the cases it is used in, it always means "not the database thread", and it seems the database thread ID is available in all points of use. > Index: WebCore/dom/Document.h > - Page* page() const; // can be NULL > + virtual Page* page() const; // can be NULL page() is a pretty 'hot' function. Making it virtual may not improve perf, a lot of work has been done in WebKit to remove 'hot' virtuals... In fact, I think SEC does not need this virtual - looking at how it is used in the patch, it is in fact detecting that the context is not a document (it always returns 0 if context is not a Document). We already have ScriptExecutionContext::isDocument() that can be used instead of checking the returning page for 0. > + virtual bool isJavaScriptThread() const; Probably unnecessary method, see above. > Index: WebCore/dom/ScriptExecutionContext.cpp > =================================================================== > --- WebCore/dom/ScriptExecutionContext.cpp (revision 52995) > +++ WebCore/dom/ScriptExecutionContext.cpp (working copy) > @@ -28,7 +28,8 @@ > #include "ScriptExecutionContext.h" > > #include "ActiveDOMObject.h" > -#include "Document.h" > +#include "DatabaseTask.h" > +#include "DatabaseThread.h" > #include "MessagePort.h" > #include "SecurityOrigin.h" > #include "WorkerContext.h" > @@ -56,6 +57,9 @@ public: > }; > > ScriptExecutionContext::ScriptExecutionContext() > +#if ENABLE(DATABASE) > + : m_hasOpenDatabases(false) > +#endif > { > } > > @@ -72,8 +76,64 @@ ScriptExecutionContext::~ScriptExecution > ASSERT((*iter)->scriptExecutionContext() == this); > (*iter)->contextDestroyed(); > } > + if (m_databaseThread) { > + ASSERT(m_databaseThread->terminationRequested()); > + m_databaseThread = 0; > + } > } > > +#if ENABLE(DATABASE) > + > +DatabaseThread* ScriptExecutionContext::databaseThread() > +{ > + if (!m_databaseThread && !m_hasOpenDatabases) { > + // Create the database thread on first request - but not if at least one database was already opened, > + // because in that case we already had a database thread and terminated it and should not create another. > + m_databaseThread = DatabaseThread::create(); > + if (!m_databaseThread->start()) > + m_databaseThread = 0; > + } > + > + return m_databaseThread.get(); > +} > + > +void ScriptExecutionContext::addOpenDatabase(Database* database) > +{ > + if (!m_openDatabaseSet) > + m_openDatabaseSet.set(new DatabaseSet()); > + > + ASSERT(!m_openDatabaseSet->contains(database)); > + m_openDatabaseSet->add(database); > +} > + > +void ScriptExecutionContext::removeOpenDatabase(Database* database) > +{ > + ASSERT(m_openDatabaseSet && m_openDatabaseSet->contains(database)); > + if (!m_openDatabaseSet) > + return; > + m_openDatabaseSet->remove(database); > +} > + > +void ScriptExecutionContext::stopDatabases(DatabaseTaskSynchronizer *cleanupSync) > +{ > + if (m_openDatabaseSet) { > + DatabaseSet::iterator i = m_openDatabaseSet->begin(); > + DatabaseSet::iterator end = m_openDatabaseSet->end(); > + for (; i != end; ++i) { > + (*i)->stop(); > + if (m_databaseThread) > + m_databaseThread->unscheduleDatabaseTasks(*i); > + } > + } > + > + if (m_databaseThread) > + m_databaseThread->requestTermination(cleanupSync); > + else if (cleanupSync) > + cleanupSync->taskCompleted(); > +} > + > +#endif > + > void ScriptExecutionContext::processMessagePortMessagesSoon() > { > postTask(ProcessMessagesSoonTask::create()); > Index: WebCore/dom/ScriptExecutionContext.h > + class Database; > + class DatabaseTaskSynchronizer; > + class DatabaseThread; @if ENABLE(DATABASE) ? > + class Page; If 'virtual Page page();' is not here, this can be removed as well. > + void stopDatabases(DatabaseTaskSynchronizer *cleanupSync); > + // Certain tasks get marked specially so that we don't forget to run > + // them while shutting down. WebKit usually does not try to wrap lines at 80 characters. It's also not clear what "we don't forget" means.. Perhaps 'so they are not discarded when context is shutting down its message queue'? > Index: WebCore/loader/FrameLoader.cpp > #if ENABLE(DATABASE) > + // TODO(ericu): Anything about worker databases here? > && !m_frame->document()->hasOpenDatabases() If doc has workers, the page is not cacheable because they are ActiveDOMObjects that can not be suspended. If they ever will be, the Worker::canSuspend() will have to verify this for all internal objects, including databases. So this TODO can be removed (or re-phrased). > +#if ENABLE(DATABASE) // TODO(ericu): Likewise, anything about worker databases? > if (m_frame->document()->hasOpenDatabases()) Ditto. > Index: WebCore/storage/Database.cpp > -#include "InspectorController.h" > +#if ENABLE(INSPECTOR) > +#include "InspectorController.h" > #endif Not sure why this include moved and gained ENABLE(INSPECTOR) protector... > #if ENABLE(INSPECTOR) > - if (Page* page = document->frame()->page()) > - page->inspectorController()->didOpenDatabase(database.get(), document->securityOrigin()->host(), name, expectedVersion); > + if (Page* page = database->executionContext()->page()) > + page->inspectorController()->didOpenDatabase(database.get(), context->securityOrigin()->host(), name, expectedVersion); That I think is the only place in this patch that uses virtual page() method. Can just check for executionContext()->isDocument() and cast for now. We'll need to figure out how to hook up inspector to workers separately... > Database::~Database() > { > - // Deref m_document on the main thread. > - callOnMainThread(derefDocument, m_document.release().releaseRef()); > + if (!m_executionContext->isJavaScriptThread()) { > + // The reference to the ScriptExecutionContext needs to be cleared on > + // the JavaScript thread, not the Database thread. However, if we're > + // already on that thread, for example cleaning up all databases during > + // worker thread shutdown, we don't want to post a task because it might > + // hit the queue after the WorkerThreadShutdownFinishTask and never get > + // executed. > + m_executionContext->postTask(DerefContextTask::create( > + m_executionContext.release().releaseRef())); The comment sounds a bit confusing. If it is bad that sometimes deref won't happen if we have to post the task to the context's thread, how it is better to never deref at all? I will do more review soon, please feel free to update the patch (or wait until I go through all of it). I'm leaning to r- it at the end due to 'virtual Page page()', but in general it looks good. 178931 8 46193 ericu 2010-01-08 19:54:06 -0800 Created attachment 46193 Revision responding to first code review comments 178933 9 ericu 2010-01-08 19:58:19 -0800 (In reply to comment #7) > > Index: WebCore/ChangeLog > > This is quite a significant change, and ChangeLog could use more comments on > what and why was actually refactored. > Right now, it has no comments at all except the generic description on top. > Depending on how people search trac or ChangeLogs, more info is useful. I've added a bunch; how's that? > > Index: WebCore/bindings/v8/custom/V8DOMWindowCustom.cpp > > > +#if ENABLE(DATABASE) > > +#include "Database.h" > > +#endif > > Database.h already contains this #ifdef inside. No need to duplicate. Fixed. > > Index: WebCore/dom/Document.cpp > > > +bool Document::isDatabaseReadOnly() const > > +{ > > + Page* page = document()->page(); > > + if (!page || page->settings()->privateBrowsingEnabled()) > > + return true; > > + return false; > > +} > > + > > +void Document::databaseExceededQuota(const String& name) > > +{ > > + Page* currentPage = page(); > > + ASSERT(currentPage); > > + currentPage->chrome()->client()->exceededDatabaseQuota(document()->frame(), name); > > +} > > One of those expects page() to be possibly 0, while another asserts on it. If > there is indeed such a difference in expectations, it'd be nice to have a > comment explaining it. Hmm...I'll look around a bit. That's actually code I relocated, that was already there. The assumptions about page() have more to do with the call sites from which I pulled the code than they really should, given the new abstraction. I'll keep looking into that, but as I've addressed everything else, I'm uploading this new patch for your review. > > +bool Document::isJavaScriptThread() const > > +{ > > + return WTF::isMainThread(); > > +} > > I think this new virtual function is redundant. For the cases it is used in, it > always means "not the database thread", and it seems the database thread ID is > available in all points of use. The database thread is available for checking anywhere you can call isJavaScriptThread. However, that's not a sufficient check; since the JS thread isn't the main thread in worker context, it's also important to verify that we're not on the main thread there. > > Index: WebCore/dom/Document.h > > > - Page* page() const; // can be NULL > > + virtual Page* page() const; // can be NULL > > page() is a pretty 'hot' function. Making it virtual may not improve perf, a > lot of work has been done in WebKit to remove 'hot' virtuals... > In fact, I think SEC does not need this virtual - looking at how it is used in > the patch, it is in fact detecting that the context is not a document (it > always returns 0 if context is not a Document). > We already have ScriptExecutionContext::isDocument() that can be used instead > of checking the returning page for 0. Fixed, as below. > > + virtual bool isJavaScriptThread() const; > > Probably unnecessary method, see above. See above. > > Index: WebCore/dom/ScriptExecutionContext.h > > > + class Database; > > + class DatabaseTaskSynchronizer; > > + class DatabaseThread; > > @if ENABLE(DATABASE) ? Fixed. > > + class Page; > > If 'virtual Page page();' is not here, this can be removed as well. Done. > > + void stopDatabases(DatabaseTaskSynchronizer *cleanupSync); > > > + // Certain tasks get marked specially so that we don't forget to run > > + // them while shutting down. > > WebKit usually does not try to wrap lines at 80 characters. It's also not clear > what "we don't forget" means.. > Perhaps 'so they are not discarded when context is shutting down its message > queue'? Fixed. Incidentally, I couldn't find a reference to a preferred line width limit; what's the proper way to wrap very long comments or statements? Do you just let them go forever? > > Index: WebCore/loader/FrameLoader.cpp > > > #if ENABLE(DATABASE) > > + // TODO(ericu): Anything about worker databases here? > > && !m_frame->document()->hasOpenDatabases() > > If doc has workers, the page is not cacheable because they are ActiveDOMObjects > that can not be suspended. > If they ever will be, the Worker::canSuspend() will have to verify this for all > internal objects, including databases. > So this TODO can be removed (or re-phrased). Excellent; thanks. Fixed. > > +#if ENABLE(DATABASE) // TODO(ericu): Likewise, anything about worker databases? > > if (m_frame->document()->hasOpenDatabases()) > > Ditto. Fixed. > > Index: WebCore/storage/Database.cpp > > > -#include "InspectorController.h" > > > +#if ENABLE(INSPECTOR) > > +#include "InspectorController.h" > > #endif > > Not sure why this include moved and gained ENABLE(INSPECTOR) protector... I saw that include guard in some other files, so I assumed it was omitted accidentally here. I see it unguarded in yet others--not sure what the right thing is. I'll put it back for now. > > #if ENABLE(INSPECTOR) > > - if (Page* page = document->frame()->page()) > > - page->inspectorController()->didOpenDatabase(database.get(), document->securityOrigin()->host(), name, expectedVersion); > > + if (Page* page = database->executionContext()->page()) > > + page->inspectorController()->didOpenDatabase(database.get(), context->securityOrigin()->host(), name, expectedVersion); > > That I think is the only place in this patch that uses virtual page() method. > Can just check for executionContext()->isDocument() and cast for now. > We'll need to figure out how to hook up inspector to workers separately... Done. > > Database::~Database() > > { > > - // Deref m_document on the main thread. > > - callOnMainThread(derefDocument, m_document.release().releaseRef()); > > + if (!m_executionContext->isJavaScriptThread()) { > > + // The reference to the ScriptExecutionContext needs to be cleared on > > + // the JavaScript thread, not the Database thread. However, if we're > > + // already on that thread, for example cleaning up all databases during > > + // worker thread shutdown, we don't want to post a task because it might > > + // hit the queue after the WorkerThreadShutdownFinishTask and never get > > + // executed. > > + m_executionContext->postTask(DerefContextTask::create( > > + m_executionContext.release().releaseRef())); > > The comment sounds a bit confusing. If it is bad that sometimes deref won't > happen if we have to post the task to the context's thread, how it is better to > never deref at all? We do nothing here; our destructor completes, calls the RefPtr destructor, and that takes care of it. In the cases where we're posting the task to the JS thread, we're guaranteed to complete it. I've made the comment clearer, mainly by deleting most of it ;'>. 178934 10 webkit.review.bot 2010-01-08 19:59:11 -0800 Attachment 46193 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/workers/WorkerContext.h:50: Code inside a namespace should not be indented. [whitespace/indent] [4] WebCore/storage/Database.cpp:234: One line control clauses should not use braces. [whitespace/braces] [4] Total errors found: 2 178949 11 dimich 2010-01-08 22:59:57 -0800 (In reply to comment #9) > > > +bool Document::isJavaScriptThread() const > > > +{ > > > + return WTF::isMainThread(); > > > +} > > > > I think this new virtual function is redundant. For the cases it is used in, it > > always means "not the database thread", and it seems the database thread ID is > > available in all points of use. > > The database thread is available for checking anywhere you can call > isJavaScriptThread. However, that's not a sufficient check; since the JS > thread isn't the main thread in worker context, it's also important to verify > that we're not on the main thread there. Perhaps, there is a naming issue here that makes me think this doesn't belong - why "JavaScript" thread? Perhaps it should be "isContextThread()"? It would check that current thread is the one that 'postTask()' targets... There are patches attempting to allow other languages to be run as 'script'. On top of that, I hope Database would never be used on 3 threads. Currently, all DOM objects created and used under SEC are accessed on 'context thread' only. In case of Workers this is a Worker thread. This is by design since none of DOM objects are natively cross-thread-capable. For example, XMLHttpRequest does not need to assert or do different things depending on which thread it is running - and in the only place it needs, it uses explicit ThreadableLoader class that explicitly encapsulates the cross-thread logic. Timers simply use TLS and are oblivious to the thread they are used on. It would be really messy if we had to assume that DOM objects can be accessed from different threads. It seems that existing Database code uses isMainThread() as synonym of !isDatabaseThread() and if it is so then the new method can be avoided. At least this seems to be true in this patch. Please correct me if I miss something. 179081 12 46193 dimich 2010-01-09 16:11:36 -0800 Comment on attachment 46193 Revision responding to first code review comments I think you can ignore first style bot complaint about indenting stuff inside namespace in WorkerContext.h. This is a recently-changed rule but this file was already indented. The other one is good to fix though. > Index: WebCore/dom/Document.cpp > +bool Document::isDatabaseReadOnly() const > +{ > + Page* page = document()->page(); no need to use document() here. 'this' is a document. > +void Document::databaseExceededQuota(const String& name) > +{ > + Page* currentPage = page(); > + ASSERT(currentPage); > + currentPage->chrome()->client()->exceededDatabaseQuota(document()->frame(), name); Ditto. document(). > Index: WebCore/dom/Document.h > + virtual bool isJavaScriptThread() const; See previous reply. If it is actually needed, the better name seems to be isContextThread(). > Index: WebCore/dom/ScriptExecutionContext.h > + void stopDatabases(DatabaseTaskSynchronizer *cleanupSync); The parameter name is usually omitted here. > + // Certain tasks get marked specially so that they aren't discarded, and are executed, when the context is shutting down its message queue. > + virtual bool isCleanupTask() const { return false; } I don't think it is possible to keep this contract for all ScriptExecutionContexts, for example Document does not control the run loop of the main thread so the tasks can be dropped even if they are marked as 'cleanup tasks'. Not sure how to change it - maybe have a specific WorkerTask class and add it there? > Index: WebCore/storage/Database.cpp > - ASSERT(m_document->databaseThread()); > - > - m_filename = DatabaseTracker::tracker().fullPathForDatabase(m_mainThreadSecurityOrigin.get(), m_name); > + m_filename = DatabaseTracker::tracker().fullPathForDatabase(securityOrigin(), m_name); Is the removal of ASSERT intentional? > +private: > + explicit DerefContextTask(ScriptExecutionContext *context) : m_context(context) > + { > + } the initializers (": m_context(conetxt)") should be on a separate line, indented 4 spaces. > Index: WebCore/storage/Database.h > + ScriptExecutionContext* executionContext() const { return m_executionContext.get(); } In other classes, this is called 'scriptExecutionContext()' (see Node.h for example). Lets rename it, for consistency. > Index: WebCore/storage/DatabaseTracker.h > class DatabaseTracker : public Noncopyable { > public: > static DatabaseTracker& tracker(); > + // NOTE: If at some point anyone implements multiple worker threads > + // running in the same process, this singleton will have to be synchronized. Very explosive NOTE you have here :-) This is exactly what happens in non-Chromium builds - workers run in their own threads in the same process. So DatabaseTracker will have to be changed now. It can be a separate patch though. You said you tested a prototype with Chromium bindings, but in Chromium Workers run in separate processes so there is no multiple Worker threads in the picture at all. Also, database code is not used from main thread in a Worker process since there is no Documents loaded. JSC case provides better threading 'test environment' so it's good to get JSC prototype up and running in order to get these things right. Also, in WebKit the comments usually don't use 'NOTE:', the comment by itself is a note. FIXME perhaps. > Index: WebCore/storage/chromium/DatabaseTrackerChromium.cpp > void DatabaseTracker::addOpenDatabase(Database* database) > { > - ASSERT(isMainThread()); > + ASSERT(database->executionContext()->isJavaScriptThread()); > DatabaseObserver::databaseOpened(database); > } Not sure this is correct replacement... It documents an assumption that this method is ok to call on multiple threads. Is it? > +class TrackerRemoveOpenDatabaseTask : public ScriptExecutionContext::Task { > + virtual void performTask(ScriptExecutionContext *context) > + { > + ASSERT(context->isJavaScriptThread()); No need for ASSERT - by design the task is executed on the context's thread. > void DatabaseTracker::removeOpenDatabase(Database* database) > { > - if (!isMainThread()) { > + if (!database->executionContext()->isJavaScriptThread()) { Does it mean the main thread is actually ok here? It can be that context's thread is not the main thread... It would be simpler to just check for database thread here. > Index: WebCore/storage/chromium/SQLTransactionClientChromium.cpp > + virtual void performTask(ScriptExecutionContext* context) > + { > + WebCore::DatabaseObserver::databaseModified(m_database.get()); > + } 'context' is an unused parameter. Can be omitted. > Index: WebCore/workers/WorkerContext.cpp > +#if ENABLE(DATABASE) > +#include "Database.h" > +#endif ENABLE() guard is not needed here. > Index: WebCore/workers/WorkerContext.h > +#if ENABLE(DATABASE) > +#include "Database.h" > +#endif Ditto. > + virtual bool isDatabaseReadOnly() const { return false; /* TODO(ericu) */ } > + virtual void databaseExceededQuota(const String&) { /* TODO(ericu) */} There is no TODO(name) in WebKit. A comment above the methods saying they are not yet implemented would suffice. It is also a good idea to file bug[s] to actually implement those. > Index: WebCore/workers/WorkerThread.cpp > +class WorkerThreadShutdownFinishTask : public ScriptExecutionContext::Task { > + virtual void performTask(ScriptExecutionContext *context) > + { > + ASSERT(context->isJavaScriptThread()); > + m_workerContext->thread()->runLoop().terminate(); ASSERT is not needed (the postTask ensures that). Also, m_workerContext is the same thing as 'context' parameter - better use the parameter. > +class WorkerThreadShutdownStartTask : public ScriptExecutionContext::Task { > + virtual void performTask(ScriptExecutionContext *context) > + { > + ASSERT(context->isJavaScriptThread()); > + // We currently ignore any DatabasePolicy used for the document's > + // databases; if it's actually used anywhere, this should be revisited. > + DatabaseTaskSynchronizer cleanupSync; > + m_workerContext->stopDatabases(&cleanupSync); Same as above. > void WorkerThread::stop() > - m_runLoop.terminate(); > + // NOTE: this can likely use the same mechanism as used for databases above. > + > + m_runLoop.postTask(WorkerThreadShutdownStartTask::create(m_workerContext.get())); How did you verify that the code that calls stop() does not depend on synchronous result of terminate()? 179655 13 46331 ericu 2010-01-11 19:20:31 -0800 Created attachment 46331 Next revision, rolling in more comments. > > Index: WebCore/dom/Document.cpp > > > +bool Document::isDatabaseReadOnly() const > > +{ > > + Page* page = document()->page(); > > + if (!page || page->settings()->privateBrowsingEnabled()) > > + return true; > > + return false; > > +} > > + > > +void Document::databaseExceededQuota(const String& name) > > +{ > > + Page* currentPage = page(); > > + ASSERT(currentPage); > > + currentPage->chrome()->client()->exceededDatabaseQuota(document()->frame(), name); > > +} > > One of those expects page() to be possibly 0, while another asserts on it. If > there is indeed such a difference in expectations, it'd be nice to have a > comment explaining it. I spoke to dglazkov; the ASSERT is a bug. Fixed. > I think you can ignore first style bot complaint about indenting stuff inside > namespace in WorkerContext.h. This is a recently-changed rule but this file was > already indented. The other one is good to fix though. Yup; that was an oversight, rushing to get a new patch up for the weekend. Fixed. > > Index: WebCore/dom/Document.cpp > > +bool Document::isDatabaseReadOnly() const > > +{ > > + Page* page = document()->page(); > > no need to use document() here. 'this' is a document. Fixed. > > +void Document::databaseExceededQuota(const String& name) > > +{ > > + Page* currentPage = page(); > > + ASSERT(currentPage); > > + > currentPage->chrome()->client()->exceededDatabaseQuota(document()->frame(), > name); > > Ditto. document(). Fixed. > > Index: WebCore/dom/Document.h > > > + virtual bool isJavaScriptThread() const; > > See previous reply. If it is actually needed, the better name seems to be > isContextThread(). Done. > > Index: WebCore/dom/ScriptExecutionContext.h > > > + void stopDatabases(DatabaseTaskSynchronizer *cleanupSync); > > The parameter name is usually omitted here. Done. > discarded, and are executed, when the context is shutting down its message > queue. > > + virtual bool isCleanupTask() const { return false; } > > I don't think it is possible to keep this contract for all > ScriptExecutionContexts, for example Document does not control the run loop of > the main thread so the tasks can be dropped even if they are marked as 'cleanup > tasks'. Not sure how to change it - maybe have a specific WorkerTask class and > add it there? There's already WorkerRunLoop::Task; that seemed like the place to put it, if that's the way you want to go. However, I started putting together an implementation down that road, and it didn't actually look much cleaner. The problem is that the reason I put that in at all was that the WorkerContext was failing to guarantee something that the Document already provides. During cleanup you can post tasks to the Document's context and they'll get executed, since the main thread outlives the cleanup. So you don't need to control the Document's run loop; it already provides the needed functionality. So in my WorkerRunLoop::Task variation, at some point you hit something like ContextRemoveOpenDatabaseTask, which on the Document you can just give to context->postTask, but if context->isWorkerContext you've got to cast to WorkerContext and call e.g. postCleanupTask. It's a bit ugly, and in the end it still assumes that the Document's context will execute all the cleanup tasks. Summing up, I think this is OK as it is, though I can do it the other way if you think it's stylistically better. > > Index: WebCore/storage/Database.cpp > > > - ASSERT(m_document->databaseThread()); > > - > > - m_filename = > DatabaseTracker::tracker().fullPathForDatabase(m_mainThreadSecurityOrigin.get() > , m_name); > > + m_filename = > DatabaseTracker::tracker().fullPathForDatabase(securityOrigin(), m_name); > > Is the removal of ASSERT intentional? No; fixed. > > +private: > > + explicit DerefContextTask(ScriptExecutionContext *context) : > m_context(context) > > + { > > + } > > the initializers (": m_context(conetxt)") should be on a separate line, > indented 4 spaces. Fixed. > > Index: WebCore/storage/Database.h > > > + ScriptExecutionContext* executionContext() const { return > m_executionContext.get(); } > > In other classes, this is called 'scriptExecutionContext()' (see Node.h for > example). Lets rename it, for consistency. Done. > > Index: WebCore/storage/DatabaseTracker.h > > > class DatabaseTracker : public Noncopyable { > > public: > > static DatabaseTracker& tracker(); > > + // NOTE: If at some point anyone implements multiple worker threads > > + // running in the same process, this singleton will have to be > synchronized. > > Very explosive NOTE you have here :-) This is exactly what happens in > non-Chromium builds - workers run in their own threads in the same process. So > DatabaseTracker will have to be changed now. It can be a separate patch though. Changed to a FIXME. I'll have to get that in before or with the JSC bindings. > You said you tested a prototype with Chromium bindings, but in Chromium Workers > run in separate processes so there is no multiple Worker threads in the picture > at all. Also, database code is not used from main thread in a Worker process > since there is no Documents loaded. JSC case provides better threading 'test > environment' so it's good to get JSC prototype up and running in order to get > these things right. Yes indeed. > Also, in WebKit the comments usually don't use 'NOTE:', the comment by itself > is a note. FIXME perhaps. > > > Index: WebCore/storage/chromium/DatabaseTrackerChromium.cpp > > > void DatabaseTracker::addOpenDatabase(Database* database) > > { > > - ASSERT(isMainThread()); > > + ASSERT(database->executionContext()->isJavaScriptThread()); > > DatabaseObserver::databaseOpened(database); > > } > > Not sure this is correct replacement... It documents an assumption that this > method is ok to call on multiple threads. Is it? How so? It seems to me to document [and enforce] the fact that it can only be called on a single thread. Or is this addressed by the change to isContextThread? > > +class TrackerRemoveOpenDatabaseTask : public ScriptExecutionContext::Task { > > + virtual void performTask(ScriptExecutionContext *context) > > + { > > + ASSERT(context->isJavaScriptThread()); > > No need for ASSERT - by design the task is executed on the context's thread. Removed. > > void DatabaseTracker::removeOpenDatabase(Database* database) > > { > > - if (!isMainThread()) { > > + if (!database->executionContext()->isJavaScriptThread()) { > > Does it mean the main thread is actually ok here? It can be that context's > thread is not the main thread... It would be simpler to just check for database > thread here. As discussed privately [reposting for anyone else following along], the main thread is only OK if it's the context thread [e.g. in the Chromium, it's a renderer, not a worker]. Only the context thread gets to call DatabaseObserver::databaseClosed() here. > > Index: WebCore/storage/chromium/SQLTransactionClientChromium.cpp > > > + virtual void performTask(ScriptExecutionContext* context) > > + { > > + WebCore::DatabaseObserver::databaseModified(m_database.get()); > > + } > > 'context' is an unused parameter. Can be omitted. Done. > > Index: WebCore/workers/WorkerContext.cpp > > > +#if ENABLE(DATABASE) > > +#include "Database.h" > > +#endif > > ENABLE() guard is not needed here. Removed. > > Index: WebCore/workers/WorkerContext.h > > > +#if ENABLE(DATABASE) > > +#include "Database.h" > > +#endif > > Ditto. Removed. > > + virtual bool isDatabaseReadOnly() const { return false; /* > TODO(ericu) */ } > > + virtual void databaseExceededQuota(const String&) { /* TODO(ericu) > */} > > There is no TODO(name) in WebKit. A comment above the methods saying they are > not yet implemented would suffice. It is also a good idea to file bug[s] to > actually implement those. Changed the comments; will log bugs once this patch is in. > > Index: WebCore/workers/WorkerThread.cpp > > > +class WorkerThreadShutdownFinishTask : public ScriptExecutionContext::Task { > > > + virtual void performTask(ScriptExecutionContext *context) > > + { > > + ASSERT(context->isJavaScriptThread()); > > + m_workerContext->thread()->runLoop().terminate(); > > ASSERT is not needed (the postTask ensures that). Also, m_workerContext is the > same thing as 'context' parameter - better use the parameter. Done. > > +class WorkerThreadShutdownStartTask : public ScriptExecutionContext::Task { > > + virtual void performTask(ScriptExecutionContext *context) > > + { > > + ASSERT(context->isJavaScriptThread()); > > + // We currently ignore any DatabasePolicy used for the document's > > + // databases; if it's actually used anywhere, this should be > revisited. > > + DatabaseTaskSynchronizer cleanupSync; > > + m_workerContext->stopDatabases(&cleanupSync); > > Same as above. Done. > > void WorkerThread::stop() > > > - m_runLoop.terminate(); > > + // NOTE: this can likely use the same mechanism as used for databases > above. > > + > > + > m_runLoop.postTask(WorkerThreadShutdownStartTask::create(m_workerContext.get()) > ); > > How did you verify that the code that calls stop() does not depend on > synchronous result of terminate()? There really isn't much synchronous result of terminate(); there's no limit on how long that takes to accomplish something, since the worker could be executing an infinite loop in JS. The only real guarantee was that no further tasks in the runLoop would get executed, which is still roughly the case. The only exceptions are the pieces of the shutdown code that have been pulled back into the runLoop, which would previously have run after it exited. And of course the new database shutdown code, which wasn't there at all before. So given the minimal guarantees, I think I've satisfied them. I don't know what the other clients do, but Chrome has a 3-second timer that forces a hard shutdown of the worker process when this more polite mechanism fails, as I'm sure happens quite a bit with badly-behaved worker code. 179656 14 webkit.review.bot 2010-01-11 19:26:14 -0800 Attachment 46331 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/workers/WorkerContext.h:47: Code inside a namespace should not be indented. [whitespace/indent] [4] Total errors found: 1 179659 15 webkit.review.bot 2010-01-11 19:57:55 -0800 Attachment 46331 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/182206 179660 16 ericu 2010-01-11 20:01:04 -0800 Arg--passed all the layout tests, but I didn't check the Chromium build, so I missed a function rename. I'll upload a fix tomorrow; nothing else will change. 179999 17 46403 ericu 2010-01-12 15:16:36 -0800 Created attachment 46403 Fixed chromium compile; removed WorkerContext.idl I fixed that compile error and also removed WorkerContext.idl, which had crept in from a future changelist. 180004 18 webkit.review.bot 2010-01-12 15:35:28 -0800 Attachment 46403 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/workers/WorkerContext.h:47: Code inside a namespace should not be indented. [whitespace/indent] [4] Total errors found: 1 180493 19 46403 dimich 2010-01-13 17:49:24 -0800 Comment on attachment 46403 Fixed chromium compile; removed WorkerContext.idl Looks good, I think this might be the last iteration! Marking r- because of number of nits, but they are all minor. I'm still not sure ScriptExecutionContext::isContextThread() is technically necessary but I can see that its use is beneficial in Database classes where many methods can be routinely called on 2 different threads (context's and database), while some other methods in the same classes must only be used on one certain thread. This 'pattern' is common to most of Database code. It makes it hard to assume certain sequence of construction/destruction of the classes since apparently due to timing of things like GC, the code can take different code paths resulting in calling big chunks of code on one thread or another. Also, since those methods call quite a few of other functions, it's hard to see right away if the whole call tree is cross-thread-safe, especially considering that any Database method without ASSERT for a particular thread is a suspect. Normally, most of WebKit objects is assumed to be created, used and destroyed on a single thread, with exceptions coded up as very small methods, often modifying some shared data, guarded by a mutex, so their cross-thread nature is obvious to the reader of the code. Database code is somewhat different in this regard (example: Database ctor can only be called on context's thread, while dtor can actually be called on either). There are some big known exceptions that can be used cross-thread (String) but they are far in between and perhaps Database classes are in the same category. That being said, cross-thread usage of Database classes is not introduced by this patch of course, so if isContextThread allows adding more ASSERTs into this code, it is better to have it. So let it be and let add more ASSERTs while adopting Database to Workers! Small nits below: > Index: WebCore/dom/Document.cpp > +bool Document::isContextThread() const > +{ > + return WTF::isMainThread(); > +} 'WTF::' prefix is normally not used with functions that exposed from WTF, see other usage of isMainThread() in the same file. > Index: WebCore/dom/ScriptExecutionContext.cpp > +void ScriptExecutionContext::addOpenDatabase(Database* database) > +void ScriptExecutionContext::removeOpenDatabase(Database* database) Lets add ASSERTs on isContextThread() in these, since they modify m_openDatabaseSet. > +void ScriptExecutionContext::stopDatabases(DatabaseTaskSynchronizer *cleanupSync) In WebKit style, there is no space between type name and '*', it should be: DatabaseTaskSynchronizer* cleanupSync. Also, it could use the ASSERT(isContextThread()) too. > Index: WebCore/dom/ScriptExecutionContext.h > + DatabaseThread *databaseThread(); space before '*'. > + typedef HashSet<Database *> DatabaseSet; space before '*'. > Index: WebCore/storage/Database.cpp > -PassRefPtr<Database> Database::openDatabase(Document* document, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, ExceptionCode& e) > +PassRefPtr<Database> Database::openDatabase(ScriptExecutionContext *context, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, ExceptionCode& e) space before '*'. > +Database::Database(ScriptExecutionContext *context, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize) space before '*'. > +class DerefContextTask : public ScriptExecutionContext::Task { > +public: > + static PassOwnPtr<DerefContextTask> create(ScriptExecutionContext *context) > + { > + return new DerefContextTask(context); > + } > + > + virtual void performTask(ScriptExecutionContext*) > + { > + m_context->deref(); > + } I probably was not clear in the comment for previous patch (sorry about that), what I meant is that it should be: virtual void performTask(ScriptExecutionContext* context) { context->deref(); } since the Task already has a pointer to the context. And then this whole 'private' section is not needed: > +private: > + explicit DerefContextTask(ScriptExecutionContext *context) > + : m_context(context) > + { > + } > + > + ScriptExecutionContext* m_context; > +}; > Database::~Database() > + if (!m_scriptExecutionContext->isContextThread()) > + m_scriptExecutionContext->postTask(DerefContextTask::create(m_scriptExecutionContext.release().releaseRef())); It seems this should crash since release() will nullify the pointer inside m_scriptExecutionContext. If it does not crash for you, perhaps ~Database() is always called on context thread? It would be nice to remove this code then. > +class ContextRemoveOpenDatabaseTask : public ScriptExecutionContext::Task { > +private: > + explicit ContextRemoveOpenDatabaseTask(Database *database) : m_database(database) the initializer should be on it own line. > void Database::scheduleTransactionCallback(SQLTransaction* transaction) > { > - transaction->ref(); > - callOnMainThread(deliverPendingCallback, transaction); > + m_scriptExecutionContext->postTask( > + DeliverPendingCallbackTask::create(transaction)); This should be a single line. There is no hard rule on line length in WebKit style guide, although it's normally assumed that 80 is too tight... 'Blend in' is a good general rule. > Index: WebCore/storage/Database.h > + static PassRefPtr<Database> openDatabase(ScriptExecutionContext *context, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, ExceptionCode&); space before '*' > + Database(ScriptExecutionContext *context, const String& name, > + const String& expectedVersion, const String& displayName, > + unsigned long estimatedSize); space before '*' > Index: WebCore/storage/DatabaseThread.h > + void requestTermination(DatabaseTaskSynchronizer *cleanupSync); space before '*' > + DatabaseTaskSynchronizer *m_cleanupSync; space before '*' > Index: WebCore/storage/chromium/DatabaseTrackerChromium.cpp > -bool DatabaseTracker::canEstablishDatabase(Document*, const String&, const String&, unsigned long) > +bool DatabaseTracker::canEstablishDatabase(ScriptExecutionContext *, const String&, const String&, unsigned long) space before '*' > + virtual void performTask(ScriptExecutionContext *context) > + { > + DatabaseTracker::tracker().removeOpenDatabase(m_database); > + // Reffed in caller. > + m_database->deref(); > + } > + > +private: > + explicit TrackerRemoveOpenDatabaseTask(Database *database) : m_database(database) > + { > + } > + > + Database* m_database; > +}; This needs to use RefPtr<Database> instead of ref/deref with comments. You seem to use RefPtr in other places, like NotifyDatabaseChangedTask. Also, m_database initializer should be on its own line, and there are spaces before '*' > Index: WebCore/storage/chromium/SQLTransactionClientChromium.cpp > + transaction->database()->scriptExecutionContext()->postTask( > + NotifyDatabaseChangedTask::create(transaction->database())); No need to break the line. > Index: WebCore/workers/WorkerContext.cpp > +PassRefPtr<Database> WorkerContext::openDatabase(const String& name, const String& version, const String& displayName, unsigned long estimatedSize, ExceptionCode& ec) > +{ > + if (!securityOrigin()->canAccessDatabase()) > + return 0; The spec says this should throw SECURITY_ERR, so 'ec' should be set. > + if (!Database::isAvailable()) > + return 0; Run-time enablement, if works correctly, will remove openDatabase in a way that script wont be able to even detect it. It seems this should this be replaced (or accompanied) with ASSERT(Database::isAvailable). > Index: WebCore/workers/WorkerThread.cpp > +class WorkerThreadShutdownFinishTask : public ScriptExecutionContext::Task { > + > +private: > + explicit WorkerThreadShutdownFinishTask() > + { > + } This constructor can be removed. > +class WorkerThreadShutdownStartTask : public ScriptExecutionContext::Task { > +private: > + explicit WorkerThreadShutdownStartTask() > + { > + } Ditto. In all your Task-derived classes, the private constructors are 'explicit'. WebKit does not require automatic 'explicit' on one-parameter constructors as Chromium style guide does, so I think it's better to remove this for consistency. It's hard to imagine using those private constructors for implicit type conversion anyways. 181050 20 46403 atwilson 2010-01-14 17:58:39 -0800 Comment on attachment 46403 Fixed chromium compile; removed WorkerContext.idl The worker shutdown behavior is somewhat subtle and has been a source of hard-to-track race conditions in the past, but I think you're doing the right things. The thing I'd want to be careful about is making sure no more events sneak in after the thread has been stopped (since we're now doing a couple of queue flushes before shutting down the message loop and exiting the thread), but it looks like the code you added to WorkerRunLoop *should* do that. Run the worker layout tests in a loop for an hour to shake out any new race conditions :) > + > + m_runLoop.postTask(WorkerThreadShutdownStartTask::create()); > + } else > + m_runLoop.terminate(); > } > > } // namespace WebCore 182501 21 46959 ericu 2010-01-19 16:32:52 -0800 Created attachment 46959 Next revision, rolling in more comments. One layout test changed. > (From update of attachment 46403 [details]) > Looks good, I think this might be the last iteration! Marking r- because of > number of nits, but they are all minor. > > I'm still not sure ScriptExecutionContext::isContextThread() is technically > necessary but I can see that its use is beneficial in Database classes where > many methods can be routinely called on 2 different threads (context's and > database), while some other methods in the same classes must only be used on > one certain thread. This 'pattern' is common to most of Database code. It makes > it hard to assume certain sequence of construction/destruction of the classes > since apparently due to timing of things like GC, the code can take different > code paths resulting in calling big chunks of code on one thread or another. > Also, since those methods call quite a few of other functions, it's hard to see > right away if the whole call tree is cross-thread-safe, especially considering > that any Database method without ASSERT for a particular thread is a suspect. > > Normally, most of WebKit objects is assumed to be created, used and destroyed > on a single thread, with exceptions coded up as very small methods, often > modifying some shared data, guarded by a mutex, so their cross-thread nature is > obvious to the reader of the code. Database code is somewhat different in this > regard (example: Database ctor can only be called on context's thread, while > dtor can actually be called on either). There are some big known exceptions > that can be used cross-thread (String) but they are far in between and perhaps > Database classes are in the same category. > > That being said, cross-thread usage of Database classes is not introduced by > this patch of course, so if isContextThread allows adding more ASSERTs into > this code, it is better to have it. So let it be and let add more ASSERTs while > adopting Database to Workers! Amen--I'm no happier than you about the complexity, but I'm a big fan of ASSERTs. > Small nits below: > > > Index: WebCore/dom/Document.cpp > > > +bool Document::isContextThread() const > > +{ > > + return WTF::isMainThread(); > > +} > > 'WTF::' prefix is normally not used with functions that exposed from WTF, see > other usage of isMainThread() in the same file. Fixed. > > Index: WebCore/dom/ScriptExecutionContext.cpp > > > +void ScriptExecutionContext::addOpenDatabase(Database* database) > > +void ScriptExecutionContext::removeOpenDatabase(Database* database) > > Lets add ASSERTs on isContextThread() in these, since they modify > m_openDatabaseSet. Done. > > +void ScriptExecutionContext::stopDatabases(DatabaseTaskSynchronizer *cleanupSync) > > In WebKit style, there is no space between type name and '*', it should be: > DatabaseTaskSynchronizer* cleanupSync. Fixed. > Also, it could use the ASSERT(isContextThread()) too. Done. > > Index: WebCore/dom/ScriptExecutionContext.h > > > + DatabaseThread *databaseThread(); > > space before '*'. Fixed. > > + typedef HashSet<Database *> DatabaseSet; > > space before '*'. Fixed. > > Index: WebCore/storage/Database.cpp > > -PassRefPtr<Database> Database::openDatabase(Document* document, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, ExceptionCode& e) > > +PassRefPtr<Database> Database::openDatabase(ScriptExecutionContext *context, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, ExceptionCode& e) > > space before '*'. > > > +Database::Database(ScriptExecutionContext *context, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize) > > space before '*'. Fixed all instances in this file. > > +class DerefContextTask : public ScriptExecutionContext::Task { > > +public: > > + static PassOwnPtr<DerefContextTask> create(ScriptExecutionContext *context) > > + { > > + return new DerefContextTask(context); > > + } > > + > > + virtual void performTask(ScriptExecutionContext*) > > + { > > + m_context->deref(); > > + } > > I probably was not clear in the comment for previous patch (sorry about that), > what I meant is that it should be: > > virtual void performTask(ScriptExecutionContext* context) > { > context->deref(); > } > > since the Task already has a pointer to the context. And then this whole > 'private' section is not needed: Arg--no, you were perfectly clear. I fixed this in about 3 places, incrementally, but somehow missed this one. Fixed. > > +private: > > + explicit DerefContextTask(ScriptExecutionContext *context) > > + : m_context(context) > > + { > > + } > > + > > + ScriptExecutionContext* m_context; > > +}; > > > Database::~Database() > > + if (!m_scriptExecutionContext->isContextThread()) > > + m_scriptExecutionContext->postTask(DerefContextTask::create(m_scriptExecutionContext.release().releaseRef())); > > It seems this should crash since release() will nullify the pointer inside > m_scriptExecutionContext. If it does not crash for you, perhaps ~Database() is > always called on context thread? It would be nice to remove this code then. I believe it's a matter of timing and circumstance whether it gets called from the context thread or not, so I'll leave the code in [after removing the bug]. As I read it I walked right off the C++ spec into explicitly undefined behavior. That's pretty bad; on the other threads, we can't even count on a crash! At any rate I've fixed the local bug. > > +class ContextRemoveOpenDatabaseTask : public ScriptExecutionContext::Task { > > +private: > > + explicit ContextRemoveOpenDatabaseTask(Database *database) : m_database(database) > > the initializer should be on it own line. Fixed. > > void Database::scheduleTransactionCallback(SQLTransaction* transaction) > > { > > - transaction->ref(); > > - callOnMainThread(deliverPendingCallback, transaction); > > + m_scriptExecutionContext->postTask( > > + DeliverPendingCallbackTask::create(transaction)); > > This should be a single line. There is no hard rule on line length in WebKit > style guide, although it's normally assumed that 80 is too tight... 'Blend in' > is a good general rule. Blended. > > Index: WebCore/storage/Database.h > > + static PassRefPtr<Database> openDatabase(ScriptExecutionContext *context, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, ExceptionCode&); > > space before '*' Fixed. > > + Database(ScriptExecutionContext *context, const String& name, > > + const String& expectedVersion, const String& displayName, > > + unsigned long estimatedSize); > > space before '*' Fixed. > > Index: WebCore/storage/DatabaseThread.h > > + void requestTermination(DatabaseTaskSynchronizer *cleanupSync); > > space before '*' Fixed. > > + DatabaseTaskSynchronizer *m_cleanupSync; > > space before '*' Fixed. > > Index: WebCore/storage/chromium/DatabaseTrackerChromium.cpp > > > -bool DatabaseTracker::canEstablishDatabase(Document*, const String&, const String&, unsigned long) > > +bool DatabaseTracker::canEstablishDatabase(ScriptExecutionContext *, const String&, const String&, unsigned long) > > space before '*' Fixed all in this file. > > + virtual void performTask(ScriptExecutionContext *context) > > + { > > + DatabaseTracker::tracker().removeOpenDatabase(m_database); > > + // Reffed in caller. > > + m_database->deref(); > > + } > > + > > +private: > > + explicit TrackerRemoveOpenDatabaseTask(Database *database) : m_database(database) > > + { > > + } > > + > > + Database* m_database; > > +}; > > This needs to use RefPtr<Database> instead of ref/deref with comments. You seem > to use RefPtr in other places, like NotifyDatabaseChangedTask. > Also, m_database initializer should be on its own line, and there are spaces > before '*' Fixed. In NotifyDatabaseChangedTask, I saw that I was taking in a raw pointer, passing it to a PassRefPtr, and storing that in a RefPtr. For uniformity I made all the raw pointers PassRefPtrs--is that right, or should I have kept it raw until I put it in the RefPtr? I've also changed ContextRemoveOpenDatabaseTask and its caller to use RefPtrs, which I think is cleaner; how's that look? > > Index: WebCore/storage/chromium/SQLTransactionClientChromium.cpp > > > + transaction->database()->scriptExecutionContext()->postTask( > > + NotifyDatabaseChangedTask::create(transaction->database())); > > No need to break the line. Fixed. > > Index: WebCore/workers/WorkerContext.cpp > > > +PassRefPtr<Database> WorkerContext::openDatabase(const String& name, const String& version, const String& displayName, unsigned long estimatedSize, ExceptionCode& ec) > > +{ > > + if (!securityOrigin()->canAccessDatabase()) > > + return 0; > > The spec says this should throw SECURITY_ERR, so 'ec' should be set. True; set here and in DOMWindow.cpp, which required a test change. > > + if (!Database::isAvailable()) > > + return 0; > > Run-time enablement, if works correctly, will remove openDatabase in a way > that script wont be able to even detect it. It seems this should this be > replaced (or accompanied) with ASSERT(Database::isAvailable). Asserted. > > Index: WebCore/workers/WorkerThread.cpp > > > +class WorkerThreadShutdownFinishTask : public ScriptExecutionContext::Task { > > + > > +private: > > + explicit WorkerThreadShutdownFinishTask() > > + { > > + } > > This constructor can be removed. Done. > > +class WorkerThreadShutdownStartTask : public ScriptExecutionContext::Task { > > +private: > > + explicit WorkerThreadShutdownStartTask() > > + { > > + } > > Ditto. Done. > In all your Task-derived classes, the private constructors are 'explicit'. > WebKit does not require automatic 'explicit' on one-parameter constructors as > Chromium style guide does, so I think it's better to remove this for > consistency. It's hard to imagine using those private constructors for implicit > type conversion anyways. Well, explicit is for the times that you didn't actually mean to use them that way, but it happened automatically. But I've removed them. > ------- Comment #20 From Andrew Wilson 2010-01-14 17:58:39 PST (-) [reply] ------- > > (From update of attachment 46403 [details]) > The worker shutdown behavior is somewhat subtle and has been a source of > hard-to-track race conditions in the past, but I think you're doing the right > things. The thing I'd want to be careful about is making sure no more events > sneak in after the thread has been stopped (since we're now doing a couple of > queue flushes before shutting down the message loop and exiting the thread), > but it looks like the code you added to WorkerRunLoop *should* do that. Run the > worker layout tests in a loop for an hour to shake out any new race conditions > :) I'm currently doing this for any test in a directory called "workers". I'll leave that going for at least an hour. 182582 22 46968 ericu 2010-01-19 19:39:20 -0800 Created attachment 46968 Updated to latest webkit code; resolved merge conflicts. Trivial changes from the last patch to resolve merge conflicts. 182584 23 webkit.review.bot 2010-01-19 19:44:05 -0800 Attachment 46968 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/workers/WorkerContext.h:47: Code inside a namespace should not be indented. [whitespace/indent] [4] Total errors found: 1 If any of these errors are false positives, please file a bug against check-webkit-style. 182885 24 46968 dimich 2010-01-20 12:40:39 -0800 Comment on attachment 46968 Updated to latest webkit code; resolved merge conflicts. Just a few more. Lets try to get to a clean r+ so we can flip cq+ on it. > Index: WebCore/page/DOMWindow.cpp > Document* document = m_frame->document(); > - if (!document->securityOrigin()->canAccessDatabase()) > + if (!document->securityOrigin()->canAccessDatabase()) { > + ec = SECURITY_ERR; > return 0; > + } This is a new addition to the previously reviewed patch. It will take less time if we keep the scope of the change rather then expand it. In this particular case, it's a change of already shipped behavior which may have compatibility issues. Basically, if some website will happen to be broken, this change may have to be reverted. Adding Database to Workers is one thing (no compatibility issues since the stuff is new), changing behavior of Database on the regular pages is a different matter, and should have a separate bug. Lets move this into separate bug. > Index: WebCore/storage/Database.cpp > > Database::~Database() > { > + // The reference to the ScriptExecutionContext needs to be cleared on the JavaScript thread. If we're on that thread already, we can just let the RefPtr's destruction do the dereffing. > + if (!m_scriptExecutionContext->isContextThread()) { > + m_scriptExecutionContext->postTask(DerefContextTask::create()); > + m_scriptExecutionContext.release().releaseRef(); This is something we'll want to cleanup, to possibly avoid having a destructor that can run on either thread, since Database may have ownership of non-thread-safe objects... But it's outside of scope of this change since this one simply refactors the existing code. > void Database::close() > { > if (!m_opened) > return; > > + // Must ref() before calling databaseThread()->recordDatabaseClosed(). > + RefPtr<Database> holder = this; The pattern used often in WebKit is to create a RefPtr named 'protect' at the very beginning of the function and then not use it in the code (since 'this' is guaranteed to be valid), like this: RefPtr<Database> protect = this; > + m_scriptExecutionContext->databaseThread()->unscheduleDatabaseTasks(this); > + m_scriptExecutionContext->postTask(ContextRemoveOpenDatabaseTask::create(holder)); Can use 'this' for both, for consistency. It's guaranteed protected. > Index: LayoutTests/ChangeLog The Layouttest change should go with the DOMWindow change, in a different bug. > + No bug. This is part of the checkin for > + https://bugs.webkit.org/show_bug.cgi?id=22725 Normally, all the ChangeLog files that are part of the same checkin, refer to the same bug number. So the first line here would not be needed. 182904 25 47061 ericu 2010-01-20 13:33:10 -0800 Created attachment 47061 Removed DOMWindow.cpp change, fixed the last(?) few comments. > --- Comment #24 from Dmitry Titov <dimich@chromium.org> 2010-01-20 12:40:39 PST --- > (From update of attachment 46968) > Just a few more. Lets try to get to a clean r+ so we can flip cq+ on it. > >> Index: WebCore/page/DOMWindow.cpp >> Document* document = m_frame->document(); >> - if (!document->securityOrigin()->canAccessDatabase()) >> + if (!document->securityOrigin()->canAccessDatabase()) { >> + ec = SECURITY_ERR; >> return 0; >> + } > > This is a new addition to the previously reviewed patch. It will take less time > if we keep the scope of the change rather then expand it. In this particular > case, it's a change of already shipped behavior which may have compatibility > issues. Basically, if some website will happen to be broken, this change may > have to be reverted. Adding Database to Workers is one thing (no compatibility > issues since the stuff is new), changing behavior of Database on the regular > pages is a different matter, and should have a separate bug. Lets move this > into separate bug. Gotcha. I've logged the bug and reverted this part of the patch. I'll resubmit that part once this is in. >> Index: WebCore/storage/Database.cpp >> >> Database::~Database() >> { >> + // The reference to the ScriptExecutionContext needs to be cleared on the JavaScript thread. If we're on that thread already, we can just let the RefPtr's destruction do the dereffing. >> + if (!m_scriptExecutionContext->isContextThread()) { >> + m_scriptExecutionContext->postTask(DerefContextTask::create()); >> + m_scriptExecutionContext.release().releaseRef(); > > This is something we'll want to cleanup, to possibly avoid having a destructor > that can run on either thread, since Database may have ownership of > non-thread-safe objects... But it's outside of scope of this change since this > one simply refactors the existing code. Yeah, it's kind of scary in there right now, thread-wise. >> void Database::close() >> { >> if (!m_opened) >> return; >> >> + // Must ref() before calling databaseThread()->recordDatabaseClosed(). >> + RefPtr<Database> holder = this; > > The pattern used often in WebKit is to create a RefPtr named 'protect' at the > very beginning of the function and then not use it in the code (since 'this' is > guaranteed to be valid), like this: > RefPtr<Database> protect = this; Changed the name to protect and moved it up to the top. I debated putting it after the easy-out "if (!m_opened) return;", but that's a rare failure path, so I assumed we wouldn't put optimization over consistency. >> + m_scriptExecutionContext->databaseThread()->unscheduleDatabaseTasks(this); >> + m_scriptExecutionContext->postTask(ContextRemoveOpenDatabaseTask::create(holder)); > > Can use 'this' for both, for consistency. It's guaranteed protected. Done. >> Index: LayoutTests/ChangeLog > > The Layouttest change should go with the DOMWindow change, in a different bug. > >> + No bug. This is part of the checkin for >> + https://bugs.webkit.org/show_bug.cgi?id=22725 > > Normally, all the ChangeLog files that are part of the same checkin, refer to > the same bug number. So the first line here would not be needed. Gotcha. Just as well that the test change will be in a separate checkin, then. 182970 26 47061 dimich 2010-01-20 16:31:15 -0800 Comment on attachment 47061 Removed DOMWindow.cpp change, fixed the last(?) few comments. r=me. Not sure if commit bot will land this since there is a style violation which is in fact a false positive (filed bug 33925 for that). 183046 27 47061 commit-queue 2010-01-20 19:49:58 -0800 Comment on attachment 47061 Removed DOMWindow.cpp change, fixed the last(?) few comments. Clearing flags on attachment: 47061 Committed r53595: <http://trac.webkit.org/changeset/53595> 183047 28 commit-queue 2010-01-20 19:50:12 -0800 All reviewed patches have been landed. Closing bug. 190062 29 mikko.honkala 2010-02-12 08:26:21 -0800 I think this bug has been closed prematurely. Most of the code is there, but for instance the glue code in WebCore/binding is not there. See e.g., WebCore/workers/WorkerContext.idl, where the openDatabase function is commented out and no implementations for the binding are there either. Since the title of the bug is "Make SQL database storage work in Workers", I would reopen this bug. http://trac.webkit.org/browser/trunk/WebCore/workers/WorkerContext.idl 190080 30 dimich 2010-02-12 09:47:40 -0800 (In reply to comment #29) > I think this bug has been closed prematurely. > Since the title of the bug is "Make SQL database storage work in Workers", I > would reopen this bug. The better way of approaching multi-patch changes may be to have an 'umbrella bug' that says "Implement Foo" and then a few 1-patch bugs implementing actual parts of it, linking them to the main one. Since this bug contained landed patch of first part of the work, it can be renamed to reflect what it actually achieved. 190723 31 ericu 2010-02-16 13:45:12 -0800 (In reply to comment #30) > (In reply to comment #29) > > I think this bug has been closed prematurely. > > Since the title of the bug is "Make SQL database storage work in Workers", I > > would reopen this bug. > > The better way of approaching multi-patch changes may be to have an 'umbrella > bug' that says "Implement Foo" and then a few 1-patch bugs implementing actual > parts of it, linking them to the main one. > > Since this bug contained landed patch of first part of the work, it can be > renamed to reflect what it actually achieved. Renaming this bug; I'll go and log a few more to fill out the task. 46164 2010-01-08 14:42:23 -0800 2010-01-08 19:54:06 -0800 Infrastructure and refactoring to prepare the way for this feature. No new APIs exposed yet. upload.patch text/plain 63422 ericu SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzAwOCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTMxIEBACisyMDEwLTAxLTA4ICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVmYWN0b3JpbmcgYW5kIHBsdW1iaW5nIHRvIGdldCB0aGUgSFRNTDUgU1FMIERhdGFiYXNlIEFQ SSBhY2Nlc3NpYmxlIHRvCisgICAgICAgIHdlYiB3b3JrZXJzLiAgTm8gbmV3IGZ1bmN0aW9uYWxp dHkgaXMgZXhwb3NlZCB5ZXQ7IHRoaXMganVzdCBnZXRzIHRoZQorICAgICAgICBpbmZyYXN0cnVj dHVyZSBpbiBwbGFjZS4gIEl0IHRvdWNoZXMgYSBsb3Qgb2YgZmlsZXMgaW4gc21hbGwgd2F5czsg dGhlCisgICAgICAgIGJpZ2dlc3QgY2hhbmdlcyBhcmUgMSkgdGhhdCBEYXRhYmFzZSBzdHVmZiBt b3ZlcyBmcm9tIERvY3VtZW50IHVwIHRvCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQg Mikgd29ya2VyIHRocmVhZCBzaHV0ZG93biBnb3QgY2hhbmdlZCBhIGJ1bmNoIHRvCisgICAgICAg IGhhbmRsZSBEYXRhYmFzZSBjbGVhbnVwIGFuZCB0aHJlYWQgc3luY2hyb25pemF0aW9uIGlzc3Vl cy4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI3 MjUKKworICAgICAgICBObyBuZXcgdGVzdHM7IGluIGEgZnV0dXJlIHBhdGNoIEknbGwgYWRkIEpT QyBhbmQgVjggYmluZGluZ3MgYW5kIG5ldworICAgICAgICBsYXlvdXQgdGVzdHMgdG8gZXhlcmNp c2UgdGhlbS4KKworICAgICAgICAqIGJpbmRpbmdzL3Y4L2N1c3RvbS9WOERPTVdpbmRvd0N1c3Rv bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOERPTVdpbmRvdzo6T3BlbkRhdGFiYXNlRW5hYmxl ZCk6CisgICAgICAgICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY3Vt ZW50OjpEb2N1bWVudCk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6fkRvY3VtZW50KToK KyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojppc0RhdGFiYXNlUmVhZE9ubHkpOgorICAgICAg ICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmRhdGFiYXNlRXhjZWVkZWRRdW90YSk6CisgICAgICAgIChX ZWJDb3JlOjpEb2N1bWVudDo6aXNKYXZhU2NyaXB0VGhyZWFkKToKKyAgICAgICAgKiBkb20vRG9j dW1lbnQuaDoKKyAgICAgICAgKiBkb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpTY3JpcHRFeGVjdXRpb25Db250 ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6On5TY3JpcHRF eGVjdXRpb25Db250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OmRhdGFiYXNlVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNv bnRleHQ6OmFkZE9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpyZW1vdmVPcGVuRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0 RXhlY3V0aW9uQ29udGV4dDo6c3RvcERhdGFiYXNlcyk6CisgICAgICAgICogZG9tL1NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQuaDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OnNldEhhc09wZW5EYXRhYmFzZXMpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RXhlY3V0 aW9uQ29udGV4dDo6aGFzT3BlbkRhdGFiYXNlcyk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpwYWdlKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2s6OmlzQ2xlYW51cFRhc2spOgorICAgICAgICAqIGxvYWRlci9GcmFtZUxv YWRlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6c3RvcExvYWRpbmcpOgor ICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OmNhbkNhY2hlUGFnZUNvbnRhaW5pbmdUaGlz RnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OmxvZ0NhbkNhY2hlRnJhbWVE ZWNpc2lvbik6CisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEYXRhYmFzZTo6c2V0SXNBdmFpbGFibGUpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJh c2U6OmlzQXZhaWxhYmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpvcGVuRGF0YWJh c2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OkRhdGFiYXNlKToKKyAgICAgICAgKFdl YkNvcmU6OkRlcmVmQ29udGV4dFRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpEZXJl ZkNvbnRleHRUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpEZXJlZkNvbnRl eHRUYXNrOjppc0NsZWFudXBUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRlcmVmQ29udGV4dFRh c2s6OkRlcmVmQ29udGV4dFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6On5EYXRh YmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6b3BlbkFuZFZlcmlmeVZlcnNpb24p OgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6Om1hcmtBc0RlbGV0ZWRBbmRDbG9zZSk6Cisg ICAgICAgIChXZWJDb3JlOjpDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6Y3JlYXRlKToK KyAgICAgICAgKFdlYkNvcmU6OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpwZXJmb3Jt VGFzayk6CisgICAgICAgIChXZWJDb3JlOjpDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6 aXNDbGVhbnVwVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpDb250ZXh0UmVtb3ZlT3BlbkRhdGFi YXNlVGFzazo6Q29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2spOgorICAgICAgICAoV2ViQ29y ZTo6RGF0YWJhc2U6OmNsb3NlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpwZXJmb3Jt T3BlbkFuZFZlcmlmeSk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6c2NoZWR1bGVUcmFu c2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6c2NoZWR1bGVUcmFuc2FjdGlv blN0ZXApOgorICAgICAgICAoV2ViQ29yZTo6RGVsaXZlclBlbmRpbmdDYWxsYmFja1Rhc2s6OmNy ZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzazo6cGVy Zm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6RGVsaXZlclBlbmRpbmdDYWxsYmFja1Rhc2s6 OkRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNl OjpzY2hlZHVsZVRyYW5zYWN0aW9uQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJh c2U6OnRyYW5zYWN0aW9uQ2xpZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjp0cmFu c2FjdGlvbkNvb3JkaW5hdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjp0YWJsZU5h bWVzKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpzZWN1cml0eU9yaWdpbik6CisgICAg ICAgICogc3RvcmFnZS9EYXRhYmFzZS5oOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OmV4 ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUYXNrLmg6CisgICAg ICAgICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRh YmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VU aHJlYWQ6On5EYXRhYmFzZVRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRocmVh ZDo6cmVxdWVzdFRlcm1pbmF0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFk OjpkYXRhYmFzZVRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6dW5z Y2hlZHVsZURhdGFiYXNlVGFza3MpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUaHJlYWQu aDoKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEYXRhYmFzZVRyYWNrZXI6OmNhbkVzdGFibGlzaERhdGFiYXNlKToKKyAgICAgICAgKFdl YkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6Z2V0TWF4U2l6ZUZvckRhdGFiYXNlKToKKyAgICAgICAg KiBzdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5oOgorICAgICAgICAqIHN0b3JhZ2UvU1FMVHJhbnNh Y3Rpb24uY3BwOgorICAgICAgICAoV2ViQ29yZTo6U1FMVHJhbnNhY3Rpb246OmV4ZWN1dGVTUUwp OgorICAgICAgICAqIHN0b3JhZ2UvU1FMVHJhbnNhY3Rpb25DbGllbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0aW9uKToKKyAg ICAgICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhdGVtZW50 KToKKyAgICAgICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90 YSk6CisgICAgICAgICogc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFzZVRyYWNrZXJDaHJvbWl1bS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRyYWNrZXI6OmNhbkVzdGFibGlzaERhdGFi YXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6YWRkT3BlbkRhdGFiYXNl KToKKyAgICAgICAgKFdlYkNvcmU6OlRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpjcmVh dGUpOgorICAgICAgICAoV2ViQ29yZTo6VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OnBl cmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OlRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VU YXNrOjpUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZVRyYWNrZXI6OmdldE1heFNpemVGb3JEYXRhYmFzZSk6CisgICAgICAgICogc3RvcmFn ZS9jaHJvbWl1bS9TUUxUcmFuc2FjdGlvbkNsaWVudENocm9taXVtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJD b3JlOjpOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChX ZWJDb3JlOjpOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrOjpOb3RpZnlEYXRhYmFzZUNoYW5nZWRU YXNrKToKKyAgICAgICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRDb21taXRU cmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlk RXhlY3V0ZVN0YXRlbWVudCk6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbkNsaWVu dDo6ZGlkRXhjZWVkUXVvdGEpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJDb250ZXh0OjpvcGVuRGF0YWJhc2UpOgorICAgICAg ICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6aXNKYXZhU2NyaXB0VGhyZWFkKToKKyAgICAgICAg KiB3b3JrZXJzL1dvcmtlckNvbnRleHQuaDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRl eHQ6OmNsZWFyU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OnRocmVh ZCk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJDb250ZXh0Ojppc0RhdGFiYXNlUmVhZE9ubHkp OgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6ZGF0YWJhc2VFeGNlZWRlZFF1b3Rh KToKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsOgorICAgICAgICAqIHdvcmtl cnMvV29ya2VyUnVuTG9vcC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJSdW5Mb29wOjpy dW5Jbk1vZGUpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyUnVuTG9vcDo6VGFzazo6cGVyZm9y bVRhc2spOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyVGhyZWFkLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OldvcmtlclRocmVhZDo6d29ya2VyVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6Oldv cmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OldvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAo V2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjppc0NsZWFudXBUYXNrKToK KyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzazo6V29ya2Vy VGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVh ZFNodXRkb3duU3RhcnRUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhy ZWFkU2h1dGRvd25TdGFydFRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6Oldv cmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjppc0NsZWFudXBUYXNrKToKKyAgICAgICAgKFdl YkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpXb3JrZXJUaHJlYWRTaHV0ZG93 blN0YXJ0VGFzayk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWQ6OnN0b3ApOgorCiAy MDEwLTAxLTA4ICBMdWl6IEFnb3N0aW5pICA8bHVpei5hZ29zdGluaUBvcGVuYm9zc2Eub3JnPgog CiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuLgpJbmRleDog V2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhET01XaW5kb3dDdXN0b20uY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcAko cmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERPTVdpbmRv d0N1c3RvbS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMzLDYgKzMzLDkgQEAKIAogI2luY2x1ZGUg IkJhc2U2NC5oIgogI2luY2x1ZGUgIkNocm9tZS5oIgorI2lmIEVOQUJMRShEQVRBQkFTRSkKKyNp bmNsdWRlICJEYXRhYmFzZS5oIgorI2VuZGlmCiAjaW5jbHVkZSAiRE9NVGltZXIuaCIKICNpbmNs dWRlICJET01XaW5kb3cuaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCkBAIC0yOTUsNyAr Mjk4LDcgQEAgYm9vbCBWOERPTVdpbmRvdzo6V2ViU29ja2V0RW5hYmxlZCgpCiAjaWYgRU5BQkxF KERBVEFCQVNFKQogYm9vbCBWOERPTVdpbmRvdzo6T3BlbkRhdGFiYXNlRW5hYmxlZCgpCiB7Ci0g ICAgcmV0dXJuIFdlYkNvcmU6OlJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmRhdGFiYXNlRW5hYmxl ZCgpOworICAgIHJldHVybiBEYXRhYmFzZTo6aXNBdmFpbGFibGUoKTsKIH0KICNlbmRpZgogCklu ZGV4OiBXZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20v RG9jdW1lbnQuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvZG9tL0RvY3VtZW50LmNw cAkod29ya2luZyBjb3B5KQpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIkNTdHJpbmcuaCIK ICNpbmNsdWRlICJDYWNoZWRDU1NTdHlsZVNoZWV0LmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCisj aW5jbHVkZSAiQ2hyb21lQ2xpZW50LmgiCiAjaW5jbHVkZSAiQ29tbWVudC5oIgogI2luY2x1ZGUg IkNvbnNvbGUuaCIKICNpbmNsdWRlICJDb29raWVKYXIuaCIKQEAgLTEzNywxMSArMTM4LDYgQEAK ICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMu aD4KIAotI2lmIEVOQUJMRShEQVRBQkFTRSkKLSNpbmNsdWRlICJEYXRhYmFzZS5oIgotI2luY2x1 ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCi0jZW5kaWYKLQogI2lmIEVOQUJMRShTSEFSRURfV09SS0VS UykKICNpbmNsdWRlICJTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmgiCiAjZW5kaWYKQEAgLTM1MCw5 ICszNDYsNiBAQCBEb2N1bWVudDo6RG9jdW1lbnQoRnJhbWUqIGZyYW1lLCBib29sIGlzCiAgICAg LCBtX3VzZVNlY3VyZUtleWJvYXJkRW50cnlXaGVuQWN0aXZlKGZhbHNlKQogICAgICwgbV9pc1hI VE1MKGlzWEhUTUwpCiAgICAgLCBtX251bU5vZGVMaXN0Q2FjaGVzKDApCi0jaWYgRU5BQkxFKERB VEFCQVNFKQotICAgICwgbV9oYXNPcGVuRGF0YWJhc2VzKGZhbHNlKQotI2VuZGlmCiAgICAgLCBt X3VzaW5nR2VvbG9jYXRpb24oZmFsc2UpCiAjaWYgRU5BQkxFKFdNTCkKICAgICAsIG1fY29udGFp bnNXTUxDb250ZW50KGZhbHNlKQpAQCAtNTAwLDEzICs0OTMsNiBAQCBEb2N1bWVudDo6fkRvY3Vt ZW50KCkKICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY291bnQ7IGkrKykKICAgICAgICAg ZGVsZXRlQWxsVmFsdWVzKG1fbmFtZUNvbGxlY3Rpb25JbmZvW2ldKTsKIAotI2lmIEVOQUJMRShE QVRBQkFTRSkKLSAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkgewotICAgICAgICBBU1NFUlQobV9k YXRhYmFzZVRocmVhZC0+dGVybWluYXRpb25SZXF1ZXN0ZWQoKSk7Ci0gICAgICAgIG1fZGF0YWJh c2VUaHJlYWQgPSAwOwotICAgIH0KLSNlbmRpZgotCiAgICAgaWYgKG1fc3R5bGVTaGVldHMpCiAg ICAgICAgIG1fc3R5bGVTaGVldHMtPmRvY3VtZW50RGVzdHJveWVkKCk7CiB9CkBAIC00Mzk0LDYg KzQzODAsMzAgQEAgdm9pZCBEb2N1bWVudDo6c2V0U2VjdXJpdHlPcmlnaW4oU2VjdXJpdAogICAg IGluaXRETlNQcmVmZXRjaCgpOwogfQogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorCitib29sIERv Y3VtZW50Ojppc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdAoreworICAgIFBhZ2UqIHBhZ2UgPSBk b2N1bWVudCgpLT5wYWdlKCk7CisgICAgaWYgKCFwYWdlIHx8IHBhZ2UtPnNldHRpbmdzKCktPnBy aXZhdGVCcm93c2luZ0VuYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgcmV0dXJu IGZhbHNlOworfQorCit2b2lkIERvY3VtZW50OjpkYXRhYmFzZUV4Y2VlZGVkUXVvdGEoY29uc3Qg U3RyaW5nJiBuYW1lKQoreworICAgIFBhZ2UqIGN1cnJlbnRQYWdlID0gcGFnZSgpOworICAgIEFT U0VSVChjdXJyZW50UGFnZSk7CisgICAgY3VycmVudFBhZ2UtPmNocm9tZSgpLT5jbGllbnQoKS0+ ZXhjZWVkZWREYXRhYmFzZVF1b3RhKGRvY3VtZW50KCktPmZyYW1lKCksIG5hbWUpOworfQorCisj ZW5kaWYKKworYm9vbCBEb2N1bWVudDo6aXNKYXZhU2NyaXB0VGhyZWFkKCkgY29uc3QKK3sKKyAg ICByZXR1cm4gV1RGOjppc01haW5UaHJlYWQoKTsKK30KKwogdm9pZCBEb2N1bWVudDo6dXBkYXRl VVJMRm9yUHVzaE9yUmVwbGFjZVN0YXRlKGNvbnN0IEtVUkwmIHVybCkKIHsKICAgICBGcmFtZSog ZiA9IGZyYW1lKCk7CkBAIC00NDk0LDU3ICs0NTA0LDYgQEAgRE9NU2VsZWN0aW9uKiBEb2N1bWVu dDo6Z2V0U2VsZWN0aW9uKCkgYwogICAgIHJldHVybiBmcmFtZSgpID8gZnJhbWUoKS0+ZG9tV2lu ZG93KCktPmdldFNlbGVjdGlvbigpIDogMDsKIH0KIAotI2lmIEVOQUJMRShEQVRBQkFTRSkKLQot dm9pZCBEb2N1bWVudDo6YWRkT3BlbkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAg ICBpZiAoIW1fb3BlbkRhdGFiYXNlU2V0KQotICAgICAgICBtX29wZW5EYXRhYmFzZVNldC5zZXQo bmV3IERhdGFiYXNlU2V0KTsKLQotICAgIEFTU0VSVCghbV9vcGVuRGF0YWJhc2VTZXQtPmNvbnRh aW5zKGRhdGFiYXNlKSk7Ci0gICAgbV9vcGVuRGF0YWJhc2VTZXQtPmFkZChkYXRhYmFzZSk7Ci19 Ci0KLXZvaWQgRG9jdW1lbnQ6OnJlbW92ZU9wZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2Up Ci17Ci0gICAgQVNTRVJUKG1fb3BlbkRhdGFiYXNlU2V0ICYmIG1fb3BlbkRhdGFiYXNlU2V0LT5j b250YWlucyhkYXRhYmFzZSkpOwotICAgIGlmICghbV9vcGVuRGF0YWJhc2VTZXQpCi0gICAgICAg IHJldHVybjsKLSAgICAgICAgCi0gICAgbV9vcGVuRGF0YWJhc2VTZXQtPnJlbW92ZShkYXRhYmFz ZSk7Ci19Ci0KLURhdGFiYXNlVGhyZWFkKiBEb2N1bWVudDo6ZGF0YWJhc2VUaHJlYWQoKQotewot ICAgIGlmICghbV9kYXRhYmFzZVRocmVhZCAmJiAhbV9oYXNPcGVuRGF0YWJhc2VzKSB7Ci0gICAg ICAgIC8vIENyZWF0ZSB0aGUgZGF0YWJhc2UgdGhyZWFkIG9uIGZpcnN0IHJlcXVlc3QgLSBidXQg bm90IGlmIGF0IGxlYXN0IG9uZSBkYXRhYmFzZSB3YXMgYWxyZWFkeSBvcGVuZWQsCi0gICAgICAg IC8vIGJlY2F1c2UgaW4gdGhhdCBjYXNlIHdlIGFscmVhZHkgaGFkIGEgZGF0YWJhc2UgdGhyZWFk IGFuZCB0ZXJtaW5hdGVkIGl0IGFuZCBzaG91bGQgbm90IGNyZWF0ZSBhbm90aGVyLgotICAgICAg ICBtX2RhdGFiYXNlVGhyZWFkID0gRGF0YWJhc2VUaHJlYWQ6OmNyZWF0ZSgpOwotICAgICAgICBp ZiAoIW1fZGF0YWJhc2VUaHJlYWQtPnN0YXJ0KCkpCi0gICAgICAgICAgICBtX2RhdGFiYXNlVGhy ZWFkID0gMDsKLSAgICB9Ci0KLSAgICByZXR1cm4gbV9kYXRhYmFzZVRocmVhZC5nZXQoKTsKLX0K LQotdm9pZCBEb2N1bWVudDo6c3RvcERhdGFiYXNlcygpCi17Ci0gICAgaWYgKG1fb3BlbkRhdGFi YXNlU2V0KSB7Ci0gICAgICAgIERhdGFiYXNlU2V0OjppdGVyYXRvciBpID0gbV9vcGVuRGF0YWJh c2VTZXQtPmJlZ2luKCk7Ci0gICAgICAgIERhdGFiYXNlU2V0OjppdGVyYXRvciBlbmQgPSBtX29w ZW5EYXRhYmFzZVNldC0+ZW5kKCk7Ci0gICAgICAgIGZvciAoOyBpICE9IGVuZDsgKytpKSB7Ci0g ICAgICAgICAgICAoKmkpLT5zdG9wKCk7Ci0gICAgICAgICAgICBpZiAobV9kYXRhYmFzZVRocmVh ZCkKLSAgICAgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFkLT51bnNjaGVkdWxlRGF0YWJhc2VU YXNrcygqaSk7Ci0gICAgICAgIH0KLSAgICB9Ci0gICAgCi0gICAgaWYgKG1fZGF0YWJhc2VUaHJl YWQpCi0gICAgICAgIG1fZGF0YWJhc2VUaHJlYWQtPnJlcXVlc3RUZXJtaW5hdGlvbigpOwotfQot Ci0jZW5kaWYKLQogI2lmIEVOQUJMRShXTUwpCiB2b2lkIERvY3VtZW50OjpyZXNldFdNTFBhZ2VT dGF0ZSgpCiB7CkluZGV4OiBXZWJDb3JlL2RvbS9Eb2N1bWVudC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvZG9tL0RvY3VtZW50LmgJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9kb20vRG9j dW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtNDM3LDcgKzQzNyw3IEBAIHB1YmxpYzoKIAogICAg IEZyYW1lVmlldyogdmlldygpIGNvbnN0OyAvLyBjYW4gYmUgTlVMTAogICAgIEZyYW1lKiBmcmFt ZSgpIGNvbnN0IHsgcmV0dXJuIG1fZnJhbWU7IH0gLy8gY2FuIGJlIE5VTEwKLSAgICBQYWdlKiBw YWdlKCkgY29uc3Q7IC8vIGNhbiBiZSBOVUxMCisgICAgdmlydHVhbCBQYWdlKiBwYWdlKCkgY29u c3Q7IC8vIGNhbiBiZSBOVUxMCiAgICAgU2V0dGluZ3MqIHNldHRpbmdzKCkgY29uc3Q7IC8vIGNh biBiZSBOVUxMCiAjaWYgRU5BQkxFKElOU1BFQ1RPUikKICAgICBJbnNwZWN0b3JUaW1lbGluZUFn ZW50KiBpbnNwZWN0b3JUaW1lbGluZUFnZW50KCkgY29uc3Q7IC8vIGNhbiBiZSBOVUxMCkBAIC05 MTQsMTQgKzkxNCwxMiBAQCBwdWJsaWM6CiAgICAgYm9vbCBwcm9jZXNzaW5nTG9hZEV2ZW50KCkg Y29uc3QgeyByZXR1cm4gbV9wcm9jZXNzaW5nTG9hZEV2ZW50OyB9CiAKICNpZiBFTkFCTEUoREFU QUJBU0UpCi0gICAgdm9pZCBhZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqKTsKLSAgICB2b2lkIHJl bW92ZU9wZW5EYXRhYmFzZShEYXRhYmFzZSopOwotICAgIERhdGFiYXNlVGhyZWFkKiBkYXRhYmFz ZVRocmVhZCgpOyAgIC8vIENyZWF0ZXMgdGhlIHRocmVhZCBhcyBuZWVkZWQsIGJ1dCBub3QgaWYg aXQgaGFzIGJlZW4gYWxyZWFkeSB0ZXJtaW5hdGVkLgotICAgIHZvaWQgc2V0SGFzT3BlbkRhdGFi YXNlcygpIHsgbV9oYXNPcGVuRGF0YWJhc2VzID0gdHJ1ZTsgfQotICAgIGJvb2wgaGFzT3BlbkRh dGFiYXNlcygpIHsgcmV0dXJuIG1faGFzT3BlbkRhdGFiYXNlczsgfQotICAgIHZvaWQgc3RvcERh dGFiYXNlcygpOworICAgIHZpcnR1YWwgYm9vbCBpc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdDsK KyAgICB2aXJ0dWFsIHZvaWQgZGF0YWJhc2VFeGNlZWRlZFF1b3RhKGNvbnN0IFN0cmluZyYgbmFt ZSk7CiAjZW5kaWYKIAorICAgIHZpcnR1YWwgYm9vbCBpc0phdmFTY3JpcHRUaHJlYWQoKSBjb25z dDsKKwogICAgIHZvaWQgc2V0VXNpbmdHZW9sb2NhdGlvbihib29sIGYpIHsgbV91c2luZ0dlb2xv Y2F0aW9uID0gZjsgfQogICAgIGJvb2wgdXNpbmdHZW9sb2NhdGlvbigpIGNvbnN0IHsgcmV0dXJu IG1fdXNpbmdHZW9sb2NhdGlvbjsgfTsKIApAQCAtMTE4MywxMyArMTE4MSw2IEBAIHByaXZhdGU6 CiAgICAgSlNXcmFwcGVyQ2FjaGVNYXAgbV93cmFwcGVyQ2FjaGVNYXA7CiAjZW5kaWYKIAotI2lm IEVOQUJMRShEQVRBQkFTRSkKLSAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fZGF0YWJhc2VU aHJlYWQ7Ci0gICAgYm9vbCBtX2hhc09wZW5EYXRhYmFzZXM7ICAgIC8vIFRoaXMgbmV2ZXIgY2hh bmdlcyBiYWNrIHRvIGZhbHNlLCBldmVuIGFzIHRoZSBkYXRhYmFzZSB0aHJlYWQgaXMgY2xvc2Vk LgotICAgIHR5cGVkZWYgSGFzaFNldDxEYXRhYmFzZSo+IERhdGFiYXNlU2V0OwotICAgIE93blB0 cjxEYXRhYmFzZVNldD4gbV9vcGVuRGF0YWJhc2VTZXQ7Ci0jZW5kaWYKLSAgICAKICAgICBib29s IG1fdXNpbmdHZW9sb2NhdGlvbjsKIAogI2lmIEVOQUJMRShXTUwpCkluZGV4OiBXZWJDb3JlL2Rv bS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9T Y3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL2Rv bS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjgsNyArMjgs OCBAQAogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKIAogI2luY2x1ZGUgIkFj dGl2ZURPTU9iamVjdC5oIgotI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRGF0YWJh c2VUYXNrLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKICNpbmNsdWRlICJNZXNzYWdl UG9ydC5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiV29ya2VyQ29u dGV4dC5oIgpAQCAtNTYsNiArNTcsOSBAQCBwdWJsaWM6CiB9OwogCiBTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KCkKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisg ICAgOiBtX2hhc09wZW5EYXRhYmFzZXMoZmFsc2UpCisjZW5kaWYKIHsKIH0KIApAQCAtNzIsOCAr NzYsNjQgQEAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6flNjcmlwdEV4ZWN1dGlvbgogICAgICAg ICBBU1NFUlQoKCppdGVyKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpID09IHRoaXMpOwogICAg ICAgICAoKml0ZXIpLT5jb250ZXh0RGVzdHJveWVkKCk7CiAgICAgfQorICAgIGlmIChtX2RhdGFi YXNlVGhyZWFkKSB7CisgICAgICAgIEFTU0VSVChtX2RhdGFiYXNlVGhyZWFkLT50ZXJtaW5hdGlv blJlcXVlc3RlZCgpKTsKKyAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IDA7CisgICAgfQogfQog CisjaWYgRU5BQkxFKERBVEFCQVNFKQorCitEYXRhYmFzZVRocmVhZCogU2NyaXB0RXhlY3V0aW9u Q29udGV4dDo6ZGF0YWJhc2VUaHJlYWQoKQoreworICAgIGlmICghbV9kYXRhYmFzZVRocmVhZCAm JiAhbV9oYXNPcGVuRGF0YWJhc2VzKSB7CisgICAgICAgIC8vIENyZWF0ZSB0aGUgZGF0YWJhc2Ug dGhyZWFkIG9uIGZpcnN0IHJlcXVlc3QgLSBidXQgbm90IGlmIGF0IGxlYXN0IG9uZSBkYXRhYmFz ZSB3YXMgYWxyZWFkeSBvcGVuZWQsCisgICAgICAgIC8vIGJlY2F1c2UgaW4gdGhhdCBjYXNlIHdl IGFscmVhZHkgaGFkIGEgZGF0YWJhc2UgdGhyZWFkIGFuZCB0ZXJtaW5hdGVkIGl0IGFuZCBzaG91 bGQgbm90IGNyZWF0ZSBhbm90aGVyLgorICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0gRGF0YWJh c2VUaHJlYWQ6OmNyZWF0ZSgpOworICAgICAgICBpZiAoIW1fZGF0YWJhc2VUaHJlYWQtPnN0YXJ0 KCkpCisgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0gMDsKKyAgICB9CisKKyAgICByZXR1 cm4gbV9kYXRhYmFzZVRocmVhZC5nZXQoKTsKK30KKwordm9pZCBTY3JpcHRFeGVjdXRpb25Db250 ZXh0OjphZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIGlmICghbV9v cGVuRGF0YWJhc2VTZXQpCisgICAgICAgIG1fb3BlbkRhdGFiYXNlU2V0LnNldChuZXcgRGF0YWJh c2VTZXQoKSk7CisKKyAgICBBU1NFUlQoIW1fb3BlbkRhdGFiYXNlU2V0LT5jb250YWlucyhkYXRh YmFzZSkpOworICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5hZGQoZGF0YWJhc2UpOworfQorCit2b2lk IFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9wZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0 YWJhc2UpCit7CisgICAgQVNTRVJUKG1fb3BlbkRhdGFiYXNlU2V0ICYmIG1fb3BlbkRhdGFiYXNl U2V0LT5jb250YWlucyhkYXRhYmFzZSkpOworICAgIGlmICghbV9vcGVuRGF0YWJhc2VTZXQpCisg ICAgICAgIHJldHVybjsKKyAgICBtX29wZW5EYXRhYmFzZVNldC0+cmVtb3ZlKGRhdGFiYXNlKTsK K30KKwordm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdG9wRGF0YWJhc2VzKERhdGFiYXNl VGFza1N5bmNocm9uaXplciAqY2xlYW51cFN5bmMpCit7CisgICAgaWYgKG1fb3BlbkRhdGFiYXNl U2V0KSB7CisgICAgICAgIERhdGFiYXNlU2V0OjppdGVyYXRvciBpID0gbV9vcGVuRGF0YWJhc2VT ZXQtPmJlZ2luKCk7CisgICAgICAgIERhdGFiYXNlU2V0OjppdGVyYXRvciBlbmQgPSBtX29wZW5E YXRhYmFzZVNldC0+ZW5kKCk7CisgICAgICAgIGZvciAoOyBpICE9IGVuZDsgKytpKSB7CisgICAg ICAgICAgICAoKmkpLT5zdG9wKCk7CisgICAgICAgICAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkK KyAgICAgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFkLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNr cygqaSk7CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQp CisgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQtPnJlcXVlc3RUZXJtaW5hdGlvbihjbGVhbnVwU3lu Yyk7CisgICAgZWxzZSBpZiAoY2xlYW51cFN5bmMpCisgICAgICAgIGNsZWFudXBTeW5jLT50YXNr Q29tcGxldGVkKCk7Cit9CisKKyNlbmRpZgorCiB2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OnByb2Nlc3NNZXNzYWdlUG9ydE1lc3NhZ2VzU29vbigpCiB7CiAgICAgcG9zdFRhc2soUHJvY2Vz c01lc3NhZ2VzU29vblRhc2s6OmNyZWF0ZSgpKTsKSW5kZXg6IFdlYkNvcmUvZG9tL1NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRp b25Db250ZXh0LmgJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0 aW9uQ29udGV4dC5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMywxMyArMzMsMTggQEAKICNpbmNsdWRl IDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CiAjaW5jbHVkZSA8 d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3Rm L1RocmVhZGluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICBjbGFzcyBBY3RpdmVE T01PYmplY3Q7CisgICAgY2xhc3MgRGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNrU3lu Y2hyb25pemVyOworICAgIGNsYXNzIERhdGFiYXNlVGhyZWFkOwogICAgIGNsYXNzIERPTVRpbWVy OwogICAgIGNsYXNzIE1lc3NhZ2VQb3J0OworICAgIGNsYXNzIFBhZ2U7CiAgICAgY2xhc3MgU2Vj dXJpdHlPcmlnaW47CiAgICAgY2xhc3MgU2NyaXB0U3RyaW5nOwogICAgIGNsYXNzIFN0cmluZzsK QEAgLTU5LDYgKzY0LDIwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCBi b29sIGlzRG9jdW1lbnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICB2aXJ0dWFs IGJvb2wgaXNXb3JrZXJDb250ZXh0KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KIAorI2lmIEVO QUJMRShEQVRBQkFTRSkKKyAgICAgICAgdmlydHVhbCBib29sIGlzRGF0YWJhc2VSZWFkT25seSgp IGNvbnN0ID0gMDsKKyAgICAgICAgdmlydHVhbCB2b2lkIGRhdGFiYXNlRXhjZWVkZWRRdW90YShj b25zdCBTdHJpbmcmIG5hbWUpID0gMDsKKyAgICAgICAgRGF0YWJhc2VUaHJlYWQgKmRhdGFiYXNl VGhyZWFkKCk7CisgICAgICAgIHZvaWQgc2V0SGFzT3BlbkRhdGFiYXNlcygpIHsgbV9oYXNPcGVu RGF0YWJhc2VzID0gdHJ1ZTsgfQorICAgICAgICBib29sIGhhc09wZW5EYXRhYmFzZXMoKSBjb25z dCB7IHJldHVybiBtX2hhc09wZW5EYXRhYmFzZXM7IH0KKyAgICAgICAgdm9pZCBhZGRPcGVuRGF0 YWJhc2UoRGF0YWJhc2UqKTsKKyAgICAgICAgdm9pZCByZW1vdmVPcGVuRGF0YWJhc2UoRGF0YWJh c2UqKTsKKyAgICAgICAgLy8gV2hlbiB0aGUgZGF0YWJhc2UgY2xlYW51cCBpcyBkb25lLCBjbGVh bnVwU3luYyB3aWxsIGJlIHNpZ25hbGxlZC4KKyAgICAgICAgdm9pZCBzdG9wRGF0YWJhc2VzKERh dGFiYXNlVGFza1N5bmNocm9uaXplciAqY2xlYW51cFN5bmMpOworI2VuZGlmCisgICAgICAgIHZp cnR1YWwgYm9vbCBpc0phdmFTY3JpcHRUaHJlYWQoKSBjb25zdCA9IDA7CisgICAgICAgIHZpcnR1 YWwgUGFnZSAqcGFnZSgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KKwogICAgICAgICBjb25zdCBLVVJM JiB1cmwoKSBjb25zdCB7IHJldHVybiB2aXJ0dWFsVVJMKCk7IH0KICAgICAgICAgS1VSTCBjb21w bGV0ZVVSTChjb25zdCBTdHJpbmcmIHVybCkgY29uc3QgeyByZXR1cm4gdmlydHVhbENvbXBsZXRl VVJMKHVybCk7IH0KIApAQCAtOTcsNiArMTE2LDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg ICAgICBwdWJsaWM6CiAgICAgICAgICAgICB2aXJ0dWFsIH5UYXNrKCk7CiAgICAgICAgICAgICB2 aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopID0gMDsKKyAg ICAgICAgICAgIC8vIENlcnRhaW4gdGFza3MgZ2V0IG1hcmtlZCBzcGVjaWFsbHkgc28gdGhhdCB3 ZSBkb24ndCBmb3JnZXQgdG8gcnVuCisgICAgICAgICAgICAvLyB0aGVtIHdoaWxlIHNodXR0aW5n IGRvd24uCisgICAgICAgICAgICB2aXJ0dWFsIGJvb2wgaXNDbGVhbnVwVGFzaygpIGNvbnN0IHsg cmV0dXJuIGZhbHNlOyB9CiAgICAgICAgIH07CiAKICAgICAgICAgdmlydHVhbCB2b2lkIHBvc3RU YXNrKFBhc3NPd25QdHI8VGFzaz4pID0gMDsgLy8gRXhlY3V0ZXMgdGhlIHRhc2sgb24gY29udGV4 dCdzIHRocmVhZCBhc3luY2hyb25vdXNseS4KQEAgLTEyOSw2ICsxNTEsMTMgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogCiAgICAgICAgIHZpcnR1YWwgdm9pZCByZWZTY3JpcHRFeGVjdXRpb25Db250 ZXh0KCkgPSAwOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGVyZWZTY3JpcHRFeGVjdXRpb25Db250 ZXh0KCkgPSAwOworCisjaWYgRU5BQkxFKERBVEFCQVNFKQorICAgICAgICBSZWZQdHI8RGF0YWJh c2VUaHJlYWQ+IG1fZGF0YWJhc2VUaHJlYWQ7CisgICAgICAgIGJvb2wgbV9oYXNPcGVuRGF0YWJh c2VzOyAvLyBUaGlzIG5ldmVyIGNoYW5nZXMgYmFjayB0byBmYWxzZSwgZXZlbiBhZnRlciB0aGUg ZGF0YWJhc2UgdGhyZWFkIGlzIGNsb3NlZC4KKyAgICAgICAgdHlwZWRlZiBIYXNoU2V0PERhdGFi YXNlICo+IERhdGFiYXNlU2V0OworICAgICAgICBPd25QdHI8RGF0YWJhc2VTZXQ+IG1fb3BlbkRh dGFiYXNlU2V0OworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRl eDogV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv bG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL2xvYWRl ci9GcmFtZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU1OSw3ICs1NTksNyBAQCB2b2lk IEZyYW1lTG9hZGVyOjpzdG9wTG9hZGluZyhVbmxvYWRFdmVuCiAKICNpZiBFTkFCTEUoREFUQUJB U0UpCiAgICAgICAgIGlmIChkYXRhYmFzZVBvbGljeSA9PSBEYXRhYmFzZVBvbGljeVN0b3ApCi0g ICAgICAgICAgICBkb2MtPnN0b3BEYXRhYmFzZXMoKTsKKyAgICAgICAgICAgIGRvYy0+c3RvcERh dGFiYXNlcygwKTsKICNlbHNlCiAgICAgVU5VU0VEX1BBUkFNKGRhdGFiYXNlUG9saWN5KTsKICNl bmRpZgpAQCAtMTUwNyw2ICsxNTA3LDcgQEAgYm9vbCBGcmFtZUxvYWRlcjo6Y2FuQ2FjaGVQYWdl Q29udGFpbmluZwogICAgICAgICAmJiAhbV9VUkwucHJvdG9jb2xJcygiaHR0cHMiKQogICAgICAg ICAmJiAoIW1fZnJhbWUtPmRvbVdpbmRvdygpIHx8ICFtX2ZyYW1lLT5kb21XaW5kb3coKS0+aGFz RXZlbnRMaXN0ZW5lcnMoZXZlbnROYW1lcygpLnVubG9hZEV2ZW50KSkKICNpZiBFTkFCTEUoREFU QUJBU0UpCisgICAgICAgIC8vIFRPRE8oZXJpY3UpOiBBbnl0aGluZyBhYm91dCB3b3JrZXIgZGF0 YWJhc2VzIGhlcmU/CiAgICAgICAgICYmICFtX2ZyYW1lLT5kb2N1bWVudCgpLT5oYXNPcGVuRGF0 YWJhc2VzKCkKICNlbmRpZgogI2lmIEVOQUJMRShTSEFSRURfV09SS0VSUykKQEAgLTE2NTIsNyAr MTY1Myw3IEBAIGJvb2wgRnJhbWVMb2FkZXI6OmxvZ0NhbkNhY2hlRnJhbWVEZWNpc2kKICAgICAg ICAgICAgIHsgUENMT0coIiAgIC1GcmFtZSBpcyBIVFRQUyIpOyBjYW5ub3RDYWNoZSA9IHRydWU7 IH0KICAgICAgICAgaWYgKG1fZnJhbWUtPmRvbVdpbmRvdygpICYmIG1fZnJhbWUtPmRvbVdpbmRv dygpLT5oYXNFdmVudExpc3RlbmVycyhldmVudE5hbWVzKCkudW5sb2FkRXZlbnQpKQogICAgICAg ICAgICAgeyBQQ0xPRygiICAgLUZyYW1lIGhhcyBhbiB1bmxvYWQgZXZlbnQgbGlzdGVuZXIiKTsg Y2Fubm90Q2FjaGUgPSB0cnVlOyB9Ci0jaWYgRU5BQkxFKERBVEFCQVNFKQorI2lmIEVOQUJMRShE QVRBQkFTRSkgLy8gVE9ETyhlcmljdSk6IExpa2V3aXNlLCBhbnl0aGluZyBhYm91dCB3b3JrZXIg ZGF0YWJhc2VzPwogICAgICAgICBpZiAobV9mcmFtZS0+ZG9jdW1lbnQoKS0+aGFzT3BlbkRhdGFi YXNlcygpKQogICAgICAgICAgICAgeyBQQ0xPRygiICAgLUZyYW1lIGhhcyBvcGVuIGRhdGFiYXNl IGhhbmRsZXMiKTsgY2Fubm90Q2FjaGUgPSB0cnVlOyB9CiAjZW5kaWYKSW5kZXg6IFdlYkNvcmUv c3RvcmFnZS9EYXRhYmFzZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFi YXNlLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC00MSw3ICs0MSw2IEBACiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIK ICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKLSNpbmNsdWRl ICJJbnNwZWN0b3JDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgogI2luY2x1ZGUg Ik5vdEltcGxlbWVudGVkLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgpAQCAtNTMsOSArNTIsMTMgQEAK ICNpbmNsdWRlICJTUUxSZXN1bHRTZXQuaCIKICNpbmNsdWRlICJTUUxUcmFuc2FjdGlvbkNsaWVu dC5oIgogI2luY2x1ZGUgIlNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaCIKLSNpbmNsdWRlIDx3 dGYvTWFpblRocmVhZC5oPgorCisjaWYgRU5BQkxFKElOU1BFQ1RPUikKKyNpbmNsdWRlICJJbnNw ZWN0b3JDb250cm9sbGVyLmgiCiAjZW5kaWYKIAorI2VuZGlmIC8vIEVOQUJMRShEQVRBQkFTRSkK KwogI2lmIFVTRShKU0MpCiAjaW5jbHVkZSAiSlNET01XaW5kb3cuaCIKICNlbmRpZgpAQCAtNzMs NiArNzYsMTggQEAgY29uc3QgU3RyaW5nJiBEYXRhYmFzZTo6ZGF0YWJhc2VJbmZvVGFibAogCiAj aWYgRU5BQkxFKERBVEFCQVNFKQogCitzdGF0aWMgYm9vbCBpc0RhdGFiYXNlQXZhaWxhYmxlID0g ZmFsc2U7CisKK3ZvaWQgRGF0YWJhc2U6OnNldElzQXZhaWxhYmxlKGJvb2wgYXZhaWxhYmxlKQor eworICAgIGlzRGF0YWJhc2VBdmFpbGFibGUgPSBhdmFpbGFibGU7Cit9CisKK2Jvb2wgRGF0YWJh c2U6OmlzQXZhaWxhYmxlKCkKK3sKKyAgICByZXR1cm4gaXNEYXRhYmFzZUF2YWlsYWJsZTsKK30K Kwogc3RhdGljIE11dGV4JiBndWlkTXV0ZXgoKQogewogICAgIC8vIE5vdGU6IFdlIGRvbid0IGhh dmUgdG8gdXNlIEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyBoZXJlIGJlY2F1c2UKQEAgLTEy MCwzOSArMTM1LDM4IEBAIHN0YXRpYyBjb25zdCBTdHJpbmcmIGRhdGFiYXNlVmVyc2lvbktleSgK IAogc3RhdGljIGludCBndWlkRm9yT3JpZ2luQW5kTmFtZShjb25zdCBTdHJpbmcmIG9yaWdpbiwg Y29uc3QgU3RyaW5nJiBuYW1lKTsKIAotUGFzc1JlZlB0cjxEYXRhYmFzZT4gRGF0YWJhc2U6Om9w ZW5EYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3Qg U3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2ln bmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZSkKK1Bhc3NSZWZQdHI8RGF0 YWJhc2U+IERhdGFiYXNlOjpvcGVuRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29u dGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwg Y29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBF eGNlcHRpb25Db2RlJiBlKQogewotICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCku Y2FuRXN0YWJsaXNoRGF0YWJhc2UoZG9jdW1lbnQsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0 ZWRTaXplKSkgeworICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0YWJs aXNoRGF0YWJhc2UoY29udGV4dCwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKSB7 CiAgICAgICAgIC8vIEZJWE1FOiBUaGVyZSBzaG91bGQgYmUgYW4gZXhjZXB0aW9uIHJhaXNlZCBo ZXJlIGluIGFkZGl0aW9uIHRvIHJldHVybmluZyBhIG51bGwgRGF0YWJhc2Ugb2JqZWN0LiAgVGhl IHF1ZXN0aW9uIGhhcyBiZWVuIHJhaXNlZCB3aXRoIHRoZSBXSEFUV0cuCi0gICAgICAgIExPRyhT dG9yYWdlQVBJLCAiRGF0YWJhc2UgJXMgZm9yIG9yaWdpbiAlcyBub3QgYWxsb3dlZCB0byBiZSBl c3RhYmxpc2hlZCIsIG5hbWUuYXNjaWkoKS5kYXRhKCksIGRvY3VtZW50LT5zZWN1cml0eU9yaWdp bigpLT50b1N0cmluZygpLmFzY2lpKCkuZGF0YSgpKTsKKyAgICAgICAgTE9HKFN0b3JhZ2VBUEks ICJEYXRhYmFzZSAlcyBmb3Igb3JpZ2luICVzIG5vdCBhbGxvd2VkIHRvIGJlIGVzdGFibGlzaGVk IiwgbmFtZS5hc2NpaSgpLmRhdGEoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJp bmcoKS5hc2NpaSgpLmRhdGEoKSk7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIFJl ZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2UgPSBhZG9wdFJlZihuZXcgRGF0YWJhc2UoZG9jdW1lbnQs IG5hbWUsIGV4cGVjdGVkVmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKKyAg ICBSZWZQdHI8RGF0YWJhc2U+IGRhdGFiYXNlID0gYWRvcHRSZWYobmV3IERhdGFiYXNlKGNvbnRl eHQsIG5hbWUsIGV4cGVjdGVkVmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsK IAogICAgIGlmICghZGF0YWJhc2UtPm9wZW5BbmRWZXJpZnlWZXJzaW9uKGUpKSB7CiAgICAgICAg IExPRyhTdG9yYWdlQVBJLCAiRmFpbGVkIHRvIG9wZW4gYW5kIHZlcmlmeSB2ZXJzaW9uIChleHBl Y3RlZCAlcykgb2YgZGF0YWJhc2UgJXMiLCBleHBlY3RlZFZlcnNpb24uYXNjaWkoKS5kYXRhKCks IGRhdGFiYXNlLT5kYXRhYmFzZURlYnVnTmFtZSgpLmFzY2lpKCkuZGF0YSgpKTsKLSAgICAgICAg ZG9jdW1lbnQtPnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CisgICAgICAgIGNv bnRleHQtPnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAgIERhdGFi YXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7 CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tl cigpLnNldERhdGFiYXNlRGV0YWlscyhkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwg ZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpOwotCi0gICAgZG9jdW1lbnQtPnNldEhhc09wZW5E YXRhYmFzZXMoKTsKKyAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5zZXREYXRhYmFzZURl dGFpbHMoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGlt YXRlZFNpemUpOwogCisgICAgZGF0YWJhc2UtPmV4ZWN1dGlvbkNvbnRleHQoKS0+c2V0SGFzT3Bl bkRhdGFiYXNlcygpOwogI2lmIEVOQUJMRShJTlNQRUNUT1IpCi0gICAgaWYgKFBhZ2UqIHBhZ2Ug PSBkb2N1bWVudC0+ZnJhbWUoKS0+cGFnZSgpKQotICAgICAgICBwYWdlLT5pbnNwZWN0b3JDb250 cm9sbGVyKCktPmRpZE9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSwgZG9jdW1lbnQtPnNlY3Vy aXR5T3JpZ2luKCktPmhvc3QoKSwgbmFtZSwgZXhwZWN0ZWRWZXJzaW9uKTsKKyAgICBpZiAoUGFn ZSogcGFnZSA9IGRhdGFiYXNlLT5leGVjdXRpb25Db250ZXh0KCktPnBhZ2UoKSkKKyAgICAgICAg cGFnZS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLT5kaWRPcGVuRGF0YWJhc2UoZGF0YWJhc2UuZ2V0 KCksIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmhvc3QoKSwgbmFtZSwgZXhwZWN0ZWRWZXJz aW9uKTsKICNlbmRpZgogCiAgICAgcmV0dXJuIGRhdGFiYXNlOwogfQogCi1EYXRhYmFzZTo6RGF0 YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmlu ZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUpCitEYXRhYmFzZTo6RGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCAqY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVk VmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0 ZWRTaXplKQogICAgIDogbV90cmFuc2FjdGlvbkluUHJvZ3Jlc3MoZmFsc2UpCiAgICAgLCBtX2lz VHJhbnNhY3Rpb25RdWV1ZUVuYWJsZWQodHJ1ZSkKLSAgICAsIG1fZG9jdW1lbnQoZG9jdW1lbnQp CisgICAgLCBtX2V4ZWN1dGlvbkNvbnRleHQoY29udGV4dCkKICAgICAsIG1fbmFtZShuYW1lLmNy b3NzVGhyZWFkU3RyaW5nKCkpCiAgICAgLCBtX2d1aWQoMCkKICAgICAsIG1fZXhwZWN0ZWRWZXJz aW9uKGV4cGVjdGVkVmVyc2lvbi5jcm9zc1RocmVhZFN0cmluZygpKQpAQCAtMTYyLDE2ICsxNzYs MTUgQEAgRGF0YWJhc2U6OkRhdGFiYXNlKERvY3VtZW50KiBkb2N1bWVudCwgYwogICAgICwgbV9z dG9wcGVkKGZhbHNlKQogICAgICwgbV9vcGVuZWQoZmFsc2UpCiB7Ci0gICAgQVNTRVJUKGRvY3Vt ZW50KTsKLSAgICBtX21haW5UaHJlYWRTZWN1cml0eU9yaWdpbiA9IGRvY3VtZW50LT5zZWN1cml0 eU9yaWdpbigpOworICAgIEFTU0VSVChtX2V4ZWN1dGlvbkNvbnRleHQuZ2V0KCkpOworICAgIG1f bWFpblRocmVhZFNlY3VyaXR5T3JpZ2luID0gbV9leGVjdXRpb25Db250ZXh0LT5zZWN1cml0eU9y aWdpbigpOwogICAgIG1fZGF0YWJhc2VUaHJlYWRTZWN1cml0eU9yaWdpbiA9IG1fbWFpblRocmVh ZFNlY3VyaXR5T3JpZ2luLT50aHJlYWRzYWZlQ29weSgpOwotCiAgICAgaWYgKG1fbmFtZS5pc051 bGwoKSkKICAgICAgICAgbV9uYW1lID0gIiI7CiAKICAgICBTY3JpcHRDb250cm9sbGVyOjppbml0 aWFsaXplVGhyZWFkaW5nKCk7CiAKLSAgICBtX2d1aWQgPSBndWlkRm9yT3JpZ2luQW5kTmFtZSht X21haW5UaHJlYWRTZWN1cml0eU9yaWdpbi0+dG9TdHJpbmcoKSwgbmFtZSk7CisgICAgbV9ndWlk ID0gZ3VpZEZvck9yaWdpbkFuZE5hbWUoc2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSwgbmFt ZSk7CiAKICAgICB7CiAgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihndWlkTXV0ZXgoKSk7CkBA IC0xODUsMjggKzE5OCw1MSBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50 LCBjCiAgICAgICAgIGhhc2hTZXQtPmFkZCh0aGlzKTsKICAgICB9CiAKLSAgICBBU1NFUlQobV9k b2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSk7Ci0KLSAgICBtX2ZpbGVuYW1lID0gRGF0YWJhc2VU cmFja2VyOjp0cmFja2VyKCkuZnVsbFBhdGhGb3JEYXRhYmFzZShtX21haW5UaHJlYWRTZWN1cml0 eU9yaWdpbi5nZXQoKSwgbV9uYW1lKTsKKyAgICBtX2ZpbGVuYW1lID0gRGF0YWJhc2VUcmFja2Vy Ojp0cmFja2VyKCkuZnVsbFBhdGhGb3JEYXRhYmFzZShzZWN1cml0eU9yaWdpbigpLCBtX25hbWUp OwogCiAgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuYWRkT3BlbkRhdGFiYXNlKHRoaXMp OwotICAgIG1fZG9jdW1lbnQtPmFkZE9wZW5EYXRhYmFzZSh0aGlzKTsKKyAgICBjb250ZXh0LT5h ZGRPcGVuRGF0YWJhc2UodGhpcyk7CiB9CiAKLXN0YXRpYyB2b2lkIGRlcmVmRG9jdW1lbnQodm9p ZCogZG9jdW1lbnQpCi17Ci0gICAgc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihkb2N1bWVudCktPmRl cmVmKCk7Ci19CitjbGFzcyBEZXJlZkNvbnRleHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPERlcmVmQ29u dGV4dFRhc2s+IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0KQorICAgIHsK KyAgICAgICAgcmV0dXJuIG5ldyBEZXJlZkNvbnRleHRUYXNrKGNvbnRleHQpOworICAgIH0KKwor ICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikKKyAg ICB7CisgICAgICAgIG1fY29udGV4dC0+ZGVyZWYoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJv b2wgaXNDbGVhbnVwVGFzaygpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKworcHJpdmF0ZToKKyAg ICBleHBsaWNpdCBEZXJlZkNvbnRleHRUYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRl eHQpIDogbV9jb250ZXh0KGNvbnRleHQpCisgICAgeworICAgIH0KKworICAgIFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIG1fY29udGV4dDsKK307CiAKIERhdGFiYXNlOjp+RGF0YWJhc2UoKQogewot ICAgIC8vIERlcmVmIG1fZG9jdW1lbnQgb24gdGhlIG1haW4gdGhyZWFkLgotICAgIGNhbGxPbk1h aW5UaHJlYWQoZGVyZWZEb2N1bWVudCwgbV9kb2N1bWVudC5yZWxlYXNlKCkucmVsZWFzZVJlZigp KTsKKyAgICBpZiAoIW1fZXhlY3V0aW9uQ29udGV4dC0+aXNKYXZhU2NyaXB0VGhyZWFkKCkpIHsK KyAgICAgICAgLy8gVGhlIHJlZmVyZW5jZSB0byB0aGUgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCBu ZWVkcyB0byBiZSBjbGVhcmVkIG9uCisgICAgICAgIC8vIHRoZSBKYXZhU2NyaXB0IHRocmVhZCwg bm90IHRoZSBEYXRhYmFzZSB0aHJlYWQuICBIb3dldmVyLCBpZiB3ZSdyZQorICAgICAgICAvLyBh bHJlYWR5IG9uIHRoYXQgdGhyZWFkLCBmb3IgZXhhbXBsZSBjbGVhbmluZyB1cCBhbGwgZGF0YWJh c2VzIGR1cmluZworICAgICAgICAvLyB3b3JrZXIgdGhyZWFkIHNodXRkb3duLCB3ZSBkb24ndCB3 YW50IHRvIHBvc3QgYSB0YXNrIGJlY2F1c2UgaXQgbWlnaHQKKyAgICAgICAgLy8gaGl0IHRoZSBx dWV1ZSBhZnRlciB0aGUgV29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrIGFuZCBuZXZlciBn ZXQKKyAgICAgICAgLy8gZXhlY3V0ZWQuCisgICAgICAgIG1fZXhlY3V0aW9uQ29udGV4dC0+cG9z dFRhc2soRGVyZWZDb250ZXh0VGFzazo6Y3JlYXRlKAorICAgICAgICAgICAgbV9leGVjdXRpb25D b250ZXh0LnJlbGVhc2UoKS5yZWxlYXNlUmVmKCkpKTsKKyAgICB9CiB9CiAKIGJvb2wgRGF0YWJh c2U6Om9wZW5BbmRWZXJpZnlWZXJzaW9uKEV4Y2VwdGlvbkNvZGUmIGUpCiB7Ci0gICAgaWYgKCFt X2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKQorICAgIGlmICghbV9leGVjdXRpb25Db250ZXh0 LT5kYXRhYmFzZVRocmVhZCgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgbV9kYXRhYmFz ZUF1dGhvcml6ZXIgPSBEYXRhYmFzZUF1dGhvcml6ZXI6OmNyZWF0ZSgpOwogCkBAIC0yMTQsNyAr MjUwLDcgQEAgYm9vbCBEYXRhYmFzZTo6b3BlbkFuZFZlcmlmeVZlcnNpb24oRXhjZQogICAgIERh dGFiYXNlVGFza1N5bmNocm9uaXplciBzeW5jaHJvbml6ZXI7CiAgICAgT3duUHRyPERhdGFiYXNl T3BlblRhc2s+IHRhc2sgPSBEYXRhYmFzZU9wZW5UYXNrOjpjcmVhdGUodGhpcywgJnN5bmNocm9u aXplciwgZSwgc3VjY2Vzcyk7CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT5z Y2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgIG1fZXhlY3V0aW9uQ29u dGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFz ZSgpKTsKICAgICBzeW5jaHJvbml6ZXIud2FpdEZvclRhc2tDb21wbGV0aW9uKCk7CiAKICAgICBy ZXR1cm4gc3VjY2VzczsKQEAgLTMwOSw0MyArMzQ1LDYzIEBAIGJvb2wgRGF0YWJhc2U6OnZlcnNp b25NYXRjaGVzRXhwZWN0ZWQoKSAKIAogdm9pZCBEYXRhYmFzZTo6bWFya0FzRGVsZXRlZEFuZENs b3NlKCkKIHsKLSAgICBpZiAobV9kZWxldGVkIHx8ICFtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVh ZCgpKQorICAgIGlmIChtX2RlbGV0ZWQgfHwgIW1fZXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VU aHJlYWQoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgTE9HKFN0b3JhZ2VBUEksICJNYXJraW5n ICVzICglcCkgYXMgZGVsZXRlZCIsIHN0cmluZ0lkZW50aWZpZXIoKS5hc2NpaSgpLmRhdGEoKSwg dGhpcyk7CiAgICAgbV9kZWxldGVkID0gdHJ1ZTsKIAotICAgIGlmIChtX2RvY3VtZW50LT5kYXRh YmFzZVRocmVhZCgpLT50ZXJtaW5hdGlvblJlcXVlc3RlZCgpKSB7CisgICAgaWYgKG1fZXhlY3V0 aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+dGVybWluYXRpb25SZXF1ZXN0ZWQoKSkgewog ICAgICAgICBMT0coU3RvcmFnZUFQSSwgIkRhdGFiYXNlIGhhbmRsZSAlcCBpcyBvbiBhIHRlcm1p bmF0ZWQgRGF0YWJhc2VUaHJlYWQsIGNhbm5vdCBiZSBtYXJrZWQgZm9yIG5vcm1hbCBjbG9zdXJl XG4iLCB0aGlzKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIG1fZG9jdW1lbnQtPmRh dGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKHRoaXMpOworICAgIG1fZXhl Y3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3Mo dGhpcyk7CiAKICAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgc3luY2hyb25pemVyOwogICAg IE93blB0cjxEYXRhYmFzZUNsb3NlVGFzaz4gdGFzayA9IERhdGFiYXNlQ2xvc2VUYXNrOjpjcmVh dGUodGhpcywgJnN5bmNocm9uaXplcik7CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVh ZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgIG1fZXhlY3V0 aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2su cmVsZWFzZSgpKTsKICAgICBzeW5jaHJvbml6ZXIud2FpdEZvclRhc2tDb21wbGV0aW9uKCk7CiB9 CiAKLXN0YXRpYyB2b2lkIGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNlKHZvaWQqIGNvbnRleHQp Ci17Ci0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKLSAgICBEYXRhYmFzZSogZGF0YWJhc2Ug PSBzdGF0aWNfY2FzdDxEYXRhYmFzZSo+KGNvbnRleHQpOwotICAgIGRhdGFiYXNlLT5kb2N1bWVu dCgpLT5yZW1vdmVPcGVuRGF0YWJhc2UoZGF0YWJhc2UpOwotICAgIGRhdGFiYXNlLT5kZXJlZigp OwotfQorY2xhc3MgQ29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2sgOiBwdWJsaWMgU2NyaXB0 RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8 Q29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s+IGNyZWF0ZShEYXRhYmFzZSAqZGF0YWJhc2Up CisgICAgeworICAgICAgICByZXR1cm4gbmV3IENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNr KGRhdGFiYXNlKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCkKKyAgICB7CisgICAgICAgIEFTU0VSVChjb250ZXh0 LT5pc0phdmFTY3JpcHRUaHJlYWQoKSk7CisgICAgICAgIGNvbnRleHQtPnJlbW92ZU9wZW5EYXRh YmFzZShtX2RhdGFiYXNlKTsKKyAgICAgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucmVt b3ZlT3BlbkRhdGFiYXNlKG1fZGF0YWJhc2UpOworICAgICAgICAvLyBSZWZmZWQgaW4gRGF0YWJh c2U6OmNsb3NlKCkuCisgICAgICAgIG1fZGF0YWJhc2UtPmRlcmVmKCk7CisgICAgfQorCisgICAg dmlydHVhbCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisKK3By aXZhdGU6CisgICAgZXhwbGljaXQgQ29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2soRGF0YWJh c2UgKmRhdGFiYXNlKSA6IG1fZGF0YWJhc2UoZGF0YWJhc2UpCisgICAgeworICAgIH0KKworICAg IERhdGFiYXNlKiBtX2RhdGFiYXNlOworfTsKIAogdm9pZCBEYXRhYmFzZTo6Y2xvc2UoKQogewog ICAgIGlmICghbV9vcGVuZWQpCiAgICAgICAgIHJldHVybjsKIAotICAgIEFTU0VSVChtX2RvY3Vt ZW50LT5kYXRhYmFzZVRocmVhZCgpKTsKLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IGRv Y3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVCht X2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpOworICAgIEFTU0VSVChjdXJyZW50 VGhyZWFkKCkgPT0gbV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJl YWRJRCgpKTsKICAgICBtX3NxbGl0ZURhdGFiYXNlLmNsb3NlKCk7Ci0gICAgbV9kb2N1bWVudC0+ ZGF0YWJhc2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VDbG9zZWQodGhpcyk7CisgICAgLy8gTXVz dCByZWYoKSBiZWZvcmUgY2FsbGluZyBkYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNs b3NlZCgpLgorICAgIHJlZigpOyAvLyBkZXJlZigpIGNhbGxlZCBieSBDb250ZXh0UmVtb3ZlT3Bl bkRhdGFiYXNlVGFzay4KKyAgICBtX2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkt PnJlY29yZERhdGFiYXNlQ2xvc2VkKHRoaXMpOwogICAgIG1fb3BlbmVkID0gZmFsc2U7CiAKICAg ICB7CkBAIC0zNjIsMTEgKzQxOCw4IEBAIHZvaWQgRGF0YWJhc2U6OmNsb3NlKCkKICAgICAgICAg fQogICAgIH0KIAotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVE YXRhYmFzZVRhc2tzKHRoaXMpOwotCi0gICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucmVt b3ZlT3BlbkRhdGFiYXNlKHRoaXMpOwotICAgIHJlZigpOyAgLy8gZGVyZWYoKSBjYWxsZWQgaW4g ZG9jdW1lbnRSZW1vdmVPcGVuRGF0YWJhc2UoKQotICAgIGNhbGxPbk1haW5UaHJlYWQoZG9jdW1l bnRSZW1vdmVPcGVuRGF0YWJhc2UsIHRoaXMpOworICAgIG1fZXhlY3V0aW9uQ29udGV4dC0+ZGF0 YWJhc2VUaHJlYWQoKS0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3ModGhpcyk7CisgICAgbV9leGVj dXRpb25Db250ZXh0LT5wb3N0VGFzayhDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6Y3Jl YXRlKHRoaXMpKTsKIH0KIAogdm9pZCBEYXRhYmFzZTo6c3RvcCgpCkBAIC01MzIsOCArNTg1LDgg QEAgYm9vbCBEYXRhYmFzZTo6cGVyZm9ybU9wZW5BbmRWZXJpZnkoRXhjZQogICAgIC8vIEFsbCBj aGVja3MgcGFzc2VkIGFuZCB3ZSBzdGlsbCBoYXZlIGEgaGFuZGxlIHRvIHRoaXMgZGF0YWJhc2Ug ZmlsZS4KICAgICAvLyBNYWtlIHN1cmUgRGF0YWJhc2VUaHJlYWQgY2xvc2VzIGl0IHdoZW4gRGF0 YWJhc2VUaHJlYWQgZ29lcyBhd2F5LgogICAgIG1fb3BlbmVkID0gdHJ1ZTsKLSAgICBpZiAobV9k b2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKLSAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VU aHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VPcGVuKHRoaXMpOworICAgIGlmIChtX2V4ZWN1dGlvbkNv bnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpCisgICAgICAgIG1fZXhlY3V0aW9uQ29udGV4dC0+ZGF0 YWJhc2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VPcGVuKHRoaXMpOwogCiAgICAgcmV0dXJuIHRy dWU7CiB9CkBAIC01NjcsMzIgKzYyMCw1MyBAQCB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5z YWN0aW9uKCkKICAgICAgICAgbV90cmFuc2FjdGlvblF1ZXVlLnJlbW92ZUZpcnN0KCk7CiAgICAg fQogCi0gICAgaWYgKHRyYW5zYWN0aW9uICYmIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkp IHsKKyAgICBpZiAodHJhbnNhY3Rpb24gJiYgbV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRo cmVhZCgpKSB7CiAgICAgICAgIE93blB0cjxEYXRhYmFzZVRyYW5zYWN0aW9uVGFzaz4gdGFzayA9 IERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrOjpjcmVhdGUodHJhbnNhY3Rpb24pOwogICAgICAgICBM T0coU3RvcmFnZUFQSSwgIlNjaGVkdWxpbmcgRGF0YWJhc2VUcmFuc2FjdGlvblRhc2sgJXAgZm9y IHRyYW5zYWN0aW9uICVwXG4iLCB0YXNrLmdldCgpLCB0YXNrLT50cmFuc2FjdGlvbigpKTsKICAg ICAgICAgbV90cmFuc2FjdGlvbkluUHJvZ3Jlc3MgPSB0cnVlOwotICAgICAgICBtX2RvY3VtZW50 LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgICAg ICBtX2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0YXNr LnJlbGVhc2UoKSk7CiAgICAgfSBlbHNlCiAgICAgICAgIG1fdHJhbnNhY3Rpb25JblByb2dyZXNz ID0gZmFsc2U7CiB9CiAKIHZvaWQgRGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25TdGVwKFNR TFRyYW5zYWN0aW9uKiB0cmFuc2FjdGlvbiwgYm9vbCBpbW1lZGlhdGVseSkKIHsKLSAgICBpZiAo IW1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpCisgICAgaWYgKCFtX2V4ZWN1dGlvbkNvbnRl eHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIE93blB0cjxEYXRh YmFzZVRyYW5zYWN0aW9uVGFzaz4gdGFzayA9IERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrOjpjcmVh dGUodHJhbnNhY3Rpb24pOwogICAgIExPRyhTdG9yYWdlQVBJLCAiU2NoZWR1bGluZyBEYXRhYmFz ZVRyYW5zYWN0aW9uVGFzayAlcCBmb3IgdGhlIHRyYW5zYWN0aW9uIHN0ZXBcbiIsIHRhc2suZ2V0 KCkpOwogICAgIGlmIChpbW1lZGlhdGVseSkKLSAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VU aHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAgICAg bV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRh c2sodGFzay5yZWxlYXNlKCkpOwogICAgIGVsc2UKLSAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJh c2VUaHJlYWQoKS0+c2NoZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAgICAgbV9leGVj dXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZVRhc2sodGFzay5yZWxlYXNl KCkpOwogfQogCitjbGFzcyBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayA6IHB1YmxpYyBTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0 cjxEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzaz4gY3JlYXRlKFNRTFRyYW5zYWN0aW9uICp0cmFu c2FjdGlvbikKKyAgICB7CisgICAgICAgIHJldHVybiBuZXcgRGVsaXZlclBlbmRpbmdDYWxsYmFj a1Rhc2sodHJhbnNhY3Rpb24pOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFz ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikKKyAgICB7CisgICAgICAgIG1fdHJhbnNhY3Rpb24t PnBlcmZvcm1QZW5kaW5nQ2FsbGJhY2soKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgZXhwbGlj aXQgRGVsaXZlclBlbmRpbmdDYWxsYmFja1Rhc2soUGFzc1JlZlB0cjxTUUxUcmFuc2FjdGlvbj4g dHJhbnNhY3Rpb24pCisgICAgICAgIDogbV90cmFuc2FjdGlvbih0cmFuc2FjdGlvbikKKyAgICB7 CisgICAgfQorCisgICAgUmVmUHRyPFNRTFRyYW5zYWN0aW9uPiBtX3RyYW5zYWN0aW9uOworfTsK Kwogdm9pZCBEYXRhYmFzZTo6c2NoZWR1bGVUcmFuc2FjdGlvbkNhbGxiYWNrKFNRTFRyYW5zYWN0 aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICB0cmFuc2FjdGlvbi0+cmVmKCk7Ci0gICAgY2FsbE9u TWFpblRocmVhZChkZWxpdmVyUGVuZGluZ0NhbGxiYWNrLCB0cmFuc2FjdGlvbik7CisgICAgbV9l eGVjdXRpb25Db250ZXh0LT5wb3N0VGFzaygKKyAgICAgICAgRGVsaXZlclBlbmRpbmdDYWxsYmFj a1Rhc2s6OmNyZWF0ZSh0cmFuc2FjdGlvbikpOwogfQogCiBWZWN0b3I8U3RyaW5nPiBEYXRhYmFz ZTo6cGVyZm9ybUdldFRhYmxlTmFtZXMoKQpAQCAtNjI2LDEyICs3MDAsMTIgQEAgVmVjdG9yPFN0 cmluZz4gRGF0YWJhc2U6OnBlcmZvcm1HZXRUYWJsZQogCiBTUUxUcmFuc2FjdGlvbkNsaWVudCog RGF0YWJhc2U6OnRyYW5zYWN0aW9uQ2xpZW50KCkgY29uc3QKIHsKLSAgICByZXR1cm4gbV9kb2N1 bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+dHJhbnNhY3Rpb25DbGllbnQoKTsKKyAgICByZXR1cm4g bV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNsaWVudCgp OwogfQogCiBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiBEYXRhYmFzZTo6dHJhbnNhY3Rpb25D b29yZGluYXRvcigpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhy ZWFkKCktPnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKTsKKyAgICByZXR1cm4gbV9leGVjdXRpb25D b250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCk7CiB9CiAK IFN0cmluZyBEYXRhYmFzZTo6dmVyc2lvbigpIGNvbnN0CkBAIC02NDIsMjUgKzcxNiwxOCBAQCBT dHJpbmcgRGF0YWJhc2U6OnZlcnNpb24oKSBjb25zdAogICAgIHJldHVybiBndWlkVG9WZXJzaW9u TWFwKCkuZ2V0KG1fZ3VpZCkudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAotdm9pZCBEYXRhYmFzZTo6 ZGVsaXZlclBlbmRpbmdDYWxsYmFjayh2b2lkKiBjb250ZXh0KQotewotICAgIFNRTFRyYW5zYWN0 aW9uKiB0cmFuc2FjdGlvbiA9IHN0YXRpY19jYXN0PFNRTFRyYW5zYWN0aW9uKj4oY29udGV4dCk7 Ci0gICAgdHJhbnNhY3Rpb24tPnBlcmZvcm1QZW5kaW5nQ2FsbGJhY2soKTsKLSAgICB0cmFuc2Fj dGlvbi0+ZGVyZWYoKTsgLy8gV2FzIHJlZidkIGluIHNjaGVkdWxlVHJhbnNhY3Rpb25DYWxsYmFj aygpLgotfQotCiBWZWN0b3I8U3RyaW5nPiBEYXRhYmFzZTo6dGFibGVOYW1lcygpCiB7CiAgICAg Ly8gRklYTUU6IE5vdCB1c2luZyB0aHJlYWRzYWZlQ29weSBvbiB0aGVzZSBzdHJpbmdzIGxvb2tz IG9rIHNpbmNlIHRocmVhZHMgdGFrZSBzdHJpY3QgdHVybnMKICAgICAvLyBpbiBkZWFsaW5nIHdp dGggdGhlbS4gSG93ZXZlciwgaWYgdGhlIGNvZGUgY2hhbmdlcywgdGhpcyBtYXkgbm90IGJlIHRy dWUgYW55bW9yZS4KICAgICBWZWN0b3I8U3RyaW5nPiByZXN1bHQ7Ci0gICAgaWYgKCFtX2RvY3Vt ZW50LT5kYXRhYmFzZVRocmVhZCgpKQorICAgIGlmICghbV9leGVjdXRpb25Db250ZXh0LT5kYXRh YmFzZVRocmVhZCgpKQogICAgICAgICByZXR1cm4gcmVzdWx0OwogCiAgICAgRGF0YWJhc2VUYXNr U3luY2hyb25pemVyIHN5bmNocm9uaXplcjsKICAgICBPd25QdHI8RGF0YWJhc2VUYWJsZU5hbWVz VGFzaz4gdGFzayA9IERhdGFiYXNlVGFibGVOYW1lc1Rhc2s6OmNyZWF0ZSh0aGlzLCAmc3luY2hy b25pemVyLCByZXN1bHQpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2No ZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICBtX2V4ZWN1dGlvbkNvbnRl eHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2Uo KSk7CiAgICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOwogCiAgICAgcmV0 dXJuIHJlc3VsdDsKQEAgLTY3Niw5ICs3NDMsOSBAQCB2b2lkIERhdGFiYXNlOjpzZXRFeHBlY3Rl ZFZlcnNpb24oY29uc3QgCiAKIFNlY3VyaXR5T3JpZ2luKiBEYXRhYmFzZTo6c2VjdXJpdHlPcmln aW4oKSBjb25zdAogewotICAgIGlmIChpc01haW5UaHJlYWQoKSkKKyAgICBpZiAoZXhlY3V0aW9u Q29udGV4dCgpLT5pc0phdmFTY3JpcHRUaHJlYWQoKSkKICAgICAgICAgcmV0dXJuIG1fbWFpblRo cmVhZFNlY3VyaXR5T3JpZ2luLmdldCgpOwotICAgIGlmIChjdXJyZW50VGhyZWFkKCkgPT0gZG9j dW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSkKKyAgICBpZiAoY3VycmVu dFRocmVhZCgpID09IG1fZXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhy ZWFkSUQoKSkKICAgICAgICAgcmV0dXJuIG1fZGF0YWJhc2VUaHJlYWRTZWN1cml0eU9yaWdpbi5n ZXQoKTsKICAgICByZXR1cm4gMDsKIH0KQEAgLTcwNiw2ICs3NzMsNiBAQCBTdHJpbmcgRGF0YWJh c2U6OmZpbGVOYW1lKCkgY29uc3QKICAgICByZXR1cm4gbV9maWxlbmFtZS50aHJlYWRzYWZlQ29w eSgpOwogfQogCi0jZW5kaWYKKyNlbmRpZiAvLyBFTkFCTEUoREFUQUJBU0UpCiAKLX0KK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5oCShyZXZpc2lvbiA1Mjk5NSkKKysr IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5oCSh3b3JraW5nIGNvcHkpCkBAIC01Miw3ICs1Miw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0YWJhc2VBdXRob3JpemVyOwogY2xh c3MgRGF0YWJhc2VUaHJlYWQ7Ci1jbGFzcyBEb2N1bWVudDsKK2NsYXNzIFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ7CiBjbGFzcyBTUUxSZXN1bHRTZXQ7CiBjbGFzcyBTUUxUcmFuc2FjdGlvbkNhbGxi YWNrOwogY2xhc3MgU1FMVHJhbnNhY3Rpb25DbGllbnQ7CkBAIC02NywxMCArNjcsMTMgQEAgY2xh c3MgRGF0YWJhc2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZAogICAgIGZyaWVuZCBjbGFzcyBT UUxTdGF0ZW1lbnQ7CiAgICAgZnJpZW5kIGNsYXNzIFNRTFRyYW5zYWN0aW9uOwogcHVibGljOgor ICAgIHN0YXRpYyB2b2lkIHNldElzQXZhaWxhYmxlKGJvb2wpOworICAgIHN0YXRpYyBib29sIGlz QXZhaWxhYmxlKCk7CisKICAgICB+RGF0YWJhc2UoKTsKIAogLy8gRGlyZWN0IHN1cHBvcnQgZm9y IHRoZSBET00gQVBJCi0gICAgc3RhdGljIFBhc3NSZWZQdHI8RGF0YWJhc2U+IG9wZW5EYXRhYmFz ZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBl eHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYpOworICAgIHN0YXRpYyBQYXNzUmVmUHRyPERh dGFiYXNlPiBvcGVuRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCwgY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3Ry aW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNlcHRpb25D b2RlJik7CiAgICAgU3RyaW5nIHZlcnNpb24oKSBjb25zdDsKICAgICB2b2lkIGNoYW5nZVZlcnNp b24oY29uc3QgU3RyaW5nJiBvbGRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIG5ld1ZlcnNpb24sCiAg ICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8U1FMVHJhbnNhY3Rpb25DYWxsYmFjaz4g Y2FsbGJhY2ssIFBhc3NSZWZQdHI8U1FMVHJhbnNhY3Rpb25FcnJvckNhbGxiYWNrPiBlcnJvckNh bGxiYWNrLApAQCAtODcsNyArOTAsNyBAQCBwdWJsaWM6CiAKICAgICBWZWN0b3I8U3RyaW5nPiB0 YWJsZU5hbWVzKCk7CiAKLSAgICBEb2N1bWVudCogZG9jdW1lbnQoKSBjb25zdCB7IHJldHVybiBt X2RvY3VtZW50LmdldCgpOyB9CisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogZXhlY3V0aW9u Q29udGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fZXhlY3V0aW9uQ29udGV4dC5nZXQoKTsgfQogICAg IFNlY3VyaXR5T3JpZ2luKiBzZWN1cml0eU9yaWdpbigpIGNvbnN0OwogICAgIFN0cmluZyBzdHJp bmdJZGVudGlmaWVyKCkgY29uc3Q7CiAgICAgU3RyaW5nIGRpc3BsYXlOYW1lKCkgY29uc3Q7CkBA IC0xMjMsOCArMTI2LDkgQEAgcHVibGljOgogICAgIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3Iq IHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSBjb25zdDsKIAogcHJpdmF0ZToKLSAgICBEYXRhYmFz ZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBl eHBlY3RlZFZlcnNpb24sCi0gICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwg dW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKKyAgICBEYXRhYmFzZShTY3JpcHRFeGVjdXRp b25Db250ZXh0ICpjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsCisgICAgICAgICAgICAgY29u c3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsCisg ICAgICAgICAgICAgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKIAogICAgIGJvb2wgb3Bl bkFuZFZlcmlmeVZlcnNpb24oRXhjZXB0aW9uQ29kZSYpOwogCkBAIC0xMzksNyArMTQzLDcgQEAg cHJpdmF0ZToKIAogICAgIHN0YXRpYyB2b2lkIGRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2sodm9pZCop OwogCi0gICAgUmVmUHRyPERvY3VtZW50PiBtX2RvY3VtZW50OworICAgIFJlZlB0cjxTY3JpcHRF eGVjdXRpb25Db250ZXh0PiBtX2V4ZWN1dGlvbkNvbnRleHQ7CiAgICAgUmVmUHRyPFNlY3VyaXR5 T3JpZ2luPiBtX21haW5UaHJlYWRTZWN1cml0eU9yaWdpbjsKICAgICBSZWZQdHI8U2VjdXJpdHlP cmlnaW4+IG1fZGF0YWJhc2VUaHJlYWRTZWN1cml0eU9yaWdpbjsKICAgICBTdHJpbmcgbV9uYW1l OwpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRhc2suaAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3Jl L3N0b3JhZ2UvRGF0YWJhc2VUYXNrLmgJKHdvcmtpbmcgY29weSkKQEAgLTUwLDE2ICs1MCwxNSBA QCBjbGFzcyBWZXJzaW9uQ2hhbmdlQ2FsbGJhY2s7CiAvLyBDYW4gYmUgdXNlZCB0byB3YWl0IHVu dGlsIERhdGFiYXNlVGFzayBpcyBjb21wbGV0ZWQuCiAvLyBIYXMgdG8gYmUgcGFzc2VkIGludG8g RGF0YWJhc2VUYXNrOjpjcmVhdGUgdG8gYmUgYXNzb2NpYXRlZCB3aXRoIHRoZSB0YXNrLgogY2xh c3MgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyIDogcHVibGljIE5vbmNvcHlhYmxlIHsKLSAgICBm cmllbmQgY2xhc3MgRGF0YWJhc2VUYXNrOwogcHVibGljOgogICAgIERhdGFiYXNlVGFza1N5bmNo cm9uaXplcigpOwogCiAgICAgLy8gQ2FsbGVkIGZyb20gbWFpbiB0aHJlYWQgdG8gd2FpdCB1bnRp bCB0YXNrIGlzIGNvbXBsZXRlZC4KICAgICB2b2lkIHdhaXRGb3JUYXNrQ29tcGxldGlvbigpOwog Ci1wcml2YXRlOgogICAgIC8vIENhbGxlZCBieSB0aGUgdGFzay4KICAgICB2b2lkIHRhc2tDb21w bGV0ZWQoKTsKK3ByaXZhdGU6CiAKICAgICBib29sIG1fdGFza0NvbXBsZXRlZDsKICAgICBNdXRl eCBtX3N5bmNocm9ub3VzTXV0ZXg7CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJl YWQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHAJ KHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNwcAko d29ya2luZyBjb3B5KQpAQCAtNDQsNiArNDQsNyBAQCBEYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VU aHJlYWQoKQogICAgIDogbV90aHJlYWRJRCgwKQogICAgICwgbV90cmFuc2FjdGlvbkNsaWVudChu ZXcgU1FMVHJhbnNhY3Rpb25DbGllbnQoKSkKICAgICAsIG1fdHJhbnNhY3Rpb25Db29yZGluYXRv cihuZXcgU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcigpKQorICAgICwgbV9jbGVhbnVwU3luYygw KQogewogICAgIG1fc2VsZlJlZiA9IHRoaXM7CiB9CkBAIC01MSw2ICs1Miw3IEBAIERhdGFiYXNl VGhyZWFkOjpEYXRhYmFzZVRocmVhZCgpCiBEYXRhYmFzZVRocmVhZDo6fkRhdGFiYXNlVGhyZWFk KCkKIHsKICAgICAvLyBGSVhNRTogQW55IGNsZWFudXAgcmVxdWlyZWQgaGVyZT8gIFNpbmNlIHRo ZSB0aHJlYWQgZGVsZXRlcyBpdHNlbGYgYWZ0ZXIgcnVubmluZyBpdHMgZGV0YWNoZWQgY291cnNl LCBJIGRvbid0IHRoaW5rIHNvLiAgTGV0cyBiZSBzdXJlLgorICAgIEFTU0VSVCh0ZXJtaW5hdGlv blJlcXVlc3RlZCgpKTsKIH0KIAogYm9vbCBEYXRhYmFzZVRocmVhZDo6c3RhcnQoKQpAQCAtNjUs OCArNjcsMTAgQEAgYm9vbCBEYXRhYmFzZVRocmVhZDo6c3RhcnQoKQogICAgIHJldHVybiBtX3Ro cmVhZElEOwogfQogCi12b2lkIERhdGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRpb24oKQor dm9pZCBEYXRhYmFzZVRocmVhZDo6cmVxdWVzdFRlcm1pbmF0aW9uKERhdGFiYXNlVGFza1N5bmNo cm9uaXplciAqY2xlYW51cFN5bmMpCiB7CisgICAgQVNTRVJUKCFtX2NsZWFudXBTeW5jKTsKKyAg ICBtX2NsZWFudXBTeW5jID0gY2xlYW51cFN5bmM7CiAgICAgTE9HKFN0b3JhZ2VBUEksICJEYXRh YmFzZVRocmVhZCAlcCB3YXMgYXNrZWQgdG8gdGVybWluYXRlXG4iLCB0aGlzKTsKICAgICBtX3F1 ZXVlLmtpbGwoKTsKIH0KQEAgLTExNSw5ICsxMTksMTQgQEAgdm9pZCogRGF0YWJhc2VUaHJlYWQ6 OmRhdGFiYXNlVGhyZWFkKCkKICAgICAvLyBEZXRhY2ggdGhlIHRocmVhZCBzbyBpdHMgcmVzb3Vy Y2VzIGFyZSBubyBsb25nZXIgb2YgYW55IGNvbmNlcm4gdG8gYW55b25lIGVsc2UKICAgICBkZXRh Y2hUaHJlYWQobV90aHJlYWRJRCk7CiAKKyAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIqIGNs ZWFudXBTeW5jID0gbV9jbGVhbnVwU3luYzsKKyAgICAKICAgICAvLyBDbGVhciB0aGUgc2VsZiBy ZWZwdHIsIHBvc3NpYmx5IHJlc3VsdGluZyBpbiBkZWxldGlvbgogICAgIG1fc2VsZlJlZiA9IDA7 CiAKKyAgICBpZiAoY2xlYW51cFN5bmMpIC8vIFNvbWVvbmUgd2FudGVkIHRvIGtub3cgd2hlbiB3 ZSB3ZXJlIGRvbmUgY2xlYW5pbmcgdXAuCisgICAgICAgIGNsZWFudXBTeW5jLT50YXNrQ29tcGxl dGVkKCk7CisKICAgICByZXR1cm4gMDsKIH0KIApAQCAtMTYyLDYgKzE3MSw1IEBAIHZvaWQgRGF0 YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVQKICAgICBTYW1lRGF0YWJhc2VQcmVkaWNh dGUgcHJlZGljYXRlKGRhdGFiYXNlKTsKICAgICBtX3F1ZXVlLnJlbW92ZUlmKHByZWRpY2F0ZSk7 CiB9Ci0KIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKICNlbmRpZgpJbmRleDogV2ViQ29yZS9zdG9y YWdlL0RhdGFiYXNlVGhyZWFkLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFi YXNlVGhyZWFkLmgJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmgJKHdvcmtpbmcgY29weSkKQEAgLTQzLDYgKzQzLDcgQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogCiBjbGFzcyBEYXRhYmFzZTsKIGNsYXNzIERhdGFiYXNlVGFzazsKK2NsYXNzIERhdGFi YXNlVGFza1N5bmNocm9uaXplcjsKIGNsYXNzIERvY3VtZW50OwogY2xhc3MgU1FMVHJhbnNhY3Rp b25DbGllbnQ7CiBjbGFzcyBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOwpAQCAtNTMsNyArNTQs NyBAQCBwdWJsaWM6CiAgICAgfkRhdGFiYXNlVGhyZWFkKCk7CiAKICAgICBib29sIHN0YXJ0KCk7 Ci0gICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oKTsKKyAgICB2b2lkIHJlcXVlc3RUZXJtaW5h dGlvbihEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgKmNsZWFudXBTeW5jKTsKICAgICBib29sIHRl cm1pbmF0aW9uUmVxdWVzdGVkKCkgY29uc3Q7CiAKICAgICB2b2lkIHNjaGVkdWxlVGFzayhQYXNz T3duUHRyPERhdGFiYXNlVGFzaz4pOwpAQCAtODUsNiArODYsNyBAQCBwcml2YXRlOgogCiAgICAg T3duUHRyPFNRTFRyYW5zYWN0aW9uQ2xpZW50PiBtX3RyYW5zYWN0aW9uQ2xpZW50OwogICAgIE93 blB0cjxTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yPiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3I7 CisgICAgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyICptX2NsZWFudXBTeW5jOwogfTsKIAogfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tl ci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5jcHAJ KHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTM2LDEwICszNiwxMCBAQAogI2luY2x1ZGUgIkRhdGFiYXNlLmgi CiAjaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKICNpbmNsdWRlICJEYXRhYmFzZVRyYWNrZXJD bGllbnQuaCIKLSNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNp bmNsdWRlICJPcmlnaW5RdW90YU1hbmFnZXIuaCIKICNpbmNsdWRlICJQYWdlLmgiCisjaW5jbHVk ZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgi CiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW5IYXNoLmgiCiAjaW5jbHVkZSAiU1FMaXRlRmlsZVN5 c3RlbS5oIgpAQCAtMTIwLDcgKzEyMCw3IEBAIHZvaWQgRGF0YWJhc2VUcmFja2VyOjpvcGVuVHJh Y2tlckRhdGFiYXMKICAgICB9CiB9CiAKLWJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxp c2hEYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3Qg U3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQorYm9vbCBE YXRhYmFzZVRyYWNrZXI6OmNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFt ZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogewogICAgIEFTU0VSVChjdXJyZW50VGhy ZWFkKCkgPT0gbV90aHJlYWQpOwogCkBAIC0xMjgsOSArMTI4LDkgQEAgYm9vbCBEYXRhYmFzZVRy YWNrZXI6OmNhbkVzdGFibGlzaERhdGFiYQogICAgIC8vIGNhbiBydW4gb24gdGhlIGRhdGFiYXNl IHRocmVhZCBsYXRlci4KICAgICBwb3B1bGF0ZU9yaWdpbnMoKTsKIAotICAgIFNlY3VyaXR5T3Jp Z2luKiBvcmlnaW4gPSBkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKTsKKyAgICBTZWN1cml0eU9y aWdpbiogb3JpZ2luID0gY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKTsKIAotICAgIC8vIFNpbmNl IHdlJ3JlIGltbWluZW50bHkgb3BlbmluZyBhIGRhdGFiYXNlIHdpdGhpbiB0aGlzIERvY3VtZW50 J3Mgb3JpZ2luLCBtYWtlIHN1cmUgdGhpcyBvcmlnaW4gaXMgYmVpbmcgdHJhY2tlZCBieSB0aGUg UXVvdGFUcmFja2VyCisgICAgLy8gU2luY2Ugd2UncmUgaW1taW5lbnRseSBvcGVuaW5nIGEgZGF0 YWJhc2Ugd2l0aGluIHRoaXMgY29udGV4dCdzIG9yaWdpbiwgbWFrZSBzdXJlIHRoaXMgb3JpZ2lu IGlzIGJlaW5nIHRyYWNrZWQgYnkgdGhlIFF1b3RhVHJhY2tlcgogICAgIC8vIGJ5IGZldGNoaW5n IGl0J3MgY3VycmVudCB1c2FnZSBub3cKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgdXNhZ2UgPSB1 c2FnZUZvck9yaWdpbihvcmlnaW4pOwogCkBAIC0xNDcsMTIgKzE0Nyw5IEBAIGJvb2wgRGF0YWJh c2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmEKIAogICAgIC8vIEdpdmUgdGhlIGNocm9tZSBj bGllbnQgYSBjaGFuY2UgdG8gaW5jcmVhc2UgdGhlIHF1b3RhLgogICAgIC8vIFRlbXBvcmFyaWx5 IG1ha2UgdGhlIGRldGFpbHMgb2YgdGhlIHByb3Bvc2VkIGRhdGFiYXNlIGF2YWlsYWJsZSwgc28g dGhlIGNsaWVudCBjYW4gZ2V0IGF0IHRoZW0uCi0gICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5w YWdlKCk7Ci0gICAgaWYgKCFwYWdlKQotICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgcGFpcjxT ZWN1cml0eU9yaWdpbiosIERhdGFiYXNlRGV0YWlscz4gZGV0YWlscyhvcmlnaW4sIERhdGFiYXNl RGV0YWlscyhuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSwgMCkpOwogICAgIG1fcHJv cG9zZWREYXRhYmFzZSA9ICZkZXRhaWxzOwotICAgIHBhZ2UtPmNocm9tZSgpLT5jbGllbnQoKS0+ ZXhjZWVkZWREYXRhYmFzZVF1b3RhKGRvY3VtZW50LT5mcmFtZSgpLCBuYW1lKTsKKyAgICBjb250 ZXh0LT5kYXRhYmFzZUV4Y2VlZGVkUXVvdGEobmFtZSk7CiAgICAgbV9wcm9wb3NlZERhdGFiYXNl ID0gMDsKIAogICAgIC8vIElmIHRoZSBkYXRhYmFzZSB3aWxsIGZpdCBub3csIGFsbG93IGl0cyBj cmVhdGlvbi4KQEAgLTE4Niw3ICsxODMsNyBAQCBib29sIERhdGFiYXNlVHJhY2tlcjo6aGFzRW50 cnlGb3JEYXRhYmFzCiAKIHVuc2lnbmVkIGxvbmcgbG9uZyBEYXRhYmFzZVRyYWNrZXI6OmdldE1h eFNpemVGb3JEYXRhYmFzZShjb25zdCBEYXRhYmFzZSogZGF0YWJhc2UpCiB7Ci0gICAgQVNTRVJU KGN1cnJlbnRUaHJlYWQoKSA9PSBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQo KS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSBkYXRhYmFz ZS0+ZXhlY3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsK ICAgICAvLyBUaGUgbWF4aW11bSBzaXplIGZvciBhIGRhdGFiYXNlIGlzIHRoZSBmdWxsIHF1b3Rh IGZvciBpdHMgb3JpZ2luLCBtaW51cyB0aGUgY3VycmVudCB1c2FnZSB3aXRoaW4gdGhlIG9yaWdp biwKICAgICAvLyBwbHVzIHRoZSBjdXJyZW50IHVzYWdlIG9mIHRoZSBnaXZlbiBkYXRhYmFzZQog ICAgIExvY2tlcjxPcmlnaW5RdW90YU1hbmFnZXI+IGxvY2tlcihvcmlnaW5RdW90YU1hbmFnZXIo KSk7CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUcmFja2VyLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5oCShyZXZpc2lvbiA1Mjk5NSkKKysr IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuaAkod29ya2luZyBjb3B5KQpAQCAtNDUs NyArNDUsNyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBEYXRhYmFzZTsKLWNsYXNz IERvY3VtZW50OworY2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIGNsYXNzIFNlY3VyaXR5 T3JpZ2luOwogCiAjaWYgIVBMQVRGT1JNKENIUk9NSVVNKQpAQCAtNTksOCArNTksMTAgQEAgc3Ry dWN0IFNlY3VyaXR5T3JpZ2luVHJhaXRzOwogY2xhc3MgRGF0YWJhc2VUcmFja2VyIDogcHVibGlj IE5vbmNvcHlhYmxlIHsKIHB1YmxpYzoKICAgICBzdGF0aWMgRGF0YWJhc2VUcmFja2VyJiB0cmFj a2VyKCk7CisgICAgLy8gTk9URTogSWYgYXQgc29tZSBwb2ludCBhbnlvbmUgaW1wbGVtZW50cyBt dWx0aXBsZSB3b3JrZXIgdGhyZWFkcworICAgIC8vIHJ1bm5pbmcgaW4gdGhlIHNhbWUgcHJvY2Vz cywgdGhpcyBzaW5nbGV0b24gd2lsbCBoYXZlIHRvIGJlIHN5bmNocm9uaXplZC4KIAotICAgIGJv b2wgY2FuRXN0YWJsaXNoRGF0YWJhc2UoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNv bnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7Cisg ICAgYm9vbCBjYW5Fc3RhYmxpc2hEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25n IGVzdGltYXRlZFNpemUpOwogICAgIHZvaWQgc2V0RGF0YWJhc2VEZXRhaWxzKFNlY3VyaXR5T3Jp Z2luKiwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNp Z25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogICAgIFN0cmluZyBmdWxsUGF0aEZvckRhdGFiYXNl KFNlY3VyaXR5T3JpZ2luKiwgY29uc3QgU3RyaW5nJiBuYW1lLCBib29sIGNyZWF0ZUlmRG9lc05v dEV4aXN0ID0gdHJ1ZSk7CiAKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL1NRTFRyYW5zYWN0aW9uLmNwcAkocmV2 aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb24uY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zNSwxMSArMzUsMTEgQEAKICNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2lu Y2x1ZGUgIkRhdGFiYXNlQXV0aG9yaXplci5oIgogI2luY2x1ZGUgIkRhdGFiYXNlRGV0YWlscy5o IgotI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2lu Y2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1T dHJpbmcuaCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAi U2V0dGluZ3MuaCIKICNpbmNsdWRlICJTUUxFcnJvci5oIgogI2luY2x1ZGUgIlNRTGl0ZVRyYW5z YWN0aW9uLmgiCkBAIC05NCw4ICs5NCw3IEBAIHZvaWQgU1FMVHJhbnNhY3Rpb246OmV4ZWN1dGVT UUwoY29uc3QgU3QKIAogICAgIGJvb2wgcmVhZE9ubHlNb2RlID0gbV9yZWFkT25seTsKICAgICBp ZiAoIXJlYWRPbmx5TW9kZSkgewotICAgICAgICBQYWdlKiBwYWdlID0gbV9kYXRhYmFzZS0+ZG9j dW1lbnQoKS0+cGFnZSgpOwotICAgICAgICBpZiAoIXBhZ2UgfHwgcGFnZS0+c2V0dGluZ3MoKS0+ cHJpdmF0ZUJyb3dzaW5nRW5hYmxlZCgpKQorICAgICAgICBpZiAobV9kYXRhYmFzZS0+ZXhlY3V0 aW9uQ29udGV4dCgpLT5pc0RhdGFiYXNlUmVhZE9ubHkoKSkKICAgICAgICAgICAgIHJlYWRPbmx5 TW9kZSA9IHRydWU7CiAgICAgfQogCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rp b25DbGllbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlv bkNsaWVudC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL1NRTFRyYW5z YWN0aW9uQ2xpZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDcsNyArNDcsNyBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKIHZvaWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5z YWN0aW9uKFNRTFRyYW5zYWN0aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQoY3VycmVu dFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFz ZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09 IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5leGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhy ZWFkKCktPmdldFRocmVhZElEKCkpOwogICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9IHRyYW5zYWN0 aW9uLT5kYXRhYmFzZSgpOwogICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnNjaGVkdWxl Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkKAogICAgICAgICBkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4o KSwgZGF0YWJhc2UtPnN0cmluZ0lkZW50aWZpZXIoKSk7CkBAIC01NSw3ICs1NSw3IEBAIHZvaWQg U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW4KIAogdm9pZCBTUUxUcmFuc2FjdGlv bkNsaWVudDo6ZGlkRXhlY3V0ZVN0YXRlbWVudChTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24p CiB7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2Uo KS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNT RVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZXhlY3V0aW9u Q29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKICAgICBPcmlnaW5R dW90YU1hbmFnZXImIG1hbmFnZXIoRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkub3JpZ2luUXVv dGFNYW5hZ2VyKCkpOwogICAgIExvY2tlcjxPcmlnaW5RdW90YU1hbmFnZXI+IGxvY2tlcihtYW5h Z2VyKTsKICAgICBtYW5hZ2VyLm1hcmtEYXRhYmFzZSh0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKSk7 CkBAIC02NSwxMSArNjUsOSBAQCBib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRR dW90CiB7CiAgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKICAgICBEYXRhYmFzZSogZGF0YWJh c2UgPSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKTsKLSAgICBQYWdlKiBwYWdlID0gZGF0YWJhc2Ut PmRvY3VtZW50KCktPnBhZ2UoKTsKLSAgICBBU1NFUlQocGFnZSk7CiAKICAgICB1bnNpZ25lZCBs b25nIGxvbmcgY3VycmVudFF1b3RhID0gRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucXVvdGFG b3JPcmlnaW4oZGF0YWJhc2UtPnNlY3VyaXR5T3JpZ2luKCkpOwotICAgIHBhZ2UtPmNocm9tZSgp LT5jbGllbnQoKS0+ZXhjZWVkZWREYXRhYmFzZVF1b3RhKGRhdGFiYXNlLT5kb2N1bWVudCgpLT5m cmFtZSgpLCBkYXRhYmFzZS0+c3RyaW5nSWRlbnRpZmllcigpKTsKKyAgICBkYXRhYmFzZS0+ZXhl Y3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZUV4Y2VlZGVkUXVvdGEoZGF0YWJhc2UtPnN0cmluZ0lk ZW50aWZpZXIoKSk7CiAgICAgdW5zaWduZWQgbG9uZyBsb25nIG5ld1F1b3RhID0gRGF0YWJhc2VU cmFja2VyOjp0cmFja2VyKCkucXVvdGFGb3JPcmlnaW4oZGF0YWJhc2UtPnNlY3VyaXR5T3JpZ2lu KCkpOwogICAgIHJldHVybiAobmV3UXVvdGEgPiBjdXJyZW50UXVvdGEpOwogfQpJbmRleDogV2Vi Q29yZS9zdG9yYWdlL2Nocm9taXVtL0RhdGFiYXNlVHJhY2tlckNocm9taXVtLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvY2hyb21pdW0vRGF0YWJhc2VUcmFja2VyQ2hyb21pdW0u Y3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFz ZVRyYWNrZXJDaHJvbWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDggKzM1LDggQEAKICNp bmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIkRhdGFiYXNlT2JzZXJ2ZXIuaCIKICNpbmNs dWRlICJEYXRhYmFzZVRocmVhZC5oIgotI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAi UXVvdGFUcmFja2VyLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgogI2lu Y2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU1FMaXRlRmlsZVN5c3RlbS5oIgog I2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CkBAIC01Niw3ICs1Niw3IEBAIERhdGFiYXNlVHJhY2tl cjo6RGF0YWJhc2VUcmFja2VyKCkKICAgICBTUUxpdGVGaWxlU3lzdGVtOjpyZWdpc3RlclNRTGl0 ZVZGUygpOwogfQogCi1ib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2Uo RG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmLCB1bnNpZ25lZCBsb25nKQor Ym9vbCBEYXRhYmFzZVRyYWNrZXI6OmNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQgKiwgY29uc3QgU3RyaW5nJiwgY29uc3QgU3RyaW5nJiwgdW5zaWduZWQgbG9uZykK IHsKICAgICAvLyBJbiBDaHJvbWl1bSwgYSBkYXRhYmFzZSBjYW4gYWx3YXlzIGJlIGVzdGFibGlz aGVkIChldmVuIHRob3VnaCB3ZSBtaWdodCBub3QKICAgICAvLyBiZSBhYmxlIHRvIHdyaXRlIGFu eXRoaW5nIHRvIGl0IGlmIHRoZSBxdW90YSBmb3IgdGhpcyBvcmlnaW4gd2FzIGV4Y2VlZGVkKQpA QCAtNzUsMjEgKzc1LDM4IEBAIFN0cmluZyBEYXRhYmFzZVRyYWNrZXI6OmZ1bGxQYXRoRm9yRGF0 YWIKIAogdm9pZCBEYXRhYmFzZVRyYWNrZXI6OmFkZE9wZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0 YWJhc2UpCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQoZGF0YWJh c2UtPmV4ZWN1dGlvbkNvbnRleHQoKS0+aXNKYXZhU2NyaXB0VGhyZWFkKCkpOwogICAgIERhdGFi YXNlT2JzZXJ2ZXI6OmRhdGFiYXNlT3BlbmVkKGRhdGFiYXNlKTsKIH0KLXN0YXRpYyB2b2lkIHJl bW92ZU9wZW5EYXRhYmFzZU9uTWFpblRocmVhZCh2b2lkKiBjb250ZXh0KQotewotICAgIERhdGFi YXNlKiBkYXRhYmFzZSA9IHN0YXRpY19jYXN0PERhdGFiYXNlKj4oY29udGV4dCk7Ci0gICAgRGF0 YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucmVtb3ZlT3BlbkRhdGFiYXNlKGRhdGFiYXNlKTsKLSAg ICBkYXRhYmFzZS0+ZGVyZWYoKTsKLX0KKworY2xhc3MgVHJhY2tlclJlbW92ZU9wZW5EYXRhYmFz ZVRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6Cisg ICAgc3RhdGljIFBhc3NPd25QdHI8VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s+IGNyZWF0 ZShEYXRhYmFzZSAqZGF0YWJhc2UpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IFRyYWNrZXJS ZW1vdmVPcGVuRGF0YWJhc2VUYXNrKGRhdGFiYXNlKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZv aWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCkKKyAgICB7Cisg ICAgICAgIEFTU0VSVChjb250ZXh0LT5pc0phdmFTY3JpcHRUaHJlYWQoKSk7CisgICAgICAgIERh dGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShtX2RhdGFiYXNlKTsK KyAgICAgICAgLy8gUmVmZmVkIGluIGNhbGxlci4KKyAgICAgICAgbV9kYXRhYmFzZS0+ZGVyZWYo KTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgZXhwbGljaXQgVHJhY2tlclJlbW92ZU9wZW5EYXRh YmFzZVRhc2soRGF0YWJhc2UgKmRhdGFiYXNlKSA6IG1fZGF0YWJhc2UoZGF0YWJhc2UpCisgICAg eworICAgIH0KKworICAgIERhdGFiYXNlKiBtX2RhdGFiYXNlOworfTsKIAogdm9pZCBEYXRhYmFz ZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCiB7Ci0gICAg aWYgKCFpc01haW5UaHJlYWQoKSkgeworICAgIGlmICghZGF0YWJhc2UtPmV4ZWN1dGlvbkNvbnRl eHQoKS0+aXNKYXZhU2NyaXB0VGhyZWFkKCkpIHsKICAgICAgICAgZGF0YWJhc2UtPnJlZigpOwot ICAgICAgICBjYWxsT25NYWluVGhyZWFkKHJlbW92ZU9wZW5EYXRhYmFzZU9uTWFpblRocmVhZCwg ZGF0YWJhc2UpOworICAgICAgICBkYXRhYmFzZS0+ZXhlY3V0aW9uQ29udGV4dCgpLT5wb3N0VGFz ayhUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6Y3JlYXRlKGRhdGFiYXNlKSk7CiAgICAg ICAgIHJldHVybjsKICAgICB9CiAKQEAgLTk4LDcgKzExNSw3IEBAIHZvaWQgRGF0YWJhc2VUcmFj a2VyOjpyZW1vdmVPcGVuRGF0YWJhc2UKIAogdW5zaWduZWQgbG9uZyBsb25nIERhdGFiYXNlVHJh Y2tlcjo6Z2V0TWF4U2l6ZUZvckRhdGFiYXNlKGNvbnN0IERhdGFiYXNlKiBkYXRhYmFzZSkKIHsK LSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IGRhdGFiYXNlLT5kb2N1bWVudCgpLT5kYXRh YmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgp ID09IGRhdGFiYXNlLT5leGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRo cmVhZElEKCkpOwogICAgIHVuc2lnbmVkIGxvbmcgbG9uZyBzcGFjZUF2YWlsYWJsZSA9IDA7CiAg ICAgdW5zaWduZWQgbG9uZyBsb25nIGRhdGFiYXNlU2l6ZSA9IDA7CiAgICAgUXVvdGFUcmFja2Vy OjppbnN0YW5jZSgpLmdldERhdGFiYXNlU2l6ZUFuZFNwYWNlQXZhaWxhYmxlVG9PcmlnaW4oCklu ZGV4OiBXZWJDb3JlL3N0b3JhZ2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRDaHJvbWl1 bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0 aW9uQ2xpZW50Q2hyb21pdW0uY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFn ZS9jaHJvbWl1bS9TUUxUcmFuc2FjdGlvbkNsaWVudENocm9taXVtLmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMzgsMjAgKzM4LDM1IEBACiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb24uaCIKICNpbmNs dWRlIDx3dGYvTWFpblRocmVhZC5oPgogCi1zdGF0aWMgdm9pZCBub3RpZnlEYXRhYmFzZUNoYW5n ZWQodm9pZCogY29udGV4dCkgewotICAgIFdlYkNvcmU6OkRhdGFiYXNlKiBkYXRhYmFzZSA9IHN0 YXRpY19jYXN0PFdlYkNvcmU6OkRhdGFiYXNlKj4oY29udGV4dCk7Ci0gICAgV2ViQ29yZTo6RGF0 YWJhc2VPYnNlcnZlcjo6ZGF0YWJhc2VNb2RpZmllZChkYXRhYmFzZSk7Ci0gICAgZGF0YWJhc2Ut PmRlcmVmKCk7ICAvLyByZWYoKSdkIGluIGRpZENvbW1pdFRyYW5zYWN0aW9uKCkKLX0KLQogbmFt ZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrIDogcHVi bGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQ YXNzT3duUHRyPE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2s+IGNyZWF0ZShEYXRhYmFzZSAqZGF0 YWJhc2UpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRh c2soZGF0YWJhc2UpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQorICAgIHsKKyAgICAgICAgV2ViQ29yZTo6RGF0 YWJhc2VPYnNlcnZlcjo6ZGF0YWJhc2VNb2RpZmllZChtX2RhdGFiYXNlLmdldCgpKTsKKyAgICB9 CisKK3ByaXZhdGU6CisgICAgZXhwbGljaXQgTm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzayhQYXNz UmVmUHRyPERhdGFiYXNlPiBkYXRhYmFzZSkKKyAgICAgICAgOiBtX2RhdGFiYXNlKGRhdGFiYXNl KQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8RGF0YWJhc2U+IG1fZGF0YWJhc2U7Cit9Owor CiB2b2lkIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRDb21taXRUcmFuc2FjdGlvbihTUUxUcmFu c2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0 cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0 VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ ZGF0YWJhc2UoKS0+ZXhlY3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJl YWRJRCgpKTsKICAgICBpZiAoIXRyYW5zYWN0aW9uLT5pc1JlYWRPbmx5KCkpIHsKLSAgICAgICAg dHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnJlZigpOyAgLy8gZGVyZWYoKSdkIGluIG5vdGlmeURh dGFiYXNlQ2hhbmdlZCgpCi0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQobm90aWZ5RGF0YWJhc2VD aGFuZ2VkLCB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKSk7CisgICAgICAgIHRyYW5zYWN0aW9uLT5k YXRhYmFzZSgpLT5leGVjdXRpb25Db250ZXh0KCktPnBvc3RUYXNrKAorICAgICAgICAgICAgTm90 aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpKSk7 CiAgICAgfQogfQogCkBAIC01OSwxNCArNzQsMTQgQEAgdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVu dDo6ZGlkRXhlY3V0ZVN0YQogewogICAgIC8vIFRoaXMgbWV0aG9kIGlzIGNhbGxlZCBhZnRlciBl eGVjdXRpbmcgZXZlcnkgc3RhdGVtZW50IHRoYXQgY2hhbmdlcyB0aGUgREIuCiAgICAgLy8gQ2hy b21pdW0gZG9lc24ndCBuZWVkIHRvIGRvIGFueXRoaW5nIGF0IHRoYXQgcG9pbnQuCi0gICAgQVNT RVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQo KS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRU aHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZXhlY3V0aW9uQ29udGV4dCgpLT5k YXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKIH0KIAotYm9vbCBTUUxUcmFuc2FjdGlv bkNsaWVudDo6ZGlkRXhjZWVkUXVvdGEoU1FMVHJhbnNhY3Rpb24qKQorYm9vbCBTUUxUcmFuc2Fj dGlvbkNsaWVudDo6ZGlkRXhjZWVkUXVvdGEoU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQog ewogICAgIC8vIENocm9taXVtIGRvZXMgbm90IGFsbG93IHVzZXJzIHRvIG1hbnVhbGx5IGNoYW5n ZSB0aGUgcXVvdGEgZm9yIGFuIG9yaWdpbiAoZm9yIG5vdywgYXQgbGVhc3QpLgogICAgIC8vIERv bid0IGRvIGFueXRoaW5nLgotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJU KHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5leGVjdXRpb25Db250ZXh0KCktPmlzSmF2YVNjcmlw dFRocmVhZCgpKTsKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKSW5kZXg6IFdlYkNvcmUvd29ya2Vy cy9Xb3JrZXJDb250ZXh0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlckNv bnRleHQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMiw2ICszMiw5IEBACiAjaW5jbHVkZSAiV29y a2VyQ29udGV4dC5oIgogCiAjaW5jbHVkZSAiQWN0aXZlRE9NT2JqZWN0LmgiCisjaWYgRU5BQkxF KERBVEFCQVNFKQorI2luY2x1ZGUgIkRhdGFiYXNlLmgiCisjZW5kaWYKICNpbmNsdWRlICJET01U aW1lci5oIgogI2luY2x1ZGUgIkRPTVdpbmRvdy5oIgogI2luY2x1ZGUgIkV2ZW50LmgiCkBAIC0y NTQsNiArMjU3LDI0IEBAIE5vdGlmaWNhdGlvbkNlbnRlciogV29ya2VyQ29udGV4dDo6d2Via2kK IH0KICNlbmRpZgogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorUGFzc1JlZlB0cjxEYXRhYmFzZT4g V29ya2VyQ29udGV4dDo6b3BlbkRhdGFiYXNlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3Ry aW5nJiB2ZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVz dGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmIGVjKQoreworICAgIGlmICghc2VjdXJpdHlPcmln aW4oKS0+Y2FuQWNjZXNzRGF0YWJhc2UoKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBpZiAo IURhdGFiYXNlOjppc0F2YWlsYWJsZSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJldHVy biBEYXRhYmFzZTo6b3BlbkRhdGFiYXNlKHRoaXMsIG5hbWUsIHZlcnNpb24sIGRpc3BsYXlOYW1l LCBlc3RpbWF0ZWRTaXplLCBlYyk7Cit9CisjZW5kaWYKKworYm9vbCBXb3JrZXJDb250ZXh0Ojpp c0phdmFTY3JpcHRUaHJlYWQoKSBjb25zdAoreworICAgIHJldHVybiBjdXJyZW50VGhyZWFkKCkg PT0gdGhyZWFkKCktPnRocmVhZElEKCk7Cit9CisKIEV2ZW50VGFyZ2V0RGF0YSogV29ya2VyQ29u dGV4dDo6ZXZlbnRUYXJnZXREYXRhKCkKIHsKICAgICByZXR1cm4gJm1fZXZlbnRUYXJnZXREYXRh OwpJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgJKHdvcmtpbmcgY29weSkKQEAgLTM1LDEzICszNSwx OSBAQAogI2luY2x1ZGUgIkV2ZW50VGFyZ2V0LmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9u Q29udGV4dC5oIgogI2luY2x1ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKKyNpbmNsdWRl IDx3dGYvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KICNpbmNsdWRlIDx3 dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CiAjaW5jbHVkZSA8 d3RmL1JlZlB0ci5oPgogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorI2luY2x1ZGUgIkRhdGFiYXNl LmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCisgICAgY2xhc3MgRGF0YWJhc2U7 CiAgICAgY2xhc3MgTm90aWZpY2F0aW9uQ2VudGVyOwogICAgIGNsYXNzIFNjaGVkdWxlZEFjdGlv bjsKICAgICBjbGFzcyBXb3JrZXJMb2NhdGlvbjsKQEAgLTY1LDkgKzcxLDkgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIFN0cmluZyB1c2VyQWdlbnQoY29uc3QgS1VSTCYp IGNvbnN0OwogCiAgICAgICAgIFdvcmtlclNjcmlwdENvbnRyb2xsZXIqIHNjcmlwdCgpIHsgcmV0 dXJuIG1fc2NyaXB0LmdldCgpOyB9Ci0gICAgICAgIHZvaWQgY2xlYXJTY3JpcHQoKSB7IHJldHVy biBtX3NjcmlwdC5jbGVhcigpOyB9CisgICAgICAgIHZvaWQgY2xlYXJTY3JpcHQoKSB7IG1fc2Ny aXB0LmNsZWFyKCk7IH0KIAotICAgICAgICBXb3JrZXJUaHJlYWQqIHRocmVhZCgpIHsgcmV0dXJu IG1fdGhyZWFkOyB9CisgICAgICAgIFdvcmtlclRocmVhZCogdGhyZWFkKCkgY29uc3QgeyByZXR1 cm4gbV90aHJlYWQ7IH0KIAogICAgICAgICBib29sIGhhc1BlbmRpbmdBY3Rpdml0eSgpIGNvbnN0 OwogCkBAIC0xMDEsNiArMTA3LDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgTm90 aWZpY2F0aW9uQ2VudGVyKiB3ZWJraXROb3RpZmljYXRpb25zKCkgY29uc3Q7CiAjZW5kaWYKIAor I2lmIEVOQUJMRShEQVRBQkFTRSkKKyAgICAgICAgLy8gSFRNTCA1IGNsaWVudC1zaWRlIGRhdGFi YXNlCisgICAgICAgIFBhc3NSZWZQdHI8RGF0YWJhc2U+IG9wZW5EYXRhYmFzZShjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFt ZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNlcHRpb25Db2RlJik7CisgICAgICAg IHZpcnR1YWwgYm9vbCBpc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdCB7IHJldHVybiBmYWxzZTsg LyogVE9ETyhlcmljdSkgKi8gfQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGF0YWJhc2VFeGNlZWRl ZFF1b3RhKGNvbnN0IFN0cmluZyYpIHsgLyogVE9ETyhlcmljdSkgKi99CisjZW5kaWYKKyAgICAg ICAgdmlydHVhbCBib29sIGlzSmF2YVNjcmlwdFRocmVhZCgpIGNvbnN0OworCisKICAgICAgICAg Ly8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0MgbWFya2luZy4gU2VlIEpTV29ya2VyQ29u dGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGluCiAgICAgICAgIC8vIEpTV29ya2VyQ29u dGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5hdmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0 b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5nZXQoKTsgfQpJbmRleDogV2ViQ29yZS93 b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmlkbAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3dvcmtlcnMvV29y a2VyQ29udGV4dC5pZGwJKHdvcmtpbmcgY29weSkKQEAgLTQ5LDcgKzQ5LDEwIEBAIG1vZHVsZSB0 aHJlYWRzIHsKICAgICAgICAgLy8gV29ya2VyVXRpbHMKICAgICAgICAgW0N1c3RvbV0gdm9pZCBp bXBvcnRTY3JpcHRzKC8qW1ZhcmlhZGljXSBpbiBET01TdHJpbmcgdXJscyAqLyk7CiAgICAgICAg ICAgICAgICAgIGF0dHJpYnV0ZSBbUmVwbGFjZWFibGVdIFdvcmtlck5hdmlnYXRvciBuYXZpZ2F0 b3I7Ci0gICAgICAgIC8vIERhdGFiYXNlIG9wZW5EYXRhYmFzZShpbiBET01TdHJpbmcgbmFtZSwg aW4gRE9NU3RyaW5nIHZlcnNpb24sIGluIERPTVN0cmluZyBkaXNwbGF5TmFtZSwgaW4gdW5zaWdu ZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKKyNpZiBkZWZpbmVkKEVOQUJMRV9EQVRBQkFTRSkgJiYg RU5BQkxFX0RBVEFCQVNFCisgICAgICAgIFtFbmFibGVkQXRSdW50aW1lXSBEYXRhYmFzZSBvcGVu RGF0YWJhc2UoaW4gRE9NU3RyaW5nIG5hbWUsIGluIERPTVN0cmluZyB2ZXJzaW9uLCBpbiBET01T dHJpbmcgZGlzcGxheU5hbWUsIGluIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKKyAgICAg ICAgICAgIHJhaXNlcyhET01FeGNlcHRpb24pOworI2VuZGlmCiAgICAgICAgIC8vIERhdGFiYXNl U3luYyBvcGVuRGF0YWJhc2VTeW5jKGluIERPTVN0cmluZyBuYW1lLCBpbiBET01TdHJpbmcgdmVy c2lvbiwgaW4gRE9NU3RyaW5nIGRpc3BsYXlOYW1lLCBpbiB1bnNpZ25lZCBsb25nIGVzdGltYXRl ZFNpemUpOwogCiAgICAgICAgIC8vIFRpbWVycwpJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtl clJ1bkxvb3AuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJSdW5Mb29w LmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3dvcmtlcnMvV29ya2VyUnVuTG9vcC5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTE1Miw5ICsxNTIsNyBAQCBNZXNzYWdlUXVldWVXYWl0UmVz dWx0IFdvcmtlclJ1bkxvb3A6OnJ1CiAgICAgTWVzc2FnZVF1ZXVlV2FpdFJlc3VsdCByZXN1bHQ7 CiAgICAgT3duUHRyPFdvcmtlclJ1bkxvb3A6OlRhc2s+IHRhc2sgPSBtX21lc3NhZ2VRdWV1ZS53 YWl0Rm9yTWVzc2FnZUZpbHRlcmVkV2l0aFRpbWVvdXQocmVzdWx0LCBwcmVkaWNhdGUsIGFic29s dXRlVGltZSk7CiAKLSAgICAvLyBJZiB0aGUgY29udGV4dCBpcyBjbG9zaW5nLCBkb24ndCBkaXNw YXRjaCBhbnkgZnVydGhlciB0YXNrcyAocGVyIHNlY3Rpb24gNC4xLjEgb2YgdGhlIFdlYiBXb3Jr ZXJzIHNwZWMpLgotICAgIGlmIChjb250ZXh0LT5pc0Nsb3NpbmcoKSkKLSAgICAgICAgcmV0dXJu IHJlc3VsdDsKKyAgICAvLyBJZiB0aGUgY29udGV4dCBpcyBjbG9zaW5nLCBkb24ndCBleGVjdXRl IGFueSBmdXJ0aGVyIEphdmFTY3JpcHQgdGFza3MgKHBlciBzZWN0aW9uIDQuMS4xIG9mIHRoZSBX ZWIgV29ya2VycyBzcGVjKS4gIEhvd2V2ZXIsIHRoZXJlIG1heSBiZSBpbXBsZW1lbnRhdGlvbiBj bGVhbnVwIHRhc2tzIGluIHRoZSBxdWV1ZSwgc28ga2VlcCBydW5uaW5nIHRocm91Z2ggaXQuCiAK ICAgICBzd2l0Y2ggKHJlc3VsdCkgewogICAgIGNhc2UgTWVzc2FnZVF1ZXVlVGVybWluYXRlZDoK QEAgLTE2NSw3ICsxNjMsOCBAQCBNZXNzYWdlUXVldWVXYWl0UmVzdWx0IFdvcmtlclJ1bkxvb3A6 OnJ1CiAgICAgICAgIGJyZWFrOwogCiAgICAgY2FzZSBNZXNzYWdlUXVldWVUaW1lb3V0OgotICAg ICAgICBtX3NoYXJlZFRpbWVyLT5maXJlKCk7CisgICAgICAgIGlmICghY29udGV4dC0+aXNDbG9z aW5nKCkpCisgICAgICAgICAgICBtX3NoYXJlZFRpbWVyLT5maXJlKCk7CiAgICAgICAgIGJyZWFr OwogICAgIH0KIApAQCAtMTk0LDcgKzE5Myw5IEBAIFBhc3NPd25QdHI8V29ya2VyUnVuTG9vcDo6 VGFzaz4gV29ya2VyUnUKIAogdm9pZCBXb3JrZXJSdW5Mb29wOjpUYXNrOjpwZXJmb3JtVGFzayhT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAgIG1fdGFzay0+cGVyZm9ybVRh c2soY29udGV4dCk7CisgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IHN0YXRpY19j YXN0PFdvcmtlckNvbnRleHQgKj4oY29udGV4dCk7CisgICAgaWYgKCF3b3JrZXJDb250ZXh0LT5p c0Nsb3NpbmcoKSB8fCBtX3Rhc2stPmlzQ2xlYW51cFRhc2soKSkKKyAgICAgICAgbV90YXNrLT5w ZXJmb3JtVGFzayhjb250ZXh0KTsKIH0KIAogV29ya2VyUnVuTG9vcDo6VGFzazo6VGFzayhQYXNz T3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+IHRhc2ssIGNvbnN0IFN0cmluZyYg bW9kZSkKSW5kZXg6IFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysr IFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMCw2 ICszMCw3IEBACiAKICNpbmNsdWRlICJXb3JrZXJUaHJlYWQuaCIKIAorI2luY2x1ZGUgIkRhdGFi YXNlVGFzay5oIgogI2luY2x1ZGUgIkRlZGljYXRlZFdvcmtlckNvbnRleHQuaCIKICNpbmNsdWRl ICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKQEAgLTEzNSw5ICsxMzYsOCBA QCB2b2lkKiBXb3JrZXJUaHJlYWQ6OndvcmtlclRocmVhZCgpCiAKICAgICBUaHJlYWRJZGVudGlm aWVyIHRocmVhZElEID0gbV90aHJlYWRJRDsKIAotICAgIG1fd29ya2VyQ29udGV4dC0+c3RvcEFj dGl2ZURPTU9iamVjdHMoKTsKLSAgICBtX3dvcmtlckNvbnRleHQtPmNsZWFyU2NyaXB0KCk7CiAg ICAgQVNTRVJUKG1fd29ya2VyQ29udGV4dC0+aGFzT25lUmVmKCkpOworCiAgICAgLy8gVGhlIGJl bG93IGFzc2lnbm1lbnQgd2lsbCBkZXN0cm95IHRoZSBjb250ZXh0LCB3aGljaCB3aWxsIGluIHR1 cm4gbm90aWZ5IG1lc3NhZ2luZyBwcm94eS4KICAgICAvLyBXZSBjYW5ub3QgbGV0IGFueSBvYmpl Y3RzIHN1cnZpdmUgcGFzdCB0aHJlYWQgZXhpdCwgYmVjYXVzZSBubyBvdGhlciB0aHJlYWQgd2ls bCBydW4gR0Mgb3Igb3RoZXJ3aXNlIGRlc3Ryb3kgdGhlbS4KICAgICBtX3dvcmtlckNvbnRleHQg PSAwOwpAQCAtMTU0LDE3ICsxNTQsNzkgQEAgdm9pZCBXb3JrZXJUaHJlYWQ6OnJ1bkV2ZW50TG9v cCgpCiAgICAgbV9ydW5Mb29wLnJ1bihtX3dvcmtlckNvbnRleHQuZ2V0KCkpOwogfQogCitjbGFz cyBXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9u Q29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8V29ya2VyVGhy ZWFkU2h1dGRvd25GaW5pc2hUYXNrPiBjcmVhdGUoV29ya2VyQ29udGV4dCAqd29ya2VyQ29udGV4 dCkKKyAgICB7CisgICAgICAgIHJldHVybiBuZXcgV29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hU YXNrKHdvcmtlckNvbnRleHQpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFz ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAgQVNTRVJU KGNvbnRleHQtPmlzSmF2YVNjcmlwdFRocmVhZCgpKTsKKyAgICAgICAgbV93b3JrZXJDb250ZXh0 LT50aHJlYWQoKS0+cnVuTG9vcCgpLnRlcm1pbmF0ZSgpOworICAgIH0KKworICAgIHZpcnR1YWwg Ym9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQorCitwcml2YXRlOgor ICAgIGV4cGxpY2l0IFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzayhXb3JrZXJDb250ZXh0 ICp3b3JrZXJDb250ZXh0KSA6IG1fd29ya2VyQ29udGV4dCh3b3JrZXJDb250ZXh0KQorICAgIHsK KyAgICB9CisgICAgV29ya2VyQ29udGV4dCogbV93b3JrZXJDb250ZXh0OworfTsKKworY2xhc3Mg V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29u dGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8V29ya2VyVGhyZWFk U2h1dGRvd25TdGFydFRhc2s+IGNyZWF0ZShXb3JrZXJDb250ZXh0ICp3b3JrZXJDb250ZXh0KQor ICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzayh3 b3JrZXJDb250ZXh0KTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCkKKyAgICB7CisgICAgICAgIEFTU0VSVChjb250 ZXh0LT5pc0phdmFTY3JpcHRUaHJlYWQoKSk7CisgICAgICAgIC8vIFdlIGN1cnJlbnRseSBpZ25v cmUgYW55IERhdGFiYXNlUG9saWN5IHVzZWQgZm9yIHRoZSBkb2N1bWVudCdzCisgICAgICAgIC8v IGRhdGFiYXNlczsgaWYgaXQncyBhY3R1YWxseSB1c2VkIGFueXdoZXJlLCB0aGlzIHNob3VsZCBi ZSByZXZpc2l0ZWQuCisgICAgICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBjbGVhbnVwU3lu YzsKKyAgICAgICAgbV93b3JrZXJDb250ZXh0LT5zdG9wRGF0YWJhc2VzKCZjbGVhbnVwU3luYyk7 CisKKyAgICAgICAgbV93b3JrZXJDb250ZXh0LT5zdG9wQWN0aXZlRE9NT2JqZWN0cygpOworICAg ICAgICBtX3dvcmtlckNvbnRleHQtPmNsZWFyU2NyaXB0KCk7CisKKyAgICAgICAgLy8gV2Ugd2Fp dCBmb3IgdGhlIGRhdGFiYXNlIHRocmVhZCB0byBjbGVhbiB1cCBhbGwgaXRzIHN0dWZmIHNvIHRo YXQgd2UKKyAgICAgICAgLy8gY2FuIGRvIG1vcmUgc3RyaW5nZW50IGxlYWsgY2hlY2tzIGFzIHdl IGV4aXQuCisgICAgICAgIGNsZWFudXBTeW5jLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOworCisg ICAgICAgIC8vIFN0aWNrIGEgc2h1dGRvd24gY29tbWFuZCBhdCB0aGUgZW5kIG9mIHRoZSBxdWV1 ZSwgc28gdGhhdCB3ZSBkZWFsCisgICAgICAgIC8vIHdpdGggYWxsIHRoZSBjbGVhbnVwIHRhc2tz IHRoZSBkYXRhYmFzZXMgcG9zdCBmaXJzdC4KKyAgICAgICAgY29udGV4dC0+cG9zdFRhc2soV29y a2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjpjcmVhdGUobV93b3JrZXJDb250ZXh0KSk7Cisg ICAgfQorCisgICAgdmlydHVhbCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0 cnVlOyB9CisKK3ByaXZhdGU6CisgICAgZXhwbGljaXQgV29ya2VyVGhyZWFkU2h1dGRvd25TdGFy dFRhc2soV29ya2VyQ29udGV4dCAqd29ya2VyQ29udGV4dCkgOiBtX3dvcmtlckNvbnRleHQod29y a2VyQ29udGV4dCkKKyAgICB7CisgICAgfQorICAgIFdvcmtlckNvbnRleHQqIG1fd29ya2VyQ29u dGV4dDsKK307CisKIHZvaWQgV29ya2VyVGhyZWFkOjpzdG9wKCkKIHsKICAgICAvLyBNdXRleCBw cm90ZWN0aW9uIGlzIG5lY2Vzc2FyeSBiZWNhdXNlIHN0b3AoKSBjYW4gYmUgY2FsbGVkIGJlZm9y ZSB0aGUgY29udGV4dCBpcyBmdWxseSBjcmVhdGVkLgogICAgIE11dGV4TG9ja2VyIGxvY2sobV90 aHJlYWRDcmVhdGlvbk11dGV4KTsKIAogICAgIC8vIEVuc3VyZSB0aGF0IHRhc2tzIGFyZSBiZWlu ZyBoYW5kbGVkIGJ5IHRocmVhZCBldmVudCBsb29wLiBJZiBzY3JpcHQgZXhlY3V0aW9uIHdlcmVu J3QgZm9yYmlkZGVuLCBhIHdoaWxlKDEpIGxvb3AgaW4gSlMgY291bGQga2VlcCB0aGUgdGhyZWFk IGFsaXZlIGZvcmV2ZXIuCi0gICAgaWYgKG1fd29ya2VyQ29udGV4dCkKKyAgICBpZiAobV93b3Jr ZXJDb250ZXh0KSB7CiAgICAgICAgIG1fd29ya2VyQ29udGV4dC0+c2NyaXB0KCktPmZvcmJpZEV4 ZWN1dGlvbigpOwogCiAgICAgLy8gRklYTUU6IFJ1ZGVseSBraWxsaW5nIHRoZSB0aHJlYWQgd29u J3Qgd29yayB3aGVuIHdlIGFsbG93IG5lc3RlZCB3b3JrZXJzLCBiZWNhdXNlIHRoZXkgd2lsbCB0 cnkgdG8gcG9zdCBub3RpZmljYXRpb25zIG9mIHRoZWlyIGRlc3RydWN0aW9uLgotICAgIG1fcnVu TG9vcC50ZXJtaW5hdGUoKTsKKyAgICAvLyBOT1RFOiB0aGlzIGNhbiBsaWtlbHkgdXNlIHRoZSBz YW1lIG1lY2hhbmlzbSBhcyB1c2VkIGZvciBkYXRhYmFzZXMgYWJvdmUuCisKKyAgICAgICAgbV9y dW5Mb29wLnBvc3RUYXNrKFdvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpjcmVhdGUobV93 b3JrZXJDb250ZXh0LmdldCgpKSk7CisgICAgfSBlbHNlCisgICAgICAgIG1fcnVuTG9vcC50ZXJt aW5hdGUoKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQo= 46193 2010-01-08 19:54:06 -0800 2010-01-11 19:20:31 -0800 Revision responding to first code review comments upload.1.patch text/plain 62977 ericu SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzAwOCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUzIEBACisyMDEwLTAxLTA4ICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVmYWN0b3JpbmcgYW5kIHBsdW1iaW5nIHRvIGdldCB0aGUgSFRNTDUgU1FMIERhdGFiYXNlIEFQ SSBhY2Nlc3NpYmxlIHRvCisgICAgICAgIHdlYiB3b3JrZXJzLiAgTm8gbmV3IGZ1bmN0aW9uYWxp dHkgaXMgZXhwb3NlZCB5ZXQ7IHRoaXMganVzdCBnZXRzIHRoZQorICAgICAgICBpbmZyYXN0cnVj dHVyZSBpbiBwbGFjZS4gIEl0IHRvdWNoZXMgYSBsb3Qgb2YgZmlsZXMgaW4gc21hbGwgd2F5czsg aGVyZQorICAgICAgICBhcmUgdGhlIG1haW4gY2hhbmdlczoKKworICAgICAgICAxKSBEYXRhYmFz ZSBtZW1iZXJzIGFuZCBtZXRob2RzIG1vdmUgZnJvbSBEb2N1bWVudCB1cCB0bworICAgICAgICBT Y3JpcHRFeGVjdXRpb25Db250ZXh0LiAgRWFjaCBvZiBEb2N1bWVudCBhbmQgV29ya2VyQ29udGV4 dCBtdXN0CisgICAgICAgIGltcGxlbWVudCBhIGZldyB2aXJ0dWFsIG1ldGhvZHMgd2hlcmUgdGhl IERhdGFiYXNlIGNvZGUgcmVxdWlyZXMKKyAgICAgICAgZGlmZmVyZW50aWF0aW9uLgorICAgICAg ICAyKSBXb3JrZXIgdGhyZWFkIHNodXRkb3duIGdvdCBjaGFuZ2VkIGEgYnVuY2ggdG8gaGFuZGxl IERhdGFiYXNlIGNsZWFudXAKKyAgICAgICAgYW5kIHRocmVhZCBzeW5jaHJvbml6YXRpb24gaXNz dWVzLiAgRGF0YWJhc2UgY2xlYW51cCB0YXNrcyBuZWVkIHRvIHBvc3QKKyAgICAgICAgc29tZSBj bGVhbnVwIHRhc2tzIHRvIHRoZSBKYXZhU2NyaXB0IHRocmVhZC4gIEhvd2V2ZXIsIHNpbmNlIGRh dGFiYXNlCisgICAgICAgIGNsZWFudXAgbWF5IGhhcHBlbiBkdWUgdG8gdGhlIGRlc3RydWN0aW9u IG9mIHRoZSBXb3JrZXJUaHJlYWQsIEkgYWRkZWQgYQorICAgICAgICBoYW5kc2hha2UgW2ludm9s dmluZyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzaywKKyAgICAgICAgV29ya2VyVGhyZWFk U2h1dGRvd25GaW5pc2hUYXNrLCBhbmQgYSBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXJdIGJldHdl ZW4KKyAgICAgICAgdGhlIERhdGFiYXNlIHRocmVhZCBhbmQgV29ya2VyVGhyZWFkIHRoYXQgY2xl YW5zIHVwIGFsbCB0aGUgRGF0YWJhc2UKKyAgICAgICAgc3R1ZmYgYmVmb3JlIHRoZSBXb3JrZXJU aHJlYWQncyBydW5Mb29wIGNhbiBleGl0LgorICAgICAgICAzKSBUaGUgcnVudGltZSBlbmFibGVy IGZvciB0aGUgRGF0YWJhc2UgbW92ZWQgdG8gYSBzdGF0aWMgdmFyaWFibGUKKyAgICAgICAgYWNj ZXNzaWJsZSB0aHJvdWdoIERhdGFiYXNlOjppc0F2YWlsYWJsZSwgZm9sbG93aW5nIHRoZSBtb2Rl bCB1c2VkIGJ5CisgICAgICAgIFdlYlNvY2tldC4KKyAgICAgICAgNCkgV29ya2VyIHRocmVhZHMg ZG9uJ3QgcnVuIHRoZWlyIEphdmFTY3JpcHQgb24gdGhlIE1haW4gdGhyZWFkLCBzbworICAgICAg ICBEYXRhYmFzZSBjb2RlIHRoYXQgZGlmZmVyZW50aWF0ZWQgYmV0d2VlbiB0aGUgTWFpbiB0aHJl YWQgYW5kIHRoZQorICAgICAgICBEYXRhYmFzZSB0aHJlYWQgbm93IG5lZWQgdG8gZGVhbCB3aXRo IGEgdGhpcmQgcG9zc2liaWxpdHkuCisgICAgICAgIDUpIE1vc3Qgb2YgdGhlIG90aGVyIGNoYW5n ZXMgaGF2ZSB0byBkbyB3aXRoIGhhdmluZyBhCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgcG9pbnRlciBpbnN0ZWFkIG9mIGEgRG9jdW1lbnQgcG9pbnRlciB3aGVuCisgICAgICAgIGRl YWxpbmcgd2l0aCBhIERhdGFiYXNlLiAgSW4gbWFueSBjYXNlcyBpdCdzIGp1c3QgYSBzdHJpbmcg cmVwbGFjZW1lbnQsCisgICAgICAgIGJ1dCBpbiBzb21lIGl0IHJlcXVpcmVkIHRoZSBjcmVhdGlv biBvZiBhIG5ldyB2aXJ0dWFsIGZ1bmN0aW9uIFtlLmcuCisgICAgICAgIGRhdGFiYXNlRXhjZWVk ZWRRdW90YSwgaXNEYXRhYmFzZVJlYWRPbmx5XQorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjcyNQorCisgICAgICAgIE5vIG5ldyB0ZXN0czsgaW4g YSBmdXR1cmUgcGF0Y2ggSSdsbCBhZGQgSlNDIGFuZCBWOCBiaW5kaW5ncyBhbmQgbmV3CisgICAg ICAgIGxheW91dCB0ZXN0cyB0byBleGVyY2lzZSB0aGVtLgorCisgICAgICAgICogYmluZGluZ3Mv djgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4RE9N V2luZG93OjpPcGVuRGF0YWJhc2VFbmFibGVkKToKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNv cmU6OkRvY3VtZW50Ojp+RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6Omlz RGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZGF0YWJhc2VF eGNlZWRlZFF1b3RhKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojppc0phdmFTY3JpcHRU aHJlYWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAgICAqIGRvbS9TY3JpcHRF eGVjdXRpb25Db250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNv bnRleHQ6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0 RXhlY3V0aW9uQ29udGV4dDo6flNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6ZGF0YWJhc2VUaHJlYWQpOgorICAgICAgICAo V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6YWRkT3BlbkRhdGFiYXNlKToKKyAgICAg ICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9wZW5EYXRhYmFzZSk6 CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdG9wRGF0YWJhc2Vz KToKKyAgICAgICAgKiBkb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oOgorICAgICAgICAoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c2V0SGFzT3BlbkRhdGFiYXNlcyk6CisgICAg ICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpoYXNPcGVuRGF0YWJhc2VzKToK KyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnBhZ2UpOgorICAgICAg ICAoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzazo6aXNDbGVhbnVwVGFzayk6 CisgICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZy YW1lTG9hZGVyOjpzdG9wTG9hZGluZyk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6 Y2FuQ2FjaGVQYWdlQ29udGFpbmluZ1RoaXNGcmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlcjo6bG9nQ2FuQ2FjaGVGcmFtZURlY2lzaW9uKToKKyAgICAgICAgKiBzdG9yYWdlL0Rh dGFiYXNlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpzZXRJc0F2YWlsYWJsZSk6 CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6aXNBdmFpbGFibGUpOgorICAgICAgICAoV2Vi Q29yZTo6RGF0YWJhc2U6Om9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFz ZTo6RGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6Y3JlYXRl KToKKyAgICAgICAgKFdlYkNvcmU6OkRlcmVmQ29udGV4dFRhc2s6OnBlcmZvcm1UYXNrKToKKyAg ICAgICAgKFdlYkNvcmU6OkRlcmVmQ29udGV4dFRhc2s6OmlzQ2xlYW51cFRhc2spOgorICAgICAg ICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6RGVyZWZDb250ZXh0VGFzayk6CisgICAgICAg IChXZWJDb3JlOjpEYXRhYmFzZTo6fkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFi YXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbik6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6 bWFya0FzRGVsZXRlZEFuZENsb3NlKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRleHRSZW1vdmVP cGVuRGF0YWJhc2VUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4dFJlbW92 ZU9wZW5EYXRhYmFzZVRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRl eHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjppc0NsZWFudXBUYXNrKToKKyAgICAgICAgKFdlYkNv cmU6OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpDb250ZXh0UmVtb3ZlT3BlbkRhdGFi YXNlVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6Y2xvc2UpOgorICAgICAgICAo V2ViQ29yZTo6RGF0YWJhc2U6OnBlcmZvcm1PcGVuQW5kVmVyaWZ5KToKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkRh dGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uU3RlcCk6CisgICAgICAgIChXZWJDb3JlOjpEZWxp dmVyUGVuZGluZ0NhbGxiYWNrVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGl2 ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpE ZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzazo6RGVsaXZlclBlbmRpbmdDYWxsYmFja1Rhc2spOgor ICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25DYWxsYmFjayk6 CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6dHJhbnNhY3Rpb25DbGllbnQpOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YWJhc2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IpOgorICAgICAgICAo V2ViQ29yZTo6RGF0YWJhc2U6OnRhYmxlTmFtZXMpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJh c2U6OnNlY3VyaXR5T3JpZ2luKToKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNlLmg6CisgICAg ICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6ZXhlY3V0aW9uQ29udGV4dCk6CisgICAgICAgICogc3Rv cmFnZS9EYXRhYmFzZVRhc2suaDoKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpEYXRhYmFzZVRocmVhZCk6Cisg ICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6fkRhdGFiYXNlVGhyZWFkKToKKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRpb24pOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OmRhdGFiYXNlVGhyZWFkKToKKyAgICAgICAgKFdl YkNvcmU6OkRhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyk6CisgICAgICAg ICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VU cmFja2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJs aXNoRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpnZXRNYXhT aXplRm9yRGF0YWJhc2UpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUcmFja2VyLmg6Cisg ICAgICAgICogc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpT UUxUcmFuc2FjdGlvbjo6ZXhlY3V0ZVNRTCk6CisgICAgICAgICogc3RvcmFnZS9TUUxUcmFuc2Fj dGlvbkNsaWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbkNsaWVudDo6 ZGlkQ29tbWl0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6U1FMVHJhbnNhY3Rpb25D bGllbnQ6OmRpZEV4ZWN1dGVTdGF0ZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6U1FMVHJhbnNh Y3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKToKKyAgICAgICAgKiBzdG9yYWdlL2Nocm9taXVt L0RhdGFiYXNlVHJhY2tlckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNl VHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJh c2VUcmFja2VyOjphZGRPcGVuRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6VHJhY2tlclJl bW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpUcmFja2Vy UmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6 VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OlRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VU YXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6cmVtb3ZlT3BlbkRhdGFi YXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6Z2V0TWF4U2l6ZUZvckRh dGFiYXNlKToKKyAgICAgICAgKiBzdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0aW9uQ2xpZW50 Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFz azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2s6 OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRh c2s6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6U1FMVHJh bnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6 OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhdGVtZW50KToKKyAgICAgICAgKFdl YkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YSk6CisgICAgICAgICog d29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRl eHQ6Om9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJDb250ZXh0Ojppc0ph dmFTY3JpcHRUaHJlYWQpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6Y2xlYXJTY3JpcHQpOgorICAgICAgICAoV2Vi Q29yZTo6V29ya2VyQ29udGV4dDo6dGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNv bnRleHQ6OmlzRGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJDb250 ZXh0OjpkYXRhYmFzZUV4Y2VlZGVkUXVvdGEpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29u dGV4dC5pZGw6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJSdW5Mb29wLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OldvcmtlclJ1bkxvb3A6OnJ1bkluTW9kZSk6CisgICAgICAgIChXZWJDb3JlOjpX b3JrZXJSdW5Mb29wOjpUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgICogd29ya2Vycy9Xb3Jr ZXJUaHJlYWQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkOjp3b3JrZXJUaHJl YWQpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjpj cmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNr OjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93bkZp bmlzaFRhc2s6OmlzQ2xlYW51cFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFk U2h1dGRvd25GaW5pc2hUYXNrOjpXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2spOgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6OmNyZWF0ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6cGVyZm9ybVRh c2spOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6Omlz Q2xlYW51cFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFy dFRhc2s6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6 OldvcmtlclRocmVhZDo6c3RvcCk6CisKIDIwMTAtMDEtMDggIEx1aXogQWdvc3RpbmkgIDxsdWl6 LmFnb3N0aW5pQG9wZW5ib3NzYS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBS b2hkZSBDaHJpc3RpYW5zZW4uCkluZGV4OiBXZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERP TVdpbmRvd0N1c3RvbS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0 b20vVjhET01XaW5kb3dDdXN0b20uY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvYmlu ZGluZ3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MzMsNiArMzMsNyBAQAogCiAjaW5jbHVkZSAiQmFzZTY0LmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgi CisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKICNpbmNsdWRlICJET01UaW1lci5oIgogI2luY2x1ZGUg IkRPTVdpbmRvdy5oIgogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKQEAgLTI5NSw3ICsyOTYs NyBAQCBib29sIFY4RE9NV2luZG93OjpXZWJTb2NrZXRFbmFibGVkKCkKICNpZiBFTkFCTEUoREFU QUJBU0UpCiBib29sIFY4RE9NV2luZG93OjpPcGVuRGF0YWJhc2VFbmFibGVkKCkKIHsKLSAgICBy ZXR1cm4gV2ViQ29yZTo6UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZGF0YWJhc2VFbmFibGVkKCk7 CisgICAgcmV0dXJuIERhdGFiYXNlOjppc0F2YWlsYWJsZSgpOwogfQogI2VuZGlmCiAKSW5kZXg6 IFdlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Eb2N1 bWVudC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2lu Y2x1ZGUgIkNhY2hlZENTU1N0eWxlU2hlZXQuaCIKICNpbmNsdWRlICJDaHJvbWUuaCIKKyNpbmNs dWRlICJDaHJvbWVDbGllbnQuaCIKICNpbmNsdWRlICJDb21tZW50LmgiCiAjaW5jbHVkZSAiQ29u c29sZS5oIgogI2luY2x1ZGUgIkNvb2tpZUphci5oIgpAQCAtMTM3LDExICsxMzgsNiBAQAogI2lu Y2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgog Ci0jaWYgRU5BQkxFKERBVEFCQVNFKQotI2luY2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5jbHVkZSAi RGF0YWJhc2VUaHJlYWQuaCIKLSNlbmRpZgotCiAjaWYgRU5BQkxFKFNIQVJFRF9XT1JLRVJTKQog I2luY2x1ZGUgIlNoYXJlZFdvcmtlclJlcG9zaXRvcnkuaCIKICNlbmRpZgpAQCAtMzUwLDkgKzM0 Niw2IEBAIERvY3VtZW50OjpEb2N1bWVudChGcmFtZSogZnJhbWUsIGJvb2wgaXMKICAgICAsIG1f dXNlU2VjdXJlS2V5Ym9hcmRFbnRyeVdoZW5BY3RpdmUoZmFsc2UpCiAgICAgLCBtX2lzWEhUTUwo aXNYSFRNTCkKICAgICAsIG1fbnVtTm9kZUxpc3RDYWNoZXMoMCkKLSNpZiBFTkFCTEUoREFUQUJB U0UpCi0gICAgLCBtX2hhc09wZW5EYXRhYmFzZXMoZmFsc2UpCi0jZW5kaWYKICAgICAsIG1fdXNp bmdHZW9sb2NhdGlvbihmYWxzZSkKICNpZiBFTkFCTEUoV01MKQogICAgICwgbV9jb250YWluc1dN TENvbnRlbnQoZmFsc2UpCkBAIC01MDAsMTMgKzQ5Myw2IEBAIERvY3VtZW50Ojp+RG9jdW1lbnQo KQogICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBjb3VudDsgaSsrKQogICAgICAgICBkZWxl dGVBbGxWYWx1ZXMobV9uYW1lQ29sbGVjdGlvbkluZm9baV0pOwogCi0jaWYgRU5BQkxFKERBVEFC QVNFKQotICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKSB7Ci0gICAgICAgIEFTU0VSVChtX2RhdGFi YXNlVGhyZWFkLT50ZXJtaW5hdGlvblJlcXVlc3RlZCgpKTsKLSAgICAgICAgbV9kYXRhYmFzZVRo cmVhZCA9IDA7Ci0gICAgfQotI2VuZGlmCi0KICAgICBpZiAobV9zdHlsZVNoZWV0cykKICAgICAg ICAgbV9zdHlsZVNoZWV0cy0+ZG9jdW1lbnREZXN0cm95ZWQoKTsKIH0KQEAgLTQzOTQsNiArNDM4 MCwzMCBAQCB2b2lkIERvY3VtZW50OjpzZXRTZWN1cml0eU9yaWdpbihTZWN1cml0CiAgICAgaW5p dEROU1ByZWZldGNoKCk7CiB9CiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisKK2Jvb2wgRG9jdW1l bnQ6OmlzRGF0YWJhc2VSZWFkT25seSgpIGNvbnN0Cit7CisgICAgUGFnZSogcGFnZSA9IGRvY3Vt ZW50KCktPnBhZ2UoKTsKKyAgICBpZiAoIXBhZ2UgfHwgcGFnZS0+c2V0dGluZ3MoKS0+cHJpdmF0 ZUJyb3dzaW5nRW5hYmxlZCgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICByZXR1cm4gZmFs c2U7Cit9CisKK3ZvaWQgRG9jdW1lbnQ6OmRhdGFiYXNlRXhjZWVkZWRRdW90YShjb25zdCBTdHJp bmcmIG5hbWUpCit7CisgICAgUGFnZSogY3VycmVudFBhZ2UgPSBwYWdlKCk7CisgICAgQVNTRVJU KGN1cnJlbnRQYWdlKTsKKyAgICBjdXJyZW50UGFnZS0+Y2hyb21lKCktPmNsaWVudCgpLT5leGNl ZWRlZERhdGFiYXNlUXVvdGEoZG9jdW1lbnQoKS0+ZnJhbWUoKSwgbmFtZSk7Cit9CisKKyNlbmRp ZgorCitib29sIERvY3VtZW50Ojppc0phdmFTY3JpcHRUaHJlYWQoKSBjb25zdAoreworICAgIHJl dHVybiBXVEY6OmlzTWFpblRocmVhZCgpOworfQorCiB2b2lkIERvY3VtZW50Ojp1cGRhdGVVUkxG b3JQdXNoT3JSZXBsYWNlU3RhdGUoY29uc3QgS1VSTCYgdXJsKQogewogICAgIEZyYW1lKiBmID0g ZnJhbWUoKTsKQEAgLTQ0OTQsNTcgKzQ1MDQsNiBAQCBET01TZWxlY3Rpb24qIERvY3VtZW50Ojpn ZXRTZWxlY3Rpb24oKSBjCiAgICAgcmV0dXJuIGZyYW1lKCkgPyBmcmFtZSgpLT5kb21XaW5kb3co KS0+Z2V0U2VsZWN0aW9uKCkgOiAwOwogfQogCi0jaWYgRU5BQkxFKERBVEFCQVNFKQotCi12b2lk IERvY3VtZW50OjphZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIGlm ICghbV9vcGVuRGF0YWJhc2VTZXQpCi0gICAgICAgIG1fb3BlbkRhdGFiYXNlU2V0LnNldChuZXcg RGF0YWJhc2VTZXQpOwotCi0gICAgQVNTRVJUKCFtX29wZW5EYXRhYmFzZVNldC0+Y29udGFpbnMo ZGF0YWJhc2UpKTsKLSAgICBtX29wZW5EYXRhYmFzZVNldC0+YWRkKGRhdGFiYXNlKTsKLX0KLQot dm9pZCBEb2N1bWVudDo6cmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsK LSAgICBBU1NFUlQobV9vcGVuRGF0YWJhc2VTZXQgJiYgbV9vcGVuRGF0YWJhc2VTZXQtPmNvbnRh aW5zKGRhdGFiYXNlKSk7Ci0gICAgaWYgKCFtX29wZW5EYXRhYmFzZVNldCkKLSAgICAgICAgcmV0 dXJuOwotICAgICAgICAKLSAgICBtX29wZW5EYXRhYmFzZVNldC0+cmVtb3ZlKGRhdGFiYXNlKTsK LX0KLQotRGF0YWJhc2VUaHJlYWQqIERvY3VtZW50OjpkYXRhYmFzZVRocmVhZCgpCi17Ci0gICAg aWYgKCFtX2RhdGFiYXNlVGhyZWFkICYmICFtX2hhc09wZW5EYXRhYmFzZXMpIHsKLSAgICAgICAg Ly8gQ3JlYXRlIHRoZSBkYXRhYmFzZSB0aHJlYWQgb24gZmlyc3QgcmVxdWVzdCAtIGJ1dCBub3Qg aWYgYXQgbGVhc3Qgb25lIGRhdGFiYXNlIHdhcyBhbHJlYWR5IG9wZW5lZCwKLSAgICAgICAgLy8g YmVjYXVzZSBpbiB0aGF0IGNhc2Ugd2UgYWxyZWFkeSBoYWQgYSBkYXRhYmFzZSB0aHJlYWQgYW5k IHRlcm1pbmF0ZWQgaXQgYW5kIHNob3VsZCBub3QgY3JlYXRlIGFub3RoZXIuCi0gICAgICAgIG1f ZGF0YWJhc2VUaHJlYWQgPSBEYXRhYmFzZVRocmVhZDo6Y3JlYXRlKCk7Ci0gICAgICAgIGlmICgh bV9kYXRhYmFzZVRocmVhZC0+c3RhcnQoKSkKLSAgICAgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQg PSAwOwotICAgIH0KLQotICAgIHJldHVybiBtX2RhdGFiYXNlVGhyZWFkLmdldCgpOwotfQotCi12 b2lkIERvY3VtZW50OjpzdG9wRGF0YWJhc2VzKCkKLXsKLSAgICBpZiAobV9vcGVuRGF0YWJhc2VT ZXQpIHsKLSAgICAgICAgRGF0YWJhc2VTZXQ6Oml0ZXJhdG9yIGkgPSBtX29wZW5EYXRhYmFzZVNl dC0+YmVnaW4oKTsKLSAgICAgICAgRGF0YWJhc2VTZXQ6Oml0ZXJhdG9yIGVuZCA9IG1fb3BlbkRh dGFiYXNlU2V0LT5lbmQoKTsKLSAgICAgICAgZm9yICg7IGkgIT0gZW5kOyArK2kpIHsKLSAgICAg ICAgICAgICgqaSktPnN0b3AoKTsKLSAgICAgICAgICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKQot ICAgICAgICAgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQtPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tz KCppKTsKLSAgICAgICAgfQotICAgIH0KLSAgICAKLSAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkK LSAgICAgICAgbV9kYXRhYmFzZVRocmVhZC0+cmVxdWVzdFRlcm1pbmF0aW9uKCk7Ci19Ci0KLSNl bmRpZgotCiAjaWYgRU5BQkxFKFdNTCkKIHZvaWQgRG9jdW1lbnQ6OnJlc2V0V01MUGFnZVN0YXRl KCkKIHsKSW5kZXg6IFdlYkNvcmUvZG9tL0RvY3VtZW50LmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9kb20vRG9jdW1lbnQuaAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL2RvbS9Eb2N1bWVu dC5oCSh3b3JraW5nIGNvcHkpCkBAIC05MTQsMTQgKzkxNCwxMiBAQCBwdWJsaWM6CiAgICAgYm9v bCBwcm9jZXNzaW5nTG9hZEV2ZW50KCkgY29uc3QgeyByZXR1cm4gbV9wcm9jZXNzaW5nTG9hZEV2 ZW50OyB9CiAKICNpZiBFTkFCTEUoREFUQUJBU0UpCi0gICAgdm9pZCBhZGRPcGVuRGF0YWJhc2Uo RGF0YWJhc2UqKTsKLSAgICB2b2lkIHJlbW92ZU9wZW5EYXRhYmFzZShEYXRhYmFzZSopOwotICAg IERhdGFiYXNlVGhyZWFkKiBkYXRhYmFzZVRocmVhZCgpOyAgIC8vIENyZWF0ZXMgdGhlIHRocmVh ZCBhcyBuZWVkZWQsIGJ1dCBub3QgaWYgaXQgaGFzIGJlZW4gYWxyZWFkeSB0ZXJtaW5hdGVkLgot ICAgIHZvaWQgc2V0SGFzT3BlbkRhdGFiYXNlcygpIHsgbV9oYXNPcGVuRGF0YWJhc2VzID0gdHJ1 ZTsgfQotICAgIGJvb2wgaGFzT3BlbkRhdGFiYXNlcygpIHsgcmV0dXJuIG1faGFzT3BlbkRhdGFi YXNlczsgfQotICAgIHZvaWQgc3RvcERhdGFiYXNlcygpOworICAgIHZpcnR1YWwgYm9vbCBpc0Rh dGFiYXNlUmVhZE9ubHkoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgZGF0YWJhc2VFeGNlZWRl ZFF1b3RhKGNvbnN0IFN0cmluZyYgbmFtZSk7CiAjZW5kaWYKIAorICAgIHZpcnR1YWwgYm9vbCBp c0phdmFTY3JpcHRUaHJlYWQoKSBjb25zdDsKKwogICAgIHZvaWQgc2V0VXNpbmdHZW9sb2NhdGlv bihib29sIGYpIHsgbV91c2luZ0dlb2xvY2F0aW9uID0gZjsgfQogICAgIGJvb2wgdXNpbmdHZW9s b2NhdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fdXNpbmdHZW9sb2NhdGlvbjsgfTsKIApAQCAtMTE4 MywxMyArMTE4MSw2IEBAIHByaXZhdGU6CiAgICAgSlNXcmFwcGVyQ2FjaGVNYXAgbV93cmFwcGVy Q2FjaGVNYXA7CiAjZW5kaWYKIAotI2lmIEVOQUJMRShEQVRBQkFTRSkKLSAgICBSZWZQdHI8RGF0 YWJhc2VUaHJlYWQ+IG1fZGF0YWJhc2VUaHJlYWQ7Ci0gICAgYm9vbCBtX2hhc09wZW5EYXRhYmFz ZXM7ICAgIC8vIFRoaXMgbmV2ZXIgY2hhbmdlcyBiYWNrIHRvIGZhbHNlLCBldmVuIGFzIHRoZSBk YXRhYmFzZSB0aHJlYWQgaXMgY2xvc2VkLgotICAgIHR5cGVkZWYgSGFzaFNldDxEYXRhYmFzZSo+ IERhdGFiYXNlU2V0OwotICAgIE93blB0cjxEYXRhYmFzZVNldD4gbV9vcGVuRGF0YWJhc2VTZXQ7 Ci0jZW5kaWYKLSAgICAKICAgICBib29sIG1fdXNpbmdHZW9sb2NhdGlvbjsKIAogI2lmIEVOQUJM RShXTUwpCkluZGV4OiBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAkocmV2aXNp b24gNTI5OTUpCisrKyBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAkod29y a2luZyBjb3B5KQpAQCAtMjgsNyArMjgsOCBAQAogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNv bnRleHQuaCIKIAogI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5oIgotI2luY2x1ZGUgIkRvY3Vt ZW50LmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUYXNrLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUaHJl YWQuaCIKICNpbmNsdWRlICJNZXNzYWdlUG9ydC5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2lu LmgiCiAjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgpAQCAtNTYsNiArNTcsOSBAQCBwdWJsaWM6 CiB9OwogCiBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KCkK KyNpZiBFTkFCTEUoREFUQUJBU0UpCisgICAgOiBtX2hhc09wZW5EYXRhYmFzZXMoZmFsc2UpCisj ZW5kaWYKIHsKIH0KIApAQCAtNzIsOCArNzYsNjQgQEAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6 flNjcmlwdEV4ZWN1dGlvbgogICAgICAgICBBU1NFUlQoKCppdGVyKS0+c2NyaXB0RXhlY3V0aW9u Q29udGV4dCgpID09IHRoaXMpOwogICAgICAgICAoKml0ZXIpLT5jb250ZXh0RGVzdHJveWVkKCk7 CiAgICAgfQorICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKSB7CisgICAgICAgIEFTU0VSVChtX2Rh dGFiYXNlVGhyZWFkLT50ZXJtaW5hdGlvblJlcXVlc3RlZCgpKTsKKyAgICAgICAgbV9kYXRhYmFz ZVRocmVhZCA9IDA7CisgICAgfQogfQogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorCitEYXRhYmFz ZVRocmVhZCogU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6ZGF0YWJhc2VUaHJlYWQoKQoreworICAg IGlmICghbV9kYXRhYmFzZVRocmVhZCAmJiAhbV9oYXNPcGVuRGF0YWJhc2VzKSB7CisgICAgICAg IC8vIENyZWF0ZSB0aGUgZGF0YWJhc2UgdGhyZWFkIG9uIGZpcnN0IHJlcXVlc3QgLSBidXQgbm90 IGlmIGF0IGxlYXN0IG9uZSBkYXRhYmFzZSB3YXMgYWxyZWFkeSBvcGVuZWQsCisgICAgICAgIC8v IGJlY2F1c2UgaW4gdGhhdCBjYXNlIHdlIGFscmVhZHkgaGFkIGEgZGF0YWJhc2UgdGhyZWFkIGFu ZCB0ZXJtaW5hdGVkIGl0IGFuZCBzaG91bGQgbm90IGNyZWF0ZSBhbm90aGVyLgorICAgICAgICBt X2RhdGFiYXNlVGhyZWFkID0gRGF0YWJhc2VUaHJlYWQ6OmNyZWF0ZSgpOworICAgICAgICBpZiAo IW1fZGF0YWJhc2VUaHJlYWQtPnN0YXJ0KCkpCisgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFk ID0gMDsKKyAgICB9CisKKyAgICByZXR1cm4gbV9kYXRhYmFzZVRocmVhZC5nZXQoKTsKK30KKwor dm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjphZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRh dGFiYXNlKQoreworICAgIGlmICghbV9vcGVuRGF0YWJhc2VTZXQpCisgICAgICAgIG1fb3BlbkRh dGFiYXNlU2V0LnNldChuZXcgRGF0YWJhc2VTZXQoKSk7CisKKyAgICBBU1NFUlQoIW1fb3BlbkRh dGFiYXNlU2V0LT5jb250YWlucyhkYXRhYmFzZSkpOworICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5h ZGQoZGF0YWJhc2UpOworfQorCit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9w ZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCit7CisgICAgQVNTRVJUKG1fb3BlbkRhdGFi YXNlU2V0ICYmIG1fb3BlbkRhdGFiYXNlU2V0LT5jb250YWlucyhkYXRhYmFzZSkpOworICAgIGlm ICghbV9vcGVuRGF0YWJhc2VTZXQpCisgICAgICAgIHJldHVybjsKKyAgICBtX29wZW5EYXRhYmFz ZVNldC0+cmVtb3ZlKGRhdGFiYXNlKTsKK30KKwordm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0 OjpzdG9wRGF0YWJhc2VzKERhdGFiYXNlVGFza1N5bmNocm9uaXplciAqY2xlYW51cFN5bmMpCit7 CisgICAgaWYgKG1fb3BlbkRhdGFiYXNlU2V0KSB7CisgICAgICAgIERhdGFiYXNlU2V0OjppdGVy YXRvciBpID0gbV9vcGVuRGF0YWJhc2VTZXQtPmJlZ2luKCk7CisgICAgICAgIERhdGFiYXNlU2V0 OjppdGVyYXRvciBlbmQgPSBtX29wZW5EYXRhYmFzZVNldC0+ZW5kKCk7CisgICAgICAgIGZvciAo OyBpICE9IGVuZDsgKytpKSB7CisgICAgICAgICAgICAoKmkpLT5zdG9wKCk7CisgICAgICAgICAg ICBpZiAobV9kYXRhYmFzZVRocmVhZCkKKyAgICAgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFk LT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcygqaSk7CisgICAgICAgIH0KKyAgICB9CisgICAgCisg ICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpCisgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQtPnJlcXVl c3RUZXJtaW5hdGlvbihjbGVhbnVwU3luYyk7CisgICAgZWxzZSBpZiAoY2xlYW51cFN5bmMpCisg ICAgICAgIGNsZWFudXBTeW5jLT50YXNrQ29tcGxldGVkKCk7Cit9CisKKyNlbmRpZgorCiB2b2lk IFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnByb2Nlc3NNZXNzYWdlUG9ydE1lc3NhZ2VzU29vbigp CiB7CiAgICAgcG9zdFRhc2soUHJvY2Vzc01lc3NhZ2VzU29vblRhc2s6OmNyZWF0ZSgpKTsKSW5k ZXg6IFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgJKHJldmlzaW9uIDUyOTk1KQorKysg V2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oCSh3b3JraW5nIGNvcHkpCkBAIC0z MywxMSArMzMsMTcgQEAKICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9Q YXNzT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYv UmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAKICAgICBjbGFzcyBBY3RpdmVET01PYmplY3Q7CisjaWYgRU5BQkxFKERBVEFCQVNFKQor ICAgIGNsYXNzIERhdGFiYXNlOworICAgIGNsYXNzIERhdGFiYXNlVGFza1N5bmNocm9uaXplcjsK KyAgICBjbGFzcyBEYXRhYmFzZVRocmVhZDsKKyNlbmRpZgogICAgIGNsYXNzIERPTVRpbWVyOwog ICAgIGNsYXNzIE1lc3NhZ2VQb3J0OwogICAgIGNsYXNzIFNlY3VyaXR5T3JpZ2luOwpAQCAtNTks NiArNjUsMTkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIGJvb2wgaXNE b2N1bWVudCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgICAgIHZpcnR1YWwgYm9vbCBp c1dvcmtlckNvbnRleHQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCisjaWYgRU5BQkxFKERB VEFCQVNFKQorICAgICAgICB2aXJ0dWFsIGJvb2wgaXNEYXRhYmFzZVJlYWRPbmx5KCkgY29uc3Qg PSAwOworICAgICAgICB2aXJ0dWFsIHZvaWQgZGF0YWJhc2VFeGNlZWRlZFF1b3RhKGNvbnN0IFN0 cmluZyYgbmFtZSkgPSAwOworICAgICAgICBEYXRhYmFzZVRocmVhZCAqZGF0YWJhc2VUaHJlYWQo KTsKKyAgICAgICAgdm9pZCBzZXRIYXNPcGVuRGF0YWJhc2VzKCkgeyBtX2hhc09wZW5EYXRhYmFz ZXMgPSB0cnVlOyB9CisgICAgICAgIGJvb2wgaGFzT3BlbkRhdGFiYXNlcygpIGNvbnN0IHsgcmV0 dXJuIG1faGFzT3BlbkRhdGFiYXNlczsgfQorICAgICAgICB2b2lkIGFkZE9wZW5EYXRhYmFzZShE YXRhYmFzZSopOworICAgICAgICB2b2lkIHJlbW92ZU9wZW5EYXRhYmFzZShEYXRhYmFzZSopOwor ICAgICAgICAvLyBXaGVuIHRoZSBkYXRhYmFzZSBjbGVhbnVwIGlzIGRvbmUsIGNsZWFudXBTeW5j IHdpbGwgYmUgc2lnbmFsbGVkLgorICAgICAgICB2b2lkIHN0b3BEYXRhYmFzZXMoRGF0YWJhc2VU YXNrU3luY2hyb25pemVyICpjbGVhbnVwU3luYyk7CisjZW5kaWYKKyAgICAgICAgdmlydHVhbCBi b29sIGlzSmF2YVNjcmlwdFRocmVhZCgpIGNvbnN0ID0gMDsKKwogICAgICAgICBjb25zdCBLVVJM JiB1cmwoKSBjb25zdCB7IHJldHVybiB2aXJ0dWFsVVJMKCk7IH0KICAgICAgICAgS1VSTCBjb21w bGV0ZVVSTChjb25zdCBTdHJpbmcmIHVybCkgY29uc3QgeyByZXR1cm4gdmlydHVhbENvbXBsZXRl VVJMKHVybCk7IH0KIApAQCAtOTcsNiArMTE2LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg ICAgICBwdWJsaWM6CiAgICAgICAgICAgICB2aXJ0dWFsIH5UYXNrKCk7CiAgICAgICAgICAgICB2 aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopID0gMDsKKyAg ICAgICAgICAgIC8vIENlcnRhaW4gdGFza3MgZ2V0IG1hcmtlZCBzcGVjaWFsbHkgc28gdGhhdCB0 aGV5IGFyZW4ndCBkaXNjYXJkZWQsIGFuZCBhcmUgZXhlY3V0ZWQsIHdoZW4gdGhlIGNvbnRleHQg aXMgc2h1dHRpbmcgZG93biBpdHMgbWVzc2FnZSBxdWV1ZS4KKyAgICAgICAgICAgIHZpcnR1YWwg Ym9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICAgICAgfTsK IAogICAgICAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soUGFzc093blB0cjxUYXNrPikgPSAwOyAv LyBFeGVjdXRlcyB0aGUgdGFzayBvbiBjb250ZXh0J3MgdGhyZWFkIGFzeW5jaHJvbm91c2x5LgpA QCAtMTI5LDYgKzE1MCwxMyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdmlydHVh bCB2b2lkIHJlZlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA9IDA7CiAgICAgICAgIHZpcnR1YWwg dm9pZCBkZXJlZlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA9IDA7CisKKyNpZiBFTkFCTEUoREFU QUJBU0UpCisgICAgICAgIFJlZlB0cjxEYXRhYmFzZVRocmVhZD4gbV9kYXRhYmFzZVRocmVhZDsK KyAgICAgICAgYm9vbCBtX2hhc09wZW5EYXRhYmFzZXM7IC8vIFRoaXMgbmV2ZXIgY2hhbmdlcyBi YWNrIHRvIGZhbHNlLCBldmVuIGFmdGVyIHRoZSBkYXRhYmFzZSB0aHJlYWQgaXMgY2xvc2VkLgor ICAgICAgICB0eXBlZGVmIEhhc2hTZXQ8RGF0YWJhc2UgKj4gRGF0YWJhc2VTZXQ7CisgICAgICAg IE93blB0cjxEYXRhYmFzZVNldD4gbV9vcGVuRGF0YWJhc2VTZXQ7CisjZW5kaWYKICAgICB9Owog CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRl ci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCShyZXZp c2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAkod29ya2luZyBj b3B5KQpAQCAtNTU5LDcgKzU1OSw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnN0b3BMb2FkaW5nKFVu bG9hZEV2ZW4KIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKICAgICAgICAgaWYgKGRhdGFiYXNlUG9s aWN5ID09IERhdGFiYXNlUG9saWN5U3RvcCkKLSAgICAgICAgICAgIGRvYy0+c3RvcERhdGFiYXNl cygpOworICAgICAgICAgICAgZG9jLT5zdG9wRGF0YWJhc2VzKDApOwogI2Vsc2UKICAgICBVTlVT RURfUEFSQU0oZGF0YWJhc2VQb2xpY3kpOwogI2VuZGlmCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2Uv RGF0YWJhc2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAJ KHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtNTMsOCArNTMsOCBAQAogI2luY2x1ZGUgIlNRTFJlc3VsdFNldC5oIgogI2lu Y2x1ZGUgIlNRTFRyYW5zYWN0aW9uQ2xpZW50LmgiCiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb25D b29yZGluYXRvci5oIgotI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+Ci0jZW5kaWYKKworI2Vu ZGlmIC8vIEVOQUJMRShEQVRBQkFTRSkKIAogI2lmIFVTRShKU0MpCiAjaW5jbHVkZSAiSlNET01X aW5kb3cuaCIKQEAgLTczLDYgKzczLDE4IEBAIGNvbnN0IFN0cmluZyYgRGF0YWJhc2U6OmRhdGFi YXNlSW5mb1RhYmwKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKIAorc3RhdGljIGJvb2wgaXNEYXRh YmFzZUF2YWlsYWJsZSA9IGZhbHNlOworCit2b2lkIERhdGFiYXNlOjpzZXRJc0F2YWlsYWJsZShi b29sIGF2YWlsYWJsZSkKK3sKKyAgICBpc0RhdGFiYXNlQXZhaWxhYmxlID0gYXZhaWxhYmxlOwor fQorCitib29sIERhdGFiYXNlOjppc0F2YWlsYWJsZSgpCit7CisgICAgcmV0dXJuIGlzRGF0YWJh c2VBdmFpbGFibGU7Cit9CisKIHN0YXRpYyBNdXRleCYgZ3VpZE11dGV4KCkKIHsKICAgICAvLyBO b3RlOiBXZSBkb24ndCBoYXZlIHRvIHVzZSBBdG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWMgaGVy ZSBiZWNhdXNlCkBAIC0xMjAsMzkgKzEzMiw0MSBAQCBzdGF0aWMgY29uc3QgU3RyaW5nJiBkYXRh YmFzZVZlcnNpb25LZXkoCiAKIHN0YXRpYyBpbnQgZ3VpZEZvck9yaWdpbkFuZE5hbWUoY29uc3Qg U3RyaW5nJiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgbmFtZSk7CiAKLVBhc3NSZWZQdHI8RGF0YWJh c2U+IERhdGFiYXNlOjpvcGVuRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmIGUp CitQYXNzUmVmUHRyPERhdGFiYXNlPiBEYXRhYmFzZTo6b3BlbkRhdGFiYXNlKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQgKmNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBl eHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZSkKIHsKLSAgICBpZiAoIURhdGFiYXNlVHJh Y2tlcjo6dHJhY2tlcigpLmNhbkVzdGFibGlzaERhdGFiYXNlKGRvY3VtZW50LCBuYW1lLCBkaXNw bGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSkpIHsKKyAgICBpZiAoIURhdGFiYXNlVHJhY2tlcjo6dHJh Y2tlcigpLmNhbkVzdGFibGlzaERhdGFiYXNlKGNvbnRleHQsIG5hbWUsIGRpc3BsYXlOYW1lLCBl c3RpbWF0ZWRTaXplKSkgewogICAgICAgICAvLyBGSVhNRTogVGhlcmUgc2hvdWxkIGJlIGFuIGV4 Y2VwdGlvbiByYWlzZWQgaGVyZSBpbiBhZGRpdGlvbiB0byByZXR1cm5pbmcgYSBudWxsIERhdGFi YXNlIG9iamVjdC4gIFRoZSBxdWVzdGlvbiBoYXMgYmVlbiByYWlzZWQgd2l0aCB0aGUgV0hBVFdH LgotICAgICAgICBMT0coU3RvcmFnZUFQSSwgIkRhdGFiYXNlICVzIGZvciBvcmlnaW4gJXMgbm90 IGFsbG93ZWQgdG8gYmUgZXN0YWJsaXNoZWQiLCBuYW1lLmFzY2lpKCkuZGF0YSgpLCBkb2N1bWVu dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKS5hc2NpaSgpLmRhdGEoKSk7CisgICAgICAg IExPRyhTdG9yYWdlQVBJLCAiRGF0YWJhc2UgJXMgZm9yIG9yaWdpbiAlcyBub3QgYWxsb3dlZCB0 byBiZSBlc3RhYmxpc2hlZCIsIG5hbWUuYXNjaWkoKS5kYXRhKCksIGNvbnRleHQtPnNlY3VyaXR5 T3JpZ2luKCktPnRvU3RyaW5nKCkuYXNjaWkoKS5kYXRhKCkpOwogICAgICAgICByZXR1cm4gMDsK ICAgICB9CiAKLSAgICBSZWZQdHI8RGF0YWJhc2U+IGRhdGFiYXNlID0gYWRvcHRSZWYobmV3IERh dGFiYXNlKGRvY3VtZW50LCBuYW1lLCBleHBlY3RlZFZlcnNpb24sIGRpc3BsYXlOYW1lLCBlc3Rp bWF0ZWRTaXplKSk7CisgICAgUmVmUHRyPERhdGFiYXNlPiBkYXRhYmFzZSA9IGFkb3B0UmVmKG5l dyBEYXRhYmFzZShjb250ZXh0LCBuYW1lLCBleHBlY3RlZFZlcnNpb24sIGRpc3BsYXlOYW1lLCBl c3RpbWF0ZWRTaXplKSk7CiAKICAgICBpZiAoIWRhdGFiYXNlLT5vcGVuQW5kVmVyaWZ5VmVyc2lv bihlKSkgewogICAgICAgICBMT0coU3RvcmFnZUFQSSwgIkZhaWxlZCB0byBvcGVuIGFuZCB2ZXJp ZnkgdmVyc2lvbiAoZXhwZWN0ZWQgJXMpIG9mIGRhdGFiYXNlICVzIiwgZXhwZWN0ZWRWZXJzaW9u LmFzY2lpKCkuZGF0YSgpLCBkYXRhYmFzZS0+ZGF0YWJhc2VEZWJ1Z05hbWUoKS5hc2NpaSgpLmRh dGEoKSk7Ci0gICAgICAgIGRvY3VtZW50LT5yZW1vdmVPcGVuRGF0YWJhc2UoZGF0YWJhc2UuZ2V0 KCkpOworICAgICAgICBjb250ZXh0LT5yZW1vdmVPcGVuRGF0YWJhc2UoZGF0YWJhc2UuZ2V0KCkp OwogICAgICAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5yZW1vdmVPcGVuRGF0YWJhc2Uo ZGF0YWJhc2UuZ2V0KCkpOwogICAgICAgICByZXR1cm4gMDsKICAgICB9CiAKLSAgICBEYXRhYmFz ZVRyYWNrZXI6OnRyYWNrZXIoKS5zZXREYXRhYmFzZURldGFpbHMoZG9jdW1lbnQtPnNlY3VyaXR5 T3JpZ2luKCksIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKTsKLQotICAgIGRvY3Vt ZW50LT5zZXRIYXNPcGVuRGF0YWJhc2VzKCk7CisgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2Vy KCkuc2V0RGF0YWJhc2VEZXRhaWxzKGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCksIG5hbWUsIGRp c3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKTsKIAorICAgIGNvbnRleHQtPnNldEhhc09wZW5EYXRh YmFzZXMoKTsKICNpZiBFTkFCTEUoSU5TUEVDVE9SKQotICAgIGlmIChQYWdlKiBwYWdlID0gZG9j dW1lbnQtPmZyYW1lKCktPnBhZ2UoKSkKLSAgICAgICAgcGFnZS0+aW5zcGVjdG9yQ29udHJvbGxl cigpLT5kaWRPcGVuRGF0YWJhc2UoZGF0YWJhc2UuZ2V0KCksIGRvY3VtZW50LT5zZWN1cml0eU9y aWdpbigpLT5ob3N0KCksIG5hbWUsIGV4cGVjdGVkVmVyc2lvbik7CisgICAgaWYgKGNvbnRleHQt PmlzRG9jdW1lbnQoKSkgeworICAgICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBzdGF0aWNfY2Fz dDxEb2N1bWVudCo+KGNvbnRleHQpOworICAgICAgICBpZiAoUGFnZSogcGFnZSA9IGRvY3VtZW50 LT5wYWdlKCkpCisgICAgICAgICAgICBwYWdlLT5pbnNwZWN0b3JDb250cm9sbGVyKCktPmRpZE9w ZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+aG9z dCgpLCBuYW1lLCBleHBlY3RlZFZlcnNpb24pOworICAgIH0KICNlbmRpZgogCiAgICAgcmV0dXJu IGRhdGFiYXNlOwogfQogCi1EYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCitEYXRhYmFz ZTo6RGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCwgY29uc3QgU3RyaW5n JiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNw bGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogICAgIDogbV90cmFuc2FjdGlv bkluUHJvZ3Jlc3MoZmFsc2UpCiAgICAgLCBtX2lzVHJhbnNhY3Rpb25RdWV1ZUVuYWJsZWQodHJ1 ZSkKLSAgICAsIG1fZG9jdW1lbnQoZG9jdW1lbnQpCisgICAgLCBtX2V4ZWN1dGlvbkNvbnRleHQo Y29udGV4dCkKICAgICAsIG1fbmFtZShuYW1lLmNyb3NzVGhyZWFkU3RyaW5nKCkpCiAgICAgLCBt X2d1aWQoMCkKICAgICAsIG1fZXhwZWN0ZWRWZXJzaW9uKGV4cGVjdGVkVmVyc2lvbi5jcm9zc1Ro cmVhZFN0cmluZygpKQpAQCAtMTYyLDE2ICsxNzYsMTUgQEAgRGF0YWJhc2U6OkRhdGFiYXNlKERv Y3VtZW50KiBkb2N1bWVudCwgYwogICAgICwgbV9zdG9wcGVkKGZhbHNlKQogICAgICwgbV9vcGVu ZWQoZmFsc2UpCiB7Ci0gICAgQVNTRVJUKGRvY3VtZW50KTsKLSAgICBtX21haW5UaHJlYWRTZWN1 cml0eU9yaWdpbiA9IGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpOworICAgIEFTU0VSVChtX2V4 ZWN1dGlvbkNvbnRleHQuZ2V0KCkpOworICAgIG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luID0g bV9leGVjdXRpb25Db250ZXh0LT5zZWN1cml0eU9yaWdpbigpOwogICAgIG1fZGF0YWJhc2VUaHJl YWRTZWN1cml0eU9yaWdpbiA9IG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLT50aHJlYWRzYWZl Q29weSgpOwotCiAgICAgaWYgKG1fbmFtZS5pc051bGwoKSkKICAgICAgICAgbV9uYW1lID0gIiI7 CiAKICAgICBTY3JpcHRDb250cm9sbGVyOjppbml0aWFsaXplVGhyZWFkaW5nKCk7CiAKLSAgICBt X2d1aWQgPSBndWlkRm9yT3JpZ2luQW5kTmFtZShtX21haW5UaHJlYWRTZWN1cml0eU9yaWdpbi0+ dG9TdHJpbmcoKSwgbmFtZSk7CisgICAgbV9ndWlkID0gZ3VpZEZvck9yaWdpbkFuZE5hbWUoc2Vj dXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSwgbmFtZSk7CiAKICAgICB7CiAgICAgICAgIE11dGV4 TG9ja2VyIGxvY2tlcihndWlkTXV0ZXgoKSk7CkBAIC0xODUsMjggKzE5OCw0NSBAQCBEYXRhYmFz ZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjCiAgICAgICAgIGhhc2hTZXQtPmFkZCh0 aGlzKTsKICAgICB9CiAKLSAgICBBU1NFUlQobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSk7 Ci0KLSAgICBtX2ZpbGVuYW1lID0gRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuZnVsbFBhdGhG b3JEYXRhYmFzZShtX21haW5UaHJlYWRTZWN1cml0eU9yaWdpbi5nZXQoKSwgbV9uYW1lKTsKKyAg ICBtX2ZpbGVuYW1lID0gRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuZnVsbFBhdGhGb3JEYXRh YmFzZShzZWN1cml0eU9yaWdpbigpLCBtX25hbWUpOwogCiAgICAgRGF0YWJhc2VUcmFja2VyOjp0 cmFja2VyKCkuYWRkT3BlbkRhdGFiYXNlKHRoaXMpOwotICAgIG1fZG9jdW1lbnQtPmFkZE9wZW5E YXRhYmFzZSh0aGlzKTsKKyAgICBjb250ZXh0LT5hZGRPcGVuRGF0YWJhc2UodGhpcyk7CiB9CiAK LXN0YXRpYyB2b2lkIGRlcmVmRG9jdW1lbnQodm9pZCogZG9jdW1lbnQpCi17Ci0gICAgc3RhdGlj X2Nhc3Q8RG9jdW1lbnQqPihkb2N1bWVudCktPmRlcmVmKCk7Ci19CitjbGFzcyBEZXJlZkNvbnRl eHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgor ICAgIHN0YXRpYyBQYXNzT3duUHRyPERlcmVmQ29udGV4dFRhc2s+IGNyZWF0ZShTY3JpcHRFeGVj dXRpb25Db250ZXh0ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBEZXJlZkNv bnRleHRUYXNrKGNvbnRleHQpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFz ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikKKyAgICB7CisgICAgICAgIG1fY29udGV4dC0+ZGVy ZWYoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGVhbnVwVGFzaygpIGNvbnN0IHsg cmV0dXJuIHRydWU7IH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBEZXJlZkNvbnRleHRUYXNr KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQpIDogbV9jb250ZXh0KGNvbnRleHQpCisg ICAgeworICAgIH0KKworICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIG1fY29udGV4dDsKK307 CiAKIERhdGFiYXNlOjp+RGF0YWJhc2UoKQogewotICAgIC8vIERlcmVmIG1fZG9jdW1lbnQgb24g dGhlIG1haW4gdGhyZWFkLgotICAgIGNhbGxPbk1haW5UaHJlYWQoZGVyZWZEb2N1bWVudCwgbV9k b2N1bWVudC5yZWxlYXNlKCkucmVsZWFzZVJlZigpKTsKKyAgICAvLyBUaGUgcmVmZXJlbmNlIHRv IHRoZSBTY3JpcHRFeGVjdXRpb25Db250ZXh0IG5lZWRzIHRvIGJlIGNsZWFyZWQgb24gdGhlIEph dmFTY3JpcHQgdGhyZWFkLiAgSWYgd2UncmUgb24gdGhhdCB0aHJlYWQgYWxyZWFkeSwgd2UgY2Fu IGp1c3QgbGV0IHRoZSBSZWZQdHIncyBkZXN0cnVjdGlvbiBkbyB0aGUgZGVyZWZmaW5nLgorICAg IGlmICghbV9leGVjdXRpb25Db250ZXh0LT5pc0phdmFTY3JpcHRUaHJlYWQoKSkgeworICAgICAg ICBtX2V4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKERlcmVmQ29udGV4dFRhc2s6OmNyZWF0ZSht X2V4ZWN1dGlvbkNvbnRleHQucmVsZWFzZSgpLnJlbGVhc2VSZWYoKSkpOworICAgIH0KIH0KIAog Ym9vbCBEYXRhYmFzZTo6b3BlbkFuZFZlcmlmeVZlcnNpb24oRXhjZXB0aW9uQ29kZSYgZSkKIHsK LSAgICBpZiAoIW1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpCisgICAgaWYgKCFtX2V4ZWN1 dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKICAg ICBtX2RhdGFiYXNlQXV0aG9yaXplciA9IERhdGFiYXNlQXV0aG9yaXplcjo6Y3JlYXRlKCk7CiAK QEAgLTIxNCw3ICsyNDQsNyBAQCBib29sIERhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbihF eGNlCiAgICAgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyIHN5bmNocm9uaXplcjsKICAgICBPd25Q dHI8RGF0YWJhc2VPcGVuVGFzaz4gdGFzayA9IERhdGFiYXNlT3BlblRhc2s6OmNyZWF0ZSh0aGlz LCAmc3luY2hyb25pemVyLCBlLCBzdWNjZXNzKTsKIAotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNl VGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CisgICAgbV9l eGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2so dGFzay5yZWxlYXNlKCkpOwogICAgIHN5bmNocm9uaXplci53YWl0Rm9yVGFza0NvbXBsZXRpb24o KTsKIAogICAgIHJldHVybiBzdWNjZXNzOwpAQCAtMzA5LDQzICszMzksNjMgQEAgYm9vbCBEYXRh YmFzZTo6dmVyc2lvbk1hdGNoZXNFeHBlY3RlZCgpIAogCiB2b2lkIERhdGFiYXNlOjptYXJrQXNE ZWxldGVkQW5kQ2xvc2UoKQogewotICAgIGlmIChtX2RlbGV0ZWQgfHwgIW1fZG9jdW1lbnQtPmRh dGFiYXNlVGhyZWFkKCkpCisgICAgaWYgKG1fZGVsZXRlZCB8fCAhbV9leGVjdXRpb25Db250ZXh0 LT5kYXRhYmFzZVRocmVhZCgpKQogICAgICAgICByZXR1cm47CiAKICAgICBMT0coU3RvcmFnZUFQ SSwgIk1hcmtpbmcgJXMgKCVwKSBhcyBkZWxldGVkIiwgc3RyaW5nSWRlbnRpZmllcigpLmFzY2lp KCkuZGF0YSgpLCB0aGlzKTsKICAgICBtX2RlbGV0ZWQgPSB0cnVlOwogCi0gICAgaWYgKG1fZG9j dW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpIHsKKyAgICBp ZiAobV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT50ZXJtaW5hdGlvblJlcXVl c3RlZCgpKSB7CiAgICAgICAgIExPRyhTdG9yYWdlQVBJLCAiRGF0YWJhc2UgaGFuZGxlICVwIGlz IG9uIGEgdGVybWluYXRlZCBEYXRhYmFzZVRocmVhZCwgY2Fubm90IGJlIG1hcmtlZCBmb3Igbm9y bWFsIGNsb3N1cmVcbiIsIHRoaXMpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCi0gICAgbV9k b2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3ModGhpcyk7 CisgICAgbV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT51bnNjaGVkdWxlRGF0 YWJhc2VUYXNrcyh0aGlzKTsKIAogICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBzeW5jaHJv bml6ZXI7CiAgICAgT3duUHRyPERhdGFiYXNlQ2xvc2VUYXNrPiB0YXNrID0gRGF0YWJhc2VDbG9z ZVRhc2s6OmNyZWF0ZSh0aGlzLCAmc3luY2hyb25pemVyKTsKIAotICAgIG1fZG9jdW1lbnQtPmRh dGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7Cisg ICAgbV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0 ZVRhc2sodGFzay5yZWxlYXNlKCkpOwogICAgIHN5bmNocm9uaXplci53YWl0Rm9yVGFza0NvbXBs ZXRpb24oKTsKIH0KIAotc3RhdGljIHZvaWQgZG9jdW1lbnRSZW1vdmVPcGVuRGF0YWJhc2Uodm9p ZCogY29udGV4dCkKLXsKLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwotICAgIERhdGFiYXNl KiBkYXRhYmFzZSA9IHN0YXRpY19jYXN0PERhdGFiYXNlKj4oY29udGV4dCk7Ci0gICAgZGF0YWJh c2UtPmRvY3VtZW50KCktPnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZSk7Ci0gICAgZGF0YWJh c2UtPmRlcmVmKCk7Ci19CitjbGFzcyBDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzayA6IHB1 YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc093blB0cjxDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzaz4gY3JlYXRlKERhdGFiYXNl ICpkYXRhYmFzZSkKKyAgICB7CisgICAgICAgIHJldHVybiBuZXcgQ29udGV4dFJlbW92ZU9wZW5E YXRhYmFzZVRhc2soZGF0YWJhc2UpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3Jt VGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAgQVNT RVJUKGNvbnRleHQtPmlzSmF2YVNjcmlwdFRocmVhZCgpKTsKKyAgICAgICAgY29udGV4dC0+cmVt b3ZlT3BlbkRhdGFiYXNlKG1fZGF0YWJhc2UpOworICAgICAgICBEYXRhYmFzZVRyYWNrZXI6OnRy YWNrZXIoKS5yZW1vdmVPcGVuRGF0YWJhc2UobV9kYXRhYmFzZSk7CisgICAgICAgIC8vIFJlZmZl ZCBpbiBEYXRhYmFzZTo6Y2xvc2UoKS4KKyAgICAgICAgbV9kYXRhYmFzZS0+ZGVyZWYoKTsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGVhbnVwVGFzaygpIGNvbnN0IHsgcmV0dXJuIHRy dWU7IH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNl VGFzayhEYXRhYmFzZSAqZGF0YWJhc2UpIDogbV9kYXRhYmFzZShkYXRhYmFzZSkKKyAgICB7Cisg ICAgfQorCisgICAgRGF0YWJhc2UqIG1fZGF0YWJhc2U7Cit9OwogCiB2b2lkIERhdGFiYXNlOjpj bG9zZSgpCiB7CiAgICAgaWYgKCFtX29wZW5lZCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgQVNT RVJUKG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpOwotICAgIEFTU0VSVChjdXJyZW50VGhy ZWFkKCkgPT0gZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7Cisg ICAgQVNTRVJUKG1fZXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSk7CisgICAgQVNT RVJUKGN1cnJlbnRUaHJlYWQoKSA9PSBtX2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFk KCktPmdldFRocmVhZElEKCkpOwogICAgIG1fc3FsaXRlRGF0YWJhc2UuY2xvc2UoKTsKLSAgICBt X2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNsb3NlZCh0aGlzKTsK KyAgICAvLyBNdXN0IHJlZigpIGJlZm9yZSBjYWxsaW5nIGRhdGFiYXNlVGhyZWFkKCktPnJlY29y ZERhdGFiYXNlQ2xvc2VkKCkuCisgICAgcmVmKCk7IC8vIGRlcmVmKCkgY2FsbGVkIGJ5IENvbnRl eHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrLgorICAgIG1fZXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJh c2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VDbG9zZWQodGhpcyk7CiAgICAgbV9vcGVuZWQgPSBm YWxzZTsKIAogICAgIHsKQEAgLTM2MiwxMSArNDEyLDggQEAgdm9pZCBEYXRhYmFzZTo6Y2xvc2Uo KQogICAgICAgICB9CiAgICAgfQogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+ dW5zY2hlZHVsZURhdGFiYXNlVGFza3ModGhpcyk7Ci0KLSAgICBEYXRhYmFzZVRyYWNrZXI6OnRy YWNrZXIoKS5yZW1vdmVPcGVuRGF0YWJhc2UodGhpcyk7Ci0gICAgcmVmKCk7ICAvLyBkZXJlZigp IGNhbGxlZCBpbiBkb2N1bWVudFJlbW92ZU9wZW5EYXRhYmFzZSgpCi0gICAgY2FsbE9uTWFpblRo cmVhZChkb2N1bWVudFJlbW92ZU9wZW5EYXRhYmFzZSwgdGhpcyk7CisgICAgbV9leGVjdXRpb25D b250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsK KyAgICBtX2V4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKENvbnRleHRSZW1vdmVPcGVuRGF0YWJh c2VUYXNrOjpjcmVhdGUodGhpcykpOwogfQogCiB2b2lkIERhdGFiYXNlOjpzdG9wKCkKQEAgLTUz Miw4ICs1NzksOCBAQCBib29sIERhdGFiYXNlOjpwZXJmb3JtT3BlbkFuZFZlcmlmeShFeGNlCiAg ICAgLy8gQWxsIGNoZWNrcyBwYXNzZWQgYW5kIHdlIHN0aWxsIGhhdmUgYSBoYW5kbGUgdG8gdGhp cyBkYXRhYmFzZSBmaWxlLgogICAgIC8vIE1ha2Ugc3VyZSBEYXRhYmFzZVRocmVhZCBjbG9zZXMg aXQgd2hlbiBEYXRhYmFzZVRocmVhZCBnb2VzIGF3YXkuCiAgICAgbV9vcGVuZWQgPSB0cnVlOwot ICAgIGlmIChtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKQotICAgICAgICBtX2RvY3VtZW50 LT5kYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZU9wZW4odGhpcyk7CisgICAgaWYgKG1f ZXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICAgICAgbV9leGVjdXRpb25D b250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZU9wZW4odGhpcyk7CiAKICAg ICByZXR1cm4gdHJ1ZTsKIH0KQEAgLTU2NywzMiArNjE0LDUzIEBAIHZvaWQgRGF0YWJhc2U6OnNj aGVkdWxlVHJhbnNhY3Rpb24oKQogICAgICAgICBtX3RyYW5zYWN0aW9uUXVldWUucmVtb3ZlRmly c3QoKTsKICAgICB9CiAKLSAgICBpZiAodHJhbnNhY3Rpb24gJiYgbV9kb2N1bWVudC0+ZGF0YWJh c2VUaHJlYWQoKSkgeworICAgIGlmICh0cmFuc2FjdGlvbiAmJiBtX2V4ZWN1dGlvbkNvbnRleHQt PmRhdGFiYXNlVGhyZWFkKCkpIHsKICAgICAgICAgT3duUHRyPERhdGFiYXNlVHJhbnNhY3Rpb25U YXNrPiB0YXNrID0gRGF0YWJhc2VUcmFuc2FjdGlvblRhc2s6OmNyZWF0ZSh0cmFuc2FjdGlvbik7 CiAgICAgICAgIExPRyhTdG9yYWdlQVBJLCAiU2NoZWR1bGluZyBEYXRhYmFzZVRyYW5zYWN0aW9u VGFzayAlcCBmb3IgdHJhbnNhY3Rpb24gJXBcbiIsIHRhc2suZ2V0KCksIHRhc2stPnRyYW5zYWN0 aW9uKCkpOwogICAgICAgICBtX3RyYW5zYWN0aW9uSW5Qcm9ncmVzcyA9IHRydWU7Ci0gICAgICAg IG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0YXNrLnJlbGVhc2Uo KSk7CisgICAgICAgIG1fZXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1 bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKICAgICB9IGVsc2UKICAgICAgICAgbV90cmFuc2FjdGlv bkluUHJvZ3Jlc3MgPSBmYWxzZTsKIH0KIAogdm9pZCBEYXRhYmFzZTo6c2NoZWR1bGVUcmFuc2Fj dGlvblN0ZXAoU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uLCBib29sIGltbWVkaWF0ZWx5KQog ewotICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAoIW1fZXhl Y3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAg T3duUHRyPERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrPiB0YXNrID0gRGF0YWJhc2VUcmFuc2FjdGlv blRhc2s6OmNyZWF0ZSh0cmFuc2FjdGlvbik7CiAgICAgTE9HKFN0b3JhZ2VBUEksICJTY2hlZHVs aW5nIERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrICVwIGZvciB0aGUgdHJhbnNhY3Rpb24gc3RlcFxu IiwgdGFzay5nZXQoKSk7CiAgICAgaWYgKGltbWVkaWF0ZWx5KQotICAgICAgICBtX2RvY3VtZW50 LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkp OworICAgICAgICBtX2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxl SW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CiAgICAgZWxzZQotICAgICAgICBtX2RvY3Vt ZW50LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAg ICAgICBtX2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0 YXNrLnJlbGVhc2UoKSk7CiB9CiAKK2NsYXNzIERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrIDog cHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRp YyBQYXNzT3duUHRyPERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrPiBjcmVhdGUoU1FMVHJhbnNh Y3Rpb24gKnRyYW5zYWN0aW9uKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBEZWxpdmVyUGVu ZGluZ0NhbGxiYWNrVGFzayh0cmFuc2FjdGlvbik7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lk IHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQorICAgIHsKKyAgICAgICAgbV90 cmFuc2FjdGlvbi0+cGVyZm9ybVBlbmRpbmdDYWxsYmFjaygpOworICAgIH0KKworcHJpdmF0ZToK KyAgICBleHBsaWNpdCBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayhQYXNzUmVmUHRyPFNRTFRy YW5zYWN0aW9uPiB0cmFuc2FjdGlvbikKKyAgICAgICAgOiBtX3RyYW5zYWN0aW9uKHRyYW5zYWN0 aW9uKQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8U1FMVHJhbnNhY3Rpb24+IG1fdHJhbnNh Y3Rpb247Cit9OworCiB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uQ2FsbGJhY2so U1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewotICAgIHRyYW5zYWN0aW9uLT5yZWYoKTsK LSAgICBjYWxsT25NYWluVGhyZWFkKGRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2ssIHRyYW5zYWN0aW9u KTsKKyAgICBtX2V4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKAorICAgICAgICBEZWxpdmVyUGVu ZGluZ0NhbGxiYWNrVGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uKSk7CiB9CiAKIFZlY3RvcjxTdHJp bmc+IERhdGFiYXNlOjpwZXJmb3JtR2V0VGFibGVOYW1lcygpCkBAIC02MjYsMTIgKzY5NCwxMiBA QCBWZWN0b3I8U3RyaW5nPiBEYXRhYmFzZTo6cGVyZm9ybUdldFRhYmxlCiAKIFNRTFRyYW5zYWN0 aW9uQ2xpZW50KiBEYXRhYmFzZTo6dHJhbnNhY3Rpb25DbGllbnQoKSBjb25zdAogewotICAgIHJl dHVybiBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNsaWVudCgpOwor ICAgIHJldHVybiBtX2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnRyYW5zYWN0 aW9uQ2xpZW50KCk7CiB9CiAKIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIERhdGFiYXNlOjp0 cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkgY29uc3QKIHsKLSAgICByZXR1cm4gbV9kb2N1bWVudC0+ ZGF0YWJhc2VUaHJlYWQoKS0+dHJhbnNhY3Rpb25Db29yZGluYXRvcigpOworICAgIHJldHVybiBt X2V4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnRyYW5zYWN0aW9uQ29vcmRpbmF0 b3IoKTsKIH0KIAogU3RyaW5nIERhdGFiYXNlOjp2ZXJzaW9uKCkgY29uc3QKQEAgLTY0MiwyNSAr NzEwLDE4IEBAIFN0cmluZyBEYXRhYmFzZTo6dmVyc2lvbigpIGNvbnN0CiAgICAgcmV0dXJuIGd1 aWRUb1ZlcnNpb25NYXAoKS5nZXQobV9ndWlkKS50aHJlYWRzYWZlQ29weSgpOwogfQogCi12b2lk IERhdGFiYXNlOjpkZWxpdmVyUGVuZGluZ0NhbGxiYWNrKHZvaWQqIGNvbnRleHQpCi17Ci0gICAg U1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uID0gc3RhdGljX2Nhc3Q8U1FMVHJhbnNhY3Rpb24q Pihjb250ZXh0KTsKLSAgICB0cmFuc2FjdGlvbi0+cGVyZm9ybVBlbmRpbmdDYWxsYmFjaygpOwot ICAgIHRyYW5zYWN0aW9uLT5kZXJlZigpOyAvLyBXYXMgcmVmJ2QgaW4gc2NoZWR1bGVUcmFuc2Fj dGlvbkNhbGxiYWNrKCkuCi19Ci0KIFZlY3RvcjxTdHJpbmc+IERhdGFiYXNlOjp0YWJsZU5hbWVz KCkKIHsKICAgICAvLyBGSVhNRTogTm90IHVzaW5nIHRocmVhZHNhZmVDb3B5IG9uIHRoZXNlIHN0 cmluZ3MgbG9va3Mgb2sgc2luY2UgdGhyZWFkcyB0YWtlIHN0cmljdCB0dXJucwogICAgIC8vIGlu IGRlYWxpbmcgd2l0aCB0aGVtLiBIb3dldmVyLCBpZiB0aGUgY29kZSBjaGFuZ2VzLCB0aGlzIG1h eSBub3QgYmUgdHJ1ZSBhbnltb3JlLgogICAgIFZlY3RvcjxTdHJpbmc+IHJlc3VsdDsKLSAgICBp ZiAoIW1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpCisgICAgaWYgKCFtX2V4ZWN1dGlvbkNv bnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJldHVybiByZXN1bHQ7CiAKICAgICBE YXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgc3luY2hyb25pemVyOwogICAgIE93blB0cjxEYXRhYmFz ZVRhYmxlTmFtZXNUYXNrPiB0YXNrID0gRGF0YWJhc2VUYWJsZU5hbWVzVGFzazo6Y3JlYXRlKHRo aXMsICZzeW5jaHJvbml6ZXIsIHJlc3VsdCk7CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRo cmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgIG1fZXhl Y3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRh c2sucmVsZWFzZSgpKTsKICAgICBzeW5jaHJvbml6ZXIud2FpdEZvclRhc2tDb21wbGV0aW9uKCk7 CiAKICAgICByZXR1cm4gcmVzdWx0OwpAQCAtNjc2LDkgKzczNyw5IEBAIHZvaWQgRGF0YWJhc2U6 OnNldEV4cGVjdGVkVmVyc2lvbihjb25zdCAKIAogU2VjdXJpdHlPcmlnaW4qIERhdGFiYXNlOjpz ZWN1cml0eU9yaWdpbigpIGNvbnN0CiB7Ci0gICAgaWYgKGlzTWFpblRocmVhZCgpKQorICAgIGlm IChleGVjdXRpb25Db250ZXh0KCktPmlzSmF2YVNjcmlwdFRocmVhZCgpKQogICAgICAgICByZXR1 cm4gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4uZ2V0KCk7Ci0gICAgaWYgKGN1cnJlbnRUaHJl YWQoKSA9PSBkb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKQorICAg IGlmIChjdXJyZW50VGhyZWFkKCkgPT0gbV9leGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVh ZCgpLT5nZXRUaHJlYWRJRCgpKQogICAgICAgICByZXR1cm4gbV9kYXRhYmFzZVRocmVhZFNlY3Vy aXR5T3JpZ2luLmdldCgpOwogICAgIHJldHVybiAwOwogfQpAQCAtNzA2LDYgKzc2Nyw2IEBAIFN0 cmluZyBEYXRhYmFzZTo6ZmlsZU5hbWUoKSBjb25zdAogICAgIHJldHVybiBtX2ZpbGVuYW1lLnRo cmVhZHNhZmVDb3B5KCk7CiB9CiAKLSNlbmRpZgorI2VuZGlmIC8vIEVOQUJMRShEQVRBQkFTRSkK IAotfQorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFi YXNlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmgJKHJldmlzaW9u IDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmgJKHdvcmtpbmcgY29weSkKQEAg LTUyLDcgKzUyLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBEYXRhYmFzZUF1dGhv cml6ZXI7CiBjbGFzcyBEYXRhYmFzZVRocmVhZDsKLWNsYXNzIERvY3VtZW50OworY2xhc3MgU2Ny aXB0RXhlY3V0aW9uQ29udGV4dDsKIGNsYXNzIFNRTFJlc3VsdFNldDsKIGNsYXNzIFNRTFRyYW5z YWN0aW9uQ2FsbGJhY2s7CiBjbGFzcyBTUUxUcmFuc2FjdGlvbkNsaWVudDsKQEAgLTY3LDEwICs2 NywxMyBAQCBjbGFzcyBEYXRhYmFzZSA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVkCiAgICAgZnJp ZW5kIGNsYXNzIFNRTFN0YXRlbWVudDsKICAgICBmcmllbmQgY2xhc3MgU1FMVHJhbnNhY3Rpb247 CiBwdWJsaWM6CisgICAgc3RhdGljIHZvaWQgc2V0SXNBdmFpbGFibGUoYm9vbCk7CisgICAgc3Rh dGljIGJvb2wgaXNBdmFpbGFibGUoKTsKKwogICAgIH5EYXRhYmFzZSgpOwogCiAvLyBEaXJlY3Qg c3VwcG9ydCBmb3IgdGhlIERPTSBBUEkKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxEYXRhYmFzZT4g b3BlbkRhdGFiYXNlKERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5z aWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNlcHRpb25Db2RlJik7CisgICAgc3RhdGljIFBh c3NSZWZQdHI8RGF0YWJhc2U+IG9wZW5EYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpj b250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9u LCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUs IEV4Y2VwdGlvbkNvZGUmKTsKICAgICBTdHJpbmcgdmVyc2lvbigpIGNvbnN0OwogICAgIHZvaWQg Y2hhbmdlVmVyc2lvbihjb25zdCBTdHJpbmcmIG9sZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgbmV3 VmVyc2lvbiwKICAgICAgICAgICAgICAgICAgICAgICAgUGFzc1JlZlB0cjxTUUxUcmFuc2FjdGlv bkNhbGxiYWNrPiBjYWxsYmFjaywgUGFzc1JlZlB0cjxTUUxUcmFuc2FjdGlvbkVycm9yQ2FsbGJh Y2s+IGVycm9yQ2FsbGJhY2ssCkBAIC04Nyw3ICs5MCw3IEBAIHB1YmxpYzoKIAogICAgIFZlY3Rv cjxTdHJpbmc+IHRhYmxlTmFtZXMoKTsKIAotICAgIERvY3VtZW50KiBkb2N1bWVudCgpIGNvbnN0 IHsgcmV0dXJuIG1fZG9jdW1lbnQuZ2V0KCk7IH0KKyAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBleGVjdXRpb25Db250ZXh0KCkgY29uc3QgeyByZXR1cm4gbV9leGVjdXRpb25Db250ZXh0Lmdl dCgpOyB9CiAgICAgU2VjdXJpdHlPcmlnaW4qIHNlY3VyaXR5T3JpZ2luKCkgY29uc3Q7CiAgICAg U3RyaW5nIHN0cmluZ0lkZW50aWZpZXIoKSBjb25zdDsKICAgICBTdHJpbmcgZGlzcGxheU5hbWUo KSBjb25zdDsKQEAgLTEyMyw4ICsxMjYsOSBAQCBwdWJsaWM6CiAgICAgU1FMVHJhbnNhY3Rpb25D b29yZGluYXRvciogdHJhbnNhY3Rpb25Db29yZGluYXRvcigpIGNvbnN0OwogCiBwcml2YXRlOgot ICAgIERhdGFiYXNlKERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwKLSAgICAgICAgICAgICBjb25zdCBTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOworICAgIERhdGFiYXNlKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwKKyAgICAg ICAgICAgICBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNw bGF5TmFtZSwKKyAgICAgICAgICAgICB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCiAg ICAgYm9vbCBvcGVuQW5kVmVyaWZ5VmVyc2lvbihFeGNlcHRpb25Db2RlJik7CiAKQEAgLTEzOSw3 ICsxNDMsNyBAQCBwcml2YXRlOgogCiAgICAgc3RhdGljIHZvaWQgZGVsaXZlclBlbmRpbmdDYWxs YmFjayh2b2lkKik7CiAKLSAgICBSZWZQdHI8RG9jdW1lbnQ+IG1fZG9jdW1lbnQ7CisgICAgUmVm UHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ+IG1fZXhlY3V0aW9uQ29udGV4dDsKICAgICBSZWZQ dHI8U2VjdXJpdHlPcmlnaW4+IG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luOwogICAgIFJlZlB0 cjxTZWN1cml0eU9yaWdpbj4gbV9kYXRhYmFzZVRocmVhZFNlY3VyaXR5T3JpZ2luOwogICAgIFN0 cmluZyBtX25hbWU7CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUYXNrLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5oCShyZXZpc2lvbiA1Mjk5NSkK KysrIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRhc2suaAkod29ya2luZyBjb3B5KQpAQCAtNTAs MTYgKzUwLDE1IEBAIGNsYXNzIFZlcnNpb25DaGFuZ2VDYWxsYmFjazsKIC8vIENhbiBiZSB1c2Vk IHRvIHdhaXQgdW50aWwgRGF0YWJhc2VUYXNrIGlzIGNvbXBsZXRlZC4KIC8vIEhhcyB0byBiZSBw YXNzZWQgaW50byBEYXRhYmFzZVRhc2s6OmNyZWF0ZSB0byBiZSBhc3NvY2lhdGVkIHdpdGggdGhl IHRhc2suCiBjbGFzcyBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgOiBwdWJsaWMgTm9uY29weWFi bGUgewotICAgIGZyaWVuZCBjbGFzcyBEYXRhYmFzZVRhc2s7CiBwdWJsaWM6CiAgICAgRGF0YWJh c2VUYXNrU3luY2hyb25pemVyKCk7CiAKICAgICAvLyBDYWxsZWQgZnJvbSBtYWluIHRocmVhZCB0 byB3YWl0IHVudGlsIHRhc2sgaXMgY29tcGxldGVkLgogICAgIHZvaWQgd2FpdEZvclRhc2tDb21w bGV0aW9uKCk7CiAKLXByaXZhdGU6CiAgICAgLy8gQ2FsbGVkIGJ5IHRoZSB0YXNrLgogICAgIHZv aWQgdGFza0NvbXBsZXRlZCgpOworcHJpdmF0ZToKIAogICAgIGJvb2wgbV90YXNrQ29tcGxldGVk OwogICAgIE11dGV4IG1fc3luY2hyb25vdXNNdXRleDsKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9E YXRhYmFzZVRocmVhZC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VU aHJlYWQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00NCw2ICs0NCw3IEBAIERhdGFiYXNlVGhyZWFk OjpEYXRhYmFzZVRocmVhZCgpCiAgICAgOiBtX3RocmVhZElEKDApCiAgICAgLCBtX3RyYW5zYWN0 aW9uQ2xpZW50KG5ldyBTUUxUcmFuc2FjdGlvbkNsaWVudCgpKQogICAgICwgbV90cmFuc2FjdGlv bkNvb3JkaW5hdG9yKG5ldyBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkpCisgICAgLCBtX2Ns ZWFudXBTeW5jKDApCiB7CiAgICAgbV9zZWxmUmVmID0gdGhpczsKIH0KQEAgLTUxLDYgKzUyLDcg QEAgRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKIERhdGFiYXNlVGhyZWFkOjp+RGF0 YWJhc2VUaHJlYWQoKQogewogICAgIC8vIEZJWE1FOiBBbnkgY2xlYW51cCByZXF1aXJlZCBoZXJl PyAgU2luY2UgdGhlIHRocmVhZCBkZWxldGVzIGl0c2VsZiBhZnRlciBydW5uaW5nIGl0cyBkZXRh Y2hlZCBjb3Vyc2UsIEkgZG9uJ3QgdGhpbmsgc28uICBMZXRzIGJlIHN1cmUuCisgICAgQVNTRVJU KHRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpOwogfQogCiBib29sIERhdGFiYXNlVGhyZWFkOjpzdGFy dCgpCkBAIC02NSw4ICs2NywxMCBAQCBib29sIERhdGFiYXNlVGhyZWFkOjpzdGFydCgpCiAgICAg cmV0dXJuIG1fdGhyZWFkSUQ7CiB9CiAKLXZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJt aW5hdGlvbigpCit2b2lkIERhdGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRpb24oRGF0YWJh c2VUYXNrU3luY2hyb25pemVyICpjbGVhbnVwU3luYykKIHsKKyAgICBBU1NFUlQoIW1fY2xlYW51 cFN5bmMpOworICAgIG1fY2xlYW51cFN5bmMgPSBjbGVhbnVwU3luYzsKICAgICBMT0coU3RvcmFn ZUFQSSwgIkRhdGFiYXNlVGhyZWFkICVwIHdhcyBhc2tlZCB0byB0ZXJtaW5hdGVcbiIsIHRoaXMp OwogICAgIG1fcXVldWUua2lsbCgpOwogfQpAQCAtMTE1LDkgKzExOSwxNCBAQCB2b2lkKiBEYXRh YmFzZVRocmVhZDo6ZGF0YWJhc2VUaHJlYWQoKQogICAgIC8vIERldGFjaCB0aGUgdGhyZWFkIHNv IGl0cyByZXNvdXJjZXMgYXJlIG5vIGxvbmdlciBvZiBhbnkgY29uY2VybiB0byBhbnlvbmUgZWxz ZQogICAgIGRldGFjaFRocmVhZChtX3RocmVhZElEKTsKIAorICAgIERhdGFiYXNlVGFza1N5bmNo cm9uaXplciogY2xlYW51cFN5bmMgPSBtX2NsZWFudXBTeW5jOworICAgIAogICAgIC8vIENsZWFy IHRoZSBzZWxmIHJlZnB0ciwgcG9zc2libHkgcmVzdWx0aW5nIGluIGRlbGV0aW9uCiAgICAgbV9z ZWxmUmVmID0gMDsKIAorICAgIGlmIChjbGVhbnVwU3luYykgLy8gU29tZW9uZSB3YW50ZWQgdG8g a25vdyB3aGVuIHdlIHdlcmUgZG9uZSBjbGVhbmluZyB1cC4KKyAgICAgICAgY2xlYW51cFN5bmMt PnRhc2tDb21wbGV0ZWQoKTsKKwogICAgIHJldHVybiAwOwogfQogCkBAIC0xNjIsNiArMTcxLDUg QEAgdm9pZCBEYXRhYmFzZVRocmVhZDo6dW5zY2hlZHVsZURhdGFiYXNlVAogICAgIFNhbWVEYXRh YmFzZVByZWRpY2F0ZSBwcmVkaWNhdGUoZGF0YWJhc2UpOwogICAgIG1fcXVldWUucmVtb3ZlSWYo cHJlZGljYXRlKTsKIH0KLQogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogI2VuZGlmCkluZGV4OiBX ZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0 b3JhZ2UvRGF0YWJhc2VUaHJlYWQuaAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3Jh Z2UvRGF0YWJhc2VUaHJlYWQuaAkod29ya2luZyBjb3B5KQpAQCAtNDMsNiArNDMsNyBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIERhdGFiYXNlOwogY2xhc3MgRGF0YWJhc2VUYXNrOwor Y2xhc3MgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyOwogY2xhc3MgRG9jdW1lbnQ7CiBjbGFzcyBT UUxUcmFuc2FjdGlvbkNsaWVudDsKIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I7CkBA IC01Myw3ICs1NCw3IEBAIHB1YmxpYzoKICAgICB+RGF0YWJhc2VUaHJlYWQoKTsKIAogICAgIGJv b2wgc3RhcnQoKTsKLSAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOworICAgIHZvaWQgcmVx dWVzdFRlcm1pbmF0aW9uKERhdGFiYXNlVGFza1N5bmNocm9uaXplciAqY2xlYW51cFN5bmMpOwog ICAgIGJvb2wgdGVybWluYXRpb25SZXF1ZXN0ZWQoKSBjb25zdDsKIAogICAgIHZvaWQgc2NoZWR1 bGVUYXNrKFBhc3NPd25QdHI8RGF0YWJhc2VUYXNrPik7CkBAIC04NSw2ICs4Niw3IEBAIHByaXZh dGU6CiAKICAgICBPd25QdHI8U1FMVHJhbnNhY3Rpb25DbGllbnQ+IG1fdHJhbnNhY3Rpb25DbGll bnQ7CiAgICAgT3duUHRyPFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3I+IG1fdHJhbnNhY3Rpb25D b29yZGluYXRvcjsKKyAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgKm1fY2xlYW51cFN5bmM7 CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0 YWJhc2VUcmFja2VyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VU cmFja2VyLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VU cmFja2VyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzYsMTAgKzM2LDEwIEBACiAjaW5jbHVkZSAi RGF0YWJhc2UuaCIKICNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgogI2luY2x1ZGUgIkRhdGFi YXNlVHJhY2tlckNsaWVudC5oIgotI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiTG9n Z2luZy5oIgogI2luY2x1ZGUgIk9yaWdpblF1b3RhTWFuYWdlci5oIgogI2luY2x1ZGUgIlBhZ2Uu aCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU2VjdXJp dHlPcmlnaW4uaCIKICNpbmNsdWRlICJTZWN1cml0eU9yaWdpbkhhc2guaCIKICNpbmNsdWRlICJT UUxpdGVGaWxlU3lzdGVtLmgiCkBAIC0xMjAsNyArMTIwLDcgQEAgdm9pZCBEYXRhYmFzZVRyYWNr ZXI6Om9wZW5UcmFja2VyRGF0YWJhcwogICAgIH0KIH0KIAotYm9vbCBEYXRhYmFzZVRyYWNrZXI6 OmNhbkVzdGFibGlzaERhdGFiYXNlKERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNp emUpCitib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcm IGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCiB7CiAgICAgQVNTRVJU KGN1cnJlbnRUaHJlYWQoKSA9PSBtX3RocmVhZCk7CiAKQEAgLTEyOCw5ICsxMjgsOSBAQCBib29s IERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhCiAgICAgLy8gY2FuIHJ1biBvbiB0 aGUgZGF0YWJhc2UgdGhyZWFkIGxhdGVyLgogICAgIHBvcHVsYXRlT3JpZ2lucygpOwogCi0gICAg U2VjdXJpdHlPcmlnaW4qIG9yaWdpbiA9IGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpOworICAg IFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4gPSBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpOwogCi0g ICAgLy8gU2luY2Ugd2UncmUgaW1taW5lbnRseSBvcGVuaW5nIGEgZGF0YWJhc2Ugd2l0aGluIHRo aXMgRG9jdW1lbnQncyBvcmlnaW4sIG1ha2Ugc3VyZSB0aGlzIG9yaWdpbiBpcyBiZWluZyB0cmFj a2VkIGJ5IHRoZSBRdW90YVRyYWNrZXIKKyAgICAvLyBTaW5jZSB3ZSdyZSBpbW1pbmVudGx5IG9w ZW5pbmcgYSBkYXRhYmFzZSB3aXRoaW4gdGhpcyBjb250ZXh0J3Mgb3JpZ2luLCBtYWtlIHN1cmUg dGhpcyBvcmlnaW4gaXMgYmVpbmcgdHJhY2tlZCBieSB0aGUgUXVvdGFUcmFja2VyCiAgICAgLy8g YnkgZmV0Y2hpbmcgaXQncyBjdXJyZW50IHVzYWdlIG5vdwogICAgIHVuc2lnbmVkIGxvbmcgbG9u ZyB1c2FnZSA9IHVzYWdlRm9yT3JpZ2luKG9yaWdpbik7CiAKQEAgLTE0NywxMiArMTQ3LDkgQEAg Ym9vbCBEYXRhYmFzZVRyYWNrZXI6OmNhbkVzdGFibGlzaERhdGFiYQogCiAgICAgLy8gR2l2ZSB0 aGUgY2hyb21lIGNsaWVudCBhIGNoYW5jZSB0byBpbmNyZWFzZSB0aGUgcXVvdGEuCiAgICAgLy8g VGVtcG9yYXJpbHkgbWFrZSB0aGUgZGV0YWlscyBvZiB0aGUgcHJvcG9zZWQgZGF0YWJhc2UgYXZh aWxhYmxlLCBzbyB0aGUgY2xpZW50IGNhbiBnZXQgYXQgdGhlbS4KLSAgICBQYWdlKiBwYWdlID0g ZG9jdW1lbnQtPnBhZ2UoKTsKLSAgICBpZiAoIXBhZ2UpCi0gICAgICAgIHJldHVybiBmYWxzZTsK ICAgICBwYWlyPFNlY3VyaXR5T3JpZ2luKiwgRGF0YWJhc2VEZXRhaWxzPiBkZXRhaWxzKG9yaWdp biwgRGF0YWJhc2VEZXRhaWxzKG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplLCAwKSk7 CiAgICAgbV9wcm9wb3NlZERhdGFiYXNlID0gJmRldGFpbHM7Ci0gICAgcGFnZS0+Y2hyb21lKCkt PmNsaWVudCgpLT5leGNlZWRlZERhdGFiYXNlUXVvdGEoZG9jdW1lbnQtPmZyYW1lKCksIG5hbWUp OworICAgIGNvbnRleHQtPmRhdGFiYXNlRXhjZWVkZWRRdW90YShuYW1lKTsKICAgICBtX3Byb3Bv c2VkRGF0YWJhc2UgPSAwOwogCiAgICAgLy8gSWYgdGhlIGRhdGFiYXNlIHdpbGwgZml0IG5vdywg YWxsb3cgaXRzIGNyZWF0aW9uLgpAQCAtMTg2LDcgKzE4Myw3IEBAIGJvb2wgRGF0YWJhc2VUcmFj a2VyOjpoYXNFbnRyeUZvckRhdGFiYXMKIAogdW5zaWduZWQgbG9uZyBsb25nIERhdGFiYXNlVHJh Y2tlcjo6Z2V0TWF4U2l6ZUZvckRhdGFiYXNlKGNvbnN0IERhdGFiYXNlKiBkYXRhYmFzZSkKIHsK LSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IGRhdGFiYXNlLT5kb2N1bWVudCgpLT5kYXRh YmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgp ID09IGRhdGFiYXNlLT5leGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRo cmVhZElEKCkpOwogICAgIC8vIFRoZSBtYXhpbXVtIHNpemUgZm9yIGEgZGF0YWJhc2UgaXMgdGhl IGZ1bGwgcXVvdGEgZm9yIGl0cyBvcmlnaW4sIG1pbnVzIHRoZSBjdXJyZW50IHVzYWdlIHdpdGhp biB0aGUgb3JpZ2luLAogICAgIC8vIHBsdXMgdGhlIGN1cnJlbnQgdXNhZ2Ugb2YgdGhlIGdpdmVu IGRhdGFiYXNlCiAgICAgTG9ja2VyPE9yaWdpblF1b3RhTWFuYWdlcj4gbG9ja2VyKG9yaWdpblF1 b3RhTWFuYWdlcigpKTsKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUcmFja2VyLmgJKHJldmlzaW9u IDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5oCSh3b3JraW5nIGNv cHkpCkBAIC00NSw3ICs0NSw3IEBACiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIERhdGFi YXNlOwotY2xhc3MgRG9jdW1lbnQ7CitjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogY2xh c3MgU2VjdXJpdHlPcmlnaW47CiAKICNpZiAhUExBVEZPUk0oQ0hST01JVU0pCkBAIC01OSw4ICs1 OSwxMCBAQCBzdHJ1Y3QgU2VjdXJpdHlPcmlnaW5UcmFpdHM7CiBjbGFzcyBEYXRhYmFzZVRyYWNr ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgewogcHVibGljOgogICAgIHN0YXRpYyBEYXRhYmFzZVRy YWNrZXImIHRyYWNrZXIoKTsKKyAgICAvLyBOT1RFOiBJZiBhdCBzb21lIHBvaW50IGFueW9uZSBp bXBsZW1lbnRzIG11bHRpcGxlIHdvcmtlciB0aHJlYWRzCisgICAgLy8gcnVubmluZyBpbiB0aGUg c2FtZSBwcm9jZXNzLCB0aGlzIHNpbmdsZXRvbiB3aWxsIGhhdmUgdG8gYmUgc3luY2hyb25pemVk LgogCi0gICAgYm9vbCBjYW5Fc3RhYmxpc2hEYXRhYmFzZShEb2N1bWVudCosIGNvbnN0IFN0cmlu ZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0 ZWRTaXplKTsKKyAgICBib29sIGNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAgICAgdm9pZCBzZXREYXRhYmFzZURldGFpbHMo U2VjdXJpdHlPcmlnaW4qLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxh eU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAgICAgU3RyaW5nIGZ1bGxQYXRo Rm9yRGF0YWJhc2UoU2VjdXJpdHlPcmlnaW4qLCBjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgY3Jl YXRlSWZEb2VzTm90RXhpc3QgPSB0cnVlKTsKIApJbmRleDogV2ViQ29yZS9zdG9yYWdlL1NRTFRy YW5zYWN0aW9uLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rp b24uY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlv bi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDExICszNSwxMSBAQAogI2luY2x1ZGUgIkRhdGFi YXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VBdXRob3JpemVyLmgiCiAjaW5jbHVkZSAiRGF0YWJh c2VEZXRhaWxzLmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJFeGNlcHRpb25D b2RlLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNsdWRl ICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIK ICNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlNRTEVycm9yLmgiCiAjaW5jbHVkZSAi U1FMaXRlVHJhbnNhY3Rpb24uaCIKQEAgLTk0LDggKzk0LDcgQEAgdm9pZCBTUUxUcmFuc2FjdGlv bjo6ZXhlY3V0ZVNRTChjb25zdCBTdAogCiAgICAgYm9vbCByZWFkT25seU1vZGUgPSBtX3JlYWRP bmx5OwogICAgIGlmICghcmVhZE9ubHlNb2RlKSB7Ci0gICAgICAgIFBhZ2UqIHBhZ2UgPSBtX2Rh dGFiYXNlLT5kb2N1bWVudCgpLT5wYWdlKCk7Ci0gICAgICAgIGlmICghcGFnZSB8fCBwYWdlLT5z ZXR0aW5ncygpLT5wcml2YXRlQnJvd3NpbmdFbmFibGVkKCkpCisgICAgICAgIGlmIChtX2RhdGFi YXNlLT5leGVjdXRpb25Db250ZXh0KCktPmlzRGF0YWJhc2VSZWFkT25seSgpKQogICAgICAgICAg ICAgcmVhZE9ubHlNb2RlID0gdHJ1ZTsKICAgICB9CiAKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9T UUxUcmFuc2FjdGlvbkNsaWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL1NR TFRyYW5zYWN0aW9uQ2xpZW50LmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3Jh Z2UvU1FMVHJhbnNhY3Rpb25DbGllbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00Nyw3ICs0Nyw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlk Q29tbWl0VHJhbnNhY3Rpb24oU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewotICAgIEFT U0VSVChjdXJyZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPmRvY3VtZW50 KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChjdXJyZW50 VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPmV4ZWN1dGlvbkNvbnRleHQoKS0+ ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgRGF0YWJhc2UqIGRhdGFiYXNl ID0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCk7CiAgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2Vy KCkuc2NoZWR1bGVOb3RpZnlEYXRhYmFzZUNoYW5nZWQoCiAgICAgICAgIGRhdGFiYXNlLT5zZWN1 cml0eU9yaWdpbigpLCBkYXRhYmFzZS0+c3RyaW5nSWRlbnRpZmllcigpKTsKQEAgLTU1LDcgKzU1 LDcgQEAgdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkQ29tbWl0VHJhbgogCiB2b2lkIFNR TFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhdGVtZW50KFNRTFRyYW5zYWN0aW9uKiB0 cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9u LT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgp KTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgp LT5leGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOwog ICAgIE9yaWdpblF1b3RhTWFuYWdlciYgbWFuYWdlcihEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIo KS5vcmlnaW5RdW90YU1hbmFnZXIoKSk7CiAgICAgTG9ja2VyPE9yaWdpblF1b3RhTWFuYWdlcj4g bG9ja2VyKG1hbmFnZXIpOwogICAgIG1hbmFnZXIubWFya0RhdGFiYXNlKHRyYW5zYWN0aW9uLT5k YXRhYmFzZSgpKTsKQEAgLTY1LDExICs2NSw5IEBAIGJvb2wgU1FMVHJhbnNhY3Rpb25DbGllbnQ6 OmRpZEV4Y2VlZFF1b3QKIHsKICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwogICAgIERhdGFi YXNlKiBkYXRhYmFzZSA9IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpOwotICAgIFBhZ2UqIHBhZ2Ug PSBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cGFnZSgpOwotICAgIEFTU0VSVChwYWdlKTsKIAogICAg IHVuc2lnbmVkIGxvbmcgbG9uZyBjdXJyZW50UXVvdGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNr ZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4oKSk7Ci0gICAgcGFn ZS0+Y2hyb21lKCktPmNsaWVudCgpLT5leGNlZWRlZERhdGFiYXNlUXVvdGEoZGF0YWJhc2UtPmRv Y3VtZW50KCktPmZyYW1lKCksIGRhdGFiYXNlLT5zdHJpbmdJZGVudGlmaWVyKCkpOworICAgIGRh dGFiYXNlLT5leGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlRXhjZWVkZWRRdW90YShkYXRhYmFz ZS0+c3RyaW5nSWRlbnRpZmllcigpKTsKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgbmV3UXVvdGEg PSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFzZS0+c2Vj dXJpdHlPcmlnaW4oKSk7CiAgICAgcmV0dXJuIChuZXdRdW90YSA+IGN1cnJlbnRRdW90YSk7CiB9 CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvY2hyb21pdW0vRGF0YWJhc2VUcmFja2VyQ2hyb21pdW0u Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFzZVRyYWNr ZXJDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL2Nocm9t aXVtL0RhdGFiYXNlVHJhY2tlckNocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzUsOCAr MzUsOCBAQAogI2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VPYnNlcnZl ci5oIgogI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIK ICNpbmNsdWRlICJRdW90YVRyYWNrZXIuaCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250 ZXh0LmgiCiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKICNpbmNsdWRlICJTUUxpdGVGaWxl U3lzdGVtLmgiCiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KQEAgLTU2LDcgKzU2LDcgQEAgRGF0 YWJhc2VUcmFja2VyOjpEYXRhYmFzZVRyYWNrZXIoKQogICAgIFNRTGl0ZUZpbGVTeXN0ZW06OnJl Z2lzdGVyU1FMaXRlVkZTKCk7CiB9CiAKLWJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxp c2hEYXRhYmFzZShEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYsIHVuc2ln bmVkIGxvbmcpCitib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCAqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmLCB1bnNp Z25lZCBsb25nKQogewogICAgIC8vIEluIENocm9taXVtLCBhIGRhdGFiYXNlIGNhbiBhbHdheXMg YmUgZXN0YWJsaXNoZWQgKGV2ZW4gdGhvdWdoIHdlIG1pZ2h0IG5vdAogICAgIC8vIGJlIGFibGUg dG8gd3JpdGUgYW55dGhpbmcgdG8gaXQgaWYgdGhlIHF1b3RhIGZvciB0aGlzIG9yaWdpbiB3YXMg ZXhjZWVkZWQpCkBAIC03NSwyMSArNzUsMzggQEAgU3RyaW5nIERhdGFiYXNlVHJhY2tlcjo6ZnVs bFBhdGhGb3JEYXRhYgogCiB2b2lkIERhdGFiYXNlVHJhY2tlcjo6YWRkT3BlbkRhdGFiYXNlKERh dGFiYXNlKiBkYXRhYmFzZSkKIHsKLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFT U0VSVChkYXRhYmFzZS0+ZXhlY3V0aW9uQ29udGV4dCgpLT5pc0phdmFTY3JpcHRUaHJlYWQoKSk7 CiAgICAgRGF0YWJhc2VPYnNlcnZlcjo6ZGF0YWJhc2VPcGVuZWQoZGF0YWJhc2UpOwogfQotc3Rh dGljIHZvaWQgcmVtb3ZlT3BlbkRhdGFiYXNlT25NYWluVGhyZWFkKHZvaWQqIGNvbnRleHQpCi17 Ci0gICAgRGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8RGF0YWJhc2UqPihjb250ZXh0 KTsKLSAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5yZW1vdmVPcGVuRGF0YWJhc2UoZGF0 YWJhc2UpOwotICAgIGRhdGFiYXNlLT5kZXJlZigpOwotfQorCitjbGFzcyBUcmFja2VyUmVtb3Zl T3BlbkRhdGFiYXNlVGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsK K3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNl VGFzaz4gY3JlYXRlKERhdGFiYXNlICpkYXRhYmFzZSkKKyAgICB7CisgICAgICAgIHJldHVybiBu ZXcgVHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2soZGF0YWJhc2UpOworICAgIH0KKworICAg IHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0 KQorICAgIHsKKyAgICAgICAgQVNTRVJUKGNvbnRleHQtPmlzSmF2YVNjcmlwdFRocmVhZCgpKTsK KyAgICAgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucmVtb3ZlT3BlbkRhdGFiYXNlKG1f ZGF0YWJhc2UpOworICAgICAgICAvLyBSZWZmZWQgaW4gY2FsbGVyLgorICAgICAgICBtX2RhdGFi YXNlLT5kZXJlZigpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBUcmFja2VyUmVt b3ZlT3BlbkRhdGFiYXNlVGFzayhEYXRhYmFzZSAqZGF0YWJhc2UpIDogbV9kYXRhYmFzZShkYXRh YmFzZSkKKyAgICB7CisgICAgfQorCisgICAgRGF0YWJhc2UqIG1fZGF0YWJhc2U7Cit9OwogCiB2 b2lkIERhdGFiYXNlVHJhY2tlcjo6cmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFz ZSkKIHsKLSAgICBpZiAoIWlzTWFpblRocmVhZCgpKSB7CisgICAgaWYgKCFkYXRhYmFzZS0+ZXhl Y3V0aW9uQ29udGV4dCgpLT5pc0phdmFTY3JpcHRUaHJlYWQoKSkgewogICAgICAgICBkYXRhYmFz ZS0+cmVmKCk7Ci0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQocmVtb3ZlT3BlbkRhdGFiYXNlT25N YWluVGhyZWFkLCBkYXRhYmFzZSk7CisgICAgICAgIGRhdGFiYXNlLT5leGVjdXRpb25Db250ZXh0 KCktPnBvc3RUYXNrKFRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpjcmVhdGUoZGF0YWJh c2UpKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApAQCAtOTgsNyArMTE1LDcgQEAgdm9pZCBE YXRhYmFzZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRhYmFzZQogCiB1bnNpZ25lZCBsb25nIGxvbmcg RGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9yRGF0YWJhc2UoY29uc3QgRGF0YWJhc2UqIGRh dGFiYXNlKQogewotICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPmRvY3Vt ZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChjdXJy ZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPmV4ZWN1dGlvbkNvbnRleHQoKS0+ZGF0YWJhc2VUaHJl YWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgdW5zaWduZWQgbG9uZyBsb25nIHNwYWNlQXZhaWxh YmxlID0gMDsKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgZGF0YWJhc2VTaXplID0gMDsKICAgICBR dW90YVRyYWNrZXI6Omluc3RhbmNlKCkuZ2V0RGF0YWJhc2VTaXplQW5kU3BhY2VBdmFpbGFibGVU b09yaWdpbigKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9TUUxUcmFuc2FjdGlvbkNs aWVudENocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvY2hyb21pdW0v U1FMVHJhbnNhY3Rpb25DbGllbnRDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2Vi Q29yZS9zdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0aW9uQ2xpZW50Q2hyb21pdW0uY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0zOCwyMCArMzgsMzUgQEAKICNpbmNsdWRlICJTUUxUcmFuc2FjdGlv bi5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAKLXN0YXRpYyB2b2lkIG5vdGlmeURh dGFiYXNlQ2hhbmdlZCh2b2lkKiBjb250ZXh0KSB7Ci0gICAgV2ViQ29yZTo6RGF0YWJhc2UqIGRh dGFiYXNlID0gc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RGF0YWJhc2UqPihjb250ZXh0KTsKLSAgICBX ZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpkYXRhYmFzZU1vZGlmaWVkKGRhdGFiYXNlKTsKLSAg ICBkYXRhYmFzZS0+ZGVyZWYoKTsgIC8vIHJlZigpJ2QgaW4gZGlkQ29tbWl0VHJhbnNhY3Rpb24o KQotfQotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIE5vdGlmeURhdGFiYXNlQ2hhbmdl ZFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6Cisg ICAgc3RhdGljIFBhc3NPd25QdHI8Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzaz4gY3JlYXRlKERh dGFiYXNlICpkYXRhYmFzZSkKKyAgICB7CisgICAgICAgIHJldHVybiBuZXcgTm90aWZ5RGF0YWJh c2VDaGFuZ2VkVGFzayhkYXRhYmFzZSk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZv cm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCisgICAgeworICAgICAgICBX ZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpkYXRhYmFzZU1vZGlmaWVkKG1fZGF0YWJhc2UuZ2V0 KCkpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBOb3RpZnlEYXRhYmFzZUNoYW5n ZWRUYXNrKFBhc3NSZWZQdHI8RGF0YWJhc2U+IGRhdGFiYXNlKQorICAgICAgICA6IG1fZGF0YWJh c2UoZGF0YWJhc2UpCisgICAgeworICAgIH0KKworICAgIFJlZlB0cjxEYXRhYmFzZT4gbV9kYXRh YmFzZTsKK307CisKIHZvaWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0 aW9uKFNRTFRyYW5zYWN0aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQoY3VycmVudFRo cmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRo cmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRy YW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5leGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFk KCktPmdldFRocmVhZElEKCkpOwogICAgIGlmICghdHJhbnNhY3Rpb24tPmlzUmVhZE9ubHkoKSkg ewotICAgICAgICB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+cmVmKCk7ICAvLyBkZXJlZigpJ2Qg aW4gbm90aWZ5RGF0YWJhc2VDaGFuZ2VkKCkKLSAgICAgICAgY2FsbE9uTWFpblRocmVhZChub3Rp ZnlEYXRhYmFzZUNoYW5nZWQsIHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpKTsKKyAgICAgICAgdHJh bnNhY3Rpb24tPmRhdGFiYXNlKCktPmV4ZWN1dGlvbkNvbnRleHQoKS0+cG9zdFRhc2soCisgICAg ICAgICAgICBOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrOjpjcmVhdGUodHJhbnNhY3Rpb24tPmRh dGFiYXNlKCkpKTsKICAgICB9CiB9CiAKQEAgLTU5LDE0ICs3NCwxNCBAQCB2b2lkIFNRTFRyYW5z YWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhCiB7CiAgICAgLy8gVGhpcyBtZXRob2QgaXMgY2Fs bGVkIGFmdGVyIGV4ZWN1dGluZyBldmVyeSBzdGF0ZW1lbnQgdGhhdCBjaGFuZ2VzIHRoZSBEQi4K ICAgICAvLyBDaHJvbWl1bSBkb2Vzbid0IG5lZWQgdG8gZG8gYW55dGhpbmcgYXQgdGhhdCBwb2lu dC4KLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgp LT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NF UlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5leGVjdXRpb25D b250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOwogfQogCi1ib29sIFNR TFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YShTUUxUcmFuc2FjdGlvbiopCitib29s IFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YShTUUxUcmFuc2FjdGlvbiogdHJh bnNhY3Rpb24pCiB7CiAgICAgLy8gQ2hyb21pdW0gZG9lcyBub3QgYWxsb3cgdXNlcnMgdG8gbWFu dWFsbHkgY2hhbmdlIHRoZSBxdW90YSBmb3IgYW4gb3JpZ2luIChmb3Igbm93LCBhdCBsZWFzdCku CiAgICAgLy8gRG9uJ3QgZG8gYW55dGhpbmcuCi0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsK KyAgICBBU1NFUlQodHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPmV4ZWN1dGlvbkNvbnRleHQoKS0+ aXNKYXZhU2NyaXB0VGhyZWFkKCkpOwogICAgIHJldHVybiBmYWxzZTsKIH0KIApJbmRleDogV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29y a2Vycy9Xb3JrZXJDb250ZXh0LmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3dvcmtl cnMvV29ya2VyQ29udGV4dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMyLDYgKzMyLDkgQEAKICNp bmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCiAKICNpbmNsdWRlICJBY3RpdmVET01PYmplY3QuaCIK KyNpZiBFTkFCTEUoREFUQUJBU0UpCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKKyNlbmRpZgogI2lu Y2x1ZGUgIkRPTVRpbWVyLmgiCiAjaW5jbHVkZSAiRE9NV2luZG93LmgiCiAjaW5jbHVkZSAiRXZl bnQuaCIKQEAgLTI1NCw2ICsyNTcsMjQgQEAgTm90aWZpY2F0aW9uQ2VudGVyKiBXb3JrZXJDb250 ZXh0Ojp3ZWJraQogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCitQYXNzUmVmUHRy PERhdGFiYXNlPiBXb3JrZXJDb250ZXh0OjpvcGVuRGF0YWJhc2UoY29uc3QgU3RyaW5nJiBuYW1l LCBjb25zdCBTdHJpbmcmIHZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2ln bmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgaWYgKCFz ZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NEYXRhYmFzZSgpKQorICAgICAgICByZXR1cm4gMDsK KworICAgIGlmICghRGF0YWJhc2U6OmlzQXZhaWxhYmxlKCkpCisgICAgICAgIHJldHVybiAwOwor CisgICAgcmV0dXJuIERhdGFiYXNlOjpvcGVuRGF0YWJhc2UodGhpcywgbmFtZSwgdmVyc2lvbiwg ZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUsIGVjKTsKK30KKyNlbmRpZgorCitib29sIFdvcmtl ckNvbnRleHQ6OmlzSmF2YVNjcmlwdFRocmVhZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGN1cnJl bnRUaHJlYWQoKSA9PSB0aHJlYWQoKS0+dGhyZWFkSUQoKTsKK30KKwogRXZlbnRUYXJnZXREYXRh KiBXb3JrZXJDb250ZXh0OjpldmVudFRhcmdldERhdGEoKQogewogICAgIHJldHVybiAmbV9ldmVu dFRhcmdldERhdGE7CkluZGV4OiBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgJKHJldmlzaW9uIDUyOTk1 KQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAkod29ya2luZyBjb3B5KQpAQCAt MzUsMTMgKzM1LDE5IEBACiAjaW5jbHVkZSAiRXZlbnRUYXJnZXQuaCIKICNpbmNsdWRlICJTY3Jp cHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5o IgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVkZSA8d3RmL093blB0ci5oPgog I2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4K ICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisjaW5jbHVk ZSAiRGF0YWJhc2UuaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKKyAgICBjbGFz cyBEYXRhYmFzZTsKICAgICBjbGFzcyBOb3RpZmljYXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2No ZWR1bGVkQWN0aW9uOwogICAgIGNsYXNzIFdvcmtlckxvY2F0aW9uOwpAQCAtNjUsOSArNzEsOSBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgU3RyaW5nIHVzZXJBZ2VudChj b25zdCBLVVJMJikgY29uc3Q7CiAKICAgICAgICAgV29ya2VyU2NyaXB0Q29udHJvbGxlciogc2Ny aXB0KCkgeyByZXR1cm4gbV9zY3JpcHQuZ2V0KCk7IH0KLSAgICAgICAgdm9pZCBjbGVhclNjcmlw dCgpIHsgcmV0dXJuIG1fc2NyaXB0LmNsZWFyKCk7IH0KKyAgICAgICAgdm9pZCBjbGVhclNjcmlw dCgpIHsgbV9zY3JpcHQuY2xlYXIoKTsgfQogCi0gICAgICAgIFdvcmtlclRocmVhZCogdGhyZWFk KCkgeyByZXR1cm4gbV90aHJlYWQ7IH0KKyAgICAgICAgV29ya2VyVGhyZWFkKiB0aHJlYWQoKSBj b25zdCB7IHJldHVybiBtX3RocmVhZDsgfQogCiAgICAgICAgIGJvb2wgaGFzUGVuZGluZ0FjdGl2 aXR5KCkgY29uc3Q7CiAKQEAgLTEwMSw2ICsxMDcsMTUgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog ICAgICAgICBOb3RpZmljYXRpb25DZW50ZXIqIHdlYmtpdE5vdGlmaWNhdGlvbnMoKSBjb25zdDsK ICNlbmRpZgogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorICAgICAgICAvLyBIVE1MIDUgY2xpZW50 LXNpZGUgZGF0YWJhc2UKKyAgICAgICAgUGFzc1JlZlB0cjxEYXRhYmFzZT4gb3BlbkRhdGFiYXNl KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2ZXJzaW9uLCBjb25zdCBTdHJpbmcm IGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUm KTsKKyAgICAgICAgdmlydHVhbCBib29sIGlzRGF0YWJhc2VSZWFkT25seSgpIGNvbnN0IHsgcmV0 dXJuIGZhbHNlOyAvKiBUT0RPKGVyaWN1KSAqLyB9CisgICAgICAgIHZpcnR1YWwgdm9pZCBkYXRh YmFzZUV4Y2VlZGVkUXVvdGEoY29uc3QgU3RyaW5nJikgeyAvKiBUT0RPKGVyaWN1KSAqL30KKyNl bmRpZgorICAgICAgICB2aXJ0dWFsIGJvb2wgaXNKYXZhU2NyaXB0VGhyZWFkKCkgY29uc3Q7CisK KwogICAgICAgICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUg SlNXb3JrZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4KICAgICAgICAgLy8g SlNXb3JrZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRp b25hbE5hdmlnYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdldCgpOyB9CkluZGV4 OiBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUv d29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAkod29ya2luZyBjb3B5KQpAQCAtNDksNyArNDksMTAg QEAgbW9kdWxlIHRocmVhZHMgewogICAgICAgICAvLyBXb3JrZXJVdGlscwogICAgICAgICBbQ3Vz dG9tXSB2b2lkIGltcG9ydFNjcmlwdHMoLypbVmFyaWFkaWNdIGluIERPTVN0cmluZyB1cmxzICov KTsKICAgICAgICAgICAgICAgICAgYXR0cmlidXRlIFtSZXBsYWNlYWJsZV0gV29ya2VyTmF2aWdh dG9yIG5hdmlnYXRvcjsKLSAgICAgICAgLy8gRGF0YWJhc2Ugb3BlbkRhdGFiYXNlKGluIERPTVN0 cmluZyBuYW1lLCBpbiBET01TdHJpbmcgdmVyc2lvbiwgaW4gRE9NU3RyaW5nIGRpc3BsYXlOYW1l LCBpbiB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOworI2lmIGRlZmluZWQoRU5BQkxFX0RB VEFCQVNFKSAmJiBFTkFCTEVfREFUQUJBU0UKKyAgICAgICAgW0VuYWJsZWRBdFJ1bnRpbWVdIERh dGFiYXNlIG9wZW5EYXRhYmFzZShpbiBET01TdHJpbmcgbmFtZSwgaW4gRE9NU3RyaW5nIHZlcnNp b24sIGluIERPTVN0cmluZyBkaXNwbGF5TmFtZSwgaW4gdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRT aXplKQorICAgICAgICAgICAgcmFpc2VzKERPTUV4Y2VwdGlvbik7CisjZW5kaWYKICAgICAgICAg Ly8gRGF0YWJhc2VTeW5jIG9wZW5EYXRhYmFzZVN5bmMoaW4gRE9NU3RyaW5nIG5hbWUsIGluIERP TVN0cmluZyB2ZXJzaW9uLCBpbiBET01TdHJpbmcgZGlzcGxheU5hbWUsIGluIHVuc2lnbmVkIGxv bmcgZXN0aW1hdGVkU2l6ZSk7CiAKICAgICAgICAgLy8gVGltZXJzCkluZGV4OiBXZWJDb3JlL3dv cmtlcnMvV29ya2VyUnVuTG9vcC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93b3JrZXJzL1dv cmtlclJ1bkxvb3AuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvd29ya2Vycy9Xb3Jr ZXJSdW5Mb29wLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTUyLDkgKzE1Miw3IEBAIE1lc3NhZ2VR dWV1ZVdhaXRSZXN1bHQgV29ya2VyUnVuTG9vcDo6cnUKICAgICBNZXNzYWdlUXVldWVXYWl0UmVz dWx0IHJlc3VsdDsKICAgICBPd25QdHI8V29ya2VyUnVuTG9vcDo6VGFzaz4gdGFzayA9IG1fbWVz c2FnZVF1ZXVlLndhaXRGb3JNZXNzYWdlRmlsdGVyZWRXaXRoVGltZW91dChyZXN1bHQsIHByZWRp Y2F0ZSwgYWJzb2x1dGVUaW1lKTsKIAotICAgIC8vIElmIHRoZSBjb250ZXh0IGlzIGNsb3Npbmcs IGRvbid0IGRpc3BhdGNoIGFueSBmdXJ0aGVyIHRhc2tzIChwZXIgc2VjdGlvbiA0LjEuMSBvZiB0 aGUgV2ViIFdvcmtlcnMgc3BlYykuCi0gICAgaWYgKGNvbnRleHQtPmlzQ2xvc2luZygpKQotICAg ICAgICByZXR1cm4gcmVzdWx0OworICAgIC8vIElmIHRoZSBjb250ZXh0IGlzIGNsb3NpbmcsIGRv bid0IGV4ZWN1dGUgYW55IGZ1cnRoZXIgSmF2YVNjcmlwdCB0YXNrcyAocGVyIHNlY3Rpb24gNC4x LjEgb2YgdGhlIFdlYiBXb3JrZXJzIHNwZWMpLiAgSG93ZXZlciwgdGhlcmUgbWF5IGJlIGltcGxl bWVudGF0aW9uIGNsZWFudXAgdGFza3MgaW4gdGhlIHF1ZXVlLCBzbyBrZWVwIHJ1bm5pbmcgdGhy b3VnaCBpdC4KIAogICAgIHN3aXRjaCAocmVzdWx0KSB7CiAgICAgY2FzZSBNZXNzYWdlUXVldWVU ZXJtaW5hdGVkOgpAQCAtMTY1LDcgKzE2Myw4IEBAIE1lc3NhZ2VRdWV1ZVdhaXRSZXN1bHQgV29y a2VyUnVuTG9vcDo6cnUKICAgICAgICAgYnJlYWs7CiAKICAgICBjYXNlIE1lc3NhZ2VRdWV1ZVRp bWVvdXQ6Ci0gICAgICAgIG1fc2hhcmVkVGltZXItPmZpcmUoKTsKKyAgICAgICAgaWYgKCFjb250 ZXh0LT5pc0Nsb3NpbmcoKSkKKyAgICAgICAgICAgIG1fc2hhcmVkVGltZXItPmZpcmUoKTsKICAg ICAgICAgYnJlYWs7CiAgICAgfQogCkBAIC0xOTQsNyArMTkzLDkgQEAgUGFzc093blB0cjxXb3Jr ZXJSdW5Mb29wOjpUYXNrPiBXb3JrZXJSdQogCiB2b2lkIFdvcmtlclJ1bkxvb3A6OlRhc2s6OnBl cmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCiB7Ci0gICAgbV90YXNr LT5wZXJmb3JtVGFzayhjb250ZXh0KTsKKyAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0 ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCAqPihjb250ZXh0KTsKKyAgICBpZiAoIXdvcmtl ckNvbnRleHQtPmlzQ2xvc2luZygpIHx8IG1fdGFzay0+aXNDbGVhbnVwVGFzaygpKQorICAgICAg ICBtX3Rhc2stPnBlcmZvcm1UYXNrKGNvbnRleHQpOwogfQogCiBXb3JrZXJSdW5Mb29wOjpUYXNr OjpUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywgY29u c3QgU3RyaW5nJiBtb2RlKQpJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAJKHJldmlzaW9u IDUyOTk1KQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogCisjaW5j bHVkZSAiRGF0YWJhc2VUYXNrLmgiCiAjaW5jbHVkZSAiRGVkaWNhdGVkV29ya2VyQ29udGV4dC5o IgogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgpAQCAtMTM1 LDkgKzEzNiw4IEBAIHZvaWQqIFdvcmtlclRocmVhZDo6d29ya2VyVGhyZWFkKCkKIAogICAgIFRo cmVhZElkZW50aWZpZXIgdGhyZWFkSUQgPSBtX3RocmVhZElEOwogCi0gICAgbV93b3JrZXJDb250 ZXh0LT5zdG9wQWN0aXZlRE9NT2JqZWN0cygpOwotICAgIG1fd29ya2VyQ29udGV4dC0+Y2xlYXJT Y3JpcHQoKTsKICAgICBBU1NFUlQobV93b3JrZXJDb250ZXh0LT5oYXNPbmVSZWYoKSk7CisKICAg ICAvLyBUaGUgYmVsb3cgYXNzaWdubWVudCB3aWxsIGRlc3Ryb3kgdGhlIGNvbnRleHQsIHdoaWNo IHdpbGwgaW4gdHVybiBub3RpZnkgbWVzc2FnaW5nIHByb3h5LgogICAgIC8vIFdlIGNhbm5vdCBs ZXQgYW55IG9iamVjdHMgc3Vydml2ZSBwYXN0IHRocmVhZCBleGl0LCBiZWNhdXNlIG5vIG90aGVy IHRocmVhZCB3aWxsIHJ1biBHQyBvciBvdGhlcndpc2UgZGVzdHJveSB0aGVtLgogICAgIG1fd29y a2VyQ29udGV4dCA9IDA7CkBAIC0xNTQsMTcgKzE1NCw3OSBAQCB2b2lkIFdvcmtlclRocmVhZDo6 cnVuRXZlbnRMb29wKCkKICAgICBtX3J1bkxvb3AucnVuKG1fd29ya2VyQ29udGV4dC5nZXQoKSk7 CiB9CiAKK2NsYXNzIFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzayA6IHB1YmxpYyBTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0 cjxXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2s+IGNyZWF0ZShXb3JrZXJDb250ZXh0ICp3 b3JrZXJDb250ZXh0KQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBXb3JrZXJUaHJlYWRTaHV0 ZG93bkZpbmlzaFRhc2sod29ya2VyQ29udGV4dCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lk IHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQpCisgICAgeworICAg ICAgICBBU1NFUlQoY29udGV4dC0+aXNKYXZhU2NyaXB0VGhyZWFkKCkpOworICAgICAgICBtX3dv cmtlckNvbnRleHQtPnRocmVhZCgpLT5ydW5Mb29wKCkudGVybWluYXRlKCk7CisgICAgfQorCisg ICAgdmlydHVhbCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisK K3ByaXZhdGU6CisgICAgZXhwbGljaXQgV29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrKFdv cmtlckNvbnRleHQgKndvcmtlckNvbnRleHQpIDogbV93b3JrZXJDb250ZXh0KHdvcmtlckNvbnRl eHQpCisgICAgeworICAgIH0KKyAgICBXb3JrZXJDb250ZXh0KiBtX3dvcmtlckNvbnRleHQ7Cit9 OworCitjbGFzcyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzayA6IHB1YmxpYyBTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxX b3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzaz4gY3JlYXRlKFdvcmtlckNvbnRleHQgKndvcmtl ckNvbnRleHQpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IFdvcmtlclRocmVhZFNodXRkb3du U3RhcnRUYXNrKHdvcmtlckNvbnRleHQpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJm b3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAg QVNTRVJUKGNvbnRleHQtPmlzSmF2YVNjcmlwdFRocmVhZCgpKTsKKyAgICAgICAgLy8gV2UgY3Vy cmVudGx5IGlnbm9yZSBhbnkgRGF0YWJhc2VQb2xpY3kgdXNlZCBmb3IgdGhlIGRvY3VtZW50J3MK KyAgICAgICAgLy8gZGF0YWJhc2VzOyBpZiBpdCdzIGFjdHVhbGx5IHVzZWQgYW55d2hlcmUsIHRo aXMgc2hvdWxkIGJlIHJldmlzaXRlZC4KKyAgICAgICAgRGF0YWJhc2VUYXNrU3luY2hyb25pemVy IGNsZWFudXBTeW5jOworICAgICAgICBtX3dvcmtlckNvbnRleHQtPnN0b3BEYXRhYmFzZXMoJmNs ZWFudXBTeW5jKTsKKworICAgICAgICBtX3dvcmtlckNvbnRleHQtPnN0b3BBY3RpdmVET01PYmpl Y3RzKCk7CisgICAgICAgIG1fd29ya2VyQ29udGV4dC0+Y2xlYXJTY3JpcHQoKTsKKworICAgICAg ICAvLyBXZSB3YWl0IGZvciB0aGUgZGF0YWJhc2UgdGhyZWFkIHRvIGNsZWFuIHVwIGFsbCBpdHMg c3R1ZmYgc28gdGhhdCB3ZQorICAgICAgICAvLyBjYW4gZG8gbW9yZSBzdHJpbmdlbnQgbGVhayBj aGVja3MgYXMgd2UgZXhpdC4KKyAgICAgICAgY2xlYW51cFN5bmMud2FpdEZvclRhc2tDb21wbGV0 aW9uKCk7CisKKyAgICAgICAgLy8gU3RpY2sgYSBzaHV0ZG93biBjb21tYW5kIGF0IHRoZSBlbmQg b2YgdGhlIHF1ZXVlLCBzbyB0aGF0IHdlIGRlYWwKKyAgICAgICAgLy8gd2l0aCBhbGwgdGhlIGNs ZWFudXAgdGFza3MgdGhlIGRhdGFiYXNlcyBwb3N0IGZpcnN0LgorICAgICAgICBjb250ZXh0LT5w b3N0VGFzayhXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2s6OmNyZWF0ZShtX3dvcmtlckNv bnRleHQpKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGVhbnVwVGFzaygpIGNvbnN0 IHsgcmV0dXJuIHRydWU7IH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBXb3JrZXJUaHJlYWRT aHV0ZG93blN0YXJ0VGFzayhXb3JrZXJDb250ZXh0ICp3b3JrZXJDb250ZXh0KSA6IG1fd29ya2Vy Q29udGV4dCh3b3JrZXJDb250ZXh0KQorICAgIHsKKyAgICB9CisgICAgV29ya2VyQ29udGV4dCog bV93b3JrZXJDb250ZXh0OworfTsKKwogdm9pZCBXb3JrZXJUaHJlYWQ6OnN0b3AoKQogewogICAg IC8vIE11dGV4IHByb3RlY3Rpb24gaXMgbmVjZXNzYXJ5IGJlY2F1c2Ugc3RvcCgpIGNhbiBiZSBj YWxsZWQgYmVmb3JlIHRoZSBjb250ZXh0IGlzIGZ1bGx5IGNyZWF0ZWQuCiAgICAgTXV0ZXhMb2Nr ZXIgbG9jayhtX3RocmVhZENyZWF0aW9uTXV0ZXgpOwogCiAgICAgLy8gRW5zdXJlIHRoYXQgdGFz a3MgYXJlIGJlaW5nIGhhbmRsZWQgYnkgdGhyZWFkIGV2ZW50IGxvb3AuIElmIHNjcmlwdCBleGVj dXRpb24gd2VyZW4ndCBmb3JiaWRkZW4sIGEgd2hpbGUoMSkgbG9vcCBpbiBKUyBjb3VsZCBrZWVw IHRoZSB0aHJlYWQgYWxpdmUgZm9yZXZlci4KLSAgICBpZiAobV93b3JrZXJDb250ZXh0KQorICAg IGlmIChtX3dvcmtlckNvbnRleHQpIHsKICAgICAgICAgbV93b3JrZXJDb250ZXh0LT5zY3JpcHQo KS0+Zm9yYmlkRXhlY3V0aW9uKCk7CiAKICAgICAvLyBGSVhNRTogUnVkZWx5IGtpbGxpbmcgdGhl IHRocmVhZCB3b24ndCB3b3JrIHdoZW4gd2UgYWxsb3cgbmVzdGVkIHdvcmtlcnMsIGJlY2F1c2Ug dGhleSB3aWxsIHRyeSB0byBwb3N0IG5vdGlmaWNhdGlvbnMgb2YgdGhlaXIgZGVzdHJ1Y3Rpb24u Ci0gICAgbV9ydW5Mb29wLnRlcm1pbmF0ZSgpOworICAgIC8vIE5PVEU6IHRoaXMgY2FuIGxpa2Vs eSB1c2UgdGhlIHNhbWUgbWVjaGFuaXNtIGFzIHVzZWQgZm9yIGRhdGFiYXNlcyBhYm92ZS4KKwor ICAgICAgICBtX3J1bkxvb3AucG9zdFRhc2soV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6 OmNyZWF0ZShtX3dvcmtlckNvbnRleHQuZ2V0KCkpKTsKKyAgICB9IGVsc2UKKyAgICAgICAgbV9y dW5Mb29wLnRlcm1pbmF0ZSgpOwogfQogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCg== 46331 2010-01-11 19:20:31 -0800 2010-01-12 15:16:36 -0800 Next revision, rolling in more comments. upload.2.1.patch text/plain 63108 ericu SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzA5NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUwIEBACisyMDEwLTAxLTExICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVmYWN0b3JpbmcgYW5kIHBsdW1iaW5nIHRvIGdldCB0aGUgSFRNTDUgU1FMIERhdGFiYXNlIEFQ SSBhY2Nlc3NpYmxlIHRvCisgICAgICAgIHdlYiB3b3JrZXJzLiAgTm8gbmV3IGZ1bmN0aW9uYWxp dHkgaXMgZXhwb3NlZCB5ZXQ7IHRoaXMganVzdCBnZXRzIHRoZQorICAgICAgICBpbmZyYXN0cnVj dHVyZSBpbiBwbGFjZS4gIEl0IHRvdWNoZXMgYSBsb3Qgb2YgZmlsZXMgaW4gc21hbGwgd2F5czsg aGVyZQorICAgICAgICBhcmUgdGhlIG1haW4gY2hhbmdlczoKKworICAgICAgICAxKSBEYXRhYmFz ZSBtZW1iZXJzIGFuZCBtZXRob2RzIG1vdmUgZnJvbSBEb2N1bWVudCB1cCB0bworICAgICAgICBT Y3JpcHRFeGVjdXRpb25Db250ZXh0LiAgRWFjaCBvZiBEb2N1bWVudCBhbmQgV29ya2VyQ29udGV4 dCBtdXN0CisgICAgICAgIGltcGxlbWVudCBhIGZldyB2aXJ0dWFsIG1ldGhvZHMgd2hlcmUgdGhl IERhdGFiYXNlIGNvZGUgcmVxdWlyZXMKKyAgICAgICAgZGlmZmVyZW50aWF0aW9uLgorICAgICAg ICAyKSBXb3JrZXIgdGhyZWFkIHNodXRkb3duIGdvdCBjaGFuZ2VkIGEgYnVuY2ggdG8gaGFuZGxl IERhdGFiYXNlIGNsZWFudXAKKyAgICAgICAgYW5kIHRocmVhZCBzeW5jaHJvbml6YXRpb24gaXNz dWVzLiAgRGF0YWJhc2UgY2xlYW51cCB0YXNrcyBuZWVkIHRvIHBvc3QKKyAgICAgICAgc29tZSBj bGVhbnVwIHRhc2tzIHRvIHRoZSBKYXZhU2NyaXB0IHRocmVhZC4gIEhvd2V2ZXIsIHNpbmNlIGRh dGFiYXNlCisgICAgICAgIGNsZWFudXAgbWF5IGhhcHBlbiBkdWUgdG8gdGhlIGRlc3RydWN0aW9u IG9mIHRoZSBXb3JrZXJUaHJlYWQsIEkgYWRkZWQgYQorICAgICAgICBoYW5kc2hha2UgW2ludm9s dmluZyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzaywKKyAgICAgICAgV29ya2VyVGhyZWFk U2h1dGRvd25GaW5pc2hUYXNrLCBhbmQgYSBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXJdIGJldHdl ZW4KKyAgICAgICAgdGhlIERhdGFiYXNlIHRocmVhZCBhbmQgV29ya2VyVGhyZWFkIHRoYXQgY2xl YW5zIHVwIGFsbCB0aGUgRGF0YWJhc2UKKyAgICAgICAgc3R1ZmYgYmVmb3JlIHRoZSBXb3JrZXJU aHJlYWQncyBydW5Mb29wIGNhbiBleGl0LgorICAgICAgICAzKSBUaGUgcnVudGltZSBlbmFibGVy IGZvciB0aGUgRGF0YWJhc2UgbW92ZWQgdG8gYSBzdGF0aWMgdmFyaWFibGUKKyAgICAgICAgYWNj ZXNzaWJsZSB0aHJvdWdoIERhdGFiYXNlOjppc0F2YWlsYWJsZSwgZm9sbG93aW5nIHRoZSBtb2Rl bCB1c2VkIGJ5CisgICAgICAgIFdlYlNvY2tldC4KKyAgICAgICAgNCkgV29ya2VyIHRocmVhZHMg ZG9uJ3QgcnVuIHRoZWlyIEphdmFTY3JpcHQgb24gdGhlIE1haW4gdGhyZWFkLCBzbworICAgICAg ICBEYXRhYmFzZSBjb2RlIHRoYXQgZGlmZmVyZW50aWF0ZWQgYmV0d2VlbiB0aGUgTWFpbiB0aHJl YWQgYW5kIHRoZQorICAgICAgICBEYXRhYmFzZSB0aHJlYWQgbm93IG5lZWQgdG8gZGVhbCB3aXRo IGEgdGhpcmQgcG9zc2liaWxpdHkuCisgICAgICAgIDUpIE1vc3Qgb2YgdGhlIG90aGVyIGNoYW5n ZXMgaGF2ZSB0byBkbyB3aXRoIGhhdmluZyBhCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgcG9pbnRlciBpbnN0ZWFkIG9mIGEgRG9jdW1lbnQgcG9pbnRlciB3aGVuCisgICAgICAgIGRl YWxpbmcgd2l0aCBhIERhdGFiYXNlLiAgSW4gbWFueSBjYXNlcyBpdCdzIGp1c3QgYSBzdHJpbmcg cmVwbGFjZW1lbnQsCisgICAgICAgIGJ1dCBpbiBzb21lIGl0IHJlcXVpcmVkIHRoZSBjcmVhdGlv biBvZiBhIG5ldyB2aXJ0dWFsIGZ1bmN0aW9uIFtlLmcuCisgICAgICAgIGRhdGFiYXNlRXhjZWVk ZWRRdW90YSwgaXNEYXRhYmFzZVJlYWRPbmx5XQorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjcyNQorCisgICAgICAgIE5vIG5ldyB0ZXN0czsgaW4g YSBmdXR1cmUgcGF0Y2ggSSdsbCBhZGQgSlNDIGFuZCBWOCBiaW5kaW5ncyBhbmQgbmV3CisgICAg ICAgIGxheW91dCB0ZXN0cyB0byBleGVyY2lzZSB0aGVtLgorCisgICAgICAgICogYmluZGluZ3Mv djgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4RE9N V2luZG93OjpPcGVuRGF0YWJhc2VFbmFibGVkKToKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNv cmU6OkRvY3VtZW50Ojp+RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6Omlz RGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZGF0YWJhc2VF eGNlZWRlZFF1b3RhKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojppc0NvbnRleHRUaHJl YWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAgICAqIGRvbS9TY3JpcHRFeGVj dXRpb25Db250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RXhl Y3V0aW9uQ29udGV4dDo6flNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6ZGF0YWJhc2VUaHJlYWQpOgorICAgICAgICAoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6YWRkT3BlbkRhdGFiYXNlKToKKyAgICAgICAg KFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9wZW5EYXRhYmFzZSk6Cisg ICAgICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdG9wRGF0YWJhc2VzKToK KyAgICAgICAgKiBkb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c2V0SGFzT3BlbkRhdGFiYXNlcyk6CisgICAgICAg IChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpoYXNPcGVuRGF0YWJhc2VzKToKKyAg ICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s6OmlzQ2xlYW51cFRh c2spOgorICAgICAgICAqIGxvYWRlci9GcmFtZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpGcmFtZUxvYWRlcjo6c3RvcExvYWRpbmcpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2Uu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNldElzQXZhaWxhYmxlKToKKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlOjppc0F2YWlsYWJsZSk6CisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZTo6b3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpEYXRh YmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEZXJlZkNvbnRleHRUYXNrOjpjcmVhdGUpOgorICAg ICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAo V2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6aXNDbGVhbnVwVGFzayk6CisgICAgICAgIChXZWJD b3JlOjpEZXJlZkNvbnRleHRUYXNrOjpEZXJlZkNvbnRleHRUYXNrKToKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFiYXNlOjp+RGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6Om9w ZW5BbmRWZXJpZnlWZXJzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjptYXJrQXNE ZWxldGVkQW5kQ2xvc2UpOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4dFJlbW92ZU9wZW5EYXRh YmFzZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDb250ZXh0UmVtb3ZlT3BlbkRh dGFiYXNlVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4dFJlbW92 ZU9wZW5EYXRhYmFzZVRhc2s6OmlzQ2xlYW51cFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6Q29u dGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNr KToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpjbG9zZSk6CisgICAgICAgIChXZWJDb3Jl OjpEYXRhYmFzZTo6cGVyZm9ybU9wZW5BbmRWZXJpZnkpOgorICAgICAgICAoV2ViQ29yZTo6RGF0 YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6 OnNjaGVkdWxlVHJhbnNhY3Rpb25TdGVwKToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGl2ZXJQZW5k aW5nQ2FsbGJhY2tUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6RGVsaXZlclBlbmRp bmdDYWxsYmFja1Rhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGl2ZXJQ ZW5kaW5nQ2FsbGJhY2tUYXNrOjpEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayk6CisgICAgICAg IChXZWJDb3JlOjpEYXRhYmFzZTo6c2NoZWR1bGVUcmFuc2FjdGlvbkNhbGxiYWNrKToKKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlOjp0cmFuc2FjdGlvbkNsaWVudCk6CisgICAgICAgIChXZWJD b3JlOjpEYXRhYmFzZTo6dHJhbnNhY3Rpb25Db29yZGluYXRvcik6CisgICAgICAgIChXZWJDb3Jl OjpEYXRhYmFzZTo6dGFibGVOYW1lcyk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6c2Vj dXJpdHlPcmlnaW4pOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2UuaDoKKyAgICAgICAgKFdl YkNvcmU6OkRhdGFiYXNlOjpzY3JpcHRFeGVjdXRpb25Db250ZXh0KToKKyAgICAgICAgKiBzdG9y YWdlL0RhdGFiYXNlVGFzay5oOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKToKKyAg ICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQpOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbik6CisgICAgICAg IChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6ZGF0YWJhc2VUaHJlYWQpOgorICAgICAgICAoV2Vi Q29yZTo6RGF0YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKToKKyAgICAgICAg KiBzdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmg6CisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRy YWNrZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxp c2hEYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRyYWNrZXI6OmdldE1heFNp emVGb3JEYXRhYmFzZSk6CisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuaDoKKyAg ICAgICAgKiBzdG9yYWdlL1NRTFRyYW5zYWN0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNR TFRyYW5zYWN0aW9uOjpleGVjdXRlU1FMKToKKyAgICAgICAgKiBzdG9yYWdlL1NRTFRyYW5zYWN0 aW9uQ2xpZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50Ojpk aWRDb21taXRUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbkNs aWVudDo6ZGlkRXhlY3V0ZVN0YXRlbWVudCk6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2Fj dGlvbkNsaWVudDo6ZGlkRXhjZWVkUXVvdGEpOgorICAgICAgICAqIHN0b3JhZ2UvY2hyb21pdW0v RGF0YWJhc2VUcmFja2VyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VU cmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFz ZVRyYWNrZXI6OmFkZE9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpUcmFja2VyUmVt b3ZlT3BlbkRhdGFiYXNlVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlRyYWNrZXJS ZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpU cmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRh c2spOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpyZW1vdmVPcGVuRGF0YWJh c2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9yRGF0 YWJhc2UpOgorICAgICAgICAqIHN0b3JhZ2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRD aHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNr OjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzazo6 cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFz azo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFu c2FjdGlvbkNsaWVudDo6ZGlkQ29tbWl0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6 U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4ZWN1dGVTdGF0ZW1lbnQpOgorICAgICAgICAoV2Vi Q29yZTo6U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKToKKyAgICAgICAgKiB3 b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4 dDo6b3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OmlzQ29u dGV4dFRocmVhZCk6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAg IChXZWJDb3JlOjpXb3JrZXJDb250ZXh0OjpjbGVhclNjcmlwdCk6CisgICAgICAgIChXZWJDb3Jl OjpXb3JrZXJDb250ZXh0Ojp0aHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4 dDo6aXNEYXRhYmFzZVJlYWRPbmx5KToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6 OmRhdGFiYXNlRXhjZWVkZWRRdW90YSk6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0 LmlkbDoKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6V29ya2VyUnVuTG9vcDo6cnVuSW5Nb2RlKToKKyAgICAgICAgKFdlYkNvcmU6Oldvcmtl clJ1bkxvb3A6OlRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclRo cmVhZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWQ6OndvcmtlclRocmVhZCk6 CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2s6OmNyZWF0 ZSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2s6OnBl cmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duRmluaXNo VGFzazo6aXNDbGVhbnVwVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0 ZG93bkZpbmlzaFRhc2s6OldvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzayk6CisgICAgICAg IChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6Y3JlYXRlKToKKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpwZXJmb3JtVGFzayk6 CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6aXNDbGVh bnVwVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFz azo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6V29y a2VyVGhyZWFkOjpzdG9wKToKKwogMjAxMC0wMS0xMSAgTmlrb2xhcyBaaW1tZXJtYW5uICA8bnpp bW1lcm1hbm5AcmltLmNvbT4KIAogICAgICAgICBOb3QgcmV2aWV3ZWQuIEF0dGVtcHQgdG8gZml4 IHdpbmRvd3MgYnVpbGRzLCBieSByZW1vdmluZyB0aGUgbm8tbG9uZ2VyIGV4aXN0YW50IEpTU1ZH UG9pbnRMaXN0Q3VzdG9tLmNwcCBmcm9tIEpTQmluZGluZ3NBbGxJbk9uZS5jcHAuCkluZGV4OiBX ZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERPTVdpbmRvd0N1c3RvbS5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhET01XaW5kb3dDdXN0b20uY3BwCShy ZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93 Q3VzdG9tLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzMsNiArMzMsNyBAQAogCiAjaW5jbHVkZSAi QmFzZTY0LmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKICNp bmNsdWRlICJET01UaW1lci5oIgogI2luY2x1ZGUgIkRPTVdpbmRvdy5oIgogI2luY2x1ZGUgIkV4 Y2VwdGlvbkNvZGUuaCIKQEAgLTI5NSw3ICsyOTYsNyBAQCBib29sIFY4RE9NV2luZG93OjpXZWJT b2NrZXRFbmFibGVkKCkKICNpZiBFTkFCTEUoREFUQUJBU0UpCiBib29sIFY4RE9NV2luZG93OjpP cGVuRGF0YWJhc2VFbmFibGVkKCkKIHsKLSAgICByZXR1cm4gV2ViQ29yZTo6UnVudGltZUVuYWJs ZWRGZWF0dXJlczo6ZGF0YWJhc2VFbmFibGVkKCk7CisgICAgcmV0dXJuIERhdGFiYXNlOjppc0F2 YWlsYWJsZSgpOwogfQogI2VuZGlmCiAKSW5kZXg6IFdlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAJKHJldmlzaW9uIDUyOTk1KQor KysgV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNyw2ICszNyw3 IEBACiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgIkNhY2hlZENTU1N0eWxlU2hlZXQu aCIKICNpbmNsdWRlICJDaHJvbWUuaCIKKyNpbmNsdWRlICJDaHJvbWVDbGllbnQuaCIKICNpbmNs dWRlICJDb21tZW50LmgiCiAjaW5jbHVkZSAiQ29uc29sZS5oIgogI2luY2x1ZGUgIkNvb2tpZUph ci5oIgpAQCAtMTM3LDExICsxMzgsNiBAQAogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAj aW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCi0jaWYgRU5BQkxFKERBVEFCQVNFKQotI2lu Y2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKLSNlbmRpZgot CiAjaWYgRU5BQkxFKFNIQVJFRF9XT1JLRVJTKQogI2luY2x1ZGUgIlNoYXJlZFdvcmtlclJlcG9z aXRvcnkuaCIKICNlbmRpZgpAQCAtMzUwLDkgKzM0Niw2IEBAIERvY3VtZW50OjpEb2N1bWVudChG cmFtZSogZnJhbWUsIGJvb2wgaXMKICAgICAsIG1fdXNlU2VjdXJlS2V5Ym9hcmRFbnRyeVdoZW5B Y3RpdmUoZmFsc2UpCiAgICAgLCBtX2lzWEhUTUwoaXNYSFRNTCkKICAgICAsIG1fbnVtTm9kZUxp c3RDYWNoZXMoMCkKLSNpZiBFTkFCTEUoREFUQUJBU0UpCi0gICAgLCBtX2hhc09wZW5EYXRhYmFz ZXMoZmFsc2UpCi0jZW5kaWYKICAgICAsIG1fdXNpbmdHZW9sb2NhdGlvbihmYWxzZSkKICNpZiBF TkFCTEUoV01MKQogICAgICwgbV9jb250YWluc1dNTENvbnRlbnQoZmFsc2UpCkBAIC01MDAsMTMg KzQ5Myw2IEBAIERvY3VtZW50Ojp+RG9jdW1lbnQoKQogICAgIGZvciAodW5zaWduZWQgaSA9IDA7 IGkgPCBjb3VudDsgaSsrKQogICAgICAgICBkZWxldGVBbGxWYWx1ZXMobV9uYW1lQ29sbGVjdGlv bkluZm9baV0pOwogCi0jaWYgRU5BQkxFKERBVEFCQVNFKQotICAgIGlmIChtX2RhdGFiYXNlVGhy ZWFkKSB7Ci0gICAgICAgIEFTU0VSVChtX2RhdGFiYXNlVGhyZWFkLT50ZXJtaW5hdGlvblJlcXVl c3RlZCgpKTsKLSAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IDA7Ci0gICAgfQotI2VuZGlmCi0K ICAgICBpZiAobV9zdHlsZVNoZWV0cykKICAgICAgICAgbV9zdHlsZVNoZWV0cy0+ZG9jdW1lbnRE ZXN0cm95ZWQoKTsKIH0KQEAgLTQzOTQsNiArNDM4MCwyOSBAQCB2b2lkIERvY3VtZW50OjpzZXRT ZWN1cml0eU9yaWdpbihTZWN1cml0CiAgICAgaW5pdEROU1ByZWZldGNoKCk7CiB9CiAKKyNpZiBF TkFCTEUoREFUQUJBU0UpCisKK2Jvb2wgRG9jdW1lbnQ6OmlzRGF0YWJhc2VSZWFkT25seSgpIGNv bnN0Cit7CisgICAgaWYgKCFwYWdlKCkgfHwgcGFnZSgpLT5zZXR0aW5ncygpLT5wcml2YXRlQnJv d3NpbmdFbmFibGVkKCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIHJldHVybiBmYWxzZTsK K30KKwordm9pZCBEb2N1bWVudDo6ZGF0YWJhc2VFeGNlZWRlZFF1b3RhKGNvbnN0IFN0cmluZyYg bmFtZSkKK3sKKyAgICBQYWdlKiBjdXJyZW50UGFnZSA9IHBhZ2UoKTsKKyAgICBpZiAoY3VycmVu dFBhZ2UpCisgICAgICAgIGN1cnJlbnRQYWdlLT5jaHJvbWUoKS0+Y2xpZW50KCktPmV4Y2VlZGVk RGF0YWJhc2VRdW90YShkb2N1bWVudCgpLT5mcmFtZSgpLCBuYW1lKTsKK30KKworI2VuZGlmCisK K2Jvb2wgRG9jdW1lbnQ6OmlzQ29udGV4dFRocmVhZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIFdU Rjo6aXNNYWluVGhyZWFkKCk7Cit9CisKIHZvaWQgRG9jdW1lbnQ6OnVwZGF0ZVVSTEZvclB1c2hP clJlcGxhY2VTdGF0ZShjb25zdCBLVVJMJiB1cmwpCiB7CiAgICAgRnJhbWUqIGYgPSBmcmFtZSgp OwpAQCAtNDQ5NCw1NyArNDUwMyw2IEBAIERPTVNlbGVjdGlvbiogRG9jdW1lbnQ6OmdldFNlbGVj dGlvbigpIGMKICAgICByZXR1cm4gZnJhbWUoKSA/IGZyYW1lKCktPmRvbVdpbmRvdygpLT5nZXRT ZWxlY3Rpb24oKSA6IDA7CiB9CiAKLSNpZiBFTkFCTEUoREFUQUJBU0UpCi0KLXZvaWQgRG9jdW1l bnQ6OmFkZE9wZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgaWYgKCFtX29w ZW5EYXRhYmFzZVNldCkKLSAgICAgICAgbV9vcGVuRGF0YWJhc2VTZXQuc2V0KG5ldyBEYXRhYmFz ZVNldCk7Ci0KLSAgICBBU1NFUlQoIW1fb3BlbkRhdGFiYXNlU2V0LT5jb250YWlucyhkYXRhYmFz ZSkpOwotICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5hZGQoZGF0YWJhc2UpOwotfQotCi12b2lkIERv Y3VtZW50OjpyZW1vdmVPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIEFT U0VSVChtX29wZW5EYXRhYmFzZVNldCAmJiBtX29wZW5EYXRhYmFzZVNldC0+Y29udGFpbnMoZGF0 YWJhc2UpKTsKLSAgICBpZiAoIW1fb3BlbkRhdGFiYXNlU2V0KQotICAgICAgICByZXR1cm47Ci0g ICAgICAgIAotICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5yZW1vdmUoZGF0YWJhc2UpOwotfQotCi1E YXRhYmFzZVRocmVhZCogRG9jdW1lbnQ6OmRhdGFiYXNlVGhyZWFkKCkKLXsKLSAgICBpZiAoIW1f ZGF0YWJhc2VUaHJlYWQgJiYgIW1faGFzT3BlbkRhdGFiYXNlcykgewotICAgICAgICAvLyBDcmVh dGUgdGhlIGRhdGFiYXNlIHRocmVhZCBvbiBmaXJzdCByZXF1ZXN0IC0gYnV0IG5vdCBpZiBhdCBs ZWFzdCBvbmUgZGF0YWJhc2Ugd2FzIGFscmVhZHkgb3BlbmVkLAotICAgICAgICAvLyBiZWNhdXNl IGluIHRoYXQgY2FzZSB3ZSBhbHJlYWR5IGhhZCBhIGRhdGFiYXNlIHRocmVhZCBhbmQgdGVybWlu YXRlZCBpdCBhbmQgc2hvdWxkIG5vdCBjcmVhdGUgYW5vdGhlci4KLSAgICAgICAgbV9kYXRhYmFz ZVRocmVhZCA9IERhdGFiYXNlVGhyZWFkOjpjcmVhdGUoKTsKLSAgICAgICAgaWYgKCFtX2RhdGFi YXNlVGhyZWFkLT5zdGFydCgpKQotICAgICAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IDA7Ci0g ICAgfQotCi0gICAgcmV0dXJuIG1fZGF0YWJhc2VUaHJlYWQuZ2V0KCk7Ci19Ci0KLXZvaWQgRG9j dW1lbnQ6OnN0b3BEYXRhYmFzZXMoKQotewotICAgIGlmIChtX29wZW5EYXRhYmFzZVNldCkgewot ICAgICAgICBEYXRhYmFzZVNldDo6aXRlcmF0b3IgaSA9IG1fb3BlbkRhdGFiYXNlU2V0LT5iZWdp bigpOwotICAgICAgICBEYXRhYmFzZVNldDo6aXRlcmF0b3IgZW5kID0gbV9vcGVuRGF0YWJhc2VT ZXQtPmVuZCgpOwotICAgICAgICBmb3IgKDsgaSAhPSBlbmQ7ICsraSkgewotICAgICAgICAgICAg KCppKS0+c3RvcCgpOwotICAgICAgICAgICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpCi0gICAgICAg ICAgICAgICAgbV9kYXRhYmFzZVRocmVhZC0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3MoKmkpOwot ICAgICAgICB9Ci0gICAgfQotICAgIAotICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKQotICAgICAg ICBtX2RhdGFiYXNlVGhyZWFkLT5yZXF1ZXN0VGVybWluYXRpb24oKTsKLX0KLQotI2VuZGlmCi0K ICNpZiBFTkFCTEUoV01MKQogdm9pZCBEb2N1bWVudDo6cmVzZXRXTUxQYWdlU3RhdGUoKQogewpJ bmRleDogV2ViQ29yZS9kb20vRG9jdW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9E b2N1bWVudC5oCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvZG9tL0RvY3VtZW50LmgJKHdv cmtpbmcgY29weSkKQEAgLTkxNCwxNCArOTE0LDEyIEBAIHB1YmxpYzoKICAgICBib29sIHByb2Nl c3NpbmdMb2FkRXZlbnQoKSBjb25zdCB7IHJldHVybiBtX3Byb2Nlc3NpbmdMb2FkRXZlbnQ7IH0K IAogI2lmIEVOQUJMRShEQVRBQkFTRSkKLSAgICB2b2lkIGFkZE9wZW5EYXRhYmFzZShEYXRhYmFz ZSopOwotICAgIHZvaWQgcmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKik7Ci0gICAgRGF0YWJh c2VUaHJlYWQqIGRhdGFiYXNlVGhyZWFkKCk7ICAgLy8gQ3JlYXRlcyB0aGUgdGhyZWFkIGFzIG5l ZWRlZCwgYnV0IG5vdCBpZiBpdCBoYXMgYmVlbiBhbHJlYWR5IHRlcm1pbmF0ZWQuCi0gICAgdm9p ZCBzZXRIYXNPcGVuRGF0YWJhc2VzKCkgeyBtX2hhc09wZW5EYXRhYmFzZXMgPSB0cnVlOyB9Ci0g ICAgYm9vbCBoYXNPcGVuRGF0YWJhc2VzKCkgeyByZXR1cm4gbV9oYXNPcGVuRGF0YWJhc2VzOyB9 Ci0gICAgdm9pZCBzdG9wRGF0YWJhc2VzKCk7CisgICAgdmlydHVhbCBib29sIGlzRGF0YWJhc2VS ZWFkT25seSgpIGNvbnN0OworICAgIHZpcnR1YWwgdm9pZCBkYXRhYmFzZUV4Y2VlZGVkUXVvdGEo Y29uc3QgU3RyaW5nJiBuYW1lKTsKICNlbmRpZgogCisgICAgdmlydHVhbCBib29sIGlzQ29udGV4 dFRocmVhZCgpIGNvbnN0OworCiAgICAgdm9pZCBzZXRVc2luZ0dlb2xvY2F0aW9uKGJvb2wgZikg eyBtX3VzaW5nR2VvbG9jYXRpb24gPSBmOyB9CiAgICAgYm9vbCB1c2luZ0dlb2xvY2F0aW9uKCkg Y29uc3QgeyByZXR1cm4gbV91c2luZ0dlb2xvY2F0aW9uOyB9OwogCkBAIC0xMTgzLDEzICsxMTgx LDYgQEAgcHJpdmF0ZToKICAgICBKU1dyYXBwZXJDYWNoZU1hcCBtX3dyYXBwZXJDYWNoZU1hcDsK ICNlbmRpZgogCi0jaWYgRU5BQkxFKERBVEFCQVNFKQotICAgIFJlZlB0cjxEYXRhYmFzZVRocmVh ZD4gbV9kYXRhYmFzZVRocmVhZDsKLSAgICBib29sIG1faGFzT3BlbkRhdGFiYXNlczsgICAgLy8g VGhpcyBuZXZlciBjaGFuZ2VzIGJhY2sgdG8gZmFsc2UsIGV2ZW4gYXMgdGhlIGRhdGFiYXNlIHRo cmVhZCBpcyBjbG9zZWQuCi0gICAgdHlwZWRlZiBIYXNoU2V0PERhdGFiYXNlKj4gRGF0YWJhc2VT ZXQ7Ci0gICAgT3duUHRyPERhdGFiYXNlU2V0PiBtX29wZW5EYXRhYmFzZVNldDsKLSNlbmRpZgot ICAgIAogICAgIGJvb2wgbV91c2luZ0dlb2xvY2F0aW9uOwogCiAjaWYgRU5BQkxFKFdNTCkKSW5k ZXg6IFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCShyZXZpc2lvbiA1Mjk5NSkK KysrIFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCSh3b3JraW5nIGNvcHkp CkBAIC0yOCw3ICsyOCw4IEBACiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgog CiAjaW5jbHVkZSAiQWN0aXZlRE9NT2JqZWN0LmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKKyNp bmNsdWRlICJEYXRhYmFzZVRhc2suaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRocmVhZC5oIgogI2lu Y2x1ZGUgIk1lc3NhZ2VQb3J0LmgiCiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKICNpbmNs dWRlICJXb3JrZXJDb250ZXh0LmgiCkBAIC01Niw2ICs1Nyw5IEBAIHB1YmxpYzoKIH07CiAKIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKQorI2lmIEVOQUJM RShEQVRBQkFTRSkKKyAgICA6IG1faGFzT3BlbkRhdGFiYXNlcyhmYWxzZSkKKyNlbmRpZgogewog fQogCkBAIC03Miw4ICs3Niw2NCBAQCBTY3JpcHRFeGVjdXRpb25Db250ZXh0Ojp+U2NyaXB0RXhl Y3V0aW9uCiAgICAgICAgIEFTU0VSVCgoKml0ZXIpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCkg PT0gdGhpcyk7CiAgICAgICAgICgqaXRlciktPmNvbnRleHREZXN0cm95ZWQoKTsKICAgICB9Cisg ICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpIHsKKyAgICAgICAgQVNTRVJUKG1fZGF0YWJhc2VUaHJl YWQtPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpOworICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0g MDsKKyAgICB9CiB9CiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisKK0RhdGFiYXNlVGhyZWFkKiBT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpkYXRhYmFzZVRocmVhZCgpCit7CisgICAgaWYgKCFtX2Rh dGFiYXNlVGhyZWFkICYmICFtX2hhc09wZW5EYXRhYmFzZXMpIHsKKyAgICAgICAgLy8gQ3JlYXRl IHRoZSBkYXRhYmFzZSB0aHJlYWQgb24gZmlyc3QgcmVxdWVzdCAtIGJ1dCBub3QgaWYgYXQgbGVh c3Qgb25lIGRhdGFiYXNlIHdhcyBhbHJlYWR5IG9wZW5lZCwKKyAgICAgICAgLy8gYmVjYXVzZSBp biB0aGF0IGNhc2Ugd2UgYWxyZWFkeSBoYWQgYSBkYXRhYmFzZSB0aHJlYWQgYW5kIHRlcm1pbmF0 ZWQgaXQgYW5kIHNob3VsZCBub3QgY3JlYXRlIGFub3RoZXIuCisgICAgICAgIG1fZGF0YWJhc2VU aHJlYWQgPSBEYXRhYmFzZVRocmVhZDo6Y3JlYXRlKCk7CisgICAgICAgIGlmICghbV9kYXRhYmFz ZVRocmVhZC0+c3RhcnQoKSkKKyAgICAgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQgPSAwOworICAg IH0KKworICAgIHJldHVybiBtX2RhdGFiYXNlVGhyZWFkLmdldCgpOworfQorCit2b2lkIFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQ6OmFkZE9wZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCit7 CisgICAgaWYgKCFtX29wZW5EYXRhYmFzZVNldCkKKyAgICAgICAgbV9vcGVuRGF0YWJhc2VTZXQu c2V0KG5ldyBEYXRhYmFzZVNldCgpKTsKKworICAgIEFTU0VSVCghbV9vcGVuRGF0YWJhc2VTZXQt PmNvbnRhaW5zKGRhdGFiYXNlKSk7CisgICAgbV9vcGVuRGF0YWJhc2VTZXQtPmFkZChkYXRhYmFz ZSk7Cit9CisKK3ZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6cmVtb3ZlT3BlbkRhdGFiYXNl KERhdGFiYXNlKiBkYXRhYmFzZSkKK3sKKyAgICBBU1NFUlQobV9vcGVuRGF0YWJhc2VTZXQgJiYg bV9vcGVuRGF0YWJhc2VTZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7CisgICAgaWYgKCFtX29wZW5E YXRhYmFzZVNldCkKKyAgICAgICAgcmV0dXJuOworICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5yZW1v dmUoZGF0YWJhc2UpOworfQorCit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnN0b3BEYXRh YmFzZXMoRGF0YWJhc2VUYXNrU3luY2hyb25pemVyICpjbGVhbnVwU3luYykKK3sKKyAgICBpZiAo bV9vcGVuRGF0YWJhc2VTZXQpIHsKKyAgICAgICAgRGF0YWJhc2VTZXQ6Oml0ZXJhdG9yIGkgPSBt X29wZW5EYXRhYmFzZVNldC0+YmVnaW4oKTsKKyAgICAgICAgRGF0YWJhc2VTZXQ6Oml0ZXJhdG9y IGVuZCA9IG1fb3BlbkRhdGFiYXNlU2V0LT5lbmQoKTsKKyAgICAgICAgZm9yICg7IGkgIT0gZW5k OyArK2kpIHsKKyAgICAgICAgICAgICgqaSktPnN0b3AoKTsKKyAgICAgICAgICAgIGlmIChtX2Rh dGFiYXNlVGhyZWFkKQorICAgICAgICAgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQtPnVuc2NoZWR1 bGVEYXRhYmFzZVRhc2tzKCppKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICBpZiAobV9k YXRhYmFzZVRocmVhZCkKKyAgICAgICAgbV9kYXRhYmFzZVRocmVhZC0+cmVxdWVzdFRlcm1pbmF0 aW9uKGNsZWFudXBTeW5jKTsKKyAgICBlbHNlIGlmIChjbGVhbnVwU3luYykKKyAgICAgICAgY2xl YW51cFN5bmMtPnRhc2tDb21wbGV0ZWQoKTsKK30KKworI2VuZGlmCisKIHZvaWQgU2NyaXB0RXhl Y3V0aW9uQ29udGV4dDo6cHJvY2Vzc01lc3NhZ2VQb3J0TWVzc2FnZXNTb29uKCkKIHsKICAgICBw b3N0VGFzayhQcm9jZXNzTWVzc2FnZXNTb29uVGFzazo6Y3JlYXRlKCkpOwpJbmRleDogV2ViQ29y ZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9t L1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL2Rv bS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgJKHdvcmtpbmcgY29weSkKQEAgLTMzLDExICszMywx NyBAQAogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIu aD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4K ICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAg IGNsYXNzIEFjdGl2ZURPTU9iamVjdDsKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisgICAgY2xhc3Mg RGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyOworICAgIGNsYXNz IERhdGFiYXNlVGhyZWFkOworI2VuZGlmCiAgICAgY2xhc3MgRE9NVGltZXI7CiAgICAgY2xhc3Mg TWVzc2FnZVBvcnQ7CiAgICAgY2xhc3MgU2VjdXJpdHlPcmlnaW47CkBAIC01OSw2ICs2NSwxOSBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgYm9vbCBpc0RvY3VtZW50KCkg Y29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICAgICAgdmlydHVhbCBib29sIGlzV29ya2VyQ29u dGV4dCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisg ICAgICAgIHZpcnR1YWwgYm9vbCBpc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdCA9IDA7CisgICAg ICAgIHZpcnR1YWwgdm9pZCBkYXRhYmFzZUV4Y2VlZGVkUXVvdGEoY29uc3QgU3RyaW5nJiBuYW1l KSA9IDA7CisgICAgICAgIERhdGFiYXNlVGhyZWFkICpkYXRhYmFzZVRocmVhZCgpOworICAgICAg ICB2b2lkIHNldEhhc09wZW5EYXRhYmFzZXMoKSB7IG1faGFzT3BlbkRhdGFiYXNlcyA9IHRydWU7 IH0KKyAgICAgICAgYm9vbCBoYXNPcGVuRGF0YWJhc2VzKCkgY29uc3QgeyByZXR1cm4gbV9oYXNP cGVuRGF0YWJhc2VzOyB9CisgICAgICAgIHZvaWQgYWRkT3BlbkRhdGFiYXNlKERhdGFiYXNlKik7 CisgICAgICAgIHZvaWQgcmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKik7CisgICAgICAgIC8v IFdoZW4gdGhlIGRhdGFiYXNlIGNsZWFudXAgaXMgZG9uZSwgY2xlYW51cFN5bmMgd2lsbCBiZSBz aWduYWxsZWQuCisgICAgICAgIHZvaWQgc3RvcERhdGFiYXNlcyhEYXRhYmFzZVRhc2tTeW5jaHJv bml6ZXIqKTsKKyNlbmRpZgorICAgICAgICB2aXJ0dWFsIGJvb2wgaXNDb250ZXh0VGhyZWFkKCkg Y29uc3QgPSAwOworCiAgICAgICAgIGNvbnN0IEtVUkwmIHVybCgpIGNvbnN0IHsgcmV0dXJuIHZp cnR1YWxVUkwoKTsgfQogICAgICAgICBLVVJMIGNvbXBsZXRlVVJMKGNvbnN0IFN0cmluZyYgdXJs KSBjb25zdCB7IHJldHVybiB2aXJ0dWFsQ29tcGxldGVVUkwodXJsKTsgfQogCkBAIC05Nyw2ICsx MTYsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHB1YmxpYzoKICAgICAgICAgICAg IHZpcnR1YWwgflRhc2soKTsKICAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhT Y3JpcHRFeGVjdXRpb25Db250ZXh0KikgPSAwOworICAgICAgICAgICAgLy8gQ2VydGFpbiB0YXNr cyBnZXQgbWFya2VkIHNwZWNpYWxseSBzbyB0aGF0IHRoZXkgYXJlbid0IGRpc2NhcmRlZCwgYW5k IGFyZSBleGVjdXRlZCwgd2hlbiB0aGUgY29udGV4dCBpcyBzaHV0dGluZyBkb3duIGl0cyBtZXNz YWdlIHF1ZXVlLgorICAgICAgICAgICAgdmlydHVhbCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25z dCB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICB9OwogCiAgICAgICAgIHZpcnR1YWwgdm9pZCBw b3N0VGFzayhQYXNzT3duUHRyPFRhc2s+KSA9IDA7IC8vIEV4ZWN1dGVzIHRoZSB0YXNrIG9uIGNv bnRleHQncyB0aHJlYWQgYXN5bmNocm9ub3VzbHkuCkBAIC0xMjksNiArMTUwLDEzIEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQgcmVmU2NyaXB0RXhlY3V0aW9u Q29udGV4dCgpID0gMDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRlcmVmU2NyaXB0RXhlY3V0aW9u Q29udGV4dCgpID0gMDsKKworI2lmIEVOQUJMRShEQVRBQkFTRSkKKyAgICAgICAgUmVmUHRyPERh dGFiYXNlVGhyZWFkPiBtX2RhdGFiYXNlVGhyZWFkOworICAgICAgICBib29sIG1faGFzT3BlbkRh dGFiYXNlczsgLy8gVGhpcyBuZXZlciBjaGFuZ2VzIGJhY2sgdG8gZmFsc2UsIGV2ZW4gYWZ0ZXIg dGhlIGRhdGFiYXNlIHRocmVhZCBpcyBjbG9zZWQuCisgICAgICAgIHR5cGVkZWYgSGFzaFNldDxE YXRhYmFzZSAqPiBEYXRhYmFzZVNldDsKKyAgICAgICAgT3duUHRyPERhdGFiYXNlU2V0PiBtX29w ZW5EYXRhYmFzZVNldDsKKyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK SW5kZXg6IFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NTksNyArNTU5LDcgQEAg dm9pZCBGcmFtZUxvYWRlcjo6c3RvcExvYWRpbmcoVW5sb2FkRXZlbgogCiAjaWYgRU5BQkxFKERB VEFCQVNFKQogICAgICAgICBpZiAoZGF0YWJhc2VQb2xpY3kgPT0gRGF0YWJhc2VQb2xpY3lTdG9w KQotICAgICAgICAgICAgZG9jLT5zdG9wRGF0YWJhc2VzKCk7CisgICAgICAgICAgICBkb2MtPnN0 b3BEYXRhYmFzZXMoMCk7CiAjZWxzZQogICAgIFVOVVNFRF9QQVJBTShkYXRhYmFzZVBvbGljeSk7 CiAjZW5kaWYKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJD b3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01Myw4ICs1Myw4IEBA CiAjaW5jbHVkZSAiU1FMUmVzdWx0U2V0LmgiCiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb25DbGll bnQuaCIKICNpbmNsdWRlICJTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCi0jaW5jbHVkZSA8 d3RmL01haW5UaHJlYWQuaD4KLSNlbmRpZgorCisjZW5kaWYgLy8gRU5BQkxFKERBVEFCQVNFKQog CiAjaWYgVVNFKEpTQykKICNpbmNsdWRlICJKU0RPTVdpbmRvdy5oIgpAQCAtNzMsNiArNzMsMTgg QEAgY29uc3QgU3RyaW5nJiBEYXRhYmFzZTo6ZGF0YWJhc2VJbmZvVGFibAogCiAjaWYgRU5BQkxF KERBVEFCQVNFKQogCitzdGF0aWMgYm9vbCBpc0RhdGFiYXNlQXZhaWxhYmxlID0gZmFsc2U7CisK K3ZvaWQgRGF0YWJhc2U6OnNldElzQXZhaWxhYmxlKGJvb2wgYXZhaWxhYmxlKQoreworICAgIGlz RGF0YWJhc2VBdmFpbGFibGUgPSBhdmFpbGFibGU7Cit9CisKK2Jvb2wgRGF0YWJhc2U6OmlzQXZh aWxhYmxlKCkKK3sKKyAgICByZXR1cm4gaXNEYXRhYmFzZUF2YWlsYWJsZTsKK30KKwogc3RhdGlj IE11dGV4JiBndWlkTXV0ZXgoKQogewogICAgIC8vIE5vdGU6IFdlIGRvbid0IGhhdmUgdG8gdXNl IEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyBoZXJlIGJlY2F1c2UKQEAgLTEyMCwzOSArMTMy LDQxIEBAIHN0YXRpYyBjb25zdCBTdHJpbmcmIGRhdGFiYXNlVmVyc2lvbktleSgKIAogc3RhdGlj IGludCBndWlkRm9yT3JpZ2luQW5kTmFtZShjb25zdCBTdHJpbmcmIG9yaWdpbiwgY29uc3QgU3Ry aW5nJiBuYW1lKTsKIAotUGFzc1JlZlB0cjxEYXRhYmFzZT4gRGF0YWJhc2U6Om9wZW5EYXRhYmFz ZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBl eHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZSkKK1Bhc3NSZWZQdHI8RGF0YWJhc2U+IERh dGFiYXNlOjpvcGVuRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCwgY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3Ry aW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNlcHRpb25D b2RlJiBlKQogewotICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0YWJs aXNoRGF0YWJhc2UoZG9jdW1lbnQsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKSkg eworICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0YWJsaXNoRGF0YWJh c2UoY29udGV4dCwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKSB7CiAgICAgICAg IC8vIEZJWE1FOiBUaGVyZSBzaG91bGQgYmUgYW4gZXhjZXB0aW9uIHJhaXNlZCBoZXJlIGluIGFk ZGl0aW9uIHRvIHJldHVybmluZyBhIG51bGwgRGF0YWJhc2Ugb2JqZWN0LiAgVGhlIHF1ZXN0aW9u IGhhcyBiZWVuIHJhaXNlZCB3aXRoIHRoZSBXSEFUV0cuCi0gICAgICAgIExPRyhTdG9yYWdlQVBJ LCAiRGF0YWJhc2UgJXMgZm9yIG9yaWdpbiAlcyBub3QgYWxsb3dlZCB0byBiZSBlc3RhYmxpc2hl ZCIsIG5hbWUuYXNjaWkoKS5kYXRhKCksIGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT50b1N0 cmluZygpLmFzY2lpKCkuZGF0YSgpKTsKKyAgICAgICAgTE9HKFN0b3JhZ2VBUEksICJEYXRhYmFz ZSAlcyBmb3Igb3JpZ2luICVzIG5vdCBhbGxvd2VkIHRvIGJlIGVzdGFibGlzaGVkIiwgbmFtZS5h c2NpaSgpLmRhdGEoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKS5hc2Np aSgpLmRhdGEoKSk7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIFJlZlB0cjxEYXRh YmFzZT4gZGF0YWJhc2UgPSBhZG9wdFJlZihuZXcgRGF0YWJhc2UoZG9jdW1lbnQsIG5hbWUsIGV4 cGVjdGVkVmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKKyAgICBSZWZQdHI8 RGF0YWJhc2U+IGRhdGFiYXNlID0gYWRvcHRSZWYobmV3IERhdGFiYXNlKGNvbnRleHQsIG5hbWUs IGV4cGVjdGVkVmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKIAogICAgIGlm ICghZGF0YWJhc2UtPm9wZW5BbmRWZXJpZnlWZXJzaW9uKGUpKSB7CiAgICAgICAgIExPRyhTdG9y YWdlQVBJLCAiRmFpbGVkIHRvIG9wZW4gYW5kIHZlcmlmeSB2ZXJzaW9uIChleHBlY3RlZCAlcykg b2YgZGF0YWJhc2UgJXMiLCBleHBlY3RlZFZlcnNpb24uYXNjaWkoKS5kYXRhKCksIGRhdGFiYXNl LT5kYXRhYmFzZURlYnVnTmFtZSgpLmFzY2lpKCkuZGF0YSgpKTsKLSAgICAgICAgZG9jdW1lbnQt PnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CisgICAgICAgIGNvbnRleHQtPnJl bW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAgIERhdGFiYXNlVHJhY2tl cjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAg IHJldHVybiAwOwogICAgIH0KIAotICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnNldERh dGFiYXNlRGV0YWlscyhkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5h bWUsIGVzdGltYXRlZFNpemUpOwotCi0gICAgZG9jdW1lbnQtPnNldEhhc09wZW5EYXRhYmFzZXMo KTsKKyAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5zZXREYXRhYmFzZURldGFpbHMoY29u dGV4dC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUp OwogCisgICAgY29udGV4dC0+c2V0SGFzT3BlbkRhdGFiYXNlcygpOwogI2lmIEVOQUJMRShJTlNQ RUNUT1IpCi0gICAgaWYgKFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+ZnJhbWUoKS0+cGFnZSgpKQot ICAgICAgICBwYWdlLT5pbnNwZWN0b3JDb250cm9sbGVyKCktPmRpZE9wZW5EYXRhYmFzZShkYXRh YmFzZS5nZXQoKSwgZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmhvc3QoKSwgbmFtZSwgZXhw ZWN0ZWRWZXJzaW9uKTsKKyAgICBpZiAoY29udGV4dC0+aXNEb2N1bWVudCgpKSB7CisgICAgICAg IERvY3VtZW50KiBkb2N1bWVudCA9IHN0YXRpY19jYXN0PERvY3VtZW50Kj4oY29udGV4dCk7Cisg ICAgICAgIGlmIChQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKSkKKyAgICAgICAgICAgIHBh Z2UtPmluc3BlY3RvckNvbnRyb2xsZXIoKS0+ZGlkT3BlbkRhdGFiYXNlKGRhdGFiYXNlLmdldCgp LCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5ob3N0KCksIG5hbWUsIGV4cGVjdGVkVmVyc2lv bik7CisgICAgfQogI2VuZGlmCiAKICAgICByZXR1cm4gZGF0YWJhc2U7CiB9CiAKLURhdGFiYXNl OjpEYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3Qg U3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2ln bmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKK0RhdGFiYXNlOjpEYXRhYmFzZShTY3JpcHRFeGVjdXRp b25Db250ZXh0ICpjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhw ZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVz dGltYXRlZFNpemUpCiAgICAgOiBtX3RyYW5zYWN0aW9uSW5Qcm9ncmVzcyhmYWxzZSkKICAgICAs IG1faXNUcmFuc2FjdGlvblF1ZXVlRW5hYmxlZCh0cnVlKQotICAgICwgbV9kb2N1bWVudChkb2N1 bWVudCkKKyAgICAsIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dChjb250ZXh0KQogICAgICwgbV9u YW1lKG5hbWUuY3Jvc3NUaHJlYWRTdHJpbmcoKSkKICAgICAsIG1fZ3VpZCgwKQogICAgICwgbV9l eHBlY3RlZFZlcnNpb24oZXhwZWN0ZWRWZXJzaW9uLmNyb3NzVGhyZWFkU3RyaW5nKCkpCkBAIC0x NjIsMTYgKzE3NiwxNSBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBj CiAgICAgLCBtX3N0b3BwZWQoZmFsc2UpCiAgICAgLCBtX29wZW5lZChmYWxzZSkKIHsKLSAgICBB U1NFUlQoZG9jdW1lbnQpOwotICAgIG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luID0gZG9jdW1l bnQtPnNlY3VyaXR5T3JpZ2luKCk7CisgICAgQVNTRVJUKG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4 dC5nZXQoKSk7CisgICAgbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4gPSBtX3NjcmlwdEV4ZWN1 dGlvbkNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCk7CiAgICAgbV9kYXRhYmFzZVRocmVhZFNlY3Vy aXR5T3JpZ2luID0gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4tPnRocmVhZHNhZmVDb3B5KCk7 Ci0KICAgICBpZiAobV9uYW1lLmlzTnVsbCgpKQogICAgICAgICBtX25hbWUgPSAiIjsKIAogICAg IFNjcmlwdENvbnRyb2xsZXI6OmluaXRpYWxpemVUaHJlYWRpbmcoKTsKIAotICAgIG1fZ3VpZCA9 IGd1aWRGb3JPcmlnaW5BbmROYW1lKG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLT50b1N0cmlu ZygpLCBuYW1lKTsKKyAgICBtX2d1aWQgPSBndWlkRm9yT3JpZ2luQW5kTmFtZShzZWN1cml0eU9y aWdpbigpLT50b1N0cmluZygpLCBuYW1lKTsKIAogICAgIHsKICAgICAgICAgTXV0ZXhMb2NrZXIg bG9ja2VyKGd1aWRNdXRleCgpKTsKQEAgLTE4NSwyOCArMTk4LDQ2IEBAIERhdGFiYXNlOjpEYXRh YmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGMKICAgICAgICAgaGFzaFNldC0+YWRkKHRoaXMpOwog ICAgIH0KIAotICAgIEFTU0VSVChtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKTsKLQotICAg IG1fZmlsZW5hbWUgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxsUGF0aEZvckRhdGFi YXNlKG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLmdldCgpLCBtX25hbWUpOworICAgIEFTU0VS VChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpOworICAgIG1fZmls ZW5hbWUgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxsUGF0aEZvckRhdGFiYXNlKHNl Y3VyaXR5T3JpZ2luKCksIG1fbmFtZSk7CiAKICAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIo KS5hZGRPcGVuRGF0YWJhc2UodGhpcyk7Ci0gICAgbV9kb2N1bWVudC0+YWRkT3BlbkRhdGFiYXNl KHRoaXMpOworICAgIGNvbnRleHQtPmFkZE9wZW5EYXRhYmFzZSh0aGlzKTsKIH0KIAotc3RhdGlj IHZvaWQgZGVyZWZEb2N1bWVudCh2b2lkKiBkb2N1bWVudCkKLXsKLSAgICBzdGF0aWNfY2FzdDxE b2N1bWVudCo+KGRvY3VtZW50KS0+ZGVyZWYoKTsKLX0KK2NsYXNzIERlcmVmQ29udGV4dFRhc2sg OiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3Rh dGljIFBhc3NPd25QdHI8RGVyZWZDb250ZXh0VGFzaz4gY3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQgKmNvbnRleHQpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IERlcmVmQ29udGV4dFRh c2soY29udGV4dCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqKQorICAgIHsKKyAgICAgICAgbV9jb250ZXh0LT5kZXJlZigpOwor ICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1cm4g dHJ1ZTsgfQorCitwcml2YXRlOgorICAgIGV4cGxpY2l0IERlcmVmQ29udGV4dFRhc2soU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCkKKyAgICAgICAgOiBtX2NvbnRleHQoY29udGV4dCkK KyAgICB7CisgICAgfQorCisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogbV9jb250ZXh0Owor fTsKIAogRGF0YWJhc2U6On5EYXRhYmFzZSgpCiB7Ci0gICAgLy8gRGVyZWYgbV9kb2N1bWVudCBv biB0aGUgbWFpbiB0aHJlYWQuCi0gICAgY2FsbE9uTWFpblRocmVhZChkZXJlZkRvY3VtZW50LCBt X2RvY3VtZW50LnJlbGVhc2UoKS5yZWxlYXNlUmVmKCkpOworICAgIC8vIFRoZSByZWZlcmVuY2Ug dG8gdGhlIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgbmVlZHMgdG8gYmUgY2xlYXJlZCBvbiB0aGUg SmF2YVNjcmlwdCB0aHJlYWQuICBJZiB3ZSdyZSBvbiB0aGF0IHRocmVhZCBhbHJlYWR5LCB3ZSBj YW4ganVzdCBsZXQgdGhlIFJlZlB0cidzIGRlc3RydWN0aW9uIGRvIHRoZSBkZXJlZmZpbmcuCisg ICAgaWYgKCFtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKQorICAg ICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKERlcmVmQ29udGV4dFRhc2s6 OmNyZWF0ZShtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQucmVsZWFzZSgpLnJlbGVhc2VSZWYoKSkp OwogfQogCiBib29sIERhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbihFeGNlcHRpb25Db2Rl JiBlKQogewotICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAo IW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKICAgICAgICAgcmV0 dXJuIGZhbHNlOwogICAgIG1fZGF0YWJhc2VBdXRob3JpemVyID0gRGF0YWJhc2VBdXRob3JpemVy OjpjcmVhdGUoKTsKIApAQCAtMjE0LDcgKzI0NSw3IEBAIGJvb2wgRGF0YWJhc2U6Om9wZW5BbmRW ZXJpZnlWZXJzaW9uKEV4Y2UKICAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgc3luY2hyb25p emVyOwogICAgIE93blB0cjxEYXRhYmFzZU9wZW5UYXNrPiB0YXNrID0gRGF0YWJhc2VPcGVuVGFz azo6Y3JlYXRlKHRoaXMsICZzeW5jaHJvbml6ZXIsIGUsIHN1Y2Nlc3MpOwogCi0gICAgbV9kb2N1 bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFz ZSgpKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNj aGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CiAgICAgc3luY2hyb25pemVyLndh aXRGb3JUYXNrQ29tcGxldGlvbigpOwogCiAgICAgcmV0dXJuIHN1Y2Nlc3M7CkBAIC0zMDksNDMg KzM0MCw2MiBAQCBib29sIERhdGFiYXNlOjp2ZXJzaW9uTWF0Y2hlc0V4cGVjdGVkKCkgCiAKIHZv aWQgRGF0YWJhc2U6Om1hcmtBc0RlbGV0ZWRBbmRDbG9zZSgpCiB7Ci0gICAgaWYgKG1fZGVsZXRl ZCB8fCAhbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAobV9kZWxldGVkIHx8 ICFtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJl dHVybjsKIAogICAgIExPRyhTdG9yYWdlQVBJLCAiTWFya2luZyAlcyAoJXApIGFzIGRlbGV0ZWQi LCBzdHJpbmdJZGVudGlmaWVyKCkuYXNjaWkoKS5kYXRhKCksIHRoaXMpOwogICAgIG1fZGVsZXRl ZCA9IHRydWU7CiAKLSAgICBpZiAobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+dGVybWlu YXRpb25SZXF1ZXN0ZWQoKSkgeworICAgIGlmIChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRh dGFiYXNlVGhyZWFkKCktPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpIHsKICAgICAgICAgTE9HKFN0 b3JhZ2VBUEksICJEYXRhYmFzZSBoYW5kbGUgJXAgaXMgb24gYSB0ZXJtaW5hdGVkIERhdGFiYXNl VGhyZWFkLCBjYW5ub3QgYmUgbWFya2VkIGZvciBub3JtYWwgY2xvc3VyZVxuIiwgdGhpcyk7CiAg ICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgp LT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNv bnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKHRoaXMpOwog CiAgICAgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyIHN5bmNocm9uaXplcjsKICAgICBPd25QdHI8 RGF0YWJhc2VDbG9zZVRhc2s+IHRhc2sgPSBEYXRhYmFzZUNsb3NlVGFzazo6Y3JlYXRlKHRoaXMs ICZzeW5jaHJvbml6ZXIpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2No ZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlv bkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJl bGVhc2UoKSk7CiAgICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOwogfQog Ci1zdGF0aWMgdm9pZCBkb2N1bWVudFJlbW92ZU9wZW5EYXRhYmFzZSh2b2lkKiBjb250ZXh0KQot ewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Ci0gICAgRGF0YWJhc2UqIGRhdGFiYXNlID0g c3RhdGljX2Nhc3Q8RGF0YWJhc2UqPihjb250ZXh0KTsKLSAgICBkYXRhYmFzZS0+ZG9jdW1lbnQo KS0+cmVtb3ZlT3BlbkRhdGFiYXNlKGRhdGFiYXNlKTsKLSAgICBkYXRhYmFzZS0+ZGVyZWYoKTsK LX0KK2NsYXNzIENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrIDogcHVibGljIFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPENv bnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrPiBjcmVhdGUoRGF0YWJhc2UgKmRhdGFiYXNlKQor ICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzayhk YXRhYmFzZSk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQpCisgICAgeworICAgICAgICBjb250ZXh0LT5yZW1vdmVP cGVuRGF0YWJhc2UobV9kYXRhYmFzZSk7CisgICAgICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tl cigpLnJlbW92ZU9wZW5EYXRhYmFzZShtX2RhdGFiYXNlKTsKKyAgICAgICAgLy8gUmVmZmVkIGlu IERhdGFiYXNlOjpjbG9zZSgpLgorICAgICAgICBtX2RhdGFiYXNlLT5kZXJlZigpOworICAgIH0K KworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsg fQorCitwcml2YXRlOgorICAgIGV4cGxpY2l0IENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNr KERhdGFiYXNlICpkYXRhYmFzZSkgOiBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAgIHsKKyAgICB9 CisKKyAgICBEYXRhYmFzZSogbV9kYXRhYmFzZTsKK307CiAKIHZvaWQgRGF0YWJhc2U6OmNsb3Nl KCkKIHsKICAgICBpZiAoIW1fb3BlbmVkKQogICAgICAgICByZXR1cm47CiAKLSAgICBBU1NFUlQo bV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSk7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQo KSA9PSBkb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBB U1NFUlQobV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpKTsKKyAgICBB U1NFUlQoY3VycmVudFRocmVhZCgpID09IG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJh c2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgbV9zcWxpdGVEYXRhYmFzZS5jbG9zZSgp OwotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnJlY29yZERhdGFiYXNlQ2xvc2Vk KHRoaXMpOworICAgIC8vIE11c3QgcmVmKCkgYmVmb3JlIGNhbGxpbmcgZGF0YWJhc2VUaHJlYWQo KS0+cmVjb3JkRGF0YWJhc2VDbG9zZWQoKS4KKyAgICByZWYoKTsgLy8gZGVyZWYoKSBjYWxsZWQg YnkgQ29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2suCisgICAgbV9zY3JpcHRFeGVjdXRpb25D b250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNsb3NlZCh0aGlzKTsKICAg ICBtX29wZW5lZCA9IGZhbHNlOwogCiAgICAgewpAQCAtMzYyLDExICs0MTIsOCBAQCB2b2lkIERh dGFiYXNlOjpjbG9zZSgpCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBtX2RvY3VtZW50LT5kYXRh YmFzZVRocmVhZCgpLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsKLQotICAgIERhdGFi YXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZSh0aGlzKTsKLSAgICByZWYo KTsgIC8vIGRlcmVmKCkgY2FsbGVkIGluIGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNlKCkKLSAg ICBjYWxsT25NYWluVGhyZWFkKGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNlLCB0aGlzKTsKKyAg ICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVE YXRhYmFzZVRhc2tzKHRoaXMpOworICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+cG9zdFRh c2soQ29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZSh0aGlzKSk7CiB9CiAKIHZv aWQgRGF0YWJhc2U6OnN0b3AoKQpAQCAtNTMyLDggKzU3OSw4IEBAIGJvb2wgRGF0YWJhc2U6OnBl cmZvcm1PcGVuQW5kVmVyaWZ5KEV4Y2UKICAgICAvLyBBbGwgY2hlY2tzIHBhc3NlZCBhbmQgd2Ug c3RpbGwgaGF2ZSBhIGhhbmRsZSB0byB0aGlzIGRhdGFiYXNlIGZpbGUuCiAgICAgLy8gTWFrZSBz dXJlIERhdGFiYXNlVGhyZWFkIGNsb3NlcyBpdCB3aGVuIERhdGFiYXNlVGhyZWFkIGdvZXMgYXdh eS4KICAgICBtX29wZW5lZCA9IHRydWU7Ci0gICAgaWYgKG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhy ZWFkKCkpCi0gICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnJlY29yZERhdGFi YXNlT3Blbih0aGlzKTsKKyAgICBpZiAobV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFz ZVRocmVhZCgpKQorICAgICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhy ZWFkKCktPnJlY29yZERhdGFiYXNlT3Blbih0aGlzKTsKIAogICAgIHJldHVybiB0cnVlOwogfQpA QCAtNTY3LDMyICs2MTQsNTMgQEAgdm9pZCBEYXRhYmFzZTo6c2NoZWR1bGVUcmFuc2FjdGlvbigp CiAgICAgICAgIG1fdHJhbnNhY3Rpb25RdWV1ZS5yZW1vdmVGaXJzdCgpOwogICAgIH0KIAotICAg IGlmICh0cmFuc2FjdGlvbiAmJiBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKSB7CisgICAg aWYgKHRyYW5zYWN0aW9uICYmIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJl YWQoKSkgewogICAgICAgICBPd25QdHI8RGF0YWJhc2VUcmFuc2FjdGlvblRhc2s+IHRhc2sgPSBE YXRhYmFzZVRyYW5zYWN0aW9uVGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uKTsKICAgICAgICAgTE9H KFN0b3JhZ2VBUEksICJTY2hlZHVsaW5nIERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrICVwIGZvciB0 cmFuc2FjdGlvbiAlcFxuIiwgdGFzay5nZXQoKSwgdGFzay0+dHJhbnNhY3Rpb24oKSk7CiAgICAg ICAgIG1fdHJhbnNhY3Rpb25JblByb2dyZXNzID0gdHJ1ZTsKLSAgICAgICAgbV9kb2N1bWVudC0+ ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAgICAg bV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZVRhc2so dGFzay5yZWxlYXNlKCkpOwogICAgIH0gZWxzZQogICAgICAgICBtX3RyYW5zYWN0aW9uSW5Qcm9n cmVzcyA9IGZhbHNlOwogfQogCiB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uU3Rl cChTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24sIGJvb2wgaW1tZWRpYXRlbHkpCiB7Ci0gICAg aWYgKCFtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKQorICAgIGlmICghbV9zY3JpcHRFeGVj dXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpKQogICAgICAgICByZXR1cm47CiAKICAgICBP d25QdHI8RGF0YWJhc2VUcmFuc2FjdGlvblRhc2s+IHRhc2sgPSBEYXRhYmFzZVRyYW5zYWN0aW9u VGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uKTsKICAgICBMT0coU3RvcmFnZUFQSSwgIlNjaGVkdWxp bmcgRGF0YWJhc2VUcmFuc2FjdGlvblRhc2sgJXAgZm9yIHRoZSB0cmFuc2FjdGlvbiBzdGVwXG4i LCB0YXNrLmdldCgpKTsKICAgICBpZiAoaW1tZWRpYXRlbHkpCi0gICAgICAgIG1fZG9jdW1lbnQt PmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7 CisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2No ZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKICAgICBlbHNlCi0gICAgICAgIG1f ZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0YXNrLnJlbGVhc2UoKSk7 CisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2No ZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKIH0KIAorY2xhc3MgRGVsaXZlclBlbmRpbmdDYWxs YmFja1Rhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6 CisgICAgc3RhdGljIFBhc3NPd25QdHI8RGVsaXZlclBlbmRpbmdDYWxsYmFja1Rhc2s+IGNyZWF0 ZShTUUxUcmFuc2FjdGlvbiAqdHJhbnNhY3Rpb24pCisgICAgeworICAgICAgICByZXR1cm4gbmV3 IERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrKHRyYW5zYWN0aW9uKTsKKyAgICB9CisKKyAgICB2 aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopCisgICAgewor ICAgICAgICBtX3RyYW5zYWN0aW9uLT5wZXJmb3JtUGVuZGluZ0NhbGxiYWNrKCk7CisgICAgfQor Citwcml2YXRlOgorICAgIGV4cGxpY2l0IERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrKFBhc3NS ZWZQdHI8U1FMVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKQorICAgICAgICA6IG1fdHJhbnNhY3Rp b24odHJhbnNhY3Rpb24pCisgICAgeworICAgIH0KKworICAgIFJlZlB0cjxTUUxUcmFuc2FjdGlv bj4gbV90cmFuc2FjdGlvbjsKK307CisKIHZvaWQgRGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rp b25DYWxsYmFjayhTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgdHJhbnNhY3Rp b24tPnJlZigpOwotICAgIGNhbGxPbk1haW5UaHJlYWQoZGVsaXZlclBlbmRpbmdDYWxsYmFjaywg dHJhbnNhY3Rpb24pOworICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+cG9zdFRhc2soCisg ICAgICAgIERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrOjpjcmVhdGUodHJhbnNhY3Rpb24pKTsK IH0KIAogVmVjdG9yPFN0cmluZz4gRGF0YWJhc2U6OnBlcmZvcm1HZXRUYWJsZU5hbWVzKCkKQEAg LTYyNiwxMiArNjk0LDEyIEBAIFZlY3RvcjxTdHJpbmc+IERhdGFiYXNlOjpwZXJmb3JtR2V0VGFi bGUKIAogU1FMVHJhbnNhY3Rpb25DbGllbnQqIERhdGFiYXNlOjp0cmFuc2FjdGlvbkNsaWVudCgp IGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnRyYW5z YWN0aW9uQ2xpZW50KCk7CisgICAgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0 YWJhc2VUaHJlYWQoKS0+dHJhbnNhY3Rpb25DbGllbnQoKTsKIH0KIAogU1FMVHJhbnNhY3Rpb25D b29yZGluYXRvciogRGF0YWJhc2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSBjb25zdAogewot ICAgIHJldHVybiBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNvb3Jk aW5hdG9yKCk7CisgICAgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VU aHJlYWQoKS0+dHJhbnNhY3Rpb25Db29yZGluYXRvcigpOwogfQogCiBTdHJpbmcgRGF0YWJhc2U6 OnZlcnNpb24oKSBjb25zdApAQCAtNjQyLDI1ICs3MTAsMTggQEAgU3RyaW5nIERhdGFiYXNlOjp2 ZXJzaW9uKCkgY29uc3QKICAgICByZXR1cm4gZ3VpZFRvVmVyc2lvbk1hcCgpLmdldChtX2d1aWQp LnRocmVhZHNhZmVDb3B5KCk7CiB9CiAKLXZvaWQgRGF0YWJhc2U6OmRlbGl2ZXJQZW5kaW5nQ2Fs bGJhY2sodm9pZCogY29udGV4dCkKLXsKLSAgICBTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24g PSBzdGF0aWNfY2FzdDxTUUxUcmFuc2FjdGlvbio+KGNvbnRleHQpOwotICAgIHRyYW5zYWN0aW9u LT5wZXJmb3JtUGVuZGluZ0NhbGxiYWNrKCk7Ci0gICAgdHJhbnNhY3Rpb24tPmRlcmVmKCk7IC8v IFdhcyByZWYnZCBpbiBzY2hlZHVsZVRyYW5zYWN0aW9uQ2FsbGJhY2soKS4KLX0KLQogVmVjdG9y PFN0cmluZz4gRGF0YWJhc2U6OnRhYmxlTmFtZXMoKQogewogICAgIC8vIEZJWE1FOiBOb3QgdXNp bmcgdGhyZWFkc2FmZUNvcHkgb24gdGhlc2Ugc3RyaW5ncyBsb29rcyBvayBzaW5jZSB0aHJlYWRz IHRha2Ugc3RyaWN0IHR1cm5zCiAgICAgLy8gaW4gZGVhbGluZyB3aXRoIHRoZW0uIEhvd2V2ZXIs IGlmIHRoZSBjb2RlIGNoYW5nZXMsIHRoaXMgbWF5IG5vdCBiZSB0cnVlIGFueW1vcmUuCiAgICAg VmVjdG9yPFN0cmluZz4gcmVzdWx0OwotICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJl YWQoKSkKKyAgICBpZiAoIW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQo KSkKICAgICAgICAgcmV0dXJuIHJlc3VsdDsKIAogICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXpl ciBzeW5jaHJvbml6ZXI7CiAgICAgT3duUHRyPERhdGFiYXNlVGFibGVOYW1lc1Rhc2s+IHRhc2sg PSBEYXRhYmFzZVRhYmxlTmFtZXNUYXNrOjpjcmVhdGUodGhpcywgJnN5bmNocm9uaXplciwgcmVz dWx0KTsKIAotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRp YXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5k YXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOwog ICAgIHN5bmNocm9uaXplci53YWl0Rm9yVGFza0NvbXBsZXRpb24oKTsKIAogICAgIHJldHVybiBy ZXN1bHQ7CkBAIC02NzYsOSArNzM3LDkgQEAgdm9pZCBEYXRhYmFzZTo6c2V0RXhwZWN0ZWRWZXJz aW9uKGNvbnN0IAogCiBTZWN1cml0eU9yaWdpbiogRGF0YWJhc2U6OnNlY3VyaXR5T3JpZ2luKCkg Y29uc3QKIHsKLSAgICBpZiAoaXNNYWluVGhyZWFkKCkpCisgICAgaWYgKHNjcmlwdEV4ZWN1dGlv bkNvbnRleHQoKS0+aXNDb250ZXh0VGhyZWFkKCkpCiAgICAgICAgIHJldHVybiBtX21haW5UaHJl YWRTZWN1cml0eU9yaWdpbi5nZXQoKTsKLSAgICBpZiAoY3VycmVudFRocmVhZCgpID09IGRvY3Vt ZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpCisgICAgaWYgKGN1cnJlbnRU aHJlYWQoKSA9PSBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPmdl dFRocmVhZElEKCkpCiAgICAgICAgIHJldHVybiBtX2RhdGFiYXNlVGhyZWFkU2VjdXJpdHlPcmln aW4uZ2V0KCk7CiAgICAgcmV0dXJuIDA7CiB9CkBAIC03MDYsNiArNzY3LDYgQEAgU3RyaW5nIERh dGFiYXNlOjpmaWxlTmFtZSgpIGNvbnN0CiAgICAgcmV0dXJuIG1fZmlsZW5hbWUudGhyZWFkc2Fm ZUNvcHkoKTsKIH0KIAotI2VuZGlmCisjZW5kaWYgLy8gRU5BQkxFKERBVEFCQVNFKQogCi19Cit9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAkocmV2aXNpb24gNTI5OTUp CisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAkod29ya2luZyBjb3B5KQpAQCAtNTIsNyAr NTIsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIERhdGFiYXNlQXV0aG9yaXplcjsK IGNsYXNzIERhdGFiYXNlVGhyZWFkOwotY2xhc3MgRG9jdW1lbnQ7CitjbGFzcyBTY3JpcHRFeGVj dXRpb25Db250ZXh0OwogY2xhc3MgU1FMUmVzdWx0U2V0OwogY2xhc3MgU1FMVHJhbnNhY3Rpb25D YWxsYmFjazsKIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ2xpZW50OwpAQCAtNjcsMTAgKzY3LDEzIEBA IGNsYXNzIERhdGFiYXNlIDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQKICAgICBmcmllbmQgY2xh c3MgU1FMU3RhdGVtZW50OwogICAgIGZyaWVuZCBjbGFzcyBTUUxUcmFuc2FjdGlvbjsKIHB1Ymxp YzoKKyAgICBzdGF0aWMgdm9pZCBzZXRJc0F2YWlsYWJsZShib29sKTsKKyAgICBzdGF0aWMgYm9v bCBpc0F2YWlsYWJsZSgpOworCiAgICAgfkRhdGFiYXNlKCk7CiAKIC8vIERpcmVjdCBzdXBwb3J0 IGZvciB0aGUgRE9NIEFQSQotICAgIHN0YXRpYyBQYXNzUmVmUHRyPERhdGFiYXNlPiBvcGVuRGF0 YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmlu ZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICBzdGF0aWMgUGFzc1JlZlB0 cjxEYXRhYmFzZT4gb3BlbkRhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQs IGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0 IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0 aW9uQ29kZSYpOwogICAgIFN0cmluZyB2ZXJzaW9uKCkgY29uc3Q7CiAgICAgdm9pZCBjaGFuZ2VW ZXJzaW9uKGNvbnN0IFN0cmluZyYgb2xkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBuZXdWZXJzaW9u LAogICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPFNRTFRyYW5zYWN0aW9uQ2FsbGJh Y2s+IGNhbGxiYWNrLCBQYXNzUmVmUHRyPFNRTFRyYW5zYWN0aW9uRXJyb3JDYWxsYmFjaz4gZXJy b3JDYWxsYmFjaywKQEAgLTg3LDcgKzkwLDcgQEAgcHVibGljOgogCiAgICAgVmVjdG9yPFN0cmlu Zz4gdGFibGVOYW1lcygpOwogCi0gICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3QgeyByZXR1 cm4gbV9kb2N1bWVudC5nZXQoKTsgfQorICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlw dEV4ZWN1dGlvbkNvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQuZ2V0KCk7IH0KICAgICBTZWN1cml0eU9yaWdpbiogc2VjdXJpdHlPcmlnaW4oKSBjb25zdDsK ICAgICBTdHJpbmcgc3RyaW5nSWRlbnRpZmllcigpIGNvbnN0OwogICAgIFN0cmluZyBkaXNwbGF5 TmFtZSgpIGNvbnN0OwpAQCAtMTIzLDggKzEyNiw5IEBAIHB1YmxpYzoKICAgICBTUUxUcmFuc2Fj dGlvbkNvb3JkaW5hdG9yKiB0cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkgY29uc3Q7CiAKIHByaXZh dGU6Ci0gICAgRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUs IGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLAotICAgICAgICAgICAgIGNvbnN0IFN0cmlu ZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisgICAgRGF0YWJh c2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLAor ICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcm IGRpc3BsYXlOYW1lLAorICAgICAgICAgICAgIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7 CiAKICAgICBib29sIG9wZW5BbmRWZXJpZnlWZXJzaW9uKEV4Y2VwdGlvbkNvZGUmKTsKIApAQCAt MTM5LDcgKzE0Myw3IEBAIHByaXZhdGU6CiAKICAgICBzdGF0aWMgdm9pZCBkZWxpdmVyUGVuZGlu Z0NhbGxiYWNrKHZvaWQqKTsKIAotICAgIFJlZlB0cjxEb2N1bWVudD4gbV9kb2N1bWVudDsKKyAg ICBSZWZQdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dD4gbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0 OwogICAgIFJlZlB0cjxTZWN1cml0eU9yaWdpbj4gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW47 CiAgICAgUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBtX2RhdGFiYXNlVGhyZWFkU2VjdXJpdHlPcmln aW47CiAgICAgU3RyaW5nIG1fbmFtZTsKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRh c2suaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUYXNrLmgJKHJldmlz aW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5oCSh3b3JraW5nIGNv cHkpCkBAIC01MCwxNiArNTAsMTUgQEAgY2xhc3MgVmVyc2lvbkNoYW5nZUNhbGxiYWNrOwogLy8g Q2FuIGJlIHVzZWQgdG8gd2FpdCB1bnRpbCBEYXRhYmFzZVRhc2sgaXMgY29tcGxldGVkLgogLy8g SGFzIHRvIGJlIHBhc3NlZCBpbnRvIERhdGFiYXNlVGFzazo6Y3JlYXRlIHRvIGJlIGFzc29jaWF0 ZWQgd2l0aCB0aGUgdGFzay4KIGNsYXNzIERhdGFiYXNlVGFza1N5bmNocm9uaXplciA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7Ci0gICAgZnJpZW5kIGNsYXNzIERhdGFiYXNlVGFzazsKIHB1YmxpYzoK ICAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIoKTsKIAogICAgIC8vIENhbGxlZCBmcm9tIG1h aW4gdGhyZWFkIHRvIHdhaXQgdW50aWwgdGFzayBpcyBjb21wbGV0ZWQuCiAgICAgdm9pZCB3YWl0 Rm9yVGFza0NvbXBsZXRpb24oKTsKIAotcHJpdmF0ZToKICAgICAvLyBDYWxsZWQgYnkgdGhlIHRh c2suCiAgICAgdm9pZCB0YXNrQ29tcGxldGVkKCk7Citwcml2YXRlOgogCiAgICAgYm9vbCBtX3Rh c2tDb21wbGV0ZWQ7CiAgICAgTXV0ZXggbV9zeW5jaHJvbm91c011dGV4OwpJbmRleDogV2ViQ29y ZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3Jh Z2UvRGF0YWJhc2VUaHJlYWQuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRocmVhZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDYgKzQ0LDcgQEAgRGF0 YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKICAgICA6IG1fdGhyZWFkSUQoMCkKICAgICAs IG1fdHJhbnNhY3Rpb25DbGllbnQobmV3IFNRTFRyYW5zYWN0aW9uQ2xpZW50KCkpCiAgICAgLCBt X3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IobmV3IFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSkK KyAgICAsIG1fY2xlYW51cFN5bmMoMCkKIHsKICAgICBtX3NlbGZSZWYgPSB0aGlzOwogfQpAQCAt NTEsNiArNTIsNyBAQCBEYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQogRGF0YWJhc2VU aHJlYWQ6On5EYXRhYmFzZVRocmVhZCgpCiB7CiAgICAgLy8gRklYTUU6IEFueSBjbGVhbnVwIHJl cXVpcmVkIGhlcmU/ICBTaW5jZSB0aGUgdGhyZWFkIGRlbGV0ZXMgaXRzZWxmIGFmdGVyIHJ1bm5p bmcgaXRzIGRldGFjaGVkIGNvdXJzZSwgSSBkb24ndCB0aGluayBzby4gIExldHMgYmUgc3VyZS4K KyAgICBBU1NFUlQodGVybWluYXRpb25SZXF1ZXN0ZWQoKSk7CiB9CiAKIGJvb2wgRGF0YWJhc2VU aHJlYWQ6OnN0YXJ0KCkKQEAgLTY1LDggKzY3LDEwIEBAIGJvb2wgRGF0YWJhc2VUaHJlYWQ6OnN0 YXJ0KCkKICAgICByZXR1cm4gbV90aHJlYWRJRDsKIH0KIAotdm9pZCBEYXRhYmFzZVRocmVhZDo6 cmVxdWVzdFRlcm1pbmF0aW9uKCkKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5h dGlvbihEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgKmNsZWFudXBTeW5jKQogeworICAgIEFTU0VS VCghbV9jbGVhbnVwU3luYyk7CisgICAgbV9jbGVhbnVwU3luYyA9IGNsZWFudXBTeW5jOwogICAg IExPRyhTdG9yYWdlQVBJLCAiRGF0YWJhc2VUaHJlYWQgJXAgd2FzIGFza2VkIHRvIHRlcm1pbmF0 ZVxuIiwgdGhpcyk7CiAgICAgbV9xdWV1ZS5raWxsKCk7CiB9CkBAIC0xMTUsOSArMTE5LDE0IEBA IHZvaWQqIERhdGFiYXNlVGhyZWFkOjpkYXRhYmFzZVRocmVhZCgpCiAgICAgLy8gRGV0YWNoIHRo ZSB0aHJlYWQgc28gaXRzIHJlc291cmNlcyBhcmUgbm8gbG9uZ2VyIG9mIGFueSBjb25jZXJuIHRv IGFueW9uZSBlbHNlCiAgICAgZGV0YWNoVGhyZWFkKG1fdGhyZWFkSUQpOwogCisgICAgRGF0YWJh c2VUYXNrU3luY2hyb25pemVyKiBjbGVhbnVwU3luYyA9IG1fY2xlYW51cFN5bmM7CisgICAgCiAg ICAgLy8gQ2xlYXIgdGhlIHNlbGYgcmVmcHRyLCBwb3NzaWJseSByZXN1bHRpbmcgaW4gZGVsZXRp b24KICAgICBtX3NlbGZSZWYgPSAwOwogCisgICAgaWYgKGNsZWFudXBTeW5jKSAvLyBTb21lb25l IHdhbnRlZCB0byBrbm93IHdoZW4gd2Ugd2VyZSBkb25lIGNsZWFuaW5nIHVwLgorICAgICAgICBj bGVhbnVwU3luYy0+dGFza0NvbXBsZXRlZCgpOworCiAgICAgcmV0dXJuIDA7CiB9CiAKQEAgLTE2 Miw2ICsxNzEsNSBAQCB2b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUCiAg ICAgU2FtZURhdGFiYXNlUHJlZGljYXRlIHByZWRpY2F0ZShkYXRhYmFzZSk7CiAgICAgbV9xdWV1 ZS5yZW1vdmVJZihwcmVkaWNhdGUpOwogfQotCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAjZW5k aWYKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdl YkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCSh3b3JraW5nIGNvcHkpCkBAIC00Myw2ICs0 Myw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0YWJhc2U7CiBjbGFzcyBEYXRh YmFzZVRhc2s7CitjbGFzcyBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXI7CiBjbGFzcyBEb2N1bWVu dDsKIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ2xpZW50OwogY2xhc3MgU1FMVHJhbnNhY3Rpb25Db29y ZGluYXRvcjsKQEAgLTUzLDcgKzU0LDcgQEAgcHVibGljOgogICAgIH5EYXRhYmFzZVRocmVhZCgp OwogCiAgICAgYm9vbCBzdGFydCgpOwotICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7Cisg ICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oRGF0YWJhc2VUYXNrU3luY2hyb25pemVyICpjbGVh bnVwU3luYyk7CiAgICAgYm9vbCB0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0OwogCiAgICAg dm9pZCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxEYXRhYmFzZVRhc2s+KTsKQEAgLTg1LDYgKzg2 LDcgQEAgcHJpdmF0ZToKIAogICAgIE93blB0cjxTUUxUcmFuc2FjdGlvbkNsaWVudD4gbV90cmFu c2FjdGlvbkNsaWVudDsKICAgICBPd25QdHI8U1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcj4gbV90 cmFuc2FjdGlvbkNvb3JkaW5hdG9yOworICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciAqbV9j bGVhbnVwU3luYzsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUv c3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRyYWNrZXIuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRyYWNrZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNiwxMCArMzYsMTAgQEAK ICNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCiAjaW5j bHVkZSAiRGF0YWJhc2VUcmFja2VyQ2xpZW50LmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNp bmNsdWRlICJMb2dnaW5nLmgiCiAjaW5jbHVkZSAiT3JpZ2luUXVvdGFNYW5hZ2VyLmgiCiAjaW5j bHVkZSAiUGFnZS5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKICNpbmNs dWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luSGFzaC5oIgog I2luY2x1ZGUgIlNRTGl0ZUZpbGVTeXN0ZW0uaCIKQEAgLTEyMCw3ICsxMjAsNyBAQCB2b2lkIERh dGFiYXNlVHJhY2tlcjo6b3BlblRyYWNrZXJEYXRhYmFzCiAgICAgfQogfQogCi1ib29sIERhdGFi YXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25z dCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSkKK2Jvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFz ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNv bnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKIHsK ICAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IG1fdGhyZWFkKTsKIApAQCAtMTI4LDkgKzEy OCw5IEBAIGJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmEKICAgICAvLyBj YW4gcnVuIG9uIHRoZSBkYXRhYmFzZSB0aHJlYWQgbGF0ZXIuCiAgICAgcG9wdWxhdGVPcmlnaW5z KCk7CiAKLSAgICBTZWN1cml0eU9yaWdpbiogb3JpZ2luID0gZG9jdW1lbnQtPnNlY3VyaXR5T3Jp Z2luKCk7CisgICAgU2VjdXJpdHlPcmlnaW4qIG9yaWdpbiA9IGNvbnRleHQtPnNlY3VyaXR5T3Jp Z2luKCk7CiAKLSAgICAvLyBTaW5jZSB3ZSdyZSBpbW1pbmVudGx5IG9wZW5pbmcgYSBkYXRhYmFz ZSB3aXRoaW4gdGhpcyBEb2N1bWVudCdzIG9yaWdpbiwgbWFrZSBzdXJlIHRoaXMgb3JpZ2luIGlz IGJlaW5nIHRyYWNrZWQgYnkgdGhlIFF1b3RhVHJhY2tlcgorICAgIC8vIFNpbmNlIHdlJ3JlIGlt bWluZW50bHkgb3BlbmluZyBhIGRhdGFiYXNlIHdpdGhpbiB0aGlzIGNvbnRleHQncyBvcmlnaW4s IG1ha2Ugc3VyZSB0aGlzIG9yaWdpbiBpcyBiZWluZyB0cmFja2VkIGJ5IHRoZSBRdW90YVRyYWNr ZXIKICAgICAvLyBieSBmZXRjaGluZyBpdCdzIGN1cnJlbnQgdXNhZ2Ugbm93CiAgICAgdW5zaWdu ZWQgbG9uZyBsb25nIHVzYWdlID0gdXNhZ2VGb3JPcmlnaW4ob3JpZ2luKTsKIApAQCAtMTQ3LDEy ICsxNDcsOSBAQCBib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhCiAKICAg ICAvLyBHaXZlIHRoZSBjaHJvbWUgY2xpZW50IGEgY2hhbmNlIHRvIGluY3JlYXNlIHRoZSBxdW90 YS4KICAgICAvLyBUZW1wb3JhcmlseSBtYWtlIHRoZSBkZXRhaWxzIG9mIHRoZSBwcm9wb3NlZCBk YXRhYmFzZSBhdmFpbGFibGUsIHNvIHRoZSBjbGllbnQgY2FuIGdldCBhdCB0aGVtLgotICAgIFBh Z2UqIHBhZ2UgPSBkb2N1bWVudC0+cGFnZSgpOwotICAgIGlmICghcGFnZSkKLSAgICAgICAgcmV0 dXJuIGZhbHNlOwogICAgIHBhaXI8U2VjdXJpdHlPcmlnaW4qLCBEYXRhYmFzZURldGFpbHM+IGRl dGFpbHMob3JpZ2luLCBEYXRhYmFzZURldGFpbHMobmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRl ZFNpemUsIDApKTsKICAgICBtX3Byb3Bvc2VkRGF0YWJhc2UgPSAmZGV0YWlsczsKLSAgICBwYWdl LT5jaHJvbWUoKS0+Y2xpZW50KCktPmV4Y2VlZGVkRGF0YWJhc2VRdW90YShkb2N1bWVudC0+ZnJh bWUoKSwgbmFtZSk7CisgICAgY29udGV4dC0+ZGF0YWJhc2VFeGNlZWRlZFF1b3RhKG5hbWUpOwog ICAgIG1fcHJvcG9zZWREYXRhYmFzZSA9IDA7CiAKICAgICAvLyBJZiB0aGUgZGF0YWJhc2Ugd2ls bCBmaXQgbm93LCBhbGxvdyBpdHMgY3JlYXRpb24uCkBAIC0xODYsNyArMTgzLDcgQEAgYm9vbCBE YXRhYmFzZVRyYWNrZXI6Omhhc0VudHJ5Rm9yRGF0YWJhcwogCiB1bnNpZ25lZCBsb25nIGxvbmcg RGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9yRGF0YWJhc2UoY29uc3QgRGF0YWJhc2UqIGRh dGFiYXNlKQogewotICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPmRvY3Vt ZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChjdXJy ZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+ZGF0YWJh c2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgLy8gVGhlIG1heGltdW0gc2l6ZSBmb3Ig YSBkYXRhYmFzZSBpcyB0aGUgZnVsbCBxdW90YSBmb3IgaXRzIG9yaWdpbiwgbWludXMgdGhlIGN1 cnJlbnQgdXNhZ2Ugd2l0aGluIHRoZSBvcmlnaW4sCiAgICAgLy8gcGx1cyB0aGUgY3VycmVudCB1 c2FnZSBvZiB0aGUgZ2l2ZW4gZGF0YWJhc2UKICAgICBMb2NrZXI8T3JpZ2luUXVvdGFNYW5hZ2Vy PiBsb2NrZXIob3JpZ2luUXVvdGFNYW5hZ2VyKCkpOwpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0Rh dGFiYXNlVHJhY2tlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRy YWNrZXIuaAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUcmFj a2VyLmgJKHdvcmtpbmcgY29weSkKQEAgLTQ1LDcgKzQ1LDcgQEAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAogY2xhc3MgRGF0YWJhc2U7Ci1jbGFzcyBEb2N1bWVudDsKK2NsYXNzIFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ7CiBjbGFzcyBTZWN1cml0eU9yaWdpbjsKIAogI2lmICFQTEFURk9STShDSFJP TUlVTSkKQEAgLTU5LDggKzU5LDExIEBAIHN0cnVjdCBTZWN1cml0eU9yaWdpblRyYWl0czsKIGNs YXNzIERhdGFiYXNlVHJhY2tlciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6CiAgICAg c3RhdGljIERhdGFiYXNlVHJhY2tlciYgdHJhY2tlcigpOworICAgIC8vIEZJWE1FOiBEdWUgdG8g d29ya2VycyBoYXZpbmcgbXVsdGlwbGUgdGhyZWFkcyBpbiBhIHNpbmdsZSBwcm9jZXNzIHNoYXJp bmcKKyAgICAvLyBhIERhdGFiYXNlVHJhY2tlciwgdGhpcyBzaW5nbGV0b24gd2lsbCBoYXZlIHRv IGJlIHN5bmNocm9uaXplZCBvciBtb3ZlZAorICAgIC8vIHRvIFRMUy4KIAotICAgIGJvb2wgY2Fu RXN0YWJsaXNoRGF0YWJhc2UoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0 cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisgICAgYm9v bCBjYW5Fc3RhYmxpc2hEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3Ry aW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGlt YXRlZFNpemUpOwogICAgIHZvaWQgc2V0RGF0YWJhc2VEZXRhaWxzKFNlY3VyaXR5T3JpZ2luKiwg Y29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUpOwogICAgIFN0cmluZyBmdWxsUGF0aEZvckRhdGFiYXNlKFNlY3Vy aXR5T3JpZ2luKiwgY29uc3QgU3RyaW5nJiBuYW1lLCBib29sIGNyZWF0ZUlmRG9lc05vdEV4aXN0 ID0gdHJ1ZSk7CiAKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL1NRTFRyYW5zYWN0aW9uLmNwcAkocmV2aXNpb24g NTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb24uY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0zNSwxMSArMzUsMTEgQEAKICNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUg IkRhdGFiYXNlQXV0aG9yaXplci5oIgogI2luY2x1ZGUgIkRhdGFiYXNlRGV0YWlscy5oIgotI2lu Y2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUg IkxvZ2dpbmcuaCIKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcu aCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU2V0dGlu Z3MuaCIKICNpbmNsdWRlICJTUUxFcnJvci5oIgogI2luY2x1ZGUgIlNRTGl0ZVRyYW5zYWN0aW9u LmgiCkBAIC05NCw4ICs5NCw3IEBAIHZvaWQgU1FMVHJhbnNhY3Rpb246OmV4ZWN1dGVTUUwoY29u c3QgU3QKIAogICAgIGJvb2wgcmVhZE9ubHlNb2RlID0gbV9yZWFkT25seTsKICAgICBpZiAoIXJl YWRPbmx5TW9kZSkgewotICAgICAgICBQYWdlKiBwYWdlID0gbV9kYXRhYmFzZS0+ZG9jdW1lbnQo KS0+cGFnZSgpOwotICAgICAgICBpZiAoIXBhZ2UgfHwgcGFnZS0+c2V0dGluZ3MoKS0+cHJpdmF0 ZUJyb3dzaW5nRW5hYmxlZCgpKQorICAgICAgICBpZiAobV9kYXRhYmFzZS0+c2NyaXB0RXhlY3V0 aW9uQ29udGV4dCgpLT5pc0RhdGFiYXNlUmVhZE9ubHkoKSkKICAgICAgICAgICAgIHJlYWRPbmx5 TW9kZSA9IHRydWU7CiAgICAgfQogCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rp b25DbGllbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlv bkNsaWVudC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL1NRTFRyYW5z YWN0aW9uQ2xpZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDcsNyArNDcsNyBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKIHZvaWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5z YWN0aW9uKFNRTFRyYW5zYWN0aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQoY3VycmVu dFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFz ZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09 IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFi YXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOwogICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9IHRy YW5zYWN0aW9uLT5kYXRhYmFzZSgpOwogICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnNj aGVkdWxlTm90aWZ5RGF0YWJhc2VDaGFuZ2VkKAogICAgICAgICBkYXRhYmFzZS0+c2VjdXJpdHlP cmlnaW4oKSwgZGF0YWJhc2UtPnN0cmluZ0lkZW50aWZpZXIoKSk7CkBAIC01NSw3ICs1NSw3IEBA IHZvaWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW4KIAogdm9pZCBTUUxUcmFu c2FjdGlvbkNsaWVudDo6ZGlkRXhlY3V0ZVN0YXRlbWVudChTUUxUcmFuc2FjdGlvbiogdHJhbnNh Y3Rpb24pCiB7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0 YWJhc2UoKS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7Cisg ICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2Ny aXB0RXhlY3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsK ICAgICBPcmlnaW5RdW90YU1hbmFnZXImIG1hbmFnZXIoRGF0YWJhc2VUcmFja2VyOjp0cmFja2Vy KCkub3JpZ2luUXVvdGFNYW5hZ2VyKCkpOwogICAgIExvY2tlcjxPcmlnaW5RdW90YU1hbmFnZXI+ IGxvY2tlcihtYW5hZ2VyKTsKICAgICBtYW5hZ2VyLm1hcmtEYXRhYmFzZSh0cmFuc2FjdGlvbi0+ ZGF0YWJhc2UoKSk7CkBAIC02MywxMyArNjMsMTEgQEAgdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVu dDo6ZGlkRXhlY3V0ZVN0YQogCiBib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRR dW90YShTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRo cmVhZCgpKTsKKyAgICBBU1NFUlQodHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQoKS0+aXNDb250ZXh0VGhyZWFkKCkpOwogICAgIERhdGFiYXNlKiBkYXRhYmFz ZSA9IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpOwotICAgIFBhZ2UqIHBhZ2UgPSBkYXRhYmFzZS0+ ZG9jdW1lbnQoKS0+cGFnZSgpOwotICAgIEFTU0VSVChwYWdlKTsKIAogICAgIHVuc2lnbmVkIGxv bmcgbG9uZyBjdXJyZW50UXVvdGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5xdW90YUZv ck9yaWdpbihkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4oKSk7Ci0gICAgcGFnZS0+Y2hyb21lKCkt PmNsaWVudCgpLT5leGNlZWRlZERhdGFiYXNlUXVvdGEoZGF0YWJhc2UtPmRvY3VtZW50KCktPmZy YW1lKCksIGRhdGFiYXNlLT5zdHJpbmdJZGVudGlmaWVyKCkpOworICAgIGRhdGFiYXNlLT5zY3Jp cHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlRXhjZWVkZWRRdW90YShkYXRhYmFzZS0+c3Ry aW5nSWRlbnRpZmllcigpKTsKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgbmV3UXVvdGEgPSBEYXRh YmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFzZS0+c2VjdXJpdHlP cmlnaW4oKSk7CiAgICAgcmV0dXJuIChuZXdRdW90YSA+IGN1cnJlbnRRdW90YSk7CiB9CkluZGV4 OiBXZWJDb3JlL3N0b3JhZ2UvY2hyb21pdW0vRGF0YWJhc2VUcmFja2VyQ2hyb21pdW0uY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFzZVRyYWNrZXJDaHJv bWl1bS5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL0Rh dGFiYXNlVHJhY2tlckNocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzUsOCArMzUsOCBA QAogI2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VPYnNlcnZlci5oIgog I2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNs dWRlICJRdW90YVRyYWNrZXIuaCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0Lmgi CiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKICNpbmNsdWRlICJTUUxpdGVGaWxlU3lzdGVt LmgiCiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KQEAgLTU2LDcgKzU2LDcgQEAgRGF0YWJhc2VU cmFja2VyOjpEYXRhYmFzZVRyYWNrZXIoKQogICAgIFNRTGl0ZUZpbGVTeXN0ZW06OnJlZ2lzdGVy U1FMaXRlVkZTKCk7CiB9CiAKLWJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRh YmFzZShEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYsIHVuc2lnbmVkIGxv bmcpCitib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCAqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmLCB1bnNpZ25lZCBs b25nKQogewogICAgIC8vIEluIENocm9taXVtLCBhIGRhdGFiYXNlIGNhbiBhbHdheXMgYmUgZXN0 YWJsaXNoZWQgKGV2ZW4gdGhvdWdoIHdlIG1pZ2h0IG5vdAogICAgIC8vIGJlIGFibGUgdG8gd3Jp dGUgYW55dGhpbmcgdG8gaXQgaWYgdGhlIHF1b3RhIGZvciB0aGlzIG9yaWdpbiB3YXMgZXhjZWVk ZWQpCkBAIC03NSwyMSArNzUsMzcgQEAgU3RyaW5nIERhdGFiYXNlVHJhY2tlcjo6ZnVsbFBhdGhG b3JEYXRhYgogCiB2b2lkIERhdGFiYXNlVHJhY2tlcjo6YWRkT3BlbkRhdGFiYXNlKERhdGFiYXNl KiBkYXRhYmFzZSkKIHsKLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChk YXRhYmFzZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRUaHJlYWQoKSk7CiAg ICAgRGF0YWJhc2VPYnNlcnZlcjo6ZGF0YWJhc2VPcGVuZWQoZGF0YWJhc2UpOwogfQotc3RhdGlj IHZvaWQgcmVtb3ZlT3BlbkRhdGFiYXNlT25NYWluVGhyZWFkKHZvaWQqIGNvbnRleHQpCi17Ci0g ICAgRGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8RGF0YWJhc2UqPihjb250ZXh0KTsK LSAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5yZW1vdmVPcGVuRGF0YWJhc2UoZGF0YWJh c2UpOwotICAgIGRhdGFiYXNlLT5kZXJlZigpOwotfQorCitjbGFzcyBUcmFja2VyUmVtb3ZlT3Bl bkRhdGFiYXNlVGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1 YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFz az4gY3JlYXRlKERhdGFiYXNlICpkYXRhYmFzZSkKKyAgICB7CisgICAgICAgIHJldHVybiBuZXcg VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2soZGF0YWJhc2UpOworICAgIH0KKworICAgIHZp cnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0KQor ICAgIHsKKyAgICAgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucmVtb3ZlT3BlbkRhdGFi YXNlKG1fZGF0YWJhc2UpOworICAgICAgICAvLyBSZWZmZWQgaW4gY2FsbGVyLgorICAgICAgICBt X2RhdGFiYXNlLT5kZXJlZigpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBUcmFj a2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzayhEYXRhYmFzZSAqZGF0YWJhc2UpIDogbV9kYXRhYmFz ZShkYXRhYmFzZSkKKyAgICB7CisgICAgfQorCisgICAgRGF0YWJhc2UqIG1fZGF0YWJhc2U7Cit9 OwogCiB2b2lkIERhdGFiYXNlVHJhY2tlcjo6cmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKiBk YXRhYmFzZSkKIHsKLSAgICBpZiAoIWlzTWFpblRocmVhZCgpKSB7CisgICAgaWYgKCFkYXRhYmFz ZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRUaHJlYWQoKSkgewogICAgICAg ICBkYXRhYmFzZS0+cmVmKCk7Ci0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQocmVtb3ZlT3BlbkRh dGFiYXNlT25NYWluVGhyZWFkLCBkYXRhYmFzZSk7CisgICAgICAgIGRhdGFiYXNlLT5zY3JpcHRF eGVjdXRpb25Db250ZXh0KCktPnBvc3RUYXNrKFRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNr OjpjcmVhdGUoZGF0YWJhc2UpKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApAQCAtOTgsNyAr MTE0LDcgQEAgdm9pZCBEYXRhYmFzZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRhYmFzZQogCiB1bnNp Z25lZCBsb25nIGxvbmcgRGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9yRGF0YWJhc2UoY29u c3QgRGF0YWJhc2UqIGRhdGFiYXNlKQogewotICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0g ZGF0YWJhc2UtPmRvY3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOwor ICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNv bnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgdW5zaWduZWQg bG9uZyBsb25nIHNwYWNlQXZhaWxhYmxlID0gMDsKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgZGF0 YWJhc2VTaXplID0gMDsKICAgICBRdW90YVRyYWNrZXI6Omluc3RhbmNlKCkuZ2V0RGF0YWJhc2VT aXplQW5kU3BhY2VBdmFpbGFibGVUb09yaWdpbigKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9jaHJv bWl1bS9TUUxUcmFuc2FjdGlvbkNsaWVudENocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3N0b3JhZ2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRDaHJvbWl1bS5jcHAJKHJl dmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0aW9u Q2xpZW50Q2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCwyMCArMzgsMzUgQEAKICNp bmNsdWRlICJTUUxUcmFuc2FjdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAK LXN0YXRpYyB2b2lkIG5vdGlmeURhdGFiYXNlQ2hhbmdlZCh2b2lkKiBjb250ZXh0KSB7Ci0gICAg V2ViQ29yZTo6RGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RGF0YWJh c2UqPihjb250ZXh0KTsKLSAgICBXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpkYXRhYmFzZU1v ZGlmaWVkKGRhdGFiYXNlKTsKLSAgICBkYXRhYmFzZS0+ZGVyZWYoKTsgIC8vIHJlZigpJ2QgaW4g ZGlkQ29tbWl0VHJhbnNhY3Rpb24oKQotfQotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNz IE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4 dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8Tm90aWZ5RGF0YWJhc2VD aGFuZ2VkVGFzaz4gY3JlYXRlKERhdGFiYXNlICpkYXRhYmFzZSkKKyAgICB7CisgICAgICAgIHJl dHVybiBuZXcgTm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzayhkYXRhYmFzZSk7CisgICAgfQorCisg ICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQorICAg IHsKKyAgICAgICAgV2ViQ29yZTo6RGF0YWJhc2VPYnNlcnZlcjo6ZGF0YWJhc2VNb2RpZmllZCht X2RhdGFiYXNlLmdldCgpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgZXhwbGljaXQgTm90aWZ5 RGF0YWJhc2VDaGFuZ2VkVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlPiBkYXRhYmFzZSkKKyAgICAg ICAgOiBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8RGF0 YWJhc2U+IG1fZGF0YWJhc2U7Cit9OworCiB2b2lkIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRD b21taXRUcmFuc2FjdGlvbihTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNT RVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQo KS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRU aHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZXhlY3V0aW9uQ29udGV4dCgpLT5k YXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKICAgICBpZiAoIXRyYW5zYWN0aW9uLT5p c1JlYWRPbmx5KCkpIHsKLSAgICAgICAgdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnJlZigpOyAg Ly8gZGVyZWYoKSdkIGluIG5vdGlmeURhdGFiYXNlQ2hhbmdlZCgpCi0gICAgICAgIGNhbGxPbk1h aW5UaHJlYWQobm90aWZ5RGF0YWJhc2VDaGFuZ2VkLCB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKSk7 CisgICAgICAgIHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5leGVjdXRpb25Db250ZXh0KCktPnBv c3RUYXNrKAorICAgICAgICAgICAgTm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzazo6Y3JlYXRlKHRy YW5zYWN0aW9uLT5kYXRhYmFzZSgpKSk7CiAgICAgfQogfQogCkBAIC01OSwxNCArNzQsMTQgQEAg dm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkRXhlY3V0ZVN0YQogewogICAgIC8vIFRoaXMg bWV0aG9kIGlzIGNhbGxlZCBhZnRlciBleGVjdXRpbmcgZXZlcnkgc3RhdGVtZW50IHRoYXQgY2hh bmdlcyB0aGUgREIuCiAgICAgLy8gQ2hyb21pdW0gZG9lc24ndCBuZWVkIHRvIGRvIGFueXRoaW5n IGF0IHRoYXQgcG9pbnQuCi0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlv bi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQo KSk7CisgICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2Uo KS0+ZXhlY3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsK IH0KIAotYm9vbCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkRXhjZWVkUXVvdGEoU1FMVHJhbnNh Y3Rpb24qKQorYm9vbCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkRXhjZWVkUXVvdGEoU1FMVHJh bnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewogICAgIC8vIENocm9taXVtIGRvZXMgbm90IGFsbG93 IHVzZXJzIHRvIG1hbnVhbGx5IGNoYW5nZSB0aGUgcXVvdGEgZm9yIGFuIG9yaWdpbiAoZm9yIG5v dywgYXQgbGVhc3QpLgogICAgIC8vIERvbid0IGRvIGFueXRoaW5nLgotICAgIEFTU0VSVChpc01h aW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5leGVjdXRp b25Db250ZXh0KCktPmlzQ29udGV4dFRocmVhZCgpKTsKICAgICByZXR1cm4gZmFsc2U7CiB9CiAK SW5kZXg6IFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMiw2ICsz Miw3IEBACiAjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgogCiAjaW5jbHVkZSAiQWN0aXZlRE9N T2JqZWN0LmgiCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKICNpbmNsdWRlICJET01UaW1lci5oIgog I2luY2x1ZGUgIkRPTVdpbmRvdy5oIgogI2luY2x1ZGUgIkV2ZW50LmgiCkBAIC0yNTQsNiArMjU1 LDI0IEBAIE5vdGlmaWNhdGlvbkNlbnRlciogV29ya2VyQ29udGV4dDo6d2Via2kKIH0KICNlbmRp ZgogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorUGFzc1JlZlB0cjxEYXRhYmFzZT4gV29ya2VyQ29u dGV4dDo6b3BlbkRhdGFiYXNlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2ZXJz aW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNp emUsIEV4Y2VwdGlvbkNvZGUmIGVjKQoreworICAgIGlmICghc2VjdXJpdHlPcmlnaW4oKS0+Y2Fu QWNjZXNzRGF0YWJhc2UoKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBpZiAoIURhdGFiYXNl Ojppc0F2YWlsYWJsZSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJldHVybiBEYXRhYmFz ZTo6b3BlbkRhdGFiYXNlKHRoaXMsIG5hbWUsIHZlcnNpb24sIGRpc3BsYXlOYW1lLCBlc3RpbWF0 ZWRTaXplLCBlYyk7Cit9CisjZW5kaWYKKworYm9vbCBXb3JrZXJDb250ZXh0Ojppc0NvbnRleHRU aHJlYWQoKSBjb25zdAoreworICAgIHJldHVybiBjdXJyZW50VGhyZWFkKCkgPT0gdGhyZWFkKCkt PnRocmVhZElEKCk7Cit9CisKIEV2ZW50VGFyZ2V0RGF0YSogV29ya2VyQ29udGV4dDo6ZXZlbnRU YXJnZXREYXRhKCkKIHsKICAgICByZXR1cm4gJm1fZXZlbnRUYXJnZXREYXRhOwpJbmRleDogV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3dvcmtl cnMvV29ya2VyQ29udGV4dC5oCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmgJKHdvcmtpbmcgY29weSkKQEAgLTMwLDExICszMCwxMyBAQAogI2lmIEVO QUJMRShXT1JLRVJTKQogCiAjaW5jbHVkZSAiQXRvbWljU3RyaW5nSGFzaC5oIgorI2luY2x1ZGUg IkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIkV2ZW50 TmFtZXMuaCIKICNpbmNsdWRlICJFdmVudFRhcmdldC5oIgogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQuaCIKICNpbmNsdWRlICJXb3JrZXJTY3JpcHRDb250cm9sbGVyLmgiCisjaW5j bHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVk ZSA8d3RmL1Bhc3NSZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgpAQCAtNDIs NiArNDQsNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKKyAgICBjbGFzcyBEYXRhYmFzZTsK ICAgICBjbGFzcyBOb3RpZmljYXRpb25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVkQWN0aW9u OwogICAgIGNsYXNzIFdvcmtlckxvY2F0aW9uOwpAQCAtNjUsOSArNjgsOSBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgU3RyaW5nIHVzZXJBZ2VudChjb25zdCBLVVJMJikg Y29uc3Q7CiAKICAgICAgICAgV29ya2VyU2NyaXB0Q29udHJvbGxlciogc2NyaXB0KCkgeyByZXR1 cm4gbV9zY3JpcHQuZ2V0KCk7IH0KLSAgICAgICAgdm9pZCBjbGVhclNjcmlwdCgpIHsgcmV0dXJu IG1fc2NyaXB0LmNsZWFyKCk7IH0KKyAgICAgICAgdm9pZCBjbGVhclNjcmlwdCgpIHsgbV9zY3Jp cHQuY2xlYXIoKTsgfQogCi0gICAgICAgIFdvcmtlclRocmVhZCogdGhyZWFkKCkgeyByZXR1cm4g bV90aHJlYWQ7IH0KKyAgICAgICAgV29ya2VyVGhyZWFkKiB0aHJlYWQoKSBjb25zdCB7IHJldHVy biBtX3RocmVhZDsgfQogCiAgICAgICAgIGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgY29uc3Q7 CiAKQEAgLTEwMSw2ICsxMDQsMTcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBOb3Rp ZmljYXRpb25DZW50ZXIqIHdlYmtpdE5vdGlmaWNhdGlvbnMoKSBjb25zdDsKICNlbmRpZgogCisj aWYgRU5BQkxFKERBVEFCQVNFKQorICAgICAgICAvLyBIVE1MIDUgY2xpZW50LXNpZGUgZGF0YWJh c2UKKyAgICAgICAgUGFzc1JlZlB0cjxEYXRhYmFzZT4gb3BlbkRhdGFiYXNlKGNvbnN0IFN0cmlu ZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2ZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1l LCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICAgICAg Ly8gTm90IGltcGxlbWVudGVkIHlldC4KKyAgICAgICAgdmlydHVhbCBib29sIGlzRGF0YWJhc2VS ZWFkT25seSgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisgICAgICAgIC8vIE5vdCBpbXBsZW1l bnRlZCB5ZXQuCisgICAgICAgIHZpcnR1YWwgdm9pZCBkYXRhYmFzZUV4Y2VlZGVkUXVvdGEoY29u c3QgU3RyaW5nJikgeyB9CisjZW5kaWYKKyAgICAgICAgdmlydHVhbCBib29sIGlzQ29udGV4dFRo cmVhZCgpIGNvbnN0OworCisKICAgICAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3Ig R0MgbWFya2luZy4gU2VlIEpTV29ya2VyQ29udGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYp IGluCiAgICAgICAgIC8vIEpTV29ya2VyQ29udGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtl ck5hdmlnYXRvciogb3B0aW9uYWxOYXZpZ2F0b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRv ci5nZXQoKTsgfQpJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaWRsCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmlkbAkocmV2aXNpb24gNTI5 OTUpCisrKyBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5pZGwJKHdvcmtpbmcgY29weSkK QEAgLTQ5LDcgKzQ5LDEwIEBAIG1vZHVsZSB0aHJlYWRzIHsKICAgICAgICAgLy8gV29ya2VyVXRp bHMKICAgICAgICAgW0N1c3RvbV0gdm9pZCBpbXBvcnRTY3JpcHRzKC8qW1ZhcmlhZGljXSBpbiBE T01TdHJpbmcgdXJscyAqLyk7CiAgICAgICAgICAgICAgICAgIGF0dHJpYnV0ZSBbUmVwbGFjZWFi bGVdIFdvcmtlck5hdmlnYXRvciBuYXZpZ2F0b3I7Ci0gICAgICAgIC8vIERhdGFiYXNlIG9wZW5E YXRhYmFzZShpbiBET01TdHJpbmcgbmFtZSwgaW4gRE9NU3RyaW5nIHZlcnNpb24sIGluIERPTVN0 cmluZyBkaXNwbGF5TmFtZSwgaW4gdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKKyNpZiBk ZWZpbmVkKEVOQUJMRV9EQVRBQkFTRSkgJiYgRU5BQkxFX0RBVEFCQVNFCisgICAgICAgIFtFbmFi bGVkQXRSdW50aW1lXSBEYXRhYmFzZSBvcGVuRGF0YWJhc2UoaW4gRE9NU3RyaW5nIG5hbWUsIGlu IERPTVN0cmluZyB2ZXJzaW9uLCBpbiBET01TdHJpbmcgZGlzcGxheU5hbWUsIGluIHVuc2lnbmVk IGxvbmcgZXN0aW1hdGVkU2l6ZSkKKyAgICAgICAgICAgIHJhaXNlcyhET01FeGNlcHRpb24pOwor I2VuZGlmCiAgICAgICAgIC8vIERhdGFiYXNlU3luYyBvcGVuRGF0YWJhc2VTeW5jKGluIERPTVN0 cmluZyBuYW1lLCBpbiBET01TdHJpbmcgdmVyc2lvbiwgaW4gRE9NU3RyaW5nIGRpc3BsYXlOYW1l LCBpbiB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogCiAgICAgICAgIC8vIFRpbWVycwpJ bmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvd29ya2Vycy9Xb3JrZXJSdW5Mb29wLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJD b3JlL3dvcmtlcnMvV29ya2VyUnVuTG9vcC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE1Miw5ICsx NTIsNyBAQCBNZXNzYWdlUXVldWVXYWl0UmVzdWx0IFdvcmtlclJ1bkxvb3A6OnJ1CiAgICAgTWVz c2FnZVF1ZXVlV2FpdFJlc3VsdCByZXN1bHQ7CiAgICAgT3duUHRyPFdvcmtlclJ1bkxvb3A6OlRh c2s+IHRhc2sgPSBtX21lc3NhZ2VRdWV1ZS53YWl0Rm9yTWVzc2FnZUZpbHRlcmVkV2l0aFRpbWVv dXQocmVzdWx0LCBwcmVkaWNhdGUsIGFic29sdXRlVGltZSk7CiAKLSAgICAvLyBJZiB0aGUgY29u dGV4dCBpcyBjbG9zaW5nLCBkb24ndCBkaXNwYXRjaCBhbnkgZnVydGhlciB0YXNrcyAocGVyIHNl Y3Rpb24gNC4xLjEgb2YgdGhlIFdlYiBXb3JrZXJzIHNwZWMpLgotICAgIGlmIChjb250ZXh0LT5p c0Nsb3NpbmcoKSkKLSAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICAvLyBJZiB0aGUgY29udGV4 dCBpcyBjbG9zaW5nLCBkb24ndCBleGVjdXRlIGFueSBmdXJ0aGVyIEphdmFTY3JpcHQgdGFza3Mg KHBlciBzZWN0aW9uIDQuMS4xIG9mIHRoZSBXZWIgV29ya2VycyBzcGVjKS4gIEhvd2V2ZXIsIHRo ZXJlIG1heSBiZSBpbXBsZW1lbnRhdGlvbiBjbGVhbnVwIHRhc2tzIGluIHRoZSBxdWV1ZSwgc28g a2VlcCBydW5uaW5nIHRocm91Z2ggaXQuCiAKICAgICBzd2l0Y2ggKHJlc3VsdCkgewogICAgIGNh c2UgTWVzc2FnZVF1ZXVlVGVybWluYXRlZDoKQEAgLTE2NSw3ICsxNjMsOCBAQCBNZXNzYWdlUXVl dWVXYWl0UmVzdWx0IFdvcmtlclJ1bkxvb3A6OnJ1CiAgICAgICAgIGJyZWFrOwogCiAgICAgY2Fz ZSBNZXNzYWdlUXVldWVUaW1lb3V0OgotICAgICAgICBtX3NoYXJlZFRpbWVyLT5maXJlKCk7Cisg ICAgICAgIGlmICghY29udGV4dC0+aXNDbG9zaW5nKCkpCisgICAgICAgICAgICBtX3NoYXJlZFRp bWVyLT5maXJlKCk7CiAgICAgICAgIGJyZWFrOwogICAgIH0KIApAQCAtMTk0LDcgKzE5Myw5IEBA IFBhc3NPd25QdHI8V29ya2VyUnVuTG9vcDo6VGFzaz4gV29ya2VyUnUKIAogdm9pZCBXb3JrZXJS dW5Mb29wOjpUYXNrOjpwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0 KQogewotICAgIG1fdGFzay0+cGVyZm9ybVRhc2soY29udGV4dCk7CisgICAgV29ya2VyQ29udGV4 dCogd29ya2VyQ29udGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQgKj4oY29udGV4dCk7 CisgICAgaWYgKCF3b3JrZXJDb250ZXh0LT5pc0Nsb3NpbmcoKSB8fCBtX3Rhc2stPmlzQ2xlYW51 cFRhc2soKSkKKyAgICAgICAgbV90YXNrLT5wZXJmb3JtVGFzayhjb250ZXh0KTsKIH0KIAogV29y a2VyUnVuTG9vcDo6VGFzazo6VGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OlRhc2s+IHRhc2ssIGNvbnN0IFN0cmluZyYgbW9kZSkKSW5kZXg6IFdlYkNvcmUvd29ya2Vycy9X b3JrZXJUaHJlYWQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJl YWQuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMCw2ICszMCw3IEBACiAKICNpbmNsdWRlICJXb3JrZXJU aHJlYWQuaCIKIAorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgogI2luY2x1ZGUgIkRlZGljYXRl ZFdvcmtlckNvbnRleHQuaCIKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1T dHJpbmcuaCIKQEAgLTEzNSw5ICsxMzYsOCBAQCB2b2lkKiBXb3JrZXJUaHJlYWQ6OndvcmtlclRo cmVhZCgpCiAKICAgICBUaHJlYWRJZGVudGlmaWVyIHRocmVhZElEID0gbV90aHJlYWRJRDsKIAot ICAgIG1fd29ya2VyQ29udGV4dC0+c3RvcEFjdGl2ZURPTU9iamVjdHMoKTsKLSAgICBtX3dvcmtl ckNvbnRleHQtPmNsZWFyU2NyaXB0KCk7CiAgICAgQVNTRVJUKG1fd29ya2VyQ29udGV4dC0+aGFz T25lUmVmKCkpOworCiAgICAgLy8gVGhlIGJlbG93IGFzc2lnbm1lbnQgd2lsbCBkZXN0cm95IHRo ZSBjb250ZXh0LCB3aGljaCB3aWxsIGluIHR1cm4gbm90aWZ5IG1lc3NhZ2luZyBwcm94eS4KICAg ICAvLyBXZSBjYW5ub3QgbGV0IGFueSBvYmplY3RzIHN1cnZpdmUgcGFzdCB0aHJlYWQgZXhpdCwg YmVjYXVzZSBubyBvdGhlciB0aHJlYWQgd2lsbCBydW4gR0Mgb3Igb3RoZXJ3aXNlIGRlc3Ryb3kg dGhlbS4KICAgICBtX3dvcmtlckNvbnRleHQgPSAwOwpAQCAtMTU0LDE3ICsxNTQsODAgQEAgdm9p ZCBXb3JrZXJUaHJlYWQ6OnJ1bkV2ZW50TG9vcCgpCiAgICAgbV9ydW5Mb29wLnJ1bihtX3dvcmtl ckNvbnRleHQuZ2V0KCkpOwogfQogCitjbGFzcyBXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRh c2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAg c3RhdGljIFBhc3NPd25QdHI8V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrPiBjcmVhdGUo KQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRh c2soKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCAqY29udGV4dCkKKyAgICB7CisgICAgICAgIEFTU0VSVChjb250ZXh0LT5pc1dv cmtlckNvbnRleHQoKSk7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBz dGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oY29udGV4dCk7CisgICAgICAgIHdvcmtlckNvbnRl eHQtPnRocmVhZCgpLT5ydW5Mb29wKCkudGVybWluYXRlKCk7CisgICAgfQorCisgICAgdmlydHVh bCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisKK3ByaXZhdGU6 CisgICAgZXhwbGljaXQgV29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrKCkKKyAgICB7Cisg ICAgfQorfTsKKworY2xhc3MgV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2sgOiBwdWJsaWMg U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NP d25QdHI8V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s+IGNyZWF0ZSgpCisgICAgeworICAg ICAgICByZXR1cm4gbmV3IFdvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrKCk7CisgICAgfQor CisgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNv bnRleHQpCisgICAgeworICAgICAgICBBU1NFUlQoY29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkp OworICAgICAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29y a2VyQ29udGV4dCo+KGNvbnRleHQpOworCisgICAgICAgIC8vIFdlIGN1cnJlbnRseSBpZ25vcmUg YW55IERhdGFiYXNlUG9saWN5IHVzZWQgZm9yIHRoZSBkb2N1bWVudCdzCisgICAgICAgIC8vIGRh dGFiYXNlczsgaWYgaXQncyBhY3R1YWxseSB1c2VkIGFueXdoZXJlLCB0aGlzIHNob3VsZCBiZSBy ZXZpc2l0ZWQuCisgICAgICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBjbGVhbnVwU3luYzsK KyAgICAgICAgd29ya2VyQ29udGV4dC0+c3RvcERhdGFiYXNlcygmY2xlYW51cFN5bmMpOworCisg ICAgICAgIHdvcmtlckNvbnRleHQtPnN0b3BBY3RpdmVET01PYmplY3RzKCk7CisgICAgICAgIHdv cmtlckNvbnRleHQtPmNsZWFyU2NyaXB0KCk7CisKKyAgICAgICAgLy8gV2Ugd2FpdCBmb3IgdGhl IGRhdGFiYXNlIHRocmVhZCB0byBjbGVhbiB1cCBhbGwgaXRzIHN0dWZmIHNvIHRoYXQgd2UKKyAg ICAgICAgLy8gY2FuIGRvIG1vcmUgc3RyaW5nZW50IGxlYWsgY2hlY2tzIGFzIHdlIGV4aXQuCisg ICAgICAgIGNsZWFudXBTeW5jLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOworCisgICAgICAgIC8v IFN0aWNrIGEgc2h1dGRvd24gY29tbWFuZCBhdCB0aGUgZW5kIG9mIHRoZSBxdWV1ZSwgc28gdGhh dCB3ZSBkZWFsCisgICAgICAgIC8vIHdpdGggYWxsIHRoZSBjbGVhbnVwIHRhc2tzIHRoZSBkYXRh YmFzZXMgcG9zdCBmaXJzdC4KKyAgICAgICAgd29ya2VyQ29udGV4dC0+cG9zdFRhc2soV29ya2Vy VGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjpjcmVhdGUoKSk7CisgICAgfQorCisgICAgdmlydHVh bCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisKK3ByaXZhdGU6 CisgICAgZXhwbGljaXQgV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2soKQorICAgIHsKKyAg ICB9Cit9OworCiB2b2lkIFdvcmtlclRocmVhZDo6c3RvcCgpCiB7CiAgICAgLy8gTXV0ZXggcHJv dGVjdGlvbiBpcyBuZWNlc3NhcnkgYmVjYXVzZSBzdG9wKCkgY2FuIGJlIGNhbGxlZCBiZWZvcmUg dGhlIGNvbnRleHQgaXMgZnVsbHkgY3JlYXRlZC4KICAgICBNdXRleExvY2tlciBsb2NrKG1fdGhy ZWFkQ3JlYXRpb25NdXRleCk7CiAKICAgICAvLyBFbnN1cmUgdGhhdCB0YXNrcyBhcmUgYmVpbmcg aGFuZGxlZCBieSB0aHJlYWQgZXZlbnQgbG9vcC4gSWYgc2NyaXB0IGV4ZWN1dGlvbiB3ZXJlbid0 IGZvcmJpZGRlbiwgYSB3aGlsZSgxKSBsb29wIGluIEpTIGNvdWxkIGtlZXAgdGhlIHRocmVhZCBh bGl2ZSBmb3JldmVyLgotICAgIGlmIChtX3dvcmtlckNvbnRleHQpCisgICAgaWYgKG1fd29ya2Vy Q29udGV4dCkgewogICAgICAgICBtX3dvcmtlckNvbnRleHQtPnNjcmlwdCgpLT5mb3JiaWRFeGVj dXRpb24oKTsKIAogICAgIC8vIEZJWE1FOiBSdWRlbHkga2lsbGluZyB0aGUgdGhyZWFkIHdvbid0 IHdvcmsgd2hlbiB3ZSBhbGxvdyBuZXN0ZWQgd29ya2VycywgYmVjYXVzZSB0aGV5IHdpbGwgdHJ5 IHRvIHBvc3Qgbm90aWZpY2F0aW9ucyBvZiB0aGVpciBkZXN0cnVjdGlvbi4KLSAgICBtX3J1bkxv b3AudGVybWluYXRlKCk7CisgICAgLy8gVGhpcyBjYW4gbGlrZWx5IHVzZSB0aGUgc2FtZSBtZWNo YW5pc20gYXMgdXNlZCBmb3IgZGF0YWJhc2VzIGFib3ZlLgorCisgICAgICAgIG1fcnVuTG9vcC5w b3N0VGFzayhXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6Y3JlYXRlKCkpOworICAgIH0g ZWxzZQorICAgICAgICBtX3J1bkxvb3AudGVybWluYXRlKCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUK 46403 2010-01-12 15:16:36 -0800 2010-01-19 16:32:52 -0800 Fixed chromium compile; removed WorkerContext.idl upload.2.2.patch text/plain 62016 ericu SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzE2NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTQ5IEBACisyMDEwLTAxLTEyICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVmYWN0b3JpbmcgYW5kIHBsdW1iaW5nIHRvIGdldCB0aGUgSFRNTDUgU1FMIERhdGFiYXNlIEFQ SSBhY2Nlc3NpYmxlIHRvCisgICAgICAgIHdlYiB3b3JrZXJzLiAgTm8gbmV3IGZ1bmN0aW9uYWxp dHkgaXMgZXhwb3NlZCB5ZXQ7IHRoaXMganVzdCBnZXRzIHRoZQorICAgICAgICBpbmZyYXN0cnVj dHVyZSBpbiBwbGFjZS4gIEl0IHRvdWNoZXMgYSBsb3Qgb2YgZmlsZXMgaW4gc21hbGwgd2F5czsg aGVyZQorICAgICAgICBhcmUgdGhlIG1haW4gY2hhbmdlczoKKworICAgICAgICAxKSBEYXRhYmFz ZSBtZW1iZXJzIGFuZCBtZXRob2RzIG1vdmUgZnJvbSBEb2N1bWVudCB1cCB0bworICAgICAgICBT Y3JpcHRFeGVjdXRpb25Db250ZXh0LiAgRWFjaCBvZiBEb2N1bWVudCBhbmQgV29ya2VyQ29udGV4 dCBtdXN0CisgICAgICAgIGltcGxlbWVudCBhIGZldyB2aXJ0dWFsIG1ldGhvZHMgd2hlcmUgdGhl IERhdGFiYXNlIGNvZGUgcmVxdWlyZXMKKyAgICAgICAgZGlmZmVyZW50aWF0aW9uLgorICAgICAg ICAyKSBXb3JrZXIgdGhyZWFkIHNodXRkb3duIGdvdCBjaGFuZ2VkIGEgYnVuY2ggdG8gaGFuZGxl IERhdGFiYXNlIGNsZWFudXAKKyAgICAgICAgYW5kIHRocmVhZCBzeW5jaHJvbml6YXRpb24gaXNz dWVzLiAgRGF0YWJhc2UgY2xlYW51cCB0YXNrcyBuZWVkIHRvIHBvc3QKKyAgICAgICAgc29tZSBj bGVhbnVwIHRhc2tzIHRvIHRoZSBKYXZhU2NyaXB0IHRocmVhZC4gIEhvd2V2ZXIsIHNpbmNlIGRh dGFiYXNlCisgICAgICAgIGNsZWFudXAgbWF5IGhhcHBlbiBkdWUgdG8gdGhlIGRlc3RydWN0aW9u IG9mIHRoZSBXb3JrZXJUaHJlYWQsIEkgYWRkZWQgYQorICAgICAgICBoYW5kc2hha2UgW2ludm9s dmluZyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzaywKKyAgICAgICAgV29ya2VyVGhyZWFk U2h1dGRvd25GaW5pc2hUYXNrLCBhbmQgYSBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXJdIGJldHdl ZW4KKyAgICAgICAgdGhlIERhdGFiYXNlIHRocmVhZCBhbmQgV29ya2VyVGhyZWFkIHRoYXQgY2xl YW5zIHVwIGFsbCB0aGUgRGF0YWJhc2UKKyAgICAgICAgc3R1ZmYgYmVmb3JlIHRoZSBXb3JrZXJU aHJlYWQncyBydW5Mb29wIGNhbiBleGl0LgorICAgICAgICAzKSBUaGUgcnVudGltZSBlbmFibGVy IGZvciB0aGUgRGF0YWJhc2UgbW92ZWQgdG8gYSBzdGF0aWMgdmFyaWFibGUKKyAgICAgICAgYWNj ZXNzaWJsZSB0aHJvdWdoIERhdGFiYXNlOjppc0F2YWlsYWJsZSwgZm9sbG93aW5nIHRoZSBtb2Rl bCB1c2VkIGJ5CisgICAgICAgIFdlYlNvY2tldC4KKyAgICAgICAgNCkgV29ya2VyIHRocmVhZHMg ZG9uJ3QgcnVuIHRoZWlyIEphdmFTY3JpcHQgb24gdGhlIE1haW4gdGhyZWFkLCBzbworICAgICAg ICBEYXRhYmFzZSBjb2RlIHRoYXQgZGlmZmVyZW50aWF0ZWQgYmV0d2VlbiB0aGUgTWFpbiB0aHJl YWQgYW5kIHRoZQorICAgICAgICBEYXRhYmFzZSB0aHJlYWQgbm93IG5lZWQgdG8gZGVhbCB3aXRo IGEgdGhpcmQgcG9zc2liaWxpdHkuCisgICAgICAgIDUpIE1vc3Qgb2YgdGhlIG90aGVyIGNoYW5n ZXMgaGF2ZSB0byBkbyB3aXRoIGhhdmluZyBhCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgcG9pbnRlciBpbnN0ZWFkIG9mIGEgRG9jdW1lbnQgcG9pbnRlciB3aGVuCisgICAgICAgIGRl YWxpbmcgd2l0aCBhIERhdGFiYXNlLiAgSW4gbWFueSBjYXNlcyBpdCdzIGp1c3QgYSBzdHJpbmcg cmVwbGFjZW1lbnQsCisgICAgICAgIGJ1dCBpbiBzb21lIGl0IHJlcXVpcmVkIHRoZSBjcmVhdGlv biBvZiBhIG5ldyB2aXJ0dWFsIGZ1bmN0aW9uIFtlLmcuCisgICAgICAgIGRhdGFiYXNlRXhjZWVk ZWRRdW90YSwgaXNEYXRhYmFzZVJlYWRPbmx5XQorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjcyNQorCisgICAgICAgIE5vIG5ldyB0ZXN0czsgaW4g YSBmdXR1cmUgcGF0Y2ggSSdsbCBhZGQgSlNDIGFuZCBWOCBiaW5kaW5ncyBhbmQgbmV3CisgICAg ICAgIGxheW91dCB0ZXN0cyB0byBleGVyY2lzZSB0aGVtLgorCisgICAgICAgICogYmluZGluZ3Mv djgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4RE9N V2luZG93OjpPcGVuRGF0YWJhc2VFbmFibGVkKToKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNv cmU6OkRvY3VtZW50Ojp+RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6Omlz RGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZGF0YWJhc2VF eGNlZWRlZFF1b3RhKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojppc0NvbnRleHRUaHJl YWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAgICAqIGRvbS9TY3JpcHRFeGVj dXRpb25Db250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RXhl Y3V0aW9uQ29udGV4dDo6flNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6ZGF0YWJhc2VUaHJlYWQpOgorICAgICAgICAoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6YWRkT3BlbkRhdGFiYXNlKToKKyAgICAgICAg KFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9wZW5EYXRhYmFzZSk6Cisg ICAgICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdG9wRGF0YWJhc2VzKToK KyAgICAgICAgKiBkb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c2V0SGFzT3BlbkRhdGFiYXNlcyk6CisgICAgICAg IChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpoYXNPcGVuRGF0YWJhc2VzKToKKyAg ICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s6OmlzQ2xlYW51cFRh c2spOgorICAgICAgICAqIGxvYWRlci9GcmFtZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpGcmFtZUxvYWRlcjo6c3RvcExvYWRpbmcpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2Uu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNldElzQXZhaWxhYmxlKToKKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlOjppc0F2YWlsYWJsZSk6CisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZTo6b3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpEYXRh YmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEZXJlZkNvbnRleHRUYXNrOjpjcmVhdGUpOgorICAg ICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAo V2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6aXNDbGVhbnVwVGFzayk6CisgICAgICAgIChXZWJD b3JlOjpEZXJlZkNvbnRleHRUYXNrOjpEZXJlZkNvbnRleHRUYXNrKToKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFiYXNlOjp+RGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6Om9w ZW5BbmRWZXJpZnlWZXJzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjptYXJrQXNE ZWxldGVkQW5kQ2xvc2UpOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4dFJlbW92ZU9wZW5EYXRh YmFzZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDb250ZXh0UmVtb3ZlT3BlbkRh dGFiYXNlVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4dFJlbW92 ZU9wZW5EYXRhYmFzZVRhc2s6OmlzQ2xlYW51cFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6Q29u dGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNr KToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpjbG9zZSk6CisgICAgICAgIChXZWJDb3Jl OjpEYXRhYmFzZTo6cGVyZm9ybU9wZW5BbmRWZXJpZnkpOgorICAgICAgICAoV2ViQ29yZTo6RGF0 YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6 OnNjaGVkdWxlVHJhbnNhY3Rpb25TdGVwKToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGl2ZXJQZW5k aW5nQ2FsbGJhY2tUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6RGVsaXZlclBlbmRp bmdDYWxsYmFja1Rhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGl2ZXJQ ZW5kaW5nQ2FsbGJhY2tUYXNrOjpEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayk6CisgICAgICAg IChXZWJDb3JlOjpEYXRhYmFzZTo6c2NoZWR1bGVUcmFuc2FjdGlvbkNhbGxiYWNrKToKKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlOjp0cmFuc2FjdGlvbkNsaWVudCk6CisgICAgICAgIChXZWJD b3JlOjpEYXRhYmFzZTo6dHJhbnNhY3Rpb25Db29yZGluYXRvcik6CisgICAgICAgIChXZWJDb3Jl OjpEYXRhYmFzZTo6dGFibGVOYW1lcyk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6c2Vj dXJpdHlPcmlnaW4pOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2UuaDoKKyAgICAgICAgKFdl YkNvcmU6OkRhdGFiYXNlOjpzY3JpcHRFeGVjdXRpb25Db250ZXh0KToKKyAgICAgICAgKiBzdG9y YWdlL0RhdGFiYXNlVGFzay5oOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKToKKyAg ICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjp+RGF0YWJhc2VUaHJlYWQpOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbik6CisgICAgICAg IChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6ZGF0YWJhc2VUaHJlYWQpOgorICAgICAgICAoV2Vi Q29yZTo6RGF0YWJhc2VUaHJlYWQ6OnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKToKKyAgICAgICAg KiBzdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmg6CisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRy YWNrZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxp c2hEYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRyYWNrZXI6OmdldE1heFNp emVGb3JEYXRhYmFzZSk6CisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuaDoKKyAg ICAgICAgKiBzdG9yYWdlL1NRTFRyYW5zYWN0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNR TFRyYW5zYWN0aW9uOjpleGVjdXRlU1FMKToKKyAgICAgICAgKiBzdG9yYWdlL1NRTFRyYW5zYWN0 aW9uQ2xpZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50Ojpk aWRDb21taXRUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbkNs aWVudDo6ZGlkRXhlY3V0ZVN0YXRlbWVudCk6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2Fj dGlvbkNsaWVudDo6ZGlkRXhjZWVkUXVvdGEpOgorICAgICAgICAqIHN0b3JhZ2UvY2hyb21pdW0v RGF0YWJhc2VUcmFja2VyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VU cmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFz ZVRyYWNrZXI6OmFkZE9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpUcmFja2VyUmVt b3ZlT3BlbkRhdGFiYXNlVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlRyYWNrZXJS ZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpU cmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRh c2spOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpyZW1vdmVPcGVuRGF0YWJh c2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9yRGF0 YWJhc2UpOgorICAgICAgICAqIHN0b3JhZ2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRD aHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNr OjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzazo6 cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFz azo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFu c2FjdGlvbkNsaWVudDo6ZGlkQ29tbWl0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6 U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4ZWN1dGVTdGF0ZW1lbnQpOgorICAgICAgICAoV2Vi Q29yZTo6U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKToKKyAgICAgICAgKiB3 b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4 dDo6b3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6OmlzQ29u dGV4dFRocmVhZCk6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0Lmg6CisgICAgICAg IChXZWJDb3JlOjpXb3JrZXJDb250ZXh0OjpjbGVhclNjcmlwdCk6CisgICAgICAgIChXZWJDb3Jl OjpXb3JrZXJDb250ZXh0Ojp0aHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4 dDo6aXNEYXRhYmFzZVJlYWRPbmx5KToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRleHQ6 OmRhdGFiYXNlRXhjZWVkZWRRdW90YSk6CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJSdW5Mb29w LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclJ1bkxvb3A6OnJ1bkluTW9kZSk6CisgICAg ICAgIChXZWJDb3JlOjpXb3JrZXJSdW5Mb29wOjpUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAg ICogd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhy ZWFkOjp3b3JrZXJUaHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRv d25GaW5pc2hUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1 dGRvd25GaW5pc2hUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJU aHJlYWRTaHV0ZG93bkZpbmlzaFRhc2s6OmlzQ2xlYW51cFRhc2spOgorICAgICAgICAoV2ViQ29y ZTo6V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjpXb3JrZXJUaHJlYWRTaHV0ZG93bkZp bmlzaFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRh c2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0 VGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRv d25TdGFydFRhc2s6OmlzQ2xlYW51cFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhy ZWFkU2h1dGRvd25TdGFydFRhc2s6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrKToKKyAg ICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZDo6c3RvcCk6CisKIDIwMTAtMDEtMTIgIEJldGgg RGFraW4gIDxiZGFraW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWlu aWcuCkluZGV4OiBXZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERPTVdpbmRvd0N1c3RvbS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhET01XaW5kb3dD dXN0b20uY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9t L1Y4RE9NV2luZG93Q3VzdG9tLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzMsNiArMzMsNyBAQAog CiAjaW5jbHVkZSAiQmFzZTY0LmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiRGF0 YWJhc2UuaCIKICNpbmNsdWRlICJET01UaW1lci5oIgogI2luY2x1ZGUgIkRPTVdpbmRvdy5oIgog I2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKQEAgLTI5NSw3ICsyOTYsNyBAQCBib29sIFY4RE9N V2luZG93OjpXZWJTb2NrZXRFbmFibGVkKCkKICNpZiBFTkFCTEUoREFUQUJBU0UpCiBib29sIFY4 RE9NV2luZG93OjpPcGVuRGF0YWJhc2VFbmFibGVkKCkKIHsKLSAgICByZXR1cm4gV2ViQ29yZTo6 UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZGF0YWJhc2VFbmFibGVkKCk7CisgICAgcmV0dXJuIERh dGFiYXNlOjppc0F2YWlsYWJsZSgpOwogfQogI2VuZGlmCiAKSW5kZXg6IFdlYkNvcmUvZG9tL0Rv Y3VtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAJKHJldmlz aW9uIDUyOTk1KQorKysgV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgIkNhY2hlZENT U1N0eWxlU2hlZXQuaCIKICNpbmNsdWRlICJDaHJvbWUuaCIKKyNpbmNsdWRlICJDaHJvbWVDbGll bnQuaCIKICNpbmNsdWRlICJDb21tZW50LmgiCiAjaW5jbHVkZSAiQ29uc29sZS5oIgogI2luY2x1 ZGUgIkNvb2tpZUphci5oIgpAQCAtMTM3LDExICsxMzgsNiBAQAogI2luY2x1ZGUgPHd0Zi9QYXNz UmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCi0jaWYgRU5BQkxFKERB VEFCQVNFKQotI2luY2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQu aCIKLSNlbmRpZgotCiAjaWYgRU5BQkxFKFNIQVJFRF9XT1JLRVJTKQogI2luY2x1ZGUgIlNoYXJl ZFdvcmtlclJlcG9zaXRvcnkuaCIKICNlbmRpZgpAQCAtMzUwLDkgKzM0Niw2IEBAIERvY3VtZW50 OjpEb2N1bWVudChGcmFtZSogZnJhbWUsIGJvb2wgaXMKICAgICAsIG1fdXNlU2VjdXJlS2V5Ym9h cmRFbnRyeVdoZW5BY3RpdmUoZmFsc2UpCiAgICAgLCBtX2lzWEhUTUwoaXNYSFRNTCkKICAgICAs IG1fbnVtTm9kZUxpc3RDYWNoZXMoMCkKLSNpZiBFTkFCTEUoREFUQUJBU0UpCi0gICAgLCBtX2hh c09wZW5EYXRhYmFzZXMoZmFsc2UpCi0jZW5kaWYKICAgICAsIG1fdXNpbmdHZW9sb2NhdGlvbihm YWxzZSkKICNpZiBFTkFCTEUoV01MKQogICAgICwgbV9jb250YWluc1dNTENvbnRlbnQoZmFsc2Up CkBAIC01MDAsMTMgKzQ5Myw2IEBAIERvY3VtZW50Ojp+RG9jdW1lbnQoKQogICAgIGZvciAodW5z aWduZWQgaSA9IDA7IGkgPCBjb3VudDsgaSsrKQogICAgICAgICBkZWxldGVBbGxWYWx1ZXMobV9u YW1lQ29sbGVjdGlvbkluZm9baV0pOwogCi0jaWYgRU5BQkxFKERBVEFCQVNFKQotICAgIGlmICht X2RhdGFiYXNlVGhyZWFkKSB7Ci0gICAgICAgIEFTU0VSVChtX2RhdGFiYXNlVGhyZWFkLT50ZXJt aW5hdGlvblJlcXVlc3RlZCgpKTsKLSAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IDA7Ci0gICAg fQotI2VuZGlmCi0KICAgICBpZiAobV9zdHlsZVNoZWV0cykKICAgICAgICAgbV9zdHlsZVNoZWV0 cy0+ZG9jdW1lbnREZXN0cm95ZWQoKTsKIH0KQEAgLTQzOTQsNiArNDM4MCwyOSBAQCB2b2lkIERv Y3VtZW50OjpzZXRTZWN1cml0eU9yaWdpbihTZWN1cml0CiAgICAgaW5pdEROU1ByZWZldGNoKCk7 CiB9CiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisKK2Jvb2wgRG9jdW1lbnQ6OmlzRGF0YWJhc2VS ZWFkT25seSgpIGNvbnN0Cit7CisgICAgaWYgKCFwYWdlKCkgfHwgcGFnZSgpLT5zZXR0aW5ncygp LT5wcml2YXRlQnJvd3NpbmdFbmFibGVkKCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIHJl dHVybiBmYWxzZTsKK30KKwordm9pZCBEb2N1bWVudDo6ZGF0YWJhc2VFeGNlZWRlZFF1b3RhKGNv bnN0IFN0cmluZyYgbmFtZSkKK3sKKyAgICBQYWdlKiBjdXJyZW50UGFnZSA9IHBhZ2UoKTsKKyAg ICBpZiAoY3VycmVudFBhZ2UpCisgICAgICAgIGN1cnJlbnRQYWdlLT5jaHJvbWUoKS0+Y2xpZW50 KCktPmV4Y2VlZGVkRGF0YWJhc2VRdW90YShkb2N1bWVudCgpLT5mcmFtZSgpLCBuYW1lKTsKK30K KworI2VuZGlmCisKK2Jvb2wgRG9jdW1lbnQ6OmlzQ29udGV4dFRocmVhZCgpIGNvbnN0Cit7Cisg ICAgcmV0dXJuIFdURjo6aXNNYWluVGhyZWFkKCk7Cit9CisKIHZvaWQgRG9jdW1lbnQ6OnVwZGF0 ZVVSTEZvclB1c2hPclJlcGxhY2VTdGF0ZShjb25zdCBLVVJMJiB1cmwpCiB7CiAgICAgRnJhbWUq IGYgPSBmcmFtZSgpOwpAQCAtNDQ5NCw1NyArNDUwMyw2IEBAIERPTVNlbGVjdGlvbiogRG9jdW1l bnQ6OmdldFNlbGVjdGlvbigpIGMKICAgICByZXR1cm4gZnJhbWUoKSA/IGZyYW1lKCktPmRvbVdp bmRvdygpLT5nZXRTZWxlY3Rpb24oKSA6IDA7CiB9CiAKLSNpZiBFTkFCTEUoREFUQUJBU0UpCi0K LXZvaWQgRG9jdW1lbnQ6OmFkZE9wZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0g ICAgaWYgKCFtX29wZW5EYXRhYmFzZVNldCkKLSAgICAgICAgbV9vcGVuRGF0YWJhc2VTZXQuc2V0 KG5ldyBEYXRhYmFzZVNldCk7Ci0KLSAgICBBU1NFUlQoIW1fb3BlbkRhdGFiYXNlU2V0LT5jb250 YWlucyhkYXRhYmFzZSkpOwotICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5hZGQoZGF0YWJhc2UpOwot fQotCi12b2lkIERvY3VtZW50OjpyZW1vdmVPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRhdGFiYXNl KQotewotICAgIEFTU0VSVChtX29wZW5EYXRhYmFzZVNldCAmJiBtX29wZW5EYXRhYmFzZVNldC0+ Y29udGFpbnMoZGF0YWJhc2UpKTsKLSAgICBpZiAoIW1fb3BlbkRhdGFiYXNlU2V0KQotICAgICAg ICByZXR1cm47Ci0gICAgICAgIAotICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5yZW1vdmUoZGF0YWJh c2UpOwotfQotCi1EYXRhYmFzZVRocmVhZCogRG9jdW1lbnQ6OmRhdGFiYXNlVGhyZWFkKCkKLXsK LSAgICBpZiAoIW1fZGF0YWJhc2VUaHJlYWQgJiYgIW1faGFzT3BlbkRhdGFiYXNlcykgewotICAg ICAgICAvLyBDcmVhdGUgdGhlIGRhdGFiYXNlIHRocmVhZCBvbiBmaXJzdCByZXF1ZXN0IC0gYnV0 IG5vdCBpZiBhdCBsZWFzdCBvbmUgZGF0YWJhc2Ugd2FzIGFscmVhZHkgb3BlbmVkLAotICAgICAg ICAvLyBiZWNhdXNlIGluIHRoYXQgY2FzZSB3ZSBhbHJlYWR5IGhhZCBhIGRhdGFiYXNlIHRocmVh ZCBhbmQgdGVybWluYXRlZCBpdCBhbmQgc2hvdWxkIG5vdCBjcmVhdGUgYW5vdGhlci4KLSAgICAg ICAgbV9kYXRhYmFzZVRocmVhZCA9IERhdGFiYXNlVGhyZWFkOjpjcmVhdGUoKTsKLSAgICAgICAg aWYgKCFtX2RhdGFiYXNlVGhyZWFkLT5zdGFydCgpKQotICAgICAgICAgICAgbV9kYXRhYmFzZVRo cmVhZCA9IDA7Ci0gICAgfQotCi0gICAgcmV0dXJuIG1fZGF0YWJhc2VUaHJlYWQuZ2V0KCk7Ci19 Ci0KLXZvaWQgRG9jdW1lbnQ6OnN0b3BEYXRhYmFzZXMoKQotewotICAgIGlmIChtX29wZW5EYXRh YmFzZVNldCkgewotICAgICAgICBEYXRhYmFzZVNldDo6aXRlcmF0b3IgaSA9IG1fb3BlbkRhdGFi YXNlU2V0LT5iZWdpbigpOwotICAgICAgICBEYXRhYmFzZVNldDo6aXRlcmF0b3IgZW5kID0gbV9v cGVuRGF0YWJhc2VTZXQtPmVuZCgpOwotICAgICAgICBmb3IgKDsgaSAhPSBlbmQ7ICsraSkgewot ICAgICAgICAgICAgKCppKS0+c3RvcCgpOwotICAgICAgICAgICAgaWYgKG1fZGF0YWJhc2VUaHJl YWQpCi0gICAgICAgICAgICAgICAgbV9kYXRhYmFzZVRocmVhZC0+dW5zY2hlZHVsZURhdGFiYXNl VGFza3MoKmkpOwotICAgICAgICB9Ci0gICAgfQotICAgIAotICAgIGlmIChtX2RhdGFiYXNlVGhy ZWFkKQotICAgICAgICBtX2RhdGFiYXNlVGhyZWFkLT5yZXF1ZXN0VGVybWluYXRpb24oKTsKLX0K LQotI2VuZGlmCi0KICNpZiBFTkFCTEUoV01MKQogdm9pZCBEb2N1bWVudDo6cmVzZXRXTUxQYWdl U3RhdGUoKQogewpJbmRleDogV2ViQ29yZS9kb20vRG9jdW1lbnQuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL2RvbS9Eb2N1bWVudC5oCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvZG9tL0Rv Y3VtZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTkxNCwxNCArOTE0LDEyIEBAIHB1YmxpYzoKICAg ICBib29sIHByb2Nlc3NpbmdMb2FkRXZlbnQoKSBjb25zdCB7IHJldHVybiBtX3Byb2Nlc3NpbmdM b2FkRXZlbnQ7IH0KIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKLSAgICB2b2lkIGFkZE9wZW5EYXRh YmFzZShEYXRhYmFzZSopOwotICAgIHZvaWQgcmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKik7 Ci0gICAgRGF0YWJhc2VUaHJlYWQqIGRhdGFiYXNlVGhyZWFkKCk7ICAgLy8gQ3JlYXRlcyB0aGUg dGhyZWFkIGFzIG5lZWRlZCwgYnV0IG5vdCBpZiBpdCBoYXMgYmVlbiBhbHJlYWR5IHRlcm1pbmF0 ZWQuCi0gICAgdm9pZCBzZXRIYXNPcGVuRGF0YWJhc2VzKCkgeyBtX2hhc09wZW5EYXRhYmFzZXMg PSB0cnVlOyB9Ci0gICAgYm9vbCBoYXNPcGVuRGF0YWJhc2VzKCkgeyByZXR1cm4gbV9oYXNPcGVu RGF0YWJhc2VzOyB9Ci0gICAgdm9pZCBzdG9wRGF0YWJhc2VzKCk7CisgICAgdmlydHVhbCBib29s IGlzRGF0YWJhc2VSZWFkT25seSgpIGNvbnN0OworICAgIHZpcnR1YWwgdm9pZCBkYXRhYmFzZUV4 Y2VlZGVkUXVvdGEoY29uc3QgU3RyaW5nJiBuYW1lKTsKICNlbmRpZgogCisgICAgdmlydHVhbCBi b29sIGlzQ29udGV4dFRocmVhZCgpIGNvbnN0OworCiAgICAgdm9pZCBzZXRVc2luZ0dlb2xvY2F0 aW9uKGJvb2wgZikgeyBtX3VzaW5nR2VvbG9jYXRpb24gPSBmOyB9CiAgICAgYm9vbCB1c2luZ0dl b2xvY2F0aW9uKCkgY29uc3QgeyByZXR1cm4gbV91c2luZ0dlb2xvY2F0aW9uOyB9OwogCkBAIC0x MTgzLDEzICsxMTgxLDYgQEAgcHJpdmF0ZToKICAgICBKU1dyYXBwZXJDYWNoZU1hcCBtX3dyYXBw ZXJDYWNoZU1hcDsKICNlbmRpZgogCi0jaWYgRU5BQkxFKERBVEFCQVNFKQotICAgIFJlZlB0cjxE YXRhYmFzZVRocmVhZD4gbV9kYXRhYmFzZVRocmVhZDsKLSAgICBib29sIG1faGFzT3BlbkRhdGFi YXNlczsgICAgLy8gVGhpcyBuZXZlciBjaGFuZ2VzIGJhY2sgdG8gZmFsc2UsIGV2ZW4gYXMgdGhl IGRhdGFiYXNlIHRocmVhZCBpcyBjbG9zZWQuCi0gICAgdHlwZWRlZiBIYXNoU2V0PERhdGFiYXNl Kj4gRGF0YWJhc2VTZXQ7Ci0gICAgT3duUHRyPERhdGFiYXNlU2V0PiBtX29wZW5EYXRhYmFzZVNl dDsKLSNlbmRpZgotICAgIAogICAgIGJvb2wgbV91c2luZ0dlb2xvY2F0aW9uOwogCiAjaWYgRU5B QkxFKFdNTCkKSW5kZXg6IFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCShyZXZp c2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0yOCw3ICsyOCw4IEBACiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9u Q29udGV4dC5oIgogCiAjaW5jbHVkZSAiQWN0aXZlRE9NT2JqZWN0LmgiCi0jaW5jbHVkZSAiRG9j dW1lbnQuaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKKyNpbmNsdWRlICJEYXRhYmFzZVRo cmVhZC5oIgogI2luY2x1ZGUgIk1lc3NhZ2VQb3J0LmgiCiAjaW5jbHVkZSAiU2VjdXJpdHlPcmln aW4uaCIKICNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCkBAIC01Niw2ICs1Nyw5IEBAIHB1Ymxp YzoKIH07CiAKIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQo KQorI2lmIEVOQUJMRShEQVRBQkFTRSkKKyAgICA6IG1faGFzT3BlbkRhdGFiYXNlcyhmYWxzZSkK KyNlbmRpZgogewogfQogCkBAIC03Miw4ICs3Niw2NCBAQCBTY3JpcHRFeGVjdXRpb25Db250ZXh0 Ojp+U2NyaXB0RXhlY3V0aW9uCiAgICAgICAgIEFTU0VSVCgoKml0ZXIpLT5zY3JpcHRFeGVjdXRp b25Db250ZXh0KCkgPT0gdGhpcyk7CiAgICAgICAgICgqaXRlciktPmNvbnRleHREZXN0cm95ZWQo KTsKICAgICB9CisgICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpIHsKKyAgICAgICAgQVNTRVJUKG1f ZGF0YWJhc2VUaHJlYWQtPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpOworICAgICAgICBtX2RhdGFi YXNlVGhyZWFkID0gMDsKKyAgICB9CiB9CiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisKK0RhdGFi YXNlVGhyZWFkKiBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpkYXRhYmFzZVRocmVhZCgpCit7Cisg ICAgaWYgKCFtX2RhdGFiYXNlVGhyZWFkICYmICFtX2hhc09wZW5EYXRhYmFzZXMpIHsKKyAgICAg ICAgLy8gQ3JlYXRlIHRoZSBkYXRhYmFzZSB0aHJlYWQgb24gZmlyc3QgcmVxdWVzdCAtIGJ1dCBu b3QgaWYgYXQgbGVhc3Qgb25lIGRhdGFiYXNlIHdhcyBhbHJlYWR5IG9wZW5lZCwKKyAgICAgICAg Ly8gYmVjYXVzZSBpbiB0aGF0IGNhc2Ugd2UgYWxyZWFkeSBoYWQgYSBkYXRhYmFzZSB0aHJlYWQg YW5kIHRlcm1pbmF0ZWQgaXQgYW5kIHNob3VsZCBub3QgY3JlYXRlIGFub3RoZXIuCisgICAgICAg IG1fZGF0YWJhc2VUaHJlYWQgPSBEYXRhYmFzZVRocmVhZDo6Y3JlYXRlKCk7CisgICAgICAgIGlm ICghbV9kYXRhYmFzZVRocmVhZC0+c3RhcnQoKSkKKyAgICAgICAgICAgIG1fZGF0YWJhc2VUaHJl YWQgPSAwOworICAgIH0KKworICAgIHJldHVybiBtX2RhdGFiYXNlVGhyZWFkLmdldCgpOworfQor Cit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OmFkZE9wZW5EYXRhYmFzZShEYXRhYmFzZSog ZGF0YWJhc2UpCit7CisgICAgaWYgKCFtX29wZW5EYXRhYmFzZVNldCkKKyAgICAgICAgbV9vcGVu RGF0YWJhc2VTZXQuc2V0KG5ldyBEYXRhYmFzZVNldCgpKTsKKworICAgIEFTU0VSVCghbV9vcGVu RGF0YWJhc2VTZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7CisgICAgbV9vcGVuRGF0YWJhc2VTZXQt PmFkZChkYXRhYmFzZSk7Cit9CisKK3ZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6cmVtb3Zl T3BlbkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sKKyAgICBBU1NFUlQobV9vcGVuRGF0 YWJhc2VTZXQgJiYgbV9vcGVuRGF0YWJhc2VTZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7CisgICAg aWYgKCFtX29wZW5EYXRhYmFzZVNldCkKKyAgICAgICAgcmV0dXJuOworICAgIG1fb3BlbkRhdGFi YXNlU2V0LT5yZW1vdmUoZGF0YWJhc2UpOworfQorCit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OnN0b3BEYXRhYmFzZXMoRGF0YWJhc2VUYXNrU3luY2hyb25pemVyICpjbGVhbnVwU3luYykK K3sKKyAgICBpZiAobV9vcGVuRGF0YWJhc2VTZXQpIHsKKyAgICAgICAgRGF0YWJhc2VTZXQ6Oml0 ZXJhdG9yIGkgPSBtX29wZW5EYXRhYmFzZVNldC0+YmVnaW4oKTsKKyAgICAgICAgRGF0YWJhc2VT ZXQ6Oml0ZXJhdG9yIGVuZCA9IG1fb3BlbkRhdGFiYXNlU2V0LT5lbmQoKTsKKyAgICAgICAgZm9y ICg7IGkgIT0gZW5kOyArK2kpIHsKKyAgICAgICAgICAgICgqaSktPnN0b3AoKTsKKyAgICAgICAg ICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKQorICAgICAgICAgICAgICAgIG1fZGF0YWJhc2VUaHJl YWQtPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKCppKTsKKyAgICAgICAgfQorICAgIH0KKyAgICAK KyAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkKKyAgICAgICAgbV9kYXRhYmFzZVRocmVhZC0+cmVx dWVzdFRlcm1pbmF0aW9uKGNsZWFudXBTeW5jKTsKKyAgICBlbHNlIGlmIChjbGVhbnVwU3luYykK KyAgICAgICAgY2xlYW51cFN5bmMtPnRhc2tDb21wbGV0ZWQoKTsKK30KKworI2VuZGlmCisKIHZv aWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6cHJvY2Vzc01lc3NhZ2VQb3J0TWVzc2FnZXNTb29u KCkKIHsKICAgICBwb3N0VGFzayhQcm9jZXNzTWVzc2FnZXNTb29uVGFzazo6Y3JlYXRlKCkpOwpJ bmRleDogV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAkocmV2aXNpb24gNTI5OTUpCisr KyBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgJKHdvcmtpbmcgY29weSkKQEAg LTMzLDExICszMywxNyBAQAogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3Rm L1Bhc3NPd25QdHIuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0 Zi9SZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogICAgIGNsYXNzIEFjdGl2ZURPTU9iamVjdDsKKyNpZiBFTkFCTEUoREFUQUJBU0Up CisgICAgY2xhc3MgRGF0YWJhc2U7CisgICAgY2xhc3MgRGF0YWJhc2VUYXNrU3luY2hyb25pemVy OworICAgIGNsYXNzIERhdGFiYXNlVGhyZWFkOworI2VuZGlmCiAgICAgY2xhc3MgRE9NVGltZXI7 CiAgICAgY2xhc3MgTWVzc2FnZVBvcnQ7CiAgICAgY2xhc3MgU2VjdXJpdHlPcmlnaW47CkBAIC01 OSw2ICs2NSwxOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgYm9vbCBp c0RvY3VtZW50KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICAgICAgdmlydHVhbCBib29s IGlzV29ya2VyQ29udGV4dCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAKKyNpZiBFTkFCTEUo REFUQUJBU0UpCisgICAgICAgIHZpcnR1YWwgYm9vbCBpc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25z dCA9IDA7CisgICAgICAgIHZpcnR1YWwgdm9pZCBkYXRhYmFzZUV4Y2VlZGVkUXVvdGEoY29uc3Qg U3RyaW5nJiBuYW1lKSA9IDA7CisgICAgICAgIERhdGFiYXNlVGhyZWFkICpkYXRhYmFzZVRocmVh ZCgpOworICAgICAgICB2b2lkIHNldEhhc09wZW5EYXRhYmFzZXMoKSB7IG1faGFzT3BlbkRhdGFi YXNlcyA9IHRydWU7IH0KKyAgICAgICAgYm9vbCBoYXNPcGVuRGF0YWJhc2VzKCkgY29uc3QgeyBy ZXR1cm4gbV9oYXNPcGVuRGF0YWJhc2VzOyB9CisgICAgICAgIHZvaWQgYWRkT3BlbkRhdGFiYXNl KERhdGFiYXNlKik7CisgICAgICAgIHZvaWQgcmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKik7 CisgICAgICAgIC8vIFdoZW4gdGhlIGRhdGFiYXNlIGNsZWFudXAgaXMgZG9uZSwgY2xlYW51cFN5 bmMgd2lsbCBiZSBzaWduYWxsZWQuCisgICAgICAgIHZvaWQgc3RvcERhdGFiYXNlcyhEYXRhYmFz ZVRhc2tTeW5jaHJvbml6ZXIqKTsKKyNlbmRpZgorICAgICAgICB2aXJ0dWFsIGJvb2wgaXNDb250 ZXh0VGhyZWFkKCkgY29uc3QgPSAwOworCiAgICAgICAgIGNvbnN0IEtVUkwmIHVybCgpIGNvbnN0 IHsgcmV0dXJuIHZpcnR1YWxVUkwoKTsgfQogICAgICAgICBLVVJMIGNvbXBsZXRlVVJMKGNvbnN0 IFN0cmluZyYgdXJsKSBjb25zdCB7IHJldHVybiB2aXJ0dWFsQ29tcGxldGVVUkwodXJsKTsgfQog CkBAIC05Nyw2ICsxMTYsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHB1YmxpYzoK ICAgICAgICAgICAgIHZpcnR1YWwgflRhc2soKTsKICAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBw ZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikgPSAwOworICAgICAgICAgICAgLy8g Q2VydGFpbiB0YXNrcyBnZXQgbWFya2VkIHNwZWNpYWxseSBzbyB0aGF0IHRoZXkgYXJlbid0IGRp c2NhcmRlZCwgYW5kIGFyZSBleGVjdXRlZCwgd2hlbiB0aGUgY29udGV4dCBpcyBzaHV0dGluZyBk b3duIGl0cyBtZXNzYWdlIHF1ZXVlLgorICAgICAgICAgICAgdmlydHVhbCBib29sIGlzQ2xlYW51 cFRhc2soKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICB9OwogCiAgICAgICAgIHZp cnR1YWwgdm9pZCBwb3N0VGFzayhQYXNzT3duUHRyPFRhc2s+KSA9IDA7IC8vIEV4ZWN1dGVzIHRo ZSB0YXNrIG9uIGNvbnRleHQncyB0aHJlYWQgYXN5bmNocm9ub3VzbHkuCkBAIC0xMjksNiArMTUw LDEzIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQgcmVmU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCgpID0gMDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRlcmVmU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCgpID0gMDsKKworI2lmIEVOQUJMRShEQVRBQkFTRSkKKyAgICAg ICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX2RhdGFiYXNlVGhyZWFkOworICAgICAgICBib29s IG1faGFzT3BlbkRhdGFiYXNlczsgLy8gVGhpcyBuZXZlciBjaGFuZ2VzIGJhY2sgdG8gZmFsc2Us IGV2ZW4gYWZ0ZXIgdGhlIGRhdGFiYXNlIHRocmVhZCBpcyBjbG9zZWQuCisgICAgICAgIHR5cGVk ZWYgSGFzaFNldDxEYXRhYmFzZSAqPiBEYXRhYmFzZVNldDsKKyAgICAgICAgT3duUHRyPERhdGFi YXNlU2V0PiBtX29wZW5EYXRhYmFzZVNldDsKKyNlbmRpZgogICAgIH07CiAKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAJKHJldmlzaW9uIDUyOTk1KQor KysgV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NTks NyArNTU5LDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6c3RvcExvYWRpbmcoVW5sb2FkRXZlbgogCiAj aWYgRU5BQkxFKERBVEFCQVNFKQogICAgICAgICBpZiAoZGF0YWJhc2VQb2xpY3kgPT0gRGF0YWJh c2VQb2xpY3lTdG9wKQotICAgICAgICAgICAgZG9jLT5zdG9wRGF0YWJhc2VzKCk7CisgICAgICAg ICAgICBkb2MtPnN0b3BEYXRhYmFzZXMoMCk7CiAjZWxzZQogICAgIFVOVVNFRF9QQVJBTShkYXRh YmFzZVBvbGljeSk7CiAjZW5kaWYKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkocmV2aXNpb24gNTI5 OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01 Myw4ICs1Myw4IEBACiAjaW5jbHVkZSAiU1FMUmVzdWx0U2V0LmgiCiAjaW5jbHVkZSAiU1FMVHJh bnNhY3Rpb25DbGllbnQuaCIKICNpbmNsdWRlICJTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgi Ci0jaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KLSNlbmRpZgorCisjZW5kaWYgLy8gRU5BQkxF KERBVEFCQVNFKQogCiAjaWYgVVNFKEpTQykKICNpbmNsdWRlICJKU0RPTVdpbmRvdy5oIgpAQCAt NzMsNiArNzMsMTggQEAgY29uc3QgU3RyaW5nJiBEYXRhYmFzZTo6ZGF0YWJhc2VJbmZvVGFibAog CiAjaWYgRU5BQkxFKERBVEFCQVNFKQogCitzdGF0aWMgYm9vbCBpc0RhdGFiYXNlQXZhaWxhYmxl ID0gZmFsc2U7CisKK3ZvaWQgRGF0YWJhc2U6OnNldElzQXZhaWxhYmxlKGJvb2wgYXZhaWxhYmxl KQoreworICAgIGlzRGF0YWJhc2VBdmFpbGFibGUgPSBhdmFpbGFibGU7Cit9CisKK2Jvb2wgRGF0 YWJhc2U6OmlzQXZhaWxhYmxlKCkKK3sKKyAgICByZXR1cm4gaXNEYXRhYmFzZUF2YWlsYWJsZTsK K30KKwogc3RhdGljIE11dGV4JiBndWlkTXV0ZXgoKQogewogICAgIC8vIE5vdGU6IFdlIGRvbid0 IGhhdmUgdG8gdXNlIEF0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpYyBoZXJlIGJlY2F1c2UKQEAg LTEyMCwzOSArMTMyLDQxIEBAIHN0YXRpYyBjb25zdCBTdHJpbmcmIGRhdGFiYXNlVmVyc2lvbktl eSgKIAogc3RhdGljIGludCBndWlkRm9yT3JpZ2luQW5kTmFtZShjb25zdCBTdHJpbmcmIG9yaWdp biwgY29uc3QgU3RyaW5nJiBuYW1lKTsKIAotUGFzc1JlZlB0cjxEYXRhYmFzZT4gRGF0YWJhc2U6 Om9wZW5EYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29u c3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZSkKK1Bhc3NSZWZQdHI8 RGF0YWJhc2U+IERhdGFiYXNlOjpvcGVuRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAq Y29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lv biwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXpl LCBFeGNlcHRpb25Db2RlJiBlKQogewotICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2Vy KCkuY2FuRXN0YWJsaXNoRGF0YWJhc2UoZG9jdW1lbnQsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3Rp bWF0ZWRTaXplKSkgeworICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0 YWJsaXNoRGF0YWJhc2UoY29udGV4dCwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUp KSB7CiAgICAgICAgIC8vIEZJWE1FOiBUaGVyZSBzaG91bGQgYmUgYW4gZXhjZXB0aW9uIHJhaXNl ZCBoZXJlIGluIGFkZGl0aW9uIHRvIHJldHVybmluZyBhIG51bGwgRGF0YWJhc2Ugb2JqZWN0LiAg VGhlIHF1ZXN0aW9uIGhhcyBiZWVuIHJhaXNlZCB3aXRoIHRoZSBXSEFUV0cuCi0gICAgICAgIExP RyhTdG9yYWdlQVBJLCAiRGF0YWJhc2UgJXMgZm9yIG9yaWdpbiAlcyBub3QgYWxsb3dlZCB0byBi ZSBlc3RhYmxpc2hlZCIsIG5hbWUuYXNjaWkoKS5kYXRhKCksIGRvY3VtZW50LT5zZWN1cml0eU9y aWdpbigpLT50b1N0cmluZygpLmFzY2lpKCkuZGF0YSgpKTsKKyAgICAgICAgTE9HKFN0b3JhZ2VB UEksICJEYXRhYmFzZSAlcyBmb3Igb3JpZ2luICVzIG5vdCBhbGxvd2VkIHRvIGJlIGVzdGFibGlz aGVkIiwgbmFtZS5hc2NpaSgpLmRhdGEoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9T dHJpbmcoKS5hc2NpaSgpLmRhdGEoKSk7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAg IFJlZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2UgPSBhZG9wdFJlZihuZXcgRGF0YWJhc2UoZG9jdW1l bnQsIG5hbWUsIGV4cGVjdGVkVmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsK KyAgICBSZWZQdHI8RGF0YWJhc2U+IGRhdGFiYXNlID0gYWRvcHRSZWYobmV3IERhdGFiYXNlKGNv bnRleHQsIG5hbWUsIGV4cGVjdGVkVmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUp KTsKIAogICAgIGlmICghZGF0YWJhc2UtPm9wZW5BbmRWZXJpZnlWZXJzaW9uKGUpKSB7CiAgICAg ICAgIExPRyhTdG9yYWdlQVBJLCAiRmFpbGVkIHRvIG9wZW4gYW5kIHZlcmlmeSB2ZXJzaW9uIChl eHBlY3RlZCAlcykgb2YgZGF0YWJhc2UgJXMiLCBleHBlY3RlZFZlcnNpb24uYXNjaWkoKS5kYXRh KCksIGRhdGFiYXNlLT5kYXRhYmFzZURlYnVnTmFtZSgpLmFzY2lpKCkuZGF0YSgpKTsKLSAgICAg ICAgZG9jdW1lbnQtPnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CisgICAgICAg IGNvbnRleHQtPnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAgIERh dGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQo KSk7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIERhdGFiYXNlVHJhY2tlcjo6dHJh Y2tlcigpLnNldERhdGFiYXNlRGV0YWlscyhkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFt ZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpOwotCi0gICAgZG9jdW1lbnQtPnNldEhhc09w ZW5EYXRhYmFzZXMoKTsKKyAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5zZXREYXRhYmFz ZURldGFpbHMoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5hbWUsIGVz dGltYXRlZFNpemUpOwogCisgICAgY29udGV4dC0+c2V0SGFzT3BlbkRhdGFiYXNlcygpOwogI2lm IEVOQUJMRShJTlNQRUNUT1IpCi0gICAgaWYgKFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+ZnJhbWUo KS0+cGFnZSgpKQotICAgICAgICBwYWdlLT5pbnNwZWN0b3JDb250cm9sbGVyKCktPmRpZE9wZW5E YXRhYmFzZShkYXRhYmFzZS5nZXQoKSwgZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmhvc3Qo KSwgbmFtZSwgZXhwZWN0ZWRWZXJzaW9uKTsKKyAgICBpZiAoY29udGV4dC0+aXNEb2N1bWVudCgp KSB7CisgICAgICAgIERvY3VtZW50KiBkb2N1bWVudCA9IHN0YXRpY19jYXN0PERvY3VtZW50Kj4o Y29udGV4dCk7CisgICAgICAgIGlmIChQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKSkKKyAg ICAgICAgICAgIHBhZ2UtPmluc3BlY3RvckNvbnRyb2xsZXIoKS0+ZGlkT3BlbkRhdGFiYXNlKGRh dGFiYXNlLmdldCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5ob3N0KCksIG5hbWUsIGV4 cGVjdGVkVmVyc2lvbik7CisgICAgfQogI2VuZGlmCiAKICAgICByZXR1cm4gZGF0YWJhc2U7CiB9 CiAKLURhdGFiYXNlOjpEYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYg bmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxh eU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKK0RhdGFiYXNlOjpEYXRhYmFzZShT Y3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0 IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNp Z25lZCBsb25nIGVzdGltYXRlZFNpemUpCiAgICAgOiBtX3RyYW5zYWN0aW9uSW5Qcm9ncmVzcyhm YWxzZSkKICAgICAsIG1faXNUcmFuc2FjdGlvblF1ZXVlRW5hYmxlZCh0cnVlKQotICAgICwgbV9k b2N1bWVudChkb2N1bWVudCkKKyAgICAsIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dChjb250ZXh0 KQogICAgICwgbV9uYW1lKG5hbWUuY3Jvc3NUaHJlYWRTdHJpbmcoKSkKICAgICAsIG1fZ3VpZCgw KQogICAgICwgbV9leHBlY3RlZFZlcnNpb24oZXhwZWN0ZWRWZXJzaW9uLmNyb3NzVGhyZWFkU3Ry aW5nKCkpCkBAIC0xNjIsMTYgKzE3NiwxNSBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQq IGRvY3VtZW50LCBjCiAgICAgLCBtX3N0b3BwZWQoZmFsc2UpCiAgICAgLCBtX29wZW5lZChmYWxz ZSkKIHsKLSAgICBBU1NFUlQoZG9jdW1lbnQpOwotICAgIG1fbWFpblRocmVhZFNlY3VyaXR5T3Jp Z2luID0gZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCk7CisgICAgQVNTRVJUKG1fc2NyaXB0RXhl Y3V0aW9uQ29udGV4dC5nZXQoKSk7CisgICAgbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4gPSBt X3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCk7CiAgICAgbV9kYXRhYmFz ZVRocmVhZFNlY3VyaXR5T3JpZ2luID0gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4tPnRocmVh ZHNhZmVDb3B5KCk7Ci0KICAgICBpZiAobV9uYW1lLmlzTnVsbCgpKQogICAgICAgICBtX25hbWUg PSAiIjsKIAogICAgIFNjcmlwdENvbnRyb2xsZXI6OmluaXRpYWxpemVUaHJlYWRpbmcoKTsKIAot ICAgIG1fZ3VpZCA9IGd1aWRGb3JPcmlnaW5BbmROYW1lKG1fbWFpblRocmVhZFNlY3VyaXR5T3Jp Z2luLT50b1N0cmluZygpLCBuYW1lKTsKKyAgICBtX2d1aWQgPSBndWlkRm9yT3JpZ2luQW5kTmFt ZShzZWN1cml0eU9yaWdpbigpLT50b1N0cmluZygpLCBuYW1lKTsKIAogICAgIHsKICAgICAgICAg TXV0ZXhMb2NrZXIgbG9ja2VyKGd1aWRNdXRleCgpKTsKQEAgLTE4NSwyOCArMTk4LDQ2IEBAIERh dGFiYXNlOjpEYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGMKICAgICAgICAgaGFzaFNldC0+ YWRkKHRoaXMpOwogICAgIH0KIAotICAgIEFTU0VSVChtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVh ZCgpKTsKLQotICAgIG1fZmlsZW5hbWUgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxs UGF0aEZvckRhdGFiYXNlKG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLmdldCgpLCBtX25hbWUp OworICAgIEFTU0VSVChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkp OworICAgIG1fZmlsZW5hbWUgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxsUGF0aEZv ckRhdGFiYXNlKHNlY3VyaXR5T3JpZ2luKCksIG1fbmFtZSk7CiAKICAgICBEYXRhYmFzZVRyYWNr ZXI6OnRyYWNrZXIoKS5hZGRPcGVuRGF0YWJhc2UodGhpcyk7Ci0gICAgbV9kb2N1bWVudC0+YWRk T3BlbkRhdGFiYXNlKHRoaXMpOworICAgIGNvbnRleHQtPmFkZE9wZW5EYXRhYmFzZSh0aGlzKTsK IH0KIAotc3RhdGljIHZvaWQgZGVyZWZEb2N1bWVudCh2b2lkKiBkb2N1bWVudCkKLXsKLSAgICBz dGF0aWNfY2FzdDxEb2N1bWVudCo+KGRvY3VtZW50KS0+ZGVyZWYoKTsKLX0KK2NsYXNzIERlcmVm Q29udGV4dFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJs aWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8RGVyZWZDb250ZXh0VGFzaz4gY3JlYXRlKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IERl cmVmQ29udGV4dFRhc2soY29udGV4dCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZv cm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQorICAgIHsKKyAgICAgICAgbV9jb250ZXh0 LT5kZXJlZigpOworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29u c3QgeyByZXR1cm4gdHJ1ZTsgfQorCitwcml2YXRlOgorICAgIGV4cGxpY2l0IERlcmVmQ29udGV4 dFRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCkKKyAgICAgICAgOiBtX2NvbnRl eHQoY29udGV4dCkKKyAgICB7CisgICAgfQorCisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog bV9jb250ZXh0OworfTsKIAogRGF0YWJhc2U6On5EYXRhYmFzZSgpCiB7Ci0gICAgLy8gRGVyZWYg bV9kb2N1bWVudCBvbiB0aGUgbWFpbiB0aHJlYWQuCi0gICAgY2FsbE9uTWFpblRocmVhZChkZXJl ZkRvY3VtZW50LCBtX2RvY3VtZW50LnJlbGVhc2UoKS5yZWxlYXNlUmVmKCkpOworICAgIC8vIFRo ZSByZWZlcmVuY2UgdG8gdGhlIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgbmVlZHMgdG8gYmUgY2xl YXJlZCBvbiB0aGUgSmF2YVNjcmlwdCB0aHJlYWQuICBJZiB3ZSdyZSBvbiB0aGF0IHRocmVhZCBh bHJlYWR5LCB3ZSBjYW4ganVzdCBsZXQgdGhlIFJlZlB0cidzIGRlc3RydWN0aW9uIGRvIHRoZSBk ZXJlZmZpbmcuCisgICAgaWYgKCFtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlzQ29udGV4dFRo cmVhZCgpKQorICAgICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKERlcmVm Q29udGV4dFRhc2s6OmNyZWF0ZShtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQucmVsZWFzZSgpLnJl bGVhc2VSZWYoKSkpOwogfQogCiBib29sIERhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbihF eGNlcHRpb25Db2RlJiBlKQogewotICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQo KSkKKyAgICBpZiAoIW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkK ICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIG1fZGF0YWJhc2VBdXRob3JpemVyID0gRGF0YWJh c2VBdXRob3JpemVyOjpjcmVhdGUoKTsKIApAQCAtMjE0LDcgKzI0NSw3IEBAIGJvb2wgRGF0YWJh c2U6Om9wZW5BbmRWZXJpZnlWZXJzaW9uKEV4Y2UKICAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6 ZXIgc3luY2hyb25pemVyOwogICAgIE93blB0cjxEYXRhYmFzZU9wZW5UYXNrPiB0YXNrID0gRGF0 YWJhc2VPcGVuVGFzazo6Y3JlYXRlKHRoaXMsICZzeW5jaHJvbml6ZXIsIGUsIHN1Y2Nlc3MpOwog Ci0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNr KHRhc2sucmVsZWFzZSgpKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNl VGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CiAgICAgc3lu Y2hyb25pemVyLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOwogCiAgICAgcmV0dXJuIHN1Y2Nlc3M7 CkBAIC0zMDksNDMgKzM0MCw2MiBAQCBib29sIERhdGFiYXNlOjp2ZXJzaW9uTWF0Y2hlc0V4cGVj dGVkKCkgCiAKIHZvaWQgRGF0YWJhc2U6Om1hcmtBc0RlbGV0ZWRBbmRDbG9zZSgpCiB7Ci0gICAg aWYgKG1fZGVsZXRlZCB8fCAhbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAo bV9kZWxldGVkIHx8ICFtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkp CiAgICAgICAgIHJldHVybjsKIAogICAgIExPRyhTdG9yYWdlQVBJLCAiTWFya2luZyAlcyAoJXAp IGFzIGRlbGV0ZWQiLCBzdHJpbmdJZGVudGlmaWVyKCkuYXNjaWkoKS5kYXRhKCksIHRoaXMpOwog ICAgIG1fZGVsZXRlZCA9IHRydWU7CiAKLSAgICBpZiAobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJl YWQoKS0+dGVybWluYXRpb25SZXF1ZXN0ZWQoKSkgeworICAgIGlmIChtX3NjcmlwdEV4ZWN1dGlv bkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpIHsKICAg ICAgICAgTE9HKFN0b3JhZ2VBUEksICJEYXRhYmFzZSBoYW5kbGUgJXAgaXMgb24gYSB0ZXJtaW5h dGVkIERhdGFiYXNlVGhyZWFkLCBjYW5ub3QgYmUgbWFya2VkIGZvciBub3JtYWwgY2xvc3VyZVxu IiwgdGhpcyk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX2RvY3VtZW50LT5kYXRh YmFzZVRocmVhZCgpLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsKKyAgICBtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRh c2tzKHRoaXMpOwogCiAgICAgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyIHN5bmNocm9uaXplcjsK ICAgICBPd25QdHI8RGF0YWJhc2VDbG9zZVRhc2s+IHRhc2sgPSBEYXRhYmFzZUNsb3NlVGFzazo6 Y3JlYXRlKHRoaXMsICZzeW5jaHJvbml6ZXIpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VU aHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICBtX3Nj cmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRl VGFzayh0YXNrLnJlbGVhc2UoKSk7CiAgICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNrQ29tcGxl dGlvbigpOwogfQogCi1zdGF0aWMgdm9pZCBkb2N1bWVudFJlbW92ZU9wZW5EYXRhYmFzZSh2b2lk KiBjb250ZXh0KQotewotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7Ci0gICAgRGF0YWJhc2Uq IGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8RGF0YWJhc2UqPihjb250ZXh0KTsKLSAgICBkYXRhYmFz ZS0+ZG9jdW1lbnQoKS0+cmVtb3ZlT3BlbkRhdGFiYXNlKGRhdGFiYXNlKTsKLSAgICBkYXRhYmFz ZS0+ZGVyZWYoKTsKLX0KK2NsYXNzIENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrIDogcHVi bGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQ YXNzT3duUHRyPENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrPiBjcmVhdGUoRGF0YWJhc2Ug KmRhdGFiYXNlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBDb250ZXh0UmVtb3ZlT3BlbkRh dGFiYXNlVGFzayhkYXRhYmFzZSk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1U YXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQpCisgICAgeworICAgICAgICBjb250 ZXh0LT5yZW1vdmVPcGVuRGF0YWJhc2UobV9kYXRhYmFzZSk7CisgICAgICAgIERhdGFiYXNlVHJh Y2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShtX2RhdGFiYXNlKTsKKyAgICAgICAg Ly8gUmVmZmVkIGluIERhdGFiYXNlOjpjbG9zZSgpLgorICAgICAgICBtX2RhdGFiYXNlLT5kZXJl ZigpOworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyBy ZXR1cm4gdHJ1ZTsgfQorCitwcml2YXRlOgorICAgIGV4cGxpY2l0IENvbnRleHRSZW1vdmVPcGVu RGF0YWJhc2VUYXNrKERhdGFiYXNlICpkYXRhYmFzZSkgOiBtX2RhdGFiYXNlKGRhdGFiYXNlKQor ICAgIHsKKyAgICB9CisKKyAgICBEYXRhYmFzZSogbV9kYXRhYmFzZTsKK307CiAKIHZvaWQgRGF0 YWJhc2U6OmNsb3NlKCkKIHsKICAgICBpZiAoIW1fb3BlbmVkKQogICAgICAgICByZXR1cm47CiAK LSAgICBBU1NFUlQobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSk7Ci0gICAgQVNTRVJUKGN1 cnJlbnRUaHJlYWQoKSA9PSBkb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJ RCgpKTsKKyAgICBBU1NFUlQobV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVh ZCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IG1fc2NyaXB0RXhlY3V0aW9uQ29u dGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgbV9zcWxpdGVEYXRh YmFzZS5jbG9zZSgpOwotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnJlY29yZERh dGFiYXNlQ2xvc2VkKHRoaXMpOworICAgIC8vIE11c3QgcmVmKCkgYmVmb3JlIGNhbGxpbmcgZGF0 YWJhc2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VDbG9zZWQoKS4KKyAgICByZWYoKTsgLy8gZGVy ZWYoKSBjYWxsZWQgYnkgQ29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2suCisgICAgbV9zY3Jp cHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNsb3Nl ZCh0aGlzKTsKICAgICBtX29wZW5lZCA9IGZhbHNlOwogCiAgICAgewpAQCAtMzYyLDExICs0MTIs OCBAQCB2b2lkIERhdGFiYXNlOjpjbG9zZSgpCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBtX2Rv Y3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsK LQotICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZSh0aGlz KTsKLSAgICByZWYoKTsgIC8vIGRlcmVmKCkgY2FsbGVkIGluIGRvY3VtZW50UmVtb3ZlT3BlbkRh dGFiYXNlKCkKLSAgICBjYWxsT25NYWluVGhyZWFkKGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNl LCB0aGlzKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkt PnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKHRoaXMpOworICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29u dGV4dC0+cG9zdFRhc2soQ29udGV4dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZSh0aGlz KSk7CiB9CiAKIHZvaWQgRGF0YWJhc2U6OnN0b3AoKQpAQCAtNTMyLDggKzU3OSw4IEBAIGJvb2wg RGF0YWJhc2U6OnBlcmZvcm1PcGVuQW5kVmVyaWZ5KEV4Y2UKICAgICAvLyBBbGwgY2hlY2tzIHBh c3NlZCBhbmQgd2Ugc3RpbGwgaGF2ZSBhIGhhbmRsZSB0byB0aGlzIGRhdGFiYXNlIGZpbGUuCiAg ICAgLy8gTWFrZSBzdXJlIERhdGFiYXNlVGhyZWFkIGNsb3NlcyBpdCB3aGVuIERhdGFiYXNlVGhy ZWFkIGdvZXMgYXdheS4KICAgICBtX29wZW5lZCA9IHRydWU7Ci0gICAgaWYgKG1fZG9jdW1lbnQt PmRhdGFiYXNlVGhyZWFkKCkpCi0gICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkt PnJlY29yZERhdGFiYXNlT3Blbih0aGlzKTsKKyAgICBpZiAobV9zY3JpcHRFeGVjdXRpb25Db250 ZXh0LT5kYXRhYmFzZVRocmVhZCgpKQorICAgICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQt PmRhdGFiYXNlVGhyZWFkKCktPnJlY29yZERhdGFiYXNlT3Blbih0aGlzKTsKIAogICAgIHJldHVy biB0cnVlOwogfQpAQCAtNTY3LDMyICs2MTQsNTMgQEAgdm9pZCBEYXRhYmFzZTo6c2NoZWR1bGVU cmFuc2FjdGlvbigpCiAgICAgICAgIG1fdHJhbnNhY3Rpb25RdWV1ZS5yZW1vdmVGaXJzdCgpOwog ICAgIH0KIAotICAgIGlmICh0cmFuc2FjdGlvbiAmJiBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVh ZCgpKSB7CisgICAgaWYgKHRyYW5zYWN0aW9uICYmIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ ZGF0YWJhc2VUaHJlYWQoKSkgewogICAgICAgICBPd25QdHI8RGF0YWJhc2VUcmFuc2FjdGlvblRh c2s+IHRhc2sgPSBEYXRhYmFzZVRyYW5zYWN0aW9uVGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uKTsK ICAgICAgICAgTE9HKFN0b3JhZ2VBUEksICJTY2hlZHVsaW5nIERhdGFiYXNlVHJhbnNhY3Rpb25U YXNrICVwIGZvciB0cmFuc2FjdGlvbiAlcFxuIiwgdGFzay5nZXQoKSwgdGFzay0+dHJhbnNhY3Rp b24oKSk7CiAgICAgICAgIG1fdHJhbnNhY3Rpb25JblByb2dyZXNzID0gdHJ1ZTsKLSAgICAgICAg bV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgp KTsKKyAgICAgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5z Y2hlZHVsZVRhc2sodGFzay5yZWxlYXNlKCkpOwogICAgIH0gZWxzZQogICAgICAgICBtX3RyYW5z YWN0aW9uSW5Qcm9ncmVzcyA9IGZhbHNlOwogfQogCiB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRy YW5zYWN0aW9uU3RlcChTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24sIGJvb2wgaW1tZWRpYXRl bHkpCiB7Ci0gICAgaWYgKCFtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKQorICAgIGlmICgh bV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpKQogICAgICAgICByZXR1 cm47CiAKICAgICBPd25QdHI8RGF0YWJhc2VUcmFuc2FjdGlvblRhc2s+IHRhc2sgPSBEYXRhYmFz ZVRyYW5zYWN0aW9uVGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uKTsKICAgICBMT0coU3RvcmFnZUFQ SSwgIlNjaGVkdWxpbmcgRGF0YWJhc2VUcmFuc2FjdGlvblRhc2sgJXAgZm9yIHRoZSB0cmFuc2Fj dGlvbiBzdGVwXG4iLCB0YXNrLmdldCgpKTsKICAgICBpZiAoaW1tZWRpYXRlbHkpCi0gICAgICAg IG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNr LnJlbGVhc2UoKSk7CisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VU aHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKICAgICBlbHNl Ci0gICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0YXNr LnJlbGVhc2UoKSk7CisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VU aHJlYWQoKS0+c2NoZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKIH0KIAorY2xhc3MgRGVsaXZl clBlbmRpbmdDYWxsYmFja1Rhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFz ayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8RGVsaXZlclBlbmRpbmdDYWxsYmFj a1Rhc2s+IGNyZWF0ZShTUUxUcmFuc2FjdGlvbiAqdHJhbnNhY3Rpb24pCisgICAgeworICAgICAg ICByZXR1cm4gbmV3IERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrKHRyYW5zYWN0aW9uKTsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCopCisgICAgeworICAgICAgICBtX3RyYW5zYWN0aW9uLT5wZXJmb3JtUGVuZGluZ0NhbGxiYWNr KCk7CisgICAgfQorCitwcml2YXRlOgorICAgIGV4cGxpY2l0IERlbGl2ZXJQZW5kaW5nQ2FsbGJh Y2tUYXNrKFBhc3NSZWZQdHI8U1FMVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKQorICAgICAgICA6 IG1fdHJhbnNhY3Rpb24odHJhbnNhY3Rpb24pCisgICAgeworICAgIH0KKworICAgIFJlZlB0cjxT UUxUcmFuc2FjdGlvbj4gbV90cmFuc2FjdGlvbjsKK307CisKIHZvaWQgRGF0YWJhc2U6OnNjaGVk dWxlVHJhbnNhY3Rpb25DYWxsYmFjayhTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0g ICAgdHJhbnNhY3Rpb24tPnJlZigpOwotICAgIGNhbGxPbk1haW5UaHJlYWQoZGVsaXZlclBlbmRp bmdDYWxsYmFjaywgdHJhbnNhY3Rpb24pOworICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ cG9zdFRhc2soCisgICAgICAgIERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrOjpjcmVhdGUodHJh bnNhY3Rpb24pKTsKIH0KIAogVmVjdG9yPFN0cmluZz4gRGF0YWJhc2U6OnBlcmZvcm1HZXRUYWJs ZU5hbWVzKCkKQEAgLTYyNiwxMiArNjk0LDEyIEBAIFZlY3RvcjxTdHJpbmc+IERhdGFiYXNlOjpw ZXJmb3JtR2V0VGFibGUKIAogU1FMVHJhbnNhY3Rpb25DbGllbnQqIERhdGFiYXNlOjp0cmFuc2Fj dGlvbkNsaWVudCgpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhy ZWFkKCktPnRyYW5zYWN0aW9uQ2xpZW50KCk7CisgICAgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9u Q29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+dHJhbnNhY3Rpb25DbGllbnQoKTsKIH0KIAogU1FM VHJhbnNhY3Rpb25Db29yZGluYXRvciogRGF0YWJhc2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3Io KSBjb25zdAogewotICAgIHJldHVybiBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT50cmFu c2FjdGlvbkNvb3JkaW5hdG9yKCk7CisgICAgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4 dC0+ZGF0YWJhc2VUaHJlYWQoKS0+dHJhbnNhY3Rpb25Db29yZGluYXRvcigpOwogfQogCiBTdHJp bmcgRGF0YWJhc2U6OnZlcnNpb24oKSBjb25zdApAQCAtNjQyLDI1ICs3MTAsMTggQEAgU3RyaW5n IERhdGFiYXNlOjp2ZXJzaW9uKCkgY29uc3QKICAgICByZXR1cm4gZ3VpZFRvVmVyc2lvbk1hcCgp LmdldChtX2d1aWQpLnRocmVhZHNhZmVDb3B5KCk7CiB9CiAKLXZvaWQgRGF0YWJhc2U6OmRlbGl2 ZXJQZW5kaW5nQ2FsbGJhY2sodm9pZCogY29udGV4dCkKLXsKLSAgICBTUUxUcmFuc2FjdGlvbiog dHJhbnNhY3Rpb24gPSBzdGF0aWNfY2FzdDxTUUxUcmFuc2FjdGlvbio+KGNvbnRleHQpOwotICAg IHRyYW5zYWN0aW9uLT5wZXJmb3JtUGVuZGluZ0NhbGxiYWNrKCk7Ci0gICAgdHJhbnNhY3Rpb24t PmRlcmVmKCk7IC8vIFdhcyByZWYnZCBpbiBzY2hlZHVsZVRyYW5zYWN0aW9uQ2FsbGJhY2soKS4K LX0KLQogVmVjdG9yPFN0cmluZz4gRGF0YWJhc2U6OnRhYmxlTmFtZXMoKQogewogICAgIC8vIEZJ WE1FOiBOb3QgdXNpbmcgdGhyZWFkc2FmZUNvcHkgb24gdGhlc2Ugc3RyaW5ncyBsb29rcyBvayBz aW5jZSB0aHJlYWRzIHRha2Ugc3RyaWN0IHR1cm5zCiAgICAgLy8gaW4gZGVhbGluZyB3aXRoIHRo ZW0uIEhvd2V2ZXIsIGlmIHRoZSBjb2RlIGNoYW5nZXMsIHRoaXMgbWF5IG5vdCBiZSB0cnVlIGFu eW1vcmUuCiAgICAgVmVjdG9yPFN0cmluZz4gcmVzdWx0OwotICAgIGlmICghbV9kb2N1bWVudC0+ ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAoIW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0 YWJhc2VUaHJlYWQoKSkKICAgICAgICAgcmV0dXJuIHJlc3VsdDsKIAogICAgIERhdGFiYXNlVGFz a1N5bmNocm9uaXplciBzeW5jaHJvbml6ZXI7CiAgICAgT3duUHRyPERhdGFiYXNlVGFibGVOYW1l c1Rhc2s+IHRhc2sgPSBEYXRhYmFzZVRhYmxlTmFtZXNUYXNrOjpjcmVhdGUodGhpcywgJnN5bmNo cm9uaXplciwgcmVzdWx0KTsKIAotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNj aGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CisgICAgbV9zY3JpcHRFeGVjdXRp b25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5y ZWxlYXNlKCkpOwogICAgIHN5bmNocm9uaXplci53YWl0Rm9yVGFza0NvbXBsZXRpb24oKTsKIAog ICAgIHJldHVybiByZXN1bHQ7CkBAIC02NzYsOSArNzM3LDkgQEAgdm9pZCBEYXRhYmFzZTo6c2V0 RXhwZWN0ZWRWZXJzaW9uKGNvbnN0IAogCiBTZWN1cml0eU9yaWdpbiogRGF0YWJhc2U6OnNlY3Vy aXR5T3JpZ2luKCkgY29uc3QKIHsKLSAgICBpZiAoaXNNYWluVGhyZWFkKCkpCisgICAgaWYgKHNj cmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNDb250ZXh0VGhyZWFkKCkpCiAgICAgICAgIHJldHVy biBtX21haW5UaHJlYWRTZWN1cml0eU9yaWdpbi5nZXQoKTsKLSAgICBpZiAoY3VycmVudFRocmVh ZCgpID09IGRvY3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpCisgICAg aWYgKGN1cnJlbnRUaHJlYWQoKSA9PSBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNl VGhyZWFkKCktPmdldFRocmVhZElEKCkpCiAgICAgICAgIHJldHVybiBtX2RhdGFiYXNlVGhyZWFk U2VjdXJpdHlPcmlnaW4uZ2V0KCk7CiAgICAgcmV0dXJuIDA7CiB9CkBAIC03MDYsNiArNzY3LDYg QEAgU3RyaW5nIERhdGFiYXNlOjpmaWxlTmFtZSgpIGNvbnN0CiAgICAgcmV0dXJuIG1fZmlsZW5h bWUudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAotI2VuZGlmCisjZW5kaWYgLy8gRU5BQkxFKERBVEFC QVNFKQogCi19Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2Uv RGF0YWJhc2UuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAkocmV2 aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAkod29ya2luZyBjb3B5 KQpAQCAtNTIsNyArNTIsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIERhdGFiYXNl QXV0aG9yaXplcjsKIGNsYXNzIERhdGFiYXNlVGhyZWFkOwotY2xhc3MgRG9jdW1lbnQ7CitjbGFz cyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogY2xhc3MgU1FMUmVzdWx0U2V0OwogY2xhc3MgU1FM VHJhbnNhY3Rpb25DYWxsYmFjazsKIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ2xpZW50OwpAQCAtNjcs MTAgKzY3LDEzIEBAIGNsYXNzIERhdGFiYXNlIDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQKICAg ICBmcmllbmQgY2xhc3MgU1FMU3RhdGVtZW50OwogICAgIGZyaWVuZCBjbGFzcyBTUUxUcmFuc2Fj dGlvbjsKIHB1YmxpYzoKKyAgICBzdGF0aWMgdm9pZCBzZXRJc0F2YWlsYWJsZShib29sKTsKKyAg ICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgpOworCiAgICAgfkRhdGFiYXNlKCk7CiAKIC8vIERp cmVjdCBzdXBwb3J0IGZvciB0aGUgRE9NIEFQSQotICAgIHN0YXRpYyBQYXNzUmVmUHRyPERhdGFi YXNlPiBvcGVuRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUs IGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1l LCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICBzdGF0 aWMgUGFzc1JlZlB0cjxEYXRhYmFzZT4gb3BlbkRhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgKmNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZl cnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVk U2l6ZSwgRXhjZXB0aW9uQ29kZSYpOwogICAgIFN0cmluZyB2ZXJzaW9uKCkgY29uc3Q7CiAgICAg dm9pZCBjaGFuZ2VWZXJzaW9uKGNvbnN0IFN0cmluZyYgb2xkVmVyc2lvbiwgY29uc3QgU3RyaW5n JiBuZXdWZXJzaW9uLAogICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPFNRTFRyYW5z YWN0aW9uQ2FsbGJhY2s+IGNhbGxiYWNrLCBQYXNzUmVmUHRyPFNRTFRyYW5zYWN0aW9uRXJyb3JD YWxsYmFjaz4gZXJyb3JDYWxsYmFjaywKQEAgLTg3LDcgKzkwLDcgQEAgcHVibGljOgogCiAgICAg VmVjdG9yPFN0cmluZz4gdGFibGVOYW1lcygpOwogCi0gICAgRG9jdW1lbnQqIGRvY3VtZW50KCkg Y29uc3QgeyByZXR1cm4gbV9kb2N1bWVudC5nZXQoKTsgfQorICAgIFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSBjb25zdCB7IHJldHVybiBtX3NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQuZ2V0KCk7IH0KICAgICBTZWN1cml0eU9yaWdpbiogc2VjdXJpdHlPcmln aW4oKSBjb25zdDsKICAgICBTdHJpbmcgc3RyaW5nSWRlbnRpZmllcigpIGNvbnN0OwogICAgIFN0 cmluZyBkaXNwbGF5TmFtZSgpIGNvbnN0OwpAQCAtMTIzLDggKzEyNiw5IEBAIHB1YmxpYzoKICAg ICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkgY29u c3Q7CiAKIHByaXZhdGU6Ci0gICAgRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBT dHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLAotICAgICAgICAgICAg IGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7 CisgICAgRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqY29udGV4dCwgY29uc3QgU3Ry aW5nJiBuYW1lLAorICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBj b25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLAorICAgICAgICAgICAgIHVuc2lnbmVkIGxvbmcgZXN0 aW1hdGVkU2l6ZSk7CiAKICAgICBib29sIG9wZW5BbmRWZXJpZnlWZXJzaW9uKEV4Y2VwdGlvbkNv ZGUmKTsKIApAQCAtMTM5LDcgKzE0Myw3IEBAIHByaXZhdGU6CiAKICAgICBzdGF0aWMgdm9pZCBk ZWxpdmVyUGVuZGluZ0NhbGxiYWNrKHZvaWQqKTsKIAotICAgIFJlZlB0cjxEb2N1bWVudD4gbV9k b2N1bWVudDsKKyAgICBSZWZQdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dD4gbV9zY3JpcHRFeGVj dXRpb25Db250ZXh0OwogICAgIFJlZlB0cjxTZWN1cml0eU9yaWdpbj4gbV9tYWluVGhyZWFkU2Vj dXJpdHlPcmlnaW47CiAgICAgUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBtX2RhdGFiYXNlVGhyZWFk U2VjdXJpdHlPcmlnaW47CiAgICAgU3RyaW5nIG1fbmFtZTsKSW5kZXg6IFdlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRhc2suaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VU YXNrLmgJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5o CSh3b3JraW5nIGNvcHkpCkBAIC01MCwxNiArNTAsMTUgQEAgY2xhc3MgVmVyc2lvbkNoYW5nZUNh bGxiYWNrOwogLy8gQ2FuIGJlIHVzZWQgdG8gd2FpdCB1bnRpbCBEYXRhYmFzZVRhc2sgaXMgY29t cGxldGVkLgogLy8gSGFzIHRvIGJlIHBhc3NlZCBpbnRvIERhdGFiYXNlVGFzazo6Y3JlYXRlIHRv IGJlIGFzc29jaWF0ZWQgd2l0aCB0aGUgdGFzay4KIGNsYXNzIERhdGFiYXNlVGFza1N5bmNocm9u aXplciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7Ci0gICAgZnJpZW5kIGNsYXNzIERhdGFiYXNlVGFz azsKIHB1YmxpYzoKICAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIoKTsKIAogICAgIC8vIENh bGxlZCBmcm9tIG1haW4gdGhyZWFkIHRvIHdhaXQgdW50aWwgdGFzayBpcyBjb21wbGV0ZWQuCiAg ICAgdm9pZCB3YWl0Rm9yVGFza0NvbXBsZXRpb24oKTsKIAotcHJpdmF0ZToKICAgICAvLyBDYWxs ZWQgYnkgdGhlIHRhc2suCiAgICAgdm9pZCB0YXNrQ29tcGxldGVkKCk7Citwcml2YXRlOgogCiAg ICAgYm9vbCBtX3Rhc2tDb21wbGV0ZWQ7CiAgICAgTXV0ZXggbV9zeW5jaHJvbm91c011dGV4OwpJ bmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdl YkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDYg KzQ0LDcgQEAgRGF0YWJhc2VUaHJlYWQ6OkRhdGFiYXNlVGhyZWFkKCkKICAgICA6IG1fdGhyZWFk SUQoMCkKICAgICAsIG1fdHJhbnNhY3Rpb25DbGllbnQobmV3IFNRTFRyYW5zYWN0aW9uQ2xpZW50 KCkpCiAgICAgLCBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IobmV3IFNRTFRyYW5zYWN0aW9uQ29v cmRpbmF0b3IoKSkKKyAgICAsIG1fY2xlYW51cFN5bmMoMCkKIHsKICAgICBtX3NlbGZSZWYgPSB0 aGlzOwogfQpAQCAtNTEsNiArNTIsNyBAQCBEYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQo KQogRGF0YWJhc2VUaHJlYWQ6On5EYXRhYmFzZVRocmVhZCgpCiB7CiAgICAgLy8gRklYTUU6IEFu eSBjbGVhbnVwIHJlcXVpcmVkIGhlcmU/ICBTaW5jZSB0aGUgdGhyZWFkIGRlbGV0ZXMgaXRzZWxm IGFmdGVyIHJ1bm5pbmcgaXRzIGRldGFjaGVkIGNvdXJzZSwgSSBkb24ndCB0aGluayBzby4gIExl dHMgYmUgc3VyZS4KKyAgICBBU1NFUlQodGVybWluYXRpb25SZXF1ZXN0ZWQoKSk7CiB9CiAKIGJv b2wgRGF0YWJhc2VUaHJlYWQ6OnN0YXJ0KCkKQEAgLTY1LDggKzY3LDEwIEBAIGJvb2wgRGF0YWJh c2VUaHJlYWQ6OnN0YXJ0KCkKICAgICByZXR1cm4gbV90aHJlYWRJRDsKIH0KIAotdm9pZCBEYXRh YmFzZVRocmVhZDo6cmVxdWVzdFRlcm1pbmF0aW9uKCkKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJl cXVlc3RUZXJtaW5hdGlvbihEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgKmNsZWFudXBTeW5jKQog eworICAgIEFTU0VSVCghbV9jbGVhbnVwU3luYyk7CisgICAgbV9jbGVhbnVwU3luYyA9IGNsZWFu dXBTeW5jOwogICAgIExPRyhTdG9yYWdlQVBJLCAiRGF0YWJhc2VUaHJlYWQgJXAgd2FzIGFza2Vk IHRvIHRlcm1pbmF0ZVxuIiwgdGhpcyk7CiAgICAgbV9xdWV1ZS5raWxsKCk7CiB9CkBAIC0xMTUs OSArMTE5LDE0IEBAIHZvaWQqIERhdGFiYXNlVGhyZWFkOjpkYXRhYmFzZVRocmVhZCgpCiAgICAg Ly8gRGV0YWNoIHRoZSB0aHJlYWQgc28gaXRzIHJlc291cmNlcyBhcmUgbm8gbG9uZ2VyIG9mIGFu eSBjb25jZXJuIHRvIGFueW9uZSBlbHNlCiAgICAgZGV0YWNoVGhyZWFkKG1fdGhyZWFkSUQpOwog CisgICAgRGF0YWJhc2VUYXNrU3luY2hyb25pemVyKiBjbGVhbnVwU3luYyA9IG1fY2xlYW51cFN5 bmM7CisgICAgCiAgICAgLy8gQ2xlYXIgdGhlIHNlbGYgcmVmcHRyLCBwb3NzaWJseSByZXN1bHRp bmcgaW4gZGVsZXRpb24KICAgICBtX3NlbGZSZWYgPSAwOwogCisgICAgaWYgKGNsZWFudXBTeW5j KSAvLyBTb21lb25lIHdhbnRlZCB0byBrbm93IHdoZW4gd2Ugd2VyZSBkb25lIGNsZWFuaW5nIHVw LgorICAgICAgICBjbGVhbnVwU3luYy0+dGFza0NvbXBsZXRlZCgpOworCiAgICAgcmV0dXJuIDA7 CiB9CiAKQEAgLTE2Miw2ICsxNzEsNSBAQCB2b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxl RGF0YWJhc2VUCiAgICAgU2FtZURhdGFiYXNlUHJlZGljYXRlIHByZWRpY2F0ZShkYXRhYmFzZSk7 CiAgICAgbV9xdWV1ZS5yZW1vdmVJZihwcmVkaWNhdGUpOwogfQotCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCiAjZW5kaWYKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCShyZXZpc2lvbiA1 Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCSh3b3JraW5nIGNvcHkp CkBAIC00Myw2ICs0Myw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0YWJhc2U7 CiBjbGFzcyBEYXRhYmFzZVRhc2s7CitjbGFzcyBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXI7CiBj bGFzcyBEb2N1bWVudDsKIGNsYXNzIFNRTFRyYW5zYWN0aW9uQ2xpZW50OwogY2xhc3MgU1FMVHJh bnNhY3Rpb25Db29yZGluYXRvcjsKQEAgLTUzLDcgKzU0LDcgQEAgcHVibGljOgogICAgIH5EYXRh YmFzZVRocmVhZCgpOwogCiAgICAgYm9vbCBzdGFydCgpOwotICAgIHZvaWQgcmVxdWVzdFRlcm1p bmF0aW9uKCk7CisgICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oRGF0YWJhc2VUYXNrU3luY2hy b25pemVyICpjbGVhbnVwU3luYyk7CiAgICAgYm9vbCB0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNv bnN0OwogCiAgICAgdm9pZCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxEYXRhYmFzZVRhc2s+KTsK QEAgLTg1LDYgKzg2LDcgQEAgcHJpdmF0ZToKIAogICAgIE93blB0cjxTUUxUcmFuc2FjdGlvbkNs aWVudD4gbV90cmFuc2FjdGlvbkNsaWVudDsKICAgICBPd25QdHI8U1FMVHJhbnNhY3Rpb25Db29y ZGluYXRvcj4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yOworICAgIERhdGFiYXNlVGFza1N5bmNo cm9uaXplciAqbV9jbGVhbnVwU3luYzsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5k ZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdl YkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNiwx MCArMzYsMTAgQEAKICNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIkRhdGFiYXNlVGhy ZWFkLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VUcmFja2VyQ2xpZW50LmgiCi0jaW5jbHVkZSAiRG9j dW1lbnQuaCIKICNpbmNsdWRlICJMb2dnaW5nLmgiCiAjaW5jbHVkZSAiT3JpZ2luUXVvdGFNYW5h Z2VyLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQuaCIKICNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3Jp Z2luSGFzaC5oIgogI2luY2x1ZGUgIlNRTGl0ZUZpbGVTeXN0ZW0uaCIKQEAgLTEyMCw3ICsxMjAs NyBAQCB2b2lkIERhdGFiYXNlVHJhY2tlcjo6b3BlblRyYWNrZXJEYXRhYmFzCiAgICAgfQogfQog Ci1ib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoRG9jdW1lbnQqIGRv Y3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKK2Jvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3Rh Ymxpc2hEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1h dGVkU2l6ZSkKIHsKICAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IG1fdGhyZWFkKTsKIApA QCAtMTI4LDkgKzEyOCw5IEBAIGJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRh YmEKICAgICAvLyBjYW4gcnVuIG9uIHRoZSBkYXRhYmFzZSB0aHJlYWQgbGF0ZXIuCiAgICAgcG9w dWxhdGVPcmlnaW5zKCk7CiAKLSAgICBTZWN1cml0eU9yaWdpbiogb3JpZ2luID0gZG9jdW1lbnQt PnNlY3VyaXR5T3JpZ2luKCk7CisgICAgU2VjdXJpdHlPcmlnaW4qIG9yaWdpbiA9IGNvbnRleHQt PnNlY3VyaXR5T3JpZ2luKCk7CiAKLSAgICAvLyBTaW5jZSB3ZSdyZSBpbW1pbmVudGx5IG9wZW5p bmcgYSBkYXRhYmFzZSB3aXRoaW4gdGhpcyBEb2N1bWVudCdzIG9yaWdpbiwgbWFrZSBzdXJlIHRo aXMgb3JpZ2luIGlzIGJlaW5nIHRyYWNrZWQgYnkgdGhlIFF1b3RhVHJhY2tlcgorICAgIC8vIFNp bmNlIHdlJ3JlIGltbWluZW50bHkgb3BlbmluZyBhIGRhdGFiYXNlIHdpdGhpbiB0aGlzIGNvbnRl eHQncyBvcmlnaW4sIG1ha2Ugc3VyZSB0aGlzIG9yaWdpbiBpcyBiZWluZyB0cmFja2VkIGJ5IHRo ZSBRdW90YVRyYWNrZXIKICAgICAvLyBieSBmZXRjaGluZyBpdCdzIGN1cnJlbnQgdXNhZ2Ugbm93 CiAgICAgdW5zaWduZWQgbG9uZyBsb25nIHVzYWdlID0gdXNhZ2VGb3JPcmlnaW4ob3JpZ2luKTsK IApAQCAtMTQ3LDEyICsxNDcsOSBAQCBib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNo RGF0YWJhCiAKICAgICAvLyBHaXZlIHRoZSBjaHJvbWUgY2xpZW50IGEgY2hhbmNlIHRvIGluY3Jl YXNlIHRoZSBxdW90YS4KICAgICAvLyBUZW1wb3JhcmlseSBtYWtlIHRoZSBkZXRhaWxzIG9mIHRo ZSBwcm9wb3NlZCBkYXRhYmFzZSBhdmFpbGFibGUsIHNvIHRoZSBjbGllbnQgY2FuIGdldCBhdCB0 aGVtLgotICAgIFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+cGFnZSgpOwotICAgIGlmICghcGFnZSkK LSAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIHBhaXI8U2VjdXJpdHlPcmlnaW4qLCBEYXRhYmFz ZURldGFpbHM+IGRldGFpbHMob3JpZ2luLCBEYXRhYmFzZURldGFpbHMobmFtZSwgZGlzcGxheU5h bWUsIGVzdGltYXRlZFNpemUsIDApKTsKICAgICBtX3Byb3Bvc2VkRGF0YWJhc2UgPSAmZGV0YWls czsKLSAgICBwYWdlLT5jaHJvbWUoKS0+Y2xpZW50KCktPmV4Y2VlZGVkRGF0YWJhc2VRdW90YShk b2N1bWVudC0+ZnJhbWUoKSwgbmFtZSk7CisgICAgY29udGV4dC0+ZGF0YWJhc2VFeGNlZWRlZFF1 b3RhKG5hbWUpOwogICAgIG1fcHJvcG9zZWREYXRhYmFzZSA9IDA7CiAKICAgICAvLyBJZiB0aGUg ZGF0YWJhc2Ugd2lsbCBmaXQgbm93LCBhbGxvdyBpdHMgY3JlYXRpb24uCkBAIC0xODYsNyArMTgz LDcgQEAgYm9vbCBEYXRhYmFzZVRyYWNrZXI6Omhhc0VudHJ5Rm9yRGF0YWJhcwogCiB1bnNpZ25l ZCBsb25nIGxvbmcgRGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9yRGF0YWJhc2UoY29uc3Qg RGF0YWJhc2UqIGRhdGFiYXNlKQogewotICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0 YWJhc2UtPmRvY3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAg IEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgLy8gVGhlIG1heGlt dW0gc2l6ZSBmb3IgYSBkYXRhYmFzZSBpcyB0aGUgZnVsbCBxdW90YSBmb3IgaXRzIG9yaWdpbiwg bWludXMgdGhlIGN1cnJlbnQgdXNhZ2Ugd2l0aGluIHRoZSBvcmlnaW4sCiAgICAgLy8gcGx1cyB0 aGUgY3VycmVudCB1c2FnZSBvZiB0aGUgZ2l2ZW4gZGF0YWJhc2UKICAgICBMb2NrZXI8T3JpZ2lu UXVvdGFNYW5hZ2VyPiBsb2NrZXIob3JpZ2luUXVvdGFNYW5hZ2VyKCkpOwpJbmRleDogV2ViQ29y ZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRyYWNrZXIuaAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2Uv RGF0YWJhc2VUcmFja2VyLmgJKHdvcmtpbmcgY29weSkKQEAgLTQ1LDcgKzQ1LDcgQEAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0YWJhc2U7Ci1jbGFzcyBEb2N1bWVudDsKK2NsYXNz IFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiBjbGFzcyBTZWN1cml0eU9yaWdpbjsKIAogI2lmICFQ TEFURk9STShDSFJPTUlVTSkKQEAgLTU5LDggKzU5LDExIEBAIHN0cnVjdCBTZWN1cml0eU9yaWdp blRyYWl0czsKIGNsYXNzIERhdGFiYXNlVHJhY2tlciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBw dWJsaWM6CiAgICAgc3RhdGljIERhdGFiYXNlVHJhY2tlciYgdHJhY2tlcigpOworICAgIC8vIEZJ WE1FOiBEdWUgdG8gd29ya2VycyBoYXZpbmcgbXVsdGlwbGUgdGhyZWFkcyBpbiBhIHNpbmdsZSBw cm9jZXNzIHNoYXJpbmcKKyAgICAvLyBhIERhdGFiYXNlVHJhY2tlciwgdGhpcyBzaW5nbGV0b24g d2lsbCBoYXZlIHRvIGJlIHN5bmNocm9uaXplZCBvciBtb3ZlZAorICAgIC8vIHRvIFRMUy4KIAot ICAgIGJvb2wgY2FuRXN0YWJsaXNoRGF0YWJhc2UoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmIG5h bWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6 ZSk7CisgICAgYm9vbCBjYW5Fc3RhYmxpc2hEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25l ZCBsb25nIGVzdGltYXRlZFNpemUpOwogICAgIHZvaWQgc2V0RGF0YWJhc2VEZXRhaWxzKFNlY3Vy aXR5T3JpZ2luKiwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1l LCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogICAgIFN0cmluZyBmdWxsUGF0aEZvckRh dGFiYXNlKFNlY3VyaXR5T3JpZ2luKiwgY29uc3QgU3RyaW5nJiBuYW1lLCBib29sIGNyZWF0ZUlm RG9lc05vdEV4aXN0ID0gdHJ1ZSk7CiAKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2Fj dGlvbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL1NRTFRyYW5zYWN0aW9uLmNw cAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb24uY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0zNSwxMSArMzUsMTEgQEAKICNpbmNsdWRlICJEYXRhYmFzZS5o IgogI2luY2x1ZGUgIkRhdGFiYXNlQXV0aG9yaXplci5oIgogI2luY2x1ZGUgIkRhdGFiYXNlRGV0 YWlscy5oIgotI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5o IgogI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGxh dGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5j bHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJTUUxFcnJvci5oIgogI2luY2x1ZGUgIlNRTGl0 ZVRyYW5zYWN0aW9uLmgiCkBAIC05NCw4ICs5NCw3IEBAIHZvaWQgU1FMVHJhbnNhY3Rpb246OmV4 ZWN1dGVTUUwoY29uc3QgU3QKIAogICAgIGJvb2wgcmVhZE9ubHlNb2RlID0gbV9yZWFkT25seTsK ICAgICBpZiAoIXJlYWRPbmx5TW9kZSkgewotICAgICAgICBQYWdlKiBwYWdlID0gbV9kYXRhYmFz ZS0+ZG9jdW1lbnQoKS0+cGFnZSgpOwotICAgICAgICBpZiAoIXBhZ2UgfHwgcGFnZS0+c2V0dGlu Z3MoKS0+cHJpdmF0ZUJyb3dzaW5nRW5hYmxlZCgpKQorICAgICAgICBpZiAobV9kYXRhYmFzZS0+ c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0RhdGFiYXNlUmVhZE9ubHkoKSkKICAgICAgICAg ICAgIHJlYWRPbmx5TW9kZSA9IHRydWU7CiAgICAgfQogCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2Uv U1FMVHJhbnNhY3Rpb25DbGllbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9T UUxUcmFuc2FjdGlvbkNsaWVudC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9y YWdlL1NRTFRyYW5zYWN0aW9uQ2xpZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDcsNyArNDcs NyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIHZvaWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRp ZENvbW1pdFRyYW5zYWN0aW9uKFNRTFRyYW5zYWN0aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICBB U1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVu dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVu dFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250 ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOwogICAgIERhdGFiYXNlKiBk YXRhYmFzZSA9IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpOwogICAgIERhdGFiYXNlVHJhY2tlcjo6 dHJhY2tlcigpLnNjaGVkdWxlTm90aWZ5RGF0YWJhc2VDaGFuZ2VkKAogICAgICAgICBkYXRhYmFz ZS0+c2VjdXJpdHlPcmlnaW4oKSwgZGF0YWJhc2UtPnN0cmluZ0lkZW50aWZpZXIoKSk7CkBAIC01 NSw3ICs1NSw3IEBAIHZvaWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW4KIAog dm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkRXhlY3V0ZVN0YXRlbWVudChTUUxUcmFuc2Fj dGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFu c2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhy ZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0 YWJhc2UoKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRU aHJlYWRJRCgpKTsKICAgICBPcmlnaW5RdW90YU1hbmFnZXImIG1hbmFnZXIoRGF0YWJhc2VUcmFj a2VyOjp0cmFja2VyKCkub3JpZ2luUXVvdGFNYW5hZ2VyKCkpOwogICAgIExvY2tlcjxPcmlnaW5R dW90YU1hbmFnZXI+IGxvY2tlcihtYW5hZ2VyKTsKICAgICBtYW5hZ2VyLm1hcmtEYXRhYmFzZSh0 cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKSk7CkBAIC02MywxMyArNjMsMTEgQEAgdm9pZCBTUUxUcmFu c2FjdGlvbkNsaWVudDo6ZGlkRXhlY3V0ZVN0YQogCiBib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50 OjpkaWRFeGNlZWRRdW90YShTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNT RVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQodHJhbnNhY3Rpb24tPmRhdGFiYXNlKCkt PnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNDb250ZXh0VGhyZWFkKCkpOwogICAgIERhdGFi YXNlKiBkYXRhYmFzZSA9IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpOwotICAgIFBhZ2UqIHBhZ2Ug PSBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cGFnZSgpOwotICAgIEFTU0VSVChwYWdlKTsKIAogICAg IHVuc2lnbmVkIGxvbmcgbG9uZyBjdXJyZW50UXVvdGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNr ZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4oKSk7Ci0gICAgcGFn ZS0+Y2hyb21lKCktPmNsaWVudCgpLT5leGNlZWRlZERhdGFiYXNlUXVvdGEoZGF0YWJhc2UtPmRv Y3VtZW50KCktPmZyYW1lKCksIGRhdGFiYXNlLT5zdHJpbmdJZGVudGlmaWVyKCkpOworICAgIGRh dGFiYXNlLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlRXhjZWVkZWRRdW90YShk YXRhYmFzZS0+c3RyaW5nSWRlbnRpZmllcigpKTsKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgbmV3 UXVvdGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFz ZS0+c2VjdXJpdHlPcmlnaW4oKSk7CiAgICAgcmV0dXJuIChuZXdRdW90YSA+IGN1cnJlbnRRdW90 YSk7CiB9CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvY2hyb21pdW0vRGF0YWJhc2VUcmFja2VyQ2hy b21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFz ZVRyYWNrZXJDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdl L2Nocm9taXVtL0RhdGFiYXNlVHJhY2tlckNocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MzUsOCArMzUsOCBAQAogI2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VP YnNlcnZlci5oIgogI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCi0jaW5jbHVkZSAiRG9jdW1l bnQuaCIKICNpbmNsdWRlICJRdW90YVRyYWNrZXIuaCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRp b25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKICNpbmNsdWRlICJTUUxp dGVGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KQEAgLTU2LDcgKzU2LDcg QEAgRGF0YWJhc2VUcmFja2VyOjpEYXRhYmFzZVRyYWNrZXIoKQogICAgIFNRTGl0ZUZpbGVTeXN0 ZW06OnJlZ2lzdGVyU1FMaXRlVkZTKCk7CiB9CiAKLWJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5F c3RhYmxpc2hEYXRhYmFzZShEb2N1bWVudCosIGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYs IHVuc2lnbmVkIGxvbmcpCitib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJh c2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCAqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcm LCB1bnNpZ25lZCBsb25nKQogewogICAgIC8vIEluIENocm9taXVtLCBhIGRhdGFiYXNlIGNhbiBh bHdheXMgYmUgZXN0YWJsaXNoZWQgKGV2ZW4gdGhvdWdoIHdlIG1pZ2h0IG5vdAogICAgIC8vIGJl IGFibGUgdG8gd3JpdGUgYW55dGhpbmcgdG8gaXQgaWYgdGhlIHF1b3RhIGZvciB0aGlzIG9yaWdp biB3YXMgZXhjZWVkZWQpCkBAIC03NSwyMSArNzUsMzcgQEAgU3RyaW5nIERhdGFiYXNlVHJhY2tl cjo6ZnVsbFBhdGhGb3JEYXRhYgogCiB2b2lkIERhdGFiYXNlVHJhY2tlcjo6YWRkT3BlbkRhdGFi YXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKIHsKLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwor ICAgIEFTU0VSVChkYXRhYmFzZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRU aHJlYWQoKSk7CiAgICAgRGF0YWJhc2VPYnNlcnZlcjo6ZGF0YWJhc2VPcGVuZWQoZGF0YWJhc2Up OwogfQotc3RhdGljIHZvaWQgcmVtb3ZlT3BlbkRhdGFiYXNlT25NYWluVGhyZWFkKHZvaWQqIGNv bnRleHQpCi17Ci0gICAgRGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8RGF0YWJhc2Uq Pihjb250ZXh0KTsKLSAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5yZW1vdmVPcGVuRGF0 YWJhc2UoZGF0YWJhc2UpOwotICAgIGRhdGFiYXNlLT5kZXJlZigpOwotfQorCitjbGFzcyBUcmFj a2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0 OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxUcmFja2VyUmVtb3ZlT3Bl bkRhdGFiYXNlVGFzaz4gY3JlYXRlKERhdGFiYXNlICpkYXRhYmFzZSkKKyAgICB7CisgICAgICAg IHJldHVybiBuZXcgVHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2soZGF0YWJhc2UpOworICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0 ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucmVt b3ZlT3BlbkRhdGFiYXNlKG1fZGF0YWJhc2UpOworICAgICAgICAvLyBSZWZmZWQgaW4gY2FsbGVy LgorICAgICAgICBtX2RhdGFiYXNlLT5kZXJlZigpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBl eHBsaWNpdCBUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzayhEYXRhYmFzZSAqZGF0YWJhc2Up IDogbV9kYXRhYmFzZShkYXRhYmFzZSkKKyAgICB7CisgICAgfQorCisgICAgRGF0YWJhc2UqIG1f ZGF0YWJhc2U7Cit9OwogCiB2b2lkIERhdGFiYXNlVHJhY2tlcjo6cmVtb3ZlT3BlbkRhdGFiYXNl KERhdGFiYXNlKiBkYXRhYmFzZSkKIHsKLSAgICBpZiAoIWlzTWFpblRocmVhZCgpKSB7CisgICAg aWYgKCFkYXRhYmFzZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRUaHJlYWQo KSkgewogICAgICAgICBkYXRhYmFzZS0+cmVmKCk7Ci0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQo cmVtb3ZlT3BlbkRhdGFiYXNlT25NYWluVGhyZWFkLCBkYXRhYmFzZSk7CisgICAgICAgIGRhdGFi YXNlLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPnBvc3RUYXNrKFRyYWNrZXJSZW1vdmVPcGVu RGF0YWJhc2VUYXNrOjpjcmVhdGUoZGF0YWJhc2UpKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0K IApAQCAtOTgsNyArMTE0LDcgQEAgdm9pZCBEYXRhYmFzZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRh YmFzZQogCiB1bnNpZ25lZCBsb25nIGxvbmcgRGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9y RGF0YWJhc2UoY29uc3QgRGF0YWJhc2UqIGRhdGFiYXNlKQogewotICAgIEFTU0VSVChjdXJyZW50 VGhyZWFkKCkgPT0gZGF0YWJhc2UtPmRvY3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRo cmVhZElEKCkpOworICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPnNjcmlw dEV4ZWN1dGlvbkNvbnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAg ICAgdW5zaWduZWQgbG9uZyBsb25nIHNwYWNlQXZhaWxhYmxlID0gMDsKICAgICB1bnNpZ25lZCBs b25nIGxvbmcgZGF0YWJhc2VTaXplID0gMDsKICAgICBRdW90YVRyYWNrZXI6Omluc3RhbmNlKCku Z2V0RGF0YWJhc2VTaXplQW5kU3BhY2VBdmFpbGFibGVUb09yaWdpbigKSW5kZXg6IFdlYkNvcmUv c3RvcmFnZS9jaHJvbWl1bS9TUUxUcmFuc2FjdGlvbkNsaWVudENocm9taXVtLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRDaHJv bWl1bS5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL1NR TFRyYW5zYWN0aW9uQ2xpZW50Q2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCwyMCAr MzgsMzUgQEAKICNpbmNsdWRlICJTUUxUcmFuc2FjdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9NYWlu VGhyZWFkLmg+CiAKLXN0YXRpYyB2b2lkIG5vdGlmeURhdGFiYXNlQ2hhbmdlZCh2b2lkKiBjb250 ZXh0KSB7Ci0gICAgV2ViQ29yZTo6RGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8V2Vi Q29yZTo6RGF0YWJhc2UqPihjb250ZXh0KTsKLSAgICBXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVy OjpkYXRhYmFzZU1vZGlmaWVkKGRhdGFiYXNlKTsKLSAgICBkYXRhYmFzZS0+ZGVyZWYoKTsgIC8v IHJlZigpJ2QgaW4gZGlkQ29tbWl0VHJhbnNhY3Rpb24oKQotfQotCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAKK2NsYXNzIE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhl Y3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8Tm90 aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzaz4gY3JlYXRlKERhdGFiYXNlICpkYXRhYmFzZSkKKyAgICB7 CisgICAgICAgIHJldHVybiBuZXcgTm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzayhkYXRhYmFzZSk7 CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqKQorICAgIHsKKyAgICAgICAgV2ViQ29yZTo6RGF0YWJhc2VPYnNlcnZlcjo6ZGF0YWJh c2VNb2RpZmllZChtX2RhdGFiYXNlLmdldCgpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgZXhw bGljaXQgTm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlPiBkYXRh YmFzZSkKKyAgICAgICAgOiBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAgIHsKKyAgICB9CisKKyAg ICBSZWZQdHI8RGF0YWJhc2U+IG1fZGF0YWJhc2U7Cit9OworCiB2b2lkIFNRTFRyYW5zYWN0aW9u Q2xpZW50OjpkaWRDb21taXRUcmFuc2FjdGlvbihTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24p CiB7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2Uo KS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNT RVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhl Y3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKICAgICBp ZiAoIXRyYW5zYWN0aW9uLT5pc1JlYWRPbmx5KCkpIHsKLSAgICAgICAgdHJhbnNhY3Rpb24tPmRh dGFiYXNlKCktPnJlZigpOyAgLy8gZGVyZWYoKSdkIGluIG5vdGlmeURhdGFiYXNlQ2hhbmdlZCgp Ci0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQobm90aWZ5RGF0YWJhc2VDaGFuZ2VkLCB0cmFuc2Fj dGlvbi0+ZGF0YWJhc2UoKSk7CisgICAgICAgIHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5zY3Jp cHRFeGVjdXRpb25Db250ZXh0KCktPnBvc3RUYXNrKAorICAgICAgICAgICAgTm90aWZ5RGF0YWJh c2VDaGFuZ2VkVGFzazo6Y3JlYXRlKHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpKSk7CiAgICAgfQog fQogCkBAIC01OSwxNCArNzQsMTQgQEAgdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkRXhl Y3V0ZVN0YQogewogICAgIC8vIFRoaXMgbWV0aG9kIGlzIGNhbGxlZCBhZnRlciBleGVjdXRpbmcg ZXZlcnkgc3RhdGVtZW50IHRoYXQgY2hhbmdlcyB0aGUgREIuCiAgICAgLy8gQ2hyb21pdW0gZG9l c24ndCBuZWVkIHRvIGRvIGFueXRoaW5nIGF0IHRoYXQgcG9pbnQuCi0gICAgQVNTRVJUKGN1cnJl bnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQoKS0+ZGF0YWJh c2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9 PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5kYXRh YmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKIH0KIAotYm9vbCBTUUxUcmFuc2FjdGlvbkNs aWVudDo6ZGlkRXhjZWVkUXVvdGEoU1FMVHJhbnNhY3Rpb24qKQorYm9vbCBTUUxUcmFuc2FjdGlv bkNsaWVudDo6ZGlkRXhjZWVkUXVvdGEoU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewog ICAgIC8vIENocm9taXVtIGRvZXMgbm90IGFsbG93IHVzZXJzIHRvIG1hbnVhbGx5IGNoYW5nZSB0 aGUgcXVvdGEgZm9yIGFuIG9yaWdpbiAoZm9yIG5vdywgYXQgbGVhc3QpLgogICAgIC8vIERvbid0 IGRvIGFueXRoaW5nLgotICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKHRy YW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzQ29udGV4 dFRocmVhZCgpKTsKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKSW5kZXg6IFdlYkNvcmUvd29ya2Vy cy9Xb3JrZXJDb250ZXh0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3dvcmtlcnMvV29ya2Vy Q29udGV4dC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlckNv bnRleHQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVkZSAiV29y a2VyQ29udGV4dC5oIgogCiAjaW5jbHVkZSAiQWN0aXZlRE9NT2JqZWN0LmgiCisjaW5jbHVkZSAi RGF0YWJhc2UuaCIKICNpbmNsdWRlICJET01UaW1lci5oIgogI2luY2x1ZGUgIkRPTVdpbmRvdy5o IgogI2luY2x1ZGUgIkV2ZW50LmgiCkBAIC0yNTQsNiArMjU1LDI0IEBAIE5vdGlmaWNhdGlvbkNl bnRlciogV29ya2VyQ29udGV4dDo6d2Via2kKIH0KICNlbmRpZgogCisjaWYgRU5BQkxFKERBVEFC QVNFKQorUGFzc1JlZlB0cjxEYXRhYmFzZT4gV29ya2VyQ29udGV4dDo6b3BlbkRhdGFiYXNlKGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2ZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmIGVj KQoreworICAgIGlmICghc2VjdXJpdHlPcmlnaW4oKS0+Y2FuQWNjZXNzRGF0YWJhc2UoKSkKKyAg ICAgICAgcmV0dXJuIDA7CisKKyAgICBpZiAoIURhdGFiYXNlOjppc0F2YWlsYWJsZSgpKQorICAg ICAgICByZXR1cm4gMDsKKworICAgIHJldHVybiBEYXRhYmFzZTo6b3BlbkRhdGFiYXNlKHRoaXMs IG5hbWUsIHZlcnNpb24sIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplLCBlYyk7Cit9CisjZW5k aWYKKworYm9vbCBXb3JrZXJDb250ZXh0Ojppc0NvbnRleHRUaHJlYWQoKSBjb25zdAoreworICAg IHJldHVybiBjdXJyZW50VGhyZWFkKCkgPT0gdGhyZWFkKCktPnRocmVhZElEKCk7Cit9CisKIEV2 ZW50VGFyZ2V0RGF0YSogV29ya2VyQ29udGV4dDo6ZXZlbnRUYXJnZXREYXRhKCkKIHsKICAgICBy ZXR1cm4gJm1fZXZlbnRUYXJnZXREYXRhOwpJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlckNv bnRleHQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCShy ZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgJKHdvcmtp bmcgY29weSkKQEAgLTMwLDExICszMCwxMyBAQAogI2lmIEVOQUJMRShXT1JLRVJTKQogCiAjaW5j bHVkZSAiQXRvbWljU3RyaW5nSGFzaC5oIgorI2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVk ZSAiRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRlICJF dmVudFRhcmdldC5oIgogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKICNpbmNs dWRlICJXb3JrZXJTY3JpcHRDb250cm9sbGVyLmgiCisjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMu aD4KICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4K ICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgpAQCAtNDIsNiArNDQsNyBAQAogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKKyAgICBjbGFzcyBEYXRhYmFzZTsKICAgICBjbGFzcyBOb3RpZmljYXRp b25DZW50ZXI7CiAgICAgY2xhc3MgU2NoZWR1bGVkQWN0aW9uOwogICAgIGNsYXNzIFdvcmtlckxv Y2F0aW9uOwpAQCAtNjUsOSArNjgsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZp cnR1YWwgU3RyaW5nIHVzZXJBZ2VudChjb25zdCBLVVJMJikgY29uc3Q7CiAKICAgICAgICAgV29y a2VyU2NyaXB0Q29udHJvbGxlciogc2NyaXB0KCkgeyByZXR1cm4gbV9zY3JpcHQuZ2V0KCk7IH0K LSAgICAgICAgdm9pZCBjbGVhclNjcmlwdCgpIHsgcmV0dXJuIG1fc2NyaXB0LmNsZWFyKCk7IH0K KyAgICAgICAgdm9pZCBjbGVhclNjcmlwdCgpIHsgbV9zY3JpcHQuY2xlYXIoKTsgfQogCi0gICAg ICAgIFdvcmtlclRocmVhZCogdGhyZWFkKCkgeyByZXR1cm4gbV90aHJlYWQ7IH0KKyAgICAgICAg V29ya2VyVGhyZWFkKiB0aHJlYWQoKSBjb25zdCB7IHJldHVybiBtX3RocmVhZDsgfQogCiAgICAg ICAgIGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KCkgY29uc3Q7CiAKQEAgLTEwMSw2ICsxMDQsMTcg QEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBOb3RpZmljYXRpb25DZW50ZXIqIHdlYmtp dE5vdGlmaWNhdGlvbnMoKSBjb25zdDsKICNlbmRpZgogCisjaWYgRU5BQkxFKERBVEFCQVNFKQor ICAgICAgICAvLyBIVE1MIDUgY2xpZW50LXNpZGUgZGF0YWJhc2UKKyAgICAgICAgUGFzc1JlZlB0 cjxEYXRhYmFzZT4gb3BlbkRhdGFiYXNlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5n JiB2ZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGlt YXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICAgICAgLy8gTm90IGltcGxlbWVudGVkIHll dC4KKyAgICAgICAgdmlydHVhbCBib29sIGlzRGF0YWJhc2VSZWFkT25seSgpIGNvbnN0IHsgcmV0 dXJuIGZhbHNlOyB9CisgICAgICAgIC8vIE5vdCBpbXBsZW1lbnRlZCB5ZXQuCisgICAgICAgIHZp cnR1YWwgdm9pZCBkYXRhYmFzZUV4Y2VlZGVkUXVvdGEoY29uc3QgU3RyaW5nJikgeyB9CisjZW5k aWYKKyAgICAgICAgdmlydHVhbCBib29sIGlzQ29udGV4dFRocmVhZCgpIGNvbnN0OworCisKICAg ICAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgdXNlZCBmb3IgR0MgbWFya2luZy4gU2VlIEpTV29y a2VyQ29udGV4dDo6bWFya0NoaWxkcmVuKE1hcmtTdGFjayYpIGluCiAgICAgICAgIC8vIEpTV29y a2VyQ29udGV4dEN1c3RvbS5jcHAuCiAgICAgICAgIFdvcmtlck5hdmlnYXRvciogb3B0aW9uYWxO YXZpZ2F0b3IoKSBjb25zdCB7IHJldHVybiBtX25hdmlnYXRvci5nZXQoKTsgfQpJbmRleDogV2Vi Q29yZS93b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29y a2Vycy9Xb3JrZXJSdW5Mb29wLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3dvcmtl cnMvV29ya2VyUnVuTG9vcC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE1Miw5ICsxNTIsNyBAQCBN ZXNzYWdlUXVldWVXYWl0UmVzdWx0IFdvcmtlclJ1bkxvb3A6OnJ1CiAgICAgTWVzc2FnZVF1ZXVl V2FpdFJlc3VsdCByZXN1bHQ7CiAgICAgT3duUHRyPFdvcmtlclJ1bkxvb3A6OlRhc2s+IHRhc2sg PSBtX21lc3NhZ2VRdWV1ZS53YWl0Rm9yTWVzc2FnZUZpbHRlcmVkV2l0aFRpbWVvdXQocmVzdWx0 LCBwcmVkaWNhdGUsIGFic29sdXRlVGltZSk7CiAKLSAgICAvLyBJZiB0aGUgY29udGV4dCBpcyBj bG9zaW5nLCBkb24ndCBkaXNwYXRjaCBhbnkgZnVydGhlciB0YXNrcyAocGVyIHNlY3Rpb24gNC4x LjEgb2YgdGhlIFdlYiBXb3JrZXJzIHNwZWMpLgotICAgIGlmIChjb250ZXh0LT5pc0Nsb3Npbmco KSkKLSAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICAvLyBJZiB0aGUgY29udGV4dCBpcyBjbG9z aW5nLCBkb24ndCBleGVjdXRlIGFueSBmdXJ0aGVyIEphdmFTY3JpcHQgdGFza3MgKHBlciBzZWN0 aW9uIDQuMS4xIG9mIHRoZSBXZWIgV29ya2VycyBzcGVjKS4gIEhvd2V2ZXIsIHRoZXJlIG1heSBi ZSBpbXBsZW1lbnRhdGlvbiBjbGVhbnVwIHRhc2tzIGluIHRoZSBxdWV1ZSwgc28ga2VlcCBydW5u aW5nIHRocm91Z2ggaXQuCiAKICAgICBzd2l0Y2ggKHJlc3VsdCkgewogICAgIGNhc2UgTWVzc2Fn ZVF1ZXVlVGVybWluYXRlZDoKQEAgLTE2NSw3ICsxNjMsOCBAQCBNZXNzYWdlUXVldWVXYWl0UmVz dWx0IFdvcmtlclJ1bkxvb3A6OnJ1CiAgICAgICAgIGJyZWFrOwogCiAgICAgY2FzZSBNZXNzYWdl UXVldWVUaW1lb3V0OgotICAgICAgICBtX3NoYXJlZFRpbWVyLT5maXJlKCk7CisgICAgICAgIGlm ICghY29udGV4dC0+aXNDbG9zaW5nKCkpCisgICAgICAgICAgICBtX3NoYXJlZFRpbWVyLT5maXJl KCk7CiAgICAgICAgIGJyZWFrOwogICAgIH0KIApAQCAtMTk0LDcgKzE5Myw5IEBAIFBhc3NPd25Q dHI8V29ya2VyUnVuTG9vcDo6VGFzaz4gV29ya2VyUnUKIAogdm9pZCBXb3JrZXJSdW5Mb29wOjpU YXNrOjpwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAg IG1fdGFzay0+cGVyZm9ybVRhc2soY29udGV4dCk7CisgICAgV29ya2VyQ29udGV4dCogd29ya2Vy Q29udGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQgKj4oY29udGV4dCk7CisgICAgaWYg KCF3b3JrZXJDb250ZXh0LT5pc0Nsb3NpbmcoKSB8fCBtX3Rhc2stPmlzQ2xlYW51cFRhc2soKSkK KyAgICAgICAgbV90YXNrLT5wZXJmb3JtVGFzayhjb250ZXh0KTsKIH0KIAogV29ya2VyUnVuTG9v cDo6VGFzazo6VGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+IHRh c2ssIGNvbnN0IFN0cmluZyYgbW9kZSkKSW5kZXg6IFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJl YWQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCShy ZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJUaHJlYWQuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zMCw2ICszMCw3IEBACiAKICNpbmNsdWRlICJXb3JrZXJUaHJlYWQuaCIK IAorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgogI2luY2x1ZGUgIkRlZGljYXRlZFdvcmtlckNv bnRleHQuaCIKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIK QEAgLTEzNSw5ICsxMzYsOCBAQCB2b2lkKiBXb3JrZXJUaHJlYWQ6OndvcmtlclRocmVhZCgpCiAK ICAgICBUaHJlYWRJZGVudGlmaWVyIHRocmVhZElEID0gbV90aHJlYWRJRDsKIAotICAgIG1fd29y a2VyQ29udGV4dC0+c3RvcEFjdGl2ZURPTU9iamVjdHMoKTsKLSAgICBtX3dvcmtlckNvbnRleHQt PmNsZWFyU2NyaXB0KCk7CiAgICAgQVNTRVJUKG1fd29ya2VyQ29udGV4dC0+aGFzT25lUmVmKCkp OworCiAgICAgLy8gVGhlIGJlbG93IGFzc2lnbm1lbnQgd2lsbCBkZXN0cm95IHRoZSBjb250ZXh0 LCB3aGljaCB3aWxsIGluIHR1cm4gbm90aWZ5IG1lc3NhZ2luZyBwcm94eS4KICAgICAvLyBXZSBj YW5ub3QgbGV0IGFueSBvYmplY3RzIHN1cnZpdmUgcGFzdCB0aHJlYWQgZXhpdCwgYmVjYXVzZSBu byBvdGhlciB0aHJlYWQgd2lsbCBydW4gR0Mgb3Igb3RoZXJ3aXNlIGRlc3Ryb3kgdGhlbS4KICAg ICBtX3dvcmtlckNvbnRleHQgPSAwOwpAQCAtMTU0LDE3ICsxNTQsODAgQEAgdm9pZCBXb3JrZXJU aHJlYWQ6OnJ1bkV2ZW50TG9vcCgpCiAgICAgbV9ydW5Mb29wLnJ1bihtX3dvcmtlckNvbnRleHQu Z2V0KCkpOwogfQogCitjbGFzcyBXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2sgOiBwdWJs aWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBh c3NPd25QdHI8V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrPiBjcmVhdGUoKQorICAgIHsK KyAgICAgICAgcmV0dXJuIG5ldyBXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2soKTsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCAqY29udGV4dCkKKyAgICB7CisgICAgICAgIEFTU0VSVChjb250ZXh0LT5pc1dvcmtlckNvbnRl eHQoKSk7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2Fz dDxXb3JrZXJDb250ZXh0Kj4oY29udGV4dCk7CisgICAgICAgIHdvcmtlckNvbnRleHQtPnRocmVh ZCgpLT5ydW5Mb29wKCkudGVybWluYXRlKCk7CisgICAgfQorCisgICAgdmlydHVhbCBib29sIGlz Q2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisKK3ByaXZhdGU6CisgICAgZXhw bGljaXQgV29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrKCkKKyAgICB7CisgICAgfQorfTsK KworY2xhc3MgV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhl Y3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8V29y a2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s+IGNyZWF0ZSgpCisgICAgeworICAgICAgICByZXR1 cm4gbmV3IFdvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrKCk7CisgICAgfQorCisgICAgdmly dHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQpCisg ICAgeworICAgICAgICBBU1NFUlQoY29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkpOworICAgICAg ICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4 dCo+KGNvbnRleHQpOworCisgICAgICAgIC8vIFdlIGN1cnJlbnRseSBpZ25vcmUgYW55IERhdGFi YXNlUG9saWN5IHVzZWQgZm9yIHRoZSBkb2N1bWVudCdzCisgICAgICAgIC8vIGRhdGFiYXNlczsg aWYgaXQncyBhY3R1YWxseSB1c2VkIGFueXdoZXJlLCB0aGlzIHNob3VsZCBiZSByZXZpc2l0ZWQu CisgICAgICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBjbGVhbnVwU3luYzsKKyAgICAgICAg d29ya2VyQ29udGV4dC0+c3RvcERhdGFiYXNlcygmY2xlYW51cFN5bmMpOworCisgICAgICAgIHdv cmtlckNvbnRleHQtPnN0b3BBY3RpdmVET01PYmplY3RzKCk7CisgICAgICAgIHdvcmtlckNvbnRl eHQtPmNsZWFyU2NyaXB0KCk7CisKKyAgICAgICAgLy8gV2Ugd2FpdCBmb3IgdGhlIGRhdGFiYXNl IHRocmVhZCB0byBjbGVhbiB1cCBhbGwgaXRzIHN0dWZmIHNvIHRoYXQgd2UKKyAgICAgICAgLy8g Y2FuIGRvIG1vcmUgc3RyaW5nZW50IGxlYWsgY2hlY2tzIGFzIHdlIGV4aXQuCisgICAgICAgIGNs ZWFudXBTeW5jLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOworCisgICAgICAgIC8vIFN0aWNrIGEg c2h1dGRvd24gY29tbWFuZCBhdCB0aGUgZW5kIG9mIHRoZSBxdWV1ZSwgc28gdGhhdCB3ZSBkZWFs CisgICAgICAgIC8vIHdpdGggYWxsIHRoZSBjbGVhbnVwIHRhc2tzIHRoZSBkYXRhYmFzZXMgcG9z dCBmaXJzdC4KKyAgICAgICAgd29ya2VyQ29udGV4dC0+cG9zdFRhc2soV29ya2VyVGhyZWFkU2h1 dGRvd25GaW5pc2hUYXNrOjpjcmVhdGUoKSk7CisgICAgfQorCisgICAgdmlydHVhbCBib29sIGlz Q2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisKK3ByaXZhdGU6CisgICAgZXhw bGljaXQgV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2soKQorICAgIHsKKyAgICB9Cit9Owor CiB2b2lkIFdvcmtlclRocmVhZDo6c3RvcCgpCiB7CiAgICAgLy8gTXV0ZXggcHJvdGVjdGlvbiBp cyBuZWNlc3NhcnkgYmVjYXVzZSBzdG9wKCkgY2FuIGJlIGNhbGxlZCBiZWZvcmUgdGhlIGNvbnRl eHQgaXMgZnVsbHkgY3JlYXRlZC4KICAgICBNdXRleExvY2tlciBsb2NrKG1fdGhyZWFkQ3JlYXRp b25NdXRleCk7CiAKICAgICAvLyBFbnN1cmUgdGhhdCB0YXNrcyBhcmUgYmVpbmcgaGFuZGxlZCBi eSB0aHJlYWQgZXZlbnQgbG9vcC4gSWYgc2NyaXB0IGV4ZWN1dGlvbiB3ZXJlbid0IGZvcmJpZGRl biwgYSB3aGlsZSgxKSBsb29wIGluIEpTIGNvdWxkIGtlZXAgdGhlIHRocmVhZCBhbGl2ZSBmb3Jl dmVyLgotICAgIGlmIChtX3dvcmtlckNvbnRleHQpCisgICAgaWYgKG1fd29ya2VyQ29udGV4dCkg ewogICAgICAgICBtX3dvcmtlckNvbnRleHQtPnNjcmlwdCgpLT5mb3JiaWRFeGVjdXRpb24oKTsK IAogICAgIC8vIEZJWE1FOiBSdWRlbHkga2lsbGluZyB0aGUgdGhyZWFkIHdvbid0IHdvcmsgd2hl biB3ZSBhbGxvdyBuZXN0ZWQgd29ya2VycywgYmVjYXVzZSB0aGV5IHdpbGwgdHJ5IHRvIHBvc3Qg bm90aWZpY2F0aW9ucyBvZiB0aGVpciBkZXN0cnVjdGlvbi4KLSAgICBtX3J1bkxvb3AudGVybWlu YXRlKCk7CisgICAgLy8gVGhpcyBjYW4gbGlrZWx5IHVzZSB0aGUgc2FtZSBtZWNoYW5pc20gYXMg dXNlZCBmb3IgZGF0YWJhc2VzIGFib3ZlLgorCisgICAgICAgIG1fcnVuTG9vcC5wb3N0VGFzayhX b3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6Y3JlYXRlKCkpOworICAgIH0gZWxzZQorICAg ICAgICBtX3J1bkxvb3AudGVybWluYXRlKCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK 46959 2010-01-19 16:32:52 -0800 2010-01-19 19:39:20 -0800 Next revision, rolling in more comments. One layout test changed. upload.3.patch text/plain 64528 ericu SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzUwNikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUxIEBACisyMDEwLTAxLTE5ICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVmYWN0b3JpbmcgYW5kIHBsdW1iaW5nIHRvIGdldCB0aGUgSFRNTDUgU1FMIERhdGFiYXNlIEFQ SSBhY2Nlc3NpYmxlIHRvCisgICAgICAgIHdlYiB3b3JrZXJzLiAgTm8gbmV3IGZ1bmN0aW9uYWxp dHkgaXMgZXhwb3NlZCB5ZXQ7IHRoaXMganVzdCBnZXRzIHRoZQorICAgICAgICBpbmZyYXN0cnVj dHVyZSBpbiBwbGFjZS4gIEl0IHRvdWNoZXMgYSBsb3Qgb2YgZmlsZXMgaW4gc21hbGwgd2F5czsg aGVyZQorICAgICAgICBhcmUgdGhlIG1haW4gY2hhbmdlczoKKworICAgICAgICAxKSBEYXRhYmFz ZSBtZW1iZXJzIGFuZCBtZXRob2RzIG1vdmUgZnJvbSBEb2N1bWVudCB1cCB0bworICAgICAgICBT Y3JpcHRFeGVjdXRpb25Db250ZXh0LiAgRWFjaCBvZiBEb2N1bWVudCBhbmQgV29ya2VyQ29udGV4 dCBtdXN0CisgICAgICAgIGltcGxlbWVudCBhIGZldyB2aXJ0dWFsIG1ldGhvZHMgd2hlcmUgdGhl IERhdGFiYXNlIGNvZGUgcmVxdWlyZXMKKyAgICAgICAgZGlmZmVyZW50aWF0aW9uLgorICAgICAg ICAyKSBXb3JrZXIgdGhyZWFkIHNodXRkb3duIGdvdCBjaGFuZ2VkIGEgYnVuY2ggdG8gaGFuZGxl IERhdGFiYXNlIGNsZWFudXAKKyAgICAgICAgYW5kIHRocmVhZCBzeW5jaHJvbml6YXRpb24gaXNz dWVzLiAgRGF0YWJhc2UgY2xlYW51cCB0YXNrcyBuZWVkIHRvIHBvc3QKKyAgICAgICAgc29tZSBj bGVhbnVwIHRhc2tzIHRvIHRoZSBKYXZhU2NyaXB0IHRocmVhZC4gIEhvd2V2ZXIsIHNpbmNlIGRh dGFiYXNlCisgICAgICAgIGNsZWFudXAgbWF5IGhhcHBlbiBkdWUgdG8gdGhlIGRlc3RydWN0aW9u IG9mIHRoZSBXb3JrZXJUaHJlYWQsIEkgYWRkZWQgYQorICAgICAgICBoYW5kc2hha2UgW2ludm9s dmluZyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzaywKKyAgICAgICAgV29ya2VyVGhyZWFk U2h1dGRvd25GaW5pc2hUYXNrLCBhbmQgYSBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXJdIGJldHdl ZW4KKyAgICAgICAgdGhlIERhdGFiYXNlIHRocmVhZCBhbmQgV29ya2VyVGhyZWFkIHRoYXQgY2xl YW5zIHVwIGFsbCB0aGUgRGF0YWJhc2UKKyAgICAgICAgc3R1ZmYgYmVmb3JlIHRoZSBXb3JrZXJU aHJlYWQncyBydW5Mb29wIGNhbiBleGl0LgorICAgICAgICAzKSBUaGUgcnVudGltZSBlbmFibGVy IGZvciB0aGUgRGF0YWJhc2UgbW92ZWQgdG8gYSBzdGF0aWMgdmFyaWFibGUKKyAgICAgICAgYWNj ZXNzaWJsZSB0aHJvdWdoIERhdGFiYXNlOjppc0F2YWlsYWJsZSwgZm9sbG93aW5nIHRoZSBtb2Rl bCB1c2VkIGJ5CisgICAgICAgIFdlYlNvY2tldC4KKyAgICAgICAgNCkgV29ya2VyIHRocmVhZHMg ZG9uJ3QgcnVuIHRoZWlyIEphdmFTY3JpcHQgb24gdGhlIE1haW4gdGhyZWFkLCBzbworICAgICAg ICBEYXRhYmFzZSBjb2RlIHRoYXQgZGlmZmVyZW50aWF0ZWQgYmV0d2VlbiB0aGUgTWFpbiB0aHJl YWQgYW5kIHRoZQorICAgICAgICBEYXRhYmFzZSB0aHJlYWQgbm93IG5lZWQgdG8gZGVhbCB3aXRo IGEgdGhpcmQgcG9zc2liaWxpdHkuCisgICAgICAgIDUpIE1vc3Qgb2YgdGhlIG90aGVyIGNoYW5n ZXMgaGF2ZSB0byBkbyB3aXRoIGhhdmluZyBhCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgcG9pbnRlciBpbnN0ZWFkIG9mIGEgRG9jdW1lbnQgcG9pbnRlciB3aGVuCisgICAgICAgIGRl YWxpbmcgd2l0aCBhIERhdGFiYXNlLiAgSW4gbWFueSBjYXNlcyBpdCdzIGp1c3QgYSBzdHJpbmcg cmVwbGFjZW1lbnQsCisgICAgICAgIGJ1dCBpbiBzb21lIGl0IHJlcXVpcmVkIHRoZSBjcmVhdGlv biBvZiBhIG5ldyB2aXJ0dWFsIGZ1bmN0aW9uIFtlLmcuCisgICAgICAgIGRhdGFiYXNlRXhjZWVk ZWRRdW90YSwgaXNEYXRhYmFzZVJlYWRPbmx5XQorICAgICAgICA2KSBQcmV2aW91c2x5IG9wZW5E YXRhYmFzZSB3b3VsZCBqdXN0IHJldHVybiBudWxsIGlmIHRoZSBvcGVuZXIgZGlkbid0CisgICAg ICAgIGhhdmUgcGVybWlzc2lvbiB0byBhY2Nlc3MgdGhlIGRhdGFiYXNlLiAgSSd2ZSBjaGFuZ2Vk IGl0IHRvIHRocm93IGFuCisgICAgICAgIGV4Y2VwdGlvbiwgYXMgSSBiZWxpdmUgdGhhdCdzIHdo YXQgdGhlIHNwZWMgcmVxdWlyZXMuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIyNzI1CisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyBpbiBhIGZ1dHVy ZSBwYXRjaCBJJ2xsIGFkZCBKU0MgYW5kIFY4IGJpbmRpbmdzIGFuZCBuZXcKKyAgICAgICAgbGF5 b3V0IHRlc3RzIHRvIGV4ZXJjaXNlIHRoZW0uCisKKyAgICAgICAgKiBiaW5kaW5ncy92OC9jdXN0 b20vVjhET01XaW5kb3dDdXN0b20uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VjhET01XaW5kb3c6 Ok9wZW5EYXRhYmFzZUVuYWJsZWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpEb2N1bWVudDo6RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9j dW1lbnQ6On5Eb2N1bWVudCk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6aXNEYXRhYmFz ZVJlYWRPbmx5KToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpkYXRhYmFzZUV4Y2VlZGVk UXVvdGEpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmlzQ29udGV4dFRocmVhZCk6Cisg ICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogZG9tL1NjcmlwdEV4ZWN1dGlvbkNv bnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6U2Ny aXB0RXhlY3V0aW9uQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25D b250ZXh0Ojp+U2NyaXB0RXhlY3V0aW9uQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpkYXRhYmFzZVRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjphZGRPcGVuRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6cmVtb3ZlT3BlbkRhdGFiYXNlKToKKyAgICAgICAg KFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnN0b3BEYXRhYmFzZXMpOgorICAgICAg ICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisgICAgICAgIChXZWJDb3JlOjpTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpzZXRIYXNPcGVuRGF0YWJhc2VzKToKKyAgICAgICAgKFdlYkNv cmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6Omhhc09wZW5EYXRhYmFzZXMpOgorICAgICAgICAo V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzazo6aXNDbGVhbnVwVGFzayk6Cisg ICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1l TG9hZGVyOjpzdG9wTG9hZGluZyk6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpvcGVuRGF0YWJhc2UpOgorICAgICAgICAqIHN0b3Jh Z2UvRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNldElzQXZhaWxh YmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjppc0F2YWlsYWJsZSk6CisgICAgICAg IChXZWJDb3JlOjpEYXRhYmFzZTo6b3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRh dGFiYXNlOjpEYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEZXJlZkNvbnRleHRUYXNrOjpj cmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6cGVyZm9ybVRhc2sp OgorICAgICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6aXNDbGVhbnVwVGFzayk6Cisg ICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6fkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6 OkRhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbik6CisgICAgICAgIChXZWJDb3JlOjpEYXRh YmFzZTo6bWFya0FzRGVsZXRlZEFuZENsb3NlKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRleHRS ZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4 dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6 OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjppc0NsZWFudXBUYXNrKToKKyAgICAgICAg KFdlYkNvcmU6OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpDb250ZXh0UmVtb3ZlT3Bl bkRhdGFiYXNlVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6Y2xvc2UpOgorICAg ICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnBlcmZvcm1PcGVuQW5kVmVyaWZ5KToKKyAgICAgICAg KFdlYkNvcmU6OkRhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uU3RlcCk6CisgICAgICAgIChXZWJDb3Jl OjpEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJD b3JlOjpEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzazo6RGVsaXZlclBlbmRpbmdDYWxsYmFja1Rh c2spOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25DYWxs YmFjayk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6dHJhbnNhY3Rpb25DbGllbnQpOgor ICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IpOgorICAg ICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnRhYmxlTmFtZXMpOgorICAgICAgICAoV2ViQ29yZTo6 RGF0YWJhc2U6OnNlY3VyaXR5T3JpZ2luKToKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNlLmg6 CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6c2NyaXB0RXhlY3V0aW9uQ29udGV4dCk6Cisg ICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRhc2suaDoKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFi YXNlVGhyZWFkLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpEYXRhYmFz ZVRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6fkRhdGFiYXNlVGhy ZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRp b24pOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OmRhdGFiYXNlVGhyZWFkKToK KyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNr cyk6CisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oOgorICAgICAgICAqIHN0b3Jh Z2UvRGF0YWJhc2VUcmFja2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tl cjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFj a2VyOjpnZXRNYXhTaXplRm9yRGF0YWJhc2UpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VU cmFja2VyLmg6CisgICAgICAgICogc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5jcHA6CisgICAgICAg IChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbjo6ZXhlY3V0ZVNRTCk6CisgICAgICAgICogc3RvcmFn ZS9TUUxUcmFuc2FjdGlvbkNsaWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2Fj dGlvbkNsaWVudDo6ZGlkQ29tbWl0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6U1FM VHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4ZWN1dGVTdGF0ZW1lbnQpOgorICAgICAgICAoV2ViQ29y ZTo6U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKToKKyAgICAgICAgKiBzdG9y YWdlL2Nocm9taXVtL0RhdGFiYXNlVHJhY2tlckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UpOgorICAgICAgICAoV2Vi Q29yZTo6RGF0YWJhc2VUcmFja2VyOjphZGRPcGVuRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29y ZTo6VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJD b3JlOjpUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAg ICAoV2ViQ29yZTo6VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OlRyYWNrZXJSZW1vdmVP cGVuRGF0YWJhc2VUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6cmVt b3ZlT3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6Z2V0 TWF4U2l6ZUZvckRhdGFiYXNlKToKKyAgICAgICAgKiBzdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5z YWN0aW9uQ2xpZW50Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJh c2VDaGFuZ2VkVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFiYXNl Q2hhbmdlZFRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFi YXNlQ2hhbmdlZFRhc2s6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2spOgorICAgICAgICAoV2Vi Q29yZTo6U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0aW9uKToKKyAgICAg ICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhdGVtZW50KToK KyAgICAgICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YSk6 CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OldvcmtlckNvbnRleHQ6Om9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJD b250ZXh0Ojppc0NvbnRleHRUaHJlYWQpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4 dC5oOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6Y2xlYXJTY3JpcHQpOgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6dGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6 OldvcmtlckNvbnRleHQ6OmlzRGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpX b3JrZXJDb250ZXh0OjpkYXRhYmFzZUV4Y2VlZGVkUXVvdGEpOgorICAgICAgICAqIHdvcmtlcnMv V29ya2VyUnVuTG9vcC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJSdW5Mb29wOjpydW5J bk1vZGUpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyUnVuTG9vcDo6VGFzazo6cGVyZm9ybVRh c2spOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyVGhyZWFkLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OldvcmtlclRocmVhZDo6d29ya2VyVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6Oldvcmtl clRocmVhZFNodXRkb3duRmluaXNoVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Oldv cmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2Vi Q29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjppc0NsZWFudXBUYXNrKToKKyAg ICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpjcmVhdGUpOgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6OnBlcmZvcm1U YXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpp c0NsZWFudXBUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZDo6c3RvcCk6CisK IDIwMTAtMDEtMTkgIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9raWEuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRleDogV2ViQ29yZS9iaW5kaW5ncy92OC9j dXN0b20vVjhET01XaW5kb3dDdXN0b20uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvYmluZGlu Z3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBX ZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERPTVdpbmRvd0N1c3RvbS5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTMzLDYgKzMzLDcgQEAKIAogI2luY2x1ZGUgIkJhc2U2NC5oIgogI2luY2x1ZGUg IkNocm9tZS5oIgorI2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRE9NVGltZXIuaCIK ICNpbmNsdWRlICJET01XaW5kb3cuaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCkBAIC0y OTUsNyArMjk2LDcgQEAgYm9vbCBWOERPTVdpbmRvdzo6V2ViU29ja2V0RW5hYmxlZCgpCiAjaWYg RU5BQkxFKERBVEFCQVNFKQogYm9vbCBWOERPTVdpbmRvdzo6T3BlbkRhdGFiYXNlRW5hYmxlZCgp CiB7Ci0gICAgcmV0dXJuIFdlYkNvcmU6OlJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmRhdGFiYXNl RW5hYmxlZCgpOworICAgIHJldHVybiBEYXRhYmFzZTo6aXNBdmFpbGFibGUoKTsKIH0KICNlbmRp ZgogCkluZGV4OiBXZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9kb20vRG9jdW1lbnQuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvZG9tL0RvY3Vt ZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIkNTdHJp bmcuaCIKICNpbmNsdWRlICJDYWNoZWRDU1NTdHlsZVNoZWV0LmgiCiAjaW5jbHVkZSAiQ2hyb21l LmgiCisjaW5jbHVkZSAiQ2hyb21lQ2xpZW50LmgiCiAjaW5jbHVkZSAiQ29tbWVudC5oIgogI2lu Y2x1ZGUgIkNvbnNvbGUuaCIKICNpbmNsdWRlICJDb29raWVKYXIuaCIKQEAgLTEzNywxMSArMTM4 LDYgQEAKICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJF eHRyYXMuaD4KIAotI2lmIEVOQUJMRShEQVRBQkFTRSkKLSNpbmNsdWRlICJEYXRhYmFzZS5oIgot I2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCi0jZW5kaWYKLQogI2lmIEVOQUJMRShTSEFSRURf V09SS0VSUykKICNpbmNsdWRlICJTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmgiCiAjZW5kaWYKQEAg LTM1MCw5ICszNDYsNiBAQCBEb2N1bWVudDo6RG9jdW1lbnQoRnJhbWUqIGZyYW1lLCBib29sIGlz CiAgICAgLCBtX3VzZVNlY3VyZUtleWJvYXJkRW50cnlXaGVuQWN0aXZlKGZhbHNlKQogICAgICwg bV9pc1hIVE1MKGlzWEhUTUwpCiAgICAgLCBtX251bU5vZGVMaXN0Q2FjaGVzKDApCi0jaWYgRU5B QkxFKERBVEFCQVNFKQotICAgICwgbV9oYXNPcGVuRGF0YWJhc2VzKGZhbHNlKQotI2VuZGlmCiAg ICAgLCBtX3VzaW5nR2VvbG9jYXRpb24oZmFsc2UpCiAjaWYgRU5BQkxFKFdNTCkKICAgICAsIG1f Y29udGFpbnNXTUxDb250ZW50KGZhbHNlKQpAQCAtNTAwLDEzICs0OTMsNiBAQCBEb2N1bWVudDo6 fkRvY3VtZW50KCkKICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY291bnQ7IGkrKykKICAg ICAgICAgZGVsZXRlQWxsVmFsdWVzKG1fbmFtZUNvbGxlY3Rpb25JbmZvW2ldKTsKIAotI2lmIEVO QUJMRShEQVRBQkFTRSkKLSAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkgewotICAgICAgICBBU1NF UlQobV9kYXRhYmFzZVRocmVhZC0+dGVybWluYXRpb25SZXF1ZXN0ZWQoKSk7Ci0gICAgICAgIG1f ZGF0YWJhc2VUaHJlYWQgPSAwOwotICAgIH0KLSNlbmRpZgotCiAgICAgaWYgKG1fc3R5bGVTaGVl dHMpCiAgICAgICAgIG1fc3R5bGVTaGVldHMtPmRvY3VtZW50RGVzdHJveWVkKCk7CiB9CkBAIC00 Mzk0LDYgKzQzODAsMjkgQEAgdm9pZCBEb2N1bWVudDo6c2V0U2VjdXJpdHlPcmlnaW4oU2VjdXJp dAogICAgIGluaXRETlNQcmVmZXRjaCgpOwogfQogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorCiti b29sIERvY3VtZW50Ojppc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdAoreworICAgIGlmICghcGFn ZSgpIHx8IHBhZ2UoKS0+c2V0dGluZ3MoKS0+cHJpdmF0ZUJyb3dzaW5nRW5hYmxlZCgpKQorICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgRG9jdW1lbnQ6 OmRhdGFiYXNlRXhjZWVkZWRRdW90YShjb25zdCBTdHJpbmcmIG5hbWUpCit7CisgICAgUGFnZSog Y3VycmVudFBhZ2UgPSBwYWdlKCk7CisgICAgaWYgKGN1cnJlbnRQYWdlKQorICAgICAgICBjdXJy ZW50UGFnZS0+Y2hyb21lKCktPmNsaWVudCgpLT5leGNlZWRlZERhdGFiYXNlUXVvdGEoZG9jdW1l bnQoKS0+ZnJhbWUoKSwgbmFtZSk7Cit9CisKKyNlbmRpZgorCitib29sIERvY3VtZW50Ojppc0Nv bnRleHRUaHJlYWQoKSBjb25zdAoreworICAgIHJldHVybiBpc01haW5UaHJlYWQoKTsKK30KKwog dm9pZCBEb2N1bWVudDo6dXBkYXRlVVJMRm9yUHVzaE9yUmVwbGFjZVN0YXRlKGNvbnN0IEtVUkwm IHVybCkKIHsKICAgICBGcmFtZSogZiA9IGZyYW1lKCk7CkBAIC00NDk0LDU3ICs0NTAzLDYgQEAg RE9NU2VsZWN0aW9uKiBEb2N1bWVudDo6Z2V0U2VsZWN0aW9uKCkgYwogICAgIHJldHVybiBmcmFt ZSgpID8gZnJhbWUoKS0+ZG9tV2luZG93KCktPmdldFNlbGVjdGlvbigpIDogMDsKIH0KIAotI2lm IEVOQUJMRShEQVRBQkFTRSkKLQotdm9pZCBEb2N1bWVudDo6YWRkT3BlbkRhdGFiYXNlKERhdGFi YXNlKiBkYXRhYmFzZSkKLXsKLSAgICBpZiAoIW1fb3BlbkRhdGFiYXNlU2V0KQotICAgICAgICBt X29wZW5EYXRhYmFzZVNldC5zZXQobmV3IERhdGFiYXNlU2V0KTsKLQotICAgIEFTU0VSVCghbV9v cGVuRGF0YWJhc2VTZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7Ci0gICAgbV9vcGVuRGF0YWJhc2VT ZXQtPmFkZChkYXRhYmFzZSk7Ci19Ci0KLXZvaWQgRG9jdW1lbnQ6OnJlbW92ZU9wZW5EYXRhYmFz ZShEYXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgQVNTRVJUKG1fb3BlbkRhdGFiYXNlU2V0ICYm IG1fb3BlbkRhdGFiYXNlU2V0LT5jb250YWlucyhkYXRhYmFzZSkpOwotICAgIGlmICghbV9vcGVu RGF0YWJhc2VTZXQpCi0gICAgICAgIHJldHVybjsKLSAgICAgICAgCi0gICAgbV9vcGVuRGF0YWJh c2VTZXQtPnJlbW92ZShkYXRhYmFzZSk7Ci19Ci0KLURhdGFiYXNlVGhyZWFkKiBEb2N1bWVudDo6 ZGF0YWJhc2VUaHJlYWQoKQotewotICAgIGlmICghbV9kYXRhYmFzZVRocmVhZCAmJiAhbV9oYXNP cGVuRGF0YWJhc2VzKSB7Ci0gICAgICAgIC8vIENyZWF0ZSB0aGUgZGF0YWJhc2UgdGhyZWFkIG9u IGZpcnN0IHJlcXVlc3QgLSBidXQgbm90IGlmIGF0IGxlYXN0IG9uZSBkYXRhYmFzZSB3YXMgYWxy ZWFkeSBvcGVuZWQsCi0gICAgICAgIC8vIGJlY2F1c2UgaW4gdGhhdCBjYXNlIHdlIGFscmVhZHkg aGFkIGEgZGF0YWJhc2UgdGhyZWFkIGFuZCB0ZXJtaW5hdGVkIGl0IGFuZCBzaG91bGQgbm90IGNy ZWF0ZSBhbm90aGVyLgotICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0gRGF0YWJhc2VUaHJlYWQ6 OmNyZWF0ZSgpOwotICAgICAgICBpZiAoIW1fZGF0YWJhc2VUaHJlYWQtPnN0YXJ0KCkpCi0gICAg ICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0gMDsKLSAgICB9Ci0KLSAgICByZXR1cm4gbV9kYXRh YmFzZVRocmVhZC5nZXQoKTsKLX0KLQotdm9pZCBEb2N1bWVudDo6c3RvcERhdGFiYXNlcygpCi17 Ci0gICAgaWYgKG1fb3BlbkRhdGFiYXNlU2V0KSB7Ci0gICAgICAgIERhdGFiYXNlU2V0OjppdGVy YXRvciBpID0gbV9vcGVuRGF0YWJhc2VTZXQtPmJlZ2luKCk7Ci0gICAgICAgIERhdGFiYXNlU2V0 OjppdGVyYXRvciBlbmQgPSBtX29wZW5EYXRhYmFzZVNldC0+ZW5kKCk7Ci0gICAgICAgIGZvciAo OyBpICE9IGVuZDsgKytpKSB7Ci0gICAgICAgICAgICAoKmkpLT5zdG9wKCk7Ci0gICAgICAgICAg ICBpZiAobV9kYXRhYmFzZVRocmVhZCkKLSAgICAgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFk LT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcygqaSk7Ci0gICAgICAgIH0KLSAgICB9Ci0gICAgCi0g ICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpCi0gICAgICAgIG1fZGF0YWJhc2VUaHJlYWQtPnJlcXVl c3RUZXJtaW5hdGlvbigpOwotfQotCi0jZW5kaWYKLQogI2lmIEVOQUJMRShXTUwpCiB2b2lkIERv Y3VtZW50OjpyZXNldFdNTFBhZ2VTdGF0ZSgpCiB7CkluZGV4OiBXZWJDb3JlL2RvbS9Eb2N1bWVu dC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL0RvY3VtZW50LmgJKHJldmlzaW9uIDUyOTk1 KQorKysgV2ViQ29yZS9kb20vRG9jdW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtOTE0LDE0ICs5 MTQsMTIgQEAgcHVibGljOgogICAgIGJvb2wgcHJvY2Vzc2luZ0xvYWRFdmVudCgpIGNvbnN0IHsg cmV0dXJuIG1fcHJvY2Vzc2luZ0xvYWRFdmVudDsgfQogCiAjaWYgRU5BQkxFKERBVEFCQVNFKQot ICAgIHZvaWQgYWRkT3BlbkRhdGFiYXNlKERhdGFiYXNlKik7Ci0gICAgdm9pZCByZW1vdmVPcGVu RGF0YWJhc2UoRGF0YWJhc2UqKTsKLSAgICBEYXRhYmFzZVRocmVhZCogZGF0YWJhc2VUaHJlYWQo KTsgICAvLyBDcmVhdGVzIHRoZSB0aHJlYWQgYXMgbmVlZGVkLCBidXQgbm90IGlmIGl0IGhhcyBi ZWVuIGFscmVhZHkgdGVybWluYXRlZC4KLSAgICB2b2lkIHNldEhhc09wZW5EYXRhYmFzZXMoKSB7 IG1faGFzT3BlbkRhdGFiYXNlcyA9IHRydWU7IH0KLSAgICBib29sIGhhc09wZW5EYXRhYmFzZXMo KSB7IHJldHVybiBtX2hhc09wZW5EYXRhYmFzZXM7IH0KLSAgICB2b2lkIHN0b3BEYXRhYmFzZXMo KTsKKyAgICB2aXJ0dWFsIGJvb2wgaXNEYXRhYmFzZVJlYWRPbmx5KCkgY29uc3Q7CisgICAgdmly dHVhbCB2b2lkIGRhdGFiYXNlRXhjZWVkZWRRdW90YShjb25zdCBTdHJpbmcmIG5hbWUpOwogI2Vu ZGlmCiAKKyAgICB2aXJ0dWFsIGJvb2wgaXNDb250ZXh0VGhyZWFkKCkgY29uc3Q7CisKICAgICB2 b2lkIHNldFVzaW5nR2VvbG9jYXRpb24oYm9vbCBmKSB7IG1fdXNpbmdHZW9sb2NhdGlvbiA9IGY7 IH0KICAgICBib29sIHVzaW5nR2VvbG9jYXRpb24oKSBjb25zdCB7IHJldHVybiBtX3VzaW5nR2Vv bG9jYXRpb247IH07CiAKQEAgLTExODMsMTMgKzExODEsNiBAQCBwcml2YXRlOgogICAgIEpTV3Jh cHBlckNhY2hlTWFwIG1fd3JhcHBlckNhY2hlTWFwOwogI2VuZGlmCiAKLSNpZiBFTkFCTEUoREFU QUJBU0UpCi0gICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX2RhdGFiYXNlVGhyZWFkOwotICAg IGJvb2wgbV9oYXNPcGVuRGF0YWJhc2VzOyAgICAvLyBUaGlzIG5ldmVyIGNoYW5nZXMgYmFjayB0 byBmYWxzZSwgZXZlbiBhcyB0aGUgZGF0YWJhc2UgdGhyZWFkIGlzIGNsb3NlZC4KLSAgICB0eXBl ZGVmIEhhc2hTZXQ8RGF0YWJhc2UqPiBEYXRhYmFzZVNldDsKLSAgICBPd25QdHI8RGF0YWJhc2VT ZXQ+IG1fb3BlbkRhdGFiYXNlU2V0OwotI2VuZGlmCi0gICAgCiAgICAgYm9vbCBtX3VzaW5nR2Vv bG9jYXRpb247CiAKICNpZiBFTkFCTEUoV01MKQpJbmRleDogV2ViQ29yZS9kb20vU2NyaXB0RXhl Y3V0aW9uQ29udGV4dC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0 aW9uQ29udGV4dC5jcHAJKHJldmlzaW9uIDUyOTk1KQorKysgV2ViQ29yZS9kb20vU2NyaXB0RXhl Y3V0aW9uQ29udGV4dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI4LDcgKzI4LDggQEAKICNpbmNs dWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAKICNpbmNsdWRlICJBY3RpdmVET01PYmpl Y3QuaCIKLSNpbmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgor I2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCiAjaW5jbHVkZSAiTWVzc2FnZVBvcnQuaCIKICNp bmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKQEAg LTU2LDYgKzU3LDkgQEAgcHVibGljOgogfTsKIAogU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6U2Ny aXB0RXhlY3V0aW9uQ29udGV4dCgpCisjaWYgRU5BQkxFKERBVEFCQVNFKQorICAgIDogbV9oYXNP cGVuRGF0YWJhc2VzKGZhbHNlKQorI2VuZGlmCiB7CiB9CiAKQEAgLTcyLDggKzc2LDY3IEBAIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQ6On5TY3JpcHRFeGVjdXRpb24KICAgICAgICAgQVNTRVJUKCgq aXRlciktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA9PSB0aGlzKTsKICAgICAgICAgKCppdGVy KS0+Y29udGV4dERlc3Ryb3llZCgpOwogICAgIH0KKyAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkg eworICAgICAgICBBU1NFUlQobV9kYXRhYmFzZVRocmVhZC0+dGVybWluYXRpb25SZXF1ZXN0ZWQo KSk7CisgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQgPSAwOworICAgIH0KIH0KIAorI2lmIEVOQUJM RShEQVRBQkFTRSkKKworRGF0YWJhc2VUaHJlYWQqIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OmRh dGFiYXNlVGhyZWFkKCkKK3sKKyAgICBpZiAoIW1fZGF0YWJhc2VUaHJlYWQgJiYgIW1faGFzT3Bl bkRhdGFiYXNlcykgeworICAgICAgICAvLyBDcmVhdGUgdGhlIGRhdGFiYXNlIHRocmVhZCBvbiBm aXJzdCByZXF1ZXN0IC0gYnV0IG5vdCBpZiBhdCBsZWFzdCBvbmUgZGF0YWJhc2Ugd2FzIGFscmVh ZHkgb3BlbmVkLAorICAgICAgICAvLyBiZWNhdXNlIGluIHRoYXQgY2FzZSB3ZSBhbHJlYWR5IGhh ZCBhIGRhdGFiYXNlIHRocmVhZCBhbmQgdGVybWluYXRlZCBpdCBhbmQgc2hvdWxkIG5vdCBjcmVh dGUgYW5vdGhlci4KKyAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IERhdGFiYXNlVGhyZWFkOjpj cmVhdGUoKTsKKyAgICAgICAgaWYgKCFtX2RhdGFiYXNlVGhyZWFkLT5zdGFydCgpKQorICAgICAg ICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IDA7CisgICAgfQorCisgICAgcmV0dXJuIG1fZGF0YWJh c2VUaHJlYWQuZ2V0KCk7Cit9CisKK3ZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6YWRkT3Bl bkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sKKyAgICBBU1NFUlQoaXNDb250ZXh0VGhy ZWFkKCkpOworICAgIGlmICghbV9vcGVuRGF0YWJhc2VTZXQpCisgICAgICAgIG1fb3BlbkRhdGFi YXNlU2V0LnNldChuZXcgRGF0YWJhc2VTZXQoKSk7CisKKyAgICBBU1NFUlQoIW1fb3BlbkRhdGFi YXNlU2V0LT5jb250YWlucyhkYXRhYmFzZSkpOworICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5hZGQo ZGF0YWJhc2UpOworfQorCit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9wZW5E YXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCit7CisgICAgQVNTRVJUKGlzQ29udGV4dFRocmVh ZCgpKTsKKyAgICBBU1NFUlQobV9vcGVuRGF0YWJhc2VTZXQgJiYgbV9vcGVuRGF0YWJhc2VTZXQt PmNvbnRhaW5zKGRhdGFiYXNlKSk7CisgICAgaWYgKCFtX29wZW5EYXRhYmFzZVNldCkKKyAgICAg ICAgcmV0dXJuOworICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5yZW1vdmUoZGF0YWJhc2UpOworfQor Cit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnN0b3BEYXRhYmFzZXMoRGF0YWJhc2VUYXNr U3luY2hyb25pemVyKiBjbGVhbnVwU3luYykKK3sKKyAgICBBU1NFUlQoaXNDb250ZXh0VGhyZWFk KCkpOworICAgIGlmIChtX29wZW5EYXRhYmFzZVNldCkgeworICAgICAgICBEYXRhYmFzZVNldDo6 aXRlcmF0b3IgaSA9IG1fb3BlbkRhdGFiYXNlU2V0LT5iZWdpbigpOworICAgICAgICBEYXRhYmFz ZVNldDo6aXRlcmF0b3IgZW5kID0gbV9vcGVuRGF0YWJhc2VTZXQtPmVuZCgpOworICAgICAgICBm b3IgKDsgaSAhPSBlbmQ7ICsraSkgeworICAgICAgICAgICAgKCppKS0+c3RvcCgpOworICAgICAg ICAgICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpCisgICAgICAgICAgICAgICAgbV9kYXRhYmFzZVRo cmVhZC0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3MoKmkpOworICAgICAgICB9CisgICAgfQorICAg IAorICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKQorICAgICAgICBtX2RhdGFiYXNlVGhyZWFkLT5y ZXF1ZXN0VGVybWluYXRpb24oY2xlYW51cFN5bmMpOworICAgIGVsc2UgaWYgKGNsZWFudXBTeW5j KQorICAgICAgICBjbGVhbnVwU3luYy0+dGFza0NvbXBsZXRlZCgpOworfQorCisjZW5kaWYKKwog dm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0Ojpwcm9jZXNzTWVzc2FnZVBvcnRNZXNzYWdlc1Nv b24oKQogewogICAgIHBvc3RUYXNrKFByb2Nlc3NNZXNzYWdlc1Nvb25UYXNrOjpjcmVhdGUoKSk7 CkluZGV4OiBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oCShyZXZpc2lvbiA1Mjk5NSkK KysrIFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAkod29ya2luZyBjb3B5KQpA QCAtMzMsMTEgKzMzLDE3IEBACiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3 dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8 d3RmL1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogbmFtZXNwYWNlIFdl YkNvcmUgewogCiAgICAgY2xhc3MgQWN0aXZlRE9NT2JqZWN0OworI2lmIEVOQUJMRShEQVRBQkFT RSkKKyAgICBjbGFzcyBEYXRhYmFzZTsKKyAgICBjbGFzcyBEYXRhYmFzZVRhc2tTeW5jaHJvbml6 ZXI7CisgICAgY2xhc3MgRGF0YWJhc2VUaHJlYWQ7CisjZW5kaWYKICAgICBjbGFzcyBET01UaW1l cjsKICAgICBjbGFzcyBNZXNzYWdlUG9ydDsKICAgICBjbGFzcyBTZWN1cml0eU9yaWdpbjsKQEAg LTU5LDYgKzY1LDE5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCBib29s IGlzRG9jdW1lbnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICB2aXJ0dWFsIGJv b2wgaXNXb3JrZXJDb250ZXh0KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KIAorI2lmIEVOQUJM RShEQVRBQkFTRSkKKyAgICAgICAgdmlydHVhbCBib29sIGlzRGF0YWJhc2VSZWFkT25seSgpIGNv bnN0ID0gMDsKKyAgICAgICAgdmlydHVhbCB2b2lkIGRhdGFiYXNlRXhjZWVkZWRRdW90YShjb25z dCBTdHJpbmcmIG5hbWUpID0gMDsKKyAgICAgICAgRGF0YWJhc2VUaHJlYWQqIGRhdGFiYXNlVGhy ZWFkKCk7CisgICAgICAgIHZvaWQgc2V0SGFzT3BlbkRhdGFiYXNlcygpIHsgbV9oYXNPcGVuRGF0 YWJhc2VzID0gdHJ1ZTsgfQorICAgICAgICBib29sIGhhc09wZW5EYXRhYmFzZXMoKSBjb25zdCB7 IHJldHVybiBtX2hhc09wZW5EYXRhYmFzZXM7IH0KKyAgICAgICAgdm9pZCBhZGRPcGVuRGF0YWJh c2UoRGF0YWJhc2UqKTsKKyAgICAgICAgdm9pZCByZW1vdmVPcGVuRGF0YWJhc2UoRGF0YWJhc2Uq KTsKKyAgICAgICAgLy8gV2hlbiB0aGUgZGF0YWJhc2UgY2xlYW51cCBpcyBkb25lLCBjbGVhbnVw U3luYyB3aWxsIGJlIHNpZ25hbGxlZC4KKyAgICAgICAgdm9pZCBzdG9wRGF0YWJhc2VzKERhdGFi YXNlVGFza1N5bmNocm9uaXplciopOworI2VuZGlmCisgICAgICAgIHZpcnR1YWwgYm9vbCBpc0Nv bnRleHRUaHJlYWQoKSBjb25zdCA9IDA7CisKICAgICAgICAgY29uc3QgS1VSTCYgdXJsKCkgY29u c3QgeyByZXR1cm4gdmlydHVhbFVSTCgpOyB9CiAgICAgICAgIEtVUkwgY29tcGxldGVVUkwoY29u c3QgU3RyaW5nJiB1cmwpIGNvbnN0IHsgcmV0dXJuIHZpcnR1YWxDb21wbGV0ZVVSTCh1cmwpOyB9 CiAKQEAgLTk3LDYgKzExNiw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgcHVibGlj OgogICAgICAgICAgICAgdmlydHVhbCB+VGFzaygpOwogICAgICAgICAgICAgdmlydHVhbCB2b2lk IHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKSA9IDA7CisgICAgICAgICAgICAv LyBDZXJ0YWluIHRhc2tzIGdldCBtYXJrZWQgc3BlY2lhbGx5IHNvIHRoYXQgdGhleSBhcmVuJ3Qg ZGlzY2FyZGVkLCBhbmQgYXJlIGV4ZWN1dGVkLCB3aGVuIHRoZSBjb250ZXh0IGlzIHNodXR0aW5n IGRvd24gaXRzIG1lc3NhZ2UgcXVldWUuCisgICAgICAgICAgICB2aXJ0dWFsIGJvb2wgaXNDbGVh bnVwVGFzaygpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgICAgIH07CiAKICAgICAgICAg dmlydHVhbCB2b2lkIHBvc3RUYXNrKFBhc3NPd25QdHI8VGFzaz4pID0gMDsgLy8gRXhlY3V0ZXMg dGhlIHRhc2sgb24gY29udGV4dCdzIHRocmVhZCBhc3luY2hyb25vdXNseS4KQEAgLTEyOSw2ICsx NTAsMTMgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIHZpcnR1YWwgdm9pZCByZWZT Y3JpcHRFeGVjdXRpb25Db250ZXh0KCkgPSAwOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGVyZWZT Y3JpcHRFeGVjdXRpb25Db250ZXh0KCkgPSAwOworCisjaWYgRU5BQkxFKERBVEFCQVNFKQorICAg ICAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fZGF0YWJhc2VUaHJlYWQ7CisgICAgICAgIGJv b2wgbV9oYXNPcGVuRGF0YWJhc2VzOyAvLyBUaGlzIG5ldmVyIGNoYW5nZXMgYmFjayB0byBmYWxz ZSwgZXZlbiBhZnRlciB0aGUgZGF0YWJhc2UgdGhyZWFkIGlzIGNsb3NlZC4KKyAgICAgICAgdHlw ZWRlZiBIYXNoU2V0PERhdGFiYXNlKiA+IERhdGFiYXNlU2V0OworICAgICAgICBPd25QdHI8RGF0 YWJhc2VTZXQ+IG1fb3BlbkRhdGFiYXNlU2V0OworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAkocmV2aXNpb24gNTI5OTUp CisrKyBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU1 OSw3ICs1NTksNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpzdG9wTG9hZGluZyhVbmxvYWRFdmVuCiAK ICNpZiBFTkFCTEUoREFUQUJBU0UpCiAgICAgICAgIGlmIChkYXRhYmFzZVBvbGljeSA9PSBEYXRh YmFzZVBvbGljeVN0b3ApCi0gICAgICAgICAgICBkb2MtPnN0b3BEYXRhYmFzZXMoKTsKKyAgICAg ICAgICAgIGRvYy0+c3RvcERhdGFiYXNlcygwKTsKICNlbHNlCiAgICAgVU5VU0VEX1BBUkFNKGRh dGFiYXNlUG9saWN5KTsKICNlbmRpZgpJbmRleDogV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAJKHJldmlzaW9uIDUyOTk1 KQorKysgV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTExMTYs OCArMTExNiwxMCBAQCBQYXNzUmVmUHRyPERhdGFiYXNlPiBET01XaW5kb3c6Om9wZW5EYXRhCiAg ICAgICAgIHJldHVybiAwOwogCiAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gbV9mcmFtZS0+ZG9j dW1lbnQoKTsKLSAgICBpZiAoIWRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NE YXRhYmFzZSgpKQorICAgIGlmICghZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vz c0RhdGFiYXNlKCkpIHsKKyAgICAgICAgZWMgPSBTRUNVUklUWV9FUlI7CiAgICAgICAgIHJldHVy biAwOworICAgIH0KIAogICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IG1fZnJhbWUtPnNldHRpbmdz KCk7CiAgICAgaWYgKCFzZXR0aW5ncyB8fCAhc2V0dGluZ3MtPmRhdGFiYXNlc0VuYWJsZWQoKSkK SW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3Jh Z2UvRGF0YWJhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01Myw4ICs1Myw4IEBACiAjaW5jbHVk ZSAiU1FMUmVzdWx0U2V0LmgiCiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb25DbGllbnQuaCIKICNp bmNsdWRlICJTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCi0jaW5jbHVkZSA8d3RmL01haW5U aHJlYWQuaD4KLSNlbmRpZgorCisjZW5kaWYgLy8gRU5BQkxFKERBVEFCQVNFKQogCiAjaWYgVVNF KEpTQykKICNpbmNsdWRlICJKU0RPTVdpbmRvdy5oIgpAQCAtNzMsNiArNzMsMTggQEAgY29uc3Qg U3RyaW5nJiBEYXRhYmFzZTo6ZGF0YWJhc2VJbmZvVGFibAogCiAjaWYgRU5BQkxFKERBVEFCQVNF KQogCitzdGF0aWMgYm9vbCBpc0RhdGFiYXNlQXZhaWxhYmxlID0gZmFsc2U7CisKK3ZvaWQgRGF0 YWJhc2U6OnNldElzQXZhaWxhYmxlKGJvb2wgYXZhaWxhYmxlKQoreworICAgIGlzRGF0YWJhc2VB dmFpbGFibGUgPSBhdmFpbGFibGU7Cit9CisKK2Jvb2wgRGF0YWJhc2U6OmlzQXZhaWxhYmxlKCkK K3sKKyAgICByZXR1cm4gaXNEYXRhYmFzZUF2YWlsYWJsZTsKK30KKwogc3RhdGljIE11dGV4JiBn dWlkTXV0ZXgoKQogewogICAgIC8vIE5vdGU6IFdlIGRvbid0IGhhdmUgdG8gdXNlIEF0b21pY2Fs bHlJbml0aWFsaXplZFN0YXRpYyBoZXJlIGJlY2F1c2UKQEAgLTEyMCwzOSArMTMyLDQxIEBAIHN0 YXRpYyBjb25zdCBTdHJpbmcmIGRhdGFiYXNlVmVyc2lvbktleSgKIAogc3RhdGljIGludCBndWlk Rm9yT3JpZ2luQW5kTmFtZShjb25zdCBTdHJpbmcmIG9yaWdpbiwgY29uc3QgU3RyaW5nJiBuYW1l KTsKIAotUGFzc1JlZlB0cjxEYXRhYmFzZT4gRGF0YWJhc2U6Om9wZW5EYXRhYmFzZShEb2N1bWVu dCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZl cnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVk U2l6ZSwgRXhjZXB0aW9uQ29kZSYgZSkKK1Bhc3NSZWZQdHI8RGF0YWJhc2U+IERhdGFiYXNlOjpv cGVuRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5n JiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNw bGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNlcHRpb25Db2RlJiBlKQog ewotICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0YWJsaXNoRGF0YWJh c2UoZG9jdW1lbnQsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKSkgeworICAgIGlm ICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0YWJsaXNoRGF0YWJhc2UoY29udGV4 dCwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKSB7CiAgICAgICAgIC8vIEZJWE1F OiBUaGVyZSBzaG91bGQgYmUgYW4gZXhjZXB0aW9uIHJhaXNlZCBoZXJlIGluIGFkZGl0aW9uIHRv IHJldHVybmluZyBhIG51bGwgRGF0YWJhc2Ugb2JqZWN0LiAgVGhlIHF1ZXN0aW9uIGhhcyBiZWVu IHJhaXNlZCB3aXRoIHRoZSBXSEFUV0cuCi0gICAgICAgIExPRyhTdG9yYWdlQVBJLCAiRGF0YWJh c2UgJXMgZm9yIG9yaWdpbiAlcyBub3QgYWxsb3dlZCB0byBiZSBlc3RhYmxpc2hlZCIsIG5hbWUu YXNjaWkoKS5kYXRhKCksIGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT50b1N0cmluZygpLmFz Y2lpKCkuZGF0YSgpKTsKKyAgICAgICAgTE9HKFN0b3JhZ2VBUEksICJEYXRhYmFzZSAlcyBmb3Ig b3JpZ2luICVzIG5vdCBhbGxvd2VkIHRvIGJlIGVzdGFibGlzaGVkIiwgbmFtZS5hc2NpaSgpLmRh dGEoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKS5hc2NpaSgpLmRhdGEo KSk7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIFJlZlB0cjxEYXRhYmFzZT4gZGF0 YWJhc2UgPSBhZG9wdFJlZihuZXcgRGF0YWJhc2UoZG9jdW1lbnQsIG5hbWUsIGV4cGVjdGVkVmVy c2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKKyAgICBSZWZQdHI8RGF0YWJhc2U+ IGRhdGFiYXNlID0gYWRvcHRSZWYobmV3IERhdGFiYXNlKGNvbnRleHQsIG5hbWUsIGV4cGVjdGVk VmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKIAogICAgIGlmICghZGF0YWJh c2UtPm9wZW5BbmRWZXJpZnlWZXJzaW9uKGUpKSB7CiAgICAgICAgIExPRyhTdG9yYWdlQVBJLCAi RmFpbGVkIHRvIG9wZW4gYW5kIHZlcmlmeSB2ZXJzaW9uIChleHBlY3RlZCAlcykgb2YgZGF0YWJh c2UgJXMiLCBleHBlY3RlZFZlcnNpb24uYXNjaWkoKS5kYXRhKCksIGRhdGFiYXNlLT5kYXRhYmFz ZURlYnVnTmFtZSgpLmFzY2lpKCkuZGF0YSgpKTsKLSAgICAgICAgZG9jdW1lbnQtPnJlbW92ZU9w ZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CisgICAgICAgIGNvbnRleHQtPnJlbW92ZU9wZW5E YXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tl cigpLnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAgIHJldHVybiAw OwogICAgIH0KIAotICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnNldERhdGFiYXNlRGV0 YWlscyhkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGlt YXRlZFNpemUpOwotCi0gICAgZG9jdW1lbnQtPnNldEhhc09wZW5EYXRhYmFzZXMoKTsKKyAgICBE YXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5zZXREYXRhYmFzZURldGFpbHMoY29udGV4dC0+c2Vj dXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpOwogCisgICAg Y29udGV4dC0+c2V0SGFzT3BlbkRhdGFiYXNlcygpOwogI2lmIEVOQUJMRShJTlNQRUNUT1IpCi0g ICAgaWYgKFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+ZnJhbWUoKS0+cGFnZSgpKQotICAgICAgICBw YWdlLT5pbnNwZWN0b3JDb250cm9sbGVyKCktPmRpZE9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQo KSwgZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmhvc3QoKSwgbmFtZSwgZXhwZWN0ZWRWZXJz aW9uKTsKKyAgICBpZiAoY29udGV4dC0+aXNEb2N1bWVudCgpKSB7CisgICAgICAgIERvY3VtZW50 KiBkb2N1bWVudCA9IHN0YXRpY19jYXN0PERvY3VtZW50Kj4oY29udGV4dCk7CisgICAgICAgIGlm IChQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKSkKKyAgICAgICAgICAgIHBhZ2UtPmluc3Bl Y3RvckNvbnRyb2xsZXIoKS0+ZGlkT3BlbkRhdGFiYXNlKGRhdGFiYXNlLmdldCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5ob3N0KCksIG5hbWUsIGV4cGVjdGVkVmVyc2lvbik7CisgICAg fQogI2VuZGlmCiAKICAgICByZXR1cm4gZGF0YWJhc2U7CiB9CiAKLURhdGFiYXNlOjpEYXRhYmFz ZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBl eHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSkKK0RhdGFiYXNlOjpEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJz aW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNp emUpCiAgICAgOiBtX3RyYW5zYWN0aW9uSW5Qcm9ncmVzcyhmYWxzZSkKICAgICAsIG1faXNUcmFu c2FjdGlvblF1ZXVlRW5hYmxlZCh0cnVlKQotICAgICwgbV9kb2N1bWVudChkb2N1bWVudCkKKyAg ICAsIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dChjb250ZXh0KQogICAgICwgbV9uYW1lKG5hbWUu Y3Jvc3NUaHJlYWRTdHJpbmcoKSkKICAgICAsIG1fZ3VpZCgwKQogICAgICwgbV9leHBlY3RlZFZl cnNpb24oZXhwZWN0ZWRWZXJzaW9uLmNyb3NzVGhyZWFkU3RyaW5nKCkpCkBAIC0xNjIsMTYgKzE3 NiwxNSBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjCiAgICAgLCBt X3N0b3BwZWQoZmFsc2UpCiAgICAgLCBtX29wZW5lZChmYWxzZSkKIHsKLSAgICBBU1NFUlQoZG9j dW1lbnQpOwotICAgIG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luID0gZG9jdW1lbnQtPnNlY3Vy aXR5T3JpZ2luKCk7CisgICAgQVNTRVJUKG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC5nZXQoKSk7 CisgICAgbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4gPSBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQtPnNlY3VyaXR5T3JpZ2luKCk7CiAgICAgbV9kYXRhYmFzZVRocmVhZFNlY3VyaXR5T3JpZ2lu ID0gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4tPnRocmVhZHNhZmVDb3B5KCk7Ci0KICAgICBp ZiAobV9uYW1lLmlzTnVsbCgpKQogICAgICAgICBtX25hbWUgPSAiIjsKIAogICAgIFNjcmlwdENv bnRyb2xsZXI6OmluaXRpYWxpemVUaHJlYWRpbmcoKTsKIAotICAgIG1fZ3VpZCA9IGd1aWRGb3JP cmlnaW5BbmROYW1lKG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLT50b1N0cmluZygpLCBuYW1l KTsKKyAgICBtX2d1aWQgPSBndWlkRm9yT3JpZ2luQW5kTmFtZShzZWN1cml0eU9yaWdpbigpLT50 b1N0cmluZygpLCBuYW1lKTsKIAogICAgIHsKICAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKGd1 aWRNdXRleCgpKTsKQEAgLTE4NSwyOCArMTk4LDQwIEBAIERhdGFiYXNlOjpEYXRhYmFzZShEb2N1 bWVudCogZG9jdW1lbnQsIGMKICAgICAgICAgaGFzaFNldC0+YWRkKHRoaXMpOwogICAgIH0KIAot ICAgIEFTU0VSVChtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKTsKLQotICAgIG1fZmlsZW5h bWUgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxsUGF0aEZvckRhdGFiYXNlKG1fbWFp blRocmVhZFNlY3VyaXR5T3JpZ2luLmdldCgpLCBtX25hbWUpOworICAgIEFTU0VSVChtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpOworICAgIG1fZmlsZW5hbWUgPSBE YXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxsUGF0aEZvckRhdGFiYXNlKHNlY3VyaXR5T3Jp Z2luKCksIG1fbmFtZSk7CiAKICAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5hZGRPcGVu RGF0YWJhc2UodGhpcyk7Ci0gICAgbV9kb2N1bWVudC0+YWRkT3BlbkRhdGFiYXNlKHRoaXMpOwor ICAgIGNvbnRleHQtPmFkZE9wZW5EYXRhYmFzZSh0aGlzKTsKIH0KIAotc3RhdGljIHZvaWQgZGVy ZWZEb2N1bWVudCh2b2lkKiBkb2N1bWVudCkKLXsKLSAgICBzdGF0aWNfY2FzdDxEb2N1bWVudCo+ KGRvY3VtZW50KS0+ZGVyZWYoKTsKLX0KK2NsYXNzIERlcmVmQ29udGV4dFRhc2sgOiBwdWJsaWMg U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NP d25QdHI8RGVyZWZDb250ZXh0VGFzaz4gY3JlYXRlKCkKKyAgICB7CisgICAgICAgIHJldHVybiBu ZXcgRGVyZWZDb250ZXh0VGFzaygpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3Jt VGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQorICAgIHsKKyAgICAgICAgY29u dGV4dC0+ZGVyZWYoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGVhbnVwVGFzaygp IGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KK307CiAKIERhdGFiYXNlOjp+RGF0YWJhc2UoKQogewot ICAgIC8vIERlcmVmIG1fZG9jdW1lbnQgb24gdGhlIG1haW4gdGhyZWFkLgotICAgIGNhbGxPbk1h aW5UaHJlYWQoZGVyZWZEb2N1bWVudCwgbV9kb2N1bWVudC5yZWxlYXNlKCkucmVsZWFzZVJlZigp KTsKKyAgICAvLyBUaGUgcmVmZXJlbmNlIHRvIHRoZSBTY3JpcHRFeGVjdXRpb25Db250ZXh0IG5l ZWRzIHRvIGJlIGNsZWFyZWQgb24gdGhlIEphdmFTY3JpcHQgdGhyZWFkLiAgSWYgd2UncmUgb24g dGhhdCB0aHJlYWQgYWxyZWFkeSwgd2UgY2FuIGp1c3QgbGV0IHRoZSBSZWZQdHIncyBkZXN0cnVj dGlvbiBkbyB0aGUgZGVyZWZmaW5nLgorICAgIGlmICghbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0 LT5pc0NvbnRleHRUaHJlYWQoKSkgeworICAgICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQt PnBvc3RUYXNrKERlcmVmQ29udGV4dFRhc2s6OmNyZWF0ZSgpKTsKKyAgICAgICAgbV9zY3JpcHRF eGVjdXRpb25Db250ZXh0LnJlbGVhc2UoKS5yZWxlYXNlUmVmKCk7CisgICAgfQogfQogCiBib29s IERhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbihFeGNlcHRpb25Db2RlJiBlKQogewotICAg IGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAoIW1fc2NyaXB0RXhl Y3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwog ICAgIG1fZGF0YWJhc2VBdXRob3JpemVyID0gRGF0YWJhc2VBdXRob3JpemVyOjpjcmVhdGUoKTsK IApAQCAtMjE0LDcgKzIzOSw3IEBAIGJvb2wgRGF0YWJhc2U6Om9wZW5BbmRWZXJpZnlWZXJzaW9u KEV4Y2UKICAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgc3luY2hyb25pemVyOwogICAgIE93 blB0cjxEYXRhYmFzZU9wZW5UYXNrPiB0YXNrID0gRGF0YWJhc2VPcGVuVGFzazo6Y3JlYXRlKHRo aXMsICZzeW5jaHJvbml6ZXIsIGUsIHN1Y2Nlc3MpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJh c2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICBt X3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRp YXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CiAgICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNrQ29t cGxldGlvbigpOwogCiAgICAgcmV0dXJuIHN1Y2Nlc3M7CkBAIC0zMDksNDMgKzMzNCw2MSBAQCBi b29sIERhdGFiYXNlOjp2ZXJzaW9uTWF0Y2hlc0V4cGVjdGVkKCkgCiAKIHZvaWQgRGF0YWJhc2U6 Om1hcmtBc0RlbGV0ZWRBbmRDbG9zZSgpCiB7Ci0gICAgaWYgKG1fZGVsZXRlZCB8fCAhbV9kb2N1 bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAobV9kZWxldGVkIHx8ICFtX3NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAg IExPRyhTdG9yYWdlQVBJLCAiTWFya2luZyAlcyAoJXApIGFzIGRlbGV0ZWQiLCBzdHJpbmdJZGVu dGlmaWVyKCkuYXNjaWkoKS5kYXRhKCksIHRoaXMpOwogICAgIG1fZGVsZXRlZCA9IHRydWU7CiAK LSAgICBpZiAobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+dGVybWluYXRpb25SZXF1ZXN0 ZWQoKSkgeworICAgIGlmIChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFk KCktPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpIHsKICAgICAgICAgTE9HKFN0b3JhZ2VBUEksICJE YXRhYmFzZSBoYW5kbGUgJXAgaXMgb24gYSB0ZXJtaW5hdGVkIERhdGFiYXNlVGhyZWFkLCBjYW5u b3QgYmUgbWFya2VkIGZvciBub3JtYWwgY2xvc3VyZVxuIiwgdGhpcyk7CiAgICAgICAgIHJldHVy bjsKICAgICB9CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT51bnNjaGVkdWxl RGF0YWJhc2VUYXNrcyh0aGlzKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFi YXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKHRoaXMpOwogCiAgICAgRGF0YWJh c2VUYXNrU3luY2hyb25pemVyIHN5bmNocm9uaXplcjsKICAgICBPd25QdHI8RGF0YWJhc2VDbG9z ZVRhc2s+IHRhc2sgPSBEYXRhYmFzZUNsb3NlVGFzazo6Y3JlYXRlKHRoaXMsICZzeW5jaHJvbml6 ZXIpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlh dGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRh dGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CiAg ICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOwogfQogCi1zdGF0aWMgdm9p ZCBkb2N1bWVudFJlbW92ZU9wZW5EYXRhYmFzZSh2b2lkKiBjb250ZXh0KQotewotICAgIEFTU0VS VChpc01haW5UaHJlYWQoKSk7Ci0gICAgRGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8 RGF0YWJhc2UqPihjb250ZXh0KTsKLSAgICBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cmVtb3ZlT3Bl bkRhdGFiYXNlKGRhdGFiYXNlKTsKLSAgICBkYXRhYmFzZS0+ZGVyZWYoKTsKLX0KK2NsYXNzIENv bnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPENvbnRleHRSZW1vdmVP cGVuRGF0YWJhc2VUYXNrPiBjcmVhdGUoUGFzc1JlZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2UpCisg ICAgeworICAgICAgICByZXR1cm4gbmV3IENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrKGRh dGFiYXNlKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCkKKyAgICB7CisgICAgICAgIGNvbnRleHQtPnJlbW92ZU9w ZW5EYXRhYmFzZShtX2RhdGFiYXNlLmdldCgpKTsKKyAgICAgICAgRGF0YWJhc2VUcmFja2VyOjp0 cmFja2VyKCkucmVtb3ZlT3BlbkRhdGFiYXNlKG1fZGF0YWJhc2UuZ2V0KCkpOworICAgIH0KKwor ICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQor Citwcml2YXRlOgorICAgIENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrKFBhc3NSZWZQdHI8 RGF0YWJhc2U+IGRhdGFiYXNlKQorICAgICAgICA6IG1fZGF0YWJhc2UoZGF0YWJhc2UpCisgICAg eworICAgIH0KKworICAgIFJlZlB0cjxEYXRhYmFzZT4gbV9kYXRhYmFzZTsKK307CiAKIHZvaWQg RGF0YWJhc2U6OmNsb3NlKCkKIHsKICAgICBpZiAoIW1fb3BlbmVkKQogICAgICAgICByZXR1cm47 CiAKLSAgICBBU1NFUlQobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSk7Ci0gICAgQVNTRVJU KGN1cnJlbnRUaHJlYWQoKSA9PSBkb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJl YWRJRCgpKTsKKyAgICBBU1NFUlQobV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRo cmVhZCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IG1fc2NyaXB0RXhlY3V0aW9u Q29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgbV9zcWxpdGVE YXRhYmFzZS5jbG9zZSgpOwotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnJlY29y ZERhdGFiYXNlQ2xvc2VkKHRoaXMpOworICAgIC8vIE11c3QgcmVmKCkgYmVmb3JlIGNhbGxpbmcg ZGF0YWJhc2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VDbG9zZWQoKS4KKyAgICBSZWZQdHI8RGF0 YWJhc2U+IGhvbGRlciA9IHRoaXM7CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRh YmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNsb3NlZCh0aGlzKTsKICAgICBtX29wZW5lZCA9 IGZhbHNlOwogCiAgICAgewpAQCAtMzYyLDExICs0MDUsOCBAQCB2b2lkIERhdGFiYXNlOjpjbG9z ZSgpCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgp LT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsKLQotICAgIERhdGFiYXNlVHJhY2tlcjo6 dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZSh0aGlzKTsKLSAgICByZWYoKTsgIC8vIGRlcmVm KCkgY2FsbGVkIGluIGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNlKCkKLSAgICBjYWxsT25NYWlu VGhyZWFkKGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNlLCB0aGlzKTsKKyAgICBtX3NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tz KHRoaXMpOworICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+cG9zdFRhc2soQ29udGV4dFJl bW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZShob2xkZXIpKTsKIH0KIAogdm9pZCBEYXRhYmFz ZTo6c3RvcCgpCkBAIC01MzIsOCArNTcyLDggQEAgYm9vbCBEYXRhYmFzZTo6cGVyZm9ybU9wZW5B bmRWZXJpZnkoRXhjZQogICAgIC8vIEFsbCBjaGVja3MgcGFzc2VkIGFuZCB3ZSBzdGlsbCBoYXZl IGEgaGFuZGxlIHRvIHRoaXMgZGF0YWJhc2UgZmlsZS4KICAgICAvLyBNYWtlIHN1cmUgRGF0YWJh c2VUaHJlYWQgY2xvc2VzIGl0IHdoZW4gRGF0YWJhc2VUaHJlYWQgZ29lcyBhd2F5LgogICAgIG1f b3BlbmVkID0gdHJ1ZTsKLSAgICBpZiAobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKLSAg ICAgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VPcGVuKHRo aXMpOworICAgIGlmIChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkp CisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+cmVj b3JkRGF0YWJhc2VPcGVuKHRoaXMpOwogCiAgICAgcmV0dXJuIHRydWU7CiB9CkBAIC01NjcsMzIg KzYwNyw1MiBAQCB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uKCkKICAgICAgICAg bV90cmFuc2FjdGlvblF1ZXVlLnJlbW92ZUZpcnN0KCk7CiAgICAgfQogCi0gICAgaWYgKHRyYW5z YWN0aW9uICYmIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpIHsKKyAgICBpZiAodHJhbnNh Y3Rpb24gJiYgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpKSB7CiAg ICAgICAgIE93blB0cjxEYXRhYmFzZVRyYW5zYWN0aW9uVGFzaz4gdGFzayA9IERhdGFiYXNlVHJh bnNhY3Rpb25UYXNrOjpjcmVhdGUodHJhbnNhY3Rpb24pOwogICAgICAgICBMT0coU3RvcmFnZUFQ SSwgIlNjaGVkdWxpbmcgRGF0YWJhc2VUcmFuc2FjdGlvblRhc2sgJXAgZm9yIHRyYW5zYWN0aW9u ICVwXG4iLCB0YXNrLmdldCgpLCB0YXNrLT50cmFuc2FjdGlvbigpKTsKICAgICAgICAgbV90cmFu c2FjdGlvbkluUHJvZ3Jlc3MgPSB0cnVlOwotICAgICAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRo cmVhZCgpLT5zY2hlZHVsZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgICAgICBtX3NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0YXNrLnJlbGVh c2UoKSk7CiAgICAgfSBlbHNlCiAgICAgICAgIG1fdHJhbnNhY3Rpb25JblByb2dyZXNzID0gZmFs c2U7CiB9CiAKIHZvaWQgRGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25TdGVwKFNRTFRyYW5z YWN0aW9uKiB0cmFuc2FjdGlvbiwgYm9vbCBpbW1lZGlhdGVseSkKIHsKLSAgICBpZiAoIW1fZG9j dW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpCisgICAgaWYgKCFtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIE93blB0cjxEYXRh YmFzZVRyYW5zYWN0aW9uVGFzaz4gdGFzayA9IERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrOjpjcmVh dGUodHJhbnNhY3Rpb24pOwogICAgIExPRyhTdG9yYWdlQVBJLCAiU2NoZWR1bGluZyBEYXRhYmFz ZVRyYW5zYWN0aW9uVGFzayAlcCBmb3IgdGhlIHRyYW5zYWN0aW9uIHN0ZXBcbiIsIHRhc2suZ2V0 KCkpOwogICAgIGlmIChpbW1lZGlhdGVseSkKLSAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VU aHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAgICAg bV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVk aWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOwogICAgIGVsc2UKLSAgICAgICAgbV9kb2N1bWVudC0+ ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAgICAg bV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZVRhc2so dGFzay5yZWxlYXNlKCkpOwogfQogCitjbGFzcyBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayA6 IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0 aWMgUGFzc093blB0cjxEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzaz4gY3JlYXRlKFBhc3NSZWZQ dHI8U1FMVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5l dyBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayh0cmFuc2FjdGlvbik7CisgICAgfQorCisgICAg dmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQorICAgIHsK KyAgICAgICAgbV90cmFuc2FjdGlvbi0+cGVyZm9ybVBlbmRpbmdDYWxsYmFjaygpOworICAgIH0K KworcHJpdmF0ZToKKyAgICBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayhQYXNzUmVmUHRyPFNR TFRyYW5zYWN0aW9uPiB0cmFuc2FjdGlvbikKKyAgICAgICAgOiBtX3RyYW5zYWN0aW9uKHRyYW5z YWN0aW9uKQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8U1FMVHJhbnNhY3Rpb24+IG1fdHJh bnNhY3Rpb247Cit9OworCiB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uQ2FsbGJh Y2soU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewotICAgIHRyYW5zYWN0aW9uLT5yZWYo KTsKLSAgICBjYWxsT25NYWluVGhyZWFkKGRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2ssIHRyYW5zYWN0 aW9uKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKERlbGl2ZXJQZW5k aW5nQ2FsbGJhY2tUYXNrOjpjcmVhdGUodHJhbnNhY3Rpb24pKTsKIH0KIAogVmVjdG9yPFN0cmlu Zz4gRGF0YWJhc2U6OnBlcmZvcm1HZXRUYWJsZU5hbWVzKCkKQEAgLTYyNiwxMiArNjg2LDEyIEBA IFZlY3RvcjxTdHJpbmc+IERhdGFiYXNlOjpwZXJmb3JtR2V0VGFibGUKIAogU1FMVHJhbnNhY3Rp b25DbGllbnQqIERhdGFiYXNlOjp0cmFuc2FjdGlvbkNsaWVudCgpIGNvbnN0CiB7Ci0gICAgcmV0 dXJuIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnRyYW5zYWN0aW9uQ2xpZW50KCk7Cisg ICAgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+dHJh bnNhY3Rpb25DbGllbnQoKTsKIH0KIAogU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvciogRGF0YWJh c2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSBjb25zdAogewotICAgIHJldHVybiBtX2RvY3Vt ZW50LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCk7CisgICAgcmV0 dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+dHJhbnNhY3Rp b25Db29yZGluYXRvcigpOwogfQogCiBTdHJpbmcgRGF0YWJhc2U6OnZlcnNpb24oKSBjb25zdApA QCAtNjQyLDI1ICs3MDIsMTggQEAgU3RyaW5nIERhdGFiYXNlOjp2ZXJzaW9uKCkgY29uc3QKICAg ICByZXR1cm4gZ3VpZFRvVmVyc2lvbk1hcCgpLmdldChtX2d1aWQpLnRocmVhZHNhZmVDb3B5KCk7 CiB9CiAKLXZvaWQgRGF0YWJhc2U6OmRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2sodm9pZCogY29udGV4 dCkKLXsKLSAgICBTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24gPSBzdGF0aWNfY2FzdDxTUUxU cmFuc2FjdGlvbio+KGNvbnRleHQpOwotICAgIHRyYW5zYWN0aW9uLT5wZXJmb3JtUGVuZGluZ0Nh bGxiYWNrKCk7Ci0gICAgdHJhbnNhY3Rpb24tPmRlcmVmKCk7IC8vIFdhcyByZWYnZCBpbiBzY2hl ZHVsZVRyYW5zYWN0aW9uQ2FsbGJhY2soKS4KLX0KLQogVmVjdG9yPFN0cmluZz4gRGF0YWJhc2U6 OnRhYmxlTmFtZXMoKQogewogICAgIC8vIEZJWE1FOiBOb3QgdXNpbmcgdGhyZWFkc2FmZUNvcHkg b24gdGhlc2Ugc3RyaW5ncyBsb29rcyBvayBzaW5jZSB0aHJlYWRzIHRha2Ugc3RyaWN0IHR1cm5z CiAgICAgLy8gaW4gZGVhbGluZyB3aXRoIHRoZW0uIEhvd2V2ZXIsIGlmIHRoZSBjb2RlIGNoYW5n ZXMsIHRoaXMgbWF5IG5vdCBiZSB0cnVlIGFueW1vcmUuCiAgICAgVmVjdG9yPFN0cmluZz4gcmVz dWx0OwotICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAoIW1f c2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKICAgICAgICAgcmV0dXJu IHJlc3VsdDsKIAogICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBzeW5jaHJvbml6ZXI7CiAg ICAgT3duUHRyPERhdGFiYXNlVGFibGVOYW1lc1Rhc2s+IHRhc2sgPSBEYXRhYmFzZVRhYmxlTmFt ZXNUYXNrOjpjcmVhdGUodGhpcywgJnN5bmNocm9uaXplciwgcmVzdWx0KTsKIAotICAgIG1fZG9j dW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVh c2UoKSk7CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5z Y2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOwogICAgIHN5bmNocm9uaXplci53 YWl0Rm9yVGFza0NvbXBsZXRpb24oKTsKIAogICAgIHJldHVybiByZXN1bHQ7CkBAIC02NzYsOSAr NzI5LDkgQEAgdm9pZCBEYXRhYmFzZTo6c2V0RXhwZWN0ZWRWZXJzaW9uKGNvbnN0IAogCiBTZWN1 cml0eU9yaWdpbiogRGF0YWJhc2U6OnNlY3VyaXR5T3JpZ2luKCkgY29uc3QKIHsKLSAgICBpZiAo aXNNYWluVGhyZWFkKCkpCisgICAgaWYgKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNDb250 ZXh0VGhyZWFkKCkpCiAgICAgICAgIHJldHVybiBtX21haW5UaHJlYWRTZWN1cml0eU9yaWdpbi5n ZXQoKTsKLSAgICBpZiAoY3VycmVudFRocmVhZCgpID09IGRvY3VtZW50KCktPmRhdGFiYXNlVGhy ZWFkKCktPmdldFRocmVhZElEKCkpCisgICAgaWYgKGN1cnJlbnRUaHJlYWQoKSA9PSBtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpCiAgICAg ICAgIHJldHVybiBtX2RhdGFiYXNlVGhyZWFkU2VjdXJpdHlPcmlnaW4uZ2V0KCk7CiAgICAgcmV0 dXJuIDA7CiB9CkBAIC03MDYsNiArNzU5LDYgQEAgU3RyaW5nIERhdGFiYXNlOjpmaWxlTmFtZSgp IGNvbnN0CiAgICAgcmV0dXJuIG1fZmlsZW5hbWUudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAotI2Vu ZGlmCisjZW5kaWYgLy8gRU5BQkxFKERBVEFCQVNFKQogCi19Cit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3JlL3N0b3Jh Z2UvRGF0YWJhc2UuaAkod29ya2luZyBjb3B5KQpAQCAtNTIsNyArNTIsNyBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKIGNsYXNzIERhdGFiYXNlQXV0aG9yaXplcjsKIGNsYXNzIERhdGFiYXNlVGhy ZWFkOwotY2xhc3MgRG9jdW1lbnQ7CitjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogY2xh c3MgU1FMUmVzdWx0U2V0OwogY2xhc3MgU1FMVHJhbnNhY3Rpb25DYWxsYmFjazsKIGNsYXNzIFNR TFRyYW5zYWN0aW9uQ2xpZW50OwpAQCAtNjcsMTAgKzY3LDEzIEBAIGNsYXNzIERhdGFiYXNlIDog cHVibGljIFRocmVhZFNhZmVTaGFyZWQKICAgICBmcmllbmQgY2xhc3MgU1FMU3RhdGVtZW50Owog ICAgIGZyaWVuZCBjbGFzcyBTUUxUcmFuc2FjdGlvbjsKIHB1YmxpYzoKKyAgICBzdGF0aWMgdm9p ZCBzZXRJc0F2YWlsYWJsZShib29sKTsKKyAgICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgpOwor CiAgICAgfkRhdGFiYXNlKCk7CiAKIC8vIERpcmVjdCBzdXBwb3J0IGZvciB0aGUgRE9NIEFQSQot ICAgIHN0YXRpYyBQYXNzUmVmUHRyPERhdGFiYXNlPiBvcGVuRGF0YWJhc2UoRG9jdW1lbnQqIGRv Y3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9u LCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUs IEV4Y2VwdGlvbkNvZGUmKTsKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxEYXRhYmFzZT4gb3BlbkRh dGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFt ZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5h bWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYpOwogICAgIFN0 cmluZyB2ZXJzaW9uKCkgY29uc3Q7CiAgICAgdm9pZCBjaGFuZ2VWZXJzaW9uKGNvbnN0IFN0cmlu ZyYgb2xkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBuZXdWZXJzaW9uLAogICAgICAgICAgICAgICAg ICAgICAgICBQYXNzUmVmUHRyPFNRTFRyYW5zYWN0aW9uQ2FsbGJhY2s+IGNhbGxiYWNrLCBQYXNz UmVmUHRyPFNRTFRyYW5zYWN0aW9uRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaywKQEAgLTg3 LDcgKzkwLDcgQEAgcHVibGljOgogCiAgICAgVmVjdG9yPFN0cmluZz4gdGFibGVOYW1lcygpOwog Ci0gICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3QgeyByZXR1cm4gbV9kb2N1bWVudC5nZXQo KTsgfQorICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQo KSBjb25zdCB7IHJldHVybiBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuZ2V0KCk7IH0KICAgICBT ZWN1cml0eU9yaWdpbiogc2VjdXJpdHlPcmlnaW4oKSBjb25zdDsKICAgICBTdHJpbmcgc3RyaW5n SWRlbnRpZmllcigpIGNvbnN0OwogICAgIFN0cmluZyBkaXNwbGF5TmFtZSgpIGNvbnN0OwpAQCAt MTIzLDggKzEyNiw5IEBAIHB1YmxpYzoKICAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0 cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkgY29uc3Q7CiAKIHByaXZhdGU6Ci0gICAgRGF0YWJhc2Uo RG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhw ZWN0ZWRWZXJzaW9uLAotICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisgICAgRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLAorICAgICAgICAgICAgIGNvbnN0 IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLAorICAg ICAgICAgICAgIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAKICAgICBib29sIG9wZW5B bmRWZXJpZnlWZXJzaW9uKEV4Y2VwdGlvbkNvZGUmKTsKIApAQCAtMTM5LDcgKzE0Myw3IEBAIHBy aXZhdGU6CiAKICAgICBzdGF0aWMgdm9pZCBkZWxpdmVyUGVuZGluZ0NhbGxiYWNrKHZvaWQqKTsK IAotICAgIFJlZlB0cjxEb2N1bWVudD4gbV9kb2N1bWVudDsKKyAgICBSZWZQdHI8U2NyaXB0RXhl Y3V0aW9uQ29udGV4dD4gbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0OwogICAgIFJlZlB0cjxTZWN1 cml0eU9yaWdpbj4gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW47CiAgICAgUmVmUHRyPFNlY3Vy aXR5T3JpZ2luPiBtX2RhdGFiYXNlVGhyZWFkU2VjdXJpdHlPcmlnaW47CiAgICAgU3RyaW5nIG1f bmFtZTsKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRhc2suaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUYXNrLmgJKHJldmlzaW9uIDUyOTk1KQorKysgV2Vi Q29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5oCSh3b3JraW5nIGNvcHkpCkBAIC01MCwxNiArNTAs MTUgQEAgY2xhc3MgVmVyc2lvbkNoYW5nZUNhbGxiYWNrOwogLy8gQ2FuIGJlIHVzZWQgdG8gd2Fp dCB1bnRpbCBEYXRhYmFzZVRhc2sgaXMgY29tcGxldGVkLgogLy8gSGFzIHRvIGJlIHBhc3NlZCBp bnRvIERhdGFiYXNlVGFzazo6Y3JlYXRlIHRvIGJlIGFzc29jaWF0ZWQgd2l0aCB0aGUgdGFzay4K IGNsYXNzIERhdGFiYXNlVGFza1N5bmNocm9uaXplciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7Ci0g ICAgZnJpZW5kIGNsYXNzIERhdGFiYXNlVGFzazsKIHB1YmxpYzoKICAgICBEYXRhYmFzZVRhc2tT eW5jaHJvbml6ZXIoKTsKIAogICAgIC8vIENhbGxlZCBmcm9tIG1haW4gdGhyZWFkIHRvIHdhaXQg dW50aWwgdGFzayBpcyBjb21wbGV0ZWQuCiAgICAgdm9pZCB3YWl0Rm9yVGFza0NvbXBsZXRpb24o KTsKIAotcHJpdmF0ZToKICAgICAvLyBDYWxsZWQgYnkgdGhlIHRhc2suCiAgICAgdm9pZCB0YXNr Q29tcGxldGVkKCk7Citwcml2YXRlOgogCiAgICAgYm9vbCBtX3Rhc2tDb21wbGV0ZWQ7CiAgICAg TXV0ZXggbV9zeW5jaHJvbm91c011dGV4OwpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNl VGhyZWFkLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQu Y3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDYgKzQ0LDcgQEAgRGF0YWJhc2VUaHJlYWQ6OkRhdGFi YXNlVGhyZWFkKCkKICAgICA6IG1fdGhyZWFkSUQoMCkKICAgICAsIG1fdHJhbnNhY3Rpb25DbGll bnQobmV3IFNRTFRyYW5zYWN0aW9uQ2xpZW50KCkpCiAgICAgLCBtX3RyYW5zYWN0aW9uQ29vcmRp bmF0b3IobmV3IFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSkKKyAgICAsIG1fY2xlYW51cFN5 bmMoMCkKIHsKICAgICBtX3NlbGZSZWYgPSB0aGlzOwogfQpAQCAtNTEsNiArNTIsNyBAQCBEYXRh YmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQogRGF0YWJhc2VUaHJlYWQ6On5EYXRhYmFzZVRo cmVhZCgpCiB7CiAgICAgLy8gRklYTUU6IEFueSBjbGVhbnVwIHJlcXVpcmVkIGhlcmU/ICBTaW5j ZSB0aGUgdGhyZWFkIGRlbGV0ZXMgaXRzZWxmIGFmdGVyIHJ1bm5pbmcgaXRzIGRldGFjaGVkIGNv dXJzZSwgSSBkb24ndCB0aGluayBzby4gIExldHMgYmUgc3VyZS4KKyAgICBBU1NFUlQodGVybWlu YXRpb25SZXF1ZXN0ZWQoKSk7CiB9CiAKIGJvb2wgRGF0YWJhc2VUaHJlYWQ6OnN0YXJ0KCkKQEAg LTY1LDggKzY3LDEwIEBAIGJvb2wgRGF0YWJhc2VUaHJlYWQ6OnN0YXJ0KCkKICAgICByZXR1cm4g bV90aHJlYWRJRDsKIH0KIAotdm9pZCBEYXRhYmFzZVRocmVhZDo6cmVxdWVzdFRlcm1pbmF0aW9u KCkKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbihEYXRhYmFzZVRhc2tT eW5jaHJvbml6ZXIgKmNsZWFudXBTeW5jKQogeworICAgIEFTU0VSVCghbV9jbGVhbnVwU3luYyk7 CisgICAgbV9jbGVhbnVwU3luYyA9IGNsZWFudXBTeW5jOwogICAgIExPRyhTdG9yYWdlQVBJLCAi RGF0YWJhc2VUaHJlYWQgJXAgd2FzIGFza2VkIHRvIHRlcm1pbmF0ZVxuIiwgdGhpcyk7CiAgICAg bV9xdWV1ZS5raWxsKCk7CiB9CkBAIC0xMTUsOSArMTE5LDE0IEBAIHZvaWQqIERhdGFiYXNlVGhy ZWFkOjpkYXRhYmFzZVRocmVhZCgpCiAgICAgLy8gRGV0YWNoIHRoZSB0aHJlYWQgc28gaXRzIHJl c291cmNlcyBhcmUgbm8gbG9uZ2VyIG9mIGFueSBjb25jZXJuIHRvIGFueW9uZSBlbHNlCiAgICAg ZGV0YWNoVGhyZWFkKG1fdGhyZWFkSUQpOwogCisgICAgRGF0YWJhc2VUYXNrU3luY2hyb25pemVy KiBjbGVhbnVwU3luYyA9IG1fY2xlYW51cFN5bmM7CisgICAgCiAgICAgLy8gQ2xlYXIgdGhlIHNl bGYgcmVmcHRyLCBwb3NzaWJseSByZXN1bHRpbmcgaW4gZGVsZXRpb24KICAgICBtX3NlbGZSZWYg PSAwOwogCisgICAgaWYgKGNsZWFudXBTeW5jKSAvLyBTb21lb25lIHdhbnRlZCB0byBrbm93IHdo ZW4gd2Ugd2VyZSBkb25lIGNsZWFuaW5nIHVwLgorICAgICAgICBjbGVhbnVwU3luYy0+dGFza0Nv bXBsZXRlZCgpOworCiAgICAgcmV0dXJuIDA7CiB9CiAKQEAgLTE2Miw2ICsxNzEsNSBAQCB2b2lk IERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUCiAgICAgU2FtZURhdGFiYXNlUHJl ZGljYXRlIHByZWRpY2F0ZShkYXRhYmFzZSk7CiAgICAgbV9xdWV1ZS5yZW1vdmVJZihwcmVkaWNh dGUpOwogfQotCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAjZW5kaWYKSW5kZXg6IFdlYkNvcmUv c3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9E YXRhYmFzZVRocmVhZC5oCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFnZS9EYXRh YmFzZVRocmVhZC5oCSh3b3JraW5nIGNvcHkpCkBAIC00Myw2ICs0Myw3IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAogY2xhc3MgRGF0YWJhc2U7CiBjbGFzcyBEYXRhYmFzZVRhc2s7CitjbGFzcyBE YXRhYmFzZVRhc2tTeW5jaHJvbml6ZXI7CiBjbGFzcyBEb2N1bWVudDsKIGNsYXNzIFNRTFRyYW5z YWN0aW9uQ2xpZW50OwogY2xhc3MgU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcjsKQEAgLTUzLDcg KzU0LDcgQEAgcHVibGljOgogICAgIH5EYXRhYmFzZVRocmVhZCgpOwogCiAgICAgYm9vbCBzdGFy dCgpOwotICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7CisgICAgdm9pZCByZXF1ZXN0VGVy bWluYXRpb24oRGF0YWJhc2VUYXNrU3luY2hyb25pemVyKiBjbGVhbnVwU3luYyk7CiAgICAgYm9v bCB0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0OwogCiAgICAgdm9pZCBzY2hlZHVsZVRhc2so UGFzc093blB0cjxEYXRhYmFzZVRhc2s+KTsKQEAgLTg1LDYgKzg2LDcgQEAgcHJpdmF0ZToKIAog ICAgIE93blB0cjxTUUxUcmFuc2FjdGlvbkNsaWVudD4gbV90cmFuc2FjdGlvbkNsaWVudDsKICAg ICBPd25QdHI8U1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcj4gbV90cmFuc2FjdGlvbkNvb3JkaW5h dG9yOworICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciogbV9jbGVhbnVwU3luYzsKIH07CiAK IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRy YWNrZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIu Y3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNiwxMCArMzYsMTAgQEAKICNpbmNsdWRlICJEYXRhYmFz ZS5oIgogI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VUcmFj a2VyQ2xpZW50LmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJMb2dnaW5nLmgi CiAjaW5jbHVkZSAiT3JpZ2luUXVvdGFNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgorI2lu Y2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKICNpbmNsdWRlICJTZWN1cml0eU9yaWdp bi5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luSGFzaC5oIgogI2luY2x1ZGUgIlNRTGl0ZUZp bGVTeXN0ZW0uaCIKQEAgLTEyMCw3ICsxMjAsNyBAQCB2b2lkIERhdGFiYXNlVHJhY2tlcjo6b3Bl blRyYWNrZXJEYXRhYmFzCiAgICAgfQogfQogCi1ib29sIERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0 YWJsaXNoRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNv bnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKK2Jv b2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25D b250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxh eU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKIHsKICAgICBBU1NFUlQoY3VycmVu dFRocmVhZCgpID09IG1fdGhyZWFkKTsKIApAQCAtMTI4LDkgKzEyOCw5IEBAIGJvb2wgRGF0YWJh c2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmEKICAgICAvLyBjYW4gcnVuIG9uIHRoZSBkYXRh YmFzZSB0aHJlYWQgbGF0ZXIuCiAgICAgcG9wdWxhdGVPcmlnaW5zKCk7CiAKLSAgICBTZWN1cml0 eU9yaWdpbiogb3JpZ2luID0gZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCk7CisgICAgU2VjdXJp dHlPcmlnaW4qIG9yaWdpbiA9IGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCk7CiAKLSAgICAvLyBT aW5jZSB3ZSdyZSBpbW1pbmVudGx5IG9wZW5pbmcgYSBkYXRhYmFzZSB3aXRoaW4gdGhpcyBEb2N1 bWVudCdzIG9yaWdpbiwgbWFrZSBzdXJlIHRoaXMgb3JpZ2luIGlzIGJlaW5nIHRyYWNrZWQgYnkg dGhlIFF1b3RhVHJhY2tlcgorICAgIC8vIFNpbmNlIHdlJ3JlIGltbWluZW50bHkgb3BlbmluZyBh IGRhdGFiYXNlIHdpdGhpbiB0aGlzIGNvbnRleHQncyBvcmlnaW4sIG1ha2Ugc3VyZSB0aGlzIG9y aWdpbiBpcyBiZWluZyB0cmFja2VkIGJ5IHRoZSBRdW90YVRyYWNrZXIKICAgICAvLyBieSBmZXRj aGluZyBpdCdzIGN1cnJlbnQgdXNhZ2Ugbm93CiAgICAgdW5zaWduZWQgbG9uZyBsb25nIHVzYWdl ID0gdXNhZ2VGb3JPcmlnaW4ob3JpZ2luKTsKIApAQCAtMTQ3LDEyICsxNDcsOSBAQCBib29sIERh dGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhCiAKICAgICAvLyBHaXZlIHRoZSBjaHJv bWUgY2xpZW50IGEgY2hhbmNlIHRvIGluY3JlYXNlIHRoZSBxdW90YS4KICAgICAvLyBUZW1wb3Jh cmlseSBtYWtlIHRoZSBkZXRhaWxzIG9mIHRoZSBwcm9wb3NlZCBkYXRhYmFzZSBhdmFpbGFibGUs IHNvIHRoZSBjbGllbnQgY2FuIGdldCBhdCB0aGVtLgotICAgIFBhZ2UqIHBhZ2UgPSBkb2N1bWVu dC0+cGFnZSgpOwotICAgIGlmICghcGFnZSkKLSAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIHBh aXI8U2VjdXJpdHlPcmlnaW4qLCBEYXRhYmFzZURldGFpbHM+IGRldGFpbHMob3JpZ2luLCBEYXRh YmFzZURldGFpbHMobmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUsIDApKTsKICAgICBt X3Byb3Bvc2VkRGF0YWJhc2UgPSAmZGV0YWlsczsKLSAgICBwYWdlLT5jaHJvbWUoKS0+Y2xpZW50 KCktPmV4Y2VlZGVkRGF0YWJhc2VRdW90YShkb2N1bWVudC0+ZnJhbWUoKSwgbmFtZSk7CisgICAg Y29udGV4dC0+ZGF0YWJhc2VFeGNlZWRlZFF1b3RhKG5hbWUpOwogICAgIG1fcHJvcG9zZWREYXRh YmFzZSA9IDA7CiAKICAgICAvLyBJZiB0aGUgZGF0YWJhc2Ugd2lsbCBmaXQgbm93LCBhbGxvdyBp dHMgY3JlYXRpb24uCkBAIC0xODYsNyArMTgzLDcgQEAgYm9vbCBEYXRhYmFzZVRyYWNrZXI6Omhh c0VudHJ5Rm9yRGF0YWJhcwogCiB1bnNpZ25lZCBsb25nIGxvbmcgRGF0YWJhc2VUcmFja2VyOjpn ZXRNYXhTaXplRm9yRGF0YWJhc2UoY29uc3QgRGF0YWJhc2UqIGRhdGFiYXNlKQogewotICAgIEFT U0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPmRvY3VtZW50KCktPmRhdGFiYXNlVGhy ZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0 YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhy ZWFkSUQoKSk7CiAgICAgLy8gVGhlIG1heGltdW0gc2l6ZSBmb3IgYSBkYXRhYmFzZSBpcyB0aGUg ZnVsbCBxdW90YSBmb3IgaXRzIG9yaWdpbiwgbWludXMgdGhlIGN1cnJlbnQgdXNhZ2Ugd2l0aGlu IHRoZSBvcmlnaW4sCiAgICAgLy8gcGx1cyB0aGUgY3VycmVudCB1c2FnZSBvZiB0aGUgZ2l2ZW4g ZGF0YWJhc2UKICAgICBMb2NrZXI8T3JpZ2luUXVvdGFNYW5hZ2VyPiBsb2NrZXIob3JpZ2luUXVv dGFNYW5hZ2VyKCkpOwpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuaAkocmV2aXNpb24g NTI5OTUpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUcmFja2VyLmgJKHdvcmtpbmcgY29w eSkKQEAgLTQ1LDcgKzQ1LDcgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0YWJh c2U7Ci1jbGFzcyBEb2N1bWVudDsKK2NsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiBjbGFz cyBTZWN1cml0eU9yaWdpbjsKIAogI2lmICFQTEFURk9STShDSFJPTUlVTSkKQEAgLTU5LDggKzU5 LDExIEBAIHN0cnVjdCBTZWN1cml0eU9yaWdpblRyYWl0czsKIGNsYXNzIERhdGFiYXNlVHJhY2tl ciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6CiAgICAgc3RhdGljIERhdGFiYXNlVHJh Y2tlciYgdHJhY2tlcigpOworICAgIC8vIEZJWE1FOiBEdWUgdG8gd29ya2VycyBoYXZpbmcgbXVs dGlwbGUgdGhyZWFkcyBpbiBhIHNpbmdsZSBwcm9jZXNzIHNoYXJpbmcKKyAgICAvLyBhIERhdGFi YXNlVHJhY2tlciwgdGhpcyBzaW5nbGV0b24gd2lsbCBoYXZlIHRvIGJlIHN5bmNocm9uaXplZCBv ciBtb3ZlZAorICAgIC8vIHRvIFRMUy4KIAotICAgIGJvb2wgY2FuRXN0YWJsaXNoRGF0YWJhc2Uo RG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUs IHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisgICAgYm9vbCBjYW5Fc3RhYmxpc2hEYXRh YmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogICAgIHZv aWQgc2V0RGF0YWJhc2VEZXRhaWxzKFNlY3VyaXR5T3JpZ2luKiwgY29uc3QgU3RyaW5nJiBuYW1l LCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUp OwogICAgIFN0cmluZyBmdWxsUGF0aEZvckRhdGFiYXNlKFNlY3VyaXR5T3JpZ2luKiwgY29uc3Qg U3RyaW5nJiBuYW1lLCBib29sIGNyZWF0ZUlmRG9lc05vdEV4aXN0ID0gdHJ1ZSk7CiAKSW5kZXg6 IFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9zdG9yYWdlL1NRTFRyYW5zYWN0aW9uLmNwcAkocmV2aXNpb24gNTI5OTUpCisrKyBXZWJDb3Jl L3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNSwxMSArMzUs MTEgQEAKICNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIkRhdGFiYXNlQXV0aG9yaXpl ci5oIgogI2luY2x1ZGUgIkRhdGFiYXNlRGV0YWlscy5oIgotI2luY2x1ZGUgIkRvY3VtZW50Lmgi CiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNs dWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJTY3Jp cHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJT UUxFcnJvci5oIgogI2luY2x1ZGUgIlNRTGl0ZVRyYW5zYWN0aW9uLmgiCkBAIC05NCw4ICs5NCw3 IEBAIHZvaWQgU1FMVHJhbnNhY3Rpb246OmV4ZWN1dGVTUUwoY29uc3QgU3QKIAogICAgIGJvb2wg cmVhZE9ubHlNb2RlID0gbV9yZWFkT25seTsKICAgICBpZiAoIXJlYWRPbmx5TW9kZSkgewotICAg ICAgICBQYWdlKiBwYWdlID0gbV9kYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cGFnZSgpOwotICAgICAg ICBpZiAoIXBhZ2UgfHwgcGFnZS0+c2V0dGluZ3MoKS0+cHJpdmF0ZUJyb3dzaW5nRW5hYmxlZCgp KQorICAgICAgICBpZiAobV9kYXRhYmFzZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0Rh dGFiYXNlUmVhZE9ubHkoKSkKICAgICAgICAgICAgIHJlYWRPbmx5TW9kZSA9IHRydWU7CiAgICAg fQogCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb25DbGllbnQuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlvbkNsaWVudC5jcHAJKHJldmlz aW9uIDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL1NRTFRyYW5zYWN0aW9uQ2xpZW50LmNwcAko d29ya2luZyBjb3B5KQpAQCAtNDcsNyArNDcsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIHZv aWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0aW9uKFNRTFRyYW5zYWN0 aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5z YWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJl YWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRh YmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRo cmVhZElEKCkpOwogICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9IHRyYW5zYWN0aW9uLT5kYXRhYmFz ZSgpOwogICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnNjaGVkdWxlTm90aWZ5RGF0YWJh c2VDaGFuZ2VkKAogICAgICAgICBkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4oKSwgZGF0YWJhc2Ut PnN0cmluZ0lkZW50aWZpZXIoKSk7CkBAIC01NSw3ICs1NSw3IEBAIHZvaWQgU1FMVHJhbnNhY3Rp b25DbGllbnQ6OmRpZENvbW1pdFRyYW4KIAogdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlk RXhlY3V0ZVN0YXRlbWVudChTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNT RVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQo KS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRU aHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4 dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKICAgICBPcmlnaW5RdW90YU1h bmFnZXImIG1hbmFnZXIoRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkub3JpZ2luUXVvdGFNYW5h Z2VyKCkpOwogICAgIExvY2tlcjxPcmlnaW5RdW90YU1hbmFnZXI+IGxvY2tlcihtYW5hZ2VyKTsK ICAgICBtYW5hZ2VyLm1hcmtEYXRhYmFzZSh0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKSk7CkBAIC02 MywxMyArNjMsMTEgQEAgdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkRXhlY3V0ZVN0YQog CiBib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YShTUUxUcmFuc2FjdGlv biogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NF UlQodHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXND b250ZXh0VGhyZWFkKCkpOwogICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9IHRyYW5zYWN0aW9uLT5k YXRhYmFzZSgpOwotICAgIFBhZ2UqIHBhZ2UgPSBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cGFnZSgp OwotICAgIEFTU0VSVChwYWdlKTsKIAogICAgIHVuc2lnbmVkIGxvbmcgbG9uZyBjdXJyZW50UXVv dGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFzZS0+ c2VjdXJpdHlPcmlnaW4oKSk7Ci0gICAgcGFnZS0+Y2hyb21lKCktPmNsaWVudCgpLT5leGNlZWRl ZERhdGFiYXNlUXVvdGEoZGF0YWJhc2UtPmRvY3VtZW50KCktPmZyYW1lKCksIGRhdGFiYXNlLT5z dHJpbmdJZGVudGlmaWVyKCkpOworICAgIGRhdGFiYXNlLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0 KCktPmRhdGFiYXNlRXhjZWVkZWRRdW90YShkYXRhYmFzZS0+c3RyaW5nSWRlbnRpZmllcigpKTsK ICAgICB1bnNpZ25lZCBsb25nIGxvbmcgbmV3UXVvdGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNr ZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4oKSk7CiAgICAgcmV0 dXJuIChuZXdRdW90YSA+IGN1cnJlbnRRdW90YSk7CiB9CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2Uv Y2hyb21pdW0vRGF0YWJhc2VUcmFja2VyQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUvc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFzZVRyYWNrZXJDaHJvbWl1bS5jcHAJKHJldmlzaW9u IDUyOTk1KQorKysgV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL0RhdGFiYXNlVHJhY2tlckNocm9t aXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzUsOCArMzUsOCBAQAogI2luY2x1ZGUgIkRhdGFi YXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VPYnNlcnZlci5oIgogI2luY2x1ZGUgIkRhdGFiYXNl VGhyZWFkLmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJRdW90YVRyYWNrZXIu aCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU2VjdXJp dHlPcmlnaW4uaCIKICNpbmNsdWRlICJTUUxpdGVGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSA8d3Rm L0hhc2hTZXQuaD4KQEAgLTU2LDcgKzU2LDcgQEAgRGF0YWJhc2VUcmFja2VyOjpEYXRhYmFzZVRy YWNrZXIoKQogICAgIFNRTGl0ZUZpbGVTeXN0ZW06OnJlZ2lzdGVyU1FMaXRlVkZTKCk7CiB9CiAK LWJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFzZShEb2N1bWVudCosIGNv bnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYsIHVuc2lnbmVkIGxvbmcpCitib29sIERhdGFiYXNl VHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNv bnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYsIHVuc2lnbmVkIGxvbmcpCiB7CiAgICAgLy8gSW4g Q2hyb21pdW0sIGEgZGF0YWJhc2UgY2FuIGFsd2F5cyBiZSBlc3RhYmxpc2hlZCAoZXZlbiB0aG91 Z2ggd2UgbWlnaHQgbm90CiAgICAgLy8gYmUgYWJsZSB0byB3cml0ZSBhbnl0aGluZyB0byBpdCBp ZiB0aGUgcXVvdGEgZm9yIHRoaXMgb3JpZ2luIHdhcyBleGNlZWRlZCkKQEAgLTc1LDIxICs3NSwz NSBAQCBTdHJpbmcgRGF0YWJhc2VUcmFja2VyOjpmdWxsUGF0aEZvckRhdGFiCiAKIHZvaWQgRGF0 YWJhc2VUcmFja2VyOjphZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRhdGFiYXNlKQogewotICAg IEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGRhdGFiYXNlLT5zY3JpcHRFeGVj dXRpb25Db250ZXh0KCktPmlzQ29udGV4dFRocmVhZCgpKTsKICAgICBEYXRhYmFzZU9ic2VydmVy OjpkYXRhYmFzZU9wZW5lZChkYXRhYmFzZSk7CiB9Ci1zdGF0aWMgdm9pZCByZW1vdmVPcGVuRGF0 YWJhc2VPbk1haW5UaHJlYWQodm9pZCogY29udGV4dCkKLXsKLSAgICBEYXRhYmFzZSogZGF0YWJh c2UgPSBzdGF0aWNfY2FzdDxEYXRhYmFzZSo+KGNvbnRleHQpOwotICAgIERhdGFiYXNlVHJhY2tl cjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZSk7Ci0gICAgZGF0YWJhc2Ut PmRlcmVmKCk7Ci19CisKK2NsYXNzIFRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrIDogcHVi bGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQ YXNzT3duUHRyPFRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrPiBjcmVhdGUoUGFzc1JlZlB0 cjxEYXRhYmFzZT4gZGF0YWJhc2UpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IFRyYWNrZXJS ZW1vdmVPcGVuRGF0YWJhc2VUYXNrKGRhdGFiYXNlKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZv aWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCkKKyAgICB7Cisg ICAgICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShtX2Rh dGFiYXNlLmdldCgpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgVHJhY2tlclJlbW92ZU9wZW5E YXRhYmFzZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2UpCisgICAgICAgIDogbV9k YXRhYmFzZShkYXRhYmFzZSkKKyAgICB7CisgICAgfQorCisgICAgUmVmUHRyPERhdGFiYXNlPiBt X2RhdGFiYXNlOworfTsKIAogdm9pZCBEYXRhYmFzZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRhYmFz ZShEYXRhYmFzZSogZGF0YWJhc2UpCiB7Ci0gICAgaWYgKCFpc01haW5UaHJlYWQoKSkgewotICAg ICAgICBkYXRhYmFzZS0+cmVmKCk7Ci0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQocmVtb3ZlT3Bl bkRhdGFiYXNlT25NYWluVGhyZWFkLCBkYXRhYmFzZSk7CisgICAgaWYgKCFkYXRhYmFzZS0+c2Ny aXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRUaHJlYWQoKSkgeworICAgICAgICBkYXRh YmFzZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5wb3N0VGFzayhUcmFja2VyUmVtb3ZlT3Bl bkRhdGFiYXNlVGFzazo6Y3JlYXRlKGRhdGFiYXNlKSk7CiAgICAgICAgIHJldHVybjsKICAgICB9 CiAKQEAgLTk4LDcgKzExMiw3IEBAIHZvaWQgRGF0YWJhc2VUcmFja2VyOjpyZW1vdmVPcGVuRGF0 YWJhc2UKIAogdW5zaWduZWQgbG9uZyBsb25nIERhdGFiYXNlVHJhY2tlcjo6Z2V0TWF4U2l6ZUZv ckRhdGFiYXNlKGNvbnN0IERhdGFiYXNlKiBkYXRhYmFzZSkKIHsKLSAgICBBU1NFUlQoY3VycmVu dFRocmVhZCgpID09IGRhdGFiYXNlLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRU aHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IGRhdGFiYXNlLT5zY3Jp cHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOwog ICAgIHVuc2lnbmVkIGxvbmcgbG9uZyBzcGFjZUF2YWlsYWJsZSA9IDA7CiAgICAgdW5zaWduZWQg bG9uZyBsb25nIGRhdGFiYXNlU2l6ZSA9IDA7CiAgICAgUXVvdGFUcmFja2VyOjppbnN0YW5jZSgp LmdldERhdGFiYXNlU2l6ZUFuZFNwYWNlQXZhaWxhYmxlVG9PcmlnaW4oCkluZGV4OiBXZWJDb3Jl L3N0b3JhZ2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRDaHJvbWl1bS5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0aW9uQ2xpZW50Q2hy b21pdW0uY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9T UUxUcmFuc2FjdGlvbkNsaWVudENocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzgsMjAg KzM4LDM0IEBACiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb24uaCIKICNpbmNsdWRlIDx3dGYvTWFp blRocmVhZC5oPgogCi1zdGF0aWMgdm9pZCBub3RpZnlEYXRhYmFzZUNoYW5nZWQodm9pZCogY29u dGV4dCkgewotICAgIFdlYkNvcmU6OkRhdGFiYXNlKiBkYXRhYmFzZSA9IHN0YXRpY19jYXN0PFdl YkNvcmU6OkRhdGFiYXNlKj4oY29udGV4dCk7Ci0gICAgV2ViQ29yZTo6RGF0YWJhc2VPYnNlcnZl cjo6ZGF0YWJhc2VNb2RpZmllZChkYXRhYmFzZSk7Ci0gICAgZGF0YWJhc2UtPmRlcmVmKCk7ICAv LyByZWYoKSdkIGluIGRpZENvbW1pdFRyYW5zYWN0aW9uKCkKLX0KLQogbmFtZXNwYWNlIFdlYkNv cmUgewogCitjbGFzcyBOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrIDogcHVibGljIFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPE5v dGlmeURhdGFiYXNlQ2hhbmdlZFRhc2s+IGNyZWF0ZShEYXRhYmFzZSAqZGF0YWJhc2UpCisgICAg eworICAgICAgICByZXR1cm4gbmV3IE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2soZGF0YWJhc2Up OworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25D b250ZXh0KikKKyAgICB7CisgICAgICAgIFdlYkNvcmU6OkRhdGFiYXNlT2JzZXJ2ZXI6OmRhdGFi YXNlTW9kaWZpZWQobV9kYXRhYmFzZS5nZXQoKSk7CisgICAgfQorCitwcml2YXRlOgorICAgIE5v dGlmeURhdGFiYXNlQ2hhbmdlZFRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2UpCisg ICAgICAgIDogbV9kYXRhYmFzZShkYXRhYmFzZSkKKyAgICB7CisgICAgfQorCisgICAgUmVmUHRy PERhdGFiYXNlPiBtX2RhdGFiYXNlOworfTsKKwogdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6 ZGlkQ29tbWl0VHJhbnNhY3Rpb24oU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewotICAg IEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPmRvY3Vt ZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChjdXJy ZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnNjcmlwdEV4ZWN1dGlvbkNv bnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgaWYgKCF0cmFu c2FjdGlvbi0+aXNSZWFkT25seSgpKSB7Ci0gICAgICAgIHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgp LT5yZWYoKTsgIC8vIGRlcmVmKCknZCBpbiBub3RpZnlEYXRhYmFzZUNoYW5nZWQoKQotICAgICAg ICBjYWxsT25NYWluVGhyZWFkKG5vdGlmeURhdGFiYXNlQ2hhbmdlZCwgdHJhbnNhY3Rpb24tPmRh dGFiYXNlKCkpOworICAgICAgICB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhlY3V0 aW9uQ29udGV4dCgpLT5wb3N0VGFzayhOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrOjpjcmVhdGUo dHJhbnNhY3Rpb24tPmRhdGFiYXNlKCkpKTsKICAgICB9CiB9CiAKQEAgLTU5LDE0ICs3MywxNCBA QCB2b2lkIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhCiB7CiAgICAgLy8gVGhp cyBtZXRob2QgaXMgY2FsbGVkIGFmdGVyIGV4ZWN1dGluZyBldmVyeSBzdGF0ZW1lbnQgdGhhdCBj aGFuZ2VzIHRoZSBEQi4KICAgICAvLyBDaHJvbWl1bSBkb2Vzbid0IG5lZWQgdG8gZG8gYW55dGhp bmcgYXQgdGhhdCBwb2ludC4KLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0 aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJ RCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRhYmFz ZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVh ZElEKCkpOwogfQogCi1ib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YShT UUxUcmFuc2FjdGlvbiopCitib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90 YShTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7CiAgICAgLy8gQ2hyb21pdW0gZG9lcyBu b3QgYWxsb3cgdXNlcnMgdG8gbWFudWFsbHkgY2hhbmdlIHRoZSBxdW90YSBmb3IgYW4gb3JpZ2lu IChmb3Igbm93LCBhdCBsZWFzdCkuCiAgICAgLy8gRG9uJ3QgZG8gYW55dGhpbmcuCi0gICAgQVNT RVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQodHJhbnNhY3Rpb24tPmRhdGFiYXNlKCkt PnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNDb250ZXh0VGhyZWFkKCkpOwogICAgIHJldHVy biBmYWxzZTsKIH0KIApJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAkocmV2aXNpb24g NTI5OTUpCisrKyBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCiAKICNpbmNs dWRlICJBY3RpdmVET01PYmplY3QuaCIKKyNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUg IkRPTVRpbWVyLmgiCiAjaW5jbHVkZSAiRE9NV2luZG93LmgiCiAjaW5jbHVkZSAiRXZlbnQuaCIK QEAgLTI1NCw2ICsyNTUsMjcgQEAgTm90aWZpY2F0aW9uQ2VudGVyKiBXb3JrZXJDb250ZXh0Ojp3 ZWJraQogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCitQYXNzUmVmUHRyPERhdGFi YXNlPiBXb3JrZXJDb250ZXh0OjpvcGVuRGF0YWJhc2UoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIHZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxv bmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgaWYgKCFzZWN1cml0 eU9yaWdpbigpLT5jYW5BY2Nlc3NEYXRhYmFzZSgpKSB7CisgICAgICAgIGVjID0gU0VDVVJJVFlf RVJSOworICAgICAgICByZXR1cm4gMDsKKyAgICB9CisKKyAgICBBU1NFUlQoRGF0YWJhc2U6Omlz QXZhaWxhYmxlKCkpOworICAgIGlmICghRGF0YWJhc2U6OmlzQXZhaWxhYmxlKCkpCisgICAgICAg IHJldHVybiAwOworCisgICAgcmV0dXJuIERhdGFiYXNlOjpvcGVuRGF0YWJhc2UodGhpcywgbmFt ZSwgdmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUsIGVjKTsKK30KKyNlbmRpZgor Citib29sIFdvcmtlckNvbnRleHQ6OmlzQ29udGV4dFRocmVhZCgpIGNvbnN0Cit7CisgICAgcmV0 dXJuIGN1cnJlbnRUaHJlYWQoKSA9PSB0aHJlYWQoKS0+dGhyZWFkSUQoKTsKK30KKwogRXZlbnRU YXJnZXREYXRhKiBXb3JrZXJDb250ZXh0OjpldmVudFRhcmdldERhdGEoKQogewogICAgIHJldHVy biAmbV9ldmVudFRhcmdldERhdGE7CkluZGV4OiBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4 dC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgJKHJldmlz aW9uIDUyOTk1KQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAkod29ya2luZyBj b3B5KQpAQCAtMzAsMTEgKzMwLDEzIEBACiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKICNpbmNsdWRl ICJBdG9taWNTdHJpbmdIYXNoLmgiCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKICNpbmNsdWRlICJF dmVudExpc3RlbmVyLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkV2ZW50 VGFyZ2V0LmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgogI2luY2x1ZGUg IldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKKyNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgog I2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2lu Y2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CkBAIC00Miw2ICs0NCw3IEBACiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAorICAgIGNsYXNzIERhdGFiYXNlOwogICAgIGNsYXNzIE5vdGlmaWNhdGlvbkNl bnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rpb247CiAgICAgY2xhc3MgV29ya2VyTG9jYXRp b247CkBAIC02NSw5ICs2OCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVh bCBTdHJpbmcgdXNlckFnZW50KGNvbnN0IEtVUkwmKSBjb25zdDsKIAogICAgICAgICBXb3JrZXJT Y3JpcHRDb250cm9sbGVyKiBzY3JpcHQoKSB7IHJldHVybiBtX3NjcmlwdC5nZXQoKTsgfQotICAg ICAgICB2b2lkIGNsZWFyU2NyaXB0KCkgeyByZXR1cm4gbV9zY3JpcHQuY2xlYXIoKTsgfQorICAg ICAgICB2b2lkIGNsZWFyU2NyaXB0KCkgeyBtX3NjcmlwdC5jbGVhcigpOyB9CiAKLSAgICAgICAg V29ya2VyVGhyZWFkKiB0aHJlYWQoKSB7IHJldHVybiBtX3RocmVhZDsgfQorICAgICAgICBXb3Jr ZXJUaHJlYWQqIHRocmVhZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGhyZWFkOyB9CiAKICAgICAgICAg Ym9vbCBoYXNQZW5kaW5nQWN0aXZpdHkoKSBjb25zdDsKIApAQCAtMTAxLDYgKzEwNCwxNyBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIE5vdGlmaWNhdGlvbkNlbnRlciogd2Via2l0Tm90 aWZpY2F0aW9ucygpIGNvbnN0OwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisgICAg ICAgIC8vIEhUTUwgNSBjbGllbnQtc2lkZSBkYXRhYmFzZQorICAgICAgICBQYXNzUmVmUHRyPERh dGFiYXNlPiBvcGVuRGF0YWJhc2UoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZl cnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVk U2l6ZSwgRXhjZXB0aW9uQ29kZSYpOworICAgICAgICAvLyBOb3QgaW1wbGVtZW50ZWQgeWV0Lgor ICAgICAgICB2aXJ0dWFsIGJvb2wgaXNEYXRhYmFzZVJlYWRPbmx5KCkgY29uc3QgeyByZXR1cm4g ZmFsc2U7IH0KKyAgICAgICAgLy8gTm90IGltcGxlbWVudGVkIHlldC4KKyAgICAgICAgdmlydHVh bCB2b2lkIGRhdGFiYXNlRXhjZWVkZWRRdW90YShjb25zdCBTdHJpbmcmKSB7IH0KKyNlbmRpZgor ICAgICAgICB2aXJ0dWFsIGJvb2wgaXNDb250ZXh0VGhyZWFkKCkgY29uc3Q7CisKKwogICAgICAg ICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNXb3JrZXJD b250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNXb3JrZXJD b250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25hbE5hdmln YXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdldCgpOyB9CkluZGV4OiBXZWJDb3Jl L3dvcmtlcnMvV29ya2VyUnVuTG9vcC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93b3JrZXJz L1dvcmtlclJ1bkxvb3AuY3BwCShyZXZpc2lvbiA1Mjk5NSkKKysrIFdlYkNvcmUvd29ya2Vycy9X b3JrZXJSdW5Mb29wLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTUyLDkgKzE1Miw3IEBAIE1lc3Nh Z2VRdWV1ZVdhaXRSZXN1bHQgV29ya2VyUnVuTG9vcDo6cnUKICAgICBNZXNzYWdlUXVldWVXYWl0 UmVzdWx0IHJlc3VsdDsKICAgICBPd25QdHI8V29ya2VyUnVuTG9vcDo6VGFzaz4gdGFzayA9IG1f bWVzc2FnZVF1ZXVlLndhaXRGb3JNZXNzYWdlRmlsdGVyZWRXaXRoVGltZW91dChyZXN1bHQsIHBy ZWRpY2F0ZSwgYWJzb2x1dGVUaW1lKTsKIAotICAgIC8vIElmIHRoZSBjb250ZXh0IGlzIGNsb3Np bmcsIGRvbid0IGRpc3BhdGNoIGFueSBmdXJ0aGVyIHRhc2tzIChwZXIgc2VjdGlvbiA0LjEuMSBv ZiB0aGUgV2ViIFdvcmtlcnMgc3BlYykuCi0gICAgaWYgKGNvbnRleHQtPmlzQ2xvc2luZygpKQot ICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIC8vIElmIHRoZSBjb250ZXh0IGlzIGNsb3Npbmcs IGRvbid0IGV4ZWN1dGUgYW55IGZ1cnRoZXIgSmF2YVNjcmlwdCB0YXNrcyAocGVyIHNlY3Rpb24g NC4xLjEgb2YgdGhlIFdlYiBXb3JrZXJzIHNwZWMpLiAgSG93ZXZlciwgdGhlcmUgbWF5IGJlIGlt cGxlbWVudGF0aW9uIGNsZWFudXAgdGFza3MgaW4gdGhlIHF1ZXVlLCBzbyBrZWVwIHJ1bm5pbmcg dGhyb3VnaCBpdC4KIAogICAgIHN3aXRjaCAocmVzdWx0KSB7CiAgICAgY2FzZSBNZXNzYWdlUXVl dWVUZXJtaW5hdGVkOgpAQCAtMTY1LDcgKzE2Myw4IEBAIE1lc3NhZ2VRdWV1ZVdhaXRSZXN1bHQg V29ya2VyUnVuTG9vcDo6cnUKICAgICAgICAgYnJlYWs7CiAKICAgICBjYXNlIE1lc3NhZ2VRdWV1 ZVRpbWVvdXQ6Ci0gICAgICAgIG1fc2hhcmVkVGltZXItPmZpcmUoKTsKKyAgICAgICAgaWYgKCFj b250ZXh0LT5pc0Nsb3NpbmcoKSkKKyAgICAgICAgICAgIG1fc2hhcmVkVGltZXItPmZpcmUoKTsK ICAgICAgICAgYnJlYWs7CiAgICAgfQogCkBAIC0xOTQsNyArMTkzLDkgQEAgUGFzc093blB0cjxX b3JrZXJSdW5Mb29wOjpUYXNrPiBXb3JrZXJSdQogCiB2b2lkIFdvcmtlclJ1bkxvb3A6OlRhc2s6 OnBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCiB7Ci0gICAgbV90 YXNrLT5wZXJmb3JtVGFzayhjb250ZXh0KTsKKyAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250 ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCAqPihjb250ZXh0KTsKKyAgICBpZiAoIXdv cmtlckNvbnRleHQtPmlzQ2xvc2luZygpIHx8IG1fdGFzay0+aXNDbGVhbnVwVGFzaygpKQorICAg ICAgICBtX3Rhc2stPnBlcmZvcm1UYXNrKGNvbnRleHQpOwogfQogCiBXb3JrZXJSdW5Mb29wOjpU YXNrOjpUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywg Y29uc3QgU3RyaW5nJiBtb2RlKQpJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAJKHJldmlz aW9uIDUyOTk1KQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogCisj aW5jbHVkZSAiRGF0YWJhc2VUYXNrLmgiCiAjaW5jbHVkZSAiRGVkaWNhdGVkV29ya2VyQ29udGV4 dC5oIgogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgpAQCAt MTM1LDkgKzEzNiw4IEBAIHZvaWQqIFdvcmtlclRocmVhZDo6d29ya2VyVGhyZWFkKCkKIAogICAg IFRocmVhZElkZW50aWZpZXIgdGhyZWFkSUQgPSBtX3RocmVhZElEOwogCi0gICAgbV93b3JrZXJD b250ZXh0LT5zdG9wQWN0aXZlRE9NT2JqZWN0cygpOwotICAgIG1fd29ya2VyQ29udGV4dC0+Y2xl YXJTY3JpcHQoKTsKICAgICBBU1NFUlQobV93b3JrZXJDb250ZXh0LT5oYXNPbmVSZWYoKSk7CisK ICAgICAvLyBUaGUgYmVsb3cgYXNzaWdubWVudCB3aWxsIGRlc3Ryb3kgdGhlIGNvbnRleHQsIHdo aWNoIHdpbGwgaW4gdHVybiBub3RpZnkgbWVzc2FnaW5nIHByb3h5LgogICAgIC8vIFdlIGNhbm5v dCBsZXQgYW55IG9iamVjdHMgc3Vydml2ZSBwYXN0IHRocmVhZCBleGl0LCBiZWNhdXNlIG5vIG90 aGVyIHRocmVhZCB3aWxsIHJ1biBHQyBvciBvdGhlcndpc2UgZGVzdHJveSB0aGVtLgogICAgIG1f d29ya2VyQ29udGV4dCA9IDA7CkBAIC0xNTQsMTcgKzE1NCw3MCBAQCB2b2lkIFdvcmtlclRocmVh ZDo6cnVuRXZlbnRMb29wKCkKICAgICBtX3J1bkxvb3AucnVuKG1fd29ya2VyQ29udGV4dC5nZXQo KSk7CiB9CiAKK2NsYXNzIFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzayA6IHB1YmxpYyBT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093 blB0cjxXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2s+IGNyZWF0ZSgpCisgICAgeworICAg ICAgICByZXR1cm4gbmV3IFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzaygpOworICAgIH0K KworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpj b250ZXh0KQorICAgIHsKKyAgICAgICAgQVNTRVJUKGNvbnRleHQtPmlzV29ya2VyQ29udGV4dCgp KTsKKyAgICAgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IHN0YXRpY19jYXN0PFdv cmtlckNvbnRleHQqPihjb250ZXh0KTsKKyAgICAgICAgd29ya2VyQ29udGV4dC0+dGhyZWFkKCkt PnJ1bkxvb3AoKS50ZXJtaW5hdGUoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGVh bnVwVGFzaygpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KK307CisKK2NsYXNzIFdvcmtlclRocmVh ZFNodXRkb3duU3RhcnRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sg eworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPFdvcmtlclRocmVhZFNodXRkb3duU3Rh cnRUYXNrPiBjcmVhdGUoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBXb3JrZXJUaHJlYWRT aHV0ZG93blN0YXJ0VGFzaygpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFz ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAgQVNTRVJU KGNvbnRleHQtPmlzV29ya2VyQ29udGV4dCgpKTsKKyAgICAgICAgV29ya2VyQ29udGV4dCogd29y a2VyQ29udGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQqPihjb250ZXh0KTsKKworICAg ICAgICAvLyBXZSBjdXJyZW50bHkgaWdub3JlIGFueSBEYXRhYmFzZVBvbGljeSB1c2VkIGZvciB0 aGUgZG9jdW1lbnQncworICAgICAgICAvLyBkYXRhYmFzZXM7IGlmIGl0J3MgYWN0dWFsbHkgdXNl ZCBhbnl3aGVyZSwgdGhpcyBzaG91bGQgYmUgcmV2aXNpdGVkLgorICAgICAgICBEYXRhYmFzZVRh c2tTeW5jaHJvbml6ZXIgY2xlYW51cFN5bmM7CisgICAgICAgIHdvcmtlckNvbnRleHQtPnN0b3BE YXRhYmFzZXMoJmNsZWFudXBTeW5jKTsKKworICAgICAgICB3b3JrZXJDb250ZXh0LT5zdG9wQWN0 aXZlRE9NT2JqZWN0cygpOworICAgICAgICB3b3JrZXJDb250ZXh0LT5jbGVhclNjcmlwdCgpOwor CisgICAgICAgIC8vIFdlIHdhaXQgZm9yIHRoZSBkYXRhYmFzZSB0aHJlYWQgdG8gY2xlYW4gdXAg YWxsIGl0cyBzdHVmZiBzbyB0aGF0IHdlCisgICAgICAgIC8vIGNhbiBkbyBtb3JlIHN0cmluZ2Vu dCBsZWFrIGNoZWNrcyBhcyB3ZSBleGl0LgorICAgICAgICBjbGVhbnVwU3luYy53YWl0Rm9yVGFz a0NvbXBsZXRpb24oKTsKKworICAgICAgICAvLyBTdGljayBhIHNodXRkb3duIGNvbW1hbmQgYXQg dGhlIGVuZCBvZiB0aGUgcXVldWUsIHNvIHRoYXQgd2UgZGVhbAorICAgICAgICAvLyB3aXRoIGFs bCB0aGUgY2xlYW51cCB0YXNrcyB0aGUgZGF0YWJhc2VzIHBvc3QgZmlyc3QuCisgICAgICAgIHdv cmtlckNvbnRleHQtPnBvc3RUYXNrKFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzazo6Y3Jl YXRlKCkpOworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3Qg eyByZXR1cm4gdHJ1ZTsgfQorfTsKKwogdm9pZCBXb3JrZXJUaHJlYWQ6OnN0b3AoKQogewogICAg IC8vIE11dGV4IHByb3RlY3Rpb24gaXMgbmVjZXNzYXJ5IGJlY2F1c2Ugc3RvcCgpIGNhbiBiZSBj YWxsZWQgYmVmb3JlIHRoZSBjb250ZXh0IGlzIGZ1bGx5IGNyZWF0ZWQuCiAgICAgTXV0ZXhMb2Nr ZXIgbG9jayhtX3RocmVhZENyZWF0aW9uTXV0ZXgpOwogCiAgICAgLy8gRW5zdXJlIHRoYXQgdGFz a3MgYXJlIGJlaW5nIGhhbmRsZWQgYnkgdGhyZWFkIGV2ZW50IGxvb3AuIElmIHNjcmlwdCBleGVj dXRpb24gd2VyZW4ndCBmb3JiaWRkZW4sIGEgd2hpbGUoMSkgbG9vcCBpbiBKUyBjb3VsZCBrZWVw IHRoZSB0aHJlYWQgYWxpdmUgZm9yZXZlci4KLSAgICBpZiAobV93b3JrZXJDb250ZXh0KQorICAg IGlmIChtX3dvcmtlckNvbnRleHQpIHsKICAgICAgICAgbV93b3JrZXJDb250ZXh0LT5zY3JpcHQo KS0+Zm9yYmlkRXhlY3V0aW9uKCk7CiAKICAgICAvLyBGSVhNRTogUnVkZWx5IGtpbGxpbmcgdGhl IHRocmVhZCB3b24ndCB3b3JrIHdoZW4gd2UgYWxsb3cgbmVzdGVkIHdvcmtlcnMsIGJlY2F1c2Ug dGhleSB3aWxsIHRyeSB0byBwb3N0IG5vdGlmaWNhdGlvbnMgb2YgdGhlaXIgZGVzdHJ1Y3Rpb24u Ci0gICAgbV9ydW5Mb29wLnRlcm1pbmF0ZSgpOworICAgIC8vIFRoaXMgY2FuIGxpa2VseSB1c2Ug dGhlIHNhbWUgbWVjaGFuaXNtIGFzIHVzZWQgZm9yIGRhdGFiYXNlcyBhYm92ZS4KKworICAgICAg ICBtX3J1bkxvb3AucG9zdFRhc2soV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6OmNyZWF0 ZSgpKTsKKyAgICB9IGVsc2UKKyAgICAgICAgbV9ydW5Mb29wLnRlcm1pbmF0ZSgpOwogfQogCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1MzUwNikKKysrIExheW91 dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDEwLTAx LTE5ICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gYnVnLiAgVGhpcyBpcyBwYXJ0IG9m IHRoZSBjaGVja2luIGZvcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjI3MjUKKworICAgICAgICBQcmV2aW91c2x5IG9wZW5EYXRhYmFzZSB3b3VsZCBq dXN0IHJldHVybiBudWxsIGlmIHRoZSBvcGVuZXIgZGlkbid0CisgICAgICAgIGhhdmUgcGVybWlz c2lvbiB0byBhY2Nlc3MgdGhlIGRhdGFiYXNlLiAgSSd2ZSBjaGFuZ2VkIGl0IHRvIHRocm93IGFu CisgICAgICAgIGV4Y2VwdGlvbiwgYXMgSSBiZWxpdmUgdGhhdCdzIHdoYXQgdGhlIHNwZWMgcmVx dWlyZXMuCisKKyAgICAgICAgKiBmYXN0L2ZyYW1lcy9yZXNvdXJjZXMvc2FuZGJveGVkLWlmcmFt ZS1zdG9yYWdlLWRpc2FsbG93ZWQuaHRtbDoKKyAgICAgICAgKiBmYXN0L2ZyYW1lcy9zYW5kYm94 ZWQtaWZyYW1lLXN0b3JhZ2UtZXhwZWN0ZWQudHh0OgorCiAyMDEwLTAxLTE5ICBDYXJvbCBTemFi byAgPGNhcm9sLnN6YWJvQG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBB ZGxlci4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZnJhbWVzL3NhbmRib3hlZC1pZnJhbWUtc3Rv cmFnZS1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9mcmFtZXMv c2FuZGJveGVkLWlmcmFtZS1zdG9yYWdlLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gNTI5OTUpCisr KyBMYXlvdXRUZXN0cy9mYXN0L2ZyYW1lcy9zYW5kYm94ZWQtaWZyYW1lLXN0b3JhZ2UtZXhwZWN0 ZWQudHh0CSh3b3JraW5nIGNvcHkpCkBAIC0xNCw3ICsxNCw3IEBAIFRFU1QgQ09NUExFVEUKIC0t LS0tLS0tCiBGcmFtZTogJzwhLS1mcmFtZVBhdGggLy88IS0tZnJhbWUwLS0+LS0+JwogLS0tLS0t LS0KLVBBU1Mgd2luZG93Lm9wZW5EYXRhYmFzZSgpID09IG51bGwgaXMgdHJ1ZQorUEFTUyB3aW5k b3cub3BlbkRhdGFiYXNlKCkgdGhyZXcgZXhjZXB0aW9uIEVycm9yOiBTRUNVUklUWV9FUlI6IERP TSBFeGNlcHRpb24gMTguCiBQQVNTIHdpbmRvdy5sb2NhbFN0b3JhZ2UgPT0gbnVsbCBpcyB0cnVl CiBQQVNTIHdpbmRvdy5zZXNzaW9uU3RvcmFnZSA9PSBudWxsIGlzIHRydWUKIApJbmRleDogTGF5 b3V0VGVzdHMvZmFzdC9mcmFtZXMvcmVzb3VyY2VzL3NhbmRib3hlZC1pZnJhbWUtc3RvcmFnZS1k aXNhbGxvd2VkLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9mcmFtZXMvcmVz b3VyY2VzL3NhbmRib3hlZC1pZnJhbWUtc3RvcmFnZS1kaXNhbGxvd2VkLmh0bWwJKHJldmlzaW9u IDUyOTk1KQorKysgTGF5b3V0VGVzdHMvZmFzdC9mcmFtZXMvcmVzb3VyY2VzL3NhbmRib3hlZC1p ZnJhbWUtc3RvcmFnZS1kaXNhbGxvd2VkLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTYsNyArNiw3 IEBACiA8c2NyaXB0PgogCiB3aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7Ci0gICAgc2hvdWxk QmVUcnVlKCJ3aW5kb3cub3BlbkRhdGFiYXNlKCkgPT0gbnVsbCIpOworICAgIHNob3VsZFRocm93 KCJ3aW5kb3cub3BlbkRhdGFiYXNlKCkiLCAiJ0Vycm9yOiBTRUNVUklUWV9FUlI6IERPTSBFeGNl cHRpb24gMTgnIik7CiAgICAgc2hvdWxkQmVUcnVlKCJ3aW5kb3cubG9jYWxTdG9yYWdlID09IG51 bGwiKTsKICAgICBzaG91bGRCZVRydWUoIndpbmRvdy5zZXNzaW9uU3RvcmFnZSA9PSBudWxsIik7 CiB9Cg== 46968 2010-01-19 19:39:20 -0800 2010-01-20 13:33:10 -0800 Updated to latest webkit code; resolved merge conflicts. upload.3.1.patch text/plain 64576 ericu SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUxIEBACisyMDEwLTAxLTE5ICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVmYWN0b3JpbmcgYW5kIHBsdW1iaW5nIHRvIGdldCB0aGUgSFRNTDUgU1FMIERhdGFiYXNlIEFQ SSBhY2Nlc3NpYmxlIHRvCisgICAgICAgIHdlYiB3b3JrZXJzLiAgTm8gbmV3IGZ1bmN0aW9uYWxp dHkgaXMgZXhwb3NlZCB5ZXQ7IHRoaXMganVzdCBnZXRzIHRoZQorICAgICAgICBpbmZyYXN0cnVj dHVyZSBpbiBwbGFjZS4gIEl0IHRvdWNoZXMgYSBsb3Qgb2YgZmlsZXMgaW4gc21hbGwgd2F5czsg aGVyZQorICAgICAgICBhcmUgdGhlIG1haW4gY2hhbmdlczoKKworICAgICAgICAxKSBEYXRhYmFz ZSBtZW1iZXJzIGFuZCBtZXRob2RzIG1vdmUgZnJvbSBEb2N1bWVudCB1cCB0bworICAgICAgICBT Y3JpcHRFeGVjdXRpb25Db250ZXh0LiAgRWFjaCBvZiBEb2N1bWVudCBhbmQgV29ya2VyQ29udGV4 dCBtdXN0CisgICAgICAgIGltcGxlbWVudCBhIGZldyB2aXJ0dWFsIG1ldGhvZHMgd2hlcmUgdGhl IERhdGFiYXNlIGNvZGUgcmVxdWlyZXMKKyAgICAgICAgZGlmZmVyZW50aWF0aW9uLgorICAgICAg ICAyKSBXb3JrZXIgdGhyZWFkIHNodXRkb3duIGdvdCBjaGFuZ2VkIGEgYnVuY2ggdG8gaGFuZGxl IERhdGFiYXNlIGNsZWFudXAKKyAgICAgICAgYW5kIHRocmVhZCBzeW5jaHJvbml6YXRpb24gaXNz dWVzLiAgRGF0YWJhc2UgY2xlYW51cCB0YXNrcyBuZWVkIHRvIHBvc3QKKyAgICAgICAgc29tZSBj bGVhbnVwIHRhc2tzIHRvIHRoZSBKYXZhU2NyaXB0IHRocmVhZC4gIEhvd2V2ZXIsIHNpbmNlIGRh dGFiYXNlCisgICAgICAgIGNsZWFudXAgbWF5IGhhcHBlbiBkdWUgdG8gdGhlIGRlc3RydWN0aW9u IG9mIHRoZSBXb3JrZXJUaHJlYWQsIEkgYWRkZWQgYQorICAgICAgICBoYW5kc2hha2UgW2ludm9s dmluZyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzaywKKyAgICAgICAgV29ya2VyVGhyZWFk U2h1dGRvd25GaW5pc2hUYXNrLCBhbmQgYSBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXJdIGJldHdl ZW4KKyAgICAgICAgdGhlIERhdGFiYXNlIHRocmVhZCBhbmQgV29ya2VyVGhyZWFkIHRoYXQgY2xl YW5zIHVwIGFsbCB0aGUgRGF0YWJhc2UKKyAgICAgICAgc3R1ZmYgYmVmb3JlIHRoZSBXb3JrZXJU aHJlYWQncyBydW5Mb29wIGNhbiBleGl0LgorICAgICAgICAzKSBUaGUgcnVudGltZSBlbmFibGVy IGZvciB0aGUgRGF0YWJhc2UgbW92ZWQgdG8gYSBzdGF0aWMgdmFyaWFibGUKKyAgICAgICAgYWNj ZXNzaWJsZSB0aHJvdWdoIERhdGFiYXNlOjppc0F2YWlsYWJsZSwgZm9sbG93aW5nIHRoZSBtb2Rl bCB1c2VkIGJ5CisgICAgICAgIFdlYlNvY2tldC4KKyAgICAgICAgNCkgV29ya2VyIHRocmVhZHMg ZG9uJ3QgcnVuIHRoZWlyIEphdmFTY3JpcHQgb24gdGhlIE1haW4gdGhyZWFkLCBzbworICAgICAg ICBEYXRhYmFzZSBjb2RlIHRoYXQgZGlmZmVyZW50aWF0ZWQgYmV0d2VlbiB0aGUgTWFpbiB0aHJl YWQgYW5kIHRoZQorICAgICAgICBEYXRhYmFzZSB0aHJlYWQgbm93IG5lZWQgdG8gZGVhbCB3aXRo IGEgdGhpcmQgcG9zc2liaWxpdHkuCisgICAgICAgIDUpIE1vc3Qgb2YgdGhlIG90aGVyIGNoYW5n ZXMgaGF2ZSB0byBkbyB3aXRoIGhhdmluZyBhCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgcG9pbnRlciBpbnN0ZWFkIG9mIGEgRG9jdW1lbnQgcG9pbnRlciB3aGVuCisgICAgICAgIGRl YWxpbmcgd2l0aCBhIERhdGFiYXNlLiAgSW4gbWFueSBjYXNlcyBpdCdzIGp1c3QgYSBzdHJpbmcg cmVwbGFjZW1lbnQsCisgICAgICAgIGJ1dCBpbiBzb21lIGl0IHJlcXVpcmVkIHRoZSBjcmVhdGlv biBvZiBhIG5ldyB2aXJ0dWFsIGZ1bmN0aW9uIFtlLmcuCisgICAgICAgIGRhdGFiYXNlRXhjZWVk ZWRRdW90YSwgaXNEYXRhYmFzZVJlYWRPbmx5XQorICAgICAgICA2KSBQcmV2aW91c2x5IG9wZW5E YXRhYmFzZSB3b3VsZCBqdXN0IHJldHVybiBudWxsIGlmIHRoZSBvcGVuZXIgZGlkbid0CisgICAg ICAgIGhhdmUgcGVybWlzc2lvbiB0byBhY2Nlc3MgdGhlIGRhdGFiYXNlLiAgSSd2ZSBjaGFuZ2Vk IGl0IHRvIHRocm93IGFuCisgICAgICAgIGV4Y2VwdGlvbiwgYXMgSSBiZWxpdmUgdGhhdCdzIHdo YXQgdGhlIHNwZWMgcmVxdWlyZXMuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIyNzI1CisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyBpbiBhIGZ1dHVy ZSBwYXRjaCBJJ2xsIGFkZCBKU0MgYW5kIFY4IGJpbmRpbmdzIGFuZCBuZXcKKyAgICAgICAgbGF5 b3V0IHRlc3RzIHRvIGV4ZXJjaXNlIHRoZW0uCisKKyAgICAgICAgKiBiaW5kaW5ncy92OC9jdXN0 b20vVjhET01XaW5kb3dDdXN0b20uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VjhET01XaW5kb3c6 Ok9wZW5EYXRhYmFzZUVuYWJsZWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpEb2N1bWVudDo6RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9j dW1lbnQ6On5Eb2N1bWVudCk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6aXNEYXRhYmFz ZVJlYWRPbmx5KToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpkYXRhYmFzZUV4Y2VlZGVk UXVvdGEpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmlzQ29udGV4dFRocmVhZCk6Cisg ICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogZG9tL1NjcmlwdEV4ZWN1dGlvbkNv bnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6U2Ny aXB0RXhlY3V0aW9uQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25D b250ZXh0Ojp+U2NyaXB0RXhlY3V0aW9uQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpkYXRhYmFzZVRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjphZGRPcGVuRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6cmVtb3ZlT3BlbkRhdGFiYXNlKToKKyAgICAgICAg KFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnN0b3BEYXRhYmFzZXMpOgorICAgICAg ICAqIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg6CisgICAgICAgIChXZWJDb3JlOjpTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpzZXRIYXNPcGVuRGF0YWJhc2VzKToKKyAgICAgICAgKFdlYkNv cmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6Omhhc09wZW5EYXRhYmFzZXMpOgorICAgICAgICAo V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzazo6aXNDbGVhbnVwVGFzayk6Cisg ICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1l TG9hZGVyOjpzdG9wTG9hZGluZyk6CisgICAgICAgICogcGFnZS9ET01XaW5kb3cuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpvcGVuRGF0YWJhc2UpOgorICAgICAgICAqIHN0b3Jh Z2UvRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNldElzQXZhaWxh YmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjppc0F2YWlsYWJsZSk6CisgICAgICAg IChXZWJDb3JlOjpEYXRhYmFzZTo6b3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRh dGFiYXNlOjpEYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEZXJlZkNvbnRleHRUYXNrOjpj cmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6cGVyZm9ybVRhc2sp OgorICAgICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6aXNDbGVhbnVwVGFzayk6Cisg ICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6fkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6 OkRhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbik6CisgICAgICAgIChXZWJDb3JlOjpEYXRh YmFzZTo6bWFya0FzRGVsZXRlZEFuZENsb3NlKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRleHRS ZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4 dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6 OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjppc0NsZWFudXBUYXNrKToKKyAgICAgICAg KFdlYkNvcmU6OkNvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpDb250ZXh0UmVtb3ZlT3Bl bkRhdGFiYXNlVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6Y2xvc2UpOgorICAg ICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnBlcmZvcm1PcGVuQW5kVmVyaWZ5KToKKyAgICAgICAg KFdlYkNvcmU6OkRhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uU3RlcCk6CisgICAgICAgIChXZWJDb3Jl OjpEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJD b3JlOjpEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzazo6RGVsaXZlclBlbmRpbmdDYWxsYmFja1Rh c2spOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25DYWxs YmFjayk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6dHJhbnNhY3Rpb25DbGllbnQpOgor ICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IpOgorICAg ICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnRhYmxlTmFtZXMpOgorICAgICAgICAoV2ViQ29yZTo6 RGF0YWJhc2U6OnNlY3VyaXR5T3JpZ2luKToKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNlLmg6 CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6c2NyaXB0RXhlY3V0aW9uQ29udGV4dCk6Cisg ICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRhc2suaDoKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFi YXNlVGhyZWFkLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpEYXRhYmFz ZVRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6fkRhdGFiYXNlVGhy ZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRp b24pOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OmRhdGFiYXNlVGhyZWFkKToK KyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNr cyk6CisgICAgICAgICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oOgorICAgICAgICAqIHN0b3Jh Z2UvRGF0YWJhc2VUcmFja2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tl cjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFj a2VyOjpnZXRNYXhTaXplRm9yRGF0YWJhc2UpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VU cmFja2VyLmg6CisgICAgICAgICogc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5jcHA6CisgICAgICAg IChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbjo6ZXhlY3V0ZVNRTCk6CisgICAgICAgICogc3RvcmFn ZS9TUUxUcmFuc2FjdGlvbkNsaWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2Fj dGlvbkNsaWVudDo6ZGlkQ29tbWl0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6U1FM VHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4ZWN1dGVTdGF0ZW1lbnQpOgorICAgICAgICAoV2ViQ29y ZTo6U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKToKKyAgICAgICAgKiBzdG9y YWdlL2Nocm9taXVtL0RhdGFiYXNlVHJhY2tlckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UpOgorICAgICAgICAoV2Vi Q29yZTo6RGF0YWJhc2VUcmFja2VyOjphZGRPcGVuRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29y ZTo6VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJD b3JlOjpUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAg ICAoV2ViQ29yZTo6VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OlRyYWNrZXJSZW1vdmVP cGVuRGF0YWJhc2VUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6cmVt b3ZlT3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6Z2V0 TWF4U2l6ZUZvckRhdGFiYXNlKToKKyAgICAgICAgKiBzdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5z YWN0aW9uQ2xpZW50Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJh c2VDaGFuZ2VkVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFiYXNl Q2hhbmdlZFRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFi YXNlQ2hhbmdlZFRhc2s6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2spOgorICAgICAgICAoV2Vi Q29yZTo6U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0aW9uKToKKyAgICAg ICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhdGVtZW50KToK KyAgICAgICAgKFdlYkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YSk6 CisgICAgICAgICogd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OldvcmtlckNvbnRleHQ6Om9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJD b250ZXh0Ojppc0NvbnRleHRUaHJlYWQpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4 dC5oOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6Y2xlYXJTY3JpcHQpOgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6dGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6 OldvcmtlckNvbnRleHQ6OmlzRGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpX b3JrZXJDb250ZXh0OjpkYXRhYmFzZUV4Y2VlZGVkUXVvdGEpOgorICAgICAgICAqIHdvcmtlcnMv V29ya2VyUnVuTG9vcC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJSdW5Mb29wOjpydW5J bk1vZGUpOgorICAgICAgICAoV2ViQ29yZTo6V29ya2VyUnVuTG9vcDo6VGFzazo6cGVyZm9ybVRh c2spOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyVGhyZWFkLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OldvcmtlclRocmVhZDo6d29ya2VyVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6Oldvcmtl clRocmVhZFNodXRkb3duRmluaXNoVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Oldv cmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2Vi Q29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjppc0NsZWFudXBUYXNrKToKKyAg ICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpjcmVhdGUpOgor ICAgICAgICAoV2ViQ29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6OnBlcmZvcm1U YXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpp c0NsZWFudXBUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZDo6c3RvcCk6CisK IDIwMTAtMDEtMTcgIEpvbiBIb25leWN1dHQgIDxqaG9uZXljdXR0QGFwcGxlLmNvbT4KIAogICAg ICAgICBNU0FBOiBUaGUgY2hpbGQgPG9wdGlvbj4gZWxlbWVudHMgb2YgYSBub24tbXVsdGlwbGUg PHNlbGVjdD4gYXJlIG5vdApJbmRleDogV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhET01X aW5kb3dDdXN0b20uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9t L1Y4RE9NV2luZG93Q3VzdG9tLmNwcAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3JlL2JpbmRp bmdzL3Y4L2N1c3RvbS9WOERPTVdpbmRvd0N1c3RvbS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMz LDYgKzMzLDcgQEAKIAogI2luY2x1ZGUgIkJhc2U2NC5oIgogI2luY2x1ZGUgIkNocm9tZS5oIgor I2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRE9NVGltZXIuaCIKICNpbmNsdWRlICJE T01XaW5kb3cuaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCkBAIC0yOTYsNyArMjk3LDcg QEAgYm9vbCBWOERPTVdpbmRvdzo6V2ViU29ja2V0RW5hYmxlZCgpCiAjaWYgRU5BQkxFKERBVEFC QVNFKQogYm9vbCBWOERPTVdpbmRvdzo6T3BlbkRhdGFiYXNlRW5hYmxlZCgpCiB7Ci0gICAgcmV0 dXJuIFdlYkNvcmU6OlJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmRhdGFiYXNlRW5hYmxlZCgpOwor ICAgIHJldHVybiBEYXRhYmFzZTo6aXNBdmFpbGFibGUoKTsKIH0KICNlbmRpZgogCkluZGV4OiBX ZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vRG9jdW1l bnQuY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAkod29y a2luZyBjb3B5KQpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNs dWRlICJDYWNoZWRDU1NTdHlsZVNoZWV0LmgiCiAjaW5jbHVkZSAiQ2hyb21lLmgiCisjaW5jbHVk ZSAiQ2hyb21lQ2xpZW50LmgiCiAjaW5jbHVkZSAiQ29tbWVudC5oIgogI2luY2x1ZGUgIkNvbnNv bGUuaCIKICNpbmNsdWRlICJDb29raWVKYXIuaCIKQEAgLTEzOCwxMSArMTM5LDYgQEAKICNpbmNs dWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAot I2lmIEVOQUJMRShEQVRBQkFTRSkKLSNpbmNsdWRlICJEYXRhYmFzZS5oIgotI2luY2x1ZGUgIkRh dGFiYXNlVGhyZWFkLmgiCi0jZW5kaWYKLQogI2lmIEVOQUJMRShTSEFSRURfV09SS0VSUykKICNp bmNsdWRlICJTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmgiCiAjZW5kaWYKQEAgLTM2MSw5ICszNTcs NiBAQCBEb2N1bWVudDo6RG9jdW1lbnQoRnJhbWUqIGZyYW1lLCBib29sIGlzCiAjaWYgVVNFKEpT QykKICAgICAsIG1fbm9ybWFsV29ybGRXcmFwcGVyQ2FjaGUoMCkKICNlbmRpZgotI2lmIEVOQUJM RShEQVRBQkFTRSkKLSAgICAsIG1faGFzT3BlbkRhdGFiYXNlcyhmYWxzZSkKLSNlbmRpZgogICAg ICwgbV91c2luZ0dlb2xvY2F0aW9uKGZhbHNlKQogI2lmIEVOQUJMRShXTUwpCiAgICAgLCBtX2Nv bnRhaW5zV01MQ29udGVudChmYWxzZSkKQEAgLTUwOSwxMyArNTAyLDYgQEAgRG9jdW1lbnQ6On5E b2N1bWVudCgpCiAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGNvdW50OyBpKyspCiAgICAg ICAgIGRlbGV0ZUFsbFZhbHVlcyhtX25hbWVDb2xsZWN0aW9uSW5mb1tpXSk7CiAKLSNpZiBFTkFC TEUoREFUQUJBU0UpCi0gICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpIHsKLSAgICAgICAgQVNTRVJU KG1fZGF0YWJhc2VUaHJlYWQtPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpOwotICAgICAgICBtX2Rh dGFiYXNlVGhyZWFkID0gMDsKLSAgICB9Ci0jZW5kaWYKLQogICAgIGlmIChtX3N0eWxlU2hlZXRz KQogICAgICAgICBtX3N0eWxlU2hlZXRzLT5kb2N1bWVudERlc3Ryb3llZCgpOwogCkBAIC00NDEy LDYgKzQzOTgsMjkgQEAgdm9pZCBEb2N1bWVudDo6c2V0U2VjdXJpdHlPcmlnaW4oU2VjdXJpdAog ICAgIGluaXRETlNQcmVmZXRjaCgpOwogfQogCisjaWYgRU5BQkxFKERBVEFCQVNFKQorCitib29s IERvY3VtZW50Ojppc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdAoreworICAgIGlmICghcGFnZSgp IHx8IHBhZ2UoKS0+c2V0dGluZ3MoKS0+cHJpdmF0ZUJyb3dzaW5nRW5hYmxlZCgpKQorICAgICAg ICByZXR1cm4gdHJ1ZTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgRG9jdW1lbnQ6OmRh dGFiYXNlRXhjZWVkZWRRdW90YShjb25zdCBTdHJpbmcmIG5hbWUpCit7CisgICAgUGFnZSogY3Vy cmVudFBhZ2UgPSBwYWdlKCk7CisgICAgaWYgKGN1cnJlbnRQYWdlKQorICAgICAgICBjdXJyZW50 UGFnZS0+Y2hyb21lKCktPmNsaWVudCgpLT5leGNlZWRlZERhdGFiYXNlUXVvdGEoZG9jdW1lbnQo KS0+ZnJhbWUoKSwgbmFtZSk7Cit9CisKKyNlbmRpZgorCitib29sIERvY3VtZW50Ojppc0NvbnRl eHRUaHJlYWQoKSBjb25zdAoreworICAgIHJldHVybiBpc01haW5UaHJlYWQoKTsKK30KKwogdm9p ZCBEb2N1bWVudDo6dXBkYXRlVVJMRm9yUHVzaE9yUmVwbGFjZVN0YXRlKGNvbnN0IEtVUkwmIHVy bCkKIHsKICAgICBGcmFtZSogZiA9IGZyYW1lKCk7CkBAIC00NTEyLDU3ICs0NTIxLDYgQEAgRE9N U2VsZWN0aW9uKiBEb2N1bWVudDo6Z2V0U2VsZWN0aW9uKCkgYwogICAgIHJldHVybiBmcmFtZSgp ID8gZnJhbWUoKS0+ZG9tV2luZG93KCktPmdldFNlbGVjdGlvbigpIDogMDsKIH0KIAotI2lmIEVO QUJMRShEQVRBQkFTRSkKLQotdm9pZCBEb2N1bWVudDo6YWRkT3BlbkRhdGFiYXNlKERhdGFiYXNl KiBkYXRhYmFzZSkKLXsKLSAgICBpZiAoIW1fb3BlbkRhdGFiYXNlU2V0KQotICAgICAgICBtX29w ZW5EYXRhYmFzZVNldC5zZXQobmV3IERhdGFiYXNlU2V0KTsKLQotICAgIEFTU0VSVCghbV9vcGVu RGF0YWJhc2VTZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7Ci0gICAgbV9vcGVuRGF0YWJhc2VTZXQt PmFkZChkYXRhYmFzZSk7Ci19Ci0KLXZvaWQgRG9jdW1lbnQ6OnJlbW92ZU9wZW5EYXRhYmFzZShE YXRhYmFzZSogZGF0YWJhc2UpCi17Ci0gICAgQVNTRVJUKG1fb3BlbkRhdGFiYXNlU2V0ICYmIG1f b3BlbkRhdGFiYXNlU2V0LT5jb250YWlucyhkYXRhYmFzZSkpOwotICAgIGlmICghbV9vcGVuRGF0 YWJhc2VTZXQpCi0gICAgICAgIHJldHVybjsKLSAgICAgICAgCi0gICAgbV9vcGVuRGF0YWJhc2VT ZXQtPnJlbW92ZShkYXRhYmFzZSk7Ci19Ci0KLURhdGFiYXNlVGhyZWFkKiBEb2N1bWVudDo6ZGF0 YWJhc2VUaHJlYWQoKQotewotICAgIGlmICghbV9kYXRhYmFzZVRocmVhZCAmJiAhbV9oYXNPcGVu RGF0YWJhc2VzKSB7Ci0gICAgICAgIC8vIENyZWF0ZSB0aGUgZGF0YWJhc2UgdGhyZWFkIG9uIGZp cnN0IHJlcXVlc3QgLSBidXQgbm90IGlmIGF0IGxlYXN0IG9uZSBkYXRhYmFzZSB3YXMgYWxyZWFk eSBvcGVuZWQsCi0gICAgICAgIC8vIGJlY2F1c2UgaW4gdGhhdCBjYXNlIHdlIGFscmVhZHkgaGFk IGEgZGF0YWJhc2UgdGhyZWFkIGFuZCB0ZXJtaW5hdGVkIGl0IGFuZCBzaG91bGQgbm90IGNyZWF0 ZSBhbm90aGVyLgotICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0gRGF0YWJhc2VUaHJlYWQ6OmNy ZWF0ZSgpOwotICAgICAgICBpZiAoIW1fZGF0YWJhc2VUaHJlYWQtPnN0YXJ0KCkpCi0gICAgICAg ICAgICBtX2RhdGFiYXNlVGhyZWFkID0gMDsKLSAgICB9Ci0KLSAgICByZXR1cm4gbV9kYXRhYmFz ZVRocmVhZC5nZXQoKTsKLX0KLQotdm9pZCBEb2N1bWVudDo6c3RvcERhdGFiYXNlcygpCi17Ci0g ICAgaWYgKG1fb3BlbkRhdGFiYXNlU2V0KSB7Ci0gICAgICAgIERhdGFiYXNlU2V0OjppdGVyYXRv ciBpID0gbV9vcGVuRGF0YWJhc2VTZXQtPmJlZ2luKCk7Ci0gICAgICAgIERhdGFiYXNlU2V0Ojpp dGVyYXRvciBlbmQgPSBtX29wZW5EYXRhYmFzZVNldC0+ZW5kKCk7Ci0gICAgICAgIGZvciAoOyBp ICE9IGVuZDsgKytpKSB7Ci0gICAgICAgICAgICAoKmkpLT5zdG9wKCk7Ci0gICAgICAgICAgICBp ZiAobV9kYXRhYmFzZVRocmVhZCkKLSAgICAgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFkLT51 bnNjaGVkdWxlRGF0YWJhc2VUYXNrcygqaSk7Ci0gICAgICAgIH0KLSAgICB9Ci0gICAgCi0gICAg aWYgKG1fZGF0YWJhc2VUaHJlYWQpCi0gICAgICAgIG1fZGF0YWJhc2VUaHJlYWQtPnJlcXVlc3RU ZXJtaW5hdGlvbigpOwotfQotCi0jZW5kaWYKLQogI2lmIEVOQUJMRShXTUwpCiB2b2lkIERvY3Vt ZW50OjpyZXNldFdNTFBhZ2VTdGF0ZSgpCiB7CkluZGV4OiBXZWJDb3JlL2RvbS9Eb2N1bWVudC5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL0RvY3VtZW50LmgJKHJldmlzaW9uIDUzNTEyKQor KysgV2ViQ29yZS9kb20vRG9jdW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtOTIyLDE0ICs5MjIs MTIgQEAgcHVibGljOgogICAgIGJvb2wgcHJvY2Vzc2luZ0xvYWRFdmVudCgpIGNvbnN0IHsgcmV0 dXJuIG1fcHJvY2Vzc2luZ0xvYWRFdmVudDsgfQogCiAjaWYgRU5BQkxFKERBVEFCQVNFKQotICAg IHZvaWQgYWRkT3BlbkRhdGFiYXNlKERhdGFiYXNlKik7Ci0gICAgdm9pZCByZW1vdmVPcGVuRGF0 YWJhc2UoRGF0YWJhc2UqKTsKLSAgICBEYXRhYmFzZVRocmVhZCogZGF0YWJhc2VUaHJlYWQoKTsg ICAvLyBDcmVhdGVzIHRoZSB0aHJlYWQgYXMgbmVlZGVkLCBidXQgbm90IGlmIGl0IGhhcyBiZWVu IGFscmVhZHkgdGVybWluYXRlZC4KLSAgICB2b2lkIHNldEhhc09wZW5EYXRhYmFzZXMoKSB7IG1f aGFzT3BlbkRhdGFiYXNlcyA9IHRydWU7IH0KLSAgICBib29sIGhhc09wZW5EYXRhYmFzZXMoKSB7 IHJldHVybiBtX2hhc09wZW5EYXRhYmFzZXM7IH0KLSAgICB2b2lkIHN0b3BEYXRhYmFzZXMoKTsK KyAgICB2aXJ0dWFsIGJvb2wgaXNEYXRhYmFzZVJlYWRPbmx5KCkgY29uc3Q7CisgICAgdmlydHVh bCB2b2lkIGRhdGFiYXNlRXhjZWVkZWRRdW90YShjb25zdCBTdHJpbmcmIG5hbWUpOwogI2VuZGlm CiAKKyAgICB2aXJ0dWFsIGJvb2wgaXNDb250ZXh0VGhyZWFkKCkgY29uc3Q7CisKICAgICB2b2lk IHNldFVzaW5nR2VvbG9jYXRpb24oYm9vbCBmKSB7IG1fdXNpbmdHZW9sb2NhdGlvbiA9IGY7IH0K ICAgICBib29sIHVzaW5nR2VvbG9jYXRpb24oKSBjb25zdCB7IHJldHVybiBtX3VzaW5nR2VvbG9j YXRpb247IH07CiAKQEAgLTExOTIsMTMgKzExOTAsNiBAQCBwcml2YXRlOgogICAgIEpTV3JhcHBl ckNhY2hlKiBtX25vcm1hbFdvcmxkV3JhcHBlckNhY2hlOwogI2VuZGlmCiAKLSNpZiBFTkFCTEUo REFUQUJBU0UpCi0gICAgUmVmUHRyPERhdGFiYXNlVGhyZWFkPiBtX2RhdGFiYXNlVGhyZWFkOwot ICAgIGJvb2wgbV9oYXNPcGVuRGF0YWJhc2VzOyAgICAvLyBUaGlzIG5ldmVyIGNoYW5nZXMgYmFj ayB0byBmYWxzZSwgZXZlbiBhcyB0aGUgZGF0YWJhc2UgdGhyZWFkIGlzIGNsb3NlZC4KLSAgICB0 eXBlZGVmIEhhc2hTZXQ8RGF0YWJhc2UqPiBEYXRhYmFzZVNldDsKLSAgICBPd25QdHI8RGF0YWJh c2VTZXQ+IG1fb3BlbkRhdGFiYXNlU2V0OwotI2VuZGlmCi0gICAgCiAgICAgYm9vbCBtX3VzaW5n R2VvbG9jYXRpb247CiAKICNpZiBFTkFCTEUoV01MKQpJbmRleDogV2ViQ29yZS9kb20vU2NyaXB0 RXhlY3V0aW9uQ29udGV4dC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vU2NyaXB0RXhl Y3V0aW9uQ29udGV4dC5jcHAJKHJldmlzaW9uIDUzNTEyKQorKysgV2ViQ29yZS9kb20vU2NyaXB0 RXhlY3V0aW9uQ29udGV4dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI4LDcgKzI4LDggQEAKICNp bmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAKICNpbmNsdWRlICJBY3RpdmVET01P YmplY3QuaCIKLSNpbmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5o IgorI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCiAjaW5jbHVkZSAiTWVzc2FnZVBvcnQuaCIK ICNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIK QEAgLTU2LDYgKzU3LDkgQEAgcHVibGljOgogfTsKIAogU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6 U2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpCisjaWYgRU5BQkxFKERBVEFCQVNFKQorICAgIDogbV9o YXNPcGVuRGF0YWJhc2VzKGZhbHNlKQorI2VuZGlmCiB7CiB9CiAKQEAgLTcyLDggKzc2LDY3IEBA IFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6On5TY3JpcHRFeGVjdXRpb24KICAgICAgICAgQVNTRVJU KCgqaXRlciktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA9PSB0aGlzKTsKICAgICAgICAgKCpp dGVyKS0+Y29udGV4dERlc3Ryb3llZCgpOwogICAgIH0KKyAgICBpZiAobV9kYXRhYmFzZVRocmVh ZCkgeworICAgICAgICBBU1NFUlQobV9kYXRhYmFzZVRocmVhZC0+dGVybWluYXRpb25SZXF1ZXN0 ZWQoKSk7CisgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQgPSAwOworICAgIH0KIH0KIAorI2lmIEVO QUJMRShEQVRBQkFTRSkKKworRGF0YWJhc2VUaHJlYWQqIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OmRhdGFiYXNlVGhyZWFkKCkKK3sKKyAgICBpZiAoIW1fZGF0YWJhc2VUaHJlYWQgJiYgIW1faGFz T3BlbkRhdGFiYXNlcykgeworICAgICAgICAvLyBDcmVhdGUgdGhlIGRhdGFiYXNlIHRocmVhZCBv biBmaXJzdCByZXF1ZXN0IC0gYnV0IG5vdCBpZiBhdCBsZWFzdCBvbmUgZGF0YWJhc2Ugd2FzIGFs cmVhZHkgb3BlbmVkLAorICAgICAgICAvLyBiZWNhdXNlIGluIHRoYXQgY2FzZSB3ZSBhbHJlYWR5 IGhhZCBhIGRhdGFiYXNlIHRocmVhZCBhbmQgdGVybWluYXRlZCBpdCBhbmQgc2hvdWxkIG5vdCBj cmVhdGUgYW5vdGhlci4KKyAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IERhdGFiYXNlVGhyZWFk OjpjcmVhdGUoKTsKKyAgICAgICAgaWYgKCFtX2RhdGFiYXNlVGhyZWFkLT5zdGFydCgpKQorICAg ICAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IDA7CisgICAgfQorCisgICAgcmV0dXJuIG1fZGF0 YWJhc2VUaHJlYWQuZ2V0KCk7Cit9CisKK3ZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6YWRk T3BlbkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sKKyAgICBBU1NFUlQoaXNDb250ZXh0 VGhyZWFkKCkpOworICAgIGlmICghbV9vcGVuRGF0YWJhc2VTZXQpCisgICAgICAgIG1fb3BlbkRh dGFiYXNlU2V0LnNldChuZXcgRGF0YWJhc2VTZXQoKSk7CisKKyAgICBBU1NFUlQoIW1fb3BlbkRh dGFiYXNlU2V0LT5jb250YWlucyhkYXRhYmFzZSkpOworICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5h ZGQoZGF0YWJhc2UpOworfQorCit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9w ZW5EYXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCit7CisgICAgQVNTRVJUKGlzQ29udGV4dFRo cmVhZCgpKTsKKyAgICBBU1NFUlQobV9vcGVuRGF0YWJhc2VTZXQgJiYgbV9vcGVuRGF0YWJhc2VT ZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7CisgICAgaWYgKCFtX29wZW5EYXRhYmFzZVNldCkKKyAg ICAgICAgcmV0dXJuOworICAgIG1fb3BlbkRhdGFiYXNlU2V0LT5yZW1vdmUoZGF0YWJhc2UpOwor fQorCit2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnN0b3BEYXRhYmFzZXMoRGF0YWJhc2VU YXNrU3luY2hyb25pemVyKiBjbGVhbnVwU3luYykKK3sKKyAgICBBU1NFUlQoaXNDb250ZXh0VGhy ZWFkKCkpOworICAgIGlmIChtX29wZW5EYXRhYmFzZVNldCkgeworICAgICAgICBEYXRhYmFzZVNl dDo6aXRlcmF0b3IgaSA9IG1fb3BlbkRhdGFiYXNlU2V0LT5iZWdpbigpOworICAgICAgICBEYXRh YmFzZVNldDo6aXRlcmF0b3IgZW5kID0gbV9vcGVuRGF0YWJhc2VTZXQtPmVuZCgpOworICAgICAg ICBmb3IgKDsgaSAhPSBlbmQ7ICsraSkgeworICAgICAgICAgICAgKCppKS0+c3RvcCgpOworICAg ICAgICAgICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpCisgICAgICAgICAgICAgICAgbV9kYXRhYmFz ZVRocmVhZC0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3MoKmkpOworICAgICAgICB9CisgICAgfQor ICAgIAorICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKQorICAgICAgICBtX2RhdGFiYXNlVGhyZWFk LT5yZXF1ZXN0VGVybWluYXRpb24oY2xlYW51cFN5bmMpOworICAgIGVsc2UgaWYgKGNsZWFudXBT eW5jKQorICAgICAgICBjbGVhbnVwU3luYy0+dGFza0NvbXBsZXRlZCgpOworfQorCisjZW5kaWYK Kwogdm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0Ojpwcm9jZXNzTWVzc2FnZVBvcnRNZXNzYWdl c1Nvb24oKQogewogICAgIHBvc3RUYXNrKFByb2Nlc3NNZXNzYWdlc1Nvb25UYXNrOjpjcmVhdGUo KSk7CkluZGV4OiBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oCShyZXZpc2lvbiA1MzUx MikKKysrIFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAkod29ya2luZyBjb3B5 KQpAQCAtMzMsMTEgKzMzLDE3IEBACiAjaW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRl IDx3dGYvUGFzc093blB0ci5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVk ZSA8d3RmL1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCiAgICAgY2xhc3MgQWN0aXZlRE9NT2JqZWN0OworI2lmIEVOQUJMRShEQVRB QkFTRSkKKyAgICBjbGFzcyBEYXRhYmFzZTsKKyAgICBjbGFzcyBEYXRhYmFzZVRhc2tTeW5jaHJv bml6ZXI7CisgICAgY2xhc3MgRGF0YWJhc2VUaHJlYWQ7CisjZW5kaWYKICAgICBjbGFzcyBET01U aW1lcjsKICAgICBjbGFzcyBNZXNzYWdlUG9ydDsKICAgICBjbGFzcyBTZWN1cml0eU9yaWdpbjsK QEAgLTU5LDYgKzY1LDE5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCBi b29sIGlzRG9jdW1lbnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICB2aXJ0dWFs IGJvb2wgaXNXb3JrZXJDb250ZXh0KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KIAorI2lmIEVO QUJMRShEQVRBQkFTRSkKKyAgICAgICAgdmlydHVhbCBib29sIGlzRGF0YWJhc2VSZWFkT25seSgp IGNvbnN0ID0gMDsKKyAgICAgICAgdmlydHVhbCB2b2lkIGRhdGFiYXNlRXhjZWVkZWRRdW90YShj b25zdCBTdHJpbmcmIG5hbWUpID0gMDsKKyAgICAgICAgRGF0YWJhc2VUaHJlYWQqIGRhdGFiYXNl VGhyZWFkKCk7CisgICAgICAgIHZvaWQgc2V0SGFzT3BlbkRhdGFiYXNlcygpIHsgbV9oYXNPcGVu RGF0YWJhc2VzID0gdHJ1ZTsgfQorICAgICAgICBib29sIGhhc09wZW5EYXRhYmFzZXMoKSBjb25z dCB7IHJldHVybiBtX2hhc09wZW5EYXRhYmFzZXM7IH0KKyAgICAgICAgdm9pZCBhZGRPcGVuRGF0 YWJhc2UoRGF0YWJhc2UqKTsKKyAgICAgICAgdm9pZCByZW1vdmVPcGVuRGF0YWJhc2UoRGF0YWJh c2UqKTsKKyAgICAgICAgLy8gV2hlbiB0aGUgZGF0YWJhc2UgY2xlYW51cCBpcyBkb25lLCBjbGVh bnVwU3luYyB3aWxsIGJlIHNpZ25hbGxlZC4KKyAgICAgICAgdm9pZCBzdG9wRGF0YWJhc2VzKERh dGFiYXNlVGFza1N5bmNocm9uaXplciopOworI2VuZGlmCisgICAgICAgIHZpcnR1YWwgYm9vbCBp c0NvbnRleHRUaHJlYWQoKSBjb25zdCA9IDA7CisKICAgICAgICAgY29uc3QgS1VSTCYgdXJsKCkg Y29uc3QgeyByZXR1cm4gdmlydHVhbFVSTCgpOyB9CiAgICAgICAgIEtVUkwgY29tcGxldGVVUkwo Y29uc3QgU3RyaW5nJiB1cmwpIGNvbnN0IHsgcmV0dXJuIHZpcnR1YWxDb21wbGV0ZVVSTCh1cmwp OyB9CiAKQEAgLTk3LDYgKzExNiw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgcHVi bGljOgogICAgICAgICAgICAgdmlydHVhbCB+VGFzaygpOwogICAgICAgICAgICAgdmlydHVhbCB2 b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKSA9IDA7CisgICAgICAgICAg ICAvLyBDZXJ0YWluIHRhc2tzIGdldCBtYXJrZWQgc3BlY2lhbGx5IHNvIHRoYXQgdGhleSBhcmVu J3QgZGlzY2FyZGVkLCBhbmQgYXJlIGV4ZWN1dGVkLCB3aGVuIHRoZSBjb250ZXh0IGlzIHNodXR0 aW5nIGRvd24gaXRzIG1lc3NhZ2UgcXVldWUuCisgICAgICAgICAgICB2aXJ0dWFsIGJvb2wgaXND bGVhbnVwVGFzaygpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgICAgIH07CiAKICAgICAg ICAgdmlydHVhbCB2b2lkIHBvc3RUYXNrKFBhc3NPd25QdHI8VGFzaz4pID0gMDsgLy8gRXhlY3V0 ZXMgdGhlIHRhc2sgb24gY29udGV4dCdzIHRocmVhZCBhc3luY2hyb25vdXNseS4KQEAgLTEyOSw2 ICsxNTAsMTMgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIHZpcnR1YWwgdm9pZCBy ZWZTY3JpcHRFeGVjdXRpb25Db250ZXh0KCkgPSAwOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGVy ZWZTY3JpcHRFeGVjdXRpb25Db250ZXh0KCkgPSAwOworCisjaWYgRU5BQkxFKERBVEFCQVNFKQor ICAgICAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fZGF0YWJhc2VUaHJlYWQ7CisgICAgICAg IGJvb2wgbV9oYXNPcGVuRGF0YWJhc2VzOyAvLyBUaGlzIG5ldmVyIGNoYW5nZXMgYmFjayB0byBm YWxzZSwgZXZlbiBhZnRlciB0aGUgZGF0YWJhc2UgdGhyZWFkIGlzIGNsb3NlZC4KKyAgICAgICAg dHlwZWRlZiBIYXNoU2V0PERhdGFiYXNlKiA+IERhdGFiYXNlU2V0OworICAgICAgICBPd25QdHI8 RGF0YWJhc2VTZXQ+IG1fb3BlbkRhdGFiYXNlU2V0OworI2VuZGlmCiAgICAgfTsKIAogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAkocmV2aXNpb24gNTM1 MTIpCisrKyBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTU2Niw3ICs1NjYsNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpzdG9wTG9hZGluZyhVbmxvYWRFdmVu CiAKICNpZiBFTkFCTEUoREFUQUJBU0UpCiAgICAgICAgIGlmIChkYXRhYmFzZVBvbGljeSA9PSBE YXRhYmFzZVBvbGljeVN0b3ApCi0gICAgICAgICAgICBkb2MtPnN0b3BEYXRhYmFzZXMoKTsKKyAg ICAgICAgICAgIGRvYy0+c3RvcERhdGFiYXNlcygwKTsKICNlbHNlCiAgICAgVU5VU0VEX1BBUkFN KGRhdGFiYXNlUG9saWN5KTsKICNlbmRpZgpJbmRleDogV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAJKHJldmlzaW9uIDUz NTEyKQorKysgV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEx MTYsOCArMTExNiwxMCBAQCBQYXNzUmVmUHRyPERhdGFiYXNlPiBET01XaW5kb3c6Om9wZW5EYXRh CiAgICAgICAgIHJldHVybiAwOwogCiAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gbV9mcmFtZS0+ ZG9jdW1lbnQoKTsKLSAgICBpZiAoIWRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT5jYW5BY2Nl c3NEYXRhYmFzZSgpKQorICAgIGlmICghZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFj Y2Vzc0RhdGFiYXNlKCkpIHsKKyAgICAgICAgZWMgPSBTRUNVUklUWV9FUlI7CiAgICAgICAgIHJl dHVybiAwOworICAgIH0KIAogICAgIFNldHRpbmdzKiBzZXR0aW5ncyA9IG1fZnJhbWUtPnNldHRp bmdzKCk7CiAgICAgaWYgKCFzZXR0aW5ncyB8fCAhc2V0dGluZ3MtPmRhdGFiYXNlc0VuYWJsZWQo KSkKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3JlL3N0 b3JhZ2UvRGF0YWJhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01Myw4ICs1Myw4IEBACiAjaW5j bHVkZSAiU1FMUmVzdWx0U2V0LmgiCiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb25DbGllbnQuaCIK ICNpbmNsdWRlICJTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCi0jaW5jbHVkZSA8d3RmL01h aW5UaHJlYWQuaD4KLSNlbmRpZgorCisjZW5kaWYgLy8gRU5BQkxFKERBVEFCQVNFKQogCiAjaWYg VVNFKEpTQykKICNpbmNsdWRlICJKU0RPTVdpbmRvdy5oIgpAQCAtNzMsNiArNzMsMTggQEAgY29u c3QgU3RyaW5nJiBEYXRhYmFzZTo6ZGF0YWJhc2VJbmZvVGFibAogCiAjaWYgRU5BQkxFKERBVEFC QVNFKQogCitzdGF0aWMgYm9vbCBpc0RhdGFiYXNlQXZhaWxhYmxlID0gZmFsc2U7CisKK3ZvaWQg RGF0YWJhc2U6OnNldElzQXZhaWxhYmxlKGJvb2wgYXZhaWxhYmxlKQoreworICAgIGlzRGF0YWJh c2VBdmFpbGFibGUgPSBhdmFpbGFibGU7Cit9CisKK2Jvb2wgRGF0YWJhc2U6OmlzQXZhaWxhYmxl KCkKK3sKKyAgICByZXR1cm4gaXNEYXRhYmFzZUF2YWlsYWJsZTsKK30KKwogc3RhdGljIE11dGV4 JiBndWlkTXV0ZXgoKQogewogICAgIC8vIE5vdGU6IFdlIGRvbid0IGhhdmUgdG8gdXNlIEF0b21p Y2FsbHlJbml0aWFsaXplZFN0YXRpYyBoZXJlIGJlY2F1c2UKQEAgLTEyMCwzOSArMTMyLDQxIEBA IHN0YXRpYyBjb25zdCBTdHJpbmcmIGRhdGFiYXNlVmVyc2lvbktleSgKIAogc3RhdGljIGludCBn dWlkRm9yT3JpZ2luQW5kTmFtZShjb25zdCBTdHJpbmcmIG9yaWdpbiwgY29uc3QgU3RyaW5nJiBu YW1lKTsKIAotUGFzc1JlZlB0cjxEYXRhYmFzZT4gRGF0YWJhc2U6Om9wZW5EYXRhYmFzZShEb2N1 bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3Rl ZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1h dGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZSkKK1Bhc3NSZWZQdHI8RGF0YWJhc2U+IERhdGFiYXNl OjpvcGVuRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3Ry aW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBk aXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNlcHRpb25Db2RlJiBl KQogewotICAgIGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0YWJsaXNoRGF0 YWJhc2UoZG9jdW1lbnQsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKSkgeworICAg IGlmICghRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuY2FuRXN0YWJsaXNoRGF0YWJhc2UoY29u dGV4dCwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKSB7CiAgICAgICAgIC8vIEZJ WE1FOiBUaGVyZSBzaG91bGQgYmUgYW4gZXhjZXB0aW9uIHJhaXNlZCBoZXJlIGluIGFkZGl0aW9u IHRvIHJldHVybmluZyBhIG51bGwgRGF0YWJhc2Ugb2JqZWN0LiAgVGhlIHF1ZXN0aW9uIGhhcyBi ZWVuIHJhaXNlZCB3aXRoIHRoZSBXSEFUV0cuCi0gICAgICAgIExPRyhTdG9yYWdlQVBJLCAiRGF0 YWJhc2UgJXMgZm9yIG9yaWdpbiAlcyBub3QgYWxsb3dlZCB0byBiZSBlc3RhYmxpc2hlZCIsIG5h bWUuYXNjaWkoKS5kYXRhKCksIGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpLT50b1N0cmluZygp LmFzY2lpKCkuZGF0YSgpKTsKKyAgICAgICAgTE9HKFN0b3JhZ2VBUEksICJEYXRhYmFzZSAlcyBm b3Igb3JpZ2luICVzIG5vdCBhbGxvd2VkIHRvIGJlIGVzdGFibGlzaGVkIiwgbmFtZS5hc2NpaSgp LmRhdGEoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKS5hc2NpaSgpLmRh dGEoKSk7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIFJlZlB0cjxEYXRhYmFzZT4g ZGF0YWJhc2UgPSBhZG9wdFJlZihuZXcgRGF0YWJhc2UoZG9jdW1lbnQsIG5hbWUsIGV4cGVjdGVk VmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKKyAgICBSZWZQdHI8RGF0YWJh c2U+IGRhdGFiYXNlID0gYWRvcHRSZWYobmV3IERhdGFiYXNlKGNvbnRleHQsIG5hbWUsIGV4cGVj dGVkVmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKIAogICAgIGlmICghZGF0 YWJhc2UtPm9wZW5BbmRWZXJpZnlWZXJzaW9uKGUpKSB7CiAgICAgICAgIExPRyhTdG9yYWdlQVBJ LCAiRmFpbGVkIHRvIG9wZW4gYW5kIHZlcmlmeSB2ZXJzaW9uIChleHBlY3RlZCAlcykgb2YgZGF0 YWJhc2UgJXMiLCBleHBlY3RlZFZlcnNpb24uYXNjaWkoKS5kYXRhKCksIGRhdGFiYXNlLT5kYXRh YmFzZURlYnVnTmFtZSgpLmFzY2lpKCkuZGF0YSgpKTsKLSAgICAgICAgZG9jdW1lbnQtPnJlbW92 ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CisgICAgICAgIGNvbnRleHQtPnJlbW92ZU9w ZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAgIERhdGFiYXNlVHJhY2tlcjo6dHJh Y2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSk7CiAgICAgICAgIHJldHVy biAwOwogICAgIH0KIAotICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnNldERhdGFiYXNl RGV0YWlscyhkb2N1bWVudC0+c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5hbWUsIGVz dGltYXRlZFNpemUpOwotCi0gICAgZG9jdW1lbnQtPnNldEhhc09wZW5EYXRhYmFzZXMoKTsKKyAg ICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5zZXREYXRhYmFzZURldGFpbHMoY29udGV4dC0+ c2VjdXJpdHlPcmlnaW4oKSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpOwogCisg ICAgY29udGV4dC0+c2V0SGFzT3BlbkRhdGFiYXNlcygpOwogI2lmIEVOQUJMRShJTlNQRUNUT1Ip Ci0gICAgaWYgKFBhZ2UqIHBhZ2UgPSBkb2N1bWVudC0+ZnJhbWUoKS0+cGFnZSgpKQotICAgICAg ICBwYWdlLT5pbnNwZWN0b3JDb250cm9sbGVyKCktPmRpZE9wZW5EYXRhYmFzZShkYXRhYmFzZS5n ZXQoKSwgZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmhvc3QoKSwgbmFtZSwgZXhwZWN0ZWRW ZXJzaW9uKTsKKyAgICBpZiAoY29udGV4dC0+aXNEb2N1bWVudCgpKSB7CisgICAgICAgIERvY3Vt ZW50KiBkb2N1bWVudCA9IHN0YXRpY19jYXN0PERvY3VtZW50Kj4oY29udGV4dCk7CisgICAgICAg IGlmIChQYWdlKiBwYWdlID0gZG9jdW1lbnQtPnBhZ2UoKSkKKyAgICAgICAgICAgIHBhZ2UtPmlu c3BlY3RvckNvbnRyb2xsZXIoKS0+ZGlkT3BlbkRhdGFiYXNlKGRhdGFiYXNlLmdldCgpLCBjb250 ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5ob3N0KCksIG5hbWUsIGV4cGVjdGVkVmVyc2lvbik7Cisg ICAgfQogI2VuZGlmCiAKICAgICByZXR1cm4gZGF0YWJhc2U7CiB9CiAKLURhdGFiYXNlOjpEYXRh YmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5n JiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxv bmcgZXN0aW1hdGVkU2l6ZSkKK0RhdGFiYXNlOjpEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRW ZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRl ZFNpemUpCiAgICAgOiBtX3RyYW5zYWN0aW9uSW5Qcm9ncmVzcyhmYWxzZSkKICAgICAsIG1faXNU cmFuc2FjdGlvblF1ZXVlRW5hYmxlZCh0cnVlKQotICAgICwgbV9kb2N1bWVudChkb2N1bWVudCkK KyAgICAsIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dChjb250ZXh0KQogICAgICwgbV9uYW1lKG5h bWUuY3Jvc3NUaHJlYWRTdHJpbmcoKSkKICAgICAsIG1fZ3VpZCgwKQogICAgICwgbV9leHBlY3Rl ZFZlcnNpb24oZXhwZWN0ZWRWZXJzaW9uLmNyb3NzVGhyZWFkU3RyaW5nKCkpCkBAIC0xNjIsMTYg KzE3NiwxNSBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjCiAgICAg LCBtX3N0b3BwZWQoZmFsc2UpCiAgICAgLCBtX29wZW5lZChmYWxzZSkKIHsKLSAgICBBU1NFUlQo ZG9jdW1lbnQpOwotICAgIG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luID0gZG9jdW1lbnQtPnNl Y3VyaXR5T3JpZ2luKCk7CisgICAgQVNTRVJUKG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC5nZXQo KSk7CisgICAgbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4gPSBtX3NjcmlwdEV4ZWN1dGlvbkNv bnRleHQtPnNlY3VyaXR5T3JpZ2luKCk7CiAgICAgbV9kYXRhYmFzZVRocmVhZFNlY3VyaXR5T3Jp Z2luID0gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW4tPnRocmVhZHNhZmVDb3B5KCk7Ci0KICAg ICBpZiAobV9uYW1lLmlzTnVsbCgpKQogICAgICAgICBtX25hbWUgPSAiIjsKIAogICAgIFNjcmlw dENvbnRyb2xsZXI6OmluaXRpYWxpemVUaHJlYWRpbmcoKTsKIAotICAgIG1fZ3VpZCA9IGd1aWRG b3JPcmlnaW5BbmROYW1lKG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLT50b1N0cmluZygpLCBu YW1lKTsKKyAgICBtX2d1aWQgPSBndWlkRm9yT3JpZ2luQW5kTmFtZShzZWN1cml0eU9yaWdpbigp LT50b1N0cmluZygpLCBuYW1lKTsKIAogICAgIHsKICAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2Vy KGd1aWRNdXRleCgpKTsKQEAgLTE4NSwyOCArMTk4LDQwIEBAIERhdGFiYXNlOjpEYXRhYmFzZShE b2N1bWVudCogZG9jdW1lbnQsIGMKICAgICAgICAgaGFzaFNldC0+YWRkKHRoaXMpOwogICAgIH0K IAotICAgIEFTU0VSVChtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKTsKLQotICAgIG1fZmls ZW5hbWUgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxsUGF0aEZvckRhdGFiYXNlKG1f bWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLmdldCgpLCBtX25hbWUpOworICAgIEFTU0VSVChtX3Nj cmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpOworICAgIG1fZmlsZW5hbWUg PSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5mdWxsUGF0aEZvckRhdGFiYXNlKHNlY3VyaXR5 T3JpZ2luKCksIG1fbmFtZSk7CiAKICAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5hZGRP cGVuRGF0YWJhc2UodGhpcyk7Ci0gICAgbV9kb2N1bWVudC0+YWRkT3BlbkRhdGFiYXNlKHRoaXMp OworICAgIGNvbnRleHQtPmFkZE9wZW5EYXRhYmFzZSh0aGlzKTsKIH0KIAotc3RhdGljIHZvaWQg ZGVyZWZEb2N1bWVudCh2b2lkKiBkb2N1bWVudCkKLXsKLSAgICBzdGF0aWNfY2FzdDxEb2N1bWVu dCo+KGRvY3VtZW50KS0+ZGVyZWYoKTsKLX0KK2NsYXNzIERlcmVmQ29udGV4dFRhc2sgOiBwdWJs aWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBh c3NPd25QdHI8RGVyZWZDb250ZXh0VGFzaz4gY3JlYXRlKCkKKyAgICB7CisgICAgICAgIHJldHVy biBuZXcgRGVyZWZDb250ZXh0VGFzaygpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJm b3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQorICAgIHsKKyAgICAgICAg Y29udGV4dC0+ZGVyZWYoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGVhbnVwVGFz aygpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KK307CiAKIERhdGFiYXNlOjp+RGF0YWJhc2UoKQog ewotICAgIC8vIERlcmVmIG1fZG9jdW1lbnQgb24gdGhlIG1haW4gdGhyZWFkLgotICAgIGNhbGxP bk1haW5UaHJlYWQoZGVyZWZEb2N1bWVudCwgbV9kb2N1bWVudC5yZWxlYXNlKCkucmVsZWFzZVJl ZigpKTsKKyAgICAvLyBUaGUgcmVmZXJlbmNlIHRvIHRoZSBTY3JpcHRFeGVjdXRpb25Db250ZXh0 IG5lZWRzIHRvIGJlIGNsZWFyZWQgb24gdGhlIEphdmFTY3JpcHQgdGhyZWFkLiAgSWYgd2UncmUg b24gdGhhdCB0aHJlYWQgYWxyZWFkeSwgd2UgY2FuIGp1c3QgbGV0IHRoZSBSZWZQdHIncyBkZXN0 cnVjdGlvbiBkbyB0aGUgZGVyZWZmaW5nLgorICAgIGlmICghbV9zY3JpcHRFeGVjdXRpb25Db250 ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSkgeworICAgICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQtPnBvc3RUYXNrKERlcmVmQ29udGV4dFRhc2s6OmNyZWF0ZSgpKTsKKyAgICAgICAgbV9zY3Jp cHRFeGVjdXRpb25Db250ZXh0LnJlbGVhc2UoKS5yZWxlYXNlUmVmKCk7CisgICAgfQogfQogCiBi b29sIERhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbihFeGNlcHRpb25Db2RlJiBlKQogewot ICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAoIW1fc2NyaXB0 RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKICAgICAgICAgcmV0dXJuIGZhbHNl OwogICAgIG1fZGF0YWJhc2VBdXRob3JpemVyID0gRGF0YWJhc2VBdXRob3JpemVyOjpjcmVhdGUo KTsKIApAQCAtMjE0LDcgKzIzOSw3IEBAIGJvb2wgRGF0YWJhc2U6Om9wZW5BbmRWZXJpZnlWZXJz aW9uKEV4Y2UKICAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIgc3luY2hyb25pemVyOwogICAg IE93blB0cjxEYXRhYmFzZU9wZW5UYXNrPiB0YXNrID0gRGF0YWJhc2VPcGVuVGFzazo6Y3JlYXRl KHRoaXMsICZzeW5jaHJvbml6ZXIsIGUsIHN1Y2Nlc3MpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0 YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAg ICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1t ZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CiAgICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNr Q29tcGxldGlvbigpOwogCiAgICAgcmV0dXJuIHN1Y2Nlc3M7CkBAIC0zMDksNDMgKzMzNCw2MSBA QCBib29sIERhdGFiYXNlOjp2ZXJzaW9uTWF0Y2hlc0V4cGVjdGVkKCkgCiAKIHZvaWQgRGF0YWJh c2U6Om1hcmtBc0RlbGV0ZWRBbmRDbG9zZSgpCiB7Ci0gICAgaWYgKG1fZGVsZXRlZCB8fCAhbV9k b2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAobV9kZWxldGVkIHx8ICFtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJldHVybjsKIAog ICAgIExPRyhTdG9yYWdlQVBJLCAiTWFya2luZyAlcyAoJXApIGFzIGRlbGV0ZWQiLCBzdHJpbmdJ ZGVudGlmaWVyKCkuYXNjaWkoKS5kYXRhKCksIHRoaXMpOwogICAgIG1fZGVsZXRlZCA9IHRydWU7 CiAKLSAgICBpZiAobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+dGVybWluYXRpb25SZXF1 ZXN0ZWQoKSkgeworICAgIGlmIChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhy ZWFkKCktPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpIHsKICAgICAgICAgTE9HKFN0b3JhZ2VBUEks ICJEYXRhYmFzZSBoYW5kbGUgJXAgaXMgb24gYSB0ZXJtaW5hdGVkIERhdGFiYXNlVGhyZWFkLCBj YW5ub3QgYmUgbWFya2VkIGZvciBub3JtYWwgY2xvc3VyZVxuIiwgdGhpcyk7CiAgICAgICAgIHJl dHVybjsKICAgICB9CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT51bnNjaGVk dWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRh dGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKHRoaXMpOwogCiAgICAgRGF0 YWJhc2VUYXNrU3luY2hyb25pemVyIHN5bmNocm9uaXplcjsKICAgICBPd25QdHI8RGF0YWJhc2VD bG9zZVRhc2s+IHRhc2sgPSBEYXRhYmFzZUNsb3NlVGFzazo6Y3JlYXRlKHRoaXMsICZzeW5jaHJv bml6ZXIpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1l ZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQt PmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7 CiAgICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOwogfQogCi1zdGF0aWMg dm9pZCBkb2N1bWVudFJlbW92ZU9wZW5EYXRhYmFzZSh2b2lkKiBjb250ZXh0KQotewotICAgIEFT U0VSVChpc01haW5UaHJlYWQoKSk7Ci0gICAgRGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nh c3Q8RGF0YWJhc2UqPihjb250ZXh0KTsKLSAgICBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cmVtb3Zl T3BlbkRhdGFiYXNlKGRhdGFiYXNlKTsKLSAgICBkYXRhYmFzZS0+ZGVyZWYoKTsKLX0KK2NsYXNz IENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPENvbnRleHRSZW1v dmVPcGVuRGF0YWJhc2VUYXNrPiBjcmVhdGUoUGFzc1JlZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2Up CisgICAgeworICAgICAgICByZXR1cm4gbmV3IENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNr KGRhdGFiYXNlKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCkKKyAgICB7CisgICAgICAgIGNvbnRleHQtPnJlbW92 ZU9wZW5EYXRhYmFzZShtX2RhdGFiYXNlLmdldCgpKTsKKyAgICAgICAgRGF0YWJhc2VUcmFja2Vy Ojp0cmFja2VyKCkucmVtb3ZlT3BlbkRhdGFiYXNlKG1fZGF0YWJhc2UuZ2V0KCkpOworICAgIH0K KworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsg fQorCitwcml2YXRlOgorICAgIENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrKFBhc3NSZWZQ dHI8RGF0YWJhc2U+IGRhdGFiYXNlKQorICAgICAgICA6IG1fZGF0YWJhc2UoZGF0YWJhc2UpCisg ICAgeworICAgIH0KKworICAgIFJlZlB0cjxEYXRhYmFzZT4gbV9kYXRhYmFzZTsKK307CiAKIHZv aWQgRGF0YWJhc2U6OmNsb3NlKCkKIHsKICAgICBpZiAoIW1fb3BlbmVkKQogICAgICAgICByZXR1 cm47CiAKLSAgICBBU1NFUlQobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSk7Ci0gICAgQVNT RVJUKGN1cnJlbnRUaHJlYWQoKSA9PSBkb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRU aHJlYWRJRCgpKTsKKyAgICBBU1NFUlQobV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFz ZVRocmVhZCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IG1fc2NyaXB0RXhlY3V0 aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgbV9zcWxp dGVEYXRhYmFzZS5jbG9zZSgpOwotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnJl Y29yZERhdGFiYXNlQ2xvc2VkKHRoaXMpOworICAgIC8vIE11c3QgcmVmKCkgYmVmb3JlIGNhbGxp bmcgZGF0YWJhc2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VDbG9zZWQoKS4KKyAgICBSZWZQdHI8 RGF0YWJhc2U+IGhvbGRlciA9IHRoaXM7CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5k YXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNsb3NlZCh0aGlzKTsKICAgICBtX29wZW5l ZCA9IGZhbHNlOwogCiAgICAgewpAQCAtMzYyLDExICs0MDUsOCBAQCB2b2lkIERhdGFiYXNlOjpj bG9zZSgpCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVh ZCgpLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsKLQotICAgIERhdGFiYXNlVHJhY2tl cjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZSh0aGlzKTsKLSAgICByZWYoKTsgIC8vIGRl cmVmKCkgY2FsbGVkIGluIGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNlKCkKLSAgICBjYWxsT25N YWluVGhyZWFkKGRvY3VtZW50UmVtb3ZlT3BlbkRhdGFiYXNlLCB0aGlzKTsKKyAgICBtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRh c2tzKHRoaXMpOworICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+cG9zdFRhc2soQ29udGV4 dFJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZShob2xkZXIpKTsKIH0KIAogdm9pZCBEYXRh YmFzZTo6c3RvcCgpCkBAIC01MzIsOCArNTcyLDggQEAgYm9vbCBEYXRhYmFzZTo6cGVyZm9ybU9w ZW5BbmRWZXJpZnkoRXhjZQogICAgIC8vIEFsbCBjaGVja3MgcGFzc2VkIGFuZCB3ZSBzdGlsbCBo YXZlIGEgaGFuZGxlIHRvIHRoaXMgZGF0YWJhc2UgZmlsZS4KICAgICAvLyBNYWtlIHN1cmUgRGF0 YWJhc2VUaHJlYWQgY2xvc2VzIGl0IHdoZW4gRGF0YWJhc2VUaHJlYWQgZ29lcyBhd2F5LgogICAg IG1fb3BlbmVkID0gdHJ1ZTsKLSAgICBpZiAobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkK LSAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VPcGVu KHRoaXMpOworICAgIGlmIChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFk KCkpCisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+ cmVjb3JkRGF0YWJhc2VPcGVuKHRoaXMpOwogCiAgICAgcmV0dXJuIHRydWU7CiB9CkBAIC01Njcs MzIgKzYwNyw1MiBAQCB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uKCkKICAgICAg ICAgbV90cmFuc2FjdGlvblF1ZXVlLnJlbW92ZUZpcnN0KCk7CiAgICAgfQogCi0gICAgaWYgKHRy YW5zYWN0aW9uICYmIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpIHsKKyAgICBpZiAodHJh bnNhY3Rpb24gJiYgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpKSB7 CiAgICAgICAgIE93blB0cjxEYXRhYmFzZVRyYW5zYWN0aW9uVGFzaz4gdGFzayA9IERhdGFiYXNl VHJhbnNhY3Rpb25UYXNrOjpjcmVhdGUodHJhbnNhY3Rpb24pOwogICAgICAgICBMT0coU3RvcmFn ZUFQSSwgIlNjaGVkdWxpbmcgRGF0YWJhc2VUcmFuc2FjdGlvblRhc2sgJXAgZm9yIHRyYW5zYWN0 aW9uICVwXG4iLCB0YXNrLmdldCgpLCB0YXNrLT50cmFuc2FjdGlvbigpKTsKICAgICAgICAgbV90 cmFuc2FjdGlvbkluUHJvZ3Jlc3MgPSB0cnVlOwotICAgICAgICBtX2RvY3VtZW50LT5kYXRhYmFz ZVRocmVhZCgpLT5zY2hlZHVsZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgICAgICBtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0YXNrLnJl bGVhc2UoKSk7CiAgICAgfSBlbHNlCiAgICAgICAgIG1fdHJhbnNhY3Rpb25JblByb2dyZXNzID0g ZmFsc2U7CiB9CiAKIHZvaWQgRGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25TdGVwKFNRTFRy YW5zYWN0aW9uKiB0cmFuc2FjdGlvbiwgYm9vbCBpbW1lZGlhdGVseSkKIHsKLSAgICBpZiAoIW1f ZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpCisgICAgaWYgKCFtX3NjcmlwdEV4ZWN1dGlvbkNv bnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIE93blB0cjxE YXRhYmFzZVRyYW5zYWN0aW9uVGFzaz4gdGFzayA9IERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrOjpj cmVhdGUodHJhbnNhY3Rpb24pOwogICAgIExPRyhTdG9yYWdlQVBJLCAiU2NoZWR1bGluZyBEYXRh YmFzZVRyYW5zYWN0aW9uVGFzayAlcCBmb3IgdGhlIHRyYW5zYWN0aW9uIHN0ZXBcbiIsIHRhc2su Z2V0KCkpOwogICAgIGlmIChpbW1lZGlhdGVseSkKLSAgICAgICAgbV9kb2N1bWVudC0+ZGF0YWJh c2VUaHJlYWQoKS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAg ICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUlt bWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOwogICAgIGVsc2UKLSAgICAgICAgbV9kb2N1bWVu dC0+ZGF0YWJhc2VUaHJlYWQoKS0+c2NoZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICAg ICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZVRh c2sodGFzay5yZWxlYXNlKCkpOwogfQogCitjbGFzcyBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFz ayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBz dGF0aWMgUGFzc093blB0cjxEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzaz4gY3JlYXRlKFBhc3NS ZWZQdHI8U1FMVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKQorICAgIHsKKyAgICAgICAgcmV0dXJu IG5ldyBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayh0cmFuc2FjdGlvbik7CisgICAgfQorCisg ICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQorICAg IHsKKyAgICAgICAgbV90cmFuc2FjdGlvbi0+cGVyZm9ybVBlbmRpbmdDYWxsYmFjaygpOworICAg IH0KKworcHJpdmF0ZToKKyAgICBEZWxpdmVyUGVuZGluZ0NhbGxiYWNrVGFzayhQYXNzUmVmUHRy PFNRTFRyYW5zYWN0aW9uPiB0cmFuc2FjdGlvbikKKyAgICAgICAgOiBtX3RyYW5zYWN0aW9uKHRy YW5zYWN0aW9uKQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8U1FMVHJhbnNhY3Rpb24+IG1f dHJhbnNhY3Rpb247Cit9OworCiB2b2lkIERhdGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uQ2Fs bGJhY2soU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewotICAgIHRyYW5zYWN0aW9uLT5y ZWYoKTsKLSAgICBjYWxsT25NYWluVGhyZWFkKGRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2ssIHRyYW5z YWN0aW9uKTsKKyAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKERlbGl2ZXJQ ZW5kaW5nQ2FsbGJhY2tUYXNrOjpjcmVhdGUodHJhbnNhY3Rpb24pKTsKIH0KIAogVmVjdG9yPFN0 cmluZz4gRGF0YWJhc2U6OnBlcmZvcm1HZXRUYWJsZU5hbWVzKCkKQEAgLTYyNiwxMiArNjg2LDEy IEBAIFZlY3RvcjxTdHJpbmc+IERhdGFiYXNlOjpwZXJmb3JtR2V0VGFibGUKIAogU1FMVHJhbnNh Y3Rpb25DbGllbnQqIERhdGFiYXNlOjp0cmFuc2FjdGlvbkNsaWVudCgpIGNvbnN0CiB7Ci0gICAg cmV0dXJuIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnRyYW5zYWN0aW9uQ2xpZW50KCk7 CisgICAgcmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+ dHJhbnNhY3Rpb25DbGllbnQoKTsKIH0KIAogU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvciogRGF0 YWJhc2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSBjb25zdAogewotICAgIHJldHVybiBtX2Rv Y3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCk7CisgICAg cmV0dXJuIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+dHJhbnNh Y3Rpb25Db29yZGluYXRvcigpOwogfQogCiBTdHJpbmcgRGF0YWJhc2U6OnZlcnNpb24oKSBjb25z dApAQCAtNjQyLDI1ICs3MDIsMTggQEAgU3RyaW5nIERhdGFiYXNlOjp2ZXJzaW9uKCkgY29uc3QK ICAgICByZXR1cm4gZ3VpZFRvVmVyc2lvbk1hcCgpLmdldChtX2d1aWQpLnRocmVhZHNhZmVDb3B5 KCk7CiB9CiAKLXZvaWQgRGF0YWJhc2U6OmRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2sodm9pZCogY29u dGV4dCkKLXsKLSAgICBTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24gPSBzdGF0aWNfY2FzdDxT UUxUcmFuc2FjdGlvbio+KGNvbnRleHQpOwotICAgIHRyYW5zYWN0aW9uLT5wZXJmb3JtUGVuZGlu Z0NhbGxiYWNrKCk7Ci0gICAgdHJhbnNhY3Rpb24tPmRlcmVmKCk7IC8vIFdhcyByZWYnZCBpbiBz Y2hlZHVsZVRyYW5zYWN0aW9uQ2FsbGJhY2soKS4KLX0KLQogVmVjdG9yPFN0cmluZz4gRGF0YWJh c2U6OnRhYmxlTmFtZXMoKQogewogICAgIC8vIEZJWE1FOiBOb3QgdXNpbmcgdGhyZWFkc2FmZUNv cHkgb24gdGhlc2Ugc3RyaW5ncyBsb29rcyBvayBzaW5jZSB0aHJlYWRzIHRha2Ugc3RyaWN0IHR1 cm5zCiAgICAgLy8gaW4gZGVhbGluZyB3aXRoIHRoZW0uIEhvd2V2ZXIsIGlmIHRoZSBjb2RlIGNo YW5nZXMsIHRoaXMgbWF5IG5vdCBiZSB0cnVlIGFueW1vcmUuCiAgICAgVmVjdG9yPFN0cmluZz4g cmVzdWx0OwotICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICBpZiAo IW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKICAgICAgICAgcmV0 dXJuIHJlc3VsdDsKIAogICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBzeW5jaHJvbml6ZXI7 CiAgICAgT3duUHRyPERhdGFiYXNlVGFibGVOYW1lc1Rhc2s+IHRhc2sgPSBEYXRhYmFzZVRhYmxl TmFtZXNUYXNrOjpjcmVhdGUodGhpcywgJnN5bmNocm9uaXplciwgcmVzdWx0KTsKIAotICAgIG1f ZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJl bGVhc2UoKSk7CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgp LT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOwogICAgIHN5bmNocm9uaXpl ci53YWl0Rm9yVGFza0NvbXBsZXRpb24oKTsKIAogICAgIHJldHVybiByZXN1bHQ7CkBAIC02NzYs OSArNzI5LDkgQEAgdm9pZCBEYXRhYmFzZTo6c2V0RXhwZWN0ZWRWZXJzaW9uKGNvbnN0IAogCiBT ZWN1cml0eU9yaWdpbiogRGF0YWJhc2U6OnNlY3VyaXR5T3JpZ2luKCkgY29uc3QKIHsKLSAgICBp ZiAoaXNNYWluVGhyZWFkKCkpCisgICAgaWYgKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXND b250ZXh0VGhyZWFkKCkpCiAgICAgICAgIHJldHVybiBtX21haW5UaHJlYWRTZWN1cml0eU9yaWdp bi5nZXQoKTsKLSAgICBpZiAoY3VycmVudFRocmVhZCgpID09IGRvY3VtZW50KCktPmRhdGFiYXNl VGhyZWFkKCktPmdldFRocmVhZElEKCkpCisgICAgaWYgKGN1cnJlbnRUaHJlYWQoKSA9PSBtX3Nj cmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpCiAg ICAgICAgIHJldHVybiBtX2RhdGFiYXNlVGhyZWFkU2VjdXJpdHlPcmlnaW4uZ2V0KCk7CiAgICAg cmV0dXJuIDA7CiB9CkBAIC03MDYsNiArNzU5LDYgQEAgU3RyaW5nIERhdGFiYXNlOjpmaWxlTmFt ZSgpIGNvbnN0CiAgICAgcmV0dXJuIG1fZmlsZW5hbWUudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAot I2VuZGlmCisjZW5kaWYgLy8gRU5BQkxFKERBVEFCQVNFKQogCi19Cit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuaAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3JlL3N0 b3JhZ2UvRGF0YWJhc2UuaAkod29ya2luZyBjb3B5KQpAQCAtNTIsNyArNTIsNyBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKIGNsYXNzIERhdGFiYXNlQXV0aG9yaXplcjsKIGNsYXNzIERhdGFiYXNl VGhyZWFkOwotY2xhc3MgRG9jdW1lbnQ7CitjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0Owog Y2xhc3MgU1FMUmVzdWx0U2V0OwogY2xhc3MgU1FMVHJhbnNhY3Rpb25DYWxsYmFjazsKIGNsYXNz IFNRTFRyYW5zYWN0aW9uQ2xpZW50OwpAQCAtNjcsMTAgKzY3LDEzIEBAIGNsYXNzIERhdGFiYXNl IDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQKICAgICBmcmllbmQgY2xhc3MgU1FMU3RhdGVtZW50 OwogICAgIGZyaWVuZCBjbGFzcyBTUUxUcmFuc2FjdGlvbjsKIHB1YmxpYzoKKyAgICBzdGF0aWMg dm9pZCBzZXRJc0F2YWlsYWJsZShib29sKTsKKyAgICBzdGF0aWMgYm9vbCBpc0F2YWlsYWJsZSgp OworCiAgICAgfkRhdGFiYXNlKCk7CiAKIC8vIERpcmVjdCBzdXBwb3J0IGZvciB0aGUgRE9NIEFQ SQotICAgIHN0YXRpYyBQYXNzUmVmUHRyPERhdGFiYXNlPiBvcGVuRGF0YWJhc2UoRG9jdW1lbnQq IGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJz aW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNp emUsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxEYXRhYmFzZT4gb3Bl bkRhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYg bmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxh eU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYpOwogICAg IFN0cmluZyB2ZXJzaW9uKCkgY29uc3Q7CiAgICAgdm9pZCBjaGFuZ2VWZXJzaW9uKGNvbnN0IFN0 cmluZyYgb2xkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBuZXdWZXJzaW9uLAogICAgICAgICAgICAg ICAgICAgICAgICBQYXNzUmVmUHRyPFNRTFRyYW5zYWN0aW9uQ2FsbGJhY2s+IGNhbGxiYWNrLCBQ YXNzUmVmUHRyPFNRTFRyYW5zYWN0aW9uRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaywKQEAg LTg3LDcgKzkwLDcgQEAgcHVibGljOgogCiAgICAgVmVjdG9yPFN0cmluZz4gdGFibGVOYW1lcygp OwogCi0gICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3QgeyByZXR1cm4gbV9kb2N1bWVudC5n ZXQoKTsgfQorICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQoKSBjb25zdCB7IHJldHVybiBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuZ2V0KCk7IH0KICAg ICBTZWN1cml0eU9yaWdpbiogc2VjdXJpdHlPcmlnaW4oKSBjb25zdDsKICAgICBTdHJpbmcgc3Ry aW5nSWRlbnRpZmllcigpIGNvbnN0OwogICAgIFN0cmluZyBkaXNwbGF5TmFtZSgpIGNvbnN0OwpA QCAtMTIzLDggKzEyNiw5IEBAIHB1YmxpYzoKICAgICBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9y KiB0cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkgY29uc3Q7CiAKIHByaXZhdGU6Ci0gICAgRGF0YWJh c2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYg ZXhwZWN0ZWRWZXJzaW9uLAotICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUs IHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisgICAgRGF0YWJhc2UoU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLAorICAgICAgICAgICAgIGNv bnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLAor ICAgICAgICAgICAgIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAKICAgICBib29sIG9w ZW5BbmRWZXJpZnlWZXJzaW9uKEV4Y2VwdGlvbkNvZGUmKTsKIApAQCAtMTM5LDcgKzE0Myw3IEBA IHByaXZhdGU6CiAKICAgICBzdGF0aWMgdm9pZCBkZWxpdmVyUGVuZGluZ0NhbGxiYWNrKHZvaWQq KTsKIAotICAgIFJlZlB0cjxEb2N1bWVudD4gbV9kb2N1bWVudDsKKyAgICBSZWZQdHI8U2NyaXB0 RXhlY3V0aW9uQ29udGV4dD4gbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0OwogICAgIFJlZlB0cjxT ZWN1cml0eU9yaWdpbj4gbV9tYWluVGhyZWFkU2VjdXJpdHlPcmlnaW47CiAgICAgUmVmUHRyPFNl Y3VyaXR5T3JpZ2luPiBtX2RhdGFiYXNlVGhyZWFkU2VjdXJpdHlPcmlnaW47CiAgICAgU3RyaW5n IG1fbmFtZTsKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRhc2suaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUYXNrLmgJKHJldmlzaW9uIDUzNTEyKQorKysg V2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGFzay5oCSh3b3JraW5nIGNvcHkpCkBAIC01MCwxNiAr NTAsMTUgQEAgY2xhc3MgVmVyc2lvbkNoYW5nZUNhbGxiYWNrOwogLy8gQ2FuIGJlIHVzZWQgdG8g d2FpdCB1bnRpbCBEYXRhYmFzZVRhc2sgaXMgY29tcGxldGVkLgogLy8gSGFzIHRvIGJlIHBhc3Nl ZCBpbnRvIERhdGFiYXNlVGFzazo6Y3JlYXRlIHRvIGJlIGFzc29jaWF0ZWQgd2l0aCB0aGUgdGFz ay4KIGNsYXNzIERhdGFiYXNlVGFza1N5bmNocm9uaXplciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7 Ci0gICAgZnJpZW5kIGNsYXNzIERhdGFiYXNlVGFzazsKIHB1YmxpYzoKICAgICBEYXRhYmFzZVRh c2tTeW5jaHJvbml6ZXIoKTsKIAogICAgIC8vIENhbGxlZCBmcm9tIG1haW4gdGhyZWFkIHRvIHdh aXQgdW50aWwgdGFzayBpcyBjb21wbGV0ZWQuCiAgICAgdm9pZCB3YWl0Rm9yVGFza0NvbXBsZXRp b24oKTsKIAotcHJpdmF0ZToKICAgICAvLyBDYWxsZWQgYnkgdGhlIHRhc2suCiAgICAgdm9pZCB0 YXNrQ29tcGxldGVkKCk7Citwcml2YXRlOgogCiAgICAgYm9vbCBtX3Rhc2tDb21wbGV0ZWQ7CiAg ICAgTXV0ZXggbV9zeW5jaHJvbm91c011dGV4OwpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFi YXNlVGhyZWFkLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJl YWQuY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVh ZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDYgKzQ0LDcgQEAgRGF0YWJhc2VUaHJlYWQ6OkRh dGFiYXNlVGhyZWFkKCkKICAgICA6IG1fdGhyZWFkSUQoMCkKICAgICAsIG1fdHJhbnNhY3Rpb25D bGllbnQobmV3IFNRTFRyYW5zYWN0aW9uQ2xpZW50KCkpCiAgICAgLCBtX3RyYW5zYWN0aW9uQ29v cmRpbmF0b3IobmV3IFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSkKKyAgICAsIG1fY2xlYW51 cFN5bmMoMCkKIHsKICAgICBtX3NlbGZSZWYgPSB0aGlzOwogfQpAQCAtNTEsNiArNTIsNyBAQCBE YXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQogRGF0YWJhc2VUaHJlYWQ6On5EYXRhYmFz ZVRocmVhZCgpCiB7CiAgICAgLy8gRklYTUU6IEFueSBjbGVhbnVwIHJlcXVpcmVkIGhlcmU/ICBT aW5jZSB0aGUgdGhyZWFkIGRlbGV0ZXMgaXRzZWxmIGFmdGVyIHJ1bm5pbmcgaXRzIGRldGFjaGVk IGNvdXJzZSwgSSBkb24ndCB0aGluayBzby4gIExldHMgYmUgc3VyZS4KKyAgICBBU1NFUlQodGVy bWluYXRpb25SZXF1ZXN0ZWQoKSk7CiB9CiAKIGJvb2wgRGF0YWJhc2VUaHJlYWQ6OnN0YXJ0KCkK QEAgLTY1LDggKzY3LDEwIEBAIGJvb2wgRGF0YWJhc2VUaHJlYWQ6OnN0YXJ0KCkKICAgICByZXR1 cm4gbV90aHJlYWRJRDsKIH0KIAotdm9pZCBEYXRhYmFzZVRocmVhZDo6cmVxdWVzdFRlcm1pbmF0 aW9uKCkKK3ZvaWQgRGF0YWJhc2VUaHJlYWQ6OnJlcXVlc3RUZXJtaW5hdGlvbihEYXRhYmFzZVRh c2tTeW5jaHJvbml6ZXIgKmNsZWFudXBTeW5jKQogeworICAgIEFTU0VSVCghbV9jbGVhbnVwU3lu Yyk7CisgICAgbV9jbGVhbnVwU3luYyA9IGNsZWFudXBTeW5jOwogICAgIExPRyhTdG9yYWdlQVBJ LCAiRGF0YWJhc2VUaHJlYWQgJXAgd2FzIGFza2VkIHRvIHRlcm1pbmF0ZVxuIiwgdGhpcyk7CiAg ICAgbV9xdWV1ZS5raWxsKCk7CiB9CkBAIC0xMTUsOSArMTE5LDE0IEBAIHZvaWQqIERhdGFiYXNl VGhyZWFkOjpkYXRhYmFzZVRocmVhZCgpCiAgICAgLy8gRGV0YWNoIHRoZSB0aHJlYWQgc28gaXRz IHJlc291cmNlcyBhcmUgbm8gbG9uZ2VyIG9mIGFueSBjb25jZXJuIHRvIGFueW9uZSBlbHNlCiAg ICAgZGV0YWNoVGhyZWFkKG1fdGhyZWFkSUQpOwogCisgICAgRGF0YWJhc2VUYXNrU3luY2hyb25p emVyKiBjbGVhbnVwU3luYyA9IG1fY2xlYW51cFN5bmM7CisgICAgCiAgICAgLy8gQ2xlYXIgdGhl IHNlbGYgcmVmcHRyLCBwb3NzaWJseSByZXN1bHRpbmcgaW4gZGVsZXRpb24KICAgICBtX3NlbGZS ZWYgPSAwOwogCisgICAgaWYgKGNsZWFudXBTeW5jKSAvLyBTb21lb25lIHdhbnRlZCB0byBrbm93 IHdoZW4gd2Ugd2VyZSBkb25lIGNsZWFuaW5nIHVwLgorICAgICAgICBjbGVhbnVwU3luYy0+dGFz a0NvbXBsZXRlZCgpOworCiAgICAgcmV0dXJuIDA7CiB9CiAKQEAgLTE2Miw2ICsxNzEsNSBAQCB2 b2lkIERhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUCiAgICAgU2FtZURhdGFiYXNl UHJlZGljYXRlIHByZWRpY2F0ZShkYXRhYmFzZSk7CiAgICAgbV9xdWV1ZS5yZW1vdmVJZihwcmVk aWNhdGUpOwogfQotCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAjZW5kaWYKSW5kZXg6IFdlYkNv cmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFn ZS9EYXRhYmFzZVRocmVhZC5oCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvc3RvcmFnZS9E YXRhYmFzZVRocmVhZC5oCSh3b3JraW5nIGNvcHkpCkBAIC00Myw2ICs0Myw3IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0YWJhc2U7CiBjbGFzcyBEYXRhYmFzZVRhc2s7CitjbGFz cyBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXI7CiBjbGFzcyBEb2N1bWVudDsKIGNsYXNzIFNRTFRy YW5zYWN0aW9uQ2xpZW50OwogY2xhc3MgU1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcjsKQEAgLTUz LDcgKzU0LDcgQEAgcHVibGljOgogICAgIH5EYXRhYmFzZVRocmVhZCgpOwogCiAgICAgYm9vbCBz dGFydCgpOwotICAgIHZvaWQgcmVxdWVzdFRlcm1pbmF0aW9uKCk7CisgICAgdm9pZCByZXF1ZXN0 VGVybWluYXRpb24oRGF0YWJhc2VUYXNrU3luY2hyb25pemVyKiBjbGVhbnVwU3luYyk7CiAgICAg Ym9vbCB0ZXJtaW5hdGlvblJlcXVlc3RlZCgpIGNvbnN0OwogCiAgICAgdm9pZCBzY2hlZHVsZVRh c2soUGFzc093blB0cjxEYXRhYmFzZVRhc2s+KTsKQEAgLTg1LDYgKzg2LDcgQEAgcHJpdmF0ZToK IAogICAgIE93blB0cjxTUUxUcmFuc2FjdGlvbkNsaWVudD4gbV90cmFuc2FjdGlvbkNsaWVudDsK ICAgICBPd25QdHI8U1FMVHJhbnNhY3Rpb25Db29yZGluYXRvcj4gbV90cmFuc2FjdGlvbkNvb3Jk aW5hdG9yOworICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciogbV9jbGVhbnVwU3luYzsKIH07 CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFz ZVRyYWNrZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNr ZXIuY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNr ZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNiwxMCArMzYsMTAgQEAKICNpbmNsdWRlICJEYXRh YmFzZS5oIgogI2luY2x1ZGUgIkRhdGFiYXNlVGhyZWFkLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VU cmFja2VyQ2xpZW50LmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJMb2dnaW5n LmgiCiAjaW5jbHVkZSAiT3JpZ2luUXVvdGFNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgor I2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKICNpbmNsdWRlICJTZWN1cml0eU9y aWdpbi5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luSGFzaC5oIgogI2luY2x1ZGUgIlNRTGl0 ZUZpbGVTeXN0ZW0uaCIKQEAgLTEyMCw3ICsxMjAsNyBAQCB2b2lkIERhdGFiYXNlVHJhY2tlcjo6 b3BlblRyYWNrZXJEYXRhYmFzCiAgICAgfQogfQogCi1ib29sIERhdGFiYXNlVHJhY2tlcjo6Y2Fu RXN0YWJsaXNoRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIG5hbWUs IGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkK K2Jvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFzZShTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlz cGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKIHsKICAgICBBU1NFUlQoY3Vy cmVudFRocmVhZCgpID09IG1fdGhyZWFkKTsKIApAQCAtMTI4LDkgKzEyOCw5IEBAIGJvb2wgRGF0 YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmEKICAgICAvLyBjYW4gcnVuIG9uIHRoZSBk YXRhYmFzZSB0aHJlYWQgbGF0ZXIuCiAgICAgcG9wdWxhdGVPcmlnaW5zKCk7CiAKLSAgICBTZWN1 cml0eU9yaWdpbiogb3JpZ2luID0gZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCk7CisgICAgU2Vj dXJpdHlPcmlnaW4qIG9yaWdpbiA9IGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCk7CiAKLSAgICAv LyBTaW5jZSB3ZSdyZSBpbW1pbmVudGx5IG9wZW5pbmcgYSBkYXRhYmFzZSB3aXRoaW4gdGhpcyBE b2N1bWVudCdzIG9yaWdpbiwgbWFrZSBzdXJlIHRoaXMgb3JpZ2luIGlzIGJlaW5nIHRyYWNrZWQg YnkgdGhlIFF1b3RhVHJhY2tlcgorICAgIC8vIFNpbmNlIHdlJ3JlIGltbWluZW50bHkgb3Blbmlu ZyBhIGRhdGFiYXNlIHdpdGhpbiB0aGlzIGNvbnRleHQncyBvcmlnaW4sIG1ha2Ugc3VyZSB0aGlz IG9yaWdpbiBpcyBiZWluZyB0cmFja2VkIGJ5IHRoZSBRdW90YVRyYWNrZXIKICAgICAvLyBieSBm ZXRjaGluZyBpdCdzIGN1cnJlbnQgdXNhZ2Ugbm93CiAgICAgdW5zaWduZWQgbG9uZyBsb25nIHVz YWdlID0gdXNhZ2VGb3JPcmlnaW4ob3JpZ2luKTsKIApAQCAtMTQ3LDEyICsxNDcsOSBAQCBib29s IERhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhCiAKICAgICAvLyBHaXZlIHRoZSBj aHJvbWUgY2xpZW50IGEgY2hhbmNlIHRvIGluY3JlYXNlIHRoZSBxdW90YS4KICAgICAvLyBUZW1w b3JhcmlseSBtYWtlIHRoZSBkZXRhaWxzIG9mIHRoZSBwcm9wb3NlZCBkYXRhYmFzZSBhdmFpbGFi bGUsIHNvIHRoZSBjbGllbnQgY2FuIGdldCBhdCB0aGVtLgotICAgIFBhZ2UqIHBhZ2UgPSBkb2N1 bWVudC0+cGFnZSgpOwotICAgIGlmICghcGFnZSkKLSAgICAgICAgcmV0dXJuIGZhbHNlOwogICAg IHBhaXI8U2VjdXJpdHlPcmlnaW4qLCBEYXRhYmFzZURldGFpbHM+IGRldGFpbHMob3JpZ2luLCBE YXRhYmFzZURldGFpbHMobmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUsIDApKTsKICAg ICBtX3Byb3Bvc2VkRGF0YWJhc2UgPSAmZGV0YWlsczsKLSAgICBwYWdlLT5jaHJvbWUoKS0+Y2xp ZW50KCktPmV4Y2VlZGVkRGF0YWJhc2VRdW90YShkb2N1bWVudC0+ZnJhbWUoKSwgbmFtZSk7Cisg ICAgY29udGV4dC0+ZGF0YWJhc2VFeGNlZWRlZFF1b3RhKG5hbWUpOwogICAgIG1fcHJvcG9zZWRE YXRhYmFzZSA9IDA7CiAKICAgICAvLyBJZiB0aGUgZGF0YWJhc2Ugd2lsbCBmaXQgbm93LCBhbGxv dyBpdHMgY3JlYXRpb24uCkBAIC0xODYsNyArMTgzLDcgQEAgYm9vbCBEYXRhYmFzZVRyYWNrZXI6 Omhhc0VudHJ5Rm9yRGF0YWJhcwogCiB1bnNpZ25lZCBsb25nIGxvbmcgRGF0YWJhc2VUcmFja2Vy OjpnZXRNYXhTaXplRm9yRGF0YWJhc2UoY29uc3QgRGF0YWJhc2UqIGRhdGFiYXNlKQogewotICAg IEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPmRvY3VtZW50KCktPmRhdGFiYXNl VGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0g ZGF0YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0 VGhyZWFkSUQoKSk7CiAgICAgLy8gVGhlIG1heGltdW0gc2l6ZSBmb3IgYSBkYXRhYmFzZSBpcyB0 aGUgZnVsbCBxdW90YSBmb3IgaXRzIG9yaWdpbiwgbWludXMgdGhlIGN1cnJlbnQgdXNhZ2Ugd2l0 aGluIHRoZSBvcmlnaW4sCiAgICAgLy8gcGx1cyB0aGUgY3VycmVudCB1c2FnZSBvZiB0aGUgZ2l2 ZW4gZGF0YWJhc2UKICAgICBMb2NrZXI8T3JpZ2luUXVvdGFNYW5hZ2VyPiBsb2NrZXIob3JpZ2lu UXVvdGFNYW5hZ2VyKCkpOwpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRyYWNrZXIuaAkocmV2aXNp b24gNTM1MTIpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUcmFja2VyLmgJKHdvcmtpbmcg Y29weSkKQEAgLTQ1LDcgKzQ1LDcgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0 YWJhc2U7Ci1jbGFzcyBEb2N1bWVudDsKK2NsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiBj bGFzcyBTZWN1cml0eU9yaWdpbjsKIAogI2lmICFQTEFURk9STShDSFJPTUlVTSkKQEAgLTU5LDgg KzU5LDExIEBAIHN0cnVjdCBTZWN1cml0eU9yaWdpblRyYWl0czsKIGNsYXNzIERhdGFiYXNlVHJh Y2tlciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6CiAgICAgc3RhdGljIERhdGFiYXNl VHJhY2tlciYgdHJhY2tlcigpOworICAgIC8vIEZJWE1FOiBEdWUgdG8gd29ya2VycyBoYXZpbmcg bXVsdGlwbGUgdGhyZWFkcyBpbiBhIHNpbmdsZSBwcm9jZXNzIHNoYXJpbmcKKyAgICAvLyBhIERh dGFiYXNlVHJhY2tlciwgdGhpcyBzaW5nbGV0b24gd2lsbCBoYXZlIHRvIGJlIHN5bmNocm9uaXpl ZCBvciBtb3ZlZAorICAgIC8vIHRvIFRMUy4KIAotICAgIGJvb2wgY2FuRXN0YWJsaXNoRGF0YWJh c2UoRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5h bWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisgICAgYm9vbCBjYW5Fc3RhYmxpc2hE YXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOwogICAg IHZvaWQgc2V0RGF0YWJhc2VEZXRhaWxzKFNlY3VyaXR5T3JpZ2luKiwgY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNp emUpOwogICAgIFN0cmluZyBmdWxsUGF0aEZvckRhdGFiYXNlKFNlY3VyaXR5T3JpZ2luKiwgY29u c3QgU3RyaW5nJiBuYW1lLCBib29sIGNyZWF0ZUlmRG9lc05vdEV4aXN0ID0gdHJ1ZSk7CiAKSW5k ZXg6IFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9zdG9yYWdlL1NRTFRyYW5zYWN0aW9uLmNwcAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJD b3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNSwxMSAr MzUsMTEgQEAKICNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIkRhdGFiYXNlQXV0aG9y aXplci5oIgogI2luY2x1ZGUgIkRhdGFiYXNlRGV0YWlscy5oIgotI2luY2x1ZGUgIkRvY3VtZW50 LmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgogI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNp bmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJT Y3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRl ICJTUUxFcnJvci5oIgogI2luY2x1ZGUgIlNRTGl0ZVRyYW5zYWN0aW9uLmgiCkBAIC05NCw4ICs5 NCw3IEBAIHZvaWQgU1FMVHJhbnNhY3Rpb246OmV4ZWN1dGVTUUwoY29uc3QgU3QKIAogICAgIGJv b2wgcmVhZE9ubHlNb2RlID0gbV9yZWFkT25seTsKICAgICBpZiAoIXJlYWRPbmx5TW9kZSkgewot ICAgICAgICBQYWdlKiBwYWdlID0gbV9kYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cGFnZSgpOwotICAg ICAgICBpZiAoIXBhZ2UgfHwgcGFnZS0+c2V0dGluZ3MoKS0+cHJpdmF0ZUJyb3dzaW5nRW5hYmxl ZCgpKQorICAgICAgICBpZiAobV9kYXRhYmFzZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5p c0RhdGFiYXNlUmVhZE9ubHkoKSkKICAgICAgICAgICAgIHJlYWRPbmx5TW9kZSA9IHRydWU7CiAg ICAgfQogCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb25DbGllbnQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlvbkNsaWVudC5jcHAJKHJl dmlzaW9uIDUzNTEyKQorKysgV2ViQ29yZS9zdG9yYWdlL1NRTFRyYW5zYWN0aW9uQ2xpZW50LmNw cAkod29ya2luZyBjb3B5KQpAQCAtNDcsNyArNDcsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK IHZvaWQgU1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0aW9uKFNRTFRyYW5z YWN0aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRy YW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRU aHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5k YXRhYmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdl dFRocmVhZElEKCkpOwogICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9IHRyYW5zYWN0aW9uLT5kYXRh YmFzZSgpOwogICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnNjaGVkdWxlTm90aWZ5RGF0 YWJhc2VDaGFuZ2VkKAogICAgICAgICBkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4oKSwgZGF0YWJh c2UtPnN0cmluZ0lkZW50aWZpZXIoKSk7CkBAIC01NSw3ICs1NSw3IEBAIHZvaWQgU1FMVHJhbnNh Y3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW4KIAogdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6 ZGlkRXhlY3V0ZVN0YXRlbWVudChTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAg QVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1l bnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJl bnRUaHJlYWQoKSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhlY3V0aW9uQ29u dGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKICAgICBPcmlnaW5RdW90 YU1hbmFnZXImIG1hbmFnZXIoRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkub3JpZ2luUXVvdGFN YW5hZ2VyKCkpOwogICAgIExvY2tlcjxPcmlnaW5RdW90YU1hbmFnZXI+IGxvY2tlcihtYW5hZ2Vy KTsKICAgICBtYW5hZ2VyLm1hcmtEYXRhYmFzZSh0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKSk7CkBA IC02MywxMyArNjMsMTEgQEAgdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkRXhlY3V0ZVN0 YQogCiBib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YShTUUxUcmFuc2Fj dGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBB U1NFUlQodHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+ aXNDb250ZXh0VGhyZWFkKCkpOwogICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9IHRyYW5zYWN0aW9u LT5kYXRhYmFzZSgpOwotICAgIFBhZ2UqIHBhZ2UgPSBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+cGFn ZSgpOwotICAgIEFTU0VSVChwYWdlKTsKIAogICAgIHVuc2lnbmVkIGxvbmcgbG9uZyBjdXJyZW50 UXVvdGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFz ZS0+c2VjdXJpdHlPcmlnaW4oKSk7Ci0gICAgcGFnZS0+Y2hyb21lKCktPmNsaWVudCgpLT5leGNl ZWRlZERhdGFiYXNlUXVvdGEoZGF0YWJhc2UtPmRvY3VtZW50KCktPmZyYW1lKCksIGRhdGFiYXNl LT5zdHJpbmdJZGVudGlmaWVyKCkpOworICAgIGRhdGFiYXNlLT5zY3JpcHRFeGVjdXRpb25Db250 ZXh0KCktPmRhdGFiYXNlRXhjZWVkZWRRdW90YShkYXRhYmFzZS0+c3RyaW5nSWRlbnRpZmllcigp KTsKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgbmV3UXVvdGEgPSBEYXRhYmFzZVRyYWNrZXI6OnRy YWNrZXIoKS5xdW90YUZvck9yaWdpbihkYXRhYmFzZS0+c2VjdXJpdHlPcmlnaW4oKSk7CiAgICAg cmV0dXJuIChuZXdRdW90YSA+IGN1cnJlbnRRdW90YSk7CiB9CkluZGV4OiBXZWJDb3JlL3N0b3Jh Z2UvY2hyb21pdW0vRGF0YWJhc2VUcmFja2VyQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFzZVRyYWNrZXJDaHJvbWl1bS5jcHAJKHJldmlz aW9uIDUzNTEyKQorKysgV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL0RhdGFiYXNlVHJhY2tlckNo cm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzUsOCArMzUsOCBAQAogI2luY2x1ZGUgIkRh dGFiYXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VPYnNlcnZlci5oIgogI2luY2x1ZGUgIkRhdGFi YXNlVGhyZWFkLmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJRdW90YVRyYWNr ZXIuaCIKKyNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU2Vj dXJpdHlPcmlnaW4uaCIKICNpbmNsdWRlICJTUUxpdGVGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSA8 d3RmL0hhc2hTZXQuaD4KQEAgLTU2LDcgKzU2LDcgQEAgRGF0YWJhc2VUcmFja2VyOjpEYXRhYmFz ZVRyYWNrZXIoKQogICAgIFNRTGl0ZUZpbGVTeXN0ZW06OnJlZ2lzdGVyU1FMaXRlVkZTKCk7CiB9 CiAKLWJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFzZShEb2N1bWVudCos IGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYsIHVuc2lnbmVkIGxvbmcpCitib29sIERhdGFi YXNlVHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCos IGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYsIHVuc2lnbmVkIGxvbmcpCiB7CiAgICAgLy8g SW4gQ2hyb21pdW0sIGEgZGF0YWJhc2UgY2FuIGFsd2F5cyBiZSBlc3RhYmxpc2hlZCAoZXZlbiB0 aG91Z2ggd2UgbWlnaHQgbm90CiAgICAgLy8gYmUgYWJsZSB0byB3cml0ZSBhbnl0aGluZyB0byBp dCBpZiB0aGUgcXVvdGEgZm9yIHRoaXMgb3JpZ2luIHdhcyBleGNlZWRlZCkKQEAgLTc1LDIxICs3 NSwzNSBAQCBTdHJpbmcgRGF0YWJhc2VUcmFja2VyOjpmdWxsUGF0aEZvckRhdGFiCiAKIHZvaWQg RGF0YWJhc2VUcmFja2VyOjphZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRhdGFiYXNlKQogewot ICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJUKGRhdGFiYXNlLT5zY3JpcHRF eGVjdXRpb25Db250ZXh0KCktPmlzQ29udGV4dFRocmVhZCgpKTsKICAgICBEYXRhYmFzZU9ic2Vy dmVyOjpkYXRhYmFzZU9wZW5lZChkYXRhYmFzZSk7CiB9Ci1zdGF0aWMgdm9pZCByZW1vdmVPcGVu RGF0YWJhc2VPbk1haW5UaHJlYWQodm9pZCogY29udGV4dCkKLXsKLSAgICBEYXRhYmFzZSogZGF0 YWJhc2UgPSBzdGF0aWNfY2FzdDxEYXRhYmFzZSo+KGNvbnRleHQpOwotICAgIERhdGFiYXNlVHJh Y2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZSk7Ci0gICAgZGF0YWJh c2UtPmRlcmVmKCk7Ci19CisKK2NsYXNzIFRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrIDog cHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRp YyBQYXNzT3duUHRyPFRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrPiBjcmVhdGUoUGFzc1Jl ZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2UpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IFRyYWNr ZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrKGRhdGFiYXNlKTsKKyAgICB9CisKKyAgICB2aXJ0dWFs IHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCkKKyAgICB7 CisgICAgICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRhYmFzZSht X2RhdGFiYXNlLmdldCgpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgVHJhY2tlclJlbW92ZU9w ZW5EYXRhYmFzZVRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2UpCisgICAgICAgIDog bV9kYXRhYmFzZShkYXRhYmFzZSkKKyAgICB7CisgICAgfQorCisgICAgUmVmUHRyPERhdGFiYXNl PiBtX2RhdGFiYXNlOworfTsKIAogdm9pZCBEYXRhYmFzZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRh YmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCiB7Ci0gICAgaWYgKCFpc01haW5UaHJlYWQoKSkgewot ICAgICAgICBkYXRhYmFzZS0+cmVmKCk7Ci0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQocmVtb3Zl T3BlbkRhdGFiYXNlT25NYWluVGhyZWFkLCBkYXRhYmFzZSk7CisgICAgaWYgKCFkYXRhYmFzZS0+ c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRUaHJlYWQoKSkgeworICAgICAgICBk YXRhYmFzZS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5wb3N0VGFzayhUcmFja2VyUmVtb3Zl T3BlbkRhdGFiYXNlVGFzazo6Y3JlYXRlKGRhdGFiYXNlKSk7CiAgICAgICAgIHJldHVybjsKICAg ICB9CiAKQEAgLTk4LDcgKzExMiw3IEBAIHZvaWQgRGF0YWJhc2VUcmFja2VyOjpyZW1vdmVPcGVu RGF0YWJhc2UKIAogdW5zaWduZWQgbG9uZyBsb25nIERhdGFiYXNlVHJhY2tlcjo6Z2V0TWF4U2l6 ZUZvckRhdGFiYXNlKGNvbnN0IERhdGFiYXNlKiBkYXRhYmFzZSkKIHsKLSAgICBBU1NFUlQoY3Vy cmVudFRocmVhZCgpID09IGRhdGFiYXNlLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5n ZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IGRhdGFiYXNlLT5z Y3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkp OwogICAgIHVuc2lnbmVkIGxvbmcgbG9uZyBzcGFjZUF2YWlsYWJsZSA9IDA7CiAgICAgdW5zaWdu ZWQgbG9uZyBsb25nIGRhdGFiYXNlU2l6ZSA9IDA7CiAgICAgUXVvdGFUcmFja2VyOjppbnN0YW5j ZSgpLmdldERhdGFiYXNlU2l6ZUFuZFNwYWNlQXZhaWxhYmxlVG9PcmlnaW4oCkluZGV4OiBXZWJD b3JlL3N0b3JhZ2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRDaHJvbWl1bS5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0aW9uQ2xpZW50 Q2hyb21pdW0uY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1 bS9TUUxUcmFuc2FjdGlvbkNsaWVudENocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzgs MjAgKzM4LDM0IEBACiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb24uaCIKICNpbmNsdWRlIDx3dGYv TWFpblRocmVhZC5oPgogCi1zdGF0aWMgdm9pZCBub3RpZnlEYXRhYmFzZUNoYW5nZWQodm9pZCog Y29udGV4dCkgewotICAgIFdlYkNvcmU6OkRhdGFiYXNlKiBkYXRhYmFzZSA9IHN0YXRpY19jYXN0 PFdlYkNvcmU6OkRhdGFiYXNlKj4oY29udGV4dCk7Ci0gICAgV2ViQ29yZTo6RGF0YWJhc2VPYnNl cnZlcjo6ZGF0YWJhc2VNb2RpZmllZChkYXRhYmFzZSk7Ci0gICAgZGF0YWJhc2UtPmRlcmVmKCk7 ICAvLyByZWYoKSdkIGluIGRpZENvbW1pdFRyYW5zYWN0aW9uKCkKLX0KLQogbmFtZXNwYWNlIFdl YkNvcmUgewogCitjbGFzcyBOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrIDogcHVibGljIFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRy PE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2s+IGNyZWF0ZShEYXRhYmFzZSAqZGF0YWJhc2UpCisg ICAgeworICAgICAgICByZXR1cm4gbmV3IE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2soZGF0YWJh c2UpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRp b25Db250ZXh0KikKKyAgICB7CisgICAgICAgIFdlYkNvcmU6OkRhdGFiYXNlT2JzZXJ2ZXI6OmRh dGFiYXNlTW9kaWZpZWQobV9kYXRhYmFzZS5nZXQoKSk7CisgICAgfQorCitwcml2YXRlOgorICAg IE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2soUGFzc1JlZlB0cjxEYXRhYmFzZT4gZGF0YWJhc2Up CisgICAgICAgIDogbV9kYXRhYmFzZShkYXRhYmFzZSkKKyAgICB7CisgICAgfQorCisgICAgUmVm UHRyPERhdGFiYXNlPiBtX2RhdGFiYXNlOworfTsKKwogdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVu dDo6ZGlkQ29tbWl0VHJhbnNhY3Rpb24oU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewot ICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPmRv Y3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChj dXJyZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnNjcmlwdEV4ZWN1dGlv bkNvbnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgaWYgKCF0 cmFuc2FjdGlvbi0+aXNSZWFkT25seSgpKSB7Ci0gICAgICAgIHRyYW5zYWN0aW9uLT5kYXRhYmFz ZSgpLT5yZWYoKTsgIC8vIGRlcmVmKCknZCBpbiBub3RpZnlEYXRhYmFzZUNoYW5nZWQoKQotICAg ICAgICBjYWxsT25NYWluVGhyZWFkKG5vdGlmeURhdGFiYXNlQ2hhbmdlZCwgdHJhbnNhY3Rpb24t PmRhdGFiYXNlKCkpOworICAgICAgICB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhl Y3V0aW9uQ29udGV4dCgpLT5wb3N0VGFzayhOb3RpZnlEYXRhYmFzZUNoYW5nZWRUYXNrOjpjcmVh dGUodHJhbnNhY3Rpb24tPmRhdGFiYXNlKCkpKTsKICAgICB9CiB9CiAKQEAgLTU5LDE0ICs3Mywx NCBAQCB2b2lkIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhCiB7CiAgICAgLy8g VGhpcyBtZXRob2QgaXMgY2FsbGVkIGFmdGVyIGV4ZWN1dGluZyBldmVyeSBzdGF0ZW1lbnQgdGhh dCBjaGFuZ2VzIHRoZSBEQi4KICAgICAvLyBDaHJvbWl1bSBkb2Vzbid0IG5lZWQgdG8gZG8gYW55 dGhpbmcgYXQgdGhhdCBwb2ludC4KLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5z YWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJl YWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9uLT5kYXRh YmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRo cmVhZElEKCkpOwogfQogCi1ib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90 YShTUUxUcmFuc2FjdGlvbiopCitib29sIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRR dW90YShTUUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7CiAgICAgLy8gQ2hyb21pdW0gZG9l cyBub3QgYWxsb3cgdXNlcnMgdG8gbWFudWFsbHkgY2hhbmdlIHRoZSBxdW90YSBmb3IgYW4gb3Jp Z2luIChmb3Igbm93LCBhdCBsZWFzdCkuCiAgICAgLy8gRG9uJ3QgZG8gYW55dGhpbmcuCi0gICAg QVNTRVJUKGlzTWFpblRocmVhZCgpKTsKKyAgICBBU1NFUlQodHJhbnNhY3Rpb24tPmRhdGFiYXNl KCktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNDb250ZXh0VGhyZWFkKCkpOwogICAgIHJl dHVybiBmYWxzZTsKIH0KIApJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcAkocmV2aXNp b24gNTM1MTIpCisrKyBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCiAKICNp bmNsdWRlICJBY3RpdmVET01PYmplY3QuaCIKKyNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1 ZGUgIkRPTVRpbWVyLmgiCiAjaW5jbHVkZSAiRE9NV2luZG93LmgiCiAjaW5jbHVkZSAiRXZlbnQu aCIKQEAgLTI1NCw2ICsyNTUsMjcgQEAgTm90aWZpY2F0aW9uQ2VudGVyKiBXb3JrZXJDb250ZXh0 Ojp3ZWJraQogfQogI2VuZGlmCiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCitQYXNzUmVmUHRyPERh dGFiYXNlPiBXb3JrZXJDb250ZXh0OjpvcGVuRGF0YWJhc2UoY29uc3QgU3RyaW5nJiBuYW1lLCBj b25zdCBTdHJpbmcmIHZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVk IGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgaWYgKCFzZWN1 cml0eU9yaWdpbigpLT5jYW5BY2Nlc3NEYXRhYmFzZSgpKSB7CisgICAgICAgIGVjID0gU0VDVVJJ VFlfRVJSOworICAgICAgICByZXR1cm4gMDsKKyAgICB9CisKKyAgICBBU1NFUlQoRGF0YWJhc2U6 OmlzQXZhaWxhYmxlKCkpOworICAgIGlmICghRGF0YWJhc2U6OmlzQXZhaWxhYmxlKCkpCisgICAg ICAgIHJldHVybiAwOworCisgICAgcmV0dXJuIERhdGFiYXNlOjpvcGVuRGF0YWJhc2UodGhpcywg bmFtZSwgdmVyc2lvbiwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUsIGVjKTsKK30KKyNlbmRp ZgorCitib29sIFdvcmtlckNvbnRleHQ6OmlzQ29udGV4dFRocmVhZCgpIGNvbnN0Cit7CisgICAg cmV0dXJuIGN1cnJlbnRUaHJlYWQoKSA9PSB0aHJlYWQoKS0+dGhyZWFkSUQoKTsKK30KKwogRXZl bnRUYXJnZXREYXRhKiBXb3JrZXJDb250ZXh0OjpldmVudFRhcmdldERhdGEoKQogewogICAgIHJl dHVybiAmbV9ldmVudFRhcmdldERhdGE7CkluZGV4OiBXZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29u dGV4dC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgJKHJl dmlzaW9uIDUzNTEyKQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAkod29ya2lu ZyBjb3B5KQpAQCAtMzAsMTEgKzMwLDEzIEBACiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKICNpbmNs dWRlICJBdG9taWNTdHJpbmdIYXNoLmgiCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKICNpbmNsdWRl ICJFdmVudExpc3RlbmVyLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkV2 ZW50VGFyZ2V0LmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgogI2luY2x1 ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKKyNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5o PgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgog I2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CkBAIC00Miw2ICs0NCw3IEBACiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAorICAgIGNsYXNzIERhdGFiYXNlOwogICAgIGNsYXNzIE5vdGlmaWNhdGlv bkNlbnRlcjsKICAgICBjbGFzcyBTY2hlZHVsZWRBY3Rpb247CiAgICAgY2xhc3MgV29ya2VyTG9j YXRpb247CkBAIC02NSw5ICs2OCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmly dHVhbCBTdHJpbmcgdXNlckFnZW50KGNvbnN0IEtVUkwmKSBjb25zdDsKIAogICAgICAgICBXb3Jr ZXJTY3JpcHRDb250cm9sbGVyKiBzY3JpcHQoKSB7IHJldHVybiBtX3NjcmlwdC5nZXQoKTsgfQot ICAgICAgICB2b2lkIGNsZWFyU2NyaXB0KCkgeyByZXR1cm4gbV9zY3JpcHQuY2xlYXIoKTsgfQor ICAgICAgICB2b2lkIGNsZWFyU2NyaXB0KCkgeyBtX3NjcmlwdC5jbGVhcigpOyB9CiAKLSAgICAg ICAgV29ya2VyVGhyZWFkKiB0aHJlYWQoKSB7IHJldHVybiBtX3RocmVhZDsgfQorICAgICAgICBX b3JrZXJUaHJlYWQqIHRocmVhZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGhyZWFkOyB9CiAKICAgICAg ICAgYm9vbCBoYXNQZW5kaW5nQWN0aXZpdHkoKSBjb25zdDsKIApAQCAtMTAxLDYgKzEwNCwxNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIE5vdGlmaWNhdGlvbkNlbnRlciogd2Via2l0 Tm90aWZpY2F0aW9ucygpIGNvbnN0OwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisg ICAgICAgIC8vIEhUTUwgNSBjbGllbnQtc2lkZSBkYXRhYmFzZQorICAgICAgICBQYXNzUmVmUHRy PERhdGFiYXNlPiBvcGVuRGF0YWJhc2UoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcm IHZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1h dGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYpOworICAgICAgICAvLyBOb3QgaW1wbGVtZW50ZWQgeWV0 LgorICAgICAgICB2aXJ0dWFsIGJvb2wgaXNEYXRhYmFzZVJlYWRPbmx5KCkgY29uc3QgeyByZXR1 cm4gZmFsc2U7IH0KKyAgICAgICAgLy8gTm90IGltcGxlbWVudGVkIHlldC4KKyAgICAgICAgdmly dHVhbCB2b2lkIGRhdGFiYXNlRXhjZWVkZWRRdW90YShjb25zdCBTdHJpbmcmKSB7IH0KKyNlbmRp ZgorICAgICAgICB2aXJ0dWFsIGJvb2wgaXNDb250ZXh0VGhyZWFkKCkgY29uc3Q7CisKKwogICAg ICAgICAvLyBUaGVzZSBtZXRob2RzIGFyZSB1c2VkIGZvciBHQyBtYXJraW5nLiBTZWUgSlNXb3Jr ZXJDb250ZXh0OjptYXJrQ2hpbGRyZW4oTWFya1N0YWNrJikgaW4KICAgICAgICAgLy8gSlNXb3Jr ZXJDb250ZXh0Q3VzdG9tLmNwcC4KICAgICAgICAgV29ya2VyTmF2aWdhdG9yKiBvcHRpb25hbE5h dmlnYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fbmF2aWdhdG9yLmdldCgpOyB9CkluZGV4OiBXZWJD b3JlL3dvcmtlcnMvV29ya2VyUnVuTG9vcC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93b3Jr ZXJzL1dvcmtlclJ1bkxvb3AuY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvd29ya2Vy cy9Xb3JrZXJSdW5Mb29wLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTUyLDkgKzE1Miw3IEBAIE1l c3NhZ2VRdWV1ZVdhaXRSZXN1bHQgV29ya2VyUnVuTG9vcDo6cnUKICAgICBNZXNzYWdlUXVldWVX YWl0UmVzdWx0IHJlc3VsdDsKICAgICBPd25QdHI8V29ya2VyUnVuTG9vcDo6VGFzaz4gdGFzayA9 IG1fbWVzc2FnZVF1ZXVlLndhaXRGb3JNZXNzYWdlRmlsdGVyZWRXaXRoVGltZW91dChyZXN1bHQs IHByZWRpY2F0ZSwgYWJzb2x1dGVUaW1lKTsKIAotICAgIC8vIElmIHRoZSBjb250ZXh0IGlzIGNs b3NpbmcsIGRvbid0IGRpc3BhdGNoIGFueSBmdXJ0aGVyIHRhc2tzIChwZXIgc2VjdGlvbiA0LjEu MSBvZiB0aGUgV2ViIFdvcmtlcnMgc3BlYykuCi0gICAgaWYgKGNvbnRleHQtPmlzQ2xvc2luZygp KQotICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIC8vIElmIHRoZSBjb250ZXh0IGlzIGNsb3Np bmcsIGRvbid0IGV4ZWN1dGUgYW55IGZ1cnRoZXIgSmF2YVNjcmlwdCB0YXNrcyAocGVyIHNlY3Rp b24gNC4xLjEgb2YgdGhlIFdlYiBXb3JrZXJzIHNwZWMpLiAgSG93ZXZlciwgdGhlcmUgbWF5IGJl IGltcGxlbWVudGF0aW9uIGNsZWFudXAgdGFza3MgaW4gdGhlIHF1ZXVlLCBzbyBrZWVwIHJ1bm5p bmcgdGhyb3VnaCBpdC4KIAogICAgIHN3aXRjaCAocmVzdWx0KSB7CiAgICAgY2FzZSBNZXNzYWdl UXVldWVUZXJtaW5hdGVkOgpAQCAtMTY1LDcgKzE2Myw4IEBAIE1lc3NhZ2VRdWV1ZVdhaXRSZXN1 bHQgV29ya2VyUnVuTG9vcDo6cnUKICAgICAgICAgYnJlYWs7CiAKICAgICBjYXNlIE1lc3NhZ2VR dWV1ZVRpbWVvdXQ6Ci0gICAgICAgIG1fc2hhcmVkVGltZXItPmZpcmUoKTsKKyAgICAgICAgaWYg KCFjb250ZXh0LT5pc0Nsb3NpbmcoKSkKKyAgICAgICAgICAgIG1fc2hhcmVkVGltZXItPmZpcmUo KTsKICAgICAgICAgYnJlYWs7CiAgICAgfQogCkBAIC0xOTQsNyArMTkzLDkgQEAgUGFzc093blB0 cjxXb3JrZXJSdW5Mb29wOjpUYXNrPiBXb3JrZXJSdQogCiB2b2lkIFdvcmtlclJ1bkxvb3A6OlRh c2s6OnBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCiB7Ci0gICAg bV90YXNrLT5wZXJmb3JtVGFzayhjb250ZXh0KTsKKyAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJD b250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCAqPihjb250ZXh0KTsKKyAgICBpZiAo IXdvcmtlckNvbnRleHQtPmlzQ2xvc2luZygpIHx8IG1fdGFzay0+aXNDbGVhbnVwVGFzaygpKQor ICAgICAgICBtX3Rhc2stPnBlcmZvcm1UYXNrKGNvbnRleHQpOwogfQogCiBXb3JrZXJSdW5Mb29w OjpUYXNrOjpUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFz aywgY29uc3QgU3RyaW5nJiBtb2RlKQpJbmRleDogV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVh ZC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAJKHJl dmlzaW9uIDUzNTEyKQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlclRocmVhZC5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTMwLDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgog CisjaW5jbHVkZSAiRGF0YWJhc2VUYXNrLmgiCiAjaW5jbHVkZSAiRGVkaWNhdGVkV29ya2VyQ29u dGV4dC5oIgogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgpA QCAtMTM1LDkgKzEzNiw4IEBAIHZvaWQqIFdvcmtlclRocmVhZDo6d29ya2VyVGhyZWFkKCkKIAog ICAgIFRocmVhZElkZW50aWZpZXIgdGhyZWFkSUQgPSBtX3RocmVhZElEOwogCi0gICAgbV93b3Jr ZXJDb250ZXh0LT5zdG9wQWN0aXZlRE9NT2JqZWN0cygpOwotICAgIG1fd29ya2VyQ29udGV4dC0+ Y2xlYXJTY3JpcHQoKTsKICAgICBBU1NFUlQobV93b3JrZXJDb250ZXh0LT5oYXNPbmVSZWYoKSk7 CisKICAgICAvLyBUaGUgYmVsb3cgYXNzaWdubWVudCB3aWxsIGRlc3Ryb3kgdGhlIGNvbnRleHQs IHdoaWNoIHdpbGwgaW4gdHVybiBub3RpZnkgbWVzc2FnaW5nIHByb3h5LgogICAgIC8vIFdlIGNh bm5vdCBsZXQgYW55IG9iamVjdHMgc3Vydml2ZSBwYXN0IHRocmVhZCBleGl0LCBiZWNhdXNlIG5v IG90aGVyIHRocmVhZCB3aWxsIHJ1biBHQyBvciBvdGhlcndpc2UgZGVzdHJveSB0aGVtLgogICAg IG1fd29ya2VyQ29udGV4dCA9IDA7CkBAIC0xNTQsMTcgKzE1NCw3MCBAQCB2b2lkIFdvcmtlclRo cmVhZDo6cnVuRXZlbnRMb29wKCkKICAgICBtX3J1bkxvb3AucnVuKG1fd29ya2VyQ29udGV4dC5n ZXQoKSk7CiB9CiAKK2NsYXNzIFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzayA6IHB1Ymxp YyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFz c093blB0cjxXb3JrZXJUaHJlYWRTaHV0ZG93bkZpbmlzaFRhc2s+IGNyZWF0ZSgpCisgICAgewor ICAgICAgICByZXR1cm4gbmV3IFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzaygpOworICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0 ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAgQVNTRVJUKGNvbnRleHQtPmlzV29ya2VyQ29udGV4 dCgpKTsKKyAgICAgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IHN0YXRpY19jYXN0 PFdvcmtlckNvbnRleHQqPihjb250ZXh0KTsKKyAgICAgICAgd29ya2VyQ29udGV4dC0+dGhyZWFk KCktPnJ1bkxvb3AoKS50ZXJtaW5hdGUoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXND bGVhbnVwVGFzaygpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KK307CisKK2NsYXNzIFdvcmtlclRo cmVhZFNodXRkb3duU3RhcnRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRh c2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPFdvcmtlclRocmVhZFNodXRkb3du U3RhcnRUYXNrPiBjcmVhdGUoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5ldyBXb3JrZXJUaHJl YWRTaHV0ZG93blN0YXJ0VGFzaygpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3Jt VGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0ICpjb250ZXh0KQorICAgIHsKKyAgICAgICAgQVNT RVJUKGNvbnRleHQtPmlzV29ya2VyQ29udGV4dCgpKTsKKyAgICAgICAgV29ya2VyQ29udGV4dCog d29ya2VyQ29udGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQqPihjb250ZXh0KTsKKwor ICAgICAgICAvLyBXZSBjdXJyZW50bHkgaWdub3JlIGFueSBEYXRhYmFzZVBvbGljeSB1c2VkIGZv ciB0aGUgZG9jdW1lbnQncworICAgICAgICAvLyBkYXRhYmFzZXM7IGlmIGl0J3MgYWN0dWFsbHkg dXNlZCBhbnl3aGVyZSwgdGhpcyBzaG91bGQgYmUgcmV2aXNpdGVkLgorICAgICAgICBEYXRhYmFz ZVRhc2tTeW5jaHJvbml6ZXIgY2xlYW51cFN5bmM7CisgICAgICAgIHdvcmtlckNvbnRleHQtPnN0 b3BEYXRhYmFzZXMoJmNsZWFudXBTeW5jKTsKKworICAgICAgICB3b3JrZXJDb250ZXh0LT5zdG9w QWN0aXZlRE9NT2JqZWN0cygpOworICAgICAgICB3b3JrZXJDb250ZXh0LT5jbGVhclNjcmlwdCgp OworCisgICAgICAgIC8vIFdlIHdhaXQgZm9yIHRoZSBkYXRhYmFzZSB0aHJlYWQgdG8gY2xlYW4g dXAgYWxsIGl0cyBzdHVmZiBzbyB0aGF0IHdlCisgICAgICAgIC8vIGNhbiBkbyBtb3JlIHN0cmlu Z2VudCBsZWFrIGNoZWNrcyBhcyB3ZSBleGl0LgorICAgICAgICBjbGVhbnVwU3luYy53YWl0Rm9y VGFza0NvbXBsZXRpb24oKTsKKworICAgICAgICAvLyBTdGljayBhIHNodXRkb3duIGNvbW1hbmQg YXQgdGhlIGVuZCBvZiB0aGUgcXVldWUsIHNvIHRoYXQgd2UgZGVhbAorICAgICAgICAvLyB3aXRo IGFsbCB0aGUgY2xlYW51cCB0YXNrcyB0aGUgZGF0YWJhc2VzIHBvc3QgZmlyc3QuCisgICAgICAg IHdvcmtlckNvbnRleHQtPnBvc3RUYXNrKFdvcmtlclRocmVhZFNodXRkb3duRmluaXNoVGFzazo6 Y3JlYXRlKCkpOworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29u c3QgeyByZXR1cm4gdHJ1ZTsgfQorfTsKKwogdm9pZCBXb3JrZXJUaHJlYWQ6OnN0b3AoKQogewog ICAgIC8vIE11dGV4IHByb3RlY3Rpb24gaXMgbmVjZXNzYXJ5IGJlY2F1c2Ugc3RvcCgpIGNhbiBi ZSBjYWxsZWQgYmVmb3JlIHRoZSBjb250ZXh0IGlzIGZ1bGx5IGNyZWF0ZWQuCiAgICAgTXV0ZXhM b2NrZXIgbG9jayhtX3RocmVhZENyZWF0aW9uTXV0ZXgpOwogCiAgICAgLy8gRW5zdXJlIHRoYXQg dGFza3MgYXJlIGJlaW5nIGhhbmRsZWQgYnkgdGhyZWFkIGV2ZW50IGxvb3AuIElmIHNjcmlwdCBl eGVjdXRpb24gd2VyZW4ndCBmb3JiaWRkZW4sIGEgd2hpbGUoMSkgbG9vcCBpbiBKUyBjb3VsZCBr ZWVwIHRoZSB0aHJlYWQgYWxpdmUgZm9yZXZlci4KLSAgICBpZiAobV93b3JrZXJDb250ZXh0KQor ICAgIGlmIChtX3dvcmtlckNvbnRleHQpIHsKICAgICAgICAgbV93b3JrZXJDb250ZXh0LT5zY3Jp cHQoKS0+Zm9yYmlkRXhlY3V0aW9uKCk7CiAKICAgICAvLyBGSVhNRTogUnVkZWx5IGtpbGxpbmcg dGhlIHRocmVhZCB3b24ndCB3b3JrIHdoZW4gd2UgYWxsb3cgbmVzdGVkIHdvcmtlcnMsIGJlY2F1 c2UgdGhleSB3aWxsIHRyeSB0byBwb3N0IG5vdGlmaWNhdGlvbnMgb2YgdGhlaXIgZGVzdHJ1Y3Rp b24uCi0gICAgbV9ydW5Mb29wLnRlcm1pbmF0ZSgpOworICAgIC8vIFRoaXMgY2FuIGxpa2VseSB1 c2UgdGhlIHNhbWUgbWVjaGFuaXNtIGFzIHVzZWQgZm9yIGRhdGFiYXNlcyBhYm92ZS4KKworICAg ICAgICBtX3J1bkxvb3AucG9zdFRhc2soV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6OmNy ZWF0ZSgpKTsKKyAgICB9IGVsc2UKKyAgICAgICAgbV9ydW5Mb29wLnRlcm1pbmF0ZSgpOwogfQog CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1MzUxMikKKysrIExh eW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDEw LTAxLTE5ICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gYnVnLiAgVGhpcyBpcyBwYXJ0 IG9mIHRoZSBjaGVja2luIGZvcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjI3MjUKKworICAgICAgICBQcmV2aW91c2x5IG9wZW5EYXRhYmFzZSB3b3Vs ZCBqdXN0IHJldHVybiBudWxsIGlmIHRoZSBvcGVuZXIgZGlkbid0CisgICAgICAgIGhhdmUgcGVy bWlzc2lvbiB0byBhY2Nlc3MgdGhlIGRhdGFiYXNlLiAgSSd2ZSBjaGFuZ2VkIGl0IHRvIHRocm93 IGFuCisgICAgICAgIGV4Y2VwdGlvbiwgYXMgSSBiZWxpdmUgdGhhdCdzIHdoYXQgdGhlIHNwZWMg cmVxdWlyZXMuCisKKyAgICAgICAgKiBmYXN0L2ZyYW1lcy9yZXNvdXJjZXMvc2FuZGJveGVkLWlm cmFtZS1zdG9yYWdlLWRpc2FsbG93ZWQuaHRtbDoKKyAgICAgICAgKiBmYXN0L2ZyYW1lcy9zYW5k Ym94ZWQtaWZyYW1lLXN0b3JhZ2UtZXhwZWN0ZWQudHh0OgorCiAyMDEwLTAxLTE3ICBKb24gSG9u ZXljdXR0ICA8amhvbmV5Y3V0dEBhcHBsZS5jb20+CiAKICAgICAgICAgTVNBQTogVGhlIGNoaWxk IDxvcHRpb24+IGVsZW1lbnRzIG9mIGEgbm9uLW11bHRpcGxlIDxzZWxlY3Q+IGFyZSBub3QKSW5k ZXg6IExheW91dFRlc3RzL2Zhc3QvZnJhbWVzL3NhbmRib3hlZC1pZnJhbWUtc3RvcmFnZS1leHBl Y3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9mcmFtZXMvc2FuZGJveGVk LWlmcmFtZS1zdG9yYWdlLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gNTM1MTIpCisrKyBMYXlvdXRU ZXN0cy9mYXN0L2ZyYW1lcy9zYW5kYm94ZWQtaWZyYW1lLXN0b3JhZ2UtZXhwZWN0ZWQudHh0CSh3 b3JraW5nIGNvcHkpCkBAIC0xNCw3ICsxNCw3IEBAIFRFU1QgQ09NUExFVEUKIC0tLS0tLS0tCiBG cmFtZTogJzwhLS1mcmFtZVBhdGggLy88IS0tZnJhbWUwLS0+LS0+JwogLS0tLS0tLS0KLVBBU1Mg d2luZG93Lm9wZW5EYXRhYmFzZSgpID09IG51bGwgaXMgdHJ1ZQorUEFTUyB3aW5kb3cub3BlbkRh dGFiYXNlKCkgdGhyZXcgZXhjZXB0aW9uIEVycm9yOiBTRUNVUklUWV9FUlI6IERPTSBFeGNlcHRp b24gMTguCiBQQVNTIHdpbmRvdy5sb2NhbFN0b3JhZ2UgPT0gbnVsbCBpcyB0cnVlCiBQQVNTIHdp bmRvdy5zZXNzaW9uU3RvcmFnZSA9PSBudWxsIGlzIHRydWUKIApJbmRleDogTGF5b3V0VGVzdHMv ZmFzdC9mcmFtZXMvcmVzb3VyY2VzL3NhbmRib3hlZC1pZnJhbWUtc3RvcmFnZS1kaXNhbGxvd2Vk Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9mcmFtZXMvcmVzb3VyY2VzL3Nh bmRib3hlZC1pZnJhbWUtc3RvcmFnZS1kaXNhbGxvd2VkLmh0bWwJKHJldmlzaW9uIDUzNTEyKQor KysgTGF5b3V0VGVzdHMvZmFzdC9mcmFtZXMvcmVzb3VyY2VzL3NhbmRib3hlZC1pZnJhbWUtc3Rv cmFnZS1kaXNhbGxvd2VkLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTYsNyArNiw3IEBACiA8c2Ny aXB0PgogCiB3aW5kb3cub25sb2FkID0gZnVuY3Rpb24oKSB7Ci0gICAgc2hvdWxkQmVUcnVlKCJ3 aW5kb3cub3BlbkRhdGFiYXNlKCkgPT0gbnVsbCIpOworICAgIHNob3VsZFRocm93KCJ3aW5kb3cu b3BlbkRhdGFiYXNlKCkiLCAiJ0Vycm9yOiBTRUNVUklUWV9FUlI6IERPTSBFeGNlcHRpb24gMTgn Iik7CiAgICAgc2hvdWxkQmVUcnVlKCJ3aW5kb3cubG9jYWxTdG9yYWdlID09IG51bGwiKTsKICAg ICBzaG91bGRCZVRydWUoIndpbmRvdy5zZXNzaW9uU3RvcmFnZSA9PSBudWxsIik7CiB9Cg== 47061 2010-01-20 13:33:10 -0800 2010-01-20 19:49:58 -0800 Removed DOMWindow.cpp change, fixed the last(?) few comments. upload.4.patch text/plain 61503 ericu SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzU2MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTQ2IEBACisyMDEwLTAxLTIwICBFcmljIFVocmhhbmUgIDxlcmljdUBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVmYWN0b3JpbmcgYW5kIHBsdW1iaW5nIHRvIGdldCB0aGUgSFRNTDUgU1FMIERhdGFiYXNlIEFQ SSBhY2Nlc3NpYmxlIHRvCisgICAgICAgIHdlYiB3b3JrZXJzLiAgTm8gbmV3IGZ1bmN0aW9uYWxp dHkgaXMgZXhwb3NlZCB5ZXQ7IHRoaXMganVzdCBnZXRzIHRoZQorICAgICAgICBpbmZyYXN0cnVj dHVyZSBpbiBwbGFjZS4gIEl0IHRvdWNoZXMgYSBsb3Qgb2YgZmlsZXMgaW4gc21hbGwgd2F5czsg aGVyZQorICAgICAgICBhcmUgdGhlIG1haW4gY2hhbmdlczoKKworICAgICAgICAxKSBEYXRhYmFz ZSBtZW1iZXJzIGFuZCBtZXRob2RzIG1vdmUgZnJvbSBEb2N1bWVudCB1cCB0bworICAgICAgICBT Y3JpcHRFeGVjdXRpb25Db250ZXh0LiAgRWFjaCBvZiBEb2N1bWVudCBhbmQgV29ya2VyQ29udGV4 dCBtdXN0CisgICAgICAgIGltcGxlbWVudCBhIGZldyB2aXJ0dWFsIG1ldGhvZHMgd2hlcmUgdGhl IERhdGFiYXNlIGNvZGUgcmVxdWlyZXMKKyAgICAgICAgZGlmZmVyZW50aWF0aW9uLgorICAgICAg ICAyKSBXb3JrZXIgdGhyZWFkIHNodXRkb3duIGdvdCBjaGFuZ2VkIGEgYnVuY2ggdG8gaGFuZGxl IERhdGFiYXNlIGNsZWFudXAKKyAgICAgICAgYW5kIHRocmVhZCBzeW5jaHJvbml6YXRpb24gaXNz dWVzLiAgRGF0YWJhc2UgY2xlYW51cCB0YXNrcyBuZWVkIHRvIHBvc3QKKyAgICAgICAgc29tZSBj bGVhbnVwIHRhc2tzIHRvIHRoZSBKYXZhU2NyaXB0IHRocmVhZC4gIEhvd2V2ZXIsIHNpbmNlIGRh dGFiYXNlCisgICAgICAgIGNsZWFudXAgbWF5IGhhcHBlbiBkdWUgdG8gdGhlIGRlc3RydWN0aW9u IG9mIHRoZSBXb3JrZXJUaHJlYWQsIEkgYWRkZWQgYQorICAgICAgICBoYW5kc2hha2UgW2ludm9s dmluZyBXb3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzaywKKyAgICAgICAgV29ya2VyVGhyZWFk U2h1dGRvd25GaW5pc2hUYXNrLCBhbmQgYSBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXJdIGJldHdl ZW4KKyAgICAgICAgdGhlIERhdGFiYXNlIHRocmVhZCBhbmQgV29ya2VyVGhyZWFkIHRoYXQgY2xl YW5zIHVwIGFsbCB0aGUgRGF0YWJhc2UKKyAgICAgICAgc3R1ZmYgYmVmb3JlIHRoZSBXb3JrZXJU aHJlYWQncyBydW5Mb29wIGNhbiBleGl0LgorICAgICAgICAzKSBUaGUgcnVudGltZSBlbmFibGVy IGZvciB0aGUgRGF0YWJhc2UgbW92ZWQgdG8gYSBzdGF0aWMgdmFyaWFibGUKKyAgICAgICAgYWNj ZXNzaWJsZSB0aHJvdWdoIERhdGFiYXNlOjppc0F2YWlsYWJsZSwgZm9sbG93aW5nIHRoZSBtb2Rl bCB1c2VkIGJ5CisgICAgICAgIFdlYlNvY2tldC4KKyAgICAgICAgNCkgV29ya2VyIHRocmVhZHMg ZG9uJ3QgcnVuIHRoZWlyIEphdmFTY3JpcHQgb24gdGhlIE1haW4gdGhyZWFkLCBzbworICAgICAg ICBEYXRhYmFzZSBjb2RlIHRoYXQgZGlmZmVyZW50aWF0ZWQgYmV0d2VlbiB0aGUgTWFpbiB0aHJl YWQgYW5kIHRoZQorICAgICAgICBEYXRhYmFzZSB0aHJlYWQgbm93IG5lZWQgdG8gZGVhbCB3aXRo IGEgdGhpcmQgcG9zc2liaWxpdHkuCisgICAgICAgIDUpIE1vc3Qgb2YgdGhlIG90aGVyIGNoYW5n ZXMgaGF2ZSB0byBkbyB3aXRoIGhhdmluZyBhCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgcG9pbnRlciBpbnN0ZWFkIG9mIGEgRG9jdW1lbnQgcG9pbnRlciB3aGVuCisgICAgICAgIGRl YWxpbmcgd2l0aCBhIERhdGFiYXNlLiAgSW4gbWFueSBjYXNlcyBpdCdzIGp1c3QgYSBzdHJpbmcg cmVwbGFjZW1lbnQsCisgICAgICAgIGJ1dCBpbiBzb21lIGl0IHJlcXVpcmVkIHRoZSBjcmVhdGlv biBvZiBhIG5ldyB2aXJ0dWFsIGZ1bmN0aW9uIFtlLmcuCisgICAgICAgIGRhdGFiYXNlRXhjZWVk ZWRRdW90YSwgaXNEYXRhYmFzZVJlYWRPbmx5XQorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjcyNQorCisgICAgICAgIE5vIG5ldyB0ZXN0czsgaW4g YSBmdXR1cmUgcGF0Y2ggSSdsbCBhZGQgSlNDIGFuZCBWOCBiaW5kaW5ncyBhbmQgbmV3CisgICAg ICAgIGxheW91dCB0ZXN0cyB0byBleGVyY2lzZSB0aGVtLgorCisgICAgICAgICogYmluZGluZ3Mv djgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4RE9N V2luZG93OjpPcGVuRGF0YWJhc2VFbmFibGVkKToKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNv cmU6OkRvY3VtZW50Ojp+RG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6Omlz RGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZGF0YWJhc2VF eGNlZWRlZFF1b3RhKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50Ojppc0NvbnRleHRUaHJl YWQpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudC5oOgorICAgICAgICAqIGRvbS9TY3JpcHRFeGVj dXRpb25Db250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RXhl Y3V0aW9uQ29udGV4dDo6flNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6ZGF0YWJhc2VUaHJlYWQpOgorICAgICAgICAoV2Vi Q29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6YWRkT3BlbkRhdGFiYXNlKToKKyAgICAgICAg KFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnJlbW92ZU9wZW5EYXRhYmFzZSk6Cisg ICAgICAgIChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzdG9wRGF0YWJhc2VzKToK KyAgICAgICAgKiBkb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oOgorICAgICAgICAoV2ViQ29y ZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c2V0SGFzT3BlbkRhdGFiYXNlcyk6CisgICAgICAg IChXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpoYXNPcGVuRGF0YWJhc2VzKToKKyAg ICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s6OmlzQ2xlYW51cFRh c2spOgorICAgICAgICAqIGxvYWRlci9GcmFtZUxvYWRlci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpGcmFtZUxvYWRlcjo6c3RvcExvYWRpbmcpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2Uu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNldElzQXZhaWxhYmxlKToKKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlOjppc0F2YWlsYWJsZSk6CisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZTo6b3BlbkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpEYXRh YmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpEZXJlZkNvbnRleHRUYXNrOjpjcmVhdGUpOgorICAg ICAgICAoV2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAo V2ViQ29yZTo6RGVyZWZDb250ZXh0VGFzazo6aXNDbGVhbnVwVGFzayk6CisgICAgICAgIChXZWJD b3JlOjpEYXRhYmFzZTo6fkRhdGFiYXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpv cGVuQW5kVmVyaWZ5VmVyc2lvbik6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6bWFya0Fz RGVsZXRlZEFuZENsb3NlKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRleHRSZW1vdmVPcGVuRGF0 YWJhc2VUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Q29udGV4dFJlbW92ZU9wZW5E YXRhYmFzZVRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkNvbnRleHRSZW1v dmVPcGVuRGF0YWJhc2VUYXNrOjppc0NsZWFudXBUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkNv bnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFz ayk6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6Y2xvc2UpOgorICAgICAgICAoV2ViQ29y ZTo6RGF0YWJhc2U6OnBlcmZvcm1PcGVuQW5kVmVyaWZ5KToKKyAgICAgICAgKFdlYkNvcmU6OkRh dGFiYXNlOjpzY2hlZHVsZVRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNl OjpzY2hlZHVsZVRyYW5zYWN0aW9uU3RlcCk6CisgICAgICAgIChXZWJDb3JlOjpEZWxpdmVyUGVu ZGluZ0NhbGxiYWNrVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGl2ZXJQZW5k aW5nQ2FsbGJhY2tUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpEZWxpdmVy UGVuZGluZ0NhbGxiYWNrVGFzazo6RGVsaXZlclBlbmRpbmdDYWxsYmFja1Rhc2spOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25DYWxsYmFjayk6CisgICAg ICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6dHJhbnNhY3Rpb25DbGllbnQpOgorICAgICAgICAoV2Vi Q29yZTo6RGF0YWJhc2U6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IpOgorICAgICAgICAoV2ViQ29y ZTo6RGF0YWJhc2U6OnRhYmxlTmFtZXMpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNl Y3VyaXR5T3JpZ2luKToKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNlLmg6CisgICAgICAgIChX ZWJDb3JlOjpEYXRhYmFzZTo6c2NyaXB0RXhlY3V0aW9uQ29udGV4dCk6CisgICAgICAgICogc3Rv cmFnZS9EYXRhYmFzZVRhc2suaDoKKyAgICAgICAgKiBzdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpEYXRhYmFzZVRocmVhZCk6Cisg ICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZVRocmVhZDo6fkRhdGFiYXNlVGhyZWFkKToKKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRpb24pOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YWJhc2VUaHJlYWQ6OmRhdGFiYXNlVGhyZWFkKToKKyAgICAgICAgKFdl YkNvcmU6OkRhdGFiYXNlVGhyZWFkOjp1bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyk6CisgICAgICAg ICogc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5oOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VU cmFja2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6Y2FuRXN0YWJs aXNoRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VUcmFja2VyOjpnZXRNYXhT aXplRm9yRGF0YWJhc2UpOgorICAgICAgICAqIHN0b3JhZ2UvRGF0YWJhc2VUcmFja2VyLmg6Cisg ICAgICAgICogc3RvcmFnZS9TUUxUcmFuc2FjdGlvbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpT UUxUcmFuc2FjdGlvbjo6ZXhlY3V0ZVNRTCk6CisgICAgICAgICogc3RvcmFnZS9TUUxUcmFuc2Fj dGlvbkNsaWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTUUxUcmFuc2FjdGlvbkNsaWVudDo6 ZGlkQ29tbWl0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6U1FMVHJhbnNhY3Rpb25D bGllbnQ6OmRpZEV4ZWN1dGVTdGF0ZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6U1FMVHJhbnNh Y3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKToKKyAgICAgICAgKiBzdG9yYWdlL2Nocm9taXVt L0RhdGFiYXNlVHJhY2tlckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNl VHJhY2tlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJh c2VUcmFja2VyOjphZGRPcGVuRGF0YWJhc2UpOgorICAgICAgICAoV2ViQ29yZTo6VHJhY2tlclJl bW92ZU9wZW5EYXRhYmFzZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpUcmFja2Vy UmVtb3ZlT3BlbkRhdGFiYXNlVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6 VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2s6OlRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VU YXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6cmVtb3ZlT3BlbkRhdGFi YXNlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlVHJhY2tlcjo6Z2V0TWF4U2l6ZUZvckRh dGFiYXNlKToKKyAgICAgICAgKiBzdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0aW9uQ2xpZW50 Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFz azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2s6 OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRh c2s6Ok5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2spOgorICAgICAgICAoV2ViQ29yZTo6U1FMVHJh bnNhY3Rpb25DbGllbnQ6OmRpZENvbW1pdFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6 OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhdGVtZW50KToKKyAgICAgICAgKFdl YkNvcmU6OlNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGNlZWRRdW90YSk6CisgICAgICAgICog d29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRl eHQ6Om9wZW5EYXRhYmFzZSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJDb250ZXh0Ojppc0Nv bnRleHRUaHJlYWQpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAgICAg ICAoV2ViQ29yZTo6V29ya2VyQ29udGV4dDo6Y2xlYXJTY3JpcHQpOgorICAgICAgICAoV2ViQ29y ZTo6V29ya2VyQ29udGV4dDo6dGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlckNvbnRl eHQ6OmlzRGF0YWJhc2VSZWFkT25seSk6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJDb250ZXh0 OjpkYXRhYmFzZUV4Y2VlZGVkUXVvdGEpOgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyUnVuTG9v cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJSdW5Mb29wOjpydW5Jbk1vZGUpOgorICAg ICAgICAoV2ViQ29yZTo6V29ya2VyUnVuTG9vcDo6VGFzazo6cGVyZm9ybVRhc2spOgorICAgICAg ICAqIHdvcmtlcnMvV29ya2VyVGhyZWFkLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRo cmVhZDo6d29ya2VyVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRk b3duRmluaXNoVGFzazo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNo dXRkb3duRmluaXNoVGFzazo6cGVyZm9ybVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6V29ya2Vy VGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjppc0NsZWFudXBUYXNrKToKKyAgICAgICAgKFdlYkNv cmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjpjcmVhdGUpOgorICAgICAgICAoV2Vi Q29yZTo6V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAg ICAgKFdlYkNvcmU6OldvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrOjppc0NsZWFudXBUYXNr KToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRocmVhZDo6c3RvcCk6CisKIDIwMTAtMDEtMjAg IEtldmluIE9sbGl2aWVyICA8a2V2aW5vQHRoZW9sbGl2aWVycy5jb20+CiAKICAgICAgICAgQnVp bGQgZml4IGZvciAhRU5BQkxFKFNWRykuCkluZGV4OiBXZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3Rv bS9WOERPTVdpbmRvd0N1c3RvbS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9iaW5kaW5ncy92 OC9jdXN0b20vVjhET01XaW5kb3dDdXN0b20uY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNv cmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4RE9NV2luZG93Q3VzdG9tLmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMzMsNiArMzMsNyBAQAogCiAjaW5jbHVkZSAiQmFzZTY0LmgiCiAjaW5jbHVkZSAiQ2hy b21lLmgiCisjaW5jbHVkZSAiRGF0YWJhc2UuaCIKICNpbmNsdWRlICJET01UaW1lci5oIgogI2lu Y2x1ZGUgIkRPTVdpbmRvdy5oIgogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKQEAgLTI5Niw3 ICsyOTcsNyBAQCBib29sIFY4RE9NV2luZG93OjpXZWJTb2NrZXRFbmFibGVkKCkKICNpZiBFTkFC TEUoREFUQUJBU0UpCiBib29sIFY4RE9NV2luZG93OjpPcGVuRGF0YWJhc2VFbmFibGVkKCkKIHsK LSAgICByZXR1cm4gV2ViQ29yZTo6UnVudGltZUVuYWJsZWRGZWF0dXJlczo6ZGF0YWJhc2VFbmFi bGVkKCk7CisgICAgcmV0dXJuIERhdGFiYXNlOjppc0F2YWlsYWJsZSgpOwogfQogI2VuZGlmCiAK SW5kZXg6IFdlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Rv bS9Eb2N1bWVudC5jcHAJKHJldmlzaW9uIDUzNTEyKQorKysgV2ViQ29yZS9kb20vRG9jdW1lbnQu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiQ1N0cmluZy5o IgogI2luY2x1ZGUgIkNhY2hlZENTU1N0eWxlU2hlZXQuaCIKICNpbmNsdWRlICJDaHJvbWUuaCIK KyNpbmNsdWRlICJDaHJvbWVDbGllbnQuaCIKICNpbmNsdWRlICJDb21tZW50LmgiCiAjaW5jbHVk ZSAiQ29uc29sZS5oIgogI2luY2x1ZGUgIkNvb2tpZUphci5oIgpAQCAtMTM4LDExICsxMzksNiBA QAogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJh cy5oPgogCi0jaWYgRU5BQkxFKERBVEFCQVNFKQotI2luY2x1ZGUgIkRhdGFiYXNlLmgiCi0jaW5j bHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKLSNlbmRpZgotCiAjaWYgRU5BQkxFKFNIQVJFRF9XT1JL RVJTKQogI2luY2x1ZGUgIlNoYXJlZFdvcmtlclJlcG9zaXRvcnkuaCIKICNlbmRpZgpAQCAtMzYx LDkgKzM1Nyw2IEBAIERvY3VtZW50OjpEb2N1bWVudChGcmFtZSogZnJhbWUsIGJvb2wgaXMKICNp ZiBVU0UoSlNDKQogICAgICwgbV9ub3JtYWxXb3JsZFdyYXBwZXJDYWNoZSgwKQogI2VuZGlmCi0j aWYgRU5BQkxFKERBVEFCQVNFKQotICAgICwgbV9oYXNPcGVuRGF0YWJhc2VzKGZhbHNlKQotI2Vu ZGlmCiAgICAgLCBtX3VzaW5nR2VvbG9jYXRpb24oZmFsc2UpCiAjaWYgRU5BQkxFKFdNTCkKICAg ICAsIG1fY29udGFpbnNXTUxDb250ZW50KGZhbHNlKQpAQCAtNTA5LDEzICs1MDIsNiBAQCBEb2N1 bWVudDo6fkRvY3VtZW50KCkKICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY291bnQ7IGkr KykKICAgICAgICAgZGVsZXRlQWxsVmFsdWVzKG1fbmFtZUNvbGxlY3Rpb25JbmZvW2ldKTsKIAot I2lmIEVOQUJMRShEQVRBQkFTRSkKLSAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkgewotICAgICAg ICBBU1NFUlQobV9kYXRhYmFzZVRocmVhZC0+dGVybWluYXRpb25SZXF1ZXN0ZWQoKSk7Ci0gICAg ICAgIG1fZGF0YWJhc2VUaHJlYWQgPSAwOwotICAgIH0KLSNlbmRpZgotCiAgICAgaWYgKG1fc3R5 bGVTaGVldHMpCiAgICAgICAgIG1fc3R5bGVTaGVldHMtPmRvY3VtZW50RGVzdHJveWVkKCk7CiAK QEAgLTQ0MTIsNiArNDM5OCwyOSBAQCB2b2lkIERvY3VtZW50OjpzZXRTZWN1cml0eU9yaWdpbihT ZWN1cml0CiAgICAgaW5pdEROU1ByZWZldGNoKCk7CiB9CiAKKyNpZiBFTkFCTEUoREFUQUJBU0Up CisKK2Jvb2wgRG9jdW1lbnQ6OmlzRGF0YWJhc2VSZWFkT25seSgpIGNvbnN0Cit7CisgICAgaWYg KCFwYWdlKCkgfHwgcGFnZSgpLT5zZXR0aW5ncygpLT5wcml2YXRlQnJvd3NpbmdFbmFibGVkKCkp CisgICAgICAgIHJldHVybiB0cnVlOworICAgIHJldHVybiBmYWxzZTsKK30KKwordm9pZCBEb2N1 bWVudDo6ZGF0YWJhc2VFeGNlZWRlZFF1b3RhKGNvbnN0IFN0cmluZyYgbmFtZSkKK3sKKyAgICBQ YWdlKiBjdXJyZW50UGFnZSA9IHBhZ2UoKTsKKyAgICBpZiAoY3VycmVudFBhZ2UpCisgICAgICAg IGN1cnJlbnRQYWdlLT5jaHJvbWUoKS0+Y2xpZW50KCktPmV4Y2VlZGVkRGF0YWJhc2VRdW90YShk b2N1bWVudCgpLT5mcmFtZSgpLCBuYW1lKTsKK30KKworI2VuZGlmCisKK2Jvb2wgRG9jdW1lbnQ6 OmlzQ29udGV4dFRocmVhZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGlzTWFpblRocmVhZCgpOwor fQorCiB2b2lkIERvY3VtZW50Ojp1cGRhdGVVUkxGb3JQdXNoT3JSZXBsYWNlU3RhdGUoY29uc3Qg S1VSTCYgdXJsKQogewogICAgIEZyYW1lKiBmID0gZnJhbWUoKTsKQEAgLTQ1MTIsNTcgKzQ1MjEs NiBAQCBET01TZWxlY3Rpb24qIERvY3VtZW50OjpnZXRTZWxlY3Rpb24oKSBjCiAgICAgcmV0dXJu IGZyYW1lKCkgPyBmcmFtZSgpLT5kb21XaW5kb3coKS0+Z2V0U2VsZWN0aW9uKCkgOiAwOwogfQog Ci0jaWYgRU5BQkxFKERBVEFCQVNFKQotCi12b2lkIERvY3VtZW50OjphZGRPcGVuRGF0YWJhc2Uo RGF0YWJhc2UqIGRhdGFiYXNlKQotewotICAgIGlmICghbV9vcGVuRGF0YWJhc2VTZXQpCi0gICAg ICAgIG1fb3BlbkRhdGFiYXNlU2V0LnNldChuZXcgRGF0YWJhc2VTZXQpOwotCi0gICAgQVNTRVJU KCFtX29wZW5EYXRhYmFzZVNldC0+Y29udGFpbnMoZGF0YWJhc2UpKTsKLSAgICBtX29wZW5EYXRh YmFzZVNldC0+YWRkKGRhdGFiYXNlKTsKLX0KLQotdm9pZCBEb2N1bWVudDo6cmVtb3ZlT3BlbkRh dGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKLXsKLSAgICBBU1NFUlQobV9vcGVuRGF0YWJhc2VT ZXQgJiYgbV9vcGVuRGF0YWJhc2VTZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7Ci0gICAgaWYgKCFt X29wZW5EYXRhYmFzZVNldCkKLSAgICAgICAgcmV0dXJuOwotICAgICAgICAKLSAgICBtX29wZW5E YXRhYmFzZVNldC0+cmVtb3ZlKGRhdGFiYXNlKTsKLX0KLQotRGF0YWJhc2VUaHJlYWQqIERvY3Vt ZW50OjpkYXRhYmFzZVRocmVhZCgpCi17Ci0gICAgaWYgKCFtX2RhdGFiYXNlVGhyZWFkICYmICFt X2hhc09wZW5EYXRhYmFzZXMpIHsKLSAgICAgICAgLy8gQ3JlYXRlIHRoZSBkYXRhYmFzZSB0aHJl YWQgb24gZmlyc3QgcmVxdWVzdCAtIGJ1dCBub3QgaWYgYXQgbGVhc3Qgb25lIGRhdGFiYXNlIHdh cyBhbHJlYWR5IG9wZW5lZCwKLSAgICAgICAgLy8gYmVjYXVzZSBpbiB0aGF0IGNhc2Ugd2UgYWxy ZWFkeSBoYWQgYSBkYXRhYmFzZSB0aHJlYWQgYW5kIHRlcm1pbmF0ZWQgaXQgYW5kIHNob3VsZCBu b3QgY3JlYXRlIGFub3RoZXIuCi0gICAgICAgIG1fZGF0YWJhc2VUaHJlYWQgPSBEYXRhYmFzZVRo cmVhZDo6Y3JlYXRlKCk7Ci0gICAgICAgIGlmICghbV9kYXRhYmFzZVRocmVhZC0+c3RhcnQoKSkK LSAgICAgICAgICAgIG1fZGF0YWJhc2VUaHJlYWQgPSAwOwotICAgIH0KLQotICAgIHJldHVybiBt X2RhdGFiYXNlVGhyZWFkLmdldCgpOwotfQotCi12b2lkIERvY3VtZW50OjpzdG9wRGF0YWJhc2Vz KCkKLXsKLSAgICBpZiAobV9vcGVuRGF0YWJhc2VTZXQpIHsKLSAgICAgICAgRGF0YWJhc2VTZXQ6 Oml0ZXJhdG9yIGkgPSBtX29wZW5EYXRhYmFzZVNldC0+YmVnaW4oKTsKLSAgICAgICAgRGF0YWJh c2VTZXQ6Oml0ZXJhdG9yIGVuZCA9IG1fb3BlbkRhdGFiYXNlU2V0LT5lbmQoKTsKLSAgICAgICAg Zm9yICg7IGkgIT0gZW5kOyArK2kpIHsKLSAgICAgICAgICAgICgqaSktPnN0b3AoKTsKLSAgICAg ICAgICAgIGlmIChtX2RhdGFiYXNlVGhyZWFkKQotICAgICAgICAgICAgICAgIG1fZGF0YWJhc2VU aHJlYWQtPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKCppKTsKLSAgICAgICAgfQotICAgIH0KLSAg ICAKLSAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkKLSAgICAgICAgbV9kYXRhYmFzZVRocmVhZC0+ cmVxdWVzdFRlcm1pbmF0aW9uKCk7Ci19Ci0KLSNlbmRpZgotCiAjaWYgRU5BQkxFKFdNTCkKIHZv aWQgRG9jdW1lbnQ6OnJlc2V0V01MUGFnZVN0YXRlKCkKIHsKSW5kZXg6IFdlYkNvcmUvZG9tL0Rv Y3VtZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vRG9jdW1lbnQuaAkocmV2aXNpb24g NTM1MTIpCisrKyBXZWJDb3JlL2RvbS9Eb2N1bWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC05MjIs MTQgKzkyMiwxMiBAQCBwdWJsaWM6CiAgICAgYm9vbCBwcm9jZXNzaW5nTG9hZEV2ZW50KCkgY29u c3QgeyByZXR1cm4gbV9wcm9jZXNzaW5nTG9hZEV2ZW50OyB9CiAKICNpZiBFTkFCTEUoREFUQUJB U0UpCi0gICAgdm9pZCBhZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqKTsKLSAgICB2b2lkIHJlbW92 ZU9wZW5EYXRhYmFzZShEYXRhYmFzZSopOwotICAgIERhdGFiYXNlVGhyZWFkKiBkYXRhYmFzZVRo cmVhZCgpOyAgIC8vIENyZWF0ZXMgdGhlIHRocmVhZCBhcyBuZWVkZWQsIGJ1dCBub3QgaWYgaXQg aGFzIGJlZW4gYWxyZWFkeSB0ZXJtaW5hdGVkLgotICAgIHZvaWQgc2V0SGFzT3BlbkRhdGFiYXNl cygpIHsgbV9oYXNPcGVuRGF0YWJhc2VzID0gdHJ1ZTsgfQotICAgIGJvb2wgaGFzT3BlbkRhdGFi YXNlcygpIHsgcmV0dXJuIG1faGFzT3BlbkRhdGFiYXNlczsgfQotICAgIHZvaWQgc3RvcERhdGFi YXNlcygpOworICAgIHZpcnR1YWwgYm9vbCBpc0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdDsKKyAg ICB2aXJ0dWFsIHZvaWQgZGF0YWJhc2VFeGNlZWRlZFF1b3RhKGNvbnN0IFN0cmluZyYgbmFtZSk7 CiAjZW5kaWYKIAorICAgIHZpcnR1YWwgYm9vbCBpc0NvbnRleHRUaHJlYWQoKSBjb25zdDsKKwog ICAgIHZvaWQgc2V0VXNpbmdHZW9sb2NhdGlvbihib29sIGYpIHsgbV91c2luZ0dlb2xvY2F0aW9u ID0gZjsgfQogICAgIGJvb2wgdXNpbmdHZW9sb2NhdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fdXNp bmdHZW9sb2NhdGlvbjsgfTsKIApAQCAtMTE5MiwxMyArMTE5MCw2IEBAIHByaXZhdGU6CiAgICAg SlNXcmFwcGVyQ2FjaGUqIG1fbm9ybWFsV29ybGRXcmFwcGVyQ2FjaGU7CiAjZW5kaWYKIAotI2lm IEVOQUJMRShEQVRBQkFTRSkKLSAgICBSZWZQdHI8RGF0YWJhc2VUaHJlYWQ+IG1fZGF0YWJhc2VU aHJlYWQ7Ci0gICAgYm9vbCBtX2hhc09wZW5EYXRhYmFzZXM7ICAgIC8vIFRoaXMgbmV2ZXIgY2hh bmdlcyBiYWNrIHRvIGZhbHNlLCBldmVuIGFzIHRoZSBkYXRhYmFzZSB0aHJlYWQgaXMgY2xvc2Vk LgotICAgIHR5cGVkZWYgSGFzaFNldDxEYXRhYmFzZSo+IERhdGFiYXNlU2V0OwotICAgIE93blB0 cjxEYXRhYmFzZVNldD4gbV9vcGVuRGF0YWJhc2VTZXQ7Ci0jZW5kaWYKLSAgICAKICAgICBib29s IG1fdXNpbmdHZW9sb2NhdGlvbjsKIAogI2lmIEVOQUJMRShXTUwpCkluZGV4OiBXZWJDb3JlL2Rv bS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9T Y3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3JlL2Rv bS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjgsNyArMjgs OCBAQAogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKIAogI2luY2x1ZGUgIkFj dGl2ZURPTU9iamVjdC5oIgotI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRGF0YWJh c2VUYXNrLmgiCisjaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKICNpbmNsdWRlICJNZXNzYWdl UG9ydC5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiV29ya2VyQ29u dGV4dC5oIgpAQCAtNTYsNiArNTcsOSBAQCBwdWJsaWM6CiB9OwogCiBTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KCkKKyNpZiBFTkFCTEUoREFUQUJBU0UpCisg ICAgOiBtX2hhc09wZW5EYXRhYmFzZXMoZmFsc2UpCisjZW5kaWYKIHsKIH0KIApAQCAtNzIsOCAr NzYsNjcgQEAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6flNjcmlwdEV4ZWN1dGlvbgogICAgICAg ICBBU1NFUlQoKCppdGVyKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpID09IHRoaXMpOwogICAg ICAgICAoKml0ZXIpLT5jb250ZXh0RGVzdHJveWVkKCk7CiAgICAgfQorICAgIGlmIChtX2RhdGFi YXNlVGhyZWFkKSB7CisgICAgICAgIEFTU0VSVChtX2RhdGFiYXNlVGhyZWFkLT50ZXJtaW5hdGlv blJlcXVlc3RlZCgpKTsKKyAgICAgICAgbV9kYXRhYmFzZVRocmVhZCA9IDA7CisgICAgfQogfQog CisjaWYgRU5BQkxFKERBVEFCQVNFKQorCitEYXRhYmFzZVRocmVhZCogU2NyaXB0RXhlY3V0aW9u Q29udGV4dDo6ZGF0YWJhc2VUaHJlYWQoKQoreworICAgIGlmICghbV9kYXRhYmFzZVRocmVhZCAm JiAhbV9oYXNPcGVuRGF0YWJhc2VzKSB7CisgICAgICAgIC8vIENyZWF0ZSB0aGUgZGF0YWJhc2Ug dGhyZWFkIG9uIGZpcnN0IHJlcXVlc3QgLSBidXQgbm90IGlmIGF0IGxlYXN0IG9uZSBkYXRhYmFz ZSB3YXMgYWxyZWFkeSBvcGVuZWQsCisgICAgICAgIC8vIGJlY2F1c2UgaW4gdGhhdCBjYXNlIHdl IGFscmVhZHkgaGFkIGEgZGF0YWJhc2UgdGhyZWFkIGFuZCB0ZXJtaW5hdGVkIGl0IGFuZCBzaG91 bGQgbm90IGNyZWF0ZSBhbm90aGVyLgorICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0gRGF0YWJh c2VUaHJlYWQ6OmNyZWF0ZSgpOworICAgICAgICBpZiAoIW1fZGF0YWJhc2VUaHJlYWQtPnN0YXJ0 KCkpCisgICAgICAgICAgICBtX2RhdGFiYXNlVGhyZWFkID0gMDsKKyAgICB9CisKKyAgICByZXR1 cm4gbV9kYXRhYmFzZVRocmVhZC5nZXQoKTsKK30KKwordm9pZCBTY3JpcHRFeGVjdXRpb25Db250 ZXh0OjphZGRPcGVuRGF0YWJhc2UoRGF0YWJhc2UqIGRhdGFiYXNlKQoreworICAgIEFTU0VSVChp c0NvbnRleHRUaHJlYWQoKSk7CisgICAgaWYgKCFtX29wZW5EYXRhYmFzZVNldCkKKyAgICAgICAg bV9vcGVuRGF0YWJhc2VTZXQuc2V0KG5ldyBEYXRhYmFzZVNldCgpKTsKKworICAgIEFTU0VSVCgh bV9vcGVuRGF0YWJhc2VTZXQtPmNvbnRhaW5zKGRhdGFiYXNlKSk7CisgICAgbV9vcGVuRGF0YWJh c2VTZXQtPmFkZChkYXRhYmFzZSk7Cit9CisKK3ZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6 cmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkKK3sKKyAgICBBU1NFUlQoaXND b250ZXh0VGhyZWFkKCkpOworICAgIEFTU0VSVChtX29wZW5EYXRhYmFzZVNldCAmJiBtX29wZW5E YXRhYmFzZVNldC0+Y29udGFpbnMoZGF0YWJhc2UpKTsKKyAgICBpZiAoIW1fb3BlbkRhdGFiYXNl U2V0KQorICAgICAgICByZXR1cm47CisgICAgbV9vcGVuRGF0YWJhc2VTZXQtPnJlbW92ZShkYXRh YmFzZSk7Cit9CisKK3ZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c3RvcERhdGFiYXNlcyhE YXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIqIGNsZWFudXBTeW5jKQoreworICAgIEFTU0VSVChpc0Nv bnRleHRUaHJlYWQoKSk7CisgICAgaWYgKG1fb3BlbkRhdGFiYXNlU2V0KSB7CisgICAgICAgIERh dGFiYXNlU2V0OjppdGVyYXRvciBpID0gbV9vcGVuRGF0YWJhc2VTZXQtPmJlZ2luKCk7CisgICAg ICAgIERhdGFiYXNlU2V0OjppdGVyYXRvciBlbmQgPSBtX29wZW5EYXRhYmFzZVNldC0+ZW5kKCk7 CisgICAgICAgIGZvciAoOyBpICE9IGVuZDsgKytpKSB7CisgICAgICAgICAgICAoKmkpLT5zdG9w KCk7CisgICAgICAgICAgICBpZiAobV9kYXRhYmFzZVRocmVhZCkKKyAgICAgICAgICAgICAgICBt X2RhdGFiYXNlVGhyZWFkLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcygqaSk7CisgICAgICAgIH0K KyAgICB9CisgICAgCisgICAgaWYgKG1fZGF0YWJhc2VUaHJlYWQpCisgICAgICAgIG1fZGF0YWJh c2VUaHJlYWQtPnJlcXVlc3RUZXJtaW5hdGlvbihjbGVhbnVwU3luYyk7CisgICAgZWxzZSBpZiAo Y2xlYW51cFN5bmMpCisgICAgICAgIGNsZWFudXBTeW5jLT50YXNrQ29tcGxldGVkKCk7Cit9CisK KyNlbmRpZgorCiB2b2lkIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OnByb2Nlc3NNZXNzYWdlUG9y dE1lc3NhZ2VzU29vbigpCiB7CiAgICAgcG9zdFRhc2soUHJvY2Vzc01lc3NhZ2VzU29vblRhc2s6 OmNyZWF0ZSgpKTsKSW5kZXg6IFdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgJKHJldmlz aW9uIDUzNTEyKQorKysgV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oCSh3b3Jr aW5nIGNvcHkpCkBAIC0zMywxMSArMzMsMTcgQEAKICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgog I2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4K KyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICBjbGFzcyBBY3RpdmVET01PYmplY3Q7CisjaWYgRU5B QkxFKERBVEFCQVNFKQorICAgIGNsYXNzIERhdGFiYXNlOworICAgIGNsYXNzIERhdGFiYXNlVGFz a1N5bmNocm9uaXplcjsKKyAgICBjbGFzcyBEYXRhYmFzZVRocmVhZDsKKyNlbmRpZgogICAgIGNs YXNzIERPTVRpbWVyOwogICAgIGNsYXNzIE1lc3NhZ2VQb3J0OwogICAgIGNsYXNzIFNlY3VyaXR5 T3JpZ2luOwpAQCAtNTksNiArNjUsMTkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2 aXJ0dWFsIGJvb2wgaXNEb2N1bWVudCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgICAg IHZpcnR1YWwgYm9vbCBpc1dvcmtlckNvbnRleHQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQog CisjaWYgRU5BQkxFKERBVEFCQVNFKQorICAgICAgICB2aXJ0dWFsIGJvb2wgaXNEYXRhYmFzZVJl YWRPbmx5KCkgY29uc3QgPSAwOworICAgICAgICB2aXJ0dWFsIHZvaWQgZGF0YWJhc2VFeGNlZWRl ZFF1b3RhKGNvbnN0IFN0cmluZyYgbmFtZSkgPSAwOworICAgICAgICBEYXRhYmFzZVRocmVhZCog ZGF0YWJhc2VUaHJlYWQoKTsKKyAgICAgICAgdm9pZCBzZXRIYXNPcGVuRGF0YWJhc2VzKCkgeyBt X2hhc09wZW5EYXRhYmFzZXMgPSB0cnVlOyB9CisgICAgICAgIGJvb2wgaGFzT3BlbkRhdGFiYXNl cygpIGNvbnN0IHsgcmV0dXJuIG1faGFzT3BlbkRhdGFiYXNlczsgfQorICAgICAgICB2b2lkIGFk ZE9wZW5EYXRhYmFzZShEYXRhYmFzZSopOworICAgICAgICB2b2lkIHJlbW92ZU9wZW5EYXRhYmFz ZShEYXRhYmFzZSopOworICAgICAgICAvLyBXaGVuIHRoZSBkYXRhYmFzZSBjbGVhbnVwIGlzIGRv bmUsIGNsZWFudXBTeW5jIHdpbGwgYmUgc2lnbmFsbGVkLgorICAgICAgICB2b2lkIHN0b3BEYXRh YmFzZXMoRGF0YWJhc2VUYXNrU3luY2hyb25pemVyKik7CisjZW5kaWYKKyAgICAgICAgdmlydHVh bCBib29sIGlzQ29udGV4dFRocmVhZCgpIGNvbnN0ID0gMDsKKwogICAgICAgICBjb25zdCBLVVJM JiB1cmwoKSBjb25zdCB7IHJldHVybiB2aXJ0dWFsVVJMKCk7IH0KICAgICAgICAgS1VSTCBjb21w bGV0ZVVSTChjb25zdCBTdHJpbmcmIHVybCkgY29uc3QgeyByZXR1cm4gdmlydHVhbENvbXBsZXRl VVJMKHVybCk7IH0KIApAQCAtOTcsNiArMTE2LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg ICAgICBwdWJsaWM6CiAgICAgICAgICAgICB2aXJ0dWFsIH5UYXNrKCk7CiAgICAgICAgICAgICB2 aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopID0gMDsKKyAg ICAgICAgICAgIC8vIENlcnRhaW4gdGFza3MgZ2V0IG1hcmtlZCBzcGVjaWFsbHkgc28gdGhhdCB0 aGV5IGFyZW4ndCBkaXNjYXJkZWQsIGFuZCBhcmUgZXhlY3V0ZWQsIHdoZW4gdGhlIGNvbnRleHQg aXMgc2h1dHRpbmcgZG93biBpdHMgbWVzc2FnZSBxdWV1ZS4KKyAgICAgICAgICAgIHZpcnR1YWwg Ym9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICAgICAgfTsK IAogICAgICAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soUGFzc093blB0cjxUYXNrPikgPSAwOyAv LyBFeGVjdXRlcyB0aGUgdGFzayBvbiBjb250ZXh0J3MgdGhyZWFkIGFzeW5jaHJvbm91c2x5LgpA QCAtMTI5LDYgKzE1MCwxMyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdmlydHVh bCB2b2lkIHJlZlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA9IDA7CiAgICAgICAgIHZpcnR1YWwg dm9pZCBkZXJlZlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSA9IDA7CisKKyNpZiBFTkFCTEUoREFU QUJBU0UpCisgICAgICAgIFJlZlB0cjxEYXRhYmFzZVRocmVhZD4gbV9kYXRhYmFzZVRocmVhZDsK KyAgICAgICAgYm9vbCBtX2hhc09wZW5EYXRhYmFzZXM7IC8vIFRoaXMgbmV2ZXIgY2hhbmdlcyBi YWNrIHRvIGZhbHNlLCBldmVuIGFmdGVyIHRoZSBkYXRhYmFzZSB0aHJlYWQgaXMgY2xvc2VkLgor ICAgICAgICB0eXBlZGVmIEhhc2hTZXQ8RGF0YWJhc2UqID4gRGF0YWJhc2VTZXQ7CisgICAgICAg IE93blB0cjxEYXRhYmFzZVNldD4gbV9vcGVuRGF0YWJhc2VTZXQ7CisjZW5kaWYKICAgICB9Owog CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRl ci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCShyZXZp c2lvbiA1MzUxMikKKysrIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAkod29ya2luZyBj b3B5KQpAQCAtNTY2LDcgKzU2Niw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OnN0b3BMb2FkaW5nKFVu bG9hZEV2ZW4KIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKICAgICAgICAgaWYgKGRhdGFiYXNlUG9s aWN5ID09IERhdGFiYXNlUG9saWN5U3RvcCkKLSAgICAgICAgICAgIGRvYy0+c3RvcERhdGFiYXNl cygpOworICAgICAgICAgICAgZG9jLT5zdG9wRGF0YWJhc2VzKDApOwogI2Vsc2UKICAgICBVTlVT RURfUEFSQU0oZGF0YWJhc2VQb2xpY3kpOwogI2VuZGlmCkluZGV4OiBXZWJDb3JlL3N0b3JhZ2Uv RGF0YWJhc2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAJ KHJldmlzaW9uIDUzNTEyKQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtNTMsOCArNTMsOCBAQAogI2luY2x1ZGUgIlNRTFJlc3VsdFNldC5oIgogI2lu Y2x1ZGUgIlNRTFRyYW5zYWN0aW9uQ2xpZW50LmgiCiAjaW5jbHVkZSAiU1FMVHJhbnNhY3Rpb25D b29yZGluYXRvci5oIgotI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+Ci0jZW5kaWYKKworI2Vu ZGlmIC8vIEVOQUJMRShEQVRBQkFTRSkKIAogI2lmIFVTRShKU0MpCiAjaW5jbHVkZSAiSlNET01X aW5kb3cuaCIKQEAgLTczLDYgKzczLDE4IEBAIGNvbnN0IFN0cmluZyYgRGF0YWJhc2U6OmRhdGFi YXNlSW5mb1RhYmwKIAogI2lmIEVOQUJMRShEQVRBQkFTRSkKIAorc3RhdGljIGJvb2wgaXNEYXRh YmFzZUF2YWlsYWJsZSA9IGZhbHNlOworCit2b2lkIERhdGFiYXNlOjpzZXRJc0F2YWlsYWJsZShi b29sIGF2YWlsYWJsZSkKK3sKKyAgICBpc0RhdGFiYXNlQXZhaWxhYmxlID0gYXZhaWxhYmxlOwor fQorCitib29sIERhdGFiYXNlOjppc0F2YWlsYWJsZSgpCit7CisgICAgcmV0dXJuIGlzRGF0YWJh c2VBdmFpbGFibGU7Cit9CisKIHN0YXRpYyBNdXRleCYgZ3VpZE11dGV4KCkKIHsKICAgICAvLyBO b3RlOiBXZSBkb24ndCBoYXZlIHRvIHVzZSBBdG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWMgaGVy ZSBiZWNhdXNlCkBAIC0xMjAsMzkgKzEzMiw0MSBAQCBzdGF0aWMgY29uc3QgU3RyaW5nJiBkYXRh YmFzZVZlcnNpb25LZXkoCiAKIHN0YXRpYyBpbnQgZ3VpZEZvck9yaWdpbkFuZE5hbWUoY29uc3Qg U3RyaW5nJiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgbmFtZSk7CiAKLVBhc3NSZWZQdHI8RGF0YWJh c2U+IERhdGFiYXNlOjpvcGVuRGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUsIEV4Y2VwdGlvbkNvZGUmIGUp CitQYXNzUmVmUHRyPERhdGFiYXNlPiBEYXRhYmFzZTo6b3BlbkRhdGFiYXNlKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBl eHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYgZSkKIHsKLSAgICBpZiAoIURhdGFiYXNlVHJh Y2tlcjo6dHJhY2tlcigpLmNhbkVzdGFibGlzaERhdGFiYXNlKGRvY3VtZW50LCBuYW1lLCBkaXNw bGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSkpIHsKKyAgICBpZiAoIURhdGFiYXNlVHJhY2tlcjo6dHJh Y2tlcigpLmNhbkVzdGFibGlzaERhdGFiYXNlKGNvbnRleHQsIG5hbWUsIGRpc3BsYXlOYW1lLCBl c3RpbWF0ZWRTaXplKSkgewogICAgICAgICAvLyBGSVhNRTogVGhlcmUgc2hvdWxkIGJlIGFuIGV4 Y2VwdGlvbiByYWlzZWQgaGVyZSBpbiBhZGRpdGlvbiB0byByZXR1cm5pbmcgYSBudWxsIERhdGFi YXNlIG9iamVjdC4gIFRoZSBxdWVzdGlvbiBoYXMgYmVlbiByYWlzZWQgd2l0aCB0aGUgV0hBVFdH LgotICAgICAgICBMT0coU3RvcmFnZUFQSSwgIkRhdGFiYXNlICVzIGZvciBvcmlnaW4gJXMgbm90 IGFsbG93ZWQgdG8gYmUgZXN0YWJsaXNoZWQiLCBuYW1lLmFzY2lpKCkuZGF0YSgpLCBkb2N1bWVu dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKS5hc2NpaSgpLmRhdGEoKSk7CisgICAgICAg IExPRyhTdG9yYWdlQVBJLCAiRGF0YWJhc2UgJXMgZm9yIG9yaWdpbiAlcyBub3QgYWxsb3dlZCB0 byBiZSBlc3RhYmxpc2hlZCIsIG5hbWUuYXNjaWkoKS5kYXRhKCksIGNvbnRleHQtPnNlY3VyaXR5 T3JpZ2luKCktPnRvU3RyaW5nKCkuYXNjaWkoKS5kYXRhKCkpOwogICAgICAgICByZXR1cm4gMDsK ICAgICB9CiAKLSAgICBSZWZQdHI8RGF0YWJhc2U+IGRhdGFiYXNlID0gYWRvcHRSZWYobmV3IERh dGFiYXNlKGRvY3VtZW50LCBuYW1lLCBleHBlY3RlZFZlcnNpb24sIGRpc3BsYXlOYW1lLCBlc3Rp bWF0ZWRTaXplKSk7CisgICAgUmVmUHRyPERhdGFiYXNlPiBkYXRhYmFzZSA9IGFkb3B0UmVmKG5l dyBEYXRhYmFzZShjb250ZXh0LCBuYW1lLCBleHBlY3RlZFZlcnNpb24sIGRpc3BsYXlOYW1lLCBl c3RpbWF0ZWRTaXplKSk7CiAKICAgICBpZiAoIWRhdGFiYXNlLT5vcGVuQW5kVmVyaWZ5VmVyc2lv bihlKSkgewogICAgICAgICBMT0coU3RvcmFnZUFQSSwgIkZhaWxlZCB0byBvcGVuIGFuZCB2ZXJp ZnkgdmVyc2lvbiAoZXhwZWN0ZWQgJXMpIG9mIGRhdGFiYXNlICVzIiwgZXhwZWN0ZWRWZXJzaW9u LmFzY2lpKCkuZGF0YSgpLCBkYXRhYmFzZS0+ZGF0YWJhc2VEZWJ1Z05hbWUoKS5hc2NpaSgpLmRh dGEoKSk7Ci0gICAgICAgIGRvY3VtZW50LT5yZW1vdmVPcGVuRGF0YWJhc2UoZGF0YWJhc2UuZ2V0 KCkpOworICAgICAgICBjb250ZXh0LT5yZW1vdmVPcGVuRGF0YWJhc2UoZGF0YWJhc2UuZ2V0KCkp OwogICAgICAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5yZW1vdmVPcGVuRGF0YWJhc2Uo ZGF0YWJhc2UuZ2V0KCkpOwogICAgICAgICByZXR1cm4gMDsKICAgICB9CiAKLSAgICBEYXRhYmFz ZVRyYWNrZXI6OnRyYWNrZXIoKS5zZXREYXRhYmFzZURldGFpbHMoZG9jdW1lbnQtPnNlY3VyaXR5 T3JpZ2luKCksIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKTsKLQotICAgIGRvY3Vt ZW50LT5zZXRIYXNPcGVuRGF0YWJhc2VzKCk7CisgICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2Vy KCkuc2V0RGF0YWJhc2VEZXRhaWxzKGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCksIG5hbWUsIGRp c3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKTsKIAorICAgIGNvbnRleHQtPnNldEhhc09wZW5EYXRh YmFzZXMoKTsKICNpZiBFTkFCTEUoSU5TUEVDVE9SKQotICAgIGlmIChQYWdlKiBwYWdlID0gZG9j dW1lbnQtPmZyYW1lKCktPnBhZ2UoKSkKLSAgICAgICAgcGFnZS0+aW5zcGVjdG9yQ29udHJvbGxl cigpLT5kaWRPcGVuRGF0YWJhc2UoZGF0YWJhc2UuZ2V0KCksIGRvY3VtZW50LT5zZWN1cml0eU9y aWdpbigpLT5ob3N0KCksIG5hbWUsIGV4cGVjdGVkVmVyc2lvbik7CisgICAgaWYgKGNvbnRleHQt PmlzRG9jdW1lbnQoKSkgeworICAgICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBzdGF0aWNfY2Fz dDxEb2N1bWVudCo+KGNvbnRleHQpOworICAgICAgICBpZiAoUGFnZSogcGFnZSA9IGRvY3VtZW50 LT5wYWdlKCkpCisgICAgICAgICAgICBwYWdlLT5pbnNwZWN0b3JDb250cm9sbGVyKCktPmRpZE9w ZW5EYXRhYmFzZShkYXRhYmFzZS5nZXQoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+aG9z dCgpLCBuYW1lLCBleHBlY3RlZFZlcnNpb24pOworICAgIH0KICNlbmRpZgogCiAgICAgcmV0dXJu IGRhdGFiYXNlOwogfQogCi1EYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZXhwZWN0ZWRWZXJzaW9uLCBjb25zdCBT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCitEYXRhYmFz ZTo6RGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5n JiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVjdGVkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNw bGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogICAgIDogbV90cmFuc2FjdGlv bkluUHJvZ3Jlc3MoZmFsc2UpCiAgICAgLCBtX2lzVHJhbnNhY3Rpb25RdWV1ZUVuYWJsZWQodHJ1 ZSkKLSAgICAsIG1fZG9jdW1lbnQoZG9jdW1lbnQpCisgICAgLCBtX3NjcmlwdEV4ZWN1dGlvbkNv bnRleHQoY29udGV4dCkKICAgICAsIG1fbmFtZShuYW1lLmNyb3NzVGhyZWFkU3RyaW5nKCkpCiAg ICAgLCBtX2d1aWQoMCkKICAgICAsIG1fZXhwZWN0ZWRWZXJzaW9uKGV4cGVjdGVkVmVyc2lvbi5j cm9zc1RocmVhZFN0cmluZygpKQpAQCAtMTYyLDE2ICsxNzYsMTUgQEAgRGF0YWJhc2U6OkRhdGFi YXNlKERvY3VtZW50KiBkb2N1bWVudCwgYwogICAgICwgbV9zdG9wcGVkKGZhbHNlKQogICAgICwg bV9vcGVuZWQoZmFsc2UpCiB7Ci0gICAgQVNTRVJUKGRvY3VtZW50KTsKLSAgICBtX21haW5UaHJl YWRTZWN1cml0eU9yaWdpbiA9IGRvY3VtZW50LT5zZWN1cml0eU9yaWdpbigpOworICAgIEFTU0VS VChtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuZ2V0KCkpOworICAgIG1fbWFpblRocmVhZFNlY3Vy aXR5T3JpZ2luID0gbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5zZWN1cml0eU9yaWdpbigpOwog ICAgIG1fZGF0YWJhc2VUaHJlYWRTZWN1cml0eU9yaWdpbiA9IG1fbWFpblRocmVhZFNlY3VyaXR5 T3JpZ2luLT50aHJlYWRzYWZlQ29weSgpOwotCiAgICAgaWYgKG1fbmFtZS5pc051bGwoKSkKICAg ICAgICAgbV9uYW1lID0gIiI7CiAKICAgICBTY3JpcHRDb250cm9sbGVyOjppbml0aWFsaXplVGhy ZWFkaW5nKCk7CiAKLSAgICBtX2d1aWQgPSBndWlkRm9yT3JpZ2luQW5kTmFtZShtX21haW5UaHJl YWRTZWN1cml0eU9yaWdpbi0+dG9TdHJpbmcoKSwgbmFtZSk7CisgICAgbV9ndWlkID0gZ3VpZEZv ck9yaWdpbkFuZE5hbWUoc2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSwgbmFtZSk7CiAKICAg ICB7CiAgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihndWlkTXV0ZXgoKSk7CkBAIC0xODUsMjgg KzE5OCw0MCBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjCiAgICAg ICAgIGhhc2hTZXQtPmFkZCh0aGlzKTsKICAgICB9CiAKLSAgICBBU1NFUlQobV9kb2N1bWVudC0+ ZGF0YWJhc2VUaHJlYWQoKSk7Ci0KLSAgICBtX2ZpbGVuYW1lID0gRGF0YWJhc2VUcmFja2VyOjp0 cmFja2VyKCkuZnVsbFBhdGhGb3JEYXRhYmFzZShtX21haW5UaHJlYWRTZWN1cml0eU9yaWdpbi5n ZXQoKSwgbV9uYW1lKTsKKyAgICBBU1NFUlQobV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRh YmFzZVRocmVhZCgpKTsKKyAgICBtX2ZpbGVuYW1lID0gRGF0YWJhc2VUcmFja2VyOjp0cmFja2Vy KCkuZnVsbFBhdGhGb3JEYXRhYmFzZShzZWN1cml0eU9yaWdpbigpLCBtX25hbWUpOwogCiAgICAg RGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkuYWRkT3BlbkRhdGFiYXNlKHRoaXMpOwotICAgIG1f ZG9jdW1lbnQtPmFkZE9wZW5EYXRhYmFzZSh0aGlzKTsKKyAgICBjb250ZXh0LT5hZGRPcGVuRGF0 YWJhc2UodGhpcyk7CiB9CiAKLXN0YXRpYyB2b2lkIGRlcmVmRG9jdW1lbnQodm9pZCogZG9jdW1l bnQpCi17Ci0gICAgc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihkb2N1bWVudCktPmRlcmVmKCk7Ci19 CitjbGFzcyBEZXJlZkNvbnRleHRUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPERlcmVmQ29udGV4dFRhc2s+ IGNyZWF0ZSgpCisgICAgeworICAgICAgICByZXR1cm4gbmV3IERlcmVmQ29udGV4dFRhc2soKTsK KyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY29udGV4dCkKKyAgICB7CisgICAgICAgIGNvbnRleHQtPmRlcmVmKCk7CisgICAgfQor CisgICAgdmlydHVhbCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9 Cit9OwogCiBEYXRhYmFzZTo6fkRhdGFiYXNlKCkKIHsKLSAgICAvLyBEZXJlZiBtX2RvY3VtZW50 IG9uIHRoZSBtYWluIHRocmVhZC4KLSAgICBjYWxsT25NYWluVGhyZWFkKGRlcmVmRG9jdW1lbnQs IG1fZG9jdW1lbnQucmVsZWFzZSgpLnJlbGVhc2VSZWYoKSk7CisgICAgLy8gVGhlIHJlZmVyZW5j ZSB0byB0aGUgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCBuZWVkcyB0byBiZSBjbGVhcmVkIG9uIHRo ZSBKYXZhU2NyaXB0IHRocmVhZC4gIElmIHdlJ3JlIG9uIHRoYXQgdGhyZWFkIGFscmVhZHksIHdl IGNhbiBqdXN0IGxldCB0aGUgUmVmUHRyJ3MgZGVzdHJ1Y3Rpb24gZG8gdGhlIGRlcmVmZmluZy4K KyAgICBpZiAoIW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+aXNDb250ZXh0VGhyZWFkKCkpIHsK KyAgICAgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5wb3N0VGFzayhEZXJlZkNvbnRleHRU YXNrOjpjcmVhdGUoKSk7CisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC5yZWxlYXNl KCkucmVsZWFzZVJlZigpOworICAgIH0KIH0KIAogYm9vbCBEYXRhYmFzZTo6b3BlbkFuZFZlcmlm eVZlcnNpb24oRXhjZXB0aW9uQ29kZSYgZSkKIHsKLSAgICBpZiAoIW1fZG9jdW1lbnQtPmRhdGFi YXNlVGhyZWFkKCkpCisgICAgaWYgKCFtX3NjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNl VGhyZWFkKCkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBtX2RhdGFiYXNlQXV0aG9yaXpl ciA9IERhdGFiYXNlQXV0aG9yaXplcjo6Y3JlYXRlKCk7CiAKQEAgLTIxNCw3ICsyMzksNyBAQCBi b29sIERhdGFiYXNlOjpvcGVuQW5kVmVyaWZ5VmVyc2lvbihFeGNlCiAgICAgRGF0YWJhc2VUYXNr U3luY2hyb25pemVyIHN5bmNocm9uaXplcjsKICAgICBPd25QdHI8RGF0YWJhc2VPcGVuVGFzaz4g dGFzayA9IERhdGFiYXNlT3BlblRhc2s6OmNyZWF0ZSh0aGlzLCAmc3luY2hyb25pemVyLCBlLCBz dWNjZXNzKTsKIAotICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1t ZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0 LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkp OwogICAgIHN5bmNocm9uaXplci53YWl0Rm9yVGFza0NvbXBsZXRpb24oKTsKIAogICAgIHJldHVy biBzdWNjZXNzOwpAQCAtMzA5LDQzICszMzQsNjIgQEAgYm9vbCBEYXRhYmFzZTo6dmVyc2lvbk1h dGNoZXNFeHBlY3RlZCgpIAogCiB2b2lkIERhdGFiYXNlOjptYXJrQXNEZWxldGVkQW5kQ2xvc2Uo KQogewotICAgIGlmIChtX2RlbGV0ZWQgfHwgIW1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkp CisgICAgaWYgKG1fZGVsZXRlZCB8fCAhbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFz ZVRocmVhZCgpKQogICAgICAgICByZXR1cm47CiAKICAgICBMT0coU3RvcmFnZUFQSSwgIk1hcmtp bmcgJXMgKCVwKSBhcyBkZWxldGVkIiwgc3RyaW5nSWRlbnRpZmllcigpLmFzY2lpKCkuZGF0YSgp LCB0aGlzKTsKICAgICBtX2RlbGV0ZWQgPSB0cnVlOwogCi0gICAgaWYgKG1fZG9jdW1lbnQtPmRh dGFiYXNlVGhyZWFkKCktPnRlcm1pbmF0aW9uUmVxdWVzdGVkKCkpIHsKKyAgICBpZiAobV9zY3Jp cHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT50ZXJtaW5hdGlvblJlcXVlc3Rl ZCgpKSB7CiAgICAgICAgIExPRyhTdG9yYWdlQVBJLCAiRGF0YWJhc2UgaGFuZGxlICVwIGlzIG9u IGEgdGVybWluYXRlZCBEYXRhYmFzZVRocmVhZCwgY2Fubm90IGJlIG1hcmtlZCBmb3Igbm9ybWFs IGNsb3N1cmVcbiIsIHRoaXMpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCi0gICAgbV9kb2N1 bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3ModGhpcyk7Cisg ICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT51bnNjaGVkdWxl RGF0YWJhc2VUYXNrcyh0aGlzKTsKIAogICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBzeW5j aHJvbml6ZXI7CiAgICAgT3duUHRyPERhdGFiYXNlQ2xvc2VUYXNrPiB0YXNrID0gRGF0YWJhc2VD bG9zZVRhc2s6OmNyZWF0ZSh0aGlzLCAmc3luY2hyb25pemVyKTsKIAotICAgIG1fZG9jdW1lbnQt PmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2UoKSk7 CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVs ZUltbWVkaWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOwogICAgIHN5bmNocm9uaXplci53YWl0Rm9y VGFza0NvbXBsZXRpb24oKTsKIH0KIAotc3RhdGljIHZvaWQgZG9jdW1lbnRSZW1vdmVPcGVuRGF0 YWJhc2Uodm9pZCogY29udGV4dCkKLXsKLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwotICAg IERhdGFiYXNlKiBkYXRhYmFzZSA9IHN0YXRpY19jYXN0PERhdGFiYXNlKj4oY29udGV4dCk7Ci0g ICAgZGF0YWJhc2UtPmRvY3VtZW50KCktPnJlbW92ZU9wZW5EYXRhYmFzZShkYXRhYmFzZSk7Ci0g ICAgZGF0YWJhc2UtPmRlcmVmKCk7Ci19CitjbGFzcyBDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNl VGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAg ICBzdGF0aWMgUGFzc093blB0cjxDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzaz4gY3JlYXRl KFBhc3NSZWZQdHI8RGF0YWJhc2U+IGRhdGFiYXNlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG5l dyBDb250ZXh0UmVtb3ZlT3BlbkRhdGFiYXNlVGFzayhkYXRhYmFzZSk7CisgICAgfQorCisgICAg dmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQp CisgICAgeworICAgICAgICBjb250ZXh0LT5yZW1vdmVPcGVuRGF0YWJhc2UobV9kYXRhYmFzZS5n ZXQoKSk7CisgICAgICAgIERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnJlbW92ZU9wZW5EYXRh YmFzZShtX2RhdGFiYXNlLmdldCgpKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGVh bnVwVGFzaygpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKworcHJpdmF0ZToKKyAgICBDb250ZXh0 UmVtb3ZlT3BlbkRhdGFiYXNlVGFzayhQYXNzUmVmUHRyPERhdGFiYXNlPiBkYXRhYmFzZSkKKyAg ICAgICAgOiBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8 RGF0YWJhc2U+IG1fZGF0YWJhc2U7Cit9OwogCiB2b2lkIERhdGFiYXNlOjpjbG9zZSgpCiB7Cisg ICAgUmVmUHRyPERhdGFiYXNlPiBwcm90ZWN0ID0gdGhpczsKKwogICAgIGlmICghbV9vcGVuZWQp CiAgICAgICAgIHJldHVybjsKIAotICAgIEFTU0VSVChtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVh ZCgpKTsKLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IGRvY3VtZW50KCktPmRhdGFiYXNl VGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChtX3NjcmlwdEV4ZWN1dGlvbkNv bnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpOworICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0g bV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgp KTsKICAgICBtX3NxbGl0ZURhdGFiYXNlLmNsb3NlKCk7Ci0gICAgbV9kb2N1bWVudC0+ZGF0YWJh c2VUaHJlYWQoKS0+cmVjb3JkRGF0YWJhc2VDbG9zZWQodGhpcyk7CisgICAgLy8gTXVzdCByZWYo KSBiZWZvcmUgY2FsbGluZyBkYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNsb3NlZCgp LgorICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKS0+cmVjb3Jk RGF0YWJhc2VDbG9zZWQodGhpcyk7CiAgICAgbV9vcGVuZWQgPSBmYWxzZTsKIAogICAgIHsKQEAg LTM2MiwxMSArNDA2LDggQEAgdm9pZCBEYXRhYmFzZTo6Y2xvc2UoKQogICAgICAgICB9CiAgICAg fQogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKS0+dW5zY2hlZHVsZURhdGFiYXNl VGFza3ModGhpcyk7Ci0KLSAgICBEYXRhYmFzZVRyYWNrZXI6OnRyYWNrZXIoKS5yZW1vdmVPcGVu RGF0YWJhc2UodGhpcyk7Ci0gICAgcmVmKCk7ICAvLyBkZXJlZigpIGNhbGxlZCBpbiBkb2N1bWVu dFJlbW92ZU9wZW5EYXRhYmFzZSgpCi0gICAgY2FsbE9uTWFpblRocmVhZChkb2N1bWVudFJlbW92 ZU9wZW5EYXRhYmFzZSwgdGhpcyk7CisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5kYXRh YmFzZVRocmVhZCgpLT51bnNjaGVkdWxlRGF0YWJhc2VUYXNrcyh0aGlzKTsKKyAgICBtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQtPnBvc3RUYXNrKENvbnRleHRSZW1vdmVPcGVuRGF0YWJhc2VUYXNr OjpjcmVhdGUodGhpcykpOwogfQogCiB2b2lkIERhdGFiYXNlOjpzdG9wKCkKQEAgLTUzMiw4ICs1 NzMsOCBAQCBib29sIERhdGFiYXNlOjpwZXJmb3JtT3BlbkFuZFZlcmlmeShFeGNlCiAgICAgLy8g QWxsIGNoZWNrcyBwYXNzZWQgYW5kIHdlIHN0aWxsIGhhdmUgYSBoYW5kbGUgdG8gdGhpcyBkYXRh YmFzZSBmaWxlLgogICAgIC8vIE1ha2Ugc3VyZSBEYXRhYmFzZVRocmVhZCBjbG9zZXMgaXQgd2hl biBEYXRhYmFzZVRocmVhZCBnb2VzIGF3YXkuCiAgICAgbV9vcGVuZWQgPSB0cnVlOwotICAgIGlm IChtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpKQotICAgICAgICBtX2RvY3VtZW50LT5kYXRh YmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZU9wZW4odGhpcyk7CisgICAgaWYgKG1fc2NyaXB0 RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkKKyAgICAgICAgbV9zY3JpcHRFeGVj dXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZU9wZW4odGhpcyk7 CiAKICAgICByZXR1cm4gdHJ1ZTsKIH0KQEAgLTU2NywzMiArNjA4LDUyIEBAIHZvaWQgRGF0YWJh c2U6OnNjaGVkdWxlVHJhbnNhY3Rpb24oKQogICAgICAgICBtX3RyYW5zYWN0aW9uUXVldWUucmVt b3ZlRmlyc3QoKTsKICAgICB9CiAKLSAgICBpZiAodHJhbnNhY3Rpb24gJiYgbV9kb2N1bWVudC0+ ZGF0YWJhc2VUaHJlYWQoKSkgeworICAgIGlmICh0cmFuc2FjdGlvbiAmJiBtX3NjcmlwdEV4ZWN1 dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCkpIHsKICAgICAgICAgT3duUHRyPERhdGFiYXNl VHJhbnNhY3Rpb25UYXNrPiB0YXNrID0gRGF0YWJhc2VUcmFuc2FjdGlvblRhc2s6OmNyZWF0ZSh0 cmFuc2FjdGlvbik7CiAgICAgICAgIExPRyhTdG9yYWdlQVBJLCAiU2NoZWR1bGluZyBEYXRhYmFz ZVRyYW5zYWN0aW9uVGFzayAlcCBmb3IgdHJhbnNhY3Rpb24gJXBcbiIsIHRhc2suZ2V0KCksIHRh c2stPnRyYW5zYWN0aW9uKCkpOwogICAgICAgICBtX3RyYW5zYWN0aW9uSW5Qcm9ncmVzcyA9IHRy dWU7Ci0gICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0 YXNrLnJlbGVhc2UoKSk7CisgICAgICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJh c2VUaHJlYWQoKS0+c2NoZWR1bGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKICAgICB9IGVsc2UKICAg ICAgICAgbV90cmFuc2FjdGlvbkluUHJvZ3Jlc3MgPSBmYWxzZTsKIH0KIAogdm9pZCBEYXRhYmFz ZTo6c2NoZWR1bGVUcmFuc2FjdGlvblN0ZXAoU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uLCBi b29sIGltbWVkaWF0ZWx5KQogewotICAgIGlmICghbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQo KSkKKyAgICBpZiAoIW1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0YWJhc2VUaHJlYWQoKSkK ICAgICAgICAgcmV0dXJuOwogCiAgICAgT3duUHRyPERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrPiB0 YXNrID0gRGF0YWJhc2VUcmFuc2FjdGlvblRhc2s6OmNyZWF0ZSh0cmFuc2FjdGlvbik7CiAgICAg TE9HKFN0b3JhZ2VBUEksICJTY2hlZHVsaW5nIERhdGFiYXNlVHJhbnNhY3Rpb25UYXNrICVwIGZv ciB0aGUgdHJhbnNhY3Rpb24gc3RlcFxuIiwgdGFzay5nZXQoKSk7CiAgICAgaWYgKGltbWVkaWF0 ZWx5KQotICAgICAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hlZHVsZUltbWVk aWF0ZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0YXNrLnJlbGVhc2Uo KSk7CiAgICAgZWxzZQotICAgICAgICBtX2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT5zY2hl ZHVsZVRhc2sodGFzay5yZWxlYXNlKCkpOworICAgICAgICBtX3NjcmlwdEV4ZWN1dGlvbkNvbnRl eHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlVGFzayh0YXNrLnJlbGVhc2UoKSk7CiB9CiAK K2NsYXNzIERlbGl2ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPERlbGl2ZXJQ ZW5kaW5nQ2FsbGJhY2tUYXNrPiBjcmVhdGUoUGFzc1JlZlB0cjxTUUxUcmFuc2FjdGlvbj4gdHJh bnNhY3Rpb24pCisgICAgeworICAgICAgICByZXR1cm4gbmV3IERlbGl2ZXJQZW5kaW5nQ2FsbGJh Y2tUYXNrKHRyYW5zYWN0aW9uKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRh c2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopCisgICAgeworICAgICAgICBtX3RyYW5zYWN0aW9u LT5wZXJmb3JtUGVuZGluZ0NhbGxiYWNrKCk7CisgICAgfQorCitwcml2YXRlOgorICAgIERlbGl2 ZXJQZW5kaW5nQ2FsbGJhY2tUYXNrKFBhc3NSZWZQdHI8U1FMVHJhbnNhY3Rpb24+IHRyYW5zYWN0 aW9uKQorICAgICAgICA6IG1fdHJhbnNhY3Rpb24odHJhbnNhY3Rpb24pCisgICAgeworICAgIH0K KworICAgIFJlZlB0cjxTUUxUcmFuc2FjdGlvbj4gbV90cmFuc2FjdGlvbjsKK307CisKIHZvaWQg RGF0YWJhc2U6OnNjaGVkdWxlVHJhbnNhY3Rpb25DYWxsYmFjayhTUUxUcmFuc2FjdGlvbiogdHJh bnNhY3Rpb24pCiB7Ci0gICAgdHJhbnNhY3Rpb24tPnJlZigpOwotICAgIGNhbGxPbk1haW5UaHJl YWQoZGVsaXZlclBlbmRpbmdDYWxsYmFjaywgdHJhbnNhY3Rpb24pOworICAgIG1fc2NyaXB0RXhl Y3V0aW9uQ29udGV4dC0+cG9zdFRhc2soRGVsaXZlclBlbmRpbmdDYWxsYmFja1Rhc2s6OmNyZWF0 ZSh0cmFuc2FjdGlvbikpOwogfQogCiBWZWN0b3I8U3RyaW5nPiBEYXRhYmFzZTo6cGVyZm9ybUdl dFRhYmxlTmFtZXMoKQpAQCAtNjI2LDEyICs2ODcsMTIgQEAgVmVjdG9yPFN0cmluZz4gRGF0YWJh c2U6OnBlcmZvcm1HZXRUYWJsZQogCiBTUUxUcmFuc2FjdGlvbkNsaWVudCogRGF0YWJhc2U6OnRy YW5zYWN0aW9uQ2xpZW50KCkgY29uc3QKIHsKLSAgICByZXR1cm4gbV9kb2N1bWVudC0+ZGF0YWJh c2VUaHJlYWQoKS0+dHJhbnNhY3Rpb25DbGllbnQoKTsKKyAgICByZXR1cm4gbV9zY3JpcHRFeGVj dXRpb25Db250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNsaWVudCgpOwogfQog CiBTUUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKiBEYXRhYmFzZTo6dHJhbnNhY3Rpb25Db29yZGlu YXRvcigpIGNvbnN0CiB7Ci0gICAgcmV0dXJuIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkt PnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKTsKKyAgICByZXR1cm4gbV9zY3JpcHRFeGVjdXRpb25D b250ZXh0LT5kYXRhYmFzZVRocmVhZCgpLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCk7CiB9CiAK IFN0cmluZyBEYXRhYmFzZTo6dmVyc2lvbigpIGNvbnN0CkBAIC02NDIsMjUgKzcwMywxOCBAQCBT dHJpbmcgRGF0YWJhc2U6OnZlcnNpb24oKSBjb25zdAogICAgIHJldHVybiBndWlkVG9WZXJzaW9u TWFwKCkuZ2V0KG1fZ3VpZCkudGhyZWFkc2FmZUNvcHkoKTsKIH0KIAotdm9pZCBEYXRhYmFzZTo6 ZGVsaXZlclBlbmRpbmdDYWxsYmFjayh2b2lkKiBjb250ZXh0KQotewotICAgIFNRTFRyYW5zYWN0 aW9uKiB0cmFuc2FjdGlvbiA9IHN0YXRpY19jYXN0PFNRTFRyYW5zYWN0aW9uKj4oY29udGV4dCk7 Ci0gICAgdHJhbnNhY3Rpb24tPnBlcmZvcm1QZW5kaW5nQ2FsbGJhY2soKTsKLSAgICB0cmFuc2Fj dGlvbi0+ZGVyZWYoKTsgLy8gV2FzIHJlZidkIGluIHNjaGVkdWxlVHJhbnNhY3Rpb25DYWxsYmFj aygpLgotfQotCiBWZWN0b3I8U3RyaW5nPiBEYXRhYmFzZTo6dGFibGVOYW1lcygpCiB7CiAgICAg Ly8gRklYTUU6IE5vdCB1c2luZyB0aHJlYWRzYWZlQ29weSBvbiB0aGVzZSBzdHJpbmdzIGxvb2tz IG9rIHNpbmNlIHRocmVhZHMgdGFrZSBzdHJpY3QgdHVybnMKICAgICAvLyBpbiBkZWFsaW5nIHdp dGggdGhlbS4gSG93ZXZlciwgaWYgdGhlIGNvZGUgY2hhbmdlcywgdGhpcyBtYXkgbm90IGJlIHRy dWUgYW55bW9yZS4KICAgICBWZWN0b3I8U3RyaW5nPiByZXN1bHQ7Ci0gICAgaWYgKCFtX2RvY3Vt ZW50LT5kYXRhYmFzZVRocmVhZCgpKQorICAgIGlmICghbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0 LT5kYXRhYmFzZVRocmVhZCgpKQogICAgICAgICByZXR1cm4gcmVzdWx0OwogCiAgICAgRGF0YWJh c2VUYXNrU3luY2hyb25pemVyIHN5bmNocm9uaXplcjsKICAgICBPd25QdHI8RGF0YWJhc2VUYWJs ZU5hbWVzVGFzaz4gdGFzayA9IERhdGFiYXNlVGFibGVOYW1lc1Rhc2s6OmNyZWF0ZSh0aGlzLCAm c3luY2hyb25pemVyLCByZXN1bHQpOwogCi0gICAgbV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQo KS0+c2NoZWR1bGVJbW1lZGlhdGVUYXNrKHRhc2sucmVsZWFzZSgpKTsKKyAgICBtX3NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQtPmRhdGFiYXNlVGhyZWFkKCktPnNjaGVkdWxlSW1tZWRpYXRlVGFzayh0 YXNrLnJlbGVhc2UoKSk7CiAgICAgc3luY2hyb25pemVyLndhaXRGb3JUYXNrQ29tcGxldGlvbigp OwogCiAgICAgcmV0dXJuIHJlc3VsdDsKQEAgLTY3Niw5ICs3MzAsOSBAQCB2b2lkIERhdGFiYXNl OjpzZXRFeHBlY3RlZFZlcnNpb24oY29uc3QgCiAKIFNlY3VyaXR5T3JpZ2luKiBEYXRhYmFzZTo6 c2VjdXJpdHlPcmlnaW4oKSBjb25zdAogewotICAgIGlmIChpc01haW5UaHJlYWQoKSkKKyAgICBp ZiAoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRUaHJlYWQoKSkKICAgICAgICAg cmV0dXJuIG1fbWFpblRocmVhZFNlY3VyaXR5T3JpZ2luLmdldCgpOwotICAgIGlmIChjdXJyZW50 VGhyZWFkKCkgPT0gZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSkK KyAgICBpZiAoY3VycmVudFRocmVhZCgpID09IG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+ZGF0 YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSkKICAgICAgICAgcmV0dXJuIG1fZGF0YWJhc2VU aHJlYWRTZWN1cml0eU9yaWdpbi5nZXQoKTsKICAgICByZXR1cm4gMDsKIH0KQEAgLTcwNiw2ICs3 NjAsNiBAQCBTdHJpbmcgRGF0YWJhc2U6OmZpbGVOYW1lKCkgY29uc3QKICAgICByZXR1cm4gbV9m aWxlbmFtZS50aHJlYWRzYWZlQ29weSgpOwogfQogCi0jZW5kaWYKKyNlbmRpZiAvLyBFTkFCTEUo REFUQUJBU0UpCiAKLX0KK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvc3Rv cmFnZS9EYXRhYmFzZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5o CShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5oCSh3b3JraW5n IGNvcHkpCkBAIC01Miw3ICs1Miw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRGF0 YWJhc2VBdXRob3JpemVyOwogY2xhc3MgRGF0YWJhc2VUaHJlYWQ7Ci1jbGFzcyBEb2N1bWVudDsK K2NsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CiBjbGFzcyBTUUxSZXN1bHRTZXQ7CiBjbGFz cyBTUUxUcmFuc2FjdGlvbkNhbGxiYWNrOwogY2xhc3MgU1FMVHJhbnNhY3Rpb25DbGllbnQ7CkBA IC02NywxMCArNjcsMTMgQEAgY2xhc3MgRGF0YWJhc2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJl ZAogICAgIGZyaWVuZCBjbGFzcyBTUUxTdGF0ZW1lbnQ7CiAgICAgZnJpZW5kIGNsYXNzIFNRTFRy YW5zYWN0aW9uOwogcHVibGljOgorICAgIHN0YXRpYyB2b2lkIHNldElzQXZhaWxhYmxlKGJvb2wp OworICAgIHN0YXRpYyBib29sIGlzQXZhaWxhYmxlKCk7CisKICAgICB+RGF0YWJhc2UoKTsKIAog Ly8gRGlyZWN0IHN1cHBvcnQgZm9yIHRoZSBET00gQVBJCi0gICAgc3RhdGljIFBhc3NSZWZQdHI8 RGF0YWJhc2U+IG9wZW5EYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYg bmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sIGNvbnN0IFN0cmluZyYgZGlzcGxh eU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSwgRXhjZXB0aW9uQ29kZSYpOworICAg IHN0YXRpYyBQYXNzUmVmUHRyPERhdGFiYXNlPiBvcGVuRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGV4cGVj dGVkVmVyc2lvbiwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3Rp bWF0ZWRTaXplLCBFeGNlcHRpb25Db2RlJik7CiAgICAgU3RyaW5nIHZlcnNpb24oKSBjb25zdDsK ICAgICB2b2lkIGNoYW5nZVZlcnNpb24oY29uc3QgU3RyaW5nJiBvbGRWZXJzaW9uLCBjb25zdCBT dHJpbmcmIG5ld1ZlcnNpb24sCiAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8U1FM VHJhbnNhY3Rpb25DYWxsYmFjaz4gY2FsbGJhY2ssIFBhc3NSZWZQdHI8U1FMVHJhbnNhY3Rpb25F cnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrLApAQCAtODcsNyArOTAsNyBAQCBwdWJsaWM6CiAK ICAgICBWZWN0b3I8U3RyaW5nPiB0YWJsZU5hbWVzKCk7CiAKLSAgICBEb2N1bWVudCogZG9jdW1l bnQoKSBjb25zdCB7IHJldHVybiBtX2RvY3VtZW50LmdldCgpOyB9CisgICAgU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIGNvbnN0IHsgcmV0dXJuIG1fc2Ny aXB0RXhlY3V0aW9uQ29udGV4dC5nZXQoKTsgfQogICAgIFNlY3VyaXR5T3JpZ2luKiBzZWN1cml0 eU9yaWdpbigpIGNvbnN0OwogICAgIFN0cmluZyBzdHJpbmdJZGVudGlmaWVyKCkgY29uc3Q7CiAg ICAgU3RyaW5nIGRpc3BsYXlOYW1lKCkgY29uc3Q7CkBAIC0xMjMsOCArMTI2LDkgQEAgcHVibGlj OgogICAgIFNRTFRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3Io KSBjb25zdDsKIAogcHJpdmF0ZToKLSAgICBEYXRhYmFzZShEb2N1bWVudCogZG9jdW1lbnQsIGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZlcnNpb24sCi0gICAgICAg ICAgICAgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRT aXplKTsKKyAgICBEYXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25z dCBTdHJpbmcmIG5hbWUsCisgICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBleHBlY3RlZFZlcnNp b24sIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsCisgICAgICAgICAgICAgdW5zaWduZWQgbG9u ZyBlc3RpbWF0ZWRTaXplKTsKIAogICAgIGJvb2wgb3BlbkFuZFZlcmlmeVZlcnNpb24oRXhjZXB0 aW9uQ29kZSYpOwogCkBAIC0xMzksNyArMTQzLDcgQEAgcHJpdmF0ZToKIAogICAgIHN0YXRpYyB2 b2lkIGRlbGl2ZXJQZW5kaW5nQ2FsbGJhY2sodm9pZCopOwogCi0gICAgUmVmUHRyPERvY3VtZW50 PiBtX2RvY3VtZW50OworICAgIFJlZlB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0PiBtX3Njcmlw dEV4ZWN1dGlvbkNvbnRleHQ7CiAgICAgUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBtX21haW5UaHJl YWRTZWN1cml0eU9yaWdpbjsKICAgICBSZWZQdHI8U2VjdXJpdHlPcmlnaW4+IG1fZGF0YWJhc2VU aHJlYWRTZWN1cml0eU9yaWdpbjsKICAgICBTdHJpbmcgbV9uYW1lOwpJbmRleDogV2ViQ29yZS9z dG9yYWdlL0RhdGFiYXNlVGFzay5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRh YmFzZVRhc2suaAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VU YXNrLmgJKHdvcmtpbmcgY29weSkKQEAgLTUwLDE2ICs1MCwxNSBAQCBjbGFzcyBWZXJzaW9uQ2hh bmdlQ2FsbGJhY2s7CiAvLyBDYW4gYmUgdXNlZCB0byB3YWl0IHVudGlsIERhdGFiYXNlVGFzayBp cyBjb21wbGV0ZWQuCiAvLyBIYXMgdG8gYmUgcGFzc2VkIGludG8gRGF0YWJhc2VUYXNrOjpjcmVh dGUgdG8gYmUgYXNzb2NpYXRlZCB3aXRoIHRoZSB0YXNrLgogY2xhc3MgRGF0YWJhc2VUYXNrU3lu Y2hyb25pemVyIDogcHVibGljIE5vbmNvcHlhYmxlIHsKLSAgICBmcmllbmQgY2xhc3MgRGF0YWJh c2VUYXNrOwogcHVibGljOgogICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplcigpOwogCiAgICAg Ly8gQ2FsbGVkIGZyb20gbWFpbiB0aHJlYWQgdG8gd2FpdCB1bnRpbCB0YXNrIGlzIGNvbXBsZXRl ZC4KICAgICB2b2lkIHdhaXRGb3JUYXNrQ29tcGxldGlvbigpOwogCi1wcml2YXRlOgogICAgIC8v IENhbGxlZCBieSB0aGUgdGFzay4KICAgICB2b2lkIHRhc2tDb21wbGV0ZWQoKTsKK3ByaXZhdGU6 CiAKICAgICBib29sIG1fdGFza0NvbXBsZXRlZDsKICAgICBNdXRleCBtX3N5bmNocm9ub3VzTXV0 ZXg7CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUaHJlYWQuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZVRocmVhZC5jcHAJKHJldmlzaW9uIDUzNTEyKQor KysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmNwcAkod29ya2luZyBjb3B5KQpAQCAt NDQsNiArNDQsNyBAQCBEYXRhYmFzZVRocmVhZDo6RGF0YWJhc2VUaHJlYWQoKQogICAgIDogbV90 aHJlYWRJRCgwKQogICAgICwgbV90cmFuc2FjdGlvbkNsaWVudChuZXcgU1FMVHJhbnNhY3Rpb25D bGllbnQoKSkKICAgICAsIG1fdHJhbnNhY3Rpb25Db29yZGluYXRvcihuZXcgU1FMVHJhbnNhY3Rp b25Db29yZGluYXRvcigpKQorICAgICwgbV9jbGVhbnVwU3luYygwKQogewogICAgIG1fc2VsZlJl ZiA9IHRoaXM7CiB9CkBAIC01MSw2ICs1Miw3IEBAIERhdGFiYXNlVGhyZWFkOjpEYXRhYmFzZVRo cmVhZCgpCiBEYXRhYmFzZVRocmVhZDo6fkRhdGFiYXNlVGhyZWFkKCkKIHsKICAgICAvLyBGSVhN RTogQW55IGNsZWFudXAgcmVxdWlyZWQgaGVyZT8gIFNpbmNlIHRoZSB0aHJlYWQgZGVsZXRlcyBp dHNlbGYgYWZ0ZXIgcnVubmluZyBpdHMgZGV0YWNoZWQgY291cnNlLCBJIGRvbid0IHRoaW5rIHNv LiAgTGV0cyBiZSBzdXJlLgorICAgIEFTU0VSVCh0ZXJtaW5hdGlvblJlcXVlc3RlZCgpKTsKIH0K IAogYm9vbCBEYXRhYmFzZVRocmVhZDo6c3RhcnQoKQpAQCAtNjUsOCArNjcsMTAgQEAgYm9vbCBE YXRhYmFzZVRocmVhZDo6c3RhcnQoKQogICAgIHJldHVybiBtX3RocmVhZElEOwogfQogCi12b2lk IERhdGFiYXNlVGhyZWFkOjpyZXF1ZXN0VGVybWluYXRpb24oKQordm9pZCBEYXRhYmFzZVRocmVh ZDo6cmVxdWVzdFRlcm1pbmF0aW9uKERhdGFiYXNlVGFza1N5bmNocm9uaXplciAqY2xlYW51cFN5 bmMpCiB7CisgICAgQVNTRVJUKCFtX2NsZWFudXBTeW5jKTsKKyAgICBtX2NsZWFudXBTeW5jID0g Y2xlYW51cFN5bmM7CiAgICAgTE9HKFN0b3JhZ2VBUEksICJEYXRhYmFzZVRocmVhZCAlcCB3YXMg YXNrZWQgdG8gdGVybWluYXRlXG4iLCB0aGlzKTsKICAgICBtX3F1ZXVlLmtpbGwoKTsKIH0KQEAg LTExNSw5ICsxMTksMTQgQEAgdm9pZCogRGF0YWJhc2VUaHJlYWQ6OmRhdGFiYXNlVGhyZWFkKCkK ICAgICAvLyBEZXRhY2ggdGhlIHRocmVhZCBzbyBpdHMgcmVzb3VyY2VzIGFyZSBubyBsb25nZXIg b2YgYW55IGNvbmNlcm4gdG8gYW55b25lIGVsc2UKICAgICBkZXRhY2hUaHJlYWQobV90aHJlYWRJ RCk7CiAKKyAgICBEYXRhYmFzZVRhc2tTeW5jaHJvbml6ZXIqIGNsZWFudXBTeW5jID0gbV9jbGVh bnVwU3luYzsKKyAgICAKICAgICAvLyBDbGVhciB0aGUgc2VsZiByZWZwdHIsIHBvc3NpYmx5IHJl c3VsdGluZyBpbiBkZWxldGlvbgogICAgIG1fc2VsZlJlZiA9IDA7CiAKKyAgICBpZiAoY2xlYW51 cFN5bmMpIC8vIFNvbWVvbmUgd2FudGVkIHRvIGtub3cgd2hlbiB3ZSB3ZXJlIGRvbmUgY2xlYW5p bmcgdXAuCisgICAgICAgIGNsZWFudXBTeW5jLT50YXNrQ29tcGxldGVkKCk7CisKICAgICByZXR1 cm4gMDsKIH0KIApAQCAtMTYyLDYgKzE3MSw1IEBAIHZvaWQgRGF0YWJhc2VUaHJlYWQ6OnVuc2No ZWR1bGVEYXRhYmFzZVQKICAgICBTYW1lRGF0YWJhc2VQcmVkaWNhdGUgcHJlZGljYXRlKGRhdGFi YXNlKTsKICAgICBtX3F1ZXVlLnJlbW92ZUlmKHByZWRpY2F0ZSk7CiB9Ci0KIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKICNlbmRpZgpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFk LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgJKHJldmlz aW9uIDUzNTEyKQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVGhyZWFkLmgJKHdvcmtpbmcg Y29weSkKQEAgLTQzLDYgKzQzLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBEYXRh YmFzZTsKIGNsYXNzIERhdGFiYXNlVGFzazsKK2NsYXNzIERhdGFiYXNlVGFza1N5bmNocm9uaXpl cjsKIGNsYXNzIERvY3VtZW50OwogY2xhc3MgU1FMVHJhbnNhY3Rpb25DbGllbnQ7CiBjbGFzcyBT UUxUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOwpAQCAtNTMsNyArNTQsNyBAQCBwdWJsaWM6CiAgICAg fkRhdGFiYXNlVGhyZWFkKCk7CiAKICAgICBib29sIHN0YXJ0KCk7Ci0gICAgdm9pZCByZXF1ZXN0 VGVybWluYXRpb24oKTsKKyAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbihEYXRhYmFzZVRhc2tT eW5jaHJvbml6ZXIqIGNsZWFudXBTeW5jKTsKICAgICBib29sIHRlcm1pbmF0aW9uUmVxdWVzdGVk KCkgY29uc3Q7CiAKICAgICB2b2lkIHNjaGVkdWxlVGFzayhQYXNzT3duUHRyPERhdGFiYXNlVGFz az4pOwpAQCAtODUsNiArODYsNyBAQCBwcml2YXRlOgogCiAgICAgT3duUHRyPFNRTFRyYW5zYWN0 aW9uQ2xpZW50PiBtX3RyYW5zYWN0aW9uQ2xpZW50OwogICAgIE93blB0cjxTUUxUcmFuc2FjdGlv bkNvb3JkaW5hdG9yPiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3I7CisgICAgRGF0YWJhc2VUYXNr U3luY2hyb25pemVyKiBtX2NsZWFudXBTeW5jOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpJbmRleDogV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5jcHAJKHJldmlzaW9uIDUzNTEyKQor KysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlVHJhY2tlci5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTM2LDEwICszNiwxMCBAQAogI2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJh c2VUaHJlYWQuaCIKICNpbmNsdWRlICJEYXRhYmFzZVRyYWNrZXJDbGllbnQuaCIKLSNpbmNsdWRl ICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJPcmlnaW5RdW90 YU1hbmFnZXIuaCIKICNpbmNsdWRlICJQYWdlLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9u Q29udGV4dC5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU2VjdXJp dHlPcmlnaW5IYXNoLmgiCiAjaW5jbHVkZSAiU1FMaXRlRmlsZVN5c3RlbS5oIgpAQCAtMTIwLDcg KzEyMCw3IEBAIHZvaWQgRGF0YWJhc2VUcmFja2VyOjpvcGVuVHJhY2tlckRhdGFiYXMKICAgICB9 CiB9CiAKLWJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hEYXRhYmFzZShEb2N1bWVu dCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFt ZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQorYm9vbCBEYXRhYmFzZVRyYWNrZXI6OmNh bkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0 IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBl c3RpbWF0ZWRTaXplKQogewogICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gbV90aHJlYWQp OwogCkBAIC0xMjgsOSArMTI4LDkgQEAgYm9vbCBEYXRhYmFzZVRyYWNrZXI6OmNhbkVzdGFibGlz aERhdGFiYQogICAgIC8vIGNhbiBydW4gb24gdGhlIGRhdGFiYXNlIHRocmVhZCBsYXRlci4KICAg ICBwb3B1bGF0ZU9yaWdpbnMoKTsKIAotICAgIFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4gPSBkb2N1 bWVudC0+c2VjdXJpdHlPcmlnaW4oKTsKKyAgICBTZWN1cml0eU9yaWdpbiogb3JpZ2luID0gY29u dGV4dC0+c2VjdXJpdHlPcmlnaW4oKTsKIAotICAgIC8vIFNpbmNlIHdlJ3JlIGltbWluZW50bHkg b3BlbmluZyBhIGRhdGFiYXNlIHdpdGhpbiB0aGlzIERvY3VtZW50J3Mgb3JpZ2luLCBtYWtlIHN1 cmUgdGhpcyBvcmlnaW4gaXMgYmVpbmcgdHJhY2tlZCBieSB0aGUgUXVvdGFUcmFja2VyCisgICAg Ly8gU2luY2Ugd2UncmUgaW1taW5lbnRseSBvcGVuaW5nIGEgZGF0YWJhc2Ugd2l0aGluIHRoaXMg Y29udGV4dCdzIG9yaWdpbiwgbWFrZSBzdXJlIHRoaXMgb3JpZ2luIGlzIGJlaW5nIHRyYWNrZWQg YnkgdGhlIFF1b3RhVHJhY2tlcgogICAgIC8vIGJ5IGZldGNoaW5nIGl0J3MgY3VycmVudCB1c2Fn ZSBub3cKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgdXNhZ2UgPSB1c2FnZUZvck9yaWdpbihvcmln aW4pOwogCkBAIC0xNDcsMTIgKzE0Nyw5IEBAIGJvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3Rh Ymxpc2hEYXRhYmEKIAogICAgIC8vIEdpdmUgdGhlIGNocm9tZSBjbGllbnQgYSBjaGFuY2UgdG8g aW5jcmVhc2UgdGhlIHF1b3RhLgogICAgIC8vIFRlbXBvcmFyaWx5IG1ha2UgdGhlIGRldGFpbHMg b2YgdGhlIHByb3Bvc2VkIGRhdGFiYXNlIGF2YWlsYWJsZSwgc28gdGhlIGNsaWVudCBjYW4gZ2V0 IGF0IHRoZW0uCi0gICAgUGFnZSogcGFnZSA9IGRvY3VtZW50LT5wYWdlKCk7Ci0gICAgaWYgKCFw YWdlKQotICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgcGFpcjxTZWN1cml0eU9yaWdpbiosIERh dGFiYXNlRGV0YWlscz4gZGV0YWlscyhvcmlnaW4sIERhdGFiYXNlRGV0YWlscyhuYW1lLCBkaXNw bGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSwgMCkpOwogICAgIG1fcHJvcG9zZWREYXRhYmFzZSA9ICZk ZXRhaWxzOwotICAgIHBhZ2UtPmNocm9tZSgpLT5jbGllbnQoKS0+ZXhjZWVkZWREYXRhYmFzZVF1 b3RhKGRvY3VtZW50LT5mcmFtZSgpLCBuYW1lKTsKKyAgICBjb250ZXh0LT5kYXRhYmFzZUV4Y2Vl ZGVkUXVvdGEobmFtZSk7CiAgICAgbV9wcm9wb3NlZERhdGFiYXNlID0gMDsKIAogICAgIC8vIElm IHRoZSBkYXRhYmFzZSB3aWxsIGZpdCBub3csIGFsbG93IGl0cyBjcmVhdGlvbi4KQEAgLTE4Niw3 ICsxODMsNyBAQCBib29sIERhdGFiYXNlVHJhY2tlcjo6aGFzRW50cnlGb3JEYXRhYmFzCiAKIHVu c2lnbmVkIGxvbmcgbG9uZyBEYXRhYmFzZVRyYWNrZXI6OmdldE1heFNpemVGb3JEYXRhYmFzZShj b25zdCBEYXRhYmFzZSogZGF0YWJhc2UpCiB7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9 PSBkYXRhYmFzZS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7 CisgICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSBkYXRhYmFzZS0+c2NyaXB0RXhlY3V0aW9u Q29udGV4dCgpLT5kYXRhYmFzZVRocmVhZCgpLT5nZXRUaHJlYWRJRCgpKTsKICAgICAvLyBUaGUg bWF4aW11bSBzaXplIGZvciBhIGRhdGFiYXNlIGlzIHRoZSBmdWxsIHF1b3RhIGZvciBpdHMgb3Jp Z2luLCBtaW51cyB0aGUgY3VycmVudCB1c2FnZSB3aXRoaW4gdGhlIG9yaWdpbiwKICAgICAvLyBw bHVzIHRoZSBjdXJyZW50IHVzYWdlIG9mIHRoZSBnaXZlbiBkYXRhYmFzZQogICAgIExvY2tlcjxP cmlnaW5RdW90YU1hbmFnZXI+IGxvY2tlcihvcmlnaW5RdW90YU1hbmFnZXIoKSk7CkluZGV4OiBX ZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2VUcmFja2VyLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9z dG9yYWdlL0RhdGFiYXNlVHJhY2tlci5oCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvc3Rv cmFnZS9EYXRhYmFzZVRyYWNrZXIuaAkod29ya2luZyBjb3B5KQpAQCAtNDUsNyArNDUsNyBAQAog bmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBEYXRhYmFzZTsKLWNsYXNzIERvY3VtZW50Owor Y2xhc3MgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDsKIGNsYXNzIFNlY3VyaXR5T3JpZ2luOwogCiAj aWYgIVBMQVRGT1JNKENIUk9NSVVNKQpAQCAtNTksOCArNTksMTEgQEAgc3RydWN0IFNlY3VyaXR5 T3JpZ2luVHJhaXRzOwogY2xhc3MgRGF0YWJhc2VUcmFja2VyIDogcHVibGljIE5vbmNvcHlhYmxl IHsKIHB1YmxpYzoKICAgICBzdGF0aWMgRGF0YWJhc2VUcmFja2VyJiB0cmFja2VyKCk7CisgICAg Ly8gRklYTUU6IER1ZSB0byB3b3JrZXJzIGhhdmluZyBtdWx0aXBsZSB0aHJlYWRzIGluIGEgc2lu Z2xlIHByb2Nlc3Mgc2hhcmluZworICAgIC8vIGEgRGF0YWJhc2VUcmFja2VyLCB0aGlzIHNpbmds ZXRvbiB3aWxsIGhhdmUgdG8gYmUgc3luY2hyb25pemVkIG9yIG1vdmVkCisgICAgLy8gdG8gVExT LgogCi0gICAgYm9vbCBjYW5Fc3RhYmxpc2hEYXRhYmFzZShEb2N1bWVudCosIGNvbnN0IFN0cmlu ZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0 ZWRTaXplKTsKKyAgICBib29sIGNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAgICAgdm9pZCBzZXREYXRhYmFzZURldGFpbHMo U2VjdXJpdHlPcmlnaW4qLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGlzcGxh eU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CiAgICAgU3RyaW5nIGZ1bGxQYXRo Rm9yRGF0YWJhc2UoU2VjdXJpdHlPcmlnaW4qLCBjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgY3Jl YXRlSWZEb2VzTm90RXhpc3QgPSB0cnVlKTsKIApJbmRleDogV2ViQ29yZS9zdG9yYWdlL1NRTFRy YW5zYWN0aW9uLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3JhZ2UvU1FMVHJhbnNhY3Rp b24uY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvc3RvcmFnZS9TUUxUcmFuc2FjdGlv bi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDExICszNSwxMSBAQAogI2luY2x1ZGUgIkRhdGFi YXNlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VBdXRob3JpemVyLmgiCiAjaW5jbHVkZSAiRGF0YWJh c2VEZXRhaWxzLmgiCi0jaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJFeGNlcHRpb25D b2RlLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNsdWRl ICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIK ICNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlNRTEVycm9yLmgiCiAjaW5jbHVkZSAi U1FMaXRlVHJhbnNhY3Rpb24uaCIKQEAgLTk0LDggKzk0LDcgQEAgdm9pZCBTUUxUcmFuc2FjdGlv bjo6ZXhlY3V0ZVNRTChjb25zdCBTdAogCiAgICAgYm9vbCByZWFkT25seU1vZGUgPSBtX3JlYWRP bmx5OwogICAgIGlmICghcmVhZE9ubHlNb2RlKSB7Ci0gICAgICAgIFBhZ2UqIHBhZ2UgPSBtX2Rh dGFiYXNlLT5kb2N1bWVudCgpLT5wYWdlKCk7Ci0gICAgICAgIGlmICghcGFnZSB8fCBwYWdlLT5z ZXR0aW5ncygpLT5wcml2YXRlQnJvd3NpbmdFbmFibGVkKCkpCisgICAgICAgIGlmIChtX2RhdGFi YXNlLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzRGF0YWJhc2VSZWFkT25seSgpKQogICAg ICAgICAgICAgcmVhZE9ubHlNb2RlID0gdHJ1ZTsKICAgICB9CiAKSW5kZXg6IFdlYkNvcmUvc3Rv cmFnZS9TUUxUcmFuc2FjdGlvbkNsaWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9y YWdlL1NRTFRyYW5zYWN0aW9uQ2xpZW50LmNwcAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3Jl L3N0b3JhZ2UvU1FMVHJhbnNhY3Rpb25DbGllbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00Nyw3 ICs0Nyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVu dDo6ZGlkQ29tbWl0VHJhbnNhY3Rpb24oU1FMVHJhbnNhY3Rpb24qIHRyYW5zYWN0aW9uKQogewot ICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPmRv Y3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChj dXJyZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnNjcmlwdEV4ZWN1dGlv bkNvbnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgRGF0YWJh c2UqIGRhdGFiYXNlID0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCk7CiAgICAgRGF0YWJhc2VUcmFj a2VyOjp0cmFja2VyKCkuc2NoZWR1bGVOb3RpZnlEYXRhYmFzZUNoYW5nZWQoCiAgICAgICAgIGRh dGFiYXNlLT5zZWN1cml0eU9yaWdpbigpLCBkYXRhYmFzZS0+c3RyaW5nSWRlbnRpZmllcigpKTsK QEAgLTU1LDcgKzU1LDcgQEAgdm9pZCBTUUxUcmFuc2FjdGlvbkNsaWVudDo6ZGlkQ29tbWl0VHJh bgogCiB2b2lkIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhdGVtZW50KFNRTFRy YW5zYWN0aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09 IHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5kb2N1bWVudCgpLT5kYXRhYmFzZVRocmVhZCgpLT5n ZXRUaHJlYWRJRCgpKTsKKyAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IHRyYW5zYWN0aW9u LT5kYXRhYmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmRhdGFiYXNlVGhyZWFkKCkt PmdldFRocmVhZElEKCkpOwogICAgIE9yaWdpblF1b3RhTWFuYWdlciYgbWFuYWdlcihEYXRhYmFz ZVRyYWNrZXI6OnRyYWNrZXIoKS5vcmlnaW5RdW90YU1hbmFnZXIoKSk7CiAgICAgTG9ja2VyPE9y aWdpblF1b3RhTWFuYWdlcj4gbG9ja2VyKG1hbmFnZXIpOwogICAgIG1hbmFnZXIubWFya0RhdGFi YXNlKHRyYW5zYWN0aW9uLT5kYXRhYmFzZSgpKTsKQEAgLTYzLDEzICs2MywxMSBAQCB2b2lkIFNR TFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRFeGVjdXRlU3RhCiAKIGJvb2wgU1FMVHJhbnNhY3Rpb25D bGllbnQ6OmRpZEV4Y2VlZFF1b3RhKFNRTFRyYW5zYWN0aW9uKiB0cmFuc2FjdGlvbikKIHsKLSAg ICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVCh0cmFuc2FjdGlvbi0+ZGF0YWJh c2UoKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0NvbnRleHRUaHJlYWQoKSk7CiAgICAg RGF0YWJhc2UqIGRhdGFiYXNlID0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCk7Ci0gICAgUGFnZSog cGFnZSA9IGRhdGFiYXNlLT5kb2N1bWVudCgpLT5wYWdlKCk7Ci0gICAgQVNTRVJUKHBhZ2UpOwog CiAgICAgdW5zaWduZWQgbG9uZyBsb25nIGN1cnJlbnRRdW90YSA9IERhdGFiYXNlVHJhY2tlcjo6 dHJhY2tlcigpLnF1b3RhRm9yT3JpZ2luKGRhdGFiYXNlLT5zZWN1cml0eU9yaWdpbigpKTsKLSAg ICBwYWdlLT5jaHJvbWUoKS0+Y2xpZW50KCktPmV4Y2VlZGVkRGF0YWJhc2VRdW90YShkYXRhYmFz ZS0+ZG9jdW1lbnQoKS0+ZnJhbWUoKSwgZGF0YWJhc2UtPnN0cmluZ0lkZW50aWZpZXIoKSk7Cisg ICAgZGF0YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+ZGF0YWJhc2VFeGNlZWRlZFF1 b3RhKGRhdGFiYXNlLT5zdHJpbmdJZGVudGlmaWVyKCkpOwogICAgIHVuc2lnbmVkIGxvbmcgbG9u ZyBuZXdRdW90YSA9IERhdGFiYXNlVHJhY2tlcjo6dHJhY2tlcigpLnF1b3RhRm9yT3JpZ2luKGRh dGFiYXNlLT5zZWN1cml0eU9yaWdpbigpKTsKICAgICByZXR1cm4gKG5ld1F1b3RhID4gY3VycmVu dFF1b3RhKTsKIH0KSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9EYXRhYmFzZVRyYWNr ZXJDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL0Rh dGFiYXNlVHJhY2tlckNocm9taXVtLmNwcAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3JlL3N0 b3JhZ2UvY2hyb21pdW0vRGF0YWJhc2VUcmFja2VyQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkp CkBAIC0zNSw4ICszNSw4IEBACiAjaW5jbHVkZSAiRGF0YWJhc2UuaCIKICNpbmNsdWRlICJEYXRh YmFzZU9ic2VydmVyLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VUaHJlYWQuaCIKLSNpbmNsdWRlICJE b2N1bWVudC5oIgogI2luY2x1ZGUgIlF1b3RhVHJhY2tlci5oIgorI2luY2x1ZGUgIlNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQuaCIKICNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUg IlNRTGl0ZUZpbGVTeXN0ZW0uaCIKICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgpAQCAtNTYsNyAr NTYsNyBAQCBEYXRhYmFzZVRyYWNrZXI6OkRhdGFiYXNlVHJhY2tlcigpCiAgICAgU1FMaXRlRmls ZVN5c3RlbTo6cmVnaXN0ZXJTUUxpdGVWRlMoKTsKIH0KIAotYm9vbCBEYXRhYmFzZVRyYWNrZXI6 OmNhbkVzdGFibGlzaERhdGFiYXNlKERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiwgY29uc3QgU3Ry aW5nJiwgdW5zaWduZWQgbG9uZykKK2Jvb2wgRGF0YWJhc2VUcmFja2VyOjpjYW5Fc3RhYmxpc2hE YXRhYmFzZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiwgY29uc3QgU3Ry aW5nJiwgdW5zaWduZWQgbG9uZykKIHsKICAgICAvLyBJbiBDaHJvbWl1bSwgYSBkYXRhYmFzZSBj YW4gYWx3YXlzIGJlIGVzdGFibGlzaGVkIChldmVuIHRob3VnaCB3ZSBtaWdodCBub3QKICAgICAv LyBiZSBhYmxlIHRvIHdyaXRlIGFueXRoaW5nIHRvIGl0IGlmIHRoZSBxdW90YSBmb3IgdGhpcyBv cmlnaW4gd2FzIGV4Y2VlZGVkKQpAQCAtNzUsMjEgKzc1LDM1IEBAIFN0cmluZyBEYXRhYmFzZVRy YWNrZXI6OmZ1bGxQYXRoRm9yRGF0YWIKIAogdm9pZCBEYXRhYmFzZVRyYWNrZXI6OmFkZE9wZW5E YXRhYmFzZShEYXRhYmFzZSogZGF0YWJhc2UpCiB7Ci0gICAgQVNTRVJUKGlzTWFpblRocmVhZCgp KTsKKyAgICBBU1NFUlQoZGF0YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNDb250 ZXh0VGhyZWFkKCkpOwogICAgIERhdGFiYXNlT2JzZXJ2ZXI6OmRhdGFiYXNlT3BlbmVkKGRhdGFi YXNlKTsKIH0KLXN0YXRpYyB2b2lkIHJlbW92ZU9wZW5EYXRhYmFzZU9uTWFpblRocmVhZCh2b2lk KiBjb250ZXh0KQotewotICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9IHN0YXRpY19jYXN0PERhdGFi YXNlKj4oY29udGV4dCk7Ci0gICAgRGF0YWJhc2VUcmFja2VyOjp0cmFja2VyKCkucmVtb3ZlT3Bl bkRhdGFiYXNlKGRhdGFiYXNlKTsKLSAgICBkYXRhYmFzZS0+ZGVyZWYoKTsKLX0KKworY2xhc3Mg VHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29u dGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8VHJhY2tlclJlbW92 ZU9wZW5EYXRhYmFzZVRhc2s+IGNyZWF0ZShQYXNzUmVmUHRyPERhdGFiYXNlPiBkYXRhYmFzZSkK KyAgICB7CisgICAgICAgIHJldHVybiBuZXcgVHJhY2tlclJlbW92ZU9wZW5EYXRhYmFzZVRhc2so ZGF0YWJhc2UpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQorICAgIHsKKyAgICAgICAgRGF0YWJhc2VUcmFja2Vy Ojp0cmFja2VyKCkucmVtb3ZlT3BlbkRhdGFiYXNlKG1fZGF0YWJhc2UuZ2V0KCkpOworICAgIH0K KworcHJpdmF0ZToKKyAgICBUcmFja2VyUmVtb3ZlT3BlbkRhdGFiYXNlVGFzayhQYXNzUmVmUHRy PERhdGFiYXNlPiBkYXRhYmFzZSkKKyAgICAgICAgOiBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAg IHsKKyAgICB9CisKKyAgICBSZWZQdHI8RGF0YWJhc2U+IG1fZGF0YWJhc2U7Cit9OwogCiB2b2lk IERhdGFiYXNlVHJhY2tlcjo6cmVtb3ZlT3BlbkRhdGFiYXNlKERhdGFiYXNlKiBkYXRhYmFzZSkK IHsKLSAgICBpZiAoIWlzTWFpblRocmVhZCgpKSB7Ci0gICAgICAgIGRhdGFiYXNlLT5yZWYoKTsK LSAgICAgICAgY2FsbE9uTWFpblRocmVhZChyZW1vdmVPcGVuRGF0YWJhc2VPbk1haW5UaHJlYWQs IGRhdGFiYXNlKTsKKyAgICBpZiAoIWRhdGFiYXNlLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCkt PmlzQ29udGV4dFRocmVhZCgpKSB7CisgICAgICAgIGRhdGFiYXNlLT5zY3JpcHRFeGVjdXRpb25D b250ZXh0KCktPnBvc3RUYXNrKFRyYWNrZXJSZW1vdmVPcGVuRGF0YWJhc2VUYXNrOjpjcmVhdGUo ZGF0YWJhc2UpKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApAQCAtOTgsNyArMTEyLDcgQEAg dm9pZCBEYXRhYmFzZVRyYWNrZXI6OnJlbW92ZU9wZW5EYXRhYmFzZQogCiB1bnNpZ25lZCBsb25n IGxvbmcgRGF0YWJhc2VUcmFja2VyOjpnZXRNYXhTaXplRm9yRGF0YWJhc2UoY29uc3QgRGF0YWJh c2UqIGRhdGFiYXNlKQogewotICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2Ut PmRvY3VtZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VS VChjdXJyZW50VGhyZWFkKCkgPT0gZGF0YWJhc2UtPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+ ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiAgICAgdW5zaWduZWQgbG9uZyBsb25n IHNwYWNlQXZhaWxhYmxlID0gMDsKICAgICB1bnNpZ25lZCBsb25nIGxvbmcgZGF0YWJhc2VTaXpl ID0gMDsKICAgICBRdW90YVRyYWNrZXI6Omluc3RhbmNlKCkuZ2V0RGF0YWJhc2VTaXplQW5kU3Bh Y2VBdmFpbGFibGVUb09yaWdpbigKSW5kZXg6IFdlYkNvcmUvc3RvcmFnZS9jaHJvbWl1bS9TUUxU cmFuc2FjdGlvbkNsaWVudENocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3N0b3Jh Z2UvY2hyb21pdW0vU1FMVHJhbnNhY3Rpb25DbGllbnRDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDUz NTEyKQorKysgV2ViQ29yZS9zdG9yYWdlL2Nocm9taXVtL1NRTFRyYW5zYWN0aW9uQ2xpZW50Q2hy b21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCwyMCArMzgsMzQgQEAKICNpbmNsdWRlICJT UUxUcmFuc2FjdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAKLXN0YXRpYyB2 b2lkIG5vdGlmeURhdGFiYXNlQ2hhbmdlZCh2b2lkKiBjb250ZXh0KSB7Ci0gICAgV2ViQ29yZTo6 RGF0YWJhc2UqIGRhdGFiYXNlID0gc3RhdGljX2Nhc3Q8V2ViQ29yZTo6RGF0YWJhc2UqPihjb250 ZXh0KTsKLSAgICBXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpkYXRhYmFzZU1vZGlmaWVkKGRh dGFiYXNlKTsKLSAgICBkYXRhYmFzZS0+ZGVyZWYoKTsgIC8vIHJlZigpJ2QgaW4gZGlkQ29tbWl0 VHJhbnNhY3Rpb24oKQotfQotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIE5vdGlmeURh dGFiYXNlQ2hhbmdlZFRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7 CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFz az4gY3JlYXRlKERhdGFiYXNlICpkYXRhYmFzZSkKKyAgICB7CisgICAgICAgIHJldHVybiBuZXcg Tm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFzayhkYXRhYmFzZSk7CisgICAgfQorCisgICAgdmlydHVh bCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQorICAgIHsKKyAgICAg ICAgV2ViQ29yZTo6RGF0YWJhc2VPYnNlcnZlcjo6ZGF0YWJhc2VNb2RpZmllZChtX2RhdGFiYXNl LmdldCgpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTm90aWZ5RGF0YWJhc2VDaGFuZ2VkVGFz ayhQYXNzUmVmUHRyPERhdGFiYXNlPiBkYXRhYmFzZSkKKyAgICAgICAgOiBtX2RhdGFiYXNlKGRh dGFiYXNlKQorICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8RGF0YWJhc2U+IG1fZGF0YWJhc2U7 Cit9OworCiB2b2lkIFNRTFRyYW5zYWN0aW9uQ2xpZW50OjpkaWRDb21taXRUcmFuc2FjdGlvbihT UUxUcmFuc2FjdGlvbiogdHJhbnNhY3Rpb24pCiB7Ci0gICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQo KSA9PSB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+ZG9jdW1lbnQoKS0+ZGF0YWJhc2VUaHJlYWQo KS0+Z2V0VGhyZWFkSUQoKSk7CisgICAgQVNTRVJUKGN1cnJlbnRUaHJlYWQoKSA9PSB0cmFuc2Fj dGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5kYXRhYmFzZVRocmVh ZCgpLT5nZXRUaHJlYWRJRCgpKTsKICAgICBpZiAoIXRyYW5zYWN0aW9uLT5pc1JlYWRPbmx5KCkp IHsKLSAgICAgICAgdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnJlZigpOyAgLy8gZGVyZWYoKSdk IGluIG5vdGlmeURhdGFiYXNlQ2hhbmdlZCgpCi0gICAgICAgIGNhbGxPbk1haW5UaHJlYWQobm90 aWZ5RGF0YWJhc2VDaGFuZ2VkLCB0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKSk7CisgICAgICAgIHRy YW5zYWN0aW9uLT5kYXRhYmFzZSgpLT5zY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPnBvc3RUYXNr KE5vdGlmeURhdGFiYXNlQ2hhbmdlZFRhc2s6OmNyZWF0ZSh0cmFuc2FjdGlvbi0+ZGF0YWJhc2Uo KSkpOwogICAgIH0KIH0KIApAQCAtNTksMTQgKzczLDE0IEBAIHZvaWQgU1FMVHJhbnNhY3Rpb25D bGllbnQ6OmRpZEV4ZWN1dGVTdGEKIHsKICAgICAvLyBUaGlzIG1ldGhvZCBpcyBjYWxsZWQgYWZ0 ZXIgZXhlY3V0aW5nIGV2ZXJ5IHN0YXRlbWVudCB0aGF0IGNoYW5nZXMgdGhlIERCLgogICAgIC8v IENocm9taXVtIGRvZXNuJ3QgbmVlZCB0byBkbyBhbnl0aGluZyBhdCB0aGF0IHBvaW50LgotICAg IEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPmRvY3Vt ZW50KCktPmRhdGFiYXNlVGhyZWFkKCktPmdldFRocmVhZElEKCkpOworICAgIEFTU0VSVChjdXJy ZW50VGhyZWFkKCkgPT0gdHJhbnNhY3Rpb24tPmRhdGFiYXNlKCktPnNjcmlwdEV4ZWN1dGlvbkNv bnRleHQoKS0+ZGF0YWJhc2VUaHJlYWQoKS0+Z2V0VGhyZWFkSUQoKSk7CiB9CiAKLWJvb2wgU1FM VHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKFNRTFRyYW5zYWN0aW9uKikKK2Jvb2wg U1FMVHJhbnNhY3Rpb25DbGllbnQ6OmRpZEV4Y2VlZFF1b3RhKFNRTFRyYW5zYWN0aW9uKiB0cmFu c2FjdGlvbikKIHsKICAgICAvLyBDaHJvbWl1bSBkb2VzIG5vdCBhbGxvdyB1c2VycyB0byBtYW51 YWxseSBjaGFuZ2UgdGhlIHF1b3RhIGZvciBhbiBvcmlnaW4gKGZvciBub3csIGF0IGxlYXN0KS4K ICAgICAvLyBEb24ndCBkbyBhbnl0aGluZy4KLSAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwor ICAgIEFTU0VSVCh0cmFuc2FjdGlvbi0+ZGF0YWJhc2UoKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4 dCgpLT5pc0NvbnRleHRUaHJlYWQoKSk7CiAgICAgcmV0dXJuIGZhbHNlOwogfQogCkluZGV4OiBX ZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93 b3JrZXJzL1dvcmtlckNvbnRleHQuY3BwCShyZXZpc2lvbiA1MzUxMikKKysrIFdlYkNvcmUvd29y a2Vycy9Xb3JrZXJDb250ZXh0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzIsNiArMzIsNyBAQAog I2luY2x1ZGUgIldvcmtlckNvbnRleHQuaCIKIAogI2luY2x1ZGUgIkFjdGl2ZURPTU9iamVjdC5o IgorI2luY2x1ZGUgIkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiRE9NVGltZXIuaCIKICNpbmNsdWRl ICJET01XaW5kb3cuaCIKICNpbmNsdWRlICJFdmVudC5oIgpAQCAtMjU0LDYgKzI1NSwyNyBAQCBO b3RpZmljYXRpb25DZW50ZXIqIFdvcmtlckNvbnRleHQ6OndlYmtpCiB9CiAjZW5kaWYKIAorI2lm IEVOQUJMRShEQVRBQkFTRSkKK1Bhc3NSZWZQdHI8RGF0YWJhc2U+IFdvcmtlckNvbnRleHQ6Om9w ZW5EYXRhYmFzZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmVyc2lvbiwgY29u c3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNl cHRpb25Db2RlJiBlYykKK3sKKyAgICBpZiAoIXNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0Rh dGFiYXNlKCkpIHsKKyAgICAgICAgZWMgPSBTRUNVUklUWV9FUlI7CisgICAgICAgIHJldHVybiAw OworICAgIH0KKworICAgIEFTU0VSVChEYXRhYmFzZTo6aXNBdmFpbGFibGUoKSk7CisgICAgaWYg KCFEYXRhYmFzZTo6aXNBdmFpbGFibGUoKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1 cm4gRGF0YWJhc2U6Om9wZW5EYXRhYmFzZSh0aGlzLCBuYW1lLCB2ZXJzaW9uLCBkaXNwbGF5TmFt ZSwgZXN0aW1hdGVkU2l6ZSwgZWMpOworfQorI2VuZGlmCisKK2Jvb2wgV29ya2VyQ29udGV4dDo6 aXNDb250ZXh0VGhyZWFkKCkgY29uc3QKK3sKKyAgICByZXR1cm4gY3VycmVudFRocmVhZCgpID09 IHRocmVhZCgpLT50aHJlYWRJRCgpOworfQorCiBFdmVudFRhcmdldERhdGEqIFdvcmtlckNvbnRl eHQ6OmV2ZW50VGFyZ2V0RGF0YSgpCiB7CiAgICAgcmV0dXJuICZtX2V2ZW50VGFyZ2V0RGF0YTsK SW5kZXg6IFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3Jl L3dvcmtlcnMvV29ya2VyQ29udGV4dC5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMCwxMSArMzAsMTMg QEAKICNpZiBFTkFCTEUoV09SS0VSUykKIAogI2luY2x1ZGUgIkF0b21pY1N0cmluZ0hhc2guaCIK KyNpbmNsdWRlICJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIkV2ZW50TGlzdGVuZXIuaCIKICNpbmNs dWRlICJFdmVudE5hbWVzLmgiCiAjaW5jbHVkZSAiRXZlbnRUYXJnZXQuaCIKICNpbmNsdWRlICJT Y3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxl ci5oIgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVkZSA8d3RmL093blB0ci5o PgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQu aD4KQEAgLTQyLDYgKzQ0LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisgICAgY2xhc3Mg RGF0YWJhc2U7CiAgICAgY2xhc3MgTm90aWZpY2F0aW9uQ2VudGVyOwogICAgIGNsYXNzIFNjaGVk dWxlZEFjdGlvbjsKICAgICBjbGFzcyBXb3JrZXJMb2NhdGlvbjsKQEAgLTY1LDkgKzY4LDkgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIFN0cmluZyB1c2VyQWdlbnQoY29u c3QgS1VSTCYpIGNvbnN0OwogCiAgICAgICAgIFdvcmtlclNjcmlwdENvbnRyb2xsZXIqIHNjcmlw dCgpIHsgcmV0dXJuIG1fc2NyaXB0LmdldCgpOyB9Ci0gICAgICAgIHZvaWQgY2xlYXJTY3JpcHQo KSB7IHJldHVybiBtX3NjcmlwdC5jbGVhcigpOyB9CisgICAgICAgIHZvaWQgY2xlYXJTY3JpcHQo KSB7IG1fc2NyaXB0LmNsZWFyKCk7IH0KIAotICAgICAgICBXb3JrZXJUaHJlYWQqIHRocmVhZCgp IHsgcmV0dXJuIG1fdGhyZWFkOyB9CisgICAgICAgIFdvcmtlclRocmVhZCogdGhyZWFkKCkgY29u c3QgeyByZXR1cm4gbV90aHJlYWQ7IH0KIAogICAgICAgICBib29sIGhhc1BlbmRpbmdBY3Rpdml0 eSgpIGNvbnN0OwogCkBAIC0xMDEsNiArMTA0LDE3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgTm90aWZpY2F0aW9uQ2VudGVyKiB3ZWJraXROb3RpZmljYXRpb25zKCkgY29uc3Q7CiAj ZW5kaWYKIAorI2lmIEVOQUJMRShEQVRBQkFTRSkKKyAgICAgICAgLy8gSFRNTCA1IGNsaWVudC1z aWRlIGRhdGFiYXNlCisgICAgICAgIFBhc3NSZWZQdHI8RGF0YWJhc2U+IG9wZW5EYXRhYmFzZShj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmVyc2lvbiwgY29uc3QgU3RyaW5nJiBk aXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBFeGNlcHRpb25Db2RlJik7 CisgICAgICAgIC8vIE5vdCBpbXBsZW1lbnRlZCB5ZXQuCisgICAgICAgIHZpcnR1YWwgYm9vbCBp c0RhdGFiYXNlUmVhZE9ubHkoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorICAgICAgICAvLyBO b3QgaW1wbGVtZW50ZWQgeWV0LgorICAgICAgICB2aXJ0dWFsIHZvaWQgZGF0YWJhc2VFeGNlZWRl ZFF1b3RhKGNvbnN0IFN0cmluZyYpIHsgfQorI2VuZGlmCisgICAgICAgIHZpcnR1YWwgYm9vbCBp c0NvbnRleHRUaHJlYWQoKSBjb25zdDsKKworCiAgICAgICAgIC8vIFRoZXNlIG1ldGhvZHMgYXJl IHVzZWQgZm9yIEdDIG1hcmtpbmcuIFNlZSBKU1dvcmtlckNvbnRleHQ6Om1hcmtDaGlsZHJlbihN YXJrU3RhY2smKSBpbgogICAgICAgICAvLyBKU1dvcmtlckNvbnRleHRDdXN0b20uY3BwLgogICAg ICAgICBXb3JrZXJOYXZpZ2F0b3IqIG9wdGlvbmFsTmF2aWdhdG9yKCkgY29uc3QgeyByZXR1cm4g bV9uYXZpZ2F0b3IuZ2V0KCk7IH0KSW5kZXg6IFdlYkNvcmUvd29ya2Vycy9Xb3JrZXJSdW5Mb29w LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3dvcmtlcnMvV29ya2VyUnVuTG9vcC5jcHAJKHJl dmlzaW9uIDUzNTEyKQorKysgV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0xNTIsOSArMTUyLDcgQEAgTWVzc2FnZVF1ZXVlV2FpdFJlc3VsdCBXb3Jr ZXJSdW5Mb29wOjpydQogICAgIE1lc3NhZ2VRdWV1ZVdhaXRSZXN1bHQgcmVzdWx0OwogICAgIE93 blB0cjxXb3JrZXJSdW5Mb29wOjpUYXNrPiB0YXNrID0gbV9tZXNzYWdlUXVldWUud2FpdEZvck1l c3NhZ2VGaWx0ZXJlZFdpdGhUaW1lb3V0KHJlc3VsdCwgcHJlZGljYXRlLCBhYnNvbHV0ZVRpbWUp OwogCi0gICAgLy8gSWYgdGhlIGNvbnRleHQgaXMgY2xvc2luZywgZG9uJ3QgZGlzcGF0Y2ggYW55 IGZ1cnRoZXIgdGFza3MgKHBlciBzZWN0aW9uIDQuMS4xIG9mIHRoZSBXZWIgV29ya2VycyBzcGVj KS4KLSAgICBpZiAoY29udGV4dC0+aXNDbG9zaW5nKCkpCi0gICAgICAgIHJldHVybiByZXN1bHQ7 CisgICAgLy8gSWYgdGhlIGNvbnRleHQgaXMgY2xvc2luZywgZG9uJ3QgZXhlY3V0ZSBhbnkgZnVy dGhlciBKYXZhU2NyaXB0IHRhc2tzIChwZXIgc2VjdGlvbiA0LjEuMSBvZiB0aGUgV2ViIFdvcmtl cnMgc3BlYykuICBIb3dldmVyLCB0aGVyZSBtYXkgYmUgaW1wbGVtZW50YXRpb24gY2xlYW51cCB0 YXNrcyBpbiB0aGUgcXVldWUsIHNvIGtlZXAgcnVubmluZyB0aHJvdWdoIGl0LgogCiAgICAgc3dp dGNoIChyZXN1bHQpIHsKICAgICBjYXNlIE1lc3NhZ2VRdWV1ZVRlcm1pbmF0ZWQ6CkBAIC0xNjUs NyArMTYzLDggQEAgTWVzc2FnZVF1ZXVlV2FpdFJlc3VsdCBXb3JrZXJSdW5Mb29wOjpydQogICAg ICAgICBicmVhazsKIAogICAgIGNhc2UgTWVzc2FnZVF1ZXVlVGltZW91dDoKLSAgICAgICAgbV9z aGFyZWRUaW1lci0+ZmlyZSgpOworICAgICAgICBpZiAoIWNvbnRleHQtPmlzQ2xvc2luZygpKQor ICAgICAgICAgICAgbV9zaGFyZWRUaW1lci0+ZmlyZSgpOwogICAgICAgICBicmVhazsKICAgICB9 CiAKQEAgLTE5NCw3ICsxOTMsOSBAQCBQYXNzT3duUHRyPFdvcmtlclJ1bkxvb3A6OlRhc2s+IFdv cmtlclJ1CiAKIHZvaWQgV29ya2VyUnVuTG9vcDo6VGFzazo6cGVyZm9ybVRhc2soU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCkKIHsKLSAgICBtX3Rhc2stPnBlcmZvcm1UYXNrKGNvbnRl eHQpOworICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3Jr ZXJDb250ZXh0ICo+KGNvbnRleHQpOworICAgIGlmICghd29ya2VyQ29udGV4dC0+aXNDbG9zaW5n KCkgfHwgbV90YXNrLT5pc0NsZWFudXBUYXNrKCkpCisgICAgICAgIG1fdGFzay0+cGVyZm9ybVRh c2soY29udGV4dCk7CiB9CiAKIFdvcmtlclJ1bkxvb3A6OlRhc2s6OlRhc2soUGFzc093blB0cjxT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUpCklu ZGV4OiBXZWJDb3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3dvcmtlcnMvV29ya2VyVGhyZWFkLmNwcAkocmV2aXNpb24gNTM1MTIpCisrKyBXZWJDb3Jl L3dvcmtlcnMvV29ya2VyVGhyZWFkLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBA QAogCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2su aCIKICNpbmNsdWRlICJEZWRpY2F0ZWRXb3JrZXJDb250ZXh0LmgiCiAjaW5jbHVkZSAiS1VSTC5o IgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCkBAIC0xMzUsOSArMTM2LDggQEAgdm9pZCog V29ya2VyVGhyZWFkOjp3b3JrZXJUaHJlYWQoKQogCiAgICAgVGhyZWFkSWRlbnRpZmllciB0aHJl YWRJRCA9IG1fdGhyZWFkSUQ7CiAKLSAgICBtX3dvcmtlckNvbnRleHQtPnN0b3BBY3RpdmVET01P YmplY3RzKCk7Ci0gICAgbV93b3JrZXJDb250ZXh0LT5jbGVhclNjcmlwdCgpOwogICAgIEFTU0VS VChtX3dvcmtlckNvbnRleHQtPmhhc09uZVJlZigpKTsKKwogICAgIC8vIFRoZSBiZWxvdyBhc3Np Z25tZW50IHdpbGwgZGVzdHJveSB0aGUgY29udGV4dCwgd2hpY2ggd2lsbCBpbiB0dXJuIG5vdGlm eSBtZXNzYWdpbmcgcHJveHkuCiAgICAgLy8gV2UgY2Fubm90IGxldCBhbnkgb2JqZWN0cyBzdXJ2 aXZlIHBhc3QgdGhyZWFkIGV4aXQsIGJlY2F1c2Ugbm8gb3RoZXIgdGhyZWFkIHdpbGwgcnVuIEdD IG9yIG90aGVyd2lzZSBkZXN0cm95IHRoZW0uCiAgICAgbV93b3JrZXJDb250ZXh0ID0gMDsKQEAg LTE1NCwxNyArMTU0LDcwIEBAIHZvaWQgV29ya2VyVGhyZWFkOjpydW5FdmVudExvb3AoKQogICAg IG1fcnVuTG9vcC5ydW4obV93b3JrZXJDb250ZXh0LmdldCgpKTsKIH0KIAorY2xhc3MgV29ya2Vy VGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrIDogcHVibGljIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPFdvcmtlclRocmVhZFNodXRk b3duRmluaXNoVGFzaz4gY3JlYXRlKCkKKyAgICB7CisgICAgICAgIHJldHVybiBuZXcgV29ya2Vy VGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrKCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBl cmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQgKmNvbnRleHQpCisgICAgeworICAgICAg ICBBU1NFUlQoY29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkpOworICAgICAgICBXb3JrZXJDb250 ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nhc3Q8V29ya2VyQ29udGV4dCo+KGNvbnRleHQp OworICAgICAgICB3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+cnVuTG9vcCgpLnRlcm1pbmF0ZSgp OworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBpc0NsZWFudXBUYXNrKCkgY29uc3QgeyByZXR1 cm4gdHJ1ZTsgfQorfTsKKworY2xhc3MgV29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2sgOiBw dWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7CitwdWJsaWM6CisgICAgc3RhdGlj IFBhc3NPd25QdHI8V29ya2VyVGhyZWFkU2h1dGRvd25TdGFydFRhc2s+IGNyZWF0ZSgpCisgICAg eworICAgICAgICByZXR1cm4gbmV3IFdvcmtlclRocmVhZFNodXRkb3duU3RhcnRUYXNrKCk7Cisg ICAgfQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQgKmNvbnRleHQpCisgICAgeworICAgICAgICBBU1NFUlQoY29udGV4dC0+aXNXb3JrZXJDb250 ZXh0KCkpOworICAgICAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGljX2Nh c3Q8V29ya2VyQ29udGV4dCo+KGNvbnRleHQpOworCisgICAgICAgIC8vIFdlIGN1cnJlbnRseSBp Z25vcmUgYW55IERhdGFiYXNlUG9saWN5IHVzZWQgZm9yIHRoZSBkb2N1bWVudCdzCisgICAgICAg IC8vIGRhdGFiYXNlczsgaWYgaXQncyBhY3R1YWxseSB1c2VkIGFueXdoZXJlLCB0aGlzIHNob3Vs ZCBiZSByZXZpc2l0ZWQuCisgICAgICAgIERhdGFiYXNlVGFza1N5bmNocm9uaXplciBjbGVhbnVw U3luYzsKKyAgICAgICAgd29ya2VyQ29udGV4dC0+c3RvcERhdGFiYXNlcygmY2xlYW51cFN5bmMp OworCisgICAgICAgIHdvcmtlckNvbnRleHQtPnN0b3BBY3RpdmVET01PYmplY3RzKCk7CisgICAg ICAgIHdvcmtlckNvbnRleHQtPmNsZWFyU2NyaXB0KCk7CisKKyAgICAgICAgLy8gV2Ugd2FpdCBm b3IgdGhlIGRhdGFiYXNlIHRocmVhZCB0byBjbGVhbiB1cCBhbGwgaXRzIHN0dWZmIHNvIHRoYXQg d2UKKyAgICAgICAgLy8gY2FuIGRvIG1vcmUgc3RyaW5nZW50IGxlYWsgY2hlY2tzIGFzIHdlIGV4 aXQuCisgICAgICAgIGNsZWFudXBTeW5jLndhaXRGb3JUYXNrQ29tcGxldGlvbigpOworCisgICAg ICAgIC8vIFN0aWNrIGEgc2h1dGRvd24gY29tbWFuZCBhdCB0aGUgZW5kIG9mIHRoZSBxdWV1ZSwg c28gdGhhdCB3ZSBkZWFsCisgICAgICAgIC8vIHdpdGggYWxsIHRoZSBjbGVhbnVwIHRhc2tzIHRo ZSBkYXRhYmFzZXMgcG9zdCBmaXJzdC4KKyAgICAgICAgd29ya2VyQ29udGV4dC0+cG9zdFRhc2so V29ya2VyVGhyZWFkU2h1dGRvd25GaW5pc2hUYXNrOjpjcmVhdGUoKSk7CisgICAgfQorCisgICAg dmlydHVhbCBib29sIGlzQ2xlYW51cFRhc2soKSBjb25zdCB7IHJldHVybiB0cnVlOyB9Cit9Owor CiB2b2lkIFdvcmtlclRocmVhZDo6c3RvcCgpCiB7CiAgICAgLy8gTXV0ZXggcHJvdGVjdGlvbiBp cyBuZWNlc3NhcnkgYmVjYXVzZSBzdG9wKCkgY2FuIGJlIGNhbGxlZCBiZWZvcmUgdGhlIGNvbnRl eHQgaXMgZnVsbHkgY3JlYXRlZC4KICAgICBNdXRleExvY2tlciBsb2NrKG1fdGhyZWFkQ3JlYXRp b25NdXRleCk7CiAKICAgICAvLyBFbnN1cmUgdGhhdCB0YXNrcyBhcmUgYmVpbmcgaGFuZGxlZCBi eSB0aHJlYWQgZXZlbnQgbG9vcC4gSWYgc2NyaXB0IGV4ZWN1dGlvbiB3ZXJlbid0IGZvcmJpZGRl biwgYSB3aGlsZSgxKSBsb29wIGluIEpTIGNvdWxkIGtlZXAgdGhlIHRocmVhZCBhbGl2ZSBmb3Jl dmVyLgotICAgIGlmIChtX3dvcmtlckNvbnRleHQpCisgICAgaWYgKG1fd29ya2VyQ29udGV4dCkg ewogICAgICAgICBtX3dvcmtlckNvbnRleHQtPnNjcmlwdCgpLT5mb3JiaWRFeGVjdXRpb24oKTsK IAogICAgIC8vIEZJWE1FOiBSdWRlbHkga2lsbGluZyB0aGUgdGhyZWFkIHdvbid0IHdvcmsgd2hl biB3ZSBhbGxvdyBuZXN0ZWQgd29ya2VycywgYmVjYXVzZSB0aGV5IHdpbGwgdHJ5IHRvIHBvc3Qg bm90aWZpY2F0aW9ucyBvZiB0aGVpciBkZXN0cnVjdGlvbi4KLSAgICBtX3J1bkxvb3AudGVybWlu YXRlKCk7CisgICAgLy8gVGhpcyBjYW4gbGlrZWx5IHVzZSB0aGUgc2FtZSBtZWNoYW5pc20gYXMg dXNlZCBmb3IgZGF0YWJhc2VzIGFib3ZlLgorCisgICAgICAgIG1fcnVuTG9vcC5wb3N0VGFzayhX b3JrZXJUaHJlYWRTaHV0ZG93blN0YXJ0VGFzazo6Y3JlYXRlKCkpOworICAgIH0gZWxzZQorICAg ICAgICBtX3J1bkxvb3AudGVybWluYXRlKCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK