144192 2015-04-25 10:07:21 -0700 SharedBuffer::createWithContentsOfFile should use map file routines 2015-05-19 08:42:17 -0700 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 youennf youennf ap beidson cgarcia commit-queue darin mcatanzaro oldest_to_newest 1088561 0 youennf 2015-04-25 10:07:21 -0700 SharedBuffer::createWithContentsOfFile currently read data using standard I/O routines (open, read, close or similar according specific platforms). Using map files routines would optimize memory allocation. 1088570 1 darin 2015-04-25 11:37:26 -0700 Note that mapping and copying the data are only equivalent if the file contents are not subsequently modified. So the semantics aren’t identical. So we might need to audit callers or change the function’s name. 1088574 2 251644 youennf 2015-04-25 13:01:33 -0700 Created attachment 251644 Patch 1088579 3 251647 youennf 2015-04-25 13:37:04 -0700 Created attachment 251647 Trying to fix mac build 1088609 4 251647 darin 2015-04-25 17:07:30 -0700 Comment on attachment 251647 Trying to fix mac build View in context: https://bugs.webkit.org/attachment.cgi?id=251647&action=review > Source/WebCore/platform/SharedBuffer.cpp:129 > + return static_cast<unsigned>(m_fileSize); What guarantees m_fileSize will fit in 32 bits? I think this shows that it’s not really a good idea to store a size in size_t, since we’ll have to convert it to unsigned later anyway, and can’t handle values that are too large to fit in an unsigned. > Source/WebCore/platform/SharedBuffer.cpp:194 > + char* fileData = m_fileData; > + m_fileData = nullptr; There’s a nice way to write this kind of shuffle in modern C++: char* fileData = std::exchange(m_fileData, nullptr); > Source/WebCore/platform/SharedBuffer.cpp:197 > + m_fileData = fileData; > + clearFileData(); This “swizzling the data pointer back to we can call clearFileData” thing is pretty ugly. A better pattern would be to make a struct or class that holds the data pointer, file descriptor, and size, then we could move the whole thing out of the SharedBuffer with MappedFileData fileData = WTF::move(m_fileData) and then let it get destroyed/cleaned up when it falls out of scope. class MappedFileData { > Source/WebCore/platform/SharedBuffer.cpp:387 > +PassRefPtr<SharedBuffer> SharedBuffer::createWithContentsOfFile(const String& filePath) New functions should not return PassRefPtr; this should return RefPtr. See <http://www.webkit.org/coding/RefPtr.html> for details. > Source/WebCore/platform/SharedBuffer.cpp:390 > + if (filePath.isEmpty()) > + return nullptr; Why is this needed? Won’t the open call below fail on this without a special case? > Source/WebCore/platform/SharedBuffer.cpp:393 > + CString filename = fileSystemRepresentation(filePath); > + int fd = open(filename.data(), O_RDONLY); No need for the local variable here: int fd = open(fileSystemRepresentation(filePath).data(), O_RDONLY); > Source/WebCore/platform/SharedBuffer.cpp:404 > + if (fileStat.st_size < 0 || size != static_cast<unsigned long long>(fileStat.st_size)) { This isn’t right. The type of st_size is not unsigned long long, it’s off_t. I think what we want to write here is: unsigned size = static_cast<unsigned>(fileStat.st_size); if (size != fileStat.st_size) { or if (fileStat.st_size < 0 || fileStat.st_size > std::numeric_limits<unsigned>::max()) { ... } unsigned size = static_cast<unsigned>(fileStat.st_size); I wonder if we want to special-case short files or empty files. File descriptors can be a scarce resource. Do we need to do anything to prevent from using too many? > Source/WebCore/platform/SharedBuffer.cpp:409 > + char* data = static_cast<char*>(mmap(0, size, PROT_READ, MAP_FILE | MAP_SHARED, fd, 0)); I’m not sure I understand why we’re using a char* for all these types rather than a void*. I think void* would be better. > Source/WebCore/platform/SharedBuffer.cpp:411 > + LOG_ERROR("Failed to map in memory file %s", filenameForDisplay(filePath).utf8().data()); I think it’s a little strange for the file system functions to log their errors. Should they? DO the others? > Source/WebCore/platform/SharedBuffer.h:180 > +#if !PLATFORM(WIN) > + int m_fileDescriptor { 0 }; > +#endif > + char* m_fileData { nullptr }; > + size_t m_fileSize { 0 }; Why are m_fileData and m_fileSize outside the #if? 1088816 5 youennf 2015-04-26 12:55:29 -0700 Thanks for the review. I will update the patch accordingly. I will put bug 143711 as r? (In reply to comment #4) > Comment on attachment 251647 [details] > Trying to fix mac build > > View in context: > https://bugs.webkit.org/attachment.cgi?id=251647&action=review > > > Source/WebCore/platform/SharedBuffer.cpp:129 > > + return static_cast<unsigned>(m_fileSize); > > What guarantees m_fileSize will fit in 32 bits? I think this shows that it’s > not really a good idea to store a size in size_t, since we’ll have to > convert it to unsigned later anyway, and can’t handle values that are too > large to fit in an unsigned. It is asserted in the constructor and checked in createWithContentsOfFile. > > > Source/WebCore/platform/SharedBuffer.cpp:194 > > + char* fileData = m_fileData; > > + m_fileData = nullptr; > > There’s a nice way to write this kind of shuffle in modern C++: > > char* fileData = std::exchange(m_fileData, nullptr); > > > Source/WebCore/platform/SharedBuffer.cpp:197 > > + m_fileData = fileData; > > + clearFileData(); > > This “swizzling the data pointer back to we can call clearFileData” thing is > pretty ugly. A better pattern would be to make a struct or class that holds > the data pointer, file descriptor, and size, then we could move the whole > thing out of the SharedBuffer with MappedFileData fileData = > WTF::move(m_fileData) and then let it get destroyed/cleaned up when it falls > out of scope. > > class MappedFileData { That is good. MappedFileData may be reused elsewhere in the future. > > > Source/WebCore/platform/SharedBuffer.cpp:387 > > +PassRefPtr<SharedBuffer> SharedBuffer::createWithContentsOfFile(const String& filePath) > > New functions should not return PassRefPtr; this should return RefPtr. See > <http://www.webkit.org/coding/RefPtr.html> for details. Well, it is not a new function, but I am ok with this refactoring. > > Source/WebCore/platform/SharedBuffer.cpp:390 > > + if (filePath.isEmpty()) > > + return nullptr; > > Why is this needed? Won’t the open call below fail on this without a special > case? It was part of the previous posix routine. OK with removing it. > > > Source/WebCore/platform/SharedBuffer.cpp:393 > > + CString filename = fileSystemRepresentation(filePath); > > + int fd = open(filename.data(), O_RDONLY); > > No need for the local variable here: > > int fd = open(fileSystemRepresentation(filePath).data(), O_RDONLY); > > > Source/WebCore/platform/SharedBuffer.cpp:404 > > + if (fileStat.st_size < 0 || size != static_cast<unsigned long long>(fileStat.st_size)) { > > This isn’t right. The type of st_size is not unsigned long long, it’s off_t. > I think what we want to write here is: > > unsigned size = static_cast<unsigned>(fileStat.st_size); > if (size != fileStat.st_size) { > > or > > if (fileStat.st_size < 0 || fileStat.st_size > > std::numeric_limits<unsigned>::max()) { > ... > } > unsigned size = static_cast<unsigned>(fileStat.st_size); > > I wonder if we want to special-case short files or empty files. > > File descriptors can be a scarce resource. Do we need to do anything to > prevent from using too many? Currently we do not need it but this might be an issue in the future. A FIXME or comment might be useful. > > > Source/WebCore/platform/SharedBuffer.cpp:409 > > + char* data = static_cast<char*>(mmap(0, size, PROT_READ, MAP_FILE | MAP_SHARED, fd, 0)); > > I’m not sure I understand why we’re using a char* for all these types rather > than a void*. I think void* would be better. void* and size_t are input/output to mmap/munmap. Hence why MappedFileData could store these as void*/size_t > > > Source/WebCore/platform/SharedBuffer.cpp:411 > > + LOG_ERROR("Failed to map in memory file %s", filenameForDisplay(filePath).utf8().data()); > > I think it’s a little strange for the file system functions to log their > errors. Should they? DO the others? This was part of the gtk version of SharedBuffer::create... I will check this further. > > > Source/WebCore/platform/SharedBuffer.h:180 > > +#if !PLATFORM(WIN) > > + int m_fileDescriptor { 0 }; > > +#endif > > + char* m_fileData { nullptr }; > > + size_t m_fileSize { 0 }; > > Why are m_fileData and m_fileSize outside the #if? This seemed useful to WIN platform as well and this allowed limiting #ifdef WIN in SharedBuffer.cpp. This will be easier to handle in MappedFileData. 1089019 6 251740 youennf 2015-04-27 07:58:41 -0700 Created attachment 251740 MappedFileData version 1089029 7 251744 youennf 2015-04-27 08:51:57 -0700 Created attachment 251744 Fixing build 1089040 8 youennf 2015-04-27 09:38:00 -0700 > I wonder if we want to special-case short files or empty files. > > File descriptors can be a scarce resource. Do we need to do anything to > prevent from using too many? Current mapped files through SharedBuffer::createWithContentsOfFile are released quite quickly. I added a FIXME. > > Source/WebCore/platform/SharedBuffer.cpp:411 > > + LOG_ERROR("Failed to map in memory file %s", filenameForDisplay(filePath).utf8().data()); > > I think it’s a little strange for the file system functions to log their > errors. Should they? DO the others? I saw some in linux based files but most don't so I removed them. I see some value in logging open errors, the fact that a file is missing in particular. 1089044 9 darin 2015-04-27 09:43:31 -0700 (In reply to comment #8) > > I think it’s a little strange for the file system functions to log their > > errors. Should they? DO the others? > > I saw some in linux based files but most don't so I removed them. > I see some value in logging open errors, the fact that a file is missing in > particular. I’m not so sure. That makes assumptions about what the higher level code is doing. What if it’s expected that the file is usually missing and we end up with logging every time? To be honest I’m not sure either way. 1089045 10 251744 cgarcia 2015-04-27 09:48:14 -0700 Comment on attachment 251744 Fixing build View in context: https://bugs.webkit.org/attachment.cgi?id=251744&action=review > Source/WebCore/platform/FileSystem.cpp:150 > + return adoptRef(new MappedFileData(fd, data, size)); Do we really need to keep the fd around? I think we can close the fd right after the mmap, the map will be alive until it's unmapped. > Source/WebCore/platform/FileSystem.cpp:162 > +void MappedFileData::clear() This is only used by the destructor, I think we can move this to the destructor instead. > Source/WebCore/platform/FileSystem.cpp:164 > + if (m_fileData) { This could be an early return. > Source/WebCore/platform/FileSystem.cpp:170 > + m_fileSize = 0; > + m_fileData = nullptr; > + m_fileDescriptor = 0; And we don't need all this in the destructor. > Source/WebCore/platform/FileSystem.cpp:174 > +const void* MappedFileData::data() This should be const > Source/WebCore/platform/FileSystem.cpp:179 > +unsigned MappedFileData::size() Ditto. > Source/WebCore/platform/FileSystem.h:222 > + int m_fileDescriptor { 0 }; If we need to keep the file descriptor, it should be initialized to -1 > Source/WebCore/platform/SharedBuffer.cpp:99 > +SharedBuffer::SharedBuffer(MappedFileData& fileData) This could probably receive a MappedFileData&& to transfer the ownership of the map. > Source/WebCore/platform/SharedBuffer.cpp:189 > + maybeTransferMappedFileData(); > maybeTransferPlatformData(); The mapped file is mostly the same than platform data, I wonder if we could implement it as part of the platform data, with common code to create map, but using the platform data for that, so we don't need any change in SharedBuffer > Source/WebCore/platform/SharedBuffer.cpp:385 > + RefPtr<MappedFileData> mappedFileData = MappedFileData::create(filePath); Why does the MappedFileData class need to be refcounted? It's created here and owned by the SharedBuffer. 1089047 11 251744 darin 2015-04-27 09:56:59 -0700 Comment on attachment 251744 Fixing build View in context: https://bugs.webkit.org/attachment.cgi?id=251744&action=review Looking generally good, but I don’t think we should be using a heap-allocated reference counted object for MappedFileData. > Source/WebCore/platform/FileSystem.cpp:171 > + if (m_fileData) { > + munmap(m_fileData, m_fileSize); > + close(m_fileDescriptor); > + > + m_fileSize = 0; > + m_fileData = nullptr; > + m_fileDescriptor = 0; > + } This would read more clearly with an early return. Not sure why we are setting m_fileDescriptor to 0 here. I think 0 can be a valid file descriptor. I can imagine setting it to -1 here or just leaving it set to an arbitrary value. > Source/WebCore/platform/FileSystem.cpp:182 > +const void* MappedFileData::data() > +{ > + return m_fileData; > +} > + > +unsigned MappedFileData::size() > +{ > + return m_fileSize; > +} These should probably be inline in the header. > Source/WebCore/platform/FileSystem.h:208 > +class MappedFileData: public RefCounted<MappedFileData> { This shouldn’t be reference counted. Instead it should have move semantics. It should have a move constructor and move assignment operator. Missing space before the colon. > Source/WebCore/platform/FileSystem.h:210 > + static RefPtr<MappedFileData> create(const String&); I think this should just be a constructor, not a factory function. If the mapping fails, the MappedFileData can indicate the failure state, maybe by leaving m_fileDescriptor equal to -1. Maybe we’d have an isValid function that returns m_fileDescriptor >= 0. > Source/WebCore/platform/FileSystem.h:214 > + void clear(); I don’t think we should have this function. > Source/WebCore/platform/FileSystem.h:218 > +private: I think the “private” need stop go inside the #if, but somehow it compiled on Windows. > Source/WebCore/platform/FileSystem.h:222 > + int m_fileDescriptor { 0 }; This should be -1. > Source/WebCore/platform/SharedBuffer.cpp:99 > +SharedBuffer::SharedBuffer(MappedFileData& fileData) Should take a MappedFileData&& and move it in. > Source/WebCore/platform/SharedBuffer.cpp:100 > + : m_size(0) m_size should be initialized to 0 in the header, now here. > Source/WebCore/platform/SharedBuffer.cpp:240 > + if (m_fileData) > + m_fileData = nullptr; m_fileData = { }; > Source/WebCore/platform/SharedBuffer.cpp:383 > +RefPtr<SharedBuffer> SharedBuffer::createWithContentsOfFile(const String& filePath) Where’s the #if that keeps this from compiling on Windows? > Source/WebCore/platform/SharedBuffer.h:31 > +#include "FileSystem.h" > + Should not have a blank line here between the "" includes and the <> includes. 1090438 12 252058 youennf 2015-04-30 08:06:07 -0700 Created attachment 252058 Using std::unique_ptr and adding unit tests 1090439 13 youennf 2015-04-30 08:15:59 -0700 (In reply to comment #12) > Created attachment 252058 [details] > Using std::unique_ptr and adding unit tests Thanks for all comments. I tried to integrate them in this patch. I sticked with the MappedFileData::create(In reply to comment #12) > Created attachment 252058 [details] > Using std::unique_ptr and adding unit tests Thanks for all comments. I tried integrating them in the latest patch. I sticked with MappedFileData::create to handle empty file (fileSize=0) vs error (null_ptr). Regarding platformData, I am not sure we can merge the two as the code paths are specific for each platform for platformData while for mappedData, code will hopefully be the same except for windows. I added some C++ unit tests. But maybe this can be landed separately: unit tests do not apply yet to EFL and tests will not pass for Win (checking whether they compile on Windows). 1090441 14 darin 2015-04-30 08:36:44 -0700 (In reply to comment #13) > I sticked with MappedFileData::create to handle empty file (fileSize=0) vs > error (null_ptr). That’s not a good choice, because it requires putting each MappedFileData object on the heap with new rather than putting it in a normal variable on the stack. Classes that force a certain kind of allocation are not a good pattern. I understand the desire to report errors in a clear way, but forcing heap allocation just so that we can report the error is not a good pattern. 1091468 15 252323 youennf 2015-05-04 12:17:38 -0700 Created attachment 252323 move constructor approach 1091555 16 252323 darin 2015-05-04 15:32:44 -0700 Comment on attachment 252323 move constructor approach View in context: https://bugs.webkit.org/attachment.cgi?id=252323&action=review > Source/WebCore/platform/FileSystem.cpp:155 > + if (fileStat.st_size < 0 || fileStat.st_size > INT_MAX) { A little strange to use INT_MAX here, but unsigned for the type of the size. I would have used std::numeric_limits<unsigned>::max(). > Source/WebCore/platform/FileSystem.cpp:163 > + if (!size) > + return; Missing close(fd) here. > Source/WebCore/platform/FileSystem.h:209 > + MappedFileData() { } Should not need to implement this. Default implementation should work fine without declaration. > Source/WebCore/platform/FileSystem.h:213 > + WEBCORE_EXPORT MappedFileData(MappedFileData&&); Also need to implement operator=(MappedFileData&&) to prevent the default assignment operator from being defined. > Source/WebCore/platform/FileSystem.h:217 > + WEBCORE_EXPORT void reset(); I would prefer to not have a separate reset function. I would just write this: fileData = { }; That would call the default constructor and the move assignment operator. > Source/WebCore/platform/FileSystem.h:218 > + operator bool() const { return !!m_fileData; } Should be explicit operator bool, or should omit this entirely. > Source/WebCore/platform/SharedBuffer.cpp:39 > +#include <fcntl.h> > +#include <sys/mman.h> > +#include <sys/stat.h> > +#include <wtf/text/CString.h> Why these includes? I don’t think any of them are needed any more. > Source/WebCore/platform/SharedBuffer.cpp:99 > + : m_size(0) Should initialize this in the class definition instead of here. > Source/WebCore/platform/SharedBuffer.cpp:387 > + long long size; > + if (!getFileSize(filePath, size)) > + return nullptr; Why do we need to get the file size twice? MappedFileData also gets the size. I suggest we write the code differently so we don’t get the size twice. > Source/WebCore/platform/SharedBuffer.h:96 > - void clear(); > + WEBCORE_EXPORT void clear(); Why this new export? > Source/WebCore/platform/SharedBuffer.h:105 > - PassRefPtr<SharedBuffer> copy() const; > + WEBCORE_EXPORT PassRefPtr<SharedBuffer> copy() const; Why this new export? > Source/WebCore/platform/SharedBuffer.h:133 > + SharedBuffer(MappedFileData&&); Should be explicit. 1091827 17 252393 youennf 2015-05-05 11:51:53 -0700 Created attachment 252393 Patch 1091829 18 youennf 2015-05-05 11:54:10 -0700 Thanks for the review, latest patch should cover the different improvements you mentioned. MappedFileData is currently put in WebCore/platform, but it could also be put in WTF? > > Source/WebCore/platform/SharedBuffer.h:96 > > - void clear(); > > + WEBCORE_EXPORT void clear(); > > Why this new export? It is apparently required to compile the new API tests on Mac platform. 1092146 19 darin 2015-05-06 07:26:01 -0700 (In reply to comment #18) > MappedFileData is currently put in WebCore/platform, but it could also be > put in WTF? I wouldn’t suggest moving it down to that layer unless we move other things like FileSystem.h, but it’s fine to move it if we have a specific client that wants to use it in, say, JavaScriptCore. 1092162 20 252393 darin 2015-05-06 08:48:59 -0700 Comment on attachment 252393 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=252393&action=review This patch is OK as is, but I still see room for improvement. I didn’t carefully study all the SharedBuffer functions that this patch doesn’t touch to make sure that they all handle m_fileData correctly, but otherwise I looked closely at all the code. > Source/WebCore/platform/FileSystem.cpp:125 > +void MappedFileData::swap(MappedFileData& fd) In WebKit coding style we avoid argument names that are letters or letter clusters and use words instead. Here I would use the word "data" or the word "other". > Source/WebCore/platform/FileSystem.cpp:131 > +MappedFileData::MappedFileData(MappedFileData&& fd) This function should be inline in the header, since it has a trivial implementation that wed like to have be inlined. > Source/WebCore/platform/FileSystem.cpp:136 > +MappedFileData& MappedFileData::operator=(MappedFileData&& fd) This function should be inline in the header, since it has a trivial implementation that wed like to have be inlined. > Source/WebCore/platform/FileSystem.cpp:138 > + swap(fd); This is OK and it’s legal C++, but I slightly prefer an operator= implementation that clears out the other object rather than swapping. It makes a class that behaves a bit more logically. There are times when you want to write a = WTF::move(b) and be sure that b is left empty instead of possibly having state from a. I would write this: m_fileData = std::exchange(other.m_fileData, nullptr); m_fileSize = std::exchange(other.m_fileSize, 0); I’d do the equivalent with construction syntax for the move constructor, and I would omit the swap function entirely. > Source/WebCore/platform/FileSystem.cpp:150 > +MappedFileData::~MappedFileData() > +{ > +#if !PLATFORM(WIN) > + if (!m_fileData) > + return; > + munmap(m_fileData, m_fileSize); > + m_fileData = nullptr; > +#endif > +} This should go in FileSystemPOSIX.cpp: The other file system functions that use these APIs are in there. > Source/WebCore/platform/FileSystem.cpp:153 > +bool MappedFileData::map(const String& filePath) This should go in FileSystemPOSIX.cpp: All the other file system functions that use these APIs are in there. > Source/WebCore/platform/FileSystem.cpp:155 > + int fd = open(fileSystemRepresentation(filePath).data(), O_RDONLY); This is missing error handling for the case when fileSystemRepresentation returns a null string. You can see the proper handling of this, although it’s in unnecessarily wordy coding style, in FileSystemPOSIX.cpp. > Source/WebCore/platform/FileSystem.h:209 > + MappedFileData() { } We should not write this explicitly. The compiler will generate the same thing if we simply leave this line out. However we would need this if we decided to add another constructor (see my comment below). > Source/WebCore/platform/FileSystem.h:211 > + WEBCORE_EXPORT bool map(const String&); I’m not sure this design is the best way to go. There’s a bug in the implementation: If a client calls map a second time on a mapped file data that is already mapped, then it will leak the old mmap’d region. If we want to go with this design, then we need to fix the map function or at the very least require that callers not try to use it that way and assert that. And from a design elegance point of view, if there is member function named map then I think we should have another member function named unmap, like the reset function you had in an earlier patch that I asked you to remove. Another design would be to make the function that actually does the mapping be a constructor or a function that returns a MappedFileData rather than a function that mutates an existing MappedFileData. I prefer this approach; that way you can’t make the mistake of trying to map something that is already mapped. I suppose since we need an way to tell an error apart from an empty file we can either use multiple return values (error indication plus the MappedFileData), or a bool& out argument from the constructor to tell the caller whether it failed, or we can have an error state of MappedFileData, distinct from empty data. This could be distinguished with a separate boolean or with a special value for m_fileData or m_fileSize as long as we are careful about what the accessor member functions return in such a case. Finally, I don’t think the purpose of the string argument is clear without an argument name. We should call it filename or filePath, I think. I am not happy with the inconsistent terminology: "filename", "file name", "fileName", "path", "path name", "pathName", "filePath". I think we should chose one instead of mixing them all. > Source/WebCore/platform/SharedBuffer.cpp:36 > +#if !PLATFORM(WIN) > +#include "FileSystem.h" > +#endif We don’t need this include. It’s already included in the header. > Source/WebCore/platform/SharedBuffer.cpp:95 > + : m_size(0) Can we initialize m_size in the class definition in the header instead of doing it here, please? > Source/WebCore/platform/SharedBuffer.cpp:96 > + , m_buffer(adoptRef(new DataBuffer)) It seems wasteful that we allocate a buffer that likely won’t be used. Can we make this get allocated when needed instead? Perhaps that would be inside the maybeTransferMappedFileData function. > Source/WebCore/platform/SharedBuffer.cpp:235 > + if (m_fileData) > + m_fileData = { }; No need for the "if" here. Unconditionally doing the assignment would be fine performance-wise. > Source/WebCore/platform/SharedBuffer.cpp:253 > RefPtr<SharedBuffer> clone { adoptRef(*new SharedBuffer) }; It’s peculiar that this makes a Ref and then puts it into a RefPtr. It’s pretty clear that we’ll want to change this function to return a Ref<SharedBuffer> instead of a PassRefPtr<SharedBuffer> later, but you don’t need to do that now. > Source/WebCore/platform/SharedBuffer.cpp:386 > +RefPtr<SharedBuffer> SharedBuffer::createWithContentsOfFile(const String& filePath) > +{ > + MappedFileData mappedFileData; > + if (!mappedFileData.map(filePath)) > + return nullptr; > + return adoptRef(new SharedBuffer(WTF::move(mappedFileData))); > +} I’m not sure it’s correct to entirely replace createWithContentsOfFile with a function that always does mmap. There are files that you can open and read successfully but can’t mmap. For example, I believe that files on removable media on OS X behave that way. This function should almost certainly either have a name that indicates it will only do file mapping, or a strategy of doing mapping if it can and falling back to file reading if it cannot. > Source/WebCore/platform/SharedBuffer.h:96 > - void clear(); > + WEBCORE_EXPORT void clear(); I still don’t understand what changed to make this additional export necessary. I accept your claim that it is needed to make things compile, but I don’t know what triggered that new requirement. > Source/WebCore/platform/SharedBuffer.h:105 > - PassRefPtr<SharedBuffer> copy() const; > + WEBCORE_EXPORT PassRefPtr<SharedBuffer> copy() const; Ditto. > Source/WebCore/platform/SharedBuffer.h:133 > + SharedBuffer(MappedFileData&&); Should be marked explicit. 1092163 21 252393 darin 2015-05-06 08:49:53 -0700 Comment on attachment 252393 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=252393&action=review >> Source/WebCore/platform/SharedBuffer.h:96 >> + WEBCORE_EXPORT void clear(); > > I still don’t understand what changed to make this additional export necessary. I accept your claim that it is needed to make things compile, but I don’t know what triggered that new requirement. Oh, wait, I do understand. You added tests and needed WEBCORE_EXPORT to make the function testable. OK. 1092208 22 mcatanzaro 2015-05-06 10:18:23 -0700 (In reply to comment #20) > In WebKit coding style we avoid argument names that are letters or letter > clusters and use words instead. Here I would use the word "data" or the word > "other". FWIW, if I see a variable named fd, I assume it's a file descriptor and would be confused if it's not an int. 1092291 23 youennf 2015-05-06 12:46:07 -0700 (In reply to comment #20) > Comment on attachment 252393 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=252393&action=review > > This patch is OK as is, but I still see room for improvement. Thanks for the review. Given your point on unmappable files, I would tend to further improve that patch with a new review cycle. Let me know if you think a follow-up patch would be a better option. > I didn’t carefully study all the SharedBuffer functions that this patch > doesn’t touch to make sure that they all handle m_fileData correctly, but > otherwise I looked closely at all the code. This code follows the same mechanism as platformData (which I guess should be unified at some point with it). > > Source/WebCore/platform/FileSystem.cpp:125 > > +void MappedFileData::swap(MappedFileData& fd) > > In WebKit coding style we avoid argument names that are letters or letter > clusters and use words instead. Here I would use the word "data" or the word > "other". Yes, this is a poor name, will fix it. > This is OK and it’s legal C++, but I slightly prefer an operator= > implementation that clears out the other object rather than swapping. It > makes a class that behaves a bit more logically. There are times when you > want to write a = WTF::move(b) and be sure that b is left empty instead of > possibly having state from a. I would write this: > > m_fileData = std::exchange(other.m_fileData, nullptr); > m_fileSize = std::exchange(other.m_fileSize, 0); > > I’d do the equivalent with construction syntax for the move constructor, and > I would omit the swap function entirely. OK > > Source/WebCore/platform/FileSystem.cpp:150 > > +MappedFileData::~MappedFileData() > > +{ > > +#if !PLATFORM(WIN) > > + if (!m_fileData) > > + return; > > + munmap(m_fileData, m_fileSize); > > + m_fileData = nullptr; > > +#endif > > +} > > This should go in FileSystemPOSIX.cpp: The other file system functions that > use these APIs are in there. This would require to duplicate the same code in FileSystemGtk.cpp. > > Source/WebCore/platform/FileSystem.cpp:155 > > + int fd = open(fileSystemRepresentation(filePath).data(), O_RDONLY); > > This is missing error handling for the case when fileSystemRepresentation > returns a null string. You can see the proper handling of this, although > it’s in unnecessarily wordy coding style, in FileSystemPOSIX.cpp. OK, I will fix it. > > Source/WebCore/platform/FileSystem.h:209 > > + MappedFileData() { } > > We should not write this explicitly. The compiler will generate the same > thing if we simply leave this line out. However we would need this if we > decided to add another constructor (see my comment below). We already have the move constructor. > > Source/WebCore/platform/FileSystem.h:211 > > + WEBCORE_EXPORT bool map(const String&); > > I’m not sure this design is the best way to go. I am not very much satisfied with it either. If it were me, I would go with map/unmap methods. > There’s a bug in the implementation: If a client calls map a second time on > a mapped file data that is already mapped, then it will leak the old mmap’d > region. If we want to go with this design, then we need to fix the map > function or at the very least require that callers not try to use it that > way and assert that. And from a design elegance point of view, if there is > member function named map then I think we should have another member > function named unmap, like the reset function you had in an earlier patch > that I asked you to remove. Yes, that would be appealing to me. This would allow reuse of the same object for several mappings. But, from the comments I read, it does not seem the preferred approach. > Another design would be to make the function that actually does the mapping > be a constructor or a function that returns a MappedFileData rather than a > function that mutates an existing MappedFileData. I prefer this approach; > that way you can’t make the mistake of trying to map something that is > already mapped. I suppose since we need an way to tell an error apart from > an empty file we can either use multiple return values (error indication > plus the MappedFileData), or a bool& out argument from the constructor to > tell the caller whether it failed, or we can have an error state of > MappedFileData, distinct from empty data. This could be distinguished with a > separate boolean or with a special value for m_fileData or m_fileSize as > long as we are careful about what the accessor member functions return in > such a case. I do not really like to create objects just to return an error code. But I can live with it. > Finally, I don’t think the purpose of the string argument is clear without > an argument name. We should call it filename or filePath, I think. I am not > happy with the inconsistent terminology: "filename", "file name", > "fileName", "path", "path name", "pathName", "filePath". I think we should > chose one instead of mixing them all. OK > > Source/WebCore/platform/SharedBuffer.cpp:95 > > + : m_size(0) > > Can we initialize m_size in the class definition in the header instead of > doing it here, please? OK. I was planning to modify each SharedBuffer constructor accordingly in a follow-up patch, as it seems strange to have different constructor style. > > Source/WebCore/platform/SharedBuffer.cpp:96 > > + , m_buffer(adoptRef(new DataBuffer)) > > It seems wasteful that we allocate a buffer that likely won’t be used. Can > we make this get allocated when needed instead? Perhaps that would be inside > the maybeTransferMappedFileData function. Good point, will have a try at fixing it. This should also be modified I guess for platformData. > > Source/WebCore/platform/SharedBuffer.cpp:235 > > + if (m_fileData) > > + m_fileData = { }; > > No need for the "if" here. Unconditionally doing the assignment would be > fine performance-wise. OK > > Source/WebCore/platform/SharedBuffer.cpp:386 > > +RefPtr<SharedBuffer> SharedBuffer::createWithContentsOfFile(const String& filePath) > > +{ > > + MappedFileData mappedFileData; > > + if (!mappedFileData.map(filePath)) > > + return nullptr; > > + return adoptRef(new SharedBuffer(WTF::move(mappedFileData))); > > +} > > I’m not sure it’s correct to entirely replace createWithContentsOfFile with > a function that always does mmap. There are files that you can open and read > successfully but can’t mmap. For example, I believe that files on removable > media on OS X behave that way. > > This function should almost certainly either have a name that indicates it > will only do file mapping, or a strategy of doing mapping if it can and > falling back to file reading if it cannot. I see. I am not sure we can know in advance whether map will work or not. Falling back to file reading seems a good approach. If we agree this is the right approach, that patch will change substantially and I guess it will need a new review cycle. If there is no objection, I will prepare a new patch accordingly. > > Source/WebCore/platform/SharedBuffer.h:133 > > + SharedBuffer(MappedFileData&&); > > Should be marked explicit. OK 1092395 24 252393 darin 2015-05-06 16:29:21 -0700 Comment on attachment 252393 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=252393&action=review >>> Source/WebCore/platform/FileSystem.h:209 >>> + MappedFileData() { } >> >> We should not write this explicitly. The compiler will generate the same thing if we simply leave this line out. However we would need this if we decided to add another constructor (see my comment below). > > We already have the move constructor. Special constructors such as the copy constructor and the move constructor do not prevent the empty constructor from being automatically generated. So the move constructor doesn’t have an effect here. But a non-special constructor would. >>> Source/WebCore/platform/SharedBuffer.cpp:386 >>> +} >> >> I’m not sure it’s correct to entirely replace createWithContentsOfFile with a function that always does mmap. There are files that you can open and read successfully but can’t mmap. For example, I believe that files on removable media on OS X behave that way. >> >> This function should almost certainly either have a name that indicates it will only do file mapping, or a strategy of doing mapping if it can and falling back to file reading if it cannot. > > I see. > I am not sure we can know in advance whether map will work or not. > Falling back to file reading seems a good approach. > If we agree this is the right approach, that patch will change substantially and I guess it will need a new review cycle. > If there is no objection, I will prepare a new patch accordingly. Exactly, we can’t know in advance. New patch seems fine. 1094218 25 youennf 2015-05-12 12:10:39 -0700 > > > Source/WebCore/platform/SharedBuffer.cpp:96 > > > + , m_buffer(adoptRef(new DataBuffer)) > > > > It seems wasteful that we allocate a buffer that likely won’t be used. Can > > we make this get allocated when needed instead? Perhaps that would be inside > > the maybeTransferMappedFileData function. After some checking, it seems to require adding more "if (!m_buffer)" than what I would like in various place. I am not sure it is worth the extra complexity. I guess a better design would be to split more cleanly the different underlying implementations (subclasses?). A first step might be to move the append() functionality outside SharedBuffer. 1094455 26 253029 youennf 2015-05-13 03:21:39 -0700 Created attachment 253029 Constructor with boolean 1094459 27 253031 youennf 2015-05-13 05:30:58 -0700 Created attachment 253031 Style improvements 1094460 28 253031 youennf 2015-05-13 07:54:36 -0700 Comment on attachment 253031 Style improvements View in context: https://bugs.webkit.org/attachment.cgi?id=253031&action=review > Source/WebCore/platform/FileSystem.cpp:128 > + if (!m_fileData) Kept map/unmap implementation here so as to support GTK, EFL and Mac at the same time. If we want FileSystem.cpp to remain platform free, we may need another FileSystemXX.cpp file. > Source/WebCore/platform/FileSystem.cpp:131 > + m_fileData = nullptr; Plan to remove that line. > Source/WebCore/platform/FileSystem.cpp:135 > +MappedFileData::MappedFileData(const String& filePath, bool& success) success value could have been an enumeration value to detail the error type. In particular, if file does not exist, no need to try the fallback in SharedBuffer::create... I kept the boolean approach as it is simpler and seems good enough. > Source/WebCore/platform/SharedBuffer.cpp:88 > + : m_buffer(adoptRef(new DataBuffer)) Not removed as fixing this would add more complexity than I would like > Source/WebCore/platform/SharedBuffer.cpp:107 > + return SharedBuffer::create(); These two lines do not add much so I plan to remove them. 1094516 29 253031 darin 2015-05-13 12:17:12 -0700 Comment on attachment 253031 Style improvements View in context: https://bugs.webkit.org/attachment.cgi?id=253031&action=review Dan Bernstein pointed out that mapping a file is different from reading the contents of the file in one other sense; if the file is changed we will see the new contents rather than the original. >> Source/WebCore/platform/FileSystem.cpp:131 >> + m_fileData = nullptr; > > Plan to remove that line. I don’t understand what you mean. When will you remove that line? Some subsequent patch? Before landing this? > Source/WebCore/platform/FileSystem.cpp:140 > + return; Please remove this line. > Source/WebCore/platform/FileSystem.h:212 > + WEBCORE_EXPORT MappedFileData(MappedFileData&&); This should not have WEBCORE_EXPORT on it because it’s defined in this header. > Source/WebCore/platform/FileSystem.h:229 > +inline MappedFileData::MappedFileData(MappedFileData&& other) > +{ > + m_fileData = std::exchange(other.m_fileData, nullptr); > + m_fileSize = std::exchange(other.m_fileSize, 0); > +} Should use construction syntax instead of assignment syntax. : m_fileData(std::exchange(other.m_fileData, nullptr)) , m_fileSize(std::exchange(other.m_fileSize, 0)) >> Source/WebCore/platform/SharedBuffer.cpp:107 >> + if (!mappedFileData) >> + return SharedBuffer::create(); > > These two lines do not add much so I plan to remove them. I agree, you should. 1094745 30 253102 youennf 2015-05-14 00:00:57 -0700 Created attachment 253102 Patch for landing 1094767 31 253102 commit-queue 2015-05-14 00:59:21 -0700 Comment on attachment 253102 Patch for landing Clearing flags on attachment: 253102 Committed r184331: <http://trac.webkit.org/changeset/184331> 1094768 32 commit-queue 2015-05-14 00:59:27 -0700 All reviewed patches have been landed. Closing bug. 1095151 33 beidson 2015-05-15 10:18:50 -0700 This patch has caused the Network Process running on Mac to assert often. Exploring more now... 1095153 34 beidson 2015-05-15 10:30:34 -0700 In NetworkResourceLoader, we create an empty SharedBuffer: if (NetworkCache::singleton().isEnabled()) m_bufferedDataForCache = WebCore::SharedBuffer::create(); Later, we try to append to it inside maybeAppendDataArray: unsigned originalSize = size(); for (auto& cfData : data->m_dataArray) append(cfData.get()); ASSERT(size() == originalSize + data->size()); The problem is originalSize is some huge amount, because the ::size() method things it should get the m_fileData size, even though it really shouldn't. 1095163 35 beidson 2015-05-15 10:59:56 -0700 (In reply to comment #34) > In NetworkResourceLoader, we create an empty SharedBuffer: > if (NetworkCache::singleton().isEnabled()) > m_bufferedDataForCache = WebCore::SharedBuffer::create(); > > Later, we try to append to it inside maybeAppendDataArray: > unsigned originalSize = size(); > for (auto& cfData : data->m_dataArray) > append(cfData.get()); > ASSERT(size() == originalSize + data->size()); > > The problem is originalSize is some huge amount, because the ::size() method > things it should get the m_fileData size, even though it really shouldn't. After debugging this a bit, I lost my WebKit disk cache, and it stopped reproducing. That's very unfortunate. 1095190 36 youennf 2015-05-15 12:18:46 -0700 (In reply to comment #34) > In NetworkResourceLoader, we create an empty SharedBuffer: > if (NetworkCache::singleton().isEnabled()) > m_bufferedDataForCache = WebCore::SharedBuffer::create(); > > Later, we try to append to it inside maybeAppendDataArray: > unsigned originalSize = size(); > for (auto& cfData : data->m_dataArray) > append(cfData.get()); > ASSERT(size() == originalSize + data->size()); > > The problem is originalSize is some huge amount, because the ::size() method > things it should get the m_fileData size, even though it really shouldn't. That seems weird. I wonder whether that is a mac specific issue or if it also happens in other gtk/efl SharedBuffer specific parts. Is there a place or some tests to look for those assertion failures in particular? 1095940 37 darin 2015-05-19 08:36:47 -0700 Brady, it’s possible your problem was due to that bug in Xcode recompilation where it gets offsets incorrect even though header files has changed. If you ever see it after a clean build that would disprove my theory. 1095942 38 darin 2015-05-19 08:37:29 -0700 I’m going to look over the code and try to make other guesses about why an empty shared buffer would have a m_fileData that’s not empty. 1095944 39 beidson 2015-05-19 08:42:17 -0700 (In reply to comment #38) > I’m going to look over the code and try to make other guesses about why an > empty shared buffer would have a m_fileData that’s not empty. I did the same and did not spot anything :( (In reply to comment #37) > Brady, it’s possible your problem was due to that bug in Xcode recompilation > where it gets offsets incorrect even though header files has changed. If you > ever see it after a clean build that would disprove my theory. You might be correct. When I nuked my disk cache (unwisely not saving it aside...) I may have also done enough of a rebuild to make it go away. I'm not sure there's anything emergent to explore here, but I will definitely chime in if I see it again. 251644 2015-04-25 13:01:33 -0700 2015-04-25 13:36:57 -0700 Patch bug-144192-20150425220012.patch text/plain 14112 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTgzMjY3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc5MzFhNGE2ZWEwYTlh YmJmYzMzY2MwYjIyYjM2MjAyODRhOTI0Ni4uNmJlN2NlMTQwOTliMTBlYzczNmE0ZGIwOTYwNmY0 ZmFkMzcwOWNkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE1LTA0LTI1ICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIEZpbGUgY29u dGVudCBpcyBtYXBwZWQgdW50aWwgU2hhcmVkQnVmZmVyIGlzIGNsZWFyZWQsIGRlc3Ryb3llZCBv ciBhZGRpdGlvbmFsIGNvbnRlbnQgaXMgYXBwZW5kZWQgdG8gdGhlIFNoYXJlZEJ1ZmZlci4KKyAg ICAgICAgUmVtb3ZlZCB0aGUgRUZML01hYyBhbmQgR1RLIHNwZWNpZmljIHZlcnNpb25zIG9mIFNo YXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorCisgICAgICAgIENoYW5nZXMg Y292ZXJlZCBieSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtl OgorICAgICAgICAqIFBsYXRmb3JtR1RLLmNtYWtlOgorICAgICAgICAqIFBsYXRmb3JtTWFjLmNt YWtlOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFy ZWRCdWZmZXI6OnNpemUpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpkYXRhKToK KyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YXBwZW5kKToKKyAgICAgICAgKFdlYkNv cmU6OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVy Ojpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEpOgor ICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUp OgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAgICAqIHBsYXRmb3Jt L2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwOiBSZW1vdmVkLgorICAgICAgICAqIHBsYXRmb3JtL3Bv c2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS93 aW4vU2hhcmVkQnVmZmVyV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6 Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKTogQWRkZWQgYSBGSVhNRSB0byB1c2UgbW1hcCByb3V0 aW5lcy4KKwogMjAxNS0wNC0yNCAgRG91ZyBSdXNzZWxsICA8ZF9ydXNzZWxsQGFwcGxlLmNvbT4K IAogICAgICAgICBBWDogcmljaGVyIHRleHQgY2hhbmdlIG5vdGlmaWNhdGlvbnMgKDE0MjcxOSkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlIGIvU291cmNlL1dl YkNvcmUvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggY2Y3ZDcxODNjNmNlY2NmMWIyYTg5NzY1MzQy NjYzZmFlM2VlMzViOC4uODU0ZWExMzg2ZTdkYzg0ZTJmZGI2NDJhNDczOTU2MTEzM2YxNTU3NSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1FZmwuY21ha2UKKysrIGIvU291cmNl L1dlYkNvcmUvUGxhdGZvcm1FZmwuY21ha2UKQEAgLTIzOCw3ICsyMzgsNiBAQCBsaXN0KEFQUEVO RCBXZWJDb3JlX1NPVVJDRVMKICAgICBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU3luY2hyb25vdXNM b2FkZXJDbGllbnRTb3VwLmNwcAogCiAgICAgcGxhdGZvcm0vcG9zaXgvRmlsZVN5c3RlbVBPU0lY LmNwcAotICAgIHBsYXRmb3JtL3Bvc2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcAogCiAgICAgcGxh dGZvcm0vc291cC9TaGFyZWRCdWZmZXJTb3VwLmNwcAogICAgIHBsYXRmb3JtL3NvdXAvVVJMU291 cC5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291 cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggZDhiNmQ2NWU4ZmFhNzlkMDhjMTI4 YzM3ZGZmODkxNmYzZmRhNWQ5ZS4uNzVjMDUxNWFjZTE5NTVjZjlhNjg0ZDk5MTMzODc4YTU3ZjNl YjE1OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIv U291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTEyNCw3ICsxMjQsNiBAQCBsaXN0 KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKICAgICBwbGF0Zm9ybS9ndGsvTGFuZ3VhZ2VHdGsuY3Bw CiAgICAgcGxhdGZvcm0vZ3RrL0xvZ2dpbmdHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL01JTUVU eXBlUmVnaXN0cnlHdGsuY3BwCi0gICAgcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAK ICAgICBwbGF0Zm9ybS9ndGsvU2hhcmVkVGltZXJHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL1Rl bXBvcmFyeUxpbmtTdHVicy5jcHAKICAgICBwbGF0Zm9ybS9ndGsvVXNlckFnZW50R3RrLmNwcApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1NYWMuY21ha2UgYi9Tb3VyY2UvV2Vi Q29yZS9QbGF0Zm9ybU1hYy5jbWFrZQppbmRleCAwNTRhYTU0MDg3ZTNjNTMxOThjMWU4ZjU1Njg2 YWI5OWUzNTFmMmY3Li5lY2JlNzk1YzI0ZWE4MGUyYTFiMmI0NTljNjIyN2Q3Y2JhOTU2NDBlIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybU1hYy5jbWFrZQorKysgYi9Tb3VyY2Uv V2ViQ29yZS9QbGF0Zm9ybU1hYy5jbWFrZQpAQCAtMzQ5LDcgKzM0OSw2IEBAIGxpc3QoQVBQRU5E IFdlYkNvcmVfU09VUkNFUwogICAgIHBsYXRmb3JtL25ldHdvcmsvbWFjL1dlYkNvcmVVUkxSZXNw b25zZS5tbQogCiAgICAgcGxhdGZvcm0vcG9zaXgvRmlsZVN5c3RlbVBPU0lYLmNwcAotICAgIHBs YXRmb3JtL3Bvc2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcAogCiAgICAgcGxhdGZvcm0vdGV4dC9j Zi9IeXBoZW5hdGlvbkNGLmNwcAogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9TaGFyZWRCdWZmZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVy LmNwcAppbmRleCBhZTZlZWU1ZWJmNTAwZWNjZTAzYTU0MTE0M2FlOWE3NTU4OGVjMWVmLi5mZWYw OWQwNWNhMjlkMWVhN2Q3Mzg1NTYwOGIxOGQ4OTM3N2UyZjY3IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKQEAgLTMwLDYgKzMwLDE1IEBACiAjaW5jbHVkZSA8YWxn b3JpdGhtPgogI2luY2x1ZGUgPHd0Zi91bmljb2RlL1VURjguaD4KIAorI2lmICFQTEFURk9STShX SU4pCisjaW5jbHVkZSAiRmlsZVN5c3RlbS5oIgorCisjaW5jbHVkZSA8ZmNudGwuaD4KKyNpbmNs dWRlIDxzeXMvbW1hbi5oPgorI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CisjaW5jbHVkZSA8d3RmL3Rl eHQvQ1N0cmluZy5oPgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogI2lmICFVU0Uo TkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC04NSw3ICs5NCwxOSBAQCBTaGFyZWRC dWZmZXI6OlNoYXJlZEJ1ZmZlcihjb25zdCB1bnNpZ25lZCBjaGFyKiBkYXRhLCB1bnNpZ25lZCBz aXplKQogewogICAgIGFwcGVuZChyZWludGVycHJldF9jYXN0PGNvbnN0IGNoYXIqPihkYXRhKSwg c2l6ZSk7CiB9Ci0gICAgCisKKyNpZiAhUExBVEZPUk0oV0lOKQorU2hhcmVkQnVmZmVyOjpTaGFy ZWRCdWZmZXIoaW50IGZpbGVEZXNjcmlwdG9yLCBjaGFyKiBmaWxlRGF0YSwgc2l6ZV90IGZpbGVT aXplKQorICAgIDogbV9zaXplKDApCisgICAgLCBtX2J1ZmZlcihhZG9wdFJlZihuZXcgRGF0YUJ1 ZmZlcikpCisgICAgLCBtX2ZpbGVEZXNjcmlwdG9yKGZpbGVEZXNjcmlwdG9yKQorICAgICwgbV9m aWxlRGF0YShmaWxlRGF0YSkKKyAgICAsIG1fZmlsZVNpemUoZmlsZVNpemUpCit7CisgICAgQVNT RVJUKGZpbGVTaXplIDwgSU5UX01BWCk7Cit9CisjZW5kaWYKKwogU2hhcmVkQnVmZmVyOjp+U2hh cmVkQnVmZmVyKCkKIHsKICAgICBjbGVhcigpOwpAQCAtMTA0LDE1ICsxMjUsMjAgQEAgdW5zaWdu ZWQgU2hhcmVkQnVmZmVyOjpzaXplKCkgY29uc3QKICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkp CiAgICAgICAgIHJldHVybiBwbGF0Zm9ybURhdGFTaXplKCk7CiAgICAgCisgICAgaWYgKG1fZmls ZURhdGEpCisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDx1bnNpZ25lZD4obV9maWxlU2l6ZSk7 CisKICAgICByZXR1cm4gbV9zaXplOwogfQogCiBjb25zdCBjaGFyKiBTaGFyZWRCdWZmZXI6OmRh dGEoKSBjb25zdAogewotCiAgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKQogICAgICAgICByZXR1 cm4gcGxhdGZvcm1EYXRhKCk7CiAKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAgcmV0dXJu IG1fZmlsZURhdGE7CisKICNpZiBVU0UoTkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCiAg ICAgaWYgKGNvbnN0IGNoYXIqIGJ1ZmZlciA9IHNpbmdsZURhdGFBcnJheUJ1ZmZlcigpKQogICAg ICAgICByZXR1cm4gYnVmZmVyOwpAQCAtMTYzLDYgKzE4OSwxNCBAQCB2b2lkIFNoYXJlZEJ1ZmZl cjo6YXBwZW5kKGNvbnN0IGNoYXIqIGRhdGEsIHVuc2lnbmVkIGxlbmd0aCkKICAgICBpZiAoIWxl bmd0aCkKICAgICAgICAgcmV0dXJuOwogCisgICAgaWYgKG1fZmlsZURhdGEpIHsKKyAgICAgICAg Y2hhciogZmlsZURhdGEgPSBtX2ZpbGVEYXRhOworICAgICAgICBtX2ZpbGVEYXRhID0gbnVsbHB0 cjsKKyAgICAgICAgYXBwZW5kKGZpbGVEYXRhLCBzdGF0aWNfY2FzdDx1bnNpZ25lZD4obV9maWxl U2l6ZSkpOworICAgICAgICBtX2ZpbGVEYXRhID0gZmlsZURhdGE7CisgICAgICAgIGNsZWFyRmls ZURhdGEoKTsKKyAgICB9CisKICAgICBtYXliZVRyYW5zZmVyUGxhdGZvcm1EYXRhKCk7CiAKICNp ZiAhVVNFKE5FVFdPUktfQ0ZEQVRBX0FSUkFZX0NBTExCQUNLKQpAQCAtMjEzLDYgKzI0Nyw5IEBA IHZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgVmVjdG9yPGNoYXI+JiBkYXRhKQogCiB2 b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXIoKQogeworICAgIGlmIChtX2ZpbGVEYXRhKQorICAgICAg ICBjbGVhckZpbGVEYXRhKCk7CisKICAgICBjbGVhclBsYXRmb3JtRGF0YSgpOwogICAgIAogI2lm ICFVU0UoTkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC0yMzAsNyArMjY3LDggQEAg dm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyKCkKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFy ZWRCdWZmZXI6OmNvcHkoKSBjb25zdAogewogICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNsb25l IHsgYWRvcHRSZWYoKm5ldyBTaGFyZWRCdWZmZXIpIH07Ci0gICAgaWYgKGhhc1BsYXRmb3JtRGF0 YSgpKSB7CisKKyAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkgfHwgbV9maWxlRGF0YSkgewogICAg ICAgICBjbG9uZS0+YXBwZW5kKGRhdGEoKSwgc2l6ZSgpKTsKICAgICAgICAgcmV0dXJuIGNsb25l LnJlbGVhc2UoKTsKICAgICB9CkBAIC0zMTIsNyArMzUwLDcgQEAgdW5zaWduZWQgU2hhcmVkQnVm ZmVyOjpnZXRTb21lRGF0YShjb25zdCBjaGFyKiYgc29tZURhdGEsIHVuc2lnbmVkIHBvc2l0aW9u KSBjb24KICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0gICAgaWYgKGhhc1BsYXRmb3JtRGF0 YSgpKSB7CisgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpIHx8IG1fZmlsZURhdGEpIHsKICAgICAg ICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04ocG9zaXRpb24gPCBzaXplKCkpOwog ICAgICAgICBzb21lRGF0YSA9IGRhdGEoKSArIHBvc2l0aW9uOwogICAgICAgICByZXR1cm4gdG90 YWxTaXplIC0gcG9zaXRpb247CkBAIC0zNDUsNiArMzgzLDU0IEBAIHVuc2lnbmVkIFNoYXJlZEJ1 ZmZlcjo6Z2V0U29tZURhdGEoY29uc3QgY2hhciomIHNvbWVEYXRhLCB1bnNpZ25lZCBwb3NpdGlv bikgY29uCiAjZW5kaWYKIH0KIAorI2lmICFQTEFURk9STShXSU4pCitQYXNzUmVmUHRyPFNoYXJl ZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3Ry aW5nJiBmaWxlUGF0aCkKK3sKKyAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQorICAgICAgICBy ZXR1cm4gbnVsbHB0cjsKKworICAgIENTdHJpbmcgZmlsZW5hbWUgPSBmaWxlU3lzdGVtUmVwcmVz ZW50YXRpb24oZmlsZVBhdGgpOworICAgIGludCBmZCA9IG9wZW4oZmlsZW5hbWUuZGF0YSgpLCBP X1JET05MWSk7CisgICAgaWYgKGZkID09IC0xKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKwor ICAgIHN0cnVjdCBzdGF0IGZpbGVTdGF0OworICAgIGlmIChmc3RhdChmZCwgJmZpbGVTdGF0KSkg eworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIH0KKwor ICAgIHNpemVfdCBzaXplID0gZmlsZVN0YXQuc3Rfc2l6ZTsKKyAgICBpZiAoZmlsZVN0YXQuc3Rf c2l6ZSA8IDAgfHwgc2l6ZSAhPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBsb25nIGxvbmc+KGZpbGVT dGF0LnN0X3NpemUpKSB7CisgICAgICAgIGNsb3NlKGZkKTsKKyAgICAgICAgcmV0dXJuIG51bGxw dHI7CisgICAgfQorCisgICAgY2hhciogZGF0YSA9IHN0YXRpY19jYXN0PGNoYXIqPihtbWFwKDAs IHNpemUsIFBST1RfUkVBRCwgTUFQX0ZJTEUgfCBNQVBfU0hBUkVELCBmZCwgMCkpOworICAgIGlm IChkYXRhID09IE1BUF9GQUlMRUQpIHsKKyAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gbWFw IGluIG1lbW9yeSBmaWxlICVzIiwgZmlsZW5hbWVGb3JEaXNwbGF5KGZpbGVQYXRoKS51dGY4KCku ZGF0YSgpKTsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAg ICB9CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBTaGFyZWRCdWZmZXIoZmQsIGRhdGEsIHNpemUp KTsKK30KKyNlbmRpZgorCit2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXJGaWxlRGF0YSgpCit7Cisj aWYgIVBMQVRGT1JNKFdJTikKKyAgICBBU1NFUlQobV9maWxlRGVzY3JpcHRvcik7CisgICAgQVNT RVJUKG1fZmlsZURhdGEpOworCisgICAgbXVubWFwKG1fZmlsZURhdGEsIG1fZmlsZVNpemUpOwor ICAgIGNsb3NlKG1fZmlsZURlc2NyaXB0b3IpOworCisgICAgbV9maWxlU2l6ZSA9IDA7CisgICAg bV9maWxlRGF0YSA9IG51bGxwdHI7CisgICAgbV9maWxlRGVzY3JpcHRvciA9IDA7CisjZW5kaWYK K30KKwogI2lmICFVU0UoQ0YpICYmICFVU0UoU09VUCkKIAogaW5saW5lIHZvaWQgU2hhcmVkQnVm ZmVyOjpjbGVhclBsYXRmb3JtRGF0YSgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9TaGFyZWRCdWZmZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZl ci5oCmluZGV4IGJjZjM1NTNlZDYwZWNmOWUxMDhiOTJhZjU3MTE0MTE3MDgwMzVlYTEuLjU5OGQy NWEwZGUyODFkYWE0YWI5NThjYThjNWM3MzhlNmZiZTMzZDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1NoYXJlZEJ1ZmZlci5oCkBAIC0xMjksNyArMTI5LDEwIEBAIHByaXZhdGU6CiAgICAgZXhw bGljaXQgU2hhcmVkQnVmZmVyKHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRC dWZmZXIoY29uc3QgY2hhciosIHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRC dWZmZXIoY29uc3QgdW5zaWduZWQgY2hhciosIHVuc2lnbmVkKTsKLSAgICAKKyNpZiAhUExBVEZP Uk0oV0lOKQorICAgIFNoYXJlZEJ1ZmZlcihpbnQgZmlsZURlc2NyaXB0b3IsIGNoYXIqLCBzaXpl X3QpOworI2VuZGlmCisKICAgICAvLyBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gd2lsbCBmb3JjZSBp bnRlcm5hbCBzZWdtZW50ZWQgYnVmZmVycwogICAgIC8vIHRvIGJlIG1lcmdlZCBpbnRvIGEgZmxh dCBidWZmZXIuIFVzZSBnZXRTb21lRGF0YSgpIHdoZW5ldmVyIHBvc3NpYmxlCiAgICAgLy8gZm9y IGJldHRlciBwZXJmb3JtYW5jZS4KQEAgLTE2Nyw2ICsxNzAsMTQgQEAgcHJpdmF0ZToKICAgICBl eHBsaWNpdCBTaGFyZWRCdWZmZXIoU291cEJ1ZmZlciopOwogICAgIEdVbmlxdWVQdHI8U291cEJ1 ZmZlcj4gbV9zb3VwQnVmZmVyOwogI2VuZGlmCisKKyAgICB2b2lkIGNsZWFyRmlsZURhdGEoKTsK KworI2lmICFQTEFURk9STShXSU4pCisgICAgaW50IG1fZmlsZURlc2NyaXB0b3IgeyAwIH07Cisj ZW5kaWYKKyAgICBjaGFyKiBtX2ZpbGVEYXRhIHsgbnVsbHB0ciB9OworICAgIHNpemVfdCBtX2Zp bGVTaXplIHsgMCB9OyAKIH07CiAKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiB1dGY4QnVmZmVy KGNvbnN0IFN0cmluZyYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L1NoYXJlZEJ1ZmZlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvU2hhcmVk QnVmZmVyR3RrLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQ4ZGU0NzE2NDNk MzAwNjI1NzZkOWQyMDA4NGQ0YTU3ZjFkZWUxMy4uMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvU2hhcmVkQnVm ZmVyR3RrLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDUwICswLDAgQEAKLS8qCi0gKiBDb3B5cmln aHQgKEMpIDIwMDggQ29sbGFib3JhIEx0ZC4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgotICogIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKLSAqICBMaWNl bnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIK LSAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5U WTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAgTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKLSAq ICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAq ICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVy YWwgUHVibGljCi0gKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3 cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQotICogIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5r bGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQotICov Ci0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJTaGFyZWRCdWZmZXIuaCIKLQotI2lu Y2x1ZGUgIkZpbGVTeXN0ZW0uaCIKLSNpbmNsdWRlIDx3dGYvZ29iamVjdC9HVW5pcXVlUHRyLmg+ Ci0jaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgotCi0jaW5jbHVkZSA8Z2xpYi5oPgotCi0K LW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1 ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCi17 Ci0gICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKLSAgICAgICAgcmV0dXJuIDA7Ci0KLSAgICBD U3RyaW5nIGZpbGVuYW1lID0gZmlsZVN5c3RlbVJlcHJlc2VudGF0aW9uKGZpbGVQYXRoKTsKLSAg ICBHVW5pcXVlT3V0UHRyPGdjaGFyPiBjb250ZW50czsKLSAgICBnc2l6ZSBzaXplOwotICAgIEdV bmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKLSAgICBpZiAoIWdfZmlsZV9nZXRfY29udGVudHMo ZmlsZW5hbWUuZGF0YSgpLCAmY29udGVudHMub3V0UHRyKCksICZzaXplLCAmZXJyb3Iub3V0UHRy KCkpKSB7Ci0gICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRvIGZ1bGx5IHJlYWQgY29udGVudHMg b2YgZmlsZSAlcyAtICVzIiwgZmlsZW5hbWVGb3JEaXNwbGF5KGZpbGVQYXRoKS51dGY4KCkuZGF0 YSgpLCBlcnJvci0+bWVzc2FnZSk7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIFJl ZlB0cjxTaGFyZWRCdWZmZXI+IHJlc3VsdCA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKGNvbnRlbnRz LmdldCgpLCBzaXplKTsKLQotICAgIHJldHVybiByZXN1bHQucmVsZWFzZSgpOwotfQotCi19IC8v IG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9w b3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3Np eC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU3 N2I4ZWNmMDZmOWJjOWMwZTVmZmExYmRhMDdkODYyMTQyODViZDQuLjAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcG9z aXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAsMCBAQAot LyoKLSAqIENvcHlyaWdodCAoQykgMjAxMCBDb21wYW55IDEwMCwgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0g KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IK LSAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLCBTUEVDSUFMLAotICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAotICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhF T1JZCi0gKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5j bHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCi0KLSNpbmNsdWRlICJG aWxlU3lzdGVtLmgiCi0KLSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUgPHN5cy9zdGF0Lmg+ Ci0jaW5jbHVkZSA8dW5pc3RkLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgotCi1u YW1lc3BhY2UgV2ViQ29yZSB7Ci0KLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZm ZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQotewot ICAgIGlmIChmaWxlUGF0aC5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVybiAwOwotCi0gICAgQ1N0 cmluZyBmaWxlbmFtZSA9IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0aCk7Ci0gICAg aW50IGZkID0gb3BlbihmaWxlbmFtZS5kYXRhKCksIE9fUkRPTkxZKTsKLSAgICBpZiAoZmQgPT0g LTEpCi0gICAgICAgIHJldHVybiAwOwotCi0gICAgc3RydWN0IHN0YXQgZmlsZVN0YXQ7Ci0gICAg aWYgKGZzdGF0KGZkLCAmZmlsZVN0YXQpKSB7Ci0gICAgICAgIGNsb3NlKGZkKTsKLSAgICAgICAg cmV0dXJuIDA7Ci0gICAgfQotCi0gICAgc2l6ZV90IGJ5dGVzVG9SZWFkID0gZmlsZVN0YXQuc3Rf c2l6ZTsKLSAgICBpZiAoZmlsZVN0YXQuc3Rfc2l6ZSA8IDAgfHwgYnl0ZXNUb1JlYWQgIT0gc3Rh dGljX2Nhc3Q8dW5zaWduZWQgbG9uZyBsb25nPihmaWxlU3RhdC5zdF9zaXplKSkgewotICAgICAg ICBjbG9zZShmZCk7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIFZlY3RvcjxjaGFy PiBidWZmZXIoYnl0ZXNUb1JlYWQpOwotCi0gICAgc2l6ZV90IHRvdGFsQnl0ZXNSZWFkID0gMDsK LSAgICBzc2l6ZV90IGJ5dGVzUmVhZDsKLSAgICB3aGlsZSAoKGJ5dGVzUmVhZCA9IHJlYWQoZmQs IGJ1ZmZlci5kYXRhKCkgKyB0b3RhbEJ5dGVzUmVhZCwgYnl0ZXNUb1JlYWQgLSB0b3RhbEJ5dGVz UmVhZCkpID4gMCkKLSAgICAgICAgdG90YWxCeXRlc1JlYWQgKz0gYnl0ZXNSZWFkOwotCi0gICAg Y2xvc2UoZmQpOwotCi0gICAgcmV0dXJuIHRvdGFsQnl0ZXNSZWFkID09IGJ5dGVzVG9SZWFkID8g U2hhcmVkQnVmZmVyOjphZG9wdFZlY3RvcihidWZmZXIpIDogMDsKLX0KLQotfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJl ZEJ1ZmZlcldpbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVy V2luLmNwcAppbmRleCBmNWRkMjI4NDY0MTlhMGYyZDk3ODViOWE2OWNkZjkwOWJjMzkxZDcwLi5i MDE2ZGFiN2UxODFlOTc4MDFmMDFmMmNlZTQ3M2EyMDg4NGIwMWM3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcApAQCAtMzUsNiArMzUsNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRC dWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQog eworICAgIC8vIEZJWE1FOiBVc2UgbWFwIGZpbGUgcm91dGluZXMuCiAgICAgaWYgKGZpbGVQYXRo LmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuIDA7CiAK 251647 2015-04-25 13:37:04 -0700 2015-04-27 07:58:35 -0700 Trying to fix mac build bug-144192-20150425223545.patch text/plain 14958 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTgzMjY3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc5MzFhNGE2ZWEwYTlh YmJmYzMzY2MwYjIyYjM2MjAyODRhOTI0Ni4uOGFkZDIxMWUxNjYxYmRkYzhiMjRlM2YyOWQwMGU3 NWQxOGFlY2I5MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDE1LTA0LTI1ICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIEZpbGUgY29u dGVudCBpcyBtYXBwZWQgdW50aWwgU2hhcmVkQnVmZmVyIGlzIGNsZWFyZWQsIGRlc3Ryb3llZCBv ciBhZGRpdGlvbmFsIGNvbnRlbnQgaXMgYXBwZW5kZWQgdG8gdGhlIFNoYXJlZEJ1ZmZlci4KKyAg ICAgICAgUmVtb3ZlZCBFRkwsIE1hYyBhbmQgR1RLIHNwZWNpZmljIHZlcnNpb25zIG9mIFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorCisgICAgICAgIENoYW5nZXMgY292 ZXJlZCBieSBleGlzdGluZyB0ZXN0cy4KKworICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtlOgor ICAgICAgICAqIFBsYXRmb3JtR1RLLmNtYWtlOgorICAgICAgICAqIFBsYXRmb3JtTWFjLmNtYWtl OgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRC dWZmZXI6OnNpemUpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpkYXRhKToKKyAg ICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YXBwZW5kKToKKyAgICAgICAgKFdlYkNvcmU6 OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpj b3B5KToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEpOgorICAg ICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOgor ICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAgICAqIHBsYXRmb3JtL21h Yy9TaGFyZWRCdWZmZXJNYWMubW06CisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZl ckd0ay5jcHA6IFJlbW92ZWQuCisgICAgICAgICogcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVy UE9TSVguY3BwOiBSZW1vdmVkLgorICAgICAgICAqIHBsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJX aW4uY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVu dHNPZkZpbGUpOiBBZGRlZCBhIEZJWE1FIHRvIHVzZSBtbWFwIHJvdXRpbmVzLgorCiAyMDE1LTA0 LTI0ICBEb3VnIFJ1c3NlbGwgIDxkX3J1c3NlbGxAYXBwbGUuY29tPgogCiAgICAgICAgIEFYOiBy aWNoZXIgdGV4dCBjaGFuZ2Ugbm90aWZpY2F0aW9ucyAoMTQyNzE5KQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvUGxhdGZvcm1FZmwuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVm bC5jbWFrZQppbmRleCBjZjdkNzE4M2M2Y2VjY2YxYjJhODk3NjUzNDI2NjNmYWUzZWUzNWI4Li44 NTRlYTEzODZlN2RjODRlMmZkYjY0MmE0NzM5NTYxMTMzZjE1NTc1IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9y bUVmbC5jbWFrZQpAQCAtMjM4LDcgKzIzOCw2IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09VUkNF UwogICAgIHBsYXRmb3JtL25ldHdvcmsvc291cC9TeW5jaHJvbm91c0xvYWRlckNsaWVudFNvdXAu Y3BwCiAKICAgICBwbGF0Zm9ybS9wb3NpeC9GaWxlU3lzdGVtUE9TSVguY3BwCi0gICAgcGxhdGZv cm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCiAKICAgICBwbGF0Zm9ybS9zb3VwL1NoYXJl ZEJ1ZmZlclNvdXAuY3BwCiAgICAgcGxhdGZvcm0vc291cC9VUkxTb3VwLmNwcApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0 Zm9ybUdUSy5jbWFrZQppbmRleCBkOGI2ZDY1ZThmYWE3OWQwOGMxMjhjMzdkZmY4OTE2ZjNmZGE1 ZDllLi43NWMwNTE1YWNlMTk1NWNmOWE2ODRkOTkxMzM4NzhhNTdmM2ViMTU4IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9Q bGF0Zm9ybUdUSy5jbWFrZQpAQCAtMTI0LDcgKzEyNCw2IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVf U09VUkNFUwogICAgIHBsYXRmb3JtL2d0ay9MYW5ndWFnZUd0ay5jcHAKICAgICBwbGF0Zm9ybS9n dGsvTG9nZ2luZ0d0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvTUlNRVR5cGVSZWdpc3RyeUd0ay5j cHAKLSAgICBwbGF0Zm9ybS9ndGsvU2hhcmVkQnVmZmVyR3RrLmNwcAogICAgIHBsYXRmb3JtL2d0 ay9TaGFyZWRUaW1lckd0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvVGVtcG9yYXJ5TGlua1N0dWJz LmNwcAogICAgIHBsYXRmb3JtL2d0ay9Vc2VyQWdlbnRHdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9QbGF0Zm9ybU1hYy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtTWFj LmNtYWtlCmluZGV4IDA1NGFhNTQwODdlM2M1MzE5OGMxZThmNTU2ODZhYjk5ZTM1MWYyZjcuLmVj YmU3OTVjMjRlYTgwZTJhMWIyYjQ1OWM2MjI3ZDdjYmE5NTY0MGUgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL1BsYXRmb3JtTWFjLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3Jt TWFjLmNtYWtlCkBAIC0zNDksNyArMzQ5LDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VT CiAgICAgcGxhdGZvcm0vbmV0d29yay9tYWMvV2ViQ29yZVVSTFJlc3BvbnNlLm1tCiAKICAgICBw bGF0Zm9ybS9wb3NpeC9GaWxlU3lzdGVtUE9TSVguY3BwCi0gICAgcGxhdGZvcm0vcG9zaXgvU2hh cmVkQnVmZmVyUE9TSVguY3BwCiAKICAgICBwbGF0Zm9ybS90ZXh0L2NmL0h5cGhlbmF0aW9uQ0Yu Y3BwCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCmluZGV4IGFlNmVl ZTVlYmY1MDBlY2NlMDNhNTQxMTQzYWU5YTc1NTg4ZWMxZWYuLjBlN2E0YjU4NTM4OGQwNTMyNGEy ZTM4NTI5ODVlYTgzYTFkNDliYmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1NoYXJlZEJ1ZmZlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVm ZmVyLmNwcApAQCAtMzAsNiArMzAsMTUgQEAKICNpbmNsdWRlIDxhbGdvcml0aG0+CiAjaW5jbHVk ZSA8d3RmL3VuaWNvZGUvVVRGOC5oPgogCisjaWYgIVBMQVRGT1JNKFdJTikKKyNpbmNsdWRlICJG aWxlU3lzdGVtLmgiCisKKyNpbmNsdWRlIDxmY250bC5oPgorI2luY2x1ZGUgPHN5cy9tbWFuLmg+ CisjaW5jbHVkZSA8c3lzL3N0YXQuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+Cisj ZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAjaWYgIVVTRShORVRXT1JLX0NGREFUQV9B UlJBWV9DQUxMQkFDSykKQEAgLTg1LDcgKzk0LDE5IEBAIFNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVm ZmVyKGNvbnN0IHVuc2lnbmVkIGNoYXIqIGRhdGEsIHVuc2lnbmVkIHNpemUpCiB7CiAgICAgYXBw ZW5kKHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KGRhdGEpLCBzaXplKTsKIH0KLSAgICAK KworI2lmICFQTEFURk9STShXSU4pCitTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcihpbnQgZmls ZURlc2NyaXB0b3IsIGNoYXIqIGZpbGVEYXRhLCBzaXplX3QgZmlsZVNpemUpCisgICAgOiBtX3Np emUoMCkKKyAgICAsIG1fYnVmZmVyKGFkb3B0UmVmKG5ldyBEYXRhQnVmZmVyKSkKKyAgICAsIG1f ZmlsZURlc2NyaXB0b3IoZmlsZURlc2NyaXB0b3IpCisgICAgLCBtX2ZpbGVEYXRhKGZpbGVEYXRh KQorICAgICwgbV9maWxlU2l6ZShmaWxlU2l6ZSkKK3sKKyAgICBBU1NFUlQoZmlsZVNpemUgPCBJ TlRfTUFYKTsKK30KKyNlbmRpZgorCiBTaGFyZWRCdWZmZXI6On5TaGFyZWRCdWZmZXIoKQogewog ICAgIGNsZWFyKCk7CkBAIC0xMDQsMTUgKzEyNSwyMCBAQCB1bnNpZ25lZCBTaGFyZWRCdWZmZXI6 OnNpemUoKSBjb25zdAogICAgIGlmIChoYXNQbGF0Zm9ybURhdGEoKSkKICAgICAgICAgcmV0dXJu IHBsYXRmb3JtRGF0YVNpemUoKTsKICAgICAKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAg cmV0dXJuIHN0YXRpY19jYXN0PHVuc2lnbmVkPihtX2ZpbGVTaXplKTsKKwogICAgIHJldHVybiBt X3NpemU7CiB9CiAKIGNvbnN0IGNoYXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CiB7Ci0K ICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0Zm9ybURhdGEo KTsKIAorICAgIGlmIChtX2ZpbGVEYXRhKQorICAgICAgICByZXR1cm4gbV9maWxlRGF0YTsKKwog I2lmIFVTRShORVRXT1JLX0NGREFUQV9BUlJBWV9DQUxMQkFDSykKICAgICBpZiAoY29uc3QgY2hh ciogYnVmZmVyID0gc2luZ2xlRGF0YUFycmF5QnVmZmVyKCkpCiAgICAgICAgIHJldHVybiBidWZm ZXI7CkBAIC0xNjMsNiArMTg5LDE0IEBAIHZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3Qg Y2hhciogZGF0YSwgdW5zaWduZWQgbGVuZ3RoKQogICAgIGlmICghbGVuZ3RoKQogICAgICAgICBy ZXR1cm47CiAKKyAgICBpZiAobV9maWxlRGF0YSkgeworICAgICAgICBjaGFyKiBmaWxlRGF0YSA9 IG1fZmlsZURhdGE7CisgICAgICAgIG1fZmlsZURhdGEgPSBudWxscHRyOworICAgICAgICBhcHBl bmQoZmlsZURhdGEsIHN0YXRpY19jYXN0PHVuc2lnbmVkPihtX2ZpbGVTaXplKSk7CisgICAgICAg IG1fZmlsZURhdGEgPSBmaWxlRGF0YTsKKyAgICAgICAgY2xlYXJGaWxlRGF0YSgpOworICAgIH0K KwogICAgIG1heWJlVHJhbnNmZXJQbGF0Zm9ybURhdGEoKTsKIAogI2lmICFVU0UoTkVUV09SS19D RkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC0yMTMsNiArMjQ3LDkgQEAgdm9pZCBTaGFyZWRCdWZm ZXI6OmFwcGVuZChjb25zdCBWZWN0b3I8Y2hhcj4mIGRhdGEpCiAKIHZvaWQgU2hhcmVkQnVmZmVy OjpjbGVhcigpCiB7CisgICAgaWYgKG1fZmlsZURhdGEpCisgICAgICAgIGNsZWFyRmlsZURhdGEo KTsKKwogICAgIGNsZWFyUGxhdGZvcm1EYXRhKCk7CiAgICAgCiAjaWYgIVVTRShORVRXT1JLX0NG REFUQV9BUlJBWV9DQUxMQkFDSykKQEAgLTIzMCw3ICsyNjcsOCBAQCB2b2lkIFNoYXJlZEJ1ZmZl cjo6Y2xlYXIoKQogUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y29weSgp IGNvbnN0CiB7CiAgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY2xvbmUgeyBhZG9wdFJlZigqbmV3 IFNoYXJlZEJ1ZmZlcikgfTsKLSAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpIHsKKworICAgIGlm IChoYXNQbGF0Zm9ybURhdGEoKSB8fCBtX2ZpbGVEYXRhKSB7CiAgICAgICAgIGNsb25lLT5hcHBl bmQoZGF0YSgpLCBzaXplKCkpOwogICAgICAgICByZXR1cm4gY2xvbmUucmVsZWFzZSgpOwogICAg IH0KQEAgLTMxMiw3ICszNTAsNyBAQCB1bnNpZ25lZCBTaGFyZWRCdWZmZXI6OmdldFNvbWVEYXRh KGNvbnN0IGNoYXIqJiBzb21lRGF0YSwgdW5zaWduZWQgcG9zaXRpb24pIGNvbgogICAgICAgICBy ZXR1cm4gMDsKICAgICB9CiAKLSAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpIHsKKyAgICBpZiAo aGFzUGxhdGZvcm1EYXRhKCkgfHwgbV9maWxlRGF0YSkgewogICAgICAgICBBU1NFUlRfV0lUSF9T RUNVUklUWV9JTVBMSUNBVElPTihwb3NpdGlvbiA8IHNpemUoKSk7CiAgICAgICAgIHNvbWVEYXRh ID0gZGF0YSgpICsgcG9zaXRpb247CiAgICAgICAgIHJldHVybiB0b3RhbFNpemUgLSBwb3NpdGlv bjsKQEAgLTM0NSw2ICszODMsNTQgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpnZXRTb21lRGF0 YShjb25zdCBjaGFyKiYgc29tZURhdGEsIHVuc2lnbmVkIHBvc2l0aW9uKSBjb24KICNlbmRpZgog fQogCisjaWYgIVBMQVRGT1JNKFdJTikKK1Bhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRC dWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQor eworICAgIGlmIChmaWxlUGF0aC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiBudWxscHRyOwor CisgICAgQ1N0cmluZyBmaWxlbmFtZSA9IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0 aCk7CisgICAgaW50IGZkID0gb3BlbihmaWxlbmFtZS5kYXRhKCksIE9fUkRPTkxZKTsKKyAgICBp ZiAoZmQgPT0gLTEpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgc3RydWN0IHN0YXQg ZmlsZVN0YXQ7CisgICAgaWYgKGZzdGF0KGZkLCAmZmlsZVN0YXQpKSB7CisgICAgICAgIGNsb3Nl KGZkKTsKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgfQorCisgICAgc2l6ZV90IHNpemUg PSBzdGF0aWNfY2FzdDxzaXplX3Q+KGZpbGVTdGF0LnN0X3NpemUpOworICAgIGlmIChmaWxlU3Rh dC5zdF9zaXplIDwgMCB8fCBzaXplICE9IHN0YXRpY19jYXN0PHVuc2lnbmVkIGxvbmcgbG9uZz4o ZmlsZVN0YXQuc3Rfc2l6ZSkpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAgICByZXR1cm4g bnVsbHB0cjsKKyAgICB9CisKKyAgICBjaGFyKiBkYXRhID0gc3RhdGljX2Nhc3Q8Y2hhcio+KG1t YXAoMCwgc2l6ZSwgUFJPVF9SRUFELCBNQVBfRklMRSB8IE1BUF9TSEFSRUQsIGZkLCAwKSk7Cisg ICAgaWYgKGRhdGEgPT0gTUFQX0ZBSUxFRCkgeworICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0 byBtYXAgaW4gbWVtb3J5IGZpbGUgJXMiLCBmaWxlbmFtZUZvckRpc3BsYXkoZmlsZVBhdGgpLnV0 ZjgoKS5kYXRhKCkpOworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHJldHVybiBudWxscHRy OworICAgIH0KKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihmZCwgZGF0YSwg c2l6ZSkpOworfQorI2VuZGlmCisKK3ZvaWQgU2hhcmVkQnVmZmVyOjpjbGVhckZpbGVEYXRhKCkK K3sKKyNpZiAhUExBVEZPUk0oV0lOKQorICAgIEFTU0VSVChtX2ZpbGVEZXNjcmlwdG9yKTsKKyAg ICBBU1NFUlQobV9maWxlRGF0YSk7CisKKyAgICBtdW5tYXAobV9maWxlRGF0YSwgbV9maWxlU2l6 ZSk7CisgICAgY2xvc2UobV9maWxlRGVzY3JpcHRvcik7CisKKyAgICBtX2ZpbGVTaXplID0gMDsK KyAgICBtX2ZpbGVEYXRhID0gbnVsbHB0cjsKKyAgICBtX2ZpbGVEZXNjcmlwdG9yID0gMDsKKyNl bmRpZgorfQorCiAjaWYgIVVTRShDRikgJiYgIVVTRShTT1VQKQogCiBpbmxpbmUgdm9pZCBTaGFy ZWRCdWZmZXI6OmNsZWFyUGxhdGZvcm1EYXRhKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVk QnVmZmVyLmgKaW5kZXggYmNmMzU1M2VkNjBlY2Y5ZTEwOGI5MmFmNTcxMTQxMTcwODAzNWVhMS4u NTk4ZDI1YTBkZTI4MWRhYTRhYjk1OGNhOGM1YzczOGU2ZmJlMzNkMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKQEAgLTEyOSw3ICsxMjksMTAgQEAgcHJpdmF0ZToKICAg ICBleHBsaWNpdCBTaGFyZWRCdWZmZXIodW5zaWduZWQpOwogICAgIFdFQkNPUkVfRVhQT1JUIFNo YXJlZEJ1ZmZlcihjb25zdCBjaGFyKiwgdW5zaWduZWQpOwogICAgIFdFQkNPUkVfRVhQT1JUIFNo YXJlZEJ1ZmZlcihjb25zdCB1bnNpZ25lZCBjaGFyKiwgdW5zaWduZWQpOwotICAgIAorI2lmICFQ TEFURk9STShXSU4pCisgICAgU2hhcmVkQnVmZmVyKGludCBmaWxlRGVzY3JpcHRvciwgY2hhcios IHNpemVfdCk7CisjZW5kaWYKKwogICAgIC8vIENhbGxpbmcgdGhpcyBmdW5jdGlvbiB3aWxsIGZv cmNlIGludGVybmFsIHNlZ21lbnRlZCBidWZmZXJzCiAgICAgLy8gdG8gYmUgbWVyZ2VkIGludG8g YSBmbGF0IGJ1ZmZlci4gVXNlIGdldFNvbWVEYXRhKCkgd2hlbmV2ZXIgcG9zc2libGUKICAgICAv LyBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLgpAQCAtMTY3LDYgKzE3MCwxNCBAQCBwcml2YXRlOgog ICAgIGV4cGxpY2l0IFNoYXJlZEJ1ZmZlcihTb3VwQnVmZmVyKik7CiAgICAgR1VuaXF1ZVB0cjxT b3VwQnVmZmVyPiBtX3NvdXBCdWZmZXI7CiAjZW5kaWYKKworICAgIHZvaWQgY2xlYXJGaWxlRGF0 YSgpOworCisjaWYgIVBMQVRGT1JNKFdJTikKKyAgICBpbnQgbV9maWxlRGVzY3JpcHRvciB7IDAg fTsKKyNlbmRpZgorICAgIGNoYXIqIG1fZmlsZURhdGEgeyBudWxscHRyIH07CisgICAgc2l6ZV90 IG1fZmlsZVNpemUgeyAwIH07IAogfTsKIAogUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IHV0ZjhC dWZmZXIoY29uc3QgU3RyaW5nJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvU2hhcmVkQnVmZmVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9T aGFyZWRCdWZmZXJHdGsuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDhkZTQ3 MTY0M2QzMDA2MjU3NmQ5ZDIwMDg0ZDRhNTdmMWRlZTEzLi4wMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TaGFy ZWRCdWZmZXJHdGsuY3BwCisrKyAvZGV2L251bGwKQEAgLTEsNTAgKzAsMCBAQAotLyoKLSAqIENv cHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEgTHRkLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCi0gKiAgbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwotICog IExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVp dGhlcgotICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBh bnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdO VQotICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0g KgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKLSAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBu b3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCi0gKiAgRm91bmRhdGlvbiwgSW5jLiwgNTEg RnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNB Ci0gKi8KLQotI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgot Ci0jaW5jbHVkZSAiRmlsZVN5c3RlbS5oIgotI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dVbmlxdWVQ dHIuaD4KLSNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+Ci0KLSNpbmNsdWRlIDxnbGliLmg+ Ci0KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hh cmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0 aCkKLXsKLSAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQotICAgICAgICByZXR1cm4gMDsKLQot ICAgIENTdHJpbmcgZmlsZW5hbWUgPSBmaWxlU3lzdGVtUmVwcmVzZW50YXRpb24oZmlsZVBhdGgp OwotICAgIEdVbmlxdWVPdXRQdHI8Z2NoYXI+IGNvbnRlbnRzOwotICAgIGdzaXplIHNpemU7Ci0g ICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOwotICAgIGlmICghZ19maWxlX2dldF9jb250 ZW50cyhmaWxlbmFtZS5kYXRhKCksICZjb250ZW50cy5vdXRQdHIoKSwgJnNpemUsICZlcnJvci5v dXRQdHIoKSkpIHsKLSAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gZnVsbHkgcmVhZCBjb250 ZW50cyBvZiBmaWxlICVzIC0gJXMiLCBmaWxlbmFtZUZvckRpc3BsYXkoZmlsZVBhdGgpLnV0Zjgo KS5kYXRhKCksIGVycm9yLT5tZXNzYWdlKTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQotCi0g ICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gcmVzdWx0ID0gU2hhcmVkQnVmZmVyOjpjcmVhdGUoY29u dGVudHMuZ2V0KCksIHNpemUpOwotCi0gICAgcmV0dXJuIHJlc3VsdC5yZWxlYXNlKCk7Ci19Ci0K LX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0gYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMv U2hhcmVkQnVmZmVyTWFjLm1tCmluZGV4IGVhNDgyZjA2ZjA4MTY4YTlhZmQ1OGM2ZDAwYWI1Y2Yw YjMzZTA1NDcuLjA5YjViYzAxZDBiN2Y5YjIzYTgyOGFhMWU5MDI1ZDRmZTJiNDMyZjUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0KKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1hYy5tbQpAQCAtMTIy LDEyICsxMjIsNCBAQCBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZUNG RGF0YSgpCiAgICAgcmV0dXJuIGFkb3B0Q0YoKENGRGF0YVJlZilhZG9wdE5TKFtbV2ViQ29yZVNo YXJlZEJ1ZmZlckRhdGEgYWxsb2NdIGluaXRXaXRoU2hhcmVkQnVmZmVyRGF0YUJ1ZmZlcjptX2J1 ZmZlci5nZXQoKV0pLmxlYWtSZWYoKSk7CiB9CiAKLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBT aGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQ YXRoKQotewotICAgIE5TRGF0YSAqcmVzb3VyY2VEYXRhID0gW05TRGF0YSBkYXRhV2l0aENvbnRl bnRzT2ZGaWxlOmZpbGVQYXRoXTsKLSAgICBpZiAocmVzb3VyY2VEYXRhKSAKLSAgICAgICAgcmV0 dXJuIFNoYXJlZEJ1ZmZlcjo6d3JhcE5TRGF0YShyZXNvdXJjZURhdGEpOwotICAgIHJldHVybiAw OwotfQotCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFy ZWRCdWZmZXJQT1NJWC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFyZWRC dWZmZXJQT1NJWC5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU3N2I4ZWNmMDZm OWJjOWMwZTVmZmExYmRhMDdkODYyMTQyODViZDQuLjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcG9zaXgvU2hhcmVk QnVmZmVyUE9TSVguY3BwCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAsMCBAQAotLyoKLSAqIENv cHlyaWdodCAoQykgMjAxMCBDb21wYW55IDEwMCwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgot ICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK LSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBg YEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKLSAqIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLAotICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLAotICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi0gKiBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29u ZmlnLmgiCi0jaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCi0KLSNpbmNsdWRlICJGaWxlU3lzdGVt LmgiCi0KLSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUgPHN5cy9zdGF0Lmg+Ci0jaW5jbHVk ZSA8dW5pc3RkLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgotCi1uYW1lc3BhY2Ug V2ViQ29yZSB7Ci0KLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0 ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQotewotICAgIGlmIChm aWxlUGF0aC5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVybiAwOwotCi0gICAgQ1N0cmluZyBmaWxl bmFtZSA9IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0aCk7Ci0gICAgaW50IGZkID0g b3BlbihmaWxlbmFtZS5kYXRhKCksIE9fUkRPTkxZKTsKLSAgICBpZiAoZmQgPT0gLTEpCi0gICAg ICAgIHJldHVybiAwOwotCi0gICAgc3RydWN0IHN0YXQgZmlsZVN0YXQ7Ci0gICAgaWYgKGZzdGF0 KGZkLCAmZmlsZVN0YXQpKSB7Ci0gICAgICAgIGNsb3NlKGZkKTsKLSAgICAgICAgcmV0dXJuIDA7 Ci0gICAgfQotCi0gICAgc2l6ZV90IGJ5dGVzVG9SZWFkID0gZmlsZVN0YXQuc3Rfc2l6ZTsKLSAg ICBpZiAoZmlsZVN0YXQuc3Rfc2l6ZSA8IDAgfHwgYnl0ZXNUb1JlYWQgIT0gc3RhdGljX2Nhc3Q8 dW5zaWduZWQgbG9uZyBsb25nPihmaWxlU3RhdC5zdF9zaXplKSkgewotICAgICAgICBjbG9zZShm ZCk7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIFZlY3RvcjxjaGFyPiBidWZmZXIo Ynl0ZXNUb1JlYWQpOwotCi0gICAgc2l6ZV90IHRvdGFsQnl0ZXNSZWFkID0gMDsKLSAgICBzc2l6 ZV90IGJ5dGVzUmVhZDsKLSAgICB3aGlsZSAoKGJ5dGVzUmVhZCA9IHJlYWQoZmQsIGJ1ZmZlci5k YXRhKCkgKyB0b3RhbEJ5dGVzUmVhZCwgYnl0ZXNUb1JlYWQgLSB0b3RhbEJ5dGVzUmVhZCkpID4g MCkKLSAgICAgICAgdG90YWxCeXRlc1JlYWQgKz0gYnl0ZXNSZWFkOwotCi0gICAgY2xvc2UoZmQp OwotCi0gICAgcmV0dXJuIHRvdGFsQnl0ZXNSZWFkID09IGJ5dGVzVG9SZWFkID8gU2hhcmVkQnVm ZmVyOjphZG9wdFZlY3RvcihidWZmZXIpIDogMDsKLX0KLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldp bi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcApp bmRleCBmNWRkMjI4NDY0MTlhMGYyZDk3ODViOWE2OWNkZjkwOWJjMzkxZDcwLi5iMDE2ZGFiN2Ux ODFlOTc4MDFmMDFmMmNlZTQ3M2EyMDg4NGIwMWM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcApAQCAtMzUsNiArMzUsNyBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNy ZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQogeworICAgIC8v IEZJWE1FOiBVc2UgbWFwIGZpbGUgcm91dGluZXMuCiAgICAgaWYgKGZpbGVQYXRoLmlzRW1wdHko KSkKICAgICAgICAgcmV0dXJuIDA7CiAK 251740 2015-04-27 07:58:41 -0700 2015-04-27 08:51:50 -0700 MappedFileData version bug-144192-20150427165732.patch text/plain 20090 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTgzMzg4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGQ1MTY5ZTEyNDFkZDJk ZDA4ZTM4ZjEwM2NmMThlMzgzMDIxZDE5My4uYzYxMGFjMWM0NjA1YTc4ZTU2OTYyODRmZGM5YjE4 ZTQ0M2I1MjVlOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUwIEBACisyMDE1LTA0LTI3ICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIEZpbGUgY29u dGVudCBpcyBtYXBwZWQgdW50aWwgU2hhcmVkQnVmZmVyIGlzIGNsZWFyZWQsIGRlc3Ryb3llZCBv ciBhZGRpdGlvbmFsIGNvbnRlbnQgaXMgYXBwZW5kZWQgdG8gdGhlIFNoYXJlZEJ1ZmZlci4KKyAg ICAgICAgUmVtb3ZlZCBFRkwsIE1hYyBhbmQgR1RLIHNwZWNpZmljIHZlcnNpb25zIG9mIFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorCisgICAgICAgIEEgaGVscGVyIGNs YXNzLCBNYXBwZWRGaWxlRGF0YSwgaXMgaW50cm9kdWNlZCB0aGUgaGFuZGxpbmcgb2YgbWFwcGVk IGZpbGVzIHRocm91Z2ggY2FsbHMgdG8gb3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAg ICBDaGFuZ2VzIGNvdmVyZWQgYnkgZXhpc3RpbmcgdGVzdHMuCisKKyAgICAgICAgKiBQbGF0Zm9y bUVmbC5jbWFrZToKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAgICAgICAgKiBQbGF0 Zm9ybU1hYy5jbWFrZToKKyAgICAgICAgKiBwbGF0Zm9ybS9GaWxlU3lzdGVtLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6 TWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBl ZEZpbGVEYXRhOjpjbGVhcik6CisgICAgICAgIChXZWJDb3JlOjpNYXBwZWRGaWxlRGF0YTo6ZGF0 YSk6CisgICAgICAgIChXZWJDb3JlOjpNYXBwZWRGaWxlRGF0YTo6c2l6ZSk6CisgICAgICAgICog cGxhdGZvcm0vRmlsZVN5c3RlbS5oOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcik6CisgICAg ICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OnNpemUpOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YXBwZW5k KToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOgorICAgICAgICAoV2Vi Q29yZTo6U2hhcmVkQnVmZmVyOjpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZl cjo6Z2V0U29tZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjptYXliZVRy YW5zZmVyTWFwcGVkRmlsZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpj cmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZl ci5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwOiBSZW1vdmVk LgorICAgICAgICAqIHBsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW06CisgICAgICAgICog cGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwOiBSZW1vdmVkLgorICAgICAgICAq IHBsYXRmb3JtL3dpbi9GaWxlU3lzdGVtV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBl ZEZpbGVEYXRhOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OmNs ZWFyKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpkYXRhKToKKyAgICAgICAg KFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpzaXplKToKKyAgICAgICAgKiBwbGF0Zm9ybS93aW4v U2hhcmVkQnVmZmVyV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y3Jl YXRlV2l0aENvbnRlbnRzT2ZGaWxlKToKKwogMjAxNS0wNC0yNCAgUGhpbGlwcGUgTm9ybWFuZCAg PHBub3JtYW5kQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0pIQnVpbGRdIE1vdmUgdG8gdXBzdHJl YW0gT3BlbldlYlJUQwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1FZmwuY21h a2UgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFrZQppbmRleCBjZjdkNzE4M2M2Y2Vj Y2YxYjJhODk3NjUzNDI2NjNmYWUzZWUzNWI4Li44NTRlYTEzODZlN2RjODRlMmZkYjY0MmE0NzM5 NTYxMTMzZjE1NTc1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFr ZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFrZQpAQCAtMjM4LDcgKzIzOCw2 IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09VUkNFUwogICAgIHBsYXRmb3JtL25ldHdvcmsvc291 cC9TeW5jaHJvbm91c0xvYWRlckNsaWVudFNvdXAuY3BwCiAKICAgICBwbGF0Zm9ybS9wb3NpeC9G aWxlU3lzdGVtUE9TSVguY3BwCi0gICAgcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVgu Y3BwCiAKICAgICBwbGF0Zm9ybS9zb3VwL1NoYXJlZEJ1ZmZlclNvdXAuY3BwCiAgICAgcGxhdGZv cm0vc291cC9VUkxTb3VwLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCAwMTgzMDEx NzM2ZDQzNTk4NTEyMDM0YzBlNmJhMDFiOWFhZmJlYjMyLi5iOWQyNzRlMDQwNGY1MTAxNWE2MTIz MTUyZTNjOWRkNjFiN2Y1MDFjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdU Sy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMTI0LDcg KzEyNCw2IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09VUkNFUwogICAgIHBsYXRmb3JtL2d0ay9M YW5ndWFnZUd0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvTG9nZ2luZ0d0ay5jcHAKICAgICBwbGF0 Zm9ybS9ndGsvTUlNRVR5cGVSZWdpc3RyeUd0ay5jcHAKLSAgICBwbGF0Zm9ybS9ndGsvU2hhcmVk QnVmZmVyR3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9TaGFyZWRUaW1lckd0ay5jcHAKICAgICBw bGF0Zm9ybS9ndGsvVGVtcG9yYXJ5TGlua1N0dWJzLmNwcAogICAgIHBsYXRmb3JtL2d0ay9Vc2Vy QWdlbnRHdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybU1hYy5jbWFr ZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtTWFjLmNtYWtlCmluZGV4IDA1NGFhNTQwODdlM2M1 MzE5OGMxZThmNTU2ODZhYjk5ZTM1MWYyZjcuLmVjYmU3OTVjMjRlYTgwZTJhMWIyYjQ1OWM2MjI3 ZDdjYmE5NTY0MGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtTWFjLmNtYWtl CisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtTWFjLmNtYWtlCkBAIC0zNDksNyArMzQ5LDYg QEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0vbmV0d29yay9tYWMv V2ViQ29yZVVSTFJlc3BvbnNlLm1tCiAKICAgICBwbGF0Zm9ybS9wb3NpeC9GaWxlU3lzdGVtUE9T SVguY3BwCi0gICAgcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCiAKICAgICBw bGF0Zm9ybS90ZXh0L2NmL0h5cGhlbmF0aW9uQ0YuY3BwCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v RmlsZVN5c3RlbS5jcHAKaW5kZXggOTdiODQ2ZWVjYzRjNjMwZGRiYTA2ZDRjNTdkMzYxNzY4ZDhl Y2ZkZi4uNGM5NWFlYzQyNzljMmU1Mzg0ZWIxMWJkMWM2Yzk1ZjMzODQ0ZTIzMyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29w eXJpZ2h0IChDKSAyMDA3LCAyMDExIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq IENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgog ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI3LDggKzI4LDE1IEBACiAjaW5jbHVkZSAi RmlsZVN5c3RlbS5oIgogCiAjaW5jbHVkZSA8d3RmL0hleE51bWJlci5oPgorI2luY2x1ZGUgPHd0 Zi90ZXh0L0NTdHJpbmcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CiAK KyNpZiAhUExBVEZPUk0oV0lOKQorI2luY2x1ZGUgPGZjbnRsLmg+CisjaW5jbHVkZSA8c3lzL21t YW4uaD4KKyNpbmNsdWRlIDxzeXMvc3RhdC5oPgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAogLy8gVGhlIGZvbGxvd2luZyBsb3dlci1BU0NJSSBjaGFyYWN0ZXJzIG5lZWQgZXNjYXBp bmcgdG8gYmUgdXNlZCBpbiBhIGZpbGVuYW1lCkBAIC0xMTMsNCArMTIxLDY1IEBAIGJvb2wgZXhj bHVkZUZyb21CYWNrdXAoY29uc3QgU3RyaW5nJikKIAogI2VuZGlmCiAKKyNpZiAhUExBVEZPUk0o V0lOKQorCitSZWZQdHI8TWFwcGVkRmlsZURhdGE+IE1hcHBlZEZpbGVEYXRhOjpjcmVhdGUoY29u c3QgU3RyaW5nJiBmaWxlUGF0aCkKK3sKKyAgICBpbnQgZmQgPSBvcGVuKGZpbGVTeXN0ZW1SZXBy ZXNlbnRhdGlvbihmaWxlUGF0aCkuZGF0YSgpLCBPX1JET05MWSk7CisgICAgaWYgKGZkIDwgMCkK KyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisKKyAgICBzdHJ1Y3Qgc3RhdCBmaWxlU3RhdDsKKyAg ICBpZiAoZnN0YXQoZmQsICZmaWxlU3RhdCkpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAg ICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisKKyAgICBpZiAoZmlsZVN0YXQuc3Rfc2l6ZSA8IDAg fHwgZmlsZVN0YXQuc3Rfc2l6ZSA+IElOVF9NQVgpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAg ICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisKKyAgICB1bnNpZ25lZCBzaXplID0gc3RhdGlj X2Nhc3Q8dW5zaWduZWQ+KGZpbGVTdGF0LnN0X3NpemUpOworICAgIHZvaWQqIGRhdGEgPSBtbWFw KDAsIHNpemUsIFBST1RfUkVBRCwgTUFQX0ZJTEUgfCBNQVBfU0hBUkVELCBmZCwgMCk7CisgICAg aWYgKGRhdGEgPT0gTUFQX0ZBSUxFRCkgeworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHJl dHVybiBudWxscHRyOworICAgIH0KKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IE1hcHBlZEZpbGVE YXRhKGZkLCBkYXRhLCBzaXplKSk7Cit9CisKK01hcHBlZEZpbGVEYXRhOjpNYXBwZWRGaWxlRGF0 YShpbnQgZmlsZURlc2NyaXB0b3IsIHZvaWQqIGZpbGVEYXRhLCB1bnNpZ25lZCBmaWxlU2l6ZSkK KyAgICA6IG1fZmlsZURlc2NyaXB0b3IoZmlsZURlc2NyaXB0b3IpCisgICAgLCBtX2ZpbGVEYXRh KGZpbGVEYXRhKQorICAgICwgbV9maWxlU2l6ZShmaWxlU2l6ZSkKK3sKKyAgICBBU1NFUlQoZmls ZURlc2NyaXB0b3IgPj0gMCk7CisgICAgQVNTRVJUKGZpbGVEYXRhKTsKK30KKwordm9pZCBNYXBw ZWRGaWxlRGF0YTo6Y2xlYXIoKQoreworICAgIGlmIChtX2ZpbGVEYXRhKSB7CisgICAgICAgIG11 bm1hcChtX2ZpbGVEYXRhLCBtX2ZpbGVTaXplKTsKKyAgICAgICAgY2xvc2UobV9maWxlRGVzY3Jp cHRvcik7CisKKyAgICAgICAgbV9maWxlU2l6ZSA9IDA7CisgICAgICAgIG1fZmlsZURhdGEgPSBu dWxscHRyOworICAgICAgICBtX2ZpbGVEZXNjcmlwdG9yID0gMDsKKyAgICB9Cit9CisKK2NvbnN0 IHZvaWQqIE1hcHBlZEZpbGVEYXRhOjpkYXRhKCkKK3sKKyAgICByZXR1cm4gbV9maWxlRGF0YTsK K30KKwordW5zaWduZWQgTWFwcGVkRmlsZURhdGE6OnNpemUoKQoreworICAgIHJldHVybiBtX2Zp bGVTaXplOworfQorCisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vRmlsZVN5c3RlbS5oCmluZGV4IGY1YzNhMmNmOGYxNjQ0M2ZmMTJlNmQ1Yzc3YTY3 NzE1YzhlMjNiNGMuLjczNmY0OGViNjI2N2RhNzljNTgyMTJlYWIzZTQ4OGQwYzA4Yjk1MTYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmgKQEAgLTMyLDYgKzMyLDcgQEAKIAogI2lu Y2x1ZGUgPHRpbWUuaD4KICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9S ZWZDb3VudGVkLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0 L1dURlN0cmluZy5oPgogCkBAIC0yMDQsNiArMjA1LDI3IEBAIFdFQkNPUkVfRVhQT1JUIFN0cmlu ZyBsb2NhbFVzZXJTcGVjaWZpY1N0b3JhZ2VEaXJlY3RvcnkoKTsKIFN0cmluZyByb2FtaW5nVXNl clNwZWNpZmljU3RvcmFnZURpcmVjdG9yeSgpOwogI2VuZGlmCiAKK2NsYXNzIE1hcHBlZEZpbGVE YXRhOiBwdWJsaWMgUmVmQ291bnRlZDxNYXBwZWRGaWxlRGF0YT4geworcHVibGljOgorICAgIHN0 YXRpYyBSZWZQdHI8TWFwcGVkRmlsZURhdGE+IGNyZWF0ZShjb25zdCBTdHJpbmcmKTsKKworICAg IH5NYXBwZWRGaWxlRGF0YSgpIHsgY2xlYXIoKTsgfQorCisgICAgdm9pZCBjbGVhcigpOworICAg IGNvbnN0IHZvaWQqIGRhdGEoKTsKKyAgICB1bnNpZ25lZCBzaXplKCk7CisKK3ByaXZhdGU6Cisj aWYgIVBMQVRGT1JNKFdJTikKKyAgICBNYXBwZWRGaWxlRGF0YShpbnQsIHZvaWQqLCB1bnNpZ25l ZCk7CisKKyAgICBpbnQgbV9maWxlRGVzY3JpcHRvciB7IDAgfTsKKyAgICB2b2lkKiBtX2ZpbGVE YXRhIHsgbnVsbHB0ciB9OworICAgIHVuc2lnbmVkIG1fZmlsZVNpemUgeyAwIH07CisjZW5kaWYK KworfTsKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRmlsZVN5c3RlbV9o CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcAppbmRleCBhZTZlZWU1ZWJm NTAwZWNjZTAzYTU0MTE0M2FlOWE3NTU4OGVjMWVmLi43ODI5OWY3MDg4Mzc0ZDc4NGFjYmE0ZGVh NTIwOGJlZjgyMzdkMjQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFy ZWRCdWZmZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5j cHAKQEAgLTEsNiArMSw3IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA2LCAyMDA4IEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqIENvcHlyaWdodCAoQykgUmVzZWFyY2ggSW4g TW90aW9uIExpbWl0ZWQgMjAwOS0yMDEwLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJp Z2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMzAsNiArMzEsMTUgQEAKICNpbmNsdWRlIDxhbGdvcml0 aG0+CiAjaW5jbHVkZSA8d3RmL3VuaWNvZGUvVVRGOC5oPgogCisjaWYgIVBMQVRGT1JNKFdJTikK KyNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCisKKyNpbmNsdWRlIDxmY250bC5oPgorI2luY2x1ZGUg PHN5cy9tbWFuLmg+CisjaW5jbHVkZSA8c3lzL3N0YXQuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9D U3RyaW5nLmg+CisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAjaWYgIVVTRShORVRX T1JLX0NGREFUQV9BUlJBWV9DQUxMQkFDSykKQEAgLTg1LDcgKzk1LDE0IEBAIFNoYXJlZEJ1ZmZl cjo6U2hhcmVkQnVmZmVyKGNvbnN0IHVuc2lnbmVkIGNoYXIqIGRhdGEsIHVuc2lnbmVkIHNpemUp CiB7CiAgICAgYXBwZW5kKHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3QgY2hhcio+KGRhdGEpLCBzaXpl KTsKIH0KLSAgICAKKworU2hhcmVkQnVmZmVyOjpTaGFyZWRCdWZmZXIoTWFwcGVkRmlsZURhdGEm IGZpbGVEYXRhKQorICAgIDogbV9zaXplKDApCisgICAgLCBtX2J1ZmZlcihhZG9wdFJlZihuZXcg RGF0YUJ1ZmZlcikpCisgICAgLCBtX2ZpbGVEYXRhKCZmaWxlRGF0YSkKK3sKK30KKwogU2hhcmVk QnVmZmVyOjp+U2hhcmVkQnVmZmVyKCkKIHsKICAgICBjbGVhcigpOwpAQCAtMTA0LDE1ICsxMjEs MjAgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpzaXplKCkgY29uc3QKICAgICBpZiAoaGFzUGxh dGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0Zm9ybURhdGFTaXplKCk7CiAgICAgCisg ICAgaWYgKG1fZmlsZURhdGEpCisgICAgICAgIHJldHVybiBtX2ZpbGVEYXRhLT5zaXplKCk7CisK ICAgICByZXR1cm4gbV9zaXplOwogfQogCiBjb25zdCBjaGFyKiBTaGFyZWRCdWZmZXI6OmRhdGEo KSBjb25zdAogewotCiAgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKQogICAgICAgICByZXR1cm4g cGxhdGZvcm1EYXRhKCk7CiAKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAgcmV0dXJuIHN0 YXRpY19jYXN0PGNvbnN0IGNoYXIqPihtX2ZpbGVEYXRhLT5kYXRhKCkpOworCiAjaWYgVVNFKE5F VFdPUktfQ0ZEQVRBX0FSUkFZX0NBTExCQUNLKQogICAgIGlmIChjb25zdCBjaGFyKiBidWZmZXIg PSBzaW5nbGVEYXRhQXJyYXlCdWZmZXIoKSkKICAgICAgICAgcmV0dXJuIGJ1ZmZlcjsKQEAgLTE2 Myw2ICsxODUsNyBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6YXBwZW5kKGNvbnN0IGNoYXIqIGRhdGEs IHVuc2lnbmVkIGxlbmd0aCkKICAgICBpZiAoIWxlbmd0aCkKICAgICAgICAgcmV0dXJuOwogCisg ICAgbWF5YmVUcmFuc2Zlck1hcHBlZEZpbGVEYXRhKCk7CiAgICAgbWF5YmVUcmFuc2ZlclBsYXRm b3JtRGF0YSgpOwogCiAjaWYgIVVTRShORVRXT1JLX0NGREFUQV9BUlJBWV9DQUxMQkFDSykKQEAg LTIxMyw2ICsyMzYsOSBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6YXBwZW5kKGNvbnN0IFZlY3Rvcjxj aGFyPiYgZGF0YSkKIAogdm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyKCkKIHsKKyAgICBpZiAobV9m aWxlRGF0YSkKKyAgICAgICAgbV9maWxlRGF0YSA9IG51bGxwdHI7CisKICAgICBjbGVhclBsYXRm b3JtRGF0YSgpOwogICAgIAogI2lmICFVU0UoTkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0sp CkBAIC0yMzAsNyArMjU2LDggQEAgdm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyKCkKIFBhc3NSZWZQ dHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNvcHkoKSBjb25zdAogewogICAgIFJlZlB0 cjxTaGFyZWRCdWZmZXI+IGNsb25lIHsgYWRvcHRSZWYoKm5ldyBTaGFyZWRCdWZmZXIpIH07Ci0g ICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7CisKKyAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkg fHwgbV9maWxlRGF0YSkgewogICAgICAgICBjbG9uZS0+YXBwZW5kKGRhdGEoKSwgc2l6ZSgpKTsK ICAgICAgICAgcmV0dXJuIGNsb25lLnJlbGVhc2UoKTsKICAgICB9CkBAIC0zMTIsNyArMzM5LDcg QEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpnZXRTb21lRGF0YShjb25zdCBjaGFyKiYgc29tZURh dGEsIHVuc2lnbmVkIHBvc2l0aW9uKSBjb24KICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0g ICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7CisgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpIHx8 IG1fZmlsZURhdGEpIHsKICAgICAgICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04o cG9zaXRpb24gPCBzaXplKCkpOwogICAgICAgICBzb21lRGF0YSA9IGRhdGEoKSArIHBvc2l0aW9u OwogICAgICAgICByZXR1cm4gdG90YWxTaXplIC0gcG9zaXRpb247CkBAIC0zNDUsNiArMzcyLDI0 IEBAIHVuc2lnbmVkIFNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEoY29uc3QgY2hhciomIHNvbWVE YXRhLCB1bnNpZ25lZCBwb3NpdGlvbikgY29uCiAjZW5kaWYKIH0KIAordm9pZCBTaGFyZWRCdWZm ZXI6Om1heWJlVHJhbnNmZXJNYXBwZWRGaWxlRGF0YSgpCit7CisgICAgaWYgKG1fZmlsZURhdGEp IHsKKyAgICAgICAgYXV0byBmaWxlRGF0YSA9IFdURjo6bW92ZShtX2ZpbGVEYXRhKTsKKyAgICAg ICAgYXBwZW5kKHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihmaWxlRGF0YS0+ZGF0YSgpKSwgZmls ZURhdGEtPnNpemUoKSk7CisgICAgfQorfQorCitSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRC dWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQor eworICAgIFJlZlB0cjxNYXBwZWRGaWxlRGF0YT4gbWFwcGVkRmlsZURhdGEgPSBNYXBwZWRGaWxl RGF0YTo6Y3JlYXRlKGZpbGVQYXRoKTsKKyAgICBpZiAoIW1hcHBlZEZpbGVEYXRhKQorICAgICAg ICByZXR1cm4gbnVsbHB0cjsKKyAgICAvLyBGSVhNRTogV2UgbWlnaHQgd2FudCB0byBsaW1pdCB0 aGUgbnVtYmVyIG9mIG9wZW5lZCBmaWxlcy4KKyAgICAvLyBGb3IgZmlsZXMgd2UgZG8gbm90IHdh bnQgdG8ga2VlcCBvcGVuZWQsIGRhdGEgY291bGQgYmUgY29waWVkIGluIG1lbW9yeSB2aWEgbWF5 YmVUYW5zZmVyTWFwcGVkRmlsZURhdGEuCisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBTaGFyZWRC dWZmZXIoKm1hcHBlZEZpbGVEYXRhKSk7Cit9CisKICNpZiAhVVNFKENGKSAmJiAhVVNFKFNPVVAp CiAKIGlubGluZSB2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXJQbGF0Zm9ybURhdGEoKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaAppbmRleCBiY2YzNTUzZWQ2MGVjZjllMTA4Yjky YWY1NzExNDExNzA4MDM1ZWExLi43YzUwMTlkODI3Njc1YzFjM2Q3YTE2ODY3ODcxMDNiN2FiOWNi ZWRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaApAQCAtMjcsNiArMjcs OCBAQAogI2lmbmRlZiBTaGFyZWRCdWZmZXJfaAogI2RlZmluZSBTaGFyZWRCdWZmZXJfaAogCisj aW5jbHVkZSAiRmlsZVN5c3RlbS5oIgorCiAjaW5jbHVkZSA8cnVudGltZS9BcnJheUJ1ZmZlci5o PgogI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4K QEAgLTU1LDcgKzU3LDcgQEAgcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1 ZmZlcj4gY3JlYXRlKGNvbnN0IGNoYXIqIGMsIHVuc2lnbmVkIGkpIHsgcmV0dXJuIGFkb3B0UmVm KG5ldyBTaGFyZWRCdWZmZXIoYywgaSkpOyB9CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVk QnVmZmVyPiBjcmVhdGUoY29uc3QgdW5zaWduZWQgY2hhciogYywgdW5zaWduZWQgaSkgeyByZXR1 cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihjLCBpKSk7IH0KIAotICAgIFdFQkNPUkVfRVhQ T1JUIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY3JlYXRlV2l0aENvbnRlbnRzT2ZG aWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpOworICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBS ZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5n JiBmaWxlUGF0aCk7CiAKICAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgUGFzc1JlZlB0cjxTaGFy ZWRCdWZmZXI+IGFkb3B0VmVjdG9yKFZlY3RvcjxjaGFyPiYgdmVjdG9yKTsKICAgICAKQEAgLTEy OSw3ICsxMzEsOCBAQCBwcml2YXRlOgogICAgIGV4cGxpY2l0IFNoYXJlZEJ1ZmZlcih1bnNpZ25l ZCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVyKGNvbnN0IGNoYXIqLCB1bnNpZ25l ZCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVyKGNvbnN0IHVuc2lnbmVkIGNoYXIq LCB1bnNpZ25lZCk7Ci0gICAgCisgICAgU2hhcmVkQnVmZmVyKE1hcHBlZEZpbGVEYXRhJik7CisK ICAgICAvLyBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gd2lsbCBmb3JjZSBpbnRlcm5hbCBzZWdtZW50 ZWQgYnVmZmVycwogICAgIC8vIHRvIGJlIG1lcmdlZCBpbnRvIGEgZmxhdCBidWZmZXIuIFVzZSBn ZXRTb21lRGF0YSgpIHdoZW5ldmVyIHBvc3NpYmxlCiAgICAgLy8gZm9yIGJldHRlciBwZXJmb3Jt YW5jZS4KQEAgLTEzOSw2ICsxNDIsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgbWF5YmVUcmFuc2Zl clBsYXRmb3JtRGF0YSgpOwogICAgIGJvb2wgbWF5YmVBcHBlbmRQbGF0Zm9ybURhdGEoU2hhcmVk QnVmZmVyKik7CiAKKyAgICB2b2lkIG1heWJlVHJhbnNmZXJNYXBwZWRGaWxlRGF0YSgpOworCiAg ICAgdm9pZCBjb3B5QnVmZmVyQW5kQ2xlYXIoY2hhciogZGVzdGluYXRpb24sIHVuc2lnbmVkIGJ5 dGVzVG9Db3B5KSBjb25zdDsKIAogICAgIHZvaWQgYXBwZW5kVG9EYXRhQnVmZmVyKGNvbnN0IGNo YXIgKiwgdW5zaWduZWQpIGNvbnN0OwpAQCAtMTY3LDYgKzE3Miw4IEBAIHByaXZhdGU6CiAgICAg ZXhwbGljaXQgU2hhcmVkQnVmZmVyKFNvdXBCdWZmZXIqKTsKICAgICBHVW5pcXVlUHRyPFNvdXBC dWZmZXI+IG1fc291cEJ1ZmZlcjsKICNlbmRpZgorCisgICAgUmVmUHRyPE1hcHBlZEZpbGVEYXRh PiBtX2ZpbGVEYXRhOwogfTsKIAogUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IHV0ZjhCdWZmZXIo Y29uc3QgU3RyaW5nJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv U2hhcmVkQnVmZmVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TaGFyZWRC dWZmZXJHdGsuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlZDhkZTQ3MTY0M2Qz MDA2MjU3NmQ5ZDIwMDg0ZDRhNTdmMWRlZTEzLi4wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TaGFyZWRCdWZm ZXJHdGsuY3BwCisrKyAvZGV2L251bGwKQEAgLTEsNTAgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdo dCAoQykgMjAwOCBDb2xsYWJvcmEgTHRkLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBz b2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCi0gKiAgbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwotICogIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgot ICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0 ZXIgdmVyc2lvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqICBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQotICog IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICog IFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJh bCBQdWJsaWMKLSAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdy aXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCi0gKiAgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCi0gKi8K LQotI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgotCi0jaW5j bHVkZSAiRmlsZVN5c3RlbS5oIgotI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dVbmlxdWVQdHIuaD4K LSNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+Ci0KLSNpbmNsdWRlIDxnbGliLmg+Ci0KLQot bmFtZXNwYWNlIFdlYkNvcmUgewotCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVm ZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKLXsK LSAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQotICAgICAgICByZXR1cm4gMDsKLQotICAgIENT dHJpbmcgZmlsZW5hbWUgPSBmaWxlU3lzdGVtUmVwcmVzZW50YXRpb24oZmlsZVBhdGgpOwotICAg IEdVbmlxdWVPdXRQdHI8Z2NoYXI+IGNvbnRlbnRzOwotICAgIGdzaXplIHNpemU7Ci0gICAgR1Vu aXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOwotICAgIGlmICghZ19maWxlX2dldF9jb250ZW50cyhm aWxlbmFtZS5kYXRhKCksICZjb250ZW50cy5vdXRQdHIoKSwgJnNpemUsICZlcnJvci5vdXRQdHIo KSkpIHsKLSAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8gZnVsbHkgcmVhZCBjb250ZW50cyBv ZiBmaWxlICVzIC0gJXMiLCBmaWxlbmFtZUZvckRpc3BsYXkoZmlsZVBhdGgpLnV0ZjgoKS5kYXRh KCksIGVycm9yLT5tZXNzYWdlKTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQotCi0gICAgUmVm UHRyPFNoYXJlZEJ1ZmZlcj4gcmVzdWx0ID0gU2hhcmVkQnVmZmVyOjpjcmVhdGUoY29udGVudHMu Z2V0KCksIHNpemUpOwotCi0gICAgcmV0dXJuIHJlc3VsdC5yZWxlYXNlKCk7Ci19Ci0KLX0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21h Yy9TaGFyZWRCdWZmZXJNYWMubW0gYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVk QnVmZmVyTWFjLm1tCmluZGV4IGVhNDgyZjA2ZjA4MTY4YTlhZmQ1OGM2ZDAwYWI1Y2YwYjMzZTA1 NDcuLjA5YjViYzAxZDBiN2Y5YjIzYTgyOGFhMWU5MDI1ZDRmZTJiNDMyZjUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0KKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1hYy5tbQpAQCAtMTIyLDEyICsx MjIsNCBAQCBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZUNGRGF0YSgp CiAgICAgcmV0dXJuIGFkb3B0Q0YoKENGRGF0YVJlZilhZG9wdE5TKFtbV2ViQ29yZVNoYXJlZEJ1 ZmZlckRhdGEgYWxsb2NdIGluaXRXaXRoU2hhcmVkQnVmZmVyRGF0YUJ1ZmZlcjptX2J1ZmZlci5n ZXQoKV0pLmxlYWtSZWYoKSk7CiB9CiAKLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRC dWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQot ewotICAgIE5TRGF0YSAqcmVzb3VyY2VEYXRhID0gW05TRGF0YSBkYXRhV2l0aENvbnRlbnRzT2ZG aWxlOmZpbGVQYXRoXTsKLSAgICBpZiAocmVzb3VyY2VEYXRhKSAKLSAgICAgICAgcmV0dXJuIFNo YXJlZEJ1ZmZlcjo6d3JhcE5TRGF0YShyZXNvdXJjZURhdGEpOwotICAgIHJldHVybiAwOwotfQot CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZm ZXJQT1NJWC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZmZXJQ T1NJWC5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGU3N2I4ZWNmMDZmOWJjOWMw ZTVmZmExYmRhMDdkODYyMTQyODViZDQuLjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVy UE9TSVguY3BwCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdo dCAoQykgMjAxMCBDb21wYW55IDEwMCwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElT JycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKLSAqIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LAotICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAotICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi0gKiBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgi Ci0jaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCi0KLSNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCi0K LSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUgPHN5cy9zdGF0Lmg+Ci0jaW5jbHVkZSA8dW5p c3RkLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgotCi1uYW1lc3BhY2UgV2ViQ29y ZSB7Ci0KLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhD b250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQotewotICAgIGlmIChmaWxlUGF0 aC5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVybiAwOwotCi0gICAgQ1N0cmluZyBmaWxlbmFtZSA9 IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0aCk7Ci0gICAgaW50IGZkID0gb3Blbihm aWxlbmFtZS5kYXRhKCksIE9fUkRPTkxZKTsKLSAgICBpZiAoZmQgPT0gLTEpCi0gICAgICAgIHJl dHVybiAwOwotCi0gICAgc3RydWN0IHN0YXQgZmlsZVN0YXQ7Ci0gICAgaWYgKGZzdGF0KGZkLCAm ZmlsZVN0YXQpKSB7Ci0gICAgICAgIGNsb3NlKGZkKTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAg fQotCi0gICAgc2l6ZV90IGJ5dGVzVG9SZWFkID0gZmlsZVN0YXQuc3Rfc2l6ZTsKLSAgICBpZiAo ZmlsZVN0YXQuc3Rfc2l6ZSA8IDAgfHwgYnl0ZXNUb1JlYWQgIT0gc3RhdGljX2Nhc3Q8dW5zaWdu ZWQgbG9uZyBsb25nPihmaWxlU3RhdC5zdF9zaXplKSkgewotICAgICAgICBjbG9zZShmZCk7Ci0g ICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIFZlY3RvcjxjaGFyPiBidWZmZXIoYnl0ZXNU b1JlYWQpOwotCi0gICAgc2l6ZV90IHRvdGFsQnl0ZXNSZWFkID0gMDsKLSAgICBzc2l6ZV90IGJ5 dGVzUmVhZDsKLSAgICB3aGlsZSAoKGJ5dGVzUmVhZCA9IHJlYWQoZmQsIGJ1ZmZlci5kYXRhKCkg KyB0b3RhbEJ5dGVzUmVhZCwgYnl0ZXNUb1JlYWQgLSB0b3RhbEJ5dGVzUmVhZCkpID4gMCkKLSAg ICAgICAgdG90YWxCeXRlc1JlYWQgKz0gYnl0ZXNSZWFkOwotCi0gICAgY2xvc2UoZmQpOwotCi0g ICAgcmV0dXJuIHRvdGFsQnl0ZXNSZWFkID09IGJ5dGVzVG9SZWFkID8gU2hhcmVkQnVmZmVyOjph ZG9wdFZlY3RvcihidWZmZXIpIDogMDsKLX0KLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL0ZpbGVTeXN0ZW1XaW4uY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL0ZpbGVTeXN0ZW1XaW4uY3BwCmluZGV4IGIyZGQ4 ZGUyNWY1ODRmNWRiOTlhNTA1NzFiMzU3ZGRkZjgwNTRlMWUuLmMxNTdkYmUwODc4MTU3MTljN2My ZWUyMjRkMzM2M2MxOGE4YTRmZTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L3dpbi9GaWxlU3lzdGVtV2luLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4v RmlsZVN5c3RlbVdpbi5jcHAKQEAgLTQ0Miw0ICs0NDIsMjQgQEAgVmVjdG9yPFN0cmluZz4gbGlz dERpcmVjdG9yeShjb25zdCBTdHJpbmcmIGRpcmVjdG9yeSwgY29uc3QgU3RyaW5nJiBmaWx0ZXIp CiAgICAgcmV0dXJuIGVudHJpZXM7CiB9CiAKKy8vIEZJWE1FOiBJbXBsZW1lbnQgTWFwcGVkRmls ZURhdGEKK1JlZlB0cjxNYXBwZWRGaWxlRGF0YT4gTWFwcGVkRmlsZURhdGE6OmNyZWF0ZShjb25z dCBTdHJpbmcmIGZpbGVQYXRoKQoreworICAgIHJldHVybiBudWxscHRyOworfQorCit2b2lkIE1h cHBlZEZpbGVEYXRhOjpjbGVhcigpCit7Cit9CisKK2NvbnN0IHZvaWQqIE1hcHBlZEZpbGVEYXRh OjpkYXRhKCkKK3sKKyAgICByZXR1cm4gbnVsbHB0cjsKK30KKwordW5zaWduZWQgTWFwcGVkRmls ZURhdGE6OnNpemUoKQoreworICAgIHJldHVybiAwOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVy V2luLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3Bw CmluZGV4IGY1ZGQyMjg0NjQxOWEwZjJkOTc4NWI5YTY5Y2RmOTA5YmMzOTFkNzAuLmIwMTZkYWI3 ZTE4MWU5NzgwMWYwMWYyY2VlNDczYTIwODg0YjAxYzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwCkBAIC0zNSw2ICszNSw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6 Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCiB7CisgICAg Ly8gRklYTUU6IFVzZSBtYXAgZmlsZSByb3V0aW5lcy4KICAgICBpZiAoZmlsZVBhdGguaXNFbXB0 eSgpKQogICAgICAgICByZXR1cm4gMDsKIAo= 251744 2015-04-27 08:51:57 -0700 2015-04-30 08:05:54 -0700 Fixing build bug-144192-20150427175047.patch text/plain 20199 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTgzMzg4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGQ1MTY5ZTEyNDFkZDJk ZDA4ZTM4ZjEwM2NmMThlMzgzMDIxZDE5My4uYzYxMGFjMWM0NjA1YTc4ZTU2OTYyODRmZGM5YjE4 ZTQ0M2I1MjVlOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUwIEBACisyMDE1LTA0LTI3ICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIEZpbGUgY29u dGVudCBpcyBtYXBwZWQgdW50aWwgU2hhcmVkQnVmZmVyIGlzIGNsZWFyZWQsIGRlc3Ryb3llZCBv ciBhZGRpdGlvbmFsIGNvbnRlbnQgaXMgYXBwZW5kZWQgdG8gdGhlIFNoYXJlZEJ1ZmZlci4KKyAg ICAgICAgUmVtb3ZlZCBFRkwsIE1hYyBhbmQgR1RLIHNwZWNpZmljIHZlcnNpb25zIG9mIFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorCisgICAgICAgIEEgaGVscGVyIGNs YXNzLCBNYXBwZWRGaWxlRGF0YSwgaXMgaW50cm9kdWNlZCB0aGUgaGFuZGxpbmcgb2YgbWFwcGVk IGZpbGVzIHRocm91Z2ggY2FsbHMgdG8gb3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAg ICBDaGFuZ2VzIGNvdmVyZWQgYnkgZXhpc3RpbmcgdGVzdHMuCisKKyAgICAgICAgKiBQbGF0Zm9y bUVmbC5jbWFrZToKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZToKKyAgICAgICAgKiBQbGF0 Zm9ybU1hYy5jbWFrZToKKyAgICAgICAgKiBwbGF0Zm9ybS9GaWxlU3lzdGVtLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6 TWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBl ZEZpbGVEYXRhOjpjbGVhcik6CisgICAgICAgIChXZWJDb3JlOjpNYXBwZWRGaWxlRGF0YTo6ZGF0 YSk6CisgICAgICAgIChXZWJDb3JlOjpNYXBwZWRGaWxlRGF0YTo6c2l6ZSk6CisgICAgICAgICog cGxhdGZvcm0vRmlsZVN5c3RlbS5oOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5j cHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcik6CisgICAg ICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OnNpemUpOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YXBwZW5k KToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOgorICAgICAgICAoV2Vi Q29yZTo6U2hhcmVkQnVmZmVyOjpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZl cjo6Z2V0U29tZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjptYXliZVRy YW5zZmVyTWFwcGVkRmlsZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpj cmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZl ci5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwOiBSZW1vdmVk LgorICAgICAgICAqIHBsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW06CisgICAgICAgICog cGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwOiBSZW1vdmVkLgorICAgICAgICAq IHBsYXRmb3JtL3dpbi9GaWxlU3lzdGVtV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBl ZEZpbGVEYXRhOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OmNs ZWFyKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpkYXRhKToKKyAgICAgICAg KFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpzaXplKToKKyAgICAgICAgKiBwbGF0Zm9ybS93aW4v U2hhcmVkQnVmZmVyV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y3Jl YXRlV2l0aENvbnRlbnRzT2ZGaWxlKToKKwogMjAxNS0wNC0yNCAgUGhpbGlwcGUgTm9ybWFuZCAg PHBub3JtYW5kQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0pIQnVpbGRdIE1vdmUgdG8gdXBzdHJl YW0gT3BlbldlYlJUQwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1FZmwuY21h a2UgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFrZQppbmRleCBjZjdkNzE4M2M2Y2Vj Y2YxYjJhODk3NjUzNDI2NjNmYWUzZWUzNWI4Li44NTRlYTEzODZlN2RjODRlMmZkYjY0MmE0NzM5 NTYxMTMzZjE1NTc1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFr ZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUVmbC5jbWFrZQpAQCAtMjM4LDcgKzIzOCw2 IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09VUkNFUwogICAgIHBsYXRmb3JtL25ldHdvcmsvc291 cC9TeW5jaHJvbm91c0xvYWRlckNsaWVudFNvdXAuY3BwCiAKICAgICBwbGF0Zm9ybS9wb3NpeC9G aWxlU3lzdGVtUE9TSVguY3BwCi0gICAgcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVgu Y3BwCiAKICAgICBwbGF0Zm9ybS9zb3VwL1NoYXJlZEJ1ZmZlclNvdXAuY3BwCiAgICAgcGxhdGZv cm0vc291cC9VUkxTb3VwLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCAwMTgzMDEx NzM2ZDQzNTk4NTEyMDM0YzBlNmJhMDFiOWFhZmJlYjMyLi5iOWQyNzRlMDQwNGY1MTAxNWE2MTIz MTUyZTNjOWRkNjFiN2Y1MDFjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdU Sy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMTI0LDcg KzEyNCw2IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09VUkNFUwogICAgIHBsYXRmb3JtL2d0ay9M YW5ndWFnZUd0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvTG9nZ2luZ0d0ay5jcHAKICAgICBwbGF0 Zm9ybS9ndGsvTUlNRVR5cGVSZWdpc3RyeUd0ay5jcHAKLSAgICBwbGF0Zm9ybS9ndGsvU2hhcmVk QnVmZmVyR3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9TaGFyZWRUaW1lckd0ay5jcHAKICAgICBw bGF0Zm9ybS9ndGsvVGVtcG9yYXJ5TGlua1N0dWJzLmNwcAogICAgIHBsYXRmb3JtL2d0ay9Vc2Vy QWdlbnRHdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybU1hYy5jbWFr ZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtTWFjLmNtYWtlCmluZGV4IDA1NGFhNTQwODdlM2M1 MzE5OGMxZThmNTU2ODZhYjk5ZTM1MWYyZjcuLmVjYmU3OTVjMjRlYTgwZTJhMWIyYjQ1OWM2MjI3 ZDdjYmE5NTY0MGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtTWFjLmNtYWtl CisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtTWFjLmNtYWtlCkBAIC0zNDksNyArMzQ5LDYg QEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0vbmV0d29yay9tYWMv V2ViQ29yZVVSTFJlc3BvbnNlLm1tCiAKICAgICBwbGF0Zm9ybS9wb3NpeC9GaWxlU3lzdGVtUE9T SVguY3BwCi0gICAgcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCiAKICAgICBw bGF0Zm9ybS90ZXh0L2NmL0h5cGhlbmF0aW9uQ0YuY3BwCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v RmlsZVN5c3RlbS5jcHAKaW5kZXggOTdiODQ2ZWVjYzRjNjMwZGRiYTA2ZDRjNTdkMzYxNzY4ZDhl Y2ZkZi4uZTliNDVmZDgwZDExZTUyOWE0ZGZiNzA3MjQzYTAyMDZmZGFkY2U1NiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29w eXJpZ2h0IChDKSAyMDA3LCAyMDExIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq IENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgog ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI3LDggKzI4LDE2IEBACiAjaW5jbHVkZSAi RmlsZVN5c3RlbS5oIgogCiAjaW5jbHVkZSA8d3RmL0hleE51bWJlci5oPgorI2luY2x1ZGUgPHd0 Zi90ZXh0L0NTdHJpbmcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CiAK KyNpZiAhUExBVEZPUk0oV0lOKQorI2luY2x1ZGUgPGZjbnRsLmg+CisjaW5jbHVkZSA8c3lzL21t YW4uaD4KKyNpbmNsdWRlIDxzeXMvc3RhdC5oPgorI2luY2x1ZGUgPHVuaXN0ZC5oPgorI2VuZGlm CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogLy8gVGhlIGZvbGxvd2luZyBsb3dlci1BU0NJSSBj aGFyYWN0ZXJzIG5lZWQgZXNjYXBpbmcgdG8gYmUgdXNlZCBpbiBhIGZpbGVuYW1lCkBAIC0xMTMs NCArMTIyLDY1IEBAIGJvb2wgZXhjbHVkZUZyb21CYWNrdXAoY29uc3QgU3RyaW5nJikKIAogI2Vu ZGlmCiAKKyNpZiAhUExBVEZPUk0oV0lOKQorCitSZWZQdHI8TWFwcGVkRmlsZURhdGE+IE1hcHBl ZEZpbGVEYXRhOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK3sKKyAgICBpbnQgZmQg PSBvcGVuKGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0aCkuZGF0YSgpLCBPX1JET05M WSk7CisgICAgaWYgKGZkIDwgMCkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisKKyAgICBzdHJ1 Y3Qgc3RhdCBmaWxlU3RhdDsKKyAgICBpZiAoZnN0YXQoZmQsICZmaWxlU3RhdCkpIHsKKyAgICAg ICAgY2xvc2UoZmQpOworICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisKKyAgICBpZiAo ZmlsZVN0YXQuc3Rfc2l6ZSA8IDAgfHwgZmlsZVN0YXQuc3Rfc2l6ZSA+IElOVF9NQVgpIHsKKyAg ICAgICAgY2xvc2UoZmQpOworICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisKKyAgICB1 bnNpZ25lZCBzaXplID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KGZpbGVTdGF0LnN0X3NpemUpOwor ICAgIHZvaWQqIGRhdGEgPSBtbWFwKDAsIHNpemUsIFBST1RfUkVBRCwgTUFQX0ZJTEUgfCBNQVBf U0hBUkVELCBmZCwgMCk7CisgICAgaWYgKGRhdGEgPT0gTUFQX0ZBSUxFRCkgeworICAgICAgICBj bG9zZShmZCk7CisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIH0KKyAgICByZXR1cm4gYWRv cHRSZWYobmV3IE1hcHBlZEZpbGVEYXRhKGZkLCBkYXRhLCBzaXplKSk7Cit9CisKK01hcHBlZEZp bGVEYXRhOjpNYXBwZWRGaWxlRGF0YShpbnQgZmlsZURlc2NyaXB0b3IsIHZvaWQqIGZpbGVEYXRh LCB1bnNpZ25lZCBmaWxlU2l6ZSkKKyAgICA6IG1fZmlsZURlc2NyaXB0b3IoZmlsZURlc2NyaXB0 b3IpCisgICAgLCBtX2ZpbGVEYXRhKGZpbGVEYXRhKQorICAgICwgbV9maWxlU2l6ZShmaWxlU2l6 ZSkKK3sKKyAgICBBU1NFUlQoZmlsZURlc2NyaXB0b3IgPj0gMCk7CisgICAgQVNTRVJUKGZpbGVE YXRhKTsKK30KKwordm9pZCBNYXBwZWRGaWxlRGF0YTo6Y2xlYXIoKQoreworICAgIGlmIChtX2Zp bGVEYXRhKSB7CisgICAgICAgIG11bm1hcChtX2ZpbGVEYXRhLCBtX2ZpbGVTaXplKTsKKyAgICAg ICAgY2xvc2UobV9maWxlRGVzY3JpcHRvcik7CisKKyAgICAgICAgbV9maWxlU2l6ZSA9IDA7Cisg ICAgICAgIG1fZmlsZURhdGEgPSBudWxscHRyOworICAgICAgICBtX2ZpbGVEZXNjcmlwdG9yID0g MDsKKyAgICB9Cit9CisKK2NvbnN0IHZvaWQqIE1hcHBlZEZpbGVEYXRhOjpkYXRhKCkKK3sKKyAg ICByZXR1cm4gbV9maWxlRGF0YTsKK30KKwordW5zaWduZWQgTWFwcGVkRmlsZURhdGE6OnNpemUo KQoreworICAgIHJldHVybiBtX2ZpbGVTaXplOworfQorCisjZW5kaWYKKwogfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3Rl bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5oCmluZGV4IGY1YzNhMmNm OGYxNjQ0M2ZmMTJlNmQ1Yzc3YTY3NzE1YzhlMjNiNGMuLjczNmY0OGViNjI2N2RhNzljNTgyMTJl YWIzZTQ4OGQwYzA4Yjk1MTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0Zp bGVTeXN0ZW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmgKQEAg LTMyLDYgKzMyLDcgQEAKIAogI2luY2x1ZGUgPHRpbWUuaD4KICNpbmNsdWRlIDx3dGYvRm9yd2Fy ZC5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5o PgogI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCkBAIC0yMDQsNiArMjA1LDI3IEBA IFdFQkNPUkVfRVhQT1JUIFN0cmluZyBsb2NhbFVzZXJTcGVjaWZpY1N0b3JhZ2VEaXJlY3Rvcnko KTsKIFN0cmluZyByb2FtaW5nVXNlclNwZWNpZmljU3RvcmFnZURpcmVjdG9yeSgpOwogI2VuZGlm CiAKK2NsYXNzIE1hcHBlZEZpbGVEYXRhOiBwdWJsaWMgUmVmQ291bnRlZDxNYXBwZWRGaWxlRGF0 YT4geworcHVibGljOgorICAgIHN0YXRpYyBSZWZQdHI8TWFwcGVkRmlsZURhdGE+IGNyZWF0ZShj b25zdCBTdHJpbmcmKTsKKworICAgIH5NYXBwZWRGaWxlRGF0YSgpIHsgY2xlYXIoKTsgfQorCisg ICAgdm9pZCBjbGVhcigpOworICAgIGNvbnN0IHZvaWQqIGRhdGEoKTsKKyAgICB1bnNpZ25lZCBz aXplKCk7CisKK3ByaXZhdGU6CisjaWYgIVBMQVRGT1JNKFdJTikKKyAgICBNYXBwZWRGaWxlRGF0 YShpbnQsIHZvaWQqLCB1bnNpZ25lZCk7CisKKyAgICBpbnQgbV9maWxlRGVzY3JpcHRvciB7IDAg fTsKKyAgICB2b2lkKiBtX2ZpbGVEYXRhIHsgbnVsbHB0ciB9OworICAgIHVuc2lnbmVkIG1fZmls ZVNpemUgeyAwIH07CisjZW5kaWYKKworfTsKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAj ZW5kaWYgLy8gRmlsZVN5c3RlbV9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9TaGFyZWRCdWZmZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVy LmNwcAppbmRleCBhZTZlZWU1ZWJmNTAwZWNjZTAzYTU0MTE0M2FlOWE3NTU4OGVjMWVmLi43ODI5 OWY3MDg4Mzc0ZDc4NGFjYmE0ZGVhNTIwOGJlZjgyMzdkMjQ0IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKQEAgLTEsNiArMSw3IEBACiAvKgogICogQ29weXJpZ2h0 IChDKSAyMDA2LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqIENvcHly aWdodCAoQykgUmVzZWFyY2ggSW4gTW90aW9uIExpbWl0ZWQgMjAwOS0yMDEwLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMzAsNiArMzEsMTUg QEAKICNpbmNsdWRlIDxhbGdvcml0aG0+CiAjaW5jbHVkZSA8d3RmL3VuaWNvZGUvVVRGOC5oPgog CisjaWYgIVBMQVRGT1JNKFdJTikKKyNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCisKKyNpbmNsdWRl IDxmY250bC5oPgorI2luY2x1ZGUgPHN5cy9tbWFuLmg+CisjaW5jbHVkZSA8c3lzL3N0YXQuaD4K KyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNv cmUgewogCiAjaWYgIVVTRShORVRXT1JLX0NGREFUQV9BUlJBWV9DQUxMQkFDSykKQEAgLTg1LDcg Kzk1LDE0IEBAIFNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKGNvbnN0IHVuc2lnbmVkIGNoYXIq IGRhdGEsIHVuc2lnbmVkIHNpemUpCiB7CiAgICAgYXBwZW5kKHJlaW50ZXJwcmV0X2Nhc3Q8Y29u c3QgY2hhcio+KGRhdGEpLCBzaXplKTsKIH0KLSAgICAKKworU2hhcmVkQnVmZmVyOjpTaGFyZWRC dWZmZXIoTWFwcGVkRmlsZURhdGEmIGZpbGVEYXRhKQorICAgIDogbV9zaXplKDApCisgICAgLCBt X2J1ZmZlcihhZG9wdFJlZihuZXcgRGF0YUJ1ZmZlcikpCisgICAgLCBtX2ZpbGVEYXRhKCZmaWxl RGF0YSkKK3sKK30KKwogU2hhcmVkQnVmZmVyOjp+U2hhcmVkQnVmZmVyKCkKIHsKICAgICBjbGVh cigpOwpAQCAtMTA0LDE1ICsxMjEsMjAgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpzaXplKCkg Y29uc3QKICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0Zm9y bURhdGFTaXplKCk7CiAgICAgCisgICAgaWYgKG1fZmlsZURhdGEpCisgICAgICAgIHJldHVybiBt X2ZpbGVEYXRhLT5zaXplKCk7CisKICAgICByZXR1cm4gbV9zaXplOwogfQogCiBjb25zdCBjaGFy KiBTaGFyZWRCdWZmZXI6OmRhdGEoKSBjb25zdAogewotCiAgICAgaWYgKGhhc1BsYXRmb3JtRGF0 YSgpKQogICAgICAgICByZXR1cm4gcGxhdGZvcm1EYXRhKCk7CiAKKyAgICBpZiAobV9maWxlRGF0 YSkKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihtX2ZpbGVEYXRhLT5k YXRhKCkpOworCiAjaWYgVVNFKE5FVFdPUktfQ0ZEQVRBX0FSUkFZX0NBTExCQUNLKQogICAgIGlm IChjb25zdCBjaGFyKiBidWZmZXIgPSBzaW5nbGVEYXRhQXJyYXlCdWZmZXIoKSkKICAgICAgICAg cmV0dXJuIGJ1ZmZlcjsKQEAgLTE2Myw2ICsxODUsNyBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6YXBw ZW5kKGNvbnN0IGNoYXIqIGRhdGEsIHVuc2lnbmVkIGxlbmd0aCkKICAgICBpZiAoIWxlbmd0aCkK ICAgICAgICAgcmV0dXJuOwogCisgICAgbWF5YmVUcmFuc2Zlck1hcHBlZEZpbGVEYXRhKCk7CiAg ICAgbWF5YmVUcmFuc2ZlclBsYXRmb3JtRGF0YSgpOwogCiAjaWYgIVVTRShORVRXT1JLX0NGREFU QV9BUlJBWV9DQUxMQkFDSykKQEAgLTIxMyw2ICsyMzYsOSBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6 YXBwZW5kKGNvbnN0IFZlY3RvcjxjaGFyPiYgZGF0YSkKIAogdm9pZCBTaGFyZWRCdWZmZXI6OmNs ZWFyKCkKIHsKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAgbV9maWxlRGF0YSA9IG51bGxw dHI7CisKICAgICBjbGVhclBsYXRmb3JtRGF0YSgpOwogICAgIAogI2lmICFVU0UoTkVUV09SS19D RkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC0yMzAsNyArMjU2LDggQEAgdm9pZCBTaGFyZWRCdWZm ZXI6OmNsZWFyKCkKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNvcHko KSBjb25zdAogewogICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNsb25lIHsgYWRvcHRSZWYoKm5l dyBTaGFyZWRCdWZmZXIpIH07Ci0gICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7CisKKyAgICBp ZiAoaGFzUGxhdGZvcm1EYXRhKCkgfHwgbV9maWxlRGF0YSkgewogICAgICAgICBjbG9uZS0+YXBw ZW5kKGRhdGEoKSwgc2l6ZSgpKTsKICAgICAgICAgcmV0dXJuIGNsb25lLnJlbGVhc2UoKTsKICAg ICB9CkBAIC0zMTIsNyArMzM5LDcgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpnZXRTb21lRGF0 YShjb25zdCBjaGFyKiYgc29tZURhdGEsIHVuc2lnbmVkIHBvc2l0aW9uKSBjb24KICAgICAgICAg cmV0dXJuIDA7CiAgICAgfQogCi0gICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7CisgICAgaWYg KGhhc1BsYXRmb3JtRGF0YSgpIHx8IG1fZmlsZURhdGEpIHsKICAgICAgICAgQVNTRVJUX1dJVEhf U0VDVVJJVFlfSU1QTElDQVRJT04ocG9zaXRpb24gPCBzaXplKCkpOwogICAgICAgICBzb21lRGF0 YSA9IGRhdGEoKSArIHBvc2l0aW9uOwogICAgICAgICByZXR1cm4gdG90YWxTaXplIC0gcG9zaXRp b247CkBAIC0zNDUsNiArMzcyLDI0IEBAIHVuc2lnbmVkIFNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURh dGEoY29uc3QgY2hhciomIHNvbWVEYXRhLCB1bnNpZ25lZCBwb3NpdGlvbikgY29uCiAjZW5kaWYK IH0KIAordm9pZCBTaGFyZWRCdWZmZXI6Om1heWJlVHJhbnNmZXJNYXBwZWRGaWxlRGF0YSgpCit7 CisgICAgaWYgKG1fZmlsZURhdGEpIHsKKyAgICAgICAgYXV0byBmaWxlRGF0YSA9IFdURjo6bW92 ZShtX2ZpbGVEYXRhKTsKKyAgICAgICAgYXBwZW5kKHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihm aWxlRGF0YS0+ZGF0YSgpKSwgZmlsZURhdGEtPnNpemUoKSk7CisgICAgfQorfQorCitSZWZQdHI8 U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25z dCBTdHJpbmcmIGZpbGVQYXRoKQoreworICAgIFJlZlB0cjxNYXBwZWRGaWxlRGF0YT4gbWFwcGVk RmlsZURhdGEgPSBNYXBwZWRGaWxlRGF0YTo6Y3JlYXRlKGZpbGVQYXRoKTsKKyAgICBpZiAoIW1h cHBlZEZpbGVEYXRhKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICAvLyBGSVhNRTogV2Ug bWlnaHQgd2FudCB0byBsaW1pdCB0aGUgbnVtYmVyIG9mIG9wZW5lZCBmaWxlcy4KKyAgICAvLyBG b3IgZmlsZXMgd2UgZG8gbm90IHdhbnQgdG8ga2VlcCBvcGVuZWQsIGRhdGEgY291bGQgYmUgY29w aWVkIGluIG1lbW9yeSB2aWEgbWF5YmVUYW5zZmVyTWFwcGVkRmlsZURhdGEuCisgICAgcmV0dXJu IGFkb3B0UmVmKG5ldyBTaGFyZWRCdWZmZXIoKm1hcHBlZEZpbGVEYXRhKSk7Cit9CisKICNpZiAh VVNFKENGKSAmJiAhVVNFKFNPVVApCiAKIGlubGluZSB2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXJQ bGF0Zm9ybURhdGEoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVk QnVmZmVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaAppbmRleCBi Y2YzNTUzZWQ2MGVjZjllMTA4YjkyYWY1NzExNDExNzA4MDM1ZWExLi43YzUwMTlkODI3Njc1YzFj M2Q3YTE2ODY3ODcxMDNiN2FiOWNiZWRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9TaGFyZWRCdWZmZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRC dWZmZXIuaApAQCAtMjcsNiArMjcsOCBAQAogI2lmbmRlZiBTaGFyZWRCdWZmZXJfaAogI2RlZmlu ZSBTaGFyZWRCdWZmZXJfaAogCisjaW5jbHVkZSAiRmlsZVN5c3RlbS5oIgorCiAjaW5jbHVkZSA8 cnVudGltZS9BcnJheUJ1ZmZlci5oPgogI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+CiAjaW5jbHVk ZSA8d3RmL1JlZkNvdW50ZWQuaD4KQEAgLTU1LDcgKzU3LDcgQEAgcHVibGljOgogICAgIHN0YXRp YyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY3JlYXRlKGNvbnN0IGNoYXIqIGMsIHVuc2lnbmVk IGkpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBTaGFyZWRCdWZmZXIoYywgaSkpOyB9CiAgICAgc3Rh dGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGUoY29uc3QgdW5zaWduZWQgY2hhciog YywgdW5zaWduZWQgaSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihjLCBpKSk7 IH0KIAotICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4g Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpOworICAgIFdF QkNPUkVfRVhQT1JUIHN0YXRpYyBSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGVXaXRoQ29udGVu dHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCk7CiAKICAgICBXRUJDT1JFX0VYUE9SVCBz dGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGFkb3B0VmVjdG9yKFZlY3RvcjxjaGFyPiYg dmVjdG9yKTsKICAgICAKQEAgLTEyOSw3ICsxMzEsOCBAQCBwcml2YXRlOgogICAgIGV4cGxpY2l0 IFNoYXJlZEJ1ZmZlcih1bnNpZ25lZCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVy KGNvbnN0IGNoYXIqLCB1bnNpZ25lZCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVy KGNvbnN0IHVuc2lnbmVkIGNoYXIqLCB1bnNpZ25lZCk7Ci0gICAgCisgICAgU2hhcmVkQnVmZmVy KE1hcHBlZEZpbGVEYXRhJik7CisKICAgICAvLyBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gd2lsbCBm b3JjZSBpbnRlcm5hbCBzZWdtZW50ZWQgYnVmZmVycwogICAgIC8vIHRvIGJlIG1lcmdlZCBpbnRv IGEgZmxhdCBidWZmZXIuIFVzZSBnZXRTb21lRGF0YSgpIHdoZW5ldmVyIHBvc3NpYmxlCiAgICAg Ly8gZm9yIGJldHRlciBwZXJmb3JtYW5jZS4KQEAgLTEzOSw2ICsxNDIsOCBAQCBwcml2YXRlOgog ICAgIHZvaWQgbWF5YmVUcmFuc2ZlclBsYXRmb3JtRGF0YSgpOwogICAgIGJvb2wgbWF5YmVBcHBl bmRQbGF0Zm9ybURhdGEoU2hhcmVkQnVmZmVyKik7CiAKKyAgICB2b2lkIG1heWJlVHJhbnNmZXJN YXBwZWRGaWxlRGF0YSgpOworCiAgICAgdm9pZCBjb3B5QnVmZmVyQW5kQ2xlYXIoY2hhciogZGVz dGluYXRpb24sIHVuc2lnbmVkIGJ5dGVzVG9Db3B5KSBjb25zdDsKIAogICAgIHZvaWQgYXBwZW5k VG9EYXRhQnVmZmVyKGNvbnN0IGNoYXIgKiwgdW5zaWduZWQpIGNvbnN0OwpAQCAtMTY3LDYgKzE3 Miw4IEBAIHByaXZhdGU6CiAgICAgZXhwbGljaXQgU2hhcmVkQnVmZmVyKFNvdXBCdWZmZXIqKTsK ICAgICBHVW5pcXVlUHRyPFNvdXBCdWZmZXI+IG1fc291cEJ1ZmZlcjsKICNlbmRpZgorCisgICAg UmVmUHRyPE1hcHBlZEZpbGVEYXRhPiBtX2ZpbGVEYXRhOwogfTsKIAogUGFzc1JlZlB0cjxTaGFy ZWRCdWZmZXI+IHV0ZjhCdWZmZXIoY29uc3QgU3RyaW5nJik7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvU2hhcmVkQnVmZmVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCBlZDhkZTQ3MTY0M2QzMDA2MjU3NmQ5ZDIwMDg0ZDRhNTdmMWRlZTEzLi4wMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwCisrKyAvZGV2L251bGwKQEAgLTEsNTAgKzAs MCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEgTHRkLgotICoKLSAqICBU aGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yCi0gKiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5l cmFsIFB1YmxpYwotICogIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb247IGVpdGhlcgotICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5IGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiAgYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKLSAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQotICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCi0gKgotICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKLSAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCi0gKiAgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAg MDIxMTAtMTMwMSAgVVNBCi0gKi8KLQotI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIlNo YXJlZEJ1ZmZlci5oIgotCi0jaW5jbHVkZSAiRmlsZVN5c3RlbS5oIgotI2luY2x1ZGUgPHd0Zi9n b2JqZWN0L0dVbmlxdWVQdHIuaD4KLSNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+Ci0KLSNp bmNsdWRlIDxnbGliLmg+Ci0KLQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1QYXNzUmVmUHRyPFNo YXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3Qg U3RyaW5nJiBmaWxlUGF0aCkKLXsKLSAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQotICAgICAg ICByZXR1cm4gMDsKLQotICAgIENTdHJpbmcgZmlsZW5hbWUgPSBmaWxlU3lzdGVtUmVwcmVzZW50 YXRpb24oZmlsZVBhdGgpOwotICAgIEdVbmlxdWVPdXRQdHI8Z2NoYXI+IGNvbnRlbnRzOwotICAg IGdzaXplIHNpemU7Ci0gICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOwotICAgIGlmICgh Z19maWxlX2dldF9jb250ZW50cyhmaWxlbmFtZS5kYXRhKCksICZjb250ZW50cy5vdXRQdHIoKSwg JnNpemUsICZlcnJvci5vdXRQdHIoKSkpIHsKLSAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQgdG8g ZnVsbHkgcmVhZCBjb250ZW50cyBvZiBmaWxlICVzIC0gJXMiLCBmaWxlbmFtZUZvckRpc3BsYXko ZmlsZVBhdGgpLnV0ZjgoKS5kYXRhKCksIGVycm9yLT5tZXNzYWdlKTsKLSAgICAgICAgcmV0dXJu IDA7Ci0gICAgfQotCi0gICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gcmVzdWx0ID0gU2hhcmVkQnVm ZmVyOjpjcmVhdGUoY29udGVudHMuZ2V0KCksIHNpemUpOwotCi0gICAgcmV0dXJuIHJlc3VsdC5y ZWxlYXNlKCk7Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0gYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1tCmluZGV4IGVhNDgyZjA2ZjA4MTY4YTlh ZmQ1OGM2ZDAwYWI1Y2YwYjMzZTA1NDcuLjA5YjViYzAxZDBiN2Y5YjIzYTgyOGFhMWU5MDI1ZDRm ZTJiNDMyZjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRC dWZmZXJNYWMubW0KKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZl ck1hYy5tbQpAQCAtMTIyLDEyICsxMjIsNCBAQCBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBTaGFyZWRC dWZmZXI6OmNyZWF0ZUNGRGF0YSgpCiAgICAgcmV0dXJuIGFkb3B0Q0YoKENGRGF0YVJlZilhZG9w dE5TKFtbV2ViQ29yZVNoYXJlZEJ1ZmZlckRhdGEgYWxsb2NdIGluaXRXaXRoU2hhcmVkQnVmZmVy RGF0YUJ1ZmZlcjptX2J1ZmZlci5nZXQoKV0pLmxlYWtSZWYoKSk7CiB9CiAKLVBhc3NSZWZQdHI8 U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25z dCBTdHJpbmcmIGZpbGVQYXRoKQotewotICAgIE5TRGF0YSAqcmVzb3VyY2VEYXRhID0gW05TRGF0 YSBkYXRhV2l0aENvbnRlbnRzT2ZGaWxlOmZpbGVQYXRoXTsKLSAgICBpZiAocmVzb3VyY2VEYXRh KSAKLSAgICAgICAgcmV0dXJuIFNoYXJlZEJ1ZmZlcjo6d3JhcE5TRGF0YShyZXNvdXJjZURhdGEp OwotICAgIHJldHVybiAwOwotfQotCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9wb3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9wb3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IGU3N2I4ZWNmMDZmOWJjOWMwZTVmZmExYmRhMDdkODYyMTQyODViZDQuLjAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCisrKyAvZGV2L251bGwKQEAgLTEsNzIgKzAs MCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMCBDb21wYW55IDEwMCwgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0 OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UgotICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElO Qy4gT1IKLSAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLAotICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAotICogUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkgVEhFT1JZCi0gKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwot Ci0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCi0KLSNpbmNs dWRlICJGaWxlU3lzdGVtLmgiCi0KLSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUgPHN5cy9z dGF0Lmg+Ci0jaW5jbHVkZSA8dW5pc3RkLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5o PgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFy ZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRo KQotewotICAgIGlmIChmaWxlUGF0aC5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVybiAwOwotCi0g ICAgQ1N0cmluZyBmaWxlbmFtZSA9IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0aCk7 Ci0gICAgaW50IGZkID0gb3BlbihmaWxlbmFtZS5kYXRhKCksIE9fUkRPTkxZKTsKLSAgICBpZiAo ZmQgPT0gLTEpCi0gICAgICAgIHJldHVybiAwOwotCi0gICAgc3RydWN0IHN0YXQgZmlsZVN0YXQ7 Ci0gICAgaWYgKGZzdGF0KGZkLCAmZmlsZVN0YXQpKSB7Ci0gICAgICAgIGNsb3NlKGZkKTsKLSAg ICAgICAgcmV0dXJuIDA7Ci0gICAgfQotCi0gICAgc2l6ZV90IGJ5dGVzVG9SZWFkID0gZmlsZVN0 YXQuc3Rfc2l6ZTsKLSAgICBpZiAoZmlsZVN0YXQuc3Rfc2l6ZSA8IDAgfHwgYnl0ZXNUb1JlYWQg IT0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgbG9uZyBsb25nPihmaWxlU3RhdC5zdF9zaXplKSkgewot ICAgICAgICBjbG9zZShmZCk7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIFZlY3Rv cjxjaGFyPiBidWZmZXIoYnl0ZXNUb1JlYWQpOwotCi0gICAgc2l6ZV90IHRvdGFsQnl0ZXNSZWFk ID0gMDsKLSAgICBzc2l6ZV90IGJ5dGVzUmVhZDsKLSAgICB3aGlsZSAoKGJ5dGVzUmVhZCA9IHJl YWQoZmQsIGJ1ZmZlci5kYXRhKCkgKyB0b3RhbEJ5dGVzUmVhZCwgYnl0ZXNUb1JlYWQgLSB0b3Rh bEJ5dGVzUmVhZCkpID4gMCkKLSAgICAgICAgdG90YWxCeXRlc1JlYWQgKz0gYnl0ZXNSZWFkOwot Ci0gICAgY2xvc2UoZmQpOwotCi0gICAgcmV0dXJuIHRvdGFsQnl0ZXNSZWFkID09IGJ5dGVzVG9S ZWFkID8gU2hhcmVkQnVmZmVyOjphZG9wdFZlY3RvcihidWZmZXIpIDogMDsKLX0KLQotfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2lu L0ZpbGVTeXN0ZW1XaW4uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL0ZpbGVTeXN0 ZW1XaW4uY3BwCmluZGV4IGIyZGQ4ZGUyNWY1ODRmNWRiOTlhNTA1NzFiMzU3ZGRkZjgwNTRlMWUu LmMxNTdkYmUwODc4MTU3MTljN2MyZWUyMjRkMzM2M2MxOGE4YTRmZTAgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9GaWxlU3lzdGVtV2luLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS93aW4vRmlsZVN5c3RlbVdpbi5jcHAKQEAgLTQ0Miw0ICs0NDIsMjQg QEAgVmVjdG9yPFN0cmluZz4gbGlzdERpcmVjdG9yeShjb25zdCBTdHJpbmcmIGRpcmVjdG9yeSwg Y29uc3QgU3RyaW5nJiBmaWx0ZXIpCiAgICAgcmV0dXJuIGVudHJpZXM7CiB9CiAKKy8vIEZJWE1F OiBJbXBsZW1lbnQgTWFwcGVkRmlsZURhdGEKK1JlZlB0cjxNYXBwZWRGaWxlRGF0YT4gTWFwcGVk RmlsZURhdGE6OmNyZWF0ZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQoreworICAgIHJldHVybiBu dWxscHRyOworfQorCit2b2lkIE1hcHBlZEZpbGVEYXRhOjpjbGVhcigpCit7Cit9CisKK2NvbnN0 IHZvaWQqIE1hcHBlZEZpbGVEYXRhOjpkYXRhKCkKK3sKKyAgICByZXR1cm4gbnVsbHB0cjsKK30K KwordW5zaWduZWQgTWFwcGVkRmlsZURhdGE6OnNpemUoKQoreworICAgIHJldHVybiAwOworfQor CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dp bi9TaGFyZWRCdWZmZXJXaW4uY3BwCmluZGV4IGY1ZGQyMjg0NjQxOWEwZjJkOTc4NWI5YTY5Y2Rm OTA5YmMzOTFkNzAuLjYwNTQ2NzEzNDI3ZWVkZGE2YjFiNWNmNGYwYmNkNjhhM2MzNTBkZDIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwCkBA IC0zMyw4ICszMyw5IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxTaGFy ZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0 cmluZyYgZmlsZVBhdGgpCitSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0 ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQogeworICAgIC8vIEZJ WE1FOiBVc2UgbWFwIGZpbGUgcm91dGluZXMuCiAgICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkK ICAgICAgICAgcmV0dXJuIDA7CiAK 252058 2015-04-30 08:06:07 -0700 2015-05-04 12:17:27 -0700 Using std::unique_ptr and adding unit tests bug-144192-20150430170455.patch text/plain 38225 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTgzNTM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2VhMDIyMjAyYmY4OGQx OTg5ZmYzM2UxY2JlMjM5YzkwNzY5MGEzNi4uMjFlMzMxMjY4YThiYjFiMGVhNThmNzAxMGYzMmQw NjA4MzgxNWNlYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUzIEBACisyMDE1LTA0LTMwICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIEZpbGUgY29u dGVudCBpcyBtYXBwZWQgdW50aWwgU2hhcmVkQnVmZmVyIGlzIGNsZWFyZWQsIGRlc3Ryb3llZCBv ciBhZGRpdGlvbmFsIGNvbnRlbnQgaXMgYXBwZW5kZWQgdG8gdGhlIFNoYXJlZEJ1ZmZlci4KKyAg ICAgICAgUmVtb3ZlZCBFRkwsIE1hYyBhbmQgR1RLIHNwZWNpZmljIHZlcnNpb25zIG9mIFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorCisgICAgICAgIEEgaGVscGVyIGNs YXNzLCBNYXBwZWRGaWxlRGF0YSwgaXMgaW50cm9kdWNlZCB0aGUgaGFuZGxpbmcgb2YgbWFwcGVk IGZpbGVzIHRocm91Z2ggY2FsbHMgdG8gb3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAg ICBQYXRjaCBjb3ZlcmVkIGJ5IGV4aXN0aW5nIGxheW91dCB0ZXN0cyBhbmQgYWRkZWQgdW5pdCB0 ZXN0cy4KKworICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtlOgorICAgICAgICAqIFBsYXRmb3Jt R1RLLmNtYWtlOgorICAgICAgICAqIFBsYXRmb3JtTWFjLmNtYWtlOgorICAgICAgICAqIHBsYXRm b3JtL0ZpbGVTeXN0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OmNy ZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpNYXBwZWRGaWxlRGF0YTo6TWFwcGVkRmlsZURhdGEp OgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0YSk6Cisg ICAgICAgIChXZWJDb3JlOjpjYW5FeGNsdWRlRnJvbUJhY2t1cCk6IERlbGV0ZWQuCisgICAgICAg ICogcGxhdGZvcm0vRmlsZVN5c3RlbS5oOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURh dGE6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OnNpemUpOgorICAg ICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFy ZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6 OnNpemUpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpkYXRhKToKKyAgICAgICAg KFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YXBwZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJl ZEJ1ZmZlcjo6Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjb3B5KToK KyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEpOgorICAgICAgICAo V2ViQ29yZTo6U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEpOgorICAg ICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOgor ICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjp+U2hhcmVkQnVmZmVyKTogRGVsZXRlZC4K KyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YWRvcHRWZWN0b3IpOiBEZWxldGVkLgor ICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjb3B5QnVmZmVyQW5kQ2xlYXIpOiBEZWxl dGVkLgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAgICAoV2ViQ29y ZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGUpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9TaGFyZWRCdWZmZXJHdGsuY3BwOiBSZW1vdmVkLgorICAgICAgICAqIHBsYXRmb3JtL21hYy9T aGFyZWRCdWZmZXJNYWMubW06CisgICAgICAgICogcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVy UE9TSVguY3BwOiBSZW1vdmVkLgorICAgICAgICAqIHBsYXRmb3JtL3dpbi9GaWxlU3lzdGVtV2lu LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpjcmVhdGUpOgorICAgICAg ICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0YSk6CisgICAgICAgICog cGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFy ZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSk6CisKIDIwMTUtMDQtMjkgIEh5dW5n d29vayBMZWUgIDxoeXVuZ3dvb2subGVlQG5hdmVyY29ycC5jb20+CiAKICAgICAgICAgRml4IGNy YXNoIGluIFdlYkNvcmU6OkxvZ2ljYWxTZWxlY3Rpb25PZmZzZXRDYWNoZXM6OkNvbnRhaW5pbmdC bG9ja0luZm86OnNldEJsb2NrKCkuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9y bUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCmluZGV4IDBiOTE0 OTk5MTkyZTU1M2EyYTIyNWVkNTBlYmIyMjBjOWQ1ODAxYzYuLmI4NGE5M2I3MGI2N2RiM2YzYWE0 M2IxOWZiNGE3MzMyZWE4OThmZDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3Jt RWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC0yMzks NyArMjM5LDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0vbmV0 d29yay9zb3VwL1N5bmNocm9ub3VzTG9hZGVyQ2xpZW50U291cC5jcHAKIAogICAgIHBsYXRmb3Jt L3Bvc2l4L0ZpbGVTeXN0ZW1QT1NJWC5jcHAKLSAgICBwbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZm ZXJQT1NJWC5jcHAKIAogICAgIHBsYXRmb3JtL3NvdXAvU2hhcmVkQnVmZmVyU291cC5jcHAKICAg ICBwbGF0Zm9ybS9zb3VwL1VSTFNvdXAuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q bGF0Zm9ybUdUSy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4 IGYzMDZhOWIzNDEwMGIzNTZmOWRkYjc0ZGM2ZTYzZGQyNWYxNWVjZTQuLjg3ZDk5OWE4YTI1NTM0 M2Q1NjgwODFmMjI1MDA5MjJjOTA1ZWM3YWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1Bs YXRmb3JtR1RLLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCkBA IC0xMjQsNyArMTI0LDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZv cm0vZ3RrL0xhbmd1YWdlR3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9Mb2dnaW5nR3RrLmNwcAog ICAgIHBsYXRmb3JtL2d0ay9NSU1FVHlwZVJlZ2lzdHJ5R3RrLmNwcAotICAgIHBsYXRmb3JtL2d0 ay9TaGFyZWRCdWZmZXJHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL1NoYXJlZFRpbWVyR3RrLmNw cAogICAgIHBsYXRmb3JtL2d0ay9UZW1wb3JhcnlMaW5rU3R1YnMuY3BwCiAgICAgcGxhdGZvcm0v Z3RrL1VzZXJBZ2VudEd0ay5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3Jt TWFjLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1NYWMuY21ha2UKaW5kZXggMDU0YWE1 NDA4N2UzYzUzMTk4YzFlOGY1NTY4NmFiOTllMzUxZjJmNy4uZWNiZTc5NWMyNGVhODBlMmExYjJi NDU5YzYyMjdkN2NiYTk1NjQwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1N YWMuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1NYWMuY21ha2UKQEAgLTM0OSw3 ICszNDksNiBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKICAgICBwbGF0Zm9ybS9uZXR3 b3JrL21hYy9XZWJDb3JlVVJMUmVzcG9uc2UubW0KIAogICAgIHBsYXRmb3JtL3Bvc2l4L0ZpbGVT eXN0ZW1QT1NJWC5jcHAKLSAgICBwbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAK IAogICAgIHBsYXRmb3JtL3RleHQvY2YvSHlwaGVuYXRpb25DRi5jcHAKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9GaWxlU3lzdGVtLmNwcAppbmRleCA5N2I4NDZlZWNjNGM2MzBkZGJhMDZkNGM1N2Qz NjE3NjhkOGVjZmRmLi5mN2ZjMzc4NmY3ZDk1ZDJjZTEyYjUzMDgxNGNhMDk5MjFkYTBkYzE4IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8q CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMTEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjcsOCArMjgsMTYgQEAKICNp bmNsdWRlICJGaWxlU3lzdGVtLmgiCiAKICNpbmNsdWRlIDx3dGYvSGV4TnVtYmVyLmg+CisjaW5j bHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxk ZXIuaD4KIAorI2lmICFQTEFURk9STShXSU4pCisjaW5jbHVkZSA8ZmNudGwuaD4KKyNpbmNsdWRl IDxzeXMvbW1hbi5oPgorI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+ CisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAvLyBUaGUgZm9sbG93aW5nIGxvd2Vy LUFTQ0lJIGNoYXJhY3RlcnMgbmVlZCBlc2NhcGluZyB0byBiZSB1c2VkIGluIGEgZmlsZW5hbWUK QEAgLTExMyw0ICsxMjIsNTEgQEAgYm9vbCBleGNsdWRlRnJvbUJhY2t1cChjb25zdCBTdHJpbmcm KQogCiAjZW5kaWYKIAorI2lmICFQTEFURk9STShXSU4pCisKK3N0ZDo6dW5pcXVlX3B0cjxNYXBw ZWRGaWxlRGF0YT4gTWFwcGVkRmlsZURhdGE6OmNyZWF0ZShjb25zdCBTdHJpbmcmIGZpbGVQYXRo KQoreworICAgIGludCBmZCA9IG9wZW4oZmlsZVN5c3RlbVJlcHJlc2VudGF0aW9uKGZpbGVQYXRo KS5kYXRhKCksIE9fUkRPTkxZKTsKKyAgICBpZiAoZmQgPCAwKQorICAgICAgICByZXR1cm4gbnVs bHB0cjsKKworICAgIHN0cnVjdCBzdGF0IGZpbGVTdGF0OworICAgIGlmIChmc3RhdChmZCwgJmZp bGVTdGF0KSkgeworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHJldHVybiBudWxscHRyOwor ICAgIH0KKworICAgIGlmIChmaWxlU3RhdC5zdF9zaXplIDwgMCB8fCBmaWxlU3RhdC5zdF9zaXpl ID4gSU5UX01BWCkgeworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHJldHVybiBudWxscHRy OworICAgIH0KKworICAgIHVuc2lnbmVkIHNpemUgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZD4oZmls ZVN0YXQuc3Rfc2l6ZSk7CisKKyAgICBpZiAoIXNpemUpCisgICAgICAgIHJldHVybiBzdGQ6OnVu aXF1ZV9wdHI8TWFwcGVkRmlsZURhdGE+KG5ldyBNYXBwZWRGaWxlRGF0YShudWxscHRyLCAwKSk7 CisKKyAgICB2b2lkKiBkYXRhID0gbW1hcCgwLCBzaXplLCBQUk9UX1JFQUQsIE1BUF9GSUxFIHwg TUFQX1NIQVJFRCwgZmQsIDApOworICAgIGNsb3NlKGZkKTsKKworICAgIGlmIChkYXRhID09IE1B UF9GQUlMRUQpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgcmV0dXJuIHN0ZDo6dW5p cXVlX3B0cjxNYXBwZWRGaWxlRGF0YT4obmV3IE1hcHBlZEZpbGVEYXRhKGRhdGEsIHNpemUpKTsK K30KKworTWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKHZvaWQqIGZpbGVEYXRhLCB1bnNp Z25lZCBmaWxlU2l6ZSkKKyAgICA6IG1fZmlsZURhdGEoZmlsZURhdGEpCisgICAgLCBtX2ZpbGVT aXplKGZpbGVTaXplKQoreworfQorCitNYXBwZWRGaWxlRGF0YTo6fk1hcHBlZEZpbGVEYXRhKCkK K3sKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAgbXVubWFwKG1fZmlsZURhdGEsIG1fZmls ZVNpemUpOworfQorCisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vRmlsZVN5c3RlbS5oCmluZGV4IGY1YzNhMmNmOGYxNjQ0M2ZmMTJlNmQ1Yzc3YTY3 NzE1YzhlMjNiNGMuLjM1NzljODZmYjZjZDVkNGUyMTQyYjg2NmQ2MzNmODkwMTk0Yzg5NjYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmgKQEAgLTMyLDYgKzMyLDcgQEAKIAogI2lu Y2x1ZGUgPHRpbWUuaD4KICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9S ZWZDb3VudGVkLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0 L1dURlN0cmluZy5oPgogCkBAIC0yMDQsNiArMjA1LDI0IEBAIFdFQkNPUkVfRVhQT1JUIFN0cmlu ZyBsb2NhbFVzZXJTcGVjaWZpY1N0b3JhZ2VEaXJlY3RvcnkoKTsKIFN0cmluZyByb2FtaW5nVXNl clNwZWNpZmljU3RvcmFnZURpcmVjdG9yeSgpOwogI2VuZGlmCiAKK2NsYXNzIE1hcHBlZEZpbGVE YXRhIHsKK3B1YmxpYzoKKyAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgc3RkOjp1bmlxdWVfcHRy PE1hcHBlZEZpbGVEYXRhPiBjcmVhdGUoY29uc3QgU3RyaW5nJik7CisKKyAgICBXRUJDT1JFX0VY UE9SVCB+TWFwcGVkRmlsZURhdGEoKTsKKworICAgIGNvbnN0IHZvaWQqIGRhdGEoKSBjb25zdCB7 IHJldHVybiBtX2ZpbGVEYXRhOyB9CisgICAgdW5zaWduZWQgc2l6ZSgpIGNvbnN0IHsgcmV0dXJu IG1fZmlsZVNpemU7IH0KKworcHJpdmF0ZToKKyNpZiAhUExBVEZPUk0oV0lOKQorICAgIE1hcHBl ZEZpbGVEYXRhKHZvaWQqLCB1bnNpZ25lZCk7CisjZW5kaWYKKworICAgIHZvaWQqIG1fZmlsZURh dGEgeyBudWxscHRyIH07CisgICAgdW5zaWduZWQgbV9maWxlU2l6ZSB7IDAgfTsKK307CisKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEZpbGVTeXN0ZW1faApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKaW5kZXggYWZiYjY1MzFmZDcxNGI4NjdhZmQ2 ZDJmZjEyN2NlOTk2NmUwZGViOS4uYjZiMDQzNTEwNGU2Y2Y3NzFkMmMzMmEyZjFkNGQ0YmExZmJl YTY5NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0xLDYg KzEsNyBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNiwgMjAwOCBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCiAgKiBDb3B5cmlnaHQgKEMpIFJlc2VhcmNoIEluIE1vdGlvbiBMaW1p dGVkIDIwMDktMjAxMC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAx NSBDYW5vbiBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKQEAgLTMwLDYgKzMxLDE0IEBACiAjaW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1 ZGUgPHd0Zi91bmljb2RlL1VURjguaD4KIAorI2lmICFQTEFURk9STShXSU4pCisjaW5jbHVkZSAi RmlsZVN5c3RlbS5oIgorI2luY2x1ZGUgPGZjbnRsLmg+CisjaW5jbHVkZSA8c3lzL21tYW4uaD4K KyNpbmNsdWRlIDxzeXMvc3RhdC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKyNl bmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICNpZiAhVVNFKE5FVFdPUktfQ0ZEQVRBX0FS UkFZX0NBTExCQUNLKQpAQCAtODUsNyArOTQsMTQgQEAgU2hhcmVkQnVmZmVyOjpTaGFyZWRCdWZm ZXIoY29uc3QgdW5zaWduZWQgY2hhciogZGF0YSwgdW5zaWduZWQgc2l6ZSkKIHsKICAgICBhcHBl bmQocmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4oZGF0YSksIHNpemUpOwogfQotICAgIAor CitTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcihzdGQ6OnVuaXF1ZV9wdHI8TWFwcGVkRmlsZURh dGE+JiYgZmlsZURhdGEpCisgICAgOiBtX3NpemUoMCkKKyAgICAsIG1fYnVmZmVyKGFkb3B0UmVm KG5ldyBEYXRhQnVmZmVyKSkKKyAgICAsIG1fZmlsZURhdGEoV1RGOjptb3ZlKGZpbGVEYXRhKSkK K3sKK30KKwogU2hhcmVkQnVmZmVyOjp+U2hhcmVkQnVmZmVyKCkKIHsKICAgICBjbGVhcigpOwpA QCAtMTA0LDE1ICsxMjAsMjAgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpzaXplKCkgY29uc3QK ICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0Zm9ybURhdGFT aXplKCk7CiAgICAgCisgICAgaWYgKG1fZmlsZURhdGEpCisgICAgICAgIHJldHVybiBtX2ZpbGVE YXRhLT5zaXplKCk7CisKICAgICByZXR1cm4gbV9zaXplOwogfQogCiBjb25zdCBjaGFyKiBTaGFy ZWRCdWZmZXI6OmRhdGEoKSBjb25zdAogewotCiAgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKQog ICAgICAgICByZXR1cm4gcGxhdGZvcm1EYXRhKCk7CiAKKyAgICBpZiAobV9maWxlRGF0YSkKKyAg ICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihtX2ZpbGVEYXRhLT5kYXRhKCkp OworCiAjaWYgVVNFKE5FVFdPUktfQ0ZEQVRBX0FSUkFZX0NBTExCQUNLKQogICAgIGlmIChjb25z dCBjaGFyKiBidWZmZXIgPSBzaW5nbGVEYXRhQXJyYXlCdWZmZXIoKSkKICAgICAgICAgcmV0dXJu IGJ1ZmZlcjsKQEAgLTE2Myw2ICsxODQsNyBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6YXBwZW5kKGNv bnN0IGNoYXIqIGRhdGEsIHVuc2lnbmVkIGxlbmd0aCkKICAgICBpZiAoIWxlbmd0aCkKICAgICAg ICAgcmV0dXJuOwogCisgICAgbWF5YmVUcmFuc2Zlck1hcHBlZEZpbGVEYXRhKCk7CiAgICAgbWF5 YmVUcmFuc2ZlclBsYXRmb3JtRGF0YSgpOwogCiAjaWYgIVVTRShORVRXT1JLX0NGREFUQV9BUlJB WV9DQUxMQkFDSykKQEAgLTIxMyw2ICsyMzUsOSBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6YXBwZW5k KGNvbnN0IFZlY3RvcjxjaGFyPiYgZGF0YSkKIAogdm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyKCkK IHsKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAgbV9maWxlRGF0YS5yZXNldCgpOworCiAg ICAgY2xlYXJQbGF0Zm9ybURhdGEoKTsKICAgICAKICNpZiAhVVNFKE5FVFdPUktfQ0ZEQVRBX0FS UkFZX0NBTExCQUNLKQpAQCAtMjMwLDcgKzI1NSw4IEBAIHZvaWQgU2hhcmVkQnVmZmVyOjpjbGVh cigpCiBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjb3B5KCkgY29uc3QK IHsKICAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBjbG9uZSB7IGFkb3B0UmVmKCpuZXcgU2hhcmVk QnVmZmVyKSB9OwotICAgIGlmIChoYXNQbGF0Zm9ybURhdGEoKSkgeworCisgICAgaWYgKGhhc1Bs YXRmb3JtRGF0YSgpIHx8IG1fZmlsZURhdGEpIHsKICAgICAgICAgY2xvbmUtPmFwcGVuZChkYXRh KCksIHNpemUoKSk7CiAgICAgICAgIHJldHVybiBjbG9uZS5yZWxlYXNlKCk7CiAgICAgfQpAQCAt MzEzLDcgKzMzOSw3IEBAIHVuc2lnbmVkIFNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEoY29uc3Qg Y2hhciomIHNvbWVEYXRhLCB1bnNpZ25lZCBwb3NpdGlvbikgY29uCiAgICAgICAgIHJldHVybiAw OwogICAgIH0KIAotICAgIGlmIChoYXNQbGF0Zm9ybURhdGEoKSkgeworICAgIGlmIChoYXNQbGF0 Zm9ybURhdGEoKSB8fCBtX2ZpbGVEYXRhKSB7CiAgICAgICAgIEFTU0VSVF9XSVRIX1NFQ1VSSVRZ X0lNUExJQ0FUSU9OKHBvc2l0aW9uIDwgc2l6ZSgpKTsKICAgICAgICAgc29tZURhdGEgPSBkYXRh KCkgKyBwb3NpdGlvbjsKICAgICAgICAgcmV0dXJuIHRvdGFsU2l6ZSAtIHBvc2l0aW9uOwpAQCAt MzQ2LDYgKzM3MiwyMiBAQCB1bnNpZ25lZCBTaGFyZWRCdWZmZXI6OmdldFNvbWVEYXRhKGNvbnN0 IGNoYXIqJiBzb21lRGF0YSwgdW5zaWduZWQgcG9zaXRpb24pIGNvbgogI2VuZGlmCiB9CiAKK3Zv aWQgU2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEoKQoreworICAgIGlm IChtX2ZpbGVEYXRhKSB7CisgICAgICAgIGF1dG8gZmlsZURhdGEgPSBXVEY6Om1vdmUobV9maWxl RGF0YSk7CisgICAgICAgIGFwcGVuZChzdGF0aWNfY2FzdDxjb25zdCBjaGFyKj4oZmlsZURhdGEt PmRhdGEoKSksIGZpbGVEYXRhLT5zaXplKCkpOworICAgIH0KK30KKworUmVmUHRyPFNoYXJlZEJ1 ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5n JiBmaWxlUGF0aCkKK3sKKyAgICBzdGQ6OnVuaXF1ZV9wdHI8TWFwcGVkRmlsZURhdGE+IG1hcHBl ZEZpbGVEYXRhID0gTWFwcGVkRmlsZURhdGE6OmNyZWF0ZShmaWxlUGF0aCk7CisgICAgaWYgKCFt YXBwZWRGaWxlRGF0YSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgcmV0dXJuIGFkb3B0 UmVmKG5ldyBTaGFyZWRCdWZmZXIoV1RGOjptb3ZlKG1hcHBlZEZpbGVEYXRhKSkpOworfQorCiAj aWYgIVVTRShDRikgJiYgIVVTRShTT1VQKQogCiBpbmxpbmUgdm9pZCBTaGFyZWRCdWZmZXI6OmNs ZWFyUGxhdGZvcm1EYXRhKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1No YXJlZEJ1ZmZlci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKaW5k ZXggYmNmMzU1M2VkNjBlY2Y5ZTEwOGI5MmFmNTcxMTQxMTcwODAzNWVhMS4uNTNiMWRjMzJhOTlj ZmMyZTUxM2QwNDM0OGRhNTQxN2Y1ZjJlOTM0NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hh cmVkQnVmZmVyLmgKQEAgLTI3LDYgKzI3LDcgQEAKICNpZm5kZWYgU2hhcmVkQnVmZmVyX2gKICNk ZWZpbmUgU2hhcmVkQnVmZmVyX2gKIAorI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKICNpbmNsdWRl IDxydW50aW1lL0FycmF5QnVmZmVyLmg+CiAjaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KICNpbmNs dWRlIDx3dGYvUmVmQ291bnRlZC5oPgpAQCAtNTUsNyArNTYsNyBAQCBwdWJsaWM6CiAgICAgc3Rh dGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGUoY29uc3QgY2hhciogYywgdW5zaWdu ZWQgaSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihjLCBpKSk7IH0KICAgICBz dGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGNyZWF0ZShjb25zdCB1bnNpZ25lZCBjaGFy KiBjLCB1bnNpZ25lZCBpKSB7IHJldHVybiBhZG9wdFJlZihuZXcgU2hhcmVkQnVmZmVyKGMsIGkp KTsgfQogCi0gICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVy PiBjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCk7CisgICAg V0VCQ09SRV9FWFBPUlQgc3RhdGljIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNyZWF0ZVdpdGhDb250 ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKTsKIAogICAgIFdFQkNPUkVfRVhQT1JU IHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYWRvcHRWZWN0b3IoVmVjdG9yPGNoYXI+ JiB2ZWN0b3IpOwogICAgIApAQCAtOTIsNyArOTMsNyBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9F WFBPUlQgdm9pZCBhcHBlbmQoY29uc3QgY2hhciosIHVuc2lnbmVkKTsKICAgICB2b2lkIGFwcGVu ZChjb25zdCBWZWN0b3I8Y2hhcj4mKTsKIAotICAgIHZvaWQgY2xlYXIoKTsKKyAgICBXRUJDT1JF X0VYUE9SVCB2b2lkIGNsZWFyKCk7CiAgICAgY29uc3QgY2hhciogcGxhdGZvcm1EYXRhKCkgY29u c3Q7CiAgICAgdW5zaWduZWQgcGxhdGZvcm1EYXRhU2l6ZSgpIGNvbnN0OwogCkBAIC0xMDEsNyAr MTAyLDcgQEAgcHVibGljOgogICAgIHZvaWQgYXBwZW5kKENGRGF0YVJlZik7CiAjZW5kaWYKIAot ICAgIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjb3B5KCkgY29uc3Q7CisgICAgV0VCQ09SRV9F WFBPUlQgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGNvcHkoKSBjb25zdDsKICAgICAKICAgICAv LyBSZXR1cm4gdGhlIG51bWJlciBvZiBjb25zZWN1dGl2ZSBieXRlcyBhZnRlciAicG9zaXRpb24i LiAiZGF0YSIKICAgICAvLyBwb2ludHMgdG8gdGhlIGZpcnN0IGJ5dGUuCkBAIC0xMjksNyArMTMw LDggQEAgcHJpdmF0ZToKICAgICBleHBsaWNpdCBTaGFyZWRCdWZmZXIodW5zaWduZWQpOwogICAg IFdFQkNPUkVfRVhQT1JUIFNoYXJlZEJ1ZmZlcihjb25zdCBjaGFyKiwgdW5zaWduZWQpOwogICAg IFdFQkNPUkVfRVhQT1JUIFNoYXJlZEJ1ZmZlcihjb25zdCB1bnNpZ25lZCBjaGFyKiwgdW5zaWdu ZWQpOwotICAgIAorICAgIFNoYXJlZEJ1ZmZlcihzdGQ6OnVuaXF1ZV9wdHI8TWFwcGVkRmlsZURh dGE+JiYpOworCiAgICAgLy8gQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIHdpbGwgZm9yY2UgaW50ZXJu YWwgc2VnbWVudGVkIGJ1ZmZlcnMKICAgICAvLyB0byBiZSBtZXJnZWQgaW50byBhIGZsYXQgYnVm ZmVyLiBVc2UgZ2V0U29tZURhdGEoKSB3aGVuZXZlciBwb3NzaWJsZQogICAgIC8vIGZvciBiZXR0 ZXIgcGVyZm9ybWFuY2UuCkBAIC0xMzksNiArMTQxLDggQEAgcHJpdmF0ZToKICAgICB2b2lkIG1h eWJlVHJhbnNmZXJQbGF0Zm9ybURhdGEoKTsKICAgICBib29sIG1heWJlQXBwZW5kUGxhdGZvcm1E YXRhKFNoYXJlZEJ1ZmZlciopOwogCisgICAgdm9pZCBtYXliZVRyYW5zZmVyTWFwcGVkRmlsZURh dGEoKTsKKwogICAgIHZvaWQgY29weUJ1ZmZlckFuZENsZWFyKGNoYXIqIGRlc3RpbmF0aW9uLCB1 bnNpZ25lZCBieXRlc1RvQ29weSkgY29uc3Q7CiAKICAgICB2b2lkIGFwcGVuZFRvRGF0YUJ1ZmZl cihjb25zdCBjaGFyICosIHVuc2lnbmVkKSBjb25zdDsKQEAgLTE2Nyw2ICsxNzEsOCBAQCBwcml2 YXRlOgogICAgIGV4cGxpY2l0IFNoYXJlZEJ1ZmZlcihTb3VwQnVmZmVyKik7CiAgICAgR1VuaXF1 ZVB0cjxTb3VwQnVmZmVyPiBtX3NvdXBCdWZmZXI7CiAjZW5kaWYKKworICAgIHN0ZDo6dW5pcXVl X3B0cjxNYXBwZWRGaWxlRGF0YT4gbV9maWxlRGF0YTsKIH07CiAKIFBhc3NSZWZQdHI8U2hhcmVk QnVmZmVyPiB1dGY4QnVmZmVyKGNvbnN0IFN0cmluZyYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ndGsvU2hhcmVkQnVmZmVyR3RrLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggZWQ4ZGU0NzE2NDNkMzAwNjI1NzZkOWQyMDA4NGQ0YTU3ZjFkZWUxMy4uMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvU2hhcmVkQnVmZmVyR3RrLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDUwICswLDAg QEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDggQ29sbGFib3JhIEx0ZC4KLSAqCi0gKiAgVGhp cyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v cgotICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJh bCBQdWJsaWMKLSAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uOyBlaXRoZXIKLSAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m Ci0gKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKLSAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCi0gKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQotICogIEZvdW5kYXRp b24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAy MTEwLTEzMDEgIFVTQQotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJTaGFy ZWRCdWZmZXIuaCIKLQotI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKLSNpbmNsdWRlIDx3dGYvZ29i amVjdC9HVW5pcXVlUHRyLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgotCi0jaW5j bHVkZSA8Z2xpYi5oPgotCi0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotUGFzc1JlZlB0cjxTaGFy ZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0 cmluZyYgZmlsZVBhdGgpCi17Ci0gICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKLSAgICAgICAg cmV0dXJuIDA7Ci0KLSAgICBDU3RyaW5nIGZpbGVuYW1lID0gZmlsZVN5c3RlbVJlcHJlc2VudGF0 aW9uKGZpbGVQYXRoKTsKLSAgICBHVW5pcXVlT3V0UHRyPGdjaGFyPiBjb250ZW50czsKLSAgICBn c2l6ZSBzaXplOwotICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKLSAgICBpZiAoIWdf ZmlsZV9nZXRfY29udGVudHMoZmlsZW5hbWUuZGF0YSgpLCAmY29udGVudHMub3V0UHRyKCksICZz aXplLCAmZXJyb3Iub3V0UHRyKCkpKSB7Ci0gICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRvIGZ1 bGx5IHJlYWQgY29udGVudHMgb2YgZmlsZSAlcyAtICVzIiwgZmlsZW5hbWVGb3JEaXNwbGF5KGZp bGVQYXRoKS51dGY4KCkuZGF0YSgpLCBlcnJvci0+bWVzc2FnZSk7Ci0gICAgICAgIHJldHVybiAw OwotICAgIH0KLQotICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IHJlc3VsdCA9IFNoYXJlZEJ1ZmZl cjo6Y3JlYXRlKGNvbnRlbnRzLmdldCgpLCBzaXplKTsKLQotICAgIHJldHVybiByZXN1bHQucmVs ZWFzZSgpOwotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1tIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1hYy5tbQppbmRleCBlYTQ4MmYwNmYwODE2OGE5YWZk NThjNmQwMGFiNWNmMGIzM2UwNTQ3Li4wOWI1YmMwMWQwYjdmOWIyM2E4MjhhYTFlOTAyNWQ0ZmUy YjQzMmY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVm ZmVyTWFjLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJN YWMubW0KQEAgLTEyMiwxMiArMTIyLDQgQEAgUmV0YWluUHRyPENGRGF0YVJlZj4gU2hhcmVkQnVm ZmVyOjpjcmVhdGVDRkRhdGEoKQogICAgIHJldHVybiBhZG9wdENGKChDRkRhdGFSZWYpYWRvcHRO UyhbW1dlYkNvcmVTaGFyZWRCdWZmZXJEYXRhIGFsbG9jXSBpbml0V2l0aFNoYXJlZEJ1ZmZlckRh dGFCdWZmZXI6bV9idWZmZXIuZ2V0KCldKS5sZWFrUmVmKCkpOwogfQogCi1QYXNzUmVmUHRyPFNo YXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3Qg U3RyaW5nJiBmaWxlUGF0aCkKLXsKLSAgICBOU0RhdGEgKnJlc291cmNlRGF0YSA9IFtOU0RhdGEg ZGF0YVdpdGhDb250ZW50c09mRmlsZTpmaWxlUGF0aF07Ci0gICAgaWYgKHJlc291cmNlRGF0YSkg Ci0gICAgICAgIHJldHVybiBTaGFyZWRCdWZmZXI6OndyYXBOU0RhdGEocmVzb3VyY2VEYXRhKTsK LSAgICByZXR1cm4gMDsKLX0KLQogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v cG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCBlNzdiOGVjZjA2ZjliYzljMGU1ZmZhMWJkYTA3ZDg2MjE0Mjg1YmQ0Li4wMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L3Bvc2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDcyICswLDAg QEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTAgQ29tcGFueSAxMDAsIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoK LSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQotICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCi0gKiBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK LSAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMu IE9SCi0gKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwgU1BFQ0lBTCwKLSAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKLSAqIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgotICogUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z IFRIRU9SWQotICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKLSAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQot I2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgotCi0jaW5jbHVk ZSAiRmlsZVN5c3RlbS5oIgotCi0jaW5jbHVkZSA8ZmNudGwuaD4KLSNpbmNsdWRlIDxzeXMvc3Rh dC5oPgotI2luY2x1ZGUgPHVuaXN0ZC5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4K LQotbmFtZXNwYWNlIFdlYkNvcmUgewotCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkK LXsKLSAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQotICAgICAgICByZXR1cm4gMDsKLQotICAg IENTdHJpbmcgZmlsZW5hbWUgPSBmaWxlU3lzdGVtUmVwcmVzZW50YXRpb24oZmlsZVBhdGgpOwot ICAgIGludCBmZCA9IG9wZW4oZmlsZW5hbWUuZGF0YSgpLCBPX1JET05MWSk7Ci0gICAgaWYgKGZk ID09IC0xKQotICAgICAgICByZXR1cm4gMDsKLQotICAgIHN0cnVjdCBzdGF0IGZpbGVTdGF0Owot ICAgIGlmIChmc3RhdChmZCwgJmZpbGVTdGF0KSkgewotICAgICAgICBjbG9zZShmZCk7Ci0gICAg ICAgIHJldHVybiAwOwotICAgIH0KLQotICAgIHNpemVfdCBieXRlc1RvUmVhZCA9IGZpbGVTdGF0 LnN0X3NpemU7Ci0gICAgaWYgKGZpbGVTdGF0LnN0X3NpemUgPCAwIHx8IGJ5dGVzVG9SZWFkICE9 IHN0YXRpY19jYXN0PHVuc2lnbmVkIGxvbmcgbG9uZz4oZmlsZVN0YXQuc3Rfc2l6ZSkpIHsKLSAg ICAgICAgY2xvc2UoZmQpOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0KLSAgICBWZWN0b3I8 Y2hhcj4gYnVmZmVyKGJ5dGVzVG9SZWFkKTsKLQotICAgIHNpemVfdCB0b3RhbEJ5dGVzUmVhZCA9 IDA7Ci0gICAgc3NpemVfdCBieXRlc1JlYWQ7Ci0gICAgd2hpbGUgKChieXRlc1JlYWQgPSByZWFk KGZkLCBidWZmZXIuZGF0YSgpICsgdG90YWxCeXRlc1JlYWQsIGJ5dGVzVG9SZWFkIC0gdG90YWxC eXRlc1JlYWQpKSA+IDApCi0gICAgICAgIHRvdGFsQnl0ZXNSZWFkICs9IGJ5dGVzUmVhZDsKLQot ICAgIGNsb3NlKGZkKTsKLQotICAgIHJldHVybiB0b3RhbEJ5dGVzUmVhZCA9PSBieXRlc1RvUmVh ZCA/IFNoYXJlZEJ1ZmZlcjo6YWRvcHRWZWN0b3IoYnVmZmVyKSA6IDA7Ci19Ci0KLX0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9G aWxlU3lzdGVtV2luLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9GaWxlU3lzdGVt V2luLmNwcAppbmRleCBiMmRkOGRlMjVmNTg0ZjVkYjk5YTUwNTcxYjM1N2RkZGY4MDU0ZTFlLi5h YzhhMTkyNjVhMzZjNDUzNjU0YjRiOWVmNjYzYjUyODkxMDA5ZGQ5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4vRmlsZVN5c3RlbVdpbi5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vd2luL0ZpbGVTeXN0ZW1XaW4uY3BwCkBAIC00NDIsNCArNDQyLDE0IEBA IFZlY3RvcjxTdHJpbmc+IGxpc3REaXJlY3RvcnkoY29uc3QgU3RyaW5nJiBkaXJlY3RvcnksIGNv bnN0IFN0cmluZyYgZmlsdGVyKQogICAgIHJldHVybiBlbnRyaWVzOwogfQogCisvLyBGSVhNRTog SW1wbGVtZW50IE1hcHBlZEZpbGVEYXRhCitSZWZQdHI8TWFwcGVkRmlsZURhdGE+IE1hcHBlZEZp bGVEYXRhOjpjcmVhdGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK3sKKyAgICByZXR1cm4gbnVs bHB0cjsKK30KKworTWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0YSgpCit7Cit9CisKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1No YXJlZEJ1ZmZlcldpbi5jcHAKaW5kZXggZjVkZDIyODQ2NDE5YTBmMmQ5Nzg1YjlhNjljZGY5MDli YzM5MWQ3MC4uNjA1NDY3MTM0MjdlZWRkYTZiMWI1Y2Y0ZjBiY2Q2OGEzYzM1MGRkMiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKQEAgLTMz LDggKzMzLDkgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPFNoYXJlZEJ1 ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5n JiBmaWxlUGF0aCkKK1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0 aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCiB7CisgICAgLy8gRklYTUU6 IFVzZSBtYXAgZmlsZSByb3V0aW5lcy4KICAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQogICAg ICAgICByZXR1cm4gMDsKIApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hh bmdlTG9nCmluZGV4IGY2NTBlMGFjZWNkN2IxNjFjM2FiYTNlYzVlYWZlYjMwMjkxYmM5YzcuLjA5 MTI4N2FhZGMzZTgyMmE0Y2EyMTBiNjRlYzAxNThiZGM0YWZjMjQgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxNS0w NC0zMCAgWW91ZW5uIEZhYmxldCAgPHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgorICAgICAg ICBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSBzaG91bGQgdXNlIG1hcCBm aWxlIHJvdXRpbmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNDQxOTIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBBZGRpbmcgU2hhcmVkQnVmZmVyIGFuZCBGaWxlU3lzdGVtIFVuaXQgdGVzdHMgdG8gTWFj IGFuZCBHVEssIG5vdCB5ZXQgZm9yIEVGTC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxh dGZvcm1HVEsuY21ha2U6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnZj eHByb2ovVGVzdFdlYktpdEFQSS52Y3hwcm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS52Y3hwcm9qL1Rlc3RXZWJLaXRBUEkudmN4cHJvai5maWx0ZXJzOgorICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q OgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcDog QWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpGaWxlU3lzdGVtVGVzdDo6dGVtcEZpbGVQ YXRoKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1RfRik6CisgICAgICAgICogVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJDb3JlL1NoYXJlZEJ1ZmZlci5jcHA6IEFkZGVkLgorICAgICAgICAo VGVzdFdlYktpdEFQSTo6U2hhcmVkQnVmZmVyVGVzdDo6dGVtcEZpbGVQYXRoKToKKyAgICAgICAg KFRlc3RXZWJLaXRBUEk6OlNoYXJlZEJ1ZmZlclRlc3Q6OnRlbXBFbXB0eUZpbGVQYXRoKToKKyAg ICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1RfRik6CisKIDIwMTUtMDQtMjkgIEpvb25naHVuIFBh cmsgIDxqaDcxOC5wYXJrQHNhbXN1bmcuY29tPgogCiAgICAgICAgIFtHVEtdIEFkZCBsaWJub3Rp ZnktZGV2IGluIGd0ayBpbnN0YWxsLWRlcGVuZGVuY2llcwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVz dFdlYktpdEFQSS9QbGF0Zm9ybUdUSy5jbWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZv cm1HVEsuY21ha2UKaW5kZXggY2ZjMGQ4NzdiZTFiZDQwMTgyMmU5MjU1YTIwMDFhZWQzMTAzMGNh YS4uZTA3OTc5M2FhMWY3MDc1Zjc3ZTJlNTFmNWQ5ZTVhNWRiNzk1YWZhNyAxMDA2NDQKLS0tIGEv VG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlCkBAIC0xMSw2ICsxMSw3IEBAIHNldChGb3J3YXJkaW5n SGVhZGVyc0ZvclRlc3RXZWJLaXRBUElfTkFNRSBUZXN0V2ViS2l0QVBJLWZvcndhcmRpbmctaGVh ZGVycykKIAogaW5jbHVkZV9kaXJlY3RvcmllcygKICAgICAke0ZPUldBUkRJTkdfSEVBREVSU19E SVJ9CisgICAgJHtGT1JXQVJESU5HX0hFQURFUlNfRElSfS9KYXZhU2NyaXB0Q29yZQogICAgICR7 V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvQy9zb3VwCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQ cm9jZXNzL0FQSS9DL2d0awogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrCkBA IC0xMjIsNiArMTIzLDggQEAgYWRkX2V4ZWN1dGFibGUoVGVzdFdlYkNvcmUKICAgICAke1RFU1RX RUJLSVRBUElfRElSfS9UZXN0c0NvbnRyb2xsZXIuY3BwCiAgICAgJHtURVNUV0VCS0lUQVBJX0RJ Un0vVGVzdHMvV2ViQ29yZS9MYXlvdXRVbml0LmNwcAogICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9 L1Rlc3RzL1dlYkNvcmUvVVJMLmNwcAorICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzL1dl YkNvcmUvU2hhcmVkQnVmZmVyLmNwcAorICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzL1dl YkNvcmUvRmlsZVN5c3RlbS5jcHAKICkKIAogdGFyZ2V0X2xpbmtfbGlicmFyaWVzKFRlc3RXZWJD b3JlICR7dGVzdF93ZWJjb3JlX0xJQlJBUklFU30pCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2ViS2l0QVBJLnZjeHByb2ogYi9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2ViS2l0QVBJLnZjeHBy b2oKaW5kZXggYmNmZWE0MDlkNTQzZGQxMDg5ODA0NzM5ZmU0ZWZiN2FhMmFlY2MwYi4uNTZmYmYw NjIxOGViNTYzOTAzYzIzNmFlODFhNzIxZDAxYzYxNzNjMyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnZjeHByb2ovVGVzdFdlYktpdEFQSS52Y3hwcm9qCisr KyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS52Y3hwcm9qL1Rlc3RXZWJLaXRB UEkudmN4cHJvagpAQCAtMjkzLDcgKzI5Myw5IEBACiAgICAgPENsQ29tcGlsZSBJbmNsdWRlPSIu LlxUZXN0c0NvbnRyb2xsZXIuY3BwIiAvPgogICAgIDxDbENvbXBpbGUgSW5jbHVkZT0iLi5cVGVz dHNcV2ViQ29yZVxDYWxjdWxhdGlvblZhbHVlLmNwcCIgLz4KICAgICA8Q2xDb21waWxlIEluY2x1 ZGU9Ii4uXFRlc3RzXFdlYkNvcmVcQ1NTUGFyc2VyLmNwcCIgLz4KKyAgICA8Q2xDb21waWxlIElu Y2x1ZGU9Ii4uXFRlc3RzXFdlYkNvcmVcRmlsZVN5c3RlbS5jcHAiIC8+CiAgICAgPENsQ29tcGls ZSBJbmNsdWRlPSIuLlxUZXN0c1xXZWJDb3JlXExheW91dFVuaXQuY3BwIiAvPgorICAgIDxDbENv bXBpbGUgSW5jbHVkZT0iLi5cVGVzdHNcV2ViQ29yZVxTaGFyZWRCdWZmZXIuY3BwIiAvPgogICAg IDxDbENvbXBpbGUgSW5jbHVkZT0iLi5cVGVzdHNcV2ViQ29yZVxUaW1lUmFuZ2VzLmNwcCIgLz4K ICAgICA8Q2xDb21waWxlIEluY2x1ZGU9Ii4uXFRlc3RzXFdlYkNvcmVcVVJMLmNwcCIgLz4KICAg ICA8Q2xDb21waWxlIEluY2x1ZGU9Ii4uXFRlc3RzXFdlYkNvcmVcd2luXEJpdG1hcEltYWdlLmNw cCI+CkBAIC0zNjQsNCArMzY2LDQgQEAKICAgPEltcG9ydCBQcm9qZWN0PSIkKFZDVGFyZ2V0c1Bh dGgpXE1pY3Jvc29mdC5DcHAudGFyZ2V0cyIgLz4KICAgPEltcG9ydEdyb3VwIExhYmVsPSJFeHRl bnNpb25UYXJnZXRzIj4KICAgPC9JbXBvcnRHcm91cD4KLTwvUHJvamVjdD4KXCBObyBuZXdsaW5l IGF0IGVuZCBvZiBmaWxlCis8L1Byb2plY3Q+CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2ViS2l0QVBJLnZjeHByb2ouZmlsdGVycyBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS52Y3hwcm9qL1Rlc3RXZWJLaXRBUEku dmN4cHJvai5maWx0ZXJzCmluZGV4IDEwY2QzZTdmYjFkYjE2MTlkNTMxMGRhZDQ1ODc1ZDYyN2Fk ODcxYWIuLmU5ZTcxMzRmYjkwOWQwMzFiZWU3ZjViZDBkZGIwY2Q1YTJiMzkxYWEgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS52Y3hwcm9qL1Rlc3RXZWJLaXRB UEkudmN4cHJvai5maWx0ZXJzCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQ SS52Y3hwcm9qL1Rlc3RXZWJLaXRBUEkudmN4cHJvai5maWx0ZXJzCkBAIC0xNjMsNiArMTYzLDEy IEBACiAgICAgPENsQ29tcGlsZSBJbmNsdWRlPSIuLlxUZXN0c1xXZWJDb3JlXENTU1BhcnNlci5j cHAiPgogICAgICAgPEZpbHRlcj5UZXN0c1xXZWJDb3JlPC9GaWx0ZXI+CiAgICAgPC9DbENvbXBp bGU+CisgICAgPENsQ29tcGlsZSBJbmNsdWRlPSIuLlxUZXN0c1xXZWJDb3JlXEZpbGVTeXN0ZW0u Y3BwIj4KKyAgICAgIDxGaWx0ZXI+VGVzdHNcV2ViQ29yZTwvRmlsdGVyPgorICAgIDwvQ2xDb21w aWxlPgorICAgIDxDbENvbXBpbGUgSW5jbHVkZT0iLi5cVGVzdHNcV2ViQ29yZVxTaGFyZWRCdWZm ZXIuY3BwIj4KKyAgICAgIDxGaWx0ZXI+VGVzdHNcV2ViQ29yZTwvRmlsdGVyPgorICAgIDwvQ2xD b21waWxlPgogICAgIDxDbENvbXBpbGUgSW5jbHVkZT0iLi5cVGVzdHNcV1RGXFdvcmtRdWV1ZS5j cHAiPgogICAgICAgPEZpbHRlcj5UZXN0c1xXVEY8L0ZpbHRlcj4KICAgICA8L0NsQ29tcGlsZT4K QEAgLTE3NCw0ICsxODAsNCBAQAogICAgIDxOb25lIEluY2x1ZGU9IlRlc3RXZWJLaXRBUElQb3N0 QnVpbGQuY21kIiAvPgogICAgIDxOb25lIEluY2x1ZGU9IlRlc3RXZWJLaXRBUElQcmVCdWlsZC5j bWQiIC8+CiAgIDwvSXRlbUdyb3VwPgotPC9Qcm9qZWN0PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9m IGZpbGUKKzwvUHJvamVjdD4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdl YktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNTkyOGRkNzY5N2M3 Njc3ZTRkMWU5ZGZhY2JiNjczYjM4YmQ5MDRmYS4uYzFiM2I5ZjdjYTg1NmVlZWQ2YTM5YThhOTJh ZjUyZTQyMTNhOGI2MSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0 QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTQzLDYgKzQzLDggQEAK IAkJMzc5MDI4QjkxNEZBQzI0QzAwN0U2QjQzIC8qIGFjY2VwdHNGaXJzdE1vdXNlLmh0bWwgaW4g Q29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMzc5MDI4 QjgxNEZBQkU0OTAwN0U2QjQzIC8qIGFjY2VwdHNGaXJzdE1vdXNlLmh0bWwgKi87IH07CiAJCTM3 REM2NzkxMTQwRDdENzYwMEFCQ0NEQiAvKiBET01SYW5nZU9mU3RyaW5nLmh0bWwgaW4gQ29weSBS ZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMzdEQzY3OEYxNDBE N0QzQTAwQUJDQ0RCIC8qIERPTVJhbmdlT2ZTdHJpbmcuaHRtbCAqLzsgfTsKIAkJMzdFMTA2NEMx Njk3NjgxODAwQjc4QkQwIC8qIERPTUhUTUxUYWJsZUNlbGxFbGVtZW50Q2VsbEFib3ZlLmh0bWwg aW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMzdF MTA2NEIxNjk3NjdGNzAwQjc4QkQwIC8qIERPTUhUTUxUYWJsZUNlbGxFbGVtZW50Q2VsbEFib3Zl Lmh0bWwgKi87IH07CisJCTQxOTczQjVCMUFGMjI4NkEwMDZDN0IzNiAvKiBGaWxlU3lzdGVtLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQxOTczQjVB MUFGMjI4NkEwMDZDN0IzNiAvKiBGaWxlU3lzdGVtLmNwcCAqLzsgfTsKKwkJNDE5NzNCNUQxQUYy Mjg3NTAwNkM3QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0MTk3M0I1QzFBRjIyODc1MDA2QzdCMzYgLyogU2hhcmVk QnVmZmVyLmNwcCAqLzsgfTsKIAkJNEJGREZGQTcxMzE0Nzc2QzAwNjFGMjRCIC8qIEhpdFRlc3RS ZXN1bHROb2RlSGFuZGxlX0J1bmRsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA0QkZERkZBNjEzMTQ3NzZDMDA2MUYyNEIgLyogSGl0VGVzdFJlc3Vs dE5vZGVIYW5kbGVfQnVuZGxlLmNwcCAqLzsgfTsKIAkJNTEzOTNFMjIxNTIzOTUyRDAwNUYzOUM1 IC8qIERPTVdpbmRvd0V4dGVuc2lvbkJhc2ljX0J1bmRsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTM5M0UxRDE1MjM5NDRBMDA1RjM5QzUgLyog RE9NV2luZG93RXh0ZW5zaW9uQmFzaWNfQnVuZGxlLmNwcCAqLzsgfTsKIAkJNTE0MkIyNzMxNTE3 QzhDODAwQzMyQjE5IC8qIENvbnRleHRNZW51Q2FuQ29weVVSTC5odG1sIGluIENvcHkgUmVzb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxNDJCMjcyMTUxN0M4OTEw MEMzMkIxOSAvKiBDb250ZXh0TWVudUNhbkNvcHlVUkwuaHRtbCAqLzsgfTsKQEAgLTQ5Miw2ICs0 OTQsOCBAQAogCQkzN0UxMDY0QTE2OTc2NzY0MDBCNzhCRDAgLyogRE9NSFRNTFRhYmxlQ2VsbENl bGxBYm92ZS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IERPTUhU TUxUYWJsZUNlbGxDZWxsQWJvdmUubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTM3 RTEwNjRCMTY5NzY3RjcwMEI3OEJEMCAvKiBET01IVE1MVGFibGVDZWxsRWxlbWVudENlbGxBYm92 ZS5odG1sICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gdGV4dC5odG1sOyBwYXRoID0gRE9NSFRNTFRhYmxlQ2VsbEVsZW1l bnRDZWxsQWJvdmUuaHRtbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMzdFMzhDMzMx NjlCN0QwMTAwODRDMjhDIC8qIFdlYlZpZXdEaWRSZW1vdmVGcmFtZUZyb21IaWVyYXJjaHkubW0g Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBXZWJWaWV3RGlkUmVtb3Zl RnJhbWVGcm9tSGllcmFyY2h5Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0MTk3 M0I1QTFBRjIyODZBMDA2QzdCMzYgLyogRmlsZVN5c3RlbS5jcHAgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBGaWxlU3lzdGVtLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJNDE5NzNCNUMxQUYyMjg3NTAwNkM3QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBTaGFyZWRCdWZmZXIuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0NDBBMUQzODE0QTAxMDNBMDA4QTY2RjIgLyogVVJM LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFVSTC5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ0QTYyMkMxMTRBMEUyQjYwMDQ4NTE1QiAvKiBXVEZT dHJpbmdVdGlsaXRpZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV1RGU3Ry aW5nVXRpbGl0aWVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRBNDEwRjRCMTlB RjdCRDYwMDJFQkFCNSAvKiBVc2VyTWVkaWEuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAu Y3BwOyBwYXRoID0gVXNlck1lZGlhLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAg LTc2Miw2ICs3NjYsNyBAQAogCQkwOEZCNzc5NUZFODQxNTVEQzAyQUFDMDcgLyogU291cmNlICov ID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJCQk0NEE4MkU3QjE5 MjUxQjM1MDBDMUM4QzQgLyogQ29jb2EgKi8sCiAJCQkJMEYxMzlFNzExQTQyM0ExRDAwRjU5MEY1 IC8qIGNvY29hICovLAogCQkJCUJDNTc1OTQ0MTI2RTczM0MwMDZGMEYxMiAvKiBJbmplY3RlZEJ1 bmRsZSAqLywKIAkJCQkyRTk2NjBEQzE2QzA3RDdCMDAzNzFCNDIgLyogaW9zICovLApAQCAtODUy LDcgKzg1Nyw5IEBACiAJCQkJN0NCMTg0QzQxQUEzRjIxMDAwNjZFREZEIC8qIENvbnRlbnRFeHRl bnNpb25zLmNwcCAqLywKIAkJCQlDRDU0NTFFOTE5RTQxRjlEMDAxNjkzNkYgLyogQ1NTUGFyc2Vy LmNwcCAqLywKIAkJCQkyNkY2RTFFRjFBREM3NDlCMDBERTY5NkIgLyogREZBTWluaW1pemVyLmNw cCAqLywKKwkJCQk0MTk3M0I1QTFBRjIyODZBMDA2QzdCMzYgLyogRmlsZVN5c3RlbS5jcHAgKi8s CiAJCQkJMTQ0NjQwMTIxNjdBODMwNTAwMEJEMjE4IC8qIExheW91dFVuaXQuY3BwICovLAorCQkJ CTQxOTczQjVDMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRCdWZmZXIuY3BwICovLAogCQkJCUNE QzJDNzE0MTc5NzA4OUQwMEU2MjdGQiAvKiBUaW1lUmFuZ2VzLmNwcCAqLywKIAkJCQk0NDBBMUQz ODE0QTAxMDNBMDA4QTY2RjIgLyogVVJMLmNwcCAqLywKIAkJCSk7CkBAIC04NjQsNyArODcxLDgg QEAKIAkJCWNoaWxkcmVuID0gKAogCQkJCTkzQTdFQjNDMThGQTYzQTQwMDlFNzY3MCAvKiBVUkxF eHRyYXMubW0gKi8sCiAJCQkpOwotCQkJcGF0aCA9IENvY29hOworCQkJbmFtZSA9IENvY29hOwor CQkJcGF0aCA9IFRlc3RzL0NvY29hOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKIAkJfTsK IAkJNzU2MDkxNzYxOTI1OUM1OTAwOUVGMDZFIC8qIGlvcyAqLyA9IHsKQEAgLTExNTMsNyArMTE2 MSw2IEBACiAJCUJDQjlFQjY2MTEyMzY2RDgwMEExMzdFMCAvKiBUZXN0cyAqLyA9IHsKIAkJCWlz YSA9IFBCWEdyb3VwOwogCQkJY2hpbGRyZW4gPSAoCi0JCQkJNDRBODJFN0IxOTI1MUIzNTAwQzFD OEM0IC8qIENvY29hICovLAogCQkJCTc1NjA5MTc2MTkyNTlDNTkwMDlFRjA2RSAvKiBpb3MgKi8s CiAJCQkJRkUyMTdFQ0IxNjQwQTU0QTAwNTI5ODhCIC8qIEphdmFTY3JpcHRDb3JlICovLAogCQkJ CUMwN0U2Q0FEMTNGRDY3NjUwMDM4QjIyQiAvKiBtYWMgKi8sCkBAIC0xNTg1LDggKzE1OTIsMTAg QEAKIAkJCQkyRDFGRTBCMDFBRDQ2NUMxMDA2Q0Q5RTYgLyogRml4ZWRMYXlvdXRTaXplLm1tIGlu IFNvdXJjZXMgKi8sCiAJCQkJMUNCOUJDMzgxQTY3NDgyMzAwRkU1Njc4IC8qIFdlYWtQdHIuY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkJMkU3NzY1Q0QxNkM0RDgwQTAwQkEyQkIxIC8qIG1haW5JT1Mu bW0gaW4gU291cmNlcyAqLywKKwkJCQk0MTk3M0I1RDFBRjIyODc1MDA2QzdCMzYgLyogU2hhcmVk QnVmZmVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdBQTZBMTUyMUFBQzBCMzEwMDJCMkVEMyAv KiBXb3JrUXVldWUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMkU3NzY1Q0YxNkM0RDgxMTAwQkEy QkIxIC8qIG1haW5NYWMubW0gaW4gU291cmNlcyAqLywKKwkJCQk0MTk3M0I1QjFBRjIyODZBMDA2 QzdCMzYgLyogRmlsZVN5c3RlbS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3QTU2MjMxMTFBRDVB RjNFMDA5NkI5MjAgLyogTWVudVR5cGVzRm9yTW91c2VFdmVudHMuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJMjZGNkUxRjAxQURDNzQ5QjAwREU2OTZCIC8qIERGQU1pbmltaXplci5jcHAgaW4gU291 cmNlcyAqLywKIAkJCQk3QTk5RDk5NDFBRDRBMjlEMDAzNzMxNDEgLyogTWVudVR5cGVzRm9yTW91 c2VFdmVudHMubW0gaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iZDJmZjQ1NDhlNjQzNGM3MGU4 MzI5OTVkZjNkMjVlYWE1ZWFmMDMwCi0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJDb3JlL0ZpbGVTeXN0ZW0uY3BwCkBAIC0wLDAgKzEsOTIgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTUgQ2Fub24gSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQg SVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUg SU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJUZXN0LmgiCisjaW5jbHVk ZSA8V2ViQ29yZS9GaWxlU3lzdGVtLmg+CisjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KKyNp bmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwor CituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK2NvbnN0IGNoYXIqIEZpbGVTeXN0ZW1UZXN0 RGF0YSA9ICJUaGlzIGlzIGEgdGVzdCI7CisKKy8vIEZJWE1FOiBSZWZhY3RvciBGaWxlU3lzdGVt VGVzdCBhbmQgU2hhcmVkQnVmZmVyVGVzdCBhcyBhIHNpbmdsZSBjbGFzcy4KK2NsYXNzIEZpbGVT eXN0ZW1UZXN0IDogcHVibGljIHRlc3Rpbmc6OlRlc3QgeworcHVibGljOgorICAgIHZpcnR1YWwg dm9pZCBTZXRVcCgpIG92ZXJyaWRlCisgICAgeworICAgICAgICBXVEY6OmluaXRpYWxpemVNYWlu VGhyZWFkKCk7CisgICAgICAgIAorICAgICAgICAvLyBjcmVhdGUgdGVtcCBmaWxlCisgICAgICAg IFBsYXRmb3JtRmlsZUhhbmRsZSBoYW5kbGU7CisgICAgICAgIG1fdGVtcEZpbGVQYXRoID0gb3Bl blRlbXBvcmFyeUZpbGUoInRlbXBUZXN0RmlsZSIsIGhhbmRsZSk7CisgICAgICAgIHdyaXRlVG9G aWxlKGhhbmRsZSwgRmlsZVN5c3RlbVRlc3REYXRhLCBzdHJsZW4oRmlsZVN5c3RlbVRlc3REYXRh KSk7CisgICAgICAgIGNsb3NlRmlsZShoYW5kbGUpOyAKKworICAgICAgICBtX3RlbXBFbXB0eUZp bGVQYXRoID0gb3BlblRlbXBvcmFyeUZpbGUoInRlbXBFbXB0eVRlc3RGaWxlIiwgaGFuZGxlKTsK KyAgICAgICAgd3JpdGVUb0ZpbGUoaGFuZGxlLCAiIiwgMCk7CisgICAgICAgIGNsb3NlRmlsZSho YW5kbGUpOyAKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgVGVhckRvd24oKSBvdmVycmlkZQor ICAgIHsKKyAgICAgICAgZGVsZXRlRmlsZShtX3RlbXBGaWxlUGF0aCk7CisgICAgICAgIGRlbGV0 ZUZpbGUobV90ZW1wRW1wdHlGaWxlUGF0aCk7CisgICAgfQorCisgICAgY29uc3QgU3RyaW5nJiB0 ZW1wRmlsZVBhdGgoKSB7IHJldHVybiBtX3RlbXBGaWxlUGF0aDsgfQorICAgIGNvbnN0IFN0cmlu ZyYgdGVtcEVtcHR5RmlsZVBhdGgoKSB7IHJldHVybiBtX3RlbXBFbXB0eUZpbGVQYXRoOyB9CisK K3ByaXZhdGU6CisgICAgU3RyaW5nIG1fdGVtcEZpbGVQYXRoOworICAgIFN0cmluZyBtX3RlbXBF bXB0eUZpbGVQYXRoOworfTsKKworVEVTVF9GKEZpbGVTeXN0ZW1UZXN0LCBNYXBwaW5nTWlzc2lu Z0ZpbGUpCit7CisgICAgc3RkOjp1bmlxdWVfcHRyPE1hcHBlZEZpbGVEYXRhPiBtYXBwZWRGaWxl RGF0YSA9IE1hcHBlZEZpbGVEYXRhOjpjcmVhdGUoU3RyaW5nKCJub3RfZXhpc3RpbmdfZmlsZSIp KTsKKyAgICBFWFBFQ1RfVFJVRSghbWFwcGVkRmlsZURhdGEpOworfQorCitURVNUX0YoRmlsZVN5 c3RlbVRlc3QsIE1hcHBpbmdFeGlzdGluZ0ZpbGUpCit7CisgICAgc3RkOjp1bmlxdWVfcHRyPE1h cHBlZEZpbGVEYXRhPiBtYXBwZWRGaWxlRGF0YSA9IE1hcHBlZEZpbGVEYXRhOjpjcmVhdGUodGVt cEZpbGVQYXRoKCkpOworICAgIEVYUEVDVF9UUlVFKCEhbWFwcGVkRmlsZURhdGEpOworICAgIEVY UEVDVF9UUlVFKG1hcHBlZEZpbGVEYXRhLT5zaXplKCkgPT0gc3RybGVuKEZpbGVTeXN0ZW1UZXN0 RGF0YSkpOworICAgIEVYUEVDVF9UUlVFKHN0cm5zdHIoRmlsZVN5c3RlbVRlc3REYXRhLCBzdGF0 aWNfY2FzdDxjb25zdCBjaGFyKj4obWFwcGVkRmlsZURhdGEtPmRhdGEoKSksIG1hcHBlZEZpbGVE YXRhLT5zaXplKCkpKTsKK30KKworVEVTVF9GKEZpbGVTeXN0ZW1UZXN0LCBNYXBwaW5nRXhpc3Rp bmdFbXB0eUZpbGUpCit7CisgICAgc3RkOjp1bmlxdWVfcHRyPE1hcHBlZEZpbGVEYXRhPiBtYXBw ZWRGaWxlRGF0YSA9IE1hcHBlZEZpbGVEYXRhOjpjcmVhdGUodGVtcEVtcHR5RmlsZVBhdGgoKSk7 CisgICAgRVhQRUNUX1RSVUUoISFtYXBwZWRGaWxlRGF0YSk7CisgICAgRVhQRUNUX1RSVUUoIW1h cHBlZEZpbGVEYXRhLT5zaXplKCkpOworfQorCit9CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYkNvcmUvU2hhcmVkQnVmZmVyLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjRhYTBhYzk3ZWRl NDYyNDA2M2YxYzMxZmU3OWFkZTUyNmU0MjNiYWMKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvU2hhcmVkQnVmZmVyLmNwcApAQCAtMCwwICsxLDEw OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisg KiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAq IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlRlc3Qu aCIKKyNpbmNsdWRlIDxXZWJDb3JlL1NoYXJlZEJ1ZmZlci5oPgorI2luY2x1ZGUgPHd0Zi9NYWlu VGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1N0cmluZ0V4dHJhcy5oPgorCit1c2luZyBuYW1lc3Bh Y2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCitjb25zdCBjaGFyKiBT aGFyZWRCdWZmZXJUZXN0RGF0YSA9ICJUaGlzIGlzIGEgdGVzdCI7CisKK2NsYXNzIFNoYXJlZEJ1 ZmZlclRlc3QgOiBwdWJsaWMgdGVzdGluZzo6VGVzdCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2 b2lkIFNldFVwKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIFdURjo6aW5pdGlhbGl6ZU1haW5U aHJlYWQoKTsKKyAgICAgICAgCisgICAgICAgIC8vIGNyZWF0ZSB0ZW1wIGZpbGUKKyAgICAgICAg UGxhdGZvcm1GaWxlSGFuZGxlIGhhbmRsZTsKKyAgICAgICAgbV90ZW1wRmlsZVBhdGggPSBvcGVu VGVtcG9yYXJ5RmlsZSgidGVtcFRlc3RGaWxlIiwgaGFuZGxlKTsKKyAgICAgICAgd3JpdGVUb0Zp bGUoaGFuZGxlLCBTaGFyZWRCdWZmZXJUZXN0RGF0YSwgc3RybGVuKFNoYXJlZEJ1ZmZlclRlc3RE YXRhKSk7CisgICAgICAgIGNsb3NlRmlsZShoYW5kbGUpOyAKKworICAgICAgICBtX3RlbXBFbXB0 eUZpbGVQYXRoID0gb3BlblRlbXBvcmFyeUZpbGUoInRlbXBFbXB0eVRlc3RGaWxlIiwgaGFuZGxl KTsKKyAgICAgICAgd3JpdGVUb0ZpbGUoaGFuZGxlLCAiIiwgMCk7CisgICAgICAgIGNsb3NlRmls ZShoYW5kbGUpOyAKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgVGVhckRvd24oKSBvdmVycmlk ZQorICAgIHsKKyAgICAgICAgZGVsZXRlRmlsZShtX3RlbXBGaWxlUGF0aCk7CisgICAgICAgIGRl bGV0ZUZpbGUobV90ZW1wRW1wdHlGaWxlUGF0aCk7CisgICAgfQorCisgICAgY29uc3QgU3RyaW5n JiB0ZW1wRmlsZVBhdGgoKSB7IHJldHVybiBtX3RlbXBGaWxlUGF0aDsgfQorICAgIGNvbnN0IFN0 cmluZyYgdGVtcEVtcHR5RmlsZVBhdGgoKSB7IHJldHVybiBtX3RlbXBFbXB0eUZpbGVQYXRoOyB9 CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIG1fdGVtcEZpbGVQYXRoOworICAgIFN0cmluZyBtX3Rl bXBFbXB0eUZpbGVQYXRoOworfTsKKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNyZWF0ZVdp dGhDb250ZW50c09mTWlzc2luZ0ZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVm ZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoU3RyaW5nKCJub3Rf ZXhpc3RpbmdfZmlsZSIpKTsKKyAgICBBU1NFUlRfTlVMTChidWZmZXIpOworfQorCitURVNUX0Yo U2hhcmVkQnVmZmVyVGVzdCwgY3JlYXRlV2l0aENvbnRlbnRzT2ZFeGlzdGluZ0ZpbGUpCit7Cisg ICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRo Q29udGVudHNPZkZpbGUodGVtcEZpbGVQYXRoKCkpOworICAgIEFTU0VSVF9OT1RfTlVMTChidWZm ZXIpOworICAgIEVYUEVDVF9UUlVFKGJ1ZmZlci0+c2l6ZSgpID09IHN0cmxlbihTaGFyZWRCdWZm ZXJUZXN0RGF0YSkpOworICAgIEVYUEVDVF9UUlVFKHN0cm5zdHIoU2hhcmVkQnVmZmVyVGVzdERh dGEsIGJ1ZmZlci0+ZGF0YSgpLCBidWZmZXItPnNpemUoKSkpOworfQorCitURVNUX0YoU2hhcmVk QnVmZmVyVGVzdCwgY3JlYXRlV2l0aENvbnRlbnRzT2ZFeGlzdGluZ0VtcHR5RmlsZSkKK3sKKyAg ICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhD b250ZW50c09mRmlsZSh0ZW1wRW1wdHlGaWxlUGF0aCgpKTsKKyAgICBBU1NFUlRfTk9UX05VTEwo YnVmZmVyKTsKKyAgICBFWFBFQ1RfVFJVRShidWZmZXItPmlzRW1wdHkoKSk7Cit9CisKK1RFU1Rf RihTaGFyZWRCdWZmZXJUZXN0LCBjb3B5QnVmZmVyQ3JlYXRlZFdpdGhDb250ZW50c09mRXhpc3Rp bmdGaWxlKQoreworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNoYXJlZEJ1ZmZl cjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKHRlbXBGaWxlUGF0aCgpKTsKKyAgICBBU1NFUlRf Tk9UX05VTEwoYnVmZmVyKTsKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBjb3B5ID0gYnVmZmVy LT5jb3B5KCk7CisgICAgRVhQRUNUX1RSVUUoYnVmZmVyLT5zaXplKCkgPT0gY29weS0+c2l6ZSgp KTsKKyAgICBFWFBFQ1RfVFJVRShzdHJuc3RyKGJ1ZmZlci0+ZGF0YSgpLCBjb3B5LT5kYXRhKCks IGJ1ZmZlci0+c2l6ZSgpKSk7Cit9CisKK1RFU1RfRihTaGFyZWRCdWZmZXJUZXN0LCBjbGVhckJ1 ZmZlckNyZWF0ZWRXaXRoQ29udGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBSZWZQdHI8U2hh cmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmls ZSh0ZW1wRmlsZVBhdGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgYnVm ZmVyLT5jbGVhcigpOworICAgIEVYUEVDVF9UUlVFKCFidWZmZXItPnNpemUoKSk7CisgICAgRVhQ RUNUX1RSVUUoIWJ1ZmZlci0+ZGF0YSgpKTsKK30KKworfQo= 252323 2015-05-04 12:17:38 -0700 2015-05-05 11:51:43 -0700 move constructor approach bug-144192-20150504211622.patch text/plain 37526 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTgzNzQ0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmM3NjFkMWViNTczOTFl ZmQ4ZjJmOWZiNWRkNGZiNDU1Njg1OWEzZi4uZmU5M2IwOWE3YjE5YmQwOTA4YzZkZmIwNDFhNzU5 MWM1NmU1MmJiMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUwIEBACisyMDE1LTA1LTA0ICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIEZpbGUgY29u dGVudCBpcyBtYXBwZWQgdW50aWwgU2hhcmVkQnVmZmVyIGlzIGNsZWFyZWQsIGRlc3Ryb3llZCBv ciBhZGRpdGlvbmFsIGNvbnRlbnQgaXMgYXBwZW5kZWQgdG8gdGhlIFNoYXJlZEJ1ZmZlci4KKyAg ICAgICAgUmVtb3ZlZCBFRkwsIE1hYyBhbmQgR1RLIHNwZWNpZmljIHZlcnNpb25zIG9mIFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorCisgICAgICAgIEEgaGVscGVyIGNs YXNzLCBNYXBwZWRGaWxlRGF0YSwgaXMgaW50cm9kdWNlZCB0byBoYW5kbGUgbWFwcGVkIGZpbGVz IHRocm91Z2ggY2FsbHMgdG8gb3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAgICBQYXRj aCBjb3ZlcmVkIGJ5IGV4aXN0aW5nIGxheW91dCB0ZXN0cyBhbmQgYWRkZWQgdW5pdCB0ZXN0cy4K KworICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtlOgorICAgICAgICAqIFBsYXRmb3JtR1RLLmNt YWtlOgorICAgICAgICAqIFBsYXRmb3JtTWFjLmNtYWtlOgorICAgICAgICAqIHBsYXRmb3JtL0Zp bGVTeXN0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OmNyZWF0ZSk6 CisgICAgICAgIChXZWJDb3JlOjpNYXBwZWRGaWxlRGF0YTo6TWFwcGVkRmlsZURhdGEpOgorICAg ICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0YSk6CisgICAgICAg IChXZWJDb3JlOjpjYW5FeGNsdWRlRnJvbUJhY2t1cCk6IERlbGV0ZWQuCisgICAgICAgICogcGxh dGZvcm0vRmlsZVN5c3RlbS5oOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OmRh dGEpOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OnNpemUpOgorICAgICAgICAq IHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZm ZXI6OlNoYXJlZEJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OnNpemUp OgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpkYXRhKToKKyAgICAgICAgKFdlYkNv cmU6OlNoYXJlZEJ1ZmZlcjo6YXBwZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZl cjo6Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjb3B5KToKKyAgICAg ICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEpOgorICAgICAgICAoV2ViQ29y ZTo6U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEpOgorICAgICAgICAo V2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOgorICAgICAg ICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjp+U2hhcmVkQnVmZmVyKTogRGVsZXRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YWRvcHRWZWN0b3IpOiBEZWxldGVkLgorICAgICAg ICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjb3B5QnVmZmVyQW5kQ2xlYXIpOiBEZWxldGVkLgor ICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpjcmVhdGUpOiBEZWxldGVkLgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9TaGFy ZWRCdWZmZXJHdGsuY3BwOiBSZW1vdmVkLgorICAgICAgICAqIHBsYXRmb3JtL21hYy9TaGFyZWRC dWZmZXJNYWMubW06CisgICAgICAgICogcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVgu Y3BwOiBSZW1vdmVkLgorICAgICAgICAqIHBsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3Bw OgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZp bGUpOgorCiAyMDE1LTA1LTA0ICBYYWJpZXIgUm9kcmlndWV6IENhbHZhciAgPGNhbHZhcmlzQGln YWxpYS5jb20+IGFuZCBZb3Vlbm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+ CiAKICAgICAgICAgW1N0cmVhbXMgQVBJXSBSZWZhY3RvciBSZWFkYWJsZUpTU3RyZWFtIGFuZCBS ZWFkYWJsZVN0cmVhbUpTU291cmNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9y bUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCmluZGV4IGU2MzMw YzU4Njg0ZjVhNzA4N2VkMTQxMWJmN2NlNGQxODI0NGYxYzkuLjhlZmQ3MWZhNDdiZTg5ZjQyNzg1 NzVkN2ZjMGE0MmI4YWIyZWI1YzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3Jt RWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC0yNDMs NyArMjQzLDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZvcm0vbmV0 d29yay9zb3VwL1N5bmNocm9ub3VzTG9hZGVyQ2xpZW50U291cC5jcHAKIAogICAgIHBsYXRmb3Jt L3Bvc2l4L0ZpbGVTeXN0ZW1QT1NJWC5jcHAKLSAgICBwbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZm ZXJQT1NJWC5jcHAKIAogICAgIHBsYXRmb3JtL3NvdXAvU2hhcmVkQnVmZmVyU291cC5jcHAKICAg ICBwbGF0Zm9ybS9zb3VwL1VSTFNvdXAuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q bGF0Zm9ybUdUSy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4 IDgxOWY1YmIzMDliZTFkYTBiMDE0NDRmZjFjOTM0OTc5NjJhM2FlNzQuLmM5MTJlNDJhMDYxNzg2 NTc0YzFkNmQ3ZDBlZDYwNTA4YTU3OTI5YmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1Bs YXRmb3JtR1RLLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCkBA IC0xMzQsNyArMTM0LDYgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZv cm0vZ3RrL0xhbmd1YWdlR3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9Mb2dnaW5nR3RrLmNwcAog ICAgIHBsYXRmb3JtL2d0ay9NSU1FVHlwZVJlZ2lzdHJ5R3RrLmNwcAotICAgIHBsYXRmb3JtL2d0 ay9TaGFyZWRCdWZmZXJHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL1NoYXJlZFRpbWVyR3RrLmNw cAogICAgIHBsYXRmb3JtL2d0ay9UZW1wb3JhcnlMaW5rU3R1YnMuY3BwCiAgICAgcGxhdGZvcm0v Z3RrL1VzZXJBZ2VudEd0ay5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3Jt TWFjLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1NYWMuY21ha2UKaW5kZXggMDU0YWE1 NDA4N2UzYzUzMTk4YzFlOGY1NTY4NmFiOTllMzUxZjJmNy4uZWNiZTc5NWMyNGVhODBlMmExYjJi NDU5YzYyMjdkN2NiYTk1NjQwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1N YWMuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1NYWMuY21ha2UKQEAgLTM0OSw3 ICszNDksNiBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKICAgICBwbGF0Zm9ybS9uZXR3 b3JrL21hYy9XZWJDb3JlVVJMUmVzcG9uc2UubW0KIAogICAgIHBsYXRmb3JtL3Bvc2l4L0ZpbGVT eXN0ZW1QT1NJWC5jcHAKLSAgICBwbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAK IAogICAgIHBsYXRmb3JtL3RleHQvY2YvSHlwaGVuYXRpb25DRi5jcHAKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9GaWxlU3lzdGVtLmNwcAppbmRleCA5N2I4NDZlZWNjNGM2MzBkZGJhMDZkNGM1N2Qz NjE3NjhkOGVjZmRmLi5jZTc0N2E1ZjU4MzBiYWZkMDJlNzAxMWVlODZkMTczOTNhNWUxOGU2IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8q CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMTEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjcsOCArMjgsMTYgQEAKICNp bmNsdWRlICJGaWxlU3lzdGVtLmgiCiAKICNpbmNsdWRlIDx3dGYvSGV4TnVtYmVyLmg+CisjaW5j bHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxk ZXIuaD4KIAorI2lmICFQTEFURk9STShXSU4pCisjaW5jbHVkZSA8ZmNudGwuaD4KKyNpbmNsdWRl IDxzeXMvbW1hbi5oPgorI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+ CisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAvLyBUaGUgZm9sbG93aW5nIGxvd2Vy LUFTQ0lJIGNoYXJhY3RlcnMgbmVlZCBlc2NhcGluZyB0byBiZSB1c2VkIGluIGEgZmlsZW5hbWUK QEAgLTExMiw1ICsxMjEsNTYgQEAgYm9vbCBleGNsdWRlRnJvbUJhY2t1cChjb25zdCBTdHJpbmcm KQogfQogCiAjZW5kaWYKKyAgICAKKworTWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKE1h cHBlZEZpbGVEYXRhJiYgZmQpCit7CisgICAgc3RkOjpzd2FwKG1fZmlsZURhdGEsIGZkLm1fZmls ZURhdGEpOworICAgIHN0ZDo6c3dhcChtX2ZpbGVTaXplLCBmZC5tX2ZpbGVTaXplKTsKK30KKwor dm9pZCBNYXBwZWRGaWxlRGF0YTo6cmVzZXQoKQoreworI2lmICFQTEFURk9STShXSU4pCisgICAg aWYgKCFtX2ZpbGVEYXRhKQorICAgICAgICByZXR1cm47CisgICAgbXVubWFwKG1fZmlsZURhdGEs IG1fZmlsZVNpemUpOworICAgIG1fZmlsZURhdGEgPSBudWxscHRyOworI2VuZGlmCit9CisKKyNp ZiAhUExBVEZPUk0oV0lOKQorTWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKGNvbnN0IFN0 cmluZyYgZmlsZVBhdGgpCit7CisgICAgaW50IGZkID0gb3BlbihmaWxlU3lzdGVtUmVwcmVzZW50 YXRpb24oZmlsZVBhdGgpLmRhdGEoKSwgT19SRE9OTFkpOworICAgIGlmIChmZCA8IDApCisgICAg ICAgIHJldHVybjsKKworICAgIHN0cnVjdCBzdGF0IGZpbGVTdGF0OworICAgIGlmIChmc3RhdChm ZCwgJmZpbGVTdGF0KSkgeworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBpZiAoZmlsZVN0YXQuc3Rfc2l6ZSA8IDAgfHwgZmlsZVN0YXQuc3Rfc2l6ZSA+ IElOVF9NQVgpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAgICByZXR1cm47CisgICAgfQor CisgICAgdW5zaWduZWQgc2l6ZSA9IHN0YXRpY19jYXN0PHVuc2lnbmVkPihmaWxlU3RhdC5zdF9z aXplKTsKKworICAgIGlmICghc2l6ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgdm9pZCogZGF0 YSA9IG1tYXAoMCwgc2l6ZSwgUFJPVF9SRUFELCBNQVBfRklMRSB8IE1BUF9TSEFSRUQsIGZkLCAw KTsKKyAgICBjbG9zZShmZCk7CisKKyAgICBpZiAoZGF0YSA9PSBNQVBfRkFJTEVEKQorICAgICAg ICByZXR1cm47CisKKyAgICBtX2ZpbGVEYXRhID0gZGF0YTsKKyAgICBtX2ZpbGVTaXplID0gc2l6 ZTsKK30KKyNlbmRpZgogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9GaWxlU3lzdGVtLmgKaW5kZXggZjVjM2EyY2Y4ZjE2NDQzZmYxMmU2ZDVjNzdhNjc3MTVjOGUy M2I0Yy4uN2RmMzhiOTU1MjEwYTg4YjBjZWE4MDJkMjVhYTY5ZWY5ODA0N2JlYiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uaApAQCAtMjA0LDYgKzIwNCwyNiBAQCBXRUJDT1JFX0VY UE9SVCBTdHJpbmcgbG9jYWxVc2VyU3BlY2lmaWNTdG9yYWdlRGlyZWN0b3J5KCk7CiBTdHJpbmcg cm9hbWluZ1VzZXJTcGVjaWZpY1N0b3JhZ2VEaXJlY3RvcnkoKTsKICNlbmRpZgogCitjbGFzcyBN YXBwZWRGaWxlRGF0YSB7CitwdWJsaWM6CisgICAgTWFwcGVkRmlsZURhdGEoKSB7IH0KKyNpZiAh UExBVEZPUk0oV0lOKQorICAgIFdFQkNPUkVfRVhQT1JUIE1hcHBlZEZpbGVEYXRhKGNvbnN0IFN0 cmluZyYpOworI2VuZGlmCisgICAgV0VCQ09SRV9FWFBPUlQgTWFwcGVkRmlsZURhdGEoTWFwcGVk RmlsZURhdGEmJik7CisKKyAgICB+TWFwcGVkRmlsZURhdGEoKSB7IHJlc2V0KCk7IH0KKworICAg IFdFQkNPUkVfRVhQT1JUIHZvaWQgcmVzZXQoKTsKKyAgICBvcGVyYXRvciBib29sKCkgY29uc3Qg eyByZXR1cm4gISFtX2ZpbGVEYXRhOyB9CisgICAgY29uc3Qgdm9pZCogZGF0YSgpIGNvbnN0IHsg cmV0dXJuIG1fZmlsZURhdGE7IH0KKyAgICB1bnNpZ25lZCBzaXplKCkgY29uc3QgeyByZXR1cm4g bV9maWxlU2l6ZTsgfQorCitwcml2YXRlOgorICAgIHZvaWQqIG1fZmlsZURhdGEgeyBudWxscHRy IH07CisgICAgdW5zaWduZWQgbV9maWxlU2l6ZSB7IDAgfTsKK307CisKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKIAogI2VuZGlmIC8vIEZpbGVTeXN0ZW1faApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1NoYXJlZEJ1ZmZlci5jcHAKaW5kZXggYWZiYjY1MzFmZDcxNGI4NjdhZmQ2ZDJmZjEyN2NlOTk2 NmUwZGViOS4uNTBmMDVhNmJkYTNlYWJkMzJlNjBhMjM1MTYyNzVkMTI2ZjA5M2IzOCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0xLDYgKzEsNyBAQAogLyoK ICAqIENvcHlyaWdodCAoQykgMjAwNiwgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCiAgKiBDb3B5cmlnaHQgKEMpIFJlc2VhcmNoIEluIE1vdGlvbiBMaW1pdGVkIDIwMDktMjAx MC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAg LTMwLDYgKzMxLDE0IEBACiAjaW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1ZGUgPHd0Zi91bmlj b2RlL1VURjguaD4KIAorI2lmICFQTEFURk9STShXSU4pCisjaW5jbHVkZSAiRmlsZVN5c3RlbS5o IgorI2luY2x1ZGUgPGZjbnRsLmg+CisjaW5jbHVkZSA8c3lzL21tYW4uaD4KKyNpbmNsdWRlIDxz eXMvc3RhdC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKyNlbmRpZgorCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKICNpZiAhVVNFKE5FVFdPUktfQ0ZEQVRBX0FSUkFZX0NBTExCQUNL KQpAQCAtODUsNyArOTQsMTQgQEAgU2hhcmVkQnVmZmVyOjpTaGFyZWRCdWZmZXIoY29uc3QgdW5z aWduZWQgY2hhciogZGF0YSwgdW5zaWduZWQgc2l6ZSkKIHsKICAgICBhcHBlbmQocmVpbnRlcnBy ZXRfY2FzdDxjb25zdCBjaGFyKj4oZGF0YSksIHNpemUpOwogfQotICAgIAorCitTaGFyZWRCdWZm ZXI6OlNoYXJlZEJ1ZmZlcihNYXBwZWRGaWxlRGF0YSYmIGZpbGVEYXRhKQorICAgIDogbV9zaXpl KDApCisgICAgLCBtX2J1ZmZlcihhZG9wdFJlZihuZXcgRGF0YUJ1ZmZlcikpCisgICAgLCBtX2Zp bGVEYXRhKFdURjo6bW92ZShmaWxlRGF0YSkpCit7Cit9CisKIFNoYXJlZEJ1ZmZlcjo6flNoYXJl ZEJ1ZmZlcigpCiB7CiAgICAgY2xlYXIoKTsKQEAgLTEwNCwxNSArMTIwLDIwIEBAIHVuc2lnbmVk IFNoYXJlZEJ1ZmZlcjo6c2l6ZSgpIGNvbnN0CiAgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKQog ICAgICAgICByZXR1cm4gcGxhdGZvcm1EYXRhU2l6ZSgpOwogICAgIAorICAgIGlmIChtX2ZpbGVE YXRhKQorICAgICAgICByZXR1cm4gbV9maWxlRGF0YS5zaXplKCk7CisKICAgICByZXR1cm4gbV9z aXplOwogfQogCiBjb25zdCBjaGFyKiBTaGFyZWRCdWZmZXI6OmRhdGEoKSBjb25zdAogewotCiAg ICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKQogICAgICAgICByZXR1cm4gcGxhdGZvcm1EYXRhKCk7 CiAKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PGNvbnN0 IGNoYXIqPihtX2ZpbGVEYXRhLmRhdGEoKSk7CisKICNpZiBVU0UoTkVUV09SS19DRkRBVEFfQVJS QVlfQ0FMTEJBQ0spCiAgICAgaWYgKGNvbnN0IGNoYXIqIGJ1ZmZlciA9IHNpbmdsZURhdGFBcnJh eUJ1ZmZlcigpKQogICAgICAgICByZXR1cm4gYnVmZmVyOwpAQCAtMTYzLDYgKzE4NCw3IEBAIHZv aWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgY2hhciogZGF0YSwgdW5zaWduZWQgbGVuZ3Ro KQogICAgIGlmICghbGVuZ3RoKQogICAgICAgICByZXR1cm47CiAKKyAgICBtYXliZVRyYW5zZmVy TWFwcGVkRmlsZURhdGEoKTsKICAgICBtYXliZVRyYW5zZmVyUGxhdGZvcm1EYXRhKCk7CiAKICNp ZiAhVVNFKE5FVFdPUktfQ0ZEQVRBX0FSUkFZX0NBTExCQUNLKQpAQCAtMjEzLDYgKzIzNSw5IEBA IHZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgVmVjdG9yPGNoYXI+JiBkYXRhKQogCiB2 b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXIoKQogeworICAgIGlmIChtX2ZpbGVEYXRhKQorICAgICAg ICBtX2ZpbGVEYXRhLnJlc2V0KCk7CisKICAgICBjbGVhclBsYXRmb3JtRGF0YSgpOwogICAgIAog I2lmICFVU0UoTkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC0yMzAsNyArMjU1LDgg QEAgdm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyKCkKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBT aGFyZWRCdWZmZXI6OmNvcHkoKSBjb25zdAogewogICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNs b25lIHsgYWRvcHRSZWYoKm5ldyBTaGFyZWRCdWZmZXIpIH07Ci0gICAgaWYgKGhhc1BsYXRmb3Jt RGF0YSgpKSB7CisKKyAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkgfHwgbV9maWxlRGF0YSkgewog ICAgICAgICBjbG9uZS0+YXBwZW5kKGRhdGEoKSwgc2l6ZSgpKTsKICAgICAgICAgcmV0dXJuIGNs b25lLnJlbGVhc2UoKTsKICAgICB9CkBAIC0zMTMsNyArMzM5LDcgQEAgdW5zaWduZWQgU2hhcmVk QnVmZmVyOjpnZXRTb21lRGF0YShjb25zdCBjaGFyKiYgc29tZURhdGEsIHVuc2lnbmVkIHBvc2l0 aW9uKSBjb24KICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0gICAgaWYgKGhhc1BsYXRmb3Jt RGF0YSgpKSB7CisgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpIHx8IG1fZmlsZURhdGEpIHsKICAg ICAgICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04ocG9zaXRpb24gPCBzaXplKCkp OwogICAgICAgICBzb21lRGF0YSA9IGRhdGEoKSArIHBvc2l0aW9uOwogICAgICAgICByZXR1cm4g dG90YWxTaXplIC0gcG9zaXRpb247CkBAIC0zNDYsNiArMzcyLDI0IEBAIHVuc2lnbmVkIFNoYXJl ZEJ1ZmZlcjo6Z2V0U29tZURhdGEoY29uc3QgY2hhciomIHNvbWVEYXRhLCB1bnNpZ25lZCBwb3Np dGlvbikgY29uCiAjZW5kaWYKIH0KIAordm9pZCBTaGFyZWRCdWZmZXI6Om1heWJlVHJhbnNmZXJN YXBwZWRGaWxlRGF0YSgpCit7CisgICAgaWYgKG1fZmlsZURhdGEpIHsKKyAgICAgICAgYXV0byBm aWxlRGF0YSA9IFdURjo6bW92ZShtX2ZpbGVEYXRhKTsKKyAgICAgICAgYXBwZW5kKHN0YXRpY19j YXN0PGNvbnN0IGNoYXIqPihmaWxlRGF0YS5kYXRhKCkpLCBmaWxlRGF0YS5zaXplKCkpOworICAg IH0KK30KKworUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK3sKKyAgICBsb25nIGxvbmcgc2l6 ZTsKKyAgICBpZiAoIWdldEZpbGVTaXplKGZpbGVQYXRoLCBzaXplKSkKKyAgICAgICAgcmV0dXJu IG51bGxwdHI7CisgICAgaWYgKCFzaXplKQorICAgICAgICByZXR1cm4gU2hhcmVkQnVmZmVyOjpj cmVhdGUoKTsKKyAgICByZXR1cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihNYXBwZWRGaWxl RGF0YShmaWxlUGF0aCkpKTsKK30KKwogI2lmICFVU0UoQ0YpICYmICFVU0UoU09VUCkKIAogaW5s aW5lIHZvaWQgU2hhcmVkQnVmZmVyOjpjbGVhclBsYXRmb3JtRGF0YSgpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1NoYXJlZEJ1ZmZlci5oCmluZGV4IGJjZjM1NTNlZDYwZWNmOWUxMDhiOTJhZjU3MTE0 MTE3MDgwMzVlYTEuLmFlOGJhNDM0NDQwZGVjYzMwZTBhZDAxNjM2NzBmM2YxMGMwOGY3NTUgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oCkBAIC0yNyw2ICsyNyw3IEBACiAj aWZuZGVmIFNoYXJlZEJ1ZmZlcl9oCiAjZGVmaW5lIFNoYXJlZEJ1ZmZlcl9oCiAKKyNpbmNsdWRl ICJGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSA8cnVudGltZS9BcnJheUJ1ZmZlci5oPgogI2luY2x1 ZGUgPHd0Zi9Gb3J3YXJkLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KQEAgLTU1LDcg KzU2LDcgQEAgcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY3Jl YXRlKGNvbnN0IGNoYXIqIGMsIHVuc2lnbmVkIGkpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBTaGFy ZWRCdWZmZXIoYywgaSkpOyB9CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBj cmVhdGUoY29uc3QgdW5zaWduZWQgY2hhciogYywgdW5zaWduZWQgaSkgeyByZXR1cm4gYWRvcHRS ZWYobmV3IFNoYXJlZEJ1ZmZlcihjLCBpKSk7IH0KIAotICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRp YyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0 IFN0cmluZyYgZmlsZVBhdGgpOworICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBSZWZQdHI8U2hh cmVkQnVmZmVyPiBjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0 aCk7CiAKICAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+ IGFkb3B0VmVjdG9yKFZlY3RvcjxjaGFyPiYgdmVjdG9yKTsKICAgICAKQEAgLTkyLDcgKzkzLDcg QEAgcHVibGljOgogICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQgYXBwZW5kKGNvbnN0IGNoYXIqLCB1 bnNpZ25lZCk7CiAgICAgdm9pZCBhcHBlbmQoY29uc3QgVmVjdG9yPGNoYXI+Jik7CiAKLSAgICB2 b2lkIGNsZWFyKCk7CisgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBjbGVhcigpOwogICAgIGNvbnN0 IGNoYXIqIHBsYXRmb3JtRGF0YSgpIGNvbnN0OwogICAgIHVuc2lnbmVkIHBsYXRmb3JtRGF0YVNp emUoKSBjb25zdDsKIApAQCAtMTAxLDcgKzEwMiw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGFwcGVu ZChDRkRhdGFSZWYpOwogI2VuZGlmCiAKLSAgICBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY29w eSgpIGNvbnN0OworICAgIFdFQkNPUkVfRVhQT1JUIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBj b3B5KCkgY29uc3Q7CiAgICAgCiAgICAgLy8gUmV0dXJuIHRoZSBudW1iZXIgb2YgY29uc2VjdXRp dmUgYnl0ZXMgYWZ0ZXIgInBvc2l0aW9uIi4gImRhdGEiCiAgICAgLy8gcG9pbnRzIHRvIHRoZSBm aXJzdCBieXRlLgpAQCAtMTI5LDcgKzEzMCw4IEBAIHByaXZhdGU6CiAgICAgZXhwbGljaXQgU2hh cmVkQnVmZmVyKHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRCdWZmZXIoY29u c3QgY2hhciosIHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRCdWZmZXIoY29u c3QgdW5zaWduZWQgY2hhciosIHVuc2lnbmVkKTsKLSAgICAKKyAgICBTaGFyZWRCdWZmZXIoTWFw cGVkRmlsZURhdGEmJik7CisKICAgICAvLyBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gd2lsbCBmb3Jj ZSBpbnRlcm5hbCBzZWdtZW50ZWQgYnVmZmVycwogICAgIC8vIHRvIGJlIG1lcmdlZCBpbnRvIGEg ZmxhdCBidWZmZXIuIFVzZSBnZXRTb21lRGF0YSgpIHdoZW5ldmVyIHBvc3NpYmxlCiAgICAgLy8g Zm9yIGJldHRlciBwZXJmb3JtYW5jZS4KQEAgLTEzOSw2ICsxNDEsOCBAQCBwcml2YXRlOgogICAg IHZvaWQgbWF5YmVUcmFuc2ZlclBsYXRmb3JtRGF0YSgpOwogICAgIGJvb2wgbWF5YmVBcHBlbmRQ bGF0Zm9ybURhdGEoU2hhcmVkQnVmZmVyKik7CiAKKyAgICB2b2lkIG1heWJlVHJhbnNmZXJNYXBw ZWRGaWxlRGF0YSgpOworCiAgICAgdm9pZCBjb3B5QnVmZmVyQW5kQ2xlYXIoY2hhciogZGVzdGlu YXRpb24sIHVuc2lnbmVkIGJ5dGVzVG9Db3B5KSBjb25zdDsKIAogICAgIHZvaWQgYXBwZW5kVG9E YXRhQnVmZmVyKGNvbnN0IGNoYXIgKiwgdW5zaWduZWQpIGNvbnN0OwpAQCAtMTY3LDYgKzE3MSw4 IEBAIHByaXZhdGU6CiAgICAgZXhwbGljaXQgU2hhcmVkQnVmZmVyKFNvdXBCdWZmZXIqKTsKICAg ICBHVW5pcXVlUHRyPFNvdXBCdWZmZXI+IG1fc291cEJ1ZmZlcjsKICNlbmRpZgorCisgICAgTWFw cGVkRmlsZURhdGEgbV9maWxlRGF0YTsKIH07CiAKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiB1 dGY4QnVmZmVyKGNvbnN0IFN0cmluZyYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvU2hhcmVkQnVmZmVyR3RrLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWQ4 ZGU0NzE2NDNkMzAwNjI1NzZkOWQyMDA4NGQ0YTU3ZjFkZWUxMy4uMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv U2hhcmVkQnVmZmVyR3RrLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDUwICswLDAgQEAKLS8qCi0g KiBDb3B5cmlnaHQgKEMpIDIwMDggQ29sbGFib3JhIEx0ZC4KLSAqCi0gKiAgVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgotICogIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMK LSAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u OyBlaXRoZXIKLSAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogIGJ1dCBXSVRIT1VUIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAgTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKLSAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCi0gKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg aWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQotICogIEZvdW5kYXRpb24sIEluYy4s IDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEg IFVTQQotICovCi0KLSNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJTaGFyZWRCdWZmZXIu aCIKLQotI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKLSNpbmNsdWRlIDx3dGYvZ29iamVjdC9HVW5p cXVlUHRyLmg+Ci0jaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgotCi0jaW5jbHVkZSA8Z2xp Yi5oPgotCi0KLW5hbWVzcGFjZSBXZWJDb3JlIHsKLQotUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+ IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmls ZVBhdGgpCi17Ci0gICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKLSAgICAgICAgcmV0dXJuIDA7 Ci0KLSAgICBDU3RyaW5nIGZpbGVuYW1lID0gZmlsZVN5c3RlbVJlcHJlc2VudGF0aW9uKGZpbGVQ YXRoKTsKLSAgICBHVW5pcXVlT3V0UHRyPGdjaGFyPiBjb250ZW50czsKLSAgICBnc2l6ZSBzaXpl OwotICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKLSAgICBpZiAoIWdfZmlsZV9nZXRf Y29udGVudHMoZmlsZW5hbWUuZGF0YSgpLCAmY29udGVudHMub3V0UHRyKCksICZzaXplLCAmZXJy b3Iub3V0UHRyKCkpKSB7Ci0gICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRvIGZ1bGx5IHJlYWQg Y29udGVudHMgb2YgZmlsZSAlcyAtICVzIiwgZmlsZW5hbWVGb3JEaXNwbGF5KGZpbGVQYXRoKS51 dGY4KCkuZGF0YSgpLCBlcnJvci0+bWVzc2FnZSk7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0K LQotICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IHJlc3VsdCA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRl KGNvbnRlbnRzLmdldCgpLCBzaXplKTsKLQotICAgIHJldHVybiByZXN1bHQucmVsZWFzZSgpOwot fQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1tIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bWFjL1NoYXJlZEJ1ZmZlck1hYy5tbQppbmRleCBlYTQ4MmYwNmYwODE2OGE5YWZkNThjNmQwMGFi NWNmMGIzM2UwNTQ3Li4wOWI1YmMwMWQwYjdmOWIyM2E4MjhhYTFlOTAyNWQ0ZmUyYjQzMmY1IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1t CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0KQEAg LTEyMiwxMiArMTIyLDQgQEAgUmV0YWluUHRyPENGRGF0YVJlZj4gU2hhcmVkQnVmZmVyOjpjcmVh dGVDRkRhdGEoKQogICAgIHJldHVybiBhZG9wdENGKChDRkRhdGFSZWYpYWRvcHROUyhbW1dlYkNv cmVTaGFyZWRCdWZmZXJEYXRhIGFsbG9jXSBpbml0V2l0aFNoYXJlZEJ1ZmZlckRhdGFCdWZmZXI6 bV9idWZmZXIuZ2V0KCldKS5sZWFrUmVmKCkpOwogfQogCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZl cj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBm aWxlUGF0aCkKLXsKLSAgICBOU0RhdGEgKnJlc291cmNlRGF0YSA9IFtOU0RhdGEgZGF0YVdpdGhD b250ZW50c09mRmlsZTpmaWxlUGF0aF07Ci0gICAgaWYgKHJlc291cmNlRGF0YSkgCi0gICAgICAg IHJldHVybiBTaGFyZWRCdWZmZXI6OndyYXBOU0RhdGEocmVzb3VyY2VEYXRhKTsKLSAgICByZXR1 cm4gMDsKLX0KLQogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcG9zaXgv U2hhcmVkQnVmZmVyUE9TSVguY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcG9zaXgvU2hh cmVkQnVmZmVyUE9TSVguY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBlNzdiOGVj ZjA2ZjliYzljMGU1ZmZhMWJkYTA3ZDg2MjE0Mjg1YmQ0Li4wMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Bvc2l4L1No YXJlZEJ1ZmZlclBPU0lYLmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDcyICswLDAgQEAKLS8qCi0g KiBDb3B5cmlnaHQgKEMpIDIwMTAgQ29tcGFueSAxMDAsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gYGBBUyBJUycnIEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCi0gKiBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKLSAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCi0gKiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwKLSAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKLSAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgotICogUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQot ICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKLSAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2luY2x1ZGUg ImNvbmZpZy5oIgotI2luY2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgotCi0jaW5jbHVkZSAiRmlsZVN5 c3RlbS5oIgotCi0jaW5jbHVkZSA8ZmNudGwuaD4KLSNpbmNsdWRlIDxzeXMvc3RhdC5oPgotI2lu Y2x1ZGUgPHVuaXN0ZC5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KLQotbmFtZXNw YWNlIFdlYkNvcmUgewotCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpj cmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKLXsKLSAgICBp ZiAoZmlsZVBhdGguaXNFbXB0eSgpKQotICAgICAgICByZXR1cm4gMDsKLQotICAgIENTdHJpbmcg ZmlsZW5hbWUgPSBmaWxlU3lzdGVtUmVwcmVzZW50YXRpb24oZmlsZVBhdGgpOwotICAgIGludCBm ZCA9IG9wZW4oZmlsZW5hbWUuZGF0YSgpLCBPX1JET05MWSk7Ci0gICAgaWYgKGZkID09IC0xKQot ICAgICAgICByZXR1cm4gMDsKLQotICAgIHN0cnVjdCBzdGF0IGZpbGVTdGF0OwotICAgIGlmIChm c3RhdChmZCwgJmZpbGVTdGF0KSkgewotICAgICAgICBjbG9zZShmZCk7Ci0gICAgICAgIHJldHVy biAwOwotICAgIH0KLQotICAgIHNpemVfdCBieXRlc1RvUmVhZCA9IGZpbGVTdGF0LnN0X3NpemU7 Ci0gICAgaWYgKGZpbGVTdGF0LnN0X3NpemUgPCAwIHx8IGJ5dGVzVG9SZWFkICE9IHN0YXRpY19j YXN0PHVuc2lnbmVkIGxvbmcgbG9uZz4oZmlsZVN0YXQuc3Rfc2l6ZSkpIHsKLSAgICAgICAgY2xv c2UoZmQpOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0KLSAgICBWZWN0b3I8Y2hhcj4gYnVm ZmVyKGJ5dGVzVG9SZWFkKTsKLQotICAgIHNpemVfdCB0b3RhbEJ5dGVzUmVhZCA9IDA7Ci0gICAg c3NpemVfdCBieXRlc1JlYWQ7Ci0gICAgd2hpbGUgKChieXRlc1JlYWQgPSByZWFkKGZkLCBidWZm ZXIuZGF0YSgpICsgdG90YWxCeXRlc1JlYWQsIGJ5dGVzVG9SZWFkIC0gdG90YWxCeXRlc1JlYWQp KSA+IDApCi0gICAgICAgIHRvdGFsQnl0ZXNSZWFkICs9IGJ5dGVzUmVhZDsKLQotICAgIGNsb3Nl KGZkKTsKLQotICAgIHJldHVybiB0b3RhbEJ5dGVzUmVhZCA9PSBieXRlc1RvUmVhZCA/IFNoYXJl ZEJ1ZmZlcjo6YWRvcHRWZWN0b3IoYnVmZmVyKSA6IDA7Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZm ZXJXaW4uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5j cHAKaW5kZXggZjVkZDIyODQ2NDE5YTBmMmQ5Nzg1YjlhNjljZGY5MDliYzM5MWQ3MC4uNjA1NDY3 MTM0MjdlZWRkYTZiMWI1Y2Y0ZjBiY2Q2OGEzYzM1MGRkMiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKQEAgLTMzLDggKzMzLDkgQEAKIAog bmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVm ZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK1Jl ZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxl KGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCiB7CisgICAgLy8gRklYTUU6IFVzZSBtYXAgZmlsZSBy b3V0aW5lcy4KICAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQogICAgICAgICByZXR1cm4gMDsK IApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDEy ZWRlOGM0Y2QwNGY5ODU0ZWM5ZjNhMDkzMjczZjc3ZDExODQ0NDkuLmRhNjAxODFkMzQ2MDZkYzFl ODI0YTA3MjAxYzRjZTg0YTIxZjBmNDIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysg Yi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxNS0wNS0wNCAgWW91ZW5uIEZh YmxldCAgPHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgorCisgICAgICAgIFNoYXJlZEJ1ZmZl cjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlIHNob3VsZCB1c2UgbWFwIGZpbGUgcm91dGluZXMK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NDE5Mgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGluZyBT aGFyZWRCdWZmZXIgYW5kIEZpbGVTeXN0ZW0gVW5pdCB0ZXN0cyB0byBNYWMgYW5kIEdUSywgbm90 IHlldCBmb3IgRUZMLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUdUSy5jbWFr ZToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2Vi S2l0QVBJLnZjeHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnZj eHByb2ovVGVzdFdlYktpdEFQSS52Y3hwcm9qLmZpbHRlcnM6CisgICAgICAgICogVGVzdFdlYktp dEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICog VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0ZpbGVTeXN0ZW0uY3BwOiBBZGRlZC4KKyAgICAg ICAgKFRlc3RXZWJLaXRBUEk6OkZpbGVTeXN0ZW1UZXN0Ojp0ZW1wRmlsZVBhdGgpOgorICAgICAg ICAoVGVzdFdlYktpdEFQSTo6VEVTVF9GKToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYkNvcmUvU2hhcmVkQnVmZmVyLmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJ OjpTaGFyZWRCdWZmZXJUZXN0Ojp0ZW1wRmlsZVBhdGgpOgorICAgICAgICAoVGVzdFdlYktpdEFQ STo6U2hhcmVkQnVmZmVyVGVzdDo6dGVtcEVtcHR5RmlsZVBhdGgpOgorICAgICAgICAoVGVzdFdl YktpdEFQSTo6VEVTVF9GKToKKwogMjAxNS0wNS0wNCAgSm9vbmdodW4gUGFyayAgPGpoNzE4LnBh cmtAc2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0dUS10gQWRkIGxpYm5vdGlmeSBpbiBndGsgaW5z dGFsbC1kZXBlbmRlbmNpZXMKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZv cm1HVEsuY21ha2UgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4 IGNmYzBkODc3YmUxYmQ0MDE4MjJlOTI1NWEyMDAxYWVkMzEwMzBjYWEuLmUwNzk3OTNhYTFmNzA3 NWY3N2UyZTUxZjVkOWU1YTVkYjc5NWFmYTcgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUdU Sy5jbWFrZQpAQCAtMTEsNiArMTEsNyBAQCBzZXQoRm9yd2FyZGluZ0hlYWRlcnNGb3JUZXN0V2Vi S2l0QVBJX05BTUUgVGVzdFdlYktpdEFQSS1mb3J3YXJkaW5nLWhlYWRlcnMpCiAKIGluY2x1ZGVf ZGlyZWN0b3JpZXMoCiAgICAgJHtGT1JXQVJESU5HX0hFQURFUlNfRElSfQorICAgICR7Rk9SV0FS RElOR19IRUFERVJTX0RJUn0vSmF2YVNjcmlwdENvcmUKICAgICAke1dFQktJVDJfRElSfS9VSVBy b2Nlc3MvQVBJL0Mvc291cAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvQy9ndGsK ICAgICAke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvQVBJL2d0awpAQCAtMTIyLDYgKzEyMyw4IEBA IGFkZF9leGVjdXRhYmxlKFRlc3RXZWJDb3JlCiAgICAgJHtURVNUV0VCS0lUQVBJX0RJUn0vVGVz dHNDb250cm9sbGVyLmNwcAogICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzL1dlYkNvcmUv TGF5b3V0VW5pdC5jcHAKICAgICAke1RFU1RXRUJLSVRBUElfRElSfS9UZXN0cy9XZWJDb3JlL1VS TC5jcHAKKyAgICAke1RFU1RXRUJLSVRBUElfRElSfS9UZXN0cy9XZWJDb3JlL1NoYXJlZEJ1ZmZl ci5jcHAKKyAgICAke1RFU1RXRUJLSVRBUElfRElSfS9UZXN0cy9XZWJDb3JlL0ZpbGVTeXN0ZW0u Y3BwCiApCiAKIHRhcmdldF9saW5rX2xpYnJhcmllcyhUZXN0V2ViQ29yZSAke3Rlc3Rfd2ViY29y ZV9MSUJSQVJJRVN9KQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0 QVBJLnZjeHByb2ovVGVzdFdlYktpdEFQSS52Y3hwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0V2ViS2l0QVBJLnZjeHByb2ovVGVzdFdlYktpdEFQSS52Y3hwcm9qCmluZGV4IGJjZmVhNDA5 ZDU0M2RkMTA4OTgwNDczOWZlNGVmYjdhYTJhZWNjMGIuLjU2ZmJmMDYyMThlYjU2MzkwM2MyMzZh ZTgxYTcyMWQwMWM2MTczYzMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdl YktpdEFQSS52Y3hwcm9qL1Rlc3RXZWJLaXRBUEkudmN4cHJvagorKysgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2ViS2l0QVBJLnZjeHByb2oKQEAgLTI5 Myw3ICsyOTMsOSBAQAogICAgIDxDbENvbXBpbGUgSW5jbHVkZT0iLi5cVGVzdHNDb250cm9sbGVy LmNwcCIgLz4KICAgICA8Q2xDb21waWxlIEluY2x1ZGU9Ii4uXFRlc3RzXFdlYkNvcmVcQ2FsY3Vs YXRpb25WYWx1ZS5jcHAiIC8+CiAgICAgPENsQ29tcGlsZSBJbmNsdWRlPSIuLlxUZXN0c1xXZWJD b3JlXENTU1BhcnNlci5jcHAiIC8+CisgICAgPENsQ29tcGlsZSBJbmNsdWRlPSIuLlxUZXN0c1xX ZWJDb3JlXEZpbGVTeXN0ZW0uY3BwIiAvPgogICAgIDxDbENvbXBpbGUgSW5jbHVkZT0iLi5cVGVz dHNcV2ViQ29yZVxMYXlvdXRVbml0LmNwcCIgLz4KKyAgICA8Q2xDb21waWxlIEluY2x1ZGU9Ii4u XFRlc3RzXFdlYkNvcmVcU2hhcmVkQnVmZmVyLmNwcCIgLz4KICAgICA8Q2xDb21waWxlIEluY2x1 ZGU9Ii4uXFRlc3RzXFdlYkNvcmVcVGltZVJhbmdlcy5jcHAiIC8+CiAgICAgPENsQ29tcGlsZSBJ bmNsdWRlPSIuLlxUZXN0c1xXZWJDb3JlXFVSTC5jcHAiIC8+CiAgICAgPENsQ29tcGlsZSBJbmNs dWRlPSIuLlxUZXN0c1xXZWJDb3JlXHdpblxCaXRtYXBJbWFnZS5jcHAiPgpAQCAtMzY0LDQgKzM2 Niw0IEBACiAgIDxJbXBvcnQgUHJvamVjdD0iJChWQ1RhcmdldHNQYXRoKVxNaWNyb3NvZnQuQ3Bw LnRhcmdldHMiIC8+CiAgIDxJbXBvcnRHcm91cCBMYWJlbD0iRXh0ZW5zaW9uVGFyZ2V0cyI+CiAg IDwvSW1wb3J0R3JvdXA+Ci08L1Byb2plY3Q+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQor PC9Qcm9qZWN0PgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJ LnZjeHByb2ovVGVzdFdlYktpdEFQSS52Y3hwcm9qLmZpbHRlcnMgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2ViS2l0QVBJLnZjeHByb2ouZmlsdGVycwpp bmRleCAxMGNkM2U3ZmIxZGIxNjE5ZDUzMTBkYWQ0NTg3NWQ2MjdhZDg3MWFiLi5lOWU3MTM0ZmI5 MDlkMDMxYmVlN2Y1YmQwZGRiMGNkNWEyYjM5MWFhIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2ViS2l0QVBJLnZjeHByb2ouZmlsdGVy cworKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkudmN4cHJvai9UZXN0V2Vi S2l0QVBJLnZjeHByb2ouZmlsdGVycwpAQCAtMTYzLDYgKzE2MywxMiBAQAogICAgIDxDbENvbXBp bGUgSW5jbHVkZT0iLi5cVGVzdHNcV2ViQ29yZVxDU1NQYXJzZXIuY3BwIj4KICAgICAgIDxGaWx0 ZXI+VGVzdHNcV2ViQ29yZTwvRmlsdGVyPgogICAgIDwvQ2xDb21waWxlPgorICAgIDxDbENvbXBp bGUgSW5jbHVkZT0iLi5cVGVzdHNcV2ViQ29yZVxGaWxlU3lzdGVtLmNwcCI+CisgICAgICA8Rmls dGVyPlRlc3RzXFdlYkNvcmU8L0ZpbHRlcj4KKyAgICA8L0NsQ29tcGlsZT4KKyAgICA8Q2xDb21w aWxlIEluY2x1ZGU9Ii4uXFRlc3RzXFdlYkNvcmVcU2hhcmVkQnVmZmVyLmNwcCI+CisgICAgICA8 RmlsdGVyPlRlc3RzXFdlYkNvcmU8L0ZpbHRlcj4KKyAgICA8L0NsQ29tcGlsZT4KICAgICA8Q2xD b21waWxlIEluY2x1ZGU9Ii4uXFRlc3RzXFdURlxXb3JrUXVldWUuY3BwIj4KICAgICAgIDxGaWx0 ZXI+VGVzdHNcV1RGPC9GaWx0ZXI+CiAgICAgPC9DbENvbXBpbGU+CkBAIC0xNzQsNCArMTgwLDQg QEAKICAgICA8Tm9uZSBJbmNsdWRlPSJUZXN0V2ViS2l0QVBJUG9zdEJ1aWxkLmNtZCIgLz4KICAg ICA8Tm9uZSBJbmNsdWRlPSJUZXN0V2ViS2l0QVBJUHJlQnVpbGQuY21kIiAvPgogICA8L0l0ZW1H cm91cD4KLTwvUHJvamVjdD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCis8L1Byb2plY3Q+ CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDZmMGNkZGEzNzk3NDI0NmU0YjE5Yzg1NThiYTUw NmFmNmIxNDRhNGEuLjQ2OGVlNWUyZjk1M2QyYWJhNzg5MzU4YzBjOWFkMDg3OTdlNDM0NDAgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC00NCw2ICs0NCw4IEBACiAJCTM3RDM2RUQ3MUFGNDJF Q0QwMEJBRjVEOSAvKiBMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbSBpbiBTb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDM3RDM2RUQ2MUFGNDJFQ0QwMEJBRjVEOSAv KiBMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbSAqLzsgfTsKIAkJMzdEQzY3OTExNDBEN0Q3NjAw QUJDQ0RCIC8qIERPTVJhbmdlT2ZTdHJpbmcuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzN0RDNjc4RjE0MEQ3RDNBMDBBQkNDREIgLyog RE9NUmFuZ2VPZlN0cmluZy5odG1sICovOyB9OwogCQkzN0UxMDY0QzE2OTc2ODE4MDBCNzhCRDAg LyogRE9NSFRNTFRhYmxlQ2VsbEVsZW1lbnRDZWxsQWJvdmUuaHRtbCBpbiBDb3B5IFJlc291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzN0UxMDY0QjE2OTc2N0Y3MDBC NzhCRDAgLyogRE9NSFRNTFRhYmxlQ2VsbEVsZW1lbnRDZWxsQWJvdmUuaHRtbCAqLzsgfTsKKwkJ NDE5NzNCNUIxQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3BwIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDE5NzNCNUExQUYyMjg2QTAwNkM3QjM2 IC8qIEZpbGVTeXN0ZW0uY3BwICovOyB9OworCQk0MTk3M0I1RDFBRjIyODc1MDA2QzdCMzYgLyog U2hhcmVkQnVmZmVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDQxOTczQjVDMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRCdWZmZXIuY3BwICovOyB9 OwogCQk0QkZERkZBNzEzMTQ3NzZDMDA2MUYyNEIgLyogSGl0VGVzdFJlc3VsdE5vZGVIYW5kbGVf QnVuZGxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDRCRkRGRkE2MTMxNDc3NkMwMDYxRjI0QiAvKiBIaXRUZXN0UmVzdWx0Tm9kZUhhbmRsZV9CdW5k bGUuY3BwICovOyB9OwogCQk1MTM5M0UyMjE1MjM5NTJEMDA1RjM5QzUgLyogRE9NV2luZG93RXh0 ZW5zaW9uQmFzaWNfQnVuZGxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDUxMzkzRTFEMTUyMzk0NEEwMDVGMzlDNSAvKiBET01XaW5kb3dFeHRlbnNp b25CYXNpY19CdW5kbGUuY3BwICovOyB9OwogCQk1MTQyQjI3MzE1MTdDOEM4MDBDMzJCMTkgLyog Q29udGV4dE1lbnVDYW5Db3B5VVJMLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE0MkIyNzIxNTE3Qzg5MTAwQzMyQjE5IC8qIENvbnRl eHRNZW51Q2FuQ29weVVSTC5odG1sICovOyB9OwpAQCAtNDk0LDYgKzQ5Niw4IEBACiAJCTM3RTEw NjRBMTY5NzY3NjQwMEI3OEJEMCAvKiBET01IVE1MVGFibGVDZWxsQ2VsbEFib3ZlLm1tICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gRE9NSFRNTFRhYmxlQ2VsbENlbGxB Ym92ZS5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMzdFMTA2NEIxNjk3NjdGNzAw Qjc4QkQwIC8qIERPTUhUTUxUYWJsZUNlbGxFbGVtZW50Q2VsbEFib3ZlLmh0bWwgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSB0ZXh0Lmh0bWw7IHBhdGggPSBET01IVE1MVGFibGVDZWxsRWxlbWVudENlbGxBYm92ZS5odG1s OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkzN0UzOEMzMzE2OUI3RDAxMDA4NEMyOEMg LyogV2ViVmlld0RpZFJlbW92ZUZyYW1lRnJvbUhpZXJhcmNoeS5tbSAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdlYlZpZXdEaWRSZW1vdmVGcmFtZUZyb21IaWVyYXJj aHkubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQxOTczQjVBMUFGMjI4NkEwMDZD N0IzNiAvKiBGaWxlU3lzdGVtLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IEZpbGVTeXN0ZW0uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0MTk3M0I1 QzFBRjIyODc1MDA2QzdCMzYgLyogU2hhcmVkQnVmZmVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IFNoYXJlZEJ1ZmZlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTQ0MEExRDM4MTRBMDEwM0EwMDhBNjZGMiAvKiBVUkwuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gVVJMLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJNDRBNjIyQzExNEEwRTJCNjAwNDg1MTVCIC8qIFdURlN0cmluZ1V0aWxpdGllcy5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXVEZTdHJpbmdVdGlsaXRpZXMuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNEE0MTBGNEIxOUFGN0JENjAwMkVCQUI1IC8q IFVzZXJNZWRpYS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBVc2Vy TWVkaWEuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNzY0LDYgKzc2OCw3IEBA CiAJCTA4RkI3Nzk1RkU4NDE1NURDMDJBQUMwNyAvKiBTb3VyY2UgKi8gPSB7CiAJCQlpc2EgPSBQ QlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAorCQkJCTQ0QTgyRTdCMTkyNTFCMzUwMEMxQzhDNCAv KiBDb2NvYSAqLywKIAkJCQkwRjEzOUU3MTFBNDIzQTFEMDBGNTkwRjUgLyogY29jb2EgKi8sCiAJ CQkJQkM1NzU5NDQxMjZFNzMzQzAwNkYwRjEyIC8qIEluamVjdGVkQnVuZGxlICovLAogCQkJCTJF OTY2MERDMTZDMDdEN0IwMDM3MUI0MiAvKiBpb3MgKi8sCkBAIC04NTUsNyArODYwLDkgQEAKIAkJ CQk3Q0IxODRDNDFBQTNGMjEwMDA2NkVERkQgLyogQ29udGVudEV4dGVuc2lvbnMuY3BwICovLAog CQkJCUNENTQ1MUU5MTlFNDFGOUQwMDE2OTM2RiAvKiBDU1NQYXJzZXIuY3BwICovLAogCQkJCTI2 RjZFMUVGMUFEQzc0OUIwMERFNjk2QiAvKiBERkFNaW5pbWl6ZXIuY3BwICovLAorCQkJCTQxOTcz QjVBMUFGMjI4NkEwMDZDN0IzNiAvKiBGaWxlU3lzdGVtLmNwcCAqLywKIAkJCQkxNDQ2NDAxMjE2 N0E4MzA1MDAwQkQyMTggLyogTGF5b3V0VW5pdC5jcHAgKi8sCisJCQkJNDE5NzNCNUMxQUYyMjg3 NTAwNkM3QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgKi8sCiAJCQkJQ0RDMkM3MTQxNzk3MDg5RDAw RTYyN0ZCIC8qIFRpbWVSYW5nZXMuY3BwICovLAogCQkJCTQ0MEExRDM4MTRBMDEwM0EwMDhBNjZG MiAvKiBVUkwuY3BwICovLAogCQkJKTsKQEAgLTg2Nyw3ICs4NzQsOCBAQAogCQkJY2hpbGRyZW4g PSAoCiAJCQkJOTNBN0VCM0MxOEZBNjNBNDAwOUU3NjcwIC8qIFVSTEV4dHJhcy5tbSAqLywKIAkJ CSk7Ci0JCQlwYXRoID0gQ29jb2E7CisJCQluYW1lID0gQ29jb2E7CisJCQlwYXRoID0gVGVzdHMv Q29jb2E7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwogCQl9OwogCQk3NTYwOTE3NjE5MjU5 QzU5MDA5RUYwNkUgLyogaW9zICovID0gewpAQCAtMTE1Niw3ICsxMTY0LDYgQEAKIAkJQkNCOUVC NjYxMTIzNjZEODAwQTEzN0UwIC8qIFRlc3RzICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJ CQljaGlsZHJlbiA9ICgKLQkJCQk0NEE4MkU3QjE5MjUxQjM1MDBDMUM4QzQgLyogQ29jb2EgKi8s CiAJCQkJNzU2MDkxNzYxOTI1OUM1OTAwOUVGMDZFIC8qIGlvcyAqLywKIAkJCQlGRTIxN0VDQjE2 NDBBNTRBMDA1Mjk4OEIgLyogSmF2YVNjcmlwdENvcmUgKi8sCiAJCQkJQzA3RTZDQUQxM0ZENjc2 NTAwMzhCMjJCIC8qIG1hYyAqLywKQEAgLTE1ODksOCArMTU5NiwxMCBAQAogCQkJCTJEMUZFMEIw MUFENDY1QzEwMDZDRDlFNiAvKiBGaXhlZExheW91dFNpemUubW0gaW4gU291cmNlcyAqLywKIAkJ CQkxQ0I5QkMzODFBNjc0ODIzMDBGRTU2NzggLyogV2Vha1B0ci5jcHAgaW4gU291cmNlcyAqLywK IAkJCQkyRTc3NjVDRDE2QzREODBBMDBCQTJCQjEgLyogbWFpbklPUy5tbSBpbiBTb3VyY2VzICov LAorCQkJCTQxOTczQjVEMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRCdWZmZXIuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJN0FBNkExNTIxQUFDMEIzMTAwMkIyRUQzIC8qIFdvcmtRdWV1ZS5jcHAg aW4gU291cmNlcyAqLywKIAkJCQkyRTc3NjVDRjE2QzREODExMDBCQTJCQjEgLyogbWFpbk1hYy5t bSBpbiBTb3VyY2VzICovLAorCQkJCTQxOTczQjVCMUFGMjI4NkEwMDZDN0IzNiAvKiBGaWxlU3lz dGVtLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdBNTYyMzExMUFENUFGM0UwMDk2QjkyMCAvKiBN ZW51VHlwZXNGb3JNb3VzZUV2ZW50cy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkyNkY2RTFGMDFB REM3NDlCMDBERTY5NkIgLyogREZBTWluaW1pemVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdB OTlEOTk0MUFENEEyOUQwMDM3MzE0MSAvKiBNZW51VHlwZXNGb3JNb3VzZUV2ZW50cy5tbSBpbiBT b3VyY2VzICovLApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3Jl L0ZpbGVTeXN0ZW0uY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0ZpbGVT eXN0ZW0uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjYxN2UxZGI1NGU2YWZhZDliYWJjZDlmYWIxNTE2YmZjZmZj OGY3OTAKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNv cmUvRmlsZVN5c3RlbS5jcHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxNSBDYW5vbiBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4g UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JT IGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05U UklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRF IEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwg T1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKworI2luY2x1ZGUgIlRlc3QuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL0ZpbGVT eXN0ZW0uaD4KKyNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgorI2luY2x1ZGUgPHd0Zi9TdHJp bmdFeHRyYXMuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBUZXN0 V2ViS2l0QVBJIHsKKworY29uc3QgY2hhciogRmlsZVN5c3RlbVRlc3REYXRhID0gIlRoaXMgaXMg YSB0ZXN0IjsKKworLy8gRklYTUU6IFJlZmFjdG9yIEZpbGVTeXN0ZW1UZXN0IGFuZCBTaGFyZWRC dWZmZXJUZXN0IGFzIGEgc2luZ2xlIGNsYXNzLgorY2xhc3MgRmlsZVN5c3RlbVRlc3QgOiBwdWJs aWMgdGVzdGluZzo6VGVzdCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2b2lkIFNldFVwKCkgb3Zl cnJpZGUKKyAgICB7CisgICAgICAgIFdURjo6aW5pdGlhbGl6ZU1haW5UaHJlYWQoKTsKKyAgICAg ICAgCisgICAgICAgIC8vIGNyZWF0ZSB0ZW1wIGZpbGUKKyAgICAgICAgUGxhdGZvcm1GaWxlSGFu ZGxlIGhhbmRsZTsKKyAgICAgICAgbV90ZW1wRmlsZVBhdGggPSBvcGVuVGVtcG9yYXJ5RmlsZSgi dGVtcFRlc3RGaWxlIiwgaGFuZGxlKTsKKyAgICAgICAgd3JpdGVUb0ZpbGUoaGFuZGxlLCBGaWxl U3lzdGVtVGVzdERhdGEsIHN0cmxlbihGaWxlU3lzdGVtVGVzdERhdGEpKTsKKyAgICAgICAgY2xv c2VGaWxlKGhhbmRsZSk7IAorCisgICAgICAgIG1fdGVtcEVtcHR5RmlsZVBhdGggPSBvcGVuVGVt cG9yYXJ5RmlsZSgidGVtcEVtcHR5VGVzdEZpbGUiLCBoYW5kbGUpOworICAgICAgICBjbG9zZUZp bGUoaGFuZGxlKTsgCisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIFRlYXJEb3duKCkgb3ZlcnJp ZGUKKyAgICB7CisgICAgICAgIGRlbGV0ZUZpbGUobV90ZW1wRmlsZVBhdGgpOworICAgICAgICBk ZWxldGVGaWxlKG1fdGVtcEVtcHR5RmlsZVBhdGgpOworICAgIH0KKworICAgIGNvbnN0IFN0cmlu ZyYgdGVtcEZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRmlsZVBhdGg7IH0KKyAgICBjb25zdCBT dHJpbmcmIHRlbXBFbXB0eUZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRW1wdHlGaWxlUGF0aDsg fQorCitwcml2YXRlOgorICAgIFN0cmluZyBtX3RlbXBGaWxlUGF0aDsKKyAgICBTdHJpbmcgbV90 ZW1wRW1wdHlGaWxlUGF0aDsKK307CisKK1RFU1RfRihGaWxlU3lzdGVtVGVzdCwgTWFwcGluZ01p c3NpbmdGaWxlKQoreworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhKFN0cmluZygi bm90X2V4aXN0aW5nX2ZpbGUiKSk7CisgICAgRVhQRUNUX1RSVUUoIW1hcHBlZEZpbGVEYXRhKTsK K30KKworVEVTVF9GKEZpbGVTeXN0ZW1UZXN0LCBNYXBwaW5nRXhpc3RpbmdGaWxlKQoreworICAg IE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhKHRlbXBGaWxlUGF0aCgpKTsKKyAgICBFWFBF Q1RfVFJVRSghIW1hcHBlZEZpbGVEYXRhKTsKKyAgICBFWFBFQ1RfVFJVRShtYXBwZWRGaWxlRGF0 YS5zaXplKCkgPT0gc3RybGVuKEZpbGVTeXN0ZW1UZXN0RGF0YSkpOworICAgIEVYUEVDVF9UUlVF KHN0cm5zdHIoRmlsZVN5c3RlbVRlc3REYXRhLCBzdGF0aWNfY2FzdDxjb25zdCBjaGFyKj4obWFw cGVkRmlsZURhdGEuZGF0YSgpKSwgbWFwcGVkRmlsZURhdGEuc2l6ZSgpKSk7Cit9CisKK1RFU1Rf RihGaWxlU3lzdGVtVGVzdCwgTWFwcGluZ0V4aXN0aW5nRW1wdHlGaWxlKQoreworICAgIE1hcHBl ZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhKHRlbXBFbXB0eUZpbGVQYXRoKCkpOworICAgIEVYUEVD VF9UUlVFKCFtYXBwZWRGaWxlRGF0YSk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJDb3JlL1NoYXJlZEJ1ZmZlci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMTllOTBiNmQw OGUxMjZmY2ZmYjk1ODdiMDJiNzcyODYxMzJhYmE1OAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0wLDAgKzEs MTE5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgor ICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAq IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiVGVz dC5oIgorI2luY2x1ZGUgPFdlYkNvcmUvU2hhcmVkQnVmZmVyLmg+CisjaW5jbHVkZSA8d3RmL01h aW5UaHJlYWQuaD4KKyNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CisKK3VzaW5nIG5hbWVz cGFjZSBXZWJDb3JlOworCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK2NvbnN0IGNoYXIq IFNoYXJlZEJ1ZmZlclRlc3REYXRhID0gIlRoaXMgaXMgYSB0ZXN0IjsKKworY2xhc3MgU2hhcmVk QnVmZmVyVGVzdCA6IHB1YmxpYyB0ZXN0aW5nOjpUZXN0IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFs IHZvaWQgU2V0VXAoKSBvdmVycmlkZQorICAgIHsKKyAgICAgICAgV1RGOjppbml0aWFsaXplTWFp blRocmVhZCgpOworICAgICAgICAKKyAgICAgICAgLy8gY3JlYXRlIHRlbXAgZmlsZQorICAgICAg ICBQbGF0Zm9ybUZpbGVIYW5kbGUgaGFuZGxlOworICAgICAgICBtX3RlbXBGaWxlUGF0aCA9IG9w ZW5UZW1wb3JhcnlGaWxlKCJ0ZW1wVGVzdEZpbGUiLCBoYW5kbGUpOworICAgICAgICB3cml0ZVRv RmlsZShoYW5kbGUsIFNoYXJlZEJ1ZmZlclRlc3REYXRhLCBzdHJsZW4oU2hhcmVkQnVmZmVyVGVz dERhdGEpKTsKKyAgICAgICAgY2xvc2VGaWxlKGhhbmRsZSk7IAorCisgICAgICAgIG1fdGVtcEVt cHR5RmlsZVBhdGggPSBvcGVuVGVtcG9yYXJ5RmlsZSgidGVtcEVtcHR5VGVzdEZpbGUiLCBoYW5k bGUpOworICAgICAgICBjbG9zZUZpbGUoaGFuZGxlKTsgCisgICAgfQorCisgICAgdmlydHVhbCB2 b2lkIFRlYXJEb3duKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIGRlbGV0ZUZpbGUobV90ZW1w RmlsZVBhdGgpOworICAgICAgICBkZWxldGVGaWxlKG1fdGVtcEVtcHR5RmlsZVBhdGgpOworICAg IH0KKworICAgIGNvbnN0IFN0cmluZyYgdGVtcEZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRmls ZVBhdGg7IH0KKyAgICBjb25zdCBTdHJpbmcmIHRlbXBFbXB0eUZpbGVQYXRoKCkgeyByZXR1cm4g bV90ZW1wRW1wdHlGaWxlUGF0aDsgfQorCitwcml2YXRlOgorICAgIFN0cmluZyBtX3RlbXBGaWxl UGF0aDsKKyAgICBTdHJpbmcgbV90ZW1wRW1wdHlGaWxlUGF0aDsKK307CisKK1RFU1RfRihTaGFy ZWRCdWZmZXJUZXN0LCBjcmVhdGVXaXRoQ29udGVudHNPZk1pc3NpbmdGaWxlKQoreworICAgIFJl ZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRl bnRzT2ZGaWxlKFN0cmluZygibm90X2V4aXN0aW5nX2ZpbGUiKSk7CisgICAgQVNTRVJUX05VTEwo YnVmZmVyKTsKK30KKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNyZWF0ZVdpdGhDb250ZW50 c09mRXhpc3RpbmdGaWxlKQoreworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNo YXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKHRlbXBGaWxlUGF0aCgpKTsKKyAg ICBBU1NFUlRfTk9UX05VTEwoYnVmZmVyKTsKKyAgICBFWFBFQ1RfVFJVRShidWZmZXItPnNpemUo KSA9PSBzdHJsZW4oU2hhcmVkQnVmZmVyVGVzdERhdGEpKTsKKyAgICBFWFBFQ1RfVFJVRShTdHJp bmcoU2hhcmVkQnVmZmVyVGVzdERhdGEpID09IFN0cmluZyhidWZmZXItPmRhdGEoKSwgYnVmZmVy LT5zaXplKCkpKTsKK30KKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNyZWF0ZVdpdGhDb250 ZW50c09mRXhpc3RpbmdFbXB0eUZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVm ZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUodGVtcEVtcHR5Rmls ZVBhdGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgRVhQRUNUX1RSVUUo YnVmZmVyLT5pc0VtcHR5KCkpOworfQorCitURVNUX0YoU2hhcmVkQnVmZmVyVGVzdCwgY29weUJ1 ZmZlckNyZWF0ZWRXaXRoQ29udGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBSZWZQdHI8U2hh cmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmls ZSh0ZW1wRmlsZVBhdGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgUmVm UHRyPFNoYXJlZEJ1ZmZlcj4gY29weSA9IGJ1ZmZlci0+Y29weSgpOworICAgIEVYUEVDVF9UUlVF KGJ1ZmZlci0+c2l6ZSgpID09IGNvcHktPnNpemUoKSk7CisgICAgRVhQRUNUX1RSVUUoc3RybnN0 cihidWZmZXItPmRhdGEoKSwgY29weS0+ZGF0YSgpLCBidWZmZXItPnNpemUoKSkpOworfQorCitU RVNUX0YoU2hhcmVkQnVmZmVyVGVzdCwgY2xlYXJCdWZmZXJDcmVhdGVkV2l0aENvbnRlbnRzT2ZF eGlzdGluZ0ZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUodGVtcEZpbGVQYXRoKCkpOworICAgIEFT U0VSVF9OT1RfTlVMTChidWZmZXIpOworICAgIGJ1ZmZlci0+Y2xlYXIoKTsKKyAgICBFWFBFQ1Rf VFJVRSghYnVmZmVyLT5zaXplKCkpOworICAgIEVYUEVDVF9UUlVFKCFidWZmZXItPmRhdGEoKSk7 Cit9CisKKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGFwcGVuZEJ1ZmZlckNyZWF0ZWRXaXRo Q29udGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZm ZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSh0ZW1wRmlsZVBhdGgo KSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgYnVmZmVyLT5hcHBlbmQoImEi LCAxKTsKKyAgICBFWFBFQ1RfVFJVRShidWZmZXItPnNpemUoKSA9PSAoc3RybGVuKFNoYXJlZEJ1 ZmZlclRlc3REYXRhKSArIDEpKTsKKyAgICBFWFBFQ1RfVFJVRShzdHJuc3RyKGJ1ZmZlci0+ZGF0 YSgpLCBTaGFyZWRCdWZmZXJUZXN0RGF0YSwgc3RybGVuKFNoYXJlZEJ1ZmZlclRlc3REYXRhKSkp OworICAgIEVYUEVDVF9FUSgnYScsIGJ1ZmZlci0+ZGF0YSgpW3N0cmxlbihTaGFyZWRCdWZmZXJU ZXN0RGF0YSldKTsKK30KKworfQo= 252393 2015-05-05 11:51:53 -0700 2015-05-13 03:21:28 -0700 Patch bug-144192-20150505205034.patch text/plain 35360 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTgzNzk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjhmMDFkNDNjN2I4ZDdj ZTQwMTJiMWY1ZDgyMWY4YWQzNTc4Zjc4OC4uNTQ0NTZkNTFhZDRkYWU2Y2QwNTM3NWJlYWU3Njcx YjdhZDYzOGJlZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUwIEBACisyMDE1LTA1LTA1ICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIEZpbGUgY29u dGVudCBpcyBtYXBwZWQgdW50aWwgU2hhcmVkQnVmZmVyIGlzIGNsZWFyZWQsIGRlc3Ryb3llZCBv ciBhZGRpdGlvbmFsIGNvbnRlbnQgaXMgYXBwZW5kZWQgdG8gdGhlIFNoYXJlZEJ1ZmZlci4KKyAg ICAgICAgUmVtb3ZlZCBFRkwsIE1hYyBhbmQgR1RLIHNwZWNpZmljIHZlcnNpb25zIG9mIFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorCisgICAgICAgIEEgaGVscGVyIGNs YXNzLCBNYXBwZWRGaWxlRGF0YSwgaXMgaW50cm9kdWNlZCB0byBoYW5kbGUgbWFwcGVkIGZpbGVz IHRocm91Z2ggY2FsbHMgdG8gb3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAgICBQYXRj aCBjb3ZlcmVkIGJ5IGV4aXN0aW5nIGxheW91dCB0ZXN0cyBhbmQgYWRkZWQgdW5pdCB0ZXN0cy4K KworICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtlOgorICAgICAgICAqIFBsYXRmb3JtR1RLLmNt YWtlOgorICAgICAgICAqIFBsYXRmb3JtTWFjLmNtYWtlOgorICAgICAgICAqIHBsYXRmb3JtL0Zp bGVTeXN0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6OnN3YXApOgor ICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAg ICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpvcGVyYXRvcj0pOgorICAgICAgICAoV2ViQ29y ZTo6TWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpN YXBwZWRGaWxlRGF0YTo6bWFwKToKKyAgICAgICAgKiBwbGF0Zm9ybS9GaWxlU3lzdGVtLmg6Cisg ICAgICAgIChXZWJDb3JlOjpNYXBwZWRGaWxlRGF0YTo6TWFwcGVkRmlsZURhdGEpOgorICAgICAg ICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6Om9wZXJhdG9yIGJvb2wpOgorICAgICAgICAoV2Vi Q29yZTo6TWFwcGVkRmlsZURhdGE6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmls ZURhdGE6OnNpemUpOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcik6CisgICAgICAgIChXZWJD b3JlOjpTaGFyZWRCdWZmZXI6OnNpemUpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVy OjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6YXBwZW5kKToKKyAgICAg ICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpjb3B5KToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29t ZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyTWFw cGVkRmlsZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRo Q29udGVudHNPZkZpbGUpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjphZG9wdFZl Y3Rvcik6IERlbGV0ZWQuCisgICAgICAgICogcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmg6CisgICAg ICAgICogcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHA6IFJlbW92ZWQuCisgICAgICAg ICogcGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1hYy5tbToKKyAgICAgICAgKiBwbGF0Zm9ybS9w b3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5jcHA6IFJlbW92ZWQuCisgICAgICAgICogcGxhdGZvcm0v d2luL1NoYXJlZEJ1ZmZlcldpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6 OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSk6CisKIDIwMTUtMDUtMDQgIEFuZHJlYXMgS2xpbmcg IDxha2xpbmdAYXBwbGUuY29tPgogCiAgICAgICAgIFJlY29yZCB0aGUgcmVmZXJlbmNlIHRpbWUg d2hlbiBQZXJmb3JtYW5jZSBpcyBjb25zdHJ1Y3RlZC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL1BsYXRmb3JtRWZsLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1FZmwuY21ha2UK aW5kZXggZTYzMzBjNTg2ODRmNWE3MDg3ZWQxNDExYmY3Y2U0ZDE4MjQ0ZjFjOS4uOGVmZDcxZmE0 N2JlODlmNDI3ODU3NWQ3ZmMwYTQyYjhhYjJlYjVjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvUGxhdGZvcm1FZmwuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1FZmwuY21h a2UKQEAgLTI0Myw3ICsyNDMsNiBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKICAgICBw bGF0Zm9ybS9uZXR3b3JrL3NvdXAvU3luY2hyb25vdXNMb2FkZXJDbGllbnRTb3VwLmNwcAogCiAg ICAgcGxhdGZvcm0vcG9zaXgvRmlsZVN5c3RlbVBPU0lYLmNwcAotICAgIHBsYXRmb3JtL3Bvc2l4 L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcAogCiAgICAgcGxhdGZvcm0vc291cC9TaGFyZWRCdWZmZXJT b3VwLmNwcAogICAgIHBsYXRmb3JtL3NvdXAvVVJMU291cC5jcHAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsu Y21ha2UKaW5kZXggODE5ZjViYjMwOWJlMWRhMGIwMTQ0NGZmMWM5MzQ5Nzk2MmEzYWU3NC4uYzkx MmU0MmEwNjE3ODY1NzRjMWQ2ZDdkMGVkNjA1MDhhNTc5MjliYyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UKQEAgLTEzNCw3ICsxMzQsNiBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMK ICAgICBwbGF0Zm9ybS9ndGsvTGFuZ3VhZ2VHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL0xvZ2dp bmdHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL01JTUVUeXBlUmVnaXN0cnlHdGsuY3BwCi0gICAg cGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvU2hhcmVk VGltZXJHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL1RlbXBvcmFyeUxpbmtTdHVicy5jcHAKICAg ICBwbGF0Zm9ybS9ndGsvVXNlckFnZW50R3RrLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvUGxhdGZvcm1NYWMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybU1hYy5jbWFrZQpp bmRleCAwNTRhYTU0MDg3ZTNjNTMxOThjMWU4ZjU1Njg2YWI5OWUzNTFmMmY3Li5lY2JlNzk1YzI0 ZWE4MGUyYTFiMmI0NTljNjIyN2Q3Y2JhOTU2NDBlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9QbGF0Zm9ybU1hYy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybU1hYy5jbWFr ZQpAQCAtMzQ5LDcgKzM0OSw2IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09VUkNFUwogICAgIHBs YXRmb3JtL25ldHdvcmsvbWFjL1dlYkNvcmVVUkxSZXNwb25zZS5tbQogCiAgICAgcGxhdGZvcm0v cG9zaXgvRmlsZVN5c3RlbVBPU0lYLmNwcAotICAgIHBsYXRmb3JtL3Bvc2l4L1NoYXJlZEJ1ZmZl clBPU0lYLmNwcAogCiAgICAgcGxhdGZvcm0vdGV4dC9jZi9IeXBoZW5hdGlvbkNGLmNwcAogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCmluZGV4IDk3Yjg0NmVlY2M0YzYzMGRk YmEwNmQ0YzU3ZDM2MTc2OGQ4ZWNmZGYuLjRhZTAyYTMzY2QxYmMxNmQ5NzI0ZDRkZmExZTM3YWI1 YzI5M2Q1Y2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0u Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCkBAIC0xLDUg KzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNywgMjAxMSBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUgQ2Fub24gSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yNyw4ICsy OCwxNiBAQAogI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKIAogI2luY2x1ZGUgPHd0Zi9IZXhOdW1i ZXIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQv U3RyaW5nQnVpbGRlci5oPgogCisjaWYgIVBMQVRGT1JNKFdJTikKKyNpbmNsdWRlIDxmY250bC5o PgorI2luY2x1ZGUgPHN5cy9tbWFuLmg+CisjaW5jbHVkZSA8c3lzL3N0YXQuaD4KKyNpbmNsdWRl IDx1bmlzdGQuaD4KKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIC8vIFRoZSBmb2xs b3dpbmcgbG93ZXItQVNDSUkgY2hhcmFjdGVycyBuZWVkIGVzY2FwaW5nIHRvIGJlIHVzZWQgaW4g YSBmaWxlbmFtZQpAQCAtMTEyLDUgKzEyMSw2OSBAQCBib29sIGV4Y2x1ZGVGcm9tQmFja3VwKGNv bnN0IFN0cmluZyYpCiB9CiAKICNlbmRpZgorICAgIAordm9pZCBNYXBwZWRGaWxlRGF0YTo6c3dh cChNYXBwZWRGaWxlRGF0YSYgZmQpCit7CisgICAgc3RkOjpzd2FwKG1fZmlsZURhdGEsIGZkLm1f ZmlsZURhdGEpOworICAgIHN0ZDo6c3dhcChtX2ZpbGVTaXplLCBmZC5tX2ZpbGVTaXplKTsKK30K KworTWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKE1hcHBlZEZpbGVEYXRhJiYgZmQpCit7 CisgICAgc3dhcChmZCk7Cit9CisKK01hcHBlZEZpbGVEYXRhJiBNYXBwZWRGaWxlRGF0YTo6b3Bl cmF0b3I9KE1hcHBlZEZpbGVEYXRhJiYgZmQpCit7CisgICAgc3dhcChmZCk7CisgICAgcmV0dXJu ICp0aGlzOworfQorCitNYXBwZWRGaWxlRGF0YTo6fk1hcHBlZEZpbGVEYXRhKCkKK3sKKyNpZiAh UExBVEZPUk0oV0lOKQorICAgIGlmICghbV9maWxlRGF0YSkKKyAgICAgICAgcmV0dXJuOworICAg IG11bm1hcChtX2ZpbGVEYXRhLCBtX2ZpbGVTaXplKTsKKyAgICBtX2ZpbGVEYXRhID0gbnVsbHB0 cjsKKyNlbmRpZgorfQorCisjaWYgIVBMQVRGT1JNKFdJTikKK2Jvb2wgTWFwcGVkRmlsZURhdGE6 Om1hcChjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQoreworICAgIGludCBmZCA9IG9wZW4oZmlsZVN5 c3RlbVJlcHJlc2VudGF0aW9uKGZpbGVQYXRoKS5kYXRhKCksIE9fUkRPTkxZKTsKKyAgICBpZiAo ZmQgPCAwKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBzdHJ1Y3Qgc3RhdCBmaWxlU3Rh dDsKKyAgICBpZiAoZnN0YXQoZmQsICZmaWxlU3RhdCkpIHsKKyAgICAgICAgY2xvc2UoZmQpOwor ICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgaWYgKGZpbGVTdGF0LnN0X3NpemUg PCAwIHx8IGZpbGVTdGF0LnN0X3NpemUgPiBzdGQ6Om51bWVyaWNfbGltaXRzPHVuc2lnbmVkPjo6 bWF4KCkpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAgICByZXR1cm4gZmFsc2U7CisgICAg fQorCisgICAgdW5zaWduZWQgc2l6ZSA9IHN0YXRpY19jYXN0PHVuc2lnbmVkPihmaWxlU3RhdC5z dF9zaXplKTsKKworICAgIGlmICghc2l6ZSkgeworICAgICAgICBjbG9zZShmZCk7CisgICAgICAg IHJldHVybiB0cnVlOworICAgIH0KKworICAgIHZvaWQqIGRhdGEgPSBtbWFwKDAsIHNpemUsIFBS T1RfUkVBRCwgTUFQX0ZJTEUgfCBNQVBfU0hBUkVELCBmZCwgMCk7CisgICAgY2xvc2UoZmQpOwor CisgICAgaWYgKGRhdGEgPT0gTUFQX0ZBSUxFRCkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgbV9maWxlRGF0YSA9IGRhdGE7CisgICAgbV9maWxlU2l6ZSA9IHNpemU7CisgICAgcmV0dXJu IHRydWU7Cit9CisjZW5kaWYKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5oIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vRmlsZVN5c3RlbS5oCmluZGV4IGY1YzNhMmNmOGYxNjQ0M2ZmMTJlNmQ1Yzc3YTY3NzE1 YzhlMjNiNGMuLjg4MTU5Y2M5ZTM3YTc3OWYyODY2MmNhNDk4ZWFlNWQ3ZDYwOTBkODQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmgKQEAgLTIwNCw2ICsyMDQsMjYgQEAgV0VCQ09S RV9FWFBPUlQgU3RyaW5nIGxvY2FsVXNlclNwZWNpZmljU3RvcmFnZURpcmVjdG9yeSgpOwogU3Ry aW5nIHJvYW1pbmdVc2VyU3BlY2lmaWNTdG9yYWdlRGlyZWN0b3J5KCk7CiAjZW5kaWYKIAorY2xh c3MgTWFwcGVkRmlsZURhdGEgeworcHVibGljOgorICAgIE1hcHBlZEZpbGVEYXRhKCkgeyB9Cisj aWYgIVBMQVRGT1JNKFdJTikKKyAgICBXRUJDT1JFX0VYUE9SVCBib29sIG1hcChjb25zdCBTdHJp bmcmKTsKKyNlbmRpZgorICAgIFdFQkNPUkVfRVhQT1JUIE1hcHBlZEZpbGVEYXRhKE1hcHBlZEZp bGVEYXRhJiYpOworICAgIFdFQkNPUkVfRVhQT1JUIH5NYXBwZWRGaWxlRGF0YSgpOworICAgIE1h cHBlZEZpbGVEYXRhJiBvcGVyYXRvcj0oTWFwcGVkRmlsZURhdGEmJik7CisgICAgdm9pZCBzd2Fw KE1hcHBlZEZpbGVEYXRhJik7CisKKyAgICBleHBsaWNpdCBvcGVyYXRvciBib29sKCkgY29uc3Qg eyByZXR1cm4gISFtX2ZpbGVEYXRhOyB9CisgICAgY29uc3Qgdm9pZCogZGF0YSgpIGNvbnN0IHsg cmV0dXJuIG1fZmlsZURhdGE7IH0KKyAgICB1bnNpZ25lZCBzaXplKCkgY29uc3QgeyByZXR1cm4g bV9maWxlU2l6ZTsgfQorCitwcml2YXRlOgorICAgIHZvaWQqIG1fZmlsZURhdGEgeyBudWxscHRy IH07CisgICAgdW5zaWduZWQgbV9maWxlU2l6ZSB7IDAgfTsKK307CisKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKIAogI2VuZGlmIC8vIEZpbGVTeXN0ZW1faApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1NoYXJlZEJ1ZmZlci5jcHAKaW5kZXggYWZiYjY1MzFmZDcxNGI4NjdhZmQ2ZDJmZjEyN2NlOTk2 NmUwZGViOS4uNDhmNTk0MTg3NTgwMzhlN2NmODYwNzViMTM4Y2U2OTVmNTBhOTVlYiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0xLDYgKzEsNyBAQAogLyoK ICAqIENvcHlyaWdodCAoQykgMjAwNiwgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCiAgKiBDb3B5cmlnaHQgKEMpIFJlc2VhcmNoIEluIE1vdGlvbiBMaW1pdGVkIDIwMDktMjAx MC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAg LTMwLDYgKzMxLDEwIEBACiAjaW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1ZGUgPHd0Zi91bmlj b2RlL1VURjguaD4KIAorI2lmICFQTEFURk9STShXSU4pCisjaW5jbHVkZSAiRmlsZVN5c3RlbS5o IgorI2VuZGlmCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogI2lmICFVU0UoTkVUV09SS19DRkRB VEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC04NSw3ICs5MCwxNCBAQCBTaGFyZWRCdWZmZXI6OlNoYXJl ZEJ1ZmZlcihjb25zdCB1bnNpZ25lZCBjaGFyKiBkYXRhLCB1bnNpZ25lZCBzaXplKQogewogICAg IGFwcGVuZChyZWludGVycHJldF9jYXN0PGNvbnN0IGNoYXIqPihkYXRhKSwgc2l6ZSk7CiB9Ci0g ICAgCisKK1NoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKE1hcHBlZEZpbGVEYXRhJiYgZmlsZURh dGEpCisgICAgOiBtX3NpemUoMCkKKyAgICAsIG1fYnVmZmVyKGFkb3B0UmVmKG5ldyBEYXRhQnVm ZmVyKSkKKyAgICAsIG1fZmlsZURhdGEoV1RGOjptb3ZlKGZpbGVEYXRhKSkKK3sKK30KKwogU2hh cmVkQnVmZmVyOjp+U2hhcmVkQnVmZmVyKCkKIHsKICAgICBjbGVhcigpOwpAQCAtMTA0LDE1ICsx MTYsMjAgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpzaXplKCkgY29uc3QKICAgICBpZiAoaGFz UGxhdGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0Zm9ybURhdGFTaXplKCk7CiAgICAg CisgICAgaWYgKG1fZmlsZURhdGEpCisgICAgICAgIHJldHVybiBtX2ZpbGVEYXRhLnNpemUoKTsK KwogICAgIHJldHVybiBtX3NpemU7CiB9CiAKIGNvbnN0IGNoYXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0 YSgpIGNvbnN0CiB7Ci0KICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVy biBwbGF0Zm9ybURhdGEoKTsKIAorICAgIGlmIChtX2ZpbGVEYXRhKQorICAgICAgICByZXR1cm4g c3RhdGljX2Nhc3Q8Y29uc3QgY2hhcio+KG1fZmlsZURhdGEuZGF0YSgpKTsKKwogI2lmIFVTRShO RVRXT1JLX0NGREFUQV9BUlJBWV9DQUxMQkFDSykKICAgICBpZiAoY29uc3QgY2hhciogYnVmZmVy ID0gc2luZ2xlRGF0YUFycmF5QnVmZmVyKCkpCiAgICAgICAgIHJldHVybiBidWZmZXI7CkBAIC0x NjMsNiArMTgwLDcgQEAgdm9pZCBTaGFyZWRCdWZmZXI6OmFwcGVuZChjb25zdCBjaGFyKiBkYXRh LCB1bnNpZ25lZCBsZW5ndGgpCiAgICAgaWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVybjsKIAor ICAgIG1heWJlVHJhbnNmZXJNYXBwZWRGaWxlRGF0YSgpOwogICAgIG1heWJlVHJhbnNmZXJQbGF0 Zm9ybURhdGEoKTsKIAogI2lmICFVU0UoTkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBA IC0yMTMsNiArMjMxLDkgQEAgdm9pZCBTaGFyZWRCdWZmZXI6OmFwcGVuZChjb25zdCBWZWN0b3I8 Y2hhcj4mIGRhdGEpCiAKIHZvaWQgU2hhcmVkQnVmZmVyOjpjbGVhcigpCiB7CisgICAgaWYgKG1f ZmlsZURhdGEpCisgICAgICAgIG1fZmlsZURhdGEgPSB7IH07CisKICAgICBjbGVhclBsYXRmb3Jt RGF0YSgpOwogICAgIAogI2lmICFVU0UoTkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBA IC0yMzAsNyArMjUxLDggQEAgdm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyKCkKIFBhc3NSZWZQdHI8 U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNvcHkoKSBjb25zdAogewogICAgIFJlZlB0cjxT aGFyZWRCdWZmZXI+IGNsb25lIHsgYWRvcHRSZWYoKm5ldyBTaGFyZWRCdWZmZXIpIH07Ci0gICAg aWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7CisKKyAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkgfHwg bV9maWxlRGF0YSkgewogICAgICAgICBjbG9uZS0+YXBwZW5kKGRhdGEoKSwgc2l6ZSgpKTsKICAg ICAgICAgcmV0dXJuIGNsb25lLnJlbGVhc2UoKTsKICAgICB9CkBAIC0zMTMsNyArMzM1LDcgQEAg dW5zaWduZWQgU2hhcmVkQnVmZmVyOjpnZXRTb21lRGF0YShjb25zdCBjaGFyKiYgc29tZURhdGEs IHVuc2lnbmVkIHBvc2l0aW9uKSBjb24KICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0gICAg aWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7CisgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpIHx8IG1f ZmlsZURhdGEpIHsKICAgICAgICAgQVNTRVJUX1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04ocG9z aXRpb24gPCBzaXplKCkpOwogICAgICAgICBzb21lRGF0YSA9IGRhdGEoKSArIHBvc2l0aW9uOwog ICAgICAgICByZXR1cm4gdG90YWxTaXplIC0gcG9zaXRpb247CkBAIC0zNDYsNiArMzY4LDI0IEBA IHVuc2lnbmVkIFNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEoY29uc3QgY2hhciomIHNvbWVEYXRh LCB1bnNpZ25lZCBwb3NpdGlvbikgY29uCiAjZW5kaWYKIH0KIAordm9pZCBTaGFyZWRCdWZmZXI6 Om1heWJlVHJhbnNmZXJNYXBwZWRGaWxlRGF0YSgpCit7CisgICAgaWYgKG1fZmlsZURhdGEpIHsK KyAgICAgICAgYXV0byBmaWxlRGF0YSA9IFdURjo6bW92ZShtX2ZpbGVEYXRhKTsKKyAgICAgICAg YXBwZW5kKHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihmaWxlRGF0YS5kYXRhKCkpLCBmaWxlRGF0 YS5zaXplKCkpOworICAgIH0KK30KKworI2lmICFQTEFURk9STShXSU4pCitSZWZQdHI8U2hhcmVk QnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJp bmcmIGZpbGVQYXRoKQoreworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhOworICAg IGlmICghbWFwcGVkRmlsZURhdGEubWFwKGZpbGVQYXRoKSkKKyAgICAgICAgcmV0dXJuIG51bGxw dHI7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBTaGFyZWRCdWZmZXIoV1RGOjptb3ZlKG1hcHBl ZEZpbGVEYXRhKSkpOworfQorI2VuZGlmCisKICNpZiAhVVNFKENGKSAmJiAhVVNFKFNPVVApCiAK IGlubGluZSB2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXJQbGF0Zm9ybURhdGEoKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaAppbmRleCBiY2YzNTUzZWQ2MGVjZjllMTA4YjkyYWY1 NzExNDExNzA4MDM1ZWExLi5hZThiYTQzNDQ0MGRlY2MzMGUwYWQwMTYzNjcwZjNmMTBjMDhmNzU1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaApAQCAtMjcsNiArMjcsNyBA QAogI2lmbmRlZiBTaGFyZWRCdWZmZXJfaAogI2RlZmluZSBTaGFyZWRCdWZmZXJfaAogCisjaW5j bHVkZSAiRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUgPHJ1bnRpbWUvQXJyYXlCdWZmZXIuaD4KICNp bmNsdWRlIDx3dGYvRm9yd2FyZC5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CkBAIC01 NSw3ICs1Niw3IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+ IGNyZWF0ZShjb25zdCBjaGFyKiBjLCB1bnNpZ25lZCBpKSB7IHJldHVybiBhZG9wdFJlZihuZXcg U2hhcmVkQnVmZmVyKGMsIGkpKTsgfQogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZl cj4gY3JlYXRlKGNvbnN0IHVuc2lnbmVkIGNoYXIqIGMsIHVuc2lnbmVkIGkpIHsgcmV0dXJuIGFk b3B0UmVmKG5ldyBTaGFyZWRCdWZmZXIoYywgaSkpOyB9CiAKLSAgICBXRUJDT1JFX0VYUE9SVCBz dGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShj b25zdCBTdHJpbmcmIGZpbGVQYXRoKTsKKyAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgUmVmUHRy PFNoYXJlZEJ1ZmZlcj4gY3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmls ZVBhdGgpOwogCiAgICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQnVm ZmVyPiBhZG9wdFZlY3RvcihWZWN0b3I8Y2hhcj4mIHZlY3Rvcik7CiAgICAgCkBAIC05Miw3ICs5 Myw3IEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGFwcGVuZChjb25zdCBjaGFy KiwgdW5zaWduZWQpOwogICAgIHZvaWQgYXBwZW5kKGNvbnN0IFZlY3RvcjxjaGFyPiYpOwogCi0g ICAgdm9pZCBjbGVhcigpOworICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQgY2xlYXIoKTsKICAgICBj b25zdCBjaGFyKiBwbGF0Zm9ybURhdGEoKSBjb25zdDsKICAgICB1bnNpZ25lZCBwbGF0Zm9ybURh dGFTaXplKCkgY29uc3Q7CiAKQEAgLTEwMSw3ICsxMDIsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBh cHBlbmQoQ0ZEYXRhUmVmKTsKICNlbmRpZgogCi0gICAgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+ IGNvcHkoKSBjb25zdDsKKyAgICBXRUJDT1JFX0VYUE9SVCBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZl cj4gY29weSgpIGNvbnN0OwogICAgIAogICAgIC8vIFJldHVybiB0aGUgbnVtYmVyIG9mIGNvbnNl Y3V0aXZlIGJ5dGVzIGFmdGVyICJwb3NpdGlvbiIuICJkYXRhIgogICAgIC8vIHBvaW50cyB0byB0 aGUgZmlyc3QgYnl0ZS4KQEAgLTEyOSw3ICsxMzAsOCBAQCBwcml2YXRlOgogICAgIGV4cGxpY2l0 IFNoYXJlZEJ1ZmZlcih1bnNpZ25lZCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVy KGNvbnN0IGNoYXIqLCB1bnNpZ25lZCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVy KGNvbnN0IHVuc2lnbmVkIGNoYXIqLCB1bnNpZ25lZCk7Ci0gICAgCisgICAgU2hhcmVkQnVmZmVy KE1hcHBlZEZpbGVEYXRhJiYpOworCiAgICAgLy8gQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIHdpbGwg Zm9yY2UgaW50ZXJuYWwgc2VnbWVudGVkIGJ1ZmZlcnMKICAgICAvLyB0byBiZSBtZXJnZWQgaW50 byBhIGZsYXQgYnVmZmVyLiBVc2UgZ2V0U29tZURhdGEoKSB3aGVuZXZlciBwb3NzaWJsZQogICAg IC8vIGZvciBiZXR0ZXIgcGVyZm9ybWFuY2UuCkBAIC0xMzksNiArMTQxLDggQEAgcHJpdmF0ZToK ICAgICB2b2lkIG1heWJlVHJhbnNmZXJQbGF0Zm9ybURhdGEoKTsKICAgICBib29sIG1heWJlQXBw ZW5kUGxhdGZvcm1EYXRhKFNoYXJlZEJ1ZmZlciopOwogCisgICAgdm9pZCBtYXliZVRyYW5zZmVy TWFwcGVkRmlsZURhdGEoKTsKKwogICAgIHZvaWQgY29weUJ1ZmZlckFuZENsZWFyKGNoYXIqIGRl c3RpbmF0aW9uLCB1bnNpZ25lZCBieXRlc1RvQ29weSkgY29uc3Q7CiAKICAgICB2b2lkIGFwcGVu ZFRvRGF0YUJ1ZmZlcihjb25zdCBjaGFyICosIHVuc2lnbmVkKSBjb25zdDsKQEAgLTE2Nyw2ICsx NzEsOCBAQCBwcml2YXRlOgogICAgIGV4cGxpY2l0IFNoYXJlZEJ1ZmZlcihTb3VwQnVmZmVyKik7 CiAgICAgR1VuaXF1ZVB0cjxTb3VwQnVmZmVyPiBtX3NvdXBCdWZmZXI7CiAjZW5kaWYKKworICAg IE1hcHBlZEZpbGVEYXRhIG1fZmlsZURhdGE7CiB9OwogCiBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZl cj4gdXRmOEJ1ZmZlcihjb25zdCBTdHJpbmcmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IGVkOGRlNDcxNjQzZDMwMDYyNTc2ZDlkMjAwODRkNGE1N2YxZGVlMTMuLjAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKKysrIC9kZXYvbnVsbApAQCAtMSw1MCArMCwwIEBACi0v KgotICogQ29weXJpZ2h0IChDKSAyMDA4IENvbGxhYm9yYSBMdGQuCi0gKgotICogIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKLSAq ICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCi0gKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCi0gKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqICBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICog IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUgR05VCi0gKiAgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KLSAqCi0gKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IExlc3NlciBHZW5lcmFsIFB1YmxpYwotICogIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJh cnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKLSAqICBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0x MzAxICBVU0EKLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiU2hhcmVkQnVm ZmVyLmgiCi0KLSNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCi0jaW5jbHVkZSA8d3RmL2dvYmplY3Qv R1VuaXF1ZVB0ci5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KLQotI2luY2x1ZGUg PGdsaWIuaD4KLQotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLVBhc3NSZWZQdHI8U2hhcmVkQnVm ZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcm IGZpbGVQYXRoKQotewotICAgIGlmIChmaWxlUGF0aC5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVy biAwOwotCi0gICAgQ1N0cmluZyBmaWxlbmFtZSA9IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihm aWxlUGF0aCk7Ci0gICAgR1VuaXF1ZU91dFB0cjxnY2hhcj4gY29udGVudHM7Ci0gICAgZ3NpemUg c2l6ZTsKLSAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7Ci0gICAgaWYgKCFnX2ZpbGVf Z2V0X2NvbnRlbnRzKGZpbGVuYW1lLmRhdGEoKSwgJmNvbnRlbnRzLm91dFB0cigpLCAmc2l6ZSwg JmVycm9yLm91dFB0cigpKSkgewotICAgICAgICBMT0dfRVJST1IoIkZhaWxlZCB0byBmdWxseSBy ZWFkIGNvbnRlbnRzIG9mIGZpbGUgJXMgLSAlcyIsIGZpbGVuYW1lRm9yRGlzcGxheShmaWxlUGF0 aCkudXRmOCgpLmRhdGEoKSwgZXJyb3ItPm1lc3NhZ2UpOwotICAgICAgICByZXR1cm4gMDsKLSAg ICB9Ci0KLSAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiByZXN1bHQgPSBTaGFyZWRCdWZmZXI6OmNy ZWF0ZShjb250ZW50cy5nZXQoKSwgc2l6ZSk7Ci0KLSAgICByZXR1cm4gcmVzdWx0LnJlbGVhc2Uo KTsKLX0KLQotfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1hYy5tbSBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0KaW5kZXggZWE0ODJmMDZmMDgxNjhhOWFmZDU4YzZk MDBhYjVjZjBiMzNlMDU0Ny4uMDliNWJjMDFkMGI3ZjliMjNhODI4YWExZTkwMjVkNGZlMmI0MzJm NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1h Yy5tbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1t CkBAIC0xMjIsMTIgKzEyMiw0IEBAIFJldGFpblB0cjxDRkRhdGFSZWY+IFNoYXJlZEJ1ZmZlcjo6 Y3JlYXRlQ0ZEYXRhKCkKICAgICByZXR1cm4gYWRvcHRDRigoQ0ZEYXRhUmVmKWFkb3B0TlMoW1tX ZWJDb3JlU2hhcmVkQnVmZmVyRGF0YSBhbGxvY10gaW5pdFdpdGhTaGFyZWRCdWZmZXJEYXRhQnVm ZmVyOm1fYnVmZmVyLmdldCgpXSkubGVha1JlZigpKTsKIH0KIAotUGFzc1JlZlB0cjxTaGFyZWRC dWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmlu ZyYgZmlsZVBhdGgpCi17Ci0gICAgTlNEYXRhICpyZXNvdXJjZURhdGEgPSBbTlNEYXRhIGRhdGFX aXRoQ29udGVudHNPZkZpbGU6ZmlsZVBhdGhdOwotICAgIGlmIChyZXNvdXJjZURhdGEpIAotICAg ICAgICByZXR1cm4gU2hhcmVkQnVmZmVyOjp3cmFwTlNEYXRhKHJlc291cmNlRGF0YSk7Ci0gICAg cmV0dXJuIDA7Ci19Ci0KIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Bv c2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Bvc2l4 L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTc3 YjhlY2YwNmY5YmM5YzBlNWZmYTFiZGEwN2Q4NjIxNDI4NWJkNC4uMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3Np eC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAKKysrIC9kZXYvbnVsbApAQCAtMSw3MiArMCwwIEBACi0v KgotICogQ29weXJpZ2h0IChDKSAyMDEwIENvbXBhbnkgMTAwLCBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQotICogSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCi0gKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgot ICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsCi0gKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCi0gKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKLSAqIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkKLSAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAotICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCi0gKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpbmNs dWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJTaGFyZWRCdWZmZXIuaCIKLQotI2luY2x1ZGUgIkZp bGVTeXN0ZW0uaCIKLQotI2luY2x1ZGUgPGZjbnRsLmg+Ci0jaW5jbHVkZSA8c3lzL3N0YXQuaD4K LSNpbmNsdWRlIDx1bmlzdGQuaD4KLSNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+Ci0KLW5h bWVzcGFjZSBXZWJDb3JlIHsKLQotUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZl cjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCi17Ci0g ICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKLSAgICAgICAgcmV0dXJuIDA7Ci0KLSAgICBDU3Ry aW5nIGZpbGVuYW1lID0gZmlsZVN5c3RlbVJlcHJlc2VudGF0aW9uKGZpbGVQYXRoKTsKLSAgICBp bnQgZmQgPSBvcGVuKGZpbGVuYW1lLmRhdGEoKSwgT19SRE9OTFkpOwotICAgIGlmIChmZCA9PSAt MSkKLSAgICAgICAgcmV0dXJuIDA7Ci0KLSAgICBzdHJ1Y3Qgc3RhdCBmaWxlU3RhdDsKLSAgICBp ZiAoZnN0YXQoZmQsICZmaWxlU3RhdCkpIHsKLSAgICAgICAgY2xvc2UoZmQpOwotICAgICAgICBy ZXR1cm4gMDsKLSAgICB9Ci0KLSAgICBzaXplX3QgYnl0ZXNUb1JlYWQgPSBmaWxlU3RhdC5zdF9z aXplOwotICAgIGlmIChmaWxlU3RhdC5zdF9zaXplIDwgMCB8fCBieXRlc1RvUmVhZCAhPSBzdGF0 aWNfY2FzdDx1bnNpZ25lZCBsb25nIGxvbmc+KGZpbGVTdGF0LnN0X3NpemUpKSB7Ci0gICAgICAg IGNsb3NlKGZkKTsKLSAgICAgICAgcmV0dXJuIDA7Ci0gICAgfQotCi0gICAgVmVjdG9yPGNoYXI+ IGJ1ZmZlcihieXRlc1RvUmVhZCk7Ci0KLSAgICBzaXplX3QgdG90YWxCeXRlc1JlYWQgPSAwOwot ICAgIHNzaXplX3QgYnl0ZXNSZWFkOwotICAgIHdoaWxlICgoYnl0ZXNSZWFkID0gcmVhZChmZCwg YnVmZmVyLmRhdGEoKSArIHRvdGFsQnl0ZXNSZWFkLCBieXRlc1RvUmVhZCAtIHRvdGFsQnl0ZXNS ZWFkKSkgPiAwKQotICAgICAgICB0b3RhbEJ5dGVzUmVhZCArPSBieXRlc1JlYWQ7Ci0KLSAgICBj bG9zZShmZCk7Ci0KLSAgICByZXR1cm4gdG90YWxCeXRlc1JlYWQgPT0gYnl0ZXNUb1JlYWQgPyBT aGFyZWRCdWZmZXI6OmFkb3B0VmVjdG9yKGJ1ZmZlcikgOiAwOwotfQotCi19IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVk QnVmZmVyV2luLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJX aW4uY3BwCmluZGV4IGY1ZGQyMjg0NjQxOWEwZjJkOTc4NWI5YTY5Y2RmOTA5YmMzOTFkNzAuLjYw NTQ2NzEzNDI3ZWVkZGE2YjFiNWNmNGYwYmNkNjhhM2MzNTBkZDIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwCkBAIC0zMyw4ICszMyw5IEBA CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgp CitSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09m RmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQogeworICAgIC8vIEZJWE1FOiBVc2UgbWFwIGZp bGUgcm91dGluZXMuCiAgICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJu IDA7CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCAxY2ZhNmNlZmU0ZjQzODFmNzU1ODFmMzJmNzBiZjNiOGQyYWMxYzJkLi4yMWQ2NWY0NDFiOTdh OWI2ODYyMjA0YWI0Yjg4MzAzMTJjNDg3MGU1IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cK KysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTUtMDUtMDUgIFlvdWVu biBGYWJsZXQgIDx5b3Vlbm4uZmFibGV0QGNyZi5jYW5vbi5mcj4KKworICAgICAgICBTaGFyZWRC dWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSBzaG91bGQgdXNlIG1hcCBmaWxlIHJvdXRp bmVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNDQx OTIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRp bmcgU2hhcmVkQnVmZmVyIGFuZCBGaWxlU3lzdGVtIFVuaXQgdGVzdHMgdG8gTWFjIGFuZCBHVEss IG5vdCB5ZXQgZm9yIEVGTC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxhdGZvcm1HVEsu Y21ha2U6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0Zp bGVTeXN0ZW0uY3BwOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OkZpbGVTeXN0ZW1U ZXN0Ojp0ZW1wRmlsZVBhdGgpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6RmlsZVN5c3RlbVRl c3Q6OnRlbXBFbXB0eUZpbGVQYXRoKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1RfRik6 CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL1NoYXJlZEJ1ZmZlci5jcHA6 IEFkZGVkLgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6U2hhcmVkQnVmZmVyVGVzdDo6dGVtcEZp bGVQYXRoKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlNoYXJlZEJ1ZmZlclRlc3Q6OnRlbXBF bXB0eUZpbGVQYXRoKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1RfRik6CisKIDIwMTUt MDUtMDQgIEJyZW50IEZ1bGdoYW0gIDxiZnVsZ2hhbUBhcHBsZS5jb20+CiAKICAgICAgICAgQ29y cmVjdCAnLS1zaG93LXdlYnZpZXcnIG9wdGlvbiBmb3IgVGlsZWQgRHJhd2luZyB0ZXN0cwpkaWZm IC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUdUSy5jbWFrZSBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggY2ZjMGQ4NzdiZTFiZDQwMTgyMmU5 MjU1YTIwMDFhZWQzMTAzMGNhYS4uZTA3OTc5M2FhMWY3MDc1Zjc3ZTJlNTFmNWQ5ZTVhNWRiNzk1 YWZhNyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUdUSy5jbWFrZQor KysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlCkBAIC0xMSw2ICsxMSw3 IEBAIHNldChGb3J3YXJkaW5nSGVhZGVyc0ZvclRlc3RXZWJLaXRBUElfTkFNRSBUZXN0V2ViS2l0 QVBJLWZvcndhcmRpbmctaGVhZGVycykKIAogaW5jbHVkZV9kaXJlY3RvcmllcygKICAgICAke0ZP UldBUkRJTkdfSEVBREVSU19ESVJ9CisgICAgJHtGT1JXQVJESU5HX0hFQURFUlNfRElSfS9KYXZh U2NyaXB0Q29yZQogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvQy9zb3VwCiAgICAg JHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQSS9DL2d0awogICAgICR7V0VCS0lUMl9ESVJ9L1VJ UHJvY2Vzcy9BUEkvZ3RrCkBAIC0xMjIsNiArMTIzLDggQEAgYWRkX2V4ZWN1dGFibGUoVGVzdFdl YkNvcmUKICAgICAke1RFU1RXRUJLSVRBUElfRElSfS9UZXN0c0NvbnRyb2xsZXIuY3BwCiAgICAg JHtURVNUV0VCS0lUQVBJX0RJUn0vVGVzdHMvV2ViQ29yZS9MYXlvdXRVbml0LmNwcAogICAgICR7 VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzL1dlYkNvcmUvVVJMLmNwcAorICAgICR7VEVTVFdFQktJ VEFQSV9ESVJ9L1Rlc3RzL1dlYkNvcmUvU2hhcmVkQnVmZmVyLmNwcAorICAgICR7VEVTVFdFQktJ VEFQSV9ESVJ9L1Rlc3RzL1dlYkNvcmUvRmlsZVN5c3RlbS5jcHAKICkKIAogdGFyZ2V0X2xpbmtf bGlicmFyaWVzKFRlc3RXZWJDb3JlICR7dGVzdF93ZWJjb3JlX0xJQlJBUklFU30pCmRpZmYgLS1n aXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCmluZGV4IDZmMGNkZGEzNzk3NDI0NmU0YjE5Yzg1NThiYTUwNmFmNmIxNDRh NGEuLjQ2OGVlNWUyZjk1M2QyYWJhNzg5MzU4YzBjOWFkMDg3OTdlNDM0NDAgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCkBAIC00NCw2ICs0NCw4IEBACiAJCTM3RDM2RUQ3MUFGNDJFQ0QwMEJBRjVE OSAvKiBMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDM3RDM2RUQ2MUFGNDJFQ0QwMEJBRjVEOSAvKiBMb2FkQWx0 ZXJuYXRlSFRNTFN0cmluZy5tbSAqLzsgfTsKIAkJMzdEQzY3OTExNDBEN0Q3NjAwQUJDQ0RCIC8q IERPTVJhbmdlT2ZTdHJpbmcuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSAzN0RDNjc4RjE0MEQ3RDNBMDBBQkNDREIgLyogRE9NUmFuZ2VP ZlN0cmluZy5odG1sICovOyB9OwogCQkzN0UxMDY0QzE2OTc2ODE4MDBCNzhCRDAgLyogRE9NSFRN TFRhYmxlQ2VsbEVsZW1lbnRDZWxsQWJvdmUuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzN0UxMDY0QjE2OTc2N0Y3MDBCNzhCRDAgLyog RE9NSFRNTFRhYmxlQ2VsbEVsZW1lbnRDZWxsQWJvdmUuaHRtbCAqLzsgfTsKKwkJNDE5NzNCNUIx QUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDE5NzNCNUExQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVT eXN0ZW0uY3BwICovOyB9OworCQk0MTk3M0I1RDFBRjIyODc1MDA2QzdCMzYgLyogU2hhcmVkQnVm ZmVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQx OTczQjVDMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRCdWZmZXIuY3BwICovOyB9OwogCQk0QkZE RkZBNzEzMTQ3NzZDMDA2MUYyNEIgLyogSGl0VGVzdFJlc3VsdE5vZGVIYW5kbGVfQnVuZGxlLmNw cCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRCRkRGRkE2 MTMxNDc3NkMwMDYxRjI0QiAvKiBIaXRUZXN0UmVzdWx0Tm9kZUhhbmRsZV9CdW5kbGUuY3BwICov OyB9OwogCQk1MTM5M0UyMjE1MjM5NTJEMDA1RjM5QzUgLyogRE9NV2luZG93RXh0ZW5zaW9uQmFz aWNfQnVuZGxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDUxMzkzRTFEMTUyMzk0NEEwMDVGMzlDNSAvKiBET01XaW5kb3dFeHRlbnNpb25CYXNpY19C dW5kbGUuY3BwICovOyB9OwogCQk1MTQyQjI3MzE1MTdDOEM4MDBDMzJCMTkgLyogQ29udGV4dE1l bnVDYW5Db3B5VVJMLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNTE0MkIyNzIxNTE3Qzg5MTAwQzMyQjE5IC8qIENvbnRleHRNZW51Q2Fu Q29weVVSTC5odG1sICovOyB9OwpAQCAtNDk0LDYgKzQ5Niw4IEBACiAJCTM3RTEwNjRBMTY5NzY3 NjQwMEI3OEJEMCAvKiBET01IVE1MVGFibGVDZWxsQ2VsbEFib3ZlLm1tICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gRE9NSFRNTFRhYmxlQ2VsbENlbGxBYm92ZS5tbTsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMzdFMTA2NEIxNjk3NjdGNzAwQjc4QkQwIC8q IERPTUhUTUxUYWJsZUNlbGxFbGVtZW50Q2VsbEFib3ZlLmh0bWwgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0 bWw7IHBhdGggPSBET01IVE1MVGFibGVDZWxsRWxlbWVudENlbGxBYm92ZS5odG1sOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQkzN0UzOEMzMzE2OUI3RDAxMDA4NEMyOEMgLyogV2ViVmll d0RpZFJlbW92ZUZyYW1lRnJvbUhpZXJhcmNoeS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw Lm9iamNwcDsgcGF0aCA9IFdlYlZpZXdEaWRSZW1vdmVGcmFtZUZyb21IaWVyYXJjaHkubW07IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQxOTczQjVBMUFGMjI4NkEwMDZDN0IzNiAvKiBG aWxlU3lzdGVtLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZpbGVT eXN0ZW0uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0MTk3M0I1QzFBRjIyODc1 MDA2QzdCMzYgLyogU2hhcmVkQnVmZmVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IFNoYXJlZEJ1ZmZlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTQ0MEExRDM4MTRBMDEwM0EwMDhBNjZGMiAvKiBVUkwuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gVVJMLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ NDRBNjIyQzExNEEwRTJCNjAwNDg1MTVCIC8qIFdURlN0cmluZ1V0aWxpdGllcy5oICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXVEZTdHJpbmdVdGlsaXRpZXMuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNEE0MTBGNEIxOUFGN0JENjAwMkVCQUI1IC8qIFVzZXJNZWRp YS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBVc2VyTWVkaWEuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNzY0LDYgKzc2OCw3IEBACiAJCTA4RkI3 Nzk1RkU4NDE1NURDMDJBQUMwNyAvKiBTb3VyY2UgKi8gPSB7CiAJCQlpc2EgPSBQQlhHcm91cDsK IAkJCWNoaWxkcmVuID0gKAorCQkJCTQ0QTgyRTdCMTkyNTFCMzUwMEMxQzhDNCAvKiBDb2NvYSAq LywKIAkJCQkwRjEzOUU3MTFBNDIzQTFEMDBGNTkwRjUgLyogY29jb2EgKi8sCiAJCQkJQkM1NzU5 NDQxMjZFNzMzQzAwNkYwRjEyIC8qIEluamVjdGVkQnVuZGxlICovLAogCQkJCTJFOTY2MERDMTZD MDdEN0IwMDM3MUI0MiAvKiBpb3MgKi8sCkBAIC04NTUsNyArODYwLDkgQEAKIAkJCQk3Q0IxODRD NDFBQTNGMjEwMDA2NkVERkQgLyogQ29udGVudEV4dGVuc2lvbnMuY3BwICovLAogCQkJCUNENTQ1 MUU5MTlFNDFGOUQwMDE2OTM2RiAvKiBDU1NQYXJzZXIuY3BwICovLAogCQkJCTI2RjZFMUVGMUFE Qzc0OUIwMERFNjk2QiAvKiBERkFNaW5pbWl6ZXIuY3BwICovLAorCQkJCTQxOTczQjVBMUFGMjI4 NkEwMDZDN0IzNiAvKiBGaWxlU3lzdGVtLmNwcCAqLywKIAkJCQkxNDQ2NDAxMjE2N0E4MzA1MDAw QkQyMTggLyogTGF5b3V0VW5pdC5jcHAgKi8sCisJCQkJNDE5NzNCNUMxQUYyMjg3NTAwNkM3QjM2 IC8qIFNoYXJlZEJ1ZmZlci5jcHAgKi8sCiAJCQkJQ0RDMkM3MTQxNzk3MDg5RDAwRTYyN0ZCIC8q IFRpbWVSYW5nZXMuY3BwICovLAogCQkJCTQ0MEExRDM4MTRBMDEwM0EwMDhBNjZGMiAvKiBVUkwu Y3BwICovLAogCQkJKTsKQEAgLTg2Nyw3ICs4NzQsOCBAQAogCQkJY2hpbGRyZW4gPSAoCiAJCQkJ OTNBN0VCM0MxOEZBNjNBNDAwOUU3NjcwIC8qIFVSTEV4dHJhcy5tbSAqLywKIAkJCSk7Ci0JCQlw YXRoID0gQ29jb2E7CisJCQluYW1lID0gQ29jb2E7CisJCQlwYXRoID0gVGVzdHMvQ29jb2E7CiAJ CQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwogCQl9OwogCQk3NTYwOTE3NjE5MjU5QzU5MDA5RUYw NkUgLyogaW9zICovID0gewpAQCAtMTE1Niw3ICsxMTY0LDYgQEAKIAkJQkNCOUVCNjYxMTIzNjZE ODAwQTEzN0UwIC8qIFRlc3RzICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJCQljaGlsZHJl biA9ICgKLQkJCQk0NEE4MkU3QjE5MjUxQjM1MDBDMUM4QzQgLyogQ29jb2EgKi8sCiAJCQkJNzU2 MDkxNzYxOTI1OUM1OTAwOUVGMDZFIC8qIGlvcyAqLywKIAkJCQlGRTIxN0VDQjE2NDBBNTRBMDA1 Mjk4OEIgLyogSmF2YVNjcmlwdENvcmUgKi8sCiAJCQkJQzA3RTZDQUQxM0ZENjc2NTAwMzhCMjJC IC8qIG1hYyAqLywKQEAgLTE1ODksOCArMTU5NiwxMCBAQAogCQkJCTJEMUZFMEIwMUFENDY1QzEw MDZDRDlFNiAvKiBGaXhlZExheW91dFNpemUubW0gaW4gU291cmNlcyAqLywKIAkJCQkxQ0I5QkMz ODFBNjc0ODIzMDBGRTU2NzggLyogV2Vha1B0ci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkyRTc3 NjVDRDE2QzREODBBMDBCQTJCQjEgLyogbWFpbklPUy5tbSBpbiBTb3VyY2VzICovLAorCQkJCTQx OTczQjVEMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRCdWZmZXIuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJN0FBNkExNTIxQUFDMEIzMTAwMkIyRUQzIC8qIFdvcmtRdWV1ZS5jcHAgaW4gU291cmNl cyAqLywKIAkJCQkyRTc3NjVDRjE2QzREODExMDBCQTJCQjEgLyogbWFpbk1hYy5tbSBpbiBTb3Vy Y2VzICovLAorCQkJCTQxOTczQjVCMUFGMjI4NkEwMDZDN0IzNiAvKiBGaWxlU3lzdGVtLmNwcCBp biBTb3VyY2VzICovLAogCQkJCTdBNTYyMzExMUFENUFGM0UwMDk2QjkyMCAvKiBNZW51VHlwZXNG b3JNb3VzZUV2ZW50cy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkyNkY2RTFGMDFBREM3NDlCMDBE RTY5NkIgLyogREZBTWluaW1pemVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdBOTlEOTk0MUFE NEEyOUQwMDM3MzE0MSAvKiBNZW51VHlwZXNGb3JNb3VzZUV2ZW50cy5tbSBpbiBTb3VyY2VzICov LApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0ZpbGVTeXN0 ZW0uY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL0ZpbGVTeXN0ZW0uY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmEwZWNmNjFlZjc0MTM5NmVlMjA4YzMzZjRlOGE1Njk3M2M3YTZiYmUKLS0t IC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmlsZVN5 c3RlbS5jcHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNSBDYW5v biBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMn JworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMK KyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAq IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICog VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKworI2luY2x1ZGUgIlRlc3QuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL0ZpbGVTeXN0ZW0uaD4K KyNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgorI2luY2x1ZGUgPHd0Zi9TdHJpbmdFeHRyYXMu aD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBUZXN0V2ViS2l0QVBJ IHsKKworY29uc3QgY2hhciogRmlsZVN5c3RlbVRlc3REYXRhID0gIlRoaXMgaXMgYSB0ZXN0IjsK KworLy8gRklYTUU6IFJlZmFjdG9yIEZpbGVTeXN0ZW1UZXN0IGFuZCBTaGFyZWRCdWZmZXJUZXN0 IGFzIGEgc2luZ2xlIGNsYXNzLgorY2xhc3MgRmlsZVN5c3RlbVRlc3QgOiBwdWJsaWMgdGVzdGlu Zzo6VGVzdCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2b2lkIFNldFVwKCkgb3ZlcnJpZGUKKyAg ICB7CisgICAgICAgIFdURjo6aW5pdGlhbGl6ZU1haW5UaHJlYWQoKTsKKyAgICAgICAgCisgICAg ICAgIC8vIGNyZWF0ZSB0ZW1wIGZpbGUKKyAgICAgICAgUGxhdGZvcm1GaWxlSGFuZGxlIGhhbmRs ZTsKKyAgICAgICAgbV90ZW1wRmlsZVBhdGggPSBvcGVuVGVtcG9yYXJ5RmlsZSgidGVtcFRlc3RG aWxlIiwgaGFuZGxlKTsKKyAgICAgICAgd3JpdGVUb0ZpbGUoaGFuZGxlLCBGaWxlU3lzdGVtVGVz dERhdGEsIHN0cmxlbihGaWxlU3lzdGVtVGVzdERhdGEpKTsKKyAgICAgICAgY2xvc2VGaWxlKGhh bmRsZSk7IAorCisgICAgICAgIG1fdGVtcEVtcHR5RmlsZVBhdGggPSBvcGVuVGVtcG9yYXJ5Rmls ZSgidGVtcEVtcHR5VGVzdEZpbGUiLCBoYW5kbGUpOworICAgICAgICBjbG9zZUZpbGUoaGFuZGxl KTsgCisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIFRlYXJEb3duKCkgb3ZlcnJpZGUKKyAgICB7 CisgICAgICAgIGRlbGV0ZUZpbGUobV90ZW1wRmlsZVBhdGgpOworICAgICAgICBkZWxldGVGaWxl KG1fdGVtcEVtcHR5RmlsZVBhdGgpOworICAgIH0KKworICAgIGNvbnN0IFN0cmluZyYgdGVtcEZp bGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRmlsZVBhdGg7IH0KKyAgICBjb25zdCBTdHJpbmcmIHRl bXBFbXB0eUZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRW1wdHlGaWxlUGF0aDsgfQorCitwcml2 YXRlOgorICAgIFN0cmluZyBtX3RlbXBGaWxlUGF0aDsKKyAgICBTdHJpbmcgbV90ZW1wRW1wdHlG aWxlUGF0aDsKK307CisKK1RFU1RfRihGaWxlU3lzdGVtVGVzdCwgTWFwcGluZ01pc3NpbmdGaWxl KQoreworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhOworICAgIEVYUEVDVF9GQUxT RShtYXBwZWRGaWxlRGF0YS5tYXAoU3RyaW5nKCJub3RfZXhpc3RpbmdfZmlsZSIpKSk7Cit9CisK K1RFU1RfRihGaWxlU3lzdGVtVGVzdCwgTWFwcGluZ0V4aXN0aW5nRmlsZSkKK3sKKyAgICBNYXBw ZWRGaWxlRGF0YSBtYXBwZWRGaWxlRGF0YTsKKyAgICBFWFBFQ1RfVFJVRShtYXBwZWRGaWxlRGF0 YS5tYXAodGVtcEZpbGVQYXRoKCkpKTsKKyAgICBFWFBFQ1RfVFJVRShtYXBwZWRGaWxlRGF0YS5z aXplKCkgPT0gc3RybGVuKEZpbGVTeXN0ZW1UZXN0RGF0YSkpOworICAgIEVYUEVDVF9UUlVFKHN0 cm5zdHIoRmlsZVN5c3RlbVRlc3REYXRhLCBzdGF0aWNfY2FzdDxjb25zdCBjaGFyKj4obWFwcGVk RmlsZURhdGEuZGF0YSgpKSwgbWFwcGVkRmlsZURhdGEuc2l6ZSgpKSk7Cit9CisKK1RFU1RfRihG aWxlU3lzdGVtVGVzdCwgTWFwcGluZ0V4aXN0aW5nRW1wdHlGaWxlKQoreworICAgIE1hcHBlZEZp bGVEYXRhIG1hcHBlZEZpbGVEYXRhOworICAgIEVYUEVDVF9UUlVFKG1hcHBlZEZpbGVEYXRhLm1h cCh0ZW1wRW1wdHlGaWxlUGF0aCgpKSk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJDb3JlL1NoYXJlZEJ1ZmZlci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMTllOTBiNmQw OGUxMjZmY2ZmYjk1ODdiMDJiNzcyODYxMzJhYmE1OAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0wLDAgKzEs MTE5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgor ICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAq IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiVGVz dC5oIgorI2luY2x1ZGUgPFdlYkNvcmUvU2hhcmVkQnVmZmVyLmg+CisjaW5jbHVkZSA8d3RmL01h aW5UaHJlYWQuaD4KKyNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CisKK3VzaW5nIG5hbWVz cGFjZSBXZWJDb3JlOworCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK2NvbnN0IGNoYXIq IFNoYXJlZEJ1ZmZlclRlc3REYXRhID0gIlRoaXMgaXMgYSB0ZXN0IjsKKworY2xhc3MgU2hhcmVk QnVmZmVyVGVzdCA6IHB1YmxpYyB0ZXN0aW5nOjpUZXN0IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFs IHZvaWQgU2V0VXAoKSBvdmVycmlkZQorICAgIHsKKyAgICAgICAgV1RGOjppbml0aWFsaXplTWFp blRocmVhZCgpOworICAgICAgICAKKyAgICAgICAgLy8gY3JlYXRlIHRlbXAgZmlsZQorICAgICAg ICBQbGF0Zm9ybUZpbGVIYW5kbGUgaGFuZGxlOworICAgICAgICBtX3RlbXBGaWxlUGF0aCA9IG9w ZW5UZW1wb3JhcnlGaWxlKCJ0ZW1wVGVzdEZpbGUiLCBoYW5kbGUpOworICAgICAgICB3cml0ZVRv RmlsZShoYW5kbGUsIFNoYXJlZEJ1ZmZlclRlc3REYXRhLCBzdHJsZW4oU2hhcmVkQnVmZmVyVGVz dERhdGEpKTsKKyAgICAgICAgY2xvc2VGaWxlKGhhbmRsZSk7IAorCisgICAgICAgIG1fdGVtcEVt cHR5RmlsZVBhdGggPSBvcGVuVGVtcG9yYXJ5RmlsZSgidGVtcEVtcHR5VGVzdEZpbGUiLCBoYW5k bGUpOworICAgICAgICBjbG9zZUZpbGUoaGFuZGxlKTsgCisgICAgfQorCisgICAgdmlydHVhbCB2 b2lkIFRlYXJEb3duKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIGRlbGV0ZUZpbGUobV90ZW1w RmlsZVBhdGgpOworICAgICAgICBkZWxldGVGaWxlKG1fdGVtcEVtcHR5RmlsZVBhdGgpOworICAg IH0KKworICAgIGNvbnN0IFN0cmluZyYgdGVtcEZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRmls ZVBhdGg7IH0KKyAgICBjb25zdCBTdHJpbmcmIHRlbXBFbXB0eUZpbGVQYXRoKCkgeyByZXR1cm4g bV90ZW1wRW1wdHlGaWxlUGF0aDsgfQorCitwcml2YXRlOgorICAgIFN0cmluZyBtX3RlbXBGaWxl UGF0aDsKKyAgICBTdHJpbmcgbV90ZW1wRW1wdHlGaWxlUGF0aDsKK307CisKK1RFU1RfRihTaGFy ZWRCdWZmZXJUZXN0LCBjcmVhdGVXaXRoQ29udGVudHNPZk1pc3NpbmdGaWxlKQoreworICAgIFJl ZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRl bnRzT2ZGaWxlKFN0cmluZygibm90X2V4aXN0aW5nX2ZpbGUiKSk7CisgICAgQVNTRVJUX05VTEwo YnVmZmVyKTsKK30KKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNyZWF0ZVdpdGhDb250ZW50 c09mRXhpc3RpbmdGaWxlKQoreworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNo YXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKHRlbXBGaWxlUGF0aCgpKTsKKyAg ICBBU1NFUlRfTk9UX05VTEwoYnVmZmVyKTsKKyAgICBFWFBFQ1RfVFJVRShidWZmZXItPnNpemUo KSA9PSBzdHJsZW4oU2hhcmVkQnVmZmVyVGVzdERhdGEpKTsKKyAgICBFWFBFQ1RfVFJVRShTdHJp bmcoU2hhcmVkQnVmZmVyVGVzdERhdGEpID09IFN0cmluZyhidWZmZXItPmRhdGEoKSwgYnVmZmVy LT5zaXplKCkpKTsKK30KKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNyZWF0ZVdpdGhDb250 ZW50c09mRXhpc3RpbmdFbXB0eUZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVm ZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUodGVtcEVtcHR5Rmls ZVBhdGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgRVhQRUNUX1RSVUUo YnVmZmVyLT5pc0VtcHR5KCkpOworfQorCitURVNUX0YoU2hhcmVkQnVmZmVyVGVzdCwgY29weUJ1 ZmZlckNyZWF0ZWRXaXRoQ29udGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBSZWZQdHI8U2hh cmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmls ZSh0ZW1wRmlsZVBhdGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgUmVm UHRyPFNoYXJlZEJ1ZmZlcj4gY29weSA9IGJ1ZmZlci0+Y29weSgpOworICAgIEVYUEVDVF9UUlVF KGJ1ZmZlci0+c2l6ZSgpID09IGNvcHktPnNpemUoKSk7CisgICAgRVhQRUNUX1RSVUUoc3RybnN0 cihidWZmZXItPmRhdGEoKSwgY29weS0+ZGF0YSgpLCBidWZmZXItPnNpemUoKSkpOworfQorCitU RVNUX0YoU2hhcmVkQnVmZmVyVGVzdCwgY2xlYXJCdWZmZXJDcmVhdGVkV2l0aENvbnRlbnRzT2ZF eGlzdGluZ0ZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUodGVtcEZpbGVQYXRoKCkpOworICAgIEFT U0VSVF9OT1RfTlVMTChidWZmZXIpOworICAgIGJ1ZmZlci0+Y2xlYXIoKTsKKyAgICBFWFBFQ1Rf VFJVRSghYnVmZmVyLT5zaXplKCkpOworICAgIEVYUEVDVF9UUlVFKCFidWZmZXItPmRhdGEoKSk7 Cit9CisKKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGFwcGVuZEJ1ZmZlckNyZWF0ZWRXaXRo Q29udGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZm ZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSh0ZW1wRmlsZVBhdGgo KSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgYnVmZmVyLT5hcHBlbmQoImEi LCAxKTsKKyAgICBFWFBFQ1RfVFJVRShidWZmZXItPnNpemUoKSA9PSAoc3RybGVuKFNoYXJlZEJ1 ZmZlclRlc3REYXRhKSArIDEpKTsKKyAgICBFWFBFQ1RfVFJVRShzdHJuc3RyKGJ1ZmZlci0+ZGF0 YSgpLCBTaGFyZWRCdWZmZXJUZXN0RGF0YSwgc3RybGVuKFNoYXJlZEJ1ZmZlclRlc3REYXRhKSkp OworICAgIEVYUEVDVF9FUSgnYScsIGJ1ZmZlci0+ZGF0YSgpW3N0cmxlbihTaGFyZWRCdWZmZXJU ZXN0RGF0YSldKTsKK30KKworfQo= 253029 2015-05-13 03:21:39 -0700 2015-05-13 05:30:48 -0700 Constructor with boolean bug-144192-20150513122009.patch text/plain 32121 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0MTcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDRiODlhNGNmZTZkODJi NmUxM2ZlZTE4MmQ1NDBkODNlYWFiMjAwYS4uNzIyMjAzYmZhODVmZDNlYWFiOTRhZmE4ZjBhYjI2 MDQ0YzUxYzFmNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDE1LTA1LTEyICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIElmIG1hcHBp bmcgaXMgZmFpbGluZywgaXQgZmFsbHMgYmFjayB0byB0aGUgcHJldmlvdXMgdmVyc2lvbiBvZiBT aGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSByZW5hbWVkIGFzCisgICAgICAg IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlICh1c2luZyBvcGVuL3JlYWQgbWV0 aG9kKS4KKyAgICAgICAgRmlsZSBjb250ZW50IGlzIG1hcHBlZCB1bnRpbCBTaGFyZWRCdWZmZXIg aXMgY2xlYXJlZCwgZGVzdHJveWVkIG9yIGFkZGl0aW9uYWwgY29udGVudCBpcyBhcHBlbmRlZCB0 byB0aGUgU2hhcmVkQnVmZmVyLgorCisgICAgICAgIEEgaGVscGVyIGNsYXNzLCBNYXBwZWRGaWxl RGF0YSwgaXMgaW50cm9kdWNlZCB0byBoYW5kbGUgbWFwcGVkIGZpbGVzIHRocm91Z2ggY2FsbHMg dG8gb3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAgICBQYXRjaCBjb3ZlcmVkIGJ5IGV4 aXN0aW5nIGxheW91dCB0ZXN0cyBhbmQgYWRkZWQgdW5pdCB0ZXN0cy4KKworICAgICAgICAqIHBs YXRmb3JtL0ZpbGVTeXN0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6 Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpvcGVy YXRvcj0pOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0 YSk6CisgICAgICAgICogcGxhdGZvcm0vRmlsZVN5c3RlbS5oOgorICAgICAgICAoV2ViQ29yZTo6 TWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBl ZEZpbGVEYXRhOjpvcGVyYXRvciBib29sKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVE YXRhOjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpzaXplKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpTaGFyZWRCdWZmZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVy OjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOiBNYWtpbmcgdXNlIG9mIE1hcHBlZEZpbGVEYXRh IGJlZm9yZSB1c2luZyBjcmVhdGVGcm9tUmVhZGluZ0ZpbGUuCisgICAgICAgIChXZWJDb3JlOjpT aGFyZWRCdWZmZXI6OnNpemUpOiBDaGVja2luZyB3aGV0aGVyIGRhdGEgaXMgY29taW5nIGZyb20g YSBNYXBwZWRGaWxlRGF0YS4KKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6ZGF0YSk6 IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjphcHBlbmQpOiBEaXR0by4K KyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOiBDbGVhcmluZyBNYXBwZWRG aWxlRGF0YSBpZiBuZWVkZWQuCisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OmNvcHkp OiBUcmFuc2ZlcnJpbmcgbWFwcGVkIGRhdGEgdG8gYnVmZmVyIGlmIG5lZWRlZC4KKyAgICAgICAg KFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6 U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEpOgorICAgICAgICAqIHBs YXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9TaGFyZWRCdWZm ZXJHdGsuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVh ZGluZ0ZpbGUpOiByZW5hbWVkIGZyb20gY3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorICAgICAg ICAqIHBsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW06CisgICAgICAgIChXZWJDb3JlOjpT aGFyZWRCdWZmZXI6OmNyZWF0ZUZyb21SZWFkaW5nRmlsZSk6IERpdG8uCisgICAgICAgICogcGxh dGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0ZpbGUpOiBEaXR0by4KKyAgICAgICAgKiBwbGF0 Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1 ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlKTogRGl0dG8uCisKIDIwMTUtMDUtMTIgIFhhYmll ciBSb2RyaWd1ZXogQ2FsdmFyICA8Y2FsdmFyaXNAaWdhbGlhLmNvbT4gYW5kIFlvdWVubiBGYWJs ZXQgPHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgogCiAgICAgICAgIFtTdHJlYW1zIEFQSV0g UmVhZGFibGVTdHJlYW0gcmVhZGVyIHNob3VsZCBub3QgYmUgZGlzcG9zYWJsZSB3aGVuIGhhdmlu ZyBwZW5kaW5nIHByb21pc2VzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9G aWxlU3lzdGVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCmlu ZGV4IDk3Yjg0NmVlY2M0YzYzMGRkYmEwNmQ0YzU3ZDM2MTc2OGQ4ZWNmZGYuLmFjMTk0ZWM0NDdl NDVkMzdjNmE5MzkyY2I5MzRmOTY0Y2NlZGExY2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0Zp bGVTeXN0ZW0uY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNywg MjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIw MTUgQ2Fub24gSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCkBAIC0yNyw4ICsyOCwxNiBAQAogI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKIAog I2luY2x1ZGUgPHd0Zi9IZXhOdW1iZXIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+ CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCisjaWYgIVBMQVRGT1JNKFdJ TikKKyNpbmNsdWRlIDxmY250bC5oPgorI2luY2x1ZGUgPHN5cy9tbWFuLmg+CisjaW5jbHVkZSA8 c3lzL3N0YXQuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNlbmRpZgorCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKIC8vIFRoZSBmb2xsb3dpbmcgbG93ZXItQVNDSUkgY2hhcmFjdGVycyBuZWVkIGVz Y2FwaW5nIHRvIGJlIHVzZWQgaW4gYSBmaWxlbmFtZQpAQCAtMTEzLDQgKzEyMiw2OCBAQCBib29s IGV4Y2x1ZGVGcm9tQmFja3VwKGNvbnN0IFN0cmluZyYpCiAKICNlbmRpZgogCitNYXBwZWRGaWxl RGF0YTo6fk1hcHBlZEZpbGVEYXRhKCkKK3sKKyNpZiAhUExBVEZPUk0oV0lOKQorICAgIGlmICgh bV9maWxlRGF0YSkKKyAgICAgICAgcmV0dXJuOworICAgIG11bm1hcChtX2ZpbGVEYXRhLCBtX2Zp bGVTaXplKTsKKyAgICBtX2ZpbGVEYXRhID0gbnVsbHB0cjsKKyNlbmRpZgorfQorCitNYXBwZWRG aWxlRGF0YTo6TWFwcGVkRmlsZURhdGEoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCwgYm9vbCYgc3Vj Y2VzcykKK3sKKyNpZiBQTEFURk9STShXSU4pCisgICAgLy8gRklYTUU6IEltcGxlbWVudCBtYXBw aW5nCisgICAgc3VjY2VzcyA9IGZhbHNlOworICAgIHJldHVybjsKKyNlbHNlCisgICAgQ1N0cmlu ZyBmc1JlcCA9IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0aCk7CisgICAgaWYgKCFm c1JlcC5kYXRhKCkgfHwgZnNSZXAuZGF0YSgpWzBdID09ICdcMCcpIHsKKyAgICAgICAgc3VjY2Vz cyA9IGZhbHNlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaW50IGZkID0gb3Blbihm c1JlcC5kYXRhKCksIE9fUkRPTkxZKTsKKyAgICBpZiAoZmQgPCAwKSB7CisgICAgICAgIHN1Y2Nl c3MgPSBmYWxzZTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHN0cnVjdCBzdGF0IGZp bGVTdGF0OworICAgIGlmIChmc3RhdChmZCwgJmZpbGVTdGF0KSkgeworICAgICAgICBjbG9zZShm ZCk7CisgICAgICAgIHN1Y2Nlc3MgPSBmYWxzZTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwor ICAgIGlmIChmaWxlU3RhdC5zdF9zaXplIDwgMCB8fCBmaWxlU3RhdC5zdF9zaXplID4gc3RkOjpu dW1lcmljX2xpbWl0czx1bnNpZ25lZD46Om1heCgpKSB7CisgICAgICAgIGNsb3NlKGZkKTsKKyAg ICAgICAgc3VjY2VzcyA9IGZhbHNlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgdW5z aWduZWQgc2l6ZSA9IHN0YXRpY19jYXN0PHVuc2lnbmVkPihmaWxlU3RhdC5zdF9zaXplKTsKKwor ICAgIGlmICghc2l6ZSkgeworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHN1Y2Nlc3MgPSB0 cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgdm9pZCogZGF0YSA9IG1tYXAoMCwg c2l6ZSwgUFJPVF9SRUFELCBNQVBfRklMRSB8IE1BUF9TSEFSRUQsIGZkLCAwKTsKKyAgICBjbG9z ZShmZCk7CisKKyAgICBpZiAoZGF0YSA9PSBNQVBfRkFJTEVEKSB7CisgICAgICAgIHN1Y2Nlc3Mg PSBmYWxzZTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHN1Y2Nlc3MgPSB0cnVlOwor ICAgIG1fZmlsZURhdGEgPSBkYXRhOworICAgIG1fZmlsZVNpemUgPSBzaXplOworI2VuZGlmCit9 CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL0ZpbGVTeXN0ZW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0u aAppbmRleCAzYTdmYjRiOWUyODNiYjM5MDg3YWMwYTI0NzUyMTc3ZTBkNzZjMDQ2Li43NjdhZDJk MjBlN2EzODI5MTBiMTRhYTQwNjcwYzhhYzQ3ZDhjY2E2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v RmlsZVN5c3RlbS5oCkBAIC0xLDYgKzEsNyBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNywg MjAwOCwgMjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKiBDb3B5cmlnaHQg KEMpIDIwMDggQ29sbGFib3JhLCBMdGQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmln aHQgKEMpIDIwMTUgQ2Fub24gSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCkBAIC0yMDQsNiArMjA1LDM2IEBAIFdFQkNPUkVfRVhQT1JUIFN0 cmluZyBsb2NhbFVzZXJTcGVjaWZpY1N0b3JhZ2VEaXJlY3RvcnkoKTsKIFN0cmluZyByb2FtaW5n VXNlclNwZWNpZmljU3RvcmFnZURpcmVjdG9yeSgpOwogI2VuZGlmCiAKK2NsYXNzIE1hcHBlZEZp bGVEYXRhIHsKK3B1YmxpYzoKKyAgICBNYXBwZWRGaWxlRGF0YSgpIHsgfQorICAgIFdFQkNPUkVf RVhQT1JUIE1hcHBlZEZpbGVEYXRhKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgsIGJvb2wmIHN1Y2Nl c3MpOworICAgIFdFQkNPUkVfRVhQT1JUIE1hcHBlZEZpbGVEYXRhKE1hcHBlZEZpbGVEYXRhJiYp OworICAgIFdFQkNPUkVfRVhQT1JUIH5NYXBwZWRGaWxlRGF0YSgpOworICAgIE1hcHBlZEZpbGVE YXRhJiBvcGVyYXRvcj0oTWFwcGVkRmlsZURhdGEmJik7CisKKyAgICBleHBsaWNpdCBvcGVyYXRv ciBib29sKCkgY29uc3QgeyByZXR1cm4gISFtX2ZpbGVEYXRhOyB9CisgICAgY29uc3Qgdm9pZCog ZGF0YSgpIGNvbnN0IHsgcmV0dXJuIG1fZmlsZURhdGE7IH0KKyAgICB1bnNpZ25lZCBzaXplKCkg Y29uc3QgeyByZXR1cm4gbV9maWxlU2l6ZTsgfQorCitwcml2YXRlOgorICAgIHZvaWQqIG1fZmls ZURhdGEgeyBudWxscHRyIH07CisgICAgdW5zaWduZWQgbV9maWxlU2l6ZSB7IDAgfTsKK307CisK K2lubGluZSBNYXBwZWRGaWxlRGF0YTo6TWFwcGVkRmlsZURhdGEoTWFwcGVkRmlsZURhdGEmJiBv dGhlcikKK3sKKyAgICBtX2ZpbGVEYXRhID0gc3RkOjpleGNoYW5nZShvdGhlci5tX2ZpbGVEYXRh LCBudWxscHRyKTsKKyAgICBtX2ZpbGVTaXplID0gc3RkOjpleGNoYW5nZShvdGhlci5tX2ZpbGVT aXplLCAwKTsKK30KKworaW5saW5lIE1hcHBlZEZpbGVEYXRhJiBNYXBwZWRGaWxlRGF0YTo6b3Bl cmF0b3I9KE1hcHBlZEZpbGVEYXRhJiYgb3RoZXIpCit7CisgICAgbV9maWxlRGF0YSA9IHN0ZDo6 ZXhjaGFuZ2Uob3RoZXIubV9maWxlRGF0YSwgbnVsbHB0cik7CisgICAgbV9maWxlU2l6ZSA9IHN0 ZDo6ZXhjaGFuZ2Uob3RoZXIubV9maWxlU2l6ZSwgMCk7CisgICAgcmV0dXJuICp0aGlzOworfQor CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBGaWxlU3lzdGVtX2gKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCmluZGV4IDlkYjdmYWQyMDgwMjdlMWYx ZTdlMDE0ODUzZTIxNThlNmQyNmYyMTYuLmQ0YzM2Yzc1MmU2MGFlNDVkZWM3YTkyMzlmNWFjNGEz N2JmYjAwYjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcApAQCAt MSw2ICsxLDcgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDYsIDIwMDggQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgogICogQ29weXJpZ2h0IChDKSBSZXNlYXJjaCBJbiBNb3Rpb24g TGltaXRlZCAyMDA5LTIwMTAuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMp IDIwMTUgQ2Fub24gSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAog ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCkBAIC04MiwxMiArODMsMzQgQEAgU2hhcmVkQnVmZmVyOjpTaGFyZWRCdWZm ZXIoY29uc3QgdW5zaWduZWQgY2hhciogZGF0YSwgdW5zaWduZWQgc2l6ZSkKIHsKICAgICBhcHBl bmQocmVpbnRlcnByZXRfY2FzdDxjb25zdCBjaGFyKj4oZGF0YSksIHNpemUpOwogfQotICAgIAor CitTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcihNYXBwZWRGaWxlRGF0YSYmIGZpbGVEYXRhKQor ICAgIDogbV9idWZmZXIoYWRvcHRSZWYobmV3IERhdGFCdWZmZXIpKQorICAgICwgbV9maWxlRGF0 YShXVEY6Om1vdmUoZmlsZURhdGEpKQoreworfQorCiBTaGFyZWRCdWZmZXI6On5TaGFyZWRCdWZm ZXIoKQogewogICAgIGNsZWFyKCk7CiB9CiAKK1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1 ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCit7 CisgICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisK KyAgICBib29sIG1hcHBpbmdTdWNjZXNzOworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVE YXRhKGZpbGVQYXRoLCBtYXBwaW5nU3VjY2Vzcyk7CisKKyAgICBpZiAoIW1hcHBpbmdTdWNjZXNz KQorICAgICAgICByZXR1cm4gU2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0ZpbGUoZmls ZVBhdGgpOworCisgICAgaWYgKCFtYXBwZWRGaWxlRGF0YSkKKyAgICAgICAgcmV0dXJuIFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlKCk7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBTaGFyZWRCdWZmZXIo V1RGOjptb3ZlKG1hcHBlZEZpbGVEYXRhKSkpOworfQorCiBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZl cj4gU2hhcmVkQnVmZmVyOjphZG9wdFZlY3RvcihWZWN0b3I8Y2hhcj4mIHZlY3RvcikKIHsKICAg ICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZmZXIgPSBjcmVhdGUoKTsKQEAgLTEwMSwxNSArMTI0 LDIwIEBAIHVuc2lnbmVkIFNoYXJlZEJ1ZmZlcjo6c2l6ZSgpIGNvbnN0CiAgICAgaWYgKGhhc1Bs YXRmb3JtRGF0YSgpKQogICAgICAgICByZXR1cm4gcGxhdGZvcm1EYXRhU2l6ZSgpOwogICAgIAor ICAgIGlmIChtX2ZpbGVEYXRhKQorICAgICAgICByZXR1cm4gbV9maWxlRGF0YS5zaXplKCk7CisK ICAgICByZXR1cm4gbV9zaXplOwogfQogCiBjb25zdCBjaGFyKiBTaGFyZWRCdWZmZXI6OmRhdGEo KSBjb25zdAogewotCiAgICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKQogICAgICAgICByZXR1cm4g cGxhdGZvcm1EYXRhKCk7CiAKKyAgICBpZiAobV9maWxlRGF0YSkKKyAgICAgICAgcmV0dXJuIHN0 YXRpY19jYXN0PGNvbnN0IGNoYXIqPihtX2ZpbGVEYXRhLmRhdGEoKSk7CisKICNpZiBVU0UoTkVU V09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCiAgICAgaWYgKGNvbnN0IGNoYXIqIGJ1ZmZlciA9 IHNpbmdsZURhdGFBcnJheUJ1ZmZlcigpKQogICAgICAgICByZXR1cm4gYnVmZmVyOwpAQCAtMTYw LDYgKzE4OCw3IEBAIHZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgY2hhciogZGF0YSwg dW5zaWduZWQgbGVuZ3RoKQogICAgIGlmICghbGVuZ3RoKQogICAgICAgICByZXR1cm47CiAKKyAg ICBtYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEoKTsKICAgICBtYXliZVRyYW5zZmVyUGxhdGZv cm1EYXRhKCk7CiAKICNpZiAhVVNFKE5FVFdPUktfQ0ZEQVRBX0FSUkFZX0NBTExCQUNLKQpAQCAt MjEwLDYgKzIzOSw4IEBAIHZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgVmVjdG9yPGNo YXI+JiBkYXRhKQogCiB2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXIoKQogeworICAgIG1fZmlsZURh dGEgPSB7IH07CisKICAgICBjbGVhclBsYXRmb3JtRGF0YSgpOwogICAgIAogI2lmICFVU0UoTkVU V09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC0yMjcsNyArMjU4LDggQEAgdm9pZCBTaGFy ZWRCdWZmZXI6OmNsZWFyKCkKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6 OmNvcHkoKSBjb25zdAogewogICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNsb25lIHsgYWRvcHRS ZWYoKm5ldyBTaGFyZWRCdWZmZXIpIH07Ci0gICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7CisK KyAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkgfHwgbV9maWxlRGF0YSkgewogICAgICAgICBjbG9u ZS0+YXBwZW5kKGRhdGEoKSwgc2l6ZSgpKTsKICAgICAgICAgcmV0dXJuIGNsb25lLnJlbGVhc2Uo KTsKICAgICB9CkBAIC0zMTAsNyArMzQyLDcgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpnZXRT b21lRGF0YShjb25zdCBjaGFyKiYgc29tZURhdGEsIHVuc2lnbmVkIHBvc2l0aW9uKSBjb24KICAg ICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0gICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpKSB7Cisg ICAgaWYgKGhhc1BsYXRmb3JtRGF0YSgpIHx8IG1fZmlsZURhdGEpIHsKICAgICAgICAgQVNTRVJU X1dJVEhfU0VDVVJJVFlfSU1QTElDQVRJT04ocG9zaXRpb24gPCBzaXplKCkpOwogICAgICAgICBz b21lRGF0YSA9IGRhdGEoKSArIHBvc2l0aW9uOwogICAgICAgICByZXR1cm4gdG90YWxTaXplIC0g cG9zaXRpb247CkBAIC0zNDMsNiArMzc1LDE0IEBAIHVuc2lnbmVkIFNoYXJlZEJ1ZmZlcjo6Z2V0 U29tZURhdGEoY29uc3QgY2hhciomIHNvbWVEYXRhLCB1bnNpZ25lZCBwb3NpdGlvbikgY29uCiAj ZW5kaWYKIH0KIAordm9pZCBTaGFyZWRCdWZmZXI6Om1heWJlVHJhbnNmZXJNYXBwZWRGaWxlRGF0 YSgpCit7CisgICAgaWYgKG1fZmlsZURhdGEpIHsKKyAgICAgICAgYXV0byBmaWxlRGF0YSA9IFdU Rjo6bW92ZShtX2ZpbGVEYXRhKTsKKyAgICAgICAgYXBwZW5kKHN0YXRpY19jYXN0PGNvbnN0IGNo YXIqPihmaWxlRGF0YS5kYXRhKCkpLCBmaWxlRGF0YS5zaXplKCkpOworICAgIH0KK30KKwogI2lm ICFVU0UoQ0YpICYmICFVU0UoU09VUCkKIAogaW5saW5lIHZvaWQgU2hhcmVkQnVmZmVyOjpjbGVh clBsYXRmb3JtRGF0YSgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFy ZWRCdWZmZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oCmluZGV4 IDA0NTVkNzk5NDA2NjAzY2ExMzJkYTc5ZDE4MzA0YjZkYjNlYjBmNDguLjQ0YWE4MTgyMWRlNTE2 ODgxZDQ1YWJkMzg3NDBiYTg4ZDg2ZWU5MjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1NoYXJlZEJ1ZmZlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJl ZEJ1ZmZlci5oCkBAIC0yNyw2ICsyNyw3IEBACiAjaWZuZGVmIFNoYXJlZEJ1ZmZlcl9oCiAjZGVm aW5lIFNoYXJlZEJ1ZmZlcl9oCiAKKyNpbmNsdWRlICJGaWxlU3lzdGVtLmgiCiAjaW5jbHVkZSA8 cnVudGltZS9BcnJheUJ1ZmZlci5oPgogI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+CiAjaW5jbHVk ZSA8d3RmL1JlZkNvdW50ZWQuaD4KQEAgLTU1LDcgKzU2LDcgQEAgcHVibGljOgogICAgIHN0YXRp YyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY3JlYXRlKGNvbnN0IGNoYXIqIGMsIHVuc2lnbmVk IGkpIHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBTaGFyZWRCdWZmZXIoYywgaSkpOyB9CiAgICAgc3Rh dGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGUoY29uc3QgdW5zaWduZWQgY2hhciog YywgdW5zaWduZWQgaSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihjLCBpKSk7 IH0KIAotICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4g Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpOworICAgIFdF QkNPUkVfRVhQT1JUIHN0YXRpYyBSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGVXaXRoQ29udGVu dHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCk7CiAKICAgICBXRUJDT1JFX0VYUE9SVCBz dGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGFkb3B0VmVjdG9yKFZlY3RvcjxjaGFyPiYg dmVjdG9yKTsKICAgICAKQEAgLTkyLDcgKzkzLDcgQEAgcHVibGljOgogICAgIFdFQkNPUkVfRVhQ T1JUIHZvaWQgYXBwZW5kKGNvbnN0IGNoYXIqLCB1bnNpZ25lZCk7CiAgICAgdm9pZCBhcHBlbmQo Y29uc3QgVmVjdG9yPGNoYXI+Jik7CiAKLSAgICB2b2lkIGNsZWFyKCk7CisgICAgV0VCQ09SRV9F WFBPUlQgdm9pZCBjbGVhcigpOwogICAgIGNvbnN0IGNoYXIqIHBsYXRmb3JtRGF0YSgpIGNvbnN0 OwogICAgIHVuc2lnbmVkIHBsYXRmb3JtRGF0YVNpemUoKSBjb25zdDsKIApAQCAtMTAxLDcgKzEw Miw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGFwcGVuZChDRkRhdGFSZWYpOwogI2VuZGlmCiAKLSAg ICBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY29weSgpIGNvbnN0OworICAgIFdFQkNPUkVfRVhQ T1JUIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjb3B5KCkgY29uc3Q7CiAgICAgCiAgICAgLy8g UmV0dXJuIHRoZSBudW1iZXIgb2YgY29uc2VjdXRpdmUgYnl0ZXMgYWZ0ZXIgInBvc2l0aW9uIi4g ImRhdGEiCiAgICAgLy8gcG9pbnRzIHRvIHRoZSBmaXJzdCBieXRlLgpAQCAtMTI5LDcgKzEzMCwx MCBAQCBwcml2YXRlOgogICAgIGV4cGxpY2l0IFNoYXJlZEJ1ZmZlcih1bnNpZ25lZCk7CiAgICAg V0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVyKGNvbnN0IGNoYXIqLCB1bnNpZ25lZCk7CiAgICAg V0VCQ09SRV9FWFBPUlQgU2hhcmVkQnVmZmVyKGNvbnN0IHVuc2lnbmVkIGNoYXIqLCB1bnNpZ25l ZCk7Ci0gICAgCisgICAgZXhwbGljaXQgU2hhcmVkQnVmZmVyKE1hcHBlZEZpbGVEYXRhJiYpOwor CisgICAgc3RhdGljIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNyZWF0ZUZyb21SZWFkaW5nRmlsZShj b25zdCBTdHJpbmcmIGZpbGVQYXRoKTsKKwogICAgIC8vIENhbGxpbmcgdGhpcyBmdW5jdGlvbiB3 aWxsIGZvcmNlIGludGVybmFsIHNlZ21lbnRlZCBidWZmZXJzCiAgICAgLy8gdG8gYmUgbWVyZ2Vk IGludG8gYSBmbGF0IGJ1ZmZlci4gVXNlIGdldFNvbWVEYXRhKCkgd2hlbmV2ZXIgcG9zc2libGUK ICAgICAvLyBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLgpAQCAtMTM5LDYgKzE0Myw4IEBAIHByaXZh dGU6CiAgICAgdm9pZCBtYXliZVRyYW5zZmVyUGxhdGZvcm1EYXRhKCk7CiAgICAgYm9vbCBtYXli ZUFwcGVuZFBsYXRmb3JtRGF0YShTaGFyZWRCdWZmZXIqKTsKIAorICAgIHZvaWQgbWF5YmVUcmFu c2Zlck1hcHBlZEZpbGVEYXRhKCk7CisKICAgICB2b2lkIGNvcHlCdWZmZXJBbmRDbGVhcihjaGFy KiBkZXN0aW5hdGlvbiwgdW5zaWduZWQgYnl0ZXNUb0NvcHkpIGNvbnN0OwogCiAgICAgdm9pZCBh cHBlbmRUb0RhdGFCdWZmZXIoY29uc3QgY2hhciAqLCB1bnNpZ25lZCkgY29uc3Q7CkBAIC0xNjcs NiArMTczLDggQEAgcHJpdmF0ZToKICAgICBleHBsaWNpdCBTaGFyZWRCdWZmZXIoU291cEJ1ZmZl ciopOwogICAgIEdVbmlxdWVQdHI8U291cEJ1ZmZlcj4gbV9zb3VwQnVmZmVyOwogI2VuZGlmCisK KyAgICBNYXBwZWRGaWxlRGF0YSBtX2ZpbGVEYXRhOwogfTsKIAogUGFzc1JlZlB0cjxTaGFyZWRC dWZmZXI+IHV0ZjhCdWZmZXIoY29uc3QgU3RyaW5nJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvU2hhcmVkQnVmZmVyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwCmluZGV4IGVkOGRlNDcxNjQzZDMwMDYyNTc2 ZDlkMjAwODRkNGE1N2YxZGVlMTMuLmYyYjY0N2ViYTU4ODVhNjNkNWQ5NWQ4ZTYyNmZkNTE5NWNj ODc5NDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TaGFyZWRCdWZm ZXJHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJH dGsuY3BwCkBAIC0yOCwxMCArMjgsOSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NS ZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmls ZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQorUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVm ZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0ZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKIHsKLSAg ICBpZiAoZmlsZVBhdGguaXNFbXB0eSgpKQotICAgICAgICByZXR1cm4gMDsKKyAgICBBU1NFUlQo IWZpbGVQYXRoLmlzRW1wdHkoKSk7CiAKICAgICBDU3RyaW5nIGZpbGVuYW1lID0gZmlsZVN5c3Rl bVJlcHJlc2VudGF0aW9uKGZpbGVQYXRoKTsKICAgICBHVW5pcXVlT3V0UHRyPGdjaGFyPiBjb250 ZW50czsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZm ZXJNYWMubW0gYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1t CmluZGV4IGVhNDgyZjA2ZjA4MTY4YTlhZmQ1OGM2ZDAwYWI1Y2YwYjMzZTA1NDcuLjFhZDI4YWQ3 NjNkODhkZTg0OTVlNDMzYjQyOGM4NGMwYWRkOTNkZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0KKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1hYy5tbQpAQCAtMTIyLDcgKzEyMiw3IEBAIFJldGFp blB0cjxDRkRhdGFSZWY+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlQ0ZEYXRhKCkKICAgICByZXR1cm4g YWRvcHRDRigoQ0ZEYXRhUmVmKWFkb3B0TlMoW1tXZWJDb3JlU2hhcmVkQnVmZmVyRGF0YSBhbGxv Y10gaW5pdFdpdGhTaGFyZWRCdWZmZXJEYXRhQnVmZmVyOm1fYnVmZmVyLmdldCgpXSkubGVha1Jl ZigpKTsKIH0KIAotUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRl V2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCitSZWZQdHI8U2hhcmVk QnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZUZyb21SZWFkaW5nRmlsZShjb25zdCBTdHJpbmcm IGZpbGVQYXRoKQogewogICAgIE5TRGF0YSAqcmVzb3VyY2VEYXRhID0gW05TRGF0YSBkYXRhV2l0 aENvbnRlbnRzT2ZGaWxlOmZpbGVQYXRoXTsKICAgICBpZiAocmVzb3VyY2VEYXRhKSAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Bvc2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Bvc2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcApp bmRleCBlNzdiOGVjZjA2ZjliYzljMGU1ZmZhMWJkYTA3ZDg2MjE0Mjg1YmQ0Li4yMGUwM2FmNDk2 NzRlOGJkYzNkMTE5NWIzOGU5NTkwN2I1OWI2YWUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCkBAIC0zNSwxMCArMzUsOSBA QAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFy ZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRo KQorUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0Zp bGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKIHsKLSAgICBpZiAoZmlsZVBhdGguaXNFbXB0eSgp KQotICAgICAgICByZXR1cm4gMDsKKyAgICBBU1NFUlQoIWZpbGVQYXRoLmlzRW1wdHkoKSk7CiAK ICAgICBDU3RyaW5nIGZpbGVuYW1lID0gZmlsZVN5c3RlbVJlcHJlc2VudGF0aW9uKGZpbGVQYXRo KTsKICAgICBpbnQgZmQgPSBvcGVuKGZpbGVuYW1lLmRhdGEoKSwgT19SRE9OTFkpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcAppbmRleCBmNWRk MjI4NDY0MTlhMGYyZDk3ODViOWE2OWNkZjkwOWJjMzkxZDcwLi41ZWI1MDU2OTk4ZTE1N2I5YzY2 YjMyMjU5MTU4ZWQyZDA5OWNmMjM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS93 aW4vU2hhcmVkQnVmZmVyV2luLmNwcApAQCAtMzMsMTAgKzMzLDkgQEAKIAogbmFtZXNwYWNlIFdl YkNvcmUgewogCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVX aXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK1JlZlB0cjxTaGFyZWRC dWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlKGNvbnN0IFN0cmluZyYg ZmlsZVBhdGgpCiB7Ci0gICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKLSAgICAgICAgcmV0dXJu IDA7CisgICAgQVNTRVJUKCFmaWxlUGF0aC5pc0VtcHR5KCkpOwogCiAgICAgU3RyaW5nIG51bGxp ZmllZFBhdGggPSBmaWxlUGF0aDsKICAgICBIQU5ETEUgZmlsZUhhbmRsZSA9IENyZWF0ZUZpbGVX KG51bGxpZmllZFBhdGguY2hhcmFjdGVyc1dpdGhOdWxsVGVybWluYXRpb24oKS5kYXRhKCksIEdF TkVSSUNfUkVBRCwgRklMRV9TSEFSRV9SRUFELCAwLCBPUEVOX0VYSVNUSU5HLCBGSUxFX0FUVFJJ QlVURV9OT1JNQUwsIDApOwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hh bmdlTG9nCmluZGV4IGYxY2JkMjhhY2ViYjNlZGY1MWViOTgxMmYxN2Y0ZTMwM2E0MDkwODMuLjk0 OTI5MTBhY2JmZjk3NzYxYWQ2YTk3YmFlNzVjODExNGQyNjI5N2YgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxNS0w NS0xMiAgWW91ZW5uIEZhYmxldCAgPHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgorCisgICAg ICAgIFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlIHNob3VsZCB1c2UgbWFw IGZpbGUgcm91dGluZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTE0NDE5MgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZGluZyBTaGFyZWRCdWZmZXIgYW5kIEZpbGVTeXN0ZW0gVW5pdCB0ZXN0cyB0byBN YWMgYW5kIEdUSywgbm90IHlldCBmb3IgRUZMLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9Q bGF0Zm9ybUdUSy5jbWFrZToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEku eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYkNvcmUvRmlsZVN5c3RlbS5jcHA6IEFkZGVkLgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6 RmlsZVN5c3RlbVRlc3Q6OnRlbXBGaWxlUGF0aCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpG aWxlU3lzdGVtVGVzdDo6dGVtcEVtcHR5RmlsZVBhdGgpOgorICAgICAgICAoVGVzdFdlYktpdEFQ STo6VEVTVF9GKToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvU2hhcmVk QnVmZmVyLmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpTaGFyZWRCdWZmZXJU ZXN0Ojp0ZW1wRmlsZVBhdGgpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6U2hhcmVkQnVmZmVy VGVzdDo6dGVtcEVtcHR5RmlsZVBhdGgpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVF9G KToKKwogMjAxNS0wNS0xMSAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAg ICAgIFRlc3QgZm9yIDxyZGFyOi8vcHJvYmxlbS8yMDg3ODA3NT4gVHJ5aW5nIHRvIG5hdmlnYXRl IHRvIGFuIGludmFsaWQgVVJMIGxvYWRzIGFib3V0OmJsYW5rLCBidXQgLVtXS1dlYlZpZXcgVVJM XSByZXR1cm5zIHRoZSBpbnZhbGlkIFVSTApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9QbGF0Zm9ybUdUSy5jbWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1HVEsuY21h a2UKaW5kZXggMDZiMzA1NzkxNTEzNDk5ZGNjNzM5MDQ2MmVlYmVlODM2MmY1ZjU5ZC4uY2M0N2Uw ODM5MzY1MGQ0ODJjMDdmNTE4MWE4NjAwYmI4ZjBiMjY1MCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVz dFdlYktpdEFQSS9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Bs YXRmb3JtR1RLLmNtYWtlCkBAIC0xMSw2ICsxMSw3IEBAIHNldChGb3J3YXJkaW5nSGVhZGVyc0Zv clRlc3RXZWJLaXRBUElfTkFNRSBUZXN0V2ViS2l0QVBJLWZvcndhcmRpbmctaGVhZGVycykKIAog aW5jbHVkZV9kaXJlY3RvcmllcygKICAgICAke0ZPUldBUkRJTkdfSEVBREVSU19ESVJ9CisgICAg JHtGT1JXQVJESU5HX0hFQURFUlNfRElSfS9KYXZhU2NyaXB0Q29yZQogICAgICR7V0VCS0lUMl9E SVJ9L1VJUHJvY2Vzcy9BUEkvQy9zb3VwCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQ SS9DL2d0awogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrCkBAIC0xMjIsNiAr MTIzLDggQEAgYWRkX2V4ZWN1dGFibGUoVGVzdFdlYkNvcmUKICAgICAke1RFU1RXRUJLSVRBUElf RElSfS9UZXN0c0NvbnRyb2xsZXIuY3BwCiAgICAgJHtURVNUV0VCS0lUQVBJX0RJUn0vVGVzdHMv V2ViQ29yZS9MYXlvdXRVbml0LmNwcAogICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzL1dl YkNvcmUvVVJMLmNwcAorICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzL1dlYkNvcmUvU2hh cmVkQnVmZmVyLmNwcAorICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzL1dlYkNvcmUvRmls ZVN5c3RlbS5jcHAKICkKIAogdGFyZ2V0X2xpbmtfbGlicmFyaWVzKFRlc3RXZWJDb3JlICR7dGVz dF93ZWJjb3JlX0xJQlJBUklFU30pCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDFmNWFjMTU1 ODNhZjlhNTdiNGNiY2E4OGZjOGFlZTc5ODhlNTk3MjUuLjlhMWYyOWU0OTgxYTIyNDBmNTRiZmVk NmNmZDM4MTEyZGFiNWFlYjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdl YktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC00NSw2ICs0NSw4 IEBACiAJCTM3RDM2RjMyMUIwMDRERDQwMEJBRjVEOSAvKiBQcm92aXNpb25hbFVSTENoYW5nZS5t bSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDM3RDM2RjMx MUIwMDRERDQwMEJBRjVEOSAvKiBQcm92aXNpb25hbFVSTENoYW5nZS5tbSAqLzsgfTsKIAkJMzdE QzY3OTExNDBEN0Q3NjAwQUJDQ0RCIC8qIERPTVJhbmdlT2ZTdHJpbmcuaHRtbCBpbiBDb3B5IFJl c291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzN0RDNjc4RjE0MEQ3 RDNBMDBBQkNDREIgLyogRE9NUmFuZ2VPZlN0cmluZy5odG1sICovOyB9OwogCQkzN0UxMDY0QzE2 OTc2ODE4MDBCNzhCRDAgLyogRE9NSFRNTFRhYmxlQ2VsbEVsZW1lbnRDZWxsQWJvdmUuaHRtbCBp biBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAzN0Ux MDY0QjE2OTc2N0Y3MDBCNzhCRDAgLyogRE9NSFRNTFRhYmxlQ2VsbEVsZW1lbnRDZWxsQWJvdmUu aHRtbCAqLzsgfTsKKwkJNDE5NzNCNUIxQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDE5NzNCNUEx QUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3BwICovOyB9OworCQk0MTk3M0I1RDFBRjIy ODc1MDA2QzdCMzYgLyogU2hhcmVkQnVmZmVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQxOTczQjVDMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRC dWZmZXIuY3BwICovOyB9OwogCQk0QkZERkZBNzEzMTQ3NzZDMDA2MUYyNEIgLyogSGl0VGVzdFJl c3VsdE5vZGVIYW5kbGVfQnVuZGxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDRCRkRGRkE2MTMxNDc3NkMwMDYxRjI0QiAvKiBIaXRUZXN0UmVzdWx0 Tm9kZUhhbmRsZV9CdW5kbGUuY3BwICovOyB9OwogCQk1MTM5M0UyMjE1MjM5NTJEMDA1RjM5QzUg LyogRE9NV2luZG93RXh0ZW5zaW9uQmFzaWNfQnVuZGxlLmNwcCBpbiBTb3VyY2VzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxMzkzRTFEMTUyMzk0NEEwMDVGMzlDNSAvKiBE T01XaW5kb3dFeHRlbnNpb25CYXNpY19CdW5kbGUuY3BwICovOyB9OwogCQk1MTQyQjI3MzE1MTdD OEM4MDBDMzJCMTkgLyogQ29udGV4dE1lbnVDYW5Db3B5VVJMLmh0bWwgaW4gQ29weSBSZXNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTE0MkIyNzIxNTE3Qzg5MTAw QzMyQjE5IC8qIENvbnRleHRNZW51Q2FuQ29weVVSTC5odG1sICovOyB9OwpAQCAtNDk3LDYgKzQ5 OSw4IEBACiAJCTM3RTEwNjRBMTY5NzY3NjQwMEI3OEJEMCAvKiBET01IVE1MVGFibGVDZWxsQ2Vs bEFib3ZlLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gRE9NSFRN TFRhYmxlQ2VsbENlbGxBYm92ZS5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMzdF MTA2NEIxNjk3NjdGNzAwQjc4QkQwIC8qIERPTUhUTUxUYWJsZUNlbGxFbGVtZW50Q2VsbEFib3Zl Lmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7IHBhdGggPSBET01IVE1MVGFibGVDZWxsRWxlbWVu dENlbGxBYm92ZS5odG1sOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkzN0UzOEMzMzE2 OUI3RDAxMDA4NEMyOEMgLyogV2ViVmlld0RpZFJlbW92ZUZyYW1lRnJvbUhpZXJhcmNoeS5tbSAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdlYlZpZXdEaWRSZW1vdmVG cmFtZUZyb21IaWVyYXJjaHkubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQxOTcz QjVBMUFGMjI4NkEwMDZDN0IzNiAvKiBGaWxlU3lzdGVtLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IEZpbGVTeXN0ZW0uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OworCQk0MTk3M0I1QzFBRjIyODc1MDA2QzdCMzYgLyogU2hhcmVkQnVmZmVyLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFNoYXJlZEJ1ZmZlci5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ0MEExRDM4MTRBMDEwM0EwMDhBNjZGMiAvKiBVUkwu Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gVVJMLmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDRBNjIyQzExNEEwRTJCNjAwNDg1MTVCIC8qIFdURlN0 cmluZ1V0aWxpdGllcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXVEZTdHJp bmdVdGlsaXRpZXMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNEE0MTBGNEIxOUFG N0JENjAwMkVCQUI1IC8qIFVzZXJNZWRpYS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBVc2VyTWVkaWEuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAt NzY3LDYgKzc3MSw3IEBACiAJCTA4RkI3Nzk1RkU4NDE1NURDMDJBQUMwNyAvKiBTb3VyY2UgKi8g PSB7CiAJCQlpc2EgPSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAorCQkJCTQ0QTgyRTdCMTky NTFCMzUwMEMxQzhDNCAvKiBDb2NvYSAqLywKIAkJCQkwRjEzOUU3MTFBNDIzQTFEMDBGNTkwRjUg LyogY29jb2EgKi8sCiAJCQkJQkM1NzU5NDQxMjZFNzMzQzAwNkYwRjEyIC8qIEluamVjdGVkQnVu ZGxlICovLAogCQkJCTJFOTY2MERDMTZDMDdEN0IwMDM3MUI0MiAvKiBpb3MgKi8sCkBAIC04NTgs NyArODYzLDkgQEAKIAkJCQk3Q0IxODRDNDFBQTNGMjEwMDA2NkVERkQgLyogQ29udGVudEV4dGVu c2lvbnMuY3BwICovLAogCQkJCUNENTQ1MUU5MTlFNDFGOUQwMDE2OTM2RiAvKiBDU1NQYXJzZXIu Y3BwICovLAogCQkJCTI2RjZFMUVGMUFEQzc0OUIwMERFNjk2QiAvKiBERkFNaW5pbWl6ZXIuY3Bw ICovLAorCQkJCTQxOTczQjVBMUFGMjI4NkEwMDZDN0IzNiAvKiBGaWxlU3lzdGVtLmNwcCAqLywK IAkJCQkxNDQ2NDAxMjE2N0E4MzA1MDAwQkQyMTggLyogTGF5b3V0VW5pdC5jcHAgKi8sCisJCQkJ NDE5NzNCNUMxQUYyMjg3NTAwNkM3QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgKi8sCiAJCQkJQ0RD MkM3MTQxNzk3MDg5RDAwRTYyN0ZCIC8qIFRpbWVSYW5nZXMuY3BwICovLAogCQkJCTQ0MEExRDM4 MTRBMDEwM0EwMDhBNjZGMiAvKiBVUkwuY3BwICovLAogCQkJKTsKQEAgLTg3MCw3ICs4NzcsOCBA QAogCQkJY2hpbGRyZW4gPSAoCiAJCQkJOTNBN0VCM0MxOEZBNjNBNDAwOUU3NjcwIC8qIFVSTEV4 dHJhcy5tbSAqLywKIAkJCSk7Ci0JCQlwYXRoID0gQ29jb2E7CisJCQluYW1lID0gQ29jb2E7CisJ CQlwYXRoID0gVGVzdHMvQ29jb2E7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwogCQl9Owog CQk3NTYwOTE3NjE5MjU5QzU5MDA5RUYwNkUgLyogaW9zICovID0gewpAQCAtMTE2MCw3ICsxMTY4 LDYgQEAKIAkJQkNCOUVCNjYxMTIzNjZEODAwQTEzN0UwIC8qIFRlc3RzICovID0gewogCQkJaXNh ID0gUEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKLQkJCQk0NEE4MkU3QjE5MjUxQjM1MDBDMUM4 QzQgLyogQ29jb2EgKi8sCiAJCQkJNzU2MDkxNzYxOTI1OUM1OTAwOUVGMDZFIC8qIGlvcyAqLywK IAkJCQlGRTIxN0VDQjE2NDBBNTRBMDA1Mjk4OEIgLyogSmF2YVNjcmlwdENvcmUgKi8sCiAJCQkJ QzA3RTZDQUQxM0ZENjc2NTAwMzhCMjJCIC8qIG1hYyAqLywKQEAgLTE1OTUsOCArMTYwMiwxMCBA QAogCQkJCTJEMUZFMEIwMUFENDY1QzEwMDZDRDlFNiAvKiBGaXhlZExheW91dFNpemUubW0gaW4g U291cmNlcyAqLywKIAkJCQkxQ0I5QkMzODFBNjc0ODIzMDBGRTU2NzggLyogV2Vha1B0ci5jcHAg aW4gU291cmNlcyAqLywKIAkJCQkyRTc3NjVDRDE2QzREODBBMDBCQTJCQjEgLyogbWFpbklPUy5t bSBpbiBTb3VyY2VzICovLAorCQkJCTQxOTczQjVEMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRC dWZmZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0FBNkExNTIxQUFDMEIzMTAwMkIyRUQzIC8q IFdvcmtRdWV1ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkyRTc3NjVDRjE2QzREODExMDBCQTJC QjEgLyogbWFpbk1hYy5tbSBpbiBTb3VyY2VzICovLAorCQkJCTQxOTczQjVCMUFGMjI4NkEwMDZD N0IzNiAvKiBGaWxlU3lzdGVtLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTdBNTYyMzExMUFENUFG M0UwMDk2QjkyMCAvKiBNZW51VHlwZXNGb3JNb3VzZUV2ZW50cy5jcHAgaW4gU291cmNlcyAqLywK IAkJCQkyNkY2RTFGMDFBREM3NDlCMDBERTY5NkIgLyogREZBTWluaW1pemVyLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCTdBOTlEOTk0MUFENEEyOUQwMDM3MzE0MSAvKiBNZW51VHlwZXNGb3JNb3Vz ZUV2ZW50cy5tbSBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XZWJDb3JlL0ZpbGVTeXN0ZW0uY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJDb3JlL0ZpbGVTeXN0ZW0uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiMjNhNGI3Y2MzNWEwNDRlMTEy NTZmZTVmYmQ2ZmM4MWUwNjMzODgKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYkNvcmUvRmlsZVN5c3RlbS5jcHAKQEAgLTAsMCArMSw5NiBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlRlc3QuaCIKKyNpbmNsdWRl IDxXZWJDb3JlL0ZpbGVTeXN0ZW0uaD4KKyNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgorI2lu Y2x1ZGUgPHd0Zi9TdHJpbmdFeHRyYXMuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisK K25hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKKworY29uc3QgY2hhciogRmlsZVN5c3RlbVRlc3RE YXRhID0gIlRoaXMgaXMgYSB0ZXN0IjsKKworLy8gRklYTUU6IFJlZmFjdG9yIEZpbGVTeXN0ZW1U ZXN0IGFuZCBTaGFyZWRCdWZmZXJUZXN0IGFzIGEgc2luZ2xlIGNsYXNzLgorY2xhc3MgRmlsZVN5 c3RlbVRlc3QgOiBwdWJsaWMgdGVzdGluZzo6VGVzdCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2 b2lkIFNldFVwKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIFdURjo6aW5pdGlhbGl6ZU1haW5U aHJlYWQoKTsKKyAgICAgICAgCisgICAgICAgIC8vIGNyZWF0ZSB0ZW1wIGZpbGUKKyAgICAgICAg UGxhdGZvcm1GaWxlSGFuZGxlIGhhbmRsZTsKKyAgICAgICAgbV90ZW1wRmlsZVBhdGggPSBvcGVu VGVtcG9yYXJ5RmlsZSgidGVtcFRlc3RGaWxlIiwgaGFuZGxlKTsKKyAgICAgICAgd3JpdGVUb0Zp bGUoaGFuZGxlLCBGaWxlU3lzdGVtVGVzdERhdGEsIHN0cmxlbihGaWxlU3lzdGVtVGVzdERhdGEp KTsKKyAgICAgICAgY2xvc2VGaWxlKGhhbmRsZSk7IAorCisgICAgICAgIG1fdGVtcEVtcHR5Rmls ZVBhdGggPSBvcGVuVGVtcG9yYXJ5RmlsZSgidGVtcEVtcHR5VGVzdEZpbGUiLCBoYW5kbGUpOwor ICAgICAgICBjbG9zZUZpbGUoaGFuZGxlKTsgCisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIFRl YXJEb3duKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIGRlbGV0ZUZpbGUobV90ZW1wRmlsZVBh dGgpOworICAgICAgICBkZWxldGVGaWxlKG1fdGVtcEVtcHR5RmlsZVBhdGgpOworICAgIH0KKwor ICAgIGNvbnN0IFN0cmluZyYgdGVtcEZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRmlsZVBhdGg7 IH0KKyAgICBjb25zdCBTdHJpbmcmIHRlbXBFbXB0eUZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1w RW1wdHlGaWxlUGF0aDsgfQorCitwcml2YXRlOgorICAgIFN0cmluZyBtX3RlbXBGaWxlUGF0aDsK KyAgICBTdHJpbmcgbV90ZW1wRW1wdHlGaWxlUGF0aDsKK307CisKK1RFU1RfRihGaWxlU3lzdGVt VGVzdCwgTWFwcGluZ01pc3NpbmdGaWxlKQoreworICAgIGJvb2wgc3VjY2VzczsKKyAgICBNYXBw ZWRGaWxlRGF0YSBtYXBwZWRGaWxlRGF0YShTdHJpbmcoIm5vdF9leGlzdGluZ19maWxlIiksIHN1 Y2Nlc3MpOworICAgIEVYUEVDVF9GQUxTRShzdWNjZXNzKTsKKyAgICBFWFBFQ1RfVFJVRSghbWFw cGVkRmlsZURhdGEpOworfQorCitURVNUX0YoRmlsZVN5c3RlbVRlc3QsIE1hcHBpbmdFeGlzdGlu Z0ZpbGUpCit7CisgICAgYm9vbCBzdWNjZXNzOworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZp bGVEYXRhKHRlbXBGaWxlUGF0aCgpLCBzdWNjZXNzKTsKKyAgICBFWFBFQ1RfVFJVRShzdWNjZXNz KTsKKyAgICBFWFBFQ1RfVFJVRSghIW1hcHBlZEZpbGVEYXRhKTsKKyAgICBFWFBFQ1RfVFJVRSht YXBwZWRGaWxlRGF0YS5zaXplKCkgPT0gc3RybGVuKEZpbGVTeXN0ZW1UZXN0RGF0YSkpOworICAg IEVYUEVDVF9UUlVFKHN0cm5zdHIoRmlsZVN5c3RlbVRlc3REYXRhLCBzdGF0aWNfY2FzdDxjb25z dCBjaGFyKj4obWFwcGVkRmlsZURhdGEuZGF0YSgpKSwgbWFwcGVkRmlsZURhdGEuc2l6ZSgpKSk7 Cit9CisKK1RFU1RfRihGaWxlU3lzdGVtVGVzdCwgTWFwcGluZ0V4aXN0aW5nRW1wdHlGaWxlKQor eworICAgIGJvb2wgc3VjY2VzczsKKyAgICBNYXBwZWRGaWxlRGF0YSBtYXBwZWRGaWxlRGF0YSh0 ZW1wRW1wdHlGaWxlUGF0aCgpLCBzdWNjZXNzKTsKKyAgICBFWFBFQ1RfVFJVRShzdWNjZXNzKTsK KyAgICBFWFBFQ1RfVFJVRSghbWFwcGVkRmlsZURhdGEpOworfQorCit9CmRpZmYgLS1naXQgYS9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvU2hhcmVkQnVmZmVyLmNwcCBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjE5ZTkwYjZkMDhlMTI2ZmNmZmI5NTg3YjAyYjc3Mjg2MTMyYWJhNTgKLS0tIC9kZXYvbnVsbAor KysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvU2hhcmVkQnVmZmVyLmNwcApA QCAtMCwwICsxLDExOSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFy ZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lu Y2x1ZGUgIlRlc3QuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1NoYXJlZEJ1ZmZlci5oPgorI2luY2x1 ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1N0cmluZ0V4dHJhcy5oPgorCit1 c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCitj b25zdCBjaGFyKiBTaGFyZWRCdWZmZXJUZXN0RGF0YSA9ICJUaGlzIGlzIGEgdGVzdCI7CisKK2Ns YXNzIFNoYXJlZEJ1ZmZlclRlc3QgOiBwdWJsaWMgdGVzdGluZzo6VGVzdCB7CitwdWJsaWM6Cisg ICAgdmlydHVhbCB2b2lkIFNldFVwKCkgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIFdURjo6aW5p dGlhbGl6ZU1haW5UaHJlYWQoKTsKKyAgICAgICAgCisgICAgICAgIC8vIGNyZWF0ZSB0ZW1wIGZp bGUKKyAgICAgICAgUGxhdGZvcm1GaWxlSGFuZGxlIGhhbmRsZTsKKyAgICAgICAgbV90ZW1wRmls ZVBhdGggPSBvcGVuVGVtcG9yYXJ5RmlsZSgidGVtcFRlc3RGaWxlIiwgaGFuZGxlKTsKKyAgICAg ICAgd3JpdGVUb0ZpbGUoaGFuZGxlLCBTaGFyZWRCdWZmZXJUZXN0RGF0YSwgc3RybGVuKFNoYXJl ZEJ1ZmZlclRlc3REYXRhKSk7CisgICAgICAgIGNsb3NlRmlsZShoYW5kbGUpOyAKKworICAgICAg ICBtX3RlbXBFbXB0eUZpbGVQYXRoID0gb3BlblRlbXBvcmFyeUZpbGUoInRlbXBFbXB0eVRlc3RG aWxlIiwgaGFuZGxlKTsKKyAgICAgICAgY2xvc2VGaWxlKGhhbmRsZSk7IAorICAgIH0KKworICAg IHZpcnR1YWwgdm9pZCBUZWFyRG93bigpIG92ZXJyaWRlCisgICAgeworICAgICAgICBkZWxldGVG aWxlKG1fdGVtcEZpbGVQYXRoKTsKKyAgICAgICAgZGVsZXRlRmlsZShtX3RlbXBFbXB0eUZpbGVQ YXRoKTsKKyAgICB9CisKKyAgICBjb25zdCBTdHJpbmcmIHRlbXBGaWxlUGF0aCgpIHsgcmV0dXJu IG1fdGVtcEZpbGVQYXRoOyB9CisgICAgY29uc3QgU3RyaW5nJiB0ZW1wRW1wdHlGaWxlUGF0aCgp IHsgcmV0dXJuIG1fdGVtcEVtcHR5RmlsZVBhdGg7IH0KKworcHJpdmF0ZToKKyAgICBTdHJpbmcg bV90ZW1wRmlsZVBhdGg7CisgICAgU3RyaW5nIG1fdGVtcEVtcHR5RmlsZVBhdGg7Cit9OworCitU RVNUX0YoU2hhcmVkQnVmZmVyVGVzdCwgY3JlYXRlV2l0aENvbnRlbnRzT2ZNaXNzaW5nRmlsZSkK K3sKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0 ZVdpdGhDb250ZW50c09mRmlsZShTdHJpbmcoIm5vdF9leGlzdGluZ19maWxlIikpOworICAgIEFT U0VSVF9OVUxMKGJ1ZmZlcik7Cit9CisKK1RFU1RfRihTaGFyZWRCdWZmZXJUZXN0LCBjcmVhdGVX aXRoQ29udGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBi dWZmZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSh0ZW1wRmlsZVBh dGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgRVhQRUNUX1RSVUUoYnVm ZmVyLT5zaXplKCkgPT0gc3RybGVuKFNoYXJlZEJ1ZmZlclRlc3REYXRhKSk7CisgICAgRVhQRUNU X1RSVUUoU3RyaW5nKFNoYXJlZEJ1ZmZlclRlc3REYXRhKSA9PSBTdHJpbmcoYnVmZmVyLT5kYXRh KCksIGJ1ZmZlci0+c2l6ZSgpKSk7Cit9CisKK1RFU1RfRihTaGFyZWRCdWZmZXJUZXN0LCBjcmVh dGVXaXRoQ29udGVudHNPZkV4aXN0aW5nRW1wdHlGaWxlKQoreworICAgIFJlZlB0cjxTaGFyZWRC dWZmZXI+IGJ1ZmZlciA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKHRl bXBFbXB0eUZpbGVQYXRoKCkpOworICAgIEFTU0VSVF9OT1RfTlVMTChidWZmZXIpOworICAgIEVY UEVDVF9UUlVFKGJ1ZmZlci0+aXNFbXB0eSgpKTsKK30KKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRl c3QsIGNvcHlCdWZmZXJDcmVhdGVkV2l0aENvbnRlbnRzT2ZFeGlzdGluZ0ZpbGUpCit7CisgICAg UmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUodGVtcEZpbGVQYXRoKCkpOworICAgIEFTU0VSVF9OT1RfTlVMTChidWZmZXIp OworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNvcHkgPSBidWZmZXItPmNvcHkoKTsKKyAgICBF WFBFQ1RfVFJVRShidWZmZXItPnNpemUoKSA9PSBjb3B5LT5zaXplKCkpOworICAgIEVYUEVDVF9U UlVFKHN0cm5zdHIoYnVmZmVyLT5kYXRhKCksIGNvcHktPmRhdGEoKSwgYnVmZmVyLT5zaXplKCkp KTsKK30KKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNsZWFyQnVmZmVyQ3JlYXRlZFdpdGhD b250ZW50c09mRXhpc3RpbmdGaWxlKQoreworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZl ciA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKHRlbXBGaWxlUGF0aCgp KTsKKyAgICBBU1NFUlRfTk9UX05VTEwoYnVmZmVyKTsKKyAgICBidWZmZXItPmNsZWFyKCk7Cisg ICAgRVhQRUNUX1RSVUUoIWJ1ZmZlci0+c2l6ZSgpKTsKKyAgICBFWFBFQ1RfVFJVRSghYnVmZmVy LT5kYXRhKCkpOworfQorCisKK1RFU1RfRihTaGFyZWRCdWZmZXJUZXN0LCBhcHBlbmRCdWZmZXJD cmVhdGVkV2l0aENvbnRlbnRzT2ZFeGlzdGluZ0ZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJlZEJ1 ZmZlcj4gYnVmZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUodGVt cEZpbGVQYXRoKCkpOworICAgIEFTU0VSVF9OT1RfTlVMTChidWZmZXIpOworICAgIGJ1ZmZlci0+ YXBwZW5kKCJhIiwgMSk7CisgICAgRVhQRUNUX1RSVUUoYnVmZmVyLT5zaXplKCkgPT0gKHN0cmxl bihTaGFyZWRCdWZmZXJUZXN0RGF0YSkgKyAxKSk7CisgICAgRVhQRUNUX1RSVUUoc3RybnN0cihi dWZmZXItPmRhdGEoKSwgU2hhcmVkQnVmZmVyVGVzdERhdGEsIHN0cmxlbihTaGFyZWRCdWZmZXJU ZXN0RGF0YSkpKTsKKyAgICBFWFBFQ1RfRVEoJ2EnLCBidWZmZXItPmRhdGEoKVtzdHJsZW4oU2hh cmVkQnVmZmVyVGVzdERhdGEpXSk7Cit9CisKK30K 253031 2015-05-13 05:30:58 -0700 2015-05-14 00:00:47 -0700 Style improvements bug-144192-20150513142928.patch text/plain 31466 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0MTcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDRiODlhNGNmZTZkODJi NmUxM2ZlZTE4MmQ1NDBkODNlYWFiMjAwYS4uNzIyMjAzYmZhODVmZDNlYWFiOTRhZmE4ZjBhYjI2 MDQ0YzUxYzFmNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDE1LTA1LTEyICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFk ZSB1c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIElmIG1hcHBp bmcgaXMgZmFpbGluZywgaXQgZmFsbHMgYmFjayB0byB0aGUgcHJldmlvdXMgdmVyc2lvbiBvZiBT aGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSByZW5hbWVkIGFzCisgICAgICAg IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlICh1c2luZyBvcGVuL3JlYWQgbWV0 aG9kKS4KKyAgICAgICAgRmlsZSBjb250ZW50IGlzIG1hcHBlZCB1bnRpbCBTaGFyZWRCdWZmZXIg aXMgY2xlYXJlZCwgZGVzdHJveWVkIG9yIGFkZGl0aW9uYWwgY29udGVudCBpcyBhcHBlbmRlZCB0 byB0aGUgU2hhcmVkQnVmZmVyLgorCisgICAgICAgIEEgaGVscGVyIGNsYXNzLCBNYXBwZWRGaWxl RGF0YSwgaXMgaW50cm9kdWNlZCB0byBoYW5kbGUgbWFwcGVkIGZpbGVzIHRocm91Z2ggY2FsbHMg dG8gb3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAgICBQYXRjaCBjb3ZlcmVkIGJ5IGV4 aXN0aW5nIGxheW91dCB0ZXN0cyBhbmQgYWRkZWQgdW5pdCB0ZXN0cy4KKworICAgICAgICAqIHBs YXRmb3JtL0ZpbGVTeXN0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6 Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpvcGVy YXRvcj0pOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0 YSk6CisgICAgICAgICogcGxhdGZvcm0vRmlsZVN5c3RlbS5oOgorICAgICAgICAoV2ViQ29yZTo6 TWFwcGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBl ZEZpbGVEYXRhOjpvcGVyYXRvciBib29sKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVE YXRhOjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpzaXplKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpTaGFyZWRCdWZmZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVy OjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOiBNYWtpbmcgdXNlIG9mIE1hcHBlZEZpbGVEYXRh IGJlZm9yZSB1c2luZyBjcmVhdGVGcm9tUmVhZGluZ0ZpbGUuCisgICAgICAgIChXZWJDb3JlOjpT aGFyZWRCdWZmZXI6OnNpemUpOiBDaGVja2luZyB3aGV0aGVyIGRhdGEgaXMgY29taW5nIGZyb20g YSBNYXBwZWRGaWxlRGF0YS4KKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6ZGF0YSk6 IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjphcHBlbmQpOiBEaXR0by4K KyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOiBDbGVhcmluZyBNYXBwZWRG aWxlRGF0YSBpZiBuZWVkZWQuCisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OmNvcHkp OiBUcmFuc2ZlcnJpbmcgbWFwcGVkIGRhdGEgdG8gYnVmZmVyIGlmIG5lZWRlZC4KKyAgICAgICAg KFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6 U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEpOgorICAgICAgICAqIHBs YXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9TaGFyZWRCdWZm ZXJHdGsuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVh ZGluZ0ZpbGUpOiByZW5hbWVkIGZyb20gY3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorICAgICAg ICAqIHBsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW06CisgICAgICAgIChXZWJDb3JlOjpT aGFyZWRCdWZmZXI6OmNyZWF0ZUZyb21SZWFkaW5nRmlsZSk6IERpdG8uCisgICAgICAgICogcGxh dGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0ZpbGUpOiBEaXR0by4KKyAgICAgICAgKiBwbGF0 Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1 ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlKTogRGl0dG8uCisKIDIwMTUtMDUtMTIgIFhhYmll ciBSb2RyaWd1ZXogQ2FsdmFyICA8Y2FsdmFyaXNAaWdhbGlhLmNvbT4gYW5kIFlvdWVubiBGYWJs ZXQgPHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgogCiAgICAgICAgIFtTdHJlYW1zIEFQSV0g UmVhZGFibGVTdHJlYW0gcmVhZGVyIHNob3VsZCBub3QgYmUgZGlzcG9zYWJsZSB3aGVuIGhhdmlu ZyBwZW5kaW5nIHByb21pc2VzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9G aWxlU3lzdGVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCmlu ZGV4IDk3Yjg0NmVlY2M0YzYzMGRkYmEwNmQ0YzU3ZDM2MTc2OGQ4ZWNmZGYuLjQ5MTFjZGI4Mzc1 NzdhZjdhYmQzZWViNWExNTQ1M2Q3ZWEwMmJkMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0Zp bGVTeXN0ZW0uY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNywg MjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIw MTUgQ2Fub24gSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCkBAIC0yNyw4ICsyOCwxNiBAQAogI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKIAog I2luY2x1ZGUgPHd0Zi9IZXhOdW1iZXIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+ CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCisjaWYgIVBMQVRGT1JNKFdJ TikKKyNpbmNsdWRlIDxmY250bC5oPgorI2luY2x1ZGUgPHN5cy9tbWFuLmg+CisjaW5jbHVkZSA8 c3lzL3N0YXQuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNlbmRpZgorCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKIC8vIFRoZSBmb2xsb3dpbmcgbG93ZXItQVNDSUkgY2hhcmFjdGVycyBuZWVkIGVz Y2FwaW5nIHRvIGJlIHVzZWQgaW4gYSBmaWxlbmFtZQpAQCAtMTEzLDQgKzEyMiw2MyBAQCBib29s IGV4Y2x1ZGVGcm9tQmFja3VwKGNvbnN0IFN0cmluZyYpCiAKICNlbmRpZgogCitNYXBwZWRGaWxl RGF0YTo6fk1hcHBlZEZpbGVEYXRhKCkKK3sKKyNpZiAhUExBVEZPUk0oV0lOKQorICAgIGlmICgh bV9maWxlRGF0YSkKKyAgICAgICAgcmV0dXJuOworICAgIG11bm1hcChtX2ZpbGVEYXRhLCBtX2Zp bGVTaXplKTsKKyAgICBtX2ZpbGVEYXRhID0gbnVsbHB0cjsKKyNlbmRpZgorfQorCitNYXBwZWRG aWxlRGF0YTo6TWFwcGVkRmlsZURhdGEoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCwgYm9vbCYgc3Vj Y2VzcykKK3sKKyNpZiBQTEFURk9STShXSU4pCisgICAgLy8gRklYTUU6IEltcGxlbWVudCBtYXBw aW5nCisgICAgc3VjY2VzcyA9IGZhbHNlOworICAgIHJldHVybjsKKyNlbHNlCisgICAgQ1N0cmlu ZyBmc1JlcCA9IGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbihmaWxlUGF0aCk7CisgICAgaW50IGZk ID0gIWZzUmVwLmlzTnVsbCgpID8gb3Blbihmc1JlcC5kYXRhKCksIE9fUkRPTkxZKSA6IC0xOwor ICAgIGlmIChmZCA8IDApIHsKKyAgICAgICAgc3VjY2VzcyA9IGZhbHNlOworICAgICAgICByZXR1 cm47CisgICAgfQorCisgICAgc3RydWN0IHN0YXQgZmlsZVN0YXQ7CisgICAgaWYgKGZzdGF0KGZk LCAmZmlsZVN0YXQpKSB7CisgICAgICAgIGNsb3NlKGZkKTsKKyAgICAgICAgc3VjY2VzcyA9IGZh bHNlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKGZpbGVTdGF0LnN0X3NpemUg PCAwIHx8IGZpbGVTdGF0LnN0X3NpemUgPiBzdGQ6Om51bWVyaWNfbGltaXRzPHVuc2lnbmVkPjo6 bWF4KCkpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAgICBzdWNjZXNzID0gZmFsc2U7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICB1bnNpZ25lZCBzaXplID0gc3RhdGljX2Nhc3Q8 dW5zaWduZWQ+KGZpbGVTdGF0LnN0X3NpemUpOworCisgICAgaWYgKCFzaXplKSB7CisgICAgICAg IGNsb3NlKGZkKTsKKyAgICAgICAgc3VjY2VzcyA9IHRydWU7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICB2b2lkKiBkYXRhID0gbW1hcCgwLCBzaXplLCBQUk9UX1JFQUQsIE1BUF9GSUxF IHwgTUFQX1NIQVJFRCwgZmQsIDApOworICAgIGNsb3NlKGZkKTsKKworICAgIGlmIChkYXRhID09 IE1BUF9GQUlMRUQpIHsKKyAgICAgICAgc3VjY2VzcyA9IGZhbHNlOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgc3VjY2VzcyA9IHRydWU7CisgICAgbV9maWxlRGF0YSA9IGRhdGE7Cisg ICAgbV9maWxlU2l6ZSA9IHNpemU7CisjZW5kaWYKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5oIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vRmlsZVN5c3RlbS5oCmluZGV4IDNhN2ZiNGI5ZTI4M2JiMzkw ODdhYzBhMjQ3NTIxNzdlMGQ3NmMwNDYuLjc2N2FkMmQyMGU3YTM4MjkxMGIxNGFhNDA2NzBjOGFj NDdkOGNjYTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0u aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmgKQEAgLTEsNiArMSw3 IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA3LCAyMDA4LCAyMDExIEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KICAqIENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEsIEx0ZC4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTIw NCw2ICsyMDUsMzYgQEAgV0VCQ09SRV9FWFBPUlQgU3RyaW5nIGxvY2FsVXNlclNwZWNpZmljU3Rv cmFnZURpcmVjdG9yeSgpOwogU3RyaW5nIHJvYW1pbmdVc2VyU3BlY2lmaWNTdG9yYWdlRGlyZWN0 b3J5KCk7CiAjZW5kaWYKIAorY2xhc3MgTWFwcGVkRmlsZURhdGEgeworcHVibGljOgorICAgIE1h cHBlZEZpbGVEYXRhKCkgeyB9CisgICAgV0VCQ09SRV9FWFBPUlQgTWFwcGVkRmlsZURhdGEoY29u c3QgU3RyaW5nJiBmaWxlUGF0aCwgYm9vbCYgc3VjY2Vzcyk7CisgICAgV0VCQ09SRV9FWFBPUlQg TWFwcGVkRmlsZURhdGEoTWFwcGVkRmlsZURhdGEmJik7CisgICAgV0VCQ09SRV9FWFBPUlQgfk1h cHBlZEZpbGVEYXRhKCk7CisgICAgTWFwcGVkRmlsZURhdGEmIG9wZXJhdG9yPShNYXBwZWRGaWxl RGF0YSYmKTsKKworICAgIGV4cGxpY2l0IG9wZXJhdG9yIGJvb2woKSBjb25zdCB7IHJldHVybiAh IW1fZmlsZURhdGE7IH0KKyAgICBjb25zdCB2b2lkKiBkYXRhKCkgY29uc3QgeyByZXR1cm4gbV9m aWxlRGF0YTsgfQorICAgIHVuc2lnbmVkIHNpemUoKSBjb25zdCB7IHJldHVybiBtX2ZpbGVTaXpl OyB9CisKK3ByaXZhdGU6CisgICAgdm9pZCogbV9maWxlRGF0YSB7IG51bGxwdHIgfTsKKyAgICB1 bnNpZ25lZCBtX2ZpbGVTaXplIHsgMCB9OworfTsKKworaW5saW5lIE1hcHBlZEZpbGVEYXRhOjpN YXBwZWRGaWxlRGF0YShNYXBwZWRGaWxlRGF0YSYmIG90aGVyKQoreworICAgIG1fZmlsZURhdGEg PSBzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fZmlsZURhdGEsIG51bGxwdHIpOworICAgIG1fZmlsZVNp emUgPSBzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fZmlsZVNpemUsIDApOworfQorCitpbmxpbmUgTWFw cGVkRmlsZURhdGEmIE1hcHBlZEZpbGVEYXRhOjpvcGVyYXRvcj0oTWFwcGVkRmlsZURhdGEmJiBv dGhlcikKK3sKKyAgICBtX2ZpbGVEYXRhID0gc3RkOjpleGNoYW5nZShvdGhlci5tX2ZpbGVEYXRh LCBudWxscHRyKTsKKyAgICBtX2ZpbGVTaXplID0gc3RkOjpleGNoYW5nZShvdGhlci5tX2ZpbGVT aXplLCAwKTsKKyAgICByZXR1cm4gKnRoaXM7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK IAogI2VuZGlmIC8vIEZpbGVTeXN0ZW1faApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vU2hhcmVkQnVmZmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1 ZmZlci5jcHAKaW5kZXggOWRiN2ZhZDIwODAyN2UxZjFlN2UwMTQ4NTNlMjE1OGU2ZDI2ZjIxNi4u Y2U2ZDdmY2EwZTZjNDRmZTg3NDE0ZjE0ZWIwNDhjMGIzODg4YzFjMyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0xLDYgKzEsNyBAQAogLyoKICAqIENvcHly aWdodCAoQykgMjAwNiwgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKiBD b3B5cmlnaHQgKEMpIFJlc2VhcmNoIEluIE1vdGlvbiBMaW1pdGVkIDIwMDktMjAxMC4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNSBDYW5vbiBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTgyLDEyICs4 MywzMiBAQCBTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcihjb25zdCB1bnNpZ25lZCBjaGFyKiBk YXRhLCB1bnNpZ25lZCBzaXplKQogewogICAgIGFwcGVuZChyZWludGVycHJldF9jYXN0PGNvbnN0 IGNoYXIqPihkYXRhKSwgc2l6ZSk7CiB9Ci0gICAgCisKK1NoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVm ZmVyKE1hcHBlZEZpbGVEYXRhJiYgZmlsZURhdGEpCisgICAgOiBtX2J1ZmZlcihhZG9wdFJlZihu ZXcgRGF0YUJ1ZmZlcikpCisgICAgLCBtX2ZpbGVEYXRhKFdURjo6bW92ZShmaWxlRGF0YSkpCit7 Cit9CisKIFNoYXJlZEJ1ZmZlcjo6flNoYXJlZEJ1ZmZlcigpCiB7CiAgICAgY2xlYXIoKTsKIH0K IAorUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNP ZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK3sKKyAgICBib29sIG1hcHBpbmdTdWNjZXNz OworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhKGZpbGVQYXRoLCBtYXBwaW5nU3Vj Y2Vzcyk7CisKKyAgICBpZiAoIW1hcHBpbmdTdWNjZXNzKQorICAgICAgICByZXR1cm4gU2hhcmVk QnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0ZpbGUoZmlsZVBhdGgpOworCisgICAgaWYgKCFtYXBw ZWRGaWxlRGF0YSkKKyAgICAgICAgcmV0dXJuIFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKCk7CisKKyAg ICByZXR1cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihXVEY6Om1vdmUobWFwcGVkRmlsZURh dGEpKSk7Cit9CisKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmFkb3B0 VmVjdG9yKFZlY3RvcjxjaGFyPiYgdmVjdG9yKQogewogICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+ IGJ1ZmZlciA9IGNyZWF0ZSgpOwpAQCAtMTAxLDE1ICsxMjIsMjAgQEAgdW5zaWduZWQgU2hhcmVk QnVmZmVyOjpzaXplKCkgY29uc3QKICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpCiAgICAgICAg IHJldHVybiBwbGF0Zm9ybURhdGFTaXplKCk7CiAgICAgCisgICAgaWYgKG1fZmlsZURhdGEpCisg ICAgICAgIHJldHVybiBtX2ZpbGVEYXRhLnNpemUoKTsKKwogICAgIHJldHVybiBtX3NpemU7CiB9 CiAKIGNvbnN0IGNoYXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CiB7Ci0KICAgICBpZiAo aGFzUGxhdGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0Zm9ybURhdGEoKTsKIAorICAg IGlmIChtX2ZpbGVEYXRhKQorICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8Y29uc3QgY2hhcio+ KG1fZmlsZURhdGEuZGF0YSgpKTsKKwogI2lmIFVTRShORVRXT1JLX0NGREFUQV9BUlJBWV9DQUxM QkFDSykKICAgICBpZiAoY29uc3QgY2hhciogYnVmZmVyID0gc2luZ2xlRGF0YUFycmF5QnVmZmVy KCkpCiAgICAgICAgIHJldHVybiBidWZmZXI7CkBAIC0xNjAsNiArMTg2LDcgQEAgdm9pZCBTaGFy ZWRCdWZmZXI6OmFwcGVuZChjb25zdCBjaGFyKiBkYXRhLCB1bnNpZ25lZCBsZW5ndGgpCiAgICAg aWYgKCFsZW5ndGgpCiAgICAgICAgIHJldHVybjsKIAorICAgIG1heWJlVHJhbnNmZXJNYXBwZWRG aWxlRGF0YSgpOwogICAgIG1heWJlVHJhbnNmZXJQbGF0Zm9ybURhdGEoKTsKIAogI2lmICFVU0Uo TkVUV09SS19DRkRBVEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC0yMTAsNiArMjM3LDggQEAgdm9pZCBT aGFyZWRCdWZmZXI6OmFwcGVuZChjb25zdCBWZWN0b3I8Y2hhcj4mIGRhdGEpCiAKIHZvaWQgU2hh cmVkQnVmZmVyOjpjbGVhcigpCiB7CisgICAgbV9maWxlRGF0YSA9IHsgfTsKKwogICAgIGNsZWFy UGxhdGZvcm1EYXRhKCk7CiAgICAgCiAjaWYgIVVTRShORVRXT1JLX0NGREFUQV9BUlJBWV9DQUxM QkFDSykKQEAgLTIyNyw3ICsyNTYsOCBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXIoKQogUGFz c1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y29weSgpIGNvbnN0CiB7CiAgICAg UmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY2xvbmUgeyBhZG9wdFJlZigqbmV3IFNoYXJlZEJ1ZmZlcikg fTsKLSAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpIHsKKworICAgIGlmIChoYXNQbGF0Zm9ybURh dGEoKSB8fCBtX2ZpbGVEYXRhKSB7CiAgICAgICAgIGNsb25lLT5hcHBlbmQoZGF0YSgpLCBzaXpl KCkpOwogICAgICAgICByZXR1cm4gY2xvbmUucmVsZWFzZSgpOwogICAgIH0KQEAgLTMxMCw3ICsz NDAsNyBAQCB1bnNpZ25lZCBTaGFyZWRCdWZmZXI6OmdldFNvbWVEYXRhKGNvbnN0IGNoYXIqJiBz b21lRGF0YSwgdW5zaWduZWQgcG9zaXRpb24pIGNvbgogICAgICAgICByZXR1cm4gMDsKICAgICB9 CiAKLSAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpIHsKKyAgICBpZiAoaGFzUGxhdGZvcm1EYXRh KCkgfHwgbV9maWxlRGF0YSkgewogICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNB VElPTihwb3NpdGlvbiA8IHNpemUoKSk7CiAgICAgICAgIHNvbWVEYXRhID0gZGF0YSgpICsgcG9z aXRpb247CiAgICAgICAgIHJldHVybiB0b3RhbFNpemUgLSBwb3NpdGlvbjsKQEAgLTM0Myw2ICsz NzMsMTQgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpnZXRTb21lRGF0YShjb25zdCBjaGFyKiYg c29tZURhdGEsIHVuc2lnbmVkIHBvc2l0aW9uKSBjb24KICNlbmRpZgogfQogCit2b2lkIFNoYXJl ZEJ1ZmZlcjo6bWF5YmVUcmFuc2Zlck1hcHBlZEZpbGVEYXRhKCkKK3sKKyAgICBpZiAobV9maWxl RGF0YSkgeworICAgICAgICBhdXRvIGZpbGVEYXRhID0gV1RGOjptb3ZlKG1fZmlsZURhdGEpOwor ICAgICAgICBhcHBlbmQoc3RhdGljX2Nhc3Q8Y29uc3QgY2hhcio+KGZpbGVEYXRhLmRhdGEoKSks IGZpbGVEYXRhLnNpemUoKSk7CisgICAgfQorfQorCiAjaWYgIVVTRShDRikgJiYgIVVTRShTT1VQ KQogCiBpbmxpbmUgdm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyUGxhdGZvcm1EYXRhKCkKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKaW5kZXggMDQ1NWQ3OTk0MDY2MDNjYTEzMmRh NzlkMTgzMDRiNmRiM2ViMGY0OC4uNDRhYTgxODIxZGU1MTY4ODFkNDVhYmQzODc0MGJhODhkODZl ZTkyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKQEAgLTI3LDYgKzI3 LDcgQEAKICNpZm5kZWYgU2hhcmVkQnVmZmVyX2gKICNkZWZpbmUgU2hhcmVkQnVmZmVyX2gKIAor I2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKICNpbmNsdWRlIDxydW50aW1lL0FycmF5QnVmZmVyLmg+ CiAjaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgpA QCAtNTUsNyArNTYsNyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQnVm ZmVyPiBjcmVhdGUoY29uc3QgY2hhciogYywgdW5zaWduZWQgaSkgeyByZXR1cm4gYWRvcHRSZWYo bmV3IFNoYXJlZEJ1ZmZlcihjLCBpKSk7IH0KICAgICBzdGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRC dWZmZXI+IGNyZWF0ZShjb25zdCB1bnNpZ25lZCBjaGFyKiBjLCB1bnNpZ25lZCBpKSB7IHJldHVy biBhZG9wdFJlZihuZXcgU2hhcmVkQnVmZmVyKGMsIGkpKTsgfQogCi0gICAgV0VCQ09SRV9FWFBP UlQgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGVXaXRoQ29udGVudHNPZkZp bGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCk7CisgICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFJl ZlB0cjxTaGFyZWRCdWZmZXI+IGNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcm IGZpbGVQYXRoKTsKIAogICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJl ZEJ1ZmZlcj4gYWRvcHRWZWN0b3IoVmVjdG9yPGNoYXI+JiB2ZWN0b3IpOwogICAgIApAQCAtOTIs NyArOTMsNyBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBhcHBlbmQoY29uc3Qg Y2hhciosIHVuc2lnbmVkKTsKICAgICB2b2lkIGFwcGVuZChjb25zdCBWZWN0b3I8Y2hhcj4mKTsK IAotICAgIHZvaWQgY2xlYXIoKTsKKyAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGNsZWFyKCk7CiAg ICAgY29uc3QgY2hhciogcGxhdGZvcm1EYXRhKCkgY29uc3Q7CiAgICAgdW5zaWduZWQgcGxhdGZv cm1EYXRhU2l6ZSgpIGNvbnN0OwogCkBAIC0xMDEsNyArMTAyLDcgQEAgcHVibGljOgogICAgIHZv aWQgYXBwZW5kKENGRGF0YVJlZik7CiAjZW5kaWYKIAotICAgIFBhc3NSZWZQdHI8U2hhcmVkQnVm ZmVyPiBjb3B5KCkgY29uc3Q7CisgICAgV0VCQ09SRV9FWFBPUlQgUGFzc1JlZlB0cjxTaGFyZWRC dWZmZXI+IGNvcHkoKSBjb25zdDsKICAgICAKICAgICAvLyBSZXR1cm4gdGhlIG51bWJlciBvZiBj b25zZWN1dGl2ZSBieXRlcyBhZnRlciAicG9zaXRpb24iLiAiZGF0YSIKICAgICAvLyBwb2ludHMg dG8gdGhlIGZpcnN0IGJ5dGUuCkBAIC0xMjksNyArMTMwLDEwIEBAIHByaXZhdGU6CiAgICAgZXhw bGljaXQgU2hhcmVkQnVmZmVyKHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRC dWZmZXIoY29uc3QgY2hhciosIHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRC dWZmZXIoY29uc3QgdW5zaWduZWQgY2hhciosIHVuc2lnbmVkKTsKLSAgICAKKyAgICBleHBsaWNp dCBTaGFyZWRCdWZmZXIoTWFwcGVkRmlsZURhdGEmJik7CisKKyAgICBzdGF0aWMgUmVmUHRyPFNo YXJlZEJ1ZmZlcj4gY3JlYXRlRnJvbVJlYWRpbmdGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgp OworCiAgICAgLy8gQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIHdpbGwgZm9yY2UgaW50ZXJuYWwgc2Vn bWVudGVkIGJ1ZmZlcnMKICAgICAvLyB0byBiZSBtZXJnZWQgaW50byBhIGZsYXQgYnVmZmVyLiBV c2UgZ2V0U29tZURhdGEoKSB3aGVuZXZlciBwb3NzaWJsZQogICAgIC8vIGZvciBiZXR0ZXIgcGVy Zm9ybWFuY2UuCkBAIC0xMzksNiArMTQzLDggQEAgcHJpdmF0ZToKICAgICB2b2lkIG1heWJlVHJh bnNmZXJQbGF0Zm9ybURhdGEoKTsKICAgICBib29sIG1heWJlQXBwZW5kUGxhdGZvcm1EYXRhKFNo YXJlZEJ1ZmZlciopOwogCisgICAgdm9pZCBtYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEoKTsK KwogICAgIHZvaWQgY29weUJ1ZmZlckFuZENsZWFyKGNoYXIqIGRlc3RpbmF0aW9uLCB1bnNpZ25l ZCBieXRlc1RvQ29weSkgY29uc3Q7CiAKICAgICB2b2lkIGFwcGVuZFRvRGF0YUJ1ZmZlcihjb25z dCBjaGFyICosIHVuc2lnbmVkKSBjb25zdDsKQEAgLTE2Nyw2ICsxNzMsOCBAQCBwcml2YXRlOgog ICAgIGV4cGxpY2l0IFNoYXJlZEJ1ZmZlcihTb3VwQnVmZmVyKik7CiAgICAgR1VuaXF1ZVB0cjxT b3VwQnVmZmVyPiBtX3NvdXBCdWZmZXI7CiAjZW5kaWYKKworICAgIE1hcHBlZEZpbGVEYXRhIG1f ZmlsZURhdGE7CiB9OwogCiBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gdXRmOEJ1ZmZlcihjb25z dCBTdHJpbmcmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TaGFy ZWRCdWZmZXJHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZl ckd0ay5jcHAKaW5kZXggZWQ4ZGU0NzE2NDNkMzAwNjI1NzZkOWQyMDA4NGQ0YTU3ZjFkZWUxMy4u OWY2YjZjNGEwYzRjMjFhYjhhOGQwYzY0MmFiNjMzYTE3OTM4YzNmYSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKQEAgLTI4LDcgKzI4LDcg QEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hh cmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0 aCkKK1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdG aWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCiB7CiAgICAgaWYgKGZpbGVQYXRoLmlzRW1wdHko KSkKICAgICAgICAgcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1tIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWFjL1No YXJlZEJ1ZmZlck1hYy5tbQppbmRleCBlYTQ4MmYwNmYwODE2OGE5YWZkNThjNmQwMGFiNWNmMGIz M2UwNTQ3Li4xYWQyOGFkNzYzZDg4ZGU4NDk1ZTQzM2I0MjhjODRjMGFkZDkzZGZkIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1tCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0KQEAgLTEyMiw3 ICsxMjIsNyBAQCBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZUNGRGF0 YSgpCiAgICAgcmV0dXJuIGFkb3B0Q0YoKENGRGF0YVJlZilhZG9wdE5TKFtbV2ViQ29yZVNoYXJl ZEJ1ZmZlckRhdGEgYWxsb2NdIGluaXRXaXRoU2hhcmVkQnVmZmVyRGF0YUJ1ZmZlcjptX2J1ZmZl ci5nZXQoKV0pLmxlYWtSZWYoKSk7CiB9CiAKLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFy ZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRo KQorUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0Zp bGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKIHsKICAgICBOU0RhdGEgKnJlc291cmNlRGF0YSA9 IFtOU0RhdGEgZGF0YVdpdGhDb250ZW50c09mRmlsZTpmaWxlUGF0aF07CiAgICAgaWYgKHJlc291 cmNlRGF0YSkgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFy ZWRCdWZmZXJQT1NJWC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFyZWRC dWZmZXJQT1NJWC5jcHAKaW5kZXggZTc3YjhlY2YwNmY5YmM5YzBlNWZmYTFiZGEwN2Q4NjIxNDI4 NWJkNC4uODYzZGJlMjUzZTVhZjIyMDAzYzdmMGJlZjUzMGFiZmExYTAxYjBkNSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3Bvc2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcApA QCAtMzUsNyArMzUsNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NSZWZQdHI8U2hh cmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBT dHJpbmcmIGZpbGVQYXRoKQorUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVh dGVGcm9tUmVhZGluZ0ZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKIHsKICAgICBpZiAoZmls ZVBhdGguaXNFbXB0eSgpKQogICAgICAgICByZXR1cm4gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKaW5kZXggZjVkZDIyODQ2NDE5YTBmMmQ5 Nzg1YjlhNjljZGY5MDliYzM5MWQ3MC4uMmFhYjNjZDQyZDAyMzE3MDM1N2Q0MDhkNzIxMTJjYzEx ZTQ4ZjVjYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1 ZmZlcldpbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZl cldpbi5jcHAKQEAgLTMzLDcgKzMzLDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNz UmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZp bGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1 ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCiB7CiAg ICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuIDA7CmRpZmYgLS1naXQg YS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZjFjYmQyOGFjZWJiM2Vk ZjUxZWI5ODEyZjE3ZjRlMzAzYTQwOTA4My4uOTQ5MjkxMGFjYmZmOTc3NjFhZDZhOTdiYWU3NWM4 MTE0ZDI2Mjk3ZiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDE1LTA1LTEyICBZb3Vlbm4gRmFibGV0ICA8eW91ZW5u LmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRo Q29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0aW5lcworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0MTkyCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkaW5nIFNoYXJlZEJ1ZmZlciBh bmQgRmlsZVN5c3RlbSBVbml0IHRlc3RzIHRvIE1hYyBhbmQgR1RLLCBub3QgeWV0IGZvciBFRkwu CisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlOgorICAgICAgICAq IFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgor ICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcDogQWRk ZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpGaWxlU3lzdGVtVGVzdDo6dGVtcEZpbGVQYXRo KToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OkZpbGVTeXN0ZW1UZXN0Ojp0ZW1wRW1wdHlGaWxl UGF0aCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUX0YpOgorICAgICAgICAqIFRlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwOiBBZGRlZC4KKyAgICAgICAg KFRlc3RXZWJLaXRBUEk6OlNoYXJlZEJ1ZmZlclRlc3Q6OnRlbXBGaWxlUGF0aCk6CisgICAgICAg IChUZXN0V2ViS2l0QVBJOjpTaGFyZWRCdWZmZXJUZXN0Ojp0ZW1wRW1wdHlGaWxlUGF0aCk6Cisg ICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUX0YpOgorCiAyMDE1LTA1LTExICBEYW4gQmVybnN0 ZWluICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAgICAgVGVzdCBmb3IgPHJkYXI6Ly9wcm9ibGVt LzIwODc4MDc1PiBUcnlpbmcgdG8gbmF2aWdhdGUgdG8gYW4gaW52YWxpZCBVUkwgbG9hZHMgYWJv dXQ6YmxhbmssIGJ1dCAtW1dLV2ViVmlldyBVUkxdIHJldHVybnMgdGhlIGludmFsaWQgVVJMCmRp ZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlIGIvVG9vbHMv VGVzdFdlYktpdEFQSS9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCAwNmIzMDU3OTE1MTM0OTlkY2M3 MzkwNDYyZWViZWU4MzYyZjVmNTlkLi5jYzQ3ZTA4MzkzNjUwZDQ4MmMwN2Y1MTgxYTg2MDBiYjhm MGIyNjUwIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtl CisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTExLDYgKzEx LDcgQEAgc2V0KEZvcndhcmRpbmdIZWFkZXJzRm9yVGVzdFdlYktpdEFQSV9OQU1FIFRlc3RXZWJL aXRBUEktZm9yd2FyZGluZy1oZWFkZXJzKQogCiBpbmNsdWRlX2RpcmVjdG9yaWVzKAogICAgICR7 Rk9SV0FSRElOR19IRUFERVJTX0RJUn0KKyAgICAke0ZPUldBUkRJTkdfSEVBREVSU19ESVJ9L0ph dmFTY3JpcHRDb3JlCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQSS9DL3NvdXAKICAg ICAke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvQVBJL0MvZ3RrCiAgICAgJHtXRUJLSVQyX0RJUn0v VUlQcm9jZXNzL0FQSS9ndGsKQEAgLTEyMiw2ICsxMjMsOCBAQCBhZGRfZXhlY3V0YWJsZShUZXN0 V2ViQ29yZQogICAgICR7VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzQ29udHJvbGxlci5jcHAKICAg ICAke1RFU1RXRUJLSVRBUElfRElSfS9UZXN0cy9XZWJDb3JlL0xheW91dFVuaXQuY3BwCiAgICAg JHtURVNUV0VCS0lUQVBJX0RJUn0vVGVzdHMvV2ViQ29yZS9VUkwuY3BwCisgICAgJHtURVNUV0VC S0lUQVBJX0RJUn0vVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwCisgICAgJHtURVNUV0VC S0lUQVBJX0RJUn0vVGVzdHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcAogKQogCiB0YXJnZXRfbGlu a19saWJyYXJpZXMoVGVzdFdlYkNvcmUgJHt0ZXN0X3dlYmNvcmVfTElCUkFSSUVTfSkKZGlmZiAt LWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKaW5kZXggMWY1YWMxNTU4M2FmOWE1N2I0Y2JjYTg4ZmM4YWVlNzk4OGU1 OTcyNS4uOWExZjI5ZTQ5ODFhMjI0MGY1NGJmZWQ2Y2ZkMzgxMTJkYWI1YWViMSAxMDA2NDQKLS0t IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKQEAgLTQ1LDYgKzQ1LDggQEAKIAkJMzdEMzZGMzIxQjAwNERENDAwQkFG NUQ5IC8qIFByb3Zpc2lvbmFsVVJMQ2hhbmdlLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gMzdEMzZGMzExQjAwNERENDAwQkFGNUQ5IC8qIFByb3Zpc2lv bmFsVVJMQ2hhbmdlLm1tICovOyB9OwogCQkzN0RDNjc5MTE0MEQ3RDc2MDBBQkNDREIgLyogRE9N UmFuZ2VPZlN0cmluZy5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDM3REM2NzhGMTQwRDdEM0EwMEFCQ0NEQiAvKiBET01SYW5nZU9mU3Ry aW5nLmh0bWwgKi87IH07CiAJCTM3RTEwNjRDMTY5NzY4MTgwMEI3OEJEMCAvKiBET01IVE1MVGFi bGVDZWxsRWxlbWVudENlbGxBYm92ZS5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDM3RTEwNjRCMTY5NzY3RjcwMEI3OEJEMCAvKiBET01I VE1MVGFibGVDZWxsRWxlbWVudENlbGxBYm92ZS5odG1sICovOyB9OworCQk0MTk3M0I1QjFBRjIy ODZBMDA2QzdCMzYgLyogRmlsZVN5c3RlbS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA0MTk3M0I1QTFBRjIyODZBMDA2QzdCMzYgLyogRmlsZVN5c3Rl bS5jcHAgKi87IH07CisJCTQxOTczQjVEMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRCdWZmZXIu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDE5NzNC NUMxQUYyMjg3NTAwNkM3QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgKi87IH07CiAJCTRCRkRGRkE3 MTMxNDc3NkMwMDYxRjI0QiAvKiBIaXRUZXN0UmVzdWx0Tm9kZUhhbmRsZV9CdW5kbGUuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEJGREZGQTYxMzE0 Nzc2QzAwNjFGMjRCIC8qIEhpdFRlc3RSZXN1bHROb2RlSGFuZGxlX0J1bmRsZS5jcHAgKi87IH07 CiAJCTUxMzkzRTIyMTUyMzk1MkQwMDVGMzlDNSAvKiBET01XaW5kb3dFeHRlbnNpb25CYXNpY19C dW5kbGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NTEzOTNFMUQxNTIzOTQ0QTAwNUYzOUM1IC8qIERPTVdpbmRvd0V4dGVuc2lvbkJhc2ljX0J1bmRs ZS5jcHAgKi87IH07CiAJCTUxNDJCMjczMTUxN0M4QzgwMEMzMkIxOSAvKiBDb250ZXh0TWVudUNh bkNvcHlVUkwuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA1MTQyQjI3MjE1MTdDODkxMDBDMzJCMTkgLyogQ29udGV4dE1lbnVDYW5Db3B5 VVJMLmh0bWwgKi87IH07CkBAIC00OTcsNiArNDk5LDggQEAKIAkJMzdFMTA2NEExNjk3Njc2NDAw Qjc4QkQwIC8qIERPTUhUTUxUYWJsZUNlbGxDZWxsQWJvdmUubW0gKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5vYmpjcHA7IHBhdGggPSBET01IVE1MVGFibGVDZWxsQ2VsbEFib3ZlLm1tOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkzN0UxMDY0QjE2OTc2N0Y3MDBCNzhCRDAgLyogRE9N SFRNTFRhYmxlQ2VsbEVsZW1lbnRDZWxsQWJvdmUuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsg cGF0aCA9IERPTUhUTUxUYWJsZUNlbGxFbGVtZW50Q2VsbEFib3ZlLmh0bWw7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTM3RTM4QzMzMTY5QjdEMDEwMDg0QzI4QyAvKiBXZWJWaWV3RGlk UmVtb3ZlRnJhbWVGcm9tSGllcmFyY2h5Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2Jq Y3BwOyBwYXRoID0gV2ViVmlld0RpZFJlbW92ZUZyYW1lRnJvbUhpZXJhcmNoeS5tbTsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDE5NzNCNUExQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVT eXN0ZW0uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRmlsZVN5c3Rl bS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTQxOTczQjVDMUFGMjI4NzUwMDZD N0IzNiAvKiBTaGFyZWRCdWZmZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gU2hhcmVkQnVmZmVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDQw QTFEMzgxNEEwMTAzQTAwOEE2NkYyIC8qIFVSTC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBVUkwuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0NEE2 MjJDMTE0QTBFMkI2MDA0ODUxNUIgLyogV1RGU3RyaW5nVXRpbGl0aWVzLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdURlN0cmluZ1V0aWxpdGllcy5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk0QTQxMEY0QjE5QUY3QkQ2MDAyRUJBQjUgLyogVXNlck1lZGlhLmNw cCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFVzZXJNZWRpYS5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC03NjcsNiArNzcxLDcgQEAKIAkJMDhGQjc3OTVG RTg0MTU1REMwMkFBQzA3IC8qIFNvdXJjZSAqLyA9IHsKIAkJCWlzYSA9IFBCWEdyb3VwOwogCQkJ Y2hpbGRyZW4gPSAoCisJCQkJNDRBODJFN0IxOTI1MUIzNTAwQzFDOEM0IC8qIENvY29hICovLAog CQkJCTBGMTM5RTcxMUE0MjNBMUQwMEY1OTBGNSAvKiBjb2NvYSAqLywKIAkJCQlCQzU3NTk0NDEy NkU3MzNDMDA2RjBGMTIgLyogSW5qZWN0ZWRCdW5kbGUgKi8sCiAJCQkJMkU5NjYwREMxNkMwN0Q3 QjAwMzcxQjQyIC8qIGlvcyAqLywKQEAgLTg1OCw3ICs4NjMsOSBAQAogCQkJCTdDQjE4NEM0MUFB M0YyMTAwMDY2RURGRCAvKiBDb250ZW50RXh0ZW5zaW9ucy5jcHAgKi8sCiAJCQkJQ0Q1NDUxRTkx OUU0MUY5RDAwMTY5MzZGIC8qIENTU1BhcnNlci5jcHAgKi8sCiAJCQkJMjZGNkUxRUYxQURDNzQ5 QjAwREU2OTZCIC8qIERGQU1pbmltaXplci5jcHAgKi8sCisJCQkJNDE5NzNCNUExQUYyMjg2QTAw NkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3BwICovLAogCQkJCTE0NDY0MDEyMTY3QTgzMDUwMDBCRDIx OCAvKiBMYXlvdXRVbml0LmNwcCAqLywKKwkJCQk0MTk3M0I1QzFBRjIyODc1MDA2QzdCMzYgLyog U2hhcmVkQnVmZmVyLmNwcCAqLywKIAkJCQlDREMyQzcxNDE3OTcwODlEMDBFNjI3RkIgLyogVGlt ZVJhbmdlcy5jcHAgKi8sCiAJCQkJNDQwQTFEMzgxNEEwMTAzQTAwOEE2NkYyIC8qIFVSTC5jcHAg Ki8sCiAJCQkpOwpAQCAtODcwLDcgKzg3Nyw4IEBACiAJCQljaGlsZHJlbiA9ICgKIAkJCQk5M0E3 RUIzQzE4RkE2M0E0MDA5RTc2NzAgLyogVVJMRXh0cmFzLm1tICovLAogCQkJKTsKLQkJCXBhdGgg PSBDb2NvYTsKKwkJCW5hbWUgPSBDb2NvYTsKKwkJCXBhdGggPSBUZXN0cy9Db2NvYTsKIAkJCXNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7CiAJCX07CiAJCTc1NjA5MTc2MTkyNTlDNTkwMDlFRjA2RSAv KiBpb3MgKi8gPSB7CkBAIC0xMTYwLDcgKzExNjgsNiBAQAogCQlCQ0I5RUI2NjExMjM2NkQ4MDBB MTM3RTAgLyogVGVzdHMgKi8gPSB7CiAJCQlpc2EgPSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0g KAotCQkJCTQ0QTgyRTdCMTkyNTFCMzUwMEMxQzhDNCAvKiBDb2NvYSAqLywKIAkJCQk3NTYwOTE3 NjE5MjU5QzU5MDA5RUYwNkUgLyogaW9zICovLAogCQkJCUZFMjE3RUNCMTY0MEE1NEEwMDUyOTg4 QiAvKiBKYXZhU2NyaXB0Q29yZSAqLywKIAkJCQlDMDdFNkNBRDEzRkQ2NzY1MDAzOEIyMkIgLyog bWFjICovLApAQCAtMTU5NSw4ICsxNjAyLDEwIEBACiAJCQkJMkQxRkUwQjAxQUQ0NjVDMTAwNkNE OUU2IC8qIEZpeGVkTGF5b3V0U2l6ZS5tbSBpbiBTb3VyY2VzICovLAogCQkJCTFDQjlCQzM4MUE2 NzQ4MjMwMEZFNTY3OCAvKiBXZWFrUHRyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTJFNzc2NUNE MTZDNEQ4MEEwMEJBMkJCMSAvKiBtYWluSU9TLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJNDE5NzNC NUQxQUYyMjg3NTAwNkM3QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgaW4gU291cmNlcyAqLywKIAkJ CQk3QUE2QTE1MjFBQUMwQjMxMDAyQjJFRDMgLyogV29ya1F1ZXVlLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTJFNzc2NUNGMTZDNEQ4MTEwMEJBMkJCMSAvKiBtYWluTWFjLm1tIGluIFNvdXJjZXMg Ki8sCisJCQkJNDE5NzNCNUIxQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJN0E1NjIzMTExQUQ1QUYzRTAwOTZCOTIwIC8qIE1lbnVUeXBlc0Zvck1v dXNlRXZlbnRzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTI2RjZFMUYwMUFEQzc0OUIwMERFNjk2 QiAvKiBERkFNaW5pbWl6ZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0E5OUQ5OTQxQUQ0QTI5 RDAwMzczMTQxIC8qIE1lbnVUeXBlc0Zvck1vdXNlRXZlbnRzLm1tIGluIFNvdXJjZXMgKi8sCmRp ZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmlsZVN5c3RlbS5j cHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmlsZVN5c3RlbS5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZmIyM2E0YjdjYzM1YTA0NGUxMTI1NmZlNWZiZDZmYzgxZTA2MzM4OAotLS0gL2Rl di9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9GaWxlU3lzdGVt LmNwcApAQCAtMCwwICsxLDk2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisg KiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICog QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor CisjaW5jbHVkZSAiVGVzdC5oIgorI2luY2x1ZGUgPFdlYkNvcmUvRmlsZVN5c3RlbS5oPgorI2lu Y2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1N0cmluZ0V4dHJhcy5oPgor Cit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgewor Citjb25zdCBjaGFyKiBGaWxlU3lzdGVtVGVzdERhdGEgPSAiVGhpcyBpcyBhIHRlc3QiOworCisv LyBGSVhNRTogUmVmYWN0b3IgRmlsZVN5c3RlbVRlc3QgYW5kIFNoYXJlZEJ1ZmZlclRlc3QgYXMg YSBzaW5nbGUgY2xhc3MuCitjbGFzcyBGaWxlU3lzdGVtVGVzdCA6IHB1YmxpYyB0ZXN0aW5nOjpU ZXN0IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgU2V0VXAoKSBvdmVycmlkZQorICAgIHsK KyAgICAgICAgV1RGOjppbml0aWFsaXplTWFpblRocmVhZCgpOworICAgICAgICAKKyAgICAgICAg Ly8gY3JlYXRlIHRlbXAgZmlsZQorICAgICAgICBQbGF0Zm9ybUZpbGVIYW5kbGUgaGFuZGxlOwor ICAgICAgICBtX3RlbXBGaWxlUGF0aCA9IG9wZW5UZW1wb3JhcnlGaWxlKCJ0ZW1wVGVzdEZpbGUi LCBoYW5kbGUpOworICAgICAgICB3cml0ZVRvRmlsZShoYW5kbGUsIEZpbGVTeXN0ZW1UZXN0RGF0 YSwgc3RybGVuKEZpbGVTeXN0ZW1UZXN0RGF0YSkpOworICAgICAgICBjbG9zZUZpbGUoaGFuZGxl KTsgCisKKyAgICAgICAgbV90ZW1wRW1wdHlGaWxlUGF0aCA9IG9wZW5UZW1wb3JhcnlGaWxlKCJ0 ZW1wRW1wdHlUZXN0RmlsZSIsIGhhbmRsZSk7CisgICAgICAgIGNsb3NlRmlsZShoYW5kbGUpOyAK KyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgVGVhckRvd24oKSBvdmVycmlkZQorICAgIHsKKyAg ICAgICAgZGVsZXRlRmlsZShtX3RlbXBGaWxlUGF0aCk7CisgICAgICAgIGRlbGV0ZUZpbGUobV90 ZW1wRW1wdHlGaWxlUGF0aCk7CisgICAgfQorCisgICAgY29uc3QgU3RyaW5nJiB0ZW1wRmlsZVBh dGgoKSB7IHJldHVybiBtX3RlbXBGaWxlUGF0aDsgfQorICAgIGNvbnN0IFN0cmluZyYgdGVtcEVt cHR5RmlsZVBhdGgoKSB7IHJldHVybiBtX3RlbXBFbXB0eUZpbGVQYXRoOyB9CisKK3ByaXZhdGU6 CisgICAgU3RyaW5nIG1fdGVtcEZpbGVQYXRoOworICAgIFN0cmluZyBtX3RlbXBFbXB0eUZpbGVQ YXRoOworfTsKKworVEVTVF9GKEZpbGVTeXN0ZW1UZXN0LCBNYXBwaW5nTWlzc2luZ0ZpbGUpCit7 CisgICAgYm9vbCBzdWNjZXNzOworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhKFN0 cmluZygibm90X2V4aXN0aW5nX2ZpbGUiKSwgc3VjY2Vzcyk7CisgICAgRVhQRUNUX0ZBTFNFKHN1 Y2Nlc3MpOworICAgIEVYUEVDVF9UUlVFKCFtYXBwZWRGaWxlRGF0YSk7Cit9CisKK1RFU1RfRihG aWxlU3lzdGVtVGVzdCwgTWFwcGluZ0V4aXN0aW5nRmlsZSkKK3sKKyAgICBib29sIHN1Y2Nlc3M7 CisgICAgTWFwcGVkRmlsZURhdGEgbWFwcGVkRmlsZURhdGEodGVtcEZpbGVQYXRoKCksIHN1Y2Nl c3MpOworICAgIEVYUEVDVF9UUlVFKHN1Y2Nlc3MpOworICAgIEVYUEVDVF9UUlVFKCEhbWFwcGVk RmlsZURhdGEpOworICAgIEVYUEVDVF9UUlVFKG1hcHBlZEZpbGVEYXRhLnNpemUoKSA9PSBzdHJs ZW4oRmlsZVN5c3RlbVRlc3REYXRhKSk7CisgICAgRVhQRUNUX1RSVUUoc3RybnN0cihGaWxlU3lz dGVtVGVzdERhdGEsIHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihtYXBwZWRGaWxlRGF0YS5kYXRh KCkpLCBtYXBwZWRGaWxlRGF0YS5zaXplKCkpKTsKK30KKworVEVTVF9GKEZpbGVTeXN0ZW1UZXN0 LCBNYXBwaW5nRXhpc3RpbmdFbXB0eUZpbGUpCit7CisgICAgYm9vbCBzdWNjZXNzOworICAgIE1h cHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhKHRlbXBFbXB0eUZpbGVQYXRoKCksIHN1Y2Nlc3Mp OworICAgIEVYUEVDVF9UUlVFKHN1Y2Nlc3MpOworICAgIEVYUEVDVF9UUlVFKCFtYXBwZWRGaWxl RGF0YSk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi Q29yZS9TaGFyZWRCdWZmZXIuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3Jl L1NoYXJlZEJ1ZmZlci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMTllOTBiNmQwOGUxMjZmY2ZmYjk1ODdiMDJi NzcyODYxMzJhYmE1OAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0wLDAgKzEsMTE5IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBD T05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4g T1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAq IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisg KiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiVGVzdC5oIgorI2luY2x1ZGUgPFdl YkNvcmUvU2hhcmVkQnVmZmVyLmg+CisjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KKyNpbmNs dWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCitu YW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK2NvbnN0IGNoYXIqIFNoYXJlZEJ1ZmZlclRlc3RE YXRhID0gIlRoaXMgaXMgYSB0ZXN0IjsKKworY2xhc3MgU2hhcmVkQnVmZmVyVGVzdCA6IHB1Ymxp YyB0ZXN0aW5nOjpUZXN0IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgU2V0VXAoKSBvdmVy cmlkZQorICAgIHsKKyAgICAgICAgV1RGOjppbml0aWFsaXplTWFpblRocmVhZCgpOworICAgICAg ICAKKyAgICAgICAgLy8gY3JlYXRlIHRlbXAgZmlsZQorICAgICAgICBQbGF0Zm9ybUZpbGVIYW5k bGUgaGFuZGxlOworICAgICAgICBtX3RlbXBGaWxlUGF0aCA9IG9wZW5UZW1wb3JhcnlGaWxlKCJ0 ZW1wVGVzdEZpbGUiLCBoYW5kbGUpOworICAgICAgICB3cml0ZVRvRmlsZShoYW5kbGUsIFNoYXJl ZEJ1ZmZlclRlc3REYXRhLCBzdHJsZW4oU2hhcmVkQnVmZmVyVGVzdERhdGEpKTsKKyAgICAgICAg Y2xvc2VGaWxlKGhhbmRsZSk7IAorCisgICAgICAgIG1fdGVtcEVtcHR5RmlsZVBhdGggPSBvcGVu VGVtcG9yYXJ5RmlsZSgidGVtcEVtcHR5VGVzdEZpbGUiLCBoYW5kbGUpOworICAgICAgICBjbG9z ZUZpbGUoaGFuZGxlKTsgCisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIFRlYXJEb3duKCkgb3Zl cnJpZGUKKyAgICB7CisgICAgICAgIGRlbGV0ZUZpbGUobV90ZW1wRmlsZVBhdGgpOworICAgICAg ICBkZWxldGVGaWxlKG1fdGVtcEVtcHR5RmlsZVBhdGgpOworICAgIH0KKworICAgIGNvbnN0IFN0 cmluZyYgdGVtcEZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRmlsZVBhdGg7IH0KKyAgICBjb25z dCBTdHJpbmcmIHRlbXBFbXB0eUZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRW1wdHlGaWxlUGF0 aDsgfQorCitwcml2YXRlOgorICAgIFN0cmluZyBtX3RlbXBGaWxlUGF0aDsKKyAgICBTdHJpbmcg bV90ZW1wRW1wdHlGaWxlUGF0aDsKK307CisKK1RFU1RfRihTaGFyZWRCdWZmZXJUZXN0LCBjcmVh dGVXaXRoQ29udGVudHNPZk1pc3NpbmdGaWxlKQoreworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+ IGJ1ZmZlciA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKFN0cmluZygi bm90X2V4aXN0aW5nX2ZpbGUiKSk7CisgICAgQVNTRVJUX05VTEwoYnVmZmVyKTsKK30KKworVEVT VF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNyZWF0ZVdpdGhDb250ZW50c09mRXhpc3RpbmdGaWxlKQor eworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRl V2l0aENvbnRlbnRzT2ZGaWxlKHRlbXBGaWxlUGF0aCgpKTsKKyAgICBBU1NFUlRfTk9UX05VTEwo YnVmZmVyKTsKKyAgICBFWFBFQ1RfVFJVRShidWZmZXItPnNpemUoKSA9PSBzdHJsZW4oU2hhcmVk QnVmZmVyVGVzdERhdGEpKTsKKyAgICBFWFBFQ1RfVFJVRShTdHJpbmcoU2hhcmVkQnVmZmVyVGVz dERhdGEpID09IFN0cmluZyhidWZmZXItPmRhdGEoKSwgYnVmZmVyLT5zaXplKCkpKTsKK30KKwor VEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3QsIGNyZWF0ZVdpdGhDb250ZW50c09mRXhpc3RpbmdFbXB0 eUZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVkQnVmZmVy OjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUodGVtcEVtcHR5RmlsZVBhdGgoKSk7CisgICAgQVNT RVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgRVhQRUNUX1RSVUUoYnVmZmVyLT5pc0VtcHR5KCkp OworfQorCitURVNUX0YoU2hhcmVkQnVmZmVyVGVzdCwgY29weUJ1ZmZlckNyZWF0ZWRXaXRoQ29u dGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZmZXIg PSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSh0ZW1wRmlsZVBhdGgoKSk7 CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4g Y29weSA9IGJ1ZmZlci0+Y29weSgpOworICAgIEVYUEVDVF9UUlVFKGJ1ZmZlci0+c2l6ZSgpID09 IGNvcHktPnNpemUoKSk7CisgICAgRVhQRUNUX1RSVUUoc3RybnN0cihidWZmZXItPmRhdGEoKSwg Y29weS0+ZGF0YSgpLCBidWZmZXItPnNpemUoKSkpOworfQorCitURVNUX0YoU2hhcmVkQnVmZmVy VGVzdCwgY2xlYXJCdWZmZXJDcmVhdGVkV2l0aENvbnRlbnRzT2ZFeGlzdGluZ0ZpbGUpCit7Cisg ICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRo Q29udGVudHNPZkZpbGUodGVtcEZpbGVQYXRoKCkpOworICAgIEFTU0VSVF9OT1RfTlVMTChidWZm ZXIpOworICAgIGJ1ZmZlci0+Y2xlYXIoKTsKKyAgICBFWFBFQ1RfVFJVRSghYnVmZmVyLT5zaXpl KCkpOworICAgIEVYUEVDVF9UUlVFKCFidWZmZXItPmRhdGEoKSk7Cit9CisKKworVEVTVF9GKFNo YXJlZEJ1ZmZlclRlc3QsIGFwcGVuZEJ1ZmZlckNyZWF0ZWRXaXRoQ29udGVudHNPZkV4aXN0aW5n RmlsZSkKK3sKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6 OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSh0ZW1wRmlsZVBhdGgoKSk7CisgICAgQVNTRVJUX05P VF9OVUxMKGJ1ZmZlcik7CisgICAgYnVmZmVyLT5hcHBlbmQoImEiLCAxKTsKKyAgICBFWFBFQ1Rf VFJVRShidWZmZXItPnNpemUoKSA9PSAoc3RybGVuKFNoYXJlZEJ1ZmZlclRlc3REYXRhKSArIDEp KTsKKyAgICBFWFBFQ1RfVFJVRShzdHJuc3RyKGJ1ZmZlci0+ZGF0YSgpLCBTaGFyZWRCdWZmZXJU ZXN0RGF0YSwgc3RybGVuKFNoYXJlZEJ1ZmZlclRlc3REYXRhKSkpOworICAgIEVYUEVDVF9FUSgn YScsIGJ1ZmZlci0+ZGF0YSgpW3N0cmxlbihTaGFyZWRCdWZmZXJUZXN0RGF0YSldKTsKK30KKwor fQo= 253102 2015-05-14 00:00:57 -0700 2015-05-14 00:59:21 -0700 Patch for landing bug-144192-20150514085922.patch text/plain 31337 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0MTcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDRiODlhNGNmZTZkODJi NmUxM2ZlZTE4MmQ1NDBkODNlYWFiMjAwYS4uN2UwMmM0MWQxZmFkODM0ZDk1NzFjN2QxMjgzYzNi ZDdjMWIyZGY0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDE1LTA1LTEyICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVk QnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0 aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0 MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgTWFkZSB1 c2Ugb2YgbW1hcCByb3V0aW5lcyB3aXRoaW4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVu dHNPZkZpbGUgZm9yIEVGTCwgR1RLIGFuZCBNYWMgcG9ydHMuCisgICAgICAgIElmIG1hcHBpbmcg aXMgZmFpbGluZywgaXQgZmFsbHMgYmFjayB0byB0aGUgcHJldmlvdXMgdmVyc2lvbiBvZiBTaGFy ZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSByZW5hbWVkIGFzCisgICAgICAgIFNo YXJlZEJ1ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlICh1c2luZyBvcGVuL3JlYWQgbWV0aG9k KS4KKyAgICAgICAgRmlsZSBjb250ZW50IGlzIG1hcHBlZCB1bnRpbCBTaGFyZWRCdWZmZXIgaXMg Y2xlYXJlZCwgZGVzdHJveWVkIG9yIGFkZGl0aW9uYWwgY29udGVudCBpcyBhcHBlbmRlZCB0byB0 aGUgU2hhcmVkQnVmZmVyLgorCisgICAgICAgIEEgaGVscGVyIGNsYXNzLCBNYXBwZWRGaWxlRGF0 YSwgaXMgaW50cm9kdWNlZCB0byBoYW5kbGUgbWFwcGVkIGZpbGVzIHRocm91Z2ggY2FsbHMgdG8g b3Blbi9tbWFwL211bm1hcC9jbG9zZS4KKworICAgICAgICBQYXRjaCBjb3ZlcmVkIGJ5IGV4aXN0 aW5nIGxheW91dCB0ZXN0cyBhbmQgYWRkZWQgdW5pdCB0ZXN0cy4KKworICAgICAgICAqIHBsYXRm b3JtL0ZpbGVTeXN0ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6Ok1h cHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpvcGVyYXRv cj0pOgorICAgICAgICAoV2ViQ29yZTo6TWFwcGVkRmlsZURhdGE6On5NYXBwZWRGaWxlRGF0YSk6 CisgICAgICAgICogcGxhdGZvcm0vRmlsZVN5c3RlbS5oOgorICAgICAgICAoV2ViQ29yZTo6TWFw cGVkRmlsZURhdGE6Ok1hcHBlZEZpbGVEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZp bGVEYXRhOjpvcGVyYXRvciBib29sKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRh OjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6Ok1hcHBlZEZpbGVEYXRhOjpzaXplKToKKyAgICAg ICAgKiBwbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVk QnVmZmVyOjpTaGFyZWRCdWZmZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpj cmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOiBNYWtpbmcgdXNlIG9mIE1hcHBlZEZpbGVEYXRhIGJl Zm9yZSB1c2luZyBjcmVhdGVGcm9tUmVhZGluZ0ZpbGUuCisgICAgICAgIChXZWJDb3JlOjpTaGFy ZWRCdWZmZXI6OnNpemUpOiBDaGVja2luZyB3aGV0aGVyIGRhdGEgaXMgY29taW5nIGZyb20gYSBN YXBwZWRGaWxlRGF0YS4KKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6ZGF0YSk6IERp dHRvLgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjphcHBlbmQpOiBEaXR0by4KKyAg ICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y2xlYXIpOiBDbGVhcmluZyBNYXBwZWRGaWxl RGF0YSBpZiBuZWVkZWQuCisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OmNvcHkpOiBU cmFuc2ZlcnJpbmcgbWFwcGVkIGRhdGEgdG8gYnVmZmVyIGlmIG5lZWRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Z2V0U29tZURhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U2hh cmVkQnVmZmVyOjptYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEpOgorICAgICAgICAqIHBsYXRm b3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJH dGsuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGlu Z0ZpbGUpOiByZW5hbWVkIGZyb20gY3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlLgorICAgICAgICAq IHBsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW06CisgICAgICAgIChXZWJDb3JlOjpTaGFy ZWRCdWZmZXI6OmNyZWF0ZUZyb21SZWFkaW5nRmlsZSk6IERpdG8uCisgICAgICAgICogcGxhdGZv cm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVk QnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0ZpbGUpOiBEaXR0by4KKyAgICAgICAgKiBwbGF0Zm9y bS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZl cjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlKTogRGl0dG8uCisKIDIwMTUtMDUtMTIgIFhhYmllciBS b2RyaWd1ZXogQ2FsdmFyICA8Y2FsdmFyaXNAaWdhbGlhLmNvbT4gYW5kIFlvdWVubiBGYWJsZXQg PHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgogCiAgICAgICAgIFtTdHJlYW1zIEFQSV0gUmVh ZGFibGVTdHJlYW0gcmVhZGVyIHNob3VsZCBub3QgYmUgZGlzcG9zYWJsZSB3aGVuIGhhdmluZyBw ZW5kaW5nIHByb21pc2VzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxl U3lzdGVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCmluZGV4 IDk3Yjg0NmVlY2M0YzYzMGRkYmEwNmQ0YzU3ZDM2MTc2OGQ4ZWNmZGYuLjk0NmQ1ZjNiM2E1ZDQ3 ZmY5NDg2Mjg0YmQwYmMzMjg4NzMzM2ZiMWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL0ZpbGVTeXN0ZW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVT eXN0ZW0uY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNywgMjAx MSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUg Q2Fub24gSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCkBAIC0yNyw4ICsyOCwxNiBAQAogI2luY2x1ZGUgIkZpbGVTeXN0ZW0uaCIKIAogI2lu Y2x1ZGUgPHd0Zi9IZXhOdW1iZXIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAj aW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCisjaWYgIVBMQVRGT1JNKFdJTikK KyNpbmNsdWRlIDxmY250bC5oPgorI2luY2x1ZGUgPHN5cy9tbWFuLmg+CisjaW5jbHVkZSA8c3lz L3N0YXQuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAKIC8vIFRoZSBmb2xsb3dpbmcgbG93ZXItQVNDSUkgY2hhcmFjdGVycyBuZWVkIGVzY2Fw aW5nIHRvIGJlIHVzZWQgaW4gYSBmaWxlbmFtZQpAQCAtMTEzLDQgKzEyMiw2MSBAQCBib29sIGV4 Y2x1ZGVGcm9tQmFja3VwKGNvbnN0IFN0cmluZyYpCiAKICNlbmRpZgogCitNYXBwZWRGaWxlRGF0 YTo6fk1hcHBlZEZpbGVEYXRhKCkKK3sKKyNpZiAhUExBVEZPUk0oV0lOKQorICAgIGlmICghbV9m aWxlRGF0YSkKKyAgICAgICAgcmV0dXJuOworICAgIG11bm1hcChtX2ZpbGVEYXRhLCBtX2ZpbGVT aXplKTsKKyNlbmRpZgorfQorCitNYXBwZWRGaWxlRGF0YTo6TWFwcGVkRmlsZURhdGEoY29uc3Qg U3RyaW5nJiBmaWxlUGF0aCwgYm9vbCYgc3VjY2VzcykKK3sKKyNpZiBQTEFURk9STShXSU4pCisg ICAgLy8gRklYTUU6IEltcGxlbWVudCBtYXBwaW5nCisgICAgc3VjY2VzcyA9IGZhbHNlOworI2Vs c2UKKyAgICBDU3RyaW5nIGZzUmVwID0gZmlsZVN5c3RlbVJlcHJlc2VudGF0aW9uKGZpbGVQYXRo KTsKKyAgICBpbnQgZmQgPSAhZnNSZXAuaXNOdWxsKCkgPyBvcGVuKGZzUmVwLmRhdGEoKSwgT19S RE9OTFkpIDogLTE7CisgICAgaWYgKGZkIDwgMCkgeworICAgICAgICBzdWNjZXNzID0gZmFsc2U7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBzdHJ1Y3Qgc3RhdCBmaWxlU3RhdDsKKyAg ICBpZiAoZnN0YXQoZmQsICZmaWxlU3RhdCkpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAg ICBzdWNjZXNzID0gZmFsc2U7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoZmls ZVN0YXQuc3Rfc2l6ZSA8IDAgfHwgZmlsZVN0YXQuc3Rfc2l6ZSA+IHN0ZDo6bnVtZXJpY19saW1p dHM8dW5zaWduZWQ+OjptYXgoKSkgeworICAgICAgICBjbG9zZShmZCk7CisgICAgICAgIHN1Y2Nl c3MgPSBmYWxzZTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHVuc2lnbmVkIHNpemUg PSBzdGF0aWNfY2FzdDx1bnNpZ25lZD4oZmlsZVN0YXQuc3Rfc2l6ZSk7CisKKyAgICBpZiAoIXNp emUpIHsKKyAgICAgICAgY2xvc2UoZmQpOworICAgICAgICBzdWNjZXNzID0gdHJ1ZTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIHZvaWQqIGRhdGEgPSBtbWFwKDAsIHNpemUsIFBST1Rf UkVBRCwgTUFQX0ZJTEUgfCBNQVBfU0hBUkVELCBmZCwgMCk7CisgICAgY2xvc2UoZmQpOworCisg ICAgaWYgKGRhdGEgPT0gTUFQX0ZBSUxFRCkgeworICAgICAgICBzdWNjZXNzID0gZmFsc2U7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBzdWNjZXNzID0gdHJ1ZTsKKyAgICBtX2ZpbGVE YXRhID0gZGF0YTsKKyAgICBtX2ZpbGVTaXplID0gc2l6ZTsKKyNlbmRpZgorfQorCiB9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxl U3lzdGVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9GaWxlU3lzdGVtLmgKaW5kZXggM2E3 ZmI0YjllMjgzYmIzOTA4N2FjMGEyNDc1MjE3N2UwZDc2YzA0Ni4uMTNhYjI5YmIyYjliOTk3OWMx OTNmYmI5MTM1ZjNlN2U1YzdiYTNiMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vRmlsZVN5c3RlbS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0ZpbGVTeXN0ZW0u aApAQCAtMSw2ICsxLDcgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDgsIDIwMTEg QXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICogQ29weXJpZ2h0IChDKSAyMDA4IENv bGxhYm9yYSwgTHRkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE1 IENhbm9uIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucwpAQCAtMjA0LDYgKzIwNSwzNiBAQCBXRUJDT1JFX0VYUE9SVCBTdHJpbmcgbG9jYWxV c2VyU3BlY2lmaWNTdG9yYWdlRGlyZWN0b3J5KCk7CiBTdHJpbmcgcm9hbWluZ1VzZXJTcGVjaWZp Y1N0b3JhZ2VEaXJlY3RvcnkoKTsKICNlbmRpZgogCitjbGFzcyBNYXBwZWRGaWxlRGF0YSB7Citw dWJsaWM6CisgICAgTWFwcGVkRmlsZURhdGEoKSB7IH0KKyAgICBNYXBwZWRGaWxlRGF0YShNYXBw ZWRGaWxlRGF0YSYmKTsKKyAgICBXRUJDT1JFX0VYUE9SVCBNYXBwZWRGaWxlRGF0YShjb25zdCBT dHJpbmcmIGZpbGVQYXRoLCBib29sJiBzdWNjZXNzKTsKKyAgICBXRUJDT1JFX0VYUE9SVCB+TWFw cGVkRmlsZURhdGEoKTsKKyAgICBNYXBwZWRGaWxlRGF0YSYgb3BlcmF0b3I9KE1hcHBlZEZpbGVE YXRhJiYpOworCisgICAgZXhwbGljaXQgb3BlcmF0b3IgYm9vbCgpIGNvbnN0IHsgcmV0dXJuICEh bV9maWxlRGF0YTsgfQorICAgIGNvbnN0IHZvaWQqIGRhdGEoKSBjb25zdCB7IHJldHVybiBtX2Zp bGVEYXRhOyB9CisgICAgdW5zaWduZWQgc2l6ZSgpIGNvbnN0IHsgcmV0dXJuIG1fZmlsZVNpemU7 IH0KKworcHJpdmF0ZToKKyAgICB2b2lkKiBtX2ZpbGVEYXRhIHsgbnVsbHB0ciB9OworICAgIHVu c2lnbmVkIG1fZmlsZVNpemUgeyAwIH07Cit9OworCitpbmxpbmUgTWFwcGVkRmlsZURhdGE6Ok1h cHBlZEZpbGVEYXRhKE1hcHBlZEZpbGVEYXRhJiYgb3RoZXIpCisgICAgOiBtX2ZpbGVEYXRhKHN0 ZDo6ZXhjaGFuZ2Uob3RoZXIubV9maWxlRGF0YSwgbnVsbHB0cikpCisgICAgLCBtX2ZpbGVTaXpl KHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV9maWxlU2l6ZSwgMCkpCit7Cit9CisKK2lubGluZSBNYXBw ZWRGaWxlRGF0YSYgTWFwcGVkRmlsZURhdGE6Om9wZXJhdG9yPShNYXBwZWRGaWxlRGF0YSYmIG90 aGVyKQoreworICAgIG1fZmlsZURhdGEgPSBzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fZmlsZURhdGEs IG51bGxwdHIpOworICAgIG1fZmlsZVNpemUgPSBzdGQ6OmV4Y2hhbmdlKG90aGVyLm1fZmlsZVNp emUsIDApOworICAgIHJldHVybiAqdGhpczsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQog CiAjZW5kaWYgLy8gRmlsZVN5c3RlbV9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9TaGFyZWRCdWZmZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVm ZmVyLmNwcAppbmRleCA5ZGI3ZmFkMjA4MDI3ZTFmMWU3ZTAxNDg1M2UyMTU4ZTZkMjZmMjE2Li42 NDZlMmFjNjQwYjliNjAwYTkxNGNiMWRjZjRhNjllZjc4ZTEyMGM5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKQEAgLTEsNiArMSw3IEBACiAvKgogICogQ29weXJp Z2h0IChDKSAyMDA2LCAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqIENv cHlyaWdodCAoQykgUmVzZWFyY2ggSW4gTW90aW9uIExpbWl0ZWQgMjAwOS0yMDEwLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtODIsMTIgKzgz LDI5IEBAIFNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKGNvbnN0IHVuc2lnbmVkIGNoYXIqIGRh dGEsIHVuc2lnbmVkIHNpemUpCiB7CiAgICAgYXBwZW5kKHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3Qg Y2hhcio+KGRhdGEpLCBzaXplKTsKIH0KLSAgICAKKworU2hhcmVkQnVmZmVyOjpTaGFyZWRCdWZm ZXIoTWFwcGVkRmlsZURhdGEmJiBmaWxlRGF0YSkKKyAgICA6IG1fYnVmZmVyKGFkb3B0UmVmKG5l dyBEYXRhQnVmZmVyKSkKKyAgICAsIG1fZmlsZURhdGEoV1RGOjptb3ZlKGZpbGVEYXRhKSkKK3sK K30KKwogU2hhcmVkQnVmZmVyOjp+U2hhcmVkQnVmZmVyKCkKIHsKICAgICBjbGVhcigpOwogfQog CitSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09m RmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQoreworICAgIGJvb2wgbWFwcGluZ1N1Y2Nlc3M7 CisgICAgTWFwcGVkRmlsZURhdGEgbWFwcGVkRmlsZURhdGEoZmlsZVBhdGgsIG1hcHBpbmdTdWNj ZXNzKTsKKworICAgIGlmICghbWFwcGluZ1N1Y2Nlc3MpCisgICAgICAgIHJldHVybiBTaGFyZWRC dWZmZXI6OmNyZWF0ZUZyb21SZWFkaW5nRmlsZShmaWxlUGF0aCk7CisKKyAgICByZXR1cm4gYWRv cHRSZWYobmV3IFNoYXJlZEJ1ZmZlcihXVEY6Om1vdmUobWFwcGVkRmlsZURhdGEpKSk7Cit9CisK IFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmFkb3B0VmVjdG9yKFZlY3Rv cjxjaGFyPiYgdmVjdG9yKQogewogICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IGNy ZWF0ZSgpOwpAQCAtMTAxLDE1ICsxMTksMjAgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpzaXpl KCkgY29uc3QKICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0 Zm9ybURhdGFTaXplKCk7CiAgICAgCisgICAgaWYgKG1fZmlsZURhdGEpCisgICAgICAgIHJldHVy biBtX2ZpbGVEYXRhLnNpemUoKTsKKwogICAgIHJldHVybiBtX3NpemU7CiB9CiAKIGNvbnN0IGNo YXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CiB7Ci0KICAgICBpZiAoaGFzUGxhdGZvcm1E YXRhKCkpCiAgICAgICAgIHJldHVybiBwbGF0Zm9ybURhdGEoKTsKIAorICAgIGlmIChtX2ZpbGVE YXRhKQorICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8Y29uc3QgY2hhcio+KG1fZmlsZURhdGEu ZGF0YSgpKTsKKwogI2lmIFVTRShORVRXT1JLX0NGREFUQV9BUlJBWV9DQUxMQkFDSykKICAgICBp ZiAoY29uc3QgY2hhciogYnVmZmVyID0gc2luZ2xlRGF0YUFycmF5QnVmZmVyKCkpCiAgICAgICAg IHJldHVybiBidWZmZXI7CkBAIC0xNjAsNiArMTgzLDcgQEAgdm9pZCBTaGFyZWRCdWZmZXI6OmFw cGVuZChjb25zdCBjaGFyKiBkYXRhLCB1bnNpZ25lZCBsZW5ndGgpCiAgICAgaWYgKCFsZW5ndGgp CiAgICAgICAgIHJldHVybjsKIAorICAgIG1heWJlVHJhbnNmZXJNYXBwZWRGaWxlRGF0YSgpOwog ICAgIG1heWJlVHJhbnNmZXJQbGF0Zm9ybURhdGEoKTsKIAogI2lmICFVU0UoTkVUV09SS19DRkRB VEFfQVJSQVlfQ0FMTEJBQ0spCkBAIC0yMTAsNiArMjM0LDggQEAgdm9pZCBTaGFyZWRCdWZmZXI6 OmFwcGVuZChjb25zdCBWZWN0b3I8Y2hhcj4mIGRhdGEpCiAKIHZvaWQgU2hhcmVkQnVmZmVyOjpj bGVhcigpCiB7CisgICAgbV9maWxlRGF0YSA9IHsgfTsKKwogICAgIGNsZWFyUGxhdGZvcm1EYXRh KCk7CiAgICAgCiAjaWYgIVVTRShORVRXT1JLX0NGREFUQV9BUlJBWV9DQUxMQkFDSykKQEAgLTIy Nyw3ICsyNTMsOCBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXIoKQogUGFzc1JlZlB0cjxTaGFy ZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y29weSgpIGNvbnN0CiB7CiAgICAgUmVmUHRyPFNoYXJl ZEJ1ZmZlcj4gY2xvbmUgeyBhZG9wdFJlZigqbmV3IFNoYXJlZEJ1ZmZlcikgfTsKLSAgICBpZiAo aGFzUGxhdGZvcm1EYXRhKCkpIHsKKworICAgIGlmIChoYXNQbGF0Zm9ybURhdGEoKSB8fCBtX2Zp bGVEYXRhKSB7CiAgICAgICAgIGNsb25lLT5hcHBlbmQoZGF0YSgpLCBzaXplKCkpOwogICAgICAg ICByZXR1cm4gY2xvbmUucmVsZWFzZSgpOwogICAgIH0KQEAgLTMxMCw3ICszMzcsNyBAQCB1bnNp Z25lZCBTaGFyZWRCdWZmZXI6OmdldFNvbWVEYXRhKGNvbnN0IGNoYXIqJiBzb21lRGF0YSwgdW5z aWduZWQgcG9zaXRpb24pIGNvbgogICAgICAgICByZXR1cm4gMDsKICAgICB9CiAKLSAgICBpZiAo aGFzUGxhdGZvcm1EYXRhKCkpIHsKKyAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkgfHwgbV9maWxl RGF0YSkgewogICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihwb3NpdGlv biA8IHNpemUoKSk7CiAgICAgICAgIHNvbWVEYXRhID0gZGF0YSgpICsgcG9zaXRpb247CiAgICAg ICAgIHJldHVybiB0b3RhbFNpemUgLSBwb3NpdGlvbjsKQEAgLTM0Myw2ICszNzAsMTQgQEAgdW5z aWduZWQgU2hhcmVkQnVmZmVyOjpnZXRTb21lRGF0YShjb25zdCBjaGFyKiYgc29tZURhdGEsIHVu c2lnbmVkIHBvc2l0aW9uKSBjb24KICNlbmRpZgogfQogCit2b2lkIFNoYXJlZEJ1ZmZlcjo6bWF5 YmVUcmFuc2Zlck1hcHBlZEZpbGVEYXRhKCkKK3sKKyAgICBpZiAobV9maWxlRGF0YSkgeworICAg ICAgICBhdXRvIGZpbGVEYXRhID0gV1RGOjptb3ZlKG1fZmlsZURhdGEpOworICAgICAgICBhcHBl bmQoc3RhdGljX2Nhc3Q8Y29uc3QgY2hhcio+KGZpbGVEYXRhLmRhdGEoKSksIGZpbGVEYXRhLnNp emUoKSk7CisgICAgfQorfQorCiAjaWYgIVVTRShDRikgJiYgIVVTRShTT1VQKQogCiBpbmxpbmUg dm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyUGxhdGZvcm1EYXRhKCkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vU2hhcmVkQnVmZmVyLmgKaW5kZXggMDQ1NWQ3OTk0MDY2MDNjYTEzMmRhNzlkMTgzMDRiNmRi M2ViMGY0OC4uNDRhYTgxODIxZGU1MTY4ODFkNDVhYmQzODc0MGJhODhkODZlZTkyOSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKQEAgLTI3LDYgKzI3LDcgQEAKICNpZm5k ZWYgU2hhcmVkQnVmZmVyX2gKICNkZWZpbmUgU2hhcmVkQnVmZmVyX2gKIAorI2luY2x1ZGUgIkZp bGVTeXN0ZW0uaCIKICNpbmNsdWRlIDxydW50aW1lL0FycmF5QnVmZmVyLmg+CiAjaW5jbHVkZSA8 d3RmL0ZvcndhcmQuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgpAQCAtNTUsNyArNTYs NyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGUo Y29uc3QgY2hhciogYywgdW5zaWduZWQgaSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IFNoYXJlZEJ1 ZmZlcihjLCBpKSk7IH0KICAgICBzdGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGNyZWF0 ZShjb25zdCB1bnNpZ25lZCBjaGFyKiBjLCB1bnNpZ25lZCBpKSB7IHJldHVybiBhZG9wdFJlZihu ZXcgU2hhcmVkQnVmZmVyKGMsIGkpKTsgfQogCi0gICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFBh c3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3Ry aW5nJiBmaWxlUGF0aCk7CisgICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFJlZlB0cjxTaGFyZWRC dWZmZXI+IGNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKTsK IAogICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYWRv cHRWZWN0b3IoVmVjdG9yPGNoYXI+JiB2ZWN0b3IpOwogICAgIApAQCAtOTIsNyArOTMsNyBAQCBw dWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBhcHBlbmQoY29uc3QgY2hhciosIHVuc2ln bmVkKTsKICAgICB2b2lkIGFwcGVuZChjb25zdCBWZWN0b3I8Y2hhcj4mKTsKIAotICAgIHZvaWQg Y2xlYXIoKTsKKyAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGNsZWFyKCk7CiAgICAgY29uc3QgY2hh ciogcGxhdGZvcm1EYXRhKCkgY29uc3Q7CiAgICAgdW5zaWduZWQgcGxhdGZvcm1EYXRhU2l6ZSgp IGNvbnN0OwogCkBAIC0xMDEsNyArMTAyLDcgQEAgcHVibGljOgogICAgIHZvaWQgYXBwZW5kKENG RGF0YVJlZik7CiAjZW5kaWYKIAotICAgIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBjb3B5KCkg Y29uc3Q7CisgICAgV0VCQ09SRV9FWFBPUlQgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IGNvcHko KSBjb25zdDsKICAgICAKICAgICAvLyBSZXR1cm4gdGhlIG51bWJlciBvZiBjb25zZWN1dGl2ZSBi eXRlcyBhZnRlciAicG9zaXRpb24iLiAiZGF0YSIKICAgICAvLyBwb2ludHMgdG8gdGhlIGZpcnN0 IGJ5dGUuCkBAIC0xMjksNyArMTMwLDEwIEBAIHByaXZhdGU6CiAgICAgZXhwbGljaXQgU2hhcmVk QnVmZmVyKHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRCdWZmZXIoY29uc3Qg Y2hhciosIHVuc2lnbmVkKTsKICAgICBXRUJDT1JFX0VYUE9SVCBTaGFyZWRCdWZmZXIoY29uc3Qg dW5zaWduZWQgY2hhciosIHVuc2lnbmVkKTsKLSAgICAKKyAgICBleHBsaWNpdCBTaGFyZWRCdWZm ZXIoTWFwcGVkRmlsZURhdGEmJik7CisKKyAgICBzdGF0aWMgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4g Y3JlYXRlRnJvbVJlYWRpbmdGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpOworCiAgICAgLy8g Q2FsbGluZyB0aGlzIGZ1bmN0aW9uIHdpbGwgZm9yY2UgaW50ZXJuYWwgc2VnbWVudGVkIGJ1ZmZl cnMKICAgICAvLyB0byBiZSBtZXJnZWQgaW50byBhIGZsYXQgYnVmZmVyLiBVc2UgZ2V0U29tZURh dGEoKSB3aGVuZXZlciBwb3NzaWJsZQogICAgIC8vIGZvciBiZXR0ZXIgcGVyZm9ybWFuY2UuCkBA IC0xMzksNiArMTQzLDggQEAgcHJpdmF0ZToKICAgICB2b2lkIG1heWJlVHJhbnNmZXJQbGF0Zm9y bURhdGEoKTsKICAgICBib29sIG1heWJlQXBwZW5kUGxhdGZvcm1EYXRhKFNoYXJlZEJ1ZmZlciop OwogCisgICAgdm9pZCBtYXliZVRyYW5zZmVyTWFwcGVkRmlsZURhdGEoKTsKKwogICAgIHZvaWQg Y29weUJ1ZmZlckFuZENsZWFyKGNoYXIqIGRlc3RpbmF0aW9uLCB1bnNpZ25lZCBieXRlc1RvQ29w eSkgY29uc3Q7CiAKICAgICB2b2lkIGFwcGVuZFRvRGF0YUJ1ZmZlcihjb25zdCBjaGFyICosIHVu c2lnbmVkKSBjb25zdDsKQEAgLTE2Nyw2ICsxNzMsOCBAQCBwcml2YXRlOgogICAgIGV4cGxpY2l0 IFNoYXJlZEJ1ZmZlcihTb3VwQnVmZmVyKik7CiAgICAgR1VuaXF1ZVB0cjxTb3VwQnVmZmVyPiBt X3NvdXBCdWZmZXI7CiAjZW5kaWYKKworICAgIE1hcHBlZEZpbGVEYXRhIG1fZmlsZURhdGE7CiB9 OwogCiBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gdXRmOEJ1ZmZlcihjb25zdCBTdHJpbmcmKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKaW5k ZXggZWQ4ZGU0NzE2NDNkMzAwNjI1NzZkOWQyMDA4NGQ0YTU3ZjFkZWUxMy4uOWY2YjZjNGEwYzRj MjFhYjhhOGQwYzY0MmFiNjMzYTE3OTM4YzNmYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL1NoYXJlZEJ1ZmZlckd0ay5jcHAKQEAgLTI4LDcgKzI4LDcgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpj cmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKK1JlZlB0cjxT aGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlRnJvbVJlYWRpbmdGaWxlKGNvbnN0IFN0 cmluZyYgZmlsZVBhdGgpCiB7CiAgICAgaWYgKGZpbGVQYXRoLmlzRW1wdHkoKSkKICAgICAgICAg cmV0dXJuIDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVk QnVmZmVyTWFjLm1tIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbWFjL1NoYXJlZEJ1ZmZlck1h Yy5tbQppbmRleCBlYTQ4MmYwNmYwODE2OGE5YWZkNThjNmQwMGFiNWNmMGIzM2UwNTQ3Li4xYWQy OGFkNzYzZDg4ZGU4NDk1ZTQzM2I0MjhjODRjMGFkZDkzZGZkIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9tYWMvU2hhcmVkQnVmZmVyTWFjLm1tCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL21hYy9TaGFyZWRCdWZmZXJNYWMubW0KQEAgLTEyMiw3ICsxMjIsNyBAQCBS ZXRhaW5QdHI8Q0ZEYXRhUmVmPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZUNGRGF0YSgpCiAgICAgcmV0 dXJuIGFkb3B0Q0YoKENGRGF0YVJlZilhZG9wdE5TKFtbV2ViQ29yZVNoYXJlZEJ1ZmZlckRhdGEg YWxsb2NdIGluaXRXaXRoU2hhcmVkQnVmZmVyRGF0YUJ1ZmZlcjptX2J1ZmZlci5nZXQoKV0pLmxl YWtSZWYoKSk7CiB9CiAKLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNy ZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQYXRoKQorUmVmUHRyPFNo YXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGluZ0ZpbGUoY29uc3QgU3Ry aW5nJiBmaWxlUGF0aCkKIHsKICAgICBOU0RhdGEgKnJlc291cmNlRGF0YSA9IFtOU0RhdGEgZGF0 YVdpdGhDb250ZW50c09mRmlsZTpmaWxlUGF0aF07CiAgICAgaWYgKHJlc291cmNlRGF0YSkgCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZmZXJQT1NJ WC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9wb3NpeC9TaGFyZWRCdWZmZXJQT1NJWC5j cHAKaW5kZXggZTc3YjhlY2YwNmY5YmM5YzBlNWZmYTFiZGEwN2Q4NjIxNDI4NWJkNC4uODYzZGJl MjUzZTVhZjIyMDAzYzdmMGJlZjUzMGFiZmExYTAxYjBkNSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vcG9zaXgvU2hhcmVkQnVmZmVyUE9TSVguY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL3Bvc2l4L1NoYXJlZEJ1ZmZlclBPU0lYLmNwcApAQCAtMzUsNyArMzUs NyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBT aGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpbGVQ YXRoKQorUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVGcm9tUmVhZGlu Z0ZpbGUoY29uc3QgU3RyaW5nJiBmaWxlUGF0aCkKIHsKICAgICBpZiAoZmlsZVBhdGguaXNFbXB0 eSgpKQogICAgICAgICByZXR1cm4gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2lu L1NoYXJlZEJ1ZmZlcldpbi5jcHAKaW5kZXggZjVkZDIyODQ2NDE5YTBmMmQ5Nzg1YjlhNjljZGY5 MDliYzM5MWQ3MC4uMmFhYjNjZDQyZDAyMzE3MDM1N2Q0MDhkNzIxMTJjYzExZTQ4ZjVjYiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKQEAg LTMzLDcgKzMzLDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1QYXNzUmVmUHRyPFNoYXJl ZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3Ry aW5nJiBmaWxlUGF0aCkKK1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRl RnJvbVJlYWRpbmdGaWxlKGNvbnN0IFN0cmluZyYgZmlsZVBhdGgpCiB7CiAgICAgaWYgKGZpbGVQ YXRoLmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9Ub29scy9DaGFu Z2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZjFjYmQyOGFjZWJiM2VkZjUxZWI5ODEyZjE3 ZjRlMzAzYTQwOTA4My4uYjU4MTA3YzM0YWEwYjVhYThmNDQwZDdlYTNkN2M5ZTljYWMzZTQ2YSAx MDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDIzIEBACisyMDE1LTA1LTEyICBZb3Vlbm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYu Y2Fub24uZnI+CisKKyAgICAgICAgU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZp bGUgc2hvdWxkIHVzZSBtYXAgZmlsZSByb3V0aW5lcworICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ0MTkyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFy aW4gQWRsZXIuCisKKyAgICAgICAgQWRkaW5nIFNoYXJlZEJ1ZmZlciBhbmQgRmlsZVN5c3RlbSBV bml0IHRlc3RzIHRvIE1hYyBhbmQgR1RLLCBub3QgeWV0IGZvciBFRkwuCisKKyAgICAgICAgKiBU ZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkv VGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFRlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcDogQWRkZWQuCisgICAgICAgIChU ZXN0V2ViS2l0QVBJOjpGaWxlU3lzdGVtVGVzdDo6dGVtcEZpbGVQYXRoKToKKyAgICAgICAgKFRl c3RXZWJLaXRBUEk6OkZpbGVTeXN0ZW1UZXN0Ojp0ZW1wRW1wdHlGaWxlUGF0aCk6CisgICAgICAg IChUZXN0V2ViS2l0QVBJOjpURVNUX0YpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMv V2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OlNoYXJlZEJ1ZmZlclRlc3Q6OnRlbXBGaWxlUGF0aCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJ OjpTaGFyZWRCdWZmZXJUZXN0Ojp0ZW1wRW1wdHlGaWxlUGF0aCk6CisgICAgICAgIChUZXN0V2Vi S2l0QVBJOjpURVNUX0YpOgorCiAyMDE1LTA1LTExICBEYW4gQmVybnN0ZWluICA8bWl0ekBhcHBs ZS5jb20+CiAKICAgICAgICAgVGVzdCBmb3IgPHJkYXI6Ly9wcm9ibGVtLzIwODc4MDc1PiBUcnlp bmcgdG8gbmF2aWdhdGUgdG8gYW4gaW52YWxpZCBVUkwgbG9hZHMgYWJvdXQ6YmxhbmssIGJ1dCAt W1dLV2ViVmlldyBVUkxdIHJldHVybnMgdGhlIGludmFsaWQgVVJMCmRpZmYgLS1naXQgYS9Ub29s cy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9Q bGF0Zm9ybUdUSy5jbWFrZQppbmRleCAwNmIzMDU3OTE1MTM0OTlkY2M3MzkwNDYyZWViZWU4MzYy ZjVmNTlkLi5jYzQ3ZTA4MzkzNjUwZDQ4MmMwN2Y1MTgxYTg2MDBiYjhmMGIyNjUwIDEwMDY0NAot LS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtR1RLLmNtYWtlCisrKyBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTExLDYgKzExLDcgQEAgc2V0KEZvcndh cmRpbmdIZWFkZXJzRm9yVGVzdFdlYktpdEFQSV9OQU1FIFRlc3RXZWJLaXRBUEktZm9yd2FyZGlu Zy1oZWFkZXJzKQogCiBpbmNsdWRlX2RpcmVjdG9yaWVzKAogICAgICR7Rk9SV0FSRElOR19IRUFE RVJTX0RJUn0KKyAgICAke0ZPUldBUkRJTkdfSEVBREVSU19ESVJ9L0phdmFTY3JpcHRDb3JlCiAg ICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQSS9DL3NvdXAKICAgICAke1dFQktJVDJfRElS fS9VSVByb2Nlc3MvQVBJL0MvZ3RrCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQSS9n dGsKQEAgLTEyMiw2ICsxMjMsOCBAQCBhZGRfZXhlY3V0YWJsZShUZXN0V2ViQ29yZQogICAgICR7 VEVTVFdFQktJVEFQSV9ESVJ9L1Rlc3RzQ29udHJvbGxlci5jcHAKICAgICAke1RFU1RXRUJLSVRB UElfRElSfS9UZXN0cy9XZWJDb3JlL0xheW91dFVuaXQuY3BwCiAgICAgJHtURVNUV0VCS0lUQVBJ X0RJUn0vVGVzdHMvV2ViQ29yZS9VUkwuY3BwCisgICAgJHtURVNUV0VCS0lUQVBJX0RJUn0vVGVz dHMvV2ViQ29yZS9TaGFyZWRCdWZmZXIuY3BwCisgICAgJHtURVNUV0VCS0lUQVBJX0RJUn0vVGVz dHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcAogKQogCiB0YXJnZXRfbGlua19saWJyYXJpZXMoVGVz dFdlYkNvcmUgJHt0ZXN0X3dlYmNvcmVfTElCUkFSSUVTfSkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9v bHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oK aW5kZXggMWY1YWMxNTU4M2FmOWE1N2I0Y2JjYTg4ZmM4YWVlNzk4OGU1OTcyNS4uOWExZjI5ZTQ5 ODFhMjI0MGY1NGJmZWQ2Y2ZkMzgxMTJkYWI1YWViMSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9v bHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oK QEAgLTQ1LDYgKzQ1LDggQEAKIAkJMzdEMzZGMzIxQjAwNERENDAwQkFGNUQ5IC8qIFByb3Zpc2lv bmFsVVJMQ2hhbmdlLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gMzdEMzZGMzExQjAwNERENDAwQkFGNUQ5IC8qIFByb3Zpc2lvbmFsVVJMQ2hhbmdlLm1t ICovOyB9OwogCQkzN0RDNjc5MTE0MEQ3RDc2MDBBQkNDREIgLyogRE9NUmFuZ2VPZlN0cmluZy5o dG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDM3REM2NzhGMTQwRDdEM0EwMEFCQ0NEQiAvKiBET01SYW5nZU9mU3RyaW5nLmh0bWwgKi87IH07 CiAJCTM3RTEwNjRDMTY5NzY4MTgwMEI3OEJEMCAvKiBET01IVE1MVGFibGVDZWxsRWxlbWVudENl bGxBYm92ZS5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDM3RTEwNjRCMTY5NzY3RjcwMEI3OEJEMCAvKiBET01IVE1MVGFibGVDZWxsRWxl bWVudENlbGxBYm92ZS5odG1sICovOyB9OworCQk0MTk3M0I1QjFBRjIyODZBMDA2QzdCMzYgLyog RmlsZVN5c3RlbS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA0MTk3M0I1QTFBRjIyODZBMDA2QzdCMzYgLyogRmlsZVN5c3RlbS5jcHAgKi87IH07CisJ CTQxOTczQjVEMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRCdWZmZXIuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDE5NzNCNUMxQUYyMjg3NTAwNkM3 QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgKi87IH07CiAJCTRCRkRGRkE3MTMxNDc3NkMwMDYxRjI0 QiAvKiBIaXRUZXN0UmVzdWx0Tm9kZUhhbmRsZV9CdW5kbGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEJGREZGQTYxMzE0Nzc2QzAwNjFGMjRCIC8q IEhpdFRlc3RSZXN1bHROb2RlSGFuZGxlX0J1bmRsZS5jcHAgKi87IH07CiAJCTUxMzkzRTIyMTUy Mzk1MkQwMDVGMzlDNSAvKiBET01XaW5kb3dFeHRlbnNpb25CYXNpY19CdW5kbGUuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTEzOTNFMUQxNTIzOTQ0 QTAwNUYzOUM1IC8qIERPTVdpbmRvd0V4dGVuc2lvbkJhc2ljX0J1bmRsZS5jcHAgKi87IH07CiAJ CTUxNDJCMjczMTUxN0M4QzgwMEMzMkIxOSAvKiBDb250ZXh0TWVudUNhbkNvcHlVUkwuaHRtbCBp biBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MTQy QjI3MjE1MTdDODkxMDBDMzJCMTkgLyogQ29udGV4dE1lbnVDYW5Db3B5VVJMLmh0bWwgKi87IH07 CkBAIC00OTcsNiArNDk5LDggQEAKIAkJMzdFMTA2NEExNjk3Njc2NDAwQjc4QkQwIC8qIERPTUhU TUxUYWJsZUNlbGxDZWxsQWJvdmUubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7 IHBhdGggPSBET01IVE1MVGFibGVDZWxsQ2VsbEFib3ZlLm1tOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQkzN0UxMDY0QjE2OTc2N0Y3MDBCNzhCRDAgLyogRE9NSFRNTFRhYmxlQ2VsbEVs ZW1lbnRDZWxsQWJvdmUuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IERPTUhUTUxU YWJsZUNlbGxFbGVtZW50Q2VsbEFib3ZlLmh0bWw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTM3RTM4QzMzMTY5QjdEMDEwMDg0QzI4QyAvKiBXZWJWaWV3RGlkUmVtb3ZlRnJhbWVGcm9t SGllcmFyY2h5Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV2Vi Vmlld0RpZFJlbW92ZUZyYW1lRnJvbUhpZXJhcmNoeS5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJNDE5NzNCNUExQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRmlsZVN5c3RlbS5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTQxOTczQjVDMUFGMjI4NzUwMDZDN0IzNiAvKiBTaGFyZWRC dWZmZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gU2hhcmVkQnVm ZmVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNDQwQTFEMzgxNEEwMTAzQTAw OEE2NkYyIC8qIFVSTC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBV UkwuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0NEE2MjJDMTE0QTBFMkI2MDA0 ODUxNUIgLyogV1RGU3RyaW5nVXRpbGl0aWVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IFdURlN0cmluZ1V0aWxpdGllcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQk0QTQxMEY0QjE5QUY3QkQ2MDAyRUJBQjUgLyogVXNlck1lZGlhLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFVzZXJNZWRpYS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CkBAIC03NjcsNiArNzcxLDcgQEAKIAkJMDhGQjc3OTVGRTg0MTU1REMwMkFBQzA3 IC8qIFNvdXJjZSAqLyA9IHsKIAkJCWlzYSA9IFBCWEdyb3VwOwogCQkJY2hpbGRyZW4gPSAoCisJ CQkJNDRBODJFN0IxOTI1MUIzNTAwQzFDOEM0IC8qIENvY29hICovLAogCQkJCTBGMTM5RTcxMUE0 MjNBMUQwMEY1OTBGNSAvKiBjb2NvYSAqLywKIAkJCQlCQzU3NTk0NDEyNkU3MzNDMDA2RjBGMTIg LyogSW5qZWN0ZWRCdW5kbGUgKi8sCiAJCQkJMkU5NjYwREMxNkMwN0Q3QjAwMzcxQjQyIC8qIGlv cyAqLywKQEAgLTg1OCw3ICs4NjMsOSBAQAogCQkJCTdDQjE4NEM0MUFBM0YyMTAwMDY2RURGRCAv KiBDb250ZW50RXh0ZW5zaW9ucy5jcHAgKi8sCiAJCQkJQ0Q1NDUxRTkxOUU0MUY5RDAwMTY5MzZG IC8qIENTU1BhcnNlci5jcHAgKi8sCiAJCQkJMjZGNkUxRUYxQURDNzQ5QjAwREU2OTZCIC8qIERG QU1pbmltaXplci5jcHAgKi8sCisJCQkJNDE5NzNCNUExQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVT eXN0ZW0uY3BwICovLAogCQkJCTE0NDY0MDEyMTY3QTgzMDUwMDBCRDIxOCAvKiBMYXlvdXRVbml0 LmNwcCAqLywKKwkJCQk0MTk3M0I1QzFBRjIyODc1MDA2QzdCMzYgLyogU2hhcmVkQnVmZmVyLmNw cCAqLywKIAkJCQlDREMyQzcxNDE3OTcwODlEMDBFNjI3RkIgLyogVGltZVJhbmdlcy5jcHAgKi8s CiAJCQkJNDQwQTFEMzgxNEEwMTAzQTAwOEE2NkYyIC8qIFVSTC5jcHAgKi8sCiAJCQkpOwpAQCAt ODcwLDcgKzg3Nyw4IEBACiAJCQljaGlsZHJlbiA9ICgKIAkJCQk5M0E3RUIzQzE4RkE2M0E0MDA5 RTc2NzAgLyogVVJMRXh0cmFzLm1tICovLAogCQkJKTsKLQkJCXBhdGggPSBDb2NvYTsKKwkJCW5h bWUgPSBDb2NvYTsKKwkJCXBhdGggPSBUZXN0cy9Db2NvYTsKIAkJCXNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7CiAJCX07CiAJCTc1NjA5MTc2MTkyNTlDNTkwMDlFRjA2RSAvKiBpb3MgKi8gPSB7CkBA IC0xMTYwLDcgKzExNjgsNiBAQAogCQlCQ0I5RUI2NjExMjM2NkQ4MDBBMTM3RTAgLyogVGVzdHMg Ki8gPSB7CiAJCQlpc2EgPSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAotCQkJCTQ0QTgyRTdC MTkyNTFCMzUwMEMxQzhDNCAvKiBDb2NvYSAqLywKIAkJCQk3NTYwOTE3NjE5MjU5QzU5MDA5RUYw NkUgLyogaW9zICovLAogCQkJCUZFMjE3RUNCMTY0MEE1NEEwMDUyOTg4QiAvKiBKYXZhU2NyaXB0 Q29yZSAqLywKIAkJCQlDMDdFNkNBRDEzRkQ2NzY1MDAzOEIyMkIgLyogbWFjICovLApAQCAtMTU5 NSw4ICsxNjAyLDEwIEBACiAJCQkJMkQxRkUwQjAxQUQ0NjVDMTAwNkNEOUU2IC8qIEZpeGVkTGF5 b3V0U2l6ZS5tbSBpbiBTb3VyY2VzICovLAogCQkJCTFDQjlCQzM4MUE2NzQ4MjMwMEZFNTY3OCAv KiBXZWFrUHRyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTJFNzc2NUNEMTZDNEQ4MEEwMEJBMkJC MSAvKiBtYWluSU9TLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJNDE5NzNCNUQxQUYyMjg3NTAwNkM3 QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk3QUE2QTE1MjFBQUMw QjMxMDAyQjJFRDMgLyogV29ya1F1ZXVlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTJFNzc2NUNG MTZDNEQ4MTEwMEJBMkJCMSAvKiBtYWluTWFjLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJNDE5NzNC NUIxQUYyMjg2QTAwNkM3QjM2IC8qIEZpbGVTeXN0ZW0uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ N0E1NjIzMTExQUQ1QUYzRTAwOTZCOTIwIC8qIE1lbnVUeXBlc0Zvck1vdXNlRXZlbnRzLmNwcCBp biBTb3VyY2VzICovLAogCQkJCTI2RjZFMUYwMUFEQzc0OUIwMERFNjk2QiAvKiBERkFNaW5pbWl6 ZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJN0E5OUQ5OTQxQUQ0QTI5RDAwMzczMTQxIC8qIE1l bnVUeXBlc0Zvck1vdXNlRXZlbnRzLm1tIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmlsZVN5c3RlbS5jcHAgYi9Ub29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYkNvcmUvRmlsZVN5c3RlbS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmIyM2E0 YjdjYzM1YTA0NGUxMTI1NmZlNWZiZDZmYzgxZTA2MzM4OAotLS0gL2Rldi9udWxsCisrKyBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9GaWxlU3lzdGVtLmNwcApAQCAtMCwwICsx LDk2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE1IENhbm9uIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgor ICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAq IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiVGVz dC5oIgorI2luY2x1ZGUgPFdlYkNvcmUvRmlsZVN5c3RlbS5oPgorI2luY2x1ZGUgPHd0Zi9NYWlu VGhyZWFkLmg+CisjaW5jbHVkZSA8d3RmL1N0cmluZ0V4dHJhcy5oPgorCit1c2luZyBuYW1lc3Bh Y2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCitjb25zdCBjaGFyKiBG aWxlU3lzdGVtVGVzdERhdGEgPSAiVGhpcyBpcyBhIHRlc3QiOworCisvLyBGSVhNRTogUmVmYWN0 b3IgRmlsZVN5c3RlbVRlc3QgYW5kIFNoYXJlZEJ1ZmZlclRlc3QgYXMgYSBzaW5nbGUgY2xhc3Mu CitjbGFzcyBGaWxlU3lzdGVtVGVzdCA6IHB1YmxpYyB0ZXN0aW5nOjpUZXN0IHsKK3B1YmxpYzoK KyAgICB2aXJ0dWFsIHZvaWQgU2V0VXAoKSBvdmVycmlkZQorICAgIHsKKyAgICAgICAgV1RGOjpp bml0aWFsaXplTWFpblRocmVhZCgpOworICAgICAgICAKKyAgICAgICAgLy8gY3JlYXRlIHRlbXAg ZmlsZQorICAgICAgICBQbGF0Zm9ybUZpbGVIYW5kbGUgaGFuZGxlOworICAgICAgICBtX3RlbXBG aWxlUGF0aCA9IG9wZW5UZW1wb3JhcnlGaWxlKCJ0ZW1wVGVzdEZpbGUiLCBoYW5kbGUpOworICAg ICAgICB3cml0ZVRvRmlsZShoYW5kbGUsIEZpbGVTeXN0ZW1UZXN0RGF0YSwgc3RybGVuKEZpbGVT eXN0ZW1UZXN0RGF0YSkpOworICAgICAgICBjbG9zZUZpbGUoaGFuZGxlKTsgCisKKyAgICAgICAg bV90ZW1wRW1wdHlGaWxlUGF0aCA9IG9wZW5UZW1wb3JhcnlGaWxlKCJ0ZW1wRW1wdHlUZXN0Rmls ZSIsIGhhbmRsZSk7CisgICAgICAgIGNsb3NlRmlsZShoYW5kbGUpOyAKKyAgICB9CisKKyAgICB2 aXJ0dWFsIHZvaWQgVGVhckRvd24oKSBvdmVycmlkZQorICAgIHsKKyAgICAgICAgZGVsZXRlRmls ZShtX3RlbXBGaWxlUGF0aCk7CisgICAgICAgIGRlbGV0ZUZpbGUobV90ZW1wRW1wdHlGaWxlUGF0 aCk7CisgICAgfQorCisgICAgY29uc3QgU3RyaW5nJiB0ZW1wRmlsZVBhdGgoKSB7IHJldHVybiBt X3RlbXBGaWxlUGF0aDsgfQorICAgIGNvbnN0IFN0cmluZyYgdGVtcEVtcHR5RmlsZVBhdGgoKSB7 IHJldHVybiBtX3RlbXBFbXB0eUZpbGVQYXRoOyB9CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIG1f dGVtcEZpbGVQYXRoOworICAgIFN0cmluZyBtX3RlbXBFbXB0eUZpbGVQYXRoOworfTsKKworVEVT VF9GKEZpbGVTeXN0ZW1UZXN0LCBNYXBwaW5nTWlzc2luZ0ZpbGUpCit7CisgICAgYm9vbCBzdWNj ZXNzOworICAgIE1hcHBlZEZpbGVEYXRhIG1hcHBlZEZpbGVEYXRhKFN0cmluZygibm90X2V4aXN0 aW5nX2ZpbGUiKSwgc3VjY2Vzcyk7CisgICAgRVhQRUNUX0ZBTFNFKHN1Y2Nlc3MpOworICAgIEVY UEVDVF9UUlVFKCFtYXBwZWRGaWxlRGF0YSk7Cit9CisKK1RFU1RfRihGaWxlU3lzdGVtVGVzdCwg TWFwcGluZ0V4aXN0aW5nRmlsZSkKK3sKKyAgICBib29sIHN1Y2Nlc3M7CisgICAgTWFwcGVkRmls ZURhdGEgbWFwcGVkRmlsZURhdGEodGVtcEZpbGVQYXRoKCksIHN1Y2Nlc3MpOworICAgIEVYUEVD VF9UUlVFKHN1Y2Nlc3MpOworICAgIEVYUEVDVF9UUlVFKCEhbWFwcGVkRmlsZURhdGEpOworICAg IEVYUEVDVF9UUlVFKG1hcHBlZEZpbGVEYXRhLnNpemUoKSA9PSBzdHJsZW4oRmlsZVN5c3RlbVRl c3REYXRhKSk7CisgICAgRVhQRUNUX1RSVUUoc3RybnN0cihGaWxlU3lzdGVtVGVzdERhdGEsIHN0 YXRpY19jYXN0PGNvbnN0IGNoYXIqPihtYXBwZWRGaWxlRGF0YS5kYXRhKCkpLCBtYXBwZWRGaWxl RGF0YS5zaXplKCkpKTsKK30KKworVEVTVF9GKEZpbGVTeXN0ZW1UZXN0LCBNYXBwaW5nRXhpc3Rp bmdFbXB0eUZpbGUpCit7CisgICAgYm9vbCBzdWNjZXNzOworICAgIE1hcHBlZEZpbGVEYXRhIG1h cHBlZEZpbGVEYXRhKHRlbXBFbXB0eUZpbGVQYXRoKCksIHN1Y2Nlc3MpOworICAgIEVYUEVDVF9U UlVFKHN1Y2Nlc3MpOworICAgIEVYUEVDVF9UUlVFKCFtYXBwZWRGaWxlRGF0YSk7Cit9CisKK30K ZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFyZWRCdWZm ZXIuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJDb3JlL1NoYXJlZEJ1ZmZlci5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMTllOTBiNmQwOGUxMjZmY2ZmYjk1ODdiMDJiNzcyODYxMzJhYmE1OAot LS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViQ29yZS9TaGFy ZWRCdWZmZXIuY3BwCkBAIC0wLDAgKzEsMTE5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE1 IENhbm9uIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBB UyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJV VE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G CisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNv bmZpZy5oIgorCisjaW5jbHVkZSAiVGVzdC5oIgorI2luY2x1ZGUgPFdlYkNvcmUvU2hhcmVkQnVm ZmVyLmg+CisjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KKyNpbmNsdWRlIDx3dGYvU3RyaW5n RXh0cmFzLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCituYW1lc3BhY2UgVGVzdFdl YktpdEFQSSB7CisKK2NvbnN0IGNoYXIqIFNoYXJlZEJ1ZmZlclRlc3REYXRhID0gIlRoaXMgaXMg YSB0ZXN0IjsKKworY2xhc3MgU2hhcmVkQnVmZmVyVGVzdCA6IHB1YmxpYyB0ZXN0aW5nOjpUZXN0 IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgU2V0VXAoKSBvdmVycmlkZQorICAgIHsKKyAg ICAgICAgV1RGOjppbml0aWFsaXplTWFpblRocmVhZCgpOworICAgICAgICAKKyAgICAgICAgLy8g Y3JlYXRlIHRlbXAgZmlsZQorICAgICAgICBQbGF0Zm9ybUZpbGVIYW5kbGUgaGFuZGxlOworICAg ICAgICBtX3RlbXBGaWxlUGF0aCA9IG9wZW5UZW1wb3JhcnlGaWxlKCJ0ZW1wVGVzdEZpbGUiLCBo YW5kbGUpOworICAgICAgICB3cml0ZVRvRmlsZShoYW5kbGUsIFNoYXJlZEJ1ZmZlclRlc3REYXRh LCBzdHJsZW4oU2hhcmVkQnVmZmVyVGVzdERhdGEpKTsKKyAgICAgICAgY2xvc2VGaWxlKGhhbmRs ZSk7IAorCisgICAgICAgIG1fdGVtcEVtcHR5RmlsZVBhdGggPSBvcGVuVGVtcG9yYXJ5RmlsZSgi dGVtcEVtcHR5VGVzdEZpbGUiLCBoYW5kbGUpOworICAgICAgICBjbG9zZUZpbGUoaGFuZGxlKTsg CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIFRlYXJEb3duKCkgb3ZlcnJpZGUKKyAgICB7Cisg ICAgICAgIGRlbGV0ZUZpbGUobV90ZW1wRmlsZVBhdGgpOworICAgICAgICBkZWxldGVGaWxlKG1f dGVtcEVtcHR5RmlsZVBhdGgpOworICAgIH0KKworICAgIGNvbnN0IFN0cmluZyYgdGVtcEZpbGVQ YXRoKCkgeyByZXR1cm4gbV90ZW1wRmlsZVBhdGg7IH0KKyAgICBjb25zdCBTdHJpbmcmIHRlbXBF bXB0eUZpbGVQYXRoKCkgeyByZXR1cm4gbV90ZW1wRW1wdHlGaWxlUGF0aDsgfQorCitwcml2YXRl OgorICAgIFN0cmluZyBtX3RlbXBGaWxlUGF0aDsKKyAgICBTdHJpbmcgbV90ZW1wRW1wdHlGaWxl UGF0aDsKK307CisKK1RFU1RfRihTaGFyZWRCdWZmZXJUZXN0LCBjcmVhdGVXaXRoQ29udGVudHNP Zk1pc3NpbmdGaWxlKQoreworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNoYXJl ZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKFN0cmluZygibm90X2V4aXN0aW5nX2Zp bGUiKSk7CisgICAgQVNTRVJUX05VTEwoYnVmZmVyKTsKK30KKworVEVTVF9GKFNoYXJlZEJ1ZmZl clRlc3QsIGNyZWF0ZVdpdGhDb250ZW50c09mRXhpc3RpbmdGaWxlKQoreworICAgIFJlZlB0cjxT aGFyZWRCdWZmZXI+IGJ1ZmZlciA9IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZG aWxlKHRlbXBGaWxlUGF0aCgpKTsKKyAgICBBU1NFUlRfTk9UX05VTEwoYnVmZmVyKTsKKyAgICBF WFBFQ1RfVFJVRShidWZmZXItPnNpemUoKSA9PSBzdHJsZW4oU2hhcmVkQnVmZmVyVGVzdERhdGEp KTsKKyAgICBFWFBFQ1RfVFJVRShTdHJpbmcoU2hhcmVkQnVmZmVyVGVzdERhdGEpID09IFN0cmlu ZyhidWZmZXItPmRhdGEoKSwgYnVmZmVyLT5zaXplKCkpKTsKK30KKworVEVTVF9GKFNoYXJlZEJ1 ZmZlclRlc3QsIGNyZWF0ZVdpdGhDb250ZW50c09mRXhpc3RpbmdFbXB0eUZpbGUpCit7CisgICAg UmVmUHRyPFNoYXJlZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29u dGVudHNPZkZpbGUodGVtcEVtcHR5RmlsZVBhdGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1 ZmZlcik7CisgICAgRVhQRUNUX1RSVUUoYnVmZmVyLT5pc0VtcHR5KCkpOworfQorCitURVNUX0Yo U2hhcmVkQnVmZmVyVGVzdCwgY29weUJ1ZmZlckNyZWF0ZWRXaXRoQ29udGVudHNPZkV4aXN0aW5n RmlsZSkKK3sKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6 OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSh0ZW1wRmlsZVBhdGgoKSk7CisgICAgQVNTRVJUX05P VF9OVUxMKGJ1ZmZlcik7CisgICAgUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gY29weSA9IGJ1ZmZlci0+ Y29weSgpOworICAgIEVYUEVDVF9UUlVFKGJ1ZmZlci0+c2l6ZSgpID09IGNvcHktPnNpemUoKSk7 CisgICAgRVhQRUNUX1RSVUUoc3RybnN0cihidWZmZXItPmRhdGEoKSwgY29weS0+ZGF0YSgpLCBi dWZmZXItPnNpemUoKSkpOworfQorCitURVNUX0YoU2hhcmVkQnVmZmVyVGVzdCwgY2xlYXJCdWZm ZXJDcmVhdGVkV2l0aENvbnRlbnRzT2ZFeGlzdGluZ0ZpbGUpCit7CisgICAgUmVmUHRyPFNoYXJl ZEJ1ZmZlcj4gYnVmZmVyID0gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUo dGVtcEZpbGVQYXRoKCkpOworICAgIEFTU0VSVF9OT1RfTlVMTChidWZmZXIpOworICAgIGJ1ZmZl ci0+Y2xlYXIoKTsKKyAgICBFWFBFQ1RfVFJVRSghYnVmZmVyLT5zaXplKCkpOworICAgIEVYUEVD VF9UUlVFKCFidWZmZXItPmRhdGEoKSk7Cit9CisKKworVEVTVF9GKFNoYXJlZEJ1ZmZlclRlc3Qs IGFwcGVuZEJ1ZmZlckNyZWF0ZWRXaXRoQ29udGVudHNPZkV4aXN0aW5nRmlsZSkKK3sKKyAgICBS ZWZQdHI8U2hhcmVkQnVmZmVyPiBidWZmZXIgPSBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250 ZW50c09mRmlsZSh0ZW1wRmlsZVBhdGgoKSk7CisgICAgQVNTRVJUX05PVF9OVUxMKGJ1ZmZlcik7 CisgICAgYnVmZmVyLT5hcHBlbmQoImEiLCAxKTsKKyAgICBFWFBFQ1RfVFJVRShidWZmZXItPnNp emUoKSA9PSAoc3RybGVuKFNoYXJlZEJ1ZmZlclRlc3REYXRhKSArIDEpKTsKKyAgICBFWFBFQ1Rf VFJVRShzdHJuc3RyKGJ1ZmZlci0+ZGF0YSgpLCBTaGFyZWRCdWZmZXJUZXN0RGF0YSwgc3RybGVu KFNoYXJlZEJ1ZmZlclRlc3REYXRhKSkpOworICAgIEVYUEVDVF9FUSgnYScsIGJ1ZmZlci0+ZGF0 YSgpW3N0cmxlbihTaGFyZWRCdWZmZXJUZXN0RGF0YSldKTsKK30KKworfQo=