107183 2013-01-17 14:56:43 -0800 [chromium] Add WebDiscardableMemory to platform 2013-01-23 14:51:42 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 nduca nduca abarth avi cc-bugs dglazkov fishd hclam jamesr levin+threading qinmin tkent+wkapi webkit.review.bot oldest_to_newest 809835 0 nduca 2013-01-17 14:56:43 -0800 [chromium] Add WebDiscardableMemory to platform 809837 1 183289 nduca 2013-01-17 14:58:34 -0800 Created attachment 183289 Patch 809849 2 webkit.review.bot 2013-01-17 15:04:54 -0800 Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, fishd@chromium.org, jamesr@chromium.org or tkent@chromium.org before submitting, as this patch contains changes to the Chromium public API. See also https://trac.webkit.org/wiki/ChromiumWebKitAPI. 809851 3 183289 hclam 2013-01-17 15:07:13 -0800 Comment on attachment 183289 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:45 > + dst->lockPixels(); allocateDisablecardMemory() and lockPixels() are separated. Is it possible that right after allocation the memory is discarded? Should allocateAndLock be one operation? 809862 4 183289 jamesr 2013-01-17 15:16:32 -0800 Comment on attachment 183289 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review I think we will benefit from massaging the WebDiscardableMemory API a bit. Now that I've had a bit of time to think about this API it'll mean some extra kernel trips on every allocation, which probably isn't great. What's the minimum practical allocation size for ashmem? Probably at least a page, right? Do we want to avoid it for small allocations? Do we have any idea of what the allocation size distribution looks like for this path? Sounds like a job for histograms to me. > Source/Platform/chromium/public/Platform.h:237 > + // Allocate discardable memory for caching decoded images. the "caching decoding images" part isn't really part of the API, it's one potential use case. Better would be describing what this call does (attempt to allocate blah blah blah). also document the initial state of the WebDiscardableMemory chunk - is it pinned, or unpinned? > Source/Platform/chromium/public/Platform.h:240 > // Message Ports ------------------------------------------------------- keep 2 blank lines between sections > Source/Platform/chromium/public/WebDiscardableMemory.h:8 > + * * Redistributions of source code must retain the above copyright 2-clause for new files (like you have in the .cpp) > Source/Platform/chromium/public/WebDiscardableMemory.h:36 > +// A memory object that can be automatically purge by system when it is typo "purge" -> "purged" include some sample code here of how to lock, use, and unlock memory correctly > Source/Platform/chromium/public/WebDiscardableMemory.h:42 > + // Lock the memory so it will not be released. Returns 0 on failure. can you expand on what "failure" means? i think with pretty much every underlying implementation evictable memory will be initially resident and then later marked as evictable. this doesn't match up all that well with this API since the only way to know where block is is to call lock(), which means we're going to force every caller to do an extra unpin/pin on initial allocation :(. also lock/unlock are a little bit too close to synchronization, which isn't really what this is about. maybe we could rejigger it to have a void* getter, bool pin() and unpin()? > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:39 > + DiscardablePixelRef* pixelRef = new DiscardablePixelRef(ctable, adoptPtr(new SkMutex())); do we really need atomic inc/dec of the refcount for this object? if not, instead of allocating a mutex per object can we just call setPreLocked()? also can we patch skia to use atomic inc/dec instead of a Mutex for atomic refcounting? seriously! 809864 5 qinmin 2013-01-17 15:17:11 -0800 (In reply to comment #3) > (From update of attachment 183289 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review > > > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:45 > > + dst->lockPixels(); > > allocateDisablecardMemory() and lockPixels() are separated. Is it possible that right after allocation the memory is discarded? Should allocateAndLock be one operation? allocateDiscardableMemory will guarantee that the memory is pinned if successful, so the memory will not be discarded. 809873 6 qinmin 2013-01-17 15:22:32 -0800 (In reply to comment #4) > (From update of attachment 183289 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review > > I think we will benefit from massaging the WebDiscardableMemory API a bit. Now that I've had a bit of time to think about this API it'll mean some extra kernel trips on every allocation, which probably isn't great. > > What's the minimum practical allocation size for ashmem? Probably at least a page, right? Do we want to avoid it for small allocations? Do we have any idea of what the allocation size distribution looks like for this path? Sounds like a job for histograms to me. > > > Source/Platform/chromium/public/Platform.h:237 > > + // Allocate discardable memory for caching decoded images. > > the "caching decoding images" part isn't really part of the API, it's one potential use case. Better would be describing what this call does (attempt to allocate blah blah blah). > > also document the initial state of the WebDiscardableMemory chunk - is it pinned, or unpinned? > > > Source/Platform/chromium/public/Platform.h:240 > > // Message Ports ------------------------------------------------------- > > keep 2 blank lines between sections > > > Source/Platform/chromium/public/WebDiscardableMemory.h:8 > > + * * Redistributions of source code must retain the above copyright > > 2-clause for new files (like you have in the .cpp) > > > Source/Platform/chromium/public/WebDiscardableMemory.h:36 > > +// A memory object that can be automatically purge by system when it is > > typo "purge" -> "purged" > > include some sample code here of how to lock, use, and unlock memory correctly > > > Source/Platform/chromium/public/WebDiscardableMemory.h:42 > > + // Lock the memory so it will not be released. Returns 0 on failure. > > can you expand on what "failure" means? > > i think with pretty much every underlying implementation evictable memory will be initially resident and then later marked as evictable. this doesn't match up all that well with this API since the only way to know where block is is to call lock(), which means we're going to force every caller to do an extra unpin/pin on initial allocation :(. also lock/unlock are a little bit too close to synchronization, which isn't really what this is about. maybe we could rejigger it to have a void* getter, bool pin() and unpin()? The initial allocation will pin the memory, so there is no need to call pin after it. > > > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:39 > > + DiscardablePixelRef* pixelRef = new DiscardablePixelRef(ctable, adoptPtr(new SkMutex())); > > do we really need atomic inc/dec of the refcount for this object? if not, instead of allocating a mutex per object can we just call setPreLocked()? We cannot use setPrelocked（）. SetPrelocked() will ignire all the onLockedPixels() and onUnlockPixels(). > > also can we patch skia to use atomic inc/dec instead of a Mutex for atomic refcounting? seriously! 809878 7 hclam 2013-01-17 15:23:41 -0800 (In reply to comment #5) > (In reply to comment #3) > > (From update of attachment 183289 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review > > > > > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:45 > > > + dst->lockPixels(); > > > > allocateDisablecardMemory() and lockPixels() are separated. Is it possible that right after allocation the memory is discarded? Should allocateAndLock be one operation? > > allocateDiscardableMemory will guarantee that the memory is pinned if successful, so the memory will not be discarded. How do you unpin it then? There must be a balancing pin and unpin. 809882 8 qinmin 2013-01-17 15:25:53 -0800 (In reply to comment #7) > (In reply to comment #5) > > (In reply to comment #3) > > > (From update of attachment 183289 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review > > > > > > > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:45 > > > > + dst->lockPixels(); > > > > > > allocateDisablecardMemory() and lockPixels() are separated. Is it possible that right after allocation the memory is discarded? Should allocateAndLock be one operation? > > > > allocateDiscardableMemory will guarantee that the memory is pinned if successful, so the memory will not be discarded. > > How do you unpin it then? There must be a balancing pin and unpin. When u delete DiscardableMemory, it will be unpinned. Or otherwise, call Unpin（） specifically. Calling Pin() when memory is pinned is a no-op 809885 9 hclam 2013-01-17 15:27:44 -0800 (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #5) > > > (In reply to comment #3) > > > > (From update of attachment 183289 [details] [details] [details] [details]) > > > > View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review > > > > > > > > > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:45 > > > > > + dst->lockPixels(); > > > > > > > > allocateDisablecardMemory() and lockPixels() are separated. Is it possible that right after allocation the memory is discarded? Should allocateAndLock be one operation? > > > > > > allocateDiscardableMemory will guarantee that the memory is pinned if successful, so the memory will not be discarded. > > > > How do you unpin it then? There must be a balancing pin and unpin. > > When u delete DiscardableMemory, it will be unpinned. Or otherwise, call Unpin（） specifically. Calling Pin() when memory is pinned is a no-op If you call unpin only when you delete DiscardableMemory then how does it different than regular memory? I thought the idea is to pin it only when we're using the bitmap for drawing / decoding. 809888 10 qinmin 2013-01-17 15:33:09 -0800 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > (In reply to comment #5) > > > > (In reply to comment #3) > > > > > (From update of attachment 183289 [details] [details] [details] [details] [details]) > > > > > View in context: https://bugs.webkit.org/attachment.cgi?id=183289&action=review > > > > > > > > > > > Source/WebCore/platform/graphics/chromium/DiscardablePixelRef.cpp:45 > > > > > > + dst->lockPixels(); > > > > > > > > > > allocateDisablecardMemory() and lockPixels() are separated. Is it possible that right after allocation the memory is discarded? Should allocateAndLock be one operation? > > > > > > > > allocateDiscardableMemory will guarantee that the memory is pinned if successful, so the memory will not be discarded. > > > > > > How do you unpin it then? There must be a balancing pin and unpin. > > > > When u delete DiscardableMemory, it will be unpinned. Or otherwise, call Unpin（） specifically. Calling Pin() when memory is pinned is a no-op > > If you call unpin only when you delete DiscardableMemory then how does it different than regular memory? I thought the idea is to pin it only when we're using the bitmap for drawing / decoding. When we call skpixelRef::OnLockPixels(), it will pin the DiscardableMemory, when OnUnlockPixels() gets called, it will unpin the memory. After the intial allocation, the first pin is a noop. So the first unpin will unpin the memory 809926 11 nduca 2013-01-17 16:16:22 -0800 I'm sorry, the WebCore changes were included in error. I want to first get on the same page about WebDiscardable. New changes uploaded to try to accomodate everyone's concerns. 809927 12 183306 nduca 2013-01-17 16:16:51 -0800 Created attachment 183306 Patch 809929 13 183306 hclam 2013-01-17 16:18:45 -0800 Comment on attachment 183306 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183306&action=review > Source/Platform/chromium/public/Platform.h:-160 > - nit: Don't remove empty lines. 809930 14 183306 hclam 2013-01-17 16:19:02 -0800 Comment on attachment 183306 Patch The interface looks good to me. 809959 15 nduca 2013-01-17 16:42:03 -0800 Whitespace deletion fixed. 813343 16 nduca 2013-01-22 13:18:52 -0800 Ping 813468 17 183306 jamesr 2013-01-22 15:27:17 -0800 Comment on attachment 183306 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183306&action=review I think a few of these APIs aren't needed, but Platform::allocateAndLock...() and Platform/..../WebDiscardableMemory.h look good except for some typos and formatting issues. > Source/Platform/chromium/public/Platform.h:238 > + // Determine if the underlying platform supports discardable memory > + virtual bool discardableMemorySupported() const { return false; } I don't think this adds much value. If the platform doesn't support discardable memory, allocateAndLock...() will return 0 and I can't think of a case where the caller would want to distinguish between the platform not supporting discardable memory and the specific call failing. > Source/Platform/chromium/public/Platform.h:244 > + // Discardable memory is often based on an underlying kernel paging system. > + // Thus, allocations below a certain size are often counterproductive. This > + // returns the suggested allocation size in bytes for discardable memory > + // allocations. > + virtual size_t suggestedMinimumDiscardableMemoryAllocationSizeInBytes() const { return 0; } I'm not sure how this would be implemented in a way that's intelligent, since the implementation of this function has no idea what the caller wants to do. If we want to set a hard floor the implementation can just return 0 from allocateAndLock...() for certain sizes. > Source/Platform/chromium/public/WebDiscardableMemory.h:37 > + // Locks the memory, prevent it from being discarded. Once locked. you may i think conventionally these sort of block comments are placed before the class declaration > Source/Platform/chromium/public/WebDiscardableMemory.h:40 > + // Lock() may return false, indicating that the underlying memory was s/Lock()/lock()/ > Source/Platform/chromium/public/WebDiscardableMemory.h:53 > + // delete mem; // Make sure to destroy it. Its never going to come back. s/Its/It's/ > Source/Platform/chromium/public/WebDiscardableMemory.h:67 > + // Unlock the memory so that it can be purged by the system. Must be called > + // after every successful lock call. is deleting the WebDiscardableMemory while locked valid? If so, we should document as such somewhere. 813529 18 qinmin 2013-01-22 16:23:43 -0800 (In reply to comment #17) > (From update of attachment 183306 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=183306&action=review > > I think a few of these APIs aren't needed, but Platform::allocateAndLock...() and Platform/..../WebDiscardableMemory.h look good except for some typos and formatting issues. > > > Source/Platform/chromium/public/Platform.h:238 > > + // Determine if the underlying platform supports discardable memory > > + virtual bool discardableMemorySupported() const { return false; } > > I don't think this adds much value. If the platform doesn't support discardable memory, allocateAndLock...() will return 0 and I can't think of a case where the caller would want to distinguish between the platform not supporting discardable memory and the specific call failing. Do you mean we need to call allocate twice each time we allocate memory for an image? First call to allocate DiscardableMemory will fail, and the 2nd time we will fallback to SkMallocPixels. > > > Source/Platform/chromium/public/Platform.h:244 > > + // Discardable memory is often based on an underlying kernel paging system. > > + // Thus, allocations below a certain size are often counterproductive. This > > + // returns the suggested allocation size in bytes for discardable memory > > + // allocations. > > + virtual size_t suggestedMinimumDiscardableMemoryAllocationSizeInBytes() const { return 0; } > > I'm not sure how this would be implemented in a way that's intelligent, since the implementation of this function has no idea what the caller wants to do. If we want to set a hard floor the implementation can just return 0 from allocateAndLock...() for certain sizes. > > > Source/Platform/chromium/public/WebDiscardableMemory.h:37 > > + // Locks the memory, prevent it from being discarded. Once locked. you may > > i think conventionally these sort of block comments are placed before the class declaration > > > Source/Platform/chromium/public/WebDiscardableMemory.h:40 > > + // Lock() may return false, indicating that the underlying memory was > > s/Lock()/lock()/ > > > Source/Platform/chromium/public/WebDiscardableMemory.h:53 > > + // delete mem; // Make sure to destroy it. Its never going to come back. > > s/Its/It's/ > > > Source/Platform/chromium/public/WebDiscardableMemory.h:67 > > + // Unlock the memory so that it can be purged by the system. Must be called > > + // after every successful lock call. > > is deleting the WebDiscardableMemory while locked valid? If so, we should document as such somewhere. 813539 19 jamesr 2013-01-22 16:30:11 -0800 (In reply to comment #18) > (In reply to comment #17) > > (From update of attachment 183306 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=183306&action=review > > > > I think a few of these APIs aren't needed, but Platform::allocateAndLock...() and Platform/..../WebDiscardableMemory.h look good except for some typos and formatting issues. > > > > > Source/Platform/chromium/public/Platform.h:238 > > > + // Determine if the underlying platform supports discardable memory > > > + virtual bool discardableMemorySupported() const { return false; } > > > > I don't think this adds much value. If the platform doesn't support discardable memory, allocateAndLock...() will return 0 and I can't think of a case where the caller would want to distinguish between the platform not supporting discardable memory and the specific call failing. > > Do you mean we need to call allocate twice each time we allocate memory for an image? First call to allocate DiscardableMemory will fail, and the 2nd time we will fallback to SkMallocPixels. What's the alternative? I would think it'd be something like: if (Platform::current()->discardableMemorySupported()) { Platform::current()->allocateAndLock...(); } else { malloc(...) } which is the same number of virtual calls as if (WebDiscardableMemory* memory = Platform::current()->allocateAndLock...()) { // use memory } else { malloc(...) } 813541 20 jamesr 2013-01-22 16:31:30 -0800 Even if you could check for platform support without the virtual call I think you'd still need the fallback path for cases where the ashmem call fails but we aren't actually OOM. 813678 21 184105 nduca 2013-01-22 19:10:55 -0800 Created attachment 184105 Patch for landing 813687 22 nduca 2013-01-22 19:30:31 -0800 Min, to use this, stop thinking of having a mode for discadable memory. Always use discardable memory, and if the alloc fails, then create an skbitmap with a regular malloc. E.g.: WebDiscardable* disc = Platform::current()->allocateAndLock(...); if(!disc) { bitmap->setPixelelRef(pixelRef that wraps and owns void*) } else { bitmap->setPixelelRef(pixelRef that wraps webdiscardable) } And, update the memory managment policy to just track bytes allocated against each type. E.g. bytes_of_discardable , bytes_of_non_discardable. 813693 23 184105 webkit.review.bot 2013-01-22 19:38:32 -0800 Comment on attachment 184105 Patch for landing Clearing flags on attachment: 184105 Committed r140499: <http://trac.webkit.org/changeset/140499> 813694 24 webkit.review.bot 2013-01-22 19:38:37 -0800 All reviewed patches have been landed. Closing bug. 813707 25 qinmin 2013-01-22 19:54:14 -0800 (In reply to comment #20) > Even if you could check for platform support without the virtual call I think you'd still need the fallback path for cases where the ashmem call fails but we aren't actually OOM. One problem is that if there are no DiscardableMemory on the platform, the image cache will use 32MB physical memory. However, with discardableMemory, the cache size limit should be gone, but we should have a file descriptor limit. Removing this flag will make us unaware which rule we should use when doing the cache pruning 813710 26 nduca 2013-01-22 20:01:25 -0800 I still think we can do it. The alloc discardable should fail, or we should have some reaosonable limit on discardable-backed cache entries. We should then either back with malloc memory, or evict old discardables when we're at the limit. 813720 27 jamesr 2013-01-22 20:13:48 -0800 (In reply to comment #25) > (In reply to comment #20) > > Even if you could check for platform support without the virtual call I think you'd still need the fallback path for cases where the ashmem call fails but we aren't actually OOM. > > > One problem is that if there are no DiscardableMemory on the platform, the image cache will use 32MB physical memory. > However, with discardableMemory, the cache size limit should be gone, but we should have a file descriptor limit. > Removing this flag will make us unaware which rule we should use when doing the cache pruning Just keep track of how many active discardable memory instances you have and limit that. 814621 28 avi 2013-01-23 14:17:31 -0800 Out of curiosity, how does this relate to WebCore/platform/PurgeableBuffer.h ? This wraps it? 814674 29 jamesr 2013-01-23 14:51:42 -0800 (In reply to comment #28) > Out of curiosity, how does this relate to WebCore/platform/PurgeableBuffer.h ? This wraps it? No, this wraps base::DiscardableMemory. WebCore/platform/PurgeableBuffer appears to only be implemented on mac. In chromium, we could implement WebCore/platform/PurgeableBuffer on top of this interface if that made sense. I'm not sure how things like PurgePriority would map in that context. 183289 2013-01-17 14:58:34 -0800 2013-01-17 16:16:48 -0800 Patch bug-107183-20130117145534.patch text/plain 12955 nduca U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5OTUwCmRpZmYgLS1naXQgYS9Tb3VyY2UvUGxhdGZvcm0v Q2hhbmdlTG9nIGIvU291cmNlL1BsYXRmb3JtL0NoYW5nZUxvZwppbmRleCBmODlhMmE4YjcyNjA1 NTI5MGNkZmE3MmM0NjMzMzUxZDg5NjJhMTdjLi5kMTI2ZTVjMTE5Y2U1YzY4ODFmMGJjMDgyNTYz NzZkMjQ4YzY5MDU0IDEwMDY0NAotLS0gYS9Tb3VyY2UvUGxhdGZvcm0vQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9QbGF0Zm9ybS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxMy0wMS0xNyAg TmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQg V2ViRGlzY2FyZGFibGVNZW1vcnkgdG8gcGxhdGZvcm0KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNzE4MworCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlYkRpc2NhcmRhYmxlIHByb3ZpZGVzIGEgd3JhcHBl ciBhcm91bmQgbWVtb3J5IHRoYXQgY2FuIGJlIHJlbGNhaW1lZCBieQorICAgICAgICB0aGUgdW5k ZXJseWluZyBrZXJuZWwuIFRoaXMgd2lsbCBiZSB1c2VkIGluIGEgZm9sbG93dXAgcGF0Y2ggaW4g dGhlIENocm9taXVtCisgICAgICAgIGltYWdlIGRlY29kaW5nIHN0b3JlIGZvciBkZWNvZGVkL3Jl c2l6ZWQgaW1hZ2VzLgorCisgICAgICAgICogUGxhdGZvcm0uZ3lwaToKKyAgICAgICAgKiBjaHJv bWl1bS9wdWJsaWMvUGxhdGZvcm0uaDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChQbGF0 Zm9ybSk6CisgICAgICAgIChXZWJLaXQ6OlBsYXRmb3JtOjphbGxvY2F0ZURpc2NhcmRhYmxlTWVt b3J5KToKKyAgICAgICAgKiBjaHJvbWl1bS9wdWJsaWMvV2ViRGlzY2FyZGFibGVNZW1vcnkuaDog QWRkZWQuCisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViRGlzY2FyZGFibGVNZW1vcnkp OgorICAgICAgICAoV2ViS2l0OjpXZWJEaXNjYXJkYWJsZU1lbW9yeTo6fldlYkRpc2NhcmRhYmxl TWVtb3J5KToKKwogMjAxMy0wMS0xMCAgVG9tbXkgV2lkZW5mbHljaHQgIDx0b21teXdAZ29vZ2xl LmNvbT4KIAogICAgICAgICBNZWRpYVN0cmVhbSBBUEk6IEFkZGluZyB0aGUgbmV3IGlkIGF0dHJp YnV0ZSB0byBNZWRpYVN0cmVhbSBhbmQgTWVkaWFTdHJlYW1UcmFjawpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGI2 YmE0MjI0OWQ1NTA5ZDYzZDhlNWEyOTdjNGUwODNlOGNjYjYwY2IuLmNiYmE5NDg3MWQyNTY2MDI4 ODIzNTI0Y2I2ZjNmYzc2NDY0MjI0ZDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAx My0wMS0xNyAgTmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9t aXVtXSBBZGQgV2ViRGlzY2FyZGFibGVNZW1vcnkgdG8gcGxhdGZvcm0KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNzE4MworCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlYkRpc2NhcmRhYmxlIHByb3ZpZGVz IGEgd3JhcHBlciBhcm91bmQgbWVtb3J5IHRoYXQgY2FuIGJlIHJlbGNhaW1lZCBieQorICAgICAg ICB0aGUgdW5kZXJseWluZyBrZXJuZWwuIFRoaXMgd2lsbCBiZSB1c2VkIGluIGEgZm9sbG93dXAg cGF0Y2ggaW4gdGhlIENocm9taXVtCisgICAgICAgIGltYWdlIGRlY29kaW5nIHN0b3JlIGZvciBk ZWNvZGVkL3Jlc2l6ZWQgaW1hZ2VzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vRGlzY2FyZGFibGVQaXhlbFJlZi5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6 CisgICAgICAgIChXZWJDb3JlOjpEaXNjYXJkYWJsZVBpeGVsUmVmQWxsb2NhdG9yOjphbGxvY1Bp eGVsUmVmKToKKyAgICAgICAgKFdlYkNvcmU6OkRpc2NhcmRhYmxlUGl4ZWxSZWY6OkRpc2NhcmRh YmxlUGl4ZWxSZWYpOgorICAgICAgICAoV2ViQ29yZTo6RGlzY2FyZGFibGVQaXhlbFJlZjo6fkRp c2NhcmRhYmxlUGl4ZWxSZWYpOgorICAgICAgICAoV2ViQ29yZTo6RGlzY2FyZGFibGVQaXhlbFJl Zjo6YWxsb2NEaXNjYXJkYWJsZU1lbW9yeSk6CisgICAgICAgIChXZWJDb3JlOjpEaXNjYXJkYWJs ZVBpeGVsUmVmOjpvbkxvY2tQaXhlbHMpOgorICAgICAgICAoV2ViQ29yZTo6RGlzY2FyZGFibGVQ aXhlbFJlZjo6b25VbmxvY2tQaXhlbHMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0Rpc2NhcmRhYmxlUGl4ZWxSZWYuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKERpc2NhcmRhYmxlUGl4ZWxSZWZBbGxvY2F0b3IpOgorICAgICAgICAoRGlzY2Fy ZGFibGVQaXhlbFJlZik6CisKIDIwMTMtMDEtMTYgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0 Lm9yZz4KIAogICAgICAgICBJbnRyb2R1Y2UgQmFja2dyb3VuZEhUTUxQYXJzZXIgZm9yIHBhcnNp bmcgSFRNTCBvbiBhIGJhY2tncm91bmQgdGhyZWFkCmRpZmYgLS1naXQgYS9Tb3VyY2UvUGxhdGZv cm0vUGxhdGZvcm0uZ3lwaSBiL1NvdXJjZS9QbGF0Zm9ybS9QbGF0Zm9ybS5neXBpCmluZGV4IDM0 MjM5NDM0NWVkY2Y2OTFlNzBjZmJiNDM2NjMxMjI5Mjk5NzA0YWUuLjk3NDlhNWMwNDJiMTM0NDUz YmQ2ZjM2OTQ0OGY1NGI3OTVjMDNkMmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9QbGF0Zm9ybS9QbGF0 Zm9ybS5neXBpCisrKyBiL1NvdXJjZS9QbGF0Zm9ybS9QbGF0Zm9ybS5neXBpCkBAIC01MSw2ICs1 MSw3IEBACiAgICAgICAgICAgICAnY2hyb21pdW0vcHVibGljL1dlYkNvb2tpZS5oJywKICAgICAg ICAgICAgICdjaHJvbWl1bS9wdWJsaWMvV2ViQ29va2llSmFyLmgnLAogICAgICAgICAgICAgJ2No cm9taXVtL3B1YmxpYy9XZWJEYXRhLmgnLAorICAgICAgICAgICAgJ2Nocm9taXVtL3B1YmxpYy9X ZWJEaXNjYXJkYWJsZU1lbW9yeS5oJywKICAgICAgICAgICAgICdjaHJvbWl1bS9wdWJsaWMvV2Vi RHJhZ0RhdGEuaCcsCiAgICAgICAgICAgICAnY2hyb21pdW0vcHVibGljL1dlYkV4dGVybmFsVGV4 dHVyZUxheWVyLmgnLAogICAgICAgICAgICAgJ2Nocm9taXVtL3B1YmxpYy9XZWJFeHRlcm5hbFRl eHR1cmVMYXllckNsaWVudC5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9QbGF0Zm9ybS9jaHJvbWl1 bS9wdWJsaWMvUGxhdGZvcm0uaCBiL1NvdXJjZS9QbGF0Zm9ybS9jaHJvbWl1bS9wdWJsaWMvUGxh dGZvcm0uaAppbmRleCA5NWNjYjk1YTVkNTIwM2E0N2VlYmM3ZWJhOTk0ZTI2YmJhODZmMjRmLi4z NGEyMjU1ZjE5NGFhMmY4ZDUzY2FiMjZiNDdhNjhhMTZhNmQ5ZDkwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvUGxhdGZvcm0vY2hyb21pdW0vcHVibGljL1BsYXRmb3JtLmgKKysrIGIvU291cmNlL1BsYXRm b3JtL2Nocm9taXVtL3B1YmxpYy9QbGF0Zm9ybS5oCkBAIC01MSw2ICs1MSw3IEBAIGNsYXNzIFdl YkJsb2JSZWdpc3RyeTsKIGNsYXNzIFdlYkNsaXBib2FyZDsKIGNsYXNzIFdlYkNvbXBvc2l0b3JT dXBwb3J0OwogY2xhc3MgV2ViQ29va2llSmFyOworY2xhc3MgV2ViRGlzY2FyZGFibGVNZW1vcnk7 CiBjbGFzcyBXZWJGaWxlU3lzdGVtOwogY2xhc3MgV2ViRmlsZVV0aWxpdGllczsKIGNsYXNzIFdl YkZsaW5nQW5pbWF0b3I7CkBAIC0xNTcsNyArMTU4LDYgQEAgcHVibGljOgogICAgIC8vIE11c3Qg cmV0dXJuIG5vbi1udWxsLgogICAgIHZpcnR1YWwgV2ViRmlsZVN5c3RlbSogZmlsZVN5c3RlbSgp IHsgcmV0dXJuIDA7IH0KIAotCiAgICAgLy8gR2FtZXBhZCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKICAgICB2aXJ0dWFsIHZv aWQgc2FtcGxlR2FtZXBhZHMoV2ViR2FtZXBhZHMmIGludG8pIHsgaW50by5sZW5ndGggPSAwOyB9 CkBAIC0yMzQsNiArMjM0LDggQEAgcHVibGljOgogICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUg c2l6ZSBoYXMgYmVlbiByZXBvcnRlZCwgb3IgZmFsc2Ugb3RoZXJ3aXNlLgogICAgIHZpcnR1YWwg Ym9vbCBtZW1vcnlBbGxvY2F0b3JXYXN0ZUluQnl0ZXMoc2l6ZV90KikgeyByZXR1cm4gZmFsc2U7 IH0KIAorICAgIC8vIEFsbG9jYXRlIGRpc2NhcmRhYmxlIG1lbW9yeSBmb3IgY2FjaGluZyBkZWNv ZGVkIGltYWdlcy4KKyAgICB2aXJ0dWFsIFdlYkRpc2NhcmRhYmxlTWVtb3J5KiBhbGxvY2F0ZURp c2NhcmRhYmxlTWVtb3J5KHNpemVfdCBieXRlcykgeyByZXR1cm4gMDsgfQogCiAgICAgLy8gTWVz c2FnZSBQb3J0cyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9QbGF0Zm9ybS9jaHJvbWl1bS9wdWJsaWMv V2ViRGlzY2FyZGFibGVNZW1vcnkuaCBiL1NvdXJjZS9QbGF0Zm9ybS9jaHJvbWl1bS9wdWJsaWMv V2ViRGlzY2FyZGFibGVNZW1vcnkuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yN2YxYzk4Y2NiYTE4MDhmMDgyMzcx NGI3MjU3ZDVlMzE4NGRhMDFlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1BsYXRmb3JtL2No cm9taXVtL3B1YmxpYy9XZWJEaXNjYXJkYWJsZU1lbW9yeS5oCkBAIC0wLDAgKzEsNTMgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAg KiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICog ZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBu b3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9y c2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0 aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9S UworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVS IE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAq IFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZu ZGVmIFdlYkRpc2NhcmRhYmxlTWVtb3J5X2gKKyNkZWZpbmUgV2ViRGlzY2FyZGFibGVNZW1vcnlf aAorCituYW1lc3BhY2UgV2ViS2l0IHsKKworLy8gQSBtZW1vcnkgb2JqZWN0IHRoYXQgY2FuIGJl IGF1dG9tYXRpY2FsbHkgcHVyZ2UgYnkgc3lzdGVtIHdoZW4gaXQgaXMKKy8vIHVubG9ja2VkLgor Y2xhc3MgV2ViRGlzY2FyZGFibGVNZW1vcnkgeworcHVibGljOgorICAgIHZpcnR1YWwgfldlYkRp c2NhcmRhYmxlTWVtb3J5KCkgeyB9CisKKyAgICAvLyBMb2NrIHRoZSBtZW1vcnkgc28gaXQgd2ls bCBub3QgYmUgcmVsZWFzZWQuIFJldHVybnMgMCBvbiBmYWlsdXJlLgorICAgIC8vIE5lc3RlZCBj YWxscyB0byB0aGlzIGZ1bmN0aW9uIGFyZSBub3QgYWxsb3dlZC4KKyAgICB2aXJ0dWFsIHZvaWQq IGxvY2soKSA9IDA7CisKKyAgICAvLyBVbmxvY2sgdGhlIG1lbW9yeSBzbyB0aGF0IGl0IGNhbiBi ZSBwdXJnZWQgYnkgdGhlIHN5c3RlbS4gTXVzdCBiZSBjYWxsZWQKKyAgICAvLyBhZnRlciBldmVy eSBzdWNjZXNzZnVsIGxvY2sgY2FsbC4KKyAgICB2aXJ0dWFsIHZvaWQgdW5sb2NrKCkgPSAwOwor fTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRGlzY2FyZGFibGVQaXhlbFJlZi5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EaXNjYXJkYWJs ZVBpeGVsUmVmLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mN2E2ZGNjNzY2MThkMzQxNmE4ZDYyMzQwYjQzY2I4 MjI0YWY2MmJlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vRGlzY2FyZGFibGVQaXhlbFJlZi5jcHAKQEAgLTAsMCArMSw4MiBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxMyBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09N UFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01Q VVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJEaXNjYXJkYWJsZVBpeGVs UmVmLmgiCisKKyNpbmNsdWRlIDxwdWJsaWMvUGxhdGZvcm0uaD4KKworbmFtZXNwYWNlIFdlYkNv cmUgeworCitib29sIERpc2NhcmRhYmxlUGl4ZWxSZWZBbGxvY2F0b3I6OmFsbG9jUGl4ZWxSZWYo U2tCaXRtYXAqIGRzdCwgU2tDb2xvclRhYmxlKiBjdGFibGUpCit7CisgICAgU2s2NCBzaXplID0g ZHN0LT5nZXRTaXplNjQoKTsKKyAgICBpZiAoc2l6ZS5pc05lZygpIHx8ICFzaXplLmlzMzIoKSkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgRGlzY2FyZGFibGVQaXhlbFJlZiogcGl4ZWxS ZWYgPSBuZXcgRGlzY2FyZGFibGVQaXhlbFJlZihjdGFibGUsIGFkb3B0UHRyKG5ldyBTa011dGV4 KCkpKTsKKyAgICBpZiAoIXBpeGVsUmVmLT5hbGxvY0Rpc2NhcmRhYmxlTWVtb3J5KHNpemUuZ2V0 MzIoKSkpIHsKKyAgICAgICAgZGVsZXRlIHBpeGVsUmVmOworICAgICAgICByZXR1cm4gZmFsc2U7 CisgICAgfQorICAgIGRzdC0+c2V0UGl4ZWxSZWYocGl4ZWxSZWYpLT51bnJlZigpOworICAgIGRz dC0+bG9ja1BpeGVscygpOworICAgIHJldHVybiB0cnVlOworfQorCitEaXNjYXJkYWJsZVBpeGVs UmVmOjpEaXNjYXJkYWJsZVBpeGVsUmVmKFNrQ29sb3JUYWJsZSogY3RhYmxlLCBQYXNzT3duUHRy PFNrTXV0ZXg+IG11dGV4KQorICAgIDogU2tQaXhlbFJlZihtdXRleC5nZXQoKSkKKyAgICAsIG1f Y29sb3JUYWJsZShjdGFibGUpCisgICAgLCBtX211dGV4KG11dGV4KQoreworICAgIG1fY29sb3JU YWJsZSA9IGN0YWJsZTsKK30KKworRGlzY2FyZGFibGVQaXhlbFJlZjo6fkRpc2NhcmRhYmxlUGl4 ZWxSZWYoKQoreworICAgIFNrU2FmZVVucmVmKG1fY29sb3JUYWJsZSk7Cit9CisKK2Jvb2wgRGlz Y2FyZGFibGVQaXhlbFJlZjo6YWxsb2NEaXNjYXJkYWJsZU1lbW9yeShzaXplX3QgYnl0ZXMpCit7 CisgICAgbV9kaXNjYXJkYWJsZSA9IGFkb3B0UHRyKFdlYktpdDo6UGxhdGZvcm06OmN1cnJlbnQo KS0+YWxsb2NhdGVEaXNjYXJkYWJsZU1lbW9yeShieXRlcykpOworICAgIHJldHVybiBtX2Rpc2Nh cmRhYmxlOworfQorCit2b2lkKiBEaXNjYXJkYWJsZVBpeGVsUmVmOjpvbkxvY2tQaXhlbHMoU2tD b2xvclRhYmxlKiogY3RhYmxlKQoreworICAgIGlmIChtX2Rpc2NhcmRhYmxlKQorICAgICAgICBt X2xvY2tlZE1lbW9yeSA9IG1fZGlzY2FyZGFibGUtPmxvY2soKTsKKyAgICAqY3RhYmxlID0gbV9j b2xvclRhYmxlOworICAgIHJldHVybiBtX2xvY2tlZE1lbW9yeTsKK30KKwordm9pZCBEaXNjYXJk YWJsZVBpeGVsUmVmOjpvblVubG9ja1BpeGVscygpCit7CisgICAgaWYgKG1fbG9ja2VkTWVtb3J5 ICYmIG1fZGlzY2FyZGFibGUpCisgICAgICAgIG1fZGlzY2FyZGFibGUtPnVubG9jaygpOworfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EaXNjYXJkYWJsZVBpeGVsUmVmLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9EaXNjYXJkYWJsZVBpeGVsUmVmLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uY2ZjZjU1M2MxZGFkMWQ4MjMxNjNlZmJlOTVjNDZlOTYzMGQxYmI4MgotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Rp c2NhcmRhYmxlUGl4ZWxSZWYuaApAQCAtMCwwICsxLDY4IEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDEzIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQor ICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBE aXNjYXJkYWJsZVBpeGVsUmVmX2gKKyNkZWZpbmUgRGlzY2FyZGFibGVQaXhlbFJlZl9oCisKKyNp bmNsdWRlICJTa0JpdG1hcC5oIgorI2luY2x1ZGUgIlNrUGl4ZWxSZWYuaCIKKworI2luY2x1ZGUg PHB1YmxpYy9XZWJEaXNjYXJkYWJsZU1lbW9yeS5oPgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4K KyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8v IENsYXNzIGZvciBhbGxvY2F0aW5nIHRoZSBEaXNjYXJkYWJsZVBpeGVsUmVmIG9iamVjdC4KK2Ns YXNzIERpc2NhcmRhYmxlUGl4ZWxSZWZBbGxvY2F0b3IgOiBwdWJsaWMgU2tCaXRtYXA6OkFsbG9j YXRvciB7CisgICAgLy8gU2tCaXRtYXA6OkFsbG9jYXRvciBpbXBsZW1lbnRhdGlvbgorICAgIHZp cnR1YWwgYm9vbCBhbGxvY1BpeGVsUmVmKFNrQml0bWFwKiwgU2tDb2xvclRhYmxlKik7Cit9Owor CisvLyBQaXhlbFJlZiBvYmplY3Qgd2hvc2UgbWVtb3J5IGNhbiBiZSBkaXNjYXJkZWQgd2hlbiBw aXhlbHMgYXJlIHVubG9ja2VkLgorY2xhc3MgRGlzY2FyZGFibGVQaXhlbFJlZiA6IHB1YmxpYyBT a1BpeGVsUmVmIHsKK3B1YmxpYzoKKyAgICBEaXNjYXJkYWJsZVBpeGVsUmVmKFNrQ29sb3JUYWJs ZSosIFBhc3NPd25QdHI8U2tNdXRleD4pOworICAgIH5EaXNjYXJkYWJsZVBpeGVsUmVmKCk7CisK KyAgICBib29sIGFsbG9jRGlzY2FyZGFibGVNZW1vcnkoc2l6ZV90KTsKKworICAgIFNLX0RFQ0xB UkVfVU5GTEFUVEVOQUJMRV9PQkpFQ1QoKQorCitwcm90ZWN0ZWQ6CisgICAgLy8gU2tQaXhlbFJl ZiBpbXBsZW1lbnRhdGlvbgorICAgIHZpcnR1YWwgdm9pZCogb25Mb2NrUGl4ZWxzKFNrQ29sb3JU YWJsZSoqKTsKKyAgICB2aXJ0dWFsIHZvaWQgb25VbmxvY2tQaXhlbHMoKTsKKworcHJpdmF0ZToK KyAgICBTa0NvbG9yVGFibGUqIG1fY29sb3JUYWJsZTsKKyAgICB2b2lkKiBtX2xvY2tlZE1lbW9y eTsKKyAgICBPd25QdHI8V2ViS2l0OjpXZWJEaXNjYXJkYWJsZU1lbW9yeT4gbV9kaXNjYXJkYWJs ZTsKKyAgICBPd25QdHI8U2tNdXRleD4gbV9tdXRleDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdl YkNvcmUKKworI2VuZGlmCg== 183306 2013-01-17 16:16:51 -0800 2013-01-22 19:10:51 -0800 Patch bug-107183-20130117161351.patch text/plain 7177 nduca U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5OTUwCmRpZmYgLS1naXQgYS9Tb3VyY2UvUGxhdGZvcm0v Q2hhbmdlTG9nIGIvU291cmNlL1BsYXRmb3JtL0NoYW5nZUxvZwppbmRleCBmODlhMmE4YjcyNjA1 NTI5MGNkZmE3MmM0NjMzMzUxZDg5NjJhMTdjLi5iMTg4MTkxZTVhY2VhNGRlYTJhM2RiYzcyNmQ2 NjI2NmI4NjFkNzJkIDEwMDY0NAotLS0gYS9Tb3VyY2UvUGxhdGZvcm0vQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9QbGF0Zm9ybS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAxMy0wMS0xNyAg TmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQg V2ViRGlzY2FyZGFibGVNZW1vcnkgdG8gcGxhdGZvcm0KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNzE4MworCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlYkRpc2NhcmRhYmxlIHByb3ZpZGVzIGEgd3JhcHBl ciBhcm91bmQgbWVtb3J5IHRoYXQgY2FuIGJlCisgICAgICAgIHJlbGNhaW1lZCBieSB0aGUgdW5k ZXJseWluZyBrZXJuZWwgd2hlbiBpdCBpcyB1bmRlciBoZWF2eSBtZW1vcnkKKyAgICAgICAgcHJl c3N1cmUuIFRoaXMgd2lsbCBiZSB1c2VkIGluIGEgZm9sbG93dXAgcGF0Y2ggaW4gdGhlIENocm9t aXVtCisgICAgICAgIGltYWdlIGRlY29kaW5nIHN0b3JlIGZvciBkZWNvZGVkL3Jlc2l6ZWQgaW1h Z2VzLgorCisgICAgICAgICogUGxhdGZvcm0uZ3lwaToKKyAgICAgICAgKiBjaHJvbWl1bS9wdWJs aWMvUGxhdGZvcm0uaDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChQbGF0Zm9ybSk6Cisg ICAgICAgIChXZWJLaXQ6OlBsYXRmb3JtOjphbGxvY2F0ZURpc2NhcmRhYmxlTWVtb3J5KToKKyAg ICAgICAgKiBjaHJvbWl1bS9wdWJsaWMvV2ViRGlzY2FyZGFibGVNZW1vcnkuaDogQWRkZWQuCisg ICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViRGlzY2FyZGFibGVNZW1vcnkpOgorICAgICAg ICAoV2ViS2l0OjpXZWJEaXNjYXJkYWJsZU1lbW9yeTo6fldlYkRpc2NhcmRhYmxlTWVtb3J5KToK KwogMjAxMy0wMS0xMCAgVG9tbXkgV2lkZW5mbHljaHQgIDx0b21teXdAZ29vZ2xlLmNvbT4KIAog ICAgICAgICBNZWRpYVN0cmVhbSBBUEk6IEFkZGluZyB0aGUgbmV3IGlkIGF0dHJpYnV0ZSB0byBN ZWRpYVN0cmVhbSBhbmQgTWVkaWFTdHJlYW1UcmFjawpkaWZmIC0tZ2l0IGEvU291cmNlL1BsYXRm b3JtL1BsYXRmb3JtLmd5cGkgYi9Tb3VyY2UvUGxhdGZvcm0vUGxhdGZvcm0uZ3lwaQppbmRleCAz NDIzOTQzNDVlZGNmNjkxZTcwY2ZiYjQzNjYzMTIyOTI5OTcwNGFlLi45NzQ5YTVjMDQyYjEzNDQ1 M2JkNmYzNjk0NDhmNTRiNzk1YzAzZDJkIDEwMDY0NAotLS0gYS9Tb3VyY2UvUGxhdGZvcm0vUGxh dGZvcm0uZ3lwaQorKysgYi9Tb3VyY2UvUGxhdGZvcm0vUGxhdGZvcm0uZ3lwaQpAQCAtNTEsNiAr NTEsNyBAQAogICAgICAgICAgICAgJ2Nocm9taXVtL3B1YmxpYy9XZWJDb29raWUuaCcsCiAgICAg ICAgICAgICAnY2hyb21pdW0vcHVibGljL1dlYkNvb2tpZUphci5oJywKICAgICAgICAgICAgICdj aHJvbWl1bS9wdWJsaWMvV2ViRGF0YS5oJywKKyAgICAgICAgICAgICdjaHJvbWl1bS9wdWJsaWMv V2ViRGlzY2FyZGFibGVNZW1vcnkuaCcsCiAgICAgICAgICAgICAnY2hyb21pdW0vcHVibGljL1dl YkRyYWdEYXRhLmgnLAogICAgICAgICAgICAgJ2Nocm9taXVtL3B1YmxpYy9XZWJFeHRlcm5hbFRl eHR1cmVMYXllci5oJywKICAgICAgICAgICAgICdjaHJvbWl1bS9wdWJsaWMvV2ViRXh0ZXJuYWxU ZXh0dXJlTGF5ZXJDbGllbnQuaCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvUGxhdGZvcm0vY2hyb21p dW0vcHVibGljL1BsYXRmb3JtLmggYi9Tb3VyY2UvUGxhdGZvcm0vY2hyb21pdW0vcHVibGljL1Bs YXRmb3JtLmgKaW5kZXggOTVjY2I5NWE1ZDUyMDNhNDdlZWJjN2ViYTk5NGUyNmJiYTg2ZjI0Zi4u ZWZmMjAzMWU0NTk3OTQyNmIxOGYxYzM4NDQ4ZTFhMjM1ZTc4MWZmZCAxMDA2NDQKLS0tIGEvU291 cmNlL1BsYXRmb3JtL2Nocm9taXVtL3B1YmxpYy9QbGF0Zm9ybS5oCisrKyBiL1NvdXJjZS9QbGF0 Zm9ybS9jaHJvbWl1bS9wdWJsaWMvUGxhdGZvcm0uaApAQCAtNTEsNiArNTEsNyBAQCBjbGFzcyBX ZWJCbG9iUmVnaXN0cnk7CiBjbGFzcyBXZWJDbGlwYm9hcmQ7CiBjbGFzcyBXZWJDb21wb3NpdG9y U3VwcG9ydDsKIGNsYXNzIFdlYkNvb2tpZUphcjsKK2NsYXNzIFdlYkRpc2NhcmRhYmxlTWVtb3J5 OwogY2xhc3MgV2ViRmlsZVN5c3RlbTsKIGNsYXNzIFdlYkZpbGVVdGlsaXRpZXM7CiBjbGFzcyBX ZWJGbGluZ0FuaW1hdG9yOwpAQCAtMTU3LDcgKzE1OCw2IEBAIHB1YmxpYzoKICAgICAvLyBNdXN0 IHJldHVybiBub24tbnVsbC4KICAgICB2aXJ0dWFsIFdlYkZpbGVTeXN0ZW0qIGZpbGVTeXN0ZW0o KSB7IHJldHVybiAwOyB9CiAKLQogICAgIC8vIEdhbWVwYWQgLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiAgICAgdmlydHVhbCB2 b2lkIHNhbXBsZUdhbWVwYWRzKFdlYkdhbWVwYWRzJiBpbnRvKSB7IGludG8ubGVuZ3RoID0gMDsg fQpAQCAtMjM0LDYgKzIzNCwyMiBAQCBwdWJsaWM6CiAgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRo ZSBzaXplIGhhcyBiZWVuIHJlcG9ydGVkLCBvciBmYWxzZSBvdGhlcndpc2UuCiAgICAgdmlydHVh bCBib29sIG1lbW9yeUFsbG9jYXRvcldhc3RlSW5CeXRlcyhzaXplX3QqKSB7IHJldHVybiBmYWxz ZTsgfQogCisgICAgLy8gRGV0ZXJtaW5lIGlmIHRoZSB1bmRlcmx5aW5nIHBsYXRmb3JtIHN1cHBv cnRzIGRpc2NhcmRhYmxlIG1lbW9yeQorICAgIHZpcnR1YWwgYm9vbCBkaXNjYXJkYWJsZU1lbW9y eVN1cHBvcnRlZCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisKKyAgICAvLyBEaXNjYXJkYWJs ZSBtZW1vcnkgaXMgb2Z0ZW4gYmFzZWQgb24gYW4gdW5kZXJseWluZyBrZXJuZWwgcGFnaW5nIHN5 c3RlbS4KKyAgICAvLyBUaHVzLCBhbGxvY2F0aW9ucyBiZWxvdyBhIGNlcnRhaW4gc2l6ZSBhcmUg b2Z0ZW4gY291bnRlcnByb2R1Y3RpdmUuIFRoaXMKKyAgICAvLyByZXR1cm5zIHRoZSBzdWdnZXN0 ZWQgYWxsb2NhdGlvbiBzaXplIGluIGJ5dGVzIGZvciBkaXNjYXJkYWJsZSBtZW1vcnkKKyAgICAv LyBhbGxvY2F0aW9ucy4KKyAgICB2aXJ0dWFsIHNpemVfdCBzdWdnZXN0ZWRNaW5pbXVtRGlzY2Fy ZGFibGVNZW1vcnlBbGxvY2F0aW9uU2l6ZUluQnl0ZXMoKSBjb25zdCB7IHJldHVybiAwOyB9CisK KyAgICAvLyBBbGxvY2F0ZXMgZGlzY2FyZGFibGUgbWVtb3J5LiBNYXkgcmV0dXJuIDAsIGV2ZW4g aWYgdGhlIHBsYXRmb3JtIHN1cHBvcnRzCisgICAgLy8gZGlzY2FyZGFibGUgbWVtb3J5LiBJZiBu b256ZXJvLCBob3dldmVyLCB0aGVuIHRoZSBXZWJEaXNjYXJkYWJsZU1tZW9yeSBpcworICAgIC8v IHJldHVybmVkIGluIGFuIGxvY2tlZCBzdGF0ZS4gWW91IG1heSB1c2UgaXRzIHVuZGVybHlpbmcg ZGF0YSgpIG1lbWJlcgorICAgIC8vIGRpcmVjdGx5LCB0YWtpbmcgY2FyZSB0byB1bmxvY2sgaXQg d2hlbiB5b3UgYXJlIHJlYWR5IHRvIGxldCBpdCBiZWNvbWUKKyAgICAvLyBkaXNjYXJkYWJsZS4K KyAgICB2aXJ0dWFsIFdlYkRpc2NhcmRhYmxlTWVtb3J5KiBhbGxvY2F0ZUFuZExvY2tEaXNjYXJk YWJsZU1lbW9yeShzaXplX3QgYnl0ZXMpIHsgcmV0dXJuIDA7IH0KKwogCiAgICAgLy8gTWVzc2Fn ZSBQb3J0cyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9QbGF0Zm9ybS9jaHJvbWl1bS9wdWJsaWMvV2Vi RGlzY2FyZGFibGVNZW1vcnkuaCBiL1NvdXJjZS9QbGF0Zm9ybS9jaHJvbWl1bS9wdWJsaWMvV2Vi RGlzY2FyZGFibGVNZW1vcnkuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45MWJjZDFkODQ0YTM5ZmY5NTJmMDg2Zjg1 ODI2N2UxNDU5ZGFmYTBlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1BsYXRmb3JtL2Nocm9t aXVtL3B1YmxpYy9XZWJEaXNjYXJkYWJsZU1lbW9yeS5oCkBAIC0wLDAgKzEsNzMgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTMgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAg ICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl IGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExF IEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElF RAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQ TEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICog T04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaWZuZGVmIFdlYkRpc2NhcmRhYmxlTWVtb3J5X2gKKyNkZWZpbmUgV2ViRGlzY2FyZGFibGVN ZW1vcnlfaAorCituYW1lc3BhY2UgV2ViS2l0IHsKKworLy8gQSBtZW1vcnkgYWxsb2NhdGlvbiB0 aGF0IGNhbiBiZSBhdXRvbWF0aWNhbGx5IGRpc2NhcmRlZCBieSB0aGUgb3BlcmF0aW5nCisvLyBz eXN0ZW0gdW5kZXIgbWVtb3J5IHByZXNzdXJlLgorY2xhc3MgV2ViRGlzY2FyZGFibGVNZW1vcnkg eworcHVibGljOgorICAgIHZpcnR1YWwgfldlYkRpc2NhcmRhYmxlTWVtb3J5KCkgeyB9CisKKyAg ICAvLyBMb2NrcyB0aGUgbWVtb3J5LCBwcmV2ZW50IGl0IGZyb20gYmVpbmcgZGlzY2FyZGVkLiBP bmNlIGxvY2tlZC4geW91IG1heQorICAgIC8vIG9idGFpbiBhIHBvaW50ZXIgdG8gdGhhdCBtZW1v cnkgdXNpbmcgdGhlIGRhdGEoKSBtZXRob2QuCisgICAgLy8KKyAgICAvLyBMb2NrKCkgbWF5IHJl dHVybiBmYWxzZSwgaW5kaWNhdGluZyB0aGF0IHRoZSB1bmRlcmx5aW5nIG1lbW9yeSB3YXMKKyAg ICAvLyBkaXNjYXJkZWQgYW5kIHRoYXQgdGhlIGxvY2sgZmFpbGVkLiBJbiB0aGlzIGNhc2UsIHRo ZQorICAgIC8vIFdlYkRpc2NhcmRhYmxlTWVtb3J5IGlzIGVmZmVjdGl2ZWx5IGRlYWQuCisgICAg Ly8KKyAgICAvLyBEaXNjYXJkYWJsZSB1c2FnZSBpcyB0eXBpY2FsbHk6CisgICAgLy8gICAgV2Vi RGlzY2FyZGFibGVNZW1vcnkqIG1lbSA9IGFsbG9jYXRlQW5kTG9ja2VkRGlzY2FyZGFibGVNZW1v cnkoMTAyNCoxMDI0KTsKKyAgICAvLyAgICB2b2lkKiBkYXRhID0gbWVtLT5kYXRhKCk7CisgICAg Ly8gICAgbWVtc2V0KGRhdGEsIDMsIDEwMjQqMTAyNCk7CisgICAgLy8gICAgbWVtLT51bmxvY2so KTsKKyAgICAvLworICAgIC8vIExhdGVyLCB3aGVuIHlvdSBuZWVkIGl0IGFnYWluOgorICAgIC8v ICAgIGlmICghbWVtLT5sb2NrKCkpIHsKKyAgICAvLyAgICAgICAuLi4gaGFuZGxlIHRoZSBmYWN0 IHRoYXQgdGhlIG1lbW9yeSBpcyBnb25lLi4uCisgICAgLy8gICAgICAgZGVsZXRlIG1lbTsgLy8g TWFrZSBzdXJlIHRvIGRlc3Ryb3kgaXQuIEl0cyBuZXZlciBnb2luZyB0byBjb21lIGJhY2suCisg ICAgLy8gICAgICAgcmV0dXJuOworICAgIC8vICAgIH0KKyAgICAvLyAgICAuLi4gdXNlIG1lbS0+ ZGF0YSgpIGFzIG11Y2ggYXMgeW91IHdhbnQKKyAgICAvLyAgICBtZW0tPnVubG9jaygpOworICAg IC8vCisgICAgLy8gTmVzdGVkIGNhbGxzIHRvIGxvY2sgYXJlIG5vdCBhbGxvd2VkLgorICAgIHZp cnR1YWwgYm9vbCBsb2NrKCkgPSAwOworCisgICAgLy8gUmV0dXJucyB0aGUgY3VycmVudCBwb2lu dGVyIGZvciB0aGUgZGlzY2FyZGFibGUgbWVtb3J5LiBUaGlzIGNhbGwgaXMgT05MWQorICAgIC8v IHZhbGlkIHdoZW4gdGhlIGRpc2NhcmRhYmxlIG1lbW9yeSBvYmplY3QgaXMgbG9ja2VkLgorICAg IHZpcnR1YWwgdm9pZCogZGF0YSgpID0gMDsKKworICAgIC8vIFVubG9jayB0aGUgbWVtb3J5IHNv IHRoYXQgaXQgY2FuIGJlIHB1cmdlZCBieSB0aGUgc3lzdGVtLiBNdXN0IGJlIGNhbGxlZAorICAg IC8vIGFmdGVyIGV2ZXJ5IHN1Y2Nlc3NmdWwgbG9jayBjYWxsLgorICAgIHZpcnR1YWwgdm9pZCB1 bmxvY2soKSA9IDA7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCg== 184105 2013-01-22 19:10:55 -0800 2013-01-22 19:38:32 -0800 Patch for landing bug-107183-20130122190749.patch text/plain 6359 nduca U3VidmVyc2lvbiBSZXZpc2lvbjogMTQwMjE4CmRpZmYgLS1naXQgYS9Tb3VyY2UvUGxhdGZvcm0v Q2hhbmdlTG9nIGIvU291cmNlL1BsYXRmb3JtL0NoYW5nZUxvZwppbmRleCAyNTE4M2ZkNTk5MjFh ZWE4OGI5MzFhMjkzZjg1ZDhlNDZjZjBhYTUxLi4wZWU4ZmViNTg0ZjE3Zjg3ZmVkMTZlYWU5NGY1 YmQ5MzhmYWZkNmM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvUGxhdGZvcm0vQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9QbGF0Zm9ybS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAxMy0wMS0xNyAg TmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBBZGQg V2ViRGlzY2FyZGFibGVNZW1vcnkgdG8gcGxhdGZvcm0KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNzE4MworCisgICAgICAgIFJldmlld2VkIGJ5IEph bWVzIFJvYmluc29uLgorCisgICAgICAgIFdlYkRpc2NhcmRhYmxlIHByb3ZpZGVzIGEgd3JhcHBl ciBhcm91bmQgbWVtb3J5IHRoYXQgY2FuIGJlCisgICAgICAgIHJlbGNhaW1lZCBieSB0aGUgdW5k ZXJseWluZyBrZXJuZWwgd2hlbiBpdCBpcyB1bmRlciBoZWF2eSBtZW1vcnkKKyAgICAgICAgcHJl c3N1cmUuIFRoaXMgd2lsbCBiZSB1c2VkIGluIGEgZm9sbG93dXAgcGF0Y2ggaW4gdGhlIENocm9t aXVtCisgICAgICAgIGltYWdlIGRlY29kaW5nIHN0b3JlIGZvciBkZWNvZGVkL3Jlc2l6ZWQgaW1h Z2VzLgorCisgICAgICAgICogUGxhdGZvcm0uZ3lwaToKKyAgICAgICAgKiBjaHJvbWl1bS9wdWJs aWMvUGxhdGZvcm0uaDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChQbGF0Zm9ybSk6Cisg ICAgICAgIChXZWJLaXQ6OlBsYXRmb3JtOjphbGxvY2F0ZURpc2NhcmRhYmxlTWVtb3J5KToKKyAg ICAgICAgKiBjaHJvbWl1bS9wdWJsaWMvV2ViRGlzY2FyZGFibGVNZW1vcnkuaDogQWRkZWQuCisg ICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViRGlzY2FyZGFibGVNZW1vcnkpOgorICAgICAg ICAoV2ViS2l0OjpXZWJEaXNjYXJkYWJsZU1lbW9yeTo6fldlYkRpc2NhcmRhYmxlTWVtb3J5KToK KwogMjAxMy0wMS0xOCAgQWxpIEp1bWEgIDxhanVtYUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg W2Nocm9taXVtXSBDb252ZXJ0IFdlYlRyYW5zZm9ybU9wZXJhdGlvbnMgaW50byBwdXJlIHZpcnR1 YWwKZGlmZiAtLWdpdCBhL1NvdXJjZS9QbGF0Zm9ybS9QbGF0Zm9ybS5neXBpIGIvU291cmNlL1Bs YXRmb3JtL1BsYXRmb3JtLmd5cGkKaW5kZXggMzQyMzk0MzQ1ZWRjZjY5MWU3MGNmYmI0MzY2MzEy MjkyOTk3MDRhZS4uOTc0OWE1YzA0MmIxMzQ0NTNiZDZmMzY5NDQ4ZjU0Yjc5NWMwM2QyZCAxMDA2 NDQKLS0tIGEvU291cmNlL1BsYXRmb3JtL1BsYXRmb3JtLmd5cGkKKysrIGIvU291cmNlL1BsYXRm b3JtL1BsYXRmb3JtLmd5cGkKQEAgLTUxLDYgKzUxLDcgQEAKICAgICAgICAgICAgICdjaHJvbWl1 bS9wdWJsaWMvV2ViQ29va2llLmgnLAogICAgICAgICAgICAgJ2Nocm9taXVtL3B1YmxpYy9XZWJD b29raWVKYXIuaCcsCiAgICAgICAgICAgICAnY2hyb21pdW0vcHVibGljL1dlYkRhdGEuaCcsCisg ICAgICAgICAgICAnY2hyb21pdW0vcHVibGljL1dlYkRpc2NhcmRhYmxlTWVtb3J5LmgnLAogICAg ICAgICAgICAgJ2Nocm9taXVtL3B1YmxpYy9XZWJEcmFnRGF0YS5oJywKICAgICAgICAgICAgICdj aHJvbWl1bS9wdWJsaWMvV2ViRXh0ZXJuYWxUZXh0dXJlTGF5ZXIuaCcsCiAgICAgICAgICAgICAn Y2hyb21pdW0vcHVibGljL1dlYkV4dGVybmFsVGV4dHVyZUxheWVyQ2xpZW50LmgnLApkaWZmIC0t Z2l0IGEvU291cmNlL1BsYXRmb3JtL2Nocm9taXVtL3B1YmxpYy9QbGF0Zm9ybS5oIGIvU291cmNl L1BsYXRmb3JtL2Nocm9taXVtL3B1YmxpYy9QbGF0Zm9ybS5oCmluZGV4IDk1Y2NiOTVhNWQ1MjAz YTQ3ZWViYzdlYmE5OTRlMjZiYmE4NmYyNGYuLjA5MzY2ZWU1MDlmYWEzOWQyZDAwZDBlZDFhMmUz OGM5MjZiNzk1M2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9QbGF0Zm9ybS9jaHJvbWl1bS9wdWJsaWMv UGxhdGZvcm0uaAorKysgYi9Tb3VyY2UvUGxhdGZvcm0vY2hyb21pdW0vcHVibGljL1BsYXRmb3Jt LmgKQEAgLTUxLDYgKzUxLDcgQEAgY2xhc3MgV2ViQmxvYlJlZ2lzdHJ5OwogY2xhc3MgV2ViQ2xp cGJvYXJkOwogY2xhc3MgV2ViQ29tcG9zaXRvclN1cHBvcnQ7CiBjbGFzcyBXZWJDb29raWVKYXI7 CitjbGFzcyBXZWJEaXNjYXJkYWJsZU1lbW9yeTsKIGNsYXNzIFdlYkZpbGVTeXN0ZW07CiBjbGFz cyBXZWJGaWxlVXRpbGl0aWVzOwogY2xhc3MgV2ViRmxpbmdBbmltYXRvcjsKQEAgLTIzNCw2ICsy MzUsMTMgQEAgcHVibGljOgogICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgc2l6ZSBoYXMgYmVl biByZXBvcnRlZCwgb3IgZmFsc2Ugb3RoZXJ3aXNlLgogICAgIHZpcnR1YWwgYm9vbCBtZW1vcnlB bGxvY2F0b3JXYXN0ZUluQnl0ZXMoc2l6ZV90KikgeyByZXR1cm4gZmFsc2U7IH0KIAorICAgIC8v IEFsbG9jYXRlcyBkaXNjYXJkYWJsZSBtZW1vcnkuIE1heSByZXR1cm4gMCwgZXZlbiBpZiB0aGUg cGxhdGZvcm0gc3VwcG9ydHMKKyAgICAvLyBkaXNjYXJkYWJsZSBtZW1vcnkuIElmIG5vbnplcm8s IGhvd2V2ZXIsIHRoZW4gdGhlIFdlYkRpc2NhcmRhYmxlTW1lb3J5IGlzCisgICAgLy8gcmV0dXJu ZWQgaW4gYW4gbG9ja2VkIHN0YXRlLiBZb3UgbWF5IHVzZSBpdHMgdW5kZXJseWluZyBkYXRhKCkg bWVtYmVyCisgICAgLy8gZGlyZWN0bHksIHRha2luZyBjYXJlIHRvIHVubG9jayBpdCB3aGVuIHlv dSBhcmUgcmVhZHkgdG8gbGV0IGl0IGJlY29tZQorICAgIC8vIGRpc2NhcmRhYmxlLgorICAgIHZp cnR1YWwgV2ViRGlzY2FyZGFibGVNZW1vcnkqIGFsbG9jYXRlQW5kTG9ja0Rpc2NhcmRhYmxlTWVt b3J5KHNpemVfdCBieXRlcykgeyByZXR1cm4gMDsgfQorCiAKICAgICAvLyBNZXNzYWdlIFBvcnRz IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K IApkaWZmIC0tZ2l0IGEvU291cmNlL1BsYXRmb3JtL2Nocm9taXVtL3B1YmxpYy9XZWJEaXNjYXJk YWJsZU1lbW9yeS5oIGIvU291cmNlL1BsYXRmb3JtL2Nocm9taXVtL3B1YmxpYy9XZWJEaXNjYXJk YWJsZU1lbW9yeS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhkOTBlYTM1MDA4ZDNiNmQwYjU0ZDhmOTdjOTYyZTE4 YWYyZmViYTEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvUGxhdGZvcm0vY2hyb21pdW0vcHVi bGljL1dlYkRpc2NhcmRhYmxlTWVtb3J5LmgKQEAgLTAsMCArMSw3NSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxMyBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElU UyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJ VFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwor ICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5k ZWYgV2ViRGlzY2FyZGFibGVNZW1vcnlfaAorI2RlZmluZSBXZWJEaXNjYXJkYWJsZU1lbW9yeV9o CisKK25hbWVzcGFjZSBXZWJLaXQgeworCisvLyBBIG1lbW9yeSBhbGxvY2F0aW9uIHRoYXQgY2Fu IGJlIGF1dG9tYXRpY2FsbHkgZGlzY2FyZGVkIGJ5IHRoZSBvcGVyYXRpbmcKKy8vIHN5c3RlbSB1 bmRlciBtZW1vcnkgcHJlc3N1cmUuCisvLworLy8gRGlzY2FyZGFibGUgdXNhZ2UgaXMgdHlwaWNh bGx5OgorLy8gICAgV2ViRGlzY2FyZGFibGVNZW1vcnkqIG1lbSA9IGFsbG9jYXRlQW5kTG9ja2Vk RGlzY2FyZGFibGVNZW1vcnkoMTAyNCoxMDI0KTsKKy8vICAgIHZvaWQqIGRhdGEgPSBtZW0tPmRh dGEoKTsKKy8vICAgIG1lbXNldChkYXRhLCAzLCAxMDI0KjEwMjQpOworLy8gICAgbWVtLT51bmxv Y2soKTsKKy8vCisvLyBMYXRlciwgd2hlbiB5b3UgbmVlZCBpdCBhZ2FpbjoKKy8vICAgIGlmICgh bWVtLT5sb2NrKCkpIHsKKy8vICAgICAgIC4uLiBoYW5kbGUgdGhlIGZhY3QgdGhhdCB0aGUgbWVt b3J5IGlzIGdvbmUuLi4KKy8vICAgICAgIGRlbGV0ZSBtZW07IC8vIE1ha2Ugc3VyZSB0byBkZXN0 cm95IGl0LiBJdCBpcyBuZXZlciBnb2luZyB0byBjb21lIGJhY2suCisvLyAgICAgICByZXR1cm47 CisvLyAgICB9CisvLyAgICAuLi4gdXNlIG1lbS0+ZGF0YSgpIGFzIG11Y2ggYXMgeW91IHdhbnQK Ky8vICAgIG1lbS0+dW5sb2NrKCk7CisvLworY2xhc3MgV2ViRGlzY2FyZGFibGVNZW1vcnkgewor cHVibGljOgorICAgIC8vIE11c3Qgbm90IGJlIGNhbGxlZCB3aGlsZSBsb2NrZWQuCisgICAgdmly dHVhbCB+V2ViRGlzY2FyZGFibGVNZW1vcnkoKSB7IH0KKworICAgIC8vIExvY2tzIHRoZSBtZW1v cnksIHByZXZlbnQgaXQgZnJvbSBiZWluZyBkaXNjYXJkZWQuIE9uY2UgbG9ja2VkLiB5b3UgbWF5 CisgICAgLy8gb2J0YWluIGEgcG9pbnRlciB0byB0aGF0IG1lbW9yeSB1c2luZyB0aGUgZGF0YSgp IG1ldGhvZC4KKyAgICAvLworICAgIC8vIGxvY2soKSBtYXkgcmV0dXJuIGZhbHNlLCBpbmRpY2F0 aW5nIHRoYXQgdGhlIHVuZGVybHlpbmcgbWVtb3J5IHdhcworICAgIC8vIGRpc2NhcmRlZCBhbmQg dGhhdCB0aGUgbG9jayBmYWlsZWQuIEluIHRoaXMgY2FzZSwgdGhlCisgICAgLy8gV2ViRGlzY2Fy ZGFibGVNZW1vcnkgaXMgZWZmZWN0aXZlbHkgZGVhZC4KKyAgICAvLworICAgIC8vIE5lc3RlZCBj YWxscyB0byBsb2NrIGFyZSBub3QgYWxsb3dlZC4KKyAgICB2aXJ0dWFsIGJvb2wgbG9jaygpID0g MDsKKworICAgIC8vIFJldHVybnMgdGhlIGN1cnJlbnQgcG9pbnRlciBmb3IgdGhlIGRpc2NhcmRh YmxlIG1lbW9yeS4gVGhpcyBjYWxsIGlzIE9OTFkKKyAgICAvLyB2YWxpZCB3aGVuIHRoZSBkaXNj YXJkYWJsZSBtZW1vcnkgb2JqZWN0IGlzIGxvY2tlZC4KKyAgICB2aXJ0dWFsIHZvaWQqIGRhdGEo KSA9IDA7CisKKyAgICAvLyBVbmxvY2sgdGhlIG1lbW9yeSBzbyB0aGF0IGl0IGNhbiBiZSBwdXJn ZWQgYnkgdGhlIHN5c3RlbS4gTXVzdCBiZSBjYWxsZWQKKyAgICAvLyBhZnRlciBldmVyeSBzdWNj ZXNzZnVsIGxvY2sgY2FsbC4KKyAgICB2aXJ0dWFsIHZvaWQgdW5sb2NrKCkgPSAwOworfTsKKwor fSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgo=