44700 2010-08-26 11:28:55 -0700 IDBObjectStore::get should run in a transaction. 2010-09-23 07:51:58 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 0 andreip webkit-unassigned abarth bulach dglazkov eric jorlow webkit.review.bot oldest_to_newest 269988 0 andreip 2010-08-26 11:28:55 -0700 IDBObjectStore::get should run in a transaction. 269990 1 65588 andreip 2010-08-26 11:30:25 -0700 Created attachment 65588 Patch 269993 2 andreip 2010-08-26 11:31:59 -0700 Not ready for review yet. 276177 3 66964 bulach 2010-09-08 16:53:54 -0700 Created attachment 66964 Patch 276181 4 bulach 2010-09-08 16:57:11 -0700 Hi Jeremy, Andrei, As suggested, I took over this patch, hopefully we'll be able to either submit by EOW or at least leave in a good shape. :) My patch is essentially Andrei's, with the following changes: 1. Added tests. 2. Fixed / improved a couple of existing tests. 3. Added a didCompleteEventsForTransaction so that IDBRequest can notify the transactions that they can either step to the next set of tasks, or commit if there's nothing else pending. 276185 5 bulach 2010-09-08 17:00:10 -0700 (In reply to comment #4) > Hi Jeremy, Andrei, > > As suggested, I took over this patch, hopefully we'll be able to either submit by EOW or at least leave in a good shape. :) > > My patch is essentially Andrei's, with the following changes: > 1. Added tests. > 2. Fixed / improved a couple of existing tests. > 3. Added a didCompleteEventsForTransaction so that IDBRequest can notify the transactions that they can either step to the next set of tasks, or commit if there's nothing else pending. oh, forgot: 4. I did a minor refactoring / simplification on V8Proxy / IDBPendingTransactionMonitor 276272 6 webkit.review.bot 2010-09-08 19:19:47 -0700 Attachment 66964 did not build on chromium: Build output: http://queues.webkit.org/results/3899315 276442 7 66964 jorlow 2010-09-09 06:57:40 -0700 Comment on attachment 66964 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66964&action=prettypatch > LayoutTests/storage/indexeddb/objectstore-basics-expected.txt:-142 > - these lines should be here > LayoutTests/storage/indexeddb/objectstore-removeobjectstore.html:78 > + window.setTimeout('removeObjectStore()', 0); Note that this will force the transaction to commit, but it won't necessarily have completed after this. BUT you are guaranteed that it will before the removal happens. Maybe just update the comment? > LayoutTests/storage/indexeddb/objectstore-removeobjectstore.html:113 > + shouldBe("event.code", "5"); Fix this fixme. > LayoutTests/storage/indexeddb/script-tests/transaction-get.js:12 > + shouldBe('exc.code', '9'); use the constant > LayoutTests/storage/indexeddb/script-tests/transaction-get.js:34 > + transaction.onabort = unexpectedErrorCallback; Does the abort have an error code and message? If not, you should make a new unexpectedAbortCallback method. > LayoutTests/storage/indexeddb/transaction-get.html:11 > +<script src="script-tests/transaction-get.js"></script> I'm about to submit a change that gets rid of script tests and converts them over to normal html pages. Please convert your new one and merge your changes to the .js files to the associated html files? > WebCore/bindings/v8/V8Proxy.cpp:655 > + IDBPendingTransactionMonitor::abortPendingTransactions(page->group().idbFactory()); I'd rather this still call some blazingly fast method (completely inline) method to decide whether we need to call into abortPendingTransactions since this will be called _every_ single time we leave JavaScript. > WebCore/storage/IDBDatabase.cpp:60 > + // FIXME: remove this method. Maybe describe why and move it to just above the method? And capitalize R. > WebCore/storage/IDBDatabase.cpp:63 > + return IDBObjectStore::create(objectStore.release(), -1); -1 should be some constant somewhere > WebCore/storage/IDBDatabaseBackendImpl.cpp:153 > + // FIXME: Do not expose this method via IDL. This fixme seems unneeded. Maybe add a fixme to remove it from the interface if appropriate tho? > WebCore/storage/IDBDatabaseBackendImpl.cpp:157 > + objectStore->setTransaction(transaction); The backend object should not store the transaction since multiple transactions can be associated with one backend at once. Only the frontend objhects should store it. > WebCore/storage/IDBFactoryBackendImpl.cpp:150 > + m_transactionCoordinator->didCompleteEventsForTransaction(transactionID); Is there any reason why the coordinators should be shared between databases. > WebCore/storage/IDBObjectStore.cpp:128 > + if (!m_isTransactionPending) Pending is so generic. m_isTransactionScheduleForExecution? :-) m_isTransactionInPurgatory m_inPurgatory etc btw, this really should be a per-transaction value, not a per object store. Maybe we should pass around pointers rather than IDs. Even though that means more wrapping/unwrapping. > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:81 > + // FIXME: implement use complete sentences comments so far 277171 8 jorlow 2010-09-10 07:21:57 -0700 Andrei, Marcus and I talked, and I think you should take over the patch at this point. This way it's at a known good stable point for you to take over (so you waste less time figuring out which way is up). 281480 9 68067 andreip 2010-09-20 03:51:44 -0700 Created attachment 68067 Patch 281482 10 webkit.review.bot 2010-09-20 03:57:43 -0700 Attachment 68067 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/storage/IDBObjectStoreBackendImpl.cpp:95: One or more unexpected \r (^M) found; better to use only a \n [whitespace/carriage_return] [1] Suppressing further [whitespace/carriage_return] reports for this file. WebCore/storage/IDBObjectStoreBackendImpl.h:78: Place brace on its own line for function definitions. [whitespace/braces] [4] WebCore/storage/IDBObjectStoreBackendImpl.h:81: Place brace on its own line for function definitions. [whitespace/braces] [4] WebCore/storage/IDBObjectStoreBackendImpl.h:93: Place brace on its own line for function definitions. [whitespace/braces] [4] Total errors found: 5 in 50 files If any of these errors are false positives, please file a bug against check-webkit-style. 281489 11 webkit.review.bot 2010-09-20 04:14:14 -0700 Attachment 68067 did not build on chromium: Build output: http://queues.webkit.org/results/4093009 281662 12 68067 jorlow 2010-09-20 10:53:42 -0700 Comment on attachment 68067 Patch a few of my comments View in context: https://bugs.webkit.org/attachment.cgi?id=68067&action=review > WebCore/storage/IDBDatabase.cpp:60 > + // FIXME: remove this method. put above function definition > WebCore/storage/IDBDatabaseBackendImpl.cpp:153 > + // FIXME: Do not expose this method via IDL. move up > WebCore/storage/IDBDatabaseBackendImpl.cpp:154 > ASSERT_UNUSED(mode, !mode); // FIXME: Handle non-standard modes. Change the fixme to be a "delete this". It should be deleted when we remove it from the IDL. > WebCore/storage/IDBDatabaseBackendImpl.cpp:156 > + return objectStore.release(); For stuff like this, I usually just do a .get() on what's returned which will coerce itself type wise...of course that will cause a needless ref count/de-ref. Your choice. > WebCore/storage/IDBDatabaseBackendInterface.h:58 > + virtual PassRefPtr<IDBObjectStoreBackendInterface> objectStore(const String& name, unsigned short mode, IDBTransactionBackendInterface* transaction = 0) = 0; Put a fixme in to remove the = 0 since it's just a compat hack. > WebCore/storage/IDBFactoryBackendImpl.cpp:147 > + m_transactionCoordinator->abortPendingTransactions(pendingIDs); Why do we still use ids here? THis is in the backendImpl, so we shouldn't need to. > WebCore/storage/IDBObjectStore.cpp:70 > return request; .release() > WebCore/storage/IDBObjectStoreBackendImpl.cpp:84 > + if (transaction) { Would this ever not be true? > WebCore/storage/IDBObjectStoreBackendImpl.cpp:90 > + OwnPtr<ScriptExecutionContext::Task> getTask = adoptPtr(newTask(this, &IDBObjectStoreBackendImpl::get, key, callbacks)); Why do you have to adopt the newTask pointer? Shouldn't it return a passOwnPtr? > WebCore/storage/IDBObjectStoreBackendImpl.cpp:91 > + transaction->scheduleTask(getTask.leakPtr()); Why do you call leak? Can't you pass a passownptr? > WebCore/storage/IDBObjectStoreBackendImpl.cpp:354 > + delete > WebCore/storage/IDBObjectStoreBackendImpl.h:75 > + class IDBTask : public ScriptExecutionContext::Task { I think add a create method that returns a passOwnPtr > WebCore/storage/IDBObjectStoreBackendImpl.h:78 > + : m_obj(obj), m_method(method), m_param1(param1), m_param2(param2) { { on new line > WebCore/storage/IDBObjectStoreBackendImpl.h:81 > + virtual void performTask(ScriptExecutionContext*) { ditto > WebCore/storage/IDBObjectStoreBackendImpl.h:84 > + } newline after > WebCore/storage/IDBObjectStoreBackendImpl.h:93 > + ScriptExecutionContext::Task* newTask(T* object, Method method, const Param1& param1, const Param2& param2) { Should return a passOwnPtr > WebCore/storage/IDBObjectStoreBackendImpl.h:94 > + return new IDBTask<T, Method, Param1, Param2 >(object, method, param1, param2); no space after Param2 > WebCore/storage/IDBObjectStoreBackendImpl.h:106 > + no newline > WebCore/storage/IDBPendingTransactionMonitor.cpp:46 > + if (!m_ids) tabbed in too much > WebCore/storage/IDBPendingTransactionMonitor.cpp:64 > + if (m_ids) { Can't you just bail if this is true? If so, then you can declare the vector below > WebCore/storage/IDBPendingTransactionMonitor.cpp:69 > + if (pendingIds.size()) { Why would this be true and above wouldn't? > WebCore/storage/IDBPendingTransactionMonitor.cpp:75 > +void IDBPendingTransactionMonitor::didCompleteEventsForTransaction(int id, IDBFactoryBackendInterface* idbFactory) why are we using an id? > WebCore/storage/IDBRequest.cpp:60 > + if (transactionId) one place you do > 0 one place just check if it's == 0...which one is right? > WebCore/storage/IDBRequest.cpp:110 > + // FIXME: the transaction id should be the one of the setVersion transaction. True, but only because this is only used by a method that is always executed in a setVersion transaction. Maybe make the comment a bit more clear. > WebCore/storage/IDBRequest.cpp:172 > + if (m_transactionId > 0) { one place you do > 0 one place just check if it's == 0...which one is right? > WebCore/storage/IDBRequest.cpp:173 > + // Now that we processed all pending events, let the transaction monitor maybe wrap to 2 lines rather than 3? > WebCore/storage/IDBRequest.cpp:176 > + ASSERT(scriptExecutionContext()->isDocument()); Add a FIXME for handling the workers case. > WebCore/storage/IDBRequest.h:40 > +#include "IDBTransaction.h" not necessary > WebCore/storage/IDBTransaction.cpp:69 > + if (!objectStoreBackend.get()) { don't need the .get() > WebCore/storage/IDBTransaction.cpp:70 > + throwError(NOT_SUPPORTED_ERR); Do you need to add the string for this error somewhere? > WebCore/storage/IDBTransactionBackendImpl.cpp:51 > + , m_timer(this, &IDBTransactionBackendImpl::timerFired) The timer is just here until we add threading, right? Maybe add a FIXME? > WebCore/storage/IDBTransactionBackendImpl.cpp:65 > + newline doesn't really seem necessary (maybe delete?) > WebCore/storage/IDBTransactionBackendImpl.cpp:67 > + newline doesn't really seem necessary (maybe delete?) > WebCore/storage/IDBTransactionBackendImpl.cpp:72 > +void IDBTransactionBackendImpl::step() step doesn't seem like a very good name > WebCore/storage/IDBTransactionBackendImpl.cpp:75 > + newline doesn't really seem necessary (maybe delete?) > WebCore/storage/IDBTransactionBackendImpl.cpp:76 > + if (!m_taskQueue.isEmpty()) { if / else seems cleaner and less lines of code > WebCore/storage/IDBTransactionBackendImpl.cpp:101 > + m_timer.startOneShot(0); should we verify that it's not currently active? > WebCore/storage/IDBTransactionBackendInterface.h:54 > + virtual void step() = 0; step is not very descriptive > WebCore/storage/IDBTransactionCoordinator.cpp:61 > + RefPtr<IDBTransactionBackendInterface> transaction = m_pendingTransactions.get(id); It doesn't need to be removed? > WebCore/storage/IDBTransactionCoordinator.cpp:62 > + ASSERT(transaction); not necessary > WebCore/storage/IDBTransactionCoordinator.cpp:69 > + if (m_runningTransactions.contains(transactionID)) { When can this be false? Should we assert it's not one of the other types? > WebCore/storage/IDBTransactionCoordinator.cpp:70 > + RefPtr<IDBTransactionBackendInterface> transaction = m_runningTransactions.get(transactionID); 4 spaces > WebCore/storage/IDBTransactionCoordinator.cpp:92 > + // Remove from pending transactions list . at end > WebCore/storage/IDBTransactionCoordinator.cpp:123 > + // FIXME: this would allocate a thread to the next transaction Capital T on This. Maybe s/would/should/? > WebCore/storage/IDBTransactionCoordinator.cpp:126 > + if (m_startedTransactions.isEmpty()) maybe if (... || ...) return ? > WebCore/storage/IDBTransactionCoordinator.cpp:132 > + IDBTransactionBackendInterface* transactionPtr = *(m_startedTransactionQueue.begin()); I believe you don't need ()'s > WebCore/storage/IDBTransactionCoordinator.cpp:134 > + RefPtr<IDBTransactionBackendInterface> transaction = m_startedTransactions.get(transactionPtr->id()); transaction.get() should == transactionPtr, right? My suggestion: RefPtr<> transaction = *_startedTransactionQueue.begin(); ASSERT(transaction.get() == m_startedTransactions.get(transaction->id()).get()); ... > WebCore/storage/IDBTransactionCoordinator.cpp:136 > + // Add to running transactions list. comment isn't useful > WebCore/storage/IDBTransactionCoordinator.cpp:140 > + static_cast<IDBTransactionBackendImpl*>(transactionPtr)->run(); Don't do this. I guess you should be storing impl ptrs rather than interface ptrs? > WebCore/storage/IDBTransactionCoordinator.h:71 > + ListHashSet<IDBTransactionBackendInterface*> m_startedTransactionQueue; Maybe this should be a refptr too...just to be safe? If not, maybe we can put in more asserts to verify that anything in here is also in m_startedTransactions? > WebKit/chromium/ChangeLog:6 > + https://bugs.webkit.org/show_bug.cgi?id=44700 You need a lot more changelog here (but just about the WEbKit parts) > WebKit/chromium/public/WebIDBObjectStore.h:61 > WEBKIT_ASSERT_NOT_REACHED(); put on same line for void methods. > WebKit/chromium/src/IDBObjectStoreProxy.cpp:77 > + OwnPtr<WebKit::WebIDBTransactionImpl> transPtr = adoptPtr(new WebKit::WebIDBTransactionImpl(transaction)); Noooooo WebKit::WebIDBTransactionImpl webTransaction = static_cast<IDBTransactionBackendProxy*>(transaction)->getWebObject() (or something like that). > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:79 > +void IDBTransactionBackendProxy::step() hmmm.....this is probably why we should stick with ids between the frontend and backend interfaces. > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:84 > +bool IDBTransactionBackendProxy::isFinished() const lets try to get rid of these > WebKit/chromium/src/WebIDBObjectStoreImpl.cpp:69 > +void WebIDBObjectStoreImpl::get(const WebIDBKey& key, WebIDBCallbacks* callbacks, const WebIDBTransaction& transaction) Ok...I think I like this afterall....basically the semantics we have is pass by reference when not transfering ownership and otherwise pass by ptr > WebKit/chromium/src/WebIDBTransactionImpl.cpp:82 > + extra new line > WebKit/chromium/src/WebIDBTransactionImpl.h:50 > +#if WEBKIT_IMPLEMENTATION this is always true in src 281740 13 68067 jorlow 2010-09-20 12:28:11 -0700 Comment on attachment 68067 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68067&action=review > LayoutTests/storage/indexeddb/objectstore-basics-expected.txt:116 > +db.transaction() hu? does this work? Don't you need to save it to a variable? ideally use db.transaction() too? > LayoutTests/storage/indexeddb/objectstore-removeobjectstore.html:73 > +function indexAdded() Half the layout tests are named for what just happened and the other half are what should happen next. In this place, it's the latter, so name it something like commitTransaction > LayoutTests/storage/indexeddb/transaction-get.html:18 > + debug("Accessing a committed transaction should throw"); This should be a failure, not a debug It's ok to check in a failing result if that's what it should be. > LayoutTests/storage/indexeddb/transaction-get.html:22 > + shouldBe('exc.code', '9'); use the constant > LayoutTests/storage/indexeddb/transaction-get.html:27 > +function nonExistingKey() { all functions should put { on the next line > LayoutTests/storage/indexeddb/transaction-get.html:41 > + transaction.onabort = unexpectedErrorCallback; newline after this maybe? > LayoutTests/storage/indexeddb/transaction-get.html:44 > + var result = store.get('myKey'); put in evalAndLog > LayoutTests/storage/indexeddb/transaction-get.html:49 > + var emptyResult = store.get('nonExistingKey'); put at the end of gotValue (yes, this is supposed to work, but that'll make it easier to read) > LayoutTests/storage/indexeddb/transaction-get.html:80 > +function test() { From now on, please write new tests from top down in terms of execution and function names saying what just happened, please. > WebCore/storage/IDBTransactionBackendImpl.cpp:115 > +void IDBTransactionBackendImpl::runNextTasks() I don't like this function name. execute tasks or something? Or just move it into the timer function? > WebCore/storage/IDBTransactionBackendImpl.cpp:121 > + // pump the task queue dry Use complete sentences. Of course this comment doesn't seem necessary. > WebCore/storage/IDBTransactionBackendImpl.cpp:123 > + queue.swap(m_taskQueue); Is there a reason we need to do this? Even if stuff is appended, we can keep running them, right? > WebCore/storage/IDBTransactionBackendImpl.cpp:125 > + OwnPtr<ScriptExecutionContext::Task> task(queue.first().release()); personally I prefer = style initialization, but if you like this better it's fine > WebCore/storage/IDBTransactionBackendImpl.h:72 > + bool m_started; Please use enums to make this a proper state machine. 281901 14 andreip 2010-09-20 16:41:39 -0700 All fixed, except for the below: (In reply to comment #12) > > WebCore/storage/IDBObjectStore.cpp:70 > > return request; > > .release() > Why release? The object store is associated with this transaction and other operations may follow. > > WebCore/storage/IDBObjectStoreBackendImpl.cpp:84 > > + if (transaction) { > > Would this ever not be true? > Yes, we use this to differentiate between the method being called by the object store or by the transaction. > > WebCore/storage/IDBTransaction.cpp:70 > > + throwError(NOT_SUPPORTED_ERR); > > Do you need to add the string for this error somewhere? > I don't think so, it's a standard exception. 281940 15 68163 andreip 2010-09-20 17:26:45 -0700 Created attachment 68163 Patch 281946 16 andreip 2010-09-20 17:28:31 -0700 (In reply to comment #13) > (From update of attachment 68067 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68067&action=review > > > LayoutTests/storage/indexeddb/objectstore-basics-expected.txt:116 > > +db.transaction() > > hu? does this work? Don't you need to save it to a variable? ideally use db.transaction() too? > Yes, you're reading the expected output, not the actual test. > > > LayoutTests/storage/indexeddb/transaction-get.html:18 > > + debug("Accessing a committed transaction should throw"); > > This should be a failure, not a debug > > It's ok to check in a failing result if that's what it should be. > > > LayoutTests/storage/indexeddb/transaction-get.html:22 > > + shouldBe('exc.code', '9'); > > use the constant > > > LayoutTests/storage/indexeddb/transaction-get.html:27 > > +function nonExistingKey() { > > all functions should put { on the next line > > > LayoutTests/storage/indexeddb/transaction-get.html:41 > > + transaction.onabort = unexpectedErrorCallback; > > newline after this maybe? > > > LayoutTests/storage/indexeddb/transaction-get.html:44 > > + var result = store.get('myKey'); > > put in evalAndLog > > > LayoutTests/storage/indexeddb/transaction-get.html:49 > > + var emptyResult = store.get('nonExistingKey'); > > put at the end of gotValue (yes, this is supposed to work, but that'll make it easier to read) > > > LayoutTests/storage/indexeddb/transaction-get.html:80 > > +function test() { > > From now on, please write new tests from top down in terms of execution and function names saying what just happened, please. > These were added in the previous patch. Will look and fix tomorrow. 282088 17 webkit.review.bot 2010-09-20 21:45:45 -0700 Attachment 68163 did not build on chromium: Build output: http://queues.webkit.org/results/3998098 282152 18 jorlow 2010-09-21 02:16:41 -0700 (In reply to comment #14) > All fixed, except for the below: > > (In reply to comment #12) > > > WebCore/storage/IDBObjectStore.cpp:70 > > > return request; > > > > .release() > > > > Why release? The object store is associated with this transaction and other operations may follow. Release just releases one ref as a pass ref pointer. If your last use of a RefPtr is use variable in something that takes a passRefPtr, you should always call .release() so it doesn't have to ref it only to have the RefPtr get rid of its ref a moment later because it's gone out of scope. > > > WebCore/storage/IDBObjectStoreBackendImpl.cpp:84 > > > + if (transaction) { > > > > Would this ever not be true? > > > > > Yes, we use this to differentiate between the method being called by the object store or by the transaction. Then it's a compat hack? If so, add a fixme. > > > WebCore/storage/IDBTransaction.cpp:70 > > > + throwError(NOT_SUPPORTED_ERR); > > > > Do you need to add the string for this error somewhere? > > > > I don't think so, it's a standard exception. Wait...why didn't you use an IndexedDB exception code? This one's probably not valid. (In reply to comment #16) > (In reply to comment #13) > > > > > LayoutTests/storage/indexeddb/transaction-get.html:18 > > > + debug("Accessing a committed transaction should throw"); > > > > This should be a failure, not a debug > > > > It's ok to check in a failing result if that's what it should be. > > > > > LayoutTests/storage/indexeddb/transaction-get.html:22 > > > + shouldBe('exc.code', '9'); > > > > use the constant > > > > > LayoutTests/storage/indexeddb/transaction-get.html:27 > > > +function nonExistingKey() { > > > > all functions should put { on the next line > > > > > LayoutTests/storage/indexeddb/transaction-get.html:41 > > > + transaction.onabort = unexpectedErrorCallback; > > > > newline after this maybe? > > > > > LayoutTests/storage/indexeddb/transaction-get.html:44 > > > + var result = store.get('myKey'); > > > > put in evalAndLog > > > > > LayoutTests/storage/indexeddb/transaction-get.html:49 > > > + var emptyResult = store.get('nonExistingKey'); > > > > put at the end of gotValue (yes, this is supposed to work, but that'll make it easier to read) > > > > > LayoutTests/storage/indexeddb/transaction-get.html:80 > > > +function test() { > > > > From now on, please write new tests from top down in terms of execution and function names saying what just happened, please. > > > > These were added in the previous patch. Will look and fix tomorrow. sounds good 282230 19 68163 jorlow 2010-09-21 05:32:50 -0700 Comment on attachment 68163 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68163&action=review > WebCore/storage/IDBDatabaseBackendImpl.cpp:154 > + ASSERT_UNUSED(mode, !mode); // FIXME: Delete this. Make it more clear that we want to delete the param, not the line of code. > WebCore/storage/IDBDatabaseBackendInterface.h:58 > + // FIXME: remove the default value for the transaction parameter. Make it more clear when this will be possible. > WebCore/storage/IDBObjectStoreBackendImpl.cpp:84 > + if (transaction) { FIXME: This is only necessary until .... > WebCore/storage/IDBPendingTransactionMonitor.cpp:40 > + m_transactions = new Vector<IDBTransactionBackendInterface*>(); NOOOOOO manual memory management! Why make the vector like this? at least store it in an ownPtr...but why not just make Vector a member...and do swap's if you need to? > WebCore/storage/IDBPendingTransactionMonitor.cpp:56 > + delete m_transactions; NOOOOO > WebCore/storage/IDBPendingTransactionMonitor.cpp:68 > + delete m_transactions; NOOOOOO > WebCore/storage/IDBPendingTransactionMonitor.h:58 > + static Vector<IDBTransactionBackendInterface*>* m_transactions; monitor is in browser process, right? if so, it should have BackendImpl pointers....or maybe even refs? > WebCore/storage/IDBRequest.cpp:174 > + if (m_transaction.get()) { no .get() > WebCore/storage/IDBRequest.cpp:180 > + m_transaction.clear(); why clear it? i know we clear objects in a few places, but i'm wondering if it's really worth bothering > WebCore/storage/IDBRequest.h:97 > + RefPtr<IDBTransactionBackendInterface> m_transaction; store an id here...and anywhere else other than backend impls > WebCore/storage/IDBTransaction.cpp:70 > + throwError(NOT_SUPPORTED_ERR); as i mentioned in the other thread, i think this is the wrong error...we should use some idb error. unknown if there isn't one specced yet (and file a spec bug) > WebCore/storage/IDBTransactionBackendImpl.cpp:68 > + if (m_state == IDLE) some of your methods here can always be called (like abort) and bail if it's not in a state where that makes sense...and some like start assume you only call it when it makes sense. Maybe you should be consistent? > WebCore/storage/IDBTransactionBackendImpl.cpp:118 > + remove newline to be consistient with method below? > WebCore/storage/IDBTransactionBackendImpl.cpp:137 > + m_database.clear(); is there any reason we need to do the .clear() if not, it might be better to get rid of didFinishTransaction here and just inline the trnasaction cordinatior calls to match what you do in stuff like ::start() > WebCore/storage/IDBTransactionBackendImpl.cpp:146 > + queue.swap(m_taskQueue); Why do we need to swap like this? If stuff is added, it'll be at the end of the list...and you just keep grabbing the first item. So I think you're ok. Oh...but then I guess you'll need to make the above logic not reschedule another timer......so I guess this is ok. > WebCore/storage/IDBTransactionBackendImpl.cpp:151 > + m_pendingEvents++; should this happen before we call performTask? Otherwise it's possible that the task should call didCompleteTaskEvents But, in general, this seems fairly fragile. Can we do it any better? Maybe keep a list of transactions with pending tasks and then call didCompleteTaskEvents at the end of the while loop on each one? > WebCore/storage/IDBTransactionBackendImpl.h:62 > + IDLE, I believe this is not webkit style. (We do it this way only when matching IDLs.) maybe s/IDLE/Unused/ or NotStarted? > WebCore/storage/IDBTransactionBackendImpl.h:73 > RefPtr<DOMStringList> m_objectStoreNames; This is a long list. Maybe add some newlines in to logically group things together? > WebCore/storage/IDBTransactionCoordinator.cpp:61 > + RefPtr<IDBTransactionBackendInterface> transaction = m_pendingTransactions.get(id); ewwww!!!!!!! we should not pass around transaction interfaces. Lets stick with either ids (when something needs to be passed outside of other backendImpls) or IDBTransactionBackendImpls. note that you just went tot he effort to lookup the _interface_ object a moment ago in the proxy layer > WebCore/storage/IDBTransactionCoordinator.cpp:62 > + ASSERT(transaction); dont' do this when the next instrction would crash anyway > WebCore/storage/IDBTransactionCoordinator.cpp:69 > ASSERT(transaction); not needed...you'll crash on the next line anyway > WebCore/storage/IDBTransactionCoordinator.cpp:71 > + m_runningTransactions.get(transaction->id())->didCompleteTaskEvents(); ewwww we should not pass around transaction interfaces. Lets stick with either ids (when something needs to be passed outside of other backendImpls) or IDBTransactionBackendImpls. > WebCore/storage/IDBTransactionCoordinator.cpp:77 > + ASSERT(transaction); not needed > WebCore/storage/IDBTransactionCoordinator.cpp:83 > + // Add to started transactions list maybe a newline above this? whenever i see code blocks of over 4-5 instructions, i start looking at where there are natural groupings of operations and tend to split there. maybe i'm overly nit-picky tho? period at end > WebCore/storage/IDBTransactionCoordinator.cpp:108 > +IDBTransactionBackendInterface* IDBTransactionCoordinator::transaction(int transactionID) maybe transactionFromId? I don't care much > WebCore/storage/IDBTransactionCoordinator.cpp:125 > + // that's ready to run. For now we only have a single running no need to wrap at 80 chars :-) 2 lines seems ok for somethign this long tho > WebCore/storage/IDBTransactionCoordinator.cpp:138 > +}; extra space > WebKit/chromium/public/WebIDBTransaction.h:62 > + virtual operator WebCore::IDBTransactionBackendInterface*() const = 0; I'm not sure we need this here....the callers should be dealing only with the impl object, right? > WebKit/chromium/src/IDBDatabaseProxy.h:53 > + virtual PassRefPtr<IDBObjectStoreBackendInterface> objectStore(const String& name, unsigned short mode, IDBTransactionBackendInterface* transaction = 0); I don't think you need the default param here > WebKit/chromium/src/IDBFactoryBackendProxy.cpp:74 > + ids[i] = transactions.at(i)->id(); Hm. I guess this works, but I had kinda envisioned doing this at the Chromium level....but i guess i can't come up with any disadvantages to doing it this way and it does seem simpler. ok. > WebKit/chromium/src/IDBObjectStoreProxy.cpp:77 > + IDBTransactionBackendProxy* transactionProxy = static_cast<IDBTransactionBackendProxy*>(transaction); Add a comment explaining why this is safe maybe? > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:72 > +bool IDBTransactionBackendProxy::scheduleTask(PassOwnPtr<ScriptExecutionContext::Task>) Lets get rid of it from the interface then. > WebKit/chromium/src/IDBTransactionBackendProxy.h:52 > + WebKit::WebIDBTransaction* toWebIDBTransaction() const { return m_webIDBTransaction.get(); } this isn't really converting it, so "to" should probably not be here > WebKit/chromium/src/WebIDBFactoryImpl.cpp:69 > + WTF::Vector<WebCore::IDBTransactionBackendInterface*> transactions(pendingIDs.size()); just do a using namespace webocre at the top? > WebKit/chromium/src/WebIDBTransactionImpl.h:-36 > -namespace WebCore { class IDBTransactionBackendInterface; } I believe a using WebCore is OK to do at the top here. > WebKit/chromium/src/WebIDBTransactionImpl.h:50 > + virtual operator WebCore::IDBTransactionBackendInterface*() const; needn't be virtual...maybe just make it inline? Not sure if it makes sense to do this as an operator. The more I deal with operators, the more I've not been super impressed by them. Maybe just getWebCoreBackend? webCoreBackend...or just backend()? 282286 20 68163 jorlow 2010-09-21 07:14:13 -0700 Comment on attachment 68163 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68163&action=review >> WebCore/storage/IDBObjectStoreBackendImpl.cpp:84 >> + if (transaction) { > > FIXME: This is only necessary until .... oh.....i see......i guess 2 methods is cleaner > WebCore/storage/IDBObjectStoreBackendImpl.cpp:86 > + callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::NOT_ALLOWED_ERR, "Get must be called in the context of a transaction.")); crap...at some point this will need to be thrown synchronously....but fine to leave for now. 283003 21 andreip 2010-09-22 10:01:47 -0700 hanks for the review. All fixed except: (In reply to comment #19) > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:40 > > + m_transactions = new Vector<IDBTransactionBackendInterface*>(); > > NOOOOOO manual memory management! > > Why make the vector like this? at least store it in an ownPtr...but why not just make Vector a member...and do swap's if you need to? > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:56 > > + delete m_transactions; > > NOOOOO > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:68 > > + delete m_transactions; > > NOOOOOO > > > WebCore/storage/IDBPendingTransactionMonitor.h:58 > > + static Vector<IDBTransactionBackendInterface*>* m_transactions; > > monitor is in browser process, right? if so, it should have BackendImpl pointers....or maybe even refs? > No, it's in the renderer! Remember we went through all this when we added the pending transaction monitor. Eventually this will live in TLS but for now it is static. And since it's static, we need to maintain the vector's lifetime manually. I am not sure how an OwnPtr can help. > > WebCore/storage/IDBRequest.cpp:174 > > + if (m_transaction.get()) { > > no .get() > > > WebCore/storage/IDBRequest.cpp:180 > > + m_transaction.clear(); > > why clear it? i know we clear objects in a few places, but i'm wondering if it's really worth bothering > We don't need the transaction anymore after this but the request object will only be released later when GC happens. I was therefore opting for clearing the pointer so that we don't needlessly keep the transaction object alive. > > WebCore/storage/IDBRequest.h:97 > > + RefPtr<IDBTransactionBackendInterface> m_transaction; > > store an id here...and anywhere else other than backend impls > > > WebCore/storage/IDBTransaction.cpp:70 > > + throwError(NOT_SUPPORTED_ERR); > > as i mentioned in the other thread, i think this is the wrong error...we should use some idb error. unknown if there isn't one specced yet (and file a spec bug) > Ok, moved to use IDBDatabaseException::NO_SUPPORTED_ERR, which is a clone of the standard DOM one. I wonder why we have to copy standard DOM exception codes in our spec? > > WebCore/storage/IDBTransactionBackendImpl.cpp:68 > > + if (m_state == IDLE) > > some of your methods here can always be called (like abort) and bail if it's not in a state where that makes sense...and some like start assume you only call it when it makes sense. Maybe you should be consistent? > The methods that bail are the ones called from JS side, like abort or scheduleTask (a result of IDBObjectStore::get/put/etc). We don't control when those are called so we bail when there is nothing to do or we need to report an error. The methods that don't bail are part of the internal state machine logic of the transaction and the transaction coordinator. There I have a bunch of asserts to make sure the state is always as expected. > > WebCore/storage/IDBTransactionBackendImpl.cpp:146 > > + queue.swap(m_taskQueue); > > Why do we need to swap like this? If stuff is added, it'll be at the end of the list...and you just keep grabbing the first item. So I think you're ok. > > Oh...but then I guess you'll need to make the above logic not reschedule another timer......so I guess this is ok. > Yes. > > WebCore/storage/IDBTransactionBackendImpl.cpp:151 > > + m_pendingEvents++; > > should this happen before we call performTask? Otherwise it's possible that the task should call didCompleteTaskEvents > That should not happen synchronously. The events complete asynchronously. > But, in general, this seems fairly fragile. Can we do it any better? Maybe keep a list of transactions with pending tasks and then call didCompleteTaskEvents at the end of the while loop on each one? > Added an assert in the IDBRequest dtor to check that the events fired for the associated transaction when the IDBRequest is destroyed. > > > WebKit/chromium/public/WebIDBTransaction.h:62 > > + virtual operator WebCore::IDBTransactionBackendInterface*() const = 0; > > I'm not sure we need this here....the callers should be dealing only with the impl object, right? > We're passing a WebIDBTransaction const ref to the WebIDBObjectStore::get() and such. The get() method needs to pass an IDBTransactionBackendInterface ptr to IDBObjectStoreBackendImpl::get(). It therefore needs to obtain an IDBTransactionBackendInterface from a WebIDBTransaction. This operator achieves that. > > WebKit/chromium/src/IDBDatabaseProxy.h:53 > > + virtual PassRefPtr<IDBObjectStoreBackendInterface> objectStore(const String& name, unsigned short mode, IDBTransactionBackendInterface* transaction = 0); > > I don't think you need the default param here > We're overriding a method from the interface. I think we do? > > > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:72 > > +bool IDBTransactionBackendProxy::scheduleTask(PassOwnPtr<ScriptExecutionContext::Task>) > > Lets get rid of it from the interface then. > If we do, then we must allow the ObjectStore backend impls to use transaction backend impls. So far, we got away with using only interfaces everywhere. Maybe it's ok to leave as is? 283029 22 jorlow 2010-09-22 10:24:20 -0700 (In reply to comment #21) > hanks for the review. All fixed except: > > (In reply to comment #19) > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:40 > > > + m_transactions = new Vector<IDBTransactionBackendInterface*>(); > > > > NOOOOOO manual memory management! > > > > Why make the vector like this? at least store it in an ownPtr...but why not just make Vector a member...and do swap's if you need to? > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:56 > > > + delete m_transactions; > > > > NOOOOO > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:68 > > > + delete m_transactions; > > > > NOOOOOO > > > > > WebCore/storage/IDBPendingTransactionMonitor.h:58 > > > + static Vector<IDBTransactionBackendInterface*>* m_transactions; > > > > monitor is in browser process, right? if so, it should have BackendImpl pointers....or maybe even refs? > > > > No, it's in the renderer! Remember we went through all this when we added the pending transaction monitor. Eventually this will live in TLS but for now it is static. And since it's static, we need to maintain the vector's lifetime manually. I am not sure how an OwnPtr can help. Oh yeah. I remember now. The reason we can't use an own ptr is because we can't have objects with constructors the global scope. Maybe we could make a static function with an own ptr that owns this though? That would be replaced by some TLS based solution in the future. > > > WebCore/storage/IDBRequest.cpp:174 > > > + if (m_transaction.get()) { > > > > no .get() > > > > > WebCore/storage/IDBRequest.cpp:180 > > > + m_transaction.clear(); > > > > why clear it? i know we clear objects in a few places, but i'm wondering if it's really worth bothering > > > > We don't need the transaction anymore after this but the request object will only be released later when GC happens. I was therefore opting for clearing the pointer so that we don't needlessly keep the transaction object alive. Actually it does seem like transactions could introduce some hairy cycles. Probably a good idea. > > > WebCore/storage/IDBRequest.h:97 > > > + RefPtr<IDBTransactionBackendInterface> m_transaction; > > > > store an id here...and anywhere else other than backend impls > > > > > WebCore/storage/IDBTransaction.cpp:70 > > > + throwError(NOT_SUPPORTED_ERR); > > > > as i mentioned in the other thread, i think this is the wrong error...we should use some idb error. unknown if there isn't one specced yet (and file a spec bug) > > > > Ok, moved to use IDBDatabaseException::NO_SUPPORTED_ERR, which is a clone of the standard DOM one. I wonder why we have to copy standard DOM exception codes in our spec? Please start a mailing list thread on this. Do we have issues with needing strings then? (If so, let's do this in another patch maybe?) Do we test this case in the layout tests? > > > WebCore/storage/IDBTransactionBackendImpl.cpp:151 > > > + m_pendingEvents++; > > > > should this happen before we call performTask? Otherwise it's possible that the task should call didCompleteTaskEvents > > > > That should not happen synchronously. The events complete asynchronously. I still think you should move it. > > > WebKit/chromium/public/WebIDBTransaction.h:62 > > > + virtual operator WebCore::IDBTransactionBackendInterface*() const = 0; > > > > I'm not sure we need this here....the callers should be dealing only with the impl object, right? > > > > We're passing a WebIDBTransaction const ref to the WebIDBObjectStore::get() and such. The get() method needs to pass an IDBTransactionBackendInterface ptr to IDBObjectStoreBackendImpl::get(). It therefore needs to obtain an IDBTransactionBackendInterface from a WebIDBTransaction. This operator achieves that. Gotcha....well see my other comment for the operator stuff you added. I feel as though a virtual method would be much more clear. > > > WebKit/chromium/src/IDBDatabaseProxy.h:53 > > > + virtual PassRefPtr<IDBObjectStoreBackendInterface> objectStore(const String& name, unsigned short mode, IDBTransactionBackendInterface* transaction = 0); > > > > I don't think you need the default param here > > > > We're overriding a method from the interface. I think we do? 99% sure we don't and shouldn't. > > > > > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:72 > > > +bool IDBTransactionBackendProxy::scheduleTask(PassOwnPtr<ScriptExecutionContext::Task>) > > > > Lets get rid of it from the interface then. > > > > If we do, then we must allow the ObjectStore backend impls to use transaction backend impls. So far, we got away with using only interfaces everywhere. Maybe it's ok to leave as is? We have many cases where backend impls hold references to other backend impls. I don't see what's different here. I'm pretty sure the plumbing should be trivial. 283364 23 andreip 2010-09-22 16:37:22 -0700 (In reply to comment #22) > (In reply to comment #21) > > hanks for the review. All fixed except: > > > > (In reply to comment #19) > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:40 > > > > + m_transactions = new Vector<IDBTransactionBackendInterface*>(); > > > > > > NOOOOOO manual memory management! > > > > > > Why make the vector like this? at least store it in an ownPtr...but why not just make Vector a member...and do swap's if you need to? > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:56 > > > > + delete m_transactions; > > > > > > NOOOOO > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:68 > > > > + delete m_transactions; > > > > > > NOOOOOO > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.h:58 > > > > + static Vector<IDBTransactionBackendInterface*>* m_transactions; > > > > > > monitor is in browser process, right? if so, it should have BackendImpl pointers....or maybe even refs? > > > > > > > No, it's in the renderer! Remember we went through all this when we added the pending transaction monitor. Eventually this will live in TLS but for now it is static. And since it's static, we need to maintain the vector's lifetime manually. I am not sure how an OwnPtr can help. > > Oh yeah. I remember now. The reason we can't use an own ptr is because we can't have objects with constructors the global scope. Maybe we could make a static function with an own ptr that owns this though? That would be replaced by some TLS based solution in the future. > Hmm, let's chat about this tomorrow. Still not sure it's a great improvement. > > > > > > > WebCore/storage/IDBTransaction.cpp:70 > > > > + throwError(NOT_SUPPORTED_ERR); > > > > > > as i mentioned in the other thread, i think this is the wrong error...we should use some idb error. unknown if there isn't one specced yet (and file a spec bug) > > > > > > > Ok, moved to use IDBDatabaseException::NO_SUPPORTED_ERR, which is a clone of the standard DOM one. I wonder why we have to copy standard DOM exception codes in our spec? > > Please start a mailing list thread on this. Do we have issues with needing strings then? (If so, let's do this in another patch maybe?) Do we test this case in the layout tests? > Ok, will do, > > > > > > > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:72 > > > > +bool IDBTransactionBackendProxy::scheduleTask(PassOwnPtr<ScriptExecutionContext::Task>) > > > > > > Lets get rid of it from the interface then. > > > > > > > If we do, then we must allow the ObjectStore backend impls to use transaction backend impls. So far, we got away with using only interfaces everywhere. Maybe it's ok to leave as is? > > We have many cases where backend impls hold references to other backend impls. I don't see what's different here. I'm pretty sure the plumbing should be trivial. But the object store backend cannot possibly hold a reference to the transaction backend, since multiple transactions can be associated with the same object store backend at the same time. So the transaction needs to be stored in the frontend object and passed into the object store's methods as needed. However, the frontend can only store transaction interface pointers, as Chromium uses proxy objects in the renderer. And since it's the frontend object that supplies the transaction parameter to the object store's backend methods, it follows that these methods can only get an interface pointer and not an impl pointer. Or perhaps I am missing something? 283382 24 68476 andreip 2010-09-22 17:20:15 -0700 Created attachment 68476 Patch 283561 25 jorlow 2010-09-23 02:33:28 -0700 (In reply to comment #23) > (In reply to comment #22) > > (In reply to comment #21) > > > hanks for the review. All fixed except: > > > > > > (In reply to comment #19) > > > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:40 > > > > > + m_transactions = new Vector<IDBTransactionBackendInterface*>(); > > > > > > > > NOOOOOO manual memory management! > > > > > > > > Why make the vector like this? at least store it in an ownPtr...but why not just make Vector a member...and do swap's if you need to? > > > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:56 > > > > > + delete m_transactions; > > > > > > > > NOOOOO > > > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.cpp:68 > > > > > + delete m_transactions; > > > > > > > > NOOOOOO > > > > > > > > > WebCore/storage/IDBPendingTransactionMonitor.h:58 > > > > > + static Vector<IDBTransactionBackendInterface*>* m_transactions; > > > > > > > > monitor is in browser process, right? if so, it should have BackendImpl pointers....or maybe even refs? > > > > > > > > > > No, it's in the renderer! Remember we went through all this when we added the pending transaction monitor. Eventually this will live in TLS but for now it is static. And since it's static, we need to maintain the vector's lifetime manually. I am not sure how an OwnPtr can help. > > > > Oh yeah. I remember now. The reason we can't use an own ptr is because we can't have objects with constructors the global scope. Maybe we could make a static function with an own ptr that owns this though? That would be replaced by some TLS based solution in the future. > > > > Hmm, let's chat about this tomorrow. Still not sure it's a great improvement. Just leave it as is. > > > > > > > > > WebCore/storage/IDBTransaction.cpp:70 > > > > > + throwError(NOT_SUPPORTED_ERR); > > > > > > > > as i mentioned in the other thread, i think this is the wrong error...we should use some idb error. unknown if there isn't one specced yet (and file a spec bug) > > > > > > > > > > Ok, moved to use IDBDatabaseException::NO_SUPPORTED_ERR, which is a clone of the standard DOM one. I wonder why we have to copy standard DOM exception codes in our spec? > > > > Please start a mailing list thread on this. Do we have issues with needing strings then? (If so, let's do this in another patch maybe?) Do we test this case in the layout tests? > > > > Ok, will do, > > > > > > > > > > WebKit/chromium/src/IDBTransactionBackendProxy.cpp:72 > > > > > +bool IDBTransactionBackendProxy::scheduleTask(PassOwnPtr<ScriptExecutionContext::Task>) > > > > > > > > Lets get rid of it from the interface then. > > > > > > > > > > If we do, then we must allow the ObjectStore backend impls to use transaction backend impls. So far, we got away with using only interfaces everywhere. Maybe it's ok to leave as is? > > > > We have many cases where backend impls hold references to other backend impls. I don't see what's different here. I'm pretty sure the plumbing should be trivial. > > > But the object store backend cannot possibly hold a reference to the transaction backend, since multiple transactions can be associated with the same object store backend at the same time. So the transaction needs to be stored in the frontend object and passed into the object store's methods as needed. > > However, the frontend can only store transaction interface pointers, as Chromium uses proxy objects in the renderer. And since it's the frontend object that supplies the transaction parameter to the object store's backend methods, it follows that these methods can only get an interface pointer and not an impl pointer. Or perhaps I am missing something? No, you're right. OK, leave it as is. 283578 26 68476 jorlow 2010-09-23 04:09:05 -0700 Comment on attachment 68476 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68476&action=review few comments until you can get me the re-based version with the test changes....close tho > WebCore/storage/IDBObjectStoreBackendImpl.h:76 > + template <class T, class Method, class Param1, class Param2> Could this stuff just all go in the .cpp? > WebCore/storage/IDBTransactionCoordinator.h:70 > + HashMap<int, RefPtr<IDBTransactionBackendImpl> > m_transactions; This is a little be weird, but probably cleaner than anything else I can think of (like having transactions self ref). > WebCore/storage/IDBTransactionCoordinator.h:72 > + HashSet<IDBTransactionBackendImpl*> m_pendingTransactions; Is this still necessary? 283613 27 68514 andreip 2010-09-23 06:57:46 -0700 Created attachment 68514 Patch 283616 28 68514 jorlow 2010-09-23 07:11:15 -0700 Comment on attachment 68514 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68514&action=review > LayoutTests/storage/indexeddb/objectstore-removeobjectstore.html:104 > + transaction.onabort = unexpectedErrorCallback; do abort events have messages and codes? if so, this won't work > WebCore/storage/IDBTransactionCoordinator.cpp:57 > + m_startedTransactions.add(transaction); assert it's in m_transactions maybe? > WebCore/storage/IDBTransactionCoordinator.cpp:86 > + m_runningTransactions.add(transaction); assert it's in m_transaction still? 283617 29 jorlow 2010-09-23 07:11:31 -0700 r=me 283629 30 andreip 2010-09-23 07:34:47 -0700 Committed r68138: <http://trac.webkit.org/changeset/68138> 283636 31 webkit.review.bot 2010-09-23 07:51:58 -0700 http://trac.webkit.org/changeset/68138 might have broken Chromium Linux Release The following changes are on the blame list: http://trac.webkit.org/changeset/68136 http://trac.webkit.org/changeset/68137 http://trac.webkit.org/changeset/68138 65588 2010-08-26 11:30:25 -0700 2010-09-20 03:51:31 -0700 Patch bug-44700-20100826193022.patch text/plain 37677 andreip ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MGMzNDE3MWJhMzIzOGRmODVkYzI2ZjY4NDNjMTliMWExMjFiNjllNi4uN2JlYzkyMDA3NGNhYzRm NjMxY2M0Y2YzZTg1MzZkYTM0NzZhNDExOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2NyBAQAorMjAxMC0wOC0yNiAgQW5k cmVpIFBvcGVzY3UgIDxhbmRyZWlwQGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSURCT2JqZWN0U3RvcmU6OmdldCBzaG91bGQgcnVu IGluIGEgdHJhbnNhY3Rpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD00NDcwMAorCisgICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAg ICAgICogc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHA6CisgICAgICAgICogc3RvcmFn ZS9JREJEYXRhYmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJEYXRhYmFzZTo6b2JqZWN0 U3RvcmUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjpvYmplY3RTdG9yZSk6Cisg ICAgICAgICogc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmg6CisgICAgICAgIChXZWJD b3JlOjpJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjp0cmFuc2FjdGlvbkNvb3JkaW5hdG9yKToKKyAg ICAgICAgKiBzdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVyZmFjZS5oOgorICAgICAgICAq IHN0b3JhZ2UvSURCT2JqZWN0U3RvcmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0 U3RvcmU6OklEQk9iamVjdFN0b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3Jl OjpnZXQpOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmU6OmFkZCk6CisgICAgICAg IChXZWJDb3JlOjpJREJPYmplY3RTdG9yZTo6cHV0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQk9i amVjdFN0b3JlOjpyZW1vdmUpOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmU6OnJl bW92ZVRyYW5zYWN0aW9uRnJvbVBlbmRpbmdMaXN0KToKKyAgICAgICAgKiBzdG9yYWdlL0lEQk9i amVjdFN0b3JlLmg6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZTo6Y3JlYXRlKToK KyAgICAgICAgKiBzdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6Z2V0KToKKyAgICAgICAgKFdl YkNvcmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OkdldFRhc2s6OkdldFRhc2spOgorICAg ICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6R2V0VGFzazo6cGVyZm9y bVRhc2spOgorICAgICAgICAqIHN0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5oOgor ICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6c2V0VHJhbnNhY3Rp b24pOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6R2V0VGFz azo6fkdldFRhc2spOgorICAgICAgICAqIHN0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50 ZXJmYWNlLmg6CisgICAgICAgICogc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9y LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OnJl bW92ZVBlbmRpbmdUcmFuc2FjdGlvbik6CisgICAgICAgICogc3RvcmFnZS9JREJSZXF1ZXN0LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlJlcXVlc3Q6Om9uU3VjY2Vzcyk6CisgICAgICAgICog c3RvcmFnZS9JREJUcmFuc2FjdGlvbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2Fj dGlvbjo6b2JqZWN0U3RvcmUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBs OjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5z YWN0aW9uQmFja2VuZEltcGw6Om9iamVjdFN0b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRy YW5zYWN0aW9uQmFja2VuZEltcGw6OnNjaGVkdWxlVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpzdGVwKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRy YW5zYWN0aW9uQmFja2VuZEltcGw6OmFib3J0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5z YWN0aW9uQmFja2VuZEltcGw6OnJ1bik6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlv bkJhY2tlbmRJbXBsOjpzdGFydCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJh Y2tlbmRJbXBsOjpydW5OZXh0VGFza3MpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rp b25CYWNrZW5kSW1wbDo6Y29tbWl0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9u QmFja2VuZEltcGw6OmRpZEZpbmlzaFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OklE QlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnRpbWVyRmlyZWQpOgorICAgICAgICAqIHN0b3JhZ2Uv SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbDo6fklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwpOgorICAgICAgICAo V2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6aXNGaW5pc2hlZCk6CisgICAgICAg ICogc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaDoKKyAgICAgICAgKiBz dG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6Y3JlYXRlVHJhbnNhY3Rpb24pOgorICAgICAgICAo V2ViQ29yZTo6SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6YWJvcnQpOgorICAgICAgICAoV2Vi Q29yZTo6SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6ZGlkU3RhcnRUcmFuc2FjdGlvbik6Cisg ICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpkaWRGaW5pc2hUcmFu c2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpw cm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucyk6CisgICAgICAgICogc3RvcmFnZS9JREJUcmFuc2Fj dGlvbkNvb3JkaW5hdG9yLmg6CisKIDIwMTAtMDgtMjYgIE1pa2hhaWwgTmFnYW5vdiAgPG1uYWdh bm92QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBQYXZlbCBGZWxkbWFuLgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcCBiL1dl YkNvcmUvc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHAKaW5kZXggZDMyOThiMzgwZGM4 ZjliYjk3YzYzOWUzNWFiMzliMDc2YmY1MWRkZi4uYjU5YmRmYWYzNDRhMjE4MmExZmNjYWUzOWU1 NGNiYmQ1MzdhOTJkZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tl bmRJbXBsLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCQ3Vyc29yQmFja2VuZEltcGwuY3Bw CkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAiSURCS2V5UmFuZ2UuaCIKICNpbmNsdWRlICJJ REJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmgiCiAjaW5jbHVkZSAiSURCUmVxdWVzdC5oIgorI2lu Y2x1ZGUgIklEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oIgogI2luY2x1ZGUgIlNRTGl0 ZURhdGFiYXNlLmgiCiAjaW5jbHVkZSAiU2VyaWFsaXplZFNjcmlwdFZhbHVlLmgiCiAKZGlmZiAt LWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZS5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uv SURCRGF0YWJhc2UuY3BwCmluZGV4IDc4YTY2NDYwNDY3ZmNjN2Q4Mzc3OWE4ZGY4MjJjYjZhNmIy NWQ0YjMuLjg2YjYyYTAyZjNjNTAxNWJlYTM5NjQ3YmFmZjhiNTZmNzUxNTBkOTkgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZS5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdl L0lEQkRhdGFiYXNlLmNwcApAQCAtNTcsOSArNTcsMTAgQEAgUGFzc1JlZlB0cjxJREJSZXF1ZXN0 PiBJREJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y28KIAogUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gSURCRGF0YWJhc2U6Om9iamVjdFN0b3Jl KGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSkKIHsKKyAgICAvLyBGSVhN RTogcmVtb3ZlIHRoaXMgbWV0aG9kLgogICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJ bnRlcmZhY2U+IG9iamVjdFN0b3JlID0gbV9iYWNrZW5kLT5vYmplY3RTdG9yZShuYW1lLCBtb2Rl KTsKICAgICBBU1NFUlQob2JqZWN0U3RvcmUpOyAvLyBGSVhNRTogSWYgdGhpcyBpcyBudWxsLCB3 ZSBzaG91bGQgcmFpc2UgYSBOT1RfRk9VTkRfRVJSLgotICAgIHJldHVybiBJREJPYmplY3RTdG9y ZTo6Y3JlYXRlKG9iamVjdFN0b3JlLnJlbGVhc2UoKSk7CisgICAgcmV0dXJuIElEQk9iamVjdFN0 b3JlOjpjcmVhdGUob2JqZWN0U3RvcmUucmVsZWFzZSgpLCAtMSk7CiB9CiAKIFBhc3NSZWZQdHI8 SURCUmVxdWVzdD4gSURCRGF0YWJhc2U6OnJlbW92ZU9iamVjdFN0b3JlKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSkKZGlmZiAtLWdpdCBhL1dlYkNv cmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9J REJEYXRhYmFzZUJhY2tlbmRJbXBsLmNwcAppbmRleCAyM2JjNDRlOGMzYjFmYzA5YzZmZTllY2Yz Yjc4YzIyN2YzNTYwMGU3Li5kYTMwZmFhYzExMzkzOTg2OTRmZTljNmJlOTAzMGJmODhkZWFiNzhi IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5jcHAK KysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuY3BwCkBAIC0xNDgs MTEgKzE0OCwxNCBAQCB2b2lkIElEQkRhdGFiYXNlQmFja2VuZEltcGw6OmNyZWF0ZU9iamVjdFN0 b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJgogICAgIGNhbGxiYWNrcy0+b25T dWNjZXNzKG9iamVjdFN0b3JlLmdldCgpKTsKIH0KIAotUGFzc1JlZlB0cjxJREJPYmplY3RTdG9y ZUJhY2tlbmRJbnRlcmZhY2U+IElEQkRhdGFiYXNlQmFja2VuZEltcGw6Om9iamVjdFN0b3JlKGNv bnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSkKK1Bhc3NSZWZQdHI8SURCT2Jq ZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjpvYmplY3RT dG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUsIElEQlRyYW5zYWN0 aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiB7Ci0gICAgLy8gRklYTUU6IElmIG5v IHRyYW5zYWN0aW9uIGlzIHJ1bm5pbmcsIHRoaXMgc2hvdWxkIGltcGxpY2l0bHkgc3RhcnQgb25l LgorICAgIC8vIEZJWE1FOiBEbyBub3QgZXhwb3NlIHRoaXMgbWV0aG9kIHZpYSBJREwuCiAgICAg QVNTRVJUX1VOVVNFRChtb2RlLCAhbW9kZSk7IC8vIEZJWE1FOiBIYW5kbGUgbm9uLXN0YW5kYXJk IG1vZGVzLgotICAgIHJldHVybiBtX29iamVjdFN0b3Jlcy5nZXQobmFtZSk7CisgICAgUmVmUHRy PElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUgPSBtX29iamVjdFN0 b3Jlcy5nZXQobmFtZSk7CisgICAgaWYgKG9iamVjdFN0b3JlKQorICAgICAgICBvYmplY3RTdG9y ZS0+c2V0VHJhbnNhY3Rpb24odHJhbnNhY3Rpb24pOworICAgIHJldHVybiBvYmplY3RTdG9yZS5y ZWxlYXNlKCk7CiB9CiAKIHN0YXRpYyB2b2lkIGRvRGVsZXRlKFNRTGl0ZURhdGFiYXNlJiBkYiwg Y29uc3QgY2hhciogc3FsLCBpbnQ2NF90IGlkKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdl L0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJh Y2tlbmRJbXBsLmgKaW5kZXggMzU0MGIyMTFmOThiOWQzZDVhNmQ5ZGUyZDMwMmMyNzgyOWRlOTg0 Ni4uZjg0ZWE4OTYwNmExM2YzNzA3NWMxZDdmNzRhY2I1YWMxMzNmNzU2NCAxMDA2NDQKLS0tIGEv V2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oCkBAIC01Nyw5ICs1NywxMiBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPERPTVN0cmluZ0xpc3Q+IG9iamVjdFN0b3JlcygpIGNv bnN0OwogCiAgICAgdmlydHVhbCB2b2lkIGNyZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYg bmFtZSwgY29uc3QgU3RyaW5nJiBrZXlQYXRoLCBib29sIGF1dG9JbmNyZW1lbnQsIFBhc3NSZWZQ dHI8SURCQ2FsbGJhY2tzPik7Ci0gICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3Jl QmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25l ZCBzaG9ydCBtb2RlKTsKKyAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNr ZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNo b3J0IG1vZGUsIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSopOwogICAgIHZpcnR1YWwg dm9pZCByZW1vdmVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NSZWZQdHI8SURC Q2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZT4gdHJhbnNhY3Rpb24oRE9NU3RyaW5nTGlzdCogc3RvcmVOYW1lcywgdW5zaWdu ZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0KTsKKworICAgIElEQlRyYW5zYWN0 aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSB7IHJldHVybiBtX3RyYW5z YWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7IH0KKwogcHJpdmF0ZToKICAgICBJREJEYXRhYmFzZUJh Y2tlbmRJbXBsKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwg UGFzc093blB0cjxTUUxpdGVEYXRhYmFzZT4gZGF0YWJhc2UsIElEQlRyYW5zYWN0aW9uQ29vcmRp bmF0b3IqKTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2Vu ZEludGVyZmFjZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVyZmFj ZS5oCmluZGV4IDllMzUzNjk4MTgzZTYwZWIyYmVlYzMxMGJjNDgyNzlmN2I5ZjRkOTEuLjQ0ZjRi OGU5MDhkOWZiNDE3OWRjNTc5MTllMWMzZjliNWNiN2U1MDEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv c3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbnRlcmZhY2UuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvSURCRGF0YWJhc2VCYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTU3LDcgKzU3LDcgQEAgcHVibGlj OgogICAgIC8vIEZJWE1FOiBBZGQgdHJhbnNhY3Rpb24gYW5kIHNldFZlcnNpb24uCiAKICAgICB2 aXJ0dWFsIHZvaWQgY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBT dHJpbmcmIGtleVBhdGgsIGJvb2wgYXV0b0luY3JlbWVudCwgUGFzc1JlZlB0cjxJREJDYWxsYmFj a3M+KSA9IDA7Ci0gICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZElu dGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBzaG9ydCBt b2RlKSA9IDA7CisgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZElu dGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBzaG9ydCBt b2RlLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uID0gMCkgPSAw OwogICAgIHZpcnR1YWwgdm9pZCByZW1vdmVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUs IFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPikgPSAwOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uKERPTVN0cmluZ0xpc3Qq IHN0b3JlTmFtZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCkg PSAwOwogfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuY3BwCmluZGV4IGI0NTdjZDFkMTU4ODZj MTBmYjJlMWYzMzRhM2RjMjJhM2ZkZjFjODUuLmY3YTQ4MTQyOWFiNDVjZDZiM2E3MGQ4MGYzNTk4 ZjU1ODY2MmUwNzcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5j cHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcApAQCAtMzEsNiArMzEs NyBAQAogI2luY2x1ZGUgIklEQkluZGV4LmgiCiAjaW5jbHVkZSAiSURCS2V5LmgiCiAjaW5jbHVk ZSAiSURCS2V5UmFuZ2UuaCIKKyNpbmNsdWRlICJJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9y LmgiCiAjaW5jbHVkZSAiU2VyaWFsaXplZFNjcmlwdFZhbHVlLmgiCiAjaW5jbHVkZSA8d3RmL1Vu dXNlZFBhcmFtLmg+CiAKQEAgLTM4LDggKzM5LDEwIEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK IAotSURCT2JqZWN0U3RvcmU6OklEQk9iamVjdFN0b3JlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3Rv cmVCYWNrZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RTdG9yZSkKK0lEQk9iamVjdFN0b3JlOjpJREJP YmplY3RTdG9yZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gaWRi T2JqZWN0U3RvcmUsIGludCB0cmFuc2FjdGlvbklkKQogICAgIDogbV9vYmplY3RTdG9yZShpZGJP YmplY3RTdG9yZSkKKyAgICAsIG1fdHJhbnNhY3Rpb25JZCh0cmFuc2FjdGlvbklkKQorICAgICwg bV9pc1RyYW5zYWN0aW9uUGVuZGluZyh0cnVlKQogewogICAgIC8vIFdlIHBhc3MgYSByZWZlcmVu Y2UgdG8gdGhpcyBvYmplY3QgYmVmb3JlIGl0IGNhbiBiZSBhZG9wdGVkLgogICAgIHJlbGF4QWRv cHRpb25SZXF1aXJlbWVudCgpOwpAQCAtNjMsNiArNjYsNyBAQCBQYXNzUmVmUHRyPERPTVN0cmlu Z0xpc3Q+IElEQk9iamVjdFN0b3JlOjppbmRleE5hbWVzKCkgY29uc3QKIFBhc3NSZWZQdHI8SURC UmVxdWVzdD4gSURCT2JqZWN0U3RvcmU6OmdldChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LCBQYXNzUmVmUHRyPElEQktleT4ga2V5KQogewogICAgIFJlZlB0cjxJREJSZXF1ZXN0PiBy ZXF1ZXN0ID0gSURCUmVxdWVzdDo6Y3JlYXRlKGNvbnRleHQsIElEQkFueTo6Y3JlYXRlKHRoaXMp KTsKKyAgICByZW1vdmVUcmFuc2FjdGlvbkZyb21QZW5kaW5nTGlzdCgpOwogICAgIG1fb2JqZWN0 U3RvcmUtPmdldChrZXksIHJlcXVlc3QpOwogICAgIHJldHVybiByZXF1ZXN0OwogfQpAQCAtNzAs NiArNzQsNyBAQCBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IElEQk9iamVjdFN0b3JlOjpnZXQoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzcwogUGFzc1JlZlB0cjxJREJSZXF1ZXN0 PiBJREJPYmplY3RTdG9yZTo6YWRkKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBh c3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiB2YWx1ZSwgUGFzc1JlZlB0cjxJREJLZXk+ IGtleSkKIHsKICAgICBSZWZQdHI8SURCUmVxdWVzdD4gcmVxdWVzdCA9IElEQlJlcXVlc3Q6OmNy ZWF0ZShjb250ZXh0LCBJREJBbnk6OmNyZWF0ZSh0aGlzKSk7CisgICAgcmVtb3ZlVHJhbnNhY3Rp b25Gcm9tUGVuZGluZ0xpc3QoKTsKICAgICBtX29iamVjdFN0b3JlLT5wdXQodmFsdWUsIGtleSwg dHJ1ZSwgcmVxdWVzdCk7CiAgICAgcmV0dXJuIHJlcXVlc3Q7CiB9CkBAIC03Nyw2ICs4Miw3IEBA IFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gSURCT2JqZWN0U3RvcmU6OmFkZChTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBjb250ZXh0LCBQYXNzCiBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IElEQk9iamVj dFN0b3JlOjpwdXQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxT ZXJpYWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBQYXNzUmVmUHRyPElEQktleT4ga2V5KQogewog ICAgIFJlZlB0cjxJREJSZXF1ZXN0PiByZXF1ZXN0ID0gSURCUmVxdWVzdDo6Y3JlYXRlKGNvbnRl eHQsIElEQkFueTo6Y3JlYXRlKHRoaXMpKTsKKyAgICByZW1vdmVUcmFuc2FjdGlvbkZyb21QZW5k aW5nTGlzdCgpOwogICAgIG1fb2JqZWN0U3RvcmUtPnB1dCh2YWx1ZSwga2V5LCBmYWxzZSwgcmVx dWVzdCk7CiAgICAgcmV0dXJuIHJlcXVlc3Q7CiB9CkBAIC04NCw2ICs5MCw3IEBAIFBhc3NSZWZQ dHI8SURCUmVxdWVzdD4gSURCT2JqZWN0U3RvcmU6OnB1dChTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBjb250ZXh0LCBQYXNzCiBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IElEQk9iamVjdFN0b3JlOjpy ZW1vdmUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJLZXk+ IGtleSkKIHsKICAgICBSZWZQdHI8SURCUmVxdWVzdD4gcmVxdWVzdCA9IElEQlJlcXVlc3Q6OmNy ZWF0ZShjb250ZXh0LCBJREJBbnk6OmNyZWF0ZSh0aGlzKSk7CisgICAgcmVtb3ZlVHJhbnNhY3Rp b25Gcm9tUGVuZGluZ0xpc3QoKTsKICAgICBtX29iamVjdFN0b3JlLT5yZW1vdmUoa2V5LCByZXF1 ZXN0KTsKICAgICByZXR1cm4gcmVxdWVzdDsKIH0KQEAgLTExNiw2ICsxMjMsMTUgQEAgUGFzc1Jl ZlB0cjxJREJSZXF1ZXN0PiBJREJPYmplY3RTdG9yZTo6b3BlbkN1cnNvcihTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBjb250ZXgKICAgICByZXR1cm4gcmVxdWVzdC5yZWxlYXNlKCk7CiB9CiAKK3Zv aWQgSURCT2JqZWN0U3RvcmU6OnJlbW92ZVRyYW5zYWN0aW9uRnJvbVBlbmRpbmdMaXN0KCkKK3sK KyAgICBpZiAoIW1faXNUcmFuc2FjdGlvblBlbmRpbmcpCisgICAgICAgIHJldHVybjsKKworICAg IG1faXNUcmFuc2FjdGlvblBlbmRpbmcgPSBmYWxzZTsKKyAgICBJREJQZW5kaW5nVHJhbnNhY3Rp b25Nb25pdG9yOjpyZW1vdmVQZW5kaW5nVHJhbnNhY3Rpb24obV90cmFuc2FjdGlvbklkKTsKK30K KwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKElOREVYRURfREFU QUJBU0UpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaCBiL1dl YkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5oCmluZGV4IDAzNWY1ZDhiNDdmYmE4MmNiYzNl ZDI0ODViNWI3ODhlMDMyMzE5MjYuLjUzN2Q5OGU2NWVjY2YwZjU3MWNlMTEwOWQ0MjMzMWMwMTI4 MTQ4Y2UgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5oCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5oCkBAIC00Nyw5ICs0Nyw5IEBAIGNsYXNz IFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZTsKIAogY2xhc3MgSURCT2JqZWN0U3RvcmUgOiBwdWJsaWMg UmVmQ291bnRlZDxJREJPYmplY3RTdG9yZT4gewogcHVibGljOgotICAgIHN0YXRpYyBQYXNzUmVm UHRyPElEQk9iamVjdFN0b3JlPiBjcmVhdGUoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tl bmRJbnRlcmZhY2U+IGlkYk9iamVjdFN0b3JlKQorICAgIHN0YXRpYyBQYXNzUmVmUHRyPElEQk9i amVjdFN0b3JlPiBjcmVhdGUoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZh Y2U+IGlkYk9iamVjdFN0b3JlLCBpbnQgdHJhbnNhY3Rpb25JZCkKICAgICB7Ci0gICAgICAgIHJl dHVybiBhZG9wdFJlZihuZXcgSURCT2JqZWN0U3RvcmUoaWRiT2JqZWN0U3RvcmUpKTsKKyAgICAg ICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBJREJPYmplY3RTdG9yZShpZGJPYmplY3RTdG9yZSwgdHJh bnNhY3Rpb25JZCkpOwogICAgIH0KICAgICB+SURCT2JqZWN0U3RvcmUoKSB7IH0KIApAQCAtNjks OSArNjksMTIgQEAgcHVibGljOgogICAgIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gb3BlbkN1cnNv cihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxJREJLZXlSYW5nZT4gPSAwLCB1 bnNpZ25lZCBzaG9ydCBkaXJlY3Rpb24gPSBJREJDdXJzb3I6Ok5FWFQpOwogCiBwcml2YXRlOgot ICAgIElEQk9iamVjdFN0b3JlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJm YWNlPik7CisgICAgSURCT2JqZWN0U3RvcmUoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tl bmRJbnRlcmZhY2U+LCBpbnQgdHJhbnNhY3Rpb25faWQpOworICAgIHZvaWQgcmVtb3ZlVHJhbnNh Y3Rpb25Gcm9tUGVuZGluZ0xpc3QoKTsKIAogICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tl bmRJbnRlcmZhY2U+IG1fb2JqZWN0U3RvcmU7CisgICAgaW50IG1fdHJhbnNhY3Rpb25JZDsKKyAg ICBib29sIG1faXNUcmFuc2FjdGlvblBlbmRpbmc7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1w bC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5jcHAKaW5k ZXggMWI5Yjc2YmNhMmZmNjZmMGM2N2RhMjNhMTA4YjM2Y2UxNWVlNDJlMC4uZTQ5ZGU4OWIzODBm NDA0OTc3NzJhMzJiNTUxOWMwZWFlN2FjNTVmNiAxMDA3NTUKLS0tIGEvV2ViQ29yZS9zdG9yYWdl L0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJP YmplY3RTdG9yZUJhY2tlbmRJbXBsLmNwcApAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIklE QktleVBhdGguaCIKICNpbmNsdWRlICJJREJLZXlQYXRoQmFja2VuZEltcGwuaCIKICNpbmNsdWRl ICJJREJLZXlSYW5nZS5oIgorI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFj ZS5oIgogI2luY2x1ZGUgIlNRTGl0ZURhdGFiYXNlLmgiCiAjaW5jbHVkZSAiU1FMaXRlU3RhdGVt ZW50LmgiCiAKQEAgLTEwOCwyMiArMTA5LDEzIEBAIHN0YXRpYyB2b2lkIGJpbmRXaGVyZUNsYXVz ZShTUUxpdGVTdGF0ZW1lbnQmIHF1ZXJ5LCBpbnQ2NF90IGlkLCBJREJLZXkqIGtleSkKIAogdm9p ZCBJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjpnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwg UGFzc1JlZlB0cjxJREJDYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBTUUxpdGVTdGF0ZW1l bnQgcXVlcnkoc3FsaXRlRGF0YWJhc2UoKSwgIlNFTEVDVCBrZXlTdHJpbmcsIGtleURhdGUsIGtl eU51bWJlciwgdmFsdWUgRlJPTSBPYmplY3RTdG9yZURhdGEgIiArIHdoZXJlQ2xhdXNlKGtleS0+ dHlwZSgpKSk7Ci0gICAgYm9vbCBvayA9IHF1ZXJ5LnByZXBhcmUoKSA9PSBTUUxSZXN1bHRPazsK LSAgICBBU1NFUlRfVU5VU0VEKG9rLCBvayk7IC8vIEZJWE1FOiBCZXR0ZXIgZXJyb3IgaGFuZGxp bmc/Ci0KLSAgICBiaW5kV2hlcmVDbGF1c2UocXVlcnksIG1faWQsIGtleS5nZXQoKSk7Ci0gICAg aWYgKHF1ZXJ5LnN0ZXAoKSAhPSBTUUxSZXN1bHRSb3cpIHsKLSAgICAgICAgY2FsbGJhY2tzLT5v bkVycm9yKElEQkRhdGFiYXNlRXJyb3I6OmNyZWF0ZShJREJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9U X0ZPVU5EX0VSUiwgIktleSBkb2VzIG5vdCBleGlzdCBpbiB0aGUgb2JqZWN0IHN0b3JlLiIpKTsK KyAgICBpZiAoIW1fdHJhbnNhY3Rpb24pIHsKKyAgICAgICAgY2FsbGJhY2tzLT5vbkVycm9yKElE QkRhdGFiYXNlRXJyb3I6OmNyZWF0ZShJREJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9UX0FMTE9XRURf RVJSLCAiR2V0IG11c3QgYmUgY2FsbGVkIGluIHRoZSBjb250ZXh0IG9mIGEgdHJhbnNhY3Rpb24u IikpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCi0gICAgQVNTRVJUKChrZXktPnR5cGUoKSA9 PSBJREJLZXk6OlN0cmluZ1R5cGUpICE9IHF1ZXJ5LmlzQ29sdW1uTnVsbCgwKSk7Ci0gICAgLy8g RklYTUU6IEltcGxlbWVudCBkYXRlLgotICAgIEFTU0VSVCgoa2V5LT50eXBlKCkgPT0gSURCS2V5 OjpOdW1iZXJUeXBlKSAhPSBxdWVyeS5pc0NvbHVtbk51bGwoMikpOwotCi0gICAgY2FsbGJhY2tz LT5vblN1Y2Nlc3MoU2VyaWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGVGcm9tV2lyZShxdWVyeS5n ZXRDb2x1bW5UZXh0KDMpKSk7Ci0gICAgQVNTRVJUKHF1ZXJ5LnN0ZXAoKSAhPSBTUUxSZXN1bHRS b3cpOworICAgIE93blB0cjxHZXRUYXNrPiBnZXRUYXNrID0gYWRvcHRQdHIobmV3IEdldFRhc2so bV90cmFuc2FjdGlvbi5nZXQoKSwga2V5LCBtX2lkLCBjYWxsYmFja3MsIHNxbGl0ZURhdGFiYXNl KCkpKTsKKyAgICBtX3RyYW5zYWN0aW9uLT5zY2hlZHVsZVRhc2soZ2V0VGFzay5sZWFrUHRyKCkp OwogfQogCiB2b2lkIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OnB1dChQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gcHJwVmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5PiBwcnBLZXks IGJvb2wgYWRkT25seSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+IGNhbGxiYWNrcykKQEAgLTMw OCw2ICszMDAsMzcgQEAgU1FMaXRlRGF0YWJhc2UmIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6 OnNxbGl0ZURhdGFiYXNlKCkgY29uc3QKICAgICByZXR1cm4gbV9kYXRhYmFzZS0+c3FsaXRlRGF0 YWJhc2UoKTsKIH0KIAorCitJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjpHZXRUYXNrOjpHZXRU YXNrKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24sIFBhc3NSZWZQ dHI8SURCS2V5PiBrZXksIGludDY0X3QgaWQsIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiBjYWxs YmFja3MsIFNRTGl0ZURhdGFiYXNlJiBkYXRhYmFzZSkKKyAgICA6IG1fdHJhbnNhY3Rpb24odHJh bnNhY3Rpb24pCisgICAgLCBtX2tleShrZXkpCisgICAgLCBtX2lkKGlkKQorICAgICwgbV9jYWxs YmFja3MoY2FsbGJhY2tzKQorICAgICwgbV9kYXRhYmFzZShkYXRhYmFzZSkKK3sKK30KKwordm9p ZCBJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjpHZXRUYXNrOjpwZXJmb3JtVGFzayhTY3JpcHRF eGVjdXRpb25Db250ZXh0KikKK3sKKyAgICBTUUxpdGVTdGF0ZW1lbnQgcXVlcnkobV9kYXRhYmFz ZSwgIlNFTEVDVCBrZXlTdHJpbmcsIGtleURhdGUsIGtleU51bWJlciwgdmFsdWUgRlJPTSBPYmpl Y3RTdG9yZURhdGEgIiArIHdoZXJlQ2xhdXNlKG1fa2V5LT50eXBlKCkpKTsKKyAgICBib29sIG9r ID0gcXVlcnkucHJlcGFyZSgpID09IFNRTFJlc3VsdE9rOworICAgIEFTU0VSVF9VTlVTRUQob2ss IG9rKTsgLy8gRklYTUU6IEJldHRlciBlcnJvciBoYW5kbGluZz8KKworICAgIGJpbmRXaGVyZUNs YXVzZShxdWVyeSwgbV9pZCwgbV9rZXkuZ2V0KCkpOworICAgIGlmIChxdWVyeS5zdGVwKCkgIT0g U1FMUmVzdWx0Um93KSB7CisgICAgICAgIG1fY2FsbGJhY2tzLT5vbkVycm9yKElEQkRhdGFiYXNl RXJyb3I6OmNyZWF0ZShJREJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9UX0ZPVU5EX0VSUiwgIktleSBk b2VzIG5vdCBleGlzdCBpbiB0aGUgb2JqZWN0IHN0b3JlLiIpKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIEFTU0VSVCgobV9rZXktPnR5cGUoKSA9PSBJREJLZXk6OlN0cmluZ1R5cGUp ICE9IHF1ZXJ5LmlzQ29sdW1uTnVsbCgwKSk7CisgICAgLy8gRklYTUU6IEltcGxlbWVudCBkYXRl LgorICAgIEFTU0VSVCgobV9rZXktPnR5cGUoKSA9PSBJREJLZXk6Ok51bWJlclR5cGUpICE9IHF1 ZXJ5LmlzQ29sdW1uTnVsbCgyKSk7CisKKyAgICBtX2NhbGxiYWNrcy0+b25TdWNjZXNzKFNlcmlh bGl6ZWRTY3JpcHRWYWx1ZTo6Y3JlYXRlRnJvbVdpcmUocXVlcnkuZ2V0Q29sdW1uVGV4dCgzKSkp OworICAgIEFTU0VSVChxdWVyeS5zdGVwKCkgIT0gU1FMUmVzdWx0Um93KTsKK30KKworCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdl L0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RT dG9yZUJhY2tlbmRJbXBsLmgKaW5kZXggZTEwNThjOGY2ZmMxMTcwNzAwNmQxMDExYmVkZjQxNjlk MjQ2YTAwNC4uYjc3YzhmMjAyMTMzNTQ1YjIxMTVmYzEyN2YwZjk2ZjY1ZDgyYzgxYSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuaAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5oCkBAIC0yNyw2ICsyNyw3 IEBACiAjZGVmaW5lIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGxfaAogCiAjaW5jbHVkZSAiSURC T2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgiCisjaW5jbHVkZSA8U2NyaXB0RXhlY3V0aW9u Q29udGV4dC5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQv U3RyaW5nSGFzaC5oPgogCkBAIC0zNSw2ICszNiw3IEBACiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK IGNsYXNzIElEQkRhdGFiYXNlQmFja2VuZEltcGw7CitjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2U7CiBjbGFzcyBTUUxpdGVEYXRhYmFzZTsKIAogY2xhc3MgSURCT2JqZWN0U3Rv cmVCYWNrZW5kSW1wbCA6IHB1YmxpYyBJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UgewpA QCAtNjIsMTIgKzY0LDI4IEBAIHB1YmxpYzoKIAogICAgIElEQkRhdGFiYXNlQmFja2VuZEltcGwq IGRhdGFiYXNlKCkgY29uc3QgeyByZXR1cm4gbV9kYXRhYmFzZS5nZXQoKTsgfQogCisgICAgdm9p ZCBzZXRUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0 aW9uKSB7IG1fdHJhbnNhY3Rpb24gPSB0cmFuc2FjdGlvbjsgfQorCiBwcml2YXRlOgogICAgIElE Qk9iamVjdFN0b3JlQmFja2VuZEltcGwoSURCRGF0YWJhc2VCYWNrZW5kSW1wbCosIGludDY0X3Qg aWQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBrZXlQYXRoLCBib29sIGF1dG9J bmNyZW1lbnQpOwogCiAgICAgdm9pZCBsb2FkSW5kZXhlcygpOwogICAgIFNRTGl0ZURhdGFiYXNl JiBzcWxpdGVEYXRhYmFzZSgpIGNvbnN0OwogCisgICAgY2xhc3MgR2V0VGFzayA6IHB1YmxpYyBT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKKyAgICBwdWJsaWM6CisgICAgICAgIEdldFRh c2soSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiwgUGFzc1JlZlB0cjxJREJLZXk+LCBp bnQ2NF90IGlkLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4sIFNRTGl0ZURhdGFiYXNlJik7Cisg ICAgICAgIHZpcnR1YWwgfkdldFRhc2soKSB7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIHBlcmZv cm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKTsKKworICAgIHByaXZhdGU6CisgICAgICAg IFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IG1fdHJhbnNhY3Rpb247Cisg ICAgICAgIFJlZlB0cjxJREJLZXk+IG1fa2V5OworICAgICAgICBpbnQ2NF90IG1faWQ7CisgICAg ICAgIFJlZlB0cjxJREJDYWxsYmFja3M+IG1fY2FsbGJhY2tzOworICAgICAgICBTUUxpdGVEYXRh YmFzZSYgbV9kYXRhYmFzZTsKKyAgICB9OworCiAgICAgUmVmUHRyPElEQkRhdGFiYXNlQmFja2Vu ZEltcGw+IG1fZGF0YWJhc2U7CiAKICAgICBpbnQ2NF90IG1faWQ7CkBAIC03Nyw2ICs5NSw4IEBA IHByaXZhdGU6CiAKICAgICB0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8SURCSW5kZXhC YWNrZW5kSW50ZXJmYWNlPiA+IEluZGV4TWFwOwogICAgIEluZGV4TWFwIG1faW5kZXhlczsKKwor ICAgIFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IG1fdHJhbnNhY3Rpb247 CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3Jh Z2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmggYi9XZWJDb3JlL3N0b3JhZ2UvSURC T2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgKaW5kZXggMjAwYWMyOWJhN2NjYTE1OTgxODVl MzU5M2JmYTRkNmZiNjNhMWQ0ZS4uMzJhMDkyMzM1ODE5NjlmOWZmODg5MjJjMTc0MWEyMWIwZGU0 ODcxYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZElu dGVyZmFjZS5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbnRl cmZhY2UuaApAQCAtMzgsNiArMzgsNyBAQCBjbGFzcyBJREJDYWxsYmFja3M7CiBjbGFzcyBJREJJ bmRleEJhY2tlbmRJbnRlcmZhY2U7CiBjbGFzcyBJREJLZXk7CiBjbGFzcyBJREJLZXlSYW5nZTsK K2NsYXNzIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZTsKIGNsYXNzIFNlcmlhbGl6ZWRT Y3JpcHRWYWx1ZTsKIAogY2xhc3MgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlIDogcHVi bGljIFRocmVhZFNhZmVTaGFyZWQ8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiB7CkBA IC01Nyw2ICs1OCw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlSW5kZXgoY29u c3QgU3RyaW5nJiBuYW1lLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pID0gMDsKIAogICAgIHZp cnR1YWwgdm9pZCBvcGVuQ3Vyc29yKFBhc3NSZWZQdHI8SURCS2V5UmFuZ2U+LCB1bnNpZ25lZCBz aG9ydCBkaXJlY3Rpb24sIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPikgPSAwOworCisgICAgdmly dHVhbCB2b2lkIHNldFRyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSop ID0gMDsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUv c3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcCBiL1dlYkNvcmUvc3RvcmFn ZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcAppbmRleCBkMDI2MDk5MDhhYjU3Y2Rj MDFkMzk4Njk1ZWIyNjUzNjMyMzYxYTliLi4wMjBjYjJlYjk3ZDgzNDI3NGFmYjkzNDVhMWRmZjY1 OTNkNjBlYzk3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0 aW9uTW9uaXRvci5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlv bk1vbml0b3IuY3BwCkBAIC00Niw3ICs0NiwxNSBAQCB2b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlv bk1vbml0b3I6OmFkZFBlbmRpbmdUcmFuc2FjdGlvbihpbnQgaWQpCiAKIHZvaWQgSURCUGVuZGlu Z1RyYW5zYWN0aW9uTW9uaXRvcjo6cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKGludCBpZCkKIHsK LSAgICBtX2lkcy0+cmVtb3ZlKGlkKTsKKyAgICBpZiAoIW1faWRzKQorICAgICAgICByZXR1cm47 CisKKyAgICBzaXplX3QgcG9zID0gbV9pZHMtPmZpbmQoaWQpOworICAgIGlmIChwb3MgPT0gbm90 Rm91bmQpCisgICAgICAgIHJldHVybjsKKworICAgIG1faWRzLT5yZW1vdmUocG9zKTsKKwogICAg IGlmICghbV9pZHMtPnNpemUoKSkgewogICAgICAgICBkZWxldGUgbV9pZHM7CiAgICAgICAgIG1f aWRzID0gMDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0LmNwcCBiL1dl YkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0LmNwcAppbmRleCA5NGVmN2U1MmUwMjdhNjk5MzdlMDQy YmExYzliNGM1OGFlYTZhMzNiLi5jMDhhNWFlYjhiYjAzY2UwZDczMjM4NzJmNmU2ZjE2OTdjNWE1 NWIxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5jcHAKKysrIGIvV2Vi Q29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuY3BwCkBAIC0xMDAsNyArMTAwLDggQEAgdm9pZCBJREJS ZXF1ZXN0OjpvblN1Y2Nlc3MoUGFzc1JlZlB0cjxJREJLZXk+IGlkYktleSkKIHZvaWQgSURCUmVx dWVzdDo6b25TdWNjZXNzKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNl PiBiYWNrZW5kKQogewogICAgIG9uRXZlbnRDb21tb24oKTsKLSAgICBtX3Jlc3VsdC0+c2V0KElE Qk9iamVjdFN0b3JlOjpjcmVhdGUoYmFja2VuZCkpOworICAgIC8vIEZJWE1FOiB0aGUgdHJhbnNh Y3Rpb24gaWQgc2hvdWxkIGJlIHRoZSBvbmUgb2YgdGhlIHNldFZlcnNpb24gdHJhbnNhY3Rpb24u CisgICAgbV9yZXN1bHQtPnNldChJREJPYmplY3RTdG9yZTo6Y3JlYXRlKGJhY2tlbmQsIC0xKSk7 CiB9CiAKIHZvaWQgSURCUmVxdWVzdDo6b25TdWNjZXNzKFBhc3NSZWZQdHI8U2VyaWFsaXplZFNj cmlwdFZhbHVlPiBzZXJpYWxpemVkU2NyaXB0VmFsdWUpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0 b3JhZ2UvSURCVHJhbnNhY3Rpb24uY3BwIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9u LmNwcAppbmRleCA0ZTkzMzc4ZGRiN2JlYjJiMmI4NzUzNGJlNjdiMzc0ZGQzMzg0OTU4Li45YjYx OTQ0ZGQ5MzI4OTBhZmY5ZDFhY2U2Y2YwNjA0MmNlYTIxMTczIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3N0b3JhZ2UvSURCVHJhbnNhY3Rpb24uY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFu c2FjdGlvbi5jcHAKQEAgLTY2LDcgKzY2LDcgQEAgSURCRGF0YWJhc2UqIElEQlRyYW5zYWN0aW9u OjpkYigpCiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBJREJUcmFuc2FjdGlvbjo6b2JqZWN0 U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBFeGNlcHRpb25Db2RlJikKIHsKICAgICBS ZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZUJhY2tlbmQg PSBtX2JhY2tlbmQtPm9iamVjdFN0b3JlKG5hbWUpOwotICAgIFJlZlB0cjxJREJPYmplY3RTdG9y ZT4gb2JqZWN0U3RvcmUgPSBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9iamVjdFN0b3JlQmFja2Vu ZCk7CisgICAgUmVmUHRyPElEQk9iamVjdFN0b3JlPiBvYmplY3RTdG9yZSA9IElEQk9iamVjdFN0 b3JlOjpjcmVhdGUob2JqZWN0U3RvcmVCYWNrZW5kLCBpZCgpKTsKICAgICByZXR1cm4gb2JqZWN0 U3RvcmUucmVsZWFzZSgpOwogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25C YWNrZW5kSW1wbC5jcHAKaW5kZXggNTFiMzNiMjM0MDAxNDc3ZjNiNjI5ZDRmNTQ4MjIyODAzNGRj ODFkMC4uNzMxZTNjZjFkNDhjNTJlZmRhMWUyMGFlMWNlODM3NDY5MTIxYTI5YSAxMDA3NTUKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuY3BwCisrKyBiL1dl YkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmNwcApAQCAtMjksNiArMjks NyBAQAogI2lmIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQogCiAjaW5jbHVkZSAiSURCRGF0YWJh c2VCYWNrZW5kSW1wbC5oIgorI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaCIK ICNpbmNsdWRlICJTUUxpdGVEYXRhYmFzZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00 MywyNiArNDQsMTA5IEBAIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OklEQlRyYW5zYWN0aW9u QmFja2VuZEltcGwoRE9NU3RyaW5nTGlzdCogb2JqZWN0U3RvcmVzCiAgICAgLCBtX21vZGUobW9k ZSkKICAgICAsIG1fdGltZW91dCh0aW1lb3V0KQogICAgICwgbV9pZChpZCkKLSAgICAsIG1fYWJv cnRlZChmYWxzZSkKKyAgICAsIG1fc3RhcnRlZChmYWxzZSkKKyAgICAsIG1fZmluaXNoZWQoZmFs c2UpCiAgICAgLCBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAgICwgbV90cmFuc2FjdGlvbihuZXcg U1FMaXRlVHJhbnNhY3Rpb24oZGF0YWJhc2UtPnNxbGl0ZURhdGFiYXNlKCkpKQorICAgICwgbV90 aW1lcih0aGlzLCAmSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZCkKIHsKIH0K IAogUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IElEQlRyYW5zYWN0 aW9uQmFja2VuZEltcGw6Om9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSkKIHsKLSAgICBy ZXR1cm4gbV9kYXRhYmFzZS0+b2JqZWN0U3RvcmUobmFtZSwgMCk7IC8vIEZJWE1FOiByZW1vdmUg bW9kZSBwYXJhbS4KKyAgICByZXR1cm4gbV9kYXRhYmFzZS0+b2JqZWN0U3RvcmUobmFtZSwgMCwg dGhpcyk7IC8vIEZJWE1FOiByZW1vdmUgbW9kZSBwYXJhbS4KIH0KIAotdm9pZCBJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbXBsOjpzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPikKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6c2NoZWR1bGVU YXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaykKIHsKLSAg ICAvLyBGSVhNRTogaW1wbGVtZW50LgotICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIEFT U0VSVCghbV9maW5pc2hlZCk7CisKKyAgICBtX3Rhc2tRdWV1ZS5hcHBlbmQodGFzayk7CisKKyAg ICBpZiAoIW1fc3RhcnRlZCkKKyAgICAgICAgc3RhcnQoKTsKK30KKwordm9pZCBJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbXBsOjpzdGVwKCkKK3sKKyAgICBBU1NFUlQoIW1fZmluaXNoZWQpOworICAg IEFTU0VSVChtX3N0YXJ0ZWQpOworCisgICAgaWYgKCFtX3Rhc2tRdWV1ZS5pc0VtcHR5KCkpIHsK KyAgICAgICAgcnVuTmV4dFRhc2tzKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBj b21taXQoKTsKIH0KIAogdm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjphYm9ydCgpCiB7 Ci0gICAgbV9hYm9ydGVkID0gdHJ1ZTsKKyAgICBpZiAobV9maW5pc2hlZCkKKyAgICAgICAgcmV0 dXJuOworCisgICAgbV9maW5pc2hlZCA9IHRydWU7CisgICAgbV90cmFuc2FjdGlvbi0+cm9sbGJh Y2soKTsKICAgICBtX2NhbGxiYWNrcy0+b25BYm9ydCgpOworCisgICAgZGlkRmluaXNoVHJhbnNh Y3Rpb24oKTsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpydW4oKQorewor ICAgIEFTU0VSVChtX3N0YXJ0ZWQpOworICAgIEFTU0VSVCghbV9maW5pc2hlZCk7CisKKyAgICBt X3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsOjpzdGFydCgpCit7CisgICAgQVNTRVJUKCFtX3N0YXJ0ZWQpOworICAgIEFTU0VSVCghbV9m aW5pc2hlZCk7CisKKyAgICBtX3N0YXJ0ZWQgPSB0cnVlOworICAgIG1fdHJhbnNhY3Rpb24tPmJl Z2luKCk7CisKKyAgICBtX2RhdGFiYXNlLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCktPmRpZFN0 YXJ0VHJhbnNhY3Rpb24obV9pZCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1w bDo6cnVuTmV4dFRhc2tzKCkKK3sKKyAgICBBU1NFUlQoIW1fdGFza1F1ZXVlLmlzRW1wdHkoKSk7 CisgICAgQVNTRVJUKG1fc3RhcnRlZCk7CisgICAgQVNTRVJUKCFtX2ZpbmlzaGVkKTsKKworICAg IC8vIHB1bXAgdGhlIHRhc2sgcXVldWUgZHJ5CisgICAgVGFza1F1ZXVlIHF1ZXVlOworICAgIHF1 ZXVlLnN3YXAobV90YXNrUXVldWUpOworICAgIHdoaWxlICghcXVldWUuaXNFbXB0eSgpKSB7Cisg ICAgICAgIE93blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrKHF1ZXVlLmZp cnN0KCkucmVsZWFzZSgpKTsKKyAgICAgICAgcXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICAgICAg dGFzay0+cGVyZm9ybVRhc2soMCk7CisgICAgfQorfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQmFj a2VuZEltcGw6OmNvbW1pdCgpCit7CisgICAgQVNTRVJUKCFtX2ZpbmlzaGVkKTsKKyAgICBBU1NF UlQobV9zdGFydGVkKTsKKworICAgIG1fZmluaXNoZWQgPSB0cnVlOworICAgIG1fdHJhbnNhY3Rp b24tPmNvbW1pdCgpOworCisgICAgZGlkRmluaXNoVHJhbnNhY3Rpb24oKTsKK30KKwordm9pZCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpkaWRGaW5pc2hUcmFuc2FjdGlvbigpCit7CisgICAg bV9kYXRhYmFzZS0+dHJhbnNhY3Rpb25Db29yZGluYXRvcigpLT5kaWRGaW5pc2hUcmFuc2FjdGlv bihtX2lkKTsKKyAgICBtX2RhdGFiYXNlLmNsZWFyKCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rp b25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZChUaW1lcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBs PiopCit7CisgICAgcnVuTmV4dFRhc2tzKCk7CiB9CiAKIH07CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lE QlRyYW5zYWN0aW9uQmFja2VuZEltcGwuaAppbmRleCBmYjU3NDAxN2ZhYmU1MjQzZWI1ZDdjMTdh ODJiMGEyNWU2MjhlMDg3Li44MTRhYzY3MDMzYWU3MmEyNTM3ODJmNTIyZTM2NDY4N2MyMTkzY2Qx IDEwMDc1NQotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5o CisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmgKQEAgLTMx LDYgKzMxLDggQEAKICNpbmNsdWRlICJET01TdHJpbmdMaXN0LmgiCiAjaW5jbHVkZSAiSURCVHJh bnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25DYWxs YmFja3MuaCIKKyNpbmNsdWRlIDxTUUxpdGVUcmFuc2FjdGlvbi5oPgorI2luY2x1ZGUgPHd0Zi9E ZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpA QCAtNDAsMjUgKzQyLDQxIEBAIGNsYXNzIElEQkRhdGFiYXNlQmFja2VuZEltcGw7CiBjbGFzcyBJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsIDogcHVibGljIElEQlRyYW5zYWN0aW9uQmFja2VuZElu dGVyZmFjZSB7CiBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb25C YWNrZW5kSW50ZXJmYWNlPiBjcmVhdGUoRE9NU3RyaW5nTGlzdCogb2JqZWN0U3RvcmVzLCB1bnNp Z25lZCBzaG9ydCBtb2RlLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQsIGludCBpZCwgSURCRGF0YWJh c2VCYWNrZW5kSW1wbCopOwotICAgIHZpcnR1YWwgfklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwo KSB7IH0KKyAgICB2aXJ0dWFsIH5JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKCkgeyBhYm9ydCgp OyB9CiAKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJm YWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUpOwogICAgIHZpcnR1YWwgdW5zaWdu ZWQgc2hvcnQgbW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fbW9kZTsgfQogICAgIHZpcnR1YWwgdm9p ZCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7 CisgICAgdmlydHVhbCB2b2lkIHN0ZXAoKTsKICAgICB2aXJ0dWFsIHZvaWQgYWJvcnQoKTsKKyAg ICB2aXJ0dWFsIGJvb2wgaXNGaW5pc2hlZCgpIHsgcmV0dXJuIG1fZmluaXNoZWQ7IH0KICAgICB2 aXJ0dWFsIGludCBpZCgpIGNvbnN0IHsgcmV0dXJuIG1faWQ7IH0KICAgICB2aXJ0dWFsIHZvaWQg c2V0Q2FsbGJhY2tzKElEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzKiBjYWxsYmFja3MpIHsgbV9jYWxs YmFja3MgPSBjYWxsYmFja3M7IH0KIAorICAgIHZvaWQgcnVuKCk7CisKIHByaXZhdGU6CiAgICAg SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbChET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVu c2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRh YmFzZUJhY2tlbmRJbXBsKik7CiAKKyAgICB2b2lkIHN0YXJ0KCk7CisgICAgdm9pZCBydW5OZXh0 VGFza3MoKTsKKyAgICB2b2lkIGNvbW1pdCgpOworICAgIHZvaWQgZGlkRmluaXNoVHJhbnNhY3Rp b24oKTsKKworICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsPiopOworCiAgICAgUmVmUHRyPERPTVN0cmluZ0xpc3Q+IG1fb2JqZWN0U3RvcmVOYW1lczsK ICAgICB1bnNpZ25lZCBzaG9ydCBtX21vZGU7CiAgICAgdW5zaWduZWQgbG9uZyBtX3RpbWVvdXQ7 CiAgICAgaW50IG1faWQ7Ci0gICAgYm9vbCBtX2Fib3J0ZWQ7CisgICAgYm9vbCBtX3N0YXJ0ZWQ7 CisgICAgYm9vbCBtX2ZpbmlzaGVkOwogICAgIFJlZlB0cjxJREJUcmFuc2FjdGlvbkNhbGxiYWNr cz4gbV9jYWxsYmFja3M7CiAgICAgUmVmUHRyPElEQkRhdGFiYXNlQmFja2VuZEltcGw+IG1fZGF0 YWJhc2U7CisgICAgdHlwZWRlZiBEZXF1ZTxPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6 VGFzaz4gPiBUYXNrUXVldWU7CisgICAgVGFza1F1ZXVlIG1fdGFza1F1ZXVlOworICAgIE93blB0 cjxTUUxpdGVUcmFuc2FjdGlvbj4gbV90cmFuc2FjdGlvbjsKKyAgICBUaW1lcjxJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbXBsPiBtX3RpbWVyOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFj ZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oCmlu ZGV4IDM5NjUxZjEwMTc1ZGU3MDYwZDA0NWE5ZjBjNjIzOTNjNmFlMzc1ZGMuLmQ0Njc4ZWY4ZmVk ODZhODA4ZWJkNmFiZjk1MjVhMTU0MjYxY2JkYjYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFn ZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uv SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTUxLDYgKzUxLDcgQEAgcHVibGlj OgogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+ IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSkgPSAwOwogICAgIHZpcnR1YWwgdW5zaWdu ZWQgc2hvcnQgbW9kZSgpIGNvbnN0ID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgc2NoZWR1bGVUYXNr KFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pID0gMDsKKyAgICB2aXJ0 dWFsIHZvaWQgc3RlcCgpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgYWJvcnQoKSA9IDA7CiAgICAg dmlydHVhbCBpbnQgaWQoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHNldENhbGxiYWNr cyhJREJUcmFuc2FjdGlvbkNhbGxiYWNrcyopID0gMDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3Rv cmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJU cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcAppbmRleCA5NzkwYzFmMmQ3OTVmNjYwNmQ2MTRiNDAz YjQzZjM2MmZiZjFiMGVjLi41ZmYwZWM5NzE0Nzc4NmE0OGI0NmY4NWY0NDZhYTI5NWE1NmI0NWE1 IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5j cHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwCkBA IC0zMCw2ICszMCw3IEBACiAKICNpbmNsdWRlICJJREJEYXRhYmFzZUJhY2tlbmRJbXBsLmgiCiAj aW5jbHVkZSAiSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgiCisjaW5jbHVkZSAiSURC UGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oIgogI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQmFj a2VuZEltcGwuaCIKICNpbmNsdWRlICJTUUxpdGVEYXRhYmFzZS5oIgogI2luY2x1ZGUgIlNjcmlw dEV4ZWN1dGlvbkNvbnRleHQuaCIKQEAgLTQ4LDIwICs0OSw2OSBAQCBJREJUcmFuc2FjdGlvbkNv b3JkaW5hdG9yOjp+SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcigpCiBQYXNzUmVmUHRyPElEQlRy YW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6Y3Jl YXRlVHJhbnNhY3Rpb24oRE9NU3RyaW5nTGlzdCogb2JqZWN0U3RvcmVzLCB1bnNpZ25lZCBzaG9y dCBtb2RlLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQsIElEQkRhdGFiYXNlQmFja2VuZEltcGwqIGRh dGFiYXNlKQogewogICAgIFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRy YW5zYWN0aW9uID0gSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6Y3JlYXRlKG9iamVjdFN0b3Jl cywgbW9kZSwgdGltZW91dCwgKyttX25leHRJRCwgZGF0YWJhc2UpOwotICAgIG1fdHJhbnNhY3Rp b25RdWV1ZS5hZGQodHJhbnNhY3Rpb24uZ2V0KCkpOwotICAgIG1faWRNYXAuYWRkKG1fbmV4dElE LCB0cmFuc2FjdGlvbik7CisgICAgbV9wZW5kaW5nVHJhbnNhY3Rpb25zLmFkZChtX25leHRJRCwg dHJhbnNhY3Rpb24pOwogICAgIHJldHVybiB0cmFuc2FjdGlvbi5yZWxlYXNlKCk7CiB9CiAKIHZv aWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6YWJvcnQoaW50IGlkKQogewotICAgIEFTU0VS VChtX2lkTWFwLmNvbnRhaW5zKGlkKSk7Ci0gICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZT4gdHJhbnNhY3Rpb24gPSBtX2lkTWFwLmdldChpZCk7CisgICAgQVNTRVJUKG1f cGVuZGluZ1RyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpOworICAgIFJlZlB0cjxJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uID0gbV9wZW5kaW5nVHJhbnNhY3Rpb25z LmdldChpZCk7CiAgICAgQVNTRVJUKHRyYW5zYWN0aW9uKTsKLSAgICBtX3RyYW5zYWN0aW9uUXVl dWUucmVtb3ZlKHRyYW5zYWN0aW9uLmdldCgpKTsKLSAgICBtX2lkTWFwLnJlbW92ZShpZCk7CiAg ICAgdHJhbnNhY3Rpb24tPmFib3J0KCk7Ci0gICAgLy8gRklYTUU6IHRoaXMgd2lsbCBjaGFuZ2Ug b25jZSB3ZSBoYXZlIHRyYW5zYWN0aW9ucyBhY3R1YWxseSBydW5uaW5nLgorfQorCit2b2lkIElE QlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZFN0YXJ0VHJhbnNhY3Rpb24oaW50IGlkKQorewor ICAgIC8vIFJlbW92ZSBmcm9tIHBlbmRpbmcgdHJhbnNhY3Rpb25zIGxpc3QKKyAgICBBU1NFUlQo bV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKGlkKSk7CisgICAgUmVmUHRyPElEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNhY3Rpb24gPSBtX3BlbmRpbmdUcmFuc2FjdGlv bnMuZ2V0KGlkKTsKKyAgICBBU1NFUlQodHJhbnNhY3Rpb24pOworICAgIG1fcGVuZGluZ1RyYW5z YWN0aW9ucy5yZW1vdmUoaWQpOworICAgIC8vIEFkZCB0byBzdGFydGVkIHRyYW5zYWN0aW9ucyBs aXN0CisgICAgbV9zdGFydGVkVHJhbnNhY3Rpb25RdWV1ZS5hZGQodHJhbnNhY3Rpb24uZ2V0KCkp OworICAgIG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5hZGQoaWQsIHRyYW5zYWN0aW9uLnJlbGVhc2Uo KSk7CisKKyAgICBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucygpOworfQorCit2b2lkIElEQlRy YW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZEZpbmlzaFRyYW5zYWN0aW9uKGludCBpZCkKK3sKKyAg ICBpZiAobV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKGlkKSkgeworICAgICAgICBBU1NF UlQoIW1fc3RhcnRlZFRyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpOworICAgICAgICBBU1NFUlQo IW1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpOworICAgICAgICBtX3BlbmRpbmdU cmFuc2FjdGlvbnMucmVtb3ZlKGlkKTsKKyAgICB9IGVsc2UgaWYgKG1fc3RhcnRlZFRyYW5zYWN0 aW9ucy5jb250YWlucyhpZCkpIHsKKyAgICAgICAgQVNTRVJUKCFtX3J1bm5pbmdUcmFuc2FjdGlv bnMuY29udGFpbnMoaWQpKTsKKyAgICAgICAgbV9wZW5kaW5nVHJhbnNhY3Rpb25zLnJlbW92ZShp ZCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgQVNTRVJUKG1fcnVubmluZ1RyYW5zYWN0aW9ucy5j b250YWlucyhpZCkpOworICAgICAgICBtX3J1bm5pbmdUcmFuc2FjdGlvbnMucmVtb3ZlKGlkKTsK KyAgICB9CisKKyAgICBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucygpOworfQorCit2b2lkIElE QlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OnByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKCkKK3sK KyAgICAvLyBGSVhNRTogdGhpcyB3b3VsZCBhbGxvY2F0ZSBhIHRocmVhZCB0byB0aGUgbmV4dCB0 cmFuc2FjdGlvbgorICAgIC8vIHRoYXQncyByZWFkeSB0byBydW4uIEZvciBub3cgd2Ugb25seSBo YXZlIGEgc2luZ2xlIHJ1bm5pbmcKKyAgICAvLyB0cmFuc2FjdGlvbi4KKyAgICBpZiAobV9zdGFy dGVkVHJhbnNhY3Rpb25zLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGlmICghbV9y dW5uaW5nVHJhbnNhY3Rpb25zLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8g UmVtb3ZlIGZyb20gc3RhcnRlZCB0cmFuc2FjdGlvbnMgbGlzdC4KKyAgICBJREJUcmFuc2FjdGlv bkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uUHRyID0gKihtX3N0YXJ0ZWRUcmFuc2FjdGlv blF1ZXVlLmJlZ2luKCkpOworICAgIG1fc3RhcnRlZFRyYW5zYWN0aW9uUXVldWUucmVtb3ZlKHRy YW5zYWN0aW9uUHRyKTsKKyAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNl PiB0cmFuc2FjdGlvbiA9IG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5nZXQodHJhbnNhY3Rpb25QdHIt PmlkKCkpOworICAgIG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5yZW1vdmUodHJhbnNhY3Rpb24tPmlk KCkpOworICAgIC8vIEFkZCB0byBydW5uaW5nIHRyYW5zYWN0aW9ucyBsaXN0LgorICAgIG1fcnVu bmluZ1RyYW5zYWN0aW9ucy5hZGQodHJhbnNhY3Rpb24tPmlkKCksIHRyYW5zYWN0aW9uKTsKKwor ICAgIC8vIEZJWE1FOiBpcyB0aGVyZSBhIGJldHRlciB3YXkgdGhhbiBjYXN0aW5nPworICAgIHN0 YXRpY19jYXN0PElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqPih0cmFuc2FjdGlvblB0ciktPnJ1 bigpOwogfQogCiB9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9u Q29vcmRpbmF0b3IuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9y LmgKaW5kZXggMTA0YTk1NjZjZWNlZGMzMmFlNmMwNTJhYzc3Nzc1NGE2MjExODIzZC4uZjY2MTk2 MzYzYjAzOWQwYmY5MTQ3NDRlZjY5ZmE0ZmQwNzVjODQyMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9z dG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2Uv SURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oCkBAIC01NywxMiArNTcsMjAgQEAgcHVibGljOgog ICAgIFBhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBjcmVhdGVUcmFu c2FjdGlvbihET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUs IHVuc2lnbmVkIGxvbmcgdGltZW91dCwgSURCRGF0YWJhc2VCYWNrZW5kSW1wbCopOwogICAgIHZv aWQgYWJvcnQoaW50IHRyYW5zYWN0aW9uSWQpOwogCisgICAgLy8gQ2FsbGVkIGJ5IHRyYW5zYWN0 aW9ucyBhcyB0aGV5IHN0YXJ0IGFuZCBmaW5pc2guCisgICAgdm9pZCBkaWRTdGFydFRyYW5zYWN0 aW9uKGludCBpZCk7CisgICAgdm9pZCBkaWRGaW5pc2hUcmFuc2FjdGlvbihpbnQgaWQpOworCiBw cml2YXRlOgogICAgIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKTsKIAotICAgIExpc3RIYXNo U2V0PElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSo+IG1fdHJhbnNhY3Rpb25RdWV1ZTsK KyAgICB2b2lkIHByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKCk7CisKKyAgICBMaXN0SGFzaFNl dDxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqPiBtX3N0YXJ0ZWRUcmFuc2FjdGlvblF1 ZXVlOwogICAgIHR5cGVkZWYgSGFzaE1hcDxpbnQsIFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2U+ID4gSWRUb1RyYW5zYWN0aW9uTWFwOwotICAgIElkVG9UcmFuc2FjdGlvbk1h cCBtX2lkTWFwOworICAgIElkVG9UcmFuc2FjdGlvbk1hcCBtX3BlbmRpbmdUcmFuc2FjdGlvbnM7 CisgICAgSWRUb1RyYW5zYWN0aW9uTWFwIG1fc3RhcnRlZFRyYW5zYWN0aW9uczsKKyAgICBJZFRv VHJhbnNhY3Rpb25NYXAgbV9ydW5uaW5nVHJhbnNhY3Rpb25zOwogICAgIGludCBtX25leHRJRDsK IH07CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCmluZGV4IDgwNmJjMDllNmM1YmM2ZjU3MjU1ZDlmZjU2MWU3OGQ5YTE4 Y2Q0MzYuLjU5NzZmZDY0ZTA4Mzc1ZTBmZmVmNGM1MWMxYjBhZWI1YjU3MTlhMDkgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEwLTA4LTI2ICBBbmRyZWkgUG9wZXNjdSAgPGFuZHJl aXBAZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBJREJPYmplY3RTdG9yZTo6Z2V0IHNob3VsZCBydW4gaW4gYSB0cmFuc2FjdGlvbi4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzAwCisK KyAgICAgICAgKiBzcmMvSURCRGF0YWJhc2VQcm94eS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJ REJEYXRhYmFzZVByb3h5OjpvYmplY3RTdG9yZSk6CisgICAgICAgICogc3JjL0lEQkRhdGFiYXNl UHJveHkuaDoKKyAgICAgICAgKiBzcmMvSURCT2JqZWN0U3RvcmVQcm94eS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpJREJPYmplY3RTdG9yZVByb3h5OjpzZXRUcmFuc2FjdGlvbik6CisgICAgICAg ICogc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuaDoKKyAgICAgICAgKiBzcmMvSURCVHJhbnNhY3Rp b25CYWNrZW5kUHJveHkuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNr ZW5kUHJveHk6OnN0ZXApOgorICAgICAgICAqIHNyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94 eS5oOgorCiAyMDEwLTA4LTI2ICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFVucmV2aWV3ZWQuIFJldmVydCByNjYxMDMgc2luY2UgUXQgdGVzdHMgYXJl IGZhaWxpbmcuCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFiYXNlUHJv eHkuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmNwcAppbmRleCA5 YWEyOTc3ODA2MTUyYzQ2MTBmMTY2NWYwYTQxZjQ3OTZjZjY3ODE0Li5iMjk4YTY3ZGU5MmRhOWQ5 MDkyZjg4NDYzOTg5YTdjZGRkZDhmMjgwIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3Jj L0lEQkRhdGFiYXNlUHJveHkuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJh c2VQcm94eS5jcHAKQEAgLTgxLDcgKzgxLDcgQEAgdm9pZCBJREJEYXRhYmFzZVByb3h5OjpjcmVh dGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYga2V5UGEKICAg ICBtX3dlYklEQkRhdGFiYXNlLT5jcmVhdGVPYmplY3RTdG9yZShuYW1lLCBrZXlQYXRoLCBhdXRv SW5jcmVtZW50LCBuZXcgV2ViSURCQ2FsbGJhY2tzSW1wbChjYWxsYmFja3MpKTsKIH0KIAotUGFz c1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IElEQkRhdGFiYXNlUHJveHk6 Om9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSkKK1Bh c3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBJREJEYXRhYmFzZVByb3h5 OjpvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUsIElE QlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSopCiB7CiAgICAgV2ViS2l0OjpXZWJJREJPYmpl Y3RTdG9yZSogb2JqZWN0U3RvcmUgPSBtX3dlYklEQkRhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1l LCBtb2RlKTsKICAgICBpZiAoIW9iamVjdFN0b3JlKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9t aXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFi YXNlUHJveHkuaAppbmRleCBlZDIwMTZhNTc5NDM2MjcwMmUyYmQwNTk1NzBhZDA3ZmI4MzcxNmE3 Li4yZGI0ZTBjYTAxM2M3MWU4YzY0ODU3YTE2MDg4ZTc1N2UxYTliN2IyIDEwMDY0NAotLS0gYS9X ZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuaAorKysgYi9XZWJLaXQvY2hyb21p dW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuaApAQCAtNDcsMTAgKzQ3LDEwIEBAIHB1YmxpYzoKICAg ICB2aXJ0dWFsIFN0cmluZyB2ZXJzaW9uKCkgY29uc3Q7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRy PERPTVN0cmluZ0xpc3Q+IG9iamVjdFN0b3JlcygpIGNvbnN0OwogCi0gICAgLy8gRklYTUU6IEFk ZCB0cmFuc2FjdGlvbiBhbmQgc2V0VmVyc2lvbi4KKyAgICAvLyBGSVhNRTogQWRkIHNldFZlcnNp b24uCiAKICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBTdHJpbmcmIGtleVBhdGgsIGJvb2wgYXV0b0luY3JlbWVudCwgUGFzc1JlZlB0 cjxJREJDYWxsYmFja3M+KTsKLSAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVC YWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVk IHNob3J0IG1vZGUpOworICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tl bmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hv cnQgbW9kZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbiA9IDAp OwogICAgIHZpcnR1YWwgdm9pZCByZW1vdmVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUs IFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQlRy YW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNhY3Rpb24oRE9NU3RyaW5nTGlzdCogc3Rv cmVOYW1lcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0KTsKIApk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmNwcCBi L1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5jcHAKaW5kZXggYWQyN2Zh MzQxYzViYzdjODljN2QwOGEyN2I1NWQxODMyOGRmMmIwMi4uNzk0MmUzOWMyMjEyOWQ1YzcyZTM0 YzAxZmMwNjM5Nzc2ZjVmNjAzMyAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJP YmplY3RTdG9yZVByb3h5LmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0 b3JlUHJveHkuY3BwCkBAIC0xMDgsNiArMTA4LDExIEBAIHZvaWQgSURCT2JqZWN0U3RvcmVQcm94 eTo6b3BlbkN1cnNvcihQYXNzUmVmUHRyPElEQktleVJhbmdlPiByYW5nZSwgdW5zaWduZWQgc2hv CiAgICAgbV93ZWJJREJPYmplY3RTdG9yZS0+b3BlbkN1cnNvcihyYW5nZSwgZGlyZWN0aW9uLCBu ZXcgV2ViSURCQ2FsbGJhY2tzSW1wbChjYWxsYmFja3MpKTsKIH0KIAordm9pZCBJREJPYmplY3RT dG9yZVByb3h5OjpzZXRUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2Uq KQoreworICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5oIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmgKaW5kZXggYTMzNDU3MmI2ZjM2YzFlMDA0ODJjMDRk MGEwN2I2NWFhYmY1OTlhMS4uMzZhYzU4OGZhZTY5ZjYwYmM1NTVjN2Y5NzVhMWJhODEwMTc0ZTdk OCAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmgK KysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmgKQEAgLTU1LDYg KzU1LDcgQEAgcHVibGljOgogICAgIHZvaWQgcmVtb3ZlSW5kZXgoY29uc3QgU3RyaW5nJiBuYW1l LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwogCiAgICAgdmlydHVhbCB2b2lkIG9wZW5DdXJz b3IoUGFzc1JlZlB0cjxJREJLZXlSYW5nZT4gcmFuZ2UsIHVuc2lnbmVkIHNob3J0IGRpcmVjdGlv biwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0VHJhbnNh Y3Rpb24oSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKik7CiAKIHByaXZhdGU6CiAgICAg SURCT2JqZWN0U3RvcmVQcm94eShQYXNzT3duUHRyPFdlYktpdDo6V2ViSURCT2JqZWN0U3RvcmU+ KTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5k UHJveHkuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94 eS5jcHAKaW5kZXggYmU2YjA1OGU1MmUyNDI3NTgzNDg3MDlkYjAwMWNkMDQxYzU2OTZlOC4uOTZh MzAwYzBiNDljZTg1OWYyMDY0NTA3ODJlYzJiMGQyMGI5MzliZSAxMDA2NDQKLS0tIGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5jcHAKKysrIGIvV2ViS2l0 L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5jcHAKQEAgLTc2LDYgKzc2 LDEzIEBAIHZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OnNjaGVkdWxlVGFzayhQYXNz T3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6CiAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7 CiB9CiAKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OnN0ZXAoKQoreworICAgIC8v IEZJWE1FOiBpbXBsZW1lbnQKKyAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKK30KKworCiBpbnQg SURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OmlkKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV93 ZWJJREJUcmFuc2FjdGlvbi0+aWQoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMv SURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCVHJh bnNhY3Rpb25CYWNrZW5kUHJveHkuaAppbmRleCBkNjJiOGZmN2I4NDFhMmEzZjkyYTJjNjdhNzAw ZGU2MzgzNWZlMzAyLi4xYTNkNzEzOWE0ZjgwY2JiZDNlZWUxMzdkZWRjMjFiZjc1ZWRjMjkzIDEw MDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5 LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5o CkBAIC00Niw2ICs0Niw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHVuc2lnbmVkIHNob3J0IG1v ZGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgYWJvcnQoKTsKICAgICB2aXJ0dWFsIHZvaWQg c2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOwor ICAgIHZpcnR1YWwgdm9pZCBzdGVwKCk7CiAgICAgdmlydHVhbCBpbnQgaWQoKSBjb25zdDsKICAg ICB2aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKElEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzKik7CiAK 66964 2010-09-08 16:53:54 -0700 2010-09-21 07:14:26 -0700 Patch bug-44700-20100909005351.patch text/plain 65291 bulach ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxMTQ1ZjAwOWMwZWE1ZWRmNTVkNDk1ZWU4YTZiYTc4ZjI4YzVmOTFmLi40ZDdjZjNk NDJiY2IzNGQyNjM1YzBiZTBlNzZjYTQ0NTUxNmFhMGQwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAK KzIwMTAtMDktMDggIE1hcmN1cyBCdWxhY2ggIDxidWxhY2hAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElEQk9iamVjdFN0b3Jl OjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAgICAgICBPcmlnaW5hbCBwYXRj aCBieSBBbmRyZWkgUG9wZXNjdSAgPGFuZHJlaXBAZ29vZ2xlLmNvbT4KKworICAgICAgICBUZXN0 OiBzdG9yYWdlL2luZGV4ZWRkYi90cmFuc2FjdGlvbi1nZXQuaHRtbAorCisgICAgICAgICogc3Rv cmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAg KiBzdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3Rl ZC50eHQ6CisgICAgICAgICogc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2Jq ZWN0c3RvcmUuaHRtbDoKKyAgICAgICAgKiBzdG9yYWdlL2luZGV4ZWRkYi9zY3JpcHQtdGVzdHMv b2JqZWN0c3RvcmUtYmFzaWNzLmpzOgorICAgICAgICAoYWRkU3VjY2Vzcyk6CisgICAgICAgICog c3RvcmFnZS9pbmRleGVkZGIvc2NyaXB0LXRlc3RzL3RyYW5zYWN0aW9uLWdldC5qczogQWRkZWQu CisgICAgICAgIChhZnRlckNvbW1pdCk6CisgICAgICAgIChub25FeGlzdGluZ0tleSk6CisgICAg ICAgIChnb3RWYWx1ZSk6CisgICAgICAgIChwb3B1bGF0ZU9iamVjdFN0b3JlKToKKyAgICAgICAg KGNyZWF0ZU9iamVjdFN0b3JlU3VjY2Vzcyk6CisgICAgICAgIChvcGVuU3VjY2Vzcyk6CisgICAg ICAgICh0ZXN0KToKKyAgICAgICAgKiBzdG9yYWdlL2luZGV4ZWRkYi90cmFuc2FjdGlvbi1nZXQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBzdG9yYWdlL2luZGV4ZWRkYi90cmFuc2Fj dGlvbi1nZXQuaHRtbDogQWRkZWQuCisKIDIwMTAtMDktMDcgIFNhdGlzaCBTYW1wYXRoICA8c2F0 aXNoQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBKZXJlbXkgT3Jsb3cuCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNp Y3MtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3Rv cmUtYmFzaWNzLWV4cGVjdGVkLnR4dAppbmRleCBhNjBlODU3NmI2NDliNDU5ZDYzOTg2YTAzYzA1 MDcwYTE4NDc5ZjBkLi5kNGQzZDRlZTc4MjU5MjdiYzdiYzg0MWZiNTNmYmYxOWRlZjZiYWQwIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNp Y3MtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVj dHN0b3JlLWJhc2ljcy1leHBlY3RlZC50eHQKQEAgLTkyLDcgKzkyLDggQEAgUEFTUyAncmVhZHlT dGF0ZScgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKIFBBU1MgZXZlbnQudGFyZ2V0LnJlYWR5U3Rh dGUgaXMgZXZlbnQudGFyZ2V0LkRPTkUKIAogUEFTUyBldmVudC5yZXN1bHQgaXMgImtleSIKLXN0 b3JlID0gZXZlbnQuc291cmNlCitkYi50cmFuc2FjdGlvbigpCitzdG9yZSA9IHRyYW5zYWN0aW9u Lm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKQogc3RvcmUuZ2V0KCdrZXknKQogUEFTUyAnb25zdWNj ZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQogUEFTUyAnb25lcnJvcicgaW4gcmVzdWx0IGlzIHRydWUK QEAgLTEzOSw0ICsxNDAsMyBAQCBQQVNTIGV2ZW50LnJlc3VsdCBpcyBudWxsCiBQQVNTIHN1Y2Nl c3NmdWxseVBhcnNlZCBpcyB0cnVlCiAKIFRFU1QgQ09NUExFVEUKLQpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUt cmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0CmluZGV4IDBhM2Q5Mzg2YzViMWI2NDNhMGQ4 MTY5ZThiZGY2ZTY4MjU1ZmYzOTEuLmY1NjQyYTA0MWI0YWQ0YjhhZDFiODA4NzUyYTE4NjNiMGM1 MzUzZGIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0 b3JlLXJlbW92ZW9iamVjdHN0b3JlLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9zdG9y YWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50eHQK QEAgLTYxLDcgKzYxLDkgQEAgUEFTUyAnYWJvcnQnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCiBQ QVNTICdyZWFkeVN0YXRlJyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQogUEFTUyBldmVudC50YXJn ZXQucmVhZHlTdGF0ZSBpcyBldmVudC50YXJnZXQuRE9ORQogCi1ldmVudC5zb3VyY2UuZ2V0KCdr ZXknKQorZGIudHJhbnNhY3Rpb24oKQorc3RvcmUgPSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgn c3RvcmVOYW1lJykKK3N0b3JlLmdldCgna2V5JykKIFBBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0 IGlzIHRydWUKIFBBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVlCiBQQVNTICdhYm9ydCcg aW4gcmVzdWx0IGlzIHRydWUKQEAgLTE1OCw5ICsxNjAsOCBAQCBQQVNTICdhYm9ydCcgaW4gZXZl bnQudGFyZ2V0IGlzIHRydWUKIFBBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0 cnVlCiBQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCiAK LVBBU1MgZXZlbnQuY29kZSBpcyAyCitQQVNTIGV2ZW50LmNvZGUgaXMgNQogUEFTUyBldmVudC5z b3VyY2UuaW5kZXhOYW1lcy5jb250YWlucygnaW5kZXhOYW1lJykgaXMgZmFsc2UKIFBBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIAogVEVTVCBDT01QTEVURQotCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9y ZS5odG1sIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zl b2JqZWN0c3RvcmUuaHRtbAppbmRleCBlODQyZjViZmJmOGVlMTE3ZjBkNmYzYzBjMGNhODRlYzQ3 YWU0OGM2Li40ZDA3NWFmN2I1ZjFmOWZjMTAwOTNmYTA0MjNhYmYxZjZhYmY0M2Q2IDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmpl Y3RzdG9yZS5odG1sCisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0 b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0bWwKQEAgLTQ5LDcgKzQ5LDExIEBAIGZ1bmN0aW9uIGdl dFZhbHVlKCkKIHsKICAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOwogCi0gICAgcmVzdWx0 ID0gZXZhbEFuZExvZygiZXZlbnQuc291cmNlLmdldCgna2V5JykiKTsKKyAgICB0cmFuc2FjdGlv biA9IGV2YWxBbmRMb2coImRiLnRyYW5zYWN0aW9uKCkiKTsKKyAgICB0cmFuc2FjdGlvbi5vbmFi b3J0ID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7CisgICAgdmFyIHN0b3JlID0gZXZhbEFuZExv Zygic3RvcmUgPSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykiKTsKKworICAg IHJlc3VsdCA9IGV2YWxBbmRMb2coInN0b3JlLmdldCgna2V5JykiKTsKICAgICB2ZXJpZnlSZXN1 bHQocmVzdWx0KTsKICAgICByZXN1bHQub25zdWNjZXNzID0gYWRkSW5kZXg7CiAgICAgcmVzdWx0 Lm9uZXJyb3IgPSB1bmV4cGVjdGVkRXJyb3JDYWxsYmFjazsKQEAgLTYyLDE1ICs2NiwyMCBAQCBm dW5jdGlvbiBhZGRJbmRleCgpCiAKICAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJldmVudC5zb3Vy Y2UuY3JlYXRlSW5kZXgoJ2luZGV4TmFtZScsICcnKSIpOwogICAgIHZlcmlmeVJlc3VsdChyZXN1 bHQpOwotICAgIHJlc3VsdC5vbnN1Y2Nlc3MgPSByZW1vdmVPYmplY3RTdG9yZTsKKyAgICByZXN1 bHQub25zdWNjZXNzID0gaW5kZXhBZGRlZDsKICAgICByZXN1bHQub25lcnJvciA9IHVuZXhwZWN0 ZWRFcnJvckNhbGxiYWNrOwogfQogCi1mdW5jdGlvbiByZW1vdmVPYmplY3RTdG9yZSgpCitmdW5j dGlvbiBpbmRleEFkZGVkKCkKIHsKICAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOwogICAg IHNob3VsZEJlVHJ1ZSgiZXZlbnQuc291cmNlLmluZGV4TmFtZXMuY29udGFpbnMoJ2luZGV4TmFt ZScpIik7CisgICAgLy8gTGV0IHRoZSB0cmFuc2FjdGlvbiBjb21taXQuCisgICAgd2luZG93LnNl dFRpbWVvdXQoJ3JlbW92ZU9iamVjdFN0b3JlKCknLCAwKTsKK30KIAorZnVuY3Rpb24gcmVtb3Zl T2JqZWN0U3RvcmUoKQorewogICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coImRiLnJlbW92ZU9iamVj dFN0b3JlKCdzdG9yZU5hbWUnKSIpOwogICAgIHZlcmlmeVJlc3VsdChyZXN1bHQpOwogICAgIHJl c3VsdC5vbnN1Y2Nlc3MgPSBjcmVhdGVPYmplY3RTdG9yZUFnYWluOwpAQCAtMTAxLDcgKzExMCw3 IEBAIGZ1bmN0aW9uIHZlcmlmeUVycm9yKCkKIHsKICAgICB2ZXJpZnlFcnJvckV2ZW50KGV2ZW50 KTsKICAgICAvLyBGSVhNRTogU2hvdWxkIGp1c3QgYmUgSURCRGF0YWJhc2VFeGNlcHRpb24uTk9U X0ZPVU5EX0VSUiBidXQgdGhhdCBkb2Vzbid0IHdvcmsgeWV0LgotICAgIHNob3VsZEJlKCJldmVu dC5jb2RlIiwgIjIiKTsKKyAgICBzaG91bGRCZSgiZXZlbnQuY29kZSIsICI1Iik7CiAgICAgc2hv dWxkQmVGYWxzZSgiZXZlbnQuc291cmNlLmluZGV4TmFtZXMuY29udGFpbnMoJ2luZGV4TmFtZScp Iik7CiAKICAgICBkb25lKCk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4 ZWRkYi9zY3JpcHQtdGVzdHMvb2JqZWN0c3RvcmUtYmFzaWNzLmpzIGIvTGF5b3V0VGVzdHMvc3Rv cmFnZS9pbmRleGVkZGIvc2NyaXB0LXRlc3RzL29iamVjdHN0b3JlLWJhc2ljcy5qcwppbmRleCAz NWNjYjRhNzM1NGE3ZjU2ZWUwZDAyZTA0NzIzOTE0YzY0ODY2ZGQ4Li42ZTczNDBkMGQ4NDNlODZl ZTM2YzQ3Zjk4NTJlNWViZmJmODliM2Y2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9zdG9yYWdl L2luZGV4ZWRkYi9zY3JpcHQtdGVzdHMvb2JqZWN0c3RvcmUtYmFzaWNzLmpzCisrKyBiL0xheW91 dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL3NjcmlwdC10ZXN0cy9vYmplY3RzdG9yZS1iYXNpY3Mu anMKQEAgLTYwLDcgKzYwLDkgQEAgZnVuY3Rpb24gYWRkU3VjY2VzcygpCiAgICAgZGVidWcoImFk ZFN1Y2Nlc3MoKToiKTsKICAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOwogICAgIHNob3Vs ZEJlRXF1YWxUb1N0cmluZygiZXZlbnQucmVzdWx0IiwgImtleSIpOwotICAgIHZhciBzdG9yZSA9 IGV2YWxBbmRMb2coInN0b3JlID0gZXZlbnQuc291cmNlIik7CisgICAgdHJhbnNhY3Rpb24gPSBl dmFsQW5kTG9nKCJkYi50cmFuc2FjdGlvbigpIik7CisgICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9 IHVuZXhwZWN0ZWRFcnJvckNhbGxiYWNrOworICAgIHZhciBzdG9yZSA9IGV2YWxBbmRMb2coInN0 b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7CiAKICAgICByZXN1 bHQgPSBldmFsQW5kTG9nKCJzdG9yZS5nZXQoJ2tleScpIik7CiAgICAgdmVyaWZ5UmVzdWx0KHJl c3VsdCk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9zY3JpcHQt dGVzdHMvdHJhbnNhY3Rpb24tZ2V0LmpzIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIv c2NyaXB0LXRlc3RzL3RyYW5zYWN0aW9uLWdldC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mNDQ1NWExMGI0NzJh MTM3MDIxZjVkNWZlNjMyMDA0NDhmOTMzZjA3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvc3RvcmFnZS9pbmRleGVkZGIvc2NyaXB0LXRlc3RzL3RyYW5zYWN0aW9uLWdldC5qcwpAQCAt MCwwICsxLDg2IEBACitkZXNjcmlwdGlvbigiVGVzdCBJbmRleGVkREIncyBnZXQgaW5zaWRlIGEg dHJhbnNhY3Rpb24uIik7CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxh eW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKworZnVuY3Rpb24gYWZ0ZXJDb21t aXQoKQoreworICAgIHRyeSB7CisgICAgICAgIGRlYnVnKCJBY2Nlc3NpbmcgYSBjb21taXR0ZWQg dHJhbnNhY3Rpb24gc2hvdWxkIHRocm93Iik7CisgICAgICAgIHZhciBzdG9yZSA9IHRyYW5zYWN0 aW9uLm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKTsKKyAgICB9IGNhdGNoIChlKSB7CisgICAgICAg IGV4YyA9IGU7CisgICAgICAgIHNob3VsZEJlKCdleGMuY29kZScsICc5Jyk7CisgICAgfQorICAg IGRvbmUoKTsKK30KKworZnVuY3Rpb24gbm9uRXhpc3RpbmdLZXkoKQoreworICAgIHZlcmlmeUVy cm9yRXZlbnQoZXZlbnQpOworICAgIHdpbmRvdy5zZXRUaW1lb3V0KCdhZnRlckNvbW1pdCgpJywg MCk7Cit9CisKK2Z1bmN0aW9uIGdvdFZhbHVlKCkKK3sKKyAgICB2ZXJpZnlTdWNjZXNzRXZlbnQo ZXZlbnQpOworICAgIHZhciB2YWx1ZSA9IGV2YWxBbmRMb2coInZhbHVlID0gZXZlbnQucmVzdWx0 Iik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd2YWx1ZScsICdteVZhbHVlJyk7Cit9CisK K2Z1bmN0aW9uIHN0YXJ0VHJhbnNhY3Rpb24oKQoreworICAgIGRlYnVnKCJVc2luZyBnZXQgaW4g YSB0cmFuc2FjdGlvbiIpOworICAgIHRyYW5zYWN0aW9uID0gZXZhbEFuZExvZygiZGIudHJhbnNh Y3Rpb24oKSIpOworICAgIHRyYW5zYWN0aW9uLm9uYWJvcnQgPSB1bmV4cGVjdGVkRXJyb3JDYWxs YmFjazsKKyAgICB2YXIgc3RvcmUgPSBldmFsQW5kTG9nKCJzdG9yZSA9IHRyYW5zYWN0aW9uLm9i amVjdFN0b3JlKCdzdG9yZU5hbWUnKSIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygic3Rv cmUubmFtZSIsICJzdG9yZU5hbWUiKTsKKyAgICB2YXIgcmVzdWx0ID0gc3RvcmUuZ2V0KCdteUtl eScpOworICAgIHZlcmlmeVJlc3VsdChyZXN1bHQpOworICAgIHJlc3VsdC5vbnN1Y2Nlc3MgPSBn b3RWYWx1ZTsKKyAgICByZXN1bHQub25lcnJvciA9IHVuZXhwZWN0ZWRFcnJvckNhbGxiYWNrOwor ICAgIAorICAgIHZhciBlbXB0eVJlc3VsdCA9IHN0b3JlLmdldCgnbm9uRXhpc3RpbmdLZXknKTsK KyAgICB2ZXJpZnlSZXN1bHQoZW1wdHlSZXN1bHQpOworICAgIGVtcHR5UmVzdWx0Lm9uc3VjY2Vz cyA9IHVuZXhwZWN0ZWRTdWNjZXNzQ2FsbGJhY2s7CisgICAgZW1wdHlSZXN1bHQub25lcnJvciA9 IG5vbkV4aXN0aW5nS2V5OworfQorCitmdW5jdGlvbiBwb3B1bGF0ZU9iamVjdFN0b3JlKG9iamVj dFN0b3JlKQoreworICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coIm9iamVjdFN0b3JlLmFkZCgnbXlW YWx1ZScsICdteUtleScpIik7CisgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CisgICAgcmVzdWx0 Lm9uc3VjY2VzcyA9IHN0YXJ0VHJhbnNhY3Rpb247CisgICAgcmVzdWx0Lm9uZXJyb3IgPSB1bmV4 cGVjdGVkRXJyb3JDYWxsYmFjazsKK30KKworZnVuY3Rpb24gY3JlYXRlT2JqZWN0U3RvcmVTdWNj ZXNzKCkKK3sKKyAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOworICAgIHZhciBvYmplY3RT dG9yZSA9IGV2YWxBbmRMb2coIm9iamVjdFN0b3JlID0gZXZlbnQucmVzdWx0Iik7CisgICAgcG9w dWxhdGVPYmplY3RTdG9yZShvYmplY3RTdG9yZSk7Cit9CisKK2Z1bmN0aW9uIG9wZW5TdWNjZXNz KCkKK3sKKyAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOworICAgIHZhciBkYiA9IGV2YWxB bmRMb2coImRiID0gZXZlbnQucmVzdWx0Iik7CisKKyAgICBkZWxldGVBbGxPYmplY3RTdG9yZXMo ZGIpOworCisgICAgcmVzdWx0ID0gZXZhbEFuZExvZygiZGIuY3JlYXRlT2JqZWN0U3RvcmUoJ3N0 b3JlTmFtZScpIik7CisgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CisgICAgcmVzdWx0Lm9uc3Vj Y2VzcyA9IGNyZWF0ZU9iamVjdFN0b3JlU3VjY2VzczsKKyAgICByZXN1bHQub25lcnJvciA9IHVu ZXhwZWN0ZWRFcnJvckNhbGxiYWNrOworfQorCitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICByZXN1 bHQgPSBldmFsQW5kTG9nKCJpbmRleGVkREIub3BlbignbmFtZScsICdkZXNjcmlwdGlvbicpIik7 CisgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CisgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IG9wZW5T dWNjZXNzOworICAgIHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7Cit9 CisKK3Rlc3QoKTsKKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi90cmFuc2FjdGlvbi1nZXQtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0LWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4yODQ1NjAyNmJjNWVhNDhmYjI1YjhlMTQ3YzM2YWEwZjIyNjQ2 MTEyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvdHJh bnNhY3Rpb24tZ2V0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDk5IEBACitUZXN0IEluZGV4ZWRE QidzIGdldCBpbnNpZGUgYSB0cmFuc2FjdGlvbi4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2Vl IGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUi LgorCisKK2luZGV4ZWREQi5vcGVuKCduYW1lJywgJ2Rlc2NyaXB0aW9uJykKK1BBU1MgJ29uc3Vj Y2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVl CitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIHJl c3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4uCisKK1N1Y2Nlc3Mg ZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRydWUKK1BBU1MgJ2NvZGUn IGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVudCBpcyBmYWxzZQorUEFT UyAnc291cmNlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNvdXJjZSAhPSBudWxsIGlz IHRydWUKK1BBU1MgJ29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ29u ZXJyb3InIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gZXZlbnQudGFy Z2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQ QVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCisKK2RiID0g ZXZlbnQucmVzdWx0CitkYi5jcmVhdGVPYmplY3RTdG9yZSgnc3RvcmVOYW1lJykKK1BBU1MgJ29u c3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0 cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGlu IHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4uCisKK1N1Y2Nl c3MgZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRydWUKK1BBU1MgJ2Nv ZGUnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVudCBpcyBmYWxzZQor UEFTUyAnc291cmNlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNvdXJjZSAhPSBudWxs IGlzIHRydWUKK1BBU1MgJ29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1Mg J29uZXJyb3InIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gZXZlbnQu dGFyZ2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVl CitQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCisKK29i amVjdFN0b3JlID0gZXZlbnQucmVzdWx0CitvYmplY3RTdG9yZS5hZGQoJ215VmFsdWUnLCAnbXlL ZXknKQorUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQorUEFTUyAnb25lcnJvcicg aW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ2Fib3J0JyBpbiByZXN1bHQgaXMgdHJ1ZQorUEFTUyAn cmVhZHlTdGF0ZScgaW4gcmVzdWx0IGlzIHRydWUKK0FuIGV2ZW50IHNob3VsZCBmaXJlIHNob3J0 bHkuLi4KKworVXNpbmcgZ2V0IGluIGEgdHJhbnNhY3Rpb24KK2RiLnRyYW5zYWN0aW9uKCkKK3N0 b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpCitQQVNTIHN0b3JlLm5h bWUgaXMgInN0b3JlTmFtZSIKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BB U1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlz IHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91 bGQgZmlyZSBzaG9ydGx5Li4uCisKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUK K1BBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0 IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBz aG91bGQgZmlyZSBzaG9ydGx5Li4uCisKK1N1Y2Nlc3MgZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1 bHQnIGluIGV2ZW50IGlzIHRydWUKK1BBU1MgJ2NvZGUnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNT ICdtZXNzYWdlJyBpbiBldmVudCBpcyBmYWxzZQorUEFTUyAnc291cmNlJyBpbiBldmVudCBpcyB0 cnVlCitQQVNTIGV2ZW50LnNvdXJjZSAhPSBudWxsIGlzIHRydWUKK1BBU1MgJ29uc3VjY2Vzcycg aW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIGV2ZW50LnRhcmdldCBp cyB0cnVlCitQQVNTICdhYm9ydCcgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5 U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0 YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCisKK3ZhbHVlID0gZXZlbnQucmVzdWx0CitQQVNTIHZh bHVlIGlzICJteVZhbHVlIgorRXJyb3IgZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1bHQnIGluIGV2 ZW50IGlzIGZhbHNlCitQQVNTICdjb2RlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTICdtZXNzYWdl JyBpbiBldmVudCBpcyB0cnVlCitQQVNTICdzb3VyY2UnIGluIGV2ZW50IGlzIHRydWUKK1BBU1Mg ZXZlbnQuc291cmNlICE9IG51bGwgaXMgdHJ1ZQorUEFTUyAnb25zdWNjZXNzJyBpbiBldmVudC50 YXJnZXQgaXMgdHJ1ZQorUEFTUyAnb25lcnJvcicgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BB U1MgJ2Fib3J0JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyAncmVhZHlTdGF0ZScgaW4g ZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgZXZlbnQudGFyZ2V0LnJlYWR5U3RhdGUgaXMgZXZl bnQudGFyZ2V0LkRPTkUKKworQWNjZXNzaW5nIGEgY29tbWl0dGVkIHRyYW5zYWN0aW9uIHNob3Vs ZCB0aHJvdworUEFTUyBleGMuY29kZSBpcyA5CitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0 cnVlCisKK1RFU1QgQ09NUExFVEUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5k ZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVk ZGIvdHJhbnNhY3Rpb24tZ2V0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjBkMWIwNzgwZWU4ZTFiYmM3NzQ5 YTQ3MTczNjYzYmU3ZmE1YjNmMAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3N0b3Jh Z2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sCkBAIC0wLDAgKzEsMTMgQEAKKzxodG1s PgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2Zhc3QvanMvcmVz b3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jl c291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFz dC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LWZ1bmN0aW9uLmpzIj48L3NjcmlwdD4KKzxzY3Jp cHQgc3JjPSJyZXNvdXJjZXMvc2hhcmVkLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5Pgor PHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3Jp cHQgc3JjPSJzY3JpcHQtdGVzdHMvdHJhbnNhY3Rpb24tZ2V0LmpzIj48L3NjcmlwdD4KKzwvYm9k eT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFu Z2VMb2cKaW5kZXggNGQxYmQzMzllMWFjMDk1ZGY0MTY4N2JmMGI2OTE1YjRlZTUwOWViZi4uZTky NjJjMDMyZjk1ZTNjN2FhZmMwMmM5YTQ3MmM4MDI2YzA0OWE5ZCAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw4NCBAQAorMjAx MC0wOS0wOCAgTWFyY3VzIEJ1bGFjaCAgPGJ1bGFjaEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSURCT2JqZWN0U3RvcmU6Omdl dCBzaG91bGQgcnVuIGluIGEgdHJhbnNhY3Rpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NDcwMAorCisgICAgICAgIE9yaWdpbmFsIHBhdGNoIGJ5 IEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBnb29nbGUuY29tPgorCisgICAgICAgIFRlc3Q6IHN0 b3JhZ2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sCisKKyAgICAgICAgKiBiaW5kaW5n cy92OC9WOFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4UHJveHk6OmRpZExlYXZlU2Ny aXB0Q29udGV4dCk6CisgICAgICAgICogc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHA6 CisgICAgICAgICogc3RvcmFnZS9JREJEYXRhYmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJ REJEYXRhYmFzZTo6b2JqZWN0U3RvcmUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCRGF0YWJhc2VC YWNrZW5kSW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJEYXRhYmFzZUJhY2tlbmRJbXBs OjpvYmplY3RTdG9yZSk6CisgICAgICAgICogc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBs Lmg6CisgICAgICAgIChXZWJDb3JlOjpJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjp0cmFuc2FjdGlv bkNvb3JkaW5hdG9yKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVy ZmFjZS5oOgorICAgICAgICAqIHN0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OklEQkZhY3RvcnlCYWNrZW5kSW1wbDo6YWJvcnRQZW5kaW5nVHJhbnNh Y3Rpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OklEQkZhY3RvcnlCYWNrZW5kSW1wbDo6ZGlkQ29t cGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbik6CisgICAgICAgICogc3RvcmFnZS9JREJGYWN0b3J5 QmFja2VuZEltcGwuaDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW50ZXJm YWNlLmg6CisgICAgICAgICogc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpJREJPYmplY3RTdG9yZTo6SURCT2JqZWN0U3RvcmUpOgorICAgICAgICAoV2ViQ29y ZTo6SURCT2JqZWN0U3RvcmU6OmdldCk6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9y ZTo6YWRkKToKKyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3JlOjpwdXQpOgorICAgICAg ICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmU6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpJ REJPYmplY3RTdG9yZTo6cmVtb3ZlVHJhbnNhY3Rpb25Gcm9tUGVuZGluZ0xpc3QpOgorICAgICAg ICAqIHN0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaDoKKyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVj dFN0b3JlOjpjcmVhdGUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5k SW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjpn ZXQpOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6R2V0VGFz azo6R2V0VGFzayk6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBs OjpHZXRUYXNrOjpwZXJmb3JtVGFzayk6CisgICAgICAgICogc3RvcmFnZS9JREJPYmplY3RTdG9y ZUJhY2tlbmRJbXBsLmg6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZUJhY2tlbmRJ bXBsOjpzZXRUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZUJh Y2tlbmRJbXBsOjpHZXRUYXNrOjp+R2V0VGFzayk6CisgICAgICAgICogc3RvcmFnZS9JREJPYmpl Y3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UuaDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQlBlbmRpbmdU cmFuc2FjdGlvbk1vbml0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCUGVuZGluZ1RyYW5z YWN0aW9uTW9uaXRvcjo6cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNv cmU6OklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9u cyk6CisgICAgICAgIChXZWJDb3JlOjpJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpkaWRD b21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlBlbmRp bmdUcmFuc2FjdGlvbk1vbml0b3IuaDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQlJlcXVlc3QuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SURCUmVxdWVzdDo6SURCUmVxdWVzdCk6CisgICAgICAgIChX ZWJDb3JlOjpJREJSZXF1ZXN0OjpvblN1Y2Nlc3MpOgorICAgICAgICAoV2ViQ29yZTo6SURCUmVx dWVzdDo6dGltZXJGaXJlZCk6CisgICAgICAgICogc3RvcmFnZS9JREJSZXF1ZXN0Lmg6CisgICAg ICAgIChXZWJDb3JlOjpJREJSZXF1ZXN0OjpjcmVhdGUpOgorICAgICAgICAqIHN0b3JhZ2UvSURC VHJhbnNhY3Rpb24uY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb246Om9iamVj dFN0b3JlKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tl bmRJbXBsOjpvYmplY3RTdG9yZSk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJh Y2tlbmRJbXBsOjpzY2hlZHVsZVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rp b25CYWNrZW5kSW1wbDo6c3RlcCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJh Y2tlbmRJbXBsOjphYm9ydCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tl bmRJbXBsOjpydW4pOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1w bDo6c3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6 cnVuTmV4dFRhc2tzKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZElt cGw6OmNvbW1pdCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBs OjpkaWRGaW5pc2hUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlv bkJhY2tlbmRJbXBsOjp0aW1lckZpcmVkKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0 aW9uQmFja2VuZEltcGwuaDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2Vu ZEltcGw6On5JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKToKKyAgICAgICAgKFdlYkNvcmU6OklE QlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OmlzRmluaXNoZWQpOgorICAgICAgICAqIHN0b3JhZ2Uv SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmg6CisgICAgICAgICogc3RvcmFnZS9JREJU cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0 aW9uQ29vcmRpbmF0b3I6OmNyZWF0ZVRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OklE QlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyk6CisgICAg ICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpkaWRDb21wbGV0ZUV2ZW50 c0ZvclRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQ29vcmRp bmF0b3I6OmRpZFN0YXJ0VHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNh Y3Rpb25Db29yZGluYXRvcjo6ZGlkRmluaXNoVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29y ZTo6SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6cHJvY2Vzc1N0YXJ0ZWRUcmFuc2FjdGlvbnMp OgorICAgICAgICAqIHN0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oOgorCiAyMDEw LTA5LTA3ICBTYXRpc2ggU2FtcGF0aCAgPHNhdGlzaEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgSmVyZW15IE9ybG93LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9iaW5kaW5ncy92 OC9WOFByb3h5LmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhQcm94eS5jcHAKaW5kZXggMDc3 YzBkZmMzYjczNmU2M2ZiMzE0NmRmZWExNjFjNGQzODlkMGNkNC4uNDZkYzM1ZTRkOGM0YmI3NTMy NGRiNGQ2YmUxN2U5MzI5ZGE5ODIyYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9iaW5kaW5ncy92OC9W OFByb3h5LmNwcAorKysgYi9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4UHJveHkuY3BwCkBAIC02NTIs MTEgKzY1Miw3IEBAIHZvaWQgVjhQcm94eTo6ZGlkTGVhdmVTY3JpcHRDb250ZXh0KCkKICAgICAv LyBJZiB3ZSd2ZSBqdXN0IGxlZnQgYSBzY3JpcHQgY29udGV4dCBhbmQgaW5kZXhlZCBkYXRhYmFz ZSBoYXMgYmVlbgogICAgIC8vIGluc3RhbnRpYXRlZCwgd2UgbXVzdCBsZXQgaXRzIHRyYW5zYWN0 aW9uIGNvb3JkaW5hdG9yIGtub3cgc28gaXQgY2FuIHRlcm1pbmF0ZQogICAgIC8vIGFueSBub3Qt eWV0LXN0YXJ0ZWQgdHJhbnNhY3Rpb25zLgotICAgIGlmIChJREJQZW5kaW5nVHJhbnNhY3Rpb25N b25pdG9yOjpoYXNQZW5kaW5nVHJhbnNhY3Rpb25zKCkpIHsKLSAgICAgICAgQVNTRVJUKHBhZ2Ut Pmdyb3VwKCkuaGFzSURCRmFjdG9yeSgpKTsKLSAgICAgICAgcGFnZS0+Z3JvdXAoKS5pZGJGYWN0 b3J5KCktPmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25p dG9yOjpwZW5kaW5nVHJhbnNhY3Rpb25zKCkpOwotICAgICAgICBJREJQZW5kaW5nVHJhbnNhY3Rp b25Nb25pdG9yOjpjbGVhclBlbmRpbmdUcmFuc2FjdGlvbnMoKTsKLSAgICB9CisgICAgSURCUGVu ZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKHBhZ2UtPmdy b3VwKCkuaWRiRmFjdG9yeSgpKTsKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkK ICAgICAvLyBJZiB3ZSd2ZSBqdXN0IGxlZnQgYSB0b3AgbGV2ZWwgc2NyaXB0IGNvbnRleHQgYW5k IGxvY2FsIHN0b3JhZ2UgaGFzIGJlZW4KICAgICAvLyBpbnN0YW50aWF0ZWQsIHdlIG11c3QgZW5z dXJlIHRoYXQgYW55IHN0b3JhZ2UgbG9ja3MgaGF2ZSBiZWVuIGZyZWVkLgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFn ZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHAKaW5kZXggNGNiYWMwZWUwNDc2YmFlMjg0OWEwNzg1 OWJjMTUwMWJhMTE0ZGIyNC4uODk0YTYwY2IxMjNiZmY2NmI3MDFjMGZmMzljNTZhMzE3ZTIwNTY2 ZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcAor KysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCQ3Vyc29yQmFja2VuZEltcGwuY3BwCkBAIC0zNSw2ICsz NSw3IEBACiAjaW5jbHVkZSAiSURCS2V5UmFuZ2UuaCIKICNpbmNsdWRlICJJREJPYmplY3RTdG9y ZUJhY2tlbmRJbXBsLmgiCiAjaW5jbHVkZSAiSURCUmVxdWVzdC5oIgorI2luY2x1ZGUgIklEQlRy YW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oIgogI2luY2x1ZGUgIlNRTGl0ZURhdGFiYXNlLmgi CiAjaW5jbHVkZSAiU1FMaXRlU3RhdGVtZW50LmgiCiAjaW5jbHVkZSAiU2VyaWFsaXplZFNjcmlw dFZhbHVlLmgiCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwIGIv V2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlLmNwcAppbmRleCA4MTk1MGQ2ZTA0M2JkZjIwYmY1 YmJjNWY2M2Y5OTgwMjYyOTJjYWNhLi44YTA2MjAyOGQ2MGQwNGEzODlhYzYyYzVkMGFhZjlmNThh N2RlZjhkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZS5jcHAKQEAgLTU3LDkgKzU3LDEwIEBAIFBhc3NS ZWZQdHI8SURCUmVxdWVzdD4gSURCRGF0YWJhc2U6OmNyZWF0ZU9iamVjdFN0b3JlKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvCiAKIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IElEQkRhdGFi YXNlOjpvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUp CiB7CisgICAgLy8gRklYTUU6IHJlbW92ZSB0aGlzIG1ldGhvZC4KICAgICBSZWZQdHI8SURCT2Jq ZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZSA9IG1fYmFja2VuZC0+b2JqZWN0 U3RvcmUobmFtZSwgbW9kZSk7CiAgICAgQVNTRVJUKG9iamVjdFN0b3JlKTsgLy8gRklYTUU6IElm IHRoaXMgaXMgbnVsbCwgd2Ugc2hvdWxkIHJhaXNlIGEgTk9UX0ZPVU5EX0VSUi4KLSAgICByZXR1 cm4gSURCT2JqZWN0U3RvcmU6OmNyZWF0ZShvYmplY3RTdG9yZS5yZWxlYXNlKCkpOworICAgIHJl dHVybiBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9iamVjdFN0b3JlLnJlbGVhc2UoKSwgLTEpOwog fQogCiBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IElEQkRhdGFiYXNlOjpyZW1vdmVPYmplY3RTdG9y ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUpCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5jcHAgYi9X ZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5jcHAKaW5kZXggMDIxZjcwYWE0 YjQ4ODExOWU5ZmM5NjE2ZjA0NWQ0OTljYTRiODFhYi4uZDJlMjY3MTk1MTFhM2RhNzgyMGM1ZTg2 MTA0NjhlMDdmNjRiMGJjNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNl QmFja2VuZEltcGwuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJ bXBsLmNwcApAQCAtMTQ4LDExICsxNDgsMTQgQEAgdm9pZCBJREJEYXRhYmFzZUJhY2tlbmRJbXBs OjpjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYKICAg ICBjYWxsYmFja3MtPm9uU3VjY2VzcyhvYmplY3RTdG9yZS5nZXQoKSk7CiB9CiAKLVBhc3NSZWZQ dHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBJREJEYXRhYmFzZUJhY2tlbmRJbXBs OjpvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUpCitQ YXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gSURCRGF0YWJhc2VCYWNr ZW5kSW1wbDo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBzaG9ydCBt b2RlLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKQogewotICAg IC8vIEZJWE1FOiBJZiBubyB0cmFuc2FjdGlvbiBpcyBydW5uaW5nLCB0aGlzIHNob3VsZCBpbXBs aWNpdGx5IHN0YXJ0IG9uZS4KKyAgICAvLyBGSVhNRTogRG8gbm90IGV4cG9zZSB0aGlzIG1ldGhv ZCB2aWEgSURMLgogICAgIEFTU0VSVF9VTlVTRUQobW9kZSwgIW1vZGUpOyAvLyBGSVhNRTogSGFu ZGxlIG5vbi1zdGFuZGFyZCBtb2Rlcy4KLSAgICByZXR1cm4gbV9vYmplY3RTdG9yZXMuZ2V0KG5h bWUpOworICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0 b3JlID0gbV9vYmplY3RTdG9yZXMuZ2V0KG5hbWUpOworICAgIGlmIChvYmplY3RTdG9yZSkKKyAg ICAgICAgb2JqZWN0U3RvcmUtPnNldFRyYW5zYWN0aW9uKHRyYW5zYWN0aW9uKTsKKyAgICByZXR1 cm4gb2JqZWN0U3RvcmUucmVsZWFzZSgpOwogfQogCiBzdGF0aWMgdm9pZCBkb0RlbGV0ZShTUUxp dGVEYXRhYmFzZSYgZGIsIGNvbnN0IGNoYXIqIHNxbCwgaW50NjRfdCBpZCkKZGlmZiAtLWdpdCBh L1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmggYi9XZWJDb3JlL3N0b3Jh Z2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oCmluZGV4IGFiMDU1Zjg4YThjMDhmMmY2ZDAzZDY5 NTk4MTQ0MTU3OGM0ZjI1NzAuLmMyYWJiNTg3ZDBjMDAzYmFlZjBiMWJiMWYxMzEyZGUwNjg0ODkx ZjYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmgK KysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaApAQCAtNTcsMTEg KzU3LDEzIEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8RE9NU3RyaW5nTGlzdD4g b2JqZWN0U3RvcmVzKCkgY29uc3Q7CiAKICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlT2JqZWN0U3Rv cmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGtleVBhdGgsIGJvb2wgYXV0b0lu Y3JlbWVudCwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKLSAgICB2aXJ0dWFsIFBhc3NSZWZQ dHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJp bmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUpOworICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJ REJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYg bmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNl Kik7CiAgICAgdmlydHVhbCB2b2lkIHJlbW92ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFt ZSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmVyc2lv bihjb25zdCBTdHJpbmcmIHZlcnNpb24sIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAgICAg dmlydHVhbCBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNh Y3Rpb24oRE9NU3RyaW5nTGlzdCogc3RvcmVOYW1lcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5z aWduZWQgbG9uZyB0aW1lb3V0KTsKIAorICAgIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRy YW5zYWN0aW9uQ29vcmRpbmF0b3IoKSBjb25zdCB7IHJldHVybiBtX3RyYW5zYWN0aW9uQ29vcmRp bmF0b3IuZ2V0KCk7IH0KKwogcHJpdmF0ZToKICAgICBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwgUGFzc093blB0cjxT UUxpdGVEYXRhYmFzZT4gZGF0YWJhc2UsIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqKTsKIApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVyZmFjZS5o IGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVyZmFjZS5oCmluZGV4IGEy ZTA0MmFlMjAwMDBhNDFjMmY2ZDUwNTA5ZmRhNDc1Zjc1NTM4NDUuLmQxZTFjYjE4MjRhMzE5NGE2 NmU5YzZmZWY5NmIxMmQzZGUxMDExMTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJE YXRhYmFzZUJhY2tlbmRJbnRlcmZhY2UuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJh c2VCYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTU1LDcgKzU1LDcgQEAgcHVibGljOgogICAgIHZpcnR1 YWwgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBvYmplY3RTdG9yZXMoKSBjb25zdCA9IDA7CiAK ICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBj b25zdCBTdHJpbmcmIGtleVBhdGgsIGJvb2wgYXV0b0luY3JlbWVudCwgUGFzc1JlZlB0cjxJREJD YWxsYmFja3M+KSA9IDA7Ci0gICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFj a2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBz aG9ydCBtb2RlKSA9IDA7CisgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFj a2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBz aG9ydCBtb2RlLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uID0g MCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCByZW1vdmVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcm IG5hbWUsIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPikgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBz ZXRWZXJzaW9uKGNvbnN0IFN0cmluZyYgdmVyc2lvbiwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+ KSA9IDA7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZT4gdHJhbnNhY3Rpb24oRE9NU3RyaW5nTGlzdCogc3RvcmVOYW1lcywgdW5zaWduZWQgc2hv cnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0KSA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJG YWN0b3J5QmFja2VuZEltcGwuY3BwCmluZGV4IDUwY2Y3NzhmMTYyYTcwOTkwMGI5ZDAyNTBhN2Iz NjQ2MTNiMWE4YTUuLjIzMzg2NDAzYWRjYWQ3OThlZTc5YzQxYWMxMGFlMzVmMTExMTIwMTEgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuY3BwCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuY3BwCkBAIC0xNDIsOCArMTQy LDEyIEBAIHZvaWQgSURCRmFjdG9yeUJhY2tlbmRJbXBsOjpvcGVuKGNvbnN0IFN0cmluZyYgbmFt ZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwKIAogdm9pZCBJREJGYWN0b3J5QmFja2VuZElt cGw6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBWZWN0b3I8aW50PiYgcGVuZGluZ0lE cykKIHsKLSAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHBlbmRpbmdJRHMuc2l6ZSgpOyArK2kp Ci0gICAgICAgIG1fdHJhbnNhY3Rpb25Db29yZGluYXRvci0+YWJvcnQocGVuZGluZ0lEcy5hdChp KSk7CisgICAgbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLT5hYm9ydFBlbmRpbmdUcmFuc2FjdGlv bnMocGVuZGluZ0lEcyk7Cit9CisKK3ZvaWQgSURCRmFjdG9yeUJhY2tlbmRJbXBsOjpkaWRDb21w bGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKGludCB0cmFuc2FjdGlvbklEKQoreworICAgIG1fdHJh bnNhY3Rpb25Db29yZGluYXRvci0+ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbih0cmFu c2FjdGlvbklEKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lE QkZhY3RvcnlCYWNrZW5kSW1wbC5oCmluZGV4IGM5YTMzZGEwMWY0Y2JhZmFjOTlhYzNjMDMxMTNm MWJmZGRlNmVlOGUuLjhiNTQ4OTEyZmRlZjRhMmI5MWEwY2Q2OTgxMGZmZTQ0ZTMwMDYzZjIgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuaAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmgKQEAgLTUxLDYgKzUxLDcgQEAg cHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIG9wZW4oY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4sIFBhc3NSZWZQ dHI8U2VjdXJpdHlPcmlnaW4+LCBGcmFtZSopOwogICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRp bmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIHBlbmRpbmdJRHMpOworICAgIHZpcnR1 YWwgdm9pZCBkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKGludCB0cmFuc2FjdGlvbklE KTsKIAogcHJpdmF0ZToKICAgICBJREJGYWN0b3J5QmFja2VuZEltcGwoKTsKZGlmZiAtLWdpdCBh L1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEludGVyZmFjZS5oIGIvV2ViQ29yZS9z dG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlLmgKaW5kZXggYzA1MmJjMjkwMmYxYjRk ZWQwN2RhZTY5NzkyNjliODZlMGFjNDZiOS4uMTdjZGIyNWNkZjUxZmY0YmUzOGUxMWM0YjMyN2Mz OTkzYTlhNDU4MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5k SW50ZXJmYWNlLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW50ZXJm YWNlLmgKQEAgLTUzLDYgKzUzLDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIG9wZW4o Y29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNzUmVmUHRy PElEQkNhbGxiYWNrcz4sIFBhc3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+LCBGcmFtZSopID0gMDsK ICAgICB2aXJ0dWFsIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFZlY3Rvcjxp bnQ+JiBpZHMpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tcGxldGVFdmVudHNGb3JUcmFu c2FjdGlvbihpbnQgdHJhbnNhY3Rpb25JRCkgPSAwOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcCBiL1dl YkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHAKaW5kZXggYjQ1N2NkMWQxNTg4NmMxMGZi MmUxZjMzNGEzZGMyMmEzZmRmMWM4NS4uNWQwNWEzMzhmOWY3NWFhNWZmZTYzNTIwZjY1ZTk0ODg0 ZjM0ZDM5YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcAor KysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuY3BwCkBAIC0zMSw2ICszMSw3IEBA CiAjaW5jbHVkZSAiSURCSW5kZXguaCIKICNpbmNsdWRlICJJREJLZXkuaCIKICNpbmNsdWRlICJJ REJLZXlSYW5nZS5oIgorI2luY2x1ZGUgIklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuaCIK ICNpbmNsdWRlICJTZXJpYWxpemVkU2NyaXB0VmFsdWUuaCIKICNpbmNsdWRlIDx3dGYvVW51c2Vk UGFyYW0uaD4KIApAQCAtMzgsOCArMzksMTAgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1J REJPYmplY3RTdG9yZTo6SURCT2JqZWN0U3RvcmUoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJh Y2tlbmRJbnRlcmZhY2U+IGlkYk9iamVjdFN0b3JlKQorSURCT2JqZWN0U3RvcmU6OklEQk9iamVj dFN0b3JlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBpZGJPYmpl Y3RTdG9yZSwgaW50IHRyYW5zYWN0aW9uSWQpCiAgICAgOiBtX29iamVjdFN0b3JlKGlkYk9iamVj dFN0b3JlKQorICAgICwgbV90cmFuc2FjdGlvbklkKHRyYW5zYWN0aW9uSWQpCisgICAgLCBtX2lz VHJhbnNhY3Rpb25QZW5kaW5nKHRydWUpCiB7CiAgICAgLy8gV2UgcGFzcyBhIHJlZmVyZW5jZSB0 byB0aGlzIG9iamVjdCBiZWZvcmUgaXQgY2FuIGJlIGFkb3B0ZWQuCiAgICAgcmVsYXhBZG9wdGlv blJlcXVpcmVtZW50KCk7CkBAIC02Miw3ICs2NSw4IEBAIFBhc3NSZWZQdHI8RE9NU3RyaW5nTGlz dD4gSURCT2JqZWN0U3RvcmU6OmluZGV4TmFtZXMoKSBjb25zdAogCiBQYXNzUmVmUHRyPElEQlJl cXVlc3Q+IElEQk9iamVjdFN0b3JlOjpnZXQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4 dCwgUGFzc1JlZlB0cjxJREJLZXk+IGtleSkKIHsKLSAgICBSZWZQdHI8SURCUmVxdWVzdD4gcmVx dWVzdCA9IElEQlJlcXVlc3Q6OmNyZWF0ZShjb250ZXh0LCBJREJBbnk6OmNyZWF0ZSh0aGlzKSk7 CisgICAgUmVmUHRyPElEQlJlcXVlc3Q+IHJlcXVlc3QgPSBJREJSZXF1ZXN0OjpjcmVhdGUoY29u dGV4dCwgSURCQW55OjpjcmVhdGUodGhpcyksIG1fdHJhbnNhY3Rpb25JZCk7CisgICAgcmVtb3Zl VHJhbnNhY3Rpb25Gcm9tUGVuZGluZ0xpc3QoKTsKICAgICBtX29iamVjdFN0b3JlLT5nZXQoa2V5 LCByZXF1ZXN0KTsKICAgICByZXR1cm4gcmVxdWVzdDsKIH0KQEAgLTcwLDYgKzc0LDcgQEAgUGFz c1JlZlB0cjxJREJSZXF1ZXN0PiBJREJPYmplY3RTdG9yZTo6Z2V0KFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqIGNvbnRleHQsIFBhc3MKIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gSURCT2JqZWN0U3Rv cmU6OmFkZChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPFNlcmlh bGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5PiBrZXkpCiB7CiAgICAg UmVmUHRyPElEQlJlcXVlc3Q+IHJlcXVlc3QgPSBJREJSZXF1ZXN0OjpjcmVhdGUoY29udGV4dCwg SURCQW55OjpjcmVhdGUodGhpcykpOworICAgIHJlbW92ZVRyYW5zYWN0aW9uRnJvbVBlbmRpbmdM aXN0KCk7CiAgICAgbV9vYmplY3RTdG9yZS0+cHV0KHZhbHVlLCBrZXksIHRydWUsIHJlcXVlc3Qp OwogICAgIHJldHVybiByZXF1ZXN0OwogfQpAQCAtNzcsNiArODIsNyBAQCBQYXNzUmVmUHRyPElE QlJlcXVlc3Q+IElEQk9iamVjdFN0b3JlOjphZGQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4dCwgUGFzcwogUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBJREJPYmplY3RTdG9yZTo6cHV0KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlw dFZhbHVlPiB2YWx1ZSwgUGFzc1JlZlB0cjxJREJLZXk+IGtleSkKIHsKICAgICBSZWZQdHI8SURC UmVxdWVzdD4gcmVxdWVzdCA9IElEQlJlcXVlc3Q6OmNyZWF0ZShjb250ZXh0LCBJREJBbnk6OmNy ZWF0ZSh0aGlzKSk7CisgICAgcmVtb3ZlVHJhbnNhY3Rpb25Gcm9tUGVuZGluZ0xpc3QoKTsKICAg ICBtX29iamVjdFN0b3JlLT5wdXQodmFsdWUsIGtleSwgZmFsc2UsIHJlcXVlc3QpOwogICAgIHJl dHVybiByZXF1ZXN0OwogfQpAQCAtODQsNiArOTAsNyBAQCBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+ IElEQk9iamVjdFN0b3JlOjpwdXQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFz cwogUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBJREJPYmplY3RTdG9yZTo6cmVtb3ZlKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8SURCS2V5PiBrZXkpCiB7CiAgICAg UmVmUHRyPElEQlJlcXVlc3Q+IHJlcXVlc3QgPSBJREJSZXF1ZXN0OjpjcmVhdGUoY29udGV4dCwg SURCQW55OjpjcmVhdGUodGhpcykpOworICAgIHJlbW92ZVRyYW5zYWN0aW9uRnJvbVBlbmRpbmdM aXN0KCk7CiAgICAgbV9vYmplY3RTdG9yZS0+cmVtb3ZlKGtleSwgcmVxdWVzdCk7CiAgICAgcmV0 dXJuIHJlcXVlc3Q7CiB9CkBAIC0xMTYsNiArMTIzLDE1IEBAIFBhc3NSZWZQdHI8SURCUmVxdWVz dD4gSURCT2JqZWN0U3RvcmU6Om9wZW5DdXJzb3IoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4CiAgICAgcmV0dXJuIHJlcXVlc3QucmVsZWFzZSgpOwogfQogCit2b2lkIElEQk9iamVjdFN0 b3JlOjpyZW1vdmVUcmFuc2FjdGlvbkZyb21QZW5kaW5nTGlzdCgpCit7CisgICAgaWYgKCFtX2lz VHJhbnNhY3Rpb25QZW5kaW5nKQorICAgICAgICByZXR1cm47CisKKyAgICBtX2lzVHJhbnNhY3Rp b25QZW5kaW5nID0gZmFsc2U7CisgICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6cmVt b3ZlUGVuZGluZ1RyYW5zYWN0aW9uKG1fdHJhbnNhY3Rpb25JZCk7Cit9CisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmggYi9XZWJDb3JlL3N0b3JhZ2Uv SURCT2JqZWN0U3RvcmUuaAppbmRleCAwMzVmNWQ4YjQ3ZmJhODJjYmMzZWQyNDg1YjViNzg4ZTAz MjMxOTI2Li41MzdkOThlNjVlY2NmMGY1NzFjZTExMDlkNDIzMzFjMDEyODE0OGNlIDEwMDY0NAot LS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvSURCT2JqZWN0U3RvcmUuaApAQCAtNDcsOSArNDcsOSBAQCBjbGFzcyBTZXJpYWxpemVkU2Ny aXB0VmFsdWU7CiAKIGNsYXNzIElEQk9iamVjdFN0b3JlIDogcHVibGljIFJlZkNvdW50ZWQ8SURC T2JqZWN0U3RvcmU+IHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJPYmplY3RT dG9yZT4gY3JlYXRlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBp ZGJPYmplY3RTdG9yZSkKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gY3Jl YXRlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RT dG9yZSwgaW50IHRyYW5zYWN0aW9uSWQpCiAgICAgewotICAgICAgICByZXR1cm4gYWRvcHRSZWYo bmV3IElEQk9iamVjdFN0b3JlKGlkYk9iamVjdFN0b3JlKSk7CisgICAgICAgIHJldHVybiBhZG9w dFJlZihuZXcgSURCT2JqZWN0U3RvcmUoaWRiT2JqZWN0U3RvcmUsIHRyYW5zYWN0aW9uSWQpKTsK ICAgICB9CiAgICAgfklEQk9iamVjdFN0b3JlKCkgeyB9CiAKQEAgLTY5LDkgKzY5LDEyIEBAIHB1 YmxpYzoKICAgICBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IG9wZW5DdXJzb3IoU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8SURCS2V5UmFuZ2U+ID0gMCwgdW5zaWduZWQgc2hvcnQg ZGlyZWN0aW9uID0gSURCQ3Vyc29yOjpORVhUKTsKIAogcHJpdmF0ZToKLSAgICBJREJPYmplY3RT dG9yZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4pOworICAgIElE Qk9iamVjdFN0b3JlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiwg aW50IHRyYW5zYWN0aW9uX2lkKTsKKyAgICB2b2lkIHJlbW92ZVRyYW5zYWN0aW9uRnJvbVBlbmRp bmdMaXN0KCk7CiAKICAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBt X29iamVjdFN0b3JlOworICAgIGludCBtX3RyYW5zYWN0aW9uSWQ7CisgICAgYm9vbCBtX2lzVHJh bnNhY3Rpb25QZW5kaW5nOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwCmluZGV4IDg2MjM3ZGUwZjU0 MWMwMTYyMTkzOTBlOGRjZDk0MmIxYmMwZjdmMWUuLmUwMTYyODE2NGQ2MGNlYWI1MjBlNWJjYmZh ZGJmOTljOWM1NzE5MDMgMTAwNzU1Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9y ZUJhY2tlbmRJbXBsLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNr ZW5kSW1wbC5jcHAKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlICJJREJLZXlQYXRoLmgiCiAj aW5jbHVkZSAiSURCS2V5UGF0aEJhY2tlbmRJbXBsLmgiCiAjaW5jbHVkZSAiSURCS2V5UmFuZ2Uu aCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaCIKICNpbmNsdWRl ICJTUUxpdGVEYXRhYmFzZS5oIgogI2luY2x1ZGUgIlNRTGl0ZVN0YXRlbWVudC5oIgogI2luY2x1 ZGUgIlNRTGl0ZVRyYW5zYWN0aW9uLmgiCkBAIC03OSwyMiArODAsMTMgQEAgc3RhdGljIHZvaWQg YmluZFdoZXJlQ2xhdXNlKFNRTGl0ZVN0YXRlbWVudCYgcXVlcnksIGludDY0X3QgaWQsIElEQktl eSoga2V5KQogCiB2b2lkIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldChQYXNzUmVmUHRy PElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAg IFNRTGl0ZVN0YXRlbWVudCBxdWVyeShzcWxpdGVEYXRhYmFzZSgpLCAiU0VMRUNUIGtleVN0cmlu Zywga2V5RGF0ZSwga2V5TnVtYmVyLCB2YWx1ZSBGUk9NIE9iamVjdFN0b3JlRGF0YSAiICsgd2hl cmVDbGF1c2Uoa2V5LmdldCgpKSk7Ci0gICAgYm9vbCBvayA9IHF1ZXJ5LnByZXBhcmUoKSA9PSBT UUxSZXN1bHRPazsKLSAgICBBU1NFUlRfVU5VU0VEKG9rLCBvayk7IC8vIEZJWE1FOiBCZXR0ZXIg ZXJyb3IgaGFuZGxpbmc/Ci0KLSAgICBiaW5kV2hlcmVDbGF1c2UocXVlcnksIG1faWQsIGtleS5n ZXQoKSk7Ci0gICAgaWYgKHF1ZXJ5LnN0ZXAoKSAhPSBTUUxSZXN1bHRSb3cpIHsKLSAgICAgICAg Y2FsbGJhY2tzLT5vbkVycm9yKElEQkRhdGFiYXNlRXJyb3I6OmNyZWF0ZShJREJEYXRhYmFzZUV4 Y2VwdGlvbjo6Tk9UX0ZPVU5EX0VSUiwgIktleSBkb2VzIG5vdCBleGlzdCBpbiB0aGUgb2JqZWN0 IHN0b3JlLiIpKTsKKyAgICBpZiAoIW1fdHJhbnNhY3Rpb24pIHsKKyAgICAgICAgY2FsbGJhY2tz LT5vbkVycm9yKElEQkRhdGFiYXNlRXJyb3I6OmNyZWF0ZShJREJEYXRhYmFzZUV4Y2VwdGlvbjo6 Tk9UX0FMTE9XRURfRVJSLCAiR2V0IG11c3QgYmUgY2FsbGVkIGluIHRoZSBjb250ZXh0IG9mIGEg dHJhbnNhY3Rpb24uIikpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCi0gICAgQVNTRVJUKChr ZXktPnR5cGUoKSA9PSBJREJLZXk6OlN0cmluZ1R5cGUpICE9IHF1ZXJ5LmlzQ29sdW1uTnVsbCgw KSk7Ci0gICAgLy8gRklYTUU6IEltcGxlbWVudCBkYXRlLgotICAgIEFTU0VSVCgoa2V5LT50eXBl KCkgPT0gSURCS2V5OjpOdW1iZXJUeXBlKSAhPSBxdWVyeS5pc0NvbHVtbk51bGwoMikpOwotCi0g ICAgY2FsbGJhY2tzLT5vblN1Y2Nlc3MoU2VyaWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGVGcm9t V2lyZShxdWVyeS5nZXRDb2x1bW5UZXh0KDMpKSk7Ci0gICAgQVNTRVJUKHF1ZXJ5LnN0ZXAoKSAh PSBTUUxSZXN1bHRSb3cpOworICAgIE93blB0cjxHZXRUYXNrPiBnZXRUYXNrID0gYWRvcHRQdHIo bmV3IEdldFRhc2sobV90cmFuc2FjdGlvbi5nZXQoKSwga2V5LCBtX2lkLCBjYWxsYmFja3MsIHNx bGl0ZURhdGFiYXNlKCkpKTsKKyAgICBtX3RyYW5zYWN0aW9uLT5zY2hlZHVsZVRhc2soZ2V0VGFz ay5sZWFrUHRyKCkpOwogfQogCiBzdGF0aWMgUGFzc1JlZlB0cjxJREJLZXk+IGZldGNoS2V5RnJv bUtleVBhdGgoU2VyaWFsaXplZFNjcmlwdFZhbHVlKiB2YWx1ZSwgY29uc3QgU3RyaW5nJiBrZXlQ YXRoKQpAQCAtMzg4LDYgKzM4MCwzNyBAQCBTUUxpdGVEYXRhYmFzZSYgSURCT2JqZWN0U3RvcmVC YWNrZW5kSW1wbDo6c3FsaXRlRGF0YWJhc2UoKSBjb25zdAogICAgIHJldHVybiBtX2RhdGFiYXNl LT5zcWxpdGVEYXRhYmFzZSgpOwogfQogCisKK0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6Okdl dFRhc2s6OkdldFRhc2soSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlv biwgUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgaW50NjRfdCBpZCwgUGFzc1JlZlB0cjxJREJDYWxs YmFja3M+IGNhbGxiYWNrcywgU1FMaXRlRGF0YWJhc2UmIGRhdGFiYXNlKQorICAgIDogbV90cmFu c2FjdGlvbih0cmFuc2FjdGlvbikKKyAgICAsIG1fa2V5KGtleSkKKyAgICAsIG1faWQoaWQpCisg ICAgLCBtX2NhbGxiYWNrcyhjYWxsYmFja3MpCisgICAgLCBtX2RhdGFiYXNlKGRhdGFiYXNlKQor eworfQorCit2b2lkIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OkdldFRhc2s6OnBlcmZvcm1U YXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKQoreworICAgIFNRTGl0ZVN0YXRlbWVudCBxdWVy eShtX2RhdGFiYXNlLCAiU0VMRUNUIGtleVN0cmluZywga2V5RGF0ZSwga2V5TnVtYmVyLCB2YWx1 ZSBGUk9NIE9iamVjdFN0b3JlRGF0YSAiICsgd2hlcmVDbGF1c2UobV9rZXkuZ2V0KCkpKTsKKyAg ICBib29sIG9rID0gcXVlcnkucHJlcGFyZSgpID09IFNRTFJlc3VsdE9rOworICAgIEFTU0VSVF9V TlVTRUQob2ssIG9rKTsgLy8gRklYTUU6IEJldHRlciBlcnJvciBoYW5kbGluZz8KKworICAgIGJp bmRXaGVyZUNsYXVzZShxdWVyeSwgbV9pZCwgbV9rZXkuZ2V0KCkpOworICAgIGlmIChxdWVyeS5z dGVwKCkgIT0gU1FMUmVzdWx0Um93KSB7CisgICAgICAgIG1fY2FsbGJhY2tzLT5vbkVycm9yKElE QkRhdGFiYXNlRXJyb3I6OmNyZWF0ZShJREJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9UX0ZPVU5EX0VS UiwgIktleSBkb2VzIG5vdCBleGlzdCBpbiB0aGUgb2JqZWN0IHN0b3JlLiIpKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIEFTU0VSVCgobV9rZXktPnR5cGUoKSA9PSBJREJLZXk6OlN0 cmluZ1R5cGUpICE9IHF1ZXJ5LmlzQ29sdW1uTnVsbCgwKSk7CisgICAgLy8gRklYTUU6IEltcGxl bWVudCBkYXRlLgorICAgIEFTU0VSVCgobV9rZXktPnR5cGUoKSA9PSBJREJLZXk6Ok51bWJlclR5 cGUpICE9IHF1ZXJ5LmlzQ29sdW1uTnVsbCgyKSk7CisKKyAgICBtX2NhbGxiYWNrcy0+b25TdWNj ZXNzKFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZTo6Y3JlYXRlRnJvbVdpcmUocXVlcnkuZ2V0Q29sdW1u VGV4dCgzKSkpOworICAgIEFTU0VSVChxdWVyeS5zdGVwKCkgIT0gU1FMUmVzdWx0Um93KTsKK30K KworCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFnZS9J REJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmgKaW5kZXggMzJlZjkyMDMyMjEzMjlmZTVhZTUyN2Ux ZTNhNjc5ZWZjY2U5ZWZmZS4uNjg1NGQ2Njg4NjUwNDZiOTgzMDdlMzY4NDFlMTJlYmJmMjQyYTMz NSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwu aAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5oCkBAIC0y Nyw2ICsyNyw3IEBACiAjZGVmaW5lIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGxfaAogCiAjaW5j bHVkZSAiSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgiCisjaW5jbHVkZSA8U2NyaXB0 RXhlY3V0aW9uQ29udGV4dC5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCkBAIC0zNiw2ICszNyw3IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogY2xhc3MgSURCRGF0YWJhc2VCYWNrZW5kSW1wbDsKIGNsYXNzIElEQkluZGV4QmFj a2VuZEltcGw7CitjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7CiBjbGFzcyBT UUxpdGVEYXRhYmFzZTsKIAogY2xhc3MgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbCA6IHB1Ymxp YyBJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UgewpAQCAtNjMsMTIgKzY1LDI4IEBAIHB1 YmxpYzoKIAogICAgIElEQkRhdGFiYXNlQmFja2VuZEltcGwqIGRhdGFiYXNlKCkgY29uc3QgeyBy ZXR1cm4gbV9kYXRhYmFzZS5nZXQoKTsgfQogCisgICAgdm9pZCBzZXRUcmFuc2FjdGlvbihJREJU cmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKSB7IG1fdHJhbnNhY3Rpb24g PSB0cmFuc2FjdGlvbjsgfQorCiBwcml2YXRlOgogICAgIElEQk9iamVjdFN0b3JlQmFja2VuZElt cGwoSURCRGF0YWJhc2VCYWNrZW5kSW1wbCosIGludDY0X3QgaWQsIGNvbnN0IFN0cmluZyYgbmFt ZSwgY29uc3QgU3RyaW5nJiBrZXlQYXRoLCBib29sIGF1dG9JbmNyZW1lbnQpOwogCiAgICAgdm9p ZCBsb2FkSW5kZXhlcygpOwogICAgIFNRTGl0ZURhdGFiYXNlJiBzcWxpdGVEYXRhYmFzZSgpIGNv bnN0OwogCisgICAgY2xhc3MgR2V0VGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0 OjpUYXNrIHsKKyAgICBwdWJsaWM6CisgICAgICAgIEdldFRhc2soSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW50ZXJmYWNlKiwgUGFzc1JlZlB0cjxJREJLZXk+LCBpbnQ2NF90IGlkLCBQYXNzUmVmUHRy PElEQkNhbGxiYWNrcz4sIFNRTGl0ZURhdGFiYXNlJik7CisgICAgICAgIHZpcnR1YWwgfkdldFRh c2soKSB7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqKTsKKworICAgIHByaXZhdGU6CisgICAgICAgIFJlZlB0cjxJREJUcmFuc2FjdGlv bkJhY2tlbmRJbnRlcmZhY2U+IG1fdHJhbnNhY3Rpb247CisgICAgICAgIFJlZlB0cjxJREJLZXk+ IG1fa2V5OworICAgICAgICBpbnQ2NF90IG1faWQ7CisgICAgICAgIFJlZlB0cjxJREJDYWxsYmFj a3M+IG1fY2FsbGJhY2tzOworICAgICAgICBTUUxpdGVEYXRhYmFzZSYgbV9kYXRhYmFzZTsKKyAg ICB9OworCiAgICAgUmVmUHRyPElEQkRhdGFiYXNlQmFja2VuZEltcGw+IG1fZGF0YWJhc2U7CiAK ICAgICBpbnQ2NF90IG1faWQ7CkBAIC03OCw2ICs5Niw4IEBAIHByaXZhdGU6CiAKICAgICB0eXBl ZGVmIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8SURCSW5kZXhCYWNrZW5kSW1wbD4gPiBJbmRleE1h cDsKICAgICBJbmRleE1hcCBtX2luZGV4ZXM7CisKKyAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25C YWNrZW5kSW50ZXJmYWNlPiBtX3RyYW5zYWN0aW9uOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZElu dGVyZmFjZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFj ZS5oCmluZGV4IDIwMGFjMjliYTdjY2ExNTk4MTg1ZTM1OTNiZmE0ZDZmYjYzYTFkNGUuLjMyYTA5 MjMzNTgxOTY5ZjlmZjg4OTIyYzE3NDFhMjFiMGRlNDg3MWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv c3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UuaAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTM4LDYgKzM4LDcgQEAg Y2xhc3MgSURCQ2FsbGJhY2tzOwogY2xhc3MgSURCSW5kZXhCYWNrZW5kSW50ZXJmYWNlOwogY2xh c3MgSURCS2V5OwogY2xhc3MgSURCS2V5UmFuZ2U7CitjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2U7CiBjbGFzcyBTZXJpYWxpemVkU2NyaXB0VmFsdWU7CiAKIGNsYXNzIElEQk9i amVjdFN0b3JlQmFja2VuZEludGVyZmFjZSA6IHB1YmxpYyBUaHJlYWRTYWZlU2hhcmVkPElEQk9i amVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gewpAQCAtNTcsNiArNTgsOCBAQCBwdWJsaWM6CiAg ICAgdmlydHVhbCB2b2lkIHJlbW92ZUluZGV4KGNvbnN0IFN0cmluZyYgbmFtZSwgUGFzc1JlZlB0 cjxJREJDYWxsYmFja3M+KSA9IDA7CiAKICAgICB2aXJ0dWFsIHZvaWQgb3BlbkN1cnNvcihQYXNz UmVmUHRyPElEQktleVJhbmdlPiwgdW5zaWduZWQgc2hvcnQgZGlyZWN0aW9uLCBQYXNzUmVmUHRy PElEQkNhbGxiYWNrcz4pID0gMDsKKworICAgIHZpcnR1YWwgdm9pZCBzZXRUcmFuc2FjdGlvbihJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqKSA9IDA7CiB9OwogCiB9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0 aW9uTW9uaXRvci5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9u aXRvci5jcHAKaW5kZXggZDAyNjA5OTA4YWI1N2NkYzAxZDM5ODY5NWViMjY1MzYzMjM2MWE5Yi4u NWQwMWYyY2M1NzQ4NjQ0ODNjMTk3ODQ0OGI5YzM0YzZlMWZmNWViMiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuY3BwCisrKyBiL1dlYkNv cmUvc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcApAQCAtMjgsMTUgKzI4 LDEyIEBACiAKICNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKIAorI2luY2x1ZGUgIklEQkZh Y3RvcnlCYWNrZW5kSW50ZXJmYWNlLmgiCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogVmVjdG9y PGludD4qIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6Om1faWRzID0gMDsKIAotYm9vbCBJ REJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpoYXNQZW5kaW5nVHJhbnNhY3Rpb25zKCkKLXsK LSAgICByZXR1cm4gbV9pZHMgJiYgbV9pZHMtPnNpemUoKTsKLX0KLQogdm9pZCBJREJQZW5kaW5n VHJhbnNhY3Rpb25Nb25pdG9yOjphZGRQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKQogewogICAg IGlmICghbV9pZHMpCkBAIC00NiwyNiArNDMsMzkgQEAgdm9pZCBJREJQZW5kaW5nVHJhbnNhY3Rp b25Nb25pdG9yOjphZGRQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKQogCiB2b2lkIElEQlBlbmRp bmdUcmFuc2FjdGlvbk1vbml0b3I6OnJlbW92ZVBlbmRpbmdUcmFuc2FjdGlvbihpbnQgaWQpCiB7 Ci0gICAgbV9pZHMtPnJlbW92ZShpZCk7CisgICAgaWYgKCFtX2lkcykKKyAgICAgICAgcmV0dXJu OworCisgICAgc2l6ZV90IHBvcyA9IG1faWRzLT5maW5kKGlkKTsKKyAgICBpZiAocG9zID09IG5v dEZvdW5kKQorICAgICAgICByZXR1cm47CisKKyAgICBtX2lkcy0+cmVtb3ZlKHBvcyk7CisKICAg ICBpZiAoIW1faWRzLT5zaXplKCkpIHsKICAgICAgICAgZGVsZXRlIG1faWRzOwogICAgICAgICBt X2lkcyA9IDA7CiAgICAgfQogfQogCi12b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6 OmNsZWFyUGVuZGluZ1RyYW5zYWN0aW9ucygpCit2b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1v bml0b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhJREJGYWN0b3J5QmFja2VuZEludGVyZmFj ZSogaWRiRmFjdG9yeSkKIHsKLSAgICBpZiAoIW1faWRzKQotICAgICAgICByZXR1cm47Ci0KLSAg ICBtX2lkcy0+Y2xlYXIoKTsKLSAgICBkZWxldGUgbV9pZHM7Ci0gICAgbV9pZHMgPSAwOworICAg IFZlY3RvcjxpbnQ+IHBlbmRpbmdJZHM7CisgICAgaWYgKG1faWRzKSB7CisgICAgICBwZW5kaW5n SWRzLnN3YXAoKm1faWRzKTsKKyAgICAgIGRlbGV0ZSBtX2lkczsKKyAgICAgIG1faWRzID0gMDsK KyAgICB9CisgICAgaWYgKHBlbmRpbmdJZHMuc2l6ZSgpKSB7CisgICAgICAgIEFTU0VSVChpZGJG YWN0b3J5KTsKKyAgICAgICAgaWRiRmFjdG9yeS0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKHBl bmRpbmdJZHMpOworICAgIH0KIH0KIAotY29uc3QgVmVjdG9yPGludD4mIElEQlBlbmRpbmdUcmFu c2FjdGlvbk1vbml0b3I6OnBlbmRpbmdUcmFuc2FjdGlvbnMoKQordm9pZCBJREJQZW5kaW5nVHJh bnNhY3Rpb25Nb25pdG9yOjpkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKGludCBpZCwg SURCRmFjdG9yeUJhY2tlbmRJbnRlcmZhY2UqIGlkYkZhY3RvcnkpCiB7Ci0gICAgcmV0dXJuICpt X2lkczsKKyAgICAvLyBGSVhNRTogY2hlY2sgaWYgd2UgaGFkIGFueSBleGNlcHRpb24gZHVyaW5n IHRoZSBldmVudCBhbmQgbm90aWZ5IHRoZSBmYWN0b3J5IHRvIGFib3J0IHRoZSB0cmFuc2FjdGlv bi4KKyAgICBpZGJGYWN0b3J5LT5kaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKGlkKTsK IH0KIAogfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rp b25Nb25pdG9yLmggYi9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRv ci5oCmluZGV4IDAwZTgzM2FmYjIyMTg1M2JkOTliMzkzODQxNTE2MGYzZGNjN2M2ZjYuLjlmZDMy NWFjNDA4ODg4ZjVlYzJjMTJkNGEyMjlmZDc1OTI0MGY3OGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv c3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgKKysrIGIvV2ViQ29yZS9zdG9y YWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuaApAQCAtMzMsNiArMzMsOCBAQAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIElEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlOwor CiAvLyBUaGlzIGNsYXNzIGtlZXBzIHRyYWNrIG9mIHRoZSB0cmFuc2FjdGlvbnMgY3JlYXRlZCBk dXJpbmcgdGhlIGN1cnJlbnQKIC8vIEphdmFzY3JpcHQgZXhlY3V0aW9uIGNvbnRleHQuIEEgdHJh bnNhY3Rpb24gaXMgJ3BlbmRpbmcnIGlmIG5vIGFzeW5jaHJvbm91cwogLy8gb3BlcmF0aW9uIGlz IGN1cnJlbnRseSBxdWV1ZWQgZm9yIGl0IChlLmcuIGFuIElEQk9iamVjdFN0b3JlOjpwdXQoKSBv ciBzaW1pbGFyKS4KQEAgLTQ0LDExICs0NiwxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAvLyBz b2x1dGlvbiBpcyB0byBrZWVwIHRoZSB2ZWN0b3IgaW4gdGhlIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQuCiBjbGFzcyBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yIDogcHVibGljIE5vbmNvcHlh YmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgYm9vbCBoYXNQZW5kaW5nVHJhbnNhY3Rpb25zKCk7 CiAgICAgc3RhdGljIHZvaWQgYWRkUGVuZGluZ1RyYW5zYWN0aW9uKGludCBpZCk7CiAgICAgc3Rh dGljIHZvaWQgcmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKGludCBpZCk7Ci0gICAgc3RhdGljIHZv aWQgY2xlYXJQZW5kaW5nVHJhbnNhY3Rpb25zKCk7Ci0gICAgc3RhdGljIGNvbnN0IFZlY3Rvcjxp bnQ+JiBwZW5kaW5nVHJhbnNhY3Rpb25zKCk7CisgICAgc3RhdGljIHZvaWQgYWJvcnRQZW5kaW5n VHJhbnNhY3Rpb25zKElEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlKik7CisgICAgc3RhdGljIHZv aWQgZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgaWQsIElEQkZhY3RvcnlCYWNr ZW5kSW50ZXJmYWNlKik7CiAKIHByaXZhdGU6CiAgICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9u aXRvcigpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuY3BwIGIvV2Vi Q29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuY3BwCmluZGV4IDM1MTNjMTc1MTE4NTgwNWZiMGFjYzQ1 ZTcyYTRmMTZiNDRhODZjYjYuLjkyNmNlZTBlYzNhZjA3YTI1NGRlNzk1N2I0NTlhZTFjYjZlYjUx MDUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0LmNwcAorKysgYi9XZWJD b3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5jcHAKQEAgLTM1LDE5ICszNSwyNCBAQAogI2luY2x1ZGUg IkV2ZW50RXhjZXB0aW9uLmgiCiAjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUg IkV2ZW50TmFtZXMuaCIKKyNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIklEQkN1cnNvci5o IgogI2luY2x1ZGUgIklEQkRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiSURCSW5kZXguaCIKICNpbmNs dWRlICJJREJFcnJvckV2ZW50LmgiCiAjaW5jbHVkZSAiSURCT2JqZWN0U3RvcmUuaCIKKyNpbmNs dWRlICJJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgiCiAjaW5jbHVkZSAiSURCU3VjY2Vz c0V2ZW50LmgiCisjaW5jbHVkZSAiUGFnZS5oIgorI2luY2x1ZGUgIlBhZ2VHcm91cC5oIgogI2lu Y2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewog Ci1JREJSZXF1ZXN0OjpJREJSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQs IFBhc3NSZWZQdHI8SURCQW55PiBzb3VyY2UpCitJREJSZXF1ZXN0OjpJREJSZXF1ZXN0KFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8SURCQW55PiBzb3VyY2UsIGlu dCB0cmFuc2FjdGlvbklkKQogICAgIDogQWN0aXZlRE9NT2JqZWN0KGNvbnRleHQsIHRoaXMpCiAg ICAgLCBtX3NvdXJjZShzb3VyY2UpCisgICAgLCBtX3RyYW5zYWN0aW9uSWQodHJhbnNhY3Rpb25J ZCkKICAgICAsIG1fdGltZXIodGhpcywgJklEQlJlcXVlc3Q6OnRpbWVyRmlyZWQpCiAgICAgLCBt X2Fib3J0ZWQoZmFsc2UpCiAgICAgLCBtX3JlYWR5U3RhdGUoTE9BRElORykKQEAgLTEwMCw3ICsx MDUsOCBAQCB2b2lkIElEQlJlcXVlc3Q6Om9uU3VjY2VzcyhQYXNzUmVmUHRyPElEQktleT4gaWRi S2V5KQogCiB2b2lkIElEQlJlcXVlc3Q6Om9uU3VjY2VzcyhQYXNzUmVmUHRyPElEQk9iamVjdFN0 b3JlQmFja2VuZEludGVyZmFjZT4gYmFja2VuZCkKIHsKLSAgICBzY2hlZHVsZUV2ZW50KElEQkFu eTo6Y3JlYXRlKElEQk9iamVjdFN0b3JlOjpjcmVhdGUoYmFja2VuZCkpLCAwKTsKKyAgICAvLyBG SVhNRTogdGhlIHRyYW5zYWN0aW9uIGlkIHNob3VsZCBiZSB0aGUgb25lIG9mIHRoZSBzZXRWZXJz aW9uIHRyYW5zYWN0aW9uLgorICAgIHNjaGVkdWxlRXZlbnQoSURCQW55OjpjcmVhdGUoSURCT2Jq ZWN0U3RvcmU6OmNyZWF0ZShiYWNrZW5kLCAtMSkpLCAwKTsKIH0KIAogdm9pZCBJREJSZXF1ZXN0 OjpvblN1Y2Nlc3MoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHNlcmlhbGl6ZWRT Y3JpcHRWYWx1ZSkKQEAgLTE2Miw2ICsxNjgsMTMgQEAgdm9pZCBJREJSZXF1ZXN0Ojp0aW1lckZp cmVkKFRpbWVyPElEQlJlcXVlc3Q+KikKICAgICAgICAgICAgIGRpc3BhdGNoRXZlbnQoSURCU3Vj Y2Vzc0V2ZW50OjpjcmVhdGUobV9zb3VyY2UsIHBlbmRpbmdFdmVudC5tX3Jlc3VsdCkpOwogICAg ICAgICB9CiAgICAgfQorICAgIGlmIChtX3RyYW5zYWN0aW9uSWQgPiAwKSB7CisgICAgICAgIC8v IE5vdyB0aGF0IHdlIHByb2Nlc3NlZCBhbGwgcGVuZGluZyBldmVudHMsIGxldCB0aGUgdHJhbnNh Y3Rpb24gbW9uaXRvcgorICAgICAgICAvLyBjaGVjayBpZiBpdCBjYW4gY29tbWl0IHRoZSBjdXJy ZW50IHRyYW5zYWN0aW9uIG9yIGlmIHRoZXJlJ3MgYW55dGhpbmcKKyAgICAgICAgLy8gbmV3IHBl bmRpbmcuCisgICAgICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzRG9jdW1l bnQoKSk7CisgICAgICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmRpZENvbXBsZXRl RXZlbnRzRm9yVHJhbnNhY3Rpb24obV90cmFuc2FjdGlvbklkLCBzdGF0aWNfY2FzdDxEb2N1bWVu dCo+KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSktPmZyYW1lKCktPnBhZ2UoKS0+Z3JvdXAoKS5p ZGJGYWN0b3J5KCkpOworICAgIH0KIH0KIAogdm9pZCBJREJSZXF1ZXN0OjpzY2hlZHVsZUV2ZW50 KFBhc3NSZWZQdHI8SURCQW55PiByZXN1bHQsIFBhc3NSZWZQdHI8SURCRGF0YWJhc2VFcnJvcj4g ZXJyb3IpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5oIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQlJlcXVlc3QuaAppbmRleCA5YjBlYTdlYWYyMWNiZWEyM2U2YmQ0YTgwNzgx NTJkODkzMzdjN2QyLi5hOWNmMjQ4YTdjZGQwZTFiYWZkZWRkNzFlNDQyM2EyZDY3MDcyN2I0IDEw MDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5oCisrKyBiL1dlYkNvcmUvc3Rv cmFnZS9JREJSZXF1ZXN0LmgKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJFdmVudFRhcmdl dC5oIgogI2luY2x1ZGUgIklEQkFueS5oIgogI2luY2x1ZGUgIklEQkNhbGxiYWNrcy5oIgorI2lu Y2x1ZGUgIklEQlRyYW5zYWN0aW9uLmgiCiAjaW5jbHVkZSAiVGltZXIuaCIKICNpbmNsdWRlIDx3 dGYvVmVjdG9yLmg+CiAKQEAgLTQ0LDcgKzQ1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBj bGFzcyBJREJSZXF1ZXN0IDogcHVibGljIElEQkNhbGxiYWNrcywgcHVibGljIEV2ZW50VGFyZ2V0 LCBwdWJsaWMgQWN0aXZlRE9NT2JqZWN0IHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0 cjxJREJSZXF1ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFz c1JlZlB0cjxJREJBbnk+IHNvdXJjZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IElEQlJlcXVlc3Qo Y29udGV4dCwgc291cmNlKSk7IH0KKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBj cmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJBbnk+ IHNvdXJjZSwgaW50IHRyYW5zYWN0aW9uSWQgPSAwKSB7IHJldHVybiBhZG9wdFJlZihuZXcgSURC UmVxdWVzdChjb250ZXh0LCBzb3VyY2UsIHRyYW5zYWN0aW9uSWQpKTsgfQogICAgIHZpcnR1YWwg fklEQlJlcXVlc3QoKTsKIAogICAgIC8vIERlZmluZWQgaW4gdGhlIElETApAQCAtODAsNyArODEs NyBAQCBwdWJsaWM6CiAgICAgdXNpbmcgUmVmQ291bnRlZDxJREJDYWxsYmFja3M+OjpkZXJlZjsK IAogcHJpdmF0ZToKLSAgICBJREJSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNz UmVmUHRyPElEQkFueT4gc291cmNlKTsKKyAgICBJREJSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlLCBpbnQgdHJhbnNhY3Rpb25JZCk7CiAK ICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8SURCUmVxdWVzdD4qKTsKICAgICB2b2lkIHNjaGVk dWxlRXZlbnQoUGFzc1JlZlB0cjxJREJBbnk+IHJlc3VsdCwgUGFzc1JlZlB0cjxJREJEYXRhYmFz ZUVycm9yPik7CkBAIC05Miw2ICs5Myw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBFdmVudFRh cmdldERhdGEqIGVuc3VyZUV2ZW50VGFyZ2V0RGF0YSgpOwogCiAgICAgUmVmUHRyPElEQkFueT4g bV9zb3VyY2U7CisgICAgaW50IG1fdHJhbnNhY3Rpb25JZDsKIAogICAgIHN0cnVjdCBQZW5kaW5n RXZlbnQgewogICAgICAgICBSZWZQdHI8SURCQW55PiBtX3Jlc3VsdDsKZGlmZiAtLWdpdCBhL1dl YkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbi5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJh bnNhY3Rpb24uY3BwCmluZGV4IDRlOTMzNzhkZGI3YmViMmIyYjg3NTM0YmU2N2IzNzRkZDMzODQ5 NTguLjM5Yzg5NWQxZTFjNTYzOGU5YWNkMzNjZDE4MDRhODY3ZjQ0ZDY4MTYgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbi5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdl L0lEQlRyYW5zYWN0aW9uLmNwcApAQCAtNjYsNyArNjYsMTEgQEAgSURCRGF0YWJhc2UqIElEQlRy YW5zYWN0aW9uOjpkYigpCiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBJREJUcmFuc2FjdGlv bjo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBFeGNlcHRpb25Db2RlJikK IHsKICAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9y ZUJhY2tlbmQgPSBtX2JhY2tlbmQtPm9iamVjdFN0b3JlKG5hbWUpOwotICAgIFJlZlB0cjxJREJP YmplY3RTdG9yZT4gb2JqZWN0U3RvcmUgPSBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9iamVjdFN0 b3JlQmFja2VuZCk7CisgICAgaWYgKCFvYmplY3RTdG9yZUJhY2tlbmQuZ2V0KCkpIHsKKyAgICAg ICAgdGhyb3dFcnJvcihOT1RfU1VQUE9SVEVEX0VSUik7CisgICAgICAgIHJldHVybiAwOworICAg IH0KKyAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmU+IG9iamVjdFN0b3JlID0gSURCT2JqZWN0U3Rv cmU6OmNyZWF0ZShvYmplY3RTdG9yZUJhY2tlbmQsIGlkKCkpOwogICAgIHJldHVybiBvYmplY3RT dG9yZS5yZWxlYXNlKCk7CiB9CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFu c2FjdGlvbkJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJh Y2tlbmRJbXBsLmNwcAppbmRleCA1MWIzM2IyMzQwMDE0NzdmM2I2MjlkNGY1NDgyMjI4MDM0ZGM4 MWQwLi5kNWFkM2IyYWE1ZTUwNzA3ZTY0MTljNmQ3MTk4NDM0MTJjMjRlNDhiIDEwMDc1NQotLS0g YS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5jcHAKKysrIGIvV2Vi Q29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuY3BwCkBAIC0yOSw2ICsyOSw3 IEBACiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAKICNpbmNsdWRlICJJREJEYXRhYmFz ZUJhY2tlbmRJbXBsLmgiCisjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIgog I2luY2x1ZGUgIlNRTGl0ZURhdGFiYXNlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQz LDI2ICs0NCwxMTAgQEAgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6SURCVHJhbnNhY3Rpb25C YWNrZW5kSW1wbChET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMKICAgICAsIG1fbW9kZShtb2Rl KQogICAgICwgbV90aW1lb3V0KHRpbWVvdXQpCiAgICAgLCBtX2lkKGlkKQotICAgICwgbV9hYm9y dGVkKGZhbHNlKQorICAgICwgbV9zdGFydGVkKGZhbHNlKQorICAgICwgbV9maW5pc2hlZChmYWxz ZSkKICAgICAsIG1fZGF0YWJhc2UoZGF0YWJhc2UpCisgICAgLCBtX3RyYW5zYWN0aW9uKG5ldyBT UUxpdGVUcmFuc2FjdGlvbihkYXRhYmFzZS0+c3FsaXRlRGF0YWJhc2UoKSkpCisgICAgLCBtX3Rp bWVyKHRoaXMsICZJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjp0aW1lckZpcmVkKQogewogfQog CiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gSURCVHJhbnNhY3Rp b25CYWNrZW5kSW1wbDo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKQogewotICAgIHJl dHVybiBtX2RhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1lLCAwKTsgLy8gRklYTUU6IHJlbW92ZSBt b2RlIHBhcmFtLgorICAgIGlmIChtX2ZpbmlzaGVkKQorICAgICAgICByZXR1cm4gMDsKKyAgICBy ZXR1cm4gbV9kYXRhYmFzZS0+b2JqZWN0U3RvcmUobmFtZSwgMCwgdGhpcyk7IC8vIEZJWE1FOiBy ZW1vdmUgbW9kZSBwYXJhbS4KIH0KIAotdm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpz Y2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPikKK3Zv aWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6c2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2Ny aXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaykKIHsKLSAgICAvLyBGSVhNRTogaW1wbGVt ZW50LgotICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIEFTU0VSVCghbV9maW5pc2hlZCk7 CisKKyAgICBtX3Rhc2tRdWV1ZS5hcHBlbmQodGFzayk7CisKKyAgICBpZiAoIW1fc3RhcnRlZCkK KyAgICAgICAgc3RhcnQoKTsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpz dGVwKCkKK3sKKyAgICBBU1NFUlQobV9zdGFydGVkKTsKKworICAgIGlmICghbV90YXNrUXVldWUu aXNFbXB0eSgpKSB7CisgICAgICAgIHJ1bigpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgY29tbWl0KCk7CiB9CiAKIHZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6YWJvcnQo KQogewotICAgIG1fYWJvcnRlZCA9IHRydWU7CisgICAgaWYgKG1fZmluaXNoZWQpCisgICAgICAg IHJldHVybjsKKworICAgIG1fZmluaXNoZWQgPSB0cnVlOworICAgIG1fdHJhbnNhY3Rpb24tPnJv bGxiYWNrKCk7CiAgICAgbV9jYWxsYmFja3MtPm9uQWJvcnQoKTsKKworICAgIGRpZEZpbmlzaFRy YW5zYWN0aW9uKCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6cnVuKCkK K3sKKyAgICBBU1NFUlQobV9zdGFydGVkKTsKKyAgICBBU1NFUlQoIW1fZmluaXNoZWQpOworCisg ICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbDo6c3RhcnQoKQoreworICAgIEFTU0VSVCghbV9zdGFydGVkKTsKKyAgICBBU1NFUlQo IW1fZmluaXNoZWQpOworCisgICAgbV9zdGFydGVkID0gdHJ1ZTsKKyAgICBtX3RyYW5zYWN0aW9u LT5iZWdpbigpOworCisgICAgbV9kYXRhYmFzZS0+dHJhbnNhY3Rpb25Db29yZGluYXRvcigpLT5k aWRTdGFydFRyYW5zYWN0aW9uKG1faWQpOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQmFja2Vu ZEltcGw6OnJ1bk5leHRUYXNrcygpCit7CisgICAgQVNTRVJUKCFtX3Rhc2tRdWV1ZS5pc0VtcHR5 KCkpOworICAgIEFTU0VSVChtX3N0YXJ0ZWQpOworICAgIEFTU0VSVCghbV9maW5pc2hlZCk7CisK KyAgICAvLyBwdW1wIHRoZSB0YXNrIHF1ZXVlIGRyeQorICAgIFRhc2tRdWV1ZSBxdWV1ZTsKKyAg ICBxdWV1ZS5zd2FwKG1fdGFza1F1ZXVlKTsKKyAgICB3aGlsZSAoIXF1ZXVlLmlzRW1wdHkoKSkg eworICAgICAgICBPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzayhxdWV1 ZS5maXJzdCgpLnJlbGVhc2UoKSk7CisgICAgICAgIHF1ZXVlLnJlbW92ZUZpcnN0KCk7CisgICAg ICAgIHRhc2stPnBlcmZvcm1UYXNrKDApOworICAgIH0KK30KKwordm9pZCBJREJUcmFuc2FjdGlv bkJhY2tlbmRJbXBsOjpjb21taXQoKQoreworICAgIEFTU0VSVCghbV9maW5pc2hlZCk7CisgICAg QVNTRVJUKG1fc3RhcnRlZCk7CisKKyAgICBtX2ZpbmlzaGVkID0gdHJ1ZTsKKyAgICBtX3RyYW5z YWN0aW9uLT5jb21taXQoKTsKKworICAgIGRpZEZpbmlzaFRyYW5zYWN0aW9uKCk7Cit9CisKK3Zv aWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6ZGlkRmluaXNoVHJhbnNhY3Rpb24oKQorewor ICAgIG1fZGF0YWJhc2UtPnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKS0+ZGlkRmluaXNoVHJhbnNh Y3Rpb24obV9pZCk7CisgICAgbV9kYXRhYmFzZS5jbGVhcigpOworfQorCit2b2lkIElEQlRyYW5z YWN0aW9uQmFja2VuZEltcGw6OnRpbWVyRmlyZWQoVGltZXI8SURCVHJhbnNhY3Rpb25CYWNrZW5k SW1wbD4qKQoreworICAgIHJ1bk5leHRUYXNrcygpOwogfQogCiB9OwpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFn ZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmgKaW5kZXggZmI1NzQwMTdmYWJlNTI0M2ViNWQ3 YzE3YTgyYjBhMjVlNjI4ZTA4Ny4uODE0YWM2NzAzM2FlNzJhMjUzNzgyZjUyMmUzNjQ2ODdjMjE5 M2NkMSAxMDA3NTUKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZElt cGwuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oCkBA IC0zMSw2ICszMSw4IEBACiAjaW5jbHVkZSAiRE9NU3RyaW5nTGlzdC5oIgogI2luY2x1ZGUgIklE QlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oIgogI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9u Q2FsbGJhY2tzLmgiCisjaW5jbHVkZSA8U1FMaXRlVHJhbnNhY3Rpb24uaD4KKyNpbmNsdWRlIDx3 dGYvRGVxdWUuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKQEAgLTQwLDI1ICs0Miw0MSBAQCBjbGFzcyBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOwogY2xh c3MgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCA6IHB1YmxpYyBJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2UgewogcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPElEQlRyYW5zYWN0 aW9uQmFja2VuZEludGVyZmFjZT4gY3JlYXRlKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3Jlcywg dW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBpbnQgaWQsIElEQkRh dGFiYXNlQmFja2VuZEltcGwqKTsKLSAgICB2aXJ0dWFsIH5JREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsKCkgeyB9CisgICAgdmlydHVhbCB+SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCgpIHsgYWJv cnQoKTsgfQogCiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZElu dGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKTsKICAgICB2aXJ0dWFsIHVu c2lnbmVkIHNob3J0IG1vZGUoKSBjb25zdCB7IHJldHVybiBtX21vZGU7IH0KICAgICB2aXJ0dWFs IHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFz az4pOworICAgIHZpcnR1YWwgdm9pZCBzdGVwKCk7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0KCk7 CisgICAgdmlydHVhbCBib29sIGlzRmluaXNoZWQoKSB7IHJldHVybiBtX2ZpbmlzaGVkOyB9CiAg ICAgdmlydHVhbCBpbnQgaWQoKSBjb25zdCB7IHJldHVybiBtX2lkOyB9CiAgICAgdmlydHVhbCB2 b2lkIHNldENhbGxiYWNrcyhJREJUcmFuc2FjdGlvbkNhbGxiYWNrcyogY2FsbGJhY2tzKSB7IG1f Y2FsbGJhY2tzID0gY2FsbGJhY2tzOyB9CiAKKyAgICB2b2lkIHJ1bigpOworCiBwcml2YXRlOgog ICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwoRE9NU3RyaW5nTGlzdCogb2JqZWN0U3RvcmVz LCB1bnNpZ25lZCBzaG9ydCBtb2RlLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQsIGludCBpZCwgSURC RGF0YWJhc2VCYWNrZW5kSW1wbCopOwogCisgICAgdm9pZCBzdGFydCgpOworICAgIHZvaWQgcnVu TmV4dFRhc2tzKCk7CisgICAgdm9pZCBjb21taXQoKTsKKyAgICB2b2lkIGRpZEZpbmlzaFRyYW5z YWN0aW9uKCk7CisKKyAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8SURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbD4qKTsKKwogICAgIFJlZlB0cjxET01TdHJpbmdMaXN0PiBtX29iamVjdFN0b3JlTmFt ZXM7CiAgICAgdW5zaWduZWQgc2hvcnQgbV9tb2RlOwogICAgIHVuc2lnbmVkIGxvbmcgbV90aW1l b3V0OwogICAgIGludCBtX2lkOwotICAgIGJvb2wgbV9hYm9ydGVkOworICAgIGJvb2wgbV9zdGFy dGVkOworICAgIGJvb2wgbV9maW5pc2hlZDsKICAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25DYWxs YmFja3M+IG1fY2FsbGJhY2tzOwogICAgIFJlZlB0cjxJREJEYXRhYmFzZUJhY2tlbmRJbXBsPiBt X2RhdGFiYXNlOworICAgIHR5cGVkZWYgRGVxdWU8T3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+ID4gVGFza1F1ZXVlOworICAgIFRhc2tRdWV1ZSBtX3Rhc2tRdWV1ZTsKKyAgICBP d25QdHI8U1FMaXRlVHJhbnNhY3Rpb24+IG1fdHJhbnNhY3Rpb247CisgICAgVGltZXI8SURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbD4gbV90aW1lcjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2Uu aAppbmRleCAzOTY1MWYxMDE3NWRlNzA2MGQwNDVhOWYwYzYyMzkzYzZhZTM3NWRjLi5kNDY3OGVm OGZlZDg2YTgwOGViZDZhYmY5NTI1YTE1NDI2MWNiZGI2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0 b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgKKysrIGIvV2ViQ29yZS9zdG9y YWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oCkBAIC01MSw2ICs1MSw3IEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJm YWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUpID0gMDsKICAgICB2aXJ0dWFsIHVu c2lnbmVkIHNob3J0IG1vZGUoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHNjaGVkdWxl VGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KSA9IDA7CisgICAg dmlydHVhbCB2b2lkIHN0ZXAoKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0KCkgPSAwOwog ICAgIHZpcnR1YWwgaW50IGlkKCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBzZXRDYWxs YmFja3MoSURCVHJhbnNhY3Rpb25DYWxsYmFja3MqKSA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHAgYi9XZWJDb3JlL3N0b3JhZ2Uv SURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHAKaW5kZXggOTc5MGMxZjJkNzk1ZjY2MDZkNjE0 YjQwM2I0M2YzNjJmYmYxYjBlYy4uZDk2YjdkNjMzZjg0YzdhZTBhOGEyY2EwNmY0MmVkNmVjODM2 NzNmYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0 b3IuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNw cApAQCAtMzAsNiArMzAsNyBAQAogCiAjaW5jbHVkZSAiSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5o IgogI2luY2x1ZGUgIklEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZS5oIgorI2luY2x1ZGUg IklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuaCIKICNpbmNsdWRlICJJREJUcmFuc2FjdGlv bkJhY2tlbmRJbXBsLmgiCiAjaW5jbHVkZSAiU1FMaXRlRGF0YWJhc2UuaCIKICNpbmNsdWRlICJT Y3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCkBAIC00OCwyMCArNDksODEgQEAgSURCVHJhbnNhY3Rp b25Db29yZGluYXRvcjo6fklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKQogUGFzc1JlZlB0cjxJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6 OmNyZWF0ZVRyYW5zYWN0aW9uKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3JlcywgdW5zaWduZWQg c2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBJREJEYXRhYmFzZUJhY2tlbmRJbXBs KiBkYXRhYmFzZSkKIHsKICAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNl PiB0cmFuc2FjdGlvbiA9IElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OmNyZWF0ZShvYmplY3RT dG9yZXMsIG1vZGUsIHRpbWVvdXQsICsrbV9uZXh0SUQsIGRhdGFiYXNlKTsKLSAgICBtX3RyYW5z YWN0aW9uUXVldWUuYWRkKHRyYW5zYWN0aW9uLmdldCgpKTsKLSAgICBtX2lkTWFwLmFkZChtX25l eHRJRCwgdHJhbnNhY3Rpb24pOworICAgIG1fcGVuZGluZ1RyYW5zYWN0aW9ucy5hZGQobV9uZXh0 SUQsIHRyYW5zYWN0aW9uKTsKICAgICByZXR1cm4gdHJhbnNhY3Rpb24ucmVsZWFzZSgpOwogfQog Ci12b2lkIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmFib3J0KGludCBpZCkKK3ZvaWQgSURC VHJhbnNhY3Rpb25Db29yZGluYXRvcjo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFZl Y3RvcjxpbnQ+JiBwZW5kaW5nSURzKQogewotICAgIEFTU0VSVChtX2lkTWFwLmNvbnRhaW5zKGlk KSk7Ci0gICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNhY3Rp b24gPSBtX2lkTWFwLmdldChpZCk7CisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBwZW5kaW5n SURzLnNpemUoKTsgKytpKSB7CisgICAgICAgIGludCBpZCA9IHBlbmRpbmdJRHMuYXQoaSk7Cisg ICAgICAgIEFTU0VSVChtX3BlbmRpbmdUcmFuc2FjdGlvbnMuY29udGFpbnMoaWQpKTsKKyAgICAg ICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNhY3Rpb24gPSBt X3BlbmRpbmdUcmFuc2FjdGlvbnMuZ2V0KGlkKTsKKyAgICAgICAgQVNTRVJUKHRyYW5zYWN0aW9u KTsKKyAgICAgICAgdHJhbnNhY3Rpb24tPmFib3J0KCk7CisgICAgfQorfQorCit2b2lkIElEQlRy YW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24oaW50 IHRyYW5zYWN0aW9uSUQpCit7CisgICAgaWYgKG1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250YWlu cyh0cmFuc2FjdGlvbklEKSkgeworICAgICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZElu dGVyZmFjZT4gdHJhbnNhY3Rpb24gPSBtX3J1bm5pbmdUcmFuc2FjdGlvbnMuZ2V0KHRyYW5zYWN0 aW9uSUQpOworICAgICAgQVNTRVJUKHRyYW5zYWN0aW9uKTsKKyAgICAgIHRyYW5zYWN0aW9uLT5z dGVwKCk7CisgICAgfQorfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZFN0 YXJ0VHJhbnNhY3Rpb24oaW50IGlkKQoreworICAgIC8vIFJlbW92ZSBmcm9tIHBlbmRpbmcgdHJh bnNhY3Rpb25zIGxpc3QKKyAgICBBU1NFUlQobV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5z KGlkKSk7CisgICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNh Y3Rpb24gPSBtX3BlbmRpbmdUcmFuc2FjdGlvbnMuZ2V0KGlkKTsKICAgICBBU1NFUlQodHJhbnNh Y3Rpb24pOwotICAgIG1fdHJhbnNhY3Rpb25RdWV1ZS5yZW1vdmUodHJhbnNhY3Rpb24uZ2V0KCkp OwotICAgIG1faWRNYXAucmVtb3ZlKGlkKTsKLSAgICB0cmFuc2FjdGlvbi0+YWJvcnQoKTsKLSAg ICAvLyBGSVhNRTogdGhpcyB3aWxsIGNoYW5nZSBvbmNlIHdlIGhhdmUgdHJhbnNhY3Rpb25zIGFj dHVhbGx5IHJ1bm5pbmcuCisgICAgbV9wZW5kaW5nVHJhbnNhY3Rpb25zLnJlbW92ZShpZCk7Cisg ICAgLy8gQWRkIHRvIHN0YXJ0ZWQgdHJhbnNhY3Rpb25zIGxpc3QKKyAgICBtX3N0YXJ0ZWRUcmFu c2FjdGlvblF1ZXVlLmFkZCh0cmFuc2FjdGlvbi5nZXQoKSk7CisgICAgbV9zdGFydGVkVHJhbnNh Y3Rpb25zLmFkZChpZCwgdHJhbnNhY3Rpb24ucmVsZWFzZSgpKTsKKworICAgIHByb2Nlc3NTdGFy dGVkVHJhbnNhY3Rpb25zKCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6 ZGlkRmluaXNoVHJhbnNhY3Rpb24oaW50IGlkKQoreworICAgIGlmIChtX3BlbmRpbmdUcmFuc2Fj dGlvbnMuY29udGFpbnMoaWQpKSB7CisgICAgICAgIEFTU0VSVCghbV9zdGFydGVkVHJhbnNhY3Rp b25zLmNvbnRhaW5zKGlkKSk7CisgICAgICAgIEFTU0VSVCghbV9ydW5uaW5nVHJhbnNhY3Rpb25z LmNvbnRhaW5zKGlkKSk7CisgICAgICAgIG1fcGVuZGluZ1RyYW5zYWN0aW9ucy5yZW1vdmUoaWQp OworICAgIH0gZWxzZSBpZiAobV9zdGFydGVkVHJhbnNhY3Rpb25zLmNvbnRhaW5zKGlkKSkgewor ICAgICAgICBBU1NFUlQoIW1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpOworICAg ICAgICBtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMucmVtb3ZlKGlkKTsKKyAgICB9IGVsc2UgeworICAg ICAgICBBU1NFUlQobV9ydW5uaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKGlkKSk7CisgICAgICAg IG1fcnVubmluZ1RyYW5zYWN0aW9ucy5yZW1vdmUoaWQpOworICAgIH0KKworICAgIHByb2Nlc3NT dGFydGVkVHJhbnNhY3Rpb25zKCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRv cjo6cHJvY2Vzc1N0YXJ0ZWRUcmFuc2FjdGlvbnMoKQoreworICAgIC8vIEZJWE1FOiB0aGlzIHdv dWxkIGFsbG9jYXRlIGEgdGhyZWFkIHRvIHRoZSBuZXh0IHRyYW5zYWN0aW9uCisgICAgLy8gdGhh dCdzIHJlYWR5IHRvIHJ1bi4gRm9yIG5vdyB3ZSBvbmx5IGhhdmUgYSBzaW5nbGUgcnVubmluZwor ICAgIC8vIHRyYW5zYWN0aW9uLgorICAgIGlmIChtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuaXNFbXB0 eSgpKQorICAgICAgICByZXR1cm47CisgICAgaWYgKCFtX3J1bm5pbmdUcmFuc2FjdGlvbnMuaXNF bXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBSZW1vdmUgZnJvbSBzdGFydGVkIHRy YW5zYWN0aW9ucyBsaXN0LgorICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJh bnNhY3Rpb25QdHIgPSAqKG1fc3RhcnRlZFRyYW5zYWN0aW9uUXVldWUuYmVnaW4oKSk7CisgICAg bV9zdGFydGVkVHJhbnNhY3Rpb25RdWV1ZS5yZW1vdmUodHJhbnNhY3Rpb25QdHIpOworICAgIFJl ZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uID0gbV9zdGFy dGVkVHJhbnNhY3Rpb25zLmdldCh0cmFuc2FjdGlvblB0ci0+aWQoKSk7CisgICAgbV9zdGFydGVk VHJhbnNhY3Rpb25zLnJlbW92ZSh0cmFuc2FjdGlvbi0+aWQoKSk7CisgICAgLy8gQWRkIHRvIHJ1 bm5pbmcgdHJhbnNhY3Rpb25zIGxpc3QuCisgICAgbV9ydW5uaW5nVHJhbnNhY3Rpb25zLmFkZCh0 cmFuc2FjdGlvbi0+aWQoKSwgdHJhbnNhY3Rpb24pOworCisgICAgLy8gRklYTUU6IGlzIHRoZXJl IGEgYmV0dGVyIHdheSB0aGFuIGNhc3Rpbmc/CisgICAgc3RhdGljX2Nhc3Q8SURCVHJhbnNhY3Rp b25CYWNrZW5kSW1wbCo+KHRyYW5zYWN0aW9uUHRyKS0+cnVuKCk7CiB9CiAKIH07CmRpZmYgLS1n aXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaAppbmRleCAxMDRhOTU2NmNlY2Vk YzMyYWU2YzA1MmFjNzc3NzU0YTYyMTE4MjNkLi41MGI2N2RjZmU3ODZmNDBiY2UyMGUyMWMzODBj NDcyNmM4ZjRiZWM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25D b29yZGluYXRvci5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5h dG9yLmgKQEAgLTU1LDE0ICs1NSwyMyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB+SURCVHJhbnNh Y3Rpb25Db29yZGluYXRvcigpOwogCiAgICAgUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2U+IGNyZWF0ZVRyYW5zYWN0aW9uKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3Jl cywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBJREJEYXRhYmFz ZUJhY2tlbmRJbXBsKik7Ci0gICAgdm9pZCBhYm9ydChpbnQgdHJhbnNhY3Rpb25JZCk7CisgICAg dm9pZCBhYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIHBlbmRpbmdJ RHMpOworICAgIHZvaWQgZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgdHJhbnNh Y3Rpb25JRCk7CisKKyAgICAvLyBDYWxsZWQgYnkgdHJhbnNhY3Rpb25zIGFzIHRoZXkgc3RhcnQg YW5kIGZpbmlzaC4KKyAgICB2b2lkIGRpZFN0YXJ0VHJhbnNhY3Rpb24oaW50IGlkKTsKKyAgICB2 b2lkIGRpZEZpbmlzaFRyYW5zYWN0aW9uKGludCBpZCk7CiAKIHByaXZhdGU6CiAgICAgSURCVHJh bnNhY3Rpb25Db29yZGluYXRvcigpOwogCi0gICAgTGlzdEhhc2hTZXQ8SURCVHJhbnNhY3Rpb25C YWNrZW5kSW50ZXJmYWNlKj4gbV90cmFuc2FjdGlvblF1ZXVlOworICAgIHZvaWQgcHJvY2Vzc1N0 YXJ0ZWRUcmFuc2FjdGlvbnMoKTsKKworICAgIExpc3RIYXNoU2V0PElEQlRyYW5zYWN0aW9uQmFj a2VuZEludGVyZmFjZSo+IG1fc3RhcnRlZFRyYW5zYWN0aW9uUXVldWU7CiAgICAgdHlwZWRlZiBI YXNoTWFwPGludCwgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gPiBJZFRv VHJhbnNhY3Rpb25NYXA7Ci0gICAgSWRUb1RyYW5zYWN0aW9uTWFwIG1faWRNYXA7CisgICAgSWRU b1RyYW5zYWN0aW9uTWFwIG1fcGVuZGluZ1RyYW5zYWN0aW9uczsKKyAgICBJZFRvVHJhbnNhY3Rp b25NYXAgbV9zdGFydGVkVHJhbnNhY3Rpb25zOworICAgIElkVG9UcmFuc2FjdGlvbk1hcCBtX3J1 bm5pbmdUcmFuc2FjdGlvbnM7CiAgICAgaW50IG1fbmV4dElEOwogfTsKIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5k ZXggNTZhMjUzZTVkY2FkMjBhMmEzYTMyMDNkOTcxODNhYTU0OWFjNDYzNC4uZDg4MjYxYTI5Y2Rm NTdkNzVhNDUzZGQ2ZWFjMmQ4N2UxZjY3NWZhNSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMg QEAKKzIwMTAtMDktMDggIE1hcmN1cyBCdWxhY2ggIDxidWxhY2hAY2hyb21pdW0ub3JnPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElEQk9iamVjdFN0 b3JlOjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAgICAgICBPcmlnaW5hbCBw YXRjaCBieSBBbmRyZWkgUG9wZXNjdSAgPGFuZHJlaXBAZ29vZ2xlLmNvbT4KKworICAgICAgICBU ZXN0OiBzdG9yYWdlL2luZGV4ZWRkYi90cmFuc2FjdGlvbi1nZXQuaHRtbAorCisgICAgICAgICog cHVibGljL1dlYklEQkZhY3RvcnkuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViSURCRmFjdG9yeTo6 ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbik6CisgICAgICAgICogc3JjL0lEQkRhdGFi YXNlUHJveHkuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJhc2VQcm94eTo6b2JqZWN0 U3RvcmUpOgorICAgICAgICAqIHNyYy9JREJEYXRhYmFzZVByb3h5Lmg6CisgICAgICAgICogc3Jj L0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRmFjdG9y eUJhY2tlbmRQcm94eTo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKToKKyAgICAgICAgKFdlYkNv cmU6OklEQkZhY3RvcnlCYWNrZW5kUHJveHk6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rp b24pOgorICAgICAgICAqIHNyYy9JREJGYWN0b3J5QmFja2VuZFByb3h5Lmg6CisgICAgICAgICog c3JjL0lEQk9iamVjdFN0b3JlUHJveHkuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0 U3RvcmVQcm94eTo6c2V0VHJhbnNhY3Rpb24pOgorICAgICAgICAqIHNyYy9JREJPYmplY3RTdG9y ZVByb3h5Lmg6CisgICAgICAgICogc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5OjpzdGVwKToKKyAg ICAgICAgKiBzcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaDoKKyAgICAgICAgKiBzcmMv V2ViSURCRmFjdG9yeUltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJJREJGYWN0b3J5SW1w bDo6ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbik6CisgICAgICAgICogc3JjL1dlYklE QkZhY3RvcnlJbXBsLmg6CisKIDIwMTAtMDktMDcgIFBhdmVsIFBvZGl2aWxvdiAgPHBvZGl2aWxv dkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4K ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCRmFjdG9yeS5oIGIvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJGYWN0b3J5LmgKaW5kZXggN2MwNzBhMmZiZWEyNjM2 NzA5NjllMjQyZjdlOTg0NWM1MjM2Zjk0Ny4uMTk5YjE5ZmUxMjU2NDY3NjJlZjcxN2E1OWY0YjVj MmM1ZTE1YmQwNCAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJGYWN0 b3J5LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJGYWN0b3J5LmgKQEAgLTY1 LDYgKzY1LDcgQEAgcHVibGljOgogICAgIH0KIAogICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRp bmdUcmFuc2FjdGlvbnMoY29uc3QgV2ViVmVjdG9yPGludD4mIHBlbmRpbmdJRHMpIHsgV0VCS0lU X0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisgICAgdmlydHVhbCB2b2lkIGRpZENvbXBsZXRlRXZl bnRzRm9yVHJhbnNhY3Rpb24oaW50IGN1cnJlbnRJRCkgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFD SEVEKCk7IH0KIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv SURCRGF0YWJhc2VQcm94eS5jcHAKaW5kZXggY2U1ZTBhNmNjZmQzMjBiYmU2MzdlM2RmN2JhYzI3 OWE4YmZiMzhkNi4uOTU0ZTdkOTBkNzMzMzNiZDg2NWQ4NzNhMzdkNjg0OGJjOWJmYTI2OCAxMDA2 NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmNwcAorKysgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuY3BwCkBAIC04MSw3ICs4MSw3IEBA IHZvaWQgSURCRGF0YWJhc2VQcm94eTo6Y3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBTdHJpbmcmIGtleVBhCiAgICAgbV93ZWJJREJEYXRhYmFzZS0+Y3JlYXRlT2Jq ZWN0U3RvcmUobmFtZSwga2V5UGF0aCwgYXV0b0luY3JlbWVudCwgbmV3IFdlYklEQkNhbGxiYWNr c0ltcGwoY2FsbGJhY2tzKSk7CiB9CiAKLVBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5k SW50ZXJmYWNlPiBJREJEYXRhYmFzZVByb3h5OjpvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5h bWUsIHVuc2lnbmVkIHNob3J0IG1vZGUpCitQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2Vu ZEludGVyZmFjZT4gSURCRGF0YWJhc2VQcm94eTo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBu YW1lLCB1bnNpZ25lZCBzaG9ydCBtb2RlLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2Uq KQogewogICAgIFdlYktpdDo6V2ViSURCT2JqZWN0U3RvcmUqIG9iamVjdFN0b3JlID0gbV93ZWJJ REJEYXRhYmFzZS0+b2JqZWN0U3RvcmUobmFtZSwgbW9kZSk7CiAgICAgaWYgKCFvYmplY3RTdG9y ZSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJhc2VQcm94eS5oIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmgKaW5kZXggNDJhN2Q3ZWM1NmEy NjI4MjE4MGQ3NmM4M2YyMzZkMTg3ZmU0NDc3Yy4uMjQ3MWI4Zjg5YmU2OGY2N2ZlNTI2NjlkNWI0 YjRlY2UwNDU4NTg5ZCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFz ZVByb3h5LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmgKQEAg LTQ3LDEwICs0NywxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTdHJpbmcgdmVyc2lvbigpIGNv bnN0OwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBvYmplY3RTdG9yZXMo KSBjb25zdDsKIAotICAgIC8vIEZJWE1FOiBBZGQgdHJhbnNhY3Rpb24gYW5kIHNldFZlcnNpb24u CisgICAgLy8gRklYTUU6IEFkZCBzZXRWZXJzaW9uLgogCiAgICAgdmlydHVhbCB2b2lkIGNyZWF0 ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBrZXlQYXRoLCBi b29sIGF1dG9JbmNyZW1lbnQsIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7Ci0gICAgdmlydHVh bCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUo Y29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBzaG9ydCBtb2RlKTsKKyAgICB2aXJ0dWFsIFBh c3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25z dCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUsIElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZSogdHJhbnNhY3Rpb24gPSAwKTsKICAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlT2Jq ZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwog ICAgIHZpcnR1YWwgdm9pZCBzZXRWZXJzaW9uKGNvbnN0IFN0cmluZyYgdmVyc2lvbiwgUGFzc1Jl ZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCVHJhbnNhY3Rp b25CYWNrZW5kSW50ZXJmYWNlPiB0cmFuc2FjdGlvbihET01TdHJpbmdMaXN0KiBzdG9yZU5hbWVz LCB1bnNpZ25lZCBzaG9ydCBtb2RlLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQpOwpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJGYWN0b3J5QmFja2VuZFByb3h5LmNwcCBiL1dlYktp dC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5jcHAKaW5kZXggMTE0ZTdlMTNm YWRjNmY5NjYwZTU5ZGNiZjEwMWI0ZTVkMGM5YzhkMC4uMzZjOGFmYmU4YTNkZDk3NjRiMWEyNjc3 ZTEzMTZjYTcwNzIxNzRiYiAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJGYWN0 b3J5QmFja2VuZFByb3h5LmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlC YWNrZW5kUHJveHkuY3BwCkBAIC02OSwxMCArNjksMTQgQEAgdm9pZCBJREJGYWN0b3J5QmFja2Vu ZFByb3h5OjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIHBlbmRp bmcKIHsKICAgICBBU1NFUlQocGVuZGluZ0lEcy5zaXplKCkpOwogICAgIFdlYktpdDo6V2ViVmVj dG9yPGludD4gaWRzID0gcGVuZGluZ0lEczsKLQogICAgIG1fd2ViSURCRmFjdG9yeS0+YWJvcnRQ ZW5kaW5nVHJhbnNhY3Rpb25zKGlkcyk7CiB9CiAKK3ZvaWQgSURCRmFjdG9yeUJhY2tlbmRQcm94 eTo6ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgdHJhbnNhY3Rpb25JRCkKK3sK KyAgICBtX3dlYklEQkZhY3RvcnktPmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24odHJh bnNhY3Rpb25JRCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVO QUJMRShJTkRFWEVEX0RBVEFCQVNFKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9J REJGYWN0b3J5QmFja2VuZFByb3h5LmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlC YWNrZW5kUHJveHkuaAppbmRleCA5ZWZjN2FmNWJhMDk1Mzc3MzBlMzE2MDA0MjI5OGE3NjhkOGZk NzdjLi5iYTM5ZTU5MWE1YTQ5OWVmNGJlMGYwODdhNzdmMDA2ZjUxODQwYjMxIDEwMDc1NQotLS0g YS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaApAQCAtNDcsNiArNDcsNyBA QCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBkYXRhYmFzZXModm9pZCkg Y29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIG9wZW4oY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBT dHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4sIFBhc3NSZWZQdHI8 U2VjdXJpdHlPcmlnaW4+LCBGcmFtZSopOwogICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRpbmdU cmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIHBlbmRpbmdJRHMpOworICAgIHZpcnR1YWwg dm9pZCBkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKGludCB0cmFuc2FjdGlvbklEKTsK IAogcHJpdmF0ZToKICAgICBJREJGYWN0b3J5QmFja2VuZFByb3h5KCk7CmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuY3BwIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmNwcAppbmRleCBhZDI3ZmEzNDFjNWJjN2M4OWM3 ZDA4YTI3YjU1ZDE4MzI4ZGYyYjAyLi43OTQyZTM5YzIyMTI5ZDVjNzJlMzRjMDFmYzA2Mzk3NzZm NWY2MDMzIDEwMDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJv eHkuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5jcHAK QEAgLTEwOCw2ICsxMDgsMTEgQEAgdm9pZCBJREJPYmplY3RTdG9yZVByb3h5OjpvcGVuQ3Vyc29y KFBhc3NSZWZQdHI8SURCS2V5UmFuZ2U+IHJhbmdlLCB1bnNpZ25lZCBzaG8KICAgICBtX3dlYklE Qk9iamVjdFN0b3JlLT5vcGVuQ3Vyc29yKHJhbmdlLCBkaXJlY3Rpb24sIG5ldyBXZWJJREJDYWxs YmFja3NJbXBsKGNhbGxiYWNrcykpOwogfQogCit2b2lkIElEQk9iamVjdFN0b3JlUHJveHk6OnNl dFRyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSopCit7CisgICAgQVNT RVJUX05PVF9SRUFDSEVEKCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlm IC8vIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVj dFN0b3JlUHJveHkuaAppbmRleCBhMzM0NTcyYjZmMzZjMWUwMDQ4MmMwNGQwYTA3YjY1YWFiZjU5 OWExLi4zNmFjNTg4ZmFlNjlmNjBiYzU1NWM3Zjk3NWExYmE4MTAxNzRlN2Q4IDEwMDc1NQotLS0g YS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuaAorKysgYi9XZWJLaXQv Y2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuaApAQCAtNTUsNiArNTUsNyBAQCBwdWJs aWM6CiAgICAgdm9pZCByZW1vdmVJbmRleChjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NSZWZQdHI8 SURCQ2FsbGJhY2tzPik7CiAKICAgICB2aXJ0dWFsIHZvaWQgb3BlbkN1cnNvcihQYXNzUmVmUHRy PElEQktleVJhbmdlPiByYW5nZSwgdW5zaWduZWQgc2hvcnQgZGlyZWN0aW9uLCBQYXNzUmVmUHRy PElEQkNhbGxiYWNrcz4pOworICAgIHZpcnR1YWwgdm9pZCBzZXRUcmFuc2FjdGlvbihJREJUcmFu c2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqKTsKIAogcHJpdmF0ZToKICAgICBJREJPYmplY3RTdG9y ZVByb3h5KFBhc3NPd25QdHI8V2ViS2l0OjpXZWJJREJPYmplY3RTdG9yZT4pOwpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5jcHAgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcAppbmRleCBi ZTZiMDU4ZTUyZTI0Mjc1ODM0ODcwOWRiMDAxY2QwNDFjNTY5NmU4Li45NmEzMDBjMGI0OWNlODU5 ZjIwNjQ1MDc4MmVjMmIwZDIwYjkzOWJlIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3Jj L0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcApAQCAtNzYsNiArNzYsMTMgQEAgdm9pZCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6c2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0 RXhlY3V0aW9uQ29udGV4dDoKICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKIH0KIAordm9pZCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6c3RlcCgpCit7CisgICAgLy8gRklYTUU6IGltcGxl bWVudAorICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQorCisKIGludCBJREJUcmFuc2FjdGlv bkJhY2tlbmRQcm94eTo6aWQoKSBjb25zdAogewogICAgIHJldHVybiBtX3dlYklEQlRyYW5zYWN0 aW9uLT5pZCgpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlv bkJhY2tlbmRQcm94eS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tl bmRQcm94eS5oCmluZGV4IGQ2MmI4ZmY3Yjg0MWEyYTNmOTJhMmM2N2E3MDBkZTYzODM1ZmUzMDIu LjFhM2Q3MTM5YTRmODBjYmJkM2VlZTEzN2RlZGMyMWJmNzVlZGMyOTMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmgKQEAgLTQ2LDYgKzQ2 LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdW5zaWduZWQgc2hvcnQgbW9kZSgpIGNvbnN0Owog ICAgIHZpcnR1YWwgdm9pZCBhYm9ydCgpOwogICAgIHZpcnR1YWwgdm9pZCBzY2hlZHVsZVRhc2so UGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7CisgICAgdmlydHVhbCB2 b2lkIHN0ZXAoKTsKICAgICB2aXJ0dWFsIGludCBpZCgpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9p ZCBzZXRDYWxsYmFja3MoSURCVHJhbnNhY3Rpb25DYWxsYmFja3MqKTsKIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJGYWN0b3J5SW1wbC5jcHAgYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmNwcAppbmRleCA1NjRiZTM2NDljNzYwNzMyOWUwNWI0 NjY4YWFlZTJhZjNiMjhhZTgxLi5iMDgxM2MzNGMxZWM5NjU1MGQ0MTRiZmYyMGFkZGFmMDEzYjdk OTQ1IDEwMDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmNw cAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmNwcApAQCAtNzIs NiArNzIsMTEgQEAgdm9pZCBXZWJJREJGYWN0b3J5SW1wbDo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rp b25zKGNvbnN0IFdlYlZlY3RvcjxpbnQ+JiBwZW5kaW5nSUQKICAgICBtX2lkYkZhY3RvcnlCYWNr ZW5kLT5hYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoaWRzKTsKIH0KIAordm9pZCBXZWJJREJGYWN0 b3J5SW1wbDo6ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgdHJhbnNhY3Rpb25J RCkKK3sKKyAgICBtX2lkYkZhY3RvcnlCYWNrZW5kLT5kaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5z YWN0aW9uKHRyYW5zYWN0aW9uSUQpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKIAogI2Vu ZGlmIC8vIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJJREJGYWN0b3J5SW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJG YWN0b3J5SW1wbC5oCmluZGV4IGFlYWI0Nzg3OGEyZDkyMDNiMDZmZTIxZGM1MzNjMTY0N2NmY2E3 MTIuLjU5MDZhNDcyYzFlMGQ0Nzk1NzFmNzczMGY4ZGVjYjU1ZThmZmRmZWEgMTAwNzU1Ci0tLSBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuaAorKysgYi9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmgKQEAgLTQ0LDYgKzQ0LDcgQEAgcHVibGljOgog CiAgICAgdmlydHVhbCB2b2lkIG9wZW4oY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHJpbmcmIGRlc2NyaXB0aW9uLCBXZWJJREJDYWxsYmFja3MqLCBjb25zdCBXZWJTZWN1cml0eU9y aWdpbiYsIFdlYkZyYW1lKik7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0 aW9ucyhjb25zdCBXZWJWZWN0b3I8aW50PiYgcGVuZGluZ0lEcyk7CisgICAgdmlydHVhbCB2b2lk IGRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24oaW50IHRyYW5zYWN0aW9uSUQpOwogCiBw cml2YXRlOgogICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OklEQkZhY3RvcnlCYWNrZW5kSW50ZXJm YWNlPiBtX2lkYkZhY3RvcnlCYWNrZW5kOwo= 68067 2010-09-20 03:51:44 -0700 2010-09-20 17:26:38 -0700 Patch bug-44700-20100920115141.patch text/plain 69372 andreip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0NDUzMDIzMWFkZWQwOTMzMDgwNzQ5Nzc0MzNhZjhjMGM0Y2RiYjJlLi4wY2FlYzk0 OTZjY2VmNzBjNzEyNjkyYmY5ZDk1N2UwYTdmZDZlYzk1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAK KzIwMTAtMDktMjAgIEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBnb29nbGUuY29tPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElEQk9iamVjdFN0b3Jl OjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAgICAgICAqIHN0b3JhZ2UvaW5k ZXhlZGRiL29iamVjdHN0b3JlLWJhc2ljcy1leHBlY3RlZC50eHQ6CisgICAgICAgICogc3RvcmFn ZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLmh0bWw6CisgICAgICAgICogc3RvcmFnZS9p bmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0OgorICAg ICAgICAqIHN0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0 bWw6CisgICAgICAgICogc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0LWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0 Lmh0bWw6IEFkZGVkLgorCiAyMDEwLTA5LTIwICBKYW1lcyBLb3ppYW5za2kgIDxrb3pAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE9qYW4gVmFmYWkuCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLWV4 cGVjdGVkLnR4dAppbmRleCA4OTBjMDBmYTcwYTY1YzhjZWIzZTRhNTA1ZGU0NTY4ZDhhYTVjOGU5 Li44MjFlOTY2YjQzOWU1NDUyOWVjMWUxYzU0YThlOWI1NWMxNmQzOTVjIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MtZXhwZWN0ZWQu dHh0CisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLWJhc2lj cy1leHBlY3RlZC50eHQKQEAgLTExMyw3ICsxMTMsOCBAQCBQQVNTICdyZWFkeVN0YXRlJyBpbiBl dmVudC50YXJnZXQgaXMgdHJ1ZQogUEFTUyBldmVudC50YXJnZXQucmVhZHlTdGF0ZSBpcyBldmVu dC50YXJnZXQuRE9ORQogCiBQQVNTIGV2ZW50LmNvZGUgaXMgSURCRGF0YWJhc2VFeGNlcHRpb24u VU5LTk9XTl9FUlIKLXN0b3JlID0gZXZlbnQuc291cmNlCitkYi50cmFuc2FjdGlvbigpCitzdG9y ZSA9IHRyYW5zYWN0aW9uLm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKQogc3RvcmUuZ2V0KCdrZXkn KQogUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQogUEFTUyAnb25lcnJvcicgaW4g cmVzdWx0IGlzIHRydWUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRi L29iamVjdHN0b3JlLWJhc2ljcy5odG1sIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIv b2JqZWN0c3RvcmUtYmFzaWNzLmh0bWwKaW5kZXggNzMxZDQyMThjMjI1MDk0YjRlZGE4ZjNjNzY2 Y2MyNTQwNzE5NWYzNS4uZjkwNDcxNDdhOWQ0Y2QxN2ZjYjIwODNlMGU5NTU2NDU2M2VhOTVjMCAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFz aWNzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUt YmFzaWNzLmh0bWwKQEAgLTg3LDYgKzg3LDEwIEBAIGZ1bmN0aW9uIGFkZEFnYWluRmFpbHVyZSgp CiAgICAgc2hvdWxkQmUoImV2ZW50LmNvZGUiLCAiSURCRGF0YWJhc2VFeGNlcHRpb24uVU5LTk9X Tl9FUlIiKTsKICAgICB2YXIgc3RvcmUgPSBldmFsQW5kTG9nKCJzdG9yZSA9IGV2ZW50LnNvdXJj ZSIpOwogCisgICAgdHJhbnNhY3Rpb24gPSBldmFsQW5kTG9nKCJkYi50cmFuc2FjdGlvbigpIik7 CisgICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9IHVuZXhwZWN0ZWRFcnJvckNhbGxiYWNrOworICAg IHZhciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUo J3N0b3JlTmFtZScpIik7CisKICAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJzdG9yZS5nZXQoJ2tl eScpIik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CiAgICAgcmVzdWx0Lm9uc3VjY2VzcyA9 IGdldFN1Y2Nlc3M7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9v YmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9z dG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50 eHQKaW5kZXggMGEzZDkzODZjNWIxYjY0M2EwZDgxNjllOGJkZjZlNjgyNTVmZjM5MS4uNjQ0YTA0 OGI0MDBiMzhhODJiOGFjYTYyZTk0Nzk4NGZmOWMyNTFmMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVz dHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0 ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJl bW92ZW9iamVjdHN0b3JlLWV4cGVjdGVkLnR4dApAQCAtNjEsNyArNjEsOSBAQCBQQVNTICdhYm9y dCcgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKIFBBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRh cmdldCBpcyB0cnVlCiBQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdl dC5ET05FCiAKLWV2ZW50LnNvdXJjZS5nZXQoJ2tleScpCitkYi50cmFuc2FjdGlvbigpDQorc3Rv cmUgPSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykNCitzdG9yZS5nZXQoJ2tl eScpCiBQQVNTICdvbnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCiBQQVNTICdvbmVycm9yJyBp biByZXN1bHQgaXMgdHJ1ZQogUEFTUyAnYWJvcnQnIGluIHJlc3VsdCBpcyB0cnVlCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmpl Y3RzdG9yZS5odG1sIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUt cmVtb3Zlb2JqZWN0c3RvcmUuaHRtbAppbmRleCBlODQyZjViZmJmOGVlMTE3ZjBkNmYzYzBjMGNh ODRlYzQ3YWU0OGM2Li40N2YxNWNmNDRkYWNmNDQ3NTgxZTI2MzkwYjI2MTQ3ZDY4OWNkZjQzIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1v dmVvYmplY3RzdG9yZS5odG1sCisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29i amVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0bWwKQEAgLTQ3LDkgKzQ3LDEzIEBAIGZ1bmN0 aW9uIGFkZFZhbHVlKCkKIAogZnVuY3Rpb24gZ2V0VmFsdWUoKQogewotICAgIHZlcmlmeVN1Y2Nl c3NFdmVudChldmVudCk7CisgICAgdmVyaWZ5U3VjY2Vzc0V2ZW50KGV2ZW50KTsNCiAKLSAgICBy ZXN1bHQgPSBldmFsQW5kTG9nKCJldmVudC5zb3VyY2UuZ2V0KCdrZXknKSIpOworICAgIHRyYW5z YWN0aW9uID0gZXZhbEFuZExvZygiZGIudHJhbnNhY3Rpb24oKSIpOw0KKyAgICB0cmFuc2FjdGlv bi5vbmFib3J0ID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7DQorICAgIHZhciBzdG9yZSA9IGV2 YWxBbmRMb2coInN0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7 DQorDQorICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coInN0b3JlLmdldCgna2V5JykiKTsKICAgICB2 ZXJpZnlSZXN1bHQocmVzdWx0KTsKICAgICByZXN1bHQub25zdWNjZXNzID0gYWRkSW5kZXg7CiAg ICAgcmVzdWx0Lm9uZXJyb3IgPSB1bmV4cGVjdGVkRXJyb3JDYWxsYmFjazsKQEAgLTYyLDE1ICs2 NiwyMCBAQCBmdW5jdGlvbiBhZGRJbmRleCgpCiAKICAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJl dmVudC5zb3VyY2UuY3JlYXRlSW5kZXgoJ2luZGV4TmFtZScsICcnKSIpOwogICAgIHZlcmlmeVJl c3VsdChyZXN1bHQpOwotICAgIHJlc3VsdC5vbnN1Y2Nlc3MgPSByZW1vdmVPYmplY3RTdG9yZTsK KyAgICByZXN1bHQub25zdWNjZXNzID0gaW5kZXhBZGRlZDsKICAgICByZXN1bHQub25lcnJvciA9 IHVuZXhwZWN0ZWRFcnJvckNhbGxiYWNrOwogfQogCi1mdW5jdGlvbiByZW1vdmVPYmplY3RTdG9y ZSgpCitmdW5jdGlvbiBpbmRleEFkZGVkKCkKIHsKICAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZl bnQpOwogICAgIHNob3VsZEJlVHJ1ZSgiZXZlbnQuc291cmNlLmluZGV4TmFtZXMuY29udGFpbnMo J2luZGV4TmFtZScpIik7CisgICAgLy8gTGV0IHRoZSB0cmFuc2FjdGlvbiBjb21taXQuDQorICAg IHdpbmRvdy5zZXRUaW1lb3V0KCdyZW1vdmVPYmplY3RTdG9yZSgpJywgMCk7Cit9CiAKK2Z1bmN0 aW9uIHJlbW92ZU9iamVjdFN0b3JlKCkKK3sKICAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJkYi5y ZW1vdmVPYmplY3RTdG9yZSgnc3RvcmVOYW1lJykiKTsKICAgICB2ZXJpZnlSZXN1bHQocmVzdWx0 KTsKICAgICByZXN1bHQub25zdWNjZXNzID0gY3JlYXRlT2JqZWN0U3RvcmVBZ2FpbjsKQEAgLTg5 LDkgKzk4LDEzIEBAIGZ1bmN0aW9uIGNyZWF0ZU9iamVjdFN0b3JlQWdhaW4oKQogCiBmdW5jdGlv biBnZXRWYWx1ZUFnYWluKCkKIHsKLSAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOwotCi0g ICAgcmVzdWx0ID0gZXZhbEFuZExvZygiZXZlbnQucmVzdWx0LmdldCgna2V5JykiKTsKKyAgICB2 ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOw0KKw0KKyAgICB0cmFuc2FjdGlvbiA9IGV2YWxBbmRM b2coImRiLnRyYW5zYWN0aW9uKCkiKTsNCisgICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9IHVuZXhw ZWN0ZWRFcnJvckNhbGxiYWNrOw0KKyAgICB2YXIgc3RvcmUgPSBldmFsQW5kTG9nKCJzdG9yZSA9 IHRyYW5zYWN0aW9uLm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKSIpOw0KKw0KKyAgICByZXN1bHQg PSBldmFsQW5kTG9nKCJzdG9yZS5nZXQoJ2tleScpIik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3Vs dCk7CiAgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IHVuZXhwZWN0ZWRTdWNjZXNzQ2FsbGJhY2s7CiAg ICAgcmVzdWx0Lm9uZXJyb3IgPSB2ZXJpZnlFcnJvcjsKQEAgLTEwMCw3ICsxMTMsNiBAQCBmdW5j dGlvbiBnZXRWYWx1ZUFnYWluKCkKIGZ1bmN0aW9uIHZlcmlmeUVycm9yKCkKIHsKICAgICB2ZXJp ZnlFcnJvckV2ZW50KGV2ZW50KTsKLSAgICAvLyBGSVhNRTogU2hvdWxkIGp1c3QgYmUgSURCRGF0 YWJhc2VFeGNlcHRpb24uTk9UX0ZPVU5EX0VSUiBidXQgdGhhdCBkb2Vzbid0IHdvcmsgeWV0Lgog ICAgIHNob3VsZEJlKCJldmVudC5jb2RlIiwgIjIiKTsKICAgICBzaG91bGRCZUZhbHNlKCJldmVu dC5zb3VyY2UuaW5kZXhOYW1lcy5jb250YWlucygnaW5kZXhOYW1lJykiKTsKIApkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0LWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uMjg0NTYwMjZiYzVlYTQ4ZmIyNWI4ZTE0N2MzNmFhMGYyMjY0 NjExMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL3Ry YW5zYWN0aW9uLWdldC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw5OSBAQAorVGVzdCBJbmRleGVk REIncyBnZXQgaW5zaWRlIGEgdHJhbnNhY3Rpb24uCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNl ZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRF Ii4KKworCitpbmRleGVkREIub3BlbignbmFtZScsICdkZXNjcmlwdGlvbicpCitQQVNTICdvbnN1 Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdvbmVycm9yJyBpbiByZXN1bHQgaXMgdHJ1 ZQorUEFTUyAnYWJvcnQnIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdyZWFkeVN0YXRlJyBpbiBy ZXN1bHQgaXMgdHJ1ZQorQW4gZXZlbnQgc2hvdWxkIGZpcmUgc2hvcnRseS4uLgorCitTdWNjZXNz IGV2ZW50IGZpcmVkOgorUEFTUyAncmVzdWx0JyBpbiBldmVudCBpcyB0cnVlCitQQVNTICdjb2Rl JyBpbiBldmVudCBpcyBmYWxzZQorUEFTUyAnbWVzc2FnZScgaW4gZXZlbnQgaXMgZmFsc2UKK1BB U1MgJ3NvdXJjZScgaW4gZXZlbnQgaXMgdHJ1ZQorUEFTUyBldmVudC5zb3VyY2UgIT0gbnVsbCBp cyB0cnVlCitQQVNTICdvbnN1Y2Nlc3MnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdv bmVycm9yJyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyAnYWJvcnQnIGluIGV2ZW50LnRh cmdldCBpcyB0cnVlCitQQVNTICdyZWFkeVN0YXRlJyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQor UEFTUyBldmVudC50YXJnZXQucmVhZHlTdGF0ZSBpcyBldmVudC50YXJnZXQuRE9ORQorCitkYiA9 IGV2ZW50LnJlc3VsdAorZGIuY3JlYXRlT2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpCitQQVNTICdv bnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdvbmVycm9yJyBpbiByZXN1bHQgaXMg dHJ1ZQorUEFTUyAnYWJvcnQnIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdyZWFkeVN0YXRlJyBp biByZXN1bHQgaXMgdHJ1ZQorQW4gZXZlbnQgc2hvdWxkIGZpcmUgc2hvcnRseS4uLgorCitTdWNj ZXNzIGV2ZW50IGZpcmVkOgorUEFTUyAncmVzdWx0JyBpbiBldmVudCBpcyB0cnVlCitQQVNTICdj b2RlJyBpbiBldmVudCBpcyBmYWxzZQorUEFTUyAnbWVzc2FnZScgaW4gZXZlbnQgaXMgZmFsc2UK K1BBU1MgJ3NvdXJjZScgaW4gZXZlbnQgaXMgdHJ1ZQorUEFTUyBldmVudC5zb3VyY2UgIT0gbnVs bCBpcyB0cnVlCitQQVNTICdvbnN1Y2Nlc3MnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNT ICdvbmVycm9yJyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyAnYWJvcnQnIGluIGV2ZW50 LnRhcmdldCBpcyB0cnVlCitQQVNTICdyZWFkeVN0YXRlJyBpbiBldmVudC50YXJnZXQgaXMgdHJ1 ZQorUEFTUyBldmVudC50YXJnZXQucmVhZHlTdGF0ZSBpcyBldmVudC50YXJnZXQuRE9ORQorCitv YmplY3RTdG9yZSA9IGV2ZW50LnJlc3VsdAorb2JqZWN0U3RvcmUuYWRkKCdteVZhbHVlJywgJ215 S2V5JykKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3In IGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1Mg J3JlYWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9y dGx5Li4uCisKK1VzaW5nIGdldCBpbiBhIHRyYW5zYWN0aW9uCitkYi50cmFuc2FjdGlvbigpCitz dG9yZSA9IHRyYW5zYWN0aW9uLm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKQorUEFTUyBzdG9yZS5u YW1lIGlzICJzdG9yZU5hbWUiCitQQVNTICdvbnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCitQ QVNTICdvbmVycm9yJyBpbiByZXN1bHQgaXMgdHJ1ZQorUEFTUyAnYWJvcnQnIGluIHJlc3VsdCBp cyB0cnVlCitQQVNTICdyZWFkeVN0YXRlJyBpbiByZXN1bHQgaXMgdHJ1ZQorQW4gZXZlbnQgc2hv dWxkIGZpcmUgc2hvcnRseS4uLgorCitQQVNTICdvbnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVl CitQQVNTICdvbmVycm9yJyBpbiByZXN1bHQgaXMgdHJ1ZQorUEFTUyAnYWJvcnQnIGluIHJlc3Vs dCBpcyB0cnVlCitQQVNTICdyZWFkeVN0YXRlJyBpbiByZXN1bHQgaXMgdHJ1ZQorQW4gZXZlbnQg c2hvdWxkIGZpcmUgc2hvcnRseS4uLgorCitTdWNjZXNzIGV2ZW50IGZpcmVkOgorUEFTUyAncmVz dWx0JyBpbiBldmVudCBpcyB0cnVlCitQQVNTICdjb2RlJyBpbiBldmVudCBpcyBmYWxzZQorUEFT UyAnbWVzc2FnZScgaW4gZXZlbnQgaXMgZmFsc2UKK1BBU1MgJ3NvdXJjZScgaW4gZXZlbnQgaXMg dHJ1ZQorUEFTUyBldmVudC5zb3VyY2UgIT0gbnVsbCBpcyB0cnVlCitQQVNTICdvbnN1Y2Nlc3Mn IGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdvbmVycm9yJyBpbiBldmVudC50YXJnZXQg aXMgdHJ1ZQorUEFTUyAnYWJvcnQnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdyZWFk eVN0YXRlJyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyBldmVudC50YXJnZXQucmVhZHlT dGF0ZSBpcyBldmVudC50YXJnZXQuRE9ORQorCit2YWx1ZSA9IGV2ZW50LnJlc3VsdAorUEFTUyB2 YWx1ZSBpcyAibXlWYWx1ZSIKK0Vycm9yIGV2ZW50IGZpcmVkOgorUEFTUyAncmVzdWx0JyBpbiBl dmVudCBpcyBmYWxzZQorUEFTUyAnY29kZScgaW4gZXZlbnQgaXMgdHJ1ZQorUEFTUyAnbWVzc2Fn ZScgaW4gZXZlbnQgaXMgdHJ1ZQorUEFTUyAnc291cmNlJyBpbiBldmVudCBpcyB0cnVlCitQQVNT IGV2ZW50LnNvdXJjZSAhPSBudWxsIGlzIHRydWUKK1BBU1MgJ29uc3VjY2VzcycgaW4gZXZlbnQu dGFyZ2V0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQ QVNTICdhYm9ydCcgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGlu IGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2 ZW50LnRhcmdldC5ET05FCisKK0FjY2Vzc2luZyBhIGNvbW1pdHRlZCB0cmFuc2FjdGlvbiBzaG91 bGQgdGhyb3cKK1BBU1MgZXhjLmNvZGUgaXMgOQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMg dHJ1ZQorCitURVNUIENPTVBMRVRFCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2lu ZGV4ZWRkYi90cmFuc2FjdGlvbi1nZXQuaHRtbCBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhl ZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjAzZjI5NTFlYWZlNzZhZTEyN2Zh NjkyNTJjNTU5N2E5OWQ5NThmMmMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9zdG9y YWdlL2luZGV4ZWRkYi90cmFuc2FjdGlvbi1nZXQuaHRtbApAQCAtMCwwICsxLDkzIEBACis8aHRt bD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9mYXN0L2pzL3Jl c291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zh c3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC1mdW5jdGlvbi5qcyI+PC9zY3JpcHQ+Cis8c2Ny aXB0IHNyYz0icmVzb3VyY2VzL3NoYXJlZC5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4K KzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2Ny aXB0Pg0KK2Rlc2NyaXB0aW9uKCJUZXN0IEluZGV4ZWREQidzIGdldCBpbnNpZGUgYSB0cmFuc2Fj dGlvbi4iKTsNCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQ0KKyAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7DQorDQorZnVuY3Rpb24gYWZ0ZXJDb21taXQo KSB7DQorICAgIHRyeSB7DQorICAgICAgICBkZWJ1ZygiQWNjZXNzaW5nIGEgY29tbWl0dGVkIHRy YW5zYWN0aW9uIHNob3VsZCB0aHJvdyIpOw0KKyAgICAgICAgdmFyIHN0b3JlID0gdHJhbnNhY3Rp b24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpOw0KKyAgICB9IGNhdGNoIChlKSB7DQorICAgICAg ICBleGMgPSBlOw0KKyAgICAgICAgc2hvdWxkQmUoJ2V4Yy5jb2RlJywgJzknKTsNCisgICAgfQ0K KyAgICBkb25lKCk7DQorfQ0KKw0KK2Z1bmN0aW9uIG5vbkV4aXN0aW5nS2V5KCkgew0KKyAgICB2 ZXJpZnlFcnJvckV2ZW50KGV2ZW50KTsNCisgICAgd2luZG93LnNldFRpbWVvdXQoJ2FmdGVyQ29t bWl0KCknLCAwKTsNCit9DQorDQorZnVuY3Rpb24gZ290VmFsdWUoKSB7DQorICAgIHZlcmlmeVN1 Y2Nlc3NFdmVudChldmVudCk7DQorICAgIHZhciB2YWx1ZSA9IGV2YWxBbmRMb2coInZhbHVlID0g ZXZlbnQucmVzdWx0Iik7DQorICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygndmFsdWUnLCAnbXlW YWx1ZScpOw0KK30NCisNCitmdW5jdGlvbiBzdGFydFRyYW5zYWN0aW9uKCkgew0KKyAgICBkZWJ1 ZygiVXNpbmcgZ2V0IGluIGEgdHJhbnNhY3Rpb24iKTsNCisgICAgdHJhbnNhY3Rpb24gPSBldmFs QW5kTG9nKCJkYi50cmFuc2FjdGlvbigpIik7DQorICAgIHRyYW5zYWN0aW9uLm9uYWJvcnQgPSB1 bmV4cGVjdGVkRXJyb3JDYWxsYmFjazsNCisgICAgdmFyIHN0b3JlID0gZXZhbEFuZExvZygic3Rv cmUgPSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykiKTsNCisgICAgc2hvdWxk QmVFcXVhbFRvU3RyaW5nKCJzdG9yZS5uYW1lIiwgInN0b3JlTmFtZSIpOw0KKyAgICB2YXIgcmVz dWx0ID0gc3RvcmUuZ2V0KCdteUtleScpOw0KKyAgICB2ZXJpZnlSZXN1bHQocmVzdWx0KTsNCisg ICAgcmVzdWx0Lm9uc3VjY2VzcyA9IGdvdFZhbHVlOw0KKyAgICByZXN1bHQub25lcnJvciA9IHVu ZXhwZWN0ZWRFcnJvckNhbGxiYWNrOw0KKw0KKyAgICB2YXIgZW1wdHlSZXN1bHQgPSBzdG9yZS5n ZXQoJ25vbkV4aXN0aW5nS2V5Jyk7DQorICAgIHZlcmlmeVJlc3VsdChlbXB0eVJlc3VsdCk7DQor ICAgIGVtcHR5UmVzdWx0Lm9uc3VjY2VzcyA9IHVuZXhwZWN0ZWRTdWNjZXNzQ2FsbGJhY2s7DQor ICAgIGVtcHR5UmVzdWx0Lm9uZXJyb3IgPSBub25FeGlzdGluZ0tleTsNCit9DQorDQorZnVuY3Rp b24gcG9wdWxhdGVPYmplY3RTdG9yZShvYmplY3RTdG9yZSkgew0KKyAgICByZXN1bHQgPSBldmFs QW5kTG9nKCJvYmplY3RTdG9yZS5hZGQoJ215VmFsdWUnLCAnbXlLZXknKSIpOw0KKyAgICB2ZXJp ZnlSZXN1bHQocmVzdWx0KTsNCisgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IHN0YXJ0VHJhbnNhY3Rp b247DQorICAgIHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7DQorfQ0K Kw0KK2Z1bmN0aW9uIGNyZWF0ZU9iamVjdFN0b3JlU3VjY2VzcygpIHsNCisgICAgdmVyaWZ5U3Vj Y2Vzc0V2ZW50KGV2ZW50KTsNCisgICAgdmFyIG9iamVjdFN0b3JlID0gZXZhbEFuZExvZygib2Jq ZWN0U3RvcmUgPSBldmVudC5yZXN1bHQiKTsNCisgICAgcG9wdWxhdGVPYmplY3RTdG9yZShvYmpl Y3RTdG9yZSk7DQorfQ0KKw0KK2Z1bmN0aW9uIG9wZW5TdWNjZXNzKCkgew0KKyAgICB2ZXJpZnlT dWNjZXNzRXZlbnQoZXZlbnQpOw0KKyAgICB2YXIgZGIgPSBldmFsQW5kTG9nKCJkYiA9IGV2ZW50 LnJlc3VsdCIpOw0KKw0KKyAgICBkZWxldGVBbGxPYmplY3RTdG9yZXMoZGIpOw0KKw0KKyAgICBy ZXN1bHQgPSBldmFsQW5kTG9nKCJkYi5jcmVhdGVPYmplY3RTdG9yZSgnc3RvcmVOYW1lJykiKTsN CisgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7DQorICAgIHJlc3VsdC5vbnN1Y2Nlc3MgPSBjcmVh dGVPYmplY3RTdG9yZVN1Y2Nlc3M7DQorICAgIHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVy cm9yQ2FsbGJhY2s7DQorfQ0KKw0KK2Z1bmN0aW9uIHRlc3QoKSB7DQorICAgIHJlc3VsdCA9IGV2 YWxBbmRMb2coImluZGV4ZWREQi5vcGVuKCduYW1lJywgJ2Rlc2NyaXB0aW9uJykiKTsNCisgICAg dmVyaWZ5UmVzdWx0KHJlc3VsdCk7DQorICAgIHJlc3VsdC5vbnN1Y2Nlc3MgPSBvcGVuU3VjY2Vz czsNCisgICAgcmVzdWx0Lm9uZXJyb3IgPSB1bmV4cGVjdGVkRXJyb3JDYWxsYmFjazsNCit9DQor DQordGVzdCgpOw0KKw0KK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworCis8L3Njcmlw dD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKaW5kZXggYWNmZjY3NTM5YjkyNmMwYzg4NTdiMWFmMzcxZjcxNjRkMWI3 MWE2Zi4uNmM2N2ViYjY1M2Y2ZTU3YTk3MmMyODQ2ODEwNjU2MmRkMDE3MTYzNSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw3 OCBAQAorMjAxMC0wOS0yMCAgQW5kcmVpIFBvcGVzY3UgIDxhbmRyZWlwQGdvb2dsZS5jb20+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSURCT2JqZWN0 U3RvcmU6OmdldCBzaG91bGQgcnVuIGluIGEgdHJhbnNhY3Rpb24uCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NDcwMAorCisgICAgICAgIFRlc3Q6IHN0 b3JhZ2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sCisKKyAgICAgICAgKiBiaW5kaW5n cy92OC9WOFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4UHJveHk6OmRpZExlYXZlU2Ny aXB0Q29udGV4dCk6CisgICAgICAgICogc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHA6 CisgICAgICAgICogc3RvcmFnZS9JREJEYXRhYmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJ REJEYXRhYmFzZTo6b2JqZWN0U3RvcmUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCRGF0YWJhc2VC YWNrZW5kSW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJEYXRhYmFzZUJhY2tlbmRJbXBs OjpvYmplY3RTdG9yZSk6CisgICAgICAgICogc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBs Lmg6CisgICAgICAgIChXZWJDb3JlOjpJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjp0cmFuc2FjdGlv bkNvb3JkaW5hdG9yKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVy ZmFjZS5oOgorICAgICAgICAqIHN0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OklEQkZhY3RvcnlCYWNrZW5kSW1wbDo6YWJvcnRQZW5kaW5nVHJhbnNh Y3Rpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OklEQkZhY3RvcnlCYWNrZW5kSW1wbDo6ZGlkQ29t cGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbik6CisgICAgICAgICogc3RvcmFnZS9JREJGYWN0b3J5 QmFja2VuZEltcGwuaDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW50ZXJm YWNlLmg6CisgICAgICAgICogc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpJREJPYmplY3RTdG9yZTo6SURCT2JqZWN0U3RvcmUpOgorICAgICAgICAoV2ViQ29y ZTo6SURCT2JqZWN0U3RvcmU6OmdldCk6CisgICAgICAgICogc3RvcmFnZS9JREJPYmplY3RTdG9y ZS5oOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmU6OmNyZWF0ZSk6CisgICAgICAg ICogc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldCk6CisgICAgICAgICogc3RvcmFnZS9J REJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmg6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RT dG9yZUJhY2tlbmRJbXBsOjpJREJUYXNrOjpJREJUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OklE Qk9iamVjdFN0b3JlQmFja2VuZEltcGw6OklEQlRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAg KFdlYkNvcmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6Om5ld1Rhc2spOgorICAgICAgICAq IHN0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmg6CisgICAgICAgICogc3Rv cmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OnJlbW92ZVBlbmRpbmdUcmFuc2FjdGlvbik6 CisgICAgICAgIChXZWJDb3JlOjpJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjphYm9ydFBl bmRpbmdUcmFuc2FjdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6SURCUGVuZGluZ1RyYW5zYWN0 aW9uTW9uaXRvcjo6ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbik6CisgICAgICAgICog c3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmg6CisgICAgICAgICogc3RvcmFn ZS9JREJSZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlJlcXVlc3Q6OklEQlJlcXVl c3QpOgorICAgICAgICAoV2ViQ29yZTo6SURCUmVxdWVzdDo6b25TdWNjZXNzKToKKyAgICAgICAg KFdlYkNvcmU6OklEQlJlcXVlc3Q6OnRpbWVyRmlyZWQpOgorICAgICAgICAqIHN0b3JhZ2UvSURC UmVxdWVzdC5oOgorICAgICAgICAoV2ViQ29yZTo6SURCUmVxdWVzdDo6Y3JlYXRlKToKKyAgICAg ICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlRy YW5zYWN0aW9uOjpvYmplY3RTdG9yZSk6CisgICAgICAgICogc3RvcmFnZS9JREJUcmFuc2FjdGlv bkJhY2tlbmRJbXBsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2Vu ZEltcGw6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwpOgorICAgICAgICAoV2ViQ29yZTo6SURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6b2JqZWN0U3RvcmUpOgorICAgICAgICAoV2ViQ29yZTo6 SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6c2NoZWR1bGVUYXNrKToKKyAgICAgICAgKFdlYkNv cmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnN0ZXApOgorICAgICAgICAoV2ViQ29yZTo6 SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6YWJvcnQpOgorICAgICAgICAoV2ViQ29yZTo6SURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6cnVuKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5z YWN0aW9uQmFja2VuZEltcGw6OnN0YXJ0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0 aW9uQmFja2VuZEltcGw6OnJ1bk5leHRUYXNrcyk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFu c2FjdGlvbkJhY2tlbmRJbXBsOjpjb21taXQpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbDo6ZGlkRmluaXNoVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29y ZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZCk6CisgICAgICAgICogc3Rv cmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmg6CisgICAgICAgIChXZWJDb3JlOjpJREJU cmFuc2FjdGlvbkJhY2tlbmRJbXBsOjp+SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCk6CisgICAg ICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjppc0ZpbmlzaGVkKToKKyAg ICAgICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oOgorICAgICAg ICAqIHN0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpjcmVhdGVUcmFuc2FjdGlvbik6CisgICAg ICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjphYm9ydFBlbmRpbmdUcmFu c2FjdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6 ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJU cmFuc2FjdGlvbkNvb3JkaW5hdG9yOjp0cmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJ REJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpkaWRTdGFydFRyYW5zYWN0aW9uKToKKyAgICAgICAg KFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZEZpbmlzaFRyYW5zYWN0aW9u KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OnByb2Nlc3NT dGFydGVkVHJhbnNhY3Rpb25zKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29v cmRpbmF0b3IuaDoKKwogMjAxMC0wOS0xOSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJv dEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY3NzQ5Lgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9iaW5kaW5ncy92OC9WOFByb3h5LmNwcCBiL1dlYkNvcmUvYmlu ZGluZ3MvdjgvVjhQcm94eS5jcHAKaW5kZXggYTc3NmVlN2Q3M2ZiOTJkNDg2ZTY3N2QwODVkYWUx NjM3OTdkYjg0ZC4uMDEzYzU5OGMwNTE5ZjVlMzE5OTM0YjQwZDU0OWE0YmNmMmJiZTVjYyAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9iaW5kaW5ncy92OC9WOFByb3h5LmNwcAorKysgYi9XZWJDb3JlL2Jp bmRpbmdzL3Y4L1Y4UHJveHkuY3BwCkBAIC02NTMsMTEgKzY1Myw3IEBAIHZvaWQgVjhQcm94eTo6 ZGlkTGVhdmVTY3JpcHRDb250ZXh0KCkKICAgICAvLyBJZiB3ZSd2ZSBqdXN0IGxlZnQgYSBzY3Jp cHQgY29udGV4dCBhbmQgaW5kZXhlZCBkYXRhYmFzZSBoYXMgYmVlbgogICAgIC8vIGluc3RhbnRp YXRlZCwgd2UgbXVzdCBsZXQgaXRzIHRyYW5zYWN0aW9uIGNvb3JkaW5hdG9yIGtub3cgc28gaXQg Y2FuIHRlcm1pbmF0ZQogICAgIC8vIGFueSBub3QteWV0LXN0YXJ0ZWQgdHJhbnNhY3Rpb25zLgot ICAgIGlmIChJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpoYXNQZW5kaW5nVHJhbnNhY3Rp b25zKCkpIHsKLSAgICAgICAgQVNTRVJUKHBhZ2UtPmdyb3VwKCkuaGFzSURCRmFjdG9yeSgpKTsK LSAgICAgICAgcGFnZS0+Z3JvdXAoKS5pZGJGYWN0b3J5KCktPmFib3J0UGVuZGluZ1RyYW5zYWN0 aW9ucyhJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpwZW5kaW5nVHJhbnNhY3Rpb25zKCkp OwotICAgICAgICBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpjbGVhclBlbmRpbmdUcmFu c2FjdGlvbnMoKTsKLSAgICB9CisgICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWJv cnRQZW5kaW5nVHJhbnNhY3Rpb25zKHBhZ2UtPmdyb3VwKCkuaWRiRmFjdG9yeSgpKTsKICNlbmRp ZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKICAgICAvLyBJZiB3ZSd2ZSBqdXN0IGxlZnQg YSB0b3AgbGV2ZWwgc2NyaXB0IGNvbnRleHQgYW5kIGxvY2FsIHN0b3JhZ2UgaGFzIGJlZW4KICAg ICAvLyBpbnN0YW50aWF0ZWQsIHdlIG11c3QgZW5zdXJlIHRoYXQgYW55IHN0b3JhZ2UgbG9ja3Mg aGF2ZSBiZWVuIGZyZWVkLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkN1cnNvckJh Y2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHAK aW5kZXggM2E0ZGQ2Nzc0OGFiNzQ3NWYxNjljZWQ3NDc2YTM1ZjdkNWI2ODM4ZC4uMTNkZjVmMDIx NTRlNTVkMTYyNmQwNjIyZTBiZDI1YzVjZTBiZDk4YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9y YWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCQ3Vy c29yQmFja2VuZEltcGwuY3BwCkBAIC0zNiw2ICszNiw3IEBACiAjaW5jbHVkZSAiSURCS2V5UmFu Z2UuaCIKICNpbmNsdWRlICJJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmgiCiAjaW5jbHVkZSAi SURCUmVxdWVzdC5oIgorI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5o IgogI2luY2x1ZGUgIlNRTGl0ZURhdGFiYXNlLmgiCiAjaW5jbHVkZSAiU1FMaXRlU3RhdGVtZW50 LmgiCiAjaW5jbHVkZSAiU2VyaWFsaXplZFNjcmlwdFZhbHVlLmgiCmRpZmYgLS1naXQgYS9XZWJD b3JlL3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNl LmNwcAppbmRleCA4MTk1MGQ2ZTA0M2JkZjIwYmY1YmJjNWY2M2Y5OTgwMjYyOTJjYWNhLi44NTBi YjllNTAyMzUyZjMzYTZmMWI2OWJjMDU0YWZkZTI3MTdjMmNiIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFz ZS5jcHAKQEAgLTU3LDkgKzU3LDEwIEBAIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gSURCRGF0YWJh c2U6OmNyZWF0ZU9iamVjdFN0b3JlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvCiAKIFBhc3NS ZWZQdHI8SURCT2JqZWN0U3RvcmU+IElEQkRhdGFiYXNlOjpvYmplY3RTdG9yZShjb25zdCBTdHJp bmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUpCiB7CisgICAgLy8gRklYTUU6IHJlbW92ZSB0 aGlzIG1ldGhvZC4KICAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBv YmplY3RTdG9yZSA9IG1fYmFja2VuZC0+b2JqZWN0U3RvcmUobmFtZSwgbW9kZSk7CiAgICAgQVNT RVJUKG9iamVjdFN0b3JlKTsgLy8gRklYTUU6IElmIHRoaXMgaXMgbnVsbCwgd2Ugc2hvdWxkIHJh aXNlIGEgTk9UX0ZPVU5EX0VSUi4KLSAgICByZXR1cm4gSURCT2JqZWN0U3RvcmU6OmNyZWF0ZShv YmplY3RTdG9yZS5yZWxlYXNlKCkpOworICAgIHJldHVybiBJREJPYmplY3RTdG9yZTo6Y3JlYXRl KG9iamVjdFN0b3JlLnJlbGVhc2UoKSwgMCk7CiB9CiAKIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4g SURCRGF0YWJhc2U6OnJlbW92ZU9iamVjdFN0b3JlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNv bnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9J REJEYXRhYmFzZUJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJh Y2tlbmRJbXBsLmNwcAppbmRleCAwMjFmNzBhYTRiNDg4MTE5ZTlmYzk2MTZmMDQ1ZDQ5OWNhNGI4 MWFiLi5iY2Q2ZGNiOWM1ZWE1ZjM4ZDI4YjY1MDE5NTBjNDRjZDg3MTdlYzM3IDEwMDY0NAotLS0g YS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5jcHAKKysrIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuY3BwCkBAIC0xNDgsMTEgKzE0OCwxMiBA QCB2b2lkIElEQkRhdGFiYXNlQmFja2VuZEltcGw6OmNyZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0 cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJgogICAgIGNhbGxiYWNrcy0+b25TdWNjZXNzKG9iamVj dFN0b3JlLmdldCgpKTsKIH0KIAotUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRl cmZhY2U+IElEQkRhdGFiYXNlQmFja2VuZEltcGw6Om9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYg bmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSkKK1Bhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNr ZW5kSW50ZXJmYWNlPiBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjpvYmplY3RTdG9yZShjb25zdCBT dHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUsIElEQlRyYW5zYWN0aW9uQmFja2VuZElu dGVyZmFjZSogdHJhbnNhY3Rpb24pCiB7Ci0gICAgLy8gRklYTUU6IElmIG5vIHRyYW5zYWN0aW9u IGlzIHJ1bm5pbmcsIHRoaXMgc2hvdWxkIGltcGxpY2l0bHkgc3RhcnQgb25lLgorICAgIC8vIEZJ WE1FOiBEbyBub3QgZXhwb3NlIHRoaXMgbWV0aG9kIHZpYSBJREwuCiAgICAgQVNTRVJUX1VOVVNF RChtb2RlLCAhbW9kZSk7IC8vIEZJWE1FOiBIYW5kbGUgbm9uLXN0YW5kYXJkIG1vZGVzLgotICAg IHJldHVybiBtX29iamVjdFN0b3Jlcy5nZXQobmFtZSk7CisgICAgUmVmUHRyPElEQk9iamVjdFN0 b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUgPSBtX29iamVjdFN0b3Jlcy5nZXQobmFt ZSk7CisgICAgcmV0dXJuIG9iamVjdFN0b3JlLnJlbGVhc2UoKTsKIH0KIAogc3RhdGljIHZvaWQg ZG9EZWxldGUoU1FMaXRlRGF0YWJhc2UmIGRiLCBjb25zdCBjaGFyKiBzcWwsIGludDY0X3QgaWQp CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oIGIv V2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaAppbmRleCBhYjA1NWY4OGE4 YzA4ZjJmNmQwM2Q2OTU5ODE0NDE1NzhjNGYyNTcwLi5jMmFiYjU4N2QwYzAwM2JhZWYwYjFiYjFm MTMxMmRlMDY4NDg5MWY2IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VC YWNrZW5kSW1wbC5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBs LmgKQEAgLTU3LDExICs1NywxMyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPERP TVN0cmluZ0xpc3Q+IG9iamVjdFN0b3JlcygpIGNvbnN0OwogCiAgICAgdmlydHVhbCB2b2lkIGNy ZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBrZXlQYXRo LCBib29sIGF1dG9JbmNyZW1lbnQsIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7Ci0gICAgdmly dHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3Rv cmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBzaG9ydCBtb2RlKTsKKyAgICB2aXJ0dWFs IFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShj b25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUsIElEQlRyYW5zYWN0aW9uQmFj a2VuZEludGVyZmFjZSopOwogICAgIHZpcnR1YWwgdm9pZCByZW1vdmVPYmplY3RTdG9yZShjb25z dCBTdHJpbmcmIG5hbWUsIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCB2 b2lkIHNldFZlcnNpb24oY29uc3QgU3RyaW5nJiB2ZXJzaW9uLCBQYXNzUmVmUHRyPElEQkNhbGxi YWNrcz4pOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2U+IHRyYW5zYWN0aW9uKERPTVN0cmluZ0xpc3QqIHN0b3JlTmFtZXMsIHVuc2lnbmVkIHNo b3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCk7CiAKKyAgICBJREJUcmFuc2FjdGlvbkNv b3JkaW5hdG9yKiB0cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkgY29uc3QgeyByZXR1cm4gbV90cmFu c2FjdGlvbkNvb3JkaW5hdG9yLmdldCgpOyB9CisKIHByaXZhdGU6CiAgICAgSURCRGF0YWJhc2VC YWNrZW5kSW1wbChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24s IFBhc3NPd25QdHI8U1FMaXRlRGF0YWJhc2U+IGRhdGFiYXNlLCBJREJUcmFuc2FjdGlvbkNvb3Jk aW5hdG9yKik7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tl bmRJbnRlcmZhY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbnRlcmZh Y2UuaAppbmRleCBhMmUwNDJhZTIwMDAwYTQxYzJmNmQ1MDUwOWZkYTQ3NWY3NTUzODQ1Li5kMWUx Y2IxODI0YTMxOTRhNjZlOWM2ZmVmOTZiMTJkM2RlMTAxMTEwIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW50ZXJmYWNlLmgKKysrIGIvV2ViQ29yZS9zdG9y YWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVyZmFjZS5oCkBAIC01NSw3ICs1NSw3IEBAIHB1Ymxp YzoKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8RE9NU3RyaW5nTGlzdD4gb2JqZWN0U3RvcmVzKCkg Y29uc3QgPSAwOwogCiAgICAgdmlydHVhbCB2b2lkIGNyZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0 cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBrZXlQYXRoLCBib29sIGF1dG9JbmNyZW1lbnQsIFBh c3NSZWZQdHI8SURCQ2FsbGJhY2tzPikgPSAwOwotICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJP YmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFt ZSwgdW5zaWduZWQgc2hvcnQgbW9kZSkgPSAwOworICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJP YmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFt ZSwgdW5zaWduZWQgc2hvcnQgbW9kZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0 cmFuc2FjdGlvbiA9IDApID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlT2JqZWN0U3RvcmUo Y29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pID0gMDsKICAgICB2 aXJ0dWFsIHZvaWQgc2V0VmVyc2lvbihjb25zdCBTdHJpbmcmIHZlcnNpb24sIFBhc3NSZWZQdHI8 SURCQ2FsbGJhY2tzPikgPSAwOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlv bkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uKERPTVN0cmluZ0xpc3QqIHN0b3JlTmFtZXMs IHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCkgPSAwOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5jcHAgYi9XZWJDb3Jl L3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcAppbmRleCBkODE5YzkyYTk0YTg5MjEw YjYzZGFmZjExN2VmODQyODE0N2VkYzY3Li4xNDk4YjkyMGMwNmVhZTQwMWQ1MDA4YTk5NzNlNDFi ODgzMzJhYWZkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJ bXBsLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcApA QCAtMTQ0LDggKzE0NCwxMiBAQCB2b2lkIElEQkZhY3RvcnlCYWNrZW5kSW1wbDo6b3Blbihjb25z dCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24sCiAKIHZvaWQgSURCRmFj dG9yeUJhY2tlbmRJbXBsOjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGlu dD4mIHBlbmRpbmdJRHMpCiB7Ci0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBwZW5kaW5nSURz LnNpemUoKTsgKytpKQotICAgICAgICBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3ItPmFib3J0KHBl bmRpbmdJRHMuYXQoaSkpOworICAgIG1fdHJhbnNhY3Rpb25Db29yZGluYXRvci0+YWJvcnRQZW5k aW5nVHJhbnNhY3Rpb25zKHBlbmRpbmdJRHMpOworfQorCit2b2lkIElEQkZhY3RvcnlCYWNrZW5k SW1wbDo6ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgdHJhbnNhY3Rpb25JRCkK K3sKKyAgICBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3ItPmRpZENvbXBsZXRlRXZlbnRzRm9yVHJh bnNhY3Rpb24odHJhbnNhY3Rpb25JRCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuaCBiL1dlYkNv cmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuaAppbmRleCBmMmUxYWY4MTE1ZWJiNGRi ZTNmZmUxMDdkNjI3NDgyZWJmNWE5MGM3Li5lNWJlN2Y5OTVhMzkyOTI3Y2IzMzJjNmExNTY5NGJi ZWJjNzFiYzA3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJ bXBsLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5oCkBAIC01 MSw2ICs1MSw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBvcGVuKGNvbnN0IFN0cmlu ZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwgUGFzc1JlZlB0cjxJREJDYWxsYmFj a3M+LCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiwgRnJhbWUqLCBjb25zdCBTdHJpbmcmIGRh dGFEaXIpOwogICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3Qg VmVjdG9yPGludD4mIHBlbmRpbmdJRHMpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0ZUV2 ZW50c0ZvclRyYW5zYWN0aW9uKGludCB0cmFuc2FjdGlvbklEKTsKIAogcHJpdmF0ZToKICAgICBJ REJGYWN0b3J5QmFja2VuZEltcGwoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJG YWN0b3J5QmFja2VuZEludGVyZmFjZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNr ZW5kSW50ZXJmYWNlLmgKaW5kZXggZTU5MTI3MTllZjU0NDk0NDZlYTZiYzIyZjM1NjQ2MzA2ZDhk NzBiZC4uYTAwOTNmN2I0ZjNhYTZlZjQzNTdiOTM2MzcxNjU4NDQ0ZTBmNGQyMSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlLmgKKysrIGIvV2Vi Q29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTUzLDYgKzUzLDcg QEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIG9wZW4oY29uc3QgU3RyaW5nJiBuYW1lLCBj b25zdCBTdHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4sIFBhc3NS ZWZQdHI8U2VjdXJpdHlPcmlnaW4+LCBGcmFtZSosIGNvbnN0IFN0cmluZyYgZGF0YURpcikgPSAw OwogICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9y PGludD4mIGlkcykgPSAwOworICAgIHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0ZUV2ZW50c0ZvclRy YW5zYWN0aW9uKGludCB0cmFuc2FjdGlvbklEKSA9IDA7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuY3BwIGIv V2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcAppbmRleCBiNDU3Y2QxZDE1ODg2YzEw ZmIyZTFmMzM0YTNkYzIyYTNmZGYxYzg1Li43YWUzNGEwNzAzN2QyNDk3ZWY2MGZiOTI4OGU3OTJh OGFhY2ZmZTYxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuY3Bw CisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHAKQEAgLTMxLDYgKzMxLDgg QEAKICNpbmNsdWRlICJJREJJbmRleC5oIgogI2luY2x1ZGUgIklEQktleS5oIgogI2luY2x1ZGUg IklEQktleVJhbmdlLmgiCisjaW5jbHVkZSAiSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5o IgorI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uLmgiCiAjaW5jbHVkZSAiU2VyaWFsaXplZFNjcmlw dFZhbHVlLmgiCiAjaW5jbHVkZSA8d3RmL1VudXNlZFBhcmFtLmg+CiAKQEAgLTM4LDggKzQwLDkg QEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1JREJPYmplY3RTdG9yZTo6SURCT2JqZWN0U3Rv cmUoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IGlkYk9iamVjdFN0 b3JlKQorSURCT2JqZWN0U3RvcmU6OklEQk9iamVjdFN0b3JlKFBhc3NSZWZQdHI8SURCT2JqZWN0 U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RTdG9yZSwgSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbikKICAgICA6IG1fb2JqZWN0U3RvcmUoaWRiT2JqZWN0 U3RvcmUpCisgICAgLCBtX3RyYW5zYWN0aW9uKHRyYW5zYWN0aW9uKQogewogICAgIC8vIFdlIHBh c3MgYSByZWZlcmVuY2UgdG8gdGhpcyBvYmplY3QgYmVmb3JlIGl0IGNhbiBiZSBhZG9wdGVkLgog ICAgIHJlbGF4QWRvcHRpb25SZXF1aXJlbWVudCgpOwpAQCAtNjIsOCArNjUsOCBAQCBQYXNzUmVm UHRyPERPTVN0cmluZ0xpc3Q+IElEQk9iamVjdFN0b3JlOjppbmRleE5hbWVzKCkgY29uc3QKIAog UGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBJREJPYmplY3RTdG9yZTo6Z2V0KFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8SURCS2V5PiBrZXkpCiB7Ci0gICAgUmVmUHRy PElEQlJlcXVlc3Q+IHJlcXVlc3QgPSBJREJSZXF1ZXN0OjpjcmVhdGUoY29udGV4dCwgSURCQW55 OjpjcmVhdGUodGhpcykpOwotICAgIG1fb2JqZWN0U3RvcmUtPmdldChrZXksIHJlcXVlc3QpOwor ICAgIFJlZlB0cjxJREJSZXF1ZXN0PiByZXF1ZXN0ID0gSURCUmVxdWVzdDo6Y3JlYXRlKGNvbnRl eHQsIElEQkFueTo6Y3JlYXRlKHRoaXMpLCBtX3RyYW5zYWN0aW9uLT5pZCgpKTsKKyAgICBtX29i amVjdFN0b3JlLT5nZXQoa2V5LCByZXF1ZXN0LCBtX3RyYW5zYWN0aW9uLmdldCgpKTsKICAgICBy ZXR1cm4gcmVxdWVzdDsKIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVj dFN0b3JlLmggYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaAppbmRleCAwMzVmNWQ4 YjQ3ZmJhODJjYmMzZWQyNDg1YjViNzg4ZTAzMjMxOTI2Li5kNzJlMjlhMDI5ZjA5OTI4MzQ1NGZj ZWRlYTRmMzEwMDczZGY5YjFjIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0 U3RvcmUuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaApAQCAtNDMsMTMg KzQzLDE0IEBAIGNsYXNzIERPTVN0cmluZ0xpc3Q7CiBjbGFzcyBJREJBbnk7CiBjbGFzcyBJREJJ bmRleFJlcXVlc3Q7CiBjbGFzcyBJREJLZXk7CitjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bnRlcmZhY2U7CiBjbGFzcyBTZXJpYWxpemVkU2NyaXB0VmFsdWU7CiAKIGNsYXNzIElEQk9iamVj dFN0b3JlIDogcHVibGljIFJlZkNvdW50ZWQ8SURCT2JqZWN0U3RvcmU+IHsKIHB1YmxpYzoKLSAg ICBzdGF0aWMgUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gY3JlYXRlKFBhc3NSZWZQdHI8SURC T2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RTdG9yZSkKKyAgICBzdGF0aWMg UGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gY3JlYXRlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3Rv cmVCYWNrZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RTdG9yZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5k SW50ZXJmYWNlKiB0cmFuc2FjdGlvbikKICAgICB7Ci0gICAgICAgIHJldHVybiBhZG9wdFJlZihu ZXcgSURCT2JqZWN0U3RvcmUoaWRiT2JqZWN0U3RvcmUpKTsKKyAgICAgICAgcmV0dXJuIGFkb3B0 UmVmKG5ldyBJREJPYmplY3RTdG9yZShpZGJPYmplY3RTdG9yZSwgdHJhbnNhY3Rpb24pKTsKICAg ICB9CiAgICAgfklEQk9iamVjdFN0b3JlKCkgeyB9CiAKQEAgLTY5LDkgKzcwLDExIEBAIHB1Ymxp YzoKICAgICBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IG9wZW5DdXJzb3IoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIFBhc3NSZWZQdHI8SURCS2V5UmFuZ2U+ID0gMCwgdW5zaWduZWQgc2hvcnQgZGly ZWN0aW9uID0gSURCQ3Vyc29yOjpORVhUKTsKIAogcHJpdmF0ZToKLSAgICBJREJPYmplY3RTdG9y ZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4pOworICAgIElEQk9i amVjdFN0b3JlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiwgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbl9pZCk7CisgICAgdm9pZCBy ZW1vdmVUcmFuc2FjdGlvbkZyb21QZW5kaW5nTGlzdCgpOwogCiAgICAgUmVmUHRyPElEQk9iamVj dFN0b3JlQmFja2VuZEludGVyZmFjZT4gbV9vYmplY3RTdG9yZTsKKyAgICBSZWZQdHI8SURCVHJh bnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBtX3RyYW5zYWN0aW9uOwogfTsKIAogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3Jl QmFja2VuZEltcGwuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZElt cGwuY3BwCmluZGV4IGU1ZjgxYWI0ZGMzMzc5ODkyMTA0Mzc1OWJkMmVhODQ3M2EzYjViNWUuLjg0 ODJhZTU2MjhhMWIzMDA2YTExMjcyMzBjZjc4YzdlOTBiNTdmMWEgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmNwcAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5jcHAKQEAgLTM2LDYgKzM2LDggQEAKICNp bmNsdWRlICJJREJLZXlQYXRoLmgiCiAjaW5jbHVkZSAiSURCS2V5UGF0aEJhY2tlbmRJbXBsLmgi CiAjaW5jbHVkZSAiSURCS2V5UmFuZ2UuaCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2UuaCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCiAj aW5jbHVkZSAiU1FMaXRlRGF0YWJhc2UuaCIKICNpbmNsdWRlICJTUUxpdGVTdGF0ZW1lbnQuaCIK ICNpbmNsdWRlICJTUUxpdGVUcmFuc2FjdGlvbi5oIgpAQCAtNzcsMTAgKzc5LDIxIEBAIHN0YXRp YyB2b2lkIGJpbmRXaGVyZUNsYXVzZShTUUxpdGVTdGF0ZW1lbnQmIHF1ZXJ5LCBpbnQ2NF90IGlk LCBJREJLZXkqIGtleSkKICAgICBrZXktPmJpbmQocXVlcnksIDIpOwogfQogCi12b2lkIElEQk9i amVjdFN0b3JlQmFja2VuZEltcGw6OmdldChQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVm UHRyPElEQkNhbGxiYWNrcz4gY2FsbGJhY2tzKQordm9pZCBJREJPYmplY3RTdG9yZUJhY2tlbmRJ bXBsOjpnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+ IGNhbGxiYWNrcywgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbikK IHsKLSAgICBTUUxpdGVTdGF0ZW1lbnQgcXVlcnkoc3FsaXRlRGF0YWJhc2UoKSwgIlNFTEVDVCBr ZXlTdHJpbmcsIGtleURhdGUsIGtleU51bWJlciwgdmFsdWUgRlJPTSBPYmplY3RTdG9yZURhdGEg IiArIHdoZXJlQ2xhdXNlKGtleS5nZXQoKSkpOwotICAgIGJvb2wgb2sgPSBxdWVyeS5wcmVwYXJl KCkgPT0gU1FMUmVzdWx0T2s7CisgICAgaWYgKHRyYW5zYWN0aW9uKSB7CisgICAgICAgIGlmICh0 cmFuc2FjdGlvbi0+aXNGaW5pc2hlZCgpKSB7CisgICAgICAgICAgICBjYWxsYmFja3MtPm9uRXJy b3IoSURCRGF0YWJhc2VFcnJvcjo6Y3JlYXRlKElEQkRhdGFiYXNlRXhjZXB0aW9uOjpOT1RfQUxM T1dFRF9FUlIsICJHZXQgbXVzdCBiZSBjYWxsZWQgaW4gdGhlIGNvbnRleHQgb2YgYSB0cmFuc2Fj dGlvbi4iKSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBPd25Q dHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gZ2V0VGFzayA9IGFkb3B0UHRyKG5ld1Rh c2sodGhpcywgJklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldCwga2V5LCBjYWxsYmFja3Mp KTsKKyAgICAgICAgdHJhbnNhY3Rpb24tPnNjaGVkdWxlVGFzayhnZXRUYXNrLmxlYWtQdHIoKSk7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBTUUxpdGVTdGF0ZW1lbnQgcXVlcnkoc3Fs aXRlRGF0YWJhc2UoKSwgIlNFTEVDVCBrZXlTdHJpbmcsIGtleURhdGUsIGtleU51bWJlciwgdmFs dWUgRlJPTSBPYmplY3RTdG9yZURhdGEgIiArIHdoZXJlQ2xhdXNlKGtleS5nZXQoKSkpOw0KKyAg ICBib29sIG9rID0gcXVlcnkucHJlcGFyZSgpID09IFNRTFJlc3VsdE9rOw0KICAgICBBU1NFUlRf VU5VU0VEKG9rLCBvayk7IC8vIEZJWE1FOiBCZXR0ZXIgZXJyb3IgaGFuZGxpbmc/CiAKICAgICBi aW5kV2hlcmVDbGF1c2UocXVlcnksIG1faWQsIGtleS5nZXQoKSk7CkBAIC0zMzgsNiArMzUxLDcg QEAgU1FMaXRlRGF0YWJhc2UmIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OnNxbGl0ZURhdGFi YXNlKCkgY29uc3QKICAgICByZXR1cm4gbV9kYXRhYmFzZS0+c3FsaXRlRGF0YWJhc2UoKTsKIH0K IAorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFnZS9J REJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmgKaW5kZXggMzJlZjkyMDMyMjEzMjlmZTVhZTUyN2Ux ZTNhNjc5ZWZjY2U5ZWZmZS4uYjE2MDViMzQ3Y2NhYjM4ZjIxYTVjNGY5MGU4YTVmNWFjMDBhMzVl OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwu aAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5oCkBAIC0y Nyw2ICsyNyw3IEBACiAjZGVmaW5lIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGxfaAogCiAjaW5j bHVkZSAiSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgiCisjaW5jbHVkZSA8U2NyaXB0 RXhlY3V0aW9uQ29udGV4dC5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCkBAIC0zNiw2ICszNyw3IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogY2xhc3MgSURCRGF0YWJhc2VCYWNrZW5kSW1wbDsKIGNsYXNzIElEQkluZGV4QmFj a2VuZEltcGw7CitjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7CiBjbGFzcyBT UUxpdGVEYXRhYmFzZTsKIAogY2xhc3MgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbCA6IHB1Ymxp YyBJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UgewpAQCAtNTEsNyArNTMsNyBAQCBwdWJs aWM6CiAgICAgU3RyaW5nIGtleVBhdGgoKSBjb25zdCB7IHJldHVybiBtX2tleVBhdGg7IH0KICAg ICBQYXNzUmVmUHRyPERPTVN0cmluZ0xpc3Q+IGluZGV4TmFtZXMoKSBjb25zdDsKIAotICAgIHZv aWQgZ2V0KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7 CisgICAgdm9pZCBnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxs YmFja3M+LCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKTsKICAg ICB2b2lkIHB1dChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NS ZWZQdHI8SURCS2V5PiBrZXksIGJvb2wgYWRkT25seSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+ KTsKICAgICB2b2lkIHJlbW92ZShQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElE QkNhbGxiYWNrcz4pOwogCkBAIC02OSw2ICs3MSwyOSBAQCBwcml2YXRlOgogICAgIHZvaWQgbG9h ZEluZGV4ZXMoKTsKICAgICBTUUxpdGVEYXRhYmFzZSYgc3FsaXRlRGF0YWJhc2UoKSBjb25zdDsK IAorICAgIHRlbXBsYXRlIDxjbGFzcyBULCBjbGFzcyBNZXRob2QsIGNsYXNzIFBhcmFtMSwgY2xh c3MgUGFyYW0yPgorICAgIGNsYXNzIElEQlRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29u dGV4dDo6VGFzayB7CisgICAgcHVibGljOgorICAgICAgICBJREJUYXNrKFQqIG9iaiwgTWV0aG9k IG1ldGhvZCwgY29uc3QgUGFyYW0xJiBwYXJhbTEsIGNvbnN0IFBhcmFtMiYgcGFyYW0yKQorICAg ICAgICAgICAgOiBtX29iaihvYmopLCBtX21ldGhvZChtZXRob2QpLCBtX3BhcmFtMShwYXJhbTEp LCBtX3BhcmFtMihwYXJhbTIpIHsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBw ZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikgeworICAgICAgICAgICAgaWYgKG1f b2JqKQorICAgICAgICAgICAgICAgIChtX29iai0+Km1fbWV0aG9kKShtX3BhcmFtMSwgbV9wYXJh bTIsIDApOworICAgICAgICB9CisgICAgcHJpdmF0ZToKKyAgICAgICAgVCogbV9vYmo7CisgICAg ICAgIE1ldGhvZCBtX21ldGhvZDsKKyAgICAgICAgUGFyYW0xIG1fcGFyYW0xOworICAgICAgICBQ YXJhbTIgbV9wYXJhbTI7CisgICAgfTsKKworICAgIHRlbXBsYXRlIDxjbGFzcyBULCBjbGFzcyBN ZXRob2QsIGNsYXNzIFBhcmFtMSwgY2xhc3MgUGFyYW0yPgorICAgIFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQ6OlRhc2sqIG5ld1Rhc2soVCogb2JqZWN0LCBNZXRob2QgbWV0aG9kLCBjb25zdCBQYXJh bTEmIHBhcmFtMSwgY29uc3QgUGFyYW0yJiBwYXJhbTIpIHsKKyAgICAgICAgcmV0dXJuIG5ldyBJ REJUYXNrPFQsIE1ldGhvZCwgUGFyYW0xLCBQYXJhbTIgPihvYmplY3QsIG1ldGhvZCwgcGFyYW0x LCBwYXJhbTIpOworICAgIH0KKwogICAgIFJlZlB0cjxJREJEYXRhYmFzZUJhY2tlbmRJbXBsPiBt X2RhdGFiYXNlOwogCiAgICAgaW50NjRfdCBtX2lkOwpAQCAtNzgsNiArMTAzLDcgQEAgcHJpdmF0 ZToKIAogICAgIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIFJlZlB0cjxJREJJbmRleEJhY2tlbmRJ bXBsPiA+IEluZGV4TWFwOwogICAgIEluZGV4TWFwIG1faW5kZXhlczsKKwogfTsKIAogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0 b3JlQmFja2VuZEludGVyZmFjZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFj a2VuZEludGVyZmFjZS5oCmluZGV4IDIwMGFjMjliYTdjY2ExNTk4MTg1ZTM1OTNiZmE0ZDZmYjYz YTFkNGUuLmMxOTg1NWM3NmRlMWU2MjUyNDM4NTkyMTc3ZTljMDFmNzcyMzIxOWQgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UuaAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTM4 LDYgKzM4LDcgQEAgY2xhc3MgSURCQ2FsbGJhY2tzOwogY2xhc3MgSURCSW5kZXhCYWNrZW5kSW50 ZXJmYWNlOwogY2xhc3MgSURCS2V5OwogY2xhc3MgSURCS2V5UmFuZ2U7CitjbGFzcyBJREJUcmFu c2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7CiBjbGFzcyBTZXJpYWxpemVkU2NyaXB0VmFsdWU7CiAK IGNsYXNzIElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZSA6IHB1YmxpYyBUaHJlYWRTYWZl U2hhcmVkPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gewpAQCAtNDgsNyArNDksNyBA QCBwdWJsaWM6CiAgICAgdmlydHVhbCBTdHJpbmcga2V5UGF0aCgpIGNvbnN0ID0gMDsKICAgICB2 aXJ0dWFsIFBhc3NSZWZQdHI8RE9NU3RyaW5nTGlzdD4gaW5kZXhOYW1lcygpIGNvbnN0ID0gMDsK IAotICAgIHZpcnR1YWwgdm9pZCBnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0 cjxJREJDYWxsYmFja3M+KSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGdldChQYXNzUmVmUHRyPElE QktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4sIElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZSogdHJhbnNhY3Rpb24pID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgcHV0KFBhc3NS ZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiB2YWx1ZSwgUGFzc1JlZlB0cjxJREJLZXk+IGtl eSwgYm9vbCBhZGRPbmx5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pID0gMDsKICAgICB2aXJ0 dWFsIHZvaWQgcmVtb3ZlKFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2Fs bGJhY2tzPikgPSAwOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1Ry YW5zYWN0aW9uTW9uaXRvci5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0 aW9uTW9uaXRvci5jcHAKaW5kZXggZDAyNjA5OTA4YWI1N2NkYzAxZDM5ODY5NWViMjY1MzYzMjM2 MWE5Yi4uMTc2NDczNDQ0MmY4NDZhYzQwNTg0NzhlMjNlNTZmMzhkNWJlMDVlNiAxMDA2NDQKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuY3BwCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcApAQCAtMjgs MTUgKzI4LDEyIEBACiAKICNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKIAorI2luY2x1ZGUg IklEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlLmgiCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAog VmVjdG9yPGludD4qIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6Om1faWRzID0gMDsKIAot Ym9vbCBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpoYXNQZW5kaW5nVHJhbnNhY3Rpb25z KCkKLXsKLSAgICByZXR1cm4gbV9pZHMgJiYgbV9pZHMtPnNpemUoKTsKLX0KLQogdm9pZCBJREJQ ZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjphZGRQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKQog ewogICAgIGlmICghbV9pZHMpCkBAIC00NiwyNiArNDMsMzkgQEAgdm9pZCBJREJQZW5kaW5nVHJh bnNhY3Rpb25Nb25pdG9yOjphZGRQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKQogCiB2b2lkIElE QlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OnJlbW92ZVBlbmRpbmdUcmFuc2FjdGlvbihpbnQg aWQpCiB7Ci0gICAgbV9pZHMtPnJlbW92ZShpZCk7CisgICAgICAgIGlmICghbV9pZHMpCisgICAg ICAgIHJldHVybjsKKworICAgIHNpemVfdCBwb3MgPSBtX2lkcy0+ZmluZChpZCk7CisgICAgaWYg KHBvcyA9PSBub3RGb3VuZCkKKyAgICAgICAgcmV0dXJuOworCisgICAgbV9pZHMtPnJlbW92ZShw b3MpOworCiAgICAgaWYgKCFtX2lkcy0+c2l6ZSgpKSB7CiAgICAgICAgIGRlbGV0ZSBtX2lkczsK ICAgICAgICAgbV9pZHMgPSAwOwogICAgIH0KIH0KIAotdm9pZCBJREJQZW5kaW5nVHJhbnNhY3Rp b25Nb25pdG9yOjpjbGVhclBlbmRpbmdUcmFuc2FjdGlvbnMoKQordm9pZCBJREJQZW5kaW5nVHJh bnNhY3Rpb25Nb25pdG9yOjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoSURCRmFjdG9yeUJhY2tl bmRJbnRlcmZhY2UqIGlkYkZhY3RvcnkpCiB7Ci0gICAgaWYgKCFtX2lkcykKLSAgICAgICAgcmV0 dXJuOwotCi0gICAgbV9pZHMtPmNsZWFyKCk7Ci0gICAgZGVsZXRlIG1faWRzOwotICAgIG1faWRz ID0gMDsKKyAgICBWZWN0b3I8aW50PiBwZW5kaW5nSWRzOworICAgIGlmIChtX2lkcykgeworICAg ICAgcGVuZGluZ0lkcy5zd2FwKCptX2lkcyk7CisgICAgICBkZWxldGUgbV9pZHM7CisgICAgICBt X2lkcyA9IDA7CisgICAgfQorICAgIGlmIChwZW5kaW5nSWRzLnNpemUoKSkgeworICAgICAgICBB U1NFUlQoaWRiRmFjdG9yeSk7CisgICAgICAgIGlkYkZhY3RvcnktPmFib3J0UGVuZGluZ1RyYW5z YWN0aW9ucyhwZW5kaW5nSWRzKTsKKyAgICB9CiB9CiAKLWNvbnN0IFZlY3RvcjxpbnQ+JiBJREJQ ZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpwZW5kaW5nVHJhbnNhY3Rpb25zKCkKK3ZvaWQgSURC UGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlv bihpbnQgaWQsIElEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlKiBpZGJGYWN0b3J5KQogewotICAg IHJldHVybiAqbV9pZHM7CisgICAgLy8gRklYTUU6IGNoZWNrIGlmIHdlIGhhZCBhbnkgZXhjZXB0 aW9uIGR1cmluZyB0aGUgZXZlbnQgYW5kIG5vdGlmeSB0aGUgZmFjdG9yeSB0byBhYm9ydCB0aGUg dHJhbnNhY3Rpb24uCisgICAgaWRiRmFjdG9yeS0+ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2Fj dGlvbihpZCk7CiB9CiAKIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGlu Z1RyYW5zYWN0aW9uTW9uaXRvci5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2Fj dGlvbk1vbml0b3IuaAppbmRleCAwMGU4MzNhZmIyMjE4NTNiZDk5YjM5Mzg0MTUxNjBmM2RjYzdj NmY2Li45ZmQzMjVhYzQwODg4OGY1ZWMyYzEyZDRhMjI5ZmQ3NTkyNDBmNzhmIDEwMDY0NAotLS0g YS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oCisrKyBiL1dl YkNvcmUvc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgKQEAgLTMzLDYgKzMz LDggQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBJREJGYWN0b3J5QmFja2VuZElu dGVyZmFjZTsKKwogLy8gVGhpcyBjbGFzcyBrZWVwcyB0cmFjayBvZiB0aGUgdHJhbnNhY3Rpb25z IGNyZWF0ZWQgZHVyaW5nIHRoZSBjdXJyZW50CiAvLyBKYXZhc2NyaXB0IGV4ZWN1dGlvbiBjb250 ZXh0LiBBIHRyYW5zYWN0aW9uIGlzICdwZW5kaW5nJyBpZiBubyBhc3luY2hyb25vdXMKIC8vIG9w ZXJhdGlvbiBpcyBjdXJyZW50bHkgcXVldWVkIGZvciBpdCAoZS5nLiBhbiBJREJPYmplY3RTdG9y ZTo6cHV0KCkgb3Igc2ltaWxhcikuCkBAIC00NCwxMSArNDYsMTAgQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogLy8gc29sdXRpb24gaXMgdG8ga2VlcCB0aGUgdmVjdG9yIGluIHRoZSBTY3JpcHRFeGVj dXRpb25Db250ZXh0LgogY2xhc3MgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvciA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIGJvb2wgaGFzUGVuZGluZ1RyYW5z YWN0aW9ucygpOwogICAgIHN0YXRpYyB2b2lkIGFkZFBlbmRpbmdUcmFuc2FjdGlvbihpbnQgaWQp OwogICAgIHN0YXRpYyB2b2lkIHJlbW92ZVBlbmRpbmdUcmFuc2FjdGlvbihpbnQgaWQpOwotICAg IHN0YXRpYyB2b2lkIGNsZWFyUGVuZGluZ1RyYW5zYWN0aW9ucygpOwotICAgIHN0YXRpYyBjb25z dCBWZWN0b3I8aW50PiYgcGVuZGluZ1RyYW5zYWN0aW9ucygpOworICAgIHN0YXRpYyB2b2lkIGFi b3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhJREJGYWN0b3J5QmFja2VuZEludGVyZmFjZSopOworICAg IHN0YXRpYyB2b2lkIGRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24oaW50IGlkLCBJREJG YWN0b3J5QmFja2VuZEludGVyZmFjZSopOwogCiBwcml2YXRlOgogICAgIElEQlBlbmRpbmdUcmFu c2FjdGlvbk1vbml0b3IoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0 LmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0LmNwcAppbmRleCA2ZmJkYTBlZWM4OWVi MmFhMDljMjBjM2JkMTNmMGU4ZGQ2MzliZTY0Li4zNjkyNDYxZDQzM2ExMGNmOTQzZDlmM2VlZDQ5 YWVlMWEwNWE0NGJhIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5jcHAK KysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuY3BwCkBAIC0zNSwyMyArMzUsMzAgQEAK ICNpbmNsdWRlICJFdmVudEV4Y2VwdGlvbi5oIgogI2luY2x1ZGUgIkV2ZW50TGlzdGVuZXIuaCIK ICNpbmNsdWRlICJFdmVudE5hbWVzLmgiCisjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJJ REJDdXJzb3IuaCIKICNpbmNsdWRlICJJREJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIklEQkluZGV4 LmgiCiAjaW5jbHVkZSAiSURCRXJyb3JFdmVudC5oIgogI2luY2x1ZGUgIklEQk9iamVjdFN0b3Jl LmgiCisjaW5jbHVkZSAiSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oIgogI2luY2x1ZGUg IklEQlN1Y2Nlc3NFdmVudC5oIgorI2luY2x1ZGUgIlBhZ2UuaCIKKyNpbmNsdWRlICJQYWdlR3Jv dXAuaCIKICNpbmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAotSURCUmVxdWVzdDo6SURCUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBjb250ZXh0LCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlKQorSURCUmVxdWVzdDo6SURCUmVx dWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPElEQkFueT4g c291cmNlLCBpbnQgdHJhbnNhY3Rpb25JZCkKICAgICA6IEFjdGl2ZURPTU9iamVjdChjb250ZXh0 LCB0aGlzKQogICAgICwgbV9zb3VyY2Uoc291cmNlKQorICAgICwgbV90cmFuc2FjdGlvbklkKHRy YW5zYWN0aW9uSWQpCiAgICAgLCBtX3RpbWVyKHRoaXMsICZJREJSZXF1ZXN0Ojp0aW1lckZpcmVk KQogICAgICwgbV9hYm9ydGVkKGZhbHNlKQogICAgICwgbV9yZWFkeVN0YXRlKExPQURJTkcpCiB7 CisgICAgaWYgKHRyYW5zYWN0aW9uSWQpCisgICAgICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1v bml0b3I6OnJlbW92ZVBlbmRpbmdUcmFuc2FjdGlvbihtX3RyYW5zYWN0aW9uSWQpOwogfQogCiBJ REJSZXF1ZXN0Ojp+SURCUmVxdWVzdCgpCkBAIC0xMDAsNyArMTA3LDggQEAgdm9pZCBJREJSZXF1 ZXN0OjpvblN1Y2Nlc3MoUGFzc1JlZlB0cjxJREJLZXk+IGlkYktleSkKIAogdm9pZCBJREJSZXF1 ZXN0OjpvblN1Y2Nlc3MoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+ IGJhY2tlbmQpCiB7Ci0gICAgc2NoZWR1bGVFdmVudChJREJBbnk6OmNyZWF0ZShJREJPYmplY3RT dG9yZTo6Y3JlYXRlKGJhY2tlbmQpKSwgMCk7CisgICAgLy8gRklYTUU6IHRoZSB0cmFuc2FjdGlv biBpZCBzaG91bGQgYmUgdGhlIG9uZSBvZiB0aGUgc2V0VmVyc2lvbiB0cmFuc2FjdGlvbi4KKyAg ICBzY2hlZHVsZUV2ZW50KElEQkFueTo6Y3JlYXRlKElEQk9iamVjdFN0b3JlOjpjcmVhdGUoYmFj a2VuZCwgMCkpLCAwKTsKIH0KIAogdm9pZCBJREJSZXF1ZXN0OjpvblN1Y2Nlc3MoUGFzc1JlZlB0 cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHNlcmlhbGl6ZWRTY3JpcHRWYWx1ZSkKQEAgLTE2MSw2 ICsxNjksMTMgQEAgdm9pZCBJREJSZXF1ZXN0Ojp0aW1lckZpcmVkKFRpbWVyPElEQlJlcXVlc3Q+ KikKICAgICAgICAgICAgIGRpc3BhdGNoRXZlbnQoSURCU3VjY2Vzc0V2ZW50OjpjcmVhdGUobV9z b3VyY2UsIHBlbmRpbmdFdmVudHNbaV0ubV9yZXN1bHQpKTsKICAgICAgICAgfQogICAgIH0KKyAg ICBpZiAobV90cmFuc2FjdGlvbklkID4gMCkgeworICAgICAgICAvLyBOb3cgdGhhdCB3ZSBwcm9j ZXNzZWQgYWxsIHBlbmRpbmcgZXZlbnRzLCBsZXQgdGhlIHRyYW5zYWN0aW9uIG1vbml0b3IKKyAg ICAgICAgLy8gY2hlY2sgaWYgaXQgY2FuIGNvbW1pdCB0aGUgY3VycmVudCB0cmFuc2FjdGlvbiBv ciBpZiB0aGVyZSdzIGFueXRoaW5nCisgICAgICAgIC8vIG5ldyBwZW5kaW5nLgorICAgICAgICBB U1NFUlQoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0RvY3VtZW50KCkpOworICAgICAgICBJ REJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0 aW9uKG1fdHJhbnNhY3Rpb25JZCwgc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihzY3JpcHRFeGVjdXRp b25Db250ZXh0KCkpLT5mcmFtZSgpLT5wYWdlKCktPmdyb3VwKCkuaWRiRmFjdG9yeSgpKTsKKyAg ICB9CiB9CiAKIHZvaWQgSURCUmVxdWVzdDo6c2NoZWR1bGVFdmVudChQYXNzUmVmUHRyPElEQkFu eT4gcmVzdWx0LCBQYXNzUmVmUHRyPElEQkRhdGFiYXNlRXJyb3I+IGVycm9yKQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1 ZXN0LmgKaW5kZXggOWIwZWE3ZWFmMjFjYmVhMjNlNmJkNGE4MDc4MTUyZDg5MzM3YzdkMi4uYTlj ZjI0OGE3Y2RkMGUxYmFmZGVkZDcxZTQ0MjNhMmQ2NzA3MjdiNCAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9zdG9yYWdlL0lEQlJlcXVlc3QuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5o CkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiRXZlbnRUYXJnZXQuaCIKICNpbmNsdWRlICJJ REJBbnkuaCIKICNpbmNsdWRlICJJREJDYWxsYmFja3MuaCIKKyNpbmNsdWRlICJJREJUcmFuc2Fj dGlvbi5oIgogI2luY2x1ZGUgIlRpbWVyLmgiCiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCkBA IC00NCw3ICs0NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgSURCUmVxdWVzdCA6 IHB1YmxpYyBJREJDYWxsYmFja3MsIHB1YmxpYyBFdmVudFRhcmdldCwgcHVibGljIEFjdGl2ZURP TU9iamVjdCB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gY3Jl YXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8SURCQW55PiBz b3VyY2UpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBJREJSZXF1ZXN0KGNvbnRleHQsIHNvdXJjZSkp OyB9CisgICAgc3RhdGljIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gY3JlYXRlKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8SURCQW55PiBzb3VyY2UsIGludCB0cmFu c2FjdGlvbklkID0gMCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IElEQlJlcXVlc3QoY29udGV4dCwg c291cmNlLCB0cmFuc2FjdGlvbklkKSk7IH0KICAgICB2aXJ0dWFsIH5JREJSZXF1ZXN0KCk7CiAK ICAgICAvLyBEZWZpbmVkIGluIHRoZSBJREwKQEAgLTgwLDcgKzgxLDcgQEAgcHVibGljOgogICAg IHVzaW5nIFJlZkNvdW50ZWQ8SURCQ2FsbGJhY2tzPjo6ZGVyZWY7CiAKIHByaXZhdGU6Ci0gICAg SURCUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxJREJBbnk+IHNv dXJjZSk7CisgICAgSURCUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0 cjxJREJBbnk+IHNvdXJjZSwgaW50IHRyYW5zYWN0aW9uSWQpOwogCiAgICAgdm9pZCB0aW1lckZp cmVkKFRpbWVyPElEQlJlcXVlc3Q+Kik7CiAgICAgdm9pZCBzY2hlZHVsZUV2ZW50KFBhc3NSZWZQ dHI8SURCQW55PiByZXN1bHQsIFBhc3NSZWZQdHI8SURCRGF0YWJhc2VFcnJvcj4pOwpAQCAtOTIs NiArOTMsNyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgRXZlbnRUYXJnZXREYXRhKiBlbnN1cmVF dmVudFRhcmdldERhdGEoKTsKIAogICAgIFJlZlB0cjxJREJBbnk+IG1fc291cmNlOworICAgIGlu dCBtX3RyYW5zYWN0aW9uSWQ7CiAKICAgICBzdHJ1Y3QgUGVuZGluZ0V2ZW50IHsKICAgICAgICAg UmVmUHRyPElEQkFueT4gbV9yZXN1bHQ7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURC VHJhbnNhY3Rpb24uY3BwIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uLmNwcAppbmRl eCA0ZTkzMzc4ZGRiN2JlYjJiMmI4NzUzNGJlNjdiMzc0ZGQzMzg0OTU4Li42MzZhNWJlMmJiMDc3 YmE0MzY5YTU0YzFhNGI3ZjBmYTU3ZmMzYWQ0IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uv SURCVHJhbnNhY3Rpb24uY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbi5j cHAKQEAgLTY2LDcgKzY2LDExIEBAIElEQkRhdGFiYXNlKiBJREJUcmFuc2FjdGlvbjo6ZGIoKQog UGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gSURCVHJhbnNhY3Rpb246Om9iamVjdFN0b3JlKGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgRXhjZXB0aW9uQ29kZSYpCiB7CiAgICAgUmVmUHRyPElE Qk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmVCYWNrZW5kID0gbV9iYWNr ZW5kLT5vYmplY3RTdG9yZShuYW1lKTsKLSAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmU+IG9iamVj dFN0b3JlID0gSURCT2JqZWN0U3RvcmU6OmNyZWF0ZShvYmplY3RTdG9yZUJhY2tlbmQpOworICAg IGlmICghb2JqZWN0U3RvcmVCYWNrZW5kLmdldCgpKSB7CisgICAgICAgIHRocm93RXJyb3IoTk9U X1NVUFBPUlRFRF9FUlIpOworICAgICAgICByZXR1cm4gMDsKKyAgICB9CisgICAgUmVmUHRyPElE Qk9iamVjdFN0b3JlPiBvYmplY3RTdG9yZSA9IElEQk9iamVjdFN0b3JlOjpjcmVhdGUob2JqZWN0 U3RvcmVCYWNrZW5kLCBtX2JhY2tlbmQuZ2V0KCkpOwogICAgIHJldHVybiBvYmplY3RTdG9yZS5y ZWxlYXNlKCk7CiB9CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlv bkJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsLmNwcAppbmRleCA1MWIzM2IyMzQwMDE0NzdmM2I2MjlkNGY1NDgyMjI4MDM0ZGM4MWQwLi5k NWFkM2IyYWE1ZTUwNzA3ZTY0MTljNmQ3MTk4NDM0MTJjMjRlNDhiIDEwMDY0NAotLS0gYS9XZWJD b3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5jcHAKKysrIGIvV2ViQ29yZS9z dG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuY3BwCkBAIC0yOSw2ICsyOSw3IEBACiAj aWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAKICNpbmNsdWRlICJJREJEYXRhYmFzZUJhY2tl bmRJbXBsLmgiCisjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1 ZGUgIlNRTGl0ZURhdGFiYXNlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQzLDI2ICs0 NCwxMTAgQEAgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6SURCVHJhbnNhY3Rpb25CYWNrZW5k SW1wbChET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMKICAgICAsIG1fbW9kZShtb2RlKQogICAg ICwgbV90aW1lb3V0KHRpbWVvdXQpCiAgICAgLCBtX2lkKGlkKQotICAgICwgbV9hYm9ydGVkKGZh bHNlKQorICAgICwgbV9zdGFydGVkKGZhbHNlKQorICAgICwgbV9maW5pc2hlZChmYWxzZSkKICAg ICAsIG1fZGF0YWJhc2UoZGF0YWJhc2UpCisgICAgLCBtX3RyYW5zYWN0aW9uKG5ldyBTUUxpdGVU cmFuc2FjdGlvbihkYXRhYmFzZS0+c3FsaXRlRGF0YWJhc2UoKSkpCisgICAgLCBtX3RpbWVyKHRo aXMsICZJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjp0aW1lckZpcmVkKQogewogfQogCiBQYXNz UmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbDo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKQogewotICAgIHJldHVybiBt X2RhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1lLCAwKTsgLy8gRklYTUU6IHJlbW92ZSBtb2RlIHBh cmFtLgorICAgIGlmIChtX2ZpbmlzaGVkKQorICAgICAgICByZXR1cm4gMDsKKyAgICByZXR1cm4g bV9kYXRhYmFzZS0+b2JqZWN0U3RvcmUobmFtZSwgMCwgdGhpcyk7IC8vIEZJWE1FOiByZW1vdmUg bW9kZSBwYXJhbS4KIH0KIAotdm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpzY2hlZHVs ZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPikKK3ZvaWQgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6c2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhl Y3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaykKIHsKLSAgICAvLyBGSVhNRTogaW1wbGVtZW50Lgot ICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIEFTU0VSVCghbV9maW5pc2hlZCk7CisKKyAg ICBtX3Rhc2tRdWV1ZS5hcHBlbmQodGFzayk7CisKKyAgICBpZiAoIW1fc3RhcnRlZCkKKyAgICAg ICAgc3RhcnQoKTsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpzdGVwKCkK K3sKKyAgICBBU1NFUlQobV9zdGFydGVkKTsKKworICAgIGlmICghbV90YXNrUXVldWUuaXNFbXB0 eSgpKSB7CisgICAgICAgIHJ1bigpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgY29t bWl0KCk7CiB9CiAKIHZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6YWJvcnQoKQogewot ICAgIG1fYWJvcnRlZCA9IHRydWU7CisgICAgaWYgKG1fZmluaXNoZWQpCisgICAgICAgIHJldHVy bjsKKworICAgIG1fZmluaXNoZWQgPSB0cnVlOworICAgIG1fdHJhbnNhY3Rpb24tPnJvbGxiYWNr KCk7CiAgICAgbV9jYWxsYmFja3MtPm9uQWJvcnQoKTsKKworICAgIGRpZEZpbmlzaFRyYW5zYWN0 aW9uKCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6cnVuKCkKK3sKKyAg ICBBU1NFUlQobV9zdGFydGVkKTsKKyAgICBBU1NFUlQoIW1fZmluaXNoZWQpOworCisgICAgbV90 aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1w bDo6c3RhcnQoKQoreworICAgIEFTU0VSVCghbV9zdGFydGVkKTsKKyAgICBBU1NFUlQoIW1fZmlu aXNoZWQpOworCisgICAgbV9zdGFydGVkID0gdHJ1ZTsKKyAgICBtX3RyYW5zYWN0aW9uLT5iZWdp bigpOworCisgICAgbV9kYXRhYmFzZS0+dHJhbnNhY3Rpb25Db29yZGluYXRvcigpLT5kaWRTdGFy dFRyYW5zYWN0aW9uKG1faWQpOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6 OnJ1bk5leHRUYXNrcygpCit7CisgICAgQVNTRVJUKCFtX3Rhc2tRdWV1ZS5pc0VtcHR5KCkpOwor ICAgIEFTU0VSVChtX3N0YXJ0ZWQpOworICAgIEFTU0VSVCghbV9maW5pc2hlZCk7CisKKyAgICAv LyBwdW1wIHRoZSB0YXNrIHF1ZXVlIGRyeQorICAgIFRhc2tRdWV1ZSBxdWV1ZTsKKyAgICBxdWV1 ZS5zd2FwKG1fdGFza1F1ZXVlKTsKKyAgICB3aGlsZSAoIXF1ZXVlLmlzRW1wdHkoKSkgeworICAg ICAgICBPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzayhxdWV1ZS5maXJz dCgpLnJlbGVhc2UoKSk7CisgICAgICAgIHF1ZXVlLnJlbW92ZUZpcnN0KCk7CisgICAgICAgIHRh c2stPnBlcmZvcm1UYXNrKDApOworICAgIH0KK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tl bmRJbXBsOjpjb21taXQoKQoreworICAgIEFTU0VSVCghbV9maW5pc2hlZCk7CisgICAgQVNTRVJU KG1fc3RhcnRlZCk7CisKKyAgICBtX2ZpbmlzaGVkID0gdHJ1ZTsKKyAgICBtX3RyYW5zYWN0aW9u LT5jb21taXQoKTsKKworICAgIGRpZEZpbmlzaFRyYW5zYWN0aW9uKCk7Cit9CisKK3ZvaWQgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6ZGlkRmluaXNoVHJhbnNhY3Rpb24oKQoreworICAgIG1f ZGF0YWJhc2UtPnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKS0+ZGlkRmluaXNoVHJhbnNhY3Rpb24o bV9pZCk7CisgICAgbV9kYXRhYmFzZS5jbGVhcigpOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9u QmFja2VuZEltcGw6OnRpbWVyRmlyZWQoVGltZXI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4q KQoreworICAgIHJ1bk5leHRUYXNrcygpOwogfQogCiB9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9z dG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJU cmFuc2FjdGlvbkJhY2tlbmRJbXBsLmgKaW5kZXggZmI1NzQwMTdmYWJlNTI0M2ViNWQ3YzE3YTgy YjBhMjVlNjI4ZTA4Ny4uNTljYmE3ZTU1Y2I4Y2JhY2QxMDZiNjMwMzk2NDI0NTdlNWVmN2EzMCAx MDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuaAor KysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oCkBAIC0zMSw2 ICszMSw4IEBACiAjaW5jbHVkZSAiRE9NU3RyaW5nTGlzdC5oIgogI2luY2x1ZGUgIklEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZS5oIgogI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQ2FsbGJh Y2tzLmgiCisjaW5jbHVkZSA8U1FMaXRlVHJhbnNhY3Rpb24uaD4KKyNpbmNsdWRlIDx3dGYvRGVx dWUuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAg LTQwLDI1ICs0Miw0MSBAQCBjbGFzcyBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOwogY2xhc3MgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbCA6IHB1YmxpYyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2UgewogcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFj a2VuZEludGVyZmFjZT4gY3JlYXRlKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3JlcywgdW5zaWdu ZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBpbnQgaWQsIElEQkRhdGFiYXNl QmFja2VuZEltcGwqKTsKLSAgICB2aXJ0dWFsIH5JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKCkg eyB9CisgICAgdmlydHVhbCB+SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCgpIHsgYWJvcnQoKTsg fQogCiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFj ZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKTsKICAgICB2aXJ0dWFsIHVuc2lnbmVk IHNob3J0IG1vZGUoKSBjb25zdCB7IHJldHVybiBtX21vZGU7IH0KICAgICB2aXJ0dWFsIHZvaWQg c2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOwor ICAgIHZpcnR1YWwgdm9pZCBzdGVwKCk7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0KCk7CisgICAg dmlydHVhbCBib29sIGlzRmluaXNoZWQoKSBjb25zdCB7IHJldHVybiBtX2ZpbmlzaGVkOyB9CiAg ICAgdmlydHVhbCBpbnQgaWQoKSBjb25zdCB7IHJldHVybiBtX2lkOyB9CiAgICAgdmlydHVhbCB2 b2lkIHNldENhbGxiYWNrcyhJREJUcmFuc2FjdGlvbkNhbGxiYWNrcyogY2FsbGJhY2tzKSB7IG1f Y2FsbGJhY2tzID0gY2FsbGJhY2tzOyB9CiAKKyAgICB2b2lkIHJ1bigpOworCiBwcml2YXRlOgog ICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwoRE9NU3RyaW5nTGlzdCogb2JqZWN0U3RvcmVz LCB1bnNpZ25lZCBzaG9ydCBtb2RlLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQsIGludCBpZCwgSURC RGF0YWJhc2VCYWNrZW5kSW1wbCopOwogCisgICAgdm9pZCBzdGFydCgpOworICAgIHZvaWQgcnVu TmV4dFRhc2tzKCk7CisgICAgdm9pZCBjb21taXQoKTsKKyAgICB2b2lkIGRpZEZpbmlzaFRyYW5z YWN0aW9uKCk7CisKKyAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8SURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbD4qKTsKKwogICAgIFJlZlB0cjxET01TdHJpbmdMaXN0PiBtX29iamVjdFN0b3JlTmFt ZXM7CiAgICAgdW5zaWduZWQgc2hvcnQgbV9tb2RlOwogICAgIHVuc2lnbmVkIGxvbmcgbV90aW1l b3V0OwogICAgIGludCBtX2lkOwotICAgIGJvb2wgbV9hYm9ydGVkOworICAgIGJvb2wgbV9zdGFy dGVkOworICAgIGJvb2wgbV9maW5pc2hlZDsKICAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25DYWxs YmFja3M+IG1fY2FsbGJhY2tzOwogICAgIFJlZlB0cjxJREJEYXRhYmFzZUJhY2tlbmRJbXBsPiBt X2RhdGFiYXNlOworICAgIHR5cGVkZWYgRGVxdWU8T3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+ID4gVGFza1F1ZXVlOworICAgIFRhc2tRdWV1ZSBtX3Rhc2tRdWV1ZTsKKyAgICBP d25QdHI8U1FMaXRlVHJhbnNhY3Rpb24+IG1fdHJhbnNhY3Rpb247CisgICAgVGltZXI8SURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbD4gbV90aW1lcjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2Uu aAppbmRleCAzOTY1MWYxMDE3NWRlNzA2MGQwNDVhOWYwYzYyMzkzYzZhZTM3NWRjLi5mOWU1YTM0 ZGQ3YThhYWY1OGFlYWExOGQxNjYwMmZiMjE2YjI2YjMyIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0 b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgKKysrIGIvV2ViQ29yZS9zdG9y YWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oCkBAIC01MSw4ICs1MSwxMCBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKSA9IDA7CiAgICAgdmlydHVhbCB1 bnNpZ25lZCBzaG9ydCBtb2RlKCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBzY2hlZHVs ZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPikgPSAwOworICAg IHZpcnR1YWwgdm9pZCBzdGVwKCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBhYm9ydCgpID0gMDsK ICAgICB2aXJ0dWFsIGludCBpZCgpIGNvbnN0ID0gMDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNGaW5p c2hlZCgpIGNvbnN0ID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKElEQlRyYW5z YWN0aW9uQ2FsbGJhY2tzKikgPSAwOwogfTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdl L0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5z YWN0aW9uQ29vcmRpbmF0b3IuY3BwCmluZGV4IDk3OTBjMWYyZDc5NWY2NjA2ZDYxNGI0MDNiNDNm MzYyZmJmMWIwZWMuLjBjNTE2YmM3OGM0OTlmNDFlNGIyZTcyOWIzN2ZjMWQxYjM1MDliZjAgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcAor KysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHAKQEAgLTMw LDYgKzMwLDcgQEAKIAogI2luY2x1ZGUgIklEQkRhdGFiYXNlQmFja2VuZEltcGwuaCIKICNpbmNs dWRlICJJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UuaCIKKyNpbmNsdWRlICJJREJQZW5k aW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgiCiAjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25CYWNrZW5k SW1wbC5oIgogI2luY2x1ZGUgIlNRTGl0ZURhdGFiYXNlLmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhl Y3V0aW9uQ29udGV4dC5oIgpAQCAtNDgsMjAgKzQ5LDk1IEBAIElEQlRyYW5zYWN0aW9uQ29vcmRp bmF0b3I6On5JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkKIFBhc3NSZWZQdHI8SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpjcmVhdGVU cmFuc2FjdGlvbihET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1v ZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCwgSURCRGF0YWJhc2VCYWNrZW5kSW1wbCogZGF0YWJh c2UpCiB7CiAgICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNh Y3Rpb24gPSBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpjcmVhdGUob2JqZWN0U3RvcmVzLCBt b2RlLCB0aW1lb3V0LCArK21fbmV4dElELCBkYXRhYmFzZSk7Ci0gICAgbV90cmFuc2FjdGlvblF1 ZXVlLmFkZCh0cmFuc2FjdGlvbi5nZXQoKSk7Ci0gICAgbV9pZE1hcC5hZGQobV9uZXh0SUQsIHRy YW5zYWN0aW9uKTsKKyAgICBtX3BlbmRpbmdUcmFuc2FjdGlvbnMuYWRkKG1fbmV4dElELCB0cmFu c2FjdGlvbik7CiAgICAgcmV0dXJuIHRyYW5zYWN0aW9uLnJlbGVhc2UoKTsKIH0KIAotdm9pZCBJ REJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjphYm9ydChpbnQgaWQpCit2b2lkIElEQlRyYW5zYWN0 aW9uQ29vcmRpbmF0b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBWZWN0b3I8aW50 PiYgcGVuZGluZ0lEcykKIHsKLSAgICBBU1NFUlQobV9pZE1hcC5jb250YWlucyhpZCkpOwotICAg IFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uID0gbV9p ZE1hcC5nZXQoaWQpOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcGVuZGluZ0lEcy5zaXpl KCk7ICsraSkgeworICAgICAgICBpbnQgaWQgPSBwZW5kaW5nSURzLmF0KGkpOworICAgICAgICBB U1NFUlQobV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKGlkKSk7CisgICAgICAgIFJlZlB0 cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uID0gbV9wZW5kaW5n VHJhbnNhY3Rpb25zLmdldChpZCk7CisgICAgICAgIEFTU0VSVCh0cmFuc2FjdGlvbik7CisgICAg ICAgIHRyYW5zYWN0aW9uLT5hYm9ydCgpOworICAgIH0KK30KKwordm9pZCBJREJUcmFuc2FjdGlv bkNvb3JkaW5hdG9yOjpkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKGludCB0cmFuc2Fj dGlvbklEKQoreworICAgIGlmIChtX3J1bm5pbmdUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNh Y3Rpb25JRCkpIHsKKyAgICAgIFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+ IHRyYW5zYWN0aW9uID0gbV9ydW5uaW5nVHJhbnNhY3Rpb25zLmdldCh0cmFuc2FjdGlvbklEKTsK KyAgICAgIEFTU0VSVCh0cmFuc2FjdGlvbik7CisgICAgICB0cmFuc2FjdGlvbi0+c3RlcCgpOwor ICAgIH0KK30KKworSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiBJREJUcmFuc2FjdGlv bkNvb3JkaW5hdG9yOjp0cmFuc2FjdGlvbihpbnQgdHJhbnNhY3Rpb25JRCkKK3sKKyAgICBpZiAo bV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKHRyYW5zYWN0aW9uSUQpKQorICAgICAgICBy ZXR1cm4gbV9wZW5kaW5nVHJhbnNhY3Rpb25zLmdldCh0cmFuc2FjdGlvbklEKS5nZXQoKTsKKwor ICAgIGlmIChtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNhY3Rpb25JRCkpCisg ICAgICAgIHJldHVybiBtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuZ2V0KHRyYW5zYWN0aW9uSUQpLmdl dCgpOworCisgICAgaWYgKG1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250YWlucyh0cmFuc2FjdGlv bklEKSkKKyAgICAgICAgcmV0dXJuIG1fcnVubmluZ1RyYW5zYWN0aW9ucy5nZXQodHJhbnNhY3Rp b25JRCkuZ2V0KCk7CisKKyAgICByZXR1cm4gMDsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkNv b3JkaW5hdG9yOjpkaWRTdGFydFRyYW5zYWN0aW9uKGludCBpZCkKK3sKKyAgICAvLyBSZW1vdmUg ZnJvbSBwZW5kaW5nIHRyYW5zYWN0aW9ucyBsaXN0CisgICAgQVNTRVJUKG1fcGVuZGluZ1RyYW5z YWN0aW9ucy5jb250YWlucyhpZCkpOworICAgIFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bnRlcmZhY2U+IHRyYW5zYWN0aW9uID0gbV9wZW5kaW5nVHJhbnNhY3Rpb25zLmdldChpZCk7CiAg ICAgQVNTRVJUKHRyYW5zYWN0aW9uKTsKLSAgICBtX3RyYW5zYWN0aW9uUXVldWUucmVtb3ZlKHRy YW5zYWN0aW9uLmdldCgpKTsKLSAgICBtX2lkTWFwLnJlbW92ZShpZCk7Ci0gICAgdHJhbnNhY3Rp b24tPmFib3J0KCk7Ci0gICAgLy8gRklYTUU6IHRoaXMgd2lsbCBjaGFuZ2Ugb25jZSB3ZSBoYXZl IHRyYW5zYWN0aW9ucyBhY3R1YWxseSBydW5uaW5nLgorICAgIG1fcGVuZGluZ1RyYW5zYWN0aW9u cy5yZW1vdmUoaWQpOworICAgIC8vIEFkZCB0byBzdGFydGVkIHRyYW5zYWN0aW9ucyBsaXN0Cisg ICAgbV9zdGFydGVkVHJhbnNhY3Rpb25RdWV1ZS5hZGQodHJhbnNhY3Rpb24uZ2V0KCkpOworICAg IG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5hZGQoaWQsIHRyYW5zYWN0aW9uLnJlbGVhc2UoKSk7CisK KyAgICBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucygpOworfQorCit2b2lkIElEQlRyYW5zYWN0 aW9uQ29vcmRpbmF0b3I6OmRpZEZpbmlzaFRyYW5zYWN0aW9uKGludCBpZCkKK3sKKyAgICBpZiAo bV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKGlkKSkgeworICAgICAgICBBU1NFUlQoIW1f c3RhcnRlZFRyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpOworICAgICAgICBBU1NFUlQoIW1fcnVu bmluZ1RyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpOworICAgICAgICBtX3BlbmRpbmdUcmFuc2Fj dGlvbnMucmVtb3ZlKGlkKTsKKyAgICB9IGVsc2UgaWYgKG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5j b250YWlucyhpZCkpIHsKKyAgICAgICAgQVNTRVJUKCFtX3J1bm5pbmdUcmFuc2FjdGlvbnMuY29u dGFpbnMoaWQpKTsKKyAgICAgICAgbV9zdGFydGVkVHJhbnNhY3Rpb25zLnJlbW92ZShpZCk7Cisg ICAgfSBlbHNlIHsKKyAgICAgICAgQVNTRVJUKG1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250YWlu cyhpZCkpOworICAgICAgICBtX3J1bm5pbmdUcmFuc2FjdGlvbnMucmVtb3ZlKGlkKTsKKyAgICB9 CisKKyAgICBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucygpOworfQorCit2b2lkIElEQlRyYW5z YWN0aW9uQ29vcmRpbmF0b3I6OnByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKCkKK3sKKyAgICAv LyBGSVhNRTogdGhpcyB3b3VsZCBhbGxvY2F0ZSBhIHRocmVhZCB0byB0aGUgbmV4dCB0cmFuc2Fj dGlvbgorICAgIC8vIHRoYXQncyByZWFkeSB0byBydW4uIEZvciBub3cgd2Ugb25seSBoYXZlIGEg c2luZ2xlIHJ1bm5pbmcKKyAgICAvLyB0cmFuc2FjdGlvbi4KKyAgICBpZiAobV9zdGFydGVkVHJh bnNhY3Rpb25zLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGlmICghbV9ydW5uaW5n VHJhbnNhY3Rpb25zLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gUmVtb3Zl IGZyb20gc3RhcnRlZCB0cmFuc2FjdGlvbnMgbGlzdC4KKyAgICBJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uUHRyID0gKihtX3N0YXJ0ZWRUcmFuc2FjdGlvblF1ZXVl LmJlZ2luKCkpOworICAgIG1fc3RhcnRlZFRyYW5zYWN0aW9uUXVldWUucmVtb3ZlKHRyYW5zYWN0 aW9uUHRyKTsKKyAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiB0cmFu c2FjdGlvbiA9IG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5nZXQodHJhbnNhY3Rpb25QdHItPmlkKCkp OworICAgIG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5yZW1vdmUodHJhbnNhY3Rpb24tPmlkKCkpOwor ICAgIC8vIEFkZCB0byBydW5uaW5nIHRyYW5zYWN0aW9ucyBsaXN0LgorICAgIG1fcnVubmluZ1Ry YW5zYWN0aW9ucy5hZGQodHJhbnNhY3Rpb24tPmlkKCksIHRyYW5zYWN0aW9uKTsKKworICAgIC8v IEZJWE1FOiBpcyB0aGVyZSBhIGJldHRlciB3YXkgdGhhbiBjYXN0aW5nPworICAgIHN0YXRpY19j YXN0PElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqPih0cmFuc2FjdGlvblB0ciktPnJ1bigpOwog fQogCiB9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRp bmF0b3IuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgKaW5k ZXggMTA0YTk1NjZjZWNlZGMzMmFlNmMwNTJhYzc3Nzc1NGE2MjExODIzZC4uZTIzODlhZDE1MGNl YzRkOTA3YmFlZDUzMzU1NWJlZDEwMGI4MDEzMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdl L0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJh bnNhY3Rpb25Db29yZGluYXRvci5oCkBAIC01NSwxNCArNTUsMjQgQEAgcHVibGljOgogICAgIHZp cnR1YWwgfklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKTsKIAogICAgIFBhc3NSZWZQdHI8SURC VHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBjcmVhdGVUcmFuc2FjdGlvbihET01TdHJpbmdM aXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGlt ZW91dCwgSURCRGF0YWJhc2VCYWNrZW5kSW1wbCopOwotICAgIHZvaWQgYWJvcnQoaW50IHRyYW5z YWN0aW9uSWQpOworICAgIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFZlY3Rv cjxpbnQ+JiBwZW5kaW5nSURzKTsKKyAgICB2b2lkIGRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNh Y3Rpb24oaW50IHRyYW5zYWN0aW9uSUQpOworICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZSogdHJhbnNhY3Rpb24oaW50IHRyYW5zYWN0aW9uSUQpOworCisgICAgLy8gQ2FsbGVkIGJ5 IHRyYW5zYWN0aW9ucyBhcyB0aGV5IHN0YXJ0IGFuZCBmaW5pc2guCisgICAgdm9pZCBkaWRTdGFy dFRyYW5zYWN0aW9uKGludCBpZCk7CisgICAgdm9pZCBkaWRGaW5pc2hUcmFuc2FjdGlvbihpbnQg aWQpOwogCiBwcml2YXRlOgogICAgIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKTsKIAotICAg IExpc3RIYXNoU2V0PElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSo+IG1fdHJhbnNhY3Rp b25RdWV1ZTsKKyAgICB2b2lkIHByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKCk7CisKKyAgICBM aXN0SGFzaFNldDxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqPiBtX3N0YXJ0ZWRUcmFu c2FjdGlvblF1ZXVlOwogICAgIHR5cGVkZWYgSGFzaE1hcDxpbnQsIFJlZlB0cjxJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbnRlcmZhY2U+ID4gSWRUb1RyYW5zYWN0aW9uTWFwOwotICAgIElkVG9UcmFu c2FjdGlvbk1hcCBtX2lkTWFwOworICAgIElkVG9UcmFuc2FjdGlvbk1hcCBtX3BlbmRpbmdUcmFu c2FjdGlvbnM7CisgICAgSWRUb1RyYW5zYWN0aW9uTWFwIG1fc3RhcnRlZFRyYW5zYWN0aW9uczsK KyAgICBJZFRvVHJhbnNhY3Rpb25NYXAgbV9ydW5uaW5nVHJhbnNhY3Rpb25zOwogICAgIGludCBt X25leHRJRDsKIH07CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9X ZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDQ3YjBlNjNkMDgwYjcxYjEyNjQ4ODM4ZTJl MDYxMTQyYjdmNWNkZWMuLmVlYzcxMWQxOGI4YzIyMzI1NTkwNTlmM2FmZTY4OTQ5ODczODFlY2Eg MTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM5IEBACisyMDEwLTA5LTIwICBBbmRyZWkgUG9wZXNj dSAgPGFuZHJlaXBAZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBJREJPYmplY3RTdG9yZTo6Z2V0IHNob3VsZCBydW4gaW4gYSB0cmFu c2FjdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTQ0NzAwCisKKyAgICAgICAgKiBwdWJsaWMvV2ViSURCRmFjdG9yeS5oOgorICAgICAgICAoV2Vi S2l0OjpXZWJJREJGYWN0b3J5OjpkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKToKKyAg ICAgICAgKiBwdWJsaWMvV2ViSURCT2JqZWN0U3RvcmUuaDoKKyAgICAgICAgKFdlYktpdDo6V2Vi SURCT2JqZWN0U3RvcmU6OmdldCk6CisgICAgICAgICogcHVibGljL1dlYklEQlRyYW5zYWN0aW9u Lmg6CisgICAgICAgICogc3JjL0lEQkRhdGFiYXNlUHJveHkuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6SURCRGF0YWJhc2VQcm94eTo6b2JqZWN0U3RvcmUpOgorICAgICAgICAqIHNyYy9JREJEYXRh YmFzZVByb3h5Lmg6CisgICAgICAgICogc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6SURCRmFjdG9yeUJhY2tlbmRQcm94eTo6YWJvcnRQZW5kaW5nVHJh bnNhY3Rpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OklEQkZhY3RvcnlCYWNrZW5kUHJveHk6OmRp ZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24pOgorICAgICAgICAqIHNyYy9JREJGYWN0b3J5 QmFja2VuZFByb3h5Lmg6CisgICAgICAgICogc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVQcm94eTo6Z2V0KToKKyAgICAgICAgKiBz cmMvSURCT2JqZWN0U3RvcmVQcm94eS5oOgorICAgICAgICAqIHNyYy9JREJUcmFuc2FjdGlvbkJh Y2tlbmRQcm94eS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRQ cm94eTo6c3RlcCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94 eTo6aXNGaW5pc2hlZCk6CisgICAgICAgICogc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5 Lmg6CisgICAgICAgICogc3JjL1dlYklEQkZhY3RvcnlJbXBsLmNwcDoKKyAgICAgICAgKFdlYktp dDo6V2ViSURCRmFjdG9yeUltcGw6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24pOgor ICAgICAgICAqIHNyYy9XZWJJREJGYWN0b3J5SW1wbC5oOgorICAgICAgICAqIHNyYy9XZWJJREJP YmplY3RTdG9yZUltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJJREJPYmplY3RTdG9yZUlt cGw6OmdldCk6CisgICAgICAgICogc3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5oOgorICAgICAg ICAqIHNyYy9XZWJJREJUcmFuc2FjdGlvbkltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJJ REJUcmFuc2FjdGlvbkltcGw6Om9wZXJhdG9yIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFj ZSopOgorICAgICAgICAqIHNyYy9XZWJJREJUcmFuc2FjdGlvbkltcGwuaDoKKwogMjAxMC0wOS0x OSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAg VW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY3NzQ5LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJJREJGYWN0b3J5LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklE QkZhY3RvcnkuaAppbmRleCBhYjA1YjA2NGQ2ZTk0ZjI4YzBmODYyOTRlMzk5ZWU1ZDk1OWY1ZjFl Li40Mzc2ODNmNWQ3ZDM2MzQ0YWU2NTQwZTYxMzViMzMwNmI0NWRiM2M0IDEwMDc1NQotLS0gYS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQkZhY3RvcnkuaAorKysgYi9XZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYklEQkZhY3RvcnkuaApAQCAtNjMsNiArNjMsNyBAQCBwdWJsaWM6CiAgICAg fQogCiAgICAgdmlydHVhbCB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBXZWJW ZWN0b3I8aW50PiYgcGVuZGluZ0lEcykgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0K KyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgY3Vy cmVudElEKSB7IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQogfTsKIAogfSAvLyBuYW1l c3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQk9i amVjdFN0b3JlLmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQk9iamVjdFN0b3JlLmgK aW5kZXggNzQ1MmJlOTliNDBjMGJkMjI2OTUwNDI3MTBjOWRhOGJmOWIyMDlkMC4uN2JhNzgxMDc3 NzJlZGJhYWZlZWQzOWY4NjlmOTVlMjdhNDA0NGM1ZCAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJJREJPYmplY3RTdG9yZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJs aWMvV2ViSURCT2JqZWN0U3RvcmUuaApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgIldlYkNv bW1vbi5oIgogI2luY2x1ZGUgIldlYkRPTVN0cmluZ0xpc3QuaCIKICNpbmNsdWRlICJXZWJJREJD YWxsYmFja3MuaCIKKyNpbmNsdWRlICJXZWJJREJUcmFuc2FjdGlvbi5oIgogI2luY2x1ZGUgIldl YlN0cmluZy5oIgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAgLTU1LDcgKzU2LDcgQEAgcHVibGlj OgogICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgIHJldHVybiBX ZWJET01TdHJpbmdMaXN0KCk7CiAgICAgfQotICAgIHZpcnR1YWwgdm9pZCBnZXQoY29uc3QgV2Vi SURCS2V5JiBrZXksIFdlYklEQkNhbGxiYWNrcyopCisgICAgdmlydHVhbCB2b2lkIGdldChjb25z dCBXZWJJREJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tzKiwgY29uc3QgV2ViSURCVHJhbnNhY3Rp b24mKQogICAgIHsKICAgICAgICAgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAgIH0K ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCVHJhbnNhY3Rpb24uaCBi L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCVHJhbnNhY3Rpb24uaAppbmRleCAwMzY5Yjg5 OWI1NjkxM2JkNmQxNzk2NzRmMjBiMmYwOGMwZWE1MjFjLi5iMWExY2ZmODM0ZjY2MDIwYjdmMmIy MzFjZGUxZjQ2NTI1YzZhNjQ0IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YklEQlRyYW5zYWN0aW9uLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJUcmFu c2FjdGlvbi5oCkBAIC0yOCw2ICsyOCw4IEBACiAKICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKIAor bmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7 IH0KKwogbmFtZXNwYWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYklEQk9iamVjdFN0b3JlOwpAQCAt NTUsNiArNTcsMTEgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gMDsKICAgICB9CiAgICAgdmly dHVhbCB2b2lkIHNldENhbGxiYWNrcyhXZWJJREJUcmFuc2FjdGlvbkNhbGxiYWNrcyopIHsgV0VC S0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04K KyAgICB2aXJ0dWFsIG9wZXJhdG9yIFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZSooKSBjb25zdCA9IDA7CisjZW5kaWYKKwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0 CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuY3BwIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmNwcAppbmRleCBjZTVlMGE2Y2Nm ZDMyMGJiZTYzN2UzZGY3YmFjMjc5YThiZmIzOGQ2Li45NTRlN2Q5MGQ3MzMzM2JkODY1ZDg3M2Ez N2Q2ODQ4YmM5YmZhMjY4IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFi YXNlUHJveHkuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJhc2VQcm94eS5j cHAKQEAgLTgxLDcgKzgxLDcgQEAgdm9pZCBJREJEYXRhYmFzZVByb3h5OjpjcmVhdGVPYmplY3RT dG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYga2V5UGEKICAgICBtX3dlYklE QkRhdGFiYXNlLT5jcmVhdGVPYmplY3RTdG9yZShuYW1lLCBrZXlQYXRoLCBhdXRvSW5jcmVtZW50 LCBuZXcgV2ViSURCQ2FsbGJhY2tzSW1wbChjYWxsYmFja3MpKTsKIH0KIAotUGFzc1JlZlB0cjxJ REJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IElEQkRhdGFiYXNlUHJveHk6Om9iamVjdFN0 b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSkKK1Bhc3NSZWZQdHI8 SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBJREJEYXRhYmFzZVByb3h5OjpvYmplY3RT dG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUsIElEQlRyYW5zYWN0 aW9uQmFja2VuZEludGVyZmFjZSopCiB7CiAgICAgV2ViS2l0OjpXZWJJREJPYmplY3RTdG9yZSog b2JqZWN0U3RvcmUgPSBtX3dlYklEQkRhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1lLCBtb2RlKTsK ICAgICBpZiAoIW9iamVjdFN0b3JlKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9J REJEYXRhYmFzZVByb3h5LmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFiYXNlUHJveHku aAppbmRleCA0MmE3ZDdlYzU2YTI2MjgyMTgwZDc2YzgzZjIzNmQxODdmZTQ0NzdjLi4yNDcxYjhm ODliZTY4ZjY3ZmU1MjY2OWQ1YjRiNGVjZTA0NTg1ODlkIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lE QkRhdGFiYXNlUHJveHkuaApAQCAtNDcsMTAgKzQ3LDEwIEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IFN0cmluZyB2ZXJzaW9uKCkgY29uc3Q7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPERPTVN0cmlu Z0xpc3Q+IG9iamVjdFN0b3JlcygpIGNvbnN0OwogCi0gICAgLy8gRklYTUU6IEFkZCB0cmFuc2Fj dGlvbiBhbmQgc2V0VmVyc2lvbi4KKyAgICAvLyBGSVhNRTogQWRkIHNldFZlcnNpb24uCiAKICAg ICB2aXJ0dWFsIHZvaWQgY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIGtleVBhdGgsIGJvb2wgYXV0b0luY3JlbWVudCwgUGFzc1JlZlB0cjxJREJDYWxs YmFja3M+KTsKLSAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50 ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1v ZGUpOworICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZh Y2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSwg SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbiA9IDApOwogICAgIHZp cnR1YWwgdm9pZCByZW1vdmVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NSZWZQ dHI8SURCQ2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCB2b2lkIHNldFZlcnNpb24oY29uc3QgU3Ry aW5nJiB2ZXJzaW9uLCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwogICAgIHZpcnR1YWwgUGFz c1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uKERPTVN0 cmluZ0xpc3QqIHN0b3JlTmFtZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcg dGltZW91dCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNr ZW5kUHJveHkuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJGYWN0b3J5QmFja2VuZFByb3h5 LmNwcAppbmRleCAxODEwMWU0ODkzMzUwMmRlMDYyNDk2ZWQ2MDFmOGUyZGIwMGExMDgyLi45MTg5 YWRiODQzOWRmNTNhMmIwY2UzOWJhY2YxYWNkMmVmODI3NDFiIDEwMDc1NQotLS0gYS9XZWJLaXQv Y2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuY3BwCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5jcHAKQEAgLTY5LDEwICs2OSwxNCBAQCB2 b2lkIElEQkZhY3RvcnlCYWNrZW5kUHJveHk6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25z dCBWZWN0b3I8aW50PiYgcGVuZGluZwogewogICAgIEFTU0VSVChwZW5kaW5nSURzLnNpemUoKSk7 CiAgICAgV2ViS2l0OjpXZWJWZWN0b3I8aW50PiBpZHMgPSBwZW5kaW5nSURzOwotCiAgICAgbV93 ZWJJREJGYWN0b3J5LT5hYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoaWRzKTsKIH0KIAordm9pZCBJ REJGYWN0b3J5QmFja2VuZFByb3h5OjpkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKGlu dCB0cmFuc2FjdGlvbklEKQoreworICAgIG1fd2ViSURCRmFjdG9yeS0+ZGlkQ29tcGxldGVFdmVu dHNGb3JUcmFuc2FjdGlvbih0cmFuc2FjdGlvbklEKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKElOREVYRURfREFUQUJBU0UpCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaCBiL1dlYktpdC9jaHJv bWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5oCmluZGV4IGFjMzBjZjJmODNiNjJiOTNj NDdmYTE4ZDg4MTk5YTY0MjY1ODdhZGYuLjVkYTM1YWMyMzMxMDUxZDUyZjFiZmZmZjM5MGNhOWJj NmQ1MDk4NzMgMTAwNzU1Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tl bmRQcm94eS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94 eS5oCkBAIC00Nyw2ICs0Nyw3IEBAIHB1YmxpYzoKICAgICBQYXNzUmVmUHRyPERPTVN0cmluZ0xp c3Q+IGRhdGFiYXNlcyh2b2lkKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgb3Blbihjb25zdCBT dHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24sIFBhc3NSZWZQdHI8SURCQ2Fs bGJhY2tzPiwgUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4sIEZyYW1lKiwgY29uc3QgU3RyaW5n JiBkYXRhRGlyKTsKICAgICB2aXJ0dWFsIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNv bnN0IFZlY3RvcjxpbnQ+JiBwZW5kaW5nSURzKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tcGxl dGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgdHJhbnNhY3Rpb25JRCk7CiAKIHByaXZhdGU6CiAg ICAgSURCRmFjdG9yeUJhY2tlbmRQcm94eSgpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVt L3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2Jq ZWN0U3RvcmVQcm94eS5jcHAKaW5kZXggYWQyN2ZhMzQxYzViYzdjODljN2QwOGEyN2I1NWQxODMy OGRmMmIwMi4uN2JjODQzMDg2MjMyYWQ2NzgyM2JjY2JkYjg2OThiZTdkOWMxMzc4ZCAxMDA3NTUK LS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmNwcAorKysgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuY3BwCkBAIC0zMCwxMSArMzAs MTMgQEAKICNpbmNsdWRlICJJREJDYWxsYmFja3MuaCIKICNpbmNsdWRlICJJREJJbmRleEJhY2tl bmRQcm94eS5oIgogI2luY2x1ZGUgIklEQktleVJhbmdlLmgiCisjaW5jbHVkZSAiSURCVHJhbnNh Y3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5jbHVkZSAiV2ViSURCQ2FsbGJhY2tzSW1wbC5o IgogI2luY2x1ZGUgIldlYklEQktleVJhbmdlLmgiCiAjaW5jbHVkZSAiV2ViSURCSW5kZXguaCIK ICNpbmNsdWRlICJXZWJJREJLZXkuaCIKICNpbmNsdWRlICJXZWJJREJPYmplY3RTdG9yZS5oIgor I2luY2x1ZGUgIldlYklEQlRyYW5zYWN0aW9uSW1wbC5oIgogI2luY2x1ZGUgIldlYlNlcmlhbGl6 ZWRTY3JpcHRWYWx1ZS5oIgogCiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCkBAIC03MCw5 ICs3MiwxMCBAQCBQYXNzUmVmUHRyPERPTVN0cmluZ0xpc3Q+IElEQk9iamVjdFN0b3JlUHJveHk6 OmluZGV4TmFtZXMoKSBjb25zdAogICAgIHJldHVybiBtX3dlYklEQk9iamVjdFN0b3JlLT5pbmRl eE5hbWVzKCk7CiB9CiAKLXZvaWQgSURCT2JqZWN0U3RvcmVQcm94eTo6Z2V0KFBhc3NSZWZQdHI8 SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit2b2lkIElE Qk9iamVjdFN0b3JlUHJveHk6OmdldChQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRy PElEQkNhbGxiYWNrcz4gY2FsbGJhY2tzLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2Uq IHRyYW5zYWN0aW9uKQogewotICAgIG1fd2ViSURCT2JqZWN0U3RvcmUtPmdldChrZXksIG5ldyBX ZWJJREJDYWxsYmFja3NJbXBsKGNhbGxiYWNrcykpOworICAgIE93blB0cjxXZWJLaXQ6OldlYklE QlRyYW5zYWN0aW9uSW1wbD4gdHJhbnNQdHIgPSBhZG9wdFB0cihuZXcgV2ViS2l0OjpXZWJJREJU cmFuc2FjdGlvbkltcGwodHJhbnNhY3Rpb24pKTsKKyAgICBtX3dlYklEQk9iamVjdFN0b3JlLT5n ZXQoa2V5LCBuZXcgV2ViSURCQ2FsbGJhY2tzSW1wbChjYWxsYmFja3MpLCAqdHJhbnNQdHIpOwog fQogCiB2b2lkIElEQk9iamVjdFN0b3JlUHJveHk6OnB1dChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRT Y3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIGJvb2wgYWRkT25seSwg UGFzc1JlZlB0cjxJREJDYWxsYmFja3M+IGNhbGxiYWNrcykKZGlmZiAtLWdpdCBhL1dlYktpdC9j aHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9J REJPYmplY3RTdG9yZVByb3h5LmgKaW5kZXggYTMzNDU3MmI2ZjM2YzFlMDA0ODJjMDRkMGEwN2I2 NWFhYmY1OTlhMS4uMTNkZmUyMzZkZTZlZTQ1YzVhNWYxOGM0NjY3NjE2N2Q0NDIzMGJiMiAxMDA3 NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmgKKysrIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmgKQEAgLTQ2LDcgKzQ2LDcg QEAgcHVibGljOgogICAgIFN0cmluZyBrZXlQYXRoKCkgY29uc3Q7CiAgICAgUGFzc1JlZlB0cjxE T01TdHJpbmdMaXN0PiBpbmRleE5hbWVzKCkgY29uc3Q7CiAKLSAgICB2b2lkIGdldChQYXNzUmVm UHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOworICAgIHZvaWQgZ2V0 KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiwgSURCVHJh bnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKik7CiAgICAgdm9pZCBwdXQoUGFzc1JlZlB0cjxTZXJp YWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBQYXNzUmVmUHRyPElEQktleT4ga2V5LCBib29sIGFk ZE9ubHksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAgICAgdm9pZCByZW1vdmUoUGFzc1Jl ZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKIApkaWZmIC0tZ2l0 IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5jcHAgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcAppbmRleCBi ZTZiMDU4ZTUyZTI0Mjc1ODM0ODcwOWRiMDAxY2QwNDFjNTY5NmU4Li43OGI1MDlmOWVhYmQyNDZh YTJiOTJjMjQzYzZkYjRkZDcxODA3YzYxIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3Jj L0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3Jj L0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcApAQCAtNzYsNiArNzYsMTcgQEAgdm9pZCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6c2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0 RXhlY3V0aW9uQ29udGV4dDoKICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKIH0KIAordm9pZCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6c3RlcCgpCit7CisgICAgQVNTRVJUX05PVF9SRUFD SEVEKCk7Cit9CisKK2Jvb2wgSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OmlzRmluaXNoZWQo KSBjb25zdAoreworICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiB0cnVlOwor fQorCiBpbnQgSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OmlkKCkgY29uc3QKIHsKICAgICBy ZXR1cm4gbV93ZWJJREJUcmFuc2FjdGlvbi0+aWQoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaCBiL1dlYktpdC9jaHJvbWl1bS9z cmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaAppbmRleCBkNjJiOGZmN2I4NDFhMmEzZjky YTJjNjdhNzAwZGU2MzgzNWZlMzAyLi4yZGEzM2I4ODg3Yzg3NDhkZWU1Yjk1MjI5ODIwYmM3MmVj OTQzNWNmIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFj a2VuZFByb3h5LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tl bmRQcm94eS5oCkBAIC00Niw3ICs0Niw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHVuc2lnbmVk IHNob3J0IG1vZGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgYWJvcnQoKTsKICAgICB2aXJ0 dWFsIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6 VGFzaz4pOworICAgIHZpcnR1YWwgdm9pZCBzdGVwKCk7CiAgICAgdmlydHVhbCBpbnQgaWQoKSBj b25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNGaW5pc2hlZCgpIGNvbnN0OwogICAgIHZpcnR1YWwg dm9pZCBzZXRDYWxsYmFja3MoSURCVHJhbnNhY3Rpb25DYWxsYmFja3MqKTsKIAogcHJpdmF0ZToK ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuY3BwIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJGYWN0b3J5SW1wbC5jcHAKaW5kZXggM2M4ZDQ1OWEw YTllNTI4Mzc1OTZmNTY0MWMyMjg0M2FlMDlkYmFlNy4uM2UzYzQzMWNhM2Y4ZTYzNzE2NTQ1M2Zj Y2JjYmIwZjA1ZmNiZGYwNCAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJG YWN0b3J5SW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJGYWN0b3J5SW1w bC5jcHAKQEAgLTcyLDYgKzcyLDExIEBAIHZvaWQgV2ViSURCRmFjdG9yeUltcGw6OmFib3J0UGVu ZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBXZWJWZWN0b3I8aW50PiYgcGVuZGluZ0lECiAgICAgbV9p ZGJGYWN0b3J5QmFja2VuZC0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGlkcyk7CiB9CiAKK3Zv aWQgV2ViSURCRmFjdG9yeUltcGw6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24oaW50 IHRyYW5zYWN0aW9uSUQpCit7CisgICAgbV9pZGJGYWN0b3J5QmFja2VuZC0+ZGlkQ29tcGxldGVF dmVudHNGb3JUcmFuc2FjdGlvbih0cmFuc2FjdGlvbklEKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViS2l0CiAKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuaCBiL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuaAppbmRleCA0ZGMwYTEwOTgwOTg1NDhiMWYzZjNlODc3 NGJjYWVjNTdlZDBmMDBjLi42OGRiY2Q0MTZjOGE1OGE0MWNhNjAyNGNjNjAwZGYwZDZjYjAyMWU0 IDEwMDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmgKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJGYWN0b3J5SW1wbC5oCkBAIC00NCw2ICs0NCw3 IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBvcGVuKGNvbnN0IFdlYlN0cmluZyYgbmFt ZSwgY29uc3QgV2ViU3RyaW5nJiBkZXNjcmlwdGlvbiwgV2ViSURCQ2FsbGJhY2tzKiwgY29uc3Qg V2ViU2VjdXJpdHlPcmlnaW4mLCBXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgZGF0YURpcik7 CiAgICAgdmlydHVhbCB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBXZWJWZWN0 b3I8aW50PiYgcGVuZGluZ0lEcyk7CisgICAgdmlydHVhbCB2b2lkIGRpZENvbXBsZXRlRXZlbnRz Rm9yVHJhbnNhY3Rpb24oaW50IHRyYW5zYWN0aW9uSUQpOwogCiBwcml2YXRlOgogICAgIFdURjo6 UmVmUHRyPFdlYkNvcmU6OklEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlPiBtX2lkYkZhY3RvcnlC YWNrZW5kOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmplY3RTdG9y ZUltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmplY3RTdG9yZUltcGwuY3Bw CmluZGV4IDFhZDFkOWYzZTQ3MzhhNzc0ZjNiNjYxNGIyMDZmNjFhM2FiMmVjMDIuLmM0YWVhZWQ1 NjQwNTQxZDA4OTNjYTJjM2ZhZmFjODhkOGYwN2M0MjkgMTAwNzU1Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRl ICJJREJDYWxsYmFja3NQcm94eS5oIgogI2luY2x1ZGUgIklEQktleVJhbmdlLmgiCiAjaW5jbHVk ZSAiSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgiCisjaW5jbHVkZSAiSURCVHJhbnNh Y3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1ZGUgIldlYklEQkluZGV4SW1wbC5oIgogI2luY2x1 ZGUgIldlYklEQktleS5oIgogI2luY2x1ZGUgIldlYklEQktleVJhbmdlLmgiCkBAIC02NSw5ICs2 Niw5IEBAIFdlYkRPTVN0cmluZ0xpc3QgV2ViSURCT2JqZWN0U3RvcmVJbXBsOjppbmRleE5hbWVz KCkgY29uc3QKICAgICByZXR1cm4gbV9vYmplY3RTdG9yZS0+aW5kZXhOYW1lcygpOwogfQogCi12 b2lkIFdlYklEQk9iamVjdFN0b3JlSW1wbDo6Z2V0KGNvbnN0IFdlYklEQktleSYga2V5LCBXZWJJ REJDYWxsYmFja3MqIGNhbGxiYWNrcykKK3ZvaWQgV2ViSURCT2JqZWN0U3RvcmVJbXBsOjpnZXQo Y29uc3QgV2ViSURCS2V5JiBrZXksIFdlYklEQkNhbGxiYWNrcyogY2FsbGJhY2tzLCBjb25zdCBX ZWJJREJUcmFuc2FjdGlvbiYgdHJhbnNhY3Rpb24pCiB7Ci0gICAgbV9vYmplY3RTdG9yZS0+Z2V0 KGtleSwgSURCQ2FsbGJhY2tzUHJveHk6OmNyZWF0ZShjYWxsYmFja3MpKTsKKyAgICBtX29iamVj dFN0b3JlLT5nZXQoa2V5LCBJREJDYWxsYmFja3NQcm94eTo6Y3JlYXRlKGNhbGxiYWNrcyksIHRy YW5zYWN0aW9uKTsKIH0KIAogdm9pZCBXZWJJREJPYmplY3RTdG9yZUltcGw6OnB1dChjb25zdCBX ZWJTZXJpYWxpemVkU2NyaXB0VmFsdWUmIHZhbHVlLCBjb25zdCBXZWJJREJLZXkmIGtleSwgYm9v bCBhZGRPbmx5LCBXZWJJREJDYWxsYmFja3MqIGNhbGxiYWNrcykKZGlmZiAtLWdpdCBhL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5oCmluZGV4IDlmMzEzNjljMzBiMTQxNWYxYjkyYzcw ODVjYWRlZGEwMjc4OTkyMmIuLmE5ZjEyMDBjOWZjNGQ4NjFkMmVmNWY3OWU5NDQyMTk2MTNlNjQ2 OTkgMTAwNzU1Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBs LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmplY3RTdG9yZUltcGwuaApAQCAt NDcsNyArNDcsNyBAQCBwdWJsaWM6CiAgICAgV2ViU3RyaW5nIGtleVBhdGgoKSBjb25zdDsKICAg ICBXZWJET01TdHJpbmdMaXN0IGluZGV4TmFtZXMoKSBjb25zdDsKIAotICAgIHZvaWQgZ2V0KGNv bnN0IFdlYklEQktleSYga2V5LCBXZWJJREJDYWxsYmFja3MqKTsKKyAgICB2b2lkIGdldChjb25z dCBXZWJJREJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tzKiwgY29uc3QgV2ViSURCVHJhbnNhY3Rp b24mKTsKICAgICB2b2lkIHB1dChjb25zdCBXZWJTZXJpYWxpemVkU2NyaXB0VmFsdWUmIHZhbHVl LCBjb25zdCBXZWJJREJLZXkmIGtleSwgYm9vbCBhZGRPbmx5LCBXZWJJREJDYWxsYmFja3MqKTsK ICAgICB2b2lkIHJlbW92ZShjb25zdCBXZWJJREJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tzKik7 CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBs LmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmNwcAppbmRl eCAwZGM5NzAyZGU5N2QxZjk4NWRlMWEwMTI0ZmY4NzM2MzU5YzIxMmYzLi42Y2U4MWExZmFlNTU4 ZjM4OTRlMjhhZGQzOGRiNWQ0YTI3ZjVjNWE3IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJJREJUcmFuc2FjdGlvbkltcGwuY3BwCkBAIC03NSw2ICs3NSwxMiBAQCB2b2lkIFdlYklEQlRy YW5zYWN0aW9uSW1wbDo6c2V0Q2FsbGJhY2tzKFdlYklEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzKiBj YWxsYmFja3MpCiAgICAgbV9iYWNrZW5kLT5zZXRDYWxsYmFja3MoaWRiQ2FsbGJhY2tzLmdldCgp KTsKIH0KIAorV2ViSURCVHJhbnNhY3Rpb25JbXBsOjpvcGVyYXRvciBJREJUcmFuc2FjdGlvbkJh Y2tlbmRJbnRlcmZhY2UqKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9iYWNrZW5kLmdldCgpOwor fQorCisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjZW5kaWYgLy8gRU5BQkxFKElOREVYRURf REFUQUJBU0UpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQlRyYW5zYWN0 aW9uSW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJUcmFuc2FjdGlvbkltcGwuaApp bmRleCBhOWJkZTY4NGVmNWEwZTM5ZjlmN2UzMzAxOWU0NzJjNDZkODlkOGRmLi5mZDk3YjNlYmEw MDk0NGYxNmMxYTg1OGQ1MWJiNDRmNjIyNDdkMDUyIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViSURCVHJhbnNhY3Rpb25JbXBsLmgKQEAgLTMzLDggKzMzLDYgQEAKICNpbmNsdWRlIDx3dGYv UGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KIAotbmFtZXNwYWNlIFdlYkNv cmUgeyBjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7IH0KLQogbmFtZXNwYWNl IFdlYktpdCB7CiAKIC8vIFNlZSBjb21tZW50IGluIFdlYkluZGV4ZWREYXRhYmFzZSBmb3IgYSBo aWdoIGxldmVsIG92ZXJ2aWV3IHRoZXNlIGNsYXNzZXMuCkBAIC00OSw2ICs0NywxMCBAQCBwdWJs aWM6CiAgICAgdmlydHVhbCBpbnQgaWQoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgc2V0Q2Fs bGJhY2tzKFdlYklEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzKik7CiAKKyNpZiBXRUJLSVRfSU1QTEVN RU5UQVRJT04KKyAgICB2aXJ0dWFsIG9wZXJhdG9yIFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFj a2VuZEludGVyZmFjZSooKSBjb25zdDsKKyNlbmRpZgorCiBwcml2YXRlOgogICAgIFdURjo6UmVm UHRyPFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gbV9iYWNrZW5kOwog fTsK 68163 2010-09-20 17:26:45 -0700 2010-09-22 17:20:08 -0700 Patch bug-44700-20100921012642.patch text/plain 76593 andreip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0NDUzMDIzMWFkZWQwOTMzMDgwNzQ5Nzc0MzNhZjhjMGM0Y2RiYjJlLi4wY2FlYzk0 OTZjY2VmNzBjNzEyNjkyYmY5ZDk1N2UwYTdmZDZlYzk1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAK KzIwMTAtMDktMjAgIEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBnb29nbGUuY29tPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElEQk9iamVjdFN0b3Jl OjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAgICAgICAqIHN0b3JhZ2UvaW5k ZXhlZGRiL29iamVjdHN0b3JlLWJhc2ljcy1leHBlY3RlZC50eHQ6CisgICAgICAgICogc3RvcmFn ZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLmh0bWw6CisgICAgICAgICogc3RvcmFnZS9p bmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0OgorICAg ICAgICAqIHN0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0 bWw6CisgICAgICAgICogc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0LWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0 Lmh0bWw6IEFkZGVkLgorCiAyMDEwLTA5LTIwICBKYW1lcyBLb3ppYW5za2kgIDxrb3pAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE9qYW4gVmFmYWkuCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLWV4 cGVjdGVkLnR4dAppbmRleCA4OTBjMDBmYTcwYTY1YzhjZWIzZTRhNTA1ZGU0NTY4ZDhhYTVjOGU5 Li44MjFlOTY2YjQzOWU1NDUyOWVjMWUxYzU0YThlOWI1NWMxNmQzOTVjIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MtZXhwZWN0ZWQu dHh0CisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLWJhc2lj cy1leHBlY3RlZC50eHQKQEAgLTExMyw3ICsxMTMsOCBAQCBQQVNTICdyZWFkeVN0YXRlJyBpbiBl dmVudC50YXJnZXQgaXMgdHJ1ZQogUEFTUyBldmVudC50YXJnZXQucmVhZHlTdGF0ZSBpcyBldmVu dC50YXJnZXQuRE9ORQogCiBQQVNTIGV2ZW50LmNvZGUgaXMgSURCRGF0YWJhc2VFeGNlcHRpb24u VU5LTk9XTl9FUlIKLXN0b3JlID0gZXZlbnQuc291cmNlCitkYi50cmFuc2FjdGlvbigpCitzdG9y ZSA9IHRyYW5zYWN0aW9uLm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKQogc3RvcmUuZ2V0KCdrZXkn KQogUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQogUEFTUyAnb25lcnJvcicgaW4g cmVzdWx0IGlzIHRydWUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRi L29iamVjdHN0b3JlLWJhc2ljcy5odG1sIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIv b2JqZWN0c3RvcmUtYmFzaWNzLmh0bWwKaW5kZXggNzMxZDQyMThjMjI1MDk0YjRlZGE4ZjNjNzY2 Y2MyNTQwNzE5NWYzNS4uYmVlNzM0Yzk1YTNjYTY4MWViYmJhZmUzMTU3M2I4MDk4YzZmNTdlYSAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFz aWNzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUt YmFzaWNzLmh0bWwKQEAgLTg1LDcgKzg1LDEwIEBAIGZ1bmN0aW9uIGFkZEFnYWluRmFpbHVyZSgp CiAgICAgdmVyaWZ5RXJyb3JFdmVudChldmVudCk7CiAgICAgLy8gRklYTUU6IFRoaXMgZXJyb3Ig Y29kZSBuZWVkcyB0byBiZSBzcGVjY2VkLgogICAgIHNob3VsZEJlKCJldmVudC5jb2RlIiwgIklE QkRhdGFiYXNlRXhjZXB0aW9uLlVOS05PV05fRVJSIik7Ci0gICAgdmFyIHN0b3JlID0gZXZhbEFu ZExvZygic3RvcmUgPSBldmVudC5zb3VyY2UiKTsKKworICAgIHRyYW5zYWN0aW9uID0gZXZhbEFu ZExvZygiZGIudHJhbnNhY3Rpb24oKSIpOw0KKyAgICB0cmFuc2FjdGlvbi5vbmFib3J0ID0gdW5l eHBlY3RlZEVycm9yQ2FsbGJhY2s7DQorICAgIHZhciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3Jl ID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7CiAKICAgICByZXN1bHQg PSBldmFsQW5kTG9nKCJzdG9yZS5nZXQoJ2tleScpIik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3Vs dCk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9y ZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9zdG9yYWdlL2lu ZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50eHQKaW5kZXgg MGEzZDkzODZjNWIxYjY0M2EwZDgxNjllOGJkZjZlNjgyNTVmZjM5MS4uYzliYmFhNWU4NTU3OGFk ZmI3MWEzM2IzMjkyMjg0Nzg1YTg0NDFhYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFn ZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0Cisr KyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJlbW92ZW9iamVj dHN0b3JlLWV4cGVjdGVkLnR4dApAQCAtNjEsNyArNjEsOSBAQCBQQVNTICdhYm9ydCcgaW4gZXZl bnQudGFyZ2V0IGlzIHRydWUKIFBBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0 cnVlCiBQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCiAK LWV2ZW50LnNvdXJjZS5nZXQoJ2tleScpCitkYi50cmFuc2FjdGlvbigpDQorc3RvcmUgPSB0cmFu c2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykNCitzdG9yZS5nZXQoJ2tleScpCiBQQVNT ICdvbnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCiBQQVNTICdvbmVycm9yJyBpbiByZXN1bHQg aXMgdHJ1ZQogUEFTUyAnYWJvcnQnIGluIHJlc3VsdCBpcyB0cnVlCkBAIC0xMzksNyArMTQxLDkg QEAgUEFTUyAnYWJvcnQnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCiBQQVNTICdyZWFkeVN0YXRl JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQogUEFTUyBldmVudC50YXJnZXQucmVhZHlTdGF0ZSBp cyBldmVudC50YXJnZXQuRE9ORQogCi1ldmVudC5yZXN1bHQuZ2V0KCdrZXknKQorZGIudHJhbnNh Y3Rpb24oKQ0KK3N0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpDQor c3RvcmUuZ2V0KCdrZXknKQogUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQogUEFT UyAnb25lcnJvcicgaW4gcmVzdWx0IGlzIHRydWUKIFBBU1MgJ2Fib3J0JyBpbiByZXN1bHQgaXMg dHJ1ZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3Rv cmUtcmVtb3Zlb2JqZWN0c3RvcmUuaHRtbCBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRi L29iamVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0bWwKaW5kZXggZTg0MmY1YmZiZjhlZTEx N2YwZDZmM2MwYzBjYTg0ZWM0N2FlNDhjNi4uN2E5YTZlMjE2OTU0MDUxNDAwZjVkODhiZTQ3NjZk YzQ5ODc5OGMyYSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2Jq ZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9zdG9yYWdl L2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS5odG1sCkBAIC00OSw3ICs0 OSwxMSBAQCBmdW5jdGlvbiBnZXRWYWx1ZSgpCiB7CiAgICAgdmVyaWZ5U3VjY2Vzc0V2ZW50KGV2 ZW50KTsKIAotICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coImV2ZW50LnNvdXJjZS5nZXQoJ2tleScp Iik7CisgICAgdHJhbnNhY3Rpb24gPSBldmFsQW5kTG9nKCJkYi50cmFuc2FjdGlvbigpIik7Cisg ICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9IHVuZXhwZWN0ZWRFcnJvckNhbGxiYWNrOworICAgIHZh ciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0 b3JlTmFtZScpIik7CisKKyAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJzdG9yZS5nZXQoJ2tleScp Iik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CiAgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IGFk ZEluZGV4OwogICAgIHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7CkBA IC02MiwxNSArNjYsMjAgQEAgZnVuY3Rpb24gYWRkSW5kZXgoKQogCiAgICAgcmVzdWx0ID0gZXZh bEFuZExvZygiZXZlbnQuc291cmNlLmNyZWF0ZUluZGV4KCdpbmRleE5hbWUnLCAnJykiKTsKICAg ICB2ZXJpZnlSZXN1bHQocmVzdWx0KTsKLSAgICByZXN1bHQub25zdWNjZXNzID0gcmVtb3ZlT2Jq ZWN0U3RvcmU7CisgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IGNvbW1pdFRyYW5zYWN0aW9uOwogICAg IHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7Ci19Ci0KLWZ1bmN0aW9u IHJlbW92ZU9iamVjdFN0b3JlKCkKK30NCisNCitmdW5jdGlvbiBjb21taXRUcmFuc2FjdGlvbigp CiB7CiAgICAgdmVyaWZ5U3VjY2Vzc0V2ZW50KGV2ZW50KTsKICAgICBzaG91bGRCZVRydWUoImV2 ZW50LnNvdXJjZS5pbmRleE5hbWVzLmNvbnRhaW5zKCdpbmRleE5hbWUnKSIpOworICAgIC8vIExl dCB0aGUgdHJhbnNhY3Rpb24gY29tbWl0LgorICAgIHdpbmRvdy5zZXRUaW1lb3V0KCdyZW1vdmVP YmplY3RTdG9yZSgpJywgMCk7Cit9CiAKK2Z1bmN0aW9uIHJlbW92ZU9iamVjdFN0b3JlKCkKK3sK ICAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJkYi5yZW1vdmVPYmplY3RTdG9yZSgnc3RvcmVOYW1l JykiKTsKICAgICB2ZXJpZnlSZXN1bHQocmVzdWx0KTsKICAgICByZXN1bHQub25zdWNjZXNzID0g Y3JlYXRlT2JqZWN0U3RvcmVBZ2FpbjsKQEAgLTkxLDcgKzEwMCwxMSBAQCBmdW5jdGlvbiBnZXRW YWx1ZUFnYWluKCkKIHsKICAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOwogCi0gICAgcmVz dWx0ID0gZXZhbEFuZExvZygiZXZlbnQucmVzdWx0LmdldCgna2V5JykiKTsKKyAgICB0cmFuc2Fj dGlvbiA9IGV2YWxBbmRMb2coImRiLnRyYW5zYWN0aW9uKCkiKTsKKyAgICB0cmFuc2FjdGlvbi5v bmFib3J0ID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7CisgICAgdmFyIHN0b3JlID0gZXZhbEFu ZExvZygic3RvcmUgPSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykiKTsKKwor ICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coInN0b3JlLmdldCgna2V5JykiKTsKICAgICB2ZXJpZnlS ZXN1bHQocmVzdWx0KTsKICAgICByZXN1bHQub25zdWNjZXNzID0gdW5leHBlY3RlZFN1Y2Nlc3ND YWxsYmFjazsKICAgICByZXN1bHQub25lcnJvciA9IHZlcmlmeUVycm9yOwpAQCAtMTAwLDcgKzEx Myw2IEBAIGZ1bmN0aW9uIGdldFZhbHVlQWdhaW4oKQogZnVuY3Rpb24gdmVyaWZ5RXJyb3IoKQog ewogICAgIHZlcmlmeUVycm9yRXZlbnQoZXZlbnQpOwotICAgIC8vIEZJWE1FOiBTaG91bGQganVz dCBiZSBJREJEYXRhYmFzZUV4Y2VwdGlvbi5OT1RfRk9VTkRfRVJSIGJ1dCB0aGF0IGRvZXNuJ3Qg d29yayB5ZXQuCiAgICAgc2hvdWxkQmUoImV2ZW50LmNvZGUiLCAiMiIpOwogICAgIHNob3VsZEJl RmFsc2UoImV2ZW50LnNvdXJjZS5pbmRleE5hbWVzLmNvbnRhaW5zKCdpbmRleE5hbWUnKSIpOwog CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi90cmFuc2FjdGlvbi1n ZXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rp b24tZ2V0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yODQ1NjAyNmJjNWVhNDhmYjI1YjhlMTQ3 YzM2YWEwZjIyNjQ2MTEyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9p bmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDk5IEBACitU ZXN0IEluZGV4ZWREQidzIGdldCBpbnNpZGUgYSB0cmFuc2FjdGlvbi4KKworT24gc3VjY2Vzcywg eW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRF U1QgQ09NUExFVEUiLgorCisKK2luZGV4ZWREQi5vcGVuKCduYW1lJywgJ2Rlc2NyaXB0aW9uJykK K1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJl c3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5 U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4u CisKK1N1Y2Nlc3MgZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRydWUK K1BBU1MgJ2NvZGUnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVudCBp cyBmYWxzZQorUEFTUyAnc291cmNlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNvdXJj ZSAhPSBudWxsIGlzIHRydWUKK1BBU1MgJ29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlzIHRy dWUKK1BBU1MgJ29uZXJyb3InIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9ydCcg aW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdl dCBpcyB0cnVlCitQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5E T05FCisKK2RiID0gZXZlbnQucmVzdWx0CitkYi5jcmVhdGVPYmplY3RTdG9yZSgnc3RvcmVOYW1l JykKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGlu IHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3Jl YWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5 Li4uCisKK1N1Y2Nlc3MgZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRy dWUKK1BBU1MgJ2NvZGUnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVu dCBpcyBmYWxzZQorUEFTUyAnc291cmNlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNv dXJjZSAhPSBudWxsIGlzIHRydWUKK1BBU1MgJ29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlz IHRydWUKK1BBU1MgJ29uZXJyb3InIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9y dCcgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRh cmdldCBpcyB0cnVlCitQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdl dC5ET05FCisKK29iamVjdFN0b3JlID0gZXZlbnQucmVzdWx0CitvYmplY3RTdG9yZS5hZGQoJ215 VmFsdWUnLCAnbXlLZXknKQorUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQorUEFT UyAnb25lcnJvcicgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ2Fib3J0JyBpbiByZXN1bHQgaXMg dHJ1ZQorUEFTUyAncmVhZHlTdGF0ZScgaW4gcmVzdWx0IGlzIHRydWUKK0FuIGV2ZW50IHNob3Vs ZCBmaXJlIHNob3J0bHkuLi4KKworVXNpbmcgZ2V0IGluIGEgdHJhbnNhY3Rpb24KK2RiLnRyYW5z YWN0aW9uKCkKK3N0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpCitQ QVNTIHN0b3JlLm5hbWUgaXMgInN0b3JlTmFtZSIKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0 IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcg aW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitB biBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4uCisKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVz dWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9y dCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVl CitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4uCisKK1N1Y2Nlc3MgZXZlbnQgZmlyZWQ6 CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRydWUKK1BBU1MgJ2NvZGUnIGluIGV2ZW50IGlz IGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVudCBpcyBmYWxzZQorUEFTUyAnc291cmNlJyBp biBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNvdXJjZSAhPSBudWxsIGlzIHRydWUKK1BBU1Mg J29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIGV2 ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUK K1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTIGV2ZW50LnRh cmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCisKK3ZhbHVlID0gZXZlbnQucmVz dWx0CitQQVNTIHZhbHVlIGlzICJteVZhbHVlIgorRXJyb3IgZXZlbnQgZmlyZWQ6CitQQVNTICdy ZXN1bHQnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdjb2RlJyBpbiBldmVudCBpcyB0cnVlCitQ QVNTICdtZXNzYWdlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTICdzb3VyY2UnIGluIGV2ZW50IGlz IHRydWUKK1BBU1MgZXZlbnQuc291cmNlICE9IG51bGwgaXMgdHJ1ZQorUEFTUyAnb25zdWNjZXNz JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyAnb25lcnJvcicgaW4gZXZlbnQudGFyZ2V0 IGlzIHRydWUKK1BBU1MgJ2Fib3J0JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyAncmVh ZHlTdGF0ZScgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgZXZlbnQudGFyZ2V0LnJlYWR5 U3RhdGUgaXMgZXZlbnQudGFyZ2V0LkRPTkUKKworQWNjZXNzaW5nIGEgY29tbWl0dGVkIHRyYW5z YWN0aW9uIHNob3VsZCB0aHJvdworUEFTUyBleGMuY29kZSBpcyA5CitQQVNTIHN1Y2Nlc3NmdWxs eVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L3N0b3JhZ2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sIGIvTGF5b3V0VGVzdHMvc3Rv cmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDNmMjk1MWVh ZmU3NmFlMTI3ZmE2OTI1MmM1NTk3YTk5ZDk1OGYyYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sCkBAIC0wLDAgKzEs OTMgQEAKKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4u L2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8u Li9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LWZ1bmN0aW9uLmpzIj48L3Nj cmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2hhcmVkLmpzIj48L3NjcmlwdD4KKzwvaGVh ZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48 L2Rpdj4KKzxzY3JpcHQ+DQorZGVzY3JpcHRpb24oIlRlc3QgSW5kZXhlZERCJ3MgZ2V0IGluc2lk ZSBhIHRyYW5zYWN0aW9uLiIpOw0KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpDQor ICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsNCisNCitmdW5jdGlvbiBh ZnRlckNvbW1pdCgpIHsNCisgICAgdHJ5IHsNCisgICAgICAgIGRlYnVnKCJBY2Nlc3NpbmcgYSBj b21taXR0ZWQgdHJhbnNhY3Rpb24gc2hvdWxkIHRocm93Iik7DQorICAgICAgICB2YXIgc3RvcmUg PSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJyk7DQorICAgIH0gY2F0Y2ggKGUp IHsNCisgICAgICAgIGV4YyA9IGU7DQorICAgICAgICBzaG91bGRCZSgnZXhjLmNvZGUnLCAnOScp Ow0KKyAgICB9DQorICAgIGRvbmUoKTsNCit9DQorDQorZnVuY3Rpb24gbm9uRXhpc3RpbmdLZXko KSB7DQorICAgIHZlcmlmeUVycm9yRXZlbnQoZXZlbnQpOw0KKyAgICB3aW5kb3cuc2V0VGltZW91 dCgnYWZ0ZXJDb21taXQoKScsIDApOw0KK30NCisNCitmdW5jdGlvbiBnb3RWYWx1ZSgpIHsNCisg ICAgdmVyaWZ5U3VjY2Vzc0V2ZW50KGV2ZW50KTsNCisgICAgdmFyIHZhbHVlID0gZXZhbEFuZExv ZygidmFsdWUgPSBldmVudC5yZXN1bHQiKTsNCisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd2 YWx1ZScsICdteVZhbHVlJyk7DQorfQ0KKw0KK2Z1bmN0aW9uIHN0YXJ0VHJhbnNhY3Rpb24oKSB7 DQorICAgIGRlYnVnKCJVc2luZyBnZXQgaW4gYSB0cmFuc2FjdGlvbiIpOw0KKyAgICB0cmFuc2Fj dGlvbiA9IGV2YWxBbmRMb2coImRiLnRyYW5zYWN0aW9uKCkiKTsNCisgICAgdHJhbnNhY3Rpb24u b25hYm9ydCA9IHVuZXhwZWN0ZWRFcnJvckNhbGxiYWNrOw0KKyAgICB2YXIgc3RvcmUgPSBldmFs QW5kTG9nKCJzdG9yZSA9IHRyYW5zYWN0aW9uLm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKSIpOw0K KyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInN0b3JlLm5hbWUiLCAic3RvcmVOYW1lIik7DQor ICAgIHZhciByZXN1bHQgPSBzdG9yZS5nZXQoJ215S2V5Jyk7DQorICAgIHZlcmlmeVJlc3VsdChy ZXN1bHQpOw0KKyAgICByZXN1bHQub25zdWNjZXNzID0gZ290VmFsdWU7DQorICAgIHJlc3VsdC5v bmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7DQorDQorICAgIHZhciBlbXB0eVJlc3Vs dCA9IHN0b3JlLmdldCgnbm9uRXhpc3RpbmdLZXknKTsNCisgICAgdmVyaWZ5UmVzdWx0KGVtcHR5 UmVzdWx0KTsNCisgICAgZW1wdHlSZXN1bHQub25zdWNjZXNzID0gdW5leHBlY3RlZFN1Y2Nlc3ND YWxsYmFjazsNCisgICAgZW1wdHlSZXN1bHQub25lcnJvciA9IG5vbkV4aXN0aW5nS2V5Ow0KK30N CisNCitmdW5jdGlvbiBwb3B1bGF0ZU9iamVjdFN0b3JlKG9iamVjdFN0b3JlKSB7DQorICAgIHJl c3VsdCA9IGV2YWxBbmRMb2coIm9iamVjdFN0b3JlLmFkZCgnbXlWYWx1ZScsICdteUtleScpIik7 DQorICAgIHZlcmlmeVJlc3VsdChyZXN1bHQpOw0KKyAgICByZXN1bHQub25zdWNjZXNzID0gc3Rh cnRUcmFuc2FjdGlvbjsNCisgICAgcmVzdWx0Lm9uZXJyb3IgPSB1bmV4cGVjdGVkRXJyb3JDYWxs YmFjazsNCit9DQorDQorZnVuY3Rpb24gY3JlYXRlT2JqZWN0U3RvcmVTdWNjZXNzKCkgew0KKyAg ICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOw0KKyAgICB2YXIgb2JqZWN0U3RvcmUgPSBldmFs QW5kTG9nKCJvYmplY3RTdG9yZSA9IGV2ZW50LnJlc3VsdCIpOw0KKyAgICBwb3B1bGF0ZU9iamVj dFN0b3JlKG9iamVjdFN0b3JlKTsNCit9DQorDQorZnVuY3Rpb24gb3BlblN1Y2Nlc3MoKSB7DQor ICAgIHZlcmlmeVN1Y2Nlc3NFdmVudChldmVudCk7DQorICAgIHZhciBkYiA9IGV2YWxBbmRMb2co ImRiID0gZXZlbnQucmVzdWx0Iik7DQorDQorICAgIGRlbGV0ZUFsbE9iamVjdFN0b3JlcyhkYik7 DQorDQorICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coImRiLmNyZWF0ZU9iamVjdFN0b3JlKCdzdG9y ZU5hbWUnKSIpOw0KKyAgICB2ZXJpZnlSZXN1bHQocmVzdWx0KTsNCisgICAgcmVzdWx0Lm9uc3Vj Y2VzcyA9IGNyZWF0ZU9iamVjdFN0b3JlU3VjY2VzczsNCisgICAgcmVzdWx0Lm9uZXJyb3IgPSB1 bmV4cGVjdGVkRXJyb3JDYWxsYmFjazsNCit9DQorDQorZnVuY3Rpb24gdGVzdCgpIHsNCisgICAg cmVzdWx0ID0gZXZhbEFuZExvZygiaW5kZXhlZERCLm9wZW4oJ25hbWUnLCAnZGVzY3JpcHRpb24n KSIpOw0KKyAgICB2ZXJpZnlSZXN1bHQocmVzdWx0KTsNCisgICAgcmVzdWx0Lm9uc3VjY2VzcyA9 IG9wZW5TdWNjZXNzOw0KKyAgICByZXN1bHQub25lcnJvciA9IHVuZXhwZWN0ZWRFcnJvckNhbGxi YWNrOw0KK30NCisNCit0ZXN0KCk7DQorDQordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7 CisKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFu Z2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBhY2ZmNjc1MzliOTI2YzBjODg1N2IxYWYz NzFmNzE2NGQxYjcxYTZmLi5jMmE4ZGJmZmE2OTMzYjdiNzI1OWMwZjU0NTA2ZDBlMzhkZDliM2E1 IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDg1IEBACisyMDEwLTA5LTIwICBBbmRyZWkgUG9wZXNjdSAgPGFuZHJlaXBAZ29v Z2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBJREJPYmplY3RTdG9yZTo6Z2V0IHNob3VsZCBydW4gaW4gYSB0cmFuc2FjdGlvbi4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzAwCisKKyAgICAg ICAgSW1wbGVtZW50cyBsb2dpYyBmb3IgcnVubmluZyBJREJPYmplY3RTdG9yZTo6Z2V0KCkgaW4g YSB0cmFuc2FjdGlvbi4KKyAgICAgICAgUmVmYWN0b3JzIHRoZSBwZW5kaW5nIHRyYW5zYWN0aW9u IG1vbml0b3IgYW5kIHRoZSB0cmFuc2FjdGlvbiBjb29yZGluYXRvcgorICAgICAgICB0byB1c2Ug cG9pbnRlcnMgaW5zdGVhZCBvZiB0cmFuc2FjdGlvbiBJRHMuCisKKyAgICAgICAgVGVzdDogc3Rv cmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0Lmh0bWwKKworICAgICAgICAqIGJpbmRpbmdz L3Y4L1Y4UHJveHkuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VjhQcm94eTo6ZGlkTGVhdmVTY3Jp cHRDb250ZXh0KToKKyAgICAgICAgKiBzdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcDoK KyAgICAgICAgKiBzdG9yYWdlL0lEQkRhdGFiYXNlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklE QkRhdGFiYXNlOjpvYmplY3RTdG9yZSk6CisgICAgICAgICogc3RvcmFnZS9JREJEYXRhYmFzZUJh Y2tlbmRJbXBsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQkRhdGFiYXNlQmFja2VuZEltcGw6 Om9iamVjdFN0b3JlKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwu aDoKKyAgICAgICAgKFdlYkNvcmU6OklEQkRhdGFiYXNlQmFja2VuZEltcGw6OnRyYW5zYWN0aW9u Q29vcmRpbmF0b3IpOgorICAgICAgICAqIHN0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW50ZXJm YWNlLmg6CisgICAgICAgICogc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SURCRmFjdG9yeUJhY2tlbmRJbXBsOjphYm9ydFBlbmRpbmdUcmFuc2Fj dGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6SURCRmFjdG9yeUJhY2tlbmRJbXBsOjpkaWRDb21w bGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQkZhY3RvcnlC YWNrZW5kSW1wbC5oOgorICAgICAgICAoV2ViQ29yZTo6SURCRmFjdG9yeUJhY2tlbmRJbXBsOjp0 cmFuc2FjdGlvbkNvb3JkaW5hdG9yKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQkZhY3RvcnlCYWNr ZW5kSW50ZXJmYWNlLmg6CisgICAgICAgICogc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZTo6SURCT2JqZWN0U3RvcmUpOgorICAgICAg ICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmU6OmdldCk6CisgICAgICAgICogc3RvcmFnZS9JREJP YmplY3RTdG9yZS5oOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmU6OmNyZWF0ZSk6 CisgICAgICAgICogc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldCk6CisgICAgICAgICog c3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmg6CisgICAgICAgIChXZWJDb3JlOjpJ REJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjpJREJUYXNrOjpJREJUYXNrKToKKyAgICAgICAgKFdl YkNvcmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OklEQlRhc2s6OnBlcmZvcm1UYXNrKToK KyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmNyZWF0ZVRhc2sp OgorICAgICAgICAqIHN0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmg6Cisg ICAgICAgICogc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmFkZFBlbmRpbmdUcmFu c2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9y OjpyZW1vdmVQZW5kaW5nVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6SURCUGVuZGlu Z1RyYW5zYWN0aW9uTW9uaXRvcjo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKToKKyAgICAgICAg KFdlYkNvcmU6OklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmRpZENvbXBsZXRlRXZlbnRz Rm9yVHJhbnNhY3Rpb24pOgorICAgICAgICAqIHN0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9u TW9uaXRvci5oOgorICAgICAgICAqIHN0b3JhZ2UvSURCUmVxdWVzdC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpJREJSZXF1ZXN0OjpJREJSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlJl cXVlc3Q6Om9uU3VjY2Vzcyk6CisgICAgICAgIChXZWJDb3JlOjpJREJSZXF1ZXN0Ojp0aW1lckZp cmVkKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlJlcXVlc3QuaDoKKyAgICAgICAgKFdlYkNvcmU6 OklEQlJlcXVlc3Q6OmNyZWF0ZSk6CisgICAgICAgICogc3RvcmFnZS9JREJUcmFuc2FjdGlvbi5j cHA6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbjo6SURCVHJhbnNhY3Rpb24pOgor ICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb246Om9iamVjdFN0b3JlKToKKyAgICAgICAg KiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwpOgor ICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6b2JqZWN0U3RvcmUp OgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6c2NoZWR1bGVU YXNrKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OmFib3J0 KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OmRpZENvbXBs ZXRlVGFza0V2ZW50cyk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsOjpydW4pOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6 c3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6Y29t bWl0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OmRpZEZp bmlzaFRyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2Vu ZEltcGw6OnRpbWVyRmlyZWQpOgorICAgICAgICAqIHN0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbC5oOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6 fklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbDo6aXNGaW5pc2hlZCk6CisgICAgICAgICogc3RvcmFnZS9JREJUcmFu c2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0 aW9uQ29vcmRpbmF0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25Db29y ZGluYXRvcjo6Y3JlYXRlVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNh Y3Rpb25Db29yZGluYXRvcjo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKToKKyAgICAgICAgKFdl YkNvcmU6OklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJh bnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6 ZGlkU3RhcnRUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNv b3JkaW5hdG9yOjpkaWRGaW5pc2hUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJU cmFuc2FjdGlvbkNvb3JkaW5hdG9yOjp0cmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJ REJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucyk6Cisg ICAgICAgICogc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmg6CisKIDIwMTAtMDkt MTkgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAg IFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2Nzc0OS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmlu ZGluZ3MvdjgvVjhQcm94eS5jcHAgYi9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4UHJveHkuY3BwCmlu ZGV4IGE3NzZlZTdkNzNmYjkyZDQ4NmU2NzdkMDg1ZGFlMTYzNzk3ZGI4NGQuLjAxM2M1OThjMDUx OWY1ZTMxOTkzNGI0MGQ1NDlhNGJjZjJiYmU1Y2MgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGlu Z3MvdjgvVjhQcm94eS5jcHAKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy92OC9WOFByb3h5LmNwcApA QCAtNjUzLDExICs2NTMsNyBAQCB2b2lkIFY4UHJveHk6OmRpZExlYXZlU2NyaXB0Q29udGV4dCgp CiAgICAgLy8gSWYgd2UndmUganVzdCBsZWZ0IGEgc2NyaXB0IGNvbnRleHQgYW5kIGluZGV4ZWQg ZGF0YWJhc2UgaGFzIGJlZW4KICAgICAvLyBpbnN0YW50aWF0ZWQsIHdlIG11c3QgbGV0IGl0cyB0 cmFuc2FjdGlvbiBjb29yZGluYXRvciBrbm93IHNvIGl0IGNhbiB0ZXJtaW5hdGUKICAgICAvLyBh bnkgbm90LXlldC1zdGFydGVkIHRyYW5zYWN0aW9ucy4KLSAgICBpZiAoSURCUGVuZGluZ1RyYW5z YWN0aW9uTW9uaXRvcjo6aGFzUGVuZGluZ1RyYW5zYWN0aW9ucygpKSB7Ci0gICAgICAgIEFTU0VS VChwYWdlLT5ncm91cCgpLmhhc0lEQkZhY3RvcnkoKSk7Ci0gICAgICAgIHBhZ2UtPmdyb3VwKCku aWRiRmFjdG9yeSgpLT5hYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoSURCUGVuZGluZ1RyYW5zYWN0 aW9uTW9uaXRvcjo6cGVuZGluZ1RyYW5zYWN0aW9ucygpKTsKLSAgICAgICAgSURCUGVuZGluZ1Ry YW5zYWN0aW9uTW9uaXRvcjo6Y2xlYXJQZW5kaW5nVHJhbnNhY3Rpb25zKCk7Ci0gICAgfQorICAg IElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhw YWdlLT5ncm91cCgpLmlkYkZhY3RvcnkoKSk7CiAjZW5kaWYgLy8gRU5BQkxFKElOREVYRURfREFU QUJBU0UpCiAgICAgLy8gSWYgd2UndmUganVzdCBsZWZ0IGEgdG9wIGxldmVsIHNjcmlwdCBjb250 ZXh0IGFuZCBsb2NhbCBzdG9yYWdlIGhhcyBiZWVuCiAgICAgLy8gaW5zdGFudGlhdGVkLCB3ZSBt dXN0IGVuc3VyZSB0aGF0IGFueSBzdG9yYWdlIGxvY2tzIGhhdmUgYmVlbiBmcmVlZC4KZGlmZiAt LWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHAgYi9XZWJDb3Jl L3N0b3JhZ2UvSURCQ3Vyc29yQmFja2VuZEltcGwuY3BwCmluZGV4IDNhNGRkNjc3NDhhYjc0NzVm MTY5Y2VkNzQ3NmEzNWY3ZDViNjgzOGQuLjEzZGY1ZjAyMTU0ZTU1ZDE2MjZkMDYyMmUwYmQyNWM1 Y2UwYmQ5OGEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1w bC5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcApAQCAt MzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIklEQktleVJhbmdlLmgiCiAjaW5jbHVkZSAiSURCT2Jq ZWN0U3RvcmVCYWNrZW5kSW1wbC5oIgogI2luY2x1ZGUgIklEQlJlcXVlc3QuaCIKKyNpbmNsdWRl ICJJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaCIKICNpbmNsdWRlICJTUUxpdGVEYXRh YmFzZS5oIgogI2luY2x1ZGUgIlNRTGl0ZVN0YXRlbWVudC5oIgogI2luY2x1ZGUgIlNlcmlhbGl6 ZWRTY3JpcHRWYWx1ZS5oIgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNl LmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZS5jcHAKaW5kZXggODE5NTBkNmUwNDNi ZGYyMGJmNWJiYzVmNjNmOTk4MDI2MjkyY2FjYS4uMGVhN2FjMjkyNjc0Y2VhNjA5NzAzNWZhNWZl NWM4OTdmNDRkYjZiNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlLmNw cAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwCkBAIC01NSwxMSArNTUsMTIg QEAgUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBJREJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUo U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY28KICAgICByZXR1cm4gcmVxdWVzdDsKIH0KIAorLy8g RklYTUU6IHJlbW92ZSB0aGlzIG1ldGhvZC4KIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IElE QkRhdGFiYXNlOjpvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0 IG1vZGUpCiB7CiAgICAgUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2Jq ZWN0U3RvcmUgPSBtX2JhY2tlbmQtPm9iamVjdFN0b3JlKG5hbWUsIG1vZGUpOwogICAgIEFTU0VS VChvYmplY3RTdG9yZSk7IC8vIEZJWE1FOiBJZiB0aGlzIGlzIG51bGwsIHdlIHNob3VsZCByYWlz ZSBhIE5PVF9GT1VORF9FUlIuCi0gICAgcmV0dXJuIElEQk9iamVjdFN0b3JlOjpjcmVhdGUob2Jq ZWN0U3RvcmUucmVsZWFzZSgpKTsKKyAgICByZXR1cm4gSURCT2JqZWN0U3RvcmU6OmNyZWF0ZShv YmplY3RTdG9yZS5yZWxlYXNlKCksIDApOwogfQogCiBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IElE QkRhdGFiYXNlOjpyZW1vdmVPYmplY3RTdG9yZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURC RGF0YWJhc2VCYWNrZW5kSW1wbC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNr ZW5kSW1wbC5jcHAKaW5kZXggMDIxZjcwYWE0YjQ4ODExOWU5ZmM5NjE2ZjA0NWQ0OTljYTRiODFh Yi4uZGUyNjBiMjQ0ZmNhNjg0N2JmZTA0OWY3ODM1YzAyYmM5YTg1Yzg5MiAxMDA2NDQKLS0tIGEv V2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuY3BwCisrKyBiL1dlYkNvcmUv c3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmNwcApAQCAtMTQ4LDExICsxNDgsMTIgQEAg dm9pZCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjpjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IFN0cmluZyYKICAgICBjYWxsYmFja3MtPm9uU3VjY2VzcyhvYmplY3RT dG9yZS5nZXQoKSk7CiB9CiAKLVBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJm YWNlPiBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOjpvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5h bWUsIHVuc2lnbmVkIHNob3J0IG1vZGUpCisvLyBGSVhNRTogRG8gbm90IGV4cG9zZSB0aGlzIG1l dGhvZCB2aWEgSURMLgorUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+ IElEQkRhdGFiYXNlQmFja2VuZEltcGw6Om9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwg dW5zaWduZWQgc2hvcnQgbW9kZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFu c2FjdGlvbikKIHsKLSAgICAvLyBGSVhNRTogSWYgbm8gdHJhbnNhY3Rpb24gaXMgcnVubmluZywg dGhpcyBzaG91bGQgaW1wbGljaXRseSBzdGFydCBvbmUuCi0gICAgQVNTRVJUX1VOVVNFRChtb2Rl LCAhbW9kZSk7IC8vIEZJWE1FOiBIYW5kbGUgbm9uLXN0YW5kYXJkIG1vZGVzLgotICAgIHJldHVy biBtX29iamVjdFN0b3Jlcy5nZXQobmFtZSk7CisgICAgQVNTRVJUX1VOVVNFRChtb2RlLCAhbW9k ZSk7IC8vIEZJWE1FOiBEZWxldGUgdGhpcy4KKyAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNr ZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZSA9IG1fb2JqZWN0U3RvcmVzLmdldChuYW1lKTsKKyAg ICByZXR1cm4gb2JqZWN0U3RvcmUucmVsZWFzZSgpOwogfQogCiBzdGF0aWMgdm9pZCBkb0RlbGV0 ZShTUUxpdGVEYXRhYmFzZSYgZGIsIGNvbnN0IGNoYXIqIHNxbCwgaW50NjRfdCBpZCkKZGlmZiAt LWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmggYi9XZWJDb3Jl L3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oCmluZGV4IGFiMDU1Zjg4YThjMDhmMmY2 ZDAzZDY5NTk4MTQ0MTU3OGM0ZjI1NzAuLmMyYWJiNTg3ZDBjMDAzYmFlZjBiMWJiMWYxMzEyZGUw Njg0ODkxZjYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJ bXBsLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaApAQCAt NTcsMTEgKzU3LDEzIEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8RE9NU3RyaW5n TGlzdD4gb2JqZWN0U3RvcmVzKCkgY29uc3Q7CiAKICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlT2Jq ZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGtleVBhdGgsIGJvb2wg YXV0b0luY3JlbWVudCwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKLSAgICB2aXJ0dWFsIFBh c3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25z dCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUpOworICAgIHZpcnR1YWwgUGFzc1Jl ZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0 cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlKik7CiAgICAgdmlydHVhbCB2b2lkIHJlbW92ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmlu ZyYgbmFtZSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0 VmVyc2lvbihjb25zdCBTdHJpbmcmIHZlcnNpb24sIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7 CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4g dHJhbnNhY3Rpb24oRE9NU3RyaW5nTGlzdCogc3RvcmVOYW1lcywgdW5zaWduZWQgc2hvcnQgbW9k ZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0KTsKIAorICAgIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0 b3IqIHRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKSBjb25zdCB7IHJldHVybiBtX3RyYW5zYWN0aW9u Q29vcmRpbmF0b3IuZ2V0KCk7IH0KKwogcHJpdmF0ZToKICAgICBJREJEYXRhYmFzZUJhY2tlbmRJ bXBsKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwgUGFzc093 blB0cjxTUUxpdGVEYXRhYmFzZT4gZGF0YWJhc2UsIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3Iq KTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVy ZmFjZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEludGVyZmFjZS5oCmlu ZGV4IGEyZTA0MmFlMjAwMDBhNDFjMmY2ZDUwNTA5ZmRhNDc1Zjc1NTM4NDUuLmMyZTIyNDQ5MmEz NjFiNTMyZjg4Zjk5OGE3M2ExODE3NjE0MDI2MGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFn ZS9JREJEYXRhYmFzZUJhY2tlbmRJbnRlcmZhY2UuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURC RGF0YWJhc2VCYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTU1LDcgKzU1LDggQEAgcHVibGljOgogICAg IHZpcnR1YWwgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBvYmplY3RTdG9yZXMoKSBjb25zdCA9 IDA7CiAKICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBTdHJpbmcmIGtleVBhdGgsIGJvb2wgYXV0b0luY3JlbWVudCwgUGFzc1JlZlB0 cjxJREJDYWxsYmFja3M+KSA9IDA7Ci0gICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0 b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNp Z25lZCBzaG9ydCBtb2RlKSA9IDA7CisgICAgLy8gRklYTUU6IHJlbW92ZSB0aGUgZGVmYXVsdCB2 YWx1ZSBmb3IgdGhlIHRyYW5zYWN0aW9uIHBhcmFtZXRlci4KKyAgICB2aXJ0dWFsIFBhc3NSZWZQ dHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJp bmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1vZGUsIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZSogdHJhbnNhY3Rpb24gPSAwKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHJlbW92ZU9iamVj dFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KSA9IDA7 CiAgICAgdmlydHVhbCB2b2lkIHNldFZlcnNpb24oY29uc3QgU3RyaW5nJiB2ZXJzaW9uLCBQYXNz UmVmUHRyPElEQkNhbGxiYWNrcz4pID0gMDsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCVHJh bnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiB0cmFuc2FjdGlvbihET01TdHJpbmdMaXN0KiBzdG9y ZU5hbWVzLCB1bnNpZ25lZCBzaG9ydCBtb2RlLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQpID0gMDsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuY3BwIGIv V2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5jcHAKaW5kZXggZDgxOWM5MmE5 NGE4OTIxMGI2M2RhZmYxMTdlZjg0MjgxNDdlZGM2Ny4uZDI2NzllNDUxMjg0YTExMTAwMzc2MTMy ZWIzOWIyZGU2OTc1N2ExNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlC YWNrZW5kSW1wbC5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW1w bC5jcHAKQEAgLTMzLDYgKzMzLDcgQEAKICNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCiAjaW5jbHVk ZSAiSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oIgogI2luY2x1ZGUgIklEQkRhdGFiYXNlRXhjZXB0 aW9uLmgiCisjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5j bHVkZSAiSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1ZGUgIlNRTGl0ZURhdGFi YXNlLmgiCiAjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKQEAgLTE0MiwxMCArMTQzLDE0IEBA IHZvaWQgSURCRmFjdG9yeUJhY2tlbmRJbXBsOjpvcGVuKGNvbnN0IFN0cmluZyYgbmFtZSwgY29u c3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwKICAgICBtX2RhdGFiYXNlQmFja2VuZE1hcC5zZXQobmFt ZSwgZGF0YWJhc2VCYWNrZW5kLnJlbGVhc2UoKSk7CiB9CiAKLXZvaWQgSURCRmFjdG9yeUJhY2tl bmRJbXBsOjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIHBlbmRp bmdJRHMpCit2b2lkIElEQkZhY3RvcnlCYWNrZW5kSW1wbDo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rp b25zKGNvbnN0IFZlY3RvcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqPiYgcGVuZGlu Z1RyYW5zYWN0aW9ucykKIHsKLSAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHBlbmRpbmdJRHMu c2l6ZSgpOyArK2kpCi0gICAgICAgIG1fdHJhbnNhY3Rpb25Db29yZGluYXRvci0+YWJvcnQocGVu ZGluZ0lEcy5hdChpKSk7CisgICAgbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLT5hYm9ydFBlbmRp bmdUcmFuc2FjdGlvbnMocGVuZGluZ1RyYW5zYWN0aW9ucyk7Cit9CisKK3ZvaWQgSURCRmFjdG9y eUJhY2tlbmRJbXBsOjpkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKElEQlRyYW5zYWN0 aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCit7CisgICAgbV90cmFuc2FjdGlvbkNv b3JkaW5hdG9yLT5kaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKHRyYW5zYWN0aW9uKTsK IH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdl L0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNr ZW5kSW1wbC5oCmluZGV4IGYyZTFhZjgxMTVlYmI0ZGJlM2ZmZTEwN2Q2Mjc0ODJlYmY1YTkwYzcu LmQ4YWQ4OGMwZjMwMGMxY2FlM2JmOGZjMTI4Y2FhYWM5MGI3ZWIxZGIgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmgKQEAgLTUwLDcgKzUwLDEwIEBAIHB1YmxpYzoKICAg ICB2aXJ0dWFsIH5JREJGYWN0b3J5QmFja2VuZEltcGwoKTsKIAogICAgIHZpcnR1YWwgdm9pZCBv cGVuKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwgUGFzc1Jl ZlB0cjxJREJDYWxsYmFja3M+LCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiwgRnJhbWUqLCBj b25zdCBTdHJpbmcmIGRhdGFEaXIpOwotICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRpbmdUcmFu c2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIHBlbmRpbmdJRHMpOworICAgIHZpcnR1YWwgdm9p ZCBhYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPElEQlRyYW5zYWN0aW9uQmFj a2VuZEludGVyZmFjZSo+Jik7CisgICAgdmlydHVhbCB2b2lkIGRpZENvbXBsZXRlRXZlbnRzRm9y VHJhbnNhY3Rpb24oSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKik7CisKKyAgICBJREJU cmFuc2FjdGlvbkNvb3JkaW5hdG9yKiB0cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCkgY29uc3QgeyBy ZXR1cm4gbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLmdldCgpOyB9CiAKIHByaXZhdGU6CiAgICAg SURCRmFjdG9yeUJhY2tlbmRJbXBsKCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURC RmFjdG9yeUJhY2tlbmRJbnRlcmZhY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFj a2VuZEludGVyZmFjZS5oCmluZGV4IGU1OTEyNzE5ZWY1NDQ5NDQ2ZWE2YmMyMmYzNTY0NjMwNmQ4 ZDcwYmQuLjg2ZTY5Y2M2YmFiNDdiZjkyMzBhZmIwMzk3OTcxOTBjODgyN2RiYjUgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEludGVyZmFjZS5oCisrKyBiL1dl YkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEludGVyZmFjZS5oCkBAIC00MCw2ICs0MCw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRnJhbWU7CiBjbGFzcyBJREJEYXRhYmFz ZTsKK2NsYXNzIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZTsKIGNsYXNzIFNlY3VyaXR5 T3JpZ2luOwogCiAvLyBUaGlzIGNsYXNzIGlzIHNoYXJlZCBieSBJREJGYWN0b3J5IChhc3luYykg YW5kIElEQkZhY3RvcnlTeW5jIChzeW5jKS4KQEAgLTUyLDcgKzUzLDggQEAgcHVibGljOgogICAg IHZpcnR1YWwgfklEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlKCkgeyB9CiAKICAgICB2aXJ0dWFs IHZvaWQgb3Blbihjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24s IFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiwgUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4sIEZy YW1lKiwgY29uc3QgU3RyaW5nJiBkYXRhRGlyKSA9IDA7Ci0gICAgdmlydHVhbCB2b2lkIGFib3J0 UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBWZWN0b3I8aW50PiYgaWRzKSA9IDA7CisgICAgdmly dHVhbCB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBWZWN0b3I8SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW50ZXJmYWNlKj4mKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGRpZENvbXBs ZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24oSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKikg PSAwOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9z dG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9y ZS5jcHAKaW5kZXggYjQ1N2NkMWQxNTg4NmMxMGZiMmUxZjMzNGEzZGMyMmEzZmRmMWM4NS4uMzk1 ODNjNGE5NzU2ZjY3ZTgxZGQ5YWU2MWE2M2JmNDMyNGJkMWMzNCAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2Jq ZWN0U3RvcmUuY3BwCkBAIC0zMSw2ICszMSw4IEBACiAjaW5jbHVkZSAiSURCSW5kZXguaCIKICNp bmNsdWRlICJJREJLZXkuaCIKICNpbmNsdWRlICJJREJLZXlSYW5nZS5oIgorI2luY2x1ZGUgIklE QlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuaCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbi5o IgogI2luY2x1ZGUgIlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgogI2luY2x1ZGUgPHd0Zi9VbnVz ZWRQYXJhbS5oPgogCkBAIC0zOCw4ICs0MCw5IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAot SURCT2JqZWN0U3RvcmU6OklEQk9iamVjdFN0b3JlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVC YWNrZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RTdG9yZSkKK0lEQk9iamVjdFN0b3JlOjpJREJPYmpl Y3RTdG9yZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gaWRiT2Jq ZWN0U3RvcmUsIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiAg ICAgOiBtX29iamVjdFN0b3JlKGlkYk9iamVjdFN0b3JlKQorICAgICwgbV90cmFuc2FjdGlvbih0 cmFuc2FjdGlvbikKIHsKICAgICAvLyBXZSBwYXNzIGEgcmVmZXJlbmNlIHRvIHRoaXMgb2JqZWN0 IGJlZm9yZSBpdCBjYW4gYmUgYWRvcHRlZC4KICAgICByZWxheEFkb3B0aW9uUmVxdWlyZW1lbnQo KTsKQEAgLTYyLDggKzY1LDggQEAgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBJREJPYmplY3RT dG9yZTo6aW5kZXhOYW1lcygpIGNvbnN0CiAKIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gSURCT2Jq ZWN0U3RvcmU6OmdldChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRy PElEQktleT4ga2V5KQogewotICAgIFJlZlB0cjxJREJSZXF1ZXN0PiByZXF1ZXN0ID0gSURCUmVx dWVzdDo6Y3JlYXRlKGNvbnRleHQsIElEQkFueTo6Y3JlYXRlKHRoaXMpKTsKLSAgICBtX29iamVj dFN0b3JlLT5nZXQoa2V5LCByZXF1ZXN0KTsKKyAgICBSZWZQdHI8SURCUmVxdWVzdD4gcmVxdWVz dCA9IElEQlJlcXVlc3Q6OmNyZWF0ZShjb250ZXh0LCBJREJBbnk6OmNyZWF0ZSh0aGlzKSwgbV90 cmFuc2FjdGlvbi5nZXQoKSk7CisgICAgbV9vYmplY3RTdG9yZS0+Z2V0KGtleSwgcmVxdWVzdCwg bV90cmFuc2FjdGlvbi5nZXQoKSk7CiAgICAgcmV0dXJuIHJlcXVlc3Q7CiB9CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lE Qk9iamVjdFN0b3JlLmgKaW5kZXggMDM1ZjVkOGI0N2ZiYTgyY2JjM2VkMjQ4NWI1Yjc4OGUwMzIz MTkyNi4uZDcyZTI5YTAyOWYwOTkyODM0NTRmY2VkZWE0ZjMxMDA3M2RmOWIxYyAxMDA2NDQKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdl L0lEQk9iamVjdFN0b3JlLmgKQEAgLTQzLDEzICs0MywxNCBAQCBjbGFzcyBET01TdHJpbmdMaXN0 OwogY2xhc3MgSURCQW55OwogY2xhc3MgSURCSW5kZXhSZXF1ZXN0OwogY2xhc3MgSURCS2V5Owor Y2xhc3MgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlOwogY2xhc3MgU2VyaWFsaXplZFNj cmlwdFZhbHVlOwogCiBjbGFzcyBJREJPYmplY3RTdG9yZSA6IHB1YmxpYyBSZWZDb3VudGVkPElE Qk9iamVjdFN0b3JlPiB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8SURCT2JqZWN0 U3RvcmU+IGNyZWF0ZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4g aWRiT2JqZWN0U3RvcmUpCisgICAgc3RhdGljIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IGNy ZWF0ZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gaWRiT2JqZWN0 U3RvcmUsIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiAgICAg ewotICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IElEQk9iamVjdFN0b3JlKGlkYk9iamVjdFN0 b3JlKSk7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgSURCT2JqZWN0U3RvcmUoaWRiT2Jq ZWN0U3RvcmUsIHRyYW5zYWN0aW9uKSk7CiAgICAgfQogICAgIH5JREJPYmplY3RTdG9yZSgpIHsg fQogCkBAIC02OSw5ICs3MCwxMSBAQCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxJREJSZXF1ZXN0 PiBvcGVuQ3Vyc29yKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQktleVJh bmdlPiA9IDAsIHVuc2lnbmVkIHNob3J0IGRpcmVjdGlvbiA9IElEQkN1cnNvcjo6TkVYVCk7CiAK IHByaXZhdGU6Ci0gICAgSURCT2JqZWN0U3RvcmUoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJh Y2tlbmRJbnRlcmZhY2U+KTsKKyAgICBJREJPYmplY3RTdG9yZShQYXNzUmVmUHRyPElEQk9iamVj dFN0b3JlQmFja2VuZEludGVyZmFjZT4sIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSog dHJhbnNhY3Rpb25faWQpOworICAgIHZvaWQgcmVtb3ZlVHJhbnNhY3Rpb25Gcm9tUGVuZGluZ0xp c3QoKTsKIAogICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG1fb2Jq ZWN0U3RvcmU7CisgICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gbV90 cmFuc2FjdGlvbjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dl YkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3Rv cmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmNwcAppbmRleCBlNWY4MWFiNGRjMzM3OTg5 MjEwNDM3NTliZDJlYTg0NzNhM2I1YjVlLi42NTE5NTBlNDYwNzYyMDQ2ZjdjZmM3YWU0ODBiZjJh YzgwNzAxNmVhIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNr ZW5kSW1wbC5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZElt cGwuY3BwCkBAIC0zNiw2ICszNiw4IEBACiAjaW5jbHVkZSAiSURCS2V5UGF0aC5oIgogI2luY2x1 ZGUgIklEQktleVBhdGhCYWNrZW5kSW1wbC5oIgogI2luY2x1ZGUgIklEQktleVJhbmdlLmgiCisj aW5jbHVkZSAiSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgiCisjaW5jbHVkZSAiSURC VHJhbnNhY3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1ZGUgIlNRTGl0ZURhdGFiYXNlLmgiCiAj aW5jbHVkZSAiU1FMaXRlU3RhdGVtZW50LmgiCiAjaW5jbHVkZSAiU1FMaXRlVHJhbnNhY3Rpb24u aCIKQEAgLTc3LDggKzc5LDE0IEBAIHN0YXRpYyB2b2lkIGJpbmRXaGVyZUNsYXVzZShTUUxpdGVT dGF0ZW1lbnQmIHF1ZXJ5LCBpbnQ2NF90IGlkLCBJREJLZXkqIGtleSkKICAgICBrZXktPmJpbmQo cXVlcnksIDIpOwogfQogCi12b2lkIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldChQYXNz UmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4gY2FsbGJhY2tzKQor dm9pZCBJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjpnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtl eSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+IGNhbGxiYWNrcywgSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbikKIHsKKyAgICBpZiAodHJhbnNhY3Rpb24pIHsKKyAg ICAgICAgaWYgKCF0cmFuc2FjdGlvbi0+c2NoZWR1bGVUYXNrKGNyZWF0ZVRhc2sodGhpcywgJklE Qk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldCwga2V5LCBjYWxsYmFja3MpKSkKKyAgICAgICAg ICAgIGNhbGxiYWNrcy0+b25FcnJvcihJREJEYXRhYmFzZUVycm9yOjpjcmVhdGUoSURCRGF0YWJh c2VFeGNlcHRpb246Ok5PVF9BTExPV0VEX0VSUiwgIkdldCBtdXN0IGJlIGNhbGxlZCBpbiB0aGUg Y29udGV4dCBvZiBhIHRyYW5zYWN0aW9uLiIpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwog ICAgIFNRTGl0ZVN0YXRlbWVudCBxdWVyeShzcWxpdGVEYXRhYmFzZSgpLCAiU0VMRUNUIGtleVN0 cmluZywga2V5RGF0ZSwga2V5TnVtYmVyLCB2YWx1ZSBGUk9NIE9iamVjdFN0b3JlRGF0YSAiICsg d2hlcmVDbGF1c2Uoa2V5LmdldCgpKSk7CiAgICAgYm9vbCBvayA9IHF1ZXJ5LnByZXBhcmUoKSA9 PSBTUUxSZXN1bHRPazsKICAgICBBU1NFUlRfVU5VU0VEKG9rLCBvayk7IC8vIEZJWE1FOiBCZXR0 ZXIgZXJyb3IgaGFuZGxpbmc/CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0 U3RvcmVCYWNrZW5kSW1wbC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2Vu ZEltcGwuaAppbmRleCAzMmVmOTIwMzIyMTMyOWZlNWFlNTI3ZTFlM2E2NzllZmNjZTllZmZlLi4z ZmZlNTAxZDIxMzgzMzkyN2U5ZmI0NmQ1NjQ4Zjc2YTYxYjg3YzgzIDEwMDY0NAotLS0gYS9XZWJD b3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5oCisrKyBiL1dlYkNvcmUvc3Rv cmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmgKQEAgLTI3LDYgKzI3LDcgQEAKICNkZWZp bmUgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbF9oCiAKICNpbmNsdWRlICJJREJPYmplY3RTdG9y ZUJhY2tlbmRJbnRlcmZhY2UuaCIKKyNpbmNsdWRlIDxTY3JpcHRFeGVjdXRpb25Db250ZXh0Lmg+ CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNo Lmg+CiAKQEAgLTM2LDYgKzM3LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBJREJE YXRhYmFzZUJhY2tlbmRJbXBsOwogY2xhc3MgSURCSW5kZXhCYWNrZW5kSW1wbDsKK2NsYXNzIElE QlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZTsKIGNsYXNzIFNRTGl0ZURhdGFiYXNlOwogCiBj bGFzcyBJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsIDogcHVibGljIElEQk9iamVjdFN0b3JlQmFj a2VuZEludGVyZmFjZSB7CkBAIC01MSw3ICs1Myw3IEBAIHB1YmxpYzoKICAgICBTdHJpbmcga2V5 UGF0aCgpIGNvbnN0IHsgcmV0dXJuIG1fa2V5UGF0aDsgfQogICAgIFBhc3NSZWZQdHI8RE9NU3Ry aW5nTGlzdD4gaW5kZXhOYW1lcygpIGNvbnN0OwogCi0gICAgdm9pZCBnZXQoUGFzc1JlZlB0cjxJ REJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKKyAgICB2b2lkIGdldChQYXNz UmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4sIElEQlRyYW5zYWN0 aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pOwogICAgIHZvaWQgcHV0KFBhc3NSZWZQ dHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiB2YWx1ZSwgUGFzc1JlZlB0cjxJREJLZXk+IGtleSwg Ym9vbCBhZGRPbmx5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwogICAgIHZvaWQgcmVtb3Zl KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAKQEAg LTY5LDYgKzcxLDMzIEBAIHByaXZhdGU6CiAgICAgdm9pZCBsb2FkSW5kZXhlcygpOwogICAgIFNR TGl0ZURhdGFiYXNlJiBzcWxpdGVEYXRhYmFzZSgpIGNvbnN0OwogCisgICAgdGVtcGxhdGUgPGNs YXNzIFQsIGNsYXNzIE1ldGhvZCwgY2xhc3MgUGFyYW0xLCBjbGFzcyBQYXJhbTI+CisgICAgY2xh c3MgSURCVGFzayA6IHB1YmxpYyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKKyAgICBw dWJsaWM6CisgICAgICAgIElEQlRhc2soVCogb2JqLCBNZXRob2QgbWV0aG9kLCBjb25zdCBQYXJh bTEmIHBhcmFtMSwgY29uc3QgUGFyYW0yJiBwYXJhbTIpCisgICAgICAgICAgICA6IG1fb2JqKG9i aiksIG1fbWV0aG9kKG1ldGhvZCksIG1fcGFyYW0xKHBhcmFtMSksIG1fcGFyYW0yKHBhcmFtMikg CisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFz ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KikgCisgICAgICAgIHsKKyAgICAgICAgICAgIGlmICht X29iaikKKyAgICAgICAgICAgICAgICAobV9vYmotPiptX21ldGhvZCkobV9wYXJhbTEsIG1fcGFy YW0yLCAwKTsKKyAgICAgICAgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgVCogbV9vYmo7Cisg ICAgICAgIE1ldGhvZCBtX21ldGhvZDsKKyAgICAgICAgUGFyYW0xIG1fcGFyYW0xOworICAgICAg ICBQYXJhbTIgbV9wYXJhbTI7CisgICAgfTsKKworICAgIHRlbXBsYXRlIDxjbGFzcyBULCBjbGFz cyBNZXRob2QsIGNsYXNzIFBhcmFtMSwgY2xhc3MgUGFyYW0yPgorICAgIFBhc3NPd25QdHI8U2Ny aXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gY3JlYXRlVGFzayhUKiBvYmplY3QsIE1ldGhvZCBt ZXRob2QsIGNvbnN0IFBhcmFtMSYgcGFyYW0xLCBjb25zdCBQYXJhbTImIHBhcmFtMikKKyAgICB7 CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgSURCVGFzazxULCBNZXRob2QsIFBhcmFtMSwg UGFyYW0yPihvYmplY3QsIG1ldGhvZCwgcGFyYW0xLCBwYXJhbTIpKTsKKyAgICB9CisKICAgICBS ZWZQdHI8SURCRGF0YWJhc2VCYWNrZW5kSW1wbD4gbV9kYXRhYmFzZTsKIAogICAgIGludDY0X3Qg bV9pZDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJ bnRlcmZhY2UuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZh Y2UuaAppbmRleCAyMDBhYzI5YmE3Y2NhMTU5ODE4NWUzNTkzYmZhNGQ2ZmI2M2ExZDRlLi5jMTk4 NTVjNzZkZTFlNjI1MjQzODU5MjE3N2U5YzAxZjc3MjMyMTlkIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgKKysrIGIvV2ViQ29yZS9z dG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZS5oCkBAIC0zOCw2ICszOCw3IEBA IGNsYXNzIElEQkNhbGxiYWNrczsKIGNsYXNzIElEQkluZGV4QmFja2VuZEludGVyZmFjZTsKIGNs YXNzIElEQktleTsKIGNsYXNzIElEQktleVJhbmdlOworY2xhc3MgSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW50ZXJmYWNlOwogY2xhc3MgU2VyaWFsaXplZFNjcmlwdFZhbHVlOwogCiBjbGFzcyBJREJP YmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxJREJP YmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IHsKQEAgLTQ4LDcgKzQ5LDcgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgU3RyaW5nIGtleVBhdGgoKSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBQYXNz UmVmUHRyPERPTVN0cmluZ0xpc3Q+IGluZGV4TmFtZXMoKSBjb25zdCA9IDA7CiAKLSAgICB2aXJ0 dWFsIHZvaWQgZ2V0KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJh Y2tzPikgPSAwOworICAgIHZpcnR1YWwgdm9pZCBnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwg UGFzc1JlZlB0cjxJREJDYWxsYmFja3M+LCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2Uq IHRyYW5zYWN0aW9uKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHB1dChQYXNzUmVmUHRyPFNlcmlh bGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIGJvb2wgYWRk T25seSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHJl bW92ZShQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pID0g MDsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1v bml0b3IuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3Iu Y3BwCmluZGV4IGQwMjYwOTkwOGFiNTdjZGMwMWQzOTg2OTVlYjI2NTM2MzIzNjFhOWIuLjdlOWZj ZmZmYTVmZGFkMTViMjBmYTUyYjg0YzA1NThiMDEzNGY1N2IgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv c3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcAorKysgYi9XZWJDb3JlL3N0 b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5jcHAKQEAgLTI4LDQ0ICsyOCw1MyBA QAogCiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAKKyNpbmNsdWRlICJJREJGYWN0b3J5 QmFja2VuZEludGVyZmFjZS5oIgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVZlY3RvcjxpbnQ+ KiBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjptX2lkcyA9IDA7CitWZWN0b3I8SURCVHJh bnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKj4qIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6 Om1fdHJhbnNhY3Rpb25zID0gMDsKIAotYm9vbCBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9y OjpoYXNQZW5kaW5nVHJhbnNhY3Rpb25zKCkKK3ZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9u aXRvcjo6YWRkUGVuZGluZ1RyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFj ZSogdHJhbnNhY3Rpb24pCiB7Ci0gICAgcmV0dXJuIG1faWRzICYmIG1faWRzLT5zaXplKCk7Cisg ICAgaWYgKCFtX3RyYW5zYWN0aW9ucykKKyAgICAgICAgbV90cmFuc2FjdGlvbnMgPSBuZXcgVmVj dG9yPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSo+KCk7CisgICAgbV90cmFuc2FjdGlv bnMtPmFwcGVuZCh0cmFuc2FjdGlvbik7CiB9CiAKLXZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9u TW9uaXRvcjo6YWRkUGVuZGluZ1RyYW5zYWN0aW9uKGludCBpZCkKK3ZvaWQgSURCUGVuZGluZ1Ry YW5zYWN0aW9uTW9uaXRvcjo6cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9u QmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiB7Ci0gICAgaWYgKCFtX2lkcykKLSAgICAg ICAgbV9pZHMgPSBuZXcgVmVjdG9yPGludD4oKTsKLSAgICBtX2lkcy0+YXBwZW5kKGlkKTsKLX0K KyAgICBpZiAoIW1fdHJhbnNhY3Rpb25zKQorICAgICAgICByZXR1cm47CiAKLXZvaWQgSURCUGVu ZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKGludCBpZCkK LXsKLSAgICBtX2lkcy0+cmVtb3ZlKGlkKTsKLSAgICBpZiAoIW1faWRzLT5zaXplKCkpIHsKLSAg ICAgICAgZGVsZXRlIG1faWRzOwotICAgICAgICBtX2lkcyA9IDA7CisgICAgc2l6ZV90IHBvcyA9 IG1fdHJhbnNhY3Rpb25zLT5maW5kKHRyYW5zYWN0aW9uKTsKKyAgICBpZiAocG9zID09IG5vdEZv dW5kKQorICAgICAgICByZXR1cm47CisKKyAgICBtX3RyYW5zYWN0aW9ucy0+cmVtb3ZlKHBvcyk7 CisKKyAgICBpZiAoIW1fdHJhbnNhY3Rpb25zLT5zaXplKCkpIHsKKyAgICAgICAgZGVsZXRlIG1f dHJhbnNhY3Rpb25zOworICAgICAgICBtX3RyYW5zYWN0aW9ucyA9IDA7CiAgICAgfQogfQogCi12 b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmNsZWFyUGVuZGluZ1RyYW5zYWN0aW9u cygpCit2b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmFib3J0UGVuZGluZ1RyYW5z YWN0aW9ucyhJREJGYWN0b3J5QmFja2VuZEludGVyZmFjZSogaWRiRmFjdG9yeSkKIHsKLSAgICBp ZiAoIW1faWRzKQorICAgIGlmICghbV90cmFuc2FjdGlvbnMpCiAgICAgICAgIHJldHVybjsKIAot ICAgIG1faWRzLT5jbGVhcigpOwotICAgIGRlbGV0ZSBtX2lkczsKLSAgICBtX2lkcyA9IDA7Cisg ICAgVmVjdG9yPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSo+IHBlbmRpbmdUcmFuc2Fj dGlvbnM7CisgICAgcGVuZGluZ1RyYW5zYWN0aW9ucy5zd2FwKCptX3RyYW5zYWN0aW9ucyk7Cisg ICAgZGVsZXRlIG1fdHJhbnNhY3Rpb25zOworICAgIG1fdHJhbnNhY3Rpb25zID0gMDsKKyAgICBB U1NFUlQoaWRiRmFjdG9yeSk7CisgICAgaWRiRmFjdG9yeS0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rp b25zKHBlbmRpbmdUcmFuc2FjdGlvbnMpOwogfQogCi1jb25zdCBWZWN0b3I8aW50PiYgSURCUGVu ZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6cGVuZGluZ1RyYW5zYWN0aW9ucygpCit2b2lkIElEQlBl bmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24o SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbiwgSURCRmFjdG9yeUJh Y2tlbmRJbnRlcmZhY2UqIGlkYkZhY3RvcnkpCiB7Ci0gICAgcmV0dXJuICptX2lkczsKKyAgICAv LyBGSVhNRTogY2hlY2sgaWYgd2UgaGFkIGFueSBleGNlcHRpb24gZHVyaW5nIHRoZSBldmVudCBh bmQgbm90aWZ5IHRoZSBmYWN0b3J5IHRvIGFib3J0IHRoZSB0cmFuc2FjdGlvbi4KKyAgICBpZGJG YWN0b3J5LT5kaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKHRyYW5zYWN0aW9uKTsKIH0K IAogfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25N b25pdG9yLmggYi9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5o CmluZGV4IDAwZTgzM2FmYjIyMTg1M2JkOTliMzkzODQxNTE2MGYzZGNjN2M2ZjYuLjA5OWM4MjAy ZmVjYWRkMjkzYTllMjg0YjA4OGMzNzI4MmQ1ZjM4MzAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3Rv cmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdl L0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuaApAQCAtMzMsMjcgKzMzLDI5IEBACiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAorY2xhc3MgSURCRmFjdG9yeUJhY2tlbmRJbnRlcmZhY2U7Citj bGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7CisKIC8vIFRoaXMgY2xhc3Mga2Vl cHMgdHJhY2sgb2YgdGhlIHRyYW5zYWN0aW9ucyBjcmVhdGVkIGR1cmluZyB0aGUgY3VycmVudAog Ly8gSmF2YXNjcmlwdCBleGVjdXRpb24gY29udGV4dC4gQSB0cmFuc2FjdGlvbiBpcyAncGVuZGlu ZycgaWYgbm8gYXN5bmNocm9ub3VzCiAvLyBvcGVyYXRpb24gaXMgY3VycmVudGx5IHF1ZXVlZCBm b3IgaXQgKGUuZy4gYW4gSURCT2JqZWN0U3RvcmU6OnB1dCgpIG9yIHNpbWlsYXIpLgogLy8gQWxs IHBlbmRpbmcgdHJhbnNhY3Rpb25zIGFyZSBhYm9ydGVkIGFzIHNvb24gYXMgZXhlY3V0aW9uIHJl dHVybnMgZnJvbQogLy8gdGhlIHNjcmlwdCBlbmdpbmUuCiAvLwotLy8gRklYTUU6IG1vdmUgdGhl IHZlY3RvciBvZiB0cmFuc2FjdGlvbiBJRHMgdG8gVExTLiBLZWVwaW5nIGl0IHN0YXRpYworLy8g RklYTUU6IG1vdmUgdGhlIHZlY3RvciBvZiB0cmFuc2FjdGlvbnMgdG8gVExTLiBLZWVwaW5nIGl0 IHN0YXRpYwogLy8gd2lsbCBub3Qgd29yayBvbmNlIHdlIGFkZCBzdXBwb3J0IGZvciB3b3JrZXJz LiBBbm90aGVyIHBvc3NpYmxlCiAvLyBzb2x1dGlvbiBpcyB0byBrZWVwIHRoZSB2ZWN0b3IgaW4g dGhlIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuCiBjbGFzcyBJREJQZW5kaW5nVHJhbnNhY3Rpb25N b25pdG9yIDogcHVibGljIE5vbmNvcHlhYmxlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgYm9vbCBo YXNQZW5kaW5nVHJhbnNhY3Rpb25zKCk7Ci0gICAgc3RhdGljIHZvaWQgYWRkUGVuZGluZ1RyYW5z YWN0aW9uKGludCBpZCk7Ci0gICAgc3RhdGljIHZvaWQgcmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9u KGludCBpZCk7Ci0gICAgc3RhdGljIHZvaWQgY2xlYXJQZW5kaW5nVHJhbnNhY3Rpb25zKCk7Ci0g ICAgc3RhdGljIGNvbnN0IFZlY3RvcjxpbnQ+JiBwZW5kaW5nVHJhbnNhY3Rpb25zKCk7CisgICAg c3RhdGljIHZvaWQgYWRkUGVuZGluZ1RyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZElu dGVyZmFjZSopOworICAgIHN0YXRpYyB2b2lkIHJlbW92ZVBlbmRpbmdUcmFuc2FjdGlvbihJREJU cmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqKTsKKyAgICBzdGF0aWMgdm9pZCBhYm9ydFBlbmRp bmdUcmFuc2FjdGlvbnMoSURCRmFjdG9yeUJhY2tlbmRJbnRlcmZhY2UqKTsKKyAgICBzdGF0aWMg dm9pZCBkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZSosIElEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlKik7CiAKIHByaXZhdGU6CiAg ICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcigpOwogCi0gICAgc3RhdGljIFZlY3Rvcjxp bnQ+KiBtX2lkczsKKyAgICBzdGF0aWMgVmVjdG9yPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZSo+KiBtX3RyYW5zYWN0aW9uczsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0LmNwcCBiL1dlYkNvcmUvc3RvcmFn ZS9JREJSZXF1ZXN0LmNwcAppbmRleCA2ZmJkYTBlZWM4OWViMmFhMDljMjBjM2JkMTNmMGU4ZGQ2 MzliZTY0Li44ZTI2ZmU4MzgwZmU1NjI4OGE3NzRkNmM1ZjFjZmY2YmU1ZTVjYzZlIDEwMDY0NAot LS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdl L0lEQlJlcXVlc3QuY3BwCkBAIC0zNSwyMyArMzUsMzAgQEAKICNpbmNsdWRlICJFdmVudEV4Y2Vw dGlvbi5oIgogI2luY2x1ZGUgIkV2ZW50TGlzdGVuZXIuaCIKICNpbmNsdWRlICJFdmVudE5hbWVz LmgiCisjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJJREJDdXJzb3IuaCIKICNpbmNsdWRl ICJJREJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIklEQkluZGV4LmgiCiAjaW5jbHVkZSAiSURCRXJy b3JFdmVudC5oIgogI2luY2x1ZGUgIklEQk9iamVjdFN0b3JlLmgiCisjaW5jbHVkZSAiSURCUGVu ZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oIgogI2luY2x1ZGUgIklEQlN1Y2Nlc3NFdmVudC5oIgor I2luY2x1ZGUgIlBhZ2UuaCIKKyNpbmNsdWRlICJQYWdlR3JvdXAuaCIKICNpbmNsdWRlICJTY3Jp cHRFeGVjdXRpb25Db250ZXh0LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotSURCUmVxdWVz dDo6SURCUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRy PElEQkFueT4gc291cmNlKQorSURCUmVxdWVzdDo6SURCUmVxdWVzdChTY3JpcHRFeGVjdXRpb25D b250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlLCBJREJUcmFuc2FjdGlv bkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKQogICAgIDogQWN0aXZlRE9NT2JqZWN0KGNv bnRleHQsIHRoaXMpCiAgICAgLCBtX3NvdXJjZShzb3VyY2UpCisgICAgLCBtX3RyYW5zYWN0aW9u KHRyYW5zYWN0aW9uKQogICAgICwgbV90aW1lcih0aGlzLCAmSURCUmVxdWVzdDo6dGltZXJGaXJl ZCkKICAgICAsIG1fYWJvcnRlZChmYWxzZSkKICAgICAsIG1fcmVhZHlTdGF0ZShMT0FESU5HKQog eworICAgIGlmICh0cmFuc2FjdGlvbikKKyAgICAgICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9u aXRvcjo6cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKHRyYW5zYWN0aW9uKTsKIH0KIAogSURCUmVx dWVzdDo6fklEQlJlcXVlc3QoKQpAQCAtMTAwLDcgKzEwNywxMCBAQCB2b2lkIElEQlJlcXVlc3Q6 Om9uU3VjY2VzcyhQYXNzUmVmUHRyPElEQktleT4gaWRiS2V5KQogCiB2b2lkIElEQlJlcXVlc3Q6 Om9uU3VjY2VzcyhQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gYmFj a2VuZCkKIHsKLSAgICBzY2hlZHVsZUV2ZW50KElEQkFueTo6Y3JlYXRlKElEQk9iamVjdFN0b3Jl OjpjcmVhdGUoYmFja2VuZCkpLCAwKTsKKyAgICAvLyBGSVhNRTogdGhlIHRyYW5zYWN0aW9uIGlk IHNob3VsZCBiZSB0aGUgb25lIG9mIHRoZSBzZXRWZXJzaW9uIHRyYW5zYWN0aW9uLgorICAgIC8v IFRoaXMgaXMgYmVjYXVzZSB0aGlzIGNhbGxiYWNrIGlzIG9ubHkgZXhlY3V0ZWQgZm9yIG9wZXJh dGlvbnMgdGhhdCBuZWVkCisgICAgLy8gdG8gcnVuIGluIGEgc2V0VmVyc2lvbiB0cmFuc2FjdGlv bi4KKyAgICBzY2hlZHVsZUV2ZW50KElEQkFueTo6Y3JlYXRlKElEQk9iamVjdFN0b3JlOjpjcmVh dGUoYmFja2VuZCwgMCkpLCAwKTsKIH0KIAogdm9pZCBJREJSZXF1ZXN0OjpvblN1Y2Nlc3MoUGFz c1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHNlcmlhbGl6ZWRTY3JpcHRWYWx1ZSkKQEAg LTE2MSw2ICsxNzEsMTQgQEAgdm9pZCBJREJSZXF1ZXN0Ojp0aW1lckZpcmVkKFRpbWVyPElEQlJl cXVlc3Q+KikKICAgICAgICAgICAgIGRpc3BhdGNoRXZlbnQoSURCU3VjY2Vzc0V2ZW50OjpjcmVh dGUobV9zb3VyY2UsIHBlbmRpbmdFdmVudHNbaV0ubV9yZXN1bHQpKTsKICAgICAgICAgfQogICAg IH0KKyAgICBpZiAobV90cmFuc2FjdGlvbi5nZXQoKSkgeworICAgICAgICAvLyBOb3cgdGhhdCB3 ZSBwcm9jZXNzZWQgYWxsIHBlbmRpbmcgZXZlbnRzLCBsZXQgdGhlIHRyYW5zYWN0aW9uIG1vbml0 b3IgY2hlY2sgaWYKKyAgICAgICAgLy8gaXQgY2FuIGNvbW1pdCB0aGUgY3VycmVudCB0cmFuc2Fj dGlvbiBvciBpZiB0aGVyZSdzIGFueXRoaW5nIG5ldyBwZW5kaW5nLgorICAgICAgICAvLyBGSVhN RTogSGFuZGxlIHRoZSB3b3JrZXJzIGNhc2UuCisgICAgICAgIEFTU0VSVChzY3JpcHRFeGVjdXRp b25Db250ZXh0KCktPmlzRG9jdW1lbnQoKSk7CisgICAgICAgIElEQlBlbmRpbmdUcmFuc2FjdGlv bk1vbml0b3I6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24obV90cmFuc2FjdGlvbi5n ZXQoKSwgc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihzY3JpcHRFeGVjdXRpb25Db250ZXh0KCkpLT5m cmFtZSgpLT5wYWdlKCktPmdyb3VwKCkuaWRiRmFjdG9yeSgpKTsKKyAgICAgICAgbV90cmFuc2Fj dGlvbi5jbGVhcigpOworICAgIH0KIH0KIAogdm9pZCBJREJSZXF1ZXN0OjpzY2hlZHVsZUV2ZW50 KFBhc3NSZWZQdHI8SURCQW55PiByZXN1bHQsIFBhc3NSZWZQdHI8SURCRGF0YWJhc2VFcnJvcj4g ZXJyb3IpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5oIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQlJlcXVlc3QuaAppbmRleCA5YjBlYTdlYWYyMWNiZWEyM2U2YmQ0YTgwNzgx NTJkODkzMzdjN2QyLi5jMDUxNWFhZTI2NjBjNDYzY2E5YTg0MWE3YWM3OTk1ZDRmZjM4OWU4IDEw MDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5oCisrKyBiL1dlYkNvcmUvc3Rv cmFnZS9JREJSZXF1ZXN0LmgKQEAgLTQyLDkgKzQyLDExIEBACiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAorY2xhc3MgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlOworCiBjbGFzcyBJREJS ZXF1ZXN0IDogcHVibGljIElEQkNhbGxiYWNrcywgcHVibGljIEV2ZW50VGFyZ2V0LCBwdWJsaWMg QWN0aXZlRE9NT2JqZWN0IHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJSZXF1 ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJ REJBbnk+IHNvdXJjZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IElEQlJlcXVlc3QoY29udGV4dCwg c291cmNlKSk7IH0KKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBjcmVhdGUoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJBbnk+IHNvdXJjZSwg SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbiA9IDApIHsgcmV0dXJu IGFkb3B0UmVmKG5ldyBJREJSZXF1ZXN0KGNvbnRleHQsIHNvdXJjZSwgdHJhbnNhY3Rpb24pKTsg fQogICAgIHZpcnR1YWwgfklEQlJlcXVlc3QoKTsKIAogICAgIC8vIERlZmluZWQgaW4gdGhlIElE TApAQCAtODAsNyArODIsNyBAQCBwdWJsaWM6CiAgICAgdXNpbmcgUmVmQ291bnRlZDxJREJDYWxs YmFja3M+OjpkZXJlZjsKIAogcHJpdmF0ZToKLSAgICBJREJSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlKTsKKyAgICBJREJSZXF1ZXN0KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlLCBJREJUcmFu c2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKTsKIAogICAgIHZvaWQgdGltZXJG aXJlZChUaW1lcjxJREJSZXF1ZXN0PiopOwogICAgIHZvaWQgc2NoZWR1bGVFdmVudChQYXNzUmVm UHRyPElEQkFueT4gcmVzdWx0LCBQYXNzUmVmUHRyPElEQkRhdGFiYXNlRXJyb3I+KTsKQEAgLTky LDYgKzk0LDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIEV2ZW50VGFyZ2V0RGF0YSogZW5zdXJl RXZlbnRUYXJnZXREYXRhKCk7CiAKICAgICBSZWZQdHI8SURCQW55PiBtX3NvdXJjZTsKKyAgICBS ZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBtX3RyYW5zYWN0aW9uOwogCiAg ICAgc3RydWN0IFBlbmRpbmdFdmVudCB7CiAgICAgICAgIFJlZlB0cjxJREJBbnk+IG1fcmVzdWx0 OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uLmNwcCBiL1dlYkNv cmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbi5jcHAKaW5kZXggNGU5MzM3OGRkYjdiZWIyYjJiODc1 MzRiZTY3YjM3NGRkMzM4NDk1OC4uZTViZTRhZTAzOTIzOTcyYjBiZTExOGIxZmIwZjZiMTc5NzQx OGM2YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uLmNwcAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb24uY3BwCkBAIC00Niw3ICs0Niw3IEBAIElE QlRyYW5zYWN0aW9uOjpJREJUcmFuc2FjdGlvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LCBQYXNzUmVmUHRyPElEQlRyCiAgICAgLCBtX3N0b3BwZWQoZmFsc2UpCiAgICAgLCBtX3Rp bWVyKHRoaXMsICZJREJUcmFuc2FjdGlvbjo6dGltZXJGaXJlZCkKIHsKLSAgICBJREJQZW5kaW5n VHJhbnNhY3Rpb25Nb25pdG9yOjphZGRQZW5kaW5nVHJhbnNhY3Rpb24obV9iYWNrZW5kLT5pZCgp KTsKKyAgICBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjphZGRQZW5kaW5nVHJhbnNhY3Rp b24obV9iYWNrZW5kLmdldCgpKTsKIH0KIAogSURCVHJhbnNhY3Rpb246On5JREJUcmFuc2FjdGlv bigpCkBAIC02Niw3ICs2NiwxMSBAQCBJREJEYXRhYmFzZSogSURCVHJhbnNhY3Rpb246OmRiKCkK IFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IElEQlRyYW5zYWN0aW9uOjpvYmplY3RTdG9yZShj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEV4Y2VwdGlvbkNvZGUmKQogewogICAgIFJlZlB0cjxJ REJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlQmFja2VuZCA9IG1fYmFj a2VuZC0+b2JqZWN0U3RvcmUobmFtZSk7Ci0gICAgUmVmUHRyPElEQk9iamVjdFN0b3JlPiBvYmpl Y3RTdG9yZSA9IElEQk9iamVjdFN0b3JlOjpjcmVhdGUob2JqZWN0U3RvcmVCYWNrZW5kKTsKKyAg ICBpZiAoIW9iamVjdFN0b3JlQmFja2VuZCkgeworICAgICAgICB0aHJvd0Vycm9yKE5PVF9TVVBQ T1JURURfRVJSKTsKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorICAgIFJlZlB0cjxJREJPYmpl Y3RTdG9yZT4gb2JqZWN0U3RvcmUgPSBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9iamVjdFN0b3Jl QmFja2VuZCwgbV9iYWNrZW5kLmdldCgpKTsKICAgICByZXR1cm4gb2JqZWN0U3RvcmUucmVsZWFz ZSgpOwogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5j cHAKaW5kZXggNTFiMzNiMjM0MDAxNDc3ZjNiNjI5ZDRmNTQ4MjIyODAzNGRjODFkMC4uNTZjM2M4 ZDk5YWE2ODNkMzBlYTZhYWFhMjAwOTNlYTBmOTI0YWY4ZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9z dG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFn ZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmNwcApAQCAtMjksMTEgKzI5LDEyIEBACiAjaWYg RU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAKICNpbmNsdWRlICJJREJEYXRhYmFzZUJhY2tlbmRJ bXBsLmgiCisjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1ZGUg IlNRTGl0ZURhdGFiYXNlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6 OmNyZWF0ZShET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUs IHVuc2lnbmVkIGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKiBk YXRhYmFzZSkKK1Bhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4gSURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbDo6Y3JlYXRlKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3JlcywgdW5z aWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBpbnQgaWQsIElEQkRhdGFi YXNlQmFja2VuZEltcGwqIGRhdGFiYXNlKQogewogICAgIHJldHVybiBhZG9wdFJlZihuZXcgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbChvYmplY3RTdG9yZXMsIG1vZGUsIHRpbWVvdXQsIGlkLCBk YXRhYmFzZSkpOwogfQpAQCAtNDMsMjYgKzQ0LDExMiBAQCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3Jl cwogICAgICwgbV9tb2RlKG1vZGUpCiAgICAgLCBtX3RpbWVvdXQodGltZW91dCkKICAgICAsIG1f aWQoaWQpCi0gICAgLCBtX2Fib3J0ZWQoZmFsc2UpCisgICAgLCBtX3N0YXRlKElETEUpCiAgICAg LCBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAgICwgbV90cmFuc2FjdGlvbihuZXcgU1FMaXRlVHJh bnNhY3Rpb24oZGF0YWJhc2UtPnNxbGl0ZURhdGFiYXNlKCkpKQorICAgICwgbV90aW1lcih0aGlz LCAmSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZCkKKyAgICAsIG1fcGVuZGlu Z0V2ZW50cygwKQogewogfQogCiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZT4gSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5n JiBuYW1lKQogewotICAgIHJldHVybiBtX2RhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1lLCAwKTsg Ly8gRklYTUU6IHJlbW92ZSBtb2RlIHBhcmFtLgorICAgIGlmIChpc0ZpbmlzaGVkKCkpCisgICAg ICAgIHJldHVybiAwOworICAgIHJldHVybiBtX2RhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1lLCAw LCB0aGlzKTsgLy8gRklYTUU6IHJlbW92ZSBtb2RlIHBhcmFtLgogfQogCi12b2lkIElEQlRyYW5z YWN0aW9uQmFja2VuZEltcGw6OnNjaGVkdWxlVGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2s+KQorYm9vbCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpzY2hlZHVs ZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrKQogewot ICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQuCi0gICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAg aWYgKGlzRmluaXNoZWQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgbV90YXNrUXVl dWUuYXBwZW5kKHRhc2spOworICAgIGlmIChtX3N0YXRlID09IElETEUpCisgICAgICAgIHN0YXJ0 KCk7CisKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAogdm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsOjphYm9ydCgpCiB7Ci0gICAgbV9hYm9ydGVkID0gdHJ1ZTsKKyAgICBpZiAoaXNGaW5pc2hl ZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBtX3N0YXRlID0gRklOSVNIRUQ7CisgICAgbV90 cmFuc2FjdGlvbi0+cm9sbGJhY2soKTsKICAgICBtX2NhbGxiYWNrcy0+b25BYm9ydCgpOworCisg ICAgZGlkRmluaXNoVHJhbnNhY3Rpb24oKTsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tl bmRJbXBsOjpkaWRDb21wbGV0ZVRhc2tFdmVudHMoKQoreworICAgIEFTU0VSVChtX3N0YXRlID09 IFNUQVJURUQpOworICAgIEFTU0VSVChtX3BlbmRpbmdFdmVudHMpOworCisgICAgbV9wZW5kaW5n RXZlbnRzLS07CisKKyAgICBpZiAoIW1fcGVuZGluZ0V2ZW50cyAmJiBtX3Rhc2tRdWV1ZS5pc0Vt cHR5KCkpIHsKKyAgICAgICAgLy8gVGhlIGxhc3QgdGFzayBldmVudCBoYXMgY29tcGxldGVkIGFu ZCB0aGUgdGFzaworICAgICAgICAvLyBxdWV1ZSBpcyBlbXB0eS4gQ29tbWl0IHRoZSB0cmFuc2Fj dGlvbi4KKyAgICAgICAgY29tbWl0KCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICAv LyBXZSBhcmUgc3RpbGwgd2FpdGluZyBmb3Igb3RoZXIgZXZlbnRzIHRvIGNvbXBsZXRlLiBIb3dl dmVyLAorICAgIC8vIHRoZSB0YXNrIHF1ZXVlIGlzIG5vbi1lbXB0eSBhbmQgdGhlIHRpbWVyIGlz IGluYWN0aXZlLgorICAgIC8vIFdlIGNhbiB0aGVyZm9yZSBzY2hlZHVsZSB0aGUgdGltZXIgYWdh aW4uCisgICAgaWYgKCFtX3Rhc2tRdWV1ZS5pc0VtcHR5KCkgJiYgIW1fdGltZXIuaXNBY3RpdmUo KSkKKyAgICAgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgSURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbDo6cnVuKCkKK3sKKyAgICBBU1NFUlQobV9zdGF0ZSA9PSBTVEFSVEVE KTsKKyAgICBBU1NFUlQoIW1fdGltZXIuaXNBY3RpdmUoKSk7CisKKyAgICBtX3RpbWVyLnN0YXJ0 T25lU2hvdCgwKTsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpzdGFydCgp Cit7CisgICAgQVNTRVJUKG1fc3RhdGUgPT0gSURMRSk7CisKKyAgICBtX3N0YXRlID0gU1RBUlRF RDsKKyAgICBtX3RyYW5zYWN0aW9uLT5iZWdpbigpOworCisgICAgbV9kYXRhYmFzZS0+dHJhbnNh Y3Rpb25Db29yZGluYXRvcigpLT5kaWRTdGFydFRyYW5zYWN0aW9uKHRoaXMpOworfQorCit2b2lk IElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OmNvbW1pdCgpCit7CisgICAgQVNTRVJUKG1fc3Rh dGUgPT0gU1RBUlRFRCk7CisgICAgbV9zdGF0ZSA9IEZJTklTSEVEOworICAgIG1fdHJhbnNhY3Rp b24tPmNvbW1pdCgpOworCisgICAgZGlkRmluaXNoVHJhbnNhY3Rpb24oKTsKK30KKwordm9pZCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpkaWRGaW5pc2hUcmFuc2FjdGlvbigpCit7CisgICAg bV9kYXRhYmFzZS0+dHJhbnNhY3Rpb25Db29yZGluYXRvcigpLT5kaWRGaW5pc2hUcmFuc2FjdGlv bih0aGlzKTsKKyAgICBtX2RhdGFiYXNlLmNsZWFyKCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rp b25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZChUaW1lcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBs PiopCit7CisgICAgQVNTRVJUKCFtX3Rhc2tRdWV1ZS5pc0VtcHR5KCkpOworICAgIEFTU0VSVCht X3N0YXRlID09IFNUQVJURUQpOworCisgICAgVGFza1F1ZXVlIHF1ZXVlOworICAgIHF1ZXVlLnN3 YXAobV90YXNrUXVldWUpOworICAgIHdoaWxlICghcXVldWUuaXNFbXB0eSgpKSB7CisgICAgICAg IE93blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrKHF1ZXVlLmZpcnN0KCku cmVsZWFzZSgpKTsKKyAgICAgICAgcXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICAgICAgdGFzay0+ cGVyZm9ybVRhc2soMCk7CisgICAgICAgIG1fcGVuZGluZ0V2ZW50cysrOworICAgIH0KIH0KIAog fTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBs LmggYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oCmluZGV4IGZi NTc0MDE3ZmFiZTUyNDNlYjVkN2MxN2E4MmIwYTI1ZTYyOGUwODcuLmE0ODRjYzBlNjFhYjc4Nzk0 N2U5NGEzNjdlNzZlYjRhZGNmOGE4MzEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJU cmFuc2FjdGlvbkJhY2tlbmRJbXBsLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0 aW9uQmFja2VuZEltcGwuaApAQCAtMzEsNiArMzEsOCBAQAogI2luY2x1ZGUgIkRPTVN0cmluZ0xp c3QuaCIKICNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaCIKICNpbmNs dWRlICJJREJUcmFuc2FjdGlvbkNhbGxiYWNrcy5oIgorI2luY2x1ZGUgPFNRTGl0ZVRyYW5zYWN0 aW9uLmg+CisjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0zOSwyNiArNDEsNDggQEAgY2xhc3MgSURCRGF0YWJh c2VCYWNrZW5kSW1wbDsKIAogY2xhc3MgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCA6IHB1Ymxp YyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UgewogcHVibGljOgotICAgIHN0YXRpYyBQ YXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gY3JlYXRlKERPTVN0cmlu Z0xpc3QqIG9iamVjdFN0b3JlcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0 aW1lb3V0LCBpbnQgaWQsIElEQkRhdGFiYXNlQmFja2VuZEltcGwqKTsKLSAgICB2aXJ0dWFsIH5J REJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKCkgeyB9CisgICAgc3RhdGljIFBhc3NSZWZQdHI8SURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4gY3JlYXRlKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3Jl cywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBpbnQgaWQsIElE QkRhdGFiYXNlQmFja2VuZEltcGwqKTsKKyAgICB2aXJ0dWFsIH5JREJUcmFuc2FjdGlvbkJhY2tl bmRJbXBsKCkgeyBhYm9ydCgpOyB9CiAKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0 U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUpOwog ICAgIHZpcnR1YWwgdW5zaWduZWQgc2hvcnQgbW9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fbW9kZTsg fQotICAgIHZpcnR1YWwgdm9pZCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPik7CisgICAgdmlydHVhbCBib29sIHNjaGVkdWxlVGFzayhQYXNzT3du UHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKICAgICB2aXJ0dWFsIHZvaWQgYWJv cnQoKTsKICAgICB2aXJ0dWFsIGludCBpZCgpIGNvbnN0IHsgcmV0dXJuIG1faWQ7IH0KICAgICB2 aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKElEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzKiBjYWxsYmFj a3MpIHsgbV9jYWxsYmFja3MgPSBjYWxsYmFja3M7IH0KIAorICAgIHZvaWQgcnVuKCk7CisgICAg dm9pZCBkaWRDb21wbGV0ZVRhc2tFdmVudHMoKTsKKyAgICBib29sIGlzRmluaXNoZWQoKSBjb25z dCB7IHJldHVybiBtX3N0YXRlID09IEZJTklTSEVEOyB9CisKIHByaXZhdGU6CiAgICAgSURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbChET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVk IHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJh Y2tlbmRJbXBsKik7CiAKKyAgICBlbnVtIFN0YXRlIHsKKyAgICAgICAgSURMRSwKKyAgICAgICAg U1RBUlRFRCwKKyAgICAgICAgRklOSVNIRUQsCisgICAgfTsKKworICAgIHZvaWQgc3RhcnQoKTsK KyAgICB2b2lkIGNvbW1pdCgpOworICAgIHZvaWQgZGlkRmluaXNoVHJhbnNhY3Rpb24oKTsKKwor ICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsPiopOwor CiAgICAgUmVmUHRyPERPTVN0cmluZ0xpc3Q+IG1fb2JqZWN0U3RvcmVOYW1lczsKICAgICB1bnNp Z25lZCBzaG9ydCBtX21vZGU7CiAgICAgdW5zaWduZWQgbG9uZyBtX3RpbWVvdXQ7CiAgICAgaW50 IG1faWQ7Ci0gICAgYm9vbCBtX2Fib3J0ZWQ7CisgICAgU3RhdGUgbV9zdGF0ZTsKICAgICBSZWZQ dHI8SURCVHJhbnNhY3Rpb25DYWxsYmFja3M+IG1fY2FsbGJhY2tzOwogICAgIFJlZlB0cjxJREJE YXRhYmFzZUJhY2tlbmRJbXBsPiBtX2RhdGFiYXNlOworICAgIHR5cGVkZWYgRGVxdWU8T3duUHRy PFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+ID4gVGFza1F1ZXVlOworICAgIFRhc2tRdWV1 ZSBtX3Rhc2tRdWV1ZTsKKyAgICBPd25QdHI8U1FMaXRlVHJhbnNhY3Rpb24+IG1fdHJhbnNhY3Rp b247CisgICAgLy8gRklYTUU6IGRlbGV0ZSB0aGUgdGltZXIgb25jZSB3ZSBoYXZlIHRocmVhZHMg aW5zdGVhZC4KKyAgICBUaW1lcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsPiBtX3RpbWVyOwor ICAgIGludCBtX3BlbmRpbmdFdmVudHM7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNl LmggYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgKaW5k ZXggMzk2NTFmMTAxNzVkZTcwNjBkMDQ1YTlmMGM2MjM5M2M2YWUzNzVkYy4uNmU5YzNjZTYwYzMw NWRkMmYzOGQ3NWQxOTNiMDk0OTI3NzFlMjU5YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdl L0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9J REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaApAQCAtNTAsNyArNTAsNyBAQCBwdWJsaWM6 CiAKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNl PiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUpID0gMDsKICAgICB2aXJ0dWFsIHVuc2ln bmVkIHNob3J0IG1vZGUoKSBjb25zdCA9IDA7Ci0gICAgdmlydHVhbCB2b2lkIHNjaGVkdWxlVGFz ayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KSA9IDA7CisgICAgdmly dHVhbCBib29sIHNjaGVkdWxlVGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OlRhc2s+KSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0KCkgPSAwOwogICAgIHZpcnR1YWwg aW50IGlkKCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBzZXRDYWxsYmFja3MoSURCVHJh bnNhY3Rpb25DYWxsYmFja3MqKSA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURC VHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rp b25Db29yZGluYXRvci5jcHAKaW5kZXggOTc5MGMxZjJkNzk1ZjY2MDZkNjE0YjQwM2I0M2YzNjJm YmYxYjBlYy4uZjUxNjQ5MjAyYzVjZTNlOWZmMWZlNGE1NWM2OGU3ZmMyOWY5ZDM4YiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcApAQCAtMzAsNiAr MzAsNyBAQAogCiAjaW5jbHVkZSAiSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oIgogI2luY2x1ZGUg IklEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZS5oIgorI2luY2x1ZGUgIklEQlBlbmRpbmdU cmFuc2FjdGlvbk1vbml0b3IuaCIKICNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBs LmgiCiAjaW5jbHVkZSAiU1FMaXRlRGF0YWJhc2UuaCIKICNpbmNsdWRlICJTY3JpcHRFeGVjdXRp b25Db250ZXh0LmgiCkBAIC00NywyMyArNDgsOTMgQEAgSURCVHJhbnNhY3Rpb25Db29yZGluYXRv cjo6fklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKQogCiBQYXNzUmVmUHRyPElEQlRyYW5zYWN0 aW9uQmFja2VuZEludGVyZmFjZT4gSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6Y3JlYXRlVHJh bnNhY3Rpb24oRE9NU3RyaW5nTGlzdCogb2JqZWN0U3RvcmVzLCB1bnNpZ25lZCBzaG9ydCBtb2Rl LCB1bnNpZ25lZCBsb25nIHRpbWVvdXQsIElEQkRhdGFiYXNlQmFja2VuZEltcGwqIGRhdGFiYXNl KQogewotICAgIFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0 aW9uID0gSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6Y3JlYXRlKG9iamVjdFN0b3JlcywgbW9k ZSwgdGltZW91dCwgKyttX25leHRJRCwgZGF0YWJhc2UpOwotICAgIG1fdHJhbnNhY3Rpb25RdWV1 ZS5hZGQodHJhbnNhY3Rpb24uZ2V0KCkpOwotICAgIG1faWRNYXAuYWRkKG1fbmV4dElELCB0cmFu c2FjdGlvbik7CisgICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw+IHRyYW5zYWN0 aW9uID0gSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6Y3JlYXRlKG9iamVjdFN0b3JlcywgbW9k ZSwgdGltZW91dCwgKyttX25leHRJRCwgZGF0YWJhc2UpOworICAgIG1fcGVuZGluZ1RyYW5zYWN0 aW9ucy5hZGQobV9uZXh0SUQsIHRyYW5zYWN0aW9uKTsKICAgICByZXR1cm4gdHJhbnNhY3Rpb24u cmVsZWFzZSgpOwogfQogCi12b2lkIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmFib3J0KGlu dCBpZCkKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6YWJvcnRQZW5kaW5nVHJhbnNh Y3Rpb25zKGNvbnN0IFZlY3RvcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqPiYgcGVu ZGluZ1RyYW5zYWN0aW9ucykKK3sKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHBlbmRpbmdU cmFuc2FjdGlvbnMuc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgaW50IGlkID0gcGVuZGluZ1RyYW5z YWN0aW9ucy5hdChpKS0+aWQoKTsKKyAgICAgICAgQVNTRVJUKG1fcGVuZGluZ1RyYW5zYWN0aW9u cy5jb250YWlucyhpZCkpOworICAgICAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlPiB0cmFuc2FjdGlvbiA9IG1fcGVuZGluZ1RyYW5zYWN0aW9ucy5nZXQoaWQpOworICAg ICAgICBBU1NFUlQodHJhbnNhY3Rpb24pOworICAgICAgICB0cmFuc2FjdGlvbi0+YWJvcnQoKTsK KyAgICB9Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6ZGlkQ29tcGxldGVF dmVudHNGb3JUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5z YWN0aW9uKQogewotICAgIEFTU0VSVChtX2lkTWFwLmNvbnRhaW5zKGlkKSk7Ci0gICAgUmVmUHRy PElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNhY3Rpb24gPSBtX2lkTWFwLmdl dChpZCk7CiAgICAgQVNTRVJUKHRyYW5zYWN0aW9uKTsKLSAgICBtX3RyYW5zYWN0aW9uUXVldWUu cmVtb3ZlKHRyYW5zYWN0aW9uLmdldCgpKTsKLSAgICBtX2lkTWFwLnJlbW92ZShpZCk7Ci0gICAg dHJhbnNhY3Rpb24tPmFib3J0KCk7Ci0gICAgLy8gRklYTUU6IHRoaXMgd2lsbCBjaGFuZ2Ugb25j ZSB3ZSBoYXZlIHRyYW5zYWN0aW9ucyBhY3R1YWxseSBydW5uaW5nLgorICAgIEFTU0VSVChtX3J1 bm5pbmdUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNhY3Rpb24tPmlkKCkpKTsKKyAgICBtX3J1 bm5pbmdUcmFuc2FjdGlvbnMuZ2V0KHRyYW5zYWN0aW9uLT5pZCgpKS0+ZGlkQ29tcGxldGVUYXNr RXZlbnRzKCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6ZGlkU3RhcnRU cmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKQor eworICAgIC8vIFJlbW92ZSBmcm9tIHBlbmRpbmcgdHJhbnNhY3Rpb25zIGxpc3QuCisgICAgQVNT RVJUKHRyYW5zYWN0aW9uKTsKKyAgICBpbnQgaWQgPSB0cmFuc2FjdGlvbi0+aWQoKTsKKyAgICBB U1NFUlQobV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKGlkKSk7CisgICAgUmVmUHRyPElE QlRyYW5zYWN0aW9uQmFja2VuZEltcGw+IHRyYW5zYWN0aW9uSW1wbCA9IG1fcGVuZGluZ1RyYW5z YWN0aW9ucy5nZXQoaWQpOworICAgIEFTU0VSVCh0cmFuc2FjdGlvbkltcGwpOworICAgIG1fcGVu ZGluZ1RyYW5zYWN0aW9ucy5yZW1vdmUoaWQpOworICAgIC8vIEFkZCB0byBzdGFydGVkIHRyYW5z YWN0aW9ucyBsaXN0CisgICAgbV9zdGFydGVkVHJhbnNhY3Rpb25RdWV1ZS5hZGQodHJhbnNhY3Rp b25JbXBsLmdldCgpKTsKKyAgICBtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuYWRkKGlkLCB0cmFuc2Fj dGlvbkltcGwucmVsZWFzZSgpKTsKKworICAgIHByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKCk7 Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6ZGlkRmluaXNoVHJhbnNhY3Rp b24oSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbikKK3sKKyAgICBp bnQgaWQgPSB0cmFuc2FjdGlvbi0+aWQoKTsKKyAgICBpZiAobV9wZW5kaW5nVHJhbnNhY3Rpb25z LmNvbnRhaW5zKGlkKSkgeworICAgICAgICBBU1NFUlQoIW1fc3RhcnRlZFRyYW5zYWN0aW9ucy5j b250YWlucyhpZCkpOworICAgICAgICBBU1NFUlQoIW1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250 YWlucyhpZCkpOworICAgICAgICBtX3BlbmRpbmdUcmFuc2FjdGlvbnMucmVtb3ZlKGlkKTsKKyAg ICB9IGVsc2UgaWYgKG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpIHsKKyAgICAg ICAgQVNTRVJUKCFtX3J1bm5pbmdUcmFuc2FjdGlvbnMuY29udGFpbnMoaWQpKTsKKyAgICAgICAg bV9zdGFydGVkVHJhbnNhY3Rpb25zLnJlbW92ZShpZCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAg QVNTRVJUKG1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250YWlucyhpZCkpOworICAgICAgICBtX3J1 bm5pbmdUcmFuc2FjdGlvbnMucmVtb3ZlKGlkKTsKKyAgICB9CisKKyAgICBwcm9jZXNzU3RhcnRl ZFRyYW5zYWN0aW9ucygpOworfQorCitJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIElE QlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OnRyYW5zYWN0aW9uKGludCB0cmFuc2FjdGlvbklEKQor eworICAgIGlmIChtX3BlbmRpbmdUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNhY3Rpb25JRCkp CisgICAgICAgIHJldHVybiBtX3BlbmRpbmdUcmFuc2FjdGlvbnMuZ2V0KHRyYW5zYWN0aW9uSUQp LmdldCgpOworCisgICAgaWYgKG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5jb250YWlucyh0cmFuc2Fj dGlvbklEKSkKKyAgICAgICAgcmV0dXJuIG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5nZXQodHJhbnNh Y3Rpb25JRCkuZ2V0KCk7CisKKyAgICBpZiAobV9ydW5uaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5z KHRyYW5zYWN0aW9uSUQpKQorICAgICAgICByZXR1cm4gbV9ydW5uaW5nVHJhbnNhY3Rpb25zLmdl dCh0cmFuc2FjdGlvbklEKS5nZXQoKTsKKworICAgIHJldHVybiAwOworfQorCit2b2lkIElEQlRy YW5zYWN0aW9uQ29vcmRpbmF0b3I6OnByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKCkKK3sKKyAg ICAvLyBGSVhNRTogVGhpcyBzaG91bGQgYWxsb2NhdGUgYSB0aHJlYWQgdG8gdGhlIG5leHQgdHJh bnNhY3Rpb24KKyAgICAvLyB0aGF0J3MgcmVhZHkgdG8gcnVuLiBGb3Igbm93IHdlIG9ubHkgaGF2 ZSBhIHNpbmdsZSBydW5uaW5nCisgICAgLy8gdHJhbnNhY3Rpb24uCisgICAgaWYgKG1fc3RhcnRl ZFRyYW5zYWN0aW9ucy5pc0VtcHR5KCkgfHwgIW1fcnVubmluZ1RyYW5zYWN0aW9ucy5pc0VtcHR5 KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFJlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsPiB0cmFuc2FjdGlvbiA9ICptX3N0YXJ0ZWRUcmFuc2FjdGlvblF1ZXVlLmJlZ2luKCk7Cisg ICAgbV9zdGFydGVkVHJhbnNhY3Rpb25RdWV1ZS5yZW1vdmUodHJhbnNhY3Rpb24uZ2V0KCkpOwor ICAgIEFTU0VSVCh0cmFuc2FjdGlvbi5nZXQoKSA9PSBtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuZ2V0 KHRyYW5zYWN0aW9uLT5pZCgpKSk7CisgICAgbV9zdGFydGVkVHJhbnNhY3Rpb25zLnJlbW92ZSh0 cmFuc2FjdGlvbi0+aWQoKSk7CisgICAgbV9ydW5uaW5nVHJhbnNhY3Rpb25zLmFkZCh0cmFuc2Fj dGlvbi0+aWQoKSwgdHJhbnNhY3Rpb24pOworICAgIHRyYW5zYWN0aW9uLT5ydW4oKTsKIH0KIAot fTsKK307IAogCiAjZW5kaWYgLy8gRU5BQkxFKElOREVYRURfREFUQUJBU0UpCmRpZmYgLS1naXQg YS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIGIvV2ViQ29yZS9z dG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaAppbmRleCAxMDRhOTU2NmNlY2VkYzMy YWU2YzA1MmFjNzc3NzU0YTYyMTE4MjNkLi4yOTlkMDBmNDdjOWQ1MzRjM2VlMzlmMjdjYmE0YzFk YWY3MDdlNTk3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29y ZGluYXRvci5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9y LmgKQEAgLTM1LDYgKzM1LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitjbGFzcyBJREJU cmFuc2FjdGlvbkJhY2tlbmRJbXBsOwogY2xhc3MgSURCVHJhbnNhY3Rpb25DYWxsYmFja3M7CiBj bGFzcyBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOwogCkBAIC01NSwxNCArNTYsMjUgQEAgcHVibGlj OgogICAgIHZpcnR1YWwgfklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKTsKIAogICAgIFBhc3NS ZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBjcmVhdGVUcmFuc2FjdGlvbihE T01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVk IGxvbmcgdGltZW91dCwgSURCRGF0YWJhc2VCYWNrZW5kSW1wbCopOwotICAgIHZvaWQgYWJvcnQo aW50IHRyYW5zYWN0aW9uSWQpOworICAgIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNv bnN0IFZlY3RvcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqPiYpOworICAgIHZvaWQg ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2UqKTsKKworICAgIC8vIENhbGxlZCBieSB0cmFuc2FjdGlvbnMgYXMgdGhleSBzdGFydCBh bmQgZmluaXNoLgorICAgIHZvaWQgZGlkU3RhcnRUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJh Y2tlbmRJbnRlcmZhY2UqKTsKKyAgICB2b2lkIGRpZEZpbmlzaFRyYW5zYWN0aW9uKElEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZSopOworCisgICAgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlKiB0cmFuc2FjdGlvbihpbnQgaWQpOwogCiBwcml2YXRlOgogICAgIElEQlRyYW5zYWN0 aW9uQ29vcmRpbmF0b3IoKTsKIAotICAgIExpc3RIYXNoU2V0PElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZSo+IG1fdHJhbnNhY3Rpb25RdWV1ZTsKLSAgICB0eXBlZGVmIEhhc2hNYXA8aW50 LCBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiA+IElkVG9UcmFuc2FjdGlv bk1hcDsKLSAgICBJZFRvVHJhbnNhY3Rpb25NYXAgbV9pZE1hcDsKKyAgICB2b2lkIHByb2Nlc3NT dGFydGVkVHJhbnNhY3Rpb25zKCk7CisKKyAgICBMaXN0SGFzaFNldDxJREJUcmFuc2FjdGlvbkJh Y2tlbmRJbXBsKj4gbV9zdGFydGVkVHJhbnNhY3Rpb25RdWV1ZTsKKyAgICB0eXBlZGVmIEhhc2hN YXA8aW50LCBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4gPiBJZFRvVHJhbnNhY3Rp b25NYXA7CisgICAgSWRUb1RyYW5zYWN0aW9uTWFwIG1fcGVuZGluZ1RyYW5zYWN0aW9uczsKKyAg ICBJZFRvVHJhbnNhY3Rpb25NYXAgbV9zdGFydGVkVHJhbnNhY3Rpb25zOworICAgIElkVG9UcmFu c2FjdGlvbk1hcCBtX3J1bm5pbmdUcmFuc2FjdGlvbnM7CiAgICAgaW50IG1fbmV4dElEOwogfTsK IApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKaW5kZXggNDdiMGU2M2QwODBiNzFiMTI2NDg4MzhlMmUwNjExNDJiN2Y1Y2Rl Yy4uMWNkYzIwMTE3MWM5YTQ5ODcwNjBkNzNmOGE3OGFmNDJhNDY2OTA5NCAxMDA2NDQKLS0tIGEv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n CkBAIC0xLDMgKzEsNDAgQEAKKzIwMTAtMDktMjAgIEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBn b29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIElEQk9iamVjdFN0b3JlOjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAg ICAgICAqIHB1YmxpYy9XZWJJREJGYWN0b3J5Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYklEQkZh Y3Rvcnk6OmRpZENvbXBsZXRlRXZlbnRzRm9yVHJhbnNhY3Rpb24pOgorICAgICAgICAqIHB1Ymxp Yy9XZWJJREJPYmplY3RTdG9yZS5oOgorICAgICAgICAoV2ViS2l0OjpXZWJJREJPYmplY3RTdG9y ZTo6Z2V0KToKKyAgICAgICAgKiBwdWJsaWMvV2ViSURCVHJhbnNhY3Rpb24uaDoKKyAgICAgICAg KiBzcmMvSURCRGF0YWJhc2VQcm94eS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJEYXRhYmFz ZVByb3h5OjpvYmplY3RTdG9yZSk6CisgICAgICAgICogc3JjL0lEQkRhdGFiYXNlUHJveHkuaDoK KyAgICAgICAgKiBzcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpJREJGYWN0b3J5QmFja2VuZFByb3h5OjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMpOgor ICAgICAgICAoV2ViQ29yZTo6SURCRmFjdG9yeUJhY2tlbmRQcm94eTo6ZGlkQ29tcGxldGVFdmVu dHNGb3JUcmFuc2FjdGlvbik6CisgICAgICAgICogc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHku aDoKKyAgICAgICAgKiBzcmMvSURCT2JqZWN0U3RvcmVQcm94eS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpJREJPYmplY3RTdG9yZVByb3h5OjpnZXQpOgorICAgICAgICAqIHNyYy9JREJPYmplY3RT dG9yZVByb3h5Lmg6CisgICAgICAgICogc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5OjpzY2hlZHVs ZVRhc2spOgorICAgICAgICAqIHNyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5oOgorICAg ICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OnRvV2ViSURCVHJhbnNh Y3Rpb24pOgorICAgICAgICAqIHNyYy9XZWJJREJGYWN0b3J5SW1wbC5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYklEQkZhY3RvcnlJbXBsOjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMpOgorICAg ICAgICAoV2ViS2l0OjpXZWJJREJGYWN0b3J5SW1wbDo6ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFu c2FjdGlvbik6CisgICAgICAgICogc3JjL1dlYklEQkZhY3RvcnlJbXBsLmg6CisgICAgICAgICog c3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYklEQk9i amVjdFN0b3JlSW1wbDo6Z2V0KToKKyAgICAgICAgKiBzcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBs Lmg6CisgICAgICAgICogc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYklEQlRyYW5zYWN0aW9uSW1wbDo6b3BlcmF0b3IgSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW50ZXJmYWNlKik6CisgICAgICAgICogc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5oOgor CiAyMDEwLTA5LTE5ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4K IAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByNjc3NDkuCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQkZhY3RvcnkuaCBiL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViSURCRmFjdG9yeS5oCmluZGV4IGFiMDViMDY0ZDZlOTRmMjhjMGY4NjI5NGUzOTll ZTVkOTU5ZjVmMWUuLjQzNzY4M2Y1ZDdkMzYzNDRhZTY1NDBlNjEzNWIzMzA2YjQ1ZGIzYzQgMTAw NzU1Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCRmFjdG9yeS5oCisrKyBiL1dl YktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCRmFjdG9yeS5oCkBAIC02Myw2ICs2Myw3IEBAIHB1 YmxpYzoKICAgICB9CiAKICAgICB2aXJ0dWFsIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25z KGNvbnN0IFdlYlZlY3RvcjxpbnQ+JiBwZW5kaW5nSURzKSB7IFdFQktJVF9BU1NFUlRfTk9UX1JF QUNIRUQoKTsgfQorICAgIHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0 aW9uKGludCBjdXJyZW50SUQpIHsgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CiB9Owog CiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJs aWMvV2ViSURCT2JqZWN0U3RvcmUuaCBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCT2Jq ZWN0U3RvcmUuaAppbmRleCA3NDUyYmU5OWI0MGMwYmQyMjY5NTA0MjcxMGM5ZGE4YmY5YjIwOWQw Li43YmE3ODEwNzc3MmVkYmFhZmVlZDM5Zjg2OWY5NWUyN2E0MDQ0YzVkIDEwMDc1NQotLS0gYS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQk9iamVjdFN0b3JlLmgKKysrIGIvV2ViS2l0L2No cm9taXVtL3B1YmxpYy9XZWJJREJPYmplY3RTdG9yZS5oCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5j bHVkZSAiV2ViQ29tbW9uLmgiCiAjaW5jbHVkZSAiV2ViRE9NU3RyaW5nTGlzdC5oIgogI2luY2x1 ZGUgIldlYklEQkNhbGxiYWNrcy5oIgorI2luY2x1ZGUgIldlYklEQlRyYW5zYWN0aW9uLmgiCiAj aW5jbHVkZSAiV2ViU3RyaW5nLmgiCiAKIG5hbWVzcGFjZSBXZWJLaXQgewpAQCAtNTUsNyArNTYs NyBAQCBwdWJsaWM6CiAgICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAg ICAgcmV0dXJuIFdlYkRPTVN0cmluZ0xpc3QoKTsKICAgICB9Ci0gICAgdmlydHVhbCB2b2lkIGdl dChjb25zdCBXZWJJREJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tzKikKKyAgICB2aXJ0dWFsIHZv aWQgZ2V0KGNvbnN0IFdlYklEQktleSYga2V5LCBXZWJJREJDYWxsYmFja3MqLCBjb25zdCBXZWJJ REJUcmFuc2FjdGlvbiYpCiAgICAgewogICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVE KCk7CiAgICAgfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJUcmFu c2FjdGlvbi5oIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJUcmFuc2FjdGlvbi5oCmlu ZGV4IDAzNjliODk5YjU2OTEzYmQ2ZDE3OTY3NGYyMGIyZjA4YzBlYTUyMWMuLmIxYTFjZmY4MzRm NjYwMjBiN2YyYjIzMWNkZTFmNDY1MjVjNmE2NDQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9wdWJsaWMvV2ViSURCVHJhbnNhY3Rpb24uaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYklEQlRyYW5zYWN0aW9uLmgKQEAgLTI4LDYgKzI4LDggQEAKIAogI2luY2x1ZGUgIldlYlN0 cmluZy5oIgogCituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZTsgfQorCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViSURCT2JqZWN0 U3RvcmU7CkBAIC01NSw2ICs1NywxMSBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiAwOwogICAg IH0KICAgICB2aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKFdlYklEQlRyYW5zYWN0aW9uQ2FsbGJh Y2tzKikgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKworI2lmIFdFQktJVF9JTVBM RU1FTlRBVElPTgorICAgIHZpcnR1YWwgb3BlcmF0b3IgV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25C YWNrZW5kSW50ZXJmYWNlKigpIGNvbnN0ID0gMDsKKyNlbmRpZgorCiB9OwogCiB9IC8vIG5hbWVz cGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJhc2VQ cm94eS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuY3BwCmluZGV4 IGNlNWUwYTZjY2ZkMzIwYmJlNjM3ZTNkZjdiYWMyNzlhOGJmYjM4ZDYuLjk1NGU3ZDkwZDczMzMz YmQ4NjVkODczYTM3ZDY4NDhiYzliZmEyNjggMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9z cmMvSURCRGF0YWJhc2VQcm94eS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRh YmFzZVByb3h5LmNwcApAQCAtODEsNyArODEsNyBAQCB2b2lkIElEQkRhdGFiYXNlUHJveHk6OmNy ZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBrZXlQYQog ICAgIG1fd2ViSURCRGF0YWJhc2UtPmNyZWF0ZU9iamVjdFN0b3JlKG5hbWUsIGtleVBhdGgsIGF1 dG9JbmNyZW1lbnQsIG5ldyBXZWJJREJDYWxsYmFja3NJbXBsKGNhbGxiYWNrcykpOwogfQogCi1Q YXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gSURCRGF0YWJhc2VQcm94 eTo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBzaG9ydCBtb2RlKQor UGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IElEQkRhdGFiYXNlUHJv eHk6Om9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSwg SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKikKIHsKICAgICBXZWJLaXQ6OldlYklEQk9i amVjdFN0b3JlKiBvYmplY3RTdG9yZSA9IG1fd2ViSURCRGF0YWJhc2UtPm9iamVjdFN0b3JlKG5h bWUsIG1vZGUpOwogICAgIGlmICghb2JqZWN0U3RvcmUpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hy b21pdW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0 YWJhc2VQcm94eS5oCmluZGV4IDQyYTdkN2VjNTZhMjYyODIxODBkNzZjODNmMjM2ZDE4N2ZlNDQ3 N2MuLjI0NzFiOGY4OWJlNjhmNjdmZTUyNjY5ZDViNGI0ZWNlMDQ1ODU4OWQgMTAwNjQ0Ci0tLSBh L1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJhc2VQcm94eS5oCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvSURCRGF0YWJhc2VQcm94eS5oCkBAIC00NywxMCArNDcsMTAgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgU3RyaW5nIHZlcnNpb24oKSBjb25zdDsKICAgICB2aXJ0dWFsIFBhc3NSZWZQ dHI8RE9NU3RyaW5nTGlzdD4gb2JqZWN0U3RvcmVzKCkgY29uc3Q7CiAKLSAgICAvLyBGSVhNRTog QWRkIHRyYW5zYWN0aW9uIGFuZCBzZXRWZXJzaW9uLgorICAgIC8vIEZJWE1FOiBBZGQgc2V0VmVy c2lvbi4KIAogICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcm IG5hbWUsIGNvbnN0IFN0cmluZyYga2V5UGF0aCwgYm9vbCBhdXRvSW5jcmVtZW50LCBQYXNzUmVm UHRyPElEQkNhbGxiYWNrcz4pOwotICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJREJPYmplY3RTdG9y ZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWdu ZWQgc2hvcnQgbW9kZSk7CisgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFj a2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBz aG9ydCBtb2RlLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uID0g MCk7CiAgICAgdmlydHVhbCB2b2lkIHJlbW92ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFt ZSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmVyc2lv bihjb25zdCBTdHJpbmcmIHZlcnNpb24sIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAgICAg dmlydHVhbCBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNh Y3Rpb24oRE9NU3RyaW5nTGlzdCogc3RvcmVOYW1lcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5z aWduZWQgbG9uZyB0aW1lb3V0KTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURC RmFjdG9yeUJhY2tlbmRQcm94eS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlC YWNrZW5kUHJveHkuY3BwCmluZGV4IDE4MTAxZTQ4OTMzNTAyZGUwNjI0OTZlZDYwMWY4ZTJkYjAw YTEwODIuLjJlZmZhNTI4MmI3MWYzOGY2MjlkMjA5MGFiZWMxZTM2YjU2NDRiNWUgMTAwNzU1Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5jcHAKKysrIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9JREJGYWN0b3J5QmFja2VuZFByb3h5LmNwcApAQCAtMzIsNiAr MzIsNyBAQAogI2luY2x1ZGUgIkRPTVN0cmluZ0xpc3QuaCIKICNpbmNsdWRlICJJREJEYXRhYmFz ZUVycm9yLmgiCiAjaW5jbHVkZSAiSURCRGF0YWJhc2VQcm94eS5oIgorI2luY2x1ZGUgIklEQlRy YW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgog I2luY2x1ZGUgIldlYklEQkNhbGxiYWNrc0ltcGwuaCIKICNpbmNsdWRlICJXZWJJREJEYXRhYmFz ZS5oIgpAQCAtNjUsMTQgKzY2LDIwIEBAIHZvaWQgSURCRmFjdG9yeUJhY2tlbmRQcm94eTo6b3Bl bihjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24sCiAgICAgbV93 ZWJJREJGYWN0b3J5LT5vcGVuKG5hbWUsIGRlc2NyaXB0aW9uLCBuZXcgV2ViSURCQ2FsbGJhY2tz SW1wbChjYWxsYmFja3MpLCBvcmlnaW4sIHdlYkZyYW1lLCBkYXRhRGlyKTsKIH0KIAotdm9pZCBJ REJGYWN0b3J5QmFja2VuZFByb3h5OjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVj dG9yPGludD4mIHBlbmRpbmdJRHMpCit2b2lkIElEQkZhY3RvcnlCYWNrZW5kUHJveHk6OmFib3J0 UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBWZWN0b3I8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlKj4mIHRyYW5zYWN0aW9ucykKIHsKLSAgICBBU1NFUlQocGVuZGluZ0lEcy5zaXplKCkp OwotICAgIFdlYktpdDo6V2ViVmVjdG9yPGludD4gaWRzID0gcGVuZGluZ0lEczsKLQorICAgIEFT U0VSVCh0cmFuc2FjdGlvbnMuc2l6ZSgpKTsKKyAgICBXZWJLaXQ6OldlYlZlY3RvcjxpbnQ+IGlk cyh0cmFuc2FjdGlvbnMuc2l6ZSgpKTsKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHRyYW5z YWN0aW9ucy5zaXplKCk7ICsraSkKKyAgICAgICAgaWRzW2ldID0gdHJhbnNhY3Rpb25zLmF0KGkp LT5pZCgpOwogICAgIG1fd2ViSURCRmFjdG9yeS0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGlk cyk7CiB9CiAKK3ZvaWQgSURCRmFjdG9yeUJhY2tlbmRQcm94eTo6ZGlkQ29tcGxldGVFdmVudHNG b3JUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9u KQoreworICAgIG1fd2ViSURCRmFjdG9yeS0+ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlv bih0cmFuc2FjdGlvbi0+aWQoKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2Vu ZGlmIC8vIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9t aXVtL3NyYy9JREJGYWN0b3J5QmFja2VuZFByb3h5LmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lE QkZhY3RvcnlCYWNrZW5kUHJveHkuaAppbmRleCBhYzMwY2YyZjgzYjYyYjkzYzQ3ZmExOGQ4ODE5 OWE2NDI2NTg3YWRmLi5hZDAxZDYwMTk0MWRiNThjNDI4MTRmNGZjM2Q3M2M5YzA3OWUzNzEwIDEw MDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaApAQCAtNDYs NyArNDYsOCBAQCBwdWJsaWM6CiAKICAgICBQYXNzUmVmUHRyPERPTVN0cmluZ0xpc3Q+IGRhdGFi YXNlcyh2b2lkKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgb3Blbihjb25zdCBTdHJpbmcmIG5h bWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24sIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiwg UGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4sIEZyYW1lKiwgY29uc3QgU3RyaW5nJiBkYXRhRGly KTsKLSAgICB2aXJ0dWFsIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFZlY3Rv cjxpbnQ+JiBwZW5kaW5nSURzKTsKKyAgICB2aXJ0dWFsIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNh Y3Rpb25zKGNvbnN0IFZlY3RvcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqPiYpOwor ICAgIHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0ZUV2ZW50c0ZvclRyYW5zYWN0aW9uKElEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZSopOwogCiBwcml2YXRlOgogICAgIElEQkZhY3RvcnlCYWNr ZW5kUHJveHkoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3Rv cmVQcm94eS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuY3Bw CmluZGV4IGFkMjdmYTM0MWM1YmM3Yzg5YzdkMDhhMjdiNTVkMTgzMjhkZjJiMDIuLmFkYjUwNmQ2 ZTBhMDE4ZTI4NWRmOGNhM2M1Mzg2ZmIwZDk4YTU1ODQgMTAwNzU1Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9JREJPYmplY3RTdG9yZVByb3h5LmNwcApAQCAtMzAsMTEgKzMwLDEzIEBACiAjaW5jbHVkZSAi SURCQ2FsbGJhY2tzLmgiCiAjaW5jbHVkZSAiSURCSW5kZXhCYWNrZW5kUHJveHkuaCIKICNpbmNs dWRlICJJREJLZXlSYW5nZS5oIgorI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5 LmgiCiAjaW5jbHVkZSAiV2ViSURCQ2FsbGJhY2tzSW1wbC5oIgogI2luY2x1ZGUgIldlYklEQktl eVJhbmdlLmgiCiAjaW5jbHVkZSAiV2ViSURCSW5kZXguaCIKICNpbmNsdWRlICJXZWJJREJLZXku aCIKICNpbmNsdWRlICJXZWJJREJPYmplY3RTdG9yZS5oIgorI2luY2x1ZGUgIldlYklEQlRyYW5z YWN0aW9uSW1wbC5oIgogI2luY2x1ZGUgIldlYlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgogCiAj aWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCkBAIC03MCw5ICs3MiwxMCBAQCBQYXNzUmVmUHRy PERPTVN0cmluZ0xpc3Q+IElEQk9iamVjdFN0b3JlUHJveHk6OmluZGV4TmFtZXMoKSBjb25zdAog ICAgIHJldHVybiBtX3dlYklEQk9iamVjdFN0b3JlLT5pbmRleE5hbWVzKCk7CiB9CiAKLXZvaWQg SURCT2JqZWN0U3RvcmVQcm94eTo6Z2V0KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQ dHI8SURCQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit2b2lkIElEQk9iamVjdFN0b3JlUHJveHk6Omdl dChQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4gY2FsbGJh Y2tzLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKQogewotICAg IG1fd2ViSURCT2JqZWN0U3RvcmUtPmdldChrZXksIG5ldyBXZWJJREJDYWxsYmFja3NJbXBsKGNh bGxiYWNrcykpOworICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5KiB0cmFuc2FjdGlvblBy b3h5ID0gc3RhdGljX2Nhc3Q8SURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkqPih0cmFuc2FjdGlv bik7CisgICAgbV93ZWJJREJPYmplY3RTdG9yZS0+Z2V0KGtleSwgbmV3IFdlYklEQkNhbGxiYWNr c0ltcGwoY2FsbGJhY2tzKSwgKnRyYW5zYWN0aW9uUHJveHktPnRvV2ViSURCVHJhbnNhY3Rpb24o KSk7CiB9CiAKIHZvaWQgSURCT2JqZWN0U3RvcmVQcm94eTo6cHV0KFBhc3NSZWZQdHI8U2VyaWFs aXplZFNjcmlwdFZhbHVlPiB2YWx1ZSwgUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgYm9vbCBhZGRP bmx5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4gY2FsbGJhY2tzKQpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmggYi9XZWJLaXQvY2hyb21pdW0v c3JjL0lEQk9iamVjdFN0b3JlUHJveHkuaAppbmRleCBhMzM0NTcyYjZmMzZjMWUwMDQ4MmMwNGQw YTA3YjY1YWFiZjU5OWExLi4xM2RmZTIzNmRlNmVlNDVjNWE1ZjE4YzQ2Njc2MTY3ZDQ0MjMwYmIy IDEwMDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuaApAQCAtNDYsNyAr NDYsNyBAQCBwdWJsaWM6CiAgICAgU3RyaW5nIGtleVBhdGgoKSBjb25zdDsKICAgICBQYXNzUmVm UHRyPERPTVN0cmluZ0xpc3Q+IGluZGV4TmFtZXMoKSBjb25zdDsKIAotICAgIHZvaWQgZ2V0KFBh c3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CisgICAgdm9p ZCBnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+LCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqKTsKICAgICB2b2lkIHB1dChQYXNzUmVmUHRy PFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIGJv b2wgYWRkT25seSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2b2lkIHJlbW92ZShQ YXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwogCmRpZmYg LS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNw cCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuY3BwCmlu ZGV4IGJlNmIwNThlNTJlMjQyNzU4MzQ4NzA5ZGIwMDFjZDA0MWM1Njk2ZTguLjVjODdjNjUxMjk4 MTA0Mzg1OTg0MDdmNzc3ZjZkNjRkMmFmMmY2ZWMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1 bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuY3BwCkBAIC02OSwxMSArNjksMTIgQEAg dm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6YWJvcnQoKQogICAgIG1fd2ViSURCVHJh bnNhY3Rpb24tPmFib3J0KCk7CiB9CiAKLXZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6 OnNjaGVkdWxlVGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KQor Ym9vbCBJREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6c2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8 U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pCiB7CiAgICAgLy8gVGhpcyBzaG91bGQgbmV2 ZXIgYmUgcmVhY2hlZCBhcyBpdCdzIHRoZSBpbXBsIG9iamVjdHMgd2hvIGdldCB0bwogICAgIC8v IGV4ZWN1dGUgdGFza3MgaW4gdGhlIGJyb3dzZXIgcHJvY2Vzcy4KICAgICBBU1NFUlRfTk9UX1JF QUNIRUQoKTsKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKIGludCBJREJUcmFuc2FjdGlvbkJhY2tl bmRQcm94eTo6aWQoKSBjb25zdApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJU cmFuc2FjdGlvbkJhY2tlbmRQcm94eS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2Fj dGlvbkJhY2tlbmRQcm94eS5oCmluZGV4IGQ2MmI4ZmY3Yjg0MWEyYTNmOTJhMmM2N2E3MDBkZTYz ODM1ZmUzMDIuLjQ0YWRlNDRlODRjMjgxNmRlMTA1YmZlMTc3YmE4YTkyM2NjNTI2MWUgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmgKQEAg LTQ1LDEwICs0NSwxMiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVj dFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKTsK ICAgICB2aXJ0dWFsIHVuc2lnbmVkIHNob3J0IG1vZGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZv aWQgYWJvcnQoKTsKLSAgICB2aXJ0dWFsIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NPd25QdHI8U2Ny aXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOworICAgIHZpcnR1YWwgYm9vbCBzY2hlZHVsZVRh c2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7CiAgICAgdmlydHVh bCBpbnQgaWQoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKElEQlRyYW5z YWN0aW9uQ2FsbGJhY2tzKik7CiAKKyAgICBXZWJLaXQ6OldlYklEQlRyYW5zYWN0aW9uKiB0b1dl YklEQlRyYW5zYWN0aW9uKCkgY29uc3QgeyByZXR1cm4gbV93ZWJJREJUcmFuc2FjdGlvbi5nZXQo KTsgfQorCiBwcml2YXRlOgogICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5KFBhc3NPd25Q dHI8V2ViS2l0OjpXZWJJREJUcmFuc2FjdGlvbj4pOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi SURCRmFjdG9yeUltcGwuY3BwCmluZGV4IDNjOGQ0NTlhMGE5ZTUyODM3NTk2ZjU2NDFjMjI4NDNh ZTA5ZGJhZTcuLjQ2MGI1NGZiOWJjNTk1YTQyODAwNGQ2YzhiNzUxYjM1MTg5NDdkYTggMTAwNzU1 Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuY3BwCisrKyBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuY3BwCkBAIC0zNCw2ICszNCw3IEBA CiAjaW5jbHVkZSAiRE9NU3RyaW5nTGlzdC5oIgogI2luY2x1ZGUgIklEQkNhbGxiYWNrc1Byb3h5 LmgiCiAjaW5jbHVkZSAiSURCRmFjdG9yeUJhY2tlbmRJbXBsLmgiCisjaW5jbHVkZSAiSURCVHJh bnNhY3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5j bHVkZSAiV2ViSURCRGF0YWJhc2VFcnJvci5oIgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KQEAg LTY1LDExICs2NiwxNyBAQCB2b2lkIFdlYklEQkZhY3RvcnlJbXBsOjpvcGVuKGNvbnN0IFdlYlN0 cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkZXNjcmlwdGlvbgogCiB2b2lkIFdlYklEQkZh Y3RvcnlJbXBsOjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgV2ViVmVjdG9yPGludD4m IHBlbmRpbmdJRHMpCiB7Ci0gICAgV1RGOjpWZWN0b3I8aW50PiBpZHMocGVuZGluZ0lEcy5zaXpl KCkpOworICAgIFdURjo6VmVjdG9yPFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZSo+IHRyYW5zYWN0aW9ucyhwZW5kaW5nSURzLnNpemUoKSk7CiAgICAgZm9yIChzaXplX3Qg aSA9IDA7IGkgPCBwZW5kaW5nSURzLnNpemUoKTsgKytpKQotICAgICAgICBpZHNbaV0gPSBwZW5k aW5nSURzW2ldOworICAgICAgICB0cmFuc2FjdGlvbnNbaV0gPSBtX2lkYkZhY3RvcnlCYWNrZW5k LT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCktPnRyYW5zYWN0aW9uKHBlbmRpbmdJRHNbaV0pOwog Ci0gICAgbV9pZGJGYWN0b3J5QmFja2VuZC0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGlkcyk7 CisgICAgbV9pZGJGYWN0b3J5QmFja2VuZC0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKHRyYW5z YWN0aW9ucyk7Cit9CisKK3ZvaWQgV2ViSURCRmFjdG9yeUltcGw6OmRpZENvbXBsZXRlRXZlbnRz Rm9yVHJhbnNhY3Rpb24oaW50IHRyYW5zYWN0aW9uSUQpCit7CisgICAgV2ViQ29yZTo6SURCVHJh bnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbiA9IG1faWRiRmFjdG9yeUJhY2tl bmQtPnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKS0+dHJhbnNhY3Rpb24odHJhbnNhY3Rpb25JRCk7 CisgICAgbV9pZGJGYWN0b3J5QmFja2VuZC0+ZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlv bih0cmFuc2FjdGlvbik7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJGYWN0b3J5SW1wbC5oIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJJREJGYWN0b3J5SW1wbC5oCmluZGV4IDRkYzBhMTA5ODA5ODU0OGIxZjNmM2U4Nzc0 YmNhZWM1N2VkMGYwMGMuLjA5YTYwMGNiOGYxMWI4Y2VmNzY4ZjFjYWFiNTRiODdmN2UwZTMxNDkg MTAwNzU1Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuaAorKysg Yi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmgKQEAgLTMzLDcgKzMzLDcg QEAKICNpbmNsdWRlICJXZWJJREJGYWN0b3J5LmgiCiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgog Ci1uYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIElEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlOyB9 CituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIElEQkZhY3RvcnlCYWNrZW5kSW1wbDsgfQogCiBu YW1lc3BhY2UgV2ViS2l0IHsKIApAQCAtNDQsOSArNDQsMTAgQEAgcHVibGljOgogCiAgICAgdmly dHVhbCB2b2lkIG9wZW4oY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRl c2NyaXB0aW9uLCBXZWJJREJDYWxsYmFja3MqLCBjb25zdCBXZWJTZWN1cml0eU9yaWdpbiYsIFdl YkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBkYXRhRGlyKTsKICAgICB2aXJ0dWFsIHZvaWQgYWJv cnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFdlYlZlY3RvcjxpbnQ+JiBwZW5kaW5nSURzKTsK KyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tcGxldGVFdmVudHNGb3JUcmFuc2FjdGlvbihpbnQgdHJh bnNhY3Rpb25JRCk7CiAKIHByaXZhdGU6Ci0gICAgV1RGOjpSZWZQdHI8V2ViQ29yZTo6SURCRmFj dG9yeUJhY2tlbmRJbnRlcmZhY2U+IG1faWRiRmFjdG9yeUJhY2tlbmQ7CisgICAgV1RGOjpSZWZQ dHI8V2ViQ29yZTo6SURCRmFjdG9yeUJhY2tlbmRJbXBsPiBtX2lkYkZhY3RvcnlCYWNrZW5kOwog fTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklE Qk9iamVjdFN0b3JlSW1wbC5jcHAKaW5kZXggMWFkMWQ5ZjNlNDczOGE3NzRmM2I2NjE0YjIwNmY2 MWEzYWIyZWMwMi4uYzRhZWFlZDU2NDA1NDFkMDg5M2NhMmMzZmFmYWM4OGQ4ZjA3YzQyOSAxMDA3 NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmplY3RTdG9yZUltcGwuY3BwCisr KyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmNwcApAQCAtMzAs NiArMzAsNyBAQAogI2luY2x1ZGUgIklEQkNhbGxiYWNrc1Byb3h5LmgiCiAjaW5jbHVkZSAiSURC S2V5UmFuZ2UuaCIKICNpbmNsdWRlICJJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UuaCIK KyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmgiCiAjaW5jbHVkZSAiV2ViSURC SW5kZXhJbXBsLmgiCiAjaW5jbHVkZSAiV2ViSURCS2V5LmgiCiAjaW5jbHVkZSAiV2ViSURCS2V5 UmFuZ2UuaCIKQEAgLTY1LDkgKzY2LDkgQEAgV2ViRE9NU3RyaW5nTGlzdCBXZWJJREJPYmplY3RT dG9yZUltcGw6OmluZGV4TmFtZXMoKSBjb25zdAogICAgIHJldHVybiBtX29iamVjdFN0b3JlLT5p bmRleE5hbWVzKCk7CiB9CiAKLXZvaWQgV2ViSURCT2JqZWN0U3RvcmVJbXBsOjpnZXQoY29uc3Qg V2ViSURCS2V5JiBrZXksIFdlYklEQkNhbGxiYWNrcyogY2FsbGJhY2tzKQordm9pZCBXZWJJREJP YmplY3RTdG9yZUltcGw6OmdldChjb25zdCBXZWJJREJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tz KiBjYWxsYmFja3MsIGNvbnN0IFdlYklEQlRyYW5zYWN0aW9uJiB0cmFuc2FjdGlvbikKIHsKLSAg ICBtX29iamVjdFN0b3JlLT5nZXQoa2V5LCBJREJDYWxsYmFja3NQcm94eTo6Y3JlYXRlKGNhbGxi YWNrcykpOworICAgIG1fb2JqZWN0U3RvcmUtPmdldChrZXksIElEQkNhbGxiYWNrc1Byb3h5Ojpj cmVhdGUoY2FsbGJhY2tzKSwgdHJhbnNhY3Rpb24pOwogfQogCiB2b2lkIFdlYklEQk9iamVjdFN0 b3JlSW1wbDo6cHV0KGNvbnN0IFdlYlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZSYgdmFsdWUsIGNvbnN0 IFdlYklEQktleSYga2V5LCBib29sIGFkZE9ubHksIFdlYklEQkNhbGxiYWNrcyogY2FsbGJhY2tz KQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmplY3RTdG9yZUltcGwu aCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmgKaW5kZXggOWYz MTM2OWMzMGIxNDE1ZjFiOTJjNzA4NWNhZGVkYTAyNzg5OTIyYi4uYTlmMTIwMGM5ZmM0ZDg2MWQy ZWY1Zjc5ZTk0NDIxOTYxM2U2NDY5OSAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJJREJPYmplY3RTdG9yZUltcGwuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQk9i amVjdFN0b3JlSW1wbC5oCkBAIC00Nyw3ICs0Nyw3IEBAIHB1YmxpYzoKICAgICBXZWJTdHJpbmcg a2V5UGF0aCgpIGNvbnN0OwogICAgIFdlYkRPTVN0cmluZ0xpc3QgaW5kZXhOYW1lcygpIGNvbnN0 OwogCi0gICAgdm9pZCBnZXQoY29uc3QgV2ViSURCS2V5JiBrZXksIFdlYklEQkNhbGxiYWNrcyop OworICAgIHZvaWQgZ2V0KGNvbnN0IFdlYklEQktleSYga2V5LCBXZWJJREJDYWxsYmFja3MqLCBj b25zdCBXZWJJREJUcmFuc2FjdGlvbiYpOwogICAgIHZvaWQgcHV0KGNvbnN0IFdlYlNlcmlhbGl6 ZWRTY3JpcHRWYWx1ZSYgdmFsdWUsIGNvbnN0IFdlYklEQktleSYga2V5LCBib29sIGFkZE9ubHks IFdlYklEQkNhbGxiYWNrcyopOwogICAgIHZvaWQgcmVtb3ZlKGNvbnN0IFdlYklEQktleSYga2V5 LCBXZWJJREJDYWxsYmFja3MqKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJJREJUcmFuc2FjdGlvbkltcGwuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJUcmFu c2FjdGlvbkltcGwuY3BwCmluZGV4IDBkYzk3MDJkZTk3ZDFmOTg1ZGUxYTAxMjRmZjg3MzYzNTlj MjEyZjMuLjBjZDkzOTVkYTRhZTY5NjNlMTlhOWY0ZjU5YzIyMjFmMzMwZGY5MGUgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmNwcAorKysgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5jcHAKQEAgLTc1LDYgKzc1 LDExIEBAIHZvaWQgV2ViSURCVHJhbnNhY3Rpb25JbXBsOjpzZXRDYWxsYmFja3MoV2ViSURCVHJh bnNhY3Rpb25DYWxsYmFja3MqIGNhbGxiYWNrcykKICAgICBtX2JhY2tlbmQtPnNldENhbGxiYWNr cyhpZGJDYWxsYmFja3MuZ2V0KCkpOwogfQogCitXZWJJREJUcmFuc2FjdGlvbkltcGw6Om9wZXJh dG9yIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSooKSBjb25zdAoreworICAgIHJldHVy biBtX2JhY2tlbmQuZ2V0KCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjZW5kaWYg Ly8gRU5BQkxFKElOREVYRURfREFUQUJBU0UpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJU cmFuc2FjdGlvbkltcGwuaAppbmRleCBhOWJkZTY4NGVmNWEwZTM5ZjlmN2UzMzAxOWU0NzJjNDZk ODlkOGRmLi5mMTM3ZDZlNTAyMDJiMzM4ZmRjYjI0ZDc1NjhkZGI3ODVlYTIyMmUzIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5oCisrKyBiL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmgKQEAgLTMzLDggKzMzLDYg QEAKICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4K IAotbmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZh Y2U7IH0KLQogbmFtZXNwYWNlIFdlYktpdCB7CiAKIC8vIFNlZSBjb21tZW50IGluIFdlYkluZGV4 ZWREYXRhYmFzZSBmb3IgYSBoaWdoIGxldmVsIG92ZXJ2aWV3IHRoZXNlIGNsYXNzZXMuCkBAIC00 OSw2ICs0Nyw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIGludCBpZCgpIGNvbnN0OwogICAgIHZp cnR1YWwgdm9pZCBzZXRDYWxsYmFja3MoV2ViSURCVHJhbnNhY3Rpb25DYWxsYmFja3MqKTsKIAor ICAgIHZpcnR1YWwgb3BlcmF0b3IgV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJm YWNlKigpIGNvbnN0OworCiBwcml2YXRlOgogICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OklEQlRy YW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gbV9iYWNrZW5kOwogfTsK 68476 2010-09-22 17:20:15 -0700 2010-09-23 06:57:39 -0700 Patch bug-44700-20100923012012.patch text/plain 68706 andreip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0NDUzMDIzMWFkZWQwOTMzMDgwNzQ5Nzc0MzNhZjhjMGM0Y2RiYjJlLi45MGI5ZDZk ZGZhODM1Mjc2OTdkNmE2ZGRjYzNmZDRjMmYzYTczNzhkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAK KzIwMTAtMDktMjIgIEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBnb29nbGUuY29tPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElEQk9iamVjdFN0b3Jl OjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAgICAgICAqIHN0b3JhZ2UvaW5k ZXhlZGRiL29iamVjdHN0b3JlLWJhc2ljcy1leHBlY3RlZC50eHQ6CisgICAgICAgICogc3RvcmFn ZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLmh0bWw6CisgICAgICAgICogc3RvcmFnZS9p bmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0OgorICAg ICAgICAqIHN0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0 bWw6CisgICAgICAgICogc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0LWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0 Lmh0bWw6IEFkZGVkLgorCiAyMDEwLTA5LTIwICBKYW1lcyBLb3ppYW5za2kgIDxrb3pAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE9qYW4gVmFmYWkuCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MtZXhwZWN0ZWQu dHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLWV4 cGVjdGVkLnR4dAppbmRleCA4OTBjMDBmYTcwYTY1YzhjZWIzZTRhNTA1ZGU0NTY4ZDhhYTVjOGU5 Li44MjFlOTY2YjQzOWU1NDUyOWVjMWUxYzU0YThlOWI1NWMxNmQzOTVjIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MtZXhwZWN0ZWQu dHh0CisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLWJhc2lj cy1leHBlY3RlZC50eHQKQEAgLTExMyw3ICsxMTMsOCBAQCBQQVNTICdyZWFkeVN0YXRlJyBpbiBl dmVudC50YXJnZXQgaXMgdHJ1ZQogUEFTUyBldmVudC50YXJnZXQucmVhZHlTdGF0ZSBpcyBldmVu dC50YXJnZXQuRE9ORQogCiBQQVNTIGV2ZW50LmNvZGUgaXMgSURCRGF0YWJhc2VFeGNlcHRpb24u VU5LTk9XTl9FUlIKLXN0b3JlID0gZXZlbnQuc291cmNlCitkYi50cmFuc2FjdGlvbigpCitzdG9y ZSA9IHRyYW5zYWN0aW9uLm9iamVjdFN0b3JlKCdzdG9yZU5hbWUnKQogc3RvcmUuZ2V0KCdrZXkn KQogUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQogUEFTUyAnb25lcnJvcicgaW4g cmVzdWx0IGlzIHRydWUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRi L29iamVjdHN0b3JlLWJhc2ljcy5odG1sIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIv b2JqZWN0c3RvcmUtYmFzaWNzLmh0bWwKaW5kZXggNzMxZDQyMThjMjI1MDk0YjRlZGE4ZjNjNzY2 Y2MyNTQwNzE5NWYzNS4uYmVlNzM0Yzk1YTNjYTY4MWViYmJhZmUzMTU3M2I4MDk4YzZmNTdlYSAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFz aWNzLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUt YmFzaWNzLmh0bWwKQEAgLTg1LDcgKzg1LDEwIEBAIGZ1bmN0aW9uIGFkZEFnYWluRmFpbHVyZSgp CiAgICAgdmVyaWZ5RXJyb3JFdmVudChldmVudCk7CiAgICAgLy8gRklYTUU6IFRoaXMgZXJyb3Ig Y29kZSBuZWVkcyB0byBiZSBzcGVjY2VkLgogICAgIHNob3VsZEJlKCJldmVudC5jb2RlIiwgIklE QkRhdGFiYXNlRXhjZXB0aW9uLlVOS05PV05fRVJSIik7Ci0gICAgdmFyIHN0b3JlID0gZXZhbEFu ZExvZygic3RvcmUgPSBldmVudC5zb3VyY2UiKTsKKworICAgIHRyYW5zYWN0aW9uID0gZXZhbEFu ZExvZygiZGIudHJhbnNhY3Rpb24oKSIpOw0KKyAgICB0cmFuc2FjdGlvbi5vbmFib3J0ID0gdW5l eHBlY3RlZEVycm9yQ2FsbGJhY2s7DQorICAgIHZhciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3Jl ID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7CiAKICAgICByZXN1bHQg PSBldmFsQW5kTG9nKCJzdG9yZS5nZXQoJ2tleScpIik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3Vs dCk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9y ZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9zdG9yYWdlL2lu ZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50eHQKaW5kZXgg MGEzZDkzODZjNWIxYjY0M2EwZDgxNjllOGJkZjZlNjgyNTVmZjM5MS4uYzliYmFhNWU4NTU3OGFk ZmI3MWEzM2IzMjkyMjg0Nzg1YTg0NDFhYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFn ZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0Cisr KyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJlbW92ZW9iamVj dHN0b3JlLWV4cGVjdGVkLnR4dApAQCAtNjEsNyArNjEsOSBAQCBQQVNTICdhYm9ydCcgaW4gZXZl bnQudGFyZ2V0IGlzIHRydWUKIFBBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0 cnVlCiBQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCiAK LWV2ZW50LnNvdXJjZS5nZXQoJ2tleScpCitkYi50cmFuc2FjdGlvbigpDQorc3RvcmUgPSB0cmFu c2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykNCitzdG9yZS5nZXQoJ2tleScpCiBQQVNT ICdvbnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCiBQQVNTICdvbmVycm9yJyBpbiByZXN1bHQg aXMgdHJ1ZQogUEFTUyAnYWJvcnQnIGluIHJlc3VsdCBpcyB0cnVlCkBAIC0xMzksNyArMTQxLDkg QEAgUEFTUyAnYWJvcnQnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCiBQQVNTICdyZWFkeVN0YXRl JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQogUEFTUyBldmVudC50YXJnZXQucmVhZHlTdGF0ZSBp cyBldmVudC50YXJnZXQuRE9ORQogCi1ldmVudC5yZXN1bHQuZ2V0KCdrZXknKQorZGIudHJhbnNh Y3Rpb24oKQ0KK3N0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpDQor c3RvcmUuZ2V0KCdrZXknKQogUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQogUEFT UyAnb25lcnJvcicgaW4gcmVzdWx0IGlzIHRydWUKIFBBU1MgJ2Fib3J0JyBpbiByZXN1bHQgaXMg dHJ1ZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3Rv cmUtcmVtb3Zlb2JqZWN0c3RvcmUuaHRtbCBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRi L29iamVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0bWwKaW5kZXggZTg0MmY1YmZiZjhlZTEx N2YwZDZmM2MwYzBjYTg0ZWM0N2FlNDhjNi4uN2E5YTZlMjE2OTU0MDUxNDAwZjVkODhiZTQ3NjZk YzQ5ODc5OGMyYSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2Jq ZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9zdG9yYWdl L2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS5odG1sCkBAIC00OSw3ICs0 OSwxMSBAQCBmdW5jdGlvbiBnZXRWYWx1ZSgpCiB7CiAgICAgdmVyaWZ5U3VjY2Vzc0V2ZW50KGV2 ZW50KTsKIAotICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coImV2ZW50LnNvdXJjZS5nZXQoJ2tleScp Iik7CisgICAgdHJhbnNhY3Rpb24gPSBldmFsQW5kTG9nKCJkYi50cmFuc2FjdGlvbigpIik7Cisg ICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9IHVuZXhwZWN0ZWRFcnJvckNhbGxiYWNrOworICAgIHZh ciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0 b3JlTmFtZScpIik7CisKKyAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJzdG9yZS5nZXQoJ2tleScp Iik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CiAgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IGFk ZEluZGV4OwogICAgIHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7CkBA IC02MiwxNSArNjYsMjAgQEAgZnVuY3Rpb24gYWRkSW5kZXgoKQogCiAgICAgcmVzdWx0ID0gZXZh bEFuZExvZygiZXZlbnQuc291cmNlLmNyZWF0ZUluZGV4KCdpbmRleE5hbWUnLCAnJykiKTsKICAg ICB2ZXJpZnlSZXN1bHQocmVzdWx0KTsKLSAgICByZXN1bHQub25zdWNjZXNzID0gcmVtb3ZlT2Jq ZWN0U3RvcmU7CisgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IGNvbW1pdFRyYW5zYWN0aW9uOwogICAg IHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7Ci19Ci0KLWZ1bmN0aW9u IHJlbW92ZU9iamVjdFN0b3JlKCkKK30NCisNCitmdW5jdGlvbiBjb21taXRUcmFuc2FjdGlvbigp CiB7CiAgICAgdmVyaWZ5U3VjY2Vzc0V2ZW50KGV2ZW50KTsKICAgICBzaG91bGRCZVRydWUoImV2 ZW50LnNvdXJjZS5pbmRleE5hbWVzLmNvbnRhaW5zKCdpbmRleE5hbWUnKSIpOworICAgIC8vIExl dCB0aGUgdHJhbnNhY3Rpb24gY29tbWl0LgorICAgIHdpbmRvdy5zZXRUaW1lb3V0KCdyZW1vdmVP YmplY3RTdG9yZSgpJywgMCk7Cit9CiAKK2Z1bmN0aW9uIHJlbW92ZU9iamVjdFN0b3JlKCkKK3sK ICAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJkYi5yZW1vdmVPYmplY3RTdG9yZSgnc3RvcmVOYW1l JykiKTsKICAgICB2ZXJpZnlSZXN1bHQocmVzdWx0KTsKICAgICByZXN1bHQub25zdWNjZXNzID0g Y3JlYXRlT2JqZWN0U3RvcmVBZ2FpbjsKQEAgLTkxLDcgKzEwMCwxMSBAQCBmdW5jdGlvbiBnZXRW YWx1ZUFnYWluKCkKIHsKICAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOwogCi0gICAgcmVz dWx0ID0gZXZhbEFuZExvZygiZXZlbnQucmVzdWx0LmdldCgna2V5JykiKTsKKyAgICB0cmFuc2Fj dGlvbiA9IGV2YWxBbmRMb2coImRiLnRyYW5zYWN0aW9uKCkiKTsKKyAgICB0cmFuc2FjdGlvbi5v bmFib3J0ID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7CisgICAgdmFyIHN0b3JlID0gZXZhbEFu ZExvZygic3RvcmUgPSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykiKTsKKwor ICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coInN0b3JlLmdldCgna2V5JykiKTsKICAgICB2ZXJpZnlS ZXN1bHQocmVzdWx0KTsKICAgICByZXN1bHQub25zdWNjZXNzID0gdW5leHBlY3RlZFN1Y2Nlc3ND YWxsYmFjazsKICAgICByZXN1bHQub25lcnJvciA9IHZlcmlmeUVycm9yOwpAQCAtMTAwLDcgKzEx Myw2IEBAIGZ1bmN0aW9uIGdldFZhbHVlQWdhaW4oKQogZnVuY3Rpb24gdmVyaWZ5RXJyb3IoKQog ewogICAgIHZlcmlmeUVycm9yRXZlbnQoZXZlbnQpOwotICAgIC8vIEZJWE1FOiBTaG91bGQganVz dCBiZSBJREJEYXRhYmFzZUV4Y2VwdGlvbi5OT1RfRk9VTkRfRVJSIGJ1dCB0aGF0IGRvZXNuJ3Qg d29yayB5ZXQuCiAgICAgc2hvdWxkQmUoImV2ZW50LmNvZGUiLCAiMiIpOwogICAgIHNob3VsZEJl RmFsc2UoImV2ZW50LnNvdXJjZS5pbmRleE5hbWVzLmNvbnRhaW5zKCdpbmRleE5hbWUnKSIpOwog CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi90cmFuc2FjdGlvbi1n ZXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rp b24tZ2V0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lNGMxNDJkZTEyOGViNDgyNWY4MzFiNGY2 OTgzNjMzODZiZGIzOWM2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9p bmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDk5IEBACitU ZXN0IEluZGV4ZWREQidzIGdldCBpbnNpZGUgYSB0cmFuc2FjdGlvbi4KKworT24gc3VjY2Vzcywg eW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRF U1QgQ09NUExFVEUiLgorCisKK2luZGV4ZWREQi5vcGVuKCduYW1lJywgJ2Rlc2NyaXB0aW9uJykK K1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJl c3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5 U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4u CisKK1N1Y2Nlc3MgZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRydWUK K1BBU1MgJ2NvZGUnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVudCBp cyBmYWxzZQorUEFTUyAnc291cmNlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNvdXJj ZSAhPSBudWxsIGlzIHRydWUKK1BBU1MgJ29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlzIHRy dWUKK1BBU1MgJ29uZXJyb3InIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9ydCcg aW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdl dCBpcyB0cnVlCitQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5E T05FCisKK2RiID0gZXZlbnQucmVzdWx0CitkYi5jcmVhdGVPYmplY3RTdG9yZSgnc3RvcmVOYW1l JykKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGlu IHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3Jl YWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5 Li4uCisKK1N1Y2Nlc3MgZXZlbnQgZmlyZWQ6CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRy dWUKK1BBU1MgJ2NvZGUnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVu dCBpcyBmYWxzZQorUEFTUyAnc291cmNlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNv dXJjZSAhPSBudWxsIGlzIHRydWUKK1BBU1MgJ29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlz IHRydWUKK1BBU1MgJ29uZXJyb3InIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9y dCcgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRh cmdldCBpcyB0cnVlCitQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdl dC5ET05FCisKK29iamVjdFN0b3JlID0gZXZlbnQucmVzdWx0CitvYmplY3RTdG9yZS5hZGQoJ215 VmFsdWUnLCAnbXlLZXknKQorUEFTUyAnb25zdWNjZXNzJyBpbiByZXN1bHQgaXMgdHJ1ZQorUEFT UyAnb25lcnJvcicgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ2Fib3J0JyBpbiByZXN1bHQgaXMg dHJ1ZQorUEFTUyAncmVhZHlTdGF0ZScgaW4gcmVzdWx0IGlzIHRydWUKK0FuIGV2ZW50IHNob3Vs ZCBmaXJlIHNob3J0bHkuLi4KKworVXNpbmcgZ2V0IGluIGEgdHJhbnNhY3Rpb24KK2RiLnRyYW5z YWN0aW9uKCkKK3N0b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpCitQ QVNTIHN0b3JlLm5hbWUgaXMgInN0b3JlTmFtZSIKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVzdWx0 IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9ydCcg aW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVlCitB biBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4uCisKK1BBU1MgJ29uc3VjY2VzcycgaW4gcmVz dWx0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIHJlc3VsdCBpcyB0cnVlCitQQVNTICdhYm9y dCcgaW4gcmVzdWx0IGlzIHRydWUKK1BBU1MgJ3JlYWR5U3RhdGUnIGluIHJlc3VsdCBpcyB0cnVl CitBbiBldmVudCBzaG91bGQgZmlyZSBzaG9ydGx5Li4uCisKK1N1Y2Nlc3MgZXZlbnQgZmlyZWQ6 CitQQVNTICdyZXN1bHQnIGluIGV2ZW50IGlzIHRydWUKK1BBU1MgJ2NvZGUnIGluIGV2ZW50IGlz IGZhbHNlCitQQVNTICdtZXNzYWdlJyBpbiBldmVudCBpcyBmYWxzZQorUEFTUyAnc291cmNlJyBp biBldmVudCBpcyB0cnVlCitQQVNTIGV2ZW50LnNvdXJjZSAhPSBudWxsIGlzIHRydWUKK1BBU1Mg J29uc3VjY2VzcycgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgJ29uZXJyb3InIGluIGV2 ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTICdhYm9ydCcgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUK K1BBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCitQQVNTIGV2ZW50LnRh cmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCisKK3ZhbHVlID0gZXZlbnQucmVz dWx0CitQQVNTIHZhbHVlIGlzICJteVZhbHVlIgorRXJyb3IgZXZlbnQgZmlyZWQ6CitQQVNTICdy ZXN1bHQnIGluIGV2ZW50IGlzIGZhbHNlCitQQVNTICdjb2RlJyBpbiBldmVudCBpcyB0cnVlCitQ QVNTICdtZXNzYWdlJyBpbiBldmVudCBpcyB0cnVlCitQQVNTICdzb3VyY2UnIGluIGV2ZW50IGlz IHRydWUKK1BBU1MgZXZlbnQuc291cmNlICE9IG51bGwgaXMgdHJ1ZQorUEFTUyAnb25zdWNjZXNz JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyAnb25lcnJvcicgaW4gZXZlbnQudGFyZ2V0 IGlzIHRydWUKK1BBU1MgJ2Fib3J0JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQorUEFTUyAncmVh ZHlTdGF0ZScgaW4gZXZlbnQudGFyZ2V0IGlzIHRydWUKK1BBU1MgZXZlbnQudGFyZ2V0LnJlYWR5 U3RhdGUgaXMgZXZlbnQudGFyZ2V0LkRPTkUKKworQWNjZXNzaW5nIGEgY29tbWl0dGVkIHRyYW5z YWN0aW9uIHNob3VsZCB0aHJvdworUEFTUyBleGMuY29kZSBpcyA1CitQQVNTIHN1Y2Nlc3NmdWxs eVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L3N0b3JhZ2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sIGIvTGF5b3V0VGVzdHMvc3Rv cmFnZS9pbmRleGVkZGIvdHJhbnNhY3Rpb24tZ2V0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTVjZjZkMTNh ODgzNTQ4MTNkM2JhYWYxODBjMDFlMmFiYmI3ZDIwZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL3RyYW5zYWN0aW9uLWdldC5odG1sCkBAIC0wLDAgKzEs OTMgQEAKKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4u L2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8u Li9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LWZ1bmN0aW9uLmpzIj48L3Nj cmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2hhcmVkLmpzIj48L3NjcmlwdD4KKzwvaGVh ZD4KKzxib2R5PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48 L2Rpdj4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbigiVGVzdCBJbmRleGVkREIncyBnZXQgaW5zaWRl IGEgdHJhbnNhY3Rpb24uIik7CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAg IGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKworZnVuY3Rpb24gYWZ0ZXJD b21taXQoKSB7CisgICAgdHJ5IHsKKyAgICAgICAgZGVidWcoIkFjY2Vzc2luZyBhIGNvbW1pdHRl ZCB0cmFuc2FjdGlvbiBzaG91bGQgdGhyb3ciKTsKKyAgICAgICAgdmFyIHN0b3JlID0gdHJhbnNh Y3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpOworICAgIH0gY2F0Y2ggKGUpIHsKKyAgICAg ICAgZXhjID0gZTsKKyAgICAgICAgc2hvdWxkQmUoJ2V4Yy5jb2RlJywgJzUnKTsKKyAgICB9Cisg ICAgZG9uZSgpOworfQorCitmdW5jdGlvbiBub25FeGlzdGluZ0tleSgpIHsKKyAgICB2ZXJpZnlF cnJvckV2ZW50KGV2ZW50KTsKKyAgICB3aW5kb3cuc2V0VGltZW91dCgnYWZ0ZXJDb21taXQoKScs IDApOworfQorCitmdW5jdGlvbiBnb3RWYWx1ZSgpIHsKKyAgICB2ZXJpZnlTdWNjZXNzRXZlbnQo ZXZlbnQpOworICAgIHZhciB2YWx1ZSA9IGV2YWxBbmRMb2coInZhbHVlID0gZXZlbnQucmVzdWx0 Iik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd2YWx1ZScsICdteVZhbHVlJyk7Cit9CisK K2Z1bmN0aW9uIHN0YXJ0VHJhbnNhY3Rpb24oKSB7CisgICAgZGVidWcoIlVzaW5nIGdldCBpbiBh IHRyYW5zYWN0aW9uIik7CisgICAgdHJhbnNhY3Rpb24gPSBldmFsQW5kTG9nKCJkYi50cmFuc2Fj dGlvbigpIik7CisgICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9IHVuZXhwZWN0ZWRFcnJvckNhbGxi YWNrOworICAgIHZhciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3JlID0gdHJhbnNhY3Rpb24ub2Jq ZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJzdG9y ZS5uYW1lIiwgInN0b3JlTmFtZSIpOworICAgIHZhciByZXN1bHQgPSBzdG9yZS5nZXQoJ215S2V5 Jyk7CisgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CisgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IGdv dFZhbHVlOworICAgIHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7CisK KyAgICB2YXIgZW1wdHlSZXN1bHQgPSBzdG9yZS5nZXQoJ25vbkV4aXN0aW5nS2V5Jyk7CisgICAg dmVyaWZ5UmVzdWx0KGVtcHR5UmVzdWx0KTsKKyAgICBlbXB0eVJlc3VsdC5vbnN1Y2Nlc3MgPSB1 bmV4cGVjdGVkU3VjY2Vzc0NhbGxiYWNrOworICAgIGVtcHR5UmVzdWx0Lm9uZXJyb3IgPSBub25F eGlzdGluZ0tleTsKK30KKworZnVuY3Rpb24gcG9wdWxhdGVPYmplY3RTdG9yZShvYmplY3RTdG9y ZSkgeworICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coIm9iamVjdFN0b3JlLmFkZCgnbXlWYWx1ZScs ICdteUtleScpIik7CisgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CisgICAgcmVzdWx0Lm9uc3Vj Y2VzcyA9IHN0YXJ0VHJhbnNhY3Rpb247CisgICAgcmVzdWx0Lm9uZXJyb3IgPSB1bmV4cGVjdGVk RXJyb3JDYWxsYmFjazsKK30KKworZnVuY3Rpb24gY3JlYXRlT2JqZWN0U3RvcmVTdWNjZXNzKCkg eworICAgIHZlcmlmeVN1Y2Nlc3NFdmVudChldmVudCk7CisgICAgdmFyIG9iamVjdFN0b3JlID0g ZXZhbEFuZExvZygib2JqZWN0U3RvcmUgPSBldmVudC5yZXN1bHQiKTsKKyAgICBwb3B1bGF0ZU9i amVjdFN0b3JlKG9iamVjdFN0b3JlKTsKK30KKworZnVuY3Rpb24gb3BlblN1Y2Nlc3MoKSB7Cisg ICAgdmVyaWZ5U3VjY2Vzc0V2ZW50KGV2ZW50KTsKKyAgICB2YXIgZGIgPSBldmFsQW5kTG9nKCJk YiA9IGV2ZW50LnJlc3VsdCIpOworCisgICAgZGVsZXRlQWxsT2JqZWN0U3RvcmVzKGRiKTsKKwor ICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coImRiLmNyZWF0ZU9iamVjdFN0b3JlKCdzdG9yZU5hbWUn KSIpOworICAgIHZlcmlmeVJlc3VsdChyZXN1bHQpOworICAgIHJlc3VsdC5vbnN1Y2Nlc3MgPSBj cmVhdGVPYmplY3RTdG9yZVN1Y2Nlc3M7CisgICAgcmVzdWx0Lm9uZXJyb3IgPSB1bmV4cGVjdGVk RXJyb3JDYWxsYmFjazsKK30KKworZnVuY3Rpb24gdGVzdCgpIHsKKyAgICByZXN1bHQgPSBldmFs QW5kTG9nKCJpbmRleGVkREIub3BlbignbmFtZScsICdkZXNjcmlwdGlvbicpIik7CisgICAgdmVy aWZ5UmVzdWx0KHJlc3VsdCk7CisgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IG9wZW5TdWNjZXNzOwor ICAgIHJlc3VsdC5vbmVycm9yID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7Cit9CisKK3Rlc3Qo KTsKKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CisKKzwvc2NyaXB0PgorPC9ib2R5 PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5n ZUxvZwppbmRleCBhY2ZmNjc1MzliOTI2YzBjODg1N2IxYWYzNzFmNzE2NGQxYjcxYTZmLi4wZGI1 YTBjYjI0MTZiMjE1ZDg3OGMxYzM4MmFmYjE2ZTA2YjBlODI0IDEwMDY0NAotLS0gYS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDc4IEBACisyMDEw LTA5LTIyICBBbmRyZWkgUG9wZXNjdSAgPGFuZHJlaXBAZ29vZ2xlLmNvbT4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJREJPYmplY3RTdG9yZTo6Z2V0 IHNob3VsZCBydW4gaW4gYSB0cmFuc2FjdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzAwCisKKyAgICAgICAgSW1wbGVtZW50cyBsb2dpYyBm b3IgcnVubmluZyBJREJPYmplY3RTdG9yZTo6Z2V0KCkgaW4gYSB0cmFuc2FjdGlvbi4KKyAgICAg ICAgUmVmYWN0b3JzIHRoZSBwZW5kaW5nIHRyYW5zYWN0aW9uIG1vbml0b3IgYW5kIHRoZSB0cmFu c2FjdGlvbiBjb29yZGluYXRvcgorICAgICAgICB0byB1c2UgcG9pbnRlcnMgaW5zdGVhZCBvZiB0 cmFuc2FjdGlvbiBJRHMuCisKKyAgICAgICAgVGVzdDogc3RvcmFnZS9pbmRleGVkZGIvdHJhbnNh Y3Rpb24tZ2V0Lmh0bWwKKworICAgICAgICAqIGJpbmRpbmdzL3Y4L1Y4UHJveHkuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6VjhQcm94eTo6ZGlkTGVhdmVTY3JpcHRDb250ZXh0KToKKyAgICAgICAg KiBzdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcDoKKyAgICAgICAgKiBzdG9yYWdlL0lE QkRhdGFiYXNlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQkRhdGFiYXNlOjpvYmplY3RTdG9y ZSk6CisgICAgICAgICogc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OklEQkRhdGFiYXNlQmFja2VuZEltcGw6Om9iamVjdFN0b3JlKToKKyAgICAg ICAgKiBzdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaDoKKyAgICAgICAgKFdlYkNvcmU6 OklEQkRhdGFiYXNlQmFja2VuZEltcGw6OnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IpOgorICAgICAg ICAqIHN0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcDoKKyAgICAgICAgKiBzdG9yYWdl L0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5oOgorICAgICAgICAqIHN0b3JhZ2UvSURCRmFjdG9yeUJh Y2tlbmRJbnRlcmZhY2UuaDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3JlOjpJREJPYmplY3RTdG9yZSk6CisgICAg ICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZTo6Z2V0KToKKyAgICAgICAgKiBzdG9yYWdlL0lE Qk9iamVjdFN0b3JlLmg6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZTo6Y3JlYXRl KToKKyAgICAgICAgKiBzdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6Z2V0KToKKyAgICAgICAg KFdlYkNvcmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldEludGVybmFsKToKKyAgICAg ICAgKiBzdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuaDoKKyAgICAgICAgKFdlYkNv cmU6OklEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OklEQlRhc2s6OklEQlRhc2spOgorICAgICAg ICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6SURCVGFzazo6cGVyZm9ybVRh c2spOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6Y3JlYXRl VGFzayk6CisgICAgICAgICogc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2Uu aDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6SURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWRkUGVuZGlu Z1RyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlBlbmRpbmdUcmFuc2FjdGlvbk1v bml0b3I6OnJlbW92ZVBlbmRpbmdUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJQ ZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMpOgorICAg ICAgICAqIHN0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oOgorICAgICAgICAq IHN0b3JhZ2UvSURCUmVxdWVzdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJSZXF1ZXN0OjpJ REJSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlJlcXVlc3Q6On5JREJSZXF1ZXN0KToK KyAgICAgICAgKFdlYkNvcmU6OklEQlJlcXVlc3Q6Om9uU3VjY2Vzcyk6CisgICAgICAgIChXZWJD b3JlOjpJREJSZXF1ZXN0Ojp0aW1lckZpcmVkKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlJlcXVl c3QuaDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlJlcXVlc3Q6OmNyZWF0ZSk6CisgICAgICAgICog c3RvcmFnZS9JREJUcmFuc2FjdGlvbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2Fj dGlvbjo6SURCVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb246 Om9iamVjdFN0b3JlKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZElt cGwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6Y3Jl YXRlKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OklEQlRy YW5zYWN0aW9uQmFja2VuZEltcGwpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25C YWNrZW5kSW1wbDo6b2JqZWN0U3RvcmUpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rp b25CYWNrZW5kSW1wbDo6c2NoZWR1bGVUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5z YWN0aW9uQmFja2VuZEltcGw6OmFib3J0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0 aW9uQmFja2VuZEltcGw6OmRpZENvbXBsZXRlVGFza0V2ZW50cyk6CisgICAgICAgIChXZWJDb3Jl OjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpydW4pOgorICAgICAgICAoV2ViQ29yZTo6SURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6c3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbDo6Y29tbWl0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5z YWN0aW9uQmFja2VuZEltcGw6OnRpbWVyRmlyZWQpOgorICAgICAgICAqIHN0b3JhZ2UvSURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbC5oOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25C YWNrZW5kSW1wbDo6fklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwpOgorICAgICAgICAoV2ViQ29y ZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6aXNGaW5pc2hlZCk6CisgICAgICAgICogc3Rv cmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaDoKKyAgICAgICAgKiBzdG9yYWdl L0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJh bnNhY3Rpb25Db29yZGluYXRvcjo6Y3JlYXRlVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29y ZTo6SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcjo6ZGlkU3RhcnRUcmFuc2FjdGlvbik6CisgICAg ICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpkaWRGaW5pc2hUcmFuc2Fj dGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpwcm9j ZXNzU3RhcnRlZFRyYW5zYWN0aW9ucyk6CisgICAgICAgICogc3RvcmFnZS9JREJUcmFuc2FjdGlv bkNvb3JkaW5hdG9yLmg6CisKIDIwMTAtMDktMTkgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmll dy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2Nzc0 OS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhQcm94eS5jcHAgYi9XZWJDb3Jl L2JpbmRpbmdzL3Y4L1Y4UHJveHkuY3BwCmluZGV4IGE3NzZlZTdkNzNmYjkyZDQ4NmU2NzdkMDg1 ZGFlMTYzNzk3ZGI4NGQuLjFkZDEyZjg4ODczMDk0ODZlZDY4ZWM5NDZlZTc2YjRhMzcwZTk3MGQg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhQcm94eS5jcHAKKysrIGIvV2ViQ29y ZS9iaW5kaW5ncy92OC9WOFByb3h5LmNwcApAQCAtNjUzLDExICs2NTMsNyBAQCB2b2lkIFY4UHJv eHk6OmRpZExlYXZlU2NyaXB0Q29udGV4dCgpCiAgICAgLy8gSWYgd2UndmUganVzdCBsZWZ0IGEg c2NyaXB0IGNvbnRleHQgYW5kIGluZGV4ZWQgZGF0YWJhc2UgaGFzIGJlZW4KICAgICAvLyBpbnN0 YW50aWF0ZWQsIHdlIG11c3QgbGV0IGl0cyB0cmFuc2FjdGlvbiBjb29yZGluYXRvciBrbm93IHNv IGl0IGNhbiB0ZXJtaW5hdGUKICAgICAvLyBhbnkgbm90LXlldC1zdGFydGVkIHRyYW5zYWN0aW9u cy4KLSAgICBpZiAoSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6aGFzUGVuZGluZ1RyYW5z YWN0aW9ucygpKSB7Ci0gICAgICAgIEFTU0VSVChwYWdlLT5ncm91cCgpLmhhc0lEQkZhY3Rvcnko KSk7Ci0gICAgICAgIHBhZ2UtPmdyb3VwKCkuaWRiRmFjdG9yeSgpLT5hYm9ydFBlbmRpbmdUcmFu c2FjdGlvbnMoSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6cGVuZGluZ1RyYW5zYWN0aW9u cygpKTsKLSAgICAgICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6Y2xlYXJQZW5kaW5n VHJhbnNhY3Rpb25zKCk7Ci0gICAgfQorICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6 OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucygpOwogI2VuZGlmIC8vIEVOQUJMRShJTkRFWEVEX0RB VEFCQVNFKQogICAgIC8vIElmIHdlJ3ZlIGp1c3QgbGVmdCBhIHRvcCBsZXZlbCBzY3JpcHQgY29u dGV4dCBhbmQgbG9jYWwgc3RvcmFnZSBoYXMgYmVlbgogICAgIC8vIGluc3RhbnRpYXRlZCwgd2Ug bXVzdCBlbnN1cmUgdGhhdCBhbnkgc3RvcmFnZSBsb2NrcyBoYXZlIGJlZW4gZnJlZWQuCmRpZmYg LS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCQ3Vyc29yQmFja2VuZEltcGwuY3BwIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcAppbmRleCAzYTRkZDY3NzQ4YWI3NDc1 ZjE2OWNlZDc0NzZhMzVmN2Q1YjY4MzhkLi4xM2RmNWYwMjE1NGU1NWQxNjI2ZDA2MjJlMGJkMjVj NWNlMGJkOThhIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCQ3Vyc29yQmFja2VuZElt cGwuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJDdXJzb3JCYWNrZW5kSW1wbC5jcHAKQEAg LTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlICJJREJLZXlSYW5nZS5oIgogI2luY2x1ZGUgIklEQk9i amVjdFN0b3JlQmFja2VuZEltcGwuaCIKICNpbmNsdWRlICJJREJSZXF1ZXN0LmgiCisjaW5jbHVk ZSAiSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5jbHVkZSAiU1FMaXRlRGF0 YWJhc2UuaCIKICNpbmNsdWRlICJTUUxpdGVTdGF0ZW1lbnQuaCIKICNpbmNsdWRlICJTZXJpYWxp emVkU2NyaXB0VmFsdWUuaCIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFz ZS5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwCmluZGV4IDgxOTUwZDZlMDQz YmRmMjBiZjViYmM1ZjYzZjk5ODAyNjI5MmNhY2EuLjBlYTdhYzI5MjY3NGNlYTYwOTcwMzVmYTVm ZTVjODk3ZjQ0ZGI2YjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZS5j cHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlLmNwcApAQCAtNTUsMTEgKzU1LDEy IEBAIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gSURCRGF0YWJhc2U6OmNyZWF0ZU9iamVjdFN0b3Jl KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvCiAgICAgcmV0dXJuIHJlcXVlc3Q7CiB9CiAKKy8v IEZJWE1FOiByZW1vdmUgdGhpcyBtZXRob2QuCiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBJ REJEYXRhYmFzZTo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCB1bnNpZ25lZCBzaG9y dCBtb2RlKQogewogICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9i amVjdFN0b3JlID0gbV9iYWNrZW5kLT5vYmplY3RTdG9yZShuYW1lLCBtb2RlKTsKICAgICBBU1NF UlQob2JqZWN0U3RvcmUpOyAvLyBGSVhNRTogSWYgdGhpcyBpcyBudWxsLCB3ZSBzaG91bGQgcmFp c2UgYSBOT1RfRk9VTkRfRVJSLgotICAgIHJldHVybiBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9i amVjdFN0b3JlLnJlbGVhc2UoKSk7CisgICAgcmV0dXJuIElEQk9iamVjdFN0b3JlOjpjcmVhdGUo b2JqZWN0U3RvcmUucmVsZWFzZSgpLCAwKTsKIH0KIAogUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBJ REJEYXRhYmFzZTo6cmVtb3ZlT2JqZWN0U3RvcmUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lE QkRhdGFiYXNlQmFja2VuZEltcGwuY3BwIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFj a2VuZEltcGwuY3BwCmluZGV4IDAyMWY3MGFhNGI0ODgxMTllOWZjOTYxNmYwNDVkNDk5Y2E0Yjgx YWIuLmI4ZmU5YjUwNjJmNmQ2MDMwNWJjMWQ1YzYwMTVkZDAwMjJmYzc1NDEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmNwcAorKysgYi9XZWJDb3Jl L3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5jcHAKQEAgLTE0OCwxMSArMTQ4LDEyIEBA IHZvaWQgSURCRGF0YWJhc2VCYWNrZW5kSW1wbDo6Y3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3Ry aW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmCiAgICAgY2FsbGJhY2tzLT5vblN1Y2Nlc3Mob2JqZWN0 U3RvcmUuZ2V0KCkpOwogfQogCisvLyBGSVhNRTogRG8gbm90IGV4cG9zZSB0aGlzIG1ldGhvZCB2 aWEgSURMLgogUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IElEQkRh dGFiYXNlQmFja2VuZEltcGw6Om9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWdu ZWQgc2hvcnQgbW9kZSkKIHsKLSAgICAvLyBGSVhNRTogSWYgbm8gdHJhbnNhY3Rpb24gaXMgcnVu bmluZywgdGhpcyBzaG91bGQgaW1wbGljaXRseSBzdGFydCBvbmUuCi0gICAgQVNTRVJUX1VOVVNF RChtb2RlLCAhbW9kZSk7IC8vIEZJWE1FOiBIYW5kbGUgbm9uLXN0YW5kYXJkIG1vZGVzLgotICAg IHJldHVybiBtX29iamVjdFN0b3Jlcy5nZXQobmFtZSk7CisgICAgQVNTRVJUX1VOVVNFRChtb2Rl LCAhbW9kZSk7IC8vIEZJWE1FOiBSZW1vdmUgdGhlIG1vZGUgcGFyYW1ldGVyLiBUcmFuc2FjdGlv bnMgaGF2ZSBtb2Rlcywgbm90IG9iamVjdCBzdG9yZXMuCisgICAgUmVmUHRyPElEQk9iamVjdFN0 b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUgPSBtX29iamVjdFN0b3Jlcy5nZXQobmFt ZSk7CisgICAgcmV0dXJuIG9iamVjdFN0b3JlLnJlbGVhc2UoKTsKIH0KIAogc3RhdGljIHZvaWQg ZG9EZWxldGUoU1FMaXRlRGF0YWJhc2UmIGRiLCBjb25zdCBjaGFyKiBzcWwsIGludDY0X3QgaWQp CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oIGIv V2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaAppbmRleCBhYjA1NWY4OGE4 YzA4ZjJmNmQwM2Q2OTU5ODE0NDE1NzhjNGYyNTcwLi43ZTA4YWQ2NWFmZTQ2Y2EzZTQzNjNlYWVm NjBiMjU3MDUzY2UzM2IxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VC YWNrZW5kSW1wbC5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBs LmgKQEAgLTYyLDYgKzYyLDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRWZXJzaW9u KGNvbnN0IFN0cmluZyYgdmVyc2lvbiwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2 aXJ0dWFsIFBhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiB0cmFuc2Fj dGlvbihET01TdHJpbmdMaXN0KiBzdG9yZU5hbWVzLCB1bnNpZ25lZCBzaG9ydCBtb2RlLCB1bnNp Z25lZCBsb25nIHRpbWVvdXQpOwogCisgICAgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvciogdHJh bnNhY3Rpb25Db29yZGluYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fdHJhbnNhY3Rpb25Db29yZGlu YXRvci5nZXQoKTsgfQorCiBwcml2YXRlOgogICAgIElEQkRhdGFiYXNlQmFja2VuZEltcGwoY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNzT3duUHRyPFNR TGl0ZURhdGFiYXNlPiBkYXRhYmFzZSwgSURCVHJhbnNhY3Rpb25Db29yZGluYXRvciopOwogCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcCBiL1dl YkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuY3BwCmluZGV4IGQ4MTljOTJhOTRh ODkyMTBiNjNkYWZmMTE3ZWY4NDI4MTQ3ZWRjNjcuLmVmMTEyZjA4ZGU5MDRhYWE3NmQzYTdhNTEx NjE2ODUwMjM1ZDUzMTQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFj a2VuZEltcGwuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwu Y3BwCkBAIC0xNDIsMTIgKzE0Miw2IEBAIHZvaWQgSURCRmFjdG9yeUJhY2tlbmRJbXBsOjpvcGVu KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwKICAgICBtX2Rh dGFiYXNlQmFja2VuZE1hcC5zZXQobmFtZSwgZGF0YWJhc2VCYWNrZW5kLnJlbGVhc2UoKSk7CiB9 CiAKLXZvaWQgSURCRmFjdG9yeUJhY2tlbmRJbXBsOjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMo Y29uc3QgVmVjdG9yPGludD4mIHBlbmRpbmdJRHMpCi17Ci0gICAgZm9yIChzaXplX3QgaSA9IDA7 IGkgPCBwZW5kaW5nSURzLnNpemUoKTsgKytpKQotICAgICAgICBtX3RyYW5zYWN0aW9uQ29vcmRp bmF0b3ItPmFib3J0KHBlbmRpbmdJRHMuYXQoaSkpOwotfQotCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKZGlmZiAtLWdpdCBhL1dl YkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFnZS9J REJGYWN0b3J5QmFja2VuZEltcGwuaAppbmRleCBmMmUxYWY4MTE1ZWJiNGRiZTNmZmUxMDdkNjI3 NDgyZWJmNWE5MGM3Li5jYjkzOGY5MDQxNzQ1MjY5YWM1ODNlODI5OTA3NzhlZThmZDliNWJlIDEw MDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmgKKysrIGIv V2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5oCkBAIC01MCw3ICs1MCw2IEBA IHB1YmxpYzoKICAgICB2aXJ0dWFsIH5JREJGYWN0b3J5QmFja2VuZEltcGwoKTsKIAogICAgIHZp cnR1YWwgdm9pZCBvcGVuKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlw dGlvbiwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+LCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2lu PiwgRnJhbWUqLCBjb25zdCBTdHJpbmcmIGRhdGFEaXIpOwotICAgIHZpcnR1YWwgdm9pZCBhYm9y dFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIHBlbmRpbmdJRHMpOwogCiBw cml2YXRlOgogICAgIElEQkZhY3RvcnlCYWNrZW5kSW1wbCgpOwpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW50ZXJmYWNlLmggYi9XZWJDb3JlL3N0b3JhZ2Uv SURCRmFjdG9yeUJhY2tlbmRJbnRlcmZhY2UuaAppbmRleCBlNTkxMjcxOWVmNTQ0OTQ0NmVhNmJj MjJmMzU2NDYzMDZkOGQ3MGJkLi40OTE0MDI0M2VhNjQwZDA3ZGEwZjA5MWRlMjk0OGM0NmUyOGE2 ODcyIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbnRlcmZh Y2UuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbnRlcmZhY2UuaApA QCAtNTIsNyArNTIsNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB+SURCRmFjdG9yeUJhY2tlbmRJ bnRlcmZhY2UoKSB7IH0KIAogICAgIHZpcnR1YWwgdm9pZCBvcGVuKGNvbnN0IFN0cmluZyYgbmFt ZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+LCBQ YXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiwgRnJhbWUqLCBjb25zdCBTdHJpbmcmIGRhdGFEaXIp ID0gMDsKLSAgICB2aXJ0dWFsIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFZl Y3RvcjxpbnQ+JiBpZHMpID0gMDsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAt LWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHAgYi9XZWJDb3JlL3N0b3Jh Z2UvSURCT2JqZWN0U3RvcmUuY3BwCmluZGV4IGI0NTdjZDFkMTU4ODZjMTBmYjJlMWYzMzRhM2Rj MjJhM2ZkZjFjODUuLjc2OGI5M2M4YzU1ODViYzU4NzhmMDhmZjJhYjlmOTg3NjI4MWRkNjAgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHAKKysrIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUg IklEQkluZGV4LmgiCiAjaW5jbHVkZSAiSURCS2V5LmgiCiAjaW5jbHVkZSAiSURCS2V5UmFuZ2Uu aCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaCIKICNpbmNsdWRl ICJTZXJpYWxpemVkU2NyaXB0VmFsdWUuaCIKICNpbmNsdWRlIDx3dGYvVW51c2VkUGFyYW0uaD4K IApAQCAtMzgsOCArMzksOSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLUlEQk9iamVjdFN0 b3JlOjpJREJPYmplY3RTdG9yZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZT4gaWRiT2JqZWN0U3RvcmUpCitJREJPYmplY3RTdG9yZTo6SURCT2JqZWN0U3RvcmUoUGFz c1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IGlkYk9iamVjdFN0b3JlLCBJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKQogICAgIDogbV9vYmpl Y3RTdG9yZShpZGJPYmplY3RTdG9yZSkKKyAgICAsIG1fdHJhbnNhY3Rpb24odHJhbnNhY3Rpb24p CiB7CiAgICAgLy8gV2UgcGFzcyBhIHJlZmVyZW5jZSB0byB0aGlzIG9iamVjdCBiZWZvcmUgaXQg Y2FuIGJlIGFkb3B0ZWQuCiAgICAgcmVsYXhBZG9wdGlvblJlcXVpcmVtZW50KCk7CkBAIC02Miw5 ICs2NCw5IEBAIFBhc3NSZWZQdHI8RE9NU3RyaW5nTGlzdD4gSURCT2JqZWN0U3RvcmU6OmluZGV4 TmFtZXMoKSBjb25zdAogCiBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+IElEQk9iamVjdFN0b3JlOjpn ZXQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJLZXk+IGtl eSkKIHsKLSAgICBSZWZQdHI8SURCUmVxdWVzdD4gcmVxdWVzdCA9IElEQlJlcXVlc3Q6OmNyZWF0 ZShjb250ZXh0LCBJREJBbnk6OmNyZWF0ZSh0aGlzKSk7Ci0gICAgbV9vYmplY3RTdG9yZS0+Z2V0 KGtleSwgcmVxdWVzdCk7Ci0gICAgcmV0dXJuIHJlcXVlc3Q7CisgICAgUmVmUHRyPElEQlJlcXVl c3Q+IHJlcXVlc3QgPSBJREJSZXF1ZXN0OjpjcmVhdGUoY29udGV4dCwgSURCQW55OjpjcmVhdGUo dGhpcyksIG1fdHJhbnNhY3Rpb24uZ2V0KCkpOworICAgIG1fb2JqZWN0U3RvcmUtPmdldChrZXks IHJlcXVlc3QsIG1fdHJhbnNhY3Rpb24uZ2V0KCkpOworICAgIHJldHVybiByZXF1ZXN0LnJlbGVh c2UoKTsKIH0KIAogUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBJREJPYmplY3RTdG9yZTo6YWRkKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlw dFZhbHVlPiB2YWx1ZSwgUGFzc1JlZlB0cjxJREJLZXk+IGtleSkKZGlmZiAtLWdpdCBhL1dlYkNv cmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0 b3JlLmgKaW5kZXggMDM1ZjVkOGI0N2ZiYTgyY2JjM2VkMjQ4NWI1Yjc4OGUwMzIzMTkyNi4uZGY1 YjNmNzUwYjlkNjI2OGNmNzIwOWI3MjkxODU4MjY5OWRhNGZiMiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVj dFN0b3JlLmgKQEAgLTQzLDEzICs0MywxNCBAQCBjbGFzcyBET01TdHJpbmdMaXN0OwogY2xhc3Mg SURCQW55OwogY2xhc3MgSURCSW5kZXhSZXF1ZXN0OwogY2xhc3MgSURCS2V5OworY2xhc3MgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlOwogY2xhc3MgU2VyaWFsaXplZFNjcmlwdFZhbHVl OwogCiBjbGFzcyBJREJPYmplY3RTdG9yZSA6IHB1YmxpYyBSZWZDb3VudGVkPElEQk9iamVjdFN0 b3JlPiB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IGNy ZWF0ZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gaWRiT2JqZWN0 U3RvcmUpCisgICAgc3RhdGljIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IGNyZWF0ZShQYXNz UmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gaWRiT2JqZWN0U3RvcmUsIElE QlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiAgICAgewotICAgICAg ICByZXR1cm4gYWRvcHRSZWYobmV3IElEQk9iamVjdFN0b3JlKGlkYk9iamVjdFN0b3JlKSk7Cisg ICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgSURCT2JqZWN0U3RvcmUoaWRiT2JqZWN0U3RvcmUs IHRyYW5zYWN0aW9uKSk7CiAgICAgfQogICAgIH5JREJPYmplY3RTdG9yZSgpIHsgfQogCkBAIC02 OSw5ICs3MCwxMSBAQCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBvcGVuQ3Vy c29yKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQktleVJhbmdlPiA9IDAs IHVuc2lnbmVkIHNob3J0IGRpcmVjdGlvbiA9IElEQkN1cnNvcjo6TkVYVCk7CiAKIHByaXZhdGU6 Ci0gICAgSURCT2JqZWN0U3RvcmUoUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRl cmZhY2U+KTsKKyAgICBJREJPYmplY3RTdG9yZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFj a2VuZEludGVyZmFjZT4sIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rp b24pOworICAgIHZvaWQgcmVtb3ZlVHJhbnNhY3Rpb25Gcm9tUGVuZGluZ0xpc3QoKTsKIAogICAg IFJlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG1fb2JqZWN0U3RvcmU7Cisg ICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gbV90cmFuc2FjdGlvbjsK IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFn ZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmpl Y3RTdG9yZUJhY2tlbmRJbXBsLmNwcAppbmRleCBlNWY4MWFiNGRjMzM3OTg5MjEwNDM3NTliZDJl YTg0NzNhM2I1YjVlLi5iYWI5YzQ2NjQzMjNhZGIxMWYyYmY5ZjcxZGUzZWUxMWFkYTMxNjg4IDEw MDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5jcHAK KysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwCkBAIC0z Niw2ICszNiw3IEBACiAjaW5jbHVkZSAiSURCS2V5UGF0aC5oIgogI2luY2x1ZGUgIklEQktleVBh dGhCYWNrZW5kSW1wbC5oIgogI2luY2x1ZGUgIklEQktleVJhbmdlLmgiCisjaW5jbHVkZSAiSURC VHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5jbHVkZSAiU1FMaXRlRGF0YWJhc2Uu aCIKICNpbmNsdWRlICJTUUxpdGVTdGF0ZW1lbnQuaCIKICNpbmNsdWRlICJTUUxpdGVUcmFuc2Fj dGlvbi5oIgpAQCAtNzcsNyArNzgsMTMgQEAgc3RhdGljIHZvaWQgYmluZFdoZXJlQ2xhdXNlKFNR TGl0ZVN0YXRlbWVudCYgcXVlcnksIGludDY0X3QgaWQsIElEQktleSoga2V5KQogICAgIGtleS0+ YmluZChxdWVyeSwgMik7CiB9CiAKLXZvaWQgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6Z2V0 KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiBjYWxsYmFj a3MpCit2b2lkIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldChQYXNzUmVmUHRyPElEQktl eT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4gY2FsbGJhY2tzLCBJREJUcmFuc2FjdGlv bkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKQoreworICAgIGlmICghdHJhbnNhY3Rpb24t PnNjaGVkdWxlVGFzayhjcmVhdGVUYXNrKHRoaXMsICZJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBs OjpnZXRJbnRlcm5hbCwga2V5LCBjYWxsYmFja3MpKSkKKyAgICAgICAgY2FsbGJhY2tzLT5vbkVy cm9yKElEQkRhdGFiYXNlRXJyb3I6OmNyZWF0ZShJREJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9UX0FM TE9XRURfRVJSLCAiR2V0IG11c3QgYmUgY2FsbGVkIGluIHRoZSBjb250ZXh0IG9mIGEgdHJhbnNh Y3Rpb24uIikpOworfQorCit2b2lkIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGw6OmdldEludGVy bmFsKFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiBjYWxs YmFja3MpCiB7CiAgICAgU1FMaXRlU3RhdGVtZW50IHF1ZXJ5KHNxbGl0ZURhdGFiYXNlKCksICJT RUxFQ1Qga2V5U3RyaW5nLCBrZXlEYXRlLCBrZXlOdW1iZXIsIHZhbHVlIEZST00gT2JqZWN0U3Rv cmVEYXRhICIgKyB3aGVyZUNsYXVzZShrZXkuZ2V0KCkpKTsKICAgICBib29sIG9rID0gcXVlcnku cHJlcGFyZSgpID09IFNRTFJlc3VsdE9rOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lE Qk9iamVjdFN0b3JlQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9y ZUJhY2tlbmRJbXBsLmgKaW5kZXggMzJlZjkyMDMyMjEzMjlmZTVhZTUyN2UxZTNhNjc5ZWZjY2U5 ZWZmZS4uZjZiYmQxN2RhODNkMWIyNDJiZTQ5ZTY2MjU2OGZjOGMwYmUyY2VlNSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuaAorKysgYi9XZWJD b3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbC5oCkBAIC0yNyw2ICsyNyw3IEBA CiAjZGVmaW5lIElEQk9iamVjdFN0b3JlQmFja2VuZEltcGxfaAogCiAjaW5jbHVkZSAiSURCT2Jq ZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgiCisjaW5jbHVkZSA8U2NyaXB0RXhlY3V0aW9uQ29u dGV4dC5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvU3Ry aW5nSGFzaC5oPgogCkBAIC0zNiw2ICszNyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xh c3MgSURCRGF0YWJhc2VCYWNrZW5kSW1wbDsKIGNsYXNzIElEQkluZGV4QmFja2VuZEltcGw7Citj bGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7CiBjbGFzcyBTUUxpdGVEYXRhYmFz ZTsKIAogY2xhc3MgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbCA6IHB1YmxpYyBJREJPYmplY3RT dG9yZUJhY2tlbmRJbnRlcmZhY2UgewpAQCAtNTEsNyArNTMsNyBAQCBwdWJsaWM6CiAgICAgU3Ry aW5nIGtleVBhdGgoKSBjb25zdCB7IHJldHVybiBtX2tleVBhdGg7IH0KICAgICBQYXNzUmVmUHRy PERPTVN0cmluZ0xpc3Q+IGluZGV4TmFtZXMoKSBjb25zdDsKIAotICAgIHZvaWQgZ2V0KFBhc3NS ZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CisgICAgdm9pZCBn ZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+LCBJREJU cmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKTsKICAgICB2b2lkIHB1dChQ YXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5 PiBrZXksIGJvb2wgYWRkT25seSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2b2lk IHJlbW92ZShQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4p OwogCkBAIC02OSw2ICs3MSwzNSBAQCBwcml2YXRlOgogICAgIHZvaWQgbG9hZEluZGV4ZXMoKTsK ICAgICBTUUxpdGVEYXRhYmFzZSYgc3FsaXRlRGF0YWJhc2UoKSBjb25zdDsKIAorICAgIHZvaWQg Z2V0SW50ZXJuYWwoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFj a3M+KTsKKworICAgIHRlbXBsYXRlIDxjbGFzcyBULCBjbGFzcyBNZXRob2QsIGNsYXNzIFBhcmFt MSwgY2xhc3MgUGFyYW0yPgorICAgIGNsYXNzIElEQlRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0 aW9uQ29udGV4dDo6VGFzayB7CisgICAgcHVibGljOgorICAgICAgICBJREJUYXNrKFQqIG9iaiwg TWV0aG9kIG1ldGhvZCwgY29uc3QgUGFyYW0xJiBwYXJhbTEsIGNvbnN0IFBhcmFtMiYgcGFyYW0y KQorICAgICAgICAgICAgOiBtX29iaihvYmopLCBtX21ldGhvZChtZXRob2QpLCBtX3BhcmFtMShw YXJhbTEpLCBtX3BhcmFtMihwYXJhbTIpIAorICAgICAgICB7CisgICAgICAgIH0KKworICAgICAg ICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopIAorICAg ICAgICB7CisgICAgICAgICAgICBpZiAobV9vYmopCisgICAgICAgICAgICAgICAgKG1fb2JqLT4q bV9tZXRob2QpKG1fcGFyYW0xLCBtX3BhcmFtMik7CisgICAgICAgIH0KKworICAgIHByaXZhdGU6 CisgICAgICAgIFQqIG1fb2JqOworICAgICAgICBNZXRob2QgbV9tZXRob2Q7CisgICAgICAgIFBh cmFtMSBtX3BhcmFtMTsKKyAgICAgICAgUGFyYW0yIG1fcGFyYW0yOworICAgIH07CisKKyAgICB0 ZW1wbGF0ZSA8Y2xhc3MgVCwgY2xhc3MgTWV0aG9kLCBjbGFzcyBQYXJhbTEsIGNsYXNzIFBhcmFt Mj4KKyAgICBQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+IGNyZWF0ZVRh c2soVCogb2JqZWN0LCBNZXRob2QgbWV0aG9kLCBjb25zdCBQYXJhbTEmIHBhcmFtMSwgY29uc3Qg UGFyYW0yJiBwYXJhbTIpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IElEQlRh c2s8VCwgTWV0aG9kLCBQYXJhbTEsIFBhcmFtMj4ob2JqZWN0LCBtZXRob2QsIHBhcmFtMSwgcGFy YW0yKSk7CisgICAgfQorCiAgICAgUmVmUHRyPElEQkRhdGFiYXNlQmFja2VuZEltcGw+IG1fZGF0 YWJhc2U7CiAKICAgICBpbnQ2NF90IG1faWQ7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2Uv SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmggYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2Jq ZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgKaW5kZXggMjAwYWMyOWJhN2NjYTE1OTgxODVlMzU5 M2JmYTRkNmZiNjNhMWQ0ZS4uYzE5ODU1Yzc2ZGUxZTYyNTI0Mzg1OTIxNzdlOWMwMWY3NzIzMjE5 ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZS5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZh Y2UuaApAQCAtMzgsNiArMzgsNyBAQCBjbGFzcyBJREJDYWxsYmFja3M7CiBjbGFzcyBJREJJbmRl eEJhY2tlbmRJbnRlcmZhY2U7CiBjbGFzcyBJREJLZXk7CiBjbGFzcyBJREJLZXlSYW5nZTsKK2Ns YXNzIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZTsKIGNsYXNzIFNlcmlhbGl6ZWRTY3Jp cHRWYWx1ZTsKIAogY2xhc3MgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlIDogcHVibGlj IFRocmVhZFNhZmVTaGFyZWQ8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiB7CkBAIC00 OCw3ICs0OSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFN0cmluZyBrZXlQYXRoKCkgY29uc3Qg PSAwOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBpbmRleE5hbWVzKCkg Y29uc3QgPSAwOwogCi0gICAgdmlydHVhbCB2b2lkIGdldChQYXNzUmVmUHRyPElEQktleT4ga2V5 LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgZ2V0KFBh c3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiwgSURCVHJhbnNh Y3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbikgPSAwOwogICAgIHZpcnR1YWwgdm9p ZCBwdXQoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBQYXNzUmVmUHRy PElEQktleT4ga2V5LCBib29sIGFkZE9ubHksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPikgPSAw OwogICAgIHZpcnR1YWwgdm9pZCByZW1vdmUoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1Jl ZlB0cjxJREJDYWxsYmFja3M+KSA9IDA7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9J REJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJQZW5k aW5nVHJhbnNhY3Rpb25Nb25pdG9yLmNwcAppbmRleCBkMDI2MDk5MDhhYjU3Y2RjMDFkMzk4Njk1 ZWIyNjUzNjMyMzYxYTliLi43OTkyMDBkM2QzZDU1NzA3NzczOGIxN2UyMTQ5MjRhNGMyNTQzY2Qy IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRv ci5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3Iu Y3BwCkBAIC0yNSw0NyArMjUsNDggQEAKIAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUg IklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuaCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlv bkJhY2tlbmRJbnRlcmZhY2UuaCIKIAogI2lmIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKLVZlY3RvcjxpbnQ+KiBJREJQZW5kaW5nVHJhbnNhY3Rpb25N b25pdG9yOjptX2lkcyA9IDA7CitWZWN0b3I8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNl Kj4qIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6Om1fdHJhbnNhY3Rpb25zID0gMDsKIAot Ym9vbCBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpoYXNQZW5kaW5nVHJhbnNhY3Rpb25z KCkKK3ZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWRkUGVuZGluZ1RyYW5zYWN0 aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiB7Ci0gICAg cmV0dXJuIG1faWRzICYmIG1faWRzLT5zaXplKCk7CisgICAgaWYgKCFtX3RyYW5zYWN0aW9ucykK KyAgICAgICAgbV90cmFuc2FjdGlvbnMgPSBuZXcgVmVjdG9yPElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZSo+KCk7CisgICAgbV90cmFuc2FjdGlvbnMtPmFwcGVuZCh0cmFuc2FjdGlvbik7 CiB9CiAKLXZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWRkUGVuZGluZ1RyYW5z YWN0aW9uKGludCBpZCkKK3ZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6cmVtb3Zl UGVuZGluZ1RyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNh Y3Rpb24pCiB7Ci0gICAgaWYgKCFtX2lkcykKLSAgICAgICAgbV9pZHMgPSBuZXcgVmVjdG9yPGlu dD4oKTsKLSAgICBtX2lkcy0+YXBwZW5kKGlkKTsKLX0KKyAgICBpZiAoIW1fdHJhbnNhY3Rpb25z KQorICAgICAgICByZXR1cm47CiAKLXZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6 cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKGludCBpZCkKLXsKLSAgICBtX2lkcy0+cmVtb3ZlKGlk KTsKLSAgICBpZiAoIW1faWRzLT5zaXplKCkpIHsKLSAgICAgICAgZGVsZXRlIG1faWRzOwotICAg ICAgICBtX2lkcyA9IDA7CisgICAgc2l6ZV90IHBvcyA9IG1fdHJhbnNhY3Rpb25zLT5maW5kKHRy YW5zYWN0aW9uKTsKKyAgICBpZiAocG9zID09IG5vdEZvdW5kKQorICAgICAgICByZXR1cm47CisK KyAgICBtX3RyYW5zYWN0aW9ucy0+cmVtb3ZlKHBvcyk7CisKKyAgICBpZiAoIW1fdHJhbnNhY3Rp b25zLT5zaXplKCkpIHsKKyAgICAgICAgZGVsZXRlIG1fdHJhbnNhY3Rpb25zOworICAgICAgICBt X3RyYW5zYWN0aW9ucyA9IDA7CiAgICAgfQogfQogCi12b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlv bk1vbml0b3I6OmNsZWFyUGVuZGluZ1RyYW5zYWN0aW9ucygpCit2b2lkIElEQlBlbmRpbmdUcmFu c2FjdGlvbk1vbml0b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucygpCiB7Ci0gICAgaWYgKCFt X2lkcykKKyAgICBpZiAoIW1fdHJhbnNhY3Rpb25zKQogICAgICAgICByZXR1cm47CiAKLSAgICBt X2lkcy0+Y2xlYXIoKTsKLSAgICBkZWxldGUgbV9pZHM7Ci0gICAgbV9pZHMgPSAwOwotfQorICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV90cmFuc2FjdGlvbnMtPnNpemUoKTsgKytpKQorICAg ICAgICBtX3RyYW5zYWN0aW9ucy0+YXQoaSktPmFib3J0KCk7CiAKLWNvbnN0IFZlY3RvcjxpbnQ+ JiBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpwZW5kaW5nVHJhbnNhY3Rpb25zKCkKLXsK LSAgICByZXR1cm4gKm1faWRzOworICAgIGRlbGV0ZSBtX3RyYW5zYWN0aW9uczsKKyAgICBtX3Ry YW5zYWN0aW9ucyA9IDA7CiB9CiAKIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURC UGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdU cmFuc2FjdGlvbk1vbml0b3IuaAppbmRleCAwMGU4MzNhZmIyMjE4NTNiZDk5YjM5Mzg0MTUxNjBm M2RjYzdjNmY2Li43ODNhNzMxMGZlM2ExMWUxMTFkNWI2YjE3YWZiYjkwNWUzMDNkYjI5IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oCisr KyBiL1dlYkNvcmUvc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgKQEAgLTMz LDI3ICszMywyNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIElEQlRyYW5zYWN0 aW9uQmFja2VuZEludGVyZmFjZTsKKwogLy8gVGhpcyBjbGFzcyBrZWVwcyB0cmFjayBvZiB0aGUg dHJhbnNhY3Rpb25zIGNyZWF0ZWQgZHVyaW5nIHRoZSBjdXJyZW50CiAvLyBKYXZhc2NyaXB0IGV4 ZWN1dGlvbiBjb250ZXh0LiBBIHRyYW5zYWN0aW9uIGlzICdwZW5kaW5nJyBpZiBubyBhc3luY2hy b25vdXMKIC8vIG9wZXJhdGlvbiBpcyBjdXJyZW50bHkgcXVldWVkIGZvciBpdCAoZS5nLiBhbiBJ REJPYmplY3RTdG9yZTo6cHV0KCkgb3Igc2ltaWxhcikuCiAvLyBBbGwgcGVuZGluZyB0cmFuc2Fj dGlvbnMgYXJlIGFib3J0ZWQgYXMgc29vbiBhcyBleGVjdXRpb24gcmV0dXJucyBmcm9tCiAvLyB0 aGUgc2NyaXB0IGVuZ2luZS4KIC8vCi0vLyBGSVhNRTogbW92ZSB0aGUgdmVjdG9yIG9mIHRyYW5z YWN0aW9uIElEcyB0byBUTFMuIEtlZXBpbmcgaXQgc3RhdGljCisvLyBGSVhNRTogbW92ZSB0aGUg dmVjdG9yIG9mIHRyYW5zYWN0aW9ucyB0byBUTFMuIEtlZXBpbmcgaXQgc3RhdGljCiAvLyB3aWxs IG5vdCB3b3JrIG9uY2Ugd2UgYWRkIHN1cHBvcnQgZm9yIHdvcmtlcnMuIEFub3RoZXIgcG9zc2li bGUKIC8vIHNvbHV0aW9uIGlzIHRvIGtlZXAgdGhlIHZlY3RvciBpbiB0aGUgU2NyaXB0RXhlY3V0 aW9uQ29udGV4dC4KIGNsYXNzIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IgOiBwdWJsaWMg Tm9uY29weWFibGUgewogcHVibGljOgotICAgIHN0YXRpYyBib29sIGhhc1BlbmRpbmdUcmFuc2Fj dGlvbnMoKTsKLSAgICBzdGF0aWMgdm9pZCBhZGRQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKTsK LSAgICBzdGF0aWMgdm9pZCByZW1vdmVQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKTsKLSAgICBz dGF0aWMgdm9pZCBjbGVhclBlbmRpbmdUcmFuc2FjdGlvbnMoKTsKLSAgICBzdGF0aWMgY29uc3Qg VmVjdG9yPGludD4mIHBlbmRpbmdUcmFuc2FjdGlvbnMoKTsKKyAgICBzdGF0aWMgdm9pZCBhZGRQ ZW5kaW5nVHJhbnNhY3Rpb24oSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKik7CisgICAg c3RhdGljIHZvaWQgcmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZSopOworICAgIHN0YXRpYyB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucygp OwogCiBwcml2YXRlOgogICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IoKTsKIAotICAg IHN0YXRpYyBWZWN0b3I8aW50PiogbV9pZHM7CisgICAgc3RhdGljIFZlY3RvcjxJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbnRlcmZhY2UqPiogbV90cmFuc2FjdGlvbnM7CiB9OwogCiB9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5jcHAKaW5kZXggNmZiZGEwZWVjODllYjJhYTA5 YzIwYzNiZDEzZjBlOGRkNjM5YmU2NC4uYTc3NjBmNDliOTQ4MzY2NzBlYzkwMTY4NDdkM2E5NTJk M2MzMzA4YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuY3BwCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0LmNwcApAQCAtNDAsMjIgKzQwLDM1IEBACiAjaW5j bHVkZSAiSURCSW5kZXguaCIKICNpbmNsdWRlICJJREJFcnJvckV2ZW50LmgiCiAjaW5jbHVkZSAi SURCT2JqZWN0U3RvcmUuaCIKKyNpbmNsdWRlICJJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9y LmgiCiAjaW5jbHVkZSAiSURCU3VjY2Vzc0V2ZW50LmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0 aW9uQ29udGV4dC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLUlEQlJlcXVlc3Q6OklEQlJl cXVlc3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJBbnk+ IHNvdXJjZSkKK0lEQlJlcXVlc3Q6OklEQlJlcXVlc3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgUGFzc1JlZlB0cjxJREJBbnk+IHNvdXJjZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5k SW50ZXJmYWNlKiB0cmFuc2FjdGlvbikKICAgICA6IEFjdGl2ZURPTU9iamVjdChjb250ZXh0LCB0 aGlzKQogICAgICwgbV9zb3VyY2Uoc291cmNlKQorICAgICwgbV90cmFuc2FjdGlvbih0cmFuc2Fj dGlvbikKICAgICAsIG1fdGltZXIodGhpcywgJklEQlJlcXVlc3Q6OnRpbWVyRmlyZWQpCiAgICAg LCBtX2Fib3J0ZWQoZmFsc2UpCiAgICAgLCBtX3JlYWR5U3RhdGUoTE9BRElORykKIHsKKyAgICBp ZiAodHJhbnNhY3Rpb24pCisgICAgICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OnJl bW92ZVBlbmRpbmdUcmFuc2FjdGlvbih0cmFuc2FjdGlvbik7CiB9CiAKIElEQlJlcXVlc3Q6On5J REJSZXF1ZXN0KCkKIHsKKyAgICAvLyBUaGUgdHJhbnNhY3Rpb24gcG9pbnRlciBpcyB1c2VkIHRv IG5vdGlmeSB0aGUgdHJhbnNhY3Rpb24gb25jZSB0aGUgSlMgZXZlbnRzIHdlcmUKKyAgICAvLyBk aXNwYXRjaGVkIGJ5IHRoaXMgcmVxdWVzdCBvYmplY3QuIElmIG5vIG5ldyB0YXNrcyB3ZXJlIGFk ZGVkIGJ5IHRoZSBldmVudCBKUyBjYWxsYmFja3MsCisgICAgLy8gdGhlIHRyYW5zYWN0aW9uIGNh biBjb21taXQuIE90aGVyd2lzZSwgaXQgY2FuIGNvbnRpbnVlIGV4ZWN1dGluZyB0aGUgbmV3IHRh c2tzLgorICAgIC8vIEl0IGlzIGltcG9ydGFudCB0byBndWFyYW50ZWUgdGhhdCB0aGUgdHJhbnNh Y3Rpb24gaXMgbm90aWZpZWQgYWZ0ZXIgdGhlIGV2ZW50cyBhcmUKKyAgICAvLyBkaXNwYXRjaGVk LCBhcyB0aGUgdHJhbnNhY3Rpb24gY2Fubm90IGNvbW1pdCBvciBleGVjdXRlIG5ldyB0YXNrcyBp biB0aGUgYWJzZW5jZQorICAgIC8vIG9mIHRoZXNlIG5vdGlmaWNhdGlvbnMuIFdlIGNsZWFyIHRo ZSB0cmFuc2FjdGlvbiBwb2ludGVyIG9uY2UgdGhlIGV2ZW50cyBoYXZlIGRpc3BhdGNoZWQsCisg ICAgLy8gc28gaGF2aW5nIGEgbm9uLXplcm8gcG9pbnRlciBhdCBJREJSZXF1ZXN0IGRlc3RydWN0 aW9uIHRpbWUgc2hvd3MgdGhhdCB0aGUgZXZlbnRzIGhhdmUgbm90CisgICAgLy8geWV0IGZpcmVk IGFuZCB0aGVyZSBpcyBhIHRyYW5zYWN0aW9uIHdhaXRpbmcgdG8gYmUgbm90aWZpZWQuIFRoaXMg aXMgYW4gZXJyb3IuCisgICAgQVNTRVJUKCFtX3RyYW5zYWN0aW9uKTsKICAgICBhYm9ydCgpOwog fQogCkBAIC0xMDAsNyArMTEzLDkgQEAgdm9pZCBJREJSZXF1ZXN0OjpvblN1Y2Nlc3MoUGFzc1Jl ZlB0cjxJREJLZXk+IGlkYktleSkKIAogdm9pZCBJREJSZXF1ZXN0OjpvblN1Y2Nlc3MoUGFzc1Jl ZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IGJhY2tlbmQpCiB7Ci0gICAgc2No ZWR1bGVFdmVudChJREJBbnk6OmNyZWF0ZShJREJPYmplY3RTdG9yZTo6Y3JlYXRlKGJhY2tlbmQp KSwgMCk7CisgICAgLy8gRklYTUU6IHRoZSB0cmFuc2FjdGlvbiBwb2ludGVyIHNob3VsZCBiZSB0 aGUgb25lIG9mIHRoZSBzZXRWZXJzaW9uIHRyYW5zYWN0aW9uLiBUaGlzIGlzIGJlY2F1c2UKKyAg ICAvLyB0aGlzIGNhbGxiYWNrIGlzIG9ubHkgZXhlY3V0ZWQgZm9yIG9wZXJhdGlvbnMgdGhhdCBu ZWVuIHRvIHJ1biBpbiBhIHNldFZlcnNpb24gdHJhbnNhY3Rpb24uCisgICAgc2NoZWR1bGVFdmVu dChJREJBbnk6OmNyZWF0ZShJREJPYmplY3RTdG9yZTo6Y3JlYXRlKGJhY2tlbmQsIDApKSwgMCk7 CiB9CiAKIHZvaWQgSURCUmVxdWVzdDo6b25TdWNjZXNzKFBhc3NSZWZQdHI8U2VyaWFsaXplZFNj cmlwdFZhbHVlPiBzZXJpYWxpemVkU2NyaXB0VmFsdWUpCkBAIC0xNjEsNiArMTc2LDEzIEBAIHZv aWQgSURCUmVxdWVzdDo6dGltZXJGaXJlZChUaW1lcjxJREJSZXF1ZXN0PiopCiAgICAgICAgICAg ICBkaXNwYXRjaEV2ZW50KElEQlN1Y2Nlc3NFdmVudDo6Y3JlYXRlKG1fc291cmNlLCBwZW5kaW5n RXZlbnRzW2ldLm1fcmVzdWx0KSk7CiAgICAgICAgIH0KICAgICB9CisgICAgaWYgKG1fdHJhbnNh Y3Rpb24pIHsKKyAgICAgICAgLy8gTm93IHRoYXQgd2UgcHJvY2Vzc2VkIGFsbCBwZW5kaW5nIGV2 ZW50cywgbGV0IHRoZSB0cmFuc2FjdGlvbiBtb25pdG9yIGNoZWNrIGlmCisgICAgICAgIC8vIGl0 IGNhbiBjb21taXQgdGhlIGN1cnJlbnQgdHJhbnNhY3Rpb24gb3IgaWYgdGhlcmUncyBhbnl0aGlu ZyBuZXcgcGVuZGluZy4KKyAgICAgICAgLy8gRklYTUU6IEhhbmRsZSB0aGUgd29ya2VycyBjYXNl LgorICAgICAgICBtX3RyYW5zYWN0aW9uLT5kaWRDb21wbGV0ZVRhc2tFdmVudHMoKTsKKyAgICAg ICAgbV90cmFuc2FjdGlvbi5jbGVhcigpOworICAgIH0KIH0KIAogdm9pZCBJREJSZXF1ZXN0Ojpz Y2hlZHVsZUV2ZW50KFBhc3NSZWZQdHI8SURCQW55PiByZXN1bHQsIFBhc3NSZWZQdHI8SURCRGF0 YWJhc2VFcnJvcj4gZXJyb3IpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVz dC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuaAppbmRleCA5YjBlYTdlYWYyMWNiZWEy M2U2YmQ0YTgwNzgxNTJkODkzMzdjN2QyLi5jMDUxNWFhZTI2NjBjNDYzY2E5YTg0MWE3YWM3OTk1 ZDRmZjM4OWU4IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5oCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJSZXF1ZXN0LmgKQEAgLTQyLDkgKzQyLDExIEBACiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAorY2xhc3MgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlOwor CiBjbGFzcyBJREJSZXF1ZXN0IDogcHVibGljIElEQkNhbGxiYWNrcywgcHVibGljIEV2ZW50VGFy Z2V0LCBwdWJsaWMgQWN0aXZlRE9NT2JqZWN0IHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1Jl ZlB0cjxJREJSZXF1ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwg UGFzc1JlZlB0cjxJREJBbnk+IHNvdXJjZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IElEQlJlcXVl c3QoY29udGV4dCwgc291cmNlKSk7IH0KKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJSZXF1ZXN0 PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJB bnk+IHNvdXJjZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbiA9 IDApIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBJREJSZXF1ZXN0KGNvbnRleHQsIHNvdXJjZSwgdHJh bnNhY3Rpb24pKTsgfQogICAgIHZpcnR1YWwgfklEQlJlcXVlc3QoKTsKIAogICAgIC8vIERlZmlu ZWQgaW4gdGhlIElETApAQCAtODAsNyArODIsNyBAQCBwdWJsaWM6CiAgICAgdXNpbmcgUmVmQ291 bnRlZDxJREJDYWxsYmFja3M+OjpkZXJlZjsKIAogcHJpdmF0ZToKLSAgICBJREJSZXF1ZXN0KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlKTsKKyAgICBJ REJSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQkFueT4gc291 cmNlLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKTsKIAogICAg IHZvaWQgdGltZXJGaXJlZChUaW1lcjxJREJSZXF1ZXN0PiopOwogICAgIHZvaWQgc2NoZWR1bGVF dmVudChQYXNzUmVmUHRyPElEQkFueT4gcmVzdWx0LCBQYXNzUmVmUHRyPElEQkRhdGFiYXNlRXJy b3I+KTsKQEAgLTkyLDYgKzk0LDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIEV2ZW50VGFyZ2V0 RGF0YSogZW5zdXJlRXZlbnRUYXJnZXREYXRhKCk7CiAKICAgICBSZWZQdHI8SURCQW55PiBtX3Nv dXJjZTsKKyAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBtX3RyYW5z YWN0aW9uOwogCiAgICAgc3RydWN0IFBlbmRpbmdFdmVudCB7CiAgICAgICAgIFJlZlB0cjxJREJB bnk+IG1fcmVzdWx0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9u LmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbi5jcHAKaW5kZXggNGU5MzM3OGRk YjdiZWIyYjJiODc1MzRiZTY3YjM3NGRkMzM4NDk1OC4uZWQ3NjI4MWY2MjdhNmRkNDcxYzA4NTY5 Nzc1MTZjMjIwMTk5ZDY3OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0 aW9uLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb24uY3BwCkBAIC0zMiw2 ICszMiw3IEBACiAjaW5jbHVkZSAiRXZlbnRFeGNlcHRpb24uaCIKICNpbmNsdWRlICJJREJBYm9y dEV2ZW50LmgiCiAjaW5jbHVkZSAiSURCRGF0YWJhc2UuaCIKKyNpbmNsdWRlICJJREJEYXRhYmFz ZUV4Y2VwdGlvbi5oIgogI2luY2x1ZGUgIklEQk9iamVjdFN0b3JlLmgiCiAjaW5jbHVkZSAiSURC T2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5jbHVkZSAiSURCUGVuZGluZ1RyYW5z YWN0aW9uTW9uaXRvci5oIgpAQCAtNDYsNyArNDcsNyBAQCBJREJUcmFuc2FjdGlvbjo6SURCVHJh bnNhY3Rpb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJU cgogICAgICwgbV9zdG9wcGVkKGZhbHNlKQogICAgICwgbV90aW1lcih0aGlzLCAmSURCVHJhbnNh Y3Rpb246OnRpbWVyRmlyZWQpCiB7Ci0gICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6 YWRkUGVuZGluZ1RyYW5zYWN0aW9uKG1fYmFja2VuZC0+aWQoKSk7CisgICAgSURCUGVuZGluZ1Ry YW5zYWN0aW9uTW9uaXRvcjo6YWRkUGVuZGluZ1RyYW5zYWN0aW9uKG1fYmFja2VuZC5nZXQoKSk7 CiB9CiAKIElEQlRyYW5zYWN0aW9uOjp+SURCVHJhbnNhY3Rpb24oKQpAQCAtNjYsNyArNjcsMTEg QEAgSURCRGF0YWJhc2UqIElEQlRyYW5zYWN0aW9uOjpkYigpCiBQYXNzUmVmUHRyPElEQk9iamVj dFN0b3JlPiBJREJUcmFuc2FjdGlvbjo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBj b25zdCBFeGNlcHRpb25Db2RlJikKIHsKICAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5k SW50ZXJmYWNlPiBvYmplY3RTdG9yZUJhY2tlbmQgPSBtX2JhY2tlbmQtPm9iamVjdFN0b3JlKG5h bWUpOwotICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZT4gb2JqZWN0U3RvcmUgPSBJREJPYmplY3RT dG9yZTo6Y3JlYXRlKG9iamVjdFN0b3JlQmFja2VuZCk7CisgICAgaWYgKCFvYmplY3RTdG9yZUJh Y2tlbmQpIHsKKyAgICAgICAgdGhyb3dFcnJvcihJREJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9UX0FM TE9XRURfRVJSKTsKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorICAgIFJlZlB0cjxJREJPYmpl Y3RTdG9yZT4gb2JqZWN0U3RvcmUgPSBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9iamVjdFN0b3Jl QmFja2VuZCwgbV9iYWNrZW5kLmdldCgpKTsKICAgICByZXR1cm4gb2JqZWN0U3RvcmUucmVsZWFz ZSgpOwogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbC5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5j cHAKaW5kZXggNTFiMzNiMjM0MDAxNDc3ZjNiNjI5ZDRmNTQ4MjIyODAzNGRjODFkMC4uNGYxODQz N2YwYmU0NGVmYzY5MmY2MWE3Y2M4MjA3NmU4Y2I3NDVlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9z dG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFn ZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmNwcApAQCAtMjksMTEgKzI5LDEyIEBACiAjaWYg RU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAKICNpbmNsdWRlICJJREJEYXRhYmFzZUJhY2tlbmRJ bXBsLmgiCisjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1ZGUg IlNRTGl0ZURhdGFiYXNlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6 OmNyZWF0ZShET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUs IHVuc2lnbmVkIGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKiBk YXRhYmFzZSkKK1Bhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4gSURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbDo6Y3JlYXRlKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3JlcywgdW5z aWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBpbnQgaWQsIElEQkRhdGFi YXNlQmFja2VuZEltcGwqIGRhdGFiYXNlKQogewogICAgIHJldHVybiBhZG9wdFJlZihuZXcgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbChvYmplY3RTdG9yZXMsIG1vZGUsIHRpbWVvdXQsIGlkLCBk YXRhYmFzZSkpOwogfQpAQCAtNDMsMjYgKzQ0LDEwNCBAQCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3Jl cwogICAgICwgbV9tb2RlKG1vZGUpCiAgICAgLCBtX3RpbWVvdXQodGltZW91dCkKICAgICAsIG1f aWQoaWQpCi0gICAgLCBtX2Fib3J0ZWQoZmFsc2UpCisgICAgLCBtX3N0YXRlKE5vdFN0YXJ0ZWQp CiAgICAgLCBtX2RhdGFiYXNlKGRhdGFiYXNlKQorICAgICwgbV90cmFuc2FjdGlvbihuZXcgU1FM aXRlVHJhbnNhY3Rpb24oZGF0YWJhc2UtPnNxbGl0ZURhdGFiYXNlKCkpKQorICAgICwgbV90aW1l cih0aGlzLCAmSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZCkKKyAgICAsIG1f cGVuZGluZ0V2ZW50cygwKQogewogfQogCiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2Vu ZEludGVyZmFjZT4gSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6b2JqZWN0U3RvcmUoY29uc3Qg U3RyaW5nJiBuYW1lKQogeworICAgIGlmIChpc0ZpbmlzaGVkKCkpCisgICAgICAgIHJldHVybiAw OwogICAgIHJldHVybiBtX2RhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1lLCAwKTsgLy8gRklYTUU6 IHJlbW92ZSBtb2RlIHBhcmFtLgogfQogCi12b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6 OnNjaGVkdWxlVGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KQor Ym9vbCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpzY2hlZHVsZVRhc2soUGFzc093blB0cjxT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrKQogewotICAgIC8vIEZJWE1FOiBpbXBs ZW1lbnQuCi0gICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgaWYgKGlzRmluaXNoZWQoKSkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgbV90YXNrUXVldWUuYXBwZW5kKHRhc2spOwor ICAgIGlmIChtX3N0YXRlID09IE5vdFN0YXJ0ZWQpCisgICAgICAgIHN0YXJ0KCk7CisKKyAgICBy ZXR1cm4gdHJ1ZTsKIH0KIAogdm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjphYm9ydCgp CiB7Ci0gICAgbV9hYm9ydGVkID0gdHJ1ZTsKKyAgICBpZiAoaXNGaW5pc2hlZCgpKQorICAgICAg ICByZXR1cm47CisKKyAgICBtX3N0YXRlID0gRmluaXNoZWQ7CisgICAgbV90cmFuc2FjdGlvbi0+ cm9sbGJhY2soKTsKICAgICBtX2NhbGxiYWNrcy0+b25BYm9ydCgpOworICAgIG1fZGF0YWJhc2Ut PnRyYW5zYWN0aW9uQ29vcmRpbmF0b3IoKS0+ZGlkRmluaXNoVHJhbnNhY3Rpb24odGhpcyk7Cit9 CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6ZGlkQ29tcGxldGVUYXNrRXZlbnRz KCkKK3sKKyAgICBBU1NFUlQobV9zdGF0ZSA9PSBTdGFydGVkKTsKKyAgICBBU1NFUlQobV9wZW5k aW5nRXZlbnRzKTsKKworICAgIG1fcGVuZGluZ0V2ZW50cy0tOworCisgICAgaWYgKCFtX3BlbmRp bmdFdmVudHMgJiYgbV90YXNrUXVldWUuaXNFbXB0eSgpKSB7CisgICAgICAgIC8vIFRoZSBsYXN0 IHRhc2sgZXZlbnQgaGFzIGNvbXBsZXRlZCBhbmQgdGhlIHRhc2sKKyAgICAgICAgLy8gcXVldWUg aXMgZW1wdHkuIENvbW1pdCB0aGUgdHJhbnNhY3Rpb24uCisgICAgICAgIGNvbW1pdCgpOworICAg ICAgICByZXR1cm47CisgICAgfQorCisgICAgLy8gV2UgYXJlIHN0aWxsIHdhaXRpbmcgZm9yIG90 aGVyIGV2ZW50cyB0byBjb21wbGV0ZS4gSG93ZXZlciwKKyAgICAvLyB0aGUgdGFzayBxdWV1ZSBp cyBub24tZW1wdHkgYW5kIHRoZSB0aW1lciBpcyBpbmFjdGl2ZS4KKyAgICAvLyBXZSBjYW4gdGhl cmZvcmUgc2NoZWR1bGUgdGhlIHRpbWVyIGFnYWluLgorICAgIGlmICghbV90YXNrUXVldWUuaXNF bXB0eSgpICYmICFtX3RpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVT aG90KDApOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnJ1bigpCit7Cisg ICAgQVNTRVJUKG1fc3RhdGUgPT0gU3RhcnRlZCk7CisgICAgQVNTRVJUKCFtX3RpbWVyLmlzQWN0 aXZlKCkpOworCisgICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgSURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbDo6c3RhcnQoKQoreworICAgIEFTU0VSVChtX3N0YXRlID09IE5v dFN0YXJ0ZWQpOworCisgICAgbV9zdGF0ZSA9IFN0YXJ0ZWQ7CisgICAgbV90cmFuc2FjdGlvbi0+ YmVnaW4oKTsKKyAgICBtX2RhdGFiYXNlLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCktPmRpZFN0 YXJ0VHJhbnNhY3Rpb24odGhpcyk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1w bDo6Y29tbWl0KCkKK3sKKyAgICBBU1NFUlQobV9zdGF0ZSA9PSBTdGFydGVkKTsKKworICAgIG1f c3RhdGUgPSBGaW5pc2hlZDsKKyAgICBtX3RyYW5zYWN0aW9uLT5jb21taXQoKTsKKyAgICBtX2Rh dGFiYXNlLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCktPmRpZEZpbmlzaFRyYW5zYWN0aW9uKHRo aXMpOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnRpbWVyRmlyZWQoVGlt ZXI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4qKQoreworICAgIEFTU0VSVCghbV90YXNrUXVl dWUuaXNFbXB0eSgpKTsKKyAgICBBU1NFUlQobV9zdGF0ZSA9PSBTdGFydGVkKTsKKworICAgIFRh c2tRdWV1ZSBxdWV1ZTsKKyAgICBxdWV1ZS5zd2FwKG1fdGFza1F1ZXVlKTsKKyAgICB3aGlsZSAo IXF1ZXVlLmlzRW1wdHkoKSkgeworICAgICAgICBPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4 dDo6VGFzaz4gdGFzayhxdWV1ZS5maXJzdCgpLnJlbGVhc2UoKSk7CisgICAgICAgIHF1ZXVlLnJl bW92ZUZpcnN0KCk7CisgICAgICAgIG1fcGVuZGluZ0V2ZW50cysrOworICAgICAgICB0YXNrLT5w ZXJmb3JtVGFzaygwKTsKKyAgICB9CiB9CiAKIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3Jh Z2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5z YWN0aW9uQmFja2VuZEltcGwuaAppbmRleCBmYjU3NDAxN2ZhYmU1MjQzZWI1ZDdjMTdhODJiMGEy NWU2MjhlMDg3Li42ZDlhM2FjNTJiNzY4YTc2ZTFhOThiNDUzZWM5OThhYWY4YjY2NzFmIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmgKQEAgLTMxLDYgKzMx LDggQEAKICNpbmNsdWRlICJET01TdHJpbmdMaXN0LmgiCiAjaW5jbHVkZSAiSURCVHJhbnNhY3Rp b25CYWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25DYWxsYmFja3Mu aCIKKyNpbmNsdWRlIDxTUUxpdGVUcmFuc2FjdGlvbi5oPgorI2luY2x1ZGUgPHd0Zi9EZXF1ZS5o PgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzks MjYgKzQxLDUxIEBAIGNsYXNzIElEQkRhdGFiYXNlQmFja2VuZEltcGw7CiAKIGNsYXNzIElEQlRy YW5zYWN0aW9uQmFja2VuZEltcGwgOiBwdWJsaWMgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJm YWNlIHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tl bmRJbnRlcmZhY2U+IGNyZWF0ZShET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVk IHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJh Y2tlbmRJbXBsKik7Ci0gICAgdmlydHVhbCB+SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCgpIHsg fQorICAgIHN0YXRpYyBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw+IGNyZWF0 ZShET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2ln bmVkIGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKik7CisgICAg dmlydHVhbCB+SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCgpIHsgYWJvcnQoKTsgfQogCiAgICAg dmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0 U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKTsKICAgICB2aXJ0dWFsIHVuc2lnbmVkIHNob3J0IG1v ZGUoKSBjb25zdCB7IHJldHVybiBtX21vZGU7IH0KLSAgICB2aXJ0dWFsIHZvaWQgc2NoZWR1bGVU YXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOworICAgIHZpcnR1 YWwgYm9vbCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpU YXNrPik7CisgICAgdmlydHVhbCB2b2lkIGRpZENvbXBsZXRlVGFza0V2ZW50cygpOwogICAgIHZp cnR1YWwgdm9pZCBhYm9ydCgpOwogICAgIHZpcnR1YWwgaW50IGlkKCkgY29uc3QgeyByZXR1cm4g bV9pZDsgfQogICAgIHZpcnR1YWwgdm9pZCBzZXRDYWxsYmFja3MoSURCVHJhbnNhY3Rpb25DYWxs YmFja3MqIGNhbGxiYWNrcykgeyBtX2NhbGxiYWNrcyA9IGNhbGxiYWNrczsgfQogCisgICAgdm9p ZCBydW4oKTsKKyAgICBib29sIGlzRmluaXNoZWQoKSBjb25zdCB7IHJldHVybiBtX3N0YXRlID09 IEZpbmlzaGVkOyB9CisKIHByaXZhdGU6CiAgICAgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbChE T01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVk IGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKik7CiAKKyAgICBl bnVtIFN0YXRlIHsKKyAgICAgICAgTm90U3RhcnRlZCwKKyAgICAgICAgU3RhcnRlZCwKKyAgICAg ICAgRmluaXNoZWQsCisgICAgfTsKKworICAgIHZvaWQgc3RhcnQoKTsKKyAgICB2b2lkIGNvbW1p dCgpOworCisgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPElEQlRyYW5zYWN0aW9uQmFja2VuZElt cGw+Kik7CisKICAgICBSZWZQdHI8RE9NU3RyaW5nTGlzdD4gbV9vYmplY3RTdG9yZU5hbWVzOwog ICAgIHVuc2lnbmVkIHNob3J0IG1fbW9kZTsKICAgICB1bnNpZ25lZCBsb25nIG1fdGltZW91dDsK ICAgICBpbnQgbV9pZDsKLSAgICBib29sIG1fYWJvcnRlZDsKKworICAgIFN0YXRlIG1fc3RhdGU7 CiAgICAgUmVmUHRyPElEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzPiBtX2NhbGxiYWNrczsKICAgICBS ZWZQdHI8SURCRGF0YWJhc2VCYWNrZW5kSW1wbD4gbV9kYXRhYmFzZTsKKworICAgIHR5cGVkZWYg RGVxdWU8T3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+ID4gVGFza1F1ZXVlOwor ICAgIFRhc2tRdWV1ZSBtX3Rhc2tRdWV1ZTsKKworICAgIE93blB0cjxTUUxpdGVUcmFuc2FjdGlv bj4gbV90cmFuc2FjdGlvbjsKKworICAgIC8vIEZJWE1FOiBkZWxldGUgdGhlIHRpbWVyIG9uY2Ug d2UgaGF2ZSB0aHJlYWRzIGluc3RlYWQuCisgICAgVGltZXI8SURCVHJhbnNhY3Rpb25CYWNrZW5k SW1wbD4gbV90aW1lcjsKKyAgICBpbnQgbV9wZW5kaW5nRXZlbnRzOwogfTsKIAogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9u QmFja2VuZEludGVyZmFjZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZS5oCmluZGV4IDM5NjUxZjEwMTc1ZGU3MDYwZDA0NWE5ZjBjNjIzOTNjNmFlMzc1 ZGMuLmRiOTVkMDM4MmZiNzc4NjhhMTg0ZDk4ZTE0ZTEzZGQzYTU3ZmZkZTggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTUwLDcg KzUwLDggQEAgcHVibGljOgogCiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3Jl QmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKSA9IDA7CiAg ICAgdmlydHVhbCB1bnNpZ25lZCBzaG9ydCBtb2RlKCkgY29uc3QgPSAwOwotICAgIHZpcnR1YWwg dm9pZCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNr PikgPSAwOworICAgIHZpcnR1YWwgYm9vbCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRF eGVjdXRpb25Db250ZXh0OjpUYXNrPikgPSAwOworICAgIHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0 ZVRhc2tFdmVudHMoKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0KCkgPSAwOwogICAgIHZp cnR1YWwgaW50IGlkKCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBzZXRDYWxsYmFja3Mo SURCVHJhbnNhY3Rpb25DYWxsYmFja3MqKSA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3Jh Z2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJh bnNhY3Rpb25Db29yZGluYXRvci5jcHAKaW5kZXggOTc5MGMxZjJkNzk1ZjY2MDZkNjE0YjQwM2I0 M2YzNjJmYmYxYjBlYy4uZTliMzA5Njc0NDg2YWI4NWRkYTFjZDE1M2FhMmZjYjAwNThjNDNkNSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3Bw CisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcApAQCAt NDcsMjEgKzQ3LDUyIEBAIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6On5JREJUcmFuc2FjdGlv bkNvb3JkaW5hdG9yKCkKIAogUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZh Y2U+IElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmNyZWF0ZVRyYW5zYWN0aW9uKERPTVN0cmlu Z0xpc3QqIG9iamVjdFN0b3JlcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0 aW1lb3V0LCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKiBkYXRhYmFzZSkKIHsKLSAgICBSZWZQdHI8 SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiB0cmFuc2FjdGlvbiA9IElEQlRyYW5zYWN0 aW9uQmFja2VuZEltcGw6OmNyZWF0ZShvYmplY3RTdG9yZXMsIG1vZGUsIHRpbWVvdXQsICsrbV9u ZXh0SUQsIGRhdGFiYXNlKTsKLSAgICBtX3RyYW5zYWN0aW9uUXVldWUuYWRkKHRyYW5zYWN0aW9u LmdldCgpKTsKLSAgICBtX2lkTWFwLmFkZChtX25leHRJRCwgdHJhbnNhY3Rpb24pOworICAgIFJl ZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsPiB0cmFuc2FjdGlvbiA9IElEQlRyYW5zYWN0 aW9uQmFja2VuZEltcGw6OmNyZWF0ZShvYmplY3RTdG9yZXMsIG1vZGUsIHRpbWVvdXQsICsrbV9u ZXh0SUQsIGRhdGFiYXNlKTsKKyAgICBtX3RyYW5zYWN0aW9ucy5hZGQobV9uZXh0SUQsIHRyYW5z YWN0aW9uKTsKKyAgICBtX3BlbmRpbmdUcmFuc2FjdGlvbnMuYWRkKHRyYW5zYWN0aW9uLmdldCgp KTsKICAgICByZXR1cm4gdHJhbnNhY3Rpb24ucmVsZWFzZSgpOwogfQogCi12b2lkIElEQlRyYW5z YWN0aW9uQ29vcmRpbmF0b3I6OmFib3J0KGludCBpZCkKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29y ZGluYXRvcjo6ZGlkU3RhcnRUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKiB0 cmFuc2FjdGlvbikKIHsKLSAgICBBU1NFUlQobV9pZE1hcC5jb250YWlucyhpZCkpOwotICAgIFJl ZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uID0gbV9pZE1h cC5nZXQoaWQpOwotICAgIEFTU0VSVCh0cmFuc2FjdGlvbik7Ci0gICAgbV90cmFuc2FjdGlvblF1 ZXVlLnJlbW92ZSh0cmFuc2FjdGlvbi5nZXQoKSk7Ci0gICAgbV9pZE1hcC5yZW1vdmUoaWQpOwot ICAgIHRyYW5zYWN0aW9uLT5hYm9ydCgpOwotICAgIC8vIEZJWE1FOiB0aGlzIHdpbGwgY2hhbmdl IG9uY2Ugd2UgaGF2ZSB0cmFuc2FjdGlvbnMgYWN0dWFsbHkgcnVubmluZy4KKyAgICBBU1NFUlQo bV9wZW5kaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKHRyYW5zYWN0aW9uKSk7CisgICAgbV9wZW5k aW5nVHJhbnNhY3Rpb25zLnJlbW92ZSh0cmFuc2FjdGlvbik7CisgICAgbV9zdGFydGVkVHJhbnNh Y3Rpb25zLmFkZCh0cmFuc2FjdGlvbik7CisKKyAgICBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9u cygpOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZEZpbmlzaFRyYW5z YWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqIHRyYW5zYWN0aW9uKQoreworICAgIEFT U0VSVChtX3RyYW5zYWN0aW9ucy5jb250YWlucyh0cmFuc2FjdGlvbi0+aWQoKSkpOworCisgICAg aWYgKG1fcGVuZGluZ1RyYW5zYWN0aW9ucy5jb250YWlucyh0cmFuc2FjdGlvbikpIHsKKyAgICAg ICAgQVNTRVJUKCFtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNhY3Rpb24pKTsK KyAgICAgICAgQVNTRVJUKCFtX3J1bm5pbmdUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNhY3Rp b24pKTsKKyAgICAgICAgbV9wZW5kaW5nVHJhbnNhY3Rpb25zLnJlbW92ZSh0cmFuc2FjdGlvbik7 CisgICAgfSBlbHNlIGlmIChtX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNhY3Rp b24pKSB7CisgICAgICAgIEFTU0VSVCghbV9ydW5uaW5nVHJhbnNhY3Rpb25zLmNvbnRhaW5zKHRy YW5zYWN0aW9uKSk7CisgICAgICAgIG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5yZW1vdmUodHJhbnNh Y3Rpb24pOworICAgIH0gZWxzZSB7CisgICAgICAgIEFTU0VSVChtX3J1bm5pbmdUcmFuc2FjdGlv bnMuY29udGFpbnModHJhbnNhY3Rpb24pKTsKKyAgICAgICAgbV9ydW5uaW5nVHJhbnNhY3Rpb25z LnJlbW92ZSh0cmFuc2FjdGlvbik7CisgICAgfQorICAgIG1fdHJhbnNhY3Rpb25zLnJlbW92ZSh0 cmFuc2FjdGlvbi0+aWQoKSk7CisKKyAgICBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucygpOwor fQorCit2b2lkIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OnByb2Nlc3NTdGFydGVkVHJhbnNh Y3Rpb25zKCkKK3sKKyAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgYWxsb2NhdGUgYSB0aHJlYWQg dG8gdGhlIG5leHQgdHJhbnNhY3Rpb24gdGhhdCdzCisgICAgLy8gcmVhZHkgdG8gcnVuLiBGb3Ig bm93IHdlIG9ubHkgaGF2ZSBhIHNpbmdsZSBydW5uaW5nIHRyYW5zYWN0aW9uLgorICAgIGlmICht X3N0YXJ0ZWRUcmFuc2FjdGlvbnMuaXNFbXB0eSgpIHx8ICFtX3J1bm5pbmdUcmFuc2FjdGlvbnMu aXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bXBsKiB0cmFuc2FjdGlvbiA9ICptX3N0YXJ0ZWRUcmFuc2FjdGlvbnMuYmVnaW4oKTsKKyAgICBt X3N0YXJ0ZWRUcmFuc2FjdGlvbnMucmVtb3ZlKHRyYW5zYWN0aW9uKTsKKyAgICBtX3J1bm5pbmdU cmFuc2FjdGlvbnMuYWRkKHRyYW5zYWN0aW9uKTsKKyAgICB0cmFuc2FjdGlvbi0+cnVuKCk7CiB9 CiAKIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGlu YXRvci5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuaAppbmRl eCAxMDRhOTU2NmNlY2VkYzMyYWU2YzA1MmFjNzc3NzU0YTYyMTE4MjNkLi42ZTkwODQ5YjcwODhl MGNkMjFlYzcwYjg3MGZlZTZlMzIxOTZmNzA5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2Uv SURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFu c2FjdGlvbkNvb3JkaW5hdG9yLmgKQEAgLTM1LDYgKzM1LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCitjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOwogY2xhc3MgSURCVHJhbnNh Y3Rpb25DYWxsYmFja3M7CiBjbGFzcyBJREJEYXRhYmFzZUJhY2tlbmRJbXBsOwogCkBAIC01NSwx NCArNTYsMjIgQEAgcHVibGljOgogICAgIHZpcnR1YWwgfklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0 b3IoKTsKIAogICAgIFBhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBj cmVhdGVUcmFuc2FjdGlvbihET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNo b3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91dCwgSURCRGF0YWJhc2VCYWNrZW5kSW1wbCop OwotICAgIHZvaWQgYWJvcnQoaW50IHRyYW5zYWN0aW9uSWQpOworCisgICAgLy8gQ2FsbGVkIGJ5 IHRyYW5zYWN0aW9ucyBhcyB0aGV5IHN0YXJ0IGFuZCBmaW5pc2guCisgICAgdm9pZCBkaWRTdGFy dFRyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqKTsKKyAgICB2b2lkIGRpZEZp bmlzaFRyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqKTsKIAogcHJpdmF0ZToK ICAgICBJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yKCk7CiAKLSAgICBMaXN0SGFzaFNldDxJREJU cmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqPiBtX3RyYW5zYWN0aW9uUXVldWU7Ci0gICAgdHlw ZWRlZiBIYXNoTWFwPGludCwgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4g PiBJZFRvVHJhbnNhY3Rpb25NYXA7Ci0gICAgSWRUb1RyYW5zYWN0aW9uTWFwIG1faWRNYXA7Cisg ICAgdm9pZCBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9ucygpOworCisgICAgLy8gVGhpcyBtYXAg b3ducyBhbGwgdHJhbnNhY3Rpb25zIGtub3duIHRvIHRoZSBjb29yZGluYXRvci4KKyAgICBIYXNo TWFwPGludCwgUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw+ID4gbV90cmFuc2FjdGlv bnM7CisgICAgLy8gVHJhbnNhY3Rpb25zIGluIGRpZmZlcmVudCBzdGF0ZXMgYXJlIGdyb3VwZWQg YmVsb3cuCisgICAgSGFzaFNldDxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKj4gbV9wZW5kaW5n VHJhbnNhY3Rpb25zOworICAgIExpc3RIYXNoU2V0PElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwq ID4gbV9zdGFydGVkVHJhbnNhY3Rpb25zOworICAgIEhhc2hTZXQ8SURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbCogPiBtX3J1bm5pbmdUcmFuc2FjdGlvbnM7CiAgICAgaW50IG1fbmV4dElEOwogfTsK IApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKaW5kZXggNDdiMGU2M2QwODBiNzFiMTI2NDg4MzhlMmUwNjExNDJiN2Y1Y2Rl Yy4uYjQxMGI1NjUyMmM1ZTQxZjBmY2M1YjVhZTdjZWViYmRjZjQ4NjM5OSAxMDA2NDQKLS0tIGEv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMzcgQEAKKzIwMTAtMDktMjIgIEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBn b29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIElEQk9iamVjdFN0b3JlOjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAg ICAgICAqIHB1YmxpYy9XZWJJREJGYWN0b3J5Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYklEQkZh Y3Rvcnk6Om9wZW4pOgorICAgICAgICAqIHB1YmxpYy9XZWJJREJPYmplY3RTdG9yZS5oOgorICAg ICAgICAoV2ViS2l0OjpXZWJJREJPYmplY3RTdG9yZTo6Z2V0KToKKyAgICAgICAgKiBwdWJsaWMv V2ViSURCVHJhbnNhY3Rpb24uaDoKKyAgICAgICAgKFdlYktpdDo6V2ViSURCVHJhbnNhY3Rpb246 OmRpZENvbXBsZXRlVGFza0V2ZW50cyk6CisgICAgICAgICogc3JjL0lEQkRhdGFiYXNlUHJveHku aDoKKyAgICAgICAgKiBzcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5jcHA6CisgICAgICAgICog c3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaDoKKyAgICAgICAgKiBzcmMvSURCT2JqZWN0U3Rv cmVQcm94eS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJPYmplY3RTdG9yZVByb3h5OjpnZXQp OgorICAgICAgICAqIHNyYy9JREJPYmplY3RTdG9yZVByb3h5Lmg6CisgICAgICAgICogc3JjL0lE QlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5z YWN0aW9uQmFja2VuZFByb3h5OjpzY2hlZHVsZVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6SURC VHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OmRpZENvbXBsZXRlVGFza0V2ZW50cyk6CisgICAgICAg ICogc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5Lmg6CisgICAgICAgIChXZWJDb3JlOjpJ REJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6Z2V0V2ViSURCVHJhbnNhY3Rpb24pOgorICAgICAg ICAqIHNyYy9XZWJJREJGYWN0b3J5SW1wbC5jcHA6CisgICAgICAgICogc3JjL1dlYklEQkZhY3Rv cnlJbXBsLmg6CisgICAgICAgICogc3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5jcHA6CisgICAg ICAgIChXZWJLaXQ6OldlYklEQk9iamVjdFN0b3JlSW1wbDo6Z2V0KToKKyAgICAgICAgKiBzcmMv V2ViSURCT2JqZWN0U3RvcmVJbXBsLmg6CisgICAgICAgICogc3JjL1dlYklEQlRyYW5zYWN0aW9u SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYklEQlRyYW5zYWN0aW9uSW1wbDo6ZGlkQ29t cGxldGVUYXNrRXZlbnRzKToKKyAgICAgICAgKFdlYktpdDo6V2ViSURCVHJhbnNhY3Rpb25JbXBs OjpnZXRJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UpOgorICAgICAgICAqIHNyYy9XZWJJ REJUcmFuc2FjdGlvbkltcGwuaDoKKwogMjAxMC0wOS0xOSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQu cmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQg cjY3NzQ5LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJGYWN0b3J5 LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQkZhY3RvcnkuaAppbmRleCBhYjA1YjA2 NGQ2ZTk0ZjI4YzBmODYyOTRlMzk5ZWU1ZDk1OWY1ZjFlLi5iNzM2YTdmOTAwZjY3NDY3MTk3ZThh YjhkNjIzYjg4YjM3NDJjMmQ2IDEwMDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YklEQkZhY3RvcnkuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQkZhY3Rvcnku aApAQCAtNjEsOCArNjEsNiBAQCBwdWJsaWM6CiAgICAgewogICAgICAgICBvcGVuKG5hbWUsIGRl c2NyaXB0aW9uLCBjYWxsYmFja3MsIG9yaWdpbiwgd2ViRnJhbWUsICIvdG1wL3RlbXBvcmFyeS1p bmRleGVkLWRiLWZpbGVzIik7CiAgICAgfQotCi0gICAgdmlydHVhbCB2b2lkIGFib3J0UGVuZGlu Z1RyYW5zYWN0aW9ucyhjb25zdCBXZWJWZWN0b3I8aW50PiYgcGVuZGluZ0lEcykgeyBXRUJLSVRf QVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZm IC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJPYmplY3RTdG9yZS5oIGIvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJPYmplY3RTdG9yZS5oCmluZGV4IDc0NTJiZTk5YjQw YzBiZDIyNjk1MDQyNzEwYzlkYThiZjliMjA5ZDAuLmZmNTdkM2Y2ODg5YmY3MmVkMjMxOTQ5YjM0 ZjdmNzFjNjUzNDBjMjcgMTAwNzU1Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURC T2JqZWN0U3RvcmUuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQk9iamVjdFN0 b3JlLmgKQEAgLTM0LDYgKzM0LDcgQEAKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBXZWJJ REJLZXlSYW5nZTsKK2NsYXNzIFdlYklEQlRyYW5zYWN0aW9uOwogCiAvLyBTZWUgY29tbWVudCBp biBXZWJJbmRleGVkRGF0YWJhc2UgZm9yIGEgaGlnaCBsZXZlbCBvdmVydmlldyB0aGVzZSBjbGFz c2VzLgogY2xhc3MgV2ViSURCT2JqZWN0U3RvcmUgewpAQCAtNTUsNyArNTYsNyBAQCBwdWJsaWM6 CiAgICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgcmV0dXJuIFdl YkRPTVN0cmluZ0xpc3QoKTsKICAgICB9Ci0gICAgdmlydHVhbCB2b2lkIGdldChjb25zdCBXZWJJ REJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tzKikKKyAgICB2aXJ0dWFsIHZvaWQgZ2V0KGNvbnN0 IFdlYklEQktleSYga2V5LCBXZWJJREJDYWxsYmFja3MqLCBjb25zdCBXZWJJREJUcmFuc2FjdGlv biYpCiAgICAgewogICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgfQpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJUcmFuc2FjdGlvbi5oIGIv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJUcmFuc2FjdGlvbi5oCmluZGV4IDAzNjliODk5 YjU2OTEzYmQ2ZDE3OTY3NGYyMGIyZjA4YzBlYTUyMWMuLjM3ZDFkYTllYjRiY2YyM2MyYzc1Mzlh ZWQ3YjE3ZTQ5OTdiMWJkN2EgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi SURCVHJhbnNhY3Rpb24uaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQlRyYW5z YWN0aW9uLmgKQEAgLTI4LDYgKzI4LDggQEAKIAogI2luY2x1ZGUgIldlYlN0cmluZy5oIgogCitu YW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZTsg fQorCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViSURCT2JqZWN0U3RvcmU7CkBAIC00 OSwxMiArNTEsMTggQEAgcHVibGljOgogICAgICAgICByZXR1cm4gMDsKICAgICB9CiAgICAgdmly dHVhbCB2b2lkIGFib3J0KCkgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKyAgICB2 aXJ0dWFsIHZvaWQgZGlkQ29tcGxldGVUYXNrRXZlbnRzKCkgeyBXRUJLSVRfQVNTRVJUX05PVF9S RUFDSEVEKCk7IH0KICAgICB2aXJ0dWFsIGludCBpZCgpIGNvbnN0CiAgICAgewogICAgICAgICBX RUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KICAg ICB2aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKFdlYklEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzKikg eyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KKworI2lmIFdFQktJVF9JTVBMRU1FTlRB VElPTgorICAgIHZpcnR1YWwgV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNl KiBnZXRJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UoKSBjb25zdCA9IDA7CisjZW5kaWYK KwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21p dW0vc3JjL0lEQkRhdGFiYXNlUHJveHkuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJh c2VQcm94eS5oCmluZGV4IDQyYTdkN2VjNTZhMjYyODIxODBkNzZjODNmMjM2ZDE4N2ZlNDQ3N2Mu LmZmZmQyM2VlODUyYTYxMzZjNDFhNWNlYmUwYTA4ZGM0ZGRhZjY1YWIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJhc2VQcm94eS5oCisrKyBiL1dlYktpdC9jaHJvbWl1 bS9zcmMvSURCRGF0YWJhc2VQcm94eS5oCkBAIC00Nyw3ICs0Nyw3IEBAIHB1YmxpYzoKICAgICB2 aXJ0dWFsIFN0cmluZyB2ZXJzaW9uKCkgY29uc3Q7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPERP TVN0cmluZ0xpc3Q+IG9iamVjdFN0b3JlcygpIGNvbnN0OwogCi0gICAgLy8gRklYTUU6IEFkZCB0 cmFuc2FjdGlvbiBhbmQgc2V0VmVyc2lvbi4KKyAgICAvLyBGSVhNRTogQWRkIHNldFZlcnNpb24u CiAKICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1l LCBjb25zdCBTdHJpbmcmIGtleVBhdGgsIGJvb2wgYXV0b0luY3JlbWVudCwgUGFzc1JlZlB0cjxJ REJDYWxsYmFja3M+KTsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNr ZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNo b3J0IG1vZGUpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJGYWN0b3J5QmFj a2VuZFByb3h5LmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94 eS5jcHAKaW5kZXggMTgxMDFlNDg5MzM1MDJkZTA2MjQ5NmVkNjAxZjhlMmRiMDBhMTA4Mi4uZDQz ZTc4N2YyZDU5NmZiZTc0ZWNmYzkyNTNjNDZlNGQ1N2RkZjc3ZCAxMDA3NTUKLS0tIGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9JREJGYWN0b3J5QmFja2VuZFByb3h5LmNwcAorKysgYi9XZWJLaXQvY2hy b21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuY3BwCkBAIC02NSwxNCArNjUsNiBAQCB2 b2lkIElEQkZhY3RvcnlCYWNrZW5kUHJveHk6Om9wZW4oY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIGRlc2NyaXB0aW9uLAogICAgIG1fd2ViSURCRmFjdG9yeS0+b3BlbihuYW1lLCBk ZXNjcmlwdGlvbiwgbmV3IFdlYklEQkNhbGxiYWNrc0ltcGwoY2FsbGJhY2tzKSwgb3JpZ2luLCB3 ZWJGcmFtZSwgZGF0YURpcik7CiB9CiAKLXZvaWQgSURCRmFjdG9yeUJhY2tlbmRQcm94eTo6YWJv cnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFZlY3RvcjxpbnQ+JiBwZW5kaW5nSURzKQotewot ICAgIEFTU0VSVChwZW5kaW5nSURzLnNpemUoKSk7Ci0gICAgV2ViS2l0OjpXZWJWZWN0b3I8aW50 PiBpZHMgPSBwZW5kaW5nSURzOwotCi0gICAgbV93ZWJJREJGYWN0b3J5LT5hYm9ydFBlbmRpbmdU cmFuc2FjdGlvbnMoaWRzKTsKLX0KLQogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYg Ly8gRU5BQkxFKElOREVYRURfREFUQUJBU0UpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v c3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFj dG9yeUJhY2tlbmRQcm94eS5oCmluZGV4IGFjMzBjZjJmODNiNjJiOTNjNDdmYTE4ZDg4MTk5YTY0 MjY1ODdhZGYuLjYzNzE2ODZjZWFmZjA2OWI4NGE0NTM1N2E5MDNkYjZlZjY4Yjk3OTAgMTAwNzU1 Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5oCisrKyBi L1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5oCkBAIC00Niw3ICs0 Niw2IEBAIHB1YmxpYzoKIAogICAgIFBhc3NSZWZQdHI8RE9NU3RyaW5nTGlzdD4gZGF0YWJhc2Vz KHZvaWQpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBvcGVuKGNvbnN0IFN0cmluZyYgbmFtZSwg Y29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+LCBQYXNz UmVmUHRyPFNlY3VyaXR5T3JpZ2luPiwgRnJhbWUqLCBjb25zdCBTdHJpbmcmIGRhdGFEaXIpOwot ICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGlu dD4mIHBlbmRpbmdJRHMpOwogCiBwcml2YXRlOgogICAgIElEQkZhY3RvcnlCYWNrZW5kUHJveHko KTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5j cHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuY3BwCmluZGV4IGFk MjdmYTM0MWM1YmM3Yzg5YzdkMDhhMjdiNTVkMTgzMjhkZjJiMDIuLjgyY2E1ZjY2Y2YwOTdmYzM5 MDg2ZGJlNjQzZTYzZGFiNmZmOGZjZmQgMTAwNzU1Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMv SURCT2JqZWN0U3RvcmVQcm94eS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmpl Y3RTdG9yZVByb3h5LmNwcApAQCAtMzAsMTEgKzMwLDEzIEBACiAjaW5jbHVkZSAiSURCQ2FsbGJh Y2tzLmgiCiAjaW5jbHVkZSAiSURCSW5kZXhCYWNrZW5kUHJveHkuaCIKICNpbmNsdWRlICJJREJL ZXlSYW5nZS5oIgorI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmgiCiAjaW5j bHVkZSAiV2ViSURCQ2FsbGJhY2tzSW1wbC5oIgogI2luY2x1ZGUgIldlYklEQktleVJhbmdlLmgi CiAjaW5jbHVkZSAiV2ViSURCSW5kZXguaCIKICNpbmNsdWRlICJXZWJJREJLZXkuaCIKICNpbmNs dWRlICJXZWJJREJPYmplY3RTdG9yZS5oIgorI2luY2x1ZGUgIldlYklEQlRyYW5zYWN0aW9uSW1w bC5oIgogI2luY2x1ZGUgIldlYlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgogCiAjaWYgRU5BQkxF KElOREVYRURfREFUQUJBU0UpCkBAIC03MCw5ICs3MiwxMiBAQCBQYXNzUmVmUHRyPERPTVN0cmlu Z0xpc3Q+IElEQk9iamVjdFN0b3JlUHJveHk6OmluZGV4TmFtZXMoKSBjb25zdAogICAgIHJldHVy biBtX3dlYklEQk9iamVjdFN0b3JlLT5pbmRleE5hbWVzKCk7CiB9CiAKLXZvaWQgSURCT2JqZWN0 U3RvcmVQcm94eTo6Z2V0KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2Fs bGJhY2tzPiBjYWxsYmFja3MpCit2b2lkIElEQk9iamVjdFN0b3JlUHJveHk6OmdldChQYXNzUmVm UHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4gY2FsbGJhY2tzLCBJREJU cmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKQogewotICAgIG1fd2ViSURC T2JqZWN0U3RvcmUtPmdldChrZXksIG5ldyBXZWJJREJDYWxsYmFja3NJbXBsKGNhbGxiYWNrcykp OworICAgIC8vIFRoZSB0cmFuc2FjdGlvbiBwb2ludGVyIGlzIGd1YXJhbnRlZWQgdG8gYmUgYSBw b2ludGVyIHRvIGEgcHJveHkgb2JqZWN0IGFzLCBpbiB0aGUgcmVuZGVyZXIsCisgICAgLy8gYWxs IGltcGxlbWVudGF0aW9ucyBvZiBJREIgaW50ZXJmYWNlcyBhcmUgcHJveHkgb2JqZWN0cy4KKyAg ICBJREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eSogdHJhbnNhY3Rpb25Qcm94eSA9IHN0YXRpY19j YXN0PElEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5Kj4odHJhbnNhY3Rpb24pOworICAgIG1fd2Vi SURCT2JqZWN0U3RvcmUtPmdldChrZXksIG5ldyBXZWJJREJDYWxsYmFja3NJbXBsKGNhbGxiYWNr cyksICp0cmFuc2FjdGlvblByb3h5LT5nZXRXZWJJREJUcmFuc2FjdGlvbigpKTsKIH0KIAogdm9p ZCBJREJPYmplY3RTdG9yZVByb3h5OjpwdXQoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFs dWU+IHZhbHVlLCBQYXNzUmVmUHRyPElEQktleT4ga2V5LCBib29sIGFkZE9ubHksIFBhc3NSZWZQ dHI8SURCQ2FsbGJhY2tzPiBjYWxsYmFja3MpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v c3JjL0lEQk9iamVjdFN0b3JlUHJveHkuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0 U3RvcmVQcm94eS5oCmluZGV4IGEzMzQ1NzJiNmYzNmMxZTAwNDgyYzA0ZDBhMDdiNjVhYWJmNTk5 YTEuLjEzZGZlMjM2ZGU2ZWU0NWM1YTVmMThjNDY2NzYxNjdkNDQyMzBiYjIgMTAwNzU1Ci0tLSBh L1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5oCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5oCkBAIC00Niw3ICs0Niw3IEBAIHB1Ymxp YzoKICAgICBTdHJpbmcga2V5UGF0aCgpIGNvbnN0OwogICAgIFBhc3NSZWZQdHI8RE9NU3RyaW5n TGlzdD4gaW5kZXhOYW1lcygpIGNvbnN0OwogCi0gICAgdm9pZCBnZXQoUGFzc1JlZlB0cjxJREJL ZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKKyAgICB2b2lkIGdldChQYXNzUmVm UHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4sIElEQlRyYW5zYWN0aW9u QmFja2VuZEludGVyZmFjZSopOwogICAgIHZvaWQgcHV0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNj cmlwdFZhbHVlPiB2YWx1ZSwgUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgYm9vbCBhZGRPbmx5LCBQ YXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwogICAgIHZvaWQgcmVtb3ZlKFBhc3NSZWZQdHI8SURC S2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAKZGlmZiAtLWdpdCBhL1dlYktp dC9jaHJvbWl1bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuY3BwIGIvV2ViS2l0L2No cm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5jcHAKaW5kZXggYmU2YjA1OGU1 MmUyNDI3NTgzNDg3MDlkYjAwMWNkMDQxYzU2OTZlOC4uNTllODhkODkzZTE1MmU3NTlhZDFjMDZh MWJjMGZhYTViZTgzOGIyOCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFu c2FjdGlvbkJhY2tlbmRQcm94eS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFu c2FjdGlvbkJhY2tlbmRQcm94eS5jcHAKQEAgLTY5LDExICs2OSwxNyBAQCB2b2lkIElEQlRyYW5z YWN0aW9uQmFja2VuZFByb3h5OjphYm9ydCgpCiAgICAgbV93ZWJJREJUcmFuc2FjdGlvbi0+YWJv cnQoKTsKIH0KIAotdm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6c2NoZWR1bGVUYXNr KFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pCitib29sIElEQlRyYW5z YWN0aW9uQmFja2VuZFByb3h5OjpzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPikKIHsKICAgICAvLyBUaGlzIHNob3VsZCBuZXZlciBiZSByZWFjaGVk IGFzIGl0J3MgdGhlIGltcGwgb2JqZWN0cyB3aG8gZ2V0IHRvCiAgICAgLy8gZXhlY3V0ZSB0YXNr cyBpbiB0aGUgYnJvd3NlciBwcm9jZXNzLgogICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg IHJldHVybiBmYWxzZTsKK30KKwordm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6ZGlk Q29tcGxldGVUYXNrRXZlbnRzKCkKK3sKKyAgICBtX3dlYklEQlRyYW5zYWN0aW9uLT5kaWRDb21w bGV0ZVRhc2tFdmVudHMoKTsKIH0KIAogaW50IElEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5Ojpp ZCgpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9u QmFja2VuZFByb3h5LmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2Vu ZFByb3h5LmgKaW5kZXggZDYyYjhmZjdiODQxYTJhM2Y5MmEyYzY3YTcwMGRlNjM4MzVmZTMwMi4u M2RhZjczZWIzYzkxY2UyODg4MzJiODczMGNkNzhmNzVjZGFhM2I0MyAxMDA2NDQKLS0tIGEvV2Vi S2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eS5oCisrKyBiL1dlYktp dC9jaHJvbWl1bS9zcmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaApAQCAtNDUsMTAgKzQ1 LDEzIEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNr ZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUpOwogICAgIHZpcnR1 YWwgdW5zaWduZWQgc2hvcnQgbW9kZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBhYm9ydCgp OwotICAgIHZpcnR1YWwgdm9pZCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPik7CisgICAgdmlydHVhbCBib29sIHNjaGVkdWxlVGFzayhQYXNzT3du UHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlk Q29tcGxldGVUYXNrRXZlbnRzKCk7CiAgICAgdmlydHVhbCBpbnQgaWQoKSBjb25zdDsKICAgICB2 aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKElEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzKik7CiAKKyAg ICBXZWJLaXQ6OldlYklEQlRyYW5zYWN0aW9uKiBnZXRXZWJJREJUcmFuc2FjdGlvbigpIGNvbnN0 IHsgcmV0dXJuIG1fd2ViSURCVHJhbnNhY3Rpb24uZ2V0KCk7IH0KKwogcHJpdmF0ZToKICAgICBJ REJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eShQYXNzT3duUHRyPFdlYktpdDo6V2ViSURCVHJhbnNh Y3Rpb24+KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJGYWN0b3J5 SW1wbC5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmNwcAppbmRl eCAzYzhkNDU5YTBhOWU1MjgzNzU5NmY1NjQxYzIyODQzYWUwOWRiYWU3Li43MTQ3Y2YwODZmMWNi NjdkZmRkOGQ4OTdhZTc1OWIxMGIzMjQwYWUxIDEwMDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQkZhY3RvcnlJbXBsLmNwcAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklE QkZhY3RvcnlJbXBsLmNwcApAQCAtNjMsMTUgKzYzLDYgQEAgdm9pZCBXZWJJREJGYWN0b3J5SW1w bDo6b3Blbihjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGVzY3JpcHRp b24KICAgICBtX2lkYkZhY3RvcnlCYWNrZW5kLT5vcGVuKG5hbWUsIGRlc2NyaXB0aW9uLCBJREJD YWxsYmFja3NQcm94eTo6Y3JlYXRlKGNhbGxiYWNrcyksIG9yaWdpbiwgMCwgZGF0YURpcik7CiB9 CiAKLXZvaWQgV2ViSURCRmFjdG9yeUltcGw6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25z dCBXZWJWZWN0b3I8aW50PiYgcGVuZGluZ0lEcykKLXsKLSAgICBXVEY6OlZlY3RvcjxpbnQ+IGlk cyhwZW5kaW5nSURzLnNpemUoKSk7Ci0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBwZW5kaW5n SURzLnNpemUoKTsgKytpKQotICAgICAgICBpZHNbaV0gPSBwZW5kaW5nSURzW2ldOwotCi0gICAg bV9pZGJGYWN0b3J5QmFja2VuZC0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGlkcyk7Ci19Ci0K IH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjZW5kaWYgLy8gRU5BQkxFKElOREVYRURfREFUQUJB U0UpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmgg Yi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmgKaW5kZXggNGRjMGExMDk4 MDk4NTQ4YjFmM2YzZTg3NzRiY2FlYzU3ZWQwZjAwYy4uYTBhNGQ3ZDlmZWQwNWFmNGFiOGZlNjU1 Mzk4MjBiNjM3NzY2NjZmOCAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJG YWN0b3J5SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwu aApAQCAtNDMsNyArNDMsNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB+V2ViSURCRmFjdG9yeUlt cGwoKTsKIAogICAgIHZpcnR1YWwgdm9pZCBvcGVuKGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29u c3QgV2ViU3RyaW5nJiBkZXNjcmlwdGlvbiwgV2ViSURCQ2FsbGJhY2tzKiwgY29uc3QgV2ViU2Vj dXJpdHlPcmlnaW4mLCBXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgZGF0YURpcik7Ci0gICAg dmlydHVhbCB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhjb25zdCBXZWJWZWN0b3I8aW50 PiYgcGVuZGluZ0lEcyk7CiAKIHByaXZhdGU6CiAgICAgV1RGOjpSZWZQdHI8V2ViQ29yZTo6SURC RmFjdG9yeUJhY2tlbmRJbnRlcmZhY2U+IG1faWRiRmFjdG9yeUJhY2tlbmQ7CmRpZmYgLS1naXQg YS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5jcHAgYi9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5jcHAKaW5kZXggMWFkMWQ5ZjNlNDcz OGE3NzRmM2I2NjE0YjIwNmY2MWEzYWIyZWMwMi4uMzZkOGFjZTRlOWQyZWYwNDExMmI0ZjJjMTAw OGY3OGVlY2JkYWM2YSAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmpl Y3RTdG9yZUltcGwuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3Rv cmVJbXBsLmNwcApAQCAtMzMsNiArMzMsNyBAQAogI2luY2x1ZGUgIldlYklEQkluZGV4SW1wbC5o IgogI2luY2x1ZGUgIldlYklEQktleS5oIgogI2luY2x1ZGUgIldlYklEQktleVJhbmdlLmgiCisj aW5jbHVkZSAiV2ViSURCVHJhbnNhY3Rpb24uaCIKICNpbmNsdWRlICJXZWJTZXJpYWxpemVkU2Ny aXB0VmFsdWUuaCIKIAogI2lmIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQpAQCAtNjUsOSArNjYs OSBAQCBXZWJET01TdHJpbmdMaXN0IFdlYklEQk9iamVjdFN0b3JlSW1wbDo6aW5kZXhOYW1lcygp IGNvbnN0CiAgICAgcmV0dXJuIG1fb2JqZWN0U3RvcmUtPmluZGV4TmFtZXMoKTsKIH0KIAotdm9p ZCBXZWJJREJPYmplY3RTdG9yZUltcGw6OmdldChjb25zdCBXZWJJREJLZXkmIGtleSwgV2ViSURC Q2FsbGJhY2tzKiBjYWxsYmFja3MpCit2b2lkIFdlYklEQk9iamVjdFN0b3JlSW1wbDo6Z2V0KGNv bnN0IFdlYklEQktleSYga2V5LCBXZWJJREJDYWxsYmFja3MqIGNhbGxiYWNrcywgY29uc3QgV2Vi SURCVHJhbnNhY3Rpb24mIHRyYW5zYWN0aW9uKQogewotICAgIG1fb2JqZWN0U3RvcmUtPmdldChr ZXksIElEQkNhbGxiYWNrc1Byb3h5OjpjcmVhdGUoY2FsbGJhY2tzKSk7CisgICAgbV9vYmplY3RT dG9yZS0+Z2V0KGtleSwgSURCQ2FsbGJhY2tzUHJveHk6OmNyZWF0ZShjYWxsYmFja3MpLCB0cmFu c2FjdGlvbi5nZXRJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UoKSk7CiB9CiAKIHZvaWQg V2ViSURCT2JqZWN0U3RvcmVJbXBsOjpwdXQoY29uc3QgV2ViU2VyaWFsaXplZFNjcmlwdFZhbHVl JiB2YWx1ZSwgY29uc3QgV2ViSURCS2V5JiBrZXksIGJvb2wgYWRkT25seSwgV2ViSURCQ2FsbGJh Y2tzKiBjYWxsYmFja3MpCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQk9i amVjdFN0b3JlSW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmplY3RTdG9yZUlt cGwuaAppbmRleCA5ZjMxMzY5YzMwYjE0MTVmMWI5MmM3MDg1Y2FkZWRhMDI3ODk5MjJiLi5hOWYx MjAwYzlmYzRkODYxZDJlZjVmNzllOTQ0MjE5NjEzZTY0Njk5IDEwMDc1NQotLS0gYS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmgKQEAgLTQ3LDcgKzQ3LDcgQEAgcHVibGljOgog ICAgIFdlYlN0cmluZyBrZXlQYXRoKCkgY29uc3Q7CiAgICAgV2ViRE9NU3RyaW5nTGlzdCBpbmRl eE5hbWVzKCkgY29uc3Q7CiAKLSAgICB2b2lkIGdldChjb25zdCBXZWJJREJLZXkmIGtleSwgV2Vi SURCQ2FsbGJhY2tzKik7CisgICAgdm9pZCBnZXQoY29uc3QgV2ViSURCS2V5JiBrZXksIFdlYklE QkNhbGxiYWNrcyosIGNvbnN0IFdlYklEQlRyYW5zYWN0aW9uJik7CiAgICAgdm9pZCBwdXQoY29u c3QgV2ViU2VyaWFsaXplZFNjcmlwdFZhbHVlJiB2YWx1ZSwgY29uc3QgV2ViSURCS2V5JiBrZXks IGJvb2wgYWRkT25seSwgV2ViSURCQ2FsbGJhY2tzKik7CiAgICAgdm9pZCByZW1vdmUoY29uc3Qg V2ViSURCS2V5JiBrZXksIFdlYklEQkNhbGxiYWNrcyopOwogCmRpZmYgLS1naXQgYS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5jcHAgYi9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5jcHAKaW5kZXggMGRjOTcwMmRlOTdkMWY5ODVkZTFh MDEyNGZmODczNjM1OWMyMTJmMy4uZjVkODc0ODcwODhhMjdkNzE2ZTc0Y2E4NzgzMmNhNTU2ZDVi MjFlMyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJUcmFuc2FjdGlvbklt cGwuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmNw cApAQCAtNjQsNiArNjQsMTEgQEAgdm9pZCBXZWJJREJUcmFuc2FjdGlvbkltcGw6OmFib3J0KCkK ICAgICBtX2JhY2tlbmQtPmFib3J0KCk7CiB9CiAKK3ZvaWQgV2ViSURCVHJhbnNhY3Rpb25JbXBs OjpkaWRDb21wbGV0ZVRhc2tFdmVudHMoKQoreworICAgIG1fYmFja2VuZC0+ZGlkQ29tcGxldGVU YXNrRXZlbnRzKCk7Cit9CisKIGludCBXZWJJREJUcmFuc2FjdGlvbkltcGw6OmlkKCkgY29uc3QK IHsKICAgICByZXR1cm4gbV9iYWNrZW5kLT5pZCgpOwpAQCAtNzUsNiArODAsMTEgQEAgdm9pZCBX ZWJJREJUcmFuc2FjdGlvbkltcGw6OnNldENhbGxiYWNrcyhXZWJJREJUcmFuc2FjdGlvbkNhbGxi YWNrcyogY2FsbGJhY2tzKQogICAgIG1fYmFja2VuZC0+c2V0Q2FsbGJhY2tzKGlkYkNhbGxiYWNr cy5nZXQoKSk7CiB9CiAKK0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogV2ViSURCVHJh bnNhY3Rpb25JbXBsOjpnZXRJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UoKSBjb25zdAor eworICAgIHJldHVybiBtX2JhY2tlbmQuZ2V0KCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktp dAogCiAjZW5kaWYgLy8gRU5BQkxFKElOREVYRURfREFUQUJBU0UpCmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5oIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJJREJUcmFuc2FjdGlvbkltcGwuaAppbmRleCBhOWJkZTY4NGVmNWEwZTM5ZjlmN2Uz MzAxOWU0NzJjNDZkODlkOGRmLi4yNGJhYjkxNGQwNDkzMWRjYzFiYWJmYmMzYzdkMjMzMWZmOTVh OTg1IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1w bC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmgKQEAg LTMzLDggKzMzLDYgQEAKICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0 Zi9SZWZQdHIuaD4KIAotbmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBJREJUcmFuc2FjdGlvbkJh Y2tlbmRJbnRlcmZhY2U7IH0KLQogbmFtZXNwYWNlIFdlYktpdCB7CiAKIC8vIFNlZSBjb21tZW50 IGluIFdlYkluZGV4ZWREYXRhYmFzZSBmb3IgYSBoaWdoIGxldmVsIG92ZXJ2aWV3IHRoZXNlIGNs YXNzZXMuCkBAIC00Niw5ICs0NCwxMiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBpbnQgbW9kZSgp IGNvbnN0OwogICAgIHZpcnR1YWwgV2ViSURCT2JqZWN0U3RvcmUqIG9iamVjdFN0b3JlKGNvbnN0 IFdlYlN0cmluZyYgbmFtZSk7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0KCk7CisgICAgdmlydHVh bCB2b2lkIGRpZENvbXBsZXRlVGFza0V2ZW50cygpOwogICAgIHZpcnR1YWwgaW50IGlkKCkgY29u c3Q7CiAgICAgdmlydHVhbCB2b2lkIHNldENhbGxiYWNrcyhXZWJJREJUcmFuc2FjdGlvbkNhbGxi YWNrcyopOwogCisgICAgdmlydHVhbCBXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2UqIGdldElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSgpIGNvbnN0OworCiBwcml2 YXRlOgogICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZT4gbV9iYWNrZW5kOwogfTsK 68514 2010-09-23 06:57:46 -0700 2010-09-23 07:11:15 -0700 Patch bug-44700-20100923145743.patch text/plain 61655 andreip ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA3ODkyMjdkNGMyZjlkMTlkYWQ0NjcxOTczMTRmYmI3MjcwYTMxNjM1Li5iZTIzZGIw MDllOTRkZTgzNmM0MmZlMDJmMDVkZGNkYmEyNzY4YTA4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTAtMDktMjMgIEFuZHJlaSBQb3Blc2N1ICA8YW5kcmVpcEBnb29nbGUuY29tPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElEQk9iamVjdFN0b3Jl OjpnZXQgc2hvdWxkIHJ1biBpbiBhIHRyYW5zYWN0aW9uLgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDQ3MDAKKworICAgICAgICAqIHN0b3JhZ2UvaW5k ZXhlZGRiL29iamVjdHN0b3JlLWJhc2ljcy1leHBlY3RlZC50eHQ6CisgICAgICAgICogc3RvcmFn ZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLmh0bWw6CisgICAgICAgICogc3RvcmFnZS9p bmRleGVkZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0OgorICAg ICAgICAqIHN0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0 bWw6CisKIDIwMTAtMDktMjMgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KIAogICAg ICAgICBSdWJiZXItc3RhbXBlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLWJhc2ljcy1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MtZXhwZWN0ZWQu dHh0CmluZGV4IDg5MGMwMGZhNzBhNjVjOGNlYjNlNGE1MDVkZTQ1NjhkOGFhNWM4ZTkuLjgyMWU5 NjZiNDM5ZTU0NTI5ZWMxZTFjNTRhOGU5YjU1YzE2ZDM5NWMgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLWJhc2ljcy1leHBlY3RlZC50eHQKKysr IGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUtYmFzaWNzLWV4cGVj dGVkLnR4dApAQCAtMTEzLDcgKzExMyw4IEBAIFBBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRh cmdldCBpcyB0cnVlCiBQQVNTIGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdl dC5ET05FCiAKIFBBU1MgZXZlbnQuY29kZSBpcyBJREJEYXRhYmFzZUV4Y2VwdGlvbi5VTktOT1dO X0VSUgotc3RvcmUgPSBldmVudC5zb3VyY2UKK2RiLnRyYW5zYWN0aW9uKCkKK3N0b3JlID0gdHJh bnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpCiBzdG9yZS5nZXQoJ2tleScpCiBQQVNT ICdvbnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCiBQQVNTICdvbmVycm9yJyBpbiByZXN1bHQg aXMgdHJ1ZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0 c3RvcmUtYmFzaWNzLmh0bWwgYi9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3Rz dG9yZS1iYXNpY3MuaHRtbAppbmRleCA3MzFkNDIxOGMyMjUwOTRiNGVkYThmM2M3NjZjYzI1NDA3 MTk1ZjM1Li42NjM3NmI3ZDNmZTkyOTA4NWI0MmE4OWIyN2M1MDYxOTBkY2MwNWI0IDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3MuaHRt bAorKysgYi9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1iYXNpY3Mu aHRtbApAQCAtODUsNyArODUsMTAgQEAgZnVuY3Rpb24gYWRkQWdhaW5GYWlsdXJlKCkKICAgICB2 ZXJpZnlFcnJvckV2ZW50KGV2ZW50KTsKICAgICAvLyBGSVhNRTogVGhpcyBlcnJvciBjb2RlIG5l ZWRzIHRvIGJlIHNwZWNjZWQuCiAgICAgc2hvdWxkQmUoImV2ZW50LmNvZGUiLCAiSURCRGF0YWJh c2VFeGNlcHRpb24uVU5LTk9XTl9FUlIiKTsKLSAgICB2YXIgc3RvcmUgPSBldmFsQW5kTG9nKCJz dG9yZSA9IGV2ZW50LnNvdXJjZSIpOworCisgICAgdHJhbnNhY3Rpb24gPSBldmFsQW5kTG9nKCJk Yi50cmFuc2FjdGlvbigpIik7CisgICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9IHVuZXhwZWN0ZWRF cnJvckNhbGxiYWNrOworICAgIHZhciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3JlID0gdHJhbnNh Y3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7CiAKICAgICByZXN1bHQgPSBldmFsQW5k TG9nKCJzdG9yZS5nZXQoJ2tleScpIik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVv YmplY3RzdG9yZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9v YmplY3RzdG9yZS1yZW1vdmVvYmplY3RzdG9yZS1leHBlY3RlZC50eHQKaW5kZXggMGEzZDkzODZj NWIxYjY0M2EwZDgxNjllOGJkZjZlNjgyNTVmZjM5MS4uNjBmZWRlYzQ4ODM3MjkyNWViZWI1NWNj ODYxMjg3ZjA4MGZiODFkNyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVk ZGIvb2JqZWN0c3RvcmUtcmVtb3Zlb2JqZWN0c3RvcmUtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91 dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29iamVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLWV4 cGVjdGVkLnR4dApAQCAtNjEsNyArNjEsOSBAQCBQQVNTICdhYm9ydCcgaW4gZXZlbnQudGFyZ2V0 IGlzIHRydWUKIFBBU1MgJ3JlYWR5U3RhdGUnIGluIGV2ZW50LnRhcmdldCBpcyB0cnVlCiBQQVNT IGV2ZW50LnRhcmdldC5yZWFkeVN0YXRlIGlzIGV2ZW50LnRhcmdldC5ET05FCiAKLWV2ZW50LnNv dXJjZS5nZXQoJ2tleScpCitkYi50cmFuc2FjdGlvbigpCitzdG9yZSA9IHRyYW5zYWN0aW9uLm9i amVjdFN0b3JlKCdzdG9yZU5hbWUnKQorc3RvcmUuZ2V0KCdrZXknKQogUEFTUyAnb25zdWNjZXNz JyBpbiByZXN1bHQgaXMgdHJ1ZQogUEFTUyAnb25lcnJvcicgaW4gcmVzdWx0IGlzIHRydWUKIFBB U1MgJ2Fib3J0JyBpbiByZXN1bHQgaXMgdHJ1ZQpAQCAtMTM5LDcgKzE0MSw5IEBAIFBBU1MgJ2Fi b3J0JyBpbiBldmVudC50YXJnZXQgaXMgdHJ1ZQogUEFTUyAncmVhZHlTdGF0ZScgaW4gZXZlbnQu dGFyZ2V0IGlzIHRydWUKIFBBU1MgZXZlbnQudGFyZ2V0LnJlYWR5U3RhdGUgaXMgZXZlbnQudGFy Z2V0LkRPTkUKIAotZXZlbnQucmVzdWx0LmdldCgna2V5JykKK2RiLnRyYW5zYWN0aW9uKCkKK3N0 b3JlID0gdHJhbnNhY3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpCitzdG9yZS5nZXQoJ2tl eScpCiBQQVNTICdvbnN1Y2Nlc3MnIGluIHJlc3VsdCBpcyB0cnVlCiBQQVNTICdvbmVycm9yJyBp biByZXN1bHQgaXMgdHJ1ZQogUEFTUyAnYWJvcnQnIGluIHJlc3VsdCBpcyB0cnVlCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1vdmVvYmpl Y3RzdG9yZS5odG1sIGIvTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvb2JqZWN0c3RvcmUt cmVtb3Zlb2JqZWN0c3RvcmUuaHRtbAppbmRleCBlODQyZjViZmJmOGVlMTE3ZjBkNmYzYzBjMGNh ODRlYzQ3YWU0OGM2Li43ODc4YzdmYWUxYTY2NDUyOWUwMjI4NjhmYmZjZjQxNmJjZTJjODg3IDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi9vYmplY3RzdG9yZS1yZW1v dmVvYmplY3RzdG9yZS5odG1sCisrKyBiL0xheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL29i amVjdHN0b3JlLXJlbW92ZW9iamVjdHN0b3JlLmh0bWwKQEAgLTQ5LDcgKzQ5LDExIEBAIGZ1bmN0 aW9uIGdldFZhbHVlKCkKIHsKICAgICB2ZXJpZnlTdWNjZXNzRXZlbnQoZXZlbnQpOwogCi0gICAg cmVzdWx0ID0gZXZhbEFuZExvZygiZXZlbnQuc291cmNlLmdldCgna2V5JykiKTsKKyAgICB0cmFu c2FjdGlvbiA9IGV2YWxBbmRMb2coImRiLnRyYW5zYWN0aW9uKCkiKTsKKyAgICB0cmFuc2FjdGlv bi5vbmFib3J0ID0gdW5leHBlY3RlZEVycm9yQ2FsbGJhY2s7CisgICAgdmFyIHN0b3JlID0gZXZh bEFuZExvZygic3RvcmUgPSB0cmFuc2FjdGlvbi5vYmplY3RTdG9yZSgnc3RvcmVOYW1lJykiKTsK KworICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coInN0b3JlLmdldCgna2V5JykiKTsKICAgICB2ZXJp ZnlSZXN1bHQocmVzdWx0KTsKICAgICByZXN1bHQub25zdWNjZXNzID0gYWRkSW5kZXg7CiAgICAg cmVzdWx0Lm9uZXJyb3IgPSB1bmV4cGVjdGVkRXJyb3JDYWxsYmFjazsKQEAgLTYyLDE1ICs2Niwy MCBAQCBmdW5jdGlvbiBhZGRJbmRleCgpCiAKICAgICByZXN1bHQgPSBldmFsQW5kTG9nKCJldmVu dC5zb3VyY2UuY3JlYXRlSW5kZXgoJ2luZGV4TmFtZScsICcnKSIpOwogICAgIHZlcmlmeVJlc3Vs dChyZXN1bHQpOwotICAgIHJlc3VsdC5vbnN1Y2Nlc3MgPSByZW1vdmVPYmplY3RTdG9yZTsKKyAg ICByZXN1bHQub25zdWNjZXNzID0gY29tbWl0VHJhbnNhY3Rpb247CiAgICAgcmVzdWx0Lm9uZXJy b3IgPSB1bmV4cGVjdGVkRXJyb3JDYWxsYmFjazsKIH0KIAotZnVuY3Rpb24gcmVtb3ZlT2JqZWN0 U3RvcmUoKQorZnVuY3Rpb24gY29tbWl0VHJhbnNhY3Rpb24oKQogewogICAgIHZlcmlmeVN1Y2Nl c3NFdmVudChldmVudCk7CiAgICAgc2hvdWxkQmVUcnVlKCJldmVudC5zb3VyY2UuaW5kZXhOYW1l cy5jb250YWlucygnaW5kZXhOYW1lJykiKTsKKyAgICAvLyBMZXQgdGhlIHRyYW5zYWN0aW9uIGNv bW1pdC4KKyAgICB3aW5kb3cuc2V0VGltZW91dCgncmVtb3ZlT2JqZWN0U3RvcmUoKScsIDApOwor fQogCitmdW5jdGlvbiByZW1vdmVPYmplY3RTdG9yZSgpCit7CiAgICAgcmVzdWx0ID0gZXZhbEFu ZExvZygiZGIucmVtb3ZlT2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7CiAgICAgdmVyaWZ5UmVz dWx0KHJlc3VsdCk7CiAgICAgcmVzdWx0Lm9uc3VjY2VzcyA9IGNyZWF0ZU9iamVjdFN0b3JlQWdh aW47CkBAIC05MSw3ICsxMDAsMTEgQEAgZnVuY3Rpb24gZ2V0VmFsdWVBZ2FpbigpCiB7CiAgICAg dmVyaWZ5U3VjY2Vzc0V2ZW50KGV2ZW50KTsKIAotICAgIHJlc3VsdCA9IGV2YWxBbmRMb2coImV2 ZW50LnJlc3VsdC5nZXQoJ2tleScpIik7CisgICAgdHJhbnNhY3Rpb24gPSBldmFsQW5kTG9nKCJk Yi50cmFuc2FjdGlvbigpIik7CisgICAgdHJhbnNhY3Rpb24ub25hYm9ydCA9IHVuZXhwZWN0ZWRF cnJvckNhbGxiYWNrOworICAgIHZhciBzdG9yZSA9IGV2YWxBbmRMb2coInN0b3JlID0gdHJhbnNh Y3Rpb24ub2JqZWN0U3RvcmUoJ3N0b3JlTmFtZScpIik7CisKKyAgICByZXN1bHQgPSBldmFsQW5k TG9nKCJzdG9yZS5nZXQoJ2tleScpIik7CiAgICAgdmVyaWZ5UmVzdWx0KHJlc3VsdCk7CiAgICAg cmVzdWx0Lm9uc3VjY2VzcyA9IHVuZXhwZWN0ZWRTdWNjZXNzQ2FsbGJhY2s7CiAgICAgcmVzdWx0 Lm9uZXJyb3IgPSB2ZXJpZnlFcnJvcjsKQEAgLTEwMCw3ICsxMTMsNiBAQCBmdW5jdGlvbiBnZXRW YWx1ZUFnYWluKCkKIGZ1bmN0aW9uIHZlcmlmeUVycm9yKCkKIHsKICAgICB2ZXJpZnlFcnJvckV2 ZW50KGV2ZW50KTsKLSAgICAvLyBGSVhNRTogU2hvdWxkIGp1c3QgYmUgSURCRGF0YWJhc2VFeGNl cHRpb24uTk9UX0ZPVU5EX0VSUiBidXQgdGhhdCBkb2Vzbid0IHdvcmsgeWV0LgogICAgIHNob3Vs ZEJlKCJldmVudC5jb2RlIiwgIjIiKTsKICAgICBzaG91bGRCZUZhbHNlKCJldmVudC5zb3VyY2Uu aW5kZXhOYW1lcy5jb250YWlucygnaW5kZXhOYW1lJykiKTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBjNDdlMDMxMzhiY2FiM2EyMDdj Njc4NDA4YzU2Yzg3NGQ3YTBjOWY0Li5kYzliNWM3ZjgxZjIyOGFkZmNkZDVjYTA4NjIzYWNiYjhj ZDNkNWZmIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDc2IEBACisyMDEwLTA5LTIzICBBbmRyZWkgUG9wZXNjdSAgPGFuZHJl aXBAZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBJREJPYmplY3RTdG9yZTo6Z2V0IHNob3VsZCBydW4gaW4gYSB0cmFuc2FjdGlvbi4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzAwCisK KyAgICAgICAgSW1wbGVtZW50cyBsb2dpYyBmb3IgcnVubmluZyBJREJPYmplY3RTdG9yZTo6Z2V0 KCkgaW4gYSB0cmFuc2FjdGlvbi4KKyAgICAgICAgUmVmYWN0b3JzIHRoZSBwZW5kaW5nIHRyYW5z YWN0aW9uIG1vbml0b3IgYW5kIHRoZSB0cmFuc2FjdGlvbiBjb29yZGluYXRvcgorICAgICAgICB0 byB1c2UgcG9pbnRlcnMgaW5zdGVhZCBvZiB0cmFuc2FjdGlvbiBJRHMuCisgCisgICAgICAgICog YmluZGluZ3MvdjgvVjhQcm94eS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOFByb3h5OjpkaWRM ZWF2ZVNjcmlwdENvbnRleHQpOgorICAgICAgICAqIHN0b3JhZ2UvSURCQ3Vyc29yQmFja2VuZElt cGwuY3BwOgorICAgICAgICAqIHN0b3JhZ2UvSURCRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6SURCRGF0YWJhc2U6Om9iamVjdFN0b3JlKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQkRh dGFiYXNlQmFja2VuZEltcGwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJhc2VCYWNr ZW5kSW1wbDo6b2JqZWN0U3RvcmUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCRGF0YWJhc2VCYWNr ZW5kSW1wbC5oOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJhc2VCYWNrZW5kSW1wbDo6dHJh bnNhY3Rpb25Db29yZGluYXRvcik6CisgICAgICAgICogc3RvcmFnZS9JREJGYWN0b3J5QmFja2Vu ZEltcGwuY3BwOgorICAgICAgICAqIHN0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmg6Cisg ICAgICAgICogc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEludGVyZmFjZS5oOgorICAgICAgICAq IHN0b3JhZ2UvSURCT2JqZWN0U3RvcmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0 U3RvcmU6OklEQk9iamVjdFN0b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3Jl OjpnZXQpOgorICAgICAgICAqIHN0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaDoKKyAgICAgICAgKFdl YkNvcmU6OklEQk9iamVjdFN0b3JlOjpjcmVhdGUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCT2Jq ZWN0U3RvcmVCYWNrZW5kSW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJUYXNrOjpJREJU YXNrKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAg KFdlYkNvcmU6OmNyZWF0ZVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6SURCT2JqZWN0U3RvcmVC YWNrZW5kSW1wbDo6Z2V0KToKKyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3JlQmFja2Vu ZEltcGw6OmdldEludGVybmFsKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFj a2VuZEltcGwuaDoKKyAgICAgICAgKiBzdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZS5oOgorICAgICAgICAqIHN0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjphZGRQ ZW5kaW5nVHJhbnNhY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6SURCUGVuZGluZ1RyYW5zYWN0 aW9uTW9uaXRvcjo6cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6 OklEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyk6 CisgICAgICAgICogc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmg6CisgICAg ICAgICogc3RvcmFnZS9JREJSZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlJlcXVl c3Q6OklEQlJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6SURCUmVxdWVzdDo6fklEQlJlcXVl c3QpOgorICAgICAgICAoV2ViQ29yZTo6SURCUmVxdWVzdDo6b25TdWNjZXNzKToKKyAgICAgICAg KFdlYkNvcmU6OklEQlJlcXVlc3Q6OnRpbWVyRmlyZWQpOgorICAgICAgICAqIHN0b3JhZ2UvSURC UmVxdWVzdC5oOgorICAgICAgICAoV2ViQ29yZTo6SURCUmVxdWVzdDo6Y3JlYXRlKToKKyAgICAg ICAgKiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQlRy YW5zYWN0aW9uOjpJREJUcmFuc2FjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2Fj dGlvbjo6b2JqZWN0U3RvcmUpOgorICAgICAgICAqIHN0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBs OjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6 SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbXBsOjpvYmplY3RTdG9yZSk6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFu c2FjdGlvbkJhY2tlbmRJbXBsOjpzY2hlZHVsZVRhc2spOgorICAgICAgICAoV2ViQ29yZTo6SURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6YWJvcnQpOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJh bnNhY3Rpb25CYWNrZW5kSW1wbDo6ZGlkQ29tcGxldGVUYXNrRXZlbnRzKToKKyAgICAgICAgKFdl YkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnJ1bik6CisgICAgICAgIChXZWJDb3Jl OjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpzdGFydCk6CisgICAgICAgIChXZWJDb3JlOjpJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpjb21taXQpOgorICAgICAgICAoV2ViQ29yZTo6SURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZCk6CisgICAgICAgICogc3RvcmFnZS9J REJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmg6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2Fj dGlvbkJhY2tlbmRJbXBsOjp+SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCk6CisgICAgICAgIChX ZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjppc0ZpbmlzaGVkKToKKyAgICAgICAg KiBzdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5oOgorICAgICAgICAqIHN0 b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJ REJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpjcmVhdGVUcmFuc2FjdGlvbik6CisgICAgICAgIChX ZWJDb3JlOjpJREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yOjpkaWRTdGFydFRyYW5zYWN0aW9uKToK KyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZEZpbmlzaFRy YW5zYWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6 OnByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKToKKyAgICAgICAgKiBzdG9yYWdlL0lEQlRyYW5z YWN0aW9uQ29vcmRpbmF0b3IuaDoKKwogMjAxMC0wOS0yMyAgRGFyaW4gQWRsZXIgIDxkYXJpbkBh cHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQ2hyaXMgRmxlaXphY2guCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4UHJveHkuY3BwIGIvV2ViQ29yZS9iaW5kaW5ncy92 OC9WOFByb3h5LmNwcAppbmRleCA5NDk5MDc1MGNmODlmNGQ4NWY2MWY4ZDI4MjcyOWYxMjNhODEy YTdlLi4wYTYyMDc5NGM5YjAxZmM4YjcxYmQ2NDM3ZTA2MDRiZWUyNmQ1N2ExIDEwMDY0NAotLS0g YS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4UHJveHkuY3BwCisrKyBiL1dlYkNvcmUvYmluZGluZ3Mv djgvVjhQcm94eS5jcHAKQEAgLTY1MywxMSArNjUzLDcgQEAgdm9pZCBWOFByb3h5OjpkaWRMZWF2 ZVNjcmlwdENvbnRleHQoKQogICAgIC8vIElmIHdlJ3ZlIGp1c3QgbGVmdCBhIHNjcmlwdCBjb250 ZXh0IGFuZCBpbmRleGVkIGRhdGFiYXNlIGhhcyBiZWVuCiAgICAgLy8gaW5zdGFudGlhdGVkLCB3 ZSBtdXN0IGxldCBpdHMgdHJhbnNhY3Rpb24gY29vcmRpbmF0b3Iga25vdyBzbyBpdCBjYW4gdGVy bWluYXRlCiAgICAgLy8gYW55IG5vdC15ZXQtc3RhcnRlZCB0cmFuc2FjdGlvbnMuCi0gICAgaWYg KElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6Omhhc1BlbmRpbmdUcmFuc2FjdGlvbnMoKSkg ewotICAgICAgICBBU1NFUlQocGFnZS0+Z3JvdXAoKS5oYXNJREJGYWN0b3J5KCkpOwotICAgICAg ICBwYWdlLT5ncm91cCgpLmlkYkZhY3RvcnkoKS0+YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKElE QlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OnBlbmRpbmdUcmFuc2FjdGlvbnMoKSk7Ci0gICAg ICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmNsZWFyUGVuZGluZ1RyYW5zYWN0aW9u cygpOwotICAgIH0KKyAgICBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjphYm9ydFBlbmRp bmdUcmFuc2FjdGlvbnMoKTsKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKICAg ICAvLyBJZiB3ZSd2ZSBqdXN0IGxlZnQgYSB0b3AgbGV2ZWwgc2NyaXB0IGNvbnRleHQgYW5kIGxv Y2FsIHN0b3JhZ2UgaGFzIGJlZW4KICAgICAvLyBpbnN0YW50aWF0ZWQsIHdlIG11c3QgZW5zdXJl IHRoYXQgYW55IHN0b3JhZ2UgbG9ja3MgaGF2ZSBiZWVuIGZyZWVkLgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9J REJDdXJzb3JCYWNrZW5kSW1wbC5jcHAKaW5kZXggM2E0ZGQ2Nzc0OGFiNzQ3NWYxNjljZWQ3NDc2 YTM1ZjdkNWI2ODM4ZC4uMTNkZjVmMDIxNTRlNTVkMTYyNmQwNjIyZTBiZDI1YzVjZTBiZDk4YSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkN1cnNvckJhY2tlbmRJbXBsLmNwcAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvSURCQ3Vyc29yQmFja2VuZEltcGwuY3BwCkBAIC0zNiw2ICszNiw3 IEBACiAjaW5jbHVkZSAiSURCS2V5UmFuZ2UuaCIKICNpbmNsdWRlICJJREJPYmplY3RTdG9yZUJh Y2tlbmRJbXBsLmgiCiAjaW5jbHVkZSAiSURCUmVxdWVzdC5oIgorI2luY2x1ZGUgIklEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZS5oIgogI2luY2x1ZGUgIlNRTGl0ZURhdGFiYXNlLmgiCiAj aW5jbHVkZSAiU1FMaXRlU3RhdGVtZW50LmgiCiAjaW5jbHVkZSAiU2VyaWFsaXplZFNjcmlwdFZh bHVlLmgiCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwIGIvV2Vi Q29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlLmNwcAppbmRleCA4MTk1MGQ2ZTA0M2JkZjIwYmY1YmJj NWY2M2Y5OTgwMjYyOTJjYWNhLi4wZWE3YWMyOTI2NzRjZWE2MDk3MDM1ZmE1ZmU1Yzg5N2Y0NGRi NmI3IDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2UuY3BwCisrKyBiL1dl YkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZS5jcHAKQEAgLTU1LDExICs1NSwxMiBAQCBQYXNzUmVm UHRyPElEQlJlcXVlc3Q+IElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShTY3JpcHRFeGVj dXRpb25Db250ZXh0KiBjbwogICAgIHJldHVybiByZXF1ZXN0OwogfQogCisvLyBGSVhNRTogcmVt b3ZlIHRoaXMgbWV0aG9kLgogUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gSURCRGF0YWJhc2U6 Om9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSkKIHsK ICAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBvYmplY3RTdG9yZSA9 IG1fYmFja2VuZC0+b2JqZWN0U3RvcmUobmFtZSwgbW9kZSk7CiAgICAgQVNTRVJUKG9iamVjdFN0 b3JlKTsgLy8gRklYTUU6IElmIHRoaXMgaXMgbnVsbCwgd2Ugc2hvdWxkIHJhaXNlIGEgTk9UX0ZP VU5EX0VSUi4KLSAgICByZXR1cm4gSURCT2JqZWN0U3RvcmU6OmNyZWF0ZShvYmplY3RTdG9yZS5y ZWxlYXNlKCkpOworICAgIHJldHVybiBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9iamVjdFN0b3Jl LnJlbGVhc2UoKSwgMCk7CiB9CiAKIFBhc3NSZWZQdHI8SURCUmVxdWVzdD4gSURCRGF0YWJhc2U6 OnJlbW92ZU9iamVjdFN0b3JlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0 IFN0cmluZyYgbmFtZSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJh Y2tlbmRJbXBsLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmNw cAppbmRleCAwMjFmNzBhYTRiNDg4MTE5ZTlmYzk2MTZmMDQ1ZDQ5OWNhNGI4MWFiLi5iOGZlOWI1 MDYyZjZkNjAzMDViYzFkNWM2MDE1ZGQwMDIyZmM3NTQxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0 b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5jcHAKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lE QkRhdGFiYXNlQmFja2VuZEltcGwuY3BwCkBAIC0xNDgsMTEgKzE0OCwxMiBAQCB2b2lkIElEQkRh dGFiYXNlQmFja2VuZEltcGw6OmNyZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwg Y29uc3QgU3RyaW5nJgogICAgIGNhbGxiYWNrcy0+b25TdWNjZXNzKG9iamVjdFN0b3JlLmdldCgp KTsKIH0KIAorLy8gRklYTUU6IERvIG5vdCBleHBvc2UgdGhpcyBtZXRob2QgdmlhIElETC4KIFBh c3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBJREJEYXRhYmFzZUJhY2tl bmRJbXBsOjpvYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIHVuc2lnbmVkIHNob3J0IG1v ZGUpCiB7Ci0gICAgLy8gRklYTUU6IElmIG5vIHRyYW5zYWN0aW9uIGlzIHJ1bm5pbmcsIHRoaXMg c2hvdWxkIGltcGxpY2l0bHkgc3RhcnQgb25lLgotICAgIEFTU0VSVF9VTlVTRUQobW9kZSwgIW1v ZGUpOyAvLyBGSVhNRTogSGFuZGxlIG5vbi1zdGFuZGFyZCBtb2Rlcy4KLSAgICByZXR1cm4gbV9v YmplY3RTdG9yZXMuZ2V0KG5hbWUpOworICAgIEFTU0VSVF9VTlVTRUQobW9kZSwgIW1vZGUpOyAv LyBGSVhNRTogUmVtb3ZlIHRoZSBtb2RlIHBhcmFtZXRlci4gVHJhbnNhY3Rpb25zIGhhdmUgbW9k ZXMsIG5vdCBvYmplY3Qgc3RvcmVzLgorICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZUJhY2tlbmRJ bnRlcmZhY2U+IG9iamVjdFN0b3JlID0gbV9vYmplY3RTdG9yZXMuZ2V0KG5hbWUpOworICAgIHJl dHVybiBvYmplY3RTdG9yZS5yZWxlYXNlKCk7CiB9CiAKIHN0YXRpYyB2b2lkIGRvRGVsZXRlKFNR TGl0ZURhdGFiYXNlJiBkYiwgY29uc3QgY2hhciogc3FsLCBpbnQ2NF90IGlkKQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwuaCBiL1dlYkNvcmUvc3Rv cmFnZS9JREJEYXRhYmFzZUJhY2tlbmRJbXBsLmgKaW5kZXggYWIwNTVmODhhOGMwOGYyZjZkMDNk Njk1OTgxNDQxNTc4YzRmMjU3MC4uN2UwOGFkNjVhZmU0NmNhM2U0MzYzZWFlZjYwYjI1NzA1M2Nl MzNiMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQkRhdGFiYXNlQmFja2VuZEltcGwu aAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRGF0YWJhc2VCYWNrZW5kSW1wbC5oCkBAIC02Miw2 ICs2Miw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmVyc2lvbihjb25zdCBTdHJp bmcmIHZlcnNpb24sIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCBQYXNz UmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZT4gdHJhbnNhY3Rpb24oRE9NU3Ry aW5nTGlzdCogc3RvcmVOYW1lcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0 aW1lb3V0KTsKIAorICAgIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqIHRyYW5zYWN0aW9uQ29v cmRpbmF0b3IoKSBjb25zdCB7IHJldHVybiBtX3RyYW5zYWN0aW9uQ29vcmRpbmF0b3IuZ2V0KCk7 IH0KKwogcHJpdmF0ZToKICAgICBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKGNvbnN0IFN0cmluZyYg bmFtZSwgY29uc3QgU3RyaW5nJiBkZXNjcmlwdGlvbiwgUGFzc093blB0cjxTUUxpdGVEYXRhYmFz ZT4gZGF0YWJhc2UsIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IqKTsKIApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5jcHAgYi9XZWJDb3JlL3N0b3Jh Z2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcAppbmRleCAyNjQ3M2FlZTFhY2YxYjNjNjQ0YjVl NWVkNTJkMzE2YWRkNjcxMzk5Li42MjE5YzJkZWQ0YjFiM2E5NzJhMDA0NjM5MDU2YmQyYzM2MGY4 M2YwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNw cAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmNwcApAQCAtMTQw LDEyICsxNDAsNiBAQCB2b2lkIElEQkZhY3RvcnlCYWNrZW5kSW1wbDo6b3Blbihjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24sCiAgICAgbV9kYXRhYmFzZUJhY2tl bmRNYXAuc2V0KG5hbWUsIGRhdGFiYXNlQmFja2VuZC5yZWxlYXNlKCkpOwogfQogCi12b2lkIElE QkZhY3RvcnlCYWNrZW5kSW1wbDo6YWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNvbnN0IFZlY3Rv cjxpbnQ+JiBwZW5kaW5nSURzKQotewotICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcGVuZGlu Z0lEcy5zaXplKCk7ICsraSkKLSAgICAgICAgbV90cmFuc2FjdGlvbkNvb3JkaW5hdG9yLT5hYm9y dChwZW5kaW5nSURzLmF0KGkpKTsKLX0KLQogU3RyaW5nIElEQkZhY3RvcnlCYWNrZW5kSW1wbDo6 ZGF0YWJhc2VGaWxlTmFtZShjb25zdCBTdHJpbmcmIG5hbWUsIFNlY3VyaXR5T3JpZ2luKiBzZWN1 cml0eU9yaWdpbikKIHsKICAgICBTdHJpbmcgZGF0YWJhc2VJZGVudGlmaWVyID0gc2VjdXJpdHlP cmlnaW4tPmRhdGFiYXNlSWRlbnRpZmllcigpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdl L0lEQkZhY3RvcnlCYWNrZW5kSW1wbC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQkZhY3RvcnlCYWNr ZW5kSW1wbC5oCmluZGV4IGNiMTMzZGVlNWYzZTBmZTMzMzNkNDU4ZmM5ZjExZjQwOGVmMGQ1N2Qu Ljc2ZTU0NWVhMmUxNjE4NThiYmRlYWNiYjcxNWE0NTJjZDQ5NmFhMmMgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEltcGwuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvSURCRmFjdG9yeUJhY2tlbmRJbXBsLmgKQEAgLTUwLDcgKzUwLDYgQEAgcHVibGljOgogICAg IHZpcnR1YWwgfklEQkZhY3RvcnlCYWNrZW5kSW1wbCgpOwogCiAgICAgdmlydHVhbCB2b2lkIG9w ZW4oY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNzUmVm UHRyPElEQkNhbGxiYWNrcz4sIFBhc3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+LCBGcmFtZSosIGNv bnN0IFN0cmluZyYgZGF0YURpcik7Ci0gICAgdmlydHVhbCB2b2lkIGFib3J0UGVuZGluZ1RyYW5z YWN0aW9ucyhjb25zdCBWZWN0b3I8aW50PiYgcGVuZGluZ0lEcyk7CiAKICAgICBzdGF0aWMgU3Ry aW5nIGRhdGFiYXNlRmlsZU5hbWUoY29uc3QgU3RyaW5nJiBuYW1lLCBTZWN1cml0eU9yaWdpbiop OwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCRmFjdG9yeUJhY2tlbmRJbnRlcmZh Y2UuaCBiL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0b3J5QmFja2VuZEludGVyZmFjZS5oCmluZGV4 IGU1OTEyNzE5ZWY1NDQ5NDQ2ZWE2YmMyMmYzNTY0NjMwNmQ4ZDcwYmQuLjQ5MTQwMjQzZWE2NDBk MDdkYTBmMDkxZGUyOTQ4YzQ2ZTI4YTY4NzIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9J REJGYWN0b3J5QmFja2VuZEludGVyZmFjZS5oCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJGYWN0 b3J5QmFja2VuZEludGVyZmFjZS5oCkBAIC01Miw3ICs1Miw2IEBAIHB1YmxpYzoKICAgICB2aXJ0 dWFsIH5JREJGYWN0b3J5QmFja2VuZEludGVyZmFjZSgpIHsgfQogCiAgICAgdmlydHVhbCB2b2lk IG9wZW4oY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNz UmVmUHRyPElEQkNhbGxiYWNrcz4sIFBhc3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+LCBGcmFtZSos IGNvbnN0IFN0cmluZyYgZGF0YURpcikgPSAwOwotICAgIHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRp bmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4mIGlkcykgPSAwOwogfTsKIAogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0 b3JlLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZS5jcHAKaW5kZXggYjQ1N2Nk MWQxNTg4NmMxMGZiMmUxZjMzNGEzZGMyMmEzZmRmMWM4NS4uNzY4YjkzYzhjNTU4NWJjNTg3OGYw OGZmMmFiOWY5ODc2MjgxZGQ2MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVj dFN0b3JlLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuY3BwCkBAIC0z MSw2ICszMSw3IEBACiAjaW5jbHVkZSAiSURCSW5kZXguaCIKICNpbmNsdWRlICJJREJLZXkuaCIK ICNpbmNsdWRlICJJREJLZXlSYW5nZS5oIgorI2luY2x1ZGUgIklEQlRyYW5zYWN0aW9uQmFja2Vu ZEludGVyZmFjZS5oIgogI2luY2x1ZGUgIlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgogI2luY2x1 ZGUgPHd0Zi9VbnVzZWRQYXJhbS5oPgogCkBAIC0zOCw4ICszOSw5IEBACiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAotSURCT2JqZWN0U3RvcmU6OklEQk9iamVjdFN0b3JlKFBhc3NSZWZQdHI8SURC T2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RTdG9yZSkKK0lEQk9iamVjdFN0 b3JlOjpJREJPYmplY3RTdG9yZShQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZT4gaWRiT2JqZWN0U3RvcmUsIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJh bnNhY3Rpb24pCiAgICAgOiBtX29iamVjdFN0b3JlKGlkYk9iamVjdFN0b3JlKQorICAgICwgbV90 cmFuc2FjdGlvbih0cmFuc2FjdGlvbikKIHsKICAgICAvLyBXZSBwYXNzIGEgcmVmZXJlbmNlIHRv IHRoaXMgb2JqZWN0IGJlZm9yZSBpdCBjYW4gYmUgYWRvcHRlZC4KICAgICByZWxheEFkb3B0aW9u UmVxdWlyZW1lbnQoKTsKQEAgLTYyLDkgKzY0LDkgQEAgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0 PiBJREJPYmplY3RTdG9yZTo6aW5kZXhOYW1lcygpIGNvbnN0CiAKIFBhc3NSZWZQdHI8SURCUmVx dWVzdD4gSURCT2JqZWN0U3RvcmU6OmdldChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0 LCBQYXNzUmVmUHRyPElEQktleT4ga2V5KQogewotICAgIFJlZlB0cjxJREJSZXF1ZXN0PiByZXF1 ZXN0ID0gSURCUmVxdWVzdDo6Y3JlYXRlKGNvbnRleHQsIElEQkFueTo6Y3JlYXRlKHRoaXMpKTsK LSAgICBtX29iamVjdFN0b3JlLT5nZXQoa2V5LCByZXF1ZXN0KTsKLSAgICByZXR1cm4gcmVxdWVz dDsKKyAgICBSZWZQdHI8SURCUmVxdWVzdD4gcmVxdWVzdCA9IElEQlJlcXVlc3Q6OmNyZWF0ZShj b250ZXh0LCBJREJBbnk6OmNyZWF0ZSh0aGlzKSwgbV90cmFuc2FjdGlvbi5nZXQoKSk7CisgICAg bV9vYmplY3RTdG9yZS0+Z2V0KGtleSwgcmVxdWVzdCwgbV90cmFuc2FjdGlvbi5nZXQoKSk7Cisg ICAgcmV0dXJuIHJlcXVlc3QucmVsZWFzZSgpOwogfQogCiBQYXNzUmVmUHRyPElEQlJlcXVlc3Q+ IElEQk9iamVjdFN0b3JlOjphZGQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFz c1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBQYXNzUmVmUHRyPElEQktleT4g a2V5KQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlLmggYi9XZWJD b3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaAppbmRleCAwMzVmNWQ4YjQ3ZmJhODJjYmMzZWQy NDg1YjViNzg4ZTAzMjMxOTI2Li5kZjViM2Y3NTBiOWQ2MjY4Y2Y3MjA5YjcyOTE4NTgyNjk5ZGE0 ZmIyIDEwMDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaAorKysgYi9X ZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmUuaApAQCAtNDMsMTMgKzQzLDE0IEBAIGNsYXNz IERPTVN0cmluZ0xpc3Q7CiBjbGFzcyBJREJBbnk7CiBjbGFzcyBJREJJbmRleFJlcXVlc3Q7CiBj bGFzcyBJREJLZXk7CitjbGFzcyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7CiBjbGFz cyBTZXJpYWxpemVkU2NyaXB0VmFsdWU7CiAKIGNsYXNzIElEQk9iamVjdFN0b3JlIDogcHVibGlj IFJlZkNvdW50ZWQ8SURCT2JqZWN0U3RvcmU+IHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1Jl ZlB0cjxJREJPYmplY3RTdG9yZT4gY3JlYXRlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNr ZW5kSW50ZXJmYWNlPiBpZGJPYmplY3RTdG9yZSkKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJP YmplY3RTdG9yZT4gY3JlYXRlKFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJm YWNlPiBpZGJPYmplY3RTdG9yZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFu c2FjdGlvbikKICAgICB7Ci0gICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgSURCT2JqZWN0U3Rv cmUoaWRiT2JqZWN0U3RvcmUpKTsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBJREJPYmpl Y3RTdG9yZShpZGJPYmplY3RTdG9yZSwgdHJhbnNhY3Rpb24pKTsKICAgICB9CiAgICAgfklEQk9i amVjdFN0b3JlKCkgeyB9CiAKQEAgLTY5LDkgKzcwLDExIEBAIHB1YmxpYzoKICAgICBQYXNzUmVm UHRyPElEQlJlcXVlc3Q+IG9wZW5DdXJzb3IoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NS ZWZQdHI8SURCS2V5UmFuZ2U+ID0gMCwgdW5zaWduZWQgc2hvcnQgZGlyZWN0aW9uID0gSURCQ3Vy c29yOjpORVhUKTsKIAogcHJpdmF0ZToKLSAgICBJREJPYmplY3RTdG9yZShQYXNzUmVmUHRyPElE Qk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4pOworICAgIElEQk9iamVjdFN0b3JlKFBhc3NS ZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiwgSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbik7CisgICAgdm9pZCByZW1vdmVUcmFuc2FjdGlvbkZy b21QZW5kaW5nTGlzdCgpOwogCiAgICAgUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZT4gbV9vYmplY3RTdG9yZTsKKyAgICBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlPiBtX3RyYW5zYWN0aW9uOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwIGIv V2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuY3BwCmluZGV4IGU1Zjgx YWI0ZGMzMzc5ODkyMTA0Mzc1OWJkMmVhODQ3M2EzYjViNWUuLjE4ZDZiMGMyODA2YTI5N2Y5NjI0 ODFkNGY3ZDZhMDNmMTA1ZTQxOGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJPYmpl Y3RTdG9yZUJhY2tlbmRJbXBsLmNwcAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3Rv cmVCYWNrZW5kSW1wbC5jcHAKQEAgLTM2LDYgKzM2LDggQEAKICNpbmNsdWRlICJJREJLZXlQYXRo LmgiCiAjaW5jbHVkZSAiSURCS2V5UGF0aEJhY2tlbmRJbXBsLmgiCiAjaW5jbHVkZSAiSURCS2V5 UmFuZ2UuaCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaCIKKyNp bmNsdWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCiAjaW5jbHVkZSAiU1FMaXRlRGF0YWJh c2UuaCIKICNpbmNsdWRlICJTUUxpdGVTdGF0ZW1lbnQuaCIKICNpbmNsdWRlICJTUUxpdGVUcmFu c2FjdGlvbi5oIgpAQCAtNDQsNiArNDYsMzMgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit0 ZW1wbGF0ZSA8Y2xhc3MgVCwgY2xhc3MgTWV0aG9kLCBjbGFzcyBQYXJhbTEsIGNsYXNzIFBhcmFt Mj4KK2NsYXNzIElEQlRhc2sgOiBwdWJsaWMgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzayB7 CitwdWJsaWM6CisgICAgSURCVGFzayhUKiBvYmosIE1ldGhvZCBtZXRob2QsIGNvbnN0IFBhcmFt MSYgcGFyYW0xLCBjb25zdCBQYXJhbTImIHBhcmFtMikKKyAgICAgICAgOiBtX29iaihvYmopLCBt X21ldGhvZChtZXRob2QpLCBtX3BhcmFtMShwYXJhbTEpLCBtX3BhcmFtMihwYXJhbTIpIAorICAg IHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhlY3V0aW9u Q29udGV4dCopIAorICAgIHsKKyAgICAgICAgaWYgKG1fb2JqKQorICAgICAgICAgICAgKG1fb2Jq LT4qbV9tZXRob2QpKG1fcGFyYW0xLCBtX3BhcmFtMik7CisgICAgfQorCitwcml2YXRlOgorICAg IFQqIG1fb2JqOworICAgIE1ldGhvZCBtX21ldGhvZDsKKyAgICBQYXJhbTEgbV9wYXJhbTE7Cisg ICAgUGFyYW0yIG1fcGFyYW0yOworfTsKKwordGVtcGxhdGUgPGNsYXNzIFQsIGNsYXNzIE1ldGhv ZCwgY2xhc3MgUGFyYW0xLCBjbGFzcyBQYXJhbTI+CitQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2s+IGNyZWF0ZVRhc2soVCogb2JqZWN0LCBNZXRob2QgbWV0aG9kLCBjb25z dCBQYXJhbTEmIHBhcmFtMSwgY29uc3QgUGFyYW0yJiBwYXJhbTIpCit7CisgICAgcmV0dXJuIGFk b3B0UHRyKG5ldyBJREJUYXNrPFQsIE1ldGhvZCwgUGFyYW0xLCBQYXJhbTI+KG9iamVjdCwgbWV0 aG9kLCBwYXJhbTEsIHBhcmFtMikpOworfQorCiBJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjp+ SURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbCgpCiB7CiB9CkBAIC03Nyw3ICsxMDYsMTMgQEAgc3Rh dGljIHZvaWQgYmluZFdoZXJlQ2xhdXNlKFNRTGl0ZVN0YXRlbWVudCYgcXVlcnksIGludDY0X3Qg aWQsIElEQktleSoga2V5KQogICAgIGtleS0+YmluZChxdWVyeSwgMik7CiB9CiAKLXZvaWQgSURC T2JqZWN0U3RvcmVCYWNrZW5kSW1wbDo6Z2V0KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NS ZWZQdHI8SURCQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit2b2lkIElEQk9iamVjdFN0b3JlQmFja2Vu ZEltcGw6OmdldChQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNr cz4gY2FsbGJhY2tzLCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9u KQoreworICAgIGlmICghdHJhbnNhY3Rpb24tPnNjaGVkdWxlVGFzayhjcmVhdGVUYXNrKHRoaXMs ICZJREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsOjpnZXRJbnRlcm5hbCwga2V5LCBjYWxsYmFja3Mp KSkKKyAgICAgICAgY2FsbGJhY2tzLT5vbkVycm9yKElEQkRhdGFiYXNlRXJyb3I6OmNyZWF0ZShJ REJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9UX0FMTE9XRURfRVJSLCAiR2V0IG11c3QgYmUgY2FsbGVk IGluIHRoZSBjb250ZXh0IG9mIGEgdHJhbnNhY3Rpb24uIikpOworfQorCit2b2lkIElEQk9iamVj dFN0b3JlQmFja2VuZEltcGw6OmdldEludGVybmFsKFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBh c3NSZWZQdHI8SURCQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7CiAgICAgU1FMaXRlU3RhdGVtZW50 IHF1ZXJ5KHNxbGl0ZURhdGFiYXNlKCksICJTRUxFQ1Qga2V5U3RyaW5nLCBrZXlEYXRlLCBrZXlO dW1iZXIsIHZhbHVlIEZST00gT2JqZWN0U3RvcmVEYXRhICIgKyB3aGVyZUNsYXVzZShrZXkuZ2V0 KCkpKTsKICAgICBib29sIG9rID0gcXVlcnkucHJlcGFyZSgpID09IFNRTFJlc3VsdE9rOwpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEltcGwuaCBiL1dl YkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbXBsLmgKaW5kZXggMzJlZjkyMDMy MjEzMjlmZTVhZTUyN2UxZTNhNjc5ZWZjY2U5ZWZmZS4uMzZjMDAxNDRhMDdmZDQxODcxMGYxYTRk NWUwZGQ0NzRhNzk1OGFhMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0 b3JlQmFja2VuZEltcGwuaAorKysgYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNr ZW5kSW1wbC5oCkBAIC0zNiw2ICszNiw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3Mg SURCRGF0YWJhc2VCYWNrZW5kSW1wbDsKIGNsYXNzIElEQkluZGV4QmFja2VuZEltcGw7CitjbGFz cyBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U7CiBjbGFzcyBTUUxpdGVEYXRhYmFzZTsK IAogY2xhc3MgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW1wbCA6IHB1YmxpYyBJREJPYmplY3RTdG9y ZUJhY2tlbmRJbnRlcmZhY2UgewpAQCAtNTEsNyArNTIsNyBAQCBwdWJsaWM6CiAgICAgU3RyaW5n IGtleVBhdGgoKSBjb25zdCB7IHJldHVybiBtX2tleVBhdGg7IH0KICAgICBQYXNzUmVmUHRyPERP TVN0cmluZ0xpc3Q+IGluZGV4TmFtZXMoKSBjb25zdDsKIAotICAgIHZvaWQgZ2V0KFBhc3NSZWZQ dHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CisgICAgdm9pZCBnZXQo UGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+LCBJREJUcmFu c2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKTsKICAgICB2b2lkIHB1dChQYXNz UmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5PiBr ZXksIGJvb2wgYWRkT25seSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKICAgICB2b2lkIHJl bW92ZShQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwog CkBAIC02OSw2ICs3MCw4IEBAIHByaXZhdGU6CiAgICAgdm9pZCBsb2FkSW5kZXhlcygpOwogICAg IFNRTGl0ZURhdGFiYXNlJiBzcWxpdGVEYXRhYmFzZSgpIGNvbnN0OwogCisgICAgdm9pZCBnZXRJ bnRlcm5hbChQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4p OworCiAgICAgUmVmUHRyPElEQkRhdGFiYXNlQmFja2VuZEltcGw+IG1fZGF0YWJhc2U7CiAKICAg ICBpbnQ2NF90IG1faWQ7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3Rv cmVCYWNrZW5kSW50ZXJmYWNlLmggYi9XZWJDb3JlL3N0b3JhZ2UvSURCT2JqZWN0U3RvcmVCYWNr ZW5kSW50ZXJmYWNlLmgKaW5kZXggMjAwYWMyOWJhN2NjYTE1OTgxODVlMzU5M2JmYTRkNmZiNjNh MWQ0ZS4uYzE5ODU1Yzc2ZGUxZTYyNTI0Mzg1OTIxNzdlOWMwMWY3NzIzMjE5ZCAxMDA2NDQKLS0t IGEvV2ViQ29yZS9zdG9yYWdlL0lEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZS5oCisrKyBi L1dlYkNvcmUvc3RvcmFnZS9JREJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2UuaApAQCAtMzgs NiArMzgsNyBAQCBjbGFzcyBJREJDYWxsYmFja3M7CiBjbGFzcyBJREJJbmRleEJhY2tlbmRJbnRl cmZhY2U7CiBjbGFzcyBJREJLZXk7CiBjbGFzcyBJREJLZXlSYW5nZTsKK2NsYXNzIElEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZTsKIGNsYXNzIFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZTsKIAog Y2xhc3MgSURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlIDogcHVibGljIFRocmVhZFNhZmVT aGFyZWQ8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiB7CkBAIC00OCw3ICs0OSw3IEBA IHB1YmxpYzoKICAgICB2aXJ0dWFsIFN0cmluZyBrZXlQYXRoKCkgY29uc3QgPSAwOwogICAgIHZp cnR1YWwgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBpbmRleE5hbWVzKCkgY29uc3QgPSAwOwog Ci0gICAgdmlydHVhbCB2b2lkIGdldChQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRy PElEQkNhbGxiYWNrcz4pID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgZ2V0KFBhc3NSZWZQdHI8SURC S2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPiwgSURCVHJhbnNhY3Rpb25CYWNrZW5k SW50ZXJmYWNlKiB0cmFuc2FjdGlvbikgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBwdXQoUGFzc1Jl ZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBQYXNzUmVmUHRyPElEQktleT4ga2V5 LCBib29sIGFkZE9ubHksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPikgPSAwOwogICAgIHZpcnR1 YWwgdm9pZCByZW1vdmUoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxs YmFja3M+KSA9IDA7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJQZW5kaW5nVHJh bnNhY3Rpb25Nb25pdG9yLmNwcCBiL1dlYkNvcmUvc3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rp b25Nb25pdG9yLmNwcAppbmRleCBkMDI2MDk5MDhhYjU3Y2RjMDFkMzk4Njk1ZWIyNjUzNjMyMzYx YTliLi43OTkyMDBkM2QzZDU1NzA3NzczOGIxN2UyMTQ5MjRhNGMyNTQzY2QyIDEwMDY0NAotLS0g YS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5jcHAKKysrIGIv V2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IuY3BwCkBAIC0yNSw0 NyArMjUsNDggQEAKIAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIklEQlBlbmRpbmdU cmFuc2FjdGlvbk1vbml0b3IuaCIKKyNpbmNsdWRlICJJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2UuaCIKIAogI2lmIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKLVZlY3RvcjxpbnQ+KiBJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yOjptX2lk cyA9IDA7CitWZWN0b3I8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKj4qIElEQlBlbmRp bmdUcmFuc2FjdGlvbk1vbml0b3I6Om1fdHJhbnNhY3Rpb25zID0gMDsKIAotYm9vbCBJREJQZW5k aW5nVHJhbnNhY3Rpb25Nb25pdG9yOjpoYXNQZW5kaW5nVHJhbnNhY3Rpb25zKCkKK3ZvaWQgSURC UGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWRkUGVuZGluZ1RyYW5zYWN0aW9uKElEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiB7Ci0gICAgcmV0dXJuIG1faWRz ICYmIG1faWRzLT5zaXplKCk7CisgICAgaWYgKCFtX3RyYW5zYWN0aW9ucykKKyAgICAgICAgbV90 cmFuc2FjdGlvbnMgPSBuZXcgVmVjdG9yPElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSo+ KCk7CisgICAgbV90cmFuc2FjdGlvbnMtPmFwcGVuZCh0cmFuc2FjdGlvbik7CiB9CiAKLXZvaWQg SURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWRkUGVuZGluZ1RyYW5zYWN0aW9uKGludCBp ZCkKK3ZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6cmVtb3ZlUGVuZGluZ1RyYW5z YWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24pCiB7Ci0g ICAgaWYgKCFtX2lkcykKLSAgICAgICAgbV9pZHMgPSBuZXcgVmVjdG9yPGludD4oKTsKLSAgICBt X2lkcy0+YXBwZW5kKGlkKTsKLX0KKyAgICBpZiAoIW1fdHJhbnNhY3Rpb25zKQorICAgICAgICBy ZXR1cm47CiAKLXZvaWQgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6cmVtb3ZlUGVuZGlu Z1RyYW5zYWN0aW9uKGludCBpZCkKLXsKLSAgICBtX2lkcy0+cmVtb3ZlKGlkKTsKLSAgICBpZiAo IW1faWRzLT5zaXplKCkpIHsKLSAgICAgICAgZGVsZXRlIG1faWRzOwotICAgICAgICBtX2lkcyA9 IDA7CisgICAgc2l6ZV90IHBvcyA9IG1fdHJhbnNhY3Rpb25zLT5maW5kKHRyYW5zYWN0aW9uKTsK KyAgICBpZiAocG9zID09IG5vdEZvdW5kKQorICAgICAgICByZXR1cm47CisKKyAgICBtX3RyYW5z YWN0aW9ucy0+cmVtb3ZlKHBvcyk7CisKKyAgICBpZiAoIW1fdHJhbnNhY3Rpb25zLT5zaXplKCkp IHsKKyAgICAgICAgZGVsZXRlIG1fdHJhbnNhY3Rpb25zOworICAgICAgICBtX3RyYW5zYWN0aW9u cyA9IDA7CiAgICAgfQogfQogCi12b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OmNs ZWFyUGVuZGluZ1RyYW5zYWN0aW9ucygpCit2b2lkIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0 b3I6OmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucygpCiB7Ci0gICAgaWYgKCFtX2lkcykKKyAgICBp ZiAoIW1fdHJhbnNhY3Rpb25zKQogICAgICAgICByZXR1cm47CiAKLSAgICBtX2lkcy0+Y2xlYXIo KTsKLSAgICBkZWxldGUgbV9pZHM7Ci0gICAgbV9pZHMgPSAwOwotfQorICAgIGZvciAoc2l6ZV90 IGkgPSAwOyBpIDwgbV90cmFuc2FjdGlvbnMtPnNpemUoKTsgKytpKQorICAgICAgICBtX3RyYW5z YWN0aW9ucy0+YXQoaSktPmFib3J0KCk7CiAKLWNvbnN0IFZlY3RvcjxpbnQ+JiBJREJQZW5kaW5n VHJhbnNhY3Rpb25Nb25pdG9yOjpwZW5kaW5nVHJhbnNhY3Rpb25zKCkKLXsKLSAgICByZXR1cm4g Km1faWRzOworICAgIGRlbGV0ZSBtX3RyYW5zYWN0aW9uczsKKyAgICBtX3RyYW5zYWN0aW9ucyA9 IDA7CiB9CiAKIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5z YWN0aW9uTW9uaXRvci5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlBlbmRpbmdUcmFuc2FjdGlvbk1v bml0b3IuaAppbmRleCAwMGU4MzNhZmIyMjE4NTNiZDk5YjM5Mzg0MTUxNjBmM2RjYzdjNmY2Li43 ODNhNzMxMGZlM2ExMWUxMTFkNWI2YjE3YWZiYjkwNWUzMDNkYjI5IDEwMDY0NAotLS0gYS9XZWJD b3JlL3N0b3JhZ2UvSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvci5oCisrKyBiL1dlYkNvcmUv c3RvcmFnZS9JREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgKQEAgLTMzLDI3ICszMywyNyBA QAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIElEQlRyYW5zYWN0aW9uQmFja2VuZElu dGVyZmFjZTsKKwogLy8gVGhpcyBjbGFzcyBrZWVwcyB0cmFjayBvZiB0aGUgdHJhbnNhY3Rpb25z IGNyZWF0ZWQgZHVyaW5nIHRoZSBjdXJyZW50CiAvLyBKYXZhc2NyaXB0IGV4ZWN1dGlvbiBjb250 ZXh0LiBBIHRyYW5zYWN0aW9uIGlzICdwZW5kaW5nJyBpZiBubyBhc3luY2hyb25vdXMKIC8vIG9w ZXJhdGlvbiBpcyBjdXJyZW50bHkgcXVldWVkIGZvciBpdCAoZS5nLiBhbiBJREJPYmplY3RTdG9y ZTo6cHV0KCkgb3Igc2ltaWxhcikuCiAvLyBBbGwgcGVuZGluZyB0cmFuc2FjdGlvbnMgYXJlIGFi b3J0ZWQgYXMgc29vbiBhcyBleGVjdXRpb24gcmV0dXJucyBmcm9tCiAvLyB0aGUgc2NyaXB0IGVu Z2luZS4KIC8vCi0vLyBGSVhNRTogbW92ZSB0aGUgdmVjdG9yIG9mIHRyYW5zYWN0aW9uIElEcyB0 byBUTFMuIEtlZXBpbmcgaXQgc3RhdGljCisvLyBGSVhNRTogbW92ZSB0aGUgdmVjdG9yIG9mIHRy YW5zYWN0aW9ucyB0byBUTFMuIEtlZXBpbmcgaXQgc3RhdGljCiAvLyB3aWxsIG5vdCB3b3JrIG9u Y2Ugd2UgYWRkIHN1cHBvcnQgZm9yIHdvcmtlcnMuIEFub3RoZXIgcG9zc2libGUKIC8vIHNvbHV0 aW9uIGlzIHRvIGtlZXAgdGhlIHZlY3RvciBpbiB0aGUgU2NyaXB0RXhlY3V0aW9uQ29udGV4dC4K IGNsYXNzIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IgOiBwdWJsaWMgTm9uY29weWFibGUg ewogcHVibGljOgotICAgIHN0YXRpYyBib29sIGhhc1BlbmRpbmdUcmFuc2FjdGlvbnMoKTsKLSAg ICBzdGF0aWMgdm9pZCBhZGRQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKTsKLSAgICBzdGF0aWMg dm9pZCByZW1vdmVQZW5kaW5nVHJhbnNhY3Rpb24oaW50IGlkKTsKLSAgICBzdGF0aWMgdm9pZCBj bGVhclBlbmRpbmdUcmFuc2FjdGlvbnMoKTsKLSAgICBzdGF0aWMgY29uc3QgVmVjdG9yPGludD4m IHBlbmRpbmdUcmFuc2FjdGlvbnMoKTsKKyAgICBzdGF0aWMgdm9pZCBhZGRQZW5kaW5nVHJhbnNh Y3Rpb24oSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKik7CisgICAgc3RhdGljIHZvaWQg cmVtb3ZlUGVuZGluZ1RyYW5zYWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSop OworICAgIHN0YXRpYyB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucygpOwogCiBwcml2YXRl OgogICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3IoKTsKIAotICAgIHN0YXRpYyBWZWN0 b3I8aW50PiogbV9pZHM7CisgICAgc3RhdGljIFZlY3RvcjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bnRlcmZhY2UqPiogbV90cmFuc2FjdGlvbnM7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5jcHAgYi9XZWJDb3JlL3N0 b3JhZ2UvSURCUmVxdWVzdC5jcHAKaW5kZXggNmZiZGEwZWVjODllYjJhYTA5YzIwYzNiZDEzZjBl OGRkNjM5YmU2NC4uYTc3NjBmNDliOTQ4MzY2NzBlYzkwMTY4NDdkM2E5NTJkM2MzMzA4YSAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlJlcXVlc3QuY3BwCisrKyBiL1dlYkNvcmUvc3Rv cmFnZS9JREJSZXF1ZXN0LmNwcApAQCAtNDAsMjIgKzQwLDM1IEBACiAjaW5jbHVkZSAiSURCSW5k ZXguaCIKICNpbmNsdWRlICJJREJFcnJvckV2ZW50LmgiCiAjaW5jbHVkZSAiSURCT2JqZWN0U3Rv cmUuaCIKKyNpbmNsdWRlICJJREJQZW5kaW5nVHJhbnNhY3Rpb25Nb25pdG9yLmgiCiAjaW5jbHVk ZSAiSURCU3VjY2Vzc0V2ZW50LmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5o IgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLUlEQlJlcXVlc3Q6OklEQlJlcXVlc3QoU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJBbnk+IHNvdXJjZSkKK0lE QlJlcXVlc3Q6OklEQlJlcXVlc3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFz c1JlZlB0cjxJREJBbnk+IHNvdXJjZSwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0 cmFuc2FjdGlvbikKICAgICA6IEFjdGl2ZURPTU9iamVjdChjb250ZXh0LCB0aGlzKQogICAgICwg bV9zb3VyY2Uoc291cmNlKQorICAgICwgbV90cmFuc2FjdGlvbih0cmFuc2FjdGlvbikKICAgICAs IG1fdGltZXIodGhpcywgJklEQlJlcXVlc3Q6OnRpbWVyRmlyZWQpCiAgICAgLCBtX2Fib3J0ZWQo ZmFsc2UpCiAgICAgLCBtX3JlYWR5U3RhdGUoTE9BRElORykKIHsKKyAgICBpZiAodHJhbnNhY3Rp b24pCisgICAgICAgIElEQlBlbmRpbmdUcmFuc2FjdGlvbk1vbml0b3I6OnJlbW92ZVBlbmRpbmdU cmFuc2FjdGlvbih0cmFuc2FjdGlvbik7CiB9CiAKIElEQlJlcXVlc3Q6On5JREJSZXF1ZXN0KCkK IHsKKyAgICAvLyBUaGUgdHJhbnNhY3Rpb24gcG9pbnRlciBpcyB1c2VkIHRvIG5vdGlmeSB0aGUg dHJhbnNhY3Rpb24gb25jZSB0aGUgSlMgZXZlbnRzIHdlcmUKKyAgICAvLyBkaXNwYXRjaGVkIGJ5 IHRoaXMgcmVxdWVzdCBvYmplY3QuIElmIG5vIG5ldyB0YXNrcyB3ZXJlIGFkZGVkIGJ5IHRoZSBl dmVudCBKUyBjYWxsYmFja3MsCisgICAgLy8gdGhlIHRyYW5zYWN0aW9uIGNhbiBjb21taXQuIE90 aGVyd2lzZSwgaXQgY2FuIGNvbnRpbnVlIGV4ZWN1dGluZyB0aGUgbmV3IHRhc2tzLgorICAgIC8v IEl0IGlzIGltcG9ydGFudCB0byBndWFyYW50ZWUgdGhhdCB0aGUgdHJhbnNhY3Rpb24gaXMgbm90 aWZpZWQgYWZ0ZXIgdGhlIGV2ZW50cyBhcmUKKyAgICAvLyBkaXNwYXRjaGVkLCBhcyB0aGUgdHJh bnNhY3Rpb24gY2Fubm90IGNvbW1pdCBvciBleGVjdXRlIG5ldyB0YXNrcyBpbiB0aGUgYWJzZW5j ZQorICAgIC8vIG9mIHRoZXNlIG5vdGlmaWNhdGlvbnMuIFdlIGNsZWFyIHRoZSB0cmFuc2FjdGlv biBwb2ludGVyIG9uY2UgdGhlIGV2ZW50cyBoYXZlIGRpc3BhdGNoZWQsCisgICAgLy8gc28gaGF2 aW5nIGEgbm9uLXplcm8gcG9pbnRlciBhdCBJREJSZXF1ZXN0IGRlc3RydWN0aW9uIHRpbWUgc2hv d3MgdGhhdCB0aGUgZXZlbnRzIGhhdmUgbm90CisgICAgLy8geWV0IGZpcmVkIGFuZCB0aGVyZSBp cyBhIHRyYW5zYWN0aW9uIHdhaXRpbmcgdG8gYmUgbm90aWZpZWQuIFRoaXMgaXMgYW4gZXJyb3Iu CisgICAgQVNTRVJUKCFtX3RyYW5zYWN0aW9uKTsKICAgICBhYm9ydCgpOwogfQogCkBAIC0xMDAs NyArMTEzLDkgQEAgdm9pZCBJREJSZXF1ZXN0OjpvblN1Y2Nlc3MoUGFzc1JlZlB0cjxJREJLZXk+ IGlkYktleSkKIAogdm9pZCBJREJSZXF1ZXN0OjpvblN1Y2Nlc3MoUGFzc1JlZlB0cjxJREJPYmpl Y3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IGJhY2tlbmQpCiB7Ci0gICAgc2NoZWR1bGVFdmVudChJ REJBbnk6OmNyZWF0ZShJREJPYmplY3RTdG9yZTo6Y3JlYXRlKGJhY2tlbmQpKSwgMCk7CisgICAg Ly8gRklYTUU6IHRoZSB0cmFuc2FjdGlvbiBwb2ludGVyIHNob3VsZCBiZSB0aGUgb25lIG9mIHRo ZSBzZXRWZXJzaW9uIHRyYW5zYWN0aW9uLiBUaGlzIGlzIGJlY2F1c2UKKyAgICAvLyB0aGlzIGNh bGxiYWNrIGlzIG9ubHkgZXhlY3V0ZWQgZm9yIG9wZXJhdGlvbnMgdGhhdCBuZWVuIHRvIHJ1biBp biBhIHNldFZlcnNpb24gdHJhbnNhY3Rpb24uCisgICAgc2NoZWR1bGVFdmVudChJREJBbnk6OmNy ZWF0ZShJREJPYmplY3RTdG9yZTo6Y3JlYXRlKGJhY2tlbmQsIDApKSwgMCk7CiB9CiAKIHZvaWQg SURCUmVxdWVzdDo6b25TdWNjZXNzKFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBz ZXJpYWxpemVkU2NyaXB0VmFsdWUpCkBAIC0xNjEsNiArMTc2LDEzIEBAIHZvaWQgSURCUmVxdWVz dDo6dGltZXJGaXJlZChUaW1lcjxJREJSZXF1ZXN0PiopCiAgICAgICAgICAgICBkaXNwYXRjaEV2 ZW50KElEQlN1Y2Nlc3NFdmVudDo6Y3JlYXRlKG1fc291cmNlLCBwZW5kaW5nRXZlbnRzW2ldLm1f cmVzdWx0KSk7CiAgICAgICAgIH0KICAgICB9CisgICAgaWYgKG1fdHJhbnNhY3Rpb24pIHsKKyAg ICAgICAgLy8gTm93IHRoYXQgd2UgcHJvY2Vzc2VkIGFsbCBwZW5kaW5nIGV2ZW50cywgbGV0IHRo ZSB0cmFuc2FjdGlvbiBtb25pdG9yIGNoZWNrIGlmCisgICAgICAgIC8vIGl0IGNhbiBjb21taXQg dGhlIGN1cnJlbnQgdHJhbnNhY3Rpb24gb3IgaWYgdGhlcmUncyBhbnl0aGluZyBuZXcgcGVuZGlu Zy4KKyAgICAgICAgLy8gRklYTUU6IEhhbmRsZSB0aGUgd29ya2VycyBjYXNlLgorICAgICAgICBt X3RyYW5zYWN0aW9uLT5kaWRDb21wbGV0ZVRhc2tFdmVudHMoKTsKKyAgICAgICAgbV90cmFuc2Fj dGlvbi5jbGVhcigpOworICAgIH0KIH0KIAogdm9pZCBJREJSZXF1ZXN0OjpzY2hlZHVsZUV2ZW50 KFBhc3NSZWZQdHI8SURCQW55PiByZXN1bHQsIFBhc3NSZWZQdHI8SURCRGF0YWJhc2VFcnJvcj4g ZXJyb3IpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5oIGIvV2ViQ29y ZS9zdG9yYWdlL0lEQlJlcXVlc3QuaAppbmRleCA5YjBlYTdlYWYyMWNiZWEyM2U2YmQ0YTgwNzgx NTJkODkzMzdjN2QyLi5jMDUxNWFhZTI2NjBjNDYzY2E5YTg0MWE3YWM3OTk1ZDRmZjM4OWU4IDEw MDY0NAotLS0gYS9XZWJDb3JlL3N0b3JhZ2UvSURCUmVxdWVzdC5oCisrKyBiL1dlYkNvcmUvc3Rv cmFnZS9JREJSZXF1ZXN0LmgKQEAgLTQyLDkgKzQyLDExIEBACiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAorY2xhc3MgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlOworCiBjbGFzcyBJREJS ZXF1ZXN0IDogcHVibGljIElEQkNhbGxiYWNrcywgcHVibGljIEV2ZW50VGFyZ2V0LCBwdWJsaWMg QWN0aXZlRE9NT2JqZWN0IHsKIHB1YmxpYzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJSZXF1 ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJ REJBbnk+IHNvdXJjZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IElEQlJlcXVlc3QoY29udGV4dCwg c291cmNlKSk7IH0KKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJSZXF1ZXN0PiBjcmVhdGUoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJBbnk+IHNvdXJjZSwg SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKiB0cmFuc2FjdGlvbiA9IDApIHsgcmV0dXJu IGFkb3B0UmVmKG5ldyBJREJSZXF1ZXN0KGNvbnRleHQsIHNvdXJjZSwgdHJhbnNhY3Rpb24pKTsg fQogICAgIHZpcnR1YWwgfklEQlJlcXVlc3QoKTsKIAogICAgIC8vIERlZmluZWQgaW4gdGhlIElE TApAQCAtODAsNyArODIsNyBAQCBwdWJsaWM6CiAgICAgdXNpbmcgUmVmQ291bnRlZDxJREJDYWxs YmFja3M+OjpkZXJlZjsKIAogcHJpdmF0ZToKLSAgICBJREJSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlKTsKKyAgICBJREJSZXF1ZXN0KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPElEQkFueT4gc291cmNlLCBJREJUcmFu c2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UqIHRyYW5zYWN0aW9uKTsKIAogICAgIHZvaWQgdGltZXJG aXJlZChUaW1lcjxJREJSZXF1ZXN0PiopOwogICAgIHZvaWQgc2NoZWR1bGVFdmVudChQYXNzUmVm UHRyPElEQkFueT4gcmVzdWx0LCBQYXNzUmVmUHRyPElEQkRhdGFiYXNlRXJyb3I+KTsKQEAgLTky LDYgKzk0LDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIEV2ZW50VGFyZ2V0RGF0YSogZW5zdXJl RXZlbnRUYXJnZXREYXRhKCk7CiAKICAgICBSZWZQdHI8SURCQW55PiBtX3NvdXJjZTsKKyAgICBS ZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBtX3RyYW5zYWN0aW9uOwogCiAg ICAgc3RydWN0IFBlbmRpbmdFdmVudCB7CiAgICAgICAgIFJlZlB0cjxJREJBbnk+IG1fcmVzdWx0 OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uLmNwcCBiL1dlYkNv cmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbi5jcHAKaW5kZXggNGU5MzM3OGRkYjdiZWIyYjJiODc1 MzRiZTY3YjM3NGRkMzM4NDk1OC4uZWQ3NjI4MWY2MjdhNmRkNDcxYzA4NTY5Nzc1MTZjMjIwMTk5 ZDY3OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uLmNwcAorKysg Yi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb24uY3BwCkBAIC0zMiw2ICszMiw3IEBACiAj aW5jbHVkZSAiRXZlbnRFeGNlcHRpb24uaCIKICNpbmNsdWRlICJJREJBYm9ydEV2ZW50LmgiCiAj aW5jbHVkZSAiSURCRGF0YWJhc2UuaCIKKyNpbmNsdWRlICJJREJEYXRhYmFzZUV4Y2VwdGlvbi5o IgogI2luY2x1ZGUgIklEQk9iamVjdFN0b3JlLmgiCiAjaW5jbHVkZSAiSURCT2JqZWN0U3RvcmVC YWNrZW5kSW50ZXJmYWNlLmgiCiAjaW5jbHVkZSAiSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRv ci5oIgpAQCAtNDYsNyArNDcsNyBAQCBJREJUcmFuc2FjdGlvbjo6SURCVHJhbnNhY3Rpb24oU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxJREJUcgogICAgICwgbV9z dG9wcGVkKGZhbHNlKQogICAgICwgbV90aW1lcih0aGlzLCAmSURCVHJhbnNhY3Rpb246OnRpbWVy RmlyZWQpCiB7Ci0gICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9uaXRvcjo6YWRkUGVuZGluZ1Ry YW5zYWN0aW9uKG1fYmFja2VuZC0+aWQoKSk7CisgICAgSURCUGVuZGluZ1RyYW5zYWN0aW9uTW9u aXRvcjo6YWRkUGVuZGluZ1RyYW5zYWN0aW9uKG1fYmFja2VuZC5nZXQoKSk7CiB9CiAKIElEQlRy YW5zYWN0aW9uOjp+SURCVHJhbnNhY3Rpb24oKQpAQCAtNjYsNyArNjcsMTEgQEAgSURCRGF0YWJh c2UqIElEQlRyYW5zYWN0aW9uOjpkYigpCiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBJREJU cmFuc2FjdGlvbjo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBFeGNlcHRp b25Db2RlJikKIHsKICAgICBSZWZQdHI8SURCT2JqZWN0U3RvcmVCYWNrZW5kSW50ZXJmYWNlPiBv YmplY3RTdG9yZUJhY2tlbmQgPSBtX2JhY2tlbmQtPm9iamVjdFN0b3JlKG5hbWUpOwotICAgIFJl ZlB0cjxJREJPYmplY3RTdG9yZT4gb2JqZWN0U3RvcmUgPSBJREJPYmplY3RTdG9yZTo6Y3JlYXRl KG9iamVjdFN0b3JlQmFja2VuZCk7CisgICAgaWYgKCFvYmplY3RTdG9yZUJhY2tlbmQpIHsKKyAg ICAgICAgdGhyb3dFcnJvcihJREJEYXRhYmFzZUV4Y2VwdGlvbjo6Tk9UX0FMTE9XRURfRVJSKTsK KyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorICAgIFJlZlB0cjxJREJPYmplY3RTdG9yZT4gb2Jq ZWN0U3RvcmUgPSBJREJPYmplY3RTdG9yZTo6Y3JlYXRlKG9iamVjdFN0b3JlQmFja2VuZCwgbV9i YWNrZW5kLmdldCgpKTsKICAgICByZXR1cm4gb2JqZWN0U3RvcmUucmVsZWFzZSgpOwogfQogCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5jcHAg Yi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5jcHAKaW5kZXggNTFi MzNiMjM0MDAxNDc3ZjNiNjI5ZDRmNTQ4MjIyODAzNGRjODFkMC4uNGYxODQzN2YwYmU0NGVmYzY5 MmY2MWE3Y2M4MjA3NmU4Y2I3NDVlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRy YW5zYWN0aW9uQmFja2VuZEltcGwuY3BwCisrKyBiL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2Fj dGlvbkJhY2tlbmRJbXBsLmNwcApAQCAtMjksMTEgKzI5LDEyIEBACiAjaWYgRU5BQkxFKElOREVY RURfREFUQUJBU0UpCiAKICNpbmNsdWRlICJJREJEYXRhYmFzZUJhY2tlbmRJbXBsLmgiCisjaW5j bHVkZSAiSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oIgogI2luY2x1ZGUgIlNRTGl0ZURhdGFi YXNlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlv bkJhY2tlbmRJbnRlcmZhY2U+IElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OmNyZWF0ZShET01T dHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxv bmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKiBkYXRhYmFzZSkKK1Bh c3NSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4gSURCVHJhbnNhY3Rpb25CYWNrZW5k SW1wbDo6Y3JlYXRlKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3JlcywgdW5zaWduZWQgc2hvcnQg bW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBpbnQgaWQsIElEQkRhdGFiYXNlQmFja2VuZElt cGwqIGRhdGFiYXNlKQogewogICAgIHJldHVybiBhZG9wdFJlZihuZXcgSURCVHJhbnNhY3Rpb25C YWNrZW5kSW1wbChvYmplY3RTdG9yZXMsIG1vZGUsIHRpbWVvdXQsIGlkLCBkYXRhYmFzZSkpOwog fQpAQCAtNDMsMjYgKzQ0LDEwNCBAQCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjpJREJUcmFu c2FjdGlvbkJhY2tlbmRJbXBsKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3JlcwogICAgICwgbV9t b2RlKG1vZGUpCiAgICAgLCBtX3RpbWVvdXQodGltZW91dCkKICAgICAsIG1faWQoaWQpCi0gICAg LCBtX2Fib3J0ZWQoZmFsc2UpCisgICAgLCBtX3N0YXRlKE5vdFN0YXJ0ZWQpCiAgICAgLCBtX2Rh dGFiYXNlKGRhdGFiYXNlKQorICAgICwgbV90cmFuc2FjdGlvbihuZXcgU1FMaXRlVHJhbnNhY3Rp b24oZGF0YWJhc2UtPnNxbGl0ZURhdGFiYXNlKCkpKQorICAgICwgbV90aW1lcih0aGlzLCAmSURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6dGltZXJGaXJlZCkKKyAgICAsIG1fcGVuZGluZ0V2ZW50 cygwKQogewogfQogCiBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4g SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6b2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1l KQogeworICAgIGlmIChpc0ZpbmlzaGVkKCkpCisgICAgICAgIHJldHVybiAwOwogICAgIHJldHVy biBtX2RhdGFiYXNlLT5vYmplY3RTdG9yZShuYW1lLCAwKTsgLy8gRklYTUU6IHJlbW92ZSBtb2Rl IHBhcmFtLgogfQogCi12b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnNjaGVkdWxlVGFz ayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KQorYm9vbCBJREJUcmFu c2FjdGlvbkJhY2tlbmRJbXBsOjpzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPiB0YXNrKQogewotICAgIC8vIEZJWE1FOiBpbXBsZW1lbnQuCi0gICAg QVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgaWYgKGlzRmluaXNoZWQoKSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworCisgICAgbV90YXNrUXVldWUuYXBwZW5kKHRhc2spOworICAgIGlmIChtX3N0 YXRlID09IE5vdFN0YXJ0ZWQpCisgICAgICAgIHN0YXJ0KCk7CisKKyAgICByZXR1cm4gdHJ1ZTsK IH0KIAogdm9pZCBJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsOjphYm9ydCgpCiB7Ci0gICAgbV9h Ym9ydGVkID0gdHJ1ZTsKKyAgICBpZiAoaXNGaW5pc2hlZCgpKQorICAgICAgICByZXR1cm47CisK KyAgICBtX3N0YXRlID0gRmluaXNoZWQ7CisgICAgbV90cmFuc2FjdGlvbi0+cm9sbGJhY2soKTsK ICAgICBtX2NhbGxiYWNrcy0+b25BYm9ydCgpOworICAgIG1fZGF0YWJhc2UtPnRyYW5zYWN0aW9u Q29vcmRpbmF0b3IoKS0+ZGlkRmluaXNoVHJhbnNhY3Rpb24odGhpcyk7Cit9CisKK3ZvaWQgSURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6ZGlkQ29tcGxldGVUYXNrRXZlbnRzKCkKK3sKKyAgICBB U1NFUlQobV9zdGF0ZSA9PSBTdGFydGVkKTsKKyAgICBBU1NFUlQobV9wZW5kaW5nRXZlbnRzKTsK KworICAgIG1fcGVuZGluZ0V2ZW50cy0tOworCisgICAgaWYgKCFtX3BlbmRpbmdFdmVudHMgJiYg bV90YXNrUXVldWUuaXNFbXB0eSgpKSB7CisgICAgICAgIC8vIFRoZSBsYXN0IHRhc2sgZXZlbnQg aGFzIGNvbXBsZXRlZCBhbmQgdGhlIHRhc2sKKyAgICAgICAgLy8gcXVldWUgaXMgZW1wdHkuIENv bW1pdCB0aGUgdHJhbnNhY3Rpb24uCisgICAgICAgIGNvbW1pdCgpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgLy8gV2UgYXJlIHN0aWxsIHdhaXRpbmcgZm9yIG90aGVyIGV2ZW50cyB0 byBjb21wbGV0ZS4gSG93ZXZlciwKKyAgICAvLyB0aGUgdGFzayBxdWV1ZSBpcyBub24tZW1wdHkg YW5kIHRoZSB0aW1lciBpcyBpbmFjdGl2ZS4KKyAgICAvLyBXZSBjYW4gdGhlcmZvcmUgc2NoZWR1 bGUgdGhlIHRpbWVyIGFnYWluLgorICAgIGlmICghbV90YXNrUXVldWUuaXNFbXB0eSgpICYmICFt X3RpbWVyLmlzQWN0aXZlKCkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworfQor Cit2b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnJ1bigpCit7CisgICAgQVNTRVJUKG1f c3RhdGUgPT0gU3RhcnRlZCk7CisgICAgQVNTRVJUKCFtX3RpbWVyLmlzQWN0aXZlKCkpOworCisg ICAgbV90aW1lci5zdGFydE9uZVNob3QoMCk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNr ZW5kSW1wbDo6c3RhcnQoKQoreworICAgIEFTU0VSVChtX3N0YXRlID09IE5vdFN0YXJ0ZWQpOwor CisgICAgbV9zdGF0ZSA9IFN0YXJ0ZWQ7CisgICAgbV90cmFuc2FjdGlvbi0+YmVnaW4oKTsKKyAg ICBtX2RhdGFiYXNlLT50cmFuc2FjdGlvbkNvb3JkaW5hdG9yKCktPmRpZFN0YXJ0VHJhbnNhY3Rp b24odGhpcyk7Cit9CisKK3ZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbDo6Y29tbWl0KCkK K3sKKyAgICBBU1NFUlQobV9zdGF0ZSA9PSBTdGFydGVkKTsKKworICAgIG1fc3RhdGUgPSBGaW5p c2hlZDsKKyAgICBtX3RyYW5zYWN0aW9uLT5jb21taXQoKTsKKyAgICBtX2RhdGFiYXNlLT50cmFu c2FjdGlvbkNvb3JkaW5hdG9yKCktPmRpZEZpbmlzaFRyYW5zYWN0aW9uKHRoaXMpOworfQorCit2 b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw6OnRpbWVyRmlyZWQoVGltZXI8SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbD4qKQoreworICAgIEFTU0VSVCghbV90YXNrUXVldWUuaXNFbXB0eSgp KTsKKyAgICBBU1NFUlQobV9zdGF0ZSA9PSBTdGFydGVkKTsKKworICAgIFRhc2tRdWV1ZSBxdWV1 ZTsKKyAgICBxdWV1ZS5zd2FwKG1fdGFza1F1ZXVlKTsKKyAgICB3aGlsZSAoIXF1ZXVlLmlzRW1w dHkoKSkgeworICAgICAgICBPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFz ayhxdWV1ZS5maXJzdCgpLnJlbGVhc2UoKSk7CisgICAgICAgIHF1ZXVlLnJlbW92ZUZpcnN0KCk7 CisgICAgICAgIG1fcGVuZGluZ0V2ZW50cysrOworICAgICAgICB0YXNrLT5wZXJmb3JtVGFzaygw KTsKKyAgICB9CiB9CiAKIH07CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNh Y3Rpb25CYWNrZW5kSW1wbC5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2Vu ZEltcGwuaAppbmRleCBmYjU3NDAxN2ZhYmU1MjQzZWI1ZDdjMTdhODJiMGEyNWU2MjhlMDg3Li42 ZDlhM2FjNTJiNzY4YTc2ZTFhOThiNDUzZWM5OThhYWY4YjY2NzFmIDEwMDY0NAotLS0gYS9XZWJD b3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbC5oCisrKyBiL1dlYkNvcmUvc3Rv cmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsLmgKQEAgLTMxLDYgKzMxLDggQEAKICNpbmNs dWRlICJET01TdHJpbmdMaXN0LmgiCiAjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlLmgiCiAjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25DYWxsYmFja3MuaCIKKyNpbmNsdWRl IDxTUUxpdGVUcmFuc2FjdGlvbi5oPgorI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUg PHd0Zi9SZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzksMjYgKzQxLDUxIEBA IGNsYXNzIElEQkRhdGFiYXNlQmFja2VuZEltcGw7CiAKIGNsYXNzIElEQlRyYW5zYWN0aW9uQmFj a2VuZEltcGwgOiBwdWJsaWMgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlIHsKIHB1Ymxp YzoKLSAgICBzdGF0aWMgUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+ IGNyZWF0ZShET01TdHJpbmdMaXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUs IHVuc2lnbmVkIGxvbmcgdGltZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKik7 Ci0gICAgdmlydHVhbCB+SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCgpIHsgfQorICAgIHN0YXRp YyBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw+IGNyZWF0ZShET01TdHJpbmdM aXN0KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGlt ZW91dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKik7CisgICAgdmlydHVhbCB+SURC VHJhbnNhY3Rpb25CYWNrZW5kSW1wbCgpIHsgYWJvcnQoKTsgfQogCiAgICAgdmlydHVhbCBQYXNz UmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVyZmFjZT4gb2JqZWN0U3RvcmUoY29uc3Qg U3RyaW5nJiBuYW1lKTsKICAgICB2aXJ0dWFsIHVuc2lnbmVkIHNob3J0IG1vZGUoKSBjb25zdCB7 IHJldHVybiBtX21vZGU7IH0KLSAgICB2aXJ0dWFsIHZvaWQgc2NoZWR1bGVUYXNrKFBhc3NPd25Q dHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOworICAgIHZpcnR1YWwgYm9vbCBzY2hl ZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7CisgICAg dmlydHVhbCB2b2lkIGRpZENvbXBsZXRlVGFza0V2ZW50cygpOwogICAgIHZpcnR1YWwgdm9pZCBh Ym9ydCgpOwogICAgIHZpcnR1YWwgaW50IGlkKCkgY29uc3QgeyByZXR1cm4gbV9pZDsgfQogICAg IHZpcnR1YWwgdm9pZCBzZXRDYWxsYmFja3MoSURCVHJhbnNhY3Rpb25DYWxsYmFja3MqIGNhbGxi YWNrcykgeyBtX2NhbGxiYWNrcyA9IGNhbGxiYWNrczsgfQogCisgICAgdm9pZCBydW4oKTsKKyAg ICBib29sIGlzRmluaXNoZWQoKSBjb25zdCB7IHJldHVybiBtX3N0YXRlID09IEZpbmlzaGVkOyB9 CisKIHByaXZhdGU6CiAgICAgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbChET01TdHJpbmdMaXN0 KiBvYmplY3RTdG9yZXMsIHVuc2lnbmVkIHNob3J0IG1vZGUsIHVuc2lnbmVkIGxvbmcgdGltZW91 dCwgaW50IGlkLCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKik7CiAKKyAgICBlbnVtIFN0YXRlIHsK KyAgICAgICAgTm90U3RhcnRlZCwKKyAgICAgICAgU3RhcnRlZCwKKyAgICAgICAgRmluaXNoZWQs CisgICAgfTsKKworICAgIHZvaWQgc3RhcnQoKTsKKyAgICB2b2lkIGNvbW1pdCgpOworCisgICAg dm9pZCB0aW1lckZpcmVkKFRpbWVyPElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw+Kik7CisKICAg ICBSZWZQdHI8RE9NU3RyaW5nTGlzdD4gbV9vYmplY3RTdG9yZU5hbWVzOwogICAgIHVuc2lnbmVk IHNob3J0IG1fbW9kZTsKICAgICB1bnNpZ25lZCBsb25nIG1fdGltZW91dDsKICAgICBpbnQgbV9p ZDsKLSAgICBib29sIG1fYWJvcnRlZDsKKworICAgIFN0YXRlIG1fc3RhdGU7CiAgICAgUmVmUHRy PElEQlRyYW5zYWN0aW9uQ2FsbGJhY2tzPiBtX2NhbGxiYWNrczsKICAgICBSZWZQdHI8SURCRGF0 YWJhc2VCYWNrZW5kSW1wbD4gbV9kYXRhYmFzZTsKKworICAgIHR5cGVkZWYgRGVxdWU8T3duUHRy PFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+ID4gVGFza1F1ZXVlOworICAgIFRhc2tRdWV1 ZSBtX3Rhc2tRdWV1ZTsKKworICAgIE93blB0cjxTUUxpdGVUcmFuc2FjdGlvbj4gbV90cmFuc2Fj dGlvbjsKKworICAgIC8vIEZJWE1FOiBkZWxldGUgdGhlIHRpbWVyIG9uY2Ugd2UgaGF2ZSB0aHJl YWRzIGluc3RlYWQuCisgICAgVGltZXI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4gbV90aW1l cjsKKyAgICBpbnQgbV9wZW5kaW5nRXZlbnRzOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVy ZmFjZS5oIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZS5o CmluZGV4IDM5NjUxZjEwMTc1ZGU3MDYwZDA0NWE5ZjBjNjIzOTNjNmFlMzc1ZGMuLmRiOTVkMDM4 MmZiNzc4NjhhMTg0ZDk4ZTE0ZTEzZGQzYTU3ZmZkZTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3Rv cmFnZS9JREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2UuaAorKysgYi9XZWJDb3JlL3N0b3Jh Z2UvSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlLmgKQEAgLTUwLDcgKzUwLDggQEAgcHVi bGljOgogCiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlQmFja2VuZEludGVy ZmFjZT4gb2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lKSA9IDA7CiAgICAgdmlydHVhbCB1 bnNpZ25lZCBzaG9ydCBtb2RlKCkgY29uc3QgPSAwOwotICAgIHZpcnR1YWwgdm9pZCBzY2hlZHVs ZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPikgPSAwOworICAg IHZpcnR1YWwgYm9vbCBzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250 ZXh0OjpUYXNrPikgPSAwOworICAgIHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0ZVRhc2tFdmVudHMo KSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGFib3J0KCkgPSAwOwogICAgIHZpcnR1YWwgaW50IGlk KCkgY29uc3QgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBzZXRDYWxsYmFja3MoSURCVHJhbnNhY3Rp b25DYWxsYmFja3MqKSA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNh Y3Rpb25Db29yZGluYXRvci5jcHAgYi9XZWJDb3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29y ZGluYXRvci5jcHAKaW5kZXggOTc5MGMxZjJkNzk1ZjY2MDZkNjE0YjQwM2I0M2YzNjJmYmYxYjBl Yy4uNjYyY2RlYzA2OWIzZjA1OWEyNDc2ZjBhMGQ2YjFiMzRmZjdiZDc4YSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3IuY3BwCisrKyBiL1dlYkNv cmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmNwcApAQCAtNDcsMjEgKzQ3LDQ0 IEBAIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6On5JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9y KCkKIAogUGFzc1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IElEQlRyYW5z YWN0aW9uQ29vcmRpbmF0b3I6OmNyZWF0ZVRyYW5zYWN0aW9uKERPTVN0cmluZ0xpc3QqIG9iamVj dFN0b3JlcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0LCBJREJE YXRhYmFzZUJhY2tlbmRJbXBsKiBkYXRhYmFzZSkKIHsKLSAgICBSZWZQdHI8SURCVHJhbnNhY3Rp b25CYWNrZW5kSW50ZXJmYWNlPiB0cmFuc2FjdGlvbiA9IElEQlRyYW5zYWN0aW9uQmFja2VuZElt cGw6OmNyZWF0ZShvYmplY3RTdG9yZXMsIG1vZGUsIHRpbWVvdXQsICsrbV9uZXh0SUQsIGRhdGFi YXNlKTsKLSAgICBtX3RyYW5zYWN0aW9uUXVldWUuYWRkKHRyYW5zYWN0aW9uLmdldCgpKTsKLSAg ICBtX2lkTWFwLmFkZChtX25leHRJRCwgdHJhbnNhY3Rpb24pOworICAgIFJlZlB0cjxJREJUcmFu c2FjdGlvbkJhY2tlbmRJbXBsPiB0cmFuc2FjdGlvbiA9IElEQlRyYW5zYWN0aW9uQmFja2VuZElt cGw6OmNyZWF0ZShvYmplY3RTdG9yZXMsIG1vZGUsIHRpbWVvdXQsICsrbV9uZXh0SUQsIGRhdGFi YXNlKTsKKyAgICBtX3RyYW5zYWN0aW9ucy5hZGQobV9uZXh0SUQsIHRyYW5zYWN0aW9uKTsKICAg ICByZXR1cm4gdHJhbnNhY3Rpb24ucmVsZWFzZSgpOwogfQogCi12b2lkIElEQlRyYW5zYWN0aW9u Q29vcmRpbmF0b3I6OmFib3J0KGludCBpZCkKK3ZvaWQgSURCVHJhbnNhY3Rpb25Db29yZGluYXRv cjo6ZGlkU3RhcnRUcmFuc2FjdGlvbihJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKiB0cmFuc2Fj dGlvbikKIHsKLSAgICBBU1NFUlQobV9pZE1hcC5jb250YWlucyhpZCkpOwotICAgIFJlZlB0cjxJ REJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IHRyYW5zYWN0aW9uID0gbV9pZE1hcC5nZXQo aWQpOwotICAgIEFTU0VSVCh0cmFuc2FjdGlvbik7Ci0gICAgbV90cmFuc2FjdGlvblF1ZXVlLnJl bW92ZSh0cmFuc2FjdGlvbi5nZXQoKSk7Ci0gICAgbV9pZE1hcC5yZW1vdmUoaWQpOwotICAgIHRy YW5zYWN0aW9uLT5hYm9ydCgpOwotICAgIC8vIEZJWE1FOiB0aGlzIHdpbGwgY2hhbmdlIG9uY2Ug d2UgaGF2ZSB0cmFuc2FjdGlvbnMgYWN0dWFsbHkgcnVubmluZy4KKyAgICBtX3N0YXJ0ZWRUcmFu c2FjdGlvbnMuYWRkKHRyYW5zYWN0aW9uKTsKKyAgICBwcm9jZXNzU3RhcnRlZFRyYW5zYWN0aW9u cygpOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9uQ29vcmRpbmF0b3I6OmRpZEZpbmlzaFRyYW5z YWN0aW9uKElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqIHRyYW5zYWN0aW9uKQoreworICAgIEFT U0VSVChtX3RyYW5zYWN0aW9ucy5jb250YWlucyh0cmFuc2FjdGlvbi0+aWQoKSkpOworCisgICAg aWYgKG1fc3RhcnRlZFRyYW5zYWN0aW9ucy5jb250YWlucyh0cmFuc2FjdGlvbikpIHsKKyAgICAg ICAgQVNTRVJUKCFtX3J1bm5pbmdUcmFuc2FjdGlvbnMuY29udGFpbnModHJhbnNhY3Rpb24pKTsK KyAgICAgICAgbV9zdGFydGVkVHJhbnNhY3Rpb25zLnJlbW92ZSh0cmFuc2FjdGlvbik7CisgICAg fSBlbHNlIHsKKyAgICAgICAgQVNTRVJUKG1fcnVubmluZ1RyYW5zYWN0aW9ucy5jb250YWlucyh0 cmFuc2FjdGlvbikpOworICAgICAgICBtX3J1bm5pbmdUcmFuc2FjdGlvbnMucmVtb3ZlKHRyYW5z YWN0aW9uKTsKKyAgICB9CisgICAgbV90cmFuc2FjdGlvbnMucmVtb3ZlKHRyYW5zYWN0aW9uLT5p ZCgpKTsKKworICAgIHByb2Nlc3NTdGFydGVkVHJhbnNhY3Rpb25zKCk7Cit9CisKK3ZvaWQgSURC VHJhbnNhY3Rpb25Db29yZGluYXRvcjo6cHJvY2Vzc1N0YXJ0ZWRUcmFuc2FjdGlvbnMoKQorewor ICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBhbGxvY2F0ZSBhIHRocmVhZCB0byB0aGUgbmV4dCB0 cmFuc2FjdGlvbiB0aGF0J3MKKyAgICAvLyByZWFkeSB0byBydW4uIEZvciBub3cgd2Ugb25seSBo YXZlIGEgc2luZ2xlIHJ1bm5pbmcgdHJhbnNhY3Rpb24uCisgICAgaWYgKG1fc3RhcnRlZFRyYW5z YWN0aW9ucy5pc0VtcHR5KCkgfHwgIW1fcnVubmluZ1RyYW5zYWN0aW9ucy5pc0VtcHR5KCkpCisg ICAgICAgIHJldHVybjsKKworICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqIHRyYW5zYWN0 aW9uID0gKm1fc3RhcnRlZFRyYW5zYWN0aW9ucy5iZWdpbigpOworICAgIG1fc3RhcnRlZFRyYW5z YWN0aW9ucy5yZW1vdmUodHJhbnNhY3Rpb24pOworICAgIG1fcnVubmluZ1RyYW5zYWN0aW9ucy5h ZGQodHJhbnNhY3Rpb24pOworICAgIHRyYW5zYWN0aW9uLT5ydW4oKTsKIH0KIAogfTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlvbkNvb3JkaW5hdG9yLmggYi9XZWJD b3JlL3N0b3JhZ2UvSURCVHJhbnNhY3Rpb25Db29yZGluYXRvci5oCmluZGV4IDEwNGE5NTY2Y2Vj ZWRjMzJhZTZjMDUyYWM3Nzc3NTRhNjIxMTgyM2QuLjVlNTRhYjQ4YTFiMjY1OWM0NThhN2JiZjkx NGRkZjI5YzgzNjVlOWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3RvcmFnZS9JREJUcmFuc2FjdGlv bkNvb3JkaW5hdG9yLmgKKysrIGIvV2ViQ29yZS9zdG9yYWdlL0lEQlRyYW5zYWN0aW9uQ29vcmRp bmF0b3IuaApAQCAtMzUsNiArMzUsNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNz IElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGw7CiBjbGFzcyBJREJUcmFuc2FjdGlvbkNhbGxiYWNr czsKIGNsYXNzIElEQkRhdGFiYXNlQmFja2VuZEltcGw7CiAKQEAgLTU1LDE0ICs1NiwyMSBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCB+SURCVHJhbnNhY3Rpb25Db29yZGluYXRvcigpOwogCiAgICAg UGFzc1JlZlB0cjxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRlcmZhY2U+IGNyZWF0ZVRyYW5zYWN0 aW9uKERPTVN0cmluZ0xpc3QqIG9iamVjdFN0b3JlcywgdW5zaWduZWQgc2hvcnQgbW9kZSwgdW5z aWduZWQgbG9uZyB0aW1lb3V0LCBJREJEYXRhYmFzZUJhY2tlbmRJbXBsKik7Ci0gICAgdm9pZCBh Ym9ydChpbnQgdHJhbnNhY3Rpb25JZCk7CisKKyAgICAvLyBDYWxsZWQgYnkgdHJhbnNhY3Rpb25z IGFzIHRoZXkgc3RhcnQgYW5kIGZpbmlzaC4KKyAgICB2b2lkIGRpZFN0YXJ0VHJhbnNhY3Rpb24o SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCopOworICAgIHZvaWQgZGlkRmluaXNoVHJhbnNhY3Rp b24oSURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbCopOwogCiBwcml2YXRlOgogICAgIElEQlRyYW5z YWN0aW9uQ29vcmRpbmF0b3IoKTsKIAotICAgIExpc3RIYXNoU2V0PElEQlRyYW5zYWN0aW9uQmFj a2VuZEludGVyZmFjZSo+IG1fdHJhbnNhY3Rpb25RdWV1ZTsKLSAgICB0eXBlZGVmIEhhc2hNYXA8 aW50LCBSZWZQdHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlPiA+IElkVG9UcmFuc2Fj dGlvbk1hcDsKLSAgICBJZFRvVHJhbnNhY3Rpb25NYXAgbV9pZE1hcDsKKyAgICB2b2lkIHByb2Nl c3NTdGFydGVkVHJhbnNhY3Rpb25zKCk7CisKKyAgICAvLyBUaGlzIG1hcCBvd25zIGFsbCB0cmFu c2FjdGlvbnMga25vd24gdG8gdGhlIGNvb3JkaW5hdG9yLgorICAgIEhhc2hNYXA8aW50LCBSZWZQ dHI8SURCVHJhbnNhY3Rpb25CYWNrZW5kSW1wbD4gPiBtX3RyYW5zYWN0aW9uczsKKyAgICAvLyBU cmFuc2FjdGlvbnMgaW4gZGlmZmVyZW50IHN0YXRlcyBhcmUgZ3JvdXBlZCBiZWxvdy4KKyAgICBM aXN0SGFzaFNldDxJREJUcmFuc2FjdGlvbkJhY2tlbmRJbXBsKiA+IG1fc3RhcnRlZFRyYW5zYWN0 aW9uczsKKyAgICBIYXNoU2V0PElEQlRyYW5zYWN0aW9uQmFja2VuZEltcGwqID4gbV9ydW5uaW5n VHJhbnNhY3Rpb25zOwogICAgIGludCBtX25leHRJRDsKIH07CiAKZGlmZiAtLWdpdCBhL1dlYktp dC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDdi NjU4OTFmMmVkZDg0Mzk0YjhlZGU5ZjVlZmMwYWVkNmI1ZDkyZjIuLjVjMGI5NzA4YzU1OTgwZGQy YWM0NDM1ZGNkYmI3ODgwNGNlMTQ0ZjAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9DaGFu Z2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisy MDEwLTA5LTIzICBBbmRyZWkgUG9wZXNjdSAgPGFuZHJlaXBAZ29vZ2xlLmNvbT4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJREJPYmplY3RTdG9yZTo6 Z2V0IHNob3VsZCBydW4gaW4gYSB0cmFuc2FjdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzAwCisKKyAgICAgICAgKiBwdWJsaWMvV2ViSURC RmFjdG9yeS5oOgorICAgICAgICAqIHB1YmxpYy9XZWJJREJPYmplY3RTdG9yZS5oOgorICAgICAg ICAqIHB1YmxpYy9XZWJJREJUcmFuc2FjdGlvbi5oOgorICAgICAgICAoV2ViS2l0OjpXZWJJREJU cmFuc2FjdGlvbjo6ZGlkQ29tcGxldGVUYXNrRXZlbnRzKToKKyAgICAgICAgKFdlYktpdDo6V2Vi SURCVHJhbnNhY3Rpb246OmdldElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSk6CisgICAg ICAgICogc3JjL0lEQkRhdGFiYXNlUHJveHkuaDoKKyAgICAgICAgKiBzcmMvSURCRmFjdG9yeUJh Y2tlbmRQcm94eS5jcHA6CisgICAgICAgICogc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuaDoK KyAgICAgICAgKiBzcmMvSURCT2JqZWN0U3RvcmVQcm94eS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpJREJPYmplY3RTdG9yZVByb3h5OjpnZXQpOgorICAgICAgICAqIHNyYy9JREJPYmplY3RTdG9y ZVByb3h5Lmg6CisgICAgICAgICogc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OklEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5OjpzY2hlZHVsZVRh c2spOgorICAgICAgICAoV2ViQ29yZTo6SURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OmRpZENv bXBsZXRlVGFza0V2ZW50cyk6CisgICAgICAgICogc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFBy b3h5Lmg6CisgICAgICAgIChXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94eTo6Z2V0 V2ViSURCVHJhbnNhY3Rpb24pOgorICAgICAgICAqIHNyYy9XZWJJREJGYWN0b3J5SW1wbC5jcHA6 CisgICAgICAgICogc3JjL1dlYklEQkZhY3RvcnlJbXBsLmg6CisgICAgICAgICogc3JjL1dlYklE Qk9iamVjdFN0b3JlSW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYklEQk9iamVjdFN0b3Jl SW1wbDo6Z2V0KToKKyAgICAgICAgKiBzcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmg6CisgICAg ICAgICogc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6Oldl YklEQlRyYW5zYWN0aW9uSW1wbDo6ZGlkQ29tcGxldGVUYXNrRXZlbnRzKToKKyAgICAgICAgKFdl YktpdDo6V2ViSURCVHJhbnNhY3Rpb25JbXBsOjpnZXRJREJUcmFuc2FjdGlvbkJhY2tlbmRJbnRl cmZhY2UpOgorICAgICAgICAqIHNyYy9XZWJJREJUcmFuc2FjdGlvbkltcGwuaDoKKwogMjAxMC0w OS0yMiAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBEYXJpbiBGaXNoZXIuCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYklEQkZhY3RvcnkuaCBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCRmFjdG9y eS5oCmluZGV4IDBiZTRjNjNhZWFmNDFkODhjYzJmYWE4ZjJmYWIyYzA4MTAwNjcxYzcuLmNiNWQz NjkwNTY1NmYwYTBkYmU3ZTIxYWQ4YzE4YzUyYTU3NmRiNDIgMTAwNzU1Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViSURCRmFjdG9yeS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJs aWMvV2ViSURCRmFjdG9yeS5oCkBAIC01NCw4ICs1NCw2IEBAIHB1YmxpYzoKICAgICAvLyBUaGUg V2ViS2l0IGltcGxlbWVudGF0aW9uIG9mIG9wZW4gaWdub3JlcyB0aGUgV2ViRnJhbWUqIHBhcmFt ZXRlci4KICAgICB2aXJ0dWFsIHZvaWQgb3Blbihjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0 IFdlYlN0cmluZyYgZGVzY3JpcHRpb24sIFdlYklEQkNhbGxiYWNrcyogY2FsbGJhY2tzLCBjb25z dCBXZWJTZWN1cml0eU9yaWdpbiYgb3JpZ2luLCBXZWJGcmFtZSogd2ViRnJhbWUsIGNvbnN0IFdl YlN0cmluZyYgZGF0YURpcikgeyBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KIAotICAg IHZpcnR1YWwgdm9pZCBhYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgV2ViVmVjdG9yPGlu dD4mIHBlbmRpbmdJRHMpIHsgV0VCS0lUX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9Ci0KICAgICAv LyBUaGUgZmlsZSBuYW1lIHRoYXQgd291bGQgYmUgdXNlZCBmb3IgcGVyc2lzdGluZyBhIGdpdmVu IGluZGV4ZWQgZGF0YWJhc2Ugb24gdGhlIGZpbGUgc3lzdGVtLgogICAgIFdFQktJVF9BUEkgc3Rh dGljIFdlYlN0cmluZyBkYXRhYmFzZUZpbGVOYW1lKGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29u c3QgV2ViU2VjdXJpdHlPcmlnaW4mKTsKIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYklEQk9iamVjdFN0b3JlLmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklE Qk9iamVjdFN0b3JlLmgKaW5kZXggNTY5ZWRlMTVlZjc5NDgzODZiZDY2N2E0MmQ4NTZiMWEyMjA4 OTk1Mi4uMTllZmQ0ODljZjFiN2QwZTg2NDM4NDU2ODhlMzliNzZlYzdkZjkyZSAxMDA3NTUKLS0t IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJREJPYmplY3RTdG9yZS5oCisrKyBiL1dlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViSURCT2JqZWN0U3RvcmUuaApAQCAtMzUsNiArMzUsNyBAQAog bmFtZXNwYWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYklEQktleVJhbmdlOworY2xhc3MgV2ViSURC VHJhbnNhY3Rpb247CiAKIC8vIFNlZSBjb21tZW50IGluIFdlYkluZGV4ZWREYXRhYmFzZSBmb3Ig YSBoaWdoIGxldmVsIG92ZXJ2aWV3IHRoZXNlIGNsYXNzZXMuCiBjbGFzcyBXZWJJREJPYmplY3RT dG9yZSB7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQlRyYW5zYWN0 aW9uLmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklEQlRyYW5zYWN0aW9uLmgKaW5kZXgg MDM2OWI4OTliNTY5MTNiZDZkMTc5Njc0ZjIwYjJmMDhjMGVhNTIxYy4uY2M5MDAwMmVjMDI4OTIz NDk5N2EyNWQ4NDU4OGY3NmNiOTIxM2E2YSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1 YmxpYy9XZWJJREJUcmFuc2FjdGlvbi5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi SURCVHJhbnNhY3Rpb24uaApAQCAtMjgsNiArMjgsOCBAQAogCiAjaW5jbHVkZSAiV2ViU3RyaW5n LmgiCiAKK25hbWVzcGFjZSBXZWJDb3JlIHsgY2xhc3MgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlOyB9CisKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBXZWJJREJPYmplY3RTdG9y ZTsKQEAgLTQ5LDEyICs1MSwyMiBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiAwOwogICAgIH0K ICAgICB2aXJ0dWFsIHZvaWQgYWJvcnQoKSB7IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsg fQorICAgIHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0ZVRhc2tFdmVudHMoKSB7IFdFQktJVF9BU1NF UlRfTk9UX1JFQUNIRUQoKTsgfQogICAgIHZpcnR1YWwgaW50IGlkKCkgY29uc3QKICAgICB7CiAg ICAgICAgIFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgcmV0dXJuIDA7CiAg ICAgfQogICAgIHZpcnR1YWwgdm9pZCBzZXRDYWxsYmFja3MoV2ViSURCVHJhbnNhY3Rpb25DYWxs YmFja3MqKSB7IFdFQktJVF9BU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorCisjaWYgV0VCS0lUX0lN UExFTUVOVEFUSU9OCisgICAgdmlydHVhbCBXZWJDb3JlOjpJREJUcmFuc2FjdGlvbkJhY2tlbmRJ bnRlcmZhY2UqIGdldElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSgpIGNvbnN0CisgICAg eworICAgICAgICBXRUJLSVRfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIHJldHVybiAw OworICAgIH0KKyNlbmRpZgorCiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdp dCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRGF0YWJhc2VQcm94eS5oIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmgKaW5kZXggNDJhN2Q3ZWM1NmEyNjI4MjE4MGQ3NmM4 M2YyMzZkMTg3ZmU0NDc3Yy4uZmZmZDIzZWU4NTJhNjEzNmM0MWE1Y2ViZTBhMDhkYzRkZGFmNjVh YiAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmgKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJEYXRhYmFzZVByb3h5LmgKQEAgLTQ3LDcgKzQ3LDcg QEAgcHVibGljOgogICAgIHZpcnR1YWwgU3RyaW5nIHZlcnNpb24oKSBjb25zdDsKICAgICB2aXJ0 dWFsIFBhc3NSZWZQdHI8RE9NU3RyaW5nTGlzdD4gb2JqZWN0U3RvcmVzKCkgY29uc3Q7CiAKLSAg ICAvLyBGSVhNRTogQWRkIHRyYW5zYWN0aW9uIGFuZCBzZXRWZXJzaW9uLgorICAgIC8vIEZJWE1F OiBBZGQgc2V0VmVyc2lvbi4KIAogICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVPYmplY3RTdG9yZShj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYga2V5UGF0aCwgYm9vbCBhdXRvSW5jcmVt ZW50LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJ REJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYg bmFtZSwgdW5zaWduZWQgc2hvcnQgbW9kZSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v c3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJG YWN0b3J5QmFja2VuZFByb3h5LmNwcAppbmRleCAxODEwMWU0ODkzMzUwMmRlMDYyNDk2ZWQ2MDFm OGUyZGIwMGExMDgyLi5kNDNlNzg3ZjJkNTk2ZmJlNzRlY2ZjOTI1M2M0NmU0ZDU3ZGRmNzdkIDEw MDc1NQotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQkZhY3RvcnlCYWNrZW5kUHJveHkuY3Bw CisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5jcHAKQEAg LTY1LDE0ICs2NSw2IEBAIHZvaWQgSURCRmFjdG9yeUJhY2tlbmRQcm94eTo6b3Blbihjb25zdCBT dHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgZGVzY3JpcHRpb24sCiAgICAgbV93ZWJJREJGYWN0 b3J5LT5vcGVuKG5hbWUsIGRlc2NyaXB0aW9uLCBuZXcgV2ViSURCQ2FsbGJhY2tzSW1wbChjYWxs YmFja3MpLCBvcmlnaW4sIHdlYkZyYW1lLCBkYXRhRGlyKTsKIH0KIAotdm9pZCBJREJGYWN0b3J5 QmFja2VuZFByb3h5OjphYm9ydFBlbmRpbmdUcmFuc2FjdGlvbnMoY29uc3QgVmVjdG9yPGludD4m IHBlbmRpbmdJRHMpCi17Ci0gICAgQVNTRVJUKHBlbmRpbmdJRHMuc2l6ZSgpKTsKLSAgICBXZWJL aXQ6OldlYlZlY3RvcjxpbnQ+IGlkcyA9IHBlbmRpbmdJRHM7Ci0KLSAgICBtX3dlYklEQkZhY3Rv cnktPmFib3J0UGVuZGluZ1RyYW5zYWN0aW9ucyhpZHMpOwotfQotCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvSURCRmFjdG9yeUJhY2tlbmRQcm94eS5oIGIvV2ViS2l0L2No cm9taXVtL3NyYy9JREJGYWN0b3J5QmFja2VuZFByb3h5LmgKaW5kZXggYWMzMGNmMmY4M2I2MmI5 M2M0N2ZhMThkODgxOTlhNjQyNjU4N2FkZi4uNjM3MTY4NmNlYWZmMDY5Yjg0YTQ1MzU3YTkwM2Ri NmVmNjhiOTc5MCAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJGYWN0b3J5QmFj a2VuZFByb3h5LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJGYWN0b3J5QmFja2VuZFBy b3h5LmgKQEAgLTQ2LDcgKzQ2LDYgQEAgcHVibGljOgogCiAgICAgUGFzc1JlZlB0cjxET01TdHJp bmdMaXN0PiBkYXRhYmFzZXModm9pZCkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIG9wZW4oY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRlc2NyaXB0aW9uLCBQYXNzUmVmUHRyPElE QkNhbGxiYWNrcz4sIFBhc3NSZWZQdHI8U2VjdXJpdHlPcmlnaW4+LCBGcmFtZSosIGNvbnN0IFN0 cmluZyYgZGF0YURpcik7Ci0gICAgdmlydHVhbCB2b2lkIGFib3J0UGVuZGluZ1RyYW5zYWN0aW9u cyhjb25zdCBWZWN0b3I8aW50PiYgcGVuZGluZ0lEcyk7CiAKIHByaXZhdGU6CiAgICAgSURCRmFj dG9yeUJhY2tlbmRQcm94eSgpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJP YmplY3RTdG9yZVByb3h5LmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQ cm94eS5jcHAKaW5kZXggYWQyN2ZhMzQxYzViYzdjODljN2QwOGEyN2I1NWQxODMyOGRmMmIwMi4u ODJjYTVmNjZjZjA5N2ZjMzkwODZkYmU2NDNlNjNkYWI2ZmY4ZmNmZCAxMDA3NTUKLS0tIGEvV2Vi S2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmNwcAorKysgYi9XZWJLaXQvY2hy b21pdW0vc3JjL0lEQk9iamVjdFN0b3JlUHJveHkuY3BwCkBAIC0zMCwxMSArMzAsMTMgQEAKICNp bmNsdWRlICJJREJDYWxsYmFja3MuaCIKICNpbmNsdWRlICJJREJJbmRleEJhY2tlbmRQcm94eS5o IgogI2luY2x1ZGUgIklEQktleVJhbmdlLmgiCisjaW5jbHVkZSAiSURCVHJhbnNhY3Rpb25CYWNr ZW5kUHJveHkuaCIKICNpbmNsdWRlICJXZWJJREJDYWxsYmFja3NJbXBsLmgiCiAjaW5jbHVkZSAi V2ViSURCS2V5UmFuZ2UuaCIKICNpbmNsdWRlICJXZWJJREJJbmRleC5oIgogI2luY2x1ZGUgIldl YklEQktleS5oIgogI2luY2x1ZGUgIldlYklEQk9iamVjdFN0b3JlLmgiCisjaW5jbHVkZSAiV2Vi SURCVHJhbnNhY3Rpb25JbXBsLmgiCiAjaW5jbHVkZSAiV2ViU2VyaWFsaXplZFNjcmlwdFZhbHVl LmgiCiAKICNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKQEAgLTcwLDkgKzcyLDEyIEBAIFBh c3NSZWZQdHI8RE9NU3RyaW5nTGlzdD4gSURCT2JqZWN0U3RvcmVQcm94eTo6aW5kZXhOYW1lcygp IGNvbnN0CiAgICAgcmV0dXJuIG1fd2ViSURCT2JqZWN0U3RvcmUtPmluZGV4TmFtZXMoKTsKIH0K IAotdm9pZCBJREJPYmplY3RTdG9yZVByb3h5OjpnZXQoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwg UGFzc1JlZlB0cjxJREJDYWxsYmFja3M+IGNhbGxiYWNrcykKK3ZvaWQgSURCT2JqZWN0U3RvcmVQ cm94eTo6Z2V0KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tz PiBjYWxsYmFja3MsIElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZSogdHJhbnNhY3Rpb24p CiB7Ci0gICAgbV93ZWJJREJPYmplY3RTdG9yZS0+Z2V0KGtleSwgbmV3IFdlYklEQkNhbGxiYWNr c0ltcGwoY2FsbGJhY2tzKSk7CisgICAgLy8gVGhlIHRyYW5zYWN0aW9uIHBvaW50ZXIgaXMgZ3Vh cmFudGVlZCB0byBiZSBhIHBvaW50ZXIgdG8gYSBwcm94eSBvYmplY3QgYXMsIGluIHRoZSByZW5k ZXJlciwKKyAgICAvLyBhbGwgaW1wbGVtZW50YXRpb25zIG9mIElEQiBpbnRlcmZhY2VzIGFyZSBw cm94eSBvYmplY3RzLgorICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5KiB0cmFuc2FjdGlv blByb3h5ID0gc3RhdGljX2Nhc3Q8SURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkqPih0cmFuc2Fj dGlvbik7CisgICAgbV93ZWJJREJPYmplY3RTdG9yZS0+Z2V0KGtleSwgbmV3IFdlYklEQkNhbGxi YWNrc0ltcGwoY2FsbGJhY2tzKSwgKnRyYW5zYWN0aW9uUHJveHktPmdldFdlYklEQlRyYW5zYWN0 aW9uKCkpOwogfQogCiB2b2lkIElEQk9iamVjdFN0b3JlUHJveHk6OnB1dChQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIGJvb2wg YWRkT25seSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+IGNhbGxiYWNrcykKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvSURCT2JqZWN0U3RvcmVQcm94eS5oIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmgKaW5kZXggYTMzNDU3MmI2ZjM2YzFlMDA0ODJj MDRkMGEwN2I2NWFhYmY1OTlhMS4uMTNkZmUyMzZkZTZlZTQ1YzVhNWYxOGM0NjY3NjE2N2Q0NDIz MGJiMiAxMDA3NTUKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5 LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJPYmplY3RTdG9yZVByb3h5LmgKQEAgLTQ2 LDcgKzQ2LDcgQEAgcHVibGljOgogICAgIFN0cmluZyBrZXlQYXRoKCkgY29uc3Q7CiAgICAgUGFz c1JlZlB0cjxET01TdHJpbmdMaXN0PiBpbmRleE5hbWVzKCkgY29uc3Q7CiAKLSAgICB2b2lkIGdl dChQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPElEQkNhbGxiYWNrcz4pOworICAg IHZvaWQgZ2V0KFBhc3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tz PiwgSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNlKik7CiAgICAgdm9pZCBwdXQoUGFzc1Jl ZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBQYXNzUmVmUHRyPElEQktleT4ga2V5 LCBib29sIGFkZE9ubHksIFBhc3NSZWZQdHI8SURCQ2FsbGJhY2tzPik7CiAgICAgdm9pZCByZW1v dmUoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxJREJDYWxsYmFja3M+KTsKIApk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94 eS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNw cAppbmRleCBiZTZiMDU4ZTUyZTI0Mjc1ODM0ODcwOWRiMDAxY2QwNDFjNTY5NmU4Li41OWU4OGQ4 OTNlMTUyZTc1OWFkMWMwNmExYmMwZmFhNWJlODM4YjI4IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcAorKysgYi9XZWJLaXQvY2hy b21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5LmNwcApAQCAtNjksMTEgKzY5LDE3 IEBAIHZvaWQgSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OmFib3J0KCkKICAgICBtX3dlYklE QlRyYW5zYWN0aW9uLT5hYm9ydCgpOwogfQogCi12b2lkIElEQlRyYW5zYWN0aW9uQmFja2VuZFBy b3h5OjpzY2hlZHVsZVRhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNr PikKK2Jvb2wgSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHk6OnNjaGVkdWxlVGFzayhQYXNzT3du UHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KQogewogICAgIC8vIFRoaXMgc2hvdWxk IG5ldmVyIGJlIHJlYWNoZWQgYXMgaXQncyB0aGUgaW1wbCBvYmplY3RzIHdobyBnZXQgdG8KICAg ICAvLyBleGVjdXRlIHRhc2tzIGluIHRoZSBicm93c2VyIHByb2Nlc3MuCiAgICAgQVNTRVJUX05P VF9SRUFDSEVEKCk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCit2b2lkIElEQlRyYW5zYWN0aW9u QmFja2VuZFByb3h5OjpkaWRDb21wbGV0ZVRhc2tFdmVudHMoKQoreworICAgIG1fd2ViSURCVHJh bnNhY3Rpb24tPmRpZENvbXBsZXRlVGFza0V2ZW50cygpOwogfQogCiBpbnQgSURCVHJhbnNhY3Rp b25CYWNrZW5kUHJveHk6OmlkKCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9z cmMvSURCVHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvSURC VHJhbnNhY3Rpb25CYWNrZW5kUHJveHkuaAppbmRleCBkNjJiOGZmN2I4NDFhMmEzZjkyYTJjNjdh NzAwZGU2MzgzNWZlMzAyLi4zZGFmNzNlYjNjOTFjZTI4ODgzMmI4NzMwY2Q3OGY3NWNkYWEzYjQz IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0lEQlRyYW5zYWN0aW9uQmFja2VuZFBy b3h5LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9JREJUcmFuc2FjdGlvbkJhY2tlbmRQcm94 eS5oCkBAIC00NSwxMCArNDUsMTMgQEAgcHVibGljOgogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxJ REJPYmplY3RTdG9yZUJhY2tlbmRJbnRlcmZhY2U+IG9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYg bmFtZSk7CiAgICAgdmlydHVhbCB1bnNpZ25lZCBzaG9ydCBtb2RlKCkgY29uc3Q7CiAgICAgdmly dHVhbCB2b2lkIGFib3J0KCk7Ci0gICAgdmlydHVhbCB2b2lkIHNjaGVkdWxlVGFzayhQYXNzT3du UHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKKyAgICB2aXJ0dWFsIGJvb2wgc2No ZWR1bGVUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOworICAg IHZpcnR1YWwgdm9pZCBkaWRDb21wbGV0ZVRhc2tFdmVudHMoKTsKICAgICB2aXJ0dWFsIGludCBp ZCgpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBzZXRDYWxsYmFja3MoSURCVHJhbnNhY3Rpb25D YWxsYmFja3MqKTsKIAorICAgIFdlYktpdDo6V2ViSURCVHJhbnNhY3Rpb24qIGdldFdlYklEQlRy YW5zYWN0aW9uKCkgY29uc3QgeyByZXR1cm4gbV93ZWJJREJUcmFuc2FjdGlvbi5nZXQoKTsgfQor CiBwcml2YXRlOgogICAgIElEQlRyYW5zYWN0aW9uQmFja2VuZFByb3h5KFBhc3NPd25QdHI8V2Vi S2l0OjpXZWJJREJUcmFuc2FjdGlvbj4pOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYklEQkZhY3RvcnlJbXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFj dG9yeUltcGwuY3BwCmluZGV4IDNjOGQ0NTlhMGE5ZTUyODM3NTk2ZjU2NDFjMjI4NDNhZTA5ZGJh ZTcuLjcxNDdjZjA4NmYxY2I2N2RmZGQ4ZDg5N2FlNzU5YjEwYjMyNDBhZTEgMTAwNzU1Ci0tLSBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuY3BwCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwuY3BwCkBAIC02MywxNSArNjMsNiBAQCB2b2lk IFdlYklEQkZhY3RvcnlJbXBsOjpvcGVuKGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2Vi U3RyaW5nJiBkZXNjcmlwdGlvbgogICAgIG1faWRiRmFjdG9yeUJhY2tlbmQtPm9wZW4obmFtZSwg ZGVzY3JpcHRpb24sIElEQkNhbGxiYWNrc1Byb3h5OjpjcmVhdGUoY2FsbGJhY2tzKSwgb3JpZ2lu LCAwLCBkYXRhRGlyKTsKIH0KIAotdm9pZCBXZWJJREJGYWN0b3J5SW1wbDo6YWJvcnRQZW5kaW5n VHJhbnNhY3Rpb25zKGNvbnN0IFdlYlZlY3RvcjxpbnQ+JiBwZW5kaW5nSURzKQotewotICAgIFdU Rjo6VmVjdG9yPGludD4gaWRzKHBlbmRpbmdJRHMuc2l6ZSgpKTsKLSAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IHBlbmRpbmdJRHMuc2l6ZSgpOyArK2kpCi0gICAgICAgIGlkc1tpXSA9IHBlbmRp bmdJRHNbaV07Ci0KLSAgICBtX2lkYkZhY3RvcnlCYWNrZW5kLT5hYm9ydFBlbmRpbmdUcmFuc2Fj dGlvbnMoaWRzKTsKLX0KLQogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CiAKICNlbmRpZiAvLyBFTkFC TEUoSU5ERVhFRF9EQVRBQkFTRSkKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi SURCRmFjdG9yeUltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCRmFjdG9yeUltcGwu aAppbmRleCA0ZGMwYTEwOTgwOTg1NDhiMWYzZjNlODc3NGJjYWVjNTdlZDBmMDBjLi5hMGE0ZDdk OWZlZDA1YWY0YWI4ZmU2NTUzOTgyMGI2Mzc3NjY2NmY4IDEwMDc1NQotLS0gYS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYklEQkZhY3RvcnlJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJJREJGYWN0b3J5SW1wbC5oCkBAIC00Myw3ICs0Myw2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IH5XZWJJREJGYWN0b3J5SW1wbCgpOwogCiAgICAgdmlydHVhbCB2b2lkIG9wZW4oY29uc3QgV2Vi U3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRlc2NyaXB0aW9uLCBXZWJJREJDYWxsYmFj a3MqLCBjb25zdCBXZWJTZWN1cml0eU9yaWdpbiYsIFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5n JiBkYXRhRGlyKTsKLSAgICB2aXJ0dWFsIHZvaWQgYWJvcnRQZW5kaW5nVHJhbnNhY3Rpb25zKGNv bnN0IFdlYlZlY3RvcjxpbnQ+JiBwZW5kaW5nSURzKTsKIAogcHJpdmF0ZToKICAgICBXVEY6OlJl ZlB0cjxXZWJDb3JlOjpJREJGYWN0b3J5QmFja2VuZEludGVyZmFjZT4gbV9pZGJGYWN0b3J5QmFj a2VuZDsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJ bXBsLmNwcCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmNwcApp bmRleCAxYWQxZDlmM2U0NzM4YTc3NGYzYjY2MTRiMjA2ZjYxYTNhYjJlYzAyLi4zNmQ4YWNlNGU5 ZDJlZjA0MTEyYjRmMmMxMDA4Zjc4ZWVjYmRhYzZhIDEwMDc1NQotLS0gYS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYklEQk9iamVjdFN0b3JlSW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJJREJPYmplY3RTdG9yZUltcGwuY3BwCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAi V2ViSURCSW5kZXhJbXBsLmgiCiAjaW5jbHVkZSAiV2ViSURCS2V5LmgiCiAjaW5jbHVkZSAiV2Vi SURCS2V5UmFuZ2UuaCIKKyNpbmNsdWRlICJXZWJJREJUcmFuc2FjdGlvbi5oIgogI2luY2x1ZGUg IldlYlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgogCiAjaWYgRU5BQkxFKElOREVYRURfREFUQUJB U0UpCkBAIC02NSw5ICs2Niw5IEBAIFdlYkRPTVN0cmluZ0xpc3QgV2ViSURCT2JqZWN0U3RvcmVJ bXBsOjppbmRleE5hbWVzKCkgY29uc3QKICAgICByZXR1cm4gbV9vYmplY3RTdG9yZS0+aW5kZXhO YW1lcygpOwogfQogCi12b2lkIFdlYklEQk9iamVjdFN0b3JlSW1wbDo6Z2V0KGNvbnN0IFdlYklE QktleSYga2V5LCBXZWJJREJDYWxsYmFja3MqIGNhbGxiYWNrcykKK3ZvaWQgV2ViSURCT2JqZWN0 U3RvcmVJbXBsOjpnZXQoY29uc3QgV2ViSURCS2V5JiBrZXksIFdlYklEQkNhbGxiYWNrcyogY2Fs bGJhY2tzLCBjb25zdCBXZWJJREJUcmFuc2FjdGlvbiYgdHJhbnNhY3Rpb24pCiB7Ci0gICAgbV9v YmplY3RTdG9yZS0+Z2V0KGtleSwgSURCQ2FsbGJhY2tzUHJveHk6OmNyZWF0ZShjYWxsYmFja3Mp KTsKKyAgICBtX29iamVjdFN0b3JlLT5nZXQoa2V5LCBJREJDYWxsYmFja3NQcm94eTo6Y3JlYXRl KGNhbGxiYWNrcyksIHRyYW5zYWN0aW9uLmdldElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFj ZSgpKTsKIH0KIAogdm9pZCBXZWJJREJPYmplY3RTdG9yZUltcGw6OnB1dChjb25zdCBXZWJTZXJp YWxpemVkU2NyaXB0VmFsdWUmIHZhbHVlLCBjb25zdCBXZWJJREJLZXkmIGtleSwgYm9vbCBhZGRP bmx5LCBXZWJJREJDYWxsYmFja3MqIGNhbGxiYWNrcykKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YklEQk9iamVjdFN0b3JlSW1wbC5oCmluZGV4IDlmMzEzNjljMzBiMTQxNWYxYjkyYzcwODVjYWRl ZGEwMjc4OTkyMmIuLmE5ZjEyMDBjOWZjNGQ4NjFkMmVmNWY3OWU5NDQyMTk2MTNlNjQ2OTkgMTAw NzU1Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCT2JqZWN0U3RvcmVJbXBsLmgKKysr IGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJPYmplY3RTdG9yZUltcGwuaApAQCAtNDcsNyAr NDcsNyBAQCBwdWJsaWM6CiAgICAgV2ViU3RyaW5nIGtleVBhdGgoKSBjb25zdDsKICAgICBXZWJE T01TdHJpbmdMaXN0IGluZGV4TmFtZXMoKSBjb25zdDsKIAotICAgIHZvaWQgZ2V0KGNvbnN0IFdl YklEQktleSYga2V5LCBXZWJJREJDYWxsYmFja3MqKTsKKyAgICB2b2lkIGdldChjb25zdCBXZWJJ REJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tzKiwgY29uc3QgV2ViSURCVHJhbnNhY3Rpb24mKTsK ICAgICB2b2lkIHB1dChjb25zdCBXZWJTZXJpYWxpemVkU2NyaXB0VmFsdWUmIHZhbHVlLCBjb25z dCBXZWJJREJLZXkmIGtleSwgYm9vbCBhZGRPbmx5LCBXZWJJREJDYWxsYmFja3MqKTsKICAgICB2 b2lkIHJlbW92ZShjb25zdCBXZWJJREJLZXkmIGtleSwgV2ViSURCQ2FsbGJhY2tzKik7CiAKZGlm ZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmNwcCBi L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmNwcAppbmRleCAwZGM5 NzAyZGU5N2QxZjk4NWRlMWEwMTI0ZmY4NzM2MzU5YzIxMmYzLi5mNWQ4NzQ4NzA4OGEyN2Q3MTZl NzRjYTg3ODMyY2E1NTZkNWIyMWUzIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YklEQlRyYW5zYWN0aW9uSW1wbC5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJU cmFuc2FjdGlvbkltcGwuY3BwCkBAIC02NCw2ICs2NCwxMSBAQCB2b2lkIFdlYklEQlRyYW5zYWN0 aW9uSW1wbDo6YWJvcnQoKQogICAgIG1fYmFja2VuZC0+YWJvcnQoKTsKIH0KIAordm9pZCBXZWJJ REJUcmFuc2FjdGlvbkltcGw6OmRpZENvbXBsZXRlVGFza0V2ZW50cygpCit7CisgICAgbV9iYWNr ZW5kLT5kaWRDb21wbGV0ZVRhc2tFdmVudHMoKTsKK30KKwogaW50IFdlYklEQlRyYW5zYWN0aW9u SW1wbDo6aWQoKSBjb25zdAogewogICAgIHJldHVybiBtX2JhY2tlbmQtPmlkKCk7CkBAIC03NSw2 ICs4MCwxMSBAQCB2b2lkIFdlYklEQlRyYW5zYWN0aW9uSW1wbDo6c2V0Q2FsbGJhY2tzKFdlYklE QlRyYW5zYWN0aW9uQ2FsbGJhY2tzKiBjYWxsYmFja3MpCiAgICAgbV9iYWNrZW5kLT5zZXRDYWxs YmFja3MoaWRiQ2FsbGJhY2tzLmdldCgpKTsKIH0KIAorSURCVHJhbnNhY3Rpb25CYWNrZW5kSW50 ZXJmYWNlKiBXZWJJREJUcmFuc2FjdGlvbkltcGw6OmdldElEQlRyYW5zYWN0aW9uQmFja2VuZElu dGVyZmFjZSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fYmFja2VuZC5nZXQoKTsKK30KKwogfSAv LyBuYW1lc3BhY2UgV2ViS2l0CiAKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkK ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSURCVHJhbnNhY3Rpb25JbXBsLmgg Yi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklEQlRyYW5zYWN0aW9uSW1wbC5oCmluZGV4IGE5YmRl Njg0ZWY1YTBlMzlmOWY3ZTMzMDE5ZTQ3MmM0NmQ4OWQ4ZGYuLjI0YmFiOTE0ZDA0OTMxZGNjMWJh YmZiYzNjN2QyMzMxZmY5NWE5ODUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi SURCVHJhbnNhY3Rpb25JbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJREJUcmFu c2FjdGlvbkltcGwuaApAQCAtMzMsOCArMzMsNiBAQAogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRy Lmg+CiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgogCi1uYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNz IElEQlRyYW5zYWN0aW9uQmFja2VuZEludGVyZmFjZTsgfQotCiBuYW1lc3BhY2UgV2ViS2l0IHsK IAogLy8gU2VlIGNvbW1lbnQgaW4gV2ViSW5kZXhlZERhdGFiYXNlIGZvciBhIGhpZ2ggbGV2ZWwg b3ZlcnZpZXcgdGhlc2UgY2xhc3Nlcy4KQEAgLTQ2LDkgKzQ0LDEyIEBAIHB1YmxpYzoKICAgICB2 aXJ0dWFsIGludCBtb2RlKCkgY29uc3Q7CiAgICAgdmlydHVhbCBXZWJJREJPYmplY3RTdG9yZSog b2JqZWN0U3RvcmUoY29uc3QgV2ViU3RyaW5nJiBuYW1lKTsKICAgICB2aXJ0dWFsIHZvaWQgYWJv cnQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tcGxldGVUYXNrRXZlbnRzKCk7CiAgICAgdmly dHVhbCBpbnQgaWQoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgc2V0Q2FsbGJhY2tzKFdlYklE QlRyYW5zYWN0aW9uQ2FsbGJhY2tzKik7CiAKKyAgICB2aXJ0dWFsIFdlYkNvcmU6OklEQlRyYW5z YWN0aW9uQmFja2VuZEludGVyZmFjZSogZ2V0SURCVHJhbnNhY3Rpb25CYWNrZW5kSW50ZXJmYWNl KCkgY29uc3Q7CisKIHByaXZhdGU6CiAgICAgV1RGOjpSZWZQdHI8V2ViQ29yZTo6SURCVHJhbnNh Y3Rpb25CYWNrZW5kSW50ZXJmYWNlPiBtX2JhY2tlbmQ7CiB9Owo=