58443 2011-04-13 08:15:04 -0700 [GTK] Support the Filesystem API 2022-02-28 04:01:34 -0800 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED WONTFIX Gtk, LayoutTestFailure P3 Normal --- 82854 83015 82853 82855 83137 1 mrobinson webkit-unassigned a.shabalin cwhong893 donggwan.kim dw.im gustavo.noronha gustavo joone.hur kevin.cs.oh kinuko laszlo.gombos levin+threading mathstuf phatina pnormand webkit.review.bot xan.lopez zan oldest_to_newest 384897 0 mrobinson 2011-04-13 08:15:04 -0700 WebKitGTK+ does not currently support the filesystem API. 384899 1 mrobinson 2011-04-13 08:15:21 -0700 *** Bug 57925 has been marked as a duplicate of this bug. *** 396374 2 phatina 2011-05-02 07:20:23 -0700 Do you mean something else than Source/WebCore/platform/gtk/FileSystemGtk.cpp? - which is the implementation of Souce/WebCore/platform/FileSystem.h (this can be found in r84622) 396395 3 mrobinson 2011-05-02 08:55:04 -0700 Yes. I believe this is the relevant draft: http://dev.w3.org/2009/dap/file-system/pub/FileSystem/ 442415 4 102035 zan 2011-07-26 11:53:10 -0700 Created attachment 102035 WIP patch This is a work-in-progress patch that brings support for FileSystem API to Gtk port. This is a first implementation (AFAIK) for a port that uses JavaScriptCore so some fixes were needed in bindings/js. The only other port to implement this feature is Chromium, so some changes (for instance those in LocalFileSystem class) should be discussed to avoid any problems. Also to discuss are the possible security problems and additional API for Gtk port. AsyncFileSystemGtk, AsyncFileWriterGtk and AsyncFileWriterClientGtk are implemented. Two helper classes are also added - AsyncFileSystemTaskControllerGtk and AsyncFileSystemCallbacksGtk. The first controls posting tasks to ScriptExecutionContext (either a Document object or a Worker) and the second is used to wrap normal callbacks and properly execute them using a task controller. With this patch non-worker tests in fast/filesystems/ (24 of them) pass flawlessly. When running a single worker test, for example async-operations.html, repeating it 5 times, the second time the test fails because of a malformed EntryArray object (object has undefined length when there are actual entries that were read) and the third time the test crashes because of what appears to be an already freed HashEntry key. Here's the backtrace: Program received signal SIGSEGV, Segmentation fault. [Switching to Thread 0x7fff9cd31700 (LWP 15534)] 0x00007ffff4458540 in JSC::HashEntry::key (this=0x72) at ../../Source/JavaScriptCore/runtime/Lookup.h:76 76 StringImpl* key() const { return m_key; } #0 0x00007ffff4458540 in JSC::HashEntry::key (this=0x72) at ../../Source/JavaScriptCore/runtime/Lookup.h:76 No locals. #1 0x00007ffff44586fb in JSC::HashTable::entry (this=0x7ffff750a020, identifier=...) at ../../Source/JavaScriptCore/runtime/Lookup.h:169 __PRETTY_FUNCTION__ = "const JSC::HashEntry* JSC::HashTable::entry(const JSC::Identifier&) const" entry = 0x72 #2 0x00007ffff4458640 in JSC::HashTable::entry (this=0x7ffff750a020, exec=0x7fff9b9300c0, identifier=...) at ../../Source/JavaScriptCore/runtime/Lookup.h:155 No locals. #3 0x00007ffff529756e in WebCore::JSEntryArray::getOwnPropertySlot (this=0x7ffff7ecba38, exec=0x7fff9b9300c0, propertyName=..., slot=...) at DerivedSources/WebCore/JSEntryArray.cpp:165 entry = 0x7fff9cd30310 ok = false index = 4425488 #4 0x00007ffff77e67e5 in JSC::JSCell::fastGetOwnPropertySlot (this=0x7ffff7ecba38, exec=0x7fff9b9300c0, propertyName=..., slot=...) at ../../Source/JavaScriptCore/runtime/JSObject.h:536 No locals. #5 0x00007ffff785c39f in JSC::JSValue::get (this=0x7fff9cd30430, exec=0x7fff9b9300c0, propertyName=..., slot=...) at ../../Source/JavaScriptCore/runtime/JSObject.h:788 prototype = {u = {asInt64 = 0, ptr = 0x0, asBits = {payload = 0, tag = 0}}} cell = 0x7ffff7ecba38 #6 0x00007ffff788b736 in JSC::cti_op_get_by_id (args=0x7fff9cd30480) ---Type <return> to continue, or q <return> to quit--- at ../../Source/JavaScriptCore/jit/JITStubs.cpp:1563 stackHack = {stackFrame = @0x7fff9cd30480, savedReturnAddress = {m_value = 0x7fff9d950c68}} callFrame = 0x7fff9b9300c0 slot = {m_getValue = 0x7fff9b930118, m_getIndexValue = 0x2, m_slotBase = {u = {asInt64 = 140737352874552, ptr = 0x7ffff7ecba38, asBits = {payload = -135480776, tag = 32767}}}, m_data = {getterFunc = 0xdf8350, index = 14648144}, m_value = {u = {asInt64 = 0, ptr = 0x0, asBits = {payload = 0, tag = 0}}}, m_thisValue = {u = {asInt64 = 0, ptr = 0x0, asBits = {payload = 0, tag = 0}}}, m_offset = 0, m_cachedPropertyType = JSC::PropertySlot::Uncacheable} stubInfo = 0x7fff9cd30480 stackFrame = @0x7fff9cd30480 ident = @0xdf5550 baseValue = {u = {asInt64 = 140737352874552, ptr = 0x7ffff7ecba38, asBits = {payload = -135480776, tag = 32767}}} result = {u = {asInt64 = 140735824462960, ptr = 0x7fff9cd30470, asBits = {payload = -1663892368, tag = 32767}}} codeBlock = 0x7fff9cd30480 #7 0x00007ffff7889d65 in JSC::JITThunks::tryCacheGetByID (callFrame=0x7fff9cd303a0, codeBlock=0x7fff9cd303d0, returnAddress=..., baseValue=..., propertyName=..., slot=..., stubInfo=0x7ffff7ecba38) at ../../Source/JavaScriptCore/jit/JITStubs.cpp:941 No locals. #8 0x00007fff9cd304b0 in ?? () . . . This might be a problem in how AsyncFileSystemTaskControllerGtk utilizes workers or maybe even how JavaScriptCore implements them. Given all the worker tests pass when running with --singly flag it might be a matter of a hash table not cleared or something similar ... Throughout the patch there might be memory leaks and debugging leftovers. This is a work-in-progress patch, not meant for review, but don't worry, such things will be fixed or removed before a patch is posted for reviewing. I am open to discussion about approach and fixing the worker crashes. 448944 5 webkit.review.bot 2011-08-09 19:15:38 -0700 Attachment 102035 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/fast/filesystem/script-tests/f..." exit_code: 1 Source/WebCore/platform/gtk/AsyncFileWriterGtk.h:8: Alphabetical sorting problem. [build/include_order] [4] Source/WebCore/platform/gtk/AsyncFileWriterGtk.cpp:15: Alphabetical sorting problem. [build/include_order] [4] Source/WebCore/platform/gtk/AsyncFileWriterGtk.cpp:44: Local variables should never be PassRefPtr (see http://webkit.org/coding/RefPtr.html). [readability/pass_ptr] [5] Source/WebCore/platform/gtk/AsyncFileWriterGtk.cpp:49: Should have a space between // and comment [whitespace/comments] [4] Source/WebCore/platform/gtk/AsyncFileWriterGtk.cpp:53: Should have a space between // and comment [whitespace/comments] [4] Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:11: Alphabetical sorting problem. [build/include_order] [4] Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.h:14: This { should be at the end of the previous line [whitespace/braces] [4] Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.h:32: The parameter name "writer" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/platform/gtk/AsyncFileSystemGtk.h:32: The parameter name "client" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/platform/gtk/AsyncFileSystemTaskControllerGtk.cpp:22: One line control clauses should not use braces. [whitespace/braces] [4] Source/WebCore/platform/gtk/AsyncFileSystemTaskControllerGtk.cpp:77: Should have a space between // and comment [whitespace/comments] [4] Source/WebCore/platform/gtk/AsyncFileSystemTaskControllerGtk.cpp:106: Should have a space between // and comment [whitespace/comments] [4] Source/WebCore/platform/gtk/AsyncFileWriterClientGtk.h:8: Alphabetical sorting problem. [build/include_order] [4] Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:20: Alphabetical sorting problem. [build/include_order] [4] Source/WebCore/platform/gtk/AsyncFileSystemTaskControllerGtk.h:16: This { should be at the end of the previous line [whitespace/braces] [4] Source/WebCore/platform/gtk/AsyncFileSystemTaskControllerGtk.h:28: The parameter name "taskMode" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 16 in 21 files If any of these errors are false positives, please file a bug against check-webkit-style. 557303 6 kevin.cs.oh 2012-02-15 08:37:27 -0800 Any progress? :) 590952 7 kevin.cs.oh 2012-03-29 01:55:27 -0700 Let me continue this bug, I may able to share my patch in a few days. :) 595456 8 135569 kevin.cs.oh 2012-04-04 05:43:58 -0700 Created attachment 135569 Patch 595655 9 135620 kevin.cs.oh 2012-04-04 10:23:13 -0700 Created attachment 135620 Patch 595660 10 kevin.cs.oh 2012-04-04 10:26:23 -0700 (In reply to comment #9) > Created an attachment (id=135620) [details] > Patch Updated copyright for Zan Dobersek. @Zan Dobersek, I added your copyright. But if you think you need to modify it, let me know. :) 596441 11 135795 kevin.cs.oh 2012-04-05 03:15:12 -0700 Created attachment 135795 Patch 596445 12 kevin.cs.oh 2012-04-05 03:18:59 -0700 (In reply to comment #11) > Created an attachment (id=135795) [details] > Patch Removed fast/filesystem/flags-passing.html in Skipped list. Because the test has a bug and it's resolved in bug 83137. 597020 13 gustavo 2012-04-05 16:42:14 -0700 *** Bug 82853 has been marked as a duplicate of this bug. *** 597065 14 kevin.cs.oh 2012-04-05 17:43:59 -0700 *** Bug 82855 has been marked as a duplicate of this bug. *** 597111 15 135795 gustavo 2012-04-05 18:39:12 -0700 Comment on attachment 135795 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=135795&action=review OK, I'm starting to grasp this code a bit more. I still need to do some more reading of the spec and understand the interaction with ScriptController, I'll probably be able to do it over the weekend, I have a few comments for now: > Source/WebCore/Modules/filesystem/LocalFileSystem.cpp:55 > +#if PLATFORM(GTK) > +#include "AsyncFileSystemCallbacksGtk.h" > +#endif > + We're essentially replacing the whole file for GTK+, I don't see any reason to use #if PLATFORM(GTK) in this file at all, better do like Chromium: http://trac.webkit.org/browser/trunk/Source/WebCore/Modules/filesystem/LocalFileSystem.cpp#L34 > Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:3 > + * Copyright (C) 2012 ChangSeok Oh <shivamidow@gmail.com> This file seems to be essentially unchanged from Zan's patch, except for some code shuffling, so I think he should be the only copyright holder. > Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.h:3 > + * Copyright (C) 2012 ChangSeok Oh <shivamidow@gmail.com> Ditto. Please check for more such cases =) > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:34 > +#include "LocalFileSystem.h" > #include "NotImplemented.h" > Empty line, don't need NotImplemented.h anymore, too. > LayoutTests/platform/gtk/Skipped:304 > +# Following tests are passed, if FileSystem API feature is enabled. I think when we land this we should enable filesystem by default in build-webkit, so that it gets tested in the bots. 598268 16 136219 kevin.cs.oh 2012-04-09 07:25:25 -0700 Created attachment 136219 Patch 598274 17 135795 kevin.cs.oh 2012-04-09 07:32:04 -0700 Comment on attachment 135795 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=135795&action=review Thank you for the review :) >> Source/WebCore/Modules/filesystem/LocalFileSystem.cpp:55 >> + > > We're essentially replacing the whole file for GTK+, I don't see any reason to use #if PLATFORM(GTK) in this file at all, better do like Chromium: http://trac.webkit.org/browser/trunk/Source/WebCore/Modules/filesystem/LocalFileSystem.cpp#L34 Done. >> Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:3 >> + * Copyright (C) 2012 ChangSeok Oh <shivamidow@gmail.com> > > This file seems to be essentially unchanged from Zan's patch, except for some code shuffling, so I think he should be the only copyright holder. O.K Acceptable :) I removed my copyright except LocalFileSystemGtk.cpp, AsyncFileSystemGtk.cpp, & AsyncFileWriterGtk.cpp >> Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.h:3 >> + * Copyright (C) 2012 ChangSeok Oh <shivamidow@gmail.com> > > Ditto. Please check for more such cases =) Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:34 >> > > Empty line, don't need NotImplemented.h anymore, too. Done. Removed. >> LayoutTests/platform/gtk/Skipped:304 >> +# Following tests are passed, if FileSystem API feature is enabled. > > I think when we land this we should enable filesystem by default in build-webkit, so that it gets tested in the bots. Done. Enabled file-system for gtk port in build-webkit. And also I removed passed tests here. 598318 18 136219 gustavo 2012-04-09 09:14:54 -0700 Comment on attachment 136219 Patch Attachment 136219 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/12373209 598345 19 136219 gustavo.noronha 2012-04-09 09:40:38 -0700 Comment on attachment 136219 Patch Attachment 136219 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/12373216 599139 20 136422 kevin.cs.oh 2012-04-10 04:08:44 -0700 Created attachment 136422 Patch 599140 21 136422 kevin.cs.oh 2012-04-10 04:09:30 -0700 Comment on attachment 136422 Patch Fixed build break for WK2 599151 22 136422 pnormand 2012-04-10 04:23:50 -0700 Comment on attachment 136422 Patch Attachment 136422 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/12370989 599404 23 kevin.cs.oh 2012-04-10 10:45:36 -0700 (In reply to comment #22) > (From update of attachment 136422 [details]) > Attachment 136422 [details] did not pass gtk-ews (gtk): > Output: http://queues.webkit.org/results/12370989 It seems false alarm. I guess the build bot needs clean build. 602769 24 136422 gustavo 2012-04-15 10:33:46 -0700 Comment on attachment 136422 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=136422&action=review > Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:127 > +void AsyncFileSystemCallbacksGtk::didReadDirectoryEntries(bool hasMore) This hasMore parameter seems to be completely useless. It doesn't seem to be used outside of this class, and is used in the others because of the way they manage the list of directories that still need to be read is different. > Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:136 > + Vector<DirectoryEntry>::iterator end = m_directoryEntries.end(); > + for (Vector<DirectoryEntry>::iterator it = m_directoryEntries.begin(); it != end; ++it) > + m_callbacks->didReadDirectoryEntry(it->name, it->isDirectory); > + > + m_directoryEntries.clear(); This makes mse wonder. The way we're handling things is when we find a directory, we call didReadDirectoryEntry with isDirectory as true, and append the entry to m_directoryEntries. But we got the end iterator before the loop. I'm pretty sure the end iterator we got there won't be moved as new entries are added, so we will end up clearing them here and not reading them, am I missing something? Would using the strategy adopted by Chromium be any better? It seems simpler. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:84 > + if (originString == String("null")) > + return String(); > + In addition to this check we should also have an ASSERT and check for type not being one we're expecting. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:92 > + if (type() == Temporary) > + result.append(temporaryPathPrefix); > + if (type() == Persistent) > + result.append(persistentPathPrefix); This would be best as else if. You can use an ASSERT + empty return on the else clause if you prefer that instead of checking/asserting above. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:103 > + GRefPtr<GFileInfo> sourceInfo = adoptGRef(g_file_query_info(sourceFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); We don't need to query all attributes if we're only going to use name, and type. Make this "standard::*". > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:109 > + GRefPtr<GFileInfo> destinationInfo = adoptGRef(g_file_query_info(destinationFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); Ditto. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:115 > + helperCallbacks->didFail(FileError::INVALID_MODIFICATION_ERR); Would type mismatch make more sense here? http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#dfn-typemismatcherror > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:120 > + helperCallbacks->didFail(FileError::INVALID_MODIFICATION_ERR); How about PathExistsError for this one? > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:126 > + helperCallbacks->didFail(FileError::NOT_FOUND_ERR); This would be much better if we actually used the error to check what happened and were able to report a more informative error. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:147 > + GOwnPtr<GDir> directory(g_dir_open(g_file_get_path(sourceDirectory), 0, error)); This does not use GIO... I am here pondering if that may be problematic in the future, but I don't think there are any reasons to believe source/destination here would be outside of the main file system, is there? Still I would prefer if we used g_file_enumerate_children instead for this function, how's that? > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:155 > + GRefPtr<GFileInfo> sourceInfo = adoptGRef(g_file_query_info(sourceFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, error)); Looks like we only need G_FILE_ATTRIBUTE_STANDARD_TYPE here. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:160 > + return; Hmm. So we found a directory, then we copy recursively and return? This would make no sense if we're trying to copy everything. You probably forgot to do the error check before returning? > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:179 > + GRefPtr<GFileInfo> destinationInfo = adoptGRef(g_file_query_info(destinationFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); G_FILE_ATTRIBUTE_STANDARD_TYPE seems to be enough here as well. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:191 > + if (destinationInfo) { > + GFileType destinationFileType = g_file_info_get_file_type(destinationInfo.get()); > + if (sourceFileType != destinationFileType) { > + helperCallbacks->didFail(FileError::INVALID_MODIFICATION_ERR); > + return; > + } > + if (destinationFileType == G_FILE_TYPE_DIRECTORY > + && !g_file_delete(destinationFile.get(), 0, 0)) { > + helperCallbacks->didFail(FileError::INVALID_MODIFICATION_ERR); > + return; > + } > + } This is the same as the code above, the same comments apply, and consider making this a helper function, I think. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:197 > + helperCallbacks->didFail(FileError::NOT_FOUND_ERR); Better error reporting would be great =) maybe have a helper function that translates GIOErrors to FileErrors. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:223 > + GOwnPtr<GDir> directory(g_dir_open(g_file_get_path(file), 0, error)); Same here, enumerate children perhaps? > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:252 > + if (error) { > + FileError::ErrorCode errorCode; > + switch (error->code) { > + case G_IO_ERROR_NOT_EMPTY: > + errorCode = FileError::INVALID_MODIFICATION_ERR; > + break; > + case G_IO_ERROR_NOT_FOUND: > + default: > + errorCode = FileError::NOT_FOUND_ERR; > + } That's more like it =). Here's the seed for our helper function! > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:280 > + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(file.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); "standard::*,time::*" looks right for here. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:313 > + if (type == G_FILE_TYPE_REGULAR && absolutePath == String("/")) { > + helperCallbacks->didFail(FileError::SECURITY_ERR); > + return; > + } Why do we need this check? Is this denying creating the root directory (of the filesystem hierarchy)? Wouldn't that be checked at a higher level? > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:328 > + errorCode = FileError::INVALID_MODIFICATION_ERR; PathExistsError seems to be a better choice here. (http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#dfn-pathexistserror) > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:362 > + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(object.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); G_FILE_ATTRIBUTE_STANDARD_TYPE > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:400 > + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(child.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); Ditto. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:408 > + } else { > + callbacks->didFail(FileError::NOT_FOUND_ERR); > + return; > + } Instead of checking for !error it would be better to check for error and remove the indentation for the normal case. if (error) { callbacks->didFail(FileError::NOT_FOUND_ERR); return; } ...rest of code here ... > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:424 > + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(file.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); G_FILE_ATTRIBUTE_STANDARD_SIZE > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:446 > +void AsyncFileSystemGtk::createSnapshotFileAndReadMetadata(const String& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks) > +{ > + // FIXME: Is this api really same with readMetadata? > + readMetadata(path, callbacks); > +} I'm pretty sure it isn't. File creation is certainly involved here. It seems to be called by DOMFileSystemSync::createFile and DOMFileSystem::createFile. The tests we have do not exercise this? > Source/WebCore/platform/gtk/AsyncFileSystemTaskControllerGtk.h:64 > +#endif // AsyncFileSystemCallbacks_h Name is wrong here. > LayoutTests/platform/gtk/Skipped:287 > +# Passed but we should enable file-system & mutation-observers at the same time. Anything stops us from doing that? =) 602799 25 gustavo 2012-04-15 15:39:59 -0700 The good news is the patch build ok in a clean build here. =) 605420 26 136422 kevin.cs.oh 2012-04-19 00:17:26 -0700 Comment on attachment 136422 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=136422&action=review Thanks for the your kind review! >> Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:127 >> +void AsyncFileSystemCallbacksGtk::didReadDirectoryEntries(bool hasMore) > > This hasMore parameter seems to be completely useless. It doesn't seem to be used outside of this class, and is used in the others because of the way they manage the list of directories that still need to be read is different. Removed it. >> Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:136 >> + m_directoryEntries.clear(); > > This makes mse wonder. The way we're handling things is when we find a directory, we call didReadDirectoryEntry with isDirectory as true, and append the entry to m_directoryEntries. But we got the end iterator before the loop. I'm pretty sure the end iterator we got there won't be moved as new entries are added, so we will end up clearing them here and not reading them, am I missing something? Would using the strategy adopted by Chromium be any better? It seems simpler. Done like chromium's way. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:84 >> + > > In addition to this check we should also have an ASSERT and check for type not being one we're expecting. Inserted ASSERT in below else clause. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:92 >> + result.append(persistentPathPrefix); > > This would be best as else if. You can use an ASSERT + empty return on the else clause if you prefer that instead of checking/asserting above. Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:103 >> + GRefPtr<GFileInfo> sourceInfo = adoptGRef(g_file_query_info(sourceFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); > > We don't need to query all attributes if we're only going to use name, and type. Make this "standard::*". Replaced the way how we get the file type, with using g_file_query_file_type. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:109 >> + GRefPtr<GFileInfo> destinationInfo = adoptGRef(g_file_query_info(destinationFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); > > Ditto. Ditto. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:115 >> + helperCallbacks->didFail(FileError::INVALID_MODIFICATION_ERR); > > Would type mismatch make more sense here? http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#dfn-typemismatcherror Yeh. It looks reasonable but failed on fast/filesystem/op-move.html if we do like that. It might be an issue of the testcase itself. I think we need to discuss with the original author of it more. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:120 >> + helperCallbacks->didFail(FileError::INVALID_MODIFICATION_ERR); > > How about PathExistsError for this one? Ditto. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:126 >> + helperCallbacks->didFail(FileError::NOT_FOUND_ERR); > > This would be much better if we actually used the error to check what happened and were able to report a more informative error. Done. I added a new function toFileErrorCode which converts GError to FileError to check what happened. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:147 >> + GOwnPtr<GDir> directory(g_dir_open(g_file_get_path(sourceDirectory), 0, error)); > > This does not use GIO... I am here pondering if that may be problematic in the future, but I don't think there are any reasons to believe source/destination here would be outside of the main file system, is there? Still I would prefer if we used g_file_enumerate_children instead for this function, how's that? I think it's a better approach. Done :) >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:155 >> + GRefPtr<GFileInfo> sourceInfo = adoptGRef(g_file_query_info(sourceFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, error)); > > Looks like we only need G_FILE_ATTRIBUTE_STANDARD_TYPE here. We're going to use g_file_query_file_type glib utility function to just get the file type. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:160 >> + return; > > Hmm. So we found a directory, then we copy recursively and return? This would make no sense if we're trying to copy everything. You probably forgot to do the error check before returning? Right. It looks there is a logical bug. Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:179 >> + GRefPtr<GFileInfo> destinationInfo = adoptGRef(g_file_query_info(destinationFile.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); > > G_FILE_ATTRIBUTE_STANDARD_TYPE seems to be enough here as well. Done. We're going to use g_file_query_file_type to get the file type. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:191 >> + } > > This is the same as the code above, the same comments apply, and consider making this a helper function, I think. Done. Added a helper function, validateFileType. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:197 >> + helperCallbacks->didFail(FileError::NOT_FOUND_ERR); > > Better error reporting would be great =) maybe have a helper function that translates GIOErrors to FileErrors. Done with adding toFileErrorCode. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:223 >> + GOwnPtr<GDir> directory(g_dir_open(g_file_get_path(file), 0, error)); > > Same here, enumerate children perhaps? Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:252 >> + } > > That's more like it =). Here's the seed for our helper function! Yep. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:280 >> + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(file.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); > > "standard::*,time::*" looks right for here. Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:313 >> + } > > Why do we need this check? Is this denying creating the root directory (of the filesystem hierarchy)? Wouldn't that be checked at a higher level? We should prevent creating a new file in upper directory than baseFileSystemPath(logically '/'). Some users (maybe contents) may try to access upper directory by using relative path like '..'. But we should not allow it becuase of the security issue I think. If that kind of invalid path comes in, a higher level (DOMFileSystemBase) converts it to '/', so we here get '/'. If we don't deal with it here. we might face some failures. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:328 >> + errorCode = FileError::INVALID_MODIFICATION_ERR; > > PathExistsError seems to be a better choice here. (http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#dfn-pathexistserror) I think it needs more discussion. :\ >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:362 >> + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(object.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); > > G_FILE_ATTRIBUTE_STANDARD_TYPE Replaced with g_file_query_file_type. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:400 >> + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(child.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); > > Ditto. Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:408 >> + } > > Instead of checking for !error it would be better to check for error and remove the indentation for the normal case. > > if (error) { > callbacks->didFail(FileError::NOT_FOUND_ERR); > return; > } > > ...rest of code here ... Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:424 >> + GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(file.get(), "*", G_FILE_QUERY_INFO_NONE, 0, 0)); > > G_FILE_ATTRIBUTE_STANDARD_SIZE Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:446 >> +} > > I'm pretty sure it isn't. File creation is certainly involved here. It seems to be called by DOMFileSystemSync::createFile and DOMFileSystem::createFile. The tests we have do not exercise this? Done. There is a test for this, but it works without any problem. :p I guess the already existing file affects the test case result. My current implementation might not be perfect now since less information what this API does. Let me watch this... >> Source/WebCore/platform/gtk/AsyncFileSystemTaskControllerGtk.h:64 >> +#endif // AsyncFileSystemCallbacks_h > > Name is wrong here. Done >> LayoutTests/platform/gtk/Skipped:287 >> +# Passed but we should enable file-system & mutation-observers at the same time. > > Anything stops us from doing that? =) Removed as well. :) 605421 27 137858 kevin.cs.oh 2012-04-19 00:20:50 -0700 Created attachment 137858 Patch 605425 28 137858 kevin.cs.oh 2012-04-19 00:21:41 -0700 Comment on attachment 137858 Patch This might require clean build. 605427 29 webkit.review.bot 2012-04-19 00:24:29 -0700 Attachment 137858 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/plat..." exit_code: 1 LayoutTests/platform/gtk/test_expectations.txt:366: Duplicate or ambiguous expectation. editing/undo/undo-smart-delete-reversed-selection.html [test/expectations] [5] Total errors found: 1 in 22 files If any of these errors are false positives, please file a bug against check-webkit-style. 605432 30 137860 kevin.cs.oh 2012-04-19 00:36:11 -0700 Created attachment 137860 Patch 605433 31 webkit.review.bot 2012-04-19 00:39:33 -0700 Attachment 137860 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/plat..." exit_code: 1 LayoutTests/platform/gtk/test_expectations.txt:366: Duplicate or ambiguous expectation. editing/undo/undo-smart-delete-reversed-selection.html [test/expectations] [5] Total errors found: 1 in 22 files If any of these errors are false positives, please file a bug against check-webkit-style. 605434 32 137861 kevin.cs.oh 2012-04-19 00:46:40 -0700 Created attachment 137861 Patch 605437 33 137861 kevin.cs.oh 2012-04-19 00:48:14 -0700 Comment on attachment 137861 Patch Removed a duplicated test above. 605438 34 137861 pnormand 2012-04-19 00:52:02 -0700 Comment on attachment 137861 Patch Attachment 137861 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/12297248 606059 35 gustavo 2012-04-19 15:58:29 -0700 (In reply to comment #26) > > I'm pretty sure it isn't. File creation is certainly involved here. It seems to be called by DOMFileSystemSync::createFile and DOMFileSystem::createFile. The tests we have do not exercise this? > > Done. There is a test for this, but it works without any problem. :p I guess the already existing file affects the test case result. My current implementation might not be perfect now since less information what this API does. Let me watch this... What test tests this? 606156 36 137861 gustavo 2012-04-19 16:43:34 -0700 Comment on attachment 137861 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=137861&action=review r- just because I'd like to be sure we know what we're doing at createObjectAndReadMetadataAsync, so I think we need another iteration. > Source/WebCore/GNUmakefile.list.am:4999 > +webcore_sources += \ > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp \ > Source/WebCore/platform/gtk/AsyncFileSystemGtk.h Why did you move these to webcore_sources? > Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:131 > +void AsyncFileSystemCallbacksGtk::didReadDirectoryEntries(bool) > +{ > + for (size_t i = 0; i < m_directoryEntries.size(); ++i) > + m_callbacks->didReadDirectoryEntry(m_directoryEntries[i].name, m_directoryEntries[i].isDirectory); > + m_directoryEntries.clear(); > + > + m_taskController->postCallbackTask(createCallbackTask(&performDidReadDirectoryEntriesAndFinishedCallback, m_callbacks.release()), m_taskMode); > +} I think you addressed my concern by removing the recursive listing, now you're not even trying to read the directories that are found. Is that acceptable? It's starting to look like it's what's intended from reading the spec and the code. The spec indicates a call to readEntries returns the 'next block' of entries, which is why there's a hasMore boolean here - you're not expected to return all entries at once. We may want to look into that, but I don't think it's very important right now: http://www.w3.org/TR/file-system-api/#the-directoryreader-interface > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:65 > +static FileError::ErrorCode validateFileType(GFile* sourceFile, GFile* destinationFile) validateFileTypes sounds like a better choice > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:242 > + if (recursive && g_file_test(filePath.get(), G_FILE_TEST_IS_DIR)) { We can use query_file_type here too, instead of testing the path. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:329 > + ASSERT(type == G_FILE_TYPE_REGULAR || type == G_FILE_TYPE_DIRECTORY); > + // We should not allow to access upper directory to create a new file than base directory > + // because of the security issue. > + if (type == G_FILE_TYPE_REGULAR && absolutePath == String("/")) { > + helperCallbacks->didFail(FileError::SECURITY_ERR); > + return; > + } I understand the security implications but I am still really doubtful we need this check. Wouldn't higher level stuff check for someone trying to create /? The comment as it is is not very useful, I would prefer if it explained why we need to do this check here. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:342 > + if (error) { > + if (!needToReadMetadata || error->code != G_IO_ERROR_EXISTS) { > + helperCallbacks->didFail(toFileErrorCode(error.get())); > + return; > + } > + } I am not sure I understand. This is very convoluted. Why do we only complain about the error if it's not a file exists? We should make all of these checks in 1 if, in any case. > Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:348 > + helperCallbacks->didSucceed(); I believe you need to report success also after reading metadata. 607840 37 138384 kevin.cs.oh 2012-04-23 10:56:28 -0700 Created attachment 138384 Patch 608330 38 137861 kevin.cs.oh 2012-04-23 20:16:16 -0700 Comment on attachment 137861 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=137861&action=review Thank you for your thoughtful review. :) >> Source/WebCore/GNUmakefile.list.am:4999 >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.h > > Why did you move these to webcore_sources? Because of build-break for WK2. AsyncFileSystemGtk.cpp uses temporaryPathPrefix & persistentPathPrefix, but they are defined in AsyncFileSystem.cpp that included in webcore_sources. >> Source/WebCore/platform/gtk/AsyncFileSystemCallbacksGtk.cpp:131 >> +} > > I think you addressed my concern by removing the recursive listing, now you're not even trying to read the directories that are found. Is that acceptable? It's starting to look like it's what's intended from reading the spec and the code. The spec indicates a call to readEntries returns the 'next block' of entries, which is why there's a hasMore boolean here - you're not expected to return all entries at once. We may want to look into that, but I don't think it's very important right now: http://www.w3.org/TR/file-system-api/#the-directoryreader-interface > I think you addressed my concern by removing the recursive listing, now you're not even trying to read the directories that are found. Is that acceptable? In my humble opinion, yes it is. We don't need to actually read directory & do something here. we just gather directory entries and return them to JS layer. That's enough. :) > The spec indicates a call to readEntries returns the 'next block' of entries, which is why there's a hasMore boolean here - you're not expected to return all entries at once. I think there is no problem too, though we return all directory entries at once. The spec is just saying that readEntries might not return all entries for a single call, so users need to check if the returned entries is empty array. In our case, we can return all entries at once and then return empty block, so it seems suitable to the spec. But I'm still not understand clearly what the situation is when we need to read directories more here. I guess we may need to check 'hasmore' for multithread model(workers)... >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:65 >> +static FileError::ErrorCode validateFileType(GFile* sourceFile, GFile* destinationFile) > > validateFileTypes sounds like a better choice Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:242 >> + if (recursive && g_file_test(filePath.get(), G_FILE_TEST_IS_DIR)) { > > We can use query_file_type here too, instead of testing the path. Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:329 >> + } > > I understand the security implications but I am still really doubtful we need this check. Wouldn't higher level stuff check for someone trying to create /? The comment as it is is not very useful, I would prefer if it explained why we need to do this check here. I've updated the comment but couldn't find a better place for this. :\ >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:342 >> + } > > I am not sure I understand. This is very convoluted. Why do we only complain about the error if it's not a file exists? We should make all of these checks in 1 if, in any case. Done. >> Source/WebCore/platform/gtk/AsyncFileSystemGtk.cpp:348 >> + helperCallbacks->didSucceed(); > > I believe you need to report success also after reading metadata. Actually we don't need to call didSucceed for reading metadata. didReadMetadata works similar to didSucceed for readMetadata api. You can refer the comment in AsyncFileSystem.h. :) It says.. > AsyncFileSystemCallbacks::didReadMetadata() is called when the operation is completed successfully. AsyncFileSystemCallbacks::didFail() is called otherwise. 608360 39 138384 mrobinson 2012-04-23 22:05:33 -0700 Comment on attachment 138384 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=138384&action=review This patch seems a bit too big to review at once. Why not try splitting it up? Since the API is divided into operations it makes sense to implement one per patch and unskip tests that pass with each iteration. One thing that I wonder about looking at this initially is the threading behavior. Instead of actually using the asychronous GIO APIs, the operations are just posted back to the main thread. That seems wrong -- unless this is supposed to be called from workers and all operations need to be on the main thread. Is that the case? If so perhaps it would be better to have a "filesystem thread" so that these operations don't block the main thread. > Source/WTF/wtf/gobject/GOwnPtr.cpp:54 > +template <> void freeOwnedGPtr<GOutputStream>(GOutputStream* ptr) > +{ > + g_output_stream_close(ptr, 0, 0); > +} > + GOutputStream is a reference counted GObject, so you should not use GOwnPtr to manage it. g_output_stream_close doesn't free a GOuputStream, only the internal bits. 608516 40 kevin.cs.oh 2012-04-24 03:47:35 -0700 (In reply to comment #39) > (From update of attachment 138384 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=138384&action=review > > This patch seems a bit too big to review at once. Why not try splitting it up? Since the API is divided into operations it makes sense to implement one per patch and unskip tests that pass with each iteration. Hmm.. I want to hear kov's thought. > One thing that I wonder about looking at this initially is the threading behavior. Instead of actually using the asychronous GIO APIs, the operations are just posted back to the main thread. That seems wrong -- unless this is supposed to be called from workers and all operations need to be on the main thread. Is that the case? If so perhaps it would be better to have a "filesystem thread" so that these operations don't block the main thread. Reasonable. How about sharing fileThread that is used by BLOB? 608588 41 mrobinson 2012-04-24 06:00:37 -0700 (In reply to comment #40) > Reasonable. How about sharing fileThread that is used by BLOB? What do other ports do? 608590 42 mrobinson 2012-04-24 06:01:09 -0700 (In reply to comment #41) > (In reply to comment #40) > > > Reasonable. How about sharing fileThread that is used by BLOB? > > What do other ports do? Another important question: Does the spec specify a certain behavior? 609458 43 kevin.cs.oh 2012-04-24 22:21:54 -0700 (In reply to comment #41) > (In reply to comment #40) > > > Reasonable. How about sharing fileThread that is used by BLOB? > > What do other ports do? Hard to know. It seems Chromium & Blackberry has the feature, but the code is not upstream yet. The only clue I got was LocalFileSystem.cpp uses "context->postTask ", so I believe other ports use main thread. 609478 44 kevin.cs.oh 2012-04-24 23:05:54 -0700 (In reply to comment #42) > (In reply to comment #41) > > (In reply to comment #40) > > > > > Reasonable. How about sharing fileThread that is used by BLOB? > > > > What do other ports do? > > Another important question: Does the spec specify a certain behavior? Nothing special related with asynchronous behavior, as I know. http://www.w3.org/TR/file-system-api/#the-asynchronous-filesystem-interface. 609784 45 mrobinson 2012-04-25 08:28:40 -0700 From this part of the spec it seems like these operations should not be on the main thread: > There are several ways in which a file system entry point can be obtained. Not all user agents may in > fact implement all of them. However, in order to avoid blocking UI actions while waiting on > filesystem IO, we define only an asynchronous interface for Window, and restrict the synchronous API > to the Worker context defined in 612570 46 gustavo 2012-04-30 06:21:41 -0700 I like Martin's idea of splitting the patch per operation, it is a great idea. What I do not agree with is just stubbing everything, that makes it impossible to do a meaninful review as well. About the threading issue, I understood it was being handled by having a thread be spawned by webcore and only the result would be posted to the main thread, isn't that correct? 612688 47 mrobinson 2012-04-30 09:25:07 -0700 (In reply to comment #46) > I like Martin's idea of splitting the patch per operation, it is a great idea. What I do not agree with is just stubbing everything, that makes it impossible to do a meaninful review as well. About the threading issue, I understood it was being handled by having a thread be spawned by webcore and only the result would be posted to the main thread, isn't that correct? I read the code and the spec a little and here's what I think is happening: There are two ways of using the filesystem API, synchronously and asynchronously. Currently, the argument that determines whether the filesystem is asynchronous is ignored. See the call to LocalFileSystem::requestFileSystem in WorkerContextFileSystem::webkitRequestFileSystemSync and note that the "synchronous" parameter is ignored completely. So before this patch can be reviewed, we need to determine (probably just by asking around) whether operations should be synchronous or asynchronous. My guess is that they should be asynchronous and that the synchronous version of the API will just block until the callback is called. If that's the case, this patch shouldn't be doing operations synchronously and definitely should not be doing them on the main thread. This API can be used from a worker thread. An easy way to accomplish this is to simply use the asychronous versions of the GIO APIs. 623177 48 zan 2012-05-14 11:59:16 -0700 Hi, first off thanks for taking up the work here and sorry for such a late reply. (In reply to comment #47) > There are two ways of using the filesystem API, synchronously and asynchronously. Currently, the argument that determines whether the filesystem is asynchronous is ignored. See the call to LocalFileSystem::requestFileSystem in WorkerContextFileSystem::webkitRequestFileSystemSync and note that the "synchronous" parameter is ignored completely. The synchronous methods are intended to be used with workers only. > So before this patch can be reviewed, we need to determine (probably just by asking around) whether operations should be synchronous or asynchronous. My guess is that they should be asynchronous and that the synchronous version of the API will just block until the callback is called. Operations (preferably GIO functions calls) should definitely be all asynchronous. The FileSystem API expects that all these operations are done via ScriptExecutionContext. This can be either a Document or a WorkerContext. If the former, calling scriptExecutionContext->postTask(task) will post the task on the main thread, if the latter, doing that will post the task on the worker thread. To use a unified approach for both cases the operations should all be asynchronous as, as said, you'd hate to clog up the main thread. When using a synchronous version of the FileSystem API (through workers) all the calls should still be asynchronous because when using that version the SyncCallbackHelpers[1] are used that basically wait until the operation is complete (either succeeds or fails, producing an error). > If that's the case, this patch shouldn't be doing operations synchronously and definitely should not be doing them on the main thread. This API can be used from a worker thread. An easy way to accomplish this is to simply use the asychronous versions of the GIO APIs. While I was still trying to get things working now almost a year back, the main problem I was facing was keeping the AsyncFileSystemCallbacks objects around long enough for the asynchronous operation to complete so the callbacks could be triggered. Just to top it off I was trying for every operation being as asynchronous as possible - from GIO operations to even the callbacks being fired asynchronously. [1] http://trac.webkit.org/browser/trunk/Source/WebCore/Modules/filesystem/SyncCallbackHelper.h 633924 49 mrobinson 2012-05-25 07:54:10 -0700 *** Bug 50948 has been marked as a duplicate of this bug. *** 734855 50 zan 2012-10-04 11:19:22 -0700 For what it's worth, the File API: Directories and System specification[1] is being considered for a move to the Note track[2]. Translated, it means the work on this particular specification will probably cease. There are already considerations of a similar but simplified approach though[3][4]. [1] http://dev.w3.org/2009/dap/file-system/file-dir-sys.html [2] http://lists.w3.org/Archives/Public/public-webapps/2012JulSep/0791.html [3] http://lists.w3.org/Archives/Public/public-webapps/2012JulSep/0823.html [4] http://lists.w3.org/Archives/Public/public-webapps/2012JulSep/0827.html 736575 51 dw.im 2012-10-08 01:49:54 -0700 (In reply to comment #50) > For what it's worth, the File API: Directories and System specification[1] is being considered for a move to the Note track[2]. > > Translated, it means the work on this particular specification will probably cease. There are already considerations of a similar but simplified approach though[3][4]. > > [1] http://dev.w3.org/2009/dap/file-system/file-dir-sys.html > [2] http://lists.w3.org/Archives/Public/public-webapps/2012JulSep/0791.html > [3] http://lists.w3.org/Archives/Public/public-webapps/2012JulSep/0823.html > [4] http://lists.w3.org/Archives/Public/public-webapps/2012JulSep/0827.html I don't think it is worthless. Because, there are already some web applications use this File System API to read/write files. And, there is no other way to do this kind of things until new file system spec is announced. So, I think still it is valuable to implement this File System API in WebKit. What do you think? 736586 52 zan 2012-10-08 02:11:30 -0700 (In reply to comment #51) > I don't think it is worthless. > > Because, there are already some web applications use this File System API to read/write files. > And, there is no other way to do this kind of things until new file system spec is announced. > > So, I think still it is valuable to implement this File System API in WebKit. > > What do you think? I'd agree it isn't worthless, the specification is not yet confirmed to be put on the Note track and there are indeed applications that use it. Furthermore the code used here might as well be reusable when implementing the future file system specification (if there'll actually be one). Despite all that, enabling this feature for the GTK port was on my personal long-term todo list but I won't really be picking the work up until the specification status clears up (though there might be someone else that will do the work, of which I'm totally supportive). 1092900 53 mrobinson 2015-05-07 17:38:44 -0700 Not sure this is going to happen. :/ 102035 2011-07-26 11:53:10 -0700 2011-07-26 11:53:10 -0700 WIP patch fsp text/plain 55456 zan ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZmlsZXN5c3RlbS9zY3JpcHQtdGVzdHMvZmxh Z3MtcGFzc2luZy5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZmlsZXN5c3RlbS9zY3JpcHQtdGVzdHMv ZmxhZ3MtcGFzc2luZy5qcwppbmRleCA2NGEyODljLi4yZjdkOTc5IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9mYXN0L2ZpbGVzeXN0ZW0vc2NyaXB0LXRlc3RzL2ZsYWdzLXBhc3NpbmcuanMKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9maWxlc3lzdGVtL3NjcmlwdC10ZXN0cy9mbGFncy1wYXNzaW5n LmpzCkBAIC04LDEyICs4LDEyIEBAIHZhciBleHBlY3RlZCA9IGZ1bmN0aW9uKGUpIHsgZXhwZWN0 ZWRDYWxsYmFja3NDb3VudCsrOyB9OwogdmFyIHVuZXhwZWN0ZWQgPSBmdW5jdGlvbihlKSB7IHVu ZXhwZWN0ZWRDYWxsYmFja3NDb3VudCsrOyB9OwogCiB2YXIgdGVzdHNMaXN0ID0gWwotICAgICdy dW5PYmplY3RUZXN0JywKLSAgICAncnVuT2JqZWN0VGVzdFdpdGhFeGNsdXNpdmUnLAotICAgICdj bGVhbnVwQW5kUnVuTmV4dCcsCi0gICAgJ3J1bkpTT05UZXN0JywKLSAgICAncnVuSlNPTlRlc3RX aXRoRXhjbHVzaXZlJywKLSAgICAncnVuTnVsbFRlc3QnCisgICAgcnVuT2JqZWN0VGVzdCwKKyAg ICBydW5PYmplY3RUZXN0V2l0aEV4Y2x1c2l2ZSwKKyAgICBjbGVhbnVwQW5kUnVuTmV4dCwKKyAg ICBydW5KU09OVGVzdCwKKyAgICBydW5KU09OVGVzdFdpdGhFeGNsdXNpdmUsCisgICAgcnVuTnVs bFRlc3QKIF07CiB2YXIgdGVzdENvdW50ZXIgPSAwOwogCkBAIC0yNCw3ICsyNCw3IEBAIGZ1bmN0 aW9uIHJ1bk5leHRUZXN0KHYpIHsKICAgICAgICAgc2hvdWxkQmUoJ3VuZXhwZWN0ZWRDYWxsYmFj a3NDb3VudCcsICcwJyk7CiAgICAgICAgIGZpbmlzaEpTVGVzdCgpOwogICAgIH0gZWxzZQotICAg ICAgICB0aGlzW3Rlc3RzTGlzdFt0ZXN0Q291bnRlcisrXV0oKTsKKyAgICAgICAgdGVzdHNMaXN0 W3Rlc3RDb3VudGVyKytdKCk7CiB9CiAKIGZ1bmN0aW9uIGVycm9yQ2FsbGJhY2soZXJyb3IpIHsK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkIGIvTGF5b3V0VGVz dHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKaW5kZXggMDk1ZjI4My4uZWEwNWQxYSAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vZ3RrL1NraXBwZWQKQEAgLTM2MSw5ICszNjEsMzEgQEAgaHR0cC90ZXN0cy9taXNjL3dl YnRpbWluZy1zc2wucGhwCiBodHRwL3Rlc3RzL21pc2Mvd2VidGltaW5nLXR3by1yZWRpcmVjdHMu cGhwCiAKICMgRmlsZVN5c3RlbSBBUEkgaXMgbm90IHN1cHBvcnRlZC4KLWZhc3QvZmlsZXN5c3Rl bQotaHR0cC90ZXN0cy9maWxlc3lzdGVtCi1odHRwL3Rlc3RzL2xvY2FsL2ZpbGVhcGkKKyMgYnVn aWQKKyNmYXN0L2ZpbGVzeXN0ZW0vZmxhZ3MtcGFzc2luZy5odG1sCisKK2Zhc3QvZmlsZXN5c3Rl bS93b3JrZXJzCisjZmFzdC9maWxlc3lzdGVtL3dvcmtlcnMvYXN5bmMtb3BlcmF0aW9ucy5odG1s CisjZmFzdC9maWxlc3lzdGVtL3dvcmtlcnMvZmlsZS1lbnRyeS10by11cmktc3luYy5odG1sCisj ZmFzdC9maWxlc3lzdGVtL3dvcmtlcnMvZmlsZS1mcm9tLWZpbGUtZW50cnkuaHRtbAorI2Zhc3Qv ZmlsZXN5c3RlbS93b3JrZXJzL2ZpbGUtZnJvbS1maWxlLWVudHJ5LXN5bmMuaHRtbAorI2Zhc3Qv ZmlsZXN5c3RlbS93b3JrZXJzL2ZpbGUtd3JpdGVyLWV2ZW50cy5odG1sCisjZmFzdC9maWxlc3lz dGVtL3dvcmtlcnMvZmlsZS13cml0ZXItZ2MtYmxvYi5odG1sCisjZmFzdC9maWxlc3lzdGVtL3dv cmtlcnMvZmlsZS13cml0ZXItc3luYy10cnVuY2F0ZS1leHRlbmQuaHRtbAorI2Zhc3QvZmlsZXN5 c3RlbS93b3JrZXJzL2ZpbGUtd3JpdGVyLXN5bmMtd3JpdGUtb3ZlcmxhcHBlZC5odG1sCisjZmFz dC9maWxlc3lzdGVtL3dvcmtlcnMvZmlsZS13cml0ZXItdHJ1bmNhdGUtZXh0ZW5kLmh0bWwKKyNm YXN0L2ZpbGVzeXN0ZW0vd29ya2Vycy9maWxlLXdyaXRlci13cml0ZS1vdmVybGFwcGVkLmh0bWwK KyNmYXN0L2ZpbGVzeXN0ZW0vd29ya2Vycy9zeW5jLW9wZXJhdGlvbnMuaHRtbAorCisjaHR0cC90 ZXN0cy9maWxlc3lzdGVtL25vLWNhY2hlLWZpbGVzeXN0ZW0tdXJsLmh0bWwKKyNodHRwL3Rlc3Rz L2ZpbGVzeXN0ZW0vcmVzb2x2ZS11cmkuaHRtbAorI2h0dHAvdGVzdHMvZmlsZXN5c3RlbS93b3Jr ZXJzL3Jlc29sdmUtdXJsLmh0bWwKKyNodHRwL3Rlc3RzL2ZpbGVzeXN0ZW0vd29ya2Vycy9yZXNv bHZlLXVybC1zeW5jLmh0bWwKKworaHR0cC90ZXN0cy9sb2NhbC9maWxlYXBpL2ZpbGUtbGFzdC1t b2RpZmllZC5odG1sCitodHRwL3Rlc3RzL2xvY2FsL2ZpbGVhcGkvc2VuZC1kcmFnZ2VkLWZpbGUu aHRtbAoraHR0cC90ZXN0cy9sb2NhbC9maWxlYXBpL3NlbmQtc2xpY2VkLWRyYWdnZWQtZmlsZS5o dG1sCisKIGh0dHAvdGVzdHMvc2VjdXJpdHkvZmlsZXN5c3RlbS1pZnJhbWUtZnJvbS1yZW1vdGUu aHRtbAogCiAjIFJlcXVpcmVzIFdlYlAgc3VwcG9ydC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0 LmFtCmluZGV4IGQ1NGI5ZDMuLjM2MzczZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dO VW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5h bQpAQCAtMTQ2Niw2ICsxNDY2LDcgQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2Vi Q29yZS9maWxlYXBpL0VudHJ5QXJyYXkuaCBcCiAJU291cmNlL1dlYkNvcmUvZmlsZWFwaS9FbnRy eUFycmF5U3luYy5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2ZpbGVhcGkvRW50cnlBcnJheVN5bmMu aCBcCisJU291cmNlL1dlYkNvcmUvZmlsZWFwaS9FbnRyeUJhc2UuY3BwIFwKIAlTb3VyY2UvV2Vi Q29yZS9maWxlYXBpL0VudHJ5QmFzZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9maWxlYXBpL0VudHJ5 Q2FsbGJhY2suaCBcCiAJU291cmNlL1dlYkNvcmUvZmlsZWFwaS9FbnRyeVN5bmMuY3BwIFwKQEAg LTM5MDksNiArMzkxMCwxNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9WaWRlb1NpbmtHU3RyZWFtZXIuaCBcCiAJ U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1dlYktpdFdlYlNvdXJj ZUdTdHJlYW1lci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJl YW1lci9XZWJLaXRXZWJTb3VyY2VHU3RyZWFtZXIuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAgXAorCVNvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCBcCisJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5jcHAgXAorCVNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuaCBcCisJU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmNwcCBcCisJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr LmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRH dGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJH dGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3Rr LmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9Db2xvckd0ay5jcHAg XAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2d0ay9Gb250R3RrLmNwcCBcCiAJ U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3RrL0dka0NhaXJvVXRpbGl0aWVzLmNw cCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpcmVjdG9yeUVu dHJ5U3luY0N1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpcmVjdG9y eUVudHJ5U3luY0N1c3RvbS5jcHAKaW5kZXggMjEwMDZhYi4uOTRmMTQ2ZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaXJlY3RvcnlFbnRyeVN5bmNDdXN0b20uY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGlyZWN0b3J5RW50cnlTeW5jQ3Vz dG9tLmNwcApAQCAtNTAsNyArNTAsNyBAQCBzdGF0aWMgUGFzc1JlZlB0cjxXZWJLaXRGbGFncz4g Z2V0RmxhZ3MoRXhlY1N0YXRlKiBleGVjLCBjb25zdCBKU1ZhbHVlJiBhcmd1bWVudAogICAgIGlm IChhcmd1bWVudC5pc051bGwoKSB8fCBhcmd1bWVudC5pc1VuZGVmaW5lZCgpIHx8ICFhcmd1bWVu dC5pc09iamVjdCgpKQogICAgICAgICByZXR1cm4gMDsKICAgICBpZiAoYXJndW1lbnQuaW5oZXJp dHMoJkpTV2ViS2l0RmxhZ3M6OnNfaW5mbykpCi0gICAgICAgIHJldHVybiB0b0ZsYWdzKGFyZ3Vt ZW50KTsKKyAgICAgICAgcmV0dXJuIHRvV2ViS2l0RmxhZ3MoYXJndW1lbnQpOwogCiAgICAgUmVm UHRyPFdlYktpdEZsYWdzPiBmbGFnczsKICAgICBKU09iamVjdCogb2JqZWN0ID0gYXJndW1lbnQu Z2V0T2JqZWN0KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0Vu dHJ5Q3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRW50cnlDdXN0b20u Y3BwCmluZGV4IDU5ZDdlM2MuLjI1NTJlMDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTRW50cnlDdXN0b20uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0pTRW50cnlDdXN0b20uY3BwCkBAIC01MCwxMCArNTAsMTAgQEAgSlNWYWx1ZSB0b0pTKEV4 ZWNTdGF0ZSogZXhlYywgSlNET01HbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgRW50cnkqIGVu dHJ5KQogICAgICAgICByZXR1cm4ganNOdWxsKCk7CiAKICAgICBpZiAoZW50cnktPmlzRmlsZSgp KQotICAgICAgICByZXR1cm4gZ2V0RE9NT2JqZWN0V3JhcHBlcjxKU0ZpbGVFbnRyeT4oZXhlYywg Z2xvYmFsT2JqZWN0LCBzdGF0aWNfY2FzdDxGaWxlRW50cnkqPihlbnRyeSkpOworICAgICAgICBy ZXR1cm4gd3JhcDxKU0ZpbGVFbnRyeT4oZXhlYywgZ2xvYmFsT2JqZWN0LCBzdGF0aWNfY2FzdDxG aWxlRW50cnkqPihlbnRyeSkpOwogCiAgICAgQVNTRVJUKGVudHJ5LT5pc0RpcmVjdG9yeSgpKTsK LSAgICByZXR1cm4gZ2V0RE9NT2JqZWN0V3JhcHBlcjxKU0RpcmVjdG9yeUVudHJ5PihleGVjLCBn bG9iYWxPYmplY3QsIHN0YXRpY19jYXN0PERpcmVjdG9yeUVudHJ5Kj4oZW50cnkpKTsKKyAgICBy ZXR1cm4gd3JhcDxKU0RpcmVjdG9yeUVudHJ5PihleGVjLCBnbG9iYWxPYmplY3QsIHN0YXRpY19j YXN0PERpcmVjdG9yeUVudHJ5Kj4oZW50cnkpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNFbnRyeVN5bmNDdXN0 b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNFbnRyeVN5bmNDdXN0b20uY3Bw CmluZGV4IDIyZjk2YWQuLjdhZDU3YzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL2pzL0pTRW50cnlTeW5jQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy9qcy9KU0VudHJ5U3luY0N1c3RvbS5jcHAKQEAgLTUwLDEwICs1MCwxMCBAQCBKU1ZhbHVlIHRv SlMoRXhlY1N0YXRlKiBleGVjLCBKU0RPTUdsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0LCBFbnRy eVN5bmMqIGVudHJ5KQogICAgICAgICByZXR1cm4ganNOdWxsKCk7CiAKICAgICBpZiAoZW50cnkt PmlzRmlsZSgpKQotICAgICAgICByZXR1cm4gZ2V0RE9NT2JqZWN0V3JhcHBlcjxKU0ZpbGVFbnRy eVN5bmM+KGV4ZWMsIGdsb2JhbE9iamVjdCwgc3RhdGljX2Nhc3Q8RmlsZUVudHJ5U3luYyo+KGVu dHJ5KSk7CisgICAgICAgIHJldHVybiB3cmFwPEpTRmlsZUVudHJ5U3luYz4oZXhlYywgZ2xvYmFs T2JqZWN0LCBzdGF0aWNfY2FzdDxGaWxlRW50cnlTeW5jKj4oZW50cnkpKTsKIAogICAgIEFTU0VS VChlbnRyeS0+aXNEaXJlY3RvcnkoKSk7Ci0gICAgcmV0dXJuIGdldERPTU9iamVjdFdyYXBwZXI8 SlNEaXJlY3RvcnlFbnRyeVN5bmM+KGV4ZWMsIGdsb2JhbE9iamVjdCwgc3RhdGljX2Nhc3Q8RGly ZWN0b3J5RW50cnlTeW5jKj4oZW50cnkpKTsKKyAgICByZXR1cm4gd3JhcDxKU0RpcmVjdG9yeUVu dHJ5U3luYz4oZXhlYywgZ2xvYmFsT2JqZWN0LCBzdGF0aWNfY2FzdDxEaXJlY3RvcnlFbnRyeVN5 bmMqPihlbnRyeSkpOwogfQogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0V2ZW50VGFyZ2V0LmNwcCBiL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTRXZlbnRUYXJnZXQuY3BwCmluZGV4IDJmM2Y2MWIuLmU4MmM2NzUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRXZlbnRUYXJnZXQuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRXZlbnRUYXJnZXQuY3BwCkBAIC0x MDUsNiArMTA1LDExIEBACiAjaW5jbHVkZSAiTWVkaWFTdHJlYW0uaCIKICNlbmRpZgogCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorI2luY2x1ZGUgIkZpbGVXcml0ZXIuaCIKKyNpbmNsdWRlICJK U0ZpbGVXcml0ZXIuaCIKKyNlbmRpZgorCiB1c2luZyBuYW1lc3BhY2UgSlNDOwogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CkBAIC0yMDIsNiArMjA3LDExIEBAIEpTVmFsdWUgdG9KUyhFeGVjU3RhdGUq IGV4ZWMsIEpTRE9NR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIEV2ZW50VGFyZ2V0KiB0YXJn CiAgICAgICAgIHJldHVybiB0b0pTKGV4ZWMsIGdsb2JhbE9iamVjdCwgc3RyZWFtKTsKICNlbmRp ZgogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorICAgIGlmIChGaWxlV3JpdGVyKiBmaWxlV3Jp dGVyID0gdGFyZ2V0LT50b0ZpbGVXcml0ZXIoKSkKKyAgICAgICAgcmV0dXJuIHRvSlMoZXhlYywg Z2xvYmFsT2JqZWN0LCBmaWxlV3JpdGVyKTsKKyNlbmRpZgorCiAgICAgQVNTRVJUX05PVF9SRUFD SEVEKCk7CiAgICAgcmV0dXJuIGpzTnVsbCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uY3BwIGIvU291cmNlL1dlYkNvcmUvZmlsZWFwaS9M b2NhbEZpbGVTeXN0ZW0uY3BwCmluZGV4IDk1NWQ3MjMuLjVjOTU3ZjEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2ZpbGVhcGkvTG9jYWxGaWxlU3lzdGVtLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTc2LDYgKzc2LDcgQEAgU3RyaW5n IExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKCkgY29uc3QKICAgICByZXR1cm4g bV9iYXNlUGF0aDsKIH0KIAorI2lmICFQTEFURk9STShHVEspCiBzdGF0aWMgdm9pZCBvcGVuRmls ZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwg Y29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgYm9v bCBjcmVhdGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3Mp CiB7CiAgICAgQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbShiYXNlUGF0aCwgaWRlbnRp ZmllciwgdHlwZSwgY3JlYXRlLCBjYWxsYmFja3MpOwpAQCAtOTIsNiArOTMsNyBAQCB2b2lkIExv Y2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgQXN5bmNGaQogICAgIC8vIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0g Y2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNvIHRoZSBtZXRob2QgbmVlZHMgdG8gYmUg Y2FsbGVkIGFzeW5jaHJvbm91c2x5LgogICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxi YWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0LT5z ZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgdHJ1ZSwgY2FsbGJh Y2tzKSk7CiB9CisjZW5kaWYKIAogfSAvLyBuYW1lc3BhY2UKIApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaCBiL1NvdXJjZS9XZWJDb3JlL2ZpbGVh cGkvTG9jYWxGaWxlU3lzdGVtLmgKaW5kZXggMmVhYmQ3YS4uNzI2YWQwNSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvZmlsZWFwaS9Mb2NhbEZpbGVTeXN0ZW0uaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9maWxlYXBpL0xvY2FsRmlsZVN5c3RlbS5oCkBAIC02MCw3ICs2MCw3IEBAIHB1YmxpYzoK IAogI2lmICFQTEFURk9STShDSFJPTUlVTSkKICAgICAvLyBUaGlzIGNhbGwgaXMgbm90IHRocmVh ZC1zYWZlOyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWRzIGFyZSBjcmVh dGVkLgotICAgIHZvaWQgaW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmKTsK KyAgICBzdGF0aWMgdm9pZCBpbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYp OwogCiAgICAgU3RyaW5nIGZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0OwogI2VuZGlmCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0ZW0uY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vQXN5bmNGaWxlU3lzdGVtLmNwcAppbmRleCA0MDRhYWI2Li5j NTE4NzAwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Bc3luY0ZpbGVTeXN0 ZW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0FzeW5jRmlsZVN5c3RlbS5jcHAK QEAgLTM5LDcgKzM5LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi0jaWYgIVBMQVRGT1JN KENIUk9NSVVNKQorI2lmICFQTEFURk9STShDSFJPTUlVTSkgJiYgIVBMQVRGT1JNKEdUSykKIGJv b2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQo KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MC4uNzA4ZDU4NAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwCkBAIC0wLDAgKzEsMTQyIEBACisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmgi CisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1H dGsuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXIuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVh ZFRhc2suaCIKKyNpbmNsdWRlICJGaWxlTWV0YWRhdGEuaCIKKworI2luY2x1ZGUgIkNTdHJpbmcu aCIKKyNpbmNsdWRlIDxzdGRpby5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3RlbXBsYXRl PD4gc3RydWN0IENyb3NzVGhyZWFkQ29waWVyQmFzZTxmYWxzZSwgZmFsc2UsIEZpbGVNZXRhZGF0 YT4geworICAgIHR5cGVkZWYgRmlsZU1ldGFkYXRhIFR5cGU7CisgICAgc3RhdGljIEZpbGVNZXRh ZGF0YSBjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYpOworfTsKKworQ3Jvc3NUaHJlYWRDb3BpZXJC YXNlPGZhbHNlLCBmYWxzZSwgRmlsZU1ldGFkYXRhPjo6VHlwZSBDcm9zc1RocmVhZENvcGllckJh c2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0YWRhdGE+Ojpjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYg b3JpZ2luYWwpCit7CisgICAgRmlsZU1ldGFkYXRhIG1ldGFkYXRhOworICAgIG1ldGFkYXRhLm1v ZGlmaWNhdGlvblRpbWUgPSBvcmlnaW5hbC5tb2RpZmljYXRpb25UaW1lOworICAgIG1ldGFkYXRh Lmxlbmd0aCA9IG9yaWdpbmFsLmxlbmd0aDsKKyAgICBtZXRhZGF0YS50eXBlID0gb3JpZ2luYWwu dHlwZTsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBvcmlnaW5hbC5wbGF0Zm9ybVBhdGg7 CisgICAgcmV0dXJuIG1ldGFkYXRhOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkU3VjY2Vl ZENhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIGNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgp OworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjayhTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ IGNhbGxiYWNrcywgY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bT4gZmlsZVN5c3RlbSkKK3sKKyAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUs IGZpbGVTeXN0ZW0pOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkUmVhZE1ldGFkYXRhQ2Fs bGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7Cisg ICAgY2FsbGJhY2tzLT5kaWRSZWFkTWV0YWRhdGEobWV0YWRhdGEpOworfQorCitzdGF0aWMgdm9p ZCBwZXJmb3JtRGlkUmVhZERpcmVjdG9yeUVudHJ5Q2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcyogY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcm IG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpCit7CisgICAgY2FsbGJhY2tzLT5kaWRSZWFkRGlyZWN0 b3J5RW50cnkobmFtZSwgaXNEaXJlY3RvcnkpOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlk UmVhZERpcmVjdG9yeUVudHJpZXNDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzKiBjYWxsYmFja3MpCit7CisgICAgY2FsbGJhY2tzLT5kaWRS ZWFkRGlyZWN0b3J5RW50cmllcyh0cnVlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZFJl YWREaXJlY3RvcnlFbnRyaWVzQW5kRmluaXNoZWRDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sK KyAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKGZhbHNlKTsKK30KKworc3Rh dGljIHZvaWQgcGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayhTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cywgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXI+IHdyaXRlciwgbG9uZyBsb25nIGxlbmd0aCkK K3sKKyAgICBjYWxsYmFja3MtPmRpZENyZWF0ZUZpbGVXcml0ZXIod3JpdGVyLCBsZW5ndGgpOwor fQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkRmFpbENhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBp bnQgY29kZSkKK3sKKyAgICBjYWxsYmFja3MtPmRpZEZhaWwoY29kZSk7Cit9CisKK0FzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMpCisgICAgOiBtX3Rhc2tDb250cm9sbGVy KEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjcmVhdGUoY29udGV4dCwgc3luY2hy b25vdXMpKQorICAgICwgbV9jYWxsYmFja3MoY2FsbGJhY2tzKQorICAgICwgbV9zeW5jaHJvbm91 cyhzeW5jaHJvbm91cykKKyAgICAsIG1fdGFza01vZGUoU3RyaW5nKCkpCit7Cit9CisKK0FzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrKEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgUGFzc093blB0cjxB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgY29uc3QgU3RyaW5nJiBtb2RlKQor ICAgIDogbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxlcikKKyAgICAsIG1fY2FsbGJhY2tz KGNhbGxiYWNrcykKKyAgICAsIG1fc3luY2hyb25vdXMoZmFsc2UpCisgICAgLCBtX3Rhc2tNb2Rl KG1vZGUpCit7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRTdWNj ZWVkKCkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmcGVyZm9ybURpZFN1Y2NlZWRDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFz ZSgpKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr OjpkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtPiBmaWxlU3lzdGVtKQoreworICAgIEFzeW5jRmlsZVN5c3RlbUd0ayogZmlsZVN5 c3RlbUd0ayA9IHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbUd0ayo+KGZpbGVTeXN0ZW0uZ2V0 KCkpOworCisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7 CisgICAgbV90YXNrQ29udHJvbGxlci0+c2V0Q3VycmVudFRhc2tNb2RlKG1vZGUpOworICAgIG1f dGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJm b3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBuYW1l LCBmaWxlU3lzdGVtKSwgbW9kZSk7CisgICAgZmlsZVN5c3RlbUd0ay0+c2V0VGFza0NvbnRyb2xs ZXIobV90YXNrQ29udHJvbGxlci5yZWxlYXNlKCkpOworICAgIGZpbGVTeXN0ZW1HdGstPndhaXRG b3JPcGVyYXRpb25Ub0NvbXBsZXRlKCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrOjpkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1ldGFkYXRhJiBtZXRhZGF0YSkKK3sK KyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFz aygmcGVyZm9ybURpZFJlYWRNZXRhZGF0YUNhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCks IG1ldGFkYXRhKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cnkoY29uc3QgU3RyaW5nJiBuYW1lLCBib29sIGlz RGlyZWN0b3J5KQoreworICAgIERpcmVjdG9yeUVudHJ5IGRpcmVjdG9yeUVudHJ5OworICAgIGRp cmVjdG9yeUVudHJ5Lm5hbWUgPSBuYW1lOworICAgIGRpcmVjdG9yeUVudHJ5LmlzRGlyZWN0b3J5 ID0gaXNEaXJlY3Rvcnk7CisgICAgbV9kaXJlY3RvcnlFbnRyaWVzLmFwcGVuZChkaXJlY3RvcnlF bnRyeSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGly ZWN0b3J5RW50cmllcyhib29sIGhhc01vcmUpCit7CisgICAgaWYgKGhhc01vcmUpCisgICAgICAg IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworCisgICAgVmVjdG9yPERpcmVjdG9yeUVudHJ5Pjo6aXRl cmF0b3IgZW5kID0gbV9kaXJlY3RvcnlFbnRyaWVzLmVuZCgpOworICAgIGZvciAoVmVjdG9yPERp cmVjdG9yeUVudHJ5Pjo6aXRlcmF0b3IgaXQgPSBtX2RpcmVjdG9yeUVudHJpZXMuYmVnaW4oKTsg aXQgIT0gZW5kOyArK2l0KQorICAgICAgICBtX2NhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeUVu dHJ5KGl0LT5uYW1lLCBpdC0+aXNEaXJlY3RvcnkpOworCisgICAgbV9kaXJlY3RvcnlFbnRyaWVz LmNsZWFyKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0 ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFJlYWREaXJlY3RvcnlFbnRyaWVzQW5kRmluaXNoZWRD YWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQg QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRDcmVhdGVGaWxlV3JpdGVyKFBhc3NPd25Q dHI8QXN5bmNGaWxlV3JpdGVyPiB3cml0ZXIsIGxvbmcgbG9uZyBsZW5ndGgpCit7CisgICAgbV90 YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZv cm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgd3Jp dGVyLCBsZW5ndGgpLCBtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs6OmRpZEZhaWwoaW50IGNvZGUpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9z dENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2ss IG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgY29kZSksIG1fdGFza01vZGUpOworfQorCit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODc2NmY1YwotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsuaApAQCAtMCwwICsxLDU4IEBACisjaWZuZGVmIEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0a19oCisjZGVmaW5lIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisK KyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3MuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgor I2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc093 blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0ayA6IHB1YmxpYyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MKK3sKK3B1YmxpYzoK KyAgICBzdGF0aWMgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0 ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQorICAgIHsKKyAgICAg ICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoY29udGV4 dCwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOworICAgIH0KKworICAgIHN0YXRpYyBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgY29uc3QgU3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAg ICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsodGFza0Nv bnRyb2xsZXIsIGNhbGxiYWNrcywgbW9kZSkpOworICAgIH0KKworCisgICAgdmlydHVhbCB2b2lk IGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3Qg U3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4pOworICAgIHZpcnR1YWwg dm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1ldGFkYXRhJik7CisgICAgdmlydHVhbCB2 b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJl Y3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0b3J5RW50cmllcyhib29sIGhh c01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVhdGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8 QXN5bmNGaWxlV3JpdGVyPiB3cml0ZXIsIGxvbmcgbG9uZyBsZW5ndGgpOworICAgIHZpcnR1YWwg dm9pZCBkaWRGYWlsKGludCBjb2RlKTsKKworcHJpdmF0ZToKKyAgICBBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzPiwgYm9vbCk7CisgICAgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr KEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJpbmcmKTsKKworICAgIFJlZlB0cjxBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90YXNrQ29udHJvbGxlcjsKKyAgICBPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBtX2NhbGxiYWNrczsKKyAgICBib29sIG1fc3luY2hyb25v dXM7CisgICAgU3RyaW5nIG1fdGFza01vZGU7CisKKyAgICBzdHJ1Y3QgRGlyZWN0b3J5RW50cnkg eworICAgICAgICBTdHJpbmcgbmFtZTsKKyAgICAgICAgYm9vbCBpc0RpcmVjdG9yeTsKKworICAg ICAgICBEaXJlY3RvcnlFbnRyeSgpIDogaXNEaXJlY3RvcnkoZmFsc2UpIHsgfQorICAgIH07CisK KyAgICBWZWN0b3I8RGlyZWN0b3J5RW50cnk+IG1fZGlyZWN0b3J5RW50cmllczsKK307CisKK30g Ly8gbmFtZXNwYWNlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAv LyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi43NTNlNjM1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5jcHAKQEAgLTAsMCArMSw0NjcgQEAKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1HdGsuaCIKKworI2lmIEVO QUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 ay5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckd0ay5oIgorI2luY2x1ZGUgIkNyb3NzVGhy ZWFkVGFzay5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIkZpbGVNZXRhZGF0 YS5oIgorI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCisjaW5j bHVkZSAiTG9jYWxGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKyNp bmNsdWRlICJXb3JrZXJDb250ZXh0LmgiCisjaW5jbHVkZSAiV29ya2VyUnVuTG9vcC5oIgorI2lu Y2x1ZGUgIldvcmtlclRocmVhZC5oIgorCisjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPGdp by9naW8uaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdGF0aWMgdm9pZCBvcGVuRmlsZVN5 c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIGJhc2VQ YXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZpZXIsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBl LCBib29sIGNyZWF0ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxi YWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxl U3lzdGVtKGJhc2VQYXRoLCBpZGVudGlmaWVyLCB0eXBlLCBjcmVhdGUsIEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0azo6Y3JlYXRlKGNvbnRleHQsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsK K30KKwordm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQor eworICAgIG9wZW5GaWxlU3lzdGVtKGNvbnRleHQsIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250 ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgZmFsc2Us IGNhbGxiYWNrcywgc3luY2hyb25vdXMpOworfQorCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVx dWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZywgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICBvcGVuRmlsZVN5 c3RlbShjb250ZXh0LCBmaWxlU3lzdGVtQmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmln aW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIHRydWUsIGNhbGxiYWNrcywgc3luY2hy b25vdXMpOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUoKQoreworICAg IHJldHVybiB0cnVlOworfQorCitQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxl U3lzdGVtOjpjcmVhdGUoVHlwZSB0eXBlKQoreworICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5 bmNGaWxlU3lzdGVtR3RrKHR5cGUpKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5G aWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmFnZUlk ZW50aWZpZXIsIFR5cGUgdHlwZSwgYm9vbCBjcmVhdGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgU3RyaW5nIHR5cGVTdHJpbmcgPSAodHlw ZSA9PSBBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpID8gIlBlcnNpc3RlbnQiIDogIlRlbXBv cmFyeSI7CisKKyAgICBTdHJpbmcgbmFtZSA9IHN0b3JhZ2VJZGVudGlmaWVyOworICAgIG5hbWUg Kz0gIjoiOworICAgIG5hbWUgKz0gdHlwZVN0cmluZzsKKworICAgIGNhbGxiYWNrcy0+ZGlkT3Bl bkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUodHlwZSkpOworfQorCitB c3luY0ZpbGVTeXN0ZW1HdGs6OkFzeW5jRmlsZVN5c3RlbUd0ayhUeXBlIHR5cGUpCisgICAgOiBB c3luY0ZpbGVTeXN0ZW0odHlwZSkKKyAgICAsIG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGgoTG9j YWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5maWxlU3lzdGVtQmFzZVBhdGgoKSkKK3sK K30KKworQXN5bmNGaWxlU3lzdGVtR3RrOjp+QXN5bmNGaWxlU3lzdGVtR3RrKCkKK3sKK30KKwor dm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnN0b3AoKQoreworfQorCitib29sIEFzeW5jRmlsZVN5 c3RlbUd0azo6aGFzUGVuZGluZ0FjdGl2aXR5KCkKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK K2Jvb2wgQXN5bmNGaWxlU3lzdGVtR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7 CisgICAgcmV0dXJuIG1fdGFza0NvbnRyb2xsZXItPndhaXRGb3JUYXNrVG9Db21wbGV0ZSgpOwor fQorCitzdGF0aWMgdm9pZCBtb3ZlQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIEdGaWxl KiBzb3VyY2VGaWxlLCBHRmlsZSogZGVzdGluYXRpb25GaWxlKQoreworICAgIEdPd25QdHI8R0Vy cm9yPiBlcnJvcjsKKyAgICBHRmlsZUluZm8qIHNvdXJjZUluZm8gPSBnX2ZpbGVfcXVlcnlfaW5m byhzb3VyY2VGaWxlLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsICZlcnJvci5vdXRQ dHIoKSk7CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFp bChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgR0ZpbGVJbmZvKiBkZXN0aW5hdGlvbkluZm8gPSBnX2ZpbGVfcXVlcnlfaW5mbyhkZXN0aW5h dGlvbkZpbGUsICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCk7CisgICAgaWYgKGRl c3RpbmF0aW9uSW5mbyAmJiBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKHNvdXJjZUluZm8pICE9 IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZGVzdGluYXRpb25JbmZvKSkgeworICAgICAgICBo ZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9F UlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKGRlc3RpbmF0aW9uSW5mbyAm JiBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGRlc3RpbmF0aW9uSW5mbykgPT0gR19GSUxFX1RZ UEVfRElSRUNUT1JZKSB7CisgICAgICAgIGdfZmlsZV9kZWxldGUoZGVzdGluYXRpb25GaWxlLCAw LCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgICAgIGhl bHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VS Uik7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBnX2ZpbGVf bW92ZShzb3VyY2VGaWxlLCBkZXN0aW5hdGlvbkZpbGUsIEdfRklMRV9DT1BZX09WRVJXUklURSwg MCwgMCwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpCisgICAgICAgIGhlbHBl ckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgIGVsc2UK KyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7Cit9CisKK3ZvaWQgQXN5bmNG aWxlU3lzdGVtR3RrOjptb3ZlKGNvbnN0IFN0cmluZyYgc3JjUGF0aCwgY29uc3QgU3RyaW5nJiBk ZXN0UGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykK K3sKKyAgICBTdHJpbmcgc291cmNlRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5 c3RlbVBhdGgoc3JjUGF0aCk7CisgICAgU3RyaW5nIGRlc3RpbmF0aW9uRmlsZVN5c3RlbVBhdGgg PSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVBhdGgoZGVzdFBhdGgpOworCisgICAgR0ZpbGUqIHNv dXJjZUZpbGUgPSBnX2ZpbGVfbmV3X2Zvcl9wYXRoKHNvdXJjZUZpbGVTeXN0ZW1QYXRoLnV0Zjgo KS5kYXRhKCkpOworICAgIEdGaWxlKiBkZXN0aW5hdGlvbkZpbGUgPSBnX2ZpbGVfbmV3X2Zvcl9w YXRoKGRlc3RpbmF0aW9uRmlsZVN5c3RlbVBhdGgudXRmOCgpLmRhdGEoKSk7CisKKyAgICBTdHJp bmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKyAgICBtX3Rhc2tDb250 cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm1vdmVBc3lu YywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5n ZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgQWxsb3dDcm9zc1RocmVhZEFjY2Vzcyhzb3VyY2VGaWxl KSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhkZXN0aW5hdGlvbkZpbGUpKSk7Cit9CisKK3N0YXRp YyB2b2lkIGNvcHlSZWN1cnNpdmVseShHRmlsZSogc291cmNlRGlyZWN0b3J5LCBHRmlsZSogZGVz dGluYXRpb25EaXJlY3RvcnksIEdFcnJvcioqIGVycm9yKQoreworICAgIGdfZmlsZV9tYWtlX2Rp cmVjdG9yeShkZXN0aW5hdGlvbkRpcmVjdG9yeSwgMCwgZXJyb3IpOworICAgIGlmICgqZXJyb3Ip CisgICAgICAgIHJldHVybjsKKworICAgIEdEaXIqIGRpcmVjdG9yeSA9IGdfZGlyX29wZW4oZ19m aWxlX2dldF9wYXRoKHNvdXJjZURpcmVjdG9yeSksIDAsIGVycm9yKTsKKyAgICBpZiAoKmVycm9y KQorICAgICAgICByZXR1cm47CisKKyAgICB3aGlsZSAoY29uc3QgY2hhciogZGlyZWN0b3J5RW50 cnkgPSBjb25zdF9jYXN0PGNoYXIqPihnX2Rpcl9yZWFkX25hbWUoZGlyZWN0b3J5KSkpIHsKKyAg ICAgICAgR0ZpbGUqIHNvdXJjZUZpbGUgPSBnX2ZpbGVfZ2V0X2NoaWxkKHNvdXJjZURpcmVjdG9y eSwgZGlyZWN0b3J5RW50cnkpOworICAgICAgICBHRmlsZSogZGVzdGluYXRpb25GaWxlID0gZ19m aWxlX2dldF9jaGlsZChkZXN0aW5hdGlvbkRpcmVjdG9yeSwgZGlyZWN0b3J5RW50cnkpOworCisg ICAgICAgIEdGaWxlSW5mbyogc291cmNlSW5mbyA9IGdfZmlsZV9xdWVyeV9pbmZvKHNvdXJjZUZp bGUsICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgZXJyb3IpOworICAgICAgICBpZiAo KmVycm9yKSB7CisgICAgICAgICAgICBnX2Rpcl9jbG9zZShkaXJlY3RvcnkpOworICAgICAgICAg ICAgcmV0dXJuOworICAgICAgICB9CisKKyAgICAgICAgaWYgKGdfZmlsZV9pbmZvX2dldF9maWxl X3R5cGUoc291cmNlSW5mbykgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZKSB7CisgICAgICAgICAg ICBjb3B5UmVjdXJzaXZlbHkoc291cmNlRmlsZSwgZGVzdGluYXRpb25GaWxlLCBlcnJvcik7Cisg ICAgICAgICAgICBpZiAoKmVycm9yKSB7CisgICAgICAgICAgICAgICAgZ19kaXJfY2xvc2UoZGly ZWN0b3J5KTsKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICB9CisgICAgICAg IH0gZWxzZSB7CisgICAgICAgICAgICBnX2ZpbGVfY29weShzb3VyY2VGaWxlLCBkZXN0aW5hdGlv bkZpbGUsIEdfRklMRV9DT1BZX05PTkUsIDAsIDAsIDAsIGVycm9yKTsKKyAgICAgICAgICAgIGlm ICgqZXJyb3IpIHsKKyAgICAgICAgICAgICAgICBnX2Rpcl9jbG9zZShkaXJlY3RvcnkpOworICAg ICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKwor ICAgIGdfZGlyX2Nsb3NlKGRpcmVjdG9yeSk7Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlBc3luYyhT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGs+IGhlbHBlckNhbGxiYWNrcywgR0ZpbGUqIHNvdXJjZUZpbGUsIEdGaWxlKiBkZXN0aW5h dGlvbkZpbGUpCit7CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworCisgICAgR0ZpbGVJbmZv KiBzb3VyY2VJbmZvID0gZ19maWxlX3F1ZXJ5X2luZm8oc291cmNlRmlsZSwgIioiLCBHX0ZJTEVf UVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGlmIChlcnJvcikgewor ICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJS KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdGaWxlSW5mbyogZGVzdGluYXRpb25J bmZvID0gZ19maWxlX3F1ZXJ5X2luZm8oZGVzdGluYXRpb25GaWxlLCAiKiIsIEdfRklMRV9RVUVS WV9JTkZPX05PTkUsIDAsIDApOworICAgIGlmIChkZXN0aW5hdGlvbkluZm8gJiYgZ19maWxlX2lu Zm9fZ2V0X2ZpbGVfdHlwZShzb3VyY2VJbmZvKSAhPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBl KGRlc3RpbmF0aW9uSW5mbykpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZp bGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKworICAgIGlmIChkZXN0aW5hdGlvbkluZm8gJiYgZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlw ZShkZXN0aW5hdGlvbkluZm8pID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkgeworICAgICAgICBn X2ZpbGVfZGVsZXRlKGRlc3RpbmF0aW9uRmlsZSwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICAg ICAgaWYgKGVycm9yKSB7CisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmls ZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlIpOworICAgICAgICAgICAgcmV0dXJuOwor ICAgICAgICB9CisgICAgfQorCisgICAgaWYgKGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoc291 cmNlSW5mbykgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZKSB7CisgICAgICAgIGNvcHlSZWN1cnNp dmVseShzb3VyY2VGaWxlLCBkZXN0aW5hdGlvbkZpbGUsICZlcnJvci5vdXRQdHIoKSk7CisgICAg ICAgIGlmIChlcnJvcikKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxl RXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICBlbHNlCisgICAgICAgICAgICBoZWxwZXJD YWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKKworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg Z19maWxlX2NvcHkoc291cmNlRmlsZSwgZGVzdGluYXRpb25GaWxlLCBHX0ZJTEVfQ09QWV9PVkVS V1JJVEUsIDAsIDAsIDAsICZlcnJvci5vdXRQdHIoKSk7CisgICAgaWYgKGVycm9yKQorICAgICAg ICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAg ICBlbHNlCisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOworfQorCit2b2lk IEFzeW5jRmlsZVN5c3RlbUd0azo6Y29weShjb25zdCBTdHJpbmcmIHNyY1BhdGgsIGNvbnN0IFN0 cmluZyYgZGVzdFBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxs YmFja3MpCit7CisgICAgU3RyaW5nIHNvdXJjZUZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhU b0ZpbGVTeXN0ZW1QYXRoKHNyY1BhdGgpOworICAgIFN0cmluZyBkZXN0aW5hdGlvbkZpbGVTeXN0 ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1QYXRoKGRlc3RQYXRoKTsKKworICAgIEdG aWxlKiBzb3VyY2VGaWxlID0gZ19maWxlX25ld19mb3JfcGF0aChzb3VyY2VGaWxlU3lzdGVtUGF0 aC51dGY4KCkuZGF0YSgpKTsKKyAgICBHRmlsZSogZGVzdGluYXRpb25GaWxlID0gZ19maWxlX25l d19mb3JfcGF0aChkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoLnV0ZjgoKS5kYXRhKCkpOworCisg ICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisgICAgbV90 YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZj b3B5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRy b2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3Moc291 cmNlRmlsZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MoZGVzdGluYXRpb25GaWxlKSkpOworfQor CitzdGF0aWMgdm9pZCByZW1vdmVGaWxlKEdGaWxlKiBmaWxlLCBib29sIGNhblJlbW92ZURpcmVj dG9yeVJlY3Vyc2l2ZWx5LCBHRXJyb3IqKiBlcnJvcikKK3sKKyAgICBpZiAoZ19maWxlX3Rlc3Qo Z19maWxlX2dldF9wYXRoKGZpbGUpLCBHX0ZJTEVfVEVTVF9JU19ESVIpICYmIGNhblJlbW92ZURp cmVjdG9yeVJlY3Vyc2l2ZWx5KSB7CisgICAgICAgIEdEaXIqIGRpcmVjdG9yeSA9IGdfZGlyX29w ZW4oZ19maWxlX2dldF9wYXRoKGZpbGUpLCAwLCBlcnJvcik7CisgICAgICAgIGlmICgqZXJyb3Ip CisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgd2hpbGUgKGNvbnN0IGNoYXIqIGRpcmVj dG9yeUVudHJ5ID0gY29uc3RfY2FzdDxjaGFyKj4oZ19kaXJfcmVhZF9uYW1lKGRpcmVjdG9yeSkp KSB7CisgICAgICAgICAgICBHRmlsZSogY2hpbGQgPSBnX2ZpbGVfZ2V0X2NoaWxkKGZpbGUsIGRp cmVjdG9yeUVudHJ5KTsKKyAgICAgICAgICAgIHJlbW92ZUZpbGUoY2hpbGQsIGNhblJlbW92ZURp cmVjdG9yeVJlY3Vyc2l2ZWx5LCBlcnJvcik7CisgICAgICAgICAgICBpZiAoKmVycm9yKSB7Cisg ICAgICAgICAgICAgICAgZ19kaXJfY2xvc2UoZGlyZWN0b3J5KTsKKyAgICAgICAgICAgICAgICBy ZXR1cm47CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAgICBnX2Rpcl9jbG9zZShk aXJlY3RvcnkpOworICAgIH0KKworICAgIGdfZmlsZV9kZWxldGUoZmlsZSwgMCwgZXJyb3IpOwor fQorCitzdGF0aWMgdm9pZCByZW1vdmVBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgR0Zp bGUqIGZpbGUsIGJvb2wgY2FuUmVtb3ZlRGlyZWN0b3J5UmVjdXJzaXZlbHkpCit7CisgICAgR093 blB0cjxHRXJyb3I+IGVycm9yOworICAgIHJlbW92ZUZpbGUoZmlsZSwgY2FuUmVtb3ZlRGlyZWN0 b3J5UmVjdXJzaXZlbHksICZlcnJvci5vdXRQdHIoKSk7CisKKyAgICBpZiAoZXJyb3IpIHsKKyAg ICAgICAgRmlsZUVycm9yOjpFcnJvckNvZGUgZXJyb3JDb2RlOworICAgICAgICBzd2l0Y2ggKGVy cm9yLT5jb2RlKSB7CisgICAgICAgIGNhc2UgR19JT19FUlJPUl9OT1RfRU1QVFk6CisgICAgICAg ICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUjsKKyAg ICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAg ICAgICBkZWZhdWx0OgorICAgICAgICAgICAgZXJyb3JDb2RlID0gRmlsZUVycm9yOjpOT1RfRk9V TkRfRVJSOworICAgICAgICB9CisKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKGVy cm9yQ29kZSk7CisgICAgfSBlbHNlCisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2Vl ZCgpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlKGNvbnN0IFN0cmluZyYg cGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sK KyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVBhdGgo cGF0aCk7CisKKyAgICBHRmlsZSogZmlsZSA9IGdfZmlsZV9uZXdfZm9yX3BhdGgoZmlsZVN5c3Rl bVBhdGgudXRmOCgpLmRhdGEoKSk7CisKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xs ZXItPnVuaXF1ZU1vZGUoKTsKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRo cmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlbW92ZUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUp LCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKGZpbGUpLCBmYWxzZSkpOworfQorCit2b2lkIEFzeW5j RmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVjdXJzaXZlbHkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIFN0cmlu ZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtUGF0aChwYXRoKTsKKwor ICAgIEdGaWxlKiBmaWxlID0gZ19maWxlX25ld19mb3JfcGF0aChmaWxlU3lzdGVtUGF0aC51dGY4 KCkuZGF0YSgpKTsKKworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVl TW9kZSgpOworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0 ZUNhbGxiYWNrVGFzaygmcmVtb3ZlQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIEFsbG93Q3Jv c3NUaHJlYWRBY2Nlc3MoZmlsZSksIHRydWUpKTsKK30KKworc3RhdGljIHZvaWQgcmVhZE1ldGFk YXRhQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIEdGaWxlKiBmaWxlKQoreworICAgIEdP d25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHRmlsZUluZm8qIGZpbGVJbmZvID0gZ19maWxlX3F1 ZXJ5X2luZm8oZmlsZSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0 UHRyKCkpOworICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZh aWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwor ICAgIEZpbGVNZXRhZGF0YSBtZXRhZGF0YTsKKyAgICBtZXRhZGF0YS50eXBlID0gZ19maWxlX2lu Zm9fZ2V0X2ZpbGVfdHlwZShmaWxlSW5mbykgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZID8gRmls ZU1ldGFkYXRhOjpUeXBlRGlyZWN0b3J5IDogRmlsZU1ldGFkYXRhOjpUeXBlRmlsZTsKKworICAg IEdUaW1lVmFsIHRpbWVWYWx1ZTsKKyAgICBnX2ZpbGVfaW5mb19nZXRfbW9kaWZpY2F0aW9uX3Rp bWUoZmlsZUluZm8sICZ0aW1lVmFsdWUpOworICAgIG1ldGFkYXRhLm1vZGlmaWNhdGlvblRpbWUg PSBzdGF0aWNfY2FzdDxkb3VibGU+KHRpbWVWYWx1ZS50dl9zZWMpOworCisgICAgbWV0YWRhdGEu bGVuZ3RoID0gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxl SW5mbykpOworICAgIG1ldGFkYXRhLnBsYXRmb3JtUGF0aCA9IGdfZmlsZV9nZXRfcGF0aChmaWxl KTsKKworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkUmVhZE1ldGFkYXRhKG1ldGFkYXRhKTsKK30K Kwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWRNZXRhZGF0YShjb25zdCBTdHJpbmcmIHBh dGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7Cisg ICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1QYXRoKHBh dGgpOworCisgICAgR0ZpbGUqIGZpbGUgPSBnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVTeXN0ZW1Q YXRoLnV0ZjgoKS5kYXRhKCkpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+ dW5pcXVlTW9kZSgpOworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFk KGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVhZE1ldGFkYXRhQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9k ZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MoZmlsZSkpKTsKK30KKworc3RhdGljIHZvaWQgY3Jl YXRlT2JqZWN0QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIEdGaWxlKiBvYmplY3QsIEdG aWxlVHlwZSB0eXBlKQoreworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHRmlsZU91 dHB1dFN0cmVhbSogb3V0cHV0U3RyZWFtID0gMDsKKworICAgIHN3aXRjaCAodHlwZSkgeworICAg IGNhc2UgR19GSUxFX1RZUEVfUkVHVUxBUjoKKyAgICAgICAgb3V0cHV0U3RyZWFtID0gZ19maWxl X2NyZWF0ZShvYmplY3QsIEdfRklMRV9DUkVBVEVfTk9ORSwgMCwgJmVycm9yLm91dFB0cigpKTsK KyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlk6CisgICAgICAg IGdfZmlsZV9tYWtlX2RpcmVjdG9yeShvYmplY3QsIDAsICZlcnJvci5vdXRQdHIoKSk7CisgICAg ICAgIGJyZWFrOworICAgIGRlZmF1bHQ6CisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwor ICAgIH0KKworICAgIGlmIChvdXRwdXRTdHJlYW0pCisgICAgICAgIGdfb2JqZWN0X3VucmVmKG91 dHB1dFN0cmVhbSk7CisKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgRmlsZUVycm9yOjpFcnJv ckNvZGUgZXJyb3JDb2RlOworICAgICAgICBzd2l0Y2ggKGVycm9yLT5jb2RlKSB7CisgICAgICAg IGNhc2UgR19JT19FUlJPUl9FWElTVFM6CisgICAgICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJy b3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAg ICBjYXNlIEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAgICAgICBkZWZhdWx0OgorICAgICAgICAg ICAgZXJyb3JDb2RlID0gRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSOworICAgICAgICB9CisKKyAg ICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKGVycm9yQ29kZSk7CisgICAgfSBlbHNlCisg ICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOworfQorCit2b2lkIEFzeW5jRmls ZVN5c3RlbUd0azo6Y3JlYXRlRmlsZShjb25zdCBTdHJpbmcmIHBhdGgsIGJvb2wgZXhjbHVzaXZl LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAg IFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtUGF0aChwYXRo KTsKKworICAgIEdGaWxlKiBvYmplY3QgPSBnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVTeXN0ZW1Q YXRoLnV0ZjgoKS5kYXRhKCkpOworCisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVy LT51bmlxdWVNb2RlKCk7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJl YWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZjcmVhdGVPYmplY3RBc3luYywgQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBt b2RlKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhvYmplY3QpLCBHX0ZJTEVfVFlQRV9SRUdVTEFS KSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3RvcnkoY29uc3Qg U3RyaW5nJiBwYXRoLCBib29sIGV4Y2x1c2l2ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0 dWFsUGF0aFRvRmlsZVN5c3RlbVBhdGgocGF0aCk7CisKKyAgICBHRmlsZSogb2JqZWN0ID0gZ19m aWxlX25ld19mb3JfcGF0aChmaWxlU3lzdGVtUGF0aC51dGY4KCkuZGF0YSgpKTsKKworICAgIFN0 cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworICAgIG1fdGFza0Nv bnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY3JlYXRl T2JqZWN0QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0Nv bnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3Mo b2JqZWN0KSwgR19GSUxFX1RZUEVfRElSRUNUT1JZKSk7Cit9CisKK3N0YXRpYyB2b2lkIG9iamVj dEV4aXN0c0FzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBHRmlsZSogb2JqZWN0LCBHRmls ZVR5cGUgdHlwZSkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR0ZpbGVJbmZv KiBmaWxlSW5mbyA9IGdfZmlsZV9xdWVyeV9pbmZvKG9iamVjdCwgIioiLCBHX0ZJTEVfUVVFUllf SU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGlmIChlcnJvcikgeworICAgICAg ICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGlmIChnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBl KGZpbGVJbmZvKSAhPSB0eXBlKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChG aWxlRXJyb3I6OlRZUEVfTUlTTUFUQ0hfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwor ICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOworfQorCit2b2lkIEFzeW5jRmlsZVN5 c3RlbUd0azo6ZmlsZUV4aXN0cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1Q YXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1QYXRoKHBhdGgpOworCisgICAgR0ZpbGUqIG9i amVjdCA9IGdfZmlsZV9uZXdfZm9yX3BhdGgoZmlsZVN5c3RlbVBhdGgudXRmOCgpLmRhdGEoKSk7 CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisgICAg bV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNr KCZvYmplY3RFeGlzdHNBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUo bV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgQWxsb3dDcm9zc1RocmVh ZEFjY2VzcyhvYmplY3QpLCBHX0ZJTEVfVFlQRV9SRUdVTEFSKSk7Cit9CisKK3ZvaWQgQXN5bmNG aWxlU3lzdGVtR3RrOjpkaXJlY3RvcnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIFN0cmluZyBm aWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtUGF0aChwYXRoKTsKKworICAg IEdGaWxlKiBvYmplY3QgPSBnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVTeXN0ZW1QYXRoLnV0Zjgo KS5kYXRhKCkpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9k ZSgpOworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNh bGxiYWNrVGFzaygmb2JqZWN0RXhpc3RzQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIEFsbG93 Q3Jvc3NUaHJlYWRBY2Nlc3Mob2JqZWN0KSwgR19GSUxFX1RZUEVfRElSRUNUT1JZKSk7Cit9CisK K3N0YXRpYyB2b2lkIHJlYWREaXJlY3RvcnlBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNhbGxiYWNrcywgR0ZpbGUq IGRpcmVjdG9yeUZpbGUpCit7CisgICAgR0RpciogZGlyZWN0b3J5ID0gZ19kaXJfb3BlbihnX2Zp bGVfZ2V0X3BhdGgoZGlyZWN0b3J5RmlsZSksIDAsIDApOworICAgIGlmICghZGlyZWN0b3J5KSB7 CisgICAgICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOwor ICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgd2hpbGUgKGNvbnN0IGNoYXIqIGRpcmVjdG9y eUVudHJ5ID0gY29uc3RfY2FzdDxjaGFyKj4oZ19kaXJfcmVhZF9uYW1lKGRpcmVjdG9yeSkpKSB7 CisgICAgICAgIEdGaWxlKiBjaGlsZCA9IGdfZmlsZV9nZXRfY2hpbGQoZGlyZWN0b3J5RmlsZSwg ZGlyZWN0b3J5RW50cnkpOworICAgICAgICBHRmlsZUluZm8qIGZpbGVJbmZvID0gZ19maWxlX3F1 ZXJ5X2luZm8oY2hpbGQsICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCk7CisgICAg ICAgIGJvb2wgaXNFbnRyeURpcmVjdG9yeSA9IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZmls ZUluZm8pID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWTsKKworICAgICAgICBjYWxsYmFja3MtPmRp ZFJlYWREaXJlY3RvcnlFbnRyeShTdHJpbmcoZGlyZWN0b3J5RW50cnkpLCBpc0VudHJ5RGlyZWN0 b3J5KTsKKyAgICB9CisKKyAgICBnX2Rpcl9jbG9zZShkaXJlY3RvcnkpOworICAgIGNhbGxiYWNr cy0+ZGlkUmVhZERpcmVjdG9yeUVudHJpZXMoZmFsc2UpOworfQorCit2b2lkIEFzeW5jRmlsZVN5 c3RlbUd0azo6cmVhZERpcmVjdG9yeShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgU3RyaW5nIGZpbGVTeXN0 ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1QYXRoKHBhdGgpOworCisgICAgR0ZpbGUq IGRpcmVjdG9yeUZpbGUgPSBnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVTeXN0ZW1QYXRoLnV0Zjgo KS5kYXRhKCkpOworCisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVN b2RlKCk7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRl Q2FsbGJhY2tUYXNrKCZyZWFkRGlyZWN0b3J5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIEFs bG93Q3Jvc3NUaHJlYWRBY2Nlc3MoZGlyZWN0b3J5RmlsZSkpKTsKK30KKworc3RhdGljIHZvaWQg Y3JlYXRlV3JpdGVyQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIEFzeW5jRmlsZVdyaXRl ckNsaWVudCogY2xpZW50LCBHRmlsZSogZmlsZSwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsqIHRhc2tDb250cm9sbGVyKQoreworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAg ICBHRmlsZUluZm8qIGZpbGVJbmZvID0gZ19maWxlX3F1ZXJ5X2luZm8oZmlsZSwgIioiLCBHX0ZJ TEVfUVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGlmIChlcnJvcikg eworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRf RVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGxvbmcgbG9uZyBmaWxlU2l6ZSA9 IHN0YXRpY19jYXN0PGxvbmcgbG9uZz4oZ19maWxlX2luZm9fZ2V0X3NpemUoZmlsZUluZm8pKTsK KyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZENyZWF0ZUZpbGVXcml0ZXIoQXN5bmNGaWxlV3JpdGVy R3RrOjpjcmVhdGUoY2xpZW50LCBmaWxlLCB0YXNrQ29udHJvbGxlciksIGZpbGVTaXplKTsKK30K Kwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcihBc3luY0ZpbGVXcml0ZXJD bGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9 IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtUGF0aChwYXRoKTsKKworICAgIEdGaWxlKiBmaWxlID0g Z19maWxlX25ld19mb3JfcGF0aChmaWxlU3lzdGVtUGF0aC51dGY4KCkuZGF0YSgpKTsKKyAgICBT dHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKyAgICBtX3Rhc2tD b250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmNyZWF0 ZVdyaXRlckFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tD b250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNz KGNsaWVudCksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MoZmlsZSksIEFsbG93Q3Jvc3NUaHJlYWRB Y2Nlc3MobV90YXNrQ29udHJvbGxlci5nZXQoKSkpKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0 ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKFBhc3NSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs+IHRhc2tDb250cm9sbGVyKQoreworICAgIG1fdGFza0NvbnRyb2xsZXIgPSB0 YXNrQ29udHJvbGxlcjsKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbUd0azo6dmlydHVhbFBh dGhUb0ZpbGVTeXN0ZW1QYXRoKGNvbnN0IFN0cmluZyYgdmlydHVhbFBhdGgpCit7CisgICAgU3Ry aW5nIGZpbGVTeXN0ZW1QYXRoID0gbV9sb2NhbEZpbGVTeXN0ZW1CYXNlUGF0aDsKKyAgICBmaWxl U3lzdGVtUGF0aC5hcHBlbmQodmlydHVhbFBhdGgpOworICAgIHJldHVybiBmaWxlU3lzdGVtUGF0 aDsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVf U1lTVEVNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmls ZVN5c3RlbUd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3Rl bUd0ay5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY1NjY3YjQKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt R3RrLmgKQEAgLTAsMCArMSw0NyBAQAorI2lmbmRlZiBBc3luY0ZpbGVTeXN0ZW1HdGtfaAorI2Rl ZmluZSBBc3luY0ZpbGVTeXN0ZW1HdGtfaAorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisj aW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ay5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIK KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1HdGsgOiBwdWJs aWMgQXN5bmNGaWxlU3lzdGVtIHsKK3B1YmxpYzoKKyAgICBBc3luY0ZpbGVTeXN0ZW1HdGsoVHlw ZSk7CisgICAgfkFzeW5jRmlsZVN5c3RlbUd0aygpOworCisgICAgdm9pZCBzdG9wKCk7CisgICAg Ym9vbCBoYXNQZW5kaW5nQWN0aXZpdHkoKTsKKyAgICBib29sIHdhaXRGb3JPcGVyYXRpb25Ub0Nv bXBsZXRlKCk7CisKKyAgICB2b2lkIG1vdmUoY29uc3QgU3RyaW5nJiBzcmNQYXRoLCBjb25zdCBT dHJpbmcmIGRlc3RQYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwor ICAgIHZvaWQgY29weShjb25zdCBTdHJpbmcmIHNyY1BhdGgsIGNvbnN0IFN0cmluZyYgZGVzdFBh dGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPik7CisgICAgdm9pZCByZW1v dmUoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4pOworICAgIHZvaWQgcmVtb3ZlUmVjdXJzaXZlbHkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZvaWQgcmVhZE1ldGFkYXRh KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ KTsKKyAgICB2b2lkIGNyZWF0ZUZpbGUoY29uc3QgU3RyaW5nJiBwYXRoLCBib29sIGV4Y2x1c2l2 ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKKyAgICB2b2lkIGNyZWF0 ZURpcmVjdG9yeShjb25zdCBTdHJpbmcmIHBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZvaWQgZmlsZUV4aXN0cyhjb25zdCBT dHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPik7CisgICAg dm9pZCBkaXJlY3RvcnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZvaWQgcmVhZERpcmVjdG9yeShjb25zdCBTdHJp bmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPik7CisgICAgdm9p ZCBjcmVhdGVXcml0ZXIoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFN0cmlu ZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKKworICAgIHZv aWQgc2V0VGFza0NvbnRyb2xsZXIoUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0az4pOworCitwcml2YXRlOgorICAgIFN0cmluZyB2aXJ0dWFsUGF0aFRvRmlsZVN5c3Rl bVBhdGgoY29uc3QgU3RyaW5nJik7CisgICAgU3RyaW5nIG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBh dGg7CisKKyAgICBSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IG1fdGFz a0NvbnRyb2xsZXI7Cit9OworCit9CisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisK KyNlbmRpZiAvLyBBc3luY0ZpbGVTeXN0ZW1HdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjViN2E5NgotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ay5jcHAKQEAgLTAsMCArMSwxNDMgQEAKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiV29ya2VyQ29udGV4dC5oIgorI2luY2x1 ZGUgIldvcmtlckxvYWRlclByb3h5LmgiCisjaW5jbHVkZSAiV29ya2VyUnVuTG9vcC5oIgorI2lu Y2x1ZGUgIldvcmtlclNjcmlwdENvbnRyb2xsZXIuaCIKKyNpbmNsdWRlICJXb3JrZXJUaHJlYWQu aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY29udGV4dCwgYm9vbCBzeW5jaHJvbm91cykKKyAgICA6IG1fY29udGV4dChjb250ZXh0 KQorICAgICwgbV9zeW5jaHJvbm91cyhzeW5jaHJvbm91cykKKyAgICAsIG1fY3VycmVudFRhc2tN b2RlKFN0cmluZygpKQorICAgICwgbV9pc1RocmVhZFN0b3BwaW5nKGZhbHNlKQoreworICAgIGlm IChtX2NvbnRleHQtPmlzRG9jdW1lbnQoKSkgeworICAgICAgICBtX3dvcmtlckxvYWRlclByb3h5 ID0gMDsKKyAgICB9IGVsc2UgeworI2lmIEVOQUJMRShXT1JLRVJTKQorICAgICAgICBBU1NFUlQo bV9jb250ZXh0LT5pc1dvcmtlckNvbnRleHQoKSk7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdv cmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4obV9jb250ZXh0KTsKKwor ICAgICAgICBtX3dvcmtlckxvYWRlclByb3h5ID0gJndvcmtlckNvbnRleHQtPnRocmVhZCgpLT53 b3JrZXJMb2FkZXJQcm94eSgpOworICAgICAgICBtX3dvcmtlck9ic2VydmVyID0gT2JzZXJ2ZXI6 OmNyZWF0ZSh3b3JrZXJDb250ZXh0LCB0aGlzKTsKKyNlbHNlCisgICAgICAgIEFTU0VSVF9OT1Rf UkVBQ0hFRCgpCisjZW5kaWYKKyAgICB9Cit9CisKK0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrOjp+QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoKQoreworfQorCitTdHJp bmcgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnVuaXF1ZU1vZGUoKQoreworICAg IFN0cmluZyB1bmlxdWVNb2RlOworICAgIGlmIChtX2NvbnRleHQtPmlzRG9jdW1lbnQoKSkKKyAg ICAgICAgdW5pcXVlTW9kZSA9IFN0cmluZygpOworICAgIGVsc2UgeworI2lmIEVOQUJMRShXT1JL RVJTKQorICAgICAgICBBU1NFUlQobV9jb250ZXh0LT5pc1dvcmtlckNvbnRleHQoKSk7CisgICAg ICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250 ZXh0Kj4obV9jb250ZXh0KTsKKworICAgICAgICB1bmlxdWVNb2RlID0gImZpbGVTeXN0ZW1PcGVy YXRpb25Nb2RlIjsKKyAgICAgICAgdW5pcXVlTW9kZS5hcHBlbmQoU3RyaW5nOjpudW1iZXIod29y a2VyQ29udGV4dC0+dGhyZWFkKCktPnJ1bkxvb3AoKS5jcmVhdGVVbmlxdWVJZCgpKSk7CisjZWxz ZQorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyNlbmRpZgorICAgIH0KKworICAgIHJl dHVybiB1bmlxdWVNb2RlOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrOjpwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+IHRhc2spCit7CisgICAgaWYgKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKQorICAg ICAgICBtX2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworICAgIGVsc2UgeworI2lmIEVOQUJMRShX T1JLRVJTKQorICAgICAgICBBU1NFUlQobV9jb250ZXh0LT5pc1dvcmtlckNvbnRleHQoKSk7CisK KyAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAgICAgICBtX3dvcmtlckxv YWRlclByb3h5LT5wb3N0VGFza1RvTG9hZGVyKHRhc2spOworI2Vsc2UKKyAgICAgICAgQVNTRVJU X05PVF9SRUFDSEVEKCk7CisjZW5kaWYKKyAgICB9Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJpbmcmIHRhc2tN b2RlKQoreworICAgIC8vQVNTRVJUKG1fY3VycmVudFRhc2tNb2RlLmlzRW1wdHkoKSk7CisgICAg bV9jdXJyZW50VGFza01vZGUgPSB0YXNrTW9kZTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0azo6cG9zdENhbGxiYWNrVGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ6OlRhc2s+IHRhc2ssIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBpZiAo bV9jb250ZXh0LT5pc0RvY3VtZW50KCkpCisgICAgICAgIG1fY29udGV4dC0+cG9zdFRhc2sodGFz ayk7CisgICAgZWxzZSB7CisjaWYgRU5BQkxFKFdPUktFUlMpCisgICAgICAgIEFTU0VSVChtX2Nv bnRleHQtPmlzV29ya2VyQ29udGV4dCgpKTsKKworICAgICAgICBNdXRleExvY2tlciBsb2NrZXIo bV9tdXRleCk7CisgICAgICAgIG1fd29ya2VyTG9hZGVyUHJveHktPnBvc3RUYXNrRm9yTW9kZVRv V29ya2VyQ29udGV4dCh0YXNrLCBtb2RlKTsKKyNlbHNlCisgICAgICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOworI2VuZGlmCisgICAgfQorfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrOjp3YWl0Rm9yVGFza1RvQ29tcGxldGUoKQoreworICAgIGlmIChtX2NvbnRleHQt PmlzRG9jdW1lbnQoKSkgeworICAgICAgICBBU1NFUlQoIW1fc3luY2hyb25vdXMpOworICAgICAg ICByZXR1cm4gZmFsc2U7CisgICAgfQorCisjaWYgRU5BQkxFKFdPUktFUlMpCisgICAgQVNTRVJU KG1fY29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkpOworICAgIC8vQVNTRVJUKCFtX2N1cnJlbnRU YXNrTW9kZS5pc0VtcHR5KCkpOworCisgICAgaWYgKCFtX3N5bmNocm9ub3VzKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisKKyAgICBXb3JrZXJDb250ZXh0KiB3b3JrZXJDb250ZXh0ID0gc3RhdGlj X2Nhc3Q8V29ya2VyQ29udGV4dCo+KG1fY29udGV4dCk7CisgICAgV29ya2VyUnVuTG9vcCYgcnVu TG9vcCA9IHdvcmtlckNvbnRleHQtPnRocmVhZCgpLT5ydW5Mb29wKCk7CisgICAgaWYgKHJ1bkxv b3AucnVuSW5Nb2RlKHdvcmtlckNvbnRleHQsIG1fY3VycmVudFRhc2tNb2RlKSA9PSBNZXNzYWdl UXVldWVUZXJtaW5hdGVkKSB7CisgICAgICAgIG1fY3VycmVudFRhc2tNb2RlID0gU3RyaW5nKCk7 CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKKyAgICBtX2N1cnJlbnRUYXNrTW9kZSA9 IFN0cmluZygpOworICAgIHJldHVybiB0cnVlOworI2Vsc2UKKyAgICBBU1NFUlRfTk9UX1JFQUNI RUQoKTsKKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0azo6dGhyZWFkU3RvcHBpbmcoKQoreworfQorCitBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0azo6T2JzZXJ2ZXI6Ok9ic2VydmVyKFdvcmtlckNvbnRleHQq IGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxl cikKKyAgICA6IFdvcmtlckNvbnRleHQ6Ok9ic2VydmVyKGNvbnRleHQpCisgICAgLCBtX3Rhc2tD b250cm9sbGVyKHRhc2tDb250cm9sbGVyKQoreworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrOjpPYnNlcnZlcjo6bm90aWZ5U3RvcCgpCit7Cit9CisKKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40 ODg1NzgyCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0Fz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmgKQEAgLTAsMCArMSw3MSBAQAorI2lmbmRl ZiBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0a19oCisjZGVmaW5lIEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2lu Y2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRlICJXb3JrZXJDb250ZXh0 LmgiCisjaW5jbHVkZSAiV29ya2VyTG9hZGVyUHJveHkuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc1Jl ZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRTYWZlUmVmQ291bnRlZC5oPgorI2luY2x1ZGUg PHd0Zi9UaHJlYWRpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4KK3sKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gY3JlYXRlKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGJvb2wgc3luY2hyb25vdXMpCisgICAgeworICAg ICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KGNvbnRleHQsIHN5bmNocm9ub3VzKSk7CisgICAgfQorCisgICAgfkFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrKCk7CisKKyAgICBTdHJpbmcgdW5pcXVlTW9kZSgpOworCisgICAgdm9p ZCBwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OlRhc2s+KTsKKyAgICB2b2lkIHNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJpbmcmIHRhc2tN b2RlKTsKKyAgICB2b2lkIHBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5nJik7CisgICAgYm9vbCB3YWl0Rm9yVGFza1Rv Q29tcGxldGUoKTsKKworICAgIGJvb2wgc3luY2hyb25vdXMoKSB7IHJldHVybiBtX3N5bmNocm9u b3VzOyB9CisKKyAgICB2b2lkIHRocmVhZFN0b3BwaW5nKCk7CisKK3ByaXZhdGU6CisgICAgQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJv b2wpOworCisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogbV9jb250ZXh0OworICAgIGJvb2wg bV9zeW5jaHJvbm91czsKKyAgICBTdHJpbmcgbV9jdXJyZW50VGFza01vZGU7CisgICAgYm9vbCBt X2lzVGhyZWFkU3RvcHBpbmc7CisKKyAgICBNdXRleCBtX211dGV4OworCisjaWYgRU5BQkxFKFdP UktFUlMpCisgICAgY2xhc3MgT2JzZXJ2ZXIgOiBwdWJsaWMgV29ya2VyQ29udGV4dDo6T2JzZXJ2 ZXIgeworICAgIHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBhc3NPd25QdHI8T2JzZXJ2ZXI+IGNy ZWF0ZShXb3JrZXJDb250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0ayogdGFza0NvbnRyb2xsZXIpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBhZG9w dFB0cihuZXcgT2JzZXJ2ZXIoY29udGV4dCwgdGFza0NvbnRyb2xsZXIpKTsKKyAgICAgICAgfQor CisgICAgICAgIHZpcnR1YWwgdm9pZCBub3RpZnlTdG9wKCk7CisKKyAgICBwcml2YXRlOgorICAg ICAgICBPYnNlcnZlcihXb3JrZXJDb250ZXh0KiwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsqKTsKKworICAgICAgICBSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGs+IG1fdGFza0NvbnRyb2xsZXI7CisgICAgfTsKKworICAgIFdvcmtlckxvYWRlclByb3h5KiBt X3dvcmtlckxvYWRlclByb3h5OworICAgIE93blB0cjxPYnNlcnZlcj4gbV93b3JrZXJPYnNlcnZl cjsKKyNlbmRpZgorfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxF X1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc19oCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3Rr LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRH dGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE1MzI3NGMKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVy Q2xpZW50R3RrLmNwcApAQCAtMCwwICsxLDUxIEBACisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNU RU0pCisKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2suaCIKKyNpbmNsdWRlIDxzdGRpby5oPgor CituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRXcml0ZUNhbGxi YWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVu dCwgbG9uZyBsb25nIGJ5dGVzLCBib29sIGNvbXBsZXRlKQoreworICAgIGNsaWVudC0+ZGlkV3Jp dGUoYnl0ZXMsIGNvbXBsZXRlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZFRydW5jYXRl Q2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVdyaXRlckNsaWVudCog Y2xpZW50KQoreworICAgIGNsaWVudC0+ZGlkVHJ1bmNhdGUoKTsKK30KKworc3RhdGljIHZvaWQg cGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxl V3JpdGVyQ2xpZW50KiBjbGllbnQsIEZpbGVFcnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAg Y2xpZW50LT5kaWRGYWlsKGNvZGUpOworfQorCitBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OkFz eW5jRmlsZVdyaXRlckNsaWVudEd0ayhBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayog dGFza0NvbnRyb2xsZXIsIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJp bmcmIG1vZGUpCisgICAgOiBtX3Rhc2tDb250cm9sbGVyKHRhc2tDb250cm9sbGVyKQorICAgICwg bV9jbGllbnQoY2xpZW50KQorICAgICwgbV90YXNrTW9kZShtb2RlKQoreworICAgIG1fdGFza0Nv bnRyb2xsZXItPnNldEN1cnJlbnRUYXNrTW9kZShtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFdyaXRlKGxvbmcgbG9uZyBieXRlcywgYm9vbCBjb21w bGV0ZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmcGVyZm9ybURpZFdyaXRlQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nl c3MobV9jbGllbnQpLCBieXRlcywgY29tcGxldGUpLCBtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBB c3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKCkKK3sKKyAgICBtX3Rhc2tDb250 cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFRy dW5jYXRlQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpKSwgbV90YXNr TW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRGYWlsKEZpbGVF cnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxi YWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2ssIEFsbG93 Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBjb2RlKSwgbV90YXNrTW9kZSk7Cit9CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGll bnRHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGll bnRHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NDM0ZjE3Ci0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRl ckNsaWVudEd0ay5oCkBAIC0wLDAgKzEsMzYgQEAKKyNpZm5kZWYgQXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrX2gKKworI2lmIEVOQUJM RShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVudC5oIgorCisj aW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIKKyNpbmNsdWRlIDx3 dGYvUGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFzeW5jRmls ZVdyaXRlckNsaWVudEd0ayA6IHB1YmxpYyBBc3luY0ZpbGVXcml0ZXJDbGllbnQgeworcHVibGlj OgorICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNsaWVudEd0az4gY3JlYXRl KEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgQXN5bmNG aWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFN0cmluZyYgbW9kZSkKKyAgICB7CisgICAg ICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKHRhc2tDb250 cm9sbGVyLCBjbGllbnQsIG1vZGUpKTsKKyAgICB9CisKKyAgICB2b2lkIGRpZFdyaXRlKGxvbmcg bG9uZyBieXRlcywgYm9vbCBjb21wbGV0ZSk7CisgICAgdm9pZCBkaWRUcnVuY2F0ZSgpOworICAg IHZvaWQgZGlkRmFpbChGaWxlRXJyb3I6OkVycm9yQ29kZSk7CisKK3ByaXZhdGU6CisgICAgQXN5 bmNGaWxlV3JpdGVyQ2xpZW50R3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwg QXN5bmNGaWxlV3JpdGVyQ2xpZW50KiwgY29uc3QgU3RyaW5nJik7CisKKyAgICBSZWZQdHI8QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IG1fdGFza0NvbnRyb2xsZXI7CisgICAgQXN5 bmNGaWxlV3JpdGVyQ2xpZW50KiBtX2NsaWVudDsKKyAgICBTdHJpbmcgbV90YXNrTW9kZTsKK307 CisKK30gLy8gbmFtZXNwYWNlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNl bmRpZiAvLyBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi4yOTI1NjAzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAKQEAgLTAsMCArMSwxNDYgQEAK KyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJHdGsuaCIKKwor I2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVu dEd0ay5oIgorI2luY2x1ZGUgIkJsb2IuaCIKKyNpbmNsdWRlICJCbG9iUmVnaXN0cnlJbXBsLmgi CisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVkZSAiR093blB0ci5oIgorCisj aW5jbHVkZSA8Z2lvL2dpby5oPgorI2luY2x1ZGUgPGdsaWIuaD4KKworI2luY2x1ZGUgIkNTdHJp bmcuaCIKKyNpbmNsdWRlIDxzdGRpby5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0FzeW5j RmlsZVdyaXRlckd0azo6QXN5bmNGaWxlV3JpdGVyR3RrKEFzeW5jRmlsZVdyaXRlckNsaWVudCog Y2xpZW50LCBHRmlsZSogZmlsZSwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRh c2tDb250cm9sbGVyKQorICAgIDogbV9jbGllbnQoY2xpZW50KQorICAgICwgbV9maWxlKGZpbGUp CisgICAgLCBtX3Rhc2tDb250cm9sbGVyKHRhc2tDb250cm9sbGVyKQoreworfQorCitzdGF0aWMg dm9pZCB3cml0ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5j RmlsZVdyaXRlckNsaWVudEd0az4gaGVscGVyQ2xpZW50LCBHRmlsZSogZmlsZSwgbG9uZyBsb25n IHBvc2l0aW9uLCBCbG9iKiBkYXRhKQoreworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAg ICBHRmlsZUlPU3RyZWFtKiBpb1N0cmVhbSA9IGdfZmlsZV9vcGVuX3JlYWR3cml0ZShmaWxlLCAw LCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDbGll bnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIEdPdXRwdXRTdHJlYW0qIG91dHB1dFN0cmVhbSA9IGdfaW9fc3RyZWFtX2dl dF9vdXRwdXRfc3RyZWFtKEdfSU9fU1RSRUFNKGlvU3RyZWFtKSk7CisKKyAgICBnX3NlZWthYmxl X3NlZWsoR19TRUVLQUJMRShvdXRwdXRTdHJlYW0pLCBwb3NpdGlvbiwgR19TRUVLX1NFVCwgMCwg JmVycm9yLm91dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVyQ2xpZW50 LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBQYXNzUmVmUHRyPEJsb2JTdG9yYWdlRGF0YT4gYmxvYlN0b3JhZ2UgPSBzdGF0 aWNfY2FzdDxCbG9iUmVnaXN0cnlJbXBsJj4oYmxvYlJlZ2lzdHJ5KCkpLmdldEJsb2JEYXRhRnJv bVVSTChkYXRhLT51cmwoKSk7CisgICAgaWYgKGJsb2JTdG9yYWdlKSB7CisgICAgICAgIGZvciAo c2l6ZV90IGkgPSAwOyBpIDwgYmxvYlN0b3JhZ2UtPml0ZW1zKCkuc2l6ZSgpOyBpKyspIHsKKyAg ICAgICAgICAgIGNvbnN0IEJsb2JEYXRhSXRlbSYgYmxvYkl0ZW0gPSBibG9iU3RvcmFnZS0+aXRl bXMoKVtpXTsKKyAgICAgICAgICAgIGlmIChibG9iSXRlbS50eXBlID09IEJsb2JEYXRhSXRlbTo6 RGF0YSkgeworICAgICAgICAgICAgICAgIC8vZnByaW50ZihzdGRlcnIsICJcdGdvdCBibG9iIGRh dGEgJXMgQCAlZCBvZiBsZW5ndGggJWRcbiIsIGJsb2JJdGVtLmRhdGEtPmRhdGEoKSwgaSwgYmxv Ykl0ZW0uZGF0YS0+bGVuZ3RoKCkpOworICAgICAgICAgICAgICAgIGdzaXplIGJ5dGVzV3JpdHRl biA9IDA7CisgICAgICAgICAgICAgICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlX2FsbChHX09VVFBV VF9TVFJFQU0ob3V0cHV0U3RyZWFtKSwgYmxvYkl0ZW0uZGF0YS0+ZGF0YSgpLCBibG9iSXRlbS5k YXRhLT5sZW5ndGgoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICZieXRlc1dyaXR0ZW4sIDAsIDApOworICAgICAgICAgICAgICAgIC8vZnByaW50ZihzdGRlcnIs ICJcdHdyaXR0ZW4gJWxkIGJ5dGVzXG4iLCBieXRlc1dyaXR0ZW4pOworICAgICAgICAgICAgICAg IGhlbHBlckNsaWVudC0+ZGlkV3JpdGUoYnl0ZXNXcml0dGVuLCAoaSArIDEgPT0gYmxvYlN0b3Jh Z2UtPml0ZW1zKCkuc2l6ZSgpKSA/IHRydWUgOiBmYWxzZSk7CisgICAgICAgICAgICB9CisgICAg ICAgIH0KKyAgICB9CisKKyAgICBnX291dHB1dF9zdHJlYW1fY2xvc2UoR19PVVRQVVRfU1RSRUFN KG91dHB1dFN0cmVhbSksIDAsIDApOworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckd0azo6d3Jp dGUobG9uZyBsb25nIHBvc2l0aW9uLCBCbG9iKiBkYXRhKQoreworICAgIFN0cmluZyBtb2RlID0g bV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworICAgIG1fdGFza0NvbnRyb2xsZXItPnBv c3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmd3JpdGVBc3luYywgQXN5bmNG aWxlV3JpdGVyQ2xpZW50R3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgbV9jbGll bnQsIG1vZGUpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fZmlsZSksIHBvc2l0aW9uLCBBbGxv d0Nyb3NzVGhyZWFkQWNjZXNzKGRhdGEpKSk7Cit9CisKK3N0YXRpYyB2b2lkIHRydW5jYXRlQXN5 bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrPiBoZWxwZXJDbGllbnQsIEdGaWxlKiBmaWxlLCBsb25nIGxvbmcgbGVuZ3RoKQorewor ICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHRmlsZU91dHB1dFN0cmVhbSogb3V0cHV0 U3RyZWFtID0gZ19maWxlX3JlcGxhY2UoZmlsZSwgMCwgZmFsc2UsIEdfRklMRV9DUkVBVEVfTk9O RSwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVy Q2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisKKyAgICBHRmlsZUluZm8qIGZpbGVJbmZvID0gZ19maWxlX3F1ZXJ5X2luZm8o ZmlsZSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpOwor ICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9y OjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGxvbmcgbG9u ZyBmaWxlTGVuZ3RoID0gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6 ZShmaWxlSW5mbykpOworCisgICAgaWYgKGxlbmd0aCA+IGZpbGVMZW5ndGgpIHsKKyAgICAgICAg R1N0cmluZyogemVyb1BhZGRpbmcgPSBnX3N0cmluZ19uZXdfbGVuKDAsIGxlbmd0aCAtIGZpbGVM ZW5ndGgpOworICAgICAgICB3aGlsZSAobGVuZ3RoID4gZmlsZUxlbmd0aCkgeworICAgICAgICAg ICAgZ19zdHJpbmdfYXBwZW5kX2MoemVyb1BhZGRpbmcsICdcMCcpOworICAgICAgICAgICAgbGVu Z3RoLS07CisgICAgICAgIH0KKworICAgICAgICBHRmlsZUlPU3RyZWFtKiBpb1N0cmVhbSA9IGdf ZmlsZV9vcGVuX3JlYWR3cml0ZShmaWxlLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBp ZiAoZXJyb3IpIHsKKyAgICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6 Ok5PVF9GT1VORF9FUlIpOworICAgICAgICAgICAgZ19zdHJpbmdfZnJlZSh6ZXJvUGFkZGluZywg VFJVRSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBHT3V0cHV0 U3RyZWFtKiBvdXRwdXRTdHJlYW0gPSBnX2lvX3N0cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShHX0lP X1NUUkVBTShpb1N0cmVhbSkpOworCisgICAgICAgIGdfc2Vla2FibGVfc2VlayhHX1NFRUtBQkxF KG91dHB1dFN0cmVhbSksIGxlbmd0aCwgR19TRUVLX1NFVCwgMCwgJmVycm9yLm91dFB0cigpKTsK KyAgICAgICAgaWYgKGVycm9yKSB7CisgICAgICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwo RmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgICAgIGdfc3RyaW5nX2ZyZWUoemVy b1BhZGRpbmcsIFRSVUUpOworICAgICAgICAgICAgZ19vdXRwdXRfc3RyZWFtX2Nsb3NlKG91dHB1 dFN0cmVhbSwgMCwgMCk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAg ICBnc2l6ZSBieXRlc1dyaXR0ZW4gPSAwOworICAgICAgICBnX291dHB1dF9zdHJlYW1fd3JpdGVf YWxsKEdfT1VUUFVUX1NUUkVBTShvdXRwdXRTdHJlYW0pLCB6ZXJvUGFkZGluZy0+c3RyLCB6ZXJv UGFkZGluZy0+bGVuLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZieXRlc1dy aXR0ZW4sIDAsIDApOworCisgICAgICAgIGdfb3V0cHV0X3N0cmVhbV9jbG9zZShvdXRwdXRTdHJl YW0sIDAsIDApOworICAgICAgICBnX3N0cmluZ19mcmVlKHplcm9QYWRkaW5nLCBUUlVFKTsKKyAg ICB9IGVsc2UgeworICAgICAgICBnX3NlZWthYmxlX3RydW5jYXRlKEdfU0VFS0FCTEUob3V0cHV0 U3RyZWFtKSwgbGVuZ3RoLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBpZiAoZXJyb3Ip IHsKKyAgICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VO RF9FUlIpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgaGVs cGVyQ2xpZW50LT5kaWRUcnVuY2F0ZSgpOworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckd0azo6 dHJ1bmNhdGUobG9uZyBsb25nIGxlbmd0aCkKK3sKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0Nv bnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1Rv TWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnRydW5jYXRlQXN5bmMsIEFzeW5jRmlsZVdy aXRlckNsaWVudEd0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIG1fY2xpZW50LCBt b2RlKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2ZpbGUpLCBsZW5ndGgpKTsKK30KKwordm9p ZCBBc3luY0ZpbGVXcml0ZXJHdGs6OmFib3J0KCkKK3sKK30KKworYm9vbCBBc3luY0ZpbGVXcml0 ZXJHdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAgICBpZiAobV90YXNrQ29u dHJvbGxlci0+c3luY2hyb25vdXMoKSkKKyAgICAgICAgcmV0dXJuIG1fdGFza0NvbnRyb2xsZXIt PndhaXRGb3JUYXNrVG9Db21wbGV0ZSgpOworCisgICAgcmV0dXJuIGZhbHNlOworfQorCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmU2M2UwNQotLS0gL2Rldi9udWxsCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaApAQCAtMCww ICsxLDQyIEBACisjaWZuZGVmIEFzeW5jRmlsZVdyaXRlckd0a19oCisjZGVmaW5lIEFzeW5jRmls ZVdyaXRlckd0a19oCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3lu Y0ZpbGVXcml0ZXIuaCIKKworI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrLmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKwordHlwZWRlZiBzdHJ1Y3QgX0dG aWxlIEdGaWxlOworCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFzeW5jRmlsZVdyaXRl ckNsaWVudDsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVyR3RrIDogcHVibGljIEFzeW5jRmlsZVdy aXRlciB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyR3Rr PiBjcmVhdGUoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEdGaWxlKiBmaWxlLCBBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIpCisgICAgeworICAg ICAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVdyaXRlckd0ayhjbGllbnQsIGZpbGUs IHRhc2tDb250cm9sbGVyKSk7CisgICAgfQorCisgICAgdm9pZCB3cml0ZShsb25nIGxvbmcgcG9z aXRpb24sIEJsb2IqIGRhdGEpOworICAgIHZvaWQgdHJ1bmNhdGUobG9uZyBsb25nIGxlbmd0aCk7 CisgICAgdm9pZCBhYm9ydCgpOworCisgICAgYm9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0 ZSgpOworCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVdyaXRlckd0ayhBc3luY0ZpbGVXcml0ZXJD bGllbnQqLCBHRmlsZSosIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKik7CisKKyAg ICBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIG1fY2xpZW50OworICAgIEdGaWxlKiBtX2ZpbGU7Cisg ICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9s bGVyOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJ TEVfU1lTVEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlV3JpdGVyR3RrX2gKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRnbG9iYWxzLmNwcCBiL1NvdXJjZS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRnbG9iYWxzLmNwcAppbmRleCAwZWI0NGNjLi4yOGY0Zjg4IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0Z2xvYmFscy5jcHAKKysr IGIvU291cmNlL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGdsb2JhbHMuY3BwCkBAIC0yNyw2ICsy Nyw3IEBACiAjaW5jbHVkZSAiR093blB0ci5oIgogI2luY2x1ZGUgIkdSZWZQdHIuaCIKICNpbmNs dWRlICJJY29uRGF0YWJhc2UuaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKICNpbmNs dWRlICJMb2dnaW5nLmgiCiAjaW5jbHVkZSAiTWVtb3J5Q2FjaGUuaCIKICNpbmNsdWRlICJQYWdl LmgiCkBAIC0zMjQsNiArMzI1LDEyIEBAIHZvaWQgd2Via2l0SW5pdCgpCiAKICAgICBnX2ZyZWUo ZGF0YWJhc2VEaXJlY3RvcnkpOwogCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorICAgIGdjaGFy KiBsb2NhbEZpbGVTeXN0ZW1EaXJlY3RvcnkgPSBnX2J1aWxkX2ZpbGVuYW1lKGdfZ2V0X3VzZXJf ZGF0YV9kaXIoKSwgIndlYmtpdCIsICJsb2NhbC1maWxlLXN5c3RlbSIsIE5VTEwpOworICAgIExv Y2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShsb2NhbEZpbGVTeXN0ZW1E aXJlY3RvcnkpOworICAgIGdfZnJlZShsb2NhbEZpbGVTeXN0ZW1EaXJlY3RvcnkpOworI2VuZGlm CisKICAgICBQYWdlR3JvdXA6OnNldFNob3VsZFRyYWNrVmlzaXRlZExpbmtzKHRydWUpOwogCiAg ICAgR093blB0cjxnY2hhcj4gaWNvbkRhdGFiYXNlUGF0aChnX2J1aWxkX2ZpbGVuYW1lKGdfZ2V0 X3VzZXJfZGF0YV9kaXIoKSwgIndlYmtpdCIsICJpY29uZGF0YWJhc2UiLCBOVUxMKSk7Cg== 135569 2012-04-04 05:43:58 -0700 2012-04-04 10:23:02 -0700 Patch bug-58443-20120404214356.patch text/plain 71302 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTEyOTkyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGZkNDhmNzViMzRmYTQxNDIxN2RjNTBm MDM0ZGYxOTE1ODYyNDQ0MWQuLjMyNWNiNmU5OGM1MDhkN2I2ZTQ0MmQ1YjhhZWVmYzg1ZGM4YzBk YWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMDQgIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDogQWRkZWQgdHlwZSBkZWZpbml0aW9ucywgR0ZpbGVJT1N0cmVh bSwgR091dHB1dFN0cmVhbSwgR1N0cmluZy4KKwogMjAxMi0wMy0zMCAgRGF2aWQgQmFyciAgPGRh dmlkYmFyckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgU3BsaXQgdXAgdG9wLWxldmVsIC5naXRp Z25vcmUgYW5kIC5naXRhdHRyaWJ1dGVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzg5N2ZkODUwYjZiM2RlNDUy Y2YyOWZlNjZlY2Y1NTkyNjhlMzJhYS4uMmE5YzQ2OGJmYWMyNzg2YTY5NjAwOGVkZDA2ZTA0Njc5 MjNlMTdjYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzNyBAQAorMjAxMi0wNC0wNCAgQ2hhbmdT ZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAgICAgICAgW0dUS10gU3VwcG9ydCB0 aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFRoaXMgcGF0Y2ggYnJpbmdzIEZpbGVTeXN0ZW0gQVBJIHRvIGd0ayBwb3J0LiBU aGlzIGFkZHMgbmV3IGludGVyZmFjZXMgbGlrZQorICAgICAgICBBc3luY0ZpbGVTeXN0ZW1HdGss IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0aywgQXN5bmNGaWxlV3JpdGVyR3RrLCBBc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsKKyAgICAgICAgYW5kIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrLiBUaGVzZSBhcmUgY2hpbGQgY2xhc3NlcyBpbXBsZW1lbnRpbmcgdGhlIGludGVyZmFj ZXMKKyAgICAgICAgb2YgZWFjaCBwYXJlbnQgY2xhc3NlcyBleGNlcHQgQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsuIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrCisgICAg ICAgIGlzIGEgaGVscGVyIGNsYXNzLiBJdCByZXRhaW5zIHNvbWUgdXNlZnVsIHZhcmlhYmxlcywg YW5kIGNvbnRyb2xzIHBvc3RpbmcgdGFza3MgdG8KKyAgICAgICAgU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCB3aGljaCBtaWdodCBiZSBlaXRoZXIgYSBEb2N1bWVudCBvYmplY3Qgb3IgYSBXb3JrZXIu CisgICAgICAgIFVuZm9ydHVuYXRlbHksIFdvcmtlciBmb3IgZmlsZXN5c3RlbSBpcyBub3Qgc3Vw cG9ydGVkIHlldCwgSSBwbGFuIHRvIHN1cHBvcnQgaXQgaW4gdGhlIG5leHQgcGF0Y2guCisKKyAg ICAgICAgVGVzdDogZmFzdC9maWxlc3lzdGVtLyouaHRtbAorICAgICAgICAgICAgICBmYXN0L211 dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRtbAorICAgICAgICAgICAgICBo dHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1ibG9iLmh0bWwKKyAgICAg ICAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi1m YWlsLmh0bWwKKworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06IEFkZGVkIHNvbWUgZmls ZXMgdG8gYnVpbGQgbmV3bHkgZm9yIEZpbGVTeXN0ZW0uCisgICAgICAgICogTW9kdWxlcy9maWxl c3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAg KFdlYkNvcmU6Om9wZW5GaWxlU3lzdGVtKTogQ3JlYXRlZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGsgaW5zdGVhZCBvZiB1c2luZyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MgaXRzZWxmLgor ICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZWFkRmlsZVN5c3RlbSk6IEFkZGVk IG1pc3NpbmcgYXJndW1lbnQgbmFtZS4KKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6cmVxdWVzdEZpbGVTeXN0ZW0pOiBBZGRlZCBtaXNzaW5nIGFyZ3VtZW50IG5hbWUuCisgICAg ICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHA6IEFkZGVk LiBUaGlzIGlzIGFuIGltcGxlbWVudGF0aW9uIG9mIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy4K KyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6Ojpjb3B5KToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRTdWNjZWVkQ2FsbGJhY2sp OgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRTdWNj ZWVkKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNr KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkT3Bl bkZpbGVTeXN0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFJlYWRNZXRhZGF0YUNh bGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 ZGlkUmVhZE1ldGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrc0d0azo6ZGlkUmVhZERpcmVjdG9yeUVudHJ5KToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZv cm1EaWRSZWFkRGlyZWN0b3J5RW50cmllc0FuZEZpbmlzaGVkQ2FsbGJhY2spOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50 cmllcyk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxi YWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlk Q3JlYXRlRmlsZVdyaXRlcik6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkRmFpbENhbGxi YWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlk RmFpbCk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrKToKKyAgICAgICAgKERpcmVjdG9yeUVudHJ5KToKKyAgICAgICAgKFdlYkNv cmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6RGlyZWN0b3J5RW50cnk6OkRpcmVjdG9y eUVudHJ5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcDog QWRkZWQgc29tZSBtaXNzaW5nIEFQSXMuIFRoaXMgaXMgYSBjaGlsZCBjbGFzcyBvZiBBc3luY0Zp bGVTeXN0ZW0uCisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxl KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6aXNWYWxpZFR5cGUpOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OkFzeW5jRmlsZVN5c3RlbUd0ayk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGspOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp0b1VSTCk6CisgICAgICAgIChX ZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6Om1vdmVBc3luYyk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1HdGs6Om1vdmUpOgorICAgICAgICAoV2ViQ29yZTo6Y29weVJlY3Vy c2l2ZWx5KToKKyAgICAgICAgKFdlYkNvcmU6OmNvcHlBc3luYyk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmNvcHkpOgorICAgICAgICAoV2ViQ29yZTo6cmVtb3ZlRmls ZSk6CisgICAgICAgIChXZWJDb3JlOjpyZW1vdmVBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1HdGs6OnJlbW92ZVJlY3Vyc2l2ZWx5KToKKyAgICAgICAgKFdlYkNvcmU6OnJlYWRNZXRh ZGF0YUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZE1l dGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZU9iamVjdEFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlT2JqZWN0KToKKyAgICAgICAgKFdl YkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZSk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVjdG9yeSk6CisgICAgICAgIChXZWJDb3Jl OjpvYmplY3RFeGlzdHNBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1H dGs6OmZpbGVFeGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpk aXJlY3RvcnlFeGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6cmVhZERpcmVjdG9yeUFzeW5jKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZERpcmVjdG9yeSk6Cisg ICAgICAgIChXZWJDb3JlOjpjcmVhdGVXcml0ZXJBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcik6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVNuYXBzaG90RmlsZUFuZFJlYWRNZXRhZGF0YSk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKToKKyAg ICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6dmlydHVhbFBhdGhUb0ZpbGVTeXN0 ZW1VUkwpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp3YWl0Rm9yT3Bl cmF0aW9uVG9Db21wbGV0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3Rl bUd0ay5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1HdGsp OgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ay5jcHA6IEFkZGVkLiBUaGlzIGlzIGEgaGVscGVyIGNsYXNzIHRvIGNvbnRyb2wgcG9zdGluZyB0 YXNrIHRvIGEgdGFyZ2V0IHRocmVhZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OmNyZWF0ZSk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6dW5pcXVl TW9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 azo6cG9zdFRhc2tUb01haW5UaHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZSk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdENhbGxiYWNrVGFzayk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6d2Fp dEZvck9wZXJhdGlvblRvQ29tcGxldGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGs6OmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KToKKyAgICAgICAg KiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaDogQWRkZWQu CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrOjpzeW5jaHJvbm91cyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNr Q29udHJvbGxlckd0azo6c2V0V3JpdGVyVG9DYW5jZWwpOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxkIGNs YXNzIGltcGxlbWVudCBvZiBBeXNuY0ZpbGVXcml0ZXJDbGllbnQuCisgICAgICAgIChXZWJDb3Jl KToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRXcml0ZUNhbGxiYWNrKToKKyAgICAgICAg KFdlYkNvcmU6OnBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6 OnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGspOgorICAgICAgICAoV2ViQ29y ZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRXcml0ZSk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKToKKyAgICAgICAgKFdlYkNv cmU6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkRmFpbCk6CisgICAgICAgICogcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKToKKyAgICAgICAgKFdlYkNv cmU6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6dGFza0NvbnRyb2xsZXIpOgorICAgICAgICAqIHBs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxk IGNsYXNzIG9mIEFzeW5jRmlsZVdyaXRlci4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlV3JpdGVyR3RrOjpBc3luY0ZpbGVXcml0ZXJHdGspOgorICAgICAgICAoV2ViQ29y ZTo6d3JpdGVBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6Ondy aXRlKToKKyAgICAgICAgKFdlYkNvcmU6OnRydW5jYXRlQXN5bmMpOgorICAgICAgICAoV2ViQ29y ZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjp0cnVuY2F0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVXcml0ZXJHdGs6OmFib3J0KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRl ckd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUpOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAg ICAgKEFzeW5jRmlsZVdyaXRlckd0ayk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0xvY2FsRmls ZVN5c3RlbUd0ay5jcHA6IEFkZGVkLiBTb21lIHBvcnQgc3BlY2lmaWMgZnVuY3Rpb25zIGFyZSBl eHRyYWN0ZWQgZnJvbSBMb2NhbEZpbGVTeXN0ZW0uY3BwIGFuZCBhZGRlZCBpbiBoZXJlLgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmluaXRp YWxpemVMb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVt Ojpsb2NhbEZpbGVTeXN0ZW0pOgorCiAyMDEyLTA0LTAyICBQYXZlbCBGZWxkbWFuICA8cGZlbGRt YW5AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6ICJQYXVzZSBvbiBzdGFy dCIgZG9lc24ndCBjaGFuZ2UgY2hlY2tlZCBzdGF0ZSBpbiB3b3JrZXJzIHBhbmVsCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwIGIvU291cmNlL1dURi93dGYv Z29iamVjdC9HT3duUHRyLmNwcAppbmRleCBkZmUxODdkNzg4N2ZmNTRlYTAyN2MxYzlkYzVjMDZi ZDdiZGI1Y2YxLi4zYWEwNzU5OTQ3NmQ3NGUyMmZkZjRlN2NkMGU4NTc3YTI4MTU5MmI0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwCisrKyBiL1NvdXJjZS9X VEYvd3RmL2dvYmplY3QvR093blB0ci5jcHAKQEAgLTQyLDYgKzQyLDE2IEBAIHRlbXBsYXRlIDw+ IHZvaWQgZnJlZU93bmVkR1B0cjxHU0xpc3Q+KEdTTGlzdCogcHRyKQogICAgIGdfc2xpc3RfZnJl ZShwdHIpOwogfQogCit0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1N0cmluZz4oR1N0 cmluZyogcHRyKQoreworICAgIGdfc3RyaW5nX2ZyZWUocHRyLCB0cnVlKTsKK30KKwordGVtcGxh dGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdPdXRwdXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qIHB0 cikKK3sKKyAgICBnX291dHB1dF9zdHJlYW1fY2xvc2UocHRyLCAwLCAwKTsKK30KKwogdGVtcGxh dGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdQYXR0ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKiBwdHIp CiB7CiAgICAgaWYgKHB0cikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093 blB0ci5oIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKaW5kZXggNGIyZGNiNzdi MjUwMDBjMmU1YjY4MDhhNGM3NDg0YzJiZTZkNmNhNS4uOWMwNjdkNzFhNjc5NTVjYzRiZjhkOGZj OGRkZjIwZDliMjJhMWM3MSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3du UHRyLmgKKysrIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKQEAgLTM2LDYgKzM2 LDggQEAgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IGlubGluZSB2b2lkIGZyZWVPd25lZEdQdHIoVCog cHRyKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdFcnJvcj4oR0Vycm9yKik7CiB0 ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHTGlzdD4oR0xpc3QqKTsKIHRlbXBsYXRlPD4g dm9pZCBmcmVlT3duZWRHUHRyPEdTTGlzdD4oR1NMaXN0Kik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJl ZU93bmVkR1B0cjxHU3RyaW5nPihHU3RyaW5nKik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVk R1B0cjxHT3V0cHV0U3RyZWFtPihHT3V0cHV0U3RyZWFtKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJl ZU93bmVkR1B0cjxHUGF0dGVyblNwZWM+KEdQYXR0ZXJuU3BlYyopOwogdGVtcGxhdGU8PiB2b2lk IGZyZWVPd25lZEdQdHI8R0Rpcj4oR0RpciopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQ dHI8R1RpbWVyPihHVGltZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3Qv R1R5cGVkZWZzLmggYi9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5oCmluZGV4IGUy OTI1MGJlZjJlZjRkNWU5ZWJlNWMyYjA1MDM3M2JiYTg1NjRmOWEuLjdhNWU5ZjNjYTA3ZGE1NWU1 NjhjNTcxZDRlNWJjOWY4NTQ1ZWI1MjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmpl Y3QvR1R5cGVkZWZzLmgKKysrIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaApA QCAtNDgsMTcgKzQ4LDIwIEBAIHR5cGVkZWYgc3RydWN0IF9HZGtFdmVudEV4cG9zZSBHZGtFdmVu dEV4cG9zZTsKIHR5cGVkZWYgc3RydWN0IF9HZGtQaXhidWYgR2RrUGl4YnVmOwogdHlwZWRlZiBz dHJ1Y3QgX0dFcnJvciBHRXJyb3I7CiB0eXBlZGVmIHN0cnVjdCBfR0ZpbGUgR0ZpbGU7Cit0eXBl ZGVmIHN0cnVjdCBfR0ZpbGVJT1N0cmVhbSBHRmlsZUlPU3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3Qg X0dIYXNoVGFibGUgR0hhc2hUYWJsZTsKIHR5cGVkZWYgc3RydWN0IF9HSW5wdXRTdHJlYW0gR0lu cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dMaXN0IEdMaXN0OwogdHlwZWRlZiBzdHJ1Y3Qg X0dNYWluQ29udGV4dCBHTWFpbkNvbnRleHQ7CiB0eXBlZGVmIHN0cnVjdCBfR01haW5Mb29wIEdN YWluTG9vcDsKK3R5cGVkZWYgc3RydWN0IF9HT3V0cHV0U3RyZWFtIEdPdXRwdXRTdHJlYW07CiB0 eXBlZGVmIHN0cnVjdCBfR1BhdHRlcm5TcGVjIEdQYXR0ZXJuU3BlYzsKIHR5cGVkZWYgc3RydWN0 IF9HUG9sbGFibGVPdXRwdXRTdHJlYW0gR1BvbGxhYmxlT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBz dHJ1Y3QgX0dTTGlzdCBHU0xpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfR1NvY2tldENsaWVudCBHU29j a2V0Q2xpZW50OwogdHlwZWRlZiBzdHJ1Y3QgX0dTb2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25u ZWN0aW9uOwogdHlwZWRlZiBzdHJ1Y3QgX0dTb3VyY2UgR1NvdXJjZTsKK3R5cGVkZWYgc3RydWN0 IF9HU3RyaW5nIEdTdHJpbmc7CiB0eXBlZGVmIHN0cnVjdCBfR1ZhcmlhbnQgR1ZhcmlhbnQ7CiB0 eXBlZGVmIHVuaW9uIF9HZGtFdmVudCBHZGtFdmVudDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIg R1RpbWVyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBi L1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggYTEwYmVkODY2NTM0M2Rh NzgzNGRkZmE0YjQyYzdlMmQ1ZWJiNjY3Ni4uODEzZDI5YTZjMGY3OWJmM2FjNjFiMzNlNTU0NTli Mzc0MGVlNDBkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5h bQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC00Njc0LDYgKzQ2 NzQsNyBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9HdGtWZXJzaW9uaW5nLmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9LZXlC aW5kaW5nVHJhbnNsYXRvci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9LZXlC aW5kaW5nVHJhbnNsYXRvci5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxG aWxlU3lzdGVtR3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2FsaXpl ZFN0cmluZ3NHdGsuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTWFpbkZyYW1l U2Nyb2xsYmFyR3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL01haW5GcmFt ZVNjcm9sbGJhckd0ay5oIFwKQEAgLTQ5NjcsOCArNDk2OCwxNiBAQCBkb21fYmluZGluZ19pZGxz ICs9IFwKIAkkKFdlYkNvcmUpL01vZHVsZXMvZmlsZXN5c3RlbS9Xb3JrZXJDb250ZXh0RmlsZVN5 c3RlbS5pZGwKIAogd2ViY29yZWd0a19zb3VyY2VzICs9IFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcCBcCisJU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIFwKIAlTb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBcCi0JU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oCisJU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwIFwKKwlTb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBc CisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5j cHAgXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRH dGsuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5j cHAgXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaAog ZW5kaWYgIyBFTkQgRU5BQkxFX0ZJTEVfU1lTVEVNCiAKICMgLS0tLQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA4 ZjAxNjllZWFiYmE5M2ZmNGYxNTZkN2MyMzQ3YjZjMGIyN2Q1YmJhLi5hMWI2Y2FhYmQ4NmEzN2I5 NjU0MGVmNmU2NzQ1ZTZhODQ4NDYyYTJhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNDksMTAgKzQ5LDE1IEBA CiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5o PgogCisjaWYgUExBVEZPUk0oR1RLKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0ay5oIgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogTG9jYWxGaWxlU3lzdGVt KiBMb2NhbEZpbGVTeXN0ZW06OnNfaW5zdGFuY2UgPSAwOwogCisjaWYgIVBMQVRGT1JNKEdUSykK IHZvaWQgTG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0 cmluZyYgYmFzZVBhdGgpCiB7CiAgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBx dW90YSBzZXR0aW5ncyBhcyB3ZWxsLgpAQCAtNzEsMjcgKzc2LDMyIEBAIExvY2FsRmlsZVN5c3Rl bSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQogICAgIEFTU0VSVChzX2luc3Rh bmNlKTsKICAgICByZXR1cm4gKnNfaW5zdGFuY2U7CiB9CisjZW5kaWYKIAogU3RyaW5nIExvY2Fs RmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJhc2VQYXRoKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9i YXNlUGF0aDsKIH0KIAotc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmll ciwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGJvb2wgY3JlYXRlLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQorc3RhdGljIHZvaWQgb3BlbkZpbGVT eXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBiYXNl UGF0aCwgY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlw ZSwgYm9vbCBjcmVhdGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxs YmFja3MsIGJvb2wgc3luY2hyb25vdXMpCiB7CisjaWYgUExBVEZPUk0oR1RLKQorICAgIEFzeW5j RmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0oYmFzZVBhdGgsIGlkZW50aWZpZXIsIHR5cGUsIGNy ZWF0ZSwgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoY29udGV4dCwgY2FsbGJh Y2tzLCBzeW5jaHJvbm91cykpOworI2Vsc2UKICAgICBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxl U3lzdGVtKGJhc2VQYXRoLCBpZGVudGlmaWVyLCB0eXBlLCBjcmVhdGUsIGNhbGxiYWNrcyk7Cisj ZW5kaWYKIH0KIAotdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sKQordm9pZCBM b2NhbEZpbGVTeXN0ZW06OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNv bnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQogewogICAgIC8vIEFz eW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3Vz bHksIHNvIHRoZSBtZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAg IGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZp bGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlk ZW50aWZpZXIoKSwgdHlwZSwgZmFsc2UsIGNhbGxiYWNrcykpOworICAgIGNvbnRleHQtPnBvc3RU YXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0 aCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlw ZSwgZmFsc2UsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKIH0KIAotdm9pZCBMb2NhbEZpbGVT eXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQs IEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wpCit2b2lkIExvY2FsRmlsZVN5c3Rl bTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5 bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZywgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKIHsKICAgICAvLyBB c3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5jaHJvbm91 c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNseS4KLSAg ICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBm aWxlU3lzdGVtQmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJ ZGVudGlmaWVyKCksIHR5cGUsIHRydWUsIGNhbGxiYWNrcykpOworICAgIGNvbnRleHQtPnBvc3RU YXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0 aCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlw ZSwgdHJ1ZSwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOwogfQogCiB9IC8vIG5hbWVzcGFjZQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40ZjczZmM3MmNlNWEzYjAzNzk5NDI0ODYw ZWE0ZDBlNjkyY2I5OTc4Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAKQEAgLTAsMCArMSwxNjMgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWls LmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBG b3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9z dG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNs dWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZ U1RFTSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUd0ay5oIgorI2luY2x1ZGUgIkFzeW5j RmlsZVdyaXRlci5oIgorI2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIkZp bGVNZXRhZGF0YS5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKworI2lu Y2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit0ZW1w bGF0ZTw+IHN0cnVjdCBDcm9zc1RocmVhZENvcGllckJhc2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0 YWRhdGE+IHsKKyAgICB0eXBlZGVmIEZpbGVNZXRhZGF0YSBUeXBlOworICAgIHN0YXRpYyBGaWxl TWV0YWRhdGEgY29weShjb25zdCBGaWxlTWV0YWRhdGEmKTsKK307CisKK0Nyb3NzVGhyZWFkQ29w aWVyQmFzZTxmYWxzZSwgZmFsc2UsIEZpbGVNZXRhZGF0YT46OlR5cGUgQ3Jvc3NUaHJlYWRDb3Bp ZXJCYXNlPGZhbHNlLCBmYWxzZSwgRmlsZU1ldGFkYXRhPjo6Y29weShjb25zdCBGaWxlTWV0YWRh dGEmIG9yaWdpbmFsKQoreworICAgIEZpbGVNZXRhZGF0YSBtZXRhZGF0YTsKKyAgICBtZXRhZGF0 YS5tb2RpZmljYXRpb25UaW1lID0gb3JpZ2luYWwubW9kaWZpY2F0aW9uVGltZTsKKyAgICBtZXRh ZGF0YS5sZW5ndGggPSBvcmlnaW5hbC5sZW5ndGg7CisgICAgbWV0YWRhdGEudHlwZSA9IG9yaWdp bmFsLnR5cGU7CisgICAgbWV0YWRhdGEucGxhdGZvcm1QYXRoID0gb3JpZ2luYWwucGxhdGZvcm1Q YXRoOworICAgIHJldHVybiBtZXRhZGF0YTsKK30KKworUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGs+IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgcmV0dXJuIGFkb3B0 UHRyKG5ldyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoY29udGV4dCwgY2FsbGJhY2tzLCBz eW5jaHJvbm91cykpOworfQorCitQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 az4gQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoQXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgcmV0dXJu IGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsodGFza0NvbnRyb2xsZXIs IGNhbGxiYWNrcywgbW9kZSkpOworfQorCisKK0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRl eHQsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wg c3luY2hyb25vdXMpCisgICAgOiBtX3N5bmNocm9ub3VzKHN5bmNocm9ub3VzKQorICAgICwgbV90 YXNrTW9kZSgiIikKKyAgICAsIG1fdGFza0NvbnRyb2xsZXIoQXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs6OmNyZWF0ZShjb250ZXh0LCBzeW5jaHJvbm91cykpCisgICAgLCBtX2NhbGxi YWNrcyhjYWxsYmFja3MpCit7Cit9CisKK0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KiB0YXNrQ29udHJvbGxlciwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNh bGxiYWNrcywgY29uc3QgU3RyaW5nJiBtb2RlKQorICAgIDogbV9zeW5jaHJvbm91cyhmYWxzZSkK KyAgICAsIG1fdGFza01vZGUobW9kZSkKKyAgICAsIG1fdGFza0NvbnRyb2xsZXIodGFza0NvbnRy b2xsZXIpCisgICAgLCBtX2NhbGxiYWNrcyhjYWxsYmFja3MpCit7Cit9CisKK3N0YXRpYyB2b2lk IHBlcmZvcm1EaWRTdWNjZWVkQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY2FsbGJh Y2tzLT5kaWRTdWNjZWVkKCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr OjpkaWRTdWNjZWVkKCkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNr KGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFN1Y2NlZWRDYWxsYmFjaywgbV9jYWxsYmFj a3MucmVsZWFzZSgpKSwgbV90YXNrTW9kZSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRP cGVuRmlsZVN5c3RlbUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcmIG5hbWUs IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBmaWxlU3lzdGVtKQoreworICAgIGNhbGxiYWNr cy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgZmlsZVN5c3RlbSk7Cit9CisKK3ZvaWQgQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIG5h bWUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPiBmaWxlU3lzdGVtKQoreworICAgIEFzeW5j RmlsZVN5c3RlbUd0ayogZmlsZVN5c3RlbUd0ayA9IHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3Rl bUd0ayo+KGZpbGVTeXN0ZW0uZ2V0KCkpOworCisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250 cm9sbGVyLT51bmlxdWVNb2RlKCk7CisgICAgbV90YXNrQ29udHJvbGxlci0+c2V0Q3VycmVudFRh c2tNb2RlKG1vZGUpOworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3Jl YXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjaywgbV9jYWxs YmFja3MucmVsZWFzZSgpLCBuYW1lLCBmaWxlU3lzdGVtKSwgbW9kZSk7CisKKyAgICBmaWxlU3lz dGVtR3RrLT5zZXRUYXNrQ29udHJvbGxlcihtX3Rhc2tDb250cm9sbGVyLnJlbGVhc2UoKSk7Cisg ICAgZmlsZVN5c3RlbUd0ay0+d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKTsKK30KKworc3Rh dGljIHZvaWQgcGVyZm9ybURpZFJlYWRNZXRhZGF0YUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBj b25zdCBGaWxlTWV0YWRhdGEmIG1ldGFkYXRhKQoreworICAgIGNhbGxiYWNrcy0+ZGlkUmVhZE1l dGFkYXRhKG1ldGFkYXRhKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6 OmRpZFJlYWRNZXRhZGF0YShjb25zdCBGaWxlTWV0YWRhdGEmIG1ldGFkYXRhKQoreworICAgIG1f dGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJm b3JtRGlkUmVhZE1ldGFkYXRhQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgbWV0YWRh dGEpLCBtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6 OmRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3Rv cnkpCit7CisgICAgRGlyZWN0b3J5RW50cnkgZGlyZWN0b3J5RW50cnk7CisgICAgZGlyZWN0b3J5 RW50cnkubmFtZSA9IG5hbWU7CisgICAgZGlyZWN0b3J5RW50cnkuaXNEaXJlY3RvcnkgPSBpc0Rp cmVjdG9yeTsKKyAgICBtX2RpcmVjdG9yeUVudHJpZXMuYXBwZW5kKGRpcmVjdG9yeUVudHJ5KTsK K30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZFJlYWREaXJlY3RvcnlFbnRyaWVzQW5kRmluaXNo ZWRDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJl Y3RvcnlFbnRyaWVzKGZhbHNlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKGJvb2wgaGFzTW9yZSkKK3sKKyAgICBpZiAoaGFz TW9yZSkKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisKKyAgICBWZWN0b3I8RGlyZWN0 b3J5RW50cnk+OjppdGVyYXRvciBlbmQgPSBtX2RpcmVjdG9yeUVudHJpZXMuZW5kKCk7CisgICAg Zm9yIChWZWN0b3I8RGlyZWN0b3J5RW50cnk+OjppdGVyYXRvciBpdCA9IG1fZGlyZWN0b3J5RW50 cmllcy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgIG1fY2FsbGJhY2tzLT5kaWRS ZWFkRGlyZWN0b3J5RW50cnkoaXQtPm5hbWUsIGl0LT5pc0RpcmVjdG9yeSk7CisKKyAgICBtX2Rp cmVjdG9yeUVudHJpZXMuY2xlYXIoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxs YmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkUmVhZERpcmVjdG9yeUVudHJp ZXNBbmRGaW5pc2hlZENhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCkpLCBtX3Rhc2tNb2Rl KTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayhT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IGNhbGxiYWNrcywgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXI+IHdyaXRlciwgbG9uZyBs b25nIGxlbmd0aCkKK3sKKyAgICBjYWxsYmFja3MtPmRpZENyZWF0ZUZpbGVXcml0ZXIod3JpdGVy LCBsZW5ndGgpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkQ3Jl YXRlRmlsZVdyaXRlcihQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBsb25nIGxv bmcgbGVuZ3RoKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3Jl YXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrLCBtX2Nh bGxiYWNrcy5yZWxlYXNlKCksIHdyaXRlciwgbGVuZ3RoKSwgbV90YXNrTW9kZSk7Cit9CisKK3N0 YXRpYyB2b2lkIHBlcmZvcm1EaWRGYWlsQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCos IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGludCBjb2Rl KQoreworICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChjb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmRpZEZhaWwoaW50IGNvZGUpCit7CisgICAgbV90YXNrQ29udHJv bGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRGYWls Q2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgY29kZSksIG1fdGFza01vZGUpOworfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0p CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMmNiOTg3YjAwNDIwYzczYjQzZWI4NjEzOTY2 ODA3YWZmMjZhMWI5OAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaApAQCAtMCwwICsxLDY5IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+ CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExl c3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0a19oCisjZGVmaW5lIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisKKyNpZiBFTkFC TEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaW5jbHVk ZSA8d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBTY3Jp cHRFeGVjdXRpb25Db250ZXh0OworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsg OiBwdWJsaWMgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0ZShTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29s IHN5bmNocm9ub3VzID0gZmFsc2UpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJpbmcmIG1v ZGUpOworCisgICAgdmlydHVhbCB2b2lkIGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFsIHZvaWQg ZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbT4pOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1l dGFkYXRhJik7CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBT dHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFk RGlyZWN0b3J5RW50cmllcyhib29sIGhhc01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVh dGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiwgbG9uZyBsb25nIGxlbmd0 aCk7CisgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoaW50IGNvZGUpOworCitwcml2YXRlOgorICAg IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzKTsKKyAg ICBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmlu ZyYgbW9kZSk7CisKKyAgICBzdHJ1Y3QgRGlyZWN0b3J5RW50cnkgeworICAgICAgICBTdHJpbmcg bmFtZTsKKyAgICAgICAgYm9vbCBpc0RpcmVjdG9yeTsKKworICAgICAgICBEaXJlY3RvcnlFbnRy eSgpIDogaXNEaXJlY3RvcnkoZmFsc2UpIHsgfQorICAgIH07CisKKyAgICBib29sIG1fc3luY2hy b25vdXM7CisgICAgU3RyaW5nIG1fdGFza01vZGU7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIE93blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3M+IG1fY2FsbGJhY2tzOworICAgIFZlY3RvcjxEaXJlY3RvcnlFbnRy eT4gbV9kaXJlY3RvcnlFbnRyaWVzOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8v IEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lz dGVtR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1H dGsuY3BwCmluZGV4IGMxZGIwMDZhODQ4ZjM5MjZkZDlmZWMzMWY5NjRhMGZkYmRhZjY5ZmMuLjVm ZGVlZTViN2UzNDdhODNiZWY3MTU4YTYzMjJmZWUxNTRmYjYyN2EgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCkBAIC0xOCwyNyAr MTgsMzUgQEAKICAqLwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxl U3lzdGVtR3RrLmgiCiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiAKLSNpbmNsdWRlICJBc3lu Y0ZpbGVTeXN0ZW1HdGsuaCIKLQotI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5o IgorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorI2luY2x1ZGUgIkFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlV3Jp dGVyR3RrLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCiAjaW5jbHVkZSAiRXhjZXB0 aW9uQ29kZS5oIgorI2luY2x1ZGUgIkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5 c3RlbS5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAKKyNpbmNsdWRlIDxnbGliLmg+ CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0 L0dSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjaW5jbHVkZSA8d3Rm L3RleHQvU3RyaW5nQnVpbGRlci5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wgQXN5 bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAg ICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIGJvb2wgQXN5bmNGaWxlU3lz dGVtOjppc1ZhbGlkVHlwZShUeXBlIHR5cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAg ICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIHR5cGUgPT0gVGVtcG9yYXJ5IHx8IHR5cGUgPT0g UGVyc2lzdGVudDsKIH0KIAogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5 c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkKQEAgLTQ4LDggKzU2LDEwIEBAIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtPiBBc3luY0ZpbGVTeXN0ZW06OmNyZWF0ZShUeXBlIHR5cGUpCiAKIHZvaWQg QXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBj b25zdCBTdHJpbmcmIHN0b3JhZ2VJZGVudGlmaWVyLCBUeXBlIHR5cGUsIGJvb2wsIFBhc3NPd25Q dHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVt ZW50ZWQoKTsKLSAgICBjYWxsYmFja3MtPmRpZEZhaWwoTk9UX1NVUFBPUlRFRF9FUlIpOworICAg IFN0cmluZyB0eXBlU3RyaW5nID0gKHR5cGUgPT0gQXN5bmNGaWxlU3lzdGVtOjpQZXJzaXN0ZW50 KSA/ICJQZXJzaXN0ZW50IiA6ICJUZW1wb3JhcnkiOworICAgIFN0cmluZyBuYW1lID0gc3RvcmFn ZUlkZW50aWZpZXIgKyAiOiIgKyB0eXBlU3RyaW5nOworCisgICAgY2FsbGJhY2tzLT5kaWRPcGVu RmlsZVN5c3RlbShuYW1lLCBBc3luY0ZpbGVTeXN0ZW06OmNyZWF0ZSh0eXBlKSk7CiB9CiAKIGJv b2wgQXN5bmNGaWxlU3lzdGVtOjpjcmFja0ZpbGVTeXN0ZW1VUkwoY29uc3QgS1VSTCYgdXJsLCBB c3luY0ZpbGVTeXN0ZW06OlR5cGUmIHR5cGUsIFN0cmluZyYgZmlsZVBhdGgpCkBAIC02MCw3NSAr NzAsMzk2IEBAIGJvb2wgQXN5bmNGaWxlU3lzdGVtOjpjcmFja0ZpbGVTeXN0ZW1VUkwoY29uc3Qg S1VSTCYgdXJsLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUmCiAKIEFzeW5jRmlsZVN5c3RlbUd0azo6 QXN5bmNGaWxlU3lzdGVtR3RrKEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlKQogICAgIDogQXN5 bmNGaWxlU3lzdGVtKHR5cGUpCisgICAgLCBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoKExvY2Fs RmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkuZmlsZVN5c3RlbUJhc2VQYXRoKCkpCiB7Ci0g ICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAogQXN5bmNGaWxlU3lzdGVtR3RrOjp+QXN5bmNGaWxl U3lzdGVtR3RrKCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCiBTdHJpbmcgQXN5bmNG aWxlU3lzdGVtR3RrOjp0b1VSTChjb25zdCBTdHJpbmcmIG9yaWdpblN0cmluZywgY29uc3QgU3Ry aW5nJiBmdWxsUGF0aCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiBTdHJp bmcoKTsKKyAgICBBU1NFUlQoIW9yaWdpblN0cmluZy5pc0VtcHR5KCkpOworICAgIGlmIChvcmln aW5TdHJpbmcgPT0gU3RyaW5nKCJudWxsIikpCisgICAgICAgIHJldHVybiBTdHJpbmcoKTsKKwor ICAgIFN0cmluZ0J1aWxkZXIgcmVzdWx0OworICAgIHJlc3VsdC5hcHBlbmQoImZpbGVzeXN0ZW06 Iik7CisgICAgcmVzdWx0LmFwcGVuZChvcmlnaW5TdHJpbmcpOworICAgIHJlc3VsdC5hcHBlbmQo Ii8iKTsKKyAgICBpZiAodHlwZSgpID09IFRlbXBvcmFyeSkKKyAgICAgICAgcmVzdWx0LmFwcGVu ZCh0ZW1wb3JhcnlQYXRoUHJlZml4KTsKKyAgICBpZiAodHlwZSgpID09IFBlcnNpc3RlbnQpCisg ICAgICAgIHJlc3VsdC5hcHBlbmQocGVyc2lzdGVudFBhdGhQcmVmaXgpOworICAgIHJlc3VsdC5h cHBlbmQoZW5jb2RlV2l0aFVSTEVzY2FwZVNlcXVlbmNlcyhmdWxsUGF0aCkpOworCisgICAgcmV0 dXJuIHJlc3VsdC50b1N0cmluZygpOworfQorCitzdGF0aWMgdm9pZCBtb3ZlQXN5bmMoU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr PiBoZWxwZXJDYWxsYmFja3MsIFN0cmluZyYgc3JjUGF0aCwgU3RyaW5nJiBkZXN0UGF0aCkKK3sK KyAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9y X3BhdGgoc3JjUGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgR1JlZlB0cjxHRmlsZT4gZGVzdGlu YXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoZGVzdFBhdGgudXRmOCgp LmRhdGEoKSkpOworCisgICAgR1JlZlB0cjxHRmlsZUluZm8+IHNvdXJjZUluZm8gPSBhZG9wdEdS ZWYoZ19maWxlX3F1ZXJ5X2luZm8oc291cmNlRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllf SU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKCFzb3VyY2VJbmZvKSB7CisgICAgICAgIGhlbHBl ckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGRlc3RpbmF0aW9uSW5mbyA9 IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhkZXN0aW5hdGlvbkZpbGUuZ2V0KCksICIqIiwg R19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlmIChkZXN0aW5hdGlvbkluZm8p IHsKKyAgICAgICAgR0ZpbGVUeXBlIHNvdXJjZUZpbGVUeXBlID0gZ19maWxlX2luZm9fZ2V0X2Zp bGVfdHlwZShzb3VyY2VJbmZvLmdldCgpKTsKKyAgICAgICAgR0ZpbGVUeXBlIGRlc3RpbmF0aW9u RmlsZVR5cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGRlc3RpbmF0aW9uSW5mby5nZXQo KSk7CisKKyAgICAgICAgaWYgKHNvdXJjZUZpbGVUeXBlICE9IGRlc3RpbmF0aW9uRmlsZVR5cGUp IHsKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6OklOVkFM SURfTU9ESUZJQ0FUSU9OX0VSUik7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAg ICAgICAgaWYgKGRlc3RpbmF0aW9uRmlsZVR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZCisg ICAgICAgICAgICAgICAgJiYgIWdfZmlsZV9kZWxldGUoZGVzdGluYXRpb25GaWxlLmdldCgpLCAw LCAwKSkgeworICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6 SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAg fQorICAgIH0KKworICAgIGlmICghZ19maWxlX21vdmUoc291cmNlRmlsZS5nZXQoKSwgZGVzdGlu YXRpb25GaWxlLmdldCgpLCBHX0ZJTEVfQ09QWV9PVkVSV1JJVEUsIDAsIDAsIDAsIDApKSB7Cisg ICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIp OworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNj ZWVkKCk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjptb3ZlKGNvbnN0IFN0cmluZyYg c291cmNlUGF0aCwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblBhdGgsIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKKyAgICBTdHJpbmcgc291cmNlRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5 c3RlbVVSTChzb3VyY2VQYXRoKTsKKyAgICBTdHJpbmcgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0 aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGRlc3RpbmF0aW9uUGF0aCk7CisgICAgU3Ry aW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tD b250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm1vdmVB c3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxl ci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgc291cmNlRmlsZVN5c3RlbVBhdGgsIGRlc3RpbmF0 aW9uRmlsZVN5c3RlbVBhdGgpKTsKK30KKworc3RhdGljIHZvaWQgY29weVJlY3Vyc2l2ZWx5KEdG aWxlKiBzb3VyY2VEaXJlY3RvcnksIEdGaWxlKiBkZXN0aW5hdGlvbkRpcmVjdG9yeSwgR0Vycm9y KiogZXJyb3IpCit7CisgICAgaWYgKCFnX2ZpbGVfbWFrZV9kaXJlY3RvcnkoZGVzdGluYXRpb25E aXJlY3RvcnksIDAsIGVycm9yKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgR093blB0cjxHRGly PiBkaXJlY3RvcnkoZ19kaXJfb3BlbihnX2ZpbGVfZ2V0X3BhdGgoc291cmNlRGlyZWN0b3J5KSwg MCwgZXJyb3IpKTsKKyAgICBpZiAoIWRpcmVjdG9yeSkKKyAgICAgICAgcmV0dXJuOworCisgICAg d2hpbGUgKGNvbnN0IGNoYXIqIGRpcmVjdG9yeUVudHJ5ID0gY29uc3RfY2FzdDxjaGFyKj4oZ19k aXJfcmVhZF9uYW1lKGRpcmVjdG9yeS5nZXQoKSkpKSB7CisgICAgICAgIEdSZWZQdHI8R0ZpbGU+ IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX2dldF9jaGlsZChzb3VyY2VEaXJlY3Rvcnks IGRpcmVjdG9yeUVudHJ5KSk7CisgICAgICAgIEdSZWZQdHI8R0ZpbGU+IGRlc3RpbmF0aW9uRmls ZSA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0X2NoaWxkKGRlc3RpbmF0aW9uRGlyZWN0b3J5LCBkaXJl Y3RvcnlFbnRyeSkpOworCisgICAgICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBzb3VyY2VJbmZvID0g YWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKHNvdXJjZUZpbGUuZ2V0KCksICIqIiwgR19GSUxF X1FVRVJZX0lORk9fTk9ORSwgMCwgZXJyb3IpKTsKKyAgICAgICAgaWYgKCFzb3VyY2VJbmZvKQor ICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBpZiAoZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlw ZShzb3VyY2VJbmZvLmdldCgpKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpIHsKKyAgICAgICAg ICAgIGNvcHlSZWN1cnNpdmVseShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0 KCksIGVycm9yKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICBpZiAo IWdfZmlsZV9jb3B5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgR19G SUxFX0NPUFlfTk9ORSwgMCwgMCwgMCwgZXJyb3IpKQorICAgICAgICAgICAgcmV0dXJuOworICAg IH0KK30KKworc3RhdGljIHZvaWQgY29weUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBT dHJpbmcmIHNvdXJjZVBhdGgsIFN0cmluZyYgZGVzdFBhdGgpCit7CisgICAgR1JlZlB0cjxHRmls ZT4gc291cmNlRmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHNvdXJjZVBhdGgu dXRmOCgpLmRhdGEoKSkpOworICAgIEdSZWZQdHI8R0ZpbGU+IGRlc3RpbmF0aW9uRmlsZSA9IGFk b3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGRlc3RQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKwor ICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBzb3VyY2VJbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVy eV9pbmZvKHNvdXJjZUZpbGUuZ2V0KCksICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwg MCkpOworICAgIGlmICghc291cmNlSW5mbykgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRp ZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KworICAgIEdGaWxlVHlwZSBzb3VyY2VGaWxlVHlwZSA9IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5 cGUoc291cmNlSW5mby5nZXQoKSk7CisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGRlc3RpbmF0aW9u SW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhkZXN0aW5hdGlvbkZpbGUuZ2V0KCks ICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlmIChkZXN0aW5hdGlv bkluZm8pIHsKKyAgICAgICAgR0ZpbGVUeXBlIGRlc3RpbmF0aW9uRmlsZVR5cGUgPSBnX2ZpbGVf aW5mb19nZXRfZmlsZV90eXBlKGRlc3RpbmF0aW9uSW5mby5nZXQoKSk7CisgICAgICAgIGlmIChz b3VyY2VGaWxlVHlwZSAhPSBkZXN0aW5hdGlvbkZpbGVUeXBlKSB7CisgICAgICAgICAgICBoZWxw ZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlIp OworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgICAgIGlmIChkZXN0aW5hdGlv bkZpbGVUeXBlID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWQorICAgICAgICAgICAgICAgICYmICFn X2ZpbGVfZGVsZXRlKGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgMCwgMCkpIHsKKyAgICAgICAgICAg IGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9O X0VSUik7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAo c291cmNlRmlsZVR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZKSB7CisgICAgICAgIEdPd25Q dHI8R0Vycm9yPiBlcnJvcjsKKyAgICAgICAgY29weVJlY3Vyc2l2ZWx5KHNvdXJjZUZpbGUuZ2V0 KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgJmVycm9yLm91dFB0cigpKTsKKyAgICAgICAgaWYg KGVycm9yKQorICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6 Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNr cy0+ZGlkU3VjY2VlZCgpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKCFnX2Zp bGVfY29weShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIEdfRklMRV9D T1BZX09WRVJXUklURSwgMCwgMCwgMCwgMCkpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5k aWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0Zp bGVTeXN0ZW1HdGs6OmNvcHkoY29uc3QgU3RyaW5nJiBzb3VyY2VQYXRoLCBjb25zdCBTdHJpbmcm IGRlc3RpbmF0aW9uUGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNh bGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBzb3VyY2VGaWxl U3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHNvdXJjZVBhdGgpOworICAg IFN0cmluZyBkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0 ZW1VUkwoZGVzdGluYXRpb25QYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xs ZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWlu VGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY29weUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUp LCBzb3VyY2VGaWxlU3lzdGVtUGF0aCwgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCkpOworfQor CitzdGF0aWMgdm9pZCByZW1vdmVGaWxlKEdGaWxlKiBmaWxlLCBib29sIHJlY3Vyc2l2ZSwgR0Vy cm9yKiogZXJyb3IpCit7CisgICAgaWYgKHJlY3Vyc2l2ZSAmJiBnX2ZpbGVfdGVzdChnX2ZpbGVf Z2V0X3BhdGgoZmlsZSksIEdfRklMRV9URVNUX0lTX0RJUikpIHsKKyAgICAgICAgR093blB0cjxH RGlyPiBkaXJlY3RvcnkoZ19kaXJfb3BlbihnX2ZpbGVfZ2V0X3BhdGgoZmlsZSksIDAsIGVycm9y KSk7CisgICAgICAgIGlmICghZGlyZWN0b3J5KQorICAgICAgICAgICAgcmV0dXJuOworCisgICAg ICAgIHdoaWxlIChjb25zdCBjaGFyKiBkaXJlY3RvcnlFbnRyeSA9IGNvbnN0X2Nhc3Q8Y2hhcio+ KGdfZGlyX3JlYWRfbmFtZShkaXJlY3RvcnkuZ2V0KCkpKSkgeworICAgICAgICAgICAgR1JlZlB0 cjxHRmlsZT4gY2hpbGQgPSBhZG9wdEdSZWYoZ19maWxlX2dldF9jaGlsZChmaWxlLCBkaXJlY3Rv cnlFbnRyeSkpOworICAgICAgICAgICAgcmVtb3ZlRmlsZShjaGlsZC5nZXQoKSwgcmVjdXJzaXZl LCBlcnJvcik7CisgICAgICAgICAgICBpZiAoKmVycm9yKQorICAgICAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgfQorICAgIH0KKworICAgIGdfZmlsZV9kZWxldGUoZmlsZSwgMCwgZXJyb3Ip OworfQorCitzdGF0aWMgdm9pZCByZW1vdmVBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywg U3RyaW5nJiBmaWxlUGF0aCwgYm9vbCByZWN1cnNpdmUpCit7CisgICAgR093blB0cjxHRXJyb3I+ IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19m b3JfcGF0aChmaWxlUGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgcmVtb3ZlRmlsZShmaWxlLmdl dCgpLCByZWN1cnNpdmUsICZlcnJvci5vdXRQdHIoKSk7CisgICAgaWYgKGVycm9yKSB7CisgICAg ICAgIEZpbGVFcnJvcjo6RXJyb3JDb2RlIGVycm9yQ29kZTsKKyAgICAgICAgc3dpdGNoIChlcnJv ci0+Y29kZSkgeworICAgICAgICBjYXNlIEdfSU9fRVJST1JfTk9UX0VNUFRZOgorICAgICAgICAg ICAgZXJyb3JDb2RlID0gRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlI7CisgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBHX0lPX0VSUk9SX05PVF9GT1VORDoKKyAgICAg ICAgZGVmYXVsdDoKKyAgICAgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6Tk9UX0ZPVU5E X0VSUjsKKyAgICAgICAgfQorCisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChlcnJv ckNvZGUpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5k aWRTdWNjZWVkKCk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZW1vdmUoY29uc3Qg U3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJh Y2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRo ID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBt X3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5w b3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlbW92ZUFzeW5jLCBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBj YWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgZmFsc2UpKTsKIH0KIAogdm9pZCBBc3lu Y0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZVJlY3Vyc2l2ZWx5KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJ bXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9G aWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+ dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJl YWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZyZW1vdmVBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwg ZmlsZVN5c3RlbVBhdGgsIHRydWUpKTsKK30KKworc3RhdGljIHZvaWQgcmVhZE1ldGFkYXRhQXN5 bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIFN0cmluZyYgZmlsZVBhdGgpCit7CisgICAgR1Jl ZlB0cjxHRmlsZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRo LnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9w dEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oZmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5G T19OT05FLCAwLCAwKSk7CisgICAgaWYgKCFmaWxlSW5mbykgeworICAgICAgICBoZWxwZXJDYWxs YmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKworICAgIEZpbGVNZXRhZGF0YTo6VHlwZSB0eXBlID0gZ19maWxlX2luZm9fZ2V0 X2ZpbGVfdHlwZShmaWxlSW5mby5nZXQoKSkgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZID8gRmls ZU1ldGFkYXRhOjpUeXBlRGlyZWN0b3J5IDogRmlsZU1ldGFkYXRhOjpUeXBlRmlsZTsKKworICAg IEdUaW1lVmFsIHRpbWVWYWx1ZTsKKyAgICBnX2ZpbGVfaW5mb19nZXRfbW9kaWZpY2F0aW9uX3Rp bWUoZmlsZUluZm8uZ2V0KCksICZ0aW1lVmFsdWUpOworCisgICAgRmlsZU1ldGFkYXRhIG1ldGFk YXRhOworICAgIG1ldGFkYXRhLnR5cGUgPSB0eXBlOworICAgIG1ldGFkYXRhLm1vZGlmaWNhdGlv blRpbWUgPSBzdGF0aWNfY2FzdDxkb3VibGU+KHRpbWVWYWx1ZS50dl9zZWMpOworICAgIG1ldGFk YXRhLmxlbmd0aCA9IHR5cGUgPT0gRmlsZU1ldGFkYXRhOjpUeXBlRmlsZSA/IHN0YXRpY19jYXN0 PGxvbmcgbG9uZz4oZ19maWxlX2luZm9fZ2V0X3NpemUoZmlsZUluZm8uZ2V0KCkpKSA6IDA7Cisg ICAgbWV0YWRhdGEucGxhdGZvcm1QYXRoID0gU3RyaW5nKGdfZmlsZV9nZXRfcGF0aChmaWxlLmdl dCgpKSk7CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFJlYWRNZXRhZGF0YShtZXRhZGF0YSk7 CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5n JiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQog ewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmly dHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tD b250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFz a1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlYWRNZXRhZGF0YUFzeW5jLCBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBj YWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCkpOwogfQogCi12b2lkIEFzeW5jRmlsZVN5 c3RlbUd0azo6Y3JlYXRlRmlsZShjb25zdCBTdHJpbmcmIHBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQorc3RhdGljIHZv aWQgY3JlYXRlT2JqZWN0QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIFN0cmluZyYgbG9j YWxGaWxlU3lzdGVtUGF0aCwgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIEdGaWxlVHlwZSB0eXBlKQog ewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgaWYgKHR5cGUgPT0gR19GSUxFX1RZUEVfUkVH VUxBUiAmJiBhYnNvbHV0ZVBhdGggPT0gU3RyaW5nKCIvIikpIHsKKyAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6U0VDVVJJVFlfRVJSKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxl PiBmaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgobG9jYWxGaWxlU3lzdGVtUGF0 aC51dGY4KCkuZGF0YSgpKSk7CisgICAgaWYgKHR5cGUgPT0gR19GSUxFX1RZUEVfUkVHVUxBUikK KyAgICAgICAgR1JlZlB0cjxHRmlsZU91dHB1dFN0cmVhbT4gb3V0cHV0U3RyZWFtID0gYWRvcHRH UmVmKGdfZmlsZV9jcmVhdGUoZmlsZS5nZXQoKSwgR19GSUxFX0NSRUFURV9OT05FLCAwLCAmZXJy b3Iub3V0UHRyKCkpKTsKKyAgICBlbHNlIGlmICh0eXBlID09IEdfRklMRV9UWVBFX0RJUkVDVE9S WSkKKyAgICAgICAgZ19maWxlX21ha2VfZGlyZWN0b3J5KGZpbGUuZ2V0KCksIDAsICZlcnJvci5v dXRQdHIoKSk7CisgICAgZWxzZQorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKworICAg IGlmIChlcnJvcikgeworICAgICAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNvZGU7Cisg ICAgICAgIHN3aXRjaCAoZXJyb3ItPmNvZGUpIHsKKyAgICAgICAgY2FzZSBHX0lPX0VSUk9SX0VY SVNUUzoKKyAgICAgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklD QVRJT05fRVJSOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgR19JT19FUlJPUl9O T1RfRk9VTkQ6CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBlcnJvckNvZGUgPSBGaWxl RXJyb3I6Ok5PVF9GT1VORF9FUlI7CisgICAgICAgIH0KKyAgICAgICAgaGVscGVyQ2FsbGJhY2tz LT5kaWRGYWlsKGVycm9yQ29kZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBoZWxw ZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAotdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6 OmNyZWF0ZURpcmVjdG9yeShjb25zdCBTdHJpbmcmIHBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQordm9pZCBBc3luY0Zp bGVTeXN0ZW1HdGs6OmNyZWF0ZU9iamVjdChQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrcz4gY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcmIGFic29sdXRlUGF0aCwgR0ZpbGVUeXBlIHR5 cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgbG9jYWxGaWxlU3lzdGVt UGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGFic29sdXRlUGF0aCk7CisgICAgU3Ry aW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tD b250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmNyZWF0 ZU9iamVjdEFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tD b250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBsb2NhbEZpbGVTeXN0ZW1QYXRoLCBh YnNvbHV0ZVBhdGgsIHR5cGUpKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0 ZUZpbGUoY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIGNyZWF0ZU9i amVjdChjYWxsYmFja3MsIGFic29sdXRlUGF0aCwgR19GSUxFX1RZUEVfUkVHVUxBUik7Cit9CisK K3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3RvcnkoY29uc3QgU3RyaW5nJiBh YnNvbHV0ZVBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIGNyZWF0ZU9iamVjdChjYWxsYmFja3MsIGFic29s dXRlUGF0aCwgR19GSUxFX1RZUEVfRElSRUNUT1JZKTsKK30KKworc3RhdGljIHZvaWQgb2JqZWN0 RXhpc3RzQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIFN0cmluZyYgcGF0aCwgR0ZpbGVU eXBlIHR5cGUpCit7CisgICAgR1JlZlB0cjxHRmlsZT4gb2JqZWN0ID0gYWRvcHRHUmVmKGdfZmls ZV9uZXdfZm9yX3BhdGgocGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgR1JlZlB0cjxHRmlsZUlu Zm8+IGZpbGVJbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKG9iamVjdC5nZXQoKSwg IioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKCFmaWxlSW5mbykg eworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRf RVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBpZiAoZ19maWxlX2luZm9fZ2V0X2Zp bGVfdHlwZShmaWxlSW5mby5nZXQoKSkgIT0gdHlwZSkgeworICAgICAgICBoZWxwZXJDYWxsYmFj a3MtPmRpZEZhaWwoRmlsZUVycm9yOjpUWVBFX01JU01BVENIX0VSUik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9p ZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmZpbGVFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdElt cGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0Zp bGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51 bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVh ZChjcmVhdGVDYWxsYmFja1Rhc2soJm9iamVjdEV4aXN0c0FzeW5jLCBBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1v ZGUpLCBmaWxlU3lzdGVtUGF0aCwgR19GSUxFX1RZUEVfUkVHVUxBUikpOwogfQogCiB2b2lkIEFz eW5jRmlsZVN5c3RlbUd0azo6ZGlyZWN0b3J5RXhpc3RzKGNvbnN0IFN0cmluZyYgcGF0aCwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJ bXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9G aWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+ dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJl YWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvYmplY3RFeGlzdHNBc3luYywgQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBt b2RlKSwgZmlsZVN5c3RlbVBhdGgsIEdfRklMRV9UWVBFX0RJUkVDVE9SWSkpOworfQorCitzdGF0 aWMgdm9pZCByZWFkRGlyZWN0b3J5QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBjYWxsYmFja3MsIFN0cmluZyYgcGF0 aCkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0cjxHRmlsZT4gZGly ZWN0b3J5RmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHBhdGgudXRmOCgpLmRh dGEoKSkpOworCisgICAgR093blB0cjxHRGlyPiBkaXJlY3RvcnkoZ19kaXJfb3BlbihwYXRoLnV0 ZjgoKS5kYXRhKCksIDAsICZlcnJvci5vdXRQdHIoKSkpOworICAgIGlmICghZXJyb3IpIHsKKyAg ICAgICAgd2hpbGUgKGNvbnN0IGNoYXIqIGRpcmVjdG9yeUVudHJ5ID0gY29uc3RfY2FzdDxjaGFy Kj4oZ19kaXJfcmVhZF9uYW1lKGRpcmVjdG9yeS5nZXQoKSkpKSB7CisgICAgICAgICAgICBHUmVm UHRyPEdGaWxlPiBjaGlsZCA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0X2NoaWxkKGRpcmVjdG9yeUZp bGUuZ2V0KCksIGRpcmVjdG9yeUVudHJ5KSk7CisgICAgICAgICAgICBHUmVmUHRyPEdGaWxlSW5m bz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oY2hpbGQuZ2V0KCksICIq IiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkpOworCisgICAgICAgICAgICBib29sIGlz RW50cnlEaXJlY3RvcnkgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgp KSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlk7CisgICAgICAgICAgICBjYWxsYmFja3MtPmRpZFJl YWREaXJlY3RvcnlFbnRyeShTdHJpbmcoZGlyZWN0b3J5RW50cnkpLCBpc0VudHJ5RGlyZWN0b3J5 KTsKKyAgICAgICAgfQorICAgIH0gZWxzZSB7CisgICAgICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChG aWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg Y2FsbGJhY2tzLT5kaWRSZWFkRGlyZWN0b3J5RW50cmllcyhmYWxzZSk7CiB9CiAKIHZvaWQgQXN5 bmNGaWxlU3lzdGVtR3RrOjpyZWFkRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBs ZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxl U3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5p cXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQo Y3JlYXRlQ2FsbGJhY2tUYXNrKCZyZWFkRGlyZWN0b3J5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9k ZSksIGZpbGVTeXN0ZW1QYXRoKSk7CiB9CiAKK3N0YXRpYyB2b2lkIGNyZWF0ZVdyaXRlckFzeW5j KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBTdHJpbmcm IHBhdGgpCit7CisgICAgR1JlZlB0cjxHRmlsZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3 X2Zvcl9wYXRoKHBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBm aWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhmaWxlLmdldCgpLCAiKiIsIEdf RklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAg ICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOwor ICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgbG9uZyBsb25nIGZpbGVTaXplID0gc3RhdGlj X2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5nZXQoKSkpOwor ICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcihBc3luY0ZpbGVXcml0ZXJH dGs6OmNyZWF0ZShjbGllbnQsIHRhc2tDb250cm9sbGVyLCBmaWxlLmxlYWtSZWYoKSksIGZpbGVT aXplKTsKK30KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcihBc3luY0Zp bGVXcml0ZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1V UkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2Rl KCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVD YWxsYmFja1Rhc2soJmNyZWF0ZVdyaXRlckFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBBbGxv d0Nyb3NzVGhyZWFkQWNjZXNzKGNsaWVudCksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV90YXNr Q29udHJvbGxlci5nZXQoKSksIGZpbGVTeXN0ZW1QYXRoKSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxl U3lzdGVtR3RrOjpjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5n JiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQor eworICAgIC8vIEZJWE1FOiBJcyB0aGlzIGFwaSByZWFsbHkgc2FtZSB3aXRoIHJlYWRNZXRhZGF0 YT8KKyAgICByZWFkTWV0YWRhdGEocGF0aCwgY2FsbGJhY2tzKTsKK30KKwordm9pZCBBc3luY0Zp bGVTeXN0ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKFBhc3NSZWZQdHI8QXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGs+IHRhc2tDb250cm9sbGVyKQoreworICAgIG1fdGFza0NvbnRyb2xs ZXIgPSB0YXNrQ29udHJvbGxlcjsKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbUd0azo6dmly dHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwoY29uc3QgU3RyaW5nJiB2aXJ0dWFsUGF0aCkKK3sKKyAg ICByZXR1cm4gdmlydHVhbFBhdGggIT0gU3RyaW5nKCIvIikgPyBtX2xvY2FsRmlsZVN5c3RlbUJh c2VQYXRoICsgdmlydHVhbFBhdGggOiBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoOworfQorCiti b29sIEFzeW5jRmlsZVN5c3RlbUd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKQorewor ICAgIHJldHVybiBtX3Rhc2tDb250cm9sbGVyLT53YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgp OwogfQogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmgKaW5kZXggY2I0NWI2ZWE0YmMyMDIwZThlYjRj OGViNWExOThmMDc2ZjVhNjk3Yi4uZTYxYzNmNzcwNTNmOTYyMDE2YmNmOWNhZmNlMjU2YmY3YzY5 NjNlZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5 c3RlbUd0ay5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1HdGsuaApAQCAtMjMsMTEgKzIzLDE0IEBACiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogCiAj aW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisKKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CiAjaW5j bHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M7CitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azsKIAogY2xhc3MgQXN5bmNGaWxlU3lzdGVtR3RrIDogcHVibGljIEFzeW5jRmlsZVN5 c3RlbSB7CiBwdWJsaWM6CkBAIC00Niw2ICs0OSwxNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2 b2lkIGRpcmVjdG9yeUV4aXN0cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCB2b2lkIHJlYWREaXJlY3RvcnkoY29u c3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwog ICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVXcml0ZXIoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiwgY29u c3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwor ICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3Qg U3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAg IHZpcnR1YWwgYm9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworCisgICAgdm9pZCBz ZXRUYXNrQ29udHJvbGxlcihQYXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrPik7Citwcml2YXRlOgorICAgIHZvaWQgY3JlYXRlT2JqZWN0KFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiwgY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIEdGaWxlVHlw ZSk7CisgICAgU3RyaW5nIHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGNvbnN0IFN0cmluZyYp OworCisgICAgU3RyaW5nIG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGg7CisgICAgUmVmUHRyPEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOwogfTsKIAog fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uYzhiZGE4ZDM1NzNjMjU5ZmU4NzFlYzFmZDZkOTVlNjkyZWE4MTIxYgotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ay5jcHAKQEAgLTAsMCArMSw5MiBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK KyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQ dWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNz ZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlm IG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUx IEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEg VVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNs dWRlICJOb3RJbXBsZW1lbnRlZC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NSZWZQ dHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9v bCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrKGNvbnRleHQsIHN5bmNocm9ub3VzKSk7Cit9CisKK0FzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBib29sIHN5bmNocm9ub3VzKQorICAg IDogbV9jb250ZXh0KGNvbnRleHQpCisgICAgLCBtX3N5bmNocm9ub3VzKHN5bmNocm9ub3VzKQor ICAgICwgbV9jdXJyZW50VGFza01vZGUoIiIpCisgICAgLCBtX3dyaXRlclRvQ2FuY2VsKDApCit7 CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHll dC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworfQorCitBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0azo6fkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KCkKK3sKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjp1bmlx dWVNb2RlKCkKK3sKKyAgICAvLyBGSVhNRTogV2UgZG9uJ3Qgc3VwcG9ydCB3b2tlcnMgZm9yIGZp bGVzeXN0ZW0geWV0LgorICAgIEFTU0VSVChtX2NvbnRleHQtPmlzRG9jdW1lbnQoKSk7CisgICAg cmV0dXJuIFN0cmluZygpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrOjpwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+IHRhc2spCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJz IGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkp OworICAgIG1fY29udGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJpbmcmIHRh c2tNb2RlKQoreworICAgIG1fY3VycmVudFRhc2tNb2RlID0gdGFza01vZGU7Cit9CisKK3ZvaWQg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBvc3RDYWxsYmFja1Rhc2soUGFzc093 blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1v ZGUpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lz dGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIG1fY29u dGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAgICBBU1NFUlQobV9j b250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFTU0VSVCghbV9zeW5jaHJvbm91cyk7CisgICAg cmV0dXJuIGZhbHNlOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr OjpjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeShBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlcikKK3sK KyAgICBpZiAobV93cml0ZXJUb0NhbmNlbCA9PSB3cml0ZXIpIHsKKyAgICAgICAgbV93cml0ZXJU b0NhbmNlbCA9IDA7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgICByZXR1cm4gZmFs c2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxF X1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNWEwMWM0N2Uw ZGQxZjEzNDk1Y2Q0ZmI1ZjFlMTA0MDY4ZGI2OWQ3MQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5o CkBAIC0wLDAgKzEsNjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9o IDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFz IHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZl cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVy c2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91 dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBG cmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpZm5kZWYg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0a19oCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNs dWRlICJTY3JpcHRFeGVjdXRpb25Db250ZXh0LmgiCisKKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0 ci5oPgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRTYWZlUmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHd0 Zi9UaHJlYWRpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0ZpbGVX cml0ZXJHdGs7CisKK2NsYXNzIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrIDogcHVi bGljIFRocmVhZFNhZmVSZWZDb3VudGVkPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr PiB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs+IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgYm9vbCBzeW5jaHJv bm91cyk7CisgICAgfkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKCk7CisKKyAgICB2 b2lkIHBvc3RUYXNrVG9NYWluVGhyZWFkKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4 dDo6VGFzaz4pOworICAgIHZvaWQgc2V0Q3VycmVudFRhc2tNb2RlKGNvbnN0IFN0cmluZyYpOwor ICAgIHZvaWQgcG9zdENhbGxiYWNrVGFzayhQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+LCBjb25zdCBTdHJpbmcmKTsKKyAgICBib29sIHdhaXRGb3JPcGVyYXRpb25Ub0Nv bXBsZXRlKCk7CisgICAgYm9vbCBzeW5jaHJvbm91cygpIHsgcmV0dXJuIG1fc3luY2hyb25vdXM7 IH0KKworICAgIGJvb2wgY2FuY2VsV3JpdGVySWZOZWNlc3NhcnkoQXN5bmNGaWxlV3JpdGVyR3Rr Kik7CisgICAgdm9pZCBzZXRXcml0ZXJUb0NhbmNlbChBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRl cikgeyBtX3dyaXRlclRvQ2FuY2VsID0gd3JpdGVyOyB9CisKKyAgICBTdHJpbmcgdW5pcXVlTW9k ZSgpOworcHJpdmF0ZToKKyAgICBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayhTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgYm9vbCk7CisKKyAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBtX2NvbnRleHQ7CisgICAgYm9vbCBtX3N5bmNocm9ub3VzOworICAgIFN0cmluZyBtX2N1cnJl bnRUYXNrTW9kZTsKKworICAgIEFzeW5jRmlsZVdyaXRlckd0ayogbV93cml0ZXJUb0NhbmNlbDsK K307CisKK30gLy8gbmFtZXNwYWNlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisK KyNlbmRpZiAvLyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NfaApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi45OGQ0MTJjZTI0OTMwYTM4OTA0Y2MzOWNmNmJjNjI4OGUwMjVlODRhCi0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNs aWVudEd0ay5jcHAKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBD aGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAq IExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVp dGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFu eSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0 aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJ TElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisg KiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAq IFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJh bCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3Jp dGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVudEd0 ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRU YXNrLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworc3RhdGljIHZvaWQgcGVyZm9ybURpZFdy aXRlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVdyaXRlckNsaWVu dCogY2xpZW50LCBsb25nIGxvbmcgYnl0ZXMsIGJvb2wgY29tcGxldGUpCit7CisgICAgY2xpZW50 LT5kaWRXcml0ZShieXRlcywgY29tcGxldGUpOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlk VHJ1bmNhdGVDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlV3JpdGVy Q2xpZW50KiBjbGllbnQpCit7CisgICAgY2xpZW50LT5kaWRUcnVuY2F0ZSgpOworfQorCitzdGF0 aWMgdm9pZCBwZXJmb3JtRGlkRmFpbENhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBB c3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgRmlsZUVycm9yOjpFcnJvckNvZGUgY29kZSkK K3sKKyAgICBjbGllbnQtPmRpZEZhaWwoY29kZSk7Cit9CisKK0FzeW5jRmlsZVdyaXRlckNsaWVu dEd0azo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrKiB0YXNrQ29udHJvbGxlciwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGNv bnN0IFN0cmluZyYgbW9kZSkKKyAgICA6IG1fdGFza0NvbnRyb2xsZXIodGFza0NvbnRyb2xsZXIp CisgICAgLCBtX2NsaWVudChjbGllbnQpCisgICAgLCBtX3Rhc2tNb2RlKG1vZGUpCit7CisgICAg bV90YXNrQ29udHJvbGxlci0+c2V0Q3VycmVudFRhc2tNb2RlKG1fdGFza01vZGUpOworfQorCit2 b2lkIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkV3JpdGUobG9uZyBsb25nIGJ5dGVzLCBi b29sIGNvbXBsZXRlKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2so Y3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkV3JpdGVDYWxsYmFjaywgQWxsb3dDcm9zc1Ro cmVhZEFjY2VzcyhtX2NsaWVudCksIGJ5dGVzLCBjb21wbGV0ZSksIG1fdGFza01vZGUpOworfQor Cit2b2lkIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkVHJ1bmNhdGUoKQoreworICAgIG1f dGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJm b3JtRGlkVHJ1bmNhdGVDYWxsYmFjaywgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2NsaWVudCkp LCBtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZEZh aWwoRmlsZUVycm9yOjpFcnJvckNvZGUgY29kZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5w b3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZEZhaWxDYWxsYmFj aywgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2NsaWVudCksIGNvZGUpLCBtX3Rhc2tNb2RlKTsK K30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lT VEVNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdy aXRlckNsaWVudEd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdy aXRlckNsaWVudEd0ay5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA5ZjlkM2E2YTQ2YTJjZDNmNTQ2ZTViYjM0Y2M4 MTU2MWRmOTNiYjAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgKQEAgLTAsMCArMSw1NyBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9T RS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxp YnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24s IEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAy MTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRlZiBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGtfaAor I2RlZmluZSBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGtfaAorCisjaWYgRU5BQkxFKEZJTEVfU1lT VEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIKKyNp bmNsdWRlICJBc3luY0ZpbGVXcml0ZXJDbGllbnQuaCIKKworI2luY2x1ZGUgPHd0Zi9QYXNzT3du UHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrIDogcHVibGljIEFzeW5jRmlsZVdyaXRlckNsaWVudCB7CitwdWJsaWM6CisgICAgc3Rh dGljIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrPiBjcmVhdGUoQXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBBc3luY0ZpbGVXcml0ZXJD bGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBtb2RlKQorICAgIHsKKyAgICAgICAgcmV0dXJu IGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsodGFza0NvbnRyb2xsZXIsIGNs aWVudCwgbW9kZSkpOworICAgIH0KKworICAgIHZvaWQgZGlkV3JpdGUobG9uZyBsb25nIGJ5dGVz LCBib29sIGNvbXBsZXRlKTsKKyAgICB2b2lkIGRpZFRydW5jYXRlKCk7CisgICAgdm9pZCBkaWRG YWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlKTsKKworICAgIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlcigpIHsgcmV0dXJuIG1fdGFza0NvbnRyb2xsZXIuZ2V0 KCk7IH0KKworcHJpdmF0ZToKKyAgICBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsoQXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqLCBjb25zdCBT dHJpbmcmKTsKKworICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4g bV90YXNrQ29udHJvbGxlcjsKKyAgICBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIG1fY2xpZW50Owor ICAgIFN0cmluZyBtX3Rhc2tNb2RlOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8v IEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0 a19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3Jp dGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJH dGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjdjOGJlZWY1MmUzYjlkNzRmNmZmYzRmMTJhNzQ5MGI4MjBjMWNl ZDgKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNG aWxlV3JpdGVyR3RrLmNwcApAQCAtMCwwICsxLDE1NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAq IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJs aWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRp b24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNI QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUg R05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgor ICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5v dCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZy YW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNB CisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckd0 ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrLmgiCisjaW5jbHVkZSAiQmxvYi5oIgorI2luY2x1ZGUgIkJsb2JSZWdpc3Ry eUltcGwuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2suaCIKKworI2luY2x1ZGUgPGdpby9n aW8uaD4KKyNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5o PgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckd0az4gQXN5bmNGaWxlV3JpdGVyR3RrOjpjcmVh dGUoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgR0ZpbGUqIGZpbGUpCit7CisgICAgcmV0dXJuIGFk b3B0UHRyKG5ldyBBc3luY0ZpbGVXcml0ZXJHdGsoY2xpZW50LCB0YXNrQ29udHJvbGxlciwgZmls ZSkpOworfQorCitBc3luY0ZpbGVXcml0ZXJHdGs6OkFzeW5jRmlsZVdyaXRlckd0ayhBc3luY0Zp bGVXcml0ZXJDbGllbnQqIGNsaWVudCwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsq IHRhc2tDb250cm9sbGVyLCBHRmlsZSogZmlsZSkKKyAgICA6IG1fY2xpZW50KGNsaWVudCkKKyAg ICAsIG1fdGFza0NvbnRyb2xsZXIodGFza0NvbnRyb2xsZXIpCisgICAgLCBtX2ZpbGUoZmlsZSkK K3sKK30KKworc3RhdGljIHZvaWQgd3JpdGVBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs+IGhlbHBlckNsaWVudCwgQXN5bmNG aWxlV3JpdGVyR3RrKiB3cml0ZXIsIEdGaWxlKiBmaWxlLCBsb25nIGxvbmcgcG9zaXRpb24sIEJs b2IqIGRhdGEpCit7CisgICAgaWYgKGhlbHBlckNsaWVudC0+dGFza0NvbnRyb2xsZXIoKS0+Y2Fu Y2VsV3JpdGVySWZOZWNlc3Nhcnkod3JpdGVyKSkgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRp ZEZhaWwoRmlsZUVycm9yOjpBQk9SVF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgR1JlZlB0cjxHRmlsZUlPU3RyZWFtPiBpb1N0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfb3Bl bl9yZWFkd3JpdGUoZmlsZSwgMCwgMCkpOworICAgIGlmICghaW9TdHJlYW0pIHsKKyAgICAgICAg aGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBHT3duUHRyPEdPdXRwdXRTdHJlYW0+IG91dHB1dFN0cmVh bShnX2lvX3N0cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShHX0lPX1NUUkVBTShpb1N0cmVhbS5nZXQo KSkpKTsKKyAgICBpZiAoIWdfc2Vla2FibGVfc2VlayhHX1NFRUtBQkxFKG91dHB1dFN0cmVhbS5n ZXQoKSksIHBvc2l0aW9uLCBHX1NFRUtfU0VULCAwLCAwKSkgeworICAgICAgICBoZWxwZXJDbGll bnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIFJlZlB0cjxCbG9iU3RvcmFnZURhdGE+IGJsb2JTdG9yYWdlID0gc3RhdGlj X2Nhc3Q8QmxvYlJlZ2lzdHJ5SW1wbCY+KGJsb2JSZWdpc3RyeSgpKS5nZXRCbG9iRGF0YUZyb21V UkwoZGF0YS0+dXJsKCkpOworICAgIGlmIChibG9iU3RvcmFnZSkgeworICAgICAgICBmb3IgKHNp emVfdCBpID0gMDsgaSA8IGJsb2JTdG9yYWdlLT5pdGVtcygpLnNpemUoKTsgaSsrKSB7CisgICAg ICAgICAgICBjb25zdCBCbG9iRGF0YUl0ZW0mIGJsb2JJdGVtID0gYmxvYlN0b3JhZ2UtPml0ZW1z KClbaV07CisgICAgICAgICAgICBpZiAoYmxvYkl0ZW0udHlwZSA9PSBCbG9iRGF0YUl0ZW06OkRh dGEpIHsKKyAgICAgICAgICAgICAgICBnc2l6ZSBieXRlc1dyaXR0ZW4gPSAwOworICAgICAgICAg ICAgICAgIGdfb3V0cHV0X3N0cmVhbV93cml0ZV9hbGwoR19PVVRQVVRfU1RSRUFNKG91dHB1dFN0 cmVhbS5nZXQoKSksIGJsb2JJdGVtLmRhdGEtPmRhdGEoKSwgYmxvYkl0ZW0uZGF0YS0+bGVuZ3Ro KCksICZieXRlc1dyaXR0ZW4sIDAsIDApOworCisgICAgICAgICAgICAgICAgYm9vbCBjb21wbGV0 ZWQgPSBibG9iU3RvcmFnZS0+aXRlbXMoKS5zaXplKCkgPT0gKGkgKyAxKTsKKyAgICAgICAgICAg ICAgICBoZWxwZXJDbGllbnQtPmRpZFdyaXRlKGJ5dGVzV3JpdHRlbiwgY29tcGxldGVkKTsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJH dGs6OndyaXRlKGxvbmcgbG9uZyBwb3NpdGlvbiwgQmxvYiogZGF0YSkKK3sKKyAgICBTdHJpbmcg bW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRy b2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmd3JpdGVBc3lu YywgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQo KSwgbV9jbGllbnQsIG1vZGUpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKHRoaXMpLCBBbGxvd0Ny b3NzVGhyZWFkQWNjZXNzKG1fZmlsZS5nZXQoKSksIHBvc2l0aW9uLCBBbGxvd0Nyb3NzVGhyZWFk QWNjZXNzKGRhdGEpKSk7Cit9CisKK3N0YXRpYyB2b2lkIHRydW5jYXRlQXN5bmMoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrPiBoZWxw ZXJDbGllbnQsIEFzeW5jRmlsZVdyaXRlckd0ayogd3JpdGVyLCBHRmlsZSogZmlsZSwgbG9uZyBs b25nIGxlbmd0aCkKK3sKKyAgICBpZiAoaGVscGVyQ2xpZW50LT50YXNrQ29udHJvbGxlcigpLT5j YW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSh3cml0ZXIpKSB7CisgICAgICAgIGhlbHBlckNsaWVudC0+ ZGlkRmFpbChGaWxlRXJyb3I6OkFCT1JUX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5 X2luZm8oZmlsZSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYg KCFmaWxlSW5mbykgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpO T1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGxvbmcgbG9uZyBm aWxlTGVuZ3RoID0gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShm aWxlSW5mby5nZXQoKSkpOworICAgIGlmIChsZW5ndGggPiBmaWxlTGVuZ3RoKSB7CisgICAgICAg IEdPd25QdHI8R1N0cmluZz4gemVyb1BhZGRpbmcoZ19zdHJpbmdfbmV3X2xlbigwLCBsZW5ndGgg LSBmaWxlTGVuZ3RoKSk7CisgICAgICAgIGRvIHsKKyAgICAgICAgICAgIGdfc3RyaW5nX2FwcGVu ZF9jKHplcm9QYWRkaW5nLmdldCgpLCAnXDAnKTsKKyAgICAgICAgfSB3aGlsZSAoLS1sZW5ndGgg PiBmaWxlTGVuZ3RoKTsKKworICAgICAgICBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IGlvU3RyZWFt ID0gYWRvcHRHUmVmKGdfZmlsZV9vcGVuX3JlYWR3cml0ZShmaWxlLCAwLCAwKSk7CisgICAgICAg IGlmICghaW9TdHJlYW0pIHsKKyAgICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxl RXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisK KyAgICAgICAgR093blB0cjxHT3V0cHV0U3RyZWFtPiBvdXRwdXRTdHJlYW0oZ19pb19zdHJlYW1f Z2V0X291dHB1dF9zdHJlYW0oR19JT19TVFJFQU0oaW9TdHJlYW0uZ2V0KCkpKSk7CisgICAgICAg IGlmICghZ19zZWVrYWJsZV9zZWVrKEdfU0VFS0FCTEUob3V0cHV0U3RyZWFtLmdldCgpKSwgbGVu Z3RoLCBHX1NFRUtfU0VULCAwLCAwKSkgeworICAgICAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRG YWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIH0KKworICAgICAgICBnc2l6ZSBieXRlc1dyaXR0ZW4gPSAwOworICAgICAgICBnX291dHB1 dF9zdHJlYW1fd3JpdGVfYWxsKEdfT1VUUFVUX1NUUkVBTShvdXRwdXRTdHJlYW0uZ2V0KCkpLCB6 ZXJvUGFkZGluZy0+c3RyLCB6ZXJvUGFkZGluZy0+bGVuLCAmYnl0ZXNXcml0dGVuLCAwLCAwKTsK KyAgICB9IGVsc2UgeworICAgICAgICBHUmVmUHRyPEdGaWxlT3V0cHV0U3RyZWFtPiBmaWxlT3V0 cHV0U3RyZWFtID0gYWRvcHRHUmVmKGdfZmlsZV9yZXBsYWNlKGZpbGUsIDAsIGZhbHNlLCBHX0ZJ TEVfQ1JFQVRFX05PTkUsIDAsIDApKTsKKyAgICAgICAgaWYgKCFmaWxlT3V0cHV0U3RyZWFtIHx8 ICFnX3NlZWthYmxlX3RydW5jYXRlKEdfU0VFS0FCTEUoZmlsZU91dHB1dFN0cmVhbS5nZXQoKSks IGxlbmd0aCwgMCwgMCkpIHsKKyAgICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxl RXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9Cisg ICAgfQorCisgICAgaGVscGVyQ2xpZW50LT5kaWRUcnVuY2F0ZSgpOworfQorCit2b2lkIEFzeW5j RmlsZVdyaXRlckd0azo6dHJ1bmNhdGUobG9uZyBsb25nIGxlbmd0aCkKK3sKKyAgICBTdHJpbmcg bW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRy b2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmdHJ1bmNhdGVB c3luYywgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5n ZXQoKSwgbV9jbGllbnQsIG1vZGUpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKHRoaXMpLCBBbGxv d0Nyb3NzVGhyZWFkQWNjZXNzKG1fZmlsZS5nZXQoKSksIGxlbmd0aCkpOworfQorCit2b2lkIEFz eW5jRmlsZVdyaXRlckd0azo6YWJvcnQoKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnNldFdy aXRlclRvQ2FuY2VsKHRoaXMpOworfQorCitib29sIEFzeW5jRmlsZVdyaXRlckd0azo6d2FpdEZv ck9wZXJhdGlvblRvQ29tcGxldGUoKQoreworICAgIHJldHVybiBtX3Rhc2tDb250cm9sbGVyLT5z eW5jaHJvbm91cygpID8gbV90YXNrQ29udHJvbGxlci0+d2FpdEZvck9wZXJhdGlvblRvQ29tcGxl dGUoKSA6IGZhbHNlOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBF TkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvQXN5bmNGaWxlV3JpdGVyR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlV3JpdGVyR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2ZhMjJhZjZkMTczODFmZGM0Y2RhN2Q2NmJk ZTUxYzJhOTU4MWZiMQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaApAQCAtMCwwICsxLDU3IEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFu ZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5l cmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor ICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFy eTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAt MTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVdyaXRlckd0a19oCisjZGVmaW5lIEFz eW5jRmlsZVdyaXRlckd0a19oCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRl ICJBc3luY0ZpbGVXcml0ZXIuaCIKKworI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisjaW5j bHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2Ns YXNzIEFzeW5jRmlsZVdyaXRlckNsaWVudDsKK2NsYXNzIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVXcml0ZXJHdGsgOiBwdWJsaWMgQXN5bmNGaWxl V3JpdGVyIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJH dGs+IGNyZWF0ZShBc3luY0ZpbGVXcml0ZXJDbGllbnQqLCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0ayosIEdGaWxlKik7CisKKyAgICB2b2lkIGFib3J0KCk7CisgICAgdm9pZCB0cnVu Y2F0ZShsb25nIGxvbmcgbGVuZ3RoKTsKKyAgICB2b2lkIHdyaXRlKGxvbmcgbG9uZyBwb3NpdGlv biwgQmxvYiogZGF0YSk7CisKKyAgICBib29sIHdhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCk7 CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlV3JpdGVyR3RrKEFzeW5jRmlsZVdyaXRlckNsaWVu dCosIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgR0ZpbGUqKTsKKworICAgIEFz eW5jRmlsZVdyaXRlckNsaWVudCogbV9jbGllbnQ7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIEdSZWZQdHI8R0ZpbGU+ IG1fZmlsZTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJM RShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVdyaXRlckd0a19oCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxlU3lzdGVtR3RrLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbEZpbGVTeXN0ZW1HdGsuY3BwCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjBjOTQwMWM3MGJmOTk0NzI5ZGQzMGNlYTczNzk4ZWMxZGVkZmQ3OTQKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxlU3lzdGVtR3Rr LmNwcApAQCAtMCwwICsxLDU4IEBACisvKgorICogIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nl b2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiAgbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExp Y2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl cgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkg bGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQor ICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgor ICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2Vu ZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3Qs IHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiAgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgor CisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSA8Z3RrL2d0ay5oPgorI2luY2x1 ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HT3duUHRyLmg+Cisj aW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJp bmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6aW5p dGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQoreworICAgIEdP d25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9yeShnX2Rpcl9v cGVuKGJhc2VQYXRoLnV0ZjgoKS5kYXRhKCksIDAsICZlcnJvci5vdXRQdHIoKSkpOworICAgIGlm IChlcnJvciAmJiBlcnJvci0+Y29kZSA9PSBHX0ZJTEVfRVJST1JfTk9FTlQpIHsKKyAgICAgICAg R1JlZlB0cjxHRmlsZT4gYmFzZURpcmVjdG9yeUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19m b3JfcGF0aChiYXNlUGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgICAgIGdfZmlsZV9tYWtlX2Rp cmVjdG9yeShiYXNlRGlyZWN0b3J5RmlsZS5nZXQoKSwgMCwgMCk7CisgICAgfQorfQorCitMb2Nh bEZpbGVTeXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICBX VEY6OmxvY2tBdG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWNNdXRleCgpOworICAgIGlmICghc19p bnN0YW5jZSkgeworICAgICAgICBHT3duUHRyPGdjaGFyPiBiYXNlUGF0aChnX2J1aWxkX2ZpbGVu YW1lKGdfZ2V0X3VzZXJfZGF0YV9kaXIoKSwgIndlYmtpdCIsICJmaWxlc3lzdGVtIiwgTlVMTCkp OworICAgICAgICBPd25QdHI8TG9jYWxGaWxlU3lzdGVtPiBsb2NhbEZpbGVTeXN0ZW0gPSBhZG9w dFB0cihuZXcgTG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoLmdldCgpKSk7CisgICAgICAgIGxvY2Fs RmlsZVN5c3RlbS0+aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShTdHJpbmcoYmFzZVBhdGguZ2V0 KCkpKTsKKworICAgICAgICBzX2luc3RhbmNlID0gbG9jYWxGaWxlU3lzdGVtLmxlYWtQdHIoKTsK KyAgICB9CisgICAgV1RGOjp1bmxvY2tBdG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWNNdXRleCgp OworICAgIHJldHVybiAqc19pbnN0YW5jZTsKK30KKworfQorCisjZW5kaWYgLy8gRU5BQkxFKEZJ TEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nCmluZGV4IGI3ZjY2MDkyNWMwODYzZWVmYmU5MGZjYjMyZWNmMTMxMjgyMGU0 MWEuLjczN2YwY2JiOTMyM2RmNGU2MGFlYzU5ZjNhMTgwMDVlNDE1NzZiNmUgMTAwNjQ0Ci0tLSBh L0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMiBAQAorMjAxMi0wNC0wNCAgQ2hhbmdTZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5j b20+CisKKyAgICAgICAgW0dUS10gU3VwcG9ydCB0aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01ODQ0MworCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFsbCBtb3N0IHRlc3RzIGlu IGZhc3QvZmlsZXN5c3RlbSBhcmUgcGFzc2VkIGV4Y2VwdCB0aGUgb25lcyByZWxhdGVkIHdpdGgg d29ya2VyLgorICAgICAgICBGb2xsb3dpbmcgdGVzdHMgYXJlIHBhc3NlZCBpbiBkZXRhaWwuCisg ICAgICAgIGZhc3QvZmlsZXN5c3RlbS8qLmh0bWwKKyAgICAgICAgZmFzdC9tdXRhdGlvbi9maWxl c3lzdGVtLWNhbGxiYWNrLWRlbGl2ZXJ5Lmh0bWwKKyAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2Nr ZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi5odG1sCisgICAgICAgIGh0dHAvdGVzdHMvd2Vi c29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2ItZmFpbC5odG1sCisKKyAgICAgICAgQnV0 IEZpbGVTeXN0ZW0gQVBJIGlzIG5vdCB0aGUgZGVmYXVsdCBlbmFibGVkIGZlYXR1cmUgYW5kIHVu Y29tcGxldGVkLAorICAgICAgICBzbyB3ZSBuZWVkIHRvIGtlZXAgdGhlbSBza2lwcGVkLgorCisg ICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBwZWQ6CisKIDIwMTItMDQtMDMgIFBoaWxpcHBlIE5v cm1hbmQgIDxwbm9ybWFuZEBpZ2FsaWEuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIEdUSyBn YXJkZW5pbmcKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkIGIv TGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKaW5kZXggODYyZTZkNDk1OTkxZWY3NzQ2 MTRhYTA2NGY3YTk5NzkyYWYxYjAwNC4uY2FhYjdhMmRiNmY1MjIwODBhMjVlM2U1MmVjNTE0NDVh NGMwY2IyMyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKKysr IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKQEAgLTI5OSwxNSArMjk5LDIyIEBA IGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmctc2xvdy1sb2FkLnBocAogaHR0cC90ZXN0cy9taXNj L3dlYnRpbWluZy1zc2wucGhwCiBodHRwL3Rlc3RzL21pc2Mvd2VidGltaW5nLXR3by1yZWRpcmVj dHMucGhwCiAKLSMgRmlsZVN5c3RlbSBBUEkgaXMgbm90IHN1cHBvcnRlZC4KKyMgRm9sbG93aW5n IHRlc3RzIGFyZSBwYXNzZWQsIGlmIEZpbGVTeXN0ZW0gQVBJIGZlYXR1cmUgaXMgZW5hYmxlZC4K IGZhc3QvZmlsZXN5c3RlbQotaHR0cC90ZXN0cy9maWxlc3lzdGVtCi1odHRwL3Rlc3RzL3NlY3Vy aXR5L2ZpbGVzeXN0ZW0taWZyYW1lLWZyb20tcmVtb3RlLmh0bWwKIGh0dHAvdGVzdHMvd2Vic29j a2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2IuaHRtbAogaHR0cC90ZXN0cy93ZWJzb2NrZXQv dGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi1mYWlsLmh0bWwKLWh0dHAvdGVzdHMvd29ya2Vycy90 ZXJtaW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0aW9uLmh0bWwKKyMgUGFzc2VkIGJ1dCB3ZSBzaG91 bGQgZW5hYmxlIGZpbGUtc3lzdGVtICYgbXV0YXRpb24tb2JzZXJ2ZXJzIGF0IHRoZSBzYW1lIHRp bWUuCiBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRtbAogCisj IEZpbGVTeXN0ZW0gQVBJIGlzIG5vdCBzdXBwb3J0ZWQgY29tcGxldGVseS4KKyMgaHR0cDovL3dl YmtpdC5vcmcvYi84MzEzNworZmFzdC9maWxlc3lzdGVtL2ZsYWdzLXBhc3NpbmcuaHRtbAorIyBX ZSBkb24ndCBzdXBwb3J0IHdvcmtlcnMgZm9yIEZpbGVTeXN0ZW0geWV0LiBodHRwOi8vd2Via2l0 Lm9yZy9iLzgyODU0CitmYXN0L2ZpbGVzeXN0ZW0vd29ya2VycworaHR0cC90ZXN0cy9maWxlc3lz dGVtCitodHRwL3Rlc3RzL3NlY3VyaXR5L2ZpbGVzeXN0ZW0taWZyYW1lLWZyb20tcmVtb3RlLmh0 bWwKK2h0dHAvdGVzdHMvd29ya2Vycy90ZXJtaW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0aW9uLmh0 bWwKKwogIyBSZXF1aXJlcyBXZWJQIHN1cHBvcnQuCiBmYXN0L2NhbnZhcy9jYW52YXMtdG9EYXRh VVJMLXdlYnAuaHRtbAogZmFzdC9pbWFnZXMvd2VicC1pbWFnZS1kZWNvZGluZy5odG1sCg== 135620 2012-04-04 10:23:13 -0700 2012-04-05 03:15:04 -0700 Patch bug-58443-20120405022311.patch text/plain 72301 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzMjAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGZkNDhmNzViMzRmYTQxNDIxN2RjNTBm MDM0ZGYxOTE1ODYyNDQ0MWQuLjMyNWNiNmU5OGM1MDhkN2I2ZTQ0MmQ1YjhhZWVmYzg1ZGM4YzBk YWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMDQgIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDogQWRkZWQgdHlwZSBkZWZpbml0aW9ucywgR0ZpbGVJT1N0cmVh bSwgR091dHB1dFN0cmVhbSwgR1N0cmluZy4KKwogMjAxMi0wMy0zMCAgRGF2aWQgQmFyciAgPGRh dmlkYmFyckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgU3BsaXQgdXAgdG9wLWxldmVsIC5naXRp Z25vcmUgYW5kIC5naXRhdHRyaWJ1dGVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWZjM2VlZDk1NmI1ZGNhMmJh NzIzNmU3NzIwMjIwNTNlNjY5NzM4My4uY2E0MGE5ZmM2ZTE5Mjg4MmMwNzNkNWZkNTcxYzM5Mjc5 Zjg1YTg5NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzOCBAQAorMjAxMi0wNC0wNCAgQ2hhbmdT ZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAgICAgICAgW0dUS10gU3VwcG9ydCB0 aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFRoaXMgcGF0Y2ggaXMgYmFzZWQgb24gWmFuIERvYmVyc2VrJ3Mgb3JpZ2luYWwg b25lIGZvciBidWc1ODQ0My4KKyAgICAgICAgVGhpcyBicmluZ3MgRmlsZVN5c3RlbSBBUEkgdG8g Z3RrIHBvcnQuIFRoaXMgYWRkcyBuZXcgaW50ZXJmYWNlcyBsaWtlCisgICAgICAgIEFzeW5jRmls ZVN5c3RlbUd0aywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLCBBc3luY0ZpbGVXcml0ZXJH dGssIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0aworICAgICAgICBhbmQgQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsuIFRoZXNlIGFyZSBjaGlsZCBjbGFzc2VzIGltcGxlbWVudGluZyB0 aGUgaW50ZXJmYWNlcworICAgICAgICBvZiBlYWNoIHBhcmVudCBjbGFzc2VzIGV4Y2VwdCBBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay4gQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsKKyAgICAgICAgaXMgYSBoZWxwZXIgY2xhc3MuIEl0IHJldGFpbnMgc29tZSB1c2VmdWwg dmFyaWFibGVzLCBhbmQgY29udHJvbHMgcG9zdGluZyB0YXNrcyB0bworICAgICAgICBTY3JpcHRF eGVjdXRpb25Db250ZXh0IHdoaWNoIG1pZ2h0IGJlIGVpdGhlciBhIERvY3VtZW50IG9iamVjdCBv ciBhIFdvcmtlci4KKyAgICAgICAgVW5mb3J0dW5hdGVseSwgV29ya2VyIGZvciBmaWxlc3lzdGVt IGlzIG5vdCBzdXBwb3J0ZWQgeWV0LCBJIHBsYW4gdG8gc3VwcG9ydCBpdCBpbiB0aGUgbmV4dCBw YXRjaC4KKworICAgICAgICBUZXN0OiBmYXN0L2ZpbGVzeXN0ZW0vKi5odG1sCisgICAgICAgICAg ICAgIGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5odG1sCisgICAg ICAgICAgICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2Iu aHRtbAorICAgICAgICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQt ZmlsZS1ibG9iLWZhaWwuaHRtbAorCisgICAgICAgICogR05VbWFrZWZpbGUubGlzdC5hbTogQWRk ZWQgc29tZSBmaWxlcyB0byBidWlsZCBuZXdseSBmb3IgRmlsZVN5c3RlbS4KKyAgICAgICAgKiBN b2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmUp OgorICAgICAgICAoV2ViQ29yZTo6b3BlbkZpbGVTeXN0ZW0pOiBDcmVhdGVkIEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0ayBpbnN0ZWFkIG9mIHVzaW5nIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cyBpdHNlbGYuCisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlYWRGaWxlU3lz dGVtKTogQWRkZWQgbWlzc2luZyBhcmd1bWVudCBuYW1lLgorICAgICAgICAoV2ViQ29yZTo6TG9j YWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6IEFkZGVkIG1pc3NpbmcgYXJndW1lbnQg bmFtZS4KKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr LmNwcDogQWRkZWQuIFRoaXMgaXMgYW4gaW1wbGVtZW50YXRpb24gb2YgQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjo6OmNvcHkp OgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUp OgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGspOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFN1Y2Nl ZWRDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmRpZFN1Y2NlZWQpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZE9wZW5GaWxlU3lz dGVtQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrOjpkaWRPcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkUmVh ZE1ldGFkYXRhQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrOjpkaWRSZWFkTWV0YWRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cnkpOgorICAgICAgICAoV2Vi Q29yZTo6cGVyZm9ybURpZFJlYWREaXJlY3RvcnlFbnRyaWVzQW5kRmluaXNoZWRDYWxsYmFjayk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWRE aXJlY3RvcnlFbnRyaWVzKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRDcmVhdGVGaWxl V3JpdGVyQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrOjpkaWRDcmVhdGVGaWxlV3JpdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1E aWRGYWlsQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrOjpkaWRGYWlsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGspOgorICAgICAgICAoRGlyZWN0b3J5RW50cnkpOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpEaXJlY3RvcnlFbnRy eTo6RGlyZWN0b3J5RW50cnkpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1HdGsuY3BwOiBBZGRlZCBzb21lIG1pc3NpbmcgQVBJcy4gVGhpcyBpcyBhIGNoaWxkIGNsYXNz IG9mIEFzeW5jRmlsZVN5c3RlbS4KKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6 aXNBdmFpbGFibGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc1ZhbGlk VHlwZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVt KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6QXN5bmNGaWxlU3lzdGVt R3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6fkFzeW5jRmlsZVN5 c3RlbUd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnRvVVJMKToK KyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6bW92ZUFzeW5jKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6bW92ZSk6CisgICAgICAgIChXZWJDb3Jl Ojpjb3B5UmVjdXJzaXZlbHkpOgorICAgICAgICAoV2ViQ29yZTo6Y29weUFzeW5jKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y29weSk6CisgICAgICAgIChXZWJDb3Jl OjpyZW1vdmVGaWxlKToKKyAgICAgICAgKFdlYkNvcmU6OnJlbW92ZUFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVjdXJzaXZlbHkpOgorICAgICAgICAoV2ViQ29y ZTo6cmVhZE1ldGFkYXRhQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVt R3RrOjpyZWFkTWV0YWRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlT2JqZWN0QXN5bmMp OgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVPYmplY3QpOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVGaWxlKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGlyZWN0b3J5KToKKyAgICAg ICAgKFdlYkNvcmU6Om9iamVjdEV4aXN0c0FzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVN5c3RlbUd0azo6ZmlsZUV4aXN0cyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1HdGs6OmRpcmVjdG9yeUV4aXN0cyk6CisgICAgICAgIChXZWJDb3JlOjpyZWFkRGlyZWN0 b3J5QXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFkRGly ZWN0b3J5KToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZVdyaXRlckFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlV3JpdGVyKToKKyAgICAgICAgKFdl YkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlU25hcHNob3RGaWxlQW5kUmVhZE1ldGFk YXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6c2V0VGFza0NvbnRy b2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp2aXJ0dWFsUGF0 aFRvRmlsZVN5c3RlbVVSTCk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6 OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtR3RrLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmls ZVN5c3RlbUd0ayk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrLmNwcDogQWRkZWQuIFRoaXMgaXMgYSBoZWxwZXIgY2xhc3MgdG8gY29udHJv bCBwb3N0aW5nIHRhc2sgdG8gYSB0YXJnZXQgdGhyZWFkLgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6Y3JlYXRl KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6fkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrOjp1bmlxdWVNb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjpwb3N0VGFza1RvTWFpblRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6c2V0Q3VycmVudFRhc2tNb2RlKToKKyAg ICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpwb3N0Q2Fs bGJhY2tUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6Y2FuY2VsV3JpdGVySWZOZWNlc3Nhcnkp OgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGs6OnN5bmNocm9ub3VzKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzZXRXcml0ZXJUb0NhbmNlbCk6CisgICAgICAgICog cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHA6IEFkZGVkLiBUaGlzIGlz IGEgY2hpbGQgY2xhc3MgaW1wbGVtZW50IG9mIEF5c25jRmlsZVdyaXRlckNsaWVudC4KKyAgICAg ICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFdyaXRlQ2FsbGJhY2sp OgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6cGVyZm9ybURpZEZhaWxDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFdyaXRlKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkVHJ1bmNhdGUpOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRGYWlsKToKKyAgICAg ICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmg6IEFkZGVkLgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGspOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpjcmVhdGUpOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjp0YXNrQ29udHJvbGxlcik6Cisg ICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHA6IEFkZGVkLiBUaGlz IGlzIGEgY2hpbGQgY2xhc3Mgb2YgQXN5bmNGaWxlV3JpdGVyLgorICAgICAgICAoV2ViQ29yZSk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OmNyZWF0ZSk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OkFzeW5jRmlsZVdyaXRlckd0ayk6CisgICAg ICAgIChXZWJDb3JlOjp3cml0ZUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdy aXRlckd0azo6d3JpdGUpOgorICAgICAgICAoV2ViQ29yZTo6dHJ1bmNhdGVBc3luYyk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OnRydW5jYXRlKToKKyAgICAgICAgKFdl YkNvcmU6OkFzeW5jRmlsZVdyaXRlckd0azo6YWJvcnQpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlV3JpdGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSk6CisgICAgICAgICog cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoQXN5bmNGaWxlV3JpdGVyR3RrKToKKyAgICAgICAgKiBwbGF0Zm9ybS9n dGsvTG9jYWxGaWxlU3lzdGVtR3RrLmNwcDogQWRkZWQuIFNvbWUgcG9ydCBzcGVjaWZpYyBmdW5j dGlvbnMgYXJlIGV4dHJhY3RlZCBmcm9tIExvY2FsRmlsZVN5c3RlbS5jcHAgYW5kIGFkZGVkIGlu IGhlcmUuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5 c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpMb2Nh bEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSk6CisKIDIwMTItMDQtMDQgIFBhdmVsIEZlbGRt YW4gIDxwZmVsZG1hbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogZXhw b3NlIHNhdmVkVVJMLCBzZXRUb29sYmFyQ29sb3JzIGFuZCB0b2dnbGVTZWFyY2hpbmdGb3JOb2Rl IGluIEluc3BlY3RvckZyb250ZW5kQVBJCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nb2Jq ZWN0L0dPd25QdHIuY3BwIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmNwcAppbmRl eCBkZmUxODdkNzg4N2ZmNTRlYTAyN2MxYzlkYzVjMDZiZDdiZGI1Y2YxLi4zYWEwNzU5OTQ3NmQ3 NGUyMmZkZjRlN2NkMGU4NTc3YTI4MTU5MmI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9n b2JqZWN0L0dPd25QdHIuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5j cHAKQEAgLTQyLDYgKzQyLDE2IEBAIHRlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0cjxHU0xp c3Q+KEdTTGlzdCogcHRyKQogICAgIGdfc2xpc3RfZnJlZShwdHIpOwogfQogCit0ZW1wbGF0ZSA8 PiB2b2lkIGZyZWVPd25lZEdQdHI8R1N0cmluZz4oR1N0cmluZyogcHRyKQoreworICAgIGdfc3Ry aW5nX2ZyZWUocHRyLCB0cnVlKTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRy PEdPdXRwdXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qIHB0cikKK3sKKyAgICBnX291dHB1dF9zdHJl YW1fY2xvc2UocHRyLCAwLCAwKTsKK30KKwogdGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRy PEdQYXR0ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKiBwdHIpCiB7CiAgICAgaWYgKHB0cikKZGlmZiAt LWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oIGIvU291cmNlL1dURi93dGYv Z29iamVjdC9HT3duUHRyLmgKaW5kZXggNGIyZGNiNzdiMjUwMDBjMmU1YjY4MDhhNGM3NDg0YzJi ZTZkNmNhNS4uOWMwNjdkNzFhNjc5NTVjYzRiZjhkOGZjOGRkZjIwZDliMjJhMWM3MSAxMDA2NDQK LS0tIGEvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKKysrIGIvU291cmNlL1dURi93 dGYvZ29iamVjdC9HT3duUHRyLmgKQEAgLTM2LDYgKzM2LDggQEAgdGVtcGxhdGUgPHR5cGVuYW1l IFQ+IGlubGluZSB2b2lkIGZyZWVPd25lZEdQdHIoVCogcHRyKTsKIHRlbXBsYXRlPD4gdm9pZCBm cmVlT3duZWRHUHRyPEdFcnJvcj4oR0Vycm9yKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVk R1B0cjxHTGlzdD4oR0xpc3QqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdTTGlz dD4oR1NMaXN0Kik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHU3RyaW5nPihHU3Ry aW5nKik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHT3V0cHV0U3RyZWFtPihHT3V0 cHV0U3RyZWFtKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHUGF0dGVyblNwZWM+ KEdQYXR0ZXJuU3BlYyopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R0Rpcj4oR0Rp ciopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1RpbWVyPihHVGltZXIqKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmggYi9Tb3VyY2UvV1RG L3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5oCmluZGV4IGUyOTI1MGJlZjJlZjRkNWU5ZWJlNWMyYjA1 MDM3M2JiYTg1NjRmOWEuLjdhNWU5ZjNjYTA3ZGE1NWU1NjhjNTcxZDRlNWJjOWY4NTQ1ZWI1MjIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmgKKysrIGIvU291 cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaApAQCAtNDgsMTcgKzQ4LDIwIEBAIHR5cGVk ZWYgc3RydWN0IF9HZGtFdmVudEV4cG9zZSBHZGtFdmVudEV4cG9zZTsKIHR5cGVkZWYgc3RydWN0 IF9HZGtQaXhidWYgR2RrUGl4YnVmOwogdHlwZWRlZiBzdHJ1Y3QgX0dFcnJvciBHRXJyb3I7CiB0 eXBlZGVmIHN0cnVjdCBfR0ZpbGUgR0ZpbGU7Cit0eXBlZGVmIHN0cnVjdCBfR0ZpbGVJT1N0cmVh bSBHRmlsZUlPU3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dIYXNoVGFibGUgR0hhc2hUYWJsZTsK IHR5cGVkZWYgc3RydWN0IF9HSW5wdXRTdHJlYW0gR0lucHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1 Y3QgX0dMaXN0IEdMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluQ29udGV4dCBHTWFpbkNvbnRl eHQ7CiB0eXBlZGVmIHN0cnVjdCBfR01haW5Mb29wIEdNYWluTG9vcDsKK3R5cGVkZWYgc3RydWN0 IF9HT3V0cHV0U3RyZWFtIEdPdXRwdXRTdHJlYW07CiB0eXBlZGVmIHN0cnVjdCBfR1BhdHRlcm5T cGVjIEdQYXR0ZXJuU3BlYzsKIHR5cGVkZWYgc3RydWN0IF9HUG9sbGFibGVPdXRwdXRTdHJlYW0g R1BvbGxhYmxlT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dTTGlzdCBHU0xpc3Q7CiB0 eXBlZGVmIHN0cnVjdCBfR1NvY2tldENsaWVudCBHU29ja2V0Q2xpZW50OwogdHlwZWRlZiBzdHJ1 Y3QgX0dTb2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25uZWN0aW9uOwogdHlwZWRlZiBzdHJ1Y3Qg X0dTb3VyY2UgR1NvdXJjZTsKK3R5cGVkZWYgc3RydWN0IF9HU3RyaW5nIEdTdHJpbmc7CiB0eXBl ZGVmIHN0cnVjdCBfR1ZhcmlhbnQgR1ZhcmlhbnQ7CiB0eXBlZGVmIHVuaW9uIF9HZGtFdmVudCBH ZGtFdmVudDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIgR1RpbWVyOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2Vm aWxlLmxpc3QuYW0KaW5kZXggMTJmNTJjZWM0ZTZkMzc2ZDkxMDFkNDBhNmIwYmViZjUxOGM3MmQ4 YS4uY2U1Yzk1NTkzMmIxMjcwODIyYzYyMGZkNDJmNDBjMjgwNmE0MjFjMyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9H TlVtYWtlZmlsZS5saXN0LmFtCkBAIC00NjgxLDYgKzQ2ODEsNyBAQCB3ZWJjb3JlZ3RrX3NvdXJj ZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HdGtWZXJzaW9uaW5nLmggXAog CVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9LZXlCaW5kaW5nVHJhbnNsYXRvci5jcHAgXAog CVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9LZXlCaW5kaW5nVHJhbnNsYXRvci5oIFwKKwlT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxlU3lzdGVtR3RrLmNwcCBcCiAJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2FsaXplZFN0cmluZ3NHdGsuY3BwIFwKIAlTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTWFpbkZyYW1lU2Nyb2xsYmFyR3RrLmNwcCBcCiAJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL01haW5GcmFtZVNjcm9sbGJhckd0ay5oIFwKQEAgLTQ5 NzQsOCArNDk3NSwxNiBAQCBkb21fYmluZGluZ19pZGxzICs9IFwKIAkkKFdlYkNvcmUpL01vZHVs ZXMvZmlsZXN5c3RlbS9Xb3JrZXJDb250ZXh0RmlsZVN5c3RlbS5pZGwKIAogd2ViY29yZWd0a19z b3VyY2VzICs9IFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0ay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtR3RrLmNwcCBcCi0JU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbUd0ay5oCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5 c3RlbUd0ay5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCBcCisJU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaAogZW5kaWYgIyBFTkQgRU5BQkxFX0ZJTEVf U1lTVEVNCiAKICMgLS0tLQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxl c3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVz eXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA4ZjAxNjllZWFiYmE5M2ZmNGYxNTZkN2My MzQ3YjZjMGIyN2Q1YmJhLi5hMWI2Y2FhYmQ4NmEzN2I5NjU0MGVmNmU2NzQ1ZTZhODQ4NDYyYTJh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxl U3lzdGVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxG aWxlU3lzdGVtLmNwcApAQCAtNDksMTAgKzQ5LDE1IEBACiAjaW5jbHVkZSA8d3RmL01haW5UaHJl YWQuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogCisjaWYgUExBVEZPUk0oR1RLKQor I2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorI2VuZGlmCisKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogTG9jYWxGaWxlU3lzdGVtKiBMb2NhbEZpbGVTeXN0ZW06OnNfaW5z dGFuY2UgPSAwOwogCisjaWYgIVBMQVRGT1JNKEdUSykKIHZvaWQgTG9jYWxGaWxlU3lzdGVtOjpp bml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCiB7CiAgICAg Ly8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5ncyBhcyB3ZWxsLgpA QCAtNzEsMjcgKzc2LDMyIEBAIExvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0oKQogICAgIEFTU0VSVChzX2luc3RhbmNlKTsKICAgICByZXR1cm4gKnNfaW5z dGFuY2U7CiB9CisjZW5kaWYKIAogU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5c3RlbUJh c2VQYXRoKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9iYXNlUGF0aDsKIH0KIAotc3RhdGljIHZv aWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmluZyYg YmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxlU3lzdGVtOjpUeXBl IHR5cGUsIGJvb2wgY3JlYXRlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4g Y2FsbGJhY2tzKQorc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBpZGVu dGlmaWVyLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgYm9vbCBjcmVhdGUsIFBhc3NPd25Q dHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMp CiB7CisjaWYgUExBVEZPUk0oR1RLKQorICAgIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0 ZW0oYmFzZVBhdGgsIGlkZW50aWZpZXIsIHR5cGUsIGNyZWF0ZSwgQXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrOjpjcmVhdGUoY29udGV4dCwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOworI2Vs c2UKICAgICBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGJhc2VQYXRoLCBpZGVudGlm aWVyLCB0eXBlLCBjcmVhdGUsIGNhbGxiYWNrcyk7CisjZW5kaWYKIH0KIAotdm9pZCBMb2NhbEZp bGVTeXN0ZW06OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQs IEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4gY2FsbGJhY2tzLCBib29sKQordm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlYWRGaWxl U3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6 VHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tz LCBib29sIHN5bmNocm9ub3VzKQogewogICAgIC8vIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVT eXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNvIHRoZSBtZXRob2QgbmVlZHMg dG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0 ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250 ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgZmFsc2Us IGNhbGxiYWNrcykpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygm b3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0LT5zZWN1cml0eU9y aWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgZmFsc2UsIGNhbGxiYWNrcywgc3lu Y2hyb25vdXMpKTsKIH0KIAotdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVt KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0 eXBlLCBsb25nIGxvbmcsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxs YmFja3MsIGJvb2wpCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUs IGxvbmcgbG9uZywgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cywgYm9vbCBzeW5jaHJvbm91cykKIHsKICAgICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxl U3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5jaHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRz IHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNseS4KLSAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVh dGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgoKSwgY29u dGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIHRydWUs IGNhbGxiYWNrcykpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygm b3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0LT5zZWN1cml0eU9y aWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgdHJ1ZSwgY2FsbGJhY2tzLCBzeW5j aHJvbm91cykpOwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi44MWMxNmNkMTRkZDYzZjRhYzhmYzJlYzNiZmIzNmY0YmVlOGE2NTljCi0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0ay5jcHAKQEAgLTAsMCArMSwxNjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMp IDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisg KiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0 aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJD SEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhl IEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4K KyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2Vy IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBu b3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBG cmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVT QQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFz eW5jRmlsZVN5c3RlbUd0ay5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlci5oIgorI2luY2x1 ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIkZpbGVNZXRhZGF0YS5oIgorI2luY2x1 ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKworI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJp bmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit0ZW1wbGF0ZTw+IHN0cnVjdCBDcm9zc1Ro cmVhZENvcGllckJhc2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0YWRhdGE+IHsKKyAgICB0eXBlZGVm IEZpbGVNZXRhZGF0YSBUeXBlOworICAgIHN0YXRpYyBGaWxlTWV0YWRhdGEgY29weShjb25zdCBG aWxlTWV0YWRhdGEmKTsKK307CisKK0Nyb3NzVGhyZWFkQ29waWVyQmFzZTxmYWxzZSwgZmFsc2Us IEZpbGVNZXRhZGF0YT46OlR5cGUgQ3Jvc3NUaHJlYWRDb3BpZXJCYXNlPGZhbHNlLCBmYWxzZSwg RmlsZU1ldGFkYXRhPjo6Y29weShjb25zdCBGaWxlTWV0YWRhdGEmIG9yaWdpbmFsKQoreworICAg IEZpbGVNZXRhZGF0YSBtZXRhZGF0YTsKKyAgICBtZXRhZGF0YS5tb2RpZmljYXRpb25UaW1lID0g b3JpZ2luYWwubW9kaWZpY2F0aW9uVGltZTsKKyAgICBtZXRhZGF0YS5sZW5ndGggPSBvcmlnaW5h bC5sZW5ndGg7CisgICAgbWV0YWRhdGEudHlwZSA9IG9yaWdpbmFsLnR5cGU7CisgICAgbWV0YWRh dGEucGxhdGZvcm1QYXRoID0gb3JpZ2luYWwucGxhdGZvcm1QYXRoOworICAgIHJldHVybiBtZXRh ZGF0YTsKK30KKworUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNv bnRleHQsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJv b2wgc3luY2hyb25vdXMpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsoY29udGV4dCwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOworfQorCitQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gQXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrOjpjcmVhdGUoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tD b250cm9sbGVyLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tz LCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGsodGFza0NvbnRyb2xsZXIsIGNhbGxiYWNrcywgbW9kZSkpOwor fQorCisKK0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMpCisgICAgOiBt X3N5bmNocm9ub3VzKHN5bmNocm9ub3VzKQorICAgICwgbV90YXNrTW9kZSgiIikKKyAgICAsIG1f dGFza0NvbnRyb2xsZXIoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OmNyZWF0ZShj b250ZXh0LCBzeW5jaHJvbm91cykpCisgICAgLCBtX2NhbGxiYWNrcyhjYWxsYmFja3MpCit7Cit9 CisKK0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgY29uc3QgU3RyaW5n JiBtb2RlKQorICAgIDogbV9zeW5jaHJvbm91cyhmYWxzZSkKKyAgICAsIG1fdGFza01vZGUobW9k ZSkKKyAgICAsIG1fdGFza0NvbnRyb2xsZXIodGFza0NvbnRyb2xsZXIpCisgICAgLCBtX2NhbGxi YWNrcyhjYWxsYmFja3MpCit7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRTdWNjZWVkQ2Fs bGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7Cit9 CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRTdWNjZWVkKCkKK3sKKyAg ICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygm cGVyZm9ybURpZFN1Y2NlZWRDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpKSwgbV90YXNr TW9kZSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNr KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrcz4gY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NPd25QdHI8QXN5bmNGaWxl U3lzdGVtPiBmaWxlU3lzdGVtKQoreworICAgIGNhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0o bmFtZSwgZmlsZVN5c3RlbSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr OjpkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtPiBmaWxlU3lzdGVtKQoreworICAgIEFzeW5jRmlsZVN5c3RlbUd0ayogZmlsZVN5 c3RlbUd0ayA9IHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbUd0ayo+KGZpbGVTeXN0ZW0uZ2V0 KCkpOworCisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7 CisgICAgbV90YXNrQ29udHJvbGxlci0+c2V0Q3VycmVudFRhc2tNb2RlKG1vZGUpOworICAgIG1f dGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJm b3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBuYW1l LCBmaWxlU3lzdGVtKSwgbW9kZSk7CisKKyAgICBmaWxlU3lzdGVtR3RrLT5zZXRUYXNrQ29udHJv bGxlcihtX3Rhc2tDb250cm9sbGVyLnJlbGVhc2UoKSk7CisgICAgZmlsZVN5c3RlbUd0ay0+d2Fp dEZvck9wZXJhdGlvblRvQ29tcGxldGUoKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZFJl YWRNZXRhZGF0YUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBjb25zdCBGaWxlTWV0YWRhdGEmIG1l dGFkYXRhKQoreworICAgIGNhbGxiYWNrcy0+ZGlkUmVhZE1ldGFkYXRhKG1ldGFkYXRhKTsKK30K Kwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWRNZXRhZGF0YShjb25z dCBGaWxlTWV0YWRhdGEmIG1ldGFkYXRhKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RD YWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkUmVhZE1ldGFkYXRhQ2Fs bGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgbWV0YWRhdGEpLCBtX3Rhc2tNb2RlKTsKK30K Kwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWREaXJlY3RvcnlFbnRy eShjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpCit7CisgICAgRGlyZWN0b3J5 RW50cnkgZGlyZWN0b3J5RW50cnk7CisgICAgZGlyZWN0b3J5RW50cnkubmFtZSA9IG5hbWU7Cisg ICAgZGlyZWN0b3J5RW50cnkuaXNEaXJlY3RvcnkgPSBpc0RpcmVjdG9yeTsKKyAgICBtX2RpcmVj dG9yeUVudHJpZXMuYXBwZW5kKGRpcmVjdG9yeUVudHJ5KTsKK30KKworc3RhdGljIHZvaWQgcGVy Zm9ybURpZFJlYWREaXJlY3RvcnlFbnRyaWVzQW5kRmluaXNoZWRDYWxsYmFjayhTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxi YWNrcykKK3sKKyAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKGZhbHNlKTsK K30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWREaXJlY3RvcnlF bnRyaWVzKGJvb2wgaGFzTW9yZSkKK3sKKyAgICBpZiAoaGFzTW9yZSkKKyAgICAgICAgQVNTRVJU X05PVF9SRUFDSEVEKCk7CisKKyAgICBWZWN0b3I8RGlyZWN0b3J5RW50cnk+OjppdGVyYXRvciBl bmQgPSBtX2RpcmVjdG9yeUVudHJpZXMuZW5kKCk7CisgICAgZm9yIChWZWN0b3I8RGlyZWN0b3J5 RW50cnk+OjppdGVyYXRvciBpdCA9IG1fZGlyZWN0b3J5RW50cmllcy5iZWdpbigpOyBpdCAhPSBl bmQ7ICsraXQpCisgICAgICAgIG1fY2FsbGJhY2tzLT5kaWRSZWFkRGlyZWN0b3J5RW50cnkoaXQt Pm5hbWUsIGl0LT5pc0RpcmVjdG9yeSk7CisKKyAgICBtX2RpcmVjdG9yeUVudHJpZXMuY2xlYXIo KTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJh Y2tUYXNrKCZwZXJmb3JtRGlkUmVhZERpcmVjdG9yeUVudHJpZXNBbmRGaW5pc2hlZENhbGxiYWNr LCBtX2NhbGxiYWNrcy5yZWxlYXNlKCkpLCBtX3Rhc2tNb2RlKTsKK30KKworc3RhdGljIHZvaWQg cGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgUGFzc093 blB0cjxBc3luY0ZpbGVXcml0ZXI+IHdyaXRlciwgbG9uZyBsb25nIGxlbmd0aCkKK3sKKyAgICBj YWxsYmFja3MtPmRpZENyZWF0ZUZpbGVXcml0ZXIod3JpdGVyLCBsZW5ndGgpOworfQorCit2b2lk IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkQ3JlYXRlRmlsZVdyaXRlcihQYXNzT3du UHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBsb25nIGxvbmcgbGVuZ3RoKQoreworICAgIG1f dGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJm b3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCksIHdy aXRlciwgbGVuZ3RoKSwgbV90YXNrTW9kZSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRG YWlsQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGludCBjb2RlKQoreworICAgIGNhbGxiYWNrcy0+ ZGlkRmFpbChjb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRp ZEZhaWwoaW50IGNvZGUpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFz ayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2ssIG1fY2FsbGJhY2tz LnJlbGVhc2UoKSwgY29kZSksIG1fdGFza01vZGUpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZjQ4NmYzZThmMTQxODE5MTYzMTA0NDU1MjIxYTAxMGVlMjgxNjRiOAotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGsuaApAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEx IFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAy MDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICog bW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1Ymxp YworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv bjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVk IGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBH TlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisg KgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBH ZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90 LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EK KyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisjZGVmaW5lIEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisK KyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKKyNpbmNsdWRlICJBc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0 OworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsgOiBwdWJsaWMgQXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzID0gZmFs c2UpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4g Y3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgdmlydHVh bCB2b2lkIGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0o Y29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4pOworICAgIHZp cnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1ldGFkYXRhJik7CisgICAgdmly dHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wg aXNEaXJlY3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0b3J5RW50cmllcyhi b29sIGhhc01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVhdGVGaWxlV3JpdGVyKFBhc3NP d25QdHI8QXN5bmNGaWxlV3JpdGVyPiwgbG9uZyBsb25nIGxlbmd0aCk7CisgICAgdmlydHVhbCB2 b2lkIGRpZEZhaWwoaW50IGNvZGUpOworCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzKTsKKyAgICBBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICBz dHJ1Y3QgRGlyZWN0b3J5RW50cnkgeworICAgICAgICBTdHJpbmcgbmFtZTsKKyAgICAgICAgYm9v bCBpc0RpcmVjdG9yeTsKKworICAgICAgICBEaXJlY3RvcnlFbnRyeSgpIDogaXNEaXJlY3Rvcnko ZmFsc2UpIHsgfQorICAgIH07CisKKyAgICBib29sIG1fc3luY2hyb25vdXM7CisgICAgU3RyaW5n IG1fdGFza01vZGU7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr PiBtX3Rhc2tDb250cm9sbGVyOworICAgIE93blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ IG1fY2FsbGJhY2tzOworICAgIFZlY3RvcjxEaXJlY3RvcnlFbnRyeT4gbV9kaXJlY3RvcnlFbnRy aWVzOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RF TSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc19oCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCmluZGV4IGMxZGIw MDZhODQ4ZjM5MjZkZDlmZWMzMWY5NjRhMGZkYmRhZjY5ZmMuLmEzNzViYjU5NTkzMDdiYjU0YWFh MmI2NjRkNTU1NzQ4ZTkxMWJhNGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCkBAIC0xLDQgKzEsNSBAQAogLyoKKyAqIENvcHly aWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAqIENv cHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgogICoK ICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKQEAgLTE4LDI3ICsxOSwzNSBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1HdGsuaCIKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKIAotI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUd0ay5oIgotCi0jaW5jbHVkZSAiQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIKKyNp bmNsdWRlICJBc3luY0ZpbGVXcml0ZXJHdGsuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2su aCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCisjaW5jbHVkZSAiRmlsZUVycm9yLmgiCisj aW5jbHVkZSAiTG9jYWxGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIK IAorI2luY2x1ZGUgPGdsaWIuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HT3duUHRyLmg+Cisj aW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJp bmcuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CisKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0K IAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzVmFsaWRUeXBlKFR5cGUgdHlwZSkKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gdHlwZSA9PSBU ZW1wb3JhcnkgfHwgdHlwZSA9PSBQZXJzaXN0ZW50OwogfQogCiBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoVHlwZSB0eXBlKQpAQCAtNDgsOCArNTcs MTAgQEAgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRl KFR5cGUgdHlwZSkKIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0 IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmFnZUlkZW50aWZpZXIsIFR5cGUg dHlwZSwgYm9vbCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChOT1Rf U1VQUE9SVEVEX0VSUik7CisgICAgU3RyaW5nIHR5cGVTdHJpbmcgPSAodHlwZSA9PSBBc3luY0Zp bGVTeXN0ZW06OlBlcnNpc3RlbnQpID8gIlBlcnNpc3RlbnQiIDogIlRlbXBvcmFyeSI7CisgICAg U3RyaW5nIG5hbWUgPSBzdG9yYWdlSWRlbnRpZmllciArICI6IiArIHR5cGVTdHJpbmc7CisKKyAg ICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIEFzeW5jRmlsZVN5c3RlbTo6Y3Jl YXRlKHR5cGUpKTsKIH0KIAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVS TChjb25zdCBLVVJMJiB1cmwsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSYgdHlwZSwgU3RyaW5nJiBm aWxlUGF0aCkKQEAgLTYwLDc1ICs3MSwzOTYgQEAgYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmNyYWNr RmlsZVN5c3RlbVVSTChjb25zdCBLVVJMJiB1cmwsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSYKIAog QXN5bmNGaWxlU3lzdGVtR3RrOjpBc3luY0ZpbGVTeXN0ZW1HdGsoQXN5bmNGaWxlU3lzdGVtOjpU eXBlIHR5cGUpCiAgICAgOiBBc3luY0ZpbGVTeXN0ZW0odHlwZSkKKyAgICAsIG1fbG9jYWxGaWxl U3lzdGVtQmFzZVBhdGgoTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5maWxlU3lz dGVtQmFzZVBhdGgoKSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCiBBc3luY0ZpbGVT eXN0ZW1HdGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGsoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7 CiB9CiAKIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW1HdGs6OnRvVVJMKGNvbnN0IFN0cmluZyYgb3Jp Z2luU3RyaW5nLCBjb25zdCBTdHJpbmcmIGZ1bGxQYXRoKQogewotICAgIG5vdEltcGxlbWVudGVk KCk7Ci0gICAgcmV0dXJuIFN0cmluZygpOworICAgIEFTU0VSVCghb3JpZ2luU3RyaW5nLmlzRW1w dHkoKSk7CisgICAgaWYgKG9yaWdpblN0cmluZyA9PSBTdHJpbmcoIm51bGwiKSkKKyAgICAgICAg cmV0dXJuIFN0cmluZygpOworCisgICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7CisgICAgcmVzdWx0 LmFwcGVuZCgiZmlsZXN5c3RlbToiKTsKKyAgICByZXN1bHQuYXBwZW5kKG9yaWdpblN0cmluZyk7 CisgICAgcmVzdWx0LmFwcGVuZCgiLyIpOworICAgIGlmICh0eXBlKCkgPT0gVGVtcG9yYXJ5KQor ICAgICAgICByZXN1bHQuYXBwZW5kKHRlbXBvcmFyeVBhdGhQcmVmaXgpOworICAgIGlmICh0eXBl KCkgPT0gUGVyc2lzdGVudCkKKyAgICAgICAgcmVzdWx0LmFwcGVuZChwZXJzaXN0ZW50UGF0aFBy ZWZpeCk7CisgICAgcmVzdWx0LmFwcGVuZChlbmNvZGVXaXRoVVJMRXNjYXBlU2VxdWVuY2VzKGZ1 bGxQYXRoKSk7CisKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK3N0YXRpYyB2 b2lkIG1vdmVBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBzcmNQYXRoLCBT dHJpbmcmIGRlc3RQYXRoKQoreworICAgIEdSZWZQdHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9w dEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChzcmNQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBH UmVmUHRyPEdGaWxlPiBkZXN0aW5hdGlvbkZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3Jf cGF0aChkZXN0UGF0aC51dGY4KCkuZGF0YSgpKSk7CisKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4g c291cmNlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhzb3VyY2VGaWxlLmdldCgp LCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBpZiAoIXNvdXJjZUlu Zm8pIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZP VU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHUmVmUHRyPEdGaWxlSW5m bz4gZGVzdGluYXRpb25JbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKGRlc3RpbmF0 aW9uRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAg aWYgKGRlc3RpbmF0aW9uSW5mbykgeworICAgICAgICBHRmlsZVR5cGUgc291cmNlRmlsZVR5cGUg PSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKHNvdXJjZUluZm8uZ2V0KCkpOworICAgICAgICBH RmlsZVR5cGUgZGVzdGluYXRpb25GaWxlVHlwZSA9IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUo ZGVzdGluYXRpb25JbmZvLmdldCgpKTsKKworICAgICAgICBpZiAoc291cmNlRmlsZVR5cGUgIT0g ZGVzdGluYXRpb25GaWxlVHlwZSkgeworICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRG YWlsKEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSKTsKKyAgICAgICAgICAgIHJl dHVybjsKKyAgICAgICAgfQorICAgICAgICBpZiAoZGVzdGluYXRpb25GaWxlVHlwZSA9PSBHX0ZJ TEVfVFlQRV9ESVJFQ1RPUlkKKyAgICAgICAgICAgICAgICAmJiAhZ19maWxlX2RlbGV0ZShkZXN0 aW5hdGlvbkZpbGUuZ2V0KCksIDAsIDApKSB7CisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3Mt PmRpZEZhaWwoRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlIpOworICAgICAgICAg ICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgaWYgKCFnX2ZpbGVfbW92ZShzb3Vy Y2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIEdfRklMRV9DT1BZX09WRVJXUklU RSwgMCwgMCwgMCwgMCkpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVF cnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBoZWxw ZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6 Om1vdmUoY29uc3QgU3RyaW5nJiBzb3VyY2VQYXRoLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0aW9u UGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsK LSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBzb3VyY2VGaWxlU3lzdGVtUGF0aCA9 IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHNvdXJjZVBhdGgpOworICAgIFN0cmluZyBkZXN0 aW5hdGlvbkZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwoZGVzdGlu YXRpb25QYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1v ZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0 ZUNhbGxiYWNrVGFzaygmbW92ZUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNy ZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBzb3VyY2VGaWxl U3lzdGVtUGF0aCwgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCkpOworfQorCitzdGF0aWMgdm9p ZCBjb3B5UmVjdXJzaXZlbHkoR0ZpbGUqIHNvdXJjZURpcmVjdG9yeSwgR0ZpbGUqIGRlc3RpbmF0 aW9uRGlyZWN0b3J5LCBHRXJyb3IqKiBlcnJvcikKK3sKKyAgICBpZiAoIWdfZmlsZV9tYWtlX2Rp cmVjdG9yeShkZXN0aW5hdGlvbkRpcmVjdG9yeSwgMCwgZXJyb3IpKQorICAgICAgICByZXR1cm47 CisKKyAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9yeShnX2Rpcl9vcGVuKGdfZmlsZV9nZXRfcGF0 aChzb3VyY2VEaXJlY3RvcnkpLCAwLCBlcnJvcikpOworICAgIGlmICghZGlyZWN0b3J5KQorICAg ICAgICByZXR1cm47CisKKyAgICB3aGlsZSAoY29uc3QgY2hhciogZGlyZWN0b3J5RW50cnkgPSBj b25zdF9jYXN0PGNoYXIqPihnX2Rpcl9yZWFkX25hbWUoZGlyZWN0b3J5LmdldCgpKSkpIHsKKyAg ICAgICAgR1JlZlB0cjxHRmlsZT4gc291cmNlRmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0X2No aWxkKHNvdXJjZURpcmVjdG9yeSwgZGlyZWN0b3J5RW50cnkpKTsKKyAgICAgICAgR1JlZlB0cjxH RmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQoZGVzdGlu YXRpb25EaXJlY3RvcnksIGRpcmVjdG9yeUVudHJ5KSk7CisKKyAgICAgICAgR1JlZlB0cjxHRmls ZUluZm8+IHNvdXJjZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oc291cmNlRmls ZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCBlcnJvcikpOworICAgICAg ICBpZiAoIXNvdXJjZUluZm8pCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIGlmIChnX2Zp bGVfaW5mb19nZXRfZmlsZV90eXBlKHNvdXJjZUluZm8uZ2V0KCkpID09IEdfRklMRV9UWVBFX0RJ UkVDVE9SWSkgeworICAgICAgICAgICAgY29weVJlY3Vyc2l2ZWx5KHNvdXJjZUZpbGUuZ2V0KCks IGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgZXJyb3IpOworICAgICAgICAgICAgcmV0dXJuOworICAg ICAgICB9CisgICAgICAgIGlmICghZ19maWxlX2NvcHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGlu YXRpb25GaWxlLmdldCgpLCBHX0ZJTEVfQ09QWV9OT05FLCAwLCAwLCAwLCBlcnJvcikpCisgICAg ICAgICAgICByZXR1cm47CisgICAgfQorfQorCitzdGF0aWMgdm9pZCBjb3B5QXN5bmMoU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr PiBoZWxwZXJDYWxsYmFja3MsIFN0cmluZyYgc291cmNlUGF0aCwgU3RyaW5nJiBkZXN0UGF0aCkK K3sKKyAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdf Zm9yX3BhdGgoc291cmNlUGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgR1JlZlB0cjxHRmlsZT4g ZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoZGVzdFBhdGgu dXRmOCgpLmRhdGEoKSkpOworCisgICAgR1JlZlB0cjxHRmlsZUluZm8+IHNvdXJjZUluZm8gPSBh ZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oc291cmNlRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVf UVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKCFzb3VyY2VJbmZvKSB7CisgICAgICAg IGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAg ICAgICByZXR1cm47CisgICAgfQorCisgICAgR0ZpbGVUeXBlIHNvdXJjZUZpbGVUeXBlID0gZ19m aWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShzb3VyY2VJbmZvLmdldCgpKTsKKyAgICBHUmVmUHRyPEdG aWxlSW5mbz4gZGVzdGluYXRpb25JbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKGRl c3RpbmF0aW9uRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7 CisgICAgaWYgKGRlc3RpbmF0aW9uSW5mbykgeworICAgICAgICBHRmlsZVR5cGUgZGVzdGluYXRp b25GaWxlVHlwZSA9IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZGVzdGluYXRpb25JbmZvLmdl dCgpKTsKKyAgICAgICAgaWYgKHNvdXJjZUZpbGVUeXBlICE9IGRlc3RpbmF0aW9uRmlsZVR5cGUp IHsKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6OklOVkFM SURfTU9ESUZJQ0FUSU9OX0VSUik7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAg ICAgICAgaWYgKGRlc3RpbmF0aW9uRmlsZVR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZCisg ICAgICAgICAgICAgICAgJiYgIWdfZmlsZV9kZWxldGUoZGVzdGluYXRpb25GaWxlLmdldCgpLCAw LCAwKSkgeworICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6 SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAg fQorICAgIH0KKworICAgIGlmIChzb3VyY2VGaWxlVHlwZSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RP UlkpIHsKKyAgICAgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgICAgICBjb3B5UmVjdXJz aXZlbHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGluYXRpb25GaWxlLmdldCgpLCAmZXJyb3Iub3V0 UHRyKCkpOworICAgICAgICBpZiAoZXJyb3IpCisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3Mt PmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgZWxzZQorICAgICAg ICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBpZiAoIWdfZmlsZV9jb3B5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9u RmlsZS5nZXQoKSwgR19GSUxFX0NPUFlfT1ZFUldSSVRFLCAwLCAwLCAwLCAwKSkgeworICAgICAg ICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgp OwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y29weShjb25zdCBTdHJpbmcmIHNvdXJj ZVBhdGgsIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25QYXRoLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Cisg ICAgU3RyaW5nIHNvdXJjZUZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1V Ukwoc291cmNlUGF0aCk7CisgICAgU3RyaW5nIGRlc3RpbmF0aW9uRmlsZVN5c3RlbVBhdGggPSB2 aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChkZXN0aW5hdGlvblBhdGgpOworICAgIFN0cmluZyBt b2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJv bGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZjb3B5QXN5bmMs IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0 KCksIGNhbGxiYWNrcywgbW9kZSksIHNvdXJjZUZpbGVTeXN0ZW1QYXRoLCBkZXN0aW5hdGlvbkZp bGVTeXN0ZW1QYXRoKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92ZUZpbGUoR0ZpbGUqIGZpbGUs IGJvb2wgcmVjdXJzaXZlLCBHRXJyb3IqKiBlcnJvcikKK3sKKyAgICBpZiAocmVjdXJzaXZlICYm IGdfZmlsZV90ZXN0KGdfZmlsZV9nZXRfcGF0aChmaWxlKSwgR19GSUxFX1RFU1RfSVNfRElSKSkg eworICAgICAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9yeShnX2Rpcl9vcGVuKGdfZmlsZV9nZXRf cGF0aChmaWxlKSwgMCwgZXJyb3IpKTsKKyAgICAgICAgaWYgKCFkaXJlY3RvcnkpCisgICAgICAg ICAgICByZXR1cm47CisKKyAgICAgICAgd2hpbGUgKGNvbnN0IGNoYXIqIGRpcmVjdG9yeUVudHJ5 ID0gY29uc3RfY2FzdDxjaGFyKj4oZ19kaXJfcmVhZF9uYW1lKGRpcmVjdG9yeS5nZXQoKSkpKSB7 CisgICAgICAgICAgICBHUmVmUHRyPEdGaWxlPiBjaGlsZCA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0 X2NoaWxkKGZpbGUsIGRpcmVjdG9yeUVudHJ5KSk7CisgICAgICAgICAgICByZW1vdmVGaWxlKGNo aWxkLmdldCgpLCByZWN1cnNpdmUsIGVycm9yKTsKKyAgICAgICAgICAgIGlmICgqZXJyb3IpCisg ICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgZ19maWxlX2Rl bGV0ZShmaWxlLCAwLCBlcnJvcik7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92ZUFzeW5jKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGZpbGVQYXRoLCBib29sIHJlY3Vyc2l2ZSkKK3sK KyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0cjxHRmlsZT4gZmlsZSA9IGFk b3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAg ICByZW1vdmVGaWxlKGZpbGUuZ2V0KCksIHJlY3Vyc2l2ZSwgJmVycm9yLm91dFB0cigpKTsKKyAg ICBpZiAoZXJyb3IpIHsKKyAgICAgICAgRmlsZUVycm9yOjpFcnJvckNvZGUgZXJyb3JDb2RlOwor ICAgICAgICBzd2l0Y2ggKGVycm9yLT5jb2RlKSB7CisgICAgICAgIGNhc2UgR19JT19FUlJPUl9O T1RfRU1QVFk6CisgICAgICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6OklOVkFMSURfTU9E SUZJQ0FUSU9OX0VSUjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIEdfSU9fRVJS T1JfTk9UX0ZPVU5EOgorICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgZXJyb3JDb2RlID0g RmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSOworICAgICAgICB9CisKKyAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKGVycm9yQ29kZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAg ICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0 ZW1HdGs6OnJlbW92ZShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBT dHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsK KyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAg IG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFz aygmcmVtb3ZlQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFz a0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoLCBmYWxz ZSkpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVjdXJzaXZlbHkoY29u c3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2Fs bGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1Q YXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUg PSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVy LT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlbW92ZUFzeW5jLCBB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgp LCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgdHJ1ZSkpOworfQorCitzdGF0aWMg dm9pZCByZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBm aWxlUGF0aCkKK3sKKyAgICBHUmVmUHRyPEdGaWxlPiBmaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9u ZXdfZm9yX3BhdGgoZmlsZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIEdSZWZQdHI8R0ZpbGVJ bmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhmaWxlLmdldCgpLCAi KiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBpZiAoIWZpbGVJbmZvKSB7 CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9F UlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgRmlsZU1ldGFkYXRhOjpUeXBlIHR5 cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgpKSA9PSBHX0ZJTEVf VFlQRV9ESVJFQ1RPUlkgPyBGaWxlTWV0YWRhdGE6OlR5cGVEaXJlY3RvcnkgOiBGaWxlTWV0YWRh dGE6OlR5cGVGaWxlOworCisgICAgR1RpbWVWYWwgdGltZVZhbHVlOworICAgIGdfZmlsZV9pbmZv X2dldF9tb2RpZmljYXRpb25fdGltZShmaWxlSW5mby5nZXQoKSwgJnRpbWVWYWx1ZSk7CisKKyAg ICBGaWxlTWV0YWRhdGEgbWV0YWRhdGE7CisgICAgbWV0YWRhdGEudHlwZSA9IHR5cGU7CisgICAg bWV0YWRhdGEubW9kaWZpY2F0aW9uVGltZSA9IHN0YXRpY19jYXN0PGRvdWJsZT4odGltZVZhbHVl LnR2X3NlYyk7CisgICAgbWV0YWRhdGEubGVuZ3RoID0gdHlwZSA9PSBGaWxlTWV0YWRhdGE6OlR5 cGVGaWxlID8gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxl SW5mby5nZXQoKSkpIDogMDsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBTdHJpbmcoZ19m aWxlX2dldF9wYXRoKGZpbGUuZ2V0KCkpKTsKKworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkUmVh ZE1ldGFkYXRhKG1ldGFkYXRhKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWRN ZXRhZGF0YShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcg ZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBT dHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFz a0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVh ZE1ldGFkYXRhQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFz a0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoKSk7CiB9 CiAKLXZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVGaWxlKGNvbnN0IFN0cmluZyYgcGF0 aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBj YWxsYmFja3MpCitzdGF0aWMgdm9pZCBjcmVhdGVPYmplY3RBc3luYyhTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNh bGxiYWNrcywgU3RyaW5nJiBsb2NhbEZpbGVTeXN0ZW1QYXRoLCBTdHJpbmcmIGFic29sdXRlUGF0 aCwgR0ZpbGVUeXBlIHR5cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBpZiAodHlw ZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSICYmIGFic29sdXRlUGF0aCA9PSBTdHJpbmcoIi8iKSkg eworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpTRUNVUklUWV9F UlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR093blB0cjxHRXJyb3I+IGVycm9y OworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0 aChsb2NhbEZpbGVTeXN0ZW1QYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBpZiAodHlwZSA9PSBH X0ZJTEVfVFlQRV9SRUdVTEFSKQorICAgICAgICBHUmVmUHRyPEdGaWxlT3V0cHV0U3RyZWFtPiBv dXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX2NyZWF0ZShmaWxlLmdldCgpLCBHX0ZJTEVf Q1JFQVRFX05PTkUsIDAsICZlcnJvci5vdXRQdHIoKSkpOworICAgIGVsc2UgaWYgKHR5cGUgPT0g R19GSUxFX1RZUEVfRElSRUNUT1JZKQorICAgICAgICBnX2ZpbGVfbWFrZV9kaXJlY3RvcnkoZmls ZS5nZXQoKSwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBlbHNlCisgICAgICAgIEFTU0VSVF9O T1RfUkVBQ0hFRCgpOworCisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIEZpbGVFcnJvcjo6RXJy b3JDb2RlIGVycm9yQ29kZTsKKyAgICAgICAgc3dpdGNoIChlcnJvci0+Y29kZSkgeworICAgICAg ICBjYXNlIEdfSU9fRVJST1JfRVhJU1RTOgorICAgICAgICAgICAgZXJyb3JDb2RlID0gRmlsZUVy cm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlI7CisgICAgICAgICAgICBicmVhazsKKyAgICAg ICAgY2FzZSBHX0lPX0VSUk9SX05PVF9GT1VORDoKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAg ICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUjsKKyAgICAgICAgfQorICAg ICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3JDb2RlKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCi12b2lk IEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwg Ym9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxs YmFja3MpCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlT2JqZWN0KFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgYWJzb2x1 dGVQYXRoLCBHRmlsZVR5cGUgdHlwZSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0 cmluZyBsb2NhbEZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwoYWJz b2x1dGVQYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1v ZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0 ZUNhbGxiYWNrVGFzaygmY3JlYXRlT2JqZWN0QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGxv Y2FsRmlsZVN5c3RlbVBhdGgsIGFic29sdXRlUGF0aCwgdHlwZSkpOworfQorCit2b2lkIEFzeW5j RmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZShjb25zdCBTdHJpbmcmIGFic29sdXRlUGF0aCwgYm9v bCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFj a3MpCit7CisgICAgY3JlYXRlT2JqZWN0KGNhbGxiYWNrcywgYWJzb2x1dGVQYXRoLCBHX0ZJTEVf VFlQRV9SRUdVTEFSKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVj dG9yeShjb25zdCBTdHJpbmcmIGFic29sdXRlUGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25Q dHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY3JlYXRlT2Jq ZWN0KGNhbGxiYWNrcywgYWJzb2x1dGVQYXRoLCBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpOworfQor CitzdGF0aWMgdm9pZCBvYmplY3RFeGlzdHNBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywg U3RyaW5nJiBwYXRoLCBHRmlsZVR5cGUgdHlwZSkKK3sKKyAgICBHUmVmUHRyPEdGaWxlPiBvYmpl Y3QgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChwYXRoLnV0ZjgoKS5kYXRhKCkpKTsK KyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5 X2luZm8ob2JqZWN0LmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsK KyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChG aWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGlm IChnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgpKSAhPSB0eXBlKSB7Cisg ICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6OlRZUEVfTUlTTUFUQ0hf RVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlk U3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6ZmlsZUV4aXN0cyhjb25z dCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxs YmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBh dGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9 IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXIt PnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmb2JqZWN0RXhpc3RzQXN5 bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIu Z2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoLCBHX0ZJTEVfVFlQRV9SRUdV TEFSKSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpkaXJlY3RvcnlFeGlzdHMoY29u c3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2Fs bGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1Q YXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUg PSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVy LT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9iamVjdEV4aXN0c0Fz eW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVy LmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgR19GSUxFX1RZUEVfRElS RUNUT1JZKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJlYWREaXJlY3RvcnlBc3luYyhTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNh bGxiYWNrcywgU3RyaW5nJiBwYXRoKQoreworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAg ICBHUmVmUHRyPEdGaWxlPiBkaXJlY3RvcnlGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9y X3BhdGgocGF0aC51dGY4KCkuZGF0YSgpKSk7CisKKyAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9y eShnX2Rpcl9vcGVuKHBhdGgudXRmOCgpLmRhdGEoKSwgMCwgJmVycm9yLm91dFB0cigpKSk7Cisg ICAgaWYgKCFlcnJvcikgeworICAgICAgICB3aGlsZSAoY29uc3QgY2hhciogZGlyZWN0b3J5RW50 cnkgPSBjb25zdF9jYXN0PGNoYXIqPihnX2Rpcl9yZWFkX25hbWUoZGlyZWN0b3J5LmdldCgpKSkp IHsKKyAgICAgICAgICAgIEdSZWZQdHI8R0ZpbGU+IGNoaWxkID0gYWRvcHRHUmVmKGdfZmlsZV9n ZXRfY2hpbGQoZGlyZWN0b3J5RmlsZS5nZXQoKSwgZGlyZWN0b3J5RW50cnkpKTsKKyAgICAgICAg ICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlf aW5mbyhjaGlsZC5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisK KyAgICAgICAgICAgIGJvb2wgaXNFbnRyeURpcmVjdG9yeSA9IGdfZmlsZV9pbmZvX2dldF9maWxl X3R5cGUoZmlsZUluZm8uZ2V0KCkpID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWTsKKyAgICAgICAg ICAgIGNhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeUVudHJ5KFN0cmluZyhkaXJlY3RvcnlFbnRy eSksIGlzRW50cnlEaXJlY3RvcnkpOworICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAg Y2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisKKyAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKGZh bHNlKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWREaXJlY3RvcnkoY29uc3Qg U3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJh Y2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRo ID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBt X3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5w b3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlYWREaXJlY3RvcnlBc3lu YywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5n ZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgpKTsKIH0KIAorc3RhdGljIHZv aWQgY3JlYXRlV3JpdGVyQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIEFzeW5jRmlsZVdy aXRlckNsaWVudCogY2xpZW50LCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFz a0NvbnRyb2xsZXIsIFN0cmluZyYgcGF0aCkKK3sKKyAgICBHUmVmUHRyPEdGaWxlPiBmaWxlID0g YWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgocGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAg R1JlZlB0cjxHRmlsZUluZm8+IGZpbGVJbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZv KGZpbGUuZ2V0KCksICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlm ICghZmlsZUluZm8pIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJv cjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBsb25nIGxv bmcgZmlsZVNpemUgPSBzdGF0aWNfY2FzdDxsb25nIGxvbmc+KGdfZmlsZV9pbmZvX2dldF9zaXpl KGZpbGVJbmZvLmdldCgpKSk7CisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRDcmVhdGVGaWxlV3Jp dGVyKEFzeW5jRmlsZVdyaXRlckd0azo6Y3JlYXRlKGNsaWVudCwgdGFza0NvbnRyb2xsZXIsIGZp bGUubGVha1JlZigpKSwgZmlsZVNpemUpOworfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6 Y3JlYXRlV3JpdGVyKEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcm IHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7 Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0 dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0Nv bnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNr VG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY3JlYXRlV3JpdGVyQXN5bmMsIEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNh bGxiYWNrcywgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MoY2xpZW50KSwgQWxsb3dDcm9z c1RocmVhZEFjY2VzcyhtX3Rhc2tDb250cm9sbGVyLmdldCgpKSwgZmlsZVN5c3RlbVBhdGgpKTsK K30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVNuYXBzaG90RmlsZUFuZFJlYWRN ZXRhZGF0YShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgLy8gRklYTUU6IElzIHRoaXMgYXBpIHJlYWxseSBz YW1lIHdpdGggcmVhZE1ldGFkYXRhPworICAgIHJlYWRNZXRhZGF0YShwYXRoLCBjYWxsYmFja3Mp OworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6c2V0VGFza0NvbnRyb2xsZXIoUGFzc1Jl ZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gdGFza0NvbnRyb2xsZXIpCit7 CisgICAgbV90YXNrQ29udHJvbGxlciA9IHRhc2tDb250cm9sbGVyOworfQorCitTdHJpbmcgQXN5 bmNGaWxlU3lzdGVtR3RrOjp2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChjb25zdCBTdHJpbmcm IHZpcnR1YWxQYXRoKQoreworICAgIHJldHVybiB2aXJ0dWFsUGF0aCAhPSBTdHJpbmcoIi8iKSA/ IG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGggKyB2aXJ0dWFsUGF0aCA6IG1fbG9jYWxGaWxlU3lz dGVtQmFzZVBhdGg7Cit9CisKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtR3RrOjp3YWl0Rm9yT3BlcmF0 aW9uVG9Db21wbGV0ZSgpCit7CisgICAgcmV0dXJuIG1fdGFza0NvbnRyb2xsZXItPndhaXRGb3JP cGVyYXRpb25Ub0NvbXBsZXRlKCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuaAppbmRleCBj YjQ1YjZlYTRiYzIwMjBlOGViNGM4ZWI1YTE5OGYwNzZmNWE2OTdiLi44MGFlNGU1ODk3M2FiYjcw NTFmNjMyYzgwNWE3MDI2Njc3ODRlNGNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oCkBAIC0xLDQgKzEsNSBAQAogLyoKKyAqIENvcHly aWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAqIENv cHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgogICoK ICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKQEAgLTIzLDExICsyNCwxNCBAQAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIAog I2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorCisjaW5jbHVkZSA8Z2lvL2dpby5oPgogI2lu Y2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3Mg QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzOworY2xhc3MgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs7CiAKIGNsYXNzIEFzeW5jRmlsZVN5c3RlbUd0ayA6IHB1YmxpYyBBc3luY0ZpbGVT eXN0ZW0gewogcHVibGljOgpAQCAtNDYsNiArNTAsMTYgQEAgcHVibGljOgogICAgIHZpcnR1YWwg dm9pZCBkaXJlY3RvcnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrcz4pOwogICAgIHZpcnR1YWwgdm9pZCByZWFkRGlyZWN0b3J5KGNv bnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsK ICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlV3JpdGVyKEFzeW5jRmlsZVdyaXRlckNsaWVudCosIGNv bnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsK KyAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlU25hcHNob3RGaWxlQW5kUmVhZE1ldGFkYXRhKGNvbnN0 IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKKyAg ICB2aXJ0dWFsIGJvb2wgd2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKTsKKworICAgIHZvaWQg c2V0VGFza0NvbnRyb2xsZXIoUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0az4pOworcHJpdmF0ZToKKyAgICB2b2lkIGNyZWF0ZU9iamVjdChQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmluZyYgYWJzb2x1dGVQYXRoLCBHRmlsZVR5 cGUpOworICAgIFN0cmluZyB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChjb25zdCBTdHJpbmcm KTsKKworICAgIFN0cmluZyBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoOworICAgIFJlZlB0cjxB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90YXNrQ29udHJvbGxlcjsKIH07CiAK IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjA1MjE2ZjAwMGFhZGU1NWNmNTU4NDk5YTNlMzVjYmJjZjdjYzc2YzkKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsuY3BwCkBAIC0wLDAgKzEsOTMgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKiBDb3B5cmln aHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisgKiBU aGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVy YWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlv dXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisg KiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBT ZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg TGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5 OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMu LCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0x MzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisj aW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNz UmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0azo6Y3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQs IGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ayhjb250ZXh0LCBzeW5jaHJvbm91cykpOworfQorCitBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9vbCBzeW5jaHJvbm91cykK KyAgICA6IG1fY29udGV4dChjb250ZXh0KQorICAgICwgbV9zeW5jaHJvbm91cyhzeW5jaHJvbm91 cykKKyAgICAsIG1fY3VycmVudFRhc2tNb2RlKCIiKQorICAgICwgbV93cml0ZXJUb0NhbmNlbCgw KQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdva2VycyBmb3IgZmlsZXN5c3Rl bSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKK30KKworQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0aygpCit7Cit9CisKK1N0cmluZyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6 dW5pcXVlTW9kZSgpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZv ciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOwor ICAgIHJldHVybiBTdHJpbmcoKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azo6cG9zdFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPiB0YXNrKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdv a2VycyBmb3IgZmlsZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVu dCgpKTsKKyAgICBtX2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCit2b2lkIEFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzZXRDdXJyZW50VGFza01vZGUoY29uc3QgU3RyaW5n JiB0YXNrTW9kZSkKK3sKKyAgICBtX2N1cnJlbnRUYXNrTW9kZSA9IHRhc2tNb2RlOworfQorCit2 b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpwb3N0Q2FsbGJhY2tUYXNrKFBh c3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywgY29uc3QgU3RyaW5n JiBtb2RlKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdva2VycyBmb3IgZmls ZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKKyAgICBt X2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgQVNTRVJU KG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKKyAgICBBU1NFUlQoIW1fc3luY2hyb25vdXMpOwor ICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0azo6Y2FuY2VsV3JpdGVySWZOZWNlc3NhcnkoQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIp Cit7CisgICAgaWYgKG1fd3JpdGVyVG9DYW5jZWwgPT0gd3JpdGVyKSB7CisgICAgICAgIG1fd3Jp dGVyVG9DYW5jZWwgPSAwOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJu IGZhbHNlOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUo RklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg5ODAz MDY4ZGM2ZDE1MGU3ZjFlZjdlNDhjYjIxMTk0MmY0Yjg2OWMKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGsuaApAQCAtMCwwICsxLDY1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2Jl cnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDEyIENoYW5n U2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGlj ZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy CisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7 IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExl c3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91 IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1 YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0 byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3Ry ZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisj aWZuZGVmIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKyNkZWZpbmUgQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaAorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQor CisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5jbHVkZSA8d3RmL1Bh c3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkU2FmZVJlZkNvdW50ZWQuaD4KKyNpbmNs dWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXN5 bmNGaWxlV3JpdGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ayA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0az4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrPiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wg c3luY2hyb25vdXMpOworICAgIH5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0aygpOwor CisgICAgdm9pZCBwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQ6OlRhc2s+KTsKKyAgICB2b2lkIHNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJp bmcmKTsKKyAgICB2b2lkIHBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5nJik7CisgICAgYm9vbCB3YWl0Rm9yT3BlcmF0 aW9uVG9Db21wbGV0ZSgpOworICAgIGJvb2wgc3luY2hyb25vdXMoKSB7IHJldHVybiBtX3N5bmNo cm9ub3VzOyB9CisKKyAgICBib29sIGNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KEFzeW5jRmlsZVdy aXRlckd0ayopOworICAgIHZvaWQgc2V0V3JpdGVyVG9DYW5jZWwoQXN5bmNGaWxlV3JpdGVyR3Rr KiB3cml0ZXIpIHsgbV93cml0ZXJUb0NhbmNlbCA9IHdyaXRlcjsgfQorCisgICAgU3RyaW5nIHVu aXF1ZU1vZGUoKTsKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wpOworCisgICAgU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogbV9jb250ZXh0OworICAgIGJvb2wgbV9zeW5jaHJvbm91czsKKyAgICBTdHJpbmcg bV9jdXJyZW50VGFza01vZGU7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJHdGsqIG1fd3JpdGVyVG9D YW5jZWw7Cit9OworCit9IC8vIG5hbWVzcGFjZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lT VEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzX2gKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uY2I4NTllMzgwNDU5YjRhZWEyYjdmYmNjODA2NDQ3YzgwYThhMTVmYQot LS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVX cml0ZXJDbGllbnRHdGsuY3BwCkBAIC0wLDAgKzEsNzAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQg KEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwg UHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBp ZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAx IFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0 ZXJDbGllbnRHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkNy b3NzVGhyZWFkVGFzay5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0YXRpYyB2b2lkIHBl cmZvcm1EaWRXcml0ZUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBBc3luY0ZpbGVX cml0ZXJDbGllbnQqIGNsaWVudCwgbG9uZyBsb25nIGJ5dGVzLCBib29sIGNvbXBsZXRlKQorewor ICAgIGNsaWVudC0+ZGlkV3JpdGUoYnl0ZXMsIGNvbXBsZXRlKTsKK30KKworc3RhdGljIHZvaWQg cGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5j RmlsZVdyaXRlckNsaWVudCogY2xpZW50KQoreworICAgIGNsaWVudC0+ZGlkVHJ1bmNhdGUoKTsK K30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEZpbGVFcnJvcjo6RXJyb3JD b2RlIGNvZGUpCit7CisgICAgY2xpZW50LT5kaWRGYWlsKGNvZGUpOworfQorCitBc3luY0ZpbGVX cml0ZXJDbGllbnRHdGs6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayhBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEFzeW5jRmlsZVdyaXRlckNsaWVudCog Y2xpZW50LCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3Rhc2tDb250cm9sbGVyKHRhc2tD b250cm9sbGVyKQorICAgICwgbV9jbGllbnQoY2xpZW50KQorICAgICwgbV90YXNrTW9kZShtb2Rl KQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnNldEN1cnJlbnRUYXNrTW9kZShtX3Rhc2tNb2Rl KTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFdyaXRlKGxvbmcgbG9u ZyBieXRlcywgYm9vbCBjb21wbGV0ZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2Fs bGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFdyaXRlQ2FsbGJhY2ssIEFs bG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBieXRlcywgY29tcGxldGUpLCBtX3Rhc2tN b2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKCkK K3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNr VGFzaygmcGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3Mo bV9jbGllbnQpKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrOjpkaWRGYWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAgbV90YXNrQ29u dHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRG YWlsQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBjb2RlKSwgbV90 YXNrTW9kZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJM RShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43YjQ1ZTFiYjA5OGYzODAwNjE3 YTE1OGNjYzFhYmQ4ZmY4NDI0OGI2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oCkBAIC0wLDAgKzEsNTggQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFp bC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdt YWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUg TGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBU aGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVz ZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25n IHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICog Qm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpZm5kZWYgQXN5bmNGaWxlV3JpdGVy Q2xpZW50R3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrX2gKKworI2lmIEVO QUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyQ2xpZW50LmgiCisKKyNpbmNsdWRl IDx3dGYvUGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFzeW5j RmlsZVdyaXRlckNsaWVudEd0ayA6IHB1YmxpYyBBc3luY0ZpbGVXcml0ZXJDbGllbnQgeworcHVi bGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNsaWVudEd0az4gY3Jl YXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgQXN5 bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFN0cmluZyYgbW9kZSkKKyAgICB7Cisg ICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKHRhc2tD b250cm9sbGVyLCBjbGllbnQsIG1vZGUpKTsKKyAgICB9CisKKyAgICB2b2lkIGRpZFdyaXRlKGxv bmcgbG9uZyBieXRlcywgYm9vbCBjb21wbGV0ZSk7CisgICAgdm9pZCBkaWRUcnVuY2F0ZSgpOwor ICAgIHZvaWQgZGlkRmFpbChGaWxlRXJyb3I6OkVycm9yQ29kZSk7CisKKyAgICBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIoKSB7IHJldHVybiBtX3Rhc2tD b250cm9sbGVyLmdldCgpOyB9CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgQXN5bmNGaWxlV3JpdGVyQ2xp ZW50KiwgY29uc3QgU3RyaW5nJik7CisKKyAgICBSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs+IG1fdGFza0NvbnRyb2xsZXI7CisgICAgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 KiBtX2NsaWVudDsKKyAgICBTdHJpbmcgbV90YXNrTW9kZTsKK307CisKK30gLy8gbmFtZXNwYWNl CisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAvLyBBc3luY0ZpbGVX cml0ZXJDbGllbnRHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVdyaXRlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlV3JpdGVyR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NTY5YWI3Mzc5MTA0YTM3MmExYzJhMzQz NjM5YTlmYTk4N2ZlNDIzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAKQEAgLTAsMCArMSwxNTUgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+Cisg KiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4K KyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwg b3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAq IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBN QSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJB c3luY0ZpbGVXcml0ZXJHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1 ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oIgorI2luY2x1ZGUgIkJsb2IuaCIKKyNpbmNs dWRlICJCbG9iUmVnaXN0cnlJbXBsLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisK KyNpbmNsdWRlIDxnaW8vZ2lvLmg+CisjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPHd0Zi9n b2JqZWN0L0dPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJHdGs+IEFzeW5jRmls ZVdyaXRlckd0azo6Y3JlYXRlKEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBBc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEdGaWxlKiBmaWxlKQor eworICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlV3JpdGVyR3RrKGNsaWVudCwgdGFz a0NvbnRyb2xsZXIsIGZpbGUpKTsKK30KKworQXN5bmNGaWxlV3JpdGVyR3RrOjpBc3luY0ZpbGVX cml0ZXJHdGsoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgR0ZpbGUqIGZpbGUpCisgICAgOiBtX2Ns aWVudChjbGllbnQpCisgICAgLCBtX3Rhc2tDb250cm9sbGVyKHRhc2tDb250cm9sbGVyKQorICAg ICwgbV9maWxlKGZpbGUpCit7Cit9CisKK3N0YXRpYyB2b2lkIHdyaXRlQXN5bmMoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrPiBoZWxw ZXJDbGllbnQsIEFzeW5jRmlsZVdyaXRlckd0ayogd3JpdGVyLCBHRmlsZSogZmlsZSwgbG9uZyBs b25nIHBvc2l0aW9uLCBCbG9iKiBkYXRhKQoreworICAgIGlmIChoZWxwZXJDbGllbnQtPnRhc2tD b250cm9sbGVyKCktPmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KHdyaXRlcikpIHsKKyAgICAgICAg aGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6QUJPUlRfRVJSKTsKKyAgICAgICAgcmV0 dXJuOworICAgIH0KKworICAgIEdSZWZQdHI8R0ZpbGVJT1N0cmVhbT4gaW9TdHJlYW0gPSBhZG9w dEdSZWYoZ19maWxlX29wZW5fcmVhZHdyaXRlKGZpbGUsIDAsIDApKTsKKyAgICBpZiAoIWlvU3Ry ZWFtKSB7CisgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VO RF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR093blB0cjxHT3V0cHV0U3Ry ZWFtPiBvdXRwdXRTdHJlYW0oZ19pb19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0oR19JT19TVFJF QU0oaW9TdHJlYW0uZ2V0KCkpKSk7CisgICAgaWYgKCFnX3NlZWthYmxlX3NlZWsoR19TRUVLQUJM RShvdXRwdXRTdHJlYW0uZ2V0KCkpLCBwb3NpdGlvbiwgR19TRUVLX1NFVCwgMCwgMCkpIHsKKyAg ICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBSZWZQdHI8QmxvYlN0b3JhZ2VEYXRhPiBibG9i U3RvcmFnZSA9IHN0YXRpY19jYXN0PEJsb2JSZWdpc3RyeUltcGwmPihibG9iUmVnaXN0cnkoKSku Z2V0QmxvYkRhdGFGcm9tVVJMKGRhdGEtPnVybCgpKTsKKyAgICBpZiAoYmxvYlN0b3JhZ2UpIHsK KyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBibG9iU3RvcmFnZS0+aXRlbXMoKS5zaXpl KCk7IGkrKykgeworICAgICAgICAgICAgY29uc3QgQmxvYkRhdGFJdGVtJiBibG9iSXRlbSA9IGJs b2JTdG9yYWdlLT5pdGVtcygpW2ldOworICAgICAgICAgICAgaWYgKGJsb2JJdGVtLnR5cGUgPT0g QmxvYkRhdGFJdGVtOjpEYXRhKSB7CisgICAgICAgICAgICAgICAgZ3NpemUgYnl0ZXNXcml0dGVu ID0gMDsKKyAgICAgICAgICAgICAgICBnX291dHB1dF9zdHJlYW1fd3JpdGVfYWxsKEdfT1VUUFVU X1NUUkVBTShvdXRwdXRTdHJlYW0uZ2V0KCkpLCBibG9iSXRlbS5kYXRhLT5kYXRhKCksIGJsb2JJ dGVtLmRhdGEtPmxlbmd0aCgpLCAmYnl0ZXNXcml0dGVuLCAwLCAwKTsKKworICAgICAgICAgICAg ICAgIGJvb2wgY29tcGxldGVkID0gYmxvYlN0b3JhZ2UtPml0ZW1zKCkuc2l6ZSgpID09IChpICsg MSk7CisgICAgICAgICAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRXcml0ZShieXRlc1dyaXR0ZW4s IGNvbXBsZXRlZCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQg QXN5bmNGaWxlV3JpdGVyR3RrOjp3cml0ZShsb25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEp Cit7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisK KyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFj a1Rhc2soJndyaXRlQXN5bmMsIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKG1fdGFz a0NvbnRyb2xsZXIuZ2V0KCksIG1fY2xpZW50LCBtb2RlKSwgQWxsb3dDcm9zc1RocmVhZEFjY2Vz cyh0aGlzKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2ZpbGUuZ2V0KCkpLCBwb3NpdGlvbiwg QWxsb3dDcm9zc1RocmVhZEFjY2VzcyhkYXRhKSkpOworfQorCitzdGF0aWMgdm9pZCB0cnVuY2F0 ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRl ckNsaWVudEd0az4gaGVscGVyQ2xpZW50LCBBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlciwgR0Zp bGUqIGZpbGUsIGxvbmcgbG9uZyBsZW5ndGgpCit7CisgICAgaWYgKGhlbHBlckNsaWVudC0+dGFz a0NvbnRyb2xsZXIoKS0+Y2FuY2VsV3JpdGVySWZOZWNlc3Nhcnkod3JpdGVyKSkgeworICAgICAg ICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpBQk9SVF9FUlIpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGZpbGVJbmZvID0gYWRvcHRH UmVmKGdfZmlsZV9xdWVyeV9pbmZvKGZpbGUsICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwg MCwgMCkpOworICAgIGlmICghZmlsZUluZm8pIHsKKyAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRG YWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICBsb25nIGxvbmcgZmlsZUxlbmd0aCA9IHN0YXRpY19jYXN0PGxvbmcgbG9uZz4oZ19maWxl X2luZm9fZ2V0X3NpemUoZmlsZUluZm8uZ2V0KCkpKTsKKyAgICBpZiAobGVuZ3RoID4gZmlsZUxl bmd0aCkgeworICAgICAgICBHT3duUHRyPEdTdHJpbmc+IHplcm9QYWRkaW5nKGdfc3RyaW5nX25l d19sZW4oMCwgbGVuZ3RoIC0gZmlsZUxlbmd0aCkpOworICAgICAgICBkbyB7CisgICAgICAgICAg ICBnX3N0cmluZ19hcHBlbmRfYyh6ZXJvUGFkZGluZy5nZXQoKSwgJ1wwJyk7CisgICAgICAgIH0g d2hpbGUgKC0tbGVuZ3RoID4gZmlsZUxlbmd0aCk7CisKKyAgICAgICAgR1JlZlB0cjxHRmlsZUlP U3RyZWFtPiBpb1N0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfb3Blbl9yZWFkd3JpdGUoZmlsZSwg MCwgMCkpOworICAgICAgICBpZiAoIWlvU3RyZWFtKSB7CisgICAgICAgICAgICBoZWxwZXJDbGll bnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgfQorCisgICAgICAgIEdPd25QdHI8R091dHB1dFN0cmVhbT4gb3V0cHV0U3Ry ZWFtKGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKEdfSU9fU1RSRUFNKGlvU3RyZWFtLmdl dCgpKSkpOworICAgICAgICBpZiAoIWdfc2Vla2FibGVfc2VlayhHX1NFRUtBQkxFKG91dHB1dFN0 cmVhbS5nZXQoKSksIGxlbmd0aCwgR19TRUVLX1NFVCwgMCwgMCkpIHsKKyAgICAgICAgICAgIGhl bHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICAg ICAgcmV0dXJuOworICAgICAgICB9CisKKyAgICAgICAgZ3NpemUgYnl0ZXNXcml0dGVuID0gMDsK KyAgICAgICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlX2FsbChHX09VVFBVVF9TVFJFQU0ob3V0cHV0 U3RyZWFtLmdldCgpKSwgemVyb1BhZGRpbmctPnN0ciwgemVyb1BhZGRpbmctPmxlbiwgJmJ5dGVz V3JpdHRlbiwgMCwgMCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgR1JlZlB0cjxHRmlsZU91dHB1 dFN0cmVhbT4gZmlsZU91dHB1dFN0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfcmVwbGFjZShmaWxl LCAwLCBmYWxzZSwgR19GSUxFX0NSRUFURV9OT05FLCAwLCAwKSk7CisgICAgICAgIGlmICghZmls ZU91dHB1dFN0cmVhbSB8fCAhZ19zZWVrYWJsZV90cnVuY2F0ZShHX1NFRUtBQkxFKGZpbGVPdXRw dXRTdHJlYW0uZ2V0KCkpLCBsZW5ndGgsIDAsIDApKSB7CisgICAgICAgICAgICBoZWxwZXJDbGll bnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgfQorICAgIH0KKworICAgIGhlbHBlckNsaWVudC0+ZGlkVHJ1bmNhdGUoKTsK K30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OnRydW5jYXRlKGxvbmcgbG9uZyBsZW5ndGgp Cit7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisK KyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFj a1Rhc2soJnRydW5jYXRlQXN5bmMsIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKG1f dGFza0NvbnRyb2xsZXIuZ2V0KCksIG1fY2xpZW50LCBtb2RlKSwgQWxsb3dDcm9zc1RocmVhZEFj Y2Vzcyh0aGlzKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2ZpbGUuZ2V0KCkpLCBsZW5ndGgp KTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OmFib3J0KCkKK3sKKyAgICBtX3Rhc2tD b250cm9sbGVyLT5zZXRXcml0ZXJUb0NhbmNlbCh0aGlzKTsKK30KKworYm9vbCBBc3luY0ZpbGVX cml0ZXJHdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAgICByZXR1cm4gbV90 YXNrQ29udHJvbGxlci0+c3luY2hyb25vdXMoKSA/IG1fdGFza0NvbnRyb2xsZXItPndhaXRGb3JP cGVyYXRpb25Ub0NvbXBsZXRlKCkgOiBmYWxzZTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU5ZmJhNGQ1Y2Rh YmJjMTYxNGI4NjU0MTA3NDk3ZTM0OWQ0NzczZTYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgKQEAgLTAsMCArMSw1OCBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdt YWlsLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dA Z21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAq IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZl ZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxv bmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3 YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisg KiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRlZiBBc3luY0ZpbGVXcml0 ZXJHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVXcml0ZXJHdGtfaAorCisjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyLmgiCisKKyNpbmNsdWRlIDx3dGYv UGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KKworbmFtZXNw YWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0ZpbGVXcml0ZXJDbGllbnQ7CitjbGFzcyBBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVyR3Rr IDogcHVibGljIEFzeW5jRmlsZVdyaXRlciB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25Q dHI8QXN5bmNGaWxlV3JpdGVyR3RrPiBjcmVhdGUoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiwgQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBHRmlsZSopOworCisgICAgdm9pZCBhYm9y dCgpOworICAgIHZvaWQgdHJ1bmNhdGUobG9uZyBsb25nIGxlbmd0aCk7CisgICAgdm9pZCB3cml0 ZShsb25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEpOworCisgICAgYm9vbCB3YWl0Rm9yT3Bl cmF0aW9uVG9Db21wbGV0ZSgpOworCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVdyaXRlckd0ayhB c3luY0ZpbGVXcml0ZXJDbGllbnQqLCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayos IEdGaWxlKik7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIG1fY2xpZW50OworICAgIFJl ZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90YXNrQ29udHJvbGxlcjsK KyAgICBHUmVmUHRyPEdGaWxlPiBtX2ZpbGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAvLyBBc3luY0ZpbGVX cml0ZXJHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2Fs RmlsZVN5c3RlbUd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxl U3lzdGVtR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wYzk0MDFjNzBiZjk5NDcyOWRkMzBjZWE3Mzc5OGVj MWRlZGZkNzk0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAKQEAgLTAsMCArMSw1OCBAQAorLyoKKyAqICBDb3B5cmln aHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisgKiAg VGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFu ZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2Vu ZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogIEZvdW5k YXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEg IDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJM b2NhbEZpbGVTeXN0ZW0uaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUg PGd0ay9ndGsuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisjaW5jbHVkZSA8d3RmL2dv YmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KKyNpbmNs dWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBM b2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBi YXNlUGF0aCkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR093blB0cjxHRGly PiBkaXJlY3RvcnkoZ19kaXJfb3BlbihiYXNlUGF0aC51dGY4KCkuZGF0YSgpLCAwLCAmZXJyb3Iu b3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IgJiYgZXJyb3ItPmNvZGUgPT0gR19GSUxFX0VSUk9S X05PRU5UKSB7CisgICAgICAgIEdSZWZQdHI8R0ZpbGU+IGJhc2VEaXJlY3RvcnlGaWxlID0gYWRv cHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoYmFzZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAg ICAgICBnX2ZpbGVfbWFrZV9kaXJlY3RvcnkoYmFzZURpcmVjdG9yeUZpbGUuZ2V0KCksIDAsIDAp OworICAgIH0KK30KKworTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmls ZVN5c3RlbSgpCit7CisgICAgV1RGOjpsb2NrQXRvbWljYWxseUluaXRpYWxpemVkU3RhdGljTXV0 ZXgoKTsKKyAgICBpZiAoIXNfaW5zdGFuY2UpIHsKKyAgICAgICAgR093blB0cjxnY2hhcj4gYmFz ZVBhdGgoZ19idWlsZF9maWxlbmFtZShnX2dldF91c2VyX2RhdGFfZGlyKCksICJ3ZWJraXQiLCAi ZmlsZXN5c3RlbSIsIE5VTEwpKTsKKyAgICAgICAgT3duUHRyPExvY2FsRmlsZVN5c3RlbT4gbG9j YWxGaWxlU3lzdGVtID0gYWRvcHRQdHIobmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aC5nZXQo KSkpOworICAgICAgICBsb2NhbEZpbGVTeXN0ZW0tPmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0o U3RyaW5nKGJhc2VQYXRoLmdldCgpKSk7CisKKyAgICAgICAgc19pbnN0YW5jZSA9IGxvY2FsRmls ZVN5c3RlbS5sZWFrUHRyKCk7CisgICAgfQorICAgIFdURjo6dW5sb2NrQXRvbWljYWxseUluaXRp YWxpemVkU3RhdGljTXV0ZXgoKTsKKyAgICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK30KKwor I2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0No YW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4MTQ0YjA0ZGYwMmRmMWQ5OThm ZTNiNmMxNDliNmZkN2U5NzhlZjQ1Li5lN2Q5N2NmMDIyNjMzNDNjNWFjMWFjNDBjZjNkNzcxNDMx NmQwYjQzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTItMDQtMDQgIENoYW5nU2VvayBPaCAg PHNoaXZhbWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUg c3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NTg0NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBBbGwgbW9zdCB0ZXN0cyBpbiBmYXN0L2ZpbGVzeXN0ZW0gYXJlIHBhc3NlZCBleGNlcHQgdGhl IG9uZXMgcmVsYXRlZCB3aXRoIHdvcmtlci4KKyAgICAgICAgRm9sbG93aW5nIHRlc3RzIGFyZSBw YXNzZWQgaW4gZGV0YWlsLgorICAgICAgICBmYXN0L2ZpbGVzeXN0ZW0vKi5odG1sCisgICAgICAg IGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5odG1sCisgICAgICAg IGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2IuaHRtbAorICAg ICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1ibG9iLWZhaWwu aHRtbAorCisgICAgICAgIEJ1dCBGaWxlU3lzdGVtIEFQSSBpcyBub3QgdGhlIGRlZmF1bHQgZW5h YmxlZCBmZWF0dXJlIGFuZCB1bmNvbXBsZXRlZCwKKyAgICAgICAgc28gd2UgbmVlZCB0byBrZWVw IHRoZW0gc2tpcHBlZC4KKworICAgICAgICAqIHBsYXRmb3JtL2d0ay9Ta2lwcGVkOgorCiAyMDEy LTA0LTA0ICBQaGlsaXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KIAogICAgICAg ICBVbnJldmlld2VkLCBHVEsgaW5zcGVjdG9yIGdhcmRlbmluZy4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1Nr aXBwZWQKaW5kZXggMTcyZjQwZmM1NmFlNTQ0NmZiNTg2YWZlMjg0ZmNkZTE1ZjJkNmY3YS4uZDhj ZDBhYWEyMzA2YTM4YTI5ZjY2YmMzNDg5NDgzNWZmZGIwYzQzNSAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3Rr L1NraXBwZWQKQEAgLTMwMSwxNSArMzAxLDIyIEBAIGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmct c2xvdy1sb2FkLnBocAogaHR0cC90ZXN0cy9taXNjL3dlYnRpbWluZy1zc2wucGhwCiBodHRwL3Rl c3RzL21pc2Mvd2VidGltaW5nLXR3by1yZWRpcmVjdHMucGhwCiAKLSMgRmlsZVN5c3RlbSBBUEkg aXMgbm90IHN1cHBvcnRlZC4KKyMgRm9sbG93aW5nIHRlc3RzIGFyZSBwYXNzZWQsIGlmIEZpbGVT eXN0ZW0gQVBJIGZlYXR1cmUgaXMgZW5hYmxlZC4KIGZhc3QvZmlsZXN5c3RlbQotaHR0cC90ZXN0 cy9maWxlc3lzdGVtCi1odHRwL3Rlc3RzL3NlY3VyaXR5L2ZpbGVzeXN0ZW0taWZyYW1lLWZyb20t cmVtb3RlLmh0bWwKIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJs b2IuaHRtbAogaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi1m YWlsLmh0bWwKLWh0dHAvdGVzdHMvd29ya2Vycy90ZXJtaW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0 aW9uLmh0bWwKKyMgUGFzc2VkIGJ1dCB3ZSBzaG91bGQgZW5hYmxlIGZpbGUtc3lzdGVtICYgbXV0 YXRpb24tb2JzZXJ2ZXJzIGF0IHRoZSBzYW1lIHRpbWUuCiBmYXN0L211dGF0aW9uL2ZpbGVzeXN0 ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRtbAogCisjIEZpbGVTeXN0ZW0gQVBJIGlzIG5vdCBzdXBw b3J0ZWQgY29tcGxldGVseS4KKyMgaHR0cDovL3dlYmtpdC5vcmcvYi84MzEzNworZmFzdC9maWxl c3lzdGVtL2ZsYWdzLXBhc3NpbmcuaHRtbAorIyBXZSBkb24ndCBzdXBwb3J0IHdvcmtlcnMgZm9y IEZpbGVTeXN0ZW0geWV0LiBodHRwOi8vd2Via2l0Lm9yZy9iLzgyODU0CitmYXN0L2ZpbGVzeXN0 ZW0vd29ya2VycworaHR0cC90ZXN0cy9maWxlc3lzdGVtCitodHRwL3Rlc3RzL3NlY3VyaXR5L2Zp bGVzeXN0ZW0taWZyYW1lLWZyb20tcmVtb3RlLmh0bWwKK2h0dHAvdGVzdHMvd29ya2Vycy90ZXJt aW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0aW9uLmh0bWwKKwogIyBSZXF1aXJlcyBXZWJQIHN1cHBv cnQuCiBmYXN0L2NhbnZhcy9jYW52YXMtdG9EYXRhVVJMLXdlYnAuaHRtbAogZmFzdC9pbWFnZXMv d2VicC1pbWFnZS1kZWNvZGluZy5odG1sCg== 135795 2012-04-05 03:15:12 -0700 2012-04-09 07:32:04 -0700 Patch bug-58443-20120405191511.patch text/plain 72266 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzMzA1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGU3YmY3NDYzYTIwYTJkMDRkYzk1M2Fl ZjBhMjFhNmM3OTcxOTJhNWQuLjJhNmU5ZjZmZWExOWIxNGFjYTYxNGYxNDFiNjk2YmIxMWQyNTZk N2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMDUgIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDogQWRkZWQgdHlwZSBkZWZpbml0aW9ucywgR0ZpbGVJT1N0cmVh bSwgR091dHB1dFN0cmVhbSwgR1N0cmluZy4KKwogMjAxMi0wNC0wNCAgUGF0cmljayBHYW5zdGVy ZXIgIDxwYXJvZ2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBBZGQgV1RGOjpnZXRDdXJyZW50TG9j YWxUaW1lKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCBkMTBjMDBlNzA4ZWRjYzNiMmVlYjM3ZmRlNzU0MzBjOTU2 MjA3MGNhLi4xMTJiODhiZGUwZmQ5MDg4OWJjMTM3YTFlYmI1NjJmOGQyYzliZTY4IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTM4IEBACisyMDEyLTA0LTA1ICBDaGFuZ1Nlb2sgT2ggIDxzaGl2YW1p ZG93QGdtYWlsLmNvbT4KKworICAgICAgICBbR1RLXSBTdXBwb3J0IHRoZSBmaWxlIHN5c3RlbSBB UEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU4NDQz CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBw YXRjaCBpcyBiYXNlZCBvbiBaYW4gRG9iZXJzZWsncyBvcmlnaW5hbCBvbmUgZm9yIGJ1ZzU4NDQz LgorICAgICAgICBUaGlzIGJyaW5ncyBGaWxlU3lzdGVtIEFQSSB0byBndGsgcG9ydC4gVGhpcyBh ZGRzIG5ldyBpbnRlcmZhY2VzIGxpa2UKKyAgICAgICAgQXN5bmNGaWxlU3lzdGVtR3RrLCBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGssIEFzeW5jRmlsZVdyaXRlckd0aywgQXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrCisgICAgICAgIGFuZCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ay4gVGhlc2UgYXJlIGNoaWxkIGNsYXNzZXMgaW1wbGVtZW50aW5nIHRoZSBpbnRlcmZhY2VzCisg ICAgICAgIG9mIGVhY2ggcGFyZW50IGNsYXNzZXMgZXhjZXB0IEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrLiBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0aworICAgICAgICBp cyBhIGhlbHBlciBjbGFzcy4gSXQgcmV0YWlucyBzb21lIHVzZWZ1bCB2YXJpYWJsZXMsIGFuZCBj b250cm9scyBwb3N0aW5nIHRhc2tzIHRvCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQg d2hpY2ggbWlnaHQgYmUgZWl0aGVyIGEgRG9jdW1lbnQgb2JqZWN0IG9yIGEgV29ya2VyLgorICAg ICAgICBVbmZvcnR1bmF0ZWx5LCBXb3JrZXIgZm9yIGZpbGVzeXN0ZW0gaXMgbm90IHN1cHBvcnRl ZCB5ZXQsIEkgcGxhbiB0byBzdXBwb3J0IGl0IGluIHRoZSBuZXh0IHBhdGNoLgorCisgICAgICAg IFRlc3Q6IGZhc3QvZmlsZXN5c3RlbS8qLmh0bWwKKyAgICAgICAgICAgICAgZmFzdC9tdXRhdGlv bi9maWxlc3lzdGVtLWNhbGxiYWNrLWRlbGl2ZXJ5Lmh0bWwKKyAgICAgICAgICAgICAgaHR0cC90 ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi5odG1sCisgICAgICAgICAg ICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2ItZmFpbC5o dG1sCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOiBBZGRlZCBzb21lIGZpbGVzIHRv IGJ1aWxkIG5ld2x5IGZvciBGaWxlU3lzdGVtLgorICAgICAgICAqIE1vZHVsZXMvZmlsZXN5c3Rl bS9Mb2NhbEZpbGVTeXN0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJD b3JlOjpvcGVuRmlsZVN5c3RlbSk6IENyZWF0ZWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr IGluc3RlYWQgb2YgdXNpbmcgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzIGl0c2VsZi4KKyAgICAg ICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVhZEZpbGVTeXN0ZW0pOiBBZGRlZCBtaXNz aW5nIGFyZ3VtZW50IG5hbWUuCisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJl cXVlc3RGaWxlU3lzdGVtKTogQWRkZWQgbWlzc2luZyBhcmd1bWVudCBuYW1lLgorICAgICAgICAq IHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwOiBBZGRlZC4gVGhp cyBpcyBhbiBpbXBsZW1lbnRhdGlvbiBvZiBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuCisgICAg ICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6Ojo6Y29weSk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0ayk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrKToKKyAg ICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkU3VjY2VlZCk6 CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjayk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZE9wZW5GaWxl U3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRSZWFkTWV0YWRhdGFDYWxsYmFj ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJl YWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmRpZFJlYWREaXJlY3RvcnlFbnRyeSk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlk UmVhZERpcmVjdG9yeUVudHJpZXNBbmRGaW5pc2hlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNv cmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkUmVhZERpcmVjdG9yeUVudHJpZXMp OgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZENyZWF0 ZUZpbGVXcml0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZEZhaWxDYWxsYmFjayk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZEZhaWwp OgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaDog QWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrc0d0ayk6CisgICAgICAgIChEaXJlY3RvcnlFbnRyeSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OkRpcmVjdG9yeUVudHJ5OjpEaXJlY3RvcnlFbnRy eSk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5jcHA6IEFkZGVk IHNvbWUgbWlzc2luZyBBUElzLiBUaGlzIGlzIGEgY2hpbGQgY2xhc3Mgb2YgQXN5bmNGaWxlU3lz dGVtLgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06OmlzVmFsaWRUeXBlKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0pOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpBc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp+QXN5bmNGaWxlU3lzdGVtR3RrKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6dG9VUkwpOgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgIChXZWJDb3JlOjptb3ZlQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtR3RrOjptb3ZlKToKKyAgICAgICAgKFdlYkNvcmU6OmNvcHlSZWN1cnNpdmVs eSk6CisgICAgICAgIChXZWJDb3JlOjpjb3B5QXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtR3RrOjpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6OnJlbW92ZUZpbGUpOgor ICAgICAgICAoV2ViQ29yZTo6cmVtb3ZlQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlU3lzdGVtR3RrOjpyZW1vdmUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVt R3RrOjpyZW1vdmVSZWN1cnNpdmVseSk6CisgICAgICAgIChXZWJDb3JlOjpyZWFkTWV0YWRhdGFB c3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWRNZXRhZGF0 YSk6CisgICAgICAgIChXZWJDb3JlOjpjcmVhdGVPYmplY3RBc3luYyk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZU9iamVjdCk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZUZpbGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3RvcnkpOgorICAgICAgICAoV2ViQ29yZTo6b2Jq ZWN0RXhpc3RzQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpm aWxlRXhpc3RzKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6ZGlyZWN0 b3J5RXhpc3RzKToKKyAgICAgICAgKFdlYkNvcmU6OnJlYWREaXJlY3RvcnlBc3luYyk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWREaXJlY3RvcnkpOgorICAgICAg ICAoV2ViQ29yZTo6Y3JlYXRlV3JpdGVyQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlU3lzdGVtR3RrOjpjcmVhdGVXcml0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl U3lzdGVtR3RrOjpjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEpOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpzZXRUYXNrQ29udHJvbGxlcik6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJM KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6d2FpdEZvck9wZXJhdGlv blRvQ29tcGxldGUpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsu aDoKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoQXN5bmNGaWxlU3lzdGVtR3RrKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3Bw OiBBZGRlZC4gVGhpcyBpcyBhIGhlbHBlciBjbGFzcyB0byBjb250cm9sIHBvc3RpbmcgdGFzayB0 byBhIHRhcmdldCB0aHJlYWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OkFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjp+QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGspOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnVuaXF1ZU1vZGUp OgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBv c3RUYXNrVG9NYWluVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrOjpzZXRDdXJyZW50VGFza01vZGUpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBvc3RDYWxsYmFja1Rhc2spOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OndhaXRGb3JP cGVyYXRpb25Ub0NvbXBsZXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrOjpjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSk6CisgICAgICAgICogcGxh dGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmg6IEFkZGVkLgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6 c3luY2hyb25vdXMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs6OnNldFdyaXRlclRvQ2FuY2VsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmNwcDogQWRkZWQuIFRoaXMgaXMgYSBjaGlsZCBjbGFzcyBp bXBsZW1lbnQgb2YgQXlzbmNGaWxlV3JpdGVyQ2xpZW50LgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkV3JpdGVDYWxsYmFjayk6CisgICAgICAgIChXZWJD b3JlOjpwZXJmb3JtRGlkVHJ1bmNhdGVDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpwZXJm b3JtRGlkRmFpbENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckNs aWVudEd0azo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkV3JpdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRUcnVuY2F0ZSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZEZhaWwpOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKEFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGs6OnRhc2tDb250cm9sbGVyKToKKyAgICAgICAgKiBwbGF0Zm9y bS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcDogQWRkZWQuIFRoaXMgaXMgYSBjaGlsZCBjbGFz cyBvZiBBc3luY0ZpbGVXcml0ZXIuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNv cmU6OkFzeW5jRmlsZVdyaXRlckd0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckd0azo6QXN5bmNGaWxlV3JpdGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6Ondy aXRlQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjp3cml0ZSk6 CisgICAgICAgIChXZWJDb3JlOjp0cnVuY2F0ZUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVdyaXRlckd0azo6dHJ1bmNhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl V3JpdGVyR3RrOjphYm9ydCk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6 OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlV3JpdGVyR3RrLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChB c3luY0ZpbGVXcml0ZXJHdGspOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Mb2NhbEZpbGVTeXN0 ZW1HdGsuY3BwOiBBZGRlZC4gU29tZSBwb3J0IHNwZWNpZmljIGZ1bmN0aW9ucyBhcmUgZXh0cmFj dGVkIGZyb20gTG9jYWxGaWxlU3lzdGVtLmNwcCBhbmQgYWRkZWQgaW4gaGVyZS4KKyAgICAgICAg KFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjppbml0aWFsaXpl TG9jYWxGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6bG9j YWxGaWxlU3lzdGVtKToKKwogMjAxMi0wNC0wNSAgU3VkYXJzYW5hIE5hZ2luZW5pICA8c3VkYXJz YW5hLm5hZ2luZW5pQGxpbnV4LmludGVsLmNvbT4KIAogICAgICAgICBbRUZMXSBrZXljb2RlIHRy YW5zbGF0aW9uIGlzIHdyb25nIGZvciBmdW5jdGlvbiBrZXlzCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3du UHRyLmNwcAppbmRleCBkZmUxODdkNzg4N2ZmNTRlYTAyN2MxYzlkYzVjMDZiZDdiZGI1Y2YxLi4z YWEwNzU5OTQ3NmQ3NGUyMmZkZjRlN2NkMGU4NTc3YTI4MTU5MmI0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dvYmpl Y3QvR093blB0ci5jcHAKQEAgLTQyLDYgKzQyLDE2IEBAIHRlbXBsYXRlIDw+IHZvaWQgZnJlZU93 bmVkR1B0cjxHU0xpc3Q+KEdTTGlzdCogcHRyKQogICAgIGdfc2xpc3RfZnJlZShwdHIpOwogfQog Cit0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1N0cmluZz4oR1N0cmluZyogcHRyKQor eworICAgIGdfc3RyaW5nX2ZyZWUocHRyLCB0cnVlKTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBm cmVlT3duZWRHUHRyPEdPdXRwdXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qIHB0cikKK3sKKyAgICBn X291dHB1dF9zdHJlYW1fY2xvc2UocHRyLCAwLCAwKTsKK30KKwogdGVtcGxhdGUgPD4gdm9pZCBm cmVlT3duZWRHUHRyPEdQYXR0ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKiBwdHIpCiB7CiAgICAgaWYg KHB0cikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oIGIvU291 cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKaW5kZXggNGIyZGNiNzdiMjUwMDBjMmU1YjY4 MDhhNGM3NDg0YzJiZTZkNmNhNS4uOWMwNjdkNzFhNjc5NTVjYzRiZjhkOGZjOGRkZjIwZDliMjJh MWM3MSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKKysrIGIv U291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKQEAgLTM2LDYgKzM2LDggQEAgdGVtcGxh dGUgPHR5cGVuYW1lIFQ+IGlubGluZSB2b2lkIGZyZWVPd25lZEdQdHIoVCogcHRyKTsKIHRlbXBs YXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdFcnJvcj4oR0Vycm9yKik7CiB0ZW1wbGF0ZTw+IHZv aWQgZnJlZU93bmVkR1B0cjxHTGlzdD4oR0xpc3QqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3du ZWRHUHRyPEdTTGlzdD4oR1NMaXN0Kik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxH U3RyaW5nPihHU3RyaW5nKik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHT3V0cHV0 U3RyZWFtPihHT3V0cHV0U3RyZWFtKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxH UGF0dGVyblNwZWM+KEdQYXR0ZXJuU3BlYyopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQ dHI8R0Rpcj4oR0RpciopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1RpbWVyPihH VGltZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmgg Yi9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5oCmluZGV4IGUyOTI1MGJlZjJlZjRk NWU5ZWJlNWMyYjA1MDM3M2JiYTg1NjRmOWEuLjdhNWU5ZjNjYTA3ZGE1NWU1NjhjNTcxZDRlNWJj OWY4NTQ1ZWI1MjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZz LmgKKysrIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaApAQCAtNDgsMTcgKzQ4 LDIwIEBAIHR5cGVkZWYgc3RydWN0IF9HZGtFdmVudEV4cG9zZSBHZGtFdmVudEV4cG9zZTsKIHR5 cGVkZWYgc3RydWN0IF9HZGtQaXhidWYgR2RrUGl4YnVmOwogdHlwZWRlZiBzdHJ1Y3QgX0dFcnJv ciBHRXJyb3I7CiB0eXBlZGVmIHN0cnVjdCBfR0ZpbGUgR0ZpbGU7Cit0eXBlZGVmIHN0cnVjdCBf R0ZpbGVJT1N0cmVhbSBHRmlsZUlPU3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dIYXNoVGFibGUg R0hhc2hUYWJsZTsKIHR5cGVkZWYgc3RydWN0IF9HSW5wdXRTdHJlYW0gR0lucHV0U3RyZWFtOwog dHlwZWRlZiBzdHJ1Y3QgX0dMaXN0IEdMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluQ29udGV4 dCBHTWFpbkNvbnRleHQ7CiB0eXBlZGVmIHN0cnVjdCBfR01haW5Mb29wIEdNYWluTG9vcDsKK3R5 cGVkZWYgc3RydWN0IF9HT3V0cHV0U3RyZWFtIEdPdXRwdXRTdHJlYW07CiB0eXBlZGVmIHN0cnVj dCBfR1BhdHRlcm5TcGVjIEdQYXR0ZXJuU3BlYzsKIHR5cGVkZWYgc3RydWN0IF9HUG9sbGFibGVP dXRwdXRTdHJlYW0gR1BvbGxhYmxlT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dTTGlz dCBHU0xpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfR1NvY2tldENsaWVudCBHU29ja2V0Q2xpZW50Owog dHlwZWRlZiBzdHJ1Y3QgX0dTb2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25uZWN0aW9uOwogdHlw ZWRlZiBzdHJ1Y3QgX0dTb3VyY2UgR1NvdXJjZTsKK3R5cGVkZWYgc3RydWN0IF9HU3RyaW5nIEdT dHJpbmc7CiB0eXBlZGVmIHN0cnVjdCBfR1ZhcmlhbnQgR1ZhcmlhbnQ7CiB0eXBlZGVmIHVuaW9u IF9HZGtFdmVudCBHZGtFdmVudDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIgR1RpbWVyOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJD b3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggNDA4Y2JjZWY1MzgyMmFlZWYxZDYyZWU5M2Ux OWE3NmNkMzA3OWY4Ny4uYzM4MjEzZDM3OTU1NGQ1NzJkMmI3MDIwMzFkZjMwZWI5ODY2NzI0ZCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC00Njc3LDYgKzQ2NzcsNyBAQCB3ZWJj b3JlZ3RrX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HdGtWZXJz aW9uaW5nLmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9LZXlCaW5kaW5nVHJhbnNs YXRvci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9LZXlCaW5kaW5nVHJhbnNs YXRvci5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxlU3lzdGVtR3Rr LmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2FsaXplZFN0cmluZ3NHdGsu Y3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTWFpbkZyYW1lU2Nyb2xsYmFyR3Rr LmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL01haW5GcmFtZVNjcm9sbGJhckd0 ay5oIFwKQEAgLTQ5NzAsOCArNDk3MSwxNiBAQCBkb21fYmluZGluZ19pZGxzICs9IFwKIAkkKFdl YkNvcmUpL01vZHVsZXMvZmlsZXN5c3RlbS9Xb3JrZXJDb250ZXh0RmlsZVN5c3RlbS5pZGwKIAog d2ViY29yZWd0a19zb3VyY2VzICs9IFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBcCi0JU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVN5c3RlbUd0ay5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBcCisJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHAgXAorCVNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCBcCisJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAgXAorCVNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaAogZW5kaWYgIyBFTkQg RU5BQkxFX0ZJTEVfU1lTVEVNCiAKICMgLS0tLQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv TW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA4ZjAxNjllZWFiYmE5 M2ZmNGYxNTZkN2MyMzQ3YjZjMGIyN2Q1YmJhLi5hMWI2Y2FhYmQ4NmEzN2I5NjU0MGVmNmU2NzQ1 ZTZhODQ4NDYyYTJhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0 ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVz eXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtNDksMTAgKzQ5LDE1IEBACiAjaW5jbHVkZSA8 d3RmL01haW5UaHJlYWQuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogCisjaWYgUExB VEZPUk0oR1RLKQorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorI2Vu ZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogTG9jYWxGaWxlU3lzdGVtKiBMb2NhbEZpbGVT eXN0ZW06OnNfaW5zdGFuY2UgPSAwOwogCisjaWYgIVBMQVRGT1JNKEdUSykKIHZvaWQgTG9jYWxG aWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBh dGgpCiB7CiAgICAgLy8gRklYTUU6IFNob3VsZCBpbml0aWFsaXplIHRoZSBxdW90YSBzZXR0aW5n cyBhcyB3ZWxsLgpAQCAtNzEsMjcgKzc2LDMyIEBAIExvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxl U3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQogICAgIEFTU0VSVChzX2luc3RhbmNlKTsKICAgICBy ZXR1cm4gKnNfaW5zdGFuY2U7CiB9CisjZW5kaWYKIAogU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6 ZmlsZVN5c3RlbUJhc2VQYXRoKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9iYXNlUGF0aDsKIH0K IAotc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNv bnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGJvb2wgY3JlYXRlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY2FsbGJhY2tzKQorc3RhdGljIHZvaWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3Qg U3RyaW5nJiBpZGVudGlmaWVyLCBBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlwZSwgYm9vbCBjcmVh dGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wg c3luY2hyb25vdXMpCiB7CisjaWYgUExBVEZPUk0oR1RLKQorICAgIEFzeW5jRmlsZVN5c3RlbTo6 b3BlbkZpbGVTeXN0ZW0oYmFzZVBhdGgsIGlkZW50aWZpZXIsIHR5cGUsIGNyZWF0ZSwgQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoY29udGV4dCwgY2FsbGJhY2tzLCBzeW5jaHJv bm91cykpOworI2Vsc2UKICAgICBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGJhc2VQ YXRoLCBpZGVudGlmaWVyLCB0eXBlLCBjcmVhdGUsIGNhbGxiYWNrcyk7CisjZW5kaWYKIH0KIAot dm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sKQordm9pZCBMb2NhbEZpbGVTeXN0 ZW06OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5j RmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQogewogICAgIC8vIEFzeW5jRmlsZVN5c3Rl bTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNvIHRoZSBt ZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgotICAgIGNvbnRleHQtPnBv c3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNl UGF0aCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwg dHlwZSwgZmFsc2UsIGNhbGxiYWNrcykpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgZmFsc2UsIGNh bGxiYWNrcywgc3luY2hyb25vdXMpKTsKIH0KIAotdm9pZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVl c3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5 c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MsIGJvb2wpCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVzdEZp bGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVt OjpUeXBlIHR5cGUsIGxvbmcgbG9uZywgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKIHsKICAgICAvLyBBc3luY0ZpbGVTeXN0 ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5jaHJvbm91c2x5LCBzbyB0aGUg bWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNseS4KLSAgICBjb250ZXh0LT5w b3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFz ZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCks IHR5cGUsIHRydWUsIGNhbGxiYWNrcykpOworICAgIGNvbnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0 LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlwZSwgdHJ1ZSwgY2Fs bGJhY2tzLCBzeW5jaHJvbm91cykpOwogfQogCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi44MWMxNmNkMTRkZDYzZjRhYzhmYzJlYzNiZmIzNmY0YmVlOGE2 NTljCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAKQEAgLTAsMCArMSwxNjQgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKiBD b3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2Vy IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBs aWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAw MjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKwor I2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUd0ay5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRl ci5oIgorI2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIkZpbGVNZXRhZGF0 YS5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKworI2luY2x1ZGUgPHd0 Zi90ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit0ZW1wbGF0ZTw+IHN0 cnVjdCBDcm9zc1RocmVhZENvcGllckJhc2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0YWRhdGE+IHsK KyAgICB0eXBlZGVmIEZpbGVNZXRhZGF0YSBUeXBlOworICAgIHN0YXRpYyBGaWxlTWV0YWRhdGEg Y29weShjb25zdCBGaWxlTWV0YWRhdGEmKTsKK307CisKK0Nyb3NzVGhyZWFkQ29waWVyQmFzZTxm YWxzZSwgZmFsc2UsIEZpbGVNZXRhZGF0YT46OlR5cGUgQ3Jvc3NUaHJlYWRDb3BpZXJCYXNlPGZh bHNlLCBmYWxzZSwgRmlsZU1ldGFkYXRhPjo6Y29weShjb25zdCBGaWxlTWV0YWRhdGEmIG9yaWdp bmFsKQoreworICAgIEZpbGVNZXRhZGF0YSBtZXRhZGF0YTsKKyAgICBtZXRhZGF0YS5tb2RpZmlj YXRpb25UaW1lID0gb3JpZ2luYWwubW9kaWZpY2F0aW9uVGltZTsKKyAgICBtZXRhZGF0YS5sZW5n dGggPSBvcmlnaW5hbC5sZW5ndGg7CisgICAgbWV0YWRhdGEudHlwZSA9IG9yaWdpbmFsLnR5cGU7 CisgICAgbWV0YWRhdGEucGxhdGZvcm1QYXRoID0gb3JpZ2luYWwucGxhdGZvcm1QYXRoOworICAg IHJldHVybiBtZXRhZGF0YTsKK30KKworUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGs+IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIGNvbnRleHQsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBj YWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoY29udGV4dCwgY2FsbGJhY2tzLCBzeW5jaHJvbm91 cykpOworfQorCitQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsqIHRhc2tDb250cm9sbGVyLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgcmV0dXJuIGFkb3B0UHRy KG5ldyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsodGFza0NvbnRyb2xsZXIsIGNhbGxiYWNr cywgbW9kZSkpOworfQorCisKK0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzR3RrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25v dXMpCisgICAgOiBtX3N5bmNocm9ub3VzKHN5bmNocm9ub3VzKQorICAgICwgbV90YXNrTW9kZSgi IikKKyAgICAsIG1fdGFza0NvbnRyb2xsZXIoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGs6OmNyZWF0ZShjb250ZXh0LCBzeW5jaHJvbm91cykpCisgICAgLCBtX2NhbGxiYWNrcyhjYWxs YmFja3MpCit7Cit9CisKK0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29u dHJvbGxlciwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywg Y29uc3QgU3RyaW5nJiBtb2RlKQorICAgIDogbV9zeW5jaHJvbm91cyhmYWxzZSkKKyAgICAsIG1f dGFza01vZGUobW9kZSkKKyAgICAsIG1fdGFza0NvbnRyb2xsZXIodGFza0NvbnRyb2xsZXIpCisg ICAgLCBtX2NhbGxiYWNrcyhjYWxsYmFja3MpCit7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1E aWRTdWNjZWVkQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY2FsbGJhY2tzLT5kaWRT dWNjZWVkKCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRTdWNj ZWVkKCkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNh bGxiYWNrVGFzaygmcGVyZm9ybURpZFN1Y2NlZWRDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFz ZSgpKSwgbV90YXNrTW9kZSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRPcGVuRmlsZVN5 c3RlbUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NPd25Q dHI8QXN5bmNGaWxlU3lzdGVtPiBmaWxlU3lzdGVtKQoreworICAgIGNhbGxiYWNrcy0+ZGlkT3Bl bkZpbGVTeXN0ZW0obmFtZSwgZmlsZVN5c3RlbSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrOjpkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIG5hbWUsIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtPiBmaWxlU3lzdGVtKQoreworICAgIEFzeW5jRmlsZVN5c3Rl bUd0ayogZmlsZVN5c3RlbUd0ayA9IHN0YXRpY19jYXN0PEFzeW5jRmlsZVN5c3RlbUd0ayo+KGZp bGVTeXN0ZW0uZ2V0KCkpOworCisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51 bmlxdWVNb2RlKCk7CisgICAgbV90YXNrQ29udHJvbGxlci0+c2V0Q3VycmVudFRhc2tNb2RlKG1v ZGUpOworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJh Y2tUYXNrKCZwZXJmb3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjaywgbV9jYWxsYmFja3MucmVs ZWFzZSgpLCBuYW1lLCBmaWxlU3lzdGVtKSwgbW9kZSk7CisKKyAgICBmaWxlU3lzdGVtR3RrLT5z ZXRUYXNrQ29udHJvbGxlcihtX3Rhc2tDb250cm9sbGVyLnJlbGVhc2UoKSk7CisgICAgZmlsZVN5 c3RlbUd0ay0+d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKTsKK30KKworc3RhdGljIHZvaWQg cGVyZm9ybURpZFJlYWRNZXRhZGF0YUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBjb25zdCBGaWxl TWV0YWRhdGEmIG1ldGFkYXRhKQoreworICAgIGNhbGxiYWNrcy0+ZGlkUmVhZE1ldGFkYXRhKG1l dGFkYXRhKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWRN ZXRhZGF0YShjb25zdCBGaWxlTWV0YWRhdGEmIG1ldGFkYXRhKQoreworICAgIG1fdGFza0NvbnRy b2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkUmVh ZE1ldGFkYXRhQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgbWV0YWRhdGEpLCBtX3Rh c2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWRE aXJlY3RvcnlFbnRyeShjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpCit7Cisg ICAgRGlyZWN0b3J5RW50cnkgZGlyZWN0b3J5RW50cnk7CisgICAgZGlyZWN0b3J5RW50cnkubmFt ZSA9IG5hbWU7CisgICAgZGlyZWN0b3J5RW50cnkuaXNEaXJlY3RvcnkgPSBpc0RpcmVjdG9yeTsK KyAgICBtX2RpcmVjdG9yeUVudHJpZXMuYXBwZW5kKGRpcmVjdG9yeUVudHJ5KTsKK30KKworc3Rh dGljIHZvaWQgcGVyZm9ybURpZFJlYWREaXJlY3RvcnlFbnRyaWVzQW5kRmluaXNoZWRDYWxsYmFj ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3RvcnlFbnRy aWVzKGZhbHNlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJl YWREaXJlY3RvcnlFbnRyaWVzKGJvb2wgaGFzTW9yZSkKK3sKKyAgICBpZiAoaGFzTW9yZSkKKyAg ICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisKKyAgICBWZWN0b3I8RGlyZWN0b3J5RW50cnk+ OjppdGVyYXRvciBlbmQgPSBtX2RpcmVjdG9yeUVudHJpZXMuZW5kKCk7CisgICAgZm9yIChWZWN0 b3I8RGlyZWN0b3J5RW50cnk+OjppdGVyYXRvciBpdCA9IG1fZGlyZWN0b3J5RW50cmllcy5iZWdp bigpOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgIG1fY2FsbGJhY2tzLT5kaWRSZWFkRGlyZWN0 b3J5RW50cnkoaXQtPm5hbWUsIGl0LT5pc0RpcmVjdG9yeSk7CisKKyAgICBtX2RpcmVjdG9yeUVu dHJpZXMuY2xlYXIoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2so Y3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkUmVhZERpcmVjdG9yeUVudHJpZXNBbmRGaW5p c2hlZENhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCkpLCBtX3Rhc2tNb2RlKTsKK30KKwor c3RhdGljIHZvaWQgcGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayhTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxi YWNrcywgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXI+IHdyaXRlciwgbG9uZyBsb25nIGxlbmd0 aCkKK3sKKyAgICBjYWxsYmFja3MtPmRpZENyZWF0ZUZpbGVXcml0ZXIod3JpdGVyLCBsZW5ndGgp OworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkQ3JlYXRlRmlsZVdy aXRlcihQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBsb25nIGxvbmcgbGVuZ3Ro KQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJh Y2tUYXNrKCZwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrLCBtX2NhbGxiYWNrcy5y ZWxlYXNlKCksIHdyaXRlciwgbGVuZ3RoKSwgbV90YXNrTW9kZSk7Cit9CisKK3N0YXRpYyB2b2lk IHBlcmZvcm1EaWRGYWlsQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25Q dHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGludCBjb2RlKQoreworICAg IGNhbGxiYWNrcy0+ZGlkRmFpbChjb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs6OmRpZEZhaWwoaW50IGNvZGUpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9z dENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2ss IG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgY29kZSksIG1fdGFza01vZGUpOworfQorCit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uZjQ4NmYzZThmMTQxODE5MTYzMTA0NDU1MjIxYTAxMGVlMjgx NjRiOAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaApAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICogQ29w eXJpZ2h0IChDKSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBH ZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQg V0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGli cmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIx MTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19o CisjZGVmaW5lIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisKKyNpZiBFTkFCTEUoRklM RV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKKyNpbmNs dWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaW5jbHVkZSA8d3Rm L1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBTY3JpcHRFeGVj dXRpb25Db250ZXh0OworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsgOiBwdWJs aWMgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNo cm9ub3VzID0gZmFsc2UpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJpbmcmIG1vZGUpOwor CisgICAgdmlydHVhbCB2b2lkIGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3Bl bkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bT4pOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1ldGFkYXRh Jik7CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBTdHJpbmcm IG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0 b3J5RW50cmllcyhib29sIGhhc01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVhdGVGaWxl V3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiwgbG9uZyBsb25nIGxlbmd0aCk7Cisg ICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoaW50IGNvZGUpOworCitwcml2YXRlOgorICAgIEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzKTsKKyAgICBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsq LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmluZyYgbW9k ZSk7CisKKyAgICBzdHJ1Y3QgRGlyZWN0b3J5RW50cnkgeworICAgICAgICBTdHJpbmcgbmFtZTsK KyAgICAgICAgYm9vbCBpc0RpcmVjdG9yeTsKKworICAgICAgICBEaXJlY3RvcnlFbnRyeSgpIDog aXNEaXJlY3RvcnkoZmFsc2UpIHsgfQorICAgIH07CisKKyAgICBib29sIG1fc3luY2hyb25vdXM7 CisgICAgU3RyaW5nIG1fdGFza01vZGU7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIE93blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IG1fY2FsbGJhY2tzOworICAgIFZlY3RvcjxEaXJlY3RvcnlFbnRyeT4gbV9k aXJlY3RvcnlFbnRyaWVzOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJM RShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc19oCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3Rr LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3Bw CmluZGV4IGMxZGIwMDZhODQ4ZjM5MjZkZDlmZWMzMWY5NjRhMGZkYmRhZjY5ZmMuLmEzNzViYjU5 NTkzMDdiYjU0YWFhMmI2NjRkNTU1NzQ4ZTkxMWJhNGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCkBAIC0xLDQgKzEsNSBAQAog LyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWls LmNvbT4KICAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21h aWwuY29tPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJl ZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTE4LDI3ICsxOSwzNSBAQAogICovCiAKICNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1HdGsuaCIKIAogI2lmIEVOQUJM RShGSUxFX1NZU1RFTSkKIAotI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUd0ay5oIgotCi0jaW5j bHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJHdGsuaCIKKyNpbmNsdWRlICJDcm9z c1RocmVhZFRhc2suaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCisjaW5jbHVkZSAiRmls ZUVycm9yLmgiCisjaW5jbHVkZSAiTG9jYWxGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSAiTm90SW1w bGVtZW50ZWQuaCIKIAorI2luY2x1ZGUgPGdsaWIuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9H T3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0 Zi90ZXh0L0NTdHJpbmcuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CisK IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxl KCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1 cm4gdHJ1ZTsKIH0KIAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzVmFsaWRUeXBlKFR5cGUgdHlw ZSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1 cm4gdHlwZSA9PSBUZW1wb3JhcnkgfHwgdHlwZSA9PSBQZXJzaXN0ZW50OwogfQogCiBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoVHlwZSB0eXBlKQpA QCAtNDgsOCArNTcsMTAgQEAgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5 c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkKIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxl U3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmFnZUlkZW50 aWZpZXIsIFR5cGUgdHlwZSwgYm9vbCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAgIGNhbGxiYWNrcy0+ ZGlkRmFpbChOT1RfU1VQUE9SVEVEX0VSUik7CisgICAgU3RyaW5nIHR5cGVTdHJpbmcgPSAodHlw ZSA9PSBBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpID8gIlBlcnNpc3RlbnQiIDogIlRlbXBv cmFyeSI7CisgICAgU3RyaW5nIG5hbWUgPSBzdG9yYWdlSWRlbnRpZmllciArICI6IiArIHR5cGVT dHJpbmc7CisKKyAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIEFzeW5jRmls ZVN5c3RlbTo6Y3JlYXRlKHR5cGUpKTsKIH0KIAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmNyYWNr RmlsZVN5c3RlbVVSTChjb25zdCBLVVJMJiB1cmwsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSYgdHlw ZSwgU3RyaW5nJiBmaWxlUGF0aCkKQEAgLTYwLDc1ICs3MSwzOTYgQEAgYm9vbCBBc3luY0ZpbGVT eXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVSTChjb25zdCBLVVJMJiB1cmwsIEFzeW5jRmlsZVN5c3Rl bTo6VHlwZSYKIAogQXN5bmNGaWxlU3lzdGVtR3RrOjpBc3luY0ZpbGVTeXN0ZW1HdGsoQXN5bmNG aWxlU3lzdGVtOjpUeXBlIHR5cGUpCiAgICAgOiBBc3luY0ZpbGVTeXN0ZW0odHlwZSkKKyAgICAs IG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGgoTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0 ZW0oKS5maWxlU3lzdGVtQmFzZVBhdGgoKSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwogfQog CiBBc3luY0ZpbGVTeXN0ZW1HdGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGsoKQogewotICAgIG5vdElt cGxlbWVudGVkKCk7CiB9CiAKIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW1HdGs6OnRvVVJMKGNvbnN0 IFN0cmluZyYgb3JpZ2luU3RyaW5nLCBjb25zdCBTdHJpbmcmIGZ1bGxQYXRoKQogewotICAgIG5v dEltcGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuIFN0cmluZygpOworICAgIEFTU0VSVCghb3JpZ2lu U3RyaW5nLmlzRW1wdHkoKSk7CisgICAgaWYgKG9yaWdpblN0cmluZyA9PSBTdHJpbmcoIm51bGwi KSkKKyAgICAgICAgcmV0dXJuIFN0cmluZygpOworCisgICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7 CisgICAgcmVzdWx0LmFwcGVuZCgiZmlsZXN5c3RlbToiKTsKKyAgICByZXN1bHQuYXBwZW5kKG9y aWdpblN0cmluZyk7CisgICAgcmVzdWx0LmFwcGVuZCgiLyIpOworICAgIGlmICh0eXBlKCkgPT0g VGVtcG9yYXJ5KQorICAgICAgICByZXN1bHQuYXBwZW5kKHRlbXBvcmFyeVBhdGhQcmVmaXgpOwor ICAgIGlmICh0eXBlKCkgPT0gUGVyc2lzdGVudCkKKyAgICAgICAgcmVzdWx0LmFwcGVuZChwZXJz aXN0ZW50UGF0aFByZWZpeCk7CisgICAgcmVzdWx0LmFwcGVuZChlbmNvZGVXaXRoVVJMRXNjYXBl U2VxdWVuY2VzKGZ1bGxQYXRoKSk7CisKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9 CisKK3N0YXRpYyB2b2lkIG1vdmVBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5n JiBzcmNQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQoreworICAgIEdSZWZQdHI8R0ZpbGU+IHNvdXJj ZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChzcmNQYXRoLnV0ZjgoKS5kYXRh KCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBkZXN0aW5hdGlvbkZpbGUgPSBhZG9wdEdSZWYoZ19m aWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51dGY4KCkuZGF0YSgpKSk7CisKKyAgICBHUmVmUHRy PEdGaWxlSW5mbz4gc291cmNlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhzb3Vy Y2VGaWxlLmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBp ZiAoIXNvdXJjZUluZm8pIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVF cnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHUmVm UHRyPEdGaWxlSW5mbz4gZGVzdGluYXRpb25JbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9p bmZvKGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAw LCAwKSk7CisgICAgaWYgKGRlc3RpbmF0aW9uSW5mbykgeworICAgICAgICBHRmlsZVR5cGUgc291 cmNlRmlsZVR5cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKHNvdXJjZUluZm8uZ2V0KCkp OworICAgICAgICBHRmlsZVR5cGUgZGVzdGluYXRpb25GaWxlVHlwZSA9IGdfZmlsZV9pbmZvX2dl dF9maWxlX3R5cGUoZGVzdGluYXRpb25JbmZvLmdldCgpKTsKKworICAgICAgICBpZiAoc291cmNl RmlsZVR5cGUgIT0gZGVzdGluYXRpb25GaWxlVHlwZSkgeworICAgICAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSKTsKKyAg ICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICBpZiAoZGVzdGluYXRpb25GaWxl VHlwZSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkKKyAgICAgICAgICAgICAgICAmJiAhZ19maWxl X2RlbGV0ZShkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIDAsIDApKSB7CisgICAgICAgICAgICBoZWxw ZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlIp OworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgaWYgKCFnX2Zp bGVfbW92ZShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIEdfRklMRV9D T1BZX09WRVJXUklURSwgMCwgMCwgMCwgMCkpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5k aWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0Zp bGVTeXN0ZW1HdGs6Om1vdmUoY29uc3QgU3RyaW5nJiBzb3VyY2VQYXRoLCBjb25zdCBTdHJpbmcm IGRlc3RpbmF0aW9uUGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNh bGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBzb3VyY2VGaWxl U3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHNvdXJjZVBhdGgpOworICAg IFN0cmluZyBkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0 ZW1VUkwoZGVzdGluYXRpb25QYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xs ZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWlu VGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmbW92ZUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUp LCBzb3VyY2VGaWxlU3lzdGVtUGF0aCwgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCkpOworfQor CitzdGF0aWMgdm9pZCBjb3B5UmVjdXJzaXZlbHkoR0ZpbGUqIHNvdXJjZURpcmVjdG9yeSwgR0Zp bGUqIGRlc3RpbmF0aW9uRGlyZWN0b3J5LCBHRXJyb3IqKiBlcnJvcikKK3sKKyAgICBpZiAoIWdf ZmlsZV9tYWtlX2RpcmVjdG9yeShkZXN0aW5hdGlvbkRpcmVjdG9yeSwgMCwgZXJyb3IpKQorICAg ICAgICByZXR1cm47CisKKyAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9yeShnX2Rpcl9vcGVuKGdf ZmlsZV9nZXRfcGF0aChzb3VyY2VEaXJlY3RvcnkpLCAwLCBlcnJvcikpOworICAgIGlmICghZGly ZWN0b3J5KQorICAgICAgICByZXR1cm47CisKKyAgICB3aGlsZSAoY29uc3QgY2hhciogZGlyZWN0 b3J5RW50cnkgPSBjb25zdF9jYXN0PGNoYXIqPihnX2Rpcl9yZWFkX25hbWUoZGlyZWN0b3J5Lmdl dCgpKSkpIHsKKyAgICAgICAgR1JlZlB0cjxHRmlsZT4gc291cmNlRmlsZSA9IGFkb3B0R1JlZihn X2ZpbGVfZ2V0X2NoaWxkKHNvdXJjZURpcmVjdG9yeSwgZGlyZWN0b3J5RW50cnkpKTsKKyAgICAg ICAgR1JlZlB0cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRf Y2hpbGQoZGVzdGluYXRpb25EaXJlY3RvcnksIGRpcmVjdG9yeUVudHJ5KSk7CisKKyAgICAgICAg R1JlZlB0cjxHRmlsZUluZm8+IHNvdXJjZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2lu Zm8oc291cmNlRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCBlcnJv cikpOworICAgICAgICBpZiAoIXNvdXJjZUluZm8pCisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIGlmIChnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKHNvdXJjZUluZm8uZ2V0KCkpID09IEdf RklMRV9UWVBFX0RJUkVDVE9SWSkgeworICAgICAgICAgICAgY29weVJlY3Vyc2l2ZWx5KHNvdXJj ZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgZXJyb3IpOworICAgICAgICAgICAg cmV0dXJuOworICAgICAgICB9CisgICAgICAgIGlmICghZ19maWxlX2NvcHkoc291cmNlRmlsZS5n ZXQoKSwgZGVzdGluYXRpb25GaWxlLmdldCgpLCBHX0ZJTEVfQ09QWV9OT05FLCAwLCAwLCAwLCBl cnJvcikpCisgICAgICAgICAgICByZXR1cm47CisgICAgfQorfQorCitzdGF0aWMgdm9pZCBjb3B5 QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIFN0cmluZyYgc291cmNlUGF0aCwgU3RyaW5n JiBkZXN0UGF0aCkKK3sKKyAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxlID0gYWRvcHRHUmVm KGdfZmlsZV9uZXdfZm9yX3BhdGgoc291cmNlUGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgR1Jl ZlB0cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3Bh dGgoZGVzdFBhdGgudXRmOCgpLmRhdGEoKSkpOworCisgICAgR1JlZlB0cjxHRmlsZUluZm8+IHNv dXJjZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oc291cmNlRmlsZS5nZXQoKSwg IioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKCFzb3VyY2VJbmZv KSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VO RF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR0ZpbGVUeXBlIHNvdXJjZUZp bGVUeXBlID0gZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShzb3VyY2VJbmZvLmdldCgpKTsKKyAg ICBHUmVmUHRyPEdGaWxlSW5mbz4gZGVzdGluYXRpb25JbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9x dWVyeV9pbmZvKGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19O T05FLCAwLCAwKSk7CisgICAgaWYgKGRlc3RpbmF0aW9uSW5mbykgeworICAgICAgICBHRmlsZVR5 cGUgZGVzdGluYXRpb25GaWxlVHlwZSA9IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZGVzdGlu YXRpb25JbmZvLmdldCgpKTsKKyAgICAgICAgaWYgKHNvdXJjZUZpbGVUeXBlICE9IGRlc3RpbmF0 aW9uRmlsZVR5cGUpIHsKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxl RXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUik7CisgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgIH0KKyAgICAgICAgaWYgKGRlc3RpbmF0aW9uRmlsZVR5cGUgPT0gR19GSUxFX1RZUEVf RElSRUNUT1JZCisgICAgICAgICAgICAgICAgJiYgIWdfZmlsZV9kZWxldGUoZGVzdGluYXRpb25G aWxlLmdldCgpLCAwLCAwKSkgeworICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWls KEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSKTsKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgfQorICAgIH0KKworICAgIGlmIChzb3VyY2VGaWxlVHlwZSA9PSBHX0ZJTEVf VFlQRV9ESVJFQ1RPUlkpIHsKKyAgICAgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgICAg ICBjb3B5UmVjdXJzaXZlbHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGluYXRpb25GaWxlLmdldCgp LCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBpZiAoZXJyb3IpCisgICAgICAgICAgICBoZWxw ZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAg ZWxzZQorICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoIWdfZmlsZV9jb3B5KHNvdXJjZUZpbGUuZ2V0KCks IGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgR19GSUxFX0NPUFlfT1ZFUldSSVRFLCAwLCAwLCAwLCAw KSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9V TkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBlckNhbGxiYWNrcy0+ ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y29weShjb25zdCBT dHJpbmcmIHNvdXJjZVBhdGgsIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25QYXRoLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxl bWVudGVkKCk7CisgICAgU3RyaW5nIHNvdXJjZUZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhU b0ZpbGVTeXN0ZW1VUkwoc291cmNlUGF0aCk7CisgICAgU3RyaW5nIGRlc3RpbmF0aW9uRmlsZVN5 c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChkZXN0aW5hdGlvblBhdGgpOwor ICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAg bV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNr KCZjb3B5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0Nv bnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIHNvdXJjZUZpbGVTeXN0ZW1QYXRoLCBk ZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92ZUZpbGUo R0ZpbGUqIGZpbGUsIGJvb2wgcmVjdXJzaXZlLCBHRXJyb3IqKiBlcnJvcikKK3sKKyAgICBpZiAo cmVjdXJzaXZlICYmIGdfZmlsZV90ZXN0KGdfZmlsZV9nZXRfcGF0aChmaWxlKSwgR19GSUxFX1RF U1RfSVNfRElSKSkgeworICAgICAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9yeShnX2Rpcl9vcGVu KGdfZmlsZV9nZXRfcGF0aChmaWxlKSwgMCwgZXJyb3IpKTsKKyAgICAgICAgaWYgKCFkaXJlY3Rv cnkpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgd2hpbGUgKGNvbnN0IGNoYXIqIGRp cmVjdG9yeUVudHJ5ID0gY29uc3RfY2FzdDxjaGFyKj4oZ19kaXJfcmVhZF9uYW1lKGRpcmVjdG9y eS5nZXQoKSkpKSB7CisgICAgICAgICAgICBHUmVmUHRyPEdGaWxlPiBjaGlsZCA9IGFkb3B0R1Jl ZihnX2ZpbGVfZ2V0X2NoaWxkKGZpbGUsIGRpcmVjdG9yeUVudHJ5KSk7CisgICAgICAgICAgICBy ZW1vdmVGaWxlKGNoaWxkLmdldCgpLCByZWN1cnNpdmUsIGVycm9yKTsKKyAgICAgICAgICAgIGlm ICgqZXJyb3IpCisgICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisg ICAgZ19maWxlX2RlbGV0ZShmaWxlLCAwLCBlcnJvcik7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92 ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGZpbGVQYXRoLCBib29sIHJl Y3Vyc2l2ZSkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0cjxHRmls ZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0ZjgoKS5k YXRhKCkpKTsKKyAgICByZW1vdmVGaWxlKGZpbGUuZ2V0KCksIHJlY3Vyc2l2ZSwgJmVycm9yLm91 dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgRmlsZUVycm9yOjpFcnJvckNvZGUg ZXJyb3JDb2RlOworICAgICAgICBzd2l0Y2ggKGVycm9yLT5jb2RlKSB7CisgICAgICAgIGNhc2Ug R19JT19FUlJPUl9OT1RfRU1QVFk6CisgICAgICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6 OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBj YXNlIEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAg ZXJyb3JDb2RlID0gRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSOworICAgICAgICB9CisKKyAgICAg ICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKGVycm9yQ29kZSk7CisgICAgICAgIHJldHVybjsK KyAgICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBB c3luY0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50 ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3Rl bVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1v ZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0 ZUNhbGxiYWNrVGFzaygmcmVtb3ZlQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0 ZW1QYXRoLCBmYWxzZSkpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVj dXJzaXZlbHkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5n IGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAg U3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rh c2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJl bW92ZUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250 cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgdHJ1ZSkpOwor fQorCitzdGF0aWMgdm9pZCByZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNr cywgU3RyaW5nJiBmaWxlUGF0aCkKK3sKKyAgICBHUmVmUHRyPEdGaWxlPiBmaWxlID0gYWRvcHRH UmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoZmlsZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIEdS ZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhm aWxlLmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBpZiAo IWZpbGVJbmZvKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6 Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgRmlsZU1ldGFk YXRhOjpUeXBlIHR5cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgp KSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkgPyBGaWxlTWV0YWRhdGE6OlR5cGVEaXJlY3Rvcnkg OiBGaWxlTWV0YWRhdGE6OlR5cGVGaWxlOworCisgICAgR1RpbWVWYWwgdGltZVZhbHVlOworICAg IGdfZmlsZV9pbmZvX2dldF9tb2RpZmljYXRpb25fdGltZShmaWxlSW5mby5nZXQoKSwgJnRpbWVW YWx1ZSk7CisKKyAgICBGaWxlTWV0YWRhdGEgbWV0YWRhdGE7CisgICAgbWV0YWRhdGEudHlwZSA9 IHR5cGU7CisgICAgbWV0YWRhdGEubW9kaWZpY2F0aW9uVGltZSA9IHN0YXRpY19jYXN0PGRvdWJs ZT4odGltZVZhbHVlLnR2X3NlYyk7CisgICAgbWV0YWRhdGEubGVuZ3RoID0gdHlwZSA9PSBGaWxl TWV0YWRhdGE6OlR5cGVGaWxlID8gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19n ZXRfc2l6ZShmaWxlSW5mby5nZXQoKSkpIDogMDsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGgg PSBTdHJpbmcoZ19maWxlX2dldF9wYXRoKGZpbGUuZ2V0KCkpKTsKKworICAgIGhlbHBlckNhbGxi YWNrcy0+ZGlkUmVhZE1ldGFkYXRhKG1ldGFkYXRhKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0 ZW1HdGs6OnJlYWRNZXRhZGF0YShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsK KyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChw YXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsK KworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxi YWNrVGFzaygmcmVhZE1ldGFkYXRhQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0 ZW1QYXRoKSk7CiB9CiAKLXZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVGaWxlKGNvbnN0 IFN0cmluZyYgcGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzPiBjYWxsYmFja3MpCitzdGF0aWMgdm9pZCBjcmVhdGVPYmplY3RBc3luYyhTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBsb2NhbEZpbGVTeXN0ZW1QYXRoLCBTdHJpbmcm IGFic29sdXRlUGF0aCwgR0ZpbGVUeXBlIHR5cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsK KyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSICYmIGFic29sdXRlUGF0aCA9PSBT dHJpbmcoIi8iKSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9y OjpTRUNVUklUWV9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR093blB0cjxH RXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdSZWYoZ19maWxl X25ld19mb3JfcGF0aChsb2NhbEZpbGVTeXN0ZW1QYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBp ZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSKQorICAgICAgICBHUmVmUHRyPEdGaWxlT3V0 cHV0U3RyZWFtPiBvdXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX2NyZWF0ZShmaWxlLmdl dCgpLCBHX0ZJTEVfQ1JFQVRFX05PTkUsIDAsICZlcnJvci5vdXRQdHIoKSkpOworICAgIGVsc2Ug aWYgKHR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZKQorICAgICAgICBnX2ZpbGVfbWFrZV9k aXJlY3RvcnkoZmlsZS5nZXQoKSwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBlbHNlCisgICAg ICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworCisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIEZp bGVFcnJvcjo6RXJyb3JDb2RlIGVycm9yQ29kZTsKKyAgICAgICAgc3dpdGNoIChlcnJvci0+Y29k ZSkgeworICAgICAgICBjYXNlIEdfSU9fRVJST1JfRVhJU1RTOgorICAgICAgICAgICAgZXJyb3JD b2RlID0gRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlI7CisgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgY2FzZSBHX0lPX0VSUk9SX05PVF9GT1VORDoKKyAgICAgICAgZGVmYXVs dDoKKyAgICAgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUjsKKyAg ICAgICAgfQorICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3JDb2RlKTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgp OwogfQogCi12b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGlyZWN0b3J5KGNvbnN0IFN0 cmluZyYgcGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MpCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlT2JqZWN0 KFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0 cmluZyYgYWJzb2x1dGVQYXRoLCBHRmlsZVR5cGUgdHlwZSkKIHsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOworICAgIFN0cmluZyBsb2NhbEZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVT eXN0ZW1VUkwoYWJzb2x1dGVQYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xs ZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWlu VGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY3JlYXRlT2JqZWN0QXN5bmMsIEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNr cywgbW9kZSksIGxvY2FsRmlsZVN5c3RlbVBhdGgsIGFic29sdXRlUGF0aCwgdHlwZSkpOworfQor Cit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZShjb25zdCBTdHJpbmcmIGFic29s dXRlUGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzPiBjYWxsYmFja3MpCit7CisgICAgY3JlYXRlT2JqZWN0KGNhbGxiYWNrcywgYWJzb2x1dGVQ YXRoLCBHX0ZJTEVfVFlQRV9SRUdVTEFSKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6 OmNyZWF0ZURpcmVjdG9yeShjb25zdCBTdHJpbmcmIGFic29sdXRlUGF0aCwgYm9vbCBleGNsdXNp dmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7Cisg ICAgY3JlYXRlT2JqZWN0KGNhbGxiYWNrcywgYWJzb2x1dGVQYXRoLCBHX0ZJTEVfVFlQRV9ESVJF Q1RPUlkpOworfQorCitzdGF0aWMgdm9pZCBvYmplY3RFeGlzdHNBc3luYyhTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBl ckNhbGxiYWNrcywgU3RyaW5nJiBwYXRoLCBHRmlsZVR5cGUgdHlwZSkKK3sKKyAgICBHUmVmUHRy PEdGaWxlPiBvYmplY3QgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChwYXRoLnV0Zjgo KS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYo Z19maWxlX3F1ZXJ5X2luZm8ob2JqZWN0LmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05P TkUsIDAsIDApKTsKKyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNr cy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47Cisg ICAgfQorICAgIGlmIChnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgpKSAh PSB0eXBlKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6OlRZ UEVfTUlTTUFUQ0hfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBlckNh bGxiYWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Zmls ZUV4aXN0cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcg ZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBT dHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFz a0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmb2Jq ZWN0RXhpc3RzQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFz a0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoLCBHX0ZJ TEVfVFlQRV9SRUdVTEFSKSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpkaXJlY3Rv cnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5n IGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAg U3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rh c2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9i amVjdEV4aXN0c0FzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rh c2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgR19G SUxFX1RZUEVfRElSRUNUT1JZKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJlYWREaXJlY3RvcnlBc3lu YyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs+IGNhbGxiYWNrcywgU3RyaW5nJiBwYXRoKQoreworICAgIEdPd25QdHI8R0Vycm9y PiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxlPiBkaXJlY3RvcnlGaWxlID0gYWRvcHRHUmVmKGdf ZmlsZV9uZXdfZm9yX3BhdGgocGF0aC51dGY4KCkuZGF0YSgpKSk7CisKKyAgICBHT3duUHRyPEdE aXI+IGRpcmVjdG9yeShnX2Rpcl9vcGVuKHBhdGgudXRmOCgpLmRhdGEoKSwgMCwgJmVycm9yLm91 dFB0cigpKSk7CisgICAgaWYgKCFlcnJvcikgeworICAgICAgICB3aGlsZSAoY29uc3QgY2hhciog ZGlyZWN0b3J5RW50cnkgPSBjb25zdF9jYXN0PGNoYXIqPihnX2Rpcl9yZWFkX25hbWUoZGlyZWN0 b3J5LmdldCgpKSkpIHsKKyAgICAgICAgICAgIEdSZWZQdHI8R0ZpbGU+IGNoaWxkID0gYWRvcHRH UmVmKGdfZmlsZV9nZXRfY2hpbGQoZGlyZWN0b3J5RmlsZS5nZXQoKSwgZGlyZWN0b3J5RW50cnkp KTsKKyAgICAgICAgICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihn X2ZpbGVfcXVlcnlfaW5mbyhjaGlsZC5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05F LCAwLCAwKSk7CisKKyAgICAgICAgICAgIGJvb2wgaXNFbnRyeURpcmVjdG9yeSA9IGdfZmlsZV9p bmZvX2dldF9maWxlX3R5cGUoZmlsZUluZm8uZ2V0KCkpID09IEdfRklMRV9UWVBFX0RJUkVDVE9S WTsKKyAgICAgICAgICAgIGNhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeUVudHJ5KFN0cmluZyhk aXJlY3RvcnlFbnRyeSksIGlzRW50cnlEaXJlY3RvcnkpOworICAgICAgICB9CisgICAgfSBlbHNl IHsKKyAgICAgICAgY2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3Rv cnlFbnRyaWVzKGZhbHNlKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWREaXJl Y3RvcnkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZp bGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3Ry aW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tD b250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlYWRE aXJlY3RvcnlBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNr Q29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgpKTsKIH0K IAorc3RhdGljIHZvaWQgY3JlYXRlV3JpdGVyQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCos IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3Ms IEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0ayogdGFza0NvbnRyb2xsZXIsIFN0cmluZyYgcGF0aCkKK3sKKyAgICBHUmVmUHRyPEdG aWxlPiBmaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgocGF0aC51dGY4KCkuZGF0 YSgpKSk7CisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGZpbGVJbmZvID0gYWRvcHRHUmVmKGdfZmls ZV9xdWVyeV9pbmZvKGZpbGUuZ2V0KCksICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwg MCkpOworICAgIGlmICghZmlsZUluZm8pIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRG YWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICBsb25nIGxvbmcgZmlsZVNpemUgPSBzdGF0aWNfY2FzdDxsb25nIGxvbmc+KGdfZmlsZV9p bmZvX2dldF9zaXplKGZpbGVJbmZvLmdldCgpKSk7CisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRD cmVhdGVGaWxlV3JpdGVyKEFzeW5jRmlsZVdyaXRlckd0azo6Y3JlYXRlKGNsaWVudCwgdGFza0Nv bnRyb2xsZXIsIGZpbGUubGVha1JlZigpKSwgZmlsZVNpemUpOworfQogCiB2b2lkIEFzeW5jRmls ZVN5c3RlbUd0azo6Y3JlYXRlV3JpdGVyKEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBj b25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBj YWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3Rl bVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9k ZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xs ZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY3JlYXRlV3JpdGVy QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xs ZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MoY2xpZW50 KSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX3Rhc2tDb250cm9sbGVyLmdldCgpKSwgZmlsZVN5 c3RlbVBhdGgpKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVNuYXBzaG90 RmlsZUFuZFJlYWRNZXRhZGF0YShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgLy8gRklYTUU6IElzIHRoaXMg YXBpIHJlYWxseSBzYW1lIHdpdGggcmVhZE1ldGFkYXRhPworICAgIHJlYWRNZXRhZGF0YShwYXRo LCBjYWxsYmFja3MpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6c2V0VGFza0NvbnRy b2xsZXIoUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gdGFza0Nv bnRyb2xsZXIpCit7CisgICAgbV90YXNrQ29udHJvbGxlciA9IHRhc2tDb250cm9sbGVyOworfQor CitTdHJpbmcgQXN5bmNGaWxlU3lzdGVtR3RrOjp2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChj b25zdCBTdHJpbmcmIHZpcnR1YWxQYXRoKQoreworICAgIHJldHVybiB2aXJ0dWFsUGF0aCAhPSBT dHJpbmcoIi8iKSA/IG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGggKyB2aXJ0dWFsUGF0aCA6IG1f bG9jYWxGaWxlU3lzdGVtQmFzZVBhdGg7Cit9CisKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtR3RrOjp3 YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgcmV0dXJuIG1fdGFza0NvbnRyb2xs ZXItPndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVT eXN0ZW1HdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1H dGsuaAppbmRleCBjYjQ1YjZlYTRiYzIwMjBlOGViNGM4ZWI1YTE5OGYwNzZmNWE2OTdiLi44MGFl NGU1ODk3M2FiYjcwNTFmNjMyYzgwNWE3MDI2Njc3ODRlNGNjIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oCkBAIC0xLDQgKzEsNSBAQAog LyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWls LmNvbT4KICAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21h aWwuY29tPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJl ZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTIzLDExICsyNCwxNCBAQAogI2lmIEVOQUJMRShGSUxF X1NZU1RFTSkKIAogI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbS5oIgorCisjaW5jbHVkZSA8Z2lv L2dpby5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAogY2xhc3MgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzOworY2xhc3MgQXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGs7CiAKIGNsYXNzIEFzeW5jRmlsZVN5c3RlbUd0ayA6IHB1Ymxp YyBBc3luY0ZpbGVTeXN0ZW0gewogcHVibGljOgpAQCAtNDYsNiArNTAsMTYgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgdm9pZCBkaXJlY3RvcnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwogICAgIHZpcnR1YWwgdm9pZCByZWFk RGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3M+KTsKICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlV3JpdGVyKEFzeW5jRmlsZVdyaXRl ckNsaWVudCosIGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3M+KTsKKyAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlU25hcHNob3RGaWxlQW5kUmVhZE1l dGFkYXRhKGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3M+KTsKKyAgICB2aXJ0dWFsIGJvb2wgd2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKTsK KworICAgIHZvaWQgc2V0VGFza0NvbnRyb2xsZXIoUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0az4pOworcHJpdmF0ZToKKyAgICB2b2lkIGNyZWF0ZU9iamVjdChQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmluZyYgYWJzb2x1dGVQ YXRoLCBHRmlsZVR5cGUpOworICAgIFN0cmluZyB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChj b25zdCBTdHJpbmcmKTsKKworICAgIFN0cmluZyBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoOwor ICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90YXNrQ29udHJv bGxlcjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA1MjE2ZjAwMGFhZGU1NWNmNTU4NDk5YTNlMzVjYmJjZjdj Yzc2YzkKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwCkBAIC0wLDAgKzEsOTMgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+ CisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNv bT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg TGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5z ZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9u LCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQorCisjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKworbmFtZXNwYWNlIFdlYkNv cmUgeworCitQYXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6Y3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqIGNvbnRleHQsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5l dyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayhjb250ZXh0LCBzeW5jaHJvbm91cykp OworfQorCitBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9vbCBz eW5jaHJvbm91cykKKyAgICA6IG1fY29udGV4dChjb250ZXh0KQorICAgICwgbV9zeW5jaHJvbm91 cyhzeW5jaHJvbm91cykKKyAgICAsIG1fY3VycmVudFRhc2tNb2RlKCIiKQorICAgICwgbV93cml0 ZXJUb0NhbmNlbCgwKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdva2VycyBm b3IgZmlsZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsK K30KKworQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0aygpCit7Cit9CisKK1N0cmluZyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0azo6dW5pcXVlTW9kZSgpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBv cnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0Rv Y3VtZW50KCkpOworICAgIHJldHVybiBTdHJpbmcoKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxTY3Jp cHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24n dCBzdXBwb3J0IHdva2VycyBmb3IgZmlsZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4 dC0+aXNEb2N1bWVudCgpKTsKKyAgICBtX2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCit2 b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzZXRDdXJyZW50VGFza01vZGUo Y29uc3QgU3RyaW5nJiB0YXNrTW9kZSkKK3sKKyAgICBtX2N1cnJlbnRUYXNrTW9kZSA9IHRhc2tN b2RlOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpwb3N0Q2Fs bGJhY2tUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywg Y29uc3QgU3RyaW5nJiBtb2RlKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdv a2VycyBmb3IgZmlsZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVu dCgpKTsKKyAgICBtX2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCitib29sIEFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7 CisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKKyAgICBBU1NFUlQoIW1fc3lu Y2hyb25vdXMpOworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0azo6Y2FuY2VsV3JpdGVySWZOZWNlc3NhcnkoQXN5bmNGaWxlV3JpdGVy R3RrKiB3cml0ZXIpCit7CisgICAgaWYgKG1fd3JpdGVyVG9DYW5jZWwgPT0gd3JpdGVyKSB7Cisg ICAgICAgIG1fd3JpdGVyVG9DYW5jZWwgPSAwOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9 CisgICAgcmV0dXJuIGZhbHNlOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRp ZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjg5ODAzMDY4ZGM2ZDE1MGU3ZjFlZjdlNDhjYjIxMTk0MmY0Yjg2OWMKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGsuaApAQCAtMCwwICsxLDY1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChD KSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgor ICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1 YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3Nl ciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYg bm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEg RnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBV U0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKyNk ZWZpbmUgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaAorCisjaWYgRU5BQkxFKEZJ TEVfU1lTVEVNKQorCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5j bHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkU2FmZVJlZkNvdW50 ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworY2xhc3MgQXN5bmNGaWxlV3JpdGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNr Q29udHJvbGxlckd0ayA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0az4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIGJvb2wgc3luY2hyb25vdXMpOworICAgIH5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0aygpOworCisgICAgdm9pZCBwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKKyAgICB2b2lkIHNldEN1cnJlbnRUYXNrTW9k ZShjb25zdCBTdHJpbmcmKTsKKyAgICB2b2lkIHBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5nJik7CisgICAgYm9vbCB3 YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworICAgIGJvb2wgc3luY2hyb25vdXMoKSB7IHJl dHVybiBtX3N5bmNocm9ub3VzOyB9CisKKyAgICBib29sIGNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5 KEFzeW5jRmlsZVdyaXRlckd0ayopOworICAgIHZvaWQgc2V0V3JpdGVyVG9DYW5jZWwoQXN5bmNG aWxlV3JpdGVyR3RrKiB3cml0ZXIpIHsgbV93cml0ZXJUb0NhbmNlbCA9IHdyaXRlcjsgfQorCisg ICAgU3RyaW5nIHVuaXF1ZU1vZGUoKTsKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wpOworCisgICAgU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogbV9jb250ZXh0OworICAgIGJvb2wgbV9zeW5jaHJvbm91czsK KyAgICBTdHJpbmcgbV9jdXJyZW50VGFza01vZGU7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJHdGsq IG1fd3JpdGVyVG9DYW5jZWw7Cit9OworCit9IC8vIG5hbWVzcGFjZQorCisjZW5kaWYgLy8gRU5B QkxFKEZJTEVfU1lTVEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzX2gK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJD bGllbnRHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRl ckNsaWVudEd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uY2I4NTllMzgwNDU5YjRhZWEyYjdmYmNjODA2NDQ3 YzgwYThhMTVmYQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwCkBAIC0wLDAgKzEsNzAgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+Cisg KiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4K KyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwg b3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAq IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBN QSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJB c3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKwor I2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0 YXRpYyB2b2lkIHBlcmZvcm1EaWRXcml0ZUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq LCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgbG9uZyBsb25nIGJ5dGVzLCBib29sIGNv bXBsZXRlKQoreworICAgIGNsaWVudC0+ZGlkV3JpdGUoYnl0ZXMsIGNvbXBsZXRlKTsKK30KKwor c3RhdGljIHZvaWQgcGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50KQoreworICAgIGNsaWVudC0+ZGlk VHJ1bmNhdGUoKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEZpbGVF cnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAgY2xpZW50LT5kaWRGYWlsKGNvZGUpOworfQor CitBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayhBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEFzeW5jRmlsZVdy aXRlckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3Rhc2tDb250 cm9sbGVyKHRhc2tDb250cm9sbGVyKQorICAgICwgbV9jbGllbnQoY2xpZW50KQorICAgICwgbV90 YXNrTW9kZShtb2RlKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnNldEN1cnJlbnRUYXNrTW9k ZShtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFdy aXRlKGxvbmcgbG9uZyBieXRlcywgYm9vbCBjb21wbGV0ZSkKK3sKKyAgICBtX3Rhc2tDb250cm9s bGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFdyaXRl Q2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBieXRlcywgY29tcGxl dGUpLCBtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRp ZFRydW5jYXRlKCkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNy ZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2ssIEFsbG93Q3Jvc3NU aHJlYWRBY2Nlc3MobV9jbGllbnQpKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxl V3JpdGVyQ2xpZW50R3RrOjpkaWRGYWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7Cisg ICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2so JnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQp LCBjb2RlKSwgbV90YXNrTW9kZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43YjQ1ZTFi YjA5OGYzODAwNjE3YTE1OGNjYzFhYmQ4ZmY4NDI0OGI2Ci0tLSAvZGV2L251bGwKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oCkBAIC0w LDAgKzEsNTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5k b2JlcnNla0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxz aGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhh dmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBM aWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVl CisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRo IEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpZm5kZWYgQXN5 bmNGaWxlV3JpdGVyQ2xpZW50R3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3Rr X2gKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyQ2xpZW50Lmgi CisKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK K2NsYXNzIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayA6IHB1YmxpYyBBc3luY0ZpbGVXcml0ZXJD bGllbnQgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNs aWVudEd0az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29u dHJvbGxlciwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFN0cmluZyYgbW9k ZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrKHRhc2tDb250cm9sbGVyLCBjbGllbnQsIG1vZGUpKTsKKyAgICB9CisKKyAgICB2b2lk IGRpZFdyaXRlKGxvbmcgbG9uZyBieXRlcywgYm9vbCBjb21wbGV0ZSk7CisgICAgdm9pZCBkaWRU cnVuY2F0ZSgpOworICAgIHZvaWQgZGlkRmFpbChGaWxlRXJyb3I6OkVycm9yQ29kZSk7CisKKyAg ICBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIoKSB7IHJl dHVybiBtX3Rhc2tDb250cm9sbGVyLmdldCgpOyB9CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxl V3JpdGVyQ2xpZW50R3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgQXN5bmNG aWxlV3JpdGVyQ2xpZW50KiwgY29uc3QgU3RyaW5nJik7CisKKyAgICBSZWZQdHI8QXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IG1fdGFza0NvbnRyb2xsZXI7CisgICAgQXN5bmNGaWxl V3JpdGVyQ2xpZW50KiBtX2NsaWVudDsKKyAgICBTdHJpbmcgbV90YXNrTW9kZTsKK307CisKK30g Ly8gbmFtZXNwYWNlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAv LyBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NTY5YWI3Mzc5MTA0 YTM3MmExYzJhMzQzNjM5YTlmYTk4N2ZlNDIzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAKQEAgLTAsMCArMSwxNTUg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0Bn bWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93 QGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAor ICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oIgorI2luY2x1ZGUgIkJs b2IuaCIKKyNpbmNsdWRlICJCbG9iUmVnaXN0cnlJbXBsLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJl YWRUYXNrLmgiCisKKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CisjaW5jbHVkZSA8Z2xpYi5oPgorI2lu Y2x1ZGUgPHd0Zi9nb2JqZWN0L0dPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5n Lmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJH dGs+IEFzeW5jRmlsZVdyaXRlckd0azo6Y3JlYXRlKEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xp ZW50LCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEdG aWxlKiBmaWxlKQoreworICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlV3JpdGVyR3Rr KGNsaWVudCwgdGFza0NvbnRyb2xsZXIsIGZpbGUpKTsKK30KKworQXN5bmNGaWxlV3JpdGVyR3Rr OjpBc3luY0ZpbGVXcml0ZXJHdGsoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgR0ZpbGUqIGZpbGUp CisgICAgOiBtX2NsaWVudChjbGllbnQpCisgICAgLCBtX3Rhc2tDb250cm9sbGVyKHRhc2tDb250 cm9sbGVyKQorICAgICwgbV9maWxlKGZpbGUpCit7Cit9CisKK3N0YXRpYyB2b2lkIHdyaXRlQXN5 bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrPiBoZWxwZXJDbGllbnQsIEFzeW5jRmlsZVdyaXRlckd0ayogd3JpdGVyLCBHRmlsZSog ZmlsZSwgbG9uZyBsb25nIHBvc2l0aW9uLCBCbG9iKiBkYXRhKQoreworICAgIGlmIChoZWxwZXJD bGllbnQtPnRhc2tDb250cm9sbGVyKCktPmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KHdyaXRlcikp IHsKKyAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6QUJPUlRfRVJSKTsK KyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdSZWZQdHI8R0ZpbGVJT1N0cmVhbT4gaW9T dHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX29wZW5fcmVhZHdyaXRlKGZpbGUsIDAsIDApKTsKKyAg ICBpZiAoIWlvU3RyZWFtKSB7CisgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJy b3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR093blB0 cjxHT3V0cHV0U3RyZWFtPiBvdXRwdXRTdHJlYW0oZ19pb19zdHJlYW1fZ2V0X291dHB1dF9zdHJl YW0oR19JT19TVFJFQU0oaW9TdHJlYW0uZ2V0KCkpKSk7CisgICAgaWYgKCFnX3NlZWthYmxlX3Nl ZWsoR19TRUVLQUJMRShvdXRwdXRTdHJlYW0uZ2V0KCkpLCBwb3NpdGlvbiwgR19TRUVLX1NFVCwg MCwgMCkpIHsKKyAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZP VU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBSZWZQdHI8QmxvYlN0b3Jh Z2VEYXRhPiBibG9iU3RvcmFnZSA9IHN0YXRpY19jYXN0PEJsb2JSZWdpc3RyeUltcGwmPihibG9i UmVnaXN0cnkoKSkuZ2V0QmxvYkRhdGFGcm9tVVJMKGRhdGEtPnVybCgpKTsKKyAgICBpZiAoYmxv YlN0b3JhZ2UpIHsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBibG9iU3RvcmFnZS0+ aXRlbXMoKS5zaXplKCk7IGkrKykgeworICAgICAgICAgICAgY29uc3QgQmxvYkRhdGFJdGVtJiBi bG9iSXRlbSA9IGJsb2JTdG9yYWdlLT5pdGVtcygpW2ldOworICAgICAgICAgICAgaWYgKGJsb2JJ dGVtLnR5cGUgPT0gQmxvYkRhdGFJdGVtOjpEYXRhKSB7CisgICAgICAgICAgICAgICAgZ3NpemUg Ynl0ZXNXcml0dGVuID0gMDsKKyAgICAgICAgICAgICAgICBnX291dHB1dF9zdHJlYW1fd3JpdGVf YWxsKEdfT1VUUFVUX1NUUkVBTShvdXRwdXRTdHJlYW0uZ2V0KCkpLCBibG9iSXRlbS5kYXRhLT5k YXRhKCksIGJsb2JJdGVtLmRhdGEtPmxlbmd0aCgpLCAmYnl0ZXNXcml0dGVuLCAwLCAwKTsKKwor ICAgICAgICAgICAgICAgIGJvb2wgY29tcGxldGVkID0gYmxvYlN0b3JhZ2UtPml0ZW1zKCkuc2l6 ZSgpID09IChpICsgMSk7CisgICAgICAgICAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRXcml0ZShi eXRlc1dyaXR0ZW4sIGNvbXBsZXRlZCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9 Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyR3RrOjp3cml0ZShsb25nIGxvbmcgcG9zaXRpb24s IEJsb2IqIGRhdGEpCit7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlx dWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJndyaXRlQXN5bmMsIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6 Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIG1fY2xpZW50LCBtb2RlKSwgQWxsb3dDcm9z c1RocmVhZEFjY2Vzcyh0aGlzKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2ZpbGUuZ2V0KCkp LCBwb3NpdGlvbiwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhkYXRhKSkpOworfQorCitzdGF0aWMg dm9pZCB0cnVuY2F0ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFz eW5jRmlsZVdyaXRlckNsaWVudEd0az4gaGVscGVyQ2xpZW50LCBBc3luY0ZpbGVXcml0ZXJHdGsq IHdyaXRlciwgR0ZpbGUqIGZpbGUsIGxvbmcgbG9uZyBsZW5ndGgpCit7CisgICAgaWYgKGhlbHBl ckNsaWVudC0+dGFza0NvbnRyb2xsZXIoKS0+Y2FuY2VsV3JpdGVySWZOZWNlc3Nhcnkod3JpdGVy KSkgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpBQk9SVF9FUlIp OworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGZpbGVJ bmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKGZpbGUsICIqIiwgR19GSUxFX1FVRVJZ X0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlmICghZmlsZUluZm8pIHsKKyAgICAgICAgaGVscGVy Q2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisKKyAgICBsb25nIGxvbmcgZmlsZUxlbmd0aCA9IHN0YXRpY19jYXN0PGxvbmcg bG9uZz4oZ19maWxlX2luZm9fZ2V0X3NpemUoZmlsZUluZm8uZ2V0KCkpKTsKKyAgICBpZiAobGVu Z3RoID4gZmlsZUxlbmd0aCkgeworICAgICAgICBHT3duUHRyPEdTdHJpbmc+IHplcm9QYWRkaW5n KGdfc3RyaW5nX25ld19sZW4oMCwgbGVuZ3RoIC0gZmlsZUxlbmd0aCkpOworICAgICAgICBkbyB7 CisgICAgICAgICAgICBnX3N0cmluZ19hcHBlbmRfYyh6ZXJvUGFkZGluZy5nZXQoKSwgJ1wwJyk7 CisgICAgICAgIH0gd2hpbGUgKC0tbGVuZ3RoID4gZmlsZUxlbmd0aCk7CisKKyAgICAgICAgR1Jl ZlB0cjxHRmlsZUlPU3RyZWFtPiBpb1N0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfb3Blbl9yZWFk d3JpdGUoZmlsZSwgMCwgMCkpOworICAgICAgICBpZiAoIWlvU3RyZWFtKSB7CisgICAgICAgICAg ICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIEdPd25QdHI8R091dHB1dFN0cmVh bT4gb3V0cHV0U3RyZWFtKGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKEdfSU9fU1RSRUFN KGlvU3RyZWFtLmdldCgpKSkpOworICAgICAgICBpZiAoIWdfc2Vla2FibGVfc2VlayhHX1NFRUtB QkxFKG91dHB1dFN0cmVhbS5nZXQoKSksIGxlbmd0aCwgR19TRUVLX1NFVCwgMCwgMCkpIHsKKyAg ICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIp OworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisKKyAgICAgICAgZ3NpemUgYnl0ZXNX cml0dGVuID0gMDsKKyAgICAgICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlX2FsbChHX09VVFBVVF9T VFJFQU0ob3V0cHV0U3RyZWFtLmdldCgpKSwgemVyb1BhZGRpbmctPnN0ciwgemVyb1BhZGRpbmct PmxlbiwgJmJ5dGVzV3JpdHRlbiwgMCwgMCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgR1JlZlB0 cjxHRmlsZU91dHB1dFN0cmVhbT4gZmlsZU91dHB1dFN0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVf cmVwbGFjZShmaWxlLCAwLCBmYWxzZSwgR19GSUxFX0NSRUFURV9OT05FLCAwLCAwKSk7CisgICAg ICAgIGlmICghZmlsZU91dHB1dFN0cmVhbSB8fCAhZ19zZWVrYWJsZV90cnVuY2F0ZShHX1NFRUtB QkxFKGZpbGVPdXRwdXRTdHJlYW0uZ2V0KCkpLCBsZW5ndGgsIDAsIDApKSB7CisgICAgICAgICAg ICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgIH0KKworICAgIGhlbHBlckNsaWVudC0+ZGlk VHJ1bmNhdGUoKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OnRydW5jYXRlKGxvbmcg bG9uZyBsZW5ndGgpCit7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlx dWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJnRydW5jYXRlQXN5bmMsIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0 azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIG1fY2xpZW50LCBtb2RlKSwgQWxsb3dD cm9zc1RocmVhZEFjY2Vzcyh0aGlzKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2ZpbGUuZ2V0 KCkpLCBsZW5ndGgpKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OmFib3J0KCkKK3sK KyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRXcml0ZXJUb0NhbmNlbCh0aGlzKTsKK30KKworYm9v bCBBc3luY0ZpbGVXcml0ZXJHdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAg ICByZXR1cm4gbV90YXNrQ29udHJvbGxlci0+c3luY2hyb25vdXMoKSA/IG1fdGFza0NvbnRyb2xs ZXItPndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkgOiBmYWxzZTsKK30KKworfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmU5ZmJhNGQ1Y2RhYmJjMTYxNGI4NjU0MTA3NDk3ZTM0OWQ0NzczZTYKLS0tIC9kZXYvbnVsbAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgKQEAg LTAsMCArMSw1OCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHph bmRvYmVyc2VrQGdtYWlsLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2gg PHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQg aGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAq IExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZy ZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlm dGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRlZiBB c3luY0ZpbGVXcml0ZXJHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVXcml0ZXJHdGtfaAorCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyLmgiCisKKyNp bmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0ZpbGVXcml0ZXJDbGllbnQ7 CitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azsKKworY2xhc3MgQXN5bmNG aWxlV3JpdGVyR3RrIDogcHVibGljIEFzeW5jRmlsZVdyaXRlciB7CitwdWJsaWM6CisgICAgc3Rh dGljIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyR3RrPiBjcmVhdGUoQXN5bmNGaWxlV3JpdGVy Q2xpZW50KiwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBHRmlsZSopOworCisg ICAgdm9pZCBhYm9ydCgpOworICAgIHZvaWQgdHJ1bmNhdGUobG9uZyBsb25nIGxlbmd0aCk7Cisg ICAgdm9pZCB3cml0ZShsb25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEpOworCisgICAgYm9v bCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworCitwcml2YXRlOgorICAgIEFzeW5jRmls ZVdyaXRlckd0ayhBc3luY0ZpbGVXcml0ZXJDbGllbnQqLCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0ayosIEdGaWxlKik7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIG1fY2xp ZW50OworICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90YXNr Q29udHJvbGxlcjsKKyAgICBHUmVmUHRyPEdGaWxlPiBtX2ZpbGU7Cit9OworCit9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAv LyBBc3luY0ZpbGVXcml0ZXJHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvTG9jYWxGaWxlU3lzdGVtR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wYzk0MDFjNzBiZjk5NDcyOWRk MzBjZWE3Mzc5OGVjMWRlZGZkNzk0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAKQEAgLTAsMCArMSw1OCBAQAorLyoK KyAqICBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNv bT4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBh bG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2Fy ZQorICogIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is IEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkK KworI2luY2x1ZGUgPGd0ay9ndGsuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisjaW5j bHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQ dHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKwordm9pZCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29u c3QgU3RyaW5nJiBiYXNlUGF0aCkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAg R093blB0cjxHRGlyPiBkaXJlY3RvcnkoZ19kaXJfb3BlbihiYXNlUGF0aC51dGY4KCkuZGF0YSgp LCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IgJiYgZXJyb3ItPmNvZGUgPT0g R19GSUxFX0VSUk9SX05PRU5UKSB7CisgICAgICAgIEdSZWZQdHI8R0ZpbGU+IGJhc2VEaXJlY3Rv cnlGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoYmFzZVBhdGgudXRmOCgpLmRh dGEoKSkpOworICAgICAgICBnX2ZpbGVfbWFrZV9kaXJlY3RvcnkoYmFzZURpcmVjdG9yeUZpbGUu Z2V0KCksIDAsIDApOworICAgIH0KK30KKworTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0 ZW06OmxvY2FsRmlsZVN5c3RlbSgpCit7CisgICAgV1RGOjpsb2NrQXRvbWljYWxseUluaXRpYWxp emVkU3RhdGljTXV0ZXgoKTsKKyAgICBpZiAoIXNfaW5zdGFuY2UpIHsKKyAgICAgICAgR093blB0 cjxnY2hhcj4gYmFzZVBhdGgoZ19idWlsZF9maWxlbmFtZShnX2dldF91c2VyX2RhdGFfZGlyKCks ICJ3ZWJraXQiLCAiZmlsZXN5c3RlbSIsIE5VTEwpKTsKKyAgICAgICAgT3duUHRyPExvY2FsRmls ZVN5c3RlbT4gbG9jYWxGaWxlU3lzdGVtID0gYWRvcHRQdHIobmV3IExvY2FsRmlsZVN5c3RlbShi YXNlUGF0aC5nZXQoKSkpOworICAgICAgICBsb2NhbEZpbGVTeXN0ZW0tPmluaXRpYWxpemVMb2Nh bEZpbGVTeXN0ZW0oU3RyaW5nKGJhc2VQYXRoLmdldCgpKSk7CisKKyAgICAgICAgc19pbnN0YW5j ZSA9IGxvY2FsRmlsZVN5c3RlbS5sZWFrUHRyKCk7CisgICAgfQorICAgIFdURjo6dW5sb2NrQXRv bWljYWxseUluaXRpYWxpemVkU3RhdGljTXV0ZXgoKTsKKyAgICByZXR1cm4gKnNfaW5zdGFuY2U7 Cit9CisKK30KKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBhNjk5OWM1 YWYwMDQwMTU1YTYwNDhmNzk2ZTgyMzY3ODhjOGY3OTk1Li44ODEzMDI4ODYxOGY0YmIyOTA0NmY5 MzRmYjM3OGM5ODkwZDkxNzJkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysr IGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMjQgQEAKIDIwMTItMDQtMDUgIENo YW5nU2VvayBPaCAgPHNoaXZhbWlkb3dAZ21haWwuY29tPgogCisgICAgICAgIFtHVEtdIFN1cHBv cnQgdGhlIGZpbGUgc3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NTg0NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBbGwgbW9zdCB0ZXN0cyBpbiBmYXN0L2ZpbGVzeXN0ZW0gYXJlIHBhc3Nl ZCBleGNlcHQgdGhlIG9uZXMgcmVsYXRlZCB3aXRoIHdvcmtlci4KKyAgICAgICAgRm9sbG93aW5n IHRlc3RzIGFyZSBwYXNzZWQgaW4gZGV0YWlsLgorICAgICAgICBmYXN0L2ZpbGVzeXN0ZW0vKi5o dG1sCisgICAgICAgIGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5o dG1sCisgICAgICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJs b2IuaHRtbAorICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmls ZS1ibG9iLWZhaWwuaHRtbAorCisgICAgICAgIEJ1dCBGaWxlU3lzdGVtIEFQSSBpcyBub3QgdGhl IGRlZmF1bHQgZW5hYmxlZCBmZWF0dXJlIGFuZCB1bmNvbXBsZXRlZCwKKyAgICAgICAgc28gd2Ug bmVlZCB0byBrZWVwIHRoZW0gc2tpcHBlZC4KKworICAgICAgICAqIHBsYXRmb3JtL2d0ay9Ta2lw cGVkOgorCisyMDEyLTA0LTA1ICBDaGFuZ1Nlb2sgT2ggIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4K KwogICAgICAgICBbR1RLXVtEUlRdIEZhaWwgZmFzdC9maWxlc3lzdGVtL2ZsYWdzLXBhc3Npbmcu aHRtbCBvbiBKU0MKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTgzMTM3CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVk IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKaW5kZXggNDRkOWQ3ZjBkNjQ1NWFi YzM0NTE4MjY0ZjQ5YmI3MjdkNTcxMzRjNS4uNWJiMTg1ZWFjNjJjNmNhZDBjOGU1YWNmZmM5NjFm MGRmOGRmZTZlNSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQK KysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKQEAgLTMwMSwxNSArMzAxLDIw IEBAIGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmctc2xvdy1sb2FkLnBocAogaHR0cC90ZXN0cy9t aXNjL3dlYnRpbWluZy1zc2wucGhwCiBodHRwL3Rlc3RzL21pc2Mvd2VidGltaW5nLXR3by1yZWRp cmVjdHMucGhwCiAKLSMgRmlsZVN5c3RlbSBBUEkgaXMgbm90IHN1cHBvcnRlZC4KKyMgRm9sbG93 aW5nIHRlc3RzIGFyZSBwYXNzZWQsIGlmIEZpbGVTeXN0ZW0gQVBJIGZlYXR1cmUgaXMgZW5hYmxl ZC4KIGZhc3QvZmlsZXN5c3RlbQotaHR0cC90ZXN0cy9maWxlc3lzdGVtCi1odHRwL3Rlc3RzL3Nl Y3VyaXR5L2ZpbGVzeXN0ZW0taWZyYW1lLWZyb20tcmVtb3RlLmh0bWwKIGh0dHAvdGVzdHMvd2Vi c29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2IuaHRtbAogaHR0cC90ZXN0cy93ZWJzb2Nr ZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi1mYWlsLmh0bWwKLWh0dHAvdGVzdHMvd29ya2Vy cy90ZXJtaW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0aW9uLmh0bWwKKyMgUGFzc2VkIGJ1dCB3ZSBz aG91bGQgZW5hYmxlIGZpbGUtc3lzdGVtICYgbXV0YXRpb24tb2JzZXJ2ZXJzIGF0IHRoZSBzYW1l IHRpbWUuCiBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRtbAog CisjIEZpbGVTeXN0ZW0gQVBJIGlzIG5vdCBzdXBwb3J0ZWQgY29tcGxldGVseS4KKyMgV2UgZG9u J3Qgc3VwcG9ydCB3b3JrZXJzIGZvciBGaWxlU3lzdGVtIHlldC4gaHR0cDovL3dlYmtpdC5vcmcv Yi84Mjg1NAorZmFzdC9maWxlc3lzdGVtL3dvcmtlcnMKK2h0dHAvdGVzdHMvZmlsZXN5c3RlbQor aHR0cC90ZXN0cy9zZWN1cml0eS9maWxlc3lzdGVtLWlmcmFtZS1mcm9tLXJlbW90ZS5odG1sCito dHRwL3Rlc3RzL3dvcmtlcnMvdGVybWluYXRlLWR1cmluZy1zeW5jLW9wZXJhdGlvbi5odG1sCisK ICMgUmVxdWlyZXMgV2ViUCBzdXBwb3J0LgogZmFzdC9jYW52YXMvY2FudmFzLXRvRGF0YVVSTC13 ZWJwLmh0bWwKIGZhc3QvaW1hZ2VzL3dlYnAtaW1hZ2UtZGVjb2RpbmcuaHRtbAo= 136219 2012-04-09 07:25:25 -0700 2012-04-10 04:08:34 -0700 Patch bug-58443-20120409232525.patch text/plain 72383 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzNTUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE4NDFkNGY5YjQ3ZTdiZGUyMGJhMTNk NTJmNzU3Y2YzYzU3MjcwYzUuLjc0ZDlkZTE3YjMwYmI4YjcwM2Y5MWNlNGQ3OWEwMmYxOTMwZmUz Y2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMDggIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDoKKwogMjAxMi0wNC0wNiAgQmVuamFtaW4gUG91bGFpbiAgPGJw b3VsYWluQGFwcGxlLmNvbT4KIAogICAgICAgICBHZXQgcmlkIG9mIHRoZSB1c2VsZXNzIGZsYWcg UFJFRU1QVF9HRU9MT0NBVElPTl9QRVJNSVNTSU9OCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDQ1NTdjNzhjOGVl ZDU3MjljNjU4Nzg3ZjBlOTgzMjRkMDUwYzUwMC4uMmRhMmMyYjUwNjA4OGYwMzZjYTY3ODkwZDk0 NWM0YmNjNTI0MzhmOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzOSBAQAorMjAxMi0wNC0wOCAg Q2hhbmdTZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAgICAgICAgW0dUS10gU3Vw cG9ydCB0aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaXMgYmFzZWQgb24gWmFuIERvYmVyc2VrJ3Mgb3Jp Z2luYWwgb25lIGZvciBidWc1ODQ0My4KKyAgICAgICAgVGhpcyBicmluZ3MgRmlsZVN5c3RlbSBB UEkgdG8gZ3RrIHBvcnQuIFRoaXMgYWRkcyBuZXcgaW50ZXJmYWNlcyBsaWtlCisgICAgICAgIEFz eW5jRmlsZVN5c3RlbUd0aywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLCBBc3luY0ZpbGVX cml0ZXJHdGssIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0aworICAgICAgICBhbmQgQXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuIFRoZXNlIGFyZSBjaGlsZCBjbGFzc2VzIGltcGxlbWVu dGluZyB0aGUgaW50ZXJmYWNlcworICAgICAgICBvZiBlYWNoIHBhcmVudCBjbGFzc2VzIGV4Y2Vw dCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay4gQXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGsKKyAgICAgICAgaXMgYSBoZWxwZXIgY2xhc3MuIEl0IHJldGFpbnMgc29tZSB1 c2VmdWwgdmFyaWFibGVzLCBhbmQgY29udHJvbHMgcG9zdGluZyB0YXNrcyB0bworICAgICAgICBT Y3JpcHRFeGVjdXRpb25Db250ZXh0IHdoaWNoIG1pZ2h0IGJlIGVpdGhlciBhIERvY3VtZW50IG9i amVjdCBvciBhIFdvcmtlci4KKyAgICAgICAgVW5mb3J0dW5hdGVseSwgV29ya2VyIGZvciBmaWxl c3lzdGVtIGlzIG5vdCBzdXBwb3J0ZWQgeWV0LCBJIHBsYW4gdG8gc3VwcG9ydCBpdCBpbiB0aGUg bmV4dCBwYXRjaC4KKworICAgICAgICBUZXN0OiBmYXN0L2ZpbGVzeXN0ZW0vKi5odG1sCisgICAg ICAgICAgICAgIGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5odG1s CisgICAgICAgICAgICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxl LWJsb2IuaHRtbAorICAgICAgICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJp L3NlbmQtZmlsZS1ibG9iLWZhaWwuaHRtbAorCisgICAgICAgICogR05VbWFrZWZpbGUubGlzdC5h bTogQWRkZWQgc29tZSBmaWxlcyB0byBidWlsZCBuZXdseSBmb3IgRmlsZVN5c3RlbS4KKyAgICAg ICAgKiBNb2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcDogV2Ugc2hvdWxkIG5v dCBidWlsZCB0aGlzIGZpbGUuIHNvIGFkZGVkIGVycm9yIG1lc3NhZ2UuCisgICAgICAgICogcGxh dGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHA6IEFkZGVkLiBUaGlzIGlz IGFuIGltcGxlbWVudGF0aW9uIG9mIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy4KKyAgICAgICAg KFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6Ojpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6 OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr KToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRTdWNjZWVkQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRTdWNjZWVkKToKKyAg ICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNrKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkT3BlbkZpbGVTeXN0 ZW0pOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFJlYWRNZXRhZGF0YUNhbGxiYWNrKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkUmVhZE1l dGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 ZGlkUmVhZERpcmVjdG9yeUVudHJ5KToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRSZWFk RGlyZWN0b3J5RW50cmllc0FuZEZpbmlzaGVkQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cmllcyk6Cisg ICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrKToKKyAg ICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkQ3JlYXRlRmls ZVdyaXRlcik6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkRmFpbENhbGxiYWNrKToKKyAg ICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkRmFpbCk6Cisg ICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oOiBBZGRl ZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrKToKKyAgICAgICAgKERpcmVjdG9yeUVudHJ5KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6RGlyZWN0b3J5RW50cnk6OkRpcmVjdG9yeUVudHJ5KToK KyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcDogQWRkZWQgc29t ZSBtaXNzaW5nIEFQSXMuIFRoaXMgaXMgYSBjaGlsZCBjbGFzcyBvZiBBc3luY0ZpbGVTeXN0ZW0u CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6aXNWYWxpZFR5cGUpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVSTCk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1HdGs6OkFzeW5jRmlsZVN5c3RlbUd0ayk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp0b1VSTCk6CisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKFdlYkNvcmU6Om1vdmVBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVTeXN0ZW1HdGs6Om1vdmUpOgorICAgICAgICAoV2ViQ29yZTo6Y29weVJlY3Vyc2l2ZWx5KToK KyAgICAgICAgKFdlYkNvcmU6OmNvcHlBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVTeXN0ZW1HdGs6OmNvcHkpOgorICAgICAgICAoV2ViQ29yZTo6cmVtb3ZlRmlsZSk6CisgICAg ICAgIChXZWJDb3JlOjpyZW1vdmVBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1HdGs6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6 OnJlbW92ZVJlY3Vyc2l2ZWx5KToKKyAgICAgICAgKFdlYkNvcmU6OnJlYWRNZXRhZGF0YUFzeW5j KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZE1ldGFkYXRhKToK KyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZU9iamVjdEFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6 OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlT2JqZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVjdG9yeSk6CisgICAgICAgIChXZWJDb3JlOjpvYmplY3RF eGlzdHNBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmZpbGVF eGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpkaXJlY3RvcnlF eGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6cmVhZERpcmVjdG9yeUFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZERpcmVjdG9yeSk6CisgICAgICAgIChX ZWJDb3JlOjpjcmVhdGVXcml0ZXJBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcik6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0 ZW1HdGs6OmNyZWF0ZVNuYXBzaG90RmlsZUFuZFJlYWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKToKKyAgICAgICAgKFdl YkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6dmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwpOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9D b21wbGV0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oOgor ICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAg ICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHA6IEFk ZGVkLiBUaGlzIGlzIGEgaGVscGVyIGNsYXNzIHRvIGNvbnRyb2wgcG9zdGluZyB0YXNrIHRvIGEg dGFyZ2V0IHRocmVhZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayk6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6dW5pcXVlTW9kZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdFRh c2tUb01haW5UaHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdENhbGxiYWNrVGFzayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6d2FpdEZvck9wZXJh dGlvblRvQ29tcGxldGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs6OmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KToKKyAgICAgICAgKiBwbGF0Zm9y bS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzeW5j aHJvbm91cyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0azo6c2V0V3JpdGVyVG9DYW5jZWwpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIGltcGxl bWVudCBvZiBBeXNuY0ZpbGVXcml0ZXJDbGllbnQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAg ICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRXcml0ZUNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6 OnBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1E aWRGYWlsQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRXcml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckNsaWVudEd0azo6ZGlkRmFpbCk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0Fz eW5jRmlsZVdyaXRlckNsaWVudEd0ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAg ICAgICAoQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVdyaXRlckNsaWVudEd0azo6dGFza0NvbnRyb2xsZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIG9m IEFzeW5jRmlsZVdyaXRlci4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl V3JpdGVyR3RrOjpBc3luY0ZpbGVXcml0ZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVB c3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OndyaXRlKToKKyAg ICAgICAgKFdlYkNvcmU6OnRydW5jYXRlQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlV3JpdGVyR3RrOjp0cnVuY2F0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0 ZXJHdGs6OmFib3J0KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckd0azo6d2Fp dEZvck9wZXJhdGlvblRvQ29tcGxldGUpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJHdGsuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5j RmlsZVdyaXRlckd0ayk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0 ay5jcHA6IEFkZGVkLiBQb3J0IHNwZWNpZmljIGltcGxlbWVudGF0aW9uIGZvciBMb2NhbEZpbGVT eXN0ZW0gY2xhc3MgaXMgaGVyZS4gV2Ugc2hvdWxkIHVzZSB0aGlzIGZpbGUgaW5zdGVhZCBvZiBM b2NhbEZpbGVTeXN0ZW0uY3BwCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6 OkxvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJD b3JlOjpMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCk6CisgICAgICAgIChXZWJD b3JlOjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06 OnJlYWRGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVx dWVzdEZpbGVTeXN0ZW0pOgorCiAyMDEyLTA0LTA4ICBQYXRyaWNrIEdhbnN0ZXJlciAgPHBhcm9n YUB3ZWJraXQub3JnPgogCiAgICAgICAgIEJ1aWxkIGZpeCBmb3IgIUVOQUJMRShDU1NfRklMVEVS UykgJiYgQVNTRVJUX0RJU0FCTEVEIGFmdGVyIHIxMDk5NTMuCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3du UHRyLmNwcAppbmRleCBkZmUxODdkNzg4N2ZmNTRlYTAyN2MxYzlkYzVjMDZiZDdiZGI1Y2YxLi4z YWEwNzU5OTQ3NmQ3NGUyMmZkZjRlN2NkMGU4NTc3YTI4MTU5MmI0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dvYmpl Y3QvR093blB0ci5jcHAKQEAgLTQyLDYgKzQyLDE2IEBAIHRlbXBsYXRlIDw+IHZvaWQgZnJlZU93 bmVkR1B0cjxHU0xpc3Q+KEdTTGlzdCogcHRyKQogICAgIGdfc2xpc3RfZnJlZShwdHIpOwogfQog Cit0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1N0cmluZz4oR1N0cmluZyogcHRyKQor eworICAgIGdfc3RyaW5nX2ZyZWUocHRyLCB0cnVlKTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBm cmVlT3duZWRHUHRyPEdPdXRwdXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qIHB0cikKK3sKKyAgICBn X291dHB1dF9zdHJlYW1fY2xvc2UocHRyLCAwLCAwKTsKK30KKwogdGVtcGxhdGUgPD4gdm9pZCBm cmVlT3duZWRHUHRyPEdQYXR0ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKiBwdHIpCiB7CiAgICAgaWYg KHB0cikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oIGIvU291 cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKaW5kZXggNGIyZGNiNzdiMjUwMDBjMmU1YjY4 MDhhNGM3NDg0YzJiZTZkNmNhNS4uOWMwNjdkNzFhNjc5NTVjYzRiZjhkOGZjOGRkZjIwZDliMjJh MWM3MSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKKysrIGIv U291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKQEAgLTM2LDYgKzM2LDggQEAgdGVtcGxh dGUgPHR5cGVuYW1lIFQ+IGlubGluZSB2b2lkIGZyZWVPd25lZEdQdHIoVCogcHRyKTsKIHRlbXBs YXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdFcnJvcj4oR0Vycm9yKik7CiB0ZW1wbGF0ZTw+IHZv aWQgZnJlZU93bmVkR1B0cjxHTGlzdD4oR0xpc3QqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3du ZWRHUHRyPEdTTGlzdD4oR1NMaXN0Kik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxH U3RyaW5nPihHU3RyaW5nKik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHT3V0cHV0 U3RyZWFtPihHT3V0cHV0U3RyZWFtKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxH UGF0dGVyblNwZWM+KEdQYXR0ZXJuU3BlYyopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQ dHI8R0Rpcj4oR0RpciopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1RpbWVyPihH VGltZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmgg Yi9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5oCmluZGV4IGUyOTI1MGJlZjJlZjRk NWU5ZWJlNWMyYjA1MDM3M2JiYTg1NjRmOWEuLjdhNWU5ZjNjYTA3ZGE1NWU1NjhjNTcxZDRlNWJj OWY4NTQ1ZWI1MjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZz LmgKKysrIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaApAQCAtNDgsMTcgKzQ4 LDIwIEBAIHR5cGVkZWYgc3RydWN0IF9HZGtFdmVudEV4cG9zZSBHZGtFdmVudEV4cG9zZTsKIHR5 cGVkZWYgc3RydWN0IF9HZGtQaXhidWYgR2RrUGl4YnVmOwogdHlwZWRlZiBzdHJ1Y3QgX0dFcnJv ciBHRXJyb3I7CiB0eXBlZGVmIHN0cnVjdCBfR0ZpbGUgR0ZpbGU7Cit0eXBlZGVmIHN0cnVjdCBf R0ZpbGVJT1N0cmVhbSBHRmlsZUlPU3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dIYXNoVGFibGUg R0hhc2hUYWJsZTsKIHR5cGVkZWYgc3RydWN0IF9HSW5wdXRTdHJlYW0gR0lucHV0U3RyZWFtOwog dHlwZWRlZiBzdHJ1Y3QgX0dMaXN0IEdMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluQ29udGV4 dCBHTWFpbkNvbnRleHQ7CiB0eXBlZGVmIHN0cnVjdCBfR01haW5Mb29wIEdNYWluTG9vcDsKK3R5 cGVkZWYgc3RydWN0IF9HT3V0cHV0U3RyZWFtIEdPdXRwdXRTdHJlYW07CiB0eXBlZGVmIHN0cnVj dCBfR1BhdHRlcm5TcGVjIEdQYXR0ZXJuU3BlYzsKIHR5cGVkZWYgc3RydWN0IF9HUG9sbGFibGVP dXRwdXRTdHJlYW0gR1BvbGxhYmxlT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dTTGlz dCBHU0xpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfR1NvY2tldENsaWVudCBHU29ja2V0Q2xpZW50Owog dHlwZWRlZiBzdHJ1Y3QgX0dTb2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25uZWN0aW9uOwogdHlw ZWRlZiBzdHJ1Y3QgX0dTb3VyY2UgR1NvdXJjZTsKK3R5cGVkZWYgc3RydWN0IF9HU3RyaW5nIEdT dHJpbmc7CiB0eXBlZGVmIHN0cnVjdCBfR1ZhcmlhbnQgR1ZhcmlhbnQ7CiB0eXBlZGVmIHVuaW9u IF9HZGtFdmVudCBHZGtFdmVudDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIgR1RpbWVyOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJD b3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggYzc1ZDBhMjBhODRjN2VhM2U3OTVhNjdkYTI1 ZDU1ZGI0MjIwNmRmZS4uOWE2YjMxNjUzZDdmNDRjMjQ2YjhjY2RmZWFhOTY3Zjg3NTZlMGQ1MCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0xMDI0LDcgKzEwMjQsNiBAQCB3ZWJj b3JlX21vZHVsZXNfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lz dGVtL0ZpbGVXcml0ZXJDYWxsYmFjay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVz eXN0ZW0vRmlsZVdyaXRlclN5bmMuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVz eXN0ZW0vRmlsZVdyaXRlclN5bmMuaCBcCi0JU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lz dGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5 c3RlbS9Mb2NhbEZpbGVTeXN0ZW0uaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lz dGVtL01ldGFkYXRhQ2FsbGJhY2suaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lz dGVtL01ldGFkYXRhLmggXApAQCAtNDY4Myw2ICs0NjgyLDcgQEAgd2ViY29yZWd0a19zb3VyY2Vz ICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR3RrVmVyc2lvbmluZy5oIFwKIAlT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuY3BwIFwKIAlT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuaCBcCisJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAgXAogCVNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbGl6ZWRTdHJpbmdzR3RrLmNwcCBcCiAJU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL01haW5GcmFtZVNjcm9sbGJhckd0ay5jcHAgXAogCVNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9NYWluRnJhbWVTY3JvbGxiYXJHdGsuaCBcCkBAIC00OTc2 LDggKzQ5NzYsMTYgQEAgZG9tX2JpbmRpbmdfaWRscyArPSBcCiAJJChXZWJDb3JlKS9Nb2R1bGVz L2ZpbGVzeXN0ZW0vV29ya2VyQ29udGV4dEZpbGVTeXN0ZW0uaWRsCiAKIHdlYmNvcmVndGtfc291 cmNlcyArPSBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0ay5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGsuaCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbUd0ay5jcHAgXAotCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1HdGsuaAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1HdGsuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgKIGVuZGlmICMgRU5EIEVOQUJMRV9GSUxFX1NZ U1RFTQogCiAjIC0tLS0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5 c3RlbS9Mb2NhbEZpbGVTeXN0ZW0uY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lz dGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAKaW5kZXggOGYwMTY5ZWVhYmJhOTNmZjRmMTU2ZDdjMjM0 N2I2YzBiMjdkNWJiYS4uNzNmMjE4YjRhMDM3MWQwMDRhMTRjYmEwMTgyNjFjOGIyZTQ5YzY2NCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5 c3RlbS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmls ZVN5c3RlbS5jcHAKQEAgLTMxLDggKzMxLDggQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNs dWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKIAotI2lmIFBMQVRGT1JNKENIUk9NSVVNKQotI2Vycm9y ICJDaHJvbWl1bSBzaG91bGQgbm90IGNvbXBpbGUgdGhpcyBmaWxlIGFuZCBpbnN0ZWFkIGRlZmlu ZSBpdHMgb3duIHZlcnNpb24gb2YgdGhlc2UgZmFjdG9yaWVzLiIKKyNpZiBQTEFURk9STShDSFJP TUlVTSkgfHwgUExBVEZPUk0oR1RLKQorI2Vycm9yICJDaHJvbWl1bSAmIFdlYktpdEdUSysgc2hv dWxkIG5vdCBjb21waWxlIHRoaXMgZmlsZSBhbmQgaW5zdGVhZCBkZWZpbmUgaXRzIG93biB2ZXJz aW9uIG9mIHRoZXNlIGZhY3Rvcmllcy4iCiAjZW5kaWYKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTZlMjY2N2NkYjYwYzk4YTMzNzU0 ZTcwMGM5YWU0OWZlMWFjM2YxMQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwCkBAIC0wLDAgKzEsMTYz IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtA Z21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAq IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZl ZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxv bmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3 YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisg KiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorCisjaWYgRU5BQkxFKEZJ TEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtR3RrLmgiCisjaW5jbHVkZSAi QXN5bmNGaWxlV3JpdGVyLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVk ZSAiRmlsZU1ldGFkYXRhLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgor CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK K3RlbXBsYXRlPD4gc3RydWN0IENyb3NzVGhyZWFkQ29waWVyQmFzZTxmYWxzZSwgZmFsc2UsIEZp bGVNZXRhZGF0YT4geworICAgIHR5cGVkZWYgRmlsZU1ldGFkYXRhIFR5cGU7CisgICAgc3RhdGlj IEZpbGVNZXRhZGF0YSBjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYpOworfTsKKworQ3Jvc3NUaHJl YWRDb3BpZXJCYXNlPGZhbHNlLCBmYWxzZSwgRmlsZU1ldGFkYXRhPjo6VHlwZSBDcm9zc1RocmVh ZENvcGllckJhc2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0YWRhdGE+Ojpjb3B5KGNvbnN0IEZpbGVN ZXRhZGF0YSYgb3JpZ2luYWwpCit7CisgICAgRmlsZU1ldGFkYXRhIG1ldGFkYXRhOworICAgIG1l dGFkYXRhLm1vZGlmaWNhdGlvblRpbWUgPSBvcmlnaW5hbC5tb2RpZmljYXRpb25UaW1lOworICAg IG1ldGFkYXRhLmxlbmd0aCA9IG9yaWdpbmFsLmxlbmd0aDsKKyAgICBtZXRhZGF0YS50eXBlID0g b3JpZ2luYWwudHlwZTsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBvcmlnaW5hbC5wbGF0 Zm9ybVBhdGg7CisgICAgcmV0dXJuIG1ldGFkYXRhOworfQorCitQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0az4gQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUo U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4g YWRvcHRQdHIobmV3IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhjb250ZXh0LCBjYWxsYmFj a3MsIHN5bmNocm9ub3VzKSk7Cit9CisKK1Bhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrPiBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIFBhc3NPd25QdHI8QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICBy ZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayh0YXNrQ29udHJv bGxlciwgY2FsbGJhY2tzLCBtb2RlKSk7Cit9CisKKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywg Ym9vbCBzeW5jaHJvbm91cykKKyAgICA6IG1fc3luY2hyb25vdXMoc3luY2hyb25vdXMpCisgICAg LCBtX3Rhc2tNb2RlKCIiKQorICAgICwgbV90YXNrQ29udHJvbGxlcihBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0azo6Y3JlYXRlKGNvbnRleHQsIHN5bmNocm9ub3VzKSkKKyAgICAsIG1f Y2FsbGJhY2tzKGNhbGxiYWNrcykKK3sKK30KKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr OjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsqIHRhc2tDb250cm9sbGVyLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3N5bmNocm9ub3VzKGZh bHNlKQorICAgICwgbV90YXNrTW9kZShtb2RlKQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNr Q29udHJvbGxlcikKKyAgICAsIG1fY2FsbGJhY2tzKGNhbGxiYWNrcykKK3sKK30KKworc3RhdGlj IHZvaWQgcGVyZm9ybURpZFN1Y2NlZWRDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBj YWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGs6OmRpZFN1Y2NlZWQoKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFj a1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrLCBtX2Nh bGxiYWNrcy5yZWxlYXNlKCkpLCBtX3Rhc2tNb2RlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9y bURpZE9wZW5GaWxlU3lzdGVtQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYg bmFtZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgY2Fs bGJhY2tzLT5kaWRPcGVuRmlsZVN5c3RlbShuYW1lLCBmaWxlU3lzdGVtKTsKK30KKwordm9pZCBB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmlu ZyYgbmFtZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAg QXN5bmNGaWxlU3lzdGVtR3RrKiBmaWxlU3lzdGVtR3RrID0gc3RhdGljX2Nhc3Q8QXN5bmNGaWxl U3lzdGVtR3RrKj4oZmlsZVN5c3RlbS5nZXQoKSk7CisKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFz a0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRDdXJy ZW50VGFza01vZGUobW9kZSk7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFz ayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNrLCBt X2NhbGxiYWNrcy5yZWxlYXNlKCksIG5hbWUsIGZpbGVTeXN0ZW0pLCBtb2RlKTsKKworICAgIGZp bGVTeXN0ZW1HdGstPnNldFRhc2tDb250cm9sbGVyKG1fdGFza0NvbnRyb2xsZXIucmVsZWFzZSgp KTsKKyAgICBmaWxlU3lzdGVtR3RrLT53YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworfQor CitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkUmVhZE1ldGFkYXRhQ2FsbGJhY2soU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFj a3MsIGNvbnN0IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7CisgICAgY2FsbGJhY2tzLT5kaWRS ZWFkTWV0YWRhdGEobWV0YWRhdGEpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6ZGlkUmVhZE1ldGFkYXRhKGNvbnN0IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7Cisg ICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2so JnBlcmZvcm1EaWRSZWFkTWV0YWRhdGFDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBt ZXRhZGF0YSksIG1fdGFza01vZGUpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6ZGlkUmVhZERpcmVjdG9yeUVudHJ5KGNvbnN0IFN0cmluZyYgbmFtZSwgYm9vbCBpc0Rp cmVjdG9yeSkKK3sKKyAgICBEaXJlY3RvcnlFbnRyeSBkaXJlY3RvcnlFbnRyeTsKKyAgICBkaXJl Y3RvcnlFbnRyeS5uYW1lID0gbmFtZTsKKyAgICBkaXJlY3RvcnlFbnRyeS5pc0RpcmVjdG9yeSA9 IGlzRGlyZWN0b3J5OworICAgIG1fZGlyZWN0b3J5RW50cmllcy5hcHBlbmQoZGlyZWN0b3J5RW50 cnkpOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkUmVhZERpcmVjdG9yeUVudHJpZXNBbmRG aW5pc2hlZENhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIGNhbGxiYWNrcy0+ZGlkUmVh ZERpcmVjdG9yeUVudHJpZXMoZmFsc2UpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrc0d0azo6ZGlkUmVhZERpcmVjdG9yeUVudHJpZXMoYm9vbCBoYXNNb3JlKQoreworICAgIGlm IChoYXNNb3JlKQorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKworICAgIFZlY3RvcjxE aXJlY3RvcnlFbnRyeT46Oml0ZXJhdG9yIGVuZCA9IG1fZGlyZWN0b3J5RW50cmllcy5lbmQoKTsK KyAgICBmb3IgKFZlY3RvcjxEaXJlY3RvcnlFbnRyeT46Oml0ZXJhdG9yIGl0ID0gbV9kaXJlY3Rv cnlFbnRyaWVzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKKyAgICAgICAgbV9jYWxsYmFja3Mt PmRpZFJlYWREaXJlY3RvcnlFbnRyeShpdC0+bmFtZSwgaXQtPmlzRGlyZWN0b3J5KTsKKworICAg IG1fZGlyZWN0b3J5RW50cmllcy5jbGVhcigpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9z dENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRSZWFkRGlyZWN0b3J5 RW50cmllc0FuZEZpbmlzaGVkQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSksIG1fdGFz a01vZGUpOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxi YWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4gY2FsbGJhY2tzLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBs b25nIGxvbmcgbGVuZ3RoKQoreworICAgIGNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcih3 cml0ZXIsIGxlbmd0aCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpk aWRDcmVhdGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiB3cml0ZXIsIGxv bmcgbG9uZyBsZW5ndGgpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFz ayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2ss IG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgd3JpdGVyLCBsZW5ndGgpLCBtX3Rhc2tNb2RlKTsKK30K Kworc3RhdGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgaW50 IGNvZGUpCit7CisgICAgY2FsbGJhY2tzLT5kaWRGYWlsKGNvZGUpOworfQorCit2b2lkIEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkRmFpbChpbnQgY29kZSkKK3sKKyAgICBtX3Rhc2tD b250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURp ZEZhaWxDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBjb2RlKSwgbV90YXNrTW9kZSk7 Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZ U1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hODdkNTQ2OWZhMTYzZTcxMDA0MzYz NTA3N2QzYTA2ZDc5NDAxYmQ1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oCkBAIC0wLDAgKzEsNjkgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFp bC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJv c3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0a19oCisjZGVmaW5lIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisKKyNp ZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3MuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisj aW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFz cyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGsgOiBwdWJsaWMgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAgICBz dGF0aWMgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0ZShTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ LCBib29sIHN5bmNocm9ub3VzID0gZmFsc2UpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrKiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJp bmcmIG1vZGUpOworCisgICAgdmlydHVhbCB2b2lkIGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFs IHZvaWQgZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbT4pOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3Qg RmlsZU1ldGFkYXRhJik7CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShj b25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBk aWRSZWFkRGlyZWN0b3J5RW50cmllcyhib29sIGhhc01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBk aWRDcmVhdGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiwgbG9uZyBsb25n IGxlbmd0aCk7CisgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoaW50IGNvZGUpOworCitwcml2YXRl OgorICAgIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3Vz KTsKKyAgICBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGsqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0 IFN0cmluZyYgbW9kZSk7CisKKyAgICBzdHJ1Y3QgRGlyZWN0b3J5RW50cnkgeworICAgICAgICBT dHJpbmcgbmFtZTsKKyAgICAgICAgYm9vbCBpc0RpcmVjdG9yeTsKKworICAgICAgICBEaXJlY3Rv cnlFbnRyeSgpIDogaXNEaXJlY3RvcnkoZmFsc2UpIHsgfQorICAgIH07CisKKyAgICBib29sIG1f c3luY2hyb25vdXM7CisgICAgU3RyaW5nIG1fdGFza01vZGU7CisgICAgUmVmUHRyPEFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIE93blB0cjxB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IG1fY2FsbGJhY2tzOworICAgIFZlY3RvcjxEaXJlY3Rv cnlFbnRyeT4gbV9kaXJlY3RvcnlFbnRyaWVzOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2Vu ZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNG aWxlU3lzdGVtR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVT eXN0ZW1HdGsuY3BwCmluZGV4IGMxZGIwMDZhODQ4ZjM5MjZkZDlmZWMzMWY5NjRhMGZkYmRhZjY5 ZmMuLjk3OTcxMDMzYmU5NmM2YzRhYmI1ZDc2NGI2MTQ0MGUyYmFlYWU0MWMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCkBAIC0x LDQgKzEsNSBAQAogLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRv YmVyc2VrQGdtYWlsLmNvbT4KICAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNo aXZhbWlkb3dAZ21haWwuY29tPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTE4LDI3ICsxOSwzMyBAQAogICov CiAKICNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1HdGsuaCIK IAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIAotI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUd0 ay5oIgotCi0jaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLmgiCisjaW5jbHVkZSAi QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJHdGsuaCIKKyNp bmNsdWRlICJDcm9zc1RocmVhZFRhc2suaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCi0j aW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNs dWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8d3Rm L2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KKyNp bmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVp bGRlci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGJvb2wgQXN5bmNGaWxlU3lzdGVtOjpp c0F2YWlsYWJsZSgpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAgICByZXR1cm4gZmFsc2U7 CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIGJvb2wgQXN5bmNGaWxlU3lzdGVtOjppc1ZhbGlkVHlw ZShUeXBlIHR5cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAgICByZXR1cm4gZmFsc2U7 CisgICAgcmV0dXJuIHR5cGUgPT0gVGVtcG9yYXJ5IHx8IHR5cGUgPT0gUGVyc2lzdGVudDsKIH0K IAogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKFR5 cGUgdHlwZSkKQEAgLTQ4LDg3ICs1NSw0MDkgQEAgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+ IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkKIAogdm9pZCBBc3luY0ZpbGVTeXN0 ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYg c3RvcmFnZUlkZW50aWZpZXIsIFR5cGUgdHlwZSwgYm9vbCwgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAg IGNhbGxiYWNrcy0+ZGlkRmFpbChOT1RfU1VQUE9SVEVEX0VSUik7CisgICAgU3RyaW5nIHR5cGVT dHJpbmcgPSAodHlwZSA9PSBBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpID8gIlBlcnNpc3Rl bnQiIDogIlRlbXBvcmFyeSI7CisgICAgU3RyaW5nIG5hbWUgPSBzdG9yYWdlSWRlbnRpZmllciAr ICI6IiArIHR5cGVTdHJpbmc7CisKKyAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5h bWUsIEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHR5cGUpKTsKIH0KIAogYm9vbCBBc3luY0ZpbGVT eXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVSTChjb25zdCBLVVJMJiB1cmwsIEFzeW5jRmlsZVN5c3Rl bTo6VHlwZSYgdHlwZSwgU3RyaW5nJiBmaWxlUGF0aCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgp OwogICAgIHJldHVybiBmYWxzZTsKIH0KIAogQXN5bmNGaWxlU3lzdGVtR3RrOjpBc3luY0ZpbGVT eXN0ZW1HdGsoQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUpCiAgICAgOiBBc3luY0ZpbGVTeXN0 ZW0odHlwZSkKKyAgICAsIG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGgoTG9jYWxGaWxlU3lzdGVt Ojpsb2NhbEZpbGVTeXN0ZW0oKS5maWxlU3lzdGVtQmFzZVBhdGgoKSkKIHsKLSAgICBub3RJbXBs ZW1lbnRlZCgpOwogfQogCiBBc3luY0ZpbGVTeXN0ZW1HdGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGso KQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIFN0cmluZyBBc3luY0ZpbGVTeXN0ZW1H dGs6OnRvVVJMKGNvbnN0IFN0cmluZyYgb3JpZ2luU3RyaW5nLCBjb25zdCBTdHJpbmcmIGZ1bGxQ YXRoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuIFN0cmluZygpOworICAg IEFTU0VSVCghb3JpZ2luU3RyaW5nLmlzRW1wdHkoKSk7CisgICAgaWYgKG9yaWdpblN0cmluZyA9 PSBTdHJpbmcoIm51bGwiKSkKKyAgICAgICAgcmV0dXJuIFN0cmluZygpOworCisgICAgU3RyaW5n QnVpbGRlciByZXN1bHQ7CisgICAgcmVzdWx0LmFwcGVuZCgiZmlsZXN5c3RlbToiKTsKKyAgICBy ZXN1bHQuYXBwZW5kKG9yaWdpblN0cmluZyk7CisgICAgcmVzdWx0LmFwcGVuZCgiLyIpOworICAg IGlmICh0eXBlKCkgPT0gVGVtcG9yYXJ5KQorICAgICAgICByZXN1bHQuYXBwZW5kKHRlbXBvcmFy eVBhdGhQcmVmaXgpOworICAgIGlmICh0eXBlKCkgPT0gUGVyc2lzdGVudCkKKyAgICAgICAgcmVz dWx0LmFwcGVuZChwZXJzaXN0ZW50UGF0aFByZWZpeCk7CisgICAgcmVzdWx0LmFwcGVuZChlbmNv ZGVXaXRoVVJMRXNjYXBlU2VxdWVuY2VzKGZ1bGxQYXRoKSk7CisKKyAgICByZXR1cm4gcmVzdWx0 LnRvU3RyaW5nKCk7Cit9CisKK3N0YXRpYyB2b2lkIG1vdmVBc3luYyhTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNh bGxiYWNrcywgU3RyaW5nJiBzcmNQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQoreworICAgIEdSZWZQ dHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChzcmNQ YXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBkZXN0aW5hdGlvbkZpbGUg PSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51dGY4KCkuZGF0YSgpKSk7 CisKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gc291cmNlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVf cXVlcnlfaW5mbyhzb3VyY2VGaWxlLmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUs IDAsIDApKTsKKyAgICBpZiAoIXNvdXJjZUluZm8pIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tz LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZGVzdGluYXRpb25JbmZvID0gYWRvcHRHUmVm KGdfZmlsZV9xdWVyeV9pbmZvKGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVF UllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKGRlc3RpbmF0aW9uSW5mbykgeworICAgICAg ICBHRmlsZVR5cGUgc291cmNlRmlsZVR5cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKHNv dXJjZUluZm8uZ2V0KCkpOworICAgICAgICBHRmlsZVR5cGUgZGVzdGluYXRpb25GaWxlVHlwZSA9 IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZGVzdGluYXRpb25JbmZvLmdldCgpKTsKKworICAg ICAgICBpZiAoc291cmNlRmlsZVR5cGUgIT0gZGVzdGluYXRpb25GaWxlVHlwZSkgeworICAgICAg ICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklD QVRJT05fRVJSKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICBpZiAo ZGVzdGluYXRpb25GaWxlVHlwZSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkKKyAgICAgICAgICAg ICAgICAmJiAhZ19maWxlX2RlbGV0ZShkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIDAsIDApKSB7Cisg ICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpJTlZBTElEX01P RElGSUNBVElPTl9FUlIpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQor CisgICAgaWYgKCFnX2ZpbGVfbW92ZShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUu Z2V0KCksIEdfRklMRV9DT1BZX09WRVJXUklURSwgMCwgMCwgMCwgMCkpIHsKKyAgICAgICAgaGVs cGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0K IAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6Om1vdmUoY29uc3QgU3RyaW5nJiBzb3VyY2VQYXRo LCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0aW9uUGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0 cmluZyBzb3VyY2VGaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHNv dXJjZVBhdGgpOworICAgIFN0cmluZyBkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoID0gdmlydHVh bFBhdGhUb0ZpbGVTeXN0ZW1VUkwoZGVzdGluYXRpb25QYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9 IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXIt PnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmbW92ZUFzeW5jLCBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBj YWxsYmFja3MsIG1vZGUpLCBzb3VyY2VGaWxlU3lzdGVtUGF0aCwgZGVzdGluYXRpb25GaWxlU3lz dGVtUGF0aCkpOworfQorCitzdGF0aWMgdm9pZCBjb3B5UmVjdXJzaXZlbHkoR0ZpbGUqIHNvdXJj ZURpcmVjdG9yeSwgR0ZpbGUqIGRlc3RpbmF0aW9uRGlyZWN0b3J5LCBHRXJyb3IqKiBlcnJvcikK K3sKKyAgICBpZiAoIWdfZmlsZV9tYWtlX2RpcmVjdG9yeShkZXN0aW5hdGlvbkRpcmVjdG9yeSwg MCwgZXJyb3IpKQorICAgICAgICByZXR1cm47CisKKyAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9y eShnX2Rpcl9vcGVuKGdfZmlsZV9nZXRfcGF0aChzb3VyY2VEaXJlY3RvcnkpLCAwLCBlcnJvcikp OworICAgIGlmICghZGlyZWN0b3J5KQorICAgICAgICByZXR1cm47CisKKyAgICB3aGlsZSAoY29u c3QgY2hhciogZGlyZWN0b3J5RW50cnkgPSBjb25zdF9jYXN0PGNoYXIqPihnX2Rpcl9yZWFkX25h bWUoZGlyZWN0b3J5LmdldCgpKSkpIHsKKyAgICAgICAgR1JlZlB0cjxHRmlsZT4gc291cmNlRmls ZSA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0X2NoaWxkKHNvdXJjZURpcmVjdG9yeSwgZGlyZWN0b3J5 RW50cnkpKTsKKyAgICAgICAgR1JlZlB0cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRH UmVmKGdfZmlsZV9nZXRfY2hpbGQoZGVzdGluYXRpb25EaXJlY3RvcnksIGRpcmVjdG9yeUVudHJ5 KSk7CisKKyAgICAgICAgR1JlZlB0cjxHRmlsZUluZm8+IHNvdXJjZUluZm8gPSBhZG9wdEdSZWYo Z19maWxlX3F1ZXJ5X2luZm8oc291cmNlRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5G T19OT05FLCAwLCBlcnJvcikpOworICAgICAgICBpZiAoIXNvdXJjZUluZm8pCisgICAgICAgICAg ICByZXR1cm47CisgICAgICAgIGlmIChnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKHNvdXJjZUlu Zm8uZ2V0KCkpID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkgeworICAgICAgICAgICAgY29weVJl Y3Vyc2l2ZWx5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgZXJyb3Ip OworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgICAgIGlmICghZ19maWxlX2Nv cHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGluYXRpb25GaWxlLmdldCgpLCBHX0ZJTEVfQ09QWV9O T05FLCAwLCAwLCAwLCBlcnJvcikpCisgICAgICAgICAgICByZXR1cm47CisgICAgfQorfQorCitz dGF0aWMgdm9pZCBjb3B5QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIFN0cmluZyYgc291 cmNlUGF0aCwgU3RyaW5nJiBkZXN0UGF0aCkKK3sKKyAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VG aWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoc291cmNlUGF0aC51dGY4KCkuZGF0 YSgpKSk7CisgICAgR1JlZlB0cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdf ZmlsZV9uZXdfZm9yX3BhdGgoZGVzdFBhdGgudXRmOCgpLmRhdGEoKSkpOworCisgICAgR1JlZlB0 cjxHRmlsZUluZm8+IHNvdXJjZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oc291 cmNlRmlsZS5nZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAg aWYgKCFzb3VyY2VJbmZvKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxl RXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR0Zp bGVUeXBlIHNvdXJjZUZpbGVUeXBlID0gZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShzb3VyY2VJ bmZvLmdldCgpKTsKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZGVzdGluYXRpb25JbmZvID0gYWRv cHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgIioiLCBHX0ZJ TEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKGRlc3RpbmF0aW9uSW5mbykgewor ICAgICAgICBHRmlsZVR5cGUgZGVzdGluYXRpb25GaWxlVHlwZSA9IGdfZmlsZV9pbmZvX2dldF9m aWxlX3R5cGUoZGVzdGluYXRpb25JbmZvLmdldCgpKTsKKyAgICAgICAgaWYgKHNvdXJjZUZpbGVU eXBlICE9IGRlc3RpbmF0aW9uRmlsZVR5cGUpIHsKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNr cy0+ZGlkRmFpbChGaWxlRXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUik7CisgICAgICAg ICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAgaWYgKGRlc3RpbmF0aW9uRmlsZVR5cGUg PT0gR19GSUxFX1RZUEVfRElSRUNUT1JZCisgICAgICAgICAgICAgICAgJiYgIWdfZmlsZV9kZWxl dGUoZGVzdGluYXRpb25GaWxlLmdldCgpLCAwLCAwKSkgeworICAgICAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSKTsKKyAg ICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgIH0KKworICAgIGlmIChzb3VyY2VGaWxl VHlwZSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpIHsKKyAgICAgICAgR093blB0cjxHRXJyb3I+ IGVycm9yOworICAgICAgICBjb3B5UmVjdXJzaXZlbHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGlu YXRpb25GaWxlLmdldCgpLCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBpZiAoZXJyb3IpCisg ICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRf RVJSKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNj ZWVkKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoIWdfZmlsZV9jb3B5KHNv dXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgR19GSUxFX0NPUFlfT1ZFUldS SVRFLCAwLCAwLCAwLCAwKSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmls ZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhl bHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0 azo6Y29weShjb25zdCBTdHJpbmcmIHNvdXJjZVBhdGgsIGNvbnN0IFN0cmluZyYgZGVzdGluYXRp b25QYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQog ewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIHNvdXJjZUZpbGVTeXN0ZW1QYXRo ID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwoc291cmNlUGF0aCk7CisgICAgU3RyaW5nIGRl c3RpbmF0aW9uRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChkZXN0 aW5hdGlvblBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVl TW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3Jl YXRlQ2FsbGJhY2tUYXNrKCZjb3B5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIHNvdXJjZUZp bGVTeXN0ZW1QYXRoLCBkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoKSk7Cit9CisKK3N0YXRpYyB2 b2lkIHJlbW92ZUZpbGUoR0ZpbGUqIGZpbGUsIGJvb2wgcmVjdXJzaXZlLCBHRXJyb3IqKiBlcnJv cikKK3sKKyAgICBpZiAocmVjdXJzaXZlICYmIGdfZmlsZV90ZXN0KGdfZmlsZV9nZXRfcGF0aChm aWxlKSwgR19GSUxFX1RFU1RfSVNfRElSKSkgeworICAgICAgICBHT3duUHRyPEdEaXI+IGRpcmVj dG9yeShnX2Rpcl9vcGVuKGdfZmlsZV9nZXRfcGF0aChmaWxlKSwgMCwgZXJyb3IpKTsKKyAgICAg ICAgaWYgKCFkaXJlY3RvcnkpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgd2hpbGUg KGNvbnN0IGNoYXIqIGRpcmVjdG9yeUVudHJ5ID0gY29uc3RfY2FzdDxjaGFyKj4oZ19kaXJfcmVh ZF9uYW1lKGRpcmVjdG9yeS5nZXQoKSkpKSB7CisgICAgICAgICAgICBHUmVmUHRyPEdGaWxlPiBj aGlsZCA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0X2NoaWxkKGZpbGUsIGRpcmVjdG9yeUVudHJ5KSk7 CisgICAgICAgICAgICByZW1vdmVGaWxlKGNoaWxkLmdldCgpLCByZWN1cnNpdmUsIGVycm9yKTsK KyAgICAgICAgICAgIGlmICgqZXJyb3IpCisgICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAg ICB9CisgICAgfQorCisgICAgZ19maWxlX2RlbGV0ZShmaWxlLCAwLCBlcnJvcik7Cit9CisKK3N0 YXRpYyB2b2lkIHJlbW92ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGZp bGVQYXRoLCBib29sIHJlY3Vyc2l2ZSkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7Cisg ICAgR1JlZlB0cjxHRmlsZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZp bGVQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICByZW1vdmVGaWxlKGZpbGUuZ2V0KCksIHJlY3Vy c2l2ZSwgJmVycm9yLm91dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgRmlsZUVy cm9yOjpFcnJvckNvZGUgZXJyb3JDb2RlOworICAgICAgICBzd2l0Y2ggKGVycm9yLT5jb2RlKSB7 CisgICAgICAgIGNhc2UgR19JT19FUlJPUl9OT1RfRU1QVFk6CisgICAgICAgICAgICBlcnJvckNv ZGUgPSBGaWxlRXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUjsKKyAgICAgICAgICAgIGJy ZWFrOworICAgICAgICBjYXNlIEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAgICAgICBkZWZhdWx0 OgorICAgICAgICAgICAgZXJyb3JDb2RlID0gRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSOworICAg ICAgICB9CisKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKGVycm9yQ29kZSk7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQo KTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZShjb25zdCBTdHJpbmcmIHBh dGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0g ICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFs UGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRy b2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9N YWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVtb3ZlQXN5bmMsIEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywg bW9kZSksIGZpbGVTeXN0ZW1QYXRoLCBmYWxzZSkpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3Rl bUd0azo6cmVtb3ZlUmVjdXJzaXZlbHkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1V UkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2Rl KCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVD YWxsYmFja1Rhc2soJnJlbW92ZUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNy ZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVt UGF0aCwgdHJ1ZSkpOworfQorCitzdGF0aWMgdm9pZCByZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRF eGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+ IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBmaWxlUGF0aCkKK3sKKyAgICBHUmVmUHRyPEdGaWxl PiBmaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoZmlsZVBhdGgudXRmOCgpLmRh dGEoKSkpOworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2Zp bGVfcXVlcnlfaW5mbyhmaWxlLmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAs IDApKTsKKyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlk RmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQor CisgICAgRmlsZU1ldGFkYXRhOjpUeXBlIHR5cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBl KGZpbGVJbmZvLmdldCgpKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkgPyBGaWxlTWV0YWRhdGE6 OlR5cGVEaXJlY3RvcnkgOiBGaWxlTWV0YWRhdGE6OlR5cGVGaWxlOworCisgICAgR1RpbWVWYWwg dGltZVZhbHVlOworICAgIGdfZmlsZV9pbmZvX2dldF9tb2RpZmljYXRpb25fdGltZShmaWxlSW5m by5nZXQoKSwgJnRpbWVWYWx1ZSk7CisKKyAgICBGaWxlTWV0YWRhdGEgbWV0YWRhdGE7CisgICAg bWV0YWRhdGEudHlwZSA9IHR5cGU7CisgICAgbWV0YWRhdGEubW9kaWZpY2F0aW9uVGltZSA9IHN0 YXRpY19jYXN0PGRvdWJsZT4odGltZVZhbHVlLnR2X3NlYyk7CisgICAgbWV0YWRhdGEubGVuZ3Ro ID0gdHlwZSA9PSBGaWxlTWV0YWRhdGE6OlR5cGVGaWxlID8gc3RhdGljX2Nhc3Q8bG9uZyBsb25n PihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5nZXQoKSkpIDogMDsKKyAgICBtZXRhZGF0 YS5wbGF0Zm9ybVBhdGggPSBTdHJpbmcoZ19maWxlX2dldF9wYXRoKGZpbGUuZ2V0KCkpKTsKKwor ICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkUmVhZE1ldGFkYXRhKG1ldGFkYXRhKTsKIH0KIAogdm9p ZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWRNZXRhZGF0YShjb25zdCBTdHJpbmcmIHBhdGgsIFBh c3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90 SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRv RmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXIt PnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhy ZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVhZE1ldGFkYXRhQXN5bmMsIEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywg bW9kZSksIGZpbGVTeXN0ZW1QYXRoKSk7CiB9CiAKLXZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpj cmVhdGVGaWxlKGNvbnN0IFN0cmluZyYgcGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCitzdGF0aWMgdm9pZCBjcmVhdGVP YmplY3RBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBsb2NhbEZpbGVTeXN0 ZW1QYXRoLCBTdHJpbmcmIGFic29sdXRlUGF0aCwgR0ZpbGVUeXBlIHR5cGUpCiB7Ci0gICAgbm90 SW1wbGVtZW50ZWQoKTsKKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSICYmIGFi c29sdXRlUGF0aCA9PSBTdHJpbmcoIi8iKSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRp ZEZhaWwoRmlsZUVycm9yOjpTRUNVUklUWV9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQor CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBh ZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChsb2NhbEZpbGVTeXN0ZW1QYXRoLnV0ZjgoKS5k YXRhKCkpKTsKKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSKQorICAgICAgICBH UmVmUHRyPEdGaWxlT3V0cHV0U3RyZWFtPiBvdXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxl X2NyZWF0ZShmaWxlLmdldCgpLCBHX0ZJTEVfQ1JFQVRFX05PTkUsIDAsICZlcnJvci5vdXRQdHIo KSkpOworICAgIGVsc2UgaWYgKHR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZKQorICAgICAg ICBnX2ZpbGVfbWFrZV9kaXJlY3RvcnkoZmlsZS5nZXQoKSwgMCwgJmVycm9yLm91dFB0cigpKTsK KyAgICBlbHNlCisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworCisgICAgaWYgKGVycm9y KSB7CisgICAgICAgIEZpbGVFcnJvcjo6RXJyb3JDb2RlIGVycm9yQ29kZTsKKyAgICAgICAgc3dp dGNoIChlcnJvci0+Y29kZSkgeworICAgICAgICBjYXNlIEdfSU9fRVJST1JfRVhJU1RTOgorICAg ICAgICAgICAgZXJyb3JDb2RlID0gRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlI7 CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBHX0lPX0VSUk9SX05PVF9GT1VORDoK KyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6Tk9U X0ZPVU5EX0VSUjsKKyAgICAgICAgfQorICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwo ZXJyb3JDb2RlKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBlckNhbGxiYWNr cy0+ZGlkU3VjY2VlZCgpOwogfQogCi12b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGly ZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0 azo6Y3JlYXRlT2JqZWN0KFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxs YmFja3MsIGNvbnN0IFN0cmluZyYgYWJzb2x1dGVQYXRoLCBHRmlsZVR5cGUgdHlwZSkKIHsKLSAg ICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBsb2NhbEZpbGVTeXN0ZW1QYXRoID0gdmly dHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwoYWJzb2x1dGVQYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9 IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXIt PnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY3JlYXRlT2JqZWN0QXN5 bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIu Z2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGxvY2FsRmlsZVN5c3RlbVBhdGgsIGFic29sdXRlUGF0 aCwgdHlwZSkpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZShjb25z dCBTdHJpbmcmIGFic29sdXRlUGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY3JlYXRlT2JqZWN0KGNhbGxi YWNrcywgYWJzb2x1dGVQYXRoLCBHX0ZJTEVfVFlQRV9SRUdVTEFSKTsKK30KKwordm9pZCBBc3lu Y0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVjdG9yeShjb25zdCBTdHJpbmcmIGFic29sdXRlUGF0 aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBj YWxsYmFja3MpCit7CisgICAgY3JlYXRlT2JqZWN0KGNhbGxiYWNrcywgYWJzb2x1dGVQYXRoLCBH X0ZJTEVfVFlQRV9ESVJFQ1RPUlkpOworfQorCitzdGF0aWMgdm9pZCBvYmplY3RFeGlzdHNBc3lu YyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBwYXRoLCBHRmlsZVR5cGUgdHlwZSkK K3sKKyAgICBHUmVmUHRyPEdGaWxlPiBvYmplY3QgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3Jf cGF0aChwYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUlu Zm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8ob2JqZWN0LmdldCgpLCAiKiIsIEdfRklM RV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAgICAg IGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAg ICAgICByZXR1cm47CisgICAgfQorICAgIGlmIChnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZp bGVJbmZvLmdldCgpKSAhPSB0eXBlKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFp bChGaWxlRXJyb3I6OlRZUEVfTUlTTUFUQ0hfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmls ZVN5c3RlbUd0azo6ZmlsZUV4aXN0cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVS TChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUo KTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNh bGxiYWNrVGFzaygmb2JqZWN0RXhpc3RzQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVT eXN0ZW1QYXRoLCBHX0ZJTEVfVFlQRV9SRUdVTEFSKSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lz dGVtR3RrOjpkaXJlY3RvcnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1V UkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2Rl KCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVD YWxsYmFja1Rhc2soJm9iamVjdEV4aXN0c0FzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxl U3lzdGVtUGF0aCwgR19GSUxFX1RZUEVfRElSRUNUT1JZKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJl YWREaXJlY3RvcnlBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNhbGxiYWNrcywgU3RyaW5nJiBwYXRoKQoreworICAg IEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxlPiBkaXJlY3RvcnlGaWxl ID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgocGF0aC51dGY4KCkuZGF0YSgpKSk7CisK KyAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9yeShnX2Rpcl9vcGVuKHBhdGgudXRmOCgpLmRhdGEo KSwgMCwgJmVycm9yLm91dFB0cigpKSk7CisgICAgaWYgKCFlcnJvcikgeworICAgICAgICB3aGls ZSAoY29uc3QgY2hhciogZGlyZWN0b3J5RW50cnkgPSBjb25zdF9jYXN0PGNoYXIqPihnX2Rpcl9y ZWFkX25hbWUoZGlyZWN0b3J5LmdldCgpKSkpIHsKKyAgICAgICAgICAgIEdSZWZQdHI8R0ZpbGU+ IGNoaWxkID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQoZGlyZWN0b3J5RmlsZS5nZXQoKSwg ZGlyZWN0b3J5RW50cnkpKTsKKyAgICAgICAgICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5m byA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhjaGlsZC5nZXQoKSwgIioiLCBHX0ZJTEVf UVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisKKyAgICAgICAgICAgIGJvb2wgaXNFbnRyeURpcmVj dG9yeSA9IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZmlsZUluZm8uZ2V0KCkpID09IEdfRklM RV9UWVBFX0RJUkVDVE9SWTsKKyAgICAgICAgICAgIGNhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9y eUVudHJ5KFN0cmluZyhkaXJlY3RvcnlFbnRyeSksIGlzRW50cnlEaXJlY3RvcnkpOworICAgICAg ICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAgY2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6 Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBjYWxsYmFja3Mt PmRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKGZhbHNlKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0 ZW1HdGs6OnJlYWREaXJlY3RvcnkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7 CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwo cGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7 CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxs YmFja1Rhc2soJnJlYWREaXJlY3RvcnlBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr OjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgZmlsZVN5 c3RlbVBhdGgpKTsKIH0KIAorc3RhdGljIHZvaWQgY3JlYXRlV3JpdGVyQXN5bmMoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBo ZWxwZXJDYWxsYmFja3MsIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIFN0cmluZyYgcGF0aCkKK3sK KyAgICBHUmVmUHRyPEdGaWxlPiBmaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgo cGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGZpbGVJbmZvID0g YWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKGZpbGUuZ2V0KCksICIqIiwgR19GSUxFX1FVRVJZ X0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlmICghZmlsZUluZm8pIHsKKyAgICAgICAgaGVscGVy Q2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisKKyAgICBsb25nIGxvbmcgZmlsZVNpemUgPSBzdGF0aWNfY2FzdDxsb25n IGxvbmc+KGdfZmlsZV9pbmZvX2dldF9zaXplKGZpbGVJbmZvLmdldCgpKSk7CisgICAgaGVscGVy Q2FsbGJhY2tzLT5kaWRDcmVhdGVGaWxlV3JpdGVyKEFzeW5jRmlsZVdyaXRlckd0azo6Y3JlYXRl KGNsaWVudCwgdGFza0NvbnRyb2xsZXIsIGZpbGUubGVha1JlZigpKSwgZmlsZVNpemUpOworfQog CiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlV3JpdGVyKEFzeW5jRmlsZVdyaXRlckNs aWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBT dHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsK KyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAg IG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFz aygmY3JlYXRlV3JpdGVyQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRl KG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIEFsbG93Q3Jvc3NUaHJl YWRBY2Nlc3MoY2xpZW50KSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX3Rhc2tDb250cm9sbGVy LmdldCgpKSwgZmlsZVN5c3RlbVBhdGgpKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6 OmNyZWF0ZVNuYXBzaG90RmlsZUFuZFJlYWRNZXRhZGF0YShjb25zdCBTdHJpbmcmIHBhdGgsIFBh c3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgLy8g RklYTUU6IElzIHRoaXMgYXBpIHJlYWxseSBzYW1lIHdpdGggcmVhZE1ldGFkYXRhPworICAgIHJl YWRNZXRhZGF0YShwYXRoLCBjYWxsYmFja3MpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0 azo6c2V0VGFza0NvbnRyb2xsZXIoUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0az4gdGFza0NvbnRyb2xsZXIpCit7CisgICAgbV90YXNrQ29udHJvbGxlciA9IHRhc2tD b250cm9sbGVyOworfQorCitTdHJpbmcgQXN5bmNGaWxlU3lzdGVtR3RrOjp2aXJ0dWFsUGF0aFRv RmlsZVN5c3RlbVVSTChjb25zdCBTdHJpbmcmIHZpcnR1YWxQYXRoKQoreworICAgIHJldHVybiB2 aXJ0dWFsUGF0aCAhPSBTdHJpbmcoIi8iKSA/IG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGggKyB2 aXJ0dWFsUGF0aCA6IG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGg7Cit9CisKK2Jvb2wgQXN5bmNG aWxlU3lzdGVtR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgcmV0dXJu IG1fdGFza0NvbnRyb2xsZXItPndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCk7CiB9CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVTeXN0ZW1HdGsuaAppbmRleCBjYjQ1YjZlYTRiYzIwMjBlOGViNGM4ZWI1YTE5OGYw NzZmNWE2OTdiLi44MjAxOGYxNzUzYmEyZTdiMzg3ZDY3OTk3YWZkNDRlZTU3ODhjYzU0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oCkBA IC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNo aXZhbWlkb3dAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8 emFuZG9iZXJzZWtAZ21haWwuY29tPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKQEAgLTIzLDExICsyMywx NCBAQAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIAogI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bS5oIgorCisjaW5jbHVkZSA8Z2lvL2dpby5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+ CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz OworY2xhc3MgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs7CiAKIGNsYXNzIEFzeW5j RmlsZVN5c3RlbUd0ayA6IHB1YmxpYyBBc3luY0ZpbGVTeXN0ZW0gewogcHVibGljOgpAQCAtNDYs NiArNDksMTYgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBkaXJlY3RvcnlFeGlzdHMoY29u c3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwog ICAgIHZpcnR1YWwgdm9pZCByZWFkRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKICAgICB2aXJ0dWFsIHZvaWQgY3JlYXRl V3JpdGVyKEFzeW5jRmlsZVdyaXRlckNsaWVudCosIGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKKyAgICB2aXJ0dWFsIHZvaWQgY3JlYXRl U25hcHNob3RGaWxlQW5kUmVhZE1ldGFkYXRhKGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKKyAgICB2aXJ0dWFsIGJvb2wgd2FpdEZvck9w ZXJhdGlvblRvQ29tcGxldGUoKTsKKworICAgIHZvaWQgc2V0VGFza0NvbnRyb2xsZXIoUGFzc1Jl ZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4pOworcHJpdmF0ZToKKyAgICB2 b2lkIGNyZWF0ZU9iamVjdChQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNv bnN0IFN0cmluZyYgYWJzb2x1dGVQYXRoLCBHRmlsZVR5cGUpOworICAgIFN0cmluZyB2aXJ0dWFs UGF0aFRvRmlsZVN5c3RlbVVSTChjb25zdCBTdHJpbmcmKTsKKworICAgIFN0cmluZyBtX2xvY2Fs RmlsZVN5c3RlbUJhc2VQYXRoOworICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0az4gbV90YXNrQ29udHJvbGxlcjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU4YTY5MDVjOTJkZWVm YjMwOTUzYjA1Y2RlOGI1NGU3NmY5NzAxZjAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwCkBA IC0wLDAgKzEsOTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6 YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJz aW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQg aXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICog TGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJl ZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0 aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIK KworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNz UmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0azo6Y3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQs IGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ayhjb250ZXh0LCBzeW5jaHJvbm91cykpOworfQorCitBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9vbCBzeW5jaHJvbm91cykK KyAgICA6IG1fY29udGV4dChjb250ZXh0KQorICAgICwgbV9zeW5jaHJvbm91cyhzeW5jaHJvbm91 cykKKyAgICAsIG1fY3VycmVudFRhc2tNb2RlKCIiKQorICAgICwgbV93cml0ZXJUb0NhbmNlbCgw KQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdva2VycyBmb3IgZmlsZXN5c3Rl bSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKK30KKworQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0aygpCit7Cit9CisKK1N0cmluZyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6 dW5pcXVlTW9kZSgpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZv ciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOwor ICAgIHJldHVybiBTdHJpbmcoKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azo6cG9zdFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPiB0YXNrKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdv a2VycyBmb3IgZmlsZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVu dCgpKTsKKyAgICBtX2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCit2b2lkIEFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzZXRDdXJyZW50VGFza01vZGUoY29uc3QgU3RyaW5n JiB0YXNrTW9kZSkKK3sKKyAgICBtX2N1cnJlbnRUYXNrTW9kZSA9IHRhc2tNb2RlOworfQorCit2 b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpwb3N0Q2FsbGJhY2tUYXNrKFBh c3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywgY29uc3QgU3RyaW5n JiBtb2RlKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdva2VycyBmb3IgZmls ZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKKyAgICBt X2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgQVNTRVJU KG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKKyAgICBBU1NFUlQoIW1fc3luY2hyb25vdXMpOwor ICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0azo6Y2FuY2VsV3JpdGVySWZOZWNlc3NhcnkoQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIp Cit7CisgICAgaWYgKG1fd3JpdGVyVG9DYW5jZWwgPT0gd3JpdGVyKSB7CisgICAgICAgIG1fd3Jp dGVyVG9DYW5jZWwgPSAwOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJu IGZhbHNlOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUo RklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjJkMWYy NzczM2ZmZjQzMTFkYWQ5MzkyNTAwODM4ZDIzNjQ1OGZiYmQKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGsuaApAQCAtMCwwICsxLDY0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2Jl cnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNz ZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBz aG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJs aWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8g dGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVl dCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lm bmRlZiBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0a19oCisjZGVmaW5lIEFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKwor I2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKworI2luY2x1ZGUgPHd0Zi9QYXNz UmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZFNhZmVSZWZDb3VudGVkLmg+CisjaW5jbHVk ZSA8d3RmL1RocmVhZGluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFzeW5j RmlsZVdyaXRlckd0azsKKworY2xhc3MgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsg OiBwdWJsaWMgVGhyZWFkU2FmZVJlZkNvdW50ZWQ8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGs+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0az4gY3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBib29sIHN5 bmNocm9ub3VzKTsKKyAgICB+QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoKTsKKwor ICAgIHZvaWQgcG9zdFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPik7CisgICAgdm9pZCBzZXRDdXJyZW50VGFza01vZGUoY29uc3QgU3RyaW5n Jik7CisgICAgdm9pZCBwb3N0Q2FsbGJhY2tUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9u Q29udGV4dDo6VGFzaz4sIGNvbnN0IFN0cmluZyYpOworICAgIGJvb2wgd2FpdEZvck9wZXJhdGlv blRvQ29tcGxldGUoKTsKKyAgICBib29sIHN5bmNocm9ub3VzKCkgeyByZXR1cm4gbV9zeW5jaHJv bm91czsgfQorCisgICAgYm9vbCBjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeShBc3luY0ZpbGVXcml0 ZXJHdGsqKTsKKyAgICB2b2lkIHNldFdyaXRlclRvQ2FuY2VsKEFzeW5jRmlsZVdyaXRlckd0ayog d3JpdGVyKSB7IG1fd3JpdGVyVG9DYW5jZWwgPSB3cml0ZXI7IH0KKworICAgIFN0cmluZyB1bmlx dWVNb2RlKCk7Citwcml2YXRlOgorICAgIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBib29sKTsKKworICAgIFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqIG1fY29udGV4dDsKKyAgICBib29sIG1fc3luY2hyb25vdXM7CisgICAgU3RyaW5nIG1f Y3VycmVudFRhc2tNb2RlOworCisgICAgQXN5bmNGaWxlV3JpdGVyR3RrKiBtX3dyaXRlclRvQ2Fu Y2VsOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RF TSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc19oCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmI5ZmJjYTAxODkwZDkwYzlhYWRhOGYxZTBhNTI1NjRiNzI2MGFiZjMKLS0t IC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrLmNwcApAQCAtMCwwICsxLDY5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAq IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJs aWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRp b24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNI QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUg R05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgor ICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5v dCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZy YW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNB CisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNs aWVudEd0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQ3Jvc3NU aHJlYWRUYXNrLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworc3RhdGljIHZvaWQgcGVyZm9y bURpZFdyaXRlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVdyaXRl ckNsaWVudCogY2xpZW50LCBsb25nIGxvbmcgYnl0ZXMsIGJvb2wgY29tcGxldGUpCit7CisgICAg Y2xpZW50LT5kaWRXcml0ZShieXRlcywgY29tcGxldGUpOworfQorCitzdGF0aWMgdm9pZCBwZXJm b3JtRGlkVHJ1bmNhdGVDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxl V3JpdGVyQ2xpZW50KiBjbGllbnQpCit7CisgICAgY2xpZW50LT5kaWRUcnVuY2F0ZSgpOworfQor CitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkRmFpbENhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgRmlsZUVycm9yOjpFcnJvckNvZGUg Y29kZSkKK3sKKyAgICBjbGllbnQtPmRpZEZhaWwoY29kZSk7Cit9CisKK0FzeW5jRmlsZVdyaXRl ckNsaWVudEd0azo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGll bnQsIGNvbnN0IFN0cmluZyYgbW9kZSkKKyAgICA6IG1fdGFza0NvbnRyb2xsZXIodGFza0NvbnRy b2xsZXIpCisgICAgLCBtX2NsaWVudChjbGllbnQpCisgICAgLCBtX3Rhc2tNb2RlKG1vZGUpCit7 CisgICAgbV90YXNrQ29udHJvbGxlci0+c2V0Q3VycmVudFRhc2tNb2RlKG1fdGFza01vZGUpOwor fQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkV3JpdGUobG9uZyBsb25nIGJ5 dGVzLCBib29sIGNvbXBsZXRlKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFj a1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkV3JpdGVDYWxsYmFjaywgQWxsb3dD cm9zc1RocmVhZEFjY2VzcyhtX2NsaWVudCksIGJ5dGVzLCBjb21wbGV0ZSksIG1fdGFza01vZGUp OworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkVHJ1bmNhdGUoKQorewor ICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNr KCZwZXJmb3JtRGlkVHJ1bmNhdGVDYWxsYmFjaywgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2Ns aWVudCkpLCBtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6 OmRpZEZhaWwoRmlsZUVycm9yOjpFcnJvckNvZGUgY29kZSkKK3sKKyAgICBtX3Rhc2tDb250cm9s bGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZEZhaWxD YWxsYmFjaywgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2NsaWVudCksIGNvZGUpLCBtX3Rhc2tN b2RlKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJ TEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVdyaXRlckNsaWVudEd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVdyaXRlckNsaWVudEd0ay5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE2ZWUxMDlmZDVkMzM5NWI2MTk4M2Qy YjgxZTE2YzdmMTIyMTlhZmIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgKQEAgLTAsMCArMSw1NyBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNv bT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg TGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5z ZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9u LCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpZm5kZWYgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrX2gKKworI2lmIEVOQUJMRShG SUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr LmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyQ2xpZW50LmgiCisKKyNpbmNsdWRlIDx3dGYv UGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFzeW5jRmlsZVdy aXRlckNsaWVudEd0ayA6IHB1YmxpYyBBc3luY0ZpbGVXcml0ZXJDbGllbnQgeworcHVibGljOgor ICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNsaWVudEd0az4gY3JlYXRlKEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgQXN5bmNGaWxl V3JpdGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFN0cmluZyYgbW9kZSkKKyAgICB7CisgICAgICAg IHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKHRhc2tDb250cm9s bGVyLCBjbGllbnQsIG1vZGUpKTsKKyAgICB9CisKKyAgICB2b2lkIGRpZFdyaXRlKGxvbmcgbG9u ZyBieXRlcywgYm9vbCBjb21wbGV0ZSk7CisgICAgdm9pZCBkaWRUcnVuY2F0ZSgpOworICAgIHZv aWQgZGlkRmFpbChGaWxlRXJyb3I6OkVycm9yQ29kZSk7CisKKyAgICBBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIoKSB7IHJldHVybiBtX3Rhc2tDb250cm9s bGVyLmdldCgpOyB9CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50Kiwg Y29uc3QgU3RyaW5nJik7CisKKyAgICBSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGs+IG1fdGFza0NvbnRyb2xsZXI7CisgICAgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBtX2Ns aWVudDsKKyAgICBTdHJpbmcgbV90YXNrTW9kZTsKK307CisKK30gLy8gbmFtZXNwYWNlCisKKyNl bmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAvLyBBc3luY0ZpbGVXcml0ZXJD bGllbnRHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVdyaXRlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxl V3JpdGVyR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NTY5YWI3Mzc5MTA0YTM3MmExYzJhMzQzNjM5YTlm YTk4N2ZlNDIzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVdyaXRlckd0ay5jcHAKQEAgLTAsMCArMSwxNTUgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKiBDb3B5 cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdl bmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBH TlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJy YXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjEx MC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0Zp bGVXcml0ZXJHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkFz eW5jRmlsZVdyaXRlckNsaWVudEd0ay5oIgorI2luY2x1ZGUgIkJsb2IuaCIKKyNpbmNsdWRlICJC bG9iUmVnaXN0cnlJbXBsLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisKKyNpbmNs dWRlIDxnaW8vZ2lvLmg+CisjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0 L0dPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJHdGs+IEFzeW5jRmlsZVdyaXRl ckd0azo6Y3JlYXRlKEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEdGaWxlKiBmaWxlKQoreworICAg IHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlV3JpdGVyR3RrKGNsaWVudCwgdGFza0NvbnRy b2xsZXIsIGZpbGUpKTsKK30KKworQXN5bmNGaWxlV3JpdGVyR3RrOjpBc3luY0ZpbGVXcml0ZXJH dGsoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgR0ZpbGUqIGZpbGUpCisgICAgOiBtX2NsaWVudChj bGllbnQpCisgICAgLCBtX3Rhc2tDb250cm9sbGVyKHRhc2tDb250cm9sbGVyKQorICAgICwgbV9m aWxlKGZpbGUpCit7Cit9CisKK3N0YXRpYyB2b2lkIHdyaXRlQXN5bmMoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrPiBoZWxwZXJDbGll bnQsIEFzeW5jRmlsZVdyaXRlckd0ayogd3JpdGVyLCBHRmlsZSogZmlsZSwgbG9uZyBsb25nIHBv c2l0aW9uLCBCbG9iKiBkYXRhKQoreworICAgIGlmIChoZWxwZXJDbGllbnQtPnRhc2tDb250cm9s bGVyKCktPmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KHdyaXRlcikpIHsKKyAgICAgICAgaGVscGVy Q2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6QUJPUlRfRVJSKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIEdSZWZQdHI8R0ZpbGVJT1N0cmVhbT4gaW9TdHJlYW0gPSBhZG9wdEdSZWYo Z19maWxlX29wZW5fcmVhZHdyaXRlKGZpbGUsIDAsIDApKTsKKyAgICBpZiAoIWlvU3RyZWFtKSB7 CisgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIp OworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR093blB0cjxHT3V0cHV0U3RyZWFtPiBv dXRwdXRTdHJlYW0oZ19pb19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0oR19JT19TVFJFQU0oaW9T dHJlYW0uZ2V0KCkpKSk7CisgICAgaWYgKCFnX3NlZWthYmxlX3NlZWsoR19TRUVLQUJMRShvdXRw dXRTdHJlYW0uZ2V0KCkpLCBwb3NpdGlvbiwgR19TRUVLX1NFVCwgMCwgMCkpIHsKKyAgICAgICAg aGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBSZWZQdHI8QmxvYlN0b3JhZ2VEYXRhPiBibG9iU3RvcmFn ZSA9IHN0YXRpY19jYXN0PEJsb2JSZWdpc3RyeUltcGwmPihibG9iUmVnaXN0cnkoKSkuZ2V0Qmxv YkRhdGFGcm9tVVJMKGRhdGEtPnVybCgpKTsKKyAgICBpZiAoYmxvYlN0b3JhZ2UpIHsKKyAgICAg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBibG9iU3RvcmFnZS0+aXRlbXMoKS5zaXplKCk7IGkr KykgeworICAgICAgICAgICAgY29uc3QgQmxvYkRhdGFJdGVtJiBibG9iSXRlbSA9IGJsb2JTdG9y YWdlLT5pdGVtcygpW2ldOworICAgICAgICAgICAgaWYgKGJsb2JJdGVtLnR5cGUgPT0gQmxvYkRh dGFJdGVtOjpEYXRhKSB7CisgICAgICAgICAgICAgICAgZ3NpemUgYnl0ZXNXcml0dGVuID0gMDsK KyAgICAgICAgICAgICAgICBnX291dHB1dF9zdHJlYW1fd3JpdGVfYWxsKEdfT1VUUFVUX1NUUkVB TShvdXRwdXRTdHJlYW0uZ2V0KCkpLCBibG9iSXRlbS5kYXRhLT5kYXRhKCksIGJsb2JJdGVtLmRh dGEtPmxlbmd0aCgpLCAmYnl0ZXNXcml0dGVuLCAwLCAwKTsKKworICAgICAgICAgICAgICAgIGJv b2wgY29tcGxldGVkID0gYmxvYlN0b3JhZ2UtPml0ZW1zKCkuc2l6ZSgpID09IChpICsgMSk7Cisg ICAgICAgICAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRXcml0ZShieXRlc1dyaXR0ZW4sIGNvbXBs ZXRlZCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9Cit9CisKK3ZvaWQgQXN5bmNG aWxlV3JpdGVyR3RrOjp3cml0ZShsb25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEpCit7Cisg ICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBt X3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2so JndyaXRlQXN5bmMsIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKG1fdGFza0NvbnRy b2xsZXIuZ2V0KCksIG1fY2xpZW50LCBtb2RlKSwgQWxsb3dDcm9zc1RocmVhZEFjY2Vzcyh0aGlz KSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2ZpbGUuZ2V0KCkpLCBwb3NpdGlvbiwgQWxsb3dD cm9zc1RocmVhZEFjY2VzcyhkYXRhKSkpOworfQorCitzdGF0aWMgdm9pZCB0cnVuY2F0ZUFzeW5j KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNsaWVu dEd0az4gaGVscGVyQ2xpZW50LCBBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlciwgR0ZpbGUqIGZp bGUsIGxvbmcgbG9uZyBsZW5ndGgpCit7CisgICAgaWYgKGhlbHBlckNsaWVudC0+dGFza0NvbnRy b2xsZXIoKS0+Y2FuY2VsV3JpdGVySWZOZWNlc3Nhcnkod3JpdGVyKSkgeworICAgICAgICBoZWxw ZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpBQk9SVF9FUlIpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGZpbGVJbmZvID0gYWRvcHRHUmVmKGdf ZmlsZV9xdWVyeV9pbmZvKGZpbGUsICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkp OworICAgIGlmICghZmlsZUluZm8pIHsKKyAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZp bGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBs b25nIGxvbmcgZmlsZUxlbmd0aCA9IHN0YXRpY19jYXN0PGxvbmcgbG9uZz4oZ19maWxlX2luZm9f Z2V0X3NpemUoZmlsZUluZm8uZ2V0KCkpKTsKKyAgICBpZiAobGVuZ3RoID4gZmlsZUxlbmd0aCkg eworICAgICAgICBHT3duUHRyPEdTdHJpbmc+IHplcm9QYWRkaW5nKGdfc3RyaW5nX25ld19sZW4o MCwgbGVuZ3RoIC0gZmlsZUxlbmd0aCkpOworICAgICAgICBkbyB7CisgICAgICAgICAgICBnX3N0 cmluZ19hcHBlbmRfYyh6ZXJvUGFkZGluZy5nZXQoKSwgJ1wwJyk7CisgICAgICAgIH0gd2hpbGUg KC0tbGVuZ3RoID4gZmlsZUxlbmd0aCk7CisKKyAgICAgICAgR1JlZlB0cjxHRmlsZUlPU3RyZWFt PiBpb1N0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfb3Blbl9yZWFkd3JpdGUoZmlsZSwgMCwgMCkp OworICAgICAgICBpZiAoIWlvU3RyZWFtKSB7CisgICAgICAgICAgICBoZWxwZXJDbGllbnQtPmRp ZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAg ICAgICAgfQorCisgICAgICAgIEdPd25QdHI8R091dHB1dFN0cmVhbT4gb3V0cHV0U3RyZWFtKGdf aW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKEdfSU9fU1RSRUFNKGlvU3RyZWFtLmdldCgpKSkp OworICAgICAgICBpZiAoIWdfc2Vla2FibGVfc2VlayhHX1NFRUtBQkxFKG91dHB1dFN0cmVhbS5n ZXQoKSksIGxlbmd0aCwgR19TRUVLX1NFVCwgMCwgMCkpIHsKKyAgICAgICAgICAgIGhlbHBlckNs aWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICAgICAgcmV0 dXJuOworICAgICAgICB9CisKKyAgICAgICAgZ3NpemUgYnl0ZXNXcml0dGVuID0gMDsKKyAgICAg ICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlX2FsbChHX09VVFBVVF9TVFJFQU0ob3V0cHV0U3RyZWFt LmdldCgpKSwgemVyb1BhZGRpbmctPnN0ciwgemVyb1BhZGRpbmctPmxlbiwgJmJ5dGVzV3JpdHRl biwgMCwgMCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgR1JlZlB0cjxHRmlsZU91dHB1dFN0cmVh bT4gZmlsZU91dHB1dFN0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfcmVwbGFjZShmaWxlLCAwLCBm YWxzZSwgR19GSUxFX0NSRUFURV9OT05FLCAwLCAwKSk7CisgICAgICAgIGlmICghZmlsZU91dHB1 dFN0cmVhbSB8fCAhZ19zZWVrYWJsZV90cnVuY2F0ZShHX1NFRUtBQkxFKGZpbGVPdXRwdXRTdHJl YW0uZ2V0KCkpLCBsZW5ndGgsIDAsIDApKSB7CisgICAgICAgICAgICBoZWxwZXJDbGllbnQtPmRp ZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAg ICAgICAgfQorICAgIH0KKworICAgIGhlbHBlckNsaWVudC0+ZGlkVHJ1bmNhdGUoKTsKK30KKwor dm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OnRydW5jYXRlKGxvbmcgbG9uZyBsZW5ndGgpCit7Cisg ICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBt X3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2so JnRydW5jYXRlQXN5bmMsIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKG1fdGFza0Nv bnRyb2xsZXIuZ2V0KCksIG1fY2xpZW50LCBtb2RlKSwgQWxsb3dDcm9zc1RocmVhZEFjY2Vzcyh0 aGlzKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhtX2ZpbGUuZ2V0KCkpLCBsZW5ndGgpKTsKK30K Kwordm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OmFib3J0KCkKK3sKKyAgICBtX3Rhc2tDb250cm9s bGVyLT5zZXRXcml0ZXJUb0NhbmNlbCh0aGlzKTsKK30KKworYm9vbCBBc3luY0ZpbGVXcml0ZXJH dGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAgICByZXR1cm4gbV90YXNrQ29u dHJvbGxlci0+c3luY2hyb25vdXMoKSA/IG1fdGFza0NvbnRyb2xsZXItPndhaXRGb3JPcGVyYXRp b25Ub0NvbXBsZXRlKCkgOiBmYWxzZTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisj ZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjU0NWIwMGMxYzk3NmFjMzQz NDQ2YWM1Yzc0N2VlNWJlODA5M2U3M2MKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgKQEAgLTAsMCArMSw1NyBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNv bT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg TGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5z ZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9u LCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpZm5kZWYgQXN5bmNGaWxlV3JpdGVyR3RrX2gK KyNkZWZpbmUgQXN5bmNGaWxlV3JpdGVyR3RrX2gKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkK KworI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlci5oIgorCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25Q dHIuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVyQ2xpZW50OworY2xhc3MgQXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGs7CisKK2NsYXNzIEFzeW5jRmlsZVdyaXRlckd0ayA6IHB1Ymxp YyBBc3luY0ZpbGVXcml0ZXIgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5j RmlsZVdyaXRlckd0az4gY3JlYXRlKEFzeW5jRmlsZVdyaXRlckNsaWVudCosIEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgR0ZpbGUqKTsKKworICAgIHZvaWQgYWJvcnQoKTsKKyAg ICB2b2lkIHRydW5jYXRlKGxvbmcgbG9uZyBsZW5ndGgpOworICAgIHZvaWQgd3JpdGUobG9uZyBs b25nIHBvc2l0aW9uLCBCbG9iKiBkYXRhKTsKKworICAgIGJvb2wgd2FpdEZvck9wZXJhdGlvblRv Q29tcGxldGUoKTsKKworcHJpdmF0ZToKKyAgICBBc3luY0ZpbGVXcml0ZXJHdGsoQXN5bmNGaWxl V3JpdGVyQ2xpZW50KiwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBHRmlsZSop OworCisgICAgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBtX2NsaWVudDsKKyAgICBSZWZQdHI8QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IG1fdGFza0NvbnRyb2xsZXI7CisgICAgR1Jl ZlB0cjxHRmlsZT4gbV9maWxlOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5k aWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlV3JpdGVyR3Rr X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbEZpbGVTeXN0 ZW1HdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0 ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNjU5NzI4NDZlNzljMzg2NjIxOWJmZmNjYzJiOGRlNjY0NzJkOTc5 NAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbEZp bGVTeXN0ZW1HdGsuY3BwCkBAIC0wLDAgKzEsODYgQEAKKy8qCisgKiAgQ29weXJpZ2h0IChDKSAy MDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiAgQ29weXJpZ2h0IChDKSAy MDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKgorICogIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAq ICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJh cnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqICBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0x MzAxICBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiTG9jYWxGaWxl U3lzdGVtLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGsuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2suaCIKKyNp bmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgorI2luY2x1ZGUgPGd0ay9ndGsuaD4KKyNpbmNsdWRl IDx3dGYvVGhyZWFkaW5nLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgorI2lu Y2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5n Lmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworTG9jYWxGaWxlU3lzdGVtKiBMb2NhbEZpbGVT eXN0ZW06OnNfaW5zdGFuY2UgPSAwOworCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6 ZUxvY2FsRmlsZVN5c3RlbShjb25zdCBTdHJpbmcmIGJhc2VQYXRoKQoreworICAgIEdPd25QdHI8 R0Vycm9yPiBlcnJvcjsKKyAgICBHT3duUHRyPEdEaXI+IGRpcmVjdG9yeShnX2Rpcl9vcGVuKGJh c2VQYXRoLnV0ZjgoKS5kYXRhKCksIDAsICZlcnJvci5vdXRQdHIoKSkpOworICAgIGlmIChlcnJv ciAmJiBlcnJvci0+Y29kZSA9PSBHX0ZJTEVfRVJST1JfTk9FTlQpIHsKKyAgICAgICAgR1JlZlB0 cjxHRmlsZT4gYmFzZURpcmVjdG9yeUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0 aChiYXNlUGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgICAgIGdfZmlsZV9tYWtlX2RpcmVjdG9y eShiYXNlRGlyZWN0b3J5RmlsZS5nZXQoKSwgMCwgMCk7CisgICAgfQorfQorCitMb2NhbEZpbGVT eXN0ZW0mIExvY2FsRmlsZVN5c3RlbTo6bG9jYWxGaWxlU3lzdGVtKCkKK3sKKyAgICBXVEY6Omxv Y2tBdG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWNNdXRleCgpOworICAgIGlmICghc19pbnN0YW5j ZSkgeworICAgICAgICBHT3duUHRyPGdjaGFyPiBiYXNlUGF0aChnX2J1aWxkX2ZpbGVuYW1lKGdf Z2V0X3VzZXJfZGF0YV9kaXIoKSwgIndlYmtpdCIsICJmaWxlc3lzdGVtIiwgTlVMTCkpOworICAg ICAgICBPd25QdHI8TG9jYWxGaWxlU3lzdGVtPiBsb2NhbEZpbGVTeXN0ZW0gPSBhZG9wdFB0cihu ZXcgTG9jYWxGaWxlU3lzdGVtKGJhc2VQYXRoLmdldCgpKSk7CisgICAgICAgIGxvY2FsRmlsZVN5 c3RlbS0+aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbShTdHJpbmcoYmFzZVBhdGguZ2V0KCkpKTsK KworICAgICAgICBzX2luc3RhbmNlID0gbG9jYWxGaWxlU3lzdGVtLmxlYWtQdHIoKTsKKyAgICB9 CisgICAgV1RGOjp1bmxvY2tBdG9taWNhbGx5SW5pdGlhbGl6ZWRTdGF0aWNNdXRleCgpOworICAg IHJldHVybiAqc19pbnN0YW5jZTsKK30KKworU3RyaW5nIExvY2FsRmlsZVN5c3RlbTo6ZmlsZVN5 c3RlbUJhc2VQYXRoKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9iYXNlUGF0aDsKK30KKworc3Rh dGljIHZvaWQgb3BlbkZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwg Y29uc3QgU3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBpZGVudGlmaWVyLCBBc3luY0Zp bGVTeXN0ZW06OlR5cGUgdHlwZSwgYm9vbCBjcmVhdGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgQXN5bmNG aWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbShiYXNlUGF0aCwgaWRlbnRpZmllciwgdHlwZSwgY3Jl YXRlLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShjb250ZXh0LCBjYWxsYmFj a3MsIHN5bmNocm9ub3VzKSk7Cit9CisKK3ZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZWFkRmlsZVN5 c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVTeXN0ZW06OlR5 cGUgdHlwZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywg Ym9vbCBzeW5jaHJvbm91cykKK3sKKyAgICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lz dGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5jaHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRv IGJlIGNhbGxlZCBhc3luY2hyb25vdXNseS4KKyAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVD YWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgoKSwgY29udGV4 dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIGZhbHNlLCBj YWxsYmFja3MsIHN5bmNocm9ub3VzKSk7Cit9CisKK3ZvaWQgTG9jYWxGaWxlU3lzdGVtOjpyZXF1 ZXN0RmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBc3luY0ZpbGVT eXN0ZW06OlR5cGUgdHlwZSwgbG9uZyBsb25nLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQoreworICAgIC8vIEFzeW5jRmls ZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNv IHRoZSBtZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgorICAgIGNvbnRl eHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0 ZW1CYXNlUGF0aCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZp ZXIoKSwgdHlwZSwgdHJ1ZSwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOworfQorCit9CisKKyNl bmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYjU2MjMzZjhlZGYyODhjODA2NGU0NjM4Y2UzYTdiOTJl MjliMzk0OC4uZjc5ZDZmN2Q2NjZmMTcyYWVlZjgzNzY0YThiMTY0ODU0OGFjM2IzNyAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0 IEBACisyMDEyLTA0LTA4ICBDaGFuZ1Nlb2sgT2ggIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKwor ICAgICAgICBbR1RLXSBTdXBwb3J0IHRoZSBmaWxlIHN5c3RlbSBBUEkKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU4NDQzCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRW5hYmxlZCBGaWxlU3lzdGVtIGZvciBH VEsgcG9ydC4KKworICAgICAgICAqIFNjcmlwdHMvYnVpbGQtd2Via2l0OgorCiAyMDEyLTA0LTA3 ICBQYXRyaWNrIEdhbnN0ZXJlciAgPHBhcm9nYUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtDTWFr ZV0gQ2xlYW51cCBXVEYgaW5jbHVkZSBkaXJlY3RvcmllcwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2Ny aXB0cy9idWlsZC13ZWJraXQgYi9Ub29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdAppbmRleCBmZWJh OWQ1ODg0YjYzOWNkZTkwMWY4YTIwMzZjNDg1YjUzNjk3ODkwLi5mZDk2MjQ2YzJmNmRhOGNhMTM0 ODM2ODU3ZGUzMGQzZTA4NmMxZmVjIDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL2J1aWxkLXdl YmtpdAorKysgYi9Ub29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdApAQCAtMjAzLDcgKzIwMyw3IEBA IG15IEBmZWF0dXJlcyA9ICgKICAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0RJUkVDVE9SWV9VUExP QUQiLCBkZWZhdWx0ID0+IDAsIHZhbHVlID0+IFwkZGlyZWN0b3J5VXBsb2FkU3VwcG9ydCB9LAog CiAgICAgeyBvcHRpb24gPT4gImZpbGUtc3lzdGVtIiwgZGVzYyA9PiAiVG9nZ2xlIEZpbGVTeXN0 ZW0gc3VwcG9ydCIsCi0gICAgICBkZWZpbmUgPT4gIkVOQUJMRV9GSUxFX1NZU1RFTSIsIGRlZmF1 bHQgPT4gaXNCbGFja0JlcnJ5KCksIHZhbHVlID0+IFwkZmlsZVN5c3RlbVN1cHBvcnQgfSwKKyAg ICAgIGRlZmluZSA9PiAiRU5BQkxFX0ZJTEVfU1lTVEVNIiwgZGVmYXVsdCA9PiAoaXNCbGFja0Jl cnJ5KCkgfHwgaXNHdGsoKSksIHZhbHVlID0+IFwkZmlsZVN5c3RlbVN1cHBvcnQgfSwKIAogICAg IHsgb3B0aW9uID0+ICJmaWx0ZXJzIiwgZGVzYyA9PiAiVG9nZ2xlIFNWRyBGaWx0ZXJzIHN1cHBv cnQiLAogICAgICAgZGVmaW5lID0+ICJFTkFCTEVfRklMVEVSUyIsIGRlZmF1bHQgPT4gKGlzQXBw bGVXZWJLaXQoKSB8fCBpc0d0aygpIHx8IGlzUXQoKSB8fCBpc0VmbCgpIHx8IGlzQmxhY2tCZXJy eSgpKSwgdmFsdWUgPT4gXCRmaWx0ZXJzU3VwcG9ydCB9LApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDI5OTk0NDI3NWQ1YmQz MTg2NTQ3NTQ4ZGJjN2FlMTYwNWRmYWMzOWEuLjU0YTA0MjU3NjAxNTZkZGZiOTkyNmRmNGQwMGUy NzU4MGVlNmZiZjQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlv dXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMi0wNC0wOCAgQ2hhbmdTZW9r IE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAgICAgICAgW0dUS10gU3VwcG9ydCB0aGUg ZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFsbCB0ZXN0cyBpbiBmYXN0L2ZpbGVzeXN0ZW0gYXJlIHBhc3NlZCBleGNlcHQgdGhl IG9uZXMgcmVsYXRlZCB3aXRoIHdvcmtlci4KKyAgICAgICAgRm9sbG93aW5nIHRlc3RzIGFyZSBw YXNzZWQgaW4gZGV0YWlsLgorICAgICAgICBmYXN0L2ZpbGVzeXN0ZW0vKi5odG1sCisgICAgICAg IGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5odG1sCisgICAgICAg IGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2IuaHRtbAorICAg ICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1ibG9iLWZhaWwu aHRtbAorCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBwZWQ6CisKIDIwMTItMDQtMDcgIEFu ZHJldyBTY2hlcmt1cyAgPHNjaGVya3VzQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbQ2hyb21p dW1dIFVucmV2aWV3ZWQsIGNoZWNraW5nIGluIGJhc2VsaW5lcyBmb3IgdmlkZW8tZnJhbWUtc2l6 ZS1jaGFuZ2UuaHRtbC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lw cGVkIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKaW5kZXggYzcyODMwYTIzNjg2 OWFjMDc5YmU3YTVhZjNkYWNhZGRkOGI3YjM4YS4uM2M1MGE3NzQwZTc3ZGRmN2IwOWU4YmJlZWE5 NzRlMDk2MWNhYjU2OSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBw ZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKQEAgLTI3OCwxMyArMjc4 LDEzIEBAIGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmctc2xvdy1sb2FkLnBocAogaHR0cC90ZXN0 cy9taXNjL3dlYnRpbWluZy1zc2wucGhwCiBodHRwL3Rlc3RzL21pc2Mvd2VidGltaW5nLXR3by1y ZWRpcmVjdHMucGhwCiAKLSMgRmlsZVN5c3RlbSBBUEkgaXMgbm90IHN1cHBvcnRlZC4KLWZhc3Qv ZmlsZXN5c3RlbQorIyBGaWxlU3lzdGVtIEFQSSBpcyBub3Qgc3VwcG9ydGVkIGNvbXBsZXRlbHku CisjIFdlIGRvbid0IHN1cHBvcnQgd29ya2VycyBmb3IgRmlsZVN5c3RlbSB5ZXQuIGh0dHA6Ly93 ZWJraXQub3JnL2IvODI4NTQKK2Zhc3QvZmlsZXN5c3RlbS93b3JrZXJzCiBodHRwL3Rlc3RzL2Zp bGVzeXN0ZW0KIGh0dHAvdGVzdHMvc2VjdXJpdHkvZmlsZXN5c3RlbS1pZnJhbWUtZnJvbS1yZW1v dGUuaHRtbAotaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi5o dG1sCi1odHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1ibG9iLWZhaWwu aHRtbAogaHR0cC90ZXN0cy93b3JrZXJzL3Rlcm1pbmF0ZS1kdXJpbmctc3luYy1vcGVyYXRpb24u aHRtbAorIyBQYXNzZWQgYnV0IHdlIHNob3VsZCBlbmFibGUgZmlsZS1zeXN0ZW0gJiBtdXRhdGlv bi1vYnNlcnZlcnMgYXQgdGhlIHNhbWUgdGltZS4KIGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1j YWxsYmFjay1kZWxpdmVyeS5odG1sCiAKICMgUmVxdWlyZXMgV2ViUCBzdXBwb3J0Lgo= 136422 2012-04-10 04:08:44 -0700 2012-04-19 00:20:38 -0700 Patch bug-58443-20120410200842.patch text/plain 72363 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTEzNjY4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDBhNTQ2YTYxNzhjMDVhYzY5MTlhNTBi MGU1YzlmMDliYTIxNDliNTEuLmFmNzNmNDZlNjE4ZTYxZmIwMjMyNjlkZjY3MGJmYTIwM2NiN2Q1 ZmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMDkgIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDoKKwogMjAxMi0wNC0wOSAgUGF0cmljayBHYW5zdGVyZXIgIDxw YXJvZ2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBQb3J0IEJpbmFyeVNlbWFwaG9yZVdpbi5jcHAg dG8gV2luQ0UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0OTJlYjFjNjM0NmNhZDQyNmY0ZGZhZDc3ZWI2NTNkZGRl MGZhNDNjLi41ODdjNjE1M2Q0ZTMzNmE0NThjOTVlM2I1NWRlMzM4OTJiY2YyMTdlIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTM5IEBACisyMDEyLTA0LTA5ICBDaGFuZ1Nlb2sgT2ggIDxzaGl2YW1p ZG93QGdtYWlsLmNvbT4KKworICAgICAgICBbR1RLXSBTdXBwb3J0IHRoZSBmaWxlIHN5c3RlbSBB UEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU4NDQz CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBw YXRjaCBpcyBiYXNlZCBvbiBaYW4gRG9iZXJzZWsncyBvcmlnaW5hbCBvbmUgZm9yIGJ1ZzU4NDQz LgorICAgICAgICBUaGlzIGJyaW5ncyBGaWxlU3lzdGVtIEFQSSB0byBndGsgcG9ydC4gVGhpcyBh ZGRzIG5ldyBpbnRlcmZhY2VzIGxpa2UKKyAgICAgICAgQXN5bmNGaWxlU3lzdGVtR3RrLCBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGssIEFzeW5jRmlsZVdyaXRlckd0aywgQXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrCisgICAgICAgIGFuZCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ay4gVGhlc2UgYXJlIGNoaWxkIGNsYXNzZXMgaW1wbGVtZW50aW5nIHRoZSBpbnRlcmZhY2VzCisg ICAgICAgIG9mIGVhY2ggcGFyZW50IGNsYXNzZXMgZXhjZXB0IEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrLiBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0aworICAgICAgICBp cyBhIGhlbHBlciBjbGFzcy4gSXQgcmV0YWlucyBzb21lIHVzZWZ1bCB2YXJpYWJsZXMsIGFuZCBj b250cm9scyBwb3N0aW5nIHRhc2tzIHRvCisgICAgICAgIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQg d2hpY2ggbWlnaHQgYmUgZWl0aGVyIGEgRG9jdW1lbnQgb2JqZWN0IG9yIGEgV29ya2VyLgorICAg ICAgICBVbmZvcnR1bmF0ZWx5LCBXb3JrZXIgZm9yIGZpbGVzeXN0ZW0gaXMgbm90IHN1cHBvcnRl ZCB5ZXQsIEkgcGxhbiB0byBzdXBwb3J0IGl0IGluIHRoZSBuZXh0IHBhdGNoLgorCisgICAgICAg IFRlc3Q6IGZhc3QvZmlsZXN5c3RlbS8qLmh0bWwKKyAgICAgICAgICAgICAgZmFzdC9tdXRhdGlv bi9maWxlc3lzdGVtLWNhbGxiYWNrLWRlbGl2ZXJ5Lmh0bWwKKyAgICAgICAgICAgICAgaHR0cC90 ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi5odG1sCisgICAgICAgICAg ICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2ItZmFpbC5o dG1sCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOiBBZGRlZCBzb21lIGZpbGVzIHRv IGJ1aWxkIG5ld2x5IGZvciBGaWxlU3lzdGVtLgorICAgICAgICAqIE1vZHVsZXMvZmlsZXN5c3Rl bS9Mb2NhbEZpbGVTeXN0ZW0uY3BwOiBXZSBzaG91bGQgbm90IGJ1aWxkIHRoaXMgZmlsZS4gc28g YWRkZWQgZXJyb3IgbWVzc2FnZS4KKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrLmNwcDogQWRkZWQuIFRoaXMgaXMgYW4gaW1wbGVtZW50YXRpb24gb2Yg QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChX ZWJDb3JlOjo6OmNvcHkpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGspOgorICAgICAgICAoV2ViQ29yZTo6 cGVyZm9ybURpZFN1Y2NlZWRDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmRpZFN1Y2NlZWQpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9y bURpZE9wZW5GaWxlU3lzdGVtQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRPcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3Jl OjpwZXJmb3JtRGlkUmVhZE1ldGFkYXRhQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkTWV0YWRhdGEpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cnkp OgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFJlYWREaXJlY3RvcnlFbnRyaWVzQW5kRmlu aXNoZWRDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGs6OmRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZv cm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRDcmVhdGVGaWxlV3JpdGVyKToKKyAgICAgICAgKFdl YkNvcmU6OnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRGYWlsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsv QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6 CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGspOgorICAgICAgICAoRGlyZWN0 b3J5RW50cnkpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr OjpEaXJlY3RvcnlFbnRyeTo6RGlyZWN0b3J5RW50cnkpOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwOiBBZGRlZCBzb21lIG1pc3NpbmcgQVBJcy4gVGhpcyBp cyBhIGNoaWxkIGNsYXNzIG9mIEFzeW5jRmlsZVN5c3RlbS4KKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN5c3RlbTo6aXNBdmFpbGFibGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl U3lzdGVtOjppc1ZhbGlkVHlwZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06 Om9wZW5GaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6Y3Jh Y2tGaWxlU3lzdGVtVVJMKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6 QXN5bmNGaWxlU3lzdGVtR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0 azo6fkFzeW5jRmlsZVN5c3RlbUd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0 ZW1HdGs6OnRvVVJMKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6bW92 ZUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6bW92ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpjb3B5UmVjdXJzaXZlbHkpOgorICAgICAgICAoV2ViQ29yZTo6Y29w eUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y29weSk6Cisg ICAgICAgIChXZWJDb3JlOjpyZW1vdmVGaWxlKToKKyAgICAgICAgKFdlYkNvcmU6OnJlbW92ZUFz eW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlKToKKyAg ICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVjdXJzaXZlbHkpOgor ICAgICAgICAoV2ViQ29yZTo6cmVhZE1ldGFkYXRhQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFkTWV0YWRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6Y3Jl YXRlT2JqZWN0QXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpj cmVhdGVPYmplY3QpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVh dGVGaWxlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGly ZWN0b3J5KToKKyAgICAgICAgKFdlYkNvcmU6Om9iamVjdEV4aXN0c0FzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6ZmlsZUV4aXN0cyk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmRpcmVjdG9yeUV4aXN0cyk6CisgICAgICAgIChXZWJD b3JlOjpyZWFkRGlyZWN0b3J5QXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lz dGVtR3RrOjpyZWFkRGlyZWN0b3J5KToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZVdyaXRlckFz eW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlV3JpdGVy KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlU25hcHNob3RG aWxlQW5kUmVhZE1ldGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0 azo6c2V0VGFza0NvbnRyb2xsZXIpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVt R3RrOjp2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTCk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVTeXN0ZW1HdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKToKKyAgICAgICAgKiBw bGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKEFzeW5jRmlsZVN5c3RlbUd0ayk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmNwcDogQWRkZWQuIFRoaXMgaXMgYSBoZWxwZXIg Y2xhc3MgdG8gY29udHJvbCBwb3N0aW5nIHRhc2sgdG8gYSB0YXJnZXQgdGhyZWFkLgorICAgICAg ICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6fkFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrOjp1bmlxdWVNb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpwb3N0VGFza1RvTWFpblRocmVhZCk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6c2V0Q3VycmVu dFRhc2tNb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrOjpwb3N0Q2FsbGJhY2tUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6Y2FuY2VsV3Jp dGVySWZOZWNlc3NhcnkpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAo QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnN5bmNocm9ub3VzKToKKyAgICAgICAgKFdl YkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzZXRXcml0ZXJUb0NhbmNl bCk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHA6 IEFkZGVkLiBUaGlzIGlzIGEgY2hpbGQgY2xhc3MgaW1wbGVtZW50IG9mIEF5c25jRmlsZVdyaXRl ckNsaWVudC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURp ZFdyaXRlQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFRydW5jYXRlQ2Fs bGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZEZhaWxDYWxsYmFjayk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OkFzeW5jRmlsZVdyaXRlckNs aWVudEd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRp ZFdyaXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlk VHJ1bmNhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpk aWRGYWlsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3Rr Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVXcml0ZXJD bGllbnRHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpj cmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjp0YXNr Q29udHJvbGxlcik6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5j cHA6IEFkZGVkLiBUaGlzIGlzIGEgY2hpbGQgY2xhc3Mgb2YgQXN5bmNGaWxlV3JpdGVyLgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OmNy ZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OkFzeW5jRmlsZVdy aXRlckd0ayk6CisgICAgICAgIChXZWJDb3JlOjp3cml0ZUFzeW5jKToKKyAgICAgICAgKFdlYkNv cmU6OkFzeW5jRmlsZVdyaXRlckd0azo6d3JpdGUpOgorICAgICAgICAoV2ViQ29yZTo6dHJ1bmNh dGVBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OnRydW5jYXRl KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckd0azo6YWJvcnQpOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0 ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oOiBBZGRlZC4K KyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoQXN5bmNGaWxlV3JpdGVyR3RrKToKKyAgICAg ICAgKiBwbGF0Zm9ybS9ndGsvTG9jYWxGaWxlU3lzdGVtR3RrLmNwcDogQWRkZWQuIFBvcnQgc3Bl Y2lmaWMgaW1wbGVtZW50YXRpb24gZm9yIExvY2FsRmlsZVN5c3RlbSBjbGFzcyBpcyBoZXJlLiBX ZSBzaG91bGQgdXNlIHRoaXMgZmlsZSBpbnN0ZWFkIG9mIExvY2FsRmlsZVN5c3RlbS5jcHAKKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjppbml0 aWFsaXplTG9jYWxGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3Rl bTo6bG9jYWxGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6 ZmlsZVN5c3RlbUJhc2VQYXRoKToKKyAgICAgICAgKFdlYkNvcmU6Om9wZW5GaWxlU3lzdGVtKToK KyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVhZEZpbGVTeXN0ZW0pOgorICAg ICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZXF1ZXN0RmlsZVN5c3RlbSk6CisKIDIw MTItMDQtMDkgIERhbmEgSmFuc2VucyAgPGRhbmFrakBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg W2Nocm9taXVtXSBSZXBsaWNhIGxheWVycyBhcmUgbm90IGRyYXduLCBzbyBzaG91bGQgbm90IGJl IHBhaW50ZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5jcHAg Yi9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwCmluZGV4IGRmZTE4N2Q3ODg3ZmY1 NGVhMDI3YzFjOWRjNWMwNmJkN2JkYjVjZjEuLjNhYTA3NTk5NDc2ZDc0ZTIyZmRmNGU3Y2QwZTg1 NzdhMjgxNTkyYjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5j cHAKKysrIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmNwcApAQCAtNDIsNiArNDIs MTYgQEAgdGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdTTGlzdD4oR1NMaXN0KiBwdHIp CiAgICAgZ19zbGlzdF9mcmVlKHB0cik7CiB9CiAKK3RlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVk R1B0cjxHU3RyaW5nPihHU3RyaW5nKiBwdHIpCit7CisgICAgZ19zdHJpbmdfZnJlZShwdHIsIHRy dWUpOworfQorCit0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8R091dHB1dFN0cmVhbT4o R091dHB1dFN0cmVhbSogcHRyKQoreworICAgIGdfb3V0cHV0X3N0cmVhbV9jbG9zZShwdHIsIDAs IDApOworfQorCiB0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1BhdHRlcm5TcGVjPihH UGF0dGVyblNwZWMqIHB0cikKIHsKICAgICBpZiAocHRyKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dU Ri93dGYvZ29iamVjdC9HT3duUHRyLmggYi9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIu aAppbmRleCA0YjJkY2I3N2IyNTAwMGMyZTViNjgwOGE0Yzc0ODRjMmJlNmQ2Y2E1Li45YzA2N2Q3 MWE2Nzk1NWNjNGJmOGQ4ZmM4ZGRmMjBkOWIyMmExYzcxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RG L3d0Zi9nb2JqZWN0L0dPd25QdHIuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25Q dHIuaApAQCAtMzYsNiArMzYsOCBAQCB0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4gaW5saW5lIHZvaWQg ZnJlZU93bmVkR1B0cihUKiBwdHIpOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R0Vy cm9yPihHRXJyb3IqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdMaXN0PihHTGlz dCopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1NMaXN0PihHU0xpc3QqKTsKK3Rl bXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdTdHJpbmc+KEdTdHJpbmcqKTsKK3RlbXBsYXRl PD4gdm9pZCBmcmVlT3duZWRHUHRyPEdPdXRwdXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qKTsKIHRl bXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdQYXR0ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKik7 CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHRGlyPihHRGlyKik7CiB0ZW1wbGF0ZTw+ IHZvaWQgZnJlZU93bmVkR1B0cjxHVGltZXI+KEdUaW1lciopOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaCBiL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5 cGVkZWZzLmgKaW5kZXggZTI5MjUwYmVmMmVmNGQ1ZTllYmU1YzJiMDUwMzczYmJhODU2NGY5YS4u N2E1ZTlmM2NhMDdkYTU1ZTU2OGM1NzFkNGU1YmM5Zjg1NDVlYjUyMiAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nb2Jq ZWN0L0dUeXBlZGVmcy5oCkBAIC00OCwxNyArNDgsMjAgQEAgdHlwZWRlZiBzdHJ1Y3QgX0dka0V2 ZW50RXhwb3NlIEdka0V2ZW50RXhwb3NlOwogdHlwZWRlZiBzdHJ1Y3QgX0dka1BpeGJ1ZiBHZGtQ aXhidWY7CiB0eXBlZGVmIHN0cnVjdCBfR0Vycm9yIEdFcnJvcjsKIHR5cGVkZWYgc3RydWN0IF9H RmlsZSBHRmlsZTsKK3R5cGVkZWYgc3RydWN0IF9HRmlsZUlPU3RyZWFtIEdGaWxlSU9TdHJlYW07 CiB0eXBlZGVmIHN0cnVjdCBfR0hhc2hUYWJsZSBHSGFzaFRhYmxlOwogdHlwZWRlZiBzdHJ1Y3Qg X0dJbnB1dFN0cmVhbSBHSW5wdXRTdHJlYW07CiB0eXBlZGVmIHN0cnVjdCBfR0xpc3QgR0xpc3Q7 CiB0eXBlZGVmIHN0cnVjdCBfR01haW5Db250ZXh0IEdNYWluQ29udGV4dDsKIHR5cGVkZWYgc3Ry dWN0IF9HTWFpbkxvb3AgR01haW5Mb29wOwordHlwZWRlZiBzdHJ1Y3QgX0dPdXRwdXRTdHJlYW0g R091dHB1dFN0cmVhbTsKIHR5cGVkZWYgc3RydWN0IF9HUGF0dGVyblNwZWMgR1BhdHRlcm5TcGVj OwogdHlwZWRlZiBzdHJ1Y3QgX0dQb2xsYWJsZU91dHB1dFN0cmVhbSBHUG9sbGFibGVPdXRwdXRT dHJlYW07CiB0eXBlZGVmIHN0cnVjdCBfR1NMaXN0IEdTTGlzdDsKIHR5cGVkZWYgc3RydWN0IF9H U29ja2V0Q2xpZW50IEdTb2NrZXRDbGllbnQ7CiB0eXBlZGVmIHN0cnVjdCBfR1NvY2tldENvbm5l Y3Rpb24gR1NvY2tldENvbm5lY3Rpb247CiB0eXBlZGVmIHN0cnVjdCBfR1NvdXJjZSBHU291cmNl OwordHlwZWRlZiBzdHJ1Y3QgX0dTdHJpbmcgR1N0cmluZzsKIHR5cGVkZWYgc3RydWN0IF9HVmFy aWFudCBHVmFyaWFudDsKIHR5cGVkZWYgdW5pb24gX0dka0V2ZW50IEdka0V2ZW50OwogdHlwZWRl ZiBzdHJ1Y3QgX0dUaW1lciBHVGltZXI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9HTlVt YWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQppbmRl eCBjNzVkMGEyMGE4NGM3ZWEzZTc5NWE2N2RhMjVkNTVkYjQyMjA2ZGZlLi5mMjg5YTNhZjU2NzBm YWY0OTU0MjY4OGVmZjUzYjFiYjcyOWUwODBhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9H TlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3Qu YW0KQEAgLTEwMjQsNyArMTAyNCw2IEBAIHdlYmNvcmVfbW9kdWxlc19zb3VyY2VzICs9IFwKIAlT b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vRmlsZVdyaXRlckNhbGxiYWNrLmggXAog CVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9GaWxlV3JpdGVyU3luYy5jcHAgXAog CVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9GaWxlV3JpdGVyU3luYy5oIFwKLQlT b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcCBcCiAJ U291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5oIFwKIAlT b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTWV0YWRhdGFDYWxsYmFjay5oIFwKIAlT b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTWV0YWRhdGEuaCBcCkBAIC00NjgzLDYg KzQ2ODIsNyBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9HdGtWZXJzaW9uaW5nLmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9L ZXlCaW5kaW5nVHJhbnNsYXRvci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9L ZXlCaW5kaW5nVHJhbnNsYXRvci5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9j YWxGaWxlU3lzdGVtR3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2Fs aXplZFN0cmluZ3NHdGsuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTWFpbkZy YW1lU2Nyb2xsYmFyR3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL01haW5G cmFtZVNjcm9sbGJhckd0ay5oIFwKQEAgLTQ5NzUsOSArNDk3NSwxOSBAQCBkb21fYmluZGluZ19p ZGxzICs9IFwKIAkkKFdlYkNvcmUpL01vZHVsZXMvZmlsZXN5c3RlbS9NZXRhZGF0YUNhbGxiYWNr LmlkbCBcCiAJJChXZWJDb3JlKS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vV29ya2VyQ29udGV4dEZpbGVT eXN0ZW0uaWRsCiAKLXdlYmNvcmVndGtfc291cmNlcyArPSBcCit3ZWJjb3JlX3NvdXJjZXMgKz0g XAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwIFwK IAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmgKKword2Vi Y29yZWd0a19zb3VyY2VzICs9IFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBcCisJ U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHAg XAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsu aCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAg XAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaAogZW5k aWYgIyBFTkQgRU5BQkxFX0ZJTEVfU1lTVEVNCiAKICMgLS0tLQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcAppbmRleCA4ZjAx NjllZWFiYmE5M2ZmNGYxNTZkN2MyMzQ3YjZjMGIyN2Q1YmJhLi43M2YyMThiNGEwMzcxZDAwNGEx NGNiYTAxODI2MWM4YjJlNDljNjY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL2ZpbGVzeXN0ZW0vTG9jYWxGaWxlU3lzdGVtLmNwcApAQCAtMzEsOCArMzEsOCBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgogCi0jaWYgUExB VEZPUk0oQ0hST01JVU0pCi0jZXJyb3IgIkNocm9taXVtIHNob3VsZCBub3QgY29tcGlsZSB0aGlz IGZpbGUgYW5kIGluc3RlYWQgZGVmaW5lIGl0cyBvd24gdmVyc2lvbiBvZiB0aGVzZSBmYWN0b3Jp ZXMuIgorI2lmIFBMQVRGT1JNKENIUk9NSVVNKSB8fCBQTEFURk9STShHVEspCisjZXJyb3IgIkNo cm9taXVtICYgV2ViS2l0R1RLKyBzaG91bGQgbm90IGNvbXBpbGUgdGhpcyBmaWxlIGFuZCBpbnN0 ZWFkIGRlZmluZSBpdHMgb3duIHZlcnNpb24gb2YgdGhlc2UgZmFjdG9yaWVzLiIKICNlbmRpZgog CiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li45NmUyNjY3Y2RiNjBjOThhMzM3NTRlNzAwYzlhZTQ5ZmUxYWMzZjExCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0ay5jcHAKQEAgLTAsMCArMSwxNjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFu IERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICog TGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0 aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55 IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAq IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICog WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFs IFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0 ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVT eXN0ZW1HdGsuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXIuaCIKKyNpbmNsdWRlICJDcm9z c1RocmVhZFRhc2suaCIKKyNpbmNsdWRlICJGaWxlTWV0YWRhdGEuaCIKKyNpbmNsdWRlICJTY3Jp cHRFeGVjdXRpb25Db250ZXh0LmgiCisKKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKwordGVtcGxhdGU8PiBzdHJ1Y3QgQ3Jvc3NUaHJlYWRDb3Bp ZXJCYXNlPGZhbHNlLCBmYWxzZSwgRmlsZU1ldGFkYXRhPiB7CisgICAgdHlwZWRlZiBGaWxlTWV0 YWRhdGEgVHlwZTsKKyAgICBzdGF0aWMgRmlsZU1ldGFkYXRhIGNvcHkoY29uc3QgRmlsZU1ldGFk YXRhJik7Cit9OworCitDcm9zc1RocmVhZENvcGllckJhc2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0 YWRhdGE+OjpUeXBlIENyb3NzVGhyZWFkQ29waWVyQmFzZTxmYWxzZSwgZmFsc2UsIEZpbGVNZXRh ZGF0YT46OmNvcHkoY29uc3QgRmlsZU1ldGFkYXRhJiBvcmlnaW5hbCkKK3sKKyAgICBGaWxlTWV0 YWRhdGEgbWV0YWRhdGE7CisgICAgbWV0YWRhdGEubW9kaWZpY2F0aW9uVGltZSA9IG9yaWdpbmFs Lm1vZGlmaWNhdGlvblRpbWU7CisgICAgbWV0YWRhdGEubGVuZ3RoID0gb3JpZ2luYWwubGVuZ3Ro OworICAgIG1ldGFkYXRhLnR5cGUgPSBvcmlnaW5hbC50eXBlOworICAgIG1ldGFkYXRhLnBsYXRm b3JtUGF0aCA9IG9yaWdpbmFsLnBsYXRmb3JtUGF0aDsKKyAgICByZXR1cm4gbWV0YWRhdGE7Cit9 CisKK1Bhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNo cm9ub3VzKQoreworICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrKGNvbnRleHQsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKK30KKworUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 azo6Y3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxl ciwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgY29uc3Qg U3RyaW5nJiBtb2RlKQoreworICAgIHJldHVybiBhZG9wdFB0cihuZXcgQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrKHRhc2tDb250cm9sbGVyLCBjYWxsYmFja3MsIG1vZGUpKTsKK30KKworCitB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQorICAgIDogbV9zeW5jaHJv bm91cyhzeW5jaHJvbm91cykKKyAgICAsIG1fdGFza01vZGUoIiIpCisgICAgLCBtX3Rhc2tDb250 cm9sbGVyKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjcmVhdGUoY29udGV4dCwg c3luY2hyb25vdXMpKQorICAgICwgbV9jYWxsYmFja3MoY2FsbGJhY2tzKQoreworfQorCitBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbW9kZSkK KyAgICA6IG1fc3luY2hyb25vdXMoZmFsc2UpCisgICAgLCBtX3Rhc2tNb2RlKG1vZGUpCisgICAg LCBtX3Rhc2tDb250cm9sbGVyKHRhc2tDb250cm9sbGVyKQorICAgICwgbV9jYWxsYmFja3MoY2Fs bGJhY2tzKQoreworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzKQoreworICAgIGNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOworfQorCit2b2lk IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkU3VjY2VlZCgpCit7CisgICAgbV90YXNr Q29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1E aWRTdWNjZWVkQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSksIG1fdGFza01vZGUpOwor fQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjayhTY3JpcHRF eGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNh bGxiYWNrcywgY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4g ZmlsZVN5c3RlbSkKK3sKKyAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIGZp bGVTeXN0ZW0pOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkT3Bl bkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bT4gZmlsZVN5c3RlbSkKK3sKKyAgICBBc3luY0ZpbGVTeXN0ZW1HdGsqIGZpbGVTeXN0ZW1HdGsg PSBzdGF0aWNfY2FzdDxBc3luY0ZpbGVTeXN0ZW1HdGsqPihmaWxlU3lzdGVtLmdldCgpKTsKKwor ICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworICAgIG1f dGFza0NvbnRyb2xsZXItPnNldEN1cnJlbnRUYXNrTW9kZShtb2RlKTsKKyAgICBtX3Rhc2tDb250 cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZE9w ZW5GaWxlU3lzdGVtQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgbmFtZSwgZmlsZVN5 c3RlbSksIG1vZGUpOworCisgICAgZmlsZVN5c3RlbUd0ay0+c2V0VGFza0NvbnRyb2xsZXIobV90 YXNrQ29udHJvbGxlci5yZWxlYXNlKCkpOworICAgIGZpbGVTeXN0ZW1HdGstPndhaXRGb3JPcGVy YXRpb25Ub0NvbXBsZXRlKCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRSZWFkTWV0YWRh dGFDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgY29uc3QgRmlsZU1ldGFkYXRhJiBtZXRhZGF0YSkK K3sKKyAgICBjYWxsYmFja3MtPmRpZFJlYWRNZXRhZGF0YShtZXRhZGF0YSk7Cit9CisKK3ZvaWQg QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1l dGFkYXRhJiBtZXRhZGF0YSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tU YXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFJlYWRNZXRhZGF0YUNhbGxiYWNrLCBt X2NhbGxiYWNrcy5yZWxlYXNlKCksIG1ldGFkYXRhKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQg QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cnkoY29uc3Qg U3RyaW5nJiBuYW1lLCBib29sIGlzRGlyZWN0b3J5KQoreworICAgIERpcmVjdG9yeUVudHJ5IGRp cmVjdG9yeUVudHJ5OworICAgIGRpcmVjdG9yeUVudHJ5Lm5hbWUgPSBuYW1lOworICAgIGRpcmVj dG9yeUVudHJ5LmlzRGlyZWN0b3J5ID0gaXNEaXJlY3Rvcnk7CisgICAgbV9kaXJlY3RvcnlFbnRy aWVzLmFwcGVuZChkaXJlY3RvcnlFbnRyeSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRS ZWFkRGlyZWN0b3J5RW50cmllc0FuZEZpbmlzaGVkQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7 CisgICAgY2FsbGJhY2tzLT5kaWRSZWFkRGlyZWN0b3J5RW50cmllcyhmYWxzZSk7Cit9CisKK3Zv aWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cmllcyhi b29sIGhhc01vcmUpCit7CisgICAgaWYgKGhhc01vcmUpCisgICAgICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOworCisgICAgVmVjdG9yPERpcmVjdG9yeUVudHJ5Pjo6aXRlcmF0b3IgZW5kID0gbV9k aXJlY3RvcnlFbnRyaWVzLmVuZCgpOworICAgIGZvciAoVmVjdG9yPERpcmVjdG9yeUVudHJ5Pjo6 aXRlcmF0b3IgaXQgPSBtX2RpcmVjdG9yeUVudHJpZXMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0 KQorICAgICAgICBtX2NhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeUVudHJ5KGl0LT5uYW1lLCBp dC0+aXNEaXJlY3RvcnkpOworCisgICAgbV9kaXJlY3RvcnlFbnRyaWVzLmNsZWFyKCk7CisKKyAg ICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygm cGVyZm9ybURpZFJlYWREaXJlY3RvcnlFbnRyaWVzQW5kRmluaXNoZWRDYWxsYmFjaywgbV9jYWxs YmFja3MucmVsZWFzZSgpKSwgbV90YXNrTW9kZSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1E aWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIFBhc3NPd25QdHI8QXN5 bmNGaWxlV3JpdGVyPiB3cml0ZXIsIGxvbmcgbG9uZyBsZW5ndGgpCit7CisgICAgY2FsbGJhY2tz LT5kaWRDcmVhdGVGaWxlV3JpdGVyKHdyaXRlciwgbGVuZ3RoKTsKK30KKwordm9pZCBBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZENyZWF0ZUZpbGVXcml0ZXIoUGFzc093blB0cjxBc3lu Y0ZpbGVXcml0ZXI+IHdyaXRlciwgbG9uZyBsb25nIGxlbmd0aCkKK3sKKyAgICBtX3Rhc2tDb250 cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZENy ZWF0ZUZpbGVXcml0ZXJDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCB3cml0ZXIsIGxl bmd0aCksIG1fdGFza01vZGUpOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkRmFpbENhbGxi YWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4gY2FsbGJhY2tzLCBpbnQgY29kZSkKK3sKKyAgICBjYWxsYmFja3MtPmRpZEZhaWwo Y29kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRGYWlsKGlu dCBjb2RlKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRl Q2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkRmFpbENhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNl KCksIGNvZGUpLCBtX3Rhc2tNb2RlKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisj ZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmE4N2Q1NDY5ZmExNjNlNzEwMDQzNjM1MDc3ZDNhMDZkNzk0MDFiZDUKLS0tIC9kZXYvbnVsbAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrLmgKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9i ZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQg dW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNl bnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIK KyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0 ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhv cGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVz c2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRv IHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJl ZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNp Zm5kZWYgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrX2gKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUg IkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrLmgiCisKKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CisKK2NsYXNz IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayA6IHB1YmxpYyBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3MgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0az4gY3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGJvb2wgc3luY2hyb25vdXMgPSBmYWxzZSk7CisgICAg c3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBjcmVhdGUoQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4sIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlk U3VjY2VlZCgpOworICAgIHZpcnR1YWwgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBTdHJp bmcmIG5hbWUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPik7CisgICAgdmlydHVhbCB2b2lk IGRpZFJlYWRNZXRhZGF0YShjb25zdCBGaWxlTWV0YWRhdGEmKTsKKyAgICB2aXJ0dWFsIHZvaWQg ZGlkUmVhZERpcmVjdG9yeUVudHJ5KGNvbnN0IFN0cmluZyYgbmFtZSwgYm9vbCBpc0RpcmVjdG9y eSk7CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKGJvb2wgaGFzTW9y ZSk7CisgICAgdmlydHVhbCB2b2lkIGRpZENyZWF0ZUZpbGVXcml0ZXIoUGFzc093blB0cjxBc3lu Y0ZpbGVXcml0ZXI+LCBsb25nIGxvbmcgbGVuZ3RoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkRmFp bChpbnQgY29kZSk7CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrcz4sIGJvb2wgc3luY2hyb25vdXMpOworICAgIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 ayhBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayosIFBhc3NPd25QdHI8QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzPiwgY29uc3QgU3RyaW5nJiBtb2RlKTsKKworICAgIHN0cnVjdCBEaXJl Y3RvcnlFbnRyeSB7CisgICAgICAgIFN0cmluZyBuYW1lOworICAgICAgICBib29sIGlzRGlyZWN0 b3J5OworCisgICAgICAgIERpcmVjdG9yeUVudHJ5KCkgOiBpc0RpcmVjdG9yeShmYWxzZSkgeyB9 CisgICAgfTsKKworICAgIGJvb2wgbV9zeW5jaHJvbm91czsKKyAgICBTdHJpbmcgbV90YXNrTW9k ZTsKKyAgICBSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IG1fdGFza0Nv bnRyb2xsZXI7CisgICAgT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gbV9jYWxsYmFj a3M7CisgICAgVmVjdG9yPERpcmVjdG9yeUVudHJ5PiBtX2RpcmVjdG9yeUVudHJpZXM7Cit9Owor Cit9IC8vIG5hbWVzcGFjZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjZW5k aWYgLy8gQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5jcHAKaW5kZXggYzFkYjAwNmE4NDhmMzky NmRkOWZlYzMxZjk2NGEwZmRiZGFmNjlmYy4uOTc5NzEwMzNiZTk2YzZjNGFiYjVkNzY0YjYxNDQw ZTJiYWVhZTQxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbUd0ay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbUd0ay5jcHAKQEAgLTEsNCArMSw1IEBACiAvKgorICogQ29weXJpZ2h0IChDKSAy MDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgogICogQ29weXJpZ2h0IChD KSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CiAgKgogICogVGhpcyBs aWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpA QCAtMTgsMjcgKzE5LDMzIEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IkFzeW5jRmlsZVN5c3RlbUd0ay5oIgogCiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogCi0jaW5j bHVkZSAiQXN5bmNGaWxlU3lzdGVtR3RrLmgiCi0KLSNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3MuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCIKKyNp bmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorI2luY2x1ZGUgIkFz eW5jRmlsZVdyaXRlckd0ay5oIgorI2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgogI2luY2x1 ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKLSNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgorI2luY2x1 ZGUgIkZpbGVFcnJvci5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgorI2luY2x1ZGUg PGdsaWIuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HT3duUHRyLmg+CisjaW5jbHVkZSA8d3Rm L2dvYmplY3QvR1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKyNpbmNs dWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAog Ym9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKIHsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAogYm9vbCBBc3lu Y0ZpbGVTeXN0ZW06OmlzVmFsaWRUeXBlKFR5cGUgdHlwZSkKIHsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gdHlwZSA9PSBUZW1wb3JhcnkgfHwg dHlwZSA9PSBQZXJzaXN0ZW50OwogfQogCiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5 bmNGaWxlU3lzdGVtOjpjcmVhdGUoVHlwZSB0eXBlKQpAQCAtNDgsODcgKzU1LDQwOSBAQCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoVHlwZSB0eXBl KQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBi YXNlUGF0aCwgY29uc3QgU3RyaW5nJiBzdG9yYWdlSWRlbnRpZmllciwgVHlwZSB0eXBlLCBib29s LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAg IG5vdEltcGxlbWVudGVkKCk7Ci0gICAgY2FsbGJhY2tzLT5kaWRGYWlsKE5PVF9TVVBQT1JURURf RVJSKTsKKyAgICBTdHJpbmcgdHlwZVN0cmluZyA9ICh0eXBlID09IEFzeW5jRmlsZVN5c3RlbTo6 UGVyc2lzdGVudCkgPyAiUGVyc2lzdGVudCIgOiAiVGVtcG9yYXJ5IjsKKyAgICBTdHJpbmcgbmFt ZSA9IHN0b3JhZ2VJZGVudGlmaWVyICsgIjoiICsgdHlwZVN0cmluZzsKKworICAgIGNhbGxiYWNr cy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUodHlwZSkp OwogfQogCiBib29sIEFzeW5jRmlsZVN5c3RlbTo6Y3JhY2tGaWxlU3lzdGVtVVJMKGNvbnN0IEtV UkwmIHVybCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlJiB0eXBlLCBTdHJpbmcmIGZpbGVQYXRoKQog ewotICAgIG5vdEltcGxlbWVudGVkKCk7CiAgICAgcmV0dXJuIGZhbHNlOwogfQogCiBBc3luY0Zp bGVTeXN0ZW1HdGs6OkFzeW5jRmlsZVN5c3RlbUd0ayhBc3luY0ZpbGVTeXN0ZW06OlR5cGUgdHlw ZSkKICAgICA6IEFzeW5jRmlsZVN5c3RlbSh0eXBlKQorICAgICwgbV9sb2NhbEZpbGVTeXN0ZW1C YXNlUGF0aChMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLmZpbGVTeXN0ZW1CYXNl UGF0aCgpKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIEFzeW5jRmlsZVN5c3RlbUd0 azo6fkFzeW5jRmlsZVN5c3RlbUd0aygpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAog U3RyaW5nIEFzeW5jRmlsZVN5c3RlbUd0azo6dG9VUkwoY29uc3QgU3RyaW5nJiBvcmlnaW5TdHJp bmcsIGNvbnN0IFN0cmluZyYgZnVsbFBhdGgpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAg ICByZXR1cm4gU3RyaW5nKCk7CisgICAgQVNTRVJUKCFvcmlnaW5TdHJpbmcuaXNFbXB0eSgpKTsK KyAgICBpZiAob3JpZ2luU3RyaW5nID09IFN0cmluZygibnVsbCIpKQorICAgICAgICByZXR1cm4g U3RyaW5nKCk7CisKKyAgICBTdHJpbmdCdWlsZGVyIHJlc3VsdDsKKyAgICByZXN1bHQuYXBwZW5k KCJmaWxlc3lzdGVtOiIpOworICAgIHJlc3VsdC5hcHBlbmQob3JpZ2luU3RyaW5nKTsKKyAgICBy ZXN1bHQuYXBwZW5kKCIvIik7CisgICAgaWYgKHR5cGUoKSA9PSBUZW1wb3JhcnkpCisgICAgICAg IHJlc3VsdC5hcHBlbmQodGVtcG9yYXJ5UGF0aFByZWZpeCk7CisgICAgaWYgKHR5cGUoKSA9PSBQ ZXJzaXN0ZW50KQorICAgICAgICByZXN1bHQuYXBwZW5kKHBlcnNpc3RlbnRQYXRoUHJlZml4KTsK KyAgICByZXN1bHQuYXBwZW5kKGVuY29kZVdpdGhVUkxFc2NhcGVTZXF1ZW5jZXMoZnVsbFBhdGgp KTsKKworICAgIHJldHVybiByZXN1bHQudG9TdHJpbmcoKTsKK30KKworc3RhdGljIHZvaWQgbW92 ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIHNyY1BhdGgsIFN0cmluZyYg ZGVzdFBhdGgpCit7CisgICAgR1JlZlB0cjxHRmlsZT4gc291cmNlRmlsZSA9IGFkb3B0R1JlZihn X2ZpbGVfbmV3X2Zvcl9wYXRoKHNyY1BhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIEdSZWZQdHI8 R0ZpbGU+IGRlc3RpbmF0aW9uRmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGRl c3RQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBzb3VyY2VJ bmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKHNvdXJjZUZpbGUuZ2V0KCksICIqIiwg R19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlmICghc291cmNlSW5mbykgewor ICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJS KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBkZXN0 aW5hdGlvbkluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oZGVzdGluYXRpb25GaWxl LmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBpZiAoZGVz dGluYXRpb25JbmZvKSB7CisgICAgICAgIEdGaWxlVHlwZSBzb3VyY2VGaWxlVHlwZSA9IGdfZmls ZV9pbmZvX2dldF9maWxlX3R5cGUoc291cmNlSW5mby5nZXQoKSk7CisgICAgICAgIEdGaWxlVHlw ZSBkZXN0aW5hdGlvbkZpbGVUeXBlID0gZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShkZXN0aW5h dGlvbkluZm8uZ2V0KCkpOworCisgICAgICAgIGlmIChzb3VyY2VGaWxlVHlwZSAhPSBkZXN0aW5h dGlvbkZpbGVUeXBlKSB7CisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmls ZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlIpOworICAgICAgICAgICAgcmV0dXJuOwor ICAgICAgICB9CisgICAgICAgIGlmIChkZXN0aW5hdGlvbkZpbGVUeXBlID09IEdfRklMRV9UWVBF X0RJUkVDVE9SWQorICAgICAgICAgICAgICAgICYmICFnX2ZpbGVfZGVsZXRlKGRlc3RpbmF0aW9u RmlsZS5nZXQoKSwgMCwgMCkpIHsKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFp bChGaWxlRXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUik7CisgICAgICAgICAgICByZXR1 cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAoIWdfZmlsZV9tb3ZlKHNvdXJjZUZpbGUu Z2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgR19GSUxFX0NPUFlfT1ZFUldSSVRFLCAwLCAw LCAwLCAwKSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpO T1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBlckNhbGxi YWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6bW92ZShj b25zdCBTdHJpbmcmIHNvdXJjZVBhdGgsIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25QYXRoLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5v dEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIHNvdXJjZUZpbGVTeXN0ZW1QYXRoID0gdmlydHVh bFBhdGhUb0ZpbGVTeXN0ZW1VUkwoc291cmNlUGF0aCk7CisgICAgU3RyaW5nIGRlc3RpbmF0aW9u RmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChkZXN0aW5hdGlvblBh dGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOwor CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJh Y2tUYXNrKCZtb3ZlQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1f dGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIHNvdXJjZUZpbGVTeXN0ZW1Q YXRoLCBkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoKSk7Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlS ZWN1cnNpdmVseShHRmlsZSogc291cmNlRGlyZWN0b3J5LCBHRmlsZSogZGVzdGluYXRpb25EaXJl Y3RvcnksIEdFcnJvcioqIGVycm9yKQoreworICAgIGlmICghZ19maWxlX21ha2VfZGlyZWN0b3J5 KGRlc3RpbmF0aW9uRGlyZWN0b3J5LCAwLCBlcnJvcikpCisgICAgICAgIHJldHVybjsKKworICAg IEdPd25QdHI8R0Rpcj4gZGlyZWN0b3J5KGdfZGlyX29wZW4oZ19maWxlX2dldF9wYXRoKHNvdXJj ZURpcmVjdG9yeSksIDAsIGVycm9yKSk7CisgICAgaWYgKCFkaXJlY3RvcnkpCisgICAgICAgIHJl dHVybjsKKworICAgIHdoaWxlIChjb25zdCBjaGFyKiBkaXJlY3RvcnlFbnRyeSA9IGNvbnN0X2Nh c3Q8Y2hhcio+KGdfZGlyX3JlYWRfbmFtZShkaXJlY3RvcnkuZ2V0KCkpKSkgeworICAgICAgICBH UmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQoc291 cmNlRGlyZWN0b3J5LCBkaXJlY3RvcnlFbnRyeSkpOworICAgICAgICBHUmVmUHRyPEdGaWxlPiBk ZXN0aW5hdGlvbkZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX2dldF9jaGlsZChkZXN0aW5hdGlvbkRp cmVjdG9yeSwgZGlyZWN0b3J5RW50cnkpKTsKKworICAgICAgICBHUmVmUHRyPEdGaWxlSW5mbz4g c291cmNlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhzb3VyY2VGaWxlLmdldCgp LCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIGVycm9yKSk7CisgICAgICAgIGlmICgh c291cmNlSW5mbykKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgaWYgKGdfZmlsZV9pbmZv X2dldF9maWxlX3R5cGUoc291cmNlSW5mby5nZXQoKSkgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZ KSB7CisgICAgICAgICAgICBjb3B5UmVjdXJzaXZlbHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGlu YXRpb25GaWxlLmdldCgpLCBlcnJvcik7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0K KyAgICAgICAgaWYgKCFnX2ZpbGVfY29weShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZp bGUuZ2V0KCksIEdfRklMRV9DT1BZX05PTkUsIDAsIDAsIDAsIGVycm9yKSkKKyAgICAgICAgICAg IHJldHVybjsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlBc3luYyhTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBl ckNhbGxiYWNrcywgU3RyaW5nJiBzb3VyY2VQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQoreworICAg IEdSZWZQdHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0 aChzb3VyY2VQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBkZXN0aW5h dGlvbkZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51dGY4KCku ZGF0YSgpKSk7CisKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gc291cmNlSW5mbyA9IGFkb3B0R1Jl ZihnX2ZpbGVfcXVlcnlfaW5mbyhzb3VyY2VGaWxlLmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9J TkZPX05PTkUsIDAsIDApKTsKKyAgICBpZiAoIXNvdXJjZUluZm8pIHsKKyAgICAgICAgaGVscGVy Q2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJl dHVybjsKKyAgICB9CisKKyAgICBHRmlsZVR5cGUgc291cmNlRmlsZVR5cGUgPSBnX2ZpbGVfaW5m b19nZXRfZmlsZV90eXBlKHNvdXJjZUluZm8uZ2V0KCkpOworICAgIEdSZWZQdHI8R0ZpbGVJbmZv PiBkZXN0aW5hdGlvbkluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oZGVzdGluYXRp b25GaWxlLmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKyAgICBp ZiAoZGVzdGluYXRpb25JbmZvKSB7CisgICAgICAgIEdGaWxlVHlwZSBkZXN0aW5hdGlvbkZpbGVU eXBlID0gZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShkZXN0aW5hdGlvbkluZm8uZ2V0KCkpOwor ICAgICAgICBpZiAoc291cmNlRmlsZVR5cGUgIT0gZGVzdGluYXRpb25GaWxlVHlwZSkgeworICAg ICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJ RklDQVRJT05fRVJSKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICBp ZiAoZGVzdGluYXRpb25GaWxlVHlwZSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkKKyAgICAgICAg ICAgICAgICAmJiAhZ19maWxlX2RlbGV0ZShkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIDAsIDApKSB7 CisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpJTlZBTElE X01PRElGSUNBVElPTl9FUlIpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAg fQorCisgICAgaWYgKHNvdXJjZUZpbGVUeXBlID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkgewor ICAgICAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgICAgIGNvcHlSZWN1cnNpdmVseShz b3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCksICZlcnJvci5vdXRQdHIoKSk7 CisgICAgICAgIGlmIChlcnJvcikKKyAgICAgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFp bChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICBlbHNlCisgICAgICAgICAgICBo ZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwor ICAgIGlmICghZ19maWxlX2NvcHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGluYXRpb25GaWxlLmdl dCgpLCBHX0ZJTEVfQ09QWV9PVkVSV1JJVEUsIDAsIDAsIDAsIDApKSB7CisgICAgICAgIGhlbHBl ckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CiB9CiAK IHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjb3B5KGNvbnN0IFN0cmluZyYgc291cmNlUGF0aCwg Y29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJp bmcgc291cmNlRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChzb3Vy Y2VQYXRoKTsKKyAgICBTdHJpbmcgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQ YXRoVG9GaWxlU3lzdGVtVVJMKGRlc3RpbmF0aW9uUGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBt X3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5w b3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmNvcHlBc3luYywgQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2Fs bGJhY2tzLCBtb2RlKSwgc291cmNlRmlsZVN5c3RlbVBhdGgsIGRlc3RpbmF0aW9uRmlsZVN5c3Rl bVBhdGgpKTsKK30KKworc3RhdGljIHZvaWQgcmVtb3ZlRmlsZShHRmlsZSogZmlsZSwgYm9vbCBy ZWN1cnNpdmUsIEdFcnJvcioqIGVycm9yKQoreworICAgIGlmIChyZWN1cnNpdmUgJiYgZ19maWxl X3Rlc3QoZ19maWxlX2dldF9wYXRoKGZpbGUpLCBHX0ZJTEVfVEVTVF9JU19ESVIpKSB7CisgICAg ICAgIEdPd25QdHI8R0Rpcj4gZGlyZWN0b3J5KGdfZGlyX29wZW4oZ19maWxlX2dldF9wYXRoKGZp bGUpLCAwLCBlcnJvcikpOworICAgICAgICBpZiAoIWRpcmVjdG9yeSkKKyAgICAgICAgICAgIHJl dHVybjsKKworICAgICAgICB3aGlsZSAoY29uc3QgY2hhciogZGlyZWN0b3J5RW50cnkgPSBjb25z dF9jYXN0PGNoYXIqPihnX2Rpcl9yZWFkX25hbWUoZGlyZWN0b3J5LmdldCgpKSkpIHsKKyAgICAg ICAgICAgIEdSZWZQdHI8R0ZpbGU+IGNoaWxkID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQo ZmlsZSwgZGlyZWN0b3J5RW50cnkpKTsKKyAgICAgICAgICAgIHJlbW92ZUZpbGUoY2hpbGQuZ2V0 KCksIHJlY3Vyc2l2ZSwgZXJyb3IpOworICAgICAgICAgICAgaWYgKCplcnJvcikKKyAgICAgICAg ICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBnX2ZpbGVfZGVsZXRlKGZp bGUsIDAsIGVycm9yKTsKK30KKworc3RhdGljIHZvaWQgcmVtb3ZlQXN5bmMoU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxw ZXJDYWxsYmFja3MsIFN0cmluZyYgZmlsZVBhdGgsIGJvb2wgcmVjdXJzaXZlKQoreworICAgIEdP d25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxlPiBmaWxlID0gYWRvcHRHUmVm KGdfZmlsZV9uZXdfZm9yX3BhdGgoZmlsZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIHJlbW92 ZUZpbGUoZmlsZS5nZXQoKSwgcmVjdXJzaXZlLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGlmIChl cnJvcikgeworICAgICAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNvZGU7CisgICAgICAg IHN3aXRjaCAoZXJyb3ItPmNvZGUpIHsKKyAgICAgICAgY2FzZSBHX0lPX0VSUk9SX05PVF9FTVBU WToKKyAgICAgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJ T05fRVJSOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgR19JT19FUlJPUl9OT1Rf Rk9VTkQ6CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJy b3I6Ok5PVF9GT1VORF9FUlI7CisgICAgICAgIH0KKworICAgICAgICBoZWxwZXJDYWxsYmFja3Mt PmRpZEZhaWwoZXJyb3JDb2RlKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGhlbHBl ckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6 cmVtb3ZlKGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBm aWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0 cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNr Q29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZyZW1v dmVBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJv bGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgsIGZhbHNlKSk7CiB9 CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZW1vdmVSZWN1cnNpdmVseShjb25zdCBTdHJp bmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3Mp CiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2 aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFz a0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RU YXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVtb3ZlQXN5bmMsIEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxi YWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoLCB0cnVlKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJl YWRNZXRhZGF0YUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGZpbGVQYXRo KQoreworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3Jf cGF0aChmaWxlUGF0aC51dGY4KCkuZGF0YSgpKSk7CisgICAgR1JlZlB0cjxHRmlsZUluZm8+IGZp bGVJbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKGZpbGUuZ2V0KCksICIqIiwgR19G SUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlmICghZmlsZUluZm8pIHsKKyAgICAg ICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBGaWxlTWV0YWRhdGE6OlR5cGUgdHlwZSA9IGdf ZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZmlsZUluZm8uZ2V0KCkpID09IEdfRklMRV9UWVBFX0RJ UkVDVE9SWSA/IEZpbGVNZXRhZGF0YTo6VHlwZURpcmVjdG9yeSA6IEZpbGVNZXRhZGF0YTo6VHlw ZUZpbGU7CisKKyAgICBHVGltZVZhbCB0aW1lVmFsdWU7CisgICAgZ19maWxlX2luZm9fZ2V0X21v ZGlmaWNhdGlvbl90aW1lKGZpbGVJbmZvLmdldCgpLCAmdGltZVZhbHVlKTsKKworICAgIEZpbGVN ZXRhZGF0YSBtZXRhZGF0YTsKKyAgICBtZXRhZGF0YS50eXBlID0gdHlwZTsKKyAgICBtZXRhZGF0 YS5tb2RpZmljYXRpb25UaW1lID0gc3RhdGljX2Nhc3Q8ZG91YmxlPih0aW1lVmFsdWUudHZfc2Vj KTsKKyAgICBtZXRhZGF0YS5sZW5ndGggPSB0eXBlID09IEZpbGVNZXRhZGF0YTo6VHlwZUZpbGUg PyBzdGF0aWNfY2FzdDxsb25nIGxvbmc+KGdfZmlsZV9pbmZvX2dldF9zaXplKGZpbGVJbmZvLmdl dCgpKSkgOiAwOworICAgIG1ldGFkYXRhLnBsYXRmb3JtUGF0aCA9IFN0cmluZyhnX2ZpbGVfZ2V0 X3BhdGgoZmlsZS5nZXQoKSkpOworCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRSZWFkTWV0YWRh dGEobWV0YWRhdGEpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZE1ldGFkYXRh KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lz dGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBt b2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJv bGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZyZWFkTWV0YWRh dGFBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJv bGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgpKTsKIH0KIAotdm9p ZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZUZpbGUoY29uc3QgU3RyaW5nJiBwYXRoLCBib29s IGV4Y2x1c2l2ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKK3N0YXRpYyB2b2lkIGNyZWF0ZU9iamVjdEFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tz LCBTdHJpbmcmIGxvY2FsRmlsZVN5c3RlbVBhdGgsIFN0cmluZyYgYWJzb2x1dGVQYXRoLCBHRmls ZVR5cGUgdHlwZSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIGlmICh0eXBlID09IEdf RklMRV9UWVBFX1JFR1VMQVIgJiYgYWJzb2x1dGVQYXRoID09IFN0cmluZygiLyIpKSB7CisgICAg ICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbChGaWxlRXJyb3I6OlNFQ1VSSVRZX0VSUik7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAg R1JlZlB0cjxHRmlsZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGxvY2Fs RmlsZVN5c3RlbVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIGlmICh0eXBlID09IEdfRklMRV9U WVBFX1JFR1VMQVIpCisgICAgICAgIEdSZWZQdHI8R0ZpbGVPdXRwdXRTdHJlYW0+IG91dHB1dFN0 cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfY3JlYXRlKGZpbGUuZ2V0KCksIEdfRklMRV9DUkVBVEVf Tk9ORSwgMCwgJmVycm9yLm91dFB0cigpKSk7CisgICAgZWxzZSBpZiAodHlwZSA9PSBHX0ZJTEVf VFlQRV9ESVJFQ1RPUlkpCisgICAgICAgIGdfZmlsZV9tYWtlX2RpcmVjdG9yeShmaWxlLmdldCgp LCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGVsc2UKKyAgICAgICAgQVNTRVJUX05PVF9SRUFD SEVEKCk7CisKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgRmlsZUVycm9yOjpFcnJvckNvZGUg ZXJyb3JDb2RlOworICAgICAgICBzd2l0Y2ggKGVycm9yLT5jb2RlKSB7CisgICAgICAgIGNhc2Ug R19JT19FUlJPUl9FWElTVFM6CisgICAgICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6OklO VkFMSURfTU9ESUZJQ0FUSU9OX0VSUjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNl IEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgZXJy b3JDb2RlID0gRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSOworICAgICAgICB9CisgICAgICAgIGhl bHBlckNhbGxiYWNrcy0+ZGlkRmFpbChlcnJvckNvZGUpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CiB9CiAKLXZvaWQgQXN5bmNG aWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3RvcnkoY29uc3QgU3RyaW5nJiBwYXRoLCBib29sIGV4 Y2x1c2l2ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykK K3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVPYmplY3QoUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgs IEdGaWxlVHlwZSB0eXBlKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGxv Y2FsRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChhYnNvbHV0ZVBh dGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOwor CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJh Y2tUYXNrKCZjcmVhdGVPYmplY3RBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpj cmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgbG9jYWxGaWxl U3lzdGVtUGF0aCwgYWJzb2x1dGVQYXRoLCB0eXBlKSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lz dGVtR3RrOjpjcmVhdGVGaWxlKGNvbnN0IFN0cmluZyYgYWJzb2x1dGVQYXRoLCBib29sIGV4Y2x1 c2l2ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sK KyAgICBjcmVhdGVPYmplY3QoY2FsbGJhY2tzLCBhYnNvbHV0ZVBhdGgsIEdfRklMRV9UWVBFX1JF R1VMQVIpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGlyZWN0b3J5KGNv bnN0IFN0cmluZyYgYWJzb2x1dGVQYXRoLCBib29sIGV4Y2x1c2l2ZSwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjcmVhdGVPYmplY3QoY2Fs bGJhY2tzLCBhYnNvbHV0ZVBhdGgsIEdfRklMRV9UWVBFX0RJUkVDVE9SWSk7Cit9CisKK3N0YXRp YyB2b2lkIG9iamVjdEV4aXN0c0FzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcm IHBhdGgsIEdGaWxlVHlwZSB0eXBlKQoreworICAgIEdSZWZQdHI8R0ZpbGU+IG9iamVjdCA9IGFk b3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIEdS ZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhv YmplY3QuZ2V0KCksICIqIiwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgMCkpOworICAgIGlm ICghZmlsZUluZm8pIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJv cjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKGdfZmls ZV9pbmZvX2dldF9maWxlX3R5cGUoZmlsZUluZm8uZ2V0KCkpICE9IHR5cGUpIHsKKyAgICAgICAg aGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6VFlQRV9NSVNNQVRDSF9FUlIpOwor ICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVk KCk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpmaWxlRXhpc3RzKGNvbnN0IFN0cmlu ZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykK IHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZp cnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNr Q29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRh c2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvYmplY3RFeGlzdHNBc3luYywgQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwg Y2FsbGJhY2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgsIEdfRklMRV9UWVBFX1JFR1VMQVIpKTsK IH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmRpcmVjdG9yeUV4aXN0cyhjb25zdCBTdHJp bmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3Mp CiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2 aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFz a0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RU YXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmb2JqZWN0RXhpc3RzQXN5bmMsIEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCks IGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoLCBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkp KTsKK30KKworc3RhdGljIHZvaWQgcmVhZERpcmVjdG9yeUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gY2FsbGJhY2tz LCBTdHJpbmcmIHBhdGgpCit7CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQ dHI8R0ZpbGU+IGRpcmVjdG9yeUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChw YXRoLnV0ZjgoKS5kYXRhKCkpKTsKKworICAgIEdPd25QdHI8R0Rpcj4gZGlyZWN0b3J5KGdfZGly X29wZW4ocGF0aC51dGY4KCkuZGF0YSgpLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAo IWVycm9yKSB7CisgICAgICAgIHdoaWxlIChjb25zdCBjaGFyKiBkaXJlY3RvcnlFbnRyeSA9IGNv bnN0X2Nhc3Q8Y2hhcio+KGdfZGlyX3JlYWRfbmFtZShkaXJlY3RvcnkuZ2V0KCkpKSkgeworICAg ICAgICAgICAgR1JlZlB0cjxHRmlsZT4gY2hpbGQgPSBhZG9wdEdSZWYoZ19maWxlX2dldF9jaGls ZChkaXJlY3RvcnlGaWxlLmdldCgpLCBkaXJlY3RvcnlFbnRyeSkpOworICAgICAgICAgICAgR1Jl ZlB0cjxHRmlsZUluZm8+IGZpbGVJbmZvID0gYWRvcHRHUmVmKGdfZmlsZV9xdWVyeV9pbmZvKGNo aWxkLmdldCgpLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsKKworICAgICAg ICAgICAgYm9vbCBpc0VudHJ5RGlyZWN0b3J5ID0gZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShm aWxlSW5mby5nZXQoKSkgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZOworICAgICAgICAgICAgY2Fs bGJhY2tzLT5kaWRSZWFkRGlyZWN0b3J5RW50cnkoU3RyaW5nKGRpcmVjdG9yeUVudHJ5KSwgaXNF bnRyeURpcmVjdG9yeSk7CisgICAgICAgIH0KKyAgICB9IGVsc2UgeworICAgICAgICBjYWxsYmFj a3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIGNhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeUVudHJpZXMoZmFsc2UpOwog fQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZERpcmVjdG9yeShjb25zdCBTdHJpbmcm IHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7 Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0 dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0Nv bnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNr VG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVhZERpcmVjdG9yeUFzeW5jLCBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBj YWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCkpOwogfQogCitzdGF0aWMgdm9pZCBjcmVh dGVXcml0ZXJBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgQXN5bmNGaWxlV3JpdGVyQ2xp ZW50KiBjbGllbnQsIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJv bGxlciwgU3RyaW5nJiBwYXRoKQoreworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdS ZWYoZ19maWxlX25ld19mb3JfcGF0aChwYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRy PEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oZmlsZS5n ZXQoKSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKCFmaWxl SW5mbykgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1Rf Rk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGxvbmcgbG9uZyBmaWxl U2l6ZSA9IHN0YXRpY19jYXN0PGxvbmcgbG9uZz4oZ19maWxlX2luZm9fZ2V0X3NpemUoZmlsZUlu Zm8uZ2V0KCkpKTsKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZENyZWF0ZUZpbGVXcml0ZXIoQXN5 bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUoY2xpZW50LCB0YXNrQ29udHJvbGxlciwgZmlsZS5sZWFr UmVmKCkpLCBmaWxlU2l6ZSk7Cit9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVX cml0ZXIoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGNvbnN0IFN0cmluZyYgcGF0aCwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRo VG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxl ci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5U aHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZjcmVhdGVXcml0ZXJBc3luYywgQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tz LCBtb2RlKSwgQWxsb3dDcm9zc1RocmVhZEFjY2VzcyhjbGllbnQpLCBBbGxvd0Nyb3NzVGhyZWFk QWNjZXNzKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCkpLCBmaWxlU3lzdGVtUGF0aCkpOworfQorCit2 b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlU25hcHNob3RGaWxlQW5kUmVhZE1ldGFkYXRh KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ IGNhbGxiYWNrcykKK3sKKyAgICAvLyBGSVhNRTogSXMgdGhpcyBhcGkgcmVhbGx5IHNhbWUgd2l0 aCByZWFkTWV0YWRhdGE/CisgICAgcmVhZE1ldGFkYXRhKHBhdGgsIGNhbGxiYWNrcyk7Cit9CisK K3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpzZXRUYXNrQ29udHJvbGxlcihQYXNzUmVmUHRyPEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiB0YXNrQ29udHJvbGxlcikKK3sKKyAgICBt X3Rhc2tDb250cm9sbGVyID0gdGFza0NvbnRyb2xsZXI7Cit9CisKK1N0cmluZyBBc3luY0ZpbGVT eXN0ZW1HdGs6OnZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGNvbnN0IFN0cmluZyYgdmlydHVh bFBhdGgpCit7CisgICAgcmV0dXJuIHZpcnR1YWxQYXRoICE9IFN0cmluZygiLyIpID8gbV9sb2Nh bEZpbGVTeXN0ZW1CYXNlUGF0aCArIHZpcnR1YWxQYXRoIDogbV9sb2NhbEZpbGVTeXN0ZW1CYXNl UGF0aDsKK30KKworYm9vbCBBc3luY0ZpbGVTeXN0ZW1HdGs6OndhaXRGb3JPcGVyYXRpb25Ub0Nv bXBsZXRlKCkKK3sKKyAgICByZXR1cm4gbV90YXNrQ29udHJvbGxlci0+d2FpdEZvck9wZXJhdGlv blRvQ29tcGxldGUoKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oCmluZGV4IGNiNDViNmVh NGJjMjAyMGU4ZWI0YzhlYjVhMTk4ZjA3NmY1YTY5N2IuLjgyMDE4ZjE3NTNiYTJlN2IzODdkNjc5 OTdhZmQ0NGVlNTc4OGNjNTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlU3lzdGVtR3RrLmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChD KSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQg KEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CiAgKgogICogVGhp cyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v cgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFs IFB1YmxpYwpAQCAtMjMsMTEgKzIzLDE0IEBACiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogCiAj aW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtLmgiCisKKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CiAjaW5j bHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M7CitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azsKIAogY2xhc3MgQXN5bmNGaWxlU3lzdGVtR3RrIDogcHVibGljIEFzeW5jRmlsZVN5 c3RlbSB7CiBwdWJsaWM6CkBAIC00Niw2ICs0OSwxNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2 b2lkIGRpcmVjdG9yeUV4aXN0cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCB2b2lkIHJlYWREaXJlY3RvcnkoY29u c3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwog ICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVXcml0ZXIoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiwgY29u c3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwor ICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3Qg U3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAg IHZpcnR1YWwgYm9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworCisgICAgdm9pZCBz ZXRUYXNrQ29udHJvbGxlcihQYXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrPik7Citwcml2YXRlOgorICAgIHZvaWQgY3JlYXRlT2JqZWN0KFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiwgY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIEdGaWxlVHlw ZSk7CisgICAgU3RyaW5nIHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGNvbnN0IFN0cmluZyYp OworCisgICAgU3RyaW5nIG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGg7CisgICAgUmVmUHRyPEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOwogfTsKIAog fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZThhNjkwNWM5MmRlZWZiMzA5NTNiMDVjZGU4YjU0ZTc2Zjk3MDFmMAotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ay5jcHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwg UHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBp ZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAx IFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGs+IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjcmVhdGUoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4g YWRvcHRSZWYobmV3IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKGNvbnRleHQsIHN5 bmNocm9ub3VzKSk7Cit9CisKK0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LCBib29sIHN5bmNocm9ub3VzKQorICAgIDogbV9jb250ZXh0KGNvbnRleHQpCisgICAgLCBt X3N5bmNocm9ub3VzKHN5bmNocm9ub3VzKQorICAgICwgbV9jdXJyZW50VGFza01vZGUoIiIpCisg ICAgLCBtX3dyaXRlclRvQ2FuY2VsKDApCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBv cnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0Rv Y3VtZW50KCkpOworfQorCitBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6fkFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKCkKK3sKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrOjp1bmlxdWVNb2RlKCkKK3sKKyAgICAvLyBGSVhNRTogV2Ug ZG9uJ3Qgc3VwcG9ydCB3b2tlcnMgZm9yIGZpbGVzeXN0ZW0geWV0LgorICAgIEFTU0VSVChtX2Nv bnRleHQtPmlzRG9jdW1lbnQoKSk7CisgICAgcmV0dXJuIFN0cmluZygpOworfQorCit2b2lkIEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpwb3N0VGFza1RvTWFpblRocmVhZChQYXNz T3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+IHRhc2spCit7CisgICAgLy8gRklY TUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NF UlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIG1fY29udGV4dC0+cG9zdFRhc2sodGFz ayk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnNldEN1cnJl bnRUYXNrTW9kZShjb25zdCBTdHJpbmcmIHRhc2tNb2RlKQoreworICAgIG1fY3VycmVudFRhc2tN b2RlID0gdGFza01vZGU7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGs6OnBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpU YXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0 IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0 LT5pc0RvY3VtZW50KCkpOworICAgIG1fY29udGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK2Jv b2wgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OndhaXRGb3JPcGVyYXRpb25Ub0Nv bXBsZXRlKCkKK3sKKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFT U0VSVCghbV9zeW5jaHJvbm91cyk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeShBc3lu Y0ZpbGVXcml0ZXJHdGsqIHdyaXRlcikKK3sKKyAgICBpZiAobV93cml0ZXJUb0NhbmNlbCA9PSB3 cml0ZXIpIHsKKyAgICAgICAgbV93cml0ZXJUb0NhbmNlbCA9IDA7CisgICAgICAgIHJldHVybiB0 cnVlOworICAgIH0KKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNv cmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMmQxZjI3NzMzZmZmNDMxMWRhZDkzOTI1MDA4MzhkMjM2NDU4ZmJi ZAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oCkBAIC0wLDAgKzEsNjQgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBH ZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQg V0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGli cmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIx MTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaAorCisjaWYg RU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5o IgorCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkU2Fm ZVJlZkNvdW50ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ayA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNz UmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBjcmVhdGUoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIGJvb2wgc3luY2hyb25vdXMpOworICAgIH5Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0aygpOworCisgICAgdm9pZCBwb3N0VGFza1RvTWFpblRocmVhZChQYXNz T3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKKyAgICB2b2lkIHNldEN1cnJl bnRUYXNrTW9kZShjb25zdCBTdHJpbmcmKTsKKyAgICB2b2lkIHBvc3RDYWxsYmFja1Rhc2soUGFz c093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5nJik7Cisg ICAgYm9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworICAgIGJvb2wgc3luY2hyb25v dXMoKSB7IHJldHVybiBtX3N5bmNocm9ub3VzOyB9CisKKyAgICBib29sIGNhbmNlbFdyaXRlcklm TmVjZXNzYXJ5KEFzeW5jRmlsZVdyaXRlckd0ayopOworICAgIHZvaWQgc2V0V3JpdGVyVG9DYW5j ZWwoQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIpIHsgbV93cml0ZXJUb0NhbmNlbCA9IHdyaXRl cjsgfQorCisgICAgU3RyaW5nIHVuaXF1ZU1vZGUoKTsKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wpOwor CisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogbV9jb250ZXh0OworICAgIGJvb2wgbV9zeW5j aHJvbm91czsKKyAgICBTdHJpbmcgbV9jdXJyZW50VGFza01vZGU7CisKKyAgICBBc3luY0ZpbGVX cml0ZXJHdGsqIG1fd3JpdGVyVG9DYW5jZWw7Cit9OworCit9IC8vIG5hbWVzcGFjZQorCisjZW5k aWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVdyaXRlckNsaWVudEd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYjlmYmNhMDE4OTBkOTBjOWFhZGE4 ZjFlMGE1MjU2NGI3MjYwYWJmMwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwCkBAIC0wLDAgKzEsNjkgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFp bC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJv c3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNU RU0pCisKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2suaCIKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkV3JpdGVDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGxvbmcgbG9uZyBieXRlcywg Ym9vbCBjb21wbGV0ZSkKK3sKKyAgICBjbGllbnQtPmRpZFdyaXRlKGJ5dGVzLCBjb21wbGV0ZSk7 Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCkKK3sKKyAgICBjbGll bnQtPmRpZFRydW5jYXRlKCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRGYWlsQ2FsbGJh Y2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50 LCBGaWxlRXJyb3I6OkVycm9yQ29kZSBjb2RlKQoreworICAgIGNsaWVudC0+ZGlkRmFpbChjb2Rl KTsKK30KKworQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRH dGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBBc3lu Y0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBtb2RlKQorICAgIDogbV90 YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxlcikKKyAgICAsIG1fY2xpZW50KGNsaWVudCkKKyAg ICAsIG1fdGFza01vZGUobW9kZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRDdXJyZW50 VGFza01vZGUobV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3Rr OjpkaWRXcml0ZShsb25nIGxvbmcgYnl0ZXMsIGJvb2wgY29tcGxldGUpCit7CisgICAgbV90YXNr Q29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1E aWRXcml0ZUNhbGxiYWNrLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fY2xpZW50KSwgYnl0ZXMs IGNvbXBsZXRlKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrOjpkaWRUcnVuY2F0ZSgpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNr VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrLCBBbGxv d0Nyb3NzVGhyZWFkQWNjZXNzKG1fY2xpZW50KSksIG1fdGFza01vZGUpOworfQorCit2b2lkIEFz eW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkRmFpbChGaWxlRXJyb3I6OkVycm9yQ29kZSBjb2Rl KQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJh Y2tUYXNrKCZwZXJmb3JtRGlkRmFpbENhbGxiYWNrLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1f Y2xpZW50KSwgY29kZSksIG1fdGFza01vZGUpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u YTZlZTEwOWZkNWQzMzk1YjYxOTgzZDJiODFlMTZjN2YxMjIxOWFmYgotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsu aApAQCAtMCwwICsxLDU3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNl ayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICog dmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMK KyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhl IEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRl ZiBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVXcml0ZXJDbGll bnRHdGtfaAorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJDbGll bnQuaCIKKworI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrIDogcHVibGljIEFzeW5jRmlsZVdy aXRlckNsaWVudCB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrPiBjcmVhdGUoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRh c2tDb250cm9sbGVyLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5n JiBtb2RlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVXcml0 ZXJDbGllbnRHdGsodGFza0NvbnRyb2xsZXIsIGNsaWVudCwgbW9kZSkpOworICAgIH0KKworICAg IHZvaWQgZGlkV3JpdGUobG9uZyBsb25nIGJ5dGVzLCBib29sIGNvbXBsZXRlKTsKKyAgICB2b2lk IGRpZFRydW5jYXRlKCk7CisgICAgdm9pZCBkaWRGYWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlKTsK KworICAgIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlcigp IHsgcmV0dXJuIG1fdGFza0NvbnRyb2xsZXIuZ2V0KCk7IH0KKworcHJpdmF0ZToKKyAgICBBc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBB c3luY0ZpbGVXcml0ZXJDbGllbnQqLCBjb25zdCBTdHJpbmcmKTsKKworICAgIFJlZlB0cjxBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90YXNrQ29udHJvbGxlcjsKKyAgICBBc3lu Y0ZpbGVXcml0ZXJDbGllbnQqIG1fY2xpZW50OworICAgIFN0cmluZyBtX3Rhc2tNb2RlOworfTsK KworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2Vu ZGlmIC8vIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0a19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQ1NjlhYjcz NzkxMDRhMzcyYTFjMmEzNDM2MzlhOWZhOTg3ZmU0MjMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcApAQCAtMCwwICsx LDE1NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVy c2VrQGdtYWlsLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZh bWlkb3dAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5 b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor ICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdp bGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSBy ZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAq IFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxv b3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZp Zy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckd0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVf U1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgiCisjaW5jbHVk ZSAiQmxvYi5oIgorI2luY2x1ZGUgIkJsb2JSZWdpc3RyeUltcGwuaCIKKyNpbmNsdWRlICJDcm9z c1RocmVhZFRhc2suaCIKKworI2luY2x1ZGUgPGdpby9naW8uaD4KKyNpbmNsdWRlIDxnbGliLmg+ CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NT dHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzT3duUHRyPEFzeW5jRmlsZVdy aXRlckd0az4gQXN5bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUoQXN5bmNGaWxlV3JpdGVyQ2xpZW50 KiBjbGllbnQsIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxl ciwgR0ZpbGUqIGZpbGUpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVXcml0 ZXJHdGsoY2xpZW50LCB0YXNrQ29udHJvbGxlciwgZmlsZSkpOworfQorCitBc3luY0ZpbGVXcml0 ZXJHdGs6OkFzeW5jRmlsZVdyaXRlckd0ayhBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBHRmlsZSog ZmlsZSkKKyAgICA6IG1fY2xpZW50KGNsaWVudCkKKyAgICAsIG1fdGFza0NvbnRyb2xsZXIodGFz a0NvbnRyb2xsZXIpCisgICAgLCBtX2ZpbGUoZmlsZSkKK3sKK30KKworc3RhdGljIHZvaWQgd3Jp dGVBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVXcml0 ZXJDbGllbnRHdGs+IGhlbHBlckNsaWVudCwgQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIsIEdG aWxlKiBmaWxlLCBsb25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEpCit7CisgICAgaWYgKGhl bHBlckNsaWVudC0+dGFza0NvbnRyb2xsZXIoKS0+Y2FuY2VsV3JpdGVySWZOZWNlc3Nhcnkod3Jp dGVyKSkgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpBQk9SVF9F UlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR1JlZlB0cjxHRmlsZUlPU3RyZWFt PiBpb1N0cmVhbSA9IGFkb3B0R1JlZihnX2ZpbGVfb3Blbl9yZWFkd3JpdGUoZmlsZSwgMCwgMCkp OworICAgIGlmICghaW9TdHJlYW0pIHsKKyAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZp bGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBH T3duUHRyPEdPdXRwdXRTdHJlYW0+IG91dHB1dFN0cmVhbShnX2lvX3N0cmVhbV9nZXRfb3V0cHV0 X3N0cmVhbShHX0lPX1NUUkVBTShpb1N0cmVhbS5nZXQoKSkpKTsKKyAgICBpZiAoIWdfc2Vla2Fi bGVfc2VlayhHX1NFRUtBQkxFKG91dHB1dFN0cmVhbS5nZXQoKSksIHBvc2l0aW9uLCBHX1NFRUtf U0VULCAwLCAwKSkgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpO T1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIFJlZlB0cjxCbG9i U3RvcmFnZURhdGE+IGJsb2JTdG9yYWdlID0gc3RhdGljX2Nhc3Q8QmxvYlJlZ2lzdHJ5SW1wbCY+ KGJsb2JSZWdpc3RyeSgpKS5nZXRCbG9iRGF0YUZyb21VUkwoZGF0YS0+dXJsKCkpOworICAgIGlm IChibG9iU3RvcmFnZSkgeworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGJsb2JTdG9y YWdlLT5pdGVtcygpLnNpemUoKTsgaSsrKSB7CisgICAgICAgICAgICBjb25zdCBCbG9iRGF0YUl0 ZW0mIGJsb2JJdGVtID0gYmxvYlN0b3JhZ2UtPml0ZW1zKClbaV07CisgICAgICAgICAgICBpZiAo YmxvYkl0ZW0udHlwZSA9PSBCbG9iRGF0YUl0ZW06OkRhdGEpIHsKKyAgICAgICAgICAgICAgICBn c2l6ZSBieXRlc1dyaXR0ZW4gPSAwOworICAgICAgICAgICAgICAgIGdfb3V0cHV0X3N0cmVhbV93 cml0ZV9hbGwoR19PVVRQVVRfU1RSRUFNKG91dHB1dFN0cmVhbS5nZXQoKSksIGJsb2JJdGVtLmRh dGEtPmRhdGEoKSwgYmxvYkl0ZW0uZGF0YS0+bGVuZ3RoKCksICZieXRlc1dyaXR0ZW4sIDAsIDAp OworCisgICAgICAgICAgICAgICAgYm9vbCBjb21wbGV0ZWQgPSBibG9iU3RvcmFnZS0+aXRlbXMo KS5zaXplKCkgPT0gKGkgKyAxKTsKKyAgICAgICAgICAgICAgICBoZWxwZXJDbGllbnQtPmRpZFdy aXRlKGJ5dGVzV3JpdHRlbiwgY29tcGxldGVkKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQor ICAgIH0KK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OndyaXRlKGxvbmcgbG9uZyBwb3Np dGlvbiwgQmxvYiogZGF0YSkKK3sKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXIt PnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhy ZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmd3JpdGVBc3luYywgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgbV9jbGllbnQsIG1vZGUpLCBBbGxv d0Nyb3NzVGhyZWFkQWNjZXNzKHRoaXMpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fZmlsZS5n ZXQoKSksIHBvc2l0aW9uLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKGRhdGEpKSk7Cit9CisKK3N0 YXRpYyB2b2lkIHRydW5jYXRlQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25Q dHI8QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrPiBoZWxwZXJDbGllbnQsIEFzeW5jRmlsZVdyaXRl ckd0ayogd3JpdGVyLCBHRmlsZSogZmlsZSwgbG9uZyBsb25nIGxlbmd0aCkKK3sKKyAgICBpZiAo aGVscGVyQ2xpZW50LT50YXNrQ29udHJvbGxlcigpLT5jYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSh3 cml0ZXIpKSB7CisgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6OkFCT1JU X0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4g ZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oZmlsZSwgIioiLCBHX0ZJTEVf UVVFUllfSU5GT19OT05FLCAwLCAwKSk7CisgICAgaWYgKCFmaWxlSW5mbykgeworICAgICAgICBo ZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIGxvbmcgbG9uZyBmaWxlTGVuZ3RoID0gc3RhdGljX2Nhc3Q8 bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5nZXQoKSkpOworICAgIGlm IChsZW5ndGggPiBmaWxlTGVuZ3RoKSB7CisgICAgICAgIEdPd25QdHI8R1N0cmluZz4gemVyb1Bh ZGRpbmcoZ19zdHJpbmdfbmV3X2xlbigwLCBsZW5ndGggLSBmaWxlTGVuZ3RoKSk7CisgICAgICAg IGRvIHsKKyAgICAgICAgICAgIGdfc3RyaW5nX2FwcGVuZF9jKHplcm9QYWRkaW5nLmdldCgpLCAn XDAnKTsKKyAgICAgICAgfSB3aGlsZSAoLS1sZW5ndGggPiBmaWxlTGVuZ3RoKTsKKworICAgICAg ICBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IGlvU3RyZWFtID0gYWRvcHRHUmVmKGdfZmlsZV9vcGVu X3JlYWR3cml0ZShmaWxlLCAwLCAwKSk7CisgICAgICAgIGlmICghaW9TdHJlYW0pIHsKKyAgICAg ICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOwor ICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisKKyAgICAgICAgR093blB0cjxHT3V0cHV0 U3RyZWFtPiBvdXRwdXRTdHJlYW0oZ19pb19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0oR19JT19T VFJFQU0oaW9TdHJlYW0uZ2V0KCkpKSk7CisgICAgICAgIGlmICghZ19zZWVrYWJsZV9zZWVrKEdf U0VFS0FCTEUob3V0cHV0U3RyZWFtLmdldCgpKSwgbGVuZ3RoLCBHX1NFRUtfU0VULCAwLCAwKSkg eworICAgICAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5E X0VSUik7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBnc2l6ZSBi eXRlc1dyaXR0ZW4gPSAwOworICAgICAgICBnX291dHB1dF9zdHJlYW1fd3JpdGVfYWxsKEdfT1VU UFVUX1NUUkVBTShvdXRwdXRTdHJlYW0uZ2V0KCkpLCB6ZXJvUGFkZGluZy0+c3RyLCB6ZXJvUGFk ZGluZy0+bGVuLCAmYnl0ZXNXcml0dGVuLCAwLCAwKTsKKyAgICB9IGVsc2UgeworICAgICAgICBH UmVmUHRyPEdGaWxlT3V0cHV0U3RyZWFtPiBmaWxlT3V0cHV0U3RyZWFtID0gYWRvcHRHUmVmKGdf ZmlsZV9yZXBsYWNlKGZpbGUsIDAsIGZhbHNlLCBHX0ZJTEVfQ1JFQVRFX05PTkUsIDAsIDApKTsK KyAgICAgICAgaWYgKCFmaWxlT3V0cHV0U3RyZWFtIHx8ICFnX3NlZWthYmxlX3RydW5jYXRlKEdf U0VFS0FCTEUoZmlsZU91dHB1dFN0cmVhbS5nZXQoKSksIGxlbmd0aCwgMCwgMCkpIHsKKyAgICAg ICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOwor ICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgaGVscGVyQ2xpZW50 LT5kaWRUcnVuY2F0ZSgpOworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckd0azo6dHJ1bmNhdGUo bG9uZyBsb25nIGxlbmd0aCkKK3sKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXIt PnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhy ZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmdHJ1bmNhdGVBc3luYywgQXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgbV9jbGllbnQsIG1vZGUpLCBB bGxvd0Nyb3NzVGhyZWFkQWNjZXNzKHRoaXMpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fZmls ZS5nZXQoKSksIGxlbmd0aCkpOworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckd0azo6YWJvcnQo KQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnNldFdyaXRlclRvQ2FuY2VsKHRoaXMpOworfQor Citib29sIEFzeW5jRmlsZVdyaXRlckd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKQor eworICAgIHJldHVybiBtX3Rhc2tDb250cm9sbGVyLT5zeW5jaHJvbm91cygpID8gbV90YXNrQ29u dHJvbGxlci0+d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKSA6IGZhbHNlOworfQorCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uNTQ1YjAwYzFjOTc2YWMzNDM0NDZhYzVjNzQ3ZWU1YmU4MDkzZTczYwotLS0gL2Rldi9u dWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsu aApAQCAtMCwwICsxLDU3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNl ayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICog dmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMK KyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhl IEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRl ZiBBc3luY0ZpbGVXcml0ZXJHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVXcml0ZXJHdGtfaAorCisj aWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyLmgiCisK KyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQ dHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0ZpbGVXcml0ZXJDbGll bnQ7CitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azsKKworY2xhc3MgQXN5 bmNGaWxlV3JpdGVyR3RrIDogcHVibGljIEFzeW5jRmlsZVdyaXRlciB7CitwdWJsaWM6CisgICAg c3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyR3RrPiBjcmVhdGUoQXN5bmNGaWxlV3Jp dGVyQ2xpZW50KiwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBHRmlsZSopOwor CisgICAgdm9pZCBhYm9ydCgpOworICAgIHZvaWQgdHJ1bmNhdGUobG9uZyBsb25nIGxlbmd0aCk7 CisgICAgdm9pZCB3cml0ZShsb25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEpOworCisgICAg Ym9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworCitwcml2YXRlOgorICAgIEFzeW5j RmlsZVdyaXRlckd0ayhBc3luY0ZpbGVXcml0ZXJDbGllbnQqLCBBc3luY0ZpbGVTeXN0ZW1UYXNr Q29udHJvbGxlckd0ayosIEdGaWxlKik7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIG1f Y2xpZW50OworICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90 YXNrQ29udHJvbGxlcjsKKyAgICBHUmVmUHRyPEdGaWxlPiBtX2ZpbGU7Cit9OworCit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRp ZiAvLyBBc3luY0ZpbGVXcml0ZXJHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvTG9jYWxGaWxlU3lzdGVtR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42NTk3Mjg0NmU3OWMzODY2 MjE5YmZmY2NjMmI4ZGU2NjQ3MmQ5Nzk0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAKQEAgLTAsMCArMSw4NiBAQAor LyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWls LmNvbT4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhl IEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhl IExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICog IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5z ZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0 d2FyZQorICogIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxv b3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RF TSkKKworI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorI2luY2x1ZGUg IkNyb3NzVGhyZWFkVGFzay5oIgorI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCisjaW5jbHVk ZSA8Z3RrL2d0ay5oPgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KKyNpbmNsdWRlIDx3dGYv Z29iamVjdC9HT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorI2lu Y2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitMb2Nh bEZpbGVTeXN0ZW0qIExvY2FsRmlsZVN5c3RlbTo6c19pbnN0YW5jZSA9IDA7CisKK3ZvaWQgTG9j YWxGaWxlU3lzdGVtOjppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFz ZVBhdGgpCit7CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdPd25QdHI8R0Rpcj4g ZGlyZWN0b3J5KGdfZGlyX29wZW4oYmFzZVBhdGgudXRmOCgpLmRhdGEoKSwgMCwgJmVycm9yLm91 dFB0cigpKSk7CisgICAgaWYgKGVycm9yICYmIGVycm9yLT5jb2RlID09IEdfRklMRV9FUlJPUl9O T0VOVCkgeworICAgICAgICBHUmVmUHRyPEdGaWxlPiBiYXNlRGlyZWN0b3J5RmlsZSA9IGFkb3B0 R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGJhc2VQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICAg ICAgZ19maWxlX21ha2VfZGlyZWN0b3J5KGJhc2VEaXJlY3RvcnlGaWxlLmdldCgpLCAwLCAwKTsK KyAgICB9Cit9CisKK0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVT eXN0ZW0oKQoreworICAgIFdURjo6bG9ja0F0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpY011dGV4 KCk7CisgICAgaWYgKCFzX2luc3RhbmNlKSB7CisgICAgICAgIEdPd25QdHI8Z2NoYXI+IGJhc2VQ YXRoKGdfYnVpbGRfZmlsZW5hbWUoZ19nZXRfdXNlcl9kYXRhX2RpcigpLCAid2Via2l0IiwgImZp bGVzeXN0ZW0iLCBOVUxMKSk7CisgICAgICAgIE93blB0cjxMb2NhbEZpbGVTeXN0ZW0+IGxvY2Fs RmlsZVN5c3RlbSA9IGFkb3B0UHRyKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGguZ2V0KCkp KTsKKyAgICAgICAgbG9jYWxGaWxlU3lzdGVtLT5pbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKFN0 cmluZyhiYXNlUGF0aC5nZXQoKSkpOworCisgICAgICAgIHNfaW5zdGFuY2UgPSBsb2NhbEZpbGVT eXN0ZW0ubGVha1B0cigpOworICAgIH0KKyAgICBXVEY6OnVubG9ja0F0b21pY2FsbHlJbml0aWFs aXplZFN0YXRpY011dGV4KCk7CisgICAgcmV0dXJuICpzX2luc3RhbmNlOworfQorCitTdHJpbmcg TG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAoreworICAgIHJldHVy biBtX2Jhc2VQYXRoOworfQorCitzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbShTY3JpcHRFeGVj dXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJp bmcmIGlkZW50aWZpZXIsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBib29sIGNyZWF0ZSwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5j aHJvbm91cykKK3sKKyAgICBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGJhc2VQYXRo LCBpZGVudGlmaWVyLCB0eXBlLCBjcmVhdGUsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6 Y3JlYXRlKGNvbnRleHQsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKK30KKwordm9pZCBMb2Nh bEZpbGVTeXN0ZW06OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRl eHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQoreworICAgIC8vIEFzeW5j RmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHks IHNvIHRoZSBtZXRob2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgorICAgIGNv bnRleHQtPnBvc3RUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVT eXN0ZW1CYXNlUGF0aCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50 aWZpZXIoKSwgdHlwZSwgZmFsc2UsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKK30KKwordm9p ZCBMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqIGNvbnRleHQsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcsIFBhc3NP d25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25v dXMpCit7CisgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxs YmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5 bmNocm9ub3VzbHkuCisgICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZv cGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQtPnNlY3VyaXR5T3Jp Z2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCB0cnVlLCBjYWxsYmFja3MsIHN5bmNo cm9ub3VzKSk7Cit9CisKK30KKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAt LWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBiZDM0MzAzMjll YTQ1YzVjMGM0YzBmNDAwNDEyY2FmNDdmMGYzNmEwLi5kMTIxY2I3NWEyY2ZhYTQ4ZDkxOGU1NGY2 M2I5NzE0NDA3Nzk3ZTM4IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTItMDQtMDkgIENoYW5nU2VvayBPaCAgPHNo aXZhbWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lz dGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NTg0NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBF bmFibGVkIEZpbGVTeXN0ZW0gZm9yIEdUSyBwb3J0LgorCisgICAgICAgICogU2NyaXB0cy9idWls ZC13ZWJraXQ6CisKIDIwMTItMDQtMDkgIFRha2FzaGkgVG95b3NoaW1hICA8dG95b3NoaW1AY2hy b21pdW0ub3JnPgogCiAgICAgICAgIFVwZGF0ZSBweXdlYnNvY2tldCB0byAwLjcuNC4KZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvYnVpbGQtd2Via2l0IGIvVG9vbHMvU2NyaXB0cy9idWlsZC13 ZWJraXQKaW5kZXggNzMxYWRmZTBhY2JkYzM5MmEwNDJiMzE5ZjJjYWQxOGFhNmQwMDRmMC4uODU3 OGYyYzgxODEyMzcwOGY0ZTQxMGIzOTVjNjg0MThmZTQwMzU2MiAxMDA3NTUKLS0tIGEvVG9vbHMv U2NyaXB0cy9idWlsZC13ZWJraXQKKysrIGIvVG9vbHMvU2NyaXB0cy9idWlsZC13ZWJraXQKQEAg LTIwMyw3ICsyMDMsNyBAQCBteSBAZmVhdHVyZXMgPSAoCiAgICAgICBkZWZpbmUgPT4gIkVOQUJM RV9ESVJFQ1RPUllfVVBMT0FEIiwgZGVmYXVsdCA9PiAwLCB2YWx1ZSA9PiBcJGRpcmVjdG9yeVVw bG9hZFN1cHBvcnQgfSwKIAogICAgIHsgb3B0aW9uID0+ICJmaWxlLXN5c3RlbSIsIGRlc2MgPT4g IlRvZ2dsZSBGaWxlU3lzdGVtIHN1cHBvcnQiLAotICAgICAgZGVmaW5lID0+ICJFTkFCTEVfRklM RV9TWVNURU0iLCBkZWZhdWx0ID0+IGlzQmxhY2tCZXJyeSgpLCB2YWx1ZSA9PiBcJGZpbGVTeXN0 ZW1TdXBwb3J0IH0sCisgICAgICBkZWZpbmUgPT4gIkVOQUJMRV9GSUxFX1NZU1RFTSIsIGRlZmF1 bHQgPT4gKGlzQmxhY2tCZXJyeSgpIHx8IGlzR3RrKCkpLCB2YWx1ZSA9PiBcJGZpbGVTeXN0ZW1T dXBwb3J0IH0sCiAKICAgICB7IG9wdGlvbiA9PiAiZmlsdGVycyIsIGRlc2MgPT4gIlRvZ2dsZSBT VkcgRmlsdGVycyBzdXBwb3J0IiwKICAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0ZJTFRFUlMiLCBk ZWZhdWx0ID0+IChpc0FwcGxlV2ViS2l0KCkgfHwgaXNHdGsoKSB8fCBpc1F0KCkgfHwgaXNFZmwo KSB8fCBpc0JsYWNrQmVycnkoKSksIHZhbHVlID0+IFwkZmlsdGVyc1N1cHBvcnQgfSwKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRl eCA5ZThjYTc1Nzk2MTMyZjlkZGY2YjY0M2JkZGFhN2VjZGI0NWVmYmYxLi45OWRmMzM5ZmEyYTE5 YWI4ZWM0MjEzYTQyZTUwYTFiZGI1NWMxMjAwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTIt MDQtMDkgIENoYW5nU2VvayBPaCAgPHNoaXZhbWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtH VEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBbGwgdGVzdHMgaW4gZmFzdC9maWxlc3lzdGVtIGFyZSBw YXNzZWQgZXhjZXB0IHRoZSBvbmVzIHJlbGF0ZWQgd2l0aCB3b3JrZXIuCisgICAgICAgIEZvbGxv d2luZyB0ZXN0cyBhcmUgcGFzc2VkIGluIGRldGFpbC4KKyAgICAgICAgZmFzdC9maWxlc3lzdGVt LyouaHRtbAorICAgICAgICBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZl cnkuaHRtbAorICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmls ZS1ibG9iLmh0bWwKKyAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5k LWZpbGUtYmxvYi1mYWlsLmh0bWwKKworICAgICAgICAqIHBsYXRmb3JtL2d0ay9Ta2lwcGVkOgor CiAyMDEyLTA0LTA5ICBTaGlueWEgS2F3YW5ha2EgIDxzaGlueWFrQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBTaGFkb3dSb290IHNob3VsZCBoYXZlIHNlbGVjdGlvbiBhdHRyaWJ1dGUuCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZCBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL2d0ay9Ta2lwcGVkCmluZGV4IDZiMmY0YjI4NmM3MDFiNDk3Zjg0YjRmZWUxYmVhMjY1 NzM2ZTZlYjAuLjYyMDEzMjU1N2NhYTllNWNkODk0N2M4ZDVmYmRjZGU5OTRhNDA3NWYgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkCisrKyBiL0xheW91dFRlc3Rz L3BsYXRmb3JtL2d0ay9Ta2lwcGVkCkBAIC0yNzgsMTMgKzI3OCwxMyBAQCBodHRwL3Rlc3RzL21p c2Mvd2VidGltaW5nLXNsb3ctbG9hZC5waHAKIGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmctc3Ns LnBocAogaHR0cC90ZXN0cy9taXNjL3dlYnRpbWluZy10d28tcmVkaXJlY3RzLnBocAogCi0jIEZp bGVTeXN0ZW0gQVBJIGlzIG5vdCBzdXBwb3J0ZWQuCi1mYXN0L2ZpbGVzeXN0ZW0KKyMgRmlsZVN5 c3RlbSBBUEkgaXMgbm90IHN1cHBvcnRlZCBjb21wbGV0ZWx5LgorIyBXZSBkb24ndCBzdXBwb3J0 IHdvcmtlcnMgZm9yIEZpbGVTeXN0ZW0geWV0LiBodHRwOi8vd2Via2l0Lm9yZy9iLzgyODU0Citm YXN0L2ZpbGVzeXN0ZW0vd29ya2VycwogaHR0cC90ZXN0cy9maWxlc3lzdGVtCiBodHRwL3Rlc3Rz L3NlY3VyaXR5L2ZpbGVzeXN0ZW0taWZyYW1lLWZyb20tcmVtb3RlLmh0bWwKLWh0dHAvdGVzdHMv d2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2IuaHRtbAotaHR0cC90ZXN0cy93ZWJz b2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi1mYWlsLmh0bWwKIGh0dHAvdGVzdHMvd29y a2Vycy90ZXJtaW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0aW9uLmh0bWwKKyMgUGFzc2VkIGJ1dCB3 ZSBzaG91bGQgZW5hYmxlIGZpbGUtc3lzdGVtICYgbXV0YXRpb24tb2JzZXJ2ZXJzIGF0IHRoZSBz YW1lIHRpbWUuCiBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRt bAogCiAjIFJlcXVpcmVzIFdlYlAgc3VwcG9ydC4K 137858 2012-04-19 00:20:50 -0700 2012-04-19 00:35:55 -0700 Patch bug-58443-20120419162050.patch text/plain 73743 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTE0MzM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDZmZTMxOTA1ZmUxNjhiMTAzOGVlMDVj Nzg0ZWNkNjczOTYyMjQ4ZDguLjg3MDEzMmMyYWQ1ZmFjZmI4ZDk1M2JkOGIzOGU0Y2QxMWFmOGNl ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMTggIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDoKKwogMjAxMi0wNC0xNiAgTmljbyBXZWJlciAgPHRoYWtpc0Bj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgTWFrZSBOdWxsUHRyLmggY29tcGlsZSB3aXRoIGNsYW5n IC1zdGQ9YysrMTEgYW5kIGxpYnN0ZGMrKzQuMgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGQ2MDUzNGVhNmNkZWY0 ZmUzMTQ5NTYxNDUyODI4MjM3NjE4Y2U0YjcuLmM1MjA0NzU3N2RhYTM5MDc1OGIyMTVkMGM5YTJi MGJlNjI4ODhlYTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNDEgQEAKKzIwMTItMDQtMTggIENo YW5nU2VvayBPaCAgPHNoaXZhbWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBv cnQgdGhlIGZpbGUgc3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NTg0NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBUaGlzIHBhdGNoIGlzIGJhc2VkIG9uIFphbiBEb2JlcnNlaydzIG9yaWdp bmFsIG9uZSBmb3IgYnVnNTg0NDMuCisgICAgICAgIFRoaXMgYnJpbmdzIEZpbGVTeXN0ZW0gQVBJ IHRvIGd0ayBwb3J0LiBUaGlzIGFkZHMgbmV3IGludGVyZmFjZXMgbGlrZQorICAgICAgICBBc3lu Y0ZpbGVTeXN0ZW1HdGssIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0aywgQXN5bmNGaWxlV3Jp dGVyR3RrLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsKKyAgICAgICAgYW5kIEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrLiBUaGVzZSBhcmUgY2hpbGQgY2xhc3NlcyBpbXBsZW1lbnRp bmcgdGhlIGludGVyZmFjZXMKKyAgICAgICAgb2YgZWFjaCBwYXJlbnQgY2xhc3NlcyBleGNlcHQg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrCisgICAgICAgIGlzIGEgaGVscGVyIGNsYXNzLiBJdCByZXRhaW5zIHNvbWUgdXNl ZnVsIHZhcmlhYmxlcywgYW5kIGNvbnRyb2xzIHBvc3RpbmcgdGFza3MgdG8KKyAgICAgICAgU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCB3aGljaCBtaWdodCBiZSBlaXRoZXIgYSBEb2N1bWVudCBvYmpl Y3Qgb3IgYSBXb3JrZXIuCisgICAgICAgIFVuZm9ydHVuYXRlbHksIFdvcmtlciBmb3IgZmlsZXN5 c3RlbSBpcyBub3Qgc3VwcG9ydGVkIHlldCwgSSBwbGFuIHRvIHN1cHBvcnQgaXQgaW4gdGhlIG5l eHQgcGF0Y2guCisKKyAgICAgICAgVGVzdDogZmFzdC9maWxlc3lzdGVtLyouaHRtbAorICAgICAg ICAgICAgICBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRtbAor ICAgICAgICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1i bG9iLmh0bWwKKyAgICAgICAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9z ZW5kLWZpbGUtYmxvYi1mYWlsLmh0bWwKKworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06 IEFkZGVkIHNvbWUgZmlsZXMgdG8gYnVpbGQgbmV3bHkgZm9yIEZpbGVTeXN0ZW0uCisgICAgICAg ICogTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHA6IFdlIHNob3VsZCBub3Qg YnVpbGQgdGhpcyBmaWxlLiBzbyBhZGRlZCBlcnJvciBtZXNzYWdlLgorICAgICAgICAqIHBsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBh biBpbXBsZW1lbnRhdGlvbiBvZiBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuCisgICAgICAgIChX ZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6Ojo6Y29weSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayk6 CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkU3VjY2VlZCk6CisgICAg ICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZE9wZW5GaWxlU3lzdGVt KToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRSZWFkTWV0YWRhdGFDYWxsYmFjayk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWRNZXRh ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRp ZFJlYWREaXJlY3RvcnlFbnRyeSk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkUmVhZERp cmVjdG9yeUVudHJpZXNBbmRGaW5pc2hlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkUmVhZERpcmVjdG9yeUVudHJpZXMpOgorICAg ICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZENyZWF0ZUZpbGVX cml0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZEZhaWxDYWxsYmFjayk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZEZhaWwpOgorICAg ICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaDogQWRkZWQu CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 ayk6IEFkZGVkIHNvbWUgbWlzc2luZyBBUElzLiBUaGlzIGlzIGEgY2hpbGQgY2xhc3Mgb2YgQXN5 bmNGaWxlU3lzdGVtLgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrOjpEaXJlY3RvcnlFbnRyeTo6RGlyZWN0b3J5RW50cnkpOgorICAgICAgICAoRGlyZWN0b3J5 RW50cnkpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6dG9GaWxlRXJyb3JDb2RlKToKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6dmFsaWRhdGVGaWxlVHlwZSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVN5c3RlbTo6aXNWYWxpZFR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVt OjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06OmNy YWNrRmlsZVN5c3RlbVVSTCk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6 OkFzeW5jRmlsZVN5c3RlbUd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1H dGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lz dGVtR3RrOjp0b1VSTCk6CisgICAgICAgIChXZWJDb3JlOjptb3ZlQXN5bmMpOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjptb3ZlKToKKyAgICAgICAgKFdlYkNvcmU6OmNv cHlSZWN1cnNpdmVseSk6CisgICAgICAgIChXZWJDb3JlOjpjb3B5QXN5bmMpOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6OnJl bW92ZUZpbGVSZWN1cnNpdmVseSk6CisgICAgICAgIChXZWJDb3JlOjpyZW1vdmVBc3luYyk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZSk6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZVJlY3Vyc2l2ZWx5KToKKyAgICAgICAg KFdlYkNvcmU6OnJlYWRNZXRhZGF0YUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVN5c3RlbUd0azo6cmVhZE1ldGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZU9iamVj dEFuZFJlYWRNZXRhZGF0YUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3Rl bUd0azo6Y3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVjdG9yeSk6CisgICAgICAgIChXZWJDb3JlOjpvYmplY3RF eGlzdHNBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmZpbGVF eGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpkaXJlY3RvcnlF eGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6cmVhZERpcmVjdG9yeUFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZERpcmVjdG9yeSk6CisgICAgICAgIChX ZWJDb3JlOjpjcmVhdGVXcml0ZXJBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcik6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0 ZW1HdGs6OmNyZWF0ZVNuYXBzaG90RmlsZUFuZFJlYWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKToKKyAgICAgICAgKFdl YkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6dmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwpOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9D b21wbGV0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oOgor ICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAg ICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHA6IEFk ZGVkLiBUaGlzIGlzIGEgaGVscGVyIGNsYXNzIHRvIGNvbnRyb2wgcG9zdGluZyB0YXNrIHRvIGEg dGFyZ2V0IHRocmVhZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayk6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6dW5pcXVlTW9kZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdFRh c2tUb01haW5UaHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdENhbGxiYWNrVGFzayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6d2FpdEZvck9wZXJh dGlvblRvQ29tcGxldGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs6OmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KToKKyAgICAgICAgKiBwbGF0Zm9y bS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzeW5j aHJvbm91cyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0azo6c2V0V3JpdGVyVG9DYW5jZWwpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIGltcGxl bWVudCBvZiBBeXNuY0ZpbGVXcml0ZXJDbGllbnQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAg ICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRXcml0ZUNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6 OnBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1E aWRGYWlsQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRXcml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckNsaWVudEd0azo6ZGlkRmFpbCk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0Fz eW5jRmlsZVdyaXRlckNsaWVudEd0ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAg ICAgICAoQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVdyaXRlckNsaWVudEd0azo6dGFza0NvbnRyb2xsZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIG9m IEFzeW5jRmlsZVdyaXRlci4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl V3JpdGVyR3RrOjpBc3luY0ZpbGVXcml0ZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVB c3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OndyaXRlKToKKyAg ICAgICAgKFdlYkNvcmU6OnRydW5jYXRlQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlV3JpdGVyR3RrOjp0cnVuY2F0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0 ZXJHdGs6OmFib3J0KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckd0azo6d2Fp dEZvck9wZXJhdGlvblRvQ29tcGxldGUpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJHdGsuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5j RmlsZVdyaXRlckd0ayk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0 ay5jcHA6IEFkZGVkLiBQb3J0IHNwZWNpZmljIGltcGxlbWVudGF0aW9uIGZvciBMb2NhbEZpbGVT eXN0ZW0gY2xhc3MgaXMgaGVyZS4gV2Ugc2hvdWxkIHVzZSB0aGlzIGZpbGUgaW5zdGVhZCBvZiBM b2NhbEZpbGVTeXN0ZW0uY3BwCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6 OkxvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJD b3JlOjpMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCk6CisgICAgICAgIChXZWJD b3JlOjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06 OnJlYWRGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVx dWVzdEZpbGVTeXN0ZW0pOgorCiAyMDEyLTA0LTE2ICBUYWthc2hpIFNha2Ftb3RvICA8dGFzYWtA Z29vZ2xlLmNvbT4KIAogICAgICAgICBbU2hhZG93IERPTV0gSW5zZXJ0aW9uUG9pbnQgc2hvdWxk IGhhdmUgaXNBY3RpdmUoKSBtZW1iZXIgZnVuY3Rpb24uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRy LmNwcAppbmRleCBkZmUxODdkNzg4N2ZmNTRlYTAyN2MxYzlkYzVjMDZiZDdiZGI1Y2YxLi4zYWEw NzU5OTQ3NmQ3NGUyMmZkZjRlN2NkMGU4NTc3YTI4MTU5MmI0IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dvYmplY3Qv R093blB0ci5jcHAKQEAgLTQyLDYgKzQyLDE2IEBAIHRlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVk R1B0cjxHU0xpc3Q+KEdTTGlzdCogcHRyKQogICAgIGdfc2xpc3RfZnJlZShwdHIpOwogfQogCit0 ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1N0cmluZz4oR1N0cmluZyogcHRyKQorewor ICAgIGdfc3RyaW5nX2ZyZWUocHRyLCB0cnVlKTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBmcmVl T3duZWRHUHRyPEdPdXRwdXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qIHB0cikKK3sKKyAgICBnX291 dHB1dF9zdHJlYW1fY2xvc2UocHRyLCAwLCAwKTsKK30KKwogdGVtcGxhdGUgPD4gdm9pZCBmcmVl T3duZWRHUHRyPEdQYXR0ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKiBwdHIpCiB7CiAgICAgaWYgKHB0 cikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oIGIvU291cmNl L1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKaW5kZXggNGIyZGNiNzdiMjUwMDBjMmU1YjY4MDhh NGM3NDg0YzJiZTZkNmNhNS4uOWMwNjdkNzFhNjc5NTVjYzRiZjhkOGZjOGRkZjIwZDliMjJhMWM3 MSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKKysrIGIvU291 cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKQEAgLTM2LDYgKzM2LDggQEAgdGVtcGxhdGUg PHR5cGVuYW1lIFQ+IGlubGluZSB2b2lkIGZyZWVPd25lZEdQdHIoVCogcHRyKTsKIHRlbXBsYXRl PD4gdm9pZCBmcmVlT3duZWRHUHRyPEdFcnJvcj4oR0Vycm9yKik7CiB0ZW1wbGF0ZTw+IHZvaWQg ZnJlZU93bmVkR1B0cjxHTGlzdD4oR0xpc3QqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRH UHRyPEdTTGlzdD4oR1NMaXN0Kik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHU3Ry aW5nPihHU3RyaW5nKik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHT3V0cHV0U3Ry ZWFtPihHT3V0cHV0U3RyZWFtKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHUGF0 dGVyblNwZWM+KEdQYXR0ZXJuU3BlYyopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8 R0Rpcj4oR0RpciopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1RpbWVyPihHVGlt ZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmggYi9T b3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5oCmluZGV4IGUyOTI1MGJlZjJlZjRkNWU5 ZWJlNWMyYjA1MDM3M2JiYTg1NjRmOWEuLjdhNWU5ZjNjYTA3ZGE1NWU1NjhjNTcxZDRlNWJjOWY4 NTQ1ZWI1MjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmgK KysrIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaApAQCAtNDgsMTcgKzQ4LDIw IEBAIHR5cGVkZWYgc3RydWN0IF9HZGtFdmVudEV4cG9zZSBHZGtFdmVudEV4cG9zZTsKIHR5cGVk ZWYgc3RydWN0IF9HZGtQaXhidWYgR2RrUGl4YnVmOwogdHlwZWRlZiBzdHJ1Y3QgX0dFcnJvciBH RXJyb3I7CiB0eXBlZGVmIHN0cnVjdCBfR0ZpbGUgR0ZpbGU7Cit0eXBlZGVmIHN0cnVjdCBfR0Zp bGVJT1N0cmVhbSBHRmlsZUlPU3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dIYXNoVGFibGUgR0hh c2hUYWJsZTsKIHR5cGVkZWYgc3RydWN0IF9HSW5wdXRTdHJlYW0gR0lucHV0U3RyZWFtOwogdHlw ZWRlZiBzdHJ1Y3QgX0dMaXN0IEdMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluQ29udGV4dCBH TWFpbkNvbnRleHQ7CiB0eXBlZGVmIHN0cnVjdCBfR01haW5Mb29wIEdNYWluTG9vcDsKK3R5cGVk ZWYgc3RydWN0IF9HT3V0cHV0U3RyZWFtIEdPdXRwdXRTdHJlYW07CiB0eXBlZGVmIHN0cnVjdCBf R1BhdHRlcm5TcGVjIEdQYXR0ZXJuU3BlYzsKIHR5cGVkZWYgc3RydWN0IF9HUG9sbGFibGVPdXRw dXRTdHJlYW0gR1BvbGxhYmxlT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dTTGlzdCBH U0xpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfR1NvY2tldENsaWVudCBHU29ja2V0Q2xpZW50OwogdHlw ZWRlZiBzdHJ1Y3QgX0dTb2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25uZWN0aW9uOwogdHlwZWRl ZiBzdHJ1Y3QgX0dTb3VyY2UgR1NvdXJjZTsKK3R5cGVkZWYgc3RydWN0IF9HU3RyaW5nIEdTdHJp bmc7CiB0eXBlZGVmIHN0cnVjdCBfR1ZhcmlhbnQgR1ZhcmlhbnQ7CiB0eXBlZGVmIHVuaW9uIF9H ZGtFdmVudCBHZGtFdmVudDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIgR1RpbWVyOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3Jl L0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggNGJkNWRmZGE3YTMzYTRhOTYwYjc4MjU5MDQxZDkz MDlkNzdlZTJjYy4uOTQxNWM2YmRjZDkyYmY4YWY4NmQ4MWUzNjJjMmJiMzE1Y2YxMzYwYyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2Uv V2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0xMDI0LDcgKzEwMjQsNiBAQCB3ZWJjb3Jl X21vZHVsZXNfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L0ZpbGVXcml0ZXJDYWxsYmFjay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0 ZW0vRmlsZVdyaXRlclN5bmMuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0 ZW0vRmlsZVdyaXRlclN5bmMuaCBcCi0JU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L0xvY2FsRmlsZVN5c3RlbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3Rl bS9Mb2NhbEZpbGVTeXN0ZW0uaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L01ldGFkYXRhQ2FsbGJhY2suaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L01ldGFkYXRhLmggXApAQCAtNDY5Myw2ICs0NjkyLDcgQEAgd2ViY29yZWd0a19zb3VyY2VzICs9 IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR3RrVmVyc2lvbmluZy5oIFwKIAlTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuY3BwIFwKIAlTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuaCBcCisJU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAgXAogCVNvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbGl6ZWRTdHJpbmdzR3RrLmNwcCBcCiAJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL01haW5GcmFtZVNjcm9sbGJhckd0ay5jcHAgXAogCVNvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9NYWluRnJhbWVTY3JvbGxiYXJHdGsuaCBcCkBAIC00OTg3LDkg KzQ5ODcsMTkgQEAgZG9tX2JpbmRpbmdfaWRscyArPSBcCiAJJChXZWJDb3JlKS9Nb2R1bGVzL2Zp bGVzeXN0ZW0vTWV0YWRhdGFDYWxsYmFjay5pZGwgXAogCSQoV2ViQ29yZSkvTW9kdWxlcy9maWxl c3lzdGVtL1dvcmtlckNvbnRleHRGaWxlU3lzdGVtLmlkbAogCi13ZWJjb3JlZ3RrX3NvdXJjZXMg Kz0gXAord2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0Fz eW5jRmlsZVN5c3RlbUd0ay5oCisKK3dlYmNvcmVndGtfc291cmNlcyArPSBcCisJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAgXAorCVNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCBc CisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlV3JpdGVyR3RrLmgKIGVuZGlmICMgRU5EIEVOQUJMRV9GSUxFX1NZU1RFTQogCiAj IC0tLS0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9Mb2Nh bEZpbGVTeXN0ZW0uY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2Fs RmlsZVN5c3RlbS5jcHAKaW5kZXggOGYwMTY5ZWVhYmJhOTNmZjRmMTU2ZDdjMjM0N2I2YzBiMjdk NWJiYS4uNzNmMjE4YjRhMDM3MWQwMDRhMTRjYmEwMTgyNjFjOGIyZTQ5YzY2NCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5j cHAKQEAgLTMxLDggKzMxLDggQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJMb2Nh bEZpbGVTeXN0ZW0uaCIKIAotI2lmIFBMQVRGT1JNKENIUk9NSVVNKQotI2Vycm9yICJDaHJvbWl1 bSBzaG91bGQgbm90IGNvbXBpbGUgdGhpcyBmaWxlIGFuZCBpbnN0ZWFkIGRlZmluZSBpdHMgb3du IHZlcnNpb24gb2YgdGhlc2UgZmFjdG9yaWVzLiIKKyNpZiBQTEFURk9STShDSFJPTUlVTSkgfHwg UExBVEZPUk0oR1RLKQorI2Vycm9yICJDaHJvbWl1bSAmIFdlYktpdEdUSysgc2hvdWxkIG5vdCBj b21waWxlIHRoaXMgZmlsZSBhbmQgaW5zdGVhZCBkZWZpbmUgaXRzIG93biB2ZXJzaW9uIG9mIHRo ZXNlIGZhY3Rvcmllcy4iCiAjZW5kaWYKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGNhYzJkMDE2ZjVhMzEwYjk0MDZmY2ZiZjUyMTMy MmQ4YjhkOTM3YQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwCkBAIC0wLDAgKzEsMTU1IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29t PgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBM ZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor ICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkg b2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0 aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24s IE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQorCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxl V3JpdGVyLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVkZSAiRmlsZU1l dGFkYXRhLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5jbHVk ZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3RlbXBsYXRl PD4gc3RydWN0IENyb3NzVGhyZWFkQ29waWVyQmFzZTxmYWxzZSwgZmFsc2UsIEZpbGVNZXRhZGF0 YT4geworICAgIHR5cGVkZWYgRmlsZU1ldGFkYXRhIFR5cGU7CisgICAgc3RhdGljIEZpbGVNZXRh ZGF0YSBjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYpOworfTsKKworQ3Jvc3NUaHJlYWRDb3BpZXJC YXNlPGZhbHNlLCBmYWxzZSwgRmlsZU1ldGFkYXRhPjo6VHlwZSBDcm9zc1RocmVhZENvcGllckJh c2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0YWRhdGE+Ojpjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYg b3JpZ2luYWwpCit7CisgICAgRmlsZU1ldGFkYXRhIG1ldGFkYXRhOworICAgIG1ldGFkYXRhLm1v ZGlmaWNhdGlvblRpbWUgPSBvcmlnaW5hbC5tb2RpZmljYXRpb25UaW1lOworICAgIG1ldGFkYXRh Lmxlbmd0aCA9IG9yaWdpbmFsLmxlbmd0aDsKKyAgICBtZXRhZGF0YS50eXBlID0gb3JpZ2luYWwu dHlwZTsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBvcmlnaW5hbC5wbGF0Zm9ybVBhdGg7 CisgICAgcmV0dXJuIG1ldGFkYXRhOworfQorCitQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0az4gQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIo bmV3IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhjb250ZXh0LCBjYWxsYmFja3MsIHN5bmNo cm9ub3VzKSk7Cit9CisKK1Bhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICByZXR1cm4gYWRv cHRQdHIobmV3IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayh0YXNrQ29udHJvbGxlciwgY2Fs bGJhY2tzLCBtb2RlKSk7Cit9CisKKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5j aHJvbm91cykKKyAgICA6IG1fc3luY2hyb25vdXMoc3luY2hyb25vdXMpCisgICAgLCBtX3Rhc2tN b2RlKCIiKQorICAgICwgbV90YXNrQ29udHJvbGxlcihBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azo6Y3JlYXRlKGNvbnRleHQsIHN5bmNocm9ub3VzKSkKKyAgICAsIG1fY2FsbGJhY2tz KGNhbGxiYWNrcykKK3sKK30KKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRh c2tDb250cm9sbGVyLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJh Y2tzLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3N5bmNocm9ub3VzKGZhbHNlKQorICAg ICwgbV90YXNrTW9kZShtb2RlKQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxl cikKKyAgICAsIG1fY2FsbGJhY2tzKGNhbGxiYWNrcykKK3sKK30KKworc3RhdGljIHZvaWQgcGVy Zm9ybURpZFN1Y2NlZWRDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjYWxsYmFja3Mt PmRpZFN1Y2NlZWQoKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRp ZFN1Y2NlZWQoKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3Jl YXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrLCBtX2NhbGxiYWNrcy5y ZWxlYXNlKCkpLCBtX3Rhc2tNb2RlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZE9wZW5G aWxlU3lzdGVtQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbmFtZSwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgY2FsbGJhY2tzLT5k aWRPcGVuRmlsZVN5c3RlbShuYW1lLCBmaWxlU3lzdGVtKTsKK30KKwordm9pZCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgbmFtZSwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgQXN5bmNGaWxl U3lzdGVtR3RrKiBmaWxlU3lzdGVtR3RrID0gc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtR3Rr Kj4oZmlsZVN5c3RlbS5nZXQoKSk7CisKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xs ZXItPnVuaXF1ZU1vZGUoKTsKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRDdXJyZW50VGFza01v ZGUobW9kZSk7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVD YWxsYmFja1Rhc2soJnBlcmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNrLCBtX2NhbGxiYWNr cy5yZWxlYXNlKCksIG5hbWUsIGZpbGVTeXN0ZW0pLCBtb2RlKTsKKworICAgIGZpbGVTeXN0ZW1H dGstPnNldFRhc2tDb250cm9sbGVyKG1fdGFza0NvbnRyb2xsZXIucmVsZWFzZSgpKTsKKyAgICBm aWxlU3lzdGVtR3RrLT53YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworfQorCitzdGF0aWMg dm9pZCBwZXJmb3JtRGlkUmVhZE1ldGFkYXRhQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0 IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7CisgICAgY2FsbGJhY2tzLT5kaWRSZWFkTWV0YWRh dGEobWV0YWRhdGEpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlk UmVhZE1ldGFkYXRhKGNvbnN0IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7CisgICAgbV90YXNr Q29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1E aWRSZWFkTWV0YWRhdGFDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBtZXRhZGF0YSks IG1fdGFza01vZGUpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlk UmVhZERpcmVjdG9yeUVudHJ5KGNvbnN0IFN0cmluZyYgbmFtZSwgYm9vbCBpc0RpcmVjdG9yeSkK K3sKKyAgICBtX2RpcmVjdG9yeUVudHJpZXMuYXBwZW5kKERpcmVjdG9yeUVudHJ5KG5hbWUsIGlz RGlyZWN0b3J5KSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRSZWFkRGlyZWN0b3J5RW50 cmllc0FuZEZpbmlzaGVkQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25Q dHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY2FsbGJhY2tz LT5kaWRSZWFkRGlyZWN0b3J5RW50cmllcyhmYWxzZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cmllcyhib29sKQoreworICAgIGZv ciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9kaXJlY3RvcnlFbnRyaWVzLnNpemUoKTsgKytpKQorICAg ICAgICBtX2NhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeUVudHJ5KG1fZGlyZWN0b3J5RW50cmll c1tpXS5uYW1lLCBtX2RpcmVjdG9yeUVudHJpZXNbaV0uaXNEaXJlY3RvcnkpOworICAgIG1fZGly ZWN0b3J5RW50cmllcy5jbGVhcigpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxi YWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRSZWFkRGlyZWN0b3J5RW50cmll c0FuZEZpbmlzaGVkQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSksIG1fdGFza01vZGUp OworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBsb25nIGxv bmcgbGVuZ3RoKQoreworICAgIGNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcih3cml0ZXIs IGxlbmd0aCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRDcmVh dGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiB3cml0ZXIsIGxvbmcgbG9u ZyBsZW5ndGgpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVh dGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2ssIG1fY2Fs bGJhY2tzLnJlbGVhc2UoKSwgd3JpdGVyLCBsZW5ndGgpLCBtX3Rhc2tNb2RlKTsKK30KKworc3Rh dGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgaW50IGNvZGUp Cit7CisgICAgY2FsbGJhY2tzLT5kaWRGYWlsKGNvZGUpOworfQorCit2b2lkIEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0azo6ZGlkRmFpbChpbnQgY29kZSkKK3sKKyAgICBtX3Rhc2tDb250cm9s bGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZEZhaWxD YWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBjb2RlKSwgbV90YXNrTW9kZSk7Cit9CisK K30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44MzM3NDZkZDhjNTRjOGY4Mzc0M2QyMmUxODUx MTg4NzhjMTdmN2NjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oCkBAIC0wLDAgKzEsNzMgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+ CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExl c3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0a19oCisjZGVmaW5lIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisKKyNpZiBFTkFC TEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaW5jbHVk ZSA8d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBTY3Jp cHRFeGVjdXRpb25Db250ZXh0OworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsg OiBwdWJsaWMgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0ZShTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29s IHN5bmNocm9ub3VzID0gZmFsc2UpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJpbmcmIG1v ZGUpOworCisgICAgdmlydHVhbCB2b2lkIGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFsIHZvaWQg ZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbT4pOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1l dGFkYXRhJik7CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBT dHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFk RGlyZWN0b3J5RW50cmllcyhib29sIGhhc01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVh dGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiwgbG9uZyBsb25nIGxlbmd0 aCk7CisgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoaW50IGNvZGUpOworCitwcml2YXRlOgorICAg IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzKTsKKyAg ICBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmlu ZyYgbW9kZSk7CisKKyAgICBzdHJ1Y3QgRGlyZWN0b3J5RW50cnkgeworICAgICAgICBEaXJlY3Rv cnlFbnRyeShjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpCisgICAgICAgICAg ICA6IG5hbWUobmFtZSkKKyAgICAgICAgICAgICwgaXNEaXJlY3RvcnkoaXNEaXJlY3RvcnkpCisg ICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIFN0cmluZyBuYW1lOworICAgICAgICBib29s IGlzRGlyZWN0b3J5OworICAgIH07CisKKyAgICBib29sIG1fc3luY2hyb25vdXM7CisgICAgU3Ry aW5nIG1fdGFza01vZGU7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIE93blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IG1fY2FsbGJhY2tzOworICAgIFZlY3RvcjxEaXJlY3RvcnlFbnRyeT4gbV9kaXJlY3RvcnlF bnRyaWVzOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZ U1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc19oCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCmluZGV4IGMx ZGIwMDZhODQ4ZjM5MjZkZDlmZWMzMWY5NjRhMGZkYmRhZjY5ZmMuLjZkN2ZmZDNhZTA1Nzg1Nzc3 Y2MxYWU2MDY0MWFhMWU5MDc4YzM5NTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCkBAIC0xLDQgKzEsNSBAQAogLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAq IENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgog ICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKQEAgLTE4LDI3ICsxOSw3NCBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1HdGsuaCIKIAogI2lmIEVOQUJMRShGSUxFX1NZ U1RFTSkKIAotI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUd0ay5oIgotCi0jaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJHdGsuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRh c2suaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCi0jaW5jbHVkZSAiTm90SW1wbGVtZW50 ZWQuaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0u aCIKKyNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgor I2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3Ry aW5nLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKK3N0YXRpYyBGaWxlRXJyb3I6OkVycm9yQ29kZSB0b0ZpbGVFcnJvckNvZGUo R0Vycm9yKiBlcnJvcikKK3sKKyAgICBBU1NFUlQoZXJyb3IpOworCisgICAgRmlsZUVycm9yOjpF cnJvckNvZGUgZXJyb3JDb2RlOworICAgIHN3aXRjaCAoZXJyb3ItPmNvZGUpIHsKKyAgICBjYXNl IEdfSU9fRVJST1JfRVhJU1RTOgorICAgIGNhc2UgR19JT19FUlJPUl9OT1RfRU1QVFk6CisgICAg ICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSOworICAg ICAgICBicmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1JfSVNfRElSRUNUT1JZOgorICAgIGNhc2Ug R19JT19FUlJPUl9XT1VMRF9SRUNVUlNFOgorICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6 OlRZUEVfTUlTTUFUQ0hfRVJSOworICAgICAgICBicmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1Jf V09VTERfTUVSR0U6CisgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6UEFUSF9FWElTVFNf RVJSOworICAgICAgICBicmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAg IGRlZmF1bHQ6CisgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUjsK KyAgICB9CisgICAgcmV0dXJuIGVycm9yQ29kZTsKK30KKworc3RhdGljIEZpbGVFcnJvcjo6RXJy b3JDb2RlIHZhbGlkYXRlRmlsZVR5cGUoR0ZpbGUqIHNvdXJjZUZpbGUsIEdGaWxlKiBkZXN0aW5h dGlvbkZpbGUpCit7CisgICAgR0ZpbGVUeXBlIHNvdXJjZUZpbGVUeXBlID0gZ19maWxlX3F1ZXJ5 X2ZpbGVfdHlwZShzb3VyY2VGaWxlLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwKTsKKyAgICBH RmlsZVR5cGUgZGVzdGluYXRpb25GaWxlVHlwZSA9IGdfZmlsZV9xdWVyeV9maWxlX3R5cGUoZGVz dGluYXRpb25GaWxlLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwKTsKKyAgICBpZiAoZGVzdGlu YXRpb25GaWxlVHlwZSAhPSBHX0ZJTEVfVFlQRV9VTktOT1dOKSB7CisgICAgICAgIGlmIChzb3Vy Y2VGaWxlVHlwZSAhPSBkZXN0aW5hdGlvbkZpbGVUeXBlKSB7CisgICAgICAgICAgICAvLyBGSVhN RTogRmlsZUVycm9yOjpUWVBFX01JU01BVENIX0VSUj8gSWYgc28sIGZhaWxlZCBvbiBmYXN0L2Zp bGVzeXN0ZW0vb3AtbW92ZS5odG1sCisgICAgICAgICAgICByZXR1cm4gRmlsZUVycm9yOjpJTlZB TElEX01PRElGSUNBVElPTl9FUlI7CisgICAgICAgIH0KKyAgICAgICAgaWYgKGRlc3RpbmF0aW9u RmlsZVR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZICYmICFnX2ZpbGVfZGVsZXRlKGRlc3Rp bmF0aW9uRmlsZSwgMCwgMCkpIHsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBGaWxlRXJyb3I6OlBB VEhfRVhJU1RTX0VSUj8gSWYgc28sIGZhaWxlZCBvbiBmYXN0L2ZpbGVzeXN0ZW0vb3AtbW92ZS5o dG1sCisgICAgICAgICAgICByZXR1cm4gRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9F UlI7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIEZpbGVFcnJvcjo6T0s7Cit9CisKIGJv b2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKLSAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIGJvb2wgQXN5bmNG aWxlU3lzdGVtOjppc1ZhbGlkVHlwZShUeXBlIHR5cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKLSAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIHR5cGUgPT0gVGVtcG9yYXJ5IHx8IHR5 cGUgPT0gUGVyc2lzdGVudDsKIH0KIAogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5j RmlsZVN5c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkKQEAgLTQ4LDg3ICs5NiwzODIgQEAgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkK IAogdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFz ZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmFnZUlkZW50aWZpZXIsIFR5cGUgdHlwZSwgYm9vbCwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwotICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChOT1RfU1VQUE9SVEVEX0VS Uik7CisgICAgU3RyaW5nIHR5cGVTdHJpbmcgPSAodHlwZSA9PSBBc3luY0ZpbGVTeXN0ZW06OlBl cnNpc3RlbnQpID8gIlBlcnNpc3RlbnQiIDogIlRlbXBvcmFyeSI7CisgICAgU3RyaW5nIG5hbWUg PSBzdG9yYWdlSWRlbnRpZmllciArICI6IiArIHR5cGVTdHJpbmc7CisKKyAgICBjYWxsYmFja3Mt PmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHR5cGUpKTsK IH0KIAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVSTChjb25zdCBLVVJM JiB1cmwsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSYgdHlwZSwgU3RyaW5nJiBmaWxlUGF0aCkKIHsK LSAgICBub3RJbXBsZW1lbnRlZCgpOwogICAgIHJldHVybiBmYWxzZTsKIH0KIAogQXN5bmNGaWxl U3lzdGVtR3RrOjpBc3luY0ZpbGVTeXN0ZW1HdGsoQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUp CiAgICAgOiBBc3luY0ZpbGVTeXN0ZW0odHlwZSkKKyAgICAsIG1fbG9jYWxGaWxlU3lzdGVtQmFz ZVBhdGgoTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5maWxlU3lzdGVtQmFzZVBh dGgoKSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCiBBc3luY0ZpbGVTeXN0ZW1HdGs6 On5Bc3luY0ZpbGVTeXN0ZW1HdGsoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIFN0 cmluZyBBc3luY0ZpbGVTeXN0ZW1HdGs6OnRvVVJMKGNvbnN0IFN0cmluZyYgb3JpZ2luU3RyaW5n LCBjb25zdCBTdHJpbmcmIGZ1bGxQYXRoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAg cmV0dXJuIFN0cmluZygpOworICAgIEFTU0VSVCghb3JpZ2luU3RyaW5nLmlzRW1wdHkoKSk7Cisg ICAgaWYgKG9yaWdpblN0cmluZyA9PSBTdHJpbmcoIm51bGwiKSkKKyAgICAgICAgcmV0dXJuIFN0 cmluZygpOworCisgICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7CisgICAgcmVzdWx0LmFwcGVuZCgi ZmlsZXN5c3RlbToiKTsKKyAgICByZXN1bHQuYXBwZW5kKG9yaWdpblN0cmluZyk7CisgICAgcmVz dWx0LmFwcGVuZCgiLyIpOworICAgIGlmICh0eXBlKCkgPT0gVGVtcG9yYXJ5KQorICAgICAgICBy ZXN1bHQuYXBwZW5kKHRlbXBvcmFyeVBhdGhQcmVmaXgpOworICAgIGVsc2UgaWYgKHR5cGUoKSA9 PSBQZXJzaXN0ZW50KQorICAgICAgICByZXN1bHQuYXBwZW5kKHBlcnNpc3RlbnRQYXRoUHJlZml4 KTsKKyAgICBlbHNlIHsKKyAgICAgICAgQVNTRVJUKHR5cGUoKSA9PSBUZW1wb3JhcnkgfHwgdHlw ZSgpID09IFBlcnNpc3RlbnQpOworICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisgICAgfQorCisg ICAgcmVzdWx0LmFwcGVuZChlbmNvZGVXaXRoVVJMRXNjYXBlU2VxdWVuY2VzKGZ1bGxQYXRoKSk7 CisKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK3N0YXRpYyB2b2lkIG1vdmVB c3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBzcmNQYXRoLCBTdHJpbmcmIGRl c3RQYXRoKQoreworICAgIEdSZWZQdHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19m aWxlX25ld19mb3JfcGF0aChzcmNQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdG aWxlPiBkZXN0aW5hdGlvbkZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0 UGF0aC51dGY4KCkuZGF0YSgpKSk7CisKKyAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNv ZGUgPSB2YWxpZGF0ZUZpbGVUeXBlKHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5n ZXQoKSk7CisgICAgaWYgKGVycm9yQ29kZSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRp ZEZhaWwoZXJyb3JDb2RlKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8 R0Vycm9yPiBlcnJvcjsKKyAgICBnX2ZpbGVfbW92ZShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5h dGlvbkZpbGUuZ2V0KCksIEdfRklMRV9DT1BZX09WRVJXUklURSwgMCwgMCwgMCwgJmVycm9yLm91 dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRG YWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CiB9CiAKIHZvaWQgQXN5bmNG aWxlU3lzdGVtR3RrOjptb3ZlKGNvbnN0IFN0cmluZyYgc291cmNlUGF0aCwgY29uc3QgU3RyaW5n JiBkZXN0aW5hdGlvblBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBj YWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgc291cmNlRmls ZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChzb3VyY2VQYXRoKTsKKyAg ICBTdHJpbmcgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lz dGVtVVJMKGRlc3RpbmF0aW9uUGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9s bGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFp blRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm1vdmVBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2Rl KSwgc291cmNlRmlsZVN5c3RlbVBhdGgsIGRlc3RpbmF0aW9uRmlsZVN5c3RlbVBhdGgpKTsKK30K Kworc3RhdGljIHZvaWQgY29weVJlY3Vyc2l2ZWx5KEdGaWxlKiBzb3VyY2VEaXJlY3RvcnksIEdG aWxlKiBkZXN0aW5hdGlvbkRpcmVjdG9yeSwgR0Vycm9yKiogZXJyb3IpCit7CisgICAgQVNTRVJU KGdfZmlsZV9xdWVyeV9maWxlX3R5cGUoc291cmNlRGlyZWN0b3J5LCBHX0ZJTEVfUVVFUllfSU5G T19OT05FLCAwKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpOworCisgICAgaWYgKCFnX2ZpbGVf bWFrZV9kaXJlY3RvcnkoZGVzdGluYXRpb25EaXJlY3RvcnksIDAsIGVycm9yKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgR1JlZlB0cjxHRmlsZUVudW1lcmF0b3I+IGZpbGVFbnVtZXJhdG9yID0g YWRvcHRHUmVmKGdfZmlsZV9lbnVtZXJhdGVfY2hpbGRyZW4oc291cmNlRGlyZWN0b3J5LCBHX0ZJ TEVfQVRUUklCVVRFX1NUQU5EQVJEX05BTUUsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIGVy cm9yKSk7CisgICAgaWYgKCplcnJvcikKKyAgICAgICAgcmV0dXJuOworCisgICAgd2hpbGUgKEdS ZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfZW51bWVyYXRvcl9u ZXh0X2ZpbGUoZmlsZUVudW1lcmF0b3IuZ2V0KCksIDAsIGVycm9yKSkpIHsKKyAgICAgICAgY29u c3QgY2hhciogZGlyZWN0b3J5RW50cnlOYW1lID0gZ19maWxlX2luZm9fZ2V0X25hbWUoZmlsZUlu Zm8uZ2V0KCkpOworICAgICAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxlID0gYWRvcHRHUmVm KGdfZmlsZV9nZXRfY2hpbGQoc291cmNlRGlyZWN0b3J5LCBkaXJlY3RvcnlFbnRyeU5hbWUpKTsK KyAgICAgICAgR1JlZlB0cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmls ZV9nZXRfY2hpbGQoZGVzdGluYXRpb25EaXJlY3RvcnksIGRpcmVjdG9yeUVudHJ5TmFtZSkpOwor CisgICAgICAgIGlmIChnX2ZpbGVfcXVlcnlfZmlsZV90eXBlKHNvdXJjZUZpbGUuZ2V0KCksIEdf RklMRV9RVUVSWV9JTkZPX05PTkUsIDApID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkKKyAgICAg ICAgICAgIGNvcHlSZWN1cnNpdmVseShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUu Z2V0KCksIGVycm9yKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgZ19maWxlX2NvcHkoc291 cmNlRmlsZS5nZXQoKSwgZGVzdGluYXRpb25GaWxlLmdldCgpLCBHX0ZJTEVfQ09QWV9OT05FLCAw LCAwLCAwLCBlcnJvcik7CisKKyAgICAgICAgaWYgKCplcnJvcikKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlBc3luYyhTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxi YWNrcywgU3RyaW5nJiBzb3VyY2VQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQoreworICAgIEdSZWZQ dHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChzb3Vy Y2VQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBkZXN0aW5hdGlvbkZp bGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51dGY4KCkuZGF0YSgp KSk7CisKKyAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNvZGUgPSB2YWxpZGF0ZUZpbGVU eXBlKHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSk7CisgICAgaWYgKGVy cm9yQ29kZSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3JDb2RlKTsK KyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAg ICBpZiAoZ19maWxlX3F1ZXJ5X2ZpbGVfdHlwZShzb3VyY2VGaWxlLmdldCgpLCBHX0ZJTEVfUVVF UllfSU5GT19OT05FLCAwKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpIHsKKyAgICAgICAgY29w eVJlY3Vyc2l2ZWx5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgJmVy cm9yLm91dFB0cigpKTsKKyAgICAgICAgaWYgKGVycm9yKQorICAgICAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICBl bHNlCisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIGdfZmlsZV9jb3B5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3Rp bmF0aW9uRmlsZS5nZXQoKSwgR19GSUxFX0NPUFlfT1ZFUldSSVRFLCAwLCAwLCAwLCAmZXJyb3Iu b3V0UHRyKCkpOworICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRp ZEZhaWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3lu Y0ZpbGVTeXN0ZW1HdGs6OmNvcHkoY29uc3QgU3RyaW5nJiBzb3VyY2VQYXRoLCBjb25zdCBTdHJp bmcmIGRlc3RpbmF0aW9uUGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBzb3VyY2VG aWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHNvdXJjZVBhdGgpOwor ICAgIFN0cmluZyBkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVT eXN0ZW1VUkwoZGVzdGluYXRpb25QYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRy b2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9N YWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY29weUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1v ZGUpLCBzb3VyY2VGaWxlU3lzdGVtUGF0aCwgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCkpOwor fQorCitzdGF0aWMgdm9pZCByZW1vdmVGaWxlUmVjdXJzaXZlbHkoR0ZpbGUqIGZpbGUsIGJvb2wg cmVjdXJzaXZlLCBHRXJyb3IqKiBlcnJvcikKK3sKKyAgICBHT3duUHRyPGdjaGFyPiBmaWxlUGF0 aChnX2ZpbGVfZ2V0X3BhdGgoZmlsZSkpOworICAgIGlmIChyZWN1cnNpdmUgJiYgZ19maWxlX3Rl c3QoZmlsZVBhdGguZ2V0KCksIEdfRklMRV9URVNUX0lTX0RJUikpIHsKKyAgICAgICAgR1JlZlB0 cjxHRmlsZUVudW1lcmF0b3I+IGZpbGVFbnVtZXJhdG9yID0gYWRvcHRHUmVmKGdfZmlsZV9lbnVt ZXJhdGVfY2hpbGRyZW4oZmlsZSwgR19GSUxFX0FUVFJJQlVURV9TVEFOREFSRF9OQU1FLCBHX0ZJ TEVfUVVFUllfSU5GT19OT05FLCAwLCBlcnJvcikpOworICAgICAgICBpZiAoKmVycm9yKQorICAg ICAgICAgICAgcmV0dXJuOworCisgICAgICAgIHdoaWxlIChHUmVmUHRyPEdGaWxlSW5mbz4gZmls ZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX2VudW1lcmF0b3JfbmV4dF9maWxlKGZpbGVFbnVtZXJh dG9yLmdldCgpLCAwLCBlcnJvcikpKSB7CisgICAgICAgICAgICBHUmVmUHRyPEdGaWxlPiBjaGls ZCA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0X2NoaWxkKGZpbGUsIGdfZmlsZV9pbmZvX2dldF9uYW1l KGZpbGVJbmZvLmdldCgpKSkpOworICAgICAgICAgICAgcmVtb3ZlRmlsZVJlY3Vyc2l2ZWx5KGNo aWxkLmdldCgpLCByZWN1cnNpdmUsIGVycm9yKTsKKyAgICAgICAgICAgIGlmICgqZXJyb3IpCisg ICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgZ19maWxlX2Rl bGV0ZShmaWxlLCAwLCBlcnJvcik7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92ZUFzeW5jKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGZpbGVQYXRoLCBib29sIHJlY3Vyc2l2ZSkKK3sK KyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0cjxHRmlsZT4gZmlsZSA9IGFk b3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAg ICByZW1vdmVGaWxlUmVjdXJzaXZlbHkoZmlsZS5nZXQoKSwgcmVjdXJzaXZlLCAmZXJyb3Iub3V0 UHRyKCkpOworICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZh aWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0Zp bGVTeXN0ZW1HdGs6OnJlbW92ZShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsK KyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChw YXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsK KworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxi YWNrVGFzaygmcmVtb3ZlQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRl KG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRo LCBmYWxzZSkpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVjdXJzaXZl bHkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVT eXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5n IG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250 cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlbW92ZUFz eW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVy LmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgdHJ1ZSkpOworfQorCitz dGF0aWMgdm9pZCByZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3Ry aW5nJiBmaWxlUGF0aCkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0 cjxHRmlsZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0 ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdS ZWYoZ19maWxlX3F1ZXJ5X2luZm8oZmlsZS5nZXQoKSwgInN0YW5kYXJkOjoqLHRpbWU6OioiLCBH X0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJy b3IpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShl cnJvci5nZXQoKSkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgRmlsZU1ldGFkYXRh OjpUeXBlIHR5cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgpKSA9 PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkgPyBGaWxlTWV0YWRhdGE6OlR5cGVEaXJlY3RvcnkgOiBG aWxlTWV0YWRhdGE6OlR5cGVGaWxlOworCisgICAgR1RpbWVWYWwgdGltZVZhbHVlOworICAgIGdf ZmlsZV9pbmZvX2dldF9tb2RpZmljYXRpb25fdGltZShmaWxlSW5mby5nZXQoKSwgJnRpbWVWYWx1 ZSk7CisKKyAgICBHT3duUHRyPGdjaGFyPiBwYXRoKGdfZmlsZV9nZXRfcGF0aChmaWxlLmdldCgp KSk7CisKKyAgICBGaWxlTWV0YWRhdGEgbWV0YWRhdGE7CisgICAgbWV0YWRhdGEudHlwZSA9IHR5 cGU7CisgICAgbWV0YWRhdGEubW9kaWZpY2F0aW9uVGltZSA9IHN0YXRpY19jYXN0PGRvdWJsZT4o dGltZVZhbHVlLnR2X3NlYyk7CisgICAgbWV0YWRhdGEubGVuZ3RoID0gdHlwZSA9PSBGaWxlTWV0 YWRhdGE6OlR5cGVGaWxlID8gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRf c2l6ZShmaWxlSW5mby5nZXQoKSkpIDogMDsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBT dHJpbmcocGF0aC5nZXQoKSk7CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFJlYWRNZXRhZGF0 YShtZXRhZGF0YSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFkTWV0YWRhdGEo Y29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4g Y2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0 ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1v ZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9s bGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlYWRNZXRhZGF0 YUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9s bGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCkpOwogfQogCi12b2lk IEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZShjb25zdCBTdHJpbmcmIHBhdGgsIGJvb2wg ZXhjbHVzaXZlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tz KQorc3RhdGljIHZvaWQgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhQXN5bmMoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBsb2NhbEZpbGVTeXN0ZW1QYXRoLCBTdHJp bmcmIGFic29sdXRlUGF0aCwgR0ZpbGVUeXBlIHR5cGUsIGJvb2wgbmVlZFRvUmVhZE1ldGFkYXRh KQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgQVNTRVJUKHR5cGUgPT0gR19GSUxFX1RZ UEVfUkVHVUxBUiB8fCB0eXBlID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSk7CisgICAgLy8gV2Ug c2hvdWxkIG5vdCBhbGxvdyB0byBhY2Nlc3MgdXBwZXIgZGlyZWN0b3J5IHRvIGNyZWF0ZSBhIG5l dyBmaWxlIHRoYW4gYmFzZSBkaXJlY3RvcnkKKyAgICAvLyBiZWNhdXNlIG9mIHRoZSBzZWN1cml0 eSBpc3N1ZS4KKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSICYmIGFic29sdXRl UGF0aCA9PSBTdHJpbmcoIi8iKSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwo RmlsZUVycm9yOjpTRUNVUklUWV9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg R093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdS ZWYoZ19maWxlX25ld19mb3JfcGF0aChsb2NhbEZpbGVTeXN0ZW1QYXRoLnV0ZjgoKS5kYXRhKCkp KTsKKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSKQorICAgICAgICBHUmVmUHRy PEdGaWxlT3V0cHV0U3RyZWFtPiBvdXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX2NyZWF0 ZShmaWxlLmdldCgpLCBHX0ZJTEVfQ1JFQVRFX05PTkUsIDAsICZlcnJvci5vdXRQdHIoKSkpOwor ICAgIGlmICh0eXBlID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkKKyAgICAgICAgZ19maWxlX21h a2VfZGlyZWN0b3J5KGZpbGUuZ2V0KCksIDAsICZlcnJvci5vdXRQdHIoKSk7CisgICAgaWYgKGVy cm9yKSB7CisgICAgICAgIGlmICghbmVlZFRvUmVhZE1ldGFkYXRhIHx8IGVycm9yLT5jb2RlICE9 IEdfSU9fRVJST1JfRVhJU1RTKSB7CisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZh aWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAobmVlZFRvUmVhZE1ldGFkYXRhKSB7CisgICAgICAg IHJlYWRNZXRhZGF0YUFzeW5jKGNvbnRleHQsIGhlbHBlckNhbGxiYWNrcywgbG9jYWxGaWxlU3lz dGVtUGF0aCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaGVscGVyQ2FsbGJhY2tzLT5k aWRTdWNjZWVkKCk7CiB9CiAKLXZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3Rv cnkoY29uc3QgU3RyaW5nJiBwYXRoLCBib29sIGV4Y2x1c2l2ZSwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpj cmVhdGVPYmplY3RBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIFBh c3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIEdGaWxlVHlwZSB0 eXBlLCBib29sIG5lZWRUb1JlYWRNZXRhZGF0YSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwor ICAgIFN0cmluZyBsb2NhbEZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1V UkwoYWJzb2x1dGVQYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVu aXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFk KGNyZWF0ZUNhbGxiYWNrVGFzaygmY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhQXN5bmMsIEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCks IGNhbGxiYWNrcywgbW9kZSksIGxvY2FsRmlsZVN5c3RlbVBhdGgsIGFic29sdXRlUGF0aCwgdHlw ZSwgbmVlZFRvUmVhZE1ldGFkYXRhKSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpj cmVhdGVGaWxlKGNvbnN0IFN0cmluZyYgYWJzb2x1dGVQYXRoLCBib29sIGV4Y2x1c2l2ZSwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjcmVh dGVPYmplY3RBbmRSZWFkTWV0YWRhdGEoYWJzb2x1dGVQYXRoLCBjYWxsYmFja3MsIEdfRklMRV9U WVBFX1JFR1VMQVIpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGlyZWN0 b3J5KGNvbnN0IFN0cmluZyYgYWJzb2x1dGVQYXRoLCBib29sIGV4Y2x1c2l2ZSwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjcmVhdGVPYmpl Y3RBbmRSZWFkTWV0YWRhdGEoYWJzb2x1dGVQYXRoLCBjYWxsYmFja3MsIEdfRklMRV9UWVBFX0RJ UkVDVE9SWSk7Cit9CisKK3N0YXRpYyB2b2lkIG9iamVjdEV4aXN0c0FzeW5jKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVs cGVyQ2FsbGJhY2tzLCBTdHJpbmcmIHBhdGgsIEdGaWxlVHlwZSB0eXBlKQoreworICAgIEdSZWZQ dHI8R0ZpbGU+IG9iamVjdCA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHBhdGgudXRm OCgpLmRhdGEoKSkpOworICAgIEdGaWxlVHlwZSBvYmplY3RUeXBlID0gZ19maWxlX3F1ZXJ5X2Zp bGVfdHlwZShvYmplY3QuZ2V0KCksIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDApOworICAgIGlm IChvYmplY3RUeXBlID09IEdfRklMRV9UWVBFX1VOS05PV04pIHsKKyAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisgICAgaWYgKG9iamVjdFR5cGUgIT0gdHlwZSkgeworICAgICAgICBoZWxwZXJD YWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpUWVBFX01JU01BVENIX0VSUik7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0K IAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmZpbGVFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRo LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAg IG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBh dGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9s bGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFp blRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9iamVjdEV4aXN0c0FzeW5jLCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFj a3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgR19GSUxFX1RZUEVfUkVHVUxBUikpOwogfQogCiB2 b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6ZGlyZWN0b3J5RXhpc3RzKGNvbnN0IFN0cmluZyYgcGF0 aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAg ICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQ YXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJv bGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01h aW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvYmplY3RFeGlzdHNBc3luYywgQXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJh Y2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgsIEdfRklMRV9UWVBFX0RJUkVDVE9SWSkpOworfQor CitzdGF0aWMgdm9pZCByZWFkRGlyZWN0b3J5QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCos IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBjYWxsYmFja3MsIFN0cmlu ZyYgcGF0aCkKK3sKKyAgICBBU1NFUlQoZ19maWxlX3Rlc3QocGF0aC51dGY4KCkuZGF0YSgpLCBH X0ZJTEVfVEVTVF9JU19ESVIpKTsKKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBH UmVmUHRyPEdGaWxlPiBkaXJlY3RvcnkgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChw YXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlRW51bWVyYXRvcj4gZmlsZUVu dW1lcmF0b3IgPSBhZG9wdEdSZWYoZ19maWxlX2VudW1lcmF0ZV9jaGlsZHJlbihkaXJlY3Rvcnku Z2V0KCksIEdfRklMRV9BVFRSSUJVVEVfU1RBTkRBUkRfTkFNRSwgR19GSUxFX1FVRVJZX0lORk9f Tk9ORSwgMCwgJmVycm9yLm91dFB0cigpKSk7CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGNh bGxiYWNrcy0+ZGlkRmFpbCh0b0ZpbGVFcnJvckNvZGUoZXJyb3IuZ2V0KCkpKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIHdoaWxlIChHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8g PSBhZG9wdEdSZWYoZ19maWxlX2VudW1lcmF0b3JfbmV4dF9maWxlKGZpbGVFbnVtZXJhdG9yLmdl dCgpLCAwLCAmZXJyb3Iub3V0UHRyKCkpKSkgeworICAgICAgICBTdHJpbmcgbmFtZShnX2ZpbGVf aW5mb19nZXRfbmFtZShmaWxlSW5mby5nZXQoKSkpOworICAgICAgICBib29sIGlzRGlyZWN0b3J5 ID0gZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShmaWxlSW5mby5nZXQoKSkgPT0gR19GSUxFX1RZ UEVfRElSRUNUT1JZOworICAgICAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3RvcnlFbnRyeShu YW1lLCBpc0RpcmVjdG9yeSk7CisgICAgfQorICAgIGlmIChlcnJvcikKKyAgICAgICAgY2FsbGJh Y2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworCisgICAgY2FsbGJh Y2tzLT5kaWRSZWFkRGlyZWN0b3J5RW50cmllcyhmYWxzZSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxl U3lzdGVtR3RrOjpyZWFkRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVt VVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9k ZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRl Q2FsbGJhY2tUYXNrKCZyZWFkRGlyZWN0b3J5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZp bGVTeXN0ZW1QYXRoKSk7CiB9CiAKK3N0YXRpYyB2b2lkIGNyZWF0ZVdyaXRlckFzeW5jKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 az4gaGVscGVyQ2FsbGJhY2tzLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBTdHJpbmcmIHBhdGgp Cit7CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUg PSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChwYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAg ICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2lu Zm8oZmlsZS5nZXQoKSwgR19GSUxFX0FUVFJJQlVURV9TVEFOREFSRF9TSVpFLCBHX0ZJTEVfUVVF UllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAg ICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQo KSkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgbG9uZyBsb25nIGZpbGVTaXplID0g c3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5nZXQo KSkpOworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcihBc3luY0ZpbGVX cml0ZXJHdGs6OmNyZWF0ZShjbGllbnQsIHRhc2tDb250cm9sbGVyLCBmaWxlLmxlYWtSZWYoKSks IGZpbGVTaXplKTsKK30KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcihB c3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxl bWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVT eXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlx dWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJmNyZWF0ZVdyaXRlckFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUp LCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKGNsaWVudCksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3Mo bV90YXNrQ29udHJvbGxlci5nZXQoKSksIGZpbGVTeXN0ZW1QYXRoKSk7Cit9CisKK3ZvaWQgQXN5 bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3Qg U3RyaW5nJiBhYnNvbHV0ZVBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjYWxsYmFja3MpCit7CisgICAgU3RyaW5nIGxvY2FsRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFs UGF0aFRvRmlsZVN5c3RlbVVSTChhYnNvbHV0ZVBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90 YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9z dFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZjcmVhdGVPYmplY3RBbmRSZWFk TWV0YWRhdGFBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNr Q29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgbG9jYWxGaWxlU3lzdGVtUGF0aCwg YWJzb2x1dGVQYXRoLCBHX0ZJTEVfVFlQRV9SRUdVTEFSLCB0cnVlKSk7Cit9CisKK3ZvaWQgQXN5 bmNGaWxlU3lzdGVtR3RrOjpzZXRUYXNrQ29udHJvbGxlcihQYXNzUmVmUHRyPEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrPiB0YXNrQ29udHJvbGxlcikKK3sKKyAgICBtX3Rhc2tDb250 cm9sbGVyID0gdGFza0NvbnRyb2xsZXI7Cit9CisKK1N0cmluZyBBc3luY0ZpbGVTeXN0ZW1HdGs6 OnZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGNvbnN0IFN0cmluZyYgdmlydHVhbFBhdGgpCit7 CisgICAgcmV0dXJuIHZpcnR1YWxQYXRoICE9IFN0cmluZygiLyIpID8gbV9sb2NhbEZpbGVTeXN0 ZW1CYXNlUGF0aCArIHZpcnR1YWxQYXRoIDogbV9sb2NhbEZpbGVTeXN0ZW1CYXNlUGF0aDsKK30K KworYm9vbCBBc3luY0ZpbGVTeXN0ZW1HdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkK K3sKKyAgICByZXR1cm4gbV90YXNrQ29udHJvbGxlci0+d2FpdEZvck9wZXJhdGlvblRvQ29tcGxl dGUoKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oCmluZGV4IGNiNDViNmVhNGJjMjAyMGU4 ZWI0YzhlYjVhMTk4ZjA3NmY1YTY5N2IuLmQ5MTk0NDM1ZDA5Y2U3NDI1ZDQzODQxZTFhY2IzMzIz YzAyZTAzMGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1HdGsuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxl U3lzdGVtR3RrLmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDEyIENo YW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTEg WmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CiAgKgogICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwpA QCAtMjMsMTEgKzIzLDEzIEBACiAjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQogCiAjaW5jbHVkZSAi QXN5bmNGaWxlU3lzdGVtLmgiCisjaW5jbHVkZSA8Z2lvL2dpby5oPgogI2luY2x1ZGUgPHd0Zi9Q YXNzT3duUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzOworY2xhc3MgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs7CiAK IGNsYXNzIEFzeW5jRmlsZVN5c3RlbUd0ayA6IHB1YmxpYyBBc3luY0ZpbGVTeXN0ZW0gewogcHVi bGljOgpAQCAtNDYsNiArNDgsMTYgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBkaXJlY3Rv cnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4pOwogICAgIHZpcnR1YWwgdm9pZCByZWFkRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYg cGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKICAgICB2aXJ0dWFs IHZvaWQgY3JlYXRlV3JpdGVyKEFzeW5jRmlsZVdyaXRlckNsaWVudCosIGNvbnN0IFN0cmluZyYg cGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKKyAgICB2aXJ0dWFs IHZvaWQgY3JlYXRlU25hcHNob3RGaWxlQW5kUmVhZE1ldGFkYXRhKGNvbnN0IFN0cmluZyYgcGF0 aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+KTsKKyAgICB2aXJ0dWFsIGJv b2wgd2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKTsKKworICAgIHZvaWQgc2V0VGFza0NvbnRy b2xsZXIoUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4pOworcHJp dmF0ZToKKyAgICB2b2lkIGNyZWF0ZU9iamVjdEFuZFJlYWRNZXRhZGF0YShjb25zdCBTdHJpbmcm IGFic29sdXRlUGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBHRmls ZVR5cGUsIGJvb2wgbmVlZFRvUmVhZE1ldGFkYXRhID0gZmFsc2UpOworICAgIFN0cmluZyB2aXJ0 dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChjb25zdCBTdHJpbmcmKTsKKworICAgIFN0cmluZyBtX2xv Y2FsRmlsZVN5c3RlbUJhc2VQYXRoOworICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0az4gbV90YXNrQ29udHJvbGxlcjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU4YTY5MDVjOTJk ZWVmYjMwOTUzYjA1Y2RlOGI1NGU3NmY5NzAxZjAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3Bw CkBAIC0wLDAgKzEsOTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2Vr IDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBh cyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2 ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3Vs ZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwor ICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUg RnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBG aWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaW5jbHVk ZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsu aCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitQ YXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0azo6Y3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRl eHQsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBBc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayhjb250ZXh0LCBzeW5jaHJvbm91cykpOworfQorCitB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9vbCBzeW5jaHJvbm91 cykKKyAgICA6IG1fY29udGV4dChjb250ZXh0KQorICAgICwgbV9zeW5jaHJvbm91cyhzeW5jaHJv bm91cykKKyAgICAsIG1fY3VycmVudFRhc2tNb2RlKCIiKQorICAgICwgbV93cml0ZXJUb0NhbmNl bCgwKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdva2VycyBmb3IgZmlsZXN5 c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKK30KKworQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0aygpCit7Cit9CisKK1N0cmluZyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 azo6dW5pcXVlTW9kZSgpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJz IGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkp OworICAgIHJldHVybiBTdHJpbmcoKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0azo6cG9zdFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPiB0YXNrKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0 IHdva2VycyBmb3IgZmlsZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1 bWVudCgpKTsKKyAgICBtX2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCit2b2lkIEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzZXRDdXJyZW50VGFza01vZGUoY29uc3QgU3Ry aW5nJiB0YXNrTW9kZSkKK3sKKyAgICBtX2N1cnJlbnRUYXNrTW9kZSA9IHRhc2tNb2RlOworfQor Cit2b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpwb3N0Q2FsbGJhY2tUYXNr KFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4gdGFzaywgY29uc3QgU3Ry aW5nJiBtb2RlKQoreworICAgIC8vIEZJWE1FOiBXZSBkb24ndCBzdXBwb3J0IHdva2VycyBmb3Ig ZmlsZXN5c3RlbSB5ZXQuCisgICAgQVNTRVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKKyAg ICBtX2NvbnRleHQtPnBvc3RUYXNrKHRhc2spOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRh c2tDb250cm9sbGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgQVNT RVJUKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKTsKKyAgICBBU1NFUlQoIW1fc3luY2hyb25vdXMp OworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azo6Y2FuY2VsV3JpdGVySWZOZWNlc3NhcnkoQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0 ZXIpCit7CisgICAgaWYgKG1fd3JpdGVyVG9DYW5jZWwgPT0gd3JpdGVyKSB7CisgICAgICAgIG1f d3JpdGVyVG9DYW5jZWwgPSAwOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0 dXJuIGZhbHNlOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFC TEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNi ZjJkOTlkMmUyY2JlNzBiMDhkNWJkMzA5NzVhY2U4ZjA3OTdhNmMKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsuaApAQCAtMCwwICsxLDY0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBE b2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExp Y2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl cgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElU WSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBM ZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlv dSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQ dWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUg dG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0 cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKwor I2lmbmRlZiBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0a19oCisjZGVmaW5lIEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkK KworI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKworI2luY2x1ZGUgPHd0Zi9Q YXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZFNhZmVSZWZDb3VudGVkLmg+CisjaW5j bHVkZSA8d3RmL1RocmVhZGluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFz eW5jRmlsZVdyaXRlckd0azsKKworY2xhc3MgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGsgOiBwdWJsaWMgVGhyZWFkU2FmZVJlZkNvdW50ZWQ8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc1JlZlB0cjxBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0az4gY3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBib29s IHN5bmNocm9ub3VzKTsKKyAgICB+QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoKTsK KworICAgIHZvaWQgcG9zdFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxTY3JpcHRFeGVjdXRp b25Db250ZXh0OjpUYXNrPik7CisgICAgdm9pZCBzZXRDdXJyZW50VGFza01vZGUoY29uc3QgU3Ry aW5nJik7CisgICAgdm9pZCBwb3N0Q2FsbGJhY2tUYXNrKFBhc3NPd25QdHI8U2NyaXB0RXhlY3V0 aW9uQ29udGV4dDo6VGFzaz4sIGNvbnN0IFN0cmluZyYpOworICAgIGJvb2wgd2FpdEZvck9wZXJh dGlvblRvQ29tcGxldGUoKTsKKyAgICBib29sIHN5bmNocm9ub3VzKCkgeyByZXR1cm4gbV9zeW5j aHJvbm91czsgfQorCisgICAgYm9vbCBjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeShBc3luY0ZpbGVX cml0ZXJHdGsqKTsKKyAgICB2b2lkIHNldFdyaXRlclRvQ2FuY2VsKEFzeW5jRmlsZVdyaXRlckd0 ayogd3JpdGVyKSB7IG1fd3JpdGVyVG9DYW5jZWwgPSB3cml0ZXI7IH0KKworICAgIFN0cmluZyB1 bmlxdWVNb2RlKCk7Citwcml2YXRlOgorICAgIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBib29sKTsKKworICAgIFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIG1fY29udGV4dDsKKyAgICBib29sIG1fc3luY2hyb25vdXM7CisgICAgU3RyaW5n IG1fY3VycmVudFRhc2tNb2RlOworCisgICAgQXN5bmNGaWxlV3JpdGVyR3RrKiBtX3dyaXRlclRv Q2FuY2VsOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZ U1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGll bnRHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNs aWVudEd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYjlmYmNhMDE4OTBkOTBjOWFhZGE4ZjFlMGE1MjU2NGI3 MjYwYWJmMwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBH ZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQg V0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGli cmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIx MTAtMTMwMSBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNG aWxlV3JpdGVyQ2xpZW50R3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNs dWRlICJDcm9zc1RocmVhZFRhc2suaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdGF0aWMg dm9pZCBwZXJmb3JtRGlkV3JpdGVDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgQXN5 bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIGxvbmcgbG9uZyBieXRlcywgYm9vbCBjb21wbGV0 ZSkKK3sKKyAgICBjbGllbnQtPmRpZFdyaXRlKGJ5dGVzLCBjb21wbGV0ZSk7Cit9CisKK3N0YXRp YyB2b2lkIHBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq LCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCkKK3sKKyAgICBjbGllbnQtPmRpZFRydW5j YXRlKCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRGYWlsQ2FsbGJhY2soU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBGaWxlRXJyb3I6 OkVycm9yQ29kZSBjb2RlKQoreworICAgIGNsaWVudC0+ZGlkRmFpbChjb2RlKTsKK30KKworQXN5 bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsoQXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBBc3luY0ZpbGVXcml0ZXJD bGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBtb2RlKQorICAgIDogbV90YXNrQ29udHJvbGxl cih0YXNrQ29udHJvbGxlcikKKyAgICAsIG1fY2xpZW50KGNsaWVudCkKKyAgICAsIG1fdGFza01v ZGUobW9kZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRDdXJyZW50VGFza01vZGUobV90 YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRXcml0ZShs b25nIGxvbmcgYnl0ZXMsIGJvb2wgY29tcGxldGUpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+ cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRXcml0ZUNhbGxi YWNrLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fY2xpZW50KSwgYnl0ZXMsIGNvbXBsZXRlKSwg bV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRUcnVu Y2F0ZSgpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVD YWxsYmFja1Rhc2soJnBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrLCBBbGxvd0Nyb3NzVGhyZWFk QWNjZXNzKG1fY2xpZW50KSksIG1fdGFza01vZGUpOworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRl ckNsaWVudEd0azo6ZGlkRmFpbChGaWxlRXJyb3I6OkVycm9yQ29kZSBjb2RlKQoreworICAgIG1f dGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZwZXJm b3JtRGlkRmFpbENhbGxiYWNrLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fY2xpZW50KSwgY29k ZSksIG1fdGFza01vZGUpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAv LyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTZlZTEwOWZkNWQz Mzk1YjYxOTgzZDJiODFlMTZjN2YxMjIxOWFmYgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaApAQCAtMCwwICsx LDU3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJz ZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9m IHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNl aXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug YWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is CisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRlZiBBc3luY0ZpbGVX cml0ZXJDbGllbnRHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGtfaAorCisj aWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGsuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJDbGllbnQuaCIKKworI2lu Y2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3Mg QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrIDogcHVibGljIEFzeW5jRmlsZVdyaXRlckNsaWVudCB7 CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3Rr PiBjcmVhdGUoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVy LCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBtb2RlKQorICAg IHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGso dGFza0NvbnRyb2xsZXIsIGNsaWVudCwgbW9kZSkpOworICAgIH0KKworICAgIHZvaWQgZGlkV3Jp dGUobG9uZyBsb25nIGJ5dGVzLCBib29sIGNvbXBsZXRlKTsKKyAgICB2b2lkIGRpZFRydW5jYXRl KCk7CisgICAgdm9pZCBkaWRGYWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlKTsKKworICAgIEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlcigpIHsgcmV0dXJuIG1f dGFza0NvbnRyb2xsZXIuZ2V0KCk7IH0KKworcHJpdmF0ZToKKyAgICBBc3luY0ZpbGVXcml0ZXJD bGllbnRHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBBc3luY0ZpbGVXcml0 ZXJDbGllbnQqLCBjb25zdCBTdHJpbmcmKTsKKworICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0az4gbV90YXNrQ29udHJvbGxlcjsKKyAgICBBc3luY0ZpbGVXcml0ZXJD bGllbnQqIG1fY2xpZW50OworICAgIFN0cmluZyBtX3Rhc2tNb2RlOworfTsKKworfSAvLyBuYW1l c3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5j RmlsZVdyaXRlckNsaWVudEd0a19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQ1NjlhYjczNzkxMDRhMzcyYTFj MmEzNDM2MzlhOWZhOTg3ZmU0MjMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcApAQCAtMCwwICsxLDE1NSBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNv bT4KKyAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwu Y29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0 aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZv dW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0 b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1 ZGUgIkFzeW5jRmlsZVdyaXRlckd0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisj aW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmgiCisjaW5jbHVkZSAiQmxvYi5oIgor I2luY2x1ZGUgIkJsb2JSZWdpc3RyeUltcGwuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2su aCIKKworI2luY2x1ZGUgPGdpby9naW8uaD4KKyNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8 d3RmL2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCitQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckd0az4gQXN5 bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiB0YXNrQ29udHJvbGxlciwgR0ZpbGUqIGZp bGUpCit7CisgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBBc3luY0ZpbGVXcml0ZXJHdGsoY2xpZW50 LCB0YXNrQ29udHJvbGxlciwgZmlsZSkpOworfQorCitBc3luY0ZpbGVXcml0ZXJHdGs6OkFzeW5j RmlsZVdyaXRlckd0ayhBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgQXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBHRmlsZSogZmlsZSkKKyAgICA6 IG1fY2xpZW50KGNsaWVudCkKKyAgICAsIG1fdGFza0NvbnRyb2xsZXIodGFza0NvbnRyb2xsZXIp CisgICAgLCBtX2ZpbGUoZmlsZSkKK3sKK30KKworc3RhdGljIHZvaWQgd3JpdGVBc3luYyhTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs+ IGhlbHBlckNsaWVudCwgQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIsIEdGaWxlKiBmaWxlLCBs b25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEpCit7CisgICAgaWYgKGhlbHBlckNsaWVudC0+ dGFza0NvbnRyb2xsZXIoKS0+Y2FuY2VsV3JpdGVySWZOZWNlc3Nhcnkod3JpdGVyKSkgeworICAg ICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpBQk9SVF9FUlIpOworICAgICAg ICByZXR1cm47CisgICAgfQorCisgICAgR1JlZlB0cjxHRmlsZUlPU3RyZWFtPiBpb1N0cmVhbSA9 IGFkb3B0R1JlZihnX2ZpbGVfb3Blbl9yZWFkd3JpdGUoZmlsZSwgMCwgMCkpOworICAgIGlmICgh aW9TdHJlYW0pIHsKKyAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9U X0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHT3duUHRyPEdPdXRw dXRTdHJlYW0+IG91dHB1dFN0cmVhbShnX2lvX3N0cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShHX0lP X1NUUkVBTShpb1N0cmVhbS5nZXQoKSkpKTsKKyAgICBpZiAoIWdfc2Vla2FibGVfc2VlayhHX1NF RUtBQkxFKG91dHB1dFN0cmVhbS5nZXQoKSksIHBvc2l0aW9uLCBHX1NFRUtfU0VULCAwLCAwKSkg eworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJS KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIFJlZlB0cjxCbG9iU3RvcmFnZURhdGE+ IGJsb2JTdG9yYWdlID0gc3RhdGljX2Nhc3Q8QmxvYlJlZ2lzdHJ5SW1wbCY+KGJsb2JSZWdpc3Ry eSgpKS5nZXRCbG9iRGF0YUZyb21VUkwoZGF0YS0+dXJsKCkpOworICAgIGlmIChibG9iU3RvcmFn ZSkgeworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IGJsb2JTdG9yYWdlLT5pdGVtcygp LnNpemUoKTsgaSsrKSB7CisgICAgICAgICAgICBjb25zdCBCbG9iRGF0YUl0ZW0mIGJsb2JJdGVt ID0gYmxvYlN0b3JhZ2UtPml0ZW1zKClbaV07CisgICAgICAgICAgICBpZiAoYmxvYkl0ZW0udHlw ZSA9PSBCbG9iRGF0YUl0ZW06OkRhdGEpIHsKKyAgICAgICAgICAgICAgICBnc2l6ZSBieXRlc1dy aXR0ZW4gPSAwOworICAgICAgICAgICAgICAgIGdfb3V0cHV0X3N0cmVhbV93cml0ZV9hbGwoR19P VVRQVVRfU1RSRUFNKG91dHB1dFN0cmVhbS5nZXQoKSksIGJsb2JJdGVtLmRhdGEtPmRhdGEoKSwg YmxvYkl0ZW0uZGF0YS0+bGVuZ3RoKCksICZieXRlc1dyaXR0ZW4sIDAsIDApOworCisgICAgICAg ICAgICAgICAgYm9vbCBjb21wbGV0ZWQgPSBibG9iU3RvcmFnZS0+aXRlbXMoKS5zaXplKCkgPT0g KGkgKyAxKTsKKyAgICAgICAgICAgICAgICBoZWxwZXJDbGllbnQtPmRpZFdyaXRlKGJ5dGVzV3Jp dHRlbiwgY29tcGxldGVkKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KK30KKwor dm9pZCBBc3luY0ZpbGVXcml0ZXJHdGs6OndyaXRlKGxvbmcgbG9uZyBwb3NpdGlvbiwgQmxvYiog ZGF0YSkKK3sKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUo KTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNh bGxiYWNrVGFzaygmd3JpdGVBc3luYywgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpjcmVhdGUo bV90YXNrQ29udHJvbGxlci5nZXQoKSwgbV9jbGllbnQsIG1vZGUpLCBBbGxvd0Nyb3NzVGhyZWFk QWNjZXNzKHRoaXMpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fZmlsZS5nZXQoKSksIHBvc2l0 aW9uLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKGRhdGEpKSk7Cit9CisKK3N0YXRpYyB2b2lkIHRy dW5jYXRlQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxl V3JpdGVyQ2xpZW50R3RrPiBoZWxwZXJDbGllbnQsIEFzeW5jRmlsZVdyaXRlckd0ayogd3JpdGVy LCBHRmlsZSogZmlsZSwgbG9uZyBsb25nIGxlbmd0aCkKK3sKKyAgICBpZiAoaGVscGVyQ2xpZW50 LT50YXNrQ29udHJvbGxlcigpLT5jYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSh3cml0ZXIpKSB7Cisg ICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6OkFCT1JUX0VSUik7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBh ZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oZmlsZSwgIioiLCBHX0ZJTEVfUVVFUllfSU5GT19O T05FLCAwLCAwKSk7CisgICAgaWYgKCFmaWxlSW5mbykgeworICAgICAgICBoZWxwZXJDbGllbnQt PmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKworICAgIGxvbmcgbG9uZyBmaWxlTGVuZ3RoID0gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihn X2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5nZXQoKSkpOworICAgIGlmIChsZW5ndGggPiBm aWxlTGVuZ3RoKSB7CisgICAgICAgIEdPd25QdHI8R1N0cmluZz4gemVyb1BhZGRpbmcoZ19zdHJp bmdfbmV3X2xlbigwLCBsZW5ndGggLSBmaWxlTGVuZ3RoKSk7CisgICAgICAgIGRvIHsKKyAgICAg ICAgICAgIGdfc3RyaW5nX2FwcGVuZF9jKHplcm9QYWRkaW5nLmdldCgpLCAnXDAnKTsKKyAgICAg ICAgfSB3aGlsZSAoLS1sZW5ndGggPiBmaWxlTGVuZ3RoKTsKKworICAgICAgICBHUmVmUHRyPEdG aWxlSU9TdHJlYW0+IGlvU3RyZWFtID0gYWRvcHRHUmVmKGdfZmlsZV9vcGVuX3JlYWR3cml0ZShm aWxlLCAwLCAwKSk7CisgICAgICAgIGlmICghaW9TdHJlYW0pIHsKKyAgICAgICAgICAgIGhlbHBl ckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICAgICAg cmV0dXJuOworICAgICAgICB9CisKKyAgICAgICAgR093blB0cjxHT3V0cHV0U3RyZWFtPiBvdXRw dXRTdHJlYW0oZ19pb19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0oR19JT19TVFJFQU0oaW9TdHJl YW0uZ2V0KCkpKSk7CisgICAgICAgIGlmICghZ19zZWVrYWJsZV9zZWVrKEdfU0VFS0FCTEUob3V0 cHV0U3RyZWFtLmdldCgpKSwgbGVuZ3RoLCBHX1NFRUtfU0VULCAwLCAwKSkgeworICAgICAgICAg ICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAg ICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBnc2l6ZSBieXRlc1dyaXR0ZW4g PSAwOworICAgICAgICBnX291dHB1dF9zdHJlYW1fd3JpdGVfYWxsKEdfT1VUUFVUX1NUUkVBTShv dXRwdXRTdHJlYW0uZ2V0KCkpLCB6ZXJvUGFkZGluZy0+c3RyLCB6ZXJvUGFkZGluZy0+bGVuLCAm Ynl0ZXNXcml0dGVuLCAwLCAwKTsKKyAgICB9IGVsc2UgeworICAgICAgICBHUmVmUHRyPEdGaWxl T3V0cHV0U3RyZWFtPiBmaWxlT3V0cHV0U3RyZWFtID0gYWRvcHRHUmVmKGdfZmlsZV9yZXBsYWNl KGZpbGUsIDAsIGZhbHNlLCBHX0ZJTEVfQ1JFQVRFX05PTkUsIDAsIDApKTsKKyAgICAgICAgaWYg KCFmaWxlT3V0cHV0U3RyZWFtIHx8ICFnX3NlZWthYmxlX3RydW5jYXRlKEdfU0VFS0FCTEUoZmls ZU91dHB1dFN0cmVhbS5nZXQoKSksIGxlbmd0aCwgMCwgMCkpIHsKKyAgICAgICAgICAgIGhlbHBl ckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICAgICAg cmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgaGVscGVyQ2xpZW50LT5kaWRUcnVuY2F0 ZSgpOworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckd0azo6dHJ1bmNhdGUobG9uZyBsb25nIGxl bmd0aCkKK3sKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUo KTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNh bGxiYWNrVGFzaygmdHJ1bmNhdGVBc3luYywgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpjcmVh dGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgbV9jbGllbnQsIG1vZGUpLCBBbGxvd0Nyb3NzVGhy ZWFkQWNjZXNzKHRoaXMpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKG1fZmlsZS5nZXQoKSksIGxl bmd0aCkpOworfQorCit2b2lkIEFzeW5jRmlsZVdyaXRlckd0azo6YWJvcnQoKQoreworICAgIG1f dGFza0NvbnRyb2xsZXItPnNldFdyaXRlclRvQ2FuY2VsKHRoaXMpOworfQorCitib29sIEFzeW5j RmlsZVdyaXRlckd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKQoreworICAgIHJldHVy biBtX3Rhc2tDb250cm9sbGVyLT5zeW5jaHJvbm91cygpID8gbV90YXNrQ29udHJvbGxlci0+d2Fp dEZvck9wZXJhdGlvblRvQ29tcGxldGUoKSA6IGZhbHNlOworfQorCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTQ1YjAw YzFjOTc2YWMzNDM0NDZhYzVjNzQ3ZWU1YmU4MDkzZTczYwotLS0gL2Rldi9udWxsCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaApAQCAtMCwwICsx LDU3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJz ZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9m IHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNl aXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug YWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3Is CisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRlZiBBc3luY0ZpbGVX cml0ZXJHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVXcml0ZXJHdGtfaAorCisjaWYgRU5BQkxFKEZJ TEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyLmgiCisKKyNpbmNsdWRlIDx3 dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0ZpbGVXcml0ZXJDbGllbnQ7CitjbGFzcyBB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVy R3RrIDogcHVibGljIEFzeW5jRmlsZVdyaXRlciB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NP d25QdHI8QXN5bmNGaWxlV3JpdGVyR3RrPiBjcmVhdGUoQXN5bmNGaWxlV3JpdGVyQ2xpZW50Kiwg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBHRmlsZSopOworCisgICAgdm9pZCBh Ym9ydCgpOworICAgIHZvaWQgdHJ1bmNhdGUobG9uZyBsb25nIGxlbmd0aCk7CisgICAgdm9pZCB3 cml0ZShsb25nIGxvbmcgcG9zaXRpb24sIEJsb2IqIGRhdGEpOworCisgICAgYm9vbCB3YWl0Rm9y T3BlcmF0aW9uVG9Db21wbGV0ZSgpOworCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVdyaXRlckd0 ayhBc3luY0ZpbGVXcml0ZXJDbGllbnQqLCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ayosIEdGaWxlKik7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIG1fY2xpZW50OworICAg IFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gbV90YXNrQ29udHJvbGxl cjsKKyAgICBHUmVmUHRyPEdGaWxlPiBtX2ZpbGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAvLyBBc3luY0Zp bGVXcml0ZXJHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xv Y2FsRmlsZVN5c3RlbUd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxG aWxlU3lzdGVtR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42NTk3Mjg0NmU3OWMzODY2MjE5YmZmY2NjMmI4 ZGU2NjQ3MmQ5Nzk0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAKQEAgLTAsMCArMSw4NiBAQAorLyoKKyAqICBDb3B5 cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqICBDb3B5 cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqCisg KiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhbG9uZyB3aXRo IHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogIEZv dW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3Rvbiwg TUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJMb2NhbEZpbGVTeXN0ZW0uaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1 ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorI2luY2x1ZGUgIkNyb3NzVGhyZWFk VGFzay5oIgorI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCisjaW5jbHVkZSA8Z3RrL2d0ay5o PgorI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HT3du UHRyLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi90 ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitMb2NhbEZpbGVTeXN0ZW0q IExvY2FsRmlsZVN5c3RlbTo6c19pbnN0YW5jZSA9IDA7CisKK3ZvaWQgTG9jYWxGaWxlU3lzdGVt Ojppbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgpCit7Cisg ICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdPd25QdHI8R0Rpcj4gZGlyZWN0b3J5KGdf ZGlyX29wZW4oYmFzZVBhdGgudXRmOCgpLmRhdGEoKSwgMCwgJmVycm9yLm91dFB0cigpKSk7Cisg ICAgaWYgKGVycm9yICYmIGVycm9yLT5jb2RlID09IEdfRklMRV9FUlJPUl9OT0VOVCkgeworICAg ICAgICBHUmVmUHRyPEdGaWxlPiBiYXNlRGlyZWN0b3J5RmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVf bmV3X2Zvcl9wYXRoKGJhc2VQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICAgICAgZ19maWxlX21h a2VfZGlyZWN0b3J5KGJhc2VEaXJlY3RvcnlGaWxlLmdldCgpLCAwLCAwKTsKKyAgICB9Cit9CisK K0xvY2FsRmlsZVN5c3RlbSYgTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKQorewor ICAgIFdURjo6bG9ja0F0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpY011dGV4KCk7CisgICAgaWYg KCFzX2luc3RhbmNlKSB7CisgICAgICAgIEdPd25QdHI8Z2NoYXI+IGJhc2VQYXRoKGdfYnVpbGRf ZmlsZW5hbWUoZ19nZXRfdXNlcl9kYXRhX2RpcigpLCAid2Via2l0IiwgImZpbGVzeXN0ZW0iLCBO VUxMKSk7CisgICAgICAgIE93blB0cjxMb2NhbEZpbGVTeXN0ZW0+IGxvY2FsRmlsZVN5c3RlbSA9 IGFkb3B0UHRyKG5ldyBMb2NhbEZpbGVTeXN0ZW0oYmFzZVBhdGguZ2V0KCkpKTsKKyAgICAgICAg bG9jYWxGaWxlU3lzdGVtLT5pbml0aWFsaXplTG9jYWxGaWxlU3lzdGVtKFN0cmluZyhiYXNlUGF0 aC5nZXQoKSkpOworCisgICAgICAgIHNfaW5zdGFuY2UgPSBsb2NhbEZpbGVTeXN0ZW0ubGVha1B0 cigpOworICAgIH0KKyAgICBXVEY6OnVubG9ja0F0b21pY2FsbHlJbml0aWFsaXplZFN0YXRpY011 dGV4KCk7CisgICAgcmV0dXJuICpzX2luc3RhbmNlOworfQorCitTdHJpbmcgTG9jYWxGaWxlU3lz dGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgoKSBjb25zdAoreworICAgIHJldHVybiBtX2Jhc2VQYXRo OworfQorCitzdGF0aWMgdm9pZCBvcGVuRmlsZVN5c3RlbShTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIGJhc2VQYXRoLCBjb25zdCBTdHJpbmcmIGlkZW50aWZp ZXIsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBib29sIGNyZWF0ZSwgUGFzc093blB0cjxB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sK KyAgICBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGJhc2VQYXRoLCBpZGVudGlmaWVy LCB0eXBlLCBjcmVhdGUsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKGNvbnRl eHQsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKK30KKwordm9pZCBMb2NhbEZpbGVTeXN0ZW06 OnJlYWRGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEFzeW5jRmls ZVN5c3RlbTo6VHlwZSB0eXBlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4g Y2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQoreworICAgIC8vIEFzeW5jRmlsZVN5c3RlbTo6 b3BlbkZpbGVTeXN0ZW0gY2FsbHMgY2FsbGJhY2tzIHN5bmNocm9ub3VzbHksIHNvIHRoZSBtZXRo b2QgbmVlZHMgdG8gYmUgY2FsbGVkIGFzeW5jaHJvbm91c2x5LgorICAgIGNvbnRleHQtPnBvc3RU YXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmb3BlbkZpbGVTeXN0ZW0sIGZpbGVTeXN0ZW1CYXNlUGF0 aCgpLCBjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT5kYXRhYmFzZUlkZW50aWZpZXIoKSwgdHlw ZSwgZmFsc2UsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKK30KKwordm9pZCBMb2NhbEZpbGVT eXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQs IEFzeW5jRmlsZVN5c3RlbTo6VHlwZSB0eXBlLCBsb25nIGxvbmcsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAg Ly8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxsYmFja3Mgc3luY2hy b25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5bmNocm9ub3VzbHku CisgICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3Rl bSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFi YXNlSWRlbnRpZmllcigpLCB0eXBlLCB0cnVlLCBjYWxsYmFja3MsIHN5bmNocm9ub3VzKSk7Cit9 CisKK30KKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1Rvb2xz L0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCAyMjI3NmJlOGY3MTg1YzRlZmQyOTVk OTlkMzBiNzQ1YTM0NjBhZTY0Li5mNWUzNzQ4YTY1ZDIyYTJhNDdhODA4ZDg3ZjdjN2RjYThkZTdj NmEyIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTQgQEAKKzIwMTItMDQtMTggIENoYW5nU2VvayBPaCAgPHNoaXZhbWlkb3dAZ21h aWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVtIEFQSQorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0NDMKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBFbmFibGVkIEZpbGVT eXN0ZW0gZm9yIEdUSyBwb3J0LgorCisgICAgICAgICogU2NyaXB0cy9idWlsZC13ZWJraXQ6CisK IDIwMTItMDQtMTYgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+CiAKICAg ICAgICAgW0dUS10gVXNlIGNvbmZpZ3VyZSBpbnN0ZWFkIG9mIGF1dG9nZW4uc2ggZm9yIGd0aysK ZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvYnVpbGQtd2Via2l0IGIvVG9vbHMvU2NyaXB0cy9i dWlsZC13ZWJraXQKaW5kZXggNmVlOWYxMmQ3MzUyYjEzYjM1OWY2Mzk4ZWYwYWZjZDY1YWRmMzc0 Yi4uZjZlYmQyMzJjZjRkZWIyYzJkMTVkM2Y5MGVkZjE2YzI3MmI3ZmQ4OSAxMDA3NTUKLS0tIGEv VG9vbHMvU2NyaXB0cy9idWlsZC13ZWJraXQKKysrIGIvVG9vbHMvU2NyaXB0cy9idWlsZC13ZWJr aXQKQEAgLTIwMyw3ICsyMDMsNyBAQCBteSBAZmVhdHVyZXMgPSAoCiAgICAgICBkZWZpbmUgPT4g IkVOQUJMRV9ESVJFQ1RPUllfVVBMT0FEIiwgZGVmYXVsdCA9PiAwLCB2YWx1ZSA9PiBcJGRpcmVj dG9yeVVwbG9hZFN1cHBvcnQgfSwKIAogICAgIHsgb3B0aW9uID0+ICJmaWxlLXN5c3RlbSIsIGRl c2MgPT4gIlRvZ2dsZSBGaWxlU3lzdGVtIHN1cHBvcnQiLAotICAgICAgZGVmaW5lID0+ICJFTkFC TEVfRklMRV9TWVNURU0iLCBkZWZhdWx0ID0+IGlzQmxhY2tCZXJyeSgpLCB2YWx1ZSA9PiBcJGZp bGVTeXN0ZW1TdXBwb3J0IH0sCisgICAgICBkZWZpbmUgPT4gIkVOQUJMRV9GSUxFX1NZU1RFTSIs IGRlZmF1bHQgPT4gKGlzQmxhY2tCZXJyeSgpIHx8IGlzR3RrKCkpLCB2YWx1ZSA9PiBcJGZpbGVT eXN0ZW1TdXBwb3J0IH0sCiAKICAgICB7IG9wdGlvbiA9PiAiZmlsdGVycyIsIGRlc2MgPT4gIlRv Z2dsZSBTVkcgRmlsdGVycyBzdXBwb3J0IiwKICAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0ZJTFRF UlMiLCBkZWZhdWx0ID0+IChpc0FwcGxlV2ViS2l0KCkgfHwgaXNHdGsoKSB8fCBpc1F0KCkgfHwg aXNFZmwoKSB8fCBpc0JsYWNrQmVycnkoKSksIHZhbHVlID0+IFwkZmlsdGVyc1N1cHBvcnQgfSwK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBjM2VlMzJkMDdkZGNhMzIyMjlhYzY0MzAwOGFjNTdlMmI2MjBhNDZkLi5lM2Y2Zjkw NTUwNDA4OTdhMDQ1MmRmYjQzNmIxNTdjZmM2YWU1OTVmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAK KzIwMTItMDQtMTggIENoYW5nU2VvayBPaCAgPHNoaXZhbWlkb3dAZ21haWwuY29tPgorCisgICAg ICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0NDMKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbGwgdGVzdHMgaW4gZmFzdC9maWxlc3lzdGVt IGFyZSBwYXNzZWQgZXhjZXB0IHRoZSBvbmVzIHJlbGF0ZWQgd2l0aCB3b3JrZXIuCisgICAgICAg IEZvbGxvd2luZyB0ZXN0cyBhcmUgcGFzc2VkIGluIGRldGFpbC4KKyAgICAgICAgZmFzdC9maWxl c3lzdGVtLyouaHRtbAorICAgICAgICBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2st ZGVsaXZlcnkuaHRtbAorICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3Nl bmQtZmlsZS1ibG9iLmh0bWwKKyAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHli aS9zZW5kLWZpbGUtYmxvYi1mYWlsLmh0bWwKKworICAgICAgICAqIHBsYXRmb3JtL2d0ay90ZXN0 X2V4cGVjdGF0aW9ucy50eHQ6CisKIDIwMTItMDQtMTYgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJl dmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIx MTQyODUuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3Rh dGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4 dAppbmRleCBhZmU0MjRjZTU5MzYzNTk1Y2MyYjM5MmJlNDRhZmRjNGM4ZGQ5MGY0Li41NGIzZjdh MTQ2Y2UzODIxNDAzOTc5OTI5ODQxMWUxNmIyYjk2ODAxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL2d0ay90ZXN0X2V4cGVjdGF0aW9ucy50eHQKQEAgLTE1NSwxNCArMTU1LDEyIEBAIEJV R1dLNDI0MzIgOiBodHRwL3Rlc3RzL21pc2Mvd2VidGltaW5nLXNsb3ctbG9hZC5waHAgPSBGQUlM CiBCVUdXSzQyNDMyIDogaHR0cC90ZXN0cy9taXNjL3dlYnRpbWluZy1zc2wucGhwID0gRkFJTAog QlVHV0s0MjQzMiA6IGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmctdHdvLXJlZGlyZWN0cy5waHAg PSBGQUlMCiAKLS8vIEZpbGVTeXN0ZW0gQVBJIGlzIG5vdCBzdXBwb3J0ZWQuCi1CVUdXS0dUSyBT S0lQIDogZmFzdC9maWxlc3lzdGVtID0gRkFJTAorLy8gRmlsZVN5c3RlbSBBUEkgaXMgbm90IHN1 cHBvcnRlZCBjb21wbGV0ZWx5LgorLy8gV2UgZG9uJ3Qgc3VwcG9ydCB3b3JrZXJzIGZvciBGaWxl U3lzdGVtIHlldC4gaHR0cDovL3dlYmtpdC5vcmcvYi84Mjg1NAorQlVHV0tHVEsgU0tJUCA6IGZh c3QvZmlsZXN5c3RlbS93b3JrZXJzID0gRkFJTAogQlVHV0tHVEsgU0tJUCA6IGh0dHAvdGVzdHMv ZmlsZXN5c3RlbSA9IEZBSUwKIEJVR1dLR1RLIFNLSVAgOiBodHRwL3Rlc3RzL3NlY3VyaXR5L2Zp bGVzeXN0ZW0taWZyYW1lLWZyb20tcmVtb3RlLmh0bWwgPSBGQUlMCi1CVUdXS0dUSyBTS0lQIDog aHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUtYmxvYi5odG1sID0gRkFJ TAotQlVHV0tHVEsgU0tJUCA6IGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1m aWxlLWJsb2ItZmFpbC5odG1sID0gRkFJTAogQlVHV0tHVEsgU0tJUCA6IGh0dHAvdGVzdHMvd29y a2Vycy90ZXJtaW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0aW9uLmh0bWwgPSBGQUlMCi1CVUdXS0dU SyBTS0lQIDogZmFzdC9tdXRhdGlvbi9maWxlc3lzdGVtLWNhbGxiYWNrLWRlbGl2ZXJ5Lmh0bWwg PSBGQUlMCiAKIC8vIFJlcXVpcmVzIFdlYlAgc3VwcG9ydC4KIEJVR1dLR1RLIFNLSVAgOiBmYXN0 L2NhbnZhcy9jYW52YXMtdG9EYXRhVVJMLXdlYnAuaHRtbCA9IEZBSUwK 137860 2012-04-19 00:36:11 -0700 2012-04-19 00:46:26 -0700 Patch bug-58443-20120419163610.patch text/plain 73460 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTE0MzM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDZmZTMxOTA1ZmUxNjhiMTAzOGVlMDVj Nzg0ZWNkNjczOTYyMjQ4ZDguLjg3MDEzMmMyYWQ1ZmFjZmI4ZDk1M2JkOGIzOGU0Y2QxMWFmOGNl ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMTggIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDoKKwogMjAxMi0wNC0xNiAgTmljbyBXZWJlciAgPHRoYWtpc0Bj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgTWFrZSBOdWxsUHRyLmggY29tcGlsZSB3aXRoIGNsYW5n IC1zdGQ9YysrMTEgYW5kIGxpYnN0ZGMrKzQuMgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGQ2MDUzNGVhNmNkZWY0 ZmUzMTQ5NTYxNDUyODI4MjM3NjE4Y2U0YjcuLmM1MjA0NzU3N2RhYTM5MDc1OGIyMTVkMGM5YTJi MGJlNjI4ODhlYTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNDEgQEAKKzIwMTItMDQtMTggIENo YW5nU2VvayBPaCAgPHNoaXZhbWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBv cnQgdGhlIGZpbGUgc3lzdGVtIEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NTg0NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBUaGlzIHBhdGNoIGlzIGJhc2VkIG9uIFphbiBEb2JlcnNlaydzIG9yaWdp bmFsIG9uZSBmb3IgYnVnNTg0NDMuCisgICAgICAgIFRoaXMgYnJpbmdzIEZpbGVTeXN0ZW0gQVBJ IHRvIGd0ayBwb3J0LiBUaGlzIGFkZHMgbmV3IGludGVyZmFjZXMgbGlrZQorICAgICAgICBBc3lu Y0ZpbGVTeXN0ZW1HdGssIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0aywgQXN5bmNGaWxlV3Jp dGVyR3RrLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsKKyAgICAgICAgYW5kIEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrLiBUaGVzZSBhcmUgY2hpbGQgY2xhc3NlcyBpbXBsZW1lbnRp bmcgdGhlIGludGVyZmFjZXMKKyAgICAgICAgb2YgZWFjaCBwYXJlbnQgY2xhc3NlcyBleGNlcHQg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrCisgICAgICAgIGlzIGEgaGVscGVyIGNsYXNzLiBJdCByZXRhaW5zIHNvbWUgdXNl ZnVsIHZhcmlhYmxlcywgYW5kIGNvbnRyb2xzIHBvc3RpbmcgdGFza3MgdG8KKyAgICAgICAgU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCB3aGljaCBtaWdodCBiZSBlaXRoZXIgYSBEb2N1bWVudCBvYmpl Y3Qgb3IgYSBXb3JrZXIuCisgICAgICAgIFVuZm9ydHVuYXRlbHksIFdvcmtlciBmb3IgZmlsZXN5 c3RlbSBpcyBub3Qgc3VwcG9ydGVkIHlldCwgSSBwbGFuIHRvIHN1cHBvcnQgaXQgaW4gdGhlIG5l eHQgcGF0Y2guCisKKyAgICAgICAgVGVzdDogZmFzdC9maWxlc3lzdGVtLyouaHRtbAorICAgICAg ICAgICAgICBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRtbAor ICAgICAgICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1i bG9iLmh0bWwKKyAgICAgICAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9z ZW5kLWZpbGUtYmxvYi1mYWlsLmh0bWwKKworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06 IEFkZGVkIHNvbWUgZmlsZXMgdG8gYnVpbGQgbmV3bHkgZm9yIEZpbGVTeXN0ZW0uCisgICAgICAg ICogTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHA6IFdlIHNob3VsZCBub3Qg YnVpbGQgdGhpcyBmaWxlLiBzbyBhZGRlZCBlcnJvciBtZXNzYWdlLgorICAgICAgICAqIHBsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBh biBpbXBsZW1lbnRhdGlvbiBvZiBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuCisgICAgICAgIChX ZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6Ojo6Y29weSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayk6 CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkU3VjY2VlZCk6CisgICAg ICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkT3BlbkZpbGVTeXN0ZW1DYWxsYmFjayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZE9wZW5GaWxlU3lzdGVt KToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRSZWFkTWV0YWRhdGFDYWxsYmFjayk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWRNZXRh ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRp ZFJlYWREaXJlY3RvcnlFbnRyeSk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkUmVhZERp cmVjdG9yeUVudHJpZXNBbmRGaW5pc2hlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkUmVhZERpcmVjdG9yeUVudHJpZXMpOgorICAg ICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZENyZWF0ZUZpbGVX cml0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZEZhaWxDYWxsYmFjayk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZEZhaWwpOgorICAg ICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaDogQWRkZWQu CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 ayk6IEFkZGVkIHNvbWUgbWlzc2luZyBBUElzLiBUaGlzIGlzIGEgY2hpbGQgY2xhc3Mgb2YgQXN5 bmNGaWxlU3lzdGVtLgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrOjpEaXJlY3RvcnlFbnRyeTo6RGlyZWN0b3J5RW50cnkpOgorICAgICAgICAoRGlyZWN0b3J5 RW50cnkpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6dG9GaWxlRXJyb3JDb2RlKToKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6dmFsaWRhdGVGaWxlVHlwZSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVN5c3RlbTo6aXNWYWxpZFR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVt OjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06OmNy YWNrRmlsZVN5c3RlbVVSTCk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6 OkFzeW5jRmlsZVN5c3RlbUd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1H dGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lz dGVtR3RrOjp0b1VSTCk6CisgICAgICAgIChXZWJDb3JlOjptb3ZlQXN5bmMpOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjptb3ZlKToKKyAgICAgICAgKFdlYkNvcmU6OmNv cHlSZWN1cnNpdmVseSk6CisgICAgICAgIChXZWJDb3JlOjpjb3B5QXN5bmMpOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6OnJl bW92ZUZpbGVSZWN1cnNpdmVseSk6CisgICAgICAgIChXZWJDb3JlOjpyZW1vdmVBc3luYyk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZSk6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlbW92ZVJlY3Vyc2l2ZWx5KToKKyAgICAgICAg KFdlYkNvcmU6OnJlYWRNZXRhZGF0YUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVN5c3RlbUd0azo6cmVhZE1ldGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZU9iamVj dEFuZFJlYWRNZXRhZGF0YUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3Rl bUd0azo6Y3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVjdG9yeSk6CisgICAgICAgIChXZWJDb3JlOjpvYmplY3RF eGlzdHNBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmZpbGVF eGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpkaXJlY3RvcnlF eGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6cmVhZERpcmVjdG9yeUFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZERpcmVjdG9yeSk6CisgICAgICAgIChX ZWJDb3JlOjpjcmVhdGVXcml0ZXJBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcik6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0 ZW1HdGs6OmNyZWF0ZVNuYXBzaG90RmlsZUFuZFJlYWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJD b3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKToKKyAgICAgICAgKFdl YkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6dmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwpOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9D b21wbGV0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oOgor ICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAg ICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHA6IEFk ZGVkLiBUaGlzIGlzIGEgaGVscGVyIGNsYXNzIHRvIGNvbnRyb2wgcG9zdGluZyB0YXNrIHRvIGEg dGFyZ2V0IHRocmVhZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayk6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6dW5pcXVlTW9kZSk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdFRh c2tUb01haW5UaHJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdENhbGxiYWNrVGFzayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6d2FpdEZvck9wZXJh dGlvblRvQ29tcGxldGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGs6OmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KToKKyAgICAgICAgKiBwbGF0Zm9y bS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzeW5j aHJvbm91cyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0azo6c2V0V3JpdGVyVG9DYW5jZWwpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIGltcGxl bWVudCBvZiBBeXNuY0ZpbGVXcml0ZXJDbGllbnQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAg ICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRXcml0ZUNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6 OnBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1E aWRGYWlsQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRXcml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckNsaWVudEd0azo6ZGlkRmFpbCk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0Fz eW5jRmlsZVdyaXRlckNsaWVudEd0ay5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAg ICAgICAoQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVdyaXRlckNsaWVudEd0azo6dGFza0NvbnRyb2xsZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwOiBBZGRlZC4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIG9m IEFzeW5jRmlsZVdyaXRlci4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl V3JpdGVyR3RrOjpBc3luY0ZpbGVXcml0ZXJHdGspOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVB c3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OndyaXRlKToKKyAg ICAgICAgKFdlYkNvcmU6OnRydW5jYXRlQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlV3JpdGVyR3RrOjp0cnVuY2F0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0 ZXJHdGs6OmFib3J0KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckd0azo6d2Fp dEZvck9wZXJhdGlvblRvQ29tcGxldGUpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJHdGsuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5j RmlsZVdyaXRlckd0ayk6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0 ay5jcHA6IEFkZGVkLiBQb3J0IHNwZWNpZmljIGltcGxlbWVudGF0aW9uIGZvciBMb2NhbEZpbGVT eXN0ZW0gY2xhc3MgaXMgaGVyZS4gV2Ugc2hvdWxkIHVzZSB0aGlzIGZpbGUgaW5zdGVhZCBvZiBM b2NhbEZpbGVTeXN0ZW0uY3BwCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6 OkxvY2FsRmlsZVN5c3RlbTo6aW5pdGlhbGl6ZUxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJD b3JlOjpMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCk6CisgICAgICAgIChXZWJD b3JlOjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06 OnJlYWRGaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OkxvY2FsRmlsZVN5c3RlbTo6cmVx dWVzdEZpbGVTeXN0ZW0pOgorCiAyMDEyLTA0LTE2ICBUYWthc2hpIFNha2Ftb3RvICA8dGFzYWtA Z29vZ2xlLmNvbT4KIAogICAgICAgICBbU2hhZG93IERPTV0gSW5zZXJ0aW9uUG9pbnQgc2hvdWxk IGhhdmUgaXNBY3RpdmUoKSBtZW1iZXIgZnVuY3Rpb24uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRy LmNwcAppbmRleCBkZmUxODdkNzg4N2ZmNTRlYTAyN2MxYzlkYzVjMDZiZDdiZGI1Y2YxLi4zYWEw NzU5OTQ3NmQ3NGUyMmZkZjRlN2NkMGU4NTc3YTI4MTU5MmI0IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dvYmplY3Qv R093blB0ci5jcHAKQEAgLTQyLDYgKzQyLDE2IEBAIHRlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVk R1B0cjxHU0xpc3Q+KEdTTGlzdCogcHRyKQogICAgIGdfc2xpc3RfZnJlZShwdHIpOwogfQogCit0 ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1N0cmluZz4oR1N0cmluZyogcHRyKQorewor ICAgIGdfc3RyaW5nX2ZyZWUocHRyLCB0cnVlKTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBmcmVl T3duZWRHUHRyPEdPdXRwdXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qIHB0cikKK3sKKyAgICBnX291 dHB1dF9zdHJlYW1fY2xvc2UocHRyLCAwLCAwKTsKK30KKwogdGVtcGxhdGUgPD4gdm9pZCBmcmVl T3duZWRHUHRyPEdQYXR0ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKiBwdHIpCiB7CiAgICAgaWYgKHB0 cikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oIGIvU291cmNl L1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKaW5kZXggNGIyZGNiNzdiMjUwMDBjMmU1YjY4MDhh NGM3NDg0YzJiZTZkNmNhNS4uOWMwNjdkNzFhNjc5NTVjYzRiZjhkOGZjOGRkZjIwZDliMjJhMWM3 MSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKKysrIGIvU291 cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKQEAgLTM2LDYgKzM2LDggQEAgdGVtcGxhdGUg PHR5cGVuYW1lIFQ+IGlubGluZSB2b2lkIGZyZWVPd25lZEdQdHIoVCogcHRyKTsKIHRlbXBsYXRl PD4gdm9pZCBmcmVlT3duZWRHUHRyPEdFcnJvcj4oR0Vycm9yKik7CiB0ZW1wbGF0ZTw+IHZvaWQg ZnJlZU93bmVkR1B0cjxHTGlzdD4oR0xpc3QqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRH UHRyPEdTTGlzdD4oR1NMaXN0Kik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHU3Ry aW5nPihHU3RyaW5nKik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHT3V0cHV0U3Ry ZWFtPihHT3V0cHV0U3RyZWFtKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHUGF0 dGVyblNwZWM+KEdQYXR0ZXJuU3BlYyopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8 R0Rpcj4oR0RpciopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1RpbWVyPihHVGlt ZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmggYi9T b3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5oCmluZGV4IGUyOTI1MGJlZjJlZjRkNWU5 ZWJlNWMyYjA1MDM3M2JiYTg1NjRmOWEuLjdhNWU5ZjNjYTA3ZGE1NWU1NjhjNTcxZDRlNWJjOWY4 NTQ1ZWI1MjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmgK KysrIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaApAQCAtNDgsMTcgKzQ4LDIw IEBAIHR5cGVkZWYgc3RydWN0IF9HZGtFdmVudEV4cG9zZSBHZGtFdmVudEV4cG9zZTsKIHR5cGVk ZWYgc3RydWN0IF9HZGtQaXhidWYgR2RrUGl4YnVmOwogdHlwZWRlZiBzdHJ1Y3QgX0dFcnJvciBH RXJyb3I7CiB0eXBlZGVmIHN0cnVjdCBfR0ZpbGUgR0ZpbGU7Cit0eXBlZGVmIHN0cnVjdCBfR0Zp bGVJT1N0cmVhbSBHRmlsZUlPU3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dIYXNoVGFibGUgR0hh c2hUYWJsZTsKIHR5cGVkZWYgc3RydWN0IF9HSW5wdXRTdHJlYW0gR0lucHV0U3RyZWFtOwogdHlw ZWRlZiBzdHJ1Y3QgX0dMaXN0IEdMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluQ29udGV4dCBH TWFpbkNvbnRleHQ7CiB0eXBlZGVmIHN0cnVjdCBfR01haW5Mb29wIEdNYWluTG9vcDsKK3R5cGVk ZWYgc3RydWN0IF9HT3V0cHV0U3RyZWFtIEdPdXRwdXRTdHJlYW07CiB0eXBlZGVmIHN0cnVjdCBf R1BhdHRlcm5TcGVjIEdQYXR0ZXJuU3BlYzsKIHR5cGVkZWYgc3RydWN0IF9HUG9sbGFibGVPdXRw dXRTdHJlYW0gR1BvbGxhYmxlT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dTTGlzdCBH U0xpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfR1NvY2tldENsaWVudCBHU29ja2V0Q2xpZW50OwogdHlw ZWRlZiBzdHJ1Y3QgX0dTb2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25uZWN0aW9uOwogdHlwZWRl ZiBzdHJ1Y3QgX0dTb3VyY2UgR1NvdXJjZTsKK3R5cGVkZWYgc3RydWN0IF9HU3RyaW5nIEdTdHJp bmc7CiB0eXBlZGVmIHN0cnVjdCBfR1ZhcmlhbnQgR1ZhcmlhbnQ7CiB0eXBlZGVmIHVuaW9uIF9H ZGtFdmVudCBHZGtFdmVudDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIgR1RpbWVyOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3Jl L0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggNGJkNWRmZGE3YTMzYTRhOTYwYjc4MjU5MDQxZDkz MDlkNzdlZTJjYy4uOTQxNWM2YmRjZDkyYmY4YWY4NmQ4MWUzNjJjMmJiMzE1Y2YxMzYwYyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2Uv V2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0xMDI0LDcgKzEwMjQsNiBAQCB3ZWJjb3Jl X21vZHVsZXNfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L0ZpbGVXcml0ZXJDYWxsYmFjay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0 ZW0vRmlsZVdyaXRlclN5bmMuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0 ZW0vRmlsZVdyaXRlclN5bmMuaCBcCi0JU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L0xvY2FsRmlsZVN5c3RlbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3Rl bS9Mb2NhbEZpbGVTeXN0ZW0uaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L01ldGFkYXRhQ2FsbGJhY2suaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVt L01ldGFkYXRhLmggXApAQCAtNDY5Myw2ICs0NjkyLDcgQEAgd2ViY29yZWd0a19zb3VyY2VzICs9 IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR3RrVmVyc2lvbmluZy5oIFwKIAlTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuY3BwIFwKIAlTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuaCBcCisJU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAgXAogCVNvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbGl6ZWRTdHJpbmdzR3RrLmNwcCBcCiAJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL01haW5GcmFtZVNjcm9sbGJhckd0ay5jcHAgXAogCVNvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9NYWluRnJhbWVTY3JvbGxiYXJHdGsuaCBcCkBAIC00OTg3LDkg KzQ5ODcsMTkgQEAgZG9tX2JpbmRpbmdfaWRscyArPSBcCiAJJChXZWJDb3JlKS9Nb2R1bGVzL2Zp bGVzeXN0ZW0vTWV0YWRhdGFDYWxsYmFjay5pZGwgXAogCSQoV2ViQ29yZSkvTW9kdWxlcy9maWxl c3lzdGVtL1dvcmtlckNvbnRleHRGaWxlU3lzdGVtLmlkbAogCi13ZWJjb3JlZ3RrX3NvdXJjZXMg Kz0gXAord2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0Fz eW5jRmlsZVN5c3RlbUd0ay5oCisKK3dlYmNvcmVndGtfc291cmNlcyArPSBcCisJU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAgXAorCVNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCBc CisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlV3JpdGVyR3RrLmgKIGVuZGlmICMgRU5EIEVOQUJMRV9GSUxFX1NZU1RFTQogCiAj IC0tLS0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9Mb2Nh bEZpbGVTeXN0ZW0uY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2Fs RmlsZVN5c3RlbS5jcHAKaW5kZXggOGYwMTY5ZWVhYmJhOTNmZjRmMTU2ZDdjMjM0N2I2YzBiMjdk NWJiYS4uNzNmMjE4YjRhMDM3MWQwMDRhMTRjYmEwMTgyNjFjOGIyZTQ5YzY2NCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5j cHAKQEAgLTMxLDggKzMxLDggQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJMb2Nh bEZpbGVTeXN0ZW0uaCIKIAotI2lmIFBMQVRGT1JNKENIUk9NSVVNKQotI2Vycm9yICJDaHJvbWl1 bSBzaG91bGQgbm90IGNvbXBpbGUgdGhpcyBmaWxlIGFuZCBpbnN0ZWFkIGRlZmluZSBpdHMgb3du IHZlcnNpb24gb2YgdGhlc2UgZmFjdG9yaWVzLiIKKyNpZiBQTEFURk9STShDSFJPTUlVTSkgfHwg UExBVEZPUk0oR1RLKQorI2Vycm9yICJDaHJvbWl1bSAmIFdlYktpdEdUSysgc2hvdWxkIG5vdCBj b21waWxlIHRoaXMgZmlsZSBhbmQgaW5zdGVhZCBkZWZpbmUgaXRzIG93biB2ZXJzaW9uIG9mIHRo ZXNlIGZhY3Rvcmllcy4iCiAjZW5kaWYKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGNhYzJkMDE2ZjVhMzEwYjk0MDZmY2ZiZjUyMTMy MmQ4YjhkOTM3YQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwCkBAIC0wLDAgKzEsMTU1IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29t PgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBM ZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor ICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkg b2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0 aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24s IE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQorCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxl V3JpdGVyLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVkZSAiRmlsZU1l dGFkYXRhLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5jbHVk ZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3RlbXBsYXRl PD4gc3RydWN0IENyb3NzVGhyZWFkQ29waWVyQmFzZTxmYWxzZSwgZmFsc2UsIEZpbGVNZXRhZGF0 YT4geworICAgIHR5cGVkZWYgRmlsZU1ldGFkYXRhIFR5cGU7CisgICAgc3RhdGljIEZpbGVNZXRh ZGF0YSBjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYpOworfTsKKworQ3Jvc3NUaHJlYWRDb3BpZXJC YXNlPGZhbHNlLCBmYWxzZSwgRmlsZU1ldGFkYXRhPjo6VHlwZSBDcm9zc1RocmVhZENvcGllckJh c2U8ZmFsc2UsIGZhbHNlLCBGaWxlTWV0YWRhdGE+Ojpjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYg b3JpZ2luYWwpCit7CisgICAgRmlsZU1ldGFkYXRhIG1ldGFkYXRhOworICAgIG1ldGFkYXRhLm1v ZGlmaWNhdGlvblRpbWUgPSBvcmlnaW5hbC5tb2RpZmljYXRpb25UaW1lOworICAgIG1ldGFkYXRh Lmxlbmd0aCA9IG9yaWdpbmFsLmxlbmd0aDsKKyAgICBtZXRhZGF0YS50eXBlID0gb3JpZ2luYWwu dHlwZTsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBvcmlnaW5hbC5wbGF0Zm9ybVBhdGg7 CisgICAgcmV0dXJuIG1ldGFkYXRhOworfQorCitQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0az4gQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIo bmV3IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhjb250ZXh0LCBjYWxsYmFja3MsIHN5bmNo cm9ub3VzKSk7Cit9CisKK1Bhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICByZXR1cm4gYWRv cHRQdHIobmV3IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayh0YXNrQ29udHJvbGxlciwgY2Fs bGJhY2tzLCBtb2RlKSk7Cit9CisKKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5j aHJvbm91cykKKyAgICA6IG1fc3luY2hyb25vdXMoc3luY2hyb25vdXMpCisgICAgLCBtX3Rhc2tN b2RlKCIiKQorICAgICwgbV90YXNrQ29udHJvbGxlcihBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0azo6Y3JlYXRlKGNvbnRleHQsIHN5bmNocm9ub3VzKSkKKyAgICAsIG1fY2FsbGJhY2tz KGNhbGxiYWNrcykKK3sKK30KKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRh c2tDb250cm9sbGVyLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJh Y2tzLCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3N5bmNocm9ub3VzKGZhbHNlKQorICAg ICwgbV90YXNrTW9kZShtb2RlKQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxl cikKKyAgICAsIG1fY2FsbGJhY2tzKGNhbGxiYWNrcykKK3sKK30KKworc3RhdGljIHZvaWQgcGVy Zm9ybURpZFN1Y2NlZWRDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjYWxsYmFja3Mt PmRpZFN1Y2NlZWQoKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRp ZFN1Y2NlZWQoKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3Jl YXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrLCBtX2NhbGxiYWNrcy5y ZWxlYXNlKCkpLCBtX3Rhc2tNb2RlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZE9wZW5G aWxlU3lzdGVtQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbmFtZSwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgY2FsbGJhY2tzLT5k aWRPcGVuRmlsZVN5c3RlbShuYW1lLCBmaWxlU3lzdGVtKTsKK30KKwordm9pZCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgbmFtZSwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgQXN5bmNGaWxl U3lzdGVtR3RrKiBmaWxlU3lzdGVtR3RrID0gc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtR3Rr Kj4oZmlsZVN5c3RlbS5nZXQoKSk7CisKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xs ZXItPnVuaXF1ZU1vZGUoKTsKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRDdXJyZW50VGFza01v ZGUobW9kZSk7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVD YWxsYmFja1Rhc2soJnBlcmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNrLCBtX2NhbGxiYWNr cy5yZWxlYXNlKCksIG5hbWUsIGZpbGVTeXN0ZW0pLCBtb2RlKTsKKworICAgIGZpbGVTeXN0ZW1H dGstPnNldFRhc2tDb250cm9sbGVyKG1fdGFza0NvbnRyb2xsZXIucmVsZWFzZSgpKTsKKyAgICBm aWxlU3lzdGVtR3RrLT53YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworfQorCitzdGF0aWMg dm9pZCBwZXJmb3JtRGlkUmVhZE1ldGFkYXRhQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0 IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7CisgICAgY2FsbGJhY2tzLT5kaWRSZWFkTWV0YWRh dGEobWV0YWRhdGEpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlk UmVhZE1ldGFkYXRhKGNvbnN0IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7CisgICAgbV90YXNr Q29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1E aWRSZWFkTWV0YWRhdGFDYWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBtZXRhZGF0YSks IG1fdGFza01vZGUpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlk UmVhZERpcmVjdG9yeUVudHJ5KGNvbnN0IFN0cmluZyYgbmFtZSwgYm9vbCBpc0RpcmVjdG9yeSkK K3sKKyAgICBtX2RpcmVjdG9yeUVudHJpZXMuYXBwZW5kKERpcmVjdG9yeUVudHJ5KG5hbWUsIGlz RGlyZWN0b3J5KSk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRSZWFkRGlyZWN0b3J5RW50 cmllc0FuZEZpbmlzaGVkQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25Q dHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY2FsbGJhY2tz LT5kaWRSZWFkRGlyZWN0b3J5RW50cmllcyhmYWxzZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5RW50cmllcyhib29sKQoreworICAgIGZv ciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9kaXJlY3RvcnlFbnRyaWVzLnNpemUoKTsgKytpKQorICAg ICAgICBtX2NhbGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeUVudHJ5KG1fZGlyZWN0b3J5RW50cmll c1tpXS5uYW1lLCBtX2RpcmVjdG9yeUVudHJpZXNbaV0uaXNEaXJlY3RvcnkpOworICAgIG1fZGly ZWN0b3J5RW50cmllcy5jbGVhcigpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxi YWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRSZWFkRGlyZWN0b3J5RW50cmll c0FuZEZpbmlzaGVkQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSksIG1fdGFza01vZGUp OworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBsb25nIGxv bmcgbGVuZ3RoKQoreworICAgIGNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcih3cml0ZXIs IGxlbmd0aCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRDcmVh dGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiB3cml0ZXIsIGxvbmcgbG9u ZyBsZW5ndGgpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVh dGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2ssIG1fY2Fs bGJhY2tzLnJlbGVhc2UoKSwgd3JpdGVyLCBsZW5ndGgpLCBtX3Rhc2tNb2RlKTsKK30KKworc3Rh dGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgaW50IGNvZGUp Cit7CisgICAgY2FsbGJhY2tzLT5kaWRGYWlsKGNvZGUpOworfQorCit2b2lkIEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0azo6ZGlkRmFpbChpbnQgY29kZSkKK3sKKyAgICBtX3Rhc2tDb250cm9s bGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZEZhaWxD YWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBjb2RlKSwgbV90YXNrTW9kZSk7Cit9CisK K30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44MzM3NDZkZDhjNTRjOGY4Mzc0M2QyMmUxODUx MTg4NzhjMTdmN2NjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oCkBAIC0wLDAgKzEsNzMgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+ CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExl c3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0a19oCisjZGVmaW5lIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisKKyNpZiBFTkFC TEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaW5jbHVk ZSA8d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBTY3Jp cHRFeGVjdXRpb25Db250ZXh0OworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsg OiBwdWJsaWMgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0ZShTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29s IHN5bmNocm9ub3VzID0gZmFsc2UpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJpbmcmIG1v ZGUpOworCisgICAgdmlydHVhbCB2b2lkIGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFsIHZvaWQg ZGlkT3BlbkZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbT4pOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1l dGFkYXRhJik7CisgICAgdmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBT dHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFk RGlyZWN0b3J5RW50cmllcyhib29sIGhhc01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVh dGVGaWxlV3JpdGVyKFBhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiwgbG9uZyBsb25nIGxlbmd0 aCk7CisgICAgdmlydHVhbCB2b2lkIGRpZEZhaWwoaW50IGNvZGUpOworCitwcml2YXRlOgorICAg IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzKTsKKyAg ICBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmlu ZyYgbW9kZSk7CisKKyAgICBzdHJ1Y3QgRGlyZWN0b3J5RW50cnkgeworICAgICAgICBEaXJlY3Rv cnlFbnRyeShjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpCisgICAgICAgICAg ICA6IG5hbWUobmFtZSkKKyAgICAgICAgICAgICwgaXNEaXJlY3RvcnkoaXNEaXJlY3RvcnkpCisg ICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIFN0cmluZyBuYW1lOworICAgICAgICBib29s IGlzRGlyZWN0b3J5OworICAgIH07CisKKyAgICBib29sIG1fc3luY2hyb25vdXM7CisgICAgU3Ry aW5nIG1fdGFza01vZGU7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIE93blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IG1fY2FsbGJhY2tzOworICAgIFZlY3RvcjxEaXJlY3RvcnlFbnRyeT4gbV9kaXJlY3RvcnlF bnRyaWVzOworfTsKKworfSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZ U1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc19oCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCmluZGV4IGMx ZGIwMDZhODQ4ZjM5MjZkZDlmZWMzMWY5NjRhMGZkYmRhZjY5ZmMuLmIzNzNiZjk3YmVhMTdkM2Y0 ZjFkMjNkZTg3NTJjMzM2ZDQ1NDBlZjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCkBAIC0xLDQgKzEsNSBAQAogLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAq IENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgog ICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKQEAgLTE4LDI3ICsxOSw3NCBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1HdGsuaCIKIAogI2lmIEVOQUJMRShGSUxFX1NZ U1RFTSkKIAotI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUd0ay5oIgotCi0jaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJHdGsuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRh c2suaCIKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCi0jaW5jbHVkZSAiTm90SW1wbGVtZW50 ZWQuaCIKKyNpbmNsdWRlICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0u aCIKKyNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgor I2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3Ry aW5nLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKK3N0YXRpYyBGaWxlRXJyb3I6OkVycm9yQ29kZSB0b0ZpbGVFcnJvckNvZGUo R0Vycm9yKiBlcnJvcikKK3sKKyAgICBBU1NFUlQoZXJyb3IpOworCisgICAgRmlsZUVycm9yOjpF cnJvckNvZGUgZXJyb3JDb2RlOworICAgIHN3aXRjaCAoZXJyb3ItPmNvZGUpIHsKKyAgICBjYXNl IEdfSU9fRVJST1JfRVhJU1RTOgorICAgIGNhc2UgR19JT19FUlJPUl9OT1RfRU1QVFk6CisgICAg ICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSOworICAg ICAgICBicmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1JfSVNfRElSRUNUT1JZOgorICAgIGNhc2Ug R19JT19FUlJPUl9XT1VMRF9SRUNVUlNFOgorICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6 OlRZUEVfTUlTTUFUQ0hfRVJSOworICAgICAgICBicmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1Jf V09VTERfTUVSR0U6CisgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6UEFUSF9FWElTVFNf RVJSOworICAgICAgICBicmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAg IGRlZmF1bHQ6CisgICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUjsK KyAgICB9CisgICAgcmV0dXJuIGVycm9yQ29kZTsKK30KKworc3RhdGljIEZpbGVFcnJvcjo6RXJy b3JDb2RlIHZhbGlkYXRlRmlsZVR5cGUoR0ZpbGUqIHNvdXJjZUZpbGUsIEdGaWxlKiBkZXN0aW5h dGlvbkZpbGUpCit7CisgICAgR0ZpbGVUeXBlIHNvdXJjZUZpbGVUeXBlID0gZ19maWxlX3F1ZXJ5 X2ZpbGVfdHlwZShzb3VyY2VGaWxlLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwKTsKKyAgICBH RmlsZVR5cGUgZGVzdGluYXRpb25GaWxlVHlwZSA9IGdfZmlsZV9xdWVyeV9maWxlX3R5cGUoZGVz dGluYXRpb25GaWxlLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwKTsKKyAgICBpZiAoZGVzdGlu YXRpb25GaWxlVHlwZSAhPSBHX0ZJTEVfVFlQRV9VTktOT1dOKSB7CisgICAgICAgIGlmIChzb3Vy Y2VGaWxlVHlwZSAhPSBkZXN0aW5hdGlvbkZpbGVUeXBlKSB7CisgICAgICAgICAgICAvLyBGSVhN RTogRmlsZUVycm9yOjpUWVBFX01JU01BVENIX0VSUj8gSWYgc28sIGZhaWxlZCBvbiBmYXN0L2Zp bGVzeXN0ZW0vb3AtbW92ZS5odG1sCisgICAgICAgICAgICByZXR1cm4gRmlsZUVycm9yOjpJTlZB TElEX01PRElGSUNBVElPTl9FUlI7CisgICAgICAgIH0KKyAgICAgICAgaWYgKGRlc3RpbmF0aW9u RmlsZVR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZICYmICFnX2ZpbGVfZGVsZXRlKGRlc3Rp bmF0aW9uRmlsZSwgMCwgMCkpIHsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBGaWxlRXJyb3I6OlBB VEhfRVhJU1RTX0VSUj8gSWYgc28sIGZhaWxlZCBvbiBmYXN0L2ZpbGVzeXN0ZW0vb3AtbW92ZS5o dG1sCisgICAgICAgICAgICByZXR1cm4gRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9F UlI7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIEZpbGVFcnJvcjo6T0s7Cit9CisKIGJv b2wgQXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSgpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKLSAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIGJvb2wgQXN5bmNG aWxlU3lzdGVtOjppc1ZhbGlkVHlwZShUeXBlIHR5cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKLSAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIHR5cGUgPT0gVGVtcG9yYXJ5IHx8IHR5 cGUgPT0gUGVyc2lzdGVudDsKIH0KIAogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5j RmlsZVN5c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkKQEAgLTQ4LDg3ICs5NiwzNzkgQEAgUGFzc093 blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkK IAogdm9pZCBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFz ZVBhdGgsIGNvbnN0IFN0cmluZyYgc3RvcmFnZUlkZW50aWZpZXIsIFR5cGUgdHlwZSwgYm9vbCwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwotICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChOT1RfU1VQUE9SVEVEX0VS Uik7CisgICAgU3RyaW5nIHR5cGVTdHJpbmcgPSAodHlwZSA9PSBBc3luY0ZpbGVTeXN0ZW06OlBl cnNpc3RlbnQpID8gIlBlcnNpc3RlbnQiIDogIlRlbXBvcmFyeSI7CisgICAgU3RyaW5nIG5hbWUg PSBzdG9yYWdlSWRlbnRpZmllciArICI6IiArIHR5cGVTdHJpbmc7CisKKyAgICBjYWxsYmFja3Mt PmRpZE9wZW5GaWxlU3lzdGVtKG5hbWUsIEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHR5cGUpKTsK IH0KIAogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVSTChjb25zdCBLVVJM JiB1cmwsIEFzeW5jRmlsZVN5c3RlbTo6VHlwZSYgdHlwZSwgU3RyaW5nJiBmaWxlUGF0aCkKIHsK LSAgICBub3RJbXBsZW1lbnRlZCgpOwogICAgIHJldHVybiBmYWxzZTsKIH0KIAogQXN5bmNGaWxl U3lzdGVtR3RrOjpBc3luY0ZpbGVTeXN0ZW1HdGsoQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUp CiAgICAgOiBBc3luY0ZpbGVTeXN0ZW0odHlwZSkKKyAgICAsIG1fbG9jYWxGaWxlU3lzdGVtQmFz ZVBhdGgoTG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5maWxlU3lzdGVtQmFzZVBh dGgoKSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCiBBc3luY0ZpbGVTeXN0ZW1HdGs6 On5Bc3luY0ZpbGVTeXN0ZW1HdGsoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIFN0 cmluZyBBc3luY0ZpbGVTeXN0ZW1HdGs6OnRvVVJMKGNvbnN0IFN0cmluZyYgb3JpZ2luU3RyaW5n LCBjb25zdCBTdHJpbmcmIGZ1bGxQYXRoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAg cmV0dXJuIFN0cmluZygpOworICAgIEFTU0VSVCghb3JpZ2luU3RyaW5nLmlzRW1wdHkoKSk7Cisg ICAgaWYgKG9yaWdpblN0cmluZyA9PSBTdHJpbmcoIm51bGwiKSkKKyAgICAgICAgcmV0dXJuIFN0 cmluZygpOworCisgICAgU3RyaW5nQnVpbGRlciByZXN1bHQ7CisgICAgcmVzdWx0LmFwcGVuZCgi ZmlsZXN5c3RlbToiKTsKKyAgICByZXN1bHQuYXBwZW5kKG9yaWdpblN0cmluZyk7CisgICAgcmVz dWx0LmFwcGVuZCgiLyIpOworICAgIGlmICh0eXBlKCkgPT0gVGVtcG9yYXJ5KQorICAgICAgICBy ZXN1bHQuYXBwZW5kKHRlbXBvcmFyeVBhdGhQcmVmaXgpOworICAgIGVsc2UgaWYgKHR5cGUoKSA9 PSBQZXJzaXN0ZW50KQorICAgICAgICByZXN1bHQuYXBwZW5kKHBlcnNpc3RlbnRQYXRoUHJlZml4 KTsKKyAgICBlbHNlIHsKKyAgICAgICAgQVNTRVJUKHR5cGUoKSA9PSBUZW1wb3JhcnkgfHwgdHlw ZSgpID09IFBlcnNpc3RlbnQpOworICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisgICAgfQorCisg ICAgcmVzdWx0LmFwcGVuZChlbmNvZGVXaXRoVVJMRXNjYXBlU2VxdWVuY2VzKGZ1bGxQYXRoKSk7 CisKKyAgICByZXR1cm4gcmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK3N0YXRpYyB2b2lkIG1vdmVB c3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBzcmNQYXRoLCBTdHJpbmcmIGRl c3RQYXRoKQoreworICAgIEdSZWZQdHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19m aWxlX25ld19mb3JfcGF0aChzcmNQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdG aWxlPiBkZXN0aW5hdGlvbkZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0 UGF0aC51dGY4KCkuZGF0YSgpKSk7CisKKyAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNv ZGUgPSB2YWxpZGF0ZUZpbGVUeXBlKHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5n ZXQoKSk7CisgICAgaWYgKGVycm9yQ29kZSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRp ZEZhaWwoZXJyb3JDb2RlKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8 R0Vycm9yPiBlcnJvcjsKKyAgICBnX2ZpbGVfbW92ZShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5h dGlvbkZpbGUuZ2V0KCksIEdfRklMRV9DT1BZX09WRVJXUklURSwgMCwgMCwgMCwgJmVycm9yLm91 dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRG YWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CiB9CiAKIHZvaWQgQXN5bmNG aWxlU3lzdGVtR3RrOjptb3ZlKGNvbnN0IFN0cmluZyYgc291cmNlUGF0aCwgY29uc3QgU3RyaW5n JiBkZXN0aW5hdGlvblBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBj YWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgc291cmNlRmls ZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChzb3VyY2VQYXRoKTsKKyAg ICBTdHJpbmcgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lz dGVtVVJMKGRlc3RpbmF0aW9uUGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9s bGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFp blRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm1vdmVBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2Rl KSwgc291cmNlRmlsZVN5c3RlbVBhdGgsIGRlc3RpbmF0aW9uRmlsZVN5c3RlbVBhdGgpKTsKK30K Kworc3RhdGljIHZvaWQgY29weVJlY3Vyc2l2ZWx5KEdGaWxlKiBzb3VyY2VEaXJlY3RvcnksIEdG aWxlKiBkZXN0aW5hdGlvbkRpcmVjdG9yeSwgR0Vycm9yKiogZXJyb3IpCit7CisgICAgQVNTRVJU KGdfZmlsZV9xdWVyeV9maWxlX3R5cGUoc291cmNlRGlyZWN0b3J5LCBHX0ZJTEVfUVVFUllfSU5G T19OT05FLCAwKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpOworCisgICAgaWYgKCFnX2ZpbGVf bWFrZV9kaXJlY3RvcnkoZGVzdGluYXRpb25EaXJlY3RvcnksIDAsIGVycm9yKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgR1JlZlB0cjxHRmlsZUVudW1lcmF0b3I+IGZpbGVFbnVtZXJhdG9yID0g YWRvcHRHUmVmKGdfZmlsZV9lbnVtZXJhdGVfY2hpbGRyZW4oc291cmNlRGlyZWN0b3J5LCBHX0ZJ TEVfQVRUUklCVVRFX1NUQU5EQVJEX05BTUUsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIGVy cm9yKSk7CisgICAgaWYgKCplcnJvcikKKyAgICAgICAgcmV0dXJuOworCisgICAgd2hpbGUgKEdS ZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfZW51bWVyYXRvcl9u ZXh0X2ZpbGUoZmlsZUVudW1lcmF0b3IuZ2V0KCksIDAsIGVycm9yKSkpIHsKKyAgICAgICAgY29u c3QgY2hhciogZGlyZWN0b3J5RW50cnlOYW1lID0gZ19maWxlX2luZm9fZ2V0X25hbWUoZmlsZUlu Zm8uZ2V0KCkpOworICAgICAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxlID0gYWRvcHRHUmVm KGdfZmlsZV9nZXRfY2hpbGQoc291cmNlRGlyZWN0b3J5LCBkaXJlY3RvcnlFbnRyeU5hbWUpKTsK KyAgICAgICAgR1JlZlB0cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmls ZV9nZXRfY2hpbGQoZGVzdGluYXRpb25EaXJlY3RvcnksIGRpcmVjdG9yeUVudHJ5TmFtZSkpOwor CisgICAgICAgIGlmIChnX2ZpbGVfcXVlcnlfZmlsZV90eXBlKHNvdXJjZUZpbGUuZ2V0KCksIEdf RklMRV9RVUVSWV9JTkZPX05PTkUsIDApID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkKKyAgICAg ICAgICAgIGNvcHlSZWN1cnNpdmVseShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUu Z2V0KCksIGVycm9yKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgZ19maWxlX2NvcHkoc291 cmNlRmlsZS5nZXQoKSwgZGVzdGluYXRpb25GaWxlLmdldCgpLCBHX0ZJTEVfQ09QWV9OT05FLCAw LCAwLCAwLCBlcnJvcik7CisKKyAgICAgICAgaWYgKCplcnJvcikKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlBc3luYyhTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxi YWNrcywgU3RyaW5nJiBzb3VyY2VQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQoreworICAgIEdSZWZQ dHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChzb3Vy Y2VQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBkZXN0aW5hdGlvbkZp bGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51dGY4KCkuZGF0YSgp KSk7CisKKyAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNvZGUgPSB2YWxpZGF0ZUZpbGVU eXBlKHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSk7CisgICAgaWYgKGVy cm9yQ29kZSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3JDb2RlKTsK KyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAg ICBpZiAoZ19maWxlX3F1ZXJ5X2ZpbGVfdHlwZShzb3VyY2VGaWxlLmdldCgpLCBHX0ZJTEVfUVVF UllfSU5GT19OT05FLCAwKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpIHsKKyAgICAgICAgY29w eVJlY3Vyc2l2ZWx5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgJmVy cm9yLm91dFB0cigpKTsKKyAgICAgICAgaWYgKGVycm9yKQorICAgICAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICBl bHNlCisgICAgICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIGdfZmlsZV9jb3B5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3Rp bmF0aW9uRmlsZS5nZXQoKSwgR19GSUxFX0NPUFlfT1ZFUldSSVRFLCAwLCAwLCAwLCAmZXJyb3Iu b3V0UHRyKCkpOworICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRp ZEZhaWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3lu Y0ZpbGVTeXN0ZW1HdGs6OmNvcHkoY29uc3QgU3RyaW5nJiBzb3VyY2VQYXRoLCBjb25zdCBTdHJp bmcmIGRlc3RpbmF0aW9uUGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBzb3VyY2VG aWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHNvdXJjZVBhdGgpOwor ICAgIFN0cmluZyBkZXN0aW5hdGlvbkZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVT eXN0ZW1VUkwoZGVzdGluYXRpb25QYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRy b2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9N YWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmY29weUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1v ZGUpLCBzb3VyY2VGaWxlU3lzdGVtUGF0aCwgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCkpOwor fQorCitzdGF0aWMgdm9pZCByZW1vdmVGaWxlUmVjdXJzaXZlbHkoR0ZpbGUqIGZpbGUsIGJvb2wg cmVjdXJzaXZlLCBHRXJyb3IqKiBlcnJvcikKK3sKKyAgICBHT3duUHRyPGdjaGFyPiBmaWxlUGF0 aChnX2ZpbGVfZ2V0X3BhdGgoZmlsZSkpOworICAgIGlmIChyZWN1cnNpdmUgJiYgZ19maWxlX3Rl c3QoZmlsZVBhdGguZ2V0KCksIEdfRklMRV9URVNUX0lTX0RJUikpIHsKKyAgICAgICAgR1JlZlB0 cjxHRmlsZUVudW1lcmF0b3I+IGZpbGVFbnVtZXJhdG9yID0gYWRvcHRHUmVmKGdfZmlsZV9lbnVt ZXJhdGVfY2hpbGRyZW4oZmlsZSwgR19GSUxFX0FUVFJJQlVURV9TVEFOREFSRF9OQU1FLCBHX0ZJ TEVfUVVFUllfSU5GT19OT05FLCAwLCBlcnJvcikpOworICAgICAgICBpZiAoKmVycm9yKQorICAg ICAgICAgICAgcmV0dXJuOworCisgICAgICAgIHdoaWxlIChHUmVmUHRyPEdGaWxlSW5mbz4gZmls ZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX2VudW1lcmF0b3JfbmV4dF9maWxlKGZpbGVFbnVtZXJh dG9yLmdldCgpLCAwLCBlcnJvcikpKSB7CisgICAgICAgICAgICBHUmVmUHRyPEdGaWxlPiBjaGls ZCA9IGFkb3B0R1JlZihnX2ZpbGVfZ2V0X2NoaWxkKGZpbGUsIGdfZmlsZV9pbmZvX2dldF9uYW1l KGZpbGVJbmZvLmdldCgpKSkpOworICAgICAgICAgICAgcmVtb3ZlRmlsZVJlY3Vyc2l2ZWx5KGNo aWxkLmdldCgpLCByZWN1cnNpdmUsIGVycm9yKTsKKyAgICAgICAgICAgIGlmICgqZXJyb3IpCisg ICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgZ19maWxlX2Rl bGV0ZShmaWxlLCAwLCBlcnJvcik7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92ZUFzeW5jKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGZpbGVQYXRoLCBib29sIHJlY3Vyc2l2ZSkKK3sK KyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0cjxHRmlsZT4gZmlsZSA9IGFk b3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAg ICByZW1vdmVGaWxlUmVjdXJzaXZlbHkoZmlsZS5nZXQoKSwgcmVjdXJzaXZlLCAmZXJyb3Iub3V0 UHRyKCkpOworICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZh aWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0Zp bGVTeXN0ZW1HdGs6OnJlbW92ZShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsK KyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChw YXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsK KworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxi YWNrVGFzaygmcmVtb3ZlQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRl KG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRo LCBmYWxzZSkpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVjdXJzaXZl bHkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVT eXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5n IG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250 cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlbW92ZUFz eW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVy LmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgdHJ1ZSkpOworfQorCitz dGF0aWMgdm9pZCByZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3Ry aW5nJiBmaWxlUGF0aCkKK3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0 cjxHRmlsZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0 ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdS ZWYoZ19maWxlX3F1ZXJ5X2luZm8oZmlsZS5nZXQoKSwgInN0YW5kYXJkOjoqLHRpbWU6OioiLCBH X0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJy b3IpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShl cnJvci5nZXQoKSkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgRmlsZU1ldGFkYXRh OjpUeXBlIHR5cGUgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgpKSA9 PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkgPyBGaWxlTWV0YWRhdGE6OlR5cGVEaXJlY3RvcnkgOiBG aWxlTWV0YWRhdGE6OlR5cGVGaWxlOworCisgICAgR1RpbWVWYWwgdGltZVZhbHVlOworICAgIGdf ZmlsZV9pbmZvX2dldF9tb2RpZmljYXRpb25fdGltZShmaWxlSW5mby5nZXQoKSwgJnRpbWVWYWx1 ZSk7CisKKyAgICBHT3duUHRyPGdjaGFyPiBwYXRoKGdfZmlsZV9nZXRfcGF0aChmaWxlLmdldCgp KSk7CisKKyAgICBGaWxlTWV0YWRhdGEgbWV0YWRhdGE7CisgICAgbWV0YWRhdGEudHlwZSA9IHR5 cGU7CisgICAgbWV0YWRhdGEubW9kaWZpY2F0aW9uVGltZSA9IHN0YXRpY19jYXN0PGRvdWJsZT4o dGltZVZhbHVlLnR2X3NlYyk7CisgICAgbWV0YWRhdGEubGVuZ3RoID0gdHlwZSA9PSBGaWxlTWV0 YWRhdGE6OlR5cGVGaWxlID8gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRf c2l6ZShmaWxlSW5mby5nZXQoKSkpIDogMDsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBT dHJpbmcocGF0aC5nZXQoKSk7CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFJlYWRNZXRhZGF0 YShtZXRhZGF0YSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFkTWV0YWRhdGEo Y29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4g Y2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0 ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1v ZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9s bGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlYWRNZXRhZGF0 YUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9s bGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCkpOworfQorCitzdGF0 aWMgdm9pZCBjcmVhdGVPYmplY3RBbmRSZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25D b250ZXh0KiBjb250ZXh0LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4g aGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGxvY2FsRmlsZVN5c3RlbVBhdGgsIFN0cmluZyYgYWJz b2x1dGVQYXRoLCBHRmlsZVR5cGUgdHlwZSwgYm9vbCBuZWVkVG9SZWFkTWV0YWRhdGEpCit7Cisg ICAgQVNTRVJUKHR5cGUgPT0gR19GSUxFX1RZUEVfUkVHVUxBUiB8fCB0eXBlID09IEdfRklMRV9U WVBFX0RJUkVDVE9SWSk7CisgICAgLy8gV2Ugc2hvdWxkIG5vdCBhbGxvdyB0byBhY2Nlc3MgdXBw ZXIgZGlyZWN0b3J5IHRvIGNyZWF0ZSBhIG5ldyBmaWxlIHRoYW4gYmFzZSBkaXJlY3RvcnkKKyAg ICAvLyBiZWNhdXNlIG9mIHRoZSBzZWN1cml0eSBpc3N1ZS4KKyAgICBpZiAodHlwZSA9PSBHX0ZJ TEVfVFlQRV9SRUdVTEFSICYmIGFic29sdXRlUGF0aCA9PSBTdHJpbmcoIi8iKSkgeworICAgICAg ICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpTRUNVUklUWV9FUlIpOworICAg ICAgICByZXR1cm47CisgICAgfQorCisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdS ZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChsb2NhbEZp bGVTeXN0ZW1QYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQ RV9SRUdVTEFSKQorICAgICAgICBHUmVmUHRyPEdGaWxlT3V0cHV0U3RyZWFtPiBvdXRwdXRTdHJl YW0gPSBhZG9wdEdSZWYoZ19maWxlX2NyZWF0ZShmaWxlLmdldCgpLCBHX0ZJTEVfQ1JFQVRFX05P TkUsIDAsICZlcnJvci5vdXRQdHIoKSkpOworICAgIGlmICh0eXBlID09IEdfRklMRV9UWVBFX0RJ UkVDVE9SWSkKKyAgICAgICAgZ19maWxlX21ha2VfZGlyZWN0b3J5KGZpbGUuZ2V0KCksIDAsICZl cnJvci5vdXRQdHIoKSk7CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGlmICghbmVlZFRvUmVh ZE1ldGFkYXRhIHx8IGVycm9yLT5jb2RlICE9IEdfSU9fRVJST1JfRVhJU1RTKSB7CisgICAgICAg ICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgp KSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAobmVl ZFRvUmVhZE1ldGFkYXRhKSB7CisgICAgICAgIHJlYWRNZXRhZGF0YUFzeW5jKGNvbnRleHQsIGhl bHBlckNhbGxiYWNrcywgbG9jYWxGaWxlU3lzdGVtUGF0aCk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7Cit9CisKK3ZvaWQgQXN5bmNG aWxlU3lzdGVtR3RrOjpjcmVhdGVPYmplY3RBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBh YnNvbHV0ZVBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFj a3MsIEdGaWxlVHlwZSB0eXBlLCBib29sIG5lZWRUb1JlYWRNZXRhZGF0YSkKK3sKKyAgICBTdHJp bmcgbG9jYWxGaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGFic29s dXRlUGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2Rl KCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVD YWxsYmFja1Rhc2soJmNyZWF0ZU9iamVjdEFuZFJlYWRNZXRhZGF0YUFzeW5jLCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFj a3MsIG1vZGUpLCBsb2NhbEZpbGVTeXN0ZW1QYXRoLCBhYnNvbHV0ZVBhdGgsIHR5cGUsIG5lZWRU b1JlYWRNZXRhZGF0YSkpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmls ZShjb25zdCBTdHJpbmcmIGFic29sdXRlUGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY3JlYXRlT2JqZWN0 QW5kUmVhZE1ldGFkYXRhKGFic29sdXRlUGF0aCwgY2FsbGJhY2tzLCBHX0ZJTEVfVFlQRV9SRUdV TEFSKTsKIH0KIAotdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZUZpbGUoY29uc3QgU3Ry aW5nJiBwYXRoLCBib29sIGV4Y2x1c2l2ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3M+IGNhbGxiYWNrcykKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3Rv cnkoY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVu dGVkKCk7CisgICAgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGFic29sdXRlUGF0aCwgY2Fs bGJhY2tzLCBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpOwogfQogCi12b2lkIEFzeW5jRmlsZVN5c3Rl bUd0azo6Y3JlYXRlRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgYm9vbCBleGNsdXNpdmUs IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCitzdGF0aWMg dm9pZCBvYmplY3RFeGlzdHNBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBw YXRoLCBHRmlsZVR5cGUgdHlwZSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIEdSZWZQ dHI8R0ZpbGU+IG9iamVjdCA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHBhdGgudXRm OCgpLmRhdGEoKSkpOworICAgIEdGaWxlVHlwZSBvYmplY3RUeXBlID0gZ19maWxlX3F1ZXJ5X2Zp bGVfdHlwZShvYmplY3QuZ2V0KCksIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDApOworICAgIGlm IChvYmplY3RUeXBlID09IEdfRklMRV9UWVBFX1VOS05PV04pIHsKKyAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisgICAgaWYgKG9iamVjdFR5cGUgIT0gdHlwZSkgeworICAgICAgICBoZWxwZXJD YWxsYmFja3MtPmRpZEZhaWwoRmlsZUVycm9yOjpUWVBFX01JU01BVENIX0VSUik7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0K IAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmZpbGVFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRo LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAg IG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBh dGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9s bGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFp blRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm9iamVjdEV4aXN0c0FzeW5jLCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFj a3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgR19GSUxFX1RZUEVfUkVHVUxBUikpOwogfQogCiB2 b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6ZGlyZWN0b3J5RXhpc3RzKGNvbnN0IFN0cmluZyYgcGF0 aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAg ICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQ YXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJv bGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01h aW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZvYmplY3RFeGlzdHNBc3luYywgQXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJh Y2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgsIEdfRklMRV9UWVBFX0RJUkVDVE9SWSkpOworfQor CitzdGF0aWMgdm9pZCByZWFkRGlyZWN0b3J5QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCos IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBjYWxsYmFja3MsIFN0cmlu ZyYgcGF0aCkKK3sKKyAgICBBU1NFUlQoZ19maWxlX3Rlc3QocGF0aC51dGY4KCkuZGF0YSgpLCBH X0ZJTEVfVEVTVF9JU19ESVIpKTsKKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBH UmVmUHRyPEdGaWxlPiBkaXJlY3RvcnkgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChw YXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlRW51bWVyYXRvcj4gZmlsZUVu dW1lcmF0b3IgPSBhZG9wdEdSZWYoZ19maWxlX2VudW1lcmF0ZV9jaGlsZHJlbihkaXJlY3Rvcnku Z2V0KCksIEdfRklMRV9BVFRSSUJVVEVfU1RBTkRBUkRfTkFNRSwgR19GSUxFX1FVRVJZX0lORk9f Tk9ORSwgMCwgJmVycm9yLm91dFB0cigpKSk7CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGNh bGxiYWNrcy0+ZGlkRmFpbCh0b0ZpbGVFcnJvckNvZGUoZXJyb3IuZ2V0KCkpKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIHdoaWxlIChHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8g PSBhZG9wdEdSZWYoZ19maWxlX2VudW1lcmF0b3JfbmV4dF9maWxlKGZpbGVFbnVtZXJhdG9yLmdl dCgpLCAwLCAmZXJyb3Iub3V0UHRyKCkpKSkgeworICAgICAgICBTdHJpbmcgbmFtZShnX2ZpbGVf aW5mb19nZXRfbmFtZShmaWxlSW5mby5nZXQoKSkpOworICAgICAgICBib29sIGlzRGlyZWN0b3J5 ID0gZ19maWxlX2luZm9fZ2V0X2ZpbGVfdHlwZShmaWxlSW5mby5nZXQoKSkgPT0gR19GSUxFX1RZ UEVfRElSRUNUT1JZOworICAgICAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3RvcnlFbnRyeShu YW1lLCBpc0RpcmVjdG9yeSk7CisgICAgfQorICAgIGlmIChlcnJvcikKKyAgICAgICAgY2FsbGJh Y2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworCisgICAgY2FsbGJh Y2tzLT5kaWRSZWFkRGlyZWN0b3J5RW50cmllcyhmYWxzZSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxl U3lzdGVtR3RrOjpyZWFkRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVt VVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9k ZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRl Q2FsbGJhY2tUYXNrKCZyZWFkRGlyZWN0b3J5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZp bGVTeXN0ZW1QYXRoKSk7CiB9CiAKK3N0YXRpYyB2b2lkIGNyZWF0ZVdyaXRlckFzeW5jKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 az4gaGVscGVyQ2FsbGJhY2tzLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBTdHJpbmcmIHBhdGgp Cit7CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUg PSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChwYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAg ICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2lu Zm8oZmlsZS5nZXQoKSwgR19GSUxFX0FUVFJJQlVURV9TVEFOREFSRF9TSVpFLCBHX0ZJTEVfUVVF UllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAg ICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQo KSkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgbG9uZyBsb25nIGZpbGVTaXplID0g c3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5nZXQo KSkpOworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcihBc3luY0ZpbGVX cml0ZXJHdGs6OmNyZWF0ZShjbGllbnQsIHRhc2tDb250cm9sbGVyLCBmaWxlLmxlYWtSZWYoKSks IGZpbGVTaXplKTsKK30KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcihB c3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxl bWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVT eXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlx dWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChj cmVhdGVDYWxsYmFja1Rhc2soJmNyZWF0ZVdyaXRlckFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUp LCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKGNsaWVudCksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3Mo bV90YXNrQ29udHJvbGxlci5nZXQoKSksIGZpbGVTeXN0ZW1QYXRoKSk7Cit9CisKK3ZvaWQgQXN5 bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3Qg U3RyaW5nJiBhYnNvbHV0ZVBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjYWxsYmFja3MpCit7CisgICAgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGFic29sdXRl UGF0aCwgY2FsbGJhY2tzLCBHX0ZJTEVfVFlQRV9SRUdVTEFSLCB0cnVlKTsKK30KKwordm9pZCBB c3luY0ZpbGVTeXN0ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKFBhc3NSZWZQdHI8QXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IHRhc2tDb250cm9sbGVyKQoreworICAgIG1fdGFza0Nv bnRyb2xsZXIgPSB0YXNrQ29udHJvbGxlcjsKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbUd0 azo6dmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwoY29uc3QgU3RyaW5nJiB2aXJ0dWFsUGF0aCkK K3sKKyAgICByZXR1cm4gdmlydHVhbFBhdGggIT0gU3RyaW5nKCIvIikgPyBtX2xvY2FsRmlsZVN5 c3RlbUJhc2VQYXRoICsgdmlydHVhbFBhdGggOiBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoOwor fQorCitib29sIEFzeW5jRmlsZVN5c3RlbUd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUo KQoreworICAgIHJldHVybiBtX3Rhc2tDb250cm9sbGVyLT53YWl0Rm9yT3BlcmF0aW9uVG9Db21w bGV0ZSgpOwogfQogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmgKaW5kZXggY2I0NWI2ZWE0YmMyMDIw ZThlYjRjOGViNWExOThmMDc2ZjVhNjk3Yi4uZDkxOTQ0MzVkMDljZTc0MjVkNDM4NDFlMWFjYjMz MjNjMDJlMDMwYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbUd0ay5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1HdGsuaApAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTIg Q2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAx MSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAqCiAgKiBUaGlzIGxpYnJh cnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGlj CkBAIC0yMywxMSArMjMsMTMgQEAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiAKICNpbmNsdWRl ICJBc3luY0ZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CiAjaW5jbHVkZSA8d3Rm L1Bhc3NPd25QdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3M7CitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azsK IAogY2xhc3MgQXN5bmNGaWxlU3lzdGVtR3RrIDogcHVibGljIEFzeW5jRmlsZVN5c3RlbSB7CiBw dWJsaWM6CkBAIC00Niw2ICs0OCwxNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRpcmVj dG9yeUV4aXN0cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzPik7CiAgICAgdmlydHVhbCB2b2lkIHJlYWREaXJlY3RvcnkoY29uc3QgU3RyaW5n JiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwogICAgIHZpcnR1 YWwgdm9pZCBjcmVhdGVXcml0ZXIoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiwgY29uc3QgU3RyaW5n JiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZpcnR1 YWwgdm9pZCBjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBw YXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZpcnR1YWwg Ym9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworCisgICAgdm9pZCBzZXRUYXNrQ29u dHJvbGxlcihQYXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPik7Citw cml2YXRlOgorICAgIHZvaWQgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGNvbnN0IFN0cmlu ZyYgYWJzb2x1dGVQYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIEdG aWxlVHlwZSwgYm9vbCBuZWVkVG9SZWFkTWV0YWRhdGEgPSBmYWxzZSk7CisgICAgU3RyaW5nIHZp cnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGNvbnN0IFN0cmluZyYpOworCisgICAgU3RyaW5nIG1f bG9jYWxGaWxlU3lzdGVtQmFzZVBhdGg7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZThhNjkwNWM5 MmRlZWZiMzA5NTNiMDVjZGU4YjU0ZTc2Zjk3MDFmMAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5j cHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJz ZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBz b2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAq IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2Vy IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGlj CisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRo ZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQs IEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisK K1Bhc3NSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4dCwgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKGNvbnRleHQsIHN5bmNocm9ub3VzKSk7Cit9CisK K0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBib29sIHN5bmNocm9u b3VzKQorICAgIDogbV9jb250ZXh0KGNvbnRleHQpCisgICAgLCBtX3N5bmNocm9ub3VzKHN5bmNo cm9ub3VzKQorICAgICwgbV9jdXJyZW50VGFza01vZGUoIiIpCisgICAgLCBtX3dyaXRlclRvQ2Fu Y2VsKDApCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxl c3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworfQorCitB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6fkFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrKCkKK3sKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrOjp1bmlxdWVNb2RlKCkKK3sKKyAgICAvLyBGSVhNRTogV2UgZG9uJ3Qgc3VwcG9ydCB3b2tl cnMgZm9yIGZpbGVzeXN0ZW0geWV0LgorICAgIEFTU0VSVChtX2NvbnRleHQtPmlzRG9jdW1lbnQo KSk7CisgICAgcmV0dXJuIFN0cmluZygpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjpwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ6OlRhc2s+IHRhc2spCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBv cnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0Rv Y3VtZW50KCkpOworICAgIG1fY29udGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK3ZvaWQgQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBT dHJpbmcmIHRhc2tNb2RlKQoreworICAgIG1fY3VycmVudFRhc2tNb2RlID0gdGFza01vZGU7Cit9 CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBvc3RDYWxsYmFja1Rh c2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBT dHJpbmcmIG1vZGUpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZv ciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOwor ICAgIG1fY29udGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK2Jvb2wgQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAgICBB U1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFTU0VSVCghbV9zeW5jaHJvbm91 cyk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrOjpjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeShBc3luY0ZpbGVXcml0ZXJHdGsqIHdy aXRlcikKK3sKKyAgICBpZiAobV93cml0ZXJUb0NhbmNlbCA9PSB3cml0ZXIpIHsKKyAgICAgICAg bV93cml0ZXJUb0NhbmNlbCA9IDA7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgICBy ZXR1cm4gZmFsc2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVO QUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u Y2JmMmQ5OWQyZTJjYmU3MGIwOGQ1YmQzMDk3NWFjZThmMDc5N2E2YwotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0ay5oCkBAIC0wLDAgKzEsNjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFu IERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICog TGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0 aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55 IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAq IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICog WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFs IFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0 ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLwor CisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKyNkZWZpbmUgQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaAorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVN KQorCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5jbHVkZSA8d3Rm L1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkU2FmZVJlZkNvdW50ZWQuaD4KKyNp bmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3Mg QXN5bmNGaWxlV3JpdGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0ayA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0az4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPEFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrPiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJv b2wgc3luY2hyb25vdXMpOworICAgIH5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0aygp OworCisgICAgdm9pZCBwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ6OlRhc2s+KTsKKyAgICB2b2lkIHNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBT dHJpbmcmKTsKKyAgICB2b2lkIHBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxTY3JpcHRFeGVj dXRpb25Db250ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5nJik7CisgICAgYm9vbCB3YWl0Rm9yT3Bl cmF0aW9uVG9Db21wbGV0ZSgpOworICAgIGJvb2wgc3luY2hyb25vdXMoKSB7IHJldHVybiBtX3N5 bmNocm9ub3VzOyB9CisKKyAgICBib29sIGNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KEFzeW5jRmls ZVdyaXRlckd0ayopOworICAgIHZvaWQgc2V0V3JpdGVyVG9DYW5jZWwoQXN5bmNGaWxlV3JpdGVy R3RrKiB3cml0ZXIpIHsgbV93cml0ZXJUb0NhbmNlbCA9IHdyaXRlcjsgfQorCisgICAgU3RyaW5n IHVuaXF1ZU1vZGUoKTsKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wpOworCisgICAgU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCogbV9jb250ZXh0OworICAgIGJvb2wgbV9zeW5jaHJvbm91czsKKyAgICBTdHJp bmcgbV9jdXJyZW50VGFza01vZGU7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJHdGsqIG1fd3JpdGVy VG9DYW5jZWw7Cit9OworCit9IC8vIG5hbWVzcGFjZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVf U1lTVEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNs aWVudEd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVy Q2xpZW50R3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iOWZiY2EwMTg5MGQ5MGM5YWFkYThmMWUwYTUyNTY0 YjcyNjBhYmYzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHAKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2Vy IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBs aWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAw MjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2lu Y2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0YXRp YyB2b2lkIHBlcmZvcm1EaWRXcml0ZUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBB c3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgbG9uZyBsb25nIGJ5dGVzLCBib29sIGNvbXBs ZXRlKQoreworICAgIGNsaWVudC0+ZGlkV3JpdGUoYnl0ZXMsIGNvbXBsZXRlKTsKK30KKworc3Rh dGljIHZvaWQgcGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCosIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50KQoreworICAgIGNsaWVudC0+ZGlkVHJ1 bmNhdGUoKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRF eGVjdXRpb25Db250ZXh0KiwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEZpbGVFcnJv cjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAgY2xpZW50LT5kaWRGYWlsKGNvZGUpOworfQorCitB c3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayhBc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEFzeW5jRmlsZVdyaXRl ckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3Rhc2tDb250cm9s bGVyKHRhc2tDb250cm9sbGVyKQorICAgICwgbV9jbGllbnQoY2xpZW50KQorICAgICwgbV90YXNr TW9kZShtb2RlKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnNldEN1cnJlbnRUYXNrTW9kZSht X3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFdyaXRl KGxvbmcgbG9uZyBieXRlcywgYm9vbCBjb21wbGV0ZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVy LT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFdyaXRlQ2Fs bGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBieXRlcywgY29tcGxldGUp LCBtX3Rhc2tNb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFRy dW5jYXRlKCkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0 ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJl YWRBY2Nlc3MobV9jbGllbnQpKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrOjpkaWRGYWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAg bV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBl cmZvcm1EaWRGYWlsQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBj b2RlKSwgbV90YXNrTW9kZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlm IC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hNmVlMTA5ZmQ1 ZDMzOTViNjE5ODNkMmI4MWUxNmM3ZjEyMjE5YWZiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oCkBAIC0wLDAg KzEsNTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2Jl cnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIg b2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisg KgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5z ZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICog U29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9v ciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmls ZVdyaXRlckNsaWVudEd0a19oCisjZGVmaW5lIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0a19oCisK KyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNr Q29udHJvbGxlckd0ay5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVudC5oIgorCisj aW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFz cyBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsgOiBwdWJsaWMgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJDbGllbnRH dGs+IGNyZWF0ZShBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xs ZXIsIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcmIG1vZGUpCisg ICAgeworICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVdyaXRlckNsaWVudEd0 ayh0YXNrQ29udHJvbGxlciwgY2xpZW50LCBtb2RlKSk7CisgICAgfQorCisgICAgdm9pZCBkaWRX cml0ZShsb25nIGxvbmcgYnl0ZXMsIGJvb2wgY29tcGxldGUpOworICAgIHZvaWQgZGlkVHJ1bmNh dGUoKTsKKyAgICB2b2lkIGRpZEZhaWwoRmlsZUVycm9yOjpFcnJvckNvZGUpOworCisgICAgQXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyKCkgeyByZXR1cm4g bV90YXNrQ29udHJvbGxlci5nZXQoKTsgfQorCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVdyaXRl ckNsaWVudEd0ayhBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayosIEFzeW5jRmlsZVdy aXRlckNsaWVudCosIGNvbnN0IFN0cmluZyYpOworCisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIEFzeW5jRmlsZVdyaXRl ckNsaWVudCogbV9jbGllbnQ7CisgICAgU3RyaW5nIG1fdGFza01vZGU7Cit9OworCit9IC8vIG5h bWVzcGFjZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjZW5kaWYgLy8gQXN5 bmNGaWxlV3JpdGVyQ2xpZW50R3RrX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0FzeW5jRmlsZVdyaXRlckd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDU2OWFiNzM3OTEwNGEzNzJh MWMyYTM0MzYzOWE5ZmE5ODdmZTQyMwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwCkBAIC0wLDAgKzEsMTU1IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwu Y29tPgorICogQ29weXJpZ2h0IChDKSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFp bC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJv c3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5j bHVkZSAiQXN5bmNGaWxlV3JpdGVyR3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisK KyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCIKKyNpbmNsdWRlICJCbG9iLmgi CisjaW5jbHVkZSAiQmxvYlJlZ2lzdHJ5SW1wbC5oIgorI2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFz ay5oIgorCisjaW5jbHVkZSA8Z2lvL2dpby5oPgorI2luY2x1ZGUgPGdsaWIuaD4KKyNpbmNsdWRl IDx3dGYvZ29iamVjdC9HT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgor CituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyR3RrPiBB c3luY0ZpbGVXcml0ZXJHdGs6OmNyZWF0ZShBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBHRmlsZSog ZmlsZSkKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVdyaXRlckd0ayhjbGll bnQsIHRhc2tDb250cm9sbGVyLCBmaWxlKSk7Cit9CisKK0FzeW5jRmlsZVdyaXRlckd0azo6QXN5 bmNGaWxlV3JpdGVyR3RrKEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEdGaWxlKiBmaWxlKQorICAg IDogbV9jbGllbnQoY2xpZW50KQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxl cikKKyAgICAsIG1fZmlsZShmaWxlKQoreworfQorCitzdGF0aWMgdm9pZCB3cml0ZUFzeW5jKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNsaWVudEd0 az4gaGVscGVyQ2xpZW50LCBBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlciwgR0ZpbGUqIGZpbGUs IGxvbmcgbG9uZyBwb3NpdGlvbiwgQmxvYiogZGF0YSkKK3sKKyAgICBpZiAoaGVscGVyQ2xpZW50 LT50YXNrQ29udHJvbGxlcigpLT5jYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSh3cml0ZXIpKSB7Cisg ICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6OkFCT1JUX0VSUik7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IGlvU3RyZWFt ID0gYWRvcHRHUmVmKGdfZmlsZV9vcGVuX3JlYWR3cml0ZShmaWxlLCAwLCAwKSk7CisgICAgaWYg KCFpb1N0cmVhbSkgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpO T1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8R091 dHB1dFN0cmVhbT4gb3V0cHV0U3RyZWFtKGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKEdf SU9fU1RSRUFNKGlvU3RyZWFtLmdldCgpKSkpOworICAgIGlmICghZ19zZWVrYWJsZV9zZWVrKEdf U0VFS0FCTEUob3V0cHV0U3RyZWFtLmdldCgpKSwgcG9zaXRpb24sIEdfU0VFS19TRVQsIDAsIDAp KSB7CisgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9F UlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgUmVmUHRyPEJsb2JTdG9yYWdlRGF0 YT4gYmxvYlN0b3JhZ2UgPSBzdGF0aWNfY2FzdDxCbG9iUmVnaXN0cnlJbXBsJj4oYmxvYlJlZ2lz dHJ5KCkpLmdldEJsb2JEYXRhRnJvbVVSTChkYXRhLT51cmwoKSk7CisgICAgaWYgKGJsb2JTdG9y YWdlKSB7CisgICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgYmxvYlN0b3JhZ2UtPml0ZW1z KCkuc2l6ZSgpOyBpKyspIHsKKyAgICAgICAgICAgIGNvbnN0IEJsb2JEYXRhSXRlbSYgYmxvYkl0 ZW0gPSBibG9iU3RvcmFnZS0+aXRlbXMoKVtpXTsKKyAgICAgICAgICAgIGlmIChibG9iSXRlbS50 eXBlID09IEJsb2JEYXRhSXRlbTo6RGF0YSkgeworICAgICAgICAgICAgICAgIGdzaXplIGJ5dGVz V3JpdHRlbiA9IDA7CisgICAgICAgICAgICAgICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlX2FsbChH X09VVFBVVF9TVFJFQU0ob3V0cHV0U3RyZWFtLmdldCgpKSwgYmxvYkl0ZW0uZGF0YS0+ZGF0YSgp LCBibG9iSXRlbS5kYXRhLT5sZW5ndGgoKSwgJmJ5dGVzV3JpdHRlbiwgMCwgMCk7CisKKyAgICAg ICAgICAgICAgICBib29sIGNvbXBsZXRlZCA9IGJsb2JTdG9yYWdlLT5pdGVtcygpLnNpemUoKSA9 PSAoaSArIDEpOworICAgICAgICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkV3JpdGUoYnl0ZXNX cml0dGVuLCBjb21wbGV0ZWQpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfQor Cit2b2lkIEFzeW5jRmlsZVdyaXRlckd0azo6d3JpdGUobG9uZyBsb25nIHBvc2l0aW9uLCBCbG9i KiBkYXRhKQoreworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9k ZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRl Q2FsbGJhY2tUYXNrKCZ3cml0ZUFzeW5jLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNyZWF0 ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBtX2NsaWVudCwgbW9kZSksIEFsbG93Q3Jvc3NUaHJl YWRBY2Nlc3ModGhpcyksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9maWxlLmdldCgpKSwgcG9z aXRpb24sIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MoZGF0YSkpKTsKK30KKworc3RhdGljIHZvaWQg dHJ1bmNhdGVBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0Zp bGVXcml0ZXJDbGllbnRHdGs+IGhlbHBlckNsaWVudCwgQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0 ZXIsIEdGaWxlKiBmaWxlLCBsb25nIGxvbmcgbGVuZ3RoKQoreworICAgIGlmIChoZWxwZXJDbGll bnQtPnRhc2tDb250cm9sbGVyKCktPmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KHdyaXRlcikpIHsK KyAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6QUJPUlRfRVJSKTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9 IGFkb3B0R1JlZihnX2ZpbGVfcXVlcnlfaW5mbyhmaWxlLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZP X05PTkUsIDAsIDApKTsKKyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAgICAgIGhlbHBlckNsaWVu dC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgbG9uZyBsb25nIGZpbGVMZW5ndGggPSBzdGF0aWNfY2FzdDxsb25nIGxvbmc+ KGdfZmlsZV9pbmZvX2dldF9zaXplKGZpbGVJbmZvLmdldCgpKSk7CisgICAgaWYgKGxlbmd0aCA+ IGZpbGVMZW5ndGgpIHsKKyAgICAgICAgR093blB0cjxHU3RyaW5nPiB6ZXJvUGFkZGluZyhnX3N0 cmluZ19uZXdfbGVuKDAsIGxlbmd0aCAtIGZpbGVMZW5ndGgpKTsKKyAgICAgICAgZG8geworICAg ICAgICAgICAgZ19zdHJpbmdfYXBwZW5kX2MoemVyb1BhZGRpbmcuZ2V0KCksICdcMCcpOworICAg ICAgICB9IHdoaWxlICgtLWxlbmd0aCA+IGZpbGVMZW5ndGgpOworCisgICAgICAgIEdSZWZQdHI8 R0ZpbGVJT1N0cmVhbT4gaW9TdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX29wZW5fcmVhZHdyaXRl KGZpbGUsIDAsIDApKTsKKyAgICAgICAgaWYgKCFpb1N0cmVhbSkgeworICAgICAgICAgICAgaGVs cGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgICAg ICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBHT3duUHRyPEdPdXRwdXRTdHJlYW0+IG91 dHB1dFN0cmVhbShnX2lvX3N0cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShHX0lPX1NUUkVBTShpb1N0 cmVhbS5nZXQoKSkpKTsKKyAgICAgICAgaWYgKCFnX3NlZWthYmxlX3NlZWsoR19TRUVLQUJMRShv dXRwdXRTdHJlYW0uZ2V0KCkpLCBsZW5ndGgsIEdfU0VFS19TRVQsIDAsIDApKSB7CisgICAgICAg ICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAg ICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIGdzaXplIGJ5dGVzV3JpdHRl biA9IDA7CisgICAgICAgIGdfb3V0cHV0X3N0cmVhbV93cml0ZV9hbGwoR19PVVRQVVRfU1RSRUFN KG91dHB1dFN0cmVhbS5nZXQoKSksIHplcm9QYWRkaW5nLT5zdHIsIHplcm9QYWRkaW5nLT5sZW4s ICZieXRlc1dyaXR0ZW4sIDAsIDApOworICAgIH0gZWxzZSB7CisgICAgICAgIEdSZWZQdHI8R0Zp bGVPdXRwdXRTdHJlYW0+IGZpbGVPdXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX3JlcGxh Y2UoZmlsZSwgMCwgZmFsc2UsIEdfRklMRV9DUkVBVEVfTk9ORSwgMCwgMCkpOworICAgICAgICBp ZiAoIWZpbGVPdXRwdXRTdHJlYW0gfHwgIWdfc2Vla2FibGVfdHJ1bmNhdGUoR19TRUVLQUJMRShm aWxlT3V0cHV0U3RyZWFtLmdldCgpKSwgbGVuZ3RoLCAwLCAwKSkgeworICAgICAgICAgICAgaGVs cGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgICAg ICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBoZWxwZXJDbGllbnQtPmRpZFRydW5j YXRlKCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyR3RrOjp0cnVuY2F0ZShsb25nIGxvbmcg bGVuZ3RoKQoreworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9k ZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRl Q2FsbGJhY2tUYXNrKCZ0cnVuY2F0ZUFzeW5jLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNy ZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBtX2NsaWVudCwgbW9kZSksIEFsbG93Q3Jvc3NU aHJlYWRBY2Nlc3ModGhpcyksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9maWxlLmdldCgpKSwg bGVuZ3RoKSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyR3RrOjphYm9ydCgpCit7CisgICAg bV90YXNrQ29udHJvbGxlci0+c2V0V3JpdGVyVG9DYW5jZWwodGhpcyk7Cit9CisKK2Jvb2wgQXN5 bmNGaWxlV3JpdGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgcmV0 dXJuIG1fdGFza0NvbnRyb2xsZXItPnN5bmNocm9ub3VzKCkgPyBtX3Rhc2tDb250cm9sbGVyLT53 YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpIDogZmFsc2U7Cit9CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41NDVi MDBjMWM5NzZhYzM0MzQ0NmFjNWM3NDdlZTViZTgwOTNlNzNjCi0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oCkBAIC0wLDAg KzEsNTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2Jl cnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIg b2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisg KgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5z ZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICog U29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9v ciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmls ZVdyaXRlckd0a19oCisjZGVmaW5lIEFzeW5jRmlsZVdyaXRlckd0a19oCisKKyNpZiBFTkFCTEUo RklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXIuaCIKKworI2luY2x1ZGUg PHd0Zi9QYXNzT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEFzeW5jRmlsZVdyaXRlckNsaWVudDsKK2NsYXNz IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVXcml0 ZXJHdGsgOiBwdWJsaWMgQXN5bmNGaWxlV3JpdGVyIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFz c093blB0cjxBc3luY0ZpbGVXcml0ZXJHdGs+IGNyZWF0ZShBc3luY0ZpbGVXcml0ZXJDbGllbnQq LCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayosIEdGaWxlKik7CisKKyAgICB2b2lk IGFib3J0KCk7CisgICAgdm9pZCB0cnVuY2F0ZShsb25nIGxvbmcgbGVuZ3RoKTsKKyAgICB2b2lk IHdyaXRlKGxvbmcgbG9uZyBwb3NpdGlvbiwgQmxvYiogZGF0YSk7CisKKyAgICBib29sIHdhaXRG b3JPcGVyYXRpb25Ub0NvbXBsZXRlKCk7CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlV3JpdGVy R3RrKEFzeW5jRmlsZVdyaXRlckNsaWVudCosIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrKiwgR0ZpbGUqKTsKKworICAgIEFzeW5jRmlsZVdyaXRlckNsaWVudCogbV9jbGllbnQ7Cisg ICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9s bGVyOworICAgIEdSZWZQdHI8R0ZpbGU+IG1fZmlsZTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdl YkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5j RmlsZVdyaXRlckd0a19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv TG9jYWxGaWxlU3lzdGVtR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2Nh bEZpbGVTeXN0ZW1HdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY1OTcyODQ2ZTc5YzM4NjYyMTliZmZjY2My YjhkZTY2NDcyZDk3OTQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvTG9jYWxGaWxlU3lzdGVtR3RrLmNwcApAQCAtMCwwICsxLDg2IEBACisvKgorICogIENv cHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogIENv cHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoK KyAqICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3Nl ciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwg b3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiAg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9u LCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1 ZGUgIkxvY2FsRmlsZVN5c3RlbS5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5j bHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJl YWRUYXNrLmgiCisjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKyNpbmNsdWRlIDxndGsvZ3Rr Lmg+CisjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dP d25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CisjaW5jbHVkZSA8d3Rm L3RleHQvQ1N0cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0xvY2FsRmlsZVN5c3Rl bSogTG9jYWxGaWxlU3lzdGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2NhbEZpbGVTeXN0 ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3sK KyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR093blB0cjxHRGlyPiBkaXJlY3Rvcnko Z19kaXJfb3BlbihiYXNlUGF0aC51dGY4KCkuZGF0YSgpLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsK KyAgICBpZiAoZXJyb3IgJiYgZXJyb3ItPmNvZGUgPT0gR19GSUxFX0VSUk9SX05PRU5UKSB7Cisg ICAgICAgIEdSZWZQdHI8R0ZpbGU+IGJhc2VEaXJlY3RvcnlGaWxlID0gYWRvcHRHUmVmKGdfZmls ZV9uZXdfZm9yX3BhdGgoYmFzZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgICAgICBnX2ZpbGVf bWFrZV9kaXJlY3RvcnkoYmFzZURpcmVjdG9yeUZpbGUuZ2V0KCksIDAsIDApOworICAgIH0KK30K KworTG9jYWxGaWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCit7 CisgICAgV1RGOjpsb2NrQXRvbWljYWxseUluaXRpYWxpemVkU3RhdGljTXV0ZXgoKTsKKyAgICBp ZiAoIXNfaW5zdGFuY2UpIHsKKyAgICAgICAgR093blB0cjxnY2hhcj4gYmFzZVBhdGgoZ19idWls ZF9maWxlbmFtZShnX2dldF91c2VyX2RhdGFfZGlyKCksICJ3ZWJraXQiLCAiZmlsZXN5c3RlbSIs IE5VTEwpKTsKKyAgICAgICAgT3duUHRyPExvY2FsRmlsZVN5c3RlbT4gbG9jYWxGaWxlU3lzdGVt ID0gYWRvcHRQdHIobmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aC5nZXQoKSkpOworICAgICAg ICBsb2NhbEZpbGVTeXN0ZW0tPmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oU3RyaW5nKGJhc2VQ YXRoLmdldCgpKSk7CisKKyAgICAgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3RlbS5sZWFr UHRyKCk7CisgICAgfQorICAgIFdURjo6dW5sb2NrQXRvbWljYWxseUluaXRpYWxpemVkU3RhdGlj TXV0ZXgoKTsKKyAgICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVT eXN0ZW06OmZpbGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fYmFzZVBh dGg7Cit9CisKK3N0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRp ZmllciwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGJvb2wgY3JlYXRlLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQor eworICAgIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0oYmFzZVBhdGgsIGlkZW50aWZp ZXIsIHR5cGUsIGNyZWF0ZSwgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoY29u dGV4dCwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOworfQorCit2b2lkIExvY2FsRmlsZVN5c3Rl bTo6cmVhZEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNG aWxlU3lzdGVtOjpUeXBlIHR5cGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz PiBjYWxsYmFja3MsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgLy8gQXN5bmNGaWxlU3lzdGVt OjpvcGVuRmlsZVN5c3RlbSBjYWxscyBjYWxsYmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1l dGhvZCBuZWVkcyB0byBiZSBjYWxsZWQgYXN5bmNocm9ub3VzbHkuCisgICAgY29udGV4dC0+cG9z dFRhc2soY3JlYXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQ YXRoKCksIGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0 eXBlLCBmYWxzZSwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOworfQorCit2b2lkIExvY2FsRmls ZVN5c3RlbTo6cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4 dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZywgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAg ICAvLyBBc3luY0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5j aHJvbm91c2x5LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNs eS4KKyAgICBjb250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lz dGVtLCBmaWxlU3lzdGVtQmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0 YWJhc2VJZGVudGlmaWVyKCksIHR5cGUsIHRydWUsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsK K30KKworfQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvVG9v bHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDIyMjc2YmU4ZjcxODVjNGVmZDI5 NWQ5OWQzMGI3NDVhMzQ2MGFlNjQuLmY1ZTM3NDhhNjVkMjJhMmE0N2E4MDhkODdmN2M3ZGNhOGRl N2M2YTIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNCBAQAorMjAxMi0wNC0xOCAgQ2hhbmdTZW9rIE9oICA8c2hpdmFtaWRvd0Bn bWFpbC5jb20+CisKKyAgICAgICAgW0dUS10gU3VwcG9ydCB0aGUgZmlsZSBzeXN0ZW0gQVBJCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01ODQ0MworCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEVuYWJsZWQgRmls ZVN5c3RlbSBmb3IgR1RLIHBvcnQuCisKKyAgICAgICAgKiBTY3JpcHRzL2J1aWxkLXdlYmtpdDoK KwogMjAxMi0wNC0xNiAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KIAog ICAgICAgICBbR1RLXSBVc2UgY29uZmlndXJlIGluc3RlYWQgb2YgYXV0b2dlbi5zaCBmb3IgZ3Rr KwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy9idWlsZC13ZWJraXQgYi9Ub29scy9TY3JpcHRz L2J1aWxkLXdlYmtpdAppbmRleCA2ZWU5ZjEyZDczNTJiMTNiMzU5ZjYzOThlZjBhZmNkNjVhZGYz NzRiLi5mNmViZDIzMmNmNGRlYjJjMmQxNWQzZjkwZWRmMTZjMjcyYjdmZDg5IDEwMDc1NQotLS0g YS9Ub29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdAorKysgYi9Ub29scy9TY3JpcHRzL2J1aWxkLXdl YmtpdApAQCAtMjAzLDcgKzIwMyw3IEBAIG15IEBmZWF0dXJlcyA9ICgKICAgICAgIGRlZmluZSA9 PiAiRU5BQkxFX0RJUkVDVE9SWV9VUExPQUQiLCBkZWZhdWx0ID0+IDAsIHZhbHVlID0+IFwkZGly ZWN0b3J5VXBsb2FkU3VwcG9ydCB9LAogCiAgICAgeyBvcHRpb24gPT4gImZpbGUtc3lzdGVtIiwg ZGVzYyA9PiAiVG9nZ2xlIEZpbGVTeXN0ZW0gc3VwcG9ydCIsCi0gICAgICBkZWZpbmUgPT4gIkVO QUJMRV9GSUxFX1NZU1RFTSIsIGRlZmF1bHQgPT4gaXNCbGFja0JlcnJ5KCksIHZhbHVlID0+IFwk ZmlsZVN5c3RlbVN1cHBvcnQgfSwKKyAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0ZJTEVfU1lTVEVN IiwgZGVmYXVsdCA9PiAoaXNCbGFja0JlcnJ5KCkgfHwgaXNHdGsoKSksIHZhbHVlID0+IFwkZmls ZVN5c3RlbVN1cHBvcnQgfSwKIAogICAgIHsgb3B0aW9uID0+ICJmaWx0ZXJzIiwgZGVzYyA9PiAi VG9nZ2xlIFNWRyBGaWx0ZXJzIHN1cHBvcnQiLAogICAgICAgZGVmaW5lID0+ICJFTkFCTEVfRklM VEVSUyIsIGRlZmF1bHQgPT4gKGlzQXBwbGVXZWJLaXQoKSB8fCBpc0d0aygpIHx8IGlzUXQoKSB8 fCBpc0VmbCgpIHx8IGlzQmxhY2tCZXJyeSgpKSwgdmFsdWUgPT4gXCRmaWx0ZXJzU3VwcG9ydCB9 LApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCmluZGV4IGMzZWUzMmQwN2RkY2EzMjIyOWFjNjQzMDA4YWM1N2UyYjYyMGE0NmQuLmUzZjZm OTA1NTA0MDg5N2EwNDUyZGZiNDM2YjE1N2NmYzZhZTU5NWYgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBA QAorMjAxMi0wNC0xOCAgQ2hhbmdTZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAg ICAgICAgW0dUS10gU3VwcG9ydCB0aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFsbCB0ZXN0cyBpbiBmYXN0L2ZpbGVzeXN0 ZW0gYXJlIHBhc3NlZCBleGNlcHQgdGhlIG9uZXMgcmVsYXRlZCB3aXRoIHdvcmtlci4KKyAgICAg ICAgRm9sbG93aW5nIHRlc3RzIGFyZSBwYXNzZWQgaW4gZGV0YWlsLgorICAgICAgICBmYXN0L2Zp bGVzeXN0ZW0vKi5odG1sCisgICAgICAgIGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFj ay1kZWxpdmVyeS5odG1sCisgICAgICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkv c2VuZC1maWxlLWJsb2IuaHRtbAorICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9o eWJpL3NlbmQtZmlsZS1ibG9iLWZhaWwuaHRtbAorCisgICAgICAgICogcGxhdGZvcm0vZ3RrL3Rl c3RfZXhwZWN0YXRpb25zLnR4dDoKKwogMjAxMi0wNC0xNiAgU2hlcmlmZiBCb3QgIDx3ZWJraXQu cmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQg cjExNDI4NS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0X2V4cGVj dGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3RhdGlvbnMu dHh0CmluZGV4IGFmZTQyNGNlNTkzNjM1OTVjYzJiMzkyYmU0NGFmZGM0YzhkZDkwZjQuLjU0YjNm N2ExNDZjZTM4MjE0MDM5Nzk5Mjk4NDExZTE2YjJiOTY4MDEgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL3BsYXRmb3JtL2d0ay90ZXN0X2V4cGVjdGF0aW9ucy50eHQKKysrIGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vZ3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dApAQCAtMTU1LDE0ICsxNTUsMTIgQEAg QlVHV0s0MjQzMiA6IGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmctc2xvdy1sb2FkLnBocCA9IEZB SUwKIEJVR1dLNDI0MzIgOiBodHRwL3Rlc3RzL21pc2Mvd2VidGltaW5nLXNzbC5waHAgPSBGQUlM CiBCVUdXSzQyNDMyIDogaHR0cC90ZXN0cy9taXNjL3dlYnRpbWluZy10d28tcmVkaXJlY3RzLnBo cCA9IEZBSUwKIAotLy8gRmlsZVN5c3RlbSBBUEkgaXMgbm90IHN1cHBvcnRlZC4KLUJVR1dLR1RL IFNLSVAgOiBmYXN0L2ZpbGVzeXN0ZW0gPSBGQUlMCisvLyBGaWxlU3lzdGVtIEFQSSBpcyBub3Qg c3VwcG9ydGVkIGNvbXBsZXRlbHkuCisvLyBXZSBkb24ndCBzdXBwb3J0IHdvcmtlcnMgZm9yIEZp bGVTeXN0ZW0geWV0LiBodHRwOi8vd2Via2l0Lm9yZy9iLzgyODU0CitCVUdXS0dUSyBTS0lQIDog ZmFzdC9maWxlc3lzdGVtL3dvcmtlcnMgPSBGQUlMCiBCVUdXS0dUSyBTS0lQIDogaHR0cC90ZXN0 cy9maWxlc3lzdGVtID0gRkFJTAogQlVHV0tHVEsgU0tJUCA6IGh0dHAvdGVzdHMvc2VjdXJpdHkv ZmlsZXN5c3RlbS1pZnJhbWUtZnJvbS1yZW1vdGUuaHRtbCA9IEZBSUwKLUJVR1dLR1RLIFNLSVAg OiBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1ibG9iLmh0bWwgPSBG QUlMCi1CVUdXS0dUSyBTS0lQIDogaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5k LWZpbGUtYmxvYi1mYWlsLmh0bWwgPSBGQUlMCiBCVUdXS0dUSyBTS0lQIDogaHR0cC90ZXN0cy93 b3JrZXJzL3Rlcm1pbmF0ZS1kdXJpbmctc3luYy1vcGVyYXRpb24uaHRtbCA9IEZBSUwKLUJVR1dL R1RLIFNLSVAgOiBmYXN0L211dGF0aW9uL2ZpbGVzeXN0ZW0tY2FsbGJhY2stZGVsaXZlcnkuaHRt bCA9IEZBSUwKIAogLy8gUmVxdWlyZXMgV2ViUCBzdXBwb3J0LgogQlVHV0tHVEsgU0tJUCA6IGZh c3QvY2FudmFzL2NhbnZhcy10b0RhdGFVUkwtd2VicC5odG1sID0gRkFJTAo= 137861 2012-04-19 00:46:40 -0700 2012-04-23 20:16:16 -0700 Patch bug-58443-20120419164639.patch text/plain 74031 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTE0NjIxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRiNGMxYTgyYjQwNjA5ZDA1NjlkMjRj ZjE2MzM0OWMwZTk1MzJiNzMuLjcxM2Q3Nzc4YmQyMWI1YjBhMGZiYWRjZWNlYjk2ZGQwZWQ4YWJl MTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMTkgIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDoKKwogMjAxMi0wNC0xOCAgTXlsZXMgTWF4ZmllbGQgIDxtbWF4 ZmllbGRAZ29vZ2xlLmNvbT4KIAogICAgICAgICBTb21laG93LCB0aGVyZSdzIGFuIGVycmFudCBi YWNrc2xhc2ggaW4gbXkgbGFzdCBXVEYgcGF0Y2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBiNWM4NTRmODIzOGRh M2FhNWY5YjAwN2EzMjA3MDgwODU5Y2NjOTIzLi5iZmFjNDY0MTMyNjE2NGM4NDQ3NGM0YmM1MDY3 N2YwZThhOWUyYWRjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQxIEBACisyMDEyLTA0LTE5ICBD aGFuZ1Nlb2sgT2ggIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKworICAgICAgICBbR1RLXSBTdXBw b3J0IHRoZSBmaWxlIHN5c3RlbSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTU4NDQzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGhpcyBwYXRjaCBpcyBiYXNlZCBvbiBaYW4gRG9iZXJzZWsncyBvcmln aW5hbCBvbmUgZm9yIGJ1ZzU4NDQzLgorICAgICAgICBUaGlzIGJyaW5ncyBGaWxlU3lzdGVtIEFQ SSB0byBndGsgcG9ydC4gVGhpcyBhZGRzIG5ldyBpbnRlcmZhY2VzIGxpa2UKKyAgICAgICAgQXN5 bmNGaWxlU3lzdGVtR3RrLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGssIEFzeW5jRmlsZVdy aXRlckd0aywgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrCisgICAgICAgIGFuZCBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ay4gVGhlc2UgYXJlIGNoaWxkIGNsYXNzZXMgaW1wbGVtZW50 aW5nIHRoZSBpbnRlcmZhY2VzCisgICAgICAgIG9mIGVhY2ggcGFyZW50IGNsYXNzZXMgZXhjZXB0 IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLiBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0aworICAgICAgICBpcyBhIGhlbHBlciBjbGFzcy4gSXQgcmV0YWlucyBzb21lIHVz ZWZ1bCB2YXJpYWJsZXMsIGFuZCBjb250cm9scyBwb3N0aW5nIHRhc2tzIHRvCisgICAgICAgIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQgd2hpY2ggbWlnaHQgYmUgZWl0aGVyIGEgRG9jdW1lbnQgb2Jq ZWN0IG9yIGEgV29ya2VyLgorICAgICAgICBVbmZvcnR1bmF0ZWx5LCBXb3JrZXIgZm9yIGZpbGVz eXN0ZW0gaXMgbm90IHN1cHBvcnRlZCB5ZXQsIEkgcGxhbiB0byBzdXBwb3J0IGl0IGluIHRoZSBu ZXh0IHBhdGNoLgorCisgICAgICAgIFRlc3Q6IGZhc3QvZmlsZXN5c3RlbS8qLmh0bWwKKyAgICAg ICAgICAgICAgZmFzdC9tdXRhdGlvbi9maWxlc3lzdGVtLWNhbGxiYWNrLWRlbGl2ZXJ5Lmh0bWwK KyAgICAgICAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUt YmxvYi5odG1sCisgICAgICAgICAgICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkv c2VuZC1maWxlLWJsb2ItZmFpbC5odG1sCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFt OiBBZGRlZCBzb21lIGZpbGVzIHRvIGJ1aWxkIG5ld2x5IGZvciBGaWxlU3lzdGVtLgorICAgICAg ICAqIE1vZHVsZXMvZmlsZXN5c3RlbS9Mb2NhbEZpbGVTeXN0ZW0uY3BwOiBXZSBzaG91bGQgbm90 IGJ1aWxkIHRoaXMgZmlsZS4gc28gYWRkZWQgZXJyb3IgbWVzc2FnZS4KKyAgICAgICAgKiBwbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcDogQWRkZWQuIFRoaXMgaXMg YW4gaW1wbGVtZW50YXRpb24gb2YgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLgorICAgICAgICAo V2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjo6OmNvcHkpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsp OgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFN1Y2NlZWRDYWxsYmFjayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFN1Y2NlZWQpOgorICAg ICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZE9wZW5GaWxlU3lzdGVtQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRPcGVuRmlsZVN5c3Rl bSk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkUmVhZE1ldGFkYXRhQ2FsbGJhY2spOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkTWV0 YWRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpk aWRSZWFkRGlyZWN0b3J5RW50cnkpOgorICAgICAgICAoV2ViQ29yZTo6cGVyZm9ybURpZFJlYWRE aXJlY3RvcnlFbnRyaWVzQW5kRmluaXNoZWRDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWREaXJlY3RvcnlFbnRyaWVzKToKKyAg ICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2spOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRDcmVhdGVGaWxl V3JpdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2spOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRGYWlsKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmg6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGspOiBBZGRlZCBzb21lIG1pc3NpbmcgQVBJcy4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIG9mIEFz eW5jRmlsZVN5c3RlbS4KKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6RGlyZWN0b3J5RW50cnk6OkRpcmVjdG9yeUVudHJ5KToKKyAgICAgICAgKERpcmVjdG9y eUVudHJ5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OnRvRmlsZUVycm9yQ29kZSk6CisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKFdlYkNvcmU6OnZhbGlkYXRlRmlsZVR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6 QXN5bmNGaWxlU3lzdGVtOjppc0F2YWlsYWJsZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVTeXN0ZW06OmlzVmFsaWRUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3Rl bTo6b3BlbkZpbGVTeXN0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjpj cmFja0ZpbGVTeXN0ZW1VUkwpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3Rr OjpBc3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVt R3RrOjp+QXN5bmNGaWxlU3lzdGVtR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5 c3RlbUd0azo6dG9VUkwpOgorICAgICAgICAoV2ViQ29yZTo6bW92ZUFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6bW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpj b3B5UmVjdXJzaXZlbHkpOgorICAgICAgICAoV2ViQ29yZTo6Y29weUFzeW5jKToKKyAgICAgICAg KFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y29weSk6CisgICAgICAgIChXZWJDb3JlOjpy ZW1vdmVGaWxlUmVjdXJzaXZlbHkpOgorICAgICAgICAoV2ViQ29yZTo6cmVtb3ZlQXN5bmMpOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpyZW1vdmUpOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpyZW1vdmVSZWN1cnNpdmVseSk6CisgICAgICAg IChXZWJDb3JlOjpyZWFkTWV0YWRhdGFBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVTeXN0ZW1HdGs6OnJlYWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpjcmVhdGVPYmpl Y3RBbmRSZWFkTWV0YWRhdGFBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0 ZW1HdGs6OmNyZWF0ZU9iamVjdEFuZFJlYWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZUZpbGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3RvcnkpOgorICAgICAgICAoV2ViQ29yZTo6b2JqZWN0 RXhpc3RzQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpmaWxl RXhpc3RzKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6ZGlyZWN0b3J5 RXhpc3RzKToKKyAgICAgICAgKFdlYkNvcmU6OnJlYWREaXJlY3RvcnlBc3luYyk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWREaXJlY3RvcnkpOgorICAgICAgICAo V2ViQ29yZTo6Y3JlYXRlV3JpdGVyQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxl U3lzdGVtR3RrOjpjcmVhdGVXcml0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lz dGVtR3RrOjpjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpzZXRUYXNrQ29udHJvbGxlcik6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6d2FpdEZvck9wZXJhdGlvblRv Q29tcGxldGUpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuaDoK KyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoQXN5bmNGaWxlU3lzdGVtR3RrKToKKyAgICAg ICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuY3BwOiBB ZGRlZC4gVGhpcyBpcyBhIGhlbHBlciBjbGFzcyB0byBjb250cm9sIHBvc3RpbmcgdGFzayB0byBh IHRhcmdldCB0aHJlYWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkFz eW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29y ZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OkFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrOjp+QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGspOgorICAgICAgICAo V2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnVuaXF1ZU1vZGUpOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBvc3RU YXNrVG9NYWluVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjpzZXRDdXJyZW50VGFza01vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBvc3RDYWxsYmFja1Rhc2spOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OndhaXRGb3JPcGVy YXRpb25Ub0NvbXBsZXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjpjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSk6CisgICAgICAgICogcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmg6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZSk6CisgICAgICAgIChBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6c3lu Y2hyb25vdXMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xs ZXJHdGs6OnNldFdyaXRlclRvQ2FuY2VsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNG aWxlV3JpdGVyQ2xpZW50R3RrLmNwcDogQWRkZWQuIFRoaXMgaXMgYSBjaGlsZCBjbGFzcyBpbXBs ZW1lbnQgb2YgQXlzbmNGaWxlV3JpdGVyQ2xpZW50LgorICAgICAgICAoV2ViQ29yZSk6CisgICAg ICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkV3JpdGVDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3Jl OjpwZXJmb3JtRGlkVHJ1bmNhdGVDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3Jt RGlkRmFpbENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckNsaWVu dEd0azo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckNsaWVudEd0azo6ZGlkV3JpdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNG aWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRUcnVuY2F0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZEZhaWwpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKEFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0Zp bGVXcml0ZXJDbGllbnRHdGs6OnRhc2tDb250cm9sbGVyKToKKyAgICAgICAgKiBwbGF0Zm9ybS9n dGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcDogQWRkZWQuIFRoaXMgaXMgYSBjaGlsZCBjbGFzcyBv ZiBBc3luY0ZpbGVXcml0ZXIuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFzeW5jRmlsZVdyaXRlckd0azo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmls ZVdyaXRlckd0azo6QXN5bmNGaWxlV3JpdGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OndyaXRl QXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjp3cml0ZSk6Cisg ICAgICAgIChXZWJDb3JlOjp0cnVuY2F0ZUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j RmlsZVdyaXRlckd0azo6dHJ1bmNhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3Jp dGVyR3RrOjphYm9ydCk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6Ondh aXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNG aWxlV3JpdGVyR3RrLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChBc3lu Y0ZpbGVXcml0ZXJHdGspOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Mb2NhbEZpbGVTeXN0ZW1H dGsuY3BwOiBBZGRlZC4gUG9ydCBzcGVjaWZpYyBpbXBsZW1lbnRhdGlvbiBmb3IgTG9jYWxGaWxl U3lzdGVtIGNsYXNzIGlzIGhlcmUuIFdlIHNob3VsZCB1c2UgdGhpcyBmaWxlIGluc3RlYWQgb2Yg TG9jYWxGaWxlU3lzdGVtLmNwcAorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3Jl OjpMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAo V2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2Vi Q29yZTo6TG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lzdGVtQmFzZVBhdGgpOgorICAgICAgICAoV2Vi Q29yZTo6b3BlbkZpbGVTeXN0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVt OjpyZWFkRmlsZVN5c3RlbSk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJl cXVlc3RGaWxlU3lzdGVtKToKKwogMjAxMi0wNC0xOSAgWGluZ25hbiBXYW5nICA8eGluZ25hbi53 YW5nQGludGVsLmNvbT4KIAogICAgICAgICBPcHRpbWl6ZSBmb3IgREFSV0lOIGluIERpcmVjdENv bnZvbHZlcjo6cHJvY2VzcygpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dP d25QdHIuY3BwIGIvU291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmNwcAppbmRleCBkZmUx ODdkNzg4N2ZmNTRlYTAyN2MxYzlkYzVjMDZiZDdiZGI1Y2YxLi4zYWEwNzU5OTQ3NmQ3NGUyMmZk ZjRlN2NkMGU4NTc3YTI4MTU5MmI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0 L0dPd25QdHIuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5jcHAKQEAg LTQyLDYgKzQyLDE2IEBAIHRlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0cjxHU0xpc3Q+KEdT TGlzdCogcHRyKQogICAgIGdfc2xpc3RfZnJlZShwdHIpOwogfQogCit0ZW1wbGF0ZSA8PiB2b2lk IGZyZWVPd25lZEdQdHI8R1N0cmluZz4oR1N0cmluZyogcHRyKQoreworICAgIGdfc3RyaW5nX2Zy ZWUocHRyLCB0cnVlKTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdPdXRw dXRTdHJlYW0+KEdPdXRwdXRTdHJlYW0qIHB0cikKK3sKKyAgICBnX291dHB1dF9zdHJlYW1fY2xv c2UocHRyLCAwLCAwKTsKK30KKwogdGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdQYXR0 ZXJuU3BlYz4oR1BhdHRlcm5TcGVjKiBwdHIpCiB7CiAgICAgaWYgKHB0cikKZGlmZiAtLWdpdCBh L1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oIGIvU291cmNlL1dURi93dGYvZ29iamVj dC9HT3duUHRyLmgKaW5kZXggNGIyZGNiNzdiMjUwMDBjMmU1YjY4MDhhNGM3NDg0YzJiZTZkNmNh NS4uOWMwNjdkNzFhNjc5NTVjYzRiZjhkOGZjOGRkZjIwZDliMjJhMWM3MSAxMDA2NDQKLS0tIGEv U291cmNlL1dURi93dGYvZ29iamVjdC9HT3duUHRyLmgKKysrIGIvU291cmNlL1dURi93dGYvZ29i amVjdC9HT3duUHRyLmgKQEAgLTM2LDYgKzM2LDggQEAgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IGlu bGluZSB2b2lkIGZyZWVPd25lZEdQdHIoVCogcHRyKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3du ZWRHUHRyPEdFcnJvcj4oR0Vycm9yKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxH TGlzdD4oR0xpc3QqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdTTGlzdD4oR1NM aXN0Kik7Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHU3RyaW5nPihHU3RyaW5nKik7 Cit0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHT3V0cHV0U3RyZWFtPihHT3V0cHV0U3Ry ZWFtKik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHUGF0dGVyblNwZWM+KEdQYXR0 ZXJuU3BlYyopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R0Rpcj4oR0RpciopOwog dGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1RpbWVyPihHVGltZXIqKTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmggYi9Tb3VyY2UvV1RGL3d0Zi9n b2JqZWN0L0dUeXBlZGVmcy5oCmluZGV4IGUyOTI1MGJlZjJlZjRkNWU5ZWJlNWMyYjA1MDM3M2Ji YTg1NjRmOWEuLjdhNWU5ZjNjYTA3ZGE1NWU1NjhjNTcxZDRlNWJjOWY4NTQ1ZWI1MjIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmgKKysrIGIvU291cmNlL1dU Ri93dGYvZ29iamVjdC9HVHlwZWRlZnMuaApAQCAtNDgsMTcgKzQ4LDIwIEBAIHR5cGVkZWYgc3Ry dWN0IF9HZGtFdmVudEV4cG9zZSBHZGtFdmVudEV4cG9zZTsKIHR5cGVkZWYgc3RydWN0IF9HZGtQ aXhidWYgR2RrUGl4YnVmOwogdHlwZWRlZiBzdHJ1Y3QgX0dFcnJvciBHRXJyb3I7CiB0eXBlZGVm IHN0cnVjdCBfR0ZpbGUgR0ZpbGU7Cit0eXBlZGVmIHN0cnVjdCBfR0ZpbGVJT1N0cmVhbSBHRmls ZUlPU3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dIYXNoVGFibGUgR0hhc2hUYWJsZTsKIHR5cGVk ZWYgc3RydWN0IF9HSW5wdXRTdHJlYW0gR0lucHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dM aXN0IEdMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluQ29udGV4dCBHTWFpbkNvbnRleHQ7CiB0 eXBlZGVmIHN0cnVjdCBfR01haW5Mb29wIEdNYWluTG9vcDsKK3R5cGVkZWYgc3RydWN0IF9HT3V0 cHV0U3RyZWFtIEdPdXRwdXRTdHJlYW07CiB0eXBlZGVmIHN0cnVjdCBfR1BhdHRlcm5TcGVjIEdQ YXR0ZXJuU3BlYzsKIHR5cGVkZWYgc3RydWN0IF9HUG9sbGFibGVPdXRwdXRTdHJlYW0gR1BvbGxh YmxlT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3QgX0dTTGlzdCBHU0xpc3Q7CiB0eXBlZGVm IHN0cnVjdCBfR1NvY2tldENsaWVudCBHU29ja2V0Q2xpZW50OwogdHlwZWRlZiBzdHJ1Y3QgX0dT b2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25uZWN0aW9uOwogdHlwZWRlZiBzdHJ1Y3QgX0dTb3Vy Y2UgR1NvdXJjZTsKK3R5cGVkZWYgc3RydWN0IF9HU3RyaW5nIEdTdHJpbmc7CiB0eXBlZGVmIHN0 cnVjdCBfR1ZhcmlhbnQgR1ZhcmlhbnQ7CiB0eXBlZGVmIHVuaW9uIF9HZGtFdmVudCBHZGtFdmVu dDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIgR1RpbWVyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxp c3QuYW0KaW5kZXggNGY4MTcxYzJhOTNmNDc0NDliMGFiMGMxMzkwMjBiZmU0NmM2MDU4Zi4uNWU0 MmZiNGE2MDFhOGMzZTVlNTY2OTM2MzMwMzc5YjcyNzFlNDUxYiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtl ZmlsZS5saXN0LmFtCkBAIC0xMDI2LDcgKzEwMjYsNiBAQCB3ZWJjb3JlX21vZHVsZXNfc291cmNl cyArPSBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0ZpbGVXcml0ZXJDYWxs YmFjay5oIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vRmlsZVdyaXRlclN5 bmMuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vRmlsZVdyaXRlclN5 bmMuaCBcCi0JU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3Rl bS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9Mb2NhbEZpbGVTeXN0 ZW0uaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL01ldGFkYXRhQ2FsbGJh Y2suaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL01ldGFkYXRhLmggXApA QCAtNDcwMCw2ICs0Njk5LDcgQEAgd2ViY29yZWd0a19zb3VyY2VzICs9IFwKIAlTb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvR3RrVmVyc2lvbmluZy5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvS2V5QmluZGluZ1RyYW5zbGF0b3IuaCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Mb2NhbGl6ZWRTdHJpbmdzR3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL01haW5GcmFtZVNjcm9sbGJhckd0ay5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9NYWluRnJhbWVTY3JvbGxiYXJHdGsuaCBcCkBAIC00OTk0LDkgKzQ5OTQsMTkgQEAgZG9t X2JpbmRpbmdfaWRscyArPSBcCiAJJChXZWJDb3JlKS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTWV0YWRh dGFDYWxsYmFjay5pZGwgXAogCSQoV2ViQ29yZSkvTW9kdWxlcy9maWxlc3lzdGVtL1dvcmtlckNv bnRleHRGaWxlU3lzdGVtLmlkbAogCi13ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAord2ViY29yZV9z b3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt R3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0 ay5oCisKK3dlYmNvcmVndGtfc291cmNlcyArPSBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCBcCisJU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmNwcCBcCisJ U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGll bnRHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVy Q2xpZW50R3RrLmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0 ZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVy R3RrLmgKIGVuZGlmICMgRU5EIEVOQUJMRV9GSUxFX1NZU1RFTQogCiAjIC0tLS0KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9Mb2NhbEZpbGVTeXN0ZW0uY3Bw IGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAK aW5kZXggOGYwMTY5ZWVhYmJhOTNmZjRmMTU2ZDdjMjM0N2I2YzBiMjdkNWJiYS4uNzNmMjE4YjRh MDM3MWQwMDRhMTRjYmEwMTgyNjFjOGIyZTQ5YzY2NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvTW9kdWxlcy9maWxlc3lzdGVtL0xvY2FsRmlsZVN5c3RlbS5jcHAKQEAgLTMxLDggKzMx LDggQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIK IAotI2lmIFBMQVRGT1JNKENIUk9NSVVNKQotI2Vycm9yICJDaHJvbWl1bSBzaG91bGQgbm90IGNv bXBpbGUgdGhpcyBmaWxlIGFuZCBpbnN0ZWFkIGRlZmluZSBpdHMgb3duIHZlcnNpb24gb2YgdGhl c2UgZmFjdG9yaWVzLiIKKyNpZiBQTEFURk9STShDSFJPTUlVTSkgfHwgUExBVEZPUk0oR1RLKQor I2Vycm9yICJDaHJvbWl1bSAmIFdlYktpdEdUSysgc2hvdWxkIG5vdCBjb21waWxlIHRoaXMgZmls ZSBhbmQgaW5zdGVhZCBkZWZpbmUgaXRzIG93biB2ZXJzaW9uIG9mIHRoZXNlIGZhY3Rvcmllcy4i CiAjZW5kaWYKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uNGNhYzJkMDE2ZjVhMzEwYjk0MDZmY2ZiZjUyMTMyMmQ4YjhkOTM3YQotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsuY3BwCkBAIC0wLDAgKzEsMTU1IEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK KyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQ dWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNz ZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlm IG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUx IEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEg VVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAi QXN5bmNGaWxlU3lzdGVtR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyLmgiCisjaW5j bHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVkZSAiRmlsZU1ldGFkYXRhLmgiCisjaW5j bHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0 cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3RlbXBsYXRlPD4gc3RydWN0IENyb3Nz VGhyZWFkQ29waWVyQmFzZTxmYWxzZSwgZmFsc2UsIEZpbGVNZXRhZGF0YT4geworICAgIHR5cGVk ZWYgRmlsZU1ldGFkYXRhIFR5cGU7CisgICAgc3RhdGljIEZpbGVNZXRhZGF0YSBjb3B5KGNvbnN0 IEZpbGVNZXRhZGF0YSYpOworfTsKKworQ3Jvc3NUaHJlYWRDb3BpZXJCYXNlPGZhbHNlLCBmYWxz ZSwgRmlsZU1ldGFkYXRhPjo6VHlwZSBDcm9zc1RocmVhZENvcGllckJhc2U8ZmFsc2UsIGZhbHNl LCBGaWxlTWV0YWRhdGE+Ojpjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYgb3JpZ2luYWwpCit7Cisg ICAgRmlsZU1ldGFkYXRhIG1ldGFkYXRhOworICAgIG1ldGFkYXRhLm1vZGlmaWNhdGlvblRpbWUg PSBvcmlnaW5hbC5tb2RpZmljYXRpb25UaW1lOworICAgIG1ldGFkYXRhLmxlbmd0aCA9IG9yaWdp bmFsLmxlbmd0aDsKKyAgICBtZXRhZGF0YS50eXBlID0gb3JpZ2luYWwudHlwZTsKKyAgICBtZXRh ZGF0YS5wbGF0Zm9ybVBhdGggPSBvcmlnaW5hbC5wbGF0Zm9ybVBhdGg7CisgICAgcmV0dXJuIG1l dGFkYXRhOworfQorCitQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywg Ym9vbCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0ayhjb250ZXh0LCBjYWxsYmFja3MsIHN5bmNocm9ub3VzKSk7Cit9CisK K1Bhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs6OmNyZWF0ZShBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFz a0NvbnRyb2xsZXIsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFj a3MsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0ayh0YXNrQ29udHJvbGxlciwgY2FsbGJhY2tzLCBtb2RlKSk7 Cit9CisKKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKKyAgICA6 IG1fc3luY2hyb25vdXMoc3luY2hyb25vdXMpCisgICAgLCBtX3Rhc2tNb2RlKCIiKQorICAgICwg bV90YXNrQ29udHJvbGxlcihBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6Y3JlYXRl KGNvbnRleHQsIHN5bmNocm9ub3VzKSkKKyAgICAsIG1fY2FsbGJhY2tzKGNhbGxiYWNrcykKK3sK K30KKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBjb25zdCBTdHJp bmcmIG1vZGUpCisgICAgOiBtX3N5bmNocm9ub3VzKGZhbHNlKQorICAgICwgbV90YXNrTW9kZSht b2RlKQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxlcikKKyAgICAsIG1fY2Fs bGJhY2tzKGNhbGxiYWNrcykKK3sKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZFN1Y2NlZWRD YWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsK K30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFN1Y2NlZWQoKQorewor ICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNr KCZwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCkpLCBtX3Rh c2tNb2RlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZE9wZW5GaWxlU3lzdGVtQ2FsbGJh Y2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbmFtZSwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgY2FsbGJhY2tzLT5kaWRPcGVuRmlsZVN5c3Rl bShuYW1lLCBmaWxlU3lzdGVtKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgbmFtZSwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgQXN5bmNGaWxlU3lzdGVtR3RrKiBmaWxl U3lzdGVtR3RrID0gc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtR3RrKj4oZmlsZVN5c3RlbS5n ZXQoKSk7CisKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUo KTsKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRDdXJyZW50VGFza01vZGUobW9kZSk7CisgICAg bV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBl cmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCksIG5h bWUsIGZpbGVTeXN0ZW0pLCBtb2RlKTsKKworICAgIGZpbGVTeXN0ZW1HdGstPnNldFRhc2tDb250 cm9sbGVyKG1fdGFza0NvbnRyb2xsZXIucmVsZWFzZSgpKTsKKyAgICBmaWxlU3lzdGVtR3RrLT53 YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlk UmVhZE1ldGFkYXRhQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IEZpbGVNZXRhZGF0YSYg bWV0YWRhdGEpCit7CisgICAgY2FsbGJhY2tzLT5kaWRSZWFkTWV0YWRhdGEobWV0YWRhdGEpOwor fQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkUmVhZE1ldGFkYXRhKGNv bnN0IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9z dENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRSZWFkTWV0YWRhdGFD YWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBtZXRhZGF0YSksIG1fdGFza01vZGUpOwor fQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkUmVhZERpcmVjdG9yeUVu dHJ5KGNvbnN0IFN0cmluZyYgbmFtZSwgYm9vbCBpc0RpcmVjdG9yeSkKK3sKKyAgICBtX2RpcmVj dG9yeUVudHJpZXMuYXBwZW5kKERpcmVjdG9yeUVudHJ5KG5hbWUsIGlzRGlyZWN0b3J5KSk7Cit9 CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1EaWRSZWFkRGlyZWN0b3J5RW50cmllc0FuZEZpbmlzaGVk Q2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY2FsbGJhY2tzLT5kaWRSZWFkRGlyZWN0 b3J5RW50cmllcyhmYWxzZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3Rr OjpkaWRSZWFkRGlyZWN0b3J5RW50cmllcyhib29sKQoreworICAgIGZvciAoc2l6ZV90IGkgPSAw OyBpIDwgbV9kaXJlY3RvcnlFbnRyaWVzLnNpemUoKTsgKytpKQorICAgICAgICBtX2NhbGxiYWNr cy0+ZGlkUmVhZERpcmVjdG9yeUVudHJ5KG1fZGlyZWN0b3J5RW50cmllc1tpXS5uYW1lLCBtX2Rp cmVjdG9yeUVudHJpZXNbaV0uaXNEaXJlY3RvcnkpOworICAgIG1fZGlyZWN0b3J5RW50cmllcy5j bGVhcigpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVD YWxsYmFja1Rhc2soJnBlcmZvcm1EaWRSZWFkRGlyZWN0b3J5RW50cmllc0FuZEZpbmlzaGVkQ2Fs bGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSksIG1fdGFza01vZGUpOworfQorCitzdGF0aWMg dm9pZCBwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBsb25nIGxvbmcgbGVuZ3RoKQorewor ICAgIGNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcih3cml0ZXIsIGxlbmd0aCk7Cit9CisK K3ZvaWQgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRDcmVhdGVGaWxlV3JpdGVyKFBh c3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiB3cml0ZXIsIGxvbmcgbG9uZyBsZW5ndGgpCit7Cisg ICAgbV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2so JnBlcmZvcm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2Uo KSwgd3JpdGVyLCBsZW5ndGgpLCBtX3Rhc2tNb2RlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9y bURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgaW50IGNvZGUpCit7CisgICAgY2FsbGJh Y2tzLT5kaWRGYWlsKGNvZGUpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 azo6ZGlkRmFpbChpbnQgY29kZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJh Y2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZEZhaWxDYWxsYmFjaywgbV9jYWxs YmFja3MucmVsZWFzZSgpLCBjb2RlKSwgbV90YXNrTW9kZSk7Cit9CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsu aApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi44MzM3NDZkZDhjNTRjOGY4Mzc0M2QyMmUxODUxMTg4NzhjMTdmN2NjCi0t LSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0ay5oCkBAIC0wLDAgKzEsNzMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgor ICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1 YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3Nl ciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYg bm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEg RnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBV U0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisjZGVmaW5l IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0a19oCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0p CisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3MuaCIKKyNpbmNsdWRlICJBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaW5jbHVkZSA8d3RmL1Bhc3NPd25Q dHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250 ZXh0OworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsgOiBwdWJsaWMgQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzID0g ZmFsc2UpOworICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 az4gY3JlYXRlKEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgUGFzc093blB0cjxB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+LCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgdmly dHVhbCB2b2lkIGRpZFN1Y2NlZWQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlkT3BlbkZpbGVTeXN0 ZW0oY29uc3QgU3RyaW5nJiBuYW1lLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4pOworICAg IHZpcnR1YWwgdm9pZCBkaWRSZWFkTWV0YWRhdGEoY29uc3QgRmlsZU1ldGFkYXRhJik7CisgICAg dmlydHVhbCB2b2lkIGRpZFJlYWREaXJlY3RvcnlFbnRyeShjb25zdCBTdHJpbmcmIG5hbWUsIGJv b2wgaXNEaXJlY3RvcnkpOworICAgIHZpcnR1YWwgdm9pZCBkaWRSZWFkRGlyZWN0b3J5RW50cmll cyhib29sIGhhc01vcmUpOworICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVhdGVGaWxlV3JpdGVyKFBh c3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyPiwgbG9uZyBsb25nIGxlbmd0aCk7CisgICAgdmlydHVh bCB2b2lkIGRpZEZhaWwoaW50IGNvZGUpOworCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrc0d0ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3M+LCBib29sIHN5bmNocm9ub3VzKTsKKyAgICBBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAg ICBzdHJ1Y3QgRGlyZWN0b3J5RW50cnkgeworICAgICAgICBEaXJlY3RvcnlFbnRyeShjb25zdCBT dHJpbmcmIG5hbWUsIGJvb2wgaXNEaXJlY3RvcnkpCisgICAgICAgICAgICA6IG5hbWUobmFtZSkK KyAgICAgICAgICAgICwgaXNEaXJlY3RvcnkoaXNEaXJlY3RvcnkpCisgICAgICAgIHsKKyAgICAg ICAgfQorCisgICAgICAgIFN0cmluZyBuYW1lOworICAgICAgICBib29sIGlzRGlyZWN0b3J5Owor ICAgIH07CisKKyAgICBib29sIG1fc3luY2hyb25vdXM7CisgICAgU3RyaW5nIG1fdGFza01vZGU7 CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250 cm9sbGVyOworICAgIE93blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IG1fY2FsbGJhY2tz OworICAgIFZlY3RvcjxEaXJlY3RvcnlFbnRyeT4gbV9kaXJlY3RvcnlFbnRyaWVzOworfTsKKwor fSAvLyBuYW1lc3BhY2UKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlm IC8vIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuY3BwCmluZGV4IGMxZGIwMDZhODQ4ZjM5MjZk ZDlmZWMzMWY5NjRhMGZkYmRhZjY5ZmMuLmIzNzNiZjk3YmVhMTdkM2Y0ZjFkMjNkZTg3NTJjMzM2 ZDQ1NDBlZjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1HdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1HdGsuY3BwCkBAIC0xLDQgKzEsNSBAQAogLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAqIENvcHlyaWdodCAoQykg MjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgogICoKICAqIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAg LTE4LDI3ICsxOSw3NCBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJB c3luY0ZpbGVTeXN0ZW1HdGsuaCIKIAogI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKIAotI2luY2x1 ZGUgIkFzeW5jRmlsZVN5c3RlbUd0ay5oIgotCi0jaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmgiCisjaW5j bHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIKKyNpbmNsdWRlICJBc3lu Y0ZpbGVXcml0ZXJHdGsuaCIKKyNpbmNsdWRlICJDcm9zc1RocmVhZFRhc2suaCIKICNpbmNsdWRl ICJFeGNlcHRpb25Db2RlLmgiCi0jaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKyNpbmNsdWRl ICJGaWxlRXJyb3IuaCIKKyNpbmNsdWRlICJMb2NhbEZpbGVTeXN0ZW0uaCIKKyNpbmNsdWRlIDxn bGliLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9n b2JqZWN0L0dSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjaW5jbHVk ZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0 YXRpYyBGaWxlRXJyb3I6OkVycm9yQ29kZSB0b0ZpbGVFcnJvckNvZGUoR0Vycm9yKiBlcnJvcikK K3sKKyAgICBBU1NFUlQoZXJyb3IpOworCisgICAgRmlsZUVycm9yOjpFcnJvckNvZGUgZXJyb3JD b2RlOworICAgIHN3aXRjaCAoZXJyb3ItPmNvZGUpIHsKKyAgICBjYXNlIEdfSU9fRVJST1JfRVhJ U1RTOgorICAgIGNhc2UgR19JT19FUlJPUl9OT1RfRU1QVFk6CisgICAgICAgIGVycm9yQ29kZSA9 IEZpbGVFcnJvcjo6SU5WQUxJRF9NT0RJRklDQVRJT05fRVJSOworICAgICAgICBicmVhazsKKyAg ICBjYXNlIEdfSU9fRVJST1JfSVNfRElSRUNUT1JZOgorICAgIGNhc2UgR19JT19FUlJPUl9XT1VM RF9SRUNVUlNFOgorICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6OlRZUEVfTUlTTUFUQ0hf RVJSOworICAgICAgICBicmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1JfV09VTERfTUVSR0U6Cisg ICAgICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6UEFUSF9FWElTVFNfRVJSOworICAgICAgICBi cmVhazsKKyAgICBjYXNlIEdfSU9fRVJST1JfTk9UX0ZPVU5EOgorICAgIGRlZmF1bHQ6CisgICAg ICAgIGVycm9yQ29kZSA9IEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUjsKKyAgICB9CisgICAgcmV0 dXJuIGVycm9yQ29kZTsKK30KKworc3RhdGljIEZpbGVFcnJvcjo6RXJyb3JDb2RlIHZhbGlkYXRl RmlsZVR5cGUoR0ZpbGUqIHNvdXJjZUZpbGUsIEdGaWxlKiBkZXN0aW5hdGlvbkZpbGUpCit7Cisg ICAgR0ZpbGVUeXBlIHNvdXJjZUZpbGVUeXBlID0gZ19maWxlX3F1ZXJ5X2ZpbGVfdHlwZShzb3Vy Y2VGaWxlLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwKTsKKyAgICBHRmlsZVR5cGUgZGVzdGlu YXRpb25GaWxlVHlwZSA9IGdfZmlsZV9xdWVyeV9maWxlX3R5cGUoZGVzdGluYXRpb25GaWxlLCBH X0ZJTEVfUVVFUllfSU5GT19OT05FLCAwKTsKKyAgICBpZiAoZGVzdGluYXRpb25GaWxlVHlwZSAh PSBHX0ZJTEVfVFlQRV9VTktOT1dOKSB7CisgICAgICAgIGlmIChzb3VyY2VGaWxlVHlwZSAhPSBk ZXN0aW5hdGlvbkZpbGVUeXBlKSB7CisgICAgICAgICAgICAvLyBGSVhNRTogRmlsZUVycm9yOjpU WVBFX01JU01BVENIX0VSUj8gSWYgc28sIGZhaWxlZCBvbiBmYXN0L2ZpbGVzeXN0ZW0vb3AtbW92 ZS5odG1sCisgICAgICAgICAgICByZXR1cm4gRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElP Tl9FUlI7CisgICAgICAgIH0KKyAgICAgICAgaWYgKGRlc3RpbmF0aW9uRmlsZVR5cGUgPT0gR19G SUxFX1RZUEVfRElSRUNUT1JZICYmICFnX2ZpbGVfZGVsZXRlKGRlc3RpbmF0aW9uRmlsZSwgMCwg MCkpIHsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBGaWxlRXJyb3I6OlBBVEhfRVhJU1RTX0VSUj8g SWYgc28sIGZhaWxlZCBvbiBmYXN0L2ZpbGVzeXN0ZW0vb3AtbW92ZS5odG1sCisgICAgICAgICAg ICByZXR1cm4gRmlsZUVycm9yOjpJTlZBTElEX01PRElGSUNBVElPTl9FUlI7CisgICAgICAgIH0K KyAgICB9CisgICAgcmV0dXJuIEZpbGVFcnJvcjo6T0s7Cit9CisKIGJvb2wgQXN5bmNGaWxlU3lz dGVtOjppc0F2YWlsYWJsZSgpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAgICByZXR1cm4g ZmFsc2U7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIGJvb2wgQXN5bmNGaWxlU3lzdGVtOjppc1Zh bGlkVHlwZShUeXBlIHR5cGUpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAgICByZXR1cm4g ZmFsc2U7CisgICAgcmV0dXJuIHR5cGUgPT0gVGVtcG9yYXJ5IHx8IHR5cGUgPT0gUGVyc2lzdGVu dDsKIH0KIAogUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3Jl YXRlKFR5cGUgdHlwZSkKQEAgLTQ4LDg3ICs5NiwzNzkgQEAgUGFzc093blB0cjxBc3luY0ZpbGVT eXN0ZW0+IEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKFR5cGUgdHlwZSkKIAogdm9pZCBBc3luY0Zp bGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0 cmluZyYgc3RvcmFnZUlkZW50aWZpZXIsIFR5cGUgdHlwZSwgYm9vbCwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgp OwotICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChOT1RfU1VQUE9SVEVEX0VSUik7CisgICAgU3RyaW5n IHR5cGVTdHJpbmcgPSAodHlwZSA9PSBBc3luY0ZpbGVTeXN0ZW06OlBlcnNpc3RlbnQpID8gIlBl cnNpc3RlbnQiIDogIlRlbXBvcmFyeSI7CisgICAgU3RyaW5nIG5hbWUgPSBzdG9yYWdlSWRlbnRp ZmllciArICI6IiArIHR5cGVTdHJpbmc7CisKKyAgICBjYWxsYmFja3MtPmRpZE9wZW5GaWxlU3lz dGVtKG5hbWUsIEFzeW5jRmlsZVN5c3RlbTo6Y3JlYXRlKHR5cGUpKTsKIH0KIAogYm9vbCBBc3lu Y0ZpbGVTeXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVSTChjb25zdCBLVVJMJiB1cmwsIEFzeW5jRmls ZVN5c3RlbTo6VHlwZSYgdHlwZSwgU3RyaW5nJiBmaWxlUGF0aCkKIHsKLSAgICBub3RJbXBsZW1l bnRlZCgpOwogICAgIHJldHVybiBmYWxzZTsKIH0KIAogQXN5bmNGaWxlU3lzdGVtR3RrOjpBc3lu Y0ZpbGVTeXN0ZW1HdGsoQXN5bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUpCiAgICAgOiBBc3luY0Zp bGVTeXN0ZW0odHlwZSkKKyAgICAsIG1fbG9jYWxGaWxlU3lzdGVtQmFzZVBhdGgoTG9jYWxGaWxl U3lzdGVtOjpsb2NhbEZpbGVTeXN0ZW0oKS5maWxlU3lzdGVtQmFzZVBhdGgoKSkKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwogfQogCiBBc3luY0ZpbGVTeXN0ZW1HdGs6On5Bc3luY0ZpbGVTeXN0 ZW1HdGsoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIFN0cmluZyBBc3luY0ZpbGVT eXN0ZW1HdGs6OnRvVVJMKGNvbnN0IFN0cmluZyYgb3JpZ2luU3RyaW5nLCBjb25zdCBTdHJpbmcm IGZ1bGxQYXRoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuIFN0cmluZygp OworICAgIEFTU0VSVCghb3JpZ2luU3RyaW5nLmlzRW1wdHkoKSk7CisgICAgaWYgKG9yaWdpblN0 cmluZyA9PSBTdHJpbmcoIm51bGwiKSkKKyAgICAgICAgcmV0dXJuIFN0cmluZygpOworCisgICAg U3RyaW5nQnVpbGRlciByZXN1bHQ7CisgICAgcmVzdWx0LmFwcGVuZCgiZmlsZXN5c3RlbToiKTsK KyAgICByZXN1bHQuYXBwZW5kKG9yaWdpblN0cmluZyk7CisgICAgcmVzdWx0LmFwcGVuZCgiLyIp OworICAgIGlmICh0eXBlKCkgPT0gVGVtcG9yYXJ5KQorICAgICAgICByZXN1bHQuYXBwZW5kKHRl bXBvcmFyeVBhdGhQcmVmaXgpOworICAgIGVsc2UgaWYgKHR5cGUoKSA9PSBQZXJzaXN0ZW50KQor ICAgICAgICByZXN1bHQuYXBwZW5kKHBlcnNpc3RlbnRQYXRoUHJlZml4KTsKKyAgICBlbHNlIHsK KyAgICAgICAgQVNTRVJUKHR5cGUoKSA9PSBUZW1wb3JhcnkgfHwgdHlwZSgpID09IFBlcnNpc3Rl bnQpOworICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisgICAgfQorCisgICAgcmVzdWx0LmFwcGVu ZChlbmNvZGVXaXRoVVJMRXNjYXBlU2VxdWVuY2VzKGZ1bGxQYXRoKSk7CisKKyAgICByZXR1cm4g cmVzdWx0LnRvU3RyaW5nKCk7Cit9CisKK3N0YXRpYyB2b2lkIG1vdmVBc3luYyhTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhl bHBlckNhbGxiYWNrcywgU3RyaW5nJiBzcmNQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQoreworICAg IEdSZWZQdHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0 aChzcmNQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBkZXN0aW5hdGlv bkZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51dGY4KCkuZGF0 YSgpKSk7CisKKyAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNvZGUgPSB2YWxpZGF0ZUZp bGVUeXBlKHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSk7CisgICAgaWYg KGVycm9yQ29kZSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3JDb2Rl KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsK KyAgICBnX2ZpbGVfbW92ZShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCks IEdfRklMRV9DT1BZX09WRVJXUklURSwgMCwgMCwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBp ZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9y Q29kZShlcnJvci5nZXQoKSkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaGVscGVy Q2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpt b3ZlKGNvbnN0IFN0cmluZyYgc291cmNlUGF0aCwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblBh dGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0g ICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgc291cmNlRmlsZVN5c3RlbVBhdGggPSB2 aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChzb3VyY2VQYXRoKTsKKyAgICBTdHJpbmcgZGVzdGlu YXRpb25GaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGRlc3RpbmF0 aW9uUGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2Rl KCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVD YWxsYmFja1Rhc2soJm1vdmVBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVh dGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgc291cmNlRmlsZVN5 c3RlbVBhdGgsIGRlc3RpbmF0aW9uRmlsZVN5c3RlbVBhdGgpKTsKK30KKworc3RhdGljIHZvaWQg Y29weVJlY3Vyc2l2ZWx5KEdGaWxlKiBzb3VyY2VEaXJlY3RvcnksIEdGaWxlKiBkZXN0aW5hdGlv bkRpcmVjdG9yeSwgR0Vycm9yKiogZXJyb3IpCit7CisgICAgQVNTRVJUKGdfZmlsZV9xdWVyeV9m aWxlX3R5cGUoc291cmNlRGlyZWN0b3J5LCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwKSA9PSBH X0ZJTEVfVFlQRV9ESVJFQ1RPUlkpOworCisgICAgaWYgKCFnX2ZpbGVfbWFrZV9kaXJlY3Rvcnko ZGVzdGluYXRpb25EaXJlY3RvcnksIDAsIGVycm9yKSkKKyAgICAgICAgcmV0dXJuOworCisgICAg R1JlZlB0cjxHRmlsZUVudW1lcmF0b3I+IGZpbGVFbnVtZXJhdG9yID0gYWRvcHRHUmVmKGdfZmls ZV9lbnVtZXJhdGVfY2hpbGRyZW4oc291cmNlRGlyZWN0b3J5LCBHX0ZJTEVfQVRUUklCVVRFX1NU QU5EQVJEX05BTUUsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIGVycm9yKSk7CisgICAgaWYg KCplcnJvcikKKyAgICAgICAgcmV0dXJuOworCisgICAgd2hpbGUgKEdSZWZQdHI8R0ZpbGVJbmZv PiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfZW51bWVyYXRvcl9uZXh0X2ZpbGUoZmlsZUVu dW1lcmF0b3IuZ2V0KCksIDAsIGVycm9yKSkpIHsKKyAgICAgICAgY29uc3QgY2hhciogZGlyZWN0 b3J5RW50cnlOYW1lID0gZ19maWxlX2luZm9fZ2V0X25hbWUoZmlsZUluZm8uZ2V0KCkpOworICAg ICAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRfY2hp bGQoc291cmNlRGlyZWN0b3J5LCBkaXJlY3RvcnlFbnRyeU5hbWUpKTsKKyAgICAgICAgR1JlZlB0 cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQoZGVz dGluYXRpb25EaXJlY3RvcnksIGRpcmVjdG9yeUVudHJ5TmFtZSkpOworCisgICAgICAgIGlmIChn X2ZpbGVfcXVlcnlfZmlsZV90eXBlKHNvdXJjZUZpbGUuZ2V0KCksIEdfRklMRV9RVUVSWV9JTkZP X05PTkUsIDApID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkKKyAgICAgICAgICAgIGNvcHlSZWN1 cnNpdmVseShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIGVycm9yKTsK KyAgICAgICAgZWxzZQorICAgICAgICAgICAgZ19maWxlX2NvcHkoc291cmNlRmlsZS5nZXQoKSwg ZGVzdGluYXRpb25GaWxlLmdldCgpLCBHX0ZJTEVfQ09QWV9OT05FLCAwLCAwLCAwLCBlcnJvcik7 CisKKyAgICAgICAgaWYgKCplcnJvcikKKyAgICAgICAgICAgIHJldHVybjsKKyAgICB9Cit9CisK K3N0YXRpYyB2b2lkIGNvcHlBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0 cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBz b3VyY2VQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQoreworICAgIEdSZWZQdHI8R0ZpbGU+IHNvdXJj ZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChzb3VyY2VQYXRoLnV0ZjgoKS5k YXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBkZXN0aW5hdGlvbkZpbGUgPSBhZG9wdEdSZWYo Z19maWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51dGY4KCkuZGF0YSgpKSk7CisKKyAgICBGaWxl RXJyb3I6OkVycm9yQ29kZSBlcnJvckNvZGUgPSB2YWxpZGF0ZUZpbGVUeXBlKHNvdXJjZUZpbGUu Z2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSk7CisgICAgaWYgKGVycm9yQ29kZSkgeworICAg ICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwoZXJyb3JDb2RlKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBpZiAoZ19maWxlX3F1 ZXJ5X2ZpbGVfdHlwZShzb3VyY2VGaWxlLmdldCgpLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAw KSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpIHsKKyAgICAgICAgY29weVJlY3Vyc2l2ZWx5KHNv dXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQoKSwgJmVycm9yLm91dFB0cigpKTsK KyAgICAgICAgaWYgKGVycm9yKQorICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWls KHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICBlbHNlCisgICAgICAgICAg ICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KworICAgIGdfZmlsZV9jb3B5KHNvdXJjZUZpbGUuZ2V0KCksIGRlc3RpbmF0aW9uRmlsZS5nZXQo KSwgR19GSUxFX0NPUFlfT1ZFUldSSVRFLCAwLCAwLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAg IGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwodG9GaWxlRXJy b3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBoZWxw ZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6 OmNvcHkoY29uc3QgU3RyaW5nJiBzb3VyY2VQYXRoLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0aW9u UGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsK LSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBzb3VyY2VGaWxlU3lzdGVtUGF0aCA9 IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHNvdXJjZVBhdGgpOworICAgIFN0cmluZyBkZXN0 aW5hdGlvbkZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwoZGVzdGlu YXRpb25QYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1v ZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0 ZUNhbGxiYWNrVGFzaygmY29weUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNy ZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBzb3VyY2VGaWxl U3lzdGVtUGF0aCwgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCkpOworfQorCitzdGF0aWMgdm9p ZCByZW1vdmVGaWxlUmVjdXJzaXZlbHkoR0ZpbGUqIGZpbGUsIGJvb2wgcmVjdXJzaXZlLCBHRXJy b3IqKiBlcnJvcikKK3sKKyAgICBHT3duUHRyPGdjaGFyPiBmaWxlUGF0aChnX2ZpbGVfZ2V0X3Bh dGgoZmlsZSkpOworICAgIGlmIChyZWN1cnNpdmUgJiYgZ19maWxlX3Rlc3QoZmlsZVBhdGguZ2V0 KCksIEdfRklMRV9URVNUX0lTX0RJUikpIHsKKyAgICAgICAgR1JlZlB0cjxHRmlsZUVudW1lcmF0 b3I+IGZpbGVFbnVtZXJhdG9yID0gYWRvcHRHUmVmKGdfZmlsZV9lbnVtZXJhdGVfY2hpbGRyZW4o ZmlsZSwgR19GSUxFX0FUVFJJQlVURV9TVEFOREFSRF9OQU1FLCBHX0ZJTEVfUVVFUllfSU5GT19O T05FLCAwLCBlcnJvcikpOworICAgICAgICBpZiAoKmVycm9yKQorICAgICAgICAgICAgcmV0dXJu OworCisgICAgICAgIHdoaWxlIChHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdS ZWYoZ19maWxlX2VudW1lcmF0b3JfbmV4dF9maWxlKGZpbGVFbnVtZXJhdG9yLmdldCgpLCAwLCBl cnJvcikpKSB7CisgICAgICAgICAgICBHUmVmUHRyPEdGaWxlPiBjaGlsZCA9IGFkb3B0R1JlZihn X2ZpbGVfZ2V0X2NoaWxkKGZpbGUsIGdfZmlsZV9pbmZvX2dldF9uYW1lKGZpbGVJbmZvLmdldCgp KSkpOworICAgICAgICAgICAgcmVtb3ZlRmlsZVJlY3Vyc2l2ZWx5KGNoaWxkLmdldCgpLCByZWN1 cnNpdmUsIGVycm9yKTsKKyAgICAgICAgICAgIGlmICgqZXJyb3IpCisgICAgICAgICAgICAgICAg cmV0dXJuOworICAgICAgICB9CisgICAgfQorCisgICAgZ19maWxlX2RlbGV0ZShmaWxlLCAwLCBl cnJvcik7Cit9CisKK3N0YXRpYyB2b2lkIHJlbW92ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJh Y2tzLCBTdHJpbmcmIGZpbGVQYXRoLCBib29sIHJlY3Vyc2l2ZSkKK3sKKyAgICBHT3duUHRyPEdF cnJvcj4gZXJyb3I7CisgICAgR1JlZlB0cjxHRmlsZT4gZmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVf bmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICByZW1vdmVGaWxlUmVj dXJzaXZlbHkoZmlsZS5nZXQoKSwgcmVjdXJzaXZlLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGlm IChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwodG9GaWxlRXJyb3JD b2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBoZWxwZXJD YWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJl bW92ZShjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmls ZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJp bmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0Nv bnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVtb3Zl QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xs ZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoLCBmYWxzZSkpOwogfQog CiB2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6cmVtb3ZlUmVjdXJzaXZlbHkoY29uc3QgU3RyaW5n JiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQog ewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmly dHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tD b250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFz a1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlbW92ZUFzeW5jLCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFj a3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCwgdHJ1ZSkpOworfQorCitzdGF0aWMgdm9pZCByZWFk TWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBmaWxlUGF0aCkK K3sKKyAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR1JlZlB0cjxHRmlsZT4gZmlsZSA9 IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKGZpbGVQYXRoLnV0ZjgoKS5kYXRhKCkpKTsK KyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5 X2luZm8oZmlsZS5nZXQoKSwgInN0YW5kYXJkOjoqLHRpbWU6OioiLCBHX0ZJTEVfUVVFUllfSU5G T19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAg aGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOwor ICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgRmlsZU1ldGFkYXRhOjpUeXBlIHR5cGUgPSBn X2ZpbGVfaW5mb19nZXRfZmlsZV90eXBlKGZpbGVJbmZvLmdldCgpKSA9PSBHX0ZJTEVfVFlQRV9E SVJFQ1RPUlkgPyBGaWxlTWV0YWRhdGE6OlR5cGVEaXJlY3RvcnkgOiBGaWxlTWV0YWRhdGE6OlR5 cGVGaWxlOworCisgICAgR1RpbWVWYWwgdGltZVZhbHVlOworICAgIGdfZmlsZV9pbmZvX2dldF9t b2RpZmljYXRpb25fdGltZShmaWxlSW5mby5nZXQoKSwgJnRpbWVWYWx1ZSk7CisKKyAgICBHT3du UHRyPGdjaGFyPiBwYXRoKGdfZmlsZV9nZXRfcGF0aChmaWxlLmdldCgpKSk7CisKKyAgICBGaWxl TWV0YWRhdGEgbWV0YWRhdGE7CisgICAgbWV0YWRhdGEudHlwZSA9IHR5cGU7CisgICAgbWV0YWRh dGEubW9kaWZpY2F0aW9uVGltZSA9IHN0YXRpY19jYXN0PGRvdWJsZT4odGltZVZhbHVlLnR2X3Nl Yyk7CisgICAgbWV0YWRhdGEubGVuZ3RoID0gdHlwZSA9PSBGaWxlTWV0YWRhdGE6OlR5cGVGaWxl ID8gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5n ZXQoKSkpIDogMDsKKyAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGggPSBTdHJpbmcocGF0aC5nZXQo KSk7CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFJlYWRNZXRhZGF0YShtZXRhZGF0YSk7CiB9 CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBw YXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewot ICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVh bFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250 cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1Rv TWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJnJlYWRNZXRhZGF0YUFzeW5jLCBBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxs YmFja3MsIG1vZGUpLCBmaWxlU3lzdGVtUGF0aCkpOworfQorCitzdGF0aWMgdm9pZCBjcmVhdGVP YmplY3RBbmRSZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0 LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tz LCBTdHJpbmcmIGxvY2FsRmlsZVN5c3RlbVBhdGgsIFN0cmluZyYgYWJzb2x1dGVQYXRoLCBHRmls ZVR5cGUgdHlwZSwgYm9vbCBuZWVkVG9SZWFkTWV0YWRhdGEpCit7CisgICAgQVNTRVJUKHR5cGUg PT0gR19GSUxFX1RZUEVfUkVHVUxBUiB8fCB0eXBlID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSk7 CisgICAgLy8gV2Ugc2hvdWxkIG5vdCBhbGxvdyB0byBhY2Nlc3MgdXBwZXIgZGlyZWN0b3J5IHRv IGNyZWF0ZSBhIG5ldyBmaWxlIHRoYW4gYmFzZSBkaXJlY3RvcnkKKyAgICAvLyBiZWNhdXNlIG9m IHRoZSBzZWN1cml0eSBpc3N1ZS4KKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFS ICYmIGFic29sdXRlUGF0aCA9PSBTdHJpbmcoIi8iKSkgeworICAgICAgICBoZWxwZXJDYWxsYmFj a3MtPmRpZEZhaWwoRmlsZUVycm9yOjpTRUNVUklUWV9FUlIpOworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZp bGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChsb2NhbEZpbGVTeXN0ZW1QYXRoLnV0 ZjgoKS5kYXRhKCkpKTsKKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdVTEFSKQorICAg ICAgICBHUmVmUHRyPEdGaWxlT3V0cHV0U3RyZWFtPiBvdXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYo Z19maWxlX2NyZWF0ZShmaWxlLmdldCgpLCBHX0ZJTEVfQ1JFQVRFX05PTkUsIDAsICZlcnJvci5v dXRQdHIoKSkpOworICAgIGlmICh0eXBlID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkKKyAgICAg ICAgZ19maWxlX21ha2VfZGlyZWN0b3J5KGZpbGUuZ2V0KCksIDAsICZlcnJvci5vdXRQdHIoKSk7 CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGlmICghbmVlZFRvUmVhZE1ldGFkYXRhIHx8IGVy cm9yLT5jb2RlICE9IEdfSU9fRVJST1JfRVhJU1RTKSB7CisgICAgICAgICAgICBoZWxwZXJDYWxs YmFja3MtPmRpZEZhaWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgICAg ICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAobmVlZFRvUmVhZE1ldGFkYXRh KSB7CisgICAgICAgIHJlYWRNZXRhZGF0YUFzeW5jKGNvbnRleHQsIGhlbHBlckNhbGxiYWNrcywg bG9jYWxGaWxlU3lzdGVtUGF0aCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaGVscGVy Q2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpj cmVhdGVPYmplY3RBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIFBh c3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIEdGaWxlVHlwZSB0 eXBlLCBib29sIG5lZWRUb1JlYWRNZXRhZGF0YSkKK3sKKyAgICBTdHJpbmcgbG9jYWxGaWxlU3lz dGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGFic29sdXRlUGF0aCk7CisgICAg U3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rh c2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmNy ZWF0ZU9iamVjdEFuZFJlYWRNZXRhZGF0YUFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBsb2Nh bEZpbGVTeXN0ZW1QYXRoLCBhYnNvbHV0ZVBhdGgsIHR5cGUsIG5lZWRUb1JlYWRNZXRhZGF0YSkp OworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZShjb25zdCBTdHJpbmcm IGFic29sdXRlUGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRh KGFic29sdXRlUGF0aCwgY2FsbGJhY2tzLCBHX0ZJTEVfVFlQRV9SRUdVTEFSKTsKIH0KIAotdm9p ZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZUZpbGUoY29uc3QgU3RyaW5nJiBwYXRoLCBib29s IGV4Y2x1c2l2ZSwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNr cykKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3RvcnkoY29uc3QgU3RyaW5n JiBhYnNvbHV0ZVBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgY3Jl YXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGFic29sdXRlUGF0aCwgY2FsbGJhY2tzLCBHX0ZJTEVf VFlQRV9ESVJFQ1RPUlkpOwogfQogCi12b2lkIEFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRGly ZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgYm9vbCBleGNsdXNpdmUsIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCitzdGF0aWMgdm9pZCBvYmplY3RFeGlz dHNBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3NHdGs+IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBwYXRoLCBHRmlsZVR5cGUg dHlwZSkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIEdSZWZQdHI8R0ZpbGU+IG9iamVj dCA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHBhdGgudXRmOCgpLmRhdGEoKSkpOwor ICAgIEdGaWxlVHlwZSBvYmplY3RUeXBlID0gZ19maWxlX3F1ZXJ5X2ZpbGVfdHlwZShvYmplY3Qu Z2V0KCksIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDApOworICAgIGlmIChvYmplY3RUeXBlID09 IEdfRklMRV9UWVBFX1VOS05PV04pIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWls KEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAg aWYgKG9iamVjdFR5cGUgIT0gdHlwZSkgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZh aWwoRmlsZUVycm9yOjpUWVBFX01JU01BVENIX0VSUik7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0KIAogdm9pZCBBc3luY0Zp bGVTeXN0ZW1HdGs6OmZpbGVFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1V UkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2Rl KCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVD YWxsYmFja1Rhc2soJm9iamVjdEV4aXN0c0FzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxl U3lzdGVtUGF0aCwgR19GSUxFX1RZUEVfUkVHVUxBUikpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5 c3RlbUd0azo6ZGlyZWN0b3J5RXhpc3RzKGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxB c3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVt VVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9k ZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRl Q2FsbGJhY2tUYXNrKCZvYmplY3RFeGlzdHNBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz R3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgZmls ZVN5c3RlbVBhdGgsIEdfRklMRV9UWVBFX0RJUkVDVE9SWSkpOworfQorCitzdGF0aWMgdm9pZCBy ZWFkRGlyZWN0b3J5QXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBjYWxsYmFja3MsIFN0cmluZyYgcGF0aCkKK3sKKyAg ICBBU1NFUlQoZ19maWxlX3Rlc3QocGF0aC51dGY4KCkuZGF0YSgpLCBHX0ZJTEVfVEVTVF9JU19E SVIpKTsKKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxlPiBk aXJlY3RvcnkgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChwYXRoLnV0ZjgoKS5kYXRh KCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlRW51bWVyYXRvcj4gZmlsZUVudW1lcmF0b3IgPSBhZG9w dEdSZWYoZ19maWxlX2VudW1lcmF0ZV9jaGlsZHJlbihkaXJlY3RvcnkuZ2V0KCksIEdfRklMRV9B VFRSSUJVVEVfU1RBTkRBUkRfTkFNRSwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCwgJmVycm9y Lm91dFB0cigpKSk7CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGNhbGxiYWNrcy0+ZGlkRmFp bCh0b0ZpbGVFcnJvckNvZGUoZXJyb3IuZ2V0KCkpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KworICAgIHdoaWxlIChHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19m aWxlX2VudW1lcmF0b3JfbmV4dF9maWxlKGZpbGVFbnVtZXJhdG9yLmdldCgpLCAwLCAmZXJyb3Iu b3V0UHRyKCkpKSkgeworICAgICAgICBTdHJpbmcgbmFtZShnX2ZpbGVfaW5mb19nZXRfbmFtZShm aWxlSW5mby5nZXQoKSkpOworICAgICAgICBib29sIGlzRGlyZWN0b3J5ID0gZ19maWxlX2luZm9f Z2V0X2ZpbGVfdHlwZShmaWxlSW5mby5nZXQoKSkgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZOwor ICAgICAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJlY3RvcnlFbnRyeShuYW1lLCBpc0RpcmVjdG9y eSk7CisgICAgfQorICAgIGlmIChlcnJvcikKKyAgICAgICAgY2FsbGJhY2tzLT5kaWRGYWlsKHRv RmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworCisgICAgY2FsbGJhY2tzLT5kaWRSZWFkRGly ZWN0b3J5RW50cmllcyhmYWxzZSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFk RGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmlu ZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAg IFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90 YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZy ZWFkRGlyZWN0b3J5QXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1f dGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoKSk7 CiB9CiAKK3N0YXRpYyB2b2lkIGNyZWF0ZVdyaXRlckFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJh Y2tzLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgQXN5bmNGaWxlU3lzdGVtVGFza0Nv bnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBTdHJpbmcmIHBhdGgpCit7CisgICAgR093blB0 cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdSZWYoZ19m aWxlX25ld19mb3JfcGF0aChwYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxl SW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYoZ19maWxlX3F1ZXJ5X2luZm8oZmlsZS5nZXQoKSwg R19GSUxFX0FUVFJJQlVURV9TVEFOREFSRF9TSVpFLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAw LCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgbG9uZyBsb25nIGZpbGVTaXplID0gc3RhdGljX2Nhc3Q8bG9u ZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6ZShmaWxlSW5mby5nZXQoKSkpOworICAgIGhlbHBl ckNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdyaXRlcihBc3luY0ZpbGVXcml0ZXJHdGs6OmNyZWF0 ZShjbGllbnQsIHRhc2tDb250cm9sbGVyLCBmaWxlLmxlYWtSZWYoKSksIGZpbGVTaXplKTsKK30K IAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcihBc3luY0ZpbGVXcml0ZXJD bGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAg U3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7 CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAg ICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rh c2soJmNyZWF0ZVdyaXRlckFzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0 ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBBbGxvd0Nyb3NzVGhy ZWFkQWNjZXNzKGNsaWVudCksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV90YXNrQ29udHJvbGxl ci5nZXQoKSksIGZpbGVTeXN0ZW1QYXRoKSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3Rr OjpjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBhYnNvbHV0 ZVBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7 CisgICAgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGFic29sdXRlUGF0aCwgY2FsbGJhY2tz LCBHX0ZJTEVfVFlQRV9SRUdVTEFSLCB0cnVlKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1H dGs6OnNldFRhc2tDb250cm9sbGVyKFBhc3NSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs+IHRhc2tDb250cm9sbGVyKQoreworICAgIG1fdGFza0NvbnRyb2xsZXIgPSB0YXNr Q29udHJvbGxlcjsKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbUd0azo6dmlydHVhbFBhdGhU b0ZpbGVTeXN0ZW1VUkwoY29uc3QgU3RyaW5nJiB2aXJ0dWFsUGF0aCkKK3sKKyAgICByZXR1cm4g dmlydHVhbFBhdGggIT0gU3RyaW5nKCIvIikgPyBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoICsg dmlydHVhbFBhdGggOiBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoOworfQorCitib29sIEFzeW5j RmlsZVN5c3RlbUd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKQoreworICAgIHJldHVy biBtX3Rhc2tDb250cm9sbGVyLT53YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOwogfQogCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv QXN5bmNGaWxlU3lzdGVtR3RrLmgKaW5kZXggY2I0NWI2ZWE0YmMyMDIwZThlYjRjOGViNWExOThm MDc2ZjVhNjk3Yi4uZDkxOTQ0MzVkMDljZTc0MjVkNDM4NDFlMWFjYjMzMjNjMDJlMDMwYiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1HdGsuaApA QCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxz aGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsg PHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCkBAIC0yMywxMSArMjMs MTMgQEAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiAKICNpbmNsdWRlICJBc3luY0ZpbGVTeXN0 ZW0uaCIKKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4K IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M7 CitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azsKIAogY2xhc3MgQXN5bmNG aWxlU3lzdGVtR3RrIDogcHVibGljIEFzeW5jRmlsZVN5c3RlbSB7CiBwdWJsaWM6CkBAIC00Niw2 ICs0OCwxNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRpcmVjdG9yeUV4aXN0cyhjb25z dCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPik7CiAg ICAgdmlydHVhbCB2b2lkIHJlYWREaXJlY3RvcnkoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwogICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVX cml0ZXIoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiwgY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3du UHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVT bmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZpcnR1YWwgYm9vbCB3YWl0Rm9yT3Bl cmF0aW9uVG9Db21wbGV0ZSgpOworCisgICAgdm9pZCBzZXRUYXNrQ29udHJvbGxlcihQYXNzUmVm UHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPik7Citwcml2YXRlOgorICAgIHZv aWQgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGNvbnN0IFN0cmluZyYgYWJzb2x1dGVQYXRo LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIEdGaWxlVHlwZSwgYm9vbCBu ZWVkVG9SZWFkTWV0YWRhdGEgPSBmYWxzZSk7CisgICAgU3RyaW5nIHZpcnR1YWxQYXRoVG9GaWxl U3lzdGVtVVJMKGNvbnN0IFN0cmluZyYpOworCisgICAgU3RyaW5nIG1fbG9jYWxGaWxlU3lzdGVt QmFzZVBhdGg7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBt X3Rhc2tDb250cm9sbGVyOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZThhNjkwNWM5MmRlZWZiMzA5NTNiMDVj ZGU4YjU0ZTc2Zjk3MDFmMAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAKQEAgLTAsMCArMSw5 MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2Vr QGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAor ICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisjaWYgRU5B QkxFKEZJTEVfU1lTVEVNKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NSZWZQdHI8QXN5 bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrOjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9vbCBzeW5j aHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrKGNvbnRleHQsIHN5bmNocm9ub3VzKSk7Cit9CisKK0FzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayhTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBib29sIHN5bmNocm9ub3VzKQorICAgIDogbV9j b250ZXh0KGNvbnRleHQpCisgICAgLCBtX3N5bmNocm9ub3VzKHN5bmNocm9ub3VzKQorICAgICwg bV9jdXJyZW50VGFza01vZGUoIiIpCisgICAgLCBtX3dyaXRlclRvQ2FuY2VsKDApCit7CisgICAg Ly8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHlldC4KKyAg ICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworfQorCitBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0azo6fkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKCkKK3sK K30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjp1bmlxdWVNb2Rl KCkKK3sKKyAgICAvLyBGSVhNRTogV2UgZG9uJ3Qgc3VwcG9ydCB3b2tlcnMgZm9yIGZpbGVzeXN0 ZW0geWV0LgorICAgIEFTU0VSVChtX2NvbnRleHQtPmlzRG9jdW1lbnQoKSk7CisgICAgcmV0dXJu IFN0cmluZygpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpw b3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRh c2s+IHRhc2spCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBm aWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworICAg IG1fY29udGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJpbmcmIHRhc2tNb2Rl KQoreworICAgIG1fY3VycmVudFRhc2tNb2RlID0gdGFza01vZGU7Cit9CisKK3ZvaWQgQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1vZGUpCit7 CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHll dC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIG1fY29udGV4dC0+ cG9zdFRhc2sodGFzayk7Cit9CisKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJH dGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAgICBBU1NFUlQobV9jb250ZXh0 LT5pc0RvY3VtZW50KCkpOworICAgIEFTU0VSVCghbV9zeW5jaHJvbm91cyk7CisgICAgcmV0dXJu IGZhbHNlOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpjYW5j ZWxXcml0ZXJJZk5lY2Vzc2FyeShBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlcikKK3sKKyAgICBp ZiAobV93cml0ZXJUb0NhbmNlbCA9PSB3cml0ZXIpIHsKKyAgICAgICAgbV93cml0ZXJUb0NhbmNl bCA9IDA7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgICByZXR1cm4gZmFsc2U7Cit9 CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RF TSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uY2JmMmQ5OWQyZTJjYmU3 MGIwOGQ1YmQzMDk3NWFjZThmMDc5N2E2YwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oCkBAIC0w LDAgKzEsNjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5k b2JlcnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQg d2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZl IHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGlj ZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQor ICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBG bG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGtfaAorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAi U2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4K KyNpbmNsdWRlIDx3dGYvVGhyZWFkU2FmZVJlZkNvdW50ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVGhy ZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXN5bmNGaWxlV3JpdGVy R3RrOworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayA6IHB1YmxpYyBU aHJlYWRTYWZlUmVmQ291bnRlZDxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0az4gewor cHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrPiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wgc3luY2hyb25vdXMp OworICAgIH5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0aygpOworCisgICAgdm9pZCBw b3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRh c2s+KTsKKyAgICB2b2lkIHNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJpbmcmKTsKKyAgICB2 b2lkIHBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpU YXNrPiwgY29uc3QgU3RyaW5nJik7CisgICAgYm9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0 ZSgpOworICAgIGJvb2wgc3luY2hyb25vdXMoKSB7IHJldHVybiBtX3N5bmNocm9ub3VzOyB9CisK KyAgICBib29sIGNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KEFzeW5jRmlsZVdyaXRlckd0ayopOwor ICAgIHZvaWQgc2V0V3JpdGVyVG9DYW5jZWwoQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIpIHsg bV93cml0ZXJUb0NhbmNlbCA9IHdyaXRlcjsgfQorCisgICAgU3RyaW5nIHVuaXF1ZU1vZGUoKTsK K3ByaXZhdGU6CisgICAgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCosIGJvb2wpOworCisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogbV9j b250ZXh0OworICAgIGJvb2wgbV9zeW5jaHJvbm91czsKKyAgICBTdHJpbmcgbV9jdXJyZW50VGFz a01vZGU7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJHdGsqIG1fd3JpdGVyVG9DYW5jZWw7Cit9Owor Cit9IC8vIG5hbWVzcGFjZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjZW5k aWYgLy8gQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5iOWZiY2EwMTg5MGQ5MGM5YWFkYThmMWUwYTUyNTY0YjcyNjBhYmYzCi0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRl ckNsaWVudEd0ay5jcHAKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGlj CisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u OyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9u KSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQg aW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBX QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdO VQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAq CisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdl bmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3Qs IHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFu a2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXJDbGll bnRHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkNyb3NzVGhy ZWFkVGFzay5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0YXRpYyB2b2lkIHBlcmZvcm1E aWRXcml0ZUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBBc3luY0ZpbGVXcml0ZXJD bGllbnQqIGNsaWVudCwgbG9uZyBsb25nIGJ5dGVzLCBib29sIGNvbXBsZXRlKQoreworICAgIGNs aWVudC0+ZGlkV3JpdGUoYnl0ZXMsIGNvbXBsZXRlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9y bURpZFRydW5jYXRlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5jRmlsZVdy aXRlckNsaWVudCogY2xpZW50KQoreworICAgIGNsaWVudC0+ZGlkVHJ1bmNhdGUoKTsKK30KKwor c3RhdGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEZpbGVFcnJvcjo6RXJyb3JDb2RlIGNv ZGUpCit7CisgICAgY2xpZW50LT5kaWRGYWlsKGNvZGUpOworfQorCitBc3luY0ZpbGVXcml0ZXJD bGllbnRHdGs6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayhBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50 LCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3Rhc2tDb250cm9sbGVyKHRhc2tDb250cm9s bGVyKQorICAgICwgbV9jbGllbnQoY2xpZW50KQorICAgICwgbV90YXNrTW9kZShtb2RlKQorewor ICAgIG1fdGFza0NvbnRyb2xsZXItPnNldEN1cnJlbnRUYXNrTW9kZShtX3Rhc2tNb2RlKTsKK30K Kwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFdyaXRlKGxvbmcgbG9uZyBieXRl cywgYm9vbCBjb21wbGV0ZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tU YXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFdyaXRlQ2FsbGJhY2ssIEFsbG93Q3Jv c3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBieXRlcywgY29tcGxldGUpLCBtX3Rhc2tNb2RlKTsK K30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKCkKK3sKKyAg ICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygm cGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGll bnQpKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpk aWRGYWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAgbV90YXNrQ29udHJvbGxl ci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRGYWlsQ2Fs bGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBjb2RlKSwgbV90YXNrTW9k ZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxF X1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hNmVlMTA5ZmQ1ZDMzOTViNjE5ODNkMmI4 MWUxNmM3ZjEyMjE5YWZiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oCkBAIC0wLDAgKzEsNTcgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+ CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExl c3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0 a19oCisjZGVmaW5lIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0a19oCisKKyNpZiBFTkFCTEUoRklM RV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5o IgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVudC5oIgorCisjaW5jbHVkZSA8d3RmL1Bh c3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0ZpbGVXcml0 ZXJDbGllbnRHdGsgOiBwdWJsaWMgQXN5bmNGaWxlV3JpdGVyQ2xpZW50IHsKK3B1YmxpYzoKKyAg ICBzdGF0aWMgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs+IGNyZWF0ZShBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEFzeW5jRmlsZVdy aXRlckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgeworICAgICAgICBy ZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayh0YXNrQ29udHJvbGxl ciwgY2xpZW50LCBtb2RlKSk7CisgICAgfQorCisgICAgdm9pZCBkaWRXcml0ZShsb25nIGxvbmcg Ynl0ZXMsIGJvb2wgY29tcGxldGUpOworICAgIHZvaWQgZGlkVHJ1bmNhdGUoKTsKKyAgICB2b2lk IGRpZEZhaWwoRmlsZUVycm9yOjpFcnJvckNvZGUpOworCisgICAgQXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyKCkgeyByZXR1cm4gbV90YXNrQ29udHJvbGxl ci5nZXQoKTsgfQorCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayhBc3lu Y0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayosIEFzeW5jRmlsZVdyaXRlckNsaWVudCosIGNv bnN0IFN0cmluZyYpOworCisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIEFzeW5jRmlsZVdyaXRlckNsaWVudCogbV9jbGll bnQ7CisgICAgU3RyaW5nIG1fdGFza01vZGU7Cit9OworCit9IC8vIG5hbWVzcGFjZQorCisjZW5k aWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlV3JpdGVyQ2xp ZW50R3RrX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVXcml0ZXJHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdy aXRlckd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDU2OWFiNzM3OTEwNGEzNzJhMWMyYTM0MzYzOWE5ZmE5 ODdmZTQyMwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJHdGsuY3BwCkBAIC0wLDAgKzEsMTU1IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICogQ29weXJp Z2h0IChDKSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFu ZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5l cmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor ICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFy eTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAt MTMwMSBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxl V3JpdGVyR3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3lu Y0ZpbGVXcml0ZXJDbGllbnRHdGsuaCIKKyNpbmNsdWRlICJCbG9iLmgiCisjaW5jbHVkZSAiQmxv YlJlZ2lzdHJ5SW1wbC5oIgorI2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorCisjaW5jbHVk ZSA8Z2lvL2dpby5oPgorI2luY2x1ZGUgPGdsaWIuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9H T3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCituYW1lc3BhY2UgV2Vi Q29yZSB7CisKK1Bhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyR3RrPiBBc3luY0ZpbGVXcml0ZXJH dGs6OmNyZWF0ZShBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgQXN5bmNGaWxlU3lzdGVt VGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBHRmlsZSogZmlsZSkKK3sKKyAgICBy ZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVdyaXRlckd0ayhjbGllbnQsIHRhc2tDb250cm9s bGVyLCBmaWxlKSk7Cit9CisKK0FzeW5jRmlsZVdyaXRlckd0azo6QXN5bmNGaWxlV3JpdGVyR3Rr KEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEdGaWxlKiBmaWxlKQorICAgIDogbV9jbGllbnQoY2xp ZW50KQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxlcikKKyAgICAsIG1fZmls ZShmaWxlKQoreworfQorCitzdGF0aWMgdm9pZCB3cml0ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNsaWVudEd0az4gaGVscGVyQ2xpZW50 LCBBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlciwgR0ZpbGUqIGZpbGUsIGxvbmcgbG9uZyBwb3Np dGlvbiwgQmxvYiogZGF0YSkKK3sKKyAgICBpZiAoaGVscGVyQ2xpZW50LT50YXNrQ29udHJvbGxl cigpLT5jYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSh3cml0ZXIpKSB7CisgICAgICAgIGhlbHBlckNs aWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6OkFCT1JUX0VSUik7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IGlvU3RyZWFtID0gYWRvcHRHUmVmKGdf ZmlsZV9vcGVuX3JlYWR3cml0ZShmaWxlLCAwLCAwKSk7CisgICAgaWYgKCFpb1N0cmVhbSkgewor ICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsK KyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8R091dHB1dFN0cmVhbT4gb3V0 cHV0U3RyZWFtKGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKEdfSU9fU1RSRUFNKGlvU3Ry ZWFtLmdldCgpKSkpOworICAgIGlmICghZ19zZWVrYWJsZV9zZWVrKEdfU0VFS0FCTEUob3V0cHV0 U3RyZWFtLmdldCgpKSwgcG9zaXRpb24sIEdfU0VFS19TRVQsIDAsIDApKSB7CisgICAgICAgIGhl bHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgUmVmUHRyPEJsb2JTdG9yYWdlRGF0YT4gYmxvYlN0b3JhZ2Ug PSBzdGF0aWNfY2FzdDxCbG9iUmVnaXN0cnlJbXBsJj4oYmxvYlJlZ2lzdHJ5KCkpLmdldEJsb2JE YXRhRnJvbVVSTChkYXRhLT51cmwoKSk7CisgICAgaWYgKGJsb2JTdG9yYWdlKSB7CisgICAgICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgYmxvYlN0b3JhZ2UtPml0ZW1zKCkuc2l6ZSgpOyBpKysp IHsKKyAgICAgICAgICAgIGNvbnN0IEJsb2JEYXRhSXRlbSYgYmxvYkl0ZW0gPSBibG9iU3RvcmFn ZS0+aXRlbXMoKVtpXTsKKyAgICAgICAgICAgIGlmIChibG9iSXRlbS50eXBlID09IEJsb2JEYXRh SXRlbTo6RGF0YSkgeworICAgICAgICAgICAgICAgIGdzaXplIGJ5dGVzV3JpdHRlbiA9IDA7Cisg ICAgICAgICAgICAgICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlX2FsbChHX09VVFBVVF9TVFJFQU0o b3V0cHV0U3RyZWFtLmdldCgpKSwgYmxvYkl0ZW0uZGF0YS0+ZGF0YSgpLCBibG9iSXRlbS5kYXRh LT5sZW5ndGgoKSwgJmJ5dGVzV3JpdHRlbiwgMCwgMCk7CisKKyAgICAgICAgICAgICAgICBib29s IGNvbXBsZXRlZCA9IGJsb2JTdG9yYWdlLT5pdGVtcygpLnNpemUoKSA9PSAoaSArIDEpOworICAg ICAgICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkV3JpdGUoYnl0ZXNXcml0dGVuLCBjb21wbGV0 ZWQpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfQorCit2b2lkIEFzeW5jRmls ZVdyaXRlckd0azo6d3JpdGUobG9uZyBsb25nIHBvc2l0aW9uLCBCbG9iKiBkYXRhKQoreworICAg IFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90 YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZ3 cml0ZUFzeW5jLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9s bGVyLmdldCgpLCBtX2NsaWVudCwgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3ModGhpcyks IEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9maWxlLmdldCgpKSwgcG9zaXRpb24sIEFsbG93Q3Jv c3NUaHJlYWRBY2Nlc3MoZGF0YSkpKTsKK30KKworc3RhdGljIHZvaWQgdHJ1bmNhdGVBc3luYyhT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJDbGllbnRH dGs+IGhlbHBlckNsaWVudCwgQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIsIEdGaWxlKiBmaWxl LCBsb25nIGxvbmcgbGVuZ3RoKQoreworICAgIGlmIChoZWxwZXJDbGllbnQtPnRhc2tDb250cm9s bGVyKCktPmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KHdyaXRlcikpIHsKKyAgICAgICAgaGVscGVy Q2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6QUJPUlRfRVJSKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2Zp bGVfcXVlcnlfaW5mbyhmaWxlLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAsIDApKTsK KyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxl RXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgbG9u ZyBsb25nIGZpbGVMZW5ndGggPSBzdGF0aWNfY2FzdDxsb25nIGxvbmc+KGdfZmlsZV9pbmZvX2dl dF9zaXplKGZpbGVJbmZvLmdldCgpKSk7CisgICAgaWYgKGxlbmd0aCA+IGZpbGVMZW5ndGgpIHsK KyAgICAgICAgR093blB0cjxHU3RyaW5nPiB6ZXJvUGFkZGluZyhnX3N0cmluZ19uZXdfbGVuKDAs IGxlbmd0aCAtIGZpbGVMZW5ndGgpKTsKKyAgICAgICAgZG8geworICAgICAgICAgICAgZ19zdHJp bmdfYXBwZW5kX2MoemVyb1BhZGRpbmcuZ2V0KCksICdcMCcpOworICAgICAgICB9IHdoaWxlICgt LWxlbmd0aCA+IGZpbGVMZW5ndGgpOworCisgICAgICAgIEdSZWZQdHI8R0ZpbGVJT1N0cmVhbT4g aW9TdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX29wZW5fcmVhZHdyaXRlKGZpbGUsIDAsIDApKTsK KyAgICAgICAgaWYgKCFpb1N0cmVhbSkgeworICAgICAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRG YWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIH0KKworICAgICAgICBHT3duUHRyPEdPdXRwdXRTdHJlYW0+IG91dHB1dFN0cmVhbShnX2lv X3N0cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShHX0lPX1NUUkVBTShpb1N0cmVhbS5nZXQoKSkpKTsK KyAgICAgICAgaWYgKCFnX3NlZWthYmxlX3NlZWsoR19TRUVLQUJMRShvdXRwdXRTdHJlYW0uZ2V0 KCkpLCBsZW5ndGgsIEdfU0VFS19TRVQsIDAsIDApKSB7CisgICAgICAgICAgICBoZWxwZXJDbGll bnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgfQorCisgICAgICAgIGdzaXplIGJ5dGVzV3JpdHRlbiA9IDA7CisgICAgICAg IGdfb3V0cHV0X3N0cmVhbV93cml0ZV9hbGwoR19PVVRQVVRfU1RSRUFNKG91dHB1dFN0cmVhbS5n ZXQoKSksIHplcm9QYWRkaW5nLT5zdHIsIHplcm9QYWRkaW5nLT5sZW4sICZieXRlc1dyaXR0ZW4s IDAsIDApOworICAgIH0gZWxzZSB7CisgICAgICAgIEdSZWZQdHI8R0ZpbGVPdXRwdXRTdHJlYW0+ IGZpbGVPdXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX3JlcGxhY2UoZmlsZSwgMCwgZmFs c2UsIEdfRklMRV9DUkVBVEVfTk9ORSwgMCwgMCkpOworICAgICAgICBpZiAoIWZpbGVPdXRwdXRT dHJlYW0gfHwgIWdfc2Vla2FibGVfdHJ1bmNhdGUoR19TRUVLQUJMRShmaWxlT3V0cHV0U3RyZWFt LmdldCgpKSwgbGVuZ3RoLCAwLCAwKSkgeworICAgICAgICAgICAgaGVscGVyQ2xpZW50LT5kaWRG YWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIH0KKyAgICB9CisKKyAgICBoZWxwZXJDbGllbnQtPmRpZFRydW5jYXRlKCk7Cit9CisKK3Zv aWQgQXN5bmNGaWxlV3JpdGVyR3RrOjp0cnVuY2F0ZShsb25nIGxvbmcgbGVuZ3RoKQoreworICAg IFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90 YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZ0 cnVuY2F0ZUFzeW5jLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNyZWF0ZShtX3Rhc2tDb250 cm9sbGVyLmdldCgpLCBtX2NsaWVudCwgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3ModGhp cyksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9maWxlLmdldCgpKSwgbGVuZ3RoKSk7Cit9CisK K3ZvaWQgQXN5bmNGaWxlV3JpdGVyR3RrOjphYm9ydCgpCit7CisgICAgbV90YXNrQ29udHJvbGxl ci0+c2V0V3JpdGVyVG9DYW5jZWwodGhpcyk7Cit9CisKK2Jvb2wgQXN5bmNGaWxlV3JpdGVyR3Rr Ojp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgcmV0dXJuIG1fdGFza0NvbnRy b2xsZXItPnN5bmNocm9ub3VzKCkgPyBtX3Rhc2tDb250cm9sbGVyLT53YWl0Rm9yT3BlcmF0aW9u VG9Db21wbGV0ZSgpIDogZmFsc2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41NDViMDBjMWM5NzZhYzM0MzQ0 NmFjNWM3NDdlZTViZTgwOTNlNzNjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oCkBAIC0wLDAgKzEsNTcgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+ CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExl c3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVdyaXRlckd0a19oCisj ZGVmaW5lIEFzeW5jRmlsZVdyaXRlckd0a19oCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisK KyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXIuaCIKKworI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRy Lmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK2NsYXNzIEFzeW5jRmlsZVdyaXRlckNsaWVudDsKK2NsYXNzIEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVXcml0ZXJHdGsgOiBwdWJsaWMg QXN5bmNGaWxlV3JpdGVyIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxBc3luY0Zp bGVXcml0ZXJHdGs+IGNyZWF0ZShBc3luY0ZpbGVXcml0ZXJDbGllbnQqLCBBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ayosIEdGaWxlKik7CisKKyAgICB2b2lkIGFib3J0KCk7CisgICAg dm9pZCB0cnVuY2F0ZShsb25nIGxvbmcgbGVuZ3RoKTsKKyAgICB2b2lkIHdyaXRlKGxvbmcgbG9u ZyBwb3NpdGlvbiwgQmxvYiogZGF0YSk7CisKKyAgICBib29sIHdhaXRGb3JPcGVyYXRpb25Ub0Nv bXBsZXRlKCk7CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlV3JpdGVyR3RrKEFzeW5jRmlsZVdy aXRlckNsaWVudCosIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgR0ZpbGUqKTsK KworICAgIEFzeW5jRmlsZVdyaXRlckNsaWVudCogbV9jbGllbnQ7CisgICAgUmVmUHRyPEFzeW5j RmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIEdSZWZQ dHI8R0ZpbGU+IG1fZmlsZTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlm IC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVdyaXRlckd0a19o CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxlU3lzdGVt R3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbEZpbGVTeXN0ZW1HdGsu Y3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjY1OTcyODQ2ZTc5YzM4NjYyMTliZmZjY2MyYjhkZTY2NDcyZDk3OTQK LS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxl U3lzdGVtR3RrLmNwcApAQCAtMCwwICsxLDg2IEBACisvKgorICogIENvcHlyaWdodCAoQykgMjAx MCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogIENvcHlyaWdodCAoQykgMjAx MiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoKKyAqICBUaGlzIGxpYnJh cnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiAg bW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1Ymxp YworICogIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlcgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0 aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM ZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5 OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiAgRm91bmRhdGlvbiwgSW5j LiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMw MSAgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkxvY2FsRmlsZVN5 c3RlbS5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzR3RrLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5j bHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisjaW5jbHVkZSA8 d3RmL1RocmVhZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dPd25QdHIuaD4KKyNpbmNs dWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5o PgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0xvY2FsRmlsZVN5c3RlbSogTG9jYWxGaWxlU3lz dGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVM b2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3sKKyAgICBHT3duUHRyPEdF cnJvcj4gZXJyb3I7CisgICAgR093blB0cjxHRGlyPiBkaXJlY3RvcnkoZ19kaXJfb3BlbihiYXNl UGF0aC51dGY4KCkuZGF0YSgpLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3Ig JiYgZXJyb3ItPmNvZGUgPT0gR19GSUxFX0VSUk9SX05PRU5UKSB7CisgICAgICAgIEdSZWZQdHI8 R0ZpbGU+IGJhc2VEaXJlY3RvcnlGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgo YmFzZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgICAgICBnX2ZpbGVfbWFrZV9kaXJlY3Rvcnko YmFzZURpcmVjdG9yeUZpbGUuZ2V0KCksIDAsIDApOworICAgIH0KK30KKworTG9jYWxGaWxlU3lz dGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCit7CisgICAgV1RGOjpsb2Nr QXRvbWljYWxseUluaXRpYWxpemVkU3RhdGljTXV0ZXgoKTsKKyAgICBpZiAoIXNfaW5zdGFuY2Up IHsKKyAgICAgICAgR093blB0cjxnY2hhcj4gYmFzZVBhdGgoZ19idWlsZF9maWxlbmFtZShnX2dl dF91c2VyX2RhdGFfZGlyKCksICJ3ZWJraXQiLCAiZmlsZXN5c3RlbSIsIE5VTEwpKTsKKyAgICAg ICAgT3duUHRyPExvY2FsRmlsZVN5c3RlbT4gbG9jYWxGaWxlU3lzdGVtID0gYWRvcHRQdHIobmV3 IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aC5nZXQoKSkpOworICAgICAgICBsb2NhbEZpbGVTeXN0 ZW0tPmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oU3RyaW5nKGJhc2VQYXRoLmdldCgpKSk7CisK KyAgICAgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3RlbS5sZWFrUHRyKCk7CisgICAgfQor ICAgIFdURjo6dW5sb2NrQXRvbWljYWxseUluaXRpYWxpemVkU3RhdGljTXV0ZXgoKTsKKyAgICBy ZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZpbGVTeXN0 ZW1CYXNlUGF0aCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fYmFzZVBhdGg7Cit9CisKK3N0YXRp YyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNv bnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5bmNGaWxl U3lzdGVtOjpUeXBlIHR5cGUsIGJvb2wgY3JlYXRlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQoreworICAgIEFzeW5jRmls ZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0oYmFzZVBhdGgsIGlkZW50aWZpZXIsIHR5cGUsIGNyZWF0 ZSwgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoY29udGV4dCwgY2FsbGJhY2tz LCBzeW5jaHJvbm91cykpOworfQorCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVhZEZpbGVTeXN0 ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBl IHR5cGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGJv b2wgc3luY2hyb25vdXMpCit7CisgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3Rl bSBjYWxscyBjYWxsYmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVkcyB0byBi ZSBjYWxsZWQgYXN5bmNocm9ub3VzbHkuCisgICAgY29udGV4dC0+cG9zdFRhc2soY3JlYXRlQ2Fs bGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNvbnRleHQt PnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCBmYWxzZSwgY2Fs bGJhY2tzLCBzeW5jaHJvbm91cykpOworfQorCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVxdWVz dEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lz dGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZywgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICAvLyBBc3luY0ZpbGVT eXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5jaHJvbm91c2x5LCBzbyB0 aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNseS4KKyAgICBjb250ZXh0 LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxlU3lzdGVt QmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVudGlmaWVy KCksIHR5cGUsIHRydWUsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKK30KKworfQorCisjZW5k aWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIv VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDE1YzJkZTBmZmI0YmJkMzU5N2E3NTFkYTZiYTE1Njk5Y2I5 Mjk2YjkuLmQ3NDM5ODNlZDA5ZTEyYTJlNzY2MTUwNTkyY2ZmNmJkMWZkNmJlZmMgMTAwNjQ0Ci0t LSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBA QAorMjAxMi0wNC0xOSAgQ2hhbmdTZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAg ICAgICAgW0dUS10gU3VwcG9ydCB0aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEVuYWJsZWQgRmlsZVN5c3RlbSBmb3IgR1RL IHBvcnQuCisKKyAgICAgICAgKiBTY3JpcHRzL2J1aWxkLXdlYmtpdDoKKwogMjAxMi0wNC0xOCAg SGlyb25vcmkgQm9ubyAgPGhib25vQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTcGxpdCBTcGVs bENoZWNrZXI6OmRpZENoZWNrKCkgdG8gU3BlbGxDaGVja2VyOjpkaWRDaGVja1N1Y2NlZWRlZCgp IGFuZCBTcGVsbENoZWNrZXI6OmRpZENoZWNrQ2FuY2VsZWQoKQpkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy9idWlsZC13ZWJraXQgYi9Ub29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdAppbmRleCA2 ZWU5ZjEyZDczNTJiMTNiMzU5ZjYzOThlZjBhZmNkNjVhZGYzNzRiLi5mNmViZDIzMmNmNGRlYjJj MmQxNWQzZjkwZWRmMTZjMjcyYjdmZDg5IDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL2J1aWxk LXdlYmtpdAorKysgYi9Ub29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdApAQCAtMjAzLDcgKzIwMyw3 IEBAIG15IEBmZWF0dXJlcyA9ICgKICAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0RJUkVDVE9SWV9V UExPQUQiLCBkZWZhdWx0ID0+IDAsIHZhbHVlID0+IFwkZGlyZWN0b3J5VXBsb2FkU3VwcG9ydCB9 LAogCiAgICAgeyBvcHRpb24gPT4gImZpbGUtc3lzdGVtIiwgZGVzYyA9PiAiVG9nZ2xlIEZpbGVT eXN0ZW0gc3VwcG9ydCIsCi0gICAgICBkZWZpbmUgPT4gIkVOQUJMRV9GSUxFX1NZU1RFTSIsIGRl ZmF1bHQgPT4gaXNCbGFja0JlcnJ5KCksIHZhbHVlID0+IFwkZmlsZVN5c3RlbVN1cHBvcnQgfSwK KyAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0ZJTEVfU1lTVEVNIiwgZGVmYXVsdCA9PiAoaXNCbGFj a0JlcnJ5KCkgfHwgaXNHdGsoKSksIHZhbHVlID0+IFwkZmlsZVN5c3RlbVN1cHBvcnQgfSwKIAog ICAgIHsgb3B0aW9uID0+ICJmaWx0ZXJzIiwgZGVzYyA9PiAiVG9nZ2xlIFNWRyBGaWx0ZXJzIHN1 cHBvcnQiLAogICAgICAgZGVmaW5lID0+ICJFTkFCTEVfRklMVEVSUyIsIGRlZmF1bHQgPT4gKGlz QXBwbGVXZWJLaXQoKSB8fCBpc0d0aygpIHx8IGlzUXQoKSB8fCBpc0VmbCgpIHx8IGlzQmxhY2tC ZXJyeSgpKSwgdmFsdWUgPT4gXCRmaWx0ZXJzU3VwcG9ydCB9LApkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGI0ZDI1YTg0YmVm MWFhNTRlMGNhZTFmMzA5NWY3YzJhNjMwOWUzMmIuLjA0MWU3MzI0MjVjMjExZTM1OGNhODBiNGM4 NmI4ZTVmNjUwNDIwOTcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMi0wNC0xOSAgQ2hhbmdT ZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAgICAgICAgW0dUS10gU3VwcG9ydCB0 aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFsbCB0ZXN0cyBpbiBmYXN0L2ZpbGVzeXN0ZW0gYXJlIHBhc3NlZCBleGNlcHQg dGhlIG9uZXMgcmVsYXRlZCB3aXRoIHdvcmtlci4KKyAgICAgICAgRm9sbG93aW5nIHRlc3RzIGFy ZSBwYXNzZWQgaW4gZGV0YWlsLgorICAgICAgICBmYXN0L2ZpbGVzeXN0ZW0vKi5odG1sCisgICAg ICAgIGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5odG1sCisgICAg ICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2IuaHRtbAor ICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1ibG9iLWZh aWwuaHRtbAorCisgICAgICAgICogcGxhdGZvcm0vZ3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dDoK KwogMjAxMi0wNC0xOCAgVGFrYXNoaSBUb3lvc2hpbWEgIDx0b3lvc2hpbUBjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgVW5yZXZpZXdlZCwgYWRkIGV4cGVjdGVkLnR4dCBmb3IgY29va2llcy13cm9u Zy1kb21haW4tcmVqZWN0ZWQtcmVzdWx0LnBocCAuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9ndGsvdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0v Z3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAppbmRleCA4YzViZDBhNzRlNWM2N2NlZjc2MTczOTVj OWM0Yzg5YTRkMTY5YzgyLi4wNmQ5ZjA5ZDY3MDVlMGNjZGMzMDAzNDYwYjM5NDE2MTZmMWMzYTBi IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3RhdGlvbnMu dHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0X2V4cGVjdGF0aW9ucy50eHQK QEAgLTE1NSwxNCArMTU1LDEyIEBAIEJVR1dLNDI0MzIgOiBodHRwL3Rlc3RzL21pc2Mvd2VidGlt aW5nLXNsb3ctbG9hZC5waHAgPSBGQUlMCiBCVUdXSzQyNDMyIDogaHR0cC90ZXN0cy9taXNjL3dl YnRpbWluZy1zc2wucGhwID0gRkFJTAogQlVHV0s0MjQzMiA6IGh0dHAvdGVzdHMvbWlzYy93ZWJ0 aW1pbmctdHdvLXJlZGlyZWN0cy5waHAgPSBGQUlMCiAKLS8vIEZpbGVTeXN0ZW0gQVBJIGlzIG5v dCBzdXBwb3J0ZWQuCi1CVUdXS0dUSyBTS0lQIDogZmFzdC9maWxlc3lzdGVtID0gRkFJTAorLy8g RmlsZVN5c3RlbSBBUEkgaXMgbm90IHN1cHBvcnRlZCBjb21wbGV0ZWx5LgorLy8gV2UgZG9uJ3Qg c3VwcG9ydCB3b3JrZXJzIGZvciBGaWxlU3lzdGVtIHlldC4gaHR0cDovL3dlYmtpdC5vcmcvYi84 Mjg1NAorQlVHV0tHVEsgU0tJUCA6IGZhc3QvZmlsZXN5c3RlbS93b3JrZXJzID0gRkFJTAogQlVH V0tHVEsgU0tJUCA6IGh0dHAvdGVzdHMvZmlsZXN5c3RlbSA9IEZBSUwKIEJVR1dLR1RLIFNLSVAg OiBodHRwL3Rlc3RzL3NlY3VyaXR5L2ZpbGVzeXN0ZW0taWZyYW1lLWZyb20tcmVtb3RlLmh0bWwg PSBGQUlMCi1CVUdXS0dUSyBTS0lQIDogaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9z ZW5kLWZpbGUtYmxvYi5odG1sID0gRkFJTAotQlVHV0tHVEsgU0tJUCA6IGh0dHAvdGVzdHMvd2Vi c29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2ItZmFpbC5odG1sID0gRkFJTAogQlVHV0tH VEsgU0tJUCA6IGh0dHAvdGVzdHMvd29ya2Vycy90ZXJtaW5hdGUtZHVyaW5nLXN5bmMtb3BlcmF0 aW9uLmh0bWwgPSBGQUlMCi1CVUdXS0dUSyBTS0lQIDogZmFzdC9tdXRhdGlvbi9maWxlc3lzdGVt LWNhbGxiYWNrLWRlbGl2ZXJ5Lmh0bWwgPSBGQUlMCiAKIC8vIFJlcXVpcmVzIFdlYlAgc3VwcG9y dC4KIEJVR1dLR1RLIFNLSVAgOiBmYXN0L2NhbnZhcy9jYW52YXMtdG9EYXRhVVJMLXdlYnAuaHRt bCA9IEZBSUwKQEAgLTMxOSw3ICszMTcsNiBAQCBCVUdXSzY3MDA3IERFQlVHIDogZmFzdC9ydWJ5 L2dlbmVyYXRlZC1iZWZvcmUtYW5kLWFmdGVyLWNvdW50ZXItZG9lc250LWNyYXNoLmh0bQogQlVH V0s3NjgxNCBERUJVRyA6IGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtZ2V0Lnho dG1sID0gQ1JBU0gKIAogQlVHV0s3NDI5NyA6IGh0dHAvdGVzdHMvc2VjdXJpdHkvY3Jvc3Mtb3Jp Z2luLXhzbC1yZWRpcmVjdC1CTE9DS0VELmh0bWwgPSBQQVNTIENSQVNICi1CVUdXSzgzNjc5IERF QlVHIDogZWRpdGluZy91bmRvL3VuZG8tc21hcnQtZGVsZXRlLXJldmVyc2VkLXNlbGVjdGlvbi5o dG1sID0gQ1JBU0gKIAogLy8gQ3Jhc2hlcyBvbiBHU3RyZWFtZXIgc2lkZSB3aGVuIGxvYWRpbmcg b25lIG9mIHRoZSBtZWRpYSBlbGVtZW50cyBvZiB0aGUgdGVzdC4KIEJVR1dLNTAxNTUgOiBmYXN0 L2V2ZW50cy90YWJpbmRleC1mb2N1cy1ibHVyLWFsbC5odG1sID0gQ1JBU0gK 138384 2012-04-23 10:56:28 -0700 2022-02-28 04:01:34 -0800 Patch bug-58443-20120424025626.patch text/plain 74566 kevin.cs.oh U3VidmVyc2lvbiBSZXZpc2lvbjogMTE0NjI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRiNGMxYTgyYjQwNjA5ZDA1NjlkMjRj ZjE2MzM0OWMwZTk1MzJiNzMuLmRjNDQyOTdjN2Y1YWFmZmU3OTYxNWUzNGY2YjA3YzkwMzVmZjli YmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMDQtMjMgIENoYW5nU2VvayBPaCAgPHNoaXZh bWlkb3dAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIFN1cHBvcnQgdGhlIGZpbGUgc3lzdGVt IEFQSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg0 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2lu ZyBHUmVmUHRyL0dPd25QdHIgZm9yIEdGaWxlSU9TdHJlYW0sIEdPdXRwdXRTdHJlYW0gYW5kIEdT dHJpbmcgaXMgbW9yZSBjb252ZW5pZW50CisgICAgICAgIHRvIGhhbmRsZSBhbmQgcmVsZWFzZS4g QnkgdXNpbmcgR093blB0cjxHU3RyaW5nPiwgd2UgZG9uJ3QgbmVlZCB0byBjYXJlIG9mIGZyZWVp bmcKKyAgICAgICAgaXRzIG1lbW9yeSBhbGxvY2F0aW9uLiBHT3duUHRyPEdPdXRwdXRTdHJlYW0+ IGNsb3NlcyBvdXRwdXQgc3RyZWFtIGltcGxpY2l0bHkKKyAgICAgICAgd2hlbiB0aGUgdmFyaWFi bGUgaXMgcmVsZWFzZWQuIEFuZCBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IHJlZHVjZXMgYSBpdHMg cmVmZXJlbmNlIGNvdW50CisgICAgICAgIGltcGxpY2l0bHkgd2hlbiBmaW5hbGl6aW5nLgorCisg ICAgICAgICogd3RmL2dvYmplY3QvR093blB0ci5jcHA6CisgICAgICAgIChXVEY6OkdTdHJpbmcp OgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6R091dHB1dFN0cmVhbSk6CisgICAgICAg ICogd3RmL2dvYmplY3QvR093blB0ci5oOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKiB3dGYv Z29iamVjdC9HVHlwZWRlZnMuaDoKKwogMjAxMi0wNC0xOCAgTXlsZXMgTWF4ZmllbGQgIDxtbWF4 ZmllbGRAZ29vZ2xlLmNvbT4KIAogICAgICAgICBTb21laG93LCB0aGVyZSdzIGFuIGVycmFudCBi YWNrc2xhc2ggaW4gbXkgbGFzdCBXVEYgcGF0Y2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA5Yjc3MTg4Zjk0YzYz NmQ4ZDE2YWY1YWFmNDZiMDg3Njc3OGQxY2I5Li4wY2ZhNjZmMDNmZjc3NTY0ZjEyMDgyMzhjYzlk Mjg1OWMwMjFmZDAxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTM5IEBACisyMDEyLTA0LTIzICBD aGFuZ1Nlb2sgT2ggIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKworICAgICAgICBbR1RLXSBTdXBw b3J0IHRoZSBmaWxlIHN5c3RlbSBBUEkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTU4NDQzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGhpcyBwYXRjaCBpcyBiYXNlZCBvbiBaYW4gRG9iZXJzZWsncyBvcmln aW5hbCBvbmUgZm9yIGJ1ZzU4NDQzLgorICAgICAgICBUaGlzIGJyaW5ncyBGaWxlU3lzdGVtIEFQ SSB0byBndGsgcG9ydC4gVGhpcyBhZGRzIG5ldyBpbnRlcmZhY2VzIGxpa2UKKyAgICAgICAgQXN5 bmNGaWxlU3lzdGVtR3RrLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGssIEFzeW5jRmlsZVdy aXRlckd0aywgQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrCisgICAgICAgIGFuZCBBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ay4gVGhlc2UgYXJlIGNoaWxkIGNsYXNzZXMgaW1wbGVtZW50 aW5nIHRoZSBpbnRlcmZhY2VzCisgICAgICAgIG9mIGVhY2ggcGFyZW50IGNsYXNzZXMgZXhjZXB0 IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLiBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0aworICAgICAgICBpcyBhIGhlbHBlciBjbGFzcy4gSXQgcmV0YWlucyBzb21lIHVz ZWZ1bCB2YXJpYWJsZXMsIGFuZCBjb250cm9scyBwb3N0aW5nIHRhc2tzIHRvCisgICAgICAgIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQgd2hpY2ggbWlnaHQgYmUgZWl0aGVyIGEgRG9jdW1lbnQgb2Jq ZWN0IG9yIGEgV29ya2VyLgorICAgICAgICBVbmZvcnR1bmF0ZWx5LCBXb3JrZXIgZm9yIGZpbGVz eXN0ZW0gaXMgbm90IHN1cHBvcnRlZCB5ZXQsIEkgcGxhbiB0byBzdXBwb3J0IGl0IGluIHRoZSBu ZXh0IHBhdGNoLgorCisgICAgICAgIFRlc3Q6IGZhc3QvZmlsZXN5c3RlbS8qLmh0bWwKKyAgICAg ICAgICAgICAgZmFzdC9tdXRhdGlvbi9maWxlc3lzdGVtLWNhbGxiYWNrLWRlbGl2ZXJ5Lmh0bWwK KyAgICAgICAgICAgICAgaHR0cC90ZXN0cy93ZWJzb2NrZXQvdGVzdHMvaHliaS9zZW5kLWZpbGUt YmxvYi5odG1sCisgICAgICAgICAgICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkv c2VuZC1maWxlLWJsb2ItZmFpbC5odG1sCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFt OiBBZGRlZCBzb21lIGZpbGVzIHRvIGJ1aWxkIG5ld2x5IGZvciBGaWxlU3lzdGVtLgorICAgICAg ICAqIE1vZHVsZXMvZmlsZXN5c3RlbS9Mb2NhbEZpbGVTeXN0ZW0uY3BwOiBXZSBzaG91bGQgbm90 IGJ1aWxkIHRoaXMgZmlsZS4gc28gYWRkZWQgZXJyb3IgbWVzc2FnZS4KKyAgICAgICAgKiBwbGF0 Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcDogQWRkZWQuIFRoaXMgaXMg YW4gaW1wbGVtZW50YXRpb24gb2YgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLgorICAgICAgICAo V2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6 OkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3Jt RGlkU3VjY2VlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrc0d0azo6ZGlkU3VjY2VlZCk6CisgICAgICAgIChXZWJDb3JlOjpwZXJmb3JtRGlkT3Bl bkZpbGVTeXN0ZW1DYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs6OmRpZE9wZW5GaWxlU3lzdGVtKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZv cm1EaWRSZWFkTWV0YWRhdGFDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmRpZFJlYWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpw ZXJmb3JtRGlkUmVhZERpcmVjdG9yeUFuZEZpbmlzaGVkQ2FsbGJhY2spOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRSZWFkRGlyZWN0b3J5KToKKyAg ICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRDcmVhdGVGaWxlV3JpdGVyQ2FsbGJhY2spOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRDcmVhdGVGaWxl V3JpdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2spOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpkaWRGYWlsKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmg6IEFkZGVk LgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpEaXJlY3RvcnlJbmZvOjpE aXJlY3RvcnlJbmZvKToKKyAgICAgICAgKERpcmVjdG9yeUluZm8pOgorICAgICAgICAoQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxl U3lzdGVtR3RrLmNwcDogQWRkZWQgc29tZSBtaXNzaW5nIEFQSXMuIFRoaXMgaXMgYSBjaGlsZCBj bGFzcyBvZiBBc3luY0ZpbGVTeXN0ZW0uCisgICAgICAgIChXZWJDb3JlOjp0b0ZpbGVFcnJvckNv ZGUpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjp2YWxpZGF0ZUZpbGVU eXBlcyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbTo6aXNWYWxpZFR5cGUpOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtOjpvcGVuRmlsZVN5c3RlbSk6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW06OmNyYWNrRmlsZVN5c3RlbVVSTCk6CisgICAgICAgIChX ZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OkFzeW5jRmlsZVN5c3RlbUd0ayk6CisgICAgICAg IChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6On5Bc3luY0ZpbGVTeXN0ZW1HdGspOgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjp0b1VSTCk6CisgICAgICAgIChXZWJD b3JlOjptb3ZlQXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpt b3ZlKToKKyAgICAgICAgKFdlYkNvcmU6OmNvcHlSZWN1cnNpdmVseSk6CisgICAgICAgIChXZWJD b3JlOjpjb3B5QXN5bmMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtR3RrOjpj b3B5KToKKyAgICAgICAgKFdlYkNvcmU6OnJlbW92ZUZpbGVSZWN1cnNpdmVseSk6CisgICAgICAg IChXZWJDb3JlOjpyZW1vdmVBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0 ZW1HdGs6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnJl bW92ZVJlY3Vyc2l2ZWx5KToKKyAgICAgICAgKFdlYkNvcmU6OnJlYWRNZXRhZGF0YUFzeW5jKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6cmVhZE1ldGFkYXRhKToKKyAg ICAgICAgKFdlYkNvcmU6OmNyZWF0ZU9iamVjdEFuZFJlYWRNZXRhZGF0YUFzeW5jKToKKyAgICAg ICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFk YXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6Y3JlYXRlRmlsZSk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVjdG9yeSk6 CisgICAgICAgIChXZWJDb3JlOjpvYmplY3RFeGlzdHNBc3luYyk6CisgICAgICAgIChXZWJDb3Jl OjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmZpbGVFeGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNGaWxlU3lzdGVtR3RrOjpkaXJlY3RvcnlFeGlzdHMpOgorICAgICAgICAoV2ViQ29yZTo6cmVh ZERpcmVjdG9yeUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6 cmVhZERpcmVjdG9yeSk6CisgICAgICAgIChXZWJDb3JlOjpjcmVhdGVXcml0ZXJBc3luYyk6Cisg ICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVdyaXRlcik6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZVNuYXBzaG90RmlsZUFuZFJl YWRNZXRhZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1HdGs6OnNldFRh c2tDb250cm9sbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5c3RlbUd0azo6dmly dHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lz dGVtR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSk6CisgICAgICAgICogcGxhdGZvcm0v Z3RrL0FzeW5jRmlsZVN5c3RlbUd0ay5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChB c3luY0ZpbGVTeXN0ZW1HdGspOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ay5jcHA6IEFkZGVkLiBUaGlzIGlzIGEgaGVscGVyIGNsYXNzIHRv IGNvbnRyb2wgcG9zdGluZyB0YXNrIHRvIGEgdGFyZ2V0IHRocmVhZC4KKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0azo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGspOgorICAgICAgICAoV2ViQ29y ZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6On5Bc3luY0ZpbGVTeXN0ZW1UYXNr Q29udHJvbGxlckd0ayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29u dHJvbGxlckd0azo6dW5pcXVlTW9kZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0azo6cG9zdFRhc2tUb01haW5UaHJlYWQpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9k ZSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6 cG9zdENhbGxiYWNrVGFzayk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVTeXN0ZW1UYXNr Q29udHJvbGxlckd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUpOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OmNhbmNlbFdyaXRlcklmTmVj ZXNzYXJ5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGsuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVN5 c3RlbVRhc2tDb250cm9sbGVyR3RrOjpzeW5jaHJvbm91cyk6CisgICAgICAgIChXZWJDb3JlOjpB c3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6c2V0V3JpdGVyVG9DYW5jZWwpOgorICAg ICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuY3BwOiBBZGRlZC4g VGhpcyBpcyBhIGNoaWxkIGNsYXNzIGltcGxlbWVudCBvZiBBeXNuY0ZpbGVXcml0ZXJDbGllbnQu CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRXcml0ZUNh bGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRUcnVuY2F0ZUNhbGxiYWNrKToK KyAgICAgICAgKFdlYkNvcmU6OnBlcmZvcm1EaWRGYWlsQ2FsbGJhY2spOgorICAgICAgICAoV2Vi Q29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsp OgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyQ2xpZW50R3RrOjpkaWRXcml0ZSk6 CisgICAgICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRl KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6ZGlkRmFpbCk6 CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oOiBBZGRl ZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3Rr KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6Y3JlYXRlKToK KyAgICAgICAgKFdlYkNvcmU6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0azo6dGFza0NvbnRyb2xs ZXIpOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwOiBBZGRl ZC4gVGhpcyBpcyBhIGNoaWxkIGNsYXNzIG9mIEFzeW5jRmlsZVdyaXRlci4KKyAgICAgICAgKFdl YkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjpjcmVhdGUpOgor ICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjpBc3luY0ZpbGVXcml0ZXJHdGsp OgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVBc3luYyk6CisgICAgICAgIChXZWJDb3JlOjpBc3lu Y0ZpbGVXcml0ZXJHdGs6OndyaXRlKToKKyAgICAgICAgKFdlYkNvcmU6OnRydW5jYXRlQXN5bmMp OgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNGaWxlV3JpdGVyR3RrOjp0cnVuY2F0ZSk6CisgICAg ICAgIChXZWJDb3JlOjpBc3luY0ZpbGVXcml0ZXJHdGs6OmFib3J0KToKKyAgICAgICAgKFdlYkNv cmU6OkFzeW5jRmlsZVdyaXRlckd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUpOgorICAg ICAgICAqIHBsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlKToKKyAgICAgICAgKEFzeW5jRmlsZVdyaXRlckd0ayk6CisgICAgICAgICogcGxh dGZvcm0vZ3RrL0xvY2FsRmlsZVN5c3RlbUd0ay5jcHA6IEFkZGVkLiBQb3J0IHNwZWNpZmljIGlt cGxlbWVudGF0aW9uIGZvciBMb2NhbEZpbGVTeXN0ZW0gY2xhc3MgaXMgaGVyZS4gV2Ugc2hvdWxk IHVzZSB0aGlzIGZpbGUgaW5zdGVhZCBvZiBMb2NhbEZpbGVTeXN0ZW0uY3BwLgorICAgICAgICAo V2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OmluaXRpYWxpemVM b2NhbEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpsb2Nh bEZpbGVTeXN0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpmaWxlU3lz dGVtQmFzZVBhdGgpOgorICAgICAgICAoV2ViQ29yZTo6b3BlbkZpbGVTeXN0ZW0pOgorICAgICAg ICAoV2ViQ29yZTo6TG9jYWxGaWxlU3lzdGVtOjpyZWFkRmlsZVN5c3RlbSk6CisgICAgICAgIChX ZWJDb3JlOjpMb2NhbEZpbGVTeXN0ZW06OnJlcXVlc3RGaWxlU3lzdGVtKToKKwogMjAxMi0wNC0x OCAgVnNldm9sb2QgVmxhc292ICA8dnNldmlrQGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIg SW5zcGVjdG9yOiBObyByZXNwb25zZSBib2R5IGF2YWlsYWJsZSBmb3IgY2FjaGVkIHJlc291cmNl IHJlcXVlc3RzIHdpdGggZXJyb3Igc3RhdHVzIGNvZGVzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dU Ri93dGYvZ29iamVjdC9HT3duUHRyLmNwcCBiL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0 ci5jcHAKaW5kZXggZGZlMTg3ZDc4ODdmZjU0ZWEwMjdjMWM5ZGM1YzA2YmQ3YmRiNWNmMS4uM2Fh MDc1OTk0NzZkNzRlMjJmZGY0ZTdjZDBlODU3N2EyODE1OTJiNCAxMDA2NDQKLS0tIGEvU291cmNl L1dURi93dGYvZ29iamVjdC9HT3duUHRyLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0 L0dPd25QdHIuY3BwCkBAIC00Miw2ICs0MiwxNiBAQCB0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25l ZEdQdHI8R1NMaXN0PihHU0xpc3QqIHB0cikKICAgICBnX3NsaXN0X2ZyZWUocHRyKTsKIH0KIAor dGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdTdHJpbmc+KEdTdHJpbmcqIHB0cikKK3sK KyAgICBnX3N0cmluZ19mcmVlKHB0ciwgdHJ1ZSk7Cit9CisKK3RlbXBsYXRlIDw+IHZvaWQgZnJl ZU93bmVkR1B0cjxHT3V0cHV0U3RyZWFtPihHT3V0cHV0U3RyZWFtKiBwdHIpCit7CisgICAgZ19v dXRwdXRfc3RyZWFtX2Nsb3NlKHB0ciwgMCwgMCk7Cit9CisKIHRlbXBsYXRlIDw+IHZvaWQgZnJl ZU93bmVkR1B0cjxHUGF0dGVyblNwZWM+KEdQYXR0ZXJuU3BlYyogcHRyKQogewogICAgIGlmIChw dHIpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dPd25QdHIuaCBiL1NvdXJj ZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oCmluZGV4IDRiMmRjYjc3YjI1MDAwYzJlNWI2ODA4 YTRjNzQ4NGMyYmU2ZDZjYTUuLjljMDY3ZDcxYTY3OTU1Y2M0YmY4ZDhmYzhkZGYyMGQ5YjIyYTFj NzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oCisrKyBiL1Nv dXJjZS9XVEYvd3RmL2dvYmplY3QvR093blB0ci5oCkBAIC0zNiw2ICszNiw4IEBAIHRlbXBsYXRl IDx0eXBlbmFtZSBUPiBpbmxpbmUgdm9pZCBmcmVlT3duZWRHUHRyKFQqIHB0cik7CiB0ZW1wbGF0 ZTw+IHZvaWQgZnJlZU93bmVkR1B0cjxHRXJyb3I+KEdFcnJvciopOwogdGVtcGxhdGU8PiB2b2lk IGZyZWVPd25lZEdQdHI8R0xpc3Q+KEdMaXN0Kik7CiB0ZW1wbGF0ZTw+IHZvaWQgZnJlZU93bmVk R1B0cjxHU0xpc3Q+KEdTTGlzdCopOwordGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1N0 cmluZz4oR1N0cmluZyopOwordGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R091dHB1dFN0 cmVhbT4oR091dHB1dFN0cmVhbSopOwogdGVtcGxhdGU8PiB2b2lkIGZyZWVPd25lZEdQdHI8R1Bh dHRlcm5TcGVjPihHUGF0dGVyblNwZWMqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRy PEdEaXI+KEdEaXIqKTsKIHRlbXBsYXRlPD4gdm9pZCBmcmVlT3duZWRHUHRyPEdUaW1lcj4oR1Rp bWVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5oIGIv U291cmNlL1dURi93dGYvZ29iamVjdC9HVHlwZWRlZnMuaAppbmRleCBlMjkyNTBiZWYyZWY0ZDVl OWViZTVjMmIwNTAzNzNiYmE4NTY0ZjlhLi43YTVlOWYzY2EwN2RhNTVlNTY4YzU3MWQ0ZTViYzlm ODU0NWViNTIyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9nb2JqZWN0L0dUeXBlZGVmcy5o CisrKyBiL1NvdXJjZS9XVEYvd3RmL2dvYmplY3QvR1R5cGVkZWZzLmgKQEAgLTQ4LDE3ICs0OCwy MCBAQCB0eXBlZGVmIHN0cnVjdCBfR2RrRXZlbnRFeHBvc2UgR2RrRXZlbnRFeHBvc2U7CiB0eXBl ZGVmIHN0cnVjdCBfR2RrUGl4YnVmIEdka1BpeGJ1ZjsKIHR5cGVkZWYgc3RydWN0IF9HRXJyb3Ig R0Vycm9yOwogdHlwZWRlZiBzdHJ1Y3QgX0dGaWxlIEdGaWxlOwordHlwZWRlZiBzdHJ1Y3QgX0dG aWxlSU9TdHJlYW0gR0ZpbGVJT1N0cmVhbTsKIHR5cGVkZWYgc3RydWN0IF9HSGFzaFRhYmxlIEdI YXNoVGFibGU7CiB0eXBlZGVmIHN0cnVjdCBfR0lucHV0U3RyZWFtIEdJbnB1dFN0cmVhbTsKIHR5 cGVkZWYgc3RydWN0IF9HTGlzdCBHTGlzdDsKIHR5cGVkZWYgc3RydWN0IF9HTWFpbkNvbnRleHQg R01haW5Db250ZXh0OwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluTG9vcCBHTWFpbkxvb3A7Cit0eXBl ZGVmIHN0cnVjdCBfR091dHB1dFN0cmVhbSBHT3V0cHV0U3RyZWFtOwogdHlwZWRlZiBzdHJ1Y3Qg X0dQYXR0ZXJuU3BlYyBHUGF0dGVyblNwZWM7CiB0eXBlZGVmIHN0cnVjdCBfR1BvbGxhYmxlT3V0 cHV0U3RyZWFtIEdQb2xsYWJsZU91dHB1dFN0cmVhbTsKIHR5cGVkZWYgc3RydWN0IF9HU0xpc3Qg R1NMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX0dTb2NrZXRDbGllbnQgR1NvY2tldENsaWVudDsKIHR5 cGVkZWYgc3RydWN0IF9HU29ja2V0Q29ubmVjdGlvbiBHU29ja2V0Q29ubmVjdGlvbjsKIHR5cGVk ZWYgc3RydWN0IF9HU291cmNlIEdTb3VyY2U7Cit0eXBlZGVmIHN0cnVjdCBfR1N0cmluZyBHU3Ry aW5nOwogdHlwZWRlZiBzdHJ1Y3QgX0dWYXJpYW50IEdWYXJpYW50OwogdHlwZWRlZiB1bmlvbiBf R2RrRXZlbnQgR2RrRXZlbnQ7CiB0eXBlZGVmIHN0cnVjdCBfR1RpbWVyIEdUaW1lcjsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29y ZS9HTlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IDRmODE3MWMyYTkzZjQ3NDQ5YjBhYjBjMTM5MDIw YmZlNDZjNjA1OGYuLjVlNDJmYjRhNjAxYThjM2U1ZTU2NjkzNjMzMDM3OWI3MjcxZTQ1MWIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNl L1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAtMTAyNiw3ICsxMDI2LDYgQEAgd2ViY29y ZV9tb2R1bGVzX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3Rl bS9GaWxlV3JpdGVyQ2FsbGJhY2suaCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lz dGVtL0ZpbGVXcml0ZXJTeW5jLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvTW9kdWxlcy9maWxlc3lz dGVtL0ZpbGVXcml0ZXJTeW5jLmggXAotCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3Rl bS9Mb2NhbEZpbGVTeXN0ZW0uY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0 ZW0vTG9jYWxGaWxlU3lzdGVtLmggXAogCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3Rl bS9NZXRhZGF0YUNhbGxiYWNrLmggXAogCVNvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3Rl bS9NZXRhZGF0YS5oIFwKQEAgLTQ3MDAsNiArNDY5OSw3IEBAIHdlYmNvcmVndGtfc291cmNlcyAr PSBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0d0a1ZlcnNpb25pbmcuaCBcCiAJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0tleUJpbmRpbmdUcmFuc2xhdG9yLmNwcCBcCiAJU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0tleUJpbmRpbmdUcmFuc2xhdG9yLmggXAorCVNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbEZpbGVTeXN0ZW1HdGsuY3BwIFwKIAlTb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxpemVkU3RyaW5nc0d0ay5jcHAgXAogCVNvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9NYWluRnJhbWVTY3JvbGxiYXJHdGsuY3BwIFwKIAlTb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvTWFpbkZyYW1lU2Nyb2xsYmFyR3RrLmggXApAQCAtNDk5NCw5 ICs0OTk0LDE5IEBAIGRvbV9iaW5kaW5nX2lkbHMgKz0gXAogCSQoV2ViQ29yZSkvTW9kdWxlcy9m aWxlc3lzdGVtL01ldGFkYXRhQ2FsbGJhY2suaWRsIFwKIAkkKFdlYkNvcmUpL01vZHVsZXMvZmls ZXN5c3RlbS9Xb3JrZXJDb250ZXh0RmlsZVN5c3RlbS5pZGwKIAotd2ViY29yZWd0a19zb3VyY2Vz ICs9IFwKK3dlYmNvcmVfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVN5c3RlbUd0ay5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVTeXN0ZW1HdGsuaAorCit3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAorCVNvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuY3BwIFwKKwlT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmgg XAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJv bGxlckd0ay5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0 ZW1UYXNrQ29udHJvbGxlckd0ay5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5 bmNGaWxlV3JpdGVyQ2xpZW50R3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvQXN5bmNGaWxlV3JpdGVyR3RrLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVdyaXRlckd0ay5oCiBlbmRpZiAjIEVORCBFTkFCTEVfRklMRV9TWVNURU0KIAog IyAtLS0tCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2ZpbGVzeXN0ZW0vTG9j YWxGaWxlU3lzdGVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9Mb2Nh bEZpbGVTeXN0ZW0uY3BwCmluZGV4IDhmMDE2OWVlYWJiYTkzZmY0ZjE1NmQ3YzIzNDdiNmMwYjI3 ZDViYmEuLjczZjIxOGI0YTAzNzFkMDA0YTE0Y2JhMDE4MjYxYzhiMmU0OWM2NjQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9Mb2NhbEZpbGVTeXN0ZW0uY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZmlsZXN5c3RlbS9Mb2NhbEZpbGVTeXN0ZW0u Y3BwCkBAIC0zMSw4ICszMSw4IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiTG9j YWxGaWxlU3lzdGVtLmgiCiAKLSNpZiBQTEFURk9STShDSFJPTUlVTSkKLSNlcnJvciAiQ2hyb21p dW0gc2hvdWxkIG5vdCBjb21waWxlIHRoaXMgZmlsZSBhbmQgaW5zdGVhZCBkZWZpbmUgaXRzIG93 biB2ZXJzaW9uIG9mIHRoZXNlIGZhY3Rvcmllcy4iCisjaWYgUExBVEZPUk0oQ0hST01JVU0pIHx8 IFBMQVRGT1JNKEdUSykKKyNlcnJvciAiQ2hyb21pdW0gJiBXZWJLaXRHVEsrIHNob3VsZCBub3Qg Y29tcGlsZSB0aGlzIGZpbGUgYW5kIGluc3RlYWQgZGVmaW5lIGl0cyBvd24gdmVyc2lvbiBvZiB0 aGVzZSBmYWN0b3JpZXMuIgogI2VuZGlmCiAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmIyNjMwNTQyNDYyNzM1NWYyNzMwMzM1MjRmZmY0 MmQ5NjZkZmVlMTkKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmNwcApAQCAtMCwwICsxLDE1OSBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNv bT4KKyAqIENvcHlyaWdodCAoQykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwu Y29tPgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0 aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZv dW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0 b24sIE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1 ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ay5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lT VEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNG aWxlV3JpdGVyLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgiCisjaW5jbHVkZSAiRmls ZU1ldGFkYXRhLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK3RlbXBsYXRlPD4gc3RydWN0IENyb3NzVGhyZWFkQ29waWVyQmFz ZTxmYWxzZSwgZmFsc2UsIEZpbGVNZXRhZGF0YT4geworICAgIHR5cGVkZWYgRmlsZU1ldGFkYXRh IFR5cGU7CisgICAgc3RhdGljIEZpbGVNZXRhZGF0YSBjb3B5KGNvbnN0IEZpbGVNZXRhZGF0YSYg b3JpZ2luYWwpCisgICAgeworICAgICAgICBGaWxlTWV0YWRhdGEgbWV0YWRhdGE7CisgICAgICAg IG1ldGFkYXRhLm1vZGlmaWNhdGlvblRpbWUgPSBvcmlnaW5hbC5tb2RpZmljYXRpb25UaW1lOwor ICAgICAgICBtZXRhZGF0YS5sZW5ndGggPSBvcmlnaW5hbC5sZW5ndGg7CisgICAgICAgIG1ldGFk YXRhLnR5cGUgPSBvcmlnaW5hbC50eXBlOworICAgICAgICBtZXRhZGF0YS5wbGF0Zm9ybVBhdGgg PSBvcmlnaW5hbC5wbGF0Zm9ybVBhdGg7CisgICAgICAgIHJldHVybiBtZXRhZGF0YTsKKyAgICB9 Cit9OworCit0ZW1wbGF0ZTw+IHN0cnVjdCBDcm9zc1RocmVhZENvcGllckJhc2U8ZmFsc2UsIGZh bHNlLCBWZWN0b3I8RGlyZWN0b3J5SW5mbz4gPiB7CisgICAgdHlwZWRlZiBWZWN0b3I8RGlyZWN0 b3J5SW5mbz4gVHlwZTsKKyAgICBzdGF0aWMgVHlwZSBjb3B5KGNvbnN0IFZlY3RvcjxEaXJlY3Rv cnlJbmZvPiYgZW50cmllcykKKyAgICB7CisgICAgICAgIFZlY3RvcjxEaXJlY3RvcnlJbmZvPiBu ZXdFbnRyaWVzKGVudHJpZXMuc2l6ZSgpKTsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkg PCBlbnRyaWVzLnNpemUoKTsgKytpKSB7CisgICAgICAgICAgICBTdHJpbmcgbmFtZSA9IGVudHJp ZXNbaV0ubmFtZTsKKyAgICAgICAgICAgIG5ld0VudHJpZXNbaV0uaXNEaXJlY3RvcnkgPSBlbnRy aWVzW2ldLmlzRGlyZWN0b3J5OworICAgICAgICAgICAgbmV3RW50cmllc1tpXS5uYW1lID0gbmFt ZS5pc29sYXRlZENvcHkoKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gbmV3RW50cmllczsK KyAgICB9Cit9OworCitQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywg Ym9vbCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0ayhjb250ZXh0LCBjYWxsYmFja3MsIHN5bmNocm9ub3VzKSk7Cit9CisK K1Bhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBBc3luY0ZpbGVTeXN0ZW1D YWxsYmFja3NHdGs6OmNyZWF0ZShBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFz a0NvbnRyb2xsZXIsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFj a3MsIGNvbnN0IFN0cmluZyYgbW9kZSkKK3sKKyAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0ayh0YXNrQ29udHJvbGxlciwgY2FsbGJhY2tzLCBtb2RlKSk7 Cit9CisKKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3NHdGsoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKKyAgICA6 IG1fc3luY2hyb25vdXMoc3luY2hyb25vdXMpCisgICAgLCBtX3Rhc2tNb2RlKCIiKQorICAgICwg bV90YXNrQ29udHJvbGxlcihBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azo6Y3JlYXRl KGNvbnRleHQsIHN5bmNocm9ub3VzKSkKKyAgICAsIG1fY2FsbGJhY2tzKGNhbGxiYWNrcykKK3sK K30KKworQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGsoQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBjb25zdCBTdHJp bmcmIG1vZGUpCisgICAgOiBtX3N5bmNocm9ub3VzKGZhbHNlKQorICAgICwgbV90YXNrTW9kZSht b2RlKQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxlcikKKyAgICAsIG1fY2Fs bGJhY2tzKGNhbGxiYWNrcykKK3sKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZFN1Y2NlZWRD YWxsYmFjayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKK3sKKyAgICBjYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsK K30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmRpZFN1Y2NlZWQoKQorewor ICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3JlYXRlQ2FsbGJhY2tUYXNr KCZwZXJmb3JtRGlkU3VjY2VlZENhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCkpLCBtX3Rh c2tNb2RlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZE9wZW5GaWxlU3lzdGVtQ2FsbGJh Y2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IFN0cmluZyYgbmFtZSwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgY2FsbGJhY2tzLT5kaWRPcGVuRmlsZVN5c3Rl bShuYW1lLCBmaWxlU3lzdGVtKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmRpZE9wZW5GaWxlU3lzdGVtKGNvbnN0IFN0cmluZyYgbmFtZSwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW0+IGZpbGVTeXN0ZW0pCit7CisgICAgQXN5bmNGaWxlU3lzdGVtR3RrKiBmaWxl U3lzdGVtR3RrID0gc3RhdGljX2Nhc3Q8QXN5bmNGaWxlU3lzdGVtR3RrKj4oZmlsZVN5c3RlbS5n ZXQoKSk7CisKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUo KTsKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5zZXRDdXJyZW50VGFza01vZGUobW9kZSk7CisgICAg bV90YXNrQ29udHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBl cmZvcm1EaWRPcGVuRmlsZVN5c3RlbUNhbGxiYWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCksIG5h bWUsIGZpbGVTeXN0ZW0pLCBtb2RlKTsKKworICAgIGZpbGVTeXN0ZW1HdGstPnNldFRhc2tDb250 cm9sbGVyKG1fdGFza0NvbnRyb2xsZXIucmVsZWFzZSgpKTsKKyAgICBmaWxlU3lzdGVtR3RrLT53 YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworfQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlk UmVhZE1ldGFkYXRhQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8 QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGNvbnN0IEZpbGVNZXRhZGF0YSYg bWV0YWRhdGEpCit7CisgICAgY2FsbGJhY2tzLT5kaWRSZWFkTWV0YWRhdGEobWV0YWRhdGEpOwor fQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkUmVhZE1ldGFkYXRhKGNv bnN0IEZpbGVNZXRhZGF0YSYgbWV0YWRhdGEpCit7CisgICAgbV90YXNrQ29udHJvbGxlci0+cG9z dENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRSZWFkTWV0YWRhdGFD YWxsYmFjaywgbV9jYWxsYmFja3MucmVsZWFzZSgpLCBtZXRhZGF0YSksIG1fdGFza01vZGUpOwor fQorCitzdGF0aWMgdm9pZCBwZXJmb3JtRGlkUmVhZERpcmVjdG9yeUFuZEZpbmlzaGVkQ2FsbGJh Y2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzPiBjYWxsYmFja3MsIFZlY3RvcjxEaXJlY3RvcnlJbmZvPiYgZW50cmllcywgYm9vbCBo YXNNb3JlKQoreworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgZW50cmllcy5zaXplKCk7ICsr aSkKKyAgICAgICAgY2FsbGJhY2tzLT5kaWRSZWFkRGlyZWN0b3J5RW50cnkoZW50cmllc1tpXS5u YW1lLCBlbnRyaWVzW2ldLmlzRGlyZWN0b3J5KTsKKyAgICBjYWxsYmFja3MtPmRpZFJlYWREaXJl Y3RvcnlFbnRyaWVzKGhhc01vcmUpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr c0d0azo6ZGlkUmVhZERpcmVjdG9yeShWZWN0b3I8RGlyZWN0b3J5SW5mbz4mIGVudHJpZXMsIGJv b2wgaGFzTW9yZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNy ZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFJlYWREaXJlY3RvcnlBbmRGaW5pc2hlZENhbGxi YWNrLCBtX2NhbGxiYWNrcy5yZWxlYXNlKCksIGVudHJpZXMsIGhhc01vcmUpLCBtX3Rhc2tNb2Rl KTsKK30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZENyZWF0ZUZpbGVXcml0ZXJDYWxsYmFjayhT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3M+IGNhbGxiYWNrcywgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXI+IHdyaXRlciwgbG9uZyBs b25nIGxlbmd0aCkKK3sKKyAgICBjYWxsYmFja3MtPmRpZENyZWF0ZUZpbGVXcml0ZXIod3JpdGVy LCBsZW5ndGgpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6ZGlkQ3Jl YXRlRmlsZVdyaXRlcihQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4gd3JpdGVyLCBsb25nIGxv bmcgbGVuZ3RoKQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RDYWxsYmFja1Rhc2soY3Jl YXRlQ2FsbGJhY2tUYXNrKCZwZXJmb3JtRGlkQ3JlYXRlRmlsZVdyaXRlckNhbGxiYWNrLCBtX2Nh bGxiYWNrcy5yZWxlYXNlKCksIHdyaXRlciwgbGVuZ3RoKSwgbV90YXNrTW9kZSk7Cit9CisKK3N0 YXRpYyB2b2lkIHBlcmZvcm1EaWRGYWlsQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCos IFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MsIGludCBjb2Rl KQoreworICAgIGNhbGxiYWNrcy0+ZGlkRmFpbChjb2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVT eXN0ZW1DYWxsYmFja3NHdGs6OmRpZEZhaWwoaW50IGNvZGUpCit7CisgICAgbV90YXNrQ29udHJv bGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRGYWls Q2FsbGJhY2ssIG1fY2FsbGJhY2tzLnJlbGVhc2UoKSwgY29kZSksIG1fdGFza01vZGUpOworfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoRklMRV9TWVNURU0p CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZTNhYjQyOGNkMWY1YWNmNjI2MTNlNzIzNjdj NjQ0OTIzN2VhMzk1ZAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsuaApAQCAtMCwwICsxLDcxIEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29t PgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBM ZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor ICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkg b2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0 aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKKyAqIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24s IE1BIDAyMTEwLTEzMDEgVVNBCisgKi8KKworI2lmbmRlZiBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3NHdGtfaAorI2RlZmluZSBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGtfaAorCisjaWYgRU5B QkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzLmgi CisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsuaCIKKworI2luY2x1 ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworc3RydWN0IERp cmVjdG9yeUluZm8geworICAgIERpcmVjdG9yeUluZm8oKSA6IG5hbWUoIiIpLCBpc0RpcmVjdG9y eShmYWxzZSkgeyB9CisgICAgRGlyZWN0b3J5SW5mbyhjb25zdCBTdHJpbmcmIG5hbWUsIGJvb2wg aXNEaXJlY3RvcnkpCisgICAgICAgIDogbmFtZShuYW1lKQorICAgICAgICAsIGlzRGlyZWN0b3J5 KGlzRGlyZWN0b3J5KQorICAgIHsgfQorCisgICAgU3RyaW5nIG5hbWU7CisgICAgYm9vbCBpc0Rp cmVjdG9yeTsKK307CisKK2NsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7CisKK2NsYXNzIEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0ayA6IHB1YmxpYyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFj a3MgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxi YWNrc0d0az4gY3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrcz4sIGJvb2wgc3luY2hyb25vdXMgPSBmYWxzZSk7CisgICAgc3Rh dGljIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBjcmVhdGUoQXN5bmNG aWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNh bGxiYWNrcz4sIGNvbnN0IFN0cmluZyYgbW9kZSk7CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkU3Vj Y2VlZCgpOworICAgIHZpcnR1YWwgdm9pZCBkaWRPcGVuRmlsZVN5c3RlbShjb25zdCBTdHJpbmcm IG5hbWUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtPik7CisgICAgdmlydHVhbCB2b2lkIGRp ZFJlYWRNZXRhZGF0YShjb25zdCBGaWxlTWV0YWRhdGEmKTsKKyAgICB2aXJ0dWFsIHZvaWQgZGlk Q3JlYXRlRmlsZVdyaXRlcihQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlcj4sIGxvbmcgbG9uZyBs ZW5ndGgpOworICAgIHZpcnR1YWwgdm9pZCBkaWRGYWlsKGludCBjb2RlKTsKKworICAgIHZvaWQg ZGlkUmVhZERpcmVjdG9yeShWZWN0b3I8RGlyZWN0b3J5SW5mbz4mLCBib29sIGhhc01vcmUpOwor cHJpdmF0ZToKKyAgICBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGsoU2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiwgYm9vbCBzeW5j aHJvbm91cyk7CisgICAgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrKEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrKiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+ LCBjb25zdCBTdHJpbmcmIG1vZGUpOworCisgICAgYm9vbCBtX3N5bmNocm9ub3VzOworICAgIFN0 cmluZyBtX3Rhc2tNb2RlOworICAgIFJlZlB0cjxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0az4gbV90YXNrQ29udHJvbGxlcjsKKyAgICBPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJh Y2tzPiBtX2NhbGxiYWNrczsKK307CisKK30gLy8gbmFtZXNwYWNlCisKKyNlbmRpZiAvLyBFTkFC TEUoRklMRV9TWVNURU0pCisKKyNlbmRpZiAvLyBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NfaApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbUd0 ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNw cAppbmRleCBjMWRiMDA2YTg0OGYzOTI2ZGQ5ZmVjMzFmOTY0YTBmZGJkYWY2OWZjLi5mM2NhMmEz NTQ0MWZkYWU2M2FiZThhODIxYzY3OWFlY2Q5NTBlY2JkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmNwcApAQCAtMSw0ICsxLDUgQEAK IC8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFp bC5jb20+CiAgKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9rIE9oIDxzaGl2YW1pZG93QGdt YWlsLmNvbT4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0xOCwyNyArMTksNzQgQEAKICAqLwogCiAjaW5jbHVk ZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlU3lzdGVtR3RrLmgiCiAKICNpZiBFTkFC TEUoRklMRV9TWVNURU0pCiAKLSNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1HdGsuaCIKLQotI2lu Y2x1ZGUgIkFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcy5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0ay5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9s bGVyR3RrLmgiCisjaW5jbHVkZSAiQXN5bmNGaWxlV3JpdGVyR3RrLmgiCisjaW5jbHVkZSAiQ3Jv c3NUaHJlYWRUYXNrLmgiCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgotI2luY2x1ZGUgIk5v dEltcGxlbWVudGVkLmgiCisjaW5jbHVkZSAiRmlsZUVycm9yLmgiCisjaW5jbHVkZSAiTG9jYWxG aWxlU3lzdGVtLmgiCisjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dP d25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CisjaW5jbHVkZSA8d3Rm L3RleHQvQ1N0cmluZy5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KIAog bmFtZXNwYWNlIFdlYkNvcmUgewogCitzdGF0aWMgRmlsZUVycm9yOjpFcnJvckNvZGUgdG9GaWxl RXJyb3JDb2RlKEdFcnJvciogZXJyb3IpCit7CisgICAgQVNTRVJUKGVycm9yKTsKKworICAgIEZp bGVFcnJvcjo6RXJyb3JDb2RlIGVycm9yQ29kZTsKKyAgICBzd2l0Y2ggKGVycm9yLT5jb2RlKSB7 CisgICAgY2FzZSBHX0lPX0VSUk9SX0VYSVNUUzoKKyAgICBjYXNlIEdfSU9fRVJST1JfTk9UX0VN UFRZOgorICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9O X0VSUjsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBHX0lPX0VSUk9SX0lTX0RJUkVDVE9SWToK KyAgICBjYXNlIEdfSU9fRVJST1JfV09VTERfUkVDVVJTRToKKyAgICAgICAgZXJyb3JDb2RlID0g RmlsZUVycm9yOjpUWVBFX01JU01BVENIX0VSUjsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBH X0lPX0VSUk9SX1dPVUxEX01FUkdFOgorICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6OlBB VEhfRVhJU1RTX0VSUjsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBHX0lPX0VSUk9SX05PVF9G T1VORDoKKyAgICBkZWZhdWx0OgorICAgICAgICBlcnJvckNvZGUgPSBGaWxlRXJyb3I6Ok5PVF9G T1VORF9FUlI7CisgICAgfQorICAgIHJldHVybiBlcnJvckNvZGU7Cit9CisKK3N0YXRpYyBGaWxl RXJyb3I6OkVycm9yQ29kZSB2YWxpZGF0ZUZpbGVUeXBlcyhHRmlsZSogc291cmNlRmlsZSwgR0Zp bGUqIGRlc3RpbmF0aW9uRmlsZSkKK3sKKyAgICBHRmlsZVR5cGUgc291cmNlRmlsZVR5cGUgPSBn X2ZpbGVfcXVlcnlfZmlsZV90eXBlKHNvdXJjZUZpbGUsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUs IDApOworICAgIEdGaWxlVHlwZSBkZXN0aW5hdGlvbkZpbGVUeXBlID0gZ19maWxlX3F1ZXJ5X2Zp bGVfdHlwZShkZXN0aW5hdGlvbkZpbGUsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDApOworICAg IGlmIChkZXN0aW5hdGlvbkZpbGVUeXBlICE9IEdfRklMRV9UWVBFX1VOS05PV04pIHsKKyAgICAg ICAgaWYgKHNvdXJjZUZpbGVUeXBlICE9IGRlc3RpbmF0aW9uRmlsZVR5cGUpIHsKKyAgICAgICAg ICAgIC8vIEZJWE1FOiBGaWxlRXJyb3I6OlRZUEVfTUlTTUFUQ0hfRVJSPyBJZiBzbywgZmFpbGVk IG9uIGZhc3QvZmlsZXN5c3RlbS9vcC1tb3ZlLmh0bWwKKyAgICAgICAgICAgIHJldHVybiBGaWxl RXJyb3I6OklOVkFMSURfTU9ESUZJQ0FUSU9OX0VSUjsKKyAgICAgICAgfQorICAgICAgICBpZiAo ZGVzdGluYXRpb25GaWxlVHlwZSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkgJiYgIWdfZmlsZV9k ZWxldGUoZGVzdGluYXRpb25GaWxlLCAwLCAwKSkgeworICAgICAgICAgICAgLy8gRklYTUU6IEZp bGVFcnJvcjo6UEFUSF9FWElTVFNfRVJSPyBJZiBzbywgZmFpbGVkIG9uIGZhc3QvZmlsZXN5c3Rl bS9vcC1tb3ZlLmh0bWwKKyAgICAgICAgICAgIHJldHVybiBGaWxlRXJyb3I6OklOVkFMSURfTU9E SUZJQ0FUSU9OX0VSUjsKKyAgICAgICAgfQorICAgIH0KKyAgICByZXR1cm4gRmlsZUVycm9yOjpP SzsKK30KKwogYm9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzQXZhaWxhYmxlKCkKIHsKLSAgICBub3RJ bXBsZW1lbnRlZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAog Ym9vbCBBc3luY0ZpbGVTeXN0ZW06OmlzVmFsaWRUeXBlKFR5cGUgdHlwZSkKIHsKLSAgICBub3RJ bXBsZW1lbnRlZCgpOwotICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gdHlwZSA9PSBUZW1w b3JhcnkgfHwgdHlwZSA9PSBQZXJzaXN0ZW50OwogfQogCiBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUoVHlwZSB0eXBlKQpAQCAtNDgsODcgKzk2LDM4 OCBAQCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbT4gQXN5bmNGaWxlU3lzdGVtOjpjcmVhdGUo VHlwZSB0eXBlKQogCiB2b2lkIEFzeW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0oY29uc3Qg U3RyaW5nJiBiYXNlUGF0aCwgY29uc3QgU3RyaW5nJiBzdG9yYWdlSWRlbnRpZmllciwgVHlwZSB0 eXBlLCBib29sLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tz KQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgY2FsbGJhY2tzLT5kaWRGYWlsKE5PVF9T VVBQT1JURURfRVJSKTsKKyAgICBTdHJpbmcgdHlwZVN0cmluZyA9ICh0eXBlID09IEFzeW5jRmls ZVN5c3RlbTo6UGVyc2lzdGVudCkgPyAiUGVyc2lzdGVudCIgOiAiVGVtcG9yYXJ5IjsKKyAgICBT dHJpbmcgbmFtZSA9IHN0b3JhZ2VJZGVudGlmaWVyICsgIjoiICsgdHlwZVN0cmluZzsKKworICAg IGNhbGxiYWNrcy0+ZGlkT3BlbkZpbGVTeXN0ZW0obmFtZSwgQXN5bmNGaWxlU3lzdGVtOjpjcmVh dGUodHlwZSkpOwogfQogCiBib29sIEFzeW5jRmlsZVN5c3RlbTo6Y3JhY2tGaWxlU3lzdGVtVVJM KGNvbnN0IEtVUkwmIHVybCwgQXN5bmNGaWxlU3lzdGVtOjpUeXBlJiB0eXBlLCBTdHJpbmcmIGZp bGVQYXRoKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CiAgICAgcmV0dXJuIGZhbHNlOwogfQog CiBBc3luY0ZpbGVTeXN0ZW1HdGs6OkFzeW5jRmlsZVN5c3RlbUd0ayhBc3luY0ZpbGVTeXN0ZW06 OlR5cGUgdHlwZSkKICAgICA6IEFzeW5jRmlsZVN5c3RlbSh0eXBlKQorICAgICwgbV9sb2NhbEZp bGVTeXN0ZW1CYXNlUGF0aChMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpLmZpbGVT eXN0ZW1CYXNlUGF0aCgpKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIEFzeW5jRmls ZVN5c3RlbUd0azo6fkFzeW5jRmlsZVN5c3RlbUd0aygpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKIH0KIAogU3RyaW5nIEFzeW5jRmlsZVN5c3RlbUd0azo6dG9VUkwoY29uc3QgU3RyaW5nJiBv cmlnaW5TdHJpbmcsIGNvbnN0IFN0cmluZyYgZnVsbFBhdGgpCiB7Ci0gICAgbm90SW1wbGVtZW50 ZWQoKTsKLSAgICByZXR1cm4gU3RyaW5nKCk7CisgICAgQVNTRVJUKCFvcmlnaW5TdHJpbmcuaXNF bXB0eSgpKTsKKyAgICBpZiAob3JpZ2luU3RyaW5nID09IFN0cmluZygibnVsbCIpKQorICAgICAg ICByZXR1cm4gU3RyaW5nKCk7CisKKyAgICBTdHJpbmdCdWlsZGVyIHJlc3VsdDsKKyAgICByZXN1 bHQuYXBwZW5kKCJmaWxlc3lzdGVtOiIpOworICAgIHJlc3VsdC5hcHBlbmQob3JpZ2luU3RyaW5n KTsKKyAgICByZXN1bHQuYXBwZW5kKCIvIik7CisgICAgaWYgKHR5cGUoKSA9PSBUZW1wb3Jhcnkp CisgICAgICAgIHJlc3VsdC5hcHBlbmQodGVtcG9yYXJ5UGF0aFByZWZpeCk7CisgICAgZWxzZSBp ZiAodHlwZSgpID09IFBlcnNpc3RlbnQpCisgICAgICAgIHJlc3VsdC5hcHBlbmQocGVyc2lzdGVu dFBhdGhQcmVmaXgpOworICAgIGVsc2UgeworICAgICAgICBBU1NFUlQodHlwZSgpID09IFRlbXBv cmFyeSB8fCB0eXBlKCkgPT0gUGVyc2lzdGVudCk7CisgICAgICAgIHJldHVybiBTdHJpbmcoKTsK KyAgICB9CisKKyAgICByZXN1bHQuYXBwZW5kKGVuY29kZVdpdGhVUkxFc2NhcGVTZXF1ZW5jZXMo ZnVsbFBhdGgpKTsKKworICAgIHJldHVybiByZXN1bHQudG9TdHJpbmcoKTsKK30KKworc3RhdGlj IHZvaWQgbW92ZUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5j RmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIHNyY1BhdGgs IFN0cmluZyYgZGVzdFBhdGgpCit7CisgICAgR1JlZlB0cjxHRmlsZT4gc291cmNlRmlsZSA9IGFk b3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHNyY1BhdGgudXRmOCgpLmRhdGEoKSkpOworICAg IEdSZWZQdHI8R0ZpbGU+IGRlc3RpbmF0aW9uRmlsZSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zv cl9wYXRoKGRlc3RQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKworICAgIEZpbGVFcnJvcjo6RXJyb3JD b2RlIGVycm9yQ29kZSA9IHZhbGlkYXRlRmlsZVR5cGVzKHNvdXJjZUZpbGUuZ2V0KCksIGRlc3Rp bmF0aW9uRmlsZS5nZXQoKSk7CisgICAgaWYgKGVycm9yQ29kZSkgeworICAgICAgICBoZWxwZXJD YWxsYmFja3MtPmRpZEZhaWwoZXJyb3JDb2RlKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwor ICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBnX2ZpbGVfbW92ZShzb3VyY2VGaWxlLmdl dCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIEdfRklMRV9DT1BZX09WRVJXUklURSwgMCwgMCwg MCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CiB9CiAK IHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjptb3ZlKGNvbnN0IFN0cmluZyYgc291cmNlUGF0aCwg Y29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVt Q2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJp bmcgc291cmNlRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChzb3Vy Y2VQYXRoKTsKKyAgICBTdHJpbmcgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQ YXRoVG9GaWxlU3lzdGVtVVJMKGRlc3RpbmF0aW9uUGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBt X3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5w b3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJm1vdmVBc3luYywgQXN5bmNG aWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2Fs bGJhY2tzLCBtb2RlKSwgc291cmNlRmlsZVN5c3RlbVBhdGgsIGRlc3RpbmF0aW9uRmlsZVN5c3Rl bVBhdGgpKTsKK30KKworc3RhdGljIHZvaWQgY29weVJlY3Vyc2l2ZWx5KEdGaWxlKiBzb3VyY2VE aXJlY3RvcnksIEdGaWxlKiBkZXN0aW5hdGlvbkRpcmVjdG9yeSwgR0Vycm9yKiogZXJyb3IpCit7 CisgICAgQVNTRVJUKGdfZmlsZV9xdWVyeV9maWxlX3R5cGUoc291cmNlRGlyZWN0b3J5LCBHX0ZJ TEVfUVVFUllfSU5GT19OT05FLCAwKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpOworCisgICAg aWYgKCFnX2ZpbGVfbWFrZV9kaXJlY3RvcnkoZGVzdGluYXRpb25EaXJlY3RvcnksIDAsIGVycm9y KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgR1JlZlB0cjxHRmlsZUVudW1lcmF0b3I+IGZpbGVF bnVtZXJhdG9yID0gYWRvcHRHUmVmKGdfZmlsZV9lbnVtZXJhdGVfY2hpbGRyZW4oc291cmNlRGly ZWN0b3J5LCBHX0ZJTEVfQVRUUklCVVRFX1NUQU5EQVJEX05BTUUsIEdfRklMRV9RVUVSWV9JTkZP X05PTkUsIDAsIGVycm9yKSk7CisgICAgaWYgKCplcnJvcikKKyAgICAgICAgcmV0dXJuOworCisg ICAgd2hpbGUgKEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVf ZW51bWVyYXRvcl9uZXh0X2ZpbGUoZmlsZUVudW1lcmF0b3IuZ2V0KCksIDAsIGVycm9yKSkpIHsK KyAgICAgICAgY29uc3QgY2hhciogZGlyZWN0b3J5RW50cnlOYW1lID0gZ19maWxlX2luZm9fZ2V0 X25hbWUoZmlsZUluZm8uZ2V0KCkpOworICAgICAgICBHUmVmUHRyPEdGaWxlPiBzb3VyY2VGaWxl ID0gYWRvcHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQoc291cmNlRGlyZWN0b3J5LCBkaXJlY3RvcnlF bnRyeU5hbWUpKTsKKyAgICAgICAgR1JlZlB0cjxHRmlsZT4gZGVzdGluYXRpb25GaWxlID0gYWRv cHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQoZGVzdGluYXRpb25EaXJlY3RvcnksIGRpcmVjdG9yeUVu dHJ5TmFtZSkpOworCisgICAgICAgIGlmIChnX2ZpbGVfcXVlcnlfZmlsZV90eXBlKHNvdXJjZUZp bGUuZ2V0KCksIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDApID09IEdfRklMRV9UWVBFX0RJUkVD VE9SWSkKKyAgICAgICAgICAgIGNvcHlSZWN1cnNpdmVseShzb3VyY2VGaWxlLmdldCgpLCBkZXN0 aW5hdGlvbkZpbGUuZ2V0KCksIGVycm9yKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgZ19m aWxlX2NvcHkoc291cmNlRmlsZS5nZXQoKSwgZGVzdGluYXRpb25GaWxlLmdldCgpLCBHX0ZJTEVf Q09QWV9OT05FLCAwLCAwLCAwLCBlcnJvcik7CisKKyAgICAgICAgaWYgKCplcnJvcikKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlBc3luYyhTY3JpcHRF eGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+ IGhlbHBlckNhbGxiYWNrcywgU3RyaW5nJiBzb3VyY2VQYXRoLCBTdHJpbmcmIGRlc3RQYXRoKQor eworICAgIEdSZWZQdHI8R0ZpbGU+IHNvdXJjZUZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19m b3JfcGF0aChzb3VyY2VQYXRoLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlPiBk ZXN0aW5hdGlvbkZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChkZXN0UGF0aC51 dGY4KCkuZGF0YSgpKSk7CisKKyAgICBGaWxlRXJyb3I6OkVycm9yQ29kZSBlcnJvckNvZGUgPSB2 YWxpZGF0ZUZpbGVUeXBlcyhzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCkp OworICAgIGlmIChlcnJvckNvZGUpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWls KGVycm9yQ29kZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHT3duUHRyPEdFcnJv cj4gZXJyb3I7CisgICAgaWYgKGdfZmlsZV9xdWVyeV9maWxlX3R5cGUoc291cmNlRmlsZS5nZXQo KSwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCkgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZKSB7 CisgICAgICAgIGNvcHlSZWN1cnNpdmVseShzb3VyY2VGaWxlLmdldCgpLCBkZXN0aW5hdGlvbkZp bGUuZ2V0KCksICZlcnJvci5vdXRQdHIoKSk7CisgICAgICAgIGlmIChlcnJvcikKKyAgICAgICAg ICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbCh0b0ZpbGVFcnJvckNvZGUoZXJyb3IuZ2V0KCkp KTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVk KCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBnX2ZpbGVfY29weShzb3VyY2VGaWxl LmdldCgpLCBkZXN0aW5hdGlvbkZpbGUuZ2V0KCksIEdfRklMRV9DT1BZX09WRVJXUklURSwgMCwg MCwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVy Q2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAg ICByZXR1cm47CisgICAgfQorCisgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRTdWNjZWVkKCk7CiB9 CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjb3B5KGNvbnN0IFN0cmluZyYgc291cmNlUGF0 aCwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lz dGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBT dHJpbmcgc291cmNlRmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChz b3VyY2VQYXRoKTsKKyAgICBTdHJpbmcgZGVzdGluYXRpb25GaWxlU3lzdGVtUGF0aCA9IHZpcnR1 YWxQYXRoVG9GaWxlU3lzdGVtVVJMKGRlc3RpbmF0aW9uUGF0aCk7CisgICAgU3RyaW5nIG1vZGUg PSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVy LT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmNvcHlBc3luYywgQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwg Y2FsbGJhY2tzLCBtb2RlKSwgc291cmNlRmlsZVN5c3RlbVBhdGgsIGRlc3RpbmF0aW9uRmlsZVN5 c3RlbVBhdGgpKTsKK30KKworc3RhdGljIHZvaWQgcmVtb3ZlRmlsZVJlY3Vyc2l2ZWx5KEdGaWxl KiBmaWxlLCBib29sIHJlY3Vyc2l2ZSwgR0Vycm9yKiogZXJyb3IpCit7CisgICAgaWYgKHJlY3Vy c2l2ZSAmJiBnX2ZpbGVfcXVlcnlfZmlsZV90eXBlKGZpbGUsIEdfRklMRV9RVUVSWV9JTkZPX05P TkUsIDApID09IEdfRklMRV9UWVBFX0RJUkVDVE9SWSkgeworICAgICAgICBHUmVmUHRyPEdGaWxl RW51bWVyYXRvcj4gZmlsZUVudW1lcmF0b3IgPSBhZG9wdEdSZWYoZ19maWxlX2VudW1lcmF0ZV9j aGlsZHJlbihmaWxlLCBHX0ZJTEVfQVRUUklCVVRFX1NUQU5EQVJEX05BTUUsIEdfRklMRV9RVUVS WV9JTkZPX05PTkUsIDAsIGVycm9yKSk7CisgICAgICAgIGlmICgqZXJyb3IpCisgICAgICAgICAg ICByZXR1cm47CisKKyAgICAgICAgd2hpbGUgKEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9 IGFkb3B0R1JlZihnX2ZpbGVfZW51bWVyYXRvcl9uZXh0X2ZpbGUoZmlsZUVudW1lcmF0b3IuZ2V0 KCksIDAsIGVycm9yKSkpIHsKKyAgICAgICAgICAgIEdSZWZQdHI8R0ZpbGU+IGNoaWxkID0gYWRv cHRHUmVmKGdfZmlsZV9nZXRfY2hpbGQoZmlsZSwgZ19maWxlX2luZm9fZ2V0X25hbWUoZmlsZUlu Zm8uZ2V0KCkpKSk7CisgICAgICAgICAgICByZW1vdmVGaWxlUmVjdXJzaXZlbHkoY2hpbGQuZ2V0 KCksIHJlY3Vyc2l2ZSwgZXJyb3IpOworICAgICAgICAgICAgaWYgKCplcnJvcikKKyAgICAgICAg ICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKKyAgICBnX2ZpbGVfZGVsZXRlKGZp bGUsIDAsIGVycm9yKTsKK30KKworc3RhdGljIHZvaWQgcmVtb3ZlQXN5bmMoU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCosIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxw ZXJDYWxsYmFja3MsIFN0cmluZyYgZmlsZVBhdGgsIGJvb2wgcmVjdXJzaXZlKQoreworICAgIEdP d25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxlPiBmaWxlID0gYWRvcHRHUmVm KGdfZmlsZV9uZXdfZm9yX3BhdGgoZmlsZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgIHJlbW92 ZUZpbGVSZWN1cnNpdmVseShmaWxlLmdldCgpLCByZWN1cnNpdmUsICZlcnJvci5vdXRQdHIoKSk7 CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFpbCh0b0Zp bGVFcnJvckNvZGUoZXJyb3IuZ2V0KCkpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAg IGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmlsZVN5c3Rl bUd0azo6cmVtb3ZlKGNvbnN0IFN0cmluZyYgcGF0aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0 cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQYXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOwor ICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisgICAg bV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNr KCZyZW1vdmVBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUobV90YXNr Q29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2RlKSwgZmlsZVN5c3RlbVBhdGgsIGZhbHNl KSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZW1vdmVSZWN1cnNpdmVseShjb25z dCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxs YmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBh dGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9 IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXIt PnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVtb3ZlQXN5bmMsIEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCks IGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoLCB0cnVlKSk7Cit9CisKK3N0YXRpYyB2 b2lkIHJlYWRNZXRhZGF0YUFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRy PEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGZp bGVQYXRoKQoreworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxl PiBmaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgoZmlsZVBhdGgudXRmOCgpLmRh dGEoKSkpOworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2Zp bGVfcXVlcnlfaW5mbyhmaWxlLmdldCgpLCAic3RhbmRhcmQ6OiosdGltZTo6KiIsIEdfRklMRV9R VUVSWV9JTkZPX05PTkUsIDAsICZlcnJvci5vdXRQdHIoKSkpOworICAgIGlmIChlcnJvcikgewor ICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwodG9GaWxlRXJyb3JDb2RlKGVycm9yLmdl dCgpKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBGaWxlTWV0YWRhdGE6OlR5cGUg dHlwZSA9IGdfZmlsZV9pbmZvX2dldF9maWxlX3R5cGUoZmlsZUluZm8uZ2V0KCkpID09IEdfRklM RV9UWVBFX0RJUkVDVE9SWSA/IEZpbGVNZXRhZGF0YTo6VHlwZURpcmVjdG9yeSA6IEZpbGVNZXRh ZGF0YTo6VHlwZUZpbGU7CisKKyAgICBHVGltZVZhbCB0aW1lVmFsdWU7CisgICAgZ19maWxlX2lu Zm9fZ2V0X21vZGlmaWNhdGlvbl90aW1lKGZpbGVJbmZvLmdldCgpLCAmdGltZVZhbHVlKTsKKwor ICAgIEdPd25QdHI8Z2NoYXI+IHBhdGgoZ19maWxlX2dldF9wYXRoKGZpbGUuZ2V0KCkpKTsKKwor ICAgIEZpbGVNZXRhZGF0YSBtZXRhZGF0YTsKKyAgICBtZXRhZGF0YS50eXBlID0gdHlwZTsKKyAg ICBtZXRhZGF0YS5tb2RpZmljYXRpb25UaW1lID0gc3RhdGljX2Nhc3Q8ZG91YmxlPih0aW1lVmFs dWUudHZfc2VjKTsKKyAgICBtZXRhZGF0YS5sZW5ndGggPSB0eXBlID09IEZpbGVNZXRhZGF0YTo6 VHlwZUZpbGUgPyBzdGF0aWNfY2FzdDxsb25nIGxvbmc+KGdfZmlsZV9pbmZvX2dldF9zaXplKGZp bGVJbmZvLmdldCgpKSkgOiAwOworICAgIG1ldGFkYXRhLnBsYXRmb3JtUGF0aCA9IFN0cmluZyhw YXRoLmdldCgpKTsKKworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkUmVhZE1ldGFkYXRhKG1ldGFk YXRhKTsKIH0KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OnJlYWRNZXRhZGF0YShjb25zdCBT dHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFj a3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGgg PSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1f dGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUoKTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBv c3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmcmVhZE1ldGFkYXRhQXN5bmMs IEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0 KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoKSk7CiB9CiAKLXZvaWQgQXN5bmNG aWxlU3lzdGVtR3RrOjpjcmVhdGVGaWxlKGNvbnN0IFN0cmluZyYgcGF0aCwgYm9vbCBleGNsdXNp dmUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCitzdGF0 aWMgdm9pZCBjcmVhdGVPYmplY3RBbmRSZWFkTWV0YWRhdGFBc3luYyhTY3JpcHRFeGVjdXRpb25D b250ZXh0KiBjb250ZXh0LCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0az4g aGVscGVyQ2FsbGJhY2tzLCBTdHJpbmcmIGxvY2FsRmlsZVN5c3RlbVBhdGgsIFN0cmluZyYgYWJz b2x1dGVQYXRoLCBHRmlsZVR5cGUgdHlwZSwgYm9vbCBuZWVkVG9SZWFkTWV0YWRhdGEpCiB7Ci0g ICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBBU1NFUlQodHlwZSA9PSBHX0ZJTEVfVFlQRV9SRUdV TEFSIHx8IHR5cGUgPT0gR19GSUxFX1RZUEVfRElSRUNUT1JZKTsKKworICAgIC8vIFdlIHNob3Vs ZCBub3QgYWxsb3cgY3JlYXRpbmcgYSBuZXcgZmlsZSB3aGljaCBuYW1lIGlzICcuJyBvciAnLi4n LiBJZiB0aGVzZSBuYW1lcyBjb21lIGluLAorICAgIC8vIHRoZXkgYXJlIGNvbnZlcnRlZCBpbnRv ICcvJyBieSBwYXRoVG9BYnNvbHV0ZVBhdGggaW4gRE9NRmlsZVN5c3RlbUJhc2U6OmdldEZpbGUK KyAgICAvLyBzbyB3ZSBjYW4gZ2V0IGl0IGhlcmUuIFdlIG1heSBmYWNlIGEgZmFpbHVyZSBvbiBm YXN0L2ZpbGVzeXN0ZW0vb3AtcmVzdHJpY3RlZC1uYW1lcy5odG1sCisgICAgLy8gd2l0aG91dCBk ZWFsaW5nIHdpdGggaXQgcHJvcGVybHkuCisgICAgaWYgKHR5cGUgPT0gR19GSUxFX1RZUEVfUkVH VUxBUiAmJiBhYnNvbHV0ZVBhdGggPT0gU3RyaW5nKCIvIikpIHsKKyAgICAgICAgaGVscGVyQ2Fs bGJhY2tzLT5kaWRGYWlsKEZpbGVFcnJvcjo6U0VDVVJJVFlfRVJSKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBHUmVmUHRyPEdGaWxl PiBmaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgobG9jYWxGaWxlU3lzdGVtUGF0 aC51dGY4KCkuZGF0YSgpKSk7CisgICAgaWYgKHR5cGUgPT0gR19GSUxFX1RZUEVfUkVHVUxBUikK KyAgICAgICAgR1JlZlB0cjxHRmlsZU91dHB1dFN0cmVhbT4gb3V0cHV0U3RyZWFtID0gYWRvcHRH UmVmKGdfZmlsZV9jcmVhdGUoZmlsZS5nZXQoKSwgR19GSUxFX0NSRUFURV9OT05FLCAwLCAmZXJy b3Iub3V0UHRyKCkpKTsKKyAgICBpZiAodHlwZSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlkpCisg ICAgICAgIGdfZmlsZV9tYWtlX2RpcmVjdG9yeShmaWxlLmdldCgpLCAwLCAmZXJyb3Iub3V0UHRy KCkpOworICAgIGlmIChlcnJvcikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwo dG9GaWxlRXJyb3JDb2RlKGVycm9yLmdldCgpKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICBpZiAobmVlZFRvUmVhZE1ldGFkYXRhKSB7CisgICAgICAgIHJlYWRNZXRhZGF0YUFzeW5j KGNvbnRleHQsIGhlbHBlckNhbGxiYWNrcywgbG9jYWxGaWxlU3lzdGVtUGF0aCk7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBoZWxwZXJDYWxsYmFja3MtPmRpZFN1Y2NlZWQoKTsKIH0K IAotdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZURpcmVjdG9yeShjb25zdCBTdHJpbmcm IHBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNr cz4gY2FsbGJhY2tzKQordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZU9iamVjdEFuZFJl YWRNZXRhZGF0YShjb25zdCBTdHJpbmcmIGFic29sdXRlUGF0aCwgUGFzc093blB0cjxBc3luY0Zp bGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgR0ZpbGVUeXBlIHR5cGUsIGJvb2wgbmVlZFRv UmVhZE1ldGFkYXRhKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGxvY2Fs RmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChhYnNvbHV0ZVBhdGgp OworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisg ICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tU YXNrKCZjcmVhdGVPYmplY3RBbmRSZWFkTWV0YWRhdGFBc3luYywgQXN5bmNGaWxlU3lzdGVtQ2Fs bGJhY2tzR3RrOjpjcmVhdGUobV90YXNrQ29udHJvbGxlci5nZXQoKSwgY2FsbGJhY2tzLCBtb2Rl KSwgbG9jYWxGaWxlU3lzdGVtUGF0aCwgYWJzb2x1dGVQYXRoLCB0eXBlLCBuZWVkVG9SZWFkTWV0 YWRhdGEpKTsKK30KKwordm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6OmNyZWF0ZUZpbGUoY29uc3Qg U3RyaW5nJiBhYnNvbHV0ZVBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIGNyZWF0ZU9iamVjdEFuZFJlYWRN ZXRhZGF0YShhYnNvbHV0ZVBhdGgsIGNhbGxiYWNrcywgR19GSUxFX1RZUEVfUkVHVUxBUik7Cit9 CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVEaXJlY3RvcnkoY29uc3QgU3RyaW5n JiBhYnNvbHV0ZVBhdGgsIGJvb2wgZXhjbHVzaXZlLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3Rl bUNhbGxiYWNrcz4gY2FsbGJhY2tzKQoreworICAgIGNyZWF0ZU9iamVjdEFuZFJlYWRNZXRhZGF0 YShhYnNvbHV0ZVBhdGgsIGNhbGxiYWNrcywgR19GSUxFX1RZUEVfRElSRUNUT1JZKTsKK30KKwor c3RhdGljIHZvaWQgb2JqZWN0RXhpc3RzQXN5bmMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBh c3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrPiBoZWxwZXJDYWxsYmFja3MsIFN0 cmluZyYgcGF0aCwgR0ZpbGVUeXBlIHR5cGUpCit7CisgICAgR1JlZlB0cjxHRmlsZT4gb2JqZWN0 ID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9yX3BhdGgocGF0aC51dGY4KCkuZGF0YSgpKSk7Cisg ICAgR0ZpbGVUeXBlIG9iamVjdFR5cGUgPSBnX2ZpbGVfcXVlcnlfZmlsZV90eXBlKG9iamVjdC5n ZXQoKSwgR19GSUxFX1FVRVJZX0lORk9fTk9ORSwgMCk7CisgICAgaWYgKG9iamVjdFR5cGUgPT0g R19GSUxFX1RZUEVfVU5LTk9XTikgeworICAgICAgICBoZWxwZXJDYWxsYmFja3MtPmRpZEZhaWwo RmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBp ZiAob2JqZWN0VHlwZSAhPSB0eXBlKSB7CisgICAgICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkRmFp bChGaWxlRXJyb3I6OlRZUEVfTUlTTUFUQ0hfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkU3VjY2VlZCgpOwogfQogCiB2b2lkIEFzeW5jRmls ZVN5c3RlbUd0azo6ZmlsZUV4aXN0cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQo KTsKKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGggPSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVS TChwYXRoKTsKKyAgICBTdHJpbmcgbW9kZSA9IG1fdGFza0NvbnRyb2xsZXItPnVuaXF1ZU1vZGUo KTsKKworICAgIG1fdGFza0NvbnRyb2xsZXItPnBvc3RUYXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNh bGxiYWNrVGFzaygmb2JqZWN0RXhpc3RzQXN5bmMsIEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrc0d0 azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxiYWNrcywgbW9kZSksIGZpbGVT eXN0ZW1QYXRoLCBHX0ZJTEVfVFlQRV9SRUdVTEFSKSk7CiB9CiAKIHZvaWQgQXN5bmNGaWxlU3lz dGVtR3RrOjpkaXJlY3RvcnlFeGlzdHMoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNzT3duUHRyPEFz eW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmlydHVhbFBhdGhUb0ZpbGVTeXN0ZW1V UkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tDb250cm9sbGVyLT51bmlxdWVNb2Rl KCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFza1RvTWFpblRocmVhZChjcmVhdGVD YWxsYmFja1Rhc2soJm9iamVjdEV4aXN0c0FzeW5jLCBBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3NH dGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBjYWxsYmFja3MsIG1vZGUpLCBmaWxl U3lzdGVtUGF0aCwgR19GSUxFX1RZUEVfRElSRUNUT1JZKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJl YWREaXJlY3RvcnlBc3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs+IGNhbGxiYWNrcywgU3RyaW5nJiBwYXRoKQoreworICAg IEFTU0VSVChnX2ZpbGVfdGVzdChwYXRoLnV0ZjgoKS5kYXRhKCksIEdfRklMRV9URVNUX0lTX0RJ UikpOworCisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQdHI8R0ZpbGU+IGRp cmVjdG9yeSA9IGFkb3B0R1JlZihnX2ZpbGVfbmV3X2Zvcl9wYXRoKHBhdGgudXRmOCgpLmRhdGEo KSkpOworICAgIEdSZWZQdHI8R0ZpbGVFbnVtZXJhdG9yPiBmaWxlRW51bWVyYXRvciA9IGFkb3B0 R1JlZihnX2ZpbGVfZW51bWVyYXRlX2NoaWxkcmVuKGRpcmVjdG9yeS5nZXQoKSwgR19GSUxFX0FU VFJJQlVURV9TVEFOREFSRF9OQU1FLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iu b3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgY2FsbGJhY2tzLT5kaWRGYWls KHRvRmlsZUVycm9yQ29kZShlcnJvci5nZXQoKSkpOworICAgICAgICByZXR1cm47CisgICAgfQor CisgICAgVmVjdG9yPERpcmVjdG9yeUluZm8+IGRpcmVjdG9yeUVudHJpZXM7CisgICAgd2hpbGUg KEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1JlZihnX2ZpbGVfZW51bWVyYXRv cl9uZXh0X2ZpbGUoZmlsZUVudW1lcmF0b3IuZ2V0KCksIDAsICZlcnJvci5vdXRQdHIoKSkpKSB7 CisgICAgICAgIFN0cmluZyBuYW1lKGdfZmlsZV9pbmZvX2dldF9uYW1lKGZpbGVJbmZvLmdldCgp KSk7CisgICAgICAgIGJvb2wgaXNEaXJlY3RvcnkgPSBnX2ZpbGVfaW5mb19nZXRfZmlsZV90eXBl KGZpbGVJbmZvLmdldCgpKSA9PSBHX0ZJTEVfVFlQRV9ESVJFQ1RPUlk7CisgICAgICAgIGRpcmVj dG9yeUVudHJpZXMuYXBwZW5kKERpcmVjdG9yeUluZm8obmFtZSwgaXNEaXJlY3RvcnkpKTsKKyAg ICB9CisgICAgaWYgKGVycm9yKSB7CisgICAgICAgIGNhbGxiYWNrcy0+ZGlkRmFpbCh0b0ZpbGVF cnJvckNvZGUoZXJyb3IuZ2V0KCkpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGNh bGxiYWNrcy0+ZGlkUmVhZERpcmVjdG9yeShkaXJlY3RvcnlFbnRyaWVzLCBmYWxzZSk7CiB9CiAK IHZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpyZWFkRGlyZWN0b3J5KGNvbnN0IFN0cmluZyYgcGF0 aCwgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0ZW1DYWxsYmFja3M+IGNhbGxiYWNrcykKIHsKLSAg ICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBmaWxlU3lzdGVtUGF0aCA9IHZpcnR1YWxQ YXRoVG9GaWxlU3lzdGVtVVJMKHBhdGgpOworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJv bGxlci0+dW5pcXVlTW9kZSgpOworCisgICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01h aW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZyZWFkRGlyZWN0b3J5QXN5bmMsIEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrc0d0azo6Y3JlYXRlKG1fdGFza0NvbnRyb2xsZXIuZ2V0KCksIGNhbGxi YWNrcywgbW9kZSksIGZpbGVTeXN0ZW1QYXRoKSk7CiB9CiAKK3N0YXRpYyB2b2lkIGNyZWF0ZVdy aXRlckFzeW5jKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5 c3RlbUNhbGxiYWNrc0d0az4gaGVscGVyQ2FsbGJhY2tzLCBBc3luY0ZpbGVXcml0ZXJDbGllbnQq IGNsaWVudCwgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVy LCBTdHJpbmcmIHBhdGgpCit7CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEdSZWZQ dHI8R0ZpbGU+IGZpbGUgPSBhZG9wdEdSZWYoZ19maWxlX25ld19mb3JfcGF0aChwYXRoLnV0Zjgo KS5kYXRhKCkpKTsKKyAgICBHUmVmUHRyPEdGaWxlSW5mbz4gZmlsZUluZm8gPSBhZG9wdEdSZWYo Z19maWxlX3F1ZXJ5X2luZm8oZmlsZS5nZXQoKSwgR19GSUxFX0FUVFJJQlVURV9TVEFOREFSRF9T SVpFLCBHX0ZJTEVfUVVFUllfSU5GT19OT05FLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBp ZiAoZXJyb3IpIHsKKyAgICAgICAgaGVscGVyQ2FsbGJhY2tzLT5kaWRGYWlsKHRvRmlsZUVycm9y Q29kZShlcnJvci5nZXQoKSkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgbG9uZyBs b25nIGZpbGVTaXplID0gc3RhdGljX2Nhc3Q8bG9uZyBsb25nPihnX2ZpbGVfaW5mb19nZXRfc2l6 ZShmaWxlSW5mby5nZXQoKSkpOworICAgIGhlbHBlckNhbGxiYWNrcy0+ZGlkQ3JlYXRlRmlsZVdy aXRlcihBc3luY0ZpbGVXcml0ZXJHdGs6OmNyZWF0ZShjbGllbnQsIHRhc2tDb250cm9sbGVyLCBm aWxlLmxlYWtSZWYoKSksIGZpbGVTaXplKTsKK30KIAogdm9pZCBBc3luY0ZpbGVTeXN0ZW1HdGs6 OmNyZWF0ZVdyaXRlcihBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgY29uc3QgU3RyaW5n JiBwYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzKQog ewotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGZpbGVTeXN0ZW1QYXRoID0gdmly dHVhbFBhdGhUb0ZpbGVTeXN0ZW1VUkwocGF0aCk7CisgICAgU3RyaW5nIG1vZGUgPSBtX3Rhc2tD b250cm9sbGVyLT51bmlxdWVNb2RlKCk7CisKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0VGFz a1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmNyZWF0ZVdyaXRlckFzeW5jLCBBc3lu Y0ZpbGVTeXN0ZW1DYWxsYmFja3NHdGs6OmNyZWF0ZShtX3Rhc2tDb250cm9sbGVyLmdldCgpLCBj YWxsYmFja3MsIG1vZGUpLCBBbGxvd0Nyb3NzVGhyZWFkQWNjZXNzKGNsaWVudCksIEFsbG93Q3Jv c3NUaHJlYWRBY2Nlc3MobV90YXNrQ29udHJvbGxlci5nZXQoKSksIGZpbGVTeXN0ZW1QYXRoKSk7 Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lzdGVtR3RrOjpjcmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFk TWV0YWRhdGEoY29uc3QgU3RyaW5nJiBhYnNvbHV0ZVBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxl U3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFja3MpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1 cHBvcnQgcmVtb3RlIGZpbGUgc3lzdGVtIHlldC4KKyAgICBTdHJpbmcgZmlsZVN5c3RlbVBhdGgg PSB2aXJ0dWFsUGF0aFRvRmlsZVN5c3RlbVVSTChhYnNvbHV0ZVBhdGgpOworICAgIGlmIChnX2Zp bGVfdGVzdChmaWxlU3lzdGVtUGF0aC51dGY4KCkuZGF0YSgpLCBHX0ZJTEVfVEVTVF9FWElTVFMp KQorICAgICAgICByZWFkTWV0YWRhdGEoYWJzb2x1dGVQYXRoLCBjYWxsYmFja3MpOworICAgIGVs c2UKKyAgICAgICAgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGFic29sdXRlUGF0aCwgY2Fs bGJhY2tzLCBHX0ZJTEVfVFlQRV9SRUdVTEFSLCB0cnVlKTsKK30KKwordm9pZCBBc3luY0ZpbGVT eXN0ZW1HdGs6OnNldFRhc2tDb250cm9sbGVyKFBhc3NSZWZQdHI8QXN5bmNGaWxlU3lzdGVtVGFz a0NvbnRyb2xsZXJHdGs+IHRhc2tDb250cm9sbGVyKQoreworICAgIG1fdGFza0NvbnRyb2xsZXIg PSB0YXNrQ29udHJvbGxlcjsKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbUd0azo6dmlydHVh bFBhdGhUb0ZpbGVTeXN0ZW1VUkwoY29uc3QgU3RyaW5nJiB2aXJ0dWFsUGF0aCkKK3sKKyAgICBy ZXR1cm4gdmlydHVhbFBhdGggIT0gU3RyaW5nKCIvIikgPyBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQ YXRoICsgdmlydHVhbFBhdGggOiBtX2xvY2FsRmlsZVN5c3RlbUJhc2VQYXRoOworfQorCitib29s IEFzeW5jRmlsZVN5c3RlbUd0azo6d2FpdEZvck9wZXJhdGlvblRvQ29tcGxldGUoKQoreworICAg IHJldHVybiBtX3Rhc2tDb250cm9sbGVyLT53YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOwog fQogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvQXN5bmNGaWxlU3lzdGVtR3RrLmgKaW5kZXggY2I0NWI2ZWE0YmMyMDIwZThlYjRjOGVi NWExOThmMDc2ZjVhNjk3Yi4uZDkxOTQ0MzVkMDljZTc0MjVkNDM4NDFlMWFjYjMzMjNjMDJlMDMw YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3Rl bUd0ay5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1H dGsuaApAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTIgQ2hhbmdTZW9r IE9oIDxzaGl2YW1pZG93QGdtYWlsLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9i ZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQg dW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCkBAIC0yMywx MSArMjMsMTMgQEAKICNpZiBFTkFCTEUoRklMRV9TWVNURU0pCiAKICNpbmNsdWRlICJBc3luY0Zp bGVTeXN0ZW0uaCIKKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25Q dHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBBc3luY0ZpbGVTeXN0ZW1DYWxs YmFja3M7CitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0azsKIAogY2xhc3Mg QXN5bmNGaWxlU3lzdGVtR3RrIDogcHVibGljIEFzeW5jRmlsZVN5c3RlbSB7CiBwdWJsaWM6CkBA IC00Niw2ICs0OCwxNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRpcmVjdG9yeUV4aXN0 cyhjb25zdCBTdHJpbmcmIHBhdGgsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tz Pik7CiAgICAgdmlydHVhbCB2b2lkIHJlYWREaXJlY3RvcnkoY29uc3QgU3RyaW5nJiBwYXRoLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOwogICAgIHZpcnR1YWwgdm9pZCBj cmVhdGVXcml0ZXIoQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiwgY29uc3QgU3RyaW5nJiBwYXRoLCBQ YXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZpcnR1YWwgdm9pZCBj cmVhdGVTbmFwc2hvdEZpbGVBbmRSZWFkTWV0YWRhdGEoY29uc3QgU3RyaW5nJiBwYXRoLCBQYXNz T3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4pOworICAgIHZpcnR1YWwgYm9vbCB3YWl0 Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpOworCisgICAgdm9pZCBzZXRUYXNrQ29udHJvbGxlcihQ YXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPik7Citwcml2YXRlOgor ICAgIHZvaWQgY3JlYXRlT2JqZWN0QW5kUmVhZE1ldGFkYXRhKGNvbnN0IFN0cmluZyYgYWJzb2x1 dGVQYXRoLCBQYXNzT3duUHRyPEFzeW5jRmlsZVN5c3RlbUNhbGxiYWNrcz4sIEdGaWxlVHlwZSwg Ym9vbCBuZWVkVG9SZWFkTWV0YWRhdGEgPSBmYWxzZSk7CisgICAgU3RyaW5nIHZpcnR1YWxQYXRo VG9GaWxlU3lzdGVtVVJMKGNvbnN0IFN0cmluZyYpOworCisgICAgU3RyaW5nIG1fbG9jYWxGaWxl U3lzdGVtQmFzZVBhdGg7CisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrPiBtX3Rhc2tDb250cm9sbGVyOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZThhNjkwNWM5MmRlZWZiMzA5 NTNiMDVjZGU4YjU0ZTc2Zjk3MDFmMAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5jcHAKQEAgLTAs MCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRv YmVyc2VrQGdtYWlsLmNvbT4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxp c2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24g MiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4K KyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVu IHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUg cmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNl bnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisg KiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZs b29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQQorICovCisKKyNpbmNsdWRlICJjb25m aWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIgorCisj aWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1Bhc3NSZWZQ dHI8QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs+IEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrOjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgYm9v bCBzeW5jaHJvbm91cykKK3sKKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IEFzeW5jRmlsZVN5c3Rl bVRhc2tDb250cm9sbGVyR3RrKGNvbnRleHQsIHN5bmNocm9ub3VzKSk7Cit9CisKK0FzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjpBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 ayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBib29sIHN5bmNocm9ub3VzKQorICAg IDogbV9jb250ZXh0KGNvbnRleHQpCisgICAgLCBtX3N5bmNocm9ub3VzKHN5bmNocm9ub3VzKQor ICAgICwgbV9jdXJyZW50VGFza01vZGUoIiIpCisgICAgLCBtX3dyaXRlclRvQ2FuY2VsKDApCit7 CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lzdGVtIHll dC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworfQorCitBc3luY0ZpbGVT eXN0ZW1UYXNrQ29udHJvbGxlckd0azo6fkFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr KCkKK3sKK30KKworU3RyaW5nIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOjp1bmlx dWVNb2RlKCkKK3sKKyAgICAvLyBGSVhNRTogV2UgZG9uJ3Qgc3VwcG9ydCB3b2tlcnMgZm9yIGZp bGVzeXN0ZW0geWV0LgorICAgIEFTU0VSVChtX2NvbnRleHQtPmlzRG9jdW1lbnQoKSk7CisgICAg cmV0dXJuIFN0cmluZygpOworfQorCit2b2lkIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVy R3RrOjpwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+IHRhc2spCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJz IGZvciBmaWxlc3lzdGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkp OworICAgIG1fY29udGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGs6OnNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJpbmcmIHRh c2tNb2RlKQoreworICAgIG1fY3VycmVudFRhc2tNb2RlID0gdGFza01vZGU7Cit9CisKK3ZvaWQg QXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGs6OnBvc3RDYWxsYmFja1Rhc2soUGFzc093 blB0cjxTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPiB0YXNrLCBjb25zdCBTdHJpbmcmIG1v ZGUpCit7CisgICAgLy8gRklYTUU6IFdlIGRvbid0IHN1cHBvcnQgd29rZXJzIGZvciBmaWxlc3lz dGVtIHlldC4KKyAgICBBU1NFUlQobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIG1fY29u dGV4dC0+cG9zdFRhc2sodGFzayk7Cit9CisKK2Jvb2wgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRy b2xsZXJHdGs6OndhaXRGb3JPcGVyYXRpb25Ub0NvbXBsZXRlKCkKK3sKKyAgICBBU1NFUlQobV9j b250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFTU0VSVCghbV9zeW5jaHJvbm91cyk7CisgICAg cmV0dXJuIGZhbHNlOworfQorCitib29sIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3Rr OjpjYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeShBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlcikKK3sK KyAgICBpZiAobV93cml0ZXJUb0NhbmNlbCA9PSB3cml0ZXIpIHsKKyAgICAgICAgbV93cml0ZXJU b0NhbmNlbCA9IDA7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgICByZXR1cm4gZmFs c2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShGSUxF X1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0FzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uY2JmMmQ5OWQy ZTJjYmU3MGIwOGQ1YmQzMDk3NWFjZThmMDc5N2E2YwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ay5o CkBAIC0wLDAgKzEsNjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2Vr IDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBh cyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2 ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3Vs ZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwor ICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUg RnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBG aWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVm IEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrX2gKKyNkZWZpbmUgQXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGtfaAorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5j bHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQ dHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkU2FmZVJlZkNvdW50ZWQuaD4KKyNpbmNsdWRlIDx3 dGYvVGhyZWFkaW5nLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXN5bmNGaWxl V3JpdGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayA6IHB1 YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0 az4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tD b250cm9sbGVyR3RrPiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wgc3luY2hy b25vdXMpOworICAgIH5Bc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0aygpOworCisgICAg dm9pZCBwb3N0VGFza1RvTWFpblRocmVhZChQYXNzT3duUHRyPFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OlRhc2s+KTsKKyAgICB2b2lkIHNldEN1cnJlbnRUYXNrTW9kZShjb25zdCBTdHJpbmcmKTsK KyAgICB2b2lkIHBvc3RDYWxsYmFja1Rhc2soUGFzc093blB0cjxTY3JpcHRFeGVjdXRpb25Db250 ZXh0OjpUYXNrPiwgY29uc3QgU3RyaW5nJik7CisgICAgYm9vbCB3YWl0Rm9yT3BlcmF0aW9uVG9D b21wbGV0ZSgpOworICAgIGJvb2wgc3luY2hyb25vdXMoKSB7IHJldHVybiBtX3N5bmNocm9ub3Vz OyB9CisKKyAgICBib29sIGNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KEFzeW5jRmlsZVdyaXRlckd0 ayopOworICAgIHZvaWQgc2V0V3JpdGVyVG9DYW5jZWwoQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0 ZXIpIHsgbV93cml0ZXJUb0NhbmNlbCA9IHdyaXRlcjsgfQorCisgICAgU3RyaW5nIHVuaXF1ZU1v ZGUoKTsKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGsoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCosIGJvb2wpOworCisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCogbV9jb250ZXh0OworICAgIGJvb2wgbV9zeW5jaHJvbm91czsKKyAgICBTdHJpbmcgbV9jdXJy ZW50VGFza01vZGU7CisKKyAgICBBc3luY0ZpbGVXcml0ZXJHdGsqIG1fd3JpdGVyVG9DYW5jZWw7 Cit9OworCit9IC8vIG5hbWVzcGFjZQorCisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQor CisjZW5kaWYgLy8gQXN5bmNGaWxlU3lzdGVtVGFza0NvbnRyb2xsZXJHdGtfaApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvQXN5bmNGaWxlV3JpdGVyQ2xpZW50R3Rr LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5iOWZiY2EwMTg5MGQ5MGM5YWFkYThmMWUwYTUyNTY0YjcyNjBhYmYz Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmls ZVdyaXRlckNsaWVudEd0ay5jcHAKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAxMSBaYW4gRG9iZXJzZWsgPHphbmRvYmVyc2VrQGdtYWlsLmNvbT4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwg UHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBp ZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCisgKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAx IFVTQQorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0 ZXJDbGllbnRHdGsuaCIKKworI2lmIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2luY2x1ZGUgIkNy b3NzVGhyZWFkVGFzay5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0YXRpYyB2b2lkIHBl cmZvcm1EaWRXcml0ZUNhbGxiYWNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBBc3luY0ZpbGVX cml0ZXJDbGllbnQqIGNsaWVudCwgbG9uZyBsb25nIGJ5dGVzLCBib29sIGNvbXBsZXRlKQorewor ICAgIGNsaWVudC0+ZGlkV3JpdGUoYnl0ZXMsIGNvbXBsZXRlKTsKK30KKworc3RhdGljIHZvaWQg cGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2soU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEFzeW5j RmlsZVdyaXRlckNsaWVudCogY2xpZW50KQoreworICAgIGNsaWVudC0+ZGlkVHJ1bmNhdGUoKTsK K30KKworc3RhdGljIHZvaWQgcGVyZm9ybURpZEZhaWxDYWxsYmFjayhTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgQXN5bmNGaWxlV3JpdGVyQ2xpZW50KiBjbGllbnQsIEZpbGVFcnJvcjo6RXJyb3JD b2RlIGNvZGUpCit7CisgICAgY2xpZW50LT5kaWRGYWlsKGNvZGUpOworfQorCitBc3luY0ZpbGVX cml0ZXJDbGllbnRHdGs6OkFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayhBc3luY0ZpbGVTeXN0ZW1U YXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEFzeW5jRmlsZVdyaXRlckNsaWVudCog Y2xpZW50LCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgOiBtX3Rhc2tDb250cm9sbGVyKHRhc2tD b250cm9sbGVyKQorICAgICwgbV9jbGllbnQoY2xpZW50KQorICAgICwgbV90YXNrTW9kZShtb2Rl KQoreworICAgIG1fdGFza0NvbnRyb2xsZXItPnNldEN1cnJlbnRUYXNrTW9kZShtX3Rhc2tNb2Rl KTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFdyaXRlKGxvbmcgbG9u ZyBieXRlcywgYm9vbCBjb21wbGV0ZSkKK3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2Fs bGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNrVGFzaygmcGVyZm9ybURpZFdyaXRlQ2FsbGJhY2ssIEFs bG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBieXRlcywgY29tcGxldGUpLCBtX3Rhc2tN b2RlKTsKK30KKwordm9pZCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmRpZFRydW5jYXRlKCkK K3sKKyAgICBtX3Rhc2tDb250cm9sbGVyLT5wb3N0Q2FsbGJhY2tUYXNrKGNyZWF0ZUNhbGxiYWNr VGFzaygmcGVyZm9ybURpZFRydW5jYXRlQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3Mo bV9jbGllbnQpKSwgbV90YXNrTW9kZSk7Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyQ2xpZW50 R3RrOjpkaWRGYWlsKEZpbGVFcnJvcjo6RXJyb3JDb2RlIGNvZGUpCit7CisgICAgbV90YXNrQ29u dHJvbGxlci0+cG9zdENhbGxiYWNrVGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJnBlcmZvcm1EaWRG YWlsQ2FsbGJhY2ssIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9jbGllbnQpLCBjb2RlKSwgbV90 YXNrTW9kZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJM RShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hNmVlMTA5ZmQ1ZDMzOTViNjE5 ODNkMmI4MWUxNmM3ZjEyMjE5YWZiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckNsaWVudEd0ay5oCkBAIC0wLDAgKzEsNTcgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFp bC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJv c3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVdyaXRlckNs aWVudEd0a19oCisjZGVmaW5lIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0a19oCisKKyNpZiBFTkFC TEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxl ckd0ay5oIgorI2luY2x1ZGUgIkFzeW5jRmlsZVdyaXRlckNsaWVudC5oIgorCisjaW5jbHVkZSA8 d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBc3luY0Zp bGVXcml0ZXJDbGllbnRHdGsgOiBwdWJsaWMgQXN5bmNGaWxlV3JpdGVyQ2xpZW50IHsKK3B1Ymxp YzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs+IGNyZWF0 ZShBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEFzeW5j RmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBjb25zdCBTdHJpbmcmIG1vZGUpCisgICAgeworICAg ICAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVdyaXRlckNsaWVudEd0ayh0YXNrQ29u dHJvbGxlciwgY2xpZW50LCBtb2RlKSk7CisgICAgfQorCisgICAgdm9pZCBkaWRXcml0ZShsb25n IGxvbmcgYnl0ZXMsIGJvb2wgY29tcGxldGUpOworICAgIHZvaWQgZGlkVHJ1bmNhdGUoKTsKKyAg ICB2b2lkIGRpZEZhaWwoRmlsZUVycm9yOjpFcnJvckNvZGUpOworCisgICAgQXN5bmNGaWxlU3lz dGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyKCkgeyByZXR1cm4gbV90YXNrQ29u dHJvbGxlci5nZXQoKTsgfQorCitwcml2YXRlOgorICAgIEFzeW5jRmlsZVdyaXRlckNsaWVudEd0 ayhBc3luY0ZpbGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayosIEFzeW5jRmlsZVdyaXRlckNsaWVu dCosIGNvbnN0IFN0cmluZyYpOworCisgICAgUmVmUHRyPEFzeW5jRmlsZVN5c3RlbVRhc2tDb250 cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAgIEFzeW5jRmlsZVdyaXRlckNsaWVudCog bV9jbGllbnQ7CisgICAgU3RyaW5nIG1fdGFza01vZGU7Cit9OworCit9IC8vIG5hbWVzcGFjZQor CisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjZW5kaWYgLy8gQXN5bmNGaWxlV3Jp dGVyQ2xpZW50R3RrX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9B c3luY0ZpbGVXcml0ZXJHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5j RmlsZVdyaXRlckd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDU2OWFiNzM3OTEwNGEzNzJhMWMyYTM0MzYz OWE5ZmE5ODdmZTQyMwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuY3BwCkBAIC0wLDAgKzEsMTU1IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDExIFphbiBEb2JlcnNlayA8emFuZG9iZXJzZWtAZ21haWwuY29tPgorICog Q29weXJpZ2h0IChDKSAyMDEyIENoYW5nU2VvayBPaCA8c2hpdmFtaWRvd0BnbWFpbC5jb20+Cisg KgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3Nl ciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlv biwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEg MDIxMTAtMTMwMSBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQXN5 bmNGaWxlV3JpdGVyR3RrLmgiCisKKyNpZiBFTkFCTEUoRklMRV9TWVNURU0pCisKKyNpbmNsdWRl ICJBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGsuaCIKKyNpbmNsdWRlICJCbG9iLmgiCisjaW5jbHVk ZSAiQmxvYlJlZ2lzdHJ5SW1wbC5oIgorI2luY2x1ZGUgIkNyb3NzVGhyZWFkVGFzay5oIgorCisj aW5jbHVkZSA8Z2lvL2dpby5oPgorI2luY2x1ZGUgPGdsaWIuaD4KKyNpbmNsdWRlIDx3dGYvZ29i amVjdC9HT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCituYW1lc3Bh Y2UgV2ViQ29yZSB7CisKK1Bhc3NPd25QdHI8QXN5bmNGaWxlV3JpdGVyR3RrPiBBc3luY0ZpbGVX cml0ZXJHdGs6OmNyZWF0ZShBc3luY0ZpbGVXcml0ZXJDbGllbnQqIGNsaWVudCwgQXN5bmNGaWxl U3lzdGVtVGFza0NvbnRyb2xsZXJHdGsqIHRhc2tDb250cm9sbGVyLCBHRmlsZSogZmlsZSkKK3sK KyAgICByZXR1cm4gYWRvcHRQdHIobmV3IEFzeW5jRmlsZVdyaXRlckd0ayhjbGllbnQsIHRhc2tD b250cm9sbGVyLCBmaWxlKSk7Cit9CisKK0FzeW5jRmlsZVdyaXRlckd0azo6QXN5bmNGaWxlV3Jp dGVyR3RrKEFzeW5jRmlsZVdyaXRlckNsaWVudCogY2xpZW50LCBBc3luY0ZpbGVTeXN0ZW1UYXNr Q29udHJvbGxlckd0ayogdGFza0NvbnRyb2xsZXIsIEdGaWxlKiBmaWxlKQorICAgIDogbV9jbGll bnQoY2xpZW50KQorICAgICwgbV90YXNrQ29udHJvbGxlcih0YXNrQ29udHJvbGxlcikKKyAgICAs IG1fZmlsZShmaWxlKQoreworfQorCitzdGF0aWMgdm9pZCB3cml0ZUFzeW5jKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqLCBQYXNzT3duUHRyPEFzeW5jRmlsZVdyaXRlckNsaWVudEd0az4gaGVscGVy Q2xpZW50LCBBc3luY0ZpbGVXcml0ZXJHdGsqIHdyaXRlciwgR0ZpbGUqIGZpbGUsIGxvbmcgbG9u ZyBwb3NpdGlvbiwgQmxvYiogZGF0YSkKK3sKKyAgICBpZiAoaGVscGVyQ2xpZW50LT50YXNrQ29u dHJvbGxlcigpLT5jYW5jZWxXcml0ZXJJZk5lY2Vzc2FyeSh3cml0ZXIpKSB7CisgICAgICAgIGhl bHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6OkFCT1JUX0VSUik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisKKyAgICBHUmVmUHRyPEdGaWxlSU9TdHJlYW0+IGlvU3RyZWFtID0gYWRvcHRH UmVmKGdfZmlsZV9vcGVuX3JlYWR3cml0ZShmaWxlLCAwLCAwKSk7CisgICAgaWYgKCFpb1N0cmVh bSkgeworICAgICAgICBoZWxwZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRf RVJSKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIEdPd25QdHI8R091dHB1dFN0cmVh bT4gb3V0cHV0U3RyZWFtKGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKEdfSU9fU1RSRUFN KGlvU3RyZWFtLmdldCgpKSkpOworICAgIGlmICghZ19zZWVrYWJsZV9zZWVrKEdfU0VFS0FCTEUo b3V0cHV0U3RyZWFtLmdldCgpKSwgcG9zaXRpb24sIEdfU0VFS19TRVQsIDAsIDApKSB7CisgICAg ICAgIGhlbHBlckNsaWVudC0+ZGlkRmFpbChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAg ICAgICByZXR1cm47CisgICAgfQorCisgICAgUmVmUHRyPEJsb2JTdG9yYWdlRGF0YT4gYmxvYlN0 b3JhZ2UgPSBzdGF0aWNfY2FzdDxCbG9iUmVnaXN0cnlJbXBsJj4oYmxvYlJlZ2lzdHJ5KCkpLmdl dEJsb2JEYXRhRnJvbVVSTChkYXRhLT51cmwoKSk7CisgICAgaWYgKGJsb2JTdG9yYWdlKSB7Cisg ICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgYmxvYlN0b3JhZ2UtPml0ZW1zKCkuc2l6ZSgp OyBpKyspIHsKKyAgICAgICAgICAgIGNvbnN0IEJsb2JEYXRhSXRlbSYgYmxvYkl0ZW0gPSBibG9i U3RvcmFnZS0+aXRlbXMoKVtpXTsKKyAgICAgICAgICAgIGlmIChibG9iSXRlbS50eXBlID09IEJs b2JEYXRhSXRlbTo6RGF0YSkgeworICAgICAgICAgICAgICAgIGdzaXplIGJ5dGVzV3JpdHRlbiA9 IDA7CisgICAgICAgICAgICAgICAgZ19vdXRwdXRfc3RyZWFtX3dyaXRlX2FsbChHX09VVFBVVF9T VFJFQU0ob3V0cHV0U3RyZWFtLmdldCgpKSwgYmxvYkl0ZW0uZGF0YS0+ZGF0YSgpLCBibG9iSXRl bS5kYXRhLT5sZW5ndGgoKSwgJmJ5dGVzV3JpdHRlbiwgMCwgMCk7CisKKyAgICAgICAgICAgICAg ICBib29sIGNvbXBsZXRlZCA9IGJsb2JTdG9yYWdlLT5pdGVtcygpLnNpemUoKSA9PSAoaSArIDEp OworICAgICAgICAgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkV3JpdGUoYnl0ZXNXcml0dGVuLCBj b21wbGV0ZWQpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfQorCit2b2lkIEFz eW5jRmlsZVdyaXRlckd0azo6d3JpdGUobG9uZyBsb25nIHBvc2l0aW9uLCBCbG9iKiBkYXRhKQor eworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisg ICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tU YXNrKCZ3cml0ZUFzeW5jLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNyZWF0ZShtX3Rhc2tD b250cm9sbGVyLmdldCgpLCBtX2NsaWVudCwgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3Mo dGhpcyksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9maWxlLmdldCgpKSwgcG9zaXRpb24sIEFs bG93Q3Jvc3NUaHJlYWRBY2Nlc3MoZGF0YSkpKTsKK30KKworc3RhdGljIHZvaWQgdHJ1bmNhdGVB c3luYyhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc093blB0cjxBc3luY0ZpbGVXcml0ZXJD bGllbnRHdGs+IGhlbHBlckNsaWVudCwgQXN5bmNGaWxlV3JpdGVyR3RrKiB3cml0ZXIsIEdGaWxl KiBmaWxlLCBsb25nIGxvbmcgbGVuZ3RoKQoreworICAgIGlmIChoZWxwZXJDbGllbnQtPnRhc2tD b250cm9sbGVyKCktPmNhbmNlbFdyaXRlcklmTmVjZXNzYXJ5KHdyaXRlcikpIHsKKyAgICAgICAg aGVscGVyQ2xpZW50LT5kaWRGYWlsKEZpbGVFcnJvcjo6QUJPUlRfRVJSKTsKKyAgICAgICAgcmV0 dXJuOworICAgIH0KKworICAgIEdSZWZQdHI8R0ZpbGVJbmZvPiBmaWxlSW5mbyA9IGFkb3B0R1Jl ZihnX2ZpbGVfcXVlcnlfaW5mbyhmaWxlLCAiKiIsIEdfRklMRV9RVUVSWV9JTkZPX05PTkUsIDAs IDApKTsKKyAgICBpZiAoIWZpbGVJbmZvKSB7CisgICAgICAgIGhlbHBlckNsaWVudC0+ZGlkRmFp bChGaWxlRXJyb3I6Ok5PVF9GT1VORF9FUlIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgbG9uZyBsb25nIGZpbGVMZW5ndGggPSBzdGF0aWNfY2FzdDxsb25nIGxvbmc+KGdfZmlsZV9p bmZvX2dldF9zaXplKGZpbGVJbmZvLmdldCgpKSk7CisgICAgaWYgKGxlbmd0aCA+IGZpbGVMZW5n dGgpIHsKKyAgICAgICAgR093blB0cjxHU3RyaW5nPiB6ZXJvUGFkZGluZyhnX3N0cmluZ19uZXdf bGVuKDAsIGxlbmd0aCAtIGZpbGVMZW5ndGgpKTsKKyAgICAgICAgZG8geworICAgICAgICAgICAg Z19zdHJpbmdfYXBwZW5kX2MoemVyb1BhZGRpbmcuZ2V0KCksICdcMCcpOworICAgICAgICB9IHdo aWxlICgtLWxlbmd0aCA+IGZpbGVMZW5ndGgpOworCisgICAgICAgIEdSZWZQdHI8R0ZpbGVJT1N0 cmVhbT4gaW9TdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX29wZW5fcmVhZHdyaXRlKGZpbGUsIDAs IDApKTsKKyAgICAgICAgaWYgKCFpb1N0cmVhbSkgeworICAgICAgICAgICAgaGVscGVyQ2xpZW50 LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgICAgICByZXR1cm47 CisgICAgICAgIH0KKworICAgICAgICBHT3duUHRyPEdPdXRwdXRTdHJlYW0+IG91dHB1dFN0cmVh bShnX2lvX3N0cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShHX0lPX1NUUkVBTShpb1N0cmVhbS5nZXQo KSkpKTsKKyAgICAgICAgaWYgKCFnX3NlZWthYmxlX3NlZWsoR19TRUVLQUJMRShvdXRwdXRTdHJl YW0uZ2V0KCkpLCBsZW5ndGgsIEdfU0VFS19TRVQsIDAsIDApKSB7CisgICAgICAgICAgICBoZWxw ZXJDbGllbnQtPmRpZEZhaWwoRmlsZUVycm9yOjpOT1RfRk9VTkRfRVJSKTsKKyAgICAgICAgICAg IHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIGdzaXplIGJ5dGVzV3JpdHRlbiA9IDA7Cisg ICAgICAgIGdfb3V0cHV0X3N0cmVhbV93cml0ZV9hbGwoR19PVVRQVVRfU1RSRUFNKG91dHB1dFN0 cmVhbS5nZXQoKSksIHplcm9QYWRkaW5nLT5zdHIsIHplcm9QYWRkaW5nLT5sZW4sICZieXRlc1dy aXR0ZW4sIDAsIDApOworICAgIH0gZWxzZSB7CisgICAgICAgIEdSZWZQdHI8R0ZpbGVPdXRwdXRT dHJlYW0+IGZpbGVPdXRwdXRTdHJlYW0gPSBhZG9wdEdSZWYoZ19maWxlX3JlcGxhY2UoZmlsZSwg MCwgZmFsc2UsIEdfRklMRV9DUkVBVEVfTk9ORSwgMCwgMCkpOworICAgICAgICBpZiAoIWZpbGVP dXRwdXRTdHJlYW0gfHwgIWdfc2Vla2FibGVfdHJ1bmNhdGUoR19TRUVLQUJMRShmaWxlT3V0cHV0 U3RyZWFtLmdldCgpKSwgbGVuZ3RoLCAwLCAwKSkgeworICAgICAgICAgICAgaGVscGVyQ2xpZW50 LT5kaWRGYWlsKEZpbGVFcnJvcjo6Tk9UX0ZPVU5EX0VSUik7CisgICAgICAgICAgICByZXR1cm47 CisgICAgICAgIH0KKyAgICB9CisKKyAgICBoZWxwZXJDbGllbnQtPmRpZFRydW5jYXRlKCk7Cit9 CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyR3RrOjp0cnVuY2F0ZShsb25nIGxvbmcgbGVuZ3RoKQor eworICAgIFN0cmluZyBtb2RlID0gbV90YXNrQ29udHJvbGxlci0+dW5pcXVlTW9kZSgpOworCisg ICAgbV90YXNrQ29udHJvbGxlci0+cG9zdFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tU YXNrKCZ0cnVuY2F0ZUFzeW5jLCBBc3luY0ZpbGVXcml0ZXJDbGllbnRHdGs6OmNyZWF0ZShtX3Rh c2tDb250cm9sbGVyLmdldCgpLCBtX2NsaWVudCwgbW9kZSksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nl c3ModGhpcyksIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MobV9maWxlLmdldCgpKSwgbGVuZ3RoKSk7 Cit9CisKK3ZvaWQgQXN5bmNGaWxlV3JpdGVyR3RrOjphYm9ydCgpCit7CisgICAgbV90YXNrQ29u dHJvbGxlci0+c2V0V3JpdGVyVG9DYW5jZWwodGhpcyk7Cit9CisKK2Jvb2wgQXN5bmNGaWxlV3Jp dGVyR3RrOjp3YWl0Rm9yT3BlcmF0aW9uVG9Db21wbGV0ZSgpCit7CisgICAgcmV0dXJuIG1fdGFz a0NvbnRyb2xsZXItPnN5bmNocm9ub3VzKCkgPyBtX3Rhc2tDb250cm9sbGVyLT53YWl0Rm9yT3Bl cmF0aW9uVG9Db21wbGV0ZSgpIDogZmFsc2U7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUK KworI2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9Bc3luY0ZpbGVXcml0ZXJHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41NDViMDBjMWM5NzZh YzM0MzQ0NmFjNWM3NDdlZTViZTgwOTNlNzNjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0FzeW5jRmlsZVdyaXRlckd0ay5oCkBAIC0wLDAgKzEsNTcgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgWmFuIERvYmVyc2VrIDx6YW5kb2JlcnNla0BnbWFp bC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQorICogU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJv c3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EKKyAqLworCisjaWZuZGVmIEFzeW5jRmlsZVdyaXRlckd0 a19oCisjZGVmaW5lIEFzeW5jRmlsZVdyaXRlckd0a19oCisKKyNpZiBFTkFCTEUoRklMRV9TWVNU RU0pCisKKyNpbmNsdWRlICJBc3luY0ZpbGVXcml0ZXIuaCIKKworI2luY2x1ZGUgPHd0Zi9QYXNz T3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgorCituYW1lc3BhY2Ug V2ViQ29yZSB7CisKK2NsYXNzIEFzeW5jRmlsZVdyaXRlckNsaWVudDsKK2NsYXNzIEFzeW5jRmls ZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrOworCitjbGFzcyBBc3luY0ZpbGVXcml0ZXJHdGsgOiBw dWJsaWMgQXN5bmNGaWxlV3JpdGVyIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxB c3luY0ZpbGVXcml0ZXJHdGs+IGNyZWF0ZShBc3luY0ZpbGVXcml0ZXJDbGllbnQqLCBBc3luY0Zp bGVTeXN0ZW1UYXNrQ29udHJvbGxlckd0ayosIEdGaWxlKik7CisKKyAgICB2b2lkIGFib3J0KCk7 CisgICAgdm9pZCB0cnVuY2F0ZShsb25nIGxvbmcgbGVuZ3RoKTsKKyAgICB2b2lkIHdyaXRlKGxv bmcgbG9uZyBwb3NpdGlvbiwgQmxvYiogZGF0YSk7CisKKyAgICBib29sIHdhaXRGb3JPcGVyYXRp b25Ub0NvbXBsZXRlKCk7CisKK3ByaXZhdGU6CisgICAgQXN5bmNGaWxlV3JpdGVyR3RrKEFzeW5j RmlsZVdyaXRlckNsaWVudCosIEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrKiwgR0Zp bGUqKTsKKworICAgIEFzeW5jRmlsZVdyaXRlckNsaWVudCogbV9jbGllbnQ7CisgICAgUmVmUHRy PEFzeW5jRmlsZVN5c3RlbVRhc2tDb250cm9sbGVyR3RrPiBtX3Rhc2tDb250cm9sbGVyOworICAg IEdSZWZQdHI8R0ZpbGU+IG1fZmlsZTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKwor I2VuZGlmIC8vIEVOQUJMRShGSUxFX1NZU1RFTSkKKworI2VuZGlmIC8vIEFzeW5jRmlsZVdyaXRl ckd0a19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9jYWxGaWxl U3lzdGVtR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Mb2NhbEZpbGVTeXN0 ZW1HdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY1OTcyODQ2ZTc5YzM4NjYyMTliZmZjY2MyYjhkZTY2NDcy ZDk3OTQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvTG9j YWxGaWxlU3lzdGVtR3RrLmNwcApAQCAtMCwwICsxLDg2IEBACisvKgorICogIENvcHlyaWdodCAo QykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogIENvcHlyaWdodCAo QykgMjAxMiBDaGFuZ1Nlb2sgT2ggPHNoaXZhbWlkb3dAZ21haWwuY29tPgorICoKKyAqICBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFs IFB1YmxpYworICogIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb247IGVpdGhlcgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlv dXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK KyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlIEdOVQorICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBs aWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiAgRm91bmRhdGlv biwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIx MTAtMTMwMSAgVVNBCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkxvY2Fs RmlsZVN5c3RlbS5oIgorCisjaWYgRU5BQkxFKEZJTEVfU1lTVEVNKQorCisjaW5jbHVkZSAiQXN5 bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrLmgiCisjaW5jbHVkZSAiQ3Jvc3NUaHJlYWRUYXNrLmgi CisjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisjaW5j bHVkZSA8d3RmL1RocmVhZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dPd25QdHIuaD4K KyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0 cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0xvY2FsRmlsZVN5c3RlbSogTG9jYWxG aWxlU3lzdGVtOjpzX2luc3RhbmNlID0gMDsKKwordm9pZCBMb2NhbEZpbGVTeXN0ZW06OmluaXRp YWxpemVMb2NhbEZpbGVTeXN0ZW0oY29uc3QgU3RyaW5nJiBiYXNlUGF0aCkKK3sKKyAgICBHT3du UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgR093blB0cjxHRGlyPiBkaXJlY3RvcnkoZ19kaXJfb3Bl bihiYXNlUGF0aC51dGY4KCkuZGF0YSgpLCAwLCAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAo ZXJyb3IgJiYgZXJyb3ItPmNvZGUgPT0gR19GSUxFX0VSUk9SX05PRU5UKSB7CisgICAgICAgIEdS ZWZQdHI8R0ZpbGU+IGJhc2VEaXJlY3RvcnlGaWxlID0gYWRvcHRHUmVmKGdfZmlsZV9uZXdfZm9y X3BhdGgoYmFzZVBhdGgudXRmOCgpLmRhdGEoKSkpOworICAgICAgICBnX2ZpbGVfbWFrZV9kaXJl Y3RvcnkoYmFzZURpcmVjdG9yeUZpbGUuZ2V0KCksIDAsIDApOworICAgIH0KK30KKworTG9jYWxG aWxlU3lzdGVtJiBMb2NhbEZpbGVTeXN0ZW06OmxvY2FsRmlsZVN5c3RlbSgpCit7CisgICAgV1RG Ojpsb2NrQXRvbWljYWxseUluaXRpYWxpemVkU3RhdGljTXV0ZXgoKTsKKyAgICBpZiAoIXNfaW5z dGFuY2UpIHsKKyAgICAgICAgR093blB0cjxnY2hhcj4gYmFzZVBhdGgoZ19idWlsZF9maWxlbmFt ZShnX2dldF91c2VyX2RhdGFfZGlyKCksICJ3ZWJraXQiLCAiZmlsZXN5c3RlbSIsIE5VTEwpKTsK KyAgICAgICAgT3duUHRyPExvY2FsRmlsZVN5c3RlbT4gbG9jYWxGaWxlU3lzdGVtID0gYWRvcHRQ dHIobmV3IExvY2FsRmlsZVN5c3RlbShiYXNlUGF0aC5nZXQoKSkpOworICAgICAgICBsb2NhbEZp bGVTeXN0ZW0tPmluaXRpYWxpemVMb2NhbEZpbGVTeXN0ZW0oU3RyaW5nKGJhc2VQYXRoLmdldCgp KSk7CisKKyAgICAgICAgc19pbnN0YW5jZSA9IGxvY2FsRmlsZVN5c3RlbS5sZWFrUHRyKCk7Cisg ICAgfQorICAgIFdURjo6dW5sb2NrQXRvbWljYWxseUluaXRpYWxpemVkU3RhdGljTXV0ZXgoKTsK KyAgICByZXR1cm4gKnNfaW5zdGFuY2U7Cit9CisKK1N0cmluZyBMb2NhbEZpbGVTeXN0ZW06OmZp bGVTeXN0ZW1CYXNlUGF0aCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fYmFzZVBhdGg7Cit9CisK K3N0YXRpYyB2b2lkIG9wZW5GaWxlU3lzdGVtKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRl eHQsIGNvbnN0IFN0cmluZyYgYmFzZVBhdGgsIGNvbnN0IFN0cmluZyYgaWRlbnRpZmllciwgQXN5 bmNGaWxlU3lzdGVtOjpUeXBlIHR5cGUsIGJvb2wgY3JlYXRlLCBQYXNzT3duUHRyPEFzeW5jRmls ZVN5c3RlbUNhbGxiYWNrcz4gY2FsbGJhY2tzLCBib29sIHN5bmNocm9ub3VzKQoreworICAgIEFz eW5jRmlsZVN5c3RlbTo6b3BlbkZpbGVTeXN0ZW0oYmFzZVBhdGgsIGlkZW50aWZpZXIsIHR5cGUs IGNyZWF0ZSwgQXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzR3RrOjpjcmVhdGUoY29udGV4dCwgY2Fs bGJhY2tzLCBzeW5jaHJvbm91cykpOworfQorCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6cmVhZEZp bGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNGaWxlU3lzdGVt OjpUeXBlIHR5cGUsIFBhc3NPd25QdHI8QXN5bmNGaWxlU3lzdGVtQ2FsbGJhY2tzPiBjYWxsYmFj a3MsIGJvb2wgc3luY2hyb25vdXMpCit7CisgICAgLy8gQXN5bmNGaWxlU3lzdGVtOjpvcGVuRmls ZVN5c3RlbSBjYWxscyBjYWxsYmFja3Mgc3luY2hyb25vdXNseSwgc28gdGhlIG1ldGhvZCBuZWVk cyB0byBiZSBjYWxsZWQgYXN5bmNocm9ub3VzbHkuCisgICAgY29udGV4dC0+cG9zdFRhc2soY3Jl YXRlQ2FsbGJhY2tUYXNrKCZvcGVuRmlsZVN5c3RlbSwgZmlsZVN5c3RlbUJhc2VQYXRoKCksIGNv bnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPmRhdGFiYXNlSWRlbnRpZmllcigpLCB0eXBlLCBmYWxz ZSwgY2FsbGJhY2tzLCBzeW5jaHJvbm91cykpOworfQorCit2b2lkIExvY2FsRmlsZVN5c3RlbTo6 cmVxdWVzdEZpbGVTeXN0ZW0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQXN5bmNG aWxlU3lzdGVtOjpUeXBlIHR5cGUsIGxvbmcgbG9uZywgUGFzc093blB0cjxBc3luY0ZpbGVTeXN0 ZW1DYWxsYmFja3M+IGNhbGxiYWNrcywgYm9vbCBzeW5jaHJvbm91cykKK3sKKyAgICAvLyBBc3lu Y0ZpbGVTeXN0ZW06Om9wZW5GaWxlU3lzdGVtIGNhbGxzIGNhbGxiYWNrcyBzeW5jaHJvbm91c2x5 LCBzbyB0aGUgbWV0aG9kIG5lZWRzIHRvIGJlIGNhbGxlZCBhc3luY2hyb25vdXNseS4KKyAgICBj b250ZXh0LT5wb3N0VGFzayhjcmVhdGVDYWxsYmFja1Rhc2soJm9wZW5GaWxlU3lzdGVtLCBmaWxl U3lzdGVtQmFzZVBhdGgoKSwgY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+ZGF0YWJhc2VJZGVu dGlmaWVyKCksIHR5cGUsIHRydWUsIGNhbGxiYWNrcywgc3luY2hyb25vdXMpKTsKK30KKworfQor CisjZW5kaWYgLy8gRU5BQkxFKEZJTEVfU1lTVEVNKQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdl TG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDE1YzJkZTBmZmI0YmJkMzU5N2E3NTFkYTZiYTE1 Njk5Y2I5Mjk2YjkuLjEzYjE3OTFhZGRlYzQzNWNiZDcyN2YwOTQ4ZDcyNTFlMTU2NmFiY2YgMTAw NjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxNCBAQAorMjAxMi0wNC0yMyAgQ2hhbmdTZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+ CisKKyAgICAgICAgW0dUS10gU3VwcG9ydCB0aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEVuYWJsZWQgRmlsZVN5c3RlbSBm b3IgR1RLIHBvcnQuCisKKyAgICAgICAgKiBTY3JpcHRzL2J1aWxkLXdlYmtpdDoKKwogMjAxMi0w NC0xOCAgSGlyb25vcmkgQm9ubyAgPGhib25vQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTcGxp dCBTcGVsbENoZWNrZXI6OmRpZENoZWNrKCkgdG8gU3BlbGxDaGVja2VyOjpkaWRDaGVja1N1Y2Nl ZWRlZCgpIGFuZCBTcGVsbENoZWNrZXI6OmRpZENoZWNrQ2FuY2VsZWQoKQpkaWZmIC0tZ2l0IGEv VG9vbHMvU2NyaXB0cy9idWlsZC13ZWJraXQgYi9Ub29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdApp bmRleCA2ZWU5ZjEyZDczNTJiMTNiMzU5ZjYzOThlZjBhZmNkNjVhZGYzNzRiLi5mNmViZDIzMmNm NGRlYjJjMmQxNWQzZjkwZWRmMTZjMjcyYjdmZDg5IDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRz L2J1aWxkLXdlYmtpdAorKysgYi9Ub29scy9TY3JpcHRzL2J1aWxkLXdlYmtpdApAQCAtMjAzLDcg KzIwMyw3IEBAIG15IEBmZWF0dXJlcyA9ICgKICAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0RJUkVD VE9SWV9VUExPQUQiLCBkZWZhdWx0ID0+IDAsIHZhbHVlID0+IFwkZGlyZWN0b3J5VXBsb2FkU3Vw cG9ydCB9LAogCiAgICAgeyBvcHRpb24gPT4gImZpbGUtc3lzdGVtIiwgZGVzYyA9PiAiVG9nZ2xl IEZpbGVTeXN0ZW0gc3VwcG9ydCIsCi0gICAgICBkZWZpbmUgPT4gIkVOQUJMRV9GSUxFX1NZU1RF TSIsIGRlZmF1bHQgPT4gaXNCbGFja0JlcnJ5KCksIHZhbHVlID0+IFwkZmlsZVN5c3RlbVN1cHBv cnQgfSwKKyAgICAgIGRlZmluZSA9PiAiRU5BQkxFX0ZJTEVfU1lTVEVNIiwgZGVmYXVsdCA9PiAo aXNCbGFja0JlcnJ5KCkgfHwgaXNHdGsoKSksIHZhbHVlID0+IFwkZmlsZVN5c3RlbVN1cHBvcnQg fSwKIAogICAgIHsgb3B0aW9uID0+ICJmaWx0ZXJzIiwgZGVzYyA9PiAiVG9nZ2xlIFNWRyBGaWx0 ZXJzIHN1cHBvcnQiLAogICAgICAgZGVmaW5lID0+ICJFTkFCTEVfRklMVEVSUyIsIGRlZmF1bHQg PT4gKGlzQXBwbGVXZWJLaXQoKSB8fCBpc0d0aygpIHx8IGlzUXQoKSB8fCBpc0VmbCgpIHx8IGlz QmxhY2tCZXJyeSgpKSwgdmFsdWUgPT4gXCRmaWx0ZXJzU3VwcG9ydCB9LApkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDYxZWJk YWI2ZjZjMTMzMmJkMGVhYmIyYzBiNWIyMTk5MjczMzc4NTYuLjM2NDVkMGE4ZTM0MWE2YjNhMTk2 Y2RmM2YwMzg1NWM1ZGY3ZWJjNjEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZwor KysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMi0wNC0yMyAg Q2hhbmdTZW9rIE9oICA8c2hpdmFtaWRvd0BnbWFpbC5jb20+CisKKyAgICAgICAgW0dUS10gU3Vw cG9ydCB0aGUgZmlsZSBzeXN0ZW0gQVBJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD01ODQ0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFsbCB0ZXN0cyBpbiBmYXN0L2ZpbGVzeXN0ZW0gYXJlIHBhc3NlZCBl eGNlcHQgdGhlIG9uZXMgcmVsYXRlZCB3aXRoIHdvcmtlci4KKyAgICAgICAgRm9sbG93aW5nIHRl c3RzIGFyZSBwYXNzZWQgaW4gZGV0YWlsLgorICAgICAgICBmYXN0L2ZpbGVzeXN0ZW0vKi5odG1s CisgICAgICAgIGZhc3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5odG1s CisgICAgICAgIGh0dHAvdGVzdHMvd2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2Iu aHRtbAorICAgICAgICBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1i bG9iLWZhaWwuaHRtbAorCisgICAgICAgICogcGxhdGZvcm0vZ3RrL3Rlc3RfZXhwZWN0YXRpb25z LnR4dDoKKwogMjAxMi0wNC0xOCAgVnNldm9sb2QgVmxhc292ICA8dnNldmlrQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBObyByZXNwb25zZSBib2R5IGF2YWlsYWJsZSBm b3IgY2FjaGVkIHJlc291cmNlIHJlcXVlc3RzIHdpdGggZXJyb3Igc3RhdHVzIGNvZGVzLgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBi L0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggOGM1 YmQwYTc0ZTVjNjdjZWY3NjE3Mzk1YzljNGM4OWE0ZDE2OWM4Mi4uMDZkOWYwOWQ2NzA1ZTBjY2Rj MzAwMzQ2MGIzOTQxNjE2ZjFjM2EwYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0v Z3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsv dGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC0xNTUsMTQgKzE1NSwxMiBAQCBCVUdXSzQyNDMyIDog aHR0cC90ZXN0cy9taXNjL3dlYnRpbWluZy1zbG93LWxvYWQucGhwID0gRkFJTAogQlVHV0s0MjQz MiA6IGh0dHAvdGVzdHMvbWlzYy93ZWJ0aW1pbmctc3NsLnBocCA9IEZBSUwKIEJVR1dLNDI0MzIg OiBodHRwL3Rlc3RzL21pc2Mvd2VidGltaW5nLXR3by1yZWRpcmVjdHMucGhwID0gRkFJTAogCi0v LyBGaWxlU3lzdGVtIEFQSSBpcyBub3Qgc3VwcG9ydGVkLgotQlVHV0tHVEsgU0tJUCA6IGZhc3Qv ZmlsZXN5c3RlbSA9IEZBSUwKKy8vIEZpbGVTeXN0ZW0gQVBJIGlzIG5vdCBzdXBwb3J0ZWQgY29t cGxldGVseS4KKy8vIFdlIGRvbid0IHN1cHBvcnQgd29ya2VycyBmb3IgRmlsZVN5c3RlbSB5ZXQu IGh0dHA6Ly93ZWJraXQub3JnL2IvODI4NTQKK0JVR1dLR1RLIFNLSVAgOiBmYXN0L2ZpbGVzeXN0 ZW0vd29ya2VycyA9IEZBSUwKIEJVR1dLR1RLIFNLSVAgOiBodHRwL3Rlc3RzL2ZpbGVzeXN0ZW0g PSBGQUlMCiBCVUdXS0dUSyBTS0lQIDogaHR0cC90ZXN0cy9zZWN1cml0eS9maWxlc3lzdGVtLWlm cmFtZS1mcm9tLXJlbW90ZS5odG1sID0gRkFJTAotQlVHV0tHVEsgU0tJUCA6IGh0dHAvdGVzdHMv d2Vic29ja2V0L3Rlc3RzL2h5Ymkvc2VuZC1maWxlLWJsb2IuaHRtbCA9IEZBSUwKLUJVR1dLR1RL IFNLSVAgOiBodHRwL3Rlc3RzL3dlYnNvY2tldC90ZXN0cy9oeWJpL3NlbmQtZmlsZS1ibG9iLWZh aWwuaHRtbCA9IEZBSUwKIEJVR1dLR1RLIFNLSVAgOiBodHRwL3Rlc3RzL3dvcmtlcnMvdGVybWlu YXRlLWR1cmluZy1zeW5jLW9wZXJhdGlvbi5odG1sID0gRkFJTAotQlVHV0tHVEsgU0tJUCA6IGZh c3QvbXV0YXRpb24vZmlsZXN5c3RlbS1jYWxsYmFjay1kZWxpdmVyeS5odG1sID0gRkFJTAogCiAv LyBSZXF1aXJlcyBXZWJQIHN1cHBvcnQuCiBCVUdXS0dUSyBTS0lQIDogZmFzdC9jYW52YXMvY2Fu dmFzLXRvRGF0YVVSTC13ZWJwLmh0bWwgPSBGQUlMCkBAIC0zMTksNyArMzE3LDYgQEAgQlVHV0s2 NzAwNyBERUJVRyA6IGZhc3QvcnVieS9nZW5lcmF0ZWQtYmVmb3JlLWFuZC1hZnRlci1jb3VudGVy LWRvZXNudC1jcmFzaC5odG0KIEJVR1dLNzY4MTQgREVCVUcgOiBmYXN0L3htbGh0dHByZXF1ZXN0 L3htbGh0dHByZXF1ZXN0LWdldC54aHRtbCA9IENSQVNICiAKIEJVR1dLNzQyOTcgOiBodHRwL3Rl c3RzL3NlY3VyaXR5L2Nyb3NzLW9yaWdpbi14c2wtcmVkaXJlY3QtQkxPQ0tFRC5odG1sID0gUEFT UyBDUkFTSAotQlVHV0s4MzY3OSBERUJVRyA6IGVkaXRpbmcvdW5kby91bmRvLXNtYXJ0LWRlbGV0 ZS1yZXZlcnNlZC1zZWxlY3Rpb24uaHRtbCA9IENSQVNICiAKIC8vIENyYXNoZXMgb24gR1N0cmVh bWVyIHNpZGUgd2hlbiBsb2FkaW5nIG9uZSBvZiB0aGUgbWVkaWEgZWxlbWVudHMgb2YgdGhlIHRl c3QuCiBCVUdXSzUwMTU1IDogZmFzdC9ldmVudHMvdGFiaW5kZXgtZm9jdXMtYmx1ci1hbGwuaHRt bCA9IENSQVNICg==