112873 2013-03-20 21:33:30 -0700 Remove ValueCheck system 2013-11-05 08:52:53 -0800 1 1 1 Unclassified WebKit Web Template Framework 528+ (Nightly build) Unspecified Unspecified RESOLVED LATER P2 Normal --- 112831 1 eric eric abarth ap benjamin buildbot cmarcelo darin dglazkov esprehn+autocc ggaren gyuyoung.kim inferno japhet jschuh mjs ojan.autocc philn rakuco rniwa webkit-ews webkit.review.bot xan.lopez oldest_to_newest 860000 0 eric 2013-03-20 21:33:30 -0700 Remove ValueCheck system 860002 1 194181 eric 2013-03-20 21:36:39 -0700 Created attachment 194181 Patch 860007 2 eric 2013-03-20 21:39:19 -0700 This came from bug http://trac.webkit.org/changeset/54618. It was a good dream, but it doesn't seem to have yielded much, and I think should now just be removed. For bug 112831, we could easily add a ValueCheck<StringImpl*> override which avoids this fastMallocSize() check, but given that fastMalloc isn't even used everywhere, it seems this code isn't buying us much anymore. 860008 3 eric 2013-03-20 21:40:18 -0700 I've CC'd the original author (ggaren) and reviewer (ap) and our Security peeps in case they have opinions on the existence of ValueCheck. 860010 4 194181 webkit-ews 2013-03-20 21:47:52 -0700 Comment on attachment 194181 Patch Attachment 194181 did not pass qt-ews (qt): Output: http://webkit-commit-queue.appspot.com/results/17226348 860012 5 194181 webkit-ews 2013-03-20 21:51:05 -0700 Comment on attachment 194181 Patch Attachment 194181 did not pass qt-wk2-ews (qt): Output: http://webkit-commit-queue.appspot.com/results/17241078 860016 6 194181 webkit.review.bot 2013-03-20 22:01:13 -0700 Comment on attachment 194181 Patch Attachment 194181 did not pass chromium-ews (chromium-xvfb): Output: http://webkit-commit-queue.appspot.com/results/17223427 860029 7 194181 eflews.bot 2013-03-20 22:18:13 -0700 Comment on attachment 194181 Patch Attachment 194181 did not pass efl-ews (efl): Output: http://webkit-commit-queue.appspot.com/results/17290035 860030 8 194181 webkit.review.bot 2013-03-20 22:22:49 -0700 Comment on attachment 194181 Patch Attachment 194181 did not pass cr-linux-debug-ews (chromium-xvfb): Output: http://webkit-commit-queue.appspot.com/results/17112592 860031 9 194181 buildbot 2013-03-20 22:23:31 -0700 Comment on attachment 194181 Patch Attachment 194181 did not pass mac-wk2-ews (mac-wk2): Output: http://webkit-commit-queue.appspot.com/results/17213788 860050 10 ap 2013-03-20 23:04:02 -0700 > it doesn't seem to have yielded much Huh? 860061 11 194181 ap 2013-03-20 23:21:45 -0700 Comment on attachment 194181 Patch The work in bug 112831 is not nearly useful enough to validate removing security checks that proved helpful in the past. Is there a stronger reason to do this? I'm not sure what you mean when saying that fastMalloc isn't used everywhere. Are you talking about ports using a malloc that doesn't have introspection capabilities? Or about some parts of WebCore? I find it unimpressive that the patch got immediately cq+'ed without any discussion outside business hours. 860073 12 194193 eric 2013-03-20 23:47:32 -0700 Created attachment 194193 Patch 860076 13 eric 2013-03-20 23:50:06 -0700 I've written a better ChangeLog and updated the patch so that it should compile on all ports. I'm in no rush to take this patch anywhere. :) I've CC'd all the folks who have touched this code, and they should feel encouraged to read the patch, consider and comment. Thanks. 860083 14 mjs 2013-03-21 00:03:33 -0700 What's the purpose of ValueCheck and what is the reason to remove it? Might be worth a discussion on webkit-dev if we don't have agreement on its value. 860100 15 ap 2013-03-21 00:25:18 -0700 This is a technique to catch some hard to reproduce crashes with strong security implications, added in bug 34150, and later extended in bug 34490. Quoting from the former, ------------------------ Having e.g. HashMap<AtomicStringImpl*, ValueType>, it is extremely difficult to catch stale AtomicStringImpl pointers in map keys. In most cases, they can just sit there making the map larger, and only cause issues if another AtomicStringImpl gets allocated at exactly the same address. Even running with CHECK_HASHTABLE_CONSISTENCY won't catch this, since pointer's hash is just its value, so the table remains perfectly consistent. And we (I?) don't usually enable CHECK_HASHTABLE_CONSISTENCY, even when hunting down mystery crashers. ------------------------ This was prompted by an investigation of a very tricky bug we had at the time (I can't easily find it) - we even knew a specific page where this frequently happened, but could not reproduce without these assertions. That also proved to be a security bug, later exploited. These assertions don't catch bugs very often AFAIK, but I have a recollection of them catching something similarly bad once or twice later. 860106 16 abarth 2013-03-21 00:33:58 -0700 These ASSERTs are just plain wrong for ports that set ENABLE_GLOBAL_FASTMALLOC_NEW to 0 and USE_SYSTEM_MALLOC to 0. There's no reason to believe that a given pointer was allocated with fastMalloc. It depends on whether the class in question contains WTF_MAKE_FAST_ALLOCATED. Even in ports that define ENABLE_GLOBAL_FASTMALLOC_NEW to 1, the ASSERTs aren't always correct. For example, they're wrong for ImageLoader, which is why it needs a template specialization of ValueCheck. Finally, there's no requirement that any given object is allocated with malloc at all. As shown in bug 112831, even objects that are normally heap allocated can be allocated in other ways, such as statically. 860111 17 eric 2013-03-21 00:41:50 -0700 (In reply to comment #14) > What's the purpose of ValueCheck and what is the reason to remove it? Might be worth a discussion on webkit-dev if we don't have agreement on its value. I recommend reading the ChangeLog in attachment 194913. I've also cc'd the author/reviewer (as noted in comment #3), who can offer validation/rejection of my understanding as noted in the ChangeLog. 860128 18 ap 2013-03-21 01:12:24 -0700 Adam, there is nothing in these checks that is FastMalloc specific. We even have an implementation that uses system malloc_size today. But even if the checks were FastMalloc specific, that wouldn't be an acceptable reason to remove them. These checks do not deal with arbitrary void* pointers, they are always typed. So it's not meaningful to say that their validity depends on whether a given class uses WTF_MAKE_FAST_ALLOCATED. You say that there is no requirement on how objects are allocated, and that is true. However, writing code that is not allowed to have any prerequisites and may not assert those is not practical for a project of this size. We should be making the code more rigid and predictable, not less. The example with ImageLoader shows that this does not even necessarily add limitations on what can be done. 860133 19 mjs 2013-03-21 01:26:20 -0700 (In reply to comment #18) > Adam, there is nothing in these checks that is FastMalloc specific. We even have an implementation that uses system malloc_size today. For reference: size_t fastMallocSize(const void* p) { #if ENABLE(WTF_MALLOC_VALIDATION) return Internal::fastMallocValidationHeader(const_cast<void*>(p))->m_size; #elif OS(DARWIN) return malloc_size(p); #elif OS(WINDOWS) return _msize(const_cast<void*>(p)); #else UNUSED_PARAM(p); return 1; #endif } 860136 20 194193 mjs 2013-03-21 01:28:37 -0700 Comment on attachment 194193 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=194193&action=review > Source/WTF/ChangeLog:71 > + * GNUmakefile.list.am: > + * WTF.gypi: > + * WTF.pro: > + * WTF.vcproj/WTF.vcproj: > + * WTF.vcxproj/WTF.vcxproj: > + * WTF.xcodeproj/project.pbxproj: > + * wtf/CMakeLists.txt: > + * wtf/HashTable.h: > + (WTF::::checkTableConsistencyExceptSize): > + * wtf/Vector.h: > + (Vector): > + (WTF): Is there a reason this patch doesn't remove ValueCheck.h? 860137 21 eric 2013-03-21 01:31:01 -0700 (In reply to comment #20) > (From update of attachment 194193 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=194193&action=review > > Is there a reason this patch doesn't remove ValueCheck.h? Just an oversight on my part. 860432 22 eric 2013-03-21 09:56:42 -0700 (In reply to comment #19) > (In reply to comment #18) > > Adam, there is nothing in these checks that is FastMalloc specific. We even have an implementation that uses system malloc_size today. > > For reference: > > size_t fastMallocSize(const void* p) > { > #if ENABLE(WTF_MALLOC_VALIDATION) > return Internal::fastMallocValidationHeader(const_cast<void*>(p))->m_size; > #elif OS(DARWIN) > return malloc_size(p); > #elif OS(WINDOWS) > return _msize(const_cast<void*>(p)); > #else > UNUSED_PARAM(p); > return 1; > #endif > } It appears the windows branch doesn't actually do what you want: http://msdn.microsoft.com/en-us/library/z2s077bc(v=vs.80).aspx Will return -1 on error, which means the ASSERT(fastMallocSize(p) in ValueCheck<T> will not fire. The only port which seems to enable WTF_MALLOC_VALIDATION is Blackberry: https://code.google.com/p/chromium/codesearch#search/&q=WTF_MALLOC_VALIDATION&sq=package:chromium&type=cs So it appears that the only builds with a working version of this ASSERT are DARWIN builds, and possibly Blackberry. :) 860615 23 abarth 2013-03-21 13:20:30 -0700 The code is also plain wrong for the ENABLE_GLOBAL_FASTMALLOC_NEW to 0 and USE_SYSTEM_MALLOC to 0 configuration. In that configuration, we use both the system heap and the FastMalloc heap. This code has no way to know which pointer the heap was allocated from (assuming it was even allocated from a heap at all). 860620 24 ap 2013-03-21 13:27:42 -0700 These are all good opportunities to make the checks more universal when someone needs to perform this sort of investigation in such configurations. 860660 25 eric 2013-03-21 14:01:54 -0700 Another solution here would be to just #ifdef all this code as OS(DARWIN) since that's the only platform it works on. :) But I think the better solution is to just remove it. I'm not super passionate about this bug, nor am I in any hurry to land it. I worked around the issue blocking bug 112831. But I do believe removing this code is the right path forward for the project. 860823 26 mjs 2013-03-21 16:05:04 -0700 (In reply to comment #25) > Another solution here would be to just #ifdef all this code as OS(DARWIN) since that's the only platform it works on. :) > > But I think the better solution is to just remove it. > > I'm not super passionate about this bug, nor am I in any hurry to land it. I worked around the issue blocking bug 112831. But I do believe removing this code is the right path forward for the project. It seems like there is at least one bug that actually happened which would have been caught by the checkConsistency ASSERTs, and it seems like fixing the crash only became tractable and testable using ValueCheck. https://bugs.webkit.org/show_bug.cgi?id=34490 That seems like better track record than most ASSERTs in the project. Removing it would materially reduce our test coverage, it seems to me. It seems to me that making it apply correctly to other malloc setups (the cases Adam cited are both eminently fixable) would be better than removing it. What's your reason for thinking it should be removed despite that? 861037 27 eric 2013-03-21 20:18:57 -0700 (In reply to comment #26) > (In reply to comment #25) > What's your reason for thinking it should be removed despite that? I guess my understanding of ASSERTs is that they're supposed to document/enforce conditions that we never believe should occur. ValueCheck, as written, enforces a condition which by chance (and only on DARWIN) happens to occur much of the time, but by no means always. One could re-write ValueCheck to only ASSERT(fastMallocSize(p)) when p is of a class type with MAKE_FAST_ALLOCATED() defined. But since MAKE_FAST_ALLOCATED currently only adds new/delete overrides, it's not immediately clear to me how we'd do that. Certainly extending the current opt-out solution to all classes for which fastMallocSize(p) is not valid seems much more trouble than it's worth. Leaving an ASSERT in the code base which is not true (and in fact we know to be false for many of our classes) seems like a bad idea. :) It's just an accident waiting for the next contributor to run into. 861054 28 mjs 2013-03-21 20:51:17 -0700 (In reply to comment #27) > (In reply to comment #26) > > (In reply to comment #25) > > What's your reason for thinking it should be removed despite that? > > I guess my understanding of ASSERTs is that they're supposed to document/enforce conditions that we never believe should occur. > > ValueCheck, as written, enforces a condition which by chance (and only on DARWIN) happens to occur much of the time, but by no means always. > > One could re-write ValueCheck to only ASSERT(fastMallocSize(p)) when p is of a class type with MAKE_FAST_ALLOCATED() defined. But since MAKE_FAST_ALLOCATED currently only adds new/delete overrides, it's not immediately clear to me how we'd do that. > > Certainly extending the current opt-out solution to all classes for which fastMallocSize(p) is not valid seems much more trouble than it's worth. Leaving an ASSERT in the code base which is not true (and in fact we know to be false for many of our classes) seems like a bad idea. :) It's just an accident waiting for the next contributor to run into. Here's the cases I can think of where it could be wrong: (a) Raw pointers to statically allocated values (b) Raw pointers to values allocated on the stack (c) Raw pointers to values that are data members of other objects (d) Raw pointers to values allocated in space that is obtained directly from the VM, rather than from malloc, such as JavaScript GC memory. Such objects would cause assertion failures when used in a HashSet or as HashMap keys. Other than (b), I'd expect all cases to occur with some regularity Since there are so few ValueCheck specializations, I would guess we only do not see more problems from this because many types are not used as HashTable keys at all. Or maybe we generally do not often use raw pointers as keys. In any case, it seems like the actually difficulties in practice have been low, even though in theory they could be high. Or at least, I don't recall a lot of other instances of ValueCheck false positives. I wonder if there is another way to do this that requires more explicit choice. For example, whenever a raw pointer type is used as a HashTable key, we could require a ValueCheck specialization specifically for that type. Then you'd never get it by accident and could think about the allocation policy for your object. Another thought: perhaps we could enhance FastMalloc to be able to directly answer the question: "is this a pointer to freed memory" rather than "is this a known valid malloc-allocated pointer". That would bias things the other way for objects that are not malloc-allocated at all. I'm curious what Alexey's further thoughts are on this topic. 861087 29 mjs 2013-03-21 22:01:34 -0700 So I looked closer into how fastMallocSize is implemented: In the WTF_MALLOC_VALIDATION case, fastMallocSize() doesn't actually check if the pointer is known to fastMalloc - it will return a random value for a pointer allocated otherwise than by FastMalloc, it seems to me. In the non-WTF_MALLOC_VALIDATION case, it looks like fastMallocSize() will always return zero, because malloc_size will call through to FastMallocZone::size(), which always returns 0. It does not look like WTF_MALLOC_VALIDATION is enabled by default. So I'm not sure how this code ever works. Clearly the assert isn't firing all the time, so am I misreading something here? 861130 30 ap 2013-03-21 23:12:43 -0700 > I'm curious what Alexey's further thoughts are on this topic. Checking how checkConsistency is used in WebCore now, I'm seeing these cases: HashMap<AtomicStringImpl*, OwnPtr<RadioButtonGroup> > HashMap<AtomicStringImpl*, RefPtr<KeyframeAnimation> > HashMap<AtomicStringImpl*, Element*> Vector<T*>, where T is template parameter for EventSender (HTMLLinkElement, HTMLStyleElement, ImageLoader) HashMap<AtomicStringImpl*, AtomicStringImpl*> HashMap<String, HostInformation*, StringHash> HashMap<AtomicStringImpl*, RefPtr<StyleRuleKeyframes> > All these cases worked reliably for years until yesterday, because StringImpl was always heap allocated, and so were elements. Objects that can be allocated in other ways just need different ValueCheck specializations, as demonstrated with ImageLoader. This is just how template specializations work. As another example, HashTraits is not a flawed idea because the default version does not work with every conceivable type. We add a new specialization when we want to put new types into HashTable. The situation is no different with ValueCheck. From the list above, it's clear that changes made in bug 112831 disable almost all checks that we have in WebCore, except for EventSender ones. I think that the responsibility to update template specializations to keep working is on people who make changes. If StringImpl now gets allocated in new ways, ValueCheck should be changed accordingly. It would be really good to have this addressed soon, before rolling out the changes in bug 112831 becomes difficult due to source conflicts. > Clearly the assert isn't firing all the time, so am I misreading something here? The only case where these checks are made is in debug builds, which use system malloc, and thus malloc_size and _msize work as expected. I agree with you that fastMallocSize behavior in release builds seems broken whether WTF_MALLOC_VALIDATION is enabled or not. The code has been deeply refactored since I last looked at it, but these issues would only surface if anyone enables assertions in builds that use FastMalloc, so in practice, this is orthogonal to ValueCheck behavior. As Eric mentioned, the Windows case also looks suspicious. I think that this concern was possibly based on a misreading of MSDN though - the only place where it mentions -1 is when the argument is null, not when it's not a pointer to an allocated block. I think that I actually confirmed correctness by manual testing back in the day. 861134 31 ap 2013-03-21 23:18:19 -0700 One thing that could be easy to overlook is that ValueCheck checks do not automatically happen in all WTF containers, they are always manual. They are also not under CHECK_HASHTABLE_CONSISTENCY ifdef. In retrospect, it was probably a poor decision to make the names so similar to CHECK_HASHTABLE_CONSISTENCY ones. 861141 32 mjs 2013-03-21 23:29:09 -0700 (In reply to comment #31) > One thing that could be easy to overlook is that ValueCheck checks do not automatically happen in all WTF containers, they are always manual. They are also not under CHECK_HASHTABLE_CONSISTENCY ifdef. > > In retrospect, it was probably a poor decision to make the names so similar to CHECK_HASHTABLE_CONSISTENCY ones. I see - if it's opt-in per hashtable, then only a subset of types need a specialization. It sounds like it will be possible to fix the StringImpl/AtomicStringImpl cases once the new statically allocated StringImpl's return true from isStatic(). Not sure why that wasn't done in the first patch, but it sounds like it will be fixed. 861146 33 eric 2013-03-21 23:37:26 -0700 I disagree with the utility of this code, but I'm not particularly interested in pushing this change. Someone else can fight this fight a later time. 861147 34 eric 2013-03-21 23:38:15 -0700 "take up this cause" might have been more appropriate than "fight this fight" as a phrasing. :) 861159 35 ap 2013-03-22 00:01:25 -0700 I filed bug 113011 to restore the functionality. 947192 36 194193 ossy 2013-11-05 08:52:53 -0800 Comment on attachment 194193 Patch Cleared review? from attachment 194193 so that this bug does not appear in http://webkit.org/pending-review. If you would like this patch reviewed, please attach it to a new bug (or re-open this bug before marking it for review again). 194181 2013-03-20 21:36:39 -0700 2013-03-20 23:47:26 -0700 Patch bug-112873-20130320213231.patch text/plain 11814 eric U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ2NDM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDI2ZWMzNTY2MzMzZjBlNjVjODQzOTRh NWMzMTYyN2VkNzU0OTYzMDUuLjYzOTYzMjhiMWEyMWQ1Zjg0ODVkZGFhZWQzMmE5MWE3OWYwZDU4 MGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTMtMDMtMjAgIEVyaWMgU2VpZGVsICA8ZXJpY0B3 ZWJraXQub3JnPgorCisgICAgICAgIFJlbW92ZSBWYWx1ZUNoZWNrIHN5c3RlbQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEyODczCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVmFsdWVDaGVjazxUPiBhcHBl YXJzIHRvIGJlIGFuIHVuZmluaXNoZWQgZHJlYW0uCisgICAgICAgIEl0J3MgYSB3YXkgZm9yIG91 ciBjb250YWluZXIgY2xhc3NlcyB0byB0aGVvcmV0aWNhbGx5CisgICAgICAgIGNoZWNrIHRoZSBj b25zaXN0ZW5jeSBvZiB0aGUgdmFsdWVzIHRoZXkgY29udGFpbi4KKyAgICAgICAgQnV0IHRoZSBv bmx5IGNoZWNrIGl0IGRvZXMsIGlzIHRvIG1ha2Ugc3VyZSB0aGF0CisgICAgICAgIHBvaW50ZXJz IHRoZXkgY29udGFpbiBoYXZlIGEgbm9uLXplcm8gbWFsbG9jJ2Qgc2l6ZSAtLQorICAgICAgICB3 aGljaCByZWFsbHkgdHJhbnNsYXRlcyBpbnRvICJ3YXMgdGhpcyBwb2ludGVyIGFsbG9jZWQKKyAg ICAgICAgYnkgZmFzdE1hbGxvYyIuICBXZWJDb3JlIGRvZXNuJ3QgZXZlbiBhbHdheXMgdXNlIGZh c3RNYWxsb2MKKyAgICAgICAgYW5kIHNvbWUgcG9pbnRlciAoaW5jbHVkaW5nIHNvb24gU3RyaW5n SW1wbCkgY2FuIGJlCisgICAgICAgIHN0YWNrIG9yIGNvbXBpbGVyLWFsbG9jYXRlZCBhbmQgdGh1 cyBjYXVzZSB1cyB0byBhZGQKKyAgICAgICAgY29kZSB0byBkaXNhYmxlIHRoaXMgb3RoZXJ3aXNl IHNlZW1pbmdseSB1c2VsZXNzIGNoZWNrLgorICAgICAgICBJIGRvbid0IHRoaW5rIHRoaXMgY29k ZSBpcyByZWFsbHkgZ2V0dGluZyB1cyBhbnl0aGluZyBhbnltb3JlCisgICAgICAgIGFuZCBzaG91 bGQgYmUgcmVtb3ZlZC4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAg ICogV1RGLmd5cGk6CisgICAgICAgICogV1RGLnBybzoKKyAgICAgICAgKiBXVEYudmNwcm9qL1dU Ri52Y3Byb2o6CisgICAgICAgICogV1RGLnZjeHByb2ovV1RGLnZjeHByb2o6CisgICAgICAgICog V1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogd3RmL0NNYWtlTGlzdHMu dHh0OgorICAgICAgICAqIHd0Zi9IYXNoVGFibGUuaDoKKyAgICAgICAgKFdURjo6OjpjaGVja1Rh YmxlQ29uc2lzdGVuY3lFeGNlcHRTaXplKToKKyAgICAgICAgKiB3dGYvVmVjdG9yLmg6CisgICAg ICAgIChWZWN0b3IpOgorICAgICAgICAoV1RGKToKKwogMjAxMy0wMy0yMCAgQWRhbSBCYXJ0aCAg PGFiYXJ0aEB3ZWJraXQub3JnPgogCiAgICAgICAgIEhUTUxOYW1lcyBzaG91bGQgY29uc3RydWN0 IHN0cmluZ3MgYXQgY29tcGlsZSB0aW1lCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTgwZDhmZWEyODY4MmJmZDZi MTA3MzExNmYxOWZmMDg0ZWY3YzRjZC4uY2JmZWE2NzA1MjIyODUzODY0NDUzOWYwMjIyODQ2ZWU5 NGM1NWE3ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEzLTAzLTIwICBFcmljIFNl aWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KKworICAgICAgICBSZW1vdmUgVmFsdWVDaGVjayBzeXN0 ZW0KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExMjg3 MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEltYWdl TG9hZGVyIG5vIGxvbmdlciBuZWVkcyB0byBkaXNhYmxlIHRoZSBWYWx1ZUNoZWNrCisgICAgICAg IGNoZWNrcywgYXMgdGhleSdyZSBiZWluZyByZW1vdmVkLgorCisgICAgICAgICogbG9hZGVyL0lt YWdlTG9hZGVyLmNwcDoKKwogMjAxMy0wMy0yMCAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQu b3JnPgogCiAgICAgICAgIEhUTUxOYW1lcyBzaG91bGQgY29uc3RydWN0IHN0cmluZ3MgYXQgY29t cGlsZSB0aW1lCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9T b3VyY2UvV1RGL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggYjFlODI1ZjQyMjVjOTViNjE0OTM2 NDlhM2U4MDM3ODJjYjJkY2JkZC4uODQyZjA4ZWVmYTQwN2Q1YWMzNWQ5ODAyYTNlNTAyN2E5NDlh MjFmYSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9HTlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1Nv dXJjZS9XVEYvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAtMTk4LDcgKzE5OCw2IEBAIHd0Zl9zb3Vy Y2VzICs9IFwKICAgICBTb3VyY2UvV1RGL3d0Zi9VbmlvbkZpbmQuaCBcCiAgICAgU291cmNlL1dU Ri93dGYvVW51c2VkUGFyYW0uaCBcCiAgICAgU291cmNlL1dURi93dGYvVk1UYWdzLmggXAotICAg IFNvdXJjZS9XVEYvd3RmL1ZhbHVlQ2hlY2suaCBcCiAgICAgU291cmNlL1dURi93dGYvVmVjdG9y LmggXAogICAgIFNvdXJjZS9XVEYvd3RmL1ZlY3RvclRyYWl0cy5oIFwKICAgICBTb3VyY2UvV1RG L3d0Zi9XVEZUaHJlYWREYXRhLmNwcCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1dURi5neXBp IGIvU291cmNlL1dURi9XVEYuZ3lwaQppbmRleCAwYjM5NmZjMWZiNTY1YmY0ODM1NTgwOTQ4YTBh NTI1ODdkYzJlYzkwLi5lMDNmOTZjNTNlMGZjNDI1MDFkNzRhMDA3NTEzMzFkNjEzNTFiM2ZjIDEw MDY0NAotLS0gYS9Tb3VyY2UvV1RGL1dURi5neXBpCisrKyBiL1NvdXJjZS9XVEYvV1RGLmd5cGkK QEAgLTEwOSw3ICsxMDksNiBAQAogICAgICAgICAgICAgJ3d0Zi9UeXBlVHJhaXRzLmgnLAogICAg ICAgICAgICAgJ3d0Zi9VbnVzZWRQYXJhbS5oJywKICAgICAgICAgICAgICd3dGYvVk1UYWdzLmgn LAotICAgICAgICAgICAgJ3d0Zi9WYWx1ZUNoZWNrLmgnLAogICAgICAgICAgICAgJ3d0Zi9WZWN0 b3IuaCcsCiAgICAgICAgICAgICAnd3RmL1ZlY3RvclRyYWl0cy5oJywKICAgICAgICAgICAgICd3 dGYvV1RGVGhyZWFkRGF0YS5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvV1RGLnBybyBiL1Nv dXJjZS9XVEYvV1RGLnBybwppbmRleCBkZjk4MDFkZTcwMDZiNzdhMTEyNjJmOTQ5YTIzOGI5NTQ0 YjBmOTQxLi45MjUxMTk4MzkyM2YyODFkODBjZGY2ZTc5OTI3Yzc3ODA2ZjY4NmZlIDEwMDY0NAot LS0gYS9Tb3VyY2UvV1RGL1dURi5wcm8KKysrIGIvU291cmNlL1dURi9XVEYucHJvCkBAIC0xODQs NyArMTg0LDYgQEAgSEVBREVSUyArPSBcCiAgICAgdW5pY29kZS9Vbmljb2RlTWFjcm9zRnJvbUlD VS5oIFwKICAgICB1bmljb2RlL1VURjguaCBcCiAgICAgVW51c2VkUGFyYW0uaCBcCi0gICAgVmFs dWVDaGVjay5oIFwKICAgICBWZWN0b3IuaCBcCiAgICAgVmVjdG9yVHJhaXRzLmggXAogICAgIFZN VGFncy5oIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvV1RGLnZjcHJvai9XVEYudmNwcm9qIGIv U291cmNlL1dURi9XVEYudmNwcm9qL1dURi52Y3Byb2oKaW5kZXggM2ZjOWI3OTM4MjUzNzI5ODc1 MjdmN2RiMzg4ZTMyNTA1MTM5YjYxYi4uYTMwNGMwOTI5MWUzOTI0N2I2ZWRkZDFjZTZlYTI3OWYw Nzg0MmQ0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9XVEYudmNwcm9qL1dURi52Y3Byb2oKKysr IGIvU291cmNlL1dURi9XVEYudmNwcm9qL1dURi52Y3Byb2oKQEAgLTEzMTMsMTAgKzEzMTMsNiBA QAogCQkJPgogCQk8L0ZpbGU+CiAJCTxGaWxlCi0JCQlSZWxhdGl2ZVBhdGg9Ii4uXHd0ZlxWYWx1 ZUNoZWNrLmgiCi0JCQk+Ci0JCTwvRmlsZT4KLQkJPEZpbGUKIAkJCVJlbGF0aXZlUGF0aD0iLi5c d3RmXFZlY3Rvci5oIgogCQkJPgogCQk8L0ZpbGU+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1dU Ri52Y3hwcm9qL1dURi52Y3hwcm9qIGIvU291cmNlL1dURi9XVEYudmN4cHJvai9XVEYudmN4cHJv agppbmRleCAyNTU5ZWMxZjU0YTg1NDZhMDlhNDEyODUzYThhOWYzNjA1OGUzZmI5Li5lMmUyZGJh NTQ3ZDk0MDZmNWVkOWY2NDQwM2Q2YjEzMWY5Njg0YmJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RG L1dURi52Y3hwcm9qL1dURi52Y3hwcm9qCisrKyBiL1NvdXJjZS9XVEYvV1RGLnZjeHByb2ovV1RG LnZjeHByb2oKQEAgLTI2MSw3ICsyNjEsNiBAQAogICAgIDxDbEluY2x1ZGUgSW5jbHVkZT0iLi5c d3RmXHVuaWNvZGVcVW5pY29kZU1hY3Jvc0Zyb21JQ1UuaCIgLz4NCiAgICAgPENsSW5jbHVkZSBJ bmNsdWRlPSIuLlx3dGZcdW5pY29kZVxVVEY4LmgiIC8+DQogICAgIDxDbEluY2x1ZGUgSW5jbHVk ZT0iLi5cd3RmXFVudXNlZFBhcmFtLmgiIC8+DQotICAgIDxDbEluY2x1ZGUgSW5jbHVkZT0iLi5c d3RmXFZhbHVlQ2hlY2suaCIgLz4NCiAgICAgPENsSW5jbHVkZSBJbmNsdWRlPSIuLlx3dGZcVmVj dG9yLmgiIC8+DQogICAgIDxDbEluY2x1ZGUgSW5jbHVkZT0iLi5cd3RmXFZNVGFncy5oIiAvPg0K ICAgICA8Q2xJbmNsdWRlIEluY2x1ZGU9Ii4uXHd0ZlxXVEZUaHJlYWREYXRhLmgiIC8+DQpAQCAt NTA0LDQgKzUwMyw0IEBACiAgIDxJbXBvcnQgUHJvamVjdD0iJChWQ1RhcmdldHNQYXRoKVxNaWNy b3NvZnQuQ3BwLnRhcmdldHMiIC8+DQogICA8SW1wb3J0R3JvdXAgTGFiZWw9IkV4dGVuc2lvblRh cmdldHMiPg0KICAgPC9JbXBvcnRHcm91cD4NCi08L1Byb2plY3Q+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQorPC9Qcm9qZWN0Pg0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvV1RGLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV1RGL1dURi54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCmluZGV4IGU4MTU4N2NkZjkwODg0YjZiNjRhMWIyNjBhZTY0OWE4MzAxYmQ0MmUuLjVl OGVhNzhkZWYzODA3OGQ5YjAwNTA3ZGQzZDNkNzM2ZDA4Yzc2YzkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dURi9XVEYu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMjk5LDcgKzI5OSw2IEBACiAJCUE4QTQ3NDc2 MTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxDb21wb25lbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4QTQ3MzY4MTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxD b21wb25lbnQuaCAqLzsgfTsKIAkJQThBNDc0N0IxNTFBODI1QjAwNDEyM0ZGIC8qIFVSTFNlZ21l bnRzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4 QTQ3MzZEMTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxTZWdtZW50cy5jcHAgKi87IH07CiAJCUE4QTQ3 NDdDMTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxTZWdtZW50cy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQThBNDczNkUxNTFBODI1QjAwNDEyM0ZGIC8qIFVS TFNlZ21lbnRzLmggKi87IH07Ci0JCUE4QTQ3NDdEMTUxQTgyNUIwMDQxMjNGRiAvKiBWYWx1ZUNo ZWNrLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBOEE0 NzM2RjE1MUE4MjVCMDA0MTIzRkYgLyogVmFsdWVDaGVjay5oICovOyB9OwogCQlBOEE0NzQ3RTE1 MUE4MjVCMDA0MTIzRkYgLyogVmVjdG9yLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSBBOEE0NzM3MDE1MUE4MjVCMDA0MTIzRkYgLyogVmVjdG9yLmggKi87 IH07CiAJCUE4QTQ3NDdGMTUxQTgyNUIwMDQxMjNGRiAvKiBWZWN0b3JUcmFpdHMuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4QTQ3MzcxMTUxQTgyNUIw MDQxMjNGRiAvKiBWZWN0b3JUcmFpdHMuaCAqLzsgfTsKIAkJQThBNDc0ODAxNTFBODI1QjAwNDEy M0ZGIC8qIFZNVGFncy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gQThBNDczNzIxNTFBODI1QjAwNDEyM0ZGIC8qIFZNVGFncy5oICovOyB9OwpAQCAtNjE4 LDcgKzYxNyw2IEBACiAJCUE4QTQ3MzY4MTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxDb21wb25lbnQu aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVVJMQ29tcG9uZW50Lmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4QTQ3MzZEMTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxT ZWdtZW50cy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBVUkxTZWdt ZW50cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4QTQ3MzZFMTUxQTgyNUIw MDQxMjNGRiAvKiBVUkxTZWdtZW50cy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBVUkxTZWdtZW50cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQlBOEE0NzM2RjE1 MUE4MjVCMDA0MTIzRkYgLyogVmFsdWVDaGVjay5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBWYWx1ZUNoZWNrLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4QTQ3 MzcwMTUxQTgyNUIwMDQxMjNGRiAvKiBWZWN0b3IuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gVmVjdG9yLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4QTQ3Mzcx MTUxQTgyNUIwMDQxMjNGRiAvKiBWZWN0b3JUcmFpdHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Yy5oOyBwYXRoID0gVmVjdG9yVHJhaXRzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CUE4QTQ3MzcyMTUxQTgyNUIwMDQxMjNGRiAvKiBWTVRhZ3MuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gVk1UYWdzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC04 OTgsNyArODk2LDYgQEAKIAkJCQlBOEE0NzM0NTE1MUE4MjVCMDA0MTIzRkYgLyogVWludDhDbGFt cGVkQXJyYXkuaCAqLywKIAkJCQlBOEE0NzM1QzE1MUE4MjVCMDA0MTIzRkYgLyogVW5pb25GaW5k LmggKi8sCiAJCQkJQThBNDczNUQxNTFBODI1QjAwNDEyM0ZGIC8qIFVudXNlZFBhcmFtLmggKi8s Ci0JCQkJQThBNDczNkYxNTFBODI1QjAwNDEyM0ZGIC8qIFZhbHVlQ2hlY2suaCAqLywKIAkJCQlB OEE0NzM3MDE1MUE4MjVCMDA0MTIzRkYgLyogVmVjdG9yLmggKi8sCiAJCQkJQThBNDczNzExNTFB ODI1QjAwNDEyM0ZGIC8qIFZlY3RvclRyYWl0cy5oICovLAogCQkJCUE4QTQ3MzcyMTUxQTgyNUIw MDQxMjNGRiAvKiBWTVRhZ3MuaCAqLywKQEAgLTEyNzgsNyArMTI3NSw2IEBACiAJCQkJMjZFNkMy MEExNjA5MDM3MzAwQ0E2QUY0IC8qIFVSTFV0aWxJbnRlcm5hbC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJQThBNDc0NkExNTFBODI1QjAwNDEyM0ZGIC8qIFVURjguaCBpbiBIZWFkZXJzICovLAogCQkJ CUE4QTQ3M0I5MTUxQTgyNUIwMDQxMjNGRiAvKiB1dGlscy5oIGluIEhlYWRlcnMgKi8sCi0JCQkJ QThBNDc0N0QxNTFBODI1QjAwNDEyM0ZGIC8qIFZhbHVlQ2hlY2suaCBpbiBIZWFkZXJzICovLAog CQkJCUE4QTQ3NDdFMTUxQTgyNUIwMDQxMjNGRiAvKiBWZWN0b3IuaCBpbiBIZWFkZXJzICovLAog CQkJCUE4QTQ3NDdGMTUxQTgyNUIwMDQxMjNGRiAvKiBWZWN0b3JUcmFpdHMuaCBpbiBIZWFkZXJz ICovLAogCQkJCUE4QTQ3NDgwMTUxQTgyNUIwMDQxMjNGRiAvKiBWTVRhZ3MuaCBpbiBIZWFkZXJz ICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvQ01ha2VMaXN0cy50eHQgYi9Tb3VyY2Uv V1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAppbmRleCA0NDczNTBiOGZmYzk1MTIzNTI4YjVjNzIxOGZl ZjdkMzZlYzI2MGNmLi5hZGQzYjNjYjMxMTk1ZGNhZGU0MmFlN2U2NWI5MDgwNDY2NTc3N2M1IDEw MDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9DTWFrZUxpc3RzLnR4dAorKysgYi9Tb3VyY2UvV1RG L3d0Zi9DTWFrZUxpc3RzLnR4dApAQCAtMTE5LDcgKzExOSw2IEBAIHNldChXVEZfSEVBREVSUwog ICAgIFR5cGVUcmFpdHMuaAogICAgIFVudXNlZFBhcmFtLmgKICAgICBWTVRhZ3MuaAotICAgIFZh bHVlQ2hlY2suaAogICAgIFZlY3Rvci5oCiAgICAgVmVjdG9yVHJhaXRzLmgKICAgICBXVEZUaHJl YWREYXRhLmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0hhc2hUYWJsZS5oIGIvU291cmNl L1dURi93dGYvSGFzaFRhYmxlLmgKaW5kZXggNmU1MWI0NTA3MjU4ZGZkZDM0ZWMwZDY2ZDVhOWM2 ZmM4N2Q3MzljYS4uYWM3MjNhMmZhMWQ5ODM0NmVlZDRhYTAzN2I3ZDMzMmU5ZTFiNGIzOCAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi93dGYvSGFzaFRhYmxlLmgKKysrIGIvU291cmNlL1dURi93dGYv SGFzaFRhYmxlLmgKQEAgLTI5LDcgKzI5LDYgQEAKICNpbmNsdWRlIDx3dGYvSGFzaFRyYWl0cy5o PgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5n Lmg+Ci0jaW5jbHVkZSA8d3RmL1ZhbHVlQ2hlY2suaD4KIAogI2lmbmRlZiBOREVCVUcKIC8vIFJl cXVpcmVkIGZvciBDSEVDS19IQVNIVEFCTEVfSVRFUkFUT1JTLgpAQCAtMTI0NSw4ICsxMjQ0LDYg QEAgbmFtZXNwYWNlIFdURiB7CiAgICAgICAgICAgICBjb25zdF9pdGVyYXRvciBpdCA9IGZpbmQo RXh0cmFjdG9yOjpleHRyYWN0KCplbnRyeSkpOwogICAgICAgICAgICAgQVNTRVJUKGVudHJ5ID09 IGl0Lm1fcG9zaXRpb24pOwogICAgICAgICAgICAgKytjb3VudDsKLQotICAgICAgICAgICAgVmFs dWVDaGVjazxLZXk+OjpjaGVja0NvbnNpc3RlbmN5KGl0LT5rZXkpOwogICAgICAgICB9CiAKICAg ICAgICAgQVNTRVJUKGNvdW50ID09IG1fa2V5Q291bnQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dU Ri93dGYvVmVjdG9yLmggYi9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaAppbmRleCA4ZjhjZTg5YzUx NGJkODFjOTc1YWQyZTA3YTMzMzNlOGU0NTI0OWU1Li4xYTczN2FhZTk2YTI4ZGNhM2U4ODU5OTkw MTUxNTE5NDEyNzBhZDFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaAorKysg Yi9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaApAQCAtMjcsNyArMjcsNiBAQAogI2luY2x1ZGUgPHd0 Zi9Ob3RGb3VuZC5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KICNpbmNsdWRlIDx3 dGYvVW51c2VkUGFyYW0uaD4KLSNpbmNsdWRlIDx3dGYvVmFsdWVDaGVjay5oPgogI2luY2x1ZGUg PHd0Zi9WZWN0b3JUcmFpdHMuaD4KICNpbmNsdWRlIDxsaW1pdHM+CiAjaW5jbHVkZSA8dXRpbGl0 eT4KQEAgLTY0Miw4ICs2NDEsNiBAQCBuYW1lc3BhY2UgV1RGIHsKIAogICAgICAgICB2b2lkIHJl dmVyc2UoKTsKIAotICAgICAgICB2b2lkIGNoZWNrQ29uc2lzdGVuY3koKTsKLQogICAgIHByaXZh dGU6CiAgICAgICAgIHZvaWQgZXhwYW5kQ2FwYWNpdHkoc2l6ZV90IG5ld01pbkNhcGFjaXR5KTsK ICAgICAgICAgY29uc3QgVCogZXhwYW5kQ2FwYWNpdHkoc2l6ZV90IG5ld01pbkNhcGFjaXR5LCBj b25zdCBUKik7CkBAIC0xMTQ5LDE1ICsxMTQ2LDYgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgfQog CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgc2l6ZV90IGlubGluZUNhcGFjaXR5PgotICAgIGlu bGluZSB2b2lkIFZlY3RvcjxULCBpbmxpbmVDYXBhY2l0eT46OmNoZWNrQ29uc2lzdGVuY3koKQot ICAgIHsKLSNpZiAhQVNTRVJUX0RJU0FCTEVECi0gICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBp IDwgc2l6ZSgpOyArK2kpCi0gICAgICAgICAgICBWYWx1ZUNoZWNrPFQ+OjpjaGVja0NvbnNpc3Rl bmN5KGF0KGkpKTsKLSNlbmRpZgotICAgIH0KLQotICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQsIHNp emVfdCBpbmxpbmVDYXBhY2l0eT4KICAgICB2b2lkIGRlbGV0ZUFsbFZhbHVlcyhjb25zdCBWZWN0 b3I8VCwgaW5saW5lQ2FwYWNpdHk+JiBjb2xsZWN0aW9uKQogICAgIHsKICAgICAgICAgdHlwZWRl ZiB0eXBlbmFtZSBWZWN0b3I8VCwgaW5saW5lQ2FwYWNpdHk+Ojpjb25zdF9pdGVyYXRvciBpdGVy YXRvcjsKQEAgLTExODcsMTYgKzExNzUsNiBAQCBuYW1lc3BhY2UgV1RGIHsKICAgICAgICAgcmV0 dXJuICEoYSA9PSBiKTsKICAgICB9CiAKLSNpZiAhQVNTRVJUX0RJU0FCTEVECi0gICAgdGVtcGxh dGU8dHlwZW5hbWUgVD4gc3RydWN0IFZhbHVlQ2hlY2s8VmVjdG9yPFQ+ID4gewotICAgICAgICB0 eXBlZGVmIFZlY3RvcjxUPiBUcmFpdFR5cGU7Ci0gICAgICAgIHN0YXRpYyB2b2lkIGNoZWNrQ29u c2lzdGVuY3koY29uc3QgVmVjdG9yPFQ+JiB2KQotICAgICAgICB7Ci0gICAgICAgICAgICB2LmNo ZWNrQ29uc2lzdGVuY3koKTsKLSAgICAgICAgfQotICAgIH07Ci0jZW5kaWYKLQogfSAvLyBuYW1l c3BhY2UgV1RGCiAKIHVzaW5nIFdURjo6VmVjdG9yOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9JbWFnZUxv YWRlci5jcHAKaW5kZXggZGYyMTFlNzY4NDk0YTQxZmMwNGYyZTA0M2E0ZDdlM2U2MmY1YjA5My4u Yjc4OThkMTkyMjY0ODkxMjg0YzZiZjY1NTI4NzU2ZWNiNTU1YmUxZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9s b2FkZXIvSW1hZ2VMb2FkZXIuY3BwCkBAIC00NiwyNCArNDYsNiBAQAogI2luY2x1ZGUgIlJlbmRl clZpZGVvLmgiCiAjZW5kaWYKIAotI2lmICFBU1NFUlRfRElTQUJMRUQKLS8vIEltYWdlTG9hZGVy IG9iamVjdHMgYXJlIGFsbG9jYXRlZCBhcyBtZW1iZXJzIG9mIG90aGVyIG9iamVjdHMsIHNvIGdl bmVyaWMgcG9pbnRlciBjaGVjayB3b3VsZCBhbHdheXMgZmFpbC4KLW5hbWVzcGFjZSBXVEYgewot Ci10ZW1wbGF0ZTw+IHN0cnVjdCBWYWx1ZUNoZWNrPFdlYkNvcmU6OkltYWdlTG9hZGVyKj4gewot ICAgIHR5cGVkZWYgV2ViQ29yZTo6SW1hZ2VMb2FkZXIqIFRyYWl0VHlwZTsKLSAgICBzdGF0aWMg dm9pZCBjaGVja0NvbnNpc3RlbmN5KGNvbnN0IFdlYkNvcmU6OkltYWdlTG9hZGVyKiBwKQotICAg IHsKLSAgICAgICAgaWYgKCFwKQotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICBBU1NFUlQo cC0+ZWxlbWVudCgpKTsKLSAgICAgICAgVmFsdWVDaGVjazxXZWJDb3JlOjpFbGVtZW50Kj46OmNo ZWNrQ29uc2lzdGVuY3kocC0+ZWxlbWVudCgpKTsKLSAgICB9Ci19OwotCi19Ci0jZW5kaWYKLQog bmFtZXNwYWNlIFdlYkNvcmUgewogCiBzdGF0aWMgSW1hZ2VFdmVudFNlbmRlciYgYmVmb3JlTG9h ZEV2ZW50U2VuZGVyKCkK 194193 2013-03-20 23:47:32 -0700 2013-11-05 08:52:53 -0800 Patch bug-112873-20130320234323.patch text/plain 15273 eric U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ2NDM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDI2ZWMzNTY2MzMzZjBlNjVjODQzOTRh NWMzMTYyN2VkNzU0OTYzMDUuLmYwYzEwZGQ5ODJhYjMwYzUwMjYyZmRjNWU5NTk4OGNjMWRlOWQ5 ZDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsNzUgQEAKKzIwMTMtMDMtMjAgIEVyaWMgU2VpZGVsICA8ZXJpY0B3 ZWJraXQub3JnPgorCisgICAgICAgIFJlbW92ZSBWYWx1ZUNoZWNrIHN5c3RlbQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEyODczCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVmFsdWVDaGVjazxUPiBpcyB0 aGVvcmV0aWNhbGx5IGEgd2F5IGZvciBvdXIgY29udGFpbmVyCisgICAgICAgIGNsYXNzZXMgdG8g Y2hlY2sgdGhlIGNvbnNpc3RlbmN5IG9mIHRoZSB2YWx1ZXMgdGhhdCB0aGV5CisgICAgICAgIGNv bnRhaW4uCisKKyAgICAgICAgVmFsdWVDaGVjayB3YXMgb25seSB1c2VkIGZvciBtZW1iZXJzIGlu IGEgVmVjdG9yLCBhbmQKKyAgICAgICAga2V5cyBpbiBhIEhhc2hUYWJsZSAodGh1cyBIYXNoU2V0 IGFzIHdlbGwpLgorCisgICAgICAgIFRoZXJlIHdhcyBvbmx5IG9uZSBjYWxsZXIgb2YgVmVjdG9y OjpjaGVja0NvbnNpc3RlbmN5LAorICAgICAgICBhbHRob3VnaCB0aGVyZSBhcmUgc2V2ZXJhbCBj YWxsZXJzIG9mIEhhc2hUYWJsZTo6Y2hlY2tDb25zaXN0ZW5jeQorICAgICAgICAod2hpY2ggZG9l cyBvdGhlciBtb3JlIGludGVyZXN0aW5nIGNoZWNrcyBhcyB3ZWxsKS4KKworICAgICAgICBUaGUg Z2VuZXJpYyBpbXBsZW1lbnRhdGlvbiBvZiBWYWx1ZUNoZWNrPFQ+IGlzIGEgZGVidWctdGltZQor ICAgICAgICBBU1NFUlQgdGhhdCB0aGUgcG9pbnRlciBpbiBxdWVzdGlvbiBpcyBrbm93biB0byBm YXN0TWFsbG9jLgorICAgICAgICBJbiBSZWxlYXNlIGJ1aWxkcyBWYWx1ZUNoZWNrIGlzIGNvbXBp bGVkIG91dC4KKworICAgICAgICBUaGUgb25seSBzcGVjaWFsaXphdGlvbnMgb2YgVmFsdWVDaGVj azxUPiBhcmUgdG8gb3B0LW91dAorICAgICAgICBvZiB0aGUgZGVmYXVsdCAiZG9lcyBtYWxsb2Mg a25vdyB0aGlzIHBvaW50ZXIiIGJlaGF2aW9yLAorICAgICAgICBmb3IgdHlwZXMgd2hpY2ggbWF5 IG5vdCBhbHdheXMgYmUgYWxsb2NhdGVkIGRpcmVjdGx5IGJ5CisgICAgICAgIGZhc3RNYWxsb2Mg KGluIHRoZSBjYXNlIG9mIHBvaW50ZXJzIHRvIG1lbWJlciBzdHJ1Y3RzLAorICAgICAgICBvYmpl Y3RzIHdoaWNoIGNhbiBiZSBzdGF0aWNhbGx5IGFsbG9jYXRlZCwgb3IKKyAgICAgICAgYWxsb2Nh dGVkIG9uIHRoZSBzdGFjaywgZXRjLikKKworICAgICAgICBJIHN0YXJ0ZWQgdG8gYWRkIGFub3Ro ZXIgb25lIG9mIHRoZXNlIHNwZWNpYWxpemF0aW9ucworICAgICAgICBmb3IgVmFsdWVDaGVjazxT dHJpbmdJbXBsKj4gbm93IHRoYXQgU3RyaW5nSW1wbHMgY2FuCisgICAgICAgIGJlIHN0YXRpY2Fs bHkgYWxsb2NhdGVkIChidWcgMTEyODMxKSBidXQgaW4gbG9va2luZworICAgICAgICBhcm91bmQg YXQgdGhlIHJlc3Qgb2YgdGhlIFZhbHVlQ2hlY2sgc3lzdGVtIGFuZCBzcGVjaWFsaXphdGlvbnMK KyAgICAgICAgdGhlIGJlaGF2aW9yIG9mIHZhbGlkYXRpbmcgdGhhdCBwb2ludGVycyBhcmUga25v d24KKyAgICAgICAgdG8gbWFsbG9jIGRpZCBub3Qgc2VlbSBwYXJ0aWN1bGFybHkgdXNlZnVsIHRv IG1lLAorICAgICAgICBzbyBJIGhhdmUgcG9zdGVkIGEgcGF0Y2ggYXMgYSBwcm9wb3NhbCB0byBy ZW1vdmUgVmFsdWVDaGVjazxUPi4KKworICAgICAgICBQcmVzdW1hYmx5IHdlIGNvdWxkIGltcGxl bWVudCBtdWNoIG1vcmUgaW50ZXJlc3RpbmcKKyAgICAgICAgY29uc2lzdGVuY3kgY2hlY2tzIGlu IFZhbHVlQ2hlY2s8VD4gc3BlY2lhbGl6YXRpb25zCisgICAgICAgIGJ1dCB0aGF0IGFwcGVhcnMg dG8gYmUgYSBkcmVhbSB3aGljaCBoYXMgbm90IGJlZW4KKyAgICAgICAgcmVhbGl6ZWQgaW4gdGhl IDMgeWVhcnMgc2luY2UgaXQgd2FzIGFkZGVkOgorICAgICAgICBodHRwOi8vdHJhYy53ZWJraXQu b3JnL2NoYW5nZXNldC81NDYxOAorCisgICAgICAgIEknbSBoYXBweSBmb3IgdXMgdG8gbGVhdmUg dGhpcyBjb2RlIGluIGlmIHdlIGhhdmUgYSBzdHJvbmcKKyAgICAgICAgdXNlIGZvciBpdCwgYnV0 IGFzIGlzIGl0IHNlZW1zIHVubmVlZGVkLiAgSXQgYXBwZWFycworICAgICAgICBvcmlnaW5hbGx5 IGRlc2lnbmVkIHRvIGNhdGNoIHBvaW50ZXJzIHRvIGRlbGV0ZWQgb2JqZWN0cworICAgICAgICBp biBWZWN0b3JzIG9yIGtleXMgaW4gSGFzaFRhYmxlcyBkdXJpbmcgRGVidWcgYnVpbGRzIGVhcmxp ZXIgdGhhbgorICAgICAgICBkZXJlZmZlcmVuY2luZyB0aGF0IHBvaW50ZXIgbWlnaHQgaGF2ZSBk b25lLgorCisgICAgICAgIFRoZSBiZW5pZml0cyBvZiB0aGlzIGNoYW5nZSB3b3VsZCBiZSByZW1v dmluZyBjb2RlIHdoaWNoCisgICAgICAgIHNlZW1zICh0byBtZSkgdG8gZ2l2ZSB1cyBsaXR0bGUg c2VjdXJpdHkgYmVuaWZpdHMsCisgICAgICAgIGFuZCBwcmV2ZW50aW5nIG90aGVycyBpbiB0aGUg ZnV0dXJlIGZyb20gaGF2aW5nCisgICAgICAgIHRvIGFkZCBzcGVjaWFsIHRlbXBsYXRlIGNvZGUg dG8gYWxsb3cgdGhlaXIgb2JqZWN0cworICAgICAgICB0byBleGlzdCBpbiBWZWN0b3JzL0hhc2hU YWJsZXMgdy9vIGJlaW5nIGRpcmVjdGx5CisgICAgICAgIGFsbG9jYXRlZCBieSBmYXN0TWFsbG9j LiAgVGhpcyBzZWVtcyB0byBtZSBsaWtlIHRoZQorICAgICAgICAiYmV0dGVyIiBjaGFuZ2UgdGhh biBqdXN0IGFkZGluZyBhbm90aGVyIHNwZWNpYWxpemF0aW9uCisgICAgICAgIGZvciBWYWx1ZUNo ZWNrPFN0cmluZ0ltcGwqPiB0byBkaXNhYmxlIGNoZWNraW5nIGZvcgorICAgICAgICBTdHJpbmdJ bXBsLgorCisgICAgICAgICogR05VbWFrZWZpbGUubGlzdC5hbToKKyAgICAgICAgKiBXVEYuZ3lw aToKKyAgICAgICAgKiBXVEYucHJvOgorICAgICAgICAqIFdURi52Y3Byb2ovV1RGLnZjcHJvajoK KyAgICAgICAgKiBXVEYudmN4cHJvai9XVEYudmN4cHJvajoKKyAgICAgICAgKiBXVEYueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiB3dGYvQ01ha2VMaXN0cy50eHQ6CisgICAg ICAgICogd3RmL0hhc2hUYWJsZS5oOgorICAgICAgICAoV1RGOjo6OmNoZWNrVGFibGVDb25zaXN0 ZW5jeUV4Y2VwdFNpemUpOgorICAgICAgICAqIHd0Zi9WZWN0b3IuaDoKKyAgICAgICAgKFZlY3Rv cik6CisgICAgICAgIChXVEYpOgorCiAyMDEzLTAzLTIwICBBZGFtIEJhcnRoICA8YWJhcnRoQHdl YmtpdC5vcmc+CiAKICAgICAgICAgSFRNTE5hbWVzIHNob3VsZCBjb25zdHJ1Y3Qgc3RyaW5ncyBh dCBjb21waWxlIHRpbWUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1ODBkOGZlYTI4NjgyYmZkNmIxMDczMTE2ZjE5 ZmYwODRlZjdjNGNkLi43NjA4MTA2NzA1N2U4OGFlNGEyNDgzMzgwOGVhYWRhYmExNzE2YWIzIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMTMtMDMtMjAgIEVyaWMgU2VpZGVsICA8ZXJp Y0B3ZWJraXQub3JnPgorCisgICAgICAgIFJlbW92ZSBWYWx1ZUNoZWNrIHN5c3RlbQorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEyODczCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRG9jdW1lbnRPcmRlck1h cCBkZWNsYXJlZCBhIGNoZWNrQ29uc2lzdGVuY3koKSBmdW5jdGlvbgorICAgICAgICB3aGljaCB3 YXMgbmV2ZXIgaW1wbGVtZW50ZWQgKG9yIHVzZWQpLgorCisgICAgICAgIEV2ZW50U2VuZGVyIG5v IGxvbmdlciBuZWVkcyB0byBjYWxsICJjaGVja0NvbnNpc3RlbmN5IgorICAgICAgICBvbiBpdCdz ICJkaXNwYXRjaFNvb25MaXN0IiBWZWN0b3IuCisgICAgICAgIEluIGZhY3QsIEV2ZW50U2VuZGVy IHdhcyB0aGUgb25seSBjYWxsZXIgb2YgVmVjdG9yOjpjaGVja0NvbnNpc3RlbmN5KCkuCisKKyAg ICAgICAgSW1hZ2VMb2FkZXIgbm8gbG9uZ2VyIG5lZWRzIHRvIG9wdC1vdXQgb2YgdGhlIFZhbHVl Q2hlY2sKKyAgICAgICAgY2hlY2tzLCBhcyB0aGV5J3JlIGJlaW5nIHJlbW92ZWQuCisKKyAgICAg ICAgKiBkb20vRG9jdW1lbnRPcmRlcmVkTWFwLmg6CisgICAgICAgIChEb2N1bWVudE9yZGVyZWRN YXApOgorICAgICAgICAqIGRvbS9FdmVudFNlbmRlci5oOgorICAgICAgICAoV2ViQ29yZTo6Ojpk aXNwYXRjaFBlbmRpbmdFdmVudHMpOgorICAgICAgICAqIGxvYWRlci9JbWFnZUxvYWRlci5jcHA6 CisKIDIwMTMtMDMtMjAgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KIAogICAgICAg ICBIVE1MTmFtZXMgc2hvdWxkIGNvbnN0cnVjdCBzdHJpbmdzIGF0IGNvbXBpbGUgdGltZQpkaWZm IC0tZ2l0IGEvU291cmNlL1dURi9HTlVtYWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dURi9HTlVt YWtlZmlsZS5saXN0LmFtCmluZGV4IGIxZTgyNWY0MjI1Yzk1YjYxNDkzNjQ5YTNlODAzNzgyY2Iy ZGNiZGQuLjg0MmYwOGVlZmE0MDdkNWFjMzVkOTgwMmEzZTUwMjdhOTQ5YTIxZmEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XVEYvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV1RGL0dOVW1h a2VmaWxlLmxpc3QuYW0KQEAgLTE5OCw3ICsxOTgsNiBAQCB3dGZfc291cmNlcyArPSBcCiAgICAg U291cmNlL1dURi93dGYvVW5pb25GaW5kLmggXAogICAgIFNvdXJjZS9XVEYvd3RmL1VudXNlZFBh cmFtLmggXAogICAgIFNvdXJjZS9XVEYvd3RmL1ZNVGFncy5oIFwKLSAgICBTb3VyY2UvV1RGL3d0 Zi9WYWx1ZUNoZWNrLmggXAogICAgIFNvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oIFwKICAgICBTb3Vy Y2UvV1RGL3d0Zi9WZWN0b3JUcmFpdHMuaCBcCiAgICAgU291cmNlL1dURi93dGYvV1RGVGhyZWFk RGF0YS5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9XVEYuZ3lwaSBiL1NvdXJjZS9XVEYv V1RGLmd5cGkKaW5kZXggMGIzOTZmYzFmYjU2NWJmNDgzNTU4MDk0OGEwYTUyNTg3ZGMyZWM5MC4u ZTAzZjk2YzUzZTBmYzQyNTAxZDc0YTAwNzUxMzMxZDYxMzUxYjNmYyAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi9XVEYuZ3lwaQorKysgYi9Tb3VyY2UvV1RGL1dURi5neXBpCkBAIC0xMDksNyArMTA5 LDYgQEAKICAgICAgICAgICAgICd3dGYvVHlwZVRyYWl0cy5oJywKICAgICAgICAgICAgICd3dGYv VW51c2VkUGFyYW0uaCcsCiAgICAgICAgICAgICAnd3RmL1ZNVGFncy5oJywKLSAgICAgICAgICAg ICd3dGYvVmFsdWVDaGVjay5oJywKICAgICAgICAgICAgICd3dGYvVmVjdG9yLmgnLAogICAgICAg ICAgICAgJ3d0Zi9WZWN0b3JUcmFpdHMuaCcsCiAgICAgICAgICAgICAnd3RmL1dURlRocmVhZERh dGEuaCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1dURi5wcm8gYi9Tb3VyY2UvV1RGL1dURi5w cm8KaW5kZXggZGY5ODAxZGU3MDA2Yjc3YTExMjYyZjk0OWEyMzhiOTU0NGIwZjk0MS4uOTI1MTE5 ODM5MjNmMjgxZDgwY2RmNmU3OTkyN2M3NzgwNmY2ODZmZSAxMDA2NDQKLS0tIGEvU291cmNlL1dU Ri9XVEYucHJvCisrKyBiL1NvdXJjZS9XVEYvV1RGLnBybwpAQCAtMTg0LDcgKzE4NCw2IEBAIEhF QURFUlMgKz0gXAogICAgIHVuaWNvZGUvVW5pY29kZU1hY3Jvc0Zyb21JQ1UuaCBcCiAgICAgdW5p Y29kZS9VVEY4LmggXAogICAgIFVudXNlZFBhcmFtLmggXAotICAgIFZhbHVlQ2hlY2suaCBcCiAg ICAgVmVjdG9yLmggXAogICAgIFZlY3RvclRyYWl0cy5oIFwKICAgICBWTVRhZ3MuaCBcCmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL1dURi52Y3Byb2ovV1RGLnZjcHJvaiBiL1NvdXJjZS9XVEYvV1RG LnZjcHJvai9XVEYudmNwcm9qCmluZGV4IDNmYzliNzkzODI1MzcyOTg3NTI3ZjdkYjM4OGUzMjUw NTEzOWI2MWIuLmEzMDRjMDkyOTFlMzkyNDdiNmVkZGQxY2U2ZWEyNzlmMDc4NDJkNDMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XVEYvV1RGLnZjcHJvai9XVEYudmNwcm9qCisrKyBiL1NvdXJjZS9XVEYv V1RGLnZjcHJvai9XVEYudmNwcm9qCkBAIC0xMzEzLDEwICsxMzEzLDYgQEAKIAkJCT4KIAkJPC9G aWxlPgogCQk8RmlsZQotCQkJUmVsYXRpdmVQYXRoPSIuLlx3dGZcVmFsdWVDaGVjay5oIgotCQkJ PgotCQk8L0ZpbGU+Ci0JCTxGaWxlCiAJCQlSZWxhdGl2ZVBhdGg9Ii4uXHd0ZlxWZWN0b3IuaCIK IAkJCT4KIAkJPC9GaWxlPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9XVEYudmN4cHJvai9XVEYu dmN4cHJvaiBiL1NvdXJjZS9XVEYvV1RGLnZjeHByb2ovV1RGLnZjeHByb2oKaW5kZXggMjU1OWVj MWY1NGE4NTQ2YTA5YTQxMjg1M2E4YTlmMzYwNThlM2ZiOS4uZTJlMmRiYTU0N2Q5NDA2ZjVlZDlm NjQ0MDNkNmIxMzFmOTY4NGJiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9XVEYudmN4cHJvai9X VEYudmN4cHJvagorKysgYi9Tb3VyY2UvV1RGL1dURi52Y3hwcm9qL1dURi52Y3hwcm9qCkBAIC0y NjEsNyArMjYxLDYgQEAKICAgICA8Q2xJbmNsdWRlIEluY2x1ZGU9Ii4uXHd0Zlx1bmljb2RlXFVu aWNvZGVNYWNyb3NGcm9tSUNVLmgiIC8+DQogICAgIDxDbEluY2x1ZGUgSW5jbHVkZT0iLi5cd3Rm XHVuaWNvZGVcVVRGOC5oIiAvPg0KICAgICA8Q2xJbmNsdWRlIEluY2x1ZGU9Ii4uXHd0ZlxVbnVz ZWRQYXJhbS5oIiAvPg0KLSAgICA8Q2xJbmNsdWRlIEluY2x1ZGU9Ii4uXHd0ZlxWYWx1ZUNoZWNr LmgiIC8+DQogICAgIDxDbEluY2x1ZGUgSW5jbHVkZT0iLi5cd3RmXFZlY3Rvci5oIiAvPg0KICAg ICA8Q2xJbmNsdWRlIEluY2x1ZGU9Ii4uXHd0ZlxWTVRhZ3MuaCIgLz4NCiAgICAgPENsSW5jbHVk ZSBJbmNsdWRlPSIuLlx3dGZcV1RGVGhyZWFkRGF0YS5oIiAvPg0KQEAgLTUwNCw0ICs1MDMsNCBA QAogICA8SW1wb3J0IFByb2plY3Q9IiQoVkNUYXJnZXRzUGF0aClcTWljcm9zb2Z0LkNwcC50YXJn ZXRzIiAvPg0KICAgPEltcG9ydEdyb3VwIExhYmVsPSJFeHRlbnNpb25UYXJnZXRzIj4NCiAgIDwv SW1wb3J0R3JvdXA+DQotPC9Qcm9qZWN0PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKKzwv UHJvamVjdD4NCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1dURi54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qIGIvU291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBl ODE1ODdjZGY5MDg4NGI2YjY0YTFiMjYwYWU2NDlhODMwMWJkNDJlLi41ZThlYTc4ZGVmMzgwNzhk OWIwMDUwN2RkM2QzZDczNmQwOGM3NmM5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL1dURi54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKQEAgLTI5OSw3ICsyOTksNiBAQAogCQlBOEE0NzQ3NjE1MUE4MjVCMDA0MTIz RkYgLyogVVJMQ29tcG9uZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBBOEE0NzM2ODE1MUE4MjVCMDA0MTIzRkYgLyogVVJMQ29tcG9uZW50LmggKi87 IH07CiAJCUE4QTQ3NDdCMTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxTZWdtZW50cy5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBOEE0NzM2RDE1MUE4MjVC MDA0MTIzRkYgLyogVVJMU2VnbWVudHMuY3BwICovOyB9OwogCQlBOEE0NzQ3QzE1MUE4MjVCMDA0 MTIzRkYgLyogVVJMU2VnbWVudHMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEE4QTQ3MzZFMTUxQTgyNUIwMDQxMjNGRiAvKiBVUkxTZWdtZW50cy5oICov OyB9OwotCQlBOEE0NzQ3RDE1MUE4MjVCMDA0MTIzRkYgLyogVmFsdWVDaGVjay5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQThBNDczNkYxNTFBODI1QjAw NDEyM0ZGIC8qIFZhbHVlQ2hlY2suaCAqLzsgfTsKIAkJQThBNDc0N0UxNTFBODI1QjAwNDEyM0ZG IC8qIFZlY3Rvci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gQThBNDczNzAxNTFBODI1QjAwNDEyM0ZGIC8qIFZlY3Rvci5oICovOyB9OwogCQlBOEE0NzQ3 RjE1MUE4MjVCMDA0MTIzRkYgLyogVmVjdG9yVHJhaXRzLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBOEE0NzM3MTE1MUE4MjVCMDA0MTIzRkYgLyogVmVj dG9yVHJhaXRzLmggKi87IH07CiAJCUE4QTQ3NDgwMTUxQTgyNUIwMDQxMjNGRiAvKiBWTVRhZ3Mu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4QTQ3Mzcy MTUxQTgyNUIwMDQxMjNGRiAvKiBWTVRhZ3MuaCAqLzsgfTsKQEAgLTYxOCw3ICs2MTcsNiBAQAog CQlBOEE0NzM2ODE1MUE4MjVCMDA0MTIzRkYgLyogVVJMQ29tcG9uZW50LmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFVSTENvbXBvbmVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQlBOEE0NzM2RDE1MUE4MjVCMDA0MTIzRkYgLyogVVJMU2VnbWVudHMuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gVVJMU2VnbWVudHMuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0NzM2RTE1MUE4MjVCMDA0MTIzRkYgLyogVVJM U2VnbWVudHMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVVJMU2VnbWVudHMu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKLQkJQThBNDczNkYxNTFBODI1QjAwNDEyM0ZG IC8qIFZhbHVlQ2hlY2suaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVmFsdWVD aGVjay5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0NzM3MDE1MUE4MjVCMDA0 MTIzRkYgLyogVmVjdG9yLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFZlY3Rv ci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0NzM3MTE1MUE4MjVCMDA0MTIz RkYgLyogVmVjdG9yVHJhaXRzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFZl Y3RvclRyYWl0cy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBOEE0NzM3MjE1MUE4 MjVCMDA0MTIzRkYgLyogVk1UYWdzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IFZNVGFncy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtODk4LDcgKzg5Niw2IEBA CiAJCQkJQThBNDczNDUxNTFBODI1QjAwNDEyM0ZGIC8qIFVpbnQ4Q2xhbXBlZEFycmF5LmggKi8s CiAJCQkJQThBNDczNUMxNTFBODI1QjAwNDEyM0ZGIC8qIFVuaW9uRmluZC5oICovLAogCQkJCUE4 QTQ3MzVEMTUxQTgyNUIwMDQxMjNGRiAvKiBVbnVzZWRQYXJhbS5oICovLAotCQkJCUE4QTQ3MzZG MTUxQTgyNUIwMDQxMjNGRiAvKiBWYWx1ZUNoZWNrLmggKi8sCiAJCQkJQThBNDczNzAxNTFBODI1 QjAwNDEyM0ZGIC8qIFZlY3Rvci5oICovLAogCQkJCUE4QTQ3MzcxMTUxQTgyNUIwMDQxMjNGRiAv KiBWZWN0b3JUcmFpdHMuaCAqLywKIAkJCQlBOEE0NzM3MjE1MUE4MjVCMDA0MTIzRkYgLyogVk1U YWdzLmggKi8sCkBAIC0xMjc4LDcgKzEyNzUsNiBAQAogCQkJCTI2RTZDMjBBMTYwOTAzNzMwMENB NkFGNCAvKiBVUkxVdGlsSW50ZXJuYWwuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4QTQ3NDZBMTUx QTgyNUIwMDQxMjNGRiAvKiBVVEY4LmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEE0NzNCOTE1MUE4 MjVCMDA0MTIzRkYgLyogdXRpbHMuaCBpbiBIZWFkZXJzICovLAotCQkJCUE4QTQ3NDdEMTUxQTgy NUIwMDQxMjNGRiAvKiBWYWx1ZUNoZWNrLmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEE0NzQ3RTE1 MUE4MjVCMDA0MTIzRkYgLyogVmVjdG9yLmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEE0NzQ3RjE1 MUE4MjVCMDA0MTIzRkYgLyogVmVjdG9yVHJhaXRzLmggaW4gSGVhZGVycyAqLywKIAkJCQlBOEE0 NzQ4MDE1MUE4MjVCMDA0MTIzRkYgLyogVk1UYWdzLmggaW4gSGVhZGVycyAqLywKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvd3RmL0NNYWtlTGlzdHMudHh0IGIvU291cmNlL1dURi93dGYvQ01ha2VM aXN0cy50eHQKaW5kZXggNDQ3MzUwYjhmZmM5NTEyMzUyOGI1YzcyMThmZWY3ZDM2ZWMyNjBjZi4u YWRkM2IzY2IzMTE5NWRjYWRlNDJhZTdlNjViOTA4MDQ2NjU3NzdjNSAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi93dGYvQ01ha2VMaXN0cy50eHQKKysrIGIvU291cmNlL1dURi93dGYvQ01ha2VMaXN0 cy50eHQKQEAgLTExOSw3ICsxMTksNiBAQCBzZXQoV1RGX0hFQURFUlMKICAgICBUeXBlVHJhaXRz LmgKICAgICBVbnVzZWRQYXJhbS5oCiAgICAgVk1UYWdzLmgKLSAgICBWYWx1ZUNoZWNrLmgKICAg ICBWZWN0b3IuaAogICAgIFZlY3RvclRyYWl0cy5oCiAgICAgV1RGVGhyZWFkRGF0YS5oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoVGFibGUuaCBiL1NvdXJjZS9XVEYvd3RmL0hhc2hU YWJsZS5oCmluZGV4IDZlNTFiNDUwNzI1OGRmZGQzNGVjMGQ2NmQ1YTljNmZjODdkNzM5Y2EuLmFj NzIzYTJmYTFkOTgzNDZlZWQ0YWEwMzdiN2QzMzJlOWUxYjRiMzggMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvd3RmL0hhc2hUYWJsZS5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0hhc2hUYWJsZS5oCkBA IC0yOSw3ICsyOSw2IEBACiAjaW5jbHVkZSA8d3RmL0hhc2hUcmFpdHMuaD4KICNpbmNsdWRlIDx3 dGYvU3RkTGliRXh0cmFzLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgotI2luY2x1ZGUg PHd0Zi9WYWx1ZUNoZWNrLmg+CiAKICNpZm5kZWYgTkRFQlVHCiAvLyBSZXF1aXJlZCBmb3IgQ0hF Q0tfSEFTSFRBQkxFX0lURVJBVE9SUy4KQEAgLTEyNDUsOCArMTI0NCw2IEBAIG5hbWVzcGFjZSBX VEYgewogICAgICAgICAgICAgY29uc3RfaXRlcmF0b3IgaXQgPSBmaW5kKEV4dHJhY3Rvcjo6ZXh0 cmFjdCgqZW50cnkpKTsKICAgICAgICAgICAgIEFTU0VSVChlbnRyeSA9PSBpdC5tX3Bvc2l0aW9u KTsKICAgICAgICAgICAgICsrY291bnQ7Ci0KLSAgICAgICAgICAgIFZhbHVlQ2hlY2s8S2V5Pjo6 Y2hlY2tDb25zaXN0ZW5jeShpdC0+a2V5KTsKICAgICAgICAgfQogCiAgICAgICAgIEFTU0VSVChj b3VudCA9PSBtX2tleUNvdW50KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5o IGIvU291cmNlL1dURi93dGYvVmVjdG9yLmgKaW5kZXggOGY4Y2U4OWM1MTRiZDgxYzk3NWFkMmUw N2EzMzMzZThlNDUyNDllNS4uMWE3MzdhYWU5NmEyOGRjYTNlODg1OTk5MDE1MTUxOTQxMjcwYWQx YSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVmVjdG9yLmgKKysrIGIvU291cmNlL1dURi93 dGYvVmVjdG9yLmgKQEAgLTI3LDcgKzI3LDYgQEAKICNpbmNsdWRlIDx3dGYvTm90Rm91bmQuaD4K ICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAjaW5jbHVkZSA8d3RmL1VudXNlZFBhcmFt Lmg+Ci0jaW5jbHVkZSA8d3RmL1ZhbHVlQ2hlY2suaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yVHJh aXRzLmg+CiAjaW5jbHVkZSA8bGltaXRzPgogI2luY2x1ZGUgPHV0aWxpdHk+CkBAIC02NDIsOCAr NjQxLDYgQEAgbmFtZXNwYWNlIFdURiB7CiAKICAgICAgICAgdm9pZCByZXZlcnNlKCk7CiAKLSAg ICAgICAgdm9pZCBjaGVja0NvbnNpc3RlbmN5KCk7Ci0KICAgICBwcml2YXRlOgogICAgICAgICB2 b2lkIGV4cGFuZENhcGFjaXR5KHNpemVfdCBuZXdNaW5DYXBhY2l0eSk7CiAgICAgICAgIGNvbnN0 IFQqIGV4cGFuZENhcGFjaXR5KHNpemVfdCBuZXdNaW5DYXBhY2l0eSwgY29uc3QgVCopOwpAQCAt MTE0OSwxNSArMTE0Niw2IEBAIG5hbWVzcGFjZSBXVEYgewogICAgIH0KIAogICAgIHRlbXBsYXRl PHR5cGVuYW1lIFQsIHNpemVfdCBpbmxpbmVDYXBhY2l0eT4KLSAgICBpbmxpbmUgdm9pZCBWZWN0 b3I8VCwgaW5saW5lQ2FwYWNpdHk+OjpjaGVja0NvbnNpc3RlbmN5KCkKLSAgICB7Ci0jaWYgIUFT U0VSVF9ESVNBQkxFRAotICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHNpemUoKTsgKytp KQotICAgICAgICAgICAgVmFsdWVDaGVjazxUPjo6Y2hlY2tDb25zaXN0ZW5jeShhdChpKSk7Ci0j ZW5kaWYKLSAgICB9Ci0KLSAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBzaXplX3QgaW5saW5lQ2Fw YWNpdHk+CiAgICAgdm9pZCBkZWxldGVBbGxWYWx1ZXMoY29uc3QgVmVjdG9yPFQsIGlubGluZUNh cGFjaXR5PiYgY29sbGVjdGlvbikKICAgICB7CiAgICAgICAgIHR5cGVkZWYgdHlwZW5hbWUgVmVj dG9yPFQsIGlubGluZUNhcGFjaXR5Pjo6Y29uc3RfaXRlcmF0b3IgaXRlcmF0b3I7CkBAIC0xMTg3 LDE2ICsxMTc1LDYgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgICAgIHJldHVybiAhKGEgPT0gYik7 CiAgICAgfQogCi0jaWYgIUFTU0VSVF9ESVNBQkxFRAotICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+ IHN0cnVjdCBWYWx1ZUNoZWNrPFZlY3RvcjxUPiA+IHsKLSAgICAgICAgdHlwZWRlZiBWZWN0b3I8 VD4gVHJhaXRUeXBlOwotICAgICAgICBzdGF0aWMgdm9pZCBjaGVja0NvbnNpc3RlbmN5KGNvbnN0 IFZlY3RvcjxUPiYgdikKLSAgICAgICAgewotICAgICAgICAgICAgdi5jaGVja0NvbnNpc3RlbmN5 KCk7Ci0gICAgICAgIH0KLSAgICB9OwotI2VuZGlmCi0KIH0gLy8gbmFtZXNwYWNlIFdURgogCiB1 c2luZyBXVEY6OlZlY3RvcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVu dE9yZGVyZWRNYXAuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudE9yZGVyZWRNYXAuaApp bmRleCBmN2RlYjNiZmUwZGJlYmEzZWFiNGMwN2M0MDk4ZjA5NzUwYmViZGU3Li45ZDg4MWE5NWY0 ZmI1M2I4N2ZhYWQ3ZmVmMThjOTYyMzFjNzg3ZmI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnRPcmRlcmVkTWFwLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3Vt ZW50T3JkZXJlZE1hcC5oCkBAIC01NCw4ICs1NCw2IEBAIHB1YmxpYzoKICAgICBFbGVtZW50KiBn ZXRFbGVtZW50QnlMb3dlcmNhc2VkTWFwTmFtZShBdG9taWNTdHJpbmdJbXBsKiwgY29uc3QgVHJl ZVNjb3BlKikgY29uc3Q7CiAgICAgRWxlbWVudCogZ2V0RWxlbWVudEJ5TGFiZWxGb3JBdHRyaWJ1 dGUoQXRvbWljU3RyaW5nSW1wbCosIGNvbnN0IFRyZWVTY29wZSopIGNvbnN0OwogCi0gICAgdm9p ZCBjaGVja0NvbnNpc3RlbmN5KCkgY29uc3Q7Ci0KICAgICB2b2lkIHJlcG9ydE1lbW9yeVVzYWdl KE1lbW9yeU9iamVjdEluZm8qKSBjb25zdDsKIAogcHJpdmF0ZToKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2RvbS9FdmVudFNlbmRlci5oIGIvU291cmNlL1dlYkNvcmUvZG9tL0V2ZW50U2Vu ZGVyLmgKaW5kZXggNjQ2MDM0YzMyMGNkODc5YzVkNTIwOGQzNmZjOGU5MTRkNjAxM2M3Mi4uOWE2 ZWJjMTc3YjFiODMzYjEzMDM0MWZiMGM3OGE4NTgzYjU1NDViNiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvZG9tL0V2ZW50U2VuZGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0V2ZW50 U2VuZGVyLmgKQEAgLTk2LDggKzk2LDYgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gdm9pZCBFdmVu dFNlbmRlcjxUPjo6ZGlzcGF0Y2hQZW5kaW5nRXZlbnRzKCkKIAogICAgIG1fdGltZXIuc3RvcCgp OwogCi0gICAgbV9kaXNwYXRjaFNvb25MaXN0LmNoZWNrQ29uc2lzdGVuY3koKTsKLQogICAgIG1f ZGlzcGF0Y2hpbmdMaXN0LnN3YXAobV9kaXNwYXRjaFNvb25MaXN0KTsKICAgICBzaXplX3Qgc2l6 ZSA9IG1fZGlzcGF0Y2hpbmdMaXN0LnNpemUoKTsKICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8 IHNpemU7ICsraSkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9h ZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9JbWFnZUxvYWRlci5jcHAKaW5kZXggZGYy MTFlNzY4NDk0YTQxZmMwNGYyZTA0M2E0ZDdlM2U2MmY1YjA5My4uYjc4OThkMTkyMjY0ODkxMjg0 YzZiZjY1NTI4NzU2ZWNiNTU1YmUxZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVy L0ltYWdlTG9hZGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvSW1hZ2VMb2FkZXIu Y3BwCkBAIC00NiwyNCArNDYsNiBAQAogI2luY2x1ZGUgIlJlbmRlclZpZGVvLmgiCiAjZW5kaWYK IAotI2lmICFBU1NFUlRfRElTQUJMRUQKLS8vIEltYWdlTG9hZGVyIG9iamVjdHMgYXJlIGFsbG9j YXRlZCBhcyBtZW1iZXJzIG9mIG90aGVyIG9iamVjdHMsIHNvIGdlbmVyaWMgcG9pbnRlciBjaGVj ayB3b3VsZCBhbHdheXMgZmFpbC4KLW5hbWVzcGFjZSBXVEYgewotCi10ZW1wbGF0ZTw+IHN0cnVj dCBWYWx1ZUNoZWNrPFdlYkNvcmU6OkltYWdlTG9hZGVyKj4gewotICAgIHR5cGVkZWYgV2ViQ29y ZTo6SW1hZ2VMb2FkZXIqIFRyYWl0VHlwZTsKLSAgICBzdGF0aWMgdm9pZCBjaGVja0NvbnNpc3Rl bmN5KGNvbnN0IFdlYkNvcmU6OkltYWdlTG9hZGVyKiBwKQotICAgIHsKLSAgICAgICAgaWYgKCFw KQotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICBBU1NFUlQocC0+ZWxlbWVudCgpKTsKLSAg ICAgICAgVmFsdWVDaGVjazxXZWJDb3JlOjpFbGVtZW50Kj46OmNoZWNrQ29uc2lzdGVuY3kocC0+ ZWxlbWVudCgpKTsKLSAgICB9Ci19OwotCi19Ci0jZW5kaWYKLQogbmFtZXNwYWNlIFdlYkNvcmUg ewogCiBzdGF0aWMgSW1hZ2VFdmVudFNlbmRlciYgYmVmb3JlTG9hZEV2ZW50U2VuZGVyKCkK