175187 2017-08-04 07:34:08 -0700 [WTF] ThreadSpecific should not introduce additional indirection 2017-08-10 14:21:07 -0700 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 ysuzuki ysuzuki benjamin buildbot cdumez cmarcelo dbates keith_miller mark.lam msaboff saam webkit-bug-importer oldest_to_newest 1335239 0 ysuzuki 2017-08-04 07:34:08 -0700 [WTF] ThreadSpecific should not introduce additional indirection 1335240 1 317242 ysuzuki 2017-08-04 07:37:15 -0700 Created attachment 317242 Patch 1335241 2 buildbot 2017-08-04 07:39:39 -0700 Attachment 317242 did not pass style-queue: ERROR: Source/WTF/wtf/ThreadSpecific.h:107: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] Total errors found: 1 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 1335242 3 317242 ysuzuki 2017-08-04 07:44:12 -0700 Comment on attachment 317242 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=317242&action=review > Source/WTF/wtf/ThreadSpecific.h:170 > RELEASE_ASSERT(canBeGCThread == CanBeGCThread::True || !mayBeGCThread()); I'm not sure this release assert is good here. get() is frequently called from operator*, operator->. And the problematic case is that when we create the Data in GC thread (with CanBeGCThread::False). So is it enough to put this in ::set() function? If we can drop this RELEASE_ASSERT, this get() function potentially becomes super fast. I intentionally put the storage in Data's first member. Thus, data->storagePointer()'s pointer value would be the same to data. In that case, this function would becomes, return static_cast<Data*>(pthread_getspecific(m_key)); 1335243 4 ysuzuki 2017-08-04 07:44:42 -0700 (In reply to Yusuke Suzuki from comment #3) > Comment on attachment 317242 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=317242&action=review > > > Source/WTF/wtf/ThreadSpecific.h:170 > > RELEASE_ASSERT(canBeGCThread == CanBeGCThread::True || !mayBeGCThread()); > > I'm not sure this release assert is good here. > get() is frequently called from operator*, operator->. And the problematic > case is that when we create the Data in GC thread (with > CanBeGCThread::False). > So is it enough to put this in ::set() function? > > If we can drop this RELEASE_ASSERT, this get() function potentially becomes > super fast. I intentionally put the storage in Data's first member. > Thus, data->storagePointer()'s pointer value would be the same to data. In > that case, this function would becomes, > > return static_cast<Data*>(pthread_getspecific(m_key)); By the optimizer 1335248 5 317243 ysuzuki 2017-08-04 08:05:22 -0700 Created attachment 317243 Patch 1335250 6 317244 ysuzuki 2017-08-04 08:12:17 -0700 Created attachment 317244 Patch 1335257 7 317245 ysuzuki 2017-08-04 08:27:02 -0700 Created attachment 317245 Patch 1335258 8 317246 ysuzuki 2017-08-04 08:28:09 -0700 Created attachment 317246 Patch 1335265 9 317249 ysuzuki 2017-08-04 08:46:16 -0700 Created attachment 317249 Patch 1335299 10 317252 ysuzuki 2017-08-04 10:02:50 -0700 Created attachment 317252 Patch 1337096 11 317252 mark.lam 2017-08-09 13:19:35 -0700 Comment on attachment 317252 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=317252&action=review I'm going to propose a change. Let me know if you think this is not a good idea. I also think there's a bug with using ThreadSpecific unique_ptrs to point to the ThreadGlobalData instance. > Source/WTF/wtf/ThreadSpecific.h:111 > + void construct() > + { > + new (NotNull, storagePointer()) T; > + } > > - T* value; > + void destroy() > + { > + storagePointer()->~T(); > + } > + > + Data(ThreadSpecific<T, canBeGCThread>* owner) > + : owner(owner) > + { > + } In the old idiom, it is possible for the T constructor to call ThreadSpecific<T...>::get() and get a nullptr. With your new idiom, the T constructor will get its partially initialized self if it calls ThreadSpecific<T...>::get(). I think it doesn't make sense for the T constructor to call ThreadSpecific<T...>::get() anyway. I understand that there is a concern of infinite recursion but that should not be possible. The old code does things in this order: 1. construct T, 2. constructs Data, 3. set Data in TLS. Because this is the case, the T constructor will always see that ThreadSpecific<T...>::get() returns null. If this triggers recursion now, then it would have done so before. So, how about changing the Data constructor to initialize T instead: Data(ThreadSpecific<T, canBeGCThread>* owner) : owner(owner) { new (NotNull, storagePointer()) T; } ~Data() { storagePointer()->~T(); } Get rid of construct() and destroy(). If we do it this way, we have the same behavior as before i.e. if T constructor calls ThreadSpecific<T...>::get(), it gets a nullptr. > Source/WTF/wtf/ThreadSpecific.h:120 > + Data* set(); Rename set to constructAndSet. > Source/WTF/wtf/ThreadSpecific.h:178 > +inline auto ThreadSpecific<T, canBeGCThread>::set() -> Data* Rename set to constructAndSet. > Source/WTF/wtf/ThreadSpecific.h:255 > +inline auto ThreadSpecific<T, canBeGCThread>::set() -> Data* Rename set to constructAndSet. > Source/WTF/wtf/ThreadSpecific.h:279 > - data->value->~T(); > - fastFree(data->value); > + data->destroy(); I suggest changing this to: auto* owner = data->owner; data->~Data(); In the old idiom, data destructors are able to call get() to get the instance of T, but the T instance may be partially destructed. In your new idiom, this is no different. Also, get() does not rely on any fields in Data itself (it only offsets into it to get T). Hence, there's no issue with just destructing Data here. You will also need to change the "delete data" below to "fastFree(data)" instead. > Source/WTF/wtf/ThreadSpecific.h:282 > + pthread_setspecific(data->owner->m_key, nullptr); I suggest changing this to: pthread_setspecific(owner->m_key, nullptr); > Source/WTF/wtf/ThreadSpecific.h:284 > + FlsSetValue(flsKeys()[data->owner->m_index], nullptr); I suggest changing this to: FlsSetValue(flsKeys()[owner->m_index], nullptr); > Source/WTF/wtf/ThreadSpecific.h:308 > + Data* data = set(); > + data->construct(); I suggest changing this to: Data* data = constructAndSet(); > Source/WebCore/platform/ThreadGlobalData.cpp:94 > + // While we store the same pointer to std::unique_ptr, it is ok because the web thread never finishes. > + (**staticData).reset(sharedMainThreadStaticData); I think using unique_ptr for staticData is problematic. Since both the main thread and the web thread has an instance of a std::unique_ptr, both pointing to the same ThreadGlobalData, if the main thread exits but the web thread does not, then the main thread's ThreadSpecific will delete its unique_ptr, which in turn deletes the ThreadGlobalData. However, the web thread still thinks it's alive. Using unique_ptr this way is also wrong because it communicates that the owner of the unique_ptr has unique and exclusive ownership of the object, but it obviously does not since you're having more than one unique_ptr point (per thread) to the same ThreadGlobalData. I think what you want is: static ThreadSpecific<ThreadGlobalData*>* staticData { nullptr }; > Source/WebCore/platform/ThreadGlobalData.h:44 > + WTF_MAKE_NONCOPYABLE(ThreadGlobalData); > + WTF_MAKE_FAST_ALLOCATED; These should be indented by 4 more spaces. 1337277 12 317252 ysuzuki 2017-08-09 19:11:35 -0700 Comment on attachment 317252 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=317252&action=review >> Source/WTF/wtf/ThreadSpecific.h:111 >> + } > > In the old idiom, it is possible for the T constructor to call ThreadSpecific<T...>::get() and get a nullptr. With your new idiom, the T constructor will get its partially initialized self if it calls ThreadSpecific<T...>::get(). I think it doesn't make sense for the T constructor to call ThreadSpecific<T...>::get() anyway. I understand that there is a concern of infinite recursion but that should not be possible. The old code does things in this order: 1. construct T, 2. constructs Data, 3. set Data in TLS. Because this is the case, the T constructor will always see that ThreadSpecific<T...>::get() returns null. If this triggers recursion now, then it would have done so before. > > So, how about changing the Data constructor to initialize T instead: > > Data(ThreadSpecific<T, canBeGCThread>* owner) > : owner(owner) > { > new (NotNull, storagePointer()) T; > } > > ~Data() > { > storagePointer()->~T(); > } > > Get rid of construct() and destroy(). If we do it this way, we have the same behavior as before i.e. if T constructor calls ThreadSpecific<T...>::get(), it gets a nullptr. According to the comment in operator T* and the old code, // Set up thread-specific value's memory pointer before invoking constructor, in case any function it calls // needs to access the value, to avoid recursion. ptr = static_cast<T*>(fastZeroedMalloc(sizeof(T))); set(ptr); new (NotNull, ptr) T; So, the old code explicitly set the pointer to the Data in TLS first and construct this after that. Thus, Data(ThreadSpecific<T, canBeGCThread>* owner) : owner(owner) { new (NotNull, storagePointer()) T; } will break the current semantics. Is it correct? I think we need to separate Data constructor and T construction to keep the current semantics. >> Source/WTF/wtf/ThreadSpecific.h:120 >> + Data* set(); > > Rename set to constructAndSet. Sounds nice. To represent the current oder, I renamed it to setAndConstruct. >> Source/WTF/wtf/ThreadSpecific.h:178 >> +inline auto ThreadSpecific<T, canBeGCThread>::set() -> Data* > > Rename set to constructAndSet. Fixed. >> Source/WTF/wtf/ThreadSpecific.h:255 >> +inline auto ThreadSpecific<T, canBeGCThread>::set() -> Data* > > Rename set to constructAndSet. Fixed. >> Source/WTF/wtf/ThreadSpecific.h:279 >> + data->destroy(); > > I suggest changing this to: > auto* owner = data->owner; > data->~Data(); > > In the old idiom, data destructors are able to call get() to get the instance of T, but the T instance may be partially destructed. In your new idiom, this is no different. Also, get() does not rely on any fields in Data itself (it only offsets into it to get T). Hence, there's no issue with just destructing Data here. > > You will also need to change the "delete data" below to "fastFree(data)" instead. OK, sounds fine. Fixed. >> Source/WTF/wtf/ThreadSpecific.h:282 >> + pthread_setspecific(data->owner->m_key, nullptr); > > I suggest changing this to: > pthread_setspecific(owner->m_key, nullptr); Fixed. >> Source/WTF/wtf/ThreadSpecific.h:284 >> + FlsSetValue(flsKeys()[data->owner->m_index], nullptr); > > I suggest changing this to: > FlsSetValue(flsKeys()[owner->m_index], nullptr); Fixed. >> Source/WTF/wtf/ThreadSpecific.h:308 >> + data->construct(); > > I suggest changing this to: > Data* data = constructAndSet(); I've changed this to return T* from setAndConstruct(). >> Source/WebCore/platform/ThreadGlobalData.cpp:94 >> + (**staticData).reset(sharedMainThreadStaticData); > > I think using unique_ptr for staticData is problematic. Since both the main thread and the web thread has an instance of a std::unique_ptr, both pointing to the same ThreadGlobalData, if the main thread exits but the web thread does not, then the main thread's ThreadSpecific will delete its unique_ptr, which in turn deletes the ThreadGlobalData. However, the web thread still thinks it's alive. Using unique_ptr this way is also wrong because it communicates that the owner of the unique_ptr has unique and exclusive ownership of the object, but it obviously does not since you're having more than one unique_ptr point (per thread) to the same ThreadGlobalData. > > I think what you want is: > static ThreadSpecific<ThreadGlobalData*>* staticData { nullptr }; However, is this the same semantics to the current code? In the current code, we just use ThreadSpecific<ThreadGlobalData>. And in web thread, we use ThreadSpecific<ThreadGlobalData>::replace. But ThreadSpecific<ThreadGlobalData>::replace does not allocate a new data. So, if the main thread exits in the current code, it will destroy ThreadGlobalData shared with the web thread. Since we should take serious care about threading code, I think we should keep the current semantics as much as possible. >> Source/WebCore/platform/ThreadGlobalData.h:44 >> + WTF_MAKE_FAST_ALLOCATED; > > These should be indented by 4 more spaces. Fixed. 1337283 13 317775 ysuzuki 2017-08-09 19:25:36 -0700 Created attachment 317775 Patch 1337459 14 317252 mark.lam 2017-08-10 09:47:20 -0700 Comment on attachment 317252 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=317252&action=review >>> Source/WebCore/platform/ThreadGlobalData.cpp:94 >>> + (**staticData).reset(sharedMainThreadStaticData); >> >> I think using unique_ptr for staticData is problematic. Since both the main thread and the web thread has an instance of a std::unique_ptr, both pointing to the same ThreadGlobalData, if the main thread exits but the web thread does not, then the main thread's ThreadSpecific will delete its unique_ptr, which in turn deletes the ThreadGlobalData. However, the web thread still thinks it's alive. Using unique_ptr this way is also wrong because it communicates that the owner of the unique_ptr has unique and exclusive ownership of the object, but it obviously does not since you're having more than one unique_ptr point (per thread) to the same ThreadGlobalData. >> >> I think what you want is: >> static ThreadSpecific<ThreadGlobalData*>* staticData { nullptr }; > > However, is this the same semantics to the current code? In the current code, we just use ThreadSpecific<ThreadGlobalData>. And in web thread, we use ThreadSpecific<ThreadGlobalData>::replace. But ThreadSpecific<ThreadGlobalData>::replace does not allocate a new data. So, if the main thread exits in the current code, it will destroy ThreadGlobalData shared with the web thread. > Since we should take serious care about threading code, I think we should keep the current semantics as much as possible. Good point! I still think that the code is fragile, but I agree with you that it is equivalent to present semantics. Hence, it is ok, and safe to go with your use of unique_ptr. What this means is that we probably don't expect the main thread to ever exit as well. 1337476 15 317775 mark.lam 2017-08-10 10:15:11 -0700 Comment on attachment 317775 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=317775&action=review r=me with suggestions. > Source/WTF/ChangeLog:15 > + This patch adds storage to Data and initializes T in Data. > + And we drop ThreadSpecific::replace support, which is only used > + by Web thread. Web thread should use ThreadSpecific<std::unique_ptr<T>> instead. I suggest rephrasing this as: This patch adds storage in Data in order to embed the instance of T. The constructor for Data will invoke the constructor for T on the embedded storage. We also drop ThreadSpecific::replace which is only used by the web thread to set its thread specific ThreadGlobalData to the one shared from the main thread. The existing implementation relies on the main thread and the web thread never exiting in order for the shared ThreadGlobalData to stay alive. We can achieve the same semantics by using a ThreadSpecific<std::unique_ptr<T>> to hold the ThreadGlobalData instance instead. > Source/WTF/wtf/ThreadSpecific.h:101 > + void construct() > + { > + new (NotNull, storagePointer()) T; > + } You can delete this. Not needed anymore. See constructor below. > Source/WTF/wtf/ThreadSpecific.h:106 > + Data(ThreadSpecific<T, canBeGCThread>* owner) > + : owner(owner) > + { > + } In the body of the constructor, add: // Set up thread-specific value's memory pointer before invoking T's constructor (in case any function it calls // needs to access the value) to avoid recursion. set(data); new (NotNull, storagePointer()) T; This ensures that T is initialize as part of constructing Data, and is not reliant on the client to do the work correctly. It also makes the code more symmetrical: Data's constructor calls T's constructor, and Data's destructor calls T's destructor. > Source/WTF/wtf/ThreadSpecific.h:121 > + T* setAndConstruct(); > + void set(Data*); This is just a suggestion: rename "setAndConstruct" to just "set" (to mirror "get"). The fact that "set"ting involves allocating Data and constructing T is just an implementation detail. Accordingly, rename "set" to "setInTLS" or "setInternal". What do you think? > Source/WTF/wtf/ThreadSpecific.h:290 > + // Set up thread-specific value's memory pointer before invoking constructor, in case any function it calls > + // needs to access the value, to avoid recursion. Move this into the Data constructor (see above). > Source/WTF/wtf/ThreadSpecific.h:295 > + set(data); > + data->construct(); Since we only even create instances of Data that we want to set into TLS, we can make this cleaner and just do this work in the constructor (see above). Also add a comment near the "new Data()" line: "// Data will set itself into TLS." Or something to that effect. Alternatively, you can just assert it: ASSERT(get() == data->storagePointer()); or add both the assert and the comment. > Source/WebCore/platform/ThreadGlobalData.cpp:93 > + // While we store the same pointer to std::unique_ptr, it is ok because the web thread never finishes. I suggest rephrasing this as: // The web thread never finishes, and we expect the main thread to also never finish. Hence, it is safe to store the same ThreadGlobalData pointer in a thread specific std::unique_ptr. I also suggest adding a FIXME comment here with a bug url to change ThreadGlobalData to be ThreadSafeRefCounted (and staticData to be ThreadSpecific<RefPtr<ThreadGlobalData>>*) later. I think that will removes the need to assume that the main thread never exits, and makes the code less fragile. On the other hand, I think there is a lot of expectation that the "main" thread paired with the web thread is always the main thread (because we rely on pthread_main_np() to be true for the main thread). Hence, it is expected in many places that the main thread never exits, and this issue is unlikely to ever manifest. I'll let you decide if you want to do this step or not. 1337573 16 317775 ysuzuki 2017-08-10 13:53:58 -0700 Comment on attachment 317775 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=317775&action=review >> Source/WTF/ChangeLog:15 >> + by Web thread. Web thread should use ThreadSpecific<std::unique_ptr<T>> instead. > > I suggest rephrasing this as: > > This patch adds storage in Data in order to embed the instance of T. The constructor for Data will invoke the constructor for T on the embedded storage. We also drop ThreadSpecific::replace which is only used by the web thread to set its thread specific ThreadGlobalData to the one shared from the main thread. The existing implementation relies on the main thread and the web thread never exiting in order for the shared ThreadGlobalData to stay alive. We can achieve the same semantics by using a ThreadSpecific<std::unique_ptr<T>> to hold the ThreadGlobalData instance instead. Sounds very fine. Fixed. >> Source/WTF/wtf/ThreadSpecific.h:101 >> + } > > You can delete this. Not needed anymore. See constructor below. Deleted. >> Source/WTF/wtf/ThreadSpecific.h:106 >> + } > > In the body of the constructor, add: > // Set up thread-specific value's memory pointer before invoking T's constructor (in case any function it calls > // needs to access the value) to avoid recursion. > set(data); > new (NotNull, storagePointer()) T; > > This ensures that T is initialize as part of constructing Data, and is not reliant on the client to do the work correctly. It also makes the code more symmetrical: Data's constructor calls T's constructor, and Data's destructor calls T's destructor. Nice, changed. >> Source/WTF/wtf/ThreadSpecific.h:121 >> + void set(Data*); > > This is just a suggestion: rename "setAndConstruct" to just "set" (to mirror "get"). The fact that "set"ting involves allocating Data and constructing T is just an implementation detail. Accordingly, rename "set" to "setInTLS" or "setInternal". What do you think? Renamed to `set`. And renamed this `set` to `setInTLS` :) > Source/WTF/wtf/ThreadSpecific.h:281 > #if USE(PTHREADS) > - pthread_setspecific(data->owner->m_key, 0); > + pthread_setspecific(owner->m_key, nullptr); > #elif OS(WINDOWS) > - FlsSetValue(flsKeys()[data->owner->m_index], 0); > + FlsSetValue(flsKeys()[owner->m_index], nullptr); > #else > #error ThreadSpecific is not implemented for this platform. > #endif I think moving this to ~Data() is fine (it makes Data and ~Data more symmetrical). And we can use `delete` instead of fastFree. >> Source/WTF/wtf/ThreadSpecific.h:290 >> + // needs to access the value, to avoid recursion. > > Move this into the Data constructor (see above). OK, moved. >> Source/WTF/wtf/ThreadSpecific.h:295 >> + data->construct(); > > Since we only even create instances of Data that we want to set into TLS, we can make this cleaner and just do this work in the constructor (see above). > > Also add a comment near the "new Data()" line: "// Data will set itself into TLS." Or something to that effect. > Alternatively, you can just assert it: > ASSERT(get() == data->storagePointer()); > or add both the assert and the comment. Make sense. I added the comment and assert. >> Source/WebCore/platform/ThreadGlobalData.cpp:93 >> + // While we store the same pointer to std::unique_ptr, it is ok because the web thread never finishes. > > I suggest rephrasing this as: > // The web thread never finishes, and we expect the main thread to also never finish. Hence, it is safe to store the same ThreadGlobalData pointer in a thread specific std::unique_ptr. > > I also suggest adding a FIXME comment here with a bug url to change ThreadGlobalData to be ThreadSafeRefCounted (and staticData to be ThreadSpecific<RefPtr<ThreadGlobalData>>*) later. I think that will removes the need to assume that the main thread never exits, and makes the code less fragile. On the other hand, I think there is a lot of expectation that the "main" thread paired with the web thread is always the main thread (because we rely on pthread_main_np() to be true for the main thread). Hence, it is expected in many places that the main thread never exits, and this issue is unlikely to ever manifest. I'll let you decide if you want to do this step or not. Changed. And filed the bug (and added FIXME comment). 1337578 17 317840 ysuzuki 2017-08-10 14:00:53 -0700 Created attachment 317840 Patch 1337588 18 ysuzuki 2017-08-10 14:19:58 -0700 Committed r220548: <http://trac.webkit.org/changeset/220548> 1337590 19 webkit-bug-importer 2017-08-10 14:21:07 -0700 <rdar://problem/33835435> 317242 2017-08-04 07:37:15 -0700 2017-08-04 08:05:19 -0700 Patch bug-175187-20170804233714.patch text/plain 11669 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwMjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGIyYTdiMzY4NGY1Mzc4OTk2Mzg5MmQ1 NGNkMzY5ZjA1OGIyODI2NzIuLmU3NjQzNmExZGY4ZDc1NTQ5MzE2M2Q0M2Q3MTE5OTZhYWIzM2Jj OGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTctMDgtMDQgIFl1c3VrZSBTdXp1a2kgIDx1dGF0 YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFkU3BlY2lmaWMgc2hvdWxk IG5vdCBpbnRyb2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhyZWFkU3BlY2lmaWMgc2V0cyBEYXRhKiB0 byB0aGUgVExTLiBBbmQgRGF0YSBob2xkcyBUKiwgd2hpY2gKKyAgICAgICAgaXMgZmFzdCBhbGxv Y2F0ZWQgYWN0dWFsIGRhdGEuIEJ1dCBpZGVhbGx5LCB3ZSBzaG91bGQgc3RvcmUgVAorICAgICAg ICBpbnN0YW5jZSBkaXJlY3RseSBpbiBEYXRhIGluc3RlYWQgb2YgaW50cm9kdWNpbmcgYW4gYWRk aXRpb25hbAorICAgICAgICBpbmRpcmVjdGlvbi4KKworICAgICAgICBUaGlzIHBhdGNoIGFkZHMg c3RvcmFnZSB0byBEYXRhIGFuZCBpbml0aWFsaXplcyBUIGluIERhdGEuCisgICAgICAgIEFuZCB3 ZSBkcm9wIFRocmVhZFNwZWNpZmljOjpyZXBsYWNlIHN1cHBvcnQsIHdoaWNoIGlzIG9ubHkgdXNl ZAorICAgICAgICBieSBXZWIgdGhyZWFkLiBXZWIgdGhyZWFkIHNob3VsZCB1c2UgVGhyZWFkU3Bl Y2lmaWM8UmVmUHRyPFQ+PgorICAgICAgICBpbnN0ZWFkLiAoQXMgaWYgUGFya2luZ0xvdHMgZG9l cyBzbykuCisKKyAgICAgICAgKiB3dGYvVGhyZWFkU3BlY2lmaWMuaDoKKyAgICAgICAgKFdURjo6 VGhyZWFkU3BlY2lmaWM6OkRhdGE6OmNvbnN0cnVjdCk6CisgICAgICAgIChXVEY6OlRocmVhZFNw ZWNpZmljOjpEYXRhOjpkZXN0cm95KToKKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWM6OkRh dGE6OkRhdGEpOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6c3RvcmFnZVBv aW50ZXIgY29uc3QpOgorICAgICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6Z2V0KToKKyAgICAg ICAgKFdURjo6Y2FuQmVHQ1RocmVhZD46OnNldCk6CisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJl YWQ+OjpkZXN0cm95KToKKyAgICAgICAgKFdURjo6VCk6CisgICAgICAgIChXVEY6OmNhbkJlR0NU aHJlYWQ+OjpyZXBsYWNlKTogRGVsZXRlZC4KKwogMjAxNy0wOC0wMyAgQnJpYW4gQnVyZyAgPGJi dXJnQGFwcGxlLmNvbT4KIAogICAgICAgICBSZW1vdmUgRU5BQkxFKFdFQl9TT0NLRVQpIGd1YXJk cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDY0NDc0OWY0YTk0YWIzN2Y3OTFjNjFjNWViYWEzOGIwM2FjYWYwOWYu LjY3ZWI3YzIxM2ZjZmU2YzQ3MWE3MWYxZmY1YWFmNzg5MTM5Y2E1YzkgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxOCBAQAorMjAxNy0wOC0wNCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdt YWlsLmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJv ZHVjZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXZSBkcm9wIFRocmVhZFNwZWNpZmljOjpyZXBsYWNlIGZlYXR1 cmUgd2hpY2ggaXMgb25seSB1c2VkIGJ5CisgICAgICAgIFdlYiB0aHJlYWQuIEluc3RlYWQsIHdl IHVzZSBUaHJlYWRTcGVjaWZpYzxSZWZQdHI8VD4+IGhlcmUuCisKKyAgICAgICAgKiBwbGF0Zm9y bS9UaHJlYWRHbG9iYWxEYXRhLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZEdsb2JhbERh dGE6OnNldFdlYkNvcmVUaHJlYWREYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OnRocmVhZEdsb2Jh bERhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuaDoKKwogMjAxNy0w OC0wNCAgWmFuIERvYmVyc2VrICA8emRvYmVyc2VrQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0VN RV0gUHVzaCBDRE1GYWN0b3J5IGludG8gdGhlIHBsYXRmb3JtIGxheWVyCmRpZmYgLS1naXQgYS9T b3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5oIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3Bl Y2lmaWMuaAppbmRleCAxZjk4MzYzZTkzNDEzNGM0MTQzMzM2YzhiODJmOGFmYzQzODE1ZTIzLi4x MTE4ZjMyOTU2MTM5NmY0MDAxOGMxZWFhNjllODczOGQ5Njg3ZDRmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZFNw ZWNpZmljLmgKQEAgLTgyLDEwICs4Miw2IEBAIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJlR0NU aHJlYWQgY2FuQmVHQ1RocmVhZCA9IENhbkJlR0NUaHJlYWQ6OkZhbHNlPiBjbGFzcyBUCiAgICAg b3BlcmF0b3IgVCooKTsKICAgICBUJiBvcGVyYXRvciooKTsKIAotI2lmIFVTRShXRUJfVEhSRUFE KQotICAgIHZvaWQgcmVwbGFjZShUKik7Ci0jZW5kaWYKLQogcHJpdmF0ZToKICAgICAvLyBOb3Qg aW1wbGVtZW50ZWQuIEl0J3MgdGVjaG5pY2FsbHkgcG9zc2libGUgdG8gZGVzdHJveSBhIHRocmVh ZCBzcGVjaWZpYyBrZXksIGJ1dCBvbmUgd291bGQgbmVlZAogICAgIC8vIHRvIG1ha2Ugc3VyZSB0 aGF0IGFsbCB2YWx1ZXMgaGF2ZSBiZWVuIGRlc3Ryb3llZCBhbHJlYWR5ICh1c3VhbGx5LCB0aGF0 IGFsbCB0aHJlYWRzIHRoYXQgdXNlZCBpdApAQCAtOTMsMTkgKzg5LDMzIEBAIHRlbXBsYXRlPHR5 cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVHQ1RocmVhZCA9IENhbkJlR0NUaHJlYWQ6OkZh bHNlPiBjbGFzcyBUCiAgICAgLy8gYSBkZXN0cnVjdG9yIGRlZmluZWQgY2FuIGJlIGNvbmZ1c2lu ZywgZ2l2ZW4gdGhhdCBpdCBoYXMgc3VjaCBzdHJvbmcgcHJlLXJlcXVpc2l0ZXMgdG8gd29yayBj b3JyZWN0bHkuCiAgICAgflRocmVhZFNwZWNpZmljKCk7CiAKLSAgICBUKiBnZXQoKTsKLSAgICB2 b2lkIHNldChUKik7Ci0gICAgdm9pZCBzdGF0aWMgVEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJv eSh2b2lkKiBwdHIpOwotCiAgICAgc3RydWN0IERhdGEgewogICAgICAgICBXVEZfTUFLRV9OT05D T1BZQUJMRShEYXRhKTsKICAgICBwdWJsaWM6Ci0gICAgICAgIERhdGEoVCogdmFsdWUsIFRocmVh ZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25lcikgOiB2YWx1ZSh2YWx1ZSksIG93bmVy KG93bmVyKSB7fQorICAgICAgICB1c2luZyBQb2ludGVyVHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVt b3ZlX2NvbnN0PFQ+Ojp0eXBlKjsKKworICAgICAgICB2b2lkIGNvbnN0cnVjdCgpCisgICAgICAg IHsKKyAgICAgICAgICAgIG5ldyAoTm90TnVsbCwgc3RvcmFnZVBvaW50ZXIoKSkgVDsKKyAgICAg ICAgfQorCisgICAgICAgIHZvaWQgZGVzdHJveSgpCisgICAgICAgIHsKKyAgICAgICAgICAgIHN0 b3JhZ2VQb2ludGVyKCktPn5UKCk7CisgICAgICAgIH0KKworICAgICAgICBEYXRhKFRocmVhZFNw ZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25lcikgOiBvd25lcihvd25lcikgeyB9CisKKyAg ICAgICAgUG9pbnRlclR5cGUgc3RvcmFnZVBvaW50ZXIoKSBjb25zdCB7IHJldHVybiBjb25zdF9j YXN0PFBvaW50ZXJUeXBlPihyZWludGVycHJldF9jYXN0PGNvbnN0IFQqPigmbV9zdG9yYWdlKSk7 IH0KIAotICAgICAgICBUKiB2YWx1ZTsKKyAgICAgICAgdHlwZW5hbWUgc3RkOjphbGlnbmVkX3N0 b3JhZ2U8c2l6ZW9mKFQpLCBzdGQ6OmFsaWdubWVudF9vZjxUPjo6dmFsdWU+Ojp0eXBlIG1fc3Rv cmFnZTsKICAgICAgICAgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD4qIG93bmVyOwog ICAgIH07CiAKKyAgICBUKiBnZXQoKTsKKyAgICBEYXRhKiBzZXQoKTsKKyAgICB2b2lkIHN0YXRp YyBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBkZXN0cm95KHZvaWQqIHB0cik7CisKICNpZiBVU0UoUFRI UkVBRFMpCiAgICAgcHRocmVhZF9rZXlfdCBtX2tleTsKICNlbGlmIE9TKFdJTkRPV1MpCkBAIC0x NTYsMTcgKzE2NiwxOSBAQCBpbmxpbmUgVCogVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVh ZD46OmdldCgpCiB7CiAgICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEqPihwdGhyZWFk X2dldHNwZWNpZmljKG1fa2V5KSk7CiAgICAgaWYgKGRhdGEpCi0gICAgICAgIHJldHVybiBkYXRh LT52YWx1ZTsKKyAgICAgICAgcmV0dXJuIGRhdGEtPnN0b3JhZ2VQb2ludGVyKCk7CiAgICAgUkVM RUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhyZWFkOjpUcnVlIHx8ICFtYXlC ZUdDVGhyZWFkKCkpOwogICAgIHJldHVybiBudWxscHRyOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFt ZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBUaHJlYWRTcGVj aWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6c2V0KFQqIHB0cikKK2lubGluZSBhdXRvIFRocmVhZFNw ZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpzZXQoKSAtPiBEYXRhKgogewogICAgIFJFTEVBU0Vf QVNTRVJUKGNhbkJlR0NUaHJlYWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1Ro cmVhZCgpKTsKICAgICBBU1NFUlQoIWdldCgpKTsKLSAgICBwdGhyZWFkX3NldHNwZWNpZmljKG1f a2V5LCBuZXcgRGF0YShwdHIsIHRoaXMpKTsKKyAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEodGhp cyk7CisgICAgcHRocmVhZF9zZXRzcGVjaWZpYyhtX2tleSwgZGF0YSk7CisgICAgcmV0dXJuIGRh dGE7CiB9CiAKICNlbGlmIE9TKFdJTkRPV1MpCkBAIC0yMzIsMTggKzI0NCwxOSBAQCBpbmxpbmUg VCogVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OmdldCgpCiB7CiAgICAgRGF0YSog ZGF0YSA9IHN0YXRpY19jYXN0PERhdGEqPihGbHNHZXRWYWx1ZShmbHNLZXlzKClbbV9pbmRleF0p KTsKICAgICBpZiAoZGF0YSkKLSAgICAgICAgcmV0dXJuIGRhdGEtPnZhbHVlOworICAgICAgICBy ZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsKICAgICBSRUxFQVNFX0FTU0VSVChjYW5CZUdD VGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NUaHJlYWQoKSk7CiAgICAg cmV0dXJuIG51bGxwdHI7CiB9CiAKIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQg Y2FuQmVHQ1RocmVhZD4KLWlubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJl YWQ+OjpzZXQoVCogcHRyKQoraW5saW5lIGF1dG8gVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1Ro cmVhZD46OnNldCgpIC0+IERhdGEqCiB7CiAgICAgUkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVh ZCA9PSBDYW5CZUdDVGhyZWFkOjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFkKCkpOwogICAgIEFTU0VS VCghZ2V0KCkpOwotICAgIERhdGEqIGRhdGEgPSBuZXcgRGF0YShwdHIsIHRoaXMpOworICAgIERh dGEqIGRhdGEgPSBuZXcgRGF0YSh0aGlzKTsKICAgICBGbHNTZXRWYWx1ZShmbHNLZXlzKClbbV9p bmRleF0sIGRhdGEpOworICAgIHJldHVybiBkYXRhOwogfQogCiAjZWxzZQpAQCAtMjYxLDEzICsy NzQsMTIgQEAgaW5saW5lIHZvaWQgVEhSRUFEX1NQRUNJRklDX0NBTEwgVGhyZWFkU3BlY2lmaWM8 VCwgY2FuQmVHQ1RocmVhZD46OmRlc3Ryb3kodm9pZCoKICAgICBwdGhyZWFkX3NldHNwZWNpZmlj KGRhdGEtPm93bmVyLT5tX2tleSwgcHRyKTsKICNlbmRpZgogCi0gICAgZGF0YS0+dmFsdWUtPn5U KCk7Ci0gICAgZmFzdEZyZWUoZGF0YS0+dmFsdWUpOworICAgIGRhdGEtPmRlc3Ryb3koKTsKIAog I2lmIFVTRShQVEhSRUFEUykKLSAgICBwdGhyZWFkX3NldHNwZWNpZmljKGRhdGEtPm93bmVyLT5t X2tleSwgMCk7CisgICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+bV9rZXksIG51 bGxwdHIpOwogI2VsaWYgT1MoV0lORE9XUykKLSAgICBGbHNTZXRWYWx1ZShmbHNLZXlzKClbZGF0 YS0+b3duZXItPm1faW5kZXhdLCAwKTsKKyAgICBGbHNTZXRWYWx1ZShmbHNLZXlzKClbZGF0YS0+ b3duZXItPm1faW5kZXhdLCBudWxscHRyKTsKICNlbHNlCiAjZXJyb3IgVGhyZWFkU3BlY2lmaWMg aXMgbm90IGltcGxlbWVudGVkIGZvciB0aGlzIHBsYXRmb3JtLgogI2VuZGlmCkBAIC0yODUsMTQg KzI5NywxNCBAQCB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJl YWQ+CiBpbmxpbmUgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46Om9wZXJhdG9yIFQq KCkKIHsKICAgICBUKiBwdHIgPSBzdGF0aWNfY2FzdDxUKj4oZ2V0KCkpOwotICAgIGlmICghcHRy KSB7Ci0gICAgICAgIC8vIFNldCB1cCB0aHJlYWQtc3BlY2lmaWMgdmFsdWUncyBtZW1vcnkgcG9p bnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0b3IsIGluIGNhc2UgYW55IGZ1bmN0aW9uIGl0 IGNhbGxzCi0gICAgICAgIC8vIG5lZWRzIHRvIGFjY2VzcyB0aGUgdmFsdWUsIHRvIGF2b2lkIHJl Y3Vyc2lvbi4KLSAgICAgICAgcHRyID0gc3RhdGljX2Nhc3Q8VCo+KGZhc3RaZXJvZWRNYWxsb2Mo c2l6ZW9mKFQpKSk7Ci0gICAgICAgIHNldChwdHIpOwotICAgICAgICBuZXcgKE5vdE51bGwsIHB0 cikgVDsKLSAgICB9Ci0gICAgcmV0dXJuIHB0cjsKKyAgICBpZiAocHRyKQorICAgICAgICByZXR1 cm4gcHRyOworCisgICAgLy8gU2V0IHVwIHRocmVhZC1zcGVjaWZpYyB2YWx1ZSdzIG1lbW9yeSBw b2ludGVyIGJlZm9yZSBpbnZva2luZyBjb25zdHJ1Y3RvciwgaW4gY2FzZSBhbnkgZnVuY3Rpb24g aXQgY2FsbHMKKyAgICAvLyBuZWVkcyB0byBhY2Nlc3MgdGhlIHZhbHVlLCB0byBhdm9pZCByZWN1 cnNpb24uCisgICAgRGF0YSogZGF0YSA9IHNldCgpOworICAgIGRhdGEtPmNvbnN0cnVjdCgpOwor ICAgIHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFt ZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+CkBAIC0zMDcsMTkgKzMxOSw2IEBAIGlu bGluZSBUJiBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6b3BlcmF0b3IqKCkKICAg ICByZXR1cm4gKm9wZXJhdG9yIFQqKCk7CiB9CiAKLSNpZiBVU0UoV0VCX1RIUkVBRCkKLXRlbXBs YXRlPHR5cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVHQ1RocmVhZD4KLWlubGluZSB2b2lk IFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpyZXBsYWNlKFQqIG5ld1B0cikKLXsK LSAgICBBU1NFUlQobmV3UHRyKTsKLSAgICBEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+ KHB0aHJlYWRfZ2V0c3BlY2lmaWMobV9rZXkpKTsKLSAgICBBU1NFUlQoZGF0YSk7Ci0gICAgZGF0 YS0+dmFsdWUtPn5UKCk7Ci0gICAgZmFzdEZyZWUoZGF0YS0+dmFsdWUpOwotICAgIGRhdGEtPnZh bHVlID0gbmV3UHRyOwotfQotI2VuZGlmCi0KIH0gLy8gbmFtZXNwYWNlIFdURgogCiAjZW5kaWYg Ly8gV1RGX1RocmVhZFNwZWNpZmljX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1RocmVhZEdsb2JhbERhdGEuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFk R2xvYmFsRGF0YS5jcHAKaW5kZXggNzczODI5ZDVlN2I0ZWIzM2Q3YmU4MzgwNzE2ZjlhMzMzNzI2 ZjRmOC4uNmI3OGIzNGFiNTMwZGE4MDNkMDIxYTk0NjgzMDBjNDlhZTdlM2YzZCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAKQEAgLTQzLDkgKzQzLDkg QEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1UaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxE YXRhPiogVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKK3N0YXRpYyBUaHJlYWRTcGVjaWZp YzxSZWZQdHI8VGhyZWFkR2xvYmFsRGF0YT4+KiBzdGF0aWNEYXRhIHsgbnVsbHB0ciB9OwogI2lm IFVTRShXRUJfVEhSRUFEKQotVGhyZWFkR2xvYmFsRGF0YSogVGhyZWFkR2xvYmFsRGF0YTo6c2hh cmVkTWFpblRocmVhZFN0YXRpY0RhdGE7CitzdGF0aWMgUmVmUHRyPFRocmVhZEdsb2JhbERhdGE+ IHNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhOwogI2VuZGlmCiAKIFRocmVhZEdsb2JhbERhdGE6 OlRocmVhZEdsb2JhbERhdGEoKQpAQCAtOTAsMzEgKzkwLDM3IEBAIHZvaWQgVGhyZWFkR2xvYmFs RGF0YTo6ZGVzdHJveSgpCiB2b2lkIFRocmVhZEdsb2JhbERhdGE6OnNldFdlYkNvcmVUaHJlYWRE YXRhKCkKIHsKICAgICBBU1NFUlQoaXNXZWJUaHJlYWQoKSk7Ci0gICAgQVNTRVJUKCZ0aHJlYWRH bG9iYWxEYXRhKCkgIT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0Rh dGEpOworICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpICE9IHNoYXJlZE1haW5UaHJlYWRT dGF0aWNEYXRhKTsKIAogICAgIC8vIFNldCBXZWJUaHJlYWQncyBUaHJlYWRHbG9iYWxEYXRhIG9i amVjdCB0byBiZSB0aGUgc2FtZSBhcyB0aGUgbWFpbiBVSSB0aHJlYWQuCi0gICAgVGhyZWFkR2xv YmFsRGF0YTo6c3RhdGljRGF0YS0+cmVwbGFjZShUaHJlYWRHbG9iYWxEYXRhOjpzaGFyZWRNYWlu VGhyZWFkU3RhdGljRGF0YSk7CisgICAgKipzdGF0aWNEYXRhID0gc2hhcmVkTWFpblRocmVhZFN0 YXRpY0RhdGE7CiAKLSAgICBBU1NFUlQoJnRocmVhZEdsb2JhbERhdGEoKSA9PSBUaHJlYWRHbG9i YWxEYXRhOjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgQVNTRVJUKCZ0aHJlYWRH bG9iYWxEYXRhKCkgPT0gc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEpOwogfQogI2VuZGlmCiAK LVRocmVhZEdsb2JhbERhdGEmIHRocmVhZEdsb2JhbERhdGEoKSAKK1RocmVhZEdsb2JhbERhdGEm IHRocmVhZEdsb2JhbERhdGEoKQogeworICAgIGlmIChVTkxJS0VMWSghc3RhdGljRGF0YSkpIHsK KyAgICAgICAgc3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRh PjsKICNpZiBVU0UoV0VCX1RIUkVBRCkKLSAgICBpZiAoVU5MSUtFTFkoIVRocmVhZEdsb2JhbERh dGE6OnN0YXRpY0RhdGEpKSB7Ci0gICAgICAgIFRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGEg PSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47CisgICAgICAgIFJlZlB0cjxU aHJlYWRHbG9iYWxEYXRhPiYgcmVzdWx0ID0gKipzdGF0aWNEYXRhOworICAgICAgICBBU1NFUlQo IXJlc3VsdCk7CisgICAgICAgIHJlc3VsdCA9IGFkb3B0UmVmKG5ldyBUaHJlYWRHbG9iYWxEYXRh KCkpOwogICAgICAgICAvLyBXZWJUaHJlYWQgYW5kIG1haW4gVUkgdGhyZWFkIG5lZWQgdG8gc2hh cmUgdGhlIHNhbWUgb2JqZWN0LiBTYXZlIGl0IGluIGEgc3RhdGljCiAgICAgICAgIC8vIGhlcmUs IHRoZSBXZWJUaHJlYWQgd2lsbCBwaWNrIGl0IHVwIGluIHNldFdlYkNvcmVUaHJlYWREYXRhKCku CiAgICAgICAgIGlmIChwdGhyZWFkX21haW5fbnAoKSkKLSAgICAgICAgICAgIFRocmVhZEdsb2Jh bERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0gKlRocmVhZEdsb2JhbERhdGE6OnN0 YXRpY0RhdGE7Ci0gICAgfQotICAgIHJldHVybiAqKlRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0Rh dGE7Ci0jZWxzZQotICAgIGlmICghVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSkKLSAgICAg ICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxUaHJl YWRHbG9iYWxEYXRhPjsKLSAgICByZXR1cm4gKipUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRh OworICAgICAgICAgICAgc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEgPSByZXN1bHQ7CisgICAg ICAgIHJldHVybiAqcmVzdWx0OwogI2VuZGlmCisgICAgfQorCisgICAgUmVmUHRyPFRocmVhZEds b2JhbERhdGE+JiByZXN1bHQgPSAqKnN0YXRpY0RhdGE7CisKKyAgICBpZiAoIXJlc3VsdCkKKyAg ICAgICAgcmVzdWx0ID0gYWRvcHRSZWYobmV3IFRocmVhZEdsb2JhbERhdGEoKSk7CisKKyAgICBy ZXR1cm4gKnJlc3VsdDsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oCmluZGV4IDU4ZjdjMDc0MDI1NDA4ODliM2Nm ZDQ0MTliOTA4NWNmNTc5Y2NmMjEuLjcwNDBiM2RlNTZmNDE3OGY5Zjk2NjU3MmRhYzA4NWFkZWQ5 ZGM1MWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERh dGEuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmgKQEAg LTI3LDExICsyNyw5IEBACiAjaWZuZGVmIFRocmVhZEdsb2JhbERhdGFfaAogI2RlZmluZSBUaHJl YWRHbG9iYWxEYXRhX2gKIAorI2luY2x1ZGUgPHd0Zi9UaHJlYWRTYWZlUmVmQ291bnRlZC5oPgog I2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0hhc2guaD4KIAotI2luY2x1ZGUgPHd0Zi9UaHJlYWRT cGVjaWZpYy5oPgotdXNpbmcgV1RGOjpUaHJlYWRTcGVjaWZpYzsKLQogbmFtZXNwYWNlIFdlYkNv cmUgewogCiAgICAgY2xhc3MgUXVhbGlmaWVkTmFtZUNhY2hlOwpAQCAtNDIsOCArNDAsNyBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgc3RydWN0IElDVUNvbnZlcnRlcldyYXBwZXI7CiAgICAg c3RydWN0IFRFQ0NvbnZlcnRlcldyYXBwZXI7CiAKLSAgICBjbGFzcyBUaHJlYWRHbG9iYWxEYXRh IHsKLSAgICAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVGhyZWFkR2xvYmFsRGF0YSk7CisgICAg Y2xhc3MgVGhyZWFkR2xvYmFsRGF0YSA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRlZDxUaHJl YWRHbG9iYWxEYXRhPiB7CiAgICAgcHVibGljOgogICAgICAgICBXRUJDT1JFX0VYUE9SVCBUaHJl YWRHbG9iYWxEYXRhKCk7CiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIH5UaHJlYWRHbG9iYWxEYXRh KCk7CkBAIC04MCwxMCArNzcsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHN0ZDo6 dW5pcXVlX3B0cjxURUNDb252ZXJ0ZXJXcmFwcGVyPiBtX2NhY2hlZENvbnZlcnRlclRFQzsKICNl bmRpZgogCi0gICAgICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBUaHJlYWRTcGVjaWZpYzxUaHJl YWRHbG9iYWxEYXRhPiogc3RhdGljRGF0YTsKLSNpZiBVU0UoV0VCX1RIUkVBRCkKLSAgICAgICAg V0VCQ09SRV9FWFBPUlQgc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5UaHJlYWRT dGF0aWNEYXRhOwotI2VuZGlmCiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIGZyaWVuZCBUaHJlYWRH bG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCk7CiAgICAgfTsKIAo= 317243 2017-08-04 08:05:22 -0700 2017-08-04 08:12:14 -0700 Patch bug-175187-20170805000520.patch text/plain 12448 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwMjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGIyYTdiMzY4NGY1Mzc4OTk2Mzg5MmQ1 NGNkMzY5ZjA1OGIyODI2NzIuLmE4Y2FmNTNjZDM0NTk2MDk5MGQwZTAwMWI5Y2NhMDE2MzA3ZGI5 NjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTctMDgtMDQgIFl1c3VrZSBTdXp1a2kgIDx1dGF0 YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFkU3BlY2lmaWMgc2hvdWxk IG5vdCBpbnRyb2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhyZWFkU3BlY2lmaWMgc2V0cyBEYXRhKiB0 byB0aGUgVExTLiBBbmQgRGF0YSBob2xkcyBUKiwgd2hpY2gKKyAgICAgICAgaXMgZmFzdCBhbGxv Y2F0ZWQgYWN0dWFsIGRhdGEuIEJ1dCBpZGVhbGx5LCB3ZSBzaG91bGQgc3RvcmUgVAorICAgICAg ICBpbnN0YW5jZSBkaXJlY3RseSBpbiBEYXRhIGluc3RlYWQgb2YgaW50cm9kdWNpbmcgYW4gYWRk aXRpb25hbAorICAgICAgICBpbmRpcmVjdGlvbi4KKworICAgICAgICBUaGlzIHBhdGNoIGFkZHMg c3RvcmFnZSB0byBEYXRhIGFuZCBpbml0aWFsaXplcyBUIGluIERhdGEuCisgICAgICAgIEFuZCB3 ZSBkcm9wIFRocmVhZFNwZWNpZmljOjpyZXBsYWNlIHN1cHBvcnQsIHdoaWNoIGlzIG9ubHkgdXNl ZAorICAgICAgICBieSBXZWIgdGhyZWFkLiBXZWIgdGhyZWFkIHNob3VsZCB1c2UgVGhyZWFkU3Bl Y2lmaWM8UmVmUHRyPFQ+PgorICAgICAgICBpbnN0ZWFkLiAoQXMgaWYgUGFya2luZ0xvdHMgZG9l cyBzbykuCisKKyAgICAgICAgKiB3dGYvVGhyZWFkU3BlY2lmaWMuaDoKKyAgICAgICAgKFdURjo6 VGhyZWFkU3BlY2lmaWM6OkRhdGE6OmNvbnN0cnVjdCk6CisgICAgICAgIChXVEY6OlRocmVhZFNw ZWNpZmljOjpEYXRhOjpkZXN0cm95KToKKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWM6OkRh dGE6OkRhdGEpOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6c3RvcmFnZVBv aW50ZXIgY29uc3QpOgorICAgICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6Z2V0KToKKyAgICAg ICAgV2UgYWxzbyBkcm9wIFJFTEVBU0VfQVNTRVJUIGZyb20gOjpnZXQoKS4gV2UgYWxyZWFkeSBp bnNlcnRlZCB0aGlzIGFzc2VydCB0byBzZXQoKSwKKyAgICAgICAgc28gd2hlbiBjcmVhdGluZyB0 aGUgbWVtYmVyIHRvIHRoaXMgVExTLCB3ZSBleGVjdXRlIHRoaXMgcmVsZWFzZSBhc3NlcnQuIFNv IGl0IGlzCisgICAgICAgIG5vdCBuZWNlc3NhcnkgdG8gZXhlY3V0ZSB0aGlzIGFzc2VydGlvbiBl dmVyeSB0aW1lIHdlIGdldCBkYXRhIGZyb20gdGhpcyBUTFMuCisKKyAgICAgICAgKFdURjo6Y2Fu QmVHQ1RocmVhZD46OnNldCk6CisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpkZXN0cm95 KToKKyAgICAgICAgKFdURjo6VCk6CisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpyZXBs YWNlKTogRGVsZXRlZC4KKwogMjAxNy0wOC0wMyAgQnJpYW4gQnVyZyAgPGJidXJnQGFwcGxlLmNv bT4KIAogICAgICAgICBSZW1vdmUgRU5BQkxFKFdFQl9TT0NLRVQpIGd1YXJkcwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IDY0NDc0OWY0YTk0YWIzN2Y3OTFjNjFjNWViYWEzOGIwM2FjYWYwOWYuLjE3YzU4NzVmYzU0 YjJiMTA0YzY4NTUwMDRiMzAwM2M3Yjk2Y2EyMDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBA QAorMjAxNy0wOC0wNCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWlsLmNvbT4KKwor ICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVjZSBhZGRpdGlv bmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBXZSBkcm9wIFRocmVhZFNwZWNpZmljOjpyZXBsYWNlIGZlYXR1cmUgd2hpY2ggaXMg b25seSB1c2VkIGJ5CisgICAgICAgIFdlYiB0aHJlYWQuIEluc3RlYWQsIHdlIHVzZSBUaHJlYWRT cGVjaWZpYzxSZWZQdHI8VD4+IGhlcmUuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9i YWxEYXRhLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZEdsb2JhbERhdGE6OlRocmVhZEds b2JhbERhdGEpOgorICAgICAgICAoV2ViQ29yZTo6VGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29y ZVRocmVhZERhdGEpOgorICAgICAgICAoV2ViQ29yZTo6dGhyZWFkR2xvYmFsRGF0YSk6CisgICAg ICAgIFdlIGFsc28gZHJvcCBTdHJpbmdJbXBsOjplbXB0eSgpIGNhbGwgc2luY2UgaXQgaXMgbm90 IG5lY2Vzc2FyeSBub3c6CisgICAgICAgIFN0cmluZ0ltcGw6OmVtcHR5IGRhdGEgaXMgc3RhdGlj YWxseSBpbml0aWFsaXplZCBieSB1c2luZyBjb25zdGV4cHIuCisKKyAgICAgICAgKiBwbGF0Zm9y bS9UaHJlYWRHbG9iYWxEYXRhLmg6CisKIDIwMTctMDgtMDQgIFphbiBEb2JlcnNlayAgPHpkb2Jl cnNla0BpZ2FsaWEuY29tPgogCiAgICAgICAgIFtFTUVdIFB1c2ggQ0RNRmFjdG9yeSBpbnRvIHRo ZSBwbGF0Zm9ybSBsYXllcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lm aWMuaCBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZFNwZWNpZmljLmgKaW5kZXggMWY5ODM2M2U5MzQx MzRjNDE0MzMzNmM4YjgyZjhhZmM0MzgxNWUyMy4uODVmMzE3NTQyYWMzMmNkNWM0NWFlNGQ4Njkw NDA3ODJjNzYwNWU4NCAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lmaWMu aAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCkBAIC04MiwxMCArODIsNiBA QCB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQgPSBDYW5C ZUdDVGhyZWFkOjpGYWxzZT4gY2xhc3MgVAogICAgIG9wZXJhdG9yIFQqKCk7CiAgICAgVCYgb3Bl cmF0b3IqKCk7CiAKLSNpZiBVU0UoV0VCX1RIUkVBRCkKLSAgICB2b2lkIHJlcGxhY2UoVCopOwot I2VuZGlmCi0KIHByaXZhdGU6CiAgICAgLy8gTm90IGltcGxlbWVudGVkLiBJdCdzIHRlY2huaWNh bGx5IHBvc3NpYmxlIHRvIGRlc3Ryb3kgYSB0aHJlYWQgc3BlY2lmaWMga2V5LCBidXQgb25lIHdv dWxkIG5lZWQKICAgICAvLyB0byBtYWtlIHN1cmUgdGhhdCBhbGwgdmFsdWVzIGhhdmUgYmVlbiBk ZXN0cm95ZWQgYWxyZWFkeSAodXN1YWxseSwgdGhhdCBhbGwgdGhyZWFkcyB0aGF0IHVzZWQgaXQK QEAgLTkzLDE5ICs4OSwzNiBAQCB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNh bkJlR0NUaHJlYWQgPSBDYW5CZUdDVGhyZWFkOjpGYWxzZT4gY2xhc3MgVAogICAgIC8vIGEgZGVz dHJ1Y3RvciBkZWZpbmVkIGNhbiBiZSBjb25mdXNpbmcsIGdpdmVuIHRoYXQgaXQgaGFzIHN1Y2gg c3Ryb25nIHByZS1yZXF1aXNpdGVzIHRvIHdvcmsgY29ycmVjdGx5LgogICAgIH5UaHJlYWRTcGVj aWZpYygpOwogCi0gICAgVCogZ2V0KCk7Ci0gICAgdm9pZCBzZXQoVCopOwotICAgIHZvaWQgc3Rh dGljIFRIUkVBRF9TUEVDSUZJQ19DQUxMIGRlc3Ryb3kodm9pZCogcHRyKTsKLQogICAgIHN0cnVj dCBEYXRhIHsKICAgICAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoRGF0YSk7CiAgICAgcHVibGlj OgotICAgICAgICBEYXRhKFQqIHZhbHVlLCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFk Piogb3duZXIpIDogdmFsdWUodmFsdWUpLCBvd25lcihvd25lcikge30KKyAgICAgICAgdXNpbmcg UG9pbnRlclR5cGUgPSB0eXBlbmFtZSBzdGQ6OnJlbW92ZV9jb25zdDxUPjo6dHlwZSo7CiAKLSAg ICAgICAgVCogdmFsdWU7CisgICAgICAgIHZvaWQgY29uc3RydWN0KCkKKyAgICAgICAgeworICAg ICAgICAgICAgbmV3IChOb3ROdWxsLCBzdG9yYWdlUG9pbnRlcigpKSBUOworICAgICAgICB9CisK KyAgICAgICAgdm9pZCBkZXN0cm95KCkKKyAgICAgICAgeworICAgICAgICAgICAgc3RvcmFnZVBv aW50ZXIoKS0+flQoKTsKKyAgICAgICAgfQorCisgICAgICAgIERhdGEoVGhyZWFkU3BlY2lmaWM8 VCwgY2FuQmVHQ1RocmVhZD4qIG93bmVyKQorICAgICAgICAgICAgOiBvd25lcihvd25lcikKKyAg ICAgICAgeworICAgICAgICB9CisKKyAgICAgICAgUG9pbnRlclR5cGUgc3RvcmFnZVBvaW50ZXIo KSBjb25zdCB7IHJldHVybiBjb25zdF9jYXN0PFBvaW50ZXJUeXBlPihyZWludGVycHJldF9jYXN0 PGNvbnN0IFQqPigmbV9zdG9yYWdlKSk7IH0KKworICAgICAgICB0eXBlbmFtZSBzdGQ6OmFsaWdu ZWRfc3RvcmFnZTxzaXplb2YoVCksIHN0ZDo6YWxpZ25tZW50X29mPFQ+Ojp2YWx1ZT46OnR5cGUg bV9zdG9yYWdlOwogICAgICAgICBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPiogb3du ZXI7CiAgICAgfTsKIAorICAgIFQqIGdldCgpOworICAgIERhdGEqIHNldCgpOworICAgIHZvaWQg c3RhdGljIFRIUkVBRF9TUEVDSUZJQ19DQUxMIGRlc3Ryb3kodm9pZCogcHRyKTsKKwogI2lmIFVT RShQVEhSRUFEUykKICAgICBwdGhyZWFkX2tleV90IG1fa2V5OwogI2VsaWYgT1MoV0lORE9XUykK QEAgLTE1NiwxNyArMTY5LDE4IEBAIGlubGluZSBUKiBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdD VGhyZWFkPjo6Z2V0KCkKIHsKICAgICBEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+KHB0 aHJlYWRfZ2V0c3BlY2lmaWMobV9rZXkpKTsKICAgICBpZiAoZGF0YSkKLSAgICAgICAgcmV0dXJu IGRhdGEtPnZhbHVlOwotICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJlR0NUaHJlYWQgPT0gQ2FuQmVH Q1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKKyAgICAgICAgcmV0dXJuIGRhdGEt PnN0b3JhZ2VQb2ludGVyKCk7CiAgICAgcmV0dXJuIG51bGxwdHI7CiB9CiAKIHRlbXBsYXRlPHR5 cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVHQ1RocmVhZD4KLWlubGluZSB2b2lkIFRocmVh ZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpzZXQoVCogcHRyKQoraW5saW5lIGF1dG8gVGhy ZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OnNldCgpIC0+IERhdGEqCiB7CiAgICAgUkVM RUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhyZWFkOjpUcnVlIHx8ICFtYXlC ZUdDVGhyZWFkKCkpOwogICAgIEFTU0VSVCghZ2V0KCkpOwotICAgIHB0aHJlYWRfc2V0c3BlY2lm aWMobV9rZXksIG5ldyBEYXRhKHB0ciwgdGhpcykpOworICAgIERhdGEqIGRhdGEgPSBuZXcgRGF0 YSh0aGlzKTsKKyAgICBwdGhyZWFkX3NldHNwZWNpZmljKG1fa2V5LCBkYXRhKTsKKyAgICByZXR1 cm4gZGF0YTsKIH0KIAogI2VsaWYgT1MoV0lORE9XUykKQEAgLTIzMiwxOCArMjQ2LDE4IEBAIGlu bGluZSBUKiBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6Z2V0KCkKIHsKICAgICBE YXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+KEZsc0dldFZhbHVlKGZsc0tleXMoKVttX2lu ZGV4XSkpOwogICAgIGlmIChkYXRhKQotICAgICAgICByZXR1cm4gZGF0YS0+dmFsdWU7Ci0gICAg UkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhyZWFkOjpUcnVlIHx8ICFt YXlCZUdDVGhyZWFkKCkpOworICAgICAgICByZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsK ICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1Ro cmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVH Q1RocmVhZD46OnNldChUKiBwdHIpCitpbmxpbmUgYXV0byBUaHJlYWRTcGVjaWZpYzxULCBjYW5C ZUdDVGhyZWFkPjo6c2V0KCkgLT4gRGF0YSoKIHsKICAgICBSRUxFQVNFX0FTU0VSVChjYW5CZUdD VGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NUaHJlYWQoKSk7CiAgICAg QVNTRVJUKCFnZXQoKSk7Ci0gICAgRGF0YSogZGF0YSA9IG5ldyBEYXRhKHB0ciwgdGhpcyk7Cisg ICAgRGF0YSogZGF0YSA9IG5ldyBEYXRhKHRoaXMpOwogICAgIEZsc1NldFZhbHVlKGZsc0tleXMo KVttX2luZGV4XSwgZGF0YSk7CisgICAgcmV0dXJuIGRhdGE7CiB9CiAKICNlbHNlCkBAIC0yNjEs MTMgKzI3NSwxMiBAQCBpbmxpbmUgdm9pZCBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBUaHJlYWRTcGVj aWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6ZGVzdHJveSh2b2lkKgogICAgIHB0aHJlYWRfc2V0c3Bl Y2lmaWMoZGF0YS0+b3duZXItPm1fa2V5LCBwdHIpOwogI2VuZGlmCiAKLSAgICBkYXRhLT52YWx1 ZS0+flQoKTsKLSAgICBmYXN0RnJlZShkYXRhLT52YWx1ZSk7CisgICAgZGF0YS0+ZGVzdHJveSgp OwogCiAjaWYgVVNFKFBUSFJFQURTKQotICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMoZGF0YS0+b3du ZXItPm1fa2V5LCAwKTsKKyAgICBwdGhyZWFkX3NldHNwZWNpZmljKGRhdGEtPm93bmVyLT5tX2tl eSwgbnVsbHB0cik7CiAjZWxpZiBPUyhXSU5ET1dTKQotICAgIEZsc1NldFZhbHVlKGZsc0tleXMo KVtkYXRhLT5vd25lci0+bV9pbmRleF0sIDApOworICAgIEZsc1NldFZhbHVlKGZsc0tleXMoKVtk YXRhLT5vd25lci0+bV9pbmRleF0sIG51bGxwdHIpOwogI2Vsc2UKICNlcnJvciBUaHJlYWRTcGVj aWZpYyBpcyBub3QgaW1wbGVtZW50ZWQgZm9yIHRoaXMgcGxhdGZvcm0uCiAjZW5kaWYKQEAgLTI4 NSwxNCArMjk4LDE0IEBAIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVH Q1RocmVhZD4KIGlubGluZSBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6b3BlcmF0 b3IgVCooKQogewogICAgIFQqIHB0ciA9IHN0YXRpY19jYXN0PFQqPihnZXQoKSk7Ci0gICAgaWYg KCFwdHIpIHsKLSAgICAgICAgLy8gU2V0IHVwIHRocmVhZC1zcGVjaWZpYyB2YWx1ZSdzIG1lbW9y eSBwb2ludGVyIGJlZm9yZSBpbnZva2luZyBjb25zdHJ1Y3RvciwgaW4gY2FzZSBhbnkgZnVuY3Rp b24gaXQgY2FsbHMKLSAgICAgICAgLy8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZv aWQgcmVjdXJzaW9uLgotICAgICAgICBwdHIgPSBzdGF0aWNfY2FzdDxUKj4oZmFzdFplcm9lZE1h bGxvYyhzaXplb2YoVCkpKTsKLSAgICAgICAgc2V0KHB0cik7Ci0gICAgICAgIG5ldyAoTm90TnVs bCwgcHRyKSBUOwotICAgIH0KLSAgICByZXR1cm4gcHRyOworICAgIGlmIChwdHIpCisgICAgICAg IHJldHVybiBwdHI7CisKKyAgICAvLyBTZXQgdXAgdGhyZWFkLXNwZWNpZmljIHZhbHVlJ3MgbWVt b3J5IHBvaW50ZXIgYmVmb3JlIGludm9raW5nIGNvbnN0cnVjdG9yLCBpbiBjYXNlIGFueSBmdW5j dGlvbiBpdCBjYWxscworICAgIC8vIG5lZWRzIHRvIGFjY2VzcyB0aGUgdmFsdWUsIHRvIGF2b2lk IHJlY3Vyc2lvbi4KKyAgICBEYXRhKiBkYXRhID0gc2V0KCk7CisgICAgZGF0YS0+Y29uc3RydWN0 KCk7CisgICAgcmV0dXJuIGRhdGEtPnN0b3JhZ2VQb2ludGVyKCk7CiB9CiAKIHRlbXBsYXRlPHR5 cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVHQ1RocmVhZD4KQEAgLTMwNywxOSArMzIwLDYg QEAgaW5saW5lIFQmIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpvcGVyYXRvcioo KQogICAgIHJldHVybiAqb3BlcmF0b3IgVCooKTsKIH0KIAotI2lmIFVTRShXRUJfVEhSRUFEKQot dGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5l IHZvaWQgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OnJlcGxhY2UoVCogbmV3UHRy KQotewotICAgIEFTU0VSVChuZXdQdHIpOwotICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxE YXRhKj4ocHRocmVhZF9nZXRzcGVjaWZpYyhtX2tleSkpOwotICAgIEFTU0VSVChkYXRhKTsKLSAg ICBkYXRhLT52YWx1ZS0+flQoKTsKLSAgICBmYXN0RnJlZShkYXRhLT52YWx1ZSk7Ci0gICAgZGF0 YS0+dmFsdWUgPSBuZXdQdHI7Ci19Ci0jZW5kaWYKLQogfSAvLyBuYW1lc3BhY2UgV1RGCiAKICNl bmRpZiAvLyBXVEZfVGhyZWFkU3BlY2lmaWNfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9U aHJlYWRHbG9iYWxEYXRhLmNwcAppbmRleCA3NzM4MjlkNWU3YjRlYjMzZDdiZTgzODA3MTZmOWEz MzM3MjZmNGY4Li5mNjUwODQ3NDJjYmQxNDMxMDg0NDY4ZTdmMjZmNGVmZDEzZTE5ZmE3IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcApAQCAtNDMsOSAr NDMsOSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVRocmVhZFNwZWNpZmljPFRocmVhZEds b2JhbERhdGE+KiBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhOworc3RhdGljIFRocmVhZFNw ZWNpZmljPFJlZlB0cjxUaHJlYWRHbG9iYWxEYXRhPj4qIHN0YXRpY0RhdGEgeyBudWxscHRyIH07 CiAjaWYgVVNFKFdFQl9USFJFQUQpCi1UaHJlYWRHbG9iYWxEYXRhKiBUaHJlYWRHbG9iYWxEYXRh OjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YTsKK3N0YXRpYyBSZWZQdHI8VGhyZWFkR2xvYmFs RGF0YT4gc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGE7CiAjZW5kaWYKIAogVGhyZWFkR2xvYmFs RGF0YTo6VGhyZWFkR2xvYmFsRGF0YSgpCkBAIC02Niw3ICs2Niw2IEBAIFRocmVhZEdsb2JhbERh dGE6OlRocmVhZEdsb2JhbERhdGEoKQogICAgIC8vIHBvaW50IHRvIGNhbGwgbWV0aG9kcyB0aGF0 IGludGVybmFsbHkgcGVyZm9ybSBhIG9uZS10aW1lIGluaXRpYWxpemF0aW9uIHRoYXQgaXMgbm90 CiAgICAgLy8gdGhyZWFkc2FmZS4KICAgICBUaHJlYWQ6OmN1cnJlbnQoKTsKLSAgICBTdHJpbmdJ bXBsOjplbXB0eSgpOwogfQogCiBUaHJlYWRHbG9iYWxEYXRhOjp+VGhyZWFkR2xvYmFsRGF0YSgp CkBAIC05MCwzMSArODksMzcgQEAgdm9pZCBUaHJlYWRHbG9iYWxEYXRhOjpkZXN0cm95KCkKIHZv aWQgVGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29yZVRocmVhZERhdGEoKQogewogICAgIEFTU0VS VChpc1dlYlRocmVhZCgpKTsKLSAgICBBU1NFUlQoJnRocmVhZEdsb2JhbERhdGEoKSAhPSBUaHJl YWRHbG9iYWxEYXRhOjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgQVNTRVJUKCZ0 aHJlYWRHbG9iYWxEYXRhKCkgIT0gc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEpOwogCiAgICAg Ly8gU2V0IFdlYlRocmVhZCdzIFRocmVhZEdsb2JhbERhdGEgb2JqZWN0IHRvIGJlIHRoZSBzYW1l IGFzIHRoZSBtYWluIFVJIHRocmVhZC4KLSAgICBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRh LT5yZXBsYWNlKFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsK KyAgICAqKnN0YXRpY0RhdGEgPSBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YTsKIAotICAgIEFT U0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpID09IFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5U aHJlYWRTdGF0aWNEYXRhKTsKKyAgICBBU1NFUlQoJnRocmVhZEdsb2JhbERhdGEoKSA9PSBzaGFy ZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CiB9CiAjZW5kaWYKIAotVGhyZWFkR2xvYmFsRGF0YSYg dGhyZWFkR2xvYmFsRGF0YSgpIAorVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgp CiB7CisgICAgaWYgKFVOTElLRUxZKCFzdGF0aWNEYXRhKSkgeworICAgICAgICBzdGF0aWNEYXRh ID0gbmV3IFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+OwogI2lmIFVTRShXRUJfVEhS RUFEKQotICAgIGlmIChVTkxJS0VMWSghVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSkpIHsK LSAgICAgICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZp YzxUaHJlYWRHbG9iYWxEYXRhPjsKKyAgICAgICAgUmVmUHRyPFRocmVhZEdsb2JhbERhdGE+JiBy ZXN1bHQgPSAqKnN0YXRpY0RhdGE7CisgICAgICAgIEFTU0VSVCghcmVzdWx0KTsKKyAgICAgICAg cmVzdWx0ID0gYWRvcHRSZWYobmV3IFRocmVhZEdsb2JhbERhdGEoKSk7CiAgICAgICAgIC8vIFdl YlRocmVhZCBhbmQgbWFpbiBVSSB0aHJlYWQgbmVlZCB0byBzaGFyZSB0aGUgc2FtZSBvYmplY3Qu IFNhdmUgaXQgaW4gYSBzdGF0aWMKICAgICAgICAgLy8gaGVyZSwgdGhlIFdlYlRocmVhZCB3aWxs IHBpY2sgaXQgdXAgaW4gc2V0V2ViQ29yZVRocmVhZERhdGEoKS4KICAgICAgICAgaWYgKHB0aHJl YWRfbWFpbl9ucCgpKQotICAgICAgICAgICAgVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRo cmVhZFN0YXRpY0RhdGEgPSAqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKLSAgICB9Ci0g ICAgcmV0dXJuICoqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKLSNlbHNlCi0gICAgaWYg KCFUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhKQotICAgICAgICBUaHJlYWRHbG9iYWxEYXRh OjpzdGF0aWNEYXRhID0gbmV3IFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+OwotICAg IHJldHVybiAqKlRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7CisgICAgICAgICAgICBzaGFy ZWRNYWluVGhyZWFkU3RhdGljRGF0YSA9IHJlc3VsdDsKKyAgICAgICAgcmV0dXJuICpyZXN1bHQ7 CiAjZW5kaWYKKyAgICB9CisKKyAgICBSZWZQdHI8VGhyZWFkR2xvYmFsRGF0YT4mIHJlc3VsdCA9 ICoqc3RhdGljRGF0YTsKKworICAgIGlmICghcmVzdWx0KQorICAgICAgICByZXN1bHQgPSBhZG9w dFJlZihuZXcgVGhyZWFkR2xvYmFsRGF0YSgpKTsKKworICAgIHJldHVybiAqcmVzdWx0OwogfQog CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRH bG9iYWxEYXRhLmgKaW5kZXggNThmN2MwNzQwMjU0MDg4OWIzY2ZkNDQxOWI5MDg1Y2Y1NzljY2Yy MS4uNzA0MGIzZGU1NmY0MTc4ZjlmOTY2NTcyZGFjMDg1YWRlZDlkYzUxZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuaApAQCAtMjcsMTEgKzI3LDkgQEAKICNp Zm5kZWYgVGhyZWFkR2xvYmFsRGF0YV9oCiAjZGVmaW5lIFRocmVhZEdsb2JhbERhdGFfaAogCisj aW5jbHVkZSA8d3RmL1RocmVhZFNhZmVSZWZDb3VudGVkLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQv U3RyaW5nSGFzaC5oPgogCi0jaW5jbHVkZSA8d3RmL1RocmVhZFNwZWNpZmljLmg+Ci11c2luZyBX VEY6OlRocmVhZFNwZWNpZmljOwotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICBjbGFzcyBR dWFsaWZpZWROYW1lQ2FjaGU7CkBAIC00Miw4ICs0MCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICBzdHJ1Y3QgSUNVQ29udmVydGVyV3JhcHBlcjsKICAgICBzdHJ1Y3QgVEVDQ29udmVydGVy V3JhcHBlcjsKIAotICAgIGNsYXNzIFRocmVhZEdsb2JhbERhdGEgewotICAgICAgICBXVEZfTUFL RV9OT05DT1BZQUJMRShUaHJlYWRHbG9iYWxEYXRhKTsKKyAgICBjbGFzcyBUaHJlYWRHbG9iYWxE YXRhIDogcHVibGljIFRocmVhZFNhZmVSZWZDb3VudGVkPFRocmVhZEdsb2JhbERhdGE+IHsKICAg ICBwdWJsaWM6CiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIFRocmVhZEdsb2JhbERhdGEoKTsKICAg ICAgICAgV0VCQ09SRV9FWFBPUlQgflRocmVhZEdsb2JhbERhdGEoKTsKQEAgLTgwLDEwICs3Nyw2 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgc3RkOjp1bmlxdWVfcHRyPFRFQ0NvbnZl cnRlcldyYXBwZXI+IG1fY2FjaGVkQ29udmVydGVyVEVDOwogI2VuZGlmCiAKLSAgICAgICAgV0VC Q09SRV9FWFBPUlQgc3RhdGljIFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+KiBzdGF0 aWNEYXRhOwotI2lmIFVTRShXRUJfVEhSRUFEKQotICAgICAgICBXRUJDT1JFX0VYUE9SVCBzdGF0 aWMgVGhyZWFkR2xvYmFsRGF0YSogc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGE7Ci0jZW5kaWYK ICAgICAgICAgV0VCQ09SRV9FWFBPUlQgZnJpZW5kIFRocmVhZEdsb2JhbERhdGEmIHRocmVhZEds b2JhbERhdGEoKTsKICAgICB9OwogCg== 317244 2017-08-04 08:12:17 -0700 2017-08-04 08:26:59 -0700 Patch bug-175187-20170805001215.patch text/plain 13727 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwMjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx ZGY3MWQ0ZWY4MDFkZDZjZTFiOGM0NWViOGE1NWFjYzY3YzE3MTNlLi5jYjIxODYyYzA3OTYxYTFj NWRiZmQyMWVmN2JhNzY4YTdmMzAwZjExIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNy0wOC0wNCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVj ZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHJ1bnRpbWUvSWRlbnRpZmllci5jcHA6CisKIDIwMTctMDgtMDQg IE9sZWtzYW5kciBTa2FjaGtvdiAgPGdza2FjaGtvdkBnbWFpbC5jb20+CiAKICAgICAgICAgW0Vz TmV4dF0gQXN5bmMgaXRlcmF0aW9uIC0gQWRkIGZlYXR1cmUgZmxhZwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCBiMmE3YjM2ODRm NTM3ODk5NjM4OTJkNTRjZDM2OWYwNThiMjgyNjcyLi5hOGNhZjUzY2QzNDU5NjA5OTBkMGUwMDFi OWNjYTAxNjMwN2RiOTYzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDE3LTA4LTA0ICBZdXN1a2Ug U3V6dWtpICA8dXRhdGFuZS50ZWFAZ21haWwuY29tPgorCisgICAgICAgIFtXVEZdIFRocmVhZFNw ZWNpZmljIHNob3VsZCBub3QgaW50cm9kdWNlIGFkZGl0aW9uYWwgaW5kaXJlY3Rpb24KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NTE4NworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRocmVhZFNwZWNpZmlj IHNldHMgRGF0YSogdG8gdGhlIFRMUy4gQW5kIERhdGEgaG9sZHMgVCosIHdoaWNoCisgICAgICAg IGlzIGZhc3QgYWxsb2NhdGVkIGFjdHVhbCBkYXRhLiBCdXQgaWRlYWxseSwgd2Ugc2hvdWxkIHN0 b3JlIFQKKyAgICAgICAgaW5zdGFuY2UgZGlyZWN0bHkgaW4gRGF0YSBpbnN0ZWFkIG9mIGludHJv ZHVjaW5nIGFuIGFkZGl0aW9uYWwKKyAgICAgICAgaW5kaXJlY3Rpb24uCisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHN0b3JhZ2UgdG8gRGF0YSBhbmQgaW5pdGlhbGl6ZXMgVCBpbiBEYXRhLgor ICAgICAgICBBbmQgd2UgZHJvcCBUaHJlYWRTcGVjaWZpYzo6cmVwbGFjZSBzdXBwb3J0LCB3aGlj aCBpcyBvbmx5IHVzZWQKKyAgICAgICAgYnkgV2ViIHRocmVhZC4gV2ViIHRocmVhZCBzaG91bGQg dXNlIFRocmVhZFNwZWNpZmljPFJlZlB0cjxUPj4KKyAgICAgICAgaW5zdGVhZC4gKEFzIGlmIFBh cmtpbmdMb3RzIGRvZXMgc28pLgorCisgICAgICAgICogd3RmL1RocmVhZFNwZWNpZmljLmg6Cisg ICAgICAgIChXVEY6OlRocmVhZFNwZWNpZmljOjpEYXRhOjpjb25zdHJ1Y3QpOgorICAgICAgICAo V1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6ZGVzdHJveSk6CisgICAgICAgIChXVEY6OlRocmVh ZFNwZWNpZmljOjpEYXRhOjpEYXRhKToKKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWM6OkRh dGE6OnN0b3JhZ2VQb2ludGVyIGNvbnN0KToKKyAgICAgICAgKFdURjo6Y2FuQmVHQ1RocmVhZD46 OmdldCk6CisgICAgICAgIFdlIGFsc28gZHJvcCBSRUxFQVNFX0FTU0VSVCBmcm9tIDo6Z2V0KCku IFdlIGFscmVhZHkgaW5zZXJ0ZWQgdGhpcyBhc3NlcnQgdG8gc2V0KCksCisgICAgICAgIHNvIHdo ZW4gY3JlYXRpbmcgdGhlIG1lbWJlciB0byB0aGlzIFRMUywgd2UgZXhlY3V0ZSB0aGlzIHJlbGVh c2UgYXNzZXJ0LiBTbyBpdCBpcworICAgICAgICBub3QgbmVjZXNzYXJ5IHRvIGV4ZWN1dGUgdGhp cyBhc3NlcnRpb24gZXZlcnkgdGltZSB3ZSBnZXQgZGF0YSBmcm9tIHRoaXMgVExTLgorCisgICAg ICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpzZXQpOgorICAgICAgICAoV1RGOjpjYW5CZUdDVGhy ZWFkPjo6ZGVzdHJveSk6CisgICAgICAgIChXVEY6OlQpOgorICAgICAgICAoV1RGOjpjYW5CZUdD VGhyZWFkPjo6cmVwbGFjZSk6IERlbGV0ZWQuCisKIDIwMTctMDgtMDMgIEJyaWFuIEJ1cmcgIDxi YnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIEVOQUJMRShXRUJfU09DS0VUKSBndWFy ZHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCA2NDQ3NDlmNGE5NGFiMzdmNzkxYzYxYzVlYmFhMzhiMDNhY2FmMDlm Li4xN2M1ODc1ZmM1NGIyYjEwNGM2ODU1MDA0YjMwMDNjN2I5NmNhMjA5IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjIgQEAKKzIwMTctMDgtMDQgIFl1c3VrZSBTdXp1a2kgIDx1dGF0YW5lLnRlYUBn bWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFkU3BlY2lmaWMgc2hvdWxkIG5vdCBpbnRy b2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgV2UgZHJvcCBUaHJlYWRTcGVjaWZpYzo6cmVwbGFjZSBmZWF0 dXJlIHdoaWNoIGlzIG9ubHkgdXNlZCBieQorICAgICAgICBXZWIgdGhyZWFkLiBJbnN0ZWFkLCB3 ZSB1c2UgVGhyZWFkU3BlY2lmaWM8UmVmUHRyPFQ+PiBoZXJlLgorCisgICAgICAgICogcGxhdGZv cm0vVGhyZWFkR2xvYmFsRGF0YS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUaHJlYWRHbG9iYWxE YXRhOjpUaHJlYWRHbG9iYWxEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OlRocmVhZEdsb2JhbERh dGE6OnNldFdlYkNvcmVUaHJlYWREYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OnRocmVhZEdsb2Jh bERhdGEpOgorICAgICAgICBXZSBhbHNvIGRyb3AgU3RyaW5nSW1wbDo6ZW1wdHkoKSBjYWxsIHNp bmNlIGl0IGlzIG5vdCBuZWNlc3Nhcnkgbm93OgorICAgICAgICBTdHJpbmdJbXBsOjplbXB0eSBk YXRhIGlzIHN0YXRpY2FsbHkgaW5pdGlhbGl6ZWQgYnkgdXNpbmcgY29uc3RleHByLgorCisgICAg ICAgICogcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oOgorCiAyMDE3LTA4LTA0ICBaYW4gRG9i ZXJzZWsgIDx6ZG9iZXJzZWtAaWdhbGlhLmNvbT4KIAogICAgICAgICBbRU1FXSBQdXNoIENETUZh Y3RvcnkgaW50byB0aGUgcGxhdGZvcm0gbGF5ZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0lkZW50aWZpZXIuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvSWRlbnRpZmllci5jcHAKaW5kZXggZDU1MmQwYjFmNjI4NzE1YTI2MzZhYjc3MzdlZGZj NjE5NzM0YzBjOC4uZjg0YjY5ZTRkM2QzZjVkZjhiNjZmZjc2ODgxZWZlNDk1ZmRiMjQyYyAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAKQEAgLTMzLDgg KzMzLDYgQEAKICNpbmNsdWRlIDx3dGYvdGV4dC9BU0NJSUZhc3RQYXRoLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCi11c2luZyBXVEY6OlRocmVhZFNwZWNpZmljOwotCiBu YW1lc3BhY2UgSlNDIHsKIAogUmVmPFN0cmluZ0ltcGw+IElkZW50aWZpZXI6OmFkZChWTSogdm0s IGNvbnN0IGNoYXIqIGMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZp Yy5oIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lmaWMuaAppbmRleCAxZjk4MzYzZTkzNDEz NGM0MTQzMzM2YzhiODJmOGFmYzQzODE1ZTIzLi5hODc4Y2QwOGE1N2JiYTBkNjdjNGRiZWEwN2Fk MTczNWE1YjNmNGNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5o CisrKyBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZFNwZWNpZmljLmgKQEAgLTgyLDEwICs4Miw2IEBA IHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVHQ1RocmVhZCA9IENhbkJl R0NUaHJlYWQ6OkZhbHNlPiBjbGFzcyBUCiAgICAgb3BlcmF0b3IgVCooKTsKICAgICBUJiBvcGVy YXRvciooKTsKIAotI2lmIFVTRShXRUJfVEhSRUFEKQotICAgIHZvaWQgcmVwbGFjZShUKik7Ci0j ZW5kaWYKLQogcHJpdmF0ZToKICAgICAvLyBOb3QgaW1wbGVtZW50ZWQuIEl0J3MgdGVjaG5pY2Fs bHkgcG9zc2libGUgdG8gZGVzdHJveSBhIHRocmVhZCBzcGVjaWZpYyBrZXksIGJ1dCBvbmUgd291 bGQgbmVlZAogICAgIC8vIHRvIG1ha2Ugc3VyZSB0aGF0IGFsbCB2YWx1ZXMgaGF2ZSBiZWVuIGRl c3Ryb3llZCBhbHJlYWR5ICh1c3VhbGx5LCB0aGF0IGFsbCB0aHJlYWRzIHRoYXQgdXNlZCBpdApA QCAtOTMsMTkgKzg5LDM2IEBAIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2Fu QmVHQ1RocmVhZCA9IENhbkJlR0NUaHJlYWQ6OkZhbHNlPiBjbGFzcyBUCiAgICAgLy8gYSBkZXN0 cnVjdG9yIGRlZmluZWQgY2FuIGJlIGNvbmZ1c2luZywgZ2l2ZW4gdGhhdCBpdCBoYXMgc3VjaCBz dHJvbmcgcHJlLXJlcXVpc2l0ZXMgdG8gd29yayBjb3JyZWN0bHkuCiAgICAgflRocmVhZFNwZWNp ZmljKCk7CiAKLSAgICBUKiBnZXQoKTsKLSAgICB2b2lkIHNldChUKik7Ci0gICAgdm9pZCBzdGF0 aWMgVEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJveSh2b2lkKiBwdHIpOwotCiAgICAgc3RydWN0 IERhdGEgewogICAgICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShEYXRhKTsKICAgICBwdWJsaWM6 Ci0gICAgICAgIERhdGEoVCogdmFsdWUsIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+ KiBvd25lcikgOiB2YWx1ZSh2YWx1ZSksIG93bmVyKG93bmVyKSB7fQorICAgICAgICB1c2luZyBQ b2ludGVyVHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX2NvbnN0PFQ+Ojp0eXBlKjsKKworICAg ICAgICB2b2lkIGNvbnN0cnVjdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIG5ldyAoTm90TnVs bCwgc3RvcmFnZVBvaW50ZXIoKSkgVDsKKyAgICAgICAgfQogCi0gICAgICAgIFQqIHZhbHVlOwor ICAgICAgICB2b2lkIGRlc3Ryb3koKQorICAgICAgICB7CisgICAgICAgICAgICBzdG9yYWdlUG9p bnRlcigpLT5+VCgpOworICAgICAgICB9CisKKyAgICAgICAgRGF0YShUaHJlYWRTcGVjaWZpYzxU LCBjYW5CZUdDVGhyZWFkPiogb3duZXIpCisgICAgICAgICAgICA6IG93bmVyKG93bmVyKQorICAg ICAgICB7CisgICAgICAgIH0KKworICAgICAgICBQb2ludGVyVHlwZSBzdG9yYWdlUG9pbnRlcigp IGNvbnN0IHsgcmV0dXJuIGNvbnN0X2Nhc3Q8UG9pbnRlclR5cGU+KHJlaW50ZXJwcmV0X2Nhc3Q8 Y29uc3QgVCo+KCZtX3N0b3JhZ2UpKTsgfQorCisgICAgICAgIHR5cGVuYW1lIHN0ZDo6YWxpZ25l ZF9zdG9yYWdlPHNpemVvZihUKSwgc3RkOjphbGlnbm1lbnRfb2Y8VD46OnZhbHVlPjo6dHlwZSBt X3N0b3JhZ2U7CiAgICAgICAgIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25l cjsKICAgICB9OwogCisgICAgVCogZ2V0KCk7CisgICAgRGF0YSogc2V0KCk7CisgICAgdm9pZCBz dGF0aWMgVEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJveSh2b2lkKiBwdHIpOworCiAjaWYgVVNF KFBUSFJFQURTKQogICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CiAjZWxpZiBPUyhXSU5ET1dTKQpA QCAtMTU2LDE3ICsxNjksMTggQEAgaW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NU aHJlYWQ+OjpnZXQoKQogewogICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRo cmVhZF9nZXRzcGVjaWZpYyhtX2tleSkpOwogICAgIGlmIChkYXRhKQotICAgICAgICByZXR1cm4g ZGF0YS0+dmFsdWU7Ci0gICAgUkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdD VGhyZWFkOjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFkKCkpOworICAgICAgICByZXR1cm4gZGF0YS0+ c3RvcmFnZVBvaW50ZXIoKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogdGVtcGxhdGU8dHlw ZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFk U3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OnNldChUKiBwdHIpCitpbmxpbmUgYXV0byBUaHJl YWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6c2V0KCkgLT4gRGF0YSoKIHsKICAgICBSRUxF QVNFX0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJl R0NUaHJlYWQoKSk7CiAgICAgQVNTRVJUKCFnZXQoKSk7Ci0gICAgcHRocmVhZF9zZXRzcGVjaWZp YyhtX2tleSwgbmV3IERhdGEocHRyLCB0aGlzKSk7CisgICAgRGF0YSogZGF0YSA9IG5ldyBEYXRh KHRoaXMpOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIGRhdGEpOworICAgIHJldHVy biBkYXRhOwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMjMyLDE4ICsyNDYsMTggQEAgaW5s aW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERh dGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4oRmxzR2V0VmFsdWUoZmxzS2V5cygpW21faW5k ZXhdKSk7CiAgICAgaWYgKGRhdGEpCi0gICAgICAgIHJldHVybiBkYXRhLT52YWx1ZTsKLSAgICBS RUxFQVNFX0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1h eUJlR0NUaHJlYWQoKSk7CisgICAgICAgIHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwog ICAgIHJldHVybiBudWxscHRyOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhy ZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdD VGhyZWFkPjo6c2V0KFQqIHB0cikKK2lubGluZSBhdXRvIFRocmVhZFNwZWNpZmljPFQsIGNhbkJl R0NUaHJlYWQ+OjpzZXQoKSAtPiBEYXRhKgogewogICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJlR0NU aHJlYWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKICAgICBB U1NFUlQoIWdldCgpKTsKLSAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEocHRyLCB0aGlzKTsKKyAg ICBEYXRhKiBkYXRhID0gbmV3IERhdGEodGhpcyk7CiAgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygp W21faW5kZXhdLCBkYXRhKTsKKyAgICByZXR1cm4gZGF0YTsKIH0KIAogI2Vsc2UKQEAgLTI2MSwx MyArMjc1LDEyIEBAIGlubGluZSB2b2lkIFRIUkVBRF9TUEVDSUZJQ19DQUxMIFRocmVhZFNwZWNp ZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpkZXN0cm95KHZvaWQqCiAgICAgcHRocmVhZF9zZXRzcGVj aWZpYyhkYXRhLT5vd25lci0+bV9rZXksIHB0cik7CiAjZW5kaWYKIAotICAgIGRhdGEtPnZhbHVl LT5+VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKKyAgICBkYXRhLT5kZXN0cm95KCk7 CiAKICNpZiBVU0UoUFRIUkVBRFMpCi0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25l ci0+bV9rZXksIDApOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMoZGF0YS0+b3duZXItPm1fa2V5 LCBudWxscHRyKTsKICNlbGlmIE9TKFdJTkRPV1MpCi0gICAgRmxzU2V0VmFsdWUoZmxzS2V5cygp W2RhdGEtPm93bmVyLT5tX2luZGV4XSwgMCk7CisgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2Rh dGEtPm93bmVyLT5tX2luZGV4XSwgbnVsbHB0cik7CiAjZWxzZQogI2Vycm9yIFRocmVhZFNwZWNp ZmljIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4KICNlbmRpZgpAQCAtMjg1 LDE0ICsyOTgsMTQgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdD VGhyZWFkPgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpvcGVyYXRv ciBUKigpCiB7CiAgICAgVCogcHRyID0gc3RhdGljX2Nhc3Q8VCo+KGdldCgpKTsKLSAgICBpZiAo IXB0cikgewotICAgICAgICAvLyBTZXQgdXAgdGhyZWFkLXNwZWNpZmljIHZhbHVlJ3MgbWVtb3J5 IHBvaW50ZXIgYmVmb3JlIGludm9raW5nIGNvbnN0cnVjdG9yLCBpbiBjYXNlIGFueSBmdW5jdGlv biBpdCBjYWxscwotICAgICAgICAvLyBuZWVkcyB0byBhY2Nlc3MgdGhlIHZhbHVlLCB0byBhdm9p ZCByZWN1cnNpb24uCi0gICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PFQqPihmYXN0WmVyb2VkTWFs bG9jKHNpemVvZihUKSkpOwotICAgICAgICBzZXQocHRyKTsKLSAgICAgICAgbmV3IChOb3ROdWxs LCBwdHIpIFQ7Ci0gICAgfQotICAgIHJldHVybiBwdHI7CisgICAgaWYgKHB0cikKKyAgICAgICAg cmV0dXJuIHB0cjsKKworICAgIC8vIFNldCB1cCB0aHJlYWQtc3BlY2lmaWMgdmFsdWUncyBtZW1v cnkgcG9pbnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0b3IsIGluIGNhc2UgYW55IGZ1bmN0 aW9uIGl0IGNhbGxzCisgICAgLy8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZvaWQg cmVjdXJzaW9uLgorICAgIERhdGEqIGRhdGEgPSBzZXQoKTsKKyAgICBkYXRhLT5jb25zdHJ1Y3Qo KTsKKyAgICByZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsKIH0KIAogdGVtcGxhdGU8dHlw ZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgpAQCAtMzA3LDE5ICszMjAsOCBA QCBpbmxpbmUgVCYgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46Om9wZXJhdG9yKigp CiAgICAgcmV0dXJuICpvcGVyYXRvciBUKigpOwogfQogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi10 ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUg dm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZShUKiBuZXdQdHIp Ci17Ci0gICAgQVNTRVJUKG5ld1B0cik7Ci0gICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERh dGEqPihwdGhyZWFkX2dldHNwZWNpZmljKG1fa2V5KSk7Ci0gICAgQVNTRVJUKGRhdGEpOwotICAg IGRhdGEtPnZhbHVlLT5+VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKLSAgICBkYXRh LT52YWx1ZSA9IG5ld1B0cjsKLX0KLSNlbmRpZgotCiB9IC8vIG5hbWVzcGFjZSBXVEYKIAordXNp bmcgV1RGOjpUaHJlYWRTcGVjaWZpYzsKKwogI2VuZGlmIC8vIFdURl9UaHJlYWRTcGVjaWZpY19o CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCmluZGV4IDc3 MzgyOWQ1ZTdiNGViMzNkN2JlODM4MDcxNmY5YTMzMzcyNmY0ZjguLmMyMTBjNWViNTlmMTA1ZWEw OTcyOGY1YmNlYjY5MDRlMTRjZGZiNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Ro cmVhZEdsb2JhbERhdGEuY3BwCkBAIC00Myw5ICs0Myw5IEBACiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIAotVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIFRocmVhZEdsb2JhbERhdGE6 OnN0YXRpY0RhdGE7CitzdGF0aWMgVGhyZWFkU3BlY2lmaWM8UmVmUHRyPFRocmVhZEdsb2JhbERh dGE+Piogc3RhdGljRGF0YSB7IG51bGxwdHIgfTsKICNpZiBVU0UoV0VCX1RIUkVBRCkKLVRocmVh ZEdsb2JhbERhdGEqIFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRh Oworc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhOwog I2VuZGlmCiAKIFRocmVhZEdsb2JhbERhdGE6OlRocmVhZEdsb2JhbERhdGEoKQpAQCAtNjYsNyAr NjYsNiBAQCBUaHJlYWRHbG9iYWxEYXRhOjpUaHJlYWRHbG9iYWxEYXRhKCkKICAgICAvLyBwb2lu dCB0byBjYWxsIG1ldGhvZHMgdGhhdCBpbnRlcm5hbGx5IHBlcmZvcm0gYSBvbmUtdGltZSBpbml0 aWFsaXphdGlvbiB0aGF0IGlzIG5vdAogICAgIC8vIHRocmVhZHNhZmUuCiAgICAgVGhyZWFkOjpj dXJyZW50KCk7Ci0gICAgU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIH0KIAogVGhyZWFkR2xvYmFsRGF0 YTo6flRocmVhZEdsb2JhbERhdGEoKQpAQCAtOTAsMzEgKzg5LDM5IEBAIHZvaWQgVGhyZWFkR2xv YmFsRGF0YTo6ZGVzdHJveSgpCiB2b2lkIFRocmVhZEdsb2JhbERhdGE6OnNldFdlYkNvcmVUaHJl YWREYXRhKCkKIHsKICAgICBBU1NFUlQoaXNXZWJUaHJlYWQoKSk7Ci0gICAgQVNTRVJUKCZ0aHJl YWRHbG9iYWxEYXRhKCkgIT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRp Y0RhdGEpOworICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpICE9IHNoYXJlZE1haW5UaHJl YWRTdGF0aWNEYXRhKTsKIAogICAgIC8vIFNldCBXZWJUaHJlYWQncyBUaHJlYWRHbG9iYWxEYXRh IG9iamVjdCB0byBiZSB0aGUgc2FtZSBhcyB0aGUgbWFpbiBVSSB0aHJlYWQuCi0gICAgVGhyZWFk R2xvYmFsRGF0YTo6c3RhdGljRGF0YS0+cmVwbGFjZShUaHJlYWRHbG9iYWxEYXRhOjpzaGFyZWRN YWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgKipzdGF0aWNEYXRhID0gYWRvcHRSZWYoc2hhcmVk TWFpblRocmVhZFN0YXRpY0RhdGEpOwogCi0gICAgQVNTRVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkg PT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEpOworICAgIEFT U0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpID09IHNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsK IH0KICNlbmRpZgogCi1UaHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCkgCitUaHJl YWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCkKIHsKKyAgICBpZiAoVU5MSUtFTFkoIXN0 YXRpY0RhdGEpKSB7CisgICAgICAgIHN0YXRpY0RhdGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8UmVm UHRyPFRocmVhZEdsb2JhbERhdGE+PjsKICNpZiBVU0UoV0VCX1RIUkVBRCkKLSAgICBpZiAoVU5M SUtFTFkoIVRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGEpKSB7Ci0gICAgICAgIFRocmVhZEds b2JhbERhdGE6OnN0YXRpY0RhdGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0 YT47CisgICAgICAgIFJlZlB0cjxUaHJlYWRHbG9iYWxEYXRhPiYgcmVzdWx0ID0gKipzdGF0aWNE YXRhOworICAgICAgICBBU1NFUlQoIXJlc3VsdCk7CisgICAgICAgIHJlc3VsdCA9IGFkb3B0UmVm KG5ldyBUaHJlYWRHbG9iYWxEYXRhKCkpOwogICAgICAgICAvLyBXZWJUaHJlYWQgYW5kIG1haW4g VUkgdGhyZWFkIG5lZWQgdG8gc2hhcmUgdGhlIHNhbWUgb2JqZWN0LiBTYXZlIGl0IGluIGEgc3Rh dGljCiAgICAgICAgIC8vIGhlcmUsIHRoZSBXZWJUaHJlYWQgd2lsbCBwaWNrIGl0IHVwIGluIHNl dFdlYkNvcmVUaHJlYWREYXRhKCkuCi0gICAgICAgIGlmIChwdGhyZWFkX21haW5fbnAoKSkKLSAg ICAgICAgICAgIFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0g KlRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7Ci0gICAgfQotICAgIHJldHVybiAqKlRocmVh ZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7Ci0jZWxzZQotICAgIGlmICghVGhyZWFkR2xvYmFsRGF0 YTo6c3RhdGljRGF0YSkKLSAgICAgICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSA9IG5l dyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsKLSAgICByZXR1cm4gKipUaHJlYWRH bG9iYWxEYXRhOjpzdGF0aWNEYXRhOworICAgICAgICBpZiAocHRocmVhZF9tYWluX25wKCkpIHsK KyAgICAgICAgICAgIHNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0gcmVzdWx0LmdldCgpOwor ICAgICAgICAgICAgc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEtPnJlZigpOworICAgICAgICB9 CisgICAgICAgIHJldHVybiAqcmVzdWx0OwogI2VuZGlmCisgICAgfQorCisgICAgUmVmUHRyPFRo cmVhZEdsb2JhbERhdGE+JiByZXN1bHQgPSAqKnN0YXRpY0RhdGE7CisKKyAgICBpZiAoIXJlc3Vs dCkKKyAgICAgICAgcmVzdWx0ID0gYWRvcHRSZWYobmV3IFRocmVhZEdsb2JhbERhdGEoKSk7CisK KyAgICByZXR1cm4gKnJlc3VsdDsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oCmluZGV4IDU4ZjdjMDc0MDI1NDA4 ODliM2NmZDQ0MTliOTA4NWNmNTc5Y2NmMjEuLjcwNDBiM2RlNTZmNDE3OGY5Zjk2NjU3MmRhYzA4 NWFkZWQ5ZGM1MWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEds b2JhbERhdGEuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRh LmgKQEAgLTI3LDExICsyNyw5IEBACiAjaWZuZGVmIFRocmVhZEdsb2JhbERhdGFfaAogI2RlZmlu ZSBUaHJlYWRHbG9iYWxEYXRhX2gKIAorI2luY2x1ZGUgPHd0Zi9UaHJlYWRTYWZlUmVmQ291bnRl ZC5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0hhc2guaD4KIAotI2luY2x1ZGUgPHd0Zi9U aHJlYWRTcGVjaWZpYy5oPgotdXNpbmcgV1RGOjpUaHJlYWRTcGVjaWZpYzsKLQogbmFtZXNwYWNl IFdlYkNvcmUgewogCiAgICAgY2xhc3MgUXVhbGlmaWVkTmFtZUNhY2hlOwpAQCAtNDIsOCArNDAs NyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgc3RydWN0IElDVUNvbnZlcnRlcldyYXBwZXI7 CiAgICAgc3RydWN0IFRFQ0NvbnZlcnRlcldyYXBwZXI7CiAKLSAgICBjbGFzcyBUaHJlYWRHbG9i YWxEYXRhIHsKLSAgICAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVGhyZWFkR2xvYmFsRGF0YSk7 CisgICAgY2xhc3MgVGhyZWFkR2xvYmFsRGF0YSA6IHB1YmxpYyBUaHJlYWRTYWZlUmVmQ291bnRl ZDxUaHJlYWRHbG9iYWxEYXRhPiB7CiAgICAgcHVibGljOgogICAgICAgICBXRUJDT1JFX0VYUE9S VCBUaHJlYWRHbG9iYWxEYXRhKCk7CiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIH5UaHJlYWRHbG9i YWxEYXRhKCk7CkBAIC04MCwxMCArNzcsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAg IHN0ZDo6dW5pcXVlX3B0cjxURUNDb252ZXJ0ZXJXcmFwcGVyPiBtX2NhY2hlZENvbnZlcnRlclRF QzsKICNlbmRpZgogCi0gICAgICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBUaHJlYWRTcGVjaWZp YzxUaHJlYWRHbG9iYWxEYXRhPiogc3RhdGljRGF0YTsKLSNpZiBVU0UoV0VCX1RIUkVBRCkKLSAg ICAgICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5U aHJlYWRTdGF0aWNEYXRhOwotI2VuZGlmCiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIGZyaWVuZCBU aHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCk7CiAgICAgfTsKIAo= 317245 2017-08-04 08:27:02 -0700 2017-08-04 08:28:07 -0700 Patch bug-175187-20170805002700.patch text/plain 14531 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwMjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx ZGY3MWQ0ZWY4MDFkZDZjZTFiOGM0NWViOGE1NWFjYzY3YzE3MTNlLi5jYjIxODYyYzA3OTYxYTFj NWRiZmQyMWVmN2JhNzY4YTdmMzAwZjExIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNy0wOC0wNCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVj ZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHJ1bnRpbWUvSWRlbnRpZmllci5jcHA6CisKIDIwMTctMDgtMDQg IE9sZWtzYW5kciBTa2FjaGtvdiAgPGdza2FjaGtvdkBnbWFpbC5jb20+CiAKICAgICAgICAgW0Vz TmV4dF0gQXN5bmMgaXRlcmF0aW9uIC0gQWRkIGZlYXR1cmUgZmxhZwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCBiMmE3YjM2ODRm NTM3ODk5NjM4OTJkNTRjZDM2OWYwNThiMjgyNjcyLi43ZWVjN2U5NGUyNWYxM2JhNThjMjhmMmUw NDRjNDcxMjM2YjFiZDNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDE3LTA4LTA0ICBZdXN1a2Ug U3V6dWtpICA8dXRhdGFuZS50ZWFAZ21haWwuY29tPgorCisgICAgICAgIFtXVEZdIFRocmVhZFNw ZWNpZmljIHNob3VsZCBub3QgaW50cm9kdWNlIGFkZGl0aW9uYWwgaW5kaXJlY3Rpb24KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NTE4NworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRocmVhZFNwZWNpZmlj IHNldHMgRGF0YSogdG8gdGhlIFRMUy4gQW5kIERhdGEgaG9sZHMgVCosIHdoaWNoCisgICAgICAg IGlzIGZhc3QgYWxsb2NhdGVkIGFjdHVhbCBkYXRhLiBCdXQgaWRlYWxseSwgd2Ugc2hvdWxkIHN0 b3JlIFQKKyAgICAgICAgaW5zdGFuY2UgZGlyZWN0bHkgaW4gRGF0YSBpbnN0ZWFkIG9mIGludHJv ZHVjaW5nIGFuIGFkZGl0aW9uYWwKKyAgICAgICAgaW5kaXJlY3Rpb24uCisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHN0b3JhZ2UgdG8gRGF0YSBhbmQgaW5pdGlhbGl6ZXMgVCBpbiBEYXRhLgor ICAgICAgICBBbmQgd2UgZHJvcCBUaHJlYWRTcGVjaWZpYzo6cmVwbGFjZSBzdXBwb3J0LCB3aGlj aCBpcyBvbmx5IHVzZWQKKyAgICAgICAgYnkgV2ViIHRocmVhZC4gV2ViIHRocmVhZCBzaG91bGQg dXNlIFRocmVhZFNwZWNpZmljPHN0ZDo6dW5pcXVlX3B0cjxUPj4gaW5zdGVhZC4KKworICAgICAg ICAqIHd0Zi9UaHJlYWRTcGVjaWZpYy5oOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6 RGF0YTo6Y29uc3RydWN0KToKKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWM6OkRhdGE6OmRl c3Ryb3kpOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6RGF0YSk6CisgICAg ICAgIFdlIG1ha2UgaXQgZmFzdCBhbGxvY2F0ZWQgc2luY2Ugd2UgcHJldmlvdXNseSBhbGxvY2F0 ZWQgVGhyZWFkU3BlY2lmaWMgVCBkYXRhIGJ5IGZhc3RNYWxsb2MuCisKKyAgICAgICAgKFdURjo6 VGhyZWFkU3BlY2lmaWM6OkRhdGE6OnN0b3JhZ2VQb2ludGVyIGNvbnN0KToKKyAgICAgICAgKFdU Rjo6Y2FuQmVHQ1RocmVhZD46OmdldCk6CisgICAgICAgIFdlIGFsc28gZHJvcCBSRUxFQVNFX0FT U0VSVCBmcm9tIDo6Z2V0KCkuIFdlIGFscmVhZHkgaW5zZXJ0ZWQgdGhpcyBhc3NlcnQgdG8gc2V0 KCksCisgICAgICAgIHNvIHdoZW4gY3JlYXRpbmcgdGhlIG1lbWJlciB0byB0aGlzIFRMUywgd2Ug ZXhlY3V0ZSB0aGlzIHJlbGVhc2UgYXNzZXJ0LiBTbyBpdCBpcworICAgICAgICBub3QgbmVjZXNz YXJ5IHRvIGV4ZWN1dGUgdGhpcyBhc3NlcnRpb24gZXZlcnkgdGltZSB3ZSBnZXQgZGF0YSBmcm9t IHRoaXMgVExTLgorCisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpzZXQpOgorICAgICAg ICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6ZGVzdHJveSk6CisgICAgICAgIChXVEY6OlQpOgorICAg ICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZSk6IERlbGV0ZWQuCisKIDIwMTctMDgt MDMgIEJyaWFuIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIEVOQUJM RShXRUJfU09DS0VUKSBndWFyZHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2NDQ3NDlmNGE5NGFiMzdmNzkxYzYx YzVlYmFhMzhiMDNhY2FmMDlmLi43NjE1YjBkYWU4ZWJhYmMwNTlhMzVkZTRhNTJjNDE3YjY2ZTMx Y2M4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTctMDgtMDQgIFl1c3VrZSBTdXp1 a2kgIDx1dGF0YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFkU3BlY2lm aWMgc2hvdWxkIG5vdCBpbnRyb2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2UgZHJvcCBUaHJlYWRTcGVj aWZpYzo6cmVwbGFjZSBmZWF0dXJlIHdoaWNoIGlzIG9ubHkgdXNlZCBieQorICAgICAgICBXZWIg dGhyZWFkLiBJbnN0ZWFkLCB3ZSB1c2UgVGhyZWFkU3BlY2lmaWM8c3RkOjp1bmlxdWVfcHRyPFQ+ PiBoZXJlLgorCisgICAgICAgIFdoaWxlIHRoaXMgc3RkOjp1bmlxdWVfcHRyPFQ+IHNoYXJlcyBv bmUgaW5zdGFuY2UgYmV0d2VlbiBtYWluIHRocmVhZAorICAgICAgICBhbmQgd2ViIHRocmVhZCwg dGhpcyBpcyB0aGUgc2FtZSB0byB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbi4gSXQgaXMKKyAg ICAgICAgc2FmZSBiZWNhdXNlIHRoZSB3ZWIgdGhyZWFkIG5ldmVyIGZpbmlzaGVzLgorCisgICAg ICAgIEFuZCBmb3Igbm9uLXdlYiB0aHJlYWQgaW1wbGVtZW50YXRpb24sIHdlIGp1c3QgdXNlIFRo cmVhZFNwZWNpZmljPFQ+LAorICAgICAgICBzaW5jZSBpdCBpcyB0aGUgbW9zdCBlZmZpY2llbnQu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRocmVhZEdsb2JhbERhdGE6OlRocmVhZEdsb2JhbERhdGEpOgorICAgICAgICAoV2Vi Q29yZTo6VGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29yZVRocmVhZERhdGEpOgorICAgICAgICAo V2ViQ29yZTo6dGhyZWFkR2xvYmFsRGF0YSk6CisgICAgICAgIFdlIGFsc28gZHJvcCBTdHJpbmdJ bXBsOjplbXB0eSgpIGNhbGwgc2luY2UgaXQgaXMgbm90IG5lY2Vzc2FyeSBub3c6CisgICAgICAg IFN0cmluZ0ltcGw6OmVtcHR5IGRhdGEgaXMgc3RhdGljYWxseSBpbml0aWFsaXplZCBieSB1c2lu ZyBjb25zdGV4cHIuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmg6CisK IDIwMTctMDgtMDQgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEuY29tPgogCiAgICAg ICAgIFtFTUVdIFB1c2ggQ0RNRmFjdG9yeSBpbnRvIHRoZSBwbGF0Zm9ybSBsYXllcgpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVudGlmaWVyLmNwcAppbmRleCBkNTUyZDBiMWY2 Mjg3MTVhMjYzNmFiNzczN2VkZmM2MTk3MzRjMGM4Li5mODRiNjllNGQzZDNmNWRmOGI2NmZmNzY4 ODFlZmU0OTVmZGIyNDJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9JZGVudGlmaWVyLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVu dGlmaWVyLmNwcApAQCAtMzMsOCArMzMsNiBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0L0FTQ0lJRmFz dFBhdGguaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKLXVzaW5nIFdURjo6 VGhyZWFkU3BlY2lmaWM7Ci0KIG5hbWVzcGFjZSBKU0MgewogCiBSZWY8U3RyaW5nSW1wbD4gSWRl bnRpZmllcjo6YWRkKFZNKiB2bSwgY29uc3QgY2hhciogYykKZGlmZiAtLWdpdCBhL1NvdXJjZS9X VEYvd3RmL1RocmVhZFNwZWNpZmljLmggYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5o CmluZGV4IDFmOTgzNjNlOTM0MTM0YzQxNDMzMzZjOGI4MmY4YWZjNDM4MTVlMjMuLjUyMzE2MWI0 MzUyOTU5OTA3ZWVlZWM2NGYxNDQyOTAyOGYzOTkxNzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv d3RmL1RocmVhZFNwZWNpZmljLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lmaWMu aApAQCAtODIsMTAgKzgyLDYgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBj YW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNsYXNzIFQKICAgICBvcGVyYXRv ciBUKigpOwogICAgIFQmIG9wZXJhdG9yKigpOwogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi0gICAg dm9pZCByZXBsYWNlKFQqKTsKLSNlbmRpZgotCiBwcml2YXRlOgogICAgIC8vIE5vdCBpbXBsZW1l bnRlZC4gSXQncyB0ZWNobmljYWxseSBwb3NzaWJsZSB0byBkZXN0cm95IGEgdGhyZWFkIHNwZWNp ZmljIGtleSwgYnV0IG9uZSB3b3VsZCBuZWVkCiAgICAgLy8gdG8gbWFrZSBzdXJlIHRoYXQgYWxs IHZhbHVlcyBoYXZlIGJlZW4gZGVzdHJveWVkIGFscmVhZHkgKHVzdWFsbHksIHRoYXQgYWxsIHRo cmVhZHMgdGhhdCB1c2VkIGl0CkBAIC05MywxOSArODksMzcgQEAgdGVtcGxhdGU8dHlwZW5hbWUg VCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNs YXNzIFQKICAgICAvLyBhIGRlc3RydWN0b3IgZGVmaW5lZCBjYW4gYmUgY29uZnVzaW5nLCBnaXZl biB0aGF0IGl0IGhhcyBzdWNoIHN0cm9uZyBwcmUtcmVxdWlzaXRlcyB0byB3b3JrIGNvcnJlY3Rs eS4KICAgICB+VGhyZWFkU3BlY2lmaWMoKTsKIAotICAgIFQqIGdldCgpOwotICAgIHZvaWQgc2V0 KFQqKTsKLSAgICB2b2lkIHN0YXRpYyBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBkZXN0cm95KHZvaWQq IHB0cik7Ci0KICAgICBzdHJ1Y3QgRGF0YSB7CiAgICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxF KERhdGEpOworICAgICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKICAgICBwdWJsaWM6Ci0g ICAgICAgIERhdGEoVCogdmFsdWUsIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBv d25lcikgOiB2YWx1ZSh2YWx1ZSksIG93bmVyKG93bmVyKSB7fQorICAgICAgICB1c2luZyBQb2lu dGVyVHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX2NvbnN0PFQ+Ojp0eXBlKjsKKworICAgICAg ICB2b2lkIGNvbnN0cnVjdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIG5ldyAoTm90TnVsbCwg c3RvcmFnZVBvaW50ZXIoKSkgVDsKKyAgICAgICAgfQogCi0gICAgICAgIFQqIHZhbHVlOworICAg ICAgICB2b2lkIGRlc3Ryb3koKQorICAgICAgICB7CisgICAgICAgICAgICBzdG9yYWdlUG9pbnRl cigpLT5+VCgpOworICAgICAgICB9CisKKyAgICAgICAgRGF0YShUaHJlYWRTcGVjaWZpYzxULCBj YW5CZUdDVGhyZWFkPiogb3duZXIpCisgICAgICAgICAgICA6IG93bmVyKG93bmVyKQorICAgICAg ICB7CisgICAgICAgIH0KKworICAgICAgICBQb2ludGVyVHlwZSBzdG9yYWdlUG9pbnRlcigpIGNv bnN0IHsgcmV0dXJuIGNvbnN0X2Nhc3Q8UG9pbnRlclR5cGU+KHJlaW50ZXJwcmV0X2Nhc3Q8Y29u c3QgVCo+KCZtX3N0b3JhZ2UpKTsgfQorCisgICAgICAgIHR5cGVuYW1lIHN0ZDo6YWxpZ25lZF9z dG9yYWdlPHNpemVvZihUKSwgc3RkOjphbGlnbm1lbnRfb2Y8VD46OnZhbHVlPjo6dHlwZSBtX3N0 b3JhZ2U7CiAgICAgICAgIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25lcjsK ICAgICB9OwogCisgICAgVCogZ2V0KCk7CisgICAgRGF0YSogc2V0KCk7CisgICAgdm9pZCBzdGF0 aWMgVEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJveSh2b2lkKiBwdHIpOworCiAjaWYgVVNFKFBU SFJFQURTKQogICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAt MTU2LDE3ICsxNzAsMTggQEAgaW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJl YWQ+OjpnZXQoKQogewogICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRocmVh ZF9nZXRzcGVjaWZpYyhtX2tleSkpOwogICAgIGlmIChkYXRhKQotICAgICAgICByZXR1cm4gZGF0 YS0+dmFsdWU7Ci0gICAgUkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhy ZWFkOjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFkKCkpOworICAgICAgICByZXR1cm4gZGF0YS0+c3Rv cmFnZVBvaW50ZXIoKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogdGVtcGxhdGU8dHlwZW5h bWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFkU3Bl Y2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OnNldChUKiBwdHIpCitpbmxpbmUgYXV0byBUaHJlYWRT cGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6c2V0KCkgLT4gRGF0YSoKIHsKICAgICBSRUxFQVNF X0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NU aHJlYWQoKSk7CiAgICAgQVNTRVJUKCFnZXQoKSk7Ci0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyht X2tleSwgbmV3IERhdGEocHRyLCB0aGlzKSk7CisgICAgRGF0YSogZGF0YSA9IG5ldyBEYXRhKHRo aXMpOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIGRhdGEpOworICAgIHJldHVybiBk YXRhOwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMjMyLDE4ICsyNDcsMTggQEAgaW5saW5l IFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERhdGEq IGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4oRmxzR2V0VmFsdWUoZmxzS2V5cygpW21faW5kZXhd KSk7CiAgICAgaWYgKGRhdGEpCi0gICAgICAgIHJldHVybiBkYXRhLT52YWx1ZTsKLSAgICBSRUxF QVNFX0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJl R0NUaHJlYWQoKSk7CisgICAgICAgIHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwogICAg IHJldHVybiBudWxscHRyOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFk IGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhy ZWFkPjo6c2V0KFQqIHB0cikKK2lubGluZSBhdXRvIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NU aHJlYWQ+OjpzZXQoKSAtPiBEYXRhKgogewogICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJlR0NUaHJl YWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKICAgICBBU1NF UlQoIWdldCgpKTsKLSAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEocHRyLCB0aGlzKTsKKyAgICBE YXRhKiBkYXRhID0gbmV3IERhdGEodGhpcyk7CiAgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW21f aW5kZXhdLCBkYXRhKTsKKyAgICByZXR1cm4gZGF0YTsKIH0KIAogI2Vsc2UKQEAgLTI2MSwxMyAr Mjc2LDEyIEBAIGlubGluZSB2b2lkIFRIUkVBRF9TUEVDSUZJQ19DQUxMIFRocmVhZFNwZWNpZmlj PFQsIGNhbkJlR0NUaHJlYWQ+OjpkZXN0cm95KHZvaWQqCiAgICAgcHRocmVhZF9zZXRzcGVjaWZp YyhkYXRhLT5vd25lci0+bV9rZXksIHB0cik7CiAjZW5kaWYKIAotICAgIGRhdGEtPnZhbHVlLT5+ VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKKyAgICBkYXRhLT5kZXN0cm95KCk7CiAK ICNpZiBVU0UoUFRIUkVBRFMpCi0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+ bV9rZXksIDApOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMoZGF0YS0+b3duZXItPm1fa2V5LCBu dWxscHRyKTsKICNlbGlmIE9TKFdJTkRPV1MpCi0gICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2Rh dGEtPm93bmVyLT5tX2luZGV4XSwgMCk7CisgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2RhdGEt Pm93bmVyLT5tX2luZGV4XSwgbnVsbHB0cik7CiAjZWxzZQogI2Vycm9yIFRocmVhZFNwZWNpZmlj IGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4KICNlbmRpZgpAQCAtMjg1LDE0 ICsyOTksMTQgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhy ZWFkPgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpvcGVyYXRvciBU KigpCiB7CiAgICAgVCogcHRyID0gc3RhdGljX2Nhc3Q8VCo+KGdldCgpKTsKLSAgICBpZiAoIXB0 cikgewotICAgICAgICAvLyBTZXQgdXAgdGhyZWFkLXNwZWNpZmljIHZhbHVlJ3MgbWVtb3J5IHBv aW50ZXIgYmVmb3JlIGludm9raW5nIGNvbnN0cnVjdG9yLCBpbiBjYXNlIGFueSBmdW5jdGlvbiBp dCBjYWxscwotICAgICAgICAvLyBuZWVkcyB0byBhY2Nlc3MgdGhlIHZhbHVlLCB0byBhdm9pZCBy ZWN1cnNpb24uCi0gICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PFQqPihmYXN0WmVyb2VkTWFsbG9j KHNpemVvZihUKSkpOwotICAgICAgICBzZXQocHRyKTsKLSAgICAgICAgbmV3IChOb3ROdWxsLCBw dHIpIFQ7Ci0gICAgfQotICAgIHJldHVybiBwdHI7CisgICAgaWYgKHB0cikKKyAgICAgICAgcmV0 dXJuIHB0cjsKKworICAgIC8vIFNldCB1cCB0aHJlYWQtc3BlY2lmaWMgdmFsdWUncyBtZW1vcnkg cG9pbnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0b3IsIGluIGNhc2UgYW55IGZ1bmN0aW9u IGl0IGNhbGxzCisgICAgLy8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZvaWQgcmVj dXJzaW9uLgorICAgIERhdGEqIGRhdGEgPSBzZXQoKTsKKyAgICBkYXRhLT5jb25zdHJ1Y3QoKTsK KyAgICByZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsKIH0KIAogdGVtcGxhdGU8dHlwZW5h bWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgpAQCAtMzA3LDE5ICszMjEsOCBAQCBp bmxpbmUgVCYgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46Om9wZXJhdG9yKigpCiAg ICAgcmV0dXJuICpvcGVyYXRvciBUKigpOwogfQogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi10ZW1w bGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9p ZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZShUKiBuZXdQdHIpCi17 Ci0gICAgQVNTRVJUKG5ld1B0cik7Ci0gICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEq PihwdGhyZWFkX2dldHNwZWNpZmljKG1fa2V5KSk7Ci0gICAgQVNTRVJUKGRhdGEpOwotICAgIGRh dGEtPnZhbHVlLT5+VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKLSAgICBkYXRhLT52 YWx1ZSA9IG5ld1B0cjsKLX0KLSNlbmRpZgotCiB9IC8vIG5hbWVzcGFjZSBXVEYKIAordXNpbmcg V1RGOjpUaHJlYWRTcGVjaWZpYzsKKwogI2VuZGlmIC8vIFdURl9UaHJlYWRTcGVjaWZpY19oCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCmluZGV4IDc3Mzgy OWQ1ZTdiNGViMzNkN2JlODM4MDcxNmY5YTMzMzcyNmY0ZjguLjA2NmNmODc3NjhhZTAyODk5ODcy NTAyNTA4MzNkNWJkMWY1MTBmZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1RocmVhZEdsb2JhbERhdGEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVh ZEdsb2JhbERhdGEuY3BwCkBAIC00MywxMSArNDMsNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKLVRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+KiBUaHJlYWRHbG9iYWxEYXRhOjpz dGF0aWNEYXRhOwotI2lmIFVTRShXRUJfVEhSRUFEKQotVGhyZWFkR2xvYmFsRGF0YSogVGhyZWFk R2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGE7Ci0jZW5kaWYKLQogVGhyZWFk R2xvYmFsRGF0YTo6VGhyZWFkR2xvYmFsRGF0YSgpCiAgICAgOiBtX2NhY2hlZFJlc291cmNlUmVx dWVzdEluaXRpYXRvcnMoc3RkOjptYWtlX3VuaXF1ZTxDYWNoZWRSZXNvdXJjZVJlcXVlc3RJbml0 aWF0b3JzPigpKQogICAgICwgbV9ldmVudE5hbWVzKEV2ZW50TmFtZXM6OmNyZWF0ZSgpKQpAQCAt NjYsNyArNjEsNiBAQCBUaHJlYWRHbG9iYWxEYXRhOjpUaHJlYWRHbG9iYWxEYXRhKCkKICAgICAv LyBwb2ludCB0byBjYWxsIG1ldGhvZHMgdGhhdCBpbnRlcm5hbGx5IHBlcmZvcm0gYSBvbmUtdGlt ZSBpbml0aWFsaXphdGlvbiB0aGF0IGlzIG5vdAogICAgIC8vIHRocmVhZHNhZmUuCiAgICAgVGhy ZWFkOjpjdXJyZW50KCk7Ci0gICAgU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIH0KIAogVGhyZWFkR2xv YmFsRGF0YTo6flRocmVhZEdsb2JhbERhdGEoKQpAQCAtODcsMzQgKzgxLDUyIEBAIHZvaWQgVGhy ZWFkR2xvYmFsRGF0YTo6ZGVzdHJveSgpCiB9CiAKICNpZiBVU0UoV0VCX1RIUkVBRCkKK3N0YXRp YyBUaHJlYWRTcGVjaWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFkR2xvYmFsRGF0YT4+KiBzdGF0 aWNEYXRhIHsgbnVsbHB0ciB9Oworc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5U aHJlYWRTdGF0aWNEYXRhIHsgbnVsbHB0ciB9OworCiB2b2lkIFRocmVhZEdsb2JhbERhdGE6OnNl dFdlYkNvcmVUaHJlYWREYXRhKCkKIHsKICAgICBBU1NFUlQoaXNXZWJUaHJlYWQoKSk7Ci0gICAg QVNTRVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkgIT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFp blRocmVhZFN0YXRpY0RhdGEpOworICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpICE9IHNo YXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKIAogICAgIC8vIFNldCBXZWJUaHJlYWQncyBUaHJl YWRHbG9iYWxEYXRhIG9iamVjdCB0byBiZSB0aGUgc2FtZSBhcyB0aGUgbWFpbiBVSSB0aHJlYWQu Ci0gICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YS0+cmVwbGFjZShUaHJlYWRHbG9iYWxE YXRhOjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgLy8gV2hpbGUgd2Ugc3RvcmUg dGhlIHNhbWUgcG9pbnRlciB0byBzdGQ6OnVuaXF1ZV9wdHIsIGl0IGlzIG9rIGJlY2F1c2UgdGhl IHdlYiB0aHJlYWQgbmV2ZXIgZmluaXNoZXMuCisgICAgKipzdGF0aWNEYXRhLnJlc2V0KHNoYXJl ZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKIAotICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgp ID09IFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKKyAgICBB U1NFUlQoJnRocmVhZEdsb2JhbERhdGEoKSA9PSBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7 CiB9Ci0jZW5kaWYKIAotVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpIAorVGhy ZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpCiB7Ci0jaWYgVVNFKFdFQl9USFJFQUQp Ci0gICAgaWYgKFVOTElLRUxZKCFUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhKSkgewotICAg ICAgICBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhID0gbmV3IFRocmVhZFNwZWNpZmljPFRo cmVhZEdsb2JhbERhdGE+OworICAgIGlmIChVTkxJS0VMWSghc3RhdGljRGF0YSkpIHsKKyAgICAg ICAgc3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFk R2xvYmFsRGF0YT4+OworICAgICAgICBhdXRvJiByZXN1bHQgPSAqKnN0YXRpY0RhdGE7CisgICAg ICAgIEFTU0VSVCghcmVzdWx0KTsKKyAgICAgICAgcmVzdWx0LnJlc2V0KG5ldyBUaHJlYWRHbG9i YWxEYXRhKCkpOwogICAgICAgICAvLyBXZWJUaHJlYWQgYW5kIG1haW4gVUkgdGhyZWFkIG5lZWQg dG8gc2hhcmUgdGhlIHNhbWUgb2JqZWN0LiBTYXZlIGl0IGluIGEgc3RhdGljCiAgICAgICAgIC8v IGhlcmUsIHRoZSBXZWJUaHJlYWQgd2lsbCBwaWNrIGl0IHVwIGluIHNldFdlYkNvcmVUaHJlYWRE YXRhKCkuCiAgICAgICAgIGlmIChwdGhyZWFkX21haW5fbnAoKSkKLSAgICAgICAgICAgIFRocmVh ZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0gKlRocmVhZEdsb2JhbERh dGE6OnN0YXRpY0RhdGE7CisgICAgICAgICAgICBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSA9 IHJlc3VsdC5nZXQoKTsKKyAgICAgICAgcmV0dXJuICpyZXN1bHQ7CiAgICAgfQotICAgIHJldHVy biAqKlRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7CisKKyAgICBhdXRvJiByZXN1bHQgPSAq KnN0YXRpY0RhdGE7CisgICAgaWYgKCFyZXN1bHQpCisgICAgICAgIHJlc3VsdC5yZXNldChuZXcg VGhyZWFkR2xvYmFsRGF0YSgpKTsKKyAgICByZXR1cm4gKnJlc3VsdDsKK30KKwogI2Vsc2UKLSAg ICBpZiAoIVRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGEpCi0gICAgICAgIFRocmVhZEdsb2Jh bERhdGE6OnN0YXRpY0RhdGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47 Ci0gICAgcmV0dXJuICoqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKLSNlbmRpZgorCitz dGF0aWMgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIHN0YXRpY0RhdGEgeyBudWxs cHRyIH07CisKK1RocmVhZEdsb2JhbERhdGEmIHRocmVhZEdsb2JhbERhdGEoKQoreworICAgIGlm IChVTkxJS0VMWSghc3RhdGljRGF0YSkpCisgICAgICAgIHN0YXRpY0RhdGEgPSBuZXcgVGhyZWFk U3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47CisgICAgcmV0dXJuICpzdGF0aWNEYXRhOwogfQog CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vVGhyZWFkR2xvYmFsRGF0YS5oCmluZGV4IDU4ZjdjMDc0MDI1NDA4ODliM2NmZDQ0MTliOTA4 NWNmNTc5Y2NmMjEuLmRmMDE1YTRhZmE5MTE3N2U4MWZiYmJiMzRkMDkxYTE4NGUzMzAwOWEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmgKQEAgLTI3LDExICsy Nyw5IEBACiAjaWZuZGVmIFRocmVhZEdsb2JhbERhdGFfaAogI2RlZmluZSBUaHJlYWRHbG9iYWxE YXRhX2gKIAorI2luY2x1ZGUgPHd0Zi9UaHJlYWRTYWZlUmVmQ291bnRlZC5oPgogI2luY2x1ZGUg PHd0Zi90ZXh0L1N0cmluZ0hhc2guaD4KIAotI2luY2x1ZGUgPHd0Zi9UaHJlYWRTcGVjaWZpYy5o PgotdXNpbmcgV1RGOjpUaHJlYWRTcGVjaWZpYzsKLQogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAg ICAgY2xhc3MgUXVhbGlmaWVkTmFtZUNhY2hlOwpAQCAtNDMsNyArNDEsOCBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgc3RydWN0IFRFQ0NvbnZlcnRlcldyYXBwZXI7CiAKICAgICBjbGFzcyBU aHJlYWRHbG9iYWxEYXRhIHsKLSAgICAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVGhyZWFkR2xv YmFsRGF0YSk7CisgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVGhyZWFkR2xvYmFsRGF0YSk7Cisg ICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiAgICAgcHVibGljOgogICAgICAgICBXRUJDT1JF X0VYUE9SVCBUaHJlYWRHbG9iYWxEYXRhKCk7CiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIH5UaHJl YWRHbG9iYWxEYXRhKCk7CkBAIC04MCwxMCArNzksNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAg ICAgICAgIHN0ZDo6dW5pcXVlX3B0cjxURUNDb252ZXJ0ZXJXcmFwcGVyPiBtX2NhY2hlZENvbnZl cnRlclRFQzsKICNlbmRpZgogCi0gICAgICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBUaHJlYWRT cGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPiogc3RhdGljRGF0YTsKLSNpZiBVU0UoV0VCX1RIUkVB RCkKLSAgICAgICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJl ZE1haW5UaHJlYWRTdGF0aWNEYXRhOwotI2VuZGlmCiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIGZy aWVuZCBUaHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCk7CiAgICAgfTsKIAo= 317246 2017-08-04 08:28:09 -0700 2017-08-04 08:46:14 -0700 Patch bug-175187-20170805002808.patch text/plain 14532 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwMjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx ZGY3MWQ0ZWY4MDFkZDZjZTFiOGM0NWViOGE1NWFjYzY3YzE3MTNlLi5jYjIxODYyYzA3OTYxYTFj NWRiZmQyMWVmN2JhNzY4YTdmMzAwZjExIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNy0wOC0wNCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVj ZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHJ1bnRpbWUvSWRlbnRpZmllci5jcHA6CisKIDIwMTctMDgtMDQg IE9sZWtzYW5kciBTa2FjaGtvdiAgPGdza2FjaGtvdkBnbWFpbC5jb20+CiAKICAgICAgICAgW0Vz TmV4dF0gQXN5bmMgaXRlcmF0aW9uIC0gQWRkIGZlYXR1cmUgZmxhZwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCBiMmE3YjM2ODRm NTM3ODk5NjM4OTJkNTRjZDM2OWYwNThiMjgyNjcyLi43ZWVjN2U5NGUyNWYxM2JhNThjMjhmMmUw NDRjNDcxMjM2YjFiZDNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDE3LTA4LTA0ICBZdXN1a2Ug U3V6dWtpICA8dXRhdGFuZS50ZWFAZ21haWwuY29tPgorCisgICAgICAgIFtXVEZdIFRocmVhZFNw ZWNpZmljIHNob3VsZCBub3QgaW50cm9kdWNlIGFkZGl0aW9uYWwgaW5kaXJlY3Rpb24KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NTE4NworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRocmVhZFNwZWNpZmlj IHNldHMgRGF0YSogdG8gdGhlIFRMUy4gQW5kIERhdGEgaG9sZHMgVCosIHdoaWNoCisgICAgICAg IGlzIGZhc3QgYWxsb2NhdGVkIGFjdHVhbCBkYXRhLiBCdXQgaWRlYWxseSwgd2Ugc2hvdWxkIHN0 b3JlIFQKKyAgICAgICAgaW5zdGFuY2UgZGlyZWN0bHkgaW4gRGF0YSBpbnN0ZWFkIG9mIGludHJv ZHVjaW5nIGFuIGFkZGl0aW9uYWwKKyAgICAgICAgaW5kaXJlY3Rpb24uCisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHN0b3JhZ2UgdG8gRGF0YSBhbmQgaW5pdGlhbGl6ZXMgVCBpbiBEYXRhLgor ICAgICAgICBBbmQgd2UgZHJvcCBUaHJlYWRTcGVjaWZpYzo6cmVwbGFjZSBzdXBwb3J0LCB3aGlj aCBpcyBvbmx5IHVzZWQKKyAgICAgICAgYnkgV2ViIHRocmVhZC4gV2ViIHRocmVhZCBzaG91bGQg dXNlIFRocmVhZFNwZWNpZmljPHN0ZDo6dW5pcXVlX3B0cjxUPj4gaW5zdGVhZC4KKworICAgICAg ICAqIHd0Zi9UaHJlYWRTcGVjaWZpYy5oOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6 RGF0YTo6Y29uc3RydWN0KToKKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWM6OkRhdGE6OmRl c3Ryb3kpOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6RGF0YSk6CisgICAg ICAgIFdlIG1ha2UgaXQgZmFzdCBhbGxvY2F0ZWQgc2luY2Ugd2UgcHJldmlvdXNseSBhbGxvY2F0 ZWQgVGhyZWFkU3BlY2lmaWMgVCBkYXRhIGJ5IGZhc3RNYWxsb2MuCisKKyAgICAgICAgKFdURjo6 VGhyZWFkU3BlY2lmaWM6OkRhdGE6OnN0b3JhZ2VQb2ludGVyIGNvbnN0KToKKyAgICAgICAgKFdU Rjo6Y2FuQmVHQ1RocmVhZD46OmdldCk6CisgICAgICAgIFdlIGFsc28gZHJvcCBSRUxFQVNFX0FT U0VSVCBmcm9tIDo6Z2V0KCkuIFdlIGFscmVhZHkgaW5zZXJ0ZWQgdGhpcyBhc3NlcnQgdG8gc2V0 KCksCisgICAgICAgIHNvIHdoZW4gY3JlYXRpbmcgdGhlIG1lbWJlciB0byB0aGlzIFRMUywgd2Ug ZXhlY3V0ZSB0aGlzIHJlbGVhc2UgYXNzZXJ0LiBTbyBpdCBpcworICAgICAgICBub3QgbmVjZXNz YXJ5IHRvIGV4ZWN1dGUgdGhpcyBhc3NlcnRpb24gZXZlcnkgdGltZSB3ZSBnZXQgZGF0YSBmcm9t IHRoaXMgVExTLgorCisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpzZXQpOgorICAgICAg ICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6ZGVzdHJveSk6CisgICAgICAgIChXVEY6OlQpOgorICAg ICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZSk6IERlbGV0ZWQuCisKIDIwMTctMDgt MDMgIEJyaWFuIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIEVOQUJM RShXRUJfU09DS0VUKSBndWFyZHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2NDQ3NDlmNGE5NGFiMzdmNzkxYzYx YzVlYmFhMzhiMDNhY2FmMDlmLi43NjE1YjBkYWU4ZWJhYmMwNTlhMzVkZTRhNTJjNDE3YjY2ZTMx Y2M4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTctMDgtMDQgIFl1c3VrZSBTdXp1 a2kgIDx1dGF0YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFkU3BlY2lm aWMgc2hvdWxkIG5vdCBpbnRyb2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2UgZHJvcCBUaHJlYWRTcGVj aWZpYzo6cmVwbGFjZSBmZWF0dXJlIHdoaWNoIGlzIG9ubHkgdXNlZCBieQorICAgICAgICBXZWIg dGhyZWFkLiBJbnN0ZWFkLCB3ZSB1c2UgVGhyZWFkU3BlY2lmaWM8c3RkOjp1bmlxdWVfcHRyPFQ+ PiBoZXJlLgorCisgICAgICAgIFdoaWxlIHRoaXMgc3RkOjp1bmlxdWVfcHRyPFQ+IHNoYXJlcyBv bmUgaW5zdGFuY2UgYmV0d2VlbiBtYWluIHRocmVhZAorICAgICAgICBhbmQgd2ViIHRocmVhZCwg dGhpcyBpcyB0aGUgc2FtZSB0byB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbi4gSXQgaXMKKyAg ICAgICAgc2FmZSBiZWNhdXNlIHRoZSB3ZWIgdGhyZWFkIG5ldmVyIGZpbmlzaGVzLgorCisgICAg ICAgIEFuZCBmb3Igbm9uLXdlYiB0aHJlYWQgaW1wbGVtZW50YXRpb24sIHdlIGp1c3QgdXNlIFRo cmVhZFNwZWNpZmljPFQ+LAorICAgICAgICBzaW5jZSBpdCBpcyB0aGUgbW9zdCBlZmZpY2llbnQu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRocmVhZEdsb2JhbERhdGE6OlRocmVhZEdsb2JhbERhdGEpOgorICAgICAgICAoV2Vi Q29yZTo6VGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29yZVRocmVhZERhdGEpOgorICAgICAgICAo V2ViQ29yZTo6dGhyZWFkR2xvYmFsRGF0YSk6CisgICAgICAgIFdlIGFsc28gZHJvcCBTdHJpbmdJ bXBsOjplbXB0eSgpIGNhbGwgc2luY2UgaXQgaXMgbm90IG5lY2Vzc2FyeSBub3c6CisgICAgICAg IFN0cmluZ0ltcGw6OmVtcHR5IGRhdGEgaXMgc3RhdGljYWxseSBpbml0aWFsaXplZCBieSB1c2lu ZyBjb25zdGV4cHIuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmg6CisK IDIwMTctMDgtMDQgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEuY29tPgogCiAgICAg ICAgIFtFTUVdIFB1c2ggQ0RNRmFjdG9yeSBpbnRvIHRoZSBwbGF0Zm9ybSBsYXllcgpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVudGlmaWVyLmNwcAppbmRleCBkNTUyZDBiMWY2 Mjg3MTVhMjYzNmFiNzczN2VkZmM2MTk3MzRjMGM4Li5mODRiNjllNGQzZDNmNWRmOGI2NmZmNzY4 ODFlZmU0OTVmZGIyNDJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9JZGVudGlmaWVyLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVu dGlmaWVyLmNwcApAQCAtMzMsOCArMzMsNiBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0L0FTQ0lJRmFz dFBhdGguaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKLXVzaW5nIFdURjo6 VGhyZWFkU3BlY2lmaWM7Ci0KIG5hbWVzcGFjZSBKU0MgewogCiBSZWY8U3RyaW5nSW1wbD4gSWRl bnRpZmllcjo6YWRkKFZNKiB2bSwgY29uc3QgY2hhciogYykKZGlmZiAtLWdpdCBhL1NvdXJjZS9X VEYvd3RmL1RocmVhZFNwZWNpZmljLmggYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5o CmluZGV4IDFmOTgzNjNlOTM0MTM0YzQxNDMzMzZjOGI4MmY4YWZjNDM4MTVlMjMuLjUyMzE2MWI0 MzUyOTU5OTA3ZWVlZWM2NGYxNDQyOTAyOGYzOTkxNzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv d3RmL1RocmVhZFNwZWNpZmljLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lmaWMu aApAQCAtODIsMTAgKzgyLDYgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBj YW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNsYXNzIFQKICAgICBvcGVyYXRv ciBUKigpOwogICAgIFQmIG9wZXJhdG9yKigpOwogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi0gICAg dm9pZCByZXBsYWNlKFQqKTsKLSNlbmRpZgotCiBwcml2YXRlOgogICAgIC8vIE5vdCBpbXBsZW1l bnRlZC4gSXQncyB0ZWNobmljYWxseSBwb3NzaWJsZSB0byBkZXN0cm95IGEgdGhyZWFkIHNwZWNp ZmljIGtleSwgYnV0IG9uZSB3b3VsZCBuZWVkCiAgICAgLy8gdG8gbWFrZSBzdXJlIHRoYXQgYWxs IHZhbHVlcyBoYXZlIGJlZW4gZGVzdHJveWVkIGFscmVhZHkgKHVzdWFsbHksIHRoYXQgYWxsIHRo cmVhZHMgdGhhdCB1c2VkIGl0CkBAIC05MywxOSArODksMzcgQEAgdGVtcGxhdGU8dHlwZW5hbWUg VCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNs YXNzIFQKICAgICAvLyBhIGRlc3RydWN0b3IgZGVmaW5lZCBjYW4gYmUgY29uZnVzaW5nLCBnaXZl biB0aGF0IGl0IGhhcyBzdWNoIHN0cm9uZyBwcmUtcmVxdWlzaXRlcyB0byB3b3JrIGNvcnJlY3Rs eS4KICAgICB+VGhyZWFkU3BlY2lmaWMoKTsKIAotICAgIFQqIGdldCgpOwotICAgIHZvaWQgc2V0 KFQqKTsKLSAgICB2b2lkIHN0YXRpYyBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBkZXN0cm95KHZvaWQq IHB0cik7Ci0KICAgICBzdHJ1Y3QgRGF0YSB7CiAgICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxF KERhdGEpOworICAgICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKICAgICBwdWJsaWM6Ci0g ICAgICAgIERhdGEoVCogdmFsdWUsIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBv d25lcikgOiB2YWx1ZSh2YWx1ZSksIG93bmVyKG93bmVyKSB7fQorICAgICAgICB1c2luZyBQb2lu dGVyVHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX2NvbnN0PFQ+Ojp0eXBlKjsKKworICAgICAg ICB2b2lkIGNvbnN0cnVjdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIG5ldyAoTm90TnVsbCwg c3RvcmFnZVBvaW50ZXIoKSkgVDsKKyAgICAgICAgfQogCi0gICAgICAgIFQqIHZhbHVlOworICAg ICAgICB2b2lkIGRlc3Ryb3koKQorICAgICAgICB7CisgICAgICAgICAgICBzdG9yYWdlUG9pbnRl cigpLT5+VCgpOworICAgICAgICB9CisKKyAgICAgICAgRGF0YShUaHJlYWRTcGVjaWZpYzxULCBj YW5CZUdDVGhyZWFkPiogb3duZXIpCisgICAgICAgICAgICA6IG93bmVyKG93bmVyKQorICAgICAg ICB7CisgICAgICAgIH0KKworICAgICAgICBQb2ludGVyVHlwZSBzdG9yYWdlUG9pbnRlcigpIGNv bnN0IHsgcmV0dXJuIGNvbnN0X2Nhc3Q8UG9pbnRlclR5cGU+KHJlaW50ZXJwcmV0X2Nhc3Q8Y29u c3QgVCo+KCZtX3N0b3JhZ2UpKTsgfQorCisgICAgICAgIHR5cGVuYW1lIHN0ZDo6YWxpZ25lZF9z dG9yYWdlPHNpemVvZihUKSwgc3RkOjphbGlnbm1lbnRfb2Y8VD46OnZhbHVlPjo6dHlwZSBtX3N0 b3JhZ2U7CiAgICAgICAgIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25lcjsK ICAgICB9OwogCisgICAgVCogZ2V0KCk7CisgICAgRGF0YSogc2V0KCk7CisgICAgdm9pZCBzdGF0 aWMgVEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJveSh2b2lkKiBwdHIpOworCiAjaWYgVVNFKFBU SFJFQURTKQogICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAt MTU2LDE3ICsxNzAsMTggQEAgaW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJl YWQ+OjpnZXQoKQogewogICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRocmVh ZF9nZXRzcGVjaWZpYyhtX2tleSkpOwogICAgIGlmIChkYXRhKQotICAgICAgICByZXR1cm4gZGF0 YS0+dmFsdWU7Ci0gICAgUkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhy ZWFkOjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFkKCkpOworICAgICAgICByZXR1cm4gZGF0YS0+c3Rv cmFnZVBvaW50ZXIoKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogdGVtcGxhdGU8dHlwZW5h bWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFkU3Bl Y2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OnNldChUKiBwdHIpCitpbmxpbmUgYXV0byBUaHJlYWRT cGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6c2V0KCkgLT4gRGF0YSoKIHsKICAgICBSRUxFQVNF X0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NU aHJlYWQoKSk7CiAgICAgQVNTRVJUKCFnZXQoKSk7Ci0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyht X2tleSwgbmV3IERhdGEocHRyLCB0aGlzKSk7CisgICAgRGF0YSogZGF0YSA9IG5ldyBEYXRhKHRo aXMpOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIGRhdGEpOworICAgIHJldHVybiBk YXRhOwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMjMyLDE4ICsyNDcsMTggQEAgaW5saW5l IFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERhdGEq IGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4oRmxzR2V0VmFsdWUoZmxzS2V5cygpW21faW5kZXhd KSk7CiAgICAgaWYgKGRhdGEpCi0gICAgICAgIHJldHVybiBkYXRhLT52YWx1ZTsKLSAgICBSRUxF QVNFX0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJl R0NUaHJlYWQoKSk7CisgICAgICAgIHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwogICAg IHJldHVybiBudWxscHRyOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFk IGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhy ZWFkPjo6c2V0KFQqIHB0cikKK2lubGluZSBhdXRvIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NU aHJlYWQ+OjpzZXQoKSAtPiBEYXRhKgogewogICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJlR0NUaHJl YWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKICAgICBBU1NF UlQoIWdldCgpKTsKLSAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEocHRyLCB0aGlzKTsKKyAgICBE YXRhKiBkYXRhID0gbmV3IERhdGEodGhpcyk7CiAgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW21f aW5kZXhdLCBkYXRhKTsKKyAgICByZXR1cm4gZGF0YTsKIH0KIAogI2Vsc2UKQEAgLTI2MSwxMyAr Mjc2LDEyIEBAIGlubGluZSB2b2lkIFRIUkVBRF9TUEVDSUZJQ19DQUxMIFRocmVhZFNwZWNpZmlj PFQsIGNhbkJlR0NUaHJlYWQ+OjpkZXN0cm95KHZvaWQqCiAgICAgcHRocmVhZF9zZXRzcGVjaWZp YyhkYXRhLT5vd25lci0+bV9rZXksIHB0cik7CiAjZW5kaWYKIAotICAgIGRhdGEtPnZhbHVlLT5+ VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKKyAgICBkYXRhLT5kZXN0cm95KCk7CiAK ICNpZiBVU0UoUFRIUkVBRFMpCi0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+ bV9rZXksIDApOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMoZGF0YS0+b3duZXItPm1fa2V5LCBu dWxscHRyKTsKICNlbGlmIE9TKFdJTkRPV1MpCi0gICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2Rh dGEtPm93bmVyLT5tX2luZGV4XSwgMCk7CisgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2RhdGEt Pm93bmVyLT5tX2luZGV4XSwgbnVsbHB0cik7CiAjZWxzZQogI2Vycm9yIFRocmVhZFNwZWNpZmlj IGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4KICNlbmRpZgpAQCAtMjg1LDE0 ICsyOTksMTQgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhy ZWFkPgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpvcGVyYXRvciBU KigpCiB7CiAgICAgVCogcHRyID0gc3RhdGljX2Nhc3Q8VCo+KGdldCgpKTsKLSAgICBpZiAoIXB0 cikgewotICAgICAgICAvLyBTZXQgdXAgdGhyZWFkLXNwZWNpZmljIHZhbHVlJ3MgbWVtb3J5IHBv aW50ZXIgYmVmb3JlIGludm9raW5nIGNvbnN0cnVjdG9yLCBpbiBjYXNlIGFueSBmdW5jdGlvbiBp dCBjYWxscwotICAgICAgICAvLyBuZWVkcyB0byBhY2Nlc3MgdGhlIHZhbHVlLCB0byBhdm9pZCBy ZWN1cnNpb24uCi0gICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PFQqPihmYXN0WmVyb2VkTWFsbG9j KHNpemVvZihUKSkpOwotICAgICAgICBzZXQocHRyKTsKLSAgICAgICAgbmV3IChOb3ROdWxsLCBw dHIpIFQ7Ci0gICAgfQotICAgIHJldHVybiBwdHI7CisgICAgaWYgKHB0cikKKyAgICAgICAgcmV0 dXJuIHB0cjsKKworICAgIC8vIFNldCB1cCB0aHJlYWQtc3BlY2lmaWMgdmFsdWUncyBtZW1vcnkg cG9pbnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0b3IsIGluIGNhc2UgYW55IGZ1bmN0aW9u IGl0IGNhbGxzCisgICAgLy8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZvaWQgcmVj dXJzaW9uLgorICAgIERhdGEqIGRhdGEgPSBzZXQoKTsKKyAgICBkYXRhLT5jb25zdHJ1Y3QoKTsK KyAgICByZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsKIH0KIAogdGVtcGxhdGU8dHlwZW5h bWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgpAQCAtMzA3LDE5ICszMjEsOCBAQCBp bmxpbmUgVCYgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46Om9wZXJhdG9yKigpCiAg ICAgcmV0dXJuICpvcGVyYXRvciBUKigpOwogfQogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi10ZW1w bGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9p ZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZShUKiBuZXdQdHIpCi17 Ci0gICAgQVNTRVJUKG5ld1B0cik7Ci0gICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEq PihwdGhyZWFkX2dldHNwZWNpZmljKG1fa2V5KSk7Ci0gICAgQVNTRVJUKGRhdGEpOwotICAgIGRh dGEtPnZhbHVlLT5+VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKLSAgICBkYXRhLT52 YWx1ZSA9IG5ld1B0cjsKLX0KLSNlbmRpZgotCiB9IC8vIG5hbWVzcGFjZSBXVEYKIAordXNpbmcg V1RGOjpUaHJlYWRTcGVjaWZpYzsKKwogI2VuZGlmIC8vIFdURl9UaHJlYWRTcGVjaWZpY19oCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCmluZGV4IDc3Mzgy OWQ1ZTdiNGViMzNkN2JlODM4MDcxNmY5YTMzMzcyNmY0ZjguLmZhZTViNmU0MDk4MjU3Yzk4MDEx ODE0MjE1OTdkZmU2MGRjMDgyNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1RocmVhZEdsb2JhbERhdGEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVh ZEdsb2JhbERhdGEuY3BwCkBAIC00MywxMSArNDMsNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKLVRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+KiBUaHJlYWRHbG9iYWxEYXRhOjpz dGF0aWNEYXRhOwotI2lmIFVTRShXRUJfVEhSRUFEKQotVGhyZWFkR2xvYmFsRGF0YSogVGhyZWFk R2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGE7Ci0jZW5kaWYKLQogVGhyZWFk R2xvYmFsRGF0YTo6VGhyZWFkR2xvYmFsRGF0YSgpCiAgICAgOiBtX2NhY2hlZFJlc291cmNlUmVx dWVzdEluaXRpYXRvcnMoc3RkOjptYWtlX3VuaXF1ZTxDYWNoZWRSZXNvdXJjZVJlcXVlc3RJbml0 aWF0b3JzPigpKQogICAgICwgbV9ldmVudE5hbWVzKEV2ZW50TmFtZXM6OmNyZWF0ZSgpKQpAQCAt NjYsNyArNjEsNiBAQCBUaHJlYWRHbG9iYWxEYXRhOjpUaHJlYWRHbG9iYWxEYXRhKCkKICAgICAv LyBwb2ludCB0byBjYWxsIG1ldGhvZHMgdGhhdCBpbnRlcm5hbGx5IHBlcmZvcm0gYSBvbmUtdGlt ZSBpbml0aWFsaXphdGlvbiB0aGF0IGlzIG5vdAogICAgIC8vIHRocmVhZHNhZmUuCiAgICAgVGhy ZWFkOjpjdXJyZW50KCk7Ci0gICAgU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIH0KIAogVGhyZWFkR2xv YmFsRGF0YTo6flRocmVhZEdsb2JhbERhdGEoKQpAQCAtODcsMzQgKzgxLDUyIEBAIHZvaWQgVGhy ZWFkR2xvYmFsRGF0YTo6ZGVzdHJveSgpCiB9CiAKICNpZiBVU0UoV0VCX1RIUkVBRCkKK3N0YXRp YyBUaHJlYWRTcGVjaWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFkR2xvYmFsRGF0YT4+KiBzdGF0 aWNEYXRhIHsgbnVsbHB0ciB9Oworc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5U aHJlYWRTdGF0aWNEYXRhIHsgbnVsbHB0ciB9OworCiB2b2lkIFRocmVhZEdsb2JhbERhdGE6OnNl dFdlYkNvcmVUaHJlYWREYXRhKCkKIHsKICAgICBBU1NFUlQoaXNXZWJUaHJlYWQoKSk7Ci0gICAg QVNTRVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkgIT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFp blRocmVhZFN0YXRpY0RhdGEpOworICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpICE9IHNo YXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKIAogICAgIC8vIFNldCBXZWJUaHJlYWQncyBUaHJl YWRHbG9iYWxEYXRhIG9iamVjdCB0byBiZSB0aGUgc2FtZSBhcyB0aGUgbWFpbiBVSSB0aHJlYWQu Ci0gICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YS0+cmVwbGFjZShUaHJlYWRHbG9iYWxE YXRhOjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgLy8gV2hpbGUgd2Ugc3RvcmUg dGhlIHNhbWUgcG9pbnRlciB0byBzdGQ6OnVuaXF1ZV9wdHIsIGl0IGlzIG9rIGJlY2F1c2UgdGhl IHdlYiB0aHJlYWQgbmV2ZXIgZmluaXNoZXMuCisgICAgKipzdGF0aWNEYXRhLnJlc2V0KHNoYXJl ZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKIAotICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgp ID09IFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKKyAgICBB U1NFUlQoJnRocmVhZEdsb2JhbERhdGEoKSA9PSBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7 CiB9Ci0jZW5kaWYKIAotVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpIAorVGhy ZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpCiB7Ci0jaWYgVVNFKFdFQl9USFJFQUQp Ci0gICAgaWYgKFVOTElLRUxZKCFUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhKSkgewotICAg ICAgICBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhID0gbmV3IFRocmVhZFNwZWNpZmljPFRo cmVhZEdsb2JhbERhdGE+OworICAgIGlmIChVTkxJS0VMWSghc3RhdGljRGF0YSkpIHsKKyAgICAg ICAgc3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFk R2xvYmFsRGF0YT4+OworICAgICAgICBhdXRvJiByZXN1bHQgPSAqKnN0YXRpY0RhdGE7CisgICAg ICAgIEFTU0VSVCghcmVzdWx0KTsKKyAgICAgICAgcmVzdWx0LnJlc2V0KG5ldyBUaHJlYWRHbG9i YWxEYXRhKCkpOwogICAgICAgICAvLyBXZWJUaHJlYWQgYW5kIG1haW4gVUkgdGhyZWFkIG5lZWQg dG8gc2hhcmUgdGhlIHNhbWUgb2JqZWN0LiBTYXZlIGl0IGluIGEgc3RhdGljCiAgICAgICAgIC8v IGhlcmUsIHRoZSBXZWJUaHJlYWQgd2lsbCBwaWNrIGl0IHVwIGluIHNldFdlYkNvcmVUaHJlYWRE YXRhKCkuCiAgICAgICAgIGlmIChwdGhyZWFkX21haW5fbnAoKSkKLSAgICAgICAgICAgIFRocmVh ZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0gKlRocmVhZEdsb2JhbERh dGE6OnN0YXRpY0RhdGE7CisgICAgICAgICAgICBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSA9 IHJlc3VsdC5nZXQoKTsKKyAgICAgICAgcmV0dXJuICpyZXN1bHQ7CiAgICAgfQotICAgIHJldHVy biAqKlRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7CisKKyAgICBhdXRvJiByZXN1bHQgPSAq KnN0YXRpY0RhdGE7CisgICAgaWYgKCFyZXN1bHQpCisgICAgICAgIHJlc3VsdC5yZXNldChuZXcg VGhyZWFkR2xvYmFsRGF0YSgpKTsKKyAgICByZXR1cm4gKnJlc3VsdDsKK30KKwogI2Vsc2UKLSAg ICBpZiAoIVRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGEpCi0gICAgICAgIFRocmVhZEdsb2Jh bERhdGE6OnN0YXRpY0RhdGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47 Ci0gICAgcmV0dXJuICoqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKLSNlbmRpZgorCitz dGF0aWMgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIHN0YXRpY0RhdGEgeyBudWxs cHRyIH07CisKK1RocmVhZEdsb2JhbERhdGEmIHRocmVhZEdsb2JhbERhdGEoKQoreworICAgIGlm IChVTkxJS0VMWSghc3RhdGljRGF0YSkpCisgICAgICAgIHN0YXRpY0RhdGEgPSBuZXcgVGhyZWFk U3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47CisgICAgcmV0dXJuICoqc3RhdGljRGF0YTsKIH0K IAorI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1RocmVhZEdsb2JhbERhdGEuaAppbmRleCA1OGY3YzA3NDAyNTQwODg5YjNjZmQ0NDE5Yjkw ODVjZjU3OWNjZjIxLi5kZjAxNWE0YWZhOTExNzdlODFmYmJiYjM0ZDA5MWExODRlMzMwMDlhIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oCkBAIC0yNywxMSAr MjcsOSBAQAogI2lmbmRlZiBUaHJlYWRHbG9iYWxEYXRhX2gKICNkZWZpbmUgVGhyZWFkR2xvYmFs RGF0YV9oCiAKKyNpbmNsdWRlIDx3dGYvVGhyZWFkU2FmZVJlZkNvdW50ZWQuaD4KICNpbmNsdWRl IDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKLSNpbmNsdWRlIDx3dGYvVGhyZWFkU3BlY2lmaWMu aD4KLXVzaW5nIFdURjo6VGhyZWFkU3BlY2lmaWM7Ci0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAog ICAgIGNsYXNzIFF1YWxpZmllZE5hbWVDYWNoZTsKQEAgLTQzLDcgKzQxLDggQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgIHN0cnVjdCBURUNDb252ZXJ0ZXJXcmFwcGVyOwogCiAgICAgY2xhc3Mg VGhyZWFkR2xvYmFsRGF0YSB7Ci0gICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFRocmVhZEds b2JhbERhdGEpOworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFRocmVhZEdsb2JhbERhdGEpOwor ICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogICAgIHB1YmxpYzoKICAgICAgICAgV0VCQ09S RV9FWFBPUlQgVGhyZWFkR2xvYmFsRGF0YSgpOwogICAgICAgICBXRUJDT1JFX0VYUE9SVCB+VGhy ZWFkR2xvYmFsRGF0YSgpOwpAQCAtODAsMTAgKzc5LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog ICAgICAgICBzdGQ6OnVuaXF1ZV9wdHI8VEVDQ29udmVydGVyV3JhcHBlcj4gbV9jYWNoZWRDb252 ZXJ0ZXJURUM7CiAjZW5kaWYKIAotICAgICAgICBXRUJDT1JFX0VYUE9SVCBzdGF0aWMgVGhyZWFk U3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIHN0YXRpY0RhdGE7Ci0jaWYgVVNFKFdFQl9USFJF QUQpCi0gICAgICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBUaHJlYWRHbG9iYWxEYXRhKiBzaGFy ZWRNYWluVGhyZWFkU3RhdGljRGF0YTsKLSNlbmRpZgogICAgICAgICBXRUJDT1JFX0VYUE9SVCBm cmllbmQgVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpOwogICAgIH07CiAK 317249 2017-08-04 08:46:16 -0700 2017-08-04 10:02:48 -0700 Patch bug-175187-20170805004615.patch text/plain 14547 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwMjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx ZGY3MWQ0ZWY4MDFkZDZjZTFiOGM0NWViOGE1NWFjYzY3YzE3MTNlLi5jYjIxODYyYzA3OTYxYTFj NWRiZmQyMWVmN2JhNzY4YTdmMzAwZjExIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNy0wOC0wNCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVj ZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHJ1bnRpbWUvSWRlbnRpZmllci5jcHA6CisKIDIwMTctMDgtMDQg IE9sZWtzYW5kciBTa2FjaGtvdiAgPGdza2FjaGtvdkBnbWFpbC5jb20+CiAKICAgICAgICAgW0Vz TmV4dF0gQXN5bmMgaXRlcmF0aW9uIC0gQWRkIGZlYXR1cmUgZmxhZwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCBiMmE3YjM2ODRm NTM3ODk5NjM4OTJkNTRjZDM2OWYwNThiMjgyNjcyLi43ZWVjN2U5NGUyNWYxM2JhNThjMjhmMmUw NDRjNDcxMjM2YjFiZDNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDE3LTA4LTA0ICBZdXN1a2Ug U3V6dWtpICA8dXRhdGFuZS50ZWFAZ21haWwuY29tPgorCisgICAgICAgIFtXVEZdIFRocmVhZFNw ZWNpZmljIHNob3VsZCBub3QgaW50cm9kdWNlIGFkZGl0aW9uYWwgaW5kaXJlY3Rpb24KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NTE4NworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRocmVhZFNwZWNpZmlj IHNldHMgRGF0YSogdG8gdGhlIFRMUy4gQW5kIERhdGEgaG9sZHMgVCosIHdoaWNoCisgICAgICAg IGlzIGZhc3QgYWxsb2NhdGVkIGFjdHVhbCBkYXRhLiBCdXQgaWRlYWxseSwgd2Ugc2hvdWxkIHN0 b3JlIFQKKyAgICAgICAgaW5zdGFuY2UgZGlyZWN0bHkgaW4gRGF0YSBpbnN0ZWFkIG9mIGludHJv ZHVjaW5nIGFuIGFkZGl0aW9uYWwKKyAgICAgICAgaW5kaXJlY3Rpb24uCisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHN0b3JhZ2UgdG8gRGF0YSBhbmQgaW5pdGlhbGl6ZXMgVCBpbiBEYXRhLgor ICAgICAgICBBbmQgd2UgZHJvcCBUaHJlYWRTcGVjaWZpYzo6cmVwbGFjZSBzdXBwb3J0LCB3aGlj aCBpcyBvbmx5IHVzZWQKKyAgICAgICAgYnkgV2ViIHRocmVhZC4gV2ViIHRocmVhZCBzaG91bGQg dXNlIFRocmVhZFNwZWNpZmljPHN0ZDo6dW5pcXVlX3B0cjxUPj4gaW5zdGVhZC4KKworICAgICAg ICAqIHd0Zi9UaHJlYWRTcGVjaWZpYy5oOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6 RGF0YTo6Y29uc3RydWN0KToKKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWM6OkRhdGE6OmRl c3Ryb3kpOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6RGF0YSk6CisgICAg ICAgIFdlIG1ha2UgaXQgZmFzdCBhbGxvY2F0ZWQgc2luY2Ugd2UgcHJldmlvdXNseSBhbGxvY2F0 ZWQgVGhyZWFkU3BlY2lmaWMgVCBkYXRhIGJ5IGZhc3RNYWxsb2MuCisKKyAgICAgICAgKFdURjo6 VGhyZWFkU3BlY2lmaWM6OkRhdGE6OnN0b3JhZ2VQb2ludGVyIGNvbnN0KToKKyAgICAgICAgKFdU Rjo6Y2FuQmVHQ1RocmVhZD46OmdldCk6CisgICAgICAgIFdlIGFsc28gZHJvcCBSRUxFQVNFX0FT U0VSVCBmcm9tIDo6Z2V0KCkuIFdlIGFscmVhZHkgaW5zZXJ0ZWQgdGhpcyBhc3NlcnQgdG8gc2V0 KCksCisgICAgICAgIHNvIHdoZW4gY3JlYXRpbmcgdGhlIG1lbWJlciB0byB0aGlzIFRMUywgd2Ug ZXhlY3V0ZSB0aGlzIHJlbGVhc2UgYXNzZXJ0LiBTbyBpdCBpcworICAgICAgICBub3QgbmVjZXNz YXJ5IHRvIGV4ZWN1dGUgdGhpcyBhc3NlcnRpb24gZXZlcnkgdGltZSB3ZSBnZXQgZGF0YSBmcm9t IHRoaXMgVExTLgorCisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpzZXQpOgorICAgICAg ICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6ZGVzdHJveSk6CisgICAgICAgIChXVEY6OlQpOgorICAg ICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZSk6IERlbGV0ZWQuCisKIDIwMTctMDgt MDMgIEJyaWFuIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIEVOQUJM RShXRUJfU09DS0VUKSBndWFyZHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2NDQ3NDlmNGE5NGFiMzdmNzkxYzYx YzVlYmFhMzhiMDNhY2FmMDlmLi43Nzc1NGQ4YjdlMGRmODVkYzg5MGRhNjA3OWUyZDdhNjg2NDg1 MjgzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTctMDgtMDQgIFl1c3VrZSBTdXp1 a2kgIDx1dGF0YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFkU3BlY2lm aWMgc2hvdWxkIG5vdCBpbnRyb2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2UgZHJvcCBUaHJlYWRTcGVj aWZpYzo6cmVwbGFjZSBmZWF0dXJlIHdoaWNoIGlzIG9ubHkgdXNlZCBieQorICAgICAgICBXZWIg dGhyZWFkLiBJbnN0ZWFkLCB3ZSB1c2UgVGhyZWFkU3BlY2lmaWM8c3RkOjp1bmlxdWVfcHRyPFQ+ PiBoZXJlLgorCisgICAgICAgIFdoaWxlIHRoaXMgc3RkOjp1bmlxdWVfcHRyPFQ+IHNoYXJlcyBv bmUgaW5zdGFuY2UgYmV0d2VlbiBtYWluIHRocmVhZAorICAgICAgICBhbmQgd2ViIHRocmVhZCwg dGhpcyBpcyB0aGUgc2FtZSB0byB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbi4gSXQgaXMKKyAg ICAgICAgc2FmZSBiZWNhdXNlIHRoZSB3ZWIgdGhyZWFkIG5ldmVyIGZpbmlzaGVzLgorCisgICAg ICAgIEFuZCBmb3Igbm9uLXdlYiB0aHJlYWQgaW1wbGVtZW50YXRpb24sIHdlIGp1c3QgdXNlIFRo cmVhZFNwZWNpZmljPFQ+LAorICAgICAgICBzaW5jZSBpdCBpcyB0aGUgbW9zdCBlZmZpY2llbnQu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRocmVhZEdsb2JhbERhdGE6OlRocmVhZEdsb2JhbERhdGEpOgorICAgICAgICAoV2Vi Q29yZTo6VGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29yZVRocmVhZERhdGEpOgorICAgICAgICAo V2ViQ29yZTo6dGhyZWFkR2xvYmFsRGF0YSk6CisgICAgICAgIFdlIGFsc28gZHJvcCBTdHJpbmdJ bXBsOjplbXB0eSgpIGNhbGwgc2luY2UgaXQgaXMgbm90IG5lY2Vzc2FyeSBub3c6CisgICAgICAg IFN0cmluZ0ltcGw6OmVtcHR5IGRhdGEgaXMgc3RhdGljYWxseSBpbml0aWFsaXplZCBieSB1c2lu ZyBjb25zdGV4cHIuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmg6Cisg ICAgICAgIFdlIG1ha2UgaXQgRkFTVF9BTExPQ0FURUQgc2luY2UgaXQgaXMgcHJldmlvdXNseSBh bGxvY2F0ZWQgYnkgZmFzdCBtYWxsb2MKKyAgICAgICAgaW4gVGhyZWFkU3BlY2lmaWMuCisKIDIw MTctMDgtMDQgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEuY29tPgogCiAgICAgICAg IFtFTUVdIFB1c2ggQ0RNRmFjdG9yeSBpbnRvIHRoZSBwbGF0Zm9ybSBsYXllcgpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVudGlmaWVyLmNwcAppbmRleCBkNTUyZDBiMWY2Mjg3 MTVhMjYzNmFiNzczN2VkZmM2MTk3MzRjMGM4Li5mODRiNjllNGQzZDNmNWRmOGI2NmZmNzY4ODFl ZmU0OTVmZGIyNDJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9J ZGVudGlmaWVyLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVudGlm aWVyLmNwcApAQCAtMzMsOCArMzMsNiBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0L0FTQ0lJRmFzdFBh dGguaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKLXVzaW5nIFdURjo6VGhy ZWFkU3BlY2lmaWM7Ci0KIG5hbWVzcGFjZSBKU0MgewogCiBSZWY8U3RyaW5nSW1wbD4gSWRlbnRp Zmllcjo6YWRkKFZNKiB2bSwgY29uc3QgY2hhciogYykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYv d3RmL1RocmVhZFNwZWNpZmljLmggYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCmlu ZGV4IDFmOTgzNjNlOTM0MTM0YzQxNDMzMzZjOGI4MmY4YWZjNDM4MTVlMjMuLjUyMzE2MWI0MzUy OTU5OTA3ZWVlZWM2NGYxNDQyOTAyOGYzOTkxNzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3Rm L1RocmVhZFNwZWNpZmljLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lmaWMuaApA QCAtODIsMTAgKzgyLDYgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5C ZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNsYXNzIFQKICAgICBvcGVyYXRvciBU KigpOwogICAgIFQmIG9wZXJhdG9yKigpOwogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi0gICAgdm9p ZCByZXBsYWNlKFQqKTsKLSNlbmRpZgotCiBwcml2YXRlOgogICAgIC8vIE5vdCBpbXBsZW1lbnRl ZC4gSXQncyB0ZWNobmljYWxseSBwb3NzaWJsZSB0byBkZXN0cm95IGEgdGhyZWFkIHNwZWNpZmlj IGtleSwgYnV0IG9uZSB3b3VsZCBuZWVkCiAgICAgLy8gdG8gbWFrZSBzdXJlIHRoYXQgYWxsIHZh bHVlcyBoYXZlIGJlZW4gZGVzdHJveWVkIGFscmVhZHkgKHVzdWFsbHksIHRoYXQgYWxsIHRocmVh ZHMgdGhhdCB1c2VkIGl0CkBAIC05MywxOSArODksMzcgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwg Q2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNsYXNz IFQKICAgICAvLyBhIGRlc3RydWN0b3IgZGVmaW5lZCBjYW4gYmUgY29uZnVzaW5nLCBnaXZlbiB0 aGF0IGl0IGhhcyBzdWNoIHN0cm9uZyBwcmUtcmVxdWlzaXRlcyB0byB3b3JrIGNvcnJlY3RseS4K ICAgICB+VGhyZWFkU3BlY2lmaWMoKTsKIAotICAgIFQqIGdldCgpOwotICAgIHZvaWQgc2V0KFQq KTsKLSAgICB2b2lkIHN0YXRpYyBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBkZXN0cm95KHZvaWQqIHB0 cik7Ci0KICAgICBzdHJ1Y3QgRGF0YSB7CiAgICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKERh dGEpOworICAgICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKICAgICBwdWJsaWM6Ci0gICAg ICAgIERhdGEoVCogdmFsdWUsIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25l cikgOiB2YWx1ZSh2YWx1ZSksIG93bmVyKG93bmVyKSB7fQorICAgICAgICB1c2luZyBQb2ludGVy VHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX2NvbnN0PFQ+Ojp0eXBlKjsKKworICAgICAgICB2 b2lkIGNvbnN0cnVjdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIG5ldyAoTm90TnVsbCwgc3Rv cmFnZVBvaW50ZXIoKSkgVDsKKyAgICAgICAgfQogCi0gICAgICAgIFQqIHZhbHVlOworICAgICAg ICB2b2lkIGRlc3Ryb3koKQorICAgICAgICB7CisgICAgICAgICAgICBzdG9yYWdlUG9pbnRlcigp LT5+VCgpOworICAgICAgICB9CisKKyAgICAgICAgRGF0YShUaHJlYWRTcGVjaWZpYzxULCBjYW5C ZUdDVGhyZWFkPiogb3duZXIpCisgICAgICAgICAgICA6IG93bmVyKG93bmVyKQorICAgICAgICB7 CisgICAgICAgIH0KKworICAgICAgICBQb2ludGVyVHlwZSBzdG9yYWdlUG9pbnRlcigpIGNvbnN0 IHsgcmV0dXJuIGNvbnN0X2Nhc3Q8UG9pbnRlclR5cGU+KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3Qg VCo+KCZtX3N0b3JhZ2UpKTsgfQorCisgICAgICAgIHR5cGVuYW1lIHN0ZDo6YWxpZ25lZF9zdG9y YWdlPHNpemVvZihUKSwgc3RkOjphbGlnbm1lbnRfb2Y8VD46OnZhbHVlPjo6dHlwZSBtX3N0b3Jh Z2U7CiAgICAgICAgIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25lcjsKICAg ICB9OwogCisgICAgVCogZ2V0KCk7CisgICAgRGF0YSogc2V0KCk7CisgICAgdm9pZCBzdGF0aWMg VEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJveSh2b2lkKiBwdHIpOworCiAjaWYgVVNFKFBUSFJF QURTKQogICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMTU2 LDE3ICsxNzAsMTggQEAgaW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+ OjpnZXQoKQogewogICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRocmVhZF9n ZXRzcGVjaWZpYyhtX2tleSkpOwogICAgIGlmIChkYXRhKQotICAgICAgICByZXR1cm4gZGF0YS0+ dmFsdWU7Ci0gICAgUkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhyZWFk OjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFkKCkpOworICAgICAgICByZXR1cm4gZGF0YS0+c3RvcmFn ZVBvaW50ZXIoKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUg VCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lm aWM8VCwgY2FuQmVHQ1RocmVhZD46OnNldChUKiBwdHIpCitpbmxpbmUgYXV0byBUaHJlYWRTcGVj aWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6c2V0KCkgLT4gRGF0YSoKIHsKICAgICBSRUxFQVNFX0FT U0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NUaHJl YWQoKSk7CiAgICAgQVNTRVJUKCFnZXQoKSk7Ci0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhtX2tl eSwgbmV3IERhdGEocHRyLCB0aGlzKSk7CisgICAgRGF0YSogZGF0YSA9IG5ldyBEYXRhKHRoaXMp OworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIGRhdGEpOworICAgIHJldHVybiBkYXRh OwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMjMyLDE4ICsyNDcsMTggQEAgaW5saW5lIFQq IFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERhdGEqIGRh dGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4oRmxzR2V0VmFsdWUoZmxzS2V5cygpW21faW5kZXhdKSk7 CiAgICAgaWYgKGRhdGEpCi0gICAgICAgIHJldHVybiBkYXRhLT52YWx1ZTsKLSAgICBSRUxFQVNF X0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NU aHJlYWQoKSk7CisgICAgICAgIHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwogICAgIHJl dHVybiBudWxscHRyOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNh bkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFk Pjo6c2V0KFQqIHB0cikKK2lubGluZSBhdXRvIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJl YWQ+OjpzZXQoKSAtPiBEYXRhKgogewogICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJlR0NUaHJlYWQg PT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKICAgICBBU1NFUlQo IWdldCgpKTsKLSAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEocHRyLCB0aGlzKTsKKyAgICBEYXRh KiBkYXRhID0gbmV3IERhdGEodGhpcyk7CiAgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW21faW5k ZXhdLCBkYXRhKTsKKyAgICByZXR1cm4gZGF0YTsKIH0KIAogI2Vsc2UKQEAgLTI2MSwxMyArMjc2 LDEyIEBAIGlubGluZSB2b2lkIFRIUkVBRF9TUEVDSUZJQ19DQUxMIFRocmVhZFNwZWNpZmljPFQs IGNhbkJlR0NUaHJlYWQ+OjpkZXN0cm95KHZvaWQqCiAgICAgcHRocmVhZF9zZXRzcGVjaWZpYyhk YXRhLT5vd25lci0+bV9rZXksIHB0cik7CiAjZW5kaWYKIAotICAgIGRhdGEtPnZhbHVlLT5+VCgp OwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKKyAgICBkYXRhLT5kZXN0cm95KCk7CiAKICNp ZiBVU0UoUFRIUkVBRFMpCi0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+bV9r ZXksIDApOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMoZGF0YS0+b3duZXItPm1fa2V5LCBudWxs cHRyKTsKICNlbGlmIE9TKFdJTkRPV1MpCi0gICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2RhdGEt Pm93bmVyLT5tX2luZGV4XSwgMCk7CisgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2RhdGEtPm93 bmVyLT5tX2luZGV4XSwgbnVsbHB0cik7CiAjZWxzZQogI2Vycm9yIFRocmVhZFNwZWNpZmljIGlz IG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4KICNlbmRpZgpAQCAtMjg1LDE0ICsy OTksMTQgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFk PgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpvcGVyYXRvciBUKigp CiB7CiAgICAgVCogcHRyID0gc3RhdGljX2Nhc3Q8VCo+KGdldCgpKTsKLSAgICBpZiAoIXB0cikg ewotICAgICAgICAvLyBTZXQgdXAgdGhyZWFkLXNwZWNpZmljIHZhbHVlJ3MgbWVtb3J5IHBvaW50 ZXIgYmVmb3JlIGludm9raW5nIGNvbnN0cnVjdG9yLCBpbiBjYXNlIGFueSBmdW5jdGlvbiBpdCBj YWxscwotICAgICAgICAvLyBuZWVkcyB0byBhY2Nlc3MgdGhlIHZhbHVlLCB0byBhdm9pZCByZWN1 cnNpb24uCi0gICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PFQqPihmYXN0WmVyb2VkTWFsbG9jKHNp emVvZihUKSkpOwotICAgICAgICBzZXQocHRyKTsKLSAgICAgICAgbmV3IChOb3ROdWxsLCBwdHIp IFQ7Ci0gICAgfQotICAgIHJldHVybiBwdHI7CisgICAgaWYgKHB0cikKKyAgICAgICAgcmV0dXJu IHB0cjsKKworICAgIC8vIFNldCB1cCB0aHJlYWQtc3BlY2lmaWMgdmFsdWUncyBtZW1vcnkgcG9p bnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0b3IsIGluIGNhc2UgYW55IGZ1bmN0aW9uIGl0 IGNhbGxzCisgICAgLy8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZvaWQgcmVjdXJz aW9uLgorICAgIERhdGEqIGRhdGEgPSBzZXQoKTsKKyAgICBkYXRhLT5jb25zdHJ1Y3QoKTsKKyAg ICByZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUg VCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgpAQCAtMzA3LDE5ICszMjEsOCBAQCBpbmxp bmUgVCYgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46Om9wZXJhdG9yKigpCiAgICAg cmV0dXJuICpvcGVyYXRvciBUKigpOwogfQogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi10ZW1wbGF0 ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBU aHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZShUKiBuZXdQdHIpCi17Ci0g ICAgQVNTRVJUKG5ld1B0cik7Ci0gICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEqPihw dGhyZWFkX2dldHNwZWNpZmljKG1fa2V5KSk7Ci0gICAgQVNTRVJUKGRhdGEpOwotICAgIGRhdGEt PnZhbHVlLT5+VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKLSAgICBkYXRhLT52YWx1 ZSA9IG5ld1B0cjsKLX0KLSNlbmRpZgotCiB9IC8vIG5hbWVzcGFjZSBXVEYKIAordXNpbmcgV1RG OjpUaHJlYWRTcGVjaWZpYzsKKwogI2VuZGlmIC8vIFdURl9UaHJlYWRTcGVjaWZpY19oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCmluZGV4IDc3MzgyOWQ1 ZTdiNGViMzNkN2JlODM4MDcxNmY5YTMzMzcyNmY0ZjguLmZhZTViNmU0MDk4MjU3Yzk4MDExODE0 MjE1OTdkZmU2MGRjMDgyNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Ro cmVhZEdsb2JhbERhdGEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEds b2JhbERhdGEuY3BwCkBAIC00MywxMSArNDMsNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK LVRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+KiBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0 aWNEYXRhOwotI2lmIFVTRShXRUJfVEhSRUFEKQotVGhyZWFkR2xvYmFsRGF0YSogVGhyZWFkR2xv YmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGE7Ci0jZW5kaWYKLQogVGhyZWFkR2xv YmFsRGF0YTo6VGhyZWFkR2xvYmFsRGF0YSgpCiAgICAgOiBtX2NhY2hlZFJlc291cmNlUmVxdWVz dEluaXRpYXRvcnMoc3RkOjptYWtlX3VuaXF1ZTxDYWNoZWRSZXNvdXJjZVJlcXVlc3RJbml0aWF0 b3JzPigpKQogICAgICwgbV9ldmVudE5hbWVzKEV2ZW50TmFtZXM6OmNyZWF0ZSgpKQpAQCAtNjYs NyArNjEsNiBAQCBUaHJlYWRHbG9iYWxEYXRhOjpUaHJlYWRHbG9iYWxEYXRhKCkKICAgICAvLyBw b2ludCB0byBjYWxsIG1ldGhvZHMgdGhhdCBpbnRlcm5hbGx5IHBlcmZvcm0gYSBvbmUtdGltZSBp bml0aWFsaXphdGlvbiB0aGF0IGlzIG5vdAogICAgIC8vIHRocmVhZHNhZmUuCiAgICAgVGhyZWFk OjpjdXJyZW50KCk7Ci0gICAgU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIH0KIAogVGhyZWFkR2xvYmFs RGF0YTo6flRocmVhZEdsb2JhbERhdGEoKQpAQCAtODcsMzQgKzgxLDUyIEBAIHZvaWQgVGhyZWFk R2xvYmFsRGF0YTo6ZGVzdHJveSgpCiB9CiAKICNpZiBVU0UoV0VCX1RIUkVBRCkKK3N0YXRpYyBU aHJlYWRTcGVjaWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFkR2xvYmFsRGF0YT4+KiBzdGF0aWNE YXRhIHsgbnVsbHB0ciB9Oworc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5UaHJl YWRTdGF0aWNEYXRhIHsgbnVsbHB0ciB9OworCiB2b2lkIFRocmVhZEdsb2JhbERhdGE6OnNldFdl YkNvcmVUaHJlYWREYXRhKCkKIHsKICAgICBBU1NFUlQoaXNXZWJUaHJlYWQoKSk7Ci0gICAgQVNT RVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkgIT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRo cmVhZFN0YXRpY0RhdGEpOworICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpICE9IHNoYXJl ZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKIAogICAgIC8vIFNldCBXZWJUaHJlYWQncyBUaHJlYWRH bG9iYWxEYXRhIG9iamVjdCB0byBiZSB0aGUgc2FtZSBhcyB0aGUgbWFpbiBVSSB0aHJlYWQuCi0g ICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YS0+cmVwbGFjZShUaHJlYWRHbG9iYWxEYXRh OjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgLy8gV2hpbGUgd2Ugc3RvcmUgdGhl IHNhbWUgcG9pbnRlciB0byBzdGQ6OnVuaXF1ZV9wdHIsIGl0IGlzIG9rIGJlY2F1c2UgdGhlIHdl YiB0aHJlYWQgbmV2ZXIgZmluaXNoZXMuCisgICAgKipzdGF0aWNEYXRhLnJlc2V0KHNoYXJlZE1h aW5UaHJlYWRTdGF0aWNEYXRhKTsKIAotICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpID09 IFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKKyAgICBBU1NF UlQoJnRocmVhZEdsb2JhbERhdGEoKSA9PSBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CiB9 Ci0jZW5kaWYKIAotVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpIAorVGhyZWFk R2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpCiB7Ci0jaWYgVVNFKFdFQl9USFJFQUQpCi0g ICAgaWYgKFVOTElLRUxZKCFUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhKSkgewotICAgICAg ICBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhID0gbmV3IFRocmVhZFNwZWNpZmljPFRocmVh ZEdsb2JhbERhdGE+OworICAgIGlmIChVTkxJS0VMWSghc3RhdGljRGF0YSkpIHsKKyAgICAgICAg c3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFkR2xv YmFsRGF0YT4+OworICAgICAgICBhdXRvJiByZXN1bHQgPSAqKnN0YXRpY0RhdGE7CisgICAgICAg IEFTU0VSVCghcmVzdWx0KTsKKyAgICAgICAgcmVzdWx0LnJlc2V0KG5ldyBUaHJlYWRHbG9iYWxE YXRhKCkpOwogICAgICAgICAvLyBXZWJUaHJlYWQgYW5kIG1haW4gVUkgdGhyZWFkIG5lZWQgdG8g c2hhcmUgdGhlIHNhbWUgb2JqZWN0LiBTYXZlIGl0IGluIGEgc3RhdGljCiAgICAgICAgIC8vIGhl cmUsIHRoZSBXZWJUaHJlYWQgd2lsbCBwaWNrIGl0IHVwIGluIHNldFdlYkNvcmVUaHJlYWREYXRh KCkuCiAgICAgICAgIGlmIChwdGhyZWFkX21haW5fbnAoKSkKLSAgICAgICAgICAgIFRocmVhZEds b2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0gKlRocmVhZEdsb2JhbERhdGE6 OnN0YXRpY0RhdGE7CisgICAgICAgICAgICBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSA9IHJl c3VsdC5nZXQoKTsKKyAgICAgICAgcmV0dXJuICpyZXN1bHQ7CiAgICAgfQotICAgIHJldHVybiAq KlRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7CisKKyAgICBhdXRvJiByZXN1bHQgPSAqKnN0 YXRpY0RhdGE7CisgICAgaWYgKCFyZXN1bHQpCisgICAgICAgIHJlc3VsdC5yZXNldChuZXcgVGhy ZWFkR2xvYmFsRGF0YSgpKTsKKyAgICByZXR1cm4gKnJlc3VsdDsKK30KKwogI2Vsc2UKLSAgICBp ZiAoIVRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGEpCi0gICAgICAgIFRocmVhZEdsb2JhbERh dGE6OnN0YXRpY0RhdGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47Ci0g ICAgcmV0dXJuICoqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKLSNlbmRpZgorCitzdGF0 aWMgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIHN0YXRpY0RhdGEgeyBudWxscHRy IH07CisKK1RocmVhZEdsb2JhbERhdGEmIHRocmVhZEdsb2JhbERhdGEoKQoreworICAgIGlmIChV TkxJS0VMWSghc3RhdGljRGF0YSkpCisgICAgICAgIHN0YXRpY0RhdGEgPSBuZXcgVGhyZWFkU3Bl Y2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47CisgICAgcmV0dXJuICoqc3RhdGljRGF0YTsKIH0KIAor I2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1RocmVhZEdsb2JhbERhdGEuaAppbmRleCA1OGY3YzA3NDAyNTQwODg5YjNjZmQ0NDE5YjkwODVj ZjU3OWNjZjIxLi5lOWNmMTRjOTJkYjIyMjFjYTg1NjhkZTMzOWY4ZGY3MGRkZjc4ZDEzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oCkBAIC0yOSw5ICsyOSw2 IEBACiAKICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKLSNpbmNsdWRlIDx3dGYv VGhyZWFkU3BlY2lmaWMuaD4KLXVzaW5nIFdURjo6VGhyZWFkU3BlY2lmaWM7Ci0KIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogICAgIGNsYXNzIFF1YWxpZmllZE5hbWVDYWNoZTsKQEAgLTQzLDcgKzQw LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIHN0cnVjdCBURUNDb252ZXJ0ZXJXcmFwcGVy OwogCiAgICAgY2xhc3MgVGhyZWFkR2xvYmFsRGF0YSB7Ci0gICAgICAgIFdURl9NQUtFX05PTkNP UFlBQkxFKFRocmVhZEdsb2JhbERhdGEpOworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFRocmVh ZEdsb2JhbERhdGEpOworICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogICAgIHB1YmxpYzoK ICAgICAgICAgV0VCQ09SRV9FWFBPUlQgVGhyZWFkR2xvYmFsRGF0YSgpOwogICAgICAgICBXRUJD T1JFX0VYUE9SVCB+VGhyZWFkR2xvYmFsRGF0YSgpOwpAQCAtODAsMTAgKzc4LDYgQEAgbmFtZXNw YWNlIFdlYkNvcmUgewogICAgICAgICBzdGQ6OnVuaXF1ZV9wdHI8VEVDQ29udmVydGVyV3JhcHBl cj4gbV9jYWNoZWRDb252ZXJ0ZXJURUM7CiAjZW5kaWYKIAotICAgICAgICBXRUJDT1JFX0VYUE9S VCBzdGF0aWMgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIHN0YXRpY0RhdGE7Ci0j aWYgVVNFKFdFQl9USFJFQUQpCi0gICAgICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBUaHJlYWRH bG9iYWxEYXRhKiBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YTsKLSNlbmRpZgogICAgICAgICBX RUJDT1JFX0VYUE9SVCBmcmllbmQgVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgp OwogICAgIH07CiAK 317252 2017-08-04 10:02:50 -0700 2017-08-09 19:25:34 -0700 Patch bug-175187-20170805020249.patch text/plain 14549 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwMjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx ZGY3MWQ0ZWY4MDFkZDZjZTFiOGM0NWViOGE1NWFjYzY3YzE3MTNlLi5jYjIxODYyYzA3OTYxYTFj NWRiZmQyMWVmN2JhNzY4YTdmMzAwZjExIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNy0wOC0wNCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVj ZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHJ1bnRpbWUvSWRlbnRpZmllci5jcHA6CisKIDIwMTctMDgtMDQg IE9sZWtzYW5kciBTa2FjaGtvdiAgPGdza2FjaGtvdkBnbWFpbC5jb20+CiAKICAgICAgICAgW0Vz TmV4dF0gQXN5bmMgaXRlcmF0aW9uIC0gQWRkIGZlYXR1cmUgZmxhZwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCBiMmE3YjM2ODRm NTM3ODk5NjM4OTJkNTRjZDM2OWYwNThiMjgyNjcyLi43ZWVjN2U5NGUyNWYxM2JhNThjMjhmMmUw NDRjNDcxMjM2YjFiZDNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDE3LTA4LTA0ICBZdXN1a2Ug U3V6dWtpICA8dXRhdGFuZS50ZWFAZ21haWwuY29tPgorCisgICAgICAgIFtXVEZdIFRocmVhZFNw ZWNpZmljIHNob3VsZCBub3QgaW50cm9kdWNlIGFkZGl0aW9uYWwgaW5kaXJlY3Rpb24KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NTE4NworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRocmVhZFNwZWNpZmlj IHNldHMgRGF0YSogdG8gdGhlIFRMUy4gQW5kIERhdGEgaG9sZHMgVCosIHdoaWNoCisgICAgICAg IGlzIGZhc3QgYWxsb2NhdGVkIGFjdHVhbCBkYXRhLiBCdXQgaWRlYWxseSwgd2Ugc2hvdWxkIHN0 b3JlIFQKKyAgICAgICAgaW5zdGFuY2UgZGlyZWN0bHkgaW4gRGF0YSBpbnN0ZWFkIG9mIGludHJv ZHVjaW5nIGFuIGFkZGl0aW9uYWwKKyAgICAgICAgaW5kaXJlY3Rpb24uCisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHN0b3JhZ2UgdG8gRGF0YSBhbmQgaW5pdGlhbGl6ZXMgVCBpbiBEYXRhLgor ICAgICAgICBBbmQgd2UgZHJvcCBUaHJlYWRTcGVjaWZpYzo6cmVwbGFjZSBzdXBwb3J0LCB3aGlj aCBpcyBvbmx5IHVzZWQKKyAgICAgICAgYnkgV2ViIHRocmVhZC4gV2ViIHRocmVhZCBzaG91bGQg dXNlIFRocmVhZFNwZWNpZmljPHN0ZDo6dW5pcXVlX3B0cjxUPj4gaW5zdGVhZC4KKworICAgICAg ICAqIHd0Zi9UaHJlYWRTcGVjaWZpYy5oOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6 RGF0YTo6Y29uc3RydWN0KToKKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWM6OkRhdGE6OmRl c3Ryb3kpOgorICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6RGF0YSk6CisgICAg ICAgIFdlIG1ha2UgaXQgZmFzdCBhbGxvY2F0ZWQgc2luY2Ugd2UgcHJldmlvdXNseSBhbGxvY2F0 ZWQgVGhyZWFkU3BlY2lmaWMgVCBkYXRhIGJ5IGZhc3RNYWxsb2MuCisKKyAgICAgICAgKFdURjo6 VGhyZWFkU3BlY2lmaWM6OkRhdGE6OnN0b3JhZ2VQb2ludGVyIGNvbnN0KToKKyAgICAgICAgKFdU Rjo6Y2FuQmVHQ1RocmVhZD46OmdldCk6CisgICAgICAgIFdlIGFsc28gZHJvcCBSRUxFQVNFX0FT U0VSVCBmcm9tIDo6Z2V0KCkuIFdlIGFscmVhZHkgaW5zZXJ0ZWQgdGhpcyBhc3NlcnQgdG8gc2V0 KCksCisgICAgICAgIHNvIHdoZW4gY3JlYXRpbmcgdGhlIG1lbWJlciB0byB0aGlzIFRMUywgd2Ug ZXhlY3V0ZSB0aGlzIHJlbGVhc2UgYXNzZXJ0LiBTbyBpdCBpcworICAgICAgICBub3QgbmVjZXNz YXJ5IHRvIGV4ZWN1dGUgdGhpcyBhc3NlcnRpb24gZXZlcnkgdGltZSB3ZSBnZXQgZGF0YSBmcm9t IHRoaXMgVExTLgorCisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpzZXQpOgorICAgICAg ICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6ZGVzdHJveSk6CisgICAgICAgIChXVEY6OlQpOgorICAg ICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZSk6IERlbGV0ZWQuCisKIDIwMTctMDgt MDMgIEJyaWFuIEJ1cmcgIDxiYnVyZ0BhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIEVOQUJM RShXRUJfU09DS0VUKSBndWFyZHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2NDQ3NDlmNGE5NGFiMzdmNzkxYzYx YzVlYmFhMzhiMDNhY2FmMDlmLi43Nzc1NGQ4YjdlMGRmODVkYzg5MGRhNjA3OWUyZDdhNjg2NDg1 MjgzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTctMDgtMDQgIFl1c3VrZSBTdXp1 a2kgIDx1dGF0YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFkU3BlY2lm aWMgc2hvdWxkIG5vdCBpbnRyb2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2UgZHJvcCBUaHJlYWRTcGVj aWZpYzo6cmVwbGFjZSBmZWF0dXJlIHdoaWNoIGlzIG9ubHkgdXNlZCBieQorICAgICAgICBXZWIg dGhyZWFkLiBJbnN0ZWFkLCB3ZSB1c2UgVGhyZWFkU3BlY2lmaWM8c3RkOjp1bmlxdWVfcHRyPFQ+ PiBoZXJlLgorCisgICAgICAgIFdoaWxlIHRoaXMgc3RkOjp1bmlxdWVfcHRyPFQ+IHNoYXJlcyBv bmUgaW5zdGFuY2UgYmV0d2VlbiBtYWluIHRocmVhZAorICAgICAgICBhbmQgd2ViIHRocmVhZCwg dGhpcyBpcyB0aGUgc2FtZSB0byB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbi4gSXQgaXMKKyAg ICAgICAgc2FmZSBiZWNhdXNlIHRoZSB3ZWIgdGhyZWFkIG5ldmVyIGZpbmlzaGVzLgorCisgICAg ICAgIEFuZCBmb3Igbm9uLXdlYiB0aHJlYWQgaW1wbGVtZW50YXRpb24sIHdlIGp1c3QgdXNlIFRo cmVhZFNwZWNpZmljPFQ+LAorICAgICAgICBzaW5jZSBpdCBpcyB0aGUgbW9zdCBlZmZpY2llbnQu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OlRocmVhZEdsb2JhbERhdGE6OlRocmVhZEdsb2JhbERhdGEpOgorICAgICAgICAoV2Vi Q29yZTo6VGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29yZVRocmVhZERhdGEpOgorICAgICAgICAo V2ViQ29yZTo6dGhyZWFkR2xvYmFsRGF0YSk6CisgICAgICAgIFdlIGFsc28gZHJvcCBTdHJpbmdJ bXBsOjplbXB0eSgpIGNhbGwgc2luY2UgaXQgaXMgbm90IG5lY2Vzc2FyeSBub3c6CisgICAgICAg IFN0cmluZ0ltcGw6OmVtcHR5IGRhdGEgaXMgc3RhdGljYWxseSBpbml0aWFsaXplZCBieSB1c2lu ZyBjb25zdGV4cHIuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmg6Cisg ICAgICAgIFdlIG1ha2UgaXQgRkFTVF9BTExPQ0FURUQgc2luY2UgaXQgaXMgcHJldmlvdXNseSBh bGxvY2F0ZWQgYnkgZmFzdCBtYWxsb2MKKyAgICAgICAgaW4gVGhyZWFkU3BlY2lmaWMuCisKIDIw MTctMDgtMDQgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEuY29tPgogCiAgICAgICAg IFtFTUVdIFB1c2ggQ0RNRmFjdG9yeSBpbnRvIHRoZSBwbGF0Zm9ybSBsYXllcgpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVudGlmaWVyLmNwcAppbmRleCBkNTUyZDBiMWY2Mjg3 MTVhMjYzNmFiNzczN2VkZmM2MTk3MzRjMGM4Li5mODRiNjllNGQzZDNmNWRmOGI2NmZmNzY4ODFl ZmU0OTVmZGIyNDJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9J ZGVudGlmaWVyLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVudGlm aWVyLmNwcApAQCAtMzMsOCArMzMsNiBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0L0FTQ0lJRmFzdFBh dGguaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKLXVzaW5nIFdURjo6VGhy ZWFkU3BlY2lmaWM7Ci0KIG5hbWVzcGFjZSBKU0MgewogCiBSZWY8U3RyaW5nSW1wbD4gSWRlbnRp Zmllcjo6YWRkKFZNKiB2bSwgY29uc3QgY2hhciogYykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYv d3RmL1RocmVhZFNwZWNpZmljLmggYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCmlu ZGV4IDFmOTgzNjNlOTM0MTM0YzQxNDMzMzZjOGI4MmY4YWZjNDM4MTVlMjMuLjUyMzE2MWI0MzUy OTU5OTA3ZWVlZWM2NGYxNDQyOTAyOGYzOTkxNzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3Rm L1RocmVhZFNwZWNpZmljLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lmaWMuaApA QCAtODIsMTAgKzgyLDYgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5C ZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNsYXNzIFQKICAgICBvcGVyYXRvciBU KigpOwogICAgIFQmIG9wZXJhdG9yKigpOwogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi0gICAgdm9p ZCByZXBsYWNlKFQqKTsKLSNlbmRpZgotCiBwcml2YXRlOgogICAgIC8vIE5vdCBpbXBsZW1lbnRl ZC4gSXQncyB0ZWNobmljYWxseSBwb3NzaWJsZSB0byBkZXN0cm95IGEgdGhyZWFkIHNwZWNpZmlj IGtleSwgYnV0IG9uZSB3b3VsZCBuZWVkCiAgICAgLy8gdG8gbWFrZSBzdXJlIHRoYXQgYWxsIHZh bHVlcyBoYXZlIGJlZW4gZGVzdHJveWVkIGFscmVhZHkgKHVzdWFsbHksIHRoYXQgYWxsIHRocmVh ZHMgdGhhdCB1c2VkIGl0CkBAIC05MywxOSArODksMzcgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwg Q2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNsYXNz IFQKICAgICAvLyBhIGRlc3RydWN0b3IgZGVmaW5lZCBjYW4gYmUgY29uZnVzaW5nLCBnaXZlbiB0 aGF0IGl0IGhhcyBzdWNoIHN0cm9uZyBwcmUtcmVxdWlzaXRlcyB0byB3b3JrIGNvcnJlY3RseS4K ICAgICB+VGhyZWFkU3BlY2lmaWMoKTsKIAotICAgIFQqIGdldCgpOwotICAgIHZvaWQgc2V0KFQq KTsKLSAgICB2b2lkIHN0YXRpYyBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBkZXN0cm95KHZvaWQqIHB0 cik7Ci0KICAgICBzdHJ1Y3QgRGF0YSB7CiAgICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKERh dGEpOworICAgICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKICAgICBwdWJsaWM6Ci0gICAg ICAgIERhdGEoVCogdmFsdWUsIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25l cikgOiB2YWx1ZSh2YWx1ZSksIG93bmVyKG93bmVyKSB7fQorICAgICAgICB1c2luZyBQb2ludGVy VHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX2NvbnN0PFQ+Ojp0eXBlKjsKKworICAgICAgICB2 b2lkIGNvbnN0cnVjdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIG5ldyAoTm90TnVsbCwgc3Rv cmFnZVBvaW50ZXIoKSkgVDsKKyAgICAgICAgfQogCi0gICAgICAgIFQqIHZhbHVlOworICAgICAg ICB2b2lkIGRlc3Ryb3koKQorICAgICAgICB7CisgICAgICAgICAgICBzdG9yYWdlUG9pbnRlcigp LT5+VCgpOworICAgICAgICB9CisKKyAgICAgICAgRGF0YShUaHJlYWRTcGVjaWZpYzxULCBjYW5C ZUdDVGhyZWFkPiogb3duZXIpCisgICAgICAgICAgICA6IG93bmVyKG93bmVyKQorICAgICAgICB7 CisgICAgICAgIH0KKworICAgICAgICBQb2ludGVyVHlwZSBzdG9yYWdlUG9pbnRlcigpIGNvbnN0 IHsgcmV0dXJuIGNvbnN0X2Nhc3Q8UG9pbnRlclR5cGU+KHJlaW50ZXJwcmV0X2Nhc3Q8Y29uc3Qg VCo+KCZtX3N0b3JhZ2UpKTsgfQorCisgICAgICAgIHR5cGVuYW1lIHN0ZDo6YWxpZ25lZF9zdG9y YWdlPHNpemVvZihUKSwgc3RkOjphbGlnbm1lbnRfb2Y8VD46OnZhbHVlPjo6dHlwZSBtX3N0b3Jh Z2U7CiAgICAgICAgIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+KiBvd25lcjsKICAg ICB9OwogCisgICAgVCogZ2V0KCk7CisgICAgRGF0YSogc2V0KCk7CisgICAgdm9pZCBzdGF0aWMg VEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJveSh2b2lkKiBwdHIpOworCiAjaWYgVVNFKFBUSFJF QURTKQogICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMTU2 LDE3ICsxNzAsMTggQEAgaW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+ OjpnZXQoKQogewogICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRocmVhZF9n ZXRzcGVjaWZpYyhtX2tleSkpOwogICAgIGlmIChkYXRhKQotICAgICAgICByZXR1cm4gZGF0YS0+ dmFsdWU7Ci0gICAgUkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhyZWFk OjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFkKCkpOworICAgICAgICByZXR1cm4gZGF0YS0+c3RvcmFn ZVBvaW50ZXIoKTsKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUg VCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lm aWM8VCwgY2FuQmVHQ1RocmVhZD46OnNldChUKiBwdHIpCitpbmxpbmUgYXV0byBUaHJlYWRTcGVj aWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6c2V0KCkgLT4gRGF0YSoKIHsKICAgICBSRUxFQVNFX0FT U0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NUaHJl YWQoKSk7CiAgICAgQVNTRVJUKCFnZXQoKSk7Ci0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhtX2tl eSwgbmV3IERhdGEocHRyLCB0aGlzKSk7CisgICAgRGF0YSogZGF0YSA9IG5ldyBEYXRhKHRoaXMp OworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIGRhdGEpOworICAgIHJldHVybiBkYXRh OwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMjMyLDE4ICsyNDcsMTggQEAgaW5saW5lIFQq IFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERhdGEqIGRh dGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4oRmxzR2V0VmFsdWUoZmxzS2V5cygpW21faW5kZXhdKSk7 CiAgICAgaWYgKGRhdGEpCi0gICAgICAgIHJldHVybiBkYXRhLT52YWx1ZTsKLSAgICBSRUxFQVNF X0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NU aHJlYWQoKSk7CisgICAgICAgIHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwogICAgIHJl dHVybiBudWxscHRyOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNh bkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFk Pjo6c2V0KFQqIHB0cikKK2lubGluZSBhdXRvIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJl YWQ+OjpzZXQoKSAtPiBEYXRhKgogewogICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJlR0NUaHJlYWQg PT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKICAgICBBU1NFUlQo IWdldCgpKTsKLSAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEocHRyLCB0aGlzKTsKKyAgICBEYXRh KiBkYXRhID0gbmV3IERhdGEodGhpcyk7CiAgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW21faW5k ZXhdLCBkYXRhKTsKKyAgICByZXR1cm4gZGF0YTsKIH0KIAogI2Vsc2UKQEAgLTI2MSwxMyArMjc2 LDEyIEBAIGlubGluZSB2b2lkIFRIUkVBRF9TUEVDSUZJQ19DQUxMIFRocmVhZFNwZWNpZmljPFQs IGNhbkJlR0NUaHJlYWQ+OjpkZXN0cm95KHZvaWQqCiAgICAgcHRocmVhZF9zZXRzcGVjaWZpYyhk YXRhLT5vd25lci0+bV9rZXksIHB0cik7CiAjZW5kaWYKIAotICAgIGRhdGEtPnZhbHVlLT5+VCgp OwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKKyAgICBkYXRhLT5kZXN0cm95KCk7CiAKICNp ZiBVU0UoUFRIUkVBRFMpCi0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+bV9r ZXksIDApOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMoZGF0YS0+b3duZXItPm1fa2V5LCBudWxs cHRyKTsKICNlbGlmIE9TKFdJTkRPV1MpCi0gICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2RhdGEt Pm93bmVyLT5tX2luZGV4XSwgMCk7CisgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygpW2RhdGEtPm93 bmVyLT5tX2luZGV4XSwgbnVsbHB0cik7CiAjZWxzZQogI2Vycm9yIFRocmVhZFNwZWNpZmljIGlz IG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4KICNlbmRpZgpAQCAtMjg1LDE0ICsy OTksMTQgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFk PgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpvcGVyYXRvciBUKigp CiB7CiAgICAgVCogcHRyID0gc3RhdGljX2Nhc3Q8VCo+KGdldCgpKTsKLSAgICBpZiAoIXB0cikg ewotICAgICAgICAvLyBTZXQgdXAgdGhyZWFkLXNwZWNpZmljIHZhbHVlJ3MgbWVtb3J5IHBvaW50 ZXIgYmVmb3JlIGludm9raW5nIGNvbnN0cnVjdG9yLCBpbiBjYXNlIGFueSBmdW5jdGlvbiBpdCBj YWxscwotICAgICAgICAvLyBuZWVkcyB0byBhY2Nlc3MgdGhlIHZhbHVlLCB0byBhdm9pZCByZWN1 cnNpb24uCi0gICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PFQqPihmYXN0WmVyb2VkTWFsbG9jKHNp emVvZihUKSkpOwotICAgICAgICBzZXQocHRyKTsKLSAgICAgICAgbmV3IChOb3ROdWxsLCBwdHIp IFQ7Ci0gICAgfQotICAgIHJldHVybiBwdHI7CisgICAgaWYgKHB0cikKKyAgICAgICAgcmV0dXJu IHB0cjsKKworICAgIC8vIFNldCB1cCB0aHJlYWQtc3BlY2lmaWMgdmFsdWUncyBtZW1vcnkgcG9p bnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0b3IsIGluIGNhc2UgYW55IGZ1bmN0aW9uIGl0 IGNhbGxzCisgICAgLy8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZvaWQgcmVjdXJz aW9uLgorICAgIERhdGEqIGRhdGEgPSBzZXQoKTsKKyAgICBkYXRhLT5jb25zdHJ1Y3QoKTsKKyAg ICByZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUg VCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgpAQCAtMzA3LDE5ICszMjEsOCBAQCBpbmxp bmUgVCYgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46Om9wZXJhdG9yKigpCiAgICAg cmV0dXJuICpvcGVyYXRvciBUKigpOwogfQogCi0jaWYgVVNFKFdFQl9USFJFQUQpCi10ZW1wbGF0 ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBU aHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6cmVwbGFjZShUKiBuZXdQdHIpCi17Ci0g ICAgQVNTRVJUKG5ld1B0cik7Ci0gICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEqPihw dGhyZWFkX2dldHNwZWNpZmljKG1fa2V5KSk7Ci0gICAgQVNTRVJUKGRhdGEpOwotICAgIGRhdGEt PnZhbHVlLT5+VCgpOwotICAgIGZhc3RGcmVlKGRhdGEtPnZhbHVlKTsKLSAgICBkYXRhLT52YWx1 ZSA9IG5ld1B0cjsKLX0KLSNlbmRpZgotCiB9IC8vIG5hbWVzcGFjZSBXVEYKIAordXNpbmcgV1RG OjpUaHJlYWRTcGVjaWZpYzsKKwogI2VuZGlmIC8vIFdURl9UaHJlYWRTcGVjaWZpY19oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCmluZGV4IDc3MzgyOWQ1 ZTdiNGViMzNkN2JlODM4MDcxNmY5YTMzMzcyNmY0ZjguLjMwMjk4NzZiZGZhNDI5ZThiMGM4MGFj ZmQzNzE5OGEwYjU0NTYwZWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Ro cmVhZEdsb2JhbERhdGEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEds b2JhbERhdGEuY3BwCkBAIC00MywxMSArNDMsNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK LVRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+KiBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0 aWNEYXRhOwotI2lmIFVTRShXRUJfVEhSRUFEKQotVGhyZWFkR2xvYmFsRGF0YSogVGhyZWFkR2xv YmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGE7Ci0jZW5kaWYKLQogVGhyZWFkR2xv YmFsRGF0YTo6VGhyZWFkR2xvYmFsRGF0YSgpCiAgICAgOiBtX2NhY2hlZFJlc291cmNlUmVxdWVz dEluaXRpYXRvcnMoc3RkOjptYWtlX3VuaXF1ZTxDYWNoZWRSZXNvdXJjZVJlcXVlc3RJbml0aWF0 b3JzPigpKQogICAgICwgbV9ldmVudE5hbWVzKEV2ZW50TmFtZXM6OmNyZWF0ZSgpKQpAQCAtNjYs NyArNjEsNiBAQCBUaHJlYWRHbG9iYWxEYXRhOjpUaHJlYWRHbG9iYWxEYXRhKCkKICAgICAvLyBw b2ludCB0byBjYWxsIG1ldGhvZHMgdGhhdCBpbnRlcm5hbGx5IHBlcmZvcm0gYSBvbmUtdGltZSBp bml0aWFsaXphdGlvbiB0aGF0IGlzIG5vdAogICAgIC8vIHRocmVhZHNhZmUuCiAgICAgVGhyZWFk OjpjdXJyZW50KCk7Ci0gICAgU3RyaW5nSW1wbDo6ZW1wdHkoKTsKIH0KIAogVGhyZWFkR2xvYmFs RGF0YTo6flRocmVhZEdsb2JhbERhdGEoKQpAQCAtODcsMzQgKzgxLDUyIEBAIHZvaWQgVGhyZWFk R2xvYmFsRGF0YTo6ZGVzdHJveSgpCiB9CiAKICNpZiBVU0UoV0VCX1RIUkVBRCkKK3N0YXRpYyBU aHJlYWRTcGVjaWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VGhyZWFkR2xvYmFsRGF0YT4+KiBzdGF0aWNE YXRhIHsgbnVsbHB0ciB9Oworc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5UaHJl YWRTdGF0aWNEYXRhIHsgbnVsbHB0ciB9OworCiB2b2lkIFRocmVhZEdsb2JhbERhdGE6OnNldFdl YkNvcmVUaHJlYWREYXRhKCkKIHsKICAgICBBU1NFUlQoaXNXZWJUaHJlYWQoKSk7Ci0gICAgQVNT RVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkgIT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRo cmVhZFN0YXRpY0RhdGEpOworICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpICE9IHNoYXJl ZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKIAogICAgIC8vIFNldCBXZWJUaHJlYWQncyBUaHJlYWRH bG9iYWxEYXRhIG9iamVjdCB0byBiZSB0aGUgc2FtZSBhcyB0aGUgbWFpbiBVSSB0aHJlYWQuCi0g ICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YS0+cmVwbGFjZShUaHJlYWRHbG9iYWxEYXRh OjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgLy8gV2hpbGUgd2Ugc3RvcmUgdGhl IHNhbWUgcG9pbnRlciB0byBzdGQ6OnVuaXF1ZV9wdHIsIGl0IGlzIG9rIGJlY2F1c2UgdGhlIHdl YiB0aHJlYWQgbmV2ZXIgZmluaXNoZXMuCisgICAgKCoqc3RhdGljRGF0YSkucmVzZXQoc2hhcmVk TWFpblRocmVhZFN0YXRpY0RhdGEpOwogCi0gICAgQVNTRVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkg PT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEpOworICAgIEFT U0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpID09IHNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsK IH0KLSNlbmRpZgogCi1UaHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCkgCitUaHJl YWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCkKIHsKLSNpZiBVU0UoV0VCX1RIUkVBRCkK LSAgICBpZiAoVU5MSUtFTFkoIVRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGEpKSB7Ci0gICAg ICAgIFRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhy ZWFkR2xvYmFsRGF0YT47CisgICAgaWYgKFVOTElLRUxZKCFzdGF0aWNEYXRhKSkgeworICAgICAg ICBzdGF0aWNEYXRhID0gbmV3IFRocmVhZFNwZWNpZmljPHN0ZDo6dW5pcXVlX3B0cjxUaHJlYWRH bG9iYWxEYXRhPj47CisgICAgICAgIGF1dG8mIHJlc3VsdCA9ICoqc3RhdGljRGF0YTsKKyAgICAg ICAgQVNTRVJUKCFyZXN1bHQpOworICAgICAgICByZXN1bHQucmVzZXQobmV3IFRocmVhZEdsb2Jh bERhdGEoKSk7CiAgICAgICAgIC8vIFdlYlRocmVhZCBhbmQgbWFpbiBVSSB0aHJlYWQgbmVlZCB0 byBzaGFyZSB0aGUgc2FtZSBvYmplY3QuIFNhdmUgaXQgaW4gYSBzdGF0aWMKICAgICAgICAgLy8g aGVyZSwgdGhlIFdlYlRocmVhZCB3aWxsIHBpY2sgaXQgdXAgaW4gc2V0V2ViQ29yZVRocmVhZERh dGEoKS4KICAgICAgICAgaWYgKHB0aHJlYWRfbWFpbl9ucCgpKQotICAgICAgICAgICAgVGhyZWFk R2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEgPSAqVGhyZWFkR2xvYmFsRGF0 YTo6c3RhdGljRGF0YTsKKyAgICAgICAgICAgIHNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0g cmVzdWx0LmdldCgpOworICAgICAgICByZXR1cm4gKnJlc3VsdDsKICAgICB9Ci0gICAgcmV0dXJu ICoqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKKworICAgIGF1dG8mIHJlc3VsdCA9ICoq c3RhdGljRGF0YTsKKyAgICBpZiAoIXJlc3VsdCkKKyAgICAgICAgcmVzdWx0LnJlc2V0KG5ldyBU aHJlYWRHbG9iYWxEYXRhKCkpOworICAgIHJldHVybiAqcmVzdWx0OworfQorCiAjZWxzZQotICAg IGlmICghVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSkKLSAgICAgICAgVGhyZWFkR2xvYmFs RGF0YTo6c3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsK LSAgICByZXR1cm4gKipUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhOwotI2VuZGlmCisKK3N0 YXRpYyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPiogc3RhdGljRGF0YSB7IG51bGxw dHIgfTsKKworVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFkR2xvYmFsRGF0YSgpCit7CisgICAgaWYg KFVOTElLRUxZKCFzdGF0aWNEYXRhKSkKKyAgICAgICAgc3RhdGljRGF0YSA9IG5ldyBUaHJlYWRT cGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsKKyAgICByZXR1cm4gKipzdGF0aWNEYXRhOwogfQog CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vVGhyZWFkR2xvYmFsRGF0YS5oCmluZGV4IDU4ZjdjMDc0MDI1NDA4ODliM2NmZDQ0MTliOTA4 NWNmNTc5Y2NmMjEuLmU5Y2YxNGM5MmRiMjIyMWNhODU2OGRlMzM5ZjhkZjcwZGRmNzhkMTMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmgKQEAgLTI5LDkgKzI5 LDYgQEAKIAogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0hhc2guaD4KIAotI2luY2x1ZGUgPHd0 Zi9UaHJlYWRTcGVjaWZpYy5oPgotdXNpbmcgV1RGOjpUaHJlYWRTcGVjaWZpYzsKLQogbmFtZXNw YWNlIFdlYkNvcmUgewogCiAgICAgY2xhc3MgUXVhbGlmaWVkTmFtZUNhY2hlOwpAQCAtNDMsNyAr NDAsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgc3RydWN0IFRFQ0NvbnZlcnRlcldyYXBw ZXI7CiAKICAgICBjbGFzcyBUaHJlYWRHbG9iYWxEYXRhIHsKLSAgICAgICAgV1RGX01BS0VfTk9O Q09QWUFCTEUoVGhyZWFkR2xvYmFsRGF0YSk7CisgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoVGhy ZWFkR2xvYmFsRGF0YSk7CisgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiAgICAgcHVibGlj OgogICAgICAgICBXRUJDT1JFX0VYUE9SVCBUaHJlYWRHbG9iYWxEYXRhKCk7CiAgICAgICAgIFdF QkNPUkVfRVhQT1JUIH5UaHJlYWRHbG9iYWxEYXRhKCk7CkBAIC04MCwxMCArNzgsNiBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHN0ZDo6dW5pcXVlX3B0cjxURUNDb252ZXJ0ZXJXcmFw cGVyPiBtX2NhY2hlZENvbnZlcnRlclRFQzsKICNlbmRpZgogCi0gICAgICAgIFdFQkNPUkVfRVhQ T1JUIHN0YXRpYyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPiogc3RhdGljRGF0YTsK LSNpZiBVU0UoV0VCX1RIUkVBRCkKLSAgICAgICAgV0VCQ09SRV9FWFBPUlQgc3RhdGljIFRocmVh ZEdsb2JhbERhdGEqIHNoYXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhOwotI2VuZGlmCiAgICAgICAg IFdFQkNPUkVfRVhQT1JUIGZyaWVuZCBUaHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRh KCk7CiAgICAgfTsKIAo= 317775 2017-08-09 19:25:36 -0700 2017-08-10 14:00:50 -0700 Patch bug-175187-20170810112535.patch text/plain 14912 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwNTAzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAw Mjc4MWIyNGRmMTQ4ZDg0ZWIyMTQzMGVmY2I3ZmY4NzhhZDU5OTMwLi5hZjg0NjhjNjY5MDgxNzZk NDMxM2Y1NWRhNWM1YzUzNGYyNzVkYmI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNy0wOC0wOSAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVj ZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHJ1bnRpbWUvSWRlbnRpZmllci5jcHA6CisKIDIwMTctMDgtMDkg IENhaW8gTGltYSAgPHRpY2Fpb2xpbWFAZ21haWwuY29tPgogCiAgICAgICAgIFtKU0NdIENyZWF0 ZSBKU1NldCBjb25zdHJ1Y3RvciB0aGF0IGFjY2VwdHMgaXQncyBzaXplIGFzIHBhcmFtZXRlcgpk aWZmIC0tZ2l0IGEvU291cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwpp bmRleCBlNjc2NzI5MDhlZDhlMWRmNTFkNmE0OGVlMzAwZWE0YzQ0NjQ5YWQ4Li5lOTFmNGNhY2Y0 ZGY0MjhiNjU4MDM1YTg3ZGVhNDM0M2NlNDgwYTc0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0No YW5nZUxvZworKysgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE3 LTA4LTA5ICBZdXN1a2UgU3V6dWtpICA8dXRhdGFuZS50ZWFAZ21haWwuY29tPgorCisgICAgICAg IFtXVEZdIFRocmVhZFNwZWNpZmljIHNob3VsZCBub3QgaW50cm9kdWNlIGFkZGl0aW9uYWwgaW5k aXJlY3Rpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE3NTE4NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRocmVhZFNwZWNpZmljIHNldHMgRGF0YSogdG8gdGhlIFRMUy4gQW5kIERhdGEgaG9sZHMgVCos IHdoaWNoCisgICAgICAgIGlzIGZhc3QgYWxsb2NhdGVkIGFjdHVhbCBkYXRhLiBCdXQgaWRlYWxs eSwgd2Ugc2hvdWxkIHN0b3JlIFQKKyAgICAgICAgaW5zdGFuY2UgZGlyZWN0bHkgaW4gRGF0YSBp bnN0ZWFkIG9mIGludHJvZHVjaW5nIGFuIGFkZGl0aW9uYWwKKyAgICAgICAgaW5kaXJlY3Rpb24u CisKKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIHN0b3JhZ2UgdG8gRGF0YSBhbmQgaW5pdGlhbGl6 ZXMgVCBpbiBEYXRhLgorICAgICAgICBBbmQgd2UgZHJvcCBUaHJlYWRTcGVjaWZpYzo6cmVwbGFj ZSBzdXBwb3J0LCB3aGljaCBpcyBvbmx5IHVzZWQKKyAgICAgICAgYnkgV2ViIHRocmVhZC4gV2Vi IHRocmVhZCBzaG91bGQgdXNlIFRocmVhZFNwZWNpZmljPHN0ZDo6dW5pcXVlX3B0cjxUPj4gaW5z dGVhZC4KKworICAgICAgICAqIHd0Zi9UaHJlYWRTcGVjaWZpYy5oOgorICAgICAgICAoV1RGOjpU aHJlYWRTcGVjaWZpYzo6RGF0YTo6Y29uc3RydWN0KToKKyAgICAgICAgKFdURjo6VGhyZWFkU3Bl Y2lmaWM6OkRhdGE6OkRhdGEpOgorICAgICAgICBXZSBtYWtlIGl0IGZhc3QgYWxsb2NhdGVkIHNp bmNlIHdlIHByZXZpb3VzbHkgYWxsb2NhdGVkIFRocmVhZFNwZWNpZmljIFQgZGF0YSBieSBmYXN0 TWFsbG9jLgorCisgICAgICAgIChXVEY6OlRocmVhZFNwZWNpZmljOjpEYXRhOjp+RGF0YSk6Cisg ICAgICAgIChXVEY6OlRocmVhZFNwZWNpZmljOjpEYXRhOjpzdG9yYWdlUG9pbnRlciBjb25zdCk6 CisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpnZXQpOgorICAgICAgICBXZSBhbHNvIGRy b3AgUkVMRUFTRV9BU1NFUlQgZnJvbSA6OmdldCgpLiBXZSBhbHJlYWR5IGluc2VydGVkIHRoaXMg YXNzZXJ0IHRvIHNldEFuZENvbnN0cnVjdCgpLAorICAgICAgICBzbyB3aGVuIGNyZWF0aW5nIHRo ZSBtZW1iZXIgdG8gdGhpcyBUTFMsIHdlIGV4ZWN1dGUgdGhpcyByZWxlYXNlIGFzc2VydC4gU28g aXQgaXMKKyAgICAgICAgbm90IG5lY2Vzc2FyeSB0byBleGVjdXRlIHRoaXMgYXNzZXJ0aW9uIGV2 ZXJ5IHRpbWUgd2UgZ2V0IGRhdGEgZnJvbSB0aGlzIFRMUy4KKworICAgICAgICAoV1RGOjpjYW5C ZUdDVGhyZWFkPjo6c2V0KToKKyAgICAgICAgKFdURjo6Y2FuQmVHQ1RocmVhZD46OmRlc3Ryb3kp OgorICAgICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6c2V0QW5kQ29uc3RydWN0KToKKyAgICAg ICAgKFdURjo6VCk6CisgICAgICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpyZXBsYWNlKTogRGVs ZXRlZC4KKwogMjAxNy0wOC0wOSAgRG9uIE9sbXN0ZWFkICA8ZG9uLm9sbXN0ZWFkQHNvbnkuY29t PgogCiAgICAgICAgIFtXVEZdIE1vdmUgVGV4dFN0cmVhbSBpbnRvIFdURgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4 IDEzMGU0ZjBmZjJkYzBmZWQ4MWY3MjIyMDBiNzJkNGY0MDgwM2ExYTguLjQxZmU4MjZkYTY2MmIw MjE3ZDVkMGQ5ZDcxNmRlM2EwNTVjZDJiYjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAor MjAxNy0wOC0wOSAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWlsLmNvbT4KKworICAg ICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVjZSBhZGRpdGlvbmFs IGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBXZSBkcm9wIFRocmVhZFNwZWNpZmljOjpyZXBsYWNlIGZlYXR1cmUgd2hpY2ggaXMgb25s eSB1c2VkIGJ5CisgICAgICAgIFdlYiB0aHJlYWQuIEluc3RlYWQsIHdlIHVzZSBUaHJlYWRTcGVj aWZpYzxzdGQ6OnVuaXF1ZV9wdHI8VD4+IGhlcmUuCisKKyAgICAgICAgV2hpbGUgdGhpcyBzdGQ6 OnVuaXF1ZV9wdHI8VD4gc2hhcmVzIG9uZSBpbnN0YW5jZSBiZXR3ZWVuIG1haW4gdGhyZWFkCisg ICAgICAgIGFuZCB3ZWIgdGhyZWFkLCB0aGlzIGlzIHRoZSBzYW1lIHRvIHRoZSBjdXJyZW50IGlt cGxlbWVudGF0aW9uLiBJdCBpcworICAgICAgICBzYWZlIGJlY2F1c2UgdGhlIHdlYiB0aHJlYWQg bmV2ZXIgZmluaXNoZXMuCisKKyAgICAgICAgQW5kIGZvciBub24td2ViIHRocmVhZCBpbXBsZW1l bnRhdGlvbiwgd2UganVzdCB1c2UgVGhyZWFkU3BlY2lmaWM8VD4sCisgICAgICAgIHNpbmNlIGl0 IGlzIHRoZSBtb3N0IGVmZmljaWVudC4KKworICAgICAgICAqIHBsYXRmb3JtL1RocmVhZEdsb2Jh bERhdGEuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGhyZWFkR2xvYmFsRGF0YTo6VGhyZWFkR2xv YmFsRGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpUaHJlYWRHbG9iYWxEYXRhOjpzZXRXZWJDb3Jl VGhyZWFkRGF0YSk6CisgICAgICAgIChXZWJDb3JlOjp0aHJlYWRHbG9iYWxEYXRhKToKKyAgICAg ICAgV2UgYWxzbyBkcm9wIFN0cmluZ0ltcGw6OmVtcHR5KCkgY2FsbCBzaW5jZSBpdCBpcyBub3Qg bmVjZXNzYXJ5IG5vdzoKKyAgICAgICAgU3RyaW5nSW1wbDo6ZW1wdHkgZGF0YSBpcyBzdGF0aWNh bGx5IGluaXRpYWxpemVkIGJ5IHVzaW5nIGNvbnN0ZXhwci4KKworICAgICAgICAqIHBsYXRmb3Jt L1RocmVhZEdsb2JhbERhdGEuaDoKKyAgICAgICAgV2UgbWFrZSBpdCBGQVNUX0FMTE9DQVRFRCBz aW5jZSBpdCBpcyBwcmV2aW91c2x5IGFsbG9jYXRlZCBieSBmYXN0IG1hbGxvYworICAgICAgICBp biBUaHJlYWRTcGVjaWZpYy4KKwogMjAxNy0wOC0wOSAgRG9uIE9sbXN0ZWFkICA8ZG9uLm9sbXN0 ZWFkQHNvbnkuY29tPgogCiAgICAgICAgIFtXVEZdIE1vdmUgVGV4dFN0cmVhbSBpbnRvIFdURgpk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9JZGVudGlmaWVyLmNwcAppbmRleCBkNTUy ZDBiMWY2Mjg3MTVhMjYzNmFiNzczN2VkZmM2MTk3MzRjMGM4Li5mODRiNjllNGQzZDNmNWRmOGI2 NmZmNzY4ODFlZmU0OTVmZGIyNDJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv cnVudGltZS9JZGVudGlmaWVyLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9JZGVudGlmaWVyLmNwcApAQCAtMzMsOCArMzMsNiBAQAogI2luY2x1ZGUgPHd0Zi90ZXh0L0FT Q0lJRmFzdFBhdGguaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CiAKLXVzaW5n IFdURjo6VGhyZWFkU3BlY2lmaWM7Ci0KIG5hbWVzcGFjZSBKU0MgewogCiBSZWY8U3RyaW5nSW1w bD4gSWRlbnRpZmllcjo6YWRkKFZNKiB2bSwgY29uc3QgY2hhciogYykKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XVEYvd3RmL1RocmVhZFNwZWNpZmljLmggYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRTcGVj aWZpYy5oCmluZGV4IDFmOTgzNjNlOTM0MTM0YzQxNDMzMzZjOGI4MmY4YWZjNDM4MTVlMjMuLjBm ODQzMzMzNWM1MWQ2MTZlNmFmMDRmODdiMTY4MjNmYjZiNzcyMDUgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvd3RmL1RocmVhZFNwZWNpZmljLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3Bl Y2lmaWMuaApAQCAtODIsMTAgKzgyLDYgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1Ro cmVhZCBjYW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFsc2U+IGNsYXNzIFQKICAgICBv cGVyYXRvciBUKigpOwogICAgIFQmIG9wZXJhdG9yKigpOwogCi0jaWYgVVNFKFdFQl9USFJFQUQp Ci0gICAgdm9pZCByZXBsYWNlKFQqKTsKLSNlbmRpZgotCiBwcml2YXRlOgogICAgIC8vIE5vdCBp bXBsZW1lbnRlZC4gSXQncyB0ZWNobmljYWxseSBwb3NzaWJsZSB0byBkZXN0cm95IGEgdGhyZWFk IHNwZWNpZmljIGtleSwgYnV0IG9uZSB3b3VsZCBuZWVkCiAgICAgLy8gdG8gbWFrZSBzdXJlIHRo YXQgYWxsIHZhbHVlcyBoYXZlIGJlZW4gZGVzdHJveWVkIGFscmVhZHkgKHVzdWFsbHksIHRoYXQg YWxsIHRocmVhZHMgdGhhdCB1c2VkIGl0CkBAIC05MywxOSArODksMzggQEAgdGVtcGxhdGU8dHlw ZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkID0gQ2FuQmVHQ1RocmVhZDo6RmFs c2U+IGNsYXNzIFQKICAgICAvLyBhIGRlc3RydWN0b3IgZGVmaW5lZCBjYW4gYmUgY29uZnVzaW5n LCBnaXZlbiB0aGF0IGl0IGhhcyBzdWNoIHN0cm9uZyBwcmUtcmVxdWlzaXRlcyB0byB3b3JrIGNv cnJlY3RseS4KICAgICB+VGhyZWFkU3BlY2lmaWMoKTsKIAotICAgIFQqIGdldCgpOwotICAgIHZv aWQgc2V0KFQqKTsKLSAgICB2b2lkIHN0YXRpYyBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBkZXN0cm95 KHZvaWQqIHB0cik7Ci0KICAgICBzdHJ1Y3QgRGF0YSB7CiAgICAgICAgIFdURl9NQUtFX05PTkNP UFlBQkxFKERhdGEpOworICAgICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKICAgICBwdWJs aWM6Ci0gICAgICAgIERhdGEoVCogdmFsdWUsIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJl YWQ+KiBvd25lcikgOiB2YWx1ZSh2YWx1ZSksIG93bmVyKG93bmVyKSB7fQorICAgICAgICB1c2lu ZyBQb2ludGVyVHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX2NvbnN0PFQ+Ojp0eXBlKjsKKwor ICAgICAgICB2b2lkIGNvbnN0cnVjdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIG5ldyAoTm90 TnVsbCwgc3RvcmFnZVBvaW50ZXIoKSkgVDsKKyAgICAgICAgfQorCisgICAgICAgIERhdGEoVGhy ZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD4qIG93bmVyKQorICAgICAgICAgICAgOiBvd25l cihvd25lcikKKyAgICAgICAgeworICAgICAgICB9CisKKyAgICAgICAgfkRhdGEoKQorICAgICAg ICB7CisgICAgICAgICAgICBzdG9yYWdlUG9pbnRlcigpLT5+VCgpOworICAgICAgICB9CiAKLSAg ICAgICAgVCogdmFsdWU7CisgICAgICAgIFBvaW50ZXJUeXBlIHN0b3JhZ2VQb2ludGVyKCkgY29u c3QgeyByZXR1cm4gY29uc3RfY2FzdDxQb2ludGVyVHlwZT4ocmVpbnRlcnByZXRfY2FzdDxjb25z dCBUKj4oJm1fc3RvcmFnZSkpOyB9CisKKyAgICAgICAgdHlwZW5hbWUgc3RkOjphbGlnbmVkX3N0 b3JhZ2U8c2l6ZW9mKFQpLCBzdGQ6OmFsaWdubWVudF9vZjxUPjo6dmFsdWU+Ojp0eXBlIG1fc3Rv cmFnZTsKICAgICAgICAgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD4qIG93bmVyOwog ICAgIH07CiAKKyAgICBUKiBnZXQoKTsKKyAgICBUKiBzZXRBbmRDb25zdHJ1Y3QoKTsKKyAgICB2 b2lkIHNldChEYXRhKik7CisgICAgdm9pZCBzdGF0aWMgVEhSRUFEX1NQRUNJRklDX0NBTEwgZGVz dHJveSh2b2lkKiBwdHIpOworCiAjaWYgVVNFKFBUSFJFQURTKQogICAgIHB0aHJlYWRfa2V5X3Qg bV9rZXk7CiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMTU2LDE3ICsxNzEsMTQgQEAgaW5saW5lIFQq IFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERhdGEqIGRh dGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRocmVhZF9nZXRzcGVjaWZpYyhtX2tleSkpOwogICAg IGlmIChkYXRhKQotICAgICAgICByZXR1cm4gZGF0YS0+dmFsdWU7Ci0gICAgUkVMRUFTRV9BU1NF UlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhyZWFkOjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFk KCkpOworICAgICAgICByZXR1cm4gZGF0YS0+c3RvcmFnZVBvaW50ZXIoKTsKICAgICByZXR1cm4g bnVsbHB0cjsKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdD VGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OnNl dChUKiBwdHIpCitpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6 c2V0KERhdGEqIGRhdGEpCiB7Ci0gICAgUkVMRUFTRV9BU1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBD YW5CZUdDVGhyZWFkOjpUcnVlIHx8ICFtYXlCZUdDVGhyZWFkKCkpOwotICAgIEFTU0VSVCghZ2V0 KCkpOwotICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIG5ldyBEYXRhKHB0ciwgdGhpcykp OworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIGRhdGEpOwogfQogCiAjZWxpZiBPUyhX SU5ET1dTKQpAQCAtMjMyLDE3ICsyNDQsMTMgQEAgaW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQs IGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxE YXRhKj4oRmxzR2V0VmFsdWUoZmxzS2V5cygpW21faW5kZXhdKSk7CiAgICAgaWYgKGRhdGEpCi0g ICAgICAgIHJldHVybiBkYXRhLT52YWx1ZTsKLSAgICBSRUxFQVNFX0FTU0VSVChjYW5CZUdDVGhy ZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1heUJlR0NUaHJlYWQoKSk7CisgICAgICAg IHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwogICAgIHJldHVybiBudWxscHRyOwogfQog CiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxp bmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6c2V0KFQqIHB0cikKK2lu bGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpzZXQoRGF0YSogZGF0 YSkKIHsKLSAgICBSRUxFQVNFX0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6 OlRydWUgfHwgIW1heUJlR0NUaHJlYWQoKSk7Ci0gICAgQVNTRVJUKCFnZXQoKSk7Ci0gICAgRGF0 YSogZGF0YSA9IG5ldyBEYXRhKHB0ciwgdGhpcyk7CiAgICAgRmxzU2V0VmFsdWUoZmxzS2V5cygp W21faW5kZXhdLCBkYXRhKTsKIH0KIApAQCAtMjYxLDE4ICsyNjksMzEgQEAgaW5saW5lIHZvaWQg VEhSRUFEX1NQRUNJRklDX0NBTEwgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OmRl c3Ryb3kodm9pZCoKICAgICBwdGhyZWFkX3NldHNwZWNpZmljKGRhdGEtPm93bmVyLT5tX2tleSwg cHRyKTsKICNlbmRpZgogCi0gICAgZGF0YS0+dmFsdWUtPn5UKCk7Ci0gICAgZmFzdEZyZWUoZGF0 YS0+dmFsdWUpOworICAgIGF1dG8qIG93bmVyID0gZGF0YS0+b3duZXI7CisgICAgZGF0YS0+fkRh dGEoKTsKIAogI2lmIFVTRShQVEhSRUFEUykKLSAgICBwdGhyZWFkX3NldHNwZWNpZmljKGRhdGEt Pm93bmVyLT5tX2tleSwgMCk7CisgICAgcHRocmVhZF9zZXRzcGVjaWZpYyhvd25lci0+bV9rZXks IG51bGxwdHIpOwogI2VsaWYgT1MoV0lORE9XUykKLSAgICBGbHNTZXRWYWx1ZShmbHNLZXlzKClb ZGF0YS0+b3duZXItPm1faW5kZXhdLCAwKTsKKyAgICBGbHNTZXRWYWx1ZShmbHNLZXlzKClbb3du ZXItPm1faW5kZXhdLCBudWxscHRyKTsKICNlbHNlCiAjZXJyb3IgVGhyZWFkU3BlY2lmaWMgaXMg bm90IGltcGxlbWVudGVkIGZvciB0aGlzIHBsYXRmb3JtLgogI2VuZGlmCiAKLSAgICBkZWxldGUg ZGF0YTsKKyAgICBmYXN0RnJlZShkYXRhKTsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2Fu QmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgoraW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNh bkJlR0NUaHJlYWQ+OjpzZXRBbmRDb25zdHJ1Y3QoKQoreworICAgIC8vIFNldCB1cCB0aHJlYWQt c3BlY2lmaWMgdmFsdWUncyBtZW1vcnkgcG9pbnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0 b3IsIGluIGNhc2UgYW55IGZ1bmN0aW9uIGl0IGNhbGxzCisgICAgLy8gbmVlZHMgdG8gYWNjZXNz IHRoZSB2YWx1ZSwgdG8gYXZvaWQgcmVjdXJzaW9uLgorICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJl R0NUaHJlYWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKKyAg ICBBU1NFUlQoIWdldCgpKTsKKyAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEodGhpcyk7CisgICAg c2V0KGRhdGEpOworICAgIGRhdGEtPmNvbnN0cnVjdCgpOworICAgIHJldHVybiBkYXRhLT5zdG9y YWdlUG9pbnRlcigpOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNh bkJlR0NUaHJlYWQ+CkBAIC0yODQsMTUgKzMwNSw5IEBAIGlubGluZSBib29sIFRocmVhZFNwZWNp ZmljPFQsIGNhbkJlR0NUaHJlYWQ+Ojppc1NldCgpCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5C ZUdDVGhyZWFkIGNhbkJlR0NUaHJlYWQ+CiBpbmxpbmUgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVH Q1RocmVhZD46Om9wZXJhdG9yIFQqKCkKIHsKLSAgICBUKiBwdHIgPSBzdGF0aWNfY2FzdDxUKj4o Z2V0KCkpOwotICAgIGlmICghcHRyKSB7Ci0gICAgICAgIC8vIFNldCB1cCB0aHJlYWQtc3BlY2lm aWMgdmFsdWUncyBtZW1vcnkgcG9pbnRlciBiZWZvcmUgaW52b2tpbmcgY29uc3RydWN0b3IsIGlu IGNhc2UgYW55IGZ1bmN0aW9uIGl0IGNhbGxzCi0gICAgICAgIC8vIG5lZWRzIHRvIGFjY2VzcyB0 aGUgdmFsdWUsIHRvIGF2b2lkIHJlY3Vyc2lvbi4KLSAgICAgICAgcHRyID0gc3RhdGljX2Nhc3Q8 VCo+KGZhc3RaZXJvZWRNYWxsb2Moc2l6ZW9mKFQpKSk7Ci0gICAgICAgIHNldChwdHIpOwotICAg ICAgICBuZXcgKE5vdE51bGwsIHB0cikgVDsKLSAgICB9Ci0gICAgcmV0dXJuIHB0cjsKKyAgICBp ZiAoVCogcHRyID0gZ2V0KCkpCisgICAgICAgIHJldHVybiBwdHI7CisgICAgcmV0dXJuIHNldEFu ZENvbnN0cnVjdCgpOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhyZWFkIGNh bkJlR0NUaHJlYWQ+CkBAIC0zMDcsMTkgKzMyMiw4IEBAIGlubGluZSBUJiBUaHJlYWRTcGVjaWZp YzxULCBjYW5CZUdDVGhyZWFkPjo6b3BlcmF0b3IqKCkKICAgICByZXR1cm4gKm9wZXJhdG9yIFQq KCk7CiB9CiAKLSNpZiBVU0UoV0VCX1RIUkVBRCkKLXRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJl R0NUaHJlYWQgY2FuQmVHQ1RocmVhZD4KLWlubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQsIGNh bkJlR0NUaHJlYWQ+OjpyZXBsYWNlKFQqIG5ld1B0cikKLXsKLSAgICBBU1NFUlQobmV3UHRyKTsK LSAgICBEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+KHB0aHJlYWRfZ2V0c3BlY2lmaWMo bV9rZXkpKTsKLSAgICBBU1NFUlQoZGF0YSk7Ci0gICAgZGF0YS0+dmFsdWUtPn5UKCk7Ci0gICAg ZmFzdEZyZWUoZGF0YS0+dmFsdWUpOwotICAgIGRhdGEtPnZhbHVlID0gbmV3UHRyOwotfQotI2Vu ZGlmCi0KIH0gLy8gbmFtZXNwYWNlIFdURgogCit1c2luZyBXVEY6OlRocmVhZFNwZWNpZmljOwor CiAjZW5kaWYgLy8gV1RGX1RocmVhZFNwZWNpZmljX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAKaW5kZXggNzczODI5ZDVlN2I0ZWIzM2Q3YmU4MzgwNzE2 ZjlhMzMzNzI2ZjRmOC4uMzAyOTg3NmJkZmE0MjllOGIwYzgwYWNmZDM3MTk4YTBiNTQ1NjBlZiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAKQEAgLTQz LDExICs0Myw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotVGhyZWFkU3BlY2lmaWM8VGhy ZWFkR2xvYmFsRGF0YT4qIFRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7Ci0jaWYgVVNFKFdF Ql9USFJFQUQpCi1UaHJlYWRHbG9iYWxEYXRhKiBUaHJlYWRHbG9iYWxEYXRhOjpzaGFyZWRNYWlu VGhyZWFkU3RhdGljRGF0YTsKLSNlbmRpZgotCiBUaHJlYWRHbG9iYWxEYXRhOjpUaHJlYWRHbG9i YWxEYXRhKCkKICAgICA6IG1fY2FjaGVkUmVzb3VyY2VSZXF1ZXN0SW5pdGlhdG9ycyhzdGQ6Om1h a2VfdW5pcXVlPENhY2hlZFJlc291cmNlUmVxdWVzdEluaXRpYXRvcnM+KCkpCiAgICAgLCBtX2V2 ZW50TmFtZXMoRXZlbnROYW1lczo6Y3JlYXRlKCkpCkBAIC02Niw3ICs2MSw2IEBAIFRocmVhZEds b2JhbERhdGE6OlRocmVhZEdsb2JhbERhdGEoKQogICAgIC8vIHBvaW50IHRvIGNhbGwgbWV0aG9k cyB0aGF0IGludGVybmFsbHkgcGVyZm9ybSBhIG9uZS10aW1lIGluaXRpYWxpemF0aW9uIHRoYXQg aXMgbm90CiAgICAgLy8gdGhyZWFkc2FmZS4KICAgICBUaHJlYWQ6OmN1cnJlbnQoKTsKLSAgICBT dHJpbmdJbXBsOjplbXB0eSgpOwogfQogCiBUaHJlYWRHbG9iYWxEYXRhOjp+VGhyZWFkR2xvYmFs RGF0YSgpCkBAIC04NywzNCArODEsNTIgQEAgdm9pZCBUaHJlYWRHbG9iYWxEYXRhOjpkZXN0cm95 KCkKIH0KIAogI2lmIFVTRShXRUJfVEhSRUFEKQorc3RhdGljIFRocmVhZFNwZWNpZmljPHN0ZDo6 dW5pcXVlX3B0cjxUaHJlYWRHbG9iYWxEYXRhPj4qIHN0YXRpY0RhdGEgeyBudWxscHRyIH07Citz dGF0aWMgVGhyZWFkR2xvYmFsRGF0YSogc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEgeyBudWxs cHRyIH07CisKIHZvaWQgVGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29yZVRocmVhZERhdGEoKQog ewogICAgIEFTU0VSVChpc1dlYlRocmVhZCgpKTsKLSAgICBBU1NFUlQoJnRocmVhZEdsb2JhbERh dGEoKSAhPSBUaHJlYWRHbG9iYWxEYXRhOjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7Cisg ICAgQVNTRVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkgIT0gc2hhcmVkTWFpblRocmVhZFN0YXRpY0Rh dGEpOwogCiAgICAgLy8gU2V0IFdlYlRocmVhZCdzIFRocmVhZEdsb2JhbERhdGEgb2JqZWN0IHRv IGJlIHRoZSBzYW1lIGFzIHRoZSBtYWluIFVJIHRocmVhZC4KLSAgICBUaHJlYWRHbG9iYWxEYXRh OjpzdGF0aWNEYXRhLT5yZXBsYWNlKFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRT dGF0aWNEYXRhKTsKKyAgICAvLyBXaGlsZSB3ZSBzdG9yZSB0aGUgc2FtZSBwb2ludGVyIHRvIHN0 ZDo6dW5pcXVlX3B0ciwgaXQgaXMgb2sgYmVjYXVzZSB0aGUgd2ViIHRocmVhZCBuZXZlciBmaW5p c2hlcy4KKyAgICAoKipzdGF0aWNEYXRhKS5yZXNldChzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0 YSk7CiAKLSAgICBBU1NFUlQoJnRocmVhZEdsb2JhbERhdGEoKSA9PSBUaHJlYWRHbG9iYWxEYXRh OjpzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YSk7CisgICAgQVNTRVJUKCZ0aHJlYWRHbG9iYWxE YXRhKCkgPT0gc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEpOwogfQotI2VuZGlmCiAKLVRocmVh ZEdsb2JhbERhdGEmIHRocmVhZEdsb2JhbERhdGEoKSAKK1RocmVhZEdsb2JhbERhdGEmIHRocmVh ZEdsb2JhbERhdGEoKQogewotI2lmIFVTRShXRUJfVEhSRUFEKQotICAgIGlmIChVTkxJS0VMWSgh VGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSkpIHsKLSAgICAgICAgVGhyZWFkR2xvYmFsRGF0 YTo6c3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsKKyAg ICBpZiAoVU5MSUtFTFkoIXN0YXRpY0RhdGEpKSB7CisgICAgICAgIHN0YXRpY0RhdGEgPSBuZXcg VGhyZWFkU3BlY2lmaWM8c3RkOjp1bmlxdWVfcHRyPFRocmVhZEdsb2JhbERhdGE+PjsKKyAgICAg ICAgYXV0byYgcmVzdWx0ID0gKipzdGF0aWNEYXRhOworICAgICAgICBBU1NFUlQoIXJlc3VsdCk7 CisgICAgICAgIHJlc3VsdC5yZXNldChuZXcgVGhyZWFkR2xvYmFsRGF0YSgpKTsKICAgICAgICAg Ly8gV2ViVGhyZWFkIGFuZCBtYWluIFVJIHRocmVhZCBuZWVkIHRvIHNoYXJlIHRoZSBzYW1lIG9i amVjdC4gU2F2ZSBpdCBpbiBhIHN0YXRpYwogICAgICAgICAvLyBoZXJlLCB0aGUgV2ViVGhyZWFk IHdpbGwgcGljayBpdCB1cCBpbiBzZXRXZWJDb3JlVGhyZWFkRGF0YSgpLgogICAgICAgICBpZiAo cHRocmVhZF9tYWluX25wKCkpCi0gICAgICAgICAgICBUaHJlYWRHbG9iYWxEYXRhOjpzaGFyZWRN YWluVGhyZWFkU3RhdGljRGF0YSA9ICpUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhOworICAg ICAgICAgICAgc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEgPSByZXN1bHQuZ2V0KCk7CisgICAg ICAgIHJldHVybiAqcmVzdWx0OwogICAgIH0KLSAgICByZXR1cm4gKipUaHJlYWRHbG9iYWxEYXRh OjpzdGF0aWNEYXRhOworCisgICAgYXV0byYgcmVzdWx0ID0gKipzdGF0aWNEYXRhOworICAgIGlm ICghcmVzdWx0KQorICAgICAgICByZXN1bHQucmVzZXQobmV3IFRocmVhZEdsb2JhbERhdGEoKSk7 CisgICAgcmV0dXJuICpyZXN1bHQ7Cit9CisKICNlbHNlCi0gICAgaWYgKCFUaHJlYWRHbG9iYWxE YXRhOjpzdGF0aWNEYXRhKQotICAgICAgICBUaHJlYWRHbG9iYWxEYXRhOjpzdGF0aWNEYXRhID0g bmV3IFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+OwotICAgIHJldHVybiAqKlRocmVh ZEdsb2JhbERhdGE6OnN0YXRpY0RhdGE7Ci0jZW5kaWYKKworc3RhdGljIFRocmVhZFNwZWNpZmlj PFRocmVhZEdsb2JhbERhdGE+KiBzdGF0aWNEYXRhIHsgbnVsbHB0ciB9OworCitUaHJlYWRHbG9i YWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCkKK3sKKyAgICBpZiAoVU5MSUtFTFkoIXN0YXRpY0Rh dGEpKQorICAgICAgICBzdGF0aWNEYXRhID0gbmV3IFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2Jh bERhdGE+OworICAgIHJldHVybiAqKnN0YXRpY0RhdGE7CiB9CiAKKyNlbmRpZgorCiB9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJl YWRHbG9iYWxEYXRhLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRh LmgKaW5kZXggNThmN2MwNzQwMjU0MDg4OWIzY2ZkNDQxOWI5MDg1Y2Y1NzljY2YyMS4uN2RiNWI5 OGJjNjU3NDE2M2E3YjExY2QzYjEzZGIwZGRmMGNhZTY4ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1RocmVhZEdsb2JhbERhdGEuaApAQCAtMjksOSArMjksNiBAQAogCiAjaW5jbHVkZSA8 d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCi0jaW5jbHVkZSA8d3RmL1RocmVhZFNwZWNpZmljLmg+ Ci11c2luZyBXVEY6OlRocmVhZFNwZWNpZmljOwotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAg ICBjbGFzcyBRdWFsaWZpZWROYW1lQ2FjaGU7CkBAIC00NCw2ICs0MSw3IEBAIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAogICAgIGNsYXNzIFRocmVhZEdsb2JhbERhdGEgewogICAgICAgICBXVEZfTUFL RV9OT05DT1BZQUJMRShUaHJlYWRHbG9iYWxEYXRhKTsKKyAgICAgICAgV1RGX01BS0VfRkFTVF9B TExPQ0FURUQ7CiAgICAgcHVibGljOgogICAgICAgICBXRUJDT1JFX0VYUE9SVCBUaHJlYWRHbG9i YWxEYXRhKCk7CiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIH5UaHJlYWRHbG9iYWxEYXRhKCk7CkBA IC04MCwxMCArNzgsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHN0ZDo6dW5pcXVl X3B0cjxURUNDb252ZXJ0ZXJXcmFwcGVyPiBtX2NhY2hlZENvbnZlcnRlclRFQzsKICNlbmRpZgog Ci0gICAgICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9i YWxEYXRhPiogc3RhdGljRGF0YTsKLSNpZiBVU0UoV0VCX1RIUkVBRCkKLSAgICAgICAgV0VCQ09S RV9FWFBPUlQgc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHNoYXJlZE1haW5UaHJlYWRTdGF0aWNE YXRhOwotI2VuZGlmCiAgICAgICAgIFdFQkNPUkVfRVhQT1JUIGZyaWVuZCBUaHJlYWRHbG9iYWxE YXRhJiB0aHJlYWRHbG9iYWxEYXRhKCk7CiAgICAgfTsKIAo= 317840 2017-08-10 14:00:53 -0700 2017-08-10 14:06:43 -0700 Patch bug-175187-20170811060052.patch text/plain 15528 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwNTQxCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA4 ZjEyOTcwNGMxM2RhYzRjNDRmY2U2NzEyMjBiNzBkMWNmMWY2OThjLi4xYTUxZjk5NWMwOWYzNGY1 M2IxNjZlNTNmZGY3OGFiMDZiZTBiZjAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNy0wOC0xMCAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KKworICAgICAgICBbV1RGXSBUaHJlYWRTcGVjaWZpYyBzaG91bGQgbm90IGludHJvZHVj ZSBhZGRpdGlvbmFsIGluZGlyZWN0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNzUxODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHJ1bnRpbWUvSWRlbnRpZmllci5jcHA6CisKIDIwMTctMDgtMTAg IFRpbSBIb3J0b24gIDx0aW1vdGh5X2hvcnRvbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3Zl IHNvbWUgdW51c2VkIGxhbWJkYSBjYXB0dXJlcyBzbyB0aGF0IFdlYktpdCBidWlsZHMgd2l0aCAt V3VudXNlZC1sYW1iZGEtY2FwdHVyZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCAzOTk1N2M2NGMwY2UxOGQ0NTE1OWFmNDUwNDk2 M2M4YzAxOGEyODZlLi4yZDU1OTRkN2U1N2EzMjdkZjYyZmJmYmVhM2EzMzYwYmU2NDJjYzgwIDEw MDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV1RGL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDQwIEBACisyMDE3LTA4LTEwICBZdXN1a2UgU3V6dWtpICA8dXRhdGFuZS50 ZWFAZ21haWwuY29tPgorCisgICAgICAgIFtXVEZdIFRocmVhZFNwZWNpZmljIHNob3VsZCBub3Qg aW50cm9kdWNlIGFkZGl0aW9uYWwgaW5kaXJlY3Rpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NTE4NworCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFRocmVhZFNwZWNpZmljIHNldHMgRGF0YSogdG8gdGhl IFRMUy4gQW5kIERhdGEgaG9sZHMgVCosIHdoaWNoCisgICAgICAgIGlzIGZhc3QgYWxsb2NhdGVk IGFjdHVhbCBkYXRhLiBCdXQgaWRlYWxseSwgd2Ugc2hvdWxkIHN0b3JlIFQKKyAgICAgICAgaW5z dGFuY2UgZGlyZWN0bHkgaW4gRGF0YSBpbnN0ZWFkIG9mIGludHJvZHVjaW5nIGFuIGFkZGl0aW9u YWwKKyAgICAgICAgaW5kaXJlY3Rpb24uCisKKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIHN0b3Jh Z2UgaW4gRGF0YSBpbiBvcmRlciB0byBlbWJlZCB0aGUgaW5zdGFuY2Ugb2YgVC4gVGhlIGNvbnN0 cnVjdG9yCisgICAgICAgIGZvciBEYXRhIHdpbGwgaW52b2tlIHRoZSBjb25zdHJ1Y3RvciBmb3Ig VCBvbiB0aGUgZW1iZWRkZWQgc3RvcmFnZS4gV2UgYWxzbyBkcm9wCisgICAgICAgIFRocmVhZFNw ZWNpZmljOjpyZXBsYWNlIHdoaWNoIGlzIG9ubHkgdXNlZCBieSB0aGUgd2ViIHRocmVhZCB0byBz ZXQgaXRzIHRocmVhZCBzcGVjaWZpYworICAgICAgICBUaHJlYWRHbG9iYWxEYXRhIHRvIHRoZSBv bmUgc2hhcmVkIGZyb20gdGhlIG1haW4gdGhyZWFkLiBUaGUgZXhpc3RpbmcgaW1wbGVtZW50YXRp b24KKyAgICAgICAgcmVsaWVzIG9uIHRoZSBtYWluIHRocmVhZCBhbmQgdGhlIHdlYiB0aHJlYWQg bmV2ZXIgZXhpdGluZyBpbiBvcmRlciBmb3IgdGhlIHNoYXJlZAorICAgICAgICBUaHJlYWRHbG9i YWxEYXRhIHRvIHN0YXkgYWxpdmUuIFdlIGNhbiBhY2hpZXZlIHRoZSBzYW1lIHNlbWFudGljcyBi eSB1c2luZyBhCisgICAgICAgIFRocmVhZFNwZWNpZmljPHN0ZDo6dW5pcXVlX3B0cjxUPj4gdG8g aG9sZCB0aGUgVGhyZWFkR2xvYmFsRGF0YSBpbnN0YW5jZSBpbnN0ZWFkLgorCisgICAgICAgICog d3RmL1RocmVhZFNwZWNpZmljLmg6CisgICAgICAgIChXVEY6OlRocmVhZFNwZWNpZmljOjpEYXRh OjpEYXRhKToKKyAgICAgICAgV2UgbWFrZSBpdCBmYXN0IGFsbG9jYXRlZCBzaW5jZSB3ZSBwcmV2 aW91c2x5IGFsbG9jYXRlZCBUaHJlYWRTcGVjaWZpYyBUIGRhdGEgYnkgZmFzdE1hbGxvYy4KKwor ICAgICAgICAoV1RGOjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6fkRhdGEpOgorICAgICAgICAoV1RG OjpUaHJlYWRTcGVjaWZpYzo6RGF0YTo6c3RvcmFnZVBvaW50ZXIgY29uc3QpOgorICAgICAgICAo V1RGOjpjYW5CZUdDVGhyZWFkPjo6Z2V0KToKKyAgICAgICAgV2UgYWxzbyBkcm9wIFJFTEVBU0Vf QVNTRVJUIGZyb20gOjpnZXQoKS4gV2UgYWxyZWFkeSBpbnNlcnRlZCB0aGlzIGFzc2VydCB0byBz ZXRBbmRDb25zdHJ1Y3QoKSwKKyAgICAgICAgc28gd2hlbiBjcmVhdGluZyB0aGUgbWVtYmVyIHRv IHRoaXMgVExTLCB3ZSBleGVjdXRlIHRoaXMgcmVsZWFzZSBhc3NlcnQuIFNvIGl0IGlzCisgICAg ICAgIG5vdCBuZWNlc3NhcnkgdG8gZXhlY3V0ZSB0aGlzIGFzc2VydGlvbiBldmVyeSB0aW1lIHdl IGdldCBkYXRhIGZyb20gdGhpcyBUTFMuCisKKyAgICAgICAgKFdURjo6Y2FuQmVHQ1RocmVhZD46 OnNldEluVExTKToKKyAgICAgICAgKFdURjo6Y2FuQmVHQ1RocmVhZD46OmRlc3Ryb3kpOgorICAg ICAgICAoV1RGOjpjYW5CZUdDVGhyZWFkPjo6c2V0KToKKyAgICAgICAgKFdURjo6VCk6CisgICAg ICAgIChXVEY6OmNhbkJlR0NUaHJlYWQ+OjpyZXBsYWNlKTogRGVsZXRlZC4KKwogMjAxNy0wOC0x MCAgVGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAogICAgICAgICBGaXgg YSBzaWxseSB0eXBvIGluIENvbXBpbGVyLmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAzODU0NWJiMzYyYjZmMjkz NWJhOTliYjNkZDA4NDU2MGI2YzNmMzExLi40MmY4ZDFmYjlhNTYxZjNlNjNlYmE1Y2Q5ZWFhYmYw ZmQ1MDQ2NTU3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTctMDgtMTAgIFl1c3Vr ZSBTdXp1a2kgIDx1dGF0YW5lLnRlYUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dURl0gVGhyZWFk U3BlY2lmaWMgc2hvdWxkIG5vdCBpbnRyb2R1Y2UgYWRkaXRpb25hbCBpbmRpcmVjdGlvbgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1MTg3CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2UgZHJvcCBUaHJl YWRTcGVjaWZpYzo6cmVwbGFjZSBmZWF0dXJlIHdoaWNoIGlzIG9ubHkgdXNlZCBieQorICAgICAg ICBXZWIgdGhyZWFkLiBJbnN0ZWFkLCB3ZSB1c2UgVGhyZWFkU3BlY2lmaWM8c3RkOjp1bmlxdWVf cHRyPFQ+PiBoZXJlLgorCisgICAgICAgIFdoaWxlIHRoaXMgc3RkOjp1bmlxdWVfcHRyPFQ+IHNo YXJlcyBvbmUgaW5zdGFuY2UgYmV0d2VlbiBtYWluIHRocmVhZAorICAgICAgICBhbmQgd2ViIHRo cmVhZCwgdGhpcyBpcyB0aGUgc2FtZSB0byB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbi4gSXQg aXMKKyAgICAgICAgc2FmZSBiZWNhdXNlIHRoZSB3ZWIgdGhyZWFkIG5ldmVyIGZpbmlzaGVzLgor CisgICAgICAgIEFuZCBmb3Igbm9uLXdlYiB0aHJlYWQgaW1wbGVtZW50YXRpb24sIHdlIGp1c3Qg dXNlIFRocmVhZFNwZWNpZmljPFQ+LAorICAgICAgICBzaW5jZSBpdCBpcyB0aGUgbW9zdCBlZmZp Y2llbnQuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlRocmVhZEdsb2JhbERhdGE6OlRocmVhZEdsb2JhbERhdGEpOgorICAgICAg ICAoV2ViQ29yZTo6VGhyZWFkR2xvYmFsRGF0YTo6c2V0V2ViQ29yZVRocmVhZERhdGEpOgorICAg ICAgICAoV2ViQ29yZTo6dGhyZWFkR2xvYmFsRGF0YSk6CisgICAgICAgIFdlIGFsc28gZHJvcCBT dHJpbmdJbXBsOjplbXB0eSgpIGNhbGwgc2luY2UgaXQgaXMgbm90IG5lY2Vzc2FyeSBub3c6Cisg ICAgICAgIFN0cmluZ0ltcGw6OmVtcHR5IGRhdGEgaXMgc3RhdGljYWxseSBpbml0aWFsaXplZCBi eSB1c2luZyBjb25zdGV4cHIuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRh Lmg6CisgICAgICAgIFdlIG1ha2UgaXQgRkFTVF9BTExPQ0FURUQgc2luY2UgaXQgaXMgcHJldmlv dXNseSBhbGxvY2F0ZWQgYnkgZmFzdCBtYWxsb2MKKyAgICAgICAgaW4gVGhyZWFkU3BlY2lmaWMu CisKIDIwMTctMDgtMTAgIE1pY2hhZWwgQ2F0YW56YXJvICA8bWNhdGFuemFyb0BpZ2FsaWEuY29t PgogCiAgICAgICAgIFJFR1JFU1NJT04ocjIyMDUxNSkgW0dUS11bQ01ha2VdIEJ1aWxkIHdpdGgg RU5BQkxFX0dFT0xPQ0FUSU9OIGZhaWxzIG9uIERlYmlhbiBKZXNzaWUKZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0lkZW50aWZpZXIuY3BwIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5jcHAKaW5kZXggZDU1MmQwYjFmNjI4NzE1YTI2 MzZhYjc3MzdlZGZjNjE5NzM0YzBjOC4uZjg0YjY5ZTRkM2QzZjVkZjhiNjZmZjc2ODgxZWZlNDk1 ZmRiMjQyYyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRp Zmllci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSWRlbnRpZmllci5j cHAKQEAgLTMzLDggKzMzLDYgQEAKICNpbmNsdWRlIDx3dGYvdGV4dC9BU0NJSUZhc3RQYXRoLmg+ CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5oPgogCi11c2luZyBXVEY6OlRocmVhZFNw ZWNpZmljOwotCiBuYW1lc3BhY2UgSlNDIHsKIAogUmVmPFN0cmluZ0ltcGw+IElkZW50aWZpZXI6 OmFkZChWTSogdm0sIGNvbnN0IGNoYXIqIGMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9U aHJlYWRTcGVjaWZpYy5oIGIvU291cmNlL1dURi93dGYvVGhyZWFkU3BlY2lmaWMuaAppbmRleCAx Zjk4MzYzZTkzNDEzNGM0MTQzMzM2YzhiODJmOGFmYzQzODE1ZTIzLi4zYTg5NzFjODgxZjFhYjBl YzBiNDNjMTg3NjczNmZjMWE2MTllMmI2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9UaHJl YWRTcGVjaWZpYy5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1RocmVhZFNwZWNpZmljLmgKQEAgLTgy LDEwICs4Miw2IEBAIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVHQ1Ro cmVhZCA9IENhbkJlR0NUaHJlYWQ6OkZhbHNlPiBjbGFzcyBUCiAgICAgb3BlcmF0b3IgVCooKTsK ICAgICBUJiBvcGVyYXRvciooKTsKIAotI2lmIFVTRShXRUJfVEhSRUFEKQotICAgIHZvaWQgcmVw bGFjZShUKik7Ci0jZW5kaWYKLQogcHJpdmF0ZToKICAgICAvLyBOb3QgaW1wbGVtZW50ZWQuIEl0 J3MgdGVjaG5pY2FsbHkgcG9zc2libGUgdG8gZGVzdHJveSBhIHRocmVhZCBzcGVjaWZpYyBrZXks IGJ1dCBvbmUgd291bGQgbmVlZAogICAgIC8vIHRvIG1ha2Ugc3VyZSB0aGF0IGFsbCB2YWx1ZXMg aGF2ZSBiZWVuIGRlc3Ryb3llZCBhbHJlYWR5ICh1c3VhbGx5LCB0aGF0IGFsbCB0aHJlYWRzIHRo YXQgdXNlZCBpdApAQCAtOTMsMTkgKzg5LDM4IEBAIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJl R0NUaHJlYWQgY2FuQmVHQ1RocmVhZCA9IENhbkJlR0NUaHJlYWQ6OkZhbHNlPiBjbGFzcyBUCiAg ICAgLy8gYSBkZXN0cnVjdG9yIGRlZmluZWQgY2FuIGJlIGNvbmZ1c2luZywgZ2l2ZW4gdGhhdCBp dCBoYXMgc3VjaCBzdHJvbmcgcHJlLXJlcXVpc2l0ZXMgdG8gd29yayBjb3JyZWN0bHkuCiAgICAg flRocmVhZFNwZWNpZmljKCk7CiAKLSAgICBUKiBnZXQoKTsKLSAgICB2b2lkIHNldChUKik7Ci0g ICAgdm9pZCBzdGF0aWMgVEhSRUFEX1NQRUNJRklDX0NBTEwgZGVzdHJveSh2b2lkKiBwdHIpOwot CiAgICAgc3RydWN0IERhdGEgewogICAgICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShEYXRhKTsK KyAgICAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiAgICAgcHVibGljOgotICAgICAgICBE YXRhKFQqIHZhbHVlLCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPiogb3duZXIpIDog dmFsdWUodmFsdWUpLCBvd25lcihvd25lcikge30KLQotICAgICAgICBUKiB2YWx1ZTsKKyAgICAg ICAgdXNpbmcgUG9pbnRlclR5cGUgPSB0eXBlbmFtZSBzdGQ6OnJlbW92ZV9jb25zdDxUPjo6dHlw ZSo7CisKKyAgICAgICAgRGF0YShUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPiogb3du ZXIpCisgICAgICAgICAgICA6IG93bmVyKG93bmVyKQorICAgICAgICB7CisgICAgICAgICAgICAv LyBTZXQgdXAgdGhyZWFkLXNwZWNpZmljIHZhbHVlJ3MgbWVtb3J5IHBvaW50ZXIgYmVmb3JlIGlu dm9raW5nIGNvbnN0cnVjdG9yLCBpbiBjYXNlIGFueSBmdW5jdGlvbiBpdCBjYWxscworICAgICAg ICAgICAgLy8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZvaWQgcmVjdXJzaW9uLgor ICAgICAgICAgICAgb3duZXItPnNldEluVExTKHRoaXMpOworICAgICAgICAgICAgbmV3IChOb3RO dWxsLCBzdG9yYWdlUG9pbnRlcigpKSBUOworICAgICAgICB9CisKKyAgICAgICAgfkRhdGEoKQor ICAgICAgICB7CisgICAgICAgICAgICBzdG9yYWdlUG9pbnRlcigpLT5+VCgpOworICAgICAgICAg ICAgb3duZXItPnNldEluVExTKG51bGxwdHIpOworICAgICAgICB9CisKKyAgICAgICAgUG9pbnRl clR5cGUgc3RvcmFnZVBvaW50ZXIoKSBjb25zdCB7IHJldHVybiBjb25zdF9jYXN0PFBvaW50ZXJU eXBlPihyZWludGVycHJldF9jYXN0PGNvbnN0IFQqPigmbV9zdG9yYWdlKSk7IH0KKworICAgICAg ICB0eXBlbmFtZSBzdGQ6OmFsaWduZWRfc3RvcmFnZTxzaXplb2YoVCksIHN0ZDo6YWxpZ25tZW50 X29mPFQ+Ojp2YWx1ZT46OnR5cGUgbV9zdG9yYWdlOwogICAgICAgICBUaHJlYWRTcGVjaWZpYzxU LCBjYW5CZUdDVGhyZWFkPiogb3duZXI7CiAgICAgfTsKIAorICAgIFQqIGdldCgpOworICAgIFQq IHNldCgpOworICAgIHZvaWQgc2V0SW5UTFMoRGF0YSopOworICAgIHZvaWQgc3RhdGljIFRIUkVB RF9TUEVDSUZJQ19DQUxMIGRlc3Ryb3kodm9pZCogcHRyKTsKKwogI2lmIFVTRShQVEhSRUFEUykK ICAgICBwdGhyZWFkX2tleV90IG1fa2V5OwogI2VsaWYgT1MoV0lORE9XUykKQEAgLTE1NiwxNyAr MTcxLDE0IEBAIGlubGluZSBUKiBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6Z2V0 KCkKIHsKICAgICBEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+KHB0aHJlYWRfZ2V0c3Bl Y2lmaWMobV9rZXkpKTsKICAgICBpZiAoZGF0YSkKLSAgICAgICAgcmV0dXJuIGRhdGEtPnZhbHVl OwotICAgIFJFTEVBU0VfQVNTRVJUKGNhbkJlR0NUaHJlYWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1 ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsKKyAgICAgICAgcmV0dXJuIGRhdGEtPnN0b3JhZ2VQb2lu dGVyKCk7CiAgICAgcmV0dXJuIG51bGxwdHI7CiB9CiAKIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENh bkJlR0NUaHJlYWQgY2FuQmVHQ1RocmVhZD4KLWlubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQs IGNhbkJlR0NUaHJlYWQ+OjpzZXQoVCogcHRyKQoraW5saW5lIHZvaWQgVGhyZWFkU3BlY2lmaWM8 VCwgY2FuQmVHQ1RocmVhZD46OnNldEluVExTKERhdGEqIGRhdGEpCiB7Ci0gICAgUkVMRUFTRV9B U1NFUlQoY2FuQmVHQ1RocmVhZCA9PSBDYW5CZUdDVGhyZWFkOjpUcnVlIHx8ICFtYXlCZUdDVGhy ZWFkKCkpOwotICAgIEFTU0VSVCghZ2V0KCkpOwotICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9r ZXksIG5ldyBEYXRhKHB0ciwgdGhpcykpOworICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXks IGRhdGEpOwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtMjMyLDE3ICsyNDQsMTMgQEAgaW5s aW5lIFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpnZXQoKQogewogICAgIERh dGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4oRmxzR2V0VmFsdWUoZmxzS2V5cygpW21faW5k ZXhdKSk7CiAgICAgaWYgKGRhdGEpCi0gICAgICAgIHJldHVybiBkYXRhLT52YWx1ZTsKLSAgICBS RUxFQVNFX0FTU0VSVChjYW5CZUdDVGhyZWFkID09IENhbkJlR0NUaHJlYWQ6OlRydWUgfHwgIW1h eUJlR0NUaHJlYWQoKSk7CisgICAgICAgIHJldHVybiBkYXRhLT5zdG9yYWdlUG9pbnRlcigpOwog ICAgIHJldHVybiBudWxscHRyOwogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBULCBDYW5CZUdDVGhy ZWFkIGNhbkJlR0NUaHJlYWQ+Ci1pbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxULCBjYW5CZUdD VGhyZWFkPjo6c2V0KFQqIHB0cikKK2lubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQsIGNhbkJl R0NUaHJlYWQ+OjpzZXRJblRMUyhEYXRhKiBkYXRhKQogewotICAgIFJFTEVBU0VfQVNTRVJUKGNh bkJlR0NUaHJlYWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVHQ1RocmVhZCgpKTsK LSAgICBBU1NFUlQoIWdldCgpKTsKLSAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEocHRyLCB0aGlz KTsKICAgICBGbHNTZXRWYWx1ZShmbHNLZXlzKClbbV9pbmRleF0sIGRhdGEpOwogfQogCkBAIC0y NjEsMjEgKzI2OSwyMCBAQCBpbmxpbmUgdm9pZCBUSFJFQURfU1BFQ0lGSUNfQ0FMTCBUaHJlYWRT cGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6ZGVzdHJveSh2b2lkKgogICAgIHB0aHJlYWRfc2V0 c3BlY2lmaWMoZGF0YS0+b3duZXItPm1fa2V5LCBwdHIpOwogI2VuZGlmCiAKLSAgICBkYXRhLT52 YWx1ZS0+flQoKTsKLSAgICBmYXN0RnJlZShkYXRhLT52YWx1ZSk7Ci0KLSNpZiBVU0UoUFRIUkVB RFMpCi0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+bV9rZXksIDApOwotI2Vs aWYgT1MoV0lORE9XUykKLSAgICBGbHNTZXRWYWx1ZShmbHNLZXlzKClbZGF0YS0+b3duZXItPm1f aW5kZXhdLCAwKTsKLSNlbHNlCi0jZXJyb3IgVGhyZWFkU3BlY2lmaWMgaXMgbm90IGltcGxlbWVu dGVkIGZvciB0aGlzIHBsYXRmb3JtLgotI2VuZGlmCi0KICAgICBkZWxldGUgZGF0YTsKIH0KIAog dGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgoraW5saW5l IFQqIFRocmVhZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpzZXQoKQoreworICAgIFJFTEVB U0VfQVNTRVJUKGNhbkJlR0NUaHJlYWQgPT0gQ2FuQmVHQ1RocmVhZDo6VHJ1ZSB8fCAhbWF5QmVH Q1RocmVhZCgpKTsKKyAgICBBU1NFUlQoIWdldCgpKTsKKyAgICBEYXRhKiBkYXRhID0gbmV3IERh dGEodGhpcyk7IC8vIERhdGEgd2lsbCBzZXQgaXRzZWxmIGludG8gVExTLgorICAgIEFTU0VSVChn ZXQoKSA9PSBkYXRhLT5zdG9yYWdlUG9pbnRlcigpKTsKKyAgICByZXR1cm4gZGF0YS0+c3RvcmFn ZVBvaW50ZXIoKTsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVCwgQ2FuQmVHQ1RocmVhZCBjYW5C ZUdDVGhyZWFkPgogaW5saW5lIGJvb2wgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46 OmlzU2V0KCkKIHsKICAgICByZXR1cm4gISFnZXQoKTsKQEAgLTI4NCwxNSArMjkxLDkgQEAgaW5s aW5lIGJvb2wgVGhyZWFkU3BlY2lmaWM8VCwgY2FuQmVHQ1RocmVhZD46OmlzU2V0KCkKIHRlbXBs YXRlPHR5cGVuYW1lIFQsIENhbkJlR0NUaHJlYWQgY2FuQmVHQ1RocmVhZD4KIGlubGluZSBUaHJl YWRTcGVjaWZpYzxULCBjYW5CZUdDVGhyZWFkPjo6b3BlcmF0b3IgVCooKQogewotICAgIFQqIHB0 ciA9IHN0YXRpY19jYXN0PFQqPihnZXQoKSk7Ci0gICAgaWYgKCFwdHIpIHsKLSAgICAgICAgLy8g U2V0IHVwIHRocmVhZC1zcGVjaWZpYyB2YWx1ZSdzIG1lbW9yeSBwb2ludGVyIGJlZm9yZSBpbnZv a2luZyBjb25zdHJ1Y3RvciwgaW4gY2FzZSBhbnkgZnVuY3Rpb24gaXQgY2FsbHMKLSAgICAgICAg Ly8gbmVlZHMgdG8gYWNjZXNzIHRoZSB2YWx1ZSwgdG8gYXZvaWQgcmVjdXJzaW9uLgotICAgICAg ICBwdHIgPSBzdGF0aWNfY2FzdDxUKj4oZmFzdFplcm9lZE1hbGxvYyhzaXplb2YoVCkpKTsKLSAg ICAgICAgc2V0KHB0cik7Ci0gICAgICAgIG5ldyAoTm90TnVsbCwgcHRyKSBUOwotICAgIH0KLSAg ICByZXR1cm4gcHRyOworICAgIGlmIChUKiBwdHIgPSBnZXQoKSkKKyAgICAgICAgcmV0dXJuIHB0 cjsKKyAgICByZXR1cm4gc2V0KCk7CiB9CiAKIHRlbXBsYXRlPHR5cGVuYW1lIFQsIENhbkJlR0NU aHJlYWQgY2FuQmVHQ1RocmVhZD4KQEAgLTMwNywxOSArMzA4LDggQEAgaW5saW5lIFQmIFRocmVh ZFNwZWNpZmljPFQsIGNhbkJlR0NUaHJlYWQ+OjpvcGVyYXRvciooKQogICAgIHJldHVybiAqb3Bl cmF0b3IgVCooKTsKIH0KIAotI2lmIFVTRShXRUJfVEhSRUFEKQotdGVtcGxhdGU8dHlwZW5hbWUg VCwgQ2FuQmVHQ1RocmVhZCBjYW5CZUdDVGhyZWFkPgotaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lm aWM8VCwgY2FuQmVHQ1RocmVhZD46OnJlcGxhY2UoVCogbmV3UHRyKQotewotICAgIEFTU0VSVChu ZXdQdHIpOwotICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRocmVhZF9nZXRz cGVjaWZpYyhtX2tleSkpOwotICAgIEFTU0VSVChkYXRhKTsKLSAgICBkYXRhLT52YWx1ZS0+flQo KTsKLSAgICBmYXN0RnJlZShkYXRhLT52YWx1ZSk7Ci0gICAgZGF0YS0+dmFsdWUgPSBuZXdQdHI7 Ci19Ci0jZW5kaWYKLQogfSAvLyBuYW1lc3BhY2UgV1RGCiAKK3VzaW5nIFdURjo6VGhyZWFkU3Bl Y2lmaWM7CisKICNlbmRpZiAvLyBXVEZfVGhyZWFkU3BlY2lmaWNfaApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcAppbmRleCA3NzM4MjlkNWU3YjRlYjMzZDdi ZTgzODA3MTZmOWEzMzM3MjZmNGY4Li43Mzc4NjdkNTMzNGNhNWJiZTNlYWVmODk1ODAwNzU2NmI1 MTljZGE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxE YXRhLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNw cApAQCAtNDMsMTEgKzQzLDYgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1UaHJlYWRTcGVj aWZpYzxUaHJlYWRHbG9iYWxEYXRhPiogVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKLSNp ZiBVU0UoV0VCX1RIUkVBRCkKLVRocmVhZEdsb2JhbERhdGEqIFRocmVhZEdsb2JhbERhdGE6OnNo YXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhOwotI2VuZGlmCi0KIFRocmVhZEdsb2JhbERhdGE6OlRo cmVhZEdsb2JhbERhdGEoKQogICAgIDogbV9jYWNoZWRSZXNvdXJjZVJlcXVlc3RJbml0aWF0b3Jz KHN0ZDo6bWFrZV91bmlxdWU8Q2FjaGVkUmVzb3VyY2VSZXF1ZXN0SW5pdGlhdG9ycz4oKSkKICAg ICAsIG1fZXZlbnROYW1lcyhFdmVudE5hbWVzOjpjcmVhdGUoKSkKQEAgLTY2LDcgKzYxLDYgQEAg VGhyZWFkR2xvYmFsRGF0YTo6VGhyZWFkR2xvYmFsRGF0YSgpCiAgICAgLy8gcG9pbnQgdG8gY2Fs bCBtZXRob2RzIHRoYXQgaW50ZXJuYWxseSBwZXJmb3JtIGEgb25lLXRpbWUgaW5pdGlhbGl6YXRp b24gdGhhdCBpcyBub3QKICAgICAvLyB0aHJlYWRzYWZlLgogICAgIFRocmVhZDo6Y3VycmVudCgp OwotICAgIFN0cmluZ0ltcGw6OmVtcHR5KCk7CiB9CiAKIFRocmVhZEdsb2JhbERhdGE6On5UaHJl YWRHbG9iYWxEYXRhKCkKQEAgLTg3LDM0ICs4MSw1NSBAQCB2b2lkIFRocmVhZEdsb2JhbERhdGE6 OmRlc3Ryb3koKQogfQogCiAjaWYgVVNFKFdFQl9USFJFQUQpCitzdGF0aWMgVGhyZWFkU3BlY2lm aWM8c3RkOjp1bmlxdWVfcHRyPFRocmVhZEdsb2JhbERhdGE+Piogc3RhdGljRGF0YSB7IG51bGxw dHIgfTsKK3N0YXRpYyBUaHJlYWRHbG9iYWxEYXRhKiBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0 YSB7IG51bGxwdHIgfTsKKwogdm9pZCBUaHJlYWRHbG9iYWxEYXRhOjpzZXRXZWJDb3JlVGhyZWFk RGF0YSgpCiB7CiAgICAgQVNTRVJUKGlzV2ViVGhyZWFkKCkpOwotICAgIEFTU0VSVCgmdGhyZWFk R2xvYmFsRGF0YSgpICE9IFRocmVhZEdsb2JhbERhdGE6OnNoYXJlZE1haW5UaHJlYWRTdGF0aWNE YXRhKTsKKyAgICBBU1NFUlQoJnRocmVhZEdsb2JhbERhdGEoKSAhPSBzaGFyZWRNYWluVGhyZWFk U3RhdGljRGF0YSk7CiAKICAgICAvLyBTZXQgV2ViVGhyZWFkJ3MgVGhyZWFkR2xvYmFsRGF0YSBv YmplY3QgdG8gYmUgdGhlIHNhbWUgYXMgdGhlIG1haW4gVUkgdGhyZWFkLgotICAgIFRocmVhZEds b2JhbERhdGE6OnN0YXRpY0RhdGEtPnJlcGxhY2UoVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFp blRocmVhZFN0YXRpY0RhdGEpOworICAgIC8vIFRoZSB3ZWIgdGhyZWFkIG5ldmVyIGZpbmlzaGVz LCBhbmQgd2UgZXhwZWN0IHRoZSBtYWluIHRocmVhZCB0byBhbHNvIG5ldmVyIGZpbmlzaC4KKyAg ICAvLyBIZW5jZSwgaXQgaXMgc2FmZSB0byBzdG9yZSB0aGUgc2FtZSBUaHJlYWRHbG9iYWxEYXRh IHBvaW50ZXIgaW4gYSB0aHJlYWQgc3BlY2lmaWMgc3RkOjp1bmlxdWVfcHRyLgorICAgIC8vIEZJ WE1FOiBNYWtlIFRocmVhZEdsb2JhbERhdGEgUmVmQ291bnRlZCBmb3Igd2ViIHRocmVhZC4KKyAg ICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc1NDM5CisgICAg KCoqc3RhdGljRGF0YSkucmVzZXQoc2hhcmVkTWFpblRocmVhZFN0YXRpY0RhdGEpOwogCi0gICAg QVNTRVJUKCZ0aHJlYWRHbG9iYWxEYXRhKCkgPT0gVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFp blRocmVhZFN0YXRpY0RhdGEpOworICAgIEFTU0VSVCgmdGhyZWFkR2xvYmFsRGF0YSgpID09IHNo YXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhKTsKIH0KLSNlbmRpZgogCi1UaHJlYWRHbG9iYWxEYXRh JiB0aHJlYWRHbG9iYWxEYXRhKCkgCitUaHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRh KCkKIHsKLSNpZiBVU0UoV0VCX1RIUkVBRCkKLSAgICBpZiAoVU5MSUtFTFkoIVRocmVhZEdsb2Jh bERhdGE6OnN0YXRpY0RhdGEpKSB7Ci0gICAgICAgIFRocmVhZEdsb2JhbERhdGE6OnN0YXRpY0Rh dGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47CisgICAgaWYgKFVOTElL RUxZKCFzdGF0aWNEYXRhKSkgeworICAgICAgICBzdGF0aWNEYXRhID0gbmV3IFRocmVhZFNwZWNp ZmljPHN0ZDo6dW5pcXVlX3B0cjxUaHJlYWRHbG9iYWxEYXRhPj47CisgICAgICAgIGF1dG8mIHJl c3VsdCA9ICoqc3RhdGljRGF0YTsKKyAgICAgICAgQVNTRVJUKCFyZXN1bHQpOworICAgICAgICBy ZXN1bHQucmVzZXQobmV3IFRocmVhZEdsb2JhbERhdGEoKSk7CiAgICAgICAgIC8vIFdlYlRocmVh ZCBhbmQgbWFpbiBVSSB0aHJlYWQgbmVlZCB0byBzaGFyZSB0aGUgc2FtZSBvYmplY3QuIFNhdmUg aXQgaW4gYSBzdGF0aWMKICAgICAgICAgLy8gaGVyZSwgdGhlIFdlYlRocmVhZCB3aWxsIHBpY2sg aXQgdXAgaW4gc2V0V2ViQ29yZVRocmVhZERhdGEoKS4KICAgICAgICAgaWYgKHB0aHJlYWRfbWFp bl9ucCgpKQotICAgICAgICAgICAgVGhyZWFkR2xvYmFsRGF0YTo6c2hhcmVkTWFpblRocmVhZFN0 YXRpY0RhdGEgPSAqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YTsKKyAgICAgICAgICAgIHNo YXJlZE1haW5UaHJlYWRTdGF0aWNEYXRhID0gcmVzdWx0LmdldCgpOworICAgICAgICByZXR1cm4g KnJlc3VsdDsKICAgICB9Ci0gICAgcmV0dXJuICoqVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0 YTsKKworICAgIGF1dG8mIHJlc3VsdCA9ICoqc3RhdGljRGF0YTsKKyAgICBpZiAoIXJlc3VsdCkK KyAgICAgICAgcmVzdWx0LnJlc2V0KG5ldyBUaHJlYWRHbG9iYWxEYXRhKCkpOworICAgIHJldHVy biAqcmVzdWx0OworfQorCiAjZWxzZQotICAgIGlmICghVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGlj RGF0YSkKLSAgICAgICAgVGhyZWFkR2xvYmFsRGF0YTo6c3RhdGljRGF0YSA9IG5ldyBUaHJlYWRT cGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsKLSAgICByZXR1cm4gKipUaHJlYWRHbG9iYWxEYXRh OjpzdGF0aWNEYXRhOwotI2VuZGlmCisKK3N0YXRpYyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9i YWxEYXRhPiogc3RhdGljRGF0YSB7IG51bGxwdHIgfTsKKworVGhyZWFkR2xvYmFsRGF0YSYgdGhy ZWFkR2xvYmFsRGF0YSgpCit7CisgICAgaWYgKFVOTElLRUxZKCFzdGF0aWNEYXRhKSkKKyAgICAg ICAgc3RhdGljRGF0YSA9IG5ldyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsKKyAg ICByZXR1cm4gKipzdGF0aWNEYXRhOwogfQogCisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0 YS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5oCmluZGV4IDU4 ZjdjMDc0MDI1NDA4ODliM2NmZDQ0MTliOTA4NWNmNTc5Y2NmMjEuLjdkYjViOThiYzY1NzQxNjNh N2IxMWNkM2IxM2RiMGRkZjBjYWU2OGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1RocmVhZEdsb2JhbERhdGEuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9UaHJl YWRHbG9iYWxEYXRhLmgKQEAgLTI5LDkgKzI5LDYgQEAKIAogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0 cmluZ0hhc2guaD4KIAotI2luY2x1ZGUgPHd0Zi9UaHJlYWRTcGVjaWZpYy5oPgotdXNpbmcgV1RG OjpUaHJlYWRTcGVjaWZpYzsKLQogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgY2xhc3MgUXVh bGlmaWVkTmFtZUNhY2hlOwpAQCAtNDQsNiArNDEsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK ICAgICBjbGFzcyBUaHJlYWRHbG9iYWxEYXRhIHsKICAgICAgICAgV1RGX01BS0VfTk9OQ09QWUFC TEUoVGhyZWFkR2xvYmFsRGF0YSk7CisgICAgICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwog ICAgIHB1YmxpYzoKICAgICAgICAgV0VCQ09SRV9FWFBPUlQgVGhyZWFkR2xvYmFsRGF0YSgpOwog ICAgICAgICBXRUJDT1JFX0VYUE9SVCB+VGhyZWFkR2xvYmFsRGF0YSgpOwpAQCAtODAsMTAgKzc4 LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBzdGQ6OnVuaXF1ZV9wdHI8VEVDQ29u dmVydGVyV3JhcHBlcj4gbV9jYWNoZWRDb252ZXJ0ZXJURUM7CiAjZW5kaWYKIAotICAgICAgICBX RUJDT1JFX0VYUE9SVCBzdGF0aWMgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIHN0 YXRpY0RhdGE7Ci0jaWYgVVNFKFdFQl9USFJFQUQpCi0gICAgICAgIFdFQkNPUkVfRVhQT1JUIHN0 YXRpYyBUaHJlYWRHbG9iYWxEYXRhKiBzaGFyZWRNYWluVGhyZWFkU3RhdGljRGF0YTsKLSNlbmRp ZgogICAgICAgICBXRUJDT1JFX0VYUE9SVCBmcmllbmQgVGhyZWFkR2xvYmFsRGF0YSYgdGhyZWFk R2xvYmFsRGF0YSgpOwogICAgIH07CiAK