216106 2020-09-02 16:09:48 -0700 [iOS WK1] Crashes when using ANGLE WebGL from another thread 2020-10-05 14:31:17 -0700 1 1 1 Unclassified WebKit WebGL WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P1 Normal --- 1 dino kkinnunen ddkilzer dino ews-watchlist geofflang graouts jdarpinian jonahr kbr kkinnunen koivisto kondapallykalyan mjs noam webkit-bug-importer oldest_to_newest 1685048 0 dino 2020-09-02 16:09:48 -0700 We are seeing a lot of incoming crash reports on the iOS 14 beta when WebGL is used with UIWebView (WK1). The issue is that ANGLE is not yet able to handle multithreaded use of a single context (even when WebKit is ensuring only one of them is actually using the context). This is tracked by ANGLE bug: https://bugs.chromium.org/p/angleproject/issues/detail?id=5010 There are three cases: 1. Web thread calls EGL_Initialize first, and then the main thread tries to create another WebGL context. This will crash in `RendererGL::getRendererDescription()`, where the `reinterpret_cast<char*>` fails because it is passed a null pointer. 2. Main thread calls EGL_Initialize first, and then the Web thread tries to create another WebGL context. This appears to crash in gl::FramebufferManager::getFramebuffer. 3. Thread A creates the only WebGL context, and it is used from thread B. (I think this might be a similar stack to 2). Again, this only applies to WebKit 1. Stack Trace for case 1. ----- Thread 0 name: ScePS4LinkRPCtrl Dispatch queue: com.apple.main-thread Thread 0 Crashed ↩: 0 libsystem_platform.dylib 0x00000001cf5c9bc4 _platform_strlen + 4 1 WebCore 0x0000000196afe468 std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::basic_string<std::nullptr_t>(char const*) + 40 (__string:253) 2 WebCore 0x0000000196c82ac4 rx::RendererGL::getRendererDescription() const + 76 (RendererGL.cpp:263) 3 WebCore 0x0000000196b164d0 gl::Context::initRendererString() + 220 (Context.cpp:2890) 4 WebCore 0x0000000196b1621c gl::Context::makeCurrent(egl::Display*, egl::Surface*, egl::Surface*) + 92 (Context.cpp:650) 5 WebCore 0x0000000196b5d87c egl::Display::makeCurrent(egl::Thread const*, egl::Surface*, egl::Surface*, gl::Context*) + 204 (Display.cpp:1227) 6 WebCore 0x0000000196b680bc EGL_MakeCurrent + 212 (entry_points_egl.cpp:454) 7 WebCore 0x000000019555a224 WebCore::GraphicsContextGLOpenGL::GraphicsContextGLOpenGL(WebCore::GraphicsContextGLAttributes, WebCore::HostWindow*, WebCore::GraphicsContextGL::Destination, WebCore::GraphicsContextGLOpenGL*) + 1748 (GraphicsContextGLOpenGLCocoa.mm:382) 8 WebCore 0x0000000195559888 WebCore::GraphicsContextGLOpenGL::create(WebCore::GraphicsContextGLAttributes, WebCore::HostWindow*, WebCore::GraphicsContextGL::Destination) + 168 (GraphicsContextGLOpenGLCocoa.mm:188) 9 WebCore 0x0000000195f6fa30 WebCore::WebGLRenderingContextBase::create(WebCore::CanvasBase&, WebCore::GraphicsContextGLAttributes&, WTF::String const&) + 1164 (WebGLRenderingContextBase.cpp:705) 10 WebCore 0x0000000195e0a5e0 WebCore::HTMLCanvasElement::getContext(JSC::JSGlobalObject&, WTF::String const&, WTF::Vector<JSC::Strong<JSC::Unknown, (JSC::ShouldStrongDestructorGrabLock)0>, 0ul, WTF::CrashOnOverflow, 16ul, WTF::FastMalloc>&&) + 896 (HTMLCanvasElement.cpp:442) 11 WebCore 0x0000000194f1ae74 WebCore::jsHTMLCanvasElementPrototypeFunctionGetContext(JSC::JSGlobalObject*, JSC::CallFrame*) + 500 (JSHTMLCanvasElement.cpp:312) 12 JavaScriptCore 0x00000001916b940c llint_entry + 159388 13 JavaScriptCore 0x00000001916b6880 llint_entry + 148240 14 JavaScriptCore 0x00000001916b6880 llint_entry + 148240 15 JavaScriptCore 0x00000001916b6880 llint_entry + 148240 16 JavaScriptCore 0x00000001916b67cc llint_entry + 148060 17 JavaScriptCore 0x00000001916922c4 vmEntryToJavaScript + 276 18 JavaScriptCore 0x0000000191cbeacc JSC::Interpreter::executeCall(JSC::JSGlobalObject*, JSC::JSObject*, JSC::CallData const&, JSC::JSValue, JSC::ArgList const&) + 488 (JITCodeInlines.h:42) 19 JavaScriptCore 0x0000000191ee50b8 JSC::profiledCall(JSC::JSGlobalObject*, JSC::ProfilingReason, JSC::JSValue, JSC::CallData const&, JSC::JSValue, JSC::ArgList const&, WTF::NakedPtr<JSC::Exception>&) + 176 (CallData.cpp:57) 20 WebCore 0x000000019592984c WebCore::JSEventListener::handleEvent(WebCore::ScriptExecutionContext&, WebCore::Event&) + 1636 (JSExecState.h:73) 21 WebCore 0x0000000195bf7354 WebCore::EventTarget::innerInvokeEventListeners(WebCore::Event&, WTF::Vector<WTF::RefPtr<WebCore::RegisteredEventListener, WTF::DumbPtrTraits<WebCore::RegisteredEventListener> >, 1ul, WTF::CrashOnOverflow, 16ul, WTF::FastMalloc>, WebCore::EventTarget::EventInvokePhase) + 440 (EventTarget.cpp:341) 22 WebCore 0x0000000195bf4690 WebCore::EventTarget::fireEventListeners(WebCore::Event&, WebCore::EventTarget::EventInvokePhase) + 384 (EventTarget.cpp:273) 23 WebCore 0x0000000195befc90 WebCore::dispatchEventInDOM(WebCore::Event&, WebCore::EventPath const&) + 128 (EventDispatcher.cpp:85) 24 WebCore 0x0000000195bef684 WebCore::EventDispatcher::dispatchEvent(WebCore::Node&, WebCore::Event&) + 1224 (EventDispatcher.cpp:154) 25 WebCore 0x00000001952390f8 WebCore::EventHandler::dispatchTouchEvent(WebCore::PlatformTouchEvent const&, WTF::AtomString const&, WTF::HashMap<WTF::Ref<WebCore::EventTarget, WTF::DumbPtrTraits<WebCore::EventTarget> >, std::__1::unique_ptr<WTF::Vector<WTF::RefPtr<WebCore::Touch, WTF::DumbPtrTraits<WebCore::Touch> >, 0ul, WTF::CrashOnOverflow, 16ul, WTF::FastMalloc>, std::__1::default_delete<WTF::Vector<WTF::RefPtr<WebCore::Touch, WTF::DumbPtrTraits<WebCore::Touch> >, 0ul, WTF::CrashOnOverflow, 16ul, WTF::FastMalloc> > >, WTF::DefaultHash<WTF::Ref<WebCore::EventTarget, WTF::DumbPtrTraits<WebCore::EventTarget> > >, WTF::HashTraits<WTF::Ref<WebCore::EventTarget, WTF::DumbPtrTraits<WebCore::EventTarget> > >, WTF::HashTraits<std::__1::unique_ptr<WTF::Vector<WTF::RefPtr<WebCore::Touch, WTF::DumbPtrTraits<WebCore::Touch> >, 0ul, WTF::CrashOnOverflow, 16ul, WTF::FastMalloc>, std::__1::default_delete<WTF::Vector<WTF::RefPtr<WebCore::Touch, WTF::DumbPtrTraits<WebCore::Touch> >, 0ul, WTF::CrashOnOverflow, 16ul, WTF::FastMalloc> > > > > const&, float, float) + 3216 (EventHandlerIOSTouch.cpp:188) 26 WebCore 0x000000019523b694 WebCore::EventHandler::handleTouchEvent(WebCore::PlatformTouchEvent const&) + 7828 (EventHandlerIOSTouch.cpp:519) 27 WebCore 0x000000019523c724 WebCore::EventHandler::touchEvent(WebEvent*) + 128 (EventHandlerIOS.mm:128) Stack trace for other cases ---------- 41 WebCore: gl::FramebufferManager::getFramebuffer(gl::FramebufferID) const <== 41 WebCore: gl::Context::unsetDefaultFramebuffer() 41 WebCore: gl::Context::unsetDefaultFramebuffer() 41 WebCore: gl::Context::unMakeCurrent(egl::Display const*) 41 WebCore: egl::Display::makeCurrent(egl::Thread const*, egl::Surface*, egl::Surface*, gl::Context*) 41 WebCore: EGL_MakeCurrent 41 WebCore: WebCore::GraphicsContextGLOpenGL::GraphicsContextGLOpenGL(WebCore::GraphicsContextGLAttributes, WebCore::HostWindow*, WebCore::GraphicsContextGL::Destination, WebCore::GraphicsContextGLOpenGL*) 41 WebCore: WebCore::GraphicsContextGLOpenGL::create(WebCore::GraphicsContextGLAttributes, WebCore::HostWindow*, WebCore::GraphicsContextGL::Destination) 41 WebCore: WebCore::WebGLRenderingContextBase::create(WebCore::CanvasBase&, WebCore::GraphicsContextGLAttributes&, WTF::String const&) 41 WebCore: WebCore::HTMLCanvasElement::getContext(JSC::JSGlobalObject&, WTF::String const&, WTF::Vector<JSC::Strong<JSC::Unknown, (JSC::ShouldStrongDestructorGrabLock)0>, 0ul, WTF::CrashOnOverflow, 16ul, WTF::FastMalloc>&&) 41 WebCore: WebCore::jsHTMLCanvasElementPrototypeFunctionGetContext(JSC::JSGlobalObject*, JSC::CallFrame*) 41 41 JavaScriptCore: llint_entry 41 JavaScriptCore: llint_entry 41 JavaScriptCore: llint_entry 41 JavaScriptCore: llint_entry 41 JavaScriptCore: llint_entry 41 JavaScriptCore: llint_entry 41 JavaScriptCore: vmEntryToJavaScript 41 JavaScriptCore: JSC::Interpreter::executeProgram(JSC::SourceCode const&, JSC::JSGlobalObject*, JSC::JSObject*) 41 JavaScriptCore: JSC::evaluate(JSC::JSGlobalObject*, JSC::SourceCode const&, JSC::JSValue, WTF::NakedPtr<JSC::Exception>&) 41 WebCore: WebCore::JSExecState::profiledEvaluate(JSC::JSGlobalObject*, JSC::ProfilingReason, JSC::SourceCode const&, JSC::JSValue, WTF::NakedPtr<JSC::Exception>&) 41 WebCore: WebCore::ScriptController::evaluateInWorld(WebCore::ScriptSourceCode const&, WebCore::DOMWrapperWorld&) 41 WebCore: WebCore::ScriptController::evaluateIgnoringException(WebCore::ScriptSourceCode const&) 41 WebCore: WebCore::ScriptElement::executeClassicScript(WebCore::ScriptSourceCode const&) 41 WebCore: WebCore::ScriptElement::prepareScript(WTF::TextPosition const&, WebCore::ScriptElement::LegacyTypeSupport) 41 WebCore: WebCore::HTMLScriptElement::didFinishInsertingNode() 41 WebCore: WebCore::ContainerNode::appendChildWithoutPreInsertionValidityCheck(WebCore::Node&) 41 WebCore: WebCore::Node::appendChild(WebCore::Node&) 41 WebCore: WebCore::jsNodePrototypeFunctionAppendChild(JSC::JSGlobalObject*, JSC::CallFrame*) 1685054 1 kbr 2020-09-02 16:23:12 -0700 As discussed with Dean, some of these cases were already subtly broken prior to the switch to ANGLE, because WebGLRenderingContextBase makes its EAGL context current on the first thread it's used on. However, there are new failure modes with ANGLE because of its internal context virtualization. Two changes - one in ANGLE, one in WebKit - are necessary to fix this: 1) ANGLE must offer a way to disable its context virtualization, and that must be used in UIWebView (ideally, only there, since virtualization offers performance benefits). Tracked in https://bugs.chromium.org/p/angleproject/issues/detail?id=5010 and dependent bug. 2) WebKit must release the GraphicsContextGL when a thread's done with its WebGL work. A new "releaseContext()" must be added along "makeContextCurrent()" in GraphicsContextGLOpenGL. To avoid releasing the context too often, it would be ideal to do it less often than after each WebGL API call. dino@ mentioned that when touch events are dispatched (on a different thread than the web main thread), a lock is grabbed that prevents concurrent access to the DOM. Could anyone offer a pointer to that code? If we could store the current GraphicsContextGLOpenGL somewhere, and release it when the touch event handler exits (just before releasing that lock), that would handle that thread's case. For the main thread, it would also be ideal to release any current GraphicsContextGLOpenGL when that DOM lock is released. I'm not sure how often that lock is acquired and released - any pointers to the code which manages it on the main thread? 1685055 2 kbr 2020-09-02 16:24:09 -0700 Since many crash reports are coming in regarding this, raising this to P1. We certainly don't want to regress UIWebView's stability with the switch to ANGLE. 1685064 3 dino 2020-09-02 16:55:19 -0700 (In reply to Kenneth Russell from comment #1) > As discussed with Dean, some of these cases were already subtly broken prior > to the switch to ANGLE, because WebGLRenderingContextBase makes its EAGL > context current on the first thread it's used on. However, there are new > failure modes with ANGLE because of its internal context virtualization. > > Two changes - one in ANGLE, one in WebKit - are necessary to fix this: > > 1) ANGLE must offer a way to disable its context virtualization, and that > must be used in UIWebView (ideally, only there, since virtualization offers > performance benefits). Tracked in > https://bugs.chromium.org/p/angleproject/issues/detail?id=5010 and dependent > bug. > > 2) WebKit must release the GraphicsContextGL when a thread's done with its > WebGL work. A new "releaseContext()" must be added along > "makeContextCurrent()" in GraphicsContextGLOpenGL. According to the Apple documentation, this isn't true. https://developer.apple.com/library/archive/documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/ConcurrencyandOpenGLES/ConcurrencyandOpenGLES.html#//apple_ref/doc/uid/TP40008793-CH409-SW4 It's ok for the EAGLContext to be the current context in multiple threads. It's just not ok to use it from multiple threads at the same time, and we already guard against that by taking a Web Thread lock when we process events on the main thread. However, we might have to call glFlush in this situation. > If we could store the current GraphicsContextGLOpenGL somewhere, and release > it when the touch event handler exits (just before releasing that lock), > that would handle that thread's case. > > For the main thread, it would also be ideal to release any current > GraphicsContextGLOpenGL when that DOM lock is released. I'm not sure how > often that lock is acquired and released - any pointers to the code which > manages it on the main thread? This happens inside UIKit, not WebKit, unfortunately. The code that calls _webTouchEventsRecognized has taken the WebThreadLock. 1685191 4 kbr 2020-09-02 22:53:33 -0700 Thanks dino@ for that documentation pointer. https://developer.apple.com/documentation/opengles/eaglcontext/1624882-setcurrentcontext?language=objc EAGL's setCurrentContext behaves differently from any other OpenGL or OpenGL ES window system binding, including eglMakeCurrent - but OK, in that case, perhaps we could give ANGLE a different multithreading mode (selected during EGL context creation time) where it can actually make its hardware context current on multiple threads simultaneously, and rely on external synchronization. CC'ing geofflang@ and jonahr@. 1685192 5 kkinnunen 2020-09-02 23:02:32 -0700 Not saying you didn't figure this out, and as far as I understand the problem, which may be wrong: In general using ANGLE from multiple threads would need to disable the context virtualization. I think in this this particular case, virtualization should still work: - Backend is using EAGL (context can be current in many threads) - Every ANGLE context is locked by the same lock If web workers can render to canvases without WebThreadLock, then those contexts should have virtualisation disabled. So wouldn't the solution be just to: 0) EGL_Initialize() once in main thread 1) EGL_MakeCurrent(nullptr) whenever releasing the WebThreadLock 2) Remember to save + retain the client EAGL context and set it back whenever main thread calls into WebKit (e.g. in the touch handler) E.g. it's of no interest whether EAGLContext can be current on multiple threads -- you still need to (possibly) flush, which the EGL_MakeCurrent(null) would guarantee via however ANGLE guarantees it. 1685193 6 kkinnunen 2020-09-02 23:14:46 -0700 And to be complete, sorry if I muddy the waters with the possibility of needing flush even though EAGL docs not explicitly saying it: If the flush incurred by the EGL_MakeCurrent(nullptr) contract would be too much overhead, one would invent the ANGLE_EGL_no_flush where then EGL_MakeCurrentNoFlush(nullptr) would just call EAGLContext setContext:nullptr . 1685348 7 kbr 2020-09-03 10:56:28 -0700 Good suggestions Kimmo. I haven't thought through all the implications of your suggestion but a few points: 1) There's no good point to call EGL_Initialize on the main thread if a touch event handler is the first one to call WebGL. 2) ANGLE would have to be changed to call [EAGLContext setCurrentContext:] during EGL_MakeCurrent. With its current assumptions about single-threadedness and context virtualization, it's called only once, during EGL_Initialize. There will surely need to be other changes to make this work properly. 3) Based on dino@'s point about UIKit being the one to grab the WebThreadLock during touch event dispatch, it's not clear there's a good point in WebKit to call EGL_MakeCurrent(null) on that thread. (Maybe there is.) Also not sure about when to do this on the main thread - who grabs / releases the WebThreadLock there? 1685386 8 kbr 2020-09-03 12:07:15 -0700 Kimmo pointed out I probably misunderstood the naming of the various threads. If the "UI thread" (== "main thread") is the one dispatching touch events, and the "web main thread" is a different thread that ordinarily runs WebKit's JS / DOM / etc: My point still stands - it might still be the case that the web main thread never did any WebGL work, and the touch event handler on the UI thread is the first one to touch WebGL. It should still be fine, under the cover of the WebThreadLock, for either thread to EGL_Initialize and make the WebGL context. Still need to release ANGLE's EGL context on both the web main thread and UI thread at appropriate points, in order to maintain correct EGL semantics. ANGLE still needs to be updated to call [EAGLContext setCurrentContext:] during EGL_MakeCurrent. jonahr@ has already done this work for ANGLE's other backends; needs to be done for the iOS backend. 1686843 9 408295 dino 2020-09-08 17:41:46 -0700 Created attachment 408295 Test app Attached is an Xcode project that will trigger these crashes. 1687187 10 webkit-bug-importer 2020-09-09 16:10:14 -0700 <rdar://problem/68602452> 1688878 11 dino 2020-09-15 15:31:25 -0700 This is actually rdar://67827426 1688885 12 kbr 2020-09-15 15:40:36 -0700 To have a central place for documentation, the point in the code dino@ pointed out dealing with the WebThreadLock, etc. is Source/WebCore/platform/ios/wak/WebCoreThread.mm : https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/platform/ios/wak/WebCoreThread.mm 1688916 13 dino 2020-09-15 16:36:35 -0700 My understanding is that the remaining steps for a fix are: - [ANGLE] patch to allow multithreading support for EAGL backend - [WebKit] release the EGL (which is from ANGLE, not EAGL) context as we release the WebThreadLock, somewhere around MainRunLoopAutoUnlock - [WebKit] have the WebThread release the EGL context if the main thread wants it. This would likely be just releasing it unconditionally in prepareCanvasForRendering if we're in WK1 and are holding the context. 1688933 14 kbr 2020-09-15 17:25:49 -0700 Those sound like the right steps needed. Let's figure out how to best get the ANGLE side changes done. https://bugs.chromium.org/p/angleproject/issues/detail?id=5010 was filed about this, but probably we should test all three components together in WebKit before upstreaming any changes to ANGLE. 1689196 15 408950 kbr 2020-09-16 13:23:05 -0700 Created attachment 408950 ANGLE EAGL multithreading patch Here's the (small) proposed ANGLE-side change adding multithreading support to its EAGL backend. Dean, could you please test this in conjunction with your WebKit-side changes? I've tested it locally in the MobileMiniBrowser on the iOS Simulator, without any other changes, and it seems to work. 1689219 16 dino 2020-09-16 14:26:30 -0700 Thanks Ken. I'll use this with the WebKit parts. 1690823 17 409390 kkinnunen 2020-09-22 12:40:33 -0700 Created attachment 409390 Patch 1690826 18 kkinnunen 2020-09-22 12:49:55 -0700 > [WebKit] release the EGL (which is from ANGLE, not EAGL) context as we release the WebThreadLock, somewhere around MainRunLoopAutoUnlock This probably is not correct. If I understand correctly, MainRunLoopAutoUnlock happens at runloop stage. However, client might make 2, 3 or 77 calls that all cause WebGL on arbitrary thread. > [WebKit] have the WebThread release the EGL context if the main thread wants it. This would likely be just releasing it unconditionally in prepareCanvasForRendering if we're in WK1 and are holding the context. This is probably not correct. Most arbitrary WebKit callgraphs can invoke graphicscontext tasks. I did a test but obviously it's not conclusive, attached as an example. I'm still trying to understand what'd be the correct place to do the unset for the arbitrary client threads. My current thinking is that it's closing of the scopes where we call WebThreadLock() 1690829 19 kkinnunen 2020-09-22 12:55:47 -0700 > MainRunLoopAutoUnlock happens at runloop stage. However, client might make 2, 3 or 77 calls that all cause WebGL on arbitrary thread. What I mean is that clients might clobber EAGL context between each consecutive call. Thus we need to unset ANGLE context after each call, so that we can also set it during each call and get ANGLE to forward the call to EAGL. 1690834 20 409393 kkinnunen 2020-09-22 13:11:19 -0700 Created attachment 409393 Patch 1690836 21 ews-watchlist 2020-09-22 13:12:35 -0700 Note that there are important steps to take when updating ANGLE. See https://trac.webkit.org/wiki/UpdatingANGLE 1691347 22 409393 kbr 2020-09-23 18:41:16 -0700 Comment on attachment 409393 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=409393&action=review > Source/ThirdParty/ANGLE/src/libANGLE/Display.cpp:1228 > + ANGLE_TRY(previousContext->flush()); This is causing the build failure - have to remove the ANGLE_TRY. Is this known to be necessary? Not making this change would be better. > Source/WebCore/platform/ios/wak/WebCoreThread.mm:75 > +class ScopedClientThreadCrossThreadGlobalStateRestore { Not used - hopefully this isn't needed. 1691348 23 kbr 2020-09-23 18:44:20 -0700 To the best of my knowledge, no other code in WebKit is using EAGL directly. Therefore it shouldn't be necessary to release the GraphicsContextGL / ANGLE context upon each WebGL API call, but only upon exiting the scopes in UIWebView where the WebThreadLock is released, as it looks like your current patch does. It would be much preferred to avoid releasing the context after every WebGL API call. Doing this might dramatically, negatively impact performance. 1692909 24 409997 kkinnunen 2020-09-29 07:19:21 -0700 Created attachment 409997 Patch 1693253 25 409997 kbr 2020-09-29 17:57:27 -0700 Comment on attachment 409997 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=409997&action=review Fantastic work Kimmo fixing this! Several comments throughout. > Source/ThirdParty/ANGLE/include/EGL/eglext_angle.h:121 > +#define EGL_PLATFORM_ANGLE_DEVICE_CONTEXT_VOLATILE_EAGL_ANGLE 0x3490 ANGLE maintains an internal list of unallocated enum constants. I've allocated 0x34A2 for this; please use it. Thanks. Could you please document these two in a new extensions/EGL_ANGLE_platform_angle_device_context_volatile.txt? You can model it after EGL_ANGLE_platform_angle_context_virtualization.txt . > Source/ThirdParty/ANGLE/include/EGL/eglext_angle.h:126 > +#define EGL_PLATFORM_ANGLE_DEVICE_CONTEXT_VOLATILE_CGL_ANGLE 0x3491 Have allocated 0x34A3 out of ANGLE's pre-reserved range for this; please use that. Thanks. > Source/ThirdParty/ANGLE/src/libANGLE/Context.cpp:699 > + ANGLE_TRY(angle::ResultToEGL(mImplementation->flush(this))); Are you sure this change is needed here? Since you're implementing and calling eglReleaseThread, could the flush be done just there? ANGLE virtualizes contexts which eliminates the need for many flushes. Concerned that this might impact performance. Wondering if you could test with WebGL content like the Aquarium with a large number of fish. > Source/ThirdParty/ANGLE/src/libANGLE/renderer/DisplayImpl.h:71 > + virtual egl::Error releaseThread() = 0; Consider implementing these in the base class and returning egl::NoError(), like DisplayImpl::handleGPUSwitch. > Source/ThirdParty/ANGLE/src/libANGLE/renderer/DisplayImpl.h:77 > + There are a few unnecessary whitespace changes; not a big deal. > Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/DisplayGL.cpp:38 > + UNIMPLEMENTED(); These shouldn't call UNIMPLEMENTED. All of the entry points call through this, which will cause lots of warnings, trace events, and even assertion failures in debug builds in DisplayGLX, DisplayWGL, etc. See my comment in DisplayImpl.h. > Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/DisplayGL.h:36 > + egl::Error releaseThread() override; These need to be overridden in more subclasses, such as DisplayD3D, DisplayVk, etc. See comment in the implementing file. > Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm:250 > + if (mDeviceContextIsVolatile || mThreadsWithCurrentContext.find(threadId) == mThreadsWithCurrentContext.end()) What happens if a second thread attempts to eglBindAPI while another's already bound? Does the CGLSetCurrentContext call below fail, or does any higher-level validation code in ANGLE prevent it (I'm guessing not)? > Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm:267 > + if (CGLSetCurrentContext(nullptr) != kCGLNoError) Can this have unexpected side effects like: - App calls ANGLE's eglBindAPI, eglMakeCurrent and does work - App uses CGL to make their own context current and does work with it - App calls eglReleaseThread This will cause the app's CGL context to be un-made current. I don't want to suggest to call CGLGetCurrentContext here - at least, not necessarily - but do you have any thoughts about this? > Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/eagl/DisplayEAGL.mm:141 > + if (![getEAGLContextClass() setCurrentContext:nil]) Would flushing here, instead of in unmakeCurrent, work? Also, similar question as that one in DisplayCGL::releaseThread. > Source/ThirdParty/ANGLE/src/libGLESv2/entry_points_egl.cpp:1083 > + ANGLE_EGL_TRY_RETURN(thread, display->bindThread(), "eglCreateWindowSurface", Should this and above have referenced "eglCreatePlatformWindowSurface"? > Source/ThirdParty/ANGLE/src/libGLESv2/entry_points_egl_ext.cpp:1667 > + ANGLE_EGL_TRY(thread, display->bindThread(), "eglReacquireHighPowerGPUANGLE", eglReacquireHighPowerGPUANGLE -> eglHandleGPUSwitchANGLE > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:149 > + // After initializitaion, EGL_DEFAULT_DISPLAY will return the platform-customized display. initializitaion -> initialization > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:774 > +#if PLATFORM(IOS_FAMILY) && USE(ANGLE) dino@ should review these #ifdefs - not sure whether MacCatalyst-related #ifdefs might be needed. > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:777 > + ASSERT(!WebCore::isInWebProcess()); WebKit2 isn't supported at all on iOS? Not even in-browser, ignoring UIWebView? > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:780 > + if (!WebThreadIsEnabled()) Is it OK from a platform layering perspective for this code to access functions in platform/ios/wak? This call causes a circular dependency between code in that directory and this one. 1693338 26 410107 kkinnunen 2020-09-30 04:38:42 -0700 Created attachment 410107 Patch 1693339 27 409997 kkinnunen 2020-09-30 04:39:52 -0700 Comment on attachment 409997 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=409997&action=review >> Source/ThirdParty/ANGLE/include/EGL/eglext_angle.h:121 >> +#define EGL_PLATFORM_ANGLE_DEVICE_CONTEXT_VOLATILE_EAGL_ANGLE 0x3490 > > ANGLE maintains an internal list of unallocated enum constants. I've allocated 0x34A2 for this; please use it. Thanks. > > Could you please document these two in a new extensions/EGL_ANGLE_platform_angle_device_context_volatile.txt? You can model it after EGL_ANGLE_platform_angle_context_virtualization.txt . done >> Source/ThirdParty/ANGLE/include/EGL/eglext_angle.h:126 >> +#define EGL_PLATFORM_ANGLE_DEVICE_CONTEXT_VOLATILE_CGL_ANGLE 0x3491 > > Have allocated 0x34A3 out of ANGLE's pre-reserved range for this; please use that. Thanks. done >> Source/ThirdParty/ANGLE/src/libANGLE/Context.cpp:699 >> + ANGLE_TRY(angle::ResultToEGL(mImplementation->flush(this))); > > Are you sure this change is needed here? Since you're implementing and calling eglReleaseThread, could the flush be done just there? > > ANGLE virtualizes contexts which eliminates the need for many flushes. Concerned that this might impact performance. Wondering if you could test with WebGL content like the Aquarium with a large number of fish. So if you consider case eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, mMyContext); glClearColor(1, 0,0, 1); glClear(); eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); CRASH(); I think EGL spec guarantees that the clear hits wherever it needs to hit. If we don't flush, there's no guarantee. The red/no-red could be observed from, say, cross-process texture. > Since you're implementing and calling eglReleaseThread, could the flush be done just there? Well, it's a bit matter of viewpoint. eglReleaseThread does not flush because of "releasing the thread". It flushes because it changes the context. I think again it's the case where if you release in one thread and continue using in other thread, you must flush or implementations that have per-thread queues might reorder calls that happen before ReleaseThread with calls that happen after MakeCurrent in other thread. Also, in this patch the the other case needs to flush too, eg the case of running in WebCoreThread where we do not do ReleaseThread but MakeCurrent. > Concerned that this might impact performance. For current WebKit use-cases, the perf impact probably is not very big, since it doesn't change the contexts (so unless Aquarium uses multiple webgl contexts). The impact would be bigger for Chromium, though, since the command buffer multiplexes all contexts in same submit thread, with MakeCurrent in between contexts (last time I looked, maybe it's different with passthrough?) To unblock this I can of course do like: // ANGLE does not flush on MakeCurrent as EGL says it should, so we flush here. glFlush(); if (!IsInWebThread()) eglReleaseThread(); else eglMakeCurrent(nullptr); >> Source/ThirdParty/ANGLE/src/libANGLE/renderer/DisplayImpl.h:71 >> + virtual egl::Error releaseThread() = 0; > > Consider implementing these in the base class and returning egl::NoError(), like DisplayImpl::handleGPUSwitch. done >> Source/ThirdParty/ANGLE/src/libANGLE/renderer/DisplayImpl.h:77 >> + > > There are a few unnecessary whitespace changes; not a big deal. done >> Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/DisplayGL.cpp:38 >> + UNIMPLEMENTED(); > > These shouldn't call UNIMPLEMENTED. All of the entry points call through this, which will cause lots of warnings, trace events, and even assertion failures in debug builds in DisplayGLX, DisplayWGL, etc. See my comment in DisplayImpl.h. done >> Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/DisplayGL.h:36 >> + egl::Error releaseThread() override; > > These need to be overridden in more subclasses, such as DisplayD3D, DisplayVk, etc. See comment in the implementing file. done >> Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm:250 >> + if (mDeviceContextIsVolatile || mThreadsWithCurrentContext.find(threadId) == mThreadsWithCurrentContext.end()) > > What happens if a second thread attempts to eglBindAPI while another's already bound? Does the CGLSetCurrentContext call below fail, or does any higher-level validation code in ANGLE prevent it (I'm guessing not)? eglBindAPI(type) just selects _EGL_ api type. It's equivalent of : thread_local apiType = type. It does not affect any other thing. In fact, the "bindThread", which I renamed to "prepareForCall", is not even invoked on eglBindAPI. I try to document the function better. With regards to what I understand is the underlying question: This part of calling CGLSetCurrentContext logic does not terribly change between what was before and what is after. * CGL context will be current in multiple threads at the same time. * CGL context needs to be called-into serially. * EGL rules are the mechanism for this serialization: no EGL context is current in two threads simultaneously. All these were effective before, and they should be effective after. the new functionality is 1) update CGL context on all EGL functions, not just make current --> Fixes a bug where function like eglTerminate would be called in other thread than eglInitialize. 2) add concept of "device context volatility" --> Update CGL context even if ANGLE thinks it's already set. >> Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm:267 >> + if (CGLSetCurrentContext(nullptr) != kCGLNoError) > > Can this have unexpected side effects like: > > - App calls ANGLE's eglBindAPI, eglMakeCurrent and does work > - App uses CGL to make their own context current and does work with it > - App calls eglReleaseThread > > This will cause the app's CGL context to be un-made current. > > I don't want to suggest to call CGLGetCurrentContext here - at least, not necessarily - but do you have any thoughts about this? > Can this have unexpected side effects like: There's no added unexpected side effects. eglInitialize already trashed the CGL context of the APP -- that's the way ANGLE did rendering: with CGL. > This will cause the app's CGL context to be un-made current. This is already the contract between APP and ANGLE: - App knows ANGLE will trash the CGL context on egl calls. So in webkit scenario: Contract between APP and WebKit WK1: - App knows WebKit WK1 will trash CGL context on WebKit calls. Contract between WebKit WK1 and ANGLE: - WebKit knows ANGLE will trash CGL context on egl calls. >> Source/ThirdParty/ANGLE/src/libANGLE/renderer/gl/eagl/DisplayEAGL.mm:141 >> + if (![getEAGLContextClass() setCurrentContext:nil]) > > Would flushing here, instead of in unmakeCurrent, work? > > Also, similar question as that one in DisplayCGL::releaseThread. The releaseThread() is just an optimisation of not leaking memory. The flush vs no flush is a MakeCurrent discussion. >> Source/ThirdParty/ANGLE/src/libGLESv2/entry_points_egl.cpp:1083 >> + ANGLE_EGL_TRY_RETURN(thread, display->bindThread(), "eglCreateWindowSurface", > > Should this and above have referenced "eglCreatePlatformWindowSurface"? done >> Source/ThirdParty/ANGLE/src/libGLESv2/entry_points_egl_ext.cpp:1667 >> + ANGLE_EGL_TRY(thread, display->bindThread(), "eglReacquireHighPowerGPUANGLE", > > eglReacquireHighPowerGPUANGLE -> eglHandleGPUSwitchANGLE done >> Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:149 >> + // After initializitaion, EGL_DEFAULT_DISPLAY will return the platform-customized display. > > initializitaion -> initialization done >> Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:774 >> +#if PLATFORM(IOS_FAMILY) && USE(ANGLE) > > dino@ should review these #ifdefs - not sure whether MacCatalyst-related #ifdefs might be needed. This is intended to cover maccatalyst -- iOS_family should cover that. >> Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:777 >> + ASSERT(!WebCore::isInWebProcess()); > > WebKit2 isn't supported at all on iOS? Not even in-browser, ignoring UIWebView? Added: // At the moment this function is relevant only when web thread lock owns the GraphicsContextGLOpenGL current context. >> Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:780 >> + if (!WebThreadIsEnabled()) > > Is it OK from a platform layering perspective for this code to access functions in platform/ios/wak? This call causes a circular dependency between code in that directory and this one. Good point. Probably a matter of viewpoint: is web thread a property on which everything is built, or is web thread aproperty that is on top of everything. I'm not familiar with the platform enough. This functionality is used in other similar levels, but the code is maybe simpler done at the call site. I'll change the code to supply the information from the call site. 1693344 28 kkinnunen 2020-09-30 05:13:47 -0700 > eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, mMyContext); > glClearColor(1, 0,0, 1); > glClear(); > eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); > CRASH(); > I think EGL spec guarantees that the clear hits wherever it needs to hit. Hmm, disregard this, this is obviously incorrect. The idea would be something like eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, mMyContext); glClearColor(1, 0,0, 1); glClear(); eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); for (;;); and then some handwaving about the per-thread buffers. Anyhow, if we want to fix this inside angle and not have perf penalty, maybe some "context is multithreaded" flag could be done. (or, to be pedantic maybe some "context is not multithread aware" flag).. 1693649 29 410107 kbr 2020-09-30 22:31:05 -0700 Comment on attachment 410107 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=410107&action=review Great work Kimmo solving this problem! Great work on the test, too. This change looks nearly perfect to me - only one comment / question, but setting r+ now in order to save re-review time regardless of which way it's answered, once you have the build failures fixed. > Source/ThirdParty/ANGLE/extensions/EGL_ANGLE_platform_angle_device_context_volatile_cgl.txt:3 > + ANGLE_platform_angle_device_context_volatile_CGL Lowercase _CGL here and below. > Source/ThirdParty/ANGLE/extensions/EGL_ANGLE_platform_angle_device_context_volatile_cgl.txt:11 > + Kenneth Russel, Google Two "l's please :) > Source/ThirdParty/ANGLE/extensions/EGL_ANGLE_platform_angle_device_context_volatile_cgl.txt:15 > + Kenneth Russel, Google (kbr 'at' chromium 'dot' org) Here too. > Source/ThirdParty/ANGLE/extensions/EGL_ANGLE_platform_angle_device_context_volatile_eagl.txt:11 > + Kenneth Russel, Google Here too. > Source/ThirdParty/ANGLE/extensions/EGL_ANGLE_platform_angle_device_context_volatile_eagl.txt:15 > + Kenneth Russel, Google (kbr 'at' chromium 'dot' org) Here too. > Source/ThirdParty/ANGLE/src/libANGLE/Display.h:105 > + // Called before all display state dependent EGL function. Backends can set up, for example, function -> functions > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:765 > + // potentially switching threads later, we should flush. See below - if the code is removed then this comment should be updated. > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:771 > + gl::Flush(); I don't understand the need for this flush on MakeCurrent. If we're coming in with a different WebGL context / GraphicsContextGL current than this one, it's still not necessary to do a glFlush at this point, because the same hardware context is used for both GraphicsContextGL instances. Commands are properly ordered between them. ANGLE handles the virtual context switch and sending down the user's GL context state to the hardware context in its EGL_MakeCurrent. If we're coming in and the application's EGAL context (for example) is current, then this code won't have the desired effect - ANGLE's EGL_GetCurrentContext() will not know about that real native context and will return nullptr. gl::Flush() will not necessarily perform a real glFlush anyway. Basically, it seems to me that the 3 lines of code above - the calls to EGL_GetCurrentContext through gl::Flush - should be removed. > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:801 > + // Called when we do not know if this thread again. ...know if we will ever see another call from this thread again. 1693660 30 kkinnunen 2020-10-01 00:23:02 -0700 > > Source/WebCore/platform/graphics/cocoa/GraphicsContextGLOpenGLCocoa.mm:771 > > + gl::Flush(); > I don't understand the need for this flush on MakeCurrent. So it's about what we assume about ANGLE implementation. My suggestion was: * Assume ANGLE has a bug where it does not flush on MakeCurrent Your suggestion was: * Assume ANGLE has one platform context * Assume ANGLE has a bug where it does not flush on MakeCurrent I can change it to your suggestion and add a comment. 1693682 31 410207 kkinnunen 2020-10-01 01:27:03 -0700 Created attachment 410207 Patch 1693847 32 mjs 2020-10-01 13:10:06 -0700 <rdar://problem/67827426> 1693890 33 410207 dino 2020-10-01 14:58:15 -0700 Comment on attachment 410207 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=410207&action=review Thanks so much Kimmo. This is awesome. > Source/ThirdParty/ANGLE/ChangeLog:16 > + gl function if the client knowns the platform state might typo: knows > Tools/TestWebKitAPI/Configurations/TestWebKitAPI.xcconfig:74 > +WK_OPENGL_LDFLAGS = $(WK_OPENGL_LDFLAGS_$(WK_PLATFORM_NAME)); > +WK_OPENGL_LDFLAGS_iphoneos = -framework OpenGLES; > +WK_OPENGL_LDFLAGS_maccatalyst = -framework OpenGL; > +WK_OPENGL_LDFLAGS_iphonesimulator = -framework OpenGLES; > +WK_OPENGL_LDFLAGS_watchos = $(WK_OPENGL_LDFLAGS_iphoneos); > +WK_OPENGL_LDFLAGS_watchsimulator = $(WK_OPENGL_LDFLAGS_iphonesimulator); > +WK_OPENGL_LDFLAGS_appletvos = $(WK_OPENGL_LDFLAGS_iphoneos); > +WK_OPENGL_LDFLAGS_appletvsimulator = $(WK_OPENGL_LDFLAGS_iphonesimulator); > +WK_OPENGL_LDFLAGS_macosx = -framework OpenGL; > + > +OTHER_LDFLAGS = $(inherited) $(UNEXPORTED_SYMBOL_LDFLAGS) -lgtest -force_load $(BUILT_PRODUCTS_DIR)/libTestWebKitAPI.a -framework JavaScriptCore -framework WebKit -lWebCoreTestSupport $(WK_AUTHKIT_LDFLAGS) -framework Network $(WK_PDFKIT_LDFLAGS) $(WK_HID_LDFLAGS) $(WK_OPENGL_LDFLAGS) $(OTHER_LDFLAGS_PLATFORM_$(WK_COCOA_TOUCH)); This is ok for the moment, but I just made a change to NOT link to OpenGL in all our frameworks, and instead soft-link. The problem is with iOS apps on Apple Silicon, where we need to decide at runtime whether to use GLES or GL. > Tools/TestWebKitAPI/Tests/WebKitLegacy/ios/WebGLNoCrashOnOtherThreadAccess.mm:180 > + [uiWebView stringByEvaluatingJavaScriptFromString:@"runTestAsync();"]; It would also be possible to have a test that dispatches touch events rather than evaluating JS, which would exercise the main/UI thread entry. 1693984 34 kkinnunen 2020-10-01 22:26:55 -0700 (In reply to Dean Jackson from comment #33) > This is ok for the moment, but I just made a change to NOT link to OpenGL in > all our frameworks, and instead soft-link. The problem is with iOS apps on > Apple Silicon, where we need to decide at runtime whether to use GLES or GL. I did a version of that too in the obsolete patches, but it failed since PAL needed libcompression.tbd and I didn't even know what that was :) It also didn't repro on my macOS and the patch was in a hurry.. Then I thought of the use-case: this is Application code, and AFAIU the applications are never compiled with either-or or dual mode. Applications are always either Mac apps or iOS apps, always CGL or EAGL. Applications never use both? Or are you saying when compiling the test case app as maccatalyst app, it should be compiled as using both and then actually use both? (That's what I had) > > > Tools/TestWebKitAPI/Tests/WebKitLegacy/ios/WebGLNoCrashOnOtherThreadAccess.mm:180 > > + [uiWebView stringByEvaluatingJavaScriptFromString:@"runTestAsync();"]; > > It would also be possible to have a test that dispatches touch events rather > than evaluating JS, which would exercise the main/UI thread entry. I tried to test that using the direct JS VM access API, JSContext invocation. I did verify this ran the call in the calling thread, eg the main/ui thread. 1694000 35 ews-feeder 2020-10-02 00:05:47 -0700 Committed r267869: <https://trac.webkit.org/changeset/267869> All reviewed patches have been landed. Closing bug and clearing flags on attachment 410207. 1694084 36 ddkilzer 2020-10-02 08:09:11 -0700 (In reply to Kimmo Kinnunen from comment #34) > (In reply to Dean Jackson from comment #33) > > This is ok for the moment, but I just made a change to NOT link to OpenGL in > > all our frameworks, and instead soft-link. The problem is with iOS apps on > > Apple Silicon, where we need to decide at runtime whether to use GLES or GL. > > I did a version of that too in the obsolete patches, but it failed since PAL > needed libcompression.tbd and I didn't even know what that was :) It also > didn't repro on my macOS and the patch was in a hurry.. The libcompression.tbd file is used by the linker when the actual library (libcompression.dylib) doesn't exist on disk. It's a text file with a list of symbols that libcompression.dylib would export, and can be used by the linker in place of the actual dylib. This file format was created to make it possible to parallelize builds so that a project that links to a dylib doesn't have to wait for the dylib to be built (since building the *.tbd file is quicker because it only requires parsing header files instead of compiling and linking all source files). > Then I thought of the use-case: this is Application code, and AFAIU the > applications are never compiled with either-or or dual mode. Applications > are always either Mac apps or iOS apps, always CGL or EAGL. Applications > never use both? Or are you saying when compiling the test case app as > maccatalyst app, it should be compiled as using both and then actually use > both? (That's what I had) We announced that it's possible to run iOS apps on Apple silicon hardware (without the iOS Simulator), so that would be a case when the app would use EAGL on the iOS device and GL on macOS. I think that's why we need to soft-link to the libraries so we can make the choice at runtime instead of compile time. 1694859 37 dino 2020-10-05 14:31:17 -0700 (In reply to David Kilzer (:ddkilzer) from comment #36) > > Then I thought of the use-case: this is Application code, and AFAIU the > > applications are never compiled with either-or or dual mode. Applications > > are always either Mac apps or iOS apps, always CGL or EAGL. Applications > > never use both? Or are you saying when compiling the test case app as > > maccatalyst app, it should be compiled as using both and then actually use > > both? (That's what I had) > > We announced that it's possible to run iOS apps on Apple silicon hardware > (without the iOS Simulator), so that would be a case when the app would use > EAGL on the iOS device and GL on macOS. I think that's why we need to > soft-link to the libraries so we can make the choice at runtime instead of > compile time. That's right. WebKit in MacCatalyst on Apple Silicon can use either OpenGL or OpenGLES, and decides at runtime based on the binary calling it. Even then it is a bit more complicated, because a WKWebView UIProcess can be Catalyst with an iOS binary, but the WebProcess would be a macOS binary. A UIWebView is whatever the app was. 408295 2020-09-08 17:41:46 -0700 2020-09-08 17:41:46 -0700 Test app UIWebViewWebGLTest.tar.gz application/x-gzip 8002 dino H4sICNgjWF8AA1VJV2ViVmlld1dlYkdMVGVzdC50YXIA7T35d9s20vtr/Few3P5gp9Z92Y6djQ7a USNLWh1O3Lw8lSIhiQ1FaknKR/vy/e3fDACeoi5Hdrdb4flZEjAYDAYzg8HB4Ux+GIx1cyjrgwmR VWL9Y/cpDalYLNJPSNFPKMz/I5MrZYvpbCaXz0B+Jl/IZP4xfgZaFtLcdmQLmrRM01kFt6482rm/ SCpkBcWcTonhXMgZkh1m5NPiMFsYjQqnikqGQzWrnp7K8nB0Ko9O1JPC6DR78GfTvE+7S/36RzK8 0cg9fFw1esR2kg+KqZKZZf6W2lEbqA+lUmG5/sP3iP4X85BX2FH7K9PfXP9Xjj/+I4qTnA0f8OtT 22D2P79k/HO5UjEXGf9sJl+C8l12dFn6m49/KiX88OPrfu/y5PWPPxz8cfBKtpSJdkduiGVrpiFc CJk3B68UXbZtYsMvgPgGGeYQBcMHKqS9TAZ1kHotVMhYM4R25VNlrunqpaYTwQYArPE6dfDqVS5z mSuUM7VsIX1SyFWK6fRlJV0uXgpQtzyb1YhOxrJDklMB0HTNuaUACa9TiF+zZfgIon4jjOB/h4wg nyOurkf8OvVGwP5wWrLpuCpdhRjku6m53AR1lJ5cXCVU16ppOJap68R6KkHZ7Ea4oxQV42pdy5qR tB3TehyasqUiQR1ib09SfhPkUYrKvFIpNMwgr44NtkymX55M0ekmyKMU1eIqNeS5oUy6ikXITnhV 2aaRCIW5dFzlKTL6qdJ0uQJjtPUShc2fhmAVkDpwQ5MTZ6o/lSm54lrMnBbIlgx1qXEKma9L1gqx iKHEm7CTOLmNmVrl2SzamxDyNwJ5mOmaojmY3XucEQC6t6Aa6CL8hyIZG38DDFL0uUrqRt1QyQNA pd8IM9mZwLf4dt8IjJ09EA0AqvTrjd6g3WnV+tVed1Crd0JDlKmss52TNR2BGcP5YJj3RqAnjAJ0 L5JKcuIRHEIboVM8H1vmfPZWDJO3kWn/LvJgMlNiKZxuRqG03tzvkIURxJuRuOGMtDs2RnBvRGU2 s8E0tUNORjFvRuSmc+nueBlFvhmdhTg6K7JNnkAbGt/AHPNGMOQpNS2AziMTfyR1upqIzOObEbzh /Ls17aauoknF+mBSZd0c+8oexr4ZndU4Ol+IsUsm/c0Il+IIrxsjMwmzje08gXyHPDiscvJhqnsE +zg3I2y1Q7E7RWIoN6JpI/fiSezCuh5FQYQr6fKdmKUuStiRsUCQ7k3rq02dnvYE5TPOn4k1E35t 3kuAf+X3NAY3cu7VEH+WaRvXsv0VoHF1nz/JFfMlCoDijovGQ/xxRLOsudEy9MdL06qRmW4+4v5k 27QdEHdwCG3NGFOPB0DDXFjTvxAzrpCRcb1PL86L0c7SupRSWCzrKnDdpd/lYHkzjxDaPQ5WO42r 1rZMda5QO3fs82iJXDCebIzwCV3bztkNUMzNmNv6Fr3YnJtP6M9Grm5olDbyPkM1NvQGQ3U2dM+C dTZ2lkKVNnVegpU2MoWhVjZc24fqbDj7h+psuS4O1V0/GYbAV09RAclfujJbrwO+dVswWCFz1oSF 4R3pydaYOLE2vfR0HQri9m06SMdIG88tuiJtIHu8ZXgu1hvCSigifi2BcnVkWgs9EBcpE3Ht7rVO jbsd1eVYIfN3M0L6tX6SC4HHbnwFNykC400p7MwX5jWVzAis1w1Fi5Zw27hEQmbMZDY3AfLdAG/r cTuLHUTGfRRRMad0/4EkeUHCgZLglsSivC6TyJDYttkRQ6zExm7GuhXYZnOctHII2g3ZcSxtOHfc vWtIDfDBuvfayOnPVLCh1QlR0CnJZNPUoWAA/dnYktWYQtad8iLa5WrmQbyqWgRaVFtGzzR1O7DF nk1y9GzWcz++baJsmdg94nXK5rJxlZ7BoIPh0oaarjmPPrXiJ3SjhdNkTuRCfUd0c4Y+WgeGlcIQ gxaBjnYV2TCICq6cZEA9cN1s13d79RVdYVbH12RiMLXDBU5ApdCsMgvodnzRT4uoQRh8rSvk1ka+ 1DSrzWy2KAbzO6bp+JkOFYYFI7S5pfX7F9KcGKUIKY1ndda48WtN1oLuxGB+ghO/i33w0ET7lC3+ kLey9Y5zqPmnnHkERPeJq5k1oxySiO5G8rBmdlyQhgWsT5eFzU8cQpx/wvlXaNLe9mwx1Pj2h4Hf P+grBzI05DeypcmGs3QZu6nDvTDqQcSrFk4rNxMXl33R7b+NV3/bevRP79CqTbzFDi3bdtvCpV82 hv5Af6pWFqb/uNHOZeJor5HhfLzAkjicvmZ3iePwWZr5LeXGx/Jtd9CVyp3q+0G/K3UG7XLvfRcA mi3mrlQb5ebVoNwsN25/geJmq9nsNxoAcCt14yH61xX4aFV+lqq9QbXVvJE63XqryaoMyldXHanb rd9IwdrVT58G+KVfvpIG3V65WSt3asjfsTH/6adMXlwArlc65c4tgujaUPnppxCE1CxXGtLgulXr N6TuIrG8HGisDqDrqwE+SuUPixAfy53moNJoVT8MquV2r9+RBuV+r9WRGlK5W29eLavRajUWmLIA VW1dX5eXljWRQYusXYCsSe2OVC33pBrrSP263ZCupWav3INKMWxhteodHDhWo1sGqYAx4YMndTqt zmKNVrXvoaW0w49l6KXrdu8W2FC7XQYAArS+b/XmZb1Z70kDILa/GnADToFUg0T1pE65MUDxXl/D Y2i9Wu8BEb1yvQl61LhcBe82sRn2TqsFpDfK3e5K7v+738IRrjerjX5Ngs/BZad8LX1sdT4M3kvl mtRZ0kgHvkmDRqvVZsrbrS8bs26vU6/SI+Veq3fbjtMoBtfvtoEfrX4XVO9GWgLVRzXv1IDm8k25 3ihX6sCX25XmgdfrSOXqe6qY1VZtGfpBrY+jAmI/uJZ671u1wXW5V30fgm61bwft9+WuRLvWDpi7 mlTpX6F0tTrXTJ7ZNwBR72VrxKC4eeB8oaN13b3qSs1asBkO1ZNAX4OdZKVX1eqgGmv0wOZlMj5Q 7bZZvq5XQUgHwN0ArVgImahwLW6LutEWWu1e/br+C+tKQ7qRGt4SjZaDhYBhrQLLWx0wGFSpuHFg 8+crkbLkIiMe898/HmrGhFgaLHePeOaRj5COQTE/6LUGueygUl+mfR5sudLqUw3qww+UrkVp92D7 zZoEQ90B2QFdAzPV6sTi7DdpP8qN+i8oZmCXu0vkK1AFpr/a4LLfrPaWkcphbsqdOo5sEKbeft9q Sq0uGt1G6xYt4KBX7lxJKDmZvLsJcN1ruHOLL2l4gsa1t9vqd6qSD3tZ7vZQfkPi22o2bgdlIPNG wtkrVNatfUC7AVnabGIaxLQD2w3cu6GuQ8QTy2XjnIwOOMP+Qefezdi7GXs3Y+9m7N2M53QzROpn JO41Z5JQ7cepGHImmkB7Fwyoq1ouws08ko19jnVuxX6Wf8os7w7W0pl9yez96gb6WENR47c6A3VC Mzufr6Nze/75NhBAFnugBOVG6wolpl1vwKRcboN+guyA34rsK89mdYWjWVLjqtGqgMUqV6sSNaQN 8Ebd2opCDKdq6qblqhU6SvUrNBi3dHzKc8ecAqmKq1zg5rbabHSk8jVAFEvvf87/O9suX/KBhAEB 9YUhuKxTFIt7+KnArSZap1EbdPpNdFxcT8Z1YlxPOcYzfiW+Iw9EmTvyUCcDPCxO+eeQYe+Zj+2g AvIPklOvAf31yzo1rKY1Tt6T4VfNSS45IvSqc7YBMUwyacYRtyIsC6QbeFSvSiCF1/UGdW8yx1lx Q1ex8Jyu4l6g/qcFKmyh+Hbpup3Q4J7p4mlp3HHIcxycRuV6gRJfrENFC+clK/dzQ2dbaxZlgY1r lYzkue6EGq7bN5qtgZh4S/44qObKqePZrnvsjJsrJ7cQN9fYrefjpifmq4UX+Y7PIrbY/QfvdHuz yxJvDr6FH9/e6PnPB4UajpmskKc8E7z987/ZbK5U3D//+wJp6/Hnh+Z2MFOVHXlFG6uf/4XRTpei 41/K5Ur7539fIJ3/62GqC3fscs+FmEmmRYHwizoXYr93mTgR//X24PyjO9YHguCC0wkcKrzFvHN+ BR2/Q9JNdi0MYWyij844VIqDAcqUh/PtPqTEn5W21v8HxZ7IFlFR5zecDJ5g/wvpXGZv/18gfd/4 w2rBU2J6V9JmS5dwG+vsf65QjIx/LlPI5Pb2/wXSpvb/h1qrSnfk2EX4dr/SqFcFMZFKlfFacCpV 69UEurYVAEcqJTVFQZw4zuwslbq/v+eXhxVzioB2ChzTGbGcR3RvE1AhqToqzBDnDHuIHMhVNcV5 e/Dq/Ct5fAsiV9PA25/O5g65lpVctqI5H2XLAILPUwgBgI41JymcYljN8xTFu59mFlPMDsTO29je /mfy+XR+b/9fIMWMf+jRp120sdb/Ly7Gf4Jfe/v/AimVOkilhPDjbjRnUTAOOCx/ikEYPgowS5gC OPmnqdNUNp1EiIN/atOZaTnCeb/+QXNS9H9y8vbg4J0GK0drBK5CsDnhDJrqEHtmGiqxsFbZf6jE BYLaB++IoR7sLfiO0xr9n+6ijTX6n82Dzi/of26v/y+RYvR/uhv9F0M2RVyq/4dHrm6/g5o6wYvy bOsgAAX6nxAO8cLKUeCZs7PDkLUQXgcLgTj1UjM0e8IuaoN/+FFzJq0Z3SA+O2x2axrdVpWtR6ip UyBeKvxBtzGgty3wRS1NJcLMBPLp3rUCImNOtd9ZK/IIOiUE22WYkhSDRZy5ZbBz2G/QiX/OLHk8 lYWpbH0VEsBk+jhBFx8IoNvjI6I8KjrvLi8Nn3i83pwBob33S9MCRAbuJBvjYKtnhxEqXh8psYCC 6bLOJ8xgO9Mu214fmVEGVmVdB2G5nxDglWCQe8HGuoLNkWq2MCT4NITCxCrpVuzbRHAmUDwlzsRU BceEOjpuY8uRUwUoYZUBngSawNsRoWH4/DmWpUChqXwRQFYclBDcnT97J9bYxr0QghVdujumTs7i +ZS0oOwLG28YxTtTU7cS2ppmK7KlBlFSce0S5zw6VG+huh0EjGc88mVug5yqDLcNPAwNg8f1+kiQ jUc32xbuiUXcWhQbBspCdEGi72VbMExHsOYGLsOO2bjda7oOYysojBB7AlZBf1xUmLOVirpKHix+ LIMUW96zV85Edhjd9owo2khTEBZp9vtBO28fCzKCk0dGK+0ClZQkHTxqlf5sA/3MKW7+Dz9X9/3r wSes/0qFdHa//nuBtMH4B65CJBX8D7lbCcX245/NFbKl/fi/QHrq+FfdY8DfbNNY08a69X+mtBD/ t5jN7uP/vkRCd0FkoyrCUvwznW3/4Id4oqZq5hTzxbmh4a6srIu07Bv8/3KMdTVjZCIEqyPKc5ic LVqFniOIxyyfb+liQeYA63/7X59Z/xppE/1nF+lwC1+Dz22t/9Psf6a0t/8vkZ42/ttY/7X2P5cu Ltz/KBRRXl6g/3/38af2X5vKY7La/rOr5tyaQwkspHRCS7IPgVztd56Zfsim+VRxvD3O3DPgjKfz 9CF7ums6vw9nLJ359EN+1/z8TpyxdBbTD8Vd07khTlmNw5j5DkmKx/g98r4NjZtJ0TY0fg/GWBo3 lKAtaPwujLE0looPpeJOadw9xpNcsvCA/9ZiNe0Ebh0T3HPcmAWZdDb/gP/2vvs+RdIG/t92zl5M Wrf+h8XBwv3vTGl//vcS6Y+9Hfhbpxj9D0SW300b26//8f1vuf36/wXS6vFfEuJsyzbWrf+z6ej9 j2wuXdzf/32JtMn9XwFYZKiyDou2C9Ew6X1g1VTmeFNDwDjAF4H4wHX3kgd9/o9YuWTVVEy5Z86V SbLriVDyU70i+u3msF0nEBUXSMllstlkpgj59BnBztxwtCm0pbW6AZyiMON3ifGcwrZ5YEgkFNaY eOqNz+nq8qM5dy7EW6kr8gsaTKp5FoD1LFnDUw6dXWmw/ZKuPCJli8huFt0uv5YdZUJUnoV3BzRZ D0emvBDTmZ8T+ixh3lyzx1+E82AE6LfcU4fsmT4f1w1BgxJHG2lYdzlLk/WK3/821NSMACuBb+l8 MpMVUwH8ijyTWRxf+jKRCxH7JMjQKYGxRhjPoXFbFKZaKDrxhXgKQ7MSlSsKtmDLd4QGQsXDdhYl +ASvzExlJwbxiY/4PLXIl3N2Rh9o+YdEAhks+BxOJALF/EID/q/XLkTp/ShR/5goZyXRB6KA/D2F 4VxachcaPxiO0BAy3NdkOiQWthCGFhfxeTiFr+SRwYtu1Nlr4M4FW7n1zEtN10Xa3C+kkCgOE1kn twQfxWnhNRiKc4SPdYvCAxCKKvTIP+811ZmAWpUKojAh2ngCsl8sloIDuYAU3D7TIrBqBNWngV1p A9Fcjrur/Y7PlnPxZ02E8la1RBWIoR/KyleMjmmo9IAReoJik8n4At59tB0ypaXAL/qjEq2kxEPf TzSHMJBV5OC4NKgWXKESMMJsrvRsWIq9r4mWlKhUbpdhOk8hmhiZSoXFJAZipoNuT+gbiYTA93rA GNQrl5plO949WUaVdvtb4sN/EpKcoXbKashDApaPggoB2IjcjsKoIh06T8Xqxzm7AEd5o8jGnWw3 +CN+VPoKOSp8KHBBY5GiTbtK7mo0qDu3GftHMv7ktNr/i8TsfWIba/y/IgjN4vt/M/m9//cCadPn v17A3ytlCvndO3vP5NlVbn9J5E4STtryPbs7TSHULlu4PysXB2CWTUtz7zNfiHgvGmkR8fojkS3Z UKCLOs6dnif0Ag5iKZPNv5h3yCZkxlkao9+TJO/GZgzaTOYv6nU6Bkn8u5fQRvPv8joD4sXvm1fx FdwXYlgOX8QlPRlWE59GiTu1uguXFAy775KenBb/S1xSez5EXsQMTwjsnk2WKzgGCm7YuuwQuxwh E7TUhLGx0QSA3F6IzRZjsNq+TOQqiextdKWyNaPz+SV8zpys6r2He5VjbqFJTCdzxXTpJJ+D+Zrv 3ojCmC2koezkBG9unuYzrCwrCkN9TrAon86dZjOF4gms52V9NpFBx7m97eLT42DOqJh74h4osTtX lXXkn6f40KwY49T6Qd7NWmAtL+31a5rVqD0pWsMVH1KgXn8dWgoJHMv23mcEBsyc4UMOUFFlwIHu 8vwoNDUS+k3i5jaR7l2uHal4moLNRGkamg4VjSBZwT4skOVWQMrK0/eJ6mmiV8k/kbJV3NKJjJ7S FhzzaiBt1Z6UaCqJ5lflGbiG0PoCcSv55ldB6px+K2GPEqTZWSmNqbXiuGxt7HaMP0W0Si9BIXXi eO4frO2ZuosC+CXobTEPK9g77MJv9s+J3M+J/tfr5ev2lQQ85/Jd/fqQ+D2dMH5/mSV6Ilugk0Qm d7LBGp3+8ly0oMPj2y7uisUbsAhtzBzSHRlq+redBMZAlqUpV/J0KmezV5b86JdGuuMT6HYq0I/9 3kMorYxAuaM21p3/lEr5hfO/XHEf/+sl0l8u/kv1sgImRie16FsHveAvMBcB8W9/PAxGZHXDWR+B fWDlEXySFy91EZH0Sar2eyy0NoY1XYbDN/mLOJbGWV2ODfTQf0SZL2CjiIvJ9LL6+BzrcjpWdqQN tlwe0zeUr+1Ju1z9gHHCUTqWIuziw5+8C10KEcWbWd6RJV3PROEb3Q75z1wDY19v4w3TVjcaEIjB hZ6/pc/TXsuGNgLb58FziYuDn89wG8e+nuuOBjJN69tuxVfnI1m3aVNu3cUHjgPQbjsu8EfNUM37 4DO++KBxoHmv6qtz2YJJkH4N4FnRbFAeKCDnXuyDzgHeRpG6z+TTHYllSEOQK5D5O4QYGDAOE+5B hxG4YZ3oV48LXq7/Zeng1Q1Vw3V03ZjNHekOt5GWiQq/AuGRGadVwWsSUaHs17ED8d1c0kVejwuz WqMbi1V3A0zzpc0XAReTbE3vSkFUHn9cpjMOENXbM2z5O5QrEPfrcRXafEMzOD6razRkQ7UVeUYa ZPSUah3c0Hh6B/8P7+U+fy/dGv2ZramkZt4b/wUcio2GFuP/RV5L//0+xhr/L53LR89/MqVsfu// vUTiMV0iY/78EaBCDS7GgArMg4EYUO/c5b9wCOJtYqQJA5wjjMaiHAluLeG1cE+/vNkHjVqb1ur/ DiJArdH/fCYbff4bX6Gd3ev/C6RY/d9VBKiIVRFXWIDlUaBCcIGQOnSjyotF5MbBoZFceGCinrk8 xJG9RUwjZSHPC7ITE5SGYZR1/dELU4QRalRBdhxZmdBTSs9U/cos1a9uhBowcHcaBqgJmUDhV9q3 X4NReub0FdKy4N/OOKYYPIyeraSxbWT3ZSWUsCFxz7W136ExnzqiupTQFr0Ge9hH1R0s1SQs4A8O 1SMF90Mh8cBCpuWFeJItFpXp0CZAXzDyz2YRqn4FYm2HyOpRMhRUiTZUYwGTWMVFcYiGQ2IBfziN XuwpHkiISjQtpluI4d6bijK37EgYIx8XQcFmyP3jnmOB7nkSQ9DwoNoPeeVFIvLa6MTGMoIVlqlo VNkwmhWTNdYgDXOkyAYOpkUSPHwWD4H14Ah4fyJAH+eQHeiUWzSVHykGBiHg4aVFQyMFiXZjPAEI 5MiWpj8G4iktDu2SQFbrxrJCFHNK8O3ydzHKvTS4FSueAI1TE28DjCxzCqyExmSKCq8wY3wwEzOD WavDS+Hc4NAhcWT7azC01Eyeo7wc4iY4cOWROAIFJupRlCrknEtHTKc/gnqC76ONjSf2muo3dtvr dUyfw4wISzaOP5VuQZ1TeJB9MOAYF4+aa2vOzd4heUgyZDBIqDf0QV4a4CtuOLFnEiIAzSZMIbZU UHqYrrHGaefC6uXaqpGHf9VwQjEDVyayMSbYb5Xg3EVVF7sTxh4voLRD/lnHLjrkk+92KEjE8g7h xRcB47Afe5HQWGx234AcU9uOcwRaKHM+njBCEl5oNCYk+AQYXpgBwtwGuQJgTZ9+JAxL0DKAwFh4 j4dL1N8lYtr/Vorx/8NXjHawAbB2/Z+Lxv/PlAq5ffyPl0jco4+O+fNvAIRbpDsA4ax1y/16pcXu BHhkCq/5pYD9wn/jtF7/v38DYJ3+F+P0P7/X/5dI8fq/qw2AqFkRV5mA5VsAUcPg+mR4NQdcsoYp q9zt+mzPwWIIgYIvYAywpNntdxrC65FG3833mf3EX/CJ4WbbsjM5+wz57MwRnEPNYF+/CPgCTfBh O9yrOnsn8vufomCO8JAUcibOVBe/QGuMDKKPku5lUR3IwMMcYOAZa5j/AgeLfmL7kHuG5HzhkYNf yJWK0X/etyT2aCdtrN//W7z/Udrr/4sk/2IHDvfbg3P3A5bo8AGLDZnf8kKdQq32rotfiOyqMXvw IUF/4G0NR4Np+a0/K1PJEnr0eJ2VHZzbziN+Dk31kWvuCJAmRvJU0x/P+P5LYq5RXUiyy2zE3Xej LZ0JJ+m7e6ZuM1nF+ypnQhZzoAarEAbPeuDsVrSbA+DDueOAmWHgCfbG24T/iMYZuh2E1fVXZgl6 b+1M+Cc+rHR6wop5Hr3mxiuYlkqshCWr2tw+Ewqzh2B+EDXlAAbtORMyyROLTCOdSycLNBMIxuO9 R8ZIxdJmDrhW9BKm8LFeoy8LL6Tf8Jz3Uv3qfY9nHYzmBnuVqALrRYtGdnlwDsc6rCCPBfCvhkcH jAtjPclBoEOHvPBYyBy9CRVD1SR7b3Klf3kpdfAt70eURK8l3Gg8dNEymtjwZIAo9y5eckwciZn8 ymNdPcTrnWM9I/LmeIUkHUqoRrsZLmKDCmWsw28CzQEiyHcBoSW336wVr5EwSzLHQpr+YZ8pwFJi Z3j3VTxKwkjRywR4qwmvK0KJSac71bw3xGPB48nhkRfdKa5d9pfmdH2DinipxCUDfV7WmSx0y5jr +pvV5LGtwSfTp42EQ95eMBsTi5b+xsv75nfKI9Aji5HBKTvkN1Rd5gfqxI1ysDh2pEMMgEnVeuzS lwWA8Iqe/UAWzPCJn+pE01WvUz4GPh+XDY3thdCXZh/GsyUoX1lPvrLL5WvJeGeZkPm6RRkZM/ag VGxvP2Yca61rHqYJfR6iwmCi3gVq481eZirOU9y4o/VFU59ZYqyh4OB8xu7Q9ia466nhiwMYCDex Q6Kb9+67G9APxL0igIBPyPN2v2bymFA/yE4KdQc30ec6blPheS/FD3C2qWsqfWAk6TdHXy0IreA9 CkFjL+CQ+cV1TgOFFpx7U2B23CVqIt8RZkGZkAsEeUbfQY1Mc3dz+VsKbGLhNOb1Ae/k8E6wBuiV bH6Y4uAOqSM45gGTGnpsDY3w7UgKGWQTw8CpjqBw310hGyZUtsL18LIGvQB5B2JDHwDzZJnfbebj gPfJuc18e55imezKxx2ONJvgEIjZqrdt+iQBJZkBn6cYUBiam463zOGnpzhRcGiEC1KK+Q77Vfdf KMX4/7jy2c2Ln3hau/4vLcR/KhQymb3//wKJL+jZmD/Prt/SF0KhBcKGD/GLbI2VYzyasYTX+OPu 8xd3tm122ZVhLPBReNdP2Uz5jj0VSo9BZqapB2ZqoL0LjspMoM8GU6s/pS6Ea3n9mmD+2ZM1whjP uHEWSnp44hqHid8l79LiT+kefg6+34ra7S/ufH7gu01C6GoqzjeHjAnY+2PB0MArj2uS+td/ttzs 0z7t0z7t0z7t0183/T+r827GAMgAAA== 408950 2020-09-16 13:23:05 -0700 2020-09-16 13:23:05 -0700 ANGLE EAGL multithreading patch eagl-multithreading-patch.txt text/plain 2633 kbr ZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJl ci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmggYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGli QU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oCmluZGV4IDI2MWJhNDA3ZDE5My4u MjQwMDE5MDQ1ZWVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGli QU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oCisrKyBiL1NvdXJjZS9UaGlyZFBh cnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmgKQEAg LTEzLDYgKzEzLDggQEAKIAogI2lmIGRlZmluZWQoQU5HTEVfUExBVEZPUk1fSU9TKSAmJiAhZGVm aW5lZChBTkdMRV9QTEFURk9STV9NQUNDQVRBTFlTVCkKIAorI2luY2x1ZGUgPHRocmVhZD4KKwog I2luY2x1ZGUgImxpYkFOR0xFL3JlbmRlcmVyL2dsL0Rpc3BsYXlHTC5oIgogCiAjaWZkZWYgX19P QkpDX18KQEAgLTkzLDYgKzk1LDcgQEAgY2xhc3MgRGlzcGxheUVBR0wgOiBwdWJsaWMgRGlzcGxh eUdMCiAKICAgICBlZ2w6OkRpc3BsYXkgKm1FR0xEaXNwbGF5OwogICAgIEVBR0xDb250ZXh0T2Jq IG1Db250ZXh0OworICAgIHN0ZDo6dW5vcmRlcmVkX21hcDxzdGQ6OnRocmVhZDo6aWQsIEVBR0xD b250ZXh0T2JqPiBtQ3VycmVudENvbnRleHRzOwogfTsKIAogfSAgLy8gbmFtZXNwYWNlIHJ4CmRp ZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIv Z2wvZWFnbC9EaXNwbGF5RUFHTC5tbSBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJB TkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLm1tCmluZGV4IGNlYjJkMTFmYzc5OS4u NTI1MGRiMTE5Yjg0IDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGli QU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQorKysgYi9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQpA QCAtNzgsNiArNzgsOCBAQCBlZ2w6OkVycm9yIERpc3BsYXlFQUdMOjppbml0aWFsaXplKGVnbDo6 RGlzcGxheSAqZGlzcGxheSkKICAgICB9CiAgICAgW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250 ZXh0Om1Db250ZXh0XTsKIAorICAgIG1DdXJyZW50Q29udGV4dHNbc3RkOjp0aGlzX3RocmVhZDo6 Z2V0X2lkKCldID0gbUNvbnRleHQ7CisKICAgICAvLyBUaGVyZSBpcyBubyBlcXVpdmFsZW50IGdl dFByb2NBZGRyZXNzIGluIEVBR0wgc28gd2Ugb3BlbiB0aGUgZHlsaWIgZGlyZWN0bHkKICAgICB2 b2lkICpoYW5kbGUgPSBkbG9wZW4oa09wZW5HTEVTRHlsaWJOYW1lLCBSVExEX05PVyk7CiAgICAg aWYgKCFoYW5kbGUpCkBAIC0xMDQsNiArMTA2LDcgQEAgdm9pZCBEaXNwbGF5RUFHTDo6dGVybWlu YXRlKCkKICAgICBEaXNwbGF5R0w6OnRlcm1pbmF0ZSgpOwogCiAgICAgbVJlbmRlcmVyLnJlc2V0 KCk7CisgICAgbUN1cnJlbnRDb250ZXh0cy5jbGVhcigpOwogICAgIGlmIChtQ29udGV4dCAhPSBu dWxscHRyKQogICAgIHsKICAgICAgICAgW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0Om5p bF07CkBAIC0zMDgsOCArMzExLDIzIEBAIGdsOjpWZXJzaW9uIERpc3BsYXlFQUdMOjpnZXRNYXhT dXBwb3J0ZWRFU1ZlcnNpb24oKSBjb25zdAogCiBlZ2w6OkVycm9yIERpc3BsYXlFQUdMOjptYWtl Q3VycmVudFN1cmZhY2VsZXNzKGdsOjpDb250ZXh0ICpjb250ZXh0KQogewotICAgIC8vIFdlIGhh dmUgbm90aGluZyB0byBkbyBhcyBtQ29udGV4dCBpcyBhbHdheXMgY3VycmVudCwgYW5kIHRoYXQg RUFHTCBpcyBzdXJmYWNlbGVzcyBieQotICAgIC8vIGRlZmF1bHQuCisgICAgLy8gU3VwcG9ydCB3 b3JraW5nIHdpdGggYSBzaW5nbGUgY29udGV4dCBmcm9tIG11bHRpcGxlIHRocmVhZHMgYXQKKyAg ICAvLyBub24tb3ZlcmxhcHBpbmcgdGltZXMuIE5vdGUgdGhhdCBFQUdMIGFjdHVhbGx5IGFsbG93 cyB0aGUgc2FtZQorICAgIC8vIGNvbnRleHQgdG8gYmUgc2V0IGN1cnJlbnQgb24gbXVsdGlwbGUg dGhyZWFkcywgYXMgbG9uZyBhcyB0aGUKKyAgICAvLyBjYWxsaW5nIGNvZGUgcGVyZm9ybXMgc3Vm ZmljaWVudCBsb2NraW5nLCBidXQgdGhpcyBkaWZmZXJzCisgICAgLy8gc2lnbmlmaWNhbnRseSBm cm9tIEVHTCBzZW1hbnRpY3MsIHNvIEFOR0xFIGRpc2FsbG93cyB0aGlzIGF0CisgICAgLy8gaGln aGVyIGxldmVscy4KKworICAgIEVBR0xDb250ZXh0T2JqIG5ld0NvbnRleHQgPSBuaWw7CisgICAg aWYgKGNvbnRleHQpCisgICAgeworICAgICAgICBuZXdDb250ZXh0ID0gbUNvbnRleHQ7CisgICAg fQorICAgIGlmIChuZXdDb250ZXh0ICE9IG1DdXJyZW50Q29udGV4dHNbc3RkOjp0aGlzX3RocmVh ZDo6Z2V0X2lkKCldKQorICAgIHsKKyAgICAgICAgW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250 ZXh0Om5ld0NvbnRleHRdOworICAgICAgICBtQ3VycmVudENvbnRleHRzW3N0ZDo6dGhpc190aHJl YWQ6OmdldF9pZCgpXSA9IG5ld0NvbnRleHQ7CisgICAgfQogICAgIHJldHVybiBlZ2w6Ok5vRXJy b3IoKTsKIH0KIAo= 409390 2020-09-22 12:40:33 -0700 2020-09-22 13:11:14 -0700 Patch bug-216106-20200922224031.patch text/plain 23051 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjY3MzQ3CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggYTNmYjY4OWRlNjEwNTlmMzdkZTRhMTkwMTJhZmUzZWI1ZmExMTM0MS4uMDNiNTJkNGQ0MGQ2 NGM1YmM5OTYyZTczZmY0MTU1MzMxYWNmOTUxOCAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDI5IEBACisyMDIwLTA5LTIyICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXSzFdIENyYXNoZXMgd2hlbiB1c2luZyBBTkdM RSBXZWJHTCBmcm9tIGFub3RoZXIgdGhyZWFkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMTYxMDYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY4NjAy NDUyPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAgICBNYWtl cyBBTkdMRSBzdXBwb3J0IHNldHRpbmcgdGhlIEVBR0wgY29udGV4dCBvbiBtdWx0aXBsZQorICAg ICAgICB0aHJlYWRzLCBub24tc2ltdWx0YW5lb3NseS4KKworICAgICAgICBNYWtlcyBBTkdMRSBz dXBwb3J0IHJlYWwgdW5zZXQgb2YgdGhlIHVuZGVybHlpbmcgY29udGV4dC4KKyAgICAgICAgKG90 aGVyd2lzZSB0aGUgY29udGV4dCB3aWxsIGxlYWspLgorCisgICAgICAgIFdvcmsgaW4gcHJvZ3Jl c3MuCisgICAgICAgIEhPV1RPOgorICAgICAgICAxKSBEZXRlY3QgdGhlIHBsYWNlIHdoZXJlIGEg V0sxIGNhbGwgZXhpdHMuCisgICAgICAgIDIpIFByZWZlcmFibHkgZGV0ZWN0IHRoZSBwbGFjZSB3 aGVyZSBXSzEgY2FsbCBlbnRlcnMuCisKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvRGlzcGxheS5j cHA6CisgICAgICAgIChlZ2w6OkRpc3BsYXk6Om1ha2VDdXJyZW50KToKKyAgICAgICAgKiBzcmMv bGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oOgorICAgICAgICAqIHNyYy9s aWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLm1tOgorICAgICAgICAocng6OkRp c3BsYXlFQUdMOjppbml0aWFsaXplKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5RUFHTDo6dGVybWlu YXRlKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5RUFHTDo6bWFrZUN1cnJlbnRTdXJmYWNlbGVzcyk6 CisKIDIwMjAtMDktMTEgIEphbWVzIERhcnBpbmlhbiAgPGpkYXJwaW5pYW5AY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFtXZWJHTDJdIFN1cHBvcnQgRVhUX2NvbG9yX2J1ZmZlcl9oYWxmX2Zsb2F0 IG9uIFdlYkdMIDIuMCBjb250ZXh0cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDRmZDE1NTU0NjAwMzhlZDUyNjZi ZDE0NTE4ZGRkYzBkNThjMWFiZmEuLjc5ZWY0YzI5MGRjMDdmNzRhMDZmZTY2MjFkZjlhNTk4NDM5 MzJjZGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAyMC0wOS0yMiAgS2ltbW8gS2lu bnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgorCisgICAgICAgIFtpT1MgV0sxXSBDcmFzaGVz IHdoZW4gdXNpbmcgQU5HTEUgV2ViR0wgZnJvbSBhbm90aGVyIHRocmVhZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE2MTA2CisgICAgICAgIDxyZGFy Oi8vcHJvYmxlbS82ODYwMjQ1Mj4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBObyBuZXcgdGVzdHMgKE9PUFMhKS4KKworICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW06CisgICAgICAg IChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6fkdyYXBoaWNzQ29udGV4dEdMT3Bl bkdMKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxlYXNl Q3VycmVudENvbnRleHRJZk5lZWRlZCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvb3Bl bmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmg6CisgICAgICAgICogcGxhdGZvcm0vaW9zL3dh ay9XZWJDb3JlVGhyZWFkLm1tOgorICAgICAgICAoV2ViUnVuTG9vcFVubG9ja0ludGVybmFsKToK KwogMjAyMC0wOS0yMSAgQW50b2luZSBRdWludCAgPGdyYW91dHNAd2Via2l0Lm9yZz4KIAogICAg ICAgICBSZW1vdmUgZGVkaWNhdGVkIEhhc2hTZXQ8RWxlbWVudCo+IGZvciBEb2N1bWVudFRpbWVs aW5lOjpydW5uaW5nQW5pbWF0aW9uc0ZvckVsZW1lbnRBcmVBbGxBY2NlbGVyYXRlZCgpCmRpZmYg LS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5jcHAg Yi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5jcHAKaW5kZXgg ZTNlYmUzMjVkYWEyODhlODVjOWJmODAzN2EwMDUzMTA1MjQ3YjdhOC4uYjU0ZmQ5ZDllYTcwYmI2 YTQ3MzlmYjk2MDJiMThkMWNiMGEzNjcyMyAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkv QU5HTEUvc3JjL2xpYkFOR0xFL0Rpc3BsYXkuY3BwCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJBTkdMRS9EaXNwbGF5LmNwcApAQCAtMTIxOCwxMSArMTIxOCwxOSBAQCBFcnJv ciBEaXNwbGF5OjptYWtlQ3VycmVudChjb25zdCBUaHJlYWQgKnRocmVhZCwKICAgICBpZiAocHJl dmlvdXNDb250ZXh0KQogICAgIHsKICAgICAgICAgQU5HTEVfVFJZKHByZXZpb3VzQ29udGV4dC0+ dW5NYWtlQ3VycmVudCh0aGlzKSk7CisgICAgICAgIC8vIEVHTCBTcGVjaWZpY2F0aW9uIDEuNSAz LjcuMyBCaW5kaW5nIENvbnRleHRzIGFuZCBEcmF3YWJsZXMKKyAgICAgICAgLy8gcGcuIDU4Cisg ICAgICAgIC8vICJJZiB0aGUgY2FsbGluZyB0aHJlYWQgYWxyZWFkeSBoYXMgYSBjdXJyZW50IGNv bnRleHQgb2YgdGhlIHNhbWUgY2xpZW50IEFQSQorICAgICAgICAvLyAgdHlwZSBhcyBjdHgsIHRo ZW4gdGhhdCBjb250ZXh0IGlzIGZsdXNoZWQgYW5kIG1hcmtlZCBhcyBubyBsb25nZXIgY3VycmVu dC4iCisgICAgICAgIC8vIHBnLiA1OQorICAgICAgICAvLyAiVGhlIGN1cnJlbnRseSBib3VuZCBj b250ZXh0IGZvciB0aGUgY2xpZW50IEFQSSBzcGVjaWZpZWQgYnkgY3VycmVudCByZW5kZXJpbmcK KyAgICAgICAgLy8gIEFQSSBpcyBmbHVzaGVkIGFuZCBtYXJrZWQgbm8gbG9uZ2VyIGN1cnJlbnQu IgorICAgICAgICBBTkdMRV9UUlkocHJldmlvdXNDb250ZXh0LT5mbHVzaCgpKTsKICAgICB9CiAK ICAgICBBTkdMRV9UUlkobUltcGxlbWVudGF0aW9uLT5tYWtlQ3VycmVudChkcmF3U3VyZmFjZSwg cmVhZFN1cmZhY2UsIGNvbnRleHQpKTsKIAotICAgIGlmIChjb250ZXh0ICE9IG51bGxwdHIpCisg ICAgaWYgKGNvbnRleHQgIT0gbnVsbHB0ciAmJiBwcmV2aW91c0NvbnRleHQgIT0gY29udGV4dCkK ICAgICB7CiAgICAgICAgIEFOR0xFX1RSWShjb250ZXh0LT5tYWtlQ3VycmVudCh0aGlzLCBkcmF3 U3VyZmFjZSwgcmVhZFN1cmZhY2UpKTsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oIGIv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2VhZ2wvRGlz cGxheUVBR0wuaAppbmRleCAyNjFiYTQwN2QxOTNiZWI5MzEyYWQxMTA2ZDhjNmJlODBkODczOWQ5 Li42ZGIzYzk0ODhkMzE4ZTgyZmVkNmRlYTZmOGFlOGUxYmFkMDA1MzY5IDEwMDY0NAotLS0gYS9T b3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNw bGF5RUFHTC5oCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5k ZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmgKQEAgLTEzLDYgKzEzLDggQEAKIAogI2lmIGRlZmlu ZWQoQU5HTEVfUExBVEZPUk1fSU9TKSAmJiAhZGVmaW5lZChBTkdMRV9QTEFURk9STV9NQUNDQVRB TFlTVCkKIAorI2luY2x1ZGUgPHRocmVhZD4KKwogI2luY2x1ZGUgImxpYkFOR0xFL3JlbmRlcmVy L2dsL0Rpc3BsYXlHTC5oIgogCiAjaWZkZWYgX19PQkpDX18KQEAgLTkzLDYgKzk1LDcgQEAgY2xh c3MgRGlzcGxheUVBR0wgOiBwdWJsaWMgRGlzcGxheUdMCiAKICAgICBlZ2w6OkRpc3BsYXkgKm1F R0xEaXNwbGF5OwogICAgIEVBR0xDb250ZXh0T2JqIG1Db250ZXh0OworICAgIHN0ZDo6dW5vcmRl cmVkX3NldDxzdGQ6OnRocmVhZDo6aWQ+IG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50OwogfTsK IAogfSAgLy8gbmFtZXNwYWNlIHJ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdM RS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbSBiL1NvdXJjZS9U aGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdM Lm1tCmluZGV4IGNlYjJkMTFmYzc5OWUzOTYyNWM3NzhhNzIyNTY1MmFhZWM4ODhhMTEuLjZkNTcz MDIzMWI1Mjg1MDRmZjJhMWM2ZDBkYzIxZDliN2Y1YmFlYTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9U aGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdM Lm1tCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9n bC9lYWdsL0Rpc3BsYXlFQUdMLm1tCkBAIC03Niw3ICs3NiwxMCBAQCBlZ2w6OkVycm9yIERpc3Bs YXlFQUdMOjppbml0aWFsaXplKGVnbDo6RGlzcGxheSAqZGlzcGxheSkKICAgICB7CiAgICAgICAg IHJldHVybiBlZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIkNvdWxkIG5vdCBjcmVhdGUgdGhl IEVBR0wgY29udGV4dC4iOwogICAgIH0KLSAgICBbRUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRl eHQ6bUNvbnRleHRdOworICAgIGlmICghW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0Om1D b250ZXh0XSkgeworICAgICAgICByZXR1cm4gZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIkNv dWxkIHNldCB0aGUgRUFHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICB9CisgICAgbVRocmVhZHNX aXRoQ29udGV4dEN1cnJlbnQuaW5zZXJ0KHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgpKTsKIAog ICAgIC8vIFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZ2V0UHJvY0FkZHJlc3MgaW4gRUFHTCBzbyB3 ZSBvcGVuIHRoZSBkeWxpYiBkaXJlY3RseQogICAgIHZvaWQgKmhhbmRsZSA9IGRsb3BlbihrT3Bl bkdMRVNEeWxpYk5hbWUsIFJUTERfTk9XKTsKQEAgLTEwOSw2ICsxMTIsOCBAQCB2b2lkIERpc3Bs YXlFQUdMOjp0ZXJtaW5hdGUoKQogICAgICAgICBbRUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRl eHQ6bmlsXTsKICAgICAgICAgW21Db250ZXh0IHJlbGVhc2VdOwogICAgICAgICBtQ29udGV4dCA9 IG51bGxwdHI7CisgICAgICAgIG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50LmVyYXNlKHN0ZDo6 dGhpc190aHJlYWQ6OmdldF9pZCgpKTsKKwogICAgIH0KIH0KIApAQCAtMzA4LDggKzMxMywzMCBA QCBnbDo6VmVyc2lvbiBEaXNwbGF5RUFHTDo6Z2V0TWF4U3VwcG9ydGVkRVNWZXJzaW9uKCkgY29u c3QKIAogZWdsOjpFcnJvciBEaXNwbGF5RUFHTDo6bWFrZUN1cnJlbnRTdXJmYWNlbGVzcyhnbDo6 Q29udGV4dCAqY29udGV4dCkKIHsKLSAgICAvLyBXZSBoYXZlIG5vdGhpbmcgdG8gZG8gYXMgbUNv bnRleHQgaXMgYWx3YXlzIGN1cnJlbnQsIGFuZCB0aGF0IEVBR0wgaXMgc3VyZmFjZWxlc3MgYnkK LSAgICAvLyBkZWZhdWx0LgorICAgIGF1dG8gdGhyZWFkSWQgPSBzdGQ6OnRoaXNfdGhyZWFkOjpn ZXRfaWQoKTsKKyAgICBib29sIHNob3VsZEhhdmVDdXJyZW50Q29udGV4dCA9IGNvbnRleHQ7Cisg ICAgYm9vbCBoYXNDdXJyZW50Q29udGV4dCA9CisgICAgICAgIG1UaHJlYWRzV2l0aENvbnRleHRD dXJyZW50LmZpbmQodGhyZWFkSWQpICE9IG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50LmVuZCgp OworICAgIAorICAgIGlmIChzaG91bGRIYXZlQ3VycmVudENvbnRleHQgIT0gaGFzQ3VycmVudENv bnRleHQpCisgICAgeworICAgICAgICBpZiAoc2hvdWxkSGF2ZUN1cnJlbnRDb250ZXh0KQorICAg ICAgICB7CisgICAgICAgICAgICBpZiAoIVtFQUdMQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDpt Q29udGV4dF0pCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgcmV0dXJuIGVnbDo6RWds QmFkQWxsb2MoKSA8PCAiQ291bGQgbm90IG1ha2UgY29udGV4dCBjdXJyZW50LiI7CisgICAgICAg ICAgICB9CisgICAgICAgICAgICBtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5pbnNlcnQodGhy ZWFkSWQpOworICAgICAgICB9CisgICAgICAgIGVsc2UKKyAgICAgICAgeworICAgICAgICAgICAg aWYgKCFbRUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6bmlsXSkKKyAgICAgICAgICAgIHsK KyAgICAgICAgICAgICAgICByZXR1cm4gZWdsOjpFZ2xCYWRBbGxvYygpIDw8ICJDb3VsZCBub3Qg Y2xlYXIgY3VycmVudCBjb250ZXh0LiI7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBtVGhy ZWFkc1dpdGhDb250ZXh0Q3VycmVudC5lcmFzZSh0aHJlYWRJZCk7CisgICAgICAgIH0KKyAgICB9 CiAgICAgcmV0dXJuIGVnbDo6Tm9FcnJvcigpOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRHTE9wZW5HTENvY29h Lm1tIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3NDb250 ZXh0R0xPcGVuR0xDb2NvYS5tbQppbmRleCBhNjI2YTE1MmY4ZTIzOTQ0MGJlOTBkNWE4YTdmNTk0 MzM3NDg5NjMzLi5iM2Q5ODA2M2I2NDBiY2UwYTliYWM0ZjZkYTI1MmM4ZWQ4YmM4YTA2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGljc0Nv bnRleHRHTE9wZW5HTENvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW0KQEAgLTU1Niw3ICs1NTYs NiBAQCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0woR3Jh cGhpY3NDb250ZXh0R0xBdHRyaWJ1dGVzIGF0dAogR3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6On5H cmFwaGljc0NvbnRleHRHTE9wZW5HTCgpCiB7CiAgICAgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xN YW5hZ2VyOjpzaGFyZWRNYW5hZ2VyKCkucmVtb3ZlQ29udGV4dCh0aGlzKTsKLQogICAgIGlmICht X2NvbnRleHRPYmopIHsKICAgICAgICAgR3JhcGhpY3NDb250ZXh0R0xBdHRyaWJ1dGVzIGF0dHJz ID0gY29udGV4dEF0dHJpYnV0ZXMoKTsKIApAQCAtNjUzLDYgKzY1MiwyNiBAQCBib29sIEdyYXBo aWNzQ29udGV4dEdMT3BlbkdMOjptYWtlQ29udGV4dEN1cnJlbnQoKQogICAgIHJldHVybiB0cnVl OwogfQogCisjaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKKworYm9vbCBHcmFwaGljc0NvbnRleHRH TE9wZW5HTDo6cmVsZWFzZUN1cnJlbnRDb250ZXh0SWZOZWVkZWQoKQoreworI2lmIFVTRShPUEVO R0xfRVMpCisgICAgcmV0dXJuIHRydWU7CisjZWxpZiBVU0UoQU5HTEUpCisgICAgaWYgKEVHTF9H ZXRDdXJyZW50Q29udGV4dCgpID09IEVHTF9OT19DT05URVhUKQorICAgICAgICByZXR1cm4gdHJ1 ZTsKKyAgICBFR0xEaXNwbGF5IGRpc3BsYXkgPSBFR0xfR2V0RGlzcGxheShFR0xfREVGQVVMVF9E SVNQTEFZKTsKKyAgICBpZiAoZGlzcGxheSA9PSBFR0xfTk9fRElTUExBWSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgIHJldHVybiBFR0xfTWFrZUN1cnJlbnQoZGlzcGxheSwgRUdMX05PX1NV UkZBQ0UsIEVHTF9OT19TVVJGQUNFLCBFR0xfTk9fQ09OVEVYVCk7CisjZWxzZQorI2Vycm9yIFVu c3VwcG9ydGVkIGdyYXBoaWNzIHBsYXRmb3JtLgorI2VuZGlmCit9CisKKyNlbmRpZgorCiB2b2lk IEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpjaGVja0dQVVN0YXR1cygpCiB7CiAgICAgaWYgKG1f ZmFpbE5leHRTdGF0dXNDaGVjaykgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaApp bmRleCBlOWNjNGZhY2QyMDMyZjllZTMxMTFhODU0MzUwMzEwNTU2NTk3YWJjLi4wNWNkYTU0YjY2 NmRjY2QxZjEyYjU5NjJiZGM1NTBiZmNiN2RlNWFiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0 R0xPcGVuR0wuaApAQCAtMTE5LDYgKzExOSw3IEBAIHB1YmxpYzoKICNlbmRpZgogCiAgICAgYm9v bCBtYWtlQ29udGV4dEN1cnJlbnQoKTsKKyAgICBzdGF0aWMgYm9vbCByZWxlYXNlQ3VycmVudENv bnRleHRJZk5lZWRlZCgpOwogCiAgICAgdm9pZCBhZGRDbGllbnQoQ2xpZW50JiBjbGllbnQpIHsg bV9jbGllbnRzLmFkZCgmY2xpZW50KTsgfQogICAgIHZvaWQgcmVtb3ZlQ2xpZW50KENsaWVudCYg Y2xpZW50KSB7IG1fY2xpZW50cy5yZW1vdmUoJmNsaWVudCk7IH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2lvcy93YWsvV2ViQ29yZVRocmVhZC5tbSBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2lvcy93YWsvV2ViQ29yZVRocmVhZC5tbQppbmRleCA1YWQ3ZmU1MTk4ZDI0 YzMwMzY2YTIzMGEwOTczMjRjNGEyNWM2OTRkLi42N2Q2MTc4MzQ3M2E0M2E0ZjcwZTQ1MDQwNDky MTI5OGEwYjUzOWJmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pb3Mvd2Fr L1dlYkNvcmVUaHJlYWQubW0KKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW9zL3dhay9X ZWJDb3JlVGhyZWFkLm1tCkBAIC0zMCw2ICszMCw3IEBACiAKICNpbXBvcnQgIkNvbW1vblZNLmgi CiAjaW1wb3J0ICJGbG9hdGluZ1BvaW50RW52aXJvbm1lbnQuaCIKKyNpbXBvcnQgIkdyYXBoaWNz Q29udGV4dEdMT3BlbkdMLmgiCiAjaW1wb3J0ICJMb2dnaW5nLmgiCiAjaW1wb3J0ICJSdW50aW1l QXBwbGljYXRpb25DaGVja3MuaCIKICNpbXBvcnQgIlRocmVhZEdsb2JhbERhdGEuaCIKQEAgLTU5 LDYgKzYwLDM2IEBACiAKICNkZWZpbmUgRGlzdGFudEZ1dHVyZSAgICg4NjQwMC4wICogMjAwMCAq IDM2NS4yNDI1ICsgODY0MDAuMCkgICAvLyBzYW1lIGFzICtbTlNEYXRlIGRpc3RhbnRGdXR1cmVd CiAKK25hbWVzcGFjZSB7CisvLyBSZWxlYXNlIGdsb2JhbCBzdGF0ZSB0aGF0IGlzIGFjY2Vzc2Vk IGZyb20gYm90aCB3ZWIgdGhyZWFkIGFzIHdlbGwKKy8vIGFzIGFueSBjbGllbnQgdGhyZWFkIHRo YXQgY2FsbHMuCit2b2lkIFdlYlRocmVhZFJlbGVhc2VDcm9zc1RocmVhZEdsb2JhbFN0YXRlKCkK K3sKKyAgICBBU1NFUlQoV2ViVGhyZWFkSXNDdXJyZW50KCkpOworCisgICAgLy8gT24gc29tZSBz ZXR1cHMsIHRoZSB1bmRlcmx5aW5nIGdyYXBoaWNzIGNvbnRleHQgY2Fubm90IGJlIGN1cnJlbnQg aW4gdHdvIHRocmVhZHMKKyAgICAvLyBhdCB0aGUgc2FtZSB0aW1lLgorICAgIFdlYkNvcmU6Okdy YXBoaWNzQ29udGV4dEdMT3BlbkdMOjp1bnNldEN1cnJlbnRDb250ZXh0SWZOZWVkZWQoKTsKK30K KworY2xhc3MgU2NvcGVkQ2xpZW50VGhyZWFkQ3Jvc3NUaHJlYWRHbG9iYWxTdGF0ZVJlc3RvcmUg eworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFNjb3BlZENsaWVudENyb3NzVGhyZWFkR2xvYmFs U3RhdGVSZXN0b3JlKTsKK3B1YmxpYzoKKyAgICBTY29wZWRDbGllbnRDcm9zc1RocmVhZEdsb2Jh bFN0YXRlUmVzdG9yZSgpCisgICAgICAgIDogbV9lYWdsQ29udGV4dChbRUFHTENvbnRleHQgY3Vy cmVudENvbnRleHRdKQorICAgIHsKKyAgICAgICAgCisgICAgfQorICAgIH5TY29wZWRDbGllbnRD cm9zc1RocmVhZEdsb2JhbFN0YXRlUmVzdG9yZSgpCisgICAgeworICAgICAgICBXZWJDb3JlOjpH cmFwaGljc0NvbnRleHRHTE9wZW5HTDo6dW5zZXRDdXJyZW50Q29udGV4dElmTmVlZGVkKCk7Cisg ICAgICAgIFtFQUdMQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDogbV9lYWdsQ29udGV4dC5nZXQo KV07CisgICAgfQorcHJpdmF0ZToKKyAgICBSZXRhaW5QdHI8RUFHTENvbnRleHQ+IG1fZWFnbENv bnRleHQ7Cit9OworfQorCiBzdGF0aWMgY29uc3QgY29uc3RleHByIFNlY29uZHMgRGVsZWdhdGVX YWl0SW50ZXJ2YWwgeyAxMF9zIH07CiAKIHN0YXRpYyB2b2lkIF9XZWJUaHJlYWRBdXRvTG9jaygp OwpAQCAtNDg2LDYgKzUxNyw4IEBAIHN0YXRpYyB2b2lkIFdlYlJ1bkxvb3BVbmxvY2tJbnRlcm5h bChBdXRvcmVsZWFzZVBvb2xPcGVyYXRpb24gcG9vbE9wZXJhdGlvbikKICAgICAgICAgICAgIFNl bmREZWxlZ2F0ZU1lc3NhZ2UoW2ludm9jYXRpb24gcmV0YWluXSk7CiAgICAgICAgIFtzQXN5bmNE ZWxlZ2F0ZXMgcmVtb3ZlQWxsT2JqZWN0c107CiAgICAgfQorICAgIC8vIFRPRE86IHByb2JhYmx5 IGRvZXMgbm90IHdvcmsgZHVlIHRvIGF1dG9yZWxlYXNlIHN0dWZmLgorICAgIC8vIFdlYlRocmVh ZFJlbGVhc2VDcm9zc1RocmVhZEdsb2JhbFN0YXRlKCk7CiAKICAgICBpZiAocG9vbE9wZXJhdGlv biA9PSBQdXNoT3JQb3BBdXRvcmVsZWFzZVBvb2wpCiAgICAgICAgIG9iamNfYXV0b3JlbGVhc2VQ b29sUG9wKGF1dG9yZWxlYXNlUG9vbE1hcmspOwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9n IGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDk4YjM2Y2M3YWQ3NTFhYmExMzA5Nzc3MzI4NDY5YTA2 NGIxYzFhZWQuLjNmNGE3YjJhYzRhZjE4OTMzN2IxOWZlYWIyYTViNjk2NzRhMTcwYTUgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx OCBAQAorMjAyMC0wOS0yMiAgS2ltbW8gS2lubnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgor CisgICAgICAgIFtpT1MgV0sxXSBDcmFzaGVzIHdoZW4gdXNpbmcgQU5HTEUgV2ViR0wgZnJvbSBh bm90aGVyIHRocmVhZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjE2MTA2CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS82ODYwMjQ1Mj4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkv Q29uZmlndXJhdGlvbnMvVGVzdFdlYktpdEFQSS54Y2NvbmZpZzoKKyAgICAgICAgKiBUZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAg KiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExlZ2FjeS9pb3MvV2ViR0xOb0NyYXNoT25PdGhl clRocmVhZEFjY2Vzcy5tbTogQWRkZWQuCisgICAgICAgICgtW1dlYkdMTm9DcmFzaE9uT3RoZXJU aHJlYWRBY2Nlc3NXZWJWaWV3RGVsZWdhdGUgd2ViVmlld0RpZEZpbmlzaExvYWQ6XSk6CisgICAg ICAgICgtW1dlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3NXZWJWaWV3RGVsZWdhdGUgd2Vi VmlldzpzaG91bGRTdGFydExvYWRXaXRoUmVxdWVzdDpuYXZpZ2F0aW9uVHlwZTpdKToKKyAgICAg ICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDIwLTA5LTIxICBLYXRlIENoZW5leSAgPGth dGhlcmluZV9jaGVuZXlAYXBwbGUuY29tPgogCiAgICAgICAgIEFsbG93IGFib3V0OmJsYW5rIHN1 YmZyYW1lIGxvYWRzIGZvciBub24gYXBwLWJvdW5kIHRvcCBmcmFtZXMKZGlmZiAtLWdpdCBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJhdGlvbnMvVGVzdFdlYktpdEFQSS54Y2NvbmZpZyBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJhdGlvbnMvVGVzdFdlYktpdEFQSS54Y2NvbmZp ZwppbmRleCBiYmRkZTg3NTE3OTM4NzNlMGQwZmEyZGNhNDIxZWQ1N2FjMGFiZjAwLi5hMzE0ODc2 ZTRkNGZmZDk1MTI2ZThjMDIxNWMwNDYwZTY3NTU5ZmI2IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0 V2ViS2l0QVBJL0NvbmZpZ3VyYXRpb25zL1Rlc3RXZWJLaXRBUEkueGNjb25maWcKKysrIGIvVG9v bHMvVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9UZXN0V2ViS2l0QVBJLnhjY29uZmlnCkBA IC02NSw3ICs2NSw3IEBAIE9USEVSX0xERkxBR1MgPSAkKGluaGVyaXRlZCkgJChVTkVYUE9SVEVE X1NZTUJPTF9MREZMQUdTKSAtbGd0ZXN0IC1mb3JjZV9sb2FkICQoCiBPVEhFUl9MREZMQUdTX1BM QVRGT1JNXyA9IC1mcmFtZXdvcmsgQ29jb2EgLWZyYW1ld29yayBDYXJib247CiAKIC8vIEZJWE1F OiBUaGlzIHNob3VsZCBub3QgYmUgYnVpbHQgb24gaU9TLiBJbnN0ZWFkIHdlIHNob3VsZCBjcmVh dGUgYW5kIHVzZSBhIFRlc3RXZWJLaXRBUEkgYXBwbGljYXRpb24uCi1PVEhFUl9MREZMQUdTX1BM QVRGT1JNX2NvY29hdG91Y2ggPSAtZnJhbWV3b3JrIFdlYkNvcmUgLWZyYW1ld29yayBDb3JlR3Jh cGhpY3MgLWZyYW1ld29yayBVSUtpdCAtZnJhbWV3b3JrIE1vYmlsZUNvcmVTZXJ2aWNlczsKK09U SEVSX0xERkxBR1NfUExBVEZPUk1fY29jb2F0b3VjaCA9IC1mcmFtZXdvcmsgV2ViQ29yZSAtZnJh bWV3b3JrIENvcmVHcmFwaGljcyAtZnJhbWV3b3JrIFVJS2l0IC1mcmFtZXdvcmsgTW9iaWxlQ29y ZVNlcnZpY2VzIC1mcmFtZXdvcmsgT3BlbkdMRVM7CiAKIExEX1JVTlBBVEhfU0VBUkNIX1BBVEhT ID0gIkBsb2FkZXJfcGF0aCI7CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNDFjNGExNzU0 ZTAzMWExMWEwMzAxNDJiM2YxNjM4YTU3OTNmMWIwZS4uYTY4Mjk3YjgzOGFlNGQ2OTkzODU1ODAw M2E4ODZjODcyZTg4NDZkYSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2Vi S2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTU0Nyw2ICs1NDcs NyBAQAogCQk3QUU5RTUwOTFBRTVBRThCMDBDRjg3NEIgLyogdGVzdC5wZGYgaW4gQ29weSBSZXNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0FFOUU1MDgxQUU1QUU4 QjAwQ0Y4NzRCIC8qIHRlc3QucGRmICovOyB9OwogCQk3QUVBRDQ3RjFFMjAxMTZDMDA0MTZFRkUg LyogQ3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0FFQUQ0N0MxRTIwMTEzODAwNDE2RUZFIC8qIENy b3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5tbSAqLzsgfTsKIAkJN0FFQUQ0ODExRTIwMTIy NzAwNDE2RUZFIC8qIENyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5odG1sIGluIENvcHkg UmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDdBRUFENDdEMUUy MDExNEUwMDQxNkVGRSAvKiBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbCAqLzsg fTsKKwkJN0I3RDA5NkEyNTE5RjhGOTAwMTdBMDc4IC8qIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJl YWRBY2Nlc3MubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA3QjdEMDk2OTI1MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFj Y2Vzcy5tbSAqLzsgfTsKIAkJN0MxQUY3OTUxRThEQ0JBQjAwMjY0NUI5IC8qIFByZXBhcmVGb3JN b3ZlVG9XaW5kb3cubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA3QzFBRjc5MzFFOERDQkFCMDAyNjQ1QjkgLyogUHJlcGFyZUZvck1vdmVUb1dpbmRvdy5t bSAqLzsgfTsKIAkJN0MzOTY1MDYxQ0RENzRGOTAwOTREQkI4IC8qIENvbG9yVGVzdHMuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0MzOTY1MDUxQ0RE NzRGOTAwOTREQkI4IC8qIENvbG9yVGVzdHMuY3BwICovOyB9OwogCQk3QzNEQjhFNDFEMTIxMjlC MDBBRThDQzMgLyogQ29tbWFuZEJhY2tGb3J3YXJkLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0MzREI4RTIxRDEyMTI5QjAwQUU4Q0MzIC8qIENvbW1h bmRCYWNrRm9yd2FyZC5tbSAqLzsgfTsKQEAgLTIzMDIsNiArMjMwMyw3IEBACiAJCTdBRTlFNTA4 MUFFNUFFOEIwMENGODc0QiAvKiB0ZXN0LnBkZiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBsYXN0S25vd25GaWxlVHlwZSA9IGltYWdlLnBkZjsgcGF0aCA9IHRlc3QucGRmOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk3QUVBRDQ3QzFFMjAxMTM4MDA0MTZFRkUgLyogQ3Jvc3NQ YXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2Jq Y3BwOyBwYXRoID0gQ3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLm1tOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk3QUVBRDQ3RDFFMjAxMTRFMDA0MTZFRkUgLyogQ3Jvc3NQYXJ0 aXRpb25GaWxlU2NoZW1lQWNjZXNzLmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7IG5hbWUgPSBD cm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbDsgcGF0aCA9IFRlc3RzL21hYy9Dcm9z c1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbDsgc291cmNlVHJlZSA9IFNPVVJDRV9ST09U OyB9OworCQk3QjdEMDk2OTI1MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhlclRo cmVhZEFjY2Vzcy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdlYkdMTm9DcmFzaE9uT3RoZXJU aHJlYWRBY2Nlc3MubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdDMUFGNzkzMUU4 RENCQUIwMDI2NDVCOSAvKiBQcmVwYXJlRm9yTW92ZVRvV2luZG93Lm1tICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gUHJlcGFyZUZvck1vdmVUb1dpbmRvdy5tbTsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJN0MzOTY1MDUxQ0RENzRGOTAwOTREQkI4IC8qIENv bG9yVGVzdHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQ29sb3JU ZXN0cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdDM0RCOEUyMUQxMjEyOUIw MEFFOENDMyAvKiBDb21tYW5kQmFja0ZvcndhcmQubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5vYmpjcHA7IHBhdGggPSBDb21tYW5kQmFja0ZvcndhcmQubW07IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CkBAIC00NTkwLDYgKzQ1OTIsNyBAQAogCQkJCUNEQzA5MzJBMjFDODcyQzEwMDMw QzRCMCAvKiBTY3JvbGxpbmdEb2VzTm90UGF1c2VNZWRpYS5tbSAqLywKIAkJCQlGNDM0Q0ExOTIy RTY1QkNBMDA1RERCMjYgLyogU2Nyb2xsVG9SZXZlYWxTZWxlY3Rpb24ubW0gKi8sCiAJCQkJMEY0 RkZBOUQxRUQzQUE4NTAwRjcxMTFGIC8qIFNuYXBzaG90VmlhUmVuZGVySW5Db250ZXh0Lm1tICov LAorCQkJCTdCN0QwOTY5MjUxOUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhy ZWFkQWNjZXNzLm1tICovLAogCQkJCTMxRTlCREEwMjQ3RjRDNjIwMDJFNTFBMiAvKiBXZWJHTFBy ZXBhcmVEaXNwbGF5T25XZWJUaHJlYWQubW0gKi8sCiAJCQkJMkRDOTQ1MTYyNEQ4QUMwMjAwNDMw Mzc2IC8qIFdlYlRocmVhZExvY2subW0gKi8sCiAJCQkpOwpAQCAtNTQ2Myw2ICs1NDY2LDcgQEAK IAkJCQk3QzgzRTA0QzFEMEE2NDE4MDBGRUJDRjMgLyogV2ViQ29yZU5TVVJMU2Vzc2lvbi5tbSBp biBTb3VyY2VzICovLAogCQkJCTU3QTc5ODU3MjI0QUIzNEUwMEE3RjZGMSAvKiBXZWJDcnlwdG9N YXN0ZXJLZXkubW0gaW4gU291cmNlcyAqLywKIAkJCQlDMUZGOUVEQjI0NDY0NEYwMDA4MzlBRTQg LyogV2ViRmlsdGVyLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJN0I3RDA5NkEyNTE5RjhGOTAwMTdB MDc4IC8qIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3MubW0gaW4gU291cmNlcyAqLywK IAkJCQk1Qzk3M0Y1QzFGNThFRjhCMDAzNTlDMjcgLyogV2ViR0xQb2xpY3kubW0gaW4gU291cmNl cyAqLywKIAkJCQkzMUU5QkRBMTI0N0Y0QzYyMDAyRTUxQTIgLyogV2ViR0xQcmVwYXJlRGlzcGxh eU9uV2ViVGhyZWFkLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJN0NDRTdFQUIxQTQxMUEyNDAwNDQ3 QzRDIC8qIFdlYktpdEFnbm9zdGljVGVzdC5tbSBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMTm9DcmFzaE9u T3RoZXJUaHJlYWRBY2Nlc3MubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExl Z2FjeS9pb3MvV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbQpuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41 M2I2ZTA5YjJmNjY4ZDdiM2I5MjJmZGZmZmRlMjc4N2M1ODQ1MTJlCi0tLSAvZGV2L251bGwKKysr IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMTm9DcmFz aE9uT3RoZXJUaHJlYWRBY2Nlc3MubW0KQEAgLTAsMCArMSwxNDkgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBB UyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgor ICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbXBv cnQgImNvbmZpZy5oIgorCisjaWYgSEFWRShVSVdFQlZJRVcpCisKKyNpbXBvcnQgIlBsYXRmb3Jt VXRpbGl0aWVzLmgiCisjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9KU1ZpcnR1YWxNYWNoaW5lLmg+ CisjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9KU1ZpcnR1YWxNYWNoaW5lSW50ZXJuYWwuaD4KKyNp bXBvcnQgPE9wZW5HTEVTL0VBR0wuaD4KKyNpbXBvcnQgPFVJS2l0L1VJS2l0Lmg+CisjaW1wb3J0 IDxXZWJDb3JlL1dlYkNvcmVUaHJlYWQuaD4KKyNpbXBvcnQgPHN0ZGxpYi5oPgorI2ltcG9ydCA8 d3RmL1JldGFpblB0ci5oPgorCituYW1lc3BhY2UgeworYm9vbCBkaWRGaW5pc2hMb2FkOworYm9v bCBkaWRGaW5pc2hUZXN0OworfQorCitAaW50ZXJmYWNlIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJl YWRBY2Nlc3NXZWJWaWV3RGVsZWdhdGUgOiBOU09iamVjdCA8VUlXZWJWaWV3RGVsZWdhdGU+CitA ZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzV2Vi Vmlld0RlbGVnYXRlCisKK0lHTk9SRV9XQVJOSU5HU19CRUdJTigiZGVwcmVjYXRlZC1pbXBsZW1l bnRhdGlvbnMiKQorLSAodm9pZCl3ZWJWaWV3RGlkRmluaXNoTG9hZDooVUlXZWJWaWV3ICopd2Vi VmlldworeworICAgIGRpZEZpbmlzaExvYWQgPSB0cnVlOworfQorCistIChCT09MKXdlYlZpZXc6 KFVJV2ViVmlldyAqKXdlYlZpZXcgc2hvdWxkU3RhcnRMb2FkV2l0aFJlcXVlc3Q6KE5TVVJMUmVx dWVzdCAqKXJlcXVlc3QgbmF2aWdhdGlvblR5cGU6KFVJV2ViVmlld05hdmlnYXRpb25UeXBlKW5h dmlnYXRpb25UeXBlCit7CisgICAgaWYgKFtyZXF1ZXN0LlVSTC5zY2hlbWUgaXNFcXVhbFRvU3Ry aW5nOkAiY2FsbGJhY2siXSAmJiBbcmVxdWVzdC5VUkwucmVzb3VyY2VTcGVjaWZpZXIgaXNFcXVh bFRvU3RyaW5nOkAiZGlkRmluaXNoVGVzdCJdKSB7CisgICAgICAgIGRpZEZpbmlzaFRlc3QgPSB0 cnVlOworICAgICAgICByZXR1cm4gTk87CisgICAgfQorCisgICAgcmV0dXJuIFlFUzsKK30KK0lH Tk9SRV9XQVJOSU5HU19FTkQKKworQGVuZAorCituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisK Ky8vIFRlc3QgdGhhdCB0ZXN0cyBiZWhhdmlvciBvZiBVSVdlYlZpZXcgQVBJIHdpdGggcmVnYXJk cyB0byBXZWJHTDoKKy8vIDEpIFdlYkdMIGNhbiBiZSBydW4gb24gd2ViIHRocmVhZAorLy8gMikg V2ViR0wgY2FuIGJlIHJ1biBvbiBjbGllbnQgdGhyZWFkcywgZS5nLiBVSSB0aHJlYWQgcnVubmlu ZyB1c2VyCisvLyAgICBpbnRlcmFjdGlvbi4KKy8vIDMpIFdlYkdMIHJ1biBvbiBjbGllbnQgdGhy ZWFkcyBkb2VzIG5vdCBjaGFuZ2UgdXNlciBFQUdMIGNvbnRleHQuCitURVNUKFdlYktpdExlZ2Fj eSwgV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2VzcykKK3sKKyAgICBjb25zdCB1bnNpZ25l ZCB0ZXN0SXRlcmF0aW9ucyA9IDEwOworICAgIAorICAgIFJldGFpblB0cjxVSVdpbmRvdz4gdWlX aW5kb3cgPSBhZG9wdE5TKFtbVUlXaW5kb3cgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNNYWtlUmVj dCgwLCAwLCA4MDAsIDYwMCldKTsKKyAgICBSZXRhaW5QdHI8VUlXZWJWaWV3PiB1aVdlYlZpZXcg PSBhZG9wdE5TKFtbVUlXZWJWaWV3IGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TTWFrZVJlY3QoMCwg MCwgODAwLCA2MDApXSk7CisgICAgW3VpV2luZG93IGFkZFN1YnZpZXc6dWlXZWJWaWV3LmdldCgp XTsKKyAgICAKKyAgICBBU1NFUlRfVFJVRShXZWJUaHJlYWRJc0VuYWJsZWQoKSk7CisgICAgRVhQ RUNUX1RSVUUoIVtFQUdMQ29udGV4dCBjdXJyZW50Q29udGV4dF0pOworICAgIFJldGFpblB0cjxF QUdMQ29udGV4dD4gY2xpZW50Q29udGV4dCA9IGFkb3B0TlMoW1tFQUdMQ29udGV4dCBhbGxvY10g aW5pdFdpdGhBUEk6IGtFQUdMUmVuZGVyaW5nQVBJT3BlbkdMRVMzXSk7CisgICAgW0VBR0xDb250 ZXh0IHNldEN1cnJlbnRDb250ZXh0OiBjbGllbnRDb250ZXh0LmdldCgpXTsKKyAgICBFWFBFQ1Rf RVEoW0VBR0xDb250ZXh0IGN1cnJlbnRDb250ZXh0XSwgY2xpZW50Q29udGV4dC5nZXQoKSk7CisK KyAgICBSZXRhaW5QdHI8V2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxl Z2F0ZT4gdWlEZWxlZ2F0ZSA9IGFkb3B0TlMoW1tXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNj ZXNzV2ViVmlld0RlbGVnYXRlIGFsbG9jXSBpbml0XSk7CisgICAgdWlXZWJWaWV3LmdldCgpLmRl bGVnYXRlID0gdWlEZWxlZ2F0ZS5nZXQoKTsKKworICAgIE5TU3RyaW5nKiB0ZXN0SHRtbCA9IEBS IkhUTUwoPGJvZHk+Cis8c2NyaXB0PgorZnVuY3Rpb24gcnVuVGVzdCgpIHsKKyAgICBsZXQgY2Fu dmFzID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiY2FudmFzIik7CisgICAgY2FudmFzLndpZHRo ID0gMTAwOworICAgIGNhbnZhcy5oZWlnaHQgPSAxMDA7CisgICAgbGV0IGdsID0gY2FudmFzLmdl dENvbnRleHQoIndlYmdsIik7CisgICAgZ2wuY2xlYXJDb2xvcigwLCAxLCAwLCAxKTsKKyAgICBn bC5jbGVhcihnbC5DT0xPUl9CVUZGRVJfQklUKTsKKyAgICB3aW5kb3cubG9jYXRpb24gPSAiY2Fs bGJhY2s6ZGlkRmluaXNoVGVzdCI7Cit9Cis8L3NjcmlwdD4pSFRNTCI7CisgICAgW3VpV2ViVmll dyBsb2FkSFRNTFN0cmluZzp0ZXN0SHRtbCBiYXNlVVJMOm5pbF07CisKKyAgICBVdGlsOjpydW4o JmRpZEZpbmlzaExvYWQpOworCisgICAgUmV0YWluUHRyPEpTQ29udGV4dD4ganNDb250ZXh0ID0g W3VpV2ViVmlldyB2YWx1ZUZvcktleVBhdGg6QCJkb2N1bWVudFZpZXcud2ViVmlldy5tYWluRnJh bWUuamF2YVNjcmlwdENvbnRleHQiXTsKKyAgICBFWFBFQ1RfVFJVRSghIWpzQ29udGV4dC5nZXQo KSk7CisgICAgUmV0YWluUHRyPEpTVmlydHVhbE1hY2hpbmU+IGpzVk0gPSBbanNDb250ZXh0IHZp cnR1YWxNYWNoaW5lXTsKKyAgICBFWFBFQ1RfVFJVRShbanNWTSBpc1dlYlRocmVhZEF3YXJlXSk7 CisgICAgLy8gUmVsZWFzZSBXZWJUaHJlYWQgbG9jay4KKyAgICBVdGlsOjpzcGluUnVuTG9vcCgx KTsKKyAgICBFWFBFQ1RfRkFMU0UoV2ViVGhyZWFkSXNMb2NrZWQoKSk7CisgICAgCisgICAgZm9y ICh1bnNpZ25lZCBpID0gMDsgaSA8IHRlc3RJdGVyYXRpb25zOyBpKyspIHsKKyAgICAgICAgLy8g UnVuIFdlYkdMIG9uIGNsaWVudCB0aHJlYWQsIGluIHRoaXMgY2FzZSB0aGlzIHRocmVhZCwgbWFp biB0aHJlYWQuCisgICAgICAgIFtqc0NvbnRleHQgZXZhbHVhdGVTY3JpcHQ6IEAicnVuVGVzdCgp OyJdOworICAgICAgICBFWFBFQ1RfVFJVRShkaWRGaW5pc2hUZXN0KTsKKyAgICAgICAgZGlkRmlu aXNoVGVzdCA9IGZhbHNlOworICAgICAgICAvLyBDbGllbnQgY2xvYmJlcnMgRUFHTENvbnRleHQg YmV0d2VlbiBjYWxscyB0aGF0IHJ1biBXZWJHTCBvbiBjbGllbnQgdGhyZWFkLgorICAgICAgICBb RUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6IGNsaWVudENvbnRleHQuZ2V0KCldOworICAg ICAgICBbanNDb250ZXh0IGV2YWx1YXRlU2NyaXB0OiBAInJ1blRlc3QoKTsiXTsKKyAgICAgICAg RVhQRUNUX1RSVUUoZGlkRmluaXNoVGVzdCk7CisgICAgICAgIGRpZEZpbmlzaFRlc3QgPSBmYWxz ZTsKKyAgICAgICAgCisgICAgICAgIC8vIFJ1biBXZWJHTCBvbiB3ZWIgdGhyZWFkLgorICAgICAg ICBbdWlXZWJWaWV3IHN0cmluZ0J5RXZhbHVhdGluZ0phdmFTY3JpcHRGcm9tU3RyaW5nOkAic2V0 VGltZW91dChydW5UZXN0LCAxMCk7Il07CisgICAgICAgIEVYUEVDVF9GQUxTRShkaWRGaW5pc2hU ZXN0KTsKKyAgICAgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hUZXN0KTsKKyAgICAgICAgZGlkRmlu aXNoVGVzdCA9IGZhbHNlOworICAgIH0KKworICAgIC8vIEFkZGl0aW9uYWwgdGVzdCB0aGF0IG5p bCBFQUdMQ29udGV4dCBzdGF5cyBuaWwuCisgICAgW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250 ZXh0OiBuaWxdOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCB0ZXN0SXRlcmF0aW9uczsg aSsrKSB7CisgICAgICAgIFtqc0NvbnRleHQgZXZhbHVhdGVTY3JpcHQ6IEAicnVuVGVzdCgpOyJd OworICAgICAgICBFWFBFQ1RfRVEoW0VBR0xDb250ZXh0IGN1cnJlbnRDb250ZXh0XSwgbmlsKTsK KyAgICAgICAgRVhQRUNUX1RSVUUoZGlkRmluaXNoVGVzdCk7CisgICAgICAgIGRpZEZpbmlzaFRl c3QgPSBmYWxzZTsKKyAgICAgICAgW3VpV2ViVmlldyBzdHJpbmdCeUV2YWx1YXRpbmdKYXZhU2Ny aXB0RnJvbVN0cmluZzpAInNldFRpbWVvdXQocnVuVGVzdCwgMTApOyJdOworICAgICAgICBVdGls OjpydW4oJmRpZEZpbmlzaFRlc3QpOworICAgICAgICBkaWRGaW5pc2hUZXN0ID0gZmFsc2U7Cisg ICAgfQorfQorCit9CisKKyNlbmRpZgo= 409393 2020-09-22 13:11:19 -0700 2020-09-29 07:19:16 -0700 Patch bug-216106-20200922231117.patch text/plain 24060 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjY3MzQ3CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggYTNmYjY4OWRlNjEwNTlmMzdkZTRhMTkwMTJhZmUzZWI1ZmExMTM0MS4uMDNiNTJkNGQ0MGQ2 NGM1YmM5OTYyZTczZmY0MTU1MzMxYWNmOTUxOCAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDI5IEBACisyMDIwLTA5LTIyICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXSzFdIENyYXNoZXMgd2hlbiB1c2luZyBBTkdM RSBXZWJHTCBmcm9tIGFub3RoZXIgdGhyZWFkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMTYxMDYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY4NjAy NDUyPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAgICBNYWtl cyBBTkdMRSBzdXBwb3J0IHNldHRpbmcgdGhlIEVBR0wgY29udGV4dCBvbiBtdWx0aXBsZQorICAg ICAgICB0aHJlYWRzLCBub24tc2ltdWx0YW5lb3NseS4KKworICAgICAgICBNYWtlcyBBTkdMRSBz dXBwb3J0IHJlYWwgdW5zZXQgb2YgdGhlIHVuZGVybHlpbmcgY29udGV4dC4KKyAgICAgICAgKG90 aGVyd2lzZSB0aGUgY29udGV4dCB3aWxsIGxlYWspLgorCisgICAgICAgIFdvcmsgaW4gcHJvZ3Jl c3MuCisgICAgICAgIEhPV1RPOgorICAgICAgICAxKSBEZXRlY3QgdGhlIHBsYWNlIHdoZXJlIGEg V0sxIGNhbGwgZXhpdHMuCisgICAgICAgIDIpIFByZWZlcmFibHkgZGV0ZWN0IHRoZSBwbGFjZSB3 aGVyZSBXSzEgY2FsbCBlbnRlcnMuCisKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvRGlzcGxheS5j cHA6CisgICAgICAgIChlZ2w6OkRpc3BsYXk6Om1ha2VDdXJyZW50KToKKyAgICAgICAgKiBzcmMv bGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oOgorICAgICAgICAqIHNyYy9s aWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLm1tOgorICAgICAgICAocng6OkRp c3BsYXlFQUdMOjppbml0aWFsaXplKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5RUFHTDo6dGVybWlu YXRlKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5RUFHTDo6bWFrZUN1cnJlbnRTdXJmYWNlbGVzcyk6 CisKIDIwMjAtMDktMTEgIEphbWVzIERhcnBpbmlhbiAgPGpkYXJwaW5pYW5AY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFtXZWJHTDJdIFN1cHBvcnQgRVhUX2NvbG9yX2J1ZmZlcl9oYWxmX2Zsb2F0 IG9uIFdlYkdMIDIuMCBjb250ZXh0cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDRmZDE1NTU0NjAwMzhlZDUyNjZi ZDE0NTE4ZGRkYzBkNThjMWFiZmEuLjc5ZWY0YzI5MGRjMDdmNzRhMDZmZTY2MjFkZjlhNTk4NDM5 MzJjZGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAyMC0wOS0yMiAgS2ltbW8gS2lu bnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgorCisgICAgICAgIFtpT1MgV0sxXSBDcmFzaGVz IHdoZW4gdXNpbmcgQU5HTEUgV2ViR0wgZnJvbSBhbm90aGVyIHRocmVhZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE2MTA2CisgICAgICAgIDxyZGFy Oi8vcHJvYmxlbS82ODYwMjQ1Mj4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBObyBuZXcgdGVzdHMgKE9PUFMhKS4KKworICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW06CisgICAgICAg IChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6fkdyYXBoaWNzQ29udGV4dEdMT3Bl bkdMKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxlYXNl Q3VycmVudENvbnRleHRJZk5lZWRlZCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvb3Bl bmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmg6CisgICAgICAgICogcGxhdGZvcm0vaW9zL3dh ay9XZWJDb3JlVGhyZWFkLm1tOgorICAgICAgICAoV2ViUnVuTG9vcFVubG9ja0ludGVybmFsKToK KwogMjAyMC0wOS0yMSAgQW50b2luZSBRdWludCAgPGdyYW91dHNAd2Via2l0Lm9yZz4KIAogICAg ICAgICBSZW1vdmUgZGVkaWNhdGVkIEhhc2hTZXQ8RWxlbWVudCo+IGZvciBEb2N1bWVudFRpbWVs aW5lOjpydW5uaW5nQW5pbWF0aW9uc0ZvckVsZW1lbnRBcmVBbGxBY2NlbGVyYXRlZCgpCmRpZmYg LS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5jcHAg Yi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5jcHAKaW5kZXgg ZTNlYmUzMjVkYWEyODhlODVjOWJmODAzN2EwMDUzMTA1MjQ3YjdhOC4uYjU0ZmQ5ZDllYTcwYmI2 YTQ3MzlmYjk2MDJiMThkMWNiMGEzNjcyMyAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkv QU5HTEUvc3JjL2xpYkFOR0xFL0Rpc3BsYXkuY3BwCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJBTkdMRS9EaXNwbGF5LmNwcApAQCAtMTIxOCwxMSArMTIxOCwxOSBAQCBFcnJv ciBEaXNwbGF5OjptYWtlQ3VycmVudChjb25zdCBUaHJlYWQgKnRocmVhZCwKICAgICBpZiAocHJl dmlvdXNDb250ZXh0KQogICAgIHsKICAgICAgICAgQU5HTEVfVFJZKHByZXZpb3VzQ29udGV4dC0+ dW5NYWtlQ3VycmVudCh0aGlzKSk7CisgICAgICAgIC8vIEVHTCBTcGVjaWZpY2F0aW9uIDEuNSAz LjcuMyBCaW5kaW5nIENvbnRleHRzIGFuZCBEcmF3YWJsZXMKKyAgICAgICAgLy8gcGcuIDU4Cisg ICAgICAgIC8vICJJZiB0aGUgY2FsbGluZyB0aHJlYWQgYWxyZWFkeSBoYXMgYSBjdXJyZW50IGNv bnRleHQgb2YgdGhlIHNhbWUgY2xpZW50IEFQSQorICAgICAgICAvLyAgdHlwZSBhcyBjdHgsIHRo ZW4gdGhhdCBjb250ZXh0IGlzIGZsdXNoZWQgYW5kIG1hcmtlZCBhcyBubyBsb25nZXIgY3VycmVu dC4iCisgICAgICAgIC8vIHBnLiA1OQorICAgICAgICAvLyAiVGhlIGN1cnJlbnRseSBib3VuZCBj b250ZXh0IGZvciB0aGUgY2xpZW50IEFQSSBzcGVjaWZpZWQgYnkgY3VycmVudCByZW5kZXJpbmcK KyAgICAgICAgLy8gIEFQSSBpcyBmbHVzaGVkIGFuZCBtYXJrZWQgbm8gbG9uZ2VyIGN1cnJlbnQu IgorICAgICAgICBBTkdMRV9UUlkocHJldmlvdXNDb250ZXh0LT5mbHVzaCgpKTsKICAgICB9CiAK ICAgICBBTkdMRV9UUlkobUltcGxlbWVudGF0aW9uLT5tYWtlQ3VycmVudChkcmF3U3VyZmFjZSwg cmVhZFN1cmZhY2UsIGNvbnRleHQpKTsKIAotICAgIGlmIChjb250ZXh0ICE9IG51bGxwdHIpCisg ICAgaWYgKGNvbnRleHQgIT0gbnVsbHB0ciAmJiBwcmV2aW91c0NvbnRleHQgIT0gY29udGV4dCkK ICAgICB7CiAgICAgICAgIEFOR0xFX1RSWShjb250ZXh0LT5tYWtlQ3VycmVudCh0aGlzLCBkcmF3 U3VyZmFjZSwgcmVhZFN1cmZhY2UpKTsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oIGIv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2VhZ2wvRGlz cGxheUVBR0wuaAppbmRleCAyNjFiYTQwN2QxOTNiZWI5MzEyYWQxMTA2ZDhjNmJlODBkODczOWQ5 Li42ZGIzYzk0ODhkMzE4ZTgyZmVkNmRlYTZmOGFlOGUxYmFkMDA1MzY5IDEwMDY0NAotLS0gYS9T b3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNw bGF5RUFHTC5oCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5k ZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmgKQEAgLTEzLDYgKzEzLDggQEAKIAogI2lmIGRlZmlu ZWQoQU5HTEVfUExBVEZPUk1fSU9TKSAmJiAhZGVmaW5lZChBTkdMRV9QTEFURk9STV9NQUNDQVRB TFlTVCkKIAorI2luY2x1ZGUgPHRocmVhZD4KKwogI2luY2x1ZGUgImxpYkFOR0xFL3JlbmRlcmVy L2dsL0Rpc3BsYXlHTC5oIgogCiAjaWZkZWYgX19PQkpDX18KQEAgLTkzLDYgKzk1LDcgQEAgY2xh c3MgRGlzcGxheUVBR0wgOiBwdWJsaWMgRGlzcGxheUdMCiAKICAgICBlZ2w6OkRpc3BsYXkgKm1F R0xEaXNwbGF5OwogICAgIEVBR0xDb250ZXh0T2JqIG1Db250ZXh0OworICAgIHN0ZDo6dW5vcmRl cmVkX3NldDxzdGQ6OnRocmVhZDo6aWQ+IG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50OwogfTsK IAogfSAgLy8gbmFtZXNwYWNlIHJ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdM RS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbSBiL1NvdXJjZS9U aGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdM Lm1tCmluZGV4IGNlYjJkMTFmYzc5OWUzOTYyNWM3NzhhNzIyNTY1MmFhZWM4ODhhMTEuLmZhNzVj ZGE1N2YxMGEyNTVkY2U5ODJjNzZiZWM4ZDRiZmNjOGI4MTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9U aGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdM Lm1tCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9n bC9lYWdsL0Rpc3BsYXlFQUdMLm1tCkBAIC03Niw3ICs3NiwxMCBAQCBlZ2w6OkVycm9yIERpc3Bs YXlFQUdMOjppbml0aWFsaXplKGVnbDo6RGlzcGxheSAqZGlzcGxheSkKICAgICB7CiAgICAgICAg IHJldHVybiBlZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIkNvdWxkIG5vdCBjcmVhdGUgdGhl IEVBR0wgY29udGV4dC4iOwogICAgIH0KLSAgICBbRUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRl eHQ6bUNvbnRleHRdOworICAgIGlmICghW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0Om1D b250ZXh0XSkgeworICAgICAgICByZXR1cm4gZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIkNv dWxkIHNldCB0aGUgRUFHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICB9CisgICAgbVRocmVhZHNX aXRoQ29udGV4dEN1cnJlbnQuaW5zZXJ0KHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgpKTsKIAog ICAgIC8vIFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZ2V0UHJvY0FkZHJlc3MgaW4gRUFHTCBzbyB3 ZSBvcGVuIHRoZSBkeWxpYiBkaXJlY3RseQogICAgIHZvaWQgKmhhbmRsZSA9IGRsb3BlbihrT3Bl bkdMRVNEeWxpYk5hbWUsIFJUTERfTk9XKTsKQEAgLTEwOSw2ICsxMTIsOCBAQCB2b2lkIERpc3Bs YXlFQUdMOjp0ZXJtaW5hdGUoKQogICAgICAgICBbRUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRl eHQ6bmlsXTsKICAgICAgICAgW21Db250ZXh0IHJlbGVhc2VdOwogICAgICAgICBtQ29udGV4dCA9 IG51bGxwdHI7CisgICAgICAgIG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50LmNsZWFyKCk7CisK ICAgICB9CiB9CiAKQEAgLTMwOCw4ICszMTMsMzAgQEAgZ2w6OlZlcnNpb24gRGlzcGxheUVBR0w6 OmdldE1heFN1cHBvcnRlZEVTVmVyc2lvbigpIGNvbnN0CiAKIGVnbDo6RXJyb3IgRGlzcGxheUVB R0w6Om1ha2VDdXJyZW50U3VyZmFjZWxlc3MoZ2w6OkNvbnRleHQgKmNvbnRleHQpCiB7Ci0gICAg Ly8gV2UgaGF2ZSBub3RoaW5nIHRvIGRvIGFzIG1Db250ZXh0IGlzIGFsd2F5cyBjdXJyZW50LCBh bmQgdGhhdCBFQUdMIGlzIHN1cmZhY2VsZXNzIGJ5Ci0gICAgLy8gZGVmYXVsdC4KKyAgICBhdXRv IHRocmVhZElkID0gc3RkOjp0aGlzX3RocmVhZDo6Z2V0X2lkKCk7CisgICAgYm9vbCBzaG91bGRI YXZlQ3VycmVudENvbnRleHQgPSBjb250ZXh0OworICAgIGJvb2wgaGFzQ3VycmVudENvbnRleHQg PQorICAgICAgICBtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5maW5kKHRocmVhZElkKSAhPSBt VGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5lbmQoKTsKKyAgICAKKyAgICBpZiAoc2hvdWxkSGF2 ZUN1cnJlbnRDb250ZXh0ICE9IGhhc0N1cnJlbnRDb250ZXh0KQorICAgIHsKKyAgICAgICAgaWYg KHNob3VsZEhhdmVDdXJyZW50Q29udGV4dCkKKyAgICAgICAgeworICAgICAgICAgICAgaWYgKCFb RUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6bUNvbnRleHRdKQorICAgICAgICAgICAgewor ICAgICAgICAgICAgICAgIHJldHVybiBlZ2w6OkVnbEJhZEFsbG9jKCkgPDwgIkNvdWxkIG5vdCBt YWtlIGNvbnRleHQgY3VycmVudC4iOworICAgICAgICAgICAgfQorICAgICAgICAgICAgbVRocmVh ZHNXaXRoQ29udGV4dEN1cnJlbnQuaW5zZXJ0KHRocmVhZElkKTsKKyAgICAgICAgfQorICAgICAg ICBlbHNlCisgICAgICAgIHsKKyAgICAgICAgICAgIGlmICghW0VBR0xDb250ZXh0IHNldEN1cnJl bnRDb250ZXh0Om5pbF0pCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgcmV0dXJuIGVn bDo6RWdsQmFkQWxsb2MoKSA8PCAiQ291bGQgbm90IGNsZWFyIGN1cnJlbnQgY29udGV4dC4iOwor ICAgICAgICAgICAgfQorICAgICAgICAgICAgbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZXJh c2UodGhyZWFkSWQpOworICAgICAgICB9CisgICAgfQogICAgIHJldHVybiBlZ2w6Ok5vRXJyb3Io KTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29j b2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xDb2NvYS5tbSBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW0KaW5kZXgg YTYyNmExNTJmOGUyMzk0NDBiZTkwZDVhOGE3ZjU5NDMzNzQ4OTYzMy4uYjNkOTgwNjNiNjQwYmNl MGE5YmFjNGY2ZGEyNTJjOGVkOGJjOGEwNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xDb2NvYS5tbQorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRH TE9wZW5HTENvY29hLm1tCkBAIC01NTYsNyArNTU2LDYgQEAgR3JhcGhpY3NDb250ZXh0R0xPcGVu R0w6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMKEdyYXBoaWNzQ29udGV4dEdMQXR0cmlidXRlcyBh dHQKIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjp+R3JhcGhpY3NDb250ZXh0R0xPcGVuR0woKQog ewogICAgIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMTWFuYWdlcjo6c2hhcmVkTWFuYWdlcigpLnJl bW92ZUNvbnRleHQodGhpcyk7Ci0KICAgICBpZiAobV9jb250ZXh0T2JqKSB7CiAgICAgICAgIEdy YXBoaWNzQ29udGV4dEdMQXR0cmlidXRlcyBhdHRycyA9IGNvbnRleHRBdHRyaWJ1dGVzKCk7CiAK QEAgLTY1Myw2ICs2NTIsMjYgQEAgYm9vbCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6bWFrZUNv bnRleHRDdXJyZW50KCkKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorI2lmIFBMQVRGT1JNKElPU19G QU1JTFkpCisKK2Jvb2wgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OnJlbGVhc2VDdXJyZW50Q29u dGV4dElmTmVlZGVkKCkKK3sKKyNpZiBVU0UoT1BFTkdMX0VTKQorICAgIHJldHVybiB0cnVlOwor I2VsaWYgVVNFKEFOR0xFKQorICAgIGlmIChFR0xfR2V0Q3VycmVudENvbnRleHQoKSA9PSBFR0xf Tk9fQ09OVEVYVCkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgRUdMRGlzcGxheSBkaXNwbGF5 ID0gRUdMX0dldERpc3BsYXkoRUdMX0RFRkFVTFRfRElTUExBWSk7CisgICAgaWYgKGRpc3BsYXkg PT0gRUdMX05PX0RJU1BMQVkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICByZXR1cm4gRUdM X01ha2VDdXJyZW50KGRpc3BsYXksIEVHTF9OT19TVVJGQUNFLCBFR0xfTk9fU1VSRkFDRSwgRUdM X05PX0NPTlRFWFQpOworI2Vsc2UKKyNlcnJvciBVbnN1cHBvcnRlZCBncmFwaGljcyBwbGF0Zm9y bS4KKyNlbmRpZgorfQorCisjZW5kaWYKKwogdm9pZCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6 Y2hlY2tHUFVTdGF0dXMoKQogewogICAgIGlmIChtX2ZhaWxOZXh0U3RhdHVzQ2hlY2spIHsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGlj c0NvbnRleHRHTE9wZW5HTC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3Bl bmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmgKaW5kZXggZTljYzRmYWNkMjAzMmY5ZWUzMTEx YTg1NDM1MDMxMDU1NjU5N2FiYy4uMDVjZGE1NGI2NjZkY2NkMWYxMmI1OTYyYmRjNTUwYmZjYjdk ZTVhYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3Blbmds L0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmgKQEAgLTExOSw2ICsxMTks NyBAQCBwdWJsaWM6CiAjZW5kaWYKIAogICAgIGJvb2wgbWFrZUNvbnRleHRDdXJyZW50KCk7Cisg ICAgc3RhdGljIGJvb2wgcmVsZWFzZUN1cnJlbnRDb250ZXh0SWZOZWVkZWQoKTsKIAogICAgIHZv aWQgYWRkQ2xpZW50KENsaWVudCYgY2xpZW50KSB7IG1fY2xpZW50cy5hZGQoJmNsaWVudCk7IH0K ICAgICB2b2lkIHJlbW92ZUNsaWVudChDbGllbnQmIGNsaWVudCkgeyBtX2NsaWVudHMucmVtb3Zl KCZjbGllbnQpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pb3Mvd2Fr L1dlYkNvcmVUaHJlYWQubW0gYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pb3Mvd2FrL1dlYkNv cmVUaHJlYWQubW0KaW5kZXggNWFkN2ZlNTE5OGQyNGMzMDM2NmEyMzBhMDk3MzI0YzRhMjVjNjk0 ZC4uMjk0MmM4ZGNiZGM4MDljMjlmNWZlYmZjNzMwNjJkMDExMTA3OGQxNiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW9zL3dhay9XZWJDb3JlVGhyZWFkLm1tCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2lvcy93YWsvV2ViQ29yZVRocmVhZC5tbQpAQCAtMzAsNiAr MzAsNyBAQAogCiAjaW1wb3J0ICJDb21tb25WTS5oIgogI2ltcG9ydCAiRmxvYXRpbmdQb2ludEVu dmlyb25tZW50LmgiCisjaW1wb3J0ICJHcmFwaGljc0NvbnRleHRHTE9wZW5HTC5oIgogI2ltcG9y dCAiTG9nZ2luZy5oIgogI2ltcG9ydCAiUnVudGltZUFwcGxpY2F0aW9uQ2hlY2tzLmgiCiAjaW1w b3J0ICJUaHJlYWRHbG9iYWxEYXRhLmgiCkBAIC01OSw2ICs2MCwzNiBAQAogCiAjZGVmaW5lIERp c3RhbnRGdXR1cmUgICAoODY0MDAuMCAqIDIwMDAgKiAzNjUuMjQyNSArIDg2NDAwLjApICAgLy8g c2FtZSBhcyArW05TRGF0ZSBkaXN0YW50RnV0dXJlXQogCituYW1lc3BhY2UgeworLy8gUmVsZWFz ZSBnbG9iYWwgc3RhdGUgdGhhdCBpcyBhY2Nlc3NlZCBmcm9tIGJvdGggd2ViIHRocmVhZCBhcyB3 ZWxsCisvLyBhcyBhbnkgY2xpZW50IHRocmVhZCB0aGF0IGNhbGxzLgordm9pZCBXZWJUaHJlYWRS ZWxlYXNlQ3Jvc3NUaHJlYWRHbG9iYWxTdGF0ZSgpCit7CisgICAgQVNTRVJUKFdlYlRocmVhZElz Q3VycmVudCgpKTsKKworICAgIC8vIE9uIHNvbWUgc2V0dXBzLCB0aGUgdW5kZXJseWluZyBncmFw aGljcyBjb250ZXh0IGNhbm5vdCBiZSBjdXJyZW50IGluIHR3byB0aHJlYWRzCisgICAgLy8gYXQg dGhlIHNhbWUgdGltZS4KKyAgICBXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6dW5z ZXRDdXJyZW50Q29udGV4dElmTmVlZGVkKCk7Cit9CisKK2NsYXNzIFNjb3BlZENsaWVudFRocmVh ZENyb3NzVGhyZWFkR2xvYmFsU3RhdGVSZXN0b3JlIHsKKyAgICBXVEZfTUFLRV9OT05DT1BZQUJM RShTY29wZWRDbGllbnRDcm9zc1RocmVhZEdsb2JhbFN0YXRlUmVzdG9yZSk7CitwdWJsaWM6Cisg ICAgU2NvcGVkQ2xpZW50Q3Jvc3NUaHJlYWRHbG9iYWxTdGF0ZVJlc3RvcmUoKQorICAgICAgICA6 IG1fZWFnbENvbnRleHQoW0VBR0xDb250ZXh0IGN1cnJlbnRDb250ZXh0XSkKKyAgICB7CisgICAg ICAgIAorICAgIH0KKyAgICB+U2NvcGVkQ2xpZW50Q3Jvc3NUaHJlYWRHbG9iYWxTdGF0ZVJlc3Rv cmUoKQorICAgIHsKKyAgICAgICAgV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OnVu c2V0Q3VycmVudENvbnRleHRJZk5lZWRlZCgpOworICAgICAgICBbRUFHTENvbnRleHQgc2V0Q3Vy cmVudENvbnRleHQ6IG1fZWFnbENvbnRleHQuZ2V0KCldOworICAgIH0KK3ByaXZhdGU6CisgICAg UmV0YWluUHRyPEVBR0xDb250ZXh0PiBtX2VhZ2xDb250ZXh0OworfTsKK30KKwogc3RhdGljIGNv bnN0IGNvbnN0ZXhwciBTZWNvbmRzIERlbGVnYXRlV2FpdEludGVydmFsIHsgMTBfcyB9OwogCiBz dGF0aWMgdm9pZCBfV2ViVGhyZWFkQXV0b0xvY2soKTsKQEAgLTIxMSw2ICsyNDIsNyBAQCBzdGF0 aWMgdm9pZCBTZW5kRGVsZWdhdGVNZXNzYWdlKE5TSW52b2NhdGlvbiogaW52b2NhdGlvbikKICAg ICAgICAgV2ViVGhyZWFkRGVsZWdhdGVNZXNzYWdlU2NvcGUgZGVsZWdhdGVTY29wZTsKICAgICAg ICAgLy8gQ29kZSBibG9jayBjcmVhdGVkIHRvIHNjb3BlIEpTQzo6SlNMb2NrOjpEcm9wQWxsTG9j a3Mgb3V0c2lkZSBvZiBXZWJUaHJlYWRMb2NrKCkKICAgICAgICAgSlNDOjpKU0xvY2s6OkRyb3BB bGxMb2NrcyBkcm9wQWxsTG9ja3MoV2ViQ29yZTo6Y29tbW9uVk0oKSk7CisgICAgICAgIFdlYlRo cmVhZFJlbGVhc2VDcm9zc1RocmVhZEdsb2JhbFN0YXRlKCk7CiAgICAgICAgIF9XZWJUaHJlYWRV bmxvY2soKTsKIAogICAgICAgICBDRlJ1bkxvb3BTb3VyY2VTaWduYWwoZGVsZWdhdGVTb3VyY2Up OwpAQCAtMjQ0LDYgKzI3Niw3IEBAIHZvaWQgV2ViVGhyZWFkUnVuT25NYWluVGhyZWFkKHZvaWQo XmRlbGVnYXRlQmxvY2spKCkpCiAgICAgfQogCiAgICAgSlNDOjpKU0xvY2s6OkRyb3BBbGxMb2Nr cyBkcm9wQWxsTG9ja3MoV2ViQ29yZTo6Y29tbW9uVk0oKSk7CisgICAgV2ViVGhyZWFkUmVsZWFz ZUNyb3NzVGhyZWFkR2xvYmFsU3RhdGUoKTsKICAgICBfV2ViVGhyZWFkVW5sb2NrKCk7CiAKICAg ICB2b2lkICheZGVsZWdhdGVCbG9ja0NvcHkpKCkgPSBCbG9ja19jb3B5KGRlbGVnYXRlQmxvY2sp OwpAQCAtNDU0LDcgKzQ4Nyw3IEBAIHN0YXRpYyB2b2lkIE1haW5SdW5Mb29wQXV0b1VubG9jayhD RlJ1bkxvb3BPYnNlcnZlclJlZiwgQ0ZSdW5Mb29wQWN0aXZpdHksIHZvaWQqCiAKICAgICBtYWlu VGhyZWFkSGFzUGVuZGluZ0F1dG9VbmxvY2sgPSBOTzsKICAgICBDRlJ1bkxvb3BSZW1vdmVPYnNl cnZlcihDRlJ1bkxvb3BHZXRDdXJyZW50KCksIG1haW5SdW5Mb29wQXV0b1VubG9ja09ic2VydmVy LCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwotCisgICAgV2ViVGhyZWFkUmVsZWFzZUNyb3NzVGhy ZWFkR2xvYmFsU3RhdGUoKTsKICAgICBfV2ViVGhyZWFkVW5sb2NrKCk7CiB9CiAKQEAgLTQ4Niwx MCArNTE5LDkgQEAgc3RhdGljIHZvaWQgV2ViUnVuTG9vcFVubG9ja0ludGVybmFsKEF1dG9yZWxl YXNlUG9vbE9wZXJhdGlvbiBwb29sT3BlcmF0aW9uKQogICAgICAgICAgICAgU2VuZERlbGVnYXRl TWVzc2FnZShbaW52b2NhdGlvbiByZXRhaW5dKTsKICAgICAgICAgW3NBc3luY0RlbGVnYXRlcyBy ZW1vdmVBbGxPYmplY3RzXTsKICAgICB9Ci0KICAgICBpZiAocG9vbE9wZXJhdGlvbiA9PSBQdXNo T3JQb3BBdXRvcmVsZWFzZVBvb2wpCiAgICAgICAgIG9iamNfYXV0b3JlbGVhc2VQb29sUG9wKGF1 dG9yZWxlYXNlUG9vbE1hcmspOwotCisgICAgV2ViVGhyZWFkUmVsZWFzZUNyb3NzVGhyZWFkR2xv YmFsU3RhdGUoKTsKICAgICBfV2ViVGhyZWFkVW5sb2NrKCk7CiAgICAgaXNXZWJUaHJlYWRMb2Nr ZWQgPSBOTzsKIH0KZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxv ZwppbmRleCA5OGIzNmNjN2FkNzUxYWJhMTMwOTc3NzMyODQ2OWEwNjRiMWMxYWVkLi4zZjRhN2Iy YWM0YWYxODkzMzdiMTlmZWFiMmE1YjY5Njc0YTE3MGE1IDEwMDY0NAotLS0gYS9Ub29scy9DaGFu Z2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMjAtMDktMjIg IEtpbW1vIEtpbm51bmVuICA8a2tpbm51bmVuQGFwcGxlLmNvbT4KKworICAgICAgICBbaU9TIFdL MV0gQ3Jhc2hlcyB3aGVuIHVzaW5nIEFOR0xFIFdlYkdMIGZyb20gYW5vdGhlciB0aHJlYWQKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNjEwNgorICAg ICAgICA8cmRhcjovL3Byb2JsZW0vNjg2MDI0NTI+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL0NvbmZpZ3VyYXRpb25zL1Rl c3RXZWJLaXRBUEkueGNjb25maWc6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0 QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3MubW06 IEFkZGVkLgorICAgICAgICAoLVtXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzV2ViVmll d0RlbGVnYXRlIHdlYlZpZXdEaWRGaW5pc2hMb2FkOl0pOgorICAgICAgICAoLVtXZWJHTE5vQ3Jh c2hPbk90aGVyVGhyZWFkQWNjZXNzV2ViVmlld0RlbGVnYXRlIHdlYlZpZXc6c2hvdWxkU3RhcnRM b2FkV2l0aFJlcXVlc3Q6bmF2aWdhdGlvblR5cGU6XSk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJ OjpURVNUKToKKwogMjAyMC0wOS0yMSAgS2F0ZSBDaGVuZXkgIDxrYXRoZXJpbmVfY2hlbmV5QGFw cGxlLmNvbT4KIAogICAgICAgICBBbGxvdyBhYm91dDpibGFuayBzdWJmcmFtZSBsb2FkcyBmb3Ig bm9uIGFwcC1ib3VuZCB0b3AgZnJhbWVzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJ L0NvbmZpZ3VyYXRpb25zL1Rlc3RXZWJLaXRBUEkueGNjb25maWcgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL0NvbmZpZ3VyYXRpb25zL1Rlc3RXZWJLaXRBUEkueGNjb25maWcKaW5kZXggYmJkZGU4NzUx NzkzODczZTBkMGZhMmRjYTQyMWVkNTdhYzBhYmYwMC4uYTMxNDg3NmU0ZDRmZmQ5NTEyNmU4YzAy MTVjMDQ2MGU2NzU1OWZiNiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9Db25maWd1 cmF0aW9ucy9UZXN0V2ViS2l0QVBJLnhjY29uZmlnCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv Q29uZmlndXJhdGlvbnMvVGVzdFdlYktpdEFQSS54Y2NvbmZpZwpAQCAtNjUsNyArNjUsNyBAQCBP VEhFUl9MREZMQUdTID0gJChpbmhlcml0ZWQpICQoVU5FWFBPUlRFRF9TWU1CT0xfTERGTEFHUykg LWxndGVzdCAtZm9yY2VfbG9hZCAkKAogT1RIRVJfTERGTEFHU19QTEFURk9STV8gPSAtZnJhbWV3 b3JrIENvY29hIC1mcmFtZXdvcmsgQ2FyYm9uOwogCiAvLyBGSVhNRTogVGhpcyBzaG91bGQgbm90 IGJlIGJ1aWx0IG9uIGlPUy4gSW5zdGVhZCB3ZSBzaG91bGQgY3JlYXRlIGFuZCB1c2UgYSBUZXN0 V2ViS2l0QVBJIGFwcGxpY2F0aW9uLgotT1RIRVJfTERGTEFHU19QTEFURk9STV9jb2NvYXRvdWNo ID0gLWZyYW1ld29yayBXZWJDb3JlIC1mcmFtZXdvcmsgQ29yZUdyYXBoaWNzIC1mcmFtZXdvcmsg VUlLaXQgLWZyYW1ld29yayBNb2JpbGVDb3JlU2VydmljZXM7CitPVEhFUl9MREZMQUdTX1BMQVRG T1JNX2NvY29hdG91Y2ggPSAtZnJhbWV3b3JrIFdlYkNvcmUgLWZyYW1ld29yayBDb3JlR3JhcGhp Y3MgLWZyYW1ld29yayBVSUtpdCAtZnJhbWV3b3JrIE1vYmlsZUNvcmVTZXJ2aWNlcyAtZnJhbWV3 b3JrIE9wZW5HTEVTOwogCiBMRF9SVU5QQVRIX1NFQVJDSF9QQVRIUyA9ICJAbG9hZGVyX3BhdGgi OwogCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDQxYzRhMTc1NGUwMzFhMTFhMDMwMTQyYjNm MTYzOGE1NzkzZjFiMGUuLmE2ODI5N2I4MzhhZTRkNjk5Mzg1NTgwMDNhODg2Yzg3MmU4ODQ2ZGEg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC01NDcsNiArNTQ3LDcgQEAKIAkJN0FFOUU1MDkx QUU1QUU4QjAwQ0Y4NzRCIC8qIHRlc3QucGRmIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDdBRTlFNTA4MUFFNUFFOEIwMENGODc0QiAvKiB0ZXN0 LnBkZiAqLzsgfTsKIAkJN0FFQUQ0N0YxRTIwMTE2QzAwNDE2RUZFIC8qIENyb3NzUGFydGl0aW9u RmlsZVNjaGVtZUFjY2Vzcy5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDdBRUFENDdDMUUyMDExMzgwMDQxNkVGRSAvKiBDcm9zc1BhcnRpdGlvbkZpbGVT Y2hlbWVBY2Nlc3MubW0gKi87IH07CiAJCTdBRUFENDgxMUUyMDEyMjcwMDQxNkVGRSAvKiBDcm9z c1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QUVBRDQ3RDFFMjAxMTRFMDA0MTZFRkUgLyog Q3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLmh0bWwgKi87IH07CisJCTdCN0QwOTZBMjUx OUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzLm1tIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0I3RDA5NjkyNTE5RjhG OTAwMTdBMDc4IC8qIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3MubW0gKi87IH07CiAJ CTdDMUFGNzk1MUU4RENCQUIwMDI2NDVCOSAvKiBQcmVwYXJlRm9yTW92ZVRvV2luZG93Lm1tIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0MxQUY3OTMxRThE Q0JBQjAwMjY0NUI5IC8qIFByZXBhcmVGb3JNb3ZlVG9XaW5kb3cubW0gKi87IH07CiAJCTdDMzk2 NTA2MUNERDc0RjkwMDk0REJCOCAvKiBDb2xvclRlc3RzLmNwcCBpbiBTb3VyY2VzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDdDMzk2NTA1MUNERDc0RjkwMDk0REJCOCAvKiBD b2xvclRlc3RzLmNwcCAqLzsgfTsKIAkJN0MzREI4RTQxRDEyMTI5QjAwQUU4Q0MzIC8qIENvbW1h bmRCYWNrRm9yd2FyZC5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDdDM0RCOEUyMUQxMjEyOUIwMEFFOENDMyAvKiBDb21tYW5kQmFja0ZvcndhcmQubW0g Ki87IH07CkBAIC0yMzAyLDYgKzIzMDMsNyBAQAogCQk3QUU5RTUwODFBRTVBRThCMDBDRjg3NEIg LyogdGVzdC5wZGYgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5 cGUgPSBpbWFnZS5wZGY7IHBhdGggPSB0ZXN0LnBkZjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJN0FFQUQ0N0MxRTIwMTEzODAwNDE2RUZFIC8qIENyb3NzUGFydGl0aW9uRmlsZVNjaGVt ZUFjY2Vzcy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IENyb3Nz UGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJN0FFQUQ0N0QxRTIwMTE0RTAwNDE2RUZFIC8qIENyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFj Y2Vzcy5odG1sICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5odG1sOyBuYW1lID0gQ3Jvc3NQYXJ0aXRpb25GaWxl U2NoZW1lQWNjZXNzLmh0bWw7IHBhdGggPSBUZXN0cy9tYWMvQ3Jvc3NQYXJ0aXRpb25GaWxlU2No ZW1lQWNjZXNzLmh0bWw7IHNvdXJjZVRyZWUgPSBTT1VSQ0VfUk9PVDsgfTsKKwkJN0I3RDA5Njky NTE5RjhGOTAwMTdBMDc4IC8qIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3MubW0gKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5vYmpjcHA7IHBhdGggPSBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzLm1tOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3QzFBRjc5MzFFOERDQkFCMDAyNjQ1QjkgLyog UHJlcGFyZUZvck1vdmVUb1dpbmRvdy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNw cDsgcGF0aCA9IFByZXBhcmVGb3JNb3ZlVG9XaW5kb3cubW07IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTdDMzk2NTA1MUNERDc0RjkwMDk0REJCOCAvKiBDb2xvclRlc3RzLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IENvbG9yVGVzdHMuY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk3QzNEQjhFMjFEMTIxMjlCMDBBRThDQzMgLyogQ29tbWFu ZEJhY2tGb3J3YXJkLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0g Q29tbWFuZEJhY2tGb3J3YXJkLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNDU5 MCw2ICs0NTkyLDcgQEAKIAkJCQlDREMwOTMyQTIxQzg3MkMxMDAzMEM0QjAgLyogU2Nyb2xsaW5n RG9lc05vdFBhdXNlTWVkaWEubW0gKi8sCiAJCQkJRjQzNENBMTkyMkU2NUJDQTAwNUREQjI2IC8q IFNjcm9sbFRvUmV2ZWFsU2VsZWN0aW9uLm1tICovLAogCQkJCTBGNEZGQTlEMUVEM0FBODUwMEY3 MTExRiAvKiBTbmFwc2hvdFZpYVJlbmRlckluQ29udGV4dC5tbSAqLywKKwkJCQk3QjdEMDk2OTI1 MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbSAqLywK IAkJCQkzMUU5QkRBMDI0N0Y0QzYyMDAyRTUxQTIgLyogV2ViR0xQcmVwYXJlRGlzcGxheU9uV2Vi VGhyZWFkLm1tICovLAogCQkJCTJEQzk0NTE2MjREOEFDMDIwMDQzMDM3NiAvKiBXZWJUaHJlYWRM b2NrLm1tICovLAogCQkJKTsKQEAgLTU0NjMsNiArNTQ2Niw3IEBACiAJCQkJN0M4M0UwNEMxRDBB NjQxODAwRkVCQ0YzIC8qIFdlYkNvcmVOU1VSTFNlc3Npb24ubW0gaW4gU291cmNlcyAqLywKIAkJ CQk1N0E3OTg1NzIyNEFCMzRFMDBBN0Y2RjEgLyogV2ViQ3J5cHRvTWFzdGVyS2V5Lm1tIGluIFNv dXJjZXMgKi8sCiAJCQkJQzFGRjlFREIyNDQ2NDRGMDAwODM5QUU0IC8qIFdlYkZpbHRlci5tbSBp biBTb3VyY2VzICovLAorCQkJCTdCN0QwOTZBMjUxOUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jh c2hPbk90aGVyVGhyZWFkQWNjZXNzLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNUM5NzNGNUMxRjU4 RUY4QjAwMzU5QzI3IC8qIFdlYkdMUG9saWN5Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJMzFFOUJE QTEyNDdGNEM2MjAwMkU1MUEyIC8qIFdlYkdMUHJlcGFyZURpc3BsYXlPbldlYlRocmVhZC5tbSBp biBTb3VyY2VzICovLAogCQkJCTdDQ0U3RUFCMUE0MTFBMjQwMDQ0N0M0QyAvKiBXZWJLaXRBZ25v c3RpY1Rlc3QubW0gaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0TGVnYWN5L2lvcy9XZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNz Lm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMTm9D cmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3MubW0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTNiNmUwOWIyZjY2OGQ3YjNi OTIyZmRmZmZkZTI3ODdjNTg0NTEyZQotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0TGVnYWN5L2lvcy9XZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNj ZXNzLm1tCkBAIC0wLDAgKzEsMTQ5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIwIEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJF IElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisg KiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4g Tk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAor ICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW1wb3J0ICJjb25maWcuaCIKKwor I2lmIEhBVkUoVUlXRUJWSUVXKQorCisjaW1wb3J0ICJQbGF0Zm9ybVV0aWxpdGllcy5oIgorI2lt cG9ydCA8SmF2YVNjcmlwdENvcmUvSlNWaXJ0dWFsTWFjaGluZS5oPgorI2ltcG9ydCA8SmF2YVNj cmlwdENvcmUvSlNWaXJ0dWFsTWFjaGluZUludGVybmFsLmg+CisjaW1wb3J0IDxPcGVuR0xFUy9F QUdMLmg+CisjaW1wb3J0IDxVSUtpdC9VSUtpdC5oPgorI2ltcG9ydCA8V2ViQ29yZS9XZWJDb3Jl VGhyZWFkLmg+CisjaW1wb3J0IDxzdGRsaWIuaD4KKyNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4K KworbmFtZXNwYWNlIHsKK2Jvb2wgZGlkRmluaXNoTG9hZDsKK2Jvb2wgZGlkRmluaXNoVGVzdDsK K30KKworQGludGVyZmFjZSBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzV2ViVmlld0Rl bGVnYXRlIDogTlNPYmplY3QgPFVJV2ViVmlld0RlbGVnYXRlPgorQGVuZAorCitAaW1wbGVtZW50 YXRpb24gV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxlZ2F0ZQorCitJ R05PUkVfV0FSTklOR1NfQkVHSU4oImRlcHJlY2F0ZWQtaW1wbGVtZW50YXRpb25zIikKKy0gKHZv aWQpd2ViVmlld0RpZEZpbmlzaExvYWQ6KFVJV2ViVmlldyAqKXdlYlZpZXcKK3sKKyAgICBkaWRG aW5pc2hMb2FkID0gdHJ1ZTsKK30KKworLSAoQk9PTCl3ZWJWaWV3OihVSVdlYlZpZXcgKil3ZWJW aWV3IHNob3VsZFN0YXJ0TG9hZFdpdGhSZXF1ZXN0OihOU1VSTFJlcXVlc3QgKilyZXF1ZXN0IG5h dmlnYXRpb25UeXBlOihVSVdlYlZpZXdOYXZpZ2F0aW9uVHlwZSluYXZpZ2F0aW9uVHlwZQorewor ICAgIGlmIChbcmVxdWVzdC5VUkwuc2NoZW1lIGlzRXF1YWxUb1N0cmluZzpAImNhbGxiYWNrIl0g JiYgW3JlcXVlc3QuVVJMLnJlc291cmNlU3BlY2lmaWVyIGlzRXF1YWxUb1N0cmluZzpAImRpZEZp bmlzaFRlc3QiXSkgeworICAgICAgICBkaWRGaW5pc2hUZXN0ID0gdHJ1ZTsKKyAgICAgICAgcmV0 dXJuIE5POworICAgIH0KKworICAgIHJldHVybiBZRVM7Cit9CitJR05PUkVfV0FSTklOR1NfRU5E CisKK0BlbmQKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCisvLyBUZXN0IHRoYXQgdGVz dHMgYmVoYXZpb3Igb2YgVUlXZWJWaWV3IEFQSSB3aXRoIHJlZ2FyZHMgdG8gV2ViR0w6CisvLyAx KSBXZWJHTCBjYW4gYmUgcnVuIG9uIHdlYiB0aHJlYWQKKy8vIDIpIFdlYkdMIGNhbiBiZSBydW4g b24gY2xpZW50IHRocmVhZHMsIGUuZy4gVUkgdGhyZWFkIHJ1bm5pbmcgdXNlcgorLy8gICAgaW50 ZXJhY3Rpb24uCisvLyAzKSBXZWJHTCBydW4gb24gY2xpZW50IHRocmVhZHMgZG9lcyBub3QgY2hh bmdlIHVzZXIgRUFHTCBjb250ZXh0LgorVEVTVChXZWJLaXRMZWdhY3ksIFdlYkdMTm9DcmFzaE9u T3RoZXJUaHJlYWRBY2Nlc3MpCit7CisgICAgY29uc3QgdW5zaWduZWQgdGVzdEl0ZXJhdGlvbnMg PSAxMDsKKyAgICAKKyAgICBSZXRhaW5QdHI8VUlXaW5kb3c+IHVpV2luZG93ID0gYWRvcHROUyhb W1VJV2luZG93IGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TTWFrZVJlY3QoMCwgMCwgODAwLCA2MDAp XSk7CisgICAgUmV0YWluUHRyPFVJV2ViVmlldz4gdWlXZWJWaWV3ID0gYWRvcHROUyhbW1VJV2Vi VmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU01ha2VSZWN0KDAsIDAsIDgwMCwgNjAwKV0pOwor ICAgIFt1aVdpbmRvdyBhZGRTdWJ2aWV3OnVpV2ViVmlldy5nZXQoKV07CisgICAgCisgICAgQVNT RVJUX1RSVUUoV2ViVGhyZWFkSXNFbmFibGVkKCkpOworICAgIEVYUEVDVF9UUlVFKCFbRUFHTENv bnRleHQgY3VycmVudENvbnRleHRdKTsKKyAgICBSZXRhaW5QdHI8RUFHTENvbnRleHQ+IGNsaWVu dENvbnRleHQgPSBhZG9wdE5TKFtbRUFHTENvbnRleHQgYWxsb2NdIGluaXRXaXRoQVBJOiBrRUFH TFJlbmRlcmluZ0FQSU9wZW5HTEVTM10pOworICAgIFtFQUdMQ29udGV4dCBzZXRDdXJyZW50Q29u dGV4dDogY2xpZW50Q29udGV4dC5nZXQoKV07CisgICAgRVhQRUNUX0VRKFtFQUdMQ29udGV4dCBj dXJyZW50Q29udGV4dF0sIGNsaWVudENvbnRleHQuZ2V0KCkpOworCisgICAgUmV0YWluUHRyPFdl YkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3NXZWJWaWV3RGVsZWdhdGU+IHVpRGVsZWdhdGUg PSBhZG9wdE5TKFtbV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxlZ2F0 ZSBhbGxvY10gaW5pdF0pOworICAgIHVpV2ViVmlldy5nZXQoKS5kZWxlZ2F0ZSA9IHVpRGVsZWdh dGUuZ2V0KCk7CisKKyAgICBOU1N0cmluZyogdGVzdEh0bWwgPSBAUiJIVE1MKDxib2R5PgorPHNj cmlwdD4KK2Z1bmN0aW9uIHJ1blRlc3QoKSB7CisgICAgbGV0IGNhbnZhcyA9IGRvY3VtZW50LmNy ZWF0ZUVsZW1lbnQoImNhbnZhcyIpOworICAgIGNhbnZhcy53aWR0aCA9IDEwMDsKKyAgICBjYW52 YXMuaGVpZ2h0ID0gMTAwOworICAgIGxldCBnbCA9IGNhbnZhcy5nZXRDb250ZXh0KCJ3ZWJnbCIp OworICAgIGdsLmNsZWFyQ29sb3IoMCwgMSwgMCwgMSk7CisgICAgZ2wuY2xlYXIoZ2wuQ09MT1Jf QlVGRkVSX0JJVCk7CisgICAgd2luZG93LmxvY2F0aW9uID0gImNhbGxiYWNrOmRpZEZpbmlzaFRl c3QiOworfQorPC9zY3JpcHQ+KUhUTUwiOworICAgIFt1aVdlYlZpZXcgbG9hZEhUTUxTdHJpbmc6 dGVzdEh0bWwgYmFzZVVSTDpuaWxdOworCisgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hMb2FkKTsK KworICAgIFJldGFpblB0cjxKU0NvbnRleHQ+IGpzQ29udGV4dCA9IFt1aVdlYlZpZXcgdmFsdWVG b3JLZXlQYXRoOkAiZG9jdW1lbnRWaWV3LndlYlZpZXcubWFpbkZyYW1lLmphdmFTY3JpcHRDb250 ZXh0Il07CisgICAgRVhQRUNUX1RSVUUoISFqc0NvbnRleHQuZ2V0KCkpOworICAgIFJldGFpblB0 cjxKU1ZpcnR1YWxNYWNoaW5lPiBqc1ZNID0gW2pzQ29udGV4dCB2aXJ0dWFsTWFjaGluZV07Cisg ICAgRVhQRUNUX1RSVUUoW2pzVk0gaXNXZWJUaHJlYWRBd2FyZV0pOworICAgIC8vIFJlbGVhc2Ug V2ViVGhyZWFkIGxvY2suCisgICAgVXRpbDo6c3BpblJ1bkxvb3AoMSk7CisgICAgRVhQRUNUX0ZB TFNFKFdlYlRocmVhZElzTG9ja2VkKCkpOworICAgIAorICAgIGZvciAodW5zaWduZWQgaSA9IDA7 IGkgPCB0ZXN0SXRlcmF0aW9uczsgaSsrKSB7CisgICAgICAgIC8vIFJ1biBXZWJHTCBvbiBjbGll bnQgdGhyZWFkLCBpbiB0aGlzIGNhc2UgdGhpcyB0aHJlYWQsIG1haW4gdGhyZWFkLgorICAgICAg ICBbanNDb250ZXh0IGV2YWx1YXRlU2NyaXB0OiBAInJ1blRlc3QoKTsiXTsKKyAgICAgICAgRVhQ RUNUX1RSVUUoZGlkRmluaXNoVGVzdCk7CisgICAgICAgIGRpZEZpbmlzaFRlc3QgPSBmYWxzZTsK KyAgICAgICAgLy8gQ2xpZW50IGNsb2JiZXJzIEVBR0xDb250ZXh0IGJldHdlZW4gY2FsbHMgdGhh dCBydW4gV2ViR0wgb24gY2xpZW50IHRocmVhZC4KKyAgICAgICAgW0VBR0xDb250ZXh0IHNldEN1 cnJlbnRDb250ZXh0OiBjbGllbnRDb250ZXh0LmdldCgpXTsKKyAgICAgICAgW2pzQ29udGV4dCBl dmFsdWF0ZVNjcmlwdDogQCJydW5UZXN0KCk7Il07CisgICAgICAgIEVYUEVDVF9UUlVFKGRpZEZp bmlzaFRlc3QpOworICAgICAgICBkaWRGaW5pc2hUZXN0ID0gZmFsc2U7CisgICAgICAgIAorICAg ICAgICAvLyBSdW4gV2ViR0wgb24gd2ViIHRocmVhZC4KKyAgICAgICAgW3VpV2ViVmlldyBzdHJp bmdCeUV2YWx1YXRpbmdKYXZhU2NyaXB0RnJvbVN0cmluZzpAInNldFRpbWVvdXQocnVuVGVzdCwg MTApOyJdOworICAgICAgICBFWFBFQ1RfRkFMU0UoZGlkRmluaXNoVGVzdCk7CisgICAgICAgIFV0 aWw6OnJ1bigmZGlkRmluaXNoVGVzdCk7CisgICAgICAgIGRpZEZpbmlzaFRlc3QgPSBmYWxzZTsK KyAgICB9CisKKyAgICAvLyBBZGRpdGlvbmFsIHRlc3QgdGhhdCBuaWwgRUFHTENvbnRleHQgc3Rh eXMgbmlsLgorICAgIFtFQUdMQ29udGV4dCBzZXRDdXJyZW50Q29udGV4dDogbmlsXTsKKyAgICBm b3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdGVzdEl0ZXJhdGlvbnM7IGkrKykgeworICAgICAgICBb anNDb250ZXh0IGV2YWx1YXRlU2NyaXB0OiBAInJ1blRlc3QoKTsiXTsKKyAgICAgICAgRVhQRUNU X0VRKFtFQUdMQ29udGV4dCBjdXJyZW50Q29udGV4dF0sIG5pbCk7CisgICAgICAgIEVYUEVDVF9U UlVFKGRpZEZpbmlzaFRlc3QpOworICAgICAgICBkaWRGaW5pc2hUZXN0ID0gZmFsc2U7CisgICAg ICAgIFt1aVdlYlZpZXcgc3RyaW5nQnlFdmFsdWF0aW5nSmF2YVNjcmlwdEZyb21TdHJpbmc6QCJz ZXRUaW1lb3V0KHJ1blRlc3QsIDEwKTsiXTsKKyAgICAgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hU ZXN0KTsKKyAgICAgICAgZGlkRmluaXNoVGVzdCA9IGZhbHNlOworICAgIH0KK30KKworfQorCisj ZW5kaWYK 409997 2020-09-29 07:19:21 -0700 2020-10-01 01:26:53 -0700 Patch bug-216106-20200929171919.patch text/plain 115437 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjY3NjkyCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggOTFjYTUyYWIwMGE2ZWE5ZTZhNGU1ZDIwM2JmYjE3YWZmY2ZlZDNiZi4uMjZhMjE4NzMyODM3 OWEwNDI0MmNmNjhkMjQyNzllY2Q0OWMzNjIyZiAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDY4IEBACisyMDIwLTA5LTI5ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXSzFdIENyYXNoZXMgd2hlbiB1c2luZyBBTkdM RSBXZWJHTCBmcm9tIGFub3RoZXIgdGhyZWFkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMTYxMDYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY4NjAy NDUyPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCB0d28gZXh0ZW5zaW9ucyBmb3IgRUFHTCBhbmQgQ0dMIGJhY2tlbmRzIHRvIGRlY2xhcmUgdGhl CisgICAgICAgIHVuZGVybHlpbmcgcGxhdGZvcm0gY29udGV4dCBiZWluZyAidm9sYXRpbGUiLiBJ dCBtZWFucyB0aGF0CisgICAgICAgIHRoZSB0aHJlYWQtZ2xvYmFsIGN1cnJlbnQgY29udGV4dCBp cyBiZWluZyBtb2RpZmllZCBiZWhpbmQKKyAgICAgICAgQU5HTEUuIElmIEFOR0xFIGNvbnRleHQg aXMgbWFya2VkIHZvbGF0aWxlIGZvciBhIHBhcnRpY3VsYXIKKyAgICAgICAgQVBJLCBpdCB3aWxs IHN5bmMgdGhlIHVuZGVybHlpbmcgY29udGV4dCBmb3IgZXZlcnkgRUdMCisgICAgICAgIGZ1bmN0 aW9uIHRoYXQgbmVlZHMgdGhlIGNvbnRleHQuIE1vc3QgaW50dWl0aXZlIHVzZSBpcworICAgICAg ICBmb3IgdGhlIGNsaWVudCB0byBjYWxsIGVnbE1ha2VDdXJyZW50IGJlZm9yZSBjYWxsaW5nIGFu eQorICAgICAgICBnbCBmdW5jdGlvbiBpZiB0aGUgY2xpZW50IGtub3ducyB0aGUgcGxhdGZvcm0g c3RhdGUgbWlnaHQKKyAgICAgICAgYmUgZGlydHkuCisKKyAgICAgICAgSW1wbGVtZW50IGVnbFJl bGVhc2VUaHJlYWQgZm9yIEVBR0wgYW5kIENHTCBiYWNrZW5kcy4KKyAgICAgICAgUmVsZWFzaW5n IHRocmVhZCB3aWxsIHVuc2V0IHRoZSBwbGF0Zm9ybSBjdXJyZW50IGNvbnRleHQuCisKKyAgICAg ICAgQWRkcyBmbHVzaCB3aGVuIGVnbE1ha2VDdXJyZW50IHN3aXRjaGVzIGNvbnRleHRzLiBUaGlz IGlzCisgICAgICAgIHNwZWNpZmllZCBpbiBFR0wuIFRoaXMgaXMgcHJvYmFibHkgYXBwcm9wcmlh dGUgZHVlIHRvIHRoZQorICAgICAgICBwdXJwb3NlIG9mIHRoZSBwYXRjaCBiZWluZyB1c2luZyB0 aGUgY29udGV4dCBmcm9tIG11bHRpcGxlCisgICAgICAgIHRocmVhZHMuIFRoZW9yZXRpY2FsbHkg RUFHTCBhY2Nlc3Mgb24gb25lIHRocmVhZCBjb3VsZAorICAgICAgICBxdWV1ZSBzb21lIGNvbW1h bmRzIGFuZCBFQUdMIGFjY2VzcyBvbiBhbm90aGVyIHRocmVhZAorICAgICAgICBjb3VsZCBqdW1w IGFoZWFkIG9mIHRoZXNlIHF1ZXVlZCBjb21tYW5kcy4KKworICAgICAgICBGaXggYSBidWcgb2Yg b21pdHRpbmcgRUdMX0FOR0xFX2RldmljZV9lYWdsIGZyb20gYmVpbmcKKyAgICAgICAgYWR2ZXJ0 aXNlZC4KKworICAgICAgICAqIGluY2x1ZGUvRUdML2VnbGV4dF9hbmdsZS5oOgorICAgICAgICAq IHNyYy9saWJBTkdMRS9DYXBzLmNwcDoKKyAgICAgICAgKGVnbDo6RGV2aWNlRXh0ZW5zaW9uczo6 Z2V0U3RyaW5ncyBjb25zdCk6CisgICAgICAgIChlZ2w6OkNsaWVudEV4dGVuc2lvbnM6OmdldFN0 cmluZ3MgY29uc3QpOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9DYXBzLmg6CisgICAgICAgICog c3JjL2xpYkFOR0xFL0NvbnRleHQuY3BwOgorICAgICAgICAoZ2w6OkNvbnRleHQ6OnVuTWFrZUN1 cnJlbnQpOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9EaXNwbGF5LmNwcDoKKyAgICAgICAgKGVn bDo6RGlzcGxheTo6YmluZFRocmVhZCk6CisgICAgICAgIChlZ2w6OkRpc3BsYXk6OnJlbGVhc2VU aHJlYWQpOgorICAgICAgICAoZWdsOjpHZW5lcmF0ZUNsaWVudEV4dGVuc2lvbnMpOgorICAgICAg ICAqIHNyYy9saWJBTkdMRS9EaXNwbGF5Lmg6CisgICAgICAgICogc3JjL2xpYkFOR0xFL3JlbmRl cmVyL0Rpc3BsYXlJbXBsLmg6CisgICAgICAgICogc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL0Rp c3BsYXlHTC5jcHA6CisgICAgICAgIChyeDo6RGlzcGxheUdMOjpiaW5kVGhyZWFkKToKKyAgICAg ICAgKHJ4OjpEaXNwbGF5R0w6OnJlbGVhc2VUaHJlYWQpOgorICAgICAgICAqIHNyYy9saWJBTkdM RS9yZW5kZXJlci9nbC9EaXNwbGF5R0wuaDoKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvcmVuZGVy ZXIvZ2wvY2dsL0Rpc3BsYXlDR0wuaDoKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvcmVuZGVyZXIv Z2wvY2dsL0Rpc3BsYXlDR0wubW06CisgICAgICAgIChyeDo6RGlzcGxheUNHTDo6aW5pdGlhbGl6 ZSk6CisgICAgICAgIChyeDo6RGlzcGxheUNHTDo6dGVybWluYXRlKToKKyAgICAgICAgKHJ4OjpE aXNwbGF5Q0dMOjpiaW5kVGhyZWFkKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5Q0dMOjpyZWxlYXNl VGhyZWFkKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5Q0dMOjptYWtlQ3VycmVudCk6CisgICAgICAg ICogc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2VhZ2wvRGlzcGxheUVBR0wuaDoKKyAgICAgICAg KiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbToKKyAgICAgICAg KHJ4OjpEaXNwbGF5RUFHTDo6aW5pdGlhbGl6ZSk6CisgICAgICAgIChyeDo6RGlzcGxheUVBR0w6 OnRlcm1pbmF0ZSk6CisgICAgICAgIChyeDo6RGlzcGxheUVBR0w6OmJpbmRUaHJlYWQpOgorICAg ICAgICAocng6OkRpc3BsYXlFQUdMOjpyZWxlYXNlVGhyZWFkKToKKyAgICAgICAgKiBzcmMvbGli QU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9FQUdMRnVuY3Rpb25zLmg6CisgICAgICAgICogc3JjL2xp YkdMRVN2Mi9lbnRyeV9wb2ludHNfZWdsLmNwcDoKKyAgICAgICAgKiBzcmMvbGliR0xFU3YyL2Vu dHJ5X3BvaW50c19lZ2xfZXh0LmNwcDoKKwogMjAyMC0wOS0yNCAgRGVhbiBKYWNrc29uICA8ZGlu b0BhcHBsZS5jb20+CiAKICAgICAgICAgV2ViR0wgc2hvdWxkIHVzZSBHTEVTIGluIGlPUyBhcHBz IHJ1bm5pbmcgb24gQXBwbGUgU2lsaWNvbgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGU2YWE1NGE1NWEzOWQ4MjMx MzYzOGJhNTA5NTczYTE0ODhkMzlmZDUuLjFkOTFlOGYxYTZiZWY5NmZiMWE2ZTljYzZhNGUxZTE4 NTVmOTc5OGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw3MSBAQAorMjAyMC0wOS0yOSAgS2ltbW8g S2lubnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgorCisgICAgICAgIFtpT1MgV0sxXSBDcmFz aGVzIHdoZW4gdXNpbmcgQU5HTEUgV2ViR0wgZnJvbSBhbm90aGVyIHRocmVhZAorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE2MTA2CisgICAgICAgIDxy ZGFyOi8vcHJvYmxlbS82ODYwMjQ1Mj4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBTb3VyY2Ugb2YgdGhlIGJ1ZyBjb21lcyBmcm9tIGZvbGxvd2luZzoK KyAgICAgICAgICAtIFdLMSBtaWdodCBydW4gV2ViS2l0IGNvZGUgaW4gY2xpZW50IG1haW4gdGhy ZWFkLgorICAgICAgICAgIC0gV0sxIG1pZ2h0IHJ1biBXZWJraXQgY29kZSBpbiB3ZWIgdGhyZWFk LgorICAgICAgICAgIC0gV2ViS2l0IGNvZGUgbWlnaHQgcnVuIFdlYkdMIHBheWxvYWQsIG5vdGFi bHkgYWNjZXNzIAorICAgICAgICAgICAgR3JhcGhpY3NDb250ZXh0R0wgY2xhc3Nlcy4KKyAgICAg ICAgICAgIENsaWVudCBpcyBhYmxlIHRvIG1vZGlmeSBFQUdML0NHTCBjdXJyZW50IGNvbnRleHQu CisKKyAgICAgICAgVGhlIGNoYW5nZSB0byBBTkdMRSBpbmN1cnJlZCB0d28gZGlzdGluY3QgYmVo YXZpb3IgY2hhbmdlcworICAgICAgICBjb21wYXJlZCB0byByYXcgRUFHTCAvIENHTDoKKyAgICAg ICAgMSkgQmVmb3JlOiBjb250ZXh0IHdhcyBzZXQgY3VycmVudCBiZWZvcmUgYW55IEdMIGNhbGwK KyAgICAgICAgQWZ0ZXI6IGNvbnRleHQgd2FzIHNldCBjdXJyZW50IG9ubHkgaWYgRUdMIGN1cnJl bnQgY29udGV4dAorICAgICAgICBoYWQgYmVlbiBjaGFuZ2VkLiAoRXhwbGljaXQgY29kZSBhcyB3 ZWxsIGFzIEFOR0xFIGltcGxlbWVudGF0aW9uCisgICAgICAgIG9wdGltaXphdGlvbi4pCisKKyAg ICAgICAgMikgQmVmb3JlOiBjb250ZXh0IGJlaW5nIHVzZWQgd2FzIGFibGUgdG8gYmUgY3VycmVu dCBpbgorICAgICAgICBtdWx0aXBsZSB0aHJlYWRzIGF0IHRoZSBzYW1lIHRpbWUuIChFQUdML0NH TCBmZWF0dXJlKQorICAgICAgICBBZnRlcjogY29udGV4dCBjYW5ub3QgYmUgY3VycmVudCBpbiBt dWx0aXBsZSB0aHJlYWRzCisgICAgICAgIGF0IHRoZSBzYW1lIHRpbWUuIChFR0wgZmVhdHVyZSkK KworICAgICAgICBDaGFuZ2UgaW4gYmVoYXZpb3IgMSkgY2F1c2VkIEFOR0xFIHRvIHNvbWV0aW1l cyB1c2UKKyAgICAgICAgdGhlIEVBR0wvQ0dMIGNvbnRleHQgb2YgdGhlIGNsaWVudCBpbnN0ZWFk IG9mCisgICAgICAgIHRoZSByZWFsIGNvbnRleHQgdGhhdCBBTkdMRSBjcmVhdGVkLgorICAgICAg ICBGaXggdGhpcyBieSBpbnRyb2R1Y2luZworICAgICAgICBFR0xfQU5HTEVfcGxhdGZvcm1fYW5n bGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbAorICAgICAgICBhbmQKKyAgICAgICAgRUdM X0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2NnbAorICAgICAg ICB3aGljaCBtYWtlIEFOR0xFIHN5bmMgdGhlIGNvbnRleHQgb24gZWFjaCBlZ2xNYWtlQ3VycmVu dAorICAgICAgICBlZ2xSZWxlYXNlVGhyZWFkIGFuZCBlZ2xUZXJtaW5hdGUuCisKKyAgICAgICAg Q2hhbmdlIGluIGJlaGF2aW9yIDIpIGNhdXNlZCBBTkdMRSB0byB1c2UgdW5pbml0aWFsaXplZAor ICAgICAgICBjb250ZXh0IG9iamVjdCBmcm9tIG9uZSB0aHJlYWQsIGlmIHRoZSByZWFsIGNvbnRl eHQgb2JqZWN0CisgICAgICAgIHdhcyBjdXJyZW50IGluIGFub3RoZXIgdGhyZWFkLgorICAgICAg ICBGaXggdGhpcyBieSBjb25zaWRlcmluZyAiR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wgY3VycmVu dCBjb250ZXh0IgorICAgICAgICBhcyBwYXJ0IG9mICJkYXRhIHRoYXQgaXMgb3duZWQgYnkgV2Vi Q29yZVRocmVhZCBsb2NrIi4KKyAgICAgICAgVGhlIGN1cnJlbnQgY29udGV4dCBpcyBzZXQgd2l0 aCBsb2NrIGhlbGQsIGltcGxpY2l0bHkuCisgICAgICAgIFRoZSBjdXJyZW50IGNvbnRleHQgaXMg cmVsZWFzZWQgd2hlbiBsb2NrIGlzIHJlbGVhc2VkLgorICAgICAgICBXaGVuIHRoZSBsb2NrIGlz IG5vdCBoZWxkLCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTCBjdXJyZW50IGNvbnRleHQKKyAgICAg ICAgaXMgbnVsbHB0ci4KKworICAgICAgICBBZGRzIHNvZnQgbGlua2luZyBmb3IgRUFHTCBmb3Ig dGhlIHB1cnBvc2Ugb2YgdGVzdGluZyB0aGlzIGluCisgICAgICAgIFRlc3RXZWJLaXRBUEkuIFRo ZSBjYXNlIG9mIEFwcGxlIFNpbGljb24gTWFjIG1heSBzb21ldGltZXMKKyAgICAgICAgdXNlIENH TCBhbmQgc29tZXRpbWVzIEVBR0wsIGFuZCB0aGUgdGVzdCBzaG91bGQgdGVzdCB0aGF0CisgICAg ICAgIGNsaWVudCBvdmVycmlkaW5nIGJvdGggY29udGV4dHMgd2lsbCBub3QgY2F1c2UgcHJvYmxl bXMuCisKKyAgICAgICAgKiBDb25maWd1cmF0aW9ucy9XZWJDb3JlLnhjY29uZmlnOgorICAgICAg ICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBodG1sL2Nh bnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHRCYXNlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Oldl YkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6Omxvc2VDb250ZXh0SW1wbCk6CisgICAgICAgICogcGxh dGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0R0wuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9n cmFwaGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRHTE9wZW5HTENvY29hLm1tOgorICAgICAgICAo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdM KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjp+R3JhcGhpY3ND b250ZXh0R0xPcGVuR0wpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVu R0w6Om1ha2VDb250ZXh0Q3VycmVudCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHRHTE9wZW5HTDo6cmVsZWFzZUN1cnJlbnRDb250ZXh0SWZOZWVkZWQpOgorICAgICAgICAoV2Vi Q29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OmNoZWNrR1BVU3RhdHVzKToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaDoKKyAg ICAgICAgKiBwbGF0Zm9ybS9pb3Mvd2FrL1dlYkNvcmVUaHJlYWQubW06CisgICAgICAgIChXZWJU aHJlYWRVbmxvY2tGcm9tQW55VGhyZWFkKToKKyAgICAgICAgKF9XZWJUaHJlYWRVbmxvY2spOgor CiAyMDIwLTA5LTI0ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgogCiAg ICAgICAgIFdlYktpdExlZ2FjeSBzaG91bGQgY2FsbCBQYWdlOjpmaW5hbGl6ZVJlbmRlcmluZ1Vw ZGF0ZSgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nIGIvU291cmNl L1dlYkNvcmUvUEFML0NoYW5nZUxvZwppbmRleCBlYTFiNjdlYzVlMzFjNjI5ZGRmMGYyYjhiNzVm NTI1MjdiYTlkZTQzLi43MWFhNDc5YmYwYjNjNjg1NGM2Yzk4MjZlMGM4YzU4ZTVmYmY2MGJkIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJD b3JlL1BBTC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAyMC0wOS0yOSAgS2ltbW8gS2lu bnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgorCisgICAgICAgIFtpT1MgV0sxXSBDcmFzaGVz IHdoZW4gdXNpbmcgQU5HTEUgV2ViR0wgZnJvbSBhbm90aGVyIHRocmVhZAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE2MTA2CisgICAgICAgIDxyZGFy Oi8vcHJvYmxlbS82ODYwMjQ1Mj4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBZGRzIHNvZnQgbGlua2luZyBmb3IgRUFHTCBmb3IgdGhlIHB1cnBvc2Ug b2YgdGVzdGluZyB0aGlzIGluCisgICAgICAgIFRlc3RXZWJLaXRBUEkuIFRoZSBjYXNlIG9mIEFw cGxlIFNpbGljb24gTWFjIG1heSBzb21ldGltZXMKKyAgICAgICAgdXNlIENHTCBhbmQgc29tZXRp bWVzIEVBR0wsIGFuZCB0aGUgdGVzdCBzaG91bGQgdGVzdCB0aGF0CisgICAgICAgIGNsaWVudCBv dmVycmlkaW5nIGJvdGggY29udGV4dHMgd2lsbCBub3QgY2F1c2UgcHJvYmxlbXMuCisKKyAgICAg ICAgQWRkIENHTFNldEN1cnJlbnRDb250ZXh0IHRvIHNvZnRsaW5raW5nLCB3aWxsIGJlIHVzZWQg aW4KKyAgICAgICAgdGhlIHRlc3Qgb2YgdGhlIGZpeC4KKworICAgICAgICAqIENvbmZpZ3VyYXRp b25zL1BBTC54Y2NvbmZpZzoKKyAgICAgICAgKiBQQUwueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv ajoKKyAgICAgICAgKiBwYWwvY29jb2EvT3BlbkdMU29mdExpbmtDb2NvYS5oOgorICAgICAgICAq IHBhbC9jb2NvYS9PcGVuR0xTb2Z0TGlua0NvY29hLm1tOgorCiAyMDIwLTA5LTI0ICBEZWFuIEph Y2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJHTCBzaG91bGQgdXNlIEdMRVMg aW4gaU9TIGFwcHMgcnVubmluZyBvbiBBcHBsZSBTaWxpY29uCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDY3MGQ0MDgz M2UyMzBjZGQ2N2EwZWFiMjEyOGI5N2UyYWU5MjQ2NTkuLjVkZGIyZjNiMzYxMmUxY2JjMDA4ZTEz NzEzNjY4ZTNjYWM0YTcyZGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMjAtMDktMjkg IEtpbW1vIEtpbm51bmVuICA8a2tpbm51bmVuQGFwcGxlLmNvbT4KKworICAgICAgICBbaU9TIFdL MV0gQ3Jhc2hlcyB3aGVuIHVzaW5nIEFOR0xFIFdlYkdMIGZyb20gYW5vdGhlciB0aHJlYWQKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNjEwNgorICAg ICAgICA8cmRhcjovL3Byb2JsZW0vNjg2MDI0NTI+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQ29jb2EvVXNlck1lZGlhUGVybWlz c2lvblJlcXVlc3RQcm94eS5tbToKKyAgICAgICAgKFdlYktpdDo6VXNlck1lZGlhUGVybWlzc2lv blJlcXVlc3RQcm94eTo6ZG9EZWZhdWx0QWN0aW9uKToKKwogMjAyMC0wOS0yNyAgTGF1cm8gTW91 cmEgIDxsbW91cmFAaWdhbGlhLmNvbT4KIAogICAgICAgICBSRUdSRVNTSU9OKHIyNjc2ODgpIFtH VEtdIE1hbnkgY29tcG9zaXRpbmcgdGltZW91dHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBh cnR5L0FOR0xFL2luY2x1ZGUvRUdML2VnbGV4dF9hbmdsZS5oIGIvU291cmNlL1RoaXJkUGFydHkv QU5HTEUvaW5jbHVkZS9FR0wvZWdsZXh0X2FuZ2xlLmgKaW5kZXggNDcwMmQ5NWE0YzMyNzZjOGFl ZTQ0MDg3OWU2N2JmYzZhZWU0NmNlNC4uZmU2ZDQwOGE2NWIwNTY4YmNhMWUwODBmN2U4ODM1Mzc0 Y2ZhMGRkNSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvaW5jbHVkZS9FR0wv ZWdsZXh0X2FuZ2xlLmgKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvaW5jbHVkZS9FR0wv ZWdsZXh0X2FuZ2xlLmgKQEAgLTExNiw2ICsxMTYsMTYgQEAKICNkZWZpbmUgRUdMX1BMQVRGT1JN X0FOR0xFX0NPTlRFWFRfVklSVFVBTElaQVRJT05fQU5HTEUgMHgzNDgxCiAjZW5kaWYgLyogRUdM X0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2NvbnRleHRfdmlydHVhbGl6YXRpb24gKi8KIAorI2lmbmRl ZiBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbAor I2RlZmluZSBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVf ZWFnbCAxCisjZGVmaW5lIEVHTF9QTEFURk9STV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElM RV9FQUdMX0FOR0xFIDB4MzQ5MAorI2VuZGlmIC8qIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9k ZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsICovCisKKyNpZm5kZWYgRUdMX0FOR0xFX3BsYXRm b3JtX2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2NnbAorI2RlZmluZSBFR0xfQU5HTEVf cGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfY2dsIDEKKyNkZWZpbmUgRUdM X1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0NHTF9BTkdMRSAweDM0OTEK KyNlbmRpZiAvKiBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRp bGVfZWFnbCAqLworCiAjaWZuZGVmIEVHTF9BTkdMRV94MTFfdmlzdWFsCiAjZGVmaW5lIEVHTF9B TkdMRV94MTFfdmlzdWFsCiAjZGVmaW5lIEVHTF9YMTFfVklTVUFMX0lEX0FOR0xFIDB4MzNBMwpk aWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0NhcHMuY3Bw IGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0NhcHMuY3BwCmluZGV4IGE2 MzJiMGMxNDNkMTM1OGE0ZTUxZDY5MjUxYTEzZTZiZDM4ODBlNTYuLmEwMWJlYzNhMTc5ODZmYzdj YzFlMmM2NzYzMmZhNDcyZmQ3N2U3OTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJBTkdMRS9DYXBzLmNwcAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9z cmMvbGliQU5HTEUvQ2Fwcy5jcHAKQEAgLTE0MTgsNiArMTQxOCw4IEBAIHN0ZDo6dmVjdG9yPHN0 ZDo6c3RyaW5nPiBEZXZpY2VFeHRlbnNpb25zOjpnZXRTdHJpbmdzKCkgY29uc3QKICAgICAvLyAg ICAgICAgICAgICAgICAgICB8IEV4dGVuc2lvbiBuYW1lICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCBTdXBwb3J0ZWQgZmxhZyAgICAgICAgICAgICAgICB8IE91dHB1dCB2ZWN0b3Ig ICB8CiAgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5nKCJFR0xfQU5HTEVfZGV2aWNlX2QzZCIsICAg ICAgICAgICAgICAgICAgICAgICAgICBkZXZpY2VEM0QsICAgICAgICAgICAgICAgICAgICAgICZl eHRlbnNpb25TdHJpbmdzKTsKICAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV9k ZXZpY2VfY2dsIiwgICAgICAgICAgICAgICAgICAgICAgICAgIGRldmljZUNHTCwgICAgICAgICAg ICAgICAgICAgICAgJmV4dGVuc2lvblN0cmluZ3MpOworICAgIEluc2VydEV4dGVuc2lvblN0cmlu ZygiRUdMX0FOR0xFX2RldmljZV9lYWdsIiwgICAgICAgICAgICAgICAgICAgICAgICAgZGV2aWNl RUFHTCwgICAgICAgICAgICAgICAgICAgICAmZXh0ZW5zaW9uU3RyaW5ncyk7CisKICAgICAvLyBj bGFuZy1mb3JtYXQgb24KIAogICAgIHJldHVybiBleHRlbnNpb25TdHJpbmdzOwpAQCAtMTQ0NSw2 ICsxNDQ3LDggQEAgc3RkOjp2ZWN0b3I8c3RkOjpzdHJpbmc+IENsaWVudEV4dGVuc2lvbnM6Omdl dFN0cmluZ3MoKSBjb25zdAogICAgIEluc2VydEV4dGVuc2lvblN0cmluZygiRUdMX0FOR0xFX3Bs YXRmb3JtX2FuZ2xlX3Z1bGthbiIsICAgICAgICAgICAgICAgICAgcGxhdGZvcm1BTkdMRVZ1bGth biwgICAgICAgICAgICAgICAgJmV4dGVuc2lvblN0cmluZ3MpOwogICAgIEluc2VydEV4dGVuc2lv blN0cmluZygiRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xlX21ldGFsIiwgICAgICAgICAgICAgICAg ICAgcGxhdGZvcm1BTkdMRU1ldGFsLCAgICAgICAgICAgICAgICAgJmV4dGVuc2lvblN0cmluZ3Mp OwogICAgIEluc2VydEV4dGVuc2lvblN0cmluZygiRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2Nv bnRleHRfdmlydHVhbGl6YXRpb24iLCAgcGxhdGZvcm1BTkdMRUNvbnRleHRWaXJ0dWFsaXphdGlv biwgJmV4dGVuc2lvblN0cmluZ3MpOworICAgIEluc2VydEV4dGVuc2lvblN0cmluZygiRUdMX0FO R0xFX3BsYXRmb3JtX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2VhZ2wiLCAgcGxhdGZvcm1BTkdM RURldmljZUNvbnRleHRWb2xhdGlsZUVhZ2wsICZleHRlbnNpb25TdHJpbmdzKTsKKyAgICBJbnNl cnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV9wbGF0Zm9ybV9kZXZpY2VfY29udGV4dF92b2xh dGlsZV9jZ2wiLCAgIHBsYXRmb3JtQU5HTEVEZXZpY2VDb250ZXh0Vm9sYXRpbGVDZ2wsICZleHRl bnNpb25TdHJpbmdzKTsKICAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV9kZXZp Y2VfY3JlYXRpb24iLCAgICAgICAgICAgICAgICAgICAgICAgIGRldmljZUNyZWF0aW9uLCAgICAg ICAgICAgICAgICAgICAgICZleHRlbnNpb25TdHJpbmdzKTsKICAgICBJbnNlcnRFeHRlbnNpb25T dHJpbmcoIkVHTF9BTkdMRV9kZXZpY2VfY3JlYXRpb25fZDNkMTEiLCAgICAgICAgICAgICAgICAg IGRldmljZUNyZWF0aW9uRDNEMTEsICAgICAgICAgICAgICAgICZleHRlbnNpb25TdHJpbmdzKTsK ICAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV94MTFfdmlzdWFsIiwgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHgxMVZpc3VhbCwgICAgICAgICAgICAgICAgICAgICAgICAg ICZleHRlbnNpb25TdHJpbmdzKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xF L3NyYy9saWJBTkdMRS9DYXBzLmggYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5H TEUvQ2Fwcy5oCmluZGV4IDM3MTNhYmFkMjNjZjkzY2Q1NTAxZDZhY2Q5YmMyMjczMzEzNTEzODYu LjBjZWM2NWY3MThjYjlmNDBjZTNkYjFjZjA0ODNjODA1YTlkNjdlYzEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9DYXBzLmgKKysrIGIvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0NhcHMuaApAQCAtMTE0NSw2ICsxMTQ1LDEyIEBA IHN0cnVjdCBDbGllbnRFeHRlbnNpb25zCiAgICAgLy8gRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xl X2NvbnRleHRfdmlydHVhbGl6YXRpb24KICAgICBib29sIHBsYXRmb3JtQU5HTEVDb250ZXh0Vmly dHVhbGl6YXRpb24gPSBmYWxzZTsKIAorICAgIC8vIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9k ZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsCisgICAgYm9vbCBwbGF0Zm9ybUFOR0xFRGV2aWNl Q29udGV4dFZvbGF0aWxlRWFnbCA9IGZhbHNlOworCisgICAgLy8gRUdMX0FOR0xFX3BsYXRmb3Jt X2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2NnbAorICAgIGJvb2wgcGxhdGZvcm1BTkdM RURldmljZUNvbnRleHRWb2xhdGlsZUNnbCA9IGZhbHNlOworCiAgICAgLy8gRUdMX0FOR0xFX2Rl dmljZV9jcmVhdGlvbgogICAgIGJvb2wgZGV2aWNlQ3JlYXRpb24gPSBmYWxzZTsKIApkaWZmIC0t Z2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0NvbnRleHQuY3BwIGIv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0NvbnRleHQuY3BwCmluZGV4IGRj Y2M4YTc4ODQxYjI1ODJjMWE4OWNiY2UzOWI5NDU4MmUzODdiZjUuLmI0NDZhZWRkZmFiOGY5ZTM0 Mjc2NWVhMzJjMmZjMjE2NjAxNzRjMTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJBTkdMRS9Db250ZXh0LmNwcAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdM RS9zcmMvbGliQU5HTEUvQ29udGV4dC5jcHAKQEAgLTY4OSw3ICs2ODksMTQgQEAgZWdsOjpFcnJv ciBDb250ZXh0OjptYWtlQ3VycmVudChlZ2w6OkRpc3BsYXkgKmRpc3BsYXksCiBlZ2w6OkVycm9y IENvbnRleHQ6OnVuTWFrZUN1cnJlbnQoY29uc3QgZWdsOjpEaXNwbGF5ICpkaXNwbGF5KQogewog ICAgIEFOR0xFX1RSWSh1bnNldERlZmF1bHRGcmFtZWJ1ZmZlcigpKTsKLQorICAgIC8vIEVHTCBT cGVjaWZpY2F0aW9uIDEuNSAzLjcuMyBCaW5kaW5nIENvbnRleHRzIGFuZCBEcmF3YWJsZXMKKyAg ICAvLyBwZy4gNTgKKyAgICAvLyAiSWYgdGhlIGNhbGxpbmcgdGhyZWFkIGFscmVhZHkgaGFzIGEg Y3VycmVudCBjb250ZXh0IG9mIHRoZSBzYW1lIGNsaWVudCBBUEkKKyAgICAvLyAgdHlwZSBhcyBj dHgsIHRoZW4gdGhhdCBjb250ZXh0IGlzIGZsdXNoZWQgYW5kIG1hcmtlZCBhcyBubyBsb25nZXIg Y3VycmVudC4iCisgICAgLy8gcGcuIDU5CisgICAgLy8gIlRoZSBjdXJyZW50bHkgYm91bmQgY29u dGV4dCBmb3IgdGhlIGNsaWVudCBBUEkgc3BlY2lmaWVkIGJ5IGN1cnJlbnQgcmVuZGVyaW5nCisg ICAgLy8gIEFQSSBpcyBmbHVzaGVkIGFuZCBtYXJrZWQgbm8gbG9uZ2VyIGN1cnJlbnQuIgorICAg IEFOR0xFX1RSWShhbmdsZTo6UmVzdWx0VG9FR0wobUltcGxlbWVudGF0aW9uLT5mbHVzaCh0aGlz KSkpOwogICAgIEFOR0xFX1RSWShhbmdsZTo6UmVzdWx0VG9FR0wobUltcGxlbWVudGF0aW9uLT5v blVuTWFrZUN1cnJlbnQodGhpcykpKTsKIAogICAgIC8vIFJldHVybiB0aGUgc2NyYXRjaCBidWZm ZXJzIHRvIHRoZSBkaXNwbGF5IHNvIHRoZXkgY2FuIGJlIHNoYXJlZCB3aXRoIG90aGVyIGNvbnRl eHRzIHdoaWxlCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5H TEUvRGlzcGxheS5jcHAgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlz cGxheS5jcHAKaW5kZXggYzMxN2Y4MjY2MzFiZDBkNTc2MjNkMjk2OWVmOTg0ZDBiMDM3ZmY4Ny4u YjFlYTQ5MmU2YjA0OTA3MzJkMTQ5ZTI0YmUzYjdhMDBkNWVjNzFhYiAxMDA2NDQKLS0tIGEvU291 cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0Rpc3BsYXkuY3BwCisrKyBiL1NvdXJj ZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9EaXNwbGF5LmNwcApAQCAtOTU1LDYgKzk1 NSwxNiBAQCBFcnJvciBEaXNwbGF5Ojp0ZXJtaW5hdGUoY29uc3QgVGhyZWFkICp0aHJlYWQpCiAg ICAgcmV0dXJuIE5vRXJyb3IoKTsKIH0KIAorRXJyb3IgRGlzcGxheTo6YmluZFRocmVhZCgpCit7 CisgICAgcmV0dXJuIG1JbXBsZW1lbnRhdGlvbi0+YmluZFRocmVhZCgpOworfQorCitFcnJvciBE aXNwbGF5OjpyZWxlYXNlVGhyZWFkKCkKK3sKKyAgICByZXR1cm4gbUltcGxlbWVudGF0aW9uLT5y ZWxlYXNlVGhyZWFkKCk7Cit9CisKIHN0ZDo6dmVjdG9yPGNvbnN0IENvbmZpZyAqPiBEaXNwbGF5 OjpnZXRDb25maWdzKGNvbnN0IGVnbDo6QXR0cmlidXRlTWFwICZhdHRyaWJzKSBjb25zdAogewog ICAgIHJldHVybiBtQ29uZmlnU2V0LmZpbHRlcihhdHRyaWJzKTsKQEAgLTE1NDQsNiArMTU1NCwx NCBAQCBzdGF0aWMgQ2xpZW50RXh0ZW5zaW9ucyBHZW5lcmF0ZUNsaWVudEV4dGVuc2lvbnMoKQog ICAgIGV4dGVuc2lvbnMucGxhdGZvcm1BTkdMRURldmljZVR5cGVFR0xBTkdMRSA9IHRydWU7CiAj ZW5kaWYKIAorI2lmIChkZWZpbmVkKEFOR0xFX1BMQVRGT1JNX0lPUykgJiYgIWRlZmluZWQoQU5H TEVfUExBVEZPUk1fTUFDQ0FUQUxZU1QpKSB8fCAoZGVmaW5lZChBTkdMRV9QTEFURk9STV9NQUND QVRBTFlTVCkgJiYgZGVmaW5lZChBTkdMRV9DUFVfQVJNNjQpKQorICAgIGV4dGVuc2lvbnMucGxh dGZvcm1BTkdMRURldmljZUNvbnRleHRWb2xhdGlsZUVhZ2wgPSB0cnVlOworI2VuZGlmCisKKyNp ZiBkZWZpbmVkKEFOR0xFX1BMQVRGT1JNX01BQ09TKSB8fCBkZWZpbmVkKEFOR0xFX1BMQVRGT1JN X01BQ0NBVEFMWVNUKQorICAgIGV4dGVuc2lvbnMucGxhdGZvcm1BTkdMRURldmljZUNvbnRleHRW b2xhdGlsZUNnbCA9IHRydWU7CisjZW5kaWYKKwogICAgIGV4dGVuc2lvbnMuY2xpZW50R2V0QWxs UHJvY0FkZHJlc3NlcyA9IHRydWU7CiAgICAgZXh0ZW5zaW9ucy5kZWJ1ZyAgICAgICAgICAgICAg ICAgICAgID0gdHJ1ZTsKICAgICBleHRlbnNpb25zLmV4cGxpY2l0Q29udGV4dCAgICAgICAgICAg PSB0cnVlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xF L0Rpc3BsYXkuaCBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9EaXNwbGF5 LmgKaW5kZXggNDlkYmE5MTZhMTRiYjg0NGUzY2M5MGVkNjZkYTMzYmUxMTk4NmQ2NC4uMGZlYjRj MTE0OWMyZmRhNDE1NThlZmU4YmMyMDI2ZmFiYjI0ZmEwMSAxMDA2NDQKLS0tIGEvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0Rpc3BsYXkuaAorKysgYi9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5oCkBAIC0xMDIsNiArMTAyLDEyIEBAIGNs YXNzIERpc3BsYXkgZmluYWwgOiBwdWJsaWMgTGFiZWxlZE9iamVjdCwKIAogICAgIEVycm9yIGlu aXRpYWxpemUoKTsKICAgICBFcnJvciB0ZXJtaW5hdGUoY29uc3QgVGhyZWFkICp0aHJlYWQpOwor ICAgIC8vIENhbGxlZCBiZWZvcmUgYW55IHN0YXRlLWRlcGVuZGVudCBFR0wgZnVuY3Rpb24uIEJh Y2tlbmRzIGNhbiBzZXQgdXAgdGhyZWFkLXNwZWNpZmljCisgICAgLy8gYmFja2VuZCBzdGF0ZSB0 aHJvdWdoIHRoaXMgZnVuY3Rpb24uIE5vdCBjYWxsZWQgZm9yIGVnbEdldCosIGVnbEluaXRpYWxp emUsIGVnbEJpbmRBUEkuCisgICAgRXJyb3IgYmluZFRocmVhZCgpOworICAgIC8vIENhbGxlZCBv biBlZ2xSZWxlYXNlVGhyZWFkLiBCYWNrZW5kcyBjYW4gdGVhciBkb3duIHRocmVhZC1zcGVjaWZp YyBiYWNrZW5kIHN0YXRlIHRocm91Z2gKKyAgICAvLyB0aGlzIGZ1bmN0aW9uLgorICAgIEVycm9y IHJlbGVhc2VUaHJlYWQoKTsKIAogICAgIHN0YXRpYyBEaXNwbGF5ICpHZXREaXNwbGF5RnJvbURl dmljZShEZXZpY2UgKmRldmljZSwgY29uc3QgQXR0cmlidXRlTWFwICZhdHRyaWJNYXApOwogICAg IHN0YXRpYyBEaXNwbGF5ICpHZXREaXNwbGF5RnJvbU5hdGl2ZURpc3BsYXkoRUdMTmF0aXZlRGlz cGxheVR5cGUgbmF0aXZlRGlzcGxheSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9EaXNwbGF5SW1wbC5oIGIvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKaW5kZXggNjZlNDdi YzkxM2Y4NzE4NWVkYzI5NTY3ODMyMWY2NWNkYmU2MTE1My4uZWY5NjgzMDgwNTljMzRlNDk5YjY3 NDUxN2ZmN2I2M2FiYjY1NGI5OCAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUv c3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKKysrIGIvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKQEAgLTY3LDExICs2 NywxNCBAQCBjbGFzcyBEaXNwbGF5SW1wbCA6IHB1YmxpYyBFR0xJbXBsRmFjdG9yeSwgcHVibGlj IGFuZ2xlOjpTdWJqZWN0CiAKICAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgaW5pdGlhbGl6ZShlZ2w6 OkRpc3BsYXkgKmRpc3BsYXkpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgdGVybWluYXRlKCkgICAg ICAgICAgICAgICAgICAgICAgICAgICAgID0gMDsKKyAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgYmlu ZFRocmVhZCgpID0gMDsKKyAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgcmVsZWFzZVRocmVhZCgpID0g MDsKIAogICAgIHZpcnR1YWwgZWdsOjpFcnJvciBtYWtlQ3VycmVudChlZ2w6OlN1cmZhY2UgKmRy YXdTdXJmYWNlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlZ2w6OlN1cmZh Y2UgKnJlYWRTdXJmYWNlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbDo6 Q29udGV4dCAqY29udGV4dCkgPSAwOwogCisKICAgICB2aXJ0dWFsIGVnbDo6Q29uZmlnU2V0IGdl bmVyYXRlQ29uZmlncygpID0gMDsKIAogICAgIHZpcnR1YWwgYm9vbCB0ZXN0RGV2aWNlTG9zdCgp ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gMDsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9EaXNwbGF5R0wu Y3BwIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL0Rp c3BsYXlHTC5jcHAKaW5kZXggZDY1ZGZkYThjZWMzMWNjMWMwZjgyZDUyYzk4Yzg1MGQxYmIyMTUw Yi4uMWQ2ZGU4M2I2MTY3MTBkYWUxYTE0MzM3NmM3MGI1NDhlNGE2OGYxNiAxMDA2NDQKLS0tIGEv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL0Rpc3BsYXlH TC5jcHAKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVy L2dsL0Rpc3BsYXlHTC5jcHAKQEAgLTMzLDYgKzMzLDE4IEBAIGVnbDo6RXJyb3IgRGlzcGxheUdM Ojppbml0aWFsaXplKGVnbDo6RGlzcGxheSAqZGlzcGxheSkKIAogdm9pZCBEaXNwbGF5R0w6OnRl cm1pbmF0ZSgpIHt9CiAKK2VnbDo6RXJyb3IgRGlzcGxheUdMOjpiaW5kVGhyZWFkKCkKK3sKKyAg ICBVTklNUExFTUVOVEVEKCk7CisgICAgcmV0dXJuIGVnbDo6Tm9FcnJvcigpOworfQorCitlZ2w6 OkVycm9yIERpc3BsYXlHTDo6cmVsZWFzZVRocmVhZCgpCit7CisgICAgVU5JTVBMRU1FTlRFRCgp OworICAgIHJldHVybiBlZ2w6Ok5vRXJyb3IoKTsKK30KKwogSW1hZ2VJbXBsICpEaXNwbGF5R0w6 OmNyZWF0ZUltYWdlKGNvbnN0IGVnbDo6SW1hZ2VTdGF0ZSAmc3RhdGUsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgY29uc3QgZ2w6OkNvbnRleHQgKmNvbnRleHQsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgRUdMZW51bSB0YXJnZXQsCkBAIC05NCw0ICsxMDYs NSBAQCBlZ2w6OkVycm9yIERpc3BsYXlHTDo6bWFrZUN1cnJlbnRTdXJmYWNlbGVzcyhnbDo6Q29u dGV4dCAqY29udGV4dCkKICAgICBVTklNUExFTUVOVEVEKCk7CiAgICAgcmV0dXJuIGVnbDo6Tm9F cnJvcigpOwogfQorCiB9ICAvLyBuYW1lc3BhY2UgcngKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGly ZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9EaXNwbGF5R0wuaCBiL1NvdXJj ZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9EaXNwbGF5R0wuaApp bmRleCBmMGM1NTNmYjA0NmU3MzllNTJhZmQzZWYwNWQyMmJjOTVkODIyNTM0Li4zZjQ0Y2JlOTMw MjU5NDJmZGRmYWVlYjIxYmZhZWI3OTlhMzc1ZDQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvRGlzcGxheUdMLmgKKysrIGIvU291 cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL0Rpc3BsYXlHTC5o CkBAIC0zMiw2ICszMiw4IEBAIGNsYXNzIERpc3BsYXlHTCA6IHB1YmxpYyBEaXNwbGF5SW1wbAog CiAgICAgZWdsOjpFcnJvciBpbml0aWFsaXplKGVnbDo6RGlzcGxheSAqZGlzcGxheSkgb3ZlcnJp ZGU7CiAgICAgdm9pZCB0ZXJtaW5hdGUoKSBvdmVycmlkZTsKKyAgICBlZ2w6OkVycm9yIGJpbmRU aHJlYWQoKSBvdmVycmlkZTsKKyAgICBlZ2w6OkVycm9yIHJlbGVhc2VUaHJlYWQoKSBvdmVycmlk ZTsKIAogICAgIEltYWdlSW1wbCAqY3JlYXRlSW1hZ2UoY29uc3QgZWdsOjpJbWFnZVN0YXRlICZz dGF0ZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGdsOjpDb250ZXh0ICpjb250 ZXh0LApkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3Jl bmRlcmVyL2dsL2NnbC9EaXNwbGF5Q0dMLmggYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMv bGliQU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wuaAppbmRleCA4OTVmNzcxMDdiYjA4 MzJjOTNhYzJiOGUxZjgyMWVmOWFiNThhNGI1Li5hOTZmOGVkM2YyYjc4ZDEwYjllNWQ0MzhhMWIx MWFjY2UyYTUwMTVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGli QU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wuaAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wuaApAQCAtMTAs NiArMTAsNyBAQAogI2RlZmluZSBMSUJBTkdMRV9SRU5ERVJFUl9HTF9DR0xfRElTUExBWUNHTF9I XwogCiAjaW5jbHVkZSA8dGhyZWFkPgorI2luY2x1ZGUgPHVub3JkZXJlZF9zZXQ+CiAKICNpbmNs dWRlICJsaWJBTkdMRS9yZW5kZXJlci9nbC9EaXNwbGF5R0wuaCIKIApAQCAtMzIsNiArMzMsOCBA QCBjbGFzcyBEaXNwbGF5Q0dMIDogcHVibGljIERpc3BsYXlHTAogCiAgICAgZWdsOjpFcnJvciBp bml0aWFsaXplKGVnbDo6RGlzcGxheSAqZGlzcGxheSkgb3ZlcnJpZGU7CiAgICAgdm9pZCB0ZXJt aW5hdGUoKSBvdmVycmlkZTsKKyAgICBlZ2w6OkVycm9yIGJpbmRUaHJlYWQoKSBvdmVycmlkZTsK KyAgICBlZ2w6OkVycm9yIHJlbGVhc2VUaHJlYWQoKSBvdmVycmlkZTsKIAogICAgIGVnbDo6RXJy b3IgbWFrZUN1cnJlbnQoZWdsOjpTdXJmYWNlICpkcmF3U3VyZmFjZSwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGVnbDo6U3VyZmFjZSAqcmVhZFN1cmZhY2UsCkBAIC0xMDMsNyArMTA2LDcg QEAgY2xhc3MgRGlzcGxheUNHTCA6IHB1YmxpYyBEaXNwbGF5R0wKIAogICAgIGVnbDo6RGlzcGxh eSAqbUVHTERpc3BsYXk7CiAgICAgQ0dMQ29udGV4dE9iaiBtQ29udGV4dDsKLSAgICBzdGQ6OnVu b3JkZXJlZF9tYXA8c3RkOjp0aHJlYWQ6OmlkLCBDR0xDb250ZXh0T2JqPiBtQ3VycmVudENvbnRl eHRzOworICAgIHN0ZDo6dW5vcmRlcmVkX3NldDxzdGQ6OnRocmVhZDo6aWQ+IG1UaHJlYWRzV2l0 aEN1cnJlbnRDb250ZXh0OwogICAgIENHTFBpeGVsRm9ybWF0T2JqIG1QaXhlbEZvcm1hdDsKICAg ICBib29sIG1TdXBwb3J0c0dQVVN3aXRjaGluZzsKICAgICB1aW50NjRfdCBtQ3VycmVudEdQVUlE OwpAQCAtMTEzLDYgKzExNiw3IEBAIGNsYXNzIERpc3BsYXlDR0wgOiBwdWJsaWMgRGlzcGxheUdM CiAgICAgLy8gaXMgdW5yZWYnZCBmb3IgdGhlIGxhc3QgdGltZSwgdGhpcyBpcyBzZXQgdG8gdGhl IHRpbWUgb2YgdGhhdCBsYXN0IHVucmVmLiBJZiBpdCBpc24ndAogICAgIC8vIGFjdGl2YXRlZCBh Z2FpbiBpbiAxMCBzZWNvbmRzLCB0aGUgZGlzY3JldGUgR1BVIHBpeGVsIGZvcm1hdCBpcyBkZWxl dGVkLgogICAgIGRvdWJsZSBtTGFzdERpc2NyZXRlR1BVVW5yZWZUaW1lOworICAgIGJvb2wgbURl dmljZUNvbnRleHRJc1ZvbGF0aWxlID0gZmFsc2U7CiB9OwogCiB9ICAvLyBuYW1lc3BhY2UgcngK ZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJl ci9nbC9jZ2wvRGlzcGxheUNHTC5tbSBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJB TkdMRS9yZW5kZXJlci9nbC9jZ2wvRGlzcGxheUNHTC5tbQppbmRleCBlN2NjMmJhMmZhNjNjNmEz MzYxYjA1N2Y4ZGYxNzgyODYxMzc5ZGYxLi42ZjY1NzExMzM4MDM0YjBjNzI4YTliNTQ3NTZjNzgw NTI0OGM0ZDRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5H TEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wubW0KKysrIGIvU291cmNlL1RoaXJkUGFydHkv QU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2NnbC9EaXNwbGF5Q0dMLm1tCkBAIC0xODQs OSArMTg0LDExIEBAIGVnbDo6RXJyb3IgRGlzcGxheUNHTDo6aW5pdGlhbGl6ZShlZ2w6OkRpc3Bs YXkgKmRpc3BsYXkpCiAgICAgICAgIG1DdXJyZW50R1BVSUQgPSBhbmdsZTo6R2V0R3B1SURGcm9t RGlzcGxheUlEKGtDR0RpcmVjdE1haW5EaXNwbGF5KTsKICAgICB9CiAKLSAgICBDR0xTZXRDdXJy ZW50Q29udGV4dChtQ29udGV4dCk7Ci0KLSAgICBtQ3VycmVudENvbnRleHRzW3N0ZDo6dGhpc190 aHJlYWQ6OmdldF9pZCgpXSA9IG1Db250ZXh0OworICAgIGlmIChDR0xTZXRDdXJyZW50Q29udGV4 dChtQ29udGV4dCkgIT0ga0NHTE5vRXJyb3IpCisgICAgeworICAgICAgICByZXR1cm4gZWdsOjpF Z2xOb3RJbml0aWFsaXplZCgpIDw8ICJDb3VsZCBub3QgbWFrZSB0aGUgQ0dMIGNvbnRleHQgY3Vy cmVudC4iOworICAgIH0KKyAgICBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5pbnNlcnQoc3Rk Ojp0aGlzX3RocmVhZDo6Z2V0X2lkKCkpOwogCiAgICAgLy8gVGhlcmUgaXMgbm8gZXF1aXZhbGVu dCBnZXRQcm9jQWRkcmVzcyBpbiBDR0wgc28gd2Ugb3BlbiB0aGUgZHlsaWIgZGlyZWN0bHkKICAg ICB2b2lkICpoYW5kbGUgPSBkbG9wZW4oa0RlZmF1bHRPcGVuR0xEeWxpYk5hbWUsIFJUTERfTk9X KTsKQEAgLTIxMCw2ICsyMTIsOSBAQCBlZ2w6OkVycm9yIERpc3BsYXlDR0w6OmluaXRpYWxpemUo ZWdsOjpEaXNwbGF5ICpkaXNwbGF5KQogICAgICAgICByZXR1cm4gZWdsOjpFZ2xOb3RJbml0aWFs aXplZCgpIDw8ICJPcGVuR0wgRVMgMi4wIGlzIG5vdCBzdXBwb3J0YWJsZS4iOwogICAgIH0KIAor ICAgIGF1dG8gJmF0dHJpYnV0ZXMgPSBkaXNwbGF5LT5nZXRBdHRyaWJ1dGVNYXAoKTsKKyAgICBt RGV2aWNlQ29udGV4dElzVm9sYXRpbGUgPSBhdHRyaWJ1dGVzLmdldChFR0xfUExBVEZPUk1fQU5H TEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfQ0dMX0FOR0xFLCBHTF9GQUxTRSk7CisKICAgICBy ZXR1cm4gRGlzcGxheUdMOjppbml0aWFsaXplKGRpc3BsYXkpOwogfQogCkBAIC0yMjMsMTIgKzIy OCwxMiBAQCB2b2lkIERpc3BsYXlDR0w6OnRlcm1pbmF0ZSgpCiAgICAgICAgIENHTERlc3Ryb3lQ aXhlbEZvcm1hdChtUGl4ZWxGb3JtYXQpOwogICAgICAgICBtUGl4ZWxGb3JtYXQgPSBudWxscHRy OwogICAgIH0KLSAgICBtQ3VycmVudENvbnRleHRzLmNsZWFyKCk7CiAgICAgaWYgKG1Db250ZXh0 ICE9IG51bGxwdHIpCiAgICAgewogICAgICAgICBDR0xTZXRDdXJyZW50Q29udGV4dChudWxscHRy KTsKICAgICAgICAgQ0dMRGVzdHJveUNvbnRleHQobUNvbnRleHQpOwogICAgICAgICBtQ29udGV4 dCA9IG51bGxwdHI7CisgICAgICAgIG1UaHJlYWRzV2l0aEN1cnJlbnRDb250ZXh0LmNsZWFyKCk7 CiAgICAgfQogICAgIGlmIChtRGlzY3JldGVHUFVQaXhlbEZvcm1hdCAhPSBudWxscHRyKQogICAg IHsKQEAgLTIzOCwyMyArMjQzLDQxIEBAIHZvaWQgRGlzcGxheUNHTDo6dGVybWluYXRlKCkKICAg ICB9CiB9CiAKLWVnbDo6RXJyb3IgRGlzcGxheUNHTDo6bWFrZUN1cnJlbnQoZWdsOjpTdXJmYWNl ICpkcmF3U3VyZmFjZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWdsOjpT dXJmYWNlICpyZWFkU3VyZmFjZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Z2w6OkNvbnRleHQgKmNvbnRleHQpCitlZ2w6OkVycm9yIERpc3BsYXlDR0w6OmJpbmRUaHJlYWQo KQogewotICAgIGNoZWNrRGlzY3JldGVHUFVTdGF0dXMoKTsKLSAgICAvLyBJZiB0aGUgdGhyZWFk IHRoYXQncyBjYWxsaW5nIG1ha2VDdXJyZW50IGRvZXMgbm90IGhhdmUgdGhlIGNvcnJlY3QKLSAg ICAvLyBjb250ZXh0IGN1cnJlbnQgKGVpdGhlciBtQ29udGV4dCBvciAwKSwgd2UgbmVlZCB0byBz ZXQgaXQgY3VycmVudC4KLSAgICBDR0xDb250ZXh0T2JqIG5ld0NvbnRleHQgPSAwOwotICAgIGlm IChjb250ZXh0KQorICAgIEFTU0VSVChtQ29udGV4dCk7CisgICAgYXV0byB0aHJlYWRJZCA9IHN0 ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgpOworICAgIGlmIChtRGV2aWNlQ29udGV4dElzVm9sYXRp bGUgfHwgbVRocmVhZHNXaXRoQ3VycmVudENvbnRleHQuZmluZCh0aHJlYWRJZCkgPT0gbVRocmVh ZHNXaXRoQ3VycmVudENvbnRleHQuZW5kKCkpCiAgICAgewotICAgICAgICBuZXdDb250ZXh0ID0g bUNvbnRleHQ7CisgICAgICAgIGlmIChDR0xTZXRDdXJyZW50Q29udGV4dChtQ29udGV4dCkgIT0g a0NHTE5vRXJyb3IpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBlZ2w6OkVnbEJhZEFs bG9jKCkgPDwgIkNvdWxkIG5vdCBtYWtlIGRldmljZSBDR0wgY29udGV4dCBjdXJyZW50LiI7Cisg ICAgICAgIH0KKyAgICAgICAgbVRocmVhZHNXaXRoQ3VycmVudENvbnRleHQuaW5zZXJ0KHRocmVh ZElkKTsKICAgICB9Ci0gICAgaWYgKG5ld0NvbnRleHQgIT0gbUN1cnJlbnRDb250ZXh0c1tzdGQ6 OnRoaXNfdGhyZWFkOjpnZXRfaWQoKV0pCisgICAgcmV0dXJuIGVnbDo6Tm9FcnJvcigpOworfQor CitlZ2w6OkVycm9yIERpc3BsYXlDR0w6OnJlbGVhc2VUaHJlYWQoKQoreworICAgIEFTU0VSVCht Q29udGV4dCk7CisgICAgYXV0byB0aHJlYWRJZCA9IHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgp OworICAgIGlmIChtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5maW5kKHRocmVhZElkKSAhPSBt VGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5lbmQoKSkKICAgICB7Ci0gICAgICAgIENHTFNldEN1 cnJlbnRDb250ZXh0KG5ld0NvbnRleHQpOwotICAgICAgICBtQ3VycmVudENvbnRleHRzW3N0ZDo6 dGhpc190aHJlYWQ6OmdldF9pZCgpXSA9IG5ld0NvbnRleHQ7CisgICAgICAgIGlmIChDR0xTZXRD dXJyZW50Q29udGV4dChudWxscHRyKSAhPSBrQ0dMTm9FcnJvcikKKyAgICAgICAgeworICAgICAg ICAgICAgcmV0dXJuIGVnbDo6RWdsQmFkQWxsb2MoKSA8PCAiQ291bGQgbm90IHJlbGVhc2UgZGV2 aWNlIENHTCBjb250ZXh0LiI7CisgICAgICAgIH0KKyAgICAgICAgbVRocmVhZHNXaXRoQ3VycmVu dENvbnRleHQuZXJhc2UodGhyZWFkSWQpOwogICAgIH0KKyAgICByZXR1cm4gZWdsOjpOb0Vycm9y KCk7Cit9CisKK2VnbDo6RXJyb3IgRGlzcGxheUNHTDo6bWFrZUN1cnJlbnQoZWdsOjpTdXJmYWNl ICpkcmF3U3VyZmFjZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWdsOjpT dXJmYWNlICpyZWFkU3VyZmFjZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Z2w6OkNvbnRleHQgKmNvbnRleHQpCit7CisgICAgY2hlY2tEaXNjcmV0ZUdQVVN0YXR1cygpOwog ICAgIHJldHVybiBEaXNwbGF5R0w6Om1ha2VDdXJyZW50KGRyYXdTdXJmYWNlLCByZWFkU3VyZmFj ZSwgY29udGV4dCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3Ny Yy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmggYi9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oCmlu ZGV4IGE1MzY2ZTkxNmU5Yzc1NjA5ZjMxMDEzMTJmZWI2MGYwNTdjMTExMTYuLmE3NmY0NWQ3ZWVm YWJmZTY1MzQwYjViMzQ2NDgxYzgwOGI0MjNkODcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBh cnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmgKKysr IGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2VhZ2wv RGlzcGxheUVBR0wuaApAQCAtMTMsNiArMTMsOSBAQAogCiAjaWYgKGRlZmluZWQoQU5HTEVfUExB VEZPUk1fSU9TKSAmJiAhZGVmaW5lZChBTkdMRV9QTEFURk9STV9NQUNDQVRBTFlTVCkpIHx8IChk ZWZpbmVkKEFOR0xFX1BMQVRGT1JNX01BQ0NBVEFMWVNUKSAmJiBkZWZpbmVkKEFOR0xFX0NQVV9B Uk02NCkpCiAKKyNpbmNsdWRlIDx0aHJlYWQ+CisjaW5jbHVkZSA8dW5vcmRlcmVkX3NldD4KKwog I2luY2x1ZGUgImxpYkFOR0xFL3JlbmRlcmVyL2dsL0Rpc3BsYXlHTC5oIgogCiAjaWZkZWYgX19P QkpDX18KQEAgLTM1LDYgKzM4LDggQEAgY2xhc3MgRGlzcGxheUVBR0wgOiBwdWJsaWMgRGlzcGxh eUdMCiAKICAgICBlZ2w6OkVycm9yIGluaXRpYWxpemUoZWdsOjpEaXNwbGF5ICpkaXNwbGF5KSBv dmVycmlkZTsKICAgICB2b2lkIHRlcm1pbmF0ZSgpIG92ZXJyaWRlOworICAgIGVnbDo6RXJyb3Ig YmluZFRocmVhZCgpIG92ZXJyaWRlOworICAgIGVnbDo6RXJyb3IgcmVsZWFzZVRocmVhZCgpIG92 ZXJyaWRlOwogCiAgICAgU3VyZmFjZUltcGwgKmNyZWF0ZVdpbmRvd1N1cmZhY2UoY29uc3QgZWds OjpTdXJmYWNlU3RhdGUgJnN0YXRlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIEVHTE5hdGl2ZVdpbmRvd1R5cGUgd2luZG93LApAQCAtOTMsNiArOTgsOCBAQCBjbGFzcyBE aXNwbGF5RUFHTCA6IHB1YmxpYyBEaXNwbGF5R0wKIAogICAgIGVnbDo6RGlzcGxheSAqbUVHTERp c3BsYXk7CiAgICAgRUFHTENvbnRleHRPYmogbUNvbnRleHQ7CisgICAgc3RkOjp1bm9yZGVyZWRf c2V0PHN0ZDo6dGhyZWFkOjppZD4gbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQ7CisgICAgYm9v bCBtRGV2aWNlQ29udGV4dElzVm9sYXRpbGUgPSBmYWxzZTsKIH07CiAKIH0gIC8vIG5hbWVzcGFj ZSByeApkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3Jl bmRlcmVyL2dsL2VhZ2wvRGlzcGxheUVBR0wubW0gYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9z cmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQppbmRleCA5NGY0ZWU1 Y2NmYzkyNmM0MGE0MWU0ODhlOWNjZTY2OTM4ZDQzY2FjLi42OGYzNTc0NDI1M2FhNWRkOWEyMTRj NWQ1NWEzYjRkOWEyMjY2NjRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9z cmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQorKysgYi9Tb3VyY2Uv VGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFH TC5tbQpAQCAtNzUsNyArNzUsMTEgQEAgZWdsOjpFcnJvciBEaXNwbGF5RUFHTDo6aW5pdGlhbGl6 ZShlZ2w6OkRpc3BsYXkgKmRpc3BsYXkpCiAgICAgewogICAgICAgICByZXR1cm4gZWdsOjpFZ2xO b3RJbml0aWFsaXplZCgpIDw8ICJDb3VsZCBub3QgY3JlYXRlIHRoZSBFQUdMIGNvbnRleHQuIjsK ICAgICB9Ci0gICAgW2dldEVBR0xDb250ZXh0Q2xhc3MoKSBzZXRDdXJyZW50Q29udGV4dDptQ29u dGV4dF07CisKKyAgICBpZiAoIVtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRl eHQ6bUNvbnRleHRdKSB7CisgICAgICAgIHJldHVybiBlZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkg PDwgIkNvdWxkIHNldCB0aGUgRUFHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICB9CisgICAgbVRo cmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuaW5zZXJ0KHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgp KTsKIAogICAgIC8vIFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZ2V0UHJvY0FkZHJlc3MgaW4gRUFH TCBzbyB3ZSBvcGVuIHRoZSBkeWxpYiBkaXJlY3RseQogICAgIHZvaWQgKmhhbmRsZSA9IGRsb3Bl bihrT3BlbkdMRVNEeWxpYk5hbWUsIFJUTERfTk9XKTsKQEAgLTk1LDYgKzk5LDkgQEAgZWdsOjpF cnJvciBEaXNwbGF5RUFHTDo6aW5pdGlhbGl6ZShlZ2w6OkRpc3BsYXkgKmRpc3BsYXkpCiAgICAg ICAgIHJldHVybiBlZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIk9wZW5HTCBFUyAyLjAgaXMg bm90IHN1cHBvcnRhYmxlLiI7CiAgICAgfQogCisgICAgYXV0byAmYXR0cmlidXRlcyA9IGRpc3Bs YXktPmdldEF0dHJpYnV0ZU1hcCgpOworICAgIG1EZXZpY2VDb250ZXh0SXNWb2xhdGlsZSA9IGF0 dHJpYnV0ZXMuZ2V0KEVHTF9QTEFURk9STV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElMRV9F QUdMX0FOR0xFLCBHTF9GQUxTRSk7CisKICAgICByZXR1cm4gRGlzcGxheUdMOjppbml0aWFsaXpl KGRpc3BsYXkpOwogfQogCkBAIC0xMDgsNyArMTE1LDM2IEBAIHZvaWQgRGlzcGxheUVBR0w6OnRl cm1pbmF0ZSgpCiAgICAgICAgIFtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRl eHQ6bmlsXTsKICAgICAgICAgW21Db250ZXh0IHJlbGVhc2VdOwogICAgICAgICBtQ29udGV4dCA9 IG51bGxwdHI7CisgICAgICAgIG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50LmNsZWFyKCk7Cisg ICAgfQorfQorCitlZ2w6OkVycm9yIERpc3BsYXlFQUdMOjpiaW5kVGhyZWFkKCkKK3sKKyAgICBh dXRvIHRocmVhZElkID0gc3RkOjp0aGlzX3RocmVhZDo6Z2V0X2lkKCk7CisgICAgaWYgKG1EZXZp Y2VDb250ZXh0SXNWb2xhdGlsZSB8fCBtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5maW5kKHRo cmVhZElkKSA9PSBtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5lbmQoKSkKKyAgICB7CisgICAg ICAgIGlmICghW2dldEVBR0xDb250ZXh0Q2xhc3MoKSBzZXRDdXJyZW50Q29udGV4dDptQ29udGV4 dF0pCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBlZ2w6OkVnbEJhZEFsbG9jKCkgPDwg IkNvdWxkIG5vdCBtYWtlIGRldmljZSBFQUdMIGNvbnRleHQgY3VycmVudC4iOworICAgICAgICB9 CisgICAgICAgIG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50Lmluc2VydCh0aHJlYWRJZCk7CiAg ICAgfQorICAgIHJldHVybiBlZ2w6Ok5vRXJyb3IoKTsKK30KKworZWdsOjpFcnJvciBEaXNwbGF5 RUFHTDo6cmVsZWFzZVRocmVhZCgpCit7CisgICAgYXV0byB0aHJlYWRJZCA9IHN0ZDo6dGhpc190 aHJlYWQ6OmdldF9pZCgpOworICAgIGlmIChtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5maW5k KHRocmVhZElkKSAhPSBtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5lbmQoKSkKKyAgICB7Cisg ICAgICAgIGlmICghW2dldEVBR0xDb250ZXh0Q2xhc3MoKSBzZXRDdXJyZW50Q29udGV4dDpuaWxd KQorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gZWdsOjpFZ2xCYWRBbGxvYygpIDw8ICJD b3VsZCBub3QgcmVsZWFzZSBkZXZpY2UgRUFHTCBjb250ZXh0LiI7CisgICAgICAgIH0KKyAgICAg ICAgbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZXJhc2UodGhyZWFkSWQpOworICAgIH0KKyAg ICByZXR1cm4gZWdsOjpOb0Vycm9yKCk7CiB9CiAKIFN1cmZhY2VJbXBsICpEaXNwbGF5RUFHTDo6 Y3JlYXRlV2luZG93U3VyZmFjZShjb25zdCBlZ2w6OlN1cmZhY2VTdGF0ZSAmc3RhdGUsCmRpZmYg LS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wv ZWFnbC9FQUdMRnVuY3Rpb25zLmggYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5H TEUvcmVuZGVyZXIvZ2wvZWFnbC9FQUdMRnVuY3Rpb25zLmgKaW5kZXggY2QzNjE5NWI5OTU4NmM5 ZmVhNGVjOGM2NmZhNWQwYjEzZWFkNzE5YS4uNDE2YTVmZTQwYzZiOTg5OWJiYTUyNzNjNmUzMTUz YTYyYWY2NjZiNiAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFO R0xFL3JlbmRlcmVyL2dsL2VhZ2wvRUFHTEZ1bmN0aW9ucy5oCisrKyBiL1NvdXJjZS9UaGlyZFBh cnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0VBR0xGdW5jdGlvbnMuaApA QCAtMTEsNiArMTEsNyBAQAogCiAjaW5jbHVkZSAiY29tbW9uL3BsYXRmb3JtLmgiCiAKKwogI2lm IChkZWZpbmVkKEFOR0xFX1BMQVRGT1JNX0lPUykgJiYgIWRlZmluZWQoQU5HTEVfUExBVEZPUk1f TUFDQ0FUQUxZU1QpKSB8fCAoZGVmaW5lZChBTkdMRV9QTEFURk9STV9NQUNDQVRBTFlTVCkgJiYg ZGVmaW5lZChBTkdMRV9DUFVfQVJNNjQpKQogCiAjaW1wb3J0IDxPcGVuR0xFUy9FQUdMLmg+CkBA IC0yNSw0ICsyNiw0IEBAIFNPRlRfTElOS19DTEFTU19IRUFERVIoRUFHTENvbnRleHQpCiAKICNl bmRpZiAvLyAoZGVmaW5lZChBTkdMRV9QTEFURk9STV9JT1MpICYmICFkZWZpbmVkKEFOR0xFX1BM QVRGT1JNX01BQ0NBVEFMWVNUKSkgfHwgKGRlZmluZWQoQU5HTEVfUExBVEZPUk1fTUFDQ0FUQUxZ U1QpICYmIGRlZmluZWQoQU5HTEVfQ1BVX0FSTTY0KSkKIAotI2VuZGlmIC8vIENHTF9GVU5DVElP TlNfSF8KKyNlbmRpZiAvLyBFQUdMX0ZVTkNUSU9OU19IXwpkaWZmIC0tZ2l0IGEvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvc3JjL2xpYkdMRVN2Mi9lbnRyeV9wb2ludHNfZWdsLmNwcCBiL1NvdXJj ZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJHTEVTdjIvZW50cnlfcG9pbnRzX2VnbC5jcHAKaW5k ZXggZmQwZmY4Njg3Y2ZiMDk4OTUxMGMzMzE0ZWRlOGIyZDk1NDdiMDQ0My4uZDQzOTFiNDZlNDRi MGY4Y2YwYTkwMWQyMmYwNWUwYzYzMTA2MzA5ZSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvc3JjL2xpYkdMRVN2Mi9lbnRyeV9wb2ludHNfZWdsLmNwcAorKysgYi9Tb3VyY2Uv VGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliR0xFU3YyL2VudHJ5X3BvaW50c19lZ2wuY3BwCkBAIC0x MDUsNyArMTA1LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfVGVybWluYXRlKEVHTERp c3BsYXkgZHB5KQogICAgIGVnbDo6RGlzcGxheSAqZGlzcGxheSA9IHN0YXRpY19jYXN0PGVnbDo6 RGlzcGxheSAqPihkcHkpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRh dGVUZXJtaW5hdGUoZGlzcGxheSksICJlZ2xUZXJtaW5hdGUiLAogICAgICAgICAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwotCisgICAgQU5H TEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xUZXJt aW5hdGUiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBFR0xfRkFMU0UpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxh eS0+bWFrZUN1cnJlbnQodGhyZWFkLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyKSwKICAgICAg ICAgICAgICAgICAgICAgICAgICAiZWdsVGVybWluYXRlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlz cGxheSksIEVHTF9GQUxTRSk7CiAgICAgU2V0Q29udGV4dEN1cnJlbnQodGhyZWFkLCBudWxscHRy KTsKQEAgLTEyNyw2ICsxMjgsOCBAQCBjb25zdCBjaGFyICpFR0xBUElFTlRSWSBFR0xfUXVlcnlT dHJpbmcoRUdMRGlzcGxheSBkcHksIEVHTGludCBuYW1lKQogICAgIHsKICAgICAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZURpc3BsYXkoZGlzcGxheSksICJlZ2xRdWVy eVN0cmluZyIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpLCBudWxscHRyKTsKKyAgICAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xRdWVyeVN0cmluZyIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBudWxscHRyKTsKICAg ICB9CiAKICAgICBjb25zdCBjaGFyICpyZXN1bHQ7CkBAIC0yNTUsNiArMjU4LDggQEAgRUdMU3Vy ZmFjZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlV2luZG93U3VyZmFjZShFR0xEaXNwbGF5IGRweSwK ICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsCiAgICAgICAgICAgICAgICAgICAgICAg ICAgVmFsaWRhdGVDcmVhdGVXaW5kb3dTdXJmYWNlKGRpc3BsYXksIGNvbmZpZ3VyYXRpb24sIHdp biwgYXR0cmlidXRlcyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVdpbmRv d1N1cmZhY2UiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwor ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAi ZWdsQ3JlYXRlV2luZG93U3VyZmFjZSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKIAogICAgIGVnbDo6U3VyZmFj ZSAqc3VyZmFjZSA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLApA QCAtMjgxLDcgKzI4Niw4IEBAIEVHTFN1cmZhY2UgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVBidWZm ZXJTdXJmYWNlKEVHTERpc3BsYXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhy ZWFkLCBWYWxpZGF0ZUNyZWF0ZVBidWZmZXJTdXJmYWNlKGRpc3BsYXksIGNvbmZpZ3VyYXRpb24s IGF0dHJpYnV0ZXMpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVQYnVmZmVy U3VyZmFjZSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7Ci0K KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwg ImVnbENyZWF0ZVBidWZmZXJTdXJmYWNlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXRE aXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIGVnbDo6U3VyZmFj ZSAqc3VyZmFjZSA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBk aXNwbGF5LT5jcmVhdGVQYnVmZmVyU3VyZmFjZShjb25maWd1cmF0aW9uLCBhdHRyaWJ1dGVzLCAm c3VyZmFjZSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVBidWZmZXJTdXJm YWNlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKQEAgLTMx MCw3ICszMTYsOCBAQCBFR0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQaXhtYXBTdXJm YWNlKEVHTERpc3BsYXkgZHB5LAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwKICAg ICAgICAgICAgICAgICAgICAgICAgICBWYWxpZGF0ZUNyZWF0ZVBpeG1hcFN1cmZhY2UoZGlzcGxh eSwgY29uZmlndXJhdGlvbiwgcGl4bWFwLCBhdHRyaWJ1dGVzKSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAiZWdsQ3JlYXRlUGl4bWFwU3VyZmFjZSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBFR0xfTk9fU1VSRkFDRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs IGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbENyZWF0ZVBpeG1hcFN1cmZhY2UiLAorICAgICAg ICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VS RkFDRSk7CiAgICAgZWdsOjpTdXJmYWNlICpzdXJmYWNlID0gbnVsbHB0cjsKICAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgZGlzcGxheS0+ Y3JlYXRlUGl4bWFwU3VyZmFjZShjb25maWd1cmF0aW9uLCBwaXhtYXAsIGF0dHJpYnV0ZXMsICZz dXJmYWNlKSwKQEAgLTMzMiw3ICszMzksOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9E ZXN0cm95U3VyZmFjZShFR0xEaXNwbGF5IGRweSwgRUdMU3VyZmFjZSBzdXJmYWNlKQogCiAgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZURlc3Ryb3lTdXJmYWNlKGRpc3Bs YXksIGVnbFN1cmZhY2UsIHN1cmZhY2UpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xE ZXN0cm95U3VyZmFjZSIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBF R0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5i aW5kVGhyZWFkKCksICJlZ2xEZXN0cm95U3VyZmFjZSIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgQU5HTEVfRUdM X1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5kZXN0cm95U3VyZmFjZShlZ2xTdXJmYWNlKSwg ImVnbERlc3Ryb3lTdXJmYWNlIiwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdXJmYWNl SWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKIApAQCAtMzUyLDEyICsz NjAsMTMgQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfUXVlcnlTdXJmYWNlKEVHTERpc3Bs YXkgZHB5LAogICAgICAgICAgICAgICAgKHVpbnRwdHJfdClkcHksICh1aW50cHRyX3Qpc3VyZmFj ZSwgYXR0cmlidXRlLCAodWludHB0cl90KXZhbHVlKTsKICAgICBUaHJlYWQgKnRocmVhZCA9IGVn bDo6R2V0Q3VycmVudFRocmVhZCgpOwogCi0gICAgY29uc3QgZWdsOjpEaXNwbGF5ICpkaXNwbGF5 ID0gc3RhdGljX2Nhc3Q8Y29uc3QgZWdsOjpEaXNwbGF5ICo+KGRweSk7CisgICAgZWdsOjpEaXNw bGF5ICpkaXNwbGF5ID0gc3RhdGljX2Nhc3Q8ZWdsOjpEaXNwbGF5ICo+KGRweSk7CiAgICAgY29u c3QgU3VyZmFjZSAqZWdsU3VyZmFjZSAgID0gc3RhdGljX2Nhc3Q8Y29uc3QgU3VyZmFjZSAqPihz dXJmYWNlKTsKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVRdWVy eVN1cmZhY2UoZGlzcGxheSwgZWdsU3VyZmFjZSwgYXR0cmlidXRlLCB2YWx1ZSksCiAgICAgICAg ICAgICAgICAgICAgICAgICAgImVnbFF1ZXJ5U3VyZmFjZSIsIEdldFN1cmZhY2VJZlZhbGlkKGRp c3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRV Uk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xRdWVyeVN1cmZhY2UiLAorICAg ICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFM U0UpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgUXVlcnlTdXJmYWNlQXR0cmli KGRpc3BsYXksIGVnbFN1cmZhY2UsIGF0dHJpYnV0ZSwgdmFsdWUpLAogICAgICAgICAgICAgICAg ICAgICAgICAgICJlZ2xRdWVyeVN1cmZhY2UiLCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBl Z2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKIApAQCAtMzg1LDcgKzM5NCw4IEBAIEVHTENvbnRleHQg RUdMQVBJRU5UUlkgRUdMX0NyZWF0ZUNvbnRleHQoRUdMRGlzcGxheSBkcHksCiAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAgICAgICAgICAgICAgICAgICAgIFZhbGlkYXRl Q3JlYXRlQ29udGV4dChkaXNwbGF5LCBjb25maWd1cmF0aW9uLCBzaGFyZWRHTENvbnRleHQsIGF0 dHJpYnV0ZXMpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVDb250ZXh0Iiwg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19DT05URVhUKTsKLQorICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsQ3JlYXRl Q29udGV4dCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlz cGxheSksIEVHTF9OT19DT05URVhUKTsKICAgICBnbDo6Q29udGV4dCAqY29udGV4dCA9IG51bGxw dHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAgICAgICAgICAgICAg ICAgICAgIGRpc3BsYXktPmNyZWF0ZUNvbnRleHQoY29uZmlndXJhdGlvbiwgc2hhcmVkR0xDb250 ZXh0LCB0aHJlYWQtPmdldEFQSSgpLApAQCAtNDA4LDcgKzQxOCw4IEBAIEVHTEJvb2xlYW4gRUdM QVBJRU5UUlkgRUdMX0Rlc3Ryb3lDb250ZXh0KEVHTERpc3BsYXkgZHB5LCBFR0xDb250ZXh0IGN0 eCkKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVEZXN0cm95Q29u dGV4dChkaXNwbGF5LCBjb250ZXh0LCBjdHgpLCAiZWdsRGVzdHJveUNvbnRleHQiLAogICAgICAg ICAgICAgICAgICAgICAgICAgIEdldENvbnRleHRJZlZhbGlkKGRpc3BsYXksIGNvbnRleHQpLCBF R0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5i aW5kVGhyZWFkKCksICJlZ2xEZXN0cm95Q29udGV4dCIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgYm9vbCBjb250 ZXh0V2FzQ3VycmVudCA9IGNvbnRleHQgPT0gdGhyZWFkLT5nZXRDb250ZXh0KCk7CiAKICAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmRlc3Ryb3lDb250ZXh0KHRocmVh ZCwgY29udGV4dCksICJlZ2xEZXN0cm95Q29udGV4dCIsCkBAIC00NDMsNyArNDU0LDggQEAgRUdM Qm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfTWFrZUN1cnJlbnQoRUdMRGlzcGxheSBkcHksCiAKICAg ICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlTWFrZUN1cnJlbnQoZGlzcGxh eSwgZHJhd1N1cmZhY2UsIHJlYWRTdXJmYWNlLCBjb250ZXh0KSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAiZWdsTWFrZUN1cnJlbnQiLCBHZXRDb250ZXh0SWZWYWxpZChkaXNwbGF5LCBjb250 ZXh0KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlz cGxheS0+YmluZFRocmVhZCgpLCAiZWdsTWFrZUN1cnJlbnQiLAorICAgICAgICAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIFN1cmZh Y2UgKnByZXZpb3VzRHJhdyAgICAgICAgPSB0aHJlYWQtPmdldEN1cnJlbnREcmF3U3VyZmFjZSgp OwogICAgIFN1cmZhY2UgKnByZXZpb3VzUmVhZCAgICAgICAgPSB0aHJlYWQtPmdldEN1cnJlbnRS ZWFkU3VyZmFjZSgpOwogICAgIGdsOjpDb250ZXh0ICpwcmV2aW91c0NvbnRleHQgPSB0aHJlYWQt PmdldENvbnRleHQoKTsKQEAgLTUxNyw3ICs1MjksOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZ IEVHTF9RdWVyeUNvbnRleHQoRUdMRGlzcGxheSBkcHksCiAKICAgICBBTkdMRV9FR0xfVFJZX1JF VFVSTih0aHJlYWQsIFZhbGlkYXRlUXVlcnlDb250ZXh0KGRpc3BsYXksIGNvbnRleHQsIGF0dHJp YnV0ZSwgdmFsdWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xRdWVyeUNvbnRleHQi LCBHZXRDb250ZXh0SWZWYWxpZChkaXNwbGF5LCBjb250ZXh0KSwgRUdMX0ZBTFNFKTsKLQorICAg IEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWds UXVlcnlDb250ZXh0IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxp ZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBRdWVyeUNvbnRleHRBdHRyaWIoY29udGV4dCwg YXR0cmlidXRlLCB2YWx1ZSk7CiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKQEAgLTUzNCw2 ICs1NDcsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9XYWl0R0wodm9pZCkKIAogICAg IEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVEaXNwbGF5KGRpc3BsYXkpLCAi ZWdsV2FpdEdMIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksCiAgICAgICAgICAgICAgICAg ICAgICAgICAgRUdMX0ZBTFNFKTsKKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRp c3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFdhaXRHTCIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAKICAgICAvLyBlZ2xX YWl0R0wgbGlrZSBjYWxsaW5nIGVnbFdhaXRDbGllbnQgd2l0aCB0aGUgT3BlbkdMIEVTIEFQSSBi b3VuZC4gU2luY2Ugd2Ugb25seSBpbXBsZW1lbnQKICAgICAvLyBPcGVuR0wgRVMgd2UgY2FuIGRv IHRoZSBjYWxsIGRpcmVjdGx5LgpAQCAtNTU0LDYgKzU2OSw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJ RU5UUlkgRUdMX1dhaXROYXRpdmUoRUdMaW50IGVuZ2luZSkKIAogICAgIEFOR0xFX0VHTF9UUllf UkVUVVJOKHRocmVhZCwgVmFsaWRhdGVXYWl0TmF0aXZlKGRpc3BsYXksIGVuZ2luZSksICJlZ2xX YWl0TmF0aXZlIiwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRUaHJlYWRJZlZhbGlkKHRo cmVhZCksIEVHTF9GQUxTRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNw bGF5LT5iaW5kVGhyZWFkKCksICJlZ2xXYWl0TmF0aXZlIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKIAogICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+d2FpdE5hdGl2ZSh0aHJlYWQtPmdldENv bnRleHQoKSwgZW5naW5lKSwgImVnbFdhaXROYXRpdmUiLAogICAgICAgICAgICAgICAgICAgICAg ICAgIEdldFRocmVhZElmVmFsaWQodGhyZWFkKSwgRUdMX0ZBTFNFKTsKQEAgLTU3NCw2ICs1OTEs OCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9Td2FwQnVmZmVycyhFR0xEaXNwbGF5IGRw eSwgRUdMU3VyZmFjZSBzdXJmYWNlKQogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBWYWxpZGF0ZVN3YXBCdWZmZXJzKHRocmVhZCwgZGlzcGxheSwgZWdsU3VyZmFjZSksICJlZ2xT d2FwQnVmZmVycyIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3VyZmFjZUlmVmFsaWQo ZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9GQUxTRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRV Uk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xTd2FwQnVmZmVycyIsCisgICAg ICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxT RSk7CiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGVnbFN1cmZhY2UtPnN3YXAo dGhyZWFkLT5nZXRDb250ZXh0KCkpLCAiZWdsU3dhcEJ1ZmZlcnMiLAogICAgICAgICAgICAgICAg ICAgICAgICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFM U0UpOwpAQCAtNTk4LDcgKzYxNyw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0NvcHlC dWZmZXJzKEVHTERpc3BsYXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBWYWxpZGF0ZUNvcHlCdWZmZXJzKGRpc3BsYXksIGVnbFN1cmZhY2UpLCAiZWdsQ29weUJ1ZmZl cnMiLAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXks IGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhy ZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xDb3B5QnVmZmVycyIsCisgICAgICAgICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAg ICAgVU5JTVBMRU1FTlRFRCgpOyAgLy8gRklYTUUKIAogICAgIHRocmVhZC0+c2V0U3VjY2Vzcygp OwpAQCAtNjIyLDcgKzY0Miw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0JpbmRUZXhJ bWFnZShFR0xEaXNwbGF5IGRweSwgRUdMU3VyZmFjZSBzdXJmYWNlLCBFR0xpCiAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4oCiAgICAgICAgIHRocmVhZCwgVmFsaWRhdGVCaW5kVGV4SW1hZ2UoZGlz cGxheSwgZWdsU3VyZmFjZSwgc3VyZmFjZSwgYnVmZmVyLCBjb250ZXh0LCAmdGV4dHVyZU9iamVj dCksCiAgICAgICAgICJlZ2xCaW5kVGV4SW1hZ2UiLCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5 LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsQmluZFRleEltYWdlIiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsK ICAgICBpZiAoY29udGV4dCkKICAgICB7CiAgICAgICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgZWdsU3VyZmFjZS0+YmluZFRleEltYWdlKGNvbnRleHQsIHRleHR1cmVPYmplY3QsIGJ1 ZmZlciksCkBAIC02NTAsNyArNjcxLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfU3Vy ZmFjZUF0dHJpYihFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgVmFsaWRhdGVTdXJmYWNlQXR0cmliKGRpc3BsYXksIGVnbFN1cmZhY2UsIGF0dHJpYnV0 ZSwgdmFsdWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xTdXJmYWNlQXR0cmliIiwg R2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9GQUxTRSk7Ci0KKyAg ICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVn bFN1cmZhY2VBdHRyaWIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZh bGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIFNldFN1cmZhY2VBdHRyaWIoZWdsU3VyZmFj ZSwgYXR0cmlidXRlLCB2YWx1ZSk7CiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKQEAgLTY3 MSw2ICs2OTMsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9SZWxlYXNlVGV4SW1hZ2Uo RUdMRGlzcGxheSBkcHksIEVHTFN1cmZhY2Ugc3VyZmFjZSwgRQogICAgIEFOR0xFX0VHTF9UUllf UkVUVVJOKHRocmVhZCwgVmFsaWRhdGVSZWxlYXNlVGV4SW1hZ2UoZGlzcGxheSwgZWdsU3VyZmFj ZSwgc3VyZmFjZSwgYnVmZmVyKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsUmVsZWFz ZVRleEltYWdlIiwgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9G QUxTRSk7CiAKKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRU aHJlYWQoKSwgImVnbFJlbGVhc2VUZXhJbWFnZSIsCisgICAgICAgICAgICAgICAgICAgICAgICAg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZ2w6OlRleHR1cmUg KnRleHR1cmUgPSBlZ2xTdXJmYWNlLT5nZXRCb3VuZFRleHR1cmUoKTsKIAogICAgIGlmICh0ZXh0 dXJlKQpAQCAtNjk3LDcgKzcyMSw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N3YXBJ bnRlcnZhbChFR0xEaXNwbGF5IGRweSwgRUdMaW50IGludGVydmFsKQogCiAgICAgQU5HTEVfRUdM X1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVN3YXBJbnRlcnZhbChkaXNwbGF5LCBkcmF3X3N1 cmZhY2UsIGNvbnRleHQpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xTd2FwSW50ZXJ2 YWwiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsU3dhcElu dGVydmFsIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNw bGF5KSwgRUdMX0ZBTFNFKTsKICAgICBjb25zdCBlZ2w6OkNvbmZpZyAqc3VyZmFjZUNvbmZpZyA9 IGRyYXdfc3VyZmFjZS0+Z2V0Q29uZmlnKCk7CiAgICAgRUdMaW50IGNsYW1wZWRJbnRlcnZhbCAg ICAgICAgICAgPSBzdGQ6Om1pbihzdGQ6Om1heChpbnRlcnZhbCwgc3VyZmFjZUNvbmZpZy0+bWlu U3dhcEludGVydmFsKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3Vy ZmFjZUNvbmZpZy0+bWF4U3dhcEludGVydmFsKTsKQEAgLTc1OSw3ICs3ODQsOCBAQCBFR0xTdXJm YWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQYnVmZmVyRnJvbUNsaWVudEJ1ZmZlcihFR0xEaXNw bGF5IGRweSwKICAgICAgICAgdGhyZWFkLAogICAgICAgICBWYWxpZGF0ZUNyZWF0ZVBidWZmZXJG cm9tQ2xpZW50QnVmZmVyKGRpc3BsYXksIGJ1ZnR5cGUsIGJ1ZmZlciwgY29uZmlndXJhdGlvbiwg YXR0cmlidXRlcyksCiAgICAgICAgICJlZ2xDcmVhdGVQYnVmZmVyRnJvbUNsaWVudEJ1ZmZlciIs IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7Ci0KKyAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbENyZWF0 ZVBidWZmZXJGcm9tQ2xpZW50QnVmZmVyIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXRE aXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIGVnbDo6U3VyZmFj ZSAqc3VyZmFjZSA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAog ICAgICAgICAgICAgICAgICAgICAgICAgIGRpc3BsYXktPmNyZWF0ZVBidWZmZXJGcm9tQ2xpZW50 QnVmZmVyKGNvbmZpZ3VyYXRpb24sIGJ1ZnR5cGUsIGJ1ZmZlciwKQEAgLTc4MSwxNiArODA3LDE5 IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1JlbGVhc2VUaHJlYWQodm9pZCkKICAgICBn bDo6Q29udGV4dCAqcHJldmlvdXNDb250ZXh0ICA9IHRocmVhZC0+Z2V0Q29udGV4dCgpOwogICAg IGVnbDo6RGlzcGxheSAqcHJldmlvdXNEaXNwbGF5ID0gdGhyZWFkLT5nZXREaXNwbGF5KCk7CiAK LSAgICAvLyBPbmx5IGNhbGwgbWFrZUN1cnJlbnQgaWYgdGhlIGNvbnRleHQgb3Igc3VyZmFjZXMg aGF2ZSBjaGFuZ2VkLgotICAgIGlmIChwcmV2aW91c0RyYXcgIT0gRUdMX05PX1NVUkZBQ0UgfHwg cHJldmlvdXNSZWFkICE9IEVHTF9OT19TVVJGQUNFIHx8Ci0gICAgICAgIHByZXZpb3VzQ29udGV4 dCAhPSBFR0xfTk9fQ09OVEVYVCkKLSAgICB7Ci0gICAgICAgIGlmIChwcmV2aW91c0Rpc3BsYXkg IT0gRUdMX05PX0RJU1BMQVkpCisgICAgaWYgKHByZXZpb3VzRGlzcGxheSAhPSBFR0xfTk9fRElT UExBWSkgeworICAgICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIHByZXZpb3VzRGlz cGxheS0+YmluZFRocmVhZCgpLCAiZWdsUmVsZWFzZVRocmVhZCIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKHByZXZpb3VzRGlzcGxheSksIEVHTF9GQUxT RSk7CisgICAgICAgIC8vIE9ubHkgY2FsbCBtYWtlQ3VycmVudCBpZiB0aGUgY29udGV4dCBvciBz dXJmYWNlcyBoYXZlIGNoYW5nZWQuCisgICAgICAgIGlmIChwcmV2aW91c0RyYXcgIT0gRUdMX05P X1NVUkZBQ0UgfHwgcHJldmlvdXNSZWFkICE9IEVHTF9OT19TVVJGQUNFIHx8CisgICAgICAgICAg ICBwcmV2aW91c0NvbnRleHQgIT0gRUdMX05PX0NPTlRFWFQpCiAgICAgICAgIHsKICAgICAgICAg ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHByZXZpb3VzRGlzcGxheS0+bWFrZUN1cnJlbnQodGhyZWFkLCBudWxscHRyLCBu dWxscHRyLCBudWxscHRyKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xS ZWxlYXNlVGhyZWFkIiwgbnVsbHB0ciwgRUdMX0ZBTFNFKTsKICAgICAgICAgfQorICAgICAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIHByZXZpb3VzRGlzcGxheS0+cmVsZWFzZVRocmVh ZCgpLCAiZWdsUmVsZWFzZVRocmVhZCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdl dERpc3BsYXlJZlZhbGlkKHByZXZpb3VzRGlzcGxheSksIEVHTF9GQUxTRSk7CiAKICAgICAgICAg U2V0Q29udGV4dEN1cnJlbnQodGhyZWFkLCBudWxscHRyKTsKICAgICB9CkBAIC04MTAsNyArODM5 LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfV2FpdENsaWVudCh2b2lkKQogCiAgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZURpc3BsYXkoZGlzcGxheSksICJl Z2xXYWl0Q2xpZW50IiwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRDb250ZXh0SWZWYWxp ZChkaXNwbGF5LCBjb250ZXh0KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsV2FpdENsaWVudCIsCisgICAg ICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxT RSk7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT53YWl0Q2xpZW50 KGNvbnRleHQpLCAiZWdsV2FpdENsaWVudCIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0 Q29udGV4dElmVmFsaWQoZGlzcGxheSwgY29udGV4dCksIEVHTF9GQUxTRSk7CiAKQEAgLTg0OSw3 ICs4NzksOCBAQCBFR0xTeW5jIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVTeW5jKEVHTERpc3BsYXkg ZHB5LCBFR0xlbnVtIHR5cGUsIGNvbnN0IEVHTEF0dHJpYgogICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlkYXRlQ3JlYXRlU3luYyhkaXNwbGF5LCB0eXBlLCBh dHRyaWJ1dGVzLCBjdXJyZW50RGlzcGxheSwgY3VycmVudENvbnRleHQpLAogICAgICAgICAiZWds Q3JlYXRlU3luYyIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1lOQyk7Ci0K KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwg ImVnbENyZWF0ZVN5bmMiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZh bGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGVnbDo6U3luYyAqc3luY09iamVjdCA9IG51 bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5jcmVhdGVT eW5jKGN1cnJlbnRDb250ZXh0LCB0eXBlLCBhdHRyaWJ1dGVzLCAmc3luY09iamVjdCksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVN5bmMiLCBHZXREaXNwbGF5SWZWYWxpZChk aXNwbGF5KSwgRUdMX05PX1NZTkMpOwpAQCAtODcwLDcgKzkwMSw4IEBAIEVHTEJvb2xlYW4gRUdM QVBJRU5UUlkgRUdMX0Rlc3Ryb3lTeW5jKEVHTERpc3BsYXkgZHB5LCBFR0xTeW5jIHN5bmMpCiAK ICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlRGVzdHJveVN5bmMoZGlz cGxheSwgc3luY09iamVjdCksICJlZ2xEZXN0cm95U3luYyIsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbERlc3Ry b3lTeW5jIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNw bGF5KSwgRUdMX0ZBTFNFKTsKICAgICBkaXNwbGF5LT5kZXN0cm95U3luYyhzeW5jT2JqZWN0KTsK IAogICAgIHRocmVhZC0+c2V0U3VjY2VzcygpOwpAQCAtODkxLDcgKzkyMyw4IEBAIEVHTGludCBF R0xBUElFTlRSWSBFR0xfQ2xpZW50V2FpdFN5bmMoRUdMRGlzcGxheSBkcHksIEVHTFN5bmMgc3lu YywgRUdMaW50IGZsYWdzCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlk YXRlQ2xpZW50V2FpdFN5bmMoZGlzcGxheSwgc3luY09iamVjdCwgZmxhZ3MsIHRpbWVvdXQpLAog ICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDbGllbnRXYWl0U3luYyIsIEdldFN5bmNJZlZh bGlkKGRpc3BsYXksIHN5bmNPYmplY3QpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RS WV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xDbGllbnRXYWl0U3lu YyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSks IEVHTF9GQUxTRSk7CiAgICAgZ2w6OkNvbnRleHQgKmN1cnJlbnRDb250ZXh0ID0gdGhyZWFkLT5n ZXRDb250ZXh0KCk7CiAgICAgRUdMaW50IHN5bmNTdGF0dXMgICAgICAgICAgID0gRUdMX0ZBTFNF OwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKApAQCAtOTU0LDYgKzk4Nyw4IEBAIEVHTEltYWdl IEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVJbWFnZShFR0xEaXNwbGF5IGRweSwKICAgICAgICAgdGhy ZWFkLT5zZXRFcnJvcihlcnJvciwgR2V0RGVidWcoKSwgImVnbENyZWF0ZUltYWdlIiwgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSkpOwogICAgICAgICByZXR1cm4gRUdMX05PX0lNQUdFOwogICAg IH0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQo KSwgImVnbENyZWF0ZUltYWdlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5 SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKIAogICAgIEltYWdlICppbWFnZSA9IG51bGxw dHI7CiAgICAgZXJyb3IgICAgICAgID0gZGlzcGxheS0+Y3JlYXRlSW1hZ2UoY29udGV4dCwgdGFy Z2V0LCBidWZmZXIsIGF0dHJpYnV0ZXMsICZpbWFnZSk7CkBAIC05ODIsNyArMTAxNyw4IEBAIEVH TEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0Rlc3Ryb3lJbWFnZShFR0xEaXNwbGF5IGRweSwgRUdM SW1hZ2UgaW1hZ2UpCiAgICAgICAgIHRocmVhZC0+c2V0RXJyb3IoZXJyb3IsIEdldERlYnVnKCks ICJlZ2xEZXN0cm95SW1hZ2UiLCBHZXRJbWFnZUlmVmFsaWQoZGlzcGxheSwgaW1nKSk7CiAgICAg ICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4o dGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xEZXN0cm95SW1hZ2UiLAorICAgICAg ICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0Up OwogICAgIGRpc3BsYXktPmRlc3Ryb3lJbWFnZShpbWcpOwogCiAgICAgdGhyZWFkLT5zZXRTdWNj ZXNzKCk7CkBAIC0xMDQ0LDcgKzEwODAsOCBAQCBFR0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9D cmVhdGVQbGF0Zm9ybVdpbmRvd1N1cmZhY2UoRUdMRGlzcGxheSBkcHksCiAgICAgQU5HTEVfRUdM X1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAgICAgICAgICAgICAgICAgICAgIFZhbGlkYXRlQ3Jl YXRlV2luZG93U3VyZmFjZShkaXNwbGF5LCBjb25maWd1cmF0aW9uLCB3aW4sIGF0dHJpYnV0ZXMp LAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVXaW5kb3dTdXJmYWNlIiwgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKLQorICAgIEFOR0xFX0VH TF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsQ3JlYXRlV2lu ZG93U3VyZmFjZSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQo ZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKICAgICBlZ2w6OlN1cmZhY2UgKnN1cmZhY2UgPSBu dWxscHRyOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwKICAgICAgICAgICAgICAg ICAgICAgICAgICBkaXNwbGF5LT5jcmVhdGVXaW5kb3dTdXJmYWNlKGNvbmZpZ3VyYXRpb24sIHdp biwgYXR0cmlidXRlcywgJnN1cmZhY2UpLApAQCAtMTA3NSw3ICsxMTEyLDggQEAgRUdMU3VyZmFj ZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNlKEVHTERpc3BsYXkg ZHB5LAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlkYXRl Q3JlYXRlUGl4bWFwU3VyZmFjZShkaXNwbGF5LCBjb25maWd1cmF0aW9uLCBwaXhtYXAsIGF0dHJp YnV0ZXMpLAogICAgICAgICAiZWdsQ3JlYXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNlIiwgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKLQorICAgIEFOR0xFX0VHTF9U UllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsQ3JlYXRlUGxhdGZv cm1QaXhtYXBTdXJmYWNlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZW YWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIGVnbDo6U3VyZmFjZSAqc3VyZmFj ZSA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4oCiAgICAgICAgIHRocmVhZCwg ZGlzcGxheS0+Y3JlYXRlUGl4bWFwU3VyZmFjZShjb25maWd1cmF0aW9uLCBwaXhtYXAsIGF0dHJp YnV0ZXMsICZzdXJmYWNlKSwKQEAgLTEwOTksNyArMTEzNyw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJ RU5UUlkgRUdMX1dhaXRTeW5jKEVHTERpc3BsYXkgZHB5LCBFR0xTeW5jIHN5bmMsIEVHTGludCBm bGFncykKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVXYWl0U3lu YyhkaXNwbGF5LCBjb250ZXh0LCBzeW5jT2JqZWN0LCBmbGFncyksCiAgICAgICAgICAgICAgICAg ICAgICAgICAgImVnbFdhaXRTeW5jIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVj dCksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3Bs YXktPmJpbmRUaHJlYWQoKSwgImVnbFdhaXRTeW5jIiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBnbDo6Q29udGV4 dCAqY3VycmVudENvbnRleHQgPSB0aHJlYWQtPmdldENvbnRleHQoKTsKICAgICBBTkdMRV9FR0xf VFJZX1JFVFVSTih0aHJlYWQsIHN5bmNPYmplY3QtPnNlcnZlcldhaXQoZGlzcGxheSwgY3VycmVu dENvbnRleHQsIGZsYWdzKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsV2FpdFN5bmMi LCBHZXRTeW5jSWZWYWxpZChkaXNwbGF5LCBzeW5jT2JqZWN0KSwgRUdMX0ZBTFNFKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJHTEVTdjIvZW50cnlfcG9pbnRz X2VnbF9leHQuY3BwIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkdMRVN2Mi9lbnRy eV9wb2ludHNfZWdsX2V4dC5jcHAKaW5kZXggOWRlNjAzMzUzNTRlYTczNzRmNDBjZWQ0MmM3ODBm NTA1OTc3OWRmMC4uMDc0MGFjOGY2NDdmM2I5MGY4ZDAzNDkzNWM0MDMzYzNjN2UyZDFkYSAxMDA2 NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkdMRVN2Mi9lbnRyeV9wb2lu dHNfZWdsX2V4dC5jcHAKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkdMRVN2 Mi9lbnRyeV9wb2ludHNfZWdsX2V4dC5jcHAKQEAgLTg2LDcgKzg2LDggQEAgRUdMQm9vbGVhbiBF R0xBUElFTlRSWSBFR0xfUXVlcnlTdXJmYWNlUG9pbnRlckFOR0xFKEVHTERpc3BsYXkgZHB5LAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBl Z2xTdXJmYWNlKSk7CiAgICAgICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAg IEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWds UXVlcnlTdXJmYWNlUG9pbnRlckFOR0xFIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXRE aXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBlcnJvciA9IGVnbFN1cmZh Y2UtPnF1ZXJ5U3VyZmFjZVBvaW50ZXJBTkdMRShhdHRyaWJ1dGUsIHZhbHVlKTsKICAgICBpZiAo ZXJyb3IuaXNFcnJvcigpKQogICAgIHsKQEAgLTE1MSw3ICsxNTIsOCBAQCBFR0xCb29sZWFuIEVH TEFQSUVOVFJZIEVHTF9Qb3N0U3ViQnVmZmVyTlYoRUdMRGlzcGxheSBkcHksCiAgICAgICAgIHRo cmVhZC0+c2V0U3VjY2VzcygpOwogICAgICAgICByZXR1cm4gRUdMX1RSVUU7CiAgICAgfQotCisg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJl Z2xQb3N0U3ViQnVmZmVyTlYiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIC8vIFRPRE8oam1hZGlsbCk6IFZhbGlk YXRlIFN1cmZhY2UgaXMgYm91bmQgdG8gdGhlIHRocmVhZC4KICAgICBlcnJvciA9IGVnbFN1cmZh Y2UtPnBvc3RTdWJCdWZmZXIodGhyZWFkLT5nZXRDb250ZXh0KCksIHgsIHksIHdpZHRoLCBoZWln aHQpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCkBAIC0yMjMsNyArMjI1LDggQEAgRUdMU3Vy ZmFjZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlUGxhdGZvcm1XaW5kb3dTdXJmYWNlRVhUKEVHTERp c3BsYXkgZHB5LAogICAgICAgICB0aHJlYWQsCiAgICAgICAgIFZhbGlkYXRlQ3JlYXRlUGxhdGZv cm1XaW5kb3dTdXJmYWNlRVhUKGRpc3BsYXksIGNvbmZpZ3VyYXRpb24sIG5hdGl2ZV93aW5kb3cs IGF0dHJpYnV0ZXMpLAogICAgICAgICAiZWdsQ3JlYXRlUGxhdGZvcm1XaW5kb3dTdXJmYWNlRVhU IiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKLQorICAgIEFO R0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsQ3Jl YXRlUGxhdGZvcm1XaW5kb3dTdXJmYWNlRVhUIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBH ZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIHRocmVhZC0+ c2V0RXJyb3IoRWdsQmFkRGlzcGxheSgpIDw8ICJDcmVhdGVQbGF0Zm9ybVdpbmRvd1N1cmZhY2VF WFQgdW5pbXBsZW1lbnRlZC4iLCBHZXREZWJ1ZygpLAogICAgICAgICAgICAgICAgICAgICAgImVn bENyZWF0ZVBsYXRmb3JtV2luZG93U3VyZmFjZUVYVCIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpKTsKICAgICByZXR1cm4gRUdMX05PX1NVUkZBQ0U7CkBAIC0yNTAsNyArMjUzLDggQEAgRUdM U3VyZmFjZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNlRVhUKEVH TERpc3BsYXkgZHB5LAogICAgICAgICB0aHJlYWQsCiAgICAgICAgIFZhbGlkYXRlQ3JlYXRlUGxh dGZvcm1QaXhtYXBTdXJmYWNlRVhUKGRpc3BsYXksIGNvbmZpZ3VyYXRpb24sIG5hdGl2ZV9waXht YXAsIGF0dHJpYnV0ZXMpLAogICAgICAgICAiZWdsQ3JlYXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNl RVhUIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKLQorICAg IEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWds Q3JlYXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNlRVhUIiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIHRocmVh ZC0+c2V0RXJyb3IoRWdsQmFkRGlzcGxheSgpIDw8ICJDcmVhdGVQbGF0Zm9ybVBpeG1hcFN1cmZh Y2VFWFQgdW5pbXBsZW1lbnRlZC4iLCBHZXREZWJ1ZygpLAogICAgICAgICAgICAgICAgICAgICAg ImVnbENyZWF0ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZUVYVCIsIEdldERpc3BsYXlJZlZhbGlkKGRp c3BsYXkpKTsKICAgICByZXR1cm4gRUdMX05PX1NVUkZBQ0U7CkBAIC0yNzUsMTAgKzI3OSwxMSBA QCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9RdWVyeURldmljZUF0dHJpYkVYVChFR0xEZXZp Y2VFWFQgZGV2aWNlLAogICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1Zygp LCAiZWdsUXVlcnlEZXZpY2VBdHRyaWJFWFQiLCBHZXREZXZpY2VJZlZhbGlkKGRldikpOwogICAg ICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAgIGVnbDo6RGlzcGxheSAqb3duaW5n RGlzcGxheSA9IGRldi0+Z2V0T3duaW5nRGlzcGxheSgpOworICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgb3duaW5nRGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsUXVlcnlEZXZpY2VB dHRyaWJFWFQiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKG93 bmluZ0Rpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIC8vIElmIHRoZSBkZXZpY2Ugd2FzIGNyZWF0 ZWQgYnkgKGFuZCBpcyBvd25lZCBieSkgYSBkaXNwbGF5LCBhbmQgdGhhdCBkaXNwbGF5IGRvZXNu J3Qgc3VwcG9ydAogICAgIC8vIGRldmljZSBxdWVyeWluZywgdGhlbiB0aGlzIGNhbGwgc2hvdWxk IGZhaWwKLSAgICBlZ2w6OkRpc3BsYXkgKm93bmluZ0Rpc3BsYXkgPSBkZXYtPmdldE93bmluZ0Rp c3BsYXkoKTsKICAgICBpZiAob3duaW5nRGlzcGxheSAhPSBudWxscHRyICYmICFvd25pbmdEaXNw bGF5LT5nZXRFeHRlbnNpb25zKCkuZGV2aWNlUXVlcnkpCiAgICAgewogICAgICAgICB0aHJlYWQt PnNldEVycm9yKEVnbEJhZEFjY2VzcygpIDw8ICJEZXZpY2Ugd2Fzbid0IGNyZWF0ZWQgdXNpbmcg ZWdsQ3JlYXRlRGV2aWNlQU5HTEUsICIKQEAgLTM1MSw3ICszNTYsOSBAQCBjb25zdCBjaGFyICpF R0xBUElFTlRSWSBFR0xfUXVlcnlEZXZpY2VTdHJpbmdFWFQoRUdMRGV2aWNlRVhUIGRldmljZSwg RUdMaW50IG5hbQogICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1ZygpLCAi ZWdsUXVlcnlEZXZpY2VTdHJpbmdFWFQiLCBHZXREZXZpY2VJZlZhbGlkKGRldikpOwogICAgICAg ICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAgIGVnbDo6RGlzcGxheSAqb3duaW5nRGlz cGxheSA9IGRldi0+Z2V0T3duaW5nRGlzcGxheSgpOworICAgIEFOR0xFX0VHTF9UUllfUkVUVVJO KHRocmVhZCwgb3duaW5nRGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsUXVlcnlEZXZpY2VTdHJp bmdFWFQiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKG93bmlu Z0Rpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGNvbnN0IGNoYXIgKnJlc3VsdDsKICAgICBzd2l0 Y2ggKG5hbWUpCiAgICAgewpAQCAtMzgxLDcgKzM4OCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5U UlkgRUdMX1F1ZXJ5RGlzcGxheUF0dHJpYkVYVChFR0xEaXNwbGF5IGRweSwgRUdMaW50IGF0dHJp YnV0CiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlUXVlcnlEaXNw bGF5QXR0cmliRVhUKGRpc3BsYXksIGF0dHJpYnV0ZSksCiAgICAgICAgICAgICAgICAgICAgICAg ICAgImVnbFF1ZXJ5RGlzcGxheUF0dHJpYkVYVCIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp LCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5 LT5iaW5kVGhyZWFkKCksICJlZ2xRdWVyeURpc3BsYXlBdHRyaWJFWFQiLAorICAgICAgICAgICAg ICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAg ICp2YWx1ZSA9IGRpc3BsYXktPnF1ZXJ5QXR0cmliKGF0dHJpYnV0ZSk7CiAgICAgdGhyZWFkLT5z ZXRTdWNjZXNzKCk7CiAgICAgcmV0dXJuIEVHTF9UUlVFOwpAQCAtNDAyLDcgKzQxMCw4IEBAIEVH TEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5RGlzcGxheUF0dHJpYkFOR0xFKEVHTERpc3Bs YXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVF1ZXJ5 RGlzcGxheUF0dHJpYkFOR0xFKGRpc3BsYXksIGF0dHJpYnV0ZSksCiAgICAgICAgICAgICAgICAg ICAgICAgICAgImVnbFF1ZXJ5RGlzcGxheUF0dHJpYkFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQo ZGlzcGxheSksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs IGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFF1ZXJ5RGlzcGxheUF0dHJpYkFOR0xFIiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZB TFNFKTsKICAgICAqdmFsdWUgPSBkaXNwbGF5LT5xdWVyeUF0dHJpYihhdHRyaWJ1dGUpOwogICAg IHRocmVhZC0+c2V0U3VjY2VzcygpOwogICAgIHJldHVybiBFR0xfVFJVRTsKQEAgLTQzMyw3ICs0 NDIsOCBAQCBBTkdMRV9FWFBPUlQgRUdMSW1hZ2VLSFIgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZUlt YWdlS0hSKEVHTERpc3BsYXkgZHB5LAogICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBH ZXREZWJ1ZygpLCAiZWdsQ3JlYXRlSW1hZ2VLSFIiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5 KSk7CiAgICAgICAgIHJldHVybiBFR0xfTk9fSU1BR0U7CiAgICAgfQotCisgICAgQU5HTEVfRUdM X1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xDcmVhdGVJbWFn ZUtIUiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxh eSksIEVHTF9OT19JTUFHRSk7CiAgICAgSW1hZ2UgKmltYWdlID0gbnVsbHB0cjsKICAgICBlcnJv ciAgICAgICAgPSBkaXNwbGF5LT5jcmVhdGVJbWFnZShjb250ZXh0LCB0YXJnZXQsIGJ1ZmZlciwg YXR0cmlidXRlcywgJmltYWdlKTsKICAgICBpZiAoZXJyb3IuaXNFcnJvcigpKQpAQCAtNDYyLDcg KzQ3Miw4IEBAIEFOR0xFX0VYUE9SVCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9EZXN0cm95 SW1hZ2VLSFIoRUdMRGlzcGxheSBkcHksIEVHTEltYWdlCiAgICAgICAgIHRocmVhZC0+c2V0RXJy b3IoZXJyb3IsIEdldERlYnVnKCksICJlZ2xEZXN0cm95SW1hZ2VLSFIiLCBHZXRJbWFnZUlmVmFs aWQoZGlzcGxheSwgaW1nKSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJl Z2xEZXN0cm95SW1hZ2VLSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGRpc3BsYXktPmRlc3Ryb3lJbWFnZShp bWcpOwogCiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CkBAIC01MzgsNyArNTQ5LDggQEAgRUdM U3RyZWFtS0hSIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVTdHJlYW1LSFIoRUdMRGlzcGxheSBkcHks IGNvbnN0IEVHTGludCAqYXR0cmkKICAgICAgICAgdGhyZWFkLT5zZXRFcnJvcihlcnJvciwgR2V0 RGVidWcoKSwgImVnbENyZWF0ZVN0cmVhbUtIUiIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp KTsKICAgICAgICAgcmV0dXJuIEVHTF9OT19TVFJFQU1fS0hSOwogICAgIH0KLQorICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsQ3JlYXRl U3RyZWFtS0hSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChk aXNwbGF5KSwgRUdMX05PX1NUUkVBTV9LSFIpOwogICAgIFN0cmVhbSAqc3RyZWFtOwogICAgIGVy cm9yID0gZGlzcGxheS0+Y3JlYXRlU3RyZWFtKGF0dHJpYnV0ZXMsICZzdHJlYW0pOwogICAgIGlm IChlcnJvci5pc0Vycm9yKCkpCkBAIC01NjgsNyArNTgwLDggQEAgRUdMQm9vbGVhbiBFR0xBUElF TlRSWSBFR0xfRGVzdHJveVN0cmVhbUtIUihFR0xEaXNwbGF5IGRweSwgRUdMU3RyZWFtS0hSIHN0 cmVhbSkKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZhbGlkKGRpc3BsYXks IHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAg IEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWds RGVzdHJveVN0cmVhbUtIUiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlm VmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZGlzcGxheS0+ZGVzdHJveVN0cmVhbShz dHJlYW1PYmplY3QpOwogCiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CkBAIC01OTcsNyArNjEw LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfU3RyZWFtQXR0cmliS0hSKEVHTERpc3Bs YXkgZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQoZGlzcGxh eSwgc3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJl Z2xTdHJlYW1BdHRyaWJLSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIHN3aXRjaCAoYXR0cmlidXRlKQogICAg IHsKICAgICAgICAgY2FzZSBFR0xfQ09OU1VNRVJfTEFURU5DWV9VU0VDX0tIUjoKQEAgLTYzNiw3 ICs2NTAsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9RdWVyeVN0cmVhbUtIUihFR0xE aXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZhbGlkKGRp c3BsYXksIHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0K LQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgp LCAiZWdsUXVlcnlTdHJlYW1LSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3Bs YXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIHN3aXRjaCAoYXR0cmlidXRlKQog ICAgIHsKICAgICAgICAgY2FzZSBFR0xfU1RSRUFNX1NUQVRFX0tIUjoKQEAgLTY3OCw3ICs2OTMs OCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9RdWVyeVN0cmVhbXU2NEtIUihFR0xEaXNw bGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZhbGlkKGRpc3Bs YXksIHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQor ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAi ZWdsUXVlcnlTdHJlYW11NjRLSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3Bs YXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIHN3aXRjaCAoYXR0cmlidXRlKQog ICAgIHsKICAgICAgICAgY2FzZSBFR0xfUFJPRFVDRVJfRlJBTUVfS0hSOgpAQCAtNzEzLDcgKzcy OSw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N0cmVhbUNvbnN1bWVyR0xUZXh0dXJl RXh0ZXJuYWxLSFIoRUdMRGlzcGxheSBkcHksIEVHCiAgICAgICAgICAgICAgICAgICAgICAgICAg R2V0U3RyZWFtSWZWYWxpZChkaXNwbGF5LCBzdHJlYW1PYmplY3QpKTsKICAgICAgICAgcmV0dXJu IEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRp c3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFN0cmVhbUNvbnN1bWVyR0xUZXh0dXJlRXh0ZXJuYWxL SFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp LCBFR0xfRkFMU0UpOwogICAgIGVycm9yID0gc3RyZWFtT2JqZWN0LT5jcmVhdGVDb25zdW1lckdM VGV4dHVyZUV4dGVybmFsKEF0dHJpYnV0ZU1hcCgpLCBjb250ZXh0KTsKICAgICBpZiAoZXJyb3Iu aXNFcnJvcigpKQogICAgIHsKQEAgLTc0NCw3ICs3NjEsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVO VFJZIEVHTF9TdHJlYW1Db25zdW1lckFjcXVpcmVLSFIoRUdMRGlzcGxheSBkcHksIEVHTFN0cmVh bUtIUgogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQoZGlzcGxheSwg c3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xT dHJlYW1Db25zdW1lckFjcXVpcmVLSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGVycm9yID0gc3RyZWFtT2Jq ZWN0LT5jb25zdW1lckFjcXVpcmUoY29udGV4dCk7CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkK ICAgICB7CkBAIC03NzUsNyArNzkzLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfU3Ry ZWFtQ29uc3VtZXJSZWxlYXNlS0hSKEVHTERpc3BsYXkgZHB5LCBFR0xTdHJlYW1LSFIKICAgICAg ICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZhbGlkKGRpc3BsYXksIHN0cmVhbU9iamVj dCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAgIEFOR0xFX0VHTF9U UllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsU3RyZWFtQ29uc3Vt ZXJSZWxlYXNlS0hSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxp ZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBlcnJvciA9IHN0cmVhbU9iamVjdC0+Y29uc3Vt ZXJSZWxlYXNlKGNvbnRleHQpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAt ODExLDcgKzgzMCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N0cmVhbUNvbnN1bWVy R0xUZXh0dXJlRXh0ZXJuYWxBdHRyaWJzTlYoRUdMRGlzcGxheSBkCiAgICAgICAgICAgICAgICAg ICAgICAgICAgR2V0U3RyZWFtSWZWYWxpZChkaXNwbGF5LCBzdHJlYW1PYmplY3QpKTsKICAgICAg ICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFN0cmVhbUNvbnN1bWVyR0xUZXh0dXJl RXh0ZXJuYWxBdHRyaWJzTlYiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGVycm9yID0gc3RyZWFtT2JqZWN0LT5j cmVhdGVDb25zdW1lckdMVGV4dHVyZUV4dGVybmFsKGF0dHJpYnV0ZXMsIGNvbnRleHQpOwogICAg IGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtODQ1LDcgKzg2NSw4IEBAIEVHTEJvb2xl YW4gRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVN0cmVhbVByb2R1Y2VyRDNEVGV4dHVyZUFOR0xFKEVH TERpc3BsYXkgZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQo ZGlzcGxheSwgc3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAg fQotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFk KCksICJlZ2xDcmVhdGVTdHJlYW1Qcm9kdWNlckQzRFRleHR1cmVBTkdMRSIsCisgICAgICAgICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAg ICAgZXJyb3IgPSBzdHJlYW1PYmplY3QtPmNyZWF0ZVByb2R1Y2VyRDNEMTFUZXh0dXJlKGF0dHJp YnV0ZXMpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtODgyLDcgKzkwMyw4 IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N0cmVhbVBvc3REM0RUZXh0dXJlQU5HTEUo RUdMRGlzcGxheSBkcHksCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3RyZWFtSWZWYWxp ZChkaXNwbGF5LCBzdHJlYW1PYmplY3QpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAg ICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJl YWQoKSwgImVnbFN0cmVhbVBvc3REM0RUZXh0dXJlQU5HTEUiLAorICAgICAgICAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGVycm9y ID0gc3RyZWFtT2JqZWN0LT5wb3N0RDNEMTFUZXh0dXJlKHRleHR1cmUsIGF0dHJpYnV0ZXMpOwog ICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtOTE1LDcgKzkzNyw4IEBAIEFOR0xF X0VYUE9SVCBFR0xTeW5jIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVTeW5jS0hSKEVHTERpc3BsYXkg ZHB5LAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlkYXRl Q3JlYXRlU3luY0tIUihkaXNwbGF5LCB0eXBlLCBhdHRyaWJ1dGVzLCBjdXJyZW50RGlzcGxheSwg Y3VycmVudENvbnRleHQpLAogICAgICAgICAiZWdsQ3JlYXRlU3luYyIsIEdldERpc3BsYXlJZlZh bGlkKGRpc3BsYXkpLCBFR0xfTk9fU1lOQyk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbENyZWF0ZVN5bmMiLAorICAgICAgICAg ICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1lOQyk7 CiAgICAgZWdsOjpTeW5jICpzeW5jT2JqZWN0ID0gbnVsbHB0cjsKICAgICBBTkdMRV9FR0xfVFJZ X1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmNyZWF0ZVN5bmMoY3VycmVudENvbnRleHQsIHR5cGUs IGF0dHJpYnV0ZXMsICZzeW5jT2JqZWN0KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWds Q3JlYXRlU3luYyIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1lOQyk7CkBA IC05MzYsNyArOTU5LDggQEAgQU5HTEVfRVhQT1JUIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdM X0Rlc3Ryb3lTeW5jS0hSKEVHTERpc3BsYXkgZHB5LCBFR0xTeW5jIHMKIAogICAgIEFOR0xFX0VH TF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVEZXN0cm95U3luYyhkaXNwbGF5LCBzeW5jT2Jq ZWN0KSwgImVnbERlc3Ryb3lTeW5jIiwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsRGVzdHJveVN5bmMiLAorICAg ICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFM U0UpOwogICAgIGRpc3BsYXktPmRlc3Ryb3lTeW5jKHN5bmNPYmplY3QpOwogCiAgICAgdGhyZWFk LT5zZXRTdWNjZXNzKCk7CkBAIC05NjAsNyArOTg0LDggQEAgQU5HTEVfRVhQT1JUIEVHTGludCBF R0xBUElFTlRSWSBFR0xfQ2xpZW50V2FpdFN5bmNLSFIoRUdMRGlzcGxheSBkcHksCiAKICAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlQ2xpZW50V2FpdFN5bmMoZGlzcGxh eSwgc3luY09iamVjdCwgZmxhZ3MsIHRpbWVvdXQpLAogICAgICAgICAgICAgICAgICAgICAgICAg ICJlZ2xDbGllbnRXYWl0U3luYyIsIEdldFN5bmNJZlZhbGlkKGRpc3BsYXksIHN5bmNPYmplY3Qp LCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5 LT5iaW5kVGhyZWFkKCksICJlZ2xDbGllbnRXYWl0U3luYyIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZ2w6OkNv bnRleHQgKmN1cnJlbnRDb250ZXh0ID0gdGhyZWFkLT5nZXRDb250ZXh0KCk7CiAgICAgRUdMaW50 IHN5bmNTdGF0dXMgICAgICAgICAgID0gRUdMX0ZBTFNFOwogICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKApAQCAtOTg4LDcgKzEwMTMsOCBAQCBBTkdMRV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElF TlRSWSBFR0xfR2V0U3luY0F0dHJpYktIUihFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VH TF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVHZXRTeW5jQXR0cmliS0hSKGRpc3BsYXksIHN5 bmNPYmplY3QsIGF0dHJpYnV0ZSwgdmFsdWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJl Z2xHZXRTeW5jQXR0cmliIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVjdCksIEVH TF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJp bmRUaHJlYWQoKSwgImVnbEdldFN5bmNBdHRyaWIiLAorICAgICAgICAgICAgICAgICAgICAgICAg IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIEFOR0xFX0VHTF9U UllfUkVUVVJOKHRocmVhZCwgR2V0U3luY0F0dHJpYihkaXNwbGF5LCBzeW5jT2JqZWN0LCBhdHRy aWJ1dGUsIHZhbHVlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsR2V0U3luY0F0dHJp YiIsIEdldFN5bmNJZlZhbGlkKGRpc3BsYXksIHN5bmNPYmplY3QpLCBFR0xfRkFMU0UpOwogCkBA IC0xMDExLDcgKzEwMzcsOCBAQCBBTkdMRV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBF R0xfV2FpdFN5bmNLSFIoRUdMRGlzcGxheSBkcHksIEVHTFN5bmMgc3luYwogCiAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVdhaXRTeW5jKGRpc3BsYXksIGNvbnRleHQs IHN5bmNPYmplY3QsIGZsYWdzKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsV2FpdFN5 bmMiLCBHZXRTeW5jSWZWYWxpZChkaXNwbGF5LCBzeW5jT2JqZWN0KSwgRUdMX0ZBTFNFKTsKLQor ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAi ZWdsV2FpdFN5bmMiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGdsOjpDb250ZXh0ICpjdXJyZW50Q29udGV4dCA9 IHRocmVhZC0+Z2V0Q29udGV4dCgpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwg c3luY09iamVjdC0+c2VydmVyV2FpdChkaXNwbGF5LCBjdXJyZW50Q29udGV4dCwgZmxhZ3MpLAog ICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xXYWl0U3luYyIsIEdldFN5bmNJZlZhbGlkKGRp c3BsYXksIHN5bmNPYmplY3QpLCBFR0xfRkFMU0UpOwpAQCAtMTA0Myw3ICsxMDcwLDggQEAgRUdM Qm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0TXNjUmF0ZUFOR0xFKEVHTERpc3BsYXkgZHB5LAog ICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1 cmZhY2UpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbEdldE1zY1Jh dGVBTkdMRSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlz cGxheSksIEVHTF9GQUxTRSk7CiAgICAgZXJyb3IgPSBlZ2xTdXJmYWNlLT5nZXRNc2NSYXRlKG51 bWVyYXRvciwgZGVub21pbmF0b3IpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpA QCAtMTA4MCw3ICsxMTA4LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0U3luY1Zh bHVlc0NIUk9NSVVNKEVHTERpc3BsYXkgZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdl dFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpKTsKICAgICAgICAgcmV0dXJuIEVH TF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3Bs YXktPmJpbmRUaHJlYWQoKSwgImVnbEdldFN5bmNWYWx1ZXNDSFJPTUlVTSIsCisgICAgICAgICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAg ICAgZXJyb3IgPSBlZ2xTdXJmYWNlLT5nZXRTeW5jVmFsdWVzKHVzdCwgbXNjLCBzYmMpOwogICAg IGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtMTExNiw3ICsxMTQ1LDggQEAgRUdMQm9v bGVhbiBFR0xBUElFTlRSWSBFR0xfU3dhcEJ1ZmZlcnNXaXRoRGFtYWdlS0hSKEVHTERpc3BsYXkg ZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXks IGVnbFN1cmZhY2UpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFN3 YXBCdWZmZXJzV2l0aERhbWFnZUVYVCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZXJyb3IgPSBlZ2xTdXJmYWNl LT5zd2FwV2l0aERhbWFnZSh0aHJlYWQtPmdldENvbnRleHQoKSwgcmVjdHMsIG5fcmVjdHMpOwog ICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtMTE0NSw2ICsxMTc1LDggQEAgRUdM Qm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfUHJlc2VudGF0aW9uVGltZUFORFJPSUQoRUdMRGlzcGxh eSBkcHksCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVByZXNlbnRh dGlvblRpbWVBTkRST0lEKGRpc3BsYXksIGVnbFN1cmZhY2UsIHRpbWUpLAogICAgICAgICAgICAg ICAgICAgICAgICAgICJlZ2xQcmVzZW50YXRpb25UaW1lQU5EUk9JRCIsIEdldFN1cmZhY2VJZlZh bGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLAogICAgICAgICAgICAgICAgICAgICAgICAgIEVHTF9G QUxTRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhy ZWFkKCksICJlZ2xQcmVzZW50YXRpb25UaW1lQU5EUk9JRCIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBlZ2xTdXJmYWNlLT5zZXRQcmVzZW50YXRpb25UaW1lKHRp bWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xQcmVzZW50YXRpb25UaW1lQU5EUk9J RCIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLAogICAgICAgICAgICAg ICAgICAgICAgICAgIEVHTF9GQUxTRSk7CkBAIC0xMTY2LDcgKzExOTgsOCBAQCBBTkdMRV9FWFBP UlQgdm9pZCBFR0xBUElFTlRSWSBFR0xfU2V0QmxvYkNhY2hlRnVuY3NBTkRST0lEKEVHTERpc3Bs YXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIFZhbGlkYXRlU2V0QmxvYkNhY2hl QU5EUk9JRChkaXNwbGF5LCBzZXQsIGdldCksCiAgICAgICAgICAgICAgICAgICAiZWdsU2V0Qmxv YkNhY2hlRnVuY3NBTkRST0lEIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwotCisgICAg QU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFNldEJsb2JD YWNoZUZ1bmNzQU5EUk9JRCIsCisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChk aXNwbGF5KSk7CiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CiAgICAgZGlzcGxheS0+c2V0Qmxv YkNhY2hlRnVuY3Moc2V0LCBnZXQpOwogfQpAQCAtMTE4MSw3ICsxMjE0LDggQEAgRUdMaW50IEVH TEFQSUVOVFJZIEVHTF9Qcm9ncmFtQ2FjaGVHZXRBdHRyaWJBTkdMRShFR0xEaXNwbGF5IGRweSwg RUdMZW51bSBhdHRyaWIKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRh dGVQcm9ncmFtQ2FjaGVHZXRBdHRyaWJBTkdMRShkaXNwbGF5LCBhdHRyaWIpLAogICAgICAgICAg ICAgICAgICAgICAgICAgICJlZ2xQcm9ncmFtQ2FjaGVHZXRBdHRyaWJBTkdMRSIsIEdldERpc3Bs YXlJZlZhbGlkKGRpc3BsYXkpLCAwKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwgZGlzcGxheS0+YmluZFRocmVhZCgpLCAiZWdsUHJvZ3JhbUNhY2hlR2V0QXR0cmliQU5HTEUi LAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCAw KTsKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKICAgICByZXR1cm4gZGlzcGxheS0+cHJvZ3Jh bUNhY2hlR2V0QXR0cmliKGF0dHJpYik7CiB9CkBAIC0xMjA2LDcgKzEyNDAsOCBAQCB2b2lkIEVH TEFQSUVOVFJZIEVHTF9Qcm9ncmFtQ2FjaGVRdWVyeUFOR0xFKEVHTERpc3BsYXkgZHB5LAogICAg IEFOR0xFX0VHTF9UUlkodGhyZWFkLAogICAgICAgICAgICAgICAgICAgVmFsaWRhdGVQcm9ncmFt Q2FjaGVRdWVyeUFOR0xFKGRpc3BsYXksIGluZGV4LCBrZXksIGtleXNpemUsIGJpbmFyeSwgYmlu YXJ5c2l6ZSksCiAgICAgICAgICAgICAgICAgICAiZWdsUHJvZ3JhbUNhY2hlUXVlcnlBTkdMRSIs IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKLQorICAgIEFOR0xFX0VHTF9UUlkodGhyZWFk LCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xQcm9ncmFtQ2FjaGVRdWVyeUFOR0xFIiwKKyAg ICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKICAgICBBTkdMRV9F R0xfVFJZKHRocmVhZCwgZGlzcGxheS0+cHJvZ3JhbUNhY2hlUXVlcnkoaW5kZXgsIGtleSwga2V5 c2l6ZSwgYmluYXJ5LCBiaW5hcnlzaXplKSwKICAgICAgICAgICAgICAgICAgICJlZ2xQcm9ncmFt Q2FjaGVRdWVyeUFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogCkBAIC0xMjMx LDcgKzEyNjYsOCBAQCB2b2lkIEVHTEFQSUVOVFJZIEVHTF9Qcm9ncmFtQ2FjaGVQb3B1bGF0ZUFO R0xFKEVHTERpc3BsYXkgZHB5LAogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLAogICAgICAgICAg ICAgICAgICAgVmFsaWRhdGVQcm9ncmFtQ2FjaGVQb3B1bGF0ZUFOR0xFKGRpc3BsYXksIGtleSwg a2V5c2l6ZSwgYmluYXJ5LCBiaW5hcnlzaXplKSwKICAgICAgICAgICAgICAgICAgICJlZ2xQcm9n cmFtQ2FjaGVQb3B1bGF0ZUFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwotCisg ICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFByb2dy YW1DYWNoZVBvcHVsYXRlQU5HTEUiLAorICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFs aWQoZGlzcGxheSkpOwogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBkaXNwbGF5LT5wcm9ncmFt Q2FjaGVQb3B1bGF0ZShrZXksIGtleXNpemUsIGJpbmFyeSwgYmluYXJ5c2l6ZSksCiAgICAgICAg ICAgICAgICAgICAiZWdsUHJvZ3JhbUNhY2hlUG9wdWxhdGVBTkdMRSIsIEdldERpc3BsYXlJZlZh bGlkKGRpc3BsYXkpKTsKIApAQCAtMTI0OSw3ICsxMjg1LDggQEAgRUdMaW50IEVHTEFQSUVOVFJZ IEVHTF9Qcm9ncmFtQ2FjaGVSZXNpemVBTkdMRShFR0xEaXNwbGF5IGRweSwgRUdMaW50IGxpbWl0 LCBFR0wKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVQcm9ncmFt Q2FjaGVSZXNpemVBTkdMRShkaXNwbGF5LCBsaW1pdCwgbW9kZSksCiAgICAgICAgICAgICAgICAg ICAgICAgICAgImVnbFByb2dyYW1DYWNoZVJlc2l6ZUFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQo ZGlzcGxheSksIDApOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5 LT5iaW5kVGhyZWFkKCksICJlZ2xQcm9ncmFtQ2FjaGVSZXNpemVBTkdMRSIsCisgICAgICAgICAg ICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgMCk7CiAgICAgdGhyZWFkLT5zZXRT dWNjZXNzKCk7CiAgICAgcmV0dXJuIGRpc3BsYXktPnByb2dyYW1DYWNoZVJlc2l6ZShsaW1pdCwg bW9kZSk7CiB9CkBAIC0xMzQwLDcgKzEzNzcsMTMgQEAgRUdMaW50IEVHTEFQSUVOVFJZIEVHTF9M YWJlbE9iamVjdEtIUihFR0xEaXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICBH ZXRMYWJlbGVkT2JqZWN0SWZWYWxpZCh0aHJlYWQsIGRpc3BsYXksIG9iamVjdFR5cGVQYWNrZWQs IG9iamVjdCkpOwogICAgICAgICByZXR1cm4gZXJyb3IuZ2V0Q29kZSgpOwogICAgIH0KLQorICAg IGVycm9yID0gZGlzcGxheS0+YmluZFRocmVhZCgpOworICAgIGlmIChlcnJvci5pc0Vycm9yKCkp CisgICAgeworICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1ZygpLCAiZWds TGFiZWxPYmplY3RLSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZh bGlkKGRpc3BsYXkpKTsKKyAgICAgICAgcmV0dXJuIGVycm9yLmdldENvZGUoKTsKKyAgICB9CiAg ICAgTGFiZWxlZE9iamVjdCAqbGFiZWxlZE9iamVjdCA9CiAgICAgICAgIEdldExhYmVsZWRPYmpl Y3RJZlZhbGlkKHRocmVhZCwgZGlzcGxheSwgb2JqZWN0VHlwZVBhY2tlZCwgb2JqZWN0KTsKICAg ICBBU1NFUlQobGFiZWxlZE9iamVjdCAhPSBudWxscHRyKTsKQEAgLTEzOTQsNiArMTQzNyw4IEBA IEFOR0xFX0VYUE9SVCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9HZXRDb21wb3NpdG9yVGlt aW5nQU5EUk9JRChFR0xEaXNwbGF5IGRwCiAgICAgICAgIHRocmVhZCwKICAgICAgICAgVmFsaWRh dGVHZXRDb21wb3NpdG9yVGltaW5nQU5EUk9JRChkaXNwbGF5LCBlZ2xTdXJmYWNlLCBudW1UaW1l c3RhbXBzLCBuYW1lcywgdmFsdWVzKSwKICAgICAgICAgImVnbEdldENvbXBvc2l0b3JUaW1pbmdB TkRST0lERCIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFM U0UpOworICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVh ZCgpLCAiZWdsR2V0Q29tcG9zaXRvclRpbWluZ0FORFJPSUREIiwKKyAgICAgICAgICAgICAgICAg IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIEFOR0xFX0VHTF9U UllfUkVUVVJOKHRocmVhZCwgZWdsU3VyZmFjZS0+Z2V0Q29tcG9zaXRvclRpbWluZyhudW1UaW1l c3RhbXBzLCBuYW1lcywgdmFsdWVzKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsR2V0 Q29tcG9zaXRvclRpbWluZ0FORFJPSUREIiwgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWds U3VyZmFjZSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgRUdMX0ZBTFNFKTsKQEAgLTE0MTgs NiArMTQ2Myw4IEBAIEFOR0xFX0VYUE9SVCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9HZXRO ZXh0RnJhbWVJZEFORFJPSUQoRUdMRGlzcGxheSBkcHksCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRV Uk4odGhyZWFkLCBWYWxpZGF0ZUdldE5leHRGcmFtZUlkQU5EUk9JRChkaXNwbGF5LCBlZ2xTdXJm YWNlLCBmcmFtZUlkKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsR2V0TmV4dEZyYW1l SWRBTkRST0lEIiwgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgRUdMX0ZBTFNFKTsKKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVS Tih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbEdldE5leHRGcmFtZUlkQU5EUk9J RCIsCisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZB TFNFKTsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGVnbFN1cmZhY2UtPmdldE5l eHRGcmFtZUlkKGZyYW1lSWQpLCAiZWdsR2V0TmV4dEZyYW1lSWRBTkRST0lEIiwKICAgICAgICAg ICAgICAgICAgICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwg RUdMX0ZBTFNFKTsKIApAQCAtMTQ0Myw3ICsxNDkwLDggQEAgQU5HTEVfRVhQT1JUIEVHTEJvb2xl YW4gRUdMQVBJRU5UUlkgRUdMX0dldEZyYW1lVGltZXN0YW1wU3VwcG9ydGVkQU5EUk9JRChFR0xE aXMKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTigKICAgICAgICAgdGhyZWFkLCBWYWxpZGF0ZUdl dEZyYW1lVGltZXN0YW1wU3VwcG9ydGVkQU5EUk9JRChkaXNwbGF5LCBlZ2xTdXJmYWNlLCB0aW1l c3RhbXBJbnRlcm5hbCksCiAgICAgICAgICJlZ2xRdWVyeVRpbWVzdGFtcFN1cHBvcnRlZEFORFJP SUQiLCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsK LQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+YmluZFRocmVhZCgp LCAiZWdsUXVlcnlUaW1lc3RhbXBTdXBwb3J0ZWRBTkRST0lEIiwKKyAgICAgICAgICAgICAgICAg IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIHRocmVhZC0+c2V0 U3VjY2VzcygpOwogICAgIHJldHVybiBlZ2xTdXJmYWNlLT5nZXRTdXBwb3J0ZWRUaW1lc3RhbXBz KCkudGVzdCh0aW1lc3RhbXBJbnRlcm5hbCk7CiB9CkBAIC0xNDcyLDYgKzE1MjAsOCBAQCBBTkdM RV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0RnJhbWVUaW1lc3RhbXBzQU5E Uk9JRChFR0xEaXNwbGF5IGRweQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBudW1UaW1lc3RhbXBzLCB0aW1lc3RhbXBzLCB2YWx1ZXMp LAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xHZXRGcmFtZVRpbWVzdGFtcHNBTkRST0lE IiwgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksCiAgICAgICAgICAgICAg ICAgICAgICAgICAgRUdMX0ZBTFNFKTsKKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs IGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbEdldEZyYW1lVGltZXN0YW1wc0FORFJPSUQiLAor ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7 CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4oCiAgICAgICAgIHRocmVhZCwgZWdsU3VyZmFjZS0+ Z2V0RnJhbWVUaW1lc3RhbXBzKGZyYW1lSWQsIG51bVRpbWVzdGFtcHMsIHRpbWVzdGFtcHMsIHZh bHVlcyksCiAgICAgICAgICJlZ2xHZXRGcmFtZVRpbWVzdGFtcHNBTkRST0lEIiwgR2V0U3VyZmFj ZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9GQUxTRSk7CkBAIC0xNDk0LDcgKzE1 NDQsOCBAQCBBTkdMRV9FWFBPUlQgY29uc3QgY2hhciAqRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5U3Ry aW5naUFOR0xFKEVHTERpc3BsYXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhy ZWFkLCBWYWxpZGF0ZVF1ZXJ5U3RyaW5naUFOR0xFKGRpc3BsYXksIG5hbWUsIGluZGV4KSwKICAg ICAgICAgICAgICAgICAgICAgICAgICAiZWdsUXVlcnlTdHJpbmdpQU5HTEUiLCBHZXREaXNwbGF5 SWZWYWxpZChkaXNwbGF5KSwgbnVsbHB0cik7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFF1ZXJ5U3RyaW5naUFOR0xFIiwKKyAg ICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBudWxscHRyKTsKICAg ICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKICAgICByZXR1cm4gZGlzcGxheS0+cXVlcnlTdHJpbmdp KG5hbWUsIGluZGV4KTsKIH0KQEAgLTE1MjYsNyArMTU3Nyw4IEBAIEVHTGludCBFR0xBUElFTlRS WSBFR0xfRHVwTmF0aXZlRmVuY2VGREFORFJPSUQoRUdMRGlzcGxheSBkcHksIEVHTFN5bmNLSFIg c3luYykKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlRHVwTmF0aXZl RmVuY2VGREFORFJPSUQoZGlzcGxheSwgc3luY09iamVjdCksCiAgICAgICAgICAgICAgICAgICAg ICAgICAgImVnbER1cE5hdGl2ZUZlbmNlRkRBTkRST0lEIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxh eSwgc3luY09iamVjdCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgRUdMX05PX05BVElWRV9G RU5DRV9GRF9BTkRST0lEKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlz cGxheS0+YmluZFRocmVhZCgpLCAiZWdsRHVwTmF0aXZlRmVuY2VGREFORFJPSUQiLAorICAgICAg ICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fTkFU SVZFX0ZFTkNFX0ZEX0FORFJPSUQpOwogICAgIEVHTGludCByZXN1bHQgPSBFR0xfTk9fTkFUSVZF X0ZFTkNFX0ZEX0FORFJPSUQ7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBzeW5j T2JqZWN0LT5kdXBOYXRpdmVGZW5jZUZEKGRpc3BsYXksICZyZXN1bHQpLAogICAgICAgICAgICAg ICAgICAgICAgICAgICJlZ2xEdXBOYXRpdmVGZW5jZUZEQU5EUk9JRCIsIEdldFN5bmNJZlZhbGlk KGRpc3BsYXksIHN5bmNPYmplY3QpLApAQCAtMTU1Miw3ICsxNjA0LDggQEAgRUdMQm9vbGVhbiBF R0xBUElFTlRSWSBFR0xfU3dhcEJ1ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFKEVHTERpc3BsYXkg ZHB5LAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlkYXRl U3dhcEJ1ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFKGRpc3BsYXksIGVnbFN1cmZhY2UsIGZyYW1l dG9rZW4pLAogICAgICAgICAiZWdsU3dhcEJ1ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFIiwgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZ X1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmJpbmRUaHJlYWQoKSwgImVnbFN3YXBCdWZmZXJzV2l0 aEZyYW1lVG9rZW5BTkdMRSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlm VmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhy ZWFkLCBlZ2xTdXJmYWNlLT5zd2FwV2l0aEZyYW1lVG9rZW4odGhyZWFkLT5nZXRDb250ZXh0KCks IGZyYW1ldG9rZW4pLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xTd2FwQnVmZmVyc1dp dGhGcmFtZVRva2VuQU5HTEUiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwKICAgICAgICAg ICAgICAgICAgICAgICAgICBFR0xfRkFMU0UpOwpAQCAtMTU3Myw2ICsxNjI2LDggQEAgdm9pZCBF R0xBUElFTlRSWSBFR0xfUmVsZWFzZUhpZ2hQb3dlckdQVUFOR0xFKEVHTERpc3BsYXkgZHB5LCBF R0xDb250ZXh0IGN0eCkKIAogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBWYWxpZGF0ZUNvbnRl eHQoZGlzcGxheSwgY29udGV4dCksICJlZ2xSZWxlYXNlSGlnaFBvd2VyR1BVQU5HTEUiLAogICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOworICAgIEFOR0xFX0VH TF9UUlkodGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xSZWxlYXNlSGlnaFBvd2Vy R1BVQU5HTEUiLAorICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkp OwogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBjb250ZXh0LT5yZWxlYXNlSGlnaFBvd2VyR1BV KCksICJlZ2xSZWxlYXNlSGlnaFBvd2VyR1BVQU5HTEUiLAogICAgICAgICAgICAgICAgICAgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogCkBAIC0xNTkxLDYgKzE2NDYsOCBAQCB2b2lkIEVH TEFQSUVOVFJZIEVHTF9SZWFjcXVpcmVIaWdoUG93ZXJHUFVBTkdMRShFR0xEaXNwbGF5IGRweSwg RUdMQ29udGV4dCBjdHgpCiAKICAgICBBTkdMRV9FR0xfVFJZKHRocmVhZCwgVmFsaWRhdGVDb250 ZXh0KGRpc3BsYXksIGNvbnRleHQpLCAiZWdsUmVhY3F1aXJlSGlnaFBvd2VyR1BVQU5HTEUiLAog ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOworICAgIEFOR0xF X0VHTF9UUlkodGhyZWFkLCBkaXNwbGF5LT5iaW5kVGhyZWFkKCksICJlZ2xSZWFjcXVpcmVIaWdo UG93ZXJHUFVBTkdMRSIsCisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNw bGF5KSk7CiAgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGNvbnRleHQtPnJlYWNxdWlyZUhpZ2hQ b3dlckdQVSgpLCAiZWdsUmVhY3F1aXJlSGlnaFBvd2VyR1BVQU5HTEUiLAogICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogCkBAIC0xNjA3LDYgKzE2NjQsOCBA QCB2b2lkIEVHTEFQSUVOVFJZIEVHTF9IYW5kbGVHUFVTd2l0Y2hBTkdMRShFR0xEaXNwbGF5IGRw eSkKIAogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBWYWxpZGF0ZURpc3BsYXkoZGlzcGxheSks ICJlZ2xIYW5kbGVHUFVTd2l0Y2hBTkdMRSIsCiAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5 SWZWYWxpZChkaXNwbGF5KSk7CisgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPmJp bmRUaHJlYWQoKSwgImVnbFJlYWNxdWlyZUhpZ2hQb3dlckdQVUFOR0xFIiwKKyAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKICAgICBBTkdMRV9FR0xfVFJZKHRo cmVhZCwgZGlzcGxheS0+aGFuZGxlR1BVU3dpdGNoKCksICJlZ2xIYW5kbGVHUFVTd2l0Y2hBTkdM RSIsCiAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3VyYXRpb25zL1dlYkNvcmUueGNjb25maWcg Yi9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9XZWJDb3JlLnhjY29uZmlnCmluZGV4IDU3 MWU4ZWIwNzA2MGMxOTdjYzNlOTU0MTFiYmE0Mzc1N2U4NTFiNTkuLjUwZmY1NTg4NjAwOTY4MTdk YWVjODhjNWFjNmJjMTYzMjllNDFiMWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NvbmZp Z3VyYXRpb25zL1dlYkNvcmUueGNjb25maWcKKysrIGIvU291cmNlL1dlYkNvcmUvQ29uZmlndXJh dGlvbnMvV2ViQ29yZS54Y2NvbmZpZwpAQCAtNDgsNyArNDgsNyBAQCBXS19MSUJXRUJSVENfTElC UkFSWV9ESVJfVVNFX09WRVJSSURFX0ZSQU1FV09SS1NfRElSX1lFUyA9ICQoV0tfT1ZFUlJJREVf RlJBTUVXTwogTElCUkFSWV9TRUFSQ0hfUEFUSFMgPSAkKGluaGVyaXRlZCkgIiQoV0tfTElCV0VC UlRDX0xJQlJBUllfRElSKSI7CiAKIFdFQktJVEFERElUSU9OU19IRUFERVJfU0VBUkNIX1BBVEhT ID0gJChCVUlMVF9QUk9EVUNUU19ESVIpL3Vzci9sb2NhbC9pbmNsdWRlL1dlYktpdEFkZGl0aW9u cyAkKFNES1JPT1QpL3Vzci9sb2NhbC9pbmNsdWRlL1dlYktpdEFkZGl0aW9uczsKLUFOR0xFX0hF QURFUl9TRUFSQ0hfUEFUSFMgPSAkKEJVSUxUX1BST0RVQ1RTX0RJUikvdXNyL2xvY2FsL2luY2x1 ZGUvQU5HTEUgJChTREtST09UKS91c3IvbG9jYWwvaW5jbHVkZS9BTkdMRTsKK0FOR0xFX0hFQURF Ul9TRUFSQ0hfUEFUSFMgPSAkKEJVSUxUX1BST0RVQ1RTX0RJUikkKFdLX0FMVEVSTkFURV9GUkFN RVdPUktTX0RJUikvdXNyL2xvY2FsL2luY2x1ZGUvICQoU0RLUk9PVCkkKFdLX0FMVEVSTkFURV9X RUJLSVRfU0RLX1BBVEgpL3Vzci9sb2NhbC9pbmNsdWRlLzsKIExJQldFQlJUQ19IRUFERVJfU0VB UkNIX1BBVEhTID0gJChCVUlMVF9QUk9EVUNUU19ESVIpL3Vzci9sb2NhbC9pbmNsdWRlL3dlYnJ0 YyAkKFNES1JPT1QpL3Vzci9sb2NhbC9pbmNsdWRlL3dlYnJ0YyAkKEJVSUxUX1BST0RVQ1RTX0RJ UikvdXNyL2xvY2FsL2luY2x1ZGUvd2VicnRjL3Nkay9vYmpjL0ZyYW1ld29yay9IZWFkZXJzICQo U0RLUk9PVCkvdXNyL2xvY2FsL2luY2x1ZGUvd2VicnRjL3Nkay9vYmpjL0ZyYW1ld29yay9IZWFk ZXJzOwogCiBIRUFERVJfU0VBUkNIX1BBVEhTID0gUEFMIEZvcndhcmRpbmdIZWFkZXJzIC91c3Iv aW5jbHVkZS9saWJ4c2x0IC91c3IvaW5jbHVkZS9saWJ4bWwyICIkKEJVSUxUX1BST0RVQ1RTX0RJ UikvRGVyaXZlZFNvdXJjZXMvV2ViQ29yZSIgIiQoQlVJTFRfUFJPRFVDVFNfRElSKS91c3IvbG9j YWwvaW5jbHVkZSIgJChXRUJLSVRBRERJVElPTlNfSEVBREVSX1NFQVJDSF9QQVRIUykgJChBTkdM RV9IRUFERVJfU0VBUkNIX1BBVEhTKSAkKExJQldFQlJUQ19IRUFERVJfU0VBUkNIX1BBVEhTKSAk KEhFQURFUl9TRUFSQ0hfUEFUSFMpICQoU1JDUk9PVCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9QQUwvQ29uZmlndXJhdGlvbnMvUEFMLnhjY29uZmlnIGIvU291cmNlL1dlYkNvcmUvUEFM L0NvbmZpZ3VyYXRpb25zL1BBTC54Y2NvbmZpZwppbmRleCAzNDg1NmZhODI3MjUzYzY4OGQ3ZjE1 MDgxYzAxMzMxNGU4ZTYzYWQ1Li4xOGFiNTJlMGNjOTAzZGU2N2IwMTk2NTAwMzQwNGQwMjY3MzIz ZDI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ29uZmlndXJhdGlvbnMvUEFMLnhj Y29uZmlnCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9Db25maWd1cmF0aW9ucy9QQUwueGNjb25m aWcKQEAgLTI1LDcgKzI1LDcgQEAKICNpbmNsdWRlICJWZXJzaW9uLnhjY29uZmlnIgogI2luY2x1 ZGUgIldlYktpdFRhcmdldENvbmRpdGlvbmFscy54Y2NvbmZpZyIKIAotR0NDX1BSRVBST0NFU1NP Ul9ERUZJTklUSU9OUyA9ICQoREVCVUdfREVGSU5FUykgJChpbmhlcml0ZWQpOworR0NDX1BSRVBS T0NFU1NPUl9ERUZJTklUSU9OUyA9ICQoREVCVUdfREVGSU5FUykgR0xfU0lMRU5DRV9ERVBSRUNB VElPTiBHTEVTX1NJTEVOQ0VfREVQUkVDQVRJT04gJChpbmhlcml0ZWQpOwogCiBGUkFNRVdPUktf U0VBUkNIX1BBVEhTW3Nkaz1pcGhvbmUqXSA9ICQoRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19pb3Nf JChDT05GSUdVUkFUSU9OKSk7CiBGUkFNRVdPUktfU0VBUkNIX1BBVEhTX2lvc19EZWJ1ZyA9ICQo QlVJTFRfUFJPRFVDVFNfRElSKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BBTC9QQUwu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1BBTC9QQUwueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA4NzI5MGVmZmJjM2UyODBjM2JlYjkxNjkwNzU3MmJh MTBhYzZmZGQyLi5lODlhN2U4ZmRjOTM0ODljMjYxOTU4OGYwNDc1NGY2MzRhNDUzZjA1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvUEFMLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oK KysrIGIvU291cmNlL1dlYkNvcmUvUEFML1BBTC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBA IC0xNDIsNiArMTQyLDggQEAKIAkJNjNDN0VEQzcyMUFGQUUwNDAwNkE3Qjk5IC8qIE5TUHJvZ3Jl c3NTUEkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDYz RTM2OUY5MjFBRkE4M0YwMDFDMTRCQyAvKiBOU1Byb2dyZXNzU1BJLmggKi87IH07CiAJCTdBMzZE MEY5MjIzQUQ5QUIwMEIwNTIyRSAvKiBDb21tb25DcnlwdG9TUEkuaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDdBMzZEMEY4MjIzQUQ5QUIwMEIwNTIyRSAv KiBDb21tb25DcnlwdG9TUEkuaCAqLzsgfTsKIAkJN0EzQTZBODAyMENBREI0NzAwMzE3QUFFIC8q IE5TSW1hZ2VTUEkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDdBM0E2QTdGMjBDQURCNDYwMDMxN0FBRSAvKiBOU0ltYWdlU1BJLmggKi87IH07CisJCTdC QjM0QTA0MjUyMzY5MUIwMDAyOUQwOCAvKiBPcGVuR0xFU1NvZnRMaW5rQ29jb2EubW0gaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QkIzNEEwMjI1MjM2OTFC MDAwMjlEMDggLyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLm1tICovOyB9OworCQk3QkIzNEEwNTI1 MjM2OTFCMDAwMjlEMDggLyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QkIzNEEwMzI1MjM2OTFCMDAwMjlEMDgg LyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLmggKi87IH07CiAJCTkzREI3RDM3MjQ2MjZCQ0QwMDRC RDhBMyAvKiBOU1RleHRJbnB1dENvbnRleHRTUEkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzREI3RDM2MjQ2MjZCQ0MwMDRCRDhBMyAvKiBOU1RleHRJ bnB1dENvbnRleHRTUEkuaCAqLzsgfTsKIAkJOTNEQjdEM0EyNDYyNkY4NjAwNEJEOEEzIC8qIE5T VW5kb01hbmFnZXJTUEkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDkzREI3RDM5MjQ2MjZGODYwMDRCRDhBMyAvKiBOU1VuZG9NYW5hZ2VyU1BJLmggKi87 IH07CiAJCUExMDI2NTg5MUY1Njc0N0EwMEI0Qzg0NCAvKiBISVRvb2xib3hTUEkuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEExMDI2NTg4MUY1Njc0N0Ew MEI0Qzg0NCAvKiBISVRvb2xib3hTUEkuaCAqLzsgfTsKQEAgLTMzMiw2ICszMzQsOCBAQAogCQk2 M0UzNjlGOTIxQUZBODNGMDAxQzE0QkMgLyogTlNQcm9ncmVzc1NQSS5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBOU1Byb2dyZXNzU1BJLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdBMzZEMEY4 MjIzQUQ5QUIwMEIwNTIyRSAvKiBDb21tb25DcnlwdG9TUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gQ29tbW9uQ3J5cHRvU1BJLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCTdBM0E2QTdGMjBDQURCNDYwMDMxN0FBRSAvKiBOU0ltYWdlU1BJLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE5TSW1hZ2VTUEkuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJN0JCMzRBMDIyNTIzNjkxQjAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtD b2NvYS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IE9wZW5HTEVT U29mdExpbmtDb2NvYS5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJN0JCMzRBMDMy NTIzNjkxQjAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBPcGVuR0xFU1NvZnRMaW5rQ29jb2EuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJOTNEQjdEMzYyNDYyNkJDQzAwNEJEOEEzIC8qIE5TVGV4dElucHV0 Q29udGV4dFNQSS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBOU1RleHRJbnB1 dENvbnRleHRTUEkuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTNEQjdEMzkyNDYy NkY4NjAwNEJEOEEzIC8qIE5TVW5kb01hbmFnZXJTUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Yy5oOyBwYXRoID0gTlNVbmRvTWFuYWdlclNQSS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk5M0U1OTA5QzFGOTNCRjFFMDA2N0Y4Q0YgLyogVW5lbmNvZGFibGVIYW5kbGluZy5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBVbmVuY29kYWJsZUhhbmRsaW5nLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CkBAIC02NjAsNiArNjY0LDggQEAKIAkJCQlDREFDQjM1RjIzODczRTQ4MDAxOEQ3Q0Ug LyogTWVkaWFUb29sYm94U29mdExpbmsuaCAqLywKIAkJCQkzMTY0N0ZBRjI1MTc1OURDMDAxMEY4 RkIgLyogT3BlbkdMU29mdExpbmtDb2NvYS5oICovLAogCQkJCTMxNjQ3RkFFMjUxNzU5REIwMDEw RjhGQiAvKiBPcGVuR0xTb2Z0TGlua0NvY29hLm1tICovLAorCQkJCTdCQjM0QTAzMjUyMzY5MUIw MDAyOUQwOCAvKiBPcGVuR0xFU1NvZnRMaW5rQ29jb2EuaCAqLywKKwkJCQk3QkIzNEEwMjI1MjM2 OTFCMDAwMjlEMDggLyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLm1tICovLAogCQkJCUExRjYzQzlE MjFBNERCRjcwMDZGQjQzQiAvKiBQYXNzS2l0U29mdExpbmsuaCAqLywKIAkJCQlBMUY2M0M5RTIx QTREQkY3MDA2RkI0M0IgLyogUGFzc0tpdFNvZnRMaW5rLm1tICovLAogCQkJCTA3NjExREI0MjQz RkE1QkUwMEQ4MDcwNCAvKiBVc2FnZVRyYWNraW5nU29mdExpbmsuaCAqLywKQEAgLTc4Miw2ICs3 ODgsNyBAQAogCQkJCTBDMkRBMTFFMUYzQkU5RTAwMERCQzMxNyAvKiBDb3JlR3JhcGhpY3NTUEku aCBpbiBIZWFkZXJzICovLAogCQkJCTBDRjk5Q0E5MUY3Mzg0MzcwMDdFRTc5MyAvKiBDb3JlTWVk aWFTb2Z0TGluay5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEMyREEwNzIxRjMzQ0E4NDAwREJDMzE3 IC8qIENvcmVNZWRpYVNQSS5oIGluIEhlYWRlcnMgKi8sCisJCQkJN0JCMzRBMDUyNTIzNjkxQjAw MDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQUJD QTUzNjgyNDg5NURCOTAwMzYxQkZGIC8qIENvcmVNb3Rpb25TUEkuaCBpbiBIZWFkZXJzICovLAog CQkJCTBDMkRBMTQwMUYzQkVCNDkwMERCQzMxNyAvKiBDb3JlVGV4dFNQSS5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJMUNDRUU0RjUyMEQ4NzE5MzAwNDdCMDk3IC8qIENvcmVVSVNQSS5oIGluIEhlYWRl cnMgKi8sCkBAIC0xMDEwLDYgKzEwMTcsNyBAQAogCQkJCUEzQUI2RTUyMUYzRDFEQzUwMDlDMTRC MSAvKiBTbGVlcERpc2FibGVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUEzQUI2RTYwMUYzRDFF MzkwMDlDMTRCMSAvKiBTbGVlcERpc2FibGVyQ29jb2EuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ QTM3ODhFOUMxRjA1Qjc4MjAwNjc5NDI1IC8qIFNvdW5kLmNwcCBpbiBTb3VyY2VzICovLAorCQkJ CTdCQjM0QTA0MjUyMzY5MUIwMDAyOUQwOCAvKiBPcGVuR0xFU1NvZnRMaW5rQ29jb2EubW0gaW4g U291cmNlcyAqLywKIAkJCQlBMzc4OEU5RTFGMDVCNzhFMDA2Nzk0MjUgLyogU291bmRNYWMubW0g aW4gU291cmNlcyAqLywKIAkJCQlBM0FCNkU1NzFGM0QxRERCMDA5QzE0QjEgLyogU3lzdGVtU2xl ZXBMaXN0ZW5lci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBM0FCNkU2NTFGM0QyMTdGMDA5QzE0 QjEgLyogU3lzdGVtU2xlZXBMaXN0ZW5lck1hYy5tbSBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xFU1NvZnRMaW5rQ29jb2EuaCBi L1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdMRVNTb2Z0TGlua0NvY29hLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZGY1NTgxOWExZjZiOWZjNTE4NmYzNmI5NGVjYTc1YmViNDM1ZTkzMQotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdMRVNTb2Z0TGlu a0NvY29hLmgKQEAgLTAsMCArMSwzOSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwg REFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkK KworI2ltcG9ydCA8T3BlbkdMRVMvRUFHTC5oPgorI2ltcG9ydCA8T3BlbkdMRVMvRUFHTERyYXdh YmxlLmg+CisjaW1wb3J0IDxPcGVuR0xFUy9FQUdMSU9TdXJmYWNlLmg+CisjaW1wb3J0IDx3dGYv U29mdExpbmtpbmcuaD4KKworU09GVF9MSU5LX0ZSQU1FV09SS19GT1JfSEVBREVSKFBBTCwgT3Bl bkdMRVMpCisKK1NPRlRfTElOS19DTEFTU19GT1JfSEVBREVSKFBBTCwgRUFHTENvbnRleHQpCisK KyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xF U1NvZnRMaW5rQ29jb2EubW0gYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL2NvY29hL09wZW5HTEVT U29mdExpbmtDb2NvYS5tbQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jZmExYmZjM2MyM2ZkZjExZjNiZTcwMjk4ZmVi ZmZjMDg1MmE4ZjQzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvUEFML3BhbC9j b2NvYS9PcGVuR0xFU1NvZnRMaW5rQ29jb2EubW0KQEAgLTAsMCArMSwzOSBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMn JyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JT IEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUws CisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNF UlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICog KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9V VCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KworI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCisKKyNpbXBvcnQgPE9wZW5HTEVTL0VBR0wuaD4K KyNpbXBvcnQgPE9wZW5HTEVTL0VBR0xEcmF3YWJsZS5oPgorI2ltcG9ydCA8T3BlbkdMRVMvRUFH TElPU3VyZmFjZS5oPgorI2ltcG9ydCA8d3RmL1NvZnRMaW5raW5nLmg+CisKK1NPRlRfTElOS19G UkFNRVdPUktfRk9SX1NPVVJDRShQQUwsIE9wZW5HTEVTKQorCitTT0ZUX0xJTktfQ0xBU1NfRk9S X1NPVVJDRV9XSVRIX0VYUE9SVChQQUwsIE9wZW5HTEVTLCBFQUdMQ29udGV4dCwgUEFMX0VYUE9S VCkKKworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL2NvY29hL09w ZW5HTFNvZnRMaW5rQ29jb2EuaCBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdM U29mdExpbmtDb2NvYS5oCmluZGV4IDNkZTlkMzc2ZDdiNWJjY2EzOTAzY2ZhMTY2MTFkZDQ3NzBj YTU1YzUuLjFiZTQwZjc2MDE0MjRlZDI5NWZkYjNmMTcyNDhhZDg2MmVjNDFmZDggMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdMU29mdExpbmtDb2NvYS5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdMU29mdExpbmtDb2NvYS5oCkBA IC00NCw1ICs0NCw2IEBAIFNPRlRfTElOS19GVU5DVElPTl9GT1JfSEVBREVSKFBBTCwgT3BlbkdM LCBDR0xRdWVyeVJlbmRlcmVySW5mbywgQ0dMRXJyb3IsIChHTHVpCiBTT0ZUX0xJTktfRlVOQ1RJ T05fRk9SX0hFQURFUihQQUwsIE9wZW5HTCwgQ0dMUmVsZWFzZVBpeGVsRm9ybWF0LCB2b2lkLCAo Q0dMUGl4ZWxGb3JtYXRPYmogcGl4KSwgKHBpeCkpCiBTT0ZUX0xJTktfRlVOQ1RJT05fRk9SX0hF QURFUihQQUwsIE9wZW5HTCwgQ0dMU2V0VmlydHVhbFNjcmVlbiwgQ0dMRXJyb3IsIChDR0xDb250 ZXh0T2JqIGN0eCwgR0xpbnQgc2NyZWVuKSwgKGN0eCwgc2NyZWVuKSkKIFNPRlRfTElOS19GVU5D VElPTl9GT1JfSEVBREVSKFBBTCwgT3BlbkdMLCBDR0xVcGRhdGVDb250ZXh0LCBDR0xFcnJvciwg KENHTENvbnRleHRPYmogY3R4KSwgKGN0eCkpCitTT0ZUX0xJTktfRlVOQ1RJT05fRk9SX0hFQURF UihQQUwsIE9wZW5HTCwgQ0dMU2V0Q3VycmVudENvbnRleHQsIENHTEVycm9yLCAoQ0dMQ29udGV4 dE9iaiBjdHgpLCAoY3R4KSkKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q QUwvcGFsL2NvY29hL09wZW5HTFNvZnRMaW5rQ29jb2EubW0gYi9Tb3VyY2UvV2ViQ29yZS9QQUwv cGFsL2NvY29hL09wZW5HTFNvZnRMaW5rQ29jb2EubW0KaW5kZXggZTA2ZWUyZjA1ZjkxZjJkNTlj ZjBiZGI2ZTdhYWUyZWZlMmM1ZmQzYy4uOGMzNWUwOGM4ODdhODJiOTNkODkyODExNDEzYjg1OGU4 YzFhYjYxMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xT b2Z0TGlua0NvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdM U29mdExpbmtDb2NvYS5tbQpAQCAtNDQsNSArNDQsNiBAQCBTT0ZUX0xJTktfRlVOQ1RJT05fRk9S X1NPVVJDRShQQUwsIE9wZW5HTCwgQ0dMR2V0UGFyYW1ldGVyLCBDR0xFcnJvciwgKENHTENvbnRl eAogU09GVF9MSU5LX0ZVTkNUSU9OX0ZPUl9TT1VSQ0UoUEFMLCBPcGVuR0wsIENHTFF1ZXJ5UmVu ZGVyZXJJbmZvLCBDR0xFcnJvciwgKEdMdWludCBkaXNwbGF5X21hc2ssIENHTFJlbmRlcmVySW5m b09iaiAqcmVuZCwgR0xpbnQgKm5yZW5kKSwgKGRpc3BsYXlfbWFzaywgcmVuZCwgbnJlbmQpKQog U09GVF9MSU5LX0ZVTkNUSU9OX0ZPUl9TT1VSQ0UoUEFMLCBPcGVuR0wsIENHTFNldFZpcnR1YWxT Y3JlZW4sIENHTEVycm9yLCAoQ0dMQ29udGV4dE9iaiBjdHgsIEdMaW50IHNjcmVlbiksIChjdHgs IHNjcmVlbikpCiBTT0ZUX0xJTktfRlVOQ1RJT05fRk9SX1NPVVJDRShQQUwsIE9wZW5HTCwgQ0dM VXBkYXRlQ29udGV4dCwgQ0dMRXJyb3IsIChDR0xDb250ZXh0T2JqIGN0eCksIChjdHgpKQorU09G VF9MSU5LX0ZVTkNUSU9OX0ZPUl9TT1VSQ0UoUEFMLCBPcGVuR0wsIENHTFNldEN1cnJlbnRDb250 ZXh0LCBDR0xFcnJvciwgKENHTENvbnRleHRPYmogY3R4KSwgKGN0eCkpCiAKICNlbmRpZgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q IGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4 IDViOWJhOWNlOWQ5MDZhNWUwMmVhOGQwYmZjMzFkOGRiNDk4NThkZGIuLjBiZmRhYWVkZDUzOTM4 MTZlY2U5NjNkM2RiMGFiNzM1MzFlYjVmYzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dl YkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTIyMTgsNiArMjIxOCw3IEBACiAJCTdB RjlCMjA2MThDRkIyREYwMEM2NEJFRiAvKiBWVFRSZWdpb25MaXN0LmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QUY5QjIwMDE4Q0ZCMkRGMDBDNjRCRUYg LyogVlRUUmVnaW9uTGlzdC5oICovOyB9OwogCQk3QUY5QjIwRDE4Q0ZCNUY0MDBDNjRCRUYgLyog SlNWVFRSZWdpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDdBRjlCMjA5MThDRkI1RjIwMEM2NEJFRiAvKiBKU1ZUVFJlZ2lvbi5oICovOyB9OwogCQk3 QUY5QjIwRjE4Q0ZCNUY0MDBDNjRCRUYgLyogSlNWVFRSZWdpb25MaXN0LmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QUY5QjIwQjE4Q0ZCNUYzMDBDNjRC RUYgLyogSlNWVFRSZWdpb25MaXN0LmggKi87IH07CisJCTdCQjM0QTAxMjUyMzVDMzkwMDAyOUQw OCAvKiBPcGVuR0xFU1NvZnRMaW5rQ29jb2EuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDdCQjM0QTAwMjUyMzVDMzUwMDAyOUQwOCAvKiBPcGVuR0xFU1Nv ZnRMaW5rQ29jb2EuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9 OyB9OwogCQk3QkU3NDI3MzgxRkE5MDZGQkI0RjBGMkMgLyogSlNTVkdHcmFwaGljc0VsZW1lbnQu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDk1MEM0QzAy QkVEODkzNkY4MThFMkY5OSAvKiBKU1NWR0dyYXBoaWNzRWxlbWVudC5oICovOyB9OwogCQk3QzAy OUM2RTI0OTNDOEY4MDAyNjgyMDQgLyogQ29sb3JUeXBlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0MwMjlDNkQyNDkzQzhGODAwMjY4MjA0IC8qIENv bG9yVHlwZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQk3QzE4NDNGRTFDOEI3MjgzMDAyRUI5NzMgLyogQXV0b2ZpbGwuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDdDMTg0M0ZDMUM4QjcyODMwMDJFQjk3 MyAvKiBBdXRvZmlsbC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7 IH07IH07CkBAIC0xMDA1MSw2ICsxMDA1Miw4IEBACiAJCTdBRjlCMjA5MThDRkI1RjIwMEM2NEJF RiAvKiBKU1ZUVFJlZ2lvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU1ZU VFJlZ2lvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3QUY5QjIwQTE4Q0ZCNUYz MDBDNjRCRUYgLyogSlNWVFRSZWdpb25MaXN0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IEpTVlRUUmVnaW9uTGlzdC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCTdBRjlCMjBCMThDRkI1RjMwMEM2NEJFRiAvKiBKU1ZUVFJlZ2lvbkxpc3QuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNWVFRSZWdpb25MaXN0Lmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTdCQjM0OUZGMjUyMzVDMzQwMDAyOUQwOCAvKiBPcGVuR0xF U1NvZnRMaW5rQ29jb2EubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IG5hbWUgPSBPcGVuR0xFU1NvZnRMaW5r Q29jb2EubW07IHBhdGggPSBQQUwvcGFsL2NvY29hL09wZW5HTEVTU29mdExpbmtDb2NvYS5tbTsg c291cmNlVHJlZSA9IFNPVVJDRV9ST09UOyB9OworCQk3QkIzNEEwMDI1MjM1QzM1MDAwMjlEMDgg LyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IE9wZW5HTEVTU29mdExp bmtDb2NvYS5oOyBwYXRoID0gUEFML3BhbC9jb2NvYS9PcGVuR0xFU1NvZnRMaW5rQ29jb2EuaDsg c291cmNlVHJlZSA9IFNPVVJDRV9ST09UOyB9OwogCQk3QzAxMUYzRDI0RkFEMzYwMDA1QkVGMTAg LyogU2V0dGluZ3MuY3BwLmVyYiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25v d25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBTZXR0aW5ncy5jcHAuZXJiOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk3QzAxMUYzRTI0RkFEMzYwMDA1QkVGMTAgLyogSW50ZXJuYWxTZXR0 aW5nc0dlbmVyYXRlZC5jcHAuZXJiICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RL bm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IEludGVybmFsU2V0dGluZ3NHZW5lcmF0ZWQuY3Bw LmVyYjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJN0MwMTFGM0YyNEZBRDM2MDAwNUJF RjEwIC8qIEludGVybmFsU2V0dGluZ3NHZW5lcmF0ZWQuaWRsLmVyYiAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBJbnRlcm5hbFNl dHRpbmdzR2VuZXJhdGVkLmlkbC5lcmI7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0y NjM0MCw2ICsyNjM0Myw4IEBACiAJCQkJQUQ5RkY2RTAxOTA4MzkxRDAwM0I2MUUwIC8qIElPU3Vy ZmFjZVBvb2xDb2NvYS5tbSAqLywKIAkJCQlDREM0OEFDODIxNDlDRjJBMDAyNEZENTkgLyogTWVk aWFFbmdpbmVDb25maWd1cmF0aW9uRmFjdG9yeUNvY29hLmNwcCAqLywKIAkJCQlDREM0OEFDNzIx NDlDRjJBMDAyNEZENTkgLyogTWVkaWFFbmdpbmVDb25maWd1cmF0aW9uRmFjdG9yeUNvY29hLmgg Ki8sCisJCQkJN0JCMzRBMDAyNTIzNUMzNTAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2Nv YS5oICovLAorCQkJCTdCQjM0OUZGMjUyMzVDMzQwMDAyOUQwOCAvKiBPcGVuR0xFU1NvZnRMaW5r Q29jb2EubW0gKi8sCiAJCQkJMzE2NDdGQTgyNTE2MTZCRDAwMTBGOEZCIC8qIE9wZW5HTFNvZnRM aW5rQ29jb2EuaCAqLywKIAkJCQkzMTY0N0ZBOTI1MTYxNkJEMDAxMEY4RkIgLyogT3BlbkdMU29m dExpbmtDb2NvYS5tbSAqLywKIAkJCQlDREVCM0Q3MjI0QzQxQTZFMDAxRkJFRUYgLyogU291cmNl QnVmZmVyUGFyc2VyLmNwcCAqLywKQEAgLTMxMjIzLDYgKzMxMjI4LDcgQEAKIAkJCQlGRDZFRDJD NDEzNkI4RTQyMDAzQ0YwNzIgLyogRHluYW1pY3NDb21wcmVzc29yTm9kZS5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJODM3QzBCNzYyNERCMzg1MDAwNUQ1OTU5IC8qIER5bmFtaWNzQ29tcHJlc3Nvck9w dGlvbnMuaCBpbiBIZWFkZXJzICovLAogCQkJCTkzMzA5REUyMDk5RTY0OTIwMDU2RTU4MSAvKiBF ZGl0QWN0aW9uLmggaW4gSGVhZGVycyAqLywKKwkJCQk3QkIzNEEwMTI1MjM1QzM5MDAwMjlEMDgg LyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLmggaW4gSGVhZGVycyAqLywKIAkJCQk5MzMwOURFNDA5 OUU2NDkyMDA1NkU1ODEgLyogRWRpdENvbW1hbmQuaCBpbiBIZWFkZXJzICovLAogCQkJCTkzMzA5 REU4MDk5RTY0OTIwMDU2RTU4MSAvKiBFZGl0aW5nLmggaW4gSGVhZGVycyAqLywKIAkJCQk0RjE1 MzRERTExQjUzMkVDMDAyMUZEODYgLyogRWRpdGluZ0JlaGF2aW9yLmggaW4gSGVhZGVycyAqLywK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29u dGV4dEdMLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRl eHRHTC5oCmluZGV4IGZhMjQxYmJlOGMzZjE3MjMwNWIxZjQ4MGJhMmYzOThjY2Q3MjEzMmQuLjVh OTVkZTNlYTVjZWJiYjg4YWZhMGMxMWE0ZjI3ZTczZjVmMGYyNDkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dEdMLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0R0wuaApAQCAtNDcs NiArNDcsOCBAQCB0eXBlZGVmIHZvaWQqIFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0R0w7CiB0eXBl ZGVmIHZvaWQqIFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0R0xEaXNwbGF5OwogdHlwZWRlZiB2b2lk KiBQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dEdMU3VyZmFjZTsKIHR5cGVkZWYgdm9pZCogUGxhdGZv cm1HcmFwaGljc0NvbnRleHRHTENvbmZpZzsKK3R5cGVkZWYgdm9pZCogUGxhdGZvcm1HcmFwaGlj c0NvbnRleHRHTERldmljZUNvbnRleHQ7CisKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogY2xhc3Mg RXh0ZW5zaW9uc0dMOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY29jb2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xDb2NvYS5tbSBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW0K aW5kZXggYzIyMWMxNDYxNTM3ZWI5ZTgwNzcyNDZiMzlkYjg3ZjM1NDNmODc4My4uOWE1NTVmMDJm Y2EzZjljNjI0MGMzMzkwZjkzOGM2YTdiZmEzMTA0NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xDb2NvYS5t bQorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGljc0Nv bnRleHRHTE9wZW5HTENvY29hLm1tCkBAIC04MCw2ICs4MCw4IEBAIHR5cGVkZWYgdm9pZCogR0xl Z2xDb250ZXh0OwogI2ltcG9ydCAiRXh0ZW5zaW9uc0dMT3BlbkdMLmgiCiAjZWxpZiBVU0UoQU5H TEUpCiAjaW1wb3J0ICJFeHRlbnNpb25zR0xBTkdMRS5oIgorI2ltcG9ydCAiUnVudGltZUFwcGxp Y2F0aW9uQ2hlY2tzLmgiCisjaW1wb3J0ICJXZWJDb3JlVGhyZWFkLmgiCiAjZW5kaWYKIAogI2lm IFBMQVRGT1JNKE1BQykKQEAgLTkxLDYgKzkzLDY5IEBAIHR5cGVkZWYgdm9pZCogR0xlZ2xDb250 ZXh0OwogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK25hbWVzcGFjZSB7CisKKyNpZiBVU0UoQU5H TEUpCisKKyNpZiBBU1NFUlRfRU5BQkxFRAorLy8gUmV0dXJucyB0cnVlIGlmIHdlIGhhdmUgdm9s YXRpbGUgY29udGV4dCBleHRlbnNpb24gZm9yIHRoZSBwYXJ0aWN1bGFyIEFQSSBvcgorLy8gaWYg dGhlIHBhcnRpY3VsYXIgQVBJIGlzIG5vdCB1c2VkLgorYm9vbCBjaGVja1ZvbGF0aWxlQ29udGV4 dFN1cHBvcnRJZkRldmljZUV4aXN0cyhFR0xEaXNwbGF5IGRpc3BsYXksIGNvbnN0IGNoYXIqIGRl dmljZUNvbnRleHRWb2xhdGlsZUV4dGVuc2lvbiwKKyAgICBjb25zdCBjaGFyKiBkZXZpY2VDb250 ZXh0RXh0ZW5zaW9uLCBFR0xpbnQgZGV2aWNlQ29udGV4dFR5cGUpCit7CisgICAgY29uc3QgY2hh ciAqY2xpZW50RXh0ZW5zaW9ucyA9IEVHTF9RdWVyeVN0cmluZyhFR0xfTk9fRElTUExBWSwgRUdM X0VYVEVOU0lPTlMpOworICAgIGlmIChjbGllbnRFeHRlbnNpb25zICYmIHN0cnN0cihjbGllbnRF eHRlbnNpb25zLCBkZXZpY2VDb250ZXh0Vm9sYXRpbGVFeHRlbnNpb24pKQorICAgICAgICByZXR1 cm4gdHJ1ZTsKKyAgICBFR0xEZXZpY2VFWFQgZGV2aWNlID0gRUdMX05PX0RFVklDRV9FWFQ7Cisg ICAgaWYgKCFFR0xfUXVlcnlEaXNwbGF5QXR0cmliRVhUKGRpc3BsYXksIEVHTF9ERVZJQ0VfRVhU LCByZWludGVycHJldF9jYXN0PEVHTEF0dHJpYio+KCZkZXZpY2UpKSkKKyAgICAgICAgcmV0dXJu IHRydWU7CisgICAgaWYgKGRldmljZSA9PSBFR0xfTk9fREVWSUNFX0VYVCkKKyAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgY29uc3QgY2hhciogZGV2aWNlRXh0ZW5zaW9ucyA9IEVHTF9RdWVyeURl dmljZVN0cmluZ0VYVChkZXZpY2UsIEVHTF9FWFRFTlNJT05TKTsKKyAgICBpZiAoIWRldmljZUV4 dGVuc2lvbnMgfHwgIXN0cnN0cihkZXZpY2VFeHRlbnNpb25zLCBkZXZpY2VDb250ZXh0RXh0ZW5z aW9uKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgdm9pZCogZGV2aWNlQ29udGV4dCA9IG51 bGxwdHI7CisgICAgaWYgKCFFR0xfUXVlcnlEZXZpY2VBdHRyaWJFWFQoZGV2aWNlLCBkZXZpY2VD b250ZXh0VHlwZSwgcmVpbnRlcnByZXRfY2FzdDxFR0xBdHRyaWIqPigmZGV2aWNlQ29udGV4dCkp KQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICByZXR1cm4gIWRldmljZUNvbnRleHQ7Cit9Cisj ZW5kaWYKKworRUdMRGlzcGxheSBJbml0aWFsaXplRUdMRGlzcGxheSgpCit7CisgICAgRUdMaW50 IG1ham9yVmVyc2lvbiA9IDA7CisgICAgRUdMaW50IG1pbm9yVmVyc2lvbiA9IDA7CisgICAgRUdM RGlzcGxheSBkaXNwbGF5OworICAgIGJvb2wgc2hvdWxkSW5pdGlhbGl6ZVdpdGhWb2xhdGlsZUNv bnRleHRTdXBwb3J0ID0gIWlzSW5XZWJQcm9jZXNzKCk7CisgICAgaWYgKHNob3VsZEluaXRpYWxp emVXaXRoVm9sYXRpbGVDb250ZXh0U3VwcG9ydCkgeworICAgICAgICAvLyBGb3IgV0sxIHR5cGUg QVBJcyB3ZSBuZWVkIHRvIHNldCAidm9sYXRpbGUgcGxhdGZvcm0gY29udGV4dCIgZm9yIHNwZWNp ZmljCisgICAgICAgIC8vIEFQSXMsIHNpbmNlIGNsaWVudCBjb2RlIHdpbGwgYmUgYWJsZSB0byBv dmVycmlkZSB0aGUgdGhyZWFkLWdsb2JhbCBjb250ZXh0CisgICAgICAgIC8vIHRoYXQgQU5HTEUg ZXhwZWN0cy4KKyAgICAgICAgRUdMaW50IGRpc3BsYXlBdHRyaWJ1dGVzW10gPSB7CisgICAgICAg ICAgICBFR0xfUExBVEZPUk1fQU5HTEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfRUFHTF9BTkdM RSwgRUdMX1RSVUUsCisgICAgICAgICAgICBFR0xfUExBVEZPUk1fQU5HTEVfREVWSUNFX0NPTlRF WFRfVk9MQVRJTEVfQ0dMX0FOR0xFLCBFR0xfVFJVRSwKKyAgICAgICAgICAgIEVHTF9OT05FCisg ICAgICAgIH07CisgICAgICAgIGRpc3BsYXkgPSBFR0xfR2V0UGxhdGZvcm1EaXNwbGF5RVhUKEVH TF9QTEFURk9STV9BTkdMRV9BTkdMRSwgcmVpbnRlcnByZXRfY2FzdDx2b2lkICo+KEVHTF9ERUZB VUxUX0RJU1BMQVkpLCBkaXNwbGF5QXR0cmlidXRlcyk7CisgICAgfSBlbHNlCisgICAgICAgIGRp c3BsYXkgPSBFR0xfR2V0RGlzcGxheShFR0xfREVGQVVMVF9ESVNQTEFZKTsKKworICAgIGlmIChF R0xfSW5pdGlhbGl6ZShkaXNwbGF5LCAmbWFqb3JWZXJzaW9uLCAmbWlub3JWZXJzaW9uKSA9PSBF R0xfRkFMU0UpIHsKKyAgICAgICAgTE9HKFdlYkdMLCAiRUdMRGlzcGxheSBJbml0aWFsaXphdGlv biBmYWlsZWQuIik7CisgICAgICAgIHJldHVybiBFR0xfTk9fRElTUExBWTsKKyAgICB9CisgICAg TE9HKFdlYkdMLCAiQU5HTEUgaW5pdGlhbGlzZWQgTWFqb3I6ICVkIE1pbm9yOiAlZCIsIG1ham9y VmVyc2lvbiwgbWlub3JWZXJzaW9uKTsKKyAgICBpZiAoc2hvdWxkSW5pdGlhbGl6ZVdpdGhWb2xh dGlsZUNvbnRleHRTdXBwb3J0KSB7CisgICAgICAgIC8vIEFmdGVyIGluaXRpYWxpeml0YWlvbiwg RUdMX0RFRkFVTFRfRElTUExBWSB3aWxsIHJldHVybiB0aGUgcGxhdGZvcm0tY3VzdG9taXplZCBk aXNwbGF5LgorICAgICAgICBBU1NFUlQoZGlzcGxheSA9PSBFR0xfR2V0RGlzcGxheShFR0xfREVG QVVMVF9ESVNQTEFZKSk7CisgICAgICAgIEFTU0VSVChjaGVja1ZvbGF0aWxlQ29udGV4dFN1cHBv cnRJZkRldmljZUV4aXN0cyhkaXNwbGF5LCAiRUdMX0FOR0xFX3BsYXRmb3JtX2RldmljZV9jb250 ZXh0X3ZvbGF0aWxlX2VhZ2wiLCAiRUdMX0FOR0xFX2RldmljZV9lYWdsIiwgRUdMX0VBR0xfQ09O VEVYVF9BTkdMRSkpOworICAgICAgICBBU1NFUlQoY2hlY2tWb2xhdGlsZUNvbnRleHRTdXBwb3J0 SWZEZXZpY2VFeGlzdHMoZGlzcGxheSwgIkVHTF9BTkdMRV9wbGF0Zm9ybV9kZXZpY2VfY29udGV4 dF92b2xhdGlsZV9jZ2wiLCAiRUdMX0FOR0xFX2RldmljZV9jZ2wiLCBFR0xfQ0dMX0NPTlRFWFRf QU5HTEUpKTsKKyAgICB9CisgICAgcmV0dXJuIGRpc3BsYXk7Cit9CisjZW5kaWYKK30KKwogc3Rh dGljIGNvbnN0IHVuc2lnbmVkIHN0YXR1c0NoZWNrVGhyZXNob2xkID0gNTsKIAogLy8gRklYTUU6 IFRoaXMgY2xhc3MgaXMgY3VycmVudGx5IGVtcHR5IG9uIE1hYywgYnV0IHdpbGwgZ2V0IHBvcHVs YXRlZCBhcwpAQCAtMzE2LDE2ICszODEsOSBAQCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6R3Jh cGhpY3NDb250ZXh0R0xPcGVuR0woR3JhcGhpY3NDb250ZXh0R0xBdHRyaWJ1dGVzIGF0dAogICAg ICAgICA6OmdsRW5hYmxlKEdyYXBoaWNzQ29udGV4dEdMOjpQUklNSVRJVkVfUkVTVEFSVCk7CiAK ICNlbGlmIFVTRShBTkdMRSkKLQotICAgIG1fZGlzcGxheU9iaiA9IEVHTF9HZXREaXNwbGF5KEVH TF9ERUZBVUxUX0RJU1BMQVkpOworICAgIG1fZGlzcGxheU9iaiA9IEluaXRpYWxpemVFR0xEaXNw bGF5KCk7CiAgICAgaWYgKG1fZGlzcGxheU9iaiA9PSBFR0xfTk9fRElTUExBWSkKICAgICAgICAg cmV0dXJuOwotICAgIEVHTGludCBtYWpvclZlcnNpb24sIG1pbm9yVmVyc2lvbjsKLSAgICBpZiAo RUdMX0luaXRpYWxpemUobV9kaXNwbGF5T2JqLCAmbWFqb3JWZXJzaW9uLCAmbWlub3JWZXJzaW9u KSA9PSBFR0xfRkFMU0UpIHsKLSAgICAgICAgTE9HKFdlYkdMLCAiRUdMRGlzcGxheSBJbml0aWFs aXphdGlvbiBmYWlsZWQuIik7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0gICAgTE9HKFdlYkdM LCAiQU5HTEUgaW5pdGlhbGlzZWQgTWFqb3I6ICVkIE1pbm9yOiAlZCIsIG1ham9yVmVyc2lvbiwg bWlub3JWZXJzaW9uKTsKICAgICBjb25zdCBjaGFyICpkaXNwbGF5RXh0ZW5zaW9ucyA9IEVHTF9R dWVyeVN0cmluZyhtX2Rpc3BsYXlPYmosIEVHTF9FWFRFTlNJT05TKTsKICAgICBMT0coV2ViR0ws ICJFeHRlbnNpb25zOiAlcyIsIGRpc3BsYXlFeHRlbnNpb25zKTsKIApAQCAtNTc4LDE3ICs2MzYs MTMgQEAgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6On5HcmFwaGljc0NvbnRleHRHTE9wZW5HTCgp CiAKICAgICBpZiAobV9jb250ZXh0T2JqKSB7CiAgICAgICAgIEdyYXBoaWNzQ29udGV4dEdMQXR0 cmlidXRlcyBhdHRycyA9IGNvbnRleHRBdHRyaWJ1dGVzKCk7Ci0KKyAgICAgICAgbWFrZUNvbnRl eHRDdXJyZW50KCk7IC8vIFRPRE86IGNoZWNrIHJlc3VsdC4KICNpZiBVU0UoT1BFTkdMX0VTKQot ICAgICAgICBtYWtlQ29udGV4dEN1cnJlbnQoKTsKICAgICAgICAgW3N0YXRpY19jYXN0PEVBR0xD b250ZXh0ICo+KG1fY29udGV4dE9iaikgcmVuZGVyYnVmZmVyU3RvcmFnZTpHTF9SRU5ERVJCVUZG RVIgZnJvbURyYXdhYmxlOm5pbF07CiAgICAgICAgIDo6Z2xEZWxldGVSZW5kZXJidWZmZXJzKDEs ICZtX3RleHR1cmUpOwogI2VsaWYgVVNFKE9QRU5HTCkKLSAgICAgICAgQ0dMQ29udGV4dE9iaiBj Z2xDb250ZXh0ID0gc3RhdGljX2Nhc3Q8Q0dMQ29udGV4dE9iaj4obV9jb250ZXh0T2JqKTsKLSAg ICAgICAgQ0dMU2V0Q3VycmVudENvbnRleHQoY2dsQ29udGV4dCk7CiAgICAgICAgIDo6Z2xEZWxl dGVUZXh0dXJlcygxLCAmbV90ZXh0dXJlKTsKICNlbGlmIFVTRShBTkdMRSkKLSAgICAgICAgRUdM X01ha2VDdXJyZW50KG1fZGlzcGxheU9iaiwgRUdMX05PX1NVUkZBQ0UsIEVHTF9OT19TVVJGQUNF LCBtX2NvbnRleHRPYmopOwogICAgICAgICBnbDo6RGVsZXRlVGV4dHVyZXMoMSwgJm1fdGV4dHVy ZSk7CiAjZW5kaWYKIApAQCAtNzA3LDEyICs3NjEsNTIgQEAgYm9vbCBHcmFwaGljc0NvbnRleHRH TE9wZW5HTDo6bWFrZUNvbnRleHRDdXJyZW50KCkKICAgICBpZiAoY3VycmVudENvbnRleHQgIT0g bV9jb250ZXh0T2JqKQogICAgICAgICByZXR1cm4gQ0dMU2V0Q3VycmVudENvbnRleHQoc3RhdGlj X2Nhc3Q8Q0dMQ29udGV4dE9iaj4obV9jb250ZXh0T2JqKSkgPT0ga0NHTE5vRXJyb3I7CiAjZWxp ZiBVU0UoQU5HTEUpCi0gICAgaWYgKEVHTF9HZXRDdXJyZW50Q29udGV4dCgpICE9IG1fY29udGV4 dE9iaikKLSAgICAgICAgcmV0dXJuIEVHTF9NYWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVHTF9O T19TVVJGQUNFLCBFR0xfTk9fU1VSRkFDRSwgbV9jb250ZXh0T2JqKTsKKyAgICAvLyBBTkdMRSBo YXMgYW4gZWFybHkgb3V0IGZvciBjYXNlIHdoZXJlIG5vdGhpbmcgY2hhbmdlcy4gQ2FsbGluZyBN YWtlQ3VycmVudCBpbnN0ZWFkIG9mCisgICAgLy8gR2V0Q3VycmVudENvbnRleHQgaXMgaW1wb3J0 YW50OgorICAgIC8vICogVm9sYXRpbGUgcGxhdGZvcm0gY29udGV4dHMgZ2V0IHNldCAoc2VlIElu aXRpYWxpemVFR0xEaXNwbGF5KCkuCisgICAgLy8gKiB0aGVvcmV0aWNhbCBpbXBvcnRhbmNlIGR1 ZSB0byBSZWxlYXNlVGhyZWFkIHJlc2V0dGluZyBBUEkgYmluZGluZy4KKyAgICBpZiAoIUVHTF9N YWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVHTF9OT19TVVJGQUNFLCBFR0xfTk9fU1VSRkFDRSwg bV9jb250ZXh0T2JqKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogI2VuZGlmCiAgICAgcmV0dXJu IHRydWU7CiB9CiAKKyNpZiBQTEFURk9STShJT1NfRkFNSUxZKSAmJiBVU0UoQU5HTEUpCitib29s IEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxlYXNlQ3VycmVudENvbnRleHRJZk5lZWRlZCgp Cit7CisgICAgQVNTRVJUKCFXZWJDb3JlOjppc0luV2ViUHJvY2VzcygpKTsKKyAgICAvLyBJbiBz aW5nbGUtdGhyZWFkZWQgZW52aXJvbm1lbnRzIHdlIGRvIG5vdCBuZWVkIHRvIHVuc2V0IEVHTCBj b250ZXh0LCBhcyB0aGVyZSBzaG91bGQgbm90IGJlIGFjY2VzcyBmcm9tCisgICAgLy8gbXVsdGlw bGUgdGhyZWFkcy4KKyAgICBpZiAoIVdlYlRocmVhZElzRW5hYmxlZCgpKQorICAgICAgICByZXR1 cm4gdHJ1ZTsKKworICAgIEVHTGVudW0gYm91bmRBUEkgPSBFR0xfUXVlcnlBUEkoKTsKKyAgICBp ZiAoYm91bmRBUEkgPT0gRUdMX09QRU5HTF9FU19BUEkgJiYgRUdMX0dldEN1cnJlbnRDb250ZXh0 KCkgPT0gRUdMX05PX0NPTlRFWFQpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgLy8gVW5z ZXQgdGhlIEVHTCBjdXJyZW50IGNvbnRleHQsIHNpbmNlIHRoZSBuZXh0IGFjY2VzcyBtaWdodCBi ZSBmcm9tIGFub3RoZXIgdGhyZWFkLCBhbmQgdGhlCisgICAgLy8gY29udGV4dCBjYW5ub3QgYmUg Y3VycmVudCBvbiBtdWx0aXBsZSB0aHJlYWRzLgorCisgICAgaWYgKCFXZWJUaHJlYWRJc0N1cnJl bnQoKSkgeworICAgICAgICAvLyBUaGUgY2FsbCBpcyBmcm9tIG1haW4gdGhyZWFkLiBXZSBkbyBu b3Qga25vdyB3aGVuLCBpZiBldmVyLCB0aGUgbmV4dCBjYWxsIGNvbWVzIGluIHRoaXMgdGhyZWFk LgorICAgICAgICAvLyBVbnNldCB0aGUgRUdMIGN1cnJlbnQgY29udGV4dCBieSByZWxlYXNpbmcg d2hvbGUgRUdMIHRocmVhZCBzdGF0ZS4KKyAgICAgICAgLy8gVGhlb3JldGljYWxseSBSZWxlYXNl VGhyZWFkIGNhbiByZXNldCB0aGUgYm91bmQgQVBJLCBzbyByZXN0IG9mIHRoZSBjb2RlIG1lbnRp b25zIEJpbmRBUEkvUXVlcnlBUEkuCisgICAgICAgIHJldHVybiBFR0xfUmVsZWFzZVRocmVhZCgp OworICAgIH0KKyAgICAvLyBPbiBXZWJLaXQgb3duZWQgdGhyZWFkcywgV2ViS2l0IGlzIGFibGUg dG8gY2hvb3NlIHRoZSB0aW1lIGZvciB0aGUgRUdMIGNsZWFudXAuCisgICAgLy8gVGhpcyBpcyB3 aHkgd2Ugb25seSB1bnNldCB0aGUgY29udGV4dC4KKyAgICAvLyBOb3RlOiBBdCB0aGUgdGltZSBv ZiB3cml0aW5nIHRoZSBFR0wgY2xlYW51cCBpcyBjaG9zZW4gdG8gYmUgbm90IGRvbmUgYXQgYWxs LgorICAgIEVHTERpc3BsYXkgZGlzcGxheSA9IEVHTF9HZXREaXNwbGF5KEVHTF9ERUZBVUxUX0RJ U1BMQVkpOworICAgIGlmIChkaXNwbGF5ID09IEVHTF9OT19ESVNQTEFZKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgaWYgKGJvdW5kQVBJICE9IEVHTF9PUEVOR0xfRVNfQVBJKSB7CisgICAg ICAgIGlmICghRUdMX0JpbmRBUEkoRUdMX09QRU5HTF9FU19BUEkpKQorICAgICAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgIH0KKyAgICByZXR1cm4gRUdMX01ha2VDdXJyZW50KGRpc3BsYXksIEVH TF9OT19TVVJGQUNFLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX0NPTlRFWFQpOworfQorI2VuZGlm CisKIHZvaWQgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OmNoZWNrR1BVU3RhdHVzKCkKIHsKICAg ICBpZiAobV9mYWlsTmV4dFN0YXR1c0NoZWNrKSB7CkBAIC03MjQsNiArODE4LDcgQEAgdm9pZCBH cmFwaGljc0NvbnRleHRHTE9wZW5HTDo6Y2hlY2tHUFVTdGF0dXMoKQogI2VsaWYgVVNFKE9QRU5H TF9FUykKICAgICAgICAgW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0OjBdOwogI2VsaWYg VVNFKEFOR0xFKQorICAgICAgICBFR0xfQmluZEFQSShFR0xfT1BFTkdMX0VTX0FQSSk7CiAgICAg ICAgIEVHTF9NYWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVHTF9OT19TVVJGQUNFLCBFR0xfTk9f U1VSRkFDRSwgRUdMX05PX0NPTlRFWFQpOwogI2VuZGlmCiAgICAgICAgIHJldHVybjsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0Nv bnRleHRHTE9wZW5HTC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3Blbmds L0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmgKaW5kZXggZTljYzRmYWNkMjAzMmY5ZWUzMTExYTg1 NDM1MDMxMDU1NjU5N2FiYy4uMzVhMDVhODM1YzM1YjIxNjc2MjdkZTQ0MGIyMTBhNGY2ZTEwMjlj NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dy YXBoaWNzQ29udGV4dEdMT3BlbkdMLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmgKQEAgLTExOSw2ICsxMTksOSBA QCBwdWJsaWM6CiAjZW5kaWYKIAogICAgIGJvb2wgbWFrZUNvbnRleHRDdXJyZW50KCk7CisjaWYg UExBVEZPUk0oSU9TX0ZBTUlMWSkgJiYgVVNFKEFOR0xFKQorICAgIHN0YXRpYyBib29sIHJlbGVh c2VDdXJyZW50Q29udGV4dElmTmVlZGVkKCk7CisjZW5kaWYKIAogICAgIHZvaWQgYWRkQ2xpZW50 KENsaWVudCYgY2xpZW50KSB7IG1fY2xpZW50cy5hZGQoJmNsaWVudCk7IH0KICAgICB2b2lkIHJl bW92ZUNsaWVudChDbGllbnQmIGNsaWVudCkgeyBtX2NsaWVudHMucmVtb3ZlKCZjbGllbnQpOyB9 CkBAIC01NTAsNyArNTUzLDcgQEAgcHVibGljOgogI2lmIFVTRShPUEVOR0wpIHx8IFVTRShBTkdM RSkKICAgICBib29sIGFsbG9jYXRlSU9TdXJmYWNlQmFja2luZ1N0b3JlKEludFNpemUpOwogICAg IHZvaWQgdXBkYXRlRnJhbWVidWZmZXJUZXh0dXJlQmFja2luZ1N0b3JlRnJvbUxheWVyKCk7Ci0j aWYgUExBVEZPUk0oTUFDKSB8fCBQTEFURk9STShNQUNDQVRBTFlTVCkKKyNpZiBQTEFURk9STShN QUMpCiAgICAgdm9pZCB1cGRhdGVDR0xDb250ZXh0KCk7CiAjZW5kaWYKICNlbmRpZgpAQCAtNzAz LDYgKzcwNiw3IEBAIHByaXZhdGU6CiAjaWYgVVNFKEFOR0xFKQogICAgIFBsYXRmb3JtR3JhcGhp Y3NDb250ZXh0R0xEaXNwbGF5IG1fZGlzcGxheU9iaiB7IG51bGxwdHIgfTsKICAgICBQbGF0Zm9y bUdyYXBoaWNzQ29udGV4dEdMQ29uZmlnIG1fY29uZmlnT2JqIHsgbnVsbHB0ciB9OworICAgIFBs YXRmb3JtR3JhcGhpY3NDb250ZXh0R0xEZXZpY2VDb250ZXh0IG1fZGV2aWNlQ29udGV4dE9iaiB7 IG51bGxwdHIgfTsKICNlbmRpZiAvLyBVU0UoQU5HTEUpCiAjZW5kaWYgLy8gUExBVEZPUk0oQ09D T0EpCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2lvcy93YWsvV2ViQ29y ZVRocmVhZC5tbSBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2lvcy93YWsvV2ViQ29yZVRocmVh ZC5tbQppbmRleCA1YWQ3ZmU1MTk4ZDI0YzMwMzY2YTIzMGEwOTczMjRjNGEyNWM2OTRkLi42MDE2 NTUyNTkwYjk5MzMyNjZhMmRiMGM5ZjQwMjQ4YWFiMTEyNjc4IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9pb3Mvd2FrL1dlYkNvcmVUaHJlYWQubW0KKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vaW9zL3dhay9XZWJDb3JlVGhyZWFkLm1tCkBAIC0zMCw2ICszMCw3IEBA CiAKICNpbXBvcnQgIkNvbW1vblZNLmgiCiAjaW1wb3J0ICJGbG9hdGluZ1BvaW50RW52aXJvbm1l bnQuaCIKKyNpbXBvcnQgIkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmgiCiAjaW1wb3J0ICJMb2dn aW5nLmgiCiAjaW1wb3J0ICJSdW50aW1lQXBwbGljYXRpb25DaGVja3MuaCIKICNpbXBvcnQgIlRo cmVhZEdsb2JhbERhdGEuaCIKQEAgLTU5LDYgKzYwLDE4IEBACiAKICNkZWZpbmUgRGlzdGFudEZ1 dHVyZSAgICg4NjQwMC4wICogMjAwMCAqIDM2NS4yNDI1ICsgODY0MDAuMCkgICAvLyBzYW1lIGFz ICtbTlNEYXRlIGRpc3RhbnRGdXR1cmVdCiAKK25hbWVzcGFjZSB7CisvLyBSZWxlYXNlIGdsb2Jh bCBzdGF0ZSB0aGF0IGlzIGFjY2Vzc2VkIGZyb20gYm90aCB3ZWIgdGhyZWFkIGFzIHdlbGwKKy8v IGFzIGFueSBjbGllbnQgdGhyZWFkIHRoYXQgY2FsbHMuCit2b2lkIFJlbGVhc2VXZWJUaHJlYWRH bG9iYWxTdGF0ZSgpCit7CisgICAgLy8gT24gc29tZSBzZXR1cHMsIHRoZSB1bmRlcmx5aW5nIGdy YXBoaWNzIGNvbnRleHQgY2Fubm90IGJlIGN1cnJlbnQgaW4gdHdvIHRocmVhZHMKKyAgICAvLyBh dCB0aGUgc2FtZSB0aW1lLgorICAgIFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpy ZWxlYXNlQ3VycmVudENvbnRleHRJZk5lZWRlZCgpOworfQorCit9CisKIHN0YXRpYyBjb25zdCBj b25zdGV4cHIgU2Vjb25kcyBEZWxlZ2F0ZVdhaXRJbnRlcnZhbCB7IDEwX3MgfTsKIAogc3RhdGlj IHZvaWQgX1dlYlRocmVhZEF1dG9Mb2NrKCk7CkBAIC03NzUsNiArNzg4LDggQEAgc3RhdGljIHZv aWQgX1dlYlRocmVhZExvY2tGcm9tQW55VGhyZWFkKGJvb2wgc2hvdWxkTG9nKQogCiB2b2lkIFdl YlRocmVhZFVubG9ja0Zyb21BbnlUaHJlYWQodm9pZCkKIHsKKyAgICBSZWxlYXNlV2ViVGhyZWFk R2xvYmFsU3RhdGUoKTsKKwogICAgIGlmICghd2ViVGhyZWFkU3RhcnRlZCkKICAgICAgICAgcmV0 dXJuOwogICAgIEFTU0VSVCghV2ViVGhyZWFkSXNDdXJyZW50KCkpOwpAQCAtNzk5LDYgKzgxNCw4 IEBAIHZvaWQgV2ViVGhyZWFkVW5sb2NrR3VhcmRGb3JNYWlsKHZvaWQpCiAKIHZvaWQgX1dlYlRo cmVhZFVubG9jaygpCiB7CisgICAgUmVsZWFzZVdlYlRocmVhZEdsb2JhbFN0YXRlKCk7CisKICNp ZiBMT0dfV0VCX0xPQ0sgfHwgTE9HX01BSU5fVEhSRUFEX0xPQ0tJTkcKICAgICBsb2NrQ291bnQt LTsKICNpZiBMT0dfV0VCX0xPQ0sKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xz L0NoYW5nZUxvZwppbmRleCA5ZTYwYzUzNmRiNzYzYmQ3ODdiOTAwZmM0YzY1MmQ0YmZlZjQ1MWVh Li5kNmVjYTIxYmM0YmZiZmZhNDc3NGM5ZDgwOTYxODkyY2I3YTFkYzRlIDEwMDY0NAotLS0gYS9U b29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIw MjAtMDktMjkgIEtpbW1vIEtpbm51bmVuICA8a2tpbm51bmVuQGFwcGxlLmNvbT4KKworICAgICAg ICBbaU9TIFdLMV0gQ3Jhc2hlcyB3aGVuIHVzaW5nIEFOR0xFIFdlYkdMIGZyb20gYW5vdGhlciB0 aHJlYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIx NjEwNgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjg2MDI0NTI+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgV0sxIHRlc3Qgd2hpY2ggcnVu cyBXZWJHTCBjb2RlIGJvdGggaW4KKyAgICAgICAgY2xpZW50IG1haW4gdGhyZWFkIGFuZCBpbiB3 ZWIgdGhyZWFkLgorICAgICAgICBUaGlzIHRlc3RzIHRoZSBjYXNlIHdoZXJlIEFOR0xFIEVHTCBj b250ZXh0IGlzCisgICAgICAgIG5vdCBiZWluZyBoZWxkIGN1cnJlbnQgaW4gb25lIHRocmVhZCB3 aGlsZSB0aGUKKyAgICAgICAgb3RoZXIgdGhyZWFkIHJ1bnMgV2ViR0wgYW5kIHRodXMgQU5HTEUg RUdMIGNvZGUuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL0NvbmZpZ3VyYXRpb25zL1Rlc3RX ZWJLaXRBUEkueGNjb25maWc6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJ Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisKIDIwMjAtMDktMjcgIERhcmluIEFkbGVyICA8 ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJlbW92ZSBydW4td2Via2l0LXRlc3RzIGNvZGUg dGhhdCBzdHJpcHMgdHJhaWxpbmcgc3BhY2VzIHdoZW4gY29tcGFyaW5nIGV4cGVjdGVkLnR4dCBm aWxlcwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9UZXN0 V2ViS2l0QVBJLnhjY29uZmlnIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9U ZXN0V2ViS2l0QVBJLnhjY29uZmlnCmluZGV4IGJiZGRlODc1MTc5Mzg3M2UwZDBmYTJkY2E0MjFl ZDU3YWMwYWJmMDAuLjY0M2Q0NjYwNDMxZDRhODY0NTEyMGY0NDZjM2ZjMmI3ZjA0ZGE2M2IgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJhdGlvbnMvVGVzdFdlYktpdEFQ SS54Y2NvbmZpZworKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL0NvbmZpZ3VyYXRpb25zL1Rlc3RX ZWJLaXRBUEkueGNjb25maWcKQEAgLTU5LDkgKzU5LDE5IEBAIFdLX0hJRF9MREZMQUdTID0gJChX S19ISURfTERGTEFHU18kKFdLX1BMQVRGT1JNX05BTUUpKTsKIFdLX0hJRF9MREZMQUdTX21hY29z eCA9ICQoV0tfSElEX0xERkxBR1MkKFdLX01BQ09TXzEwMTUpKTsKIFdLX0hJRF9MREZMQUdTX01B Q09TX1NJTkNFXzEwMTUgPSAtZnJhbWV3b3JrIEhJRDsKIAorV0tfT1BFTkdMX0xERkxBR1MgPSAk KFdLX09QRU5HTF9MREZMQUdTXyQoV0tfUExBVEZPUk1fTkFNRSkpOworV0tfT1BFTkdMX0xERkxB R1NfaXBob25lb3MgPSAtZnJhbWV3b3JrIE9wZW5HTEVTOworV0tfT1BFTkdMX0xERkxBR1NfbWFj Y2F0YWx5c3QgPSAtZnJhbWV3b3JrIE9wZW5HTDsKK1dLX09QRU5HTF9MREZMQUdTX2lwaG9uZXNp bXVsYXRvciA9IC1mcmFtZXdvcmsgT3BlbkdMRVM7CitXS19PUEVOR0xfTERGTEFHU193YXRjaG9z ID0gJChXS19PUEVOR0xfTERGTEFHU19pcGhvbmVvcyk7CitXS19PUEVOR0xfTERGTEFHU193YXRj aHNpbXVsYXRvciA9ICQoV0tfT1BFTkdMX0xERkxBR1NfaXBob25lc2ltdWxhdG9yKTsKK1dLX09Q RU5HTF9MREZMQUdTX2FwcGxldHZvcyA9ICQoV0tfT1BFTkdMX0xERkxBR1NfaXBob25lb3MpOwor V0tfT1BFTkdMX0xERkxBR1NfYXBwbGV0dnNpbXVsYXRvciA9ICQoV0tfT1BFTkdMX0xERkxBR1Nf aXBob25lc2ltdWxhdG9yKTsKK1dLX09QRU5HTF9MREZMQUdTX21hY29zeCA9IC1mcmFtZXdvcmsg T3BlbkdMOworCiBPVEhFUl9DUExVU1BMVVNGTEFHUyA9ICQoaW5oZXJpdGVkKSAtaXN5c3RlbSAk KFNES1JPT1QpL1N5c3RlbS9MaWJyYXJ5L0ZyYW1ld29ya3MvU3lzdGVtLmZyYW1ld29yay9Qcml2 YXRlSGVhZGVyczsKIAotT1RIRVJfTERGTEFHUyA9ICQoaW5oZXJpdGVkKSAkKFVORVhQT1JURURf U1lNQk9MX0xERkxBR1MpIC1sZ3Rlc3QgLWZvcmNlX2xvYWQgJChCVUlMVF9QUk9EVUNUU19ESVIp L2xpYlRlc3RXZWJLaXRBUEkuYSAtZnJhbWV3b3JrIEphdmFTY3JpcHRDb3JlIC1mcmFtZXdvcmsg V2ViS2l0IC1sV2ViQ29yZVRlc3RTdXBwb3J0ICQoV0tfQVVUSEtJVF9MREZMQUdTKSAtZnJhbWV3 b3JrIE5ldHdvcmsgJChXS19QREZLSVRfTERGTEFHUykgJChXS19ISURfTERGTEFHUykgJChPVEhF Ul9MREZMQUdTX1BMQVRGT1JNXyQoV0tfQ09DT0FfVE9VQ0gpKTsKK09USEVSX0xERkxBR1MgPSAk KGluaGVyaXRlZCkgJChVTkVYUE9SVEVEX1NZTUJPTF9MREZMQUdTKSAtbGd0ZXN0IC1mb3JjZV9s b2FkICQoQlVJTFRfUFJPRFVDVFNfRElSKS9saWJUZXN0V2ViS2l0QVBJLmEgIC1mb3JjZV9sb2Fk ICQoQlVJTFRfUFJPRFVDVFNfRElSKS9saWJQQUwuYSAtZnJhbWV3b3JrIEphdmFTY3JpcHRDb3Jl IC1mcmFtZXdvcmsgV2ViS2l0IC1sV2ViQ29yZVRlc3RTdXBwb3J0ICQoV0tfQVVUSEtJVF9MREZM QUdTKSAtZnJhbWV3b3JrIE5ldHdvcmsgJChXS19QREZLSVRfTERGTEFHUykgJChXS19ISURfTERG TEFHUykgJChPVEhFUl9MREZMQUdTX1BMQVRGT1JNXyQoV0tfQ09DT0FfVE9VQ0gpKSAkKFdLX09Q RU5HTF9MREZMQUdTKTsKIE9USEVSX0xERkxBR1NfUExBVEZPUk1fID0gLWZyYW1ld29yayBDb2Nv YSAtZnJhbWV3b3JrIENhcmJvbjsKIAogLy8gRklYTUU6IFRoaXMgc2hvdWxkIG5vdCBiZSBidWls dCBvbiBpT1MuIEluc3RlYWQgd2Ugc2hvdWxkIGNyZWF0ZSBhbmQgdXNlIGEgVGVzdFdlYktpdEFQ SSBhcHBsaWNhdGlvbi4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktp dEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNDFjNGExNzU0ZTAzMWEx MWEwMzAxNDJiM2YxNjM4YTU3OTNmMWIwZS4uYTY4Mjk3YjgzOGFlNGQ2OTkzODU1ODAwM2E4ODZj ODcyZTg4NDZkYSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJ Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTU0Nyw2ICs1NDcsNyBAQAog CQk3QUU5RTUwOTFBRTVBRThCMDBDRjg3NEIgLyogdGVzdC5wZGYgaW4gQ29weSBSZXNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0FFOUU1MDgxQUU1QUU4QjAwQ0Y4 NzRCIC8qIHRlc3QucGRmICovOyB9OwogCQk3QUVBRDQ3RjFFMjAxMTZDMDA0MTZFRkUgLyogQ3Jv c3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gN0FFQUQ0N0MxRTIwMTEzODAwNDE2RUZFIC8qIENyb3NzUGFy dGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5tbSAqLzsgfTsKIAkJN0FFQUQ0ODExRTIwMTIyNzAwNDE2 RUZFIC8qIENyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5odG1sIGluIENvcHkgUmVzb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDdBRUFENDdEMUUyMDExNEUw MDQxNkVGRSAvKiBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbCAqLzsgfTsKKwkJ N0I3RDA5NkEyNTE5RjhGOTAwMTdBMDc4IC8qIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nl c3MubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QjdE MDk2OTI1MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5t bSAqLzsgfTsKIAkJN0MxQUY3OTUxRThEQ0JBQjAwMjY0NUI5IC8qIFByZXBhcmVGb3JNb3ZlVG9X aW5kb3cubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3 QzFBRjc5MzFFOERDQkFCMDAyNjQ1QjkgLyogUHJlcGFyZUZvck1vdmVUb1dpbmRvdy5tbSAqLzsg fTsKIAkJN0MzOTY1MDYxQ0RENzRGOTAwOTREQkI4IC8qIENvbG9yVGVzdHMuY3BwIGluIFNvdXJj ZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0MzOTY1MDUxQ0RENzRGOTAw OTREQkI4IC8qIENvbG9yVGVzdHMuY3BwICovOyB9OwogCQk3QzNEQjhFNDFEMTIxMjlCMDBBRThD QzMgLyogQ29tbWFuZEJhY2tGb3J3YXJkLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gN0MzREI4RTIxRDEyMTI5QjAwQUU4Q0MzIC8qIENvbW1hbmRCYWNr Rm9yd2FyZC5tbSAqLzsgfTsKQEAgLTIzMDIsNiArMjMwMyw3IEBACiAJCTdBRTlFNTA4MUFFNUFF OEIwMENGODc0QiAvKiB0ZXN0LnBkZiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0 S25vd25GaWxlVHlwZSA9IGltYWdlLnBkZjsgcGF0aCA9IHRlc3QucGRmOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk3QUVBRDQ3QzFFMjAxMTM4MDA0MTZFRkUgLyogQ3Jvc3NQYXJ0aXRp b25GaWxlU2NoZW1lQWNjZXNzLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBw YXRoID0gQ3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLm1tOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk3QUVBRDQ3RDFFMjAxMTRFMDA0MTZFRkUgLyogQ3Jvc3NQYXJ0aXRpb25G aWxlU2NoZW1lQWNjZXNzLmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7IG5hbWUgPSBDcm9zc1Bh cnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbDsgcGF0aCA9IFRlc3RzL21hYy9Dcm9zc1BhcnRp dGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbDsgc291cmNlVHJlZSA9IFNPVVJDRV9ST09UOyB9Owor CQk3QjdEMDk2OTI1MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFj Y2Vzcy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRB Y2Nlc3MubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdDMUFGNzkzMUU4RENCQUIw MDI2NDVCOSAvKiBQcmVwYXJlRm9yTW92ZVRvV2luZG93Lm1tICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAub2JqY3BwOyBwYXRoID0gUHJlcGFyZUZvck1vdmVUb1dpbmRvdy5tbTsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJN0MzOTY1MDUxQ0RENzRGOTAwOTREQkI4IC8qIENvbG9yVGVz dHMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQ29sb3JUZXN0cy5j cHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdDM0RCOEUyMUQxMjEyOUIwMEFFOEND MyAvKiBDb21tYW5kQmFja0ZvcndhcmQubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpj cHA7IHBhdGggPSBDb21tYW5kQmFja0ZvcndhcmQubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CkBAIC00NTkwLDYgKzQ1OTIsNyBAQAogCQkJCUNEQzA5MzJBMjFDODcyQzEwMDMwQzRCMCAv KiBTY3JvbGxpbmdEb2VzTm90UGF1c2VNZWRpYS5tbSAqLywKIAkJCQlGNDM0Q0ExOTIyRTY1QkNB MDA1RERCMjYgLyogU2Nyb2xsVG9SZXZlYWxTZWxlY3Rpb24ubW0gKi8sCiAJCQkJMEY0RkZBOUQx RUQzQUE4NTAwRjcxMTFGIC8qIFNuYXBzaG90VmlhUmVuZGVySW5Db250ZXh0Lm1tICovLAorCQkJ CTdCN0QwOTY5MjUxOUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNj ZXNzLm1tICovLAogCQkJCTMxRTlCREEwMjQ3RjRDNjIwMDJFNTFBMiAvKiBXZWJHTFByZXBhcmVE aXNwbGF5T25XZWJUaHJlYWQubW0gKi8sCiAJCQkJMkRDOTQ1MTYyNEQ4QUMwMjAwNDMwMzc2IC8q IFdlYlRocmVhZExvY2subW0gKi8sCiAJCQkpOwpAQCAtNTQ2Myw2ICs1NDY2LDcgQEAKIAkJCQk3 QzgzRTA0QzFEMEE2NDE4MDBGRUJDRjMgLyogV2ViQ29yZU5TVVJMU2Vzc2lvbi5tbSBpbiBTb3Vy Y2VzICovLAogCQkJCTU3QTc5ODU3MjI0QUIzNEUwMEE3RjZGMSAvKiBXZWJDcnlwdG9NYXN0ZXJL ZXkubW0gaW4gU291cmNlcyAqLywKIAkJCQlDMUZGOUVEQjI0NDY0NEYwMDA4MzlBRTQgLyogV2Vi RmlsdGVyLm1tIGluIFNvdXJjZXMgKi8sCisJCQkJN0I3RDA5NkEyNTE5RjhGOTAwMTdBMDc4IC8q IFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3MubW0gaW4gU291cmNlcyAqLywKIAkJCQk1 Qzk3M0Y1QzFGNThFRjhCMDAzNTlDMjcgLyogV2ViR0xQb2xpY3kubW0gaW4gU291cmNlcyAqLywK IAkJCQkzMUU5QkRBMTI0N0Y0QzYyMDAyRTUxQTIgLyogV2ViR0xQcmVwYXJlRGlzcGxheU9uV2Vi VGhyZWFkLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJN0NDRTdFQUIxQTQxMUEyNDAwNDQ3QzRDIC8q IFdlYktpdEFnbm9zdGljVGVzdC5tbSBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMTm9DcmFzaE9uT3RoZXJU aHJlYWRBY2Nlc3MubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExlZ2FjeS9p b3MvV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbQpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kYmU0YzNi NmRjYzE1OTMxNjk4YTMxNjViMmFkOGRhOTBkZWY3ODBkCi0tLSAvZGV2L251bGwKKysrIGIvVG9v bHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMTm9DcmFzaE9uT3Ro ZXJUaHJlYWRBY2Nlc3MubW0KQEAgLTAsMCArMSwyMDcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycn IEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAq IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbXBvcnQgImNv bmZpZy5oIgorCisjaWYgSEFWRShVSVdFQlZJRVcpCisKKyNpbXBvcnQgIlBsYXRmb3JtVXRpbGl0 aWVzLmgiCisjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9KU1ZpcnR1YWxNYWNoaW5lLmg+CisjaW1w b3J0IDxKYXZhU2NyaXB0Q29yZS9KU1ZpcnR1YWxNYWNoaW5lSW50ZXJuYWwuaD4KKyNpbXBvcnQg PFVJS2l0L1VJS2l0Lmg+CisjaW1wb3J0IDxXZWJDb3JlL09wZW5HTEVTU29mdExpbmtDb2NvYS5o PgorI2ltcG9ydCA8V2ViQ29yZS9PcGVuR0xTb2Z0TGlua0NvY29hLmg+CisjaW1wb3J0IDxXZWJD b3JlL1dlYkNvcmVUaHJlYWQuaD4KKyNpbXBvcnQgPHN0ZGxpYi5oPgorI2ltcG9ydCA8d3RmL1Jl dGFpblB0ci5oPgorCit1c2luZyBuYW1lc3BhY2UgUEFMOworCituYW1lc3BhY2UgeworYm9vbCBk aWRGaW5pc2hMb2FkOworYm9vbCBkaWRGaW5pc2hUZXN0OworCisjaWYgUExBVEZPUk0oTUFDKSB8 fCBQTEFURk9STShNQUNDQVRBTFlTVCkKK2NsYXNzIFNldENvbnRleHRDR0wgeworICAgIFNldENv bnRleHRDR0woKQorICAgIHsKKyAgICAgICAgLy8gVE9ETzogaW1wbGVtZW50IHByb3Blcmx5LiBT a2lwcGVkIGR1ZSB0byBjb21wbGljYXRlZCBpbnN0YW50aWF0aW9uLgorICAgICAgICAvLyBpbnN0 ZWFkLCBqdXN0IGNsb2JiZXIgdGhlIGN1cnJlbnQgY29udGV4dCB3aXRoIG51bGxwdHIuCisgICAg ICAgIENHTFNldEN1cnJlbnRDb250ZXh0KG51bGxwdHIpOworICAgIH0KKyAgICB+U2V0Q29udGV4 dENHTCgpCisgICAgeworICAgICAgICBDR0xTZXRDdXJyZW50Q29udGV4dChudWxscHRyKTsKKyAg ICB9Cit9OworI2Vsc2UKK2NsYXNzIFNldENvbnRleHRDR0wgeworCit9OworI2VuZGlmCisKKyNp ZiBQTEFURk9STShJT1NfRkFNSUxZKQorY2xhc3MgU2V0Q29udGV4dEVBR0wgeworcHVibGljOgor ICAgIFNldENvbnRleHRFQUdMKCkKKyAgICB7CisgICAgICAgIG1fZWFnbENvbnRleHQgPSBhZG9w dE5TKFthbGxvY0VBR0xDb250ZXh0SW5zdGFuY2UoKSBpbml0V2l0aEFQSToga0VBR0xSZW5kZXJp bmdBUElPcGVuR0xFUzNdKTsKKyAgICAgICAgYXV0byByID0gW2dldEVBR0xDb250ZXh0Q2xhc3Mo KSBzZXRDdXJyZW50Q29udGV4dDogbV9lYWdsQ29udGV4dC5nZXQoKV07CisgICAgICAgIEFTU0VS VChyKTsKKyAgICB9CisgICAgflNldENvbnRleHRFQUdMKCkKKyAgICB7CisgICAgICAgIFtnZXRF QUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6IG5pbF07CisgICAgfQorCitwcml2 YXRlOgorICAgIFJldGFpblB0cjxFQUdMQ29udGV4dD4gbV9lYWdsQ29udGV4dDsKK307CisjZWxz ZQorY2xhc3MgU2V0Q29udGV4dEVBR0wgeworCit9OworI2VuZGlmCisKK30KKworQGludGVyZmFj ZSBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzV2ViVmlld0RlbGVnYXRlIDogTlNPYmpl Y3QgPFVJV2ViVmlld0RlbGVnYXRlPgorQGVuZAorCitAaW1wbGVtZW50YXRpb24gV2ViR0xOb0Ny YXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxlZ2F0ZQorCitJR05PUkVfV0FSTklOR1Nf QkVHSU4oImRlcHJlY2F0ZWQtaW1wbGVtZW50YXRpb25zIikKKy0gKHZvaWQpd2ViVmlld0RpZEZp bmlzaExvYWQ6KFVJV2ViVmlldyAqKXdlYlZpZXcKK3sKKyAgICBkaWRGaW5pc2hMb2FkID0gdHJ1 ZTsKK30KKworLSAoQk9PTCl3ZWJWaWV3OihVSVdlYlZpZXcgKil3ZWJWaWV3IHNob3VsZFN0YXJ0 TG9hZFdpdGhSZXF1ZXN0OihOU1VSTFJlcXVlc3QgKilyZXF1ZXN0IG5hdmlnYXRpb25UeXBlOihV SVdlYlZpZXdOYXZpZ2F0aW9uVHlwZSluYXZpZ2F0aW9uVHlwZQoreworICAgIGlmIChbcmVxdWVz dC5VUkwuc2NoZW1lIGlzRXF1YWxUb1N0cmluZzpAImNhbGxiYWNrIl0pIHsKKyAgICAgICAgaWYg KFtyZXF1ZXN0LlVSTC5yZXNvdXJjZVNwZWNpZmllciBpc0VxdWFsVG9TdHJpbmc6QCJkaWRGaW5p c2hUZXN0Il0pCisgICAgICAgICAgICBkaWRGaW5pc2hUZXN0ID0gdHJ1ZTsKKyAgICAgICAgZWxz ZQorICAgICAgICAgICAgRVhQRUNUX1RSVUUoZmFsc2UpIDw8IFtyZXF1ZXN0LlVSTC5yZXNvdXJj ZVNwZWNpZmllciBVVEY4U3RyaW5nXTsKKyAgICAgICAgcmV0dXJuIE5POworICAgIH0KKworICAg IHJldHVybiBZRVM7Cit9CitJR05PUkVfV0FSTklOR1NfRU5ECisKK0BlbmQKKworbmFtZXNwYWNl IFRlc3RXZWJLaXRBUEkgeworCisvLyBUZXN0IHRoYXQgdGVzdHMgYmVoYXZpb3Igb2YgVUlXZWJW aWV3IEFQSSB3aXRoIHJlZ2FyZHMgdG8gV2ViR0w6CisvLyAxKSBXZWJHTCBjYW4gYmUgcnVuIG9u IHdlYiB0aHJlYWQuCisvLyAyKSBXZWJHTCBjYW4gYmUgcnVuIG9uIGNsaWVudCBtYWluIHRocmVh ZC4KKy8vIDMpIFdlYkdMIHJ1biBvbiBjbGllbnQgdGhyZWFkIGlzIG5vdCBhZmZlY3RlZCBieSBj bGllbnQgY2hhbmdpbmcKKy8vICAgIHRoZSBFQUdML0NHTCBjb250ZXh0LgorVEVTVChXZWJLaXRM ZWdhY3ksIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3MpCit7CisgICAgY29uc3QgdW5z aWduZWQgdGVzdEl0ZXJhdGlvbnMgPSAxMDsKKworICAgIFJldGFpblB0cjxVSVdpbmRvdz4gdWlX aW5kb3cgPSBhZG9wdE5TKFtbVUlXaW5kb3cgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNNYWtlUmVj dCgwLCAwLCA4MDAsIDYwMCldKTsKKyAgICBSZXRhaW5QdHI8VUlXZWJWaWV3PiB1aVdlYlZpZXcg PSBhZG9wdE5TKFtbVUlXZWJWaWV3IGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TTWFrZVJlY3QoMCwg MCwgODAwLCA2MDApXSk7CisgICAgW3VpV2luZG93IGFkZFN1YnZpZXc6dWlXZWJWaWV3LmdldCgp XTsKKworICAgIEFTU0VSVF9UUlVFKFdlYlRocmVhZElzRW5hYmxlZCgpKTsKKyAgICBTZXRDb250 ZXh0Q0dMIGNsaWVudENvbnRleHRDR0wxOworICAgIFNldENvbnRleHRFQUdMIGNsaWVudENvbnRl eHRFQUdMMTsKKyAgICBVTlVTRURfVkFSSUFCTEUoY2xpZW50Q29udGV4dENHTDEpOworICAgIFVO VVNFRF9WQVJJQUJMRShjbGllbnRDb250ZXh0RUFHTDEpOworCisgICAgUmV0YWluUHRyPFdlYkdM Tm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3NXZWJWaWV3RGVsZWdhdGU+IHVpRGVsZWdhdGUgPQor ICAgICAgICBhZG9wdE5TKFtbV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdE ZWxlZ2F0ZSBhbGxvY10gaW5pdF0pOworICAgIHVpV2ViVmlldy5nZXQoKS5kZWxlZ2F0ZSA9IHVp RGVsZWdhdGUuZ2V0KCk7CisgICAgTlNTdHJpbmcqIHRlc3RIdG1sID0gQFIiSFRNTCg8Ym9keT5O T0xJTlQocmVhZGFiaWxpdHkvbXVsdGlsaW5lX3N0cmluZykKKzxzY3JpcHQ+CitmdW5jdGlvbiBy dW5UZXN0KCkKK3sKKyAgICBsZXQgdyA9IDEwMDsKKyAgICBsZXQgaCA9IDEwMDsKKyAgICBsZXQg Y2FudmFzID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiY2FudmFzIik7CisgICAgY2FudmFzLndp ZHRoID0gdzsKKyAgICBjYW52YXMuaGVpZ2h0ID0gaDsKKyAgICBsZXQgZ2wgPSBjYW52YXMuZ2V0 Q29udGV4dCgid2ViZ2wiKTsKKyAgICBnbC5jbGVhckNvbG9yKDAsIDAsIDEsIDEpOworICAgIGds LmNsZWFyKGdsLkNPTE9SX0JVRkZFUl9CSVQpOworICAgIGxldCBleHBlY3RlZCA9IDI1NSA8PCAy NCB8IDI1NSA8PCAxNjsKKyAgICBsZXQgcHMgPSBuZXcgVWludDhBcnJheSh3ICogaCAqIDQpOwor ICAgIGdsLnJlYWRQaXhlbHMoMCwgMCwgdywgaCwgZ2wuUkdCQSwgZ2wuVU5TSUdORURfQllURSwg cHMpOworICAgIGZvciAobGV0IGkgPSAwOyBpIDwgcHMubGVuZ3RoOyBpICs9IDQpIHsKKyAgICAg ICAgbGV0IGdvdCA9IHBzW2ldIHwgcHNbaSsxXSA8PCA4IHwgcHNbaSsyXSA8PCAxNiB8IHBzW2kr M10gPDwgMjQ7CisgICAgICAgIGlmIChnb3QgIT0gZXhwZWN0ZWQpCisgICAgICAgICAgICByZXR1 cm4gYCR7Z290fSAhPSAke2V4cGVjdGVkfWA7IC8vIE5PTElOVAorICAgIH0KKyAgICByZXR1cm4g ImRpZEZpbmlzaFRlc3QiOworfQorZnVuY3Rpb24gcnVuVGVzdEFzeW5jKCkKK3sKKyAgICBzZXRU aW1lb3V0KCgpID0+IHsgd2luZG93LmxvY2F0aW9uID0gJ2NhbGxiYWNrOicgKyBydW5UZXN0KCk7 IH0sIDEwKTsgLy8gTk9MSU5UCit9Cis8L3NjcmlwdD4pSFRNTCI7IC8vIE5PTElOVChyZWFkYWJp bGl0eS9tdWx0aWxpbmVfc3RyaW5nKQorICAgIFt1aVdlYlZpZXcgbG9hZEhUTUxTdHJpbmc6dGVz dEh0bWwgYmFzZVVSTDpuaWxdOworCisgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hMb2FkKTsKKwor ICAgIFJldGFpblB0cjxKU0NvbnRleHQ+IGpzQ29udGV4dCA9IFt1aVdlYlZpZXcgdmFsdWVGb3JL ZXlQYXRoOkAiZG9jdW1lbnRWaWV3LndlYlZpZXcubWFpbkZyYW1lLmphdmFTY3JpcHRDb250ZXh0 Il07CisgICAgUmV0YWluUHRyPEpTVmlydHVhbE1hY2hpbmU+IGpzVk0gPSBbanNDb250ZXh0IHZp cnR1YWxNYWNoaW5lXTsKKyAgICBFWFBFQ1RfVFJVRShbanNWTSBpc1dlYlRocmVhZEF3YXJlXSk7 CisKKyAgICAvLyBTdGFydCB0byBydW4gV2ViR0wgb24gd2ViIHRocmVhZC4KKyAgICBbdWlXZWJW aWV3IHN0cmluZ0J5RXZhbHVhdGluZ0phdmFTY3JpcHRGcm9tU3RyaW5nOkAicnVuVGVzdEFzeW5j KCk7Il07CisgICAgRVhQRUNUX0ZBTFNFKGRpZEZpbmlzaFRlc3QpOyAvLyBUaGUgcGF0dGVybiBy dW5zIHRoZSB0ZXN0IG9uIHdlYiB0aHJlYWQuCisKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBp IDwgdGVzdEl0ZXJhdGlvbnM7IGkrKykgeworICAgICAgICAvLyBSdW4gV2ViR0wgb24gY2xpZW50 IG1haW4gdGhyZWFkLgorICAgICAgICBOU1N0cmluZyogcmVzdWx0ID0gW1tqc0NvbnRleHQgZXZh bHVhdGVTY3JpcHQ6IEAicnVuVGVzdCgpOyJdIHRvU3RyaW5nXTsKKyAgICAgICAgRVhQRUNUX1RS VUUoW0AiZGlkRmluaXNoVGVzdCIgaXNFcXVhbFRvU3RyaW5nOiByZXN1bHRdKTsKKworICAgICAg ICAvLyBDbGllbnQgY2xvYmJlcnMgRUFHTENvbnRleHQgYmV0d2VlbiBjYWxscyB0aGF0IHJ1biBX ZWJHTCBvbiBtYWluIHRocmVhZC4KKyAgICAgICAgU2V0Q29udGV4dENHTCBjbGllbnRDb250ZXh0 Q0dMMjsKKyAgICAgICAgU2V0Q29udGV4dEVBR0wgY2xpZW50Q29udGV4dEVBR0wyOworICAgICAg ICBVTlVTRURfVkFSSUFCTEUoY2xpZW50Q29udGV4dENHTDIpOworICAgICAgICBVTlVTRURfVkFS SUFCTEUoY2xpZW50Q29udGV4dEVBR0wyKTsKKworICAgICAgICByZXN1bHQgPSBbW2pzQ29udGV4 dCBldmFsdWF0ZVNjcmlwdDogQCJydW5UZXN0KCk7Il0gdG9TdHJpbmddOworICAgICAgICBFWFBF Q1RfVFJVRShbQCJkaWRGaW5pc2hUZXN0IiBpc0VxdWFsVG9TdHJpbmc6IHJlc3VsdF0pOworCisg ICAgICAgIC8vIFdhaXQgdW50aWwgdGhlIHByZXZpb3VzIFdlYkdMIHRlc3QgcnVuIGhhcyBmaW5p c2hlZC4KKyAgICAgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hUZXN0KTsKKyAgICAgICAgZGlkRmlu aXNoVGVzdCA9IGZhbHNlOworICAgICAgICAvLyBTdGFydCB0byBydW4gV2ViR0wgb24gd2ViIHRo cmVhZC4KKyAgICAgICAgW3VpV2ViVmlldyBzdHJpbmdCeUV2YWx1YXRpbmdKYXZhU2NyaXB0RnJv bVN0cmluZzpAInJ1blRlc3RBc3luYygpOyJdOworICAgICAgICBFWFBFQ1RfRkFMU0UoZGlkRmlu aXNoVGVzdCk7CisgICAgfQorCisgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hUZXN0KTsKK30KKwor fQorCisjZW5kaWYK 410107 2020-09-30 04:38:42 -0700 2020-10-01 01:26:57 -0700 Patch bug-216106-20200930143840.patch text/plain 122716 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjY3NzgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggYjE3OWJjZmNkNmQ5MGVmOGFjNjYxMGI2ZDhiMTdkNmQ0MjAzNjFiYy4uYzFiNDY3YTMwNGQw MGNhMjc5NTQxNmQwOWUyODkwOTNkNWQ2OWU0NSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDYwIEBACisyMDIwLTA5LTI5ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXSzFdIENyYXNoZXMgd2hlbiB1c2luZyBBTkdM RSBXZWJHTCBmcm9tIGFub3RoZXIgdGhyZWFkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMTYxMDYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY4NjAy NDUyPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCB0d28gZXh0ZW5zaW9ucyBmb3IgRUFHTCBhbmQgQ0dMIGJhY2tlbmRzIHRvIGRlY2xhcmUgdGhl CisgICAgICAgIHVuZGVybHlpbmcgcGxhdGZvcm0gY29udGV4dCBiZWluZyAidm9sYXRpbGUiLiBJ dCBtZWFucyB0aGF0CisgICAgICAgIHRoZSB0aHJlYWQtZ2xvYmFsIGN1cnJlbnQgY29udGV4dCBp cyBiZWluZyBtb2RpZmllZCBiZWhpbmQKKyAgICAgICAgQU5HTEUuIElmIEFOR0xFIGNvbnRleHQg aXMgbWFya2VkIHZvbGF0aWxlIGZvciBhIHBhcnRpY3VsYXIKKyAgICAgICAgQVBJLCBpdCB3aWxs IHN5bmMgdGhlIHVuZGVybHlpbmcgY29udGV4dCBmb3IgZXZlcnkgRUdMCisgICAgICAgIGZ1bmN0 aW9uIHRoYXQgbmVlZHMgdGhlIGNvbnRleHQuIE1vc3QgaW50dWl0aXZlIHVzZSBpcworICAgICAg ICBmb3IgdGhlIGNsaWVudCB0byBjYWxsIGVnbE1ha2VDdXJyZW50IGJlZm9yZSBjYWxsaW5nIGFu eQorICAgICAgICBnbCBmdW5jdGlvbiBpZiB0aGUgY2xpZW50IGtub3ducyB0aGUgcGxhdGZvcm0g c3RhdGUgbWlnaHQKKyAgICAgICAgYmUgZGlydHkuCisKKyAgICAgICAgSW1wbGVtZW50IGVnbFJl bGVhc2VUaHJlYWQgZm9yIEVBR0wgYW5kIENHTCBiYWNrZW5kcy4KKyAgICAgICAgUmVsZWFzaW5n IHRocmVhZCB3aWxsIHVuc2V0IHRoZSBwbGF0Zm9ybSBjdXJyZW50IGNvbnRleHQuCisKKyAgICAg ICAgRml4IGEgYnVnIG9mIG9taXR0aW5nIEVHTF9BTkdMRV9kZXZpY2VfZWFnbCBmcm9tIGJlaW5n CisgICAgICAgIGFkdmVydGlzZWQuCisKKyAgICAgICAgKiBpbmNsdWRlL0VHTC9lZ2xleHRfYW5n bGUuaDoKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvQ2Fwcy5jcHA6CisgICAgICAgIChlZ2w6OkRl dmljZUV4dGVuc2lvbnM6OmdldFN0cmluZ3MgY29uc3QpOgorICAgICAgICAoZWdsOjpDbGllbnRF eHRlbnNpb25zOjpnZXRTdHJpbmdzIGNvbnN0KToKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvQ2Fw cy5oOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9Db250ZXh0LmNwcDoKKyAgICAgICAgKGdsOjpD b250ZXh0Ojp1bk1ha2VDdXJyZW50KToKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvRGlzcGxheS5j cHA6CisgICAgICAgIChlZ2w6OkRpc3BsYXk6OnByZXBhcmVGb3JDYWxsKToKKyAgICAgICAgKGVn bDo6RGlzcGxheTo6cmVsZWFzZVRocmVhZCk6CisgICAgICAgIChlZ2w6OkdlbmVyYXRlQ2xpZW50 RXh0ZW5zaW9ucyk6CisgICAgICAgICogc3JjL2xpYkFOR0xFL0Rpc3BsYXkuaDoKKyAgICAgICAg KiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvRGlzcGxheUltcGwuY3BwOgorICAgICAgICAocng6OkRp c3BsYXlJbXBsOjpwcmVwYXJlRm9yQ2FsbCk6CisgICAgICAgIChyeDo6RGlzcGxheUltcGw6OnJl bGVhc2VUaHJlYWQpOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9yZW5kZXJlci9EaXNwbGF5SW1w bC5oOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9jZ2wvRGlzcGxheUNHTC5o OgorICAgICAgICAqIHNyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9jZ2wvRGlzcGxheUNHTC5tbToK KyAgICAgICAgKHJ4OjpEaXNwbGF5Q0dMOjppbml0aWFsaXplKToKKyAgICAgICAgKHJ4OjpEaXNw bGF5Q0dMOjp0ZXJtaW5hdGUpOgorICAgICAgICAocng6OkRpc3BsYXlDR0w6OnByZXBhcmVGb3JD YWxsKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5Q0dMOjpyZWxlYXNlVGhyZWFkKToKKyAgICAgICAg KHJ4OjpEaXNwbGF5Q0dMOjptYWtlQ3VycmVudCk6CisgICAgICAgICogc3JjL2xpYkFOR0xFL3Jl bmRlcmVyL2dsL2VhZ2wvRGlzcGxheUVBR0wuaDoKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvcmVu ZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbToKKyAgICAgICAgKHJ4OjpEaXNwbGF5RUFHTDo6 aW5pdGlhbGl6ZSk6CisgICAgICAgIChyeDo6RGlzcGxheUVBR0w6OnRlcm1pbmF0ZSk6CisgICAg ICAgIChyeDo6RGlzcGxheUVBR0w6OnByZXBhcmVGb3JDYWxsKToKKyAgICAgICAgKHJ4OjpEaXNw bGF5RUFHTDo6cmVsZWFzZVRocmVhZCk6CisgICAgICAgICogc3JjL2xpYkFOR0xFL3JlbmRlcmVy L2dsL2VhZ2wvRUFHTEZ1bmN0aW9ucy5oOgorICAgICAgICAqIHNyYy9saWJHTEVTdjIvZW50cnlf cG9pbnRzX2VnbC5jcHA6CisgICAgICAgICogc3JjL2xpYkdMRVN2Mi9lbnRyeV9wb2ludHNfZWds X2V4dC5jcHA6CisKIDIwMjAtMDktMjkgIEphbWVzIERhcnBpbmlhbiAgPGpkYXJwaW5pYW5AY2hy b21pdW0ub3JnPgogCiAgICAgICAgIEZpeCBFWFRfY29sb3JfYnVmZmVyX2hhbGZfZmxvYXQgb24g aU9TCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKaW5kZXggZWM2NTBhZGEwNWQwZDFmNjU5YjIyYjAzYzRjOTcyNWU4ZDg4ZDZk Yy4uMTMwMTU5ODZjNDNlZTBlYTU4MDFmZjFjNmNmNGM1NTQ1OGFhMjYwNSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDc4IEBACisyMDIwLTA5LTI5ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5lbkBh cHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXSzFdIENyYXNoZXMgd2hlbiB1c2luZyBBTkdMRSBX ZWJHTCBmcm9tIGFub3RoZXIgdGhyZWFkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMTYxMDYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY4NjAyNDUy PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNvdXJj ZSBvZiB0aGUgYnVnIGNvbWVzIGZyb20gZm9sbG93aW5nOgorICAgICAgICAgIC0gV0sxIG1pZ2h0 IHJ1biBXZWJLaXQgY29kZSBpbiBjbGllbnQgbWFpbiB0aHJlYWQuCisgICAgICAgICAgLSBXSzEg bWlnaHQgcnVuIFdlYmtpdCBjb2RlIGluIHdlYiB0aHJlYWQuCisgICAgICAgICAgLSBXZWJLaXQg Y29kZSBtaWdodCBydW4gV2ViR0wgcGF5bG9hZCwgbm90YWJseSBhY2Nlc3MKKyAgICAgICAgICAg IEdyYXBoaWNzQ29udGV4dEdMIGNsYXNzZXMuCisgICAgICAgICAgICBDbGllbnQgaXMgYWJsZSB0 byBtb2RpZnkgRUFHTC9DR0wgY3VycmVudCBjb250ZXh0LgorCisgICAgICAgIFRoZSBjaGFuZ2Ug dG8gQU5HTEUgaW5jdXJyZWQgdHdvIGRpc3RpbmN0IGJlaGF2aW9yIGNoYW5nZXMKKyAgICAgICAg Y29tcGFyZWQgdG8gcmF3IEVBR0wgLyBDR0w6CisgICAgICAgIDEpIEJlZm9yZTogY29udGV4dCB3 YXMgc2V0IGN1cnJlbnQgYmVmb3JlIGFueSBHTCBjYWxsCisgICAgICAgIEFmdGVyOiBjb250ZXh0 IHdhcyBzZXQgY3VycmVudCBvbmx5IGlmIEVHTCBjdXJyZW50IGNvbnRleHQKKyAgICAgICAgaGFk IGJlZW4gY2hhbmdlZC4gKEV4cGxpY2l0IGNvZGUgYXMgd2VsbCBhcyBBTkdMRSBpbXBsZW1lbnRh dGlvbgorICAgICAgICBvcHRpbWl6YXRpb24uKQorCisgICAgICAgIDIpIEJlZm9yZTogY29udGV4 dCBiZWluZyB1c2VkIHdhcyBhYmxlIHRvIGJlIGN1cnJlbnQgaW4KKyAgICAgICAgbXVsdGlwbGUg dGhyZWFkcyBhdCB0aGUgc2FtZSB0aW1lLiAoRUFHTC9DR0wgZmVhdHVyZSkKKyAgICAgICAgQWZ0 ZXI6IGNvbnRleHQgY2Fubm90IGJlIGN1cnJlbnQgaW4gbXVsdGlwbGUgdGhyZWFkcworICAgICAg ICBhdCB0aGUgc2FtZSB0aW1lLiAoRUdMIGZlYXR1cmUpCisKKyAgICAgICAgQ2hhbmdlIGluIGJl aGF2aW9yIDEpIGNhdXNlZCBBTkdMRSB0byBzb21ldGltZXMgdXNlCisgICAgICAgIHRoZSBFQUdM L0NHTCBjb250ZXh0IG9mIHRoZSBjbGllbnQgaW5zdGVhZCBvZgorICAgICAgICB0aGUgcmVhbCBj b250ZXh0IHRoYXQgQU5HTEUgY3JlYXRlZC4KKyAgICAgICAgRml4IHRoaXMgYnkgaW50cm9kdWNp bmcKKyAgICAgICAgRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0 aWxlX2VhZ2wKKyAgICAgICAgYW5kCisgICAgICAgIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9k ZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wKKyAgICAgICAgd2hpY2ggbWFrZSBBTkdMRSBzeW5j IHRoZSBjb250ZXh0IG9uIGVhY2ggZWdsTWFrZUN1cnJlbnQKKyAgICAgICAgZWdsUmVsZWFzZVRo cmVhZCBhbmQgZWdsVGVybWluYXRlLgorCisgICAgICAgIENoYW5nZSBpbiBiZWhhdmlvciAyKSBj YXVzZWQgQU5HTEUgdG8gdXNlIHVuaW5pdGlhbGl6ZWQKKyAgICAgICAgY29udGV4dCBvYmplY3Qg ZnJvbSBvbmUgdGhyZWFkLCBpZiB0aGUgcmVhbCBjb250ZXh0IG9iamVjdAorICAgICAgICB3YXMg Y3VycmVudCBpbiBhbm90aGVyIHRocmVhZC4KKyAgICAgICAgRml4IHRoaXMgYnkgY29uc2lkZXJp bmcgIkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMIGN1cnJlbnQgY29udGV4dCIKKyAgICAgICAgYXMg cGFydCBvZiAiZGF0YSB0aGF0IGlzIG93bmVkIGJ5IFdlYkNvcmVUaHJlYWQgbG9jayIuCisgICAg ICAgIFRoZSBjdXJyZW50IGNvbnRleHQgaXMgc2V0IHdpdGggbG9jayBoZWxkLCBpbXBsaWNpdGx5 LgorICAgICAgICBUaGUgY3VycmVudCBjb250ZXh0IGlzIHJlbGVhc2VkIHdoZW4gbG9jayBpcyBy ZWxlYXNlZC4KKyAgICAgICAgV2hlbiB0aGUgbG9jayBpcyBub3QgaGVsZCwgR3JhcGhpY3NDb250 ZXh0R0xPcGVuR0wgY3VycmVudCBjb250ZXh0CisgICAgICAgIGlzIG51bGxwdHIuCisKKyAgICAg ICAgQWRkcyBzb2Z0IGxpbmtpbmcgZm9yIEVBR0wgZm9yIHRoZSBwdXJwb3NlIG9mIHRlc3Rpbmcg dGhpcyBpbgorICAgICAgICBUZXN0V2ViS2l0QVBJLiBUaGUgY2FzZSBvZiBBcHBsZSBTaWxpY29u IE1hYyBtYXkgc29tZXRpbWVzCisgICAgICAgIHVzZSBDR0wgYW5kIHNvbWV0aW1lcyBFQUdMLCBh bmQgdGhlIHRlc3Qgc2hvdWxkIHRlc3QgdGhhdAorICAgICAgICBjbGllbnQgb3ZlcnJpZGluZyBi b3RoIGNvbnRleHRzIHdpbGwgbm90IGNhdXNlIHByb2JsZW1zLgorCisgICAgICAgIEZpeCBBTkdM RSBoZWFkZXIgaW5jbHVkZSBwYXRoOgorICAgICAgICAgLSBEbyBub3QgaW5jbHVkZSBBTkdMRSBp biB0aGUgcGF0aCwgYXMgZmlsZXMgYXJlIGluY2x1ZGVkIHdpdGggQU5HTEUvCisgICAgICAgICAt IEFkZCBXS19BTFRFUk5BVEVfRlJBTUVXT1JLU19ESVIgc28gdGhhdCBTREtfVkFSSUFOVD1pb3Nt YWMKKyAgICAgICAgICAgZS5nLiBtYWNjYXRhbHlzdCBidWlsZHMgd29yaworICAgICAgICBQcmV2 aW91c2x5IHRoZSBBTkdMRSB3YXMgbm90IGluY2x1ZGVkIGZyb20gVGhpcmRQYXJ0eS9BTkdMRSwg cmF0aGVyCisgICAgICAgICJXZWJLaXQgU0RLIi4KKworICAgICAgICAqIENvbmZpZ3VyYXRpb25z L1dlYkNvcmUueGNjb25maWc6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qOgorICAgICAgICAqIGh0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2Uu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdDb250ZXh0QmFzZTo6bG9zZUNv bnRleHRJbXBsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHRH TC5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdM T3BlbkdMQ29jb2EubW06CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5H TDo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0wpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3ND b250ZXh0R0xPcGVuR0w6On5HcmFwaGljc0NvbnRleHRHTE9wZW5HTCk6CisgICAgICAgIChXZWJD b3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6bWFrZUNvbnRleHRDdXJyZW50KToKKyAgICAg ICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxlYXNlQ3VycmVudENvbnRl eHQpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OmNoZWNrR1BV U3RhdHVzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250 ZXh0R0xPcGVuR0wuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9pb3Mvd2FrL1dlYkNvcmVUaHJlYWQu bW06CisgICAgICAgIChXZWJUaHJlYWRVbmxvY2tGcm9tQW55VGhyZWFkKToKKyAgICAgICAgKF9X ZWJUaHJlYWRVbmxvY2spOgorCiAyMDIwLTA5LTI5ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5mcmFz ZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFtMRkMgRGlzcGxheV0gQmFzaWMgdGV4dCBkaXNwbGF5 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNv cmUvUEFML0NoYW5nZUxvZwppbmRleCBlYzkwNmZjODNhOTRhMjE4Y2FjZmRkMDEwNjE2YmY3OWY2 ODExMjU1Li45YjNmNzU2NDgyOWIzMDY5MGQ4M2ZlZmYxZDRhNDI5MTMyNGQyZjk1IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BB TC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAyMC0wOS0yOSAgS2ltbW8gS2lubnVuZW4g IDxra2lubnVuZW5AYXBwbGUuY29tPgorCisgICAgICAgIFtpT1MgV0sxXSBDcmFzaGVzIHdoZW4g dXNpbmcgQU5HTEUgV2ViR0wgZnJvbSBhbm90aGVyIHRocmVhZAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE2MTA2CisgICAgICAgIDxyZGFyOi8vcHJv YmxlbS82ODYwMjQ1Mj4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGRzIHNvZnQgbGlua2luZyBmb3IgRUFHTCBmb3IgdGhlIHB1cnBvc2Ugb2YgdGVz dGluZyB0aGlzIGluCisgICAgICAgIFRlc3RXZWJLaXRBUEkuIFRoZSBjYXNlIG9mIEFwcGxlIFNp bGljb24gTWFjIG1heSBzb21ldGltZXMKKyAgICAgICAgdXNlIENHTCBhbmQgc29tZXRpbWVzIEVB R0wsIGFuZCB0aGUgdGVzdCBzaG91bGQgdGVzdCB0aGF0CisgICAgICAgIGNsaWVudCBvdmVycmlk aW5nIGJvdGggY29udGV4dHMgd2lsbCBub3QgY2F1c2UgcHJvYmxlbXMuCisKKyAgICAgICAgQWRk IENHTFNldEN1cnJlbnRDb250ZXh0IHRvIHNvZnRsaW5raW5nLCB3aWxsIGJlIHVzZWQgaW4KKyAg ICAgICAgdGhlIHRlc3Qgb2YgdGhlIGZpeC4KKworICAgICAgICAqIENvbmZpZ3VyYXRpb25zL1BB TC54Y2NvbmZpZzoKKyAgICAgICAgKiBQQUwueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAg ICAgICAgKiBwYWwvY29jb2EvT3BlbkdMRVNTb2Z0TGlua0NvY29hLmg6IEFkZGVkLgorICAgICAg ICAqIHBhbC9jb2NvYS9PcGVuR0xFU1NvZnRMaW5rQ29jb2EubW06IEFkZGVkLgorICAgICAgICAq IHBhbC9jb2NvYS9PcGVuR0xTb2Z0TGlua0NvY29hLmg6CisgICAgICAgICogcGFsL2NvY29hL09w ZW5HTFNvZnRMaW5rQ29jb2EubW06CisKIDIwMjAtMDktMjkgIEpvbmF0aGFuIEJlZGFyZCAgPGpi ZWRhcmRAYXBwbGUuY29tPgogCiAgICAgICAgIFt3YXRjaE9TXSBBVktpdFNQSSBidWlsZCBmaXhl cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZwppbmRleCAxYmJlNWMyYTJlMWQxNTYyNTFlYjA4OGYxYTcyOTE4NzYzNWQ1NTE2Li45 Zjg4N2YxYjA2OGE4MzU2M2U3ZGY2YWQ4NGYwYzJlNTM0M2EzNjE0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE0IEBACisyMDIwLTA5LTI5ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5lbkBhcHBsZS5j b20+CisKKyAgICAgICAgW2lPUyBXSzFdIENyYXNoZXMgd2hlbiB1c2luZyBBTkdMRSBXZWJHTCBm cm9tIGFub3RoZXIgdGhyZWFkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0yMTYxMDYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY4NjAyNDUyPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNz L0NvY29hL1VzZXJNZWRpYVBlcm1pc3Npb25SZXF1ZXN0UHJveHkubW06CisgICAgICAgIChXZWJL aXQ6OlVzZXJNZWRpYVBlcm1pc3Npb25SZXF1ZXN0UHJveHk6OmRvRGVmYXVsdEFjdGlvbik6CisK IDIwMjAtMDktMjkgIFNhbSBXZWluaWcgIDx3ZWluaWdAYXBwbGUuY29tPgogCiAgICAgICAgIFtQ cmVmZXJlbmNlc10gQWRvcHQgc2hhcmVkIHByZWZlcmVuY2VzIGNvbmZpZ3VyYXRpb24gYW5kIHNj cmlwdCBpbiBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL2V4dGVu c2lvbnMvRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2Nn bC50eHQgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9leHRlbnNpb25zL0VHTF9BTkdMRV9wbGF0 Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE3 MGQ4ZDFlYzcxNmJlZjVlZmY4YmE3NmM1MDllMjU5NjZlZDc2MGIKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9leHRlbnNpb25zL0VHTF9BTkdMRV9wbGF0Zm9ybV9h bmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wudHh0CkBAIC0wLDAgKzEsOTAgQEAKK05h bWUKKworICAgIEFOR0xFX3BsYXRmb3JtX2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX0NH TAorCitOYW1lIFN0cmluZ3MKKworICAgIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2Vf Y29udGV4dF92b2xhdGlsZV9DR0wKKworQ29udHJpYnV0b3JzCisgICAgS2ltbW8gS2lubnVuZW4s IEFwcGxlCisgICAgS2VubmV0aCBSdXNzZWwsIEdvb2dsZQorCitDb250YWN0cworICAgIEtpbW1v IEtpbm51bmVuLCBBcHBsZSAoa2tpbm51bmVuICdhdCcgYXBwbGUgJ2RvdCcgb3JnKQorICAgIEtl bm5ldGggUnVzc2VsLCBHb29nbGUgKGticiAnYXQnIGNocm9taXVtICdkb3QnIG9yZykKKworU3Rh dHVzCisKKyAgICBEcmFmdAorCitWZXJzaW9uCisKKyAgICBWZXJzaW9uIDEsIDIwMjAtMDktMzAK KworTnVtYmVyCisKKyAgICBFR0wgRXh0ZW5zaW9uIFhYWAorCitFeHRlbnNpb24gVHlwZQorCisg ICAgRUdMIGNsaWVudCBleHRlbnNpb24KKworRGVwZW5kZW5jaWVzCisKKyAgICBSZXF1aXJlcyBB TkdMRV9wbGF0Zm9ybV9hbmdsZS4KKworT3ZlcnZpZXcKKworICAgIFRoaXMgZXh0ZW5zaW9uIGFs bG93cyB0aGUgY2xpZW50IHRvIHJlcXVlc3QgYSBEaXNwbGF5IHRoYXQgaW50ZXJuYWxseQorICAg IGlzIGFibGUgdG8gZnVuY3Rpb24gZXZlbiBpZiBjbGllbnQgY2hhbmdlcyBjdXJyZW50IENHTCBj b250ZXh0IG9mIHRoZQorICAgIHRocmVhZC4gUmVxdWVzdGluZyBhIHZvbGF0aWxlIGRldmljZSBj b250ZXh0IGNvbnRleHRzIG1heSBpbXBhY3QgcGVyZm9ybWFuY2UuCisgICAgVGhlIGV4dGVuc2lv biBpcyB1c2VmdWwgZm9yIHVzaW5nIEVHTCBpbiBhIGxpYnJhcnkgdGhhdCBjYW5ub3QgZ3VhcmFu dGVlCisgICAgd2hpY2ggcGxhdGZvcm0gQVBJcyBpdHMgY2xpZW50cyB3aWxsIHVzZS4KKworTmV3 IFR5cGVzCisKKyAgICBOb25lCisKK05ldyBQcm9jZWR1cmVzIGFuZCBGdW5jdGlvbnMKKworICAg IE5vbmUKKworTmV3IFRva2VucworCisgICAgQWNjZXB0ZWQgYXMgYW4gYXR0cmlidXRlIG5hbWUg aW4gdGhlIDxhdHRyaWJfbGlzdD4gYXJndW1lbnQgb2YKKyAgICBlZ2xHZXRQbGF0Zm9ybURpc3Bs YXlFWFQ6CisKKyAgICAgICAgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFU SUxFX0NHTF9BTkdMRSAgICAweDM0QTMKKworQWRkaXRpb25zIHRvIHRoZSBFR0wgU3BlY2lmaWNh dGlvbgorCisgICAgTm9uZS4KKworTmV3IEJlaGF2aW9yCisKKyAgICBUbyByZXF1ZXN0IGEgZGlz cGxheSB0aGF0IGludGVybmFsbHkgc3VwcG9ydHMgdGhlIGZlYXR1cmUsCisgICAgdXNlIHRoZSBh dHRyaWJ1dGUgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0NHTF9B TkdMRS4KKyAgICBFR0xfVFJVRSBlbmFibGVzIHZvbGF0aWxlIENHTCBkZXZpY2UgY29udGV4dCBh bmQgRUdMX0ZBTFNFIGRpc2FibGVzIGl0LgorICAgIEFueSB2YWx1ZSBvdGhlciB0aGFuIHRoZXNl IHdpbGwgcmVzdWx0IGluIGFuIGVycm9yLgorICAgIFRoZSBkZWZhdWx0IHZhbHVlIGZvciBFR0xf UExBVEZPUk1fQU5HTEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfQ0dMX0FOR0xFCisgICAgaXMg RUdMX0ZBTFNFLgorCisgICAgV2hlbiB0aGUgZGV2aWNlIGNvbnRleHQgb2YgdGhlIGRpc3BsYXkg aXMgc2V0IGFzIHZvbGF0aWxlIENHTCwgdGhlbgorICAgIGVhY2ggRUdMIGZ1bmN0aW9uIHdpbGwg Y2hhbmdlIHRoZSBjdXJyZW50IENHTCBjb250ZXh0IHN0YXRlIGFjY29yZGluZ2x5CisgICAgdG8g dXNlIHRoZSBpbnRlcm5hbCBkZXZpY2UgY29udGV4dCwgaWYgbmVlZGVkLiBJZiB0aGUgaW50ZXJu YWwgZGV2aWNlIGNvbnRleHQKKyAgICBpcyBub3QgdXNpbmcgQ0dMLCB0aGUgcHJvcGVydHkgaGFz IG5vIGVmZmVjdC4KKworICAgIENhbGxzIHRvIE9wZW5HTCBvciBPcGVuR0wgRVMgZnVuY3Rpb25z IHdpbGwgbm90IGVuc3VyZSB0aGUgdW5kZXJseWluZyBkZXZpY2UKKyAgICBjb250ZXh0IGlzIGNv cnJlY3QuIElmIHRoZSBzdGF0ZSBvZiB0aGUgY3VycmVudCBDR0wgY29udGV4dCBpcyB1bmtub3du LAorICAgIGNsaWVudHMgc2hvdWxkIGNhbGwgTWFrZUN1cnJlbnQgdG8gZW5zdXJlIHRoYXQgdGhl IGludGVybmFsIGRldmljZQorICAgIGNvbnRleHQgaXMgbWFkZSBjdXJyZW50LgorCitJc3N1ZXMK KworICAgIE5vbmUKKworUmV2aXNpb24gSGlzdG9yeQorCisgICAgVmVyc2lvbiAxLCAyMDIwLTA5 LTMwIChLaW1tbyBLaW5udW5lbikKKyAgICAgIC0gSW5pdGlhbCBkcmFmdApkaWZmIC0tZ2l0IGEv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvZXh0ZW5zaW9ucy9FR0xfQU5HTEVfcGxhdGZvcm1fYW5n bGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbC50eHQgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9B TkdMRS9leHRlbnNpb25zL0VHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92 b2xhdGlsZV9lYWdsLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NGE0OTdjOGM5Y2U4NDE3ZTIwZjBmYzk2ZTUy ZGU5YjYzYmU4NWU0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUv ZXh0ZW5zaW9ucy9FR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRp bGVfZWFnbC50eHQKQEAgLTAsMCArMSw5MCBAQAorTmFtZQorCisgICAgQU5HTEVfcGxhdGZvcm1f YW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbAorCitOYW1lIFN0cmluZ3MKKworICAg IEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsCisK K0NvbnRyaWJ1dG9ycworICAgIEtpbW1vIEtpbm51bmVuLCBBcHBsZQorICAgIEtlbm5ldGggUnVz c2VsLCBHb29nbGUKKworQ29udGFjdHMKKyAgICBLaW1tbyBLaW5udW5lbiwgQXBwbGUgKGtraW5u dW5lbiAnYXQnIGFwcGxlICdkb3QnIG9yZykKKyAgICBLZW5uZXRoIFJ1c3NlbCwgR29vZ2xlIChr YnIgJ2F0JyBjaHJvbWl1bSAnZG90JyBvcmcpCisKK1N0YXR1cworCisgICAgRHJhZnQKKworVmVy c2lvbgorCisgICAgVmVyc2lvbiAxLCAyMDIwLTA5LTMwCisKK051bWJlcgorCisgICAgRUdMIEV4 dGVuc2lvbiBYWFgKKworRXh0ZW5zaW9uIFR5cGUKKworICAgIEVHTCBjbGllbnQgZXh0ZW5zaW9u CisKK0RlcGVuZGVuY2llcworCisgICAgUmVxdWlyZXMgQU5HTEVfcGxhdGZvcm1fYW5nbGUuCisK K092ZXJ2aWV3CisKKyAgICBUaGlzIGV4dGVuc2lvbiBhbGxvd3MgdGhlIGNsaWVudCB0byByZXF1 ZXN0IGEgRGlzcGxheSB0aGF0IGludGVybmFsbHkKKyAgICBpcyBhYmxlIHRvIGZ1bmN0aW9uIGV2 ZW4gaWYgY2xpZW50IGNoYW5nZXMgY3VycmVudCBFQUdMIGNvbnRleHQgb2YgdGhlCisgICAgdGhy ZWFkLiBSZXF1ZXN0aW5nIGEgdm9sYXRpbGUgZGV2aWNlIGNvbnRleHQgY29udGV4dHMgbWF5IGlt cGFjdCBwZXJmb3JtYW5jZS4KKyAgICBUaGUgZXh0ZW5zaW9uIGlzIHVzZWZ1bCBmb3IgdXNpbmcg RUdMIGluIGEgbGlicmFyeSB0aGF0IGNhbm5vdCBndWFyYW50ZWUKKyAgICB3aGljaCBwbGF0Zm9y bSBBUElzIGl0cyBjbGllbnRzIHdpbGwgdXNlLgorCitOZXcgVHlwZXMKKworICAgIE5vbmUKKwor TmV3IFByb2NlZHVyZXMgYW5kIEZ1bmN0aW9ucworCisgICAgTm9uZQorCitOZXcgVG9rZW5zCisK KyAgICBBY2NlcHRlZCBhcyBhbiBhdHRyaWJ1dGUgbmFtZSBpbiB0aGUgPGF0dHJpYl9saXN0PiBh cmd1bWVudCBvZgorICAgIGVnbEdldFBsYXRmb3JtRGlzcGxheUVYVDoKKworICAgICAgICBFR0xf UExBVEZPUk1fQU5HTEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfRUFHTF9BTkdMRSAgICAweDM0 QTIKKworQWRkaXRpb25zIHRvIHRoZSBFR0wgU3BlY2lmaWNhdGlvbgorCisgICAgTm9uZS4KKwor TmV3IEJlaGF2aW9yCisKKyAgICBUbyByZXF1ZXN0IGEgZGlzcGxheSB0aGF0IGludGVybmFsbHkg c3VwcG9ydHMgdGhlIGZlYXR1cmUsCisgICAgdXNlIHRoZSBhdHRyaWJ1dGUgRUdMX1BMQVRGT1JN X0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0VBR0xfQU5HTEUuCisgICAgRUdMX1RSVUUg ZW5hYmxlcyB2b2xhdGlsZSBFQUdMIGRldmljZSBjb250ZXh0IGFuZCBFR0xfRkFMU0UgZGlzYWJs ZXMgaXQuCisgICAgQW55IHZhbHVlIG90aGVyIHRoYW4gdGhlc2Ugd2lsbCByZXN1bHQgaW4gYW4g ZXJyb3IuCisgICAgVGhlIGRlZmF1bHQgdmFsdWUgZm9yIEVHTF9QTEFURk9STV9BTkdMRV9ERVZJ Q0VfQ09OVEVYVF9WT0xBVElMRV9FQUdMX0FOR0xFCisgICAgaXMgRUdMX0ZBTFNFLgorCisgICAg V2hlbiB0aGUgZGV2aWNlIGNvbnRleHQgb2YgdGhlIGRpc3BsYXkgaXMgc2V0IGFzIHZvbGF0aWxl IEVBR0wsIHRoZW4KKyAgICBlYWNoIEVHTCBmdW5jdGlvbiB3aWxsIGNoYW5nZSB0aGUgY3VycmVu dCBFQUdMIGNvbnRleHQgc3RhdGUgYWNjb3JkaW5nbHkKKyAgICB0byB1c2UgdGhlIGludGVybmFs IGRldmljZSBjb250ZXh0LCBpZiBuZWVkZWQuIElmIHRoZSBpbnRlcm5hbCBkZXZpY2UgY29udGV4 dAorICAgIGlzIG5vdCB1c2luZyBFQUdMLCB0aGUgcHJvcGVydHkgaGFzIG5vIGVmZmVjdC4KKwor ICAgIENhbGxzIHRvIE9wZW5HTCBvciBPcGVuR0wgRVMgZnVuY3Rpb25zIHdpbGwgbm90IGVuc3Vy ZSB0aGUgdW5kZXJseWluZyBkZXZpY2UKKyAgICBjb250ZXh0IGlzIGNvcnJlY3QuIElmIHRoZSBz dGF0ZSBvZiB0aGUgY3VycmVudCBFQUdMIGNvbnRleHQgaXMgdW5rbm93biwKKyAgICBjbGllbnRz IHNob3VsZCBjYWxsIE1ha2VDdXJyZW50IHRvIGVuc3VyZSB0aGF0IHRoZSBpbnRlcm5hbCBkZXZp Y2UKKyAgICBjb250ZXh0IGlzIG1hZGUgY3VycmVudC4KKworSXNzdWVzCisKKyAgICBOb25lCisK K1JldmlzaW9uIEhpc3RvcnkKKworICAgIFZlcnNpb24gMSwgMjAyMC0wOS0zMCAoS2ltbW8gS2lu bnVuZW4pCisgICAgICAtIEluaXRpYWwgZHJhZnQKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBh cnR5L0FOR0xFL2luY2x1ZGUvRUdML2VnbGV4dF9hbmdsZS5oIGIvU291cmNlL1RoaXJkUGFydHkv QU5HTEUvaW5jbHVkZS9FR0wvZWdsZXh0X2FuZ2xlLmgKaW5kZXggNDcwMmQ5NWE0YzMyNzZjOGFl ZTQ0MDg3OWU2N2JmYzZhZWU0NmNlNC4uN2RjNjljNWE1ZmZkY2FiMWRmYjc1MjkwZGMwOTk3MTE5 MDY4NzIxNSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvaW5jbHVkZS9FR0wv ZWdsZXh0X2FuZ2xlLmgKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvaW5jbHVkZS9FR0wv ZWdsZXh0X2FuZ2xlLmgKQEAgLTExNiw2ICsxMTYsMTYgQEAKICNkZWZpbmUgRUdMX1BMQVRGT1JN X0FOR0xFX0NPTlRFWFRfVklSVFVBTElaQVRJT05fQU5HTEUgMHgzNDgxCiAjZW5kaWYgLyogRUdM X0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2NvbnRleHRfdmlydHVhbGl6YXRpb24gKi8KIAorI2lmbmRl ZiBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbAor I2RlZmluZSBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVf ZWFnbCAxCisjZGVmaW5lIEVHTF9QTEFURk9STV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElM RV9FQUdMX0FOR0xFIDB4MzRBMgorI2VuZGlmIC8qIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9k ZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsICovCisKKyNpZm5kZWYgRUdMX0FOR0xFX3BsYXRm b3JtX2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2NnbAorI2RlZmluZSBFR0xfQU5HTEVf cGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfY2dsIDEKKyNkZWZpbmUgRUdM X1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0NHTF9BTkdMRSAweDM0QTMK KyNlbmRpZiAvKiBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRp bGVfY2dsICovCisKICNpZm5kZWYgRUdMX0FOR0xFX3gxMV92aXN1YWwKICNkZWZpbmUgRUdMX0FO R0xFX3gxMV92aXN1YWwKICNkZWZpbmUgRUdMX1gxMV9WSVNVQUxfSURfQU5HTEUgMHgzM0EzCmRp ZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvQ2Fwcy5jcHAg Yi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvQ2Fwcy5jcHAKaW5kZXggYTYz MmIwYzE0M2QxMzU4YTRlNTFkNjkyNTFhMTNlNmJkMzg4MGU1Ni4uYTAxYmVjM2ExNzk4NmZjN2Nj MWUyYzY3NjMyZmE0NzJmZDc3ZTc5NiAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5H TEUvc3JjL2xpYkFOR0xFL0NhcHMuY3BwCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3Ny Yy9saWJBTkdMRS9DYXBzLmNwcApAQCAtMTQxOCw2ICsxNDE4LDggQEAgc3RkOjp2ZWN0b3I8c3Rk OjpzdHJpbmc+IERldmljZUV4dGVuc2lvbnM6OmdldFN0cmluZ3MoKSBjb25zdAogICAgIC8vICAg ICAgICAgICAgICAgICAgIHwgRXh0ZW5zaW9uIG5hbWUgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8IFN1cHBvcnRlZCBmbGFnICAgICAgICAgICAgICAgIHwgT3V0cHV0IHZlY3RvciAg IHwKICAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV9kZXZpY2VfZDNkIiwgICAg ICAgICAgICAgICAgICAgICAgICAgIGRldmljZUQzRCwgICAgICAgICAgICAgICAgICAgICAgJmV4 dGVuc2lvblN0cmluZ3MpOwogICAgIEluc2VydEV4dGVuc2lvblN0cmluZygiRUdMX0FOR0xFX2Rl dmljZV9jZ2wiLCAgICAgICAgICAgICAgICAgICAgICAgICAgZGV2aWNlQ0dMLCAgICAgICAgICAg ICAgICAgICAgICAmZXh0ZW5zaW9uU3RyaW5ncyk7CisgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5n KCJFR0xfQU5HTEVfZGV2aWNlX2VhZ2wiLCAgICAgICAgICAgICAgICAgICAgICAgICBkZXZpY2VF QUdMLCAgICAgICAgICAgICAgICAgICAgICZleHRlbnNpb25TdHJpbmdzKTsKKwogICAgIC8vIGNs YW5nLWZvcm1hdCBvbgogCiAgICAgcmV0dXJuIGV4dGVuc2lvblN0cmluZ3M7CkBAIC0xNDQ1LDYg KzE0NDcsOCBAQCBzdGQ6OnZlY3RvcjxzdGQ6OnN0cmluZz4gQ2xpZW50RXh0ZW5zaW9uczo6Z2V0 U3RyaW5ncygpIGNvbnN0CiAgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5nKCJFR0xfQU5HTEVfcGxh dGZvcm1fYW5nbGVfdnVsa2FuIiwgICAgICAgICAgICAgICAgICBwbGF0Zm9ybUFOR0xFVnVsa2Fu LCAgICAgICAgICAgICAgICAmZXh0ZW5zaW9uU3RyaW5ncyk7CiAgICAgSW5zZXJ0RXh0ZW5zaW9u U3RyaW5nKCJFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfbWV0YWwiLCAgICAgICAgICAgICAgICAg ICBwbGF0Zm9ybUFOR0xFTWV0YWwsICAgICAgICAgICAgICAgICAmZXh0ZW5zaW9uU3RyaW5ncyk7 CiAgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5nKCJFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfY29u dGV4dF92aXJ0dWFsaXphdGlvbiIsICBwbGF0Zm9ybUFOR0xFQ29udGV4dFZpcnR1YWxpemF0aW9u LCAmZXh0ZW5zaW9uU3RyaW5ncyk7CisgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5nKCJFR0xfQU5H TEVfcGxhdGZvcm1fZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbCIsICBwbGF0Zm9ybUFOR0xF RGV2aWNlQ29udGV4dFZvbGF0aWxlRWFnbCwgJmV4dGVuc2lvblN0cmluZ3MpOworICAgIEluc2Vy dEV4dGVuc2lvblN0cmluZygiRUdMX0FOR0xFX3BsYXRmb3JtX2RldmljZV9jb250ZXh0X3ZvbGF0 aWxlX2NnbCIsICAgcGxhdGZvcm1BTkdMRURldmljZUNvbnRleHRWb2xhdGlsZUNnbCwgJmV4dGVu c2lvblN0cmluZ3MpOwogICAgIEluc2VydEV4dGVuc2lvblN0cmluZygiRUdMX0FOR0xFX2Rldmlj ZV9jcmVhdGlvbiIsICAgICAgICAgICAgICAgICAgICAgICAgZGV2aWNlQ3JlYXRpb24sICAgICAg ICAgICAgICAgICAgICAgJmV4dGVuc2lvblN0cmluZ3MpOwogICAgIEluc2VydEV4dGVuc2lvblN0 cmluZygiRUdMX0FOR0xFX2RldmljZV9jcmVhdGlvbl9kM2QxMSIsICAgICAgICAgICAgICAgICAg ZGV2aWNlQ3JlYXRpb25EM0QxMSwgICAgICAgICAgICAgICAgJmV4dGVuc2lvblN0cmluZ3MpOwog ICAgIEluc2VydEV4dGVuc2lvblN0cmluZygiRUdMX0FOR0xFX3gxMV92aXN1YWwiLCAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgeDExVmlzdWFsLCAgICAgICAgICAgICAgICAgICAgICAgICAg JmV4dGVuc2lvblN0cmluZ3MpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUv c3JjL2xpYkFOR0xFL0NhcHMuaCBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdM RS9DYXBzLmgKaW5kZXggMzcxM2FiYWQyM2NmOTNjZDU1MDFkNmFjZDliYzIyNzMzMTM1MTM4Ni4u MGNlYzY1ZjcxOGNiOWY0MGNlM2RiMWNmMDQ4M2M4MDVhOWQ2N2VjMSAxMDA2NDQKLS0tIGEvU291 cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0NhcHMuaAorKysgYi9Tb3VyY2UvVGhp cmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvQ2Fwcy5oCkBAIC0xMTQ1LDYgKzExNDUsMTIgQEAg c3RydWN0IENsaWVudEV4dGVuc2lvbnMKICAgICAvLyBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVf Y29udGV4dF92aXJ0dWFsaXphdGlvbgogICAgIGJvb2wgcGxhdGZvcm1BTkdMRUNvbnRleHRWaXJ0 dWFsaXphdGlvbiA9IGZhbHNlOwogCisgICAgLy8gRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2Rl dmljZV9jb250ZXh0X3ZvbGF0aWxlX2VhZ2wKKyAgICBib29sIHBsYXRmb3JtQU5HTEVEZXZpY2VD b250ZXh0Vm9sYXRpbGVFYWdsID0gZmFsc2U7CisKKyAgICAvLyBFR0xfQU5HTEVfcGxhdGZvcm1f YW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfY2dsCisgICAgYm9vbCBwbGF0Zm9ybUFOR0xF RGV2aWNlQ29udGV4dFZvbGF0aWxlQ2dsID0gZmFsc2U7CisKICAgICAvLyBFR0xfQU5HTEVfZGV2 aWNlX2NyZWF0aW9uCiAgICAgYm9vbCBkZXZpY2VDcmVhdGlvbiA9IGZhbHNlOwogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5jcHAgYi9T b3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5jcHAKaW5kZXggYzMx N2Y4MjY2MzFiZDBkNTc2MjNkMjk2OWVmOTg0ZDBiMDM3ZmY4Ny4uNjFkYTZiM2JjYjBiMGJjYjc2 MjNiMjkxM2M0YWIwNDYwYjY0NDdhNSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5H TEUvc3JjL2xpYkFOR0xFL0Rpc3BsYXkuY3BwCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xF L3NyYy9saWJBTkdMRS9EaXNwbGF5LmNwcApAQCAtOTU1LDYgKzk1NSwxNiBAQCBFcnJvciBEaXNw bGF5Ojp0ZXJtaW5hdGUoY29uc3QgVGhyZWFkICp0aHJlYWQpCiAgICAgcmV0dXJuIE5vRXJyb3Io KTsKIH0KIAorRXJyb3IgRGlzcGxheTo6cHJlcGFyZUZvckNhbGwoKQoreworICAgIHJldHVybiBt SW1wbGVtZW50YXRpb24tPnByZXBhcmVGb3JDYWxsKCk7Cit9CisKK0Vycm9yIERpc3BsYXk6OnJl bGVhc2VUaHJlYWQoKQoreworICAgIHJldHVybiBtSW1wbGVtZW50YXRpb24tPnJlbGVhc2VUaHJl YWQoKTsKK30KKwogc3RkOjp2ZWN0b3I8Y29uc3QgQ29uZmlnICo+IERpc3BsYXk6OmdldENvbmZp Z3MoY29uc3QgZWdsOjpBdHRyaWJ1dGVNYXAgJmF0dHJpYnMpIGNvbnN0CiB7CiAgICAgcmV0dXJu IG1Db25maWdTZXQuZmlsdGVyKGF0dHJpYnMpOwpAQCAtMTU0NCw2ICsxNTU0LDE0IEBAIHN0YXRp YyBDbGllbnRFeHRlbnNpb25zIEdlbmVyYXRlQ2xpZW50RXh0ZW5zaW9ucygpCiAgICAgZXh0ZW5z aW9ucy5wbGF0Zm9ybUFOR0xFRGV2aWNlVHlwZUVHTEFOR0xFID0gdHJ1ZTsKICNlbmRpZgogCisj aWYgKGRlZmluZWQoQU5HTEVfUExBVEZPUk1fSU9TKSAmJiAhZGVmaW5lZChBTkdMRV9QTEFURk9S TV9NQUNDQVRBTFlTVCkpIHx8IChkZWZpbmVkKEFOR0xFX1BMQVRGT1JNX01BQ0NBVEFMWVNUKSAm JiBkZWZpbmVkKEFOR0xFX0NQVV9BUk02NCkpCisgICAgZXh0ZW5zaW9ucy5wbGF0Zm9ybUFOR0xF RGV2aWNlQ29udGV4dFZvbGF0aWxlRWFnbCA9IHRydWU7CisjZW5kaWYKKworI2lmIGRlZmluZWQo QU5HTEVfUExBVEZPUk1fTUFDT1MpIHx8IGRlZmluZWQoQU5HTEVfUExBVEZPUk1fTUFDQ0FUQUxZ U1QpCisgICAgZXh0ZW5zaW9ucy5wbGF0Zm9ybUFOR0xFRGV2aWNlQ29udGV4dFZvbGF0aWxlQ2ds ID0gdHJ1ZTsKKyNlbmRpZgorCiAgICAgZXh0ZW5zaW9ucy5jbGllbnRHZXRBbGxQcm9jQWRkcmVz c2VzID0gdHJ1ZTsKICAgICBleHRlbnNpb25zLmRlYnVnICAgICAgICAgICAgICAgICAgICAgPSB0 cnVlOwogICAgIGV4dGVuc2lvbnMuZXhwbGljaXRDb250ZXh0ICAgICAgICAgICA9IHRydWU7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5o IGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0Rpc3BsYXkuaAppbmRleCA0 OWRiYTkxNmExNGJiODQ0ZTNjYzkwZWQ2NmRhMzNiZTExOTg2ZDY0Li5mMzhjOGVkMmJjYTM1MGE5 YjVhYWE3OGQ0YzNlODVlYmIxMjc5NDg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9B TkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5oCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xF L3NyYy9saWJBTkdMRS9EaXNwbGF5LmgKQEAgLTEwMiw2ICsxMDIsMTMgQEAgY2xhc3MgRGlzcGxh eSBmaW5hbCA6IHB1YmxpYyBMYWJlbGVkT2JqZWN0LAogCiAgICAgRXJyb3IgaW5pdGlhbGl6ZSgp OwogICAgIEVycm9yIHRlcm1pbmF0ZShjb25zdCBUaHJlYWQgKnRocmVhZCk7CisgICAgLy8gQ2Fs bGVkIGJlZm9yZSBhbGwgZGlzcGxheSBzdGF0ZSBkZXBlbmRlbnQgRUdMIGZ1bmN0aW9uLiBCYWNr ZW5kcyBjYW4gc2V0IHVwLCBmb3IgZXhhbXBsZSwKKyAgICAvLyB0aHJlYWQtc3BlY2lmaWMgYmFj a2VuZCBzdGF0ZSB0aHJvdWdoIHRoaXMgZnVuY3Rpb24uIE5vdCBjYWxsZWQgZm9yIGZ1bmN0aW9u cyB0aGF0IGRvIG5vdAorICAgIC8vIG5lZWQgdGhlIHN0YXRlLgorICAgIEVycm9yIHByZXBhcmVG b3JDYWxsKCk7CisgICAgLy8gQ2FsbGVkIG9uIGVnbFJlbGVhc2VUaHJlYWQuIEJhY2tlbmRzIGNh biB0ZWFyIGRvd24gdGhyZWFkLXNwZWNpZmljIGJhY2tlbmQgc3RhdGUgdGhyb3VnaAorICAgIC8v IHRoaXMgZnVuY3Rpb24uCisgICAgRXJyb3IgcmVsZWFzZVRocmVhZCgpOwogCiAgICAgc3RhdGlj IERpc3BsYXkgKkdldERpc3BsYXlGcm9tRGV2aWNlKERldmljZSAqZGV2aWNlLCBjb25zdCBBdHRy aWJ1dGVNYXAgJmF0dHJpYk1hcCk7CiAgICAgc3RhdGljIERpc3BsYXkgKkdldERpc3BsYXlGcm9t TmF0aXZlRGlzcGxheShFR0xOYXRpdmVEaXNwbGF5VHlwZSBuYXRpdmVEaXNwbGF5LApkaWZmIC0t Z2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3Bs YXlJbXBsLmNwcCBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJl ci9EaXNwbGF5SW1wbC5jcHAKaW5kZXggMmY5NjU4MTdkZWFmNGRmZjU3YTRjYmI0ODYzN2Y2MTRi NTUwNjY5Ny4uZDQxYzI1Nzc2Y2QyMzIxNTA1NzVmM2U1MzI0N2QxOTcxZWFjMWRjNiAxMDA2NDQK LS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3Bs YXlJbXBsLmNwcAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVu ZGVyZXIvRGlzcGxheUltcGwuY3BwCkBAIC0yMyw2ICsyMywxNiBAQCBEaXNwbGF5SW1wbDo6fkRp c3BsYXlJbXBsKCkKICAgICBBU1NFUlQobVN0YXRlLnN1cmZhY2VTZXQuZW1wdHkoKSk7CiB9CiAK K2VnbDo6RXJyb3IgRGlzcGxheUltcGw6OnByZXBhcmVGb3JDYWxsKCkKK3sKKyAgICByZXR1cm4g ZWdsOjpOb0Vycm9yKCk7Cit9CisKK2VnbDo6RXJyb3IgRGlzcGxheUltcGw6OnJlbGVhc2VUaHJl YWQoKQoreworICAgIHJldHVybiBlZ2w6Ok5vRXJyb3IoKTsKK30KKwogY29uc3QgZWdsOjpEaXNw bGF5RXh0ZW5zaW9ucyAmRGlzcGxheUltcGw6OmdldEV4dGVuc2lvbnMoKSBjb25zdAogewogICAg IGlmICghbUV4dGVuc2lvbnNJbml0aWFsaXplZCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBh cnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9EaXNwbGF5SW1wbC5oIGIvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKaW5kZXgg NjZlNDdiYzkxM2Y4NzE4NWVkYzI5NTY3ODMyMWY2NWNkYmU2MTE1My4uMjY0NDliODVmYzA2ODVh OGRjYzBjYmQwMGViMjkyZTRhMjFmNzQ2MCAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkv QU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKKysrIGIvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKQEAgLTY3 LDExICs2NywxNCBAQCBjbGFzcyBEaXNwbGF5SW1wbCA6IHB1YmxpYyBFR0xJbXBsRmFjdG9yeSwg cHVibGljIGFuZ2xlOjpTdWJqZWN0CiAKICAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgaW5pdGlhbGl6 ZShlZ2w6OkRpc3BsYXkgKmRpc3BsYXkpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgdGVybWluYXRl KCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gMDsKKyAgICB2aXJ0dWFsIGVnbDo6RXJy b3IgcHJlcGFyZUZvckNhbGwoKTsKKyAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgcmVsZWFzZVRocmVh ZCgpOwogCiAgICAgdmlydHVhbCBlZ2w6OkVycm9yIG1ha2VDdXJyZW50KGVnbDo6U3VyZmFjZSAq ZHJhd1N1cmZhY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVnbDo6U3Vy ZmFjZSAqcmVhZFN1cmZhY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGds OjpDb250ZXh0ICpjb250ZXh0KSA9IDA7CiAKKwogICAgIHZpcnR1YWwgZWdsOjpDb25maWdTZXQg Z2VuZXJhdGVDb25maWdzKCkgPSAwOwogCiAgICAgdmlydHVhbCBib29sIHRlc3REZXZpY2VMb3N0 KCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPSAwOwpkaWZmIC0tZ2l0IGEv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2NnbC9EaXNw bGF5Q0dMLmggYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIv Z2wvY2dsL0Rpc3BsYXlDR0wuaAppbmRleCA4OTVmNzcxMDdiYjA4MzJjOTNhYzJiOGUxZjgyMWVm OWFiNThhNGI1Li5mMDI0YmI4M2YxYTZlMGNjN2Q2ZTQ1ODY0MGFkZTdhODQwMmRmY2UzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wv Y2dsL0Rpc3BsYXlDR0wuaAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5H TEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wuaApAQCAtMTAsNiArMTAsNyBAQAogI2RlZmlu ZSBMSUJBTkdMRV9SRU5ERVJFUl9HTF9DR0xfRElTUExBWUNHTF9IXwogCiAjaW5jbHVkZSA8dGhy ZWFkPgorI2luY2x1ZGUgPHVub3JkZXJlZF9zZXQ+CiAKICNpbmNsdWRlICJsaWJBTkdMRS9yZW5k ZXJlci9nbC9EaXNwbGF5R0wuaCIKIApAQCAtMzIsNiArMzMsOCBAQCBjbGFzcyBEaXNwbGF5Q0dM IDogcHVibGljIERpc3BsYXlHTAogCiAgICAgZWdsOjpFcnJvciBpbml0aWFsaXplKGVnbDo6RGlz cGxheSAqZGlzcGxheSkgb3ZlcnJpZGU7CiAgICAgdm9pZCB0ZXJtaW5hdGUoKSBvdmVycmlkZTsK KyAgICBlZ2w6OkVycm9yIHByZXBhcmVGb3JDYWxsKCkgb3ZlcnJpZGU7CisgICAgZWdsOjpFcnJv ciByZWxlYXNlVGhyZWFkKCkgb3ZlcnJpZGU7CiAKICAgICBlZ2w6OkVycm9yIG1ha2VDdXJyZW50 KGVnbDo6U3VyZmFjZSAqZHJhd1N1cmZhY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBl Z2w6OlN1cmZhY2UgKnJlYWRTdXJmYWNlLApAQCAtMTAzLDcgKzEwNiw3IEBAIGNsYXNzIERpc3Bs YXlDR0wgOiBwdWJsaWMgRGlzcGxheUdMCiAKICAgICBlZ2w6OkRpc3BsYXkgKm1FR0xEaXNwbGF5 OwogICAgIENHTENvbnRleHRPYmogbUNvbnRleHQ7Ci0gICAgc3RkOjp1bm9yZGVyZWRfbWFwPHN0 ZDo6dGhyZWFkOjppZCwgQ0dMQ29udGV4dE9iaj4gbUN1cnJlbnRDb250ZXh0czsKKyAgICBzdGQ6 OnVub3JkZXJlZF9zZXQ8c3RkOjp0aHJlYWQ6OmlkPiBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4 dDsKICAgICBDR0xQaXhlbEZvcm1hdE9iaiBtUGl4ZWxGb3JtYXQ7CiAgICAgYm9vbCBtU3VwcG9y dHNHUFVTd2l0Y2hpbmc7CiAgICAgdWludDY0X3QgbUN1cnJlbnRHUFVJRDsKQEAgLTExMyw2ICsx MTYsNyBAQCBjbGFzcyBEaXNwbGF5Q0dMIDogcHVibGljIERpc3BsYXlHTAogICAgIC8vIGlzIHVu cmVmJ2QgZm9yIHRoZSBsYXN0IHRpbWUsIHRoaXMgaXMgc2V0IHRvIHRoZSB0aW1lIG9mIHRoYXQg bGFzdCB1bnJlZi4gSWYgaXQgaXNuJ3QKICAgICAvLyBhY3RpdmF0ZWQgYWdhaW4gaW4gMTAgc2Vj b25kcywgdGhlIGRpc2NyZXRlIEdQVSBwaXhlbCBmb3JtYXQgaXMgZGVsZXRlZC4KICAgICBkb3Vi bGUgbUxhc3REaXNjcmV0ZUdQVVVucmVmVGltZTsKKyAgICBib29sIG1EZXZpY2VDb250ZXh0SXNW b2xhdGlsZSA9IGZhbHNlOwogfTsKIAogfSAgLy8gbmFtZXNwYWNlIHJ4CmRpZmYgLS1naXQgYS9T b3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3Bs YXlDR0wubW0gYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIv Z2wvY2dsL0Rpc3BsYXlDR0wubW0KaW5kZXggZTdjYzJiYTJmYTYzYzZhMzM2MWIwNTdmOGRmMTc4 Mjg2MTM3OWRmMS4uMGRiNTFiZjE2OWUwNWZiNmRjOGJhOGMwYWI4M2U2YTJlYjJkY2JkMCAxMDA2 NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2ds L2NnbC9EaXNwbGF5Q0dMLm1tCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJB TkdMRS9yZW5kZXJlci9nbC9jZ2wvRGlzcGxheUNHTC5tbQpAQCAtMTg0LDkgKzE4NCwxMSBAQCBl Z2w6OkVycm9yIERpc3BsYXlDR0w6OmluaXRpYWxpemUoZWdsOjpEaXNwbGF5ICpkaXNwbGF5KQog ICAgICAgICBtQ3VycmVudEdQVUlEID0gYW5nbGU6OkdldEdwdUlERnJvbURpc3BsYXlJRChrQ0dE aXJlY3RNYWluRGlzcGxheSk7CiAgICAgfQogCi0gICAgQ0dMU2V0Q3VycmVudENvbnRleHQobUNv bnRleHQpOwotCi0gICAgbUN1cnJlbnRDb250ZXh0c1tzdGQ6OnRoaXNfdGhyZWFkOjpnZXRfaWQo KV0gPSBtQ29udGV4dDsKKyAgICBpZiAoQ0dMU2V0Q3VycmVudENvbnRleHQobUNvbnRleHQpICE9 IGtDR0xOb0Vycm9yKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGVnbDo6RWdsTm90SW5pdGlhbGl6 ZWQoKSA8PCAiQ291bGQgbm90IG1ha2UgdGhlIENHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICB9 CisgICAgbVRocmVhZHNXaXRoQ3VycmVudENvbnRleHQuaW5zZXJ0KHN0ZDo6dGhpc190aHJlYWQ6 OmdldF9pZCgpKTsKIAogICAgIC8vIFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZ2V0UHJvY0FkZHJl c3MgaW4gQ0dMIHNvIHdlIG9wZW4gdGhlIGR5bGliIGRpcmVjdGx5CiAgICAgdm9pZCAqaGFuZGxl ID0gZGxvcGVuKGtEZWZhdWx0T3BlbkdMRHlsaWJOYW1lLCBSVExEX05PVyk7CkBAIC0yMTAsNiAr MjEyLDkgQEAgZWdsOjpFcnJvciBEaXNwbGF5Q0dMOjppbml0aWFsaXplKGVnbDo6RGlzcGxheSAq ZGlzcGxheSkKICAgICAgICAgcmV0dXJuIGVnbDo6RWdsTm90SW5pdGlhbGl6ZWQoKSA8PCAiT3Bl bkdMIEVTIDIuMCBpcyBub3Qgc3VwcG9ydGFibGUuIjsKICAgICB9CiAKKyAgICBhdXRvICZhdHRy aWJ1dGVzID0gZGlzcGxheS0+Z2V0QXR0cmlidXRlTWFwKCk7CisgICAgbURldmljZUNvbnRleHRJ c1ZvbGF0aWxlID0gYXR0cmlidXRlcy5nZXQoRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05U RVhUX1ZPTEFUSUxFX0NHTF9BTkdMRSwgR0xfRkFMU0UpOworCiAgICAgcmV0dXJuIERpc3BsYXlH TDo6aW5pdGlhbGl6ZShkaXNwbGF5KTsKIH0KIApAQCAtMjIzLDEyICsyMjgsMTIgQEAgdm9pZCBE aXNwbGF5Q0dMOjp0ZXJtaW5hdGUoKQogICAgICAgICBDR0xEZXN0cm95UGl4ZWxGb3JtYXQobVBp eGVsRm9ybWF0KTsKICAgICAgICAgbVBpeGVsRm9ybWF0ID0gbnVsbHB0cjsKICAgICB9Ci0gICAg bUN1cnJlbnRDb250ZXh0cy5jbGVhcigpOwogICAgIGlmIChtQ29udGV4dCAhPSBudWxscHRyKQog ICAgIHsKICAgICAgICAgQ0dMU2V0Q3VycmVudENvbnRleHQobnVsbHB0cik7CiAgICAgICAgIENH TERlc3Ryb3lDb250ZXh0KG1Db250ZXh0KTsKICAgICAgICAgbUNvbnRleHQgPSBudWxscHRyOwor ICAgICAgICBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5jbGVhcigpOwogICAgIH0KICAgICBp ZiAobURpc2NyZXRlR1BVUGl4ZWxGb3JtYXQgIT0gbnVsbHB0cikKICAgICB7CkBAIC0yMzgsMjMg KzI0Myw0MSBAQCB2b2lkIERpc3BsYXlDR0w6OnRlcm1pbmF0ZSgpCiAgICAgfQogfQogCi1lZ2w6 OkVycm9yIERpc3BsYXlDR0w6Om1ha2VDdXJyZW50KGVnbDo6U3VyZmFjZSAqZHJhd1N1cmZhY2Us Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVnbDo6U3VyZmFjZSAqcmVhZFN1 cmZhY2UsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdsOjpDb250ZXh0ICpj b250ZXh0KQorZWdsOjpFcnJvciBEaXNwbGF5Q0dMOjpwcmVwYXJlRm9yQ2FsbCgpCiB7Ci0gICAg Y2hlY2tEaXNjcmV0ZUdQVVN0YXR1cygpOwotICAgIC8vIElmIHRoZSB0aHJlYWQgdGhhdCdzIGNh bGxpbmcgbWFrZUN1cnJlbnQgZG9lcyBub3QgaGF2ZSB0aGUgY29ycmVjdAotICAgIC8vIGNvbnRl eHQgY3VycmVudCAoZWl0aGVyIG1Db250ZXh0IG9yIDApLCB3ZSBuZWVkIHRvIHNldCBpdCBjdXJy ZW50LgotICAgIENHTENvbnRleHRPYmogbmV3Q29udGV4dCA9IDA7Ci0gICAgaWYgKGNvbnRleHQp CisgICAgQVNTRVJUKG1Db250ZXh0KTsKKyAgICBhdXRvIHRocmVhZElkID0gc3RkOjp0aGlzX3Ro cmVhZDo6Z2V0X2lkKCk7CisgICAgaWYgKG1EZXZpY2VDb250ZXh0SXNWb2xhdGlsZSB8fCBtVGhy ZWFkc1dpdGhDdXJyZW50Q29udGV4dC5maW5kKHRocmVhZElkKSA9PSBtVGhyZWFkc1dpdGhDdXJy ZW50Q29udGV4dC5lbmQoKSkKICAgICB7Ci0gICAgICAgIG5ld0NvbnRleHQgPSBtQ29udGV4dDsK KyAgICAgICAgaWYgKENHTFNldEN1cnJlbnRDb250ZXh0KG1Db250ZXh0KSAhPSBrQ0dMTm9FcnJv cikKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIGVnbDo6RWdsQmFkQWxsb2MoKSA8PCAi Q291bGQgbm90IG1ha2UgZGV2aWNlIENHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICAgICAgfQor ICAgICAgICBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5pbnNlcnQodGhyZWFkSWQpOwogICAg IH0KLSAgICBpZiAobmV3Q29udGV4dCAhPSBtQ3VycmVudENvbnRleHRzW3N0ZDo6dGhpc190aHJl YWQ6OmdldF9pZCgpXSkKKyAgICByZXR1cm4gZWdsOjpOb0Vycm9yKCk7Cit9CisKK2VnbDo6RXJy b3IgRGlzcGxheUNHTDo6cmVsZWFzZVRocmVhZCgpCit7CisgICAgQVNTRVJUKG1Db250ZXh0KTsK KyAgICBhdXRvIHRocmVhZElkID0gc3RkOjp0aGlzX3RocmVhZDo6Z2V0X2lkKCk7CisgICAgaWYg KG1UaHJlYWRzV2l0aEN1cnJlbnRDb250ZXh0LmZpbmQodGhyZWFkSWQpICE9IG1UaHJlYWRzV2l0 aEN1cnJlbnRDb250ZXh0LmVuZCgpKQogICAgIHsKLSAgICAgICAgQ0dMU2V0Q3VycmVudENvbnRl eHQobmV3Q29udGV4dCk7Ci0gICAgICAgIG1DdXJyZW50Q29udGV4dHNbc3RkOjp0aGlzX3RocmVh ZDo6Z2V0X2lkKCldID0gbmV3Q29udGV4dDsKKyAgICAgICAgaWYgKENHTFNldEN1cnJlbnRDb250 ZXh0KG51bGxwdHIpICE9IGtDR0xOb0Vycm9yKQorICAgICAgICB7CisgICAgICAgICAgICByZXR1 cm4gZWdsOjpFZ2xCYWRBbGxvYygpIDw8ICJDb3VsZCBub3QgcmVsZWFzZSBkZXZpY2UgQ0dMIGNv bnRleHQuIjsKKyAgICAgICAgfQorICAgICAgICBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5l cmFzZSh0aHJlYWRJZCk7CiAgICAgfQorICAgIHJldHVybiBlZ2w6Ok5vRXJyb3IoKTsKK30KKwor ZWdsOjpFcnJvciBEaXNwbGF5Q0dMOjptYWtlQ3VycmVudChlZ2w6OlN1cmZhY2UgKmRyYXdTdXJm YWNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlZ2w6OlN1cmZhY2UgKnJl YWRTdXJmYWNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbDo6Q29udGV4 dCAqY29udGV4dCkKK3sKKyAgICBjaGVja0Rpc2NyZXRlR1BVU3RhdHVzKCk7CiAgICAgcmV0dXJu IERpc3BsYXlHTDo6bWFrZUN1cnJlbnQoZHJhd1N1cmZhY2UsIHJlYWRTdXJmYWNlLCBjb250ZXh0 KTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xF L3JlbmRlcmVyL2dsL2VhZ2wvRGlzcGxheUVBR0wuaCBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xF L3NyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmgKaW5kZXggYTUzNjZl OTE2ZTljNzU2MDlmMzEwMTMxMmZlYjYwZjA1N2MxMTExNi4uZGE0YTcwMzcxYjY1N2YyYjVlYWIw YTQxYzRiMGJhYTA5ZWVkMzQ0NiAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUv c3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2VhZ2wvRGlzcGxheUVBR0wuaAorKysgYi9Tb3VyY2Uv VGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFH TC5oCkBAIC0xMyw2ICsxMyw5IEBACiAKICNpZiAoZGVmaW5lZChBTkdMRV9QTEFURk9STV9JT1Mp ICYmICFkZWZpbmVkKEFOR0xFX1BMQVRGT1JNX01BQ0NBVEFMWVNUKSkgfHwgKGRlZmluZWQoQU5H TEVfUExBVEZPUk1fTUFDQ0FUQUxZU1QpICYmIGRlZmluZWQoQU5HTEVfQ1BVX0FSTTY0KSkKIAor I2luY2x1ZGUgPHRocmVhZD4KKyNpbmNsdWRlIDx1bm9yZGVyZWRfc2V0PgorCiAjaW5jbHVkZSAi bGliQU5HTEUvcmVuZGVyZXIvZ2wvRGlzcGxheUdMLmgiCiAKICNpZmRlZiBfX09CSkNfXwpAQCAt MzUsNiArMzgsOCBAQCBjbGFzcyBEaXNwbGF5RUFHTCA6IHB1YmxpYyBEaXNwbGF5R0wKIAogICAg IGVnbDo6RXJyb3IgaW5pdGlhbGl6ZShlZ2w6OkRpc3BsYXkgKmRpc3BsYXkpIG92ZXJyaWRlOwog ICAgIHZvaWQgdGVybWluYXRlKCkgb3ZlcnJpZGU7CisgICAgZWdsOjpFcnJvciBwcmVwYXJlRm9y Q2FsbCgpIG92ZXJyaWRlOworICAgIGVnbDo6RXJyb3IgcmVsZWFzZVRocmVhZCgpIG92ZXJyaWRl OwogCiAgICAgU3VyZmFjZUltcGwgKmNyZWF0ZVdpbmRvd1N1cmZhY2UoY29uc3QgZWdsOjpTdXJm YWNlU3RhdGUgJnN0YXRlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVH TE5hdGl2ZVdpbmRvd1R5cGUgd2luZG93LApAQCAtOTMsNiArOTgsOCBAQCBjbGFzcyBEaXNwbGF5 RUFHTCA6IHB1YmxpYyBEaXNwbGF5R0wKIAogICAgIGVnbDo6RGlzcGxheSAqbUVHTERpc3BsYXk7 CiAgICAgRUFHTENvbnRleHRPYmogbUNvbnRleHQ7CisgICAgc3RkOjp1bm9yZGVyZWRfc2V0PHN0 ZDo6dGhyZWFkOjppZD4gbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQ7CisgICAgYm9vbCBtRGV2 aWNlQ29udGV4dElzVm9sYXRpbGUgPSBmYWxzZTsKIH07CiAKIH0gIC8vIG5hbWVzcGFjZSByeApk aWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVy L2dsL2VhZ2wvRGlzcGxheUVBR0wubW0gYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGli QU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQppbmRleCA5NGY0ZWU1Y2NmYzky NmM0MGE0MWU0ODhlOWNjZTY2OTM4ZDQzY2FjLi42Y2I5YzliZmY0Njc5OWM5ZjVmZjhhOTZjOTBl OTljMjZiMjE4MTRjIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGli QU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQorKysgYi9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQpA QCAtNzUsNyArNzUsMTEgQEAgZWdsOjpFcnJvciBEaXNwbGF5RUFHTDo6aW5pdGlhbGl6ZShlZ2w6 OkRpc3BsYXkgKmRpc3BsYXkpCiAgICAgewogICAgICAgICByZXR1cm4gZWdsOjpFZ2xOb3RJbml0 aWFsaXplZCgpIDw8ICJDb3VsZCBub3QgY3JlYXRlIHRoZSBFQUdMIGNvbnRleHQuIjsKICAgICB9 Ci0gICAgW2dldEVBR0xDb250ZXh0Q2xhc3MoKSBzZXRDdXJyZW50Q29udGV4dDptQ29udGV4dF07 CisKKyAgICBpZiAoIVtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bUNv bnRleHRdKSB7CisgICAgICAgIHJldHVybiBlZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIkNv dWxkIHNldCB0aGUgRUFHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICB9CisgICAgbVRocmVhZHNX aXRoQ29udGV4dEN1cnJlbnQuaW5zZXJ0KHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgpKTsKIAog ICAgIC8vIFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZ2V0UHJvY0FkZHJlc3MgaW4gRUFHTCBzbyB3 ZSBvcGVuIHRoZSBkeWxpYiBkaXJlY3RseQogICAgIHZvaWQgKmhhbmRsZSA9IGRsb3BlbihrT3Bl bkdMRVNEeWxpYk5hbWUsIFJUTERfTk9XKTsKQEAgLTk1LDYgKzk5LDkgQEAgZWdsOjpFcnJvciBE aXNwbGF5RUFHTDo6aW5pdGlhbGl6ZShlZ2w6OkRpc3BsYXkgKmRpc3BsYXkpCiAgICAgICAgIHJl dHVybiBlZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIk9wZW5HTCBFUyAyLjAgaXMgbm90IHN1 cHBvcnRhYmxlLiI7CiAgICAgfQogCisgICAgYXV0byAmYXR0cmlidXRlcyA9IGRpc3BsYXktPmdl dEF0dHJpYnV0ZU1hcCgpOworICAgIG1EZXZpY2VDb250ZXh0SXNWb2xhdGlsZSA9IGF0dHJpYnV0 ZXMuZ2V0KEVHTF9QTEFURk9STV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElMRV9FQUdMX0FO R0xFLCBHTF9GQUxTRSk7CisKICAgICByZXR1cm4gRGlzcGxheUdMOjppbml0aWFsaXplKGRpc3Bs YXkpOwogfQogCkBAIC0xMDgsNyArMTE1LDM2IEBAIHZvaWQgRGlzcGxheUVBR0w6OnRlcm1pbmF0 ZSgpCiAgICAgICAgIFtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bmls XTsKICAgICAgICAgW21Db250ZXh0IHJlbGVhc2VdOwogICAgICAgICBtQ29udGV4dCA9IG51bGxw dHI7CisgICAgICAgIG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50LmNsZWFyKCk7CisgICAgfQor fQorCitlZ2w6OkVycm9yIERpc3BsYXlFQUdMOjpwcmVwYXJlRm9yQ2FsbCgpCit7CisgICAgYXV0 byB0aHJlYWRJZCA9IHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgpOworICAgIGlmIChtRGV2aWNl Q29udGV4dElzVm9sYXRpbGUgfHwgbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZmluZCh0aHJl YWRJZCkgPT0gbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZW5kKCkpCisgICAgeworICAgICAg ICBpZiAoIVtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bUNvbnRleHRd KQorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gZWdsOjpFZ2xCYWRBbGxvYygpIDw8ICJD b3VsZCBub3QgbWFrZSBkZXZpY2UgRUFHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICAgICAgfQor ICAgICAgICBtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5pbnNlcnQodGhyZWFkSWQpOwogICAg IH0KKyAgICByZXR1cm4gZWdsOjpOb0Vycm9yKCk7Cit9CisKK2VnbDo6RXJyb3IgRGlzcGxheUVB R0w6OnJlbGVhc2VUaHJlYWQoKQoreworICAgIGF1dG8gdGhyZWFkSWQgPSBzdGQ6OnRoaXNfdGhy ZWFkOjpnZXRfaWQoKTsKKyAgICBpZiAobVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZmluZCh0 aHJlYWRJZCkgIT0gbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZW5kKCkpCisgICAgeworICAg ICAgICBpZiAoIVtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bmlsXSkK KyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIGVnbDo6RWdsQmFkQWxsb2MoKSA8PCAiQ291 bGQgbm90IHJlbGVhc2UgZGV2aWNlIEVBR0wgY29udGV4dC4iOworICAgICAgICB9CisgICAgICAg IG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50LmVyYXNlKHRocmVhZElkKTsKKyAgICB9CisgICAg cmV0dXJuIGVnbDo6Tm9FcnJvcigpOwogfQogCiBTdXJmYWNlSW1wbCAqRGlzcGxheUVBR0w6OmNy ZWF0ZVdpbmRvd1N1cmZhY2UoY29uc3QgZWdsOjpTdXJmYWNlU3RhdGUgJnN0YXRlLApkaWZmIC0t Z2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2Vh Z2wvRUFHTEZ1bmN0aW9ucy5oIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xF L3JlbmRlcmVyL2dsL2VhZ2wvRUFHTEZ1bmN0aW9ucy5oCmluZGV4IGNkMzYxOTViOTk1ODZjOWZl YTRlYzhjNjZmYTVkMGIxM2VhZDcxOWEuLjE3MmM1NTZhMDU3MjliNTQwNGUzNzk4YTgxZDc0NDMx YjgxZmZlODMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdM RS9yZW5kZXJlci9nbC9lYWdsL0VBR0xGdW5jdGlvbnMuaAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9FQUdMRnVuY3Rpb25zLmgKQEAg LTI1LDQgKzI1LDQgQEAgU09GVF9MSU5LX0NMQVNTX0hFQURFUihFQUdMQ29udGV4dCkKIAogI2Vu ZGlmIC8vIChkZWZpbmVkKEFOR0xFX1BMQVRGT1JNX0lPUykgJiYgIWRlZmluZWQoQU5HTEVfUExB VEZPUk1fTUFDQ0FUQUxZU1QpKSB8fCAoZGVmaW5lZChBTkdMRV9QTEFURk9STV9NQUNDQVRBTFlT VCkgJiYgZGVmaW5lZChBTkdMRV9DUFVfQVJNNjQpKQogCi0jZW5kaWYgLy8gQ0dMX0ZVTkNUSU9O U19IXworI2VuZGlmIC8vIEVBR0xfRlVOQ1RJT05TX0hfCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhp cmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvdmFsaWRhdGlvbkVHTC5jcHAgYi9Tb3VyY2UvVGhp cmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvdmFsaWRhdGlvbkVHTC5jcHAKaW5kZXggYjU2NmNm MGZkMTU2YmFmNTYxZTA0ZmY1MjAzMGI0Yjg1YTEzODlhYi4uMGExMjViOTA0M2FiNWU2YmFiODAz YzVjMGE5YTRmZDYxNmU5OWI1NSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUv c3JjL2xpYkFOR0xFL3ZhbGlkYXRpb25FR0wuY3BwCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJBTkdMRS92YWxpZGF0aW9uRUdMLmNwcApAQCAtNjQzLDYgKzY0MywzNCBAQCBF cnJvciBWYWxpZGF0ZUdldFBsYXRmb3JtRGlzcGxheUNvbW1vbihFR0xlbnVtIHBsYXRmb3JtLAog ICAgICAgICAgICAgICAgIGNhc2UgRUdMX1BMQVRGT1JNX0FOR0xFX0QzRF9MVUlEX0xPV19BTkdM RToKICAgICAgICAgICAgICAgICAgICAgbHVpZFNwZWNpZmllZCA9IHRydWU7CiAgICAgICAgICAg ICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIGNhc2UgRUdMX1BMQVRGT1JNX0FOR0xF X0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0VBR0xfQU5HTEU6CisgICAgICAgICAgICAgICAgICAg IC8vIFRoZSBwcm9wZXJ0eSBkb2VzIG5vdCBoYXZlIGFuIGVmZmVjdCBpZiBpdCdzIG5vdCBhY3Rp dmUsIHNvIGRvIG5vdCBjaGVjaworICAgICAgICAgICAgICAgICAgICAvLyBmb3Igbm9uLXN1cHBv cnQuCisgICAgICAgICAgICAgICAgICAgIHN3aXRjaCAodmFsdWUpCisgICAgICAgICAgICAgICAg ICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGNhc2UgRUdMX0ZBTFNFOgorICAgICAgICAg ICAgICAgICAgICAgICAgY2FzZSBFR0xfVFJVRToKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIEVnbEJhZEF0dHJpYnV0ZSgpIDw8ICJJbnZhbGlkIHZhbHVl IGZvciAiCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJFR0xfUExBVEZPUk1fQU5HTEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfIgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiRUFH TF9BTkdMRSBhdHRyaWIiOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAg ICAgIGJyZWFrOworICAgICAgICAgICAgICAgIGNhc2UgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklD RV9DT05URVhUX1ZPTEFUSUxFX0NHTF9BTkdMRToKKyAgICAgICAgICAgICAgICAgICAgLy8gVGhl IHByb3BlcnR5IGRvZXMgbm90IGhhdmUgYW4gZWZmZWN0IGlmIGl0J3Mgbm90IGFjdGl2ZSwgc28g ZG8gbm90IGNoZWNrCisgICAgICAgICAgICAgICAgICAgIC8vIGZvciBub24tc3VwcG9ydC4KKyAg ICAgICAgICAgICAgICAgICAgc3dpdGNoICh2YWx1ZSkKKyAgICAgICAgICAgICAgICAgICAgewor ICAgICAgICAgICAgICAgICAgICAgICAgY2FzZSBFR0xfRkFMU0U6CisgICAgICAgICAgICAgICAg ICAgICAgICBjYXNlIEVHTF9UUlVFOgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFr OworICAgICAgICAgICAgICAgICAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm4gRWdsQmFkQXR0cmlidXRlKCkgPDwgIkludmFsaWQgdmFsdWUgZm9yICIK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IkVHTF9QTEFURk9STV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElMRV8iCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJDR0xfQU5HTEUg YXR0cmliIjsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICBicmVh azsKICAgICAgICAgICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9s aWJHTEVTdjIvZW50cnlfcG9pbnRzX2VnbC5jcHAgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9z cmMvbGliR0xFU3YyL2VudHJ5X3BvaW50c19lZ2wuY3BwCmluZGV4IGZkMGZmODY4N2NmYjA5ODk1 MTBjMzMxNGVkZThiMmQ5NTQ3YjA0NDMuLjAxZmU5ZjYzMGQ3ZjA4NzM2ZDc0MjMzMWRhMDVkYzA2 OWY2ZDJjMzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJHTEVT djIvZW50cnlfcG9pbnRzX2VnbC5jcHAKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3Jj L2xpYkdMRVN2Mi9lbnRyeV9wb2ludHNfZWdsLmNwcApAQCAtMTA1LDcgKzEwNSw4IEBAIEVHTEJv b2xlYW4gRUdMQVBJRU5UUlkgRUdMX1Rlcm1pbmF0ZShFR0xEaXNwbGF5IGRweSkKICAgICBlZ2w6 OkRpc3BsYXkgKmRpc3BsYXkgPSBzdGF0aWNfY2FzdDxlZ2w6OkRpc3BsYXkgKj4oZHB5KTsKICAg ICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlVGVybWluYXRlKGRpc3BsYXkp LCAiZWdsVGVybWluYXRlIiwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZW YWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFRlcm1pbmF0ZSIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7 CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5tYWtlQ3VycmVudCh0 aHJlYWQsIG51bGxwdHIsIG51bGxwdHIsIG51bGxwdHIpLAogICAgICAgICAgICAgICAgICAgICAg ICAgICJlZ2xUZXJtaW5hdGUiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNF KTsKICAgICBTZXRDb250ZXh0Q3VycmVudCh0aHJlYWQsIG51bGxwdHIpOwpAQCAtMTI3LDYgKzEy OCw4IEBAIGNvbnN0IGNoYXIgKkVHTEFQSUVOVFJZIEVHTF9RdWVyeVN0cmluZyhFR0xEaXNwbGF5 IGRweSwgRUdMaW50IG5hbWUpCiAgICAgewogICAgICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIFZhbGlkYXRlRGlzcGxheShkaXNwbGF5KSwgImVnbFF1ZXJ5U3RyaW5nIiwKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIG51bGxw dHIpOworICAgICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBh cmVGb3JDYWxsKCksICJlZ2xRdWVyeVN0cmluZyIsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBudWxscHRyKTsKICAgICB9CiAKICAgICBj b25zdCBjaGFyICpyZXN1bHQ7CkBAIC0yNTUsNiArMjU4LDggQEAgRUdMU3VyZmFjZSBFR0xBUElF TlRSWSBFR0xfQ3JlYXRlV2luZG93U3VyZmFjZShFR0xEaXNwbGF5IGRweSwKICAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgVmFsaWRhdGVD cmVhdGVXaW5kb3dTdXJmYWNlKGRpc3BsYXksIGNvbmZpZ3VyYXRpb24sIHdpbiwgYXR0cmlidXRl cyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVdpbmRvd1N1cmZhY2UiLCBH ZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOworICAgIEFOR0xFX0VH TF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENyZWF0 ZVdpbmRvd1N1cmZhY2UiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZh bGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7CiAKICAgICBlZ2w6OlN1cmZhY2UgKnN1cmZh Y2UgPSBudWxscHRyOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwKQEAgLTI4MSw3 ICsyODYsOCBAQCBFR0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQYnVmZmVyU3VyZmFj ZShFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFs aWRhdGVDcmVhdGVQYnVmZmVyU3VyZmFjZShkaXNwbGF5LCBjb25maWd1cmF0aW9uLCBhdHRyaWJ1 dGVzKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsQ3JlYXRlUGJ1ZmZlclN1cmZhY2Ui LCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwotCisgICAgQU5H TEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWds Q3JlYXRlUGJ1ZmZlclN1cmZhY2UiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3Bs YXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7CiAgICAgZWdsOjpTdXJmYWNlICpz dXJmYWNlID0gbnVsbHB0cjsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3Bs YXktPmNyZWF0ZVBidWZmZXJTdXJmYWNlKGNvbmZpZ3VyYXRpb24sIGF0dHJpYnV0ZXMsICZzdXJm YWNlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsQ3JlYXRlUGJ1ZmZlclN1cmZhY2Ui LCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwpAQCAtMzEwLDcg KzMxNiw4IEBAIEVHTFN1cmZhY2UgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVBpeG1hcFN1cmZhY2Uo RUdMRGlzcGxheSBkcHksCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAg ICAgICAgICAgICAgICAgICAgIFZhbGlkYXRlQ3JlYXRlUGl4bWFwU3VyZmFjZShkaXNwbGF5LCBj b25maWd1cmF0aW9uLCBwaXhtYXAsIGF0dHJpYnV0ZXMpLAogICAgICAgICAgICAgICAgICAgICAg ICAgICJlZ2xDcmVhdGVQaXhtYXBTdXJmYWNlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSks IEVHTF9OT19TVVJGQUNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlz cGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENyZWF0ZVBpeG1hcFN1cmZhY2UiLAorICAgICAg ICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VS RkFDRSk7CiAgICAgZWdsOjpTdXJmYWNlICpzdXJmYWNlID0gbnVsbHB0cjsKICAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgZGlzcGxheS0+ Y3JlYXRlUGl4bWFwU3VyZmFjZShjb25maWd1cmF0aW9uLCBwaXhtYXAsIGF0dHJpYnV0ZXMsICZz dXJmYWNlKSwKQEAgLTMzMiw3ICszMzksOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9E ZXN0cm95U3VyZmFjZShFR0xEaXNwbGF5IGRweSwgRUdMU3VyZmFjZSBzdXJmYWNlKQogCiAgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZURlc3Ryb3lTdXJmYWNlKGRpc3Bs YXksIGVnbFN1cmZhY2UsIHN1cmZhY2UpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xE ZXN0cm95U3VyZmFjZSIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBF R0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5w cmVwYXJlRm9yQ2FsbCgpLCAiZWdsRGVzdHJveVN1cmZhY2UiLAorICAgICAgICAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+ZGVzdHJveVN1cmZhY2UoZWdsU3VyZmFj ZSksICJlZ2xEZXN0cm95U3VyZmFjZSIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3Vy ZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9GQUxTRSk7CiAKQEAgLTM1Miwx MiArMzYwLDEzIEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5U3VyZmFjZShFR0xE aXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICh1aW50cHRyX3QpZHB5LCAodWludHB0cl90KXN1 cmZhY2UsIGF0dHJpYnV0ZSwgKHVpbnRwdHJfdCl2YWx1ZSk7CiAgICAgVGhyZWFkICp0aHJlYWQg PSBlZ2w6OkdldEN1cnJlbnRUaHJlYWQoKTsKIAotICAgIGNvbnN0IGVnbDo6RGlzcGxheSAqZGlz cGxheSA9IHN0YXRpY19jYXN0PGNvbnN0IGVnbDo6RGlzcGxheSAqPihkcHkpOworICAgIGVnbDo6 RGlzcGxheSAqZGlzcGxheSA9IHN0YXRpY19jYXN0PGVnbDo6RGlzcGxheSAqPihkcHkpOwogICAg IGNvbnN0IFN1cmZhY2UgKmVnbFN1cmZhY2UgICA9IHN0YXRpY19jYXN0PGNvbnN0IFN1cmZhY2Ug Kj4oc3VyZmFjZSk7CiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRl UXVlcnlTdXJmYWNlKGRpc3BsYXksIGVnbFN1cmZhY2UsIGF0dHJpYnV0ZSwgdmFsdWUpLAogICAg ICAgICAgICAgICAgICAgICAgICAgICJlZ2xRdWVyeVN1cmZhY2UiLCBHZXRTdXJmYWNlSWZWYWxp ZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllf UkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFF1ZXJ5U3VyZmFj ZSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSks IEVHTF9GQUxTRSk7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBRdWVyeVN1cmZh Y2VBdHRyaWIoZGlzcGxheSwgZWdsU3VyZmFjZSwgYXR0cmlidXRlLCB2YWx1ZSksCiAgICAgICAg ICAgICAgICAgICAgICAgICAgImVnbFF1ZXJ5U3VyZmFjZSIsIEdldFN1cmZhY2VJZlZhbGlkKGRp c3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwogCkBAIC0zODUsNyArMzk0LDggQEAgRUdM Q29udGV4dCBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlQ29udGV4dChFR0xEaXNwbGF5IGRweSwKICAg ICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAg VmFsaWRhdGVDcmVhdGVDb250ZXh0KGRpc3BsYXksIGNvbmZpZ3VyYXRpb24sIHNoYXJlZEdMQ29u dGV4dCwgYXR0cmlidXRlcyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZUNv bnRleHQiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX0NPTlRFWFQpOwotCisg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgp LCAiZWdsQ3JlYXRlQ29udGV4dCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxh eUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19DT05URVhUKTsKICAgICBnbDo6Q29udGV4dCAqY29u dGV4dCA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAg ICAgICAgICAgICAgICAgICAgIGRpc3BsYXktPmNyZWF0ZUNvbnRleHQoY29uZmlndXJhdGlvbiwg c2hhcmVkR0xDb250ZXh0LCB0aHJlYWQtPmdldEFQSSgpLApAQCAtNDA4LDcgKzQxOCw4IEBAIEVH TEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0Rlc3Ryb3lDb250ZXh0KEVHTERpc3BsYXkgZHB5LCBF R0xDb250ZXh0IGN0eCkKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRh dGVEZXN0cm95Q29udGV4dChkaXNwbGF5LCBjb250ZXh0LCBjdHgpLCAiZWdsRGVzdHJveUNvbnRl eHQiLAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldENvbnRleHRJZlZhbGlkKGRpc3BsYXks IGNvbnRleHQpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsRGVzdHJveUNvbnRleHQiLAorICAgICAg ICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0Up OwogICAgIGJvb2wgY29udGV4dFdhc0N1cnJlbnQgPSBjb250ZXh0ID09IHRocmVhZC0+Z2V0Q29u dGV4dCgpOwogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5kZXN0 cm95Q29udGV4dCh0aHJlYWQsIGNvbnRleHQpLCAiZWdsRGVzdHJveUNvbnRleHQiLApAQCAtNDQz LDcgKzQ1NCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX01ha2VDdXJyZW50KEVHTERp c3BsYXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZU1h a2VDdXJyZW50KGRpc3BsYXksIGRyYXdTdXJmYWNlLCByZWFkU3VyZmFjZSwgY29udGV4dCksCiAg ICAgICAgICAgICAgICAgICAgICAgICAgImVnbE1ha2VDdXJyZW50IiwgR2V0Q29udGV4dElmVmFs aWQoZGlzcGxheSwgY29udGV4dCksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JF VFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xNYWtlQ3VycmVudCIs CisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVH TF9GQUxTRSk7CiAgICAgU3VyZmFjZSAqcHJldmlvdXNEcmF3ICAgICAgICA9IHRocmVhZC0+Z2V0 Q3VycmVudERyYXdTdXJmYWNlKCk7CiAgICAgU3VyZmFjZSAqcHJldmlvdXNSZWFkICAgICAgICA9 IHRocmVhZC0+Z2V0Q3VycmVudFJlYWRTdXJmYWNlKCk7CiAgICAgZ2w6OkNvbnRleHQgKnByZXZp b3VzQ29udGV4dCA9IHRocmVhZC0+Z2V0Q29udGV4dCgpOwpAQCAtNTE3LDcgKzUyOSw4IEBAIEVH TEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5Q29udGV4dChFR0xEaXNwbGF5IGRweSwKIAog ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVRdWVyeUNvbnRleHQoZGlz cGxheSwgY29udGV4dCwgYXR0cmlidXRlLCB2YWx1ZSksCiAgICAgICAgICAgICAgICAgICAgICAg ICAgImVnbFF1ZXJ5Q29udGV4dCIsIEdldENvbnRleHRJZlZhbGlkKGRpc3BsYXksIGNvbnRleHQp LCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5 LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUXVlcnlDb250ZXh0IiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBRdWVy eUNvbnRleHRBdHRyaWIoY29udGV4dCwgYXR0cmlidXRlLCB2YWx1ZSk7CiAKICAgICB0aHJlYWQt PnNldFN1Y2Nlc3MoKTsKQEAgLTUzNCw2ICs1NDcsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZ IEVHTF9XYWl0R0wodm9pZCkKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFs aWRhdGVEaXNwbGF5KGRpc3BsYXkpLCAiZWdsV2FpdEdMIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlz cGxheSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgRUdMX0ZBTFNFKTsKKyAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xXYWl0 R0wiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp LCBFR0xfRkFMU0UpOwogCiAgICAgLy8gZWdsV2FpdEdMIGxpa2UgY2FsbGluZyBlZ2xXYWl0Q2xp ZW50IHdpdGggdGhlIE9wZW5HTCBFUyBBUEkgYm91bmQuIFNpbmNlIHdlIG9ubHkgaW1wbGVtZW50 CiAgICAgLy8gT3BlbkdMIEVTIHdlIGNhbiBkbyB0aGUgY2FsbCBkaXJlY3RseS4KQEAgLTU1NCw2 ICs1NjksOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9XYWl0TmF0aXZlKEVHTGludCBl bmdpbmUpCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlV2FpdE5h dGl2ZShkaXNwbGF5LCBlbmdpbmUpLCAiZWdsV2FpdE5hdGl2ZSIsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgR2V0VGhyZWFkSWZWYWxpZCh0aHJlYWQpLCBFR0xfRkFMU0UpOworICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFdh aXROYXRpdmUiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRp c3BsYXkpLCBFR0xfRkFMU0UpOwogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBk aXNwbGF5LT53YWl0TmF0aXZlKHRocmVhZC0+Z2V0Q29udGV4dCgpLCBlbmdpbmUpLCAiZWdsV2Fp dE5hdGl2ZSIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0VGhyZWFkSWZWYWxpZCh0aHJl YWQpLCBFR0xfRkFMU0UpOwpAQCAtNTc0LDYgKzU5MSw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5U UlkgRUdMX1N3YXBCdWZmZXJzKEVHTERpc3BsYXkgZHB5LCBFR0xTdXJmYWNlIHN1cmZhY2UpCiAK ICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlU3dhcEJ1ZmZlcnModGhy ZWFkLCBkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgImVnbFN3YXBCdWZmZXJzIiwKICAgICAgICAgICAg ICAgICAgICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdM X0ZBTFNFKTsKKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBh cmVGb3JDYWxsKCksICJlZ2xTd2FwQnVmZmVycyIsCisgICAgICAgICAgICAgICAgICAgICAgICAg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAKICAgICBBTkdMRV9FR0xf VFJZX1JFVFVSTih0aHJlYWQsIGVnbFN1cmZhY2UtPnN3YXAodGhyZWFkLT5nZXRDb250ZXh0KCkp LCAiZWdsU3dhcEJ1ZmZlcnMiLAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN1cmZhY2VJ ZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwpAQCAtNTk4LDcgKzYxNyw4 IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0NvcHlCdWZmZXJzKEVHTERpc3BsYXkgZHB5 LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZUNvcHlCdWZmZXJz KGRpc3BsYXksIGVnbFN1cmZhY2UpLCAiZWdsQ29weUJ1ZmZlcnMiLAogICAgICAgICAgICAgICAg ICAgICAgICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFM U0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJl Rm9yQ2FsbCgpLCAiZWdsQ29weUJ1ZmZlcnMiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdl dERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIFVOSU1QTEVNRU5URUQo KTsgIC8vIEZJWE1FCiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKQEAgLTYyMiw3ICs2NDIs OCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9CaW5kVGV4SW1hZ2UoRUdMRGlzcGxheSBk cHksIEVHTFN1cmZhY2Ugc3VyZmFjZSwgRUdMaQogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKAog ICAgICAgICB0aHJlYWQsIFZhbGlkYXRlQmluZFRleEltYWdlKGRpc3BsYXksIGVnbFN1cmZhY2Us IHN1cmZhY2UsIGJ1ZmZlciwgY29udGV4dCwgJnRleHR1cmVPYmplY3QpLAogICAgICAgICAiZWds QmluZFRleEltYWdlIiwgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVH TF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnBy ZXBhcmVGb3JDYWxsKCksICJlZ2xCaW5kVGV4SW1hZ2UiLAorICAgICAgICAgICAgICAgICAgICAg ICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGlmIChjb250 ZXh0KQogICAgIHsKICAgICAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBlZ2xTdXJm YWNlLT5iaW5kVGV4SW1hZ2UoY29udGV4dCwgdGV4dHVyZU9iamVjdCwgYnVmZmVyKSwKQEAgLTY1 MCw3ICs2NzEsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9TdXJmYWNlQXR0cmliKEVH TERpc3BsYXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0 ZVN1cmZhY2VBdHRyaWIoZGlzcGxheSwgZWdsU3VyZmFjZSwgYXR0cmlidXRlLCB2YWx1ZSksCiAg ICAgICAgICAgICAgICAgICAgICAgICAgImVnbFN1cmZhY2VBdHRyaWIiLCBHZXRTdXJmYWNlSWZW YWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9U UllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFN1cmZhY2VB dHRyaWIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBFR0xfRkFMU0UpOwogICAgIFNldFN1cmZhY2VBdHRyaWIoZWdsU3VyZmFjZSwgYXR0cmli dXRlLCB2YWx1ZSk7CiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKQEAgLTY3MSw2ICs2OTMs OCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9SZWxlYXNlVGV4SW1hZ2UoRUdMRGlzcGxh eSBkcHksIEVHTFN1cmZhY2Ugc3VyZmFjZSwgRQogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgVmFsaWRhdGVSZWxlYXNlVGV4SW1hZ2UoZGlzcGxheSwgZWdsU3VyZmFjZSwgc3VyZmFj ZSwgYnVmZmVyKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsUmVsZWFzZVRleEltYWdl IiwgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9GQUxTRSk7CiAK KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxs KCksICJlZ2xSZWxlYXNlVGV4SW1hZ2UiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGdsOjpUZXh0dXJlICp0ZXh0 dXJlID0gZWdsU3VyZmFjZS0+Z2V0Qm91bmRUZXh0dXJlKCk7CiAKICAgICBpZiAodGV4dHVyZSkK QEAgLTY5Nyw3ICs3MjEsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9Td2FwSW50ZXJ2 YWwoRUdMRGlzcGxheSBkcHksIEVHTGludCBpbnRlcnZhbCkKIAogICAgIEFOR0xFX0VHTF9UUllf UkVUVVJOKHRocmVhZCwgVmFsaWRhdGVTd2FwSW50ZXJ2YWwoZGlzcGxheSwgZHJhd19zdXJmYWNl LCBjb250ZXh0KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsU3dhcEludGVydmFsIiwg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xf VFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xTd2FwSW50 ZXJ2YWwiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBFR0xfRkFMU0UpOwogICAgIGNvbnN0IGVnbDo6Q29uZmlnICpzdXJmYWNlQ29uZmlnID0g ZHJhd19zdXJmYWNlLT5nZXRDb25maWcoKTsKICAgICBFR0xpbnQgY2xhbXBlZEludGVydmFsICAg ICAgICAgICA9IHN0ZDo6bWluKHN0ZDo6bWF4KGludGVydmFsLCBzdXJmYWNlQ29uZmlnLT5taW5T d2FwSW50ZXJ2YWwpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdXJm YWNlQ29uZmlnLT5tYXhTd2FwSW50ZXJ2YWwpOwpAQCAtNzU5LDcgKzc4NCw4IEBAIEVHTFN1cmZh Y2UgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVBidWZmZXJGcm9tQ2xpZW50QnVmZmVyKEVHTERpc3Bs YXkgZHB5LAogICAgICAgICB0aHJlYWQsCiAgICAgICAgIFZhbGlkYXRlQ3JlYXRlUGJ1ZmZlckZy b21DbGllbnRCdWZmZXIoZGlzcGxheSwgYnVmdHlwZSwgYnVmZmVyLCBjb25maWd1cmF0aW9uLCBh dHRyaWJ1dGVzKSwKICAgICAgICAgImVnbENyZWF0ZVBidWZmZXJGcm9tQ2xpZW50QnVmZmVyIiwg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKLQorICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENy ZWF0ZVBidWZmZXJGcm9tQ2xpZW50QnVmZmVyIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBH ZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIGVnbDo6U3Vy ZmFjZSAqc3VyZmFjZSA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LAogICAgICAgICAgICAgICAgICAgICAgICAgIGRpc3BsYXktPmNyZWF0ZVBidWZmZXJGcm9tQ2xp ZW50QnVmZmVyKGNvbmZpZ3VyYXRpb24sIGJ1ZnR5cGUsIGJ1ZmZlciwKQEAgLTc4MSwxNiArODA3 LDE5IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1JlbGVhc2VUaHJlYWQodm9pZCkKICAg ICBnbDo6Q29udGV4dCAqcHJldmlvdXNDb250ZXh0ICA9IHRocmVhZC0+Z2V0Q29udGV4dCgpOwog ICAgIGVnbDo6RGlzcGxheSAqcHJldmlvdXNEaXNwbGF5ID0gdGhyZWFkLT5nZXREaXNwbGF5KCk7 CiAKLSAgICAvLyBPbmx5IGNhbGwgbWFrZUN1cnJlbnQgaWYgdGhlIGNvbnRleHQgb3Igc3VyZmFj ZXMgaGF2ZSBjaGFuZ2VkLgotICAgIGlmIChwcmV2aW91c0RyYXcgIT0gRUdMX05PX1NVUkZBQ0Ug fHwgcHJldmlvdXNSZWFkICE9IEVHTF9OT19TVVJGQUNFIHx8Ci0gICAgICAgIHByZXZpb3VzQ29u dGV4dCAhPSBFR0xfTk9fQ09OVEVYVCkKLSAgICB7Ci0gICAgICAgIGlmIChwcmV2aW91c0Rpc3Bs YXkgIT0gRUdMX05PX0RJU1BMQVkpCisgICAgaWYgKHByZXZpb3VzRGlzcGxheSAhPSBFR0xfTk9f RElTUExBWSkgeworICAgICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIHByZXZpb3Vz RGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFJlbGVhc2VUaHJlYWQiLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChwcmV2aW91c0Rpc3BsYXkpLCBF R0xfRkFMU0UpOworICAgICAgICAvLyBPbmx5IGNhbGwgbWFrZUN1cnJlbnQgaWYgdGhlIGNvbnRl eHQgb3Igc3VyZmFjZXMgaGF2ZSBjaGFuZ2VkLgorICAgICAgICBpZiAocHJldmlvdXNEcmF3ICE9 IEVHTF9OT19TVVJGQUNFIHx8IHByZXZpb3VzUmVhZCAhPSBFR0xfTk9fU1VSRkFDRSB8fAorICAg ICAgICAgICAgcHJldmlvdXNDb250ZXh0ICE9IEVHTF9OT19DT05URVhUKQogICAgICAgICB7CiAg ICAgICAgICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBwcmV2aW91c0Rpc3BsYXktPm1ha2VDdXJyZW50KHRocmVhZCwgbnVs bHB0ciwgbnVsbHB0ciwgbnVsbHB0ciksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAiZWdsUmVsZWFzZVRocmVhZCIsIG51bGxwdHIsIEVHTF9GQUxTRSk7CiAgICAgICAgIH0KKyAg ICAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBwcmV2aW91c0Rpc3BsYXktPnJlbGVh c2VUaHJlYWQoKSwgImVnbFJlbGVhc2VUaHJlYWQiLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBHZXREaXNwbGF5SWZWYWxpZChwcmV2aW91c0Rpc3BsYXkpLCBFR0xfRkFMU0UpOwogCiAg ICAgICAgIFNldENvbnRleHRDdXJyZW50KHRocmVhZCwgbnVsbHB0cik7CiAgICAgfQpAQCAtODEw LDcgKzgzOSw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1dhaXRDbGllbnQodm9pZCkK IAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVEaXNwbGF5KGRpc3Bs YXkpLCAiZWdsV2FpdENsaWVudCIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0Q29udGV4 dElmVmFsaWQoZGlzcGxheSwgY29udGV4dCksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xf VFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xXYWl0Q2xp ZW50IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5 KSwgRUdMX0ZBTFNFKTsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXkt PndhaXRDbGllbnQoY29udGV4dCksICJlZ2xXYWl0Q2xpZW50IiwKICAgICAgICAgICAgICAgICAg ICAgICAgICBHZXRDb250ZXh0SWZWYWxpZChkaXNwbGF5LCBjb250ZXh0KSwgRUdMX0ZBTFNFKTsK IApAQCAtODQ5LDcgKzg3OSw4IEBAIEVHTFN5bmMgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVN5bmMo RUdMRGlzcGxheSBkcHksIEVHTGVudW0gdHlwZSwgY29uc3QgRUdMQXR0cmliCiAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4oCiAgICAgICAgIHRocmVhZCwgVmFsaWRhdGVDcmVhdGVTeW5jKGRpc3Bs YXksIHR5cGUsIGF0dHJpYnV0ZXMsIGN1cnJlbnREaXNwbGF5LCBjdXJyZW50Q29udGV4dCksCiAg ICAgICAgICJlZ2xDcmVhdGVTeW5jIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9O T19TWU5DKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJl cGFyZUZvckNhbGwoKSwgImVnbENyZWF0ZVN5bmMiLAorICAgICAgICAgICAgICAgICAgICAgICAg IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGVnbDo6U3luYyAq c3luY09iamVjdCA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBk aXNwbGF5LT5jcmVhdGVTeW5jKGN1cnJlbnRDb250ZXh0LCB0eXBlLCBhdHRyaWJ1dGVzLCAmc3lu Y09iamVjdCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVN5bmMiLCBHZXRE aXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NZTkMpOwpAQCAtODcwLDcgKzkwMSw4IEBA IEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0Rlc3Ryb3lTeW5jKEVHTERpc3BsYXkgZHB5LCBF R0xTeW5jIHN5bmMpCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRl RGVzdHJveVN5bmMoZGlzcGxheSwgc3luY09iamVjdCksICJlZ2xEZXN0cm95U3luYyIsCiAgICAg ICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxT RSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVG b3JDYWxsKCksICJlZ2xEZXN0cm95U3luYyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZGlzcGxheS0+ZGVzdHJv eVN5bmMoc3luY09iamVjdCk7CiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKQEAgLTg5MSw3 ICs5MjMsOCBAQCBFR0xpbnQgRUdMQVBJRU5UUlkgRUdMX0NsaWVudFdhaXRTeW5jKEVHTERpc3Bs YXkgZHB5LCBFR0xTeW5jIHN5bmMsIEVHTGludCBmbGFncwogCiAgICAgQU5HTEVfRUdMX1RSWV9S RVRVUk4odGhyZWFkLCBWYWxpZGF0ZUNsaWVudFdhaXRTeW5jKGRpc3BsYXksIHN5bmNPYmplY3Qs IGZsYWdzLCB0aW1lb3V0KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsQ2xpZW50V2Fp dFN5bmMiLCBHZXRTeW5jSWZWYWxpZChkaXNwbGF5LCBzeW5jT2JqZWN0KSwgRUdMX0ZBTFNFKTsK LQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNh bGwoKSwgImVnbENsaWVudFdhaXRTeW5jIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXRE aXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBnbDo6Q29udGV4dCAqY3Vy cmVudENvbnRleHQgPSB0aHJlYWQtPmdldENvbnRleHQoKTsKICAgICBFR0xpbnQgc3luY1N0YXR1 cyAgICAgICAgICAgPSBFR0xfRkFMU0U7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4oCkBAIC05 NTQsNiArOTg3LDggQEAgRUdMSW1hZ2UgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZUltYWdlKEVHTERp c3BsYXkgZHB5LAogICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1ZygpLCAi ZWdsQ3JlYXRlSW1hZ2UiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAgICAgIHJl dHVybiBFR0xfTk9fSU1BR0U7CiAgICAgfQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENyZWF0ZUltYWdlIiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsK IAogICAgIEltYWdlICppbWFnZSA9IG51bGxwdHI7CiAgICAgZXJyb3IgICAgICAgID0gZGlzcGxh eS0+Y3JlYXRlSW1hZ2UoY29udGV4dCwgdGFyZ2V0LCBidWZmZXIsIGF0dHJpYnV0ZXMsICZpbWFn ZSk7CkBAIC05ODIsNyArMTAxNyw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0Rlc3Ry b3lJbWFnZShFR0xEaXNwbGF5IGRweSwgRUdMSW1hZ2UgaW1hZ2UpCiAgICAgICAgIHRocmVhZC0+ c2V0RXJyb3IoZXJyb3IsIEdldERlYnVnKCksICJlZ2xEZXN0cm95SW1hZ2UiLCBHZXRJbWFnZUlm VmFsaWQoZGlzcGxheSwgaW1nKSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQot CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2Fs bCgpLCAiZWdsRGVzdHJveUltYWdlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBkaXNwbGF5LT5kZXN0cm95SW1h Z2UoaW1nKTsKIAogICAgIHRocmVhZC0+c2V0U3VjY2VzcygpOwpAQCAtMTA0MywxMiArMTA3OSwx MyBAQCBFR0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQbGF0Zm9ybVdpbmRvd1N1cmZh Y2UoRUdMRGlzcGxheSBkcHksCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgVmFsaWRhdGVDcmVhdGVXaW5kb3dTdXJmYWNlKGRpc3Bs YXksIGNvbmZpZ3VyYXRpb24sIHdpbiwgYXR0cmlidXRlcyksCi0gICAgICAgICAgICAgICAgICAg ICAgICAgImVnbENyZWF0ZVdpbmRvd1N1cmZhY2UiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5 KSwgRUdMX05PX1NVUkZBQ0UpOwotCisgICAgICAgICAgICAgICAgICAgICAgICAgImVnbFBsYXRm b3JtQ3JlYXRlV2luZG93U3VyZmFjZSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xf Tk9fU1VSRkFDRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5w cmVwYXJlRm9yQ2FsbCgpLCAiZWdsQ3JlYXRlV2luZG93U3VyZmFjZSIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsK ICAgICBlZ2w6OlN1cmZhY2UgKnN1cmZhY2UgPSBudWxscHRyOwogICAgIEFOR0xFX0VHTF9UUllf UkVUVVJOKHRocmVhZCwKICAgICAgICAgICAgICAgICAgICAgICAgICBkaXNwbGF5LT5jcmVhdGVX aW5kb3dTdXJmYWNlKGNvbmZpZ3VyYXRpb24sIHdpbiwgYXR0cmlidXRlcywgJnN1cmZhY2UpLAot ICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVXaW5kb3dTdXJmYWNlIiwgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKKyAgICAgICAgICAgICAgICAg ICAgICAgICAiZWdsUGxhdGZvcm1DcmVhdGVXaW5kb3dTdXJmYWNlIiwgR2V0RGlzcGxheUlmVmFs aWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKIAogICAgIHJldHVybiBzdGF0aWNfY2FzdDxF R0xTdXJmYWNlPihzdXJmYWNlKTsKIH0KQEAgLTEwNzUsNyArMTExMiw4IEBAIEVHTFN1cmZhY2Ug RUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZShFR0xEaXNwbGF5IGRw eSwKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTigKICAgICAgICAgdGhyZWFkLCBWYWxpZGF0ZUNy ZWF0ZVBpeG1hcFN1cmZhY2UoZGlzcGxheSwgY29uZmlndXJhdGlvbiwgcGl4bWFwLCBhdHRyaWJ1 dGVzKSwKICAgICAgICAgImVnbENyZWF0ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZSIsIEdldERpc3Bs YXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZ X1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVQbGF0 Zm9ybVBpeG1hcFN1cmZhY2UiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7CiAgICAgZWdsOjpTdXJmYWNlICpzdXJm YWNlID0gbnVsbHB0cjsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTigKICAgICAgICAgdGhyZWFk LCBkaXNwbGF5LT5jcmVhdGVQaXhtYXBTdXJmYWNlKGNvbmZpZ3VyYXRpb24sIHBpeG1hcCwgYXR0 cmlidXRlcywgJnN1cmZhY2UpLApAQCAtMTA5OSw3ICsxMTM3LDggQEAgRUdMQm9vbGVhbiBFR0xB UElFTlRSWSBFR0xfV2FpdFN5bmMoRUdMRGlzcGxheSBkcHksIEVHTFN5bmMgc3luYywgRUdMaW50 IGZsYWdzKQogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVdhaXRT eW5jKGRpc3BsYXksIGNvbnRleHQsIHN5bmNPYmplY3QsIGZsYWdzKSwKICAgICAgICAgICAgICAg ICAgICAgICAgICAiZWdsV2FpdFN5bmMiLCBHZXRTeW5jSWZWYWxpZChkaXNwbGF5LCBzeW5jT2Jq ZWN0KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlz cGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFdhaXRTeW5jIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBnbDo6 Q29udGV4dCAqY3VycmVudENvbnRleHQgPSB0aHJlYWQtPmdldENvbnRleHQoKTsKICAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIHN5bmNPYmplY3QtPnNlcnZlcldhaXQoZGlzcGxheSwg Y3VycmVudENvbnRleHQsIGZsYWdzKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsV2Fp dFN5bmMiLCBHZXRTeW5jSWZWYWxpZChkaXNwbGF5LCBzeW5jT2JqZWN0KSwgRUdMX0ZBTFNFKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJHTEVTdjIvZW50cnlf cG9pbnRzX2VnbF9leHQuY3BwIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkdMRVN2 Mi9lbnRyeV9wb2ludHNfZWdsX2V4dC5jcHAKaW5kZXggOWRlNjAzMzUzNTRlYTczNzRmNDBjZWQ0 MmM3ODBmNTA1OTc3OWRmMC4uZTJjNjVlYTZiZTQ1YTY3Yjk5YzMzNzNiZDE0MzMwNmU1YmU2YzY2 MyAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkdMRVN2Mi9lbnRy eV9wb2ludHNfZWdsX2V4dC5jcHAKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xp YkdMRVN2Mi9lbnRyeV9wb2ludHNfZWdsX2V4dC5jcHAKQEAgLTg2LDcgKzg2LDggQEAgRUdMQm9v bGVhbiBFR0xBUElFTlRSWSBFR0xfUXVlcnlTdXJmYWNlUG9pbnRlckFOR0xFKEVHTERpc3BsYXkg ZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNw bGF5LCBlZ2xTdXJmYWNlKSk7CiAgICAgICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0K LQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNh bGwoKSwgImVnbFF1ZXJ5U3VyZmFjZVBvaW50ZXJBTkdMRSIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZXJyb3Ig PSBlZ2xTdXJmYWNlLT5xdWVyeVN1cmZhY2VQb2ludGVyQU5HTEUoYXR0cmlidXRlLCB2YWx1ZSk7 CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkKICAgICB7CkBAIC0xNTEsNyArMTUyLDggQEAgRUdM Qm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfUG9zdFN1YkJ1ZmZlck5WKEVHTERpc3BsYXkgZHB5LAog ICAgICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKICAgICAgICAgcmV0dXJuIEVHTF9UUlVFOwog ICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFy ZUZvckNhbGwoKSwgImVnbFBvc3RTdWJCdWZmZXJOViIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgLy8gVE9ETyhq bWFkaWxsKTogVmFsaWRhdGUgU3VyZmFjZSBpcyBib3VuZCB0byB0aGUgdGhyZWFkLgogICAgIGVy cm9yID0gZWdsU3VyZmFjZS0+cG9zdFN1YkJ1ZmZlcih0aHJlYWQtPmdldENvbnRleHQoKSwgeCwg eSwgd2lkdGgsIGhlaWdodCk7CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkKQEAgLTIyMyw3ICsy MjUsOCBAQCBFR0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQbGF0Zm9ybVdpbmRvd1N1 cmZhY2VFWFQoRUdMRGlzcGxheSBkcHksCiAgICAgICAgIHRocmVhZCwKICAgICAgICAgVmFsaWRh dGVDcmVhdGVQbGF0Zm9ybVdpbmRvd1N1cmZhY2VFWFQoZGlzcGxheSwgY29uZmlndXJhdGlvbiwg bmF0aXZlX3dpbmRvdywgYXR0cmlidXRlcyksCiAgICAgICAgICJlZ2xDcmVhdGVQbGF0Zm9ybVdp bmRvd1N1cmZhY2VFWFQiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZB Q0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJl Rm9yQ2FsbCgpLCAiZWdsQ3JlYXRlUGxhdGZvcm1XaW5kb3dTdXJmYWNlRVhUIiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZB Q0UpOwogICAgIHRocmVhZC0+c2V0RXJyb3IoRWdsQmFkRGlzcGxheSgpIDw8ICJDcmVhdGVQbGF0 Zm9ybVdpbmRvd1N1cmZhY2VFWFQgdW5pbXBsZW1lbnRlZC4iLCBHZXREZWJ1ZygpLAogICAgICAg ICAgICAgICAgICAgICAgImVnbENyZWF0ZVBsYXRmb3JtV2luZG93U3VyZmFjZUVYVCIsIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKICAgICByZXR1cm4gRUdMX05PX1NVUkZBQ0U7CkBAIC0y NTAsNyArMjUzLDggQEAgRUdMU3VyZmFjZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlUGxhdGZvcm1Q aXhtYXBTdXJmYWNlRVhUKEVHTERpc3BsYXkgZHB5LAogICAgICAgICB0aHJlYWQsCiAgICAgICAg IFZhbGlkYXRlQ3JlYXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNlRVhUKGRpc3BsYXksIGNvbmZpZ3Vy YXRpb24sIG5hdGl2ZV9waXhtYXAsIGF0dHJpYnV0ZXMpLAogICAgICAgICAiZWdsQ3JlYXRlUGxh dGZvcm1QaXhtYXBTdXJmYWNlRVhUIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9O T19TVVJGQUNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+ cHJlcGFyZUZvckNhbGwoKSwgImVnbENyZWF0ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZUVYVCIsCisg ICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9O T19TVVJGQUNFKTsKICAgICB0aHJlYWQtPnNldEVycm9yKEVnbEJhZERpc3BsYXkoKSA8PCAiQ3Jl YXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNlRVhUIHVuaW1wbGVtZW50ZWQuIiwgR2V0RGVidWcoKSwK ICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVQbGF0Zm9ybVBpeG1hcFN1cmZhY2VFWFQi LCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAgcmV0dXJuIEVHTF9OT19TVVJGQUNF OwpAQCAtMjc1LDEwICsyNzksMTEgQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfUXVlcnlE ZXZpY2VBdHRyaWJFWFQoRUdMRGV2aWNlRVhUIGRldmljZSwKICAgICAgICAgdGhyZWFkLT5zZXRF cnJvcihlcnJvciwgR2V0RGVidWcoKSwgImVnbFF1ZXJ5RGV2aWNlQXR0cmliRVhUIiwgR2V0RGV2 aWNlSWZWYWxpZChkZXYpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAg ICBlZ2w6OkRpc3BsYXkgKm93bmluZ0Rpc3BsYXkgPSBkZXYtPmdldE93bmluZ0Rpc3BsYXkoKTsK KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIG93bmluZ0Rpc3BsYXktPnByZXBhcmVG b3JDYWxsKCksICJlZ2xRdWVyeURldmljZUF0dHJpYkVYVCIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQob3duaW5nRGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAg Ly8gSWYgdGhlIGRldmljZSB3YXMgY3JlYXRlZCBieSAoYW5kIGlzIG93bmVkIGJ5KSBhIGRpc3Bs YXksIGFuZCB0aGF0IGRpc3BsYXkgZG9lc24ndCBzdXBwb3J0CiAgICAgLy8gZGV2aWNlIHF1ZXJ5 aW5nLCB0aGVuIHRoaXMgY2FsbCBzaG91bGQgZmFpbAotICAgIGVnbDo6RGlzcGxheSAqb3duaW5n RGlzcGxheSA9IGRldi0+Z2V0T3duaW5nRGlzcGxheSgpOwogICAgIGlmIChvd25pbmdEaXNwbGF5 ICE9IG51bGxwdHIgJiYgIW93bmluZ0Rpc3BsYXktPmdldEV4dGVuc2lvbnMoKS5kZXZpY2VRdWVy eSkKICAgICB7CiAgICAgICAgIHRocmVhZC0+c2V0RXJyb3IoRWdsQmFkQWNjZXNzKCkgPDwgIkRl dmljZSB3YXNuJ3QgY3JlYXRlZCB1c2luZyBlZ2xDcmVhdGVEZXZpY2VBTkdMRSwgIgpAQCAtMzUx LDcgKzM1Niw5IEBAIGNvbnN0IGNoYXIgKkVHTEFQSUVOVFJZIEVHTF9RdWVyeURldmljZVN0cmlu Z0VYVChFR0xEZXZpY2VFWFQgZGV2aWNlLCBFR0xpbnQgbmFtCiAgICAgICAgIHRocmVhZC0+c2V0 RXJyb3IoZXJyb3IsIEdldERlYnVnKCksICJlZ2xRdWVyeURldmljZVN0cmluZ0VYVCIsIEdldERl dmljZUlmVmFsaWQoZGV2KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisg ICAgZWdsOjpEaXNwbGF5ICpvd25pbmdEaXNwbGF5ID0gZGV2LT5nZXRPd25pbmdEaXNwbGF5KCk7 CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBvd25pbmdEaXNwbGF5LT5wcmVwYXJl Rm9yQ2FsbCgpLCAiZWdsUXVlcnlEZXZpY2VTdHJpbmdFWFQiLAorICAgICAgICAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKG93bmluZ0Rpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAg IGNvbnN0IGNoYXIgKnJlc3VsdDsKICAgICBzd2l0Y2ggKG5hbWUpCiAgICAgewpAQCAtMzgxLDcg KzM4OCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5RGlzcGxheUF0dHJpYkVY VChFR0xEaXNwbGF5IGRweSwgRUdMaW50IGF0dHJpYnV0CiAKICAgICBBTkdMRV9FR0xfVFJZX1JF VFVSTih0aHJlYWQsIFZhbGlkYXRlUXVlcnlEaXNwbGF5QXR0cmliRVhUKGRpc3BsYXksIGF0dHJp YnV0ZSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbFF1ZXJ5RGlzcGxheUF0dHJpYkVY VCIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUXVl cnlEaXNwbGF5QXR0cmliRVhUIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5 SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICAqdmFsdWUgPSBkaXNwbGF5LT5xdWVy eUF0dHJpYihhdHRyaWJ1dGUpOwogICAgIHRocmVhZC0+c2V0U3VjY2VzcygpOwogICAgIHJldHVy biBFR0xfVFJVRTsKQEAgLTQwMiw3ICs0MTAsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVH TF9RdWVyeURpc3BsYXlBdHRyaWJBTkdMRShFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VH TF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVRdWVyeURpc3BsYXlBdHRyaWJBTkdMRShkaXNw bGF5LCBhdHRyaWJ1dGUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xRdWVyeURpc3Bs YXlBdHRyaWJBTkdMRSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwot CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2Fs bCgpLCAiZWdsUXVlcnlEaXNwbGF5QXR0cmliQU5HTEUiLAorICAgICAgICAgICAgICAgICAgICAg ICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgICp2YWx1ZSA9 IGRpc3BsYXktPnF1ZXJ5QXR0cmliKGF0dHJpYnV0ZSk7CiAgICAgdGhyZWFkLT5zZXRTdWNjZXNz KCk7CiAgICAgcmV0dXJuIEVHTF9UUlVFOwpAQCAtNDMzLDcgKzQ0Miw4IEBAIEFOR0xFX0VYUE9S VCBFR0xJbWFnZUtIUiBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlSW1hZ2VLSFIoRUdMRGlzcGxheSBk cHksCiAgICAgICAgIHRocmVhZC0+c2V0RXJyb3IoZXJyb3IsIEdldERlYnVnKCksICJlZ2xDcmVh dGVJbWFnZUtIUiIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKICAgICAgICAgcmV0dXJu IEVHTF9OT19JTUFHRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs IGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVJbWFnZUtIUiIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19JTUFH RSk7CiAgICAgSW1hZ2UgKmltYWdlID0gbnVsbHB0cjsKICAgICBlcnJvciAgICAgICAgPSBkaXNw bGF5LT5jcmVhdGVJbWFnZShjb250ZXh0LCB0YXJnZXQsIGJ1ZmZlciwgYXR0cmlidXRlcywgJmlt YWdlKTsKICAgICBpZiAoZXJyb3IuaXNFcnJvcigpKQpAQCAtNDYyLDcgKzQ3Miw4IEBAIEFOR0xF X0VYUE9SVCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9EZXN0cm95SW1hZ2VLSFIoRUdMRGlz cGxheSBkcHksIEVHTEltYWdlCiAgICAgICAgIHRocmVhZC0+c2V0RXJyb3IoZXJyb3IsIEdldERl YnVnKCksICJlZ2xEZXN0cm95SW1hZ2VLSFIiLCBHZXRJbWFnZUlmVmFsaWQoZGlzcGxheSwgaW1n KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisgICAgQU5HTEVfRUdMX1RS WV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsRGVzdHJveUlt YWdlS0hSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNw bGF5KSwgRUdMX0ZBTFNFKTsKICAgICBkaXNwbGF5LT5kZXN0cm95SW1hZ2UoaW1nKTsKIAogICAg IHRocmVhZC0+c2V0U3VjY2VzcygpOwpAQCAtNTM4LDcgKzU0OSw4IEBAIEVHTFN0cmVhbUtIUiBF R0xBUElFTlRSWSBFR0xfQ3JlYXRlU3RyZWFtS0hSKEVHTERpc3BsYXkgZHB5LCBjb25zdCBFR0xp bnQgKmF0dHJpCiAgICAgICAgIHRocmVhZC0+c2V0RXJyb3IoZXJyb3IsIEdldERlYnVnKCksICJl Z2xDcmVhdGVTdHJlYW1LSFIiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAgICAg IHJldHVybiBFR0xfTk9fU1RSRUFNX0tIUjsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JF VFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVTdHJlYW1L SFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp LCBFR0xfTk9fU1RSRUFNX0tIUik7CiAgICAgU3RyZWFtICpzdHJlYW07CiAgICAgZXJyb3IgPSBk aXNwbGF5LT5jcmVhdGVTdHJlYW0oYXR0cmlidXRlcywgJnN0cmVhbSk7CiAgICAgaWYgKGVycm9y LmlzRXJyb3IoKSkKQEAgLTU2OCw3ICs1ODAsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVH TF9EZXN0cm95U3RyZWFtS0hSKEVHTERpc3BsYXkgZHB5LCBFR0xTdHJlYW1LSFIgc3RyZWFtKQog ICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQoZGlzcGxheSwgc3RyZWFt T2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsRGVz dHJveVN0cmVhbUtIUiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFs aWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZGlzcGxheS0+ZGVzdHJveVN0cmVhbShzdHJl YW1PYmplY3QpOwogCiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CkBAIC01OTcsNyArNjEwLDgg QEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfU3RyZWFtQXR0cmliS0hSKEVHTERpc3BsYXkg ZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQoZGlzcGxheSwg c3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAi ZWdsU3RyZWFtQXR0cmliS0hSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5 SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBzd2l0Y2ggKGF0dHJpYnV0ZSkKICAg ICB7CiAgICAgICAgIGNhc2UgRUdMX0NPTlNVTUVSX0xBVEVOQ1lfVVNFQ19LSFI6CkBAIC02MzYs NyArNjUwLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfUXVlcnlTdHJlYW1LSFIoRUdM RGlzcGxheSBkcHksCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3RyZWFtSWZWYWxpZChk aXNwbGF5LCBzdHJlYW1PYmplY3QpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9 Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JD YWxsKCksICJlZ2xRdWVyeVN0cmVhbUtIUiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgc3dpdGNoIChhdHRyaWJ1 dGUpCiAgICAgewogICAgICAgICBjYXNlIEVHTF9TVFJFQU1fU1RBVEVfS0hSOgpAQCAtNjc4LDcg KzY5Myw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5U3RyZWFtdTY0S0hSKEVH TERpc3BsYXkgZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQo ZGlzcGxheSwgc3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAg fQotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9y Q2FsbCgpLCAiZWdsUXVlcnlTdHJlYW11NjRLSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAg IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIHN3aXRjaCAoYXR0 cmlidXRlKQogICAgIHsKICAgICAgICAgY2FzZSBFR0xfUFJPRFVDRVJfRlJBTUVfS0hSOgpAQCAt NzEzLDcgKzcyOSw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N0cmVhbUNvbnN1bWVy R0xUZXh0dXJlRXh0ZXJuYWxLSFIoRUdMRGlzcGxheSBkcHksIEVHCiAgICAgICAgICAgICAgICAg ICAgICAgICAgR2V0U3RyZWFtSWZWYWxpZChkaXNwbGF5LCBzdHJlYW1PYmplY3QpKTsKICAgICAg ICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xTdHJlYW1Db25zdW1lckdMVGV4 dHVyZUV4dGVybmFsS0hSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZW YWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBlcnJvciA9IHN0cmVhbU9iamVjdC0+Y3Jl YXRlQ29uc3VtZXJHTFRleHR1cmVFeHRlcm5hbChBdHRyaWJ1dGVNYXAoKSwgY29udGV4dCk7CiAg ICAgaWYgKGVycm9yLmlzRXJyb3IoKSkKICAgICB7CkBAIC03NDQsNyArNzYxLDggQEAgRUdMQm9v bGVhbiBFR0xBUElFTlRSWSBFR0xfU3RyZWFtQ29uc3VtZXJBY3F1aXJlS0hSKEVHTERpc3BsYXkg ZHB5LCBFR0xTdHJlYW1LSFIKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZh bGlkKGRpc3BsYXksIHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwog ICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFy ZUZvckNhbGwoKSwgImVnbFN0cmVhbUNvbnN1bWVyQWNxdWlyZUtIUiIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAg ZXJyb3IgPSBzdHJlYW1PYmplY3QtPmNvbnN1bWVyQWNxdWlyZShjb250ZXh0KTsKICAgICBpZiAo ZXJyb3IuaXNFcnJvcigpKQogICAgIHsKQEAgLTc3NSw3ICs3OTMsOCBAQCBFR0xCb29sZWFuIEVH TEFQSUVOVFJZIEVHTF9TdHJlYW1Db25zdW1lclJlbGVhc2VLSFIoRUdMRGlzcGxheSBkcHksIEVH TFN0cmVhbUtIUgogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQoZGlz cGxheSwgc3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQot CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2Fs bCgpLCAiZWdsU3RyZWFtQ29uc3VtZXJSZWxlYXNlS0hSIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBlcnJvciA9 IHN0cmVhbU9iamVjdC0+Y29uc3VtZXJSZWxlYXNlKGNvbnRleHQpOwogICAgIGlmIChlcnJvci5p c0Vycm9yKCkpCiAgICAgewpAQCAtODExLDcgKzgzMCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5U UlkgRUdMX1N0cmVhbUNvbnN1bWVyR0xUZXh0dXJlRXh0ZXJuYWxBdHRyaWJzTlYoRUdMRGlzcGxh eSBkCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3RyZWFtSWZWYWxpZChkaXNwbGF5LCBz dHJlYW1PYmplY3QpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJl Z2xTdHJlYW1Db25zdW1lckdMVGV4dHVyZUV4dGVybmFsQXR0cmlic05WIiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAg ICBlcnJvciA9IHN0cmVhbU9iamVjdC0+Y3JlYXRlQ29uc3VtZXJHTFRleHR1cmVFeHRlcm5hbChh dHRyaWJ1dGVzLCBjb250ZXh0KTsKICAgICBpZiAoZXJyb3IuaXNFcnJvcigpKQogICAgIHsKQEAg LTg0NSw3ICs4NjUsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVTdHJlYW1Q cm9kdWNlckQzRFRleHR1cmVBTkdMRShFR0xEaXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAg ICAgICAgICBHZXRTdHJlYW1JZlZhbGlkKGRpc3BsYXksIHN0cmVhbU9iamVjdCkpOwogICAgICAg ICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENyZWF0ZVN0cmVhbVByb2R1Y2Vy RDNEVGV4dHVyZUFOR0xFIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZW YWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBlcnJvciA9IHN0cmVhbU9iamVjdC0+Y3Jl YXRlUHJvZHVjZXJEM0QxMVRleHR1cmUoYXR0cmlidXRlcyk7CiAgICAgaWYgKGVycm9yLmlzRXJy b3IoKSkKICAgICB7CkBAIC04ODIsNyArOTAzLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBF R0xfU3RyZWFtUG9zdEQzRFRleHR1cmVBTkdMRShFR0xEaXNwbGF5IGRweSwKICAgICAgICAgICAg ICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZhbGlkKGRpc3BsYXksIHN0cmVhbU9iamVjdCkpOwog ICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFN0cmVhbVBvc3REM0RU ZXh0dXJlQU5HTEUiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGVycm9yID0gc3RyZWFtT2JqZWN0LT5wb3N0RDNE MTFUZXh0dXJlKHRleHR1cmUsIGF0dHJpYnV0ZXMpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkp CiAgICAgewpAQCAtOTE1LDcgKzkzNyw4IEBAIEFOR0xFX0VYUE9SVCBFR0xTeW5jIEVHTEFQSUVO VFJZIEVHTF9DcmVhdGVTeW5jS0hSKEVHTERpc3BsYXkgZHB5LAogICAgIEFOR0xFX0VHTF9UUllf UkVUVVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlkYXRlQ3JlYXRlU3luY0tIUihkaXNwbGF5LCB0 eXBlLCBhdHRyaWJ1dGVzLCBjdXJyZW50RGlzcGxheSwgY3VycmVudENvbnRleHQpLAogICAgICAg ICAiZWdsQ3JlYXRlU3luYyIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1lO Qyk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVG b3JDYWxsKCksICJlZ2xDcmVhdGVTeW5jIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXRE aXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NZTkMpOwogICAgIGVnbDo6U3luYyAqc3lu Y09iamVjdCA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNw bGF5LT5jcmVhdGVTeW5jKGN1cnJlbnRDb250ZXh0LCB0eXBlLCBhdHRyaWJ1dGVzLCAmc3luY09i amVjdCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVN5bmMiLCBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NZTkMpOwpAQCAtOTM2LDcgKzk1OSw4IEBAIEFO R0xFX0VYUE9SVCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9EZXN0cm95U3luY0tIUihFR0xE aXNwbGF5IGRweSwgRUdMU3luYyBzCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs IFZhbGlkYXRlRGVzdHJveVN5bmMoZGlzcGxheSwgc3luY09iamVjdCksICJlZ2xEZXN0cm95U3lu YyIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSks IEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXkt PnByZXBhcmVGb3JDYWxsKCksICJlZ2xEZXN0cm95U3luYyIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZGlzcGxh eS0+ZGVzdHJveVN5bmMoc3luY09iamVjdCk7CiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsK QEAgLTk2MCw3ICs5ODQsOCBAQCBBTkdMRV9FWFBPUlQgRUdMaW50IEVHTEFQSUVOVFJZIEVHTF9D bGllbnRXYWl0U3luY0tIUihFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgVmFsaWRhdGVDbGllbnRXYWl0U3luYyhkaXNwbGF5LCBzeW5jT2JqZWN0LCBm bGFncywgdGltZW91dCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENsaWVudFdhaXRT eW5jIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVjdCksIEVHTF9GQUxTRSk7Ci0K KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxs KCksICJlZ2xDbGllbnRXYWl0U3luYyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZ2w6OkNvbnRleHQgKmN1cnJl bnRDb250ZXh0ID0gdGhyZWFkLT5nZXRDb250ZXh0KCk7CiAgICAgRUdMaW50IHN5bmNTdGF0dXMg ICAgICAgICAgID0gRUdMX0ZBTFNFOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKApAQCAtOTg4 LDcgKzEwMTMsOCBAQCBBTkdMRV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0 U3luY0F0dHJpYktIUihFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJO KHRocmVhZCwgVmFsaWRhdGVHZXRTeW5jQXR0cmliS0hSKGRpc3BsYXksIHN5bmNPYmplY3QsIGF0 dHJpYnV0ZSwgdmFsdWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xHZXRTeW5jQXR0 cmliIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVjdCksIEVHTF9GQUxTRSk7Ci0K KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxs KCksICJlZ2xHZXRTeW5jQXR0cmliIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVS Tih0aHJlYWQsIEdldFN5bmNBdHRyaWIoZGlzcGxheSwgc3luY09iamVjdCwgYXR0cmlidXRlLCB2 YWx1ZSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbEdldFN5bmNBdHRyaWIiLCBHZXRT eW5jSWZWYWxpZChkaXNwbGF5LCBzeW5jT2JqZWN0KSwgRUdMX0ZBTFNFKTsKIApAQCAtMTAxMSw3 ICsxMDM3LDggQEAgQU5HTEVfRVhQT1JUIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1dhaXRT eW5jS0hSKEVHTERpc3BsYXkgZHB5LCBFR0xTeW5jIHN5bmMKIAogICAgIEFOR0xFX0VHTF9UUllf UkVUVVJOKHRocmVhZCwgVmFsaWRhdGVXYWl0U3luYyhkaXNwbGF5LCBjb250ZXh0LCBzeW5jT2Jq ZWN0LCBmbGFncyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbFdhaXRTeW5jIiwgR2V0 U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVjdCksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xX YWl0U3luYyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlz cGxheSksIEVHTF9GQUxTRSk7CiAgICAgZ2w6OkNvbnRleHQgKmN1cnJlbnRDb250ZXh0ID0gdGhy ZWFkLT5nZXRDb250ZXh0KCk7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBzeW5j T2JqZWN0LT5zZXJ2ZXJXYWl0KGRpc3BsYXksIGN1cnJlbnRDb250ZXh0LCBmbGFncyksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgImVnbFdhaXRTeW5jIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxh eSwgc3luY09iamVjdCksIEVHTF9GQUxTRSk7CkBAIC0xMDQzLDcgKzEwNzAsOCBAQCBFR0xCb29s ZWFuIEVHTEFQSUVOVFJZIEVHTF9HZXRNc2NSYXRlQU5HTEUoRUdMRGlzcGxheSBkcHksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFj ZSkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAgIEFOR0xFX0VHTF9U UllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbEdldE1zY1Jh dGVBTkdMRSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlz cGxheSksIEVHTF9GQUxTRSk7CiAgICAgZXJyb3IgPSBlZ2xTdXJmYWNlLT5nZXRNc2NSYXRlKG51 bWVyYXRvciwgZGVub21pbmF0b3IpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpA QCAtMTA4MCw3ICsxMTA4LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0U3luY1Zh bHVlc0NIUk9NSVVNKEVHTERpc3BsYXkgZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdl dFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpKTsKICAgICAgICAgcmV0dXJuIEVH TF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3Bs YXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xHZXRTeW5jVmFsdWVzQ0hST01JVU0iLAorICAgICAg ICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0Up OwogICAgIGVycm9yID0gZWdsU3VyZmFjZS0+Z2V0U3luY1ZhbHVlcyh1c3QsIG1zYywgc2JjKTsK ICAgICBpZiAoZXJyb3IuaXNFcnJvcigpKQogICAgIHsKQEAgLTExMTYsNyArMTE0NSw4IEBAIEVH TEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N3YXBCdWZmZXJzV2l0aERhbWFnZUtIUihFR0xEaXNw bGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNw bGF5LCBlZ2xTdXJmYWNlKSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgp LCAiZWdsU3dhcEJ1ZmZlcnNXaXRoRGFtYWdlRVhUIiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBlcnJvciA9IGVn bFN1cmZhY2UtPnN3YXBXaXRoRGFtYWdlKHRocmVhZC0+Z2V0Q29udGV4dCgpLCByZWN0cywgbl9y ZWN0cyk7CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkKICAgICB7CkBAIC0xMTQ1LDYgKzExNzUs OCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9QcmVzZW50YXRpb25UaW1lQU5EUk9JRChF R0xEaXNwbGF5IGRweSwKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRl UHJlc2VudGF0aW9uVGltZUFORFJPSUQoZGlzcGxheSwgZWdsU3VyZmFjZSwgdGltZSksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgImVnbFByZXNlbnRhdGlvblRpbWVBTkRST0lEIiwgR2V0U3Vy ZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksCiAgICAgICAgICAgICAgICAgICAgICAg ICAgRUdMX0ZBTFNFKTsKKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXkt PnByZXBhcmVGb3JDYWxsKCksICJlZ2xQcmVzZW50YXRpb25UaW1lQU5EUk9JRCIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7 CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBlZ2xTdXJmYWNlLT5zZXRQcmVzZW50 YXRpb25UaW1lKHRpbWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xQcmVzZW50YXRp b25UaW1lQU5EUk9JRCIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLAog ICAgICAgICAgICAgICAgICAgICAgICAgIEVHTF9GQUxTRSk7CkBAIC0xMTY2LDcgKzExOTgsOCBA QCBBTkdMRV9FWFBPUlQgdm9pZCBFR0xBUElFTlRSWSBFR0xfU2V0QmxvYkNhY2hlRnVuY3NBTkRS T0lEKEVHTERpc3BsYXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIFZhbGlkYXRl U2V0QmxvYkNhY2hlQU5EUk9JRChkaXNwbGF5LCBzZXQsIGdldCksCiAgICAgICAgICAgICAgICAg ICAiZWdsU2V0QmxvYkNhY2hlRnVuY3NBTkRST0lEIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxh eSkpOwotCisgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxs KCksICJlZ2xTZXRCbG9iQ2FjaGVGdW5jc0FORFJPSUQiLAorICAgICAgICAgICAgICAgICAgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogICAgIHRocmVhZC0+c2V0U3VjY2VzcygpOwogICAg IGRpc3BsYXktPnNldEJsb2JDYWNoZUZ1bmNzKHNldCwgZ2V0KTsKIH0KQEAgLTExODEsNyArMTIx NCw4IEBAIEVHTGludCBFR0xBUElFTlRSWSBFR0xfUHJvZ3JhbUNhY2hlR2V0QXR0cmliQU5HTEUo RUdMRGlzcGxheSBkcHksIEVHTGVudW0gYXR0cmliCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVS Tih0aHJlYWQsIFZhbGlkYXRlUHJvZ3JhbUNhY2hlR2V0QXR0cmliQU5HTEUoZGlzcGxheSwgYXR0 cmliKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsUHJvZ3JhbUNhY2hlR2V0QXR0cmli QU5HTEUiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgMCk7Ci0KKyAgICBBTkdMRV9FR0xf VFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xQcm9ncmFt Q2FjaGVHZXRBdHRyaWJBTkdMRSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxh eUlmVmFsaWQoZGlzcGxheSksIDApOwogICAgIHRocmVhZC0+c2V0U3VjY2VzcygpOwogICAgIHJl dHVybiBkaXNwbGF5LT5wcm9ncmFtQ2FjaGVHZXRBdHRyaWIoYXR0cmliKTsKIH0KQEAgLTEyMDYs NyArMTI0MCw4IEBAIHZvaWQgRUdMQVBJRU5UUlkgRUdMX1Byb2dyYW1DYWNoZVF1ZXJ5QU5HTEUo RUdMRGlzcGxheSBkcHksCiAgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsCiAgICAgICAgICAgICAg ICAgICBWYWxpZGF0ZVByb2dyYW1DYWNoZVF1ZXJ5QU5HTEUoZGlzcGxheSwgaW5kZXgsIGtleSwg a2V5c2l6ZSwgYmluYXJ5LCBiaW5hcnlzaXplKSwKICAgICAgICAgICAgICAgICAgICJlZ2xQcm9n cmFtQ2FjaGVRdWVyeUFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwotCisgICAg QU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xQcm9n cmFtQ2FjaGVRdWVyeUFOR0xFIiwKKyAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpKTsKICAgICBBTkdMRV9FR0xfVFJZKHRocmVhZCwgZGlzcGxheS0+cHJvZ3JhbUNh Y2hlUXVlcnkoaW5kZXgsIGtleSwga2V5c2l6ZSwgYmluYXJ5LCBiaW5hcnlzaXplKSwKICAgICAg ICAgICAgICAgICAgICJlZ2xQcm9ncmFtQ2FjaGVRdWVyeUFOR0xFIiwgR2V0RGlzcGxheUlmVmFs aWQoZGlzcGxheSkpOwogCkBAIC0xMjMxLDcgKzEyNjYsOCBAQCB2b2lkIEVHTEFQSUVOVFJZIEVH TF9Qcm9ncmFtQ2FjaGVQb3B1bGF0ZUFOR0xFKEVHTERpc3BsYXkgZHB5LAogICAgIEFOR0xFX0VH TF9UUlkodGhyZWFkLAogICAgICAgICAgICAgICAgICAgVmFsaWRhdGVQcm9ncmFtQ2FjaGVQb3B1 bGF0ZUFOR0xFKGRpc3BsYXksIGtleSwga2V5c2l6ZSwgYmluYXJ5LCBiaW5hcnlzaXplKSwKICAg ICAgICAgICAgICAgICAgICJlZ2xQcm9ncmFtQ2FjaGVQb3B1bGF0ZUFOR0xFIiwgR2V0RGlzcGxh eUlmVmFsaWQoZGlzcGxheSkpOwotCisgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXkt PnByZXBhcmVGb3JDYWxsKCksICJlZ2xQcm9ncmFtQ2FjaGVQb3B1bGF0ZUFOR0xFIiwKKyAgICAg ICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKICAgICBBTkdMRV9FR0xf VFJZKHRocmVhZCwgZGlzcGxheS0+cHJvZ3JhbUNhY2hlUG9wdWxhdGUoa2V5LCBrZXlzaXplLCBi aW5hcnksIGJpbmFyeXNpemUpLAogICAgICAgICAgICAgICAgICAgImVnbFByb2dyYW1DYWNoZVBv cHVsYXRlQU5HTEUiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAKQEAgLTEyNDksNyAr MTI4NSw4IEBAIEVHTGludCBFR0xBUElFTlRSWSBFR0xfUHJvZ3JhbUNhY2hlUmVzaXplQU5HTEUo RUdMRGlzcGxheSBkcHksIEVHTGludCBsaW1pdCwgRUdMCiAKICAgICBBTkdMRV9FR0xfVFJZX1JF VFVSTih0aHJlYWQsIFZhbGlkYXRlUHJvZ3JhbUNhY2hlUmVzaXplQU5HTEUoZGlzcGxheSwgbGlt aXQsIG1vZGUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xQcm9ncmFtQ2FjaGVSZXNp emVBTkdMRSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCAwKTsKLQorICAgIEFOR0xFX0VH TF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFByb2dy YW1DYWNoZVJlc2l6ZUFOR0xFIiwKKyAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpLCAwKTsKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKICAgICByZXR1cm4gZGlz cGxheS0+cHJvZ3JhbUNhY2hlUmVzaXplKGxpbWl0LCBtb2RlKTsKIH0KQEAgLTEzNDAsNyArMTM3 NywxMyBAQCBFR0xpbnQgRUdMQVBJRU5UUlkgRUdMX0xhYmVsT2JqZWN0S0hSKEVHTERpc3BsYXkg ZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldExhYmVsZWRPYmplY3RJZlZhbGlkKHRo cmVhZCwgZGlzcGxheSwgb2JqZWN0VHlwZVBhY2tlZCwgb2JqZWN0KSk7CiAgICAgICAgIHJldHVy biBlcnJvci5nZXRDb2RlKCk7CiAgICAgfQotCisgICAgZXJyb3IgPSBkaXNwbGF5LT5wcmVwYXJl Rm9yQ2FsbCgpOworICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCisgICAgeworICAgICAgICB0aHJl YWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1ZygpLCAiZWdsTGFiZWxPYmplY3RLSFIiLAorICAg ICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKKyAgICAg ICAgcmV0dXJuIGVycm9yLmdldENvZGUoKTsKKyAgICB9CiAgICAgTGFiZWxlZE9iamVjdCAqbGFi ZWxlZE9iamVjdCA9CiAgICAgICAgIEdldExhYmVsZWRPYmplY3RJZlZhbGlkKHRocmVhZCwgZGlz cGxheSwgb2JqZWN0VHlwZVBhY2tlZCwgb2JqZWN0KTsKICAgICBBU1NFUlQobGFiZWxlZE9iamVj dCAhPSBudWxscHRyKTsKQEAgLTEzOTQsNiArMTQzNyw4IEBAIEFOR0xFX0VYUE9SVCBFR0xCb29s ZWFuIEVHTEFQSUVOVFJZIEVHTF9HZXRDb21wb3NpdG9yVGltaW5nQU5EUk9JRChFR0xEaXNwbGF5 IGRwCiAgICAgICAgIHRocmVhZCwKICAgICAgICAgVmFsaWRhdGVHZXRDb21wb3NpdG9yVGltaW5n QU5EUk9JRChkaXNwbGF5LCBlZ2xTdXJmYWNlLCBudW1UaW1lc3RhbXBzLCBuYW1lcywgdmFsdWVz KSwKICAgICAgICAgImVnbEdldENvbXBvc2l0b3JUaW1pbmdBTkRST0lERCIsIEdldFN1cmZhY2VJ ZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOworICAgIEFOR0xFX0VHTF9U UllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbEdldENvbXBv c2l0b3JUaW1pbmdBTkRST0lERCIsCisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxp ZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs IGVnbFN1cmZhY2UtPmdldENvbXBvc2l0b3JUaW1pbmcobnVtVGltZXN0YW1wcywgbmFtZXMsIHZh bHVlcyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbEdldENvbXBvc2l0b3JUaW1pbmdB TkRST0lERCIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLAogICAgICAg ICAgICAgICAgICAgICAgICAgIEVHTF9GQUxTRSk7CkBAIC0xNDE4LDYgKzE0NjMsOCBAQCBBTkdM RV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0TmV4dEZyYW1lSWRBTkRST0lE KEVHTERpc3BsYXkgZHB5LAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRh dGVHZXROZXh0RnJhbWVJZEFORFJPSUQoZGlzcGxheSwgZWdsU3VyZmFjZSwgZnJhbWVJZCksCiAg ICAgICAgICAgICAgICAgICAgICAgICAgImVnbEdldE5leHRGcmFtZUlkQU5EUk9JRCIsIEdldFN1 cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLAogICAgICAgICAgICAgICAgICAgICAg ICAgIEVHTF9GQUxTRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5 LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsR2V0TmV4dEZyYW1lSWRBTkRST0lEIiwKKyAgICAgICAg ICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIEFO R0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZWdsU3VyZmFjZS0+Z2V0TmV4dEZyYW1lSWQoZnJh bWVJZCksICJlZ2xHZXROZXh0RnJhbWVJZEFORFJPSUQiLAogICAgICAgICAgICAgICAgICAgICAg ICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwog CkBAIC0xNDQzLDcgKzE0OTAsOCBAQCBBTkdMRV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElFTlRS WSBFR0xfR2V0RnJhbWVUaW1lc3RhbXBTdXBwb3J0ZWRBTkRST0lEKEVHTERpcwogICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlkYXRlR2V0RnJhbWVUaW1lc3Rh bXBTdXBwb3J0ZWRBTkRST0lEKGRpc3BsYXksIGVnbFN1cmZhY2UsIHRpbWVzdGFtcEludGVybmFs KSwKICAgICAgICAgImVnbFF1ZXJ5VGltZXN0YW1wU3VwcG9ydGVkQU5EUk9JRCIsIEdldFN1cmZh Y2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUXVl cnlUaW1lc3RhbXBTdXBwb3J0ZWRBTkRST0lEIiwKKyAgICAgICAgICAgICAgICAgIEdldERpc3Bs YXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIHRocmVhZC0+c2V0U3VjY2Vzcygp OwogICAgIHJldHVybiBlZ2xTdXJmYWNlLT5nZXRTdXBwb3J0ZWRUaW1lc3RhbXBzKCkudGVzdCh0 aW1lc3RhbXBJbnRlcm5hbCk7CiB9CkBAIC0xNDcyLDYgKzE1MjAsOCBAQCBBTkdMRV9FWFBPUlQg RUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0RnJhbWVUaW1lc3RhbXBzQU5EUk9JRChFR0xE aXNwbGF5IGRweQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBudW1UaW1lc3RhbXBzLCB0aW1lc3RhbXBzLCB2YWx1ZXMpLAogICAgICAg ICAgICAgICAgICAgICAgICAgICJlZ2xHZXRGcmFtZVRpbWVzdGFtcHNBTkRST0lEIiwgR2V0U3Vy ZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksCiAgICAgICAgICAgICAgICAgICAgICAg ICAgRUdMX0ZBTFNFKTsKKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXkt PnByZXBhcmVGb3JDYWxsKCksICJlZ2xHZXRGcmFtZVRpbWVzdGFtcHNBTkRST0lEIiwKKyAgICAg ICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAg IEFOR0xFX0VHTF9UUllfUkVUVVJOKAogICAgICAgICB0aHJlYWQsIGVnbFN1cmZhY2UtPmdldEZy YW1lVGltZXN0YW1wcyhmcmFtZUlkLCBudW1UaW1lc3RhbXBzLCB0aW1lc3RhbXBzLCB2YWx1ZXMp LAogICAgICAgICAiZWdsR2V0RnJhbWVUaW1lc3RhbXBzQU5EUk9JRCIsIEdldFN1cmZhY2VJZlZh bGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwpAQCAtMTQ5NCw3ICsxNTQ0LDgg QEAgQU5HTEVfRVhQT1JUIGNvbnN0IGNoYXIgKkVHTEFQSUVOVFJZIEVHTF9RdWVyeVN0cmluZ2lB TkdMRShFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwg VmFsaWRhdGVRdWVyeVN0cmluZ2lBTkdMRShkaXNwbGF5LCBuYW1lLCBpbmRleCksCiAgICAgICAg ICAgICAgICAgICAgICAgICAgImVnbFF1ZXJ5U3RyaW5naUFOR0xFIiwgR2V0RGlzcGxheUlmVmFs aWQoZGlzcGxheSksIG51bGxwdHIpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUXVlcnlTdHJpbmdpQU5HTEUiLAorICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIG51bGxwdHIpOwogICAg IHRocmVhZC0+c2V0U3VjY2VzcygpOwogICAgIHJldHVybiBkaXNwbGF5LT5xdWVyeVN0cmluZ2ko bmFtZSwgaW5kZXgpOwogfQpAQCAtMTUyNiw3ICsxNTc3LDggQEAgRUdMaW50IEVHTEFQSUVOVFJZ IEVHTF9EdXBOYXRpdmVGZW5jZUZEQU5EUk9JRChFR0xEaXNwbGF5IGRweSwgRUdMU3luY0tIUiBz eW5jKQogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVEdXBOYXRpdmVG ZW5jZUZEQU5EUk9JRChkaXNwbGF5LCBzeW5jT2JqZWN0KSwKICAgICAgICAgICAgICAgICAgICAg ICAgICAiZWdsRHVwTmF0aXZlRmVuY2VGREFORFJPSUQiLCBHZXRTeW5jSWZWYWxpZChkaXNwbGF5 LCBzeW5jT2JqZWN0KSwKICAgICAgICAgICAgICAgICAgICAgICAgICBFR0xfTk9fTkFUSVZFX0ZF TkNFX0ZEX0FORFJPSUQpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNw bGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsRHVwTmF0aXZlRmVuY2VGREFORFJPSUQiLAorICAg ICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9f TkFUSVZFX0ZFTkNFX0ZEX0FORFJPSUQpOwogICAgIEVHTGludCByZXN1bHQgPSBFR0xfTk9fTkFU SVZFX0ZFTkNFX0ZEX0FORFJPSUQ7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBz eW5jT2JqZWN0LT5kdXBOYXRpdmVGZW5jZUZEKGRpc3BsYXksICZyZXN1bHQpLAogICAgICAgICAg ICAgICAgICAgICAgICAgICJlZ2xEdXBOYXRpdmVGZW5jZUZEQU5EUk9JRCIsIEdldFN5bmNJZlZh bGlkKGRpc3BsYXksIHN5bmNPYmplY3QpLApAQCAtMTU1Miw3ICsxNjA0LDggQEAgRUdMQm9vbGVh biBFR0xBUElFTlRSWSBFR0xfU3dhcEJ1ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFKEVHTERpc3Bs YXkgZHB5LAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlk YXRlU3dhcEJ1ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFKGRpc3BsYXksIGVnbFN1cmZhY2UsIGZy YW1ldG9rZW4pLAogICAgICAgICAiZWdsU3dhcEJ1ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFIiwg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xf VFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xTd2FwQnVm ZmVyc1dpdGhGcmFtZVRva2VuQU5HTEUiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgZWdsU3VyZmFjZS0+c3dhcFdpdGhGcmFtZVRva2VuKHRocmVhZC0+Z2V0Q29u dGV4dCgpLCBmcmFtZXRva2VuKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsU3dhcEJ1 ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksCiAg ICAgICAgICAgICAgICAgICAgICAgICAgRUdMX0ZBTFNFKTsKQEAgLTE1NzMsNiArMTYyNiw4IEBA IHZvaWQgRUdMQVBJRU5UUlkgRUdMX1JlbGVhc2VIaWdoUG93ZXJHUFVBTkdMRShFR0xEaXNwbGF5 IGRweSwgRUdMQ29udGV4dCBjdHgpCiAKICAgICBBTkdMRV9FR0xfVFJZKHRocmVhZCwgVmFsaWRh dGVDb250ZXh0KGRpc3BsYXksIGNvbnRleHQpLCAiZWdsUmVsZWFzZUhpZ2hQb3dlckdQVUFOR0xF IiwKICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKKyAgICBB TkdMRV9FR0xfVFJZKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFJlbGVh c2VIaWdoUG93ZXJHUFVBTkdMRSIsCisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxp ZChkaXNwbGF5KSk7CiAgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGNvbnRleHQtPnJlbGVhc2VI aWdoUG93ZXJHUFUoKSwgImVnbFJlbGVhc2VIaWdoUG93ZXJHUFVBTkdMRSIsCiAgICAgICAgICAg ICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAKQEAgLTE1OTEsNiArMTY0Niw4 IEBAIHZvaWQgRUdMQVBJRU5UUlkgRUdMX1JlYWNxdWlyZUhpZ2hQb3dlckdQVUFOR0xFKEVHTERp c3BsYXkgZHB5LCBFR0xDb250ZXh0IGN0eCkKIAogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBW YWxpZGF0ZUNvbnRleHQoZGlzcGxheSwgY29udGV4dCksICJlZ2xSZWFjcXVpcmVIaWdoUG93ZXJH UFVBTkdMRSIsCiAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7 CisgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJl Z2xSZWFjcXVpcmVIaWdoUG93ZXJHUFVBTkdMRSIsCisgICAgICAgICAgICAgICAgICBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGNvbnRleHQt PnJlYWNxdWlyZUhpZ2hQb3dlckdQVSgpLCAiZWdsUmVhY3F1aXJlSGlnaFBvd2VyR1BVQU5HTEUi LAogICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogCkBAIC0x NjA3LDYgKzE2NjQsOCBAQCB2b2lkIEVHTEFQSUVOVFJZIEVHTF9IYW5kbGVHUFVTd2l0Y2hBTkdM RShFR0xEaXNwbGF5IGRweSkKIAogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBWYWxpZGF0ZURp c3BsYXkoZGlzcGxheSksICJlZ2xIYW5kbGVHUFVTd2l0Y2hBTkdMRSIsCiAgICAgICAgICAgICAg ICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CisgICAgQU5HTEVfRUdMX1RSWSh0aHJl YWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xIYW5kbGVHUFVTd2l0Y2hBTkdMRSIs CisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAgQU5H TEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPmhhbmRsZUdQVVN3aXRjaCgpLCAiZWdsSGFuZGxl R1BVU3dpdGNoQU5HTEUiLAogICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlz cGxheSkpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9XZWJD b3JlLnhjY29uZmlnIGIvU291cmNlL1dlYkNvcmUvQ29uZmlndXJhdGlvbnMvV2ViQ29yZS54Y2Nv bmZpZwppbmRleCA1NzFlOGViMDcwNjBjMTk3Y2MzZTk1NDExYmJhNDM3NTdlODUxYjU5Li41MGZm NTU4ODYwMDk2ODE3ZGFlYzg4YzVhYzZiYzE2MzI5ZTQxYjFmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9Db25maWd1cmF0aW9ucy9XZWJDb3JlLnhjY29uZmlnCisrKyBiL1NvdXJjZS9XZWJD b3JlL0NvbmZpZ3VyYXRpb25zL1dlYkNvcmUueGNjb25maWcKQEAgLTQ4LDcgKzQ4LDcgQEAgV0tf TElCV0VCUlRDX0xJQlJBUllfRElSX1VTRV9PVkVSUklERV9GUkFNRVdPUktTX0RJUl9ZRVMgPSAk KFdLX09WRVJSSURFX0ZSQU1FV08KIExJQlJBUllfU0VBUkNIX1BBVEhTID0gJChpbmhlcml0ZWQp ICIkKFdLX0xJQldFQlJUQ19MSUJSQVJZX0RJUikiOwogCiBXRUJLSVRBRERJVElPTlNfSEVBREVS X1NFQVJDSF9QQVRIUyA9ICQoQlVJTFRfUFJPRFVDVFNfRElSKS91c3IvbG9jYWwvaW5jbHVkZS9X ZWJLaXRBZGRpdGlvbnMgJChTREtST09UKS91c3IvbG9jYWwvaW5jbHVkZS9XZWJLaXRBZGRpdGlv bnM7Ci1BTkdMRV9IRUFERVJfU0VBUkNIX1BBVEhTID0gJChCVUlMVF9QUk9EVUNUU19ESVIpL3Vz ci9sb2NhbC9pbmNsdWRlL0FOR0xFICQoU0RLUk9PVCkvdXNyL2xvY2FsL2luY2x1ZGUvQU5HTEU7 CitBTkdMRV9IRUFERVJfU0VBUkNIX1BBVEhTID0gJChCVUlMVF9QUk9EVUNUU19ESVIpJChXS19B TFRFUk5BVEVfRlJBTUVXT1JLU19ESVIpL3Vzci9sb2NhbC9pbmNsdWRlLyAkKFNES1JPT1QpJChX S19BTFRFUk5BVEVfV0VCS0lUX1NES19QQVRIKS91c3IvbG9jYWwvaW5jbHVkZS87CiBMSUJXRUJS VENfSEVBREVSX1NFQVJDSF9QQVRIUyA9ICQoQlVJTFRfUFJPRFVDVFNfRElSKS91c3IvbG9jYWwv aW5jbHVkZS93ZWJydGMgJChTREtST09UKS91c3IvbG9jYWwvaW5jbHVkZS93ZWJydGMgJChCVUlM VF9QUk9EVUNUU19ESVIpL3Vzci9sb2NhbC9pbmNsdWRlL3dlYnJ0Yy9zZGsvb2JqYy9GcmFtZXdv cmsvSGVhZGVycyAkKFNES1JPT1QpL3Vzci9sb2NhbC9pbmNsdWRlL3dlYnJ0Yy9zZGsvb2JqYy9G cmFtZXdvcmsvSGVhZGVyczsKIAogSEVBREVSX1NFQVJDSF9QQVRIUyA9IFBBTCBGb3J3YXJkaW5n SGVhZGVycyAvdXNyL2luY2x1ZGUvbGlieHNsdCAvdXNyL2luY2x1ZGUvbGlieG1sMiAiJChCVUlM VF9QUk9EVUNUU19ESVIpL0Rlcml2ZWRTb3VyY2VzL1dlYkNvcmUiICIkKEJVSUxUX1BST0RVQ1RT X0RJUikvdXNyL2xvY2FsL2luY2x1ZGUiICQoV0VCS0lUQURESVRJT05TX0hFQURFUl9TRUFSQ0hf UEFUSFMpICQoQU5HTEVfSEVBREVSX1NFQVJDSF9QQVRIUykgJChMSUJXRUJSVENfSEVBREVSX1NF QVJDSF9QQVRIUykgJChIRUFERVJfU0VBUkNIX1BBVEhTKSAkKFNSQ1JPT1QpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvUEFML0NvbmZpZ3VyYXRpb25zL1BBTC54Y2NvbmZpZyBiL1NvdXJj ZS9XZWJDb3JlL1BBTC9Db25maWd1cmF0aW9ucy9QQUwueGNjb25maWcKaW5kZXggMzQ4NTZmYTgy NzI1M2M2ODhkN2YxNTA4MWMwMTMzMTRlOGU2M2FkNS4uMThhYjUyZTBjYzkwM2RlNjdiMDE5NjUw MDM0MDRkMDI2NzMyM2QyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUEFML0NvbmZpZ3Vy YXRpb25zL1BBTC54Y2NvbmZpZworKysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvQ29uZmlndXJhdGlv bnMvUEFMLnhjY29uZmlnCkBAIC0yNSw3ICsyNSw3IEBACiAjaW5jbHVkZSAiVmVyc2lvbi54Y2Nv bmZpZyIKICNpbmNsdWRlICJXZWJLaXRUYXJnZXRDb25kaXRpb25hbHMueGNjb25maWciCiAKLUdD Q19QUkVQUk9DRVNTT1JfREVGSU5JVElPTlMgPSAkKERFQlVHX0RFRklORVMpICQoaW5oZXJpdGVk KTsKK0dDQ19QUkVQUk9DRVNTT1JfREVGSU5JVElPTlMgPSAkKERFQlVHX0RFRklORVMpIEdMX1NJ TEVOQ0VfREVQUkVDQVRJT04gR0xFU19TSUxFTkNFX0RFUFJFQ0FUSU9OICQoaW5oZXJpdGVkKTsK IAogRlJBTUVXT1JLX1NFQVJDSF9QQVRIU1tzZGs9aXBob25lKl0gPSAkKEZSQU1FV09SS19TRUFS Q0hfUEFUSFNfaW9zXyQoQ09ORklHVVJBVElPTikpOwogRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19p b3NfRGVidWcgPSAkKEJVSUxUX1BST0RVQ1RTX0RJUik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9QQUwvUEFMLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9Q QUwvUEFMLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggODcyOTBlZmZiYzNlMjgwYzNi ZWI5MTY5MDc1NzJiYTEwYWM2ZmRkMi4uNTc4ODIyOGNlNTExY2E0YTNiYzZjMDJlOTFkODRhNTJk ZTI3YjYzYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUEFML1BBTC54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9QQUwueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvagpAQCAtMTQyLDYgKzE0Miw4IEBACiAJCTYzQzdFREM3MjFBRkFFMDQwMDZBN0I5 OSAvKiBOU1Byb2dyZXNzU1BJLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSA2M0UzNjlGOTIxQUZBODNGMDAxQzE0QkMgLyogTlNQcm9ncmVzc1NQSS5oICov OyB9OwogCQk3QTM2RDBGOTIyM0FEOUFCMDBCMDUyMkUgLyogQ29tbW9uQ3J5cHRvU1BJLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QTM2RDBGODIyM0FE OUFCMDBCMDUyMkUgLyogQ29tbW9uQ3J5cHRvU1BJLmggKi87IH07CiAJCTdBM0E2QTgwMjBDQURC NDcwMDMxN0FBRSAvKiBOU0ltYWdlU1BJLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA3QTNBNkE3RjIwQ0FEQjQ2MDAzMTdBQUUgLyogTlNJbWFnZVNQSS5o ICovOyB9OworCQk3QkIzNEEwNDI1MjM2OTFCMDAwMjlEMDggLyogT3BlbkdMRVNTb2Z0TGlua0Nv Y29hLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0JC MzRBMDIyNTIzNjkxQjAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5tbSAqLzsgfTsK KwkJN0JCMzRBMDUyNTIzNjkxQjAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0JCMzRBMDMyNTIz NjkxQjAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5oICovOyB9OwogCQk5M0RCN0Qz NzI0NjI2QkNEMDA0QkQ4QTMgLyogTlNUZXh0SW5wdXRDb250ZXh0U1BJLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5M0RCN0QzNjI0NjI2QkNDMDA0QkQ4 QTMgLyogTlNUZXh0SW5wdXRDb250ZXh0U1BJLmggKi87IH07CiAJCTkzREI3RDNBMjQ2MjZGODYw MDRCRDhBMyAvKiBOU1VuZG9NYW5hZ2VyU1BJLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA5M0RCN0QzOTI0NjI2Rjg2MDA0QkQ4QTMgLyogTlNVbmRvTWFu YWdlclNQSS5oICovOyB9OwogCQlBMTAyNjU4OTFGNTY3NDdBMDBCNEM4NDQgLyogSElUb29sYm94 U1BJLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBMTAy NjU4ODFGNTY3NDdBMDBCNEM4NDQgLyogSElUb29sYm94U1BJLmggKi87IH07CkBAIC0zMzIsNiAr MzM0LDggQEAKIAkJNjNFMzY5RjkyMUFGQTgzRjAwMUMxNEJDIC8qIE5TUHJvZ3Jlc3NTUEkuaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gTlNQcm9ncmVzc1NQSS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk3QTM2RDBGODIyM0FEOUFCMDBCMDUyMkUgLyogQ29tbW9uQ3J5cHRvU1BJLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvbW1vbkNyeXB0b1NQSS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk3QTNBNkE3RjIwQ0FEQjQ2MDAzMTdBQUUgLyogTlNJbWFnZVNQ SS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBOU0ltYWdlU1BJLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTdCQjM0QTAyMjUyMzY5MUIwMDAyOUQwOCAvKiBPcGVu R0xFU1NvZnRMaW5rQ29jb2EubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBh dGggPSBPcGVuR0xFU1NvZnRMaW5rQ29jb2EubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTdCQjM0QTAzMjUyMzY5MUIwMDAyOUQwOCAvKiBPcGVuR0xFU1NvZnRMaW5rQ29jb2EuaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gT3BlbkdMRVNTb2Z0TGlua0NvY29hLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzREI3RDM2MjQ2MjZCQ0MwMDRCRDhBMyAv KiBOU1RleHRJbnB1dENvbnRleHRTUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gTlNUZXh0SW5wdXRDb250ZXh0U1BJLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTkzREI3RDM5MjQ2MjZGODYwMDRCRDhBMyAvKiBOU1VuZG9NYW5hZ2VyU1BJLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE5TVW5kb01hbmFnZXJTUEkuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJOTNFNTkwOUMxRjkzQkYxRTAwNjdGOENGIC8qIFVuZW5jb2RhYmxl SGFuZGxpbmcuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gVW5lbmNvZGFibGVIYW5kbGluZy5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwpAQCAtNjU4LDYgKzY2Miw4IEBACiAJCQkJMUMwMjJFRkMyMkNG RThFMDAwNkRGMDFCIC8qIEd1bnppcC5jcHAgKi8sCiAJCQkJQ0RBQ0IzNUUyMzg3M0U0ODAwMThE N0NFIC8qIE1lZGlhVG9vbGJveFNvZnRMaW5rLmNwcCAqLywKIAkJCQlDREFDQjM1RjIzODczRTQ4 MDAxOEQ3Q0UgLyogTWVkaWFUb29sYm94U29mdExpbmsuaCAqLywKKwkJCQk3QkIzNEEwMzI1MjM2 OTFCMDAwMjlEMDggLyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLmggKi8sCisJCQkJN0JCMzRBMDIy NTIzNjkxQjAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5tbSAqLywKIAkJCQkzMTY0 N0ZBRjI1MTc1OURDMDAxMEY4RkIgLyogT3BlbkdMU29mdExpbmtDb2NvYS5oICovLAogCQkJCTMx NjQ3RkFFMjUxNzU5REIwMDEwRjhGQiAvKiBPcGVuR0xTb2Z0TGlua0NvY29hLm1tICovLAogCQkJ CUExRjYzQzlEMjFBNERCRjcwMDZGQjQzQiAvKiBQYXNzS2l0U29mdExpbmsuaCAqLywKQEAgLTg2 NCw2ICs4NzAsNyBAQAogCQkJCTBDNzc4NTlDMUY0NTEzMEYwMEY0RUJCNiAvKiBOU1ZpZXdTUEku aCBpbiBIZWFkZXJzICovLAogCQkJCTBDNzc4NTlEMUY0NTEzMEYwMEY0RUJCNiAvKiBOU1dpbmRv d1NQSS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNTcwQUI4RjkyMEFGNkUzRDAwQjhCRTg3IC8qIE5T WFBDQ29ubmVjdGlvblNQSS5oIGluIEhlYWRlcnMgKi8sCisJCQkJN0JCMzRBMDUyNTIzNjkxQjAw MDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEM1 QUY5MUYxRjQzQTRDNzAwMkVBQzAyIC8qIE9wZW5HTEVTU1BJLmggaW4gSGVhZGVycyAqLywKIAkJ CQkzMTY0N0ZCMTI1MTc1OUVGMDAxMEY4RkIgLyogT3BlbkdMU29mdExpbmtDb2NvYS5oIGluIEhl YWRlcnMgKi8sCiAJCQkJQTE2OUIwNDEyNDhFRjA1MjAwRUU4QjdCIC8qIFBhc3NLaXRJbnN0YWxs bWVudHNTUEkuaCBpbiBIZWFkZXJzICovLApAQCAtMTAwMiw2ICsxMDA5LDcgQEAKIAkJCQk1QzdD Nzg3NDIzQUMzRTc3MDA2NUY0N0UgLyogTWFuYWdlZENvbmZpZ3VyYXRpb25Tb2Z0TGluay5tbSBp biBTb3VyY2VzICovLAogCQkJCTBDRjk5Q0E0MUY3MzYzNzUwMDdFRTc5MyAvKiBNZWRpYVRpbWVB VkZvdW5kYXRpb24uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0RBQ0IzNjAyMzg3NDI1QjAwMThE N0NFIC8qIE1lZGlhVG9vbGJveFNvZnRMaW5rLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTdCQjM0 QTA0MjUyMzY5MUIwMDAyOUQwOCAvKiBPcGVuR0xFU1NvZnRMaW5rQ29jb2EubW0gaW4gU291cmNl cyAqLywKIAkJCQkzMTY0N0ZCMDI1MTc1OUREMDAxMEY4RkIgLyogT3BlbkdMU29mdExpbmtDb2Nv YS5tbSBpbiBTb3VyY2VzICovLAogCQkJCUExRjYzQ0EwMjFBNERCRjcwMDZGQjQzQiAvKiBQYXNz S2l0U29mdExpbmsubW0gaW4gU291cmNlcyAqLywKIAkJCQlBMTE3NUI0RjFGNkIzMzczMDBDNEI5 RjAgLyogUG9wdXBNZW51Lm1tIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9QQUwvcGFsL2NvY29hL09wZW5HTEVTU29mdExpbmtDb2NvYS5oIGIvU291cmNlL1dlYkNv cmUvUEFML3BhbC9jb2NvYS9PcGVuR0xFU1NvZnRMaW5rQ29jb2EuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kZjU1 ODE5YTFmNmI5ZmM1MTg2ZjM2Yjk0ZWNhNzViZWI0MzVlOTMxCi0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL1dlYkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xFU1NvZnRMaW5rQ29jb2EuaApAQCAt MCwwICsxLDM5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIwIEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICog UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI3ByYWdtYSBvbmNlCisKKyNpZiBQTEFURk9STShJT1NfRkFNSUxZKQorCisjaW1wb3J0IDxP cGVuR0xFUy9FQUdMLmg+CisjaW1wb3J0IDxPcGVuR0xFUy9FQUdMRHJhd2FibGUuaD4KKyNpbXBv cnQgPE9wZW5HTEVTL0VBR0xJT1N1cmZhY2UuaD4KKyNpbXBvcnQgPHd0Zi9Tb2Z0TGlua2luZy5o PgorCitTT0ZUX0xJTktfRlJBTUVXT1JLX0ZPUl9IRUFERVIoUEFMLCBPcGVuR0xFUykKKworU09G VF9MSU5LX0NMQVNTX0ZPUl9IRUFERVIoUEFMLCBFQUdMQ29udGV4dCkKKworI2VuZGlmCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL2NvY29hL09wZW5HTEVTU29mdExpbmtDb2Nv YS5tbSBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdMRVNTb2Z0TGlua0NvY29h Lm1tCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmNmYTFiZmMzYzIzZmRmMTFmM2JlNzAyOThmZWJmZmMwODUyYThmNDMK LS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL2NvY29hL09wZW5HTEVT U29mdExpbmtDb2NvYS5tbQpAQCAtMCwwICsxLDM5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAq IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBO TyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgUExBVEZP Uk0oSU9TX0ZBTUlMWSkKKworI2ltcG9ydCA8T3BlbkdMRVMvRUFHTC5oPgorI2ltcG9ydCA8T3Bl bkdMRVMvRUFHTERyYXdhYmxlLmg+CisjaW1wb3J0IDxPcGVuR0xFUy9FQUdMSU9TdXJmYWNlLmg+ CisjaW1wb3J0IDx3dGYvU29mdExpbmtpbmcuaD4KKworU09GVF9MSU5LX0ZSQU1FV09SS19GT1Jf U09VUkNFKFBBTCwgT3BlbkdMRVMpCisKK1NPRlRfTElOS19DTEFTU19GT1JfU09VUkNFX1dJVEhf RVhQT1JUKFBBTCwgT3BlbkdMRVMsIEVBR0xDb250ZXh0LCBQQUxfRVhQT1JUKQorCisjZW5kaWYK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3BlbkdMU29mdExpbmtD b2NvYS5oIGIvU291cmNlL1dlYkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xTb2Z0TGlua0NvY29h LmgKaW5kZXggM2RlOWQzNzZkN2I1YmNjYTM5MDNjZmExNjYxMWRkNDc3MGNhNTVjNS4uMWJlNDBm NzYwMTQyNGVkMjk1ZmRiM2YxNzI0OGFkODYyZWM0MWZkOCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xTb2Z0TGlua0NvY29hLmgKKysrIGIvU291cmNlL1dl YkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xTb2Z0TGlua0NvY29hLmgKQEAgLTQ0LDUgKzQ0LDYg QEAgU09GVF9MSU5LX0ZVTkNUSU9OX0ZPUl9IRUFERVIoUEFMLCBPcGVuR0wsIENHTFF1ZXJ5UmVu ZGVyZXJJbmZvLCBDR0xFcnJvciwgKEdMdWkKIFNPRlRfTElOS19GVU5DVElPTl9GT1JfSEVBREVS KFBBTCwgT3BlbkdMLCBDR0xSZWxlYXNlUGl4ZWxGb3JtYXQsIHZvaWQsIChDR0xQaXhlbEZvcm1h dE9iaiBwaXgpLCAocGl4KSkKIFNPRlRfTElOS19GVU5DVElPTl9GT1JfSEVBREVSKFBBTCwgT3Bl bkdMLCBDR0xTZXRWaXJ0dWFsU2NyZWVuLCBDR0xFcnJvciwgKENHTENvbnRleHRPYmogY3R4LCBH TGludCBzY3JlZW4pLCAoY3R4LCBzY3JlZW4pKQogU09GVF9MSU5LX0ZVTkNUSU9OX0ZPUl9IRUFE RVIoUEFMLCBPcGVuR0wsIENHTFVwZGF0ZUNvbnRleHQsIENHTEVycm9yLCAoQ0dMQ29udGV4dE9i aiBjdHgpLCAoY3R4KSkKK1NPRlRfTElOS19GVU5DVElPTl9GT1JfSEVBREVSKFBBTCwgT3BlbkdM LCBDR0xTZXRDdXJyZW50Q29udGV4dCwgQ0dMRXJyb3IsIChDR0xDb250ZXh0T2JqIGN0eCksIChj dHgpKQogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2Ev T3BlbkdMU29mdExpbmtDb2NvYS5tbSBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvY29jb2EvT3Bl bkdMU29mdExpbmtDb2NvYS5tbQppbmRleCBlMDZlZTJmMDVmOTFmMmQ1OWNmMGJkYjZlN2FhZTJl ZmUyYzVmZDNjLi44YzM1ZTA4Yzg4N2E4MmI5M2Q4OTI4MTE0MTNiODU4ZThjMWFiNjEwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL2NvY29hL09wZW5HTFNvZnRMaW5rQ29jb2Eu bW0KKysrIGIvU291cmNlL1dlYkNvcmUvUEFML3BhbC9jb2NvYS9PcGVuR0xTb2Z0TGlua0NvY29h Lm1tCkBAIC00NCw1ICs0NCw2IEBAIFNPRlRfTElOS19GVU5DVElPTl9GT1JfU09VUkNFKFBBTCwg T3BlbkdMLCBDR0xHZXRQYXJhbWV0ZXIsIENHTEVycm9yLCAoQ0dMQ29udGV4CiBTT0ZUX0xJTktf RlVOQ1RJT05fRk9SX1NPVVJDRShQQUwsIE9wZW5HTCwgQ0dMUXVlcnlSZW5kZXJlckluZm8sIENH TEVycm9yLCAoR0x1aW50IGRpc3BsYXlfbWFzaywgQ0dMUmVuZGVyZXJJbmZvT2JqICpyZW5kLCBH TGludCAqbnJlbmQpLCAoZGlzcGxheV9tYXNrLCByZW5kLCBucmVuZCkpCiBTT0ZUX0xJTktfRlVO Q1RJT05fRk9SX1NPVVJDRShQQUwsIE9wZW5HTCwgQ0dMU2V0VmlydHVhbFNjcmVlbiwgQ0dMRXJy b3IsIChDR0xDb250ZXh0T2JqIGN0eCwgR0xpbnQgc2NyZWVuKSwgKGN0eCwgc2NyZWVuKSkKIFNP RlRfTElOS19GVU5DVElPTl9GT1JfU09VUkNFKFBBTCwgT3BlbkdMLCBDR0xVcGRhdGVDb250ZXh0 LCBDR0xFcnJvciwgKENHTENvbnRleHRPYmogY3R4KSwgKGN0eCkpCitTT0ZUX0xJTktfRlVOQ1RJ T05fRk9SX1NPVVJDRShQQUwsIE9wZW5HTCwgQ0dMU2V0Q3VycmVudENvbnRleHQsIENHTEVycm9y LCAoQ0dMQ29udGV4dE9iaiBjdHgpLCAoY3R4KSkKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2Vi Q29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNGIwYzlmMGU0NjU4 ZGIzOTU2ZjgyMTQyYTgyZDVlZjFmOWQyOTA5OS4uMDk0ZTg4YTM5YzY3YmNhNDA4ZTZiZWNiMWQ3 MmIwZGY0M2U1MmY5YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvagpAQCAtMjIyMSw2ICsyMjIxLDcgQEAKIAkJN0FGOUIyMDYxOENGQjJE RjAwQzY0QkVGIC8qIFZUVFJlZ2lvbkxpc3QuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDdBRjlCMjAwMThDRkIyREYwMEM2NEJFRiAvKiBWVFRSZWdpb25M aXN0LmggKi87IH07CiAJCTdBRjlCMjBEMThDRkI1RjQwMEM2NEJFRiAvKiBKU1ZUVFJlZ2lvbi5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0FGOUIyMDkx OENGQjVGMjAwQzY0QkVGIC8qIEpTVlRUUmVnaW9uLmggKi87IH07CiAJCTdBRjlCMjBGMThDRkI1 RjQwMEM2NEJFRiAvKiBKU1ZUVFJlZ2lvbkxpc3QuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDdBRjlCMjBCMThDRkI1RjMwMEM2NEJFRiAvKiBKU1ZUVFJl Z2lvbkxpc3QuaCAqLzsgfTsKKwkJN0JCMzRBMDEyNTIzNUMzOTAwMDI5RDA4IC8qIE9wZW5HTEVT U29mdExpbmtDb2NvYS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gN0JCMzRBMDAyNTIzNUMzNTAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5o ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTdCRTc0 MjczODFGQTkwNkZCQjRGMEYyQyAvKiBKU1NWR0dyYXBoaWNzRWxlbWVudC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTUwQzRDMDJCRUQ4OTM2RjgxOEUy Rjk5IC8qIEpTU1ZHR3JhcGhpY3NFbGVtZW50LmggKi87IH07CiAJCTdDMDI5QzZFMjQ5M0M4Rjgw MDI2ODIwNCAvKiBDb2xvclR5cGVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA3QzAyOUM2RDI0OTNDOEY4MDAyNjgyMDQgLyogQ29sb3JUeXBlcy5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTdDMTg0M0ZF MUM4QjcyODMwMDJFQjk3MyAvKiBBdXRvZmlsbC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gN0MxODQzRkMxQzhCNzI4MzAwMkVCOTczIC8qIEF1dG9maWxs LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKQEAgLTEw MDY0LDYgKzEwMDY1LDggQEAKIAkJN0FGOUIyMDkxOENGQjVGMjAwQzY0QkVGIC8qIEpTVlRUUmVn aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTVlRUUmVnaW9uLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdBRjlCMjBBMThDRkI1RjMwMEM2NEJFRiAvKiBK U1ZUVFJlZ2lvbkxpc3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g SlNWVFRSZWdpb25MaXN0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJN0FGOUIy MEIxOENGQjVGMzAwQzY0QkVGIC8qIEpTVlRUUmVnaW9uTGlzdC5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBKU1ZUVFJlZ2lvbkxpc3QuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJN0JCMzQ5RkYyNTIzNUMzNDAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2Nv YS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLm9iamNwcDsgbmFtZSA9IE9wZW5HTEVTU29mdExpbmtDb2NvYS5tbTsgcGF0 aCA9IFBBTC9wYWwvY29jb2EvT3BlbkdMRVNTb2Z0TGlua0NvY29hLm1tOyBzb3VyY2VUcmVlID0g U09VUkNFX1JPT1Q7IH07CisJCTdCQjM0QTAwMjUyMzVDMzUwMDAyOUQwOCAvKiBPcGVuR0xFU1Nv ZnRMaW5rQ29jb2EuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gT3BlbkdMRVNTb2Z0TGlua0NvY29hLmg7IHBh dGggPSBQQUwvcGFsL2NvY29hL09wZW5HTEVTU29mdExpbmtDb2NvYS5oOyBzb3VyY2VUcmVlID0g U09VUkNFX1JPT1Q7IH07CiAJCTdDMDExRjNEMjRGQUQzNjAwMDVCRUYxMCAvKiBTZXR0aW5ncy5j cHAuZXJiICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0g dGV4dDsgcGF0aCA9IFNldHRpbmdzLmNwcC5lcmI7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCTdDMDExRjNFMjRGQUQzNjAwMDVCRUYxMCAvKiBJbnRlcm5hbFNldHRpbmdzR2VuZXJhdGVk LmNwcC5lcmIgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUg PSB0ZXh0OyBwYXRoID0gSW50ZXJuYWxTZXR0aW5nc0dlbmVyYXRlZC5jcHAuZXJiOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk3QzAxMUYzRjI0RkFEMzYwMDA1QkVGMTAgLyogSW50ZXJu YWxTZXR0aW5nc0dlbmVyYXRlZC5pZGwuZXJiICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IEludGVybmFsU2V0dGluZ3NHZW5lcmF0 ZWQuaWRsLmVyYjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTI2Mzc0LDYgKzI2Mzc3 LDggQEAKIAkJCQlBRDlGRjZFMDE5MDgzOTFEMDAzQjYxRTAgLyogSU9TdXJmYWNlUG9vbENvY29h Lm1tICovLAogCQkJCUNEQzQ4QUM4MjE0OUNGMkEwMDI0RkQ1OSAvKiBNZWRpYUVuZ2luZUNvbmZp Z3VyYXRpb25GYWN0b3J5Q29jb2EuY3BwICovLAogCQkJCUNEQzQ4QUM3MjE0OUNGMkEwMDI0RkQ1 OSAvKiBNZWRpYUVuZ2luZUNvbmZpZ3VyYXRpb25GYWN0b3J5Q29jb2EuaCAqLywKKwkJCQk3QkIz NEEwMDI1MjM1QzM1MDAwMjlEMDggLyogT3BlbkdMRVNTb2Z0TGlua0NvY29hLmggKi8sCisJCQkJ N0JCMzQ5RkYyNTIzNUMzNDAwMDI5RDA4IC8qIE9wZW5HTEVTU29mdExpbmtDb2NvYS5tbSAqLywK IAkJCQkzMTY0N0ZBODI1MTYxNkJEMDAxMEY4RkIgLyogT3BlbkdMU29mdExpbmtDb2NvYS5oICov LAogCQkJCTMxNjQ3RkE5MjUxNjE2QkQwMDEwRjhGQiAvKiBPcGVuR0xTb2Z0TGlua0NvY29hLm1t ICovLAogCQkJCUNERUIzRDcyMjRDNDFBNkUwMDFGQkVFRiAvKiBTb3VyY2VCdWZmZXJQYXJzZXIu Y3BwICovLApAQCAtMzMxNzksNiArMzMxODQsNyBAQAogCQkJCUZEQTNFOTVDMTM0QTQ5RUYwMDhE NEI1QSAvKiBPZmZsaW5lQXVkaW9EZXN0aW5hdGlvbk5vZGUuaCBpbiBIZWFkZXJzICovLAogCQkJ CTMxNDg3N0UzMUZBQThGRTkwMEMwNTc1OSAvKiBPZmZzY3JlZW5DYW52YXMuaCBpbiBIZWFkZXJz ICovLAogCQkJCTMxNDBDNTIwMUZERjE1MUEwMEQyQTg3MyAvKiBPZmZzY3JlZW5DYW52YXNSZW5k ZXJpbmdDb250ZXh0MkQuaCBpbiBIZWFkZXJzICovLAorCQkJCTdCQjM0QTAxMjUyMzVDMzkwMDAy OUQwOCAvKiBPcGVuR0xFU1NvZnRMaW5rQ29jb2EuaCBpbiBIZWFkZXJzICovLAogCQkJCTMxNjQ3 RkFCMjUxNjE4RTIwMDEwRjhGQiAvKiBPcGVuR0xTb2Z0TGlua0NvY29hLmggaW4gSGVhZGVycyAq LywKIAkJCQlCMkQzREE2NTBEMDA2Q0Q2MDBFRjZGM0EgLyogT3BlblR5cGVDRy5oIGluIEhlYWRl cnMgKi8sCiAJCQkJQjJEM0RBNjUwRDAwNkNENjAwRUY2RjI3IC8qIE9wZW5UeXBlTWF0aERhdGEu aCBpbiBIZWFkZXJzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY29jb2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xDb2NvYS5tbSBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2Eu bW0KaW5kZXggYzIyMWMxNDYxNTM3ZWI5ZTgwNzcyNDZiMzlkYjg3ZjM1NDNmODc4My4uYzM5ZDRj MWY4YWFhYWZiYWNkNDU0YjFhNGU4ZmQ4ODE0MTFlYTZmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xDb2Nv YS5tbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGlj c0NvbnRleHRHTE9wZW5HTENvY29hLm1tCkBAIC0yMCw3ICsyMCw3IEBACiAgKiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZ CiAgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKICAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgogICovCiAKICNpbXBvcnQgImNvbmZpZy5oIgpAQCAtODAsNiArODAsOCBAQCB0eXBlZGVmIHZv aWQqIEdMZWdsQ29udGV4dDsKICNpbXBvcnQgIkV4dGVuc2lvbnNHTE9wZW5HTC5oIgogI2VsaWYg VVNFKEFOR0xFKQogI2ltcG9ydCAiRXh0ZW5zaW9uc0dMQU5HTEUuaCIKKyNpbXBvcnQgIlJ1bnRp bWVBcHBsaWNhdGlvbkNoZWNrcy5oIgorI2ltcG9ydCAiV2ViQ29yZVRocmVhZC5oIgogI2VuZGlm CiAKICNpZiBQTEFURk9STShNQUMpCkBAIC05MSw2ICs5Myw2OSBAQCB0eXBlZGVmIHZvaWQqIEdM ZWdsQ29udGV4dDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCituYW1lc3BhY2UgeworCisjaWYg VVNFKEFOR0xFKQorCisjaWYgQVNTRVJUX0VOQUJMRUQKKy8vIFJldHVybnMgdHJ1ZSBpZiB3ZSBo YXZlIHZvbGF0aWxlIGNvbnRleHQgZXh0ZW5zaW9uIGZvciB0aGUgcGFydGljdWxhciBBUEkgb3IK Ky8vIGlmIHRoZSBwYXJ0aWN1bGFyIEFQSSBpcyBub3QgdXNlZC4KK2Jvb2wgY2hlY2tWb2xhdGls ZUNvbnRleHRTdXBwb3J0SWZEZXZpY2VFeGlzdHMoRUdMRGlzcGxheSBkaXNwbGF5LCBjb25zdCBj aGFyKiBkZXZpY2VDb250ZXh0Vm9sYXRpbGVFeHRlbnNpb24sCisgICAgY29uc3QgY2hhciogZGV2 aWNlQ29udGV4dEV4dGVuc2lvbiwgRUdMaW50IGRldmljZUNvbnRleHRUeXBlKQoreworICAgIGNv bnN0IGNoYXIgKmNsaWVudEV4dGVuc2lvbnMgPSBFR0xfUXVlcnlTdHJpbmcoRUdMX05PX0RJU1BM QVksIEVHTF9FWFRFTlNJT05TKTsKKyAgICBpZiAoY2xpZW50RXh0ZW5zaW9ucyAmJiBzdHJzdHIo Y2xpZW50RXh0ZW5zaW9ucywgZGV2aWNlQ29udGV4dFZvbGF0aWxlRXh0ZW5zaW9uKSkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgRUdMRGV2aWNlRVhUIGRldmljZSA9IEVHTF9OT19ERVZJQ0Vf RVhUOworICAgIGlmICghRUdMX1F1ZXJ5RGlzcGxheUF0dHJpYkVYVChkaXNwbGF5LCBFR0xfREVW SUNFX0VYVCwgcmVpbnRlcnByZXRfY2FzdDxFR0xBdHRyaWIqPigmZGV2aWNlKSkpCisgICAgICAg IHJldHVybiB0cnVlOworICAgIGlmIChkZXZpY2UgPT0gRUdMX05PX0RFVklDRV9FWFQpCisgICAg ICAgIHJldHVybiB0cnVlOworICAgIGNvbnN0IGNoYXIqIGRldmljZUV4dGVuc2lvbnMgPSBFR0xf UXVlcnlEZXZpY2VTdHJpbmdFWFQoZGV2aWNlLCBFR0xfRVhURU5TSU9OUyk7CisgICAgaWYgKCFk ZXZpY2VFeHRlbnNpb25zIHx8ICFzdHJzdHIoZGV2aWNlRXh0ZW5zaW9ucywgZGV2aWNlQ29udGV4 dEV4dGVuc2lvbikpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIHZvaWQqIGRldmljZUNvbnRl eHQgPSBudWxscHRyOworICAgIGlmICghRUdMX1F1ZXJ5RGV2aWNlQXR0cmliRVhUKGRldmljZSwg ZGV2aWNlQ29udGV4dFR5cGUsIHJlaW50ZXJwcmV0X2Nhc3Q8RUdMQXR0cmliKj4oJmRldmljZUNv bnRleHQpKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgcmV0dXJuICFkZXZpY2VDb250ZXh0 OworfQorI2VuZGlmCisKK0VHTERpc3BsYXkgSW5pdGlhbGl6ZUVHTERpc3BsYXkoKQoreworICAg IEVHTGludCBtYWpvclZlcnNpb24gPSAwOworICAgIEVHTGludCBtaW5vclZlcnNpb24gPSAwOwor ICAgIEVHTERpc3BsYXkgZGlzcGxheTsKKyAgICBib29sIHNob3VsZEluaXRpYWxpemVXaXRoVm9s YXRpbGVDb250ZXh0U3VwcG9ydCA9ICFpc0luV2ViUHJvY2VzcygpOworICAgIGlmIChzaG91bGRJ bml0aWFsaXplV2l0aFZvbGF0aWxlQ29udGV4dFN1cHBvcnQpIHsKKyAgICAgICAgLy8gRm9yIFdL MSB0eXBlIEFQSXMgd2UgbmVlZCB0byBzZXQgInZvbGF0aWxlIHBsYXRmb3JtIGNvbnRleHQiIGZv ciBzcGVjaWZpYworICAgICAgICAvLyBBUElzLCBzaW5jZSBjbGllbnQgY29kZSB3aWxsIGJlIGFi bGUgdG8gb3ZlcnJpZGUgdGhlIHRocmVhZC1nbG9iYWwgY29udGV4dAorICAgICAgICAvLyB0aGF0 IEFOR0xFIGV4cGVjdHMuCisgICAgICAgIEVHTGludCBkaXNwbGF5QXR0cmlidXRlc1tdID0gewor ICAgICAgICAgICAgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0VB R0xfQU5HTEUsIEVHTF9UUlVFLAorICAgICAgICAgICAgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklD RV9DT05URVhUX1ZPTEFUSUxFX0NHTF9BTkdMRSwgRUdMX1RSVUUsCisgICAgICAgICAgICBFR0xf Tk9ORQorICAgICAgICB9OworICAgICAgICBkaXNwbGF5ID0gRUdMX0dldFBsYXRmb3JtRGlzcGxh eUVYVChFR0xfUExBVEZPUk1fQU5HTEVfQU5HTEUsIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCAqPihF R0xfREVGQVVMVF9ESVNQTEFZKSwgZGlzcGxheUF0dHJpYnV0ZXMpOworICAgIH0gZWxzZQorICAg ICAgICBkaXNwbGF5ID0gRUdMX0dldERpc3BsYXkoRUdMX0RFRkFVTFRfRElTUExBWSk7CisKKyAg ICBpZiAoRUdMX0luaXRpYWxpemUoZGlzcGxheSwgJm1ham9yVmVyc2lvbiwgJm1pbm9yVmVyc2lv bikgPT0gRUdMX0ZBTFNFKSB7CisgICAgICAgIExPRyhXZWJHTCwgIkVHTERpc3BsYXkgSW5pdGlh bGl6YXRpb24gZmFpbGVkLiIpOworICAgICAgICByZXR1cm4gRUdMX05PX0RJU1BMQVk7CisgICAg fQorICAgIExPRyhXZWJHTCwgIkFOR0xFIGluaXRpYWxpc2VkIE1ham9yOiAlZCBNaW5vcjogJWQi LCBtYWpvclZlcnNpb24sIG1pbm9yVmVyc2lvbik7CisgICAgaWYgKHNob3VsZEluaXRpYWxpemVX aXRoVm9sYXRpbGVDb250ZXh0U3VwcG9ydCkgeworICAgICAgICAvLyBBZnRlciBpbml0aWFsaXph dGlvbiwgRUdMX0RFRkFVTFRfRElTUExBWSB3aWxsIHJldHVybiB0aGUgcGxhdGZvcm0tY3VzdG9t aXplZCBkaXNwbGF5LgorICAgICAgICBBU1NFUlQoZGlzcGxheSA9PSBFR0xfR2V0RGlzcGxheShF R0xfREVGQVVMVF9ESVNQTEFZKSk7CisgICAgICAgIEFTU0VSVChjaGVja1ZvbGF0aWxlQ29udGV4 dFN1cHBvcnRJZkRldmljZUV4aXN0cyhkaXNwbGF5LCAiRUdMX0FOR0xFX3BsYXRmb3JtX2Rldmlj ZV9jb250ZXh0X3ZvbGF0aWxlX2VhZ2wiLCAiRUdMX0FOR0xFX2RldmljZV9lYWdsIiwgRUdMX0VB R0xfQ09OVEVYVF9BTkdMRSkpOworICAgICAgICBBU1NFUlQoY2hlY2tWb2xhdGlsZUNvbnRleHRT dXBwb3J0SWZEZXZpY2VFeGlzdHMoZGlzcGxheSwgIkVHTF9BTkdMRV9wbGF0Zm9ybV9kZXZpY2Vf Y29udGV4dF92b2xhdGlsZV9jZ2wiLCAiRUdMX0FOR0xFX2RldmljZV9jZ2wiLCBFR0xfQ0dMX0NP TlRFWFRfQU5HTEUpKTsKKyAgICB9CisgICAgcmV0dXJuIGRpc3BsYXk7Cit9CisjZW5kaWYKK30K Kwogc3RhdGljIGNvbnN0IHVuc2lnbmVkIHN0YXR1c0NoZWNrVGhyZXNob2xkID0gNTsKIAogLy8g RklYTUU6IFRoaXMgY2xhc3MgaXMgY3VycmVudGx5IGVtcHR5IG9uIE1hYywgYnV0IHdpbGwgZ2V0 IHBvcHVsYXRlZCBhcwpAQCAtOTksNyArMTY0LDcgQEAgY2xhc3MgR3JhcGhpY3NDb250ZXh0R0xP cGVuR0xQcml2YXRlIHsKICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKIHB1YmxpYzoKICAg ICBHcmFwaGljc0NvbnRleHRHTE9wZW5HTFByaXZhdGUoR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wq KSB7IH0KLSAgICAKKwogICAgIH5HcmFwaGljc0NvbnRleHRHTE9wZW5HTFByaXZhdGUoKSB7IH0K IH07CiAKQEAgLTMxNiwxNiArMzgxLDkgQEAgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OkdyYXBo aWNzQ29udGV4dEdMT3BlbkdMKEdyYXBoaWNzQ29udGV4dEdMQXR0cmlidXRlcyBhdHQKICAgICAg ICAgOjpnbEVuYWJsZShHcmFwaGljc0NvbnRleHRHTDo6UFJJTUlUSVZFX1JFU1RBUlQpOwogCiAj ZWxpZiBVU0UoQU5HTEUpCi0KLSAgICBtX2Rpc3BsYXlPYmogPSBFR0xfR2V0RGlzcGxheShFR0xf REVGQVVMVF9ESVNQTEFZKTsKKyAgICBtX2Rpc3BsYXlPYmogPSBJbml0aWFsaXplRUdMRGlzcGxh eSgpOwogICAgIGlmIChtX2Rpc3BsYXlPYmogPT0gRUdMX05PX0RJU1BMQVkpCiAgICAgICAgIHJl dHVybjsKLSAgICBFR0xpbnQgbWFqb3JWZXJzaW9uLCBtaW5vclZlcnNpb247Ci0gICAgaWYgKEVH TF9Jbml0aWFsaXplKG1fZGlzcGxheU9iaiwgJm1ham9yVmVyc2lvbiwgJm1pbm9yVmVyc2lvbikg PT0gRUdMX0ZBTFNFKSB7Ci0gICAgICAgIExPRyhXZWJHTCwgIkVHTERpc3BsYXkgSW5pdGlhbGl6 YXRpb24gZmFpbGVkLiIpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotICAgIExPRyhXZWJHTCwg IkFOR0xFIGluaXRpYWxpc2VkIE1ham9yOiAlZCBNaW5vcjogJWQiLCBtYWpvclZlcnNpb24sIG1p bm9yVmVyc2lvbik7CiAgICAgY29uc3QgY2hhciAqZGlzcGxheUV4dGVuc2lvbnMgPSBFR0xfUXVl cnlTdHJpbmcobV9kaXNwbGF5T2JqLCBFR0xfRVhURU5TSU9OUyk7CiAgICAgTE9HKFdlYkdMLCAi RXh0ZW5zaW9uczogJXMiLCBkaXNwbGF5RXh0ZW5zaW9ucyk7CiAKQEAgLTU0OSwxNCArNjA3LDE0 IEBAIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTChHcmFw aGljc0NvbnRleHRHTEF0dHJpYnV0ZXMgYXR0CiAKICAgICAvLyBBbHdheXMgc2V0IHRvIDEgZm9y IE9wZW5HTCBFUy4KICAgICBBTkdMRVJlc291cmNlcy5NYXhEcmF3QnVmZmVycyA9IDE7Ci0gICAg CisKICAgICBHQ0dMaW50IHJhbmdlWzJdLCBwcmVjaXNpb247CiAgICAgZ2V0U2hhZGVyUHJlY2lz aW9uRm9ybWF0KEdyYXBoaWNzQ29udGV4dEdMOjpGUkFHTUVOVF9TSEFERVIsIEdyYXBoaWNzQ29u dGV4dEdMOjpISUdIX0ZMT0FULCByYW5nZSwgJnByZWNpc2lvbik7CiAgICAgQU5HTEVSZXNvdXJj ZXMuRnJhZ21lbnRQcmVjaXNpb25IaWdoID0gKHJhbmdlWzBdIHx8IHJhbmdlWzFdIHx8IHByZWNp c2lvbik7CiAKICAgICBtX2NvbXBpbGVyLnNldFJlc291cmNlcyhBTkdMRVJlc291cmNlcyk7CiAj ZW5kaWYgLy8gIVVTRShBTkdMRSkKLSAgICAKKwogI2lmIFVTRShPUEVOR0wpCiAgICAgOjpnbEVu YWJsZShHTF9WRVJURVhfUFJPR1JBTV9QT0lOVF9TSVpFKTsKICAgICBpZiAoIWlzR0xFUzJDb21w bGlhbnQoKSkKQEAgLTU3OCwxNyArNjM2LDEzIEBAIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjp+ R3JhcGhpY3NDb250ZXh0R0xPcGVuR0woKQogCiAgICAgaWYgKG1fY29udGV4dE9iaikgewogICAg ICAgICBHcmFwaGljc0NvbnRleHRHTEF0dHJpYnV0ZXMgYXR0cnMgPSBjb250ZXh0QXR0cmlidXRl cygpOwotCisgICAgICAgIG1ha2VDb250ZXh0Q3VycmVudCgpOyAvLyBUT0RPOiBjaGVjayByZXN1 bHQuCiAjaWYgVVNFKE9QRU5HTF9FUykKLSAgICAgICAgbWFrZUNvbnRleHRDdXJyZW50KCk7CiAg ICAgICAgIFtzdGF0aWNfY2FzdDxFQUdMQ29udGV4dCAqPihtX2NvbnRleHRPYmopIHJlbmRlcmJ1 ZmZlclN0b3JhZ2U6R0xfUkVOREVSQlVGRkVSIGZyb21EcmF3YWJsZTpuaWxdOwogICAgICAgICA6 OmdsRGVsZXRlUmVuZGVyYnVmZmVycygxLCAmbV90ZXh0dXJlKTsKICNlbGlmIFVTRShPUEVOR0wp Ci0gICAgICAgIENHTENvbnRleHRPYmogY2dsQ29udGV4dCA9IHN0YXRpY19jYXN0PENHTENvbnRl eHRPYmo+KG1fY29udGV4dE9iaik7Ci0gICAgICAgIENHTFNldEN1cnJlbnRDb250ZXh0KGNnbENv bnRleHQpOwogICAgICAgICA6OmdsRGVsZXRlVGV4dHVyZXMoMSwgJm1fdGV4dHVyZSk7CiAjZWxp ZiBVU0UoQU5HTEUpCi0gICAgICAgIEVHTF9NYWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVHTF9O T19TVVJGQUNFLCBFR0xfTk9fU1VSRkFDRSwgbV9jb250ZXh0T2JqKTsKICAgICAgICAgZ2w6OkRl bGV0ZVRleHR1cmVzKDEsICZtX3RleHR1cmUpOwogI2VuZGlmCiAKQEAgLTcwNywxMiArNzYxLDU4 IEBAIGJvb2wgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6Om1ha2VDb250ZXh0Q3VycmVudCgpCiAg ICAgaWYgKGN1cnJlbnRDb250ZXh0ICE9IG1fY29udGV4dE9iaikKICAgICAgICAgcmV0dXJuIENH TFNldEN1cnJlbnRDb250ZXh0KHN0YXRpY19jYXN0PENHTENvbnRleHRPYmo+KG1fY29udGV4dE9i aikpID09IGtDR0xOb0Vycm9yOwogI2VsaWYgVVNFKEFOR0xFKQotICAgIGlmIChFR0xfR2V0Q3Vy cmVudENvbnRleHQoKSAhPSBtX2NvbnRleHRPYmopCi0gICAgICAgIHJldHVybiBFR0xfTWFrZUN1 cnJlbnQobV9kaXNwbGF5T2JqLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX1NVUkZBQ0UsIG1fY29u dGV4dE9iaik7CisgICAgLy8gQXQgdGhlIHRpbWUgb2Ygd3JpdGluZywgQU5HTEUgZG9lcyBub3Qg Zmx1c2ggb24gTWFrZUN1cnJlbnQuIFNpbmNlIHdlIGFyZQorICAgIC8vIHBvdGVudGlhbGx5IHN3 aXRjaGluZyB0aHJlYWRzIGxhdGVyLCB3ZSBzaG91bGQgZmx1c2guCisgICAgaWYgKCFXZWJDb3Jl Ojppc0luV2ViUHJvY2VzcygpKSB7CisgICAgICAgIGlmICghRUdMX0JpbmRBUEkoRUdMX09QRU5H TF9FU19BUEkpKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICBhdXRvIGN1cnJl bnRDb250ZXh0ID0gRUdMX0dldEN1cnJlbnRDb250ZXh0KCk7CisgICAgICAgIGlmIChjdXJyZW50 Q29udGV4dCAmJiBjdXJyZW50Q29udGV4dCAhPSBtX2NvbnRleHRPYmopCisgICAgICAgICAgICBn bDo6Rmx1c2goKTsKKyAgICB9CisKKyAgICAvLyBBTkdMRSBoYXMgYW4gZWFybHkgb3V0IGZvciBj YXNlIHdoZXJlIG5vdGhpbmcgY2hhbmdlcy4gQ2FsbGluZyBNYWtlQ3VycmVudAorICAgIC8vIGlz IGltcG9ydGFudCB0byBzZXQgdm9sYXRpbGUgcGxhdGZvcm0gY29udGV4dC4gU2VlIEluaXRpYWxp emVFR0xEaXNwbGF5KCkuCisgICAgaWYgKCFFR0xfTWFrZUN1cnJlbnQobV9kaXNwbGF5T2JqLCBF R0xfTk9fU1VSRkFDRSwgRUdMX05PX1NVUkZBQ0UsIG1fY29udGV4dE9iaikpCisgICAgICAgIHJl dHVybiBmYWxzZTsKICNlbmRpZgogICAgIHJldHVybiB0cnVlOwogfQogCisjaWYgUExBVEZPUk0o SU9TX0ZBTUlMWSkgJiYgVVNFKEFOR0xFKQorYm9vbCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6 cmVsZWFzZUN1cnJlbnRDb250ZXh0KFJlbGVhc2VCZWhhdmlvciByZWxlYXNlQmVoYXZpb3IpCit7 CisgICAgLy8gQXQgdGhlIG1vbWVudCB0aGlzIGZ1bmN0aW9uIGlzIHJlbGV2YW50IG9ubHkgd2hl biB3ZWIgdGhyZWFkIGxvY2sgb3ducyB0aGUgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wgY3VycmVu dCBjb250ZXh0LgorICAgIEFTU0VSVCghV2ViQ29yZTo6aXNJbldlYlByb2Nlc3MoKSk7CisKKyAg ICBpZiAoIUVHTF9CaW5kQVBJKEVHTF9PUEVOR0xfRVNfQVBJKSkKKyAgICAgICAgcmV0dXJuIGZh bHNlOworICAgIGlmIChFR0xfR2V0Q3VycmVudENvbnRleHQoKSA9PSBFR0xfTk9fQ09OVEVYVCkK KyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICAvLyBBdCB0aGUgdGltZSBvZiB3cml0aW5nLCBB TkdMRSBkb2VzIG5vdCBmbHVzaCBvbiBNYWtlQ3VycmVudC4gU2luY2Ugd2UgYXJlCisgICAgLy8g cG90ZW50aWFsbHkgc3dpdGNoaW5nIHRocmVhZHMsIHdlIHNob3VsZCBmbHVzaC4KKyAgICBnbDo6 Rmx1c2goKTsKKworICAgIC8vIFVuc2V0IHRoZSBFR0wgY3VycmVudCBjb250ZXh0LCBzaW5jZSB0 aGUgbmV4dCBhY2Nlc3MgbWlnaHQgYmUgZnJvbSBhbm90aGVyIHRocmVhZCwgYW5kIHRoZQorICAg IC8vIGNvbnRleHQgY2Fubm90IGJlIGN1cnJlbnQgb24gbXVsdGlwbGUgdGhyZWFkcy4KKworICAg IGlmIChyZWxlYXNlQmVoYXZpb3IgPT0gUmVsZWFzZUJlaGF2aW9yOjpSZWxlYXNlVGhyZWFkUmVz b3VyY2VzKSB7CisgICAgICAgIC8vIENhbGxlZCB3aGVuIHdlIGRvIG5vdCBrbm93IGlmIHRoaXMg dGhyZWFkIGFnYWluLgorICAgICAgICAvLyBVbnNldCB0aGUgRUdMIGN1cnJlbnQgY29udGV4dCBi eSByZWxlYXNpbmcgd2hvbGUgRUdMIHRocmVhZCBzdGF0ZS4KKyAgICAgICAgLy8gVGhlb3JldGlj YWxseSBSZWxlYXNlVGhyZWFkIGNhbiByZXNldCB0aGUgYm91bmQgQVBJLCBzbyB0aGUgcmVzdCBv ZiB0aGUgY29kZSBtZW50aW9ucyBCaW5kQVBJL1F1ZXJ5QVBJLgorICAgICAgICByZXR1cm4gRUdM X1JlbGVhc2VUaHJlYWQoKTsKKyAgICB9CisgICAgLy8gT24gV2ViS2l0IG93bmVkIHRocmVhZHMs IFdlYktpdCBpcyBhYmxlIHRvIGNob29zZSB0aGUgdGltZSBmb3IgdGhlIEVHTCBjbGVhbnVwLgor ICAgIC8vIFRoaXMgaXMgd2h5IHdlIG9ubHkgdW5zZXQgdGhlIGNvbnRleHQuCisgICAgLy8gTm90 ZTogQXQgdGhlIHRpbWUgb2Ygd3JpdGluZyB0aGUgRUdMIGNsZWFudXAgaXMgY2hvc2VuIHRvIGJl IG5vdCBkb25lIGF0IGFsbC4KKyAgICBFR0xEaXNwbGF5IGRpc3BsYXkgPSBFR0xfR2V0RGlzcGxh eShFR0xfREVGQVVMVF9ESVNQTEFZKTsKKyAgICBpZiAoZGlzcGxheSA9PSBFR0xfTk9fRElTUExB WSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHJldHVybiBFR0xfTWFrZUN1cnJlbnQoZGlz cGxheSwgRUdMX05PX1NVUkZBQ0UsIEVHTF9OT19TVVJGQUNFLCBFR0xfTk9fQ09OVEVYVCk7Cit9 CisjZW5kaWYKKwogdm9pZCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6Y2hlY2tHUFVTdGF0dXMo KQogewogICAgIGlmIChtX2ZhaWxOZXh0U3RhdHVzQ2hlY2spIHsKQEAgLTcyNCw2ICs4MjQsNyBA QCB2b2lkIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpjaGVja0dQVVN0YXR1cygpCiAjZWxpZiBV U0UoT1BFTkdMX0VTKQogICAgICAgICBbRUFHTENvbnRleHQgc2V0Q3VycmVudENvbnRleHQ6MF07 CiAjZWxpZiBVU0UoQU5HTEUpCisgICAgICAgIEVHTF9CaW5kQVBJKEVHTF9PUEVOR0xfRVNfQVBJ KTsKICAgICAgICAgRUdMX01ha2VDdXJyZW50KG1fZGlzcGxheU9iaiwgRUdMX05PX1NVUkZBQ0Us IEVHTF9OT19TVVJGQUNFLCBFR0xfTk9fQ09OVEVYVCk7CiAjZW5kaWYKICAgICAgICAgcmV0dXJu OwpAQCAtODk2LDEyICs5OTcsMTIgQEAgYm9vbCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6YWxs b3dPZmZsaW5lUmVuZGVyZXJzKCkgY29uc3QKICAgICAvLyBhbmQgTUFDL01BQ0NBVEFMWVNUIGFu ZCBPUEVOR0wvT1BFTkdMRVMuCiAgICAgcmV0dXJuIHRydWU7CiAjZW5kaWYKLSAgICAgICAgCisK ICNpZiBIQVZFKEFQUExFX0dSQVBISUNTX0NPTlRST0wpCiAgICAgaWYgKGhhc0xvd0FuZEhpZ2hQ b3dlckdQVXMoKSkKICAgICAgICAgcmV0dXJuIHRydWU7CiAjZW5kaWYKLSAgICAKKwogICAgIHJl dHVybiBmYWxzZTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMLmggYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaAppbmRleCBl OWNjNGZhY2QyMDMyZjllZTMxMTFhODU0MzUwMzEwNTU2NTk3YWJjLi43MDRkMjk3OTQ2MzNjMjdm NTZjYTgxYjBiYTA3MDk2NmZmNWVjNmQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVu R0wuaApAQCAtMTE5LDYgKzExOSwxMyBAQCBwdWJsaWM6CiAjZW5kaWYKIAogICAgIGJvb2wgbWFr ZUNvbnRleHRDdXJyZW50KCk7CisjaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkgJiYgVVNFKEFOR0xF KQorICAgIGVudW0gY2xhc3MgUmVsZWFzZUJlaGF2aW9yIHsgCisgICAgICAgIFByZXNlcnZlVGhy ZWFkUmVzb3VyY2VzLAorICAgICAgICBSZWxlYXNlVGhyZWFkUmVzb3VyY2VzCisgICAgfTsKKyAg ICBzdGF0aWMgYm9vbCByZWxlYXNlQ3VycmVudENvbnRleHQoUmVsZWFzZUJlaGF2aW9yKTsKKyNl bmRpZgogCiAgICAgdm9pZCBhZGRDbGllbnQoQ2xpZW50JiBjbGllbnQpIHsgbV9jbGllbnRzLmFk ZCgmY2xpZW50KTsgfQogICAgIHZvaWQgcmVtb3ZlQ2xpZW50KENsaWVudCYgY2xpZW50KSB7IG1f Y2xpZW50cy5yZW1vdmUoJmNsaWVudCk7IH0KQEAgLTU1MCw3ICs1NTcsNyBAQCBwdWJsaWM6CiAj aWYgVVNFKE9QRU5HTCkgfHwgVVNFKEFOR0xFKQogICAgIGJvb2wgYWxsb2NhdGVJT1N1cmZhY2VC YWNraW5nU3RvcmUoSW50U2l6ZSk7CiAgICAgdm9pZCB1cGRhdGVGcmFtZWJ1ZmZlclRleHR1cmVC YWNraW5nU3RvcmVGcm9tTGF5ZXIoKTsKLSNpZiBQTEFURk9STShNQUMpIHx8IFBMQVRGT1JNKE1B Q0NBVEFMWVNUKQorI2lmIFBMQVRGT1JNKE1BQykKICAgICB2b2lkIHVwZGF0ZUNHTENvbnRleHQo KTsKICNlbmRpZgogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9p b3Mvd2FrL1dlYkNvcmVUaHJlYWQubW0gYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pb3Mvd2Fr L1dlYkNvcmVUaHJlYWQubW0KaW5kZXggNWFkN2ZlNTE5OGQyNGMzMDM2NmEyMzBhMDk3MzI0YzRh MjVjNjk0ZC4uNjM5NGI5N2Q3OGFhMTBlNTgzNTQzOTY1YjU5N2JkMzA5Zjk2MzBjOSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW9zL3dhay9XZWJDb3JlVGhyZWFkLm1tCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2lvcy93YWsvV2ViQ29yZVRocmVhZC5tbQpAQCAt MzAsNiArMzAsNyBAQAogCiAjaW1wb3J0ICJDb21tb25WTS5oIgogI2ltcG9ydCAiRmxvYXRpbmdQ b2ludEVudmlyb25tZW50LmgiCisjaW1wb3J0ICJHcmFwaGljc0NvbnRleHRHTE9wZW5HTC5oIgog I2ltcG9ydCAiTG9nZ2luZy5oIgogI2ltcG9ydCAiUnVudGltZUFwcGxpY2F0aW9uQ2hlY2tzLmgi CiAjaW1wb3J0ICJUaHJlYWRHbG9iYWxEYXRhLmgiCkBAIC01OSw2ICs2MCwyNiBAQAogCiAjZGVm aW5lIERpc3RhbnRGdXR1cmUgICAoODY0MDAuMCAqIDIwMDAgKiAzNjUuMjQyNSArIDg2NDAwLjAp ICAgLy8gc2FtZSBhcyArW05TRGF0ZSBkaXN0YW50RnV0dXJlXQogCituYW1lc3BhY2UgeworLy8g UmVsZWFzZSBnbG9iYWwgc3RhdGUgdGhhdCBpcyBhY2Nlc3NlZCBmcm9tIGJvdGggd2ViIHRocmVh ZCBhcyB3ZWxsCisvLyBhcyBhbnkgY2xpZW50IHRocmVhZCB0aGF0IGNhbGxzIGludG8gV2ViS2l0 Lgordm9pZCBSZWxlYXNlV2ViVGhyZWFkR2xvYmFsU3RhdGUoKQoreworICAgIC8vIEdyYXBoaWNz Q29udGV4dEdMT3BlbkdMIGN1cnJlbnQgY29udGV4dCBpcyBvd25lZCBieSB0aGUgd2ViIHRocmVh ZCBsb2NrLiBSZWxlYXNlIHRoZSBjb250ZXh0CisgICAgLy8gYmVmb3JlIHRoZSBsb2NrIGlzIHJl bGVhc2VkLgorCisgICAgLy8gSW4gc2luZ2xlLXRocmVhZGVkIGVudmlyb25tZW50cyB3ZSBkbyBu b3QgbmVlZCB0byB1bnNldCB0aGUgY29udGV4dCwgYXMgdGhlcmUgc2hvdWxkIG5vdCBiZSBhY2Nl c3MgZnJvbQorICAgIC8vIG11bHRpcGxlIHRocmVhZHMuCisgICAgQVNTRVJUKFdlYlRocmVhZElz RW5hYmxlZCgpKTsKKyAgICB1c2luZyBSZWxlYXNlQmVoYXZpb3IgPSBXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHRHTE9wZW5HTDo6UmVsZWFzZUJlaGF2aW9yOworICAgIC8vIEZvciBub24td2ViIHRo cmVhZHMsIHdlIGRvbid0IGtub3cgaWYgd2UgZXZlciBzZWUgYW5vdGhlciBjYWxsIGZyb20gdGhl IHRocmVhZC4KKyAgICBSZWxlYXNlQmVoYXZpb3IgcmVsZWFzZUJlaGF2aW9yID0KKyAgICAgICAg V2ViVGhyZWFkSXNDdXJyZW50KCkgPyBSZWxlYXNlQmVoYXZpb3I6OlByZXNlcnZlVGhyZWFkUmVz b3VyY2VzIDogUmVsZWFzZUJlaGF2aW9yOjpSZWxlYXNlVGhyZWFkUmVzb3VyY2VzOworICAgIFdl YkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxlYXNlQ3VycmVudENvbnRleHQocmVs ZWFzZUJlaGF2aW9yKTsKK30KKworfQorCiBzdGF0aWMgY29uc3QgY29uc3RleHByIFNlY29uZHMg RGVsZWdhdGVXYWl0SW50ZXJ2YWwgeyAxMF9zIH07CiAKIHN0YXRpYyB2b2lkIF9XZWJUaHJlYWRB dXRvTG9jaygpOwpAQCAtNzc4LDYgKzc5OSw4IEBAIHZvaWQgV2ViVGhyZWFkVW5sb2NrRnJvbUFu eVRocmVhZCh2b2lkKQogICAgIGlmICghd2ViVGhyZWFkU3RhcnRlZCkKICAgICAgICAgcmV0dXJu OwogICAgIEFTU0VSVCghV2ViVGhyZWFkSXNDdXJyZW50KCkpOworICAgIFJlbGVhc2VXZWJUaHJl YWRHbG9iYWxTdGF0ZSgpOworCiAgICAgLy8gTm8tb3AgZXhjZXB0IGZyb20gYSBzZWNvbmRhcnkg dGhyZWFkLgogICAgIGlmIChwdGhyZWFkX21haW5fbnAoKSkKICAgICAgICAgcmV0dXJuOwpAQCAt Nzk5LDYgKzgyMiw4IEBAIHZvaWQgV2ViVGhyZWFkVW5sb2NrR3VhcmRGb3JNYWlsKHZvaWQpCiAK IHZvaWQgX1dlYlRocmVhZFVubG9jaygpCiB7CisgICAgUmVsZWFzZVdlYlRocmVhZEdsb2JhbFN0 YXRlKCk7CisKICNpZiBMT0dfV0VCX0xPQ0sgfHwgTE9HX01BSU5fVEhSRUFEX0xPQ0tJTkcKICAg ICBsb2NrQ291bnQtLTsKICNpZiBMT0dfV0VCX0xPQ0sKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5n ZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCA2OGNiYjVjMmIwMGFiODRhNmE3MDk2NWU2MDkz ZDM0ZTAwYThiNGY4Li44MjFiZDVmZjEyOWU3ZDAxYjMwYTgwMTM1YjdlZDEzNDYwMzA5NDhjIDEw MDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMjggQEAKKzIwMjAtMDktMjkgIEtpbW1vIEtpbm51bmVuICA8a2tpbm51bmVuQGFwcGxlLmNv bT4KKworICAgICAgICBbaU9TIFdLMV0gQ3Jhc2hlcyB3aGVuIHVzaW5nIEFOR0xFIFdlYkdMIGZy b20gYW5vdGhlciB0aHJlYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIxNjEwNgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjg2MDI0NTI+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgV0sxIHRl c3Qgd2hpY2ggcnVucyBXZWJHTCBjb2RlIGJvdGggaW4KKyAgICAgICAgY2xpZW50IG1haW4gdGhy ZWFkIGFuZCBpbiB3ZWIgdGhyZWFkLgorICAgICAgICBUaGlzIHRlc3RzIHRoZSBjYXNlIHdoZXJl IEFOR0xFIEVHTCBjb250ZXh0IGlzCisgICAgICAgIG5vdCBiZWluZyBoZWxkIGN1cnJlbnQgaW4g b25lIHRocmVhZCB3aGlsZSB0aGUKKyAgICAgICAgb3RoZXIgdGhyZWFkIHJ1bnMgV2ViR0wgYW5k IHRodXMgQU5HTEUgRUdMIGNvZGUuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL0NvbmZpZ3Vy YXRpb25zL1Rlc3RXZWJLaXRBUEkueGNjb25maWc6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9U ZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRB Y2Nlc3MubW06IEFkZGVkLgorICAgICAgICAoUEFMOjpTZXRDb250ZXh0Q0dMOjpTZXRDb250ZXh0 Q0dMKToKKyAgICAgICAgKFBBTDo6U2V0Q29udGV4dENHTDo6flNldENvbnRleHRDR0wpOgorICAg ICAgICAoUEFMOjpTZXRDb250ZXh0RUFHTDo6U2V0Q29udGV4dEVBR0wpOgorICAgICAgICAoUEFM OjpTZXRDb250ZXh0RUFHTDo6flNldENvbnRleHRFQUdMKToKKyAgICAgICAgKC1bV2ViR0xOb0Ny YXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxlZ2F0ZSB3ZWJWaWV3RGlkRmluaXNoTG9h ZDpdKToKKyAgICAgICAgKC1bV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdE ZWxlZ2F0ZSB3ZWJWaWV3OnNob3VsZFN0YXJ0TG9hZFdpdGhSZXF1ZXN0Om5hdmlnYXRpb25UeXBl Ol0pOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIwMjAtMDktMjkgIEFuZHJl cyBHb256YWxleiAgPGFuZHJlc2dfMjJAYXBwbGUuY29tPgogCiAgICAgICAgIE1vZGlmeSBFTkRf QVhfT0JKQ19FWENFUFRJT05TIG1hY3JvIHRvIGFzc2VydCB0byBhaWQgZGVidWdnaW5nIG9mIGxh eW91dCB0ZXN0cy4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJhdGlv bnMvVGVzdFdlYktpdEFQSS54Y2NvbmZpZyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJh dGlvbnMvVGVzdFdlYktpdEFQSS54Y2NvbmZpZwppbmRleCBiYmRkZTg3NTE3OTM4NzNlMGQwZmEy ZGNhNDIxZWQ1N2FjMGFiZjAwLi43N2YyZTM1MzI5N2NhMzY4NDk5YWViNjlmOTlhY2MwNjdhNTMx OTEwIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL0NvbmZpZ3VyYXRpb25zL1Rlc3RX ZWJLaXRBUEkueGNjb25maWcKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9u cy9UZXN0V2ViS2l0QVBJLnhjY29uZmlnCkBAIC02MSw3ICs2MSw3IEBAIFdLX0hJRF9MREZMQUdT X01BQ09TX1NJTkNFXzEwMTUgPSAtZnJhbWV3b3JrIEhJRDsKIAogT1RIRVJfQ1BMVVNQTFVTRkxB R1MgPSAkKGluaGVyaXRlZCkgLWlzeXN0ZW0gJChTREtST09UKS9TeXN0ZW0vTGlicmFyeS9GcmFt ZXdvcmtzL1N5c3RlbS5mcmFtZXdvcmsvUHJpdmF0ZUhlYWRlcnM7CiAKLU9USEVSX0xERkxBR1Mg PSAkKGluaGVyaXRlZCkgJChVTkVYUE9SVEVEX1NZTUJPTF9MREZMQUdTKSAtbGd0ZXN0IC1mb3Jj ZV9sb2FkICQoQlVJTFRfUFJPRFVDVFNfRElSKS9saWJUZXN0V2ViS2l0QVBJLmEgLWZyYW1ld29y ayBKYXZhU2NyaXB0Q29yZSAtZnJhbWV3b3JrIFdlYktpdCAtbFdlYkNvcmVUZXN0U3VwcG9ydCAk KFdLX0FVVEhLSVRfTERGTEFHUykgLWZyYW1ld29yayBOZXR3b3JrICQoV0tfUERGS0lUX0xERkxB R1MpICQoV0tfSElEX0xERkxBR1MpICQoT1RIRVJfTERGTEFHU19QTEFURk9STV8kKFdLX0NPQ09B X1RPVUNIKSk7CitPVEhFUl9MREZMQUdTID0gJChpbmhlcml0ZWQpICQoVU5FWFBPUlRFRF9TWU1C T0xfTERGTEFHUykgLWxndGVzdCAtZm9yY2VfbG9hZCAkKEJVSUxUX1BST0RVQ1RTX0RJUikvbGli VGVzdFdlYktpdEFQSS5hICAtZm9yY2VfbG9hZCAkKEJVSUxUX1BST0RVQ1RTX0RJUikvbGliUEFM LmEgLWx6IC1mcmFtZXdvcmsgSmF2YVNjcmlwdENvcmUgLWZyYW1ld29yayBXZWJLaXQgLWxXZWJD b3JlVGVzdFN1cHBvcnQgJChXS19BVVRIS0lUX0xERkxBR1MpIC1mcmFtZXdvcmsgTmV0d29yayAk KFdLX1BERktJVF9MREZMQUdTKSAkKFdLX0hJRF9MREZMQUdTKSAkKE9USEVSX0xERkxBR1NfUExB VEZPUk1fJChXS19DT0NPQV9UT1VDSCkpOwogT1RIRVJfTERGTEFHU19QTEFURk9STV8gPSAtZnJh bWV3b3JrIENvY29hIC1mcmFtZXdvcmsgQ2FyYm9uOwogCiAvLyBGSVhNRTogVGhpcyBzaG91bGQg bm90IGJlIGJ1aWx0IG9uIGlPUy4gSW5zdGVhZCB3ZSBzaG91bGQgY3JlYXRlIGFuZCB1c2UgYSBU ZXN0V2ViS2l0QVBJIGFwcGxpY2F0aW9uLgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBjYmNk OTMzY2Y2N2FkNzkzOTJjYzM5NDY0ZDI2NzA4MWQ4ODA5MDUyLi45YTg3MjI4OWNlZmJlZjYzMGVl YzM3OTkwY2RhZjVlMzdjNGNmZTY0IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNTQ3LDYg KzU0Nyw3IEBACiAJCTdBRTlFNTA5MUFFNUFFOEIwMENGODc0QiAvKiB0ZXN0LnBkZiBpbiBDb3B5 IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QUU5RTUwODFB RTVBRThCMDBDRjg3NEIgLyogdGVzdC5wZGYgKi87IH07CiAJCTdBRUFENDdGMUUyMDExNkMwMDQx NkVGRSAvKiBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MubW0gaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QUVBRDQ3QzFFMjAxMTM4MDA0MTZFRkUg LyogQ3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLm1tICovOyB9OwogCQk3QUVBRDQ4MTFF MjAxMjI3MDA0MTZFRkUgLyogQ3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLmh0bWwgaW4g Q29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gN0FFQUQ0 N0QxRTIwMTE0RTAwNDE2RUZFIC8qIENyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5odG1s ICovOyB9OworCQk3QjdEMDk2QTI1MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhl clRocmVhZEFjY2Vzcy5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDdCN0QwOTY5MjUxOUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhy ZWFkQWNjZXNzLm1tICovOyB9OwogCQk3QzFBRjc5NTFFOERDQkFCMDAyNjQ1QjkgLyogUHJlcGFy ZUZvck1vdmVUb1dpbmRvdy5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDdDMUFGNzkzMUU4RENCQUIwMDI2NDVCOSAvKiBQcmVwYXJlRm9yTW92ZVRvV2lu ZG93Lm1tICovOyB9OwogCQk3QzM5NjUwNjFDREQ3NEY5MDA5NERCQjggLyogQ29sb3JUZXN0cy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QzM5NjUw NTFDREQ3NEY5MDA5NERCQjggLyogQ29sb3JUZXN0cy5jcHAgKi87IH07CiAJCTdDM0RCOEU0MUQx MjEyOUIwMEFFOENDMyAvKiBDb21tYW5kQmFja0ZvcndhcmQubW0gaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QzNEQjhFMjFEMTIxMjlCMDBBRThDQzMgLyog Q29tbWFuZEJhY2tGb3J3YXJkLm1tICovOyB9OwpAQCAtMjMwOSw2ICsyMzEwLDcgQEAKIAkJN0FF OUU1MDgxQUU1QUU4QjAwQ0Y4NzRCIC8qIHRlc3QucGRmICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gaW1hZ2UucGRmOyBwYXRoID0gdGVzdC5wZGY7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdBRUFENDdDMUUyMDExMzgwMDQxNkVGRSAvKiBD cm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5vYmpjcHA7IHBhdGggPSBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MubW07IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdBRUFENDdEMUUyMDExNEUwMDQxNkVGRSAvKiBDcm9z c1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgbmFt ZSA9IENyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5odG1sOyBwYXRoID0gVGVzdHMvbWFj L0Nyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5odG1sOyBzb3VyY2VUcmVlID0gU09VUkNF X1JPT1Q7IH07CisJCTdCN0QwOTY5MjUxOUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jhc2hPbk90 aGVyVGhyZWFkQWNjZXNzLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV2ViR0xOb0NyYXNoT25P dGhlclRocmVhZEFjY2Vzcy5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJN0MxQUY3 OTMxRThEQ0JBQjAwMjY0NUI5IC8qIFByZXBhcmVGb3JNb3ZlVG9XaW5kb3cubW0gKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBQcmVwYXJlRm9yTW92ZVRvV2luZG93Lm1t OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3QzM5NjUwNTFDREQ3NEY5MDA5NERCQjgg LyogQ29sb3JUZXN0cy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBD b2xvclRlc3RzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJN0MzREI4RTIxRDEy MTI5QjAwQUU4Q0MzIC8qIENvbW1hbmRCYWNrRm9yd2FyZC5tbSAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLm9iamNwcDsgcGF0aCA9IENvbW1hbmRCYWNrRm9yd2FyZC5tbTsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKQEAgLTQ2MDUsNiArNDYwNyw3IEBACiAJCQkJQ0RDMDkzMkEyMUM4NzJD MTAwMzBDNEIwIC8qIFNjcm9sbGluZ0RvZXNOb3RQYXVzZU1lZGlhLm1tICovLAogCQkJCUY0MzRD QTE5MjJFNjVCQ0EwMDVEREIyNiAvKiBTY3JvbGxUb1JldmVhbFNlbGVjdGlvbi5tbSAqLywKIAkJ CQkwRjRGRkE5RDFFRDNBQTg1MDBGNzExMUYgLyogU25hcHNob3RWaWFSZW5kZXJJbkNvbnRleHQu bW0gKi8sCisJCQkJN0I3RDA5NjkyNTE5RjhGOTAwMTdBMDc4IC8qIFdlYkdMTm9DcmFzaE9uT3Ro ZXJUaHJlYWRBY2Nlc3MubW0gKi8sCiAJCQkJMzFFOUJEQTAyNDdGNEM2MjAwMkU1MUEyIC8qIFdl YkdMUHJlcGFyZURpc3BsYXlPbldlYlRocmVhZC5tbSAqLywKIAkJCQkyREM5NDUxNjI0RDhBQzAy MDA0MzAzNzYgLyogV2ViVGhyZWFkTG9jay5tbSAqLywKIAkJCSk7CkBAIC01NDc5LDYgKzU0ODIs NyBAQAogCQkJCTdDODNFMDRDMUQwQTY0MTgwMEZFQkNGMyAvKiBXZWJDb3JlTlNVUkxTZXNzaW9u Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNTdBNzk4NTcyMjRBQjM0RTAwQTdGNkYxIC8qIFdlYkNy eXB0b01hc3RlcktleS5tbSBpbiBTb3VyY2VzICovLAogCQkJCUMxRkY5RURCMjQ0NjQ0RjAwMDgz OUFFNCAvKiBXZWJGaWx0ZXIubW0gaW4gU291cmNlcyAqLywKKwkJCQk3QjdEMDk2QTI1MTlGOEY5 MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbSBpbiBTb3VyY2Vz ICovLAogCQkJCTVDOTczRjVDMUY1OEVGOEIwMDM1OUMyNyAvKiBXZWJHTFBvbGljeS5tbSBpbiBT b3VyY2VzICovLAogCQkJCTMxRTlCREExMjQ3RjRDNjIwMDJFNTFBMiAvKiBXZWJHTFByZXBhcmVE aXNwbGF5T25XZWJUaHJlYWQubW0gaW4gU291cmNlcyAqLywKIAkJCQk3Q0NFN0VBQjFBNDExQTI0 MDA0NDdDNEMgLyogV2ViS2l0QWdub3N0aWNUZXN0Lm1tIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1n aXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExlZ2FjeS9pb3MvV2ViR0xOb0Ny YXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0TGVnYWN5L2lvcy9XZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzLm1tCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjRhMGFmMjM1MzQzMmY4ZWU2ZmUyYzI3OWFjNjExZjYyM2RhMTI5MDMKLS0tIC9kZXYvbnVs bAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExlZ2FjeS9pb3MvV2ViR0xO b0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbQpAQCAtMCwwICsxLDIwOCBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5D LiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMu IE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z IFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I2ltcG9ydCAiY29uZmlnLmgiCisKKyNpZiBIQVZFKFVJV0VCVklFVykKKworI2ltcG9ydCAiUGxh dGZvcm1VdGlsaXRpZXMuaCIKKyNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0pTVmlydHVhbE1hY2hp bmUuaD4KKyNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0pTVmlydHVhbE1hY2hpbmVJbnRlcm5hbC5o PgorI2ltcG9ydCA8VUlLaXQvVUlLaXQuaD4KKyNpbXBvcnQgPFdlYkNvcmUvT3BlbkdMRVNTb2Z0 TGlua0NvY29hLmg+CisjaW1wb3J0IDxXZWJDb3JlL09wZW5HTFNvZnRMaW5rQ29jb2EuaD4KKyNp bXBvcnQgPFdlYkNvcmUvV2ViQ29yZVRocmVhZC5oPgorI2ltcG9ydCA8c3RkbGliLmg+CisjaW1w b3J0IDx3dGYvUmV0YWluUHRyLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBQQUw7CisKK25hbWVzcGFj ZSB7Citib29sIGRpZEZpbmlzaExvYWQ7Citib29sIGRpZEZpbmlzaFRlc3Q7CisKKyNpZiBQTEFU Rk9STShNQUMpIHx8IFBMQVRGT1JNKE1BQ0NBVEFMWVNUKQorY2xhc3MgU2V0Q29udGV4dENHTCB7 CisgICAgU2V0Q29udGV4dENHTCgpCisgICAgeworICAgICAgICAvLyBUT0RPOiBpbXBsZW1lbnQg cHJvcGVybHkuIFNraXBwZWQgZHVlIHRvIGNvbXBsaWNhdGVkIGluc3RhbnRpYXRpb24uCisgICAg ICAgIC8vIGluc3RlYWQsIGp1c3QgY2xvYmJlciB0aGUgY3VycmVudCBjb250ZXh0IHdpdGggbnVs bHB0ci4KKyAgICAgICAgQ0dMU2V0Q3VycmVudENvbnRleHQobnVsbHB0cik7CisgICAgfQorICAg IH5TZXRDb250ZXh0Q0dMKCkKKyAgICB7CisgICAgICAgIENHTFNldEN1cnJlbnRDb250ZXh0KG51 bGxwdHIpOworICAgIH0KK307CisjZWxzZQorY2xhc3MgU2V0Q29udGV4dENHTCB7CisKK307Cisj ZW5kaWYKKworI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCitjbGFzcyBTZXRDb250ZXh0RUFHTCB7 CitwdWJsaWM6CisgICAgU2V0Q29udGV4dEVBR0woKQorICAgIHsKKyAgICAgICAgbV9lYWdsQ29u dGV4dCA9IGFkb3B0TlMoW2FsbG9jRUFHTENvbnRleHRJbnN0YW5jZSgpIGluaXRXaXRoQVBJOiBr RUFHTFJlbmRlcmluZ0FQSU9wZW5HTEVTM10pOworICAgICAgICBhdXRvIHIgPSBbZ2V0RUFHTENv bnRleHRDbGFzcygpIHNldEN1cnJlbnRDb250ZXh0OiBtX2VhZ2xDb250ZXh0LmdldCgpXTsKKyAg ICAgICAgQVNTRVJUKHIpOworICAgICAgICBVTlVTRURfVkFSSUFCTEUocik7CisgICAgfQorICAg IH5TZXRDb250ZXh0RUFHTCgpCisgICAgeworICAgICAgICBbZ2V0RUFHTENvbnRleHRDbGFzcygp IHNldEN1cnJlbnRDb250ZXh0OiBuaWxdOworICAgIH0KKworcHJpdmF0ZToKKyAgICBSZXRhaW5Q dHI8RUFHTENvbnRleHQ+IG1fZWFnbENvbnRleHQ7Cit9OworI2Vsc2UKK2NsYXNzIFNldENvbnRl eHRFQUdMIHsKKworfTsKKyNlbmRpZgorCit9CisKK0BpbnRlcmZhY2UgV2ViR0xOb0NyYXNoT25P dGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxlZ2F0ZSA6IE5TT2JqZWN0IDxVSVdlYlZpZXdEZWxl Z2F0ZT4KK0BlbmQKKworQGltcGxlbWVudGF0aW9uIFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRB Y2Nlc3NXZWJWaWV3RGVsZWdhdGUKKworSUdOT1JFX1dBUk5JTkdTX0JFR0lOKCJkZXByZWNhdGVk LWltcGxlbWVudGF0aW9ucyIpCistICh2b2lkKXdlYlZpZXdEaWRGaW5pc2hMb2FkOihVSVdlYlZp ZXcgKil3ZWJWaWV3Cit7CisgICAgZGlkRmluaXNoTG9hZCA9IHRydWU7Cit9CisKKy0gKEJPT0wp d2ViVmlldzooVUlXZWJWaWV3ICopd2ViVmlldyBzaG91bGRTdGFydExvYWRXaXRoUmVxdWVzdDoo TlNVUkxSZXF1ZXN0ICopcmVxdWVzdCBuYXZpZ2F0aW9uVHlwZTooVUlXZWJWaWV3TmF2aWdhdGlv blR5cGUpbmF2aWdhdGlvblR5cGUKK3sKKyAgICBpZiAoW3JlcXVlc3QuVVJMLnNjaGVtZSBpc0Vx dWFsVG9TdHJpbmc6QCJjYWxsYmFjayJdKSB7CisgICAgICAgIGlmIChbcmVxdWVzdC5VUkwucmVz b3VyY2VTcGVjaWZpZXIgaXNFcXVhbFRvU3RyaW5nOkAiZGlkRmluaXNoVGVzdCJdKQorICAgICAg ICAgICAgZGlkRmluaXNoVGVzdCA9IHRydWU7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIEVY UEVDVF9UUlVFKGZhbHNlKSA8PCBbcmVxdWVzdC5VUkwucmVzb3VyY2VTcGVjaWZpZXIgVVRGOFN0 cmluZ107CisgICAgICAgIHJldHVybiBOTzsKKyAgICB9CisKKyAgICByZXR1cm4gWUVTOworfQor SUdOT1JFX1dBUk5JTkdTX0VORAorCitAZW5kCisKK25hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsK KworLy8gVGVzdCB0aGF0IHRlc3RzIGJlaGF2aW9yIG9mIFVJV2ViVmlldyBBUEkgd2l0aCByZWdh cmRzIHRvIFdlYkdMOgorLy8gMSkgV2ViR0wgY2FuIGJlIHJ1biBvbiB3ZWIgdGhyZWFkLgorLy8g MikgV2ViR0wgY2FuIGJlIHJ1biBvbiBjbGllbnQgbWFpbiB0aHJlYWQuCisvLyAzKSBXZWJHTCBy dW4gb24gY2xpZW50IHRocmVhZCBpcyBub3QgYWZmZWN0ZWQgYnkgY2xpZW50IGNoYW5naW5nCisv LyAgICB0aGUgRUFHTC9DR0wgY29udGV4dC4KK1RFU1QoV2ViS2l0TGVnYWN5LCBXZWJHTE5vQ3Jh c2hPbk90aGVyVGhyZWFkQWNjZXNzKQoreworICAgIGNvbnN0IHVuc2lnbmVkIHRlc3RJdGVyYXRp b25zID0gMTA7CisKKyAgICBSZXRhaW5QdHI8VUlXaW5kb3c+IHVpV2luZG93ID0gYWRvcHROUyhb W1VJV2luZG93IGFsbG9jXSBpbml0V2l0aEZyYW1lOk5TTWFrZVJlY3QoMCwgMCwgODAwLCA2MDAp XSk7CisgICAgUmV0YWluUHRyPFVJV2ViVmlldz4gdWlXZWJWaWV3ID0gYWRvcHROUyhbW1VJV2Vi VmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU01ha2VSZWN0KDAsIDAsIDgwMCwgNjAwKV0pOwor ICAgIFt1aVdpbmRvdyBhZGRTdWJ2aWV3OnVpV2ViVmlldy5nZXQoKV07CisKKyAgICBBU1NFUlRf VFJVRShXZWJUaHJlYWRJc0VuYWJsZWQoKSk7CisgICAgU2V0Q29udGV4dENHTCBjbGllbnRDb250 ZXh0Q0dMMTsKKyAgICBTZXRDb250ZXh0RUFHTCBjbGllbnRDb250ZXh0RUFHTDE7CisgICAgVU5V U0VEX1ZBUklBQkxFKGNsaWVudENvbnRleHRDR0wxKTsKKyAgICBVTlVTRURfVkFSSUFCTEUoY2xp ZW50Q29udGV4dEVBR0wxKTsKKworICAgIFJldGFpblB0cjxXZWJHTE5vQ3Jhc2hPbk90aGVyVGhy ZWFkQWNjZXNzV2ViVmlld0RlbGVnYXRlPiB1aURlbGVnYXRlID0KKyAgICAgICAgYWRvcHROUyhb W1dlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nlc3NXZWJWaWV3RGVsZWdhdGUgYWxsb2NdIGlu aXRdKTsKKyAgICB1aVdlYlZpZXcuZ2V0KCkuZGVsZWdhdGUgPSB1aURlbGVnYXRlLmdldCgpOwor ICAgIE5TU3RyaW5nKiB0ZXN0SHRtbCA9IEBSIkhUTUwoPGJvZHk+Tk9MSU5UKHJlYWRhYmlsaXR5 L211bHRpbGluZV9zdHJpbmcpCis8c2NyaXB0PgorZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgICAg bGV0IHcgPSAxMDA7CisgICAgbGV0IGggPSAxMDA7CisgICAgbGV0IGNhbnZhcyA9IGRvY3VtZW50 LmNyZWF0ZUVsZW1lbnQoImNhbnZhcyIpOworICAgIGNhbnZhcy53aWR0aCA9IHc7CisgICAgY2Fu dmFzLmhlaWdodCA9IGg7CisgICAgbGV0IGdsID0gY2FudmFzLmdldENvbnRleHQoIndlYmdsIik7 CisgICAgZ2wuY2xlYXJDb2xvcigwLCAwLCAxLCAxKTsKKyAgICBnbC5jbGVhcihnbC5DT0xPUl9C VUZGRVJfQklUKTsKKyAgICBsZXQgZXhwZWN0ZWQgPSAyNTUgPDwgMjQgfCAyNTUgPDwgMTY7Cisg ICAgbGV0IHBzID0gbmV3IFVpbnQ4QXJyYXkodyAqIGggKiA0KTsKKyAgICBnbC5yZWFkUGl4ZWxz KDAsIDAsIHcsIGgsIGdsLlJHQkEsIGdsLlVOU0lHTkVEX0JZVEUsIHBzKTsKKyAgICBmb3IgKGxl dCBpID0gMDsgaSA8IHBzLmxlbmd0aDsgaSArPSA0KSB7CisgICAgICAgIGxldCBnb3QgPSBwc1tp XSB8IHBzW2krMV0gPDwgOCB8IHBzW2krMl0gPDwgMTYgfCBwc1tpKzNdIDw8IDI0OworICAgICAg ICBpZiAoZ290ICE9IGV4cGVjdGVkKQorICAgICAgICAgICAgcmV0dXJuIGAke2dvdH0gIT0gJHtl eHBlY3RlZH1gOyAvLyBOT0xJTlQKKyAgICB9CisgICAgcmV0dXJuICJkaWRGaW5pc2hUZXN0IjsK K30KK2Z1bmN0aW9uIHJ1blRlc3RBc3luYygpCit7CisgICAgc2V0VGltZW91dCgoKSA9PiB7IHdp bmRvdy5sb2NhdGlvbiA9ICdjYWxsYmFjazonICsgcnVuVGVzdCgpOyB9LCAxMCk7IC8vIE5PTElO VAorfQorPC9zY3JpcHQ+KUhUTUwiOyAvLyBOT0xJTlQocmVhZGFiaWxpdHkvbXVsdGlsaW5lX3N0 cmluZykKKyAgICBbdWlXZWJWaWV3IGxvYWRIVE1MU3RyaW5nOnRlc3RIdG1sIGJhc2VVUkw6bmls XTsKKworICAgIFV0aWw6OnJ1bigmZGlkRmluaXNoTG9hZCk7CisKKyAgICBSZXRhaW5QdHI8SlND b250ZXh0PiBqc0NvbnRleHQgPSBbdWlXZWJWaWV3IHZhbHVlRm9yS2V5UGF0aDpAImRvY3VtZW50 Vmlldy53ZWJWaWV3Lm1haW5GcmFtZS5qYXZhU2NyaXB0Q29udGV4dCJdOworICAgIFJldGFpblB0 cjxKU1ZpcnR1YWxNYWNoaW5lPiBqc1ZNID0gW2pzQ29udGV4dCB2aXJ0dWFsTWFjaGluZV07Cisg ICAgRVhQRUNUX1RSVUUoW2pzVk0gaXNXZWJUaHJlYWRBd2FyZV0pOworCisgICAgLy8gU3RhcnQg dG8gcnVuIFdlYkdMIG9uIHdlYiB0aHJlYWQuCisgICAgW3VpV2ViVmlldyBzdHJpbmdCeUV2YWx1 YXRpbmdKYXZhU2NyaXB0RnJvbVN0cmluZzpAInJ1blRlc3RBc3luYygpOyJdOworICAgIEVYUEVD VF9GQUxTRShkaWRGaW5pc2hUZXN0KTsgLy8gVGhlIHBhdHRlcm4gcnVucyB0aGUgdGVzdCBvbiB3 ZWIgdGhyZWFkLgorCisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHRlc3RJdGVyYXRpb25z OyBpKyspIHsKKyAgICAgICAgLy8gUnVuIFdlYkdMIG9uIGNsaWVudCBtYWluIHRocmVhZC4KKyAg ICAgICAgTlNTdHJpbmcqIHJlc3VsdCA9IFtbanNDb250ZXh0IGV2YWx1YXRlU2NyaXB0OiBAInJ1 blRlc3QoKTsiXSB0b1N0cmluZ107CisgICAgICAgIEVYUEVDVF9UUlVFKFtAImRpZEZpbmlzaFRl c3QiIGlzRXF1YWxUb1N0cmluZzogcmVzdWx0XSk7CisKKyAgICAgICAgLy8gQ2xpZW50IGNsb2Ji ZXJzIEVBR0xDb250ZXh0IGJldHdlZW4gY2FsbHMgdGhhdCBydW4gV2ViR0wgb24gbWFpbiB0aHJl YWQuCisgICAgICAgIFNldENvbnRleHRDR0wgY2xpZW50Q29udGV4dENHTDI7CisgICAgICAgIFNl dENvbnRleHRFQUdMIGNsaWVudENvbnRleHRFQUdMMjsKKyAgICAgICAgVU5VU0VEX1ZBUklBQkxF KGNsaWVudENvbnRleHRDR0wyKTsKKyAgICAgICAgVU5VU0VEX1ZBUklBQkxFKGNsaWVudENvbnRl eHRFQUdMMik7CisKKyAgICAgICAgcmVzdWx0ID0gW1tqc0NvbnRleHQgZXZhbHVhdGVTY3JpcHQ6 IEAicnVuVGVzdCgpOyJdIHRvU3RyaW5nXTsKKyAgICAgICAgRVhQRUNUX1RSVUUoW0AiZGlkRmlu aXNoVGVzdCIgaXNFcXVhbFRvU3RyaW5nOiByZXN1bHRdKTsKKworICAgICAgICAvLyBXYWl0IHVu dGlsIHRoZSBwcmV2aW91cyBXZWJHTCB0ZXN0IHJ1biBoYXMgZmluaXNoZWQuCisgICAgICAgIFV0 aWw6OnJ1bigmZGlkRmluaXNoVGVzdCk7CisgICAgICAgIGRpZEZpbmlzaFRlc3QgPSBmYWxzZTsK KyAgICAgICAgLy8gU3RhcnQgdG8gcnVuIFdlYkdMIG9uIHdlYiB0aHJlYWQuCisgICAgICAgIFt1 aVdlYlZpZXcgc3RyaW5nQnlFdmFsdWF0aW5nSmF2YVNjcmlwdEZyb21TdHJpbmc6QCJydW5UZXN0 QXN5bmMoKTsiXTsKKyAgICAgICAgRVhQRUNUX0ZBTFNFKGRpZEZpbmlzaFRlc3QpOworICAgIH0K KworICAgIFV0aWw6OnJ1bigmZGlkRmluaXNoVGVzdCk7Cit9CisKK30KKworI2VuZGlmCg== 410207 2020-10-01 01:27:03 -0700 2020-10-02 00:05:47 -0700 Patch bug-216106-20201001112700.patch text/plain 103101 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjY3NzgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggYjE3OWJjZmNkNmQ5MGVmOGFjNjYxMGI2ZDhiMTdkNmQ0MjAzNjFiYy4uMzNiMzVjMjEzZDll NjJmNmVjMmUxZGVlYjU5OTMwNzZiNjA4NTUwMiAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDYwIEBACisyMDIwLTA5LTI5ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPUyBXSzFdIENyYXNoZXMgd2hlbiB1c2luZyBBTkdM RSBXZWJHTCBmcm9tIGFub3RoZXIgdGhyZWFkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMTYxMDYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY4NjAy NDUyPgorCisgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUnVzc2VsbC4KKworICAgICAgICBB ZGQgdHdvIGV4dGVuc2lvbnMgZm9yIEVBR0wgYW5kIENHTCBiYWNrZW5kcyB0byBkZWNsYXJlIHRo ZQorICAgICAgICB1bmRlcmx5aW5nIHBsYXRmb3JtIGNvbnRleHQgYmVpbmcgInZvbGF0aWxlIi4g SXQgbWVhbnMgdGhhdAorICAgICAgICB0aGUgdGhyZWFkLWdsb2JhbCBjdXJyZW50IGNvbnRleHQg aXMgYmVpbmcgbW9kaWZpZWQgYmVoaW5kCisgICAgICAgIEFOR0xFLiBJZiBBTkdMRSBjb250ZXh0 IGlzIG1hcmtlZCB2b2xhdGlsZSBmb3IgYSBwYXJ0aWN1bGFyCisgICAgICAgIEFQSSwgaXQgd2ls bCBzeW5jIHRoZSB1bmRlcmx5aW5nIGNvbnRleHQgZm9yIGV2ZXJ5IEVHTAorICAgICAgICBmdW5j dGlvbiB0aGF0IG5lZWRzIHRoZSBjb250ZXh0LiBNb3N0IGludHVpdGl2ZSB1c2UgaXMKKyAgICAg ICAgZm9yIHRoZSBjbGllbnQgdG8gY2FsbCBlZ2xNYWtlQ3VycmVudCBiZWZvcmUgY2FsbGluZyBh bnkKKyAgICAgICAgZ2wgZnVuY3Rpb24gaWYgdGhlIGNsaWVudCBrbm93bnMgdGhlIHBsYXRmb3Jt IHN0YXRlIG1pZ2h0CisgICAgICAgIGJlIGRpcnR5LgorCisgICAgICAgIEltcGxlbWVudCBlZ2xS ZWxlYXNlVGhyZWFkIGZvciBFQUdMIGFuZCBDR0wgYmFja2VuZHMuCisgICAgICAgIFJlbGVhc2lu ZyB0aHJlYWQgd2lsbCB1bnNldCB0aGUgcGxhdGZvcm0gY3VycmVudCBjb250ZXh0LgorCisgICAg ICAgIEZpeCBhIGJ1ZyBvZiBvbWl0dGluZyBFR0xfQU5HTEVfZGV2aWNlX2VhZ2wgZnJvbSBiZWlu ZworICAgICAgICBhZHZlcnRpc2VkLgorCisgICAgICAgICogZXh0ZW5zaW9ucy9FR0xfQU5HTEVf cGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfY2dsLnR4dDogQWRkZWQuCisg ICAgICAgICogZXh0ZW5zaW9ucy9FR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRl eHRfdm9sYXRpbGVfZWFnbC50eHQ6IEFkZGVkLgorICAgICAgICAqIGluY2x1ZGUvRUdML2VnbGV4 dF9hbmdsZS5oOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9DYXBzLmNwcDoKKyAgICAgICAgKGVn bDo6RGV2aWNlRXh0ZW5zaW9uczo6Z2V0U3RyaW5ncyBjb25zdCk6CisgICAgICAgIChlZ2w6OkNs aWVudEV4dGVuc2lvbnM6OmdldFN0cmluZ3MgY29uc3QpOgorICAgICAgICAqIHNyYy9saWJBTkdM RS9DYXBzLmg6CisgICAgICAgICogc3JjL2xpYkFOR0xFL0Rpc3BsYXkuY3BwOgorICAgICAgICAo ZWdsOjpEaXNwbGF5OjpwcmVwYXJlRm9yQ2FsbCk6CisgICAgICAgIChlZ2w6OkRpc3BsYXk6OnJl bGVhc2VUaHJlYWQpOgorICAgICAgICAoZWdsOjpHZW5lcmF0ZUNsaWVudEV4dGVuc2lvbnMpOgor ICAgICAgICAqIHNyYy9saWJBTkdMRS9EaXNwbGF5Lmg6CisgICAgICAgICogc3JjL2xpYkFOR0xF L3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmNwcDoKKyAgICAgICAgKHJ4OjpEaXNwbGF5SW1wbDo6cHJl cGFyZUZvckNhbGwpOgorICAgICAgICAocng6OkRpc3BsYXlJbXBsOjpyZWxlYXNlVGhyZWFkKToK KyAgICAgICAgKiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvRGlzcGxheUltcGwuaDoKKyAgICAgICAg KiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wuaDoKKyAgICAgICAgKiBz cmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wubW06CisgICAgICAgIChyeDo6 RGlzcGxheUNHTDo6aW5pdGlhbGl6ZSk6CisgICAgICAgIChyeDo6RGlzcGxheUNHTDo6dGVybWlu YXRlKToKKyAgICAgICAgKHJ4OjpEaXNwbGF5Q0dMOjpwcmVwYXJlRm9yQ2FsbCk6CisgICAgICAg IChyeDo6RGlzcGxheUNHTDo6cmVsZWFzZVRocmVhZCk6CisgICAgICAgIChyeDo6RGlzcGxheUNH TDo6bWFrZUN1cnJlbnQpOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lYWds L0Rpc3BsYXlFQUdMLmg6CisgICAgICAgICogc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2VhZ2wv RGlzcGxheUVBR0wubW06CisgICAgICAgIChyeDo6RGlzcGxheUVBR0w6OmluaXRpYWxpemUpOgor ICAgICAgICAocng6OkRpc3BsYXlFQUdMOjp0ZXJtaW5hdGUpOgorICAgICAgICAocng6OkRpc3Bs YXlFQUdMOjpwcmVwYXJlRm9yQ2FsbCk6CisgICAgICAgIChyeDo6RGlzcGxheUVBR0w6OnJlbGVh c2VUaHJlYWQpOgorICAgICAgICAqIHNyYy9saWJBTkdMRS92YWxpZGF0aW9uRUdMLmNwcDoKKyAg ICAgICAgKiBzcmMvbGliR0xFU3YyL2VudHJ5X3BvaW50c19lZ2wuY3BwOgorICAgICAgICAqIHNy Yy9saWJHTEVTdjIvZW50cnlfcG9pbnRzX2VnbF9leHQuY3BwOgorCiAyMDIwLTA5LTI5ICBKYW1l cyBEYXJwaW5pYW4gIDxqZGFycGluaWFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBGaXggRVhU X2NvbG9yX2J1ZmZlcl9oYWxmX2Zsb2F0IG9uIGlPUwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGVjNjUwYWRhMDVk MGQxZjY1OWIyMmIwM2M0Yzk3MjVlOGQ4OGQ2ZGMuLjNjMjA4ZGE1MGM4ZDUxODAwMGU5N2VmZjVm N2Q2MmU4MzFiMTVmZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw3NSBAQAorMjAyMC0wOS0yOSAg S2ltbW8gS2lubnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgorCisgICAgICAgIFtpT1MgV0sx XSBDcmFzaGVzIHdoZW4gdXNpbmcgQU5HTEUgV2ViR0wgZnJvbSBhbm90aGVyIHRocmVhZAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE2MTA2CisgICAg ICAgIDxyZGFyOi8vcHJvYmxlbS82ODYwMjQ1Mj4KKworICAgICAgICBSZXZpZXdlZCBieSBLZW5u ZXRoIFJ1c3NlbGwuCisKKyAgICAgICAgU291cmNlIG9mIHRoZSBidWcgY29tZXMgZnJvbSBmb2xs b3dpbmc6CisgICAgICAgICAgLSBXSzEgbWlnaHQgcnVuIFdlYktpdCBjb2RlIGluIGNsaWVudCBt YWluIHRocmVhZC4KKyAgICAgICAgICAtIFdLMSBtaWdodCBydW4gV2Via2l0IGNvZGUgaW4gd2Vi IHRocmVhZC4KKyAgICAgICAgICAtIFdlYktpdCBjb2RlIG1pZ2h0IHJ1biBXZWJHTCBwYXlsb2Fk LCBub3RhYmx5IGFjY2VzcworICAgICAgICAgICAgR3JhcGhpY3NDb250ZXh0R0wgY2xhc3Nlcy4K KyAgICAgICAgICAgIENsaWVudCBpcyBhYmxlIHRvIG1vZGlmeSBFQUdML0NHTCBjdXJyZW50IGNv bnRleHQuCisKKyAgICAgICAgVGhlIGNoYW5nZSB0byBBTkdMRSBpbmN1cnJlZCB0d28gZGlzdGlu Y3QgYmVoYXZpb3IgY2hhbmdlcworICAgICAgICBjb21wYXJlZCB0byByYXcgRUFHTCAvIENHTDoK KyAgICAgICAgMSkgQmVmb3JlOiBjb250ZXh0IHdhcyBzZXQgY3VycmVudCBiZWZvcmUgYW55IEdM IGNhbGwKKyAgICAgICAgQWZ0ZXI6IGNvbnRleHQgd2FzIHNldCBjdXJyZW50IG9ubHkgaWYgRUdM IGN1cnJlbnQgY29udGV4dAorICAgICAgICBoYWQgYmVlbiBjaGFuZ2VkLiAoRXhwbGljaXQgY29k ZSBhcyB3ZWxsIGFzIEFOR0xFIGltcGxlbWVudGF0aW9uCisgICAgICAgIG9wdGltaXphdGlvbi4p CisKKyAgICAgICAgMikgQmVmb3JlOiBjb250ZXh0IGJlaW5nIHVzZWQgd2FzIGFibGUgdG8gYmUg Y3VycmVudCBpbgorICAgICAgICBtdWx0aXBsZSB0aHJlYWRzIGF0IHRoZSBzYW1lIHRpbWUuIChF QUdML0NHTCBmZWF0dXJlKQorICAgICAgICBBZnRlcjogY29udGV4dCBjYW5ub3QgYmUgY3VycmVu dCBpbiBtdWx0aXBsZSB0aHJlYWRzCisgICAgICAgIGF0IHRoZSBzYW1lIHRpbWUuIChFR0wgZmVh dHVyZSkKKworICAgICAgICBDaGFuZ2UgaW4gYmVoYXZpb3IgMSkgY2F1c2VkIEFOR0xFIHRvIHNv bWV0aW1lcyB1c2UKKyAgICAgICAgdGhlIEVBR0wvQ0dMIGNvbnRleHQgb2YgdGhlIGNsaWVudCBp bnN0ZWFkIG9mCisgICAgICAgIHRoZSByZWFsIGNvbnRleHQgdGhhdCBBTkdMRSBjcmVhdGVkLgor ICAgICAgICBGaXggdGhpcyBieSBpbnRyb2R1Y2luZworICAgICAgICBFR0xfQU5HTEVfcGxhdGZv cm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbAorICAgICAgICBhbmQKKyAgICAg ICAgRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2NnbAor ICAgICAgICB3aGljaCBtYWtlIEFOR0xFIHN5bmMgdGhlIGNvbnRleHQgb24gZWFjaCBlZ2xNYWtl Q3VycmVudAorICAgICAgICBlZ2xSZWxlYXNlVGhyZWFkIGFuZCBlZ2xUZXJtaW5hdGUuCisKKyAg ICAgICAgQ2hhbmdlIGluIGJlaGF2aW9yIDIpIGNhdXNlZCBBTkdMRSB0byB1c2UgdW5pbml0aWFs aXplZAorICAgICAgICBjb250ZXh0IG9iamVjdCBmcm9tIG9uZSB0aHJlYWQsIGlmIHRoZSByZWFs IGNvbnRleHQgb2JqZWN0CisgICAgICAgIHdhcyBjdXJyZW50IGluIGFub3RoZXIgdGhyZWFkLgor ICAgICAgICBGaXggdGhpcyBieSBjb25zaWRlcmluZyAiR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wg Y3VycmVudCBjb250ZXh0IgorICAgICAgICBhcyBwYXJ0IG9mICJkYXRhIHRoYXQgaXMgb3duZWQg YnkgV2ViQ29yZVRocmVhZCBsb2NrIi4KKyAgICAgICAgVGhlIGN1cnJlbnQgY29udGV4dCBpcyBz ZXQgd2l0aCBsb2NrIGhlbGQsIGltcGxpY2l0bHkuCisgICAgICAgIFRoZSBjdXJyZW50IGNvbnRl eHQgaXMgcmVsZWFzZWQgd2hlbiBsb2NrIGlzIHJlbGVhc2VkLgorICAgICAgICBXaGVuIHRoZSBs b2NrIGlzIG5vdCBoZWxkLCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTCBjdXJyZW50IGNvbnRleHQK KyAgICAgICAgaXMgbnVsbHB0ci4KKworICAgICAgICBBZGRzIHNvZnQgbGlua2luZyBmb3IgRUFH TCBmb3IgdGhlIHB1cnBvc2Ugb2YgdGVzdGluZyB0aGlzIGluCisgICAgICAgIFRlc3RXZWJLaXRB UEkuIFRoZSBjYXNlIG9mIEFwcGxlIFNpbGljb24gTWFjIG1heSBzb21ldGltZXMKKyAgICAgICAg dXNlIENHTCBhbmQgc29tZXRpbWVzIEVBR0wsIGFuZCB0aGUgdGVzdCBzaG91bGQgdGVzdCB0aGF0 CisgICAgICAgIGNsaWVudCBvdmVycmlkaW5nIGJvdGggY29udGV4dHMgd2lsbCBub3QgY2F1c2Ug cHJvYmxlbXMuCisKKyAgICAgICAgRml4IEFOR0xFIGhlYWRlciBpbmNsdWRlIHBhdGg6CisgICAg ICAgICAtIERvIG5vdCBpbmNsdWRlIEFOR0xFIGluIHRoZSBwYXRoLCBhcyBmaWxlcyBhcmUgaW5j bHVkZWQgd2l0aCBBTkdMRS8KKyAgICAgICAgIC0gQWRkIFdLX0FMVEVSTkFURV9GUkFNRVdPUktT X0RJUiBzbyB0aGF0IFNES19WQVJJQU5UPWlvc21hYworICAgICAgICAgICBlLmcuIG1hY2NhdGFs eXN0IGJ1aWxkcyB3b3JrCisgICAgICAgIFByZXZpb3VzbHkgdGhlIEFOR0xFIHdhcyBub3QgaW5j bHVkZWQgZnJvbSBUaGlyZFBhcnR5L0FOR0xFLCByYXRoZXIKKyAgICAgICAgIldlYktpdCBTREsi LgorCisgICAgICAgICogQ29uZmlndXJhdGlvbnMvV2ViQ29yZS54Y2NvbmZpZzoKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRHTE9wZW5HTENvY29hLm1t OgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6OkdyYXBoaWNzQ29u dGV4dEdMT3BlbkdMKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdM Ojp+R3JhcGhpY3NDb250ZXh0R0xPcGVuR0wpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3ND b250ZXh0R0xPcGVuR0w6Om1ha2VDb250ZXh0Q3VycmVudCk6CisgICAgICAgIChXZWJDb3JlOjpH cmFwaGljc0NvbnRleHRHTE9wZW5HTDo6cmVsZWFzZUN1cnJlbnRDb250ZXh0KToKKyAgICAgICAg KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpjaGVja0dQVVN0YXR1cyk6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6YWxsb3dPZmZsaW5lUmVuZGVy ZXJzIGNvbnN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3ND b250ZXh0R0xPcGVuR0wuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9pb3Mvd2FrL1dlYkNvcmVUaHJl YWQubW06CisgICAgICAgIChXZWJUaHJlYWRVbmxvY2tGcm9tQW55VGhyZWFkKToKKyAgICAgICAg KF9XZWJUaHJlYWRVbmxvY2spOgorCiAyMDIwLTA5LTI5ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5m cmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFtMRkMgRGlzcGxheV0gQmFzaWMgdGV4dCBkaXNw bGF5CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9leHRlbnNpb25zL0VHTF9B TkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wudHh0IGIvU291 cmNlL1RoaXJkUGFydHkvQU5HTEUvZXh0ZW5zaW9ucy9FR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVf ZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfY2dsLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41ZTM1MDZiMWVmNzFi MjYwMjhmZDI4OThlYTViNmJmOWEyZTI5ZTA2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvZXh0ZW5zaW9ucy9FR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNl X2NvbnRleHRfdm9sYXRpbGVfY2dsLnR4dApAQCAtMCwwICsxLDkwIEBACitOYW1lCisKKyAgICBB TkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wKKworTmFtZSBT dHJpbmdzCisKKyAgICBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9s YXRpbGVfY2dsCisKK0NvbnRyaWJ1dG9ycworICAgIEtpbW1vIEtpbm51bmVuLCBBcHBsZQorICAg IEtlbm5ldGggUnVzc2VsbCwgR29vZ2xlCisKK0NvbnRhY3RzCisgICAgS2ltbW8gS2lubnVuZW4s IEFwcGxlIChra2lubnVuZW4gJ2F0JyBhcHBsZSAnZG90JyBvcmcpCisgICAgS2VubmV0aCBSdXNz ZWxsLCBHb29nbGUgKGticiAnYXQnIGNocm9taXVtICdkb3QnIG9yZykKKworU3RhdHVzCisKKyAg ICBEcmFmdAorCitWZXJzaW9uCisKKyAgICBWZXJzaW9uIDEsIDIwMjAtMDktMzAKKworTnVtYmVy CisKKyAgICBFR0wgRXh0ZW5zaW9uIFhYWAorCitFeHRlbnNpb24gVHlwZQorCisgICAgRUdMIGNs aWVudCBleHRlbnNpb24KKworRGVwZW5kZW5jaWVzCisKKyAgICBSZXF1aXJlcyBBTkdMRV9wbGF0 Zm9ybV9hbmdsZS4KKworT3ZlcnZpZXcKKworICAgIFRoaXMgZXh0ZW5zaW9uIGFsbG93cyB0aGUg Y2xpZW50IHRvIHJlcXVlc3QgYSBEaXNwbGF5IHRoYXQgaW50ZXJuYWxseQorICAgIGlzIGFibGUg dG8gZnVuY3Rpb24gZXZlbiBpZiBjbGllbnQgY2hhbmdlcyBjdXJyZW50IENHTCBjb250ZXh0IG9m IHRoZQorICAgIHRocmVhZC4gUmVxdWVzdGluZyBhIHZvbGF0aWxlIGRldmljZSBjb250ZXh0IGNv bnRleHRzIG1heSBpbXBhY3QgcGVyZm9ybWFuY2UuCisgICAgVGhlIGV4dGVuc2lvbiBpcyB1c2Vm dWwgZm9yIHVzaW5nIEVHTCBpbiBhIGxpYnJhcnkgdGhhdCBjYW5ub3QgZ3VhcmFudGVlCisgICAg d2hpY2ggcGxhdGZvcm0gQVBJcyBpdHMgY2xpZW50cyB3aWxsIHVzZS4KKworTmV3IFR5cGVzCisK KyAgICBOb25lCisKK05ldyBQcm9jZWR1cmVzIGFuZCBGdW5jdGlvbnMKKworICAgIE5vbmUKKwor TmV3IFRva2VucworCisgICAgQWNjZXB0ZWQgYXMgYW4gYXR0cmlidXRlIG5hbWUgaW4gdGhlIDxh dHRyaWJfbGlzdD4gYXJndW1lbnQgb2YKKyAgICBlZ2xHZXRQbGF0Zm9ybURpc3BsYXlFWFQ6CisK KyAgICAgICAgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0NHTF9B TkdMRSAgICAweDM0QTMKKworQWRkaXRpb25zIHRvIHRoZSBFR0wgU3BlY2lmaWNhdGlvbgorCisg ICAgTm9uZS4KKworTmV3IEJlaGF2aW9yCisKKyAgICBUbyByZXF1ZXN0IGEgZGlzcGxheSB0aGF0 IGludGVybmFsbHkgc3VwcG9ydHMgdGhlIGZlYXR1cmUsCisgICAgdXNlIHRoZSBhdHRyaWJ1dGUg RUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0NHTF9BTkdMRS4KKyAg ICBFR0xfVFJVRSBlbmFibGVzIHZvbGF0aWxlIENHTCBkZXZpY2UgY29udGV4dCBhbmQgRUdMX0ZB TFNFIGRpc2FibGVzIGl0LgorICAgIEFueSB2YWx1ZSBvdGhlciB0aGFuIHRoZXNlIHdpbGwgcmVz dWx0IGluIGFuIGVycm9yLgorICAgIFRoZSBkZWZhdWx0IHZhbHVlIGZvciBFR0xfUExBVEZPUk1f QU5HTEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfQ0dMX0FOR0xFCisgICAgaXMgRUdMX0ZBTFNF LgorCisgICAgV2hlbiB0aGUgZGV2aWNlIGNvbnRleHQgb2YgdGhlIGRpc3BsYXkgaXMgc2V0IGFz IHZvbGF0aWxlIENHTCwgdGhlbgorICAgIGVhY2ggRUdMIGZ1bmN0aW9uIHdpbGwgY2hhbmdlIHRo ZSBjdXJyZW50IENHTCBjb250ZXh0IHN0YXRlIGFjY29yZGluZ2x5CisgICAgdG8gdXNlIHRoZSBp bnRlcm5hbCBkZXZpY2UgY29udGV4dCwgaWYgbmVlZGVkLiBJZiB0aGUgaW50ZXJuYWwgZGV2aWNl IGNvbnRleHQKKyAgICBpcyBub3QgdXNpbmcgQ0dMLCB0aGUgcHJvcGVydHkgaGFzIG5vIGVmZmVj dC4KKworICAgIENhbGxzIHRvIE9wZW5HTCBvciBPcGVuR0wgRVMgZnVuY3Rpb25zIHdpbGwgbm90 IGVuc3VyZSB0aGUgdW5kZXJseWluZyBkZXZpY2UKKyAgICBjb250ZXh0IGlzIGNvcnJlY3QuIElm IHRoZSBzdGF0ZSBvZiB0aGUgY3VycmVudCBDR0wgY29udGV4dCBpcyB1bmtub3duLAorICAgIGNs aWVudHMgc2hvdWxkIGNhbGwgTWFrZUN1cnJlbnQgdG8gZW5zdXJlIHRoYXQgdGhlIGludGVybmFs IGRldmljZQorICAgIGNvbnRleHQgaXMgbWFkZSBjdXJyZW50LgorCitJc3N1ZXMKKworICAgIE5v bmUKKworUmV2aXNpb24gSGlzdG9yeQorCisgICAgVmVyc2lvbiAxLCAyMDIwLTA5LTMwIChLaW1t byBLaW5udW5lbikKKyAgICAgIC0gSW5pdGlhbCBkcmFmdApkaWZmIC0tZ2l0IGEvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvZXh0ZW5zaW9ucy9FR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNl X2NvbnRleHRfdm9sYXRpbGVfZWFnbC50eHQgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9leHRl bnNpb25zL0VHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9l YWdsLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4zZTQ5ZTFhNTBlODMwYjdmNDNhMzk5YjE5ZGZiMjc4ZWFiODg0 MmI2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvZXh0ZW5zaW9u cy9FR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbC50 eHQKQEAgLTAsMCArMSw5MCBAQAorTmFtZQorCisgICAgQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2 aWNlX2NvbnRleHRfdm9sYXRpbGVfZWFnbAorCitOYW1lIFN0cmluZ3MKKworICAgIEVHTF9BTkdM RV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsCisKK0NvbnRyaWJ1 dG9ycworICAgIEtpbW1vIEtpbm51bmVuLCBBcHBsZQorICAgIEtlbm5ldGggUnVzc2VsbCwgR29v Z2xlCisKK0NvbnRhY3RzCisgICAgS2ltbW8gS2lubnVuZW4sIEFwcGxlIChra2lubnVuZW4gJ2F0 JyBhcHBsZSAnZG90JyBvcmcpCisgICAgS2VubmV0aCBSdXNzZWxsLCBHb29nbGUgKGticiAnYXQn IGNocm9taXVtICdkb3QnIG9yZykKKworU3RhdHVzCisKKyAgICBEcmFmdAorCitWZXJzaW9uCisK KyAgICBWZXJzaW9uIDEsIDIwMjAtMDktMzAKKworTnVtYmVyCisKKyAgICBFR0wgRXh0ZW5zaW9u IFhYWAorCitFeHRlbnNpb24gVHlwZQorCisgICAgRUdMIGNsaWVudCBleHRlbnNpb24KKworRGVw ZW5kZW5jaWVzCisKKyAgICBSZXF1aXJlcyBBTkdMRV9wbGF0Zm9ybV9hbmdsZS4KKworT3ZlcnZp ZXcKKworICAgIFRoaXMgZXh0ZW5zaW9uIGFsbG93cyB0aGUgY2xpZW50IHRvIHJlcXVlc3QgYSBE aXNwbGF5IHRoYXQgaW50ZXJuYWxseQorICAgIGlzIGFibGUgdG8gZnVuY3Rpb24gZXZlbiBpZiBj bGllbnQgY2hhbmdlcyBjdXJyZW50IEVBR0wgY29udGV4dCBvZiB0aGUKKyAgICB0aHJlYWQuIFJl cXVlc3RpbmcgYSB2b2xhdGlsZSBkZXZpY2UgY29udGV4dCBjb250ZXh0cyBtYXkgaW1wYWN0IHBl cmZvcm1hbmNlLgorICAgIFRoZSBleHRlbnNpb24gaXMgdXNlZnVsIGZvciB1c2luZyBFR0wgaW4g YSBsaWJyYXJ5IHRoYXQgY2Fubm90IGd1YXJhbnRlZQorICAgIHdoaWNoIHBsYXRmb3JtIEFQSXMg aXRzIGNsaWVudHMgd2lsbCB1c2UuCisKK05ldyBUeXBlcworCisgICAgTm9uZQorCitOZXcgUHJv Y2VkdXJlcyBhbmQgRnVuY3Rpb25zCisKKyAgICBOb25lCisKK05ldyBUb2tlbnMKKworICAgIEFj Y2VwdGVkIGFzIGFuIGF0dHJpYnV0ZSBuYW1lIGluIHRoZSA8YXR0cmliX2xpc3Q+IGFyZ3VtZW50 IG9mCisgICAgZWdsR2V0UGxhdGZvcm1EaXNwbGF5RVhUOgorCisgICAgICAgIEVHTF9QTEFURk9S TV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElMRV9FQUdMX0FOR0xFICAgIDB4MzRBMgorCitB ZGRpdGlvbnMgdG8gdGhlIEVHTCBTcGVjaWZpY2F0aW9uCisKKyAgICBOb25lLgorCitOZXcgQmVo YXZpb3IKKworICAgIFRvIHJlcXVlc3QgYSBkaXNwbGF5IHRoYXQgaW50ZXJuYWxseSBzdXBwb3J0 cyB0aGUgZmVhdHVyZSwKKyAgICB1c2UgdGhlIGF0dHJpYnV0ZSBFR0xfUExBVEZPUk1fQU5HTEVf REVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfRUFHTF9BTkdMRS4KKyAgICBFR0xfVFJVRSBlbmFibGVz IHZvbGF0aWxlIEVBR0wgZGV2aWNlIGNvbnRleHQgYW5kIEVHTF9GQUxTRSBkaXNhYmxlcyBpdC4K KyAgICBBbnkgdmFsdWUgb3RoZXIgdGhhbiB0aGVzZSB3aWxsIHJlc3VsdCBpbiBhbiBlcnJvci4K KyAgICBUaGUgZGVmYXVsdCB2YWx1ZSBmb3IgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05U RVhUX1ZPTEFUSUxFX0VBR0xfQU5HTEUKKyAgICBpcyBFR0xfRkFMU0UuCisKKyAgICBXaGVuIHRo ZSBkZXZpY2UgY29udGV4dCBvZiB0aGUgZGlzcGxheSBpcyBzZXQgYXMgdm9sYXRpbGUgRUFHTCwg dGhlbgorICAgIGVhY2ggRUdMIGZ1bmN0aW9uIHdpbGwgY2hhbmdlIHRoZSBjdXJyZW50IEVBR0wg Y29udGV4dCBzdGF0ZSBhY2NvcmRpbmdseQorICAgIHRvIHVzZSB0aGUgaW50ZXJuYWwgZGV2aWNl IGNvbnRleHQsIGlmIG5lZWRlZC4gSWYgdGhlIGludGVybmFsIGRldmljZSBjb250ZXh0CisgICAg aXMgbm90IHVzaW5nIEVBR0wsIHRoZSBwcm9wZXJ0eSBoYXMgbm8gZWZmZWN0LgorCisgICAgQ2Fs bHMgdG8gT3BlbkdMIG9yIE9wZW5HTCBFUyBmdW5jdGlvbnMgd2lsbCBub3QgZW5zdXJlIHRoZSB1 bmRlcmx5aW5nIGRldmljZQorICAgIGNvbnRleHQgaXMgY29ycmVjdC4gSWYgdGhlIHN0YXRlIG9m IHRoZSBjdXJyZW50IEVBR0wgY29udGV4dCBpcyB1bmtub3duLAorICAgIGNsaWVudHMgc2hvdWxk IGNhbGwgTWFrZUN1cnJlbnQgdG8gZW5zdXJlIHRoYXQgdGhlIGludGVybmFsIGRldmljZQorICAg IGNvbnRleHQgaXMgbWFkZSBjdXJyZW50LgorCitJc3N1ZXMKKworICAgIE5vbmUKKworUmV2aXNp b24gSGlzdG9yeQorCisgICAgVmVyc2lvbiAxLCAyMDIwLTA5LTMwIChLaW1tbyBLaW5udW5lbikK KyAgICAgIC0gSW5pdGlhbCBkcmFmdApkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5H TEUvaW5jbHVkZS9FR0wvZWdsZXh0X2FuZ2xlLmggYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9p bmNsdWRlL0VHTC9lZ2xleHRfYW5nbGUuaAppbmRleCA0NzAyZDk1YTRjMzI3NmM4YWVlNDQwODc5 ZTY3YmZjNmFlZTQ2Y2U0Li43ZGM2OWM1YTVmZmRjYWIxZGZiNzUyOTBkYzA5OTcxMTkwNjg3MjE1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9pbmNsdWRlL0VHTC9lZ2xleHRf YW5nbGUuaAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9pbmNsdWRlL0VHTC9lZ2xleHRf YW5nbGUuaApAQCAtMTE2LDYgKzExNiwxNiBAQAogI2RlZmluZSBFR0xfUExBVEZPUk1fQU5HTEVf Q09OVEVYVF9WSVJUVUFMSVpBVElPTl9BTkdMRSAweDM0ODEKICNlbmRpZiAvKiBFR0xfQU5HTEVf cGxhdGZvcm1fYW5nbGVfY29udGV4dF92aXJ0dWFsaXphdGlvbiAqLwogCisjaWZuZGVmIEVHTF9B TkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsCisjZGVmaW5l IEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsIDEK KyNkZWZpbmUgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0VBR0xf QU5HTEUgMHgzNEEyCisjZW5kaWYgLyogRUdMX0FOR0xFX3BsYXRmb3JtX2FuZ2xlX2RldmljZV9j b250ZXh0X3ZvbGF0aWxlX2VhZ2wgKi8KKworI2lmbmRlZiBFR0xfQU5HTEVfcGxhdGZvcm1fYW5n bGVfZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfY2dsCisjZGVmaW5lIEVHTF9BTkdMRV9wbGF0Zm9y bV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wgMQorI2RlZmluZSBFR0xfUExBVEZP Uk1fQU5HTEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfQ0dMX0FOR0xFIDB4MzRBMworI2VuZGlm IC8qIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wg Ki8KKwogI2lmbmRlZiBFR0xfQU5HTEVfeDExX3Zpc3VhbAogI2RlZmluZSBFR0xfQU5HTEVfeDEx X3Zpc3VhbAogI2RlZmluZSBFR0xfWDExX1ZJU1VBTF9JRF9BTkdMRSAweDMzQTMKZGlmZiAtLWdp dCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9DYXBzLmNwcCBiL1NvdXJj ZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9DYXBzLmNwcAppbmRleCBhNjMyYjBjMTQz ZDEzNThhNGU1MWQ2OTI1MWExM2U2YmQzODgwZTU2Li5hMDFiZWMzYTE3OTg2ZmM3Y2MxZTJjNjc2 MzJmYTQ3MmZkNzdlNzk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMv bGliQU5HTEUvQ2Fwcy5jcHAKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFO R0xFL0NhcHMuY3BwCkBAIC0xNDE4LDYgKzE0MTgsOCBAQCBzdGQ6OnZlY3RvcjxzdGQ6OnN0cmlu Zz4gRGV2aWNlRXh0ZW5zaW9uczo6Z2V0U3RyaW5ncygpIGNvbnN0CiAgICAgLy8gICAgICAgICAg ICAgICAgICAgfCBFeHRlbnNpb24gbmFtZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgU3VwcG9ydGVkIGZsYWcgICAgICAgICAgICAgICAgfCBPdXRwdXQgdmVjdG9yICAgfAogICAg IEluc2VydEV4dGVuc2lvblN0cmluZygiRUdMX0FOR0xFX2RldmljZV9kM2QiLCAgICAgICAgICAg ICAgICAgICAgICAgICAgZGV2aWNlRDNELCAgICAgICAgICAgICAgICAgICAgICAmZXh0ZW5zaW9u U3RyaW5ncyk7CiAgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5nKCJFR0xfQU5HTEVfZGV2aWNlX2Nn bCIsICAgICAgICAgICAgICAgICAgICAgICAgICBkZXZpY2VDR0wsICAgICAgICAgICAgICAgICAg ICAgICZleHRlbnNpb25TdHJpbmdzKTsKKyAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9B TkdMRV9kZXZpY2VfZWFnbCIsICAgICAgICAgICAgICAgICAgICAgICAgIGRldmljZUVBR0wsICAg ICAgICAgICAgICAgICAgICAgJmV4dGVuc2lvblN0cmluZ3MpOworCiAgICAgLy8gY2xhbmctZm9y bWF0IG9uCiAKICAgICByZXR1cm4gZXh0ZW5zaW9uU3RyaW5nczsKQEAgLTE0NDUsNiArMTQ0Nyw4 IEBAIHN0ZDo6dmVjdG9yPHN0ZDo6c3RyaW5nPiBDbGllbnRFeHRlbnNpb25zOjpnZXRTdHJpbmdz KCkgY29uc3QKICAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV9wbGF0Zm9ybV9h bmdsZV92dWxrYW4iLCAgICAgICAgICAgICAgICAgIHBsYXRmb3JtQU5HTEVWdWxrYW4sICAgICAg ICAgICAgICAgICZleHRlbnNpb25TdHJpbmdzKTsKICAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmco IkVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9tZXRhbCIsICAgICAgICAgICAgICAgICAgIHBsYXRm b3JtQU5HTEVNZXRhbCwgICAgICAgICAgICAgICAgICZleHRlbnNpb25TdHJpbmdzKTsKICAgICBJ bnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9jb250ZXh0X3Zp cnR1YWxpemF0aW9uIiwgIHBsYXRmb3JtQU5HTEVDb250ZXh0VmlydHVhbGl6YXRpb24sICZleHRl bnNpb25TdHJpbmdzKTsKKyAgICBJbnNlcnRFeHRlbnNpb25TdHJpbmcoIkVHTF9BTkdMRV9wbGF0 Zm9ybV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9lYWdsIiwgIHBsYXRmb3JtQU5HTEVEZXZpY2VD b250ZXh0Vm9sYXRpbGVFYWdsLCAmZXh0ZW5zaW9uU3RyaW5ncyk7CisgICAgSW5zZXJ0RXh0ZW5z aW9uU3RyaW5nKCJFR0xfQU5HTEVfcGxhdGZvcm1fZGV2aWNlX2NvbnRleHRfdm9sYXRpbGVfY2ds IiwgICBwbGF0Zm9ybUFOR0xFRGV2aWNlQ29udGV4dFZvbGF0aWxlQ2dsLCAmZXh0ZW5zaW9uU3Ry aW5ncyk7CiAgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5nKCJFR0xfQU5HTEVfZGV2aWNlX2NyZWF0 aW9uIiwgICAgICAgICAgICAgICAgICAgICAgICBkZXZpY2VDcmVhdGlvbiwgICAgICAgICAgICAg ICAgICAgICAmZXh0ZW5zaW9uU3RyaW5ncyk7CiAgICAgSW5zZXJ0RXh0ZW5zaW9uU3RyaW5nKCJF R0xfQU5HTEVfZGV2aWNlX2NyZWF0aW9uX2QzZDExIiwgICAgICAgICAgICAgICAgICBkZXZpY2VD cmVhdGlvbkQzRDExLCAgICAgICAgICAgICAgICAmZXh0ZW5zaW9uU3RyaW5ncyk7CiAgICAgSW5z ZXJ0RXh0ZW5zaW9uU3RyaW5nKCJFR0xfQU5HTEVfeDExX3Zpc3VhbCIsICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB4MTFWaXN1YWwsICAgICAgICAgICAgICAgICAgICAgICAgICAmZXh0ZW5z aW9uU3RyaW5ncyk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGli QU5HTEUvQ2Fwcy5oIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL0NhcHMu aAppbmRleCAzNzEzYWJhZDIzY2Y5M2NkNTUwMWQ2YWNkOWJjMjI3MzMxMzUxMzg2Li4wY2VjNjVm NzE4Y2I5ZjQwY2UzZGIxY2YwNDgzYzgwNWE5ZDY3ZWMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhp cmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvQ2Fwcy5oCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5 L0FOR0xFL3NyYy9saWJBTkdMRS9DYXBzLmgKQEAgLTExNDUsNiArMTE0NSwxMiBAQCBzdHJ1Y3Qg Q2xpZW50RXh0ZW5zaW9ucwogICAgIC8vIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9jb250ZXh0 X3ZpcnR1YWxpemF0aW9uCiAgICAgYm9vbCBwbGF0Zm9ybUFOR0xFQ29udGV4dFZpcnR1YWxpemF0 aW9uID0gZmFsc2U7CiAKKyAgICAvLyBFR0xfQU5HTEVfcGxhdGZvcm1fYW5nbGVfZGV2aWNlX2Nv bnRleHRfdm9sYXRpbGVfZWFnbAorICAgIGJvb2wgcGxhdGZvcm1BTkdMRURldmljZUNvbnRleHRW b2xhdGlsZUVhZ2wgPSBmYWxzZTsKKworICAgIC8vIEVHTF9BTkdMRV9wbGF0Zm9ybV9hbmdsZV9k ZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wKKyAgICBib29sIHBsYXRmb3JtQU5HTEVEZXZpY2VD b250ZXh0Vm9sYXRpbGVDZ2wgPSBmYWxzZTsKKwogICAgIC8vIEVHTF9BTkdMRV9kZXZpY2VfY3Jl YXRpb24KICAgICBib29sIGRldmljZUNyZWF0aW9uID0gZmFsc2U7CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9EaXNwbGF5LmNwcCBiL1NvdXJjZS9U aGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9EaXNwbGF5LmNwcAppbmRleCBjMzE3ZjgyNjYz MWJkMGQ1NzYyM2QyOTY5ZWY5ODRkMGIwMzdmZjg3Li42MWRhNmIzYmNiMGIwYmNiNzYyM2IyOTEz YzRhYjA0NjBiNjQ0N2E1IDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMv bGliQU5HTEUvRGlzcGxheS5jcHAKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xp YkFOR0xFL0Rpc3BsYXkuY3BwCkBAIC05NTUsNiArOTU1LDE2IEBAIEVycm9yIERpc3BsYXk6OnRl cm1pbmF0ZShjb25zdCBUaHJlYWQgKnRocmVhZCkKICAgICByZXR1cm4gTm9FcnJvcigpOwogfQog CitFcnJvciBEaXNwbGF5OjpwcmVwYXJlRm9yQ2FsbCgpCit7CisgICAgcmV0dXJuIG1JbXBsZW1l bnRhdGlvbi0+cHJlcGFyZUZvckNhbGwoKTsKK30KKworRXJyb3IgRGlzcGxheTo6cmVsZWFzZVRo cmVhZCgpCit7CisgICAgcmV0dXJuIG1JbXBsZW1lbnRhdGlvbi0+cmVsZWFzZVRocmVhZCgpOwor fQorCiBzdGQ6OnZlY3Rvcjxjb25zdCBDb25maWcgKj4gRGlzcGxheTo6Z2V0Q29uZmlncyhjb25z dCBlZ2w6OkF0dHJpYnV0ZU1hcCAmYXR0cmlicykgY29uc3QKIHsKICAgICByZXR1cm4gbUNvbmZp Z1NldC5maWx0ZXIoYXR0cmlicyk7CkBAIC0xNTQ0LDYgKzE1NTQsMTQgQEAgc3RhdGljIENsaWVu dEV4dGVuc2lvbnMgR2VuZXJhdGVDbGllbnRFeHRlbnNpb25zKCkKICAgICBleHRlbnNpb25zLnBs YXRmb3JtQU5HTEVEZXZpY2VUeXBlRUdMQU5HTEUgPSB0cnVlOwogI2VuZGlmCiAKKyNpZiAoZGVm aW5lZChBTkdMRV9QTEFURk9STV9JT1MpICYmICFkZWZpbmVkKEFOR0xFX1BMQVRGT1JNX01BQ0NB VEFMWVNUKSkgfHwgKGRlZmluZWQoQU5HTEVfUExBVEZPUk1fTUFDQ0FUQUxZU1QpICYmIGRlZmlu ZWQoQU5HTEVfQ1BVX0FSTTY0KSkKKyAgICBleHRlbnNpb25zLnBsYXRmb3JtQU5HTEVEZXZpY2VD b250ZXh0Vm9sYXRpbGVFYWdsID0gdHJ1ZTsKKyNlbmRpZgorCisjaWYgZGVmaW5lZChBTkdMRV9Q TEFURk9STV9NQUNPUykgfHwgZGVmaW5lZChBTkdMRV9QTEFURk9STV9NQUNDQVRBTFlTVCkKKyAg ICBleHRlbnNpb25zLnBsYXRmb3JtQU5HTEVEZXZpY2VDb250ZXh0Vm9sYXRpbGVDZ2wgPSB0cnVl OworI2VuZGlmCisKICAgICBleHRlbnNpb25zLmNsaWVudEdldEFsbFByb2NBZGRyZXNzZXMgPSB0 cnVlOwogICAgIGV4dGVuc2lvbnMuZGVidWcgICAgICAgICAgICAgICAgICAgICA9IHRydWU7CiAg ICAgZXh0ZW5zaW9ucy5leHBsaWNpdENvbnRleHQgICAgICAgICAgID0gdHJ1ZTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9EaXNwbGF5LmggYi9Tb3Vy Y2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvRGlzcGxheS5oCmluZGV4IDQ5ZGJhOTE2 YTE0YmI4NDRlM2NjOTBlZDY2ZGEzM2JlMTE5ODZkNjQuLjJlMTI0NzM3MmZjNGYyYTkzYTUwYzNl ZTVhZGVhOWMyNTYyOWQ4NDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3Ny Yy9saWJBTkdMRS9EaXNwbGF5LmgKKysrIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xp YkFOR0xFL0Rpc3BsYXkuaApAQCAtMTAyLDYgKzEwMiwxMyBAQCBjbGFzcyBEaXNwbGF5IGZpbmFs IDogcHVibGljIExhYmVsZWRPYmplY3QsCiAKICAgICBFcnJvciBpbml0aWFsaXplKCk7CiAgICAg RXJyb3IgdGVybWluYXRlKGNvbnN0IFRocmVhZCAqdGhyZWFkKTsKKyAgICAvLyBDYWxsZWQgYmVm b3JlIGFsbCBkaXNwbGF5IHN0YXRlIGRlcGVuZGVudCBFR0wgZnVuY3Rpb25zLiBCYWNrZW5kcyBj YW4gc2V0IHVwLCBmb3IgZXhhbXBsZSwKKyAgICAvLyB0aHJlYWQtc3BlY2lmaWMgYmFja2VuZCBz dGF0ZSB0aHJvdWdoIHRoaXMgZnVuY3Rpb24uIE5vdCBjYWxsZWQgZm9yIGZ1bmN0aW9ucyB0aGF0 IGRvIG5vdAorICAgIC8vIG5lZWQgdGhlIHN0YXRlLgorICAgIEVycm9yIHByZXBhcmVGb3JDYWxs KCk7CisgICAgLy8gQ2FsbGVkIG9uIGVnbFJlbGVhc2VUaHJlYWQuIEJhY2tlbmRzIGNhbiB0ZWFy IGRvd24gdGhyZWFkLXNwZWNpZmljIGJhY2tlbmQgc3RhdGUgdGhyb3VnaAorICAgIC8vIHRoaXMg ZnVuY3Rpb24uCisgICAgRXJyb3IgcmVsZWFzZVRocmVhZCgpOwogCiAgICAgc3RhdGljIERpc3Bs YXkgKkdldERpc3BsYXlGcm9tRGV2aWNlKERldmljZSAqZGV2aWNlLCBjb25zdCBBdHRyaWJ1dGVN YXAgJmF0dHJpYk1hcCk7CiAgICAgc3RhdGljIERpc3BsYXkgKkdldERpc3BsYXlGcm9tTmF0aXZl RGlzcGxheShFR0xOYXRpdmVEaXNwbGF5VHlwZSBuYXRpdmVEaXNwbGF5LApkaWZmIC0tZ2l0IGEv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBs LmNwcCBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9EaXNw bGF5SW1wbC5jcHAKaW5kZXggMmY5NjU4MTdkZWFmNGRmZjU3YTRjYmI0ODYzN2Y2MTRiNTUwNjY5 Ny4uZDQxYzI1Nzc2Y2QyMzIxNTA1NzVmM2U1MzI0N2QxOTcxZWFjMWRjNiAxMDA2NDQKLS0tIGEv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBs LmNwcAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIv RGlzcGxheUltcGwuY3BwCkBAIC0yMyw2ICsyMywxNiBAQCBEaXNwbGF5SW1wbDo6fkRpc3BsYXlJ bXBsKCkKICAgICBBU1NFUlQobVN0YXRlLnN1cmZhY2VTZXQuZW1wdHkoKSk7CiB9CiAKK2VnbDo6 RXJyb3IgRGlzcGxheUltcGw6OnByZXBhcmVGb3JDYWxsKCkKK3sKKyAgICByZXR1cm4gZWdsOjpO b0Vycm9yKCk7Cit9CisKK2VnbDo6RXJyb3IgRGlzcGxheUltcGw6OnJlbGVhc2VUaHJlYWQoKQor eworICAgIHJldHVybiBlZ2w6Ok5vRXJyb3IoKTsKK30KKwogY29uc3QgZWdsOjpEaXNwbGF5RXh0 ZW5zaW9ucyAmRGlzcGxheUltcGw6OmdldEV4dGVuc2lvbnMoKSBjb25zdAogewogICAgIGlmICgh bUV4dGVuc2lvbnNJbml0aWFsaXplZCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9EaXNwbGF5SW1wbC5oIGIvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKaW5kZXggNjZlNDdi YzkxM2Y4NzE4NWVkYzI5NTY3ODMyMWY2NWNkYmU2MTE1My4uMjY0NDliODVmYzA2ODVhOGRjYzBj YmQwMGViMjkyZTRhMjFmNzQ2MCAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUv c3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKKysrIGIvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL0Rpc3BsYXlJbXBsLmgKQEAgLTY3LDExICs2 NywxNCBAQCBjbGFzcyBEaXNwbGF5SW1wbCA6IHB1YmxpYyBFR0xJbXBsRmFjdG9yeSwgcHVibGlj IGFuZ2xlOjpTdWJqZWN0CiAKICAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgaW5pdGlhbGl6ZShlZ2w6 OkRpc3BsYXkgKmRpc3BsYXkpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgdGVybWluYXRlKCkgICAg ICAgICAgICAgICAgICAgICAgICAgICAgID0gMDsKKyAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgcHJl cGFyZUZvckNhbGwoKTsKKyAgICB2aXJ0dWFsIGVnbDo6RXJyb3IgcmVsZWFzZVRocmVhZCgpOwog CiAgICAgdmlydHVhbCBlZ2w6OkVycm9yIG1ha2VDdXJyZW50KGVnbDo6U3VyZmFjZSAqZHJhd1N1 cmZhY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVnbDo6U3VyZmFjZSAq cmVhZFN1cmZhY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdsOjpDb250 ZXh0ICpjb250ZXh0KSA9IDA7CiAKKwogICAgIHZpcnR1YWwgZWdsOjpDb25maWdTZXQgZ2VuZXJh dGVDb25maWdzKCkgPSAwOwogCiAgICAgdmlydHVhbCBib29sIHRlc3REZXZpY2VMb3N0KCkgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPSAwOwpkaWZmIC0tZ2l0IGEvU291cmNl L1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2NnbC9EaXNwbGF5Q0dM LmggYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2ds L0Rpc3BsYXlDR0wuaAppbmRleCA4OTVmNzcxMDdiYjA4MzJjOTNhYzJiOGUxZjgyMWVmOWFiNThh NGI1Li5mMDI0YmI4M2YxYTZlMGNjN2Q2ZTQ1ODY0MGFkZTdhODQwMmRmY2UzIDEwMDY0NAotLS0g YS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rp c3BsYXlDR0wuaAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVu ZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wuaApAQCAtMTAsNiArMTAsNyBAQAogI2RlZmluZSBMSUJB TkdMRV9SRU5ERVJFUl9HTF9DR0xfRElTUExBWUNHTF9IXwogCiAjaW5jbHVkZSA8dGhyZWFkPgor I2luY2x1ZGUgPHVub3JkZXJlZF9zZXQ+CiAKICNpbmNsdWRlICJsaWJBTkdMRS9yZW5kZXJlci9n bC9EaXNwbGF5R0wuaCIKIApAQCAtMzIsNiArMzMsOCBAQCBjbGFzcyBEaXNwbGF5Q0dMIDogcHVi bGljIERpc3BsYXlHTAogCiAgICAgZWdsOjpFcnJvciBpbml0aWFsaXplKGVnbDo6RGlzcGxheSAq ZGlzcGxheSkgb3ZlcnJpZGU7CiAgICAgdm9pZCB0ZXJtaW5hdGUoKSBvdmVycmlkZTsKKyAgICBl Z2w6OkVycm9yIHByZXBhcmVGb3JDYWxsKCkgb3ZlcnJpZGU7CisgICAgZWdsOjpFcnJvciByZWxl YXNlVGhyZWFkKCkgb3ZlcnJpZGU7CiAKICAgICBlZ2w6OkVycm9yIG1ha2VDdXJyZW50KGVnbDo6 U3VyZmFjZSAqZHJhd1N1cmZhY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBlZ2w6OlN1 cmZhY2UgKnJlYWRTdXJmYWNlLApAQCAtMTAzLDcgKzEwNiw3IEBAIGNsYXNzIERpc3BsYXlDR0wg OiBwdWJsaWMgRGlzcGxheUdMCiAKICAgICBlZ2w6OkRpc3BsYXkgKm1FR0xEaXNwbGF5OwogICAg IENHTENvbnRleHRPYmogbUNvbnRleHQ7Ci0gICAgc3RkOjp1bm9yZGVyZWRfbWFwPHN0ZDo6dGhy ZWFkOjppZCwgQ0dMQ29udGV4dE9iaj4gbUN1cnJlbnRDb250ZXh0czsKKyAgICBzdGQ6OnVub3Jk ZXJlZF9zZXQ8c3RkOjp0aHJlYWQ6OmlkPiBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dDsKICAg ICBDR0xQaXhlbEZvcm1hdE9iaiBtUGl4ZWxGb3JtYXQ7CiAgICAgYm9vbCBtU3VwcG9ydHNHUFVT d2l0Y2hpbmc7CiAgICAgdWludDY0X3QgbUN1cnJlbnRHUFVJRDsKQEAgLTExMyw2ICsxMTYsNyBA QCBjbGFzcyBEaXNwbGF5Q0dMIDogcHVibGljIERpc3BsYXlHTAogICAgIC8vIGlzIHVucmVmJ2Qg Zm9yIHRoZSBsYXN0IHRpbWUsIHRoaXMgaXMgc2V0IHRvIHRoZSB0aW1lIG9mIHRoYXQgbGFzdCB1 bnJlZi4gSWYgaXQgaXNuJ3QKICAgICAvLyBhY3RpdmF0ZWQgYWdhaW4gaW4gMTAgc2Vjb25kcywg dGhlIGRpc2NyZXRlIEdQVSBwaXhlbCBmb3JtYXQgaXMgZGVsZXRlZC4KICAgICBkb3VibGUgbUxh c3REaXNjcmV0ZUdQVVVucmVmVGltZTsKKyAgICBib29sIG1EZXZpY2VDb250ZXh0SXNWb2xhdGls ZSA9IGZhbHNlOwogfTsKIAogfSAgLy8gbmFtZXNwYWNlIHJ4CmRpZmYgLS1naXQgYS9Tb3VyY2Uv VGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2dsL0Rpc3BsYXlDR0wu bW0gYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvY2ds L0Rpc3BsYXlDR0wubW0KaW5kZXggZTdjYzJiYTJmYTYzYzZhMzM2MWIwNTdmOGRmMTc4Mjg2MTM3 OWRmMS4uMGRiNTFiZjE2OWUwNWZiNmRjOGJhOGMwYWI4M2U2YTJlYjJkY2JkMCAxMDA2NDQKLS0t IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2NnbC9E aXNwbGF5Q0dMLm1tCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9y ZW5kZXJlci9nbC9jZ2wvRGlzcGxheUNHTC5tbQpAQCAtMTg0LDkgKzE4NCwxMSBAQCBlZ2w6OkVy cm9yIERpc3BsYXlDR0w6OmluaXRpYWxpemUoZWdsOjpEaXNwbGF5ICpkaXNwbGF5KQogICAgICAg ICBtQ3VycmVudEdQVUlEID0gYW5nbGU6OkdldEdwdUlERnJvbURpc3BsYXlJRChrQ0dEaXJlY3RN YWluRGlzcGxheSk7CiAgICAgfQogCi0gICAgQ0dMU2V0Q3VycmVudENvbnRleHQobUNvbnRleHQp OwotCi0gICAgbUN1cnJlbnRDb250ZXh0c1tzdGQ6OnRoaXNfdGhyZWFkOjpnZXRfaWQoKV0gPSBt Q29udGV4dDsKKyAgICBpZiAoQ0dMU2V0Q3VycmVudENvbnRleHQobUNvbnRleHQpICE9IGtDR0xO b0Vycm9yKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGVnbDo6RWdsTm90SW5pdGlhbGl6ZWQoKSA8 PCAiQ291bGQgbm90IG1ha2UgdGhlIENHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICB9CisgICAg bVRocmVhZHNXaXRoQ3VycmVudENvbnRleHQuaW5zZXJ0KHN0ZDo6dGhpc190aHJlYWQ6OmdldF9p ZCgpKTsKIAogICAgIC8vIFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZ2V0UHJvY0FkZHJlc3MgaW4g Q0dMIHNvIHdlIG9wZW4gdGhlIGR5bGliIGRpcmVjdGx5CiAgICAgdm9pZCAqaGFuZGxlID0gZGxv cGVuKGtEZWZhdWx0T3BlbkdMRHlsaWJOYW1lLCBSVExEX05PVyk7CkBAIC0yMTAsNiArMjEyLDkg QEAgZWdsOjpFcnJvciBEaXNwbGF5Q0dMOjppbml0aWFsaXplKGVnbDo6RGlzcGxheSAqZGlzcGxh eSkKICAgICAgICAgcmV0dXJuIGVnbDo6RWdsTm90SW5pdGlhbGl6ZWQoKSA8PCAiT3BlbkdMIEVT IDIuMCBpcyBub3Qgc3VwcG9ydGFibGUuIjsKICAgICB9CiAKKyAgICBhdXRvICZhdHRyaWJ1dGVz ID0gZGlzcGxheS0+Z2V0QXR0cmlidXRlTWFwKCk7CisgICAgbURldmljZUNvbnRleHRJc1ZvbGF0 aWxlID0gYXR0cmlidXRlcy5nZXQoRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZP TEFUSUxFX0NHTF9BTkdMRSwgR0xfRkFMU0UpOworCiAgICAgcmV0dXJuIERpc3BsYXlHTDo6aW5p dGlhbGl6ZShkaXNwbGF5KTsKIH0KIApAQCAtMjIzLDEyICsyMjgsMTIgQEAgdm9pZCBEaXNwbGF5 Q0dMOjp0ZXJtaW5hdGUoKQogICAgICAgICBDR0xEZXN0cm95UGl4ZWxGb3JtYXQobVBpeGVsRm9y bWF0KTsKICAgICAgICAgbVBpeGVsRm9ybWF0ID0gbnVsbHB0cjsKICAgICB9Ci0gICAgbUN1cnJl bnRDb250ZXh0cy5jbGVhcigpOwogICAgIGlmIChtQ29udGV4dCAhPSBudWxscHRyKQogICAgIHsK ICAgICAgICAgQ0dMU2V0Q3VycmVudENvbnRleHQobnVsbHB0cik7CiAgICAgICAgIENHTERlc3Ry b3lDb250ZXh0KG1Db250ZXh0KTsKICAgICAgICAgbUNvbnRleHQgPSBudWxscHRyOworICAgICAg ICBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5jbGVhcigpOwogICAgIH0KICAgICBpZiAobURp c2NyZXRlR1BVUGl4ZWxGb3JtYXQgIT0gbnVsbHB0cikKICAgICB7CkBAIC0yMzgsMjMgKzI0Myw0 MSBAQCB2b2lkIERpc3BsYXlDR0w6OnRlcm1pbmF0ZSgpCiAgICAgfQogfQogCi1lZ2w6OkVycm9y IERpc3BsYXlDR0w6Om1ha2VDdXJyZW50KGVnbDo6U3VyZmFjZSAqZHJhd1N1cmZhY2UsCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVnbDo6U3VyZmFjZSAqcmVhZFN1cmZhY2Us Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdsOjpDb250ZXh0ICpjb250ZXh0 KQorZWdsOjpFcnJvciBEaXNwbGF5Q0dMOjpwcmVwYXJlRm9yQ2FsbCgpCiB7Ci0gICAgY2hlY2tE aXNjcmV0ZUdQVVN0YXR1cygpOwotICAgIC8vIElmIHRoZSB0aHJlYWQgdGhhdCdzIGNhbGxpbmcg bWFrZUN1cnJlbnQgZG9lcyBub3QgaGF2ZSB0aGUgY29ycmVjdAotICAgIC8vIGNvbnRleHQgY3Vy cmVudCAoZWl0aGVyIG1Db250ZXh0IG9yIDApLCB3ZSBuZWVkIHRvIHNldCBpdCBjdXJyZW50Lgot ICAgIENHTENvbnRleHRPYmogbmV3Q29udGV4dCA9IDA7Ci0gICAgaWYgKGNvbnRleHQpCisgICAg QVNTRVJUKG1Db250ZXh0KTsKKyAgICBhdXRvIHRocmVhZElkID0gc3RkOjp0aGlzX3RocmVhZDo6 Z2V0X2lkKCk7CisgICAgaWYgKG1EZXZpY2VDb250ZXh0SXNWb2xhdGlsZSB8fCBtVGhyZWFkc1dp dGhDdXJyZW50Q29udGV4dC5maW5kKHRocmVhZElkKSA9PSBtVGhyZWFkc1dpdGhDdXJyZW50Q29u dGV4dC5lbmQoKSkKICAgICB7Ci0gICAgICAgIG5ld0NvbnRleHQgPSBtQ29udGV4dDsKKyAgICAg ICAgaWYgKENHTFNldEN1cnJlbnRDb250ZXh0KG1Db250ZXh0KSAhPSBrQ0dMTm9FcnJvcikKKyAg ICAgICAgeworICAgICAgICAgICAgcmV0dXJuIGVnbDo6RWdsQmFkQWxsb2MoKSA8PCAiQ291bGQg bm90IG1ha2UgZGV2aWNlIENHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICAgICAgfQorICAgICAg ICBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5pbnNlcnQodGhyZWFkSWQpOwogICAgIH0KLSAg ICBpZiAobmV3Q29udGV4dCAhPSBtQ3VycmVudENvbnRleHRzW3N0ZDo6dGhpc190aHJlYWQ6Omdl dF9pZCgpXSkKKyAgICByZXR1cm4gZWdsOjpOb0Vycm9yKCk7Cit9CisKK2VnbDo6RXJyb3IgRGlz cGxheUNHTDo6cmVsZWFzZVRocmVhZCgpCit7CisgICAgQVNTRVJUKG1Db250ZXh0KTsKKyAgICBh dXRvIHRocmVhZElkID0gc3RkOjp0aGlzX3RocmVhZDo6Z2V0X2lkKCk7CisgICAgaWYgKG1UaHJl YWRzV2l0aEN1cnJlbnRDb250ZXh0LmZpbmQodGhyZWFkSWQpICE9IG1UaHJlYWRzV2l0aEN1cnJl bnRDb250ZXh0LmVuZCgpKQogICAgIHsKLSAgICAgICAgQ0dMU2V0Q3VycmVudENvbnRleHQobmV3 Q29udGV4dCk7Ci0gICAgICAgIG1DdXJyZW50Q29udGV4dHNbc3RkOjp0aGlzX3RocmVhZDo6Z2V0 X2lkKCldID0gbmV3Q29udGV4dDsKKyAgICAgICAgaWYgKENHTFNldEN1cnJlbnRDb250ZXh0KG51 bGxwdHIpICE9IGtDR0xOb0Vycm9yKQorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gZWds OjpFZ2xCYWRBbGxvYygpIDw8ICJDb3VsZCBub3QgcmVsZWFzZSBkZXZpY2UgQ0dMIGNvbnRleHQu IjsKKyAgICAgICAgfQorICAgICAgICBtVGhyZWFkc1dpdGhDdXJyZW50Q29udGV4dC5lcmFzZSh0 aHJlYWRJZCk7CiAgICAgfQorICAgIHJldHVybiBlZ2w6Ok5vRXJyb3IoKTsKK30KKworZWdsOjpF cnJvciBEaXNwbGF5Q0dMOjptYWtlQ3VycmVudChlZ2w6OlN1cmZhY2UgKmRyYXdTdXJmYWNlLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlZ2w6OlN1cmZhY2UgKnJlYWRTdXJm YWNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnbDo6Q29udGV4dCAqY29u dGV4dCkKK3sKKyAgICBjaGVja0Rpc2NyZXRlR1BVU3RhdHVzKCk7CiAgICAgcmV0dXJuIERpc3Bs YXlHTDo6bWFrZUN1cnJlbnQoZHJhd1N1cmZhY2UsIHJlYWRTdXJmYWNlLCBjb250ZXh0KTsKIH0K IApkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRl cmVyL2dsL2VhZ2wvRGlzcGxheUVBR0wuaCBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9s aWJBTkdMRS9yZW5kZXJlci9nbC9lYWdsL0Rpc3BsYXlFQUdMLmgKaW5kZXggYTUzNjZlOTE2ZTlj NzU2MDlmMzEwMTMxMmZlYjYwZjA1N2MxMTExNi4uZGE0YTcwMzcxYjY1N2YyYjVlYWIwYTQxYzRi MGJhYTA5ZWVkMzQ0NiAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xp YkFOR0xFL3JlbmRlcmVyL2dsL2VhZ2wvRGlzcGxheUVBR0wuaAorKysgYi9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5oCkBA IC0xMyw2ICsxMyw5IEBACiAKICNpZiAoZGVmaW5lZChBTkdMRV9QTEFURk9STV9JT1MpICYmICFk ZWZpbmVkKEFOR0xFX1BMQVRGT1JNX01BQ0NBVEFMWVNUKSkgfHwgKGRlZmluZWQoQU5HTEVfUExB VEZPUk1fTUFDQ0FUQUxZU1QpICYmIGRlZmluZWQoQU5HTEVfQ1BVX0FSTTY0KSkKIAorI2luY2x1 ZGUgPHRocmVhZD4KKyNpbmNsdWRlIDx1bm9yZGVyZWRfc2V0PgorCiAjaW5jbHVkZSAibGliQU5H TEUvcmVuZGVyZXIvZ2wvRGlzcGxheUdMLmgiCiAKICNpZmRlZiBfX09CSkNfXwpAQCAtMzUsNiAr MzgsOCBAQCBjbGFzcyBEaXNwbGF5RUFHTCA6IHB1YmxpYyBEaXNwbGF5R0wKIAogICAgIGVnbDo6 RXJyb3IgaW5pdGlhbGl6ZShlZ2w6OkRpc3BsYXkgKmRpc3BsYXkpIG92ZXJyaWRlOwogICAgIHZv aWQgdGVybWluYXRlKCkgb3ZlcnJpZGU7CisgICAgZWdsOjpFcnJvciBwcmVwYXJlRm9yQ2FsbCgp IG92ZXJyaWRlOworICAgIGVnbDo6RXJyb3IgcmVsZWFzZVRocmVhZCgpIG92ZXJyaWRlOwogCiAg ICAgU3VyZmFjZUltcGwgKmNyZWF0ZVdpbmRvd1N1cmZhY2UoY29uc3QgZWdsOjpTdXJmYWNlU3Rh dGUgJnN0YXRlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVHTE5hdGl2 ZVdpbmRvd1R5cGUgd2luZG93LApAQCAtOTMsNiArOTgsOCBAQCBjbGFzcyBEaXNwbGF5RUFHTCA6 IHB1YmxpYyBEaXNwbGF5R0wKIAogICAgIGVnbDo6RGlzcGxheSAqbUVHTERpc3BsYXk7CiAgICAg RUFHTENvbnRleHRPYmogbUNvbnRleHQ7CisgICAgc3RkOjp1bm9yZGVyZWRfc2V0PHN0ZDo6dGhy ZWFkOjppZD4gbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQ7CisgICAgYm9vbCBtRGV2aWNlQ29u dGV4dElzVm9sYXRpbGUgPSBmYWxzZTsKIH07CiAKIH0gIC8vIG5hbWVzcGFjZSByeApkaWZmIC0t Z2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2Vh Z2wvRGlzcGxheUVBR0wubW0gYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUv cmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQppbmRleCA5NGY0ZWU1Y2NmYzkyNmM0MGE0 MWU0ODhlOWNjZTY2OTM4ZDQzY2FjLi42Y2I5YzliZmY0Njc5OWM5ZjVmZjhhOTZjOTBlOTljMjZi MjE4MTRjIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUv cmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9B TkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWFnbC9EaXNwbGF5RUFHTC5tbQpAQCAtNzUs NyArNzUsMTEgQEAgZWdsOjpFcnJvciBEaXNwbGF5RUFHTDo6aW5pdGlhbGl6ZShlZ2w6OkRpc3Bs YXkgKmRpc3BsYXkpCiAgICAgewogICAgICAgICByZXR1cm4gZWdsOjpFZ2xOb3RJbml0aWFsaXpl ZCgpIDw8ICJDb3VsZCBub3QgY3JlYXRlIHRoZSBFQUdMIGNvbnRleHQuIjsKICAgICB9Ci0gICAg W2dldEVBR0xDb250ZXh0Q2xhc3MoKSBzZXRDdXJyZW50Q29udGV4dDptQ29udGV4dF07CisKKyAg ICBpZiAoIVtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bUNvbnRleHRd KSB7CisgICAgICAgIHJldHVybiBlZ2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIkNvdWxkIHNl dCB0aGUgRUFHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICB9CisgICAgbVRocmVhZHNXaXRoQ29u dGV4dEN1cnJlbnQuaW5zZXJ0KHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgpKTsKIAogICAgIC8v IFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZ2V0UHJvY0FkZHJlc3MgaW4gRUFHTCBzbyB3ZSBvcGVu IHRoZSBkeWxpYiBkaXJlY3RseQogICAgIHZvaWQgKmhhbmRsZSA9IGRsb3BlbihrT3BlbkdMRVNE eWxpYk5hbWUsIFJUTERfTk9XKTsKQEAgLTk1LDYgKzk5LDkgQEAgZWdsOjpFcnJvciBEaXNwbGF5 RUFHTDo6aW5pdGlhbGl6ZShlZ2w6OkRpc3BsYXkgKmRpc3BsYXkpCiAgICAgICAgIHJldHVybiBl Z2w6OkVnbE5vdEluaXRpYWxpemVkKCkgPDwgIk9wZW5HTCBFUyAyLjAgaXMgbm90IHN1cHBvcnRh YmxlLiI7CiAgICAgfQogCisgICAgYXV0byAmYXR0cmlidXRlcyA9IGRpc3BsYXktPmdldEF0dHJp YnV0ZU1hcCgpOworICAgIG1EZXZpY2VDb250ZXh0SXNWb2xhdGlsZSA9IGF0dHJpYnV0ZXMuZ2V0 KEVHTF9QTEFURk9STV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElMRV9FQUdMX0FOR0xFLCBH TF9GQUxTRSk7CisKICAgICByZXR1cm4gRGlzcGxheUdMOjppbml0aWFsaXplKGRpc3BsYXkpOwog fQogCkBAIC0xMDgsNyArMTE1LDM2IEBAIHZvaWQgRGlzcGxheUVBR0w6OnRlcm1pbmF0ZSgpCiAg ICAgICAgIFtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bmlsXTsKICAg ICAgICAgW21Db250ZXh0IHJlbGVhc2VdOwogICAgICAgICBtQ29udGV4dCA9IG51bGxwdHI7Cisg ICAgICAgIG1UaHJlYWRzV2l0aENvbnRleHRDdXJyZW50LmNsZWFyKCk7CisgICAgfQorfQorCitl Z2w6OkVycm9yIERpc3BsYXlFQUdMOjpwcmVwYXJlRm9yQ2FsbCgpCit7CisgICAgYXV0byB0aHJl YWRJZCA9IHN0ZDo6dGhpc190aHJlYWQ6OmdldF9pZCgpOworICAgIGlmIChtRGV2aWNlQ29udGV4 dElzVm9sYXRpbGUgfHwgbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZmluZCh0aHJlYWRJZCkg PT0gbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZW5kKCkpCisgICAgeworICAgICAgICBpZiAo IVtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bUNvbnRleHRdKQorICAg ICAgICB7CisgICAgICAgICAgICByZXR1cm4gZWdsOjpFZ2xCYWRBbGxvYygpIDw8ICJDb3VsZCBu b3QgbWFrZSBkZXZpY2UgRUFHTCBjb250ZXh0IGN1cnJlbnQuIjsKKyAgICAgICAgfQorICAgICAg ICBtVGhyZWFkc1dpdGhDb250ZXh0Q3VycmVudC5pbnNlcnQodGhyZWFkSWQpOwogICAgIH0KKyAg ICByZXR1cm4gZWdsOjpOb0Vycm9yKCk7Cit9CisKK2VnbDo6RXJyb3IgRGlzcGxheUVBR0w6OnJl bGVhc2VUaHJlYWQoKQoreworICAgIGF1dG8gdGhyZWFkSWQgPSBzdGQ6OnRoaXNfdGhyZWFkOjpn ZXRfaWQoKTsKKyAgICBpZiAobVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZmluZCh0aHJlYWRJ ZCkgIT0gbVRocmVhZHNXaXRoQ29udGV4dEN1cnJlbnQuZW5kKCkpCisgICAgeworICAgICAgICBp ZiAoIVtnZXRFQUdMQ29udGV4dENsYXNzKCkgc2V0Q3VycmVudENvbnRleHQ6bmlsXSkKKyAgICAg ICAgeworICAgICAgICAgICAgcmV0dXJuIGVnbDo6RWdsQmFkQWxsb2MoKSA8PCAiQ291bGQgbm90 IHJlbGVhc2UgZGV2aWNlIEVBR0wgY29udGV4dC4iOworICAgICAgICB9CisgICAgICAgIG1UaHJl YWRzV2l0aENvbnRleHRDdXJyZW50LmVyYXNlKHRocmVhZElkKTsKKyAgICB9CisgICAgcmV0dXJu IGVnbDo6Tm9FcnJvcigpOwogfQogCiBTdXJmYWNlSW1wbCAqRGlzcGxheUVBR0w6OmNyZWF0ZVdp bmRvd1N1cmZhY2UoY29uc3QgZWdsOjpTdXJmYWNlU3RhdGUgJnN0YXRlLApkaWZmIC0tZ2l0IGEv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3ZhbGlkYXRpb25FR0wuY3BwIGIv U291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3ZhbGlkYXRpb25FR0wuY3BwCmlu ZGV4IGI1NjZjZjBmZDE1NmJhZjU2MWUwNGZmNTIwMzBiNGI4NWExMzg5YWIuLjBhMTI1YjkwNDNh YjVlNmJhYjgwM2M1YzBhOWE0ZmQ2MTZlOTliNTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBh cnR5L0FOR0xFL3NyYy9saWJBTkdMRS92YWxpZGF0aW9uRUdMLmNwcAorKysgYi9Tb3VyY2UvVGhp cmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvdmFsaWRhdGlvbkVHTC5jcHAKQEAgLTY0Myw2ICs2 NDMsMzQgQEAgRXJyb3IgVmFsaWRhdGVHZXRQbGF0Zm9ybURpc3BsYXlDb21tb24oRUdMZW51bSBw bGF0Zm9ybSwKICAgICAgICAgICAgICAgICBjYXNlIEVHTF9QTEFURk9STV9BTkdMRV9EM0RfTFVJ RF9MT1dfQU5HTEU6CiAgICAgICAgICAgICAgICAgICAgIGx1aWRTcGVjaWZpZWQgPSB0cnVlOwog ICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICBjYXNlIEVHTF9QTEFU Rk9STV9BTkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElMRV9FQUdMX0FOR0xFOgorICAgICAgICAg ICAgICAgICAgICAvLyBUaGUgcHJvcGVydHkgZG9lcyBub3QgaGF2ZSBhbiBlZmZlY3QgaWYgaXQn cyBub3QgYWN0aXZlLCBzbyBkbyBub3QgY2hlY2sKKyAgICAgICAgICAgICAgICAgICAgLy8gZm9y IG5vbi1zdXBwb3J0LgorICAgICAgICAgICAgICAgICAgICBzd2l0Y2ggKHZhbHVlKQorICAgICAg ICAgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgICAgICAgICBjYXNlIEVHTF9GQUxTRToK KyAgICAgICAgICAgICAgICAgICAgICAgIGNhc2UgRUdMX1RSVUU6CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgICAgICAgICBkZWZhdWx0OgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBFZ2xCYWRBdHRyaWJ1dGUoKSA8PCAiSW52 YWxpZCB2YWx1ZSBmb3IgIgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAiRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFU SUxFXyIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIkVBR0xfQU5HTEUgYXR0cmliIjsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAg ICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICBjYXNlIEVHTF9QTEFURk9STV9B TkdMRV9ERVZJQ0VfQ09OVEVYVF9WT0xBVElMRV9DR0xfQU5HTEU6CisgICAgICAgICAgICAgICAg ICAgIC8vIFRoZSBwcm9wZXJ0eSBkb2VzIG5vdCBoYXZlIGFuIGVmZmVjdCBpZiBpdCdzIG5vdCBh Y3RpdmUsIHNvIGRvIG5vdCBjaGVjaworICAgICAgICAgICAgICAgICAgICAvLyBmb3Igbm9uLXN1 cHBvcnQuCisgICAgICAgICAgICAgICAgICAgIHN3aXRjaCAodmFsdWUpCisgICAgICAgICAgICAg ICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGNhc2UgRUdMX0ZBTFNFOgorICAgICAg ICAgICAgICAgICAgICAgICAgY2FzZSBFR0xfVFJVRToKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmV0dXJuIEVnbEJhZEF0dHJpYnV0ZSgpIDw8ICJJbnZhbGlkIHZh bHVlIGZvciAiCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICJFR0xfUExBVEZPUk1fQU5HTEVfREVWSUNFX0NPTlRFWFRfVk9MQVRJTEVfIgor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi Q0dMX0FOR0xFIGF0dHJpYiI7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAg ICAgICAgYnJlYWs7CiAgICAgICAgICAgICAgICAgZGVmYXVsdDoKICAgICAgICAgICAgICAgICAg ICAgYnJlYWs7CiAgICAgICAgICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9B TkdMRS9zcmMvbGliR0xFU3YyL2VudHJ5X3BvaW50c19lZ2wuY3BwIGIvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvc3JjL2xpYkdMRVN2Mi9lbnRyeV9wb2ludHNfZWdsLmNwcAppbmRleCBmZDBmZjg2 ODdjZmIwOTg5NTEwYzMzMTRlZGU4YjJkOTU0N2IwNDQzLi4wMWZlOWY2MzBkN2YwODczNmQ3NDIz MzFkYTA1ZGMwNjlmNmQyYzMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9z cmMvbGliR0xFU3YyL2VudHJ5X3BvaW50c19lZ2wuY3BwCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5 L0FOR0xFL3NyYy9saWJHTEVTdjIvZW50cnlfcG9pbnRzX2VnbC5jcHAKQEAgLTEwNSw3ICsxMDUs OCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9UZXJtaW5hdGUoRUdMRGlzcGxheSBkcHkp CiAgICAgZWdsOjpEaXNwbGF5ICpkaXNwbGF5ID0gc3RhdGljX2Nhc3Q8ZWdsOjpEaXNwbGF5ICo+ KGRweSk7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVRlcm1pbmF0 ZShkaXNwbGF5KSwgImVnbFRlcm1pbmF0ZSIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZ X1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xUZXJtaW5hdGUi LAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBF R0xfRkFMU0UpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+bWFr ZUN1cnJlbnQodGhyZWFkLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyKSwKICAgICAgICAgICAg ICAgICAgICAgICAgICAiZWdsVGVybWluYXRlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSks IEVHTF9GQUxTRSk7CiAgICAgU2V0Q29udGV4dEN1cnJlbnQodGhyZWFkLCBudWxscHRyKTsKQEAg LTEyNyw2ICsxMjgsOCBAQCBjb25zdCBjaGFyICpFR0xBUElFTlRSWSBFR0xfUXVlcnlTdHJpbmco RUdMRGlzcGxheSBkcHksIEVHTGludCBuYW1lKQogICAgIHsKICAgICAgICAgQU5HTEVfRUdMX1RS WV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZURpc3BsYXkoZGlzcGxheSksICJlZ2xRdWVyeVN0cmlu ZyIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBudWxscHRyKTsKKyAgICAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNw bGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUXVlcnlTdHJpbmciLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgbnVsbHB0cik7CiAgICAg fQogCiAgICAgY29uc3QgY2hhciAqcmVzdWx0OwpAQCAtMjU1LDYgKzI1OCw4IEBAIEVHTFN1cmZh Y2UgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVdpbmRvd1N1cmZhY2UoRUdMRGlzcGxheSBkcHksCiAg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAgICAgICAgICAgICAgICAgICAg IFZhbGlkYXRlQ3JlYXRlV2luZG93U3VyZmFjZShkaXNwbGF5LCBjb25maWd1cmF0aW9uLCB3aW4s IGF0dHJpYnV0ZXMpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVXaW5kb3dT dXJmYWNlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKKyAg ICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCks ICJlZ2xDcmVhdGVXaW5kb3dTdXJmYWNlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXRE aXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogCiAgICAgZWdsOjpTdXJm YWNlICpzdXJmYWNlID0gbnVsbHB0cjsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs CkBAIC0yODEsNyArMjg2LDggQEAgRUdMU3VyZmFjZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlUGJ1 ZmZlclN1cmZhY2UoRUdMRGlzcGxheSBkcHksCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIFZhbGlkYXRlQ3JlYXRlUGJ1ZmZlclN1cmZhY2UoZGlzcGxheSwgY29uZmlndXJhdGlv biwgYXR0cmlidXRlcyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVBidWZm ZXJTdXJmYWNlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsK LQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNh bGwoKSwgImVnbENyZWF0ZVBidWZmZXJTdXJmYWNlIiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIGVnbDo6 U3VyZmFjZSAqc3VyZmFjZSA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhy ZWFkLCBkaXNwbGF5LT5jcmVhdGVQYnVmZmVyU3VyZmFjZShjb25maWd1cmF0aW9uLCBhdHRyaWJ1 dGVzLCAmc3VyZmFjZSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbENyZWF0ZVBidWZm ZXJTdXJmYWNlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsK QEAgLTMxMCw3ICszMTYsOCBAQCBFR0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQaXht YXBTdXJmYWNlKEVHTERpc3BsYXkgZHB5LAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwKICAgICAgICAgICAgICAgICAgICAgICAgICBWYWxpZGF0ZUNyZWF0ZVBpeG1hcFN1cmZhY2Uo ZGlzcGxheSwgY29uZmlndXJhdGlvbiwgcGl4bWFwLCBhdHRyaWJ1dGVzKSwKICAgICAgICAgICAg ICAgICAgICAgICAgICAiZWdsQ3JlYXRlUGl4bWFwU3VyZmFjZSIsIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVQaXhtYXBTdXJmYWNl IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwg RUdMX05PX1NVUkZBQ0UpOwogICAgIGVnbDo6U3VyZmFjZSAqc3VyZmFjZSA9IG51bGxwdHI7CiAg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAgICAgICAgICAgICAgICAgICAg IGRpc3BsYXktPmNyZWF0ZVBpeG1hcFN1cmZhY2UoY29uZmlndXJhdGlvbiwgcGl4bWFwLCBhdHRy aWJ1dGVzLCAmc3VyZmFjZSksCkBAIC0zMzIsNyArMzM5LDggQEAgRUdMQm9vbGVhbiBFR0xBUElF TlRSWSBFR0xfRGVzdHJveVN1cmZhY2UoRUdMRGlzcGxheSBkcHksIEVHTFN1cmZhY2Ugc3VyZmFj ZSkKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVEZXN0cm95U3Vy ZmFjZShkaXNwbGF5LCBlZ2xTdXJmYWNlLCBzdXJmYWNlKSwKICAgICAgICAgICAgICAgICAgICAg ICAgICAiZWdsRGVzdHJveVN1cmZhY2UiLCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xT dXJmYWNlKSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwg ZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbERlc3Ryb3lTdXJmYWNlIiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsK ICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPmRlc3Ryb3lTdXJmYWNl KGVnbFN1cmZhY2UpLCAiZWdsRGVzdHJveVN1cmZhY2UiLAogICAgICAgICAgICAgICAgICAgICAg ICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xfRkFMU0UpOwog CkBAIC0zNTIsMTIgKzM2MCwxMyBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9RdWVyeVN1 cmZhY2UoRUdMRGlzcGxheSBkcHksCiAgICAgICAgICAgICAgICAodWludHB0cl90KWRweSwgKHVp bnRwdHJfdClzdXJmYWNlLCBhdHRyaWJ1dGUsICh1aW50cHRyX3QpdmFsdWUpOwogICAgIFRocmVh ZCAqdGhyZWFkID0gZWdsOjpHZXRDdXJyZW50VGhyZWFkKCk7CiAKLSAgICBjb25zdCBlZ2w6OkRp c3BsYXkgKmRpc3BsYXkgPSBzdGF0aWNfY2FzdDxjb25zdCBlZ2w6OkRpc3BsYXkgKj4oZHB5KTsK KyAgICBlZ2w6OkRpc3BsYXkgKmRpc3BsYXkgPSBzdGF0aWNfY2FzdDxlZ2w6OkRpc3BsYXkgKj4o ZHB5KTsKICAgICBjb25zdCBTdXJmYWNlICplZ2xTdXJmYWNlICAgPSBzdGF0aWNfY2FzdDxjb25z dCBTdXJmYWNlICo+KHN1cmZhY2UpOwogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBWYWxpZGF0ZVF1ZXJ5U3VyZmFjZShkaXNwbGF5LCBlZ2xTdXJmYWNlLCBhdHRyaWJ1dGUsIHZh bHVlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsUXVlcnlTdXJmYWNlIiwgR2V0U3Vy ZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xR dWVyeVN1cmZhY2UiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwg UXVlcnlTdXJmYWNlQXR0cmliKGRpc3BsYXksIGVnbFN1cmZhY2UsIGF0dHJpYnV0ZSwgdmFsdWUp LAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xRdWVyeVN1cmZhY2UiLCBHZXRTdXJmYWNl SWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKIApAQCAtMzg1LDcgKzM5 NCw4IEBAIEVHTENvbnRleHQgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZUNvbnRleHQoRUdMRGlzcGxh eSBkcHksCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAgICAgICAgICAg ICAgICAgICAgIFZhbGlkYXRlQ3JlYXRlQ29udGV4dChkaXNwbGF5LCBjb25maWd1cmF0aW9uLCBz aGFyZWRHTENvbnRleHQsIGF0dHJpYnV0ZXMpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJl Z2xDcmVhdGVDb250ZXh0IiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19DT05U RVhUKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFy ZUZvckNhbGwoKSwgImVnbENyZWF0ZUNvbnRleHQiLAorICAgICAgICAgICAgICAgICAgICAgICAg IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fQ09OVEVYVCk7CiAgICAgZ2w6OkNv bnRleHQgKmNvbnRleHQgPSBudWxscHRyOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwKICAgICAgICAgICAgICAgICAgICAgICAgICBkaXNwbGF5LT5jcmVhdGVDb250ZXh0KGNvbmZp Z3VyYXRpb24sIHNoYXJlZEdMQ29udGV4dCwgdGhyZWFkLT5nZXRBUEkoKSwKQEAgLTQwOCw3ICs0 MTgsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9EZXN0cm95Q29udGV4dChFR0xEaXNw bGF5IGRweSwgRUdMQ29udGV4dCBjdHgpCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJl YWQsIFZhbGlkYXRlRGVzdHJveUNvbnRleHQoZGlzcGxheSwgY29udGV4dCwgY3R4KSwgImVnbERl c3Ryb3lDb250ZXh0IiwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRDb250ZXh0SWZWYWxp ZChkaXNwbGF5LCBjb250ZXh0KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbERlc3Ryb3lDb250ZXh0 IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwg RUdMX0ZBTFNFKTsKICAgICBib29sIGNvbnRleHRXYXNDdXJyZW50ID0gY29udGV4dCA9PSB0aHJl YWQtPmdldENvbnRleHQoKTsKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlz cGxheS0+ZGVzdHJveUNvbnRleHQodGhyZWFkLCBjb250ZXh0KSwgImVnbERlc3Ryb3lDb250ZXh0 IiwKQEAgLTQ0Myw3ICs0NTQsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9NYWtlQ3Vy cmVudChFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwg VmFsaWRhdGVNYWtlQ3VycmVudChkaXNwbGF5LCBkcmF3U3VyZmFjZSwgcmVhZFN1cmZhY2UsIGNv bnRleHQpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xNYWtlQ3VycmVudCIsIEdldENv bnRleHRJZlZhbGlkKGRpc3BsYXksIGNvbnRleHQpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsTWFr ZUN1cnJlbnQiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRp c3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIFN1cmZhY2UgKnByZXZpb3VzRHJhdyAgICAgICAgPSB0 aHJlYWQtPmdldEN1cnJlbnREcmF3U3VyZmFjZSgpOwogICAgIFN1cmZhY2UgKnByZXZpb3VzUmVh ZCAgICAgICAgPSB0aHJlYWQtPmdldEN1cnJlbnRSZWFkU3VyZmFjZSgpOwogICAgIGdsOjpDb250 ZXh0ICpwcmV2aW91c0NvbnRleHQgPSB0aHJlYWQtPmdldENvbnRleHQoKTsKQEAgLTUxNyw3ICs1 MjksOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9RdWVyeUNvbnRleHQoRUdMRGlzcGxh eSBkcHksCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlUXVlcnlD b250ZXh0KGRpc3BsYXksIGNvbnRleHQsIGF0dHJpYnV0ZSwgdmFsdWUpLAogICAgICAgICAgICAg ICAgICAgICAgICAgICJlZ2xRdWVyeUNvbnRleHQiLCBHZXRDb250ZXh0SWZWYWxpZChkaXNwbGF5 LCBjb250ZXh0KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFF1ZXJ5Q29udGV4dCIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7 CiAgICAgUXVlcnlDb250ZXh0QXR0cmliKGNvbnRleHQsIGF0dHJpYnV0ZSwgdmFsdWUpOwogCiAg ICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CkBAIC01MzQsNiArNTQ3LDggQEAgRUdMQm9vbGVhbiBF R0xBUElFTlRSWSBFR0xfV2FpdEdMKHZvaWQpCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIFZhbGlkYXRlRGlzcGxheShkaXNwbGF5KSwgImVnbFdhaXRHTCIsIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLAogICAgICAgICAgICAgICAgICAgICAgICAgIEVHTF9GQUxTRSk7Cisg ICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgp LCAiZWdsV2FpdEdMIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxp ZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKIAogICAgIC8vIGVnbFdhaXRHTCBsaWtlIGNhbGxpbmcg ZWdsV2FpdENsaWVudCB3aXRoIHRoZSBPcGVuR0wgRVMgQVBJIGJvdW5kLiBTaW5jZSB3ZSBvbmx5 IGltcGxlbWVudAogICAgIC8vIE9wZW5HTCBFUyB3ZSBjYW4gZG8gdGhlIGNhbGwgZGlyZWN0bHku CkBAIC01NTQsNiArNTY5LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfV2FpdE5hdGl2 ZShFR0xpbnQgZW5naW5lKQogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxp ZGF0ZVdhaXROYXRpdmUoZGlzcGxheSwgZW5naW5lKSwgImVnbFdhaXROYXRpdmUiLAogICAgICAg ICAgICAgICAgICAgICAgICAgIEdldFRocmVhZElmVmFsaWQodGhyZWFkKSwgRUdMX0ZBTFNFKTsK KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxs KCksICJlZ2xXYWl0TmF0aXZlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5 SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJO KHRocmVhZCwgZGlzcGxheS0+d2FpdE5hdGl2ZSh0aHJlYWQtPmdldENvbnRleHQoKSwgZW5naW5l KSwgImVnbFdhaXROYXRpdmUiLAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFRocmVhZElm VmFsaWQodGhyZWFkKSwgRUdMX0ZBTFNFKTsKQEAgLTU3NCw2ICs1OTEsOCBAQCBFR0xCb29sZWFu IEVHTEFQSUVOVFJZIEVHTF9Td2FwQnVmZmVycyhFR0xEaXNwbGF5IGRweSwgRUdMU3VyZmFjZSBz dXJmYWNlKQogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVN3YXBC dWZmZXJzKHRocmVhZCwgZGlzcGxheSwgZWdsU3VyZmFjZSksICJlZ2xTd2FwQnVmZmVycyIsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3Vy ZmFjZSksIEVHTF9GQUxTRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNw bGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsU3dhcEJ1ZmZlcnMiLAorICAgICAgICAgICAgICAg ICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogCiAgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBlZ2xTdXJmYWNlLT5zd2FwKHRocmVhZC0+Z2V0 Q29udGV4dCgpKSwgImVnbFN3YXBCdWZmZXJzIiwKICAgICAgICAgICAgICAgICAgICAgICAgICBH ZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKQEAgLTU5 OCw3ICs2MTcsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9Db3B5QnVmZmVycyhFR0xE aXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVD b3B5QnVmZmVycyhkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgImVnbENvcHlCdWZmZXJzIiwKICAgICAg ICAgICAgICAgICAgICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNl KSwgRUdMX0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxh eS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENvcHlCdWZmZXJzIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBVTklN UExFTUVOVEVEKCk7ICAvLyBGSVhNRQogCiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CkBAIC02 MjIsNyArNjQyLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfQmluZFRleEltYWdlKEVH TERpc3BsYXkgZHB5LCBFR0xTdXJmYWNlIHN1cmZhY2UsIEVHTGkKICAgICBBTkdMRV9FR0xfVFJZ X1JFVFVSTigKICAgICAgICAgdGhyZWFkLCBWYWxpZGF0ZUJpbmRUZXhJbWFnZShkaXNwbGF5LCBl Z2xTdXJmYWNlLCBzdXJmYWNlLCBidWZmZXIsIGNvbnRleHQsICZ0ZXh0dXJlT2JqZWN0KSwKICAg ICAgICAgImVnbEJpbmRUZXhJbWFnZSIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1 cmZhY2UpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBk aXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsQmluZFRleEltYWdlIiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAg ICBpZiAoY29udGV4dCkKICAgICB7CiAgICAgICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwgZWdsU3VyZmFjZS0+YmluZFRleEltYWdlKGNvbnRleHQsIHRleHR1cmVPYmplY3QsIGJ1ZmZl ciksCkBAIC02NTAsNyArNjcxLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfU3VyZmFj ZUF0dHJpYihFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwgVmFsaWRhdGVTdXJmYWNlQXR0cmliKGRpc3BsYXksIGVnbFN1cmZhY2UsIGF0dHJpYnV0ZSwg dmFsdWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xTdXJmYWNlQXR0cmliIiwgR2V0 U3VyZmFjZUlmVmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSksIEVHTF9GQUxTRSk7Ci0KKyAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJl Z2xTdXJmYWNlQXR0cmliIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZW YWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBTZXRTdXJmYWNlQXR0cmliKGVnbFN1cmZh Y2UsIGF0dHJpYnV0ZSwgdmFsdWUpOwogCiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CkBAIC02 NzEsNiArNjkzLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfUmVsZWFzZVRleEltYWdl KEVHTERpc3BsYXkgZHB5LCBFR0xTdXJmYWNlIHN1cmZhY2UsIEUKICAgICBBTkdMRV9FR0xfVFJZ X1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlUmVsZWFzZVRleEltYWdlKGRpc3BsYXksIGVnbFN1cmZh Y2UsIHN1cmZhY2UsIGJ1ZmZlciksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbFJlbGVh c2VUZXhJbWFnZSIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLCBFR0xf RkFMU0UpOwogCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVw YXJlRm9yQ2FsbCgpLCAiZWdsUmVsZWFzZVRleEltYWdlIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBnbDo6VGV4 dHVyZSAqdGV4dHVyZSA9IGVnbFN1cmZhY2UtPmdldEJvdW5kVGV4dHVyZSgpOwogCiAgICAgaWYg KHRleHR1cmUpCkBAIC02OTcsNyArNzIxLDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xf U3dhcEludGVydmFsKEVHTERpc3BsYXkgZHB5LCBFR0xpbnQgaW50ZXJ2YWwpCiAKICAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlU3dhcEludGVydmFsKGRpc3BsYXksIGRy YXdfc3VyZmFjZSwgY29udGV4dCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbFN3YXBJ bnRlcnZhbCIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwotCisgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAi ZWdsU3dhcEludGVydmFsIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZW YWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBjb25zdCBlZ2w6OkNvbmZpZyAqc3VyZmFj ZUNvbmZpZyA9IGRyYXdfc3VyZmFjZS0+Z2V0Q29uZmlnKCk7CiAgICAgRUdMaW50IGNsYW1wZWRJ bnRlcnZhbCAgICAgICAgICAgPSBzdGQ6Om1pbihzdGQ6Om1heChpbnRlcnZhbCwgc3VyZmFjZUNv bmZpZy0+bWluU3dhcEludGVydmFsKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgc3VyZmFjZUNvbmZpZy0+bWF4U3dhcEludGVydmFsKTsKQEAgLTc1OSw3ICs3ODQsOCBA QCBFR0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQYnVmZmVyRnJvbUNsaWVudEJ1ZmZl cihFR0xEaXNwbGF5IGRweSwKICAgICAgICAgdGhyZWFkLAogICAgICAgICBWYWxpZGF0ZUNyZWF0 ZVBidWZmZXJGcm9tQ2xpZW50QnVmZmVyKGRpc3BsYXksIGJ1ZnR5cGUsIGJ1ZmZlciwgY29uZmln dXJhdGlvbiwgYXR0cmlidXRlcyksCiAgICAgICAgICJlZ2xDcmVhdGVQYnVmZmVyRnJvbUNsaWVu dEJ1ZmZlciIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7Ci0K KyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxs KCksICJlZ2xDcmVhdGVQYnVmZmVyRnJvbUNsaWVudEJ1ZmZlciIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKICAg ICBlZ2w6OlN1cmZhY2UgKnN1cmZhY2UgPSBudWxscHRyOwogICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwKICAgICAgICAgICAgICAgICAgICAgICAgICBkaXNwbGF5LT5jcmVhdGVQYnVm ZmVyRnJvbUNsaWVudEJ1ZmZlcihjb25maWd1cmF0aW9uLCBidWZ0eXBlLCBidWZmZXIsCkBAIC03 ODEsMTYgKzgwNywxOSBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9SZWxlYXNlVGhyZWFk KHZvaWQpCiAgICAgZ2w6OkNvbnRleHQgKnByZXZpb3VzQ29udGV4dCAgPSB0aHJlYWQtPmdldENv bnRleHQoKTsKICAgICBlZ2w6OkRpc3BsYXkgKnByZXZpb3VzRGlzcGxheSA9IHRocmVhZC0+Z2V0 RGlzcGxheSgpOwogCi0gICAgLy8gT25seSBjYWxsIG1ha2VDdXJyZW50IGlmIHRoZSBjb250ZXh0 IG9yIHN1cmZhY2VzIGhhdmUgY2hhbmdlZC4KLSAgICBpZiAocHJldmlvdXNEcmF3ICE9IEVHTF9O T19TVVJGQUNFIHx8IHByZXZpb3VzUmVhZCAhPSBFR0xfTk9fU1VSRkFDRSB8fAotICAgICAgICBw cmV2aW91c0NvbnRleHQgIT0gRUdMX05PX0NPTlRFWFQpCi0gICAgewotICAgICAgICBpZiAocHJl dmlvdXNEaXNwbGF5ICE9IEVHTF9OT19ESVNQTEFZKQorICAgIGlmIChwcmV2aW91c0Rpc3BsYXkg IT0gRUdMX05PX0RJU1BMQVkpIHsKKyAgICAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBwcmV2aW91c0Rpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xSZWxlYXNlVGhyZWFkIiwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQocHJldmlvdXNE aXNwbGF5KSwgRUdMX0ZBTFNFKTsKKyAgICAgICAgLy8gT25seSBjYWxsIG1ha2VDdXJyZW50IGlm IHRoZSBjb250ZXh0IG9yIHN1cmZhY2VzIGhhdmUgY2hhbmdlZC4KKyAgICAgICAgaWYgKHByZXZp b3VzRHJhdyAhPSBFR0xfTk9fU1VSRkFDRSB8fCBwcmV2aW91c1JlYWQgIT0gRUdMX05PX1NVUkZB Q0UgfHwKKyAgICAgICAgICAgIHByZXZpb3VzQ29udGV4dCAhPSBFR0xfTk9fQ09OVEVYVCkKICAg ICAgICAgewogICAgICAgICAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJldmlvdXNEaXNwbGF5LT5tYWtlQ3VycmVudCh0 aHJlYWQsIG51bGxwdHIsIG51bGxwdHIsIG51bGxwdHIpLAogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgImVnbFJlbGVhc2VUaHJlYWQiLCBudWxscHRyLCBFR0xfRkFMU0UpOwogICAg ICAgICB9CisgICAgICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgcHJldmlvdXNEaXNw bGF5LT5yZWxlYXNlVGhyZWFkKCksICJlZ2xSZWxlYXNlVGhyZWFkIiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQocHJldmlvdXNEaXNwbGF5KSwgRUdMX0ZB TFNFKTsKIAogICAgICAgICBTZXRDb250ZXh0Q3VycmVudCh0aHJlYWQsIG51bGxwdHIpOwogICAg IH0KQEAgLTgxMCw3ICs4MzksOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9XYWl0Q2xp ZW50KHZvaWQpCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlRGlz cGxheShkaXNwbGF5KSwgImVnbFdhaXRDbGllbnQiLAogICAgICAgICAgICAgICAgICAgICAgICAg IEdldENvbnRleHRJZlZhbGlkKGRpc3BsYXksIGNvbnRleHQpLCBFR0xfRkFMU0UpOwotCisgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAi ZWdsV2FpdENsaWVudCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFs aWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBkaXNwbGF5LT53YWl0Q2xpZW50KGNvbnRleHQpLCAiZWdsV2FpdENsaWVudCIsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgR2V0Q29udGV4dElmVmFsaWQoZGlzcGxheSwgY29udGV4dCksIEVH TF9GQUxTRSk7CiAKQEAgLTg0OSw3ICs4NzksOCBAQCBFR0xTeW5jIEVHTEFQSUVOVFJZIEVHTF9D cmVhdGVTeW5jKEVHTERpc3BsYXkgZHB5LCBFR0xlbnVtIHR5cGUsIGNvbnN0IEVHTEF0dHJpYgog ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKAogICAgICAgICB0aHJlYWQsIFZhbGlkYXRlQ3JlYXRl U3luYyhkaXNwbGF5LCB0eXBlLCBhdHRyaWJ1dGVzLCBjdXJyZW50RGlzcGxheSwgY3VycmVudENv bnRleHQpLAogICAgICAgICAiZWdsQ3JlYXRlU3luYyIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBFR0xfTk9fU1lOQyk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRp c3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVTeW5jIiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBl Z2w6OlN5bmMgKnN5bmNPYmplY3QgPSBudWxscHRyOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJO KHRocmVhZCwgZGlzcGxheS0+Y3JlYXRlU3luYyhjdXJyZW50Q29udGV4dCwgdHlwZSwgYXR0cmli dXRlcywgJnN5bmNPYmplY3QpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVT eW5jIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TWU5DKTsKQEAgLTg3MCw3 ICs5MDEsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9EZXN0cm95U3luYyhFR0xEaXNw bGF5IGRweSwgRUdMU3luYyBzeW5jKQogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBWYWxpZGF0ZURlc3Ryb3lTeW5jKGRpc3BsYXksIHN5bmNPYmplY3QpLCAiZWdsRGVzdHJveVN5 bmMiLAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp LCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5 LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsRGVzdHJveVN5bmMiLAorICAgICAgICAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGRpc3Bs YXktPmRlc3Ryb3lTeW5jKHN5bmNPYmplY3QpOwogCiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7 CkBAIC04OTEsNyArOTIzLDggQEAgRUdMaW50IEVHTEFQSUVOVFJZIEVHTF9DbGllbnRXYWl0U3lu YyhFR0xEaXNwbGF5IGRweSwgRUdMU3luYyBzeW5jLCBFR0xpbnQgZmxhZ3MKIAogICAgIEFOR0xF X0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFsaWRhdGVDbGllbnRXYWl0U3luYyhkaXNwbGF5LCBz eW5jT2JqZWN0LCBmbGFncywgdGltZW91dCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVn bENsaWVudFdhaXRTeW5jIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVjdCksIEVH TF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnBy ZXBhcmVGb3JDYWxsKCksICJlZ2xDbGllbnRXYWl0U3luYyIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZ2w6OkNv bnRleHQgKmN1cnJlbnRDb250ZXh0ID0gdGhyZWFkLT5nZXRDb250ZXh0KCk7CiAgICAgRUdMaW50 IHN5bmNTdGF0dXMgICAgICAgICAgID0gRUdMX0ZBTFNFOwogICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKApAQCAtOTU0LDYgKzk4Nyw4IEBAIEVHTEltYWdlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVJ bWFnZShFR0xEaXNwbGF5IGRweSwKICAgICAgICAgdGhyZWFkLT5zZXRFcnJvcihlcnJvciwgR2V0 RGVidWcoKSwgImVnbENyZWF0ZUltYWdlIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwog ICAgICAgICByZXR1cm4gRUdMX05PX0lNQUdFOwogICAgIH0KKyAgICBBTkdMRV9FR0xfVFJZX1JF VFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVJbWFnZSIs CisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVH TF9GQUxTRSk7CiAKICAgICBJbWFnZSAqaW1hZ2UgPSBudWxscHRyOwogICAgIGVycm9yICAgICAg ICA9IGRpc3BsYXktPmNyZWF0ZUltYWdlKGNvbnRleHQsIHRhcmdldCwgYnVmZmVyLCBhdHRyaWJ1 dGVzLCAmaW1hZ2UpOwpAQCAtOTgyLDcgKzEwMTcsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZ IEVHTF9EZXN0cm95SW1hZ2UoRUdMRGlzcGxheSBkcHksIEVHTEltYWdlIGltYWdlKQogICAgICAg ICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1ZygpLCAiZWdsRGVzdHJveUltYWdlIiwg R2V0SW1hZ2VJZlZhbGlkKGRpc3BsYXksIGltZykpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNF OwogICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJl cGFyZUZvckNhbGwoKSwgImVnbERlc3Ryb3lJbWFnZSIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZGlzcGxheS0+ ZGVzdHJveUltYWdlKGltZyk7CiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKQEAgLTEwNDMs MTIgKzEwNzksMTMgQEAgRUdMU3VyZmFjZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlUGxhdGZvcm1X aW5kb3dTdXJmYWNlKEVHTERpc3BsYXkgZHB5LAogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4o dGhyZWFkLAogICAgICAgICAgICAgICAgICAgICAgICAgIFZhbGlkYXRlQ3JlYXRlV2luZG93U3Vy ZmFjZShkaXNwbGF5LCBjb25maWd1cmF0aW9uLCB3aW4sIGF0dHJpYnV0ZXMpLAotICAgICAgICAg ICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVXaW5kb3dTdXJmYWNlIiwgR2V0RGlzcGxheUlmVmFs aWQoZGlzcGxheSksIEVHTF9OT19TVVJGQUNFKTsKLQorICAgICAgICAgICAgICAgICAgICAgICAg ICJlZ2xQbGF0Zm9ybUNyZWF0ZVdpbmRvd1N1cmZhY2UiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNw bGF5KSwgRUdMX05PX1NVUkZBQ0UpOworICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwg ZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENyZWF0ZVdpbmRvd1N1cmZhY2UiLAorICAg ICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9f U1VSRkFDRSk7CiAgICAgZWdsOjpTdXJmYWNlICpzdXJmYWNlID0gbnVsbHB0cjsKICAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgZGlzcGxh eS0+Y3JlYXRlV2luZG93U3VyZmFjZShjb25maWd1cmF0aW9uLCB3aW4sIGF0dHJpYnV0ZXMsICZz dXJmYWNlKSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsQ3JlYXRlV2luZG93U3VyZmFj ZSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7CisgICAgICAg ICAgICAgICAgICAgICAgICAgImVnbFBsYXRmb3JtQ3JlYXRlV2luZG93U3VyZmFjZSIsIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfTk9fU1VSRkFDRSk7CiAKICAgICByZXR1cm4gc3Rh dGljX2Nhc3Q8RUdMU3VyZmFjZT4oc3VyZmFjZSk7CiB9CkBAIC0xMDc1LDcgKzExMTIsOCBAQCBF R0xTdXJmYWNlIEVHTEFQSUVOVFJZIEVHTF9DcmVhdGVQbGF0Zm9ybVBpeG1hcFN1cmZhY2UoRUdM RGlzcGxheSBkcHksCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4oCiAgICAgICAgIHRocmVhZCwg VmFsaWRhdGVDcmVhdGVQaXhtYXBTdXJmYWNlKGRpc3BsYXksIGNvbmZpZ3VyYXRpb24sIHBpeG1h cCwgYXR0cmlidXRlcyksCiAgICAgICAgICJlZ2xDcmVhdGVQbGF0Zm9ybVBpeG1hcFN1cmZhY2Ui LCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwotCisgICAgQU5H TEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWds Q3JlYXRlUGxhdGZvcm1QaXhtYXBTdXJmYWNlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBH ZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX05PX1NVUkZBQ0UpOwogICAgIGVnbDo6U3Vy ZmFjZSAqc3VyZmFjZSA9IG51bGxwdHI7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4oCiAgICAg ICAgIHRocmVhZCwgZGlzcGxheS0+Y3JlYXRlUGl4bWFwU3VyZmFjZShjb25maWd1cmF0aW9uLCBw aXhtYXAsIGF0dHJpYnV0ZXMsICZzdXJmYWNlKSwKQEAgLTEwOTksNyArMTEzNyw4IEBAIEVHTEJv b2xlYW4gRUdMQVBJRU5UUlkgRUdMX1dhaXRTeW5jKEVHTERpc3BsYXkgZHB5LCBFR0xTeW5jIHN5 bmMsIEVHTGludCBmbGFncykKIAogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgVmFs aWRhdGVXYWl0U3luYyhkaXNwbGF5LCBjb250ZXh0LCBzeW5jT2JqZWN0LCBmbGFncyksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgImVnbFdhaXRTeW5jIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxh eSwgc3luY09iamVjdCksIEVHTF9GQUxTRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0 aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xXYWl0U3luYyIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7 CiAgICAgZ2w6OkNvbnRleHQgKmN1cnJlbnRDb250ZXh0ID0gdGhyZWFkLT5nZXRDb250ZXh0KCk7 CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBzeW5jT2JqZWN0LT5zZXJ2ZXJXYWl0 KGRpc3BsYXksIGN1cnJlbnRDb250ZXh0LCBmbGFncyksCiAgICAgICAgICAgICAgICAgICAgICAg ICAgImVnbFdhaXRTeW5jIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVjdCksIEVH TF9GQUxTRSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliR0xF U3YyL2VudHJ5X3BvaW50c19lZ2xfZXh0LmNwcCBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3Ny Yy9saWJHTEVTdjIvZW50cnlfcG9pbnRzX2VnbF9leHQuY3BwCmluZGV4IDlkZTYwMzM1MzU0ZWE3 Mzc0ZjQwY2VkNDJjNzgwZjUwNTk3NzlkZjAuLmUyYzY1ZWE2YmU0NWE2N2I5OWMzMzczYmQxNDMz MDZlNWJlNmM2NjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJH TEVTdjIvZW50cnlfcG9pbnRzX2VnbF9leHQuY3BwCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL3NyYy9saWJHTEVTdjIvZW50cnlfcG9pbnRzX2VnbF9leHQuY3BwCkBAIC04Niw3ICs4Niw4 IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5U3VyZmFjZVBvaW50ZXJBTkdMRShF R0xEaXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3VyZmFjZUlm VmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSkpOwogICAgICAgICAgICAgcmV0dXJuIEVHTF9GQUxT RTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnBy ZXBhcmVGb3JDYWxsKCksICJlZ2xRdWVyeVN1cmZhY2VQb2ludGVyQU5HTEUiLAorICAgICAgICAg ICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwog ICAgIGVycm9yID0gZWdsU3VyZmFjZS0+cXVlcnlTdXJmYWNlUG9pbnRlckFOR0xFKGF0dHJpYnV0 ZSwgdmFsdWUpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtMTUxLDcgKzE1 Miw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1Bvc3RTdWJCdWZmZXJOVihFR0xEaXNw bGF5IGRweSwKICAgICAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CiAgICAgICAgIHJldHVybiBF R0xfVFJVRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3Bs YXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xQb3N0U3ViQnVmZmVyTlYiLAorICAgICAgICAgICAg ICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAg IC8vIFRPRE8oam1hZGlsbCk6IFZhbGlkYXRlIFN1cmZhY2UgaXMgYm91bmQgdG8gdGhlIHRocmVh ZC4KICAgICBlcnJvciA9IGVnbFN1cmZhY2UtPnBvc3RTdWJCdWZmZXIodGhyZWFkLT5nZXRDb250 ZXh0KCksIHgsIHksIHdpZHRoLCBoZWlnaHQpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCkBA IC0yMjMsNyArMjI1LDggQEAgRUdMU3VyZmFjZSBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlUGxhdGZv cm1XaW5kb3dTdXJmYWNlRVhUKEVHTERpc3BsYXkgZHB5LAogICAgICAgICB0aHJlYWQsCiAgICAg ICAgIFZhbGlkYXRlQ3JlYXRlUGxhdGZvcm1XaW5kb3dTdXJmYWNlRVhUKGRpc3BsYXksIGNvbmZp Z3VyYXRpb24sIG5hdGl2ZV93aW5kb3csIGF0dHJpYnV0ZXMpLAogICAgICAgICAiZWdsQ3JlYXRl UGxhdGZvcm1XaW5kb3dTdXJmYWNlRVhUIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVH TF9OT19TVVJGQUNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxh eS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbENyZWF0ZVBsYXRmb3JtV2luZG93U3VyZmFjZUVYVCIs CisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVH TF9OT19TVVJGQUNFKTsKICAgICB0aHJlYWQtPnNldEVycm9yKEVnbEJhZERpc3BsYXkoKSA8PCAi Q3JlYXRlUGxhdGZvcm1XaW5kb3dTdXJmYWNlRVhUIHVuaW1wbGVtZW50ZWQuIiwgR2V0RGVidWco KSwKICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVQbGF0Zm9ybVdpbmRvd1N1cmZhY2VF WFQiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAgcmV0dXJuIEVHTF9OT19TVVJG QUNFOwpAQCAtMjUwLDcgKzI1Myw4IEBAIEVHTFN1cmZhY2UgRUdMQVBJRU5UUlkgRUdMX0NyZWF0 ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZUVYVChFR0xEaXNwbGF5IGRweSwKICAgICAgICAgdGhyZWFk LAogICAgICAgICBWYWxpZGF0ZUNyZWF0ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZUVYVChkaXNwbGF5 LCBjb25maWd1cmF0aW9uLCBuYXRpdmVfcGl4bWFwLCBhdHRyaWJ1dGVzKSwKICAgICAgICAgImVn bENyZWF0ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZUVYVCIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBFR0xfTk9fU1VSRkFDRSk7Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQs IGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVQbGF0Zm9ybVBpeG1hcFN1cmZh Y2VFWFQiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3Bs YXkpLCBFR0xfTk9fU1VSRkFDRSk7CiAgICAgdGhyZWFkLT5zZXRFcnJvcihFZ2xCYWREaXNwbGF5 KCkgPDwgIkNyZWF0ZVBsYXRmb3JtUGl4bWFwU3VyZmFjZUVYVCB1bmltcGxlbWVudGVkLiIsIEdl dERlYnVnKCksCiAgICAgICAgICAgICAgICAgICAgICAiZWdsQ3JlYXRlUGxhdGZvcm1QaXhtYXBT dXJmYWNlRVhUIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogICAgIHJldHVybiBFR0xf Tk9fU1VSRkFDRTsKQEAgLTI3NSwxMCArMjc5LDExIEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkg RUdMX1F1ZXJ5RGV2aWNlQXR0cmliRVhUKEVHTERldmljZUVYVCBkZXZpY2UsCiAgICAgICAgIHRo cmVhZC0+c2V0RXJyb3IoZXJyb3IsIEdldERlYnVnKCksICJlZ2xRdWVyeURldmljZUF0dHJpYkVY VCIsIEdldERldmljZUlmVmFsaWQoZGV2KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAg ICAgfQotCisgICAgZWdsOjpEaXNwbGF5ICpvd25pbmdEaXNwbGF5ID0gZGV2LT5nZXRPd25pbmdE aXNwbGF5KCk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBvd25pbmdEaXNwbGF5 LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUXVlcnlEZXZpY2VBdHRyaWJFWFQiLAorICAgICAgICAg ICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKG93bmluZ0Rpc3BsYXkpLCBFR0xfRkFM U0UpOwogICAgIC8vIElmIHRoZSBkZXZpY2Ugd2FzIGNyZWF0ZWQgYnkgKGFuZCBpcyBvd25lZCBi eSkgYSBkaXNwbGF5LCBhbmQgdGhhdCBkaXNwbGF5IGRvZXNuJ3Qgc3VwcG9ydAogICAgIC8vIGRl dmljZSBxdWVyeWluZywgdGhlbiB0aGlzIGNhbGwgc2hvdWxkIGZhaWwKLSAgICBlZ2w6OkRpc3Bs YXkgKm93bmluZ0Rpc3BsYXkgPSBkZXYtPmdldE93bmluZ0Rpc3BsYXkoKTsKICAgICBpZiAob3du aW5nRGlzcGxheSAhPSBudWxscHRyICYmICFvd25pbmdEaXNwbGF5LT5nZXRFeHRlbnNpb25zKCku ZGV2aWNlUXVlcnkpCiAgICAgewogICAgICAgICB0aHJlYWQtPnNldEVycm9yKEVnbEJhZEFjY2Vz cygpIDw8ICJEZXZpY2Ugd2Fzbid0IGNyZWF0ZWQgdXNpbmcgZWdsQ3JlYXRlRGV2aWNlQU5HTEUs ICIKQEAgLTM1MSw3ICszNTYsOSBAQCBjb25zdCBjaGFyICpFR0xBUElFTlRSWSBFR0xfUXVlcnlE ZXZpY2VTdHJpbmdFWFQoRUdMRGV2aWNlRVhUIGRldmljZSwgRUdMaW50IG5hbQogICAgICAgICB0 aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1ZygpLCAiZWdsUXVlcnlEZXZpY2VTdHJpbmdF WFQiLCBHZXREZXZpY2VJZlZhbGlkKGRldikpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwog ICAgIH0KLQorICAgIGVnbDo6RGlzcGxheSAqb3duaW5nRGlzcGxheSA9IGRldi0+Z2V0T3duaW5n RGlzcGxheSgpOworICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgb3duaW5nRGlzcGxh eS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFF1ZXJ5RGV2aWNlU3RyaW5nRVhUIiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChvd25pbmdEaXNwbGF5KSwgRUdMX0ZB TFNFKTsKICAgICBjb25zdCBjaGFyICpyZXN1bHQ7CiAgICAgc3dpdGNoIChuYW1lKQogICAgIHsK QEAgLTM4MSw3ICszODgsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9RdWVyeURpc3Bs YXlBdHRyaWJFWFQoRUdMRGlzcGxheSBkcHksIEVHTGludCBhdHRyaWJ1dAogCiAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVF1ZXJ5RGlzcGxheUF0dHJpYkVYVChkaXNw bGF5LCBhdHRyaWJ1dGUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xRdWVyeURpc3Bs YXlBdHRyaWJFWFQiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKLQor ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwo KSwgImVnbFF1ZXJ5RGlzcGxheUF0dHJpYkVYVCIsCisgICAgICAgICAgICAgICAgICAgICAgICAg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgKnZhbHVlID0gZGlz cGxheS0+cXVlcnlBdHRyaWIoYXR0cmlidXRlKTsKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsK ICAgICByZXR1cm4gRUdMX1RSVUU7CkBAIC00MDIsNyArNDEwLDggQEAgRUdMQm9vbGVhbiBFR0xB UElFTlRSWSBFR0xfUXVlcnlEaXNwbGF5QXR0cmliQU5HTEUoRUdMRGlzcGxheSBkcHksCiAKICAg ICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlUXVlcnlEaXNwbGF5QXR0cmli QU5HTEUoZGlzcGxheSwgYXR0cmlidXRlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWds UXVlcnlEaXNwbGF5QXR0cmliQU5HTEUiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdM X0ZBTFNFKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJl cGFyZUZvckNhbGwoKSwgImVnbFF1ZXJ5RGlzcGxheUF0dHJpYkFOR0xFIiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAg ICAqdmFsdWUgPSBkaXNwbGF5LT5xdWVyeUF0dHJpYihhdHRyaWJ1dGUpOwogICAgIHRocmVhZC0+ c2V0U3VjY2VzcygpOwogICAgIHJldHVybiBFR0xfVFJVRTsKQEAgLTQzMyw3ICs0NDIsOCBAQCBB TkdMRV9FWFBPUlQgRUdMSW1hZ2VLSFIgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZUltYWdlS0hSKEVH TERpc3BsYXkgZHB5LAogICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXREZWJ1Zygp LCAiZWdsQ3JlYXRlSW1hZ2VLSFIiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAg ICAgIHJldHVybiBFR0xfTk9fSU1BR0U7CiAgICAgfQotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRV Uk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsQ3JlYXRlSW1hZ2VLSFIi LAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBF R0xfTk9fSU1BR0UpOwogICAgIEltYWdlICppbWFnZSA9IG51bGxwdHI7CiAgICAgZXJyb3IgICAg ICAgID0gZGlzcGxheS0+Y3JlYXRlSW1hZ2UoY29udGV4dCwgdGFyZ2V0LCBidWZmZXIsIGF0dHJp YnV0ZXMsICZpbWFnZSk7CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkKQEAgLTQ2Miw3ICs0NzIs OCBAQCBBTkdMRV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfRGVzdHJveUltYWdl S0hSKEVHTERpc3BsYXkgZHB5LCBFR0xJbWFnZQogICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVy cm9yLCBHZXREZWJ1ZygpLCAiZWdsRGVzdHJveUltYWdlS0hSIiwgR2V0SW1hZ2VJZlZhbGlkKGRp c3BsYXksIGltZykpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQorICAgIEFO R0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVn bERlc3Ryb3lJbWFnZUtIUiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlm VmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZGlzcGxheS0+ZGVzdHJveUltYWdlKGlt Zyk7CiAKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKQEAgLTUzOCw3ICs1NDksOCBAQCBFR0xT dHJlYW1LSFIgRUdMQVBJRU5UUlkgRUdMX0NyZWF0ZVN0cmVhbUtIUihFR0xEaXNwbGF5IGRweSwg Y29uc3QgRUdMaW50ICphdHRyaQogICAgICAgICB0aHJlYWQtPnNldEVycm9yKGVycm9yLCBHZXRE ZWJ1ZygpLCAiZWdsQ3JlYXRlU3RyZWFtS0hSIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkp OwogICAgICAgICByZXR1cm4gRUdMX05PX1NUUkVBTV9LSFI7CiAgICAgfQotCisgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsQ3Jl YXRlU3RyZWFtS0hSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxp ZChkaXNwbGF5KSwgRUdMX05PX1NUUkVBTV9LSFIpOwogICAgIFN0cmVhbSAqc3RyZWFtOwogICAg IGVycm9yID0gZGlzcGxheS0+Y3JlYXRlU3RyZWFtKGF0dHJpYnV0ZXMsICZzdHJlYW0pOwogICAg IGlmIChlcnJvci5pc0Vycm9yKCkpCkBAIC01NjgsNyArNTgwLDggQEAgRUdMQm9vbGVhbiBFR0xB UElFTlRSWSBFR0xfRGVzdHJveVN0cmVhbUtIUihFR0xEaXNwbGF5IGRweSwgRUdMU3RyZWFtS0hS IHN0cmVhbSkKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZhbGlkKGRpc3Bs YXksIHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAgIH0KLQor ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwo KSwgImVnbERlc3Ryb3lTdHJlYW1LSFIiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGRpc3BsYXktPmRlc3Ryb3lT dHJlYW0oc3RyZWFtT2JqZWN0KTsKIAogICAgIHRocmVhZC0+c2V0U3VjY2VzcygpOwpAQCAtNTk3 LDcgKzYxMCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N0cmVhbUF0dHJpYktIUihF R0xEaXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1JZlZhbGlk KGRpc3BsYXksIHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwogICAg IH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZv ckNhbGwoKSwgImVnbFN0cmVhbUF0dHJpYktIUiIsCisgICAgICAgICAgICAgICAgICAgICAgICAg R2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgc3dpdGNoIChhdHRy aWJ1dGUpCiAgICAgewogICAgICAgICBjYXNlIEVHTF9DT05TVU1FUl9MQVRFTkNZX1VTRUNfS0hS OgpAQCAtNjM2LDcgKzY1MCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1F1ZXJ5U3Ry ZWFtS0hSKEVHTERpc3BsYXkgZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVh bUlmVmFsaWQoZGlzcGxheSwgc3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFM U0U7CiAgICAgfQotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5w cmVwYXJlRm9yQ2FsbCgpLCAiZWdsUXVlcnlTdHJlYW1LSFIiLAorICAgICAgICAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIHN3aXRj aCAoYXR0cmlidXRlKQogICAgIHsKICAgICAgICAgY2FzZSBFR0xfU1RSRUFNX1NUQVRFX0tIUjoK QEAgLTY3OCw3ICs2OTMsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9RdWVyeVN0cmVh bXU2NEtIUihFR0xEaXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJl YW1JZlZhbGlkKGRpc3BsYXksIHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZB TFNFOwogICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+ cHJlcGFyZUZvckNhbGwoKSwgImVnbFF1ZXJ5U3RyZWFtdTY0S0hSIiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBz d2l0Y2ggKGF0dHJpYnV0ZSkKICAgICB7CiAgICAgICAgIGNhc2UgRUdMX1BST0RVQ0VSX0ZSQU1F X0tIUjoKQEAgLTcxMyw3ICs3MjksOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9TdHJl YW1Db25zdW1lckdMVGV4dHVyZUV4dGVybmFsS0hSKEVHTERpc3BsYXkgZHB5LCBFRwogICAgICAg ICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQoZGlzcGxheSwgc3RyZWFtT2JqZWN0 KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisgICAgQU5HTEVfRUdMX1RS WV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsU3RyZWFtQ29u c3VtZXJHTFRleHR1cmVFeHRlcm5hbEtIUiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZXJyb3IgPSBzdHJlYW1P YmplY3QtPmNyZWF0ZUNvbnN1bWVyR0xUZXh0dXJlRXh0ZXJuYWwoQXR0cmlidXRlTWFwKCksIGNv bnRleHQpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtNzQ0LDcgKzc2MSw4 IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N0cmVhbUNvbnN1bWVyQWNxdWlyZUtIUihF R0xEaXNwbGF5IGRweSwgRUdMU3RyZWFtS0hSCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0 U3RyZWFtSWZWYWxpZChkaXNwbGF5LCBzdHJlYW1PYmplY3QpKTsKICAgICAgICAgcmV0dXJuIEVH TF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3Bs YXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xTdHJlYW1Db25zdW1lckFjcXVpcmVLSFIiLAorICAg ICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFM U0UpOwogICAgIGVycm9yID0gc3RyZWFtT2JqZWN0LT5jb25zdW1lckFjcXVpcmUoY29udGV4dCk7 CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkKICAgICB7CkBAIC03NzUsNyArNzkzLDggQEAgRUdM Qm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfU3RyZWFtQ29uc3VtZXJSZWxlYXNlS0hSKEVHTERpc3Bs YXkgZHB5LCBFR0xTdHJlYW1LSFIKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTdHJlYW1J ZlZhbGlkKGRpc3BsYXksIHN0cmVhbU9iamVjdCkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNF OwogICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJl cGFyZUZvckNhbGwoKSwgImVnbFN0cmVhbUNvbnN1bWVyUmVsZWFzZUtIUiIsCisgICAgICAgICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAg ICAgZXJyb3IgPSBzdHJlYW1PYmplY3QtPmNvbnN1bWVyUmVsZWFzZShjb250ZXh0KTsKICAgICBp ZiAoZXJyb3IuaXNFcnJvcigpKQogICAgIHsKQEAgLTgxMSw3ICs4MzAsOCBAQCBFR0xCb29sZWFu IEVHTEFQSUVOVFJZIEVHTF9TdHJlYW1Db25zdW1lckdMVGV4dHVyZUV4dGVybmFsQXR0cmlic05W KEVHTERpc3BsYXkgZAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN0cmVhbUlmVmFsaWQo ZGlzcGxheSwgc3RyZWFtT2JqZWN0KSk7CiAgICAgICAgIHJldHVybiBFR0xfRkFMU0U7CiAgICAg fQotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9y Q2FsbCgpLCAiZWdsU3RyZWFtQ29uc3VtZXJHTFRleHR1cmVFeHRlcm5hbEF0dHJpYnNOViIsCisg ICAgICAgICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9G QUxTRSk7CiAgICAgZXJyb3IgPSBzdHJlYW1PYmplY3QtPmNyZWF0ZUNvbnN1bWVyR0xUZXh0dXJl RXh0ZXJuYWwoYXR0cmlidXRlcywgY29udGV4dCk7CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkK ICAgICB7CkBAIC04NDUsNyArODY1LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfQ3Jl YXRlU3RyZWFtUHJvZHVjZXJEM0RUZXh0dXJlQU5HTEUoRUdMRGlzcGxheSBkcHksCiAgICAgICAg ICAgICAgICAgICAgICAgICAgR2V0U3RyZWFtSWZWYWxpZChkaXNwbGF5LCBzdHJlYW1PYmplY3Qp KTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9FR0xfVFJZ X1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xDcmVhdGVTdHJl YW1Qcm9kdWNlckQzRFRleHR1cmVBTkdMRSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgR2V0 RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgZXJyb3IgPSBzdHJlYW1P YmplY3QtPmNyZWF0ZVByb2R1Y2VyRDNEMTFUZXh0dXJlKGF0dHJpYnV0ZXMpOwogICAgIGlmIChl cnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtODgyLDcgKzkwMyw4IEBAIEVHTEJvb2xlYW4gRUdM QVBJRU5UUlkgRUdMX1N0cmVhbVBvc3REM0RUZXh0dXJlQU5HTEUoRUdMRGlzcGxheSBkcHksCiAg ICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3RyZWFtSWZWYWxpZChkaXNwbGF5LCBzdHJlYW1P YmplY3QpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJlZ2xTdHJl YW1Qb3N0RDNEVGV4dHVyZUFOR0xFIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBlcnJvciA9IHN0cmVhbU9iamVj dC0+cG9zdEQzRDExVGV4dHVyZSh0ZXh0dXJlLCBhdHRyaWJ1dGVzKTsKICAgICBpZiAoZXJyb3Iu aXNFcnJvcigpKQogICAgIHsKQEAgLTkxNSw3ICs5MzcsOCBAQCBBTkdMRV9FWFBPUlQgRUdMU3lu YyBFR0xBUElFTlRSWSBFR0xfQ3JlYXRlU3luY0tIUihFR0xEaXNwbGF5IGRweSwKICAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTigKICAgICAgICAgdGhyZWFkLCBWYWxpZGF0ZUNyZWF0ZVN5bmNLSFIo ZGlzcGxheSwgdHlwZSwgYXR0cmlidXRlcywgY3VycmVudERpc3BsYXksIGN1cnJlbnRDb250ZXh0 KSwKICAgICAgICAgImVnbENyZWF0ZVN5bmMiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwg RUdMX05PX1NZTkMpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5 LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsQ3JlYXRlU3luYyIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TWU5DKTsKICAgICBlZ2w6 OlN5bmMgKnN5bmNPYmplY3QgPSBudWxscHRyOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgZGlzcGxheS0+Y3JlYXRlU3luYyhjdXJyZW50Q29udGV4dCwgdHlwZSwgYXR0cmlidXRl cywgJnN5bmNPYmplY3QpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xDcmVhdGVTeW5j IiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9OT19TWU5DKTsKQEAgLTkzNiw3ICs5 NTksOCBAQCBBTkdMRV9FWFBPUlQgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfRGVzdHJveVN5 bmNLSFIoRUdMRGlzcGxheSBkcHksIEVHTFN5bmMgcwogCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRV Uk4odGhyZWFkLCBWYWxpZGF0ZURlc3Ryb3lTeW5jKGRpc3BsYXksIHN5bmNPYmplY3QpLCAiZWds RGVzdHJveVN5bmMiLAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlk KGRpc3BsYXkpLCBFR0xfRkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsRGVzdHJveVN5bmMiLAorICAgICAgICAg ICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwog ICAgIGRpc3BsYXktPmRlc3Ryb3lTeW5jKHN5bmNPYmplY3QpOwogCiAgICAgdGhyZWFkLT5zZXRT dWNjZXNzKCk7CkBAIC05NjAsNyArOTg0LDggQEAgQU5HTEVfRVhQT1JUIEVHTGludCBFR0xBUElF TlRSWSBFR0xfQ2xpZW50V2FpdFN5bmNLSFIoRUdMRGlzcGxheSBkcHksCiAKICAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlQ2xpZW50V2FpdFN5bmMoZGlzcGxheSwgc3lu Y09iamVjdCwgZmxhZ3MsIHRpbWVvdXQpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xD bGllbnRXYWl0U3luYyIsIEdldFN5bmNJZlZhbGlkKGRpc3BsYXksIHN5bmNPYmplY3QpLCBFR0xf RkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVw YXJlRm9yQ2FsbCgpLCAiZWdsQ2xpZW50V2FpdFN5bmMiLAorICAgICAgICAgICAgICAgICAgICAg ICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGdsOjpDb250 ZXh0ICpjdXJyZW50Q29udGV4dCA9IHRocmVhZC0+Z2V0Q29udGV4dCgpOwogICAgIEVHTGludCBz eW5jU3RhdHVzICAgICAgICAgICA9IEVHTF9GQUxTRTsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVS TigKQEAgLTk4OCw3ICsxMDEzLDggQEAgQU5HTEVfRVhQT1JUIEVHTEJvb2xlYW4gRUdMQVBJRU5U UlkgRUdMX0dldFN5bmNBdHRyaWJLSFIoRUdMRGlzcGxheSBkcHksCiAKICAgICBBTkdMRV9FR0xf VFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlR2V0U3luY0F0dHJpYktIUihkaXNwbGF5LCBzeW5j T2JqZWN0LCBhdHRyaWJ1dGUsIHZhbHVlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWds R2V0U3luY0F0dHJpYiIsIEdldFN5bmNJZlZhbGlkKGRpc3BsYXksIHN5bmNPYmplY3QpLCBFR0xf RkFMU0UpOwotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVw YXJlRm9yQ2FsbCgpLCAiZWdsR2V0U3luY0F0dHJpYiIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgQU5HTEVfRUdM X1RSWV9SRVRVUk4odGhyZWFkLCBHZXRTeW5jQXR0cmliKGRpc3BsYXksIHN5bmNPYmplY3QsIGF0 dHJpYnV0ZSwgdmFsdWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xHZXRTeW5jQXR0 cmliIiwgR2V0U3luY0lmVmFsaWQoZGlzcGxheSwgc3luY09iamVjdCksIEVHTF9GQUxTRSk7CiAK QEAgLTEwMTEsNyArMTAzNyw4IEBAIEFOR0xFX0VYUE9SVCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZ IEVHTF9XYWl0U3luY0tIUihFR0xEaXNwbGF5IGRweSwgRUdMU3luYyBzeW5jCiAKICAgICBBTkdM RV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRlV2FpdFN5bmMoZGlzcGxheSwgY29udGV4 dCwgc3luY09iamVjdCwgZmxhZ3MpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xXYWl0 U3luYyIsIEdldFN5bmNJZlZhbGlkKGRpc3BsYXksIHN5bmNPYmplY3QpLCBFR0xfRkFMU0UpOwot CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2Fs bCgpLCAiZWdsV2FpdFN5bmMiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGdsOjpDb250ZXh0ICpjdXJyZW50Q29u dGV4dCA9IHRocmVhZC0+Z2V0Q29udGV4dCgpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgc3luY09iamVjdC0+c2VydmVyV2FpdChkaXNwbGF5LCBjdXJyZW50Q29udGV4dCwgZmxh Z3MpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xXYWl0U3luYyIsIEdldFN5bmNJZlZh bGlkKGRpc3BsYXksIHN5bmNPYmplY3QpLCBFR0xfRkFMU0UpOwpAQCAtMTA0Myw3ICsxMDcwLDgg QEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0TXNjUmF0ZUFOR0xFKEVHTERpc3BsYXkg ZHB5LAogICAgICAgICAgICAgICAgICAgICAgICAgIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXks IGVnbFN1cmZhY2UpKTsKICAgICAgICAgcmV0dXJuIEVHTF9GQUxTRTsKICAgICB9Ci0KKyAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJl Z2xHZXRNc2NSYXRlQU5HTEUiLAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwogICAgIGVycm9yID0gZWdsU3VyZmFjZS0+Z2V0 TXNjUmF0ZShudW1lcmF0b3IsIGRlbm9taW5hdG9yKTsKICAgICBpZiAoZXJyb3IuaXNFcnJvcigp KQogICAgIHsKQEAgLTEwODAsNyArMTEwOCw4IEBAIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdM X0dldFN5bmNWYWx1ZXNDSFJPTUlVTShFR0xEaXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAg ICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSk7CiAgICAgICAg IHJldHVybiBFR0xfRkFMU0U7CiAgICAgfQotCisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhy ZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsR2V0U3luY1ZhbHVlc0NIUk9NSVVN IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwg RUdMX0ZBTFNFKTsKICAgICBlcnJvciA9IGVnbFN1cmZhY2UtPmdldFN5bmNWYWx1ZXModXN0LCBt c2MsIHNiYyk7CiAgICAgaWYgKGVycm9yLmlzRXJyb3IoKSkKICAgICB7CkBAIC0xMTE2LDcgKzEx NDUsOCBAQCBFR0xCb29sZWFuIEVHTEFQSUVOVFJZIEVHTF9Td2FwQnVmZmVyc1dpdGhEYW1hZ2VL SFIoRUdMRGlzcGxheSBkcHksCiAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0U3VyZmFjZUlm VmFsaWQoZGlzcGxheSwgZWdsU3VyZmFjZSkpOwogICAgICAgICByZXR1cm4gRUdMX0ZBTFNFOwog ICAgIH0KLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFy ZUZvckNhbGwoKSwgImVnbFN3YXBCdWZmZXJzV2l0aERhbWFnZUVYVCIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAg ZXJyb3IgPSBlZ2xTdXJmYWNlLT5zd2FwV2l0aERhbWFnZSh0aHJlYWQtPmdldENvbnRleHQoKSwg cmVjdHMsIG5fcmVjdHMpOwogICAgIGlmIChlcnJvci5pc0Vycm9yKCkpCiAgICAgewpAQCAtMTE0 NSw2ICsxMTc1LDggQEAgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfUHJlc2VudGF0aW9uVGlt ZUFORFJPSUQoRUdMRGlzcGxheSBkcHksCiAgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBWYWxpZGF0ZVByZXNlbnRhdGlvblRpbWVBTkRST0lEKGRpc3BsYXksIGVnbFN1cmZhY2UsIHRp bWUpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xQcmVzZW50YXRpb25UaW1lQU5EUk9J RCIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLAogICAgICAgICAgICAg ICAgICAgICAgICAgIEVHTF9GQUxTRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUHJlc2VudGF0aW9uVGltZUFORFJPSUQi LAorICAgICAgICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBF R0xfRkFMU0UpOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZWdsU3VyZmFjZS0+ c2V0UHJlc2VudGF0aW9uVGltZSh0aW1lKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWds UHJlc2VudGF0aW9uVGltZUFORFJPSUQiLCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xT dXJmYWNlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICBFR0xfRkFMU0UpOwpAQCAtMTE2Niw3 ICsxMTk4LDggQEAgQU5HTEVfRVhQT1JUIHZvaWQgRUdMQVBJRU5UUlkgRUdMX1NldEJsb2JDYWNo ZUZ1bmNzQU5EUk9JRChFR0xEaXNwbGF5IGRweSwKIAogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFk LCBWYWxpZGF0ZVNldEJsb2JDYWNoZUFORFJPSUQoZGlzcGxheSwgc2V0LCBnZXQpLAogICAgICAg ICAgICAgICAgICAgImVnbFNldEJsb2JDYWNoZUZ1bmNzQU5EUk9JRCIsIEdldERpc3BsYXlJZlZh bGlkKGRpc3BsYXkpKTsKLQorICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBkaXNwbGF5LT5wcmVw YXJlRm9yQ2FsbCgpLCAiZWdsU2V0QmxvYkNhY2hlRnVuY3NBTkRST0lEIiwKKyAgICAgICAgICAg ICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKICAgICB0aHJlYWQtPnNldFN1Y2Nl c3MoKTsKICAgICBkaXNwbGF5LT5zZXRCbG9iQ2FjaGVGdW5jcyhzZXQsIGdldCk7CiB9CkBAIC0x MTgxLDcgKzEyMTQsOCBAQCBFR0xpbnQgRUdMQVBJRU5UUlkgRUdMX1Byb2dyYW1DYWNoZUdldEF0 dHJpYkFOR0xFKEVHTERpc3BsYXkgZHB5LCBFR0xlbnVtIGF0dHJpYgogCiAgICAgQU5HTEVfRUdM X1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVByb2dyYW1DYWNoZUdldEF0dHJpYkFOR0xFKGRp c3BsYXksIGF0dHJpYiksCiAgICAgICAgICAgICAgICAgICAgICAgICAgImVnbFByb2dyYW1DYWNo ZUdldEF0dHJpYkFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSksIDApOwotCisgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAi ZWdsUHJvZ3JhbUNhY2hlR2V0QXR0cmliQU5HTEUiLAorICAgICAgICAgICAgICAgICAgICAgICAg IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCAwKTsKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3Mo KTsKICAgICByZXR1cm4gZGlzcGxheS0+cHJvZ3JhbUNhY2hlR2V0QXR0cmliKGF0dHJpYik7CiB9 CkBAIC0xMjA2LDcgKzEyNDAsOCBAQCB2b2lkIEVHTEFQSUVOVFJZIEVHTF9Qcm9ncmFtQ2FjaGVR dWVyeUFOR0xFKEVHTERpc3BsYXkgZHB5LAogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLAogICAg ICAgICAgICAgICAgICAgVmFsaWRhdGVQcm9ncmFtQ2FjaGVRdWVyeUFOR0xFKGRpc3BsYXksIGlu ZGV4LCBrZXksIGtleXNpemUsIGJpbmFyeSwgYmluYXJ5c2l6ZSksCiAgICAgICAgICAgICAgICAg ICAiZWdsUHJvZ3JhbUNhY2hlUXVlcnlBTkdMRSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp KTsKLQorICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgp LCAiZWdsUHJvZ3JhbUNhY2hlUXVlcnlBTkdMRSIsCisgICAgICAgICAgICAgICAgICBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXkt PnByb2dyYW1DYWNoZVF1ZXJ5KGluZGV4LCBrZXksIGtleXNpemUsIGJpbmFyeSwgYmluYXJ5c2l6 ZSksCiAgICAgICAgICAgICAgICAgICAiZWdsUHJvZ3JhbUNhY2hlUXVlcnlBTkdMRSIsIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKIApAQCAtMTIzMSw3ICsxMjY2LDggQEAgdm9pZCBFR0xB UElFTlRSWSBFR0xfUHJvZ3JhbUNhY2hlUG9wdWxhdGVBTkdMRShFR0xEaXNwbGF5IGRweSwKICAg ICBBTkdMRV9FR0xfVFJZKHRocmVhZCwKICAgICAgICAgICAgICAgICAgIFZhbGlkYXRlUHJvZ3Jh bUNhY2hlUG9wdWxhdGVBTkdMRShkaXNwbGF5LCBrZXksIGtleXNpemUsIGJpbmFyeSwgYmluYXJ5 c2l6ZSksCiAgICAgICAgICAgICAgICAgICAiZWdsUHJvZ3JhbUNhY2hlUG9wdWxhdGVBTkdMRSIs IEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpKTsKLQorICAgIEFOR0xFX0VHTF9UUlkodGhyZWFk LCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsUHJvZ3JhbUNhY2hlUG9wdWxhdGVBTkdM RSIsCisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSk7CiAgICAg QU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPnByb2dyYW1DYWNoZVBvcHVsYXRlKGtleSwg a2V5c2l6ZSwgYmluYXJ5LCBiaW5hcnlzaXplKSwKICAgICAgICAgICAgICAgICAgICJlZ2xQcm9n cmFtQ2FjaGVQb3B1bGF0ZUFOR0xFIiwgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogCkBA IC0xMjQ5LDcgKzEyODUsOCBAQCBFR0xpbnQgRUdMQVBJRU5UUlkgRUdMX1Byb2dyYW1DYWNoZVJl c2l6ZUFOR0xFKEVHTERpc3BsYXkgZHB5LCBFR0xpbnQgbGltaXQsIEVHTAogCiAgICAgQU5HTEVf RUdMX1RSWV9SRVRVUk4odGhyZWFkLCBWYWxpZGF0ZVByb2dyYW1DYWNoZVJlc2l6ZUFOR0xFKGRp c3BsYXksIGxpbWl0LCBtb2RlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsUHJvZ3Jh bUNhY2hlUmVzaXplQU5HTEUiLCBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgMCk7Ci0KKyAg ICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCks ICJlZ2xQcm9ncmFtQ2FjaGVSZXNpemVBTkdMRSIsCisgICAgICAgICAgICAgICAgICBHZXREaXNw bGF5SWZWYWxpZChkaXNwbGF5KSwgMCk7CiAgICAgdGhyZWFkLT5zZXRTdWNjZXNzKCk7CiAgICAg cmV0dXJuIGRpc3BsYXktPnByb2dyYW1DYWNoZVJlc2l6ZShsaW1pdCwgbW9kZSk7CiB9CkBAIC0x MzQwLDcgKzEzNzcsMTMgQEAgRUdMaW50IEVHTEFQSUVOVFJZIEVHTF9MYWJlbE9iamVjdEtIUihF R0xEaXNwbGF5IGRweSwKICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRMYWJlbGVkT2JqZWN0 SWZWYWxpZCh0aHJlYWQsIGRpc3BsYXksIG9iamVjdFR5cGVQYWNrZWQsIG9iamVjdCkpOwogICAg ICAgICByZXR1cm4gZXJyb3IuZ2V0Q29kZSgpOwogICAgIH0KLQorICAgIGVycm9yID0gZGlzcGxh eS0+cHJlcGFyZUZvckNhbGwoKTsKKyAgICBpZiAoZXJyb3IuaXNFcnJvcigpKQorICAgIHsKKyAg ICAgICAgdGhyZWFkLT5zZXRFcnJvcihlcnJvciwgR2V0RGVidWcoKSwgImVnbExhYmVsT2JqZWN0 S0hSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5 KSk7CisgICAgICAgIHJldHVybiBlcnJvci5nZXRDb2RlKCk7CisgICAgfQogICAgIExhYmVsZWRP YmplY3QgKmxhYmVsZWRPYmplY3QgPQogICAgICAgICBHZXRMYWJlbGVkT2JqZWN0SWZWYWxpZCh0 aHJlYWQsIGRpc3BsYXksIG9iamVjdFR5cGVQYWNrZWQsIG9iamVjdCk7CiAgICAgQVNTRVJUKGxh YmVsZWRPYmplY3QgIT0gbnVsbHB0cik7CkBAIC0xMzk0LDYgKzE0MzcsOCBAQCBBTkdMRV9FWFBP UlQgRUdMQm9vbGVhbiBFR0xBUElFTlRSWSBFR0xfR2V0Q29tcG9zaXRvclRpbWluZ0FORFJPSUQo RUdMRGlzcGxheSBkcAogICAgICAgICB0aHJlYWQsCiAgICAgICAgIFZhbGlkYXRlR2V0Q29tcG9z aXRvclRpbWluZ0FORFJPSUQoZGlzcGxheSwgZWdsU3VyZmFjZSwgbnVtVGltZXN0YW1wcywgbmFt ZXMsIHZhbHVlcyksCiAgICAgICAgICJlZ2xHZXRDb21wb3NpdG9yVGltaW5nQU5EUk9JREQiLCBH ZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKKyAgICBB TkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCksICJl Z2xHZXRDb21wb3NpdG9yVGltaW5nQU5EUk9JREQiLAorICAgICAgICAgICAgICAgICAgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSksIEVHTF9GQUxTRSk7CiAgICAgQU5HTEVfRUdMX1RSWV9SRVRV Uk4odGhyZWFkLCBlZ2xTdXJmYWNlLT5nZXRDb21wb3NpdG9yVGltaW5nKG51bVRpbWVzdGFtcHMs IG5hbWVzLCB2YWx1ZXMpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xHZXRDb21wb3Np dG9yVGltaW5nQU5EUk9JREQiLCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNl KSwKICAgICAgICAgICAgICAgICAgICAgICAgICBFR0xfRkFMU0UpOwpAQCAtMTQxOCw2ICsxNDYz LDggQEAgQU5HTEVfRVhQT1JUIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0dldE5leHRGcmFt ZUlkQU5EUk9JRChFR0xEaXNwbGF5IGRweSwKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJl YWQsIFZhbGlkYXRlR2V0TmV4dEZyYW1lSWRBTkRST0lEKGRpc3BsYXksIGVnbFN1cmZhY2UsIGZy YW1lSWQpLAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xHZXROZXh0RnJhbWVJZEFORFJP SUQiLCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwKICAgICAgICAgICAg ICAgICAgICAgICAgICBFR0xfRkFMU0UpOworICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVh ZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbEdldE5leHRGcmFtZUlkQU5EUk9JRCIs CisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNF KTsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIGVnbFN1cmZhY2UtPmdldE5leHRG cmFtZUlkKGZyYW1lSWQpLCAiZWdsR2V0TmV4dEZyYW1lSWRBTkRST0lEIiwKICAgICAgICAgICAg ICAgICAgICAgICAgICBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdM X0ZBTFNFKTsKIApAQCAtMTQ0Myw3ICsxNDkwLDggQEAgQU5HTEVfRVhQT1JUIEVHTEJvb2xlYW4g RUdMQVBJRU5UUlkgRUdMX0dldEZyYW1lVGltZXN0YW1wU3VwcG9ydGVkQU5EUk9JRChFR0xEaXMK ICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTigKICAgICAgICAgdGhyZWFkLCBWYWxpZGF0ZUdldEZy YW1lVGltZXN0YW1wU3VwcG9ydGVkQU5EUk9JRChkaXNwbGF5LCBlZ2xTdXJmYWNlLCB0aW1lc3Rh bXBJbnRlcm5hbCksCiAgICAgICAgICJlZ2xRdWVyeVRpbWVzdGFtcFN1cHBvcnRlZEFORFJPSUQi LCBHZXRTdXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKLQor ICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwo KSwgImVnbFF1ZXJ5VGltZXN0YW1wU3VwcG9ydGVkQU5EUk9JRCIsCisgICAgICAgICAgICAgICAg ICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICB0aHJlYWQtPnNl dFN1Y2Nlc3MoKTsKICAgICByZXR1cm4gZWdsU3VyZmFjZS0+Z2V0U3VwcG9ydGVkVGltZXN0YW1w cygpLnRlc3QodGltZXN0YW1wSW50ZXJuYWwpOwogfQpAQCAtMTQ3Miw2ICsxNTIwLDggQEAgQU5H TEVfRVhQT1JUIEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX0dldEZyYW1lVGltZXN0YW1wc0FO RFJPSUQoRUdMRGlzcGxheSBkcHkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgbnVtVGltZXN0YW1wcywgdGltZXN0YW1wcywgdmFsdWVz KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsR2V0RnJhbWVUaW1lc3RhbXBzQU5EUk9J RCIsIEdldFN1cmZhY2VJZlZhbGlkKGRpc3BsYXksIGVnbFN1cmZhY2UpLAogICAgICAgICAgICAg ICAgICAgICAgICAgIEVHTF9GQUxTRSk7CisgICAgQU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFk LCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsR2V0RnJhbWVUaW1lc3RhbXBzQU5EUk9J RCIsCisgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZB TFNFKTsKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTigKICAgICAgICAgdGhyZWFkLCBlZ2xTdXJm YWNlLT5nZXRGcmFtZVRpbWVzdGFtcHMoZnJhbWVJZCwgbnVtVGltZXN0YW1wcywgdGltZXN0YW1w cywgdmFsdWVzKSwKICAgICAgICAgImVnbEdldEZyYW1lVGltZXN0YW1wc0FORFJPSUQiLCBHZXRT dXJmYWNlSWZWYWxpZChkaXNwbGF5LCBlZ2xTdXJmYWNlKSwgRUdMX0ZBTFNFKTsKQEAgLTE0OTQs NyArMTU0NCw4IEBAIEFOR0xFX0VYUE9SVCBjb25zdCBjaGFyICpFR0xBUElFTlRSWSBFR0xfUXVl cnlTdHJpbmdpQU5HTEUoRUdMRGlzcGxheSBkcHksCiAKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVS Tih0aHJlYWQsIFZhbGlkYXRlUXVlcnlTdHJpbmdpQU5HTEUoZGlzcGxheSwgbmFtZSwgaW5kZXgp LAogICAgICAgICAgICAgICAgICAgICAgICAgICJlZ2xRdWVyeVN0cmluZ2lBTkdMRSIsIEdldERp c3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBudWxscHRyKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVU VVJOKHRocmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbFF1ZXJ5U3RyaW5naUFO R0xFIiwKKyAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBudWxs cHRyKTsKICAgICB0aHJlYWQtPnNldFN1Y2Nlc3MoKTsKICAgICByZXR1cm4gZGlzcGxheS0+cXVl cnlTdHJpbmdpKG5hbWUsIGluZGV4KTsKIH0KQEAgLTE1MjYsNyArMTU3Nyw4IEBAIEVHTGludCBF R0xBUElFTlRSWSBFR0xfRHVwTmF0aXZlRmVuY2VGREFORFJPSUQoRUdMRGlzcGxheSBkcHksIEVH TFN5bmNLSFIgc3luYykKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTih0aHJlYWQsIFZhbGlkYXRl RHVwTmF0aXZlRmVuY2VGREFORFJPSUQoZGlzcGxheSwgc3luY09iamVjdCksCiAgICAgICAgICAg ICAgICAgICAgICAgICAgImVnbER1cE5hdGl2ZUZlbmNlRkRBTkRST0lEIiwgR2V0U3luY0lmVmFs aWQoZGlzcGxheSwgc3luY09iamVjdCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgRUdMX05P X05BVElWRV9GRU5DRV9GRF9BTkRST0lEKTsKLQorICAgIEFOR0xFX0VHTF9UUllfUkVUVVJOKHRo cmVhZCwgZGlzcGxheS0+cHJlcGFyZUZvckNhbGwoKSwgImVnbER1cE5hdGl2ZUZlbmNlRkRBTkRS T0lEIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5 KSwgRUdMX05PX05BVElWRV9GRU5DRV9GRF9BTkRST0lEKTsKICAgICBFR0xpbnQgcmVzdWx0ID0g RUdMX05PX05BVElWRV9GRU5DRV9GRF9BTkRST0lEOwogICAgIEFOR0xFX0VHTF9UUllfUkVUVVJO KHRocmVhZCwgc3luY09iamVjdC0+ZHVwTmF0aXZlRmVuY2VGRChkaXNwbGF5LCAmcmVzdWx0KSwK ICAgICAgICAgICAgICAgICAgICAgICAgICAiZWdsRHVwTmF0aXZlRmVuY2VGREFORFJPSUQiLCBH ZXRTeW5jSWZWYWxpZChkaXNwbGF5LCBzeW5jT2JqZWN0KSwKQEAgLTE1NTIsNyArMTYwNCw4IEBA IEVHTEJvb2xlYW4gRUdMQVBJRU5UUlkgRUdMX1N3YXBCdWZmZXJzV2l0aEZyYW1lVG9rZW5BTkdM RShFR0xEaXNwbGF5IGRweSwKICAgICBBTkdMRV9FR0xfVFJZX1JFVFVSTigKICAgICAgICAgdGhy ZWFkLCBWYWxpZGF0ZVN3YXBCdWZmZXJzV2l0aEZyYW1lVG9rZW5BTkdMRShkaXNwbGF5LCBlZ2xT dXJmYWNlLCBmcmFtZXRva2VuKSwKICAgICAgICAgImVnbFN3YXBCdWZmZXJzV2l0aEZyYW1lVG9r ZW5BTkdMRSIsIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkpLCBFR0xfRkFMU0UpOwotCisgICAg QU5HTEVfRUdMX1RSWV9SRVRVUk4odGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAi ZWdsU3dhcEJ1ZmZlcnNXaXRoRnJhbWVUb2tlbkFOR0xFIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5KSwgRUdMX0ZBTFNFKTsKICAgICBBTkdMRV9F R0xfVFJZX1JFVFVSTih0aHJlYWQsIGVnbFN1cmZhY2UtPnN3YXBXaXRoRnJhbWVUb2tlbih0aHJl YWQtPmdldENvbnRleHQoKSwgZnJhbWV0b2tlbiksCiAgICAgICAgICAgICAgICAgICAgICAgICAg ImVnbFN3YXBCdWZmZXJzV2l0aEZyYW1lVG9rZW5BTkdMRSIsIEdldERpc3BsYXlJZlZhbGlkKGRp c3BsYXkpLAogICAgICAgICAgICAgICAgICAgICAgICAgIEVHTF9GQUxTRSk7CkBAIC0xNTczLDYg KzE2MjYsOCBAQCB2b2lkIEVHTEFQSUVOVFJZIEVHTF9SZWxlYXNlSGlnaFBvd2VyR1BVQU5HTEUo RUdMRGlzcGxheSBkcHksIEVHTENvbnRleHQgY3R4KQogCiAgICAgQU5HTEVfRUdMX1RSWSh0aHJl YWQsIFZhbGlkYXRlQ29udGV4dChkaXNwbGF5LCBjb250ZXh0KSwgImVnbFJlbGVhc2VIaWdoUG93 ZXJHUFVBTkdMRSIsCiAgICAgICAgICAgICAgICAgICBHZXREaXNwbGF5SWZWYWxpZChkaXNwbGF5 KSk7CisgICAgQU5HTEVfRUdMX1RSWSh0aHJlYWQsIGRpc3BsYXktPnByZXBhcmVGb3JDYWxsKCks ICJlZ2xSZWxlYXNlSGlnaFBvd2VyR1BVQU5HTEUiLAorICAgICAgICAgICAgICAgICAgR2V0RGlz cGxheUlmVmFsaWQoZGlzcGxheSkpOwogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBjb250ZXh0 LT5yZWxlYXNlSGlnaFBvd2VyR1BVKCksICJlZ2xSZWxlYXNlSGlnaFBvd2VyR1BVQU5HTEUiLAog ICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogCkBAIC0xNTkx LDYgKzE2NDYsOCBAQCB2b2lkIEVHTEFQSUVOVFJZIEVHTF9SZWFjcXVpcmVIaWdoUG93ZXJHUFVB TkdMRShFR0xEaXNwbGF5IGRweSwgRUdMQ29udGV4dCBjdHgpCiAKICAgICBBTkdMRV9FR0xfVFJZ KHRocmVhZCwgVmFsaWRhdGVDb250ZXh0KGRpc3BsYXksIGNvbnRleHQpLCAiZWdsUmVhY3F1aXJl SGlnaFBvd2VyR1BVQU5HTEUiLAogICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQo ZGlzcGxheSkpOworICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9y Q2FsbCgpLCAiZWdsUmVhY3F1aXJlSGlnaFBvd2VyR1BVQU5HTEUiLAorICAgICAgICAgICAgICAg ICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOwogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFk LCBjb250ZXh0LT5yZWFjcXVpcmVIaWdoUG93ZXJHUFUoKSwgImVnbFJlYWNxdWlyZUhpZ2hQb3dl ckdQVUFOR0xFIiwKICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJZlZhbGlkKGRpc3BsYXkp KTsKIApAQCAtMTYwNyw2ICsxNjY0LDggQEAgdm9pZCBFR0xBUElFTlRSWSBFR0xfSGFuZGxlR1BV U3dpdGNoQU5HTEUoRUdMRGlzcGxheSBkcHkpCiAKICAgICBBTkdMRV9FR0xfVFJZKHRocmVhZCwg VmFsaWRhdGVEaXNwbGF5KGRpc3BsYXkpLCAiZWdsSGFuZGxlR1BVU3dpdGNoQU5HTEUiLAogICAg ICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkpOworICAgIEFOR0xFX0VH TF9UUlkodGhyZWFkLCBkaXNwbGF5LT5wcmVwYXJlRm9yQ2FsbCgpLCAiZWdsSGFuZGxlR1BVU3dp dGNoQU5HTEUiLAorICAgICAgICAgICAgICAgICAgR2V0RGlzcGxheUlmVmFsaWQoZGlzcGxheSkp OwogICAgIEFOR0xFX0VHTF9UUlkodGhyZWFkLCBkaXNwbGF5LT5oYW5kbGVHUFVTd2l0Y2goKSwg ImVnbEhhbmRsZUdQVVN3aXRjaEFOR0xFIiwKICAgICAgICAgICAgICAgICAgIEdldERpc3BsYXlJ ZlZhbGlkKGRpc3BsYXkpKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ29uZmlndXJh dGlvbnMvV2ViQ29yZS54Y2NvbmZpZyBiL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3VyYXRpb25zL1dl YkNvcmUueGNjb25maWcKaW5kZXggNTcxZThlYjA3MDYwYzE5N2NjM2U5NTQxMWJiYTQzNzU3ZTg1 MWI1OS4uNTBmZjU1ODg2MDA5NjgxN2RhZWM4OGM1YWM2YmMxNjMyOWU0MWIxZiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvQ29uZmlndXJhdGlvbnMvV2ViQ29yZS54Y2NvbmZpZworKysgYi9T b3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9XZWJDb3JlLnhjY29uZmlnCkBAIC00OCw3ICs0 OCw3IEBAIFdLX0xJQldFQlJUQ19MSUJSQVJZX0RJUl9VU0VfT1ZFUlJJREVfRlJBTUVXT1JLU19E SVJfWUVTID0gJChXS19PVkVSUklERV9GUkFNRVdPCiBMSUJSQVJZX1NFQVJDSF9QQVRIUyA9ICQo aW5oZXJpdGVkKSAiJChXS19MSUJXRUJSVENfTElCUkFSWV9ESVIpIjsKIAogV0VCS0lUQURESVRJ T05TX0hFQURFUl9TRUFSQ0hfUEFUSFMgPSAkKEJVSUxUX1BST0RVQ1RTX0RJUikvdXNyL2xvY2Fs L2luY2x1ZGUvV2ViS2l0QWRkaXRpb25zICQoU0RLUk9PVCkvdXNyL2xvY2FsL2luY2x1ZGUvV2Vi S2l0QWRkaXRpb25zOwotQU5HTEVfSEVBREVSX1NFQVJDSF9QQVRIUyA9ICQoQlVJTFRfUFJPRFVD VFNfRElSKS91c3IvbG9jYWwvaW5jbHVkZS9BTkdMRSAkKFNES1JPT1QpL3Vzci9sb2NhbC9pbmNs dWRlL0FOR0xFOworQU5HTEVfSEVBREVSX1NFQVJDSF9QQVRIUyA9ICQoQlVJTFRfUFJPRFVDVFNf RElSKSQoV0tfQUxURVJOQVRFX0ZSQU1FV09SS1NfRElSKS91c3IvbG9jYWwvaW5jbHVkZS8gJChT REtST09UKSQoV0tfQUxURVJOQVRFX1dFQktJVF9TREtfUEFUSCkvdXNyL2xvY2FsL2luY2x1ZGUv OwogTElCV0VCUlRDX0hFQURFUl9TRUFSQ0hfUEFUSFMgPSAkKEJVSUxUX1BST0RVQ1RTX0RJUikv dXNyL2xvY2FsL2luY2x1ZGUvd2VicnRjICQoU0RLUk9PVCkvdXNyL2xvY2FsL2luY2x1ZGUvd2Vi cnRjICQoQlVJTFRfUFJPRFVDVFNfRElSKS91c3IvbG9jYWwvaW5jbHVkZS93ZWJydGMvc2RrL29i amMvRnJhbWV3b3JrL0hlYWRlcnMgJChTREtST09UKS91c3IvbG9jYWwvaW5jbHVkZS93ZWJydGMv c2RrL29iamMvRnJhbWV3b3JrL0hlYWRlcnM7CiAKIEhFQURFUl9TRUFSQ0hfUEFUSFMgPSBQQUwg Rm9yd2FyZGluZ0hlYWRlcnMgL3Vzci9pbmNsdWRlL2xpYnhzbHQgL3Vzci9pbmNsdWRlL2xpYnht bDIgIiQoQlVJTFRfUFJPRFVDVFNfRElSKS9EZXJpdmVkU291cmNlcy9XZWJDb3JlIiAiJChCVUlM VF9QUk9EVUNUU19ESVIpL3Vzci9sb2NhbC9pbmNsdWRlIiAkKFdFQktJVEFERElUSU9OU19IRUFE RVJfU0VBUkNIX1BBVEhTKSAkKEFOR0xFX0hFQURFUl9TRUFSQ0hfUEFUSFMpICQoTElCV0VCUlRD X0hFQURFUl9TRUFSQ0hfUEFUSFMpICQoSEVBREVSX1NFQVJDSF9QQVRIUykgJChTUkNST09UKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL0dyYXBo aWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW0gYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jb2NvYS9HcmFwaGljc0NvbnRleHRHTE9wZW5HTENvY29hLm1tCmluZGV4IGMyMjFjMTQ2 MTUzN2ViOWU4MDc3MjQ2YjM5ZGI4N2YzNTQzZjg3ODMuLjM4ZTdmOGI3OGQ1Nzc0ZWIyMzhmM2M0 MzBiM2QzYzc1MjIwNWIxYTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2NvY29hL0dyYXBoaWNzQ29udGV4dEdMT3BlbkdMQ29jb2EubW0KKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0xD b2NvYS5tbQpAQCAtODAsNiArODAsOCBAQCB0eXBlZGVmIHZvaWQqIEdMZWdsQ29udGV4dDsKICNp bXBvcnQgIkV4dGVuc2lvbnNHTE9wZW5HTC5oIgogI2VsaWYgVVNFKEFOR0xFKQogI2ltcG9ydCAi RXh0ZW5zaW9uc0dMQU5HTEUuaCIKKyNpbXBvcnQgIlJ1bnRpbWVBcHBsaWNhdGlvbkNoZWNrcy5o IgorI2ltcG9ydCAiV2ViQ29yZVRocmVhZC5oIgogI2VuZGlmCiAKICNpZiBQTEFURk9STShNQUMp CkBAIC05MSw2ICs5Myw2OSBAQCB0eXBlZGVmIHZvaWQqIEdMZWdsQ29udGV4dDsKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCituYW1lc3BhY2UgeworCisjaWYgVVNFKEFOR0xFKQorCisjaWYgQVNT RVJUX0VOQUJMRUQKKy8vIFJldHVybnMgdHJ1ZSBpZiB3ZSBoYXZlIHZvbGF0aWxlIGNvbnRleHQg ZXh0ZW5zaW9uIGZvciB0aGUgcGFydGljdWxhciBBUEkgb3IKKy8vIGlmIHRoZSBwYXJ0aWN1bGFy IEFQSSBpcyBub3QgdXNlZC4KK2Jvb2wgY2hlY2tWb2xhdGlsZUNvbnRleHRTdXBwb3J0SWZEZXZp Y2VFeGlzdHMoRUdMRGlzcGxheSBkaXNwbGF5LCBjb25zdCBjaGFyKiBkZXZpY2VDb250ZXh0Vm9s YXRpbGVFeHRlbnNpb24sCisgICAgY29uc3QgY2hhciogZGV2aWNlQ29udGV4dEV4dGVuc2lvbiwg RUdMaW50IGRldmljZUNvbnRleHRUeXBlKQoreworICAgIGNvbnN0IGNoYXIgKmNsaWVudEV4dGVu c2lvbnMgPSBFR0xfUXVlcnlTdHJpbmcoRUdMX05PX0RJU1BMQVksIEVHTF9FWFRFTlNJT05TKTsK KyAgICBpZiAoY2xpZW50RXh0ZW5zaW9ucyAmJiBzdHJzdHIoY2xpZW50RXh0ZW5zaW9ucywgZGV2 aWNlQ29udGV4dFZvbGF0aWxlRXh0ZW5zaW9uKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAg RUdMRGV2aWNlRVhUIGRldmljZSA9IEVHTF9OT19ERVZJQ0VfRVhUOworICAgIGlmICghRUdMX1F1 ZXJ5RGlzcGxheUF0dHJpYkVYVChkaXNwbGF5LCBFR0xfREVWSUNFX0VYVCwgcmVpbnRlcnByZXRf Y2FzdDxFR0xBdHRyaWIqPigmZGV2aWNlKSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIGlm IChkZXZpY2UgPT0gRUdMX05PX0RFVklDRV9FWFQpCisgICAgICAgIHJldHVybiB0cnVlOworICAg IGNvbnN0IGNoYXIqIGRldmljZUV4dGVuc2lvbnMgPSBFR0xfUXVlcnlEZXZpY2VTdHJpbmdFWFQo ZGV2aWNlLCBFR0xfRVhURU5TSU9OUyk7CisgICAgaWYgKCFkZXZpY2VFeHRlbnNpb25zIHx8ICFz dHJzdHIoZGV2aWNlRXh0ZW5zaW9ucywgZGV2aWNlQ29udGV4dEV4dGVuc2lvbikpCisgICAgICAg IHJldHVybiB0cnVlOworICAgIHZvaWQqIGRldmljZUNvbnRleHQgPSBudWxscHRyOworICAgIGlm ICghRUdMX1F1ZXJ5RGV2aWNlQXR0cmliRVhUKGRldmljZSwgZGV2aWNlQ29udGV4dFR5cGUsIHJl aW50ZXJwcmV0X2Nhc3Q8RUdMQXR0cmliKj4oJmRldmljZUNvbnRleHQpKSkKKyAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgcmV0dXJuICFkZXZpY2VDb250ZXh0OworfQorI2VuZGlmCisKK0VHTERp c3BsYXkgSW5pdGlhbGl6ZUVHTERpc3BsYXkoKQoreworICAgIEVHTGludCBtYWpvclZlcnNpb24g PSAwOworICAgIEVHTGludCBtaW5vclZlcnNpb24gPSAwOworICAgIEVHTERpc3BsYXkgZGlzcGxh eTsKKyAgICBib29sIHNob3VsZEluaXRpYWxpemVXaXRoVm9sYXRpbGVDb250ZXh0U3VwcG9ydCA9 ICFpc0luV2ViUHJvY2VzcygpOworICAgIGlmIChzaG91bGRJbml0aWFsaXplV2l0aFZvbGF0aWxl Q29udGV4dFN1cHBvcnQpIHsKKyAgICAgICAgLy8gRm9yIFdLMSB0eXBlIEFQSXMgd2UgbmVlZCB0 byBzZXQgInZvbGF0aWxlIHBsYXRmb3JtIGNvbnRleHQiIGZvciBzcGVjaWZpYworICAgICAgICAv LyBBUElzLCBzaW5jZSBjbGllbnQgY29kZSB3aWxsIGJlIGFibGUgdG8gb3ZlcnJpZGUgdGhlIHRo cmVhZC1nbG9iYWwgY29udGV4dAorICAgICAgICAvLyB0aGF0IEFOR0xFIGV4cGVjdHMuCisgICAg ICAgIEVHTGludCBkaXNwbGF5QXR0cmlidXRlc1tdID0geworICAgICAgICAgICAgRUdMX1BMQVRG T1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0VBR0xfQU5HTEUsIEVHTF9UUlVFLAor ICAgICAgICAgICAgRUdMX1BMQVRGT1JNX0FOR0xFX0RFVklDRV9DT05URVhUX1ZPTEFUSUxFX0NH TF9BTkdMRSwgRUdMX1RSVUUsCisgICAgICAgICAgICBFR0xfTk9ORQorICAgICAgICB9OworICAg ICAgICBkaXNwbGF5ID0gRUdMX0dldFBsYXRmb3JtRGlzcGxheUVYVChFR0xfUExBVEZPUk1fQU5H TEVfQU5HTEUsIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCAqPihFR0xfREVGQVVMVF9ESVNQTEFZKSwg ZGlzcGxheUF0dHJpYnV0ZXMpOworICAgIH0gZWxzZQorICAgICAgICBkaXNwbGF5ID0gRUdMX0dl dERpc3BsYXkoRUdMX0RFRkFVTFRfRElTUExBWSk7CisKKyAgICBpZiAoRUdMX0luaXRpYWxpemUo ZGlzcGxheSwgJm1ham9yVmVyc2lvbiwgJm1pbm9yVmVyc2lvbikgPT0gRUdMX0ZBTFNFKSB7Cisg ICAgICAgIExPRyhXZWJHTCwgIkVHTERpc3BsYXkgSW5pdGlhbGl6YXRpb24gZmFpbGVkLiIpOwor ICAgICAgICByZXR1cm4gRUdMX05PX0RJU1BMQVk7CisgICAgfQorICAgIExPRyhXZWJHTCwgIkFO R0xFIGluaXRpYWxpc2VkIE1ham9yOiAlZCBNaW5vcjogJWQiLCBtYWpvclZlcnNpb24sIG1pbm9y VmVyc2lvbik7CisgICAgaWYgKHNob3VsZEluaXRpYWxpemVXaXRoVm9sYXRpbGVDb250ZXh0U3Vw cG9ydCkgeworICAgICAgICAvLyBBZnRlciBpbml0aWFsaXphdGlvbiwgRUdMX0RFRkFVTFRfRElT UExBWSB3aWxsIHJldHVybiB0aGUgcGxhdGZvcm0tY3VzdG9taXplZCBkaXNwbGF5LgorICAgICAg ICBBU1NFUlQoZGlzcGxheSA9PSBFR0xfR2V0RGlzcGxheShFR0xfREVGQVVMVF9ESVNQTEFZKSk7 CisgICAgICAgIEFTU0VSVChjaGVja1ZvbGF0aWxlQ29udGV4dFN1cHBvcnRJZkRldmljZUV4aXN0 cyhkaXNwbGF5LCAiRUdMX0FOR0xFX3BsYXRmb3JtX2RldmljZV9jb250ZXh0X3ZvbGF0aWxlX2Vh Z2wiLCAiRUdMX0FOR0xFX2RldmljZV9lYWdsIiwgRUdMX0VBR0xfQ09OVEVYVF9BTkdMRSkpOwor ICAgICAgICBBU1NFUlQoY2hlY2tWb2xhdGlsZUNvbnRleHRTdXBwb3J0SWZEZXZpY2VFeGlzdHMo ZGlzcGxheSwgIkVHTF9BTkdMRV9wbGF0Zm9ybV9kZXZpY2VfY29udGV4dF92b2xhdGlsZV9jZ2wi LCAiRUdMX0FOR0xFX2RldmljZV9jZ2wiLCBFR0xfQ0dMX0NPTlRFWFRfQU5HTEUpKTsKKyAgICB9 CisgICAgcmV0dXJuIGRpc3BsYXk7Cit9CisjZW5kaWYKK30KKwogc3RhdGljIGNvbnN0IHVuc2ln bmVkIHN0YXR1c0NoZWNrVGhyZXNob2xkID0gNTsKIAogLy8gRklYTUU6IFRoaXMgY2xhc3MgaXMg Y3VycmVudGx5IGVtcHR5IG9uIE1hYywgYnV0IHdpbGwgZ2V0IHBvcHVsYXRlZCBhcwpAQCAtMzE2 LDE2ICszODEsOSBAQCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6R3JhcGhpY3NDb250ZXh0R0xP cGVuR0woR3JhcGhpY3NDb250ZXh0R0xBdHRyaWJ1dGVzIGF0dAogICAgICAgICA6OmdsRW5hYmxl KEdyYXBoaWNzQ29udGV4dEdMOjpQUklNSVRJVkVfUkVTVEFSVCk7CiAKICNlbGlmIFVTRShBTkdM RSkKLQotICAgIG1fZGlzcGxheU9iaiA9IEVHTF9HZXREaXNwbGF5KEVHTF9ERUZBVUxUX0RJU1BM QVkpOworICAgIG1fZGlzcGxheU9iaiA9IEluaXRpYWxpemVFR0xEaXNwbGF5KCk7CiAgICAgaWYg KG1fZGlzcGxheU9iaiA9PSBFR0xfTk9fRElTUExBWSkKICAgICAgICAgcmV0dXJuOwotICAgIEVH TGludCBtYWpvclZlcnNpb24sIG1pbm9yVmVyc2lvbjsKLSAgICBpZiAoRUdMX0luaXRpYWxpemUo bV9kaXNwbGF5T2JqLCAmbWFqb3JWZXJzaW9uLCAmbWlub3JWZXJzaW9uKSA9PSBFR0xfRkFMU0Up IHsKLSAgICAgICAgTE9HKFdlYkdMLCAiRUdMRGlzcGxheSBJbml0aWFsaXphdGlvbiBmYWlsZWQu Iik7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0gICAgTE9HKFdlYkdMLCAiQU5HTEUgaW5pdGlh bGlzZWQgTWFqb3I6ICVkIE1pbm9yOiAlZCIsIG1ham9yVmVyc2lvbiwgbWlub3JWZXJzaW9uKTsK ICAgICBjb25zdCBjaGFyICpkaXNwbGF5RXh0ZW5zaW9ucyA9IEVHTF9RdWVyeVN0cmluZyhtX2Rp c3BsYXlPYmosIEVHTF9FWFRFTlNJT05TKTsKICAgICBMT0coV2ViR0wsICJFeHRlbnNpb25zOiAl cyIsIGRpc3BsYXlFeHRlbnNpb25zKTsKIApAQCAtNTc4LDE3ICs2MzYsMTMgQEAgR3JhcGhpY3ND b250ZXh0R0xPcGVuR0w6On5HcmFwaGljc0NvbnRleHRHTE9wZW5HTCgpCiAKICAgICBpZiAobV9j b250ZXh0T2JqKSB7CiAgICAgICAgIEdyYXBoaWNzQ29udGV4dEdMQXR0cmlidXRlcyBhdHRycyA9 IGNvbnRleHRBdHRyaWJ1dGVzKCk7Ci0KKyAgICAgICAgbWFrZUNvbnRleHRDdXJyZW50KCk7IC8v IFRPRE86IGNoZWNrIHJlc3VsdC4KICNpZiBVU0UoT1BFTkdMX0VTKQotICAgICAgICBtYWtlQ29u dGV4dEN1cnJlbnQoKTsKICAgICAgICAgW3N0YXRpY19jYXN0PEVBR0xDb250ZXh0ICo+KG1fY29u dGV4dE9iaikgcmVuZGVyYnVmZmVyU3RvcmFnZTpHTF9SRU5ERVJCVUZGRVIgZnJvbURyYXdhYmxl Om5pbF07CiAgICAgICAgIDo6Z2xEZWxldGVSZW5kZXJidWZmZXJzKDEsICZtX3RleHR1cmUpOwog I2VsaWYgVVNFKE9QRU5HTCkKLSAgICAgICAgQ0dMQ29udGV4dE9iaiBjZ2xDb250ZXh0ID0gc3Rh dGljX2Nhc3Q8Q0dMQ29udGV4dE9iaj4obV9jb250ZXh0T2JqKTsKLSAgICAgICAgQ0dMU2V0Q3Vy cmVudENvbnRleHQoY2dsQ29udGV4dCk7CiAgICAgICAgIDo6Z2xEZWxldGVUZXh0dXJlcygxLCAm bV90ZXh0dXJlKTsKICNlbGlmIFVTRShBTkdMRSkKLSAgICAgICAgRUdMX01ha2VDdXJyZW50KG1f ZGlzcGxheU9iaiwgRUdMX05PX1NVUkZBQ0UsIEVHTF9OT19TVVJGQUNFLCBtX2NvbnRleHRPYmop OwogICAgICAgICBnbDo6RGVsZXRlVGV4dHVyZXMoMSwgJm1fdGV4dHVyZSk7CiAjZW5kaWYKIApA QCAtNzA3LDEyICs3NjEsNTAgQEAgYm9vbCBHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6bWFrZUNv bnRleHRDdXJyZW50KCkKICAgICBpZiAoY3VycmVudENvbnRleHQgIT0gbV9jb250ZXh0T2JqKQog ICAgICAgICByZXR1cm4gQ0dMU2V0Q3VycmVudENvbnRleHQoc3RhdGljX2Nhc3Q8Q0dMQ29udGV4 dE9iaj4obV9jb250ZXh0T2JqKSkgPT0ga0NHTE5vRXJyb3I7CiAjZWxpZiBVU0UoQU5HTEUpCi0g ICAgaWYgKEVHTF9HZXRDdXJyZW50Q29udGV4dCgpICE9IG1fY29udGV4dE9iaikKLSAgICAgICAg cmV0dXJuIEVHTF9NYWtlQ3VycmVudChtX2Rpc3BsYXlPYmosIEVHTF9OT19TVVJGQUNFLCBFR0xf Tk9fU1VSRkFDRSwgbV9jb250ZXh0T2JqKTsKKyAgICAvLyBBTkdMRSBoYXMgYW4gZWFybHkgb3V0 IGZvciBjYXNlIHdoZXJlIG5vdGhpbmcgY2hhbmdlcy4gQ2FsbGluZyBNYWtlQ3VycmVudAorICAg IC8vIGlzIGltcG9ydGFudCB0byBzZXQgdm9sYXRpbGUgcGxhdGZvcm0gY29udGV4dC4gU2VlIElu aXRpYWxpemVFR0xEaXNwbGF5KCkuCisgICAgaWYgKCFFR0xfTWFrZUN1cnJlbnQobV9kaXNwbGF5 T2JqLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX1NVUkZBQ0UsIG1fY29udGV4dE9iaikpCisgICAg ICAgIHJldHVybiBmYWxzZTsKICNlbmRpZgogICAgIHJldHVybiB0cnVlOwogfQogCisjaWYgUExB VEZPUk0oSU9TX0ZBTUlMWSkgJiYgVVNFKEFOR0xFKQorYm9vbCBHcmFwaGljc0NvbnRleHRHTE9w ZW5HTDo6cmVsZWFzZUN1cnJlbnRDb250ZXh0KFJlbGVhc2VCZWhhdmlvciByZWxlYXNlQmVoYXZp b3IpCit7CisgICAgLy8gQXQgdGhlIG1vbWVudCB0aGlzIGZ1bmN0aW9uIGlzIHJlbGV2YW50IG9u bHkgd2hlbiB3ZWIgdGhyZWFkIGxvY2sgb3ducyB0aGUgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wg Y3VycmVudCBjb250ZXh0LgorICAgIEFTU0VSVCghV2ViQ29yZTo6aXNJbldlYlByb2Nlc3MoKSk7 CisKKyAgICBpZiAoIUVHTF9CaW5kQVBJKEVHTF9PUEVOR0xfRVNfQVBJKSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgIGlmIChFR0xfR2V0Q3VycmVudENvbnRleHQoKSA9PSBFR0xfTk9fQ09O VEVYVCkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICAvLyBBdCB0aGUgdGltZSBvZiB3cml0 aW5nLCBBTkdMRSBkb2VzIG5vdCBmbHVzaCBvbiBNYWtlQ3VycmVudC4gU2luY2Ugd2UgYXJlCisg ICAgLy8gcG90ZW50aWFsbHkgc3dpdGNoaW5nIHRocmVhZHMsIHdlIHNob3VsZCBmbHVzaC4KKyAg ICAvLyBOb3RlOiBIZXJlIHdlIGFzc3VtZSBhbHNvIHRoYXQgQU5HTEUgaGFzIG9ubHkgb25lIHBs YXRmb3JtIGNvbnRleHQgLS0gb3RoZXJ3aXNlCisgICAgLy8gd2Ugd291bGQgbmVlZCB0byBmbHVz aCBlYWNoIEVHTCBjb250ZXh0IHRoYXQgaGFzIGJlZW4gdXNlZC4KKyAgICBnbDo6Rmx1c2goKTsK KworICAgIC8vIFVuc2V0IHRoZSBFR0wgY3VycmVudCBjb250ZXh0LCBzaW5jZSB0aGUgbmV4dCBh Y2Nlc3MgbWlnaHQgYmUgZnJvbSBhbm90aGVyIHRocmVhZCwgYW5kIHRoZQorICAgIC8vIGNvbnRl eHQgY2Fubm90IGJlIGN1cnJlbnQgb24gbXVsdGlwbGUgdGhyZWFkcy4KKworICAgIGlmIChyZWxl YXNlQmVoYXZpb3IgPT0gUmVsZWFzZUJlaGF2aW9yOjpSZWxlYXNlVGhyZWFkUmVzb3VyY2VzKSB7 CisgICAgICAgIC8vIENhbGxlZCB3aGVuIHdlIGRvIG5vdCBrbm93IGlmIHdlIHdpbGwgZXZlciBz ZWUgYW5vdGhlciBjYWxsIGZyb20gdGhpcyB0aHJlYWQgYWdhaW4uCisgICAgICAgIC8vIFVuc2V0 IHRoZSBFR0wgY3VycmVudCBjb250ZXh0IGJ5IHJlbGVhc2luZyB3aG9sZSBFR0wgdGhyZWFkIHN0 YXRlLgorICAgICAgICAvLyBUaGVvcmV0aWNhbGx5IFJlbGVhc2VUaHJlYWQgY2FuIHJlc2V0IHRo ZSBib3VuZCBBUEksIHNvIHRoZSByZXN0IG9mIHRoZSBjb2RlIG1lbnRpb25zIEJpbmRBUEkvUXVl cnlBUEkuCisgICAgICAgIHJldHVybiBFR0xfUmVsZWFzZVRocmVhZCgpOworICAgIH0KKyAgICAv LyBPbiBXZWJLaXQgb3duZWQgdGhyZWFkcywgV2ViS2l0IGlzIGFibGUgdG8gY2hvb3NlIHRoZSB0 aW1lIGZvciB0aGUgRUdMIGNsZWFudXAuCisgICAgLy8gVGhpcyBpcyB3aHkgd2Ugb25seSB1bnNl dCB0aGUgY29udGV4dC4KKyAgICAvLyBOb3RlOiBBdCB0aGUgdGltZSBvZiB3cml0aW5nIHRoZSBF R0wgY2xlYW51cCBpcyBjaG9zZW4gdG8gYmUgbm90IGRvbmUgYXQgYWxsLgorICAgIEVHTERpc3Bs YXkgZGlzcGxheSA9IEVHTF9HZXREaXNwbGF5KEVHTF9ERUZBVUxUX0RJU1BMQVkpOworICAgIGlm IChkaXNwbGF5ID09IEVHTF9OT19ESVNQTEFZKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAg cmV0dXJuIEVHTF9NYWtlQ3VycmVudChkaXNwbGF5LCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX1NV UkZBQ0UsIEVHTF9OT19DT05URVhUKTsKK30KKyNlbmRpZgorCiB2b2lkIEdyYXBoaWNzQ29udGV4 dEdMT3BlbkdMOjpjaGVja0dQVVN0YXR1cygpCiB7CiAgICAgaWYgKG1fZmFpbE5leHRTdGF0dXND aGVjaykgewpAQCAtNzI0LDYgKzgxNiw3IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0R0xPcGVuR0w6 OmNoZWNrR1BVU3RhdHVzKCkKICNlbGlmIFVTRShPUEVOR0xfRVMpCiAgICAgICAgIFtFQUdMQ29u dGV4dCBzZXRDdXJyZW50Q29udGV4dDowXTsKICNlbGlmIFVTRShBTkdMRSkKKyAgICAgICAgRUdM X0JpbmRBUEkoRUdMX09QRU5HTF9FU19BUEkpOwogICAgICAgICBFR0xfTWFrZUN1cnJlbnQobV9k aXNwbGF5T2JqLCBFR0xfTk9fU1VSRkFDRSwgRUdMX05PX1NVUkZBQ0UsIEVHTF9OT19DT05URVhU KTsKICNlbmRpZgogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0R0xPcGVuR0wuaCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHRHTE9wZW5H TC5oCmluZGV4IGU5Y2M0ZmFjZDIwMzJmOWVlMzExMWE4NTQzNTAzMTA1NTY1OTdhYmMuLjc3MTlj OTE0MTMyNGJiNmU5OTI1YzRlNDc4ZjlkYTU2YTQ4YzE2ZTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHRHTE9wZW5HTC5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0Nv bnRleHRHTE9wZW5HTC5oCkBAIC0xMTksNiArMTE5LDEzIEBAIHB1YmxpYzoKICNlbmRpZgogCiAg ICAgYm9vbCBtYWtlQ29udGV4dEN1cnJlbnQoKTsKKyNpZiBQTEFURk9STShJT1NfRkFNSUxZKSAm JiBVU0UoQU5HTEUpCisgICAgZW51bSBjbGFzcyBSZWxlYXNlQmVoYXZpb3IgeworICAgICAgICBQ cmVzZXJ2ZVRocmVhZFJlc291cmNlcywKKyAgICAgICAgUmVsZWFzZVRocmVhZFJlc291cmNlcwor ICAgIH07CisgICAgc3RhdGljIGJvb2wgcmVsZWFzZUN1cnJlbnRDb250ZXh0KFJlbGVhc2VCZWhh dmlvcik7CisjZW5kaWYKIAogICAgIHZvaWQgYWRkQ2xpZW50KENsaWVudCYgY2xpZW50KSB7IG1f Y2xpZW50cy5hZGQoJmNsaWVudCk7IH0KICAgICB2b2lkIHJlbW92ZUNsaWVudChDbGllbnQmIGNs aWVudCkgeyBtX2NsaWVudHMucmVtb3ZlKCZjbGllbnQpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9pb3Mvd2FrL1dlYkNvcmVUaHJlYWQubW0gYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9pb3Mvd2FrL1dlYkNvcmVUaHJlYWQubW0KaW5kZXggNWFkN2ZlNTE5OGQyNGMz MDM2NmEyMzBhMDk3MzI0YzRhMjVjNjk0ZC4uNjM5NGI5N2Q3OGFhMTBlNTgzNTQzOTY1YjU5N2Jk MzA5Zjk2MzBjOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vaW9zL3dhay9X ZWJDb3JlVGhyZWFkLm1tCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2lvcy93YWsvV2Vi Q29yZVRocmVhZC5tbQpAQCAtMzAsNiArMzAsNyBAQAogCiAjaW1wb3J0ICJDb21tb25WTS5oIgog I2ltcG9ydCAiRmxvYXRpbmdQb2ludEVudmlyb25tZW50LmgiCisjaW1wb3J0ICJHcmFwaGljc0Nv bnRleHRHTE9wZW5HTC5oIgogI2ltcG9ydCAiTG9nZ2luZy5oIgogI2ltcG9ydCAiUnVudGltZUFw cGxpY2F0aW9uQ2hlY2tzLmgiCiAjaW1wb3J0ICJUaHJlYWRHbG9iYWxEYXRhLmgiCkBAIC01OSw2 ICs2MCwyNiBAQAogCiAjZGVmaW5lIERpc3RhbnRGdXR1cmUgICAoODY0MDAuMCAqIDIwMDAgKiAz NjUuMjQyNSArIDg2NDAwLjApICAgLy8gc2FtZSBhcyArW05TRGF0ZSBkaXN0YW50RnV0dXJlXQog CituYW1lc3BhY2UgeworLy8gUmVsZWFzZSBnbG9iYWwgc3RhdGUgdGhhdCBpcyBhY2Nlc3NlZCBm cm9tIGJvdGggd2ViIHRocmVhZCBhcyB3ZWxsCisvLyBhcyBhbnkgY2xpZW50IHRocmVhZCB0aGF0 IGNhbGxzIGludG8gV2ViS2l0Lgordm9pZCBSZWxlYXNlV2ViVGhyZWFkR2xvYmFsU3RhdGUoKQor eworICAgIC8vIEdyYXBoaWNzQ29udGV4dEdMT3BlbkdMIGN1cnJlbnQgY29udGV4dCBpcyBvd25l ZCBieSB0aGUgd2ViIHRocmVhZCBsb2NrLiBSZWxlYXNlIHRoZSBjb250ZXh0CisgICAgLy8gYmVm b3JlIHRoZSBsb2NrIGlzIHJlbGVhc2VkLgorCisgICAgLy8gSW4gc2luZ2xlLXRocmVhZGVkIGVu dmlyb25tZW50cyB3ZSBkbyBub3QgbmVlZCB0byB1bnNldCB0aGUgY29udGV4dCwgYXMgdGhlcmUg c2hvdWxkIG5vdCBiZSBhY2Nlc3MgZnJvbQorICAgIC8vIG11bHRpcGxlIHRocmVhZHMuCisgICAg QVNTRVJUKFdlYlRocmVhZElzRW5hYmxlZCgpKTsKKyAgICB1c2luZyBSZWxlYXNlQmVoYXZpb3Ig PSBXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTDo6UmVsZWFzZUJlaGF2aW9yOworICAg IC8vIEZvciBub24td2ViIHRocmVhZHMsIHdlIGRvbid0IGtub3cgaWYgd2UgZXZlciBzZWUgYW5v dGhlciBjYWxsIGZyb20gdGhlIHRocmVhZC4KKyAgICBSZWxlYXNlQmVoYXZpb3IgcmVsZWFzZUJl aGF2aW9yID0KKyAgICAgICAgV2ViVGhyZWFkSXNDdXJyZW50KCkgPyBSZWxlYXNlQmVoYXZpb3I6 OlByZXNlcnZlVGhyZWFkUmVzb3VyY2VzIDogUmVsZWFzZUJlaGF2aW9yOjpSZWxlYXNlVGhyZWFk UmVzb3VyY2VzOworICAgIFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMOjpyZWxlYXNl Q3VycmVudENvbnRleHQocmVsZWFzZUJlaGF2aW9yKTsKK30KKworfQorCiBzdGF0aWMgY29uc3Qg Y29uc3RleHByIFNlY29uZHMgRGVsZWdhdGVXYWl0SW50ZXJ2YWwgeyAxMF9zIH07CiAKIHN0YXRp YyB2b2lkIF9XZWJUaHJlYWRBdXRvTG9jaygpOwpAQCAtNzc4LDYgKzc5OSw4IEBAIHZvaWQgV2Vi VGhyZWFkVW5sb2NrRnJvbUFueVRocmVhZCh2b2lkKQogICAgIGlmICghd2ViVGhyZWFkU3RhcnRl ZCkKICAgICAgICAgcmV0dXJuOwogICAgIEFTU0VSVCghV2ViVGhyZWFkSXNDdXJyZW50KCkpOwor ICAgIFJlbGVhc2VXZWJUaHJlYWRHbG9iYWxTdGF0ZSgpOworCiAgICAgLy8gTm8tb3AgZXhjZXB0 IGZyb20gYSBzZWNvbmRhcnkgdGhyZWFkLgogICAgIGlmIChwdGhyZWFkX21haW5fbnAoKSkKICAg ICAgICAgcmV0dXJuOwpAQCAtNzk5LDYgKzgyMiw4IEBAIHZvaWQgV2ViVGhyZWFkVW5sb2NrR3Vh cmRGb3JNYWlsKHZvaWQpCiAKIHZvaWQgX1dlYlRocmVhZFVubG9jaygpCiB7CisgICAgUmVsZWFz ZVdlYlRocmVhZEdsb2JhbFN0YXRlKCk7CisKICNpZiBMT0dfV0VCX0xPQ0sgfHwgTE9HX01BSU5f VEhSRUFEX0xPQ0tJTkcKICAgICBsb2NrQ291bnQtLTsKICNpZiBMT0dfV0VCX0xPQ0sKZGlmZiAt LWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCA2OGNiYjVjMmIw MGFiODRhNmE3MDk2NWU2MDkzZDM0ZTAwYThiNGY4Li45NzI3ZTUyYzdkNWM3YWEzMzFhY2NiYjE4 ZmZkMjg3ZGE5MmNlZWQ3IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjAtMDktMjkgIEtpbW1vIEtpbm51bmVuICA8 a2tpbm51bmVuQGFwcGxlLmNvbT4KKworICAgICAgICBbaU9TIFdLMV0gQ3Jhc2hlcyB3aGVuIHVz aW5nIEFOR0xFIFdlYkdMIGZyb20gYW5vdGhlciB0aHJlYWQKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNjEwNgorICAgICAgICA8cmRhcjovL3Byb2Js ZW0vNjg2MDI0NTI+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSdXNzZWxsLgorCisg ICAgICAgIEFkZCBhIFdLMSB0ZXN0IHdoaWNoIHJ1bnMgV2ViR0wgY29kZSBib3RoIGluCisgICAg ICAgIGNsaWVudCBtYWluIHRocmVhZCBhbmQgaW4gd2ViIHRocmVhZC4KKyAgICAgICAgVGhpcyB0 ZXN0cyB0aGUgY2FzZSB3aGVyZSBBTkdMRSBFR0wgY29udGV4dCBpcworICAgICAgICBub3QgYmVp bmcgaGVsZCBjdXJyZW50IGluIG9uZSB0aHJlYWQgd2hpbGUgdGhlCisgICAgICAgIG90aGVyIHRo cmVhZCBydW5zIFdlYkdMIGFuZCB0aHVzIEFOR0xFIEVHTCBjb2RlLgorCisgICAgICAgICogVGVz dFdlYktpdEFQSS9Db25maWd1cmF0aW9ucy9UZXN0V2ViS2l0QVBJLnhjY29uZmlnOgorICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q OgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0TGVnYWN5L2lvcy9XZWJHTE5v Q3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzLm1tOiBBZGRlZC4KKyAgICAgICAgKC1bV2ViR0xOb0Ny YXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxlZ2F0ZSB3ZWJWaWV3RGlkRmluaXNoTG9h ZDpdKToKKyAgICAgICAgKC1bV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdE ZWxlZ2F0ZSB3ZWJWaWV3OnNob3VsZFN0YXJ0TG9hZFdpdGhSZXF1ZXN0Om5hdmlnYXRpb25UeXBl Ol0pOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIwMjAtMDktMjkgIEFuZHJl cyBHb256YWxleiAgPGFuZHJlc2dfMjJAYXBwbGUuY29tPgogCiAgICAgICAgIE1vZGlmeSBFTkRf QVhfT0JKQ19FWENFUFRJT05TIG1hY3JvIHRvIGFzc2VydCB0byBhaWQgZGVidWdnaW5nIG9mIGxh eW91dCB0ZXN0cy4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJhdGlv bnMvVGVzdFdlYktpdEFQSS54Y2NvbmZpZyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvQ29uZmlndXJh dGlvbnMvVGVzdFdlYktpdEFQSS54Y2NvbmZpZwppbmRleCBiYmRkZTg3NTE3OTM4NzNlMGQwZmEy ZGNhNDIxZWQ1N2FjMGFiZjAwLi43MGJlOGFhNzcwNDNiNzQxNzdkNDA2ZDAzYzMxNDk2MzhhOTlm MWU5IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL0NvbmZpZ3VyYXRpb25zL1Rlc3RX ZWJLaXRBUEkueGNjb25maWcKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9Db25maWd1cmF0aW9u cy9UZXN0V2ViS2l0QVBJLnhjY29uZmlnCkBAIC02MSw3ICs2MSwxNyBAQCBXS19ISURfTERGTEFH U19NQUNPU19TSU5DRV8xMDE1ID0gLWZyYW1ld29yayBISUQ7CiAKIE9USEVSX0NQTFVTUExVU0ZM QUdTID0gJChpbmhlcml0ZWQpIC1pc3lzdGVtICQoU0RLUk9PVCkvU3lzdGVtL0xpYnJhcnkvRnJh bWV3b3Jrcy9TeXN0ZW0uZnJhbWV3b3JrL1ByaXZhdGVIZWFkZXJzOwogCi1PVEhFUl9MREZMQUdT ID0gJChpbmhlcml0ZWQpICQoVU5FWFBPUlRFRF9TWU1CT0xfTERGTEFHUykgLWxndGVzdCAtZm9y Y2VfbG9hZCAkKEJVSUxUX1BST0RVQ1RTX0RJUikvbGliVGVzdFdlYktpdEFQSS5hIC1mcmFtZXdv cmsgSmF2YVNjcmlwdENvcmUgLWZyYW1ld29yayBXZWJLaXQgLWxXZWJDb3JlVGVzdFN1cHBvcnQg JChXS19BVVRIS0lUX0xERkxBR1MpIC1mcmFtZXdvcmsgTmV0d29yayAkKFdLX1BERktJVF9MREZM QUdTKSAkKFdLX0hJRF9MREZMQUdTKSAkKE9USEVSX0xERkxBR1NfUExBVEZPUk1fJChXS19DT0NP QV9UT1VDSCkpOworV0tfT1BFTkdMX0xERkxBR1MgPSAkKFdLX09QRU5HTF9MREZMQUdTXyQoV0tf UExBVEZPUk1fTkFNRSkpOworV0tfT1BFTkdMX0xERkxBR1NfaXBob25lb3MgPSAtZnJhbWV3b3Jr IE9wZW5HTEVTOworV0tfT1BFTkdMX0xERkxBR1NfbWFjY2F0YWx5c3QgPSAtZnJhbWV3b3JrIE9w ZW5HTDsKK1dLX09QRU5HTF9MREZMQUdTX2lwaG9uZXNpbXVsYXRvciA9IC1mcmFtZXdvcmsgT3Bl bkdMRVM7CitXS19PUEVOR0xfTERGTEFHU193YXRjaG9zID0gJChXS19PUEVOR0xfTERGTEFHU19p cGhvbmVvcyk7CitXS19PUEVOR0xfTERGTEFHU193YXRjaHNpbXVsYXRvciA9ICQoV0tfT1BFTkdM X0xERkxBR1NfaXBob25lc2ltdWxhdG9yKTsKK1dLX09QRU5HTF9MREZMQUdTX2FwcGxldHZvcyA9 ICQoV0tfT1BFTkdMX0xERkxBR1NfaXBob25lb3MpOworV0tfT1BFTkdMX0xERkxBR1NfYXBwbGV0 dnNpbXVsYXRvciA9ICQoV0tfT1BFTkdMX0xERkxBR1NfaXBob25lc2ltdWxhdG9yKTsKK1dLX09Q RU5HTF9MREZMQUdTX21hY29zeCA9IC1mcmFtZXdvcmsgT3BlbkdMOworCitPVEhFUl9MREZMQUdT ID0gJChpbmhlcml0ZWQpICQoVU5FWFBPUlRFRF9TWU1CT0xfTERGTEFHUykgLWxndGVzdCAtZm9y Y2VfbG9hZCAkKEJVSUxUX1BST0RVQ1RTX0RJUikvbGliVGVzdFdlYktpdEFQSS5hIC1mcmFtZXdv cmsgSmF2YVNjcmlwdENvcmUgLWZyYW1ld29yayBXZWJLaXQgLWxXZWJDb3JlVGVzdFN1cHBvcnQg JChXS19BVVRIS0lUX0xERkxBR1MpIC1mcmFtZXdvcmsgTmV0d29yayAkKFdLX1BERktJVF9MREZM QUdTKSAkKFdLX0hJRF9MREZMQUdTKSAkKFdLX09QRU5HTF9MREZMQUdTKSAkKE9USEVSX0xERkxB R1NfUExBVEZPUk1fJChXS19DT0NPQV9UT1VDSCkpOwogT1RIRVJfTERGTEFHU19QTEFURk9STV8g PSAtZnJhbWV3b3JrIENvY29hIC1mcmFtZXdvcmsgQ2FyYm9uOwogCiAvLyBGSVhNRTogVGhpcyBz aG91bGQgbm90IGJlIGJ1aWx0IG9uIGlPUy4gSW5zdGVhZCB3ZSBzaG91bGQgY3JlYXRlIGFuZCB1 c2UgYSBUZXN0V2ViS2l0QVBJIGFwcGxpY2F0aW9uLgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRl eCBjYmNkOTMzY2Y2N2FkNzkzOTJjYzM5NDY0ZDI2NzA4MWQ4ODA5MDUyLi45YTg3MjI4OWNlZmJl ZjYzMGVlYzM3OTkwY2RhZjVlMzdjNGNmZTY0IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAt NTQ3LDYgKzU0Nyw3IEBACiAJCTdBRTlFNTA5MUFFNUFFOEIwMENGODc0QiAvKiB0ZXN0LnBkZiBp biBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QUU5 RTUwODFBRTVBRThCMDBDRjg3NEIgLyogdGVzdC5wZGYgKi87IH07CiAJCTdBRUFENDdGMUUyMDEx NkMwMDQxNkVGRSAvKiBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MubW0gaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QUVBRDQ3QzFFMjAxMTM4MDA0 MTZFRkUgLyogQ3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLm1tICovOyB9OwogCQk3QUVB RDQ4MTFFMjAxMjI3MDA0MTZFRkUgLyogQ3Jvc3NQYXJ0aXRpb25GaWxlU2NoZW1lQWNjZXNzLmh0 bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g N0FFQUQ0N0QxRTIwMTE0RTAwNDE2RUZFIC8qIENyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vz cy5odG1sICovOyB9OworCQk3QjdEMDk2QTI1MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNo T25PdGhlclRocmVhZEFjY2Vzcy5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDdCN0QwOTY5MjUxOUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jhc2hPbk90 aGVyVGhyZWFkQWNjZXNzLm1tICovOyB9OwogCQk3QzFBRjc5NTFFOERDQkFCMDAyNjQ1QjkgLyog UHJlcGFyZUZvck1vdmVUb1dpbmRvdy5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDdDMUFGNzkzMUU4RENCQUIwMDI2NDVCOSAvKiBQcmVwYXJlRm9yTW92 ZVRvV2luZG93Lm1tICovOyB9OwogCQk3QzM5NjUwNjFDREQ3NEY5MDA5NERCQjggLyogQ29sb3JU ZXN0cy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3 QzM5NjUwNTFDREQ3NEY5MDA5NERCQjggLyogQ29sb3JUZXN0cy5jcHAgKi87IH07CiAJCTdDM0RC OEU0MUQxMjEyOUIwMEFFOENDMyAvKiBDb21tYW5kQmFja0ZvcndhcmQubW0gaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3QzNEQjhFMjFEMTIxMjlCMDBBRThD QzMgLyogQ29tbWFuZEJhY2tGb3J3YXJkLm1tICovOyB9OwpAQCAtMjMwOSw2ICsyMzEwLDcgQEAK IAkJN0FFOUU1MDgxQUU1QUU4QjAwQ0Y4NzRCIC8qIHRlc3QucGRmICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gaW1hZ2UucGRmOyBwYXRoID0gdGVzdC5w ZGY7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdBRUFENDdDMUUyMDExMzgwMDQxNkVG RSAvKiBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MubW0gKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5vYmpjcHA7IHBhdGggPSBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MubW07 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTdBRUFENDdEMUUyMDExNEUwMDQxNkVGRSAv KiBDcm9zc1BhcnRpdGlvbkZpbGVTY2hlbWVBY2Nlc3MuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRt bDsgbmFtZSA9IENyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5odG1sOyBwYXRoID0gVGVz dHMvbWFjL0Nyb3NzUGFydGl0aW9uRmlsZVNjaGVtZUFjY2Vzcy5odG1sOyBzb3VyY2VUcmVlID0g U09VUkNFX1JPT1Q7IH07CisJCTdCN0QwOTY5MjUxOUY4RjkwMDE3QTA3OCAvKiBXZWJHTE5vQ3Jh c2hPbk90aGVyVGhyZWFkQWNjZXNzLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV2ViR0xOb0Ny YXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ N0MxQUY3OTMxRThEQ0JBQjAwMjY0NUI5IC8qIFByZXBhcmVGb3JNb3ZlVG9XaW5kb3cubW0gKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBQcmVwYXJlRm9yTW92ZVRvV2lu ZG93Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3QzM5NjUwNTFDREQ3NEY5MDA5 NERCQjggLyogQ29sb3JUZXN0cy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBh dGggPSBDb2xvclRlc3RzLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJN0MzREI4 RTIxRDEyMTI5QjAwQUU4Q0MzIC8qIENvbW1hbmRCYWNrRm9yd2FyZC5tbSAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IENvbW1hbmRCYWNrRm9yd2FyZC5tbTsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTQ2MDUsNiArNDYwNyw3IEBACiAJCQkJQ0RDMDkzMkEy MUM4NzJDMTAwMzBDNEIwIC8qIFNjcm9sbGluZ0RvZXNOb3RQYXVzZU1lZGlhLm1tICovLAogCQkJ CUY0MzRDQTE5MjJFNjVCQ0EwMDVEREIyNiAvKiBTY3JvbGxUb1JldmVhbFNlbGVjdGlvbi5tbSAq LywKIAkJCQkwRjRGRkE5RDFFRDNBQTg1MDBGNzExMUYgLyogU25hcHNob3RWaWFSZW5kZXJJbkNv bnRleHQubW0gKi8sCisJCQkJN0I3RDA5NjkyNTE5RjhGOTAwMTdBMDc4IC8qIFdlYkdMTm9DcmFz aE9uT3RoZXJUaHJlYWRBY2Nlc3MubW0gKi8sCiAJCQkJMzFFOUJEQTAyNDdGNEM2MjAwMkU1MUEy IC8qIFdlYkdMUHJlcGFyZURpc3BsYXlPbldlYlRocmVhZC5tbSAqLywKIAkJCQkyREM5NDUxNjI0 RDhBQzAyMDA0MzAzNzYgLyogV2ViVGhyZWFkTG9jay5tbSAqLywKIAkJCSk7CkBAIC01NDc5LDYg KzU0ODIsNyBAQAogCQkJCTdDODNFMDRDMUQwQTY0MTgwMEZFQkNGMyAvKiBXZWJDb3JlTlNVUkxT ZXNzaW9uLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNTdBNzk4NTcyMjRBQjM0RTAwQTdGNkYxIC8q IFdlYkNyeXB0b01hc3RlcktleS5tbSBpbiBTb3VyY2VzICovLAogCQkJCUMxRkY5RURCMjQ0NjQ0 RjAwMDgzOUFFNCAvKiBXZWJGaWx0ZXIubW0gaW4gU291cmNlcyAqLywKKwkJCQk3QjdEMDk2QTI1 MTlGOEY5MDAxN0EwNzggLyogV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbSBpbiBT b3VyY2VzICovLAogCQkJCTVDOTczRjVDMUY1OEVGOEIwMDM1OUMyNyAvKiBXZWJHTFBvbGljeS5t bSBpbiBTb3VyY2VzICovLAogCQkJCTMxRTlCREExMjQ3RjRDNjIwMDJFNTFBMiAvKiBXZWJHTFBy ZXBhcmVEaXNwbGF5T25XZWJUaHJlYWQubW0gaW4gU291cmNlcyAqLywKIAkJCQk3Q0NFN0VBQjFB NDExQTI0MDA0NDdDNEMgLyogV2ViS2l0QWdub3N0aWNUZXN0Lm1tIGluIFNvdXJjZXMgKi8sCmRp ZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExlZ2FjeS9pb3MvV2Vi R0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0TGVnYWN5L2lvcy9XZWJHTE5vQ3Jhc2hPbk90aGVyVGhyZWFkQWNjZXNzLm1tCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjI2MGJhYjU3YTY1NDBiMDI0YmVmMTcwMThkNzhiMmM4OTUzNTlhZjcKLS0tIC9k ZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExlZ2FjeS9pb3Mv V2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzcy5tbQpAQCAtMCwwICsxLDIxMCBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRF UiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVS LCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5U IE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgor ICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2ltcG9ydCAiY29uZmlnLmgiCisKKyNpZiBIQVZFKFVJV0VCVklFVykKKworI2ltcG9y dCAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0pTVmlydHVh bE1hY2hpbmUuaD4KKyNpbXBvcnQgPEphdmFTY3JpcHRDb3JlL0pTVmlydHVhbE1hY2hpbmVJbnRl cm5hbC5oPgorI2ltcG9ydCA8VUlLaXQvVUlLaXQuaD4KKyNpbXBvcnQgPFdlYkNvcmUvV2ViQ29y ZVRocmVhZC5oPgorI2ltcG9ydCA8c3RkbGliLmg+CisjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+ CisKKyNpZiBQTEFURk9STShNQUMpIHx8IFBMQVRGT1JNKE1BQ0NBVEFMWVNUKQorI2ltcG9ydCA8 T3BlbkdML09wZW5HTC5oPgorI2VsaWYgUExBVEZPUk0oSU9TKQorI2ltcG9ydCA8T3BlbkdMRVMv RUFHTC5oPgorI2VuZGlmCisKK25hbWVzcGFjZSB7Citib29sIGRpZEZpbmlzaExvYWQ7Citib29s IGRpZEZpbmlzaFRlc3Q7CisKKyNpZiBQTEFURk9STShNQUMpIHx8IFBMQVRGT1JNKE1BQ0NBVEFM WVNUKQorY2xhc3MgU2V0Q29udGV4dENHTCB7CisgICAgU2V0Q29udGV4dENHTCgpCisgICAgewor ICAgICAgICAvLyBUT0RPOiBpbXBsZW1lbnQgcHJvcGVybHkuIFNraXBwZWQgZHVlIHRvIGNvbXBs aWNhdGVkIGluc3RhbnRpYXRpb24uCisgICAgICAgIC8vIGluc3RlYWQsIGp1c3QgY2xvYmJlciB0 aGUgY3VycmVudCBjb250ZXh0IHdpdGggbnVsbHB0ci4KKyAgICAgICAgQ0dMU2V0Q3VycmVudENv bnRleHQobnVsbHB0cik7CisgICAgfQorICAgIH5TZXRDb250ZXh0Q0dMKCkKKyAgICB7CisgICAg ICAgIENHTFNldEN1cnJlbnRDb250ZXh0KG51bGxwdHIpOworICAgIH0KK307CisjZWxzZQorY2xh c3MgU2V0Q29udGV4dENHTCB7CisKK307CisjZW5kaWYKKworI2lmIFBMQVRGT1JNKElPUykKK2Ns YXNzIFNldENvbnRleHRFQUdMIHsKK3B1YmxpYzoKKyAgICBTZXRDb250ZXh0RUFHTCgpCisgICAg eworICAgICAgICBtX2VhZ2xDb250ZXh0ID0gYWRvcHROUyhbW0VBR0xDb250ZXh0IGFsbG9jXSBp bml0V2l0aEFQSToga0VBR0xSZW5kZXJpbmdBUElPcGVuR0xFUzNdKTsKKyAgICAgICAgYXV0byBy ID0gW0VBR0xDb250ZXh0IHNldEN1cnJlbnRDb250ZXh0OiBtX2VhZ2xDb250ZXh0LmdldCgpXTsK KyAgICAgICAgQVNTRVJUKHIpOworICAgICAgICBVTlVTRURfVkFSSUFCTEUocik7CisgICAgfQor ICAgIH5TZXRDb250ZXh0RUFHTCgpCisgICAgeworICAgICAgICBbRUFHTENvbnRleHQgc2V0Q3Vy cmVudENvbnRleHQ6IG5pbF07CisgICAgfQorCitwcml2YXRlOgorICAgIFJldGFpblB0cjxFQUdM Q29udGV4dD4gbV9lYWdsQ29udGV4dDsKK307CisjZWxzZQorY2xhc3MgU2V0Q29udGV4dEVBR0wg eworCit9OworI2VuZGlmCisKK30KKworQGludGVyZmFjZSBXZWJHTE5vQ3Jhc2hPbk90aGVyVGhy ZWFkQWNjZXNzV2ViVmlld0RlbGVnYXRlIDogTlNPYmplY3QgPFVJV2ViVmlld0RlbGVnYXRlPgor QGVuZAorCitAaW1wbGVtZW50YXRpb24gV2ViR0xOb0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dl YlZpZXdEZWxlZ2F0ZQorCitJR05PUkVfV0FSTklOR1NfQkVHSU4oImRlcHJlY2F0ZWQtaW1wbGVt ZW50YXRpb25zIikKKy0gKHZvaWQpd2ViVmlld0RpZEZpbmlzaExvYWQ6KFVJV2ViVmlldyAqKXdl YlZpZXcKK3sKKyAgICBkaWRGaW5pc2hMb2FkID0gdHJ1ZTsKK30KKworLSAoQk9PTCl3ZWJWaWV3 OihVSVdlYlZpZXcgKil3ZWJWaWV3IHNob3VsZFN0YXJ0TG9hZFdpdGhSZXF1ZXN0OihOU1VSTFJl cXVlc3QgKilyZXF1ZXN0IG5hdmlnYXRpb25UeXBlOihVSVdlYlZpZXdOYXZpZ2F0aW9uVHlwZSlu YXZpZ2F0aW9uVHlwZQoreworICAgIGlmIChbcmVxdWVzdC5VUkwuc2NoZW1lIGlzRXF1YWxUb1N0 cmluZzpAImNhbGxiYWNrIl0pIHsKKyAgICAgICAgaWYgKFtyZXF1ZXN0LlVSTC5yZXNvdXJjZVNw ZWNpZmllciBpc0VxdWFsVG9TdHJpbmc6QCJkaWRGaW5pc2hUZXN0Il0pCisgICAgICAgICAgICBk aWRGaW5pc2hUZXN0ID0gdHJ1ZTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgRVhQRUNUX1RS VUUoZmFsc2UpIDw8IFtyZXF1ZXN0LlVSTC5yZXNvdXJjZVNwZWNpZmllciBVVEY4U3RyaW5nXTsK KyAgICAgICAgcmV0dXJuIE5POworICAgIH0KKworICAgIHJldHVybiBZRVM7Cit9CitJR05PUkVf V0FSTklOR1NfRU5ECisKK0BlbmQKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCisvLyBU ZXN0IHRoYXQgdGVzdHMgYmVoYXZpb3Igb2YgVUlXZWJWaWV3IEFQSSB3aXRoIHJlZ2FyZHMgdG8g V2ViR0w6CisvLyAxKSBXZWJHTCBjYW4gYmUgcnVuIG9uIHdlYiB0aHJlYWQuCisvLyAyKSBXZWJH TCBjYW4gYmUgcnVuIG9uIGNsaWVudCBtYWluIHRocmVhZC4KKy8vIDMpIFdlYkdMIHJ1biBvbiBj bGllbnQgdGhyZWFkIGlzIG5vdCBhZmZlY3RlZCBieSBjbGllbnQgY2hhbmdpbmcKKy8vICAgIHRo ZSBFQUdML0NHTCBjb250ZXh0LgorVEVTVChXZWJLaXRMZWdhY3ksIFdlYkdMTm9DcmFzaE9uT3Ro ZXJUaHJlYWRBY2Nlc3MpCit7CisgICAgY29uc3QgdW5zaWduZWQgdGVzdEl0ZXJhdGlvbnMgPSAx MDsKKworICAgIFJldGFpblB0cjxVSVdpbmRvdz4gdWlXaW5kb3cgPSBhZG9wdE5TKFtbVUlXaW5k b3cgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNNYWtlUmVjdCgwLCAwLCA4MDAsIDYwMCldKTsKKyAg ICBSZXRhaW5QdHI8VUlXZWJWaWV3PiB1aVdlYlZpZXcgPSBhZG9wdE5TKFtbVUlXZWJWaWV3IGFs bG9jXSBpbml0V2l0aEZyYW1lOk5TTWFrZVJlY3QoMCwgMCwgODAwLCA2MDApXSk7CisgICAgW3Vp V2luZG93IGFkZFN1YnZpZXc6dWlXZWJWaWV3LmdldCgpXTsKKworICAgIEFTU0VSVF9UUlVFKFdl YlRocmVhZElzRW5hYmxlZCgpKTsKKyAgICBTZXRDb250ZXh0Q0dMIGNsaWVudENvbnRleHRDR0wx OworICAgIFNldENvbnRleHRFQUdMIGNsaWVudENvbnRleHRFQUdMMTsKKyAgICBVTlVTRURfVkFS SUFCTEUoY2xpZW50Q29udGV4dENHTDEpOworICAgIFVOVVNFRF9WQVJJQUJMRShjbGllbnRDb250 ZXh0RUFHTDEpOworCisgICAgUmV0YWluUHRyPFdlYkdMTm9DcmFzaE9uT3RoZXJUaHJlYWRBY2Nl c3NXZWJWaWV3RGVsZWdhdGU+IHVpRGVsZWdhdGUgPQorICAgICAgICBhZG9wdE5TKFtbV2ViR0xO b0NyYXNoT25PdGhlclRocmVhZEFjY2Vzc1dlYlZpZXdEZWxlZ2F0ZSBhbGxvY10gaW5pdF0pOwor ICAgIHVpV2ViVmlldy5nZXQoKS5kZWxlZ2F0ZSA9IHVpRGVsZWdhdGUuZ2V0KCk7CisgICAgTlNT dHJpbmcqIHRlc3RIdG1sID0gQFIiSFRNTCg8Ym9keT5OT0xJTlQocmVhZGFiaWxpdHkvbXVsdGls aW5lX3N0cmluZykKKzxzY3JpcHQ+CitmdW5jdGlvbiBydW5UZXN0KCkKK3sKKyAgICBsZXQgdyA9 IDEwMDsKKyAgICBsZXQgaCA9IDEwMDsKKyAgICBsZXQgY2FudmFzID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgiY2FudmFzIik7CisgICAgY2FudmFzLndpZHRoID0gdzsKKyAgICBjYW52YXMuaGVp Z2h0ID0gaDsKKyAgICBsZXQgZ2wgPSBjYW52YXMuZ2V0Q29udGV4dCgid2ViZ2wiKTsKKyAgICBn bC5jbGVhckNvbG9yKDAsIDAsIDEsIDEpOworICAgIGdsLmNsZWFyKGdsLkNPTE9SX0JVRkZFUl9C SVQpOworICAgIGxldCBleHBlY3RlZCA9IDI1NSA8PCAyNCB8IDI1NSA8PCAxNjsKKyAgICBsZXQg cHMgPSBuZXcgVWludDhBcnJheSh3ICogaCAqIDQpOworICAgIGdsLnJlYWRQaXhlbHMoMCwgMCwg dywgaCwgZ2wuUkdCQSwgZ2wuVU5TSUdORURfQllURSwgcHMpOworICAgIGZvciAobGV0IGkgPSAw OyBpIDwgcHMubGVuZ3RoOyBpICs9IDQpIHsKKyAgICAgICAgbGV0IGdvdCA9IHBzW2ldIHwgcHNb aSsxXSA8PCA4IHwgcHNbaSsyXSA8PCAxNiB8IHBzW2krM10gPDwgMjQ7CisgICAgICAgIGlmIChn b3QgIT0gZXhwZWN0ZWQpCisgICAgICAgICAgICByZXR1cm4gYCR7Z290fSAhPSAke2V4cGVjdGVk fWA7IC8vIE5PTElOVAorICAgIH0KKyAgICByZXR1cm4gImRpZEZpbmlzaFRlc3QiOworfQorZnVu Y3Rpb24gcnVuVGVzdEFzeW5jKCkKK3sKKyAgICBzZXRUaW1lb3V0KCgpID0+IHsgd2luZG93Lmxv Y2F0aW9uID0gJ2NhbGxiYWNrOicgKyBydW5UZXN0KCk7IH0sIDEwKTsgLy8gTk9MSU5UCit9Cis8 L3NjcmlwdD4pSFRNTCI7IC8vIE5PTElOVChyZWFkYWJpbGl0eS9tdWx0aWxpbmVfc3RyaW5nKQor ICAgIFt1aVdlYlZpZXcgbG9hZEhUTUxTdHJpbmc6dGVzdEh0bWwgYmFzZVVSTDpuaWxdOworCisg ICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hMb2FkKTsKKworICAgIFJldGFpblB0cjxKU0NvbnRleHQ+ IGpzQ29udGV4dCA9IFt1aVdlYlZpZXcgdmFsdWVGb3JLZXlQYXRoOkAiZG9jdW1lbnRWaWV3Lndl YlZpZXcubWFpbkZyYW1lLmphdmFTY3JpcHRDb250ZXh0Il07CisgICAgUmV0YWluUHRyPEpTVmly dHVhbE1hY2hpbmU+IGpzVk0gPSBbanNDb250ZXh0IHZpcnR1YWxNYWNoaW5lXTsKKyAgICBFWFBF Q1RfVFJVRShbanNWTSBpc1dlYlRocmVhZEF3YXJlXSk7CisKKyAgICAvLyBTdGFydCB0byBydW4g V2ViR0wgb24gd2ViIHRocmVhZC4KKyAgICBbdWlXZWJWaWV3IHN0cmluZ0J5RXZhbHVhdGluZ0ph dmFTY3JpcHRGcm9tU3RyaW5nOkAicnVuVGVzdEFzeW5jKCk7Il07CisgICAgRVhQRUNUX0ZBTFNF KGRpZEZpbmlzaFRlc3QpOyAvLyBUaGUgcGF0dGVybiBydW5zIHRoZSB0ZXN0IG9uIHdlYiB0aHJl YWQuCisKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdGVzdEl0ZXJhdGlvbnM7IGkrKykg eworICAgICAgICAvLyBSdW4gV2ViR0wgb24gY2xpZW50IG1haW4gdGhyZWFkLgorICAgICAgICBO U1N0cmluZyogcmVzdWx0ID0gW1tqc0NvbnRleHQgZXZhbHVhdGVTY3JpcHQ6IEAicnVuVGVzdCgp OyJdIHRvU3RyaW5nXTsKKyAgICAgICAgRVhQRUNUX1RSVUUoW0AiZGlkRmluaXNoVGVzdCIgaXNF cXVhbFRvU3RyaW5nOiByZXN1bHRdKTsKKworICAgICAgICAvLyBDbGllbnQgY2xvYmJlcnMgRUFH TENvbnRleHQgYmV0d2VlbiBjYWxscyB0aGF0IHJ1biBXZWJHTCBvbiBtYWluIHRocmVhZC4KKyAg ICAgICAgU2V0Q29udGV4dENHTCBjbGllbnRDb250ZXh0Q0dMMjsKKyAgICAgICAgU2V0Q29udGV4 dEVBR0wgY2xpZW50Q29udGV4dEVBR0wyOworICAgICAgICBVTlVTRURfVkFSSUFCTEUoY2xpZW50 Q29udGV4dENHTDIpOworICAgICAgICBVTlVTRURfVkFSSUFCTEUoY2xpZW50Q29udGV4dEVBR0wy KTsKKworICAgICAgICByZXN1bHQgPSBbW2pzQ29udGV4dCBldmFsdWF0ZVNjcmlwdDogQCJydW5U ZXN0KCk7Il0gdG9TdHJpbmddOworICAgICAgICBFWFBFQ1RfVFJVRShbQCJkaWRGaW5pc2hUZXN0 IiBpc0VxdWFsVG9TdHJpbmc6IHJlc3VsdF0pOworCisgICAgICAgIC8vIFdhaXQgdW50aWwgdGhl IHByZXZpb3VzIFdlYkdMIHRlc3QgcnVuIGhhcyBmaW5pc2hlZC4KKyAgICAgICAgVXRpbDo6cnVu KCZkaWRGaW5pc2hUZXN0KTsKKyAgICAgICAgZGlkRmluaXNoVGVzdCA9IGZhbHNlOworICAgICAg ICAvLyBTdGFydCB0byBydW4gV2ViR0wgb24gd2ViIHRocmVhZC4KKyAgICAgICAgW3VpV2ViVmll dyBzdHJpbmdCeUV2YWx1YXRpbmdKYXZhU2NyaXB0RnJvbVN0cmluZzpAInJ1blRlc3RBc3luYygp OyJdOworICAgICAgICBFWFBFQ1RfRkFMU0UoZGlkRmluaXNoVGVzdCk7CisgICAgfQorCisgICAg VXRpbDo6cnVuKCZkaWRGaW5pc2hUZXN0KTsKK30KKworfQorCisjZW5kaWYK