24540 2009-03-11 19:38:25 -0700 Fix for missing mmap features in Symbian 2009-07-23 07:29:00 -0700 1 1 1 Unclassified WebKit JavaScriptCore 528+ (Nightly build) S60 Hardware S60 3rd edition RESOLVED FIXED P2 Normal --- 27065 0 norbert.leser webkit-unassigned hausmann laszlo.gombos oldest_to_newest 113304 0 norbert.leser 2009-03-11 19:38:25 -0700 This is a proposed fix conditionally for PLATFORM(SYMBIAN), as a workaround for missing support for the MAP_ANON property flag in mmap. It utilizes fastMalloc and Symbian specific memory allocation features. See attached patch. 113307 1 28516 norbert.leser 2009-03-11 19:39:13 -0700 Created attachment 28516 Proposed fix for bug 24540 113309 2 28516 mrowe 2009-03-11 19:51:30 -0700 Comment on attachment 28516 Proposed fix for bug 24540 If every location where mmap is used needs to be if'd, it may make more sense to not set HAVE_MMAP to true for Symbian. Alternatively, you may want to implement a wrapper around mmap / munmap that uses some other mechanism for MAP_ANON and calls through to the system mmap for other flags. This would avoid having to sprinkle #if's through so much code. > Index: JavaScriptCore/interpreter/RegisterFile.cpp > =================================================================== > --- JavaScriptCore/interpreter/RegisterFile.cpp (revision 41604) > +++ JavaScriptCore/interpreter/RegisterFile.cpp (working copy) > @@ -34,7 +34,11 @@ namespace JSC { > RegisterFile::~RegisterFile() > { > #if HAVE(MMAP) > - munmap(m_buffer, ((m_max - m_start) + m_maxGlobals) * sizeof(Register)); > + #if PLATFORM(SYMBIAN) > + fastFree(m_bufferSymbian); > + #else > + munmap(m_buffer, ((m_max - m_start) + m_maxGlobals) * sizeof(Register)); > + #endif > #elif HAVE(VIRTUALALLOC) > VirtualFree(m_buffer, 0, MEM_RELEASE); > #else It doesn't make sense to put this inside the HAVE(MMAP) block given it doesn't even use mmap. We also don't indent code in this manner. > #if HAVE(MMAP) > +#if PLATFORM(SYMBIAN) > + // Symbian's OpenC doesn't support MAP_ANON for mmap. > + // Need to hack with fastMalloc. > + // FIXME --nl-- Not sure, if we really need memory alignment here, > + // but it's safe this way and only wastes very little memory. > + static size_t pagesize = getpagesize(); > + size_t extra = 0; > + if (allocationSize > pagesize) { > + extra = allocationSize - pagesize; > + } > + m_bufferSymbian = fastMalloc(bufferLength + extra); > + > + // Align memory at allocationSize boundary > + uintptr_t ptr = reinterpret_cast<uintptr_t>(m_bufferSymbian); > + size_t adjust = 0; > + if ((ptr & (allocationSizeMask)) != 0) { > + adjust = allocationSize - (ptr & (allocationSizeMask)); > + } > + > + if (!m_bufferSymbian || adjust > (bufferLength + extra)) { > + fprintf(stderr, "Could not allocate register file: %d\n", errno); > + CRASH(); > + } > + ptr += adjust; > + m_buffer = reinterpret_cast<Register*>(ptr); > +#else > m_buffer = static_cast<Register*>(mmap(0, bufferLength, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0)); > if (m_buffer == MAP_FAILED) { > fprintf(stderr, "Could not allocate register file: %d\n", errno); > CRASH(); > } > +#endif // PLATFORM(SYMBIAN) It doesn't make sense to put this inside the HAVE(MMAP) block given it doesn't even use mmap. It also makes it hard to see the common implementation of the function given the mass of code related to a single obscure platform. > Index: JavaScriptCore/jit/ExecutableAllocatorPosix.cpp > =================================================================== > --- JavaScriptCore/jit/ExecutableAllocatorPosix.cpp (revision 41604) > +++ JavaScriptCore/jit/ExecutableAllocatorPosix.cpp (working copy) > @@ -41,14 +41,24 @@ void ExecutableAllocator::intializePageS > > ExecutablePool::Allocation ExecutablePool::systemAlloc(size_t n) > { > +#if PLATFORM(SYMBIAN) > + // Symbian's OpenC doesn't support MAP_ANON for mmap. > + // Need to hack with fastMalloc. > + ExecutablePool::Allocation alloc = {reinterpret_cast<char*>(fastMalloc(n)), n}; > +#else > ExecutablePool::Allocation alloc = {reinterpret_cast<char*>(mmap(NULL, n, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANON, -1, 0)), n}; > +#endif > return alloc; > } > > void ExecutablePool::systemRelease(const ExecutablePool::Allocation& alloc) > { > +#if PLATFORM(SYMBIAN) > + fastFree(reinterpret_cast<void*>alloc.pages); > +#else > int result = munmap(alloc.pages, alloc.size); > ASSERT_UNUSED(result, !result); > +#endif > } If you're not going to use the POSIX allocator on Symbian then you should add a new implementation of the ExecutablePool interface for your platform rather than #if'ing the POSIX implementation. > Index: JavaScriptCore/runtime/Collector.cpp > =================================================================== > --- JavaScriptCore/runtime/Collector.cpp (revision 41604) > +++ JavaScriptCore/runtime/Collector.cpp (working copy) I'm skipping over the Collector.cpp changes as I'm not particularly familiar this code. > Index: JavaScriptCore/runtime/Collector.h > =================================================================== > --- JavaScriptCore/runtime/Collector.h (revision 41604) > +++ JavaScriptCore/runtime/Collector.h (working copy) > @@ -93,6 +93,7 @@ namespace JSC { > size_t size; > size_t free; > }; > + > Statistics statistics() const; > > void setGCProtectNeedsLocking(); Seems superfluous. > Index: JavaScriptCore/wtf/TCSystemAlloc.cpp > =================================================================== > --- JavaScriptCore/wtf/TCSystemAlloc.cpp (revision 41604) > +++ JavaScriptCore/wtf/TCSystemAlloc.cpp (working copy) > @@ -169,6 +169,27 @@ static void* TryMmap(size_t size, size_t > if (alignment > pagesize) { > extra = alignment - pagesize; > } > +#if PLATFORM(SYMBIAN) > + // Symbian's OpenC doesn't support MAP_ANON for mmap. > + // Need to hack with fastMalloc(). > + // FIXME: The way we adjust for memory alignment > + // causes a small memory leak of returned result ptr > + // (The adjust size won't be free'd). > + // However, this function is currently not called from anywhere ?! > + void* result = fastMalloc(size + extra); > + > + // Adjust the return memory so it is aligned > + uintptr_t ptr = reinterpret_cast<uintptr_t>(result); > + size_t adjust = 0; > + if ((ptr & (alignment - 1)) != 0) { > + adjust = alignment - (ptr & (alignment - 1)); > + } > + > + if (!result || adjust > (size + extra)) { > + fprintf(stderr, "Could not allocate register file: %d\n", errno); > + CRASH(); > + } > +#else > void* result = mmap(NULL, size + extra, > PROT_READ | PROT_WRITE, > MAP_PRIVATE|MAP_ANONYMOUS, > @@ -192,6 +213,7 @@ static void* TryMmap(size_t size, size_t > if (adjust < extra) { > munmap(reinterpret_cast<void*>(ptr + adjust + size), extra - adjust); > } > +#endif /* PLATFORM(SYMBIAN) */ > > ptr += adjust; > return reinterpret_cast<void*>(ptr); This code seems totally wrong. You can't call fastMalloc from here! TryMmap is called from TCMalloc_SystemAlloc to allocate memory. TCMalloc_SystemAlloc is called by TCMalloc to request more memory from the system. TCMalloc is what implements fastMalloc. So this code attempts to use TCMalloc to allocate memory for TCMalloc.... And again, please include a real name rather than "Nokia User" in your changelogs. 114160 3 28716 norbert.leser 2009-03-17 19:17:54 -0700 Created attachment 28716 Updated patch for bug 24540 I implemented the changes as suggested by Mark Rowe in his review. In particular: - The PLATFORM(SYMBIAN) conditional changes are now outside the HAVE(MMAP)blocks - I created a new ExecutableAllocatorSymbian.cpp instead of embedding the symbian changes within ExecutableAllocatorPosix.cpp - I removed the patch for TCSystemAlloc. According to the processing logic, it is sufficient to utilize the sbrk feature (SBRK is already set true for Symbian anyway). 122099 4 28716 mrowe 2009-05-20 01:18:11 -0700 Comment on attachment 28716 Updated patch for bug 24540 I'm going to say r- again as the patch looks like it won't compile, and has a number of more minor issues. I'd also prefer that the change were less invasive / better factored so the #if PLATFORM(SYMBIAN) code can be kept to a minimum, or at least following our typical pattern of putting such platform-specific code in separate implementation files. WebCore has better examples of this practice than JavaScriptCore at present, but I think it would be good to apply here too. > @@ -124,7 +128,28 @@ > , m_globalObject(0) > { > size_t bufferLength = (capacity + maxGlobals) * sizeof(Register); > -#if HAVE(MMAP) > +#if PLATFORM(SYMBIAN) > + // Symbian's OpenC doesn't support MAP_ANON for mmap. > + // Need to hack with fastMalloc. > + // We may not really need memory alignment on page boundary (4k), > + // but it's safe this way, with very little overhead. > + static size_t pagesize = getpagesize(); > + m_bufferSymbian = fastMalloc(bufferLength + pagesize); > + > + // Align memory at allocationSize boundary > + uintptr_t ptr = reinterpret_cast<uintptr_t>(m_bufferSymbian); > + size_t adjust = 0; > + if ((ptr & (pagesize - 1)) != 0) { > + adjust = pagesize - (ptr & (pagesize - 1)); > + } > + > + if (!m_bufferSymbian || adjust > pagesize || adjust < 0) { > + fprintf(stderr, "Could not allocate register file: %d\n", errno); > + CRASH(); > + } > + ptr += adjust; > + m_buffer = reinterpret_cast<Register*>(ptr); > +#elif HAVE(MMAP) Can we factor this in a way that doesn't require putting 20 lines of Symbian-specific code in this method? Putting code related to such a niche platform first in the function is also a little obnoxious. > m_buffer = static_cast<Register*>(mmap(0, bufferLength, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0)); > if (m_buffer == MAP_FAILED) { > fprintf(stderr, "Could not allocate register file: %d\n", errno); > @@ -207,6 +232,9 @@ > #if HAVE(VIRTUALALLOC) > Register* m_maxCommitted; > #endif > +#if PLATFORM(SYMBIAN) > + void* m_bufferSymbian; > +#endif This variable name doesn't describe what the variable represents. The fact it is Symbian-specific is obvious from the fact it's declared in PLATFORM(SYMBIAN) block, so doesn't need to be mentioned in the name. > +#include "config.h" > + > +#include "ExecutableAllocator.h" There shouldn't be a blank line between these two #include's. > + > +#if ENABLE(ASSEMBLER) > + > +#include <sys/mman.h> > +#include <unistd.h> > + > +namespace JSC { > + > +void ExecutableAllocator::intializePageSize() > +{ > + ExecutableAllocator::pageSize = getpagesize(); > +} > + > +ExecutablePool::Allocation ExecutablePool::systemAlloc(size_t n) > +{ > + // Symbian's OpenC doesn't support MAP_ANON for mmap. > + // Need to hack with fastMalloc. > + ExecutablePool::Allocation alloc = {reinterpret_cast<char*>(fastMalloc(n)), n}; > + return alloc; > +} > + > +void ExecutablePool::systemRelease(const ExecutablePool::Allocation& alloc) > +{ > + fastFree(reinterpret_cast<void*>alloc.pages); > +} > + > +} > + > +#endif // HAVE(ASSEMBLER) Does this code even compile? The systemRelease method seems particular suspicious. > @@ -87,6 +92,11 @@ > // a PIC branch in Mach-O binaries, see <rdar://problem/5971391>. > #define MIN_ARRAY_SIZE (static_cast<size_t>(14)) > > +#if PLATFORM(SYMBIAN) > + const size_t MAX_NUM_BLOCKS = 128; // Max size of collector heap set to 8 MB > + static RHeap* userChunk = NULL; > +#endif > + We don't typically indent in this manner. > static void freeHeap(CollectorHeap*); > > #if ENABLE(JSC_MULTIPLE_THREADS) > @@ -128,6 +138,27 @@ > { > ASSERT(globalData); > > +#if PLATFORM(SYMBIAN) > + // Symbian OpenC supports mmap but currently not the MAP_ANON flag. > + // Using fastMalloc() does not properly align blocks on 64k boundaries > + // and previous implementation was flawed/incomplete. > + // UserHeap::ChunkHeap allows allocation of continuous memory and specification > + // of alignment value for (symbian) cells within that heap. > + // > + // Clarification and mapping of terminology: > + // RHeap (created by UserHeap::ChunkHeap below) is continuos memory chunk, > + // which can dynamically grow up to 8 MB, > + // that holds all CollectorBlocks of this session (static). > + // Each symbian cell within RHeap maps to a 64kb aligned CollectorBlock. > + // JSCell objects are maintained as usual within CollectorBlocks. > + if (NULL == userChunk) { > + userChunk = UserHeap::ChunkHeap (NULL, 0, MAX_NUM_BLOCKS * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE); > + if (NULL == userChunk) { > + CRASH(); > + } > + } > +#endif // PLATFORM(SYMBIAN) > + > memset(&primaryHeap, 0, sizeof(CollectorHeap)); > memset(&numberHeap, 0, sizeof(CollectorHeap)); > } > @@ -184,10 +215,18 @@ Besides the coding style issues here (explicit comparisons with NULL, braces around one-line if statements, use of NULL where we prefer 0, and whitespace between function name and arguments), it's rather horrible to have a huge chunk of #if'd code in this otherwise platform-independent method. It would be preferable to factor this in some manner that avoids this. The use of a static in this code doesn't seem thread-safe either. > vm_address_t address = 0; > // FIXME: tag the region as a JavaScriptCore heap when we get a registered VM tag: <rdar://problem/6054788>. > vm_map(current_task(), &address, BLOCK_SIZE, BLOCK_OFFSET_MASK, VM_FLAGS_ANYWHERE, MEMORY_OBJECT_NULL, 0, FALSE, VM_PROT_DEFAULT, VM_PROT_DEFAULT, VM_INHERIT_DEFAULT); > + > #elif PLATFORM(SYMBIAN) > - // no memory map in symbian, need to hack with fastMalloc > - void* address = fastMalloc(BLOCK_SIZE); > + > + // Allocate a 64 kb aligned CollectorBlock > + unsigned char* mask = (unsigned char*)userChunk->Alloc(BLOCK_SIZE); > + if (NULL == mask) { > + CRASH(); > + } > + uintptr_t address = reinterpret_cast<uintptr_t>(mask); > + > memset(reinterpret_cast<void*>(address), 0, BLOCK_SIZE); > + > #elif PLATFORM(WIN_OS) > // windows virtual address granularity is naturally 64k > LPVOID address = VirtualAlloc(NULL, BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); > @@ -231,7 +270,7 @@ > #if PLATFORM(DARWIN) > vm_deallocate(current_task(), reinterpret_cast<vm_address_t>(block), BLOCK_SIZE); > #elif PLATFORM(SYMBIAN) > - fastFree(block); > + userChunk->Free(reinterpret_cast<TAny *>(block)); > #elif PLATFORM(WIN_OS) > VirtualFree(block, 0, MEM_RELEASE); > #elif HAVE(POSIX_MEMALIGN) > @@ -395,6 +434,16 @@ There are a few coding style issues here. The use of C-style casts, braces around one-line if statements, explicit comparisons with NULL and whitespace before the * in type names are ones that jump out at me. > +#elif PLATFORM(SYMBIAN) > + // Needs to be positioned before other platforms to avoid potential ambiguities > + static void* stackBase = 0; > + if (stackBase == 0) { > + TThreadStackInfo info; > + RThread thread; > + thread.StackInfo(info); > + stackBase = (void*)info.iBase; > + } > + return (void*)stackBase; > #elif PLATFORM(WIN_OS) && PLATFORM(X86) && COMPILER(MSVC) > // offset 0x18 from the FS segment register gives a pointer to > // the thread information block for the current thread > @@ -446,15 +495,6 @@ > stackThread = thread; > } > return static_cast<char*>(stackBase) + stackSize; > -#elif PLATFORM(SYMBIAN) > - static void* stackBase = 0; > - if (stackBase == 0) { > - TThreadStackInfo info; > - RThread thread; > - thread.StackInfo(info); > - stackBase = (void*)info.iBase; > - } > - return (void*)stackBase; > #else > #error Need a way to get the stack base on this platform > #endif Why does this code need to move? The ChangeLog doesn't mention it at all. 130324 5 32409 norbert.leser 2009-07-07 18:26:23 -0700 Created attachment 32409 Update 2 of patch file for bug 24540 Attached patch contains cleaned-up code for collector.cpp, according to suggestions from Mark Rowe in comment #4. For simplicity, I separated the change requests for RegisterFile and ExecutableAllocator from this bug and will submit those independently. 133270 6 32409 eric 2009-07-20 15:32:33 -0700 Comment on attachment 32409 Update 2 of patch file for bug 24540 Can this be tested by layout tests? (Ones which crash perhaps?) 134093 7 32409 hausmann 2009-07-23 07:25:01 -0700 Comment on attachment 32409 Update 2 of patch file for bug 24540 > +#if PLATFORM(SYMBIAN) > + const size_t MAX_NUM_BLOCKS = 256; // Max size of collector heap set to 16 MB > + static RHeap* userChunk = NULL; > +#endif > + This should not be indented and 0 instead of NULL should be used, as Mark points out. That's a really simple and minor issue that I can fix while landing. The rest looks good to me. 134094 8 hausmann 2009-07-23 07:29:00 -0700 Landed in r46266 28516 2009-03-11 19:39:13 -0700 2009-03-17 19:17:54 -0700 Proposed fix for bug 24540 patch_fix14.txt text/plain 12073 norbert.leser SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDQxNjA0KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjYgQEAKKzIwMDktMDMtMTEgIE5va2lhIFVz ZXIgIDxub3JiZXJ0Lmxlc2VyQG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBcHBsaWVkIGZpeGVzIGNvbmRpdGlvbmFsIHRvIFBMQVRG T1JNKFNZTUJJQU4pLAorICAgICAgICBkdWUgdG8gbWlzc2luZyBzdXBwb3J0IGZvciBNQVBfQU5P TiBwcm9wZXJ0eSBmb3IgbW1hcC4KKworICAgICAgICAqIGludGVycHJldGVyL1JlZ2lzdGVyRmls ZS5jcHA6CisgICAgICAgIChKU0M6OlJlZ2lzdGVyRmlsZTo6flJlZ2lzdGVyRmlsZSk6CisgICAg ICAgICogaW50ZXJwcmV0ZXIvUmVnaXN0ZXJGaWxlLmg6CisgICAgICAgIChKU0M6OlJlZ2lzdGVy RmlsZTo6UmVnaXN0ZXJGaWxlKToKKyAgICAgICAgKiBqaXQvRXhlY3V0YWJsZUFsbG9jYXRvclBv c2l4LmNwcDoKKyAgICAgICAgKEpTQzo6RXhlY3V0YWJsZVBvb2w6OnN5c3RlbUFsbG9jKToKKyAg ICAgICAgKEpTQzo6RXhlY3V0YWJsZVBvb2w6OnN5c3RlbVJlbGVhc2UpOgorICAgICAgICAqIHJ1 bnRpbWUvQ29sbGVjdG9yLmNwcDoKKyAgICAgICAgKEpTQzo6SGVhcDo6SGVhcCk6CisgICAgICAg IChKU0M6OmFsbG9jYXRlQmxvY2spOgorICAgICAgICAoSlNDOjpmcmVlQmxvY2spOgorICAgICAg ICAoSlNDOjpjdXJyZW50VGhyZWFkU3RhY2tCYXNlKToKKyAgICAgICAgKiBydW50aW1lL0NvbGxl Y3Rvci5oOgorICAgICAgICAqIHd0Zi9UQ1N5c3RlbUFsbG9jLmNwcDoKKyAgICAgICAgKFRyeU1t YXApOgorCiAyMDA5LTAzLTExICBBZGFtIFJvYmVuICA8YXJvYmVuQGFwcGxlLmNvbT4KIAogICAg ICAgICBDaGFuZ2UgdGhlIFdpbmRvd3MgaW1wbGVtZW50YXRpb24gb2YgVGhyZWFkU3BlY2lmaWMg dG8gdXNlIGZ1bmN0aW9ucwpJbmRleDogSmF2YVNjcmlwdENvcmUvaW50ZXJwcmV0ZXIvUmVnaXN0 ZXJGaWxlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0Q29yZS9pbnRlcnByZXRlci9SZWdp c3RlckZpbGUuY3BwCShyZXZpc2lvbiA0MTYwNCkKKysrIEphdmFTY3JpcHRDb3JlL2ludGVycHJl dGVyL1JlZ2lzdGVyRmlsZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM0LDcgKzM0LDExIEBAIG5h bWVzcGFjZSBKU0MgewogUmVnaXN0ZXJGaWxlOjp+UmVnaXN0ZXJGaWxlKCkKIHsKICNpZiBIQVZF KE1NQVApCi0gICAgbXVubWFwKG1fYnVmZmVyLCAoKG1fbWF4IC0gbV9zdGFydCkgKyBtX21heEds b2JhbHMpICogc2l6ZW9mKFJlZ2lzdGVyKSk7CisgICAgI2lmIFBMQVRGT1JNKFNZTUJJQU4pCisg ICAgICAgIGZhc3RGcmVlKG1fYnVmZmVyU3ltYmlhbik7CisgICAgI2Vsc2UKKyAgICAgICAgbXVu bWFwKG1fYnVmZmVyLCAoKG1fbWF4IC0gbV9zdGFydCkgKyBtX21heEdsb2JhbHMpICogc2l6ZW9m KFJlZ2lzdGVyKSk7CisgICAgI2VuZGlmCiAjZWxpZiBIQVZFKFZJUlRVQUxBTExPQykKICAgICBW aXJ0dWFsRnJlZShtX2J1ZmZlciwgMCwgTUVNX1JFTEVBU0UpOwogI2Vsc2UKSW5kZXg6IEphdmFT Y3JpcHRDb3JlL2ludGVycHJldGVyL1JlZ2lzdGVyRmlsZS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFT Y3JpcHRDb3JlL2ludGVycHJldGVyL1JlZ2lzdGVyRmlsZS5oCShyZXZpc2lvbiA0MTYwNCkKKysr IEphdmFTY3JpcHRDb3JlL2ludGVycHJldGVyL1JlZ2lzdGVyRmlsZS5oCSh3b3JraW5nIGNvcHkp CkBAIC0zNyw2ICszNyw5IEBACiAjaW5jbHVkZSA8ZXJybm8uaD4KICNpbmNsdWRlIDxzdGRpby5o PgogI2luY2x1ZGUgPHN5cy9tbWFuLmg+CisjaWYgUExBVEZPUk0oU1lNQklBTikKKyMgIGluY2x1 ZGUgPHVuaXN0ZC5oPgorI2VuZGlmCiAjZW5kaWYKIAogbmFtZXNwYWNlIEpTQyB7CkBAIC0xMjUs MTEgKzEyOCwzOCBAQCBuYW1lc3BhY2UgSlNDIHsKICAgICAgICAgewogICAgICAgICAgICAgc2l6 ZV90IGJ1ZmZlckxlbmd0aCA9IChjYXBhY2l0eSArIG1heEdsb2JhbHMpICogc2l6ZW9mKFJlZ2lz dGVyKTsKICNpZiBIQVZFKE1NQVApCisjaWYgUExBVEZPUk0oU1lNQklBTikKKyAgICAgICAgICAg IC8vIFN5bWJpYW4ncyBPcGVuQyBkb2Vzbid0IHN1cHBvcnQgTUFQX0FOT04gZm9yIG1tYXAuCisg ICAgICAgICAgICAvLyBOZWVkIHRvIGhhY2sgd2l0aCBmYXN0TWFsbG9jLgorICAgICAgICAgICAg Ly8gRklYTUUgLS1ubC0tIE5vdCBzdXJlLCBpZiB3ZSByZWFsbHkgbmVlZCBtZW1vcnkgYWxpZ25t ZW50IGhlcmUsCisgICAgICAgICAgICAvLyBidXQgaXQncyBzYWZlIHRoaXMgd2F5IGFuZCBvbmx5 IHdhc3RlcyB2ZXJ5IGxpdHRsZSBtZW1vcnkuCisgICAgICAgICAgICBzdGF0aWMgc2l6ZV90IHBh Z2VzaXplID0gZ2V0cGFnZXNpemUoKTsKKyAgICAgICAgICAgIHNpemVfdCBleHRyYSA9IDA7Cisg ICAgICAgICAgICBpZiAoYWxsb2NhdGlvblNpemUgPiBwYWdlc2l6ZSkgeworICAgICAgICAgICAg ICAgIGV4dHJhID0gYWxsb2NhdGlvblNpemUgLSBwYWdlc2l6ZTsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgICAgIG1fYnVmZmVyU3ltYmlhbiA9IGZhc3RNYWxsb2MoYnVmZmVyTGVuZ3RoICsgZXh0 cmEpOworCisgICAgICAgICAgICAvLyBBbGlnbiBtZW1vcnkgYXQgYWxsb2NhdGlvblNpemUgYm91 bmRhcnkgCisgICAgICAgICAgICB1aW50cHRyX3QgcHRyID0gcmVpbnRlcnByZXRfY2FzdDx1aW50 cHRyX3Q+KG1fYnVmZmVyU3ltYmlhbik7CisgICAgICAgICAgICBzaXplX3QgYWRqdXN0ID0gMDsK KyAgICAgICAgICAgIGlmICgocHRyICYgKGFsbG9jYXRpb25TaXplTWFzaykpICE9IDApIHsKKyAg ICAgICAgICAgICAgICBhZGp1c3QgPSBhbGxvY2F0aW9uU2l6ZSAtIChwdHIgJiAoYWxsb2NhdGlv blNpemVNYXNrKSk7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGlmICghbV9idWZmZXJT eW1iaWFuIHx8IGFkanVzdCA+IChidWZmZXJMZW5ndGggKyBleHRyYSkpIHsKKyAgICAgICAgICAg ICAgICBmcHJpbnRmKHN0ZGVyciwgIkNvdWxkIG5vdCBhbGxvY2F0ZSByZWdpc3RlciBmaWxlOiAl ZFxuIiwgZXJybm8pOworICAgICAgICAgICAgICAgIENSQVNIKCk7CisgICAgICAgICAgICB9Cisg ICAgICAgICAgICBwdHIgKz0gYWRqdXN0OworICAgICAgICAgICAgbV9idWZmZXIgPSByZWludGVy cHJldF9jYXN0PFJlZ2lzdGVyKj4ocHRyKTsKKyNlbHNlCiAgICAgICAgICAgICBtX2J1ZmZlciA9 IHN0YXRpY19jYXN0PFJlZ2lzdGVyKj4obW1hcCgwLCBidWZmZXJMZW5ndGgsIFBST1RfUkVBRHxQ Uk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTiwgLTEsIDApKTsKICAgICAgICAgICAgIGlm IChtX2J1ZmZlciA9PSBNQVBfRkFJTEVEKSB7CiAgICAgICAgICAgICAgICAgZnByaW50ZihzdGRl cnIsICJDb3VsZCBub3QgYWxsb2NhdGUgcmVnaXN0ZXIgZmlsZTogJWRcbiIsIGVycm5vKTsKICAg ICAgICAgICAgICAgICBDUkFTSCgpOwogICAgICAgICAgICAgfQorI2VuZGlmIC8vIFBMQVRGT1JN KFNZTUJJQU4pCiAjZWxpZiBIQVZFKFZJUlRVQUxBTExPQykKICAgICAgICAgICAgIC8vIEVuc3Vy ZSBidWZmZXJMZW5ndGggaXMgYSBtdWx0aXBsZSBvZiBhbGxvY2F0aW9uIHNpemUKICAgICAgICAg ICAgIGJ1ZmZlckxlbmd0aCA9IChidWZmZXJMZW5ndGggKyBhbGxvY2F0aW9uU2l6ZU1hc2spICYg fmFsbG9jYXRpb25TaXplTWFzazsKQEAgLTIwNyw2ICsyMzcsOSBAQCBuYW1lc3BhY2UgSlNDIHsK ICNpZiBIQVZFKFZJUlRVQUxBTExPQykKICAgICAgICAgUmVnaXN0ZXIqIG1fbWF4Q29tbWl0dGVk OwogI2VuZGlmCisjaWYgUExBVEZPUk0oU1lNQklBTikKKyAgICAgICAgdm9pZCogbV9idWZmZXJT eW1iaWFuOworI2VuZGlmCiAKICAgICAgICAgSlNHbG9iYWxPYmplY3QqIG1fZ2xvYmFsT2JqZWN0 OyAvLyBUaGUgZ2xvYmFsIG9iamVjdCB3aG9zZSB2YXJzIGFyZSBjdXJyZW50bHkgc3RvcmVkIGlu IHRoZSByZWdpc3RlciBmaWxlLgogICAgIH07CkluZGV4OiBKYXZhU2NyaXB0Q29yZS9qaXQvRXhl Y3V0YWJsZUFsbG9jYXRvclBvc2l4LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0Q29yZS9q aXQvRXhlY3V0YWJsZUFsbG9jYXRvclBvc2l4LmNwcAkocmV2aXNpb24gNDE2MDQpCisrKyBKYXZh U2NyaXB0Q29yZS9qaXQvRXhlY3V0YWJsZUFsbG9jYXRvclBvc2l4LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtNDEsMTQgKzQxLDI0IEBAIHZvaWQgRXhlY3V0YWJsZUFsbG9jYXRvcjo6aW50aWFsaXpl UGFnZVMKIAogRXhlY3V0YWJsZVBvb2w6OkFsbG9jYXRpb24gRXhlY3V0YWJsZVBvb2w6OnN5c3Rl bUFsbG9jKHNpemVfdCBuKQogeworI2lmIFBMQVRGT1JNKFNZTUJJQU4pCisgICAgLy8gU3ltYmlh bidzIE9wZW5DIGRvZXNuJ3Qgc3VwcG9ydCBNQVBfQU5PTiBmb3IgbW1hcC4KKyAgICAvLyBOZWVk IHRvIGhhY2sgd2l0aCBmYXN0TWFsbG9jLgorICAgIEV4ZWN1dGFibGVQb29sOjpBbGxvY2F0aW9u IGFsbG9jID0ge3JlaW50ZXJwcmV0X2Nhc3Q8Y2hhcio+KGZhc3RNYWxsb2MobikpLCBufTsKKyNl bHNlCiAgICAgRXhlY3V0YWJsZVBvb2w6OkFsbG9jYXRpb24gYWxsb2MgPSB7cmVpbnRlcnByZXRf Y2FzdDxjaGFyKj4obW1hcChOVUxMLCBuLCBQUk9UX1JFQUQgfCBQUk9UX1dSSVRFIHwgUFJPVF9F WEVDLCBNQVBfUFJJVkFURSB8IE1BUF9BTk9OLCAtMSwgMCkpLCBufTsKKyNlbmRpZgogICAgIHJl dHVybiBhbGxvYzsKIH0KIAogdm9pZCBFeGVjdXRhYmxlUG9vbDo6c3lzdGVtUmVsZWFzZShjb25z dCBFeGVjdXRhYmxlUG9vbDo6QWxsb2NhdGlvbiYgYWxsb2MpIAogeyAKKyNpZiBQTEFURk9STShT WU1CSUFOKQorICAgIGZhc3RGcmVlKHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+YWxsb2MucGFnZXMp OworI2Vsc2UKICAgICBpbnQgcmVzdWx0ID0gbXVubWFwKGFsbG9jLnBhZ2VzLCBhbGxvYy5zaXpl KTsKICAgICBBU1NFUlRfVU5VU0VEKHJlc3VsdCwgIXJlc3VsdCk7CisjZW5kaWYKIH0KIAogfQpJ bmRleDogSmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2xsZWN0b3IuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IEphdmFTY3JpcHRDb3JlL3J1bnRpbWUvQ29sbGVjdG9yLmNwcAkocmV2aXNpb24gNDE2MDQpCisr KyBKYXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvbGxlY3Rvci5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTQ2LDYgKzQ2LDExIEBACiAjaW5jbHVkZSA8bWFjaC90aHJlYWRfYWN0Lmg+CiAjaW5jbHVkZSA8 bWFjaC92bV9tYXAuaD4KIAorI2VsaWYgUExBVEZPUk0oU1lNQklBTikKKyNpbmNsdWRlIDxlMzJz dGQuaD4KKyNpbmNsdWRlIDxlMzJjbW4uaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKwogI2VsaWYg UExBVEZPUk0oV0lOX09TKQogCiAjaW5jbHVkZSA8d2luZG93cy5oPgpAQCAtODcsNiArOTIsMTEg QEAgY29uc3Qgc2l6ZV90IEFMTE9DQVRJT05TX1BFUl9DT0xMRUNUSU9OIAogLy8gYSBQSUMgYnJh bmNoIGluIE1hY2gtTyBiaW5hcmllcywgc2VlIDxyZGFyOi8vcHJvYmxlbS81OTcxMzkxPi4KICNk ZWZpbmUgTUlOX0FSUkFZX1NJWkUgKHN0YXRpY19jYXN0PHNpemVfdD4oMTQpKQogCisjaWYgUExB VEZPUk0oU1lNQklBTikKKyAgICBjb25zdCBzaXplX3QgTUFYX05VTV9CTE9DS1MgPSAxMjg7IC8v IE1heCBzaXplIG9mIGNvbGxlY3RvciBoZWFwIHNldCB0byA4IE1CCisgICAgc3RhdGljIFJIZWFw KiB1c2VyQ2h1bmsgPSBOVUxMOworI2VuZGlmCisgICAgCiBzdGF0aWMgdm9pZCBmcmVlSGVhcChD b2xsZWN0b3JIZWFwKik7CiAKICNpZiBFTkFCTEUoSlNDX01VTFRJUExFX1RIUkVBRFMpCkBAIC0x MjgsNiArMTM4LDM0IEBAIEhlYXA6OkhlYXAoSlNHbG9iYWxEYXRhKiBnbG9iYWxEYXRhKQogewog ICAgIEFTU0VSVChnbG9iYWxEYXRhKTsKIAorI2lmIFBMQVRGT1JNKFNZTUJJQU4pCisgICAgLy8g U3ltYmlhbiBPcGVuQyBzdXBwb3J0cyBtbWFwIGJ1dCBjdXJyZW50bHkgbm90IHRoZSBNQVBfQU5P TiBmbGFnLgorICAgIC8vIFVzaW5nIGZhc3RNYWxsb2MoKSBkb2VzIG5vdCBwcm9wZXJseSBhbGln biBibG9ja3Mgb24gNjRrIGJvdW5kYXJpZXMKKyAgICAvLyBhbmQgcHJldmlvdXMgaW1wbGVtZW50 YXRpb24gd2FzIGZsYXdlZC9pbmNvbXBsZXRlLgorICAgIC8vIFVzZXJIZWFwOjpDaHVua0hlYXAg YWxsb3dzIGFsbG9jYXRpb24gb2YgY29udGludW91cyBtZW1vcnkgYW5kIHNwZWNpZmljYXRpb24K KyAgICAvLyBvZiBhbGlnbm1lbnQgdmFsdWUgZm9yIChzeW1iaWFuKSBjZWxscyB3aXRoaW4gdGhh dCBoZWFwLgorICAgIC8vCisgICAgLy8gQ2xhcmlmaWNhdGlvbiBhbmQgbWFwcGluZyBvZiB0ZXJt aW5vbG9neToKKyAgICAvLyBSSGVhcCAoY3JlYXRlZCBieSBVc2VySGVhcDo6Q2h1bmtIZWFwIGJl bG93KSBpcyBjb250aW51b3MgbWVtb3J5IGNodW5rLAorICAgIC8vIHdoaWNoIGNhbiBkeW5hbWlj YWxseSBncm93IHVwIHRvIDggTUIsCisgICAgLy8gdGhhdCBob2xkcyBhbGwgQ29sbGVjdG9yQmxv Y2tzIG9mIHRoaXMgc2Vzc2lvbiAoc3RhdGljKS4KKyAgICAvLyBFYWNoIHN5bWJpYW4gY2VsbCB3 aXRoaW4gUkhlYXAgbWFwcyB0byBhIDY0a2IgYWxpZ25lZCBDb2xsZWN0b3JCbG9jay4KKyAgICAv LyBKU0NlbGwgb2JqZWN0cyBhcmUgbWFpbnRhaW5lZCBhcyB1c3VhbCB3aXRoaW4gQ29sbGVjdG9y QmxvY2tzLgorICAgIGlmIChOVUxMID09IHVzZXJDaHVuaykgeworICAgICAgICBzdGF0aWMgc2l6 ZV90IHBhZ2VzaXplID0gZ2V0cGFnZXNpemUoKTsKKyAgICAKKyAgICAgICAgc2l6ZV90IGV4dHJh ID0gMDsKKyAgICAgICAgaWYgKEJMT0NLX1NJWkUgPiBwYWdlc2l6ZSkgeworICAgICAgICAgICAg ZXh0cmEgPSBCTE9DS19TSVpFIC0gcGFnZXNpemU7CisgICAgICAgIH0KKyAgICAgICAgCisgICAg ICAgIHVzZXJDaHVuayA9IFVzZXJIZWFwOjpDaHVua0hlYXAgKE5VTEwsIEJMT0NLX1NJWkUgKyBl eHRyYSwgTUFYX05VTV9CTE9DS1MgKiBCTE9DS19TSVpFICsgZXh0cmEsIEJMT0NLX1NJWkUsIEJM T0NLX1NJWkUpOworICAgICAgICBpZiAoTlVMTCA9PSB1c2VyQ2h1bmspIHsKKyAgICAgICAgICAg IENSQVNIKCk7CisgICAgICAgIH0KKyAgICB9CisjZW5kaWYgLy8gUExBVEZPUk0oU1lNQklBTikK KyAgICAKICAgICBtZW1zZXQoJnByaW1hcnlIZWFwLCAwLCBzaXplb2YoQ29sbGVjdG9ySGVhcCkp OwogICAgIG1lbXNldCgmbnVtYmVySGVhcCwgMCwgc2l6ZW9mKENvbGxlY3RvckhlYXApKTsKIH0K QEAgLTE4NCwxMCArMjIyLDE4IEBAIHN0YXRpYyBORVZFUl9JTkxJTkUgQ29sbGVjdG9yQmxvY2sq IGFsbG8KICAgICB2bV9hZGRyZXNzX3QgYWRkcmVzcyA9IDA7CiAgICAgLy8gRklYTUU6IHRhZyB0 aGUgcmVnaW9uIGFzIGEgSmF2YVNjcmlwdENvcmUgaGVhcCB3aGVuIHdlIGdldCBhIHJlZ2lzdGVy ZWQgVk0gdGFnOiA8cmRhcjovL3Byb2JsZW0vNjA1NDc4OD4uCiAgICAgdm1fbWFwKGN1cnJlbnRf dGFzaygpLCAmYWRkcmVzcywgQkxPQ0tfU0laRSwgQkxPQ0tfT0ZGU0VUX01BU0ssIFZNX0ZMQUdT X0FOWVdIRVJFLCBNRU1PUllfT0JKRUNUX05VTEwsIDAsIEZBTFNFLCBWTV9QUk9UX0RFRkFVTFQs IFZNX1BST1RfREVGQVVMVCwgVk1fSU5IRVJJVF9ERUZBVUxUKTsKKwogI2VsaWYgUExBVEZPUk0o U1lNQklBTikKLSAgICAvLyBubyBtZW1vcnkgbWFwIGluIHN5bWJpYW4sIG5lZWQgdG8gaGFjayB3 aXRoIGZhc3RNYWxsb2MKLSAgICB2b2lkKiBhZGRyZXNzID0gZmFzdE1hbGxvYyhCTE9DS19TSVpF KTsKKworICAgIC8vIEFsbG9jYXRlIGEgNjQga2IgYWxpZ25lZCBDb2xsZWN0b3JCbG9jaworICAg IHVuc2lnbmVkIGNoYXIqIG1hc2sgPSAodW5zaWduZWQgY2hhciopdXNlckNodW5rLT5BbGxvYyhC TE9DS19TSVpFKTsKKyAgICBpZiAoTlVMTCA9PSBtYXNrKSB7CisgICAgICAgIENSQVNIKCk7Cisg ICAgfQorICAgIHVpbnRwdHJfdCBhZGRyZXNzID0gcmVpbnRlcnByZXRfY2FzdDx1aW50cHRyX3Q+ KG1hc2spOworCiAgICAgbWVtc2V0KHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KGFkZHJlc3MpLCAw LCBCTE9DS19TSVpFKTsKKyAgICAKICNlbGlmIFBMQVRGT1JNKFdJTl9PUykKICAgICAgLy8gd2lu ZG93cyB2aXJ0dWFsIGFkZHJlc3MgZ3JhbnVsYXJpdHkgaXMgbmF0dXJhbGx5IDY0awogICAgIExQ Vk9JRCBhZGRyZXNzID0gVmlydHVhbEFsbG9jKE5VTEwsIEJMT0NLX1NJWkUsIE1FTV9DT01NSVQg fCBNRU1fUkVTRVJWRSwgUEFHRV9SRUFEV1JJVEUpOwpAQCAtMjMxLDcgKzI3Nyw3IEBAIHN0YXRp YyB2b2lkIGZyZWVCbG9jayhDb2xsZWN0b3JCbG9jayogYmwKICNpZiBQTEFURk9STShEQVJXSU4p ICAgIAogICAgIHZtX2RlYWxsb2NhdGUoY3VycmVudF90YXNrKCksIHJlaW50ZXJwcmV0X2Nhc3Q8 dm1fYWRkcmVzc190PihibG9jayksIEJMT0NLX1NJWkUpOwogI2VsaWYgUExBVEZPUk0oU1lNQklB TikKLSAgICBmYXN0RnJlZShibG9jayk7CisgICAgdXNlckNodW5rLT5GcmVlKHJlaW50ZXJwcmV0 X2Nhc3Q8VEFueSAqPihibG9jaykpOwogI2VsaWYgUExBVEZPUk0oV0lOX09TKQogICAgIFZpcnR1 YWxGcmVlKGJsb2NrLCAwLCBNRU1fUkVMRUFTRSk7CiAjZWxpZiBIQVZFKFBPU0lYX01FTUFMSUdO KQpAQCAtMzk1LDYgKzQ0MSwxNiBAQCBzdGF0aWMgaW5saW5lIHZvaWQqIGN1cnJlbnRUaHJlYWRT dGFja0JhCiAjaWYgUExBVEZPUk0oREFSV0lOKQogICAgIHB0aHJlYWRfdCB0aHJlYWQgPSBwdGhy ZWFkX3NlbGYoKTsKICAgICByZXR1cm4gcHRocmVhZF9nZXRfc3RhY2thZGRyX25wKHRocmVhZCk7 CisjZWxpZiBQTEFURk9STShTWU1CSUFOKQorICAgIC8vIE5lZWRzIHRvIGJlIHBvc2l0aW9uZWQg YmVmb3JlIG90aGVyIHBsYXRmb3JtcyB0byBhdm9pZCBwb3RlbnRpYWwgYW1iaWd1aXRpZXMKKyAg ICBzdGF0aWMgdm9pZCogc3RhY2tCYXNlID0gMDsKKyAgICBpZiAoc3RhY2tCYXNlID09IDApIHsK KyAgICAgICAgVFRocmVhZFN0YWNrSW5mbyBpbmZvOworICAgICAgICBSVGhyZWFkIHRocmVhZDsK KyAgICAgICAgdGhyZWFkLlN0YWNrSW5mbyhpbmZvKTsKKyAgICAgICAgc3RhY2tCYXNlID0gKHZv aWQqKWluZm8uaUJhc2U7CisgICAgfQorICAgIHJldHVybiAodm9pZCopc3RhY2tCYXNlOwogI2Vs aWYgUExBVEZPUk0oV0lOX09TKSAmJiBQTEFURk9STShYODYpICYmIENPTVBJTEVSKE1TVkMpCiAg ICAgLy8gb2Zmc2V0IDB4MTggZnJvbSB0aGUgRlMgc2VnbWVudCByZWdpc3RlciBnaXZlcyBhIHBv aW50ZXIgdG8KICAgICAvLyB0aGUgdGhyZWFkIGluZm9ybWF0aW9uIGJsb2NrIGZvciB0aGUgY3Vy cmVudCB0aHJlYWQKQEAgLTQ0NiwxNSArNTAyLDYgQEAgc3RhdGljIGlubGluZSB2b2lkKiBjdXJy ZW50VGhyZWFkU3RhY2tCYQogICAgICAgICBzdGFja1RocmVhZCA9IHRocmVhZDsKICAgICB9CiAg ICAgcmV0dXJuIHN0YXRpY19jYXN0PGNoYXIqPihzdGFja0Jhc2UpICsgc3RhY2tTaXplOwotI2Vs aWYgUExBVEZPUk0oU1lNQklBTikKLSAgICBzdGF0aWMgdm9pZCogc3RhY2tCYXNlID0gMDsKLSAg ICBpZiAoc3RhY2tCYXNlID09IDApIHsKLSAgICAgICAgVFRocmVhZFN0YWNrSW5mbyBpbmZvOwot ICAgICAgICBSVGhyZWFkIHRocmVhZDsKLSAgICAgICAgdGhyZWFkLlN0YWNrSW5mbyhpbmZvKTsK LSAgICAgICAgc3RhY2tCYXNlID0gKHZvaWQqKWluZm8uaUJhc2U7Ci0gICAgfQotICAgIHJldHVy biAodm9pZCopc3RhY2tCYXNlOwogI2Vsc2UKICNlcnJvciBOZWVkIGEgd2F5IHRvIGdldCB0aGUg c3RhY2sgYmFzZSBvbiB0aGlzIHBsYXRmb3JtCiAjZW5kaWYKSW5kZXg6IEphdmFTY3JpcHRDb3Jl L3J1bnRpbWUvQ29sbGVjdG9yLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9Db2xsZWN0b3IuaAkocmV2aXNpb24gNDE2MDQpCisrKyBKYXZhU2NyaXB0Q29yZS9ydW50aW1l L0NvbGxlY3Rvci5oCSh3b3JraW5nIGNvcHkpCkBAIC05Myw2ICs5Myw3IEBAIG5hbWVzcGFjZSBK U0MgewogICAgICAgICAgICAgc2l6ZV90IHNpemU7CiAgICAgICAgICAgICBzaXplX3QgZnJlZTsK ICAgICAgICAgfTsKKwogICAgICAgICBTdGF0aXN0aWNzIHN0YXRpc3RpY3MoKSBjb25zdDsKIAog ICAgICAgICB2b2lkIHNldEdDUHJvdGVjdE5lZWRzTG9ja2luZygpOwpJbmRleDogSmF2YVNjcmlw dENvcmUvd3RmL1RDU3lzdGVtQWxsb2MuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3Jl L3d0Zi9UQ1N5c3RlbUFsbG9jLmNwcAkocmV2aXNpb24gNDE2MDQpCisrKyBKYXZhU2NyaXB0Q29y ZS93dGYvVENTeXN0ZW1BbGxvYy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE2OSw2ICsxNjksMjcg QEAgc3RhdGljIHZvaWQqIFRyeU1tYXAoc2l6ZV90IHNpemUsIHNpemVfdAogICBpZiAoYWxpZ25t ZW50ID4gcGFnZXNpemUpIHsKICAgICBleHRyYSA9IGFsaWdubWVudCAtIHBhZ2VzaXplOwogICB9 CisjaWYgUExBVEZPUk0oU1lNQklBTikKKyAgICAvLyBTeW1iaWFuJ3MgT3BlbkMgZG9lc24ndCBz dXBwb3J0IE1BUF9BTk9OIGZvciBtbWFwLgorICAgIC8vIE5lZWQgdG8gaGFjayB3aXRoIGZhc3RN YWxsb2MoKS4KKyAgICAvLyBGSVhNRTogVGhlIHdheSB3ZSBhZGp1c3QgZm9yIG1lbW9yeSBhbGln bm1lbnQgCisJLy8gY2F1c2VzIGEgc21hbGwgbWVtb3J5IGxlYWsgb2YgcmV0dXJuZWQgcmVzdWx0 IHB0cgorCS8vIChUaGUgYWRqdXN0IHNpemUgd29uJ3QgYmUgZnJlZSdkKS4KKyAgICAvLyBIb3dl dmVyLCB0aGlzIGZ1bmN0aW9uIGlzIGN1cnJlbnRseSBub3QgY2FsbGVkIGZyb20gYW55d2hlcmUg PyEKKyAgICB2b2lkKiByZXN1bHQgPSBmYXN0TWFsbG9jKHNpemUgKyBleHRyYSk7CisgICAgCisg ICAgLy8gQWRqdXN0IHRoZSByZXR1cm4gbWVtb3J5IHNvIGl0IGlzIGFsaWduZWQKKyAgICB1aW50 cHRyX3QgcHRyID0gcmVpbnRlcnByZXRfY2FzdDx1aW50cHRyX3Q+KHJlc3VsdCk7CisgICAgc2l6 ZV90IGFkanVzdCA9IDA7CisgICAgaWYgKChwdHIgJiAoYWxpZ25tZW50IC0gMSkpICE9IDApIHsK KyAgICBhZGp1c3QgPSBhbGlnbm1lbnQgLSAocHRyICYgKGFsaWdubWVudCAtIDEpKTsKKyAgICB9 CisgICAgCisgICAgaWYgKCFyZXN1bHQgfHwgYWRqdXN0ID4gKHNpemUgKyBleHRyYSkpIHsKKyAg ICAgICAgZnByaW50ZihzdGRlcnIsICJDb3VsZCBub3QgYWxsb2NhdGUgcmVnaXN0ZXIgZmlsZTog JWRcbiIsIGVycm5vKTsKKyAgICAgICAgQ1JBU0goKTsKKyAgICB9CisjZWxzZQogICB2b2lkKiBy ZXN1bHQgPSBtbWFwKE5VTEwsIHNpemUgKyBleHRyYSwKICAgICAgICAgICAgICAgICAgICAgICBQ Uk9UX1JFQUQgfCBQUk9UX1dSSVRFLAogICAgICAgICAgICAgICAgICAgICAgIE1BUF9QUklWQVRF fE1BUF9BTk9OWU1PVVMsCkBAIC0xOTIsNiArMjEzLDcgQEAgc3RhdGljIHZvaWQqIFRyeU1tYXAo c2l6ZV90IHNpemUsIHNpemVfdAogICBpZiAoYWRqdXN0IDwgZXh0cmEpIHsKICAgICBtdW5tYXAo cmVpbnRlcnByZXRfY2FzdDx2b2lkKj4ocHRyICsgYWRqdXN0ICsgc2l6ZSksIGV4dHJhIC0gYWRq dXN0KTsKICAgfQorI2VuZGlmIC8qIFBMQVRGT1JNKFNZTUJJQU4pICovCiAKICAgcHRyICs9IGFk anVzdDsKICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KHB0cik7Cg== 28716 2009-03-17 19:17:54 -0700 2009-07-07 18:26:23 -0700 Updated patch for bug 24540 patch_update1_24540.txt text/plain 10637 norbert.leser SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZw0KPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIEphdmFTY3Jp cHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gNDE3OTYpDQorKysgSmF2YVNjcmlwdENvcmUvQ2hh bmdlTG9nCSh3b3JraW5nIGNvcHkpDQpAQCAtMSwzICsxLDE3IEBADQorMjAwOS0wMy0xNyAgTm9y YmVydCBMZXNlciAgPE5vcmJlcnQuTGVzZXJAbm9raWEuY29tPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEZpeCwgY29uZGl0aW9uYWxseSBmb3IgUExB VEZPUk0oU1lNQklBTiksIGFzIGEgd29ya2Fyb3VuZCBmb3IKKyAgICAgICAgbWlzc2luZyBzdXBw b3J0IGZvciB0aGUgTUFQX0FOT04gcHJvcGVydHkgZmxhZyBpbiBtbWFwLiBJdCB1dGlsaXplcyBm YXN0TWFsbG9jCisgICAgICAgIGFuZCBTeW1iaWFuIHNwZWNpZmljIG1lbW9yeSBhbGxvY2F0aW9u IGZlYXR1cmVzLgorCisgICAgICAgICogSmF2YVNjcmlwdENvcmUucHJpOgorICAgICAgICAqIGlu dGVycHJldGVyL1JlZ2lzdGVyRmlsZS5jcHA6CisgICAgICAgICogaW50ZXJwcmV0ZXIvUmVnaXN0 ZXJGaWxlLmg6CisgICAgICAgICogaml0L0V4ZWN1dGFibGVBbGxvY2F0b3JTeW1iaWFuLmNwcDog QWRkZWQuCisgICAgICAgICogcnVudGltZS9Db2xsZWN0b3IuY3BwOgorCiAyMDA5LTAzLTE3ICBL ZXZpbiBPbGxpdmllciAgPGtldmlub0B0aGVvbGxpdmllcnMuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IE1hcmsgUm93ZS4KSW5kZXg6IEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnBy aQ0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQ0KLS0tIEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaQkocmV2 aXNpb24gNDE3OTYpDQorKysgSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUucHJpCSh3b3Jr aW5nIGNvcHkpDQpAQCAtOTksNiArOTksNyBAQA0KICAgICBpbnRlcnByZXRlci9SZWdpc3RlckZp bGUuY3BwCiAKIHdpbjMyLSo6IFNPVVJDRVMgKz0gaml0L0V4ZWN1dGFibGVBbGxvY2F0b3JXaW4u Y3BwCitlbHNlOnN5bWJpYW46IFNPVVJDRVMgKz0gaml0L0V4ZWN1dGFibGVBbGxvY2F0b3JTeW1i aWFuLmNwcAogZWxzZTogU09VUkNFUyArPSBqaXQvRXhlY3V0YWJsZUFsbG9jYXRvclBvc2l4LmNw cAogCiAjIEFsbEluT25lRmlsZS5jcHAgaGVscHMgZ2NjIGFuYWxpemUgYW5kIG9wdGltaXplIGNv ZGUKSW5kZXg6IEphdmFTY3JpcHRDb3JlL2ludGVycHJldGVyL1JlZ2lzdGVyRmlsZS5jcHANCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0NCi0tLSBKYXZhU2NyaXB0Q29yZS9pbnRlcnByZXRlci9SZWdpc3RlckZpbGUuY3Bw CShyZXZpc2lvbiA0MTc5NikNCisrKyBKYXZhU2NyaXB0Q29yZS9pbnRlcnByZXRlci9SZWdpc3Rl ckZpbGUuY3BwCSh3b3JraW5nIGNvcHkpDQpAQCAtMzMsNyArMzMsOSBAQA0KIAogUmVnaXN0ZXJG aWxlOjp+UmVnaXN0ZXJGaWxlKCkKIHsKLSNpZiBIQVZFKE1NQVApCisjaWYgUExBVEZPUk0oU1lN QklBTikKKyAgICBmYXN0RnJlZShtX2J1ZmZlclN5bWJpYW4pOworI2VsaWYgSEFWRShNTUFQKQog ICAgIG11bm1hcChtX2J1ZmZlciwgKChtX21heCAtIG1fc3RhcnQpICsgbV9tYXhHbG9iYWxzKSAq IHNpemVvZihSZWdpc3RlcikpOwogI2VsaWYgSEFWRShWSVJUVUFMQUxMT0MpCiAgICAgVmlydHVh bEZyZWUobV9idWZmZXIsIDAsIE1FTV9SRUxFQVNFKTsKSW5kZXg6IEphdmFTY3JpcHRDb3JlL2lu dGVycHJldGVyL1JlZ2lzdGVyRmlsZS5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gSmF2YVNjcmlwdENvcmUv aW50ZXJwcmV0ZXIvUmVnaXN0ZXJGaWxlLmgJKHJldmlzaW9uIDQxNzk2KQ0KKysrIEphdmFTY3Jp cHRDb3JlL2ludGVycHJldGVyL1JlZ2lzdGVyRmlsZS5oCSh3b3JraW5nIGNvcHkpDQpAQCAtMzks NiArMzksMTAgQEANCiAjaW5jbHVkZSA8c3lzL21tYW4uaD4KICNlbmRpZgogCisjaWYgUExBVEZP Uk0oU1lNQklBTikKKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNlbmRpZgorCiBuYW1lc3BhY2UgSlND IHsKIAogLyoKQEAgLTEyNCw3ICsxMjgsMjggQEANCiAgICAgICAgICAgICAsIG1fZ2xvYmFsT2Jq ZWN0KDApCiAgICAgICAgIHsKICAgICAgICAgICAgIHNpemVfdCBidWZmZXJMZW5ndGggPSAoY2Fw YWNpdHkgKyBtYXhHbG9iYWxzKSAqIHNpemVvZihSZWdpc3Rlcik7Ci0jaWYgSEFWRShNTUFQKQor I2lmIFBMQVRGT1JNKFNZTUJJQU4pCisgICAgICAgICAgICAvLyBTeW1iaWFuJ3MgT3BlbkMgZG9l c24ndCBzdXBwb3J0IE1BUF9BTk9OIGZvciBtbWFwLgorICAgICAgICAgICAgLy8gTmVlZCB0byBo YWNrIHdpdGggZmFzdE1hbGxvYy4KKyAgICAgICAgICAgIC8vIFdlIG1heSBub3QgcmVhbGx5IG5l ZWQgbWVtb3J5IGFsaWdubWVudCBvbiBwYWdlIGJvdW5kYXJ5ICg0ayksCisgICAgICAgICAgICAv LyBidXQgaXQncyBzYWZlIHRoaXMgd2F5LCB3aXRoIHZlcnkgbGl0dGxlIG92ZXJoZWFkLgorICAg ICAgICAgICAgc3RhdGljIHNpemVfdCBwYWdlc2l6ZSA9IGdldHBhZ2VzaXplKCk7CisgICAgICAg ICAgICBtX2J1ZmZlclN5bWJpYW4gPSBmYXN0TWFsbG9jKGJ1ZmZlckxlbmd0aCArIHBhZ2VzaXpl KTsKKworICAgICAgICAgICAgLy8gQWxpZ24gbWVtb3J5IGF0IGFsbG9jYXRpb25TaXplIGJvdW5k YXJ5IAorICAgICAgICAgICAgdWludHB0cl90IHB0ciA9IHJlaW50ZXJwcmV0X2Nhc3Q8dWludHB0 cl90PihtX2J1ZmZlclN5bWJpYW4pOworICAgICAgICAgICAgc2l6ZV90IGFkanVzdCA9IDA7Cisg ICAgICAgICAgICBpZiAoKHB0ciAmIChwYWdlc2l6ZSAtIDEpKSAhPSAwKSB7CisgICAgICAgICAg ICAgICAgYWRqdXN0ID0gcGFnZXNpemUgLSAocHRyICYgKHBhZ2VzaXplIC0gMSkpOworICAgICAg ICAgICAgfQorCisgICAgICAgICAgICBpZiAoIW1fYnVmZmVyU3ltYmlhbiB8fCBhZGp1c3QgPiBw YWdlc2l6ZSB8fCBhZGp1c3QgPCAwKSB7CisgICAgICAgICAgICAgICAgZnByaW50ZihzdGRlcnIs ICJDb3VsZCBub3QgYWxsb2NhdGUgcmVnaXN0ZXIgZmlsZTogJWRcbiIsIGVycm5vKTsKKyAgICAg ICAgICAgICAgICBDUkFTSCgpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgcHRyICs9IGFk anVzdDsKKyAgICAgICAgICAgIG1fYnVmZmVyID0gcmVpbnRlcnByZXRfY2FzdDxSZWdpc3Rlcio+ KHB0cik7CisjZWxpZiBIQVZFKE1NQVApCiAgICAgICAgICAgICBtX2J1ZmZlciA9IHN0YXRpY19j YXN0PFJlZ2lzdGVyKj4obW1hcCgwLCBidWZmZXJMZW5ndGgsIFBST1RfUkVBRHxQUk9UX1dSSVRF LCBNQVBfUFJJVkFURXxNQVBfQU5PTiwgLTEsIDApKTsKICAgICAgICAgICAgIGlmIChtX2J1ZmZl ciA9PSBNQVBfRkFJTEVEKSB7CiAgICAgICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJDb3Vs ZCBub3QgYWxsb2NhdGUgcmVnaXN0ZXIgZmlsZTogJWRcbiIsIGVycm5vKTsKQEAgLTIwNyw2ICsy MzIsOSBAQA0KICNpZiBIQVZFKFZJUlRVQUxBTExPQykKICAgICAgICAgUmVnaXN0ZXIqIG1fbWF4 Q29tbWl0dGVkOwogI2VuZGlmCisjaWYgUExBVEZPUk0oU1lNQklBTikKKyAgICAgICAgdm9pZCog bV9idWZmZXJTeW1iaWFuOworI2VuZGlmCiAKICAgICAgICAgSlNHbG9iYWxPYmplY3QqIG1fZ2xv YmFsT2JqZWN0OyAvLyBUaGUgZ2xvYmFsIG9iamVjdCB3aG9zZSB2YXJzIGFyZSBjdXJyZW50bHkg c3RvcmVkIGluIHRoZSByZWdpc3RlciBmaWxlLgogICAgIH07CkluZGV4OiBKYXZhU2NyaXB0Q29y ZS9qaXQvRXhlY3V0YWJsZUFsbG9jYXRvclN5bWJpYW4uY3BwDQo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gSmF2 YVNjcmlwdENvcmUvaml0L0V4ZWN1dGFibGVBbGxvY2F0b3JTeW1iaWFuLmNwcAkocmV2aXNpb24g MCkNCisrKyBKYXZhU2NyaXB0Q29yZS9qaXQvRXhlY3V0YWJsZUFsbG9jYXRvclN5bWJpYW4uY3Bw CShyZXZpc2lvbiAwKQ0KQEAgLTAsMCArMSw1NyBAQA0KKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICog RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZ LCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQor ICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4gCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAi RXhlY3V0YWJsZUFsbG9jYXRvci5oIgorCisjaWYgRU5BQkxFKEFTU0VNQkxFUikKKworI2luY2x1 ZGUgPHN5cy9tbWFuLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CisKK25hbWVzcGFjZSBKU0Mgewor Cit2b2lkIEV4ZWN1dGFibGVBbGxvY2F0b3I6OmludGlhbGl6ZVBhZ2VTaXplKCkKK3sKKyAgICBF eGVjdXRhYmxlQWxsb2NhdG9yOjpwYWdlU2l6ZSA9IGdldHBhZ2VzaXplKCk7Cit9CisKK0V4ZWN1 dGFibGVQb29sOjpBbGxvY2F0aW9uIEV4ZWN1dGFibGVQb29sOjpzeXN0ZW1BbGxvYyhzaXplX3Qg bikKK3sKKyAgICAvLyBTeW1iaWFuJ3MgT3BlbkMgZG9lc24ndCBzdXBwb3J0IE1BUF9BTk9OIGZv ciBtbWFwLgorICAgIC8vIE5lZWQgdG8gaGFjayB3aXRoIGZhc3RNYWxsb2MuCisgICAgRXhlY3V0 YWJsZVBvb2w6OkFsbG9jYXRpb24gYWxsb2MgPSB7cmVpbnRlcnByZXRfY2FzdDxjaGFyKj4oZmFz dE1hbGxvYyhuKSksIG59OworICAgIHJldHVybiBhbGxvYzsKK30KKwordm9pZCBFeGVjdXRhYmxl UG9vbDo6c3lzdGVtUmVsZWFzZShjb25zdCBFeGVjdXRhYmxlUG9vbDo6QWxsb2NhdGlvbiYgYWxs b2MpIAoreyAKKyAgICBmYXN0RnJlZShyZWludGVycHJldF9jYXN0PHZvaWQqPmFsbG9jLnBhZ2Vz KTsKK30KKworfQorCisjZW5kaWYgLy8gSEFWRShBU1NFTUJMRVIpCkluZGV4OiBKYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0NvbGxlY3Rvci5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBKYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0NvbGxlY3Rvci5jcHAJKHJldmlzaW9uIDQxNzk2KQ0KKysrIEphdmFTY3JpcHRD b3JlL3J1bnRpbWUvQ29sbGVjdG9yLmNwcAkod29ya2luZyBjb3B5KQ0KQEAgLTQ2LDYgKzQ2LDEx IEBADQogI2luY2x1ZGUgPG1hY2gvdGhyZWFkX2FjdC5oPgogI2luY2x1ZGUgPG1hY2gvdm1fbWFw Lmg+CiAKKyNlbGlmIFBMQVRGT1JNKFNZTUJJQU4pCisjaW5jbHVkZSA8ZTMyc3RkLmg+CisjaW5j bHVkZSA8ZTMyY21uLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CisKICNlbGlmIFBMQVRGT1JNKFdJ Tl9PUykKIAogI2luY2x1ZGUgPHdpbmRvd3MuaD4KQEAgLTg3LDYgKzkyLDExIEBADQogLy8gYSBQ SUMgYnJhbmNoIGluIE1hY2gtTyBiaW5hcmllcywgc2VlIDxyZGFyOi8vcHJvYmxlbS81OTcxMzkx Pi4KICNkZWZpbmUgTUlOX0FSUkFZX1NJWkUgKHN0YXRpY19jYXN0PHNpemVfdD4oMTQpKQogCisj aWYgUExBVEZPUk0oU1lNQklBTikKKyAgICBjb25zdCBzaXplX3QgTUFYX05VTV9CTE9DS1MgPSAx Mjg7IC8vIE1heCBzaXplIG9mIGNvbGxlY3RvciBoZWFwIHNldCB0byA4IE1CCisgICAgc3RhdGlj IFJIZWFwKiB1c2VyQ2h1bmsgPSBOVUxMOworI2VuZGlmCisgICAgCiBzdGF0aWMgdm9pZCBmcmVl SGVhcChDb2xsZWN0b3JIZWFwKik7CiAKICNpZiBFTkFCTEUoSlNDX01VTFRJUExFX1RIUkVBRFMp CkBAIC0xMjgsNiArMTM4LDI3IEBADQogewogICAgIEFTU0VSVChnbG9iYWxEYXRhKTsKIAorI2lm IFBMQVRGT1JNKFNZTUJJQU4pCisgICAgLy8gU3ltYmlhbiBPcGVuQyBzdXBwb3J0cyBtbWFwIGJ1 dCBjdXJyZW50bHkgbm90IHRoZSBNQVBfQU5PTiBmbGFnLgorICAgIC8vIFVzaW5nIGZhc3RNYWxs b2MoKSBkb2VzIG5vdCBwcm9wZXJseSBhbGlnbiBibG9ja3Mgb24gNjRrIGJvdW5kYXJpZXMKKyAg ICAvLyBhbmQgcHJldmlvdXMgaW1wbGVtZW50YXRpb24gd2FzIGZsYXdlZC9pbmNvbXBsZXRlLgor ICAgIC8vIFVzZXJIZWFwOjpDaHVua0hlYXAgYWxsb3dzIGFsbG9jYXRpb24gb2YgY29udGludW91 cyBtZW1vcnkgYW5kIHNwZWNpZmljYXRpb24KKyAgICAvLyBvZiBhbGlnbm1lbnQgdmFsdWUgZm9y IChzeW1iaWFuKSBjZWxscyB3aXRoaW4gdGhhdCBoZWFwLgorICAgIC8vCisgICAgLy8gQ2xhcmlm aWNhdGlvbiBhbmQgbWFwcGluZyBvZiB0ZXJtaW5vbG9neToKKyAgICAvLyBSSGVhcCAoY3JlYXRl ZCBieSBVc2VySGVhcDo6Q2h1bmtIZWFwIGJlbG93KSBpcyBjb250aW51b3MgbWVtb3J5IGNodW5r LAorICAgIC8vIHdoaWNoIGNhbiBkeW5hbWljYWxseSBncm93IHVwIHRvIDggTUIsCisgICAgLy8g dGhhdCBob2xkcyBhbGwgQ29sbGVjdG9yQmxvY2tzIG9mIHRoaXMgc2Vzc2lvbiAoc3RhdGljKS4K KyAgICAvLyBFYWNoIHN5bWJpYW4gY2VsbCB3aXRoaW4gUkhlYXAgbWFwcyB0byBhIDY0a2IgYWxp Z25lZCBDb2xsZWN0b3JCbG9jay4KKyAgICAvLyBKU0NlbGwgb2JqZWN0cyBhcmUgbWFpbnRhaW5l ZCBhcyB1c3VhbCB3aXRoaW4gQ29sbGVjdG9yQmxvY2tzLgorICAgIGlmIChOVUxMID09IHVzZXJD aHVuaykgeworICAgICAgICB1c2VyQ2h1bmsgPSBVc2VySGVhcDo6Q2h1bmtIZWFwIChOVUxMLCAw LCBNQVhfTlVNX0JMT0NLUyAqIEJMT0NLX1NJWkUsIEJMT0NLX1NJWkUsIEJMT0NLX1NJWkUpOwor ICAgICAgICBpZiAoTlVMTCA9PSB1c2VyQ2h1bmspIHsKKyAgICAgICAgICAgIENSQVNIKCk7Cisg ICAgICAgIH0KKyAgICB9CisjZW5kaWYgLy8gUExBVEZPUk0oU1lNQklBTikKKyAgICAKICAgICBt ZW1zZXQoJnByaW1hcnlIZWFwLCAwLCBzaXplb2YoQ29sbGVjdG9ySGVhcCkpOwogICAgIG1lbXNl dCgmbnVtYmVySGVhcCwgMCwgc2l6ZW9mKENvbGxlY3RvckhlYXApKTsKIH0KQEAgLTE4NCwxMCAr MjE1LDE4IEBADQogICAgIHZtX2FkZHJlc3NfdCBhZGRyZXNzID0gMDsKICAgICAvLyBGSVhNRTog dGFnIHRoZSByZWdpb24gYXMgYSBKYXZhU2NyaXB0Q29yZSBoZWFwIHdoZW4gd2UgZ2V0IGEgcmVn aXN0ZXJlZCBWTSB0YWc6IDxyZGFyOi8vcHJvYmxlbS82MDU0Nzg4Pi4KICAgICB2bV9tYXAoY3Vy cmVudF90YXNrKCksICZhZGRyZXNzLCBCTE9DS19TSVpFLCBCTE9DS19PRkZTRVRfTUFTSywgVk1f RkxBR1NfQU5ZV0hFUkUsIE1FTU9SWV9PQkpFQ1RfTlVMTCwgMCwgRkFMU0UsIFZNX1BST1RfREVG QVVMVCwgVk1fUFJPVF9ERUZBVUxULCBWTV9JTkhFUklUX0RFRkFVTFQpOworCiAjZWxpZiBQTEFU Rk9STShTWU1CSUFOKQotICAgIC8vIG5vIG1lbW9yeSBtYXAgaW4gc3ltYmlhbiwgbmVlZCB0byBo YWNrIHdpdGggZmFzdE1hbGxvYwotICAgIHZvaWQqIGFkZHJlc3MgPSBmYXN0TWFsbG9jKEJMT0NL X1NJWkUpOworCisgICAgLy8gQWxsb2NhdGUgYSA2NCBrYiBhbGlnbmVkIENvbGxlY3RvckJsb2Nr CisgICAgdW5zaWduZWQgY2hhciogbWFzayA9ICh1bnNpZ25lZCBjaGFyKil1c2VyQ2h1bmstPkFs bG9jKEJMT0NLX1NJWkUpOworICAgIGlmIChOVUxMID09IG1hc2spIHsKKyAgICAgICAgQ1JBU0go KTsKKyAgICB9CisgICAgdWludHB0cl90IGFkZHJlc3MgPSByZWludGVycHJldF9jYXN0PHVpbnRw dHJfdD4obWFzayk7CisKICAgICBtZW1zZXQocmVpbnRlcnByZXRfY2FzdDx2b2lkKj4oYWRkcmVz cyksIDAsIEJMT0NLX1NJWkUpOworICAgIAogI2VsaWYgUExBVEZPUk0oV0lOX09TKQogICAgICAv LyB3aW5kb3dzIHZpcnR1YWwgYWRkcmVzcyBncmFudWxhcml0eSBpcyBuYXR1cmFsbHkgNjRrCiAg ICAgTFBWT0lEIGFkZHJlc3MgPSBWaXJ0dWFsQWxsb2MoTlVMTCwgQkxPQ0tfU0laRSwgTUVNX0NP TU1JVCB8IE1FTV9SRVNFUlZFLCBQQUdFX1JFQURXUklURSk7CkBAIC0yMzEsNyArMjcwLDcgQEAN CiAjaWYgUExBVEZPUk0oREFSV0lOKSAgICAKICAgICB2bV9kZWFsbG9jYXRlKGN1cnJlbnRfdGFz aygpLCByZWludGVycHJldF9jYXN0PHZtX2FkZHJlc3NfdD4oYmxvY2spLCBCTE9DS19TSVpFKTsK ICNlbGlmIFBMQVRGT1JNKFNZTUJJQU4pCi0gICAgZmFzdEZyZWUoYmxvY2spOworICAgIHVzZXJD aHVuay0+RnJlZShyZWludGVycHJldF9jYXN0PFRBbnkgKj4oYmxvY2spKTsKICNlbGlmIFBMQVRG T1JNKFdJTl9PUykKICAgICBWaXJ0dWFsRnJlZShibG9jaywgMCwgTUVNX1JFTEVBU0UpOwogI2Vs aWYgSEFWRShQT1NJWF9NRU1BTElHTikKQEAgLTM5NSw2ICs0MzQsMTYgQEANCiAjaWYgUExBVEZP Uk0oREFSV0lOKQogICAgIHB0aHJlYWRfdCB0aHJlYWQgPSBwdGhyZWFkX3NlbGYoKTsKICAgICBy ZXR1cm4gcHRocmVhZF9nZXRfc3RhY2thZGRyX25wKHRocmVhZCk7CisjZWxpZiBQTEFURk9STShT WU1CSUFOKQorICAgIC8vIE5lZWRzIHRvIGJlIHBvc2l0aW9uZWQgYmVmb3JlIG90aGVyIHBsYXRm b3JtcyB0byBhdm9pZCBwb3RlbnRpYWwgYW1iaWd1aXRpZXMKKyAgICBzdGF0aWMgdm9pZCogc3Rh Y2tCYXNlID0gMDsKKyAgICBpZiAoc3RhY2tCYXNlID09IDApIHsKKyAgICAgICAgVFRocmVhZFN0 YWNrSW5mbyBpbmZvOworICAgICAgICBSVGhyZWFkIHRocmVhZDsKKyAgICAgICAgdGhyZWFkLlN0 YWNrSW5mbyhpbmZvKTsKKyAgICAgICAgc3RhY2tCYXNlID0gKHZvaWQqKWluZm8uaUJhc2U7Cisg ICAgfQorICAgIHJldHVybiAodm9pZCopc3RhY2tCYXNlOwogI2VsaWYgUExBVEZPUk0oV0lOX09T KSAmJiBQTEFURk9STShYODYpICYmIENPTVBJTEVSKE1TVkMpCiAgICAgLy8gb2Zmc2V0IDB4MTgg ZnJvbSB0aGUgRlMgc2VnbWVudCByZWdpc3RlciBnaXZlcyBhIHBvaW50ZXIgdG8KICAgICAvLyB0 aGUgdGhyZWFkIGluZm9ybWF0aW9uIGJsb2NrIGZvciB0aGUgY3VycmVudCB0aHJlYWQKQEAgLTQ0 NiwxNSArNDk1LDYgQEANCiAgICAgICAgIHN0YWNrVGhyZWFkID0gdGhyZWFkOwogICAgIH0KICAg ICByZXR1cm4gc3RhdGljX2Nhc3Q8Y2hhcio+KHN0YWNrQmFzZSkgKyBzdGFja1NpemU7Ci0jZWxp ZiBQTEFURk9STShTWU1CSUFOKQotICAgIHN0YXRpYyB2b2lkKiBzdGFja0Jhc2UgPSAwOwotICAg IGlmIChzdGFja0Jhc2UgPT0gMCkgewotICAgICAgICBUVGhyZWFkU3RhY2tJbmZvIGluZm87Ci0g ICAgICAgIFJUaHJlYWQgdGhyZWFkOwotICAgICAgICB0aHJlYWQuU3RhY2tJbmZvKGluZm8pOwot ICAgICAgICBzdGFja0Jhc2UgPSAodm9pZCopaW5mby5pQmFzZTsKLSAgICB9Ci0gICAgcmV0dXJu ICh2b2lkKilzdGFja0Jhc2U7CiAjZWxzZQogI2Vycm9yIE5lZWQgYSB3YXkgdG8gZ2V0IHRoZSBz dGFjayBiYXNlIG9uIHRoaXMgcGxhdGZvcm0KICNlbmRpZgo= 32409 2009-07-07 18:26:23 -0700 2009-07-23 07:25:01 -0700 Update 2 of patch file for bug 24540 patch_update_2_24540.txt text/plain 4175 norbert.leser SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDQ1NjAz KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDktMDct MDcgIE5vcmJlcnQgTGVzZXIgIDxub3JiZXJ0Lmxlc2VyQG5va2lhLmNvbT4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBGaXggZm9yIG1pc3NpbmcgbW1h cCBmZWF0dXJlcyBpbiBTeW1iaWFuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yNDU0MAorCisgICAgICAgIEZpeCwgY29uZGl0aW9uYWxseSBmb3IgUExB VEZPUk0oU1lNQklBTiksIGFzIGFuIGFsdGVybmF0aXZlIAorICAgICAgICB0byBtaXNzaW5nIHN1 cHBvcnQgZm9yIHRoZSBNQVBfQU5PTiBwcm9wZXJ0eSBmbGFnIGluIG1tYXAuIAorICAgICAgICBJ dCB1dGlsaXplcyBTeW1iaWFuIHNwZWNpZmljIG1lbW9yeSBhbGxvY2F0aW9uIGZlYXR1cmVzLgor CisgICAgICAgICogSmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2xsZWN0b3IuY3BwCis6CisKIDIw MDktMDctMDMgIEphbiBNaWNoYWVsIEFsb256byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgWGFuIExvcGV6IGFuZCBHdXN0YXZvIE5vcm9uaGEuCkluZGV4OiBK YXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvbGxlY3Rvci5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNj cmlwdENvcmUvcnVudGltZS9Db2xsZWN0b3IuY3BwCShyZXZpc2lvbiA0NTU5MCkKKysrIEphdmFT Y3JpcHRDb3JlL3J1bnRpbWUvQ29sbGVjdG9yLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDgsNiAr NDgsMTEgQEAKICNpbmNsdWRlIDxtYWNoL3RocmVhZF9hY3QuaD4KICNpbmNsdWRlIDxtYWNoL3Zt X21hcC5oPgogCisjZWxpZiBQTEFURk9STShTWU1CSUFOKQorI2luY2x1ZGUgPGUzMnN0ZC5oPgor I2luY2x1ZGUgPGUzMmNtbi5oPgorI2luY2x1ZGUgPHVuaXN0ZC5oPgorCiAjZWxpZiBQTEFURk9S TShXSU5fT1MpCiAKICNpbmNsdWRlIDx3aW5kb3dzLmg+CkBAIC04Nyw2ICs5MiwxMSBAQCBjb25z dCBzaXplX3QgQUxMT0NBVElPTlNfUEVSX0NPTExFQ1RJT04gCiAvLyBhIFBJQyBicmFuY2ggaW4g TWFjaC1PIGJpbmFyaWVzLCBzZWUgPHJkYXI6Ly9wcm9ibGVtLzU5NzEzOTE+LgogI2RlZmluZSBN SU5fQVJSQVlfU0laRSAoc3RhdGljX2Nhc3Q8c2l6ZV90PigxNCkpCiAKKyNpZiBQTEFURk9STShT WU1CSUFOKQorICAgIGNvbnN0IHNpemVfdCBNQVhfTlVNX0JMT0NLUyA9IDI1NjsgLy8gTWF4IHNp emUgb2YgY29sbGVjdG9yIGhlYXAgc2V0IHRvIDE2IE1CCisgICAgc3RhdGljIFJIZWFwKiB1c2Vy Q2h1bmsgPSBOVUxMOworI2VuZGlmCisgICAgCiBzdGF0aWMgdm9pZCBmcmVlSGVhcChDb2xsZWN0 b3JIZWFwKik7CiAKICNpZiBFTkFCTEUoSlNDX01VTFRJUExFX1RIUkVBRFMpCkBAIC0xMjgsNiAr MTM4LDI2IEBAIEhlYXA6OkhlYXAoSlNHbG9iYWxEYXRhKiBnbG9iYWxEYXRhKQogewogICAgIEFT U0VSVChnbG9iYWxEYXRhKTsKIAorI2lmIFBMQVRGT1JNKFNZTUJJQU4pCisgICAgLy8gU3ltYmlh biBPcGVuQyBzdXBwb3J0cyBtbWFwIGJ1dCBjdXJyZW50bHkgbm90IHRoZSBNQVBfQU5PTiBmbGFn LgorICAgIC8vIFVzaW5nIGZhc3RNYWxsb2MoKSBkb2VzIG5vdCBwcm9wZXJseSBhbGlnbiBibG9j a3Mgb24gNjRrIGJvdW5kYXJpZXMKKyAgICAvLyBhbmQgcHJldmlvdXMgaW1wbGVtZW50YXRpb24g d2FzIGZsYXdlZC9pbmNvbXBsZXRlLgorICAgIC8vIFVzZXJIZWFwOjpDaHVua0hlYXAgYWxsb3dz IGFsbG9jYXRpb24gb2YgY29udGludW91cyBtZW1vcnkgYW5kIHNwZWNpZmljYXRpb24KKyAgICAv LyBvZiBhbGlnbm1lbnQgdmFsdWUgZm9yIChzeW1iaWFuKSBjZWxscyB3aXRoaW4gdGhhdCBoZWFw LgorICAgIC8vCisgICAgLy8gQ2xhcmlmaWNhdGlvbiBhbmQgbWFwcGluZyBvZiB0ZXJtaW5vbG9n eToKKyAgICAvLyBSSGVhcCAoY3JlYXRlZCBieSBVc2VySGVhcDo6Q2h1bmtIZWFwIGJlbG93KSBp cyBjb250aW51b3MgbWVtb3J5IGNodW5rLAorICAgIC8vIHdoaWNoIGNhbiBkeW5hbWljYWxseSBn cm93IHVwIHRvIDggTUIsCisgICAgLy8gdGhhdCBob2xkcyBhbGwgQ29sbGVjdG9yQmxvY2tzIG9m IHRoaXMgc2Vzc2lvbiAoc3RhdGljKS4KKyAgICAvLyBFYWNoIHN5bWJpYW4gY2VsbCB3aXRoaW4g UkhlYXAgbWFwcyB0byBhIDY0a2IgYWxpZ25lZCBDb2xsZWN0b3JCbG9jay4KKyAgICAvLyBKU0Nl bGwgb2JqZWN0cyBhcmUgbWFpbnRhaW5lZCBhcyB1c3VhbCB3aXRoaW4gQ29sbGVjdG9yQmxvY2tz LgorICAgIGlmICghdXNlckNodW5rKSB7CisgICAgICAgIHVzZXJDaHVuayA9IFVzZXJIZWFwOjpD aHVua0hlYXAoMCwgMCwgTUFYX05VTV9CTE9DS1MgKiBCTE9DS19TSVpFLCBCTE9DS19TSVpFLCBC TE9DS19TSVpFKTsKKyAgICAgICAgaWYgKCF1c2VyQ2h1bmspCisgICAgICAgICAgICBDUkFTSCgp OworICAgIH0KKyNlbmRpZiAvLyBQTEFURk9STShTWU1CSUFOKQorICAgIAogICAgIG1lbXNldCgm cHJpbWFyeUhlYXAsIDAsIHNpemVvZihDb2xsZWN0b3JIZWFwKSk7CiAgICAgbWVtc2V0KCZudW1i ZXJIZWFwLCAwLCBzaXplb2YoQ29sbGVjdG9ySGVhcCkpOwogfQpAQCAtMTg0LDEwICsyMTQsMTcg QEAgc3RhdGljIE5FVkVSX0lOTElORSBDb2xsZWN0b3JCbG9jayogYWxsbwogICAgIHZtX2FkZHJl c3NfdCBhZGRyZXNzID0gMDsKICAgICAvLyBGSVhNRTogdGFnIHRoZSByZWdpb24gYXMgYSBKYXZh U2NyaXB0Q29yZSBoZWFwIHdoZW4gd2UgZ2V0IGEgcmVnaXN0ZXJlZCBWTSB0YWc6IDxyZGFyOi8v cHJvYmxlbS82MDU0Nzg4Pi4KICAgICB2bV9tYXAoY3VycmVudF90YXNrKCksICZhZGRyZXNzLCBC TE9DS19TSVpFLCBCTE9DS19PRkZTRVRfTUFTSywgVk1fRkxBR1NfQU5ZV0hFUkUgfCBWTV9UQUdf Rk9SX0NPTExFQ1RPUl9NRU1PUlksIE1FTU9SWV9PQkpFQ1RfTlVMTCwgMCwgRkFMU0UsIFZNX1BS T1RfREVGQVVMVCwgVk1fUFJPVF9ERUZBVUxULCBWTV9JTkhFUklUX0RFRkFVTFQpOworCiAjZWxp ZiBQTEFURk9STShTWU1CSUFOKQotICAgIC8vIG5vIG1lbW9yeSBtYXAgaW4gc3ltYmlhbiwgbmVl ZCB0byBoYWNrIHdpdGggZmFzdE1hbGxvYwotICAgIHZvaWQqIGFkZHJlc3MgPSBmYXN0TWFsbG9j KEJMT0NLX1NJWkUpOworCisgICAgLy8gQWxsb2NhdGUgYSA2NCBrYiBhbGlnbmVkIENvbGxlY3Rv ckJsb2NrCisgICAgdW5zaWduZWQgY2hhciogbWFzayA9IHJlaW50ZXJwcmV0X2Nhc3Q8dW5zaWdu ZWQgY2hhcio+KHVzZXJDaHVuay0+QWxsb2MoQkxPQ0tfU0laRSkpOworICAgIGlmICghbWFzaykK KyAgICAgICAgQ1JBU0goKTsKKyAgICB1aW50cHRyX3QgYWRkcmVzcyA9IHJlaW50ZXJwcmV0X2Nh c3Q8dWludHB0cl90PihtYXNrKTsKKwogICAgIG1lbXNldChyZWludGVycHJldF9jYXN0PHZvaWQq PihhZGRyZXNzKSwgMCwgQkxPQ0tfU0laRSk7CisgICAgCiAjZWxpZiBQTEFURk9STShXSU5fT1Mp CiAgICAgIC8vIHdpbmRvd3MgdmlydHVhbCBhZGRyZXNzIGdyYW51bGFyaXR5IGlzIG5hdHVyYWxs eSA2NGsKICAgICBMUFZPSUQgYWRkcmVzcyA9IFZpcnR1YWxBbGxvYyhOVUxMLCBCTE9DS19TSVpF LCBNRU1fQ09NTUlUIHwgTUVNX1JFU0VSVkUsIFBBR0VfUkVBRFdSSVRFKTsKQEAgLTIzMSw3ICsy NjgsNyBAQCBzdGF0aWMgdm9pZCBmcmVlQmxvY2soQ29sbGVjdG9yQmxvY2sqIGJsCiAjaWYgUExB VEZPUk0oREFSV0lOKSAgICAKICAgICB2bV9kZWFsbG9jYXRlKGN1cnJlbnRfdGFzaygpLCByZWlu dGVycHJldF9jYXN0PHZtX2FkZHJlc3NfdD4oYmxvY2spLCBCTE9DS19TSVpFKTsKICNlbGlmIFBM QVRGT1JNKFNZTUJJQU4pCi0gICAgZmFzdEZyZWUoYmxvY2spOworICAgIHVzZXJDaHVuay0+RnJl ZShyZWludGVycHJldF9jYXN0PFRBbnkqPihibG9jaykpOwogI2VsaWYgUExBVEZPUk0oV0lOX09T KQogICAgIFZpcnR1YWxGcmVlKGJsb2NrLCAwLCBNRU1fUkVMRUFTRSk7CiAjZWxpZiBIQVZFKFBP U0lYX01FTUFMSUdOKQo=